1 // license:BSD-3-Clause
2 // copyright-holders:Ville Linde
3 // stack is LIFO and is 8 levels deep, there is no stackpointer on the real chip
PUSH_STACK(uint16_t pc)4 void tms32051_device::PUSH_STACK(uint16_t pc)
5 {
6 m_pcstack_ptr = (m_pcstack_ptr - 1) & 7;
7 m_pcstack[m_pcstack_ptr] = pc;
8 }
9
POP_STACK()10 uint16_t tms32051_device::POP_STACK()
11 {
12 uint16_t pc = m_pcstack[m_pcstack_ptr];
13 m_pcstack_ptr = (m_pcstack_ptr + 1) & 7;
14 m_pcstack[(m_pcstack_ptr + 7) & 7] = m_pcstack[(m_pcstack_ptr + 6) & 7];
15 return pc;
16 }
17
SUB(uint32_t a,uint32_t b,bool shift16)18 int32_t tms32051_device::SUB(uint32_t a, uint32_t b, bool shift16)
19 {
20 uint32_t res = a - b;
21
22 if (shift16)
23 {
24 // C is cleared if borrow was generated, otherwise unaffected
25 if (a < res) m_st1.c = 0;
26 }
27 else
28 {
29 // C is cleared if borrow was generated
30 m_st1.c = (a < res) ? 0 : 1;
31 }
32
33 // check overflow
34 if ((a ^ b) & (a ^ res) & 0x80000000)
35 {
36 if (m_st0.ovm) // overflow saturation mode
37 {
38 res = ((int32_t)(res) < 0) ? 0x7fffffff : 0x80000000;
39 }
40
41 // set OV, this is a sticky flag
42 m_st0.ov = 1;
43 }
44
45 return (int32_t)(res);
46 }
47
ADD(uint32_t a,uint32_t b,bool shift16)48 int32_t tms32051_device::ADD(uint32_t a, uint32_t b, bool shift16)
49 {
50 uint32_t res = a + b;
51
52 if (shift16)
53 {
54 // C is set if carry was generated, otherwise unaffected
55 if (a > res) m_st1.c = 1;
56 }
57 else
58 {
59 // C is set if carry was generated
60 m_st1.c = (a > res) ? 1 : 0;
61 }
62
63 // check overflow
64 if ((a ^ res) & (b ^ res) & 0x80000000)
65 {
66 if (m_st0.ovm) // overflow saturation mode
67 {
68 res = ((int32_t)(res) < 0) ? 0x7fffffff : 0x80000000;
69 }
70
71 // set OV, this is a sticky flag
72 m_st0.ov = 1;
73 }
74
75 return (int32_t)(res);
76 }
77
78
UPDATE_AR(int ar,int step)79 void tms32051_device::UPDATE_AR(int ar, int step)
80 {
81 int cenb1 = (m_cbcr >> 3) & 0x1;
82 int car1 = m_cbcr & 0x7;
83 int cenb2 = (m_cbcr >> 7) & 0x1;
84 int car2 = (m_cbcr >> 4) & 0x7;
85
86 if (cenb1 && ar == car1)
87 {
88 // update circular buffer 1, note that it only checks ==
89 if (m_ar[ar] == m_cber1)
90 {
91 m_ar[ar] = m_cbsr1;
92 }
93 else
94 {
95 m_ar[ar] += step;
96 }
97 }
98 else if (cenb2 && ar == car2)
99 {
100 // update circular buffer 2, note that it only checks ==
101 if (m_ar[ar] == m_cber2)
102 {
103 m_ar[ar] = m_cbsr2;
104 }
105 else
106 {
107 m_ar[ar] += step;
108 }
109 }
110 else
111 {
112 m_ar[ar] += step;
113 }
114 }
115
UPDATE_ARP(int nar)116 void tms32051_device::UPDATE_ARP(int nar)
117 {
118 m_st1.arb = m_st0.arp;
119 m_st0.arp = nar;
120 }
121
GET_ADDRESS()122 uint16_t tms32051_device::GET_ADDRESS()
123 {
124 if (m_op & 0x80) // Indirect Addressing
125 {
126 uint16_t ea;
127 int arp = m_st0.arp;
128 int nar = m_op & 0x7;
129
130 ea = m_ar[arp];
131
132 switch ((m_op >> 3) & 0xf)
133 {
134 case 0x0: // * (no operation)
135 {
136 break;
137 }
138 case 0x1: // *, ARn (NAR -> ARP)
139 {
140 UPDATE_ARP(nar);
141 break;
142 }
143 case 0x2: // *- ((CurrentAR)-1 -> CurrentAR)
144 {
145 UPDATE_AR(arp, -1);
146 break;
147 }
148 case 0x3: // *-, ARn ((CurrentAR)-1 -> CurrentAR, NAR -> ARP)
149 {
150 UPDATE_AR(arp, -1);
151 UPDATE_ARP(nar);
152 break;
153 }
154 case 0x4: // *+ ((CurrentAR)+1 -> CurrentAR)
155 {
156 UPDATE_AR(arp, 1);
157 break;
158 }
159 case 0x5: // *+, ARn ((CurrentAR)+1 -> CurrentAR, NAR -> ARP)
160 {
161 UPDATE_AR(arp, 1);
162 UPDATE_ARP(nar);
163 break;
164 }
165 case 0xa: // *0- ((CurrentAR) - INDX)
166 {
167 UPDATE_AR(arp, -m_indx);
168 break;
169 }
170 case 0xb: // *0-, ARn ((CurrentAR) - INDX -> CurrentAR, NAR -> ARP)
171 {
172 UPDATE_AR(arp, -m_indx);
173 UPDATE_ARP(nar);
174 break;
175 }
176 case 0xc: // *0+ ((CurrentAR) + INDX -> CurrentAR)
177 {
178 UPDATE_AR(arp, m_indx);
179 break;
180 }
181 case 0xd: // *0+, ARn ((CurrentAR) + INDX -> CurrentAR, NAR -> ARP)
182 {
183 UPDATE_AR(arp, m_indx);
184 UPDATE_ARP(nar);
185 break;
186 }
187
188 default: fatalerror("32051: GET_ADDRESS: unimplemented indirect addressing mode %d at %04X (%04X)\n", (m_op >> 3) & 0xf, m_pc, m_op);
189 }
190
191 return ea;
192 }
193 else // Direct Addressing
194 {
195 return m_st0.dp | (m_op & 0x7f);
196 }
197 }
198
GET_ZLVC_CONDITION(int zlvc,int zlvc_mask)199 bool tms32051_device::GET_ZLVC_CONDITION(int zlvc, int zlvc_mask)
200 {
201 if (zlvc_mask & 0x2) // OV-bit
202 {
203 if ((zlvc & 0x2) && m_st0.ov == 0) // OV
204 return false;
205 if (((zlvc & 0x2) == 0) && m_st0.ov != 0) // NOV
206 return false;
207 }
208 if (zlvc_mask & 0x1) // C-bit
209 {
210 if ((zlvc & 0x1) && m_st1.c == 0) // C
211 return false;
212 if (((zlvc & 0x1) == 0) && m_st1.c != 0) // NC
213 return false;
214 }
215
216 switch ((zlvc_mask & 0xc) | ((zlvc >> 2) & 0x3))
217 {
218 case 0x00: break; // MZ=0, ML=0, Z=0, L=0
219 case 0x01: break; // MZ=0, ML=0, Z=0, L=1
220 case 0x02: break; // MZ=0, ML=0, Z=1, L=0
221 case 0x03: break; // MZ=0, ML=0, Z=1, L=1
222 case 0x04: if ((int32_t)(m_acc) <= 0) return false; break; // MZ=0, ML=1, Z=0, L=0 (GT)
223 case 0x05: if ((int32_t)(m_acc) >= 0) return false; break; // MZ=0, ML=1, Z=0, L=1 (LT)
224 case 0x06: if ((int32_t)(m_acc) <= 0) return false; break; // MZ=0, ML=1, Z=1, L=0 (GT)
225 case 0x07: if ((int32_t)(m_acc) >= 0) return false; break; // MZ=0, ML=1, Z=1, L=1 (LT)
226 case 0x08: if ((int32_t)(m_acc) == 0) return false; break; // MZ=1, ML=0, Z=0, L=0 (NEQ)
227 case 0x09: if ((int32_t)(m_acc) == 0) return false; break; // MZ=1, ML=0, Z=0, L=1 (NEQ)
228 case 0x0a: if ((int32_t)(m_acc) != 0) return false; break; // MZ=1, ML=0, Z=1, L=0 (EQ)
229 case 0x0b: if ((int32_t)(m_acc) != 0) return false; break; // MZ=1, ML=0, Z=1, L=1 (EQ)
230 case 0x0c: if ((int32_t)(m_acc) <= 0) return false; break; // MZ=1, ML=1, Z=0, L=0 (GT)
231 case 0x0d: if ((int32_t)(m_acc) >= 0) return false; break; // MZ=1, ML=1, Z=0, L=1 (LT)
232 case 0x0e: if ((int32_t)(m_acc) < 0) return false; break; // MZ=1, ML=1, Z=1, L=0 (GEQ)
233 case 0x0f: if ((int32_t)(m_acc) > 0) return false; break; // MZ=1, ML=1, Z=1, L=1 (LEQ)
234 }
235 return true;
236 }
237
GET_TP_CONDITION(int tp)238 bool tms32051_device::GET_TP_CONDITION(int tp)
239 {
240 switch (tp)
241 {
242 case 0: // BIO pin low
243 // TODO
244 return false;
245
246 case 1: // TC == 1
247 return m_st1.tc != 0;
248
249 case 2: // TC == 0
250 return m_st1.tc == 0;
251
252 case 3:
253 return true;
254 }
255 return true;
256 }
257
PREG_PSCALER(int32_t preg)258 int32_t tms32051_device::PREG_PSCALER(int32_t preg)
259 {
260 switch (m_st1.pm & 3)
261 {
262 case 0: // No shift
263 {
264 return preg;
265 }
266 case 1: // Left-shifted 1 bit, LSB zero-filled
267 {
268 return preg << 1;
269 }
270 case 2: // Left-shifted 4 bits, 4 LSBs zero-filled
271 {
272 return preg << 4;
273 }
274 case 3: // Right-shifted 6 bits, sign-extended, 6 LSBs lost
275 {
276 return (int32_t)(preg >> 6);
277 }
278 }
279 return 0;
280 }
281
282
283
op_invalid()284 void tms32051_device::op_invalid()
285 {
286 fatalerror("32051: invalid op at %08X\n", m_pc-1);
287 }
288
289 /*****************************************************************************/
290
op_abs()291 void tms32051_device::op_abs()
292 {
293 fatalerror("32051: unimplemented op abs at %08X\n", m_pc-1);
294 }
295
op_adcb()296 void tms32051_device::op_adcb()
297 {
298 fatalerror("32051: unimplemented op adcb at %08X\n", m_pc-1);
299 }
300
op_add_mem()301 void tms32051_device::op_add_mem()
302 {
303 int32_t d;
304 uint16_t ea = GET_ADDRESS();
305 uint16_t data = DM_READ16(ea);
306 int shift = (m_op >> 8) & 0xf;
307
308 if (m_st1.sxm)
309 {
310 d = (int32_t)(int16_t)(data) << shift;
311 }
312 else
313 {
314 d = (uint32_t)(uint16_t)(data) << shift;
315 }
316
317 m_acc = ADD(m_acc, d, false);
318
319 CYCLES(1);
320 }
321
op_add_simm()322 void tms32051_device::op_add_simm()
323 {
324 uint16_t imm = m_op & 0xff;
325
326 m_acc = ADD(m_acc, imm, false);
327
328 CYCLES(1);
329 }
330
op_add_limm()331 void tms32051_device::op_add_limm()
332 {
333 int32_t d;
334 uint16_t imm = ROPCODE();
335 int shift = m_op & 0xf;
336
337 if (m_st1.sxm)
338 {
339 d = (int32_t)(int16_t)(imm) << shift;
340 }
341 else
342 {
343 d = (uint32_t)(uint16_t)(imm) << shift;
344 }
345
346 m_acc = ADD(m_acc, d, false);
347
348 CYCLES(2);
349 }
350
op_add_s16_mem()351 void tms32051_device::op_add_s16_mem()
352 {
353 uint16_t ea = GET_ADDRESS();
354 uint32_t data = DM_READ16(ea) << 16;
355
356 m_acc = ADD(m_acc, data, true);
357
358 CYCLES(1);
359 }
360
op_addb()361 void tms32051_device::op_addb()
362 {
363 m_acc = ADD(m_acc, m_accb, false);
364
365 CYCLES(1);
366 }
367
op_addc()368 void tms32051_device::op_addc()
369 {
370 fatalerror("32051: unimplemented op addc at %08X\n", m_pc-1);
371 }
372
op_adds()373 void tms32051_device::op_adds()
374 {
375 fatalerror("32051: unimplemented op adds at %08X\n", m_pc-1);
376 }
377
op_addt()378 void tms32051_device::op_addt()
379 {
380 fatalerror("32051: unimplemented op addt at %08X\n", m_pc-1);
381 }
382
op_and_mem()383 void tms32051_device::op_and_mem()
384 {
385 uint16_t ea = GET_ADDRESS();
386 uint16_t data = DM_READ16(ea);
387
388 m_acc &= (uint32_t)(data);
389
390 CYCLES(1);
391 }
392
op_and_limm()393 void tms32051_device::op_and_limm()
394 {
395 uint32_t imm = ROPCODE();
396 int shift = m_op & 0xf;
397
398 m_acc &= imm << shift;
399
400 CYCLES(2);
401 }
402
op_and_s16_limm()403 void tms32051_device::op_and_s16_limm()
404 {
405 fatalerror("32051: unimplemented op and s16 limm at %08X\n", m_pc-1);
406 }
407
op_andb()408 void tms32051_device::op_andb()
409 {
410 fatalerror("32051: unimplemented op andb at %08X\n", m_pc-1);
411 }
412
op_bsar()413 void tms32051_device::op_bsar()
414 {
415 int shift = (m_op & 0xf) + 1;
416
417 if (m_st1.sxm)
418 {
419 m_acc = (int32_t)(m_acc) >> shift;
420 }
421 else
422 {
423 m_acc = (uint32_t)(m_acc) >> shift;
424 }
425
426 CYCLES(1);
427 }
428
op_cmpl()429 void tms32051_device::op_cmpl()
430 {
431 m_acc = ~(uint32_t)(m_acc);
432
433 CYCLES(1);
434 }
435
op_crgt()436 void tms32051_device::op_crgt()
437 {
438 if (m_acc >= m_accb)
439 {
440 m_accb = m_acc;
441 m_st1.c = 1;
442 }
443 else
444 {
445 m_acc = m_accb;
446 m_st1.c = 0;
447 }
448
449 CYCLES(1);
450 }
451
op_crlt()452 void tms32051_device::op_crlt()
453 {
454 if (m_acc >= m_accb)
455 {
456 m_acc = m_accb;
457 m_st1.c = 0;
458 }
459 else
460 {
461 m_accb = m_acc;
462 m_st1.c = 1;
463 }
464
465 CYCLES(1);
466 }
467
op_exar()468 void tms32051_device::op_exar()
469 {
470 int32_t tmp = m_acc;
471 m_acc = m_accb;
472 m_accb = tmp;
473
474 CYCLES(1);
475 }
476
op_lacb()477 void tms32051_device::op_lacb()
478 {
479 m_acc = m_accb;
480
481 CYCLES(1);
482 }
483
op_lacc_mem()484 void tms32051_device::op_lacc_mem()
485 {
486 int shift = (m_op >> 8) & 0xf;
487 uint16_t ea = GET_ADDRESS();
488 uint16_t data = DM_READ16(ea);
489
490 if (m_st1.sxm)
491 {
492 m_acc = (int32_t)(int16_t)(data) << shift;
493 }
494 else
495 {
496 m_acc = (uint32_t)(uint16_t)(data) << shift;
497 }
498
499 CYCLES(1);
500 }
501
op_lacc_limm()502 void tms32051_device::op_lacc_limm()
503 {
504 uint16_t imm = ROPCODE();
505 int shift = m_op & 0xf;
506
507 if (m_st1.sxm)
508 {
509 m_acc = (int32_t)(int16_t)(imm) << shift;
510 }
511 else
512 {
513 m_acc = (uint32_t)(uint16_t)(imm) << shift;
514 }
515
516 CYCLES(1);
517 }
518
op_lacc_s16_mem()519 void tms32051_device::op_lacc_s16_mem()
520 {
521 uint16_t ea = GET_ADDRESS();
522 m_acc = DM_READ16(ea) << 16;
523
524 CYCLES(1);
525 }
526
op_lacl_simm()527 void tms32051_device::op_lacl_simm()
528 {
529 m_acc = m_op & 0xff;
530
531 CYCLES(1);
532 }
533
op_lacl_mem()534 void tms32051_device::op_lacl_mem()
535 {
536 uint16_t ea = GET_ADDRESS();
537 m_acc = DM_READ16(ea) & 0xffff;
538
539 CYCLES(1);
540 }
541
op_lact()542 void tms32051_device::op_lact()
543 {
544 fatalerror("32051: unimplemented op lact at %08X\n", m_pc-1);
545 }
546
op_lamm()547 void tms32051_device::op_lamm()
548 {
549 uint16_t ea = GET_ADDRESS() & 0x7f;
550 m_acc = DM_READ16(ea) & 0xffff;
551
552 CYCLES(1);
553 }
554
op_neg()555 void tms32051_device::op_neg()
556 {
557 if ((uint32_t)(m_acc) == 0x80000000)
558 {
559 m_st0.ov = 1;
560 m_st1.c = 0;
561 m_acc = (m_st0.ovm) ? 0x7fffffff : 0x80000000;
562 }
563 else
564 {
565 m_acc = 0 - (uint32_t)(m_acc);
566 m_st1.c = (m_acc == 0) ? 1 : 0;
567 }
568
569 CYCLES(1);
570 }
571
op_norm()572 void tms32051_device::op_norm()
573 {
574 fatalerror("32051: unimplemented op norm at %08X\n", m_pc-1);
575 }
576
op_or_mem()577 void tms32051_device::op_or_mem()
578 {
579 uint16_t ea = GET_ADDRESS();
580 uint16_t data = DM_READ16(ea);
581
582 m_acc |= (uint32_t)(data);
583
584 CYCLES(1);
585 }
586
op_or_limm()587 void tms32051_device::op_or_limm()
588 {
589 uint32_t imm = ROPCODE();
590 int shift = m_op & 0xf;
591
592 m_acc |= imm << shift;
593
594 CYCLES(1);
595 }
596
op_or_s16_limm()597 void tms32051_device::op_or_s16_limm()
598 {
599 fatalerror("32051: unimplemented op or s16 limm at %08X\n", m_pc-1);
600 }
601
op_orb()602 void tms32051_device::op_orb()
603 {
604 m_acc |= m_accb;
605
606 CYCLES(1);
607 }
608
op_rol()609 void tms32051_device::op_rol()
610 {
611 fatalerror("32051: unimplemented op rol at %08X\n", m_pc-1);
612 }
613
op_rolb()614 void tms32051_device::op_rolb()
615 {
616 uint32_t acc = m_acc;
617 uint32_t accb = m_accb;
618 uint32_t c = m_st1.c & 1;
619
620 m_acc = (acc << 1) | ((accb >> 31) & 1);
621 m_accb = (accb << 1) | c;
622 m_st1.c = (acc >> 31) & 1;
623
624 CYCLES(1);
625 }
626
op_ror()627 void tms32051_device::op_ror()
628 {
629 fatalerror("32051: unimplemented op ror at %08X\n", m_pc-1);
630 }
631
op_rorb()632 void tms32051_device::op_rorb()
633 {
634 fatalerror("32051: unimplemented op rorb at %08X\n", m_pc-1);
635 }
636
op_sacb()637 void tms32051_device::op_sacb()
638 {
639 m_accb = m_acc;
640
641 CYCLES(1);
642 }
643
op_sach()644 void tms32051_device::op_sach()
645 {
646 uint16_t ea = GET_ADDRESS();
647 int shift = (m_op >> 8) & 0x7;
648
649 DM_WRITE16(ea, (uint16_t)((m_acc << shift) >> 16));
650 CYCLES(1);
651 }
652
op_sacl()653 void tms32051_device::op_sacl()
654 {
655 uint16_t ea = GET_ADDRESS();
656 int shift = (m_op >> 8) & 0x7;
657
658 DM_WRITE16(ea, (uint16_t)(m_acc << shift));
659 CYCLES(1);
660 }
661
op_samm()662 void tms32051_device::op_samm()
663 {
664 uint16_t ea = GET_ADDRESS();
665 ea &= 0x7f;
666
667 DM_WRITE16(ea, (uint16_t)(m_acc));
668 CYCLES(1);
669 }
670
op_sath()671 void tms32051_device::op_sath()
672 {
673 fatalerror("32051: unimplemented op sath at %08X\n", m_pc-1);
674 }
675
op_satl()676 void tms32051_device::op_satl()
677 {
678 int count = m_treg1 & 0xf;
679 if (m_st1.sxm)
680 {
681 m_acc = (int32_t)(m_acc) >> count;
682 }
683 else
684 {
685 m_acc = (uint32_t)(m_acc) >> count;
686 }
687
688 CYCLES(1);
689 }
690
op_sbb()691 void tms32051_device::op_sbb()
692 {
693 uint32_t res = m_acc - m_accb;
694
695 // C is cleared if borrow was generated
696 m_st1.c = ((uint32_t)(m_acc) < res) ? 0 : 1;
697
698 m_acc = res;
699
700 CYCLES(1);
701 }
702
op_sbbb()703 void tms32051_device::op_sbbb()
704 {
705 fatalerror("32051: unimplemented op sbbb at %08X\n", m_pc-1);
706 }
707
op_sfl()708 void tms32051_device::op_sfl()
709 {
710 m_st1.c = (m_acc >> 31) & 1;
711 m_acc = m_acc << 1;
712
713 CYCLES(1);
714 }
715
op_sflb()716 void tms32051_device::op_sflb()
717 {
718 uint32_t acc = m_acc;
719 uint32_t accb = m_accb;
720
721 m_acc = (acc << 1) | ((accb >> 31) & 1);
722 m_accb = (accb << 1);
723 m_st1.c = (acc >> 31) & 1;
724
725 CYCLES(1);
726 }
727
op_sfr()728 void tms32051_device::op_sfr()
729 {
730 m_st1.c = m_acc & 1;
731
732 if (m_st1.sxm)
733 {
734 m_acc = (int32_t)(m_acc) >> 1;
735 }
736 else
737 {
738 m_acc = (uint32_t)(m_acc) >> 1;
739 }
740
741 CYCLES(1);
742 }
743
op_sfrb()744 void tms32051_device::op_sfrb()
745 {
746 fatalerror("32051: unimplemented op sfrb at %08X\n", m_pc-1);
747 }
748
op_sub_mem()749 void tms32051_device::op_sub_mem()
750 {
751 int32_t d;
752 uint16_t ea = GET_ADDRESS();
753 uint16_t data = DM_READ16(ea);
754 int shift = (m_op >> 8) & 0xf;
755
756 if (m_st1.sxm)
757 {
758 d = (int32_t)(int16_t)(data) << shift;
759 }
760 else
761 {
762 d = (uint32_t)(uint16_t)(data) << shift;
763 }
764
765 m_acc = SUB(m_acc, d, false);
766
767 CYCLES(1);
768 }
769
op_sub_s16_mem()770 void tms32051_device::op_sub_s16_mem()
771 {
772 fatalerror("32051: unimplemented op sub s16 mem at %08X\n", m_pc-1);
773 }
774
op_sub_simm()775 void tms32051_device::op_sub_simm()
776 {
777 uint16_t imm = m_op & 0xff;
778
779 m_acc = SUB(m_acc, imm, false);
780
781 CYCLES(1);
782 }
783
op_sub_limm()784 void tms32051_device::op_sub_limm()
785 {
786 int32_t d;
787 uint16_t imm = ROPCODE();
788 int shift = m_op & 0xf;
789
790 if (m_st1.sxm)
791 {
792 d = (int32_t)(int16_t)(imm) << shift;
793 }
794 else
795 {
796 d = (uint32_t)(uint16_t)(imm) << shift;
797 }
798
799 m_acc = SUB(m_acc, d, false);
800
801 CYCLES(2);
802 }
803
op_subb()804 void tms32051_device::op_subb()
805 {
806 fatalerror("32051: unimplemented op subb at %08X\n", m_pc-1);
807 }
808
op_subc()809 void tms32051_device::op_subc()
810 {
811 fatalerror("32051: unimplemented op subc at %08X\n", m_pc-1);
812 }
813
op_subs()814 void tms32051_device::op_subs()
815 {
816 fatalerror("32051: unimplemented op subs at %08X\n", m_pc-1);
817 }
818
op_subt()819 void tms32051_device::op_subt()
820 {
821 fatalerror("32051: unimplemented op subt at %08X\n", m_pc-1);
822 }
823
op_xor_mem()824 void tms32051_device::op_xor_mem()
825 {
826 uint16_t ea = GET_ADDRESS();
827 uint16_t data = DM_READ16(ea);
828
829 m_acc ^= (uint32_t)(data);
830
831 CYCLES(1);
832 }
833
op_xor_limm()834 void tms32051_device::op_xor_limm()
835 {
836 uint32_t imm = ROPCODE();
837 int shift = m_op & 0xf;
838
839 m_acc ^= imm << shift;
840
841 CYCLES(1);
842 }
843
op_xor_s16_limm()844 void tms32051_device::op_xor_s16_limm()
845 {
846 fatalerror("32051: unimplemented op xor s16 limm at %08X\n", m_pc-1);
847 }
848
op_xorb()849 void tms32051_device::op_xorb()
850 {
851 fatalerror("32051: unimplemented op xorb at %08X\n", m_pc-1);
852 }
853
op_zalr()854 void tms32051_device::op_zalr()
855 {
856 fatalerror("32051: unimplemented op zalr at %08X\n", m_pc-1);
857 }
858
op_zap()859 void tms32051_device::op_zap()
860 {
861 m_acc = 0;
862 m_preg = 0;
863
864 CYCLES(1);
865 }
866
867 /*****************************************************************************/
868
op_adrk()869 void tms32051_device::op_adrk()
870 {
871 uint16_t imm = m_op & 0xff;
872 UPDATE_AR(m_st0.arp, imm);
873
874 CYCLES(1);
875 }
876
op_cmpr()877 void tms32051_device::op_cmpr()
878 {
879 m_st1.tc = 0;
880
881 switch (m_op & 0x3)
882 {
883 case 0: // (CurrentAR) == ARCR
884 {
885 if (m_ar[m_st0.arp] == m_arcr)
886 {
887 m_st1.tc = 1;
888 }
889 break;
890 }
891 case 1: // (CurrentAR) < ARCR
892 {
893 if (m_ar[m_st0.arp] < m_arcr)
894 {
895 m_st1.tc = 1;
896 }
897 break;
898 }
899 case 2: // (CurrentAR) > ARCR
900 {
901 if (m_ar[m_st0.arp] > m_arcr)
902 {
903 m_st1.tc = 1;
904 }
905 break;
906 }
907 case 3: // (CurrentAR) != ARCR
908 {
909 if (m_ar[m_st0.arp] != m_arcr)
910 {
911 m_st1.tc = 1;
912 }
913 break;
914 }
915 }
916
917 CYCLES(1);
918 }
919
op_lar_mem()920 void tms32051_device::op_lar_mem()
921 {
922 int arx = (m_op >> 8) & 0x7;
923 uint16_t ea = GET_ADDRESS();
924 uint16_t data = DM_READ16(ea);
925
926 m_ar[arx] = data;
927
928 CYCLES(2);
929 }
930
op_lar_simm()931 void tms32051_device::op_lar_simm()
932 {
933 int arx = (m_op >> 8) & 0x7;
934 m_ar[arx] = m_op & 0xff;
935
936 CYCLES(2);
937 }
938
op_lar_limm()939 void tms32051_device::op_lar_limm()
940 {
941 int arx = m_op & 0x7;
942 uint16_t imm = ROPCODE();
943 m_ar[arx] = imm;
944
945 CYCLES(2);
946 }
947
op_ldp_mem()948 void tms32051_device::op_ldp_mem()
949 {
950 fatalerror("32051: unimplemented op ldp mem at %08X\n", m_pc-1);
951 }
952
op_ldp_imm()953 void tms32051_device::op_ldp_imm()
954 {
955 m_st0.dp = (m_op & 0x1ff) << 7;
956 CYCLES(2);
957 }
958
op_mar()959 void tms32051_device::op_mar()
960 {
961 // direct addressing is NOP
962 if (m_op & 0x80)
963 {
964 GET_ADDRESS();
965 }
966 CYCLES(1);
967 }
968
op_sar()969 void tms32051_device::op_sar()
970 {
971 int arx = (m_op >> 8) & 0x7;
972 uint16_t ar = m_ar[arx];
973 uint16_t ea = GET_ADDRESS();
974 DM_WRITE16(ea, ar);
975
976 CYCLES(1);
977 }
978
op_sbrk()979 void tms32051_device::op_sbrk()
980 {
981 uint16_t imm = m_op & 0xff;
982 UPDATE_AR(m_st0.arp, -imm);
983
984 CYCLES(1);
985 }
986
987 /*****************************************************************************/
988
op_b()989 void tms32051_device::op_b()
990 {
991 uint16_t pma = ROPCODE();
992 GET_ADDRESS(); // update AR/ARP
993
994 CHANGE_PC(pma);
995 CYCLES(4);
996 }
997
op_bacc()998 void tms32051_device::op_bacc()
999 {
1000 CHANGE_PC((uint16_t)(m_acc));
1001
1002 CYCLES(4);
1003 }
1004
op_baccd()1005 void tms32051_device::op_baccd()
1006 {
1007 uint16_t pc = (uint16_t)(m_acc);
1008
1009 delay_slot(m_pc);
1010 CHANGE_PC(pc);
1011
1012 CYCLES(2);
1013 }
1014
op_banz()1015 void tms32051_device::op_banz()
1016 {
1017 uint16_t pma = ROPCODE();
1018
1019 if (m_ar[m_st0.arp] != 0)
1020 {
1021 CHANGE_PC(pma);
1022 CYCLES(4);
1023 }
1024 else
1025 {
1026 CYCLES(2);
1027 }
1028
1029 GET_ADDRESS(); // modify AR/ARP
1030 }
1031
op_banzd()1032 void tms32051_device::op_banzd()
1033 {
1034 fatalerror("32051: unimplemented op banzd at %08X\n", m_pc-1);
1035 }
1036
op_bcnd()1037 void tms32051_device::op_bcnd()
1038 {
1039 uint16_t pma = ROPCODE();
1040
1041 if (GET_ZLVC_CONDITION((m_op >> 4) & 0xf, m_op & 0xf) && GET_TP_CONDITION((m_op >> 8) & 0x3))
1042 {
1043 CHANGE_PC(pma);
1044 CYCLES(4);
1045
1046 // clear overflow
1047 if (m_op & 0x2)
1048 m_st0.ov = 0;
1049 }
1050 else
1051 {
1052 CYCLES(2);
1053 }
1054 }
1055
op_bcndd()1056 void tms32051_device::op_bcndd()
1057 {
1058 uint16_t pma = ROPCODE();
1059
1060 if (GET_ZLVC_CONDITION((m_op >> 4) & 0xf, m_op & 0xf) && GET_TP_CONDITION((m_op >> 8) & 0x3))
1061 {
1062 // clear overflow
1063 if (m_op & 0x2)
1064 m_st0.ov = 0;
1065
1066 delay_slot(m_pc);
1067 CHANGE_PC(pma);
1068 CYCLES(4);
1069 }
1070 else
1071 {
1072 CYCLES(2);
1073 }
1074 }
1075
op_bd()1076 void tms32051_device::op_bd()
1077 {
1078 uint16_t pma = ROPCODE();
1079 GET_ADDRESS(); // update AR/ARP
1080
1081 delay_slot(m_pc);
1082 CHANGE_PC(pma);
1083 CYCLES(2);
1084 }
1085
op_cala()1086 void tms32051_device::op_cala()
1087 {
1088 PUSH_STACK(m_pc);
1089
1090 CHANGE_PC(m_acc);
1091
1092 CYCLES(4);
1093 }
1094
op_calad()1095 void tms32051_device::op_calad()
1096 {
1097 uint16_t pma = m_acc;
1098 PUSH_STACK(m_pc+2);
1099
1100 delay_slot(m_pc);
1101 CHANGE_PC(pma);
1102
1103 CYCLES(4);
1104 }
1105
op_call()1106 void tms32051_device::op_call()
1107 {
1108 uint16_t pma = ROPCODE();
1109 GET_ADDRESS(); // update AR/ARP
1110 PUSH_STACK(m_pc);
1111
1112 CHANGE_PC(pma);
1113
1114 CYCLES(4);
1115 }
1116
op_calld()1117 void tms32051_device::op_calld()
1118 {
1119 uint16_t pma = ROPCODE();
1120 GET_ADDRESS(); // update AR/ARP
1121 PUSH_STACK(m_pc+2);
1122
1123 delay_slot(m_pc);
1124 CHANGE_PC(pma);
1125
1126 CYCLES(4);
1127 }
1128
op_cc()1129 void tms32051_device::op_cc()
1130 {
1131 uint16_t pma = ROPCODE();
1132
1133 if (GET_ZLVC_CONDITION((m_op >> 4) & 0xf, m_op & 0xf) && GET_TP_CONDITION((m_op >> 8) & 0x3))
1134 {
1135 PUSH_STACK(m_pc);
1136
1137 CHANGE_PC(pma);
1138 CYCLES(4);
1139
1140 // clear overflow
1141 if (m_op & 0x2)
1142 m_st0.ov = 0;
1143 }
1144 else
1145 {
1146 CYCLES(2);
1147 }
1148 }
1149
op_ccd()1150 void tms32051_device::op_ccd()
1151 {
1152 uint16_t pma = ROPCODE();
1153
1154 if (GET_ZLVC_CONDITION((m_op >> 4) & 0xf, m_op & 0xf) && GET_TP_CONDITION((m_op >> 8) & 0x3))
1155 {
1156 PUSH_STACK(m_pc+2);
1157
1158 // clear overflow
1159 if (m_op & 0x2)
1160 m_st0.ov = 0;
1161
1162 delay_slot(m_pc);
1163 CHANGE_PC(pma);
1164 }
1165
1166 CYCLES(2);
1167 }
1168
op_intr()1169 void tms32051_device::op_intr()
1170 {
1171 fatalerror("32051: unimplemented op intr at %08X\n", m_pc-1);
1172 }
1173
op_nmi()1174 void tms32051_device::op_nmi()
1175 {
1176 fatalerror("32051: unimplemented op nmi at %08X\n", m_pc-1);
1177 }
1178
op_retc()1179 void tms32051_device::op_retc()
1180 {
1181 if (GET_ZLVC_CONDITION((m_op >> 4) & 0xf, m_op & 0xf) && GET_TP_CONDITION((m_op >> 8) & 0x3))
1182 {
1183 uint16_t pc = POP_STACK();
1184 CHANGE_PC(pc);
1185 CYCLES(4);
1186 }
1187 else
1188 {
1189 CYCLES(2);
1190 }
1191 }
1192
op_retcd()1193 void tms32051_device::op_retcd()
1194 {
1195 if (GET_ZLVC_CONDITION((m_op >> 4) & 0xf, m_op & 0xf) && GET_TP_CONDITION((m_op >> 8) & 0x3))
1196 {
1197 uint16_t pc = POP_STACK();
1198 delay_slot(m_pc);
1199 CHANGE_PC(pc);
1200 CYCLES(4);
1201 }
1202 else
1203 {
1204 CYCLES(2);
1205 }
1206 }
1207
op_rete()1208 void tms32051_device::op_rete()
1209 {
1210 uint16_t pc = POP_STACK();
1211 CHANGE_PC(pc);
1212
1213 restore_interrupt_context();
1214
1215 m_st0.intm = 0;
1216
1217 CYCLES(4);
1218 }
1219
op_reti()1220 void tms32051_device::op_reti()
1221 {
1222 fatalerror("32051: unimplemented op reti at %08X\n", m_pc-1);
1223 }
1224
op_trap()1225 void tms32051_device::op_trap()
1226 {
1227 fatalerror("32051: unimplemented op trap at %08X\n", m_pc-1);
1228 }
1229
op_xc()1230 void tms32051_device::op_xc()
1231 {
1232 if (GET_ZLVC_CONDITION((m_op >> 4) & 0xf, m_op & 0xf) && GET_TP_CONDITION((m_op >> 8) & 0x3))
1233 {
1234 CYCLES(1);
1235 }
1236 else
1237 {
1238 int n = ((m_op >> 12) & 0x1) + 1;
1239 CHANGE_PC(m_pc + n);
1240 CYCLES(1 + n);
1241 }
1242 }
1243
1244 /*****************************************************************************/
1245
op_bldd_slimm()1246 void tms32051_device::op_bldd_slimm()
1247 {
1248 uint16_t pfc = ROPCODE();
1249
1250 while (m_rptc > -1)
1251 {
1252 uint16_t ea = GET_ADDRESS();
1253 uint16_t data = DM_READ16(pfc);
1254 DM_WRITE16(ea, data);
1255 pfc++;
1256 CYCLES(2);
1257
1258 m_rptc--;
1259 };
1260 }
1261
op_bldd_dlimm()1262 void tms32051_device::op_bldd_dlimm()
1263 {
1264 uint16_t pfc = ROPCODE();
1265
1266 while (m_rptc > -1)
1267 {
1268 uint16_t ea = GET_ADDRESS();
1269 uint16_t data = DM_READ16(ea);
1270 DM_WRITE16(pfc, data);
1271 pfc++;
1272 CYCLES(2);
1273
1274 m_rptc--;
1275 };
1276 }
1277
op_bldd_sbmar()1278 void tms32051_device::op_bldd_sbmar()
1279 {
1280 uint16_t pfc = m_bmar;
1281
1282 while (m_rptc > -1)
1283 {
1284 uint16_t ea = GET_ADDRESS();
1285 uint16_t data = DM_READ16(pfc);
1286 DM_WRITE16(ea, data);
1287 pfc++;
1288 CYCLES(2);
1289
1290 m_rptc--;
1291 };
1292 }
1293
op_bldd_dbmar()1294 void tms32051_device::op_bldd_dbmar()
1295 {
1296 uint16_t pfc = m_bmar;
1297
1298 while (m_rptc > -1)
1299 {
1300 uint16_t ea = GET_ADDRESS();
1301 uint16_t data = DM_READ16(ea);
1302 DM_WRITE16(pfc, data);
1303 pfc++;
1304 CYCLES(2);
1305
1306 m_rptc--;
1307 };
1308 }
1309
op_bldp()1310 void tms32051_device::op_bldp()
1311 {
1312 uint16_t pfc = m_bmar;
1313
1314 while (m_rptc > -1)
1315 {
1316 uint16_t ea = GET_ADDRESS();
1317 uint16_t data = DM_READ16(ea);
1318 PM_WRITE16(pfc, data);
1319 pfc++;
1320 CYCLES(1);
1321
1322 m_rptc--;
1323 };
1324 }
1325
op_blpd_bmar()1326 void tms32051_device::op_blpd_bmar()
1327 {
1328 fatalerror("32051: unimplemented op bpld bmar at %08X\n", m_pc-1);
1329 }
1330
op_blpd_imm()1331 void tms32051_device::op_blpd_imm()
1332 {
1333 uint16_t pfc = ROPCODE();
1334
1335 while (m_rptc > -1)
1336 {
1337 uint16_t ea = GET_ADDRESS();
1338 uint16_t data = PM_READ16(pfc);
1339 DM_WRITE16(ea, data);
1340 pfc++;
1341 CYCLES(2);
1342
1343 m_rptc--;
1344 };
1345 }
1346
1347 /*****************************************************************************/
1348
op_dmov()1349 void tms32051_device::op_dmov()
1350 {
1351 fatalerror("32051: unimplemented op dmov at %08X\n", m_pc-1);
1352 }
1353
op_in()1354 void tms32051_device::op_in()
1355 {
1356 fatalerror("32051: unimplemented op in at %08X\n", m_pc-1);
1357 }
1358
op_lmmr()1359 void tms32051_device::op_lmmr()
1360 {
1361 uint16_t pfc = ROPCODE();
1362
1363 while (m_rptc > -1)
1364 {
1365 uint16_t ea = GET_ADDRESS();
1366 uint16_t data = DM_READ16(pfc);
1367 DM_WRITE16(ea & 0x7f, data);
1368 pfc++;
1369 CYCLES(2);
1370
1371 m_rptc--;
1372 };
1373 }
1374
op_out()1375 void tms32051_device::op_out()
1376 {
1377 uint16_t port = ROPCODE();
1378 uint16_t ea = GET_ADDRESS();
1379
1380 uint16_t data = DM_READ16(ea);
1381 m_io.write_word(port << 1, data);
1382
1383 // TODO: handle repeat
1384 CYCLES(3);
1385 }
1386
op_smmr()1387 void tms32051_device::op_smmr()
1388 {
1389 uint16_t pfc = ROPCODE();
1390
1391 while (m_rptc > -1)
1392 {
1393 uint16_t ea = GET_ADDRESS();
1394 uint16_t data = DM_READ16(ea & 0x7f);
1395 DM_WRITE16(pfc, data);
1396 pfc++;
1397 CYCLES(2);
1398
1399 m_rptc--;
1400 };
1401 }
1402
op_tblr()1403 void tms32051_device::op_tblr()
1404 {
1405 uint16_t pfc = (uint16_t)(m_acc);
1406
1407 while (m_rptc > -1)
1408 {
1409 uint16_t ea = GET_ADDRESS();
1410 uint16_t data = PM_READ16(pfc);
1411 DM_WRITE16(ea, data);
1412 pfc++;
1413 CYCLES(2);
1414
1415 m_rptc--;
1416 };
1417 }
1418
op_tblw()1419 void tms32051_device::op_tblw()
1420 {
1421 uint16_t pfc = (uint16_t)(m_acc);
1422
1423 while (m_rptc > -1)
1424 {
1425 uint16_t ea = GET_ADDRESS();
1426 uint16_t data = DM_READ16(ea);
1427 PM_WRITE16(pfc, data);
1428 pfc++;
1429 CYCLES(2);
1430
1431 m_rptc--;
1432 };
1433 }
1434
1435 /*****************************************************************************/
1436
op_apl_dbmr()1437 void tms32051_device::op_apl_dbmr()
1438 {
1439 uint16_t ea = GET_ADDRESS();
1440 uint16_t data = DM_READ16(ea);
1441
1442 data &= m_dbmr;
1443
1444 m_st1.tc = (data == 0) ? 1 : 0;
1445
1446 DM_WRITE16(ea, data);
1447 CYCLES(1);
1448 }
1449
op_apl_imm()1450 void tms32051_device::op_apl_imm()
1451 {
1452 uint16_t ea = GET_ADDRESS();
1453 uint16_t imm = ROPCODE();
1454 uint16_t data = DM_READ16(ea);
1455
1456 data &= imm;
1457
1458 m_st1.tc = (data == 0) ? 1 : 0;
1459
1460 DM_WRITE16(ea, data);
1461 CYCLES(1);
1462 }
1463
op_cpl_dbmr()1464 void tms32051_device::op_cpl_dbmr()
1465 {
1466 fatalerror("32051: unimplemented op cpl dbmr at %08X\n", m_pc-1);
1467 }
1468
op_cpl_imm()1469 void tms32051_device::op_cpl_imm()
1470 {
1471 uint16_t imm = ROPCODE();
1472 uint16_t ea = GET_ADDRESS();
1473 uint16_t data = DM_READ16(ea);
1474
1475 m_st1.tc = (data == imm) ? 1 : 0;
1476
1477 CYCLES(1);
1478 }
1479
op_opl_dbmr()1480 void tms32051_device::op_opl_dbmr()
1481 {
1482 uint16_t ea = GET_ADDRESS();
1483 uint16_t data = DM_READ16(ea);
1484 data |= m_dbmr;
1485
1486 m_st1.tc = (data == 0) ? 1 : 0;
1487
1488 DM_WRITE16(ea, data);
1489 CYCLES(1);
1490 }
1491
op_opl_imm()1492 void tms32051_device::op_opl_imm()
1493 {
1494 uint16_t ea = GET_ADDRESS();
1495 uint16_t imm = ROPCODE();
1496 uint16_t data = DM_READ16(ea);
1497 data |= imm;
1498
1499 m_st1.tc = (data == 0) ? 1 : 0;
1500
1501 DM_WRITE16(ea, data);
1502 CYCLES(1);
1503 }
1504
op_splk()1505 void tms32051_device::op_splk()
1506 {
1507 uint16_t ea = GET_ADDRESS();
1508 uint16_t imm = ROPCODE();
1509
1510 DM_WRITE16(ea, imm);
1511
1512 CYCLES(2);
1513 }
1514
op_xpl_dbmr()1515 void tms32051_device::op_xpl_dbmr()
1516 {
1517 fatalerror("32051: unimplemented op xpl dbmr at %08X\n", m_pc-1);
1518 }
1519
op_xpl_imm()1520 void tms32051_device::op_xpl_imm()
1521 {
1522 fatalerror("32051: unimplemented op xpl imm at %08X\n", m_pc-1);
1523 }
1524
op_apac()1525 void tms32051_device::op_apac()
1526 {
1527 int32_t spreg = PREG_PSCALER(m_preg);
1528 m_acc = ADD(m_acc, spreg, false);
1529
1530 CYCLES(1);
1531 }
1532
op_lph()1533 void tms32051_device::op_lph()
1534 {
1535 fatalerror("32051: unimplemented op lph at %08X\n", m_pc-1);
1536 }
1537
op_lt()1538 void tms32051_device::op_lt()
1539 {
1540 uint16_t ea = GET_ADDRESS();
1541 uint16_t data = DM_READ16(ea);
1542
1543 m_treg0 = data;
1544 if (m_pmst.trm == 0)
1545 {
1546 m_treg1 = data;
1547 m_treg2 = data;
1548 }
1549
1550 CYCLES(1);
1551 }
1552
op_lta()1553 void tms32051_device::op_lta()
1554 {
1555 int32_t spreg;
1556 uint16_t ea = GET_ADDRESS();
1557 uint16_t data = DM_READ16(ea);
1558
1559 m_treg0 = data;
1560 spreg = PREG_PSCALER(m_preg);
1561 m_acc = ADD(m_acc, spreg, false);
1562 if (m_pmst.trm == 0)
1563 {
1564 m_treg1 = data;
1565 m_treg2 = data;
1566 }
1567
1568 CYCLES(1);
1569 }
1570
op_ltd()1571 void tms32051_device::op_ltd()
1572 {
1573 fatalerror("32051: unimplemented op ltd at %08X\n", m_pc-1);
1574 }
1575
op_ltp()1576 void tms32051_device::op_ltp()
1577 {
1578 fatalerror("32051: unimplemented op ltp at %08X\n", m_pc-1);
1579 }
1580
op_lts()1581 void tms32051_device::op_lts()
1582 {
1583 fatalerror("32051: unimplemented op lts at %08X\n", m_pc-1);
1584 }
1585
op_mac()1586 void tms32051_device::op_mac()
1587 {
1588 fatalerror("32051: unimplemented op mac at %08X\n", m_pc-1);
1589 }
1590
op_macd()1591 void tms32051_device::op_macd()
1592 {
1593 fatalerror("32051: unimplemented op macd at %08X\n", m_pc-1);
1594 }
1595
op_madd()1596 void tms32051_device::op_madd()
1597 {
1598 fatalerror("32051: unimplemented op madd at %08X\n", m_pc-1);
1599 }
1600
op_mads()1601 void tms32051_device::op_mads()
1602 {
1603 fatalerror("32051: unimplemented op mads at %08X\n", m_pc-1);
1604 }
1605
op_mpy_mem()1606 void tms32051_device::op_mpy_mem()
1607 {
1608 uint16_t ea = GET_ADDRESS();
1609 int16_t data = DM_READ16(ea);
1610
1611 m_preg = (int32_t)(data) * (int32_t)(int16_t)(m_treg0);
1612
1613 CYCLES(1);
1614 }
1615
op_mpy_simm()1616 void tms32051_device::op_mpy_simm()
1617 {
1618 fatalerror("32051: unimplemented op mpy simm at %08X\n", m_pc-1);
1619 }
1620
op_mpy_limm()1621 void tms32051_device::op_mpy_limm()
1622 {
1623 fatalerror("32051: unimplemented op mpy limm at %08X\n", m_pc-1);
1624 }
1625
op_mpya()1626 void tms32051_device::op_mpya()
1627 {
1628 fatalerror("32051: unimplemented op mpya at %08X\n", m_pc-1);
1629 }
1630
op_mpys()1631 void tms32051_device::op_mpys()
1632 {
1633 fatalerror("32051: unimplemented op mpys at %08X\n", m_pc-1);
1634 }
1635
op_mpyu()1636 void tms32051_device::op_mpyu()
1637 {
1638 fatalerror("32051: unimplemented op mpyu at %08X\n", m_pc-1);
1639 }
1640
op_pac()1641 void tms32051_device::op_pac()
1642 {
1643 fatalerror("32051: unimplemented op pac at %08X\n", m_pc-1);
1644 }
1645
op_spac()1646 void tms32051_device::op_spac()
1647 {
1648 fatalerror("32051: unimplemented op spac at %08X\n", m_pc-1);
1649 }
1650
op_sph()1651 void tms32051_device::op_sph()
1652 {
1653 uint16_t ea = GET_ADDRESS();
1654 uint16_t spreg = (uint16_t)(PREG_PSCALER(m_preg) >> 16);
1655 DM_WRITE16(ea, spreg);
1656
1657 CYCLES(1);
1658 }
1659
op_spl()1660 void tms32051_device::op_spl()
1661 {
1662 uint16_t ea = GET_ADDRESS();
1663 uint16_t spreg = (uint16_t)(PREG_PSCALER(m_preg));
1664 DM_WRITE16(ea, spreg);
1665
1666 CYCLES(1);
1667 }
1668
op_spm()1669 void tms32051_device::op_spm()
1670 {
1671 m_st1.pm = m_op & 0x3;
1672
1673 CYCLES(1);
1674 }
1675
op_sqra()1676 void tms32051_device::op_sqra()
1677 {
1678 fatalerror("32051: unimplemented op sqra at %08X\n", m_pc-1);
1679 }
1680
op_sqrs()1681 void tms32051_device::op_sqrs()
1682 {
1683 fatalerror("32051: unimplemented op sqrs at %08X\n", m_pc-1);
1684 }
1685
op_zpr()1686 void tms32051_device::op_zpr()
1687 {
1688 fatalerror("32051: unimplemented op zpr at %08X\n", m_pc-1);
1689 }
1690
op_bit()1691 void tms32051_device::op_bit()
1692 {
1693 uint16_t ea = GET_ADDRESS();
1694 uint16_t data = DM_READ16(ea);
1695
1696 m_st1.tc = (data >> (~m_op >> 8 & 0xf)) & 1;
1697
1698 CYCLES(1);
1699 }
1700
op_bitt()1701 void tms32051_device::op_bitt()
1702 {
1703 uint16_t ea = GET_ADDRESS();
1704 uint16_t data = DM_READ16(ea);
1705
1706 m_st1.tc = (data >> (~m_treg2 & 0xf)) & 1;
1707
1708 CYCLES(1);
1709 }
1710
op_clrc_ov()1711 void tms32051_device::op_clrc_ov()
1712 {
1713 m_st0.ovm = 0;
1714
1715 CYCLES(1);
1716 }
1717
op_clrc_ext()1718 void tms32051_device::op_clrc_ext()
1719 {
1720 m_st1.sxm = 0;
1721
1722 CYCLES(1);
1723 }
1724
op_clrc_hold()1725 void tms32051_device::op_clrc_hold()
1726 {
1727 fatalerror("32051: unimplemented op clrc hold at %08X\n", m_pc-1);
1728 }
1729
op_clrc_tc()1730 void tms32051_device::op_clrc_tc()
1731 {
1732 fatalerror("32051: unimplemented op clrc tc at %08X\n", m_pc-1);
1733 }
1734
op_clrc_carry()1735 void tms32051_device::op_clrc_carry()
1736 {
1737 fatalerror("32051: unimplemented op clrc carry at %08X\n", m_pc-1);
1738 }
1739
op_clrc_cnf()1740 void tms32051_device::op_clrc_cnf()
1741 {
1742 m_st1.cnf = 0;
1743
1744 CYCLES(1);
1745 }
1746
op_clrc_intm()1747 void tms32051_device::op_clrc_intm()
1748 {
1749 m_st0.intm = 0;
1750
1751 check_interrupts();
1752
1753 CYCLES(1);
1754 }
1755
op_clrc_xf()1756 void tms32051_device::op_clrc_xf()
1757 {
1758 m_st1.xf = 0;
1759
1760 CYCLES(1);
1761 }
1762
op_idle()1763 void tms32051_device::op_idle()
1764 {
1765 m_idle = true;
1766 }
1767
op_idle2()1768 void tms32051_device::op_idle2()
1769 {
1770 fatalerror("32051: unimplemented op idle2 at %08X\n", m_pc-1);
1771 }
1772
op_lst_st0()1773 void tms32051_device::op_lst_st0()
1774 {
1775 fatalerror("32051: unimplemented op lst st0 at %08X\n", m_pc-1);
1776 }
1777
op_lst_st1()1778 void tms32051_device::op_lst_st1()
1779 {
1780 fatalerror("32051: unimplemented op lst st1 at %08X\n", m_pc-1);
1781 }
1782
op_pop()1783 void tms32051_device::op_pop()
1784 {
1785 m_acc = POP_STACK();
1786
1787 CYCLES(1);
1788 }
1789
op_popd()1790 void tms32051_device::op_popd()
1791 {
1792 fatalerror("32051: unimplemented op popd at %08X\n", m_pc-1);
1793 }
1794
op_pshd()1795 void tms32051_device::op_pshd()
1796 {
1797 fatalerror("32051: unimplemented op pshd at %08X\n", m_pc-1);
1798 }
1799
op_push()1800 void tms32051_device::op_push()
1801 {
1802 fatalerror("32051: unimplemented op push at %08X\n", m_pc-1);
1803 }
1804
op_rpt_mem()1805 void tms32051_device::op_rpt_mem()
1806 {
1807 uint16_t ea = GET_ADDRESS();
1808 uint16_t data = DM_READ16(ea);
1809 m_rptc = data;
1810 m_rpt_start = m_pc;
1811 m_rpt_end = m_pc;
1812
1813 CYCLES(1);
1814 }
1815
op_rpt_limm()1816 void tms32051_device::op_rpt_limm()
1817 {
1818 m_rptc = (uint16_t)ROPCODE();
1819 m_rpt_start = m_pc;
1820 m_rpt_end = m_pc;
1821
1822 CYCLES(2);
1823 }
1824
op_rpt_simm()1825 void tms32051_device::op_rpt_simm()
1826 {
1827 m_rptc = (m_op & 0xff);
1828 m_rpt_start = m_pc;
1829 m_rpt_end = m_pc;
1830
1831 CYCLES(1);
1832 }
1833
op_rptb()1834 void tms32051_device::op_rptb()
1835 {
1836 uint16_t pma = ROPCODE();
1837 m_pmst.braf = 1;
1838 m_pasr = m_pc;
1839 m_paer = pma + 1;
1840
1841 CYCLES(2);
1842 }
1843
op_rptz()1844 void tms32051_device::op_rptz()
1845 {
1846 fatalerror("32051: unimplemented op rptz at %08X\n", m_pc-1);
1847 }
1848
op_setc_ov()1849 void tms32051_device::op_setc_ov()
1850 {
1851 m_st0.ovm = 1;
1852
1853 CYCLES(1);
1854 }
1855
op_setc_ext()1856 void tms32051_device::op_setc_ext()
1857 {
1858 m_st1.sxm = 1;
1859
1860 CYCLES(1);
1861 }
1862
op_setc_hold()1863 void tms32051_device::op_setc_hold()
1864 {
1865 fatalerror("32051: unimplemented op setc hold at %08X\n", m_pc-1);
1866 }
1867
op_setc_tc()1868 void tms32051_device::op_setc_tc()
1869 {
1870 m_st1.tc = 1;
1871
1872 CYCLES(1);
1873 }
1874
op_setc_carry()1875 void tms32051_device::op_setc_carry()
1876 {
1877 fatalerror("32051: unimplemented op setc carry at %08X\n", m_pc-1);
1878 }
1879
op_setc_xf()1880 void tms32051_device::op_setc_xf()
1881 {
1882 m_st1.xf = 1;
1883
1884 CYCLES(1);
1885 }
1886
op_setc_cnf()1887 void tms32051_device::op_setc_cnf()
1888 {
1889 m_st1.cnf = 1;
1890
1891 CYCLES(1);
1892 }
1893
op_setc_intm()1894 void tms32051_device::op_setc_intm()
1895 {
1896 m_st0.intm = 1;
1897
1898 check_interrupts();
1899
1900 CYCLES(1);
1901 }
1902
op_sst_st0()1903 void tms32051_device::op_sst_st0()
1904 {
1905 fatalerror("32051: unimplemented op sst st0 at %08X\n", m_pc-1);
1906 }
1907
op_sst_st1()1908 void tms32051_device::op_sst_st1()
1909 {
1910 fatalerror("32051: unimplemented op sst st1 at %08X\n", m_pc-1);
1911 }
1912