Previous 15994 Revisions Next

r9743 Tuesday 7th December, 2010 at 02:42:31 UTC by R. Belmont
m680x0: Many FPU and PMMU fixes and enhancements [Hans Ostermeyer]
[src/emu/cpu/m68000]m68k_in.c m68kcpu.c m68kcpu.h m68kdasm.c m68kfpu.c m68kmake.c m68kmmu.h

src/emu/cpu/m68000/m68kfpu.c
r9742r9743
366366         UINT32 ea = REG_A[reg];
367367         return m68ki_read_8(m68k, ea);
368368      }
369      case 3:      // (An)+
370      {
371         UINT32 ea = EA_AY_PI_8(m68k);
372         return m68ki_read_8(m68k, ea);
373      }
374      case 4:      // -(An)
375      {
376         UINT32 ea = EA_AY_PD_8(m68k);
377         return m68ki_read_8(m68k, ea);
378      }
369379      case 5:      // (d16, An)
370380      {
371381         UINT32 ea = EA_AY_DI_8(m68k);
r9742r9743
392402               UINT32 ea = (d1 << 16) | d2;
393403               return m68ki_read_8(m68k, ea);
394404            }
405            case 2:      // (d16, PC)
406            {
407               UINT32 ea = EA_PCDI_8(m68k);
408               return m68ki_read_8(m68k, ea);
409            }
410            case 3:      // (PC) + (Xn) + d8
411            {
412               UINT32 ea =  EA_PCIX_8(m68k);
413               return m68ki_read_8(m68k, ea);
414            }
395415            case 4:      // #<data>
396416            {
397417               return  OPER_I_8(m68k);
r9742r9743
422442         UINT32 ea = REG_A[reg];
423443         return m68ki_read_16(m68k, ea);
424444      }
445      case 3:      // (An)+
446      {
447         UINT32 ea = EA_AY_PI_16(m68k);
448         return m68ki_read_16(m68k, ea);
449      }
450      case 4:      // -(An)
451      {
452         UINT32 ea = EA_AY_PD_16(m68k);
453         return m68ki_read_16(m68k, ea);
454      }
425455      case 5:      // (d16, An)
426456      {
427457         UINT32 ea = EA_AY_DI_16(m68k);
r9742r9743
448478               UINT32 ea = (d1 << 16) | d2;
449479               return m68ki_read_16(m68k, ea);
450480            }
481            case 2:      // (d16, PC)
482            {
483               UINT32 ea = EA_PCDI_16(m68k);
484               return m68ki_read_16(m68k, ea);
485            }
486            case 3:      // (PC) + (Xn) + d8
487            {
488               UINT32 ea =  EA_PCIX_16(m68k);
489               return m68ki_read_16(m68k, ea);
490            }
451491            case 4:      // #<data>
452492            {
453493               return OPER_I_16(m68k);
r9742r9743
484524         UINT32 ea = EA_AY_PI_32(m68k);
485525         return m68ki_read_32(m68k, ea);
486526      }
527      case 4:      // -(An)
528      {
529         UINT32 ea = EA_AY_PD_32(m68k);
530         return m68ki_read_32(m68k, ea);
531      }
487532      case 5:      // (d16, An)
488533      {
489534         UINT32 ea = EA_AY_DI_32(m68k);
r9742r9743
515560               UINT32 ea = EA_PCDI_32(m68k);
516561               return m68ki_read_32(m68k, ea);
517562            }
563            case 3:      // (PC) + (Xn) + d8
564            {
565               UINT32 ea =  EA_PCIX_32(m68k);
566               return m68ki_read_32(m68k, ea);
567            }
518568            case 4:      // #<data>
519569            {
520570               return  OPER_I_32(m68k);
r9742r9743
551601         h2 = m68ki_read_32(m68k, ea+4);
552602         return  (UINT64)(h1) << 32 | (UINT64)(h2);
553603      }
604      case 4:      // -(An)
605      {
606         UINT32 ea = REG_A[reg]-8;
607         REG_A[reg] -= 8;
608         h1 = m68ki_read_32(m68k, ea+0);
609         h2 = m68ki_read_32(m68k, ea+4);
610         return  (UINT64)(h1) << 32 | (UINT64)(h2);
611      }
554612      case 5:      // (d16, An)
555613      {
556614         UINT32 ea = EA_AY_DI_32(m68k);
r9742r9743
558616         h2 = m68ki_read_32(m68k, ea+4);
559617         return  (UINT64)(h1) << 32 | (UINT64)(h2);
560618      }
619      case 6:      // (An) + (Xn) + d8
620      {
621         UINT32 ea = EA_AY_IX_32(m68k);
622         h1 = m68ki_read_32(m68k, ea+0);
623         h2 = m68ki_read_32(m68k, ea+4);
624         return  (UINT64)(h1) << 32 | (UINT64)(h2);
625      }
561626      case 7:
562627      {
563628         switch (reg)
564629         {
630            case 1:      // (xxx).L
631            {
632               UINT32 d1 = OPER_I_16(m68k);
633               UINT32 d2 = OPER_I_16(m68k);
634               UINT32 ea = (d1 << 16) | d2;
635               return (UINT64)(m68ki_read_32(m68k, ea)) << 32 | (UINT64)(m68ki_read_32(m68k, ea+4));
636            }
637            case 3:      // (PC) + (Xn) + d8
638            {
639               UINT32 ea =  EA_PCIX_32(m68k);
640               h1 = m68ki_read_32(m68k, ea+0);
641               h2 = m68ki_read_32(m68k, ea+4);
642               return  (UINT64)(h1) << 32 | (UINT64)(h2);
643            }
565644            case 4:      // #<data>
566645            {
567646               h1 = OPER_I_32(m68k);
r9742r9743
608687         fpr = load_extended_float80(m68k, ea);
609688         break;
610689      }
690      case 4:      // -(An)
691      {
692         UINT32 ea = REG_A[reg]-12;
693         REG_A[reg] -= 12;
694         fpr = load_extended_float80(m68k, ea);
695         break;
696      }
697      case 5:      // (d16, An)
698      {
699         // FIXME: will fail for fmovem
700         UINT32 ea = EA_AY_DI_32(m68k);
701         fpr = load_extended_float80(m68k, ea);
702         break;
703      }
704      case 6:      // (An) + (Xn) + d8
705      {
706         // FIXME: will fail for fmovem
707         UINT32 ea = EA_AY_IX_32(m68k);
708         fpr = load_extended_float80(m68k, ea);
709         break;
710      }
611711
612712      case 7:   // extended modes
613713      {
r9742r9743
9101010         m68ki_write_32(m68k, ea+4, (UINT32)(data));
9111011         break;
9121012      }
1013      case 3:      // (An)+
1014      {
1015         UINT32 ea = REG_A[reg];
1016         REG_A[reg] += 8;
1017         m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
1018         m68ki_write_32(m68k, ea+4, (UINT32)(data));
1019         break;
1020      }
9131021      case 4:      // -(An)
9141022      {
9151023         UINT32 ea;
r9742r9743
9261034         m68ki_write_32(m68k, ea+4, (UINT32)(data));
9271035         break;
9281036      }
1037      case 6:      // (An) + (Xn) + d8
1038      {
1039         UINT32 ea = EA_AY_IX_32(m68k);
1040         m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
1041         m68ki_write_32(m68k, ea+4, (UINT32)(data));
1042         break;
1043      }
1044      case 7:
1045      {
1046         switch (reg)
1047         {
1048            case 1:      // (xxx).L
1049            {
1050               UINT32 d1 = OPER_I_16(m68k);
1051               UINT32 d2 = OPER_I_16(m68k);
1052               UINT32 ea = (d1 << 16) | d2;
1053               m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
1054               m68ki_write_32(m68k, ea+4, (UINT32)(data));
1055               break;
1056            }
1057            case 2:      // (d16, PC)
1058            {
1059               UINT32 ea = EA_PCDI_32(m68k);
1060               m68ki_write_32(m68k, ea+0, (UINT32)(data >> 32));
1061               m68ki_write_32(m68k, ea+4, (UINT32)(data));
1062               break;
1063            }
1064            default:   fatalerror("M68kFPU: WRITE_EA_64: unhandled mode %d, reg %d at %08X\n", mode, reg, REG_PC);
1065         }
1066         break;
1067      }
9291068      default:   fatalerror("M68kFPU: WRITE_EA_64: unhandled mode %d, reg %d, data %08X%08X at %08X\n", mode, reg, (UINT32)(data >> 32), (UINT32)(data), REG_PC);
9301069   }
9311070}
r9742r9743
11541293      case 0x00:      // FMOVE
11551294      {
11561295         REG_FP[dst] = source;
1296         SET_CONDITION_CODES(m68k, REG_FP[dst]);
11571297         m68k->remaining_cycles -= 4;
11581298         break;
11591299      }
r9742r9743
13521492   int mode = (w2 >> 11) & 0x3;
13531493   int reglist = w2 & 0xff;
13541494
1495   UINT32 mem_addr = 0;
1496   switch (ea >> 3)
1497   {
1498      case 5:      // (d16, An)
1499         mem_addr= EA_AY_DI_32(m68k);
1500         break;
1501      case 6:      // (An) + (Xn) + d8
1502         mem_addr= EA_AY_IX_32(m68k);
1503         break;
1504   }
1505
13551506   if (dir)   // From FP regs to mem
13561507   {
13571508      switch (mode)
13581509      {
1359         case 0:      // Static register list, predecrement addressing mode
1510         case 0:      // Static register list, predecrement or control addressing mode
13601511         {
13611512            for (i=0; i < 8; i++)
13621513            {
13631514               if (reglist & (1 << i))
13641515               {
1365                  WRITE_EA_FPE(m68k, ea, REG_FP[i]);
1516                  switch (ea >> 3)
1517                  {
1518                     case 5:      // (d16, An)
1519                     case 6:      // (An) + (Xn) + d8
1520                        store_extended_float80(m68k, mem_addr, REG_FP[i]);
1521                        mem_addr += 12;
1522                        break;
1523                     default:
1524                        WRITE_EA_FPE(m68k, ea, REG_FP[i]);
1525                        break;
1526                  }
1527
13661528                  m68k->remaining_cycles -= 2;
13671529               }
13681530            }
r9742r9743
13761538   {
13771539      switch (mode)
13781540      {
1379         case 2:      // Static register list, postincrement addressing mode
1541         case 2:      // Static register list, postincrement or control addressing mode
13801542         {
13811543            for (i=0; i < 8; i++)
13821544            {
13831545               if (reglist & (1 << i))
13841546               {
1385                  REG_FP[7-i] = READ_EA_FPE(m68k, ea);
1547                  switch (ea >> 3)
1548                  {
1549                     case 5:      // (d16, An)
1550                     case 6:      // (An) + (Xn) + d8
1551                        REG_FP[7-i] = load_extended_float80(m68k, mem_addr);
1552                        mem_addr += 12;
1553                        break;
1554                     default:
1555                        REG_FP[7-i] = READ_EA_FPE(m68k, ea);
1556                        break;
1557                  }
13861558                  m68k->remaining_cycles -= 2;
13871559               }
13881560            }
r9742r9743
14721644         break;
14731645      }
14741646
1647      case 1:      // FBcc disp16
1648      {
1649         switch ((m68k->ir >> 3) & 0x3) {
1650         case 1: // FDBcc
1651            // TODO:
1652            break;
1653         default: // FScc (?)
1654            // TODO:
1655            break;
1656         }
1657         fatalerror("M68kFPU: unimplemented main op %d with mode %d\n", (m68k->ir >> 6) & 0x3, (m68k->ir >> 3) & 0x7);
1658      }
1659
14751660      case 2:      // FBcc disp16
14761661      {
14771662         fbcc16(m68k);
r9742r9743
16301815               }
16311816               break;
16321817
1818            case 5: // (D16, An)
1819               addr = EA_AY_DI_16(m68k);
1820               temp = m68ki_read_32(m68k, addr);
1821
1822               // check for NULL frame
1823               if (temp & 0xff000000)
1824               {
1825                  // we don't handle non-NULL frames and there's no pre/post inc/dec to do here
1826                  m68k->fpu_just_reset = 0;
1827               }
1828               else
1829               {
1830                  do_frestore_null(m68k);
1831               }
1832               break;
1833
1834            case 7: //
1835               switch (reg)
1836               {
1837                  case 2:      // (d16, PC)
1838                  {
1839                     addr = EA_PCDI_16(m68k);;
1840                     temp = m68ki_read_32(m68k, addr);
1841
1842                     // check for NULL frame
1843                     if (temp & 0xff000000)
1844                     {
1845                        // we don't handle non-NULL frames and there's no pre/post inc/dec to do here
1846                        m68k->fpu_just_reset = 0;
1847                     }
1848                     else
1849                     {
1850                        do_frestore_null(m68k);
1851                     }
1852                     break;
1853                  }
1854                  default:
1855                     fatalerror("M68kFPU: FRESTORE unhandled mode %d reg %d at %x\n", mode, reg, REG_PC);
1856               }
1857
1858               break;
1859
16331860            default:
16341861               fatalerror("M68kFPU: FRESTORE unhandled mode %d reg %d at %x\n", mode, reg, REG_PC);
16351862         }
src/emu/cpu/m68000/m68kcpu.h
r9742r9743
636636   int    has_hmmu;     /* Indicates if an Apple HMMU is available in place of the 68851 (020 only) */
637637   int    pmmu_enabled; /* Indicates if the PMMU is enabled */
638638   int    hmmu_enabled; /* Indicates if the HMMU is enabled */
639   int    has_fpu;      /* Indicates if a FPU is available (yes on 030, 040, may be on 020) */
639640   int    fpu_just_reset; /* Indicates the FPU was just reset */
640641
641642   /* Clocks required for instructions / exceptions */
r9742r9743
699700   UINT32 mmu_atc_tag[MMU_ATC_ENTRIES], mmu_atc_data[MMU_ATC_ENTRIES];
700701   UINT32 mmu_atc_rr;
701702   UINT32 mmu_tt0, mmu_tt1;
703
704   UINT16 mmu_tmp_sr;      /* temporary hack: status code for ptest and to handle write protection */
705   UINT16 mmu_tmp_fc;      /* temporary hack: function code for the mmu (moves) */
706   UINT16 mmu_tmp_rw;      /* temporary hack: read/write (1/0) for the mmu */
707   UINT32 mmu_tmp_buserror_address;   /* temporary hack: (first) bus error address */
708   UINT16 mmu_tmp_buserror_occurred;  /* temporary hack: flag that bus error has occurred from mmu */
702709};
703710
704711
r9742r9743
807814INLINE void m68ki_stack_frame_0001(m68ki_cpu_core *m68k, UINT32 pc, UINT32 sr, UINT32 vector);
808815INLINE void m68ki_stack_frame_0010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector);
809816INLINE void m68ki_stack_frame_1000(m68ki_cpu_core *m68k, UINT32 pc, UINT32 sr, UINT32 vector);
810INLINE void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc);
811INLINE void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc);
817INLINE void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address);
818INLINE void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address);
812819
813820INLINE void m68ki_exception_trap(m68ki_cpu_core *m68k, UINT32 vector);
814821INLINE void m68ki_exception_trapN(m68ki_cpu_core *m68k, UINT32 vector);
r9742r9743
882889{
883890   UINT32 result;
884891
892   m68k->mmu_tmp_fc = m68k->s_flag | FUNCTION_CODE_USER_PROGRAM;
893   m68k->mmu_tmp_rw = 1;
894
885895   m68ki_check_address_error(m68k, REG_PC, MODE_READ, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
886896
887897   if(REG_PC != m68k->pref_addr)
888898   {
889      m68k->pref_addr = REG_PC;
890      m68k->pref_data = m68k->memory.readimm16(m68k->pref_addr);
899      m68k->pref_data = m68k->memory.readimm16(REG_PC);
900      m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC;
891901   }
892902   result = MASK_OUT_ABOVE_16(m68k->pref_data);
893903   REG_PC += 2;
894   m68k->pref_addr = REG_PC;
895   m68k->pref_data = m68k->memory.readimm16(m68k->pref_addr);
904   if (!m68k->mmu_tmp_buserror_occurred) {
905      // prefetch only if no bus error occurred in opcode fetch
906      m68k->pref_data = m68k->memory.readimm16(REG_PC);
907      m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC;
908      // ignore bus error on prefetch
909      m68k->mmu_tmp_buserror_occurred = 0;
910   }
911
896912   return result;
897913}
898914
r9742r9743
900916{
901917   UINT32 temp_val;
902918
919   m68k->mmu_tmp_fc = m68k->s_flag | FUNCTION_CODE_USER_PROGRAM;
920   m68k->mmu_tmp_rw = 1;
921
903922   m68ki_check_address_error(m68k, REG_PC, MODE_READ, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */
904923
905924   if(REG_PC != m68k->pref_addr)
r9742r9743
914933
915934   temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | MASK_OUT_ABOVE_16(m68k->pref_data));
916935   REG_PC += 2;
917   m68k->pref_addr = REG_PC;
918   m68k->pref_data = m68k->memory.readimm16(m68k->pref_addr);
936   m68k->pref_data = m68k->memory.readimm16(REG_PC);
937   m68k->pref_addr = m68k->mmu_tmp_buserror_occurred ? ~0 : REG_PC;
919938
920939   return temp_val;
921940}
r9742r9743
932951 */
933952INLINE UINT32 m68ki_read_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
934953{
954   m68k->mmu_tmp_fc = fc;
955   m68k->mmu_tmp_rw = 1;
935956   return m68k->memory.read8(address);
936957}
937958INLINE UINT32 m68ki_read_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
r9742r9743
940961   {
941962      m68ki_check_address_error(m68k, address, MODE_READ, fc);
942963   }
964   m68k->mmu_tmp_fc = fc;
965   m68k->mmu_tmp_rw = 1;
943966   return m68k->memory.read16(address);
944967}
945968INLINE UINT32 m68ki_read_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
r9742r9743
948971   {
949972      m68ki_check_address_error(m68k, address, MODE_READ, fc);
950973   }
974   m68k->mmu_tmp_fc = fc;
975   m68k->mmu_tmp_rw = 1;
951976   return m68k->memory.read32(address);
952977}
953978
954979INLINE void m68ki_write_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
955980{
981   m68k->mmu_tmp_fc = fc;
982   m68k->mmu_tmp_rw = 0;
956983   m68k->memory.write8(address, value);
957984}
958985INLINE void m68ki_write_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
r9742r9743
961988   {
962989      m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
963990   }
991   m68k->mmu_tmp_fc = fc;
992   m68k->mmu_tmp_rw = 0;
964993   m68k->memory.write16(address, value);
965994}
966995INLINE void m68ki_write_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
r9742r9743
969998   {
970999      m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
9711000   }
1001   m68k->mmu_tmp_fc = fc;
1002   m68k->mmu_tmp_rw = 0;
9721003   m68k->memory.write32(address, value);
9731004}
9741005
r9742r9743
9831014   {
9841015      m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
9851016   }
1017   m68k->mmu_tmp_fc = fc;
1018   m68k->mmu_tmp_rw = 0;
9861019   m68k->memory.write16(address+2, value>>16);
9871020   m68k->memory.write16(address, value&0xffff);
9881021}
r9742r9743
14831516 * if the error happens at an instruction boundary.
14841517 * PC stacked is address of next instruction.
14851518 */
1486void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc)
1519void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address)
14871520{
14881521   /* INTERNAL REGISTER */
14891522   m68ki_push_16(m68k, 0);
r9742r9743
15011534   m68ki_push_16(m68k, 0);
15021535
15031536   /* DATA CYCLE FAULT ADDRESS (2 words) */
1504   m68ki_push_32(m68k, 0);
1537   m68ki_push_32(m68k, fault_address);
15051538
15061539   /* INSTRUCTION PIPE STAGE B */
15071540   m68ki_push_16(m68k, 0);
r9742r9743
15301563 * if the error happens during instruction execution.
15311564 * PC stacked is address of instruction in progress.
15321565 */
1533void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc)
1566void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address)
15341567{
15351568   /* INTERNAL REGISTERS (18 words) */
15361569   m68ki_push_32(m68k, 0);
r9742r9743
15571590   m68ki_push_32(m68k, 0);
15581591
15591592   /* STAGE B ADDRESS (2 words) */
1560   m68ki_push_32(m68k, 0);
1593   m68ki_push_32(m68k, fault_address);
15611594
15621595   /* INTERNAL REGISTER (4 words) */
15631596   m68ki_push_32(m68k, 0);
src/emu/cpu/m68000/m68kmake.c
r9742r9743
33/* ======================================================================== */
44/*
55 *                                  MUSASHI
6 *                                Version 4.6
6 *                                Version 4.7
77 *
88 * A portable Motorola M680x0 processor emulation engine.
99 * Copyright Karl Stenerud.  All rights reserved.
r9742r9743
2424 * Modified For OpenVMS By:  Robert Alan Byer
2525 *                           byer@mail.ourservers.net
2626 *
27 * 68030 and PMMU by R. Belmont
28 * 68040 and FPU by Ville Linde
27 * 68030 and PMMU by R. Belmont and Hans Ostermeyer
28 * 68040 and FPU by Ville Linde, R. Belmont, and Hans Ostermeyer
2929 */
3030
3131
r9742r9743
5656 */
5757
5858
59static const char g_version[] = "4.60";
59static const char g_version[] = "4.70";
6060
6161/* ======================================================================== */
6262/* =============================== INCLUDES =============================== */
src/emu/cpu/m68000/m68kmmu.h
r9742r9743
88    Visit http://mamedev.org for licensing and usage restrictions.
99*/
1010
11// MMU status register bit definitions
12
13#define M68K_MMU_SR_BUS_ERROR 0x8000
14#define M68K_MMU_SR_SUPERVISOR_ONLY 0x2000
15#define M68K_MMU_SR_WRITE_PROTECT 0x0800
16#define M68K_MMU_SR_INVALID 0x0400
17#define M68K_MMU_SR_MODIFIED 0x0200
18#define M68K_MMU_SR_LEVEL_0 0x0000
19#define M68K_MMU_SR_LEVEL_1 0x0001
20#define M68K_MMU_SR_LEVEL_2 0x0002
21#define M68K_MMU_SR_LEVEL_3 0x0003
22
23// MMU translation table descriptor field definitions
24
25#define M68K_MMU_DF_DT         0x0003
26#define M68K_MMU_DF_DT0        0x0000
27#define M68K_MMU_DF_DT1        0x0001
28#define M68K_MMU_DF_DT2        0x0002
29#define M68K_MMU_DF_DT3        0x0003
30#define M68K_MMU_DF_WP         0x0004
31#define M68K_MMU_DF_USED       0x0008
32#define M68K_MMU_DF_MODIFIED   0x0010
33#define M68K_MMU_DF_CI         0x0040
34#define M68K_MMU_DF_SUPERVISOR 0x0100
35
36// MMU ATC Fields
37
38#define M68K_MMU_ATC_BUSERROR  0x08000000
39#define M68K_MMU_ATC_CACHE_IN  0x04000000
40#define M68K_MMU_ATC_WRITE_PR  0x02000000
41#define M68K_MMU_ATC_MODIFIED  0x01000000
42#define M68K_MMU_ATC_MASK      0x00ffffff
43#define M68K_MMU_ATC_SHIFT     8
44#define M68K_MMU_ATC_VALID     0x08000000
45
46// MMU Translation Control register
47#define M68K_MMU_TC_SRE        0x02000000
48
1149/* decodes the effective address */
1250static UINT32 DECODE_EA_32(m68ki_cpu_core *m68k, int ea)
1351{
r9742r9743
68106/*
69107    pmmu_atc_add: adds this address to the ATC
70108*/
71void pmmu_atc_add(m68ki_cpu_core *m68k, UINT32 logical, UINT32 physical)
109void pmmu_atc_add(m68ki_cpu_core *m68k, UINT32 logical, UINT32 physical, int fc)
72110{
73   int i, found, curfc;
111   int i, found;
74112
75   curfc = (m68ki_get_sr(m68k) & 0x2000) ? 4 : 0;
76   curfc |= 1;   // program vs. data space is not implemented
113     // get page size (i.e. # of bits to ignore); is 10 for Apollo
114    int ps = (m68k->mmu_tc >> 20) & 0xf;
115    // Note: exact emulation would use (logical >> ps) << (ps-8)
116    UINT32 atc_tag = M68K_MMU_ATC_VALID | ((fc &7) << 24)| logical >> ps;
77117
78118   // first see if this is already in the cache
79119   for (i = 0; i < MMU_ATC_ENTRIES; i++)
80120   {
81121      // if tag bits and function code match, don't add
82      if (((m68k->mmu_atc_tag[i] & 0xffffff) == (logical>>8)) && (((m68k->mmu_atc_tag[i]>>24) & 7) == curfc))
122      if (m68k->mmu_atc_tag[i] == atc_tag)
83123      {
84124         return;
85125      }
r9742r9743
89129   found = -1;
90130   for (i = 0; i < MMU_ATC_ENTRIES; i++)
91131   {
92      if (!(m68k->mmu_atc_tag[i] & 0x80000000))
132      if (!(m68k->mmu_atc_tag[i] & M68K_MMU_ATC_VALID))
93133      {
94134         found = i;
95135         break;
r9742r9743
108148   }
109149
110150   // add the entry
111//  logerror("ATC[%d] add: log %08x -> phys %08x\n", found, logical, physical);
112   m68k->mmu_atc_tag[found] = (logical>>8) | (curfc<<24) | 0x80000000;
113   m68k->mmu_atc_data[found] = (physical>>8);
151    // logerror("ATC[%2d] add: log %08x -> phys %08x (fc=%d)\n", found, (logical>>ps) << ps, (physical >> ps) << ps, fc);
152   m68k->mmu_atc_tag[found] = atc_tag;
153   m68k->mmu_atc_data[found] = (physical >> ps) << (ps-8);
154
155   if (m68k->mmu_tmp_sr & M68K_MMU_SR_WRITE_PROTECT)
156   {
157      m68k->mmu_atc_data[found] |= M68K_MMU_ATC_WRITE_PR;
158   }
114159}
115160
116161/*
r9742r9743
121166void pmmu_atc_flush(m68ki_cpu_core *m68k)
122167{
123168   int i;
169    // logerror("ATC flush: pc=%08x\n", REG_PPC);
124170
125171   for (i = 0; i < MMU_ATC_ENTRIES; i++)
126172   {
r9742r9743
130176   m68k->mmu_atc_rr = 0;
131177}
132178
179
180INLINE UINT32 get_dt2_table_entry(m68ki_cpu_core *m68k, UINT32 tptr, UINT8 ptest)
181{
182   UINT32 tbl_entry = m68k->program->read_dword(tptr);
183   UINT32 dt = tbl_entry & M68K_MMU_DF_DT;
184
185   m68k->mmu_tmp_sr |= tbl_entry & 0x0004 ? M68K_MMU_SR_WRITE_PROTECT : 0;
186
187   if (!ptest && dt != M68K_MMU_DF_DT0)
188   {
189      if (dt == M68K_MMU_DF_DT1 && !m68k->mmu_tmp_rw && !(m68k->mmu_tmp_sr & M68K_MMU_SR_WRITE_PROTECT))
190      {
191         // set used and modified
192         m68k->program->write_dword( tptr, tbl_entry | M68K_MMU_DF_USED | M68K_MMU_DF_MODIFIED);
193      }
194      else if (!(tbl_entry & M68K_MMU_DF_USED))
195      {
196         m68k->program->write_dword( tptr, tbl_entry | M68K_MMU_DF_USED);
197      }
198   }
199   return tbl_entry;
200}
201
202INLINE UINT32 get_dt3_table_entry(m68ki_cpu_core *m68k, UINT32 tptr, UINT8 ptest)
203{
204   UINT32 tbl_entry2 = m68k->program->read_dword(tptr);
205   UINT32 tbl_entry = m68k->program->read_dword(tptr + 4);
206   UINT32 dt = tbl_entry2 & M68K_MMU_DF_DT;
207
208   m68k->mmu_tmp_sr |= tbl_entry2 & 0x0100 ? M68K_MMU_SR_SUPERVISOR_ONLY : 0;
209   m68k->mmu_tmp_sr |= tbl_entry2 & 0x0004 ? M68K_MMU_SR_WRITE_PROTECT : 0;
210
211   if (!ptest)
212   {
213      if (dt == M68K_MMU_DF_DT1 && !m68k->mmu_tmp_rw && !(m68k->mmu_tmp_sr & M68K_MMU_SR_WRITE_PROTECT))
214      {
215         // set modified
216         m68k->program->write_dword( tptr, tbl_entry2 | M68K_MMU_DF_USED | M68K_MMU_DF_MODIFIED);
217      }
218      else if (!(tbl_entry2 & M68K_MMU_DF_USED))
219      {
220         m68k->program->write_dword( tptr, tbl_entry2 | M68K_MMU_DF_USED);
221      }
222   }
223
224   return (tbl_entry & ~M68K_MMU_DF_DT) | dt;
225}
226
133227/*
134    pmmu_translate_addr: perform 68851/68030-style PMMU address translation
228    pmmu_translate_addr_with_fc: perform 68851/68030-style PMMU address translation
135229*/
136INLINE UINT32 pmmu_translate_addr(m68ki_cpu_core *m68k, UINT32 addr_in)
230/*INLINE*/ static UINT32 pmmu_translate_addr_with_fc(m68ki_cpu_core *m68k, UINT32 addr_in, UINT8 fc, UINT8 ptest)
137231{
138   UINT32 addr_out, tbl_entry = 0, tbl_entry2, tamode = 0, tbmode = 0, tcmode = 0;
139   UINT32 root_aptr, root_limit, tofs, is, abits, bbits, cbits;
140   UINT32 resolved, tptr, shift;
141   int curfc, i;
232   UINT32 addr_out, tbl_entry = 0, tamode = 0, tbmode = 0, tcmode = 0;
233   UINT32 root_aptr, root_limit, tofs, ps, is, abits, bbits, cbits;
234   UINT32 resolved, tptr, shift, last_entry_ptr;
235   int i;
236   UINT32 atc_tag;
142237//  int verbose = 0;
143238
239//   static UINT32 pmmu_access_count = 0;
240//   static UINT32 pmmu_atc_count = 0;
241
144242   resolved = 0;
145243   addr_out = addr_in;
244   m68k->mmu_tmp_sr = 0;
146245
147   curfc = (m68ki_get_sr(m68k) & 0x2000) ? 4 : 0;
148   curfc |= 1;   // program vs. data space is not implemented
246   if (fc == 7)
247   {
248      return addr_in;
249   }
149250
251   if (m68k->mmu_tt0 & 0x8000)
252   {
253      // transparent translation register 0 enabled
254      UINT32 address_base = m68k->mmu_tt0 & 0xff000000;
255      UINT32 address_mask = ((m68k->mmu_tt0 << 8) & 0xff000000) ^ 0xff000000;
256      if ((addr_in & address_mask) == address_base)
257      {
258//         logerror("PMMU: pc=%x TT0 fc=%x addr_in=%08x address_mask=%08x address_base=%08x\n", m68k->ppc, fc, addr_in, address_mask, address_base);
259         return addr_in;
260      }
261   }
262
263//   if ((++pmmu_access_count % 10000000) == 0) {
264//      logerror("pmmu_translate_addr_with_fc: atc usage = %d%%\n", pmmu_atc_count*100/pmmu_access_count);
265//      pmmu_atc_count = pmmu_access_count = 0;
266//   }
267
268     // get page size (i.e. # of bits to ignore); ps is 10 or 12 for Apollo, 8 otherwise
269    ps = (m68k->mmu_tc >> 20) & 0xf;
270    atc_tag = M68K_MMU_ATC_VALID | ((fc &7) << 24) | addr_in >> ps;
271
150272   // first see if this is already in the ATC
151273   for (i = 0; i < MMU_ATC_ENTRIES; i++)
152274   {
153275      // if tag bits and function code match, we've got it
154      if (((m68k->mmu_atc_tag[i] & 0xffffff) == (addr_in>>8)) && (((m68k->mmu_atc_tag[i]>>24) & 7) == curfc))
276      if (m68k->mmu_atc_tag[i] == atc_tag)
155277      {
156         addr_out = (m68k->mmu_atc_data[i]<<8) | (addr_in & 0xff);
157//          logerror("ATC[%d] hit: log %08x -> phys %08x\n", i, addr_in, addr_out);
158         return addr_out;
278          if (m68k->mmu_tmp_rw || !(m68k->mmu_atc_data[i] & M68K_MMU_ATC_WRITE_PR))
279          {
280             // read access or write access and not write protected
281             if (!m68k->mmu_tmp_rw && !ptest)
282             {
283                // FIXME: must set modified in PMMU tables as well
284                m68k->mmu_atc_data[i] |= M68K_MMU_ATC_MODIFIED;
285             }
286             else
287             {
288                // FIXME: supervisor mode?
289                m68k->mmu_tmp_sr = M68K_MMU_SR_MODIFIED;
290             }
291            addr_out = (m68k->mmu_atc_data[i]<<8) | (addr_in & ~(~0 << ps));
292//              logerror("ATC[%2d] hit: log %08x -> phys %08x  pc=%08x fc=%d\n", i, addr_in, addr_out, REG_PPC, fc);
293//            pmmu_atc_count++;
294            return addr_out;
295          }
159296      }
160297   }
161298
162//  if (addr_in == 0x5fa04c) verbose = 1;
163
164299   // if SRP is enabled and we're in supervisor mode, use it
165   if ((m68k->mmu_tc & 0x02000000) && (m68ki_get_sr(m68k) & 0x2000))
300   if ((m68k->mmu_tc & M68K_MMU_TC_SRE) && (fc & 4))
166301   {
167302      root_aptr = m68k->mmu_srp_aptr;
168303      root_limit = m68k->mmu_srp_limit;
r9742r9743
173308      root_limit = m68k->mmu_crp_limit;
174309   }
175310
176   // get initial shift (# of top bits to ignore)
177   is = (m68k->mmu_tc>>16) & 0xf;
178   abits = (m68k->mmu_tc>>12)&0xf;
179   bbits = (m68k->mmu_tc>>8)&0xf;
180   cbits = (m68k->mmu_tc>>4)&0xf;
311     // get initial shift (# of top bits to ignore)
312    is = (m68k->mmu_tc >> 16) & 0xf;
313    ps = (m68k->mmu_tc >> 20) & 0xf;
314    abits = (m68k->mmu_tc >> 12) & 0xf;
315    bbits = (m68k->mmu_tc >> 8) & 0xf;
316    cbits = (m68k->mmu_tc >> 4) & 0xf;
181317
182   //logerror("PMMU: tcr %08x limit %08x aptr %08x is %x abits %d bbits %d cbits %d\n", m68k->mmu_tc, root_limit, root_aptr, is, abits, bbits, cbits);
318//   logerror("PMMU: tcr %08x limit %08x aptr %08x is %x abits %d bbits %d cbits %d\n", m68k->mmu_tc, root_limit, root_aptr, is, abits, bbits, cbits);
183319
184320   // get table A offset
185321   tofs = (addr_in<<is)>>(32-abits);
322   tptr = root_aptr & 0xfffffff0;
186323
187324   // find out what format table A is
188   switch (root_limit & 3)
325   switch (root_limit & M68K_MMU_DF_DT)
189326   {
190      case 0:   // invalid, should cause MMU exception
191      case 1:   // page descriptor, should cause direct mapping
192         logerror("680x0 PMMU: Unhandled root mode %d, not translating (addr_in %x)\n", root_limit & 3, addr_in);
193         logerror("          : aptr %08x limit %08x\n", root_aptr, root_limit);
194         return addr_in;
195         break;
327      case M68K_MMU_DF_DT0:   // invalid, will cause MMU exception
328         m68k->mmu_tmp_sr |= M68K_MMU_SR_INVALID;
329         return root_aptr;
196330
197      case 2:   // valid 4 byte descriptors
331      case M68K_MMU_DF_DT1:   // page descriptor, will cause direct mapping
332         addr_out = tptr + addr_in;
333//         logerror("PMMU: PC=%x root mode %d (addr_in %08x -> %08x)\n", m68k->ppc, M68K_MMU_DF_DT1, addr_in, addr_out);
334         return addr_out;
335
336      case M68K_MMU_DF_DT2:   // valid 4 byte descriptors
198337         tofs *= 4;
199//          if (verbose) logerror("PMMU: reading table A entry at %08x\n", tofs + (root_aptr & 0xfffffffc));
200         tbl_entry = m68k->program->read_dword(tofs + (root_aptr & 0xfffffffc));
201         tamode = tbl_entry & 3;
338//          if (verbose) logerror("PMMU: reading table A entry at %08x\n", tofs + tptr);
339         tbl_entry = get_dt2_table_entry(m68k,  tptr + tofs,  ptest);
340         tamode = tbl_entry & M68K_MMU_DF_DT;
202341//          if (verbose) logerror("PMMU: addr %08x entry %08x mode %x tofs %x\n", addr_in, tbl_entry, tamode, tofs);
203342         break;
204343
205      case 3: // valid 8 byte descriptors
344      case M68K_MMU_DF_DT3: // valid 8 byte descriptors
206345         tofs *= 8;
207//          if (verbose) logerror("PMMU: reading table A entries at %08x\n", tofs + (root_aptr & 0xfffffffc));
208         tbl_entry2 = m68k->program->read_dword(tofs + (root_aptr & 0xfffffffc));
209         tbl_entry = m68k->program->read_dword(tofs + (root_aptr & 0xfffffffc)+4);
210         tamode = tbl_entry2 & 3;
346//          if (verbose) logerror("PMMU: reading table A entries at %08x\n", tofs + tptr);
347         tbl_entry = get_dt3_table_entry(m68k,  tofs + tptr,  ptest);
348         tamode = tbl_entry & M68K_MMU_DF_DT;
211349//          if (verbose) logerror("PMMU: addr %08x entry %08x entry2 %08x mode %x tofs %x\n", addr_in, tbl_entry, tbl_entry2, tamode, tofs);
212350         break;
213351   }
214352
353   last_entry_ptr = tptr + tofs;
354
215355   // get table B offset and pointer
216356   tofs = (addr_in<<(is+abits))>>(32-bbits);
217357   tptr = tbl_entry & 0xfffffff0;
r9742r9743
219359   // find out what format table B is, if any
220360   switch (tamode)
221361   {
222      case 0: // invalid, should cause MMU exception
223         fatalerror("680x0 PMMU: Unhandled Table A mode %d (addr_in %08x PC %x)\n", tamode, addr_in, m68k->pc);
362      case M68K_MMU_DF_DT0: // invalid, will cause MMU exception (but not for ptest)
363         m68k->mmu_tmp_sr |= (M68K_MMU_SR_INVALID | M68K_MMU_SR_LEVEL_1);
364         // last valid pointer (for ptest)
365         addr_out = last_entry_ptr;
366         resolved = 1;
224367         break;
225368
226      case 2: // 4-byte table B descriptor
369      case M68K_MMU_DF_DT2: // 4-byte table B descriptor
227370         tofs *= 4;
228371//          if (verbose) logerror("PMMU: reading table B entry at %08x\n", tofs + tptr);
229         tbl_entry = m68k->program->read_dword(tofs + tptr);
230         tbmode = tbl_entry & 3;
372         tbl_entry = get_dt2_table_entry(m68k, tptr + tofs,  ptest);
373         tbmode = tbl_entry & M68K_MMU_DF_DT;
231374//          if (verbose) logerror("PMMU: addr %08x entry %08x mode %x tofs %x\n", addr_in, tbl_entry, tbmode, tofs);
232375         break;
233376
234      case 3: // 8-byte table B descriptor
377      case M68K_MMU_DF_DT3: // 8-byte table B descriptor
235378         tofs *= 8;
236379//          if (verbose) logerror("PMMU: reading table B entries at %08x\n", tofs + tptr);
237         tbl_entry2 = m68k->program->read_dword(tofs + tptr);
238         tbl_entry = m68k->program->read_dword(tofs + tptr + 4);
239         tbmode = tbl_entry2 & 3;
380         tbl_entry = get_dt3_table_entry(m68k, tptr + tofs,  ptest);
381         tbmode = tbl_entry & M68K_MMU_DF_DT;
382         tbl_entry &= ~M68K_MMU_DF_DT;
240383//          if (verbose) logerror("PMMU: addr %08x entry %08x entry2 %08x mode %x tofs %x\n", addr_in, tbl_entry, tbl_entry2, tbmode, tofs);
241384         break;
242385
243      case 1:   // early termination descriptor
244         tbl_entry &= 0xffffff00;
386      case M68K_MMU_DF_DT1:   // early termination descriptor
387         tbl_entry &= (~0 << ps);
245388
246389         shift = is+abits;
247390         addr_out = ((addr_in<<shift)>>shift) + tbl_entry;
r9742r9743
252395   // if table A wasn't early-out, continue to process table B
253396   if (!resolved)
254397   {
398      last_entry_ptr =  tptr + tofs;
399
255400      // get table C offset and pointer
256401      tofs = (addr_in<<(is+abits+bbits))>>(32-cbits);
257402      tptr = tbl_entry & 0xfffffff0;
258403
259404      switch (tbmode)
260405      {
261         case 0:   // invalid, should cause MMU exception
262            fatalerror("680x0 PMMU: Unhandled Table B mode %d (addr_in %08x PC %x)\n", tbmode, addr_in, m68k->pc);
406         case M68K_MMU_DF_DT0:   // invalid, will cause MMU exception (but not for ptest)
407            m68k->mmu_tmp_sr |= (M68K_MMU_SR_INVALID | M68K_MMU_SR_LEVEL_2);
408            // last valid pointer (for ptest)
409            addr_out = last_entry_ptr;
410            resolved = 1;
263411            break;
264412
265         case 2: // 4-byte table C descriptor
413         case M68K_MMU_DF_DT2: // 4-byte table C descriptor
266414            tofs *= 4;
267415//              if (verbose) logerror("PMMU: reading table C entry at %08x\n", tofs + tptr);
268            tbl_entry = m68k->program->read_dword(tofs + tptr);
269            tcmode = tbl_entry & 3;
416            tbl_entry = get_dt2_table_entry(m68k, tptr + tofs, ptest);
417            tcmode = tbl_entry & M68K_MMU_DF_DT;
270418//              if (verbose) logerror("PMMU: addr %08x entry %08x mode %x tofs %x\n", addr_in, tbl_entry, tbmode, tofs);
271419            break;
272420
273         case 3: // 8-byte table C descriptor
421         case M68K_MMU_DF_DT3: // 8-byte table C descriptor
274422            tofs *= 8;
275423//              if (verbose) logerror("PMMU: reading table C entries at %08x\n", tofs + tptr);
276            tbl_entry2 = m68k->program->read_dword(tofs + tptr);
277            tbl_entry = m68k->program->read_dword(tofs + tptr + 4);
278            tcmode = tbl_entry2 & 3;
279//              if (verbose) logerror("PMMU: addr %08x entry %08x entry2 %08x mode %x tofs %x\n", addr_in, tbl_entry, tbl_entry2, tbmode, tofs);
424            tbl_entry = get_dt3_table_entry(m68k,  tptr+ tofs,  ptest);
425            tcmode = tbl_entry & M68K_MMU_DF_DT;
426//              if (verbose) logerror("PMMU: addr %08x entry %08x entry2 %08x mode %x tofs %x\n", addr_in, tbl_entry, tbl_entry2, tcmode, tofs);
280427            break;
281428
282         case 1: // termination descriptor
283            tbl_entry &= 0xffffff00;
429         case M68K_MMU_DF_DT1: // termination descriptor
430            tbl_entry &= (~0 << ps);
284431
285432            shift = is+abits+bbits;
286433            addr_out = ((addr_in<<shift)>>shift) + tbl_entry;
r9742r9743
293440   {
294441      switch (tcmode)
295442      {
296         case 0:   // invalid, should cause MMU exception
297         case 2: // 4-byte table D descriptor
298         case 3: // 8-byte table D descriptor
299            fatalerror("680x0 PMMU: Unhandled Table C mode %d (addr_in %08x PC %x)\n", tbmode, addr_in, m68k->pc);
443         case M68K_MMU_DF_DT0:   // invalid, will cause MMU exception (unless ptest)
444            m68k->mmu_tmp_sr |= (M68K_MMU_SR_INVALID | M68K_MMU_SR_LEVEL_3);
445            addr_out = tptr + tofs;
446            resolved = 1;
300447            break;
301448
302         case 1: // termination descriptor
303            tbl_entry &= 0xffffff00;
449         case M68K_MMU_DF_DT2: // 4-byte (short-form) indirect descriptor
450         case M68K_MMU_DF_DT3: // 8-byte (long-form) indirect descriptor
451            fatalerror("PMMU: pc=%08x Unhandled Table C mode %d (addr_in %08x)\n", m68k->ppc, tcmode, addr_in);
452            break;
304453
454         case M68K_MMU_DF_DT1: // termination descriptor
455            tbl_entry &= (~0 << ps);
456
305457            shift = is+abits+bbits+cbits;
306458            addr_out = ((addr_in<<shift)>>shift) + tbl_entry;
307459            resolved = 1;
r9742r9743
309461      }
310462   }
311463
312   pmmu_atc_add(m68k, addr_in, addr_out);
464    if (!ptest)
465   {
466      if (m68k->mmu_tmp_sr & M68K_MMU_SR_INVALID)
467      {
468         if (++m68k->mmu_tmp_buserror_occurred == 1)
469         {
470            m68k->mmu_tmp_buserror_address = addr_in;
471         }
472      }
473      else if ((m68k->mmu_tmp_sr & M68K_MMU_SR_SUPERVISOR_ONLY) && !(fc & 4))
474      {
475         if (++m68k->mmu_tmp_buserror_occurred == 1)
476         {
477            m68k->mmu_tmp_buserror_address = addr_in;
478         }
479      }
480      else if ((m68k->mmu_tmp_sr & M68K_MMU_SR_WRITE_PROTECT) && !m68k->mmu_tmp_rw)
481      {
482         if (++m68k->mmu_tmp_buserror_occurred == 1)
483         {
484            m68k->mmu_tmp_buserror_address = addr_in;
485         }
486      }
313487
488      if (!m68k->mmu_tmp_buserror_occurred)
489      {
490         // we add only valid entries
491         pmmu_atc_add(m68k, addr_in, addr_out, fc);
492      }
493   }
494
314495   //logerror("PMMU: [%08x] => [%08x]\n", addr_in, addr_out);
315496
316497   return addr_out;
317498}
318499
319500/*
501    pmmu_translate_addr: perform 68851/68030-style PMMU address translation
502*/
503/*INLINE*/ static UINT32 pmmu_translate_addr(m68ki_cpu_core *m68k, UINT32 addr_in)
504{
505   UINT32 addr_out = pmmu_translate_addr_with_fc(m68k, addr_in, m68k->mmu_tmp_fc, 0);
506
507//   if (m68k->mmu_tmp_buserror_occurred > 0) {
508//      logerror("PMMU: pc=%08x sp=%08x va=%08x pa=%08x - invalid Table mode for level=%d (buserror %d)\n",
509//            REG_PPC, REG_A[7], addr_in, addr_out, m68k->mmu_tmp_sr & M68K_MMU_SR_LEVEL_3,
510//            m68k->mmu_tmp_buserror_occurred);
511//   }
512
513   return addr_out;
514}
515
516/*
320517    m68881_mmu_ops: COP 0 MMU opcode handling
321518
322519*/
r9742r9743
327524   UINT32 ea = m68k->ir & 0x3f;
328525   UINT64 temp64;
329526
527
330528   // catch the 2 "weird" encodings up front (PBcc)
331529   if ((m68k->ir & 0xffc0) == 0xf0c0)
332530   {
r9742r9743
353551               ptmp = ltmp;
354552               if (m68k->pmmu_enabled)
355553               {
356                  ptmp = pmmu_translate_addr(m68k, ltmp);
554                  ptmp = pmmu_translate_addr_with_fc(m68k, ltmp, modes & 0x07, 0);
357555               }
358556
359//                  logerror("680x0: PLOADing ATC with logical %08x => phys %08x\n", ltmp, ptmp);
360
361               pmmu_atc_add(m68k, ltmp, ptmp);
557                    logerror("680x0: PLOADing ATC with logical %08x => phys %08x\n", ltmp, ptmp);
558               // FIXME: rw bit?
559               pmmu_atc_add(m68k, ltmp, ptmp,  modes & 0x07);
362560               return;
363561            }
364562            else if ((modes & 0xe200) == 0x2000)   // PFLUSH
r9742r9743
383581            }
384582            else if ((modes & 0xe000) == 0x8000)   // PTEST
385583            {
386               logerror("680x0: unhandled PTEST\n");
584               UINT32 v_addr = DECODE_EA_32(m68k,  ea);
585               UINT32 p_addr;
586               UINT32 fc = modes & 0x1f;
587               switch (fc >> 3) {
588               case 0:
589                  fc = fc == 0 ? m68k->sfc :  m68k->dfc;
590                  break;
591               case 1:
592                  fc = REG_D[fc &7] &7;
593                  break;
594               case 2:
595                  fc &=7;
596                  break;
597               }
598
599               p_addr = pmmu_translate_addr_with_fc(m68k, v_addr, fc, 1);
600               m68k->mmu_sr = m68k->mmu_tmp_sr;
601
602//               logerror("PMMU: pc=%08x sp=%08x va=%08x pa=%08x PTEST fc=%x level=%x mmu_sr=%04x\n",
603//                     m68k->ppc, REG_A[7], v_addr, p_addr, fc, (modes >> 10) & 0x07, m68k->mmu_sr);
604
605               if (modes & 0x100)
606               {
607                  int areg = (modes >> 5) & 7;
608                  WRITE_EA_32(m68k, 0x08 | areg, p_addr);
609               }
387610               return;
388611            }
389612            else
r9742r9743
394617                  case 2:   // MC68881 form, FD never set
395618                     if (modes & 0x200)
396619                     {
397                        switch ((modes>>10) & 7)
398                        {
399                           case 0:   // translation control register
400                              WRITE_EA_32(m68k, ea, m68k->mmu_tc);
401                              break;
620                           switch ((modes>>10) & 0x3f)
621                           {
622                              case 0x02: // transparent translation register 0
623                                 WRITE_EA_32(m68k, ea, m68k->mmu_tt0);
624//                                 logerror("PMMU: pc=%x PMOVE from mmu_tt0=%08x\n", m68k->ppc, m68k->mmu_tt0);
625                                 break;
626                              case 0x03: // transparent translation register 1
627                                 WRITE_EA_32(m68k, ea, m68k->mmu_tt1);
628//                                 logerror("PMMU: pc=%x PMOVE from mmu_tt1=%08x\n", m68k->ppc, m68k->mmu_tt1);
629                                 break;
630                              case 0x10:   // translation control register
631                                 WRITE_EA_32(m68k, ea, m68k->mmu_tc);
632//                                 logerror("PMMU: pc=%x PMOVE from mmu_tc=%08x\n", m68k->ppc, m68k->mmu_tc);
633                                 break;
402634
403                           case 2: // supervisor root pointer
404                              WRITE_EA_64(m68k, ea, (UINT64)m68k->mmu_srp_limit<<32 | (UINT64)m68k->mmu_srp_aptr);
405                              break;
635                              case 0x12: // supervisor root pointer
636                                 WRITE_EA_64(m68k, ea, (UINT64)m68k->mmu_srp_limit<<32 | (UINT64)m68k->mmu_srp_aptr);
637//                                 logerror("PMMU: pc=%x PMOVE from SRP limit = %08x, aptr = %08x\n", REG_PPC, m68k->mmu_srp_limit, m68k->mmu_srp_aptr);
638                                 break;
406639
407                           case 3: // CPU root pointer
408                              WRITE_EA_64(m68k, ea, (UINT64)m68k->mmu_crp_limit<<32 | (UINT64)m68k->mmu_crp_aptr);
409                              break;
640                              case 0x13: // CPU root pointer
641                                 WRITE_EA_64(m68k, ea, (UINT64)m68k->mmu_crp_limit<<32 | (UINT64)m68k->mmu_crp_aptr);
642//                                 logerror("PMMU: pc=%x PMOVE from CRP limit = %08x, aptr = %08x\n", REG_PPC, m68k->mmu_crp_limit, m68k->mmu_crp_aptr);
643                                 break;
410644
411                           default:
412                              logerror("680x0: PMOVE from unknown MMU register %x, PC %x\n", (modes>>10) & 7, m68k->pc);
413                              break;
645                              default:
646                                 logerror("680x0: PMOVE from unknown MMU register %x, PC %x\n", (modes>>10) & 7, m68k->pc);
647                                 break;
414648                        }
649
415650                     }
416651                     else   // top 3 bits of modes: 010 for this, 011 for status, 000 for transparent translation regs
417652                     {
r9742r9743
464699                                    temp64 = READ_EA_64(m68k, ea);
465700                                    m68k->mmu_srp_limit = (temp64>>32) & 0xffffffff;
466701                                    m68k->mmu_srp_aptr = temp64 & 0xffffffff;
467//                                              logerror("PMMU: SRP limit = %08x aptr = %08x\n", m68k->mmu_srp_limit, m68k->mmu_srp_aptr);
702//                                    logerror("PMMU: SRP limit = %08x aptr = %08x\n", m68k->mmu_srp_limit, m68k->mmu_srp_aptr);
468703                                    if (!(modes & 0x100))
469704                                    {
470705                                       pmmu_atc_flush(m68k);
r9742r9743
475710                                    temp64 = READ_EA_64(m68k, ea);
476711                                    m68k->mmu_crp_limit = (temp64>>32) & 0xffffffff;
477712                                    m68k->mmu_crp_aptr = temp64 & 0xffffffff;
478//                                              logerror("PMMU: CRP limit = %08x aptr = %08x\n", m68k->mmu_crp_limit, m68k->mmu_crp_aptr);
713//                                    logerror("PMMU: CRP limit = %08x aptr = %08x\n", m68k->mmu_crp_limit, m68k->mmu_crp_aptr);
479714                                    if (!(modes & 0x100))
480715                                    {
481716                                       pmmu_atc_flush(m68k);
r9742r9743
501736                  case 3:   // MC68030 to/from status reg
502737                     if (modes & 0x200)
503738                     {
504                        WRITE_EA_32(m68k, ea, m68k->mmu_sr);
739                        WRITE_EA_16(m68k, ea, m68k->mmu_sr);
505740                     }
506741                     else
507742                     {
508                        m68k->mmu_sr = READ_EA_32(m68k, ea);
743                        m68k->mmu_sr = READ_EA_16(m68k, ea);
509744                     }
510745                     break;
511746
r9742r9743
532767
533768   addr_out = addr_in;
534769
535   // check if LC mode is enabled
770   // check if LC 24-bit mode is enabled - this simply blanks out A31, the V8 ignores A30-24 always
536771   if (m68k->hmmu_enabled == M68K_HMMU_ENABLE_LC)
537772   {
538      addr_in &= 0xffffff;
539      addr_out &= 0xffffff;
773      addr_out = addr_in & 0xffffff;
774   }
775   else if (m68k->hmmu_enabled == M68K_HMMU_ENABLE_II)   // the original II does a more complex translation
776   {
777      addr_out = addr_in & 0xffffff;
540778
541      if ((addr_in >= 0xa00000) && (addr_in <= 0xdfffff))
779      if ((addr_in >= 0x800000) && (addr_in <= 0x8fffff))
542780      {
543         addr_out |= 0x40000000;
781         addr_out |= 0x40000000;   // ROM
544782      }
545      if ((addr_in >= 0xe00000) && (addr_in <= 0xefffff))
783      else if ((addr_in >= 0x900000) && (addr_in <= 0xefffff))
546784      {
547         addr_out &= 0xfffff;
548         addr_out |= 0xfe000000;
785         addr_out |= 0xf0ff0000;   // NuBus
786         addr_out |= ((addr_in & 0xf00000)<<4);
549787      }
550788      else if (addr_in >= 0xf00000)
551789      {
552         addr_out |= 0x50000000;
790         addr_out |= 0x50000000;   // I/O
553791      }
792
793      // (RAM is at 0 and doesn't need special massaging)
554794   }
555795
556796   return addr_out;
src/emu/cpu/m68000/m68kdasm.c
r9742r9743
17191719
17201720   char mnemonic[40];
17211721   UINT32 w2, src, dst_reg;
1722   LIMIT_CPU_TYPES(M68030_PLUS);
1722   LIMIT_CPU_TYPES(M68020_PLUS);
17231723   w2 = read_imm_16();
17241724
17251725   src = (w2 >> 10) & 0x7;
src/emu/cpu/m68000/m68k_in.c
r9742r9743
894894
895895M68KMAKE_OP(040fpu0, 32, ., .)
896896{
897   if(CPU_TYPE_IS_030_PLUS(m68k->cpu_type))
897   if(m68k->has_fpu)
898898   {
899899      m68040_fpu_op0(m68k);
900900      return;
r9742r9743
905905
906906M68KMAKE_OP(040fpu1, 32, ., .)
907907{
908   if(CPU_TYPE_IS_030_PLUS(m68k->cpu_type))
908   if(m68k->has_fpu)
909909   {
910910      m68040_fpu_op1(m68k);
911911      return;
r9742r9743
87958795            m68k->instr_mode = INSTRUCTION_YES;
87968796            m68k->run_mode = RUN_MODE_NORMAL;
87978797            return;
8798         case 0x0a: /* Bus Error at instruction boundary */
8799            new_sr = m68ki_pull_16(m68k);
8800            new_pc = m68ki_pull_32(m68k);
8801            m68ki_fake_pull_16(m68k);   /* $06: format word */
8802            m68ki_fake_pull_16(m68k);   /* $08: internal register */
8803            m68ki_fake_pull_16(m68k);   /* $0a: special status word */
8804            m68ki_fake_pull_16(m68k);   /* $0c: instruction pipe stage c */
8805            m68ki_fake_pull_16(m68k);   /* $0e: instruction pipe stage b */
8806            m68ki_fake_pull_32(m68k);   /* $10: data fault address */
8807            m68ki_fake_pull_32(m68k);   /* $14: internal registers */
8808            m68ki_fake_pull_32(m68k);   /* $18: data output buffer */
8809            m68ki_fake_pull_32(m68k);   /* $1c: internal registers */
8810
8811            m68ki_jump(m68k, new_pc);
8812            m68ki_set_sr(m68k, new_sr);
8813            m68k->instr_mode = INSTRUCTION_YES;
8814            m68k->run_mode = RUN_MODE_NORMAL;
8815            return;
8816         case 0x0b: /* Bus Error - Instruction Execution in Progress */
8817            new_sr = m68ki_pull_16(m68k);
8818            new_pc = m68ki_pull_32(m68k);
8819            m68ki_fake_pull_16(m68k);   /* $06: format word */
8820            m68ki_fake_pull_16(m68k);   /* $08: internal register */
8821            m68ki_fake_pull_16(m68k);   /* $0a: special status word */
8822            m68ki_fake_pull_16(m68k);   /* $0c: instruction pipe stage c */
8823            m68ki_fake_pull_16(m68k);   /* $0e: instruction pipe stage b */
8824            m68ki_fake_pull_32(m68k);   /* $10: data fault address */
8825            m68ki_fake_pull_32(m68k);   /* $14: internal registers */
8826            m68ki_fake_pull_32(m68k);   /* $18: data output buffer */
8827            m68ki_fake_pull_32(m68k);   /* $1c: internal registers */
8828            m68ki_fake_pull_32(m68k);   /* $20:  */
8829            m68ki_fake_pull_32(m68k);   /* $24: stage B address */
8830            m68ki_fake_pull_32(m68k);   /* $28:  */
8831            m68ki_fake_pull_32(m68k);   /* $2c: data input buffer */
8832            m68ki_fake_pull_32(m68k);   /* $30:  */
8833            m68ki_fake_pull_16(m68k);   /* $34:  */
8834            m68ki_fake_pull_16(m68k);   /* $36: version #, internal information */
8835            m68ki_fake_pull_32(m68k);   /* $38:  */
8836            m68ki_fake_pull_32(m68k);   /* $3c:  */
8837            m68ki_fake_pull_32(m68k);   /* $40:  */
8838            m68ki_fake_pull_32(m68k);   /* $44:  */
8839            m68ki_fake_pull_32(m68k);   /* $48:  */
8840            m68ki_fake_pull_32(m68k);   /* $4c:  */
8841            m68ki_fake_pull_32(m68k);   /* $50:  */
8842            m68ki_fake_pull_32(m68k);   /* $54:  */
8843            m68ki_fake_pull_32(m68k);   /* $58:  */
8844
8845            m68ki_jump(m68k, new_pc);
8846            m68ki_set_sr(m68k, new_sr);
8847            m68k->instr_mode = INSTRUCTION_YES;
8848            m68k->run_mode = RUN_MODE_NORMAL;
8849            return;
87988850      }
87998851      /* Not handling long or short bus fault */
88008852      m68k->instr_mode = INSTRUCTION_YES;
src/emu/cpu/m68000/m68kcpu.c
r9742r9743
55#if 0
66static const char copyright_notice[] =
77"MUSASHI\n"
8"Version 4.60 (2010-03-12)\n"
8"Version 4.70 (2010-11-06)\n"
99"A portable Motorola M680x0 processor emulation engine.\n"
1010"Copyright Karl Stenerud.  All rights reserved.\n"
1111"\n"
r9742r9743
565565   {
566566      if ((space == ADDRESS_SPACE_PROGRAM) && (m68k->pmmu_enabled))
567567      {
568         *address = pmmu_translate_addr(m68k, *address);
568         // FIXME: mmu_tmp_sr will be overwritten in pmmu_translate_addr_with_fc
569         UINT16 mmu_tmp_sr = m68k->mmu_tmp_sr;
570//         UINT32 va=*address;
571
572         *address = pmmu_translate_addr_with_fc(m68k, *address, 4, 1);
573
574         if ((m68k->mmu_tmp_sr & M68K_MMU_SR_INVALID) != 0) {
575//            logerror("cpu_translate_m68k failed with mmu_sr=%04x va=%08x pa=%08x\n",m68k->mmu_tmp_sr,va ,*address);
576            *address = 0;
577         }
578
579         m68k->mmu_tmp_sr= mmu_tmp_sr;
569580      }
570581   }
571582   return TRUE;
r9742r9743
621632         /* Call external hook to peek at CPU */
622633         debugger_instruction_hook(device, REG_PC);
623634
635         // FIXME: remove this
636//         void apollo_debug_instruction(running_device *device);
637//         apollo_debug_instruction(device);
638
624639         /* Record previous program counter */
625640         REG_PPC = REG_PC;
626641
627         /* Read an instruction and call its handler */
628         m68k->ir = m68ki_read_imm_16(m68k);
629         m68ki_instruction_jump_table[m68k->ir](m68k);
630         m68k->remaining_cycles -= m68k->cyc_instruction[m68k->ir];
642         if (!m68k->pmmu_enabled)
643         {
644            /* Read an instruction and call its handler */
645            m68k->ir = m68ki_read_imm_16(m68k);
646            m68ki_instruction_jump_table[m68k->ir](m68k);
647            m68k->remaining_cycles -= m68k->cyc_instruction[m68k->ir];
648         }
649         else
650         {
651            // save CPU address registers values at start of instruction
652            int i;
653            UINT32 tmp_dar[16];
631654
655            for (i = 15; i >= 0; i--)
656            {
657               tmp_dar[i] = REG_DA[i];
658            }
659
660            m68k->mmu_tmp_buserror_occurred = 0;
661
662            /* Read an instruction and call its handler */
663            m68k->ir = m68ki_read_imm_16(m68k);
664
665            if (!m68k->mmu_tmp_buserror_occurred)
666            {
667               m68ki_instruction_jump_table[m68k->ir](m68k);
668               m68k->remaining_cycles -= m68k->cyc_instruction[m68k->ir];
669            }
670
671            if (m68k->mmu_tmp_buserror_occurred)
672            {
673               UINT32 sr;
674
675//               const char * disassemble(m68ki_cpu_core *m68k, offs_t pc);
676//               logerror(
677//                     "PMMU: pc=%08x sp=%08x va=%08x bus error: %s\n",
678//                     REG_PPC, REG_A[7], m68k->mmu_tmp_buserror_address,
679//                     (m68k->mmu_tmp_buserror_address == REG_PPC) ? "-"
680//                           : disassemble(m68k, REG_PPC));
681
682               m68k->mmu_tmp_buserror_occurred = 0;
683
684               // restore cpu address registers to value at start of instruction
685               for (i = 15; i >= 0; i--)
686               {
687                  if (REG_DA[i] != tmp_dar[i])
688                  {
689//                     logerror("PMMU: pc=%08x sp=%08x bus error: fixed %s[%d]: %08x -> %08x\n",
690//                           REG_PPC, REG_A[7], i < 8 ? "D" : "A", i & 7, REG_DA[i], tmp_dar[i]);
691                     REG_DA[i] = tmp_dar[i];
692                  }
693               }
694
695               sr = m68ki_init_exception(m68k);
696
697               m68k->run_mode = RUN_MODE_BERR_AERR_RESET;
698
699               if (!CPU_TYPE_IS_020_PLUS(m68k->cpu_type))
700               {
701                  /* Note: This is implemented for 68000 only! */
702                  m68ki_stack_frame_buserr(m68k, sr);
703               }
704               else if (m68k->mmu_tmp_buserror_address == REG_PPC)
705               {
706                  m68ki_stack_frame_1010(m68k, sr, EXCEPTION_BUS_ERROR, REG_PPC, m68k->mmu_tmp_buserror_address);
707               }
708               else
709               {
710                  m68ki_stack_frame_1011(m68k, sr, EXCEPTION_BUS_ERROR, REG_PPC, m68k->mmu_tmp_buserror_address);
711               }
712
713               m68ki_jump_vector(m68k, EXCEPTION_BUS_ERROR);
714
715               // TODO:
716               /* Use up some clock cycles and undo the instruction's cycles */
717               // m68k->remaining_cycles -= m68k->cyc_exception[EXCEPTION_BUS_ERROR] - m68k->cyc_instruction[m68k->ir];
718            }
719         }
720
632721         /* Trace m68k_exception, if necessary */
633722         m68ki_exception_if_trace(); /* auto-disable (see m68kcpu.h) */
634723      } while (m68k->remaining_cycles > 0);
r9742r9743
693782   m68k->pmmu_enabled = 0;
694783   m68k->hmmu_enabled = 0;
695784
785   m68k->mmu_tc = 0;
786   m68k->mmu_tt0 = 0;
787   m68k->mmu_tt1 = 0;
788
696789   /* Clear all stop levels and eat up all remaining cycles */
697790   m68k->stopped = 0;
698791   if (m68k->remaining_cycles > 0)
r9742r9743
9521045      case DEVINFO_STR_FAMILY:               strcpy(info->s, "Motorola 68K");      break;
9531046      case DEVINFO_STR_VERSION:               strcpy(info->s, "4.60");            break;
9541047      case DEVINFO_STR_SOURCE_FILE:                  strcpy(info->s, __FILE__);            break;
955      case DEVINFO_STR_CREDITS:               strcpy(info->s, "Copyright Karl Stenerud. All rights reserved. (2.1 fixes HJB, FPU+MMU by RB)"); break;
1048      case DEVINFO_STR_CREDITS:               strcpy(info->s, "Copyright Karl Stenerud. All rights reserved. (2.1 fixes HJB, FPU+MMU by RB+HO)"); break;
9561049   }
9571050}
9581051
r9742r9743
10551148   if (m_cpustate->pmmu_enabled)
10561149   {
10571150      address = pmmu_translate_addr(m_cpustate, address);
1151      if (m_cpustate->mmu_tmp_buserror_occurred) {
1152         return ~0;
1153      }
10581154   }
10591155
10601156   return m_space->read_byte(address);
r9742r9743
10651161   if (m_cpustate->pmmu_enabled)
10661162   {
10671163      address = pmmu_translate_addr(m_cpustate, address);
1164      if (m_cpustate->mmu_tmp_buserror_occurred) {
1165         return;
1166      }
10681167   }
10691168
10701169   m_space->write_byte(address, data);
r9742r9743
10751174   if (m_cpustate->pmmu_enabled)
10761175   {
10771176      address = pmmu_translate_addr(m_cpustate, address);
1177      if (m_cpustate->mmu_tmp_buserror_occurred) {
1178         return ~0;
1179      }
10781180   }
10791181
10801182   return m_direct->read_decrypted_word((address) ^ m_cpustate->memory.opcode_xor);
r9742r9743
10871189
10881190   if (m_cpustate->pmmu_enabled)
10891191   {
1090      address = pmmu_translate_addr(m_cpustate, address);
1192      UINT32 address0 = pmmu_translate_addr(m_cpustate, address);
1193      if (m_cpustate->mmu_tmp_buserror_occurred) {
1194         return ~0;
1195      } else if (!(address & 1)) {
1196         return m_space->read_word(address0);
1197      } else {
1198         UINT32 address1 = pmmu_translate_addr(m_cpustate, address + 1);
1199         if (m_cpustate->mmu_tmp_buserror_occurred) {
1200            return ~0;
1201         } else {
1202            result = m_space->read_byte(address0) << 8;
1203            return result | m_space->read_byte(address1);
1204         }
1205      }
10911206   }
10921207
10931208   if (!(address & 1))
r9742r9743
11011216{
11021217   if (m_cpustate->pmmu_enabled)
11031218   {
1104      address = pmmu_translate_addr(m_cpustate, address);
1219      UINT32 address0 = pmmu_translate_addr(m_cpustate, address);
1220      if (m_cpustate->mmu_tmp_buserror_occurred) {
1221         return;
1222      } else if (!(address & 1)) {
1223         m_space->write_word(address0, data);
1224         return;
1225      } else {
1226         UINT32 address1 = pmmu_translate_addr(m_cpustate, address + 1);
1227         if (m_cpustate->mmu_tmp_buserror_occurred) {
1228            return;
1229         } else {
1230            m_space->write_byte(address0, data >> 8);
1231            m_space->write_byte(address1, data);
1232            return;
1233         }
1234      }
11051235   }
11061236
11071237   if (!(address & 1))
r9742r9743
11201250
11211251   if (m_cpustate->pmmu_enabled)
11221252   {
1123      address = pmmu_translate_addr(m_cpustate, address);
1253      UINT32 address0 = pmmu_translate_addr(m_cpustate, address);
1254      if (m_cpustate->mmu_tmp_buserror_occurred) {
1255         return ~0;
1256      } else if ((address +3) & 0xfc) {
1257         // not at page boundary; use default code
1258         address = address0;
1259      } else if (!(address & 3)) { // 0
1260         return m_space->read_dword(address0);
1261      } else {
1262         UINT32 address2 = pmmu_translate_addr(m_cpustate, address+2);
1263         if (m_cpustate->mmu_tmp_buserror_occurred) {
1264            return ~0;
1265         } else if (!(address & 1)) { // 2
1266            result = m_space->read_word(address0) << 16;
1267            return result | m_space->read_word(address2);
1268         } else {
1269            UINT32 address1 = pmmu_translate_addr(m_cpustate, address+1);
1270            UINT32 address3 = pmmu_translate_addr(m_cpustate, address+3);
1271            if (m_cpustate->mmu_tmp_buserror_occurred) {
1272               return ~0;
1273            } else {
1274               result = m_space->read_byte(address0) << 24;
1275               result |= m_space->read_word(address1) << 8;
1276               return result | m_space->read_byte(address3);
1277            }
1278         }
1279      }
11241280   }
11251281
11261282   if (!(address & 3))
r9742r9743
11401296{
11411297   if (m_cpustate->pmmu_enabled)
11421298   {
1143      address = pmmu_translate_addr(m_cpustate, address);
1299      UINT32 address0 = pmmu_translate_addr(m_cpustate, address);
1300      if (m_cpustate->mmu_tmp_buserror_occurred) {
1301         return;
1302      } else if ((address +3) & 0xfc) {
1303         // not at page boundary; use default code
1304         address = address0;
1305      } else if (!(address & 3)) { // 0
1306         m_space->write_dword(address0, data);
1307         return;
1308      } else {
1309         UINT32 address2 = pmmu_translate_addr(m_cpustate, address+2);
1310         if (m_cpustate->mmu_tmp_buserror_occurred) {
1311            return;
1312         } else if (!(address & 1)) { // 2
1313            m_space->write_word(address0, data >> 16);
1314            m_space->write_word(address2, data);
1315            return;
1316         } else {
1317            UINT32 address1 = pmmu_translate_addr(m_cpustate, address+1);
1318            UINT32 address3 = pmmu_translate_addr(m_cpustate, address+3);
1319            if (m_cpustate->mmu_tmp_buserror_occurred) {
1320               return;
1321            } else {
1322               m_space->write_byte(address0, data >> 24);
1323               m_space->write_word(address1, data >> 8);
1324               m_space->write_byte(address3, data);
1325               return;
1326            }
1327         }
1328      }
11441329   }
11451330
11461331   if (!(address & 3))
r9742r9743
14131598   m68k->cyc_reset        = 132;
14141599   m68k->has_pmmu          = 0;
14151600   m68k->has_hmmu          = 0;
1601   m68k->has_fpu          = 0;
14161602
14171603   define_state(device);
14181604}
r9742r9743
14621648   m68k->cyc_shift        = 1;
14631649   m68k->cyc_reset        = 132;
14641650   m68k->has_pmmu          = 0;
1651   m68k->has_fpu          = 0;
14651652
14661653   define_state(device);
14671654}
r9742r9743
15151702   m68k->cyc_shift        = 1;
15161703   m68k->cyc_reset        = 130;
15171704   m68k->has_pmmu          = 0;
1705   m68k->has_fpu          = 0;
15181706
15191707   define_state(device);
15201708}
r9742r9743
15971785   CPU_INIT_CALL(m68020);
15981786
15991787   m68k->has_pmmu          = 1;
1788   m68k->has_fpu          = 1;
1789
16001790// hack alert: we use placement new to ensure we are properly initialized
16011791// because we live in the device state which is allocated as bytes
16021792// remove me when we have a real C++ device
r9742r9743
16781868   m68k->cyc_shift        = 0;
16791869   m68k->cyc_reset        = 518;
16801870   m68k->has_pmmu          = 0;
1871   m68k->has_fpu          = 0;
16811872
16821873   define_state(device);
16831874}
r9742r9743
17291920   m68k->cyc_shift        = 0;
17301921   m68k->cyc_reset        = 518;
17311922   m68k->has_pmmu          = 1;
1923   m68k->has_fpu          = 1;
17321924
17331925   define_state(device);
17341926}
r9742r9743
17861978   m68k->cyc_shift        = 0;
17871979   m68k->cyc_reset        = 518;
17881980   m68k->has_pmmu          = 0;      /* EC030 lacks the PMMU and is effectively a die-shrink 68020 */
1981   m68k->has_fpu          = 1;
17891982
17901983   define_state(device);
17911984}
r9742r9743
18342027   m68k->cyc_shift        = 0;
18352028   m68k->cyc_reset        = 518;
18362029   m68k->has_pmmu          = 1;
2030   m68k->has_fpu          = 1;
18372031
18382032   define_state(device);
18392033}
r9742r9743
18902084   m68k->cyc_shift        = 0;
18912085   m68k->cyc_reset        = 518;
18922086   m68k->has_pmmu          = 0;
2087   m68k->has_fpu          = 0;
18932088
18942089   define_state(device);
18952090}
r9742r9743
19382133   m68k->cyc_shift        = 0;
19392134   m68k->cyc_reset        = 518;
19402135   m68k->has_pmmu          = 1;
2136   m68k->has_fpu          = 0;
19412137
19422138   define_state(device);
19432139}

Previous 15994 Revisions Next


© 1998-2018 The MESS Team