src/emu/cpu/m68000/m68kfpu.c
| r9742 | r9743 | |
| 366 | 366 | UINT32 ea = REG_A[reg]; |
| 367 | 367 | return m68ki_read_8(m68k, ea); |
| 368 | 368 | } |
| 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 | } |
| 369 | 379 | case 5: // (d16, An) |
| 370 | 380 | { |
| 371 | 381 | UINT32 ea = EA_AY_DI_8(m68k); |
| r9742 | r9743 | |
| 392 | 402 | UINT32 ea = (d1 << 16) | d2; |
| 393 | 403 | return m68ki_read_8(m68k, ea); |
| 394 | 404 | } |
| 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 | } |
| 395 | 415 | case 4: // #<data> |
| 396 | 416 | { |
| 397 | 417 | return OPER_I_8(m68k); |
| r9742 | r9743 | |
| 422 | 442 | UINT32 ea = REG_A[reg]; |
| 423 | 443 | return m68ki_read_16(m68k, ea); |
| 424 | 444 | } |
| 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 | } |
| 425 | 455 | case 5: // (d16, An) |
| 426 | 456 | { |
| 427 | 457 | UINT32 ea = EA_AY_DI_16(m68k); |
| r9742 | r9743 | |
| 448 | 478 | UINT32 ea = (d1 << 16) | d2; |
| 449 | 479 | return m68ki_read_16(m68k, ea); |
| 450 | 480 | } |
| 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 | } |
| 451 | 491 | case 4: // #<data> |
| 452 | 492 | { |
| 453 | 493 | return OPER_I_16(m68k); |
| r9742 | r9743 | |
| 484 | 524 | UINT32 ea = EA_AY_PI_32(m68k); |
| 485 | 525 | return m68ki_read_32(m68k, ea); |
| 486 | 526 | } |
| 527 | case 4: // -(An) |
| 528 | { |
| 529 | UINT32 ea = EA_AY_PD_32(m68k); |
| 530 | return m68ki_read_32(m68k, ea); |
| 531 | } |
| 487 | 532 | case 5: // (d16, An) |
| 488 | 533 | { |
| 489 | 534 | UINT32 ea = EA_AY_DI_32(m68k); |
| r9742 | r9743 | |
| 515 | 560 | UINT32 ea = EA_PCDI_32(m68k); |
| 516 | 561 | return m68ki_read_32(m68k, ea); |
| 517 | 562 | } |
| 563 | case 3: // (PC) + (Xn) + d8 |
| 564 | { |
| 565 | UINT32 ea = EA_PCIX_32(m68k); |
| 566 | return m68ki_read_32(m68k, ea); |
| 567 | } |
| 518 | 568 | case 4: // #<data> |
| 519 | 569 | { |
| 520 | 570 | return OPER_I_32(m68k); |
| r9742 | r9743 | |
| 551 | 601 | h2 = m68ki_read_32(m68k, ea+4); |
| 552 | 602 | return (UINT64)(h1) << 32 | (UINT64)(h2); |
| 553 | 603 | } |
| 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 | } |
| 554 | 612 | case 5: // (d16, An) |
| 555 | 613 | { |
| 556 | 614 | UINT32 ea = EA_AY_DI_32(m68k); |
| r9742 | r9743 | |
| 558 | 616 | h2 = m68ki_read_32(m68k, ea+4); |
| 559 | 617 | return (UINT64)(h1) << 32 | (UINT64)(h2); |
| 560 | 618 | } |
| 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 | } |
| 561 | 626 | case 7: |
| 562 | 627 | { |
| 563 | 628 | switch (reg) |
| 564 | 629 | { |
| 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 | } |
| 565 | 644 | case 4: // #<data> |
| 566 | 645 | { |
| 567 | 646 | h1 = OPER_I_32(m68k); |
| r9742 | r9743 | |
| 608 | 687 | fpr = load_extended_float80(m68k, ea); |
| 609 | 688 | break; |
| 610 | 689 | } |
| 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 | } |
| 611 | 711 | |
| 612 | 712 | case 7: // extended modes |
| 613 | 713 | { |
| r9742 | r9743 | |
| 910 | 1010 | m68ki_write_32(m68k, ea+4, (UINT32)(data)); |
| 911 | 1011 | break; |
| 912 | 1012 | } |
| 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 | } |
| 913 | 1021 | case 4: // -(An) |
| 914 | 1022 | { |
| 915 | 1023 | UINT32 ea; |
| r9742 | r9743 | |
| 926 | 1034 | m68ki_write_32(m68k, ea+4, (UINT32)(data)); |
| 927 | 1035 | break; |
| 928 | 1036 | } |
| 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 | } |
| 929 | 1068 | 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); |
| 930 | 1069 | } |
| 931 | 1070 | } |
| r9742 | r9743 | |
| 1154 | 1293 | case 0x00: // FMOVE |
| 1155 | 1294 | { |
| 1156 | 1295 | REG_FP[dst] = source; |
| 1296 | SET_CONDITION_CODES(m68k, REG_FP[dst]); |
| 1157 | 1297 | m68k->remaining_cycles -= 4; |
| 1158 | 1298 | break; |
| 1159 | 1299 | } |
| r9742 | r9743 | |
| 1352 | 1492 | int mode = (w2 >> 11) & 0x3; |
| 1353 | 1493 | int reglist = w2 & 0xff; |
| 1354 | 1494 | |
| 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 | |
| 1355 | 1506 | if (dir) // From FP regs to mem |
| 1356 | 1507 | { |
| 1357 | 1508 | switch (mode) |
| 1358 | 1509 | { |
| 1359 | | case 0: // Static register list, predecrement addressing mode |
| 1510 | case 0: // Static register list, predecrement or control addressing mode |
| 1360 | 1511 | { |
| 1361 | 1512 | for (i=0; i < 8; i++) |
| 1362 | 1513 | { |
| 1363 | 1514 | if (reglist & (1 << i)) |
| 1364 | 1515 | { |
| 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 | |
| 1366 | 1528 | m68k->remaining_cycles -= 2; |
| 1367 | 1529 | } |
| 1368 | 1530 | } |
| r9742 | r9743 | |
| 1376 | 1538 | { |
| 1377 | 1539 | switch (mode) |
| 1378 | 1540 | { |
| 1379 | | case 2: // Static register list, postincrement addressing mode |
| 1541 | case 2: // Static register list, postincrement or control addressing mode |
| 1380 | 1542 | { |
| 1381 | 1543 | for (i=0; i < 8; i++) |
| 1382 | 1544 | { |
| 1383 | 1545 | if (reglist & (1 << i)) |
| 1384 | 1546 | { |
| 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 | } |
| 1386 | 1558 | m68k->remaining_cycles -= 2; |
| 1387 | 1559 | } |
| 1388 | 1560 | } |
| r9742 | r9743 | |
| 1472 | 1644 | break; |
| 1473 | 1645 | } |
| 1474 | 1646 | |
| 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 | |
| 1475 | 1660 | case 2: // FBcc disp16 |
| 1476 | 1661 | { |
| 1477 | 1662 | fbcc16(m68k); |
| r9742 | r9743 | |
| 1630 | 1815 | } |
| 1631 | 1816 | break; |
| 1632 | 1817 | |
| 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 | |
| 1633 | 1860 | default: |
| 1634 | 1861 | fatalerror("M68kFPU: FRESTORE unhandled mode %d reg %d at %x\n", mode, reg, REG_PC); |
| 1635 | 1862 | } |
src/emu/cpu/m68000/m68kcpu.h
| r9742 | r9743 | |
| 636 | 636 | int has_hmmu; /* Indicates if an Apple HMMU is available in place of the 68851 (020 only) */ |
| 637 | 637 | int pmmu_enabled; /* Indicates if the PMMU is enabled */ |
| 638 | 638 | 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) */ |
| 639 | 640 | int fpu_just_reset; /* Indicates the FPU was just reset */ |
| 640 | 641 | |
| 641 | 642 | /* Clocks required for instructions / exceptions */ |
| r9742 | r9743 | |
| 699 | 700 | UINT32 mmu_atc_tag[MMU_ATC_ENTRIES], mmu_atc_data[MMU_ATC_ENTRIES]; |
| 700 | 701 | UINT32 mmu_atc_rr; |
| 701 | 702 | 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 */ |
| 702 | 709 | }; |
| 703 | 710 | |
| 704 | 711 | |
| r9742 | r9743 | |
| 807 | 814 | INLINE void m68ki_stack_frame_0001(m68ki_cpu_core *m68k, UINT32 pc, UINT32 sr, UINT32 vector); |
| 808 | 815 | INLINE void m68ki_stack_frame_0010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector); |
| 809 | 816 | INLINE void m68ki_stack_frame_1000(m68ki_cpu_core *m68k, UINT32 pc, UINT32 sr, UINT32 vector); |
| 810 | | INLINE void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc); |
| 811 | | INLINE void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc); |
| 817 | INLINE void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address); |
| 818 | INLINE void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address); |
| 812 | 819 | |
| 813 | 820 | INLINE void m68ki_exception_trap(m68ki_cpu_core *m68k, UINT32 vector); |
| 814 | 821 | INLINE void m68ki_exception_trapN(m68ki_cpu_core *m68k, UINT32 vector); |
| r9742 | r9743 | |
| 882 | 889 | { |
| 883 | 890 | UINT32 result; |
| 884 | 891 | |
| 892 | m68k->mmu_tmp_fc = m68k->s_flag | FUNCTION_CODE_USER_PROGRAM; |
| 893 | m68k->mmu_tmp_rw = 1; |
| 894 | |
| 885 | 895 | m68ki_check_address_error(m68k, REG_PC, MODE_READ, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */ |
| 886 | 896 | |
| 887 | 897 | if(REG_PC != m68k->pref_addr) |
| 888 | 898 | { |
| 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; |
| 891 | 901 | } |
| 892 | 902 | result = MASK_OUT_ABOVE_16(m68k->pref_data); |
| 893 | 903 | 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 | |
| 896 | 912 | return result; |
| 897 | 913 | } |
| 898 | 914 | |
| r9742 | r9743 | |
| 900 | 916 | { |
| 901 | 917 | UINT32 temp_val; |
| 902 | 918 | |
| 919 | m68k->mmu_tmp_fc = m68k->s_flag | FUNCTION_CODE_USER_PROGRAM; |
| 920 | m68k->mmu_tmp_rw = 1; |
| 921 | |
| 903 | 922 | m68ki_check_address_error(m68k, REG_PC, MODE_READ, m68k->s_flag | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */ |
| 904 | 923 | |
| 905 | 924 | if(REG_PC != m68k->pref_addr) |
| r9742 | r9743 | |
| 914 | 933 | |
| 915 | 934 | temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | MASK_OUT_ABOVE_16(m68k->pref_data)); |
| 916 | 935 | 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; |
| 919 | 938 | |
| 920 | 939 | return temp_val; |
| 921 | 940 | } |
| r9742 | r9743 | |
| 932 | 951 | */ |
| 933 | 952 | INLINE UINT32 m68ki_read_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc) |
| 934 | 953 | { |
| 954 | m68k->mmu_tmp_fc = fc; |
| 955 | m68k->mmu_tmp_rw = 1; |
| 935 | 956 | return m68k->memory.read8(address); |
| 936 | 957 | } |
| 937 | 958 | INLINE UINT32 m68ki_read_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc) |
| r9742 | r9743 | |
| 940 | 961 | { |
| 941 | 962 | m68ki_check_address_error(m68k, address, MODE_READ, fc); |
| 942 | 963 | } |
| 964 | m68k->mmu_tmp_fc = fc; |
| 965 | m68k->mmu_tmp_rw = 1; |
| 943 | 966 | return m68k->memory.read16(address); |
| 944 | 967 | } |
| 945 | 968 | INLINE UINT32 m68ki_read_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc) |
| r9742 | r9743 | |
| 948 | 971 | { |
| 949 | 972 | m68ki_check_address_error(m68k, address, MODE_READ, fc); |
| 950 | 973 | } |
| 974 | m68k->mmu_tmp_fc = fc; |
| 975 | m68k->mmu_tmp_rw = 1; |
| 951 | 976 | return m68k->memory.read32(address); |
| 952 | 977 | } |
| 953 | 978 | |
| 954 | 979 | INLINE void m68ki_write_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value) |
| 955 | 980 | { |
| 981 | m68k->mmu_tmp_fc = fc; |
| 982 | m68k->mmu_tmp_rw = 0; |
| 956 | 983 | m68k->memory.write8(address, value); |
| 957 | 984 | } |
| 958 | 985 | INLINE void m68ki_write_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value) |
| r9742 | r9743 | |
| 961 | 988 | { |
| 962 | 989 | m68ki_check_address_error(m68k, address, MODE_WRITE, fc); |
| 963 | 990 | } |
| 991 | m68k->mmu_tmp_fc = fc; |
| 992 | m68k->mmu_tmp_rw = 0; |
| 964 | 993 | m68k->memory.write16(address, value); |
| 965 | 994 | } |
| 966 | 995 | INLINE void m68ki_write_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value) |
| r9742 | r9743 | |
| 969 | 998 | { |
| 970 | 999 | m68ki_check_address_error(m68k, address, MODE_WRITE, fc); |
| 971 | 1000 | } |
| 1001 | m68k->mmu_tmp_fc = fc; |
| 1002 | m68k->mmu_tmp_rw = 0; |
| 972 | 1003 | m68k->memory.write32(address, value); |
| 973 | 1004 | } |
| 974 | 1005 | |
| r9742 | r9743 | |
| 983 | 1014 | { |
| 984 | 1015 | m68ki_check_address_error(m68k, address, MODE_WRITE, fc); |
| 985 | 1016 | } |
| 1017 | m68k->mmu_tmp_fc = fc; |
| 1018 | m68k->mmu_tmp_rw = 0; |
| 986 | 1019 | m68k->memory.write16(address+2, value>>16); |
| 987 | 1020 | m68k->memory.write16(address, value&0xffff); |
| 988 | 1021 | } |
| r9742 | r9743 | |
| 1483 | 1516 | * if the error happens at an instruction boundary. |
| 1484 | 1517 | * PC stacked is address of next instruction. |
| 1485 | 1518 | */ |
| 1486 | | void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc) |
| 1519 | void m68ki_stack_frame_1010(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address) |
| 1487 | 1520 | { |
| 1488 | 1521 | /* INTERNAL REGISTER */ |
| 1489 | 1522 | m68ki_push_16(m68k, 0); |
| r9742 | r9743 | |
| 1501 | 1534 | m68ki_push_16(m68k, 0); |
| 1502 | 1535 | |
| 1503 | 1536 | /* DATA CYCLE FAULT ADDRESS (2 words) */ |
| 1504 | | m68ki_push_32(m68k, 0); |
| 1537 | m68ki_push_32(m68k, fault_address); |
| 1505 | 1538 | |
| 1506 | 1539 | /* INSTRUCTION PIPE STAGE B */ |
| 1507 | 1540 | m68ki_push_16(m68k, 0); |
| r9742 | r9743 | |
| 1530 | 1563 | * if the error happens during instruction execution. |
| 1531 | 1564 | * PC stacked is address of instruction in progress. |
| 1532 | 1565 | */ |
| 1533 | | void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc) |
| 1566 | void m68ki_stack_frame_1011(m68ki_cpu_core *m68k, UINT32 sr, UINT32 vector, UINT32 pc, UINT32 fault_address) |
| 1534 | 1567 | { |
| 1535 | 1568 | /* INTERNAL REGISTERS (18 words) */ |
| 1536 | 1569 | m68ki_push_32(m68k, 0); |
| r9742 | r9743 | |
| 1557 | 1590 | m68ki_push_32(m68k, 0); |
| 1558 | 1591 | |
| 1559 | 1592 | /* STAGE B ADDRESS (2 words) */ |
| 1560 | | m68ki_push_32(m68k, 0); |
| 1593 | m68ki_push_32(m68k, fault_address); |
| 1561 | 1594 | |
| 1562 | 1595 | /* INTERNAL REGISTER (4 words) */ |
| 1563 | 1596 | m68ki_push_32(m68k, 0); |
src/emu/cpu/m68000/m68kmmu.h
| r9742 | r9743 | |
| 8 | 8 | Visit http://mamedev.org for licensing and usage restrictions. |
| 9 | 9 | */ |
| 10 | 10 | |
| 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 | |
| 11 | 49 | /* decodes the effective address */ |
| 12 | 50 | static UINT32 DECODE_EA_32(m68ki_cpu_core *m68k, int ea) |
| 13 | 51 | { |
| r9742 | r9743 | |
| 68 | 106 | /* |
| 69 | 107 | pmmu_atc_add: adds this address to the ATC |
| 70 | 108 | */ |
| 71 | | void pmmu_atc_add(m68ki_cpu_core *m68k, UINT32 logical, UINT32 physical) |
| 109 | void pmmu_atc_add(m68ki_cpu_core *m68k, UINT32 logical, UINT32 physical, int fc) |
| 72 | 110 | { |
| 73 | | int i, found, curfc; |
| 111 | int i, found; |
| 74 | 112 | |
| 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; |
| 77 | 117 | |
| 78 | 118 | // first see if this is already in the cache |
| 79 | 119 | for (i = 0; i < MMU_ATC_ENTRIES; i++) |
| 80 | 120 | { |
| 81 | 121 | // 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) |
| 83 | 123 | { |
| 84 | 124 | return; |
| 85 | 125 | } |
| r9742 | r9743 | |
| 89 | 129 | found = -1; |
| 90 | 130 | for (i = 0; i < MMU_ATC_ENTRIES; i++) |
| 91 | 131 | { |
| 92 | | if (!(m68k->mmu_atc_tag[i] & 0x80000000)) |
| 132 | if (!(m68k->mmu_atc_tag[i] & M68K_MMU_ATC_VALID)) |
| 93 | 133 | { |
| 94 | 134 | found = i; |
| 95 | 135 | break; |
| r9742 | r9743 | |
| 108 | 148 | } |
| 109 | 149 | |
| 110 | 150 | // 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 | } |
| 114 | 159 | } |
| 115 | 160 | |
| 116 | 161 | /* |
| r9742 | r9743 | |
| 121 | 166 | void pmmu_atc_flush(m68ki_cpu_core *m68k) |
| 122 | 167 | { |
| 123 | 168 | int i; |
| 169 | // logerror("ATC flush: pc=%08x\n", REG_PPC); |
| 124 | 170 | |
| 125 | 171 | for (i = 0; i < MMU_ATC_ENTRIES; i++) |
| 126 | 172 | { |
| r9742 | r9743 | |
| 130 | 176 | m68k->mmu_atc_rr = 0; |
| 131 | 177 | } |
| 132 | 178 | |
| 179 | |
| 180 | INLINE 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 | |
| 202 | INLINE 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 | |
| 133 | 227 | /* |
| 134 | | pmmu_translate_addr: perform 68851/68030-style PMMU address translation |
| 228 | pmmu_translate_addr_with_fc: perform 68851/68030-style PMMU address translation |
| 135 | 229 | */ |
| 136 | | INLINE 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) |
| 137 | 231 | { |
| 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; |
| 142 | 237 | // int verbose = 0; |
| 143 | 238 | |
| 239 | // static UINT32 pmmu_access_count = 0; |
| 240 | // static UINT32 pmmu_atc_count = 0; |
| 241 | |
| 144 | 242 | resolved = 0; |
| 145 | 243 | addr_out = addr_in; |
| 244 | m68k->mmu_tmp_sr = 0; |
| 146 | 245 | |
| 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 | } |
| 149 | 250 | |
| 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 | |
| 150 | 272 | // first see if this is already in the ATC |
| 151 | 273 | for (i = 0; i < MMU_ATC_ENTRIES; i++) |
| 152 | 274 | { |
| 153 | 275 | // 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) |
| 155 | 277 | { |
| 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 | } |
| 159 | 296 | } |
| 160 | 297 | } |
| 161 | 298 | |
| 162 | | // if (addr_in == 0x5fa04c) verbose = 1; |
| 163 | | |
| 164 | 299 | // 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)) |
| 166 | 301 | { |
| 167 | 302 | root_aptr = m68k->mmu_srp_aptr; |
| 168 | 303 | root_limit = m68k->mmu_srp_limit; |
| r9742 | r9743 | |
| 173 | 308 | root_limit = m68k->mmu_crp_limit; |
| 174 | 309 | } |
| 175 | 310 | |
| 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; |
| 181 | 317 | |
| 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); |
| 183 | 319 | |
| 184 | 320 | // get table A offset |
| 185 | 321 | tofs = (addr_in<<is)>>(32-abits); |
| 322 | tptr = root_aptr & 0xfffffff0; |
| 186 | 323 | |
| 187 | 324 | // find out what format table A is |
| 188 | | switch (root_limit & 3) |
| 325 | switch (root_limit & M68K_MMU_DF_DT) |
| 189 | 326 | { |
| 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; |
| 196 | 330 | |
| 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 |
| 198 | 337 | 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; |
| 202 | 341 | // if (verbose) logerror("PMMU: addr %08x entry %08x mode %x tofs %x\n", addr_in, tbl_entry, tamode, tofs); |
| 203 | 342 | break; |
| 204 | 343 | |
| 205 | | case 3: // valid 8 byte descriptors |
| 344 | case M68K_MMU_DF_DT3: // valid 8 byte descriptors |
| 206 | 345 | 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; |
| 211 | 349 | // if (verbose) logerror("PMMU: addr %08x entry %08x entry2 %08x mode %x tofs %x\n", addr_in, tbl_entry, tbl_entry2, tamode, tofs); |
| 212 | 350 | break; |
| 213 | 351 | } |
| 214 | 352 | |
| 353 | last_entry_ptr = tptr + tofs; |
| 354 | |
| 215 | 355 | // get table B offset and pointer |
| 216 | 356 | tofs = (addr_in<<(is+abits))>>(32-bbits); |
| 217 | 357 | tptr = tbl_entry & 0xfffffff0; |
| r9742 | r9743 | |
| 219 | 359 | // find out what format table B is, if any |
| 220 | 360 | switch (tamode) |
| 221 | 361 | { |
| 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; |
| 224 | 367 | break; |
| 225 | 368 | |
| 226 | | case 2: // 4-byte table B descriptor |
| 369 | case M68K_MMU_DF_DT2: // 4-byte table B descriptor |
| 227 | 370 | tofs *= 4; |
| 228 | 371 | // 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; |
| 231 | 374 | // if (verbose) logerror("PMMU: addr %08x entry %08x mode %x tofs %x\n", addr_in, tbl_entry, tbmode, tofs); |
| 232 | 375 | break; |
| 233 | 376 | |
| 234 | | case 3: // 8-byte table B descriptor |
| 377 | case M68K_MMU_DF_DT3: // 8-byte table B descriptor |
| 235 | 378 | tofs *= 8; |
| 236 | 379 | // 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; |
| 240 | 383 | // if (verbose) logerror("PMMU: addr %08x entry %08x entry2 %08x mode %x tofs %x\n", addr_in, tbl_entry, tbl_entry2, tbmode, tofs); |
| 241 | 384 | break; |
| 242 | 385 | |
| 243 | | case 1: // early termination descriptor |
| 244 | | tbl_entry &= 0xffffff00; |
| 386 | case M68K_MMU_DF_DT1: // early termination descriptor |
| 387 | tbl_entry &= (~0 << ps); |
| 245 | 388 | |
| 246 | 389 | shift = is+abits; |
| 247 | 390 | addr_out = ((addr_in<<shift)>>shift) + tbl_entry; |
| r9742 | r9743 | |
| 252 | 395 | // if table A wasn't early-out, continue to process table B |
| 253 | 396 | if (!resolved) |
| 254 | 397 | { |
| 398 | last_entry_ptr = tptr + tofs; |
| 399 | |
| 255 | 400 | // get table C offset and pointer |
| 256 | 401 | tofs = (addr_in<<(is+abits+bbits))>>(32-cbits); |
| 257 | 402 | tptr = tbl_entry & 0xfffffff0; |
| 258 | 403 | |
| 259 | 404 | switch (tbmode) |
| 260 | 405 | { |
| 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; |
| 263 | 411 | break; |
| 264 | 412 | |
| 265 | | case 2: // 4-byte table C descriptor |
| 413 | case M68K_MMU_DF_DT2: // 4-byte table C descriptor |
| 266 | 414 | tofs *= 4; |
| 267 | 415 | // 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; |
| 270 | 418 | // if (verbose) logerror("PMMU: addr %08x entry %08x mode %x tofs %x\n", addr_in, tbl_entry, tbmode, tofs); |
| 271 | 419 | break; |
| 272 | 420 | |
| 273 | | case 3: // 8-byte table C descriptor |
| 421 | case M68K_MMU_DF_DT3: // 8-byte table C descriptor |
| 274 | 422 | tofs *= 8; |
| 275 | 423 | // 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); |
| 280 | 427 | break; |
| 281 | 428 | |
| 282 | | case 1: // termination descriptor |
| 283 | | tbl_entry &= 0xffffff00; |
| 429 | case M68K_MMU_DF_DT1: // termination descriptor |
| 430 | tbl_entry &= (~0 << ps); |
| 284 | 431 | |
| 285 | 432 | shift = is+abits+bbits; |
| 286 | 433 | addr_out = ((addr_in<<shift)>>shift) + tbl_entry; |
| r9742 | r9743 | |
| 293 | 440 | { |
| 294 | 441 | switch (tcmode) |
| 295 | 442 | { |
| 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; |
| 300 | 447 | break; |
| 301 | 448 | |
| 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; |
| 304 | 453 | |
| 454 | case M68K_MMU_DF_DT1: // termination descriptor |
| 455 | tbl_entry &= (~0 << ps); |
| 456 | |
| 305 | 457 | shift = is+abits+bbits+cbits; |
| 306 | 458 | addr_out = ((addr_in<<shift)>>shift) + tbl_entry; |
| 307 | 459 | resolved = 1; |
| r9742 | r9743 | |
| 309 | 461 | } |
| 310 | 462 | } |
| 311 | 463 | |
| 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 | } |
| 313 | 487 | |
| 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 | |
| 314 | 495 | //logerror("PMMU: [%08x] => [%08x]\n", addr_in, addr_out); |
| 315 | 496 | |
| 316 | 497 | return addr_out; |
| 317 | 498 | } |
| 318 | 499 | |
| 319 | 500 | /* |
| 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 | /* |
| 320 | 517 | m68881_mmu_ops: COP 0 MMU opcode handling |
| 321 | 518 | |
| 322 | 519 | */ |
| r9742 | r9743 | |
| 327 | 524 | UINT32 ea = m68k->ir & 0x3f; |
| 328 | 525 | UINT64 temp64; |
| 329 | 526 | |
| 527 | |
| 330 | 528 | // catch the 2 "weird" encodings up front (PBcc) |
| 331 | 529 | if ((m68k->ir & 0xffc0) == 0xf0c0) |
| 332 | 530 | { |
| r9742 | r9743 | |
| 353 | 551 | ptmp = ltmp; |
| 354 | 552 | if (m68k->pmmu_enabled) |
| 355 | 553 | { |
| 356 | | ptmp = pmmu_translate_addr(m68k, ltmp); |
| 554 | ptmp = pmmu_translate_addr_with_fc(m68k, ltmp, modes & 0x07, 0); |
| 357 | 555 | } |
| 358 | 556 | |
| 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); |
| 362 | 560 | return; |
| 363 | 561 | } |
| 364 | 562 | else if ((modes & 0xe200) == 0x2000) // PFLUSH |
| r9742 | r9743 | |
| 383 | 581 | } |
| 384 | 582 | else if ((modes & 0xe000) == 0x8000) // PTEST |
| 385 | 583 | { |
| 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 | } |
| 387 | 610 | return; |
| 388 | 611 | } |
| 389 | 612 | else |
| r9742 | r9743 | |
| 394 | 617 | case 2: // MC68881 form, FD never set |
| 395 | 618 | if (modes & 0x200) |
| 396 | 619 | { |
| 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; |
| 402 | 634 | |
| 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; |
| 406 | 639 | |
| 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; |
| 410 | 644 | |
| 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; |
| 414 | 648 | } |
| 649 | |
| 415 | 650 | } |
| 416 | 651 | else // top 3 bits of modes: 010 for this, 011 for status, 000 for transparent translation regs |
| 417 | 652 | { |
| r9742 | r9743 | |
| 464 | 699 | temp64 = READ_EA_64(m68k, ea); |
| 465 | 700 | m68k->mmu_srp_limit = (temp64>>32) & 0xffffffff; |
| 466 | 701 | 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); |
| 468 | 703 | if (!(modes & 0x100)) |
| 469 | 704 | { |
| 470 | 705 | pmmu_atc_flush(m68k); |
| r9742 | r9743 | |
| 475 | 710 | temp64 = READ_EA_64(m68k, ea); |
| 476 | 711 | m68k->mmu_crp_limit = (temp64>>32) & 0xffffffff; |
| 477 | 712 | 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); |
| 479 | 714 | if (!(modes & 0x100)) |
| 480 | 715 | { |
| 481 | 716 | pmmu_atc_flush(m68k); |
| r9742 | r9743 | |
| 501 | 736 | case 3: // MC68030 to/from status reg |
| 502 | 737 | if (modes & 0x200) |
| 503 | 738 | { |
| 504 | | WRITE_EA_32(m68k, ea, m68k->mmu_sr); |
| 739 | WRITE_EA_16(m68k, ea, m68k->mmu_sr); |
| 505 | 740 | } |
| 506 | 741 | else |
| 507 | 742 | { |
| 508 | | m68k->mmu_sr = READ_EA_32(m68k, ea); |
| 743 | m68k->mmu_sr = READ_EA_16(m68k, ea); |
| 509 | 744 | } |
| 510 | 745 | break; |
| 511 | 746 | |
| r9742 | r9743 | |
| 532 | 767 | |
| 533 | 768 | addr_out = addr_in; |
| 534 | 769 | |
| 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 |
| 536 | 771 | if (m68k->hmmu_enabled == M68K_HMMU_ENABLE_LC) |
| 537 | 772 | { |
| 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; |
| 540 | 778 | |
| 541 | | if ((addr_in >= 0xa00000) && (addr_in <= 0xdfffff)) |
| 779 | if ((addr_in >= 0x800000) && (addr_in <= 0x8fffff)) |
| 542 | 780 | { |
| 543 | | addr_out |= 0x40000000; |
| 781 | addr_out |= 0x40000000; // ROM |
| 544 | 782 | } |
| 545 | | if ((addr_in >= 0xe00000) && (addr_in <= 0xefffff)) |
| 783 | else if ((addr_in >= 0x900000) && (addr_in <= 0xefffff)) |
| 546 | 784 | { |
| 547 | | addr_out &= 0xfffff; |
| 548 | | addr_out |= 0xfe000000; |
| 785 | addr_out |= 0xf0ff0000; // NuBus |
| 786 | addr_out |= ((addr_in & 0xf00000)<<4); |
| 549 | 787 | } |
| 550 | 788 | else if (addr_in >= 0xf00000) |
| 551 | 789 | { |
| 552 | | addr_out |= 0x50000000; |
| 790 | addr_out |= 0x50000000; // I/O |
| 553 | 791 | } |
| 792 | |
| 793 | // (RAM is at 0 and doesn't need special massaging) |
| 554 | 794 | } |
| 555 | 795 | |
| 556 | 796 | return addr_out; |
src/emu/cpu/m68000/m68kcpu.c
| r9742 | r9743 | |
| 5 | 5 | #if 0 |
| 6 | 6 | static const char copyright_notice[] = |
| 7 | 7 | "MUSASHI\n" |
| 8 | | "Version 4.60 (2010-03-12)\n" |
| 8 | "Version 4.70 (2010-11-06)\n" |
| 9 | 9 | "A portable Motorola M680x0 processor emulation engine.\n" |
| 10 | 10 | "Copyright Karl Stenerud. All rights reserved.\n" |
| 11 | 11 | "\n" |
| r9742 | r9743 | |
| 565 | 565 | { |
| 566 | 566 | if ((space == ADDRESS_SPACE_PROGRAM) && (m68k->pmmu_enabled)) |
| 567 | 567 | { |
| 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; |
| 569 | 580 | } |
| 570 | 581 | } |
| 571 | 582 | return TRUE; |
| r9742 | r9743 | |
| 621 | 632 | /* Call external hook to peek at CPU */ |
| 622 | 633 | debugger_instruction_hook(device, REG_PC); |
| 623 | 634 | |
| 635 | // FIXME: remove this |
| 636 | // void apollo_debug_instruction(running_device *device); |
| 637 | // apollo_debug_instruction(device); |
| 638 | |
| 624 | 639 | /* Record previous program counter */ |
| 625 | 640 | REG_PPC = REG_PC; |
| 626 | 641 | |
| 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]; |
| 631 | 654 | |
| 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 | |
| 632 | 721 | /* Trace m68k_exception, if necessary */ |
| 633 | 722 | m68ki_exception_if_trace(); /* auto-disable (see m68kcpu.h) */ |
| 634 | 723 | } while (m68k->remaining_cycles > 0); |
| r9742 | r9743 | |
| 693 | 782 | m68k->pmmu_enabled = 0; |
| 694 | 783 | m68k->hmmu_enabled = 0; |
| 695 | 784 | |
| 785 | m68k->mmu_tc = 0; |
| 786 | m68k->mmu_tt0 = 0; |
| 787 | m68k->mmu_tt1 = 0; |
| 788 | |
| 696 | 789 | /* Clear all stop levels and eat up all remaining cycles */ |
| 697 | 790 | m68k->stopped = 0; |
| 698 | 791 | if (m68k->remaining_cycles > 0) |
| r9742 | r9743 | |
| 952 | 1045 | case DEVINFO_STR_FAMILY: strcpy(info->s, "Motorola 68K"); break; |
| 953 | 1046 | case DEVINFO_STR_VERSION: strcpy(info->s, "4.60"); break; |
| 954 | 1047 | 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; |
| 956 | 1049 | } |
| 957 | 1050 | } |
| 958 | 1051 | |
| r9742 | r9743 | |
| 1055 | 1148 | if (m_cpustate->pmmu_enabled) |
| 1056 | 1149 | { |
| 1057 | 1150 | address = pmmu_translate_addr(m_cpustate, address); |
| 1151 | if (m_cpustate->mmu_tmp_buserror_occurred) { |
| 1152 | return ~0; |
| 1153 | } |
| 1058 | 1154 | } |
| 1059 | 1155 | |
| 1060 | 1156 | return m_space->read_byte(address); |
| r9742 | r9743 | |
| 1065 | 1161 | if (m_cpustate->pmmu_enabled) |
| 1066 | 1162 | { |
| 1067 | 1163 | address = pmmu_translate_addr(m_cpustate, address); |
| 1164 | if (m_cpustate->mmu_tmp_buserror_occurred) { |
| 1165 | return; |
| 1166 | } |
| 1068 | 1167 | } |
| 1069 | 1168 | |
| 1070 | 1169 | m_space->write_byte(address, data); |
| r9742 | r9743 | |
| 1075 | 1174 | if (m_cpustate->pmmu_enabled) |
| 1076 | 1175 | { |
| 1077 | 1176 | address = pmmu_translate_addr(m_cpustate, address); |
| 1177 | if (m_cpustate->mmu_tmp_buserror_occurred) { |
| 1178 | return ~0; |
| 1179 | } |
| 1078 | 1180 | } |
| 1079 | 1181 | |
| 1080 | 1182 | return m_direct->read_decrypted_word((address) ^ m_cpustate->memory.opcode_xor); |
| r9742 | r9743 | |
| 1087 | 1189 | |
| 1088 | 1190 | if (m_cpustate->pmmu_enabled) |
| 1089 | 1191 | { |
| 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 | } |
| 1091 | 1206 | } |
| 1092 | 1207 | |
| 1093 | 1208 | if (!(address & 1)) |
| r9742 | r9743 | |
| 1101 | 1216 | { |
| 1102 | 1217 | if (m_cpustate->pmmu_enabled) |
| 1103 | 1218 | { |
| 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 | } |
| 1105 | 1235 | } |
| 1106 | 1236 | |
| 1107 | 1237 | if (!(address & 1)) |
| r9742 | r9743 | |
| 1120 | 1250 | |
| 1121 | 1251 | if (m_cpustate->pmmu_enabled) |
| 1122 | 1252 | { |
| 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 | } |
| 1124 | 1280 | } |
| 1125 | 1281 | |
| 1126 | 1282 | if (!(address & 3)) |
| r9742 | r9743 | |
| 1140 | 1296 | { |
| 1141 | 1297 | if (m_cpustate->pmmu_enabled) |
| 1142 | 1298 | { |
| 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 | } |
| 1144 | 1329 | } |
| 1145 | 1330 | |
| 1146 | 1331 | if (!(address & 3)) |
| r9742 | r9743 | |
| 1413 | 1598 | m68k->cyc_reset = 132; |
| 1414 | 1599 | m68k->has_pmmu = 0; |
| 1415 | 1600 | m68k->has_hmmu = 0; |
| 1601 | m68k->has_fpu = 0; |
| 1416 | 1602 | |
| 1417 | 1603 | define_state(device); |
| 1418 | 1604 | } |
| r9742 | r9743 | |
| 1462 | 1648 | m68k->cyc_shift = 1; |
| 1463 | 1649 | m68k->cyc_reset = 132; |
| 1464 | 1650 | m68k->has_pmmu = 0; |
| 1651 | m68k->has_fpu = 0; |
| 1465 | 1652 | |
| 1466 | 1653 | define_state(device); |
| 1467 | 1654 | } |
| r9742 | r9743 | |
| 1515 | 1702 | m68k->cyc_shift = 1; |
| 1516 | 1703 | m68k->cyc_reset = 130; |
| 1517 | 1704 | m68k->has_pmmu = 0; |
| 1705 | m68k->has_fpu = 0; |
| 1518 | 1706 | |
| 1519 | 1707 | define_state(device); |
| 1520 | 1708 | } |
| r9742 | r9743 | |
| 1597 | 1785 | CPU_INIT_CALL(m68020); |
| 1598 | 1786 | |
| 1599 | 1787 | m68k->has_pmmu = 1; |
| 1788 | m68k->has_fpu = 1; |
| 1789 | |
| 1600 | 1790 | // hack alert: we use placement new to ensure we are properly initialized |
| 1601 | 1791 | // because we live in the device state which is allocated as bytes |
| 1602 | 1792 | // remove me when we have a real C++ device |
| r9742 | r9743 | |
| 1678 | 1868 | m68k->cyc_shift = 0; |
| 1679 | 1869 | m68k->cyc_reset = 518; |
| 1680 | 1870 | m68k->has_pmmu = 0; |
| 1871 | m68k->has_fpu = 0; |
| 1681 | 1872 | |
| 1682 | 1873 | define_state(device); |
| 1683 | 1874 | } |
| r9742 | r9743 | |
| 1729 | 1920 | m68k->cyc_shift = 0; |
| 1730 | 1921 | m68k->cyc_reset = 518; |
| 1731 | 1922 | m68k->has_pmmu = 1; |
| 1923 | m68k->has_fpu = 1; |
| 1732 | 1924 | |
| 1733 | 1925 | define_state(device); |
| 1734 | 1926 | } |
| r9742 | r9743 | |
| 1786 | 1978 | m68k->cyc_shift = 0; |
| 1787 | 1979 | m68k->cyc_reset = 518; |
| 1788 | 1980 | m68k->has_pmmu = 0; /* EC030 lacks the PMMU and is effectively a die-shrink 68020 */ |
| 1981 | m68k->has_fpu = 1; |
| 1789 | 1982 | |
| 1790 | 1983 | define_state(device); |
| 1791 | 1984 | } |
| r9742 | r9743 | |
| 1834 | 2027 | m68k->cyc_shift = 0; |
| 1835 | 2028 | m68k->cyc_reset = 518; |
| 1836 | 2029 | m68k->has_pmmu = 1; |
| 2030 | m68k->has_fpu = 1; |
| 1837 | 2031 | |
| 1838 | 2032 | define_state(device); |
| 1839 | 2033 | } |
| r9742 | r9743 | |
| 1890 | 2084 | m68k->cyc_shift = 0; |
| 1891 | 2085 | m68k->cyc_reset = 518; |
| 1892 | 2086 | m68k->has_pmmu = 0; |
| 2087 | m68k->has_fpu = 0; |
| 1893 | 2088 | |
| 1894 | 2089 | define_state(device); |
| 1895 | 2090 | } |
| r9742 | r9743 | |
| 1938 | 2133 | m68k->cyc_shift = 0; |
| 1939 | 2134 | m68k->cyc_reset = 518; |
| 1940 | 2135 | m68k->has_pmmu = 1; |
| 2136 | m68k->has_fpu = 0; |
| 1941 | 2137 | |
| 1942 | 2138 | define_state(device); |
| 1943 | 2139 | } |