src/mame/machine/snes.c
| r7662 | r7663 | |
| 137 | 137 | /* Vertical IRQ timer - only if horizontal isn't also enabled! */ |
| 138 | 138 | if ((snes_ram[NMITIMEN] & 0x20) && !(snes_ram[NMITIMEN] & 0x10)) |
| 139 | 139 | { |
| 140 | | if (snes_ppu.beam.current_vert == (((snes_ram[VTIMEH] << 8) | snes_ram[VTIMEL]) & 0x1ff)) |
| 140 | if (snes_ppu.beam.current_vert == state->vtime) |
| 141 | 141 | { |
| 142 | 142 | snes_ram[TIMEUP] = 0x80; /* Indicate that irq occured */ |
| 143 | 143 | // IRQ latches the counters, do it now |
| r7662 | r7663 | |
| 149 | 149 | if (snes_ram[NMITIMEN] & 0x10) |
| 150 | 150 | { |
| 151 | 151 | int setirq = 1; |
| 152 | | int pixel = ((snes_ram[HTIMEH] << 8) | snes_ram[HTIMEL]) & 0x1ff; |
| 152 | int pixel = state->htime; |
| 153 | 153 | |
| 154 | 154 | // is the HIRQ on a specific scanline? |
| 155 | 155 | if (snes_ram[NMITIMEN] & 0x20) |
| 156 | 156 | { |
| 157 | | if (snes_ppu.beam.current_vert != (((snes_ram[VTIMEH] << 8) | snes_ram[VTIMEL]) & 0x1ff) ) |
| 157 | if (snes_ppu.beam.current_vert != state->vtime) |
| 158 | 158 | { |
| 159 | 159 | setirq = 0; |
| 160 | 160 | } |
| r7662 | r7663 | |
| 238 | 238 | if (snes_ram[HDMAEN]) |
| 239 | 239 | snes_hdma(cpu0space); |
| 240 | 240 | |
| 241 | | video_screen_update_partial(machine->primary_screen, (snes_ppu.interlace == 2) ? (snes_ppu.beam.current_vert*snes_ppu.interlace) : snes_ppu.beam.current_vert-1); |
| 241 | video_screen_update_partial(machine->primary_screen, (snes_ppu.interlace == 2) ? (snes_ppu.beam.current_vert * snes_ppu.interlace) : snes_ppu.beam.current_vert - 1); |
| 242 | 242 | } |
| 243 | 243 | } |
| 244 | 244 | |
| r7662 | r7663 | |
| 773 | 773 | snes_ppu.ppu2_open_bus = value; |
| 774 | 774 | return snes_ppu.ppu2_open_bus; |
| 775 | 775 | case WMDATA: /* Data to read from WRAM */ |
| 776 | | { |
| 777 | | UINT32 addr = ((snes_ram[WMADDH] & 0x1) << 16) | (snes_ram[WMADDM] << 8) | snes_ram[WMADDL]; |
| 778 | | |
| 779 | | value = memory_read_byte(space, 0x7e0000 + addr++); |
| 780 | | addr &= 0x1ffff; |
| 781 | | snes_ram[WMADDH] = (addr >> 16) & 0x1; |
| 782 | | snes_ram[WMADDM] = (addr >> 8) & 0xff; |
| 783 | | snes_ram[WMADDL] = addr & 0xff; |
| 784 | | return value; |
| 785 | | } |
| 786 | | case WMADDL: /* Address to read/write to wram (low) */ |
| 787 | | case WMADDM: /* Address to read/write to wram (mid) */ |
| 788 | | case WMADDH: /* Address to read/write to wram (high) */ |
| 789 | | return snes_ram[offset]; |
| 776 | value = memory_read_byte(space, 0x7e0000 + state->wram_address++); |
| 777 | state->wram_address &= 0x1ffff; |
| 778 | return value; |
| 790 | 779 | case OLDJOY1: /* Data for old NES controllers (JOYSER1) */ |
| 791 | 780 | if (snes_ram[offset] & 0x1) |
| 792 | 781 | return 0 | (snes_open_bus_r(space, 0) & 0xfc); //correct? |
| r7662 | r7663 | |
| 801 | 790 | value = state->oldjoy2_read(space->machine); |
| 802 | 791 | |
| 803 | 792 | return value | 0x1c | (snes_open_bus_r(space, 0) & 0xe0); //correct? |
| 804 | | case HTIMEL: |
| 805 | | case HTIMEH: |
| 806 | | case VTIMEL: |
| 807 | | case VTIMEH: |
| 808 | | return snes_ram[offset]; |
| 809 | 793 | case RDNMI: /* NMI flag by v-blank and version number */ |
| 810 | 794 | value = (snes_ram[offset] & 0x8f) | (snes_open_bus_r(space, 0) & 0x70); |
| 811 | 795 | snes_ram[offset] &= 0x7f; /* NMI flag is reset on read */ |
| r7662 | r7663 | |
| 813 | 797 | case TIMEUP: /* IRQ flag by H/V count timer */ |
| 814 | 798 | value = (snes_open_bus_r(space, 0) & 0x7f) | (snes_ram[TIMEUP] & 0x80); |
| 815 | 799 | cpu_set_input_line(state->maincpu, G65816_LINE_IRQ, CLEAR_LINE ); |
| 816 | | snes_ram[TIMEUP] = 0; |
| 800 | snes_ram[TIMEUP] = 0; // flag is cleared on both read and write |
| 817 | 801 | return value; |
| 818 | 802 | case HVBJOY: /* H/V blank and joypad controller enable */ |
| 819 | 803 | // electronics test says hcounter 272 is start of hblank, which is beampos 363 |
| r7662 | r7663 | |
| 1354 | 1338 | #endif |
| 1355 | 1339 | break; |
| 1356 | 1340 | case WMDATA: /* Data to write to WRAM */ |
| 1357 | | { |
| 1358 | | UINT32 addr = ((snes_ram[WMADDH] & 0x1) << 16) | (snes_ram[WMADDM] << 8) | snes_ram[WMADDL]; |
| 1359 | | memory_write_byte(space, 0x7e0000 + addr++, data ); |
| 1360 | | addr &= 0x1ffff; |
| 1361 | | snes_ram[WMADDH] = (addr >> 16) & 0x1; |
| 1362 | | snes_ram[WMADDM] = (addr >> 8) & 0xff; |
| 1363 | | snes_ram[WMADDL] = addr & 0xff; |
| 1364 | | return; |
| 1365 | | } |
| 1341 | memory_write_byte(space, 0x7e0000 + state->wram_address++, data ); |
| 1342 | state->wram_address &= 0x1ffff; |
| 1343 | return; |
| 1366 | 1344 | case WMADDL: /* Address to read/write to wram (low) */ |
| 1345 | state->wram_address = (state->wram_address & 0xffff00) | (data << 0); |
| 1346 | state->wram_address &= 0x1ffff; |
| 1347 | return; |
| 1367 | 1348 | case WMADDM: /* Address to read/write to wram (mid) */ |
| 1349 | state->wram_address = (state->wram_address & 0xff00ff) | (data << 8); |
| 1350 | state->wram_address &= 0x1ffff; |
| 1351 | return; |
| 1368 | 1352 | case WMADDH: /* Address to read/write to wram (high) */ |
| 1369 | | break; |
| 1353 | state->wram_address = (state->wram_address & 0x00ffff) | (data << 16); |
| 1354 | state->wram_address &= 0x1ffff; |
| 1355 | return; |
| 1370 | 1356 | case OLDJOY1: /* Old NES joystick support */ |
| 1371 | 1357 | if (((!(data & 0x1)) && (snes_ram[offset] & 0x1))) |
| 1372 | 1358 | { |
| r7662 | r7663 | |
| 1422 | 1408 | } |
| 1423 | 1409 | break; |
| 1424 | 1410 | case HTIMEL: /* H-Count timer settings (low) */ |
| 1411 | state->htime = (state->htime & 0xff00) | (data << 0); |
| 1412 | state->htime &= 0x1ff; |
| 1413 | return; |
| 1425 | 1414 | case HTIMEH: /* H-Count timer settings (high) */ |
| 1415 | state->htime = (state->htime & 0x00ff) | (data << 8); |
| 1416 | state->htime &= 0x1ff; |
| 1417 | return; |
| 1426 | 1418 | case VTIMEL: /* V-Count timer settings (low) */ |
| 1419 | state->vtime = (state->vtime & 0xff00) | (data << 0); |
| 1420 | state->vtime &= 0x1ff; |
| 1421 | return; |
| 1427 | 1422 | case VTIMEH: /* V-Count timer settings (high) */ |
| 1428 | | break; |
| 1423 | state->vtime = (state->vtime & 0x00ff) | (data << 8); |
| 1424 | state->vtime &= 0x1ff; |
| 1425 | return; |
| 1429 | 1426 | case MDMAEN: /* DMA channel designation and trigger */ |
| 1430 | 1427 | snes_dma(space, data); |
| 1431 | 1428 | data = 0; /* Once DMA is done we need to reset all bits to 0 */ |
| r7662 | r7663 | |
| 1443 | 1440 | mame_printf_debug( "CPU speed: %f Mhz\n", (data & 0x1) ? 3.58 : 2.68 ); |
| 1444 | 1441 | #endif |
| 1445 | 1442 | break; |
| 1446 | | case TIMEUP: |
| 1447 | | snes_ram[TIMEUP] = data &~0x7f; |
| 1443 | case TIMEUP: // IRQ Flag is cleared on both read and write |
| 1444 | snes_ram[TIMEUP] = 0; |
| 1448 | 1445 | return; |
| 1449 | 1446 | /* Following are read-only */ |
| 1450 | 1447 | case HVBJOY: /* H/V blank and joypad enable */ |
| r7662 | r7663 | |
| 1606 | 1603 | /* 0x000000 - 0x2fffff */ |
| 1607 | 1604 | READ8_HANDLER( snes_r_bank1 ) |
| 1608 | 1605 | { |
| 1609 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 1610 | 1606 | UINT8 value; |
| 1611 | 1607 | UINT16 address = offset & 0xffff; |
| 1612 | 1608 | |
| r7662 | r7663 | |
| 1616 | 1612 | value = snes_r_io(space, address); |
| 1617 | 1613 | else if (address < 0x8000) |
| 1618 | 1614 | { |
| 1619 | | if (snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 1620 | | value = snes_ram[0x700000 + (address & 0x1fff)]; |
| 1615 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1616 | value = snes_ram[0xf00000 + (address & 0x1fff)]; // here it should 0xe00000 but there are mirroring issues |
| 1621 | 1617 | else if (snes_has_addon_chip == HAS_OBC1) |
| 1622 | 1618 | value = obc1_read(space, offset); |
| 1623 | 1619 | else if ((snes_has_addon_chip == HAS_DSP2) && (offset >= 0x200000)) |
| r7662 | r7663 | |
| 1627 | 1623 | else if (snes_has_addon_chip == HAS_CX4) |
| 1628 | 1624 | value = CX4_read(address - 0x6000); |
| 1629 | 1625 | else if (snes_has_addon_chip == HAS_SPC7110 || snes_has_addon_chip == HAS_SPC7110_RTC) |
| 1630 | | { |
| 1631 | 1626 | value = snes_ram[0x306000 + (offset & 0x1fff)]; |
| 1632 | | } |
| 1633 | 1627 | else |
| 1634 | 1628 | { |
| 1635 | 1629 | logerror( "snes_r_bank1: Unmapped external chip read: %04x\n", address ); |
| r7662 | r7663 | |
| 1660 | 1654 | value = snes_r_io(space, address); |
| 1661 | 1655 | else if (address < 0x8000) /* SRAM for mode_21, Reserved othewise */ |
| 1662 | 1656 | { |
| 1663 | | if (snes_has_addon_chip == HAS_OBC1) |
| 1657 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1658 | value = snes_ram[0xf00000 + (address & 0x1fff)]; // here it should 0xe00000 but there are mirroring issues |
| 1659 | else if (snes_has_addon_chip == HAS_OBC1) |
| 1664 | 1660 | value = obc1_read (space, offset); |
| 1665 | 1661 | else if (snes_has_addon_chip == HAS_DSP2) |
| 1666 | 1662 | value = (address < 0x7000) ? dsp2_read() : 0x00; |
| 1667 | 1663 | else if (snes_has_addon_chip == HAS_SPC7110 || snes_has_addon_chip == HAS_SPC7110_RTC) |
| 1668 | | { |
| 1669 | 1664 | value = snes_ram[0x306000 + (offset & 0x1fff)]; |
| 1670 | | } |
| 1671 | 1665 | else if ((snes_cart.mode == SNES_MODE_21) && (snes_cart.sram > 0)) |
| 1672 | 1666 | { |
| 1673 | 1667 | int mask = ((snes_cart.sram * 1024) - 1); /* Limit SRAM size to what's actually present */ |
| r7662 | r7663 | |
| 1701 | 1695 | UINT8 value; |
| 1702 | 1696 | UINT16 address = offset & 0xffff; |
| 1703 | 1697 | |
| 1704 | | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1698 | if ((snes_cart.mode & 5) && !(snes_has_addon_chip == HAS_SUPERFX)) /* Mode 20 & 22 */ |
| 1705 | 1699 | { |
| 1706 | | //printf( "snes_r_bank3: %08x\n", offset ); |
| 1707 | | return snes_ram[0x400000 + offset]; |
| 1708 | | } |
| 1709 | | else if (snes_cart.mode & 5) /* Mode 20 & 22 */ |
| 1710 | | { |
| 1711 | | if ((address < 0x8000) && (snes_cart.mode == SNES_MODE_20)) //FIXME: check this |
| 1712 | | { |
| 1700 | if ((address < 0x8000) && (snes_cart.mode == SNES_MODE_20)) |
| 1713 | 1701 | value = 0xff; /* Reserved */ |
| 1714 | | //value = snes_ram[0x200000 + ((offset & ~0x8000) | 0x8000)]; // is this hack still needed? /* Reserved */ |
| 1715 | | } |
| 1716 | 1702 | else |
| 1717 | 1703 | value = snes_ram[0x400000 + offset]; |
| 1718 | 1704 | } |
| 1719 | | else /* Mode 21 & 25 */ |
| 1705 | else /* Mode 21 & 25 + SuperFX games */ |
| 1720 | 1706 | value = snes_ram[0x400000 + offset]; |
| 1721 | 1707 | |
| 1722 | 1708 | return value; |
| r7662 | r7663 | |
| 1725 | 1711 | /* 0x600000 - 0x6fffff */ |
| 1726 | 1712 | READ8_HANDLER( snes_r_bank4 ) |
| 1727 | 1713 | { |
| 1728 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 1729 | 1714 | UINT8 value = 0xff; |
| 1730 | 1715 | UINT16 address = offset & 0xffff; |
| 1731 | 1716 | |
| 1732 | | if (snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 1733 | | { |
| 1734 | | value = snes_ram[0x600000 + offset]; |
| 1735 | | } |
| 1717 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1718 | value = snes_ram[0xe00000 + offset]; |
| 1736 | 1719 | else if (snes_has_addon_chip == HAS_ST010 && offset >= 0x80000 && address < 0x1000) |
| 1737 | | { |
| 1738 | 1720 | value = st010_read(address); |
| 1739 | | } |
| 1740 | 1721 | else if (snes_cart.mode & 5) /* Mode 20 & 22 */ |
| 1741 | 1722 | { |
| 1742 | 1723 | if (address >= 0x8000) |
| r7662 | r7663 | |
| 1759 | 1740 | /* 0x700000 - 0x7dffff */ |
| 1760 | 1741 | READ8_HANDLER( snes_r_bank5 ) |
| 1761 | 1742 | { |
| 1762 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 1763 | 1743 | UINT8 value; |
| 1764 | 1744 | UINT16 address = offset & 0xffff; |
| 1765 | 1745 | |
| 1766 | | if (snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 1746 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1747 | value = snes_ram[0xf00000 + offset]; |
| 1748 | else if ((snes_cart.mode & 5) && (address < 0x8000)) /* Mode 20 & 22 */ |
| 1767 | 1749 | { |
| 1768 | | value = snes_ram[0x700000 + offset]; |
| 1769 | | } |
| 1770 | | else if ((snes_cart.mode & 5) &&(address < 0x8000)) /* Mode 20 & 22 */ |
| 1771 | | { |
| 1772 | 1750 | if (snes_cart.sram > 0) |
| 1773 | 1751 | { |
| 1774 | 1752 | int mask = ((snes_cart.sram * 1024) - 1) | 0xff0000; /* Limit SRAM size to what's actually present */ |
| r7662 | r7663 | |
| 1776 | 1754 | } |
| 1777 | 1755 | else |
| 1778 | 1756 | { |
| 1779 | | logerror( "snes_r_bank5: Unmapped external chip read: %04x\n", address ); |
| 1757 | logerror("snes_r_bank5: Unmapped external chip read: %04x\n", address); |
| 1780 | 1758 | value = 0xff; /* Reserved */ |
| 1781 | 1759 | } |
| 1782 | 1760 | } |
| 1783 | 1761 | else |
| 1784 | | { |
| 1785 | 1762 | value = snes_ram[0x700000 + offset]; |
| 1786 | | } |
| 1787 | 1763 | |
| 1788 | 1764 | return value; |
| 1789 | 1765 | } |
| r7662 | r7663 | |
| 1791 | 1767 | /* 0x800000 - 0xbfffff */ |
| 1792 | 1768 | READ8_HANDLER( snes_r_bank6 ) |
| 1793 | 1769 | { |
| 1794 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 1795 | 1770 | UINT8 value = 0; |
| 1796 | 1771 | UINT16 address = offset & 0xffff; |
| 1797 | 1772 | |
| 1798 | | if (address < 0x8000) |
| 1773 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1774 | value = memory_read_byte(space, offset); |
| 1775 | else if (address < 0x8000) |
| 1799 | 1776 | { |
| 1800 | | if (address >= 0x6000 && snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 1801 | | logerror( "snes_r_bank6 hit in Super FX mode, please fix me\n" ); |
| 1802 | | else if (snes_cart.mode != SNES_MODE_25) |
| 1777 | if (snes_cart.mode != SNES_MODE_25) |
| 1803 | 1778 | value = memory_read_byte(space, offset); |
| 1804 | 1779 | else if (snes_has_addon_chip == HAS_CX4) |
| 1805 | 1780 | { |
| r7662 | r7663 | |
| 1817 | 1792 | } |
| 1818 | 1793 | else /* Area 0x6000-0x8000 with offset < 0x300000 is reserved */ |
| 1819 | 1794 | { |
| 1820 | | logerror( "snes_r_bank6: Unmapped external chip read: %04x\n", address ); |
| 1795 | logerror("snes_r_bank6: Unmapped external chip read: %04x\n", address); |
| 1821 | 1796 | value = 0xff; |
| 1822 | 1797 | } |
| 1823 | 1798 | } |
| r7662 | r7663 | |
| 1839 | 1814 | /* 0xc00000 - 0xffffff */ |
| 1840 | 1815 | READ8_HANDLER( snes_r_bank7 ) |
| 1841 | 1816 | { |
| 1842 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 1843 | 1817 | UINT8 value = 0; |
| 1844 | 1818 | UINT16 address = offset & 0xffff; |
| 1845 | 1819 | |
| 1846 | 1820 | if (snes_has_addon_chip == HAS_SDD1) |
| 1847 | | { |
| 1848 | | return sdd1_read(space->machine, offset); |
| 1849 | | } |
| 1850 | | else if (snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 1851 | | { |
| 1852 | | logerror( "snes_r_bank7 hit in Super FX mode, please fix me\n" ); |
| 1853 | | } |
| 1821 | value = sdd1_read(space->machine, offset); |
| 1854 | 1822 | else if (snes_has_addon_chip == HAS_ST010 && offset >= 0x280000 && offset < 0x300000 && address < 0x1000) |
| 1855 | | { |
| 1856 | 1823 | value = st010_read(address); |
| 1857 | | } |
| 1858 | | else if (snes_cart.mode & 5) /* Mode 20 & 22 */ |
| 1824 | else if ((snes_cart.mode & 5) && !(snes_has_addon_chip == HAS_SUPERFX)) /* Mode 20 & 22 */ |
| 1859 | 1825 | { |
| 1860 | 1826 | if (address < 0x8000) |
| 1861 | | { |
| 1862 | 1827 | value = memory_read_byte(space, 0x400000 + offset); |
| 1863 | | } |
| 1864 | 1828 | else |
| 1865 | 1829 | value = snes_ram[0xc00000 + offset]; |
| 1866 | 1830 | } |
| 1867 | | else /* Mode 21 & 25 */ |
| 1831 | else /* Mode 21 & 25 + SuperFX Games */ |
| 1868 | 1832 | value = snes_ram[0xc00000 + offset]; |
| 1869 | 1833 | |
| 1870 | 1834 | return value; |
| r7662 | r7663 | |
| 1883 | 1847 | else if (address < 0x8000) |
| 1884 | 1848 | { |
| 1885 | 1849 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1886 | | snes_ram[0x700000 + (address & 0x1fff)] = data; |
| 1850 | snes_ram[0xf00000 + (address & 0x1fff)] = data; // here it should 0xe00000 but there are mirroring issues |
| 1887 | 1851 | else if (snes_has_addon_chip == HAS_OBC1) |
| 1888 | 1852 | obc1_write(space, offset, data); |
| 1889 | 1853 | else if ((snes_has_addon_chip == HAS_DSP2) && (offset >= 0x200000)) |
| r7662 | r7663 | |
| 1920 | 1884 | snes_w_io(space, address, data); |
| 1921 | 1885 | else if (address < 0x8000) /* SRAM for mode_21, Reserved othewise */ |
| 1922 | 1886 | { |
| 1923 | | if (snes_has_addon_chip == HAS_OBC1) |
| 1887 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1888 | snes_ram[0xf00000 + (address & 0x1fff)] = data; // here it should 0xe00000 but there are mirroring issues |
| 1889 | else if (snes_has_addon_chip == HAS_OBC1) |
| 1924 | 1890 | obc1_write(space, offset, data); |
| 1925 | 1891 | else if (snes_has_addon_chip == HAS_DSP2) |
| 1926 | 1892 | dsp2_write(data); |
| r7662 | r7663 | |
| 1931 | 1897 | else if ((snes_cart.mode == SNES_MODE_21) && (snes_cart.sram > 0)) |
| 1932 | 1898 | { |
| 1933 | 1899 | int mask = ((snes_cart.sram * 1024) - 1); /* Limit SRAM size to what's actually present */ |
| 1934 | | logerror( "snes_w_bank2 hit in Super FX mode, please fix me if necessary\n" ); |
| 1935 | 1900 | offset -= 0x6000; |
| 1936 | 1901 | snes_ram[0x306000 + (offset & mask)] = data; |
| 1937 | 1902 | } |
| r7662 | r7663 | |
| 1954 | 1919 | /* 0x600000 - 0x6fffff */ |
| 1955 | 1920 | WRITE8_HANDLER( snes_w_bank4 ) |
| 1956 | 1921 | { |
| 1957 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 1958 | 1922 | UINT16 address = offset & 0xffff; |
| 1959 | 1923 | |
| 1960 | | if (snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 1961 | | { |
| 1962 | | snes_ram[0x600000 + offset] = data; |
| 1963 | | } |
| 1924 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1925 | snes_ram[0xe00000 + offset] = data; |
| 1964 | 1926 | else if (snes_has_addon_chip == HAS_ST010 && offset >= 0x80000 && address < 0x1000) |
| 1965 | | { |
| 1966 | 1927 | st010_write(address, data); |
| 1967 | | } |
| 1968 | 1928 | else if (snes_cart.mode & 5) /* Mode 20 & 22 */ |
| 1969 | 1929 | { |
| 1970 | 1930 | if (address >= 0x8000) |
| 1971 | | { |
| 1972 | 1931 | logerror("Attempt to write to ROM address: %X\n", offset + 0x600000); |
| 1973 | | } |
| 1974 | 1932 | else if (snes_has_addon_chip == HAS_DSP1) |
| 1975 | | { |
| 1976 | 1933 | dsp1_set_dr(data); |
| 1977 | | } |
| 1978 | 1934 | else |
| 1979 | | { |
| 1980 | 1935 | logerror("snes_w_bank4: Attempt to write to reserved address: %X = %02x\n", offset + 0x600000, data); |
| 1981 | | } |
| 1982 | 1936 | } |
| 1983 | 1937 | else if (snes_cart.mode & 0x0a) |
| 1984 | | { |
| 1985 | 1938 | logerror("Attempt to write to ROM address: %X\n", offset + 0x600000); |
| 1986 | | } |
| 1987 | 1939 | } |
| 1988 | 1940 | |
| 1989 | 1941 | /* 0x700000 - 0x7dffff */ |
| 1990 | 1942 | WRITE8_HANDLER( snes_w_bank5 ) |
| 1991 | 1943 | { |
| 1992 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 1993 | 1944 | UINT16 address = offset & 0xffff; |
| 1994 | 1945 | |
| 1995 | | if (snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 1996 | | { |
| 1997 | | snes_ram[0x700000 + offset] = data; |
| 1998 | | } |
| 1946 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1947 | snes_ram[0xf00000 + offset] = data; |
| 1999 | 1948 | else if ((snes_cart.mode & 5) && (address < 0x8000)) /* Mode 20 & 22 */ |
| 2000 | 1949 | { |
| 2001 | 1950 | if (snes_cart.sram > 0) |
| r7662 | r7663 | |
| 2004 | 1953 | snes_ram[0x700000 + (offset & mask)] = data; |
| 2005 | 1954 | } |
| 2006 | 1955 | else |
| 2007 | | { |
| 2008 | 1956 | logerror("snes_w_bank5: Attempt to write to reserved address: %X = %02x\n", offset + 0x700000, data); |
| 2009 | | } |
| 2010 | 1957 | } |
| 2011 | 1958 | else if (snes_cart.mode & 0x0a) |
| 2012 | | { |
| 2013 | 1959 | logerror("Attempt to write to ROM address: %X\n", offset + 0x700000); |
| 2014 | | } |
| 2015 | 1960 | } |
| 2016 | 1961 | |
| 2017 | 1962 | |
| 2018 | 1963 | /* 0x800000 - 0xbfffff */ |
| 2019 | 1964 | WRITE8_HANDLER( snes_w_bank6 ) |
| 2020 | 1965 | { |
| 2021 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 2022 | 1966 | UINT16 address = offset & 0xffff; |
| 2023 | 1967 | |
| 2024 | | if (address < 0x8000) |
| 1968 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 1969 | memory_write_byte(space, offset, data); |
| 1970 | else if (address < 0x8000) |
| 2025 | 1971 | { |
| 2026 | | if (address >= 0x6000 && snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 1972 | if (snes_has_addon_chip == HAS_CX4) |
| 2027 | 1973 | { |
| 2028 | | logerror( "snes_w_bank6 hit (RAM) in Super FX mode, please fix me\n" ); |
| 2029 | | } |
| 2030 | | else if (snes_has_addon_chip == HAS_CX4) |
| 2031 | | { |
| 2032 | 1974 | //printf( "R: CX4 hit from 0x800000\n" ); |
| 2033 | 1975 | } |
| 2034 | 1976 | if (snes_cart.mode != SNES_MODE_25) |
| 2035 | | { |
| 2036 | | if (offset < 0x300000) |
| 2037 | | snes_w_bank1(space, offset, data); |
| 2038 | | else |
| 2039 | | snes_w_bank2(space, offset - 0x300000, data); |
| 2040 | | } |
| 1977 | memory_write_byte(space, offset, data); |
| 2041 | 1978 | else /* Mode 25 has SRAM not mirrored from lower banks */ |
| 2042 | 1979 | { |
| 2043 | 1980 | if (address < 0x6000) |
| 2044 | | { |
| 2045 | | if (offset < 0x300000) |
| 2046 | | snes_w_bank1(space, offset, data); |
| 2047 | | else |
| 2048 | | snes_w_bank2(space, offset - 0x300000, data); |
| 2049 | | } |
| 1981 | memory_write_byte(space, offset, data); |
| 2050 | 1982 | else if ((offset >= 0x300000) && (snes_cart.sram > 0)) |
| 2051 | 1983 | { |
| 2052 | 1984 | int mask = ((snes_cart.sram * 1024) - 1); /* Limit SRAM size to what's actually present */ |
| r7662 | r7663 | |
| 2065 | 1997 | dsp3_write(address, data); |
| 2066 | 1998 | else if ((snes_has_addon_chip == HAS_DSP4) && (offset >= 0x300000) && (address < 0xc000)) |
| 2067 | 1999 | dsp4_write(data); |
| 2068 | | else if (snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 2069 | | logerror( "snes_w_bank6 hit (ROM) in Super FX mode, please fix me\n" ); |
| 2070 | 2000 | else |
| 2071 | 2001 | logerror("Attempt to write to ROM address: %X\n", offset + 0x800000); |
| 2072 | 2002 | } |
| r7662 | r7663 | |
| 2075 | 2005 | /* 0xc00000 - 0xffffff */ |
| 2076 | 2006 | WRITE8_HANDLER( snes_w_bank7 ) |
| 2077 | 2007 | { |
| 2078 | | snes_state *state = (snes_state *)space->machine->driver_data; |
| 2079 | 2008 | UINT16 address = offset & 0xffff; |
| 2080 | 2009 | |
| 2081 | | if (snes_has_addon_chip == HAS_SUPERFX && state->superfx != NULL) |
| 2010 | if (snes_has_addon_chip == HAS_SUPERFX) |
| 2082 | 2011 | { |
| 2083 | 2012 | if (offset >= 0x200000) |
| 2084 | | { |
| 2085 | | logerror( "snes_w_bank7 hit (ROM) in Super FX mode, please fix me\n" ); |
| 2086 | | } |
| 2013 | snes_ram[0xc00000 + offset] = data; // SFX RAM |
| 2087 | 2014 | else |
| 2088 | | { |
| 2089 | | logerror( "snes_w_bank7 hit (RAM) in Super FX mode, please fix me\n" ); |
| 2090 | | } |
| 2015 | logerror("Attempt to write to ROM address: %X\n", offset + 0xc00000); |
| 2091 | 2016 | } |
| 2092 | 2017 | else if (snes_has_addon_chip == HAS_ST010 && offset >= 0x280000 && offset < 0x300000 && address < 0x1000) |
| 2093 | | { |
| 2094 | 2018 | st010_write(address, data); |
| 2095 | | } |
| 2096 | 2019 | else if (snes_cart.mode & 5) /* Mode 20 & 22 */ |
| 2097 | 2020 | { |
| 2098 | 2021 | if (address < 0x8000) |
| r7662 | r7663 | |
| 2391 | 2314 | |
| 2392 | 2315 | // reset does this to these registers |
| 2393 | 2316 | snes_ram[NMITIMEN] = 0; |
| 2394 | | snes_ram[HTIMEL] = 0xff; |
| 2395 | | snes_ram[HTIMEH] = 0x1; |
| 2396 | | snes_ram[VTIMEL] = 0xff; |
| 2397 | | snes_ram[VTIMEH] = 0x1; |
| 2317 | state->htime = 0x1ff; |
| 2318 | state->vtime = 0x1ff; |
| 2398 | 2319 | |
| 2399 | 2320 | state->htmult = 1; |
| 2400 | 2321 | snes_ppu.interlace = 1; |
| r7662 | r7663 | |
| 2884 | 2805 | |
| 2885 | 2806 | READ8_HANDLER( superfx_r_bank3 ) |
| 2886 | 2807 | { |
| 2887 | | //printf( "superfx_r_bank3: %08x = %02x\n", 0x600000 + offset, snes_ram[0x600000 + offset] ); |
| 2888 | | return snes_ram[0x600000 + offset]; |
| 2808 | /* IMPORTANT: SFX RAM sits in 0x600000-0x7fffff, and it's mirrored in 0xe00000-0xffffff. However, SNES |
| 2809 | has only access to 0x600000-0x7d00000 (because there is WRAM after that), hence we directly use the mirror |
| 2810 | as the place where to write & read SFX RAM. SNES handlers have been setup accordingly. */ |
| 2811 | //printf("superfx_r_bank3: %08x = %02x\n", offset, snes_ram[0xe00000 + offset]); |
| 2812 | return snes_ram[0xe00000 + offset]; |
| 2889 | 2813 | } |
| 2890 | 2814 | |
| 2891 | 2815 | WRITE8_HANDLER( superfx_w_bank1 ) |
| 2892 | 2816 | { |
| 2893 | | printf( "Attempting to write to cart ROM: %08x = %02x\n", offset, data ); |
| 2817 | printf("Attempting to write to cart ROM: %08x = %02x\n", offset, data); |
| 2894 | 2818 | // Do nothing; can't write to cart ROM. |
| 2895 | 2819 | } |
| 2896 | 2820 | |
| 2897 | 2821 | WRITE8_HANDLER( superfx_w_bank2 ) |
| 2898 | 2822 | { |
| 2899 | | printf( "Attempting to write to cart ROM: %08x = %02x\n", 0x400000 + offset, data ); |
| 2823 | printf("Attempting to write to cart ROM: %08x = %02x\n", 0x400000 + offset, data); |
| 2900 | 2824 | // Do nothing; can't write to cart ROM. |
| 2901 | 2825 | } |
| 2902 | 2826 | |
| 2903 | 2827 | WRITE8_HANDLER( superfx_w_bank3 ) |
| 2904 | 2828 | { |
| 2905 | | //printf( "superfx_w_bank3: %08x = %02x\n", 0x600000 + offset, data ); |
| 2906 | | snes_ram[0x600000 + offset] = data; |
| 2829 | /* IMPORTANT: SFX RAM sits in 0x600000-0x7f00000, and it's mirrored in 0xe00000-0xff00000. However, SNES |
| 2830 | has only access to 0x600000-0x7d00000 (because there is WRAM after that), hence we directly use the mirror |
| 2831 | as the place where to write & read SFX RAM. SNES handlers have been setup accordingly. */ |
| 2832 | //printf("superfx_w_bank3: %08x = %02x\n", offset, data); |
| 2833 | snes_ram[0xe00000 + offset] = data; |
| 2907 | 2834 | } |
src/emu/cpu/superfx/superfx.c
| r7662 | r7663 | |
| 61 | 61 | cache_t cache; |
| 62 | 62 | pixelcache_t pixelcache[2]; |
| 63 | 63 | |
| 64 | | running_device *device; |
| 65 | | const address_space *program; |
| 66 | | int icount; |
| 64 | running_device *device; |
| 65 | const address_space *program; |
| 66 | int icount; |
| 67 | 67 | }; |
| 68 | 68 | |
| 69 | 69 | INLINE superfx_state *get_safe_token(running_device *device) |
| 70 | 70 | { |
| 71 | | assert(device != NULL); |
| 72 | | assert(device->token != NULL); |
| 73 | | assert(device->type == CPU); |
| 74 | | assert(cpu_get_type(device) == CPU_SUPERFX); |
| 75 | | return (superfx_state *)device->token; |
| 71 | assert(device != NULL); |
| 72 | assert(device->token != NULL); |
| 73 | assert(device->type == CPU); |
| 74 | assert(cpu_get_type(device) == CPU_SUPERFX); |
| 75 | return (superfx_state *)device->token; |
| 76 | 76 | } |
| 77 | 77 | |
| 78 | 78 | /*****************************************************************************/ |
| r7662 | r7663 | |
| 648 | 648 | |
| 649 | 649 | /*****************************************************************************/ |
| 650 | 650 | |
| 651 | static void superfx_register_save( running_device *device ) |
| 652 | { |
| 653 | superfx_state *cpustate = get_safe_token(device); |
| 654 | int i; |
| 655 | |
| 656 | state_save_register_device_item(device, 0, cpustate->pipeline); |
| 657 | state_save_register_device_item(device, 0, cpustate->ramaddr); |
| 658 | |
| 659 | state_save_register_device_item_array(device, 0, cpustate->r); |
| 660 | state_save_register_device_item(device, 0, cpustate->sfr); |
| 661 | state_save_register_device_item(device, 0, cpustate->pbr); |
| 662 | state_save_register_device_item(device, 0, cpustate->rombr); |
| 663 | state_save_register_device_item(device, 0, cpustate->rambr); |
| 664 | state_save_register_device_item(device, 0, cpustate->cbr); |
| 665 | state_save_register_device_item(device, 0, cpustate->scbr); |
| 666 | state_save_register_device_item(device, 0, cpustate->scmr); |
| 667 | state_save_register_device_item(device, 0, cpustate->colr); |
| 668 | state_save_register_device_item(device, 0, cpustate->por); |
| 669 | state_save_register_device_item(device, 0, cpustate->bramr); |
| 670 | state_save_register_device_item(device, 0, cpustate->vcr); |
| 671 | state_save_register_device_item(device, 0, cpustate->cfgr); |
| 672 | state_save_register_device_item(device, 0, cpustate->clsr); |
| 673 | |
| 674 | state_save_register_device_item(device, 0, cpustate->romcl); |
| 675 | state_save_register_device_item(device, 0, cpustate->romdr); |
| 676 | |
| 677 | state_save_register_device_item(device, 0, cpustate->ramcl); |
| 678 | state_save_register_device_item(device, 0, cpustate->ramar); |
| 679 | state_save_register_device_item(device, 0, cpustate->ramdr); |
| 680 | |
| 681 | state_save_register_device_item(device, 0, cpustate->sreg_idx); |
| 682 | state_save_register_device_item(device, 0, cpustate->dreg_idx); |
| 683 | state_save_register_device_item(device, 0, cpustate->r15_modified); |
| 684 | |
| 685 | state_save_register_device_item(device, 0, cpustate->irq); |
| 686 | |
| 687 | state_save_register_device_item(device, 0, cpustate->cache_access_speed); |
| 688 | state_save_register_device_item(device, 0, cpustate->memory_access_speed); |
| 689 | |
| 690 | state_save_register_device_item_array(device, 0, cpustate->cache.buffer); |
| 691 | state_save_register_device_item_array(device, 0, cpustate->cache.valid); |
| 692 | |
| 693 | for (i = 0; i < 2; i++) |
| 694 | { |
| 695 | state_save_register_device_item(device, i, cpustate->pixelcache[i].offset); |
| 696 | state_save_register_device_item(device, i, cpustate->pixelcache[i].bitpend); |
| 697 | state_save_register_device_item_array(device, i, cpustate->pixelcache[i].data); |
| 698 | } |
| 699 | |
| 700 | state_save_register_device_item(device, 0, cpustate->icount); |
| 701 | } |
| 702 | |
| 651 | 703 | static CPU_INIT( superfx ) |
| 652 | 704 | { |
| 653 | 705 | int i; |
| 654 | | superfx_state *cpustate = get_safe_token(device); |
| 706 | superfx_state *cpustate = get_safe_token(device); |
| 655 | 707 | |
| 656 | 708 | for(i = 0; i < 16; i++) |
| 657 | 709 | { |
| r7662 | r7663 | |
| 679 | 731 | superfx_memory_reset(cpustate); |
| 680 | 732 | superfx_update_speed(cpustate); |
| 681 | 733 | |
| 682 | | cpustate->device = device; |
| 683 | | cpustate->program = device->space(AS_PROGRAM); |
| 734 | cpustate->device = device; |
| 735 | cpustate->program = device->space(AS_PROGRAM); |
| 684 | 736 | |
| 685 | 737 | if (device->baseconfig().static_config != NULL) |
| 686 | 738 | { |
| r7662 | r7663 | |
| 688 | 740 | } |
| 689 | 741 | |
| 690 | 742 | devcb_resolve_write_line(&cpustate->out_irq_func, &cpustate->config.out_irq_func, device); |
| 743 | |
| 744 | superfx_register_save(device); |
| 691 | 745 | } |
| 692 | 746 | |
| 693 | 747 | static CPU_EXIT( superfx ) |
| r7662 | r7663 | |
| 698 | 752 | { |
| 699 | 753 | int i; |
| 700 | 754 | |
| 701 | | superfx_state *cpustate = get_safe_token(device); |
| 755 | superfx_state *cpustate = get_safe_token(device); |
| 702 | 756 | |
| 703 | 757 | for(i = 0; i < 16; i++) |
| 704 | 758 | { |
| r7662 | r7663 | |
| 756 | 810 | |
| 757 | 811 | debugger_instruction_hook(device, (cpustate->pbr << 16) | cpustate->r[15]); |
| 758 | 812 | |
| 759 | | op = superfx_peekpipe(cpustate); |
| 813 | op = superfx_peekpipe(cpustate); |
| 760 | 814 | |
| 761 | 815 | switch(op) |
| 762 | 816 | { |
| r7662 | r7663 | |
| 1098 | 1152 | superfx_regs_reset(cpustate); |
| 1099 | 1153 | break; |
| 1100 | 1154 | |
| 1101 | | case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: |
| 1155 | case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: |
| 1102 | 1156 | case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c: case 0x7d: case 0x7e: case 0x7f: // AND / BIC / ANDI / BICI |
| 1103 | 1157 | switch(cpustate->sfr & SUPERFX_SFR_ALT) |
| 1104 | 1158 | { |
| r7662 | r7663 | |
| 1284 | 1338 | superfx_regs_reset(cpustate); |
| 1285 | 1339 | break; |
| 1286 | 1340 | |
| 1287 | | case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: |
| 1341 | case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: |
| 1288 | 1342 | case 0xc8: case 0xc9: case 0xca: case 0xcb: case 0xcc: case 0xcd: case 0xce: case 0xcf: // OR / XOR / ORI / XORI |
| 1289 | 1343 | switch(cpustate->sfr & SUPERFX_SFR_ALT) |
| 1290 | 1344 | { |
| r7662 | r7663 | |
| 1408 | 1462 | //printf( " r8:%04x r9:%04x r10:%04x r11:%04x r12:%04x r13:%04x r14:%04x r15:%04x\n", cpustate->r[8], cpustate->r[9], cpustate->r[10], cpustate->r[11], cpustate->r[12], cpustate->r[13], cpustate->r[14], cpustate->r[15] ); |
| 1409 | 1463 | //printf( "sfr:%04x\n", cpustate->sfr ); |
| 1410 | 1464 | |
| 1411 | | --cpustate->icount; |
| 1412 | | } |
| 1465 | --cpustate->icount; |
| 1466 | } |
| 1413 | 1467 | |
| 1414 | | return cycles - cpustate->icount; |
| 1468 | return cycles - cpustate->icount; |
| 1415 | 1469 | } |
| 1416 | 1470 | |
| 1417 | 1471 | /*****************************************************************************/ |
| r7662 | r7663 | |
| 1420 | 1474 | { |
| 1421 | 1475 | superfx_state *cpustate = get_safe_token(device); |
| 1422 | 1476 | |
| 1423 | | UINT8 op = *(UINT8 *)(opram + 0); |
| 1424 | | UINT8 param0 = *(UINT8 *)(opram + 1); |
| 1425 | | UINT8 param1 = *(UINT8 *)(opram + 2); |
| 1426 | | UINT16 alt = cpustate->sfr & SUPERFX_SFR_ALT; |
| 1477 | UINT8 op = *(UINT8 *)(opram + 0); |
| 1478 | UINT8 param0 = *(UINT8 *)(opram + 1); |
| 1479 | UINT8 param1 = *(UINT8 *)(opram + 2); |
| 1480 | UINT16 alt = cpustate->sfr & SUPERFX_SFR_ALT; |
| 1427 | 1481 | |
| 1428 | | return superfx_dasm_one(buffer, pc, op, param0, param1, alt); |
| 1482 | return superfx_dasm_one(buffer, pc, op, param0, param1, alt); |
| 1429 | 1483 | } |
| 1430 | 1484 | |
| 1431 | 1485 | /*****************************************************************************/ |
| 1432 | 1486 | |
| 1433 | 1487 | static CPU_SET_INFO( superfx ) |
| 1434 | 1488 | { |
| 1435 | | superfx_state *cpustate = get_safe_token(device); |
| 1489 | superfx_state *cpustate = get_safe_token(device); |
| 1436 | 1490 | |
| 1437 | | switch (state) |
| 1438 | | { |
| 1439 | | /* --- the following bits of info are set as 64-bit signed integers --- */ |
| 1440 | | case CPUINFO_INT_PC: |
| 1441 | | case CPUINFO_INT_REGISTER + SUPERFX_PC: cpustate->r[15] = info->i; break; |
| 1442 | | case CPUINFO_INT_REGISTER + SUPERFX_DREG: info->i = cpustate->dreg_idx; break; |
| 1443 | | case CPUINFO_INT_REGISTER + SUPERFX_SREG: info->i = cpustate->sreg_idx; break; |
| 1444 | | case CPUINFO_INT_REGISTER + SUPERFX_R0: cpustate->r[0] = info->i; break; |
| 1445 | | case CPUINFO_INT_REGISTER + SUPERFX_R1: cpustate->r[1] = info->i; break; |
| 1446 | | case CPUINFO_INT_REGISTER + SUPERFX_R2: cpustate->r[2] = info->i; break; |
| 1447 | | case CPUINFO_INT_REGISTER + SUPERFX_R3: cpustate->r[3] = info->i; break; |
| 1448 | | case CPUINFO_INT_REGISTER + SUPERFX_R4: cpustate->r[4] = info->i; break; |
| 1449 | | case CPUINFO_INT_REGISTER + SUPERFX_R5: cpustate->r[5] = info->i; break; |
| 1450 | | case CPUINFO_INT_REGISTER + SUPERFX_R6: cpustate->r[6] = info->i; break; |
| 1451 | | case CPUINFO_INT_REGISTER + SUPERFX_R7: cpustate->r[7] = info->i; break; |
| 1452 | | case CPUINFO_INT_REGISTER + SUPERFX_R8: cpustate->r[8] = info->i; break; |
| 1453 | | case CPUINFO_INT_REGISTER + SUPERFX_R9: cpustate->r[9] = info->i; break; |
| 1454 | | case CPUINFO_INT_REGISTER + SUPERFX_R10: cpustate->r[10] = info->i; break; |
| 1455 | | case CPUINFO_INT_REGISTER + SUPERFX_R11: cpustate->r[11] = info->i; break; |
| 1456 | | case CPUINFO_INT_REGISTER + SUPERFX_R12: cpustate->r[12] = info->i; break; |
| 1457 | | case CPUINFO_INT_REGISTER + SUPERFX_R13: cpustate->r[13] = info->i; break; |
| 1458 | | case CPUINFO_INT_REGISTER + SUPERFX_R14: cpustate->r[14] = info->i; break; |
| 1459 | | case CPUINFO_INT_REGISTER + SUPERFX_R15: cpustate->r[15] = info->i; break; |
| 1460 | | case CPUINFO_INT_REGISTER + SUPERFX_SFR: cpustate->sfr = info->i; break; |
| 1461 | | case CPUINFO_INT_REGISTER + SUPERFX_PBR: cpustate->pbr = info->i; break; |
| 1462 | | case CPUINFO_INT_REGISTER + SUPERFX_ROMBR: cpustate->rombr = info->i; break; |
| 1463 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMBR: cpustate->rambr = info->i; break; |
| 1464 | | case CPUINFO_INT_REGISTER + SUPERFX_CBR: cpustate->cbr = info->i; break; |
| 1465 | | case CPUINFO_INT_REGISTER + SUPERFX_SCBR: cpustate->scbr = info->i; break; |
| 1466 | | case CPUINFO_INT_REGISTER + SUPERFX_SCMR: cpustate->scmr = info->i; break; |
| 1467 | | case CPUINFO_INT_REGISTER + SUPERFX_COLR: cpustate->colr = info->i; break; |
| 1468 | | case CPUINFO_INT_REGISTER + SUPERFX_POR: cpustate->por = info->i; break; |
| 1469 | | case CPUINFO_INT_REGISTER + SUPERFX_BRAMR: cpustate->bramr = info->i; break; |
| 1470 | | case CPUINFO_INT_REGISTER + SUPERFX_VCR: cpustate->vcr = info->i; break; |
| 1471 | | case CPUINFO_INT_REGISTER + SUPERFX_CFGR: cpustate->cfgr = info->i; break; |
| 1472 | | case CPUINFO_INT_REGISTER + SUPERFX_CLSR: cpustate->clsr = info->i; break; |
| 1473 | | case CPUINFO_INT_REGISTER + SUPERFX_ROMCL: cpustate->romcl = info->i; break; |
| 1474 | | case CPUINFO_INT_REGISTER + SUPERFX_ROMDR: cpustate->romdr = info->i; break; |
| 1475 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMCL: cpustate->ramcl = info->i; break; |
| 1476 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMAR: cpustate->ramar = info->i; break; |
| 1477 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMDR: cpustate->ramdr = info->i; break; |
| 1478 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMADDR: cpustate->ramaddr = info->i; break; |
| 1491 | switch (state) |
| 1492 | { |
| 1493 | /* --- the following bits of info are set as 64-bit signed integers --- */ |
| 1494 | case CPUINFO_INT_PC: |
| 1495 | case CPUINFO_INT_REGISTER + SUPERFX_PC: cpustate->r[15] = info->i; break; |
| 1496 | case CPUINFO_INT_REGISTER + SUPERFX_DREG: info->i = cpustate->dreg_idx; break; |
| 1497 | case CPUINFO_INT_REGISTER + SUPERFX_SREG: info->i = cpustate->sreg_idx; break; |
| 1498 | case CPUINFO_INT_REGISTER + SUPERFX_R0: cpustate->r[0] = info->i; break; |
| 1499 | case CPUINFO_INT_REGISTER + SUPERFX_R1: cpustate->r[1] = info->i; break; |
| 1500 | case CPUINFO_INT_REGISTER + SUPERFX_R2: cpustate->r[2] = info->i; break; |
| 1501 | case CPUINFO_INT_REGISTER + SUPERFX_R3: cpustate->r[3] = info->i; break; |
| 1502 | case CPUINFO_INT_REGISTER + SUPERFX_R4: cpustate->r[4] = info->i; break; |
| 1503 | case CPUINFO_INT_REGISTER + SUPERFX_R5: cpustate->r[5] = info->i; break; |
| 1504 | case CPUINFO_INT_REGISTER + SUPERFX_R6: cpustate->r[6] = info->i; break; |
| 1505 | case CPUINFO_INT_REGISTER + SUPERFX_R7: cpustate->r[7] = info->i; break; |
| 1506 | case CPUINFO_INT_REGISTER + SUPERFX_R8: cpustate->r[8] = info->i; break; |
| 1507 | case CPUINFO_INT_REGISTER + SUPERFX_R9: cpustate->r[9] = info->i; break; |
| 1508 | case CPUINFO_INT_REGISTER + SUPERFX_R10: cpustate->r[10] = info->i; break; |
| 1509 | case CPUINFO_INT_REGISTER + SUPERFX_R11: cpustate->r[11] = info->i; break; |
| 1510 | case CPUINFO_INT_REGISTER + SUPERFX_R12: cpustate->r[12] = info->i; break; |
| 1511 | case CPUINFO_INT_REGISTER + SUPERFX_R13: cpustate->r[13] = info->i; break; |
| 1512 | case CPUINFO_INT_REGISTER + SUPERFX_R14: cpustate->r[14] = info->i; break; |
| 1513 | case CPUINFO_INT_REGISTER + SUPERFX_R15: cpustate->r[15] = info->i; break; |
| 1514 | case CPUINFO_INT_REGISTER + SUPERFX_SFR: cpustate->sfr = info->i; break; |
| 1515 | case CPUINFO_INT_REGISTER + SUPERFX_PBR: cpustate->pbr = info->i; break; |
| 1516 | case CPUINFO_INT_REGISTER + SUPERFX_ROMBR: cpustate->rombr = info->i; break; |
| 1517 | case CPUINFO_INT_REGISTER + SUPERFX_RAMBR: cpustate->rambr = info->i; break; |
| 1518 | case CPUINFO_INT_REGISTER + SUPERFX_CBR: cpustate->cbr = info->i; break; |
| 1519 | case CPUINFO_INT_REGISTER + SUPERFX_SCBR: cpustate->scbr = info->i; break; |
| 1520 | case CPUINFO_INT_REGISTER + SUPERFX_SCMR: cpustate->scmr = info->i; break; |
| 1521 | case CPUINFO_INT_REGISTER + SUPERFX_COLR: cpustate->colr = info->i; break; |
| 1522 | case CPUINFO_INT_REGISTER + SUPERFX_POR: cpustate->por = info->i; break; |
| 1523 | case CPUINFO_INT_REGISTER + SUPERFX_BRAMR: cpustate->bramr = info->i; break; |
| 1524 | case CPUINFO_INT_REGISTER + SUPERFX_VCR: cpustate->vcr = info->i; break; |
| 1525 | case CPUINFO_INT_REGISTER + SUPERFX_CFGR: cpustate->cfgr = info->i; break; |
| 1526 | case CPUINFO_INT_REGISTER + SUPERFX_CLSR: cpustate->clsr = info->i; break; |
| 1527 | case CPUINFO_INT_REGISTER + SUPERFX_ROMCL: cpustate->romcl = info->i; break; |
| 1528 | case CPUINFO_INT_REGISTER + SUPERFX_ROMDR: cpustate->romdr = info->i; break; |
| 1529 | case CPUINFO_INT_REGISTER + SUPERFX_RAMCL: cpustate->ramcl = info->i; break; |
| 1530 | case CPUINFO_INT_REGISTER + SUPERFX_RAMAR: cpustate->ramar = info->i; break; |
| 1531 | case CPUINFO_INT_REGISTER + SUPERFX_RAMDR: cpustate->ramdr = info->i; break; |
| 1532 | case CPUINFO_INT_REGISTER + SUPERFX_RAMADDR: cpustate->ramaddr = info->i; break; |
| 1479 | 1533 | } |
| 1480 | 1534 | } |
| 1481 | 1535 | |
| 1482 | 1536 | CPU_GET_INFO( superfx ) |
| 1483 | 1537 | { |
| 1484 | | superfx_state *cpustate = (device != NULL && device->token != NULL) ? get_safe_token(device) : NULL; |
| 1538 | superfx_state *cpustate = (device != NULL && device->token != NULL) ? get_safe_token(device) : NULL; |
| 1485 | 1539 | |
| 1486 | | switch(state) |
| 1487 | | { |
| 1488 | | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 1489 | | case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(superfx_state); break; |
| 1490 | | case CPUINFO_INT_INPUT_LINES: info->i = 0; break; |
| 1491 | | case CPUINFO_INT_DEFAULT_IRQ_VECTOR: info->i = 0; break; |
| 1492 | | case DEVINFO_INT_ENDIANNESS: info->i = ENDIANNESS_LITTLE; break; |
| 1493 | | case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break; |
| 1494 | | case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break; |
| 1495 | | case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 1; break; |
| 1496 | | case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 3; break; |
| 1497 | | case CPUINFO_INT_MIN_CYCLES: info->i = 1; break; |
| 1498 | | case CPUINFO_INT_MAX_CYCLES: info->i = 1; break; |
| 1540 | switch(state) |
| 1541 | { |
| 1542 | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 1543 | case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(superfx_state); break; |
| 1544 | case CPUINFO_INT_INPUT_LINES: info->i = 0; break; |
| 1545 | case CPUINFO_INT_DEFAULT_IRQ_VECTOR: info->i = 0; break; |
| 1546 | case DEVINFO_INT_ENDIANNESS: info->i = ENDIANNESS_LITTLE; break; |
| 1547 | case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break; |
| 1548 | case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break; |
| 1549 | case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 1; break; |
| 1550 | case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 3; break; |
| 1551 | case CPUINFO_INT_MIN_CYCLES: info->i = 1; break; |
| 1552 | case CPUINFO_INT_MAX_CYCLES: info->i = 1; break; |
| 1499 | 1553 | |
| 1500 | | case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_PROGRAM: info->i = 8; break; |
| 1501 | | case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_PROGRAM: info->i = 32; break; |
| 1502 | | case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_PROGRAM: info->i = 0; break; |
| 1503 | | case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_DATA: info->i = 0; break; |
| 1504 | | case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_DATA: info->i = 0; break; |
| 1505 | | case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_DATA: info->i = 0; break; |
| 1506 | | case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_IO: info->i = 0; break; |
| 1507 | | case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_IO: info->i = 0; break; |
| 1508 | | case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_IO: info->i = 0; break; |
| 1554 | case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_PROGRAM: info->i = 8; break; |
| 1555 | case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_PROGRAM: info->i = 32; break; |
| 1556 | case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_PROGRAM: info->i = 0; break; |
| 1557 | case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_DATA: info->i = 0; break; |
| 1558 | case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_DATA: info->i = 0; break; |
| 1559 | case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_DATA: info->i = 0; break; |
| 1560 | case DEVINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_IO: info->i = 0; break; |
| 1561 | case DEVINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_IO: info->i = 0; break; |
| 1562 | case DEVINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_IO: info->i = 0; break; |
| 1509 | 1563 | |
| 1510 | | case CPUINFO_INT_PC: /* intentional fallthrough */ |
| 1511 | | case CPUINFO_INT_REGISTER + SUPERFX_PC: info->i = ((cpustate->pbr << 16) | cpustate->r[15]) - 1; break; |
| 1512 | | case CPUINFO_INT_REGISTER + SUPERFX_DREG: info->i = cpustate->dreg_idx; break; |
| 1513 | | case CPUINFO_INT_REGISTER + SUPERFX_SREG: info->i = cpustate->sreg_idx; break; |
| 1514 | | case CPUINFO_INT_REGISTER + SUPERFX_R0: info->i = cpustate->r[0]; break; |
| 1515 | | case CPUINFO_INT_REGISTER + SUPERFX_R1: info->i = cpustate->r[1]; break; |
| 1516 | | case CPUINFO_INT_REGISTER + SUPERFX_R2: info->i = cpustate->r[2]; break; |
| 1517 | | case CPUINFO_INT_REGISTER + SUPERFX_R3: info->i = cpustate->r[3]; break; |
| 1518 | | case CPUINFO_INT_REGISTER + SUPERFX_R4: info->i = cpustate->r[4]; break; |
| 1519 | | case CPUINFO_INT_REGISTER + SUPERFX_R5: info->i = cpustate->r[5]; break; |
| 1520 | | case CPUINFO_INT_REGISTER + SUPERFX_R6: info->i = cpustate->r[6]; break; |
| 1521 | | case CPUINFO_INT_REGISTER + SUPERFX_R7: info->i = cpustate->r[7]; break; |
| 1522 | | case CPUINFO_INT_REGISTER + SUPERFX_R8: info->i = cpustate->r[8]; break; |
| 1523 | | case CPUINFO_INT_REGISTER + SUPERFX_R9: info->i = cpustate->r[9]; break; |
| 1524 | | case CPUINFO_INT_REGISTER + SUPERFX_R10: info->i = cpustate->r[10]; break; |
| 1525 | | case CPUINFO_INT_REGISTER + SUPERFX_R11: info->i = cpustate->r[11]; break; |
| 1526 | | case CPUINFO_INT_REGISTER + SUPERFX_R12: info->i = cpustate->r[12]; break; |
| 1527 | | case CPUINFO_INT_REGISTER + SUPERFX_R13: info->i = cpustate->r[13]; break; |
| 1528 | | case CPUINFO_INT_REGISTER + SUPERFX_R14: info->i = cpustate->r[14]; break; |
| 1529 | | case CPUINFO_INT_REGISTER + SUPERFX_R15: info->i = cpustate->r[15]; break; |
| 1530 | | case CPUINFO_INT_REGISTER + SUPERFX_SFR: info->i = cpustate->sfr; break; |
| 1531 | | case CPUINFO_INT_REGISTER + SUPERFX_PBR: info->i = cpustate->sfr; break; |
| 1532 | | case CPUINFO_INT_REGISTER + SUPERFX_ROMBR: info->i = cpustate->rombr; break; |
| 1533 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMBR: info->i = cpustate->rambr; break; |
| 1534 | | case CPUINFO_INT_REGISTER + SUPERFX_CBR: info->i = cpustate->cbr; break; |
| 1535 | | case CPUINFO_INT_REGISTER + SUPERFX_SCBR: info->i = cpustate->scbr; break; |
| 1536 | | case CPUINFO_INT_REGISTER + SUPERFX_SCMR: info->i = cpustate->scmr; break; |
| 1537 | | case CPUINFO_INT_REGISTER + SUPERFX_COLR: info->i = cpustate->colr; break; |
| 1538 | | case CPUINFO_INT_REGISTER + SUPERFX_POR: info->i = cpustate->por; break; |
| 1539 | | case CPUINFO_INT_REGISTER + SUPERFX_BRAMR: info->i = cpustate->bramr; break; |
| 1540 | | case CPUINFO_INT_REGISTER + SUPERFX_VCR: info->i = cpustate->vcr; break; |
| 1541 | | case CPUINFO_INT_REGISTER + SUPERFX_CFGR: info->i = cpustate->cfgr; break; |
| 1542 | | case CPUINFO_INT_REGISTER + SUPERFX_CLSR: info->i = cpustate->clsr; break; |
| 1543 | | case CPUINFO_INT_REGISTER + SUPERFX_ROMCL: info->i = cpustate->romcl; break; |
| 1544 | | case CPUINFO_INT_REGISTER + SUPERFX_ROMDR: info->i = cpustate->romdr; break; |
| 1545 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMCL: info->i = cpustate->ramcl; break; |
| 1546 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMAR: info->i = cpustate->ramar; break; |
| 1547 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMDR: info->i = cpustate->ramdr; break; |
| 1548 | | case CPUINFO_INT_REGISTER + SUPERFX_RAMADDR: info->i = cpustate->ramaddr; break; |
| 1564 | case CPUINFO_INT_PC: /* intentional fallthrough */ |
| 1565 | case CPUINFO_INT_REGISTER + SUPERFX_PC: info->i = ((cpustate->pbr << 16) | cpustate->r[15]) - 1; break; |
| 1566 | case CPUINFO_INT_REGISTER + SUPERFX_DREG: info->i = cpustate->dreg_idx; break; |
| 1567 | case CPUINFO_INT_REGISTER + SUPERFX_SREG: info->i = cpustate->sreg_idx; break; |
| 1568 | case CPUINFO_INT_REGISTER + SUPERFX_R0: info->i = cpustate->r[0]; break; |
| 1569 | case CPUINFO_INT_REGISTER + SUPERFX_R1: info->i = cpustate->r[1]; break; |
| 1570 | case CPUINFO_INT_REGISTER + SUPERFX_R2: info->i = cpustate->r[2]; break; |
| 1571 | case CPUINFO_INT_REGISTER + SUPERFX_R3: info->i = cpustate->r[3]; break; |
| 1572 | case CPUINFO_INT_REGISTER + SUPERFX_R4: info->i = cpustate->r[4]; break; |
| 1573 | case CPUINFO_INT_REGISTER + SUPERFX_R5: info->i = cpustate->r[5]; break; |
| 1574 | case CPUINFO_INT_REGISTER + SUPERFX_R6: info->i = cpustate->r[6]; break; |
| 1575 | case CPUINFO_INT_REGISTER + SUPERFX_R7: info->i = cpustate->r[7]; break; |
| 1576 | case CPUINFO_INT_REGISTER + SUPERFX_R8: info->i = cpustate->r[8]; break; |
| 1577 | case CPUINFO_INT_REGISTER + SUPERFX_R9: info->i = cpustate->r[9]; break; |
| 1578 | case CPUINFO_INT_REGISTER + SUPERFX_R10: info->i = cpustate->r[10]; break; |
| 1579 | case CPUINFO_INT_REGISTER + SUPERFX_R11: info->i = cpustate->r[11]; break; |
| 1580 | case CPUINFO_INT_REGISTER + SUPERFX_R12: info->i = cpustate->r[12]; break; |
| 1581 | case CPUINFO_INT_REGISTER + SUPERFX_R13: info->i = cpustate->r[13]; break; |
| 1582 | case CPUINFO_INT_REGISTER + SUPERFX_R14: info->i = cpustate->r[14]; break; |
| 1583 | case CPUINFO_INT_REGISTER + SUPERFX_R15: info->i = cpustate->r[15]; break; |
| 1584 | case CPUINFO_INT_REGISTER + SUPERFX_SFR: info->i = cpustate->sfr; break; |
| 1585 | case CPUINFO_INT_REGISTER + SUPERFX_PBR: info->i = cpustate->sfr; break; |
| 1586 | case CPUINFO_INT_REGISTER + SUPERFX_ROMBR: info->i = cpustate->rombr; break; |
| 1587 | case CPUINFO_INT_REGISTER + SUPERFX_RAMBR: info->i = cpustate->rambr; break; |
| 1588 | case CPUINFO_INT_REGISTER + SUPERFX_CBR: info->i = cpustate->cbr; break; |
| 1589 | case CPUINFO_INT_REGISTER + SUPERFX_SCBR: info->i = cpustate->scbr; break; |
| 1590 | case CPUINFO_INT_REGISTER + SUPERFX_SCMR: info->i = cpustate->scmr; break; |
| 1591 | case CPUINFO_INT_REGISTER + SUPERFX_COLR: info->i = cpustate->colr; break; |
| 1592 | case CPUINFO_INT_REGISTER + SUPERFX_POR: info->i = cpustate->por; break; |
| 1593 | case CPUINFO_INT_REGISTER + SUPERFX_BRAMR: info->i = cpustate->bramr; break; |
| 1594 | case CPUINFO_INT_REGISTER + SUPERFX_VCR: info->i = cpustate->vcr; break; |
| 1595 | case CPUINFO_INT_REGISTER + SUPERFX_CFGR: info->i = cpustate->cfgr; break; |
| 1596 | case CPUINFO_INT_REGISTER + SUPERFX_CLSR: info->i = cpustate->clsr; break; |
| 1597 | case CPUINFO_INT_REGISTER + SUPERFX_ROMCL: info->i = cpustate->romcl; break; |
| 1598 | case CPUINFO_INT_REGISTER + SUPERFX_ROMDR: info->i = cpustate->romdr; break; |
| 1599 | case CPUINFO_INT_REGISTER + SUPERFX_RAMCL: info->i = cpustate->ramcl; break; |
| 1600 | case CPUINFO_INT_REGISTER + SUPERFX_RAMAR: info->i = cpustate->ramar; break; |
| 1601 | case CPUINFO_INT_REGISTER + SUPERFX_RAMDR: info->i = cpustate->ramdr; break; |
| 1602 | case CPUINFO_INT_REGISTER + SUPERFX_RAMADDR: info->i = cpustate->ramaddr; break; |
| 1549 | 1603 | |
| 1550 | 1604 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 1551 | | case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(superfx); break; |
| 1552 | | case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(superfx); break; |
| 1553 | | case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(superfx); break; |
| 1554 | | case CPUINFO_FCT_EXIT: info->exit = CPU_EXIT_NAME(superfx); break; |
| 1555 | | case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(superfx); break; |
| 1556 | | case CPUINFO_FCT_BURN: info->burn = NULL; break; |
| 1557 | | case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(superfx); break; |
| 1558 | | case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->icount; break; |
| 1605 | case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(superfx); break; |
| 1606 | case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(superfx); break; |
| 1607 | case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(superfx); break; |
| 1608 | case CPUINFO_FCT_EXIT: info->exit = CPU_EXIT_NAME(superfx); break; |
| 1609 | case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(superfx); break; |
| 1610 | case CPUINFO_FCT_BURN: info->burn = NULL; break; |
| 1611 | case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(superfx); break; |
| 1612 | case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->icount; break; |
| 1559 | 1613 | |
| 1560 | 1614 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 1561 | | case DEVINFO_STR_NAME: strcpy(info->s, "SuperFX"); break; |
| 1562 | | case DEVINFO_STR_FAMILY: strcpy(info->s, "SuperFX"); break; |
| 1563 | | case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break; |
| 1564 | | case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; |
| 1565 | | case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break; |
| 1615 | case DEVINFO_STR_NAME: strcpy(info->s, "SuperFX"); break; |
| 1616 | case DEVINFO_STR_FAMILY: strcpy(info->s, "SuperFX"); break; |
| 1617 | case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break; |
| 1618 | case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; |
| 1619 | case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright Nicola Salmoria and the MAME Team"); break; |
| 1566 | 1620 | |
| 1567 | | case CPUINFO_STR_FLAGS: strcpy(info->s, " "); break; |
| 1621 | case CPUINFO_STR_FLAGS: strcpy(info->s, " "); break; |
| 1568 | 1622 | |
| 1569 | | case CPUINFO_STR_REGISTER + SUPERFX_PC: sprintf(info->s, "PC: %06X", (cpustate->pbr << 16) | cpustate->r[15]); break; |
| 1570 | | case CPUINFO_STR_REGISTER + SUPERFX_DREG: sprintf(info->s, "DREG: R%d", cpustate->dreg_idx); break; |
| 1571 | | case CPUINFO_STR_REGISTER + SUPERFX_SREG: sprintf(info->s, "SREG: R%d", cpustate->sreg_idx); break; |
| 1572 | | case CPUINFO_STR_REGISTER + SUPERFX_R0: sprintf(info->s, "R0: %04X", cpustate->r[0]); break; |
| 1573 | | case CPUINFO_STR_REGISTER + SUPERFX_R1: sprintf(info->s, "R1: %04X", cpustate->r[1]); break; |
| 1574 | | case CPUINFO_STR_REGISTER + SUPERFX_R2: sprintf(info->s, "R2: %04X", cpustate->r[2]); break; |
| 1575 | | case CPUINFO_STR_REGISTER + SUPERFX_R3: sprintf(info->s, "R3: %04X", cpustate->r[3]); break; |
| 1576 | | case CPUINFO_STR_REGISTER + SUPERFX_R4: sprintf(info->s, "R4: %04X", cpustate->r[4]); break; |
| 1577 | | case CPUINFO_STR_REGISTER + SUPERFX_R5: sprintf(info->s, "R5: %04X", cpustate->r[5]); break; |
| 1578 | | case CPUINFO_STR_REGISTER + SUPERFX_R6: sprintf(info->s, "R6: %04X", cpustate->r[6]); break; |
| 1579 | | case CPUINFO_STR_REGISTER + SUPERFX_R7: sprintf(info->s, "R7: %04X", cpustate->r[7]); break; |
| 1580 | | case CPUINFO_STR_REGISTER + SUPERFX_R8: sprintf(info->s, "R8: %04X", cpustate->r[8]); break; |
| 1581 | | case CPUINFO_STR_REGISTER + SUPERFX_R9: sprintf(info->s, "R9: %04X", cpustate->r[9]); break; |
| 1582 | | case CPUINFO_STR_REGISTER + SUPERFX_R10: sprintf(info->s, "R10: %04X", cpustate->r[10]); break; |
| 1583 | | case CPUINFO_STR_REGISTER + SUPERFX_R11: sprintf(info->s, "R11: %04X", cpustate->r[11]); break; |
| 1584 | | case CPUINFO_STR_REGISTER + SUPERFX_R12: sprintf(info->s, "R12: %04X", cpustate->r[12]); break; |
| 1585 | | case CPUINFO_STR_REGISTER + SUPERFX_R13: sprintf(info->s, "R13: %04X", cpustate->r[13]); break; |
| 1586 | | case CPUINFO_STR_REGISTER + SUPERFX_R14: sprintf(info->s, "R14: %04X", cpustate->r[14]); break; |
| 1587 | | case CPUINFO_STR_REGISTER + SUPERFX_R15: sprintf(info->s, "R15: %04X", cpustate->r[15]); break; |
| 1588 | | case CPUINFO_STR_REGISTER + SUPERFX_SFR: sprintf(info->s, "SFR: %04X", cpustate->sfr); break; |
| 1589 | | case CPUINFO_STR_REGISTER + SUPERFX_PBR: sprintf(info->s, "PBR: %02X", cpustate->sfr); break; |
| 1590 | | case CPUINFO_STR_REGISTER + SUPERFX_ROMBR: sprintf(info->s, "ROMBR: %02X", cpustate->rombr); break; |
| 1591 | | case CPUINFO_STR_REGISTER + SUPERFX_RAMBR: sprintf(info->s, "RAMBR: %02X", cpustate->rambr); break; |
| 1592 | | case CPUINFO_STR_REGISTER + SUPERFX_CBR: sprintf(info->s, "CBR: %04X", cpustate->cbr); break; |
| 1593 | | case CPUINFO_STR_REGISTER + SUPERFX_SCBR: sprintf(info->s, "SCBR: %02X", cpustate->scbr); break; |
| 1594 | | case CPUINFO_STR_REGISTER + SUPERFX_SCMR: sprintf(info->s, "SCMR: %02X", cpustate->scmr); break; |
| 1595 | | case CPUINFO_STR_REGISTER + SUPERFX_COLR: sprintf(info->s, "COLR %02X", cpustate->colr); break; |
| 1596 | | case CPUINFO_STR_REGISTER + SUPERFX_POR: sprintf(info->s, "POR: %02X", cpustate->por); break; |
| 1597 | | case CPUINFO_STR_REGISTER + SUPERFX_BRAMR: sprintf(info->s, "BRAMR: %02X", cpustate->bramr); break; |
| 1598 | | case CPUINFO_STR_REGISTER + SUPERFX_VCR: sprintf(info->s, "VCR: %02X", cpustate->vcr); break; |
| 1599 | | case CPUINFO_STR_REGISTER + SUPERFX_CFGR: sprintf(info->s, "CFGR: %02X", cpustate->cfgr); break; |
| 1600 | | case CPUINFO_STR_REGISTER + SUPERFX_CLSR: sprintf(info->s, "CLSR: %02X", cpustate->clsr); break; |
| 1601 | | case CPUINFO_STR_REGISTER + SUPERFX_ROMCL: sprintf(info->s, "ROMCL: %08X", cpustate->romcl); break; |
| 1602 | | case CPUINFO_STR_REGISTER + SUPERFX_ROMDR: sprintf(info->s, "ROMDR: %02X", cpustate->romdr); break; |
| 1603 | | case CPUINFO_STR_REGISTER + SUPERFX_RAMCL: sprintf(info->s, "RAMCL: %08X", cpustate->ramcl); break; |
| 1604 | | case CPUINFO_STR_REGISTER + SUPERFX_RAMAR: sprintf(info->s, "RAMAR: %04X", cpustate->ramar); break; |
| 1605 | | case CPUINFO_STR_REGISTER + SUPERFX_RAMDR: sprintf(info->s, "RAMDR: %02X", cpustate->ramdr); break; |
| 1606 | | case CPUINFO_STR_REGISTER + SUPERFX_RAMADDR: sprintf(info->s, "RAMADDR: %04X", cpustate->ramaddr); break; |
| 1623 | case CPUINFO_STR_REGISTER + SUPERFX_PC: sprintf(info->s, "PC: %06X", (cpustate->pbr << 16) | cpustate->r[15]); break; |
| 1624 | case CPUINFO_STR_REGISTER + SUPERFX_DREG: sprintf(info->s, "DREG: R%d", cpustate->dreg_idx); break; |
| 1625 | case CPUINFO_STR_REGISTER + SUPERFX_SREG: sprintf(info->s, "SREG: R%d", cpustate->sreg_idx); break; |
| 1626 | case CPUINFO_STR_REGISTER + SUPERFX_R0: sprintf(info->s, "R0: %04X", cpustate->r[0]); break; |
| 1627 | case CPUINFO_STR_REGISTER + SUPERFX_R1: sprintf(info->s, "R1: %04X", cpustate->r[1]); break; |
| 1628 | case CPUINFO_STR_REGISTER + SUPERFX_R2: sprintf(info->s, "R2: %04X", cpustate->r[2]); break; |
| 1629 | case CPUINFO_STR_REGISTER + SUPERFX_R3: sprintf(info->s, "R3: %04X", cpustate->r[3]); break; |
| 1630 | case CPUINFO_STR_REGISTER + SUPERFX_R4: sprintf(info->s, "R4: %04X", cpustate->r[4]); break; |
| 1631 | case CPUINFO_STR_REGISTER + SUPERFX_R5: sprintf(info->s, "R5: %04X", cpustate->r[5]); break; |
| 1632 | case CPUINFO_STR_REGISTER + SUPERFX_R6: sprintf(info->s, "R6: %04X", cpustate->r[6]); break; |
| 1633 | case CPUINFO_STR_REGISTER + SUPERFX_R7: sprintf(info->s, "R7: %04X", cpustate->r[7]); break; |
| 1634 | case CPUINFO_STR_REGISTER + SUPERFX_R8: sprintf(info->s, "R8: %04X", cpustate->r[8]); break; |
| 1635 | case CPUINFO_STR_REGISTER + SUPERFX_R9: sprintf(info->s, "R9: %04X", cpustate->r[9]); break; |
| 1636 | case CPUINFO_STR_REGISTER + SUPERFX_R10: sprintf(info->s, "R10: %04X", cpustate->r[10]); break; |
| 1637 | case CPUINFO_STR_REGISTER + SUPERFX_R11: sprintf(info->s, "R11: %04X", cpustate->r[11]); break; |
| 1638 | case CPUINFO_STR_REGISTER + SUPERFX_R12: sprintf(info->s, "R12: %04X", cpustate->r[12]); break; |
| 1639 | case CPUINFO_STR_REGISTER + SUPERFX_R13: sprintf(info->s, "R13: %04X", cpustate->r[13]); break; |
| 1640 | case CPUINFO_STR_REGISTER + SUPERFX_R14: sprintf(info->s, "R14: %04X", cpustate->r[14]); break; |
| 1641 | case CPUINFO_STR_REGISTER + SUPERFX_R15: sprintf(info->s, "R15: %04X", cpustate->r[15]); break; |
| 1642 | case CPUINFO_STR_REGISTER + SUPERFX_SFR: sprintf(info->s, "SFR: %04X", cpustate->sfr); break; |
| 1643 | case CPUINFO_STR_REGISTER + SUPERFX_PBR: sprintf(info->s, "PBR: %02X", cpustate->sfr); break; |
| 1644 | case CPUINFO_STR_REGISTER + SUPERFX_ROMBR: sprintf(info->s, "ROMBR: %02X", cpustate->rombr); break; |
| 1645 | case CPUINFO_STR_REGISTER + SUPERFX_RAMBR: sprintf(info->s, "RAMBR: %02X", cpustate->rambr); break; |
| 1646 | case CPUINFO_STR_REGISTER + SUPERFX_CBR: sprintf(info->s, "CBR: %04X", cpustate->cbr); break; |
| 1647 | case CPUINFO_STR_REGISTER + SUPERFX_SCBR: sprintf(info->s, "SCBR: %02X", cpustate->scbr); break; |
| 1648 | case CPUINFO_STR_REGISTER + SUPERFX_SCMR: sprintf(info->s, "SCMR: %02X", cpustate->scmr); break; |
| 1649 | case CPUINFO_STR_REGISTER + SUPERFX_COLR: sprintf(info->s, "COLR %02X", cpustate->colr); break; |
| 1650 | case CPUINFO_STR_REGISTER + SUPERFX_POR: sprintf(info->s, "POR: %02X", cpustate->por); break; |
| 1651 | case CPUINFO_STR_REGISTER + SUPERFX_BRAMR: sprintf(info->s, "BRAMR: %02X", cpustate->bramr); break; |
| 1652 | case CPUINFO_STR_REGISTER + SUPERFX_VCR: sprintf(info->s, "VCR: %02X", cpustate->vcr); break; |
| 1653 | case CPUINFO_STR_REGISTER + SUPERFX_CFGR: sprintf(info->s, "CFGR: %02X", cpustate->cfgr); break; |
| 1654 | case CPUINFO_STR_REGISTER + SUPERFX_CLSR: sprintf(info->s, "CLSR: %02X", cpustate->clsr); break; |
| 1655 | case CPUINFO_STR_REGISTER + SUPERFX_ROMCL: sprintf(info->s, "ROMCL: %08X", cpustate->romcl); break; |
| 1656 | case CPUINFO_STR_REGISTER + SUPERFX_ROMDR: sprintf(info->s, "ROMDR: %02X", cpustate->romdr); break; |
| 1657 | case CPUINFO_STR_REGISTER + SUPERFX_RAMCL: sprintf(info->s, "RAMCL: %08X", cpustate->ramcl); break; |
| 1658 | case CPUINFO_STR_REGISTER + SUPERFX_RAMAR: sprintf(info->s, "RAMAR: %04X", cpustate->ramar); break; |
| 1659 | case CPUINFO_STR_REGISTER + SUPERFX_RAMDR: sprintf(info->s, "RAMDR: %02X", cpustate->ramdr); break; |
| 1660 | case CPUINFO_STR_REGISTER + SUPERFX_RAMADDR: sprintf(info->s, "RAMADDR: %04X", cpustate->ramaddr); break; |
| 1607 | 1661 | } |
| 1608 | 1662 | } |