trunk/src/mame/drivers/jaguar.c
| r23540 | r23541 | |
| 1077 | 1077 | AM_RANGE(0xf1d000, 0xf1dfff) AM_READWRITE(wave_rom_r16, wave_rom_w16 ) |
| 1078 | 1078 | ADDRESS_MAP_END |
| 1079 | 1079 | |
| 1080 | /// hack for 32 big endian bus talking to 16 bit little endian ide |
| 1081 | READ32_MEMBER(jaguar_state::vt83c461_r) |
| 1082 | { |
| 1083 | UINT32 data = 0; |
| 1080 | 1084 | |
| 1085 | if(offset >= 0x30/4 && offset < 0x40/4) |
| 1086 | { |
| 1087 | if (ACCESSING_BITS_0_7) |
| 1088 | data = m_ide->read_via_config(space, (offset * 4) & 0xf, mem_mask); |
| 1089 | } |
| 1090 | else if( offset >= 0x1f0/4 && offset < 0x1f8/4 ) |
| 1091 | { |
| 1092 | if (ACCESSING_BITS_0_15) |
| 1093 | data |= m_ide->read_cs0_pc(space, (offset * 2) & 7, mem_mask); |
| 1094 | if (ACCESSING_BITS_16_31) |
| 1095 | data |= m_ide->read_cs0_pc(space, ((offset * 2) & 7) + 1, mem_mask >> 16) << 16; |
| 1096 | } |
| 1097 | else if( offset >= 0x3f0/4 && offset < 0x3f8/4 ) |
| 1098 | { |
| 1099 | if (ACCESSING_BITS_0_15) |
| 1100 | data |= m_ide->read_cs1_pc(space, (offset * 2) & 7, mem_mask); |
| 1101 | if (ACCESSING_BITS_16_31) |
| 1102 | data |= m_ide->read_cs1_pc(space, ((offset * 2) & 7) + 1, mem_mask >> 16) << 16; |
| 1103 | } |
| 1081 | 1104 | |
| 1105 | return data; |
| 1106 | } |
| 1107 | |
| 1108 | WRITE32_MEMBER(jaguar_state::vt83c461_w) |
| 1109 | { |
| 1110 | if(offset >= 0x30/4 && offset < 0x40/4) |
| 1111 | { |
| 1112 | if (ACCESSING_BITS_0_7) |
| 1113 | m_ide->write_via_config(space, (offset * 4) & 0xf, data, mem_mask); |
| 1114 | } |
| 1115 | else if( offset >= 0x1f0/4 && offset < 0x1f8/4 ) |
| 1116 | { |
| 1117 | if (ACCESSING_BITS_0_15) |
| 1118 | m_ide->write_cs0_pc(space, (offset * 2) & 7, data, mem_mask); |
| 1119 | if (ACCESSING_BITS_16_31) |
| 1120 | m_ide->write_cs0_pc(space, ((offset * 2) & 7) + 1, data >> 16, mem_mask >> 16); |
| 1121 | } |
| 1122 | else if( offset >= 0x3f0/4 && offset < 0x3f8/4 ) |
| 1123 | { |
| 1124 | if (ACCESSING_BITS_0_15) |
| 1125 | m_ide->write_cs1_pc(space, (offset * 2) & 7, data, mem_mask); |
| 1126 | if (ACCESSING_BITS_16_31) |
| 1127 | m_ide->write_cs1_pc(space, ((offset * 2) & 7) + 1, data >> 16, mem_mask >> 16); |
| 1128 | } |
| 1129 | } |
| 1130 | |
| 1131 | |
| 1132 | |
| 1082 | 1133 | /************************************* |
| 1083 | 1134 | * |
| 1084 | 1135 | * Main CPU memory handlers |
| r23540 | r23541 | |
| 1089 | 1140 | AM_RANGE(0x04000000, 0x047fffff) AM_RAM AM_SHARE("sharedram") |
| 1090 | 1141 | AM_RANGE(0x04800000, 0x04bfffff) AM_ROMBANK("maingfxbank") |
| 1091 | 1142 | AM_RANGE(0x04c00000, 0x04dfffff) AM_ROMBANK("mainsndbank") |
| 1092 | | AM_RANGE(0x04e00000, 0x04e003ff) AM_DEVREADWRITE("ide", ide_controller_device, ide_controller32_r, ide_controller32_w) |
| 1143 | AM_RANGE(0x04e00000, 0x04e003ff) AM_READWRITE(vt83c461_r, vt83c461_w) |
| 1093 | 1144 | AM_RANGE(0x04f00000, 0x04f003ff) AM_READWRITE16(tom_regs_r, tom_regs_w, 0xffffffff) |
| 1094 | 1145 | AM_RANGE(0x04f00400, 0x04f007ff) AM_RAM AM_SHARE("gpuclut") |
| 1095 | 1146 | AM_RANGE(0x04f02100, 0x04f021ff) AM_READWRITE(gpuctrl_r, gpuctrl_w) |
| r23540 | r23541 | |
| 1123 | 1174 | AM_RANGE(0xa40000, 0xa40003) AM_WRITE(eeprom_enable_w) |
| 1124 | 1175 | AM_RANGE(0xb70000, 0xb70003) AM_READWRITE(misc_control_r, misc_control_w) |
| 1125 | 1176 | AM_RANGE(0xc00000, 0xdfffff) AM_ROMBANK("mainsndbank") |
| 1126 | | AM_RANGE(0xe00000, 0xe003ff) AM_DEVREADWRITE("ide", ide_controller_device, ide_controller32_r, ide_controller32_w) |
| 1177 | AM_RANGE(0xe00000, 0xe003ff) AM_READWRITE(vt83c461_r, vt83c461_w) |
| 1127 | 1178 | AM_RANGE(0xf00000, 0xf003ff) AM_READWRITE16(tom_regs_r, tom_regs_w, 0xffffffff) |
| 1128 | 1179 | AM_RANGE(0xf00400, 0xf007ff) AM_RAM AM_SHARE("gpuclut") |
| 1129 | 1180 | AM_RANGE(0xf02100, 0xf021ff) AM_READWRITE(gpuctrl_r, gpuctrl_w) |
| r23540 | r23541 | |
| 1151 | 1202 | AM_RANGE(0x000000, 0x7fffff) AM_RAM AM_SHARE("sharedram") |
| 1152 | 1203 | AM_RANGE(0x800000, 0xbfffff) AM_ROMBANK("gpugfxbank") |
| 1153 | 1204 | AM_RANGE(0xc00000, 0xdfffff) AM_ROMBANK("dspsndbank") |
| 1154 | | AM_RANGE(0xe00000, 0xe003ff) AM_DEVREADWRITE("ide", ide_controller_device, ide_controller32_r, ide_controller32_w) |
| 1205 | AM_RANGE(0xe00000, 0xe003ff) AM_READWRITE(vt83c461_r, vt83c461_w) |
| 1155 | 1206 | AM_RANGE(0xf00000, 0xf003ff) AM_READWRITE16(tom_regs_r, tom_regs_w, 0xffffffff) |
| 1156 | 1207 | AM_RANGE(0xf00400, 0xf007ff) AM_RAM AM_SHARE("gpuclut") |
| 1157 | 1208 | AM_RANGE(0xf02100, 0xf021ff) AM_READWRITE(gpuctrl_r, gpuctrl_w) |
trunk/src/mame/drivers/viper.c
| r23540 | r23541 | |
| 1266 | 1266 | { |
| 1267 | 1267 | case 0x8: // Duplicate Even RD Data |
| 1268 | 1268 | { |
| 1269 | | r |= m_ide->ide_bus_r(0, 0) << 16; |
| 1269 | r |= m_ide->read_cs0(space, 0, mem_mask >> 16) << 16; |
| 1270 | 1270 | break; |
| 1271 | 1271 | } |
| 1272 | 1272 | |
| r23540 | r23541 | |
| 1287 | 1287 | { |
| 1288 | 1288 | case 0x8: // Duplicate Even RD Data |
| 1289 | 1289 | { |
| 1290 | | m_ide->ide_bus_w(0, 0, (data >> 16) & 0xffff); |
| 1290 | m_ide->write_cs0(space, 0, data >> 16, mem_mask >> 16); |
| 1291 | 1291 | break; |
| 1292 | 1292 | } |
| 1293 | 1293 | |
| r23540 | r23541 | |
| 1318 | 1318 | case 0x6: // Select Card/Head |
| 1319 | 1319 | case 0x7: // Status |
| 1320 | 1320 | { |
| 1321 | | r |= m_ide->ide_bus_r(0, offset & 7) << 16; |
| 1321 | r |= m_ide->read_cs0(space, offset & 7, mem_mask >> 16) << 16; |
| 1322 | 1322 | break; |
| 1323 | 1323 | } |
| 1324 | 1324 | |
| r23540 | r23541 | |
| 1327 | 1327 | |
| 1328 | 1328 | case 0xd: // Duplicate Error |
| 1329 | 1329 | { |
| 1330 | | r |= m_ide->ide_bus_r(0, 1) << 16; |
| 1330 | r |= m_ide->read_cs0(space, 1, mem_mask >> 16) << 16; |
| 1331 | 1331 | break; |
| 1332 | 1332 | } |
| 1333 | 1333 | case 0xe: // Alt Status |
| 1334 | 1334 | case 0xf: // Drive Address |
| 1335 | 1335 | { |
| 1336 | | r |= m_ide->ide_bus_r(1, offset & 7) << 16; |
| 1336 | r |= m_ide->read_cs1(space, offset & 7, mem_mask >> 16) << 16; |
| 1337 | 1337 | break; |
| 1338 | 1338 | } |
| 1339 | 1339 | |
| r23540 | r23541 | |
| 1383 | 1383 | case 0x6: // Select Card/Head |
| 1384 | 1384 | case 0x7: // Command |
| 1385 | 1385 | { |
| 1386 | | m_ide->ide_bus_w(0, offset & 7, (data >> 16) & 0xffff); |
| 1386 | m_ide->write_cs0(space, offset & 7, data >> 16, mem_mask >> 16); |
| 1387 | 1387 | break; |
| 1388 | 1388 | } |
| 1389 | 1389 | |
| r23540 | r23541 | |
| 1392 | 1392 | |
| 1393 | 1393 | case 0xd: // Duplicate Features |
| 1394 | 1394 | { |
| 1395 | | m_ide->ide_bus_w(0, 1, (data >> 16) & 0xffff); |
| 1395 | m_ide->write_cs0(space, 1, data >> 16, mem_mask >> 16); |
| 1396 | 1396 | break; |
| 1397 | 1397 | } |
| 1398 | 1398 | case 0xe: // Device Ctl |
| 1399 | 1399 | case 0xf: // Reserved |
| 1400 | 1400 | { |
| 1401 | | m_ide->ide_bus_w(1, offset & 7, (data >> 16) & 0xffff); |
| 1401 | m_ide->write_cs1(space, offset & 7, data >> 16, mem_mask >> 16); |
| 1402 | 1402 | break; |
| 1403 | 1403 | } |
| 1404 | 1404 | |
| r23540 | r23541 | |
| 1424 | 1424 | // cylinder low register is set to 0x00 |
| 1425 | 1425 | // cylinder high register is set to 0x00 |
| 1426 | 1426 | |
| 1427 | | m_ide->ide_bus_w(1, 6, 0x04); |
| 1427 | m_ide->write_cs1(space, 6, 0x04, 0xff); |
| 1428 | 1428 | |
| 1429 | | m_ide->ide_bus_w(0, 2, 0x01); |
| 1430 | | m_ide->ide_bus_w(0, 3, 0x01); |
| 1431 | | m_ide->ide_bus_w(0, 4, 0x00); |
| 1432 | | m_ide->ide_bus_w(0, 5, 0x00); |
| 1429 | m_ide->write_cs0(space, 2, 0x01, 0xff); |
| 1430 | m_ide->write_cs0(space, 3, 0x01, 0xff); |
| 1431 | m_ide->write_cs0(space, 4, 0x00, 0xff); |
| 1432 | m_ide->write_cs0(space, 5, 0x00, 0xff); |
| 1433 | 1433 | } |
| 1434 | 1434 | break; |
| 1435 | 1435 | } |
| r23540 | r23541 | |
| 1461 | 1461 | { |
| 1462 | 1462 | int reg = (offset >> 4) & 0x7; |
| 1463 | 1463 | |
| 1464 | | r |= m_ide->ide_bus_r((offset & 0x80) ? 1 : 0, reg) << 16; |
| 1464 | switch(offset & 0x80) |
| 1465 | { |
| 1466 | case 0x00: |
| 1467 | r |= m_ide->read_cs0(space, reg, mem_mask >> 16) << 16; |
| 1468 | break; |
| 1469 | case 0x80: |
| 1470 | r |= m_ide->read_cs1(space, reg, mem_mask >> 16) << 16; |
| 1471 | break; |
| 1472 | } |
| 1465 | 1473 | } |
| 1466 | 1474 | |
| 1467 | 1475 | return r; |
| r23540 | r23541 | |
| 1473 | 1481 | { |
| 1474 | 1482 | int reg = (offset >> 4) & 0x7; |
| 1475 | 1483 | |
| 1476 | | m_ide->ide_bus_w((offset & 0x80) ? 1 : 0, reg, (UINT16)(data >> 16)); |
| 1484 | switch(offset & 0x80) |
| 1485 | { |
| 1486 | case 0x00: |
| 1487 | m_ide->write_cs0(space, reg, data >> 16, mem_mask >> 16); |
| 1488 | break; |
| 1489 | case 0x80: |
| 1490 | m_ide->write_cs1(space, reg, data >> 16, mem_mask >> 16); |
| 1491 | break; |
| 1492 | } |
| 1477 | 1493 | } |
| 1478 | 1494 | } |
| 1479 | 1495 | |
trunk/src/mame/drivers/queen.c
| r23540 | r23541 | |
| 37 | 37 | { |
| 38 | 38 | public: |
| 39 | 39 | queen_state(const machine_config &mconfig, device_type type, const char *tag) |
| 40 | | : pcat_base_state(mconfig, type, tag), |
| 41 | | m_ide(*this, "ide") |
| 42 | | { } |
| 40 | : pcat_base_state(mconfig, type, tag) |
| 41 | { |
| 42 | } |
| 43 | 43 | |
| 44 | 44 | UINT32 *m_bios_ram; |
| 45 | 45 | UINT32 *m_bios_ext_ram; |
| 46 | 46 | UINT8 m_mxtc_config_reg[256]; |
| 47 | 47 | UINT8 m_piix4_config_reg[4][256]; |
| 48 | 48 | |
| 49 | | // devices |
| 50 | | required_device<ide_controller_device> m_ide; |
| 51 | | |
| 52 | 49 | DECLARE_WRITE32_MEMBER( bios_ext_ram_w ); |
| 53 | 50 | |
| 54 | 51 | DECLARE_WRITE32_MEMBER( bios_ram_w ); |
| 55 | | DECLARE_READ32_MEMBER(ide_r); |
| 56 | | DECLARE_WRITE32_MEMBER(ide_w); |
| 57 | | DECLARE_READ32_MEMBER(fdc_r); |
| 58 | | DECLARE_WRITE32_MEMBER(fdc_w); |
| 59 | 52 | virtual void machine_start(); |
| 60 | 53 | virtual void machine_reset(); |
| 61 | 54 | void intel82439tx_init(); |
| r23540 | r23541 | |
| 230 | 223 | } |
| 231 | 224 | } |
| 232 | 225 | |
| 233 | | READ32_MEMBER(queen_state::ide_r) |
| 234 | | { |
| 235 | | return m_ide->ide_controller32_r(space, 0x1f0/4 + offset, mem_mask); |
| 236 | | } |
| 237 | | |
| 238 | | WRITE32_MEMBER(queen_state::ide_w) |
| 239 | | { |
| 240 | | m_ide->ide_controller32_w(space, 0x1f0/4 + offset, data, mem_mask); |
| 241 | | } |
| 242 | | |
| 243 | | READ32_MEMBER(queen_state::fdc_r) |
| 244 | | { |
| 245 | | return m_ide->ide_controller32_r(space, 0x3f0/4 + offset, mem_mask); |
| 246 | | } |
| 247 | | |
| 248 | | WRITE32_MEMBER(queen_state::fdc_w) |
| 249 | | { |
| 250 | | //mame_printf_debug("FDC: write %08X, %08X, %08X\n", data, offset, mem_mask); |
| 251 | | m_ide->ide_controller32_w(space, 0x3f0/4 + offset, data, mem_mask); |
| 252 | | } |
| 253 | | |
| 254 | 226 | static ADDRESS_MAP_START( queen_map, AS_PROGRAM, 32, queen_state ) |
| 255 | 227 | AM_RANGE(0x00000000, 0x0009ffff) AM_RAM |
| 256 | 228 | AM_RANGE(0x000a0000, 0x000bffff) AM_DEVREADWRITE8("vga", vga_device, mem_r, mem_w, 0xffffffff) |
| r23540 | r23541 | |
| 264 | 236 | AM_IMPORT_FROM(pcat32_io_common) |
| 265 | 237 | AM_RANGE(0x00e8, 0x00ef) AM_NOP |
| 266 | 238 | |
| 267 | | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w) |
| 239 | AM_RANGE(0x01f0, 0x01f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0_pc, write_cs0_pc, 0xffffffff) |
| 268 | 240 | AM_RANGE(0x03b0, 0x03bf) AM_DEVREADWRITE8("vga", vga_device, port_03b0_r, port_03b0_w, 0xffffffff) |
| 269 | 241 | AM_RANGE(0x03c0, 0x03cf) AM_DEVREADWRITE8("vga", vga_device, port_03c0_r, port_03c0_w, 0xffffffff) |
| 270 | 242 | AM_RANGE(0x03d0, 0x03df) AM_DEVREADWRITE8("vga", vga_device, port_03d0_r, port_03d0_w, 0xffffffff) |
| 271 | | AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(fdc_r, fdc_w) |
| 243 | AM_RANGE(0x03f0, 0x03f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1_pc, write_cs1_pc, 0xffffffff) |
| 272 | 244 | |
| 273 | 245 | AM_RANGE(0x0cf8, 0x0cff) AM_DEVREADWRITE("pcibus", pci_bus_legacy_device, read, write) |
| 274 | 246 | ADDRESS_MAP_END |
trunk/src/mame/drivers/voyager.c
| r23540 | r23541 | |
| 24 | 24 | { |
| 25 | 25 | public: |
| 26 | 26 | voyager_state(const machine_config &mconfig, device_type type, const char *tag) |
| 27 | | : pcat_base_state(mconfig, type, tag), |
| 28 | | m_ide(*this, "ide") |
| 29 | | { } |
| 27 | : pcat_base_state(mconfig, type, tag) |
| 28 | { |
| 29 | } |
| 30 | 30 | |
| 31 | 31 | UINT32 *m_bios_ram; |
| 32 | 32 | UINT8 m_mxtc_config_reg[256]; |
| 33 | 33 | UINT8 m_piix4_config_reg[4][256]; |
| 34 | 34 | |
| 35 | | required_device<ide_controller_device> m_ide; |
| 36 | | |
| 37 | 35 | UINT32 m_idle_skip_ram; |
| 38 | 36 | DECLARE_WRITE32_MEMBER(bios_ram_w); |
| 39 | | DECLARE_READ32_MEMBER(ide_r); |
| 40 | | DECLARE_WRITE32_MEMBER(ide_w); |
| 41 | | DECLARE_READ32_MEMBER(fdc_r); |
| 42 | | DECLARE_WRITE32_MEMBER(fdc_w); |
| 43 | 37 | DECLARE_DRIVER_INIT(voyager); |
| 44 | 38 | virtual void machine_start(); |
| 45 | 39 | virtual void machine_reset(); |
| r23540 | r23541 | |
| 47 | 41 | }; |
| 48 | 42 | |
| 49 | 43 | |
| 50 | | READ32_MEMBER(voyager_state::ide_r) |
| 51 | | { |
| 52 | | return m_ide->ide_controller32_r(space, 0x1f0/4 + offset, mem_mask); |
| 53 | | } |
| 54 | | |
| 55 | | WRITE32_MEMBER(voyager_state::ide_w) |
| 56 | | { |
| 57 | | m_ide->ide_controller32_w(space, 0x1f0/4 + offset, data, mem_mask); |
| 58 | | } |
| 59 | | |
| 60 | | READ32_MEMBER(voyager_state::fdc_r) |
| 61 | | { |
| 62 | | return m_ide->ide_controller32_r(space, 0x3f0/4 + offset, mem_mask); |
| 63 | | } |
| 64 | | |
| 65 | | WRITE32_MEMBER(voyager_state::fdc_w) |
| 66 | | { |
| 67 | | //mame_printf_debug("FDC: write %08X, %08X, %08X\n", data, offset, mem_mask); |
| 68 | | m_ide->ide_controller32_w(space, 0x3f0/4 + offset, data, mem_mask); |
| 69 | | } |
| 70 | | |
| 71 | | |
| 72 | 44 | // Intel 82439TX System Controller (MXTC) |
| 73 | 45 | |
| 74 | 46 | static UINT8 mxtc_config_r(device_t *busdevice, device_t *device, int function, int reg) |
| r23540 | r23541 | |
| 276 | 248 | //AM_RANGE(0x00e8, 0x00eb) AM_NOP |
| 277 | 249 | AM_RANGE(0x00e8, 0x00ef) AM_NOP //AMI BIOS write to this ports as delays between I/O ports operations sending al value -> NEWIODELAY |
| 278 | 250 | AM_RANGE(0x0170, 0x0177) AM_NOP //To debug |
| 279 | | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w) |
| 251 | AM_RANGE(0x01f0, 0x01f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0_pc, write_cs0_pc, 0xffffffff) |
| 280 | 252 | AM_RANGE(0x0200, 0x021f) AM_NOP //To debug |
| 281 | 253 | AM_RANGE(0x0260, 0x026f) AM_NOP //To debug |
| 282 | 254 | AM_RANGE(0x0278, 0x027b) AM_WRITENOP//AM_WRITE(pnp_config_w) |
| r23540 | r23541 | |
| 295 | 267 | AM_RANGE(0x0378, 0x037f) AM_NOP //To debug |
| 296 | 268 | // AM_RANGE(0x0300, 0x03af) AM_NOP |
| 297 | 269 | // AM_RANGE(0x03b0, 0x03df) AM_NOP |
| 298 | | AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(fdc_r, fdc_w) |
| 270 | AM_RANGE(0x03f0, 0x03f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1_pc, write_cs1_pc, 0xffffffff) |
| 299 | 271 | AM_RANGE(0x03f8, 0x03ff) AM_NOP // To debug Serial Port COM1: |
| 300 | 272 | AM_RANGE(0x0a78, 0x0a7b) AM_WRITENOP//AM_WRITE(pnp_data_w) |
| 301 | 273 | AM_RANGE(0x0cf8, 0x0cff) AM_DEVREADWRITE("pcibus", pci_bus_legacy_device, read, write) |
trunk/src/mame/drivers/savquest.c
| r23540 | r23541 | |
| 40 | 40 | { |
| 41 | 41 | public: |
| 42 | 42 | savquest_state(const machine_config &mconfig, device_type type, const char *tag) |
| 43 | | : pcat_base_state(mconfig, type, tag), |
| 44 | | m_ide(*this, "ide") |
| 45 | | { } |
| 43 | : pcat_base_state(mconfig, type, tag) |
| 44 | { |
| 45 | } |
| 46 | 46 | |
| 47 | 47 | UINT32 *m_bios_f0000_ram; |
| 48 | 48 | UINT32 *m_bios_e0000_ram; |
| r23540 | r23541 | |
| 67 | 67 | UINT8 m_mxtc_config_reg[256]; |
| 68 | 68 | UINT8 m_piix4_config_reg[8][256]; |
| 69 | 69 | |
| 70 | | // devices |
| 71 | | required_device<ide_controller_device> m_ide; |
| 72 | | |
| 73 | 70 | DECLARE_WRITE32_MEMBER( bios_f0000_ram_w ); |
| 74 | 71 | DECLARE_WRITE32_MEMBER( bios_e0000_ram_w ); |
| 75 | 72 | DECLARE_WRITE32_MEMBER( bios_e4000_ram_w ); |
| r23540 | r23541 | |
| 85 | 82 | // driver_device overrides |
| 86 | 83 | // virtual void video_start(); |
| 87 | 84 | public: |
| 88 | | DECLARE_READ32_MEMBER(ide_r); |
| 89 | | DECLARE_WRITE32_MEMBER(ide_w); |
| 90 | | DECLARE_READ32_MEMBER(fdc_r); |
| 91 | | DECLARE_WRITE32_MEMBER(fdc_w); |
| 92 | 85 | virtual void machine_start(); |
| 93 | 86 | virtual void machine_reset(); |
| 94 | 87 | void intel82439tx_init(); |
| r23540 | r23541 | |
| 535 | 528 | } |
| 536 | 529 | } |
| 537 | 530 | |
| 538 | | READ32_MEMBER(savquest_state::ide_r) |
| 539 | | { |
| 540 | | return m_ide->ide_controller32_r(space, 0x1f0/4 + offset, mem_mask); |
| 541 | | } |
| 542 | | |
| 543 | | WRITE32_MEMBER(savquest_state::ide_w) |
| 544 | | { |
| 545 | | m_ide->ide_controller32_w(space, 0x1f0/4 + offset, data, mem_mask); |
| 546 | | } |
| 547 | | |
| 548 | | READ32_MEMBER(savquest_state::fdc_r) |
| 549 | | { |
| 550 | | return m_ide->ide_controller32_r(space, 0x3f0/4 + offset, mem_mask); |
| 551 | | } |
| 552 | | |
| 553 | | WRITE32_MEMBER(savquest_state::fdc_w) |
| 554 | | { |
| 555 | | //mame_printf_debug("FDC: write %08X, %08X, %08X\n", data, offset, mem_mask); |
| 556 | | m_ide->ide_controller32_w(space, 0x3f0/4 + offset, data, mem_mask); |
| 557 | | } |
| 558 | | |
| 559 | 531 | static ADDRESS_MAP_START(savquest_map, AS_PROGRAM, 32, savquest_state) |
| 560 | 532 | AM_RANGE(0x00000000, 0x0009ffff) AM_RAM |
| 561 | 533 | AM_RANGE(0x000a0000, 0x000bffff) AM_DEVREADWRITE8("vga", vga_device, mem_r, mem_w, 0xffffffff) |
| r23540 | r23541 | |
| 575 | 547 | |
| 576 | 548 | AM_RANGE(0x00e8, 0x00ef) AM_NOP |
| 577 | 549 | |
| 578 | | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w) |
| 550 | AM_RANGE(0x01f0, 0x01f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0_pc, write_cs0_pc, 0xffffffff) |
| 579 | 551 | AM_RANGE(0x0378, 0x037b) AM_READWRITE(parallel_port_r, parallel_port_w) |
| 580 | 552 | AM_RANGE(0x03b0, 0x03bf) AM_DEVREADWRITE8("vga", vga_device, port_03b0_r, port_03b0_w, 0xffffffff) |
| 581 | 553 | AM_RANGE(0x03c0, 0x03cf) AM_DEVREADWRITE8("vga", vga_device, port_03c0_r, port_03c0_w, 0xffffffff) |
| 582 | 554 | AM_RANGE(0x03d0, 0x03df) AM_DEVREADWRITE8("vga", vga_device, port_03d0_r, port_03d0_w, 0xffffffff) |
| 583 | | AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(fdc_r, fdc_w) |
| 555 | AM_RANGE(0x03f0, 0x03f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1_pc, write_cs1_pc, 0xffffffff) |
| 584 | 556 | |
| 585 | 557 | AM_RANGE(0x0cf8, 0x0cff) AM_DEVREADWRITE("pcibus", pci_bus_legacy_device, read, write) |
| 586 | 558 | |
trunk/src/mame/drivers/photoply.c
| r23540 | r23541 | |
| 21 | 21 | { |
| 22 | 22 | public: |
| 23 | 23 | photoply_state(const machine_config &mconfig, device_type type, const char *tag) |
| 24 | | : pcat_base_state(mconfig, type, tag), |
| 25 | | m_ide(*this, "ide") { } |
| 24 | : pcat_base_state(mconfig, type, tag) |
| 25 | { |
| 26 | } |
| 26 | 27 | |
| 27 | 28 | UINT8 m_vga_address; |
| 28 | 29 | |
| 29 | | DECLARE_READ32_MEMBER(ide_r); |
| 30 | | DECLARE_WRITE32_MEMBER(ide_w); |
| 31 | | DECLARE_READ32_MEMBER(fdc_r); |
| 32 | | DECLARE_WRITE32_MEMBER(fdc_w); |
| 33 | 30 | DECLARE_DRIVER_INIT(photoply); |
| 34 | 31 | virtual void machine_start(); |
| 35 | | |
| 36 | | required_device<ide_controller_device> m_ide; |
| 37 | 32 | }; |
| 38 | 33 | |
| 39 | 34 | |
| 40 | 35 | |
| 41 | | READ32_MEMBER(photoply_state::ide_r) |
| 42 | | { |
| 43 | | return m_ide->ide_controller32_r(space, 0x1f0/4 + offset, mem_mask); |
| 44 | | } |
| 45 | | |
| 46 | | WRITE32_MEMBER(photoply_state::ide_w) |
| 47 | | { |
| 48 | | m_ide->ide_controller32_w(space, 0x1f0/4 + offset, data, mem_mask); |
| 49 | | } |
| 50 | | |
| 51 | | READ32_MEMBER(photoply_state::fdc_r) |
| 52 | | { |
| 53 | | return m_ide->ide_controller32_r(space, 0x3f0/4 + offset, mem_mask); |
| 54 | | } |
| 55 | | |
| 56 | | WRITE32_MEMBER(photoply_state::fdc_w) |
| 57 | | { |
| 58 | | //mame_printf_debug("FDC: write %08X, %08X, %08X\n", data, offset, mem_mask); |
| 59 | | m_ide->ide_controller32_w(space, 0x3f0/4 + offset, data, mem_mask); |
| 60 | | } |
| 61 | | |
| 62 | 36 | static ADDRESS_MAP_START( photoply_map, AS_PROGRAM, 32, photoply_state ) |
| 63 | 37 | AM_RANGE(0x00000000, 0x0009ffff) AM_RAM |
| 64 | 38 | AM_RANGE(0x000a0000, 0x000bffff) AM_DEVREADWRITE8("vga", vga_device, mem_r, mem_w, 0xffffffff) // VGA RAM |
| r23540 | r23541 | |
| 74 | 48 | static ADDRESS_MAP_START( photoply_io, AS_IO, 32, photoply_state ) |
| 75 | 49 | AM_IMPORT_FROM(pcat32_io_common) |
| 76 | 50 | AM_RANGE(0x00e8, 0x00eb) AM_NOP |
| 77 | | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w) |
| 51 | AM_RANGE(0x01f0, 0x01f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0_pc, write_cs0_pc, 0xffffffff) |
| 78 | 52 | AM_RANGE(0x0278, 0x027f) AM_RAM //parallel port 2 |
| 79 | 53 | AM_RANGE(0x0378, 0x037f) AM_RAM //parallel port |
| 80 | 54 | //AM_RANGE(0x03bc, 0x03bf) AM_RAM //parallel port 3 |
| 81 | 55 | AM_RANGE(0x03b0, 0x03bf) AM_DEVREADWRITE8("vga", vga_device, port_03b0_r, port_03b0_w, 0xffffffff) |
| 82 | 56 | AM_RANGE(0x03c0, 0x03cf) AM_DEVREADWRITE8("vga", vga_device, port_03c0_r, port_03c0_w, 0xffffffff) |
| 83 | 57 | AM_RANGE(0x03d0, 0x03df) AM_DEVREADWRITE8("vga", vga_device, port_03d0_r, port_03d0_w, 0xffffffff) |
| 84 | | AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(fdc_r, fdc_w) |
| 58 | AM_RANGE(0x03f0, 0x03f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1_pc, write_cs1_pc, 0xffffffff) |
| 85 | 59 | ADDRESS_MAP_END |
| 86 | 60 | |
| 87 | 61 | #define AT_KEYB_HELPER(bit, text, key1) \ |
trunk/src/mame/drivers/midqslvr.c
| r23540 | r23541 | |
| 34 | 34 | { |
| 35 | 35 | public: |
| 36 | 36 | midqslvr_state(const machine_config &mconfig, device_type type, const char *tag) |
| 37 | | : pcat_base_state(mconfig, type, tag), |
| 38 | | m_ide(*this, "ide") |
| 39 | | { } |
| 37 | : pcat_base_state(mconfig, type, tag) |
| 38 | { |
| 39 | } |
| 40 | 40 | |
| 41 | | required_device<ide_controller_device> m_ide; |
| 42 | | |
| 43 | 41 | UINT32 *m_bios_ram; |
| 44 | 42 | UINT32 *m_bios_ext1_ram; |
| 45 | 43 | UINT32 *m_bios_ext2_ram; |
| r23540 | r23541 | |
| 59 | 57 | DECLARE_WRITE32_MEMBER( bios_ext4_ram_w ); |
| 60 | 58 | |
| 61 | 59 | DECLARE_WRITE32_MEMBER( bios_ram_w ); |
| 62 | | DECLARE_READ32_MEMBER(ide_r); |
| 63 | | DECLARE_WRITE32_MEMBER(ide_w); |
| 64 | | DECLARE_READ32_MEMBER(fdc_r); |
| 65 | | DECLARE_WRITE32_MEMBER(fdc_w); |
| 66 | 60 | virtual void machine_start(); |
| 67 | 61 | virtual void machine_reset(); |
| 68 | 62 | void intel82439tx_init(); |
| r23540 | r23541 | |
| 360 | 354 | } |
| 361 | 355 | } |
| 362 | 356 | |
| 363 | | READ32_MEMBER(midqslvr_state::ide_r) |
| 364 | | { |
| 365 | | return m_ide->ide_controller32_r(space, 0x1f0/4 + offset, mem_mask); |
| 366 | | } |
| 367 | | |
| 368 | | WRITE32_MEMBER(midqslvr_state::ide_w) |
| 369 | | { |
| 370 | | m_ide->ide_controller32_w(space, 0x1f0/4 + offset, data, mem_mask); |
| 371 | | } |
| 372 | | |
| 373 | | READ32_MEMBER(midqslvr_state::fdc_r) |
| 374 | | { |
| 375 | | return m_ide->ide_controller32_r(space, 0x3f0/4 + offset, mem_mask); |
| 376 | | } |
| 377 | | |
| 378 | | WRITE32_MEMBER(midqslvr_state::fdc_w) |
| 379 | | { |
| 380 | | //mame_printf_debug("FDC: write %08X, %08X, %08X\n", data, offset, mem_mask); |
| 381 | | m_ide->ide_controller32_w(space, 0x3f0/4 + offset, data, mem_mask); |
| 382 | | } |
| 383 | | |
| 384 | 357 | static ADDRESS_MAP_START(midqslvr_map, AS_PROGRAM, 32, midqslvr_state) |
| 385 | 358 | AM_RANGE(0x00000000, 0x0009ffff) AM_RAM |
| 386 | 359 | AM_RANGE(0x000a0000, 0x000bffff) AM_DEVREADWRITE8("vga", vga_device, mem_r, mem_w, 0xffffffff) |
| r23540 | r23541 | |
| 399 | 372 | AM_IMPORT_FROM(pcat32_io_common) |
| 400 | 373 | AM_RANGE(0x00e8, 0x00ef) AM_NOP |
| 401 | 374 | |
| 402 | | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w) |
| 375 | AM_RANGE(0x01f0, 0x01f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0_pc, write_cs0_pc, 0xffffffff) |
| 403 | 376 | AM_RANGE(0x03b0, 0x03bf) AM_DEVREADWRITE8("vga", vga_device, port_03b0_r, port_03b0_w, 0xffffffff) |
| 404 | 377 | AM_RANGE(0x03c0, 0x03cf) AM_DEVREADWRITE8("vga", vga_device, port_03c0_r, port_03c0_w, 0xffffffff) |
| 405 | 378 | AM_RANGE(0x03d0, 0x03df) AM_DEVREADWRITE8("vga", vga_device, port_03d0_r, port_03d0_w, 0xffffffff) |
| 406 | | AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(fdc_r, fdc_w) |
| 379 | AM_RANGE(0x03f0, 0x03f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1_pc, write_cs1_pc, 0xffffffff) |
| 407 | 380 | |
| 408 | 381 | AM_RANGE(0x0cf8, 0x0cff) AM_DEVREADWRITE("pcibus", pci_bus_legacy_device, read, write) |
| 409 | 382 | ADDRESS_MAP_END |
trunk/src/mame/drivers/calchase.c
| r23540 | r23541 | |
| 127 | 127 | calchase_state(const machine_config &mconfig, device_type type, const char *tag) |
| 128 | 128 | : pcat_base_state(mconfig, type, tag), |
| 129 | 129 | m_dac_l(*this, "dac_l"), |
| 130 | | m_dac_r(*this, "dac_r"), |
| 131 | | m_ide(*this, "ide") |
| 132 | | { } |
| 130 | m_dac_r(*this, "dac_r") |
| 131 | { |
| 132 | } |
| 133 | 133 | |
| 134 | 134 | UINT32 *m_bios_ram; |
| 135 | 135 | UINT32 *m_bios_ext_ram; |
| r23540 | r23541 | |
| 149 | 149 | DECLARE_WRITE16_MEMBER(calchase_dac_l_w); |
| 150 | 150 | DECLARE_WRITE16_MEMBER(calchase_dac_r_w); |
| 151 | 151 | DECLARE_DRIVER_INIT(calchase); |
| 152 | | DECLARE_READ32_MEMBER(ide_r); |
| 153 | | DECLARE_WRITE32_MEMBER(ide_w); |
| 154 | | DECLARE_READ32_MEMBER(fdc_r); |
| 155 | | DECLARE_WRITE32_MEMBER(fdc_w); |
| 156 | 152 | virtual void machine_start(); |
| 157 | 153 | virtual void machine_reset(); |
| 158 | 154 | void intel82439tx_init(); |
| 159 | 155 | required_device<dac_device> m_dac_l; |
| 160 | 156 | required_device<dac_device> m_dac_r; |
| 161 | | required_device<ide_controller_device> m_ide; |
| 162 | 157 | }; |
| 163 | 158 | |
| 164 | 159 | // Intel 82439TX System Controller (MXTC) |
| r23540 | r23541 | |
| 374 | 369 | m_dac_r->write_unsigned16((data & 0xfff) << 4); |
| 375 | 370 | } |
| 376 | 371 | |
| 377 | | READ32_MEMBER(calchase_state::ide_r) |
| 378 | | { |
| 379 | | return m_ide->ide_controller32_r(space, 0x1f0/4 + offset, mem_mask); |
| 380 | | } |
| 381 | | |
| 382 | | WRITE32_MEMBER(calchase_state::ide_w) |
| 383 | | { |
| 384 | | m_ide->ide_controller32_w(space, 0x1f0/4 + offset, data, mem_mask); |
| 385 | | } |
| 386 | | |
| 387 | | READ32_MEMBER(calchase_state::fdc_r) |
| 388 | | { |
| 389 | | return m_ide->ide_controller32_r(space, 0x3f0/4 + offset, mem_mask); |
| 390 | | } |
| 391 | | |
| 392 | | WRITE32_MEMBER(calchase_state::fdc_w) |
| 393 | | { |
| 394 | | //mame_printf_debug("FDC: write %08X, %08X, %08X\n", data, offset, mem_mask); |
| 395 | | m_ide->ide_controller32_w(space, 0x3f0/4 + offset, data, mem_mask); |
| 396 | | } |
| 397 | | |
| 398 | 372 | static ADDRESS_MAP_START( calchase_map, AS_PROGRAM, 32, calchase_state ) |
| 399 | 373 | AM_RANGE(0x00000000, 0x0009ffff) AM_RAM |
| 400 | 374 | AM_RANGE(0x000a0000, 0x000bffff) AM_DEVREADWRITE8("vga", trident_vga_device, mem_r, mem_w, 0xffffffff) // VGA VRAM |
| r23540 | r23541 | |
| 435 | 409 | //AM_RANGE(0x00e8, 0x00eb) AM_NOP |
| 436 | 410 | AM_RANGE(0x00e8, 0x00ef) AM_NOP //AMI BIOS write to this ports as delays between I/O ports operations sending al value -> NEWIODELAY |
| 437 | 411 | AM_RANGE(0x0170, 0x0177) AM_NOP //To debug |
| 438 | | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide_r, ide_w) |
| 412 | AM_RANGE(0x01f0, 0x01f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0_pc, write_cs0_pc, 0xffffffff) |
| 439 | 413 | AM_RANGE(0x0200, 0x021f) AM_NOP //To debug |
| 440 | 414 | AM_RANGE(0x0260, 0x026f) AM_NOP //To debug |
| 441 | 415 | AM_RANGE(0x0278, 0x027b) AM_WRITENOP//AM_WRITE(pnp_config_w) |
| r23540 | r23541 | |
| 454 | 428 | AM_RANGE(0x0378, 0x037f) AM_NOP //To debug |
| 455 | 429 | // AM_RANGE(0x0300, 0x03af) AM_NOP |
| 456 | 430 | // AM_RANGE(0x03b0, 0x03df) AM_NOP |
| 457 | | AM_RANGE(0x03f0, 0x03f7) AM_READWRITE(fdc_r, fdc_w) |
| 431 | AM_RANGE(0x03f0, 0x03f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1_pc, write_cs1_pc, 0xffffffff) |
| 458 | 432 | AM_RANGE(0x03f8, 0x03ff) AM_NOP // To debug Serial Port COM1: |
| 459 | 433 | AM_RANGE(0x0a78, 0x0a7b) AM_WRITENOP//AM_WRITE(pnp_data_w) |
| 460 | 434 | AM_RANGE(0x0cf8, 0x0cff) AM_DEVREADWRITE("pcibus", pci_bus_legacy_device, read, write) |
trunk/src/mame/drivers/taitotz.c
| r23540 | r23541 | |
| 613 | 613 | |
| 614 | 614 | UINT8 m_rtcdata[8]; |
| 615 | 615 | |
| 616 | UINT16 ide_cs0_latch_r; |
| 617 | UINT16 ide_cs0_latch_w; |
| 618 | UINT16 ide_cs1_latch_w; |
| 616 | 619 | |
| 617 | 620 | |
| 618 | 621 | UINT32 m_reg105; |
| r23540 | r23541 | |
| 2109 | 2112 | |
| 2110 | 2113 | READ8_MEMBER(taitotz_state::tlcs_ide0_r) |
| 2111 | 2114 | { |
| 2112 | | static UINT16 ide_reg_latch; |
| 2113 | 2115 | int reg = offset >> 1; |
| 2114 | 2116 | |
| 2115 | 2117 | if (reg == 0) |
| 2116 | 2118 | { |
| 2117 | 2119 | if ((offset & 1) == 0) |
| 2118 | 2120 | { |
| 2119 | | ide_reg_latch = m_ide->ide_bus_r(0, reg); |
| 2120 | | return (ide_reg_latch & 0xff); |
| 2121 | ide_cs0_latch_r = m_ide->read_cs0(space, reg, 0xffff); |
| 2122 | return (ide_cs0_latch_r & 0xff); |
| 2121 | 2123 | } |
| 2122 | 2124 | else |
| 2123 | 2125 | { |
| 2124 | | return (ide_reg_latch >> 8) & 0xff; |
| 2126 | return (ide_cs0_latch_r >> 8) & 0xff; |
| 2125 | 2127 | } |
| 2126 | 2128 | } |
| 2127 | 2129 | else |
| r23540 | r23541 | |
| 2129 | 2131 | if (offset & 1) |
| 2130 | 2132 | fatalerror("tlcs_ide0_r: %02X, odd offset\n", offset); |
| 2131 | 2133 | |
| 2132 | | UINT8 d = m_ide->ide_bus_r(0, reg); |
| 2134 | UINT8 d = m_ide->read_cs0(space, reg, 0xff); |
| 2133 | 2135 | if (reg == 7) |
| 2134 | 2136 | d &= ~0x2; // Type Zero doesn't like the index bit. It's defined as vendor-specific, so it probably shouldn't be up... |
| 2135 | 2137 | // The status check explicitly checks for 0x50 (drive ready, seek complete). |
| r23540 | r23541 | |
| 2139 | 2141 | |
| 2140 | 2142 | WRITE8_MEMBER(taitotz_state::tlcs_ide0_w) |
| 2141 | 2143 | { |
| 2142 | | static UINT16 ide_reg_latch; |
| 2143 | 2144 | int reg = offset >> 1; |
| 2144 | 2145 | |
| 2145 | 2146 | if (reg == 7 || reg == 0) |
| 2146 | 2147 | { |
| 2147 | 2148 | if ((offset & 1) == 0) |
| 2148 | 2149 | { |
| 2149 | | ide_reg_latch &= 0xff00; |
| 2150 | | ide_reg_latch |= data; |
| 2150 | ide_cs0_latch_w &= 0xff00; |
| 2151 | ide_cs0_latch_w |= data; |
| 2151 | 2152 | } |
| 2152 | 2153 | else |
| 2153 | 2154 | { |
| 2154 | | ide_reg_latch &= 0x00ff; |
| 2155 | | ide_reg_latch |= (UINT16)(data) << 8; |
| 2156 | | m_ide->ide_bus_w(0, reg, ide_reg_latch); |
| 2155 | ide_cs0_latch_w &= 0x00ff; |
| 2156 | ide_cs0_latch_w |= (UINT16)(data) << 8; |
| 2157 | m_ide->write_cs0(space, reg, ide_cs0_latch_w, 0xffff); |
| 2157 | 2158 | } |
| 2158 | 2159 | } |
| 2159 | 2160 | else |
| 2160 | 2161 | { |
| 2161 | 2162 | if (offset & 1) |
| 2162 | 2163 | fatalerror("tlcs_ide0_w: %02X, %02X, odd offset\n", offset, data); |
| 2163 | | m_ide->ide_bus_w(0, reg, data); |
| 2164 | m_ide->write_cs0(space, reg, data, 0xff); |
| 2164 | 2165 | } |
| 2165 | 2166 | } |
| 2166 | 2167 | |
| 2167 | 2168 | READ8_MEMBER(taitotz_state::tlcs_ide1_r) |
| 2168 | 2169 | { |
| 2169 | | //static UINT16 ide_reg_latch; |
| 2170 | 2170 | int reg = offset >> 1; |
| 2171 | 2171 | |
| 2172 | 2172 | if (reg != 6) |
| r23540 | r23541 | |
| 2174 | 2174 | |
| 2175 | 2175 | if ((offset & 1) == 0) |
| 2176 | 2176 | { |
| 2177 | | UINT8 d = m_ide->ide_bus_r(1, reg); |
| 2177 | UINT8 d = m_ide->read_cs1(space, reg, 0xff); |
| 2178 | 2178 | d &= ~0x2; // Type Zero doesn't like the index bit. It's defined as vendor-specific, so it probably shouldn't be up... |
| 2179 | 2179 | // The status check explicitly checks for 0x50 (drive ready, seek complete). |
| 2180 | 2180 | return d; |
| r23540 | r23541 | |
| 2182 | 2182 | else |
| 2183 | 2183 | { |
| 2184 | 2184 | //fatalerror("tlcs_ide1_r: %02X, odd offset\n", offset); |
| 2185 | | UINT8 d = m_ide->ide_bus_r(1, reg); |
| 2185 | UINT8 d = m_ide->read_cs1(space, reg, 0xff); |
| 2186 | 2186 | d &= ~0x2; |
| 2187 | 2187 | return d; |
| 2188 | 2188 | } |
| r23540 | r23541 | |
| 2190 | 2190 | |
| 2191 | 2191 | WRITE8_MEMBER(taitotz_state::tlcs_ide1_w) |
| 2192 | 2192 | { |
| 2193 | | static UINT16 ide_reg_latch; |
| 2194 | 2193 | int reg = offset >> 1; |
| 2195 | 2194 | |
| 2196 | 2195 | if (reg != 6) |
| r23540 | r23541 | |
| 2198 | 2197 | |
| 2199 | 2198 | if ((offset & 1) == 0) |
| 2200 | 2199 | { |
| 2201 | | ide_reg_latch &= 0xff00; |
| 2202 | | ide_reg_latch |= data; |
| 2200 | ide_cs1_latch_w &= 0xff00; |
| 2201 | ide_cs1_latch_w |= data; |
| 2203 | 2202 | } |
| 2204 | 2203 | else |
| 2205 | 2204 | { |
| 2206 | | ide_reg_latch &= 0x00ff; |
| 2207 | | ide_reg_latch |= (UINT16)(data) << 16; |
| 2208 | | m_ide->ide_bus_w(1, reg, ide_reg_latch); |
| 2205 | ide_cs1_latch_w &= 0x00ff; |
| 2206 | ide_cs1_latch_w |= (UINT16)(data) << 16; |
| 2207 | m_ide->write_cs1(space, reg, ide_cs1_latch_w, 0xffff); |
| 2209 | 2208 | } |
| 2210 | 2209 | } |
| 2211 | 2210 | |
| r23540 | r23541 | |
| 2527 | 2526 | INPUT_PORTS_END |
| 2528 | 2527 | |
| 2529 | 2528 | |
| 2530 | | static void set_ide_drive_serial_number(device_t *device, int drive, const char *serial) |
| 2531 | | { |
| 2532 | | ide_controller_device *ide = (ide_controller_device *) device; |
| 2533 | | UINT8 *ide_features = ide->ide_get_features(drive); |
| 2534 | | |
| 2535 | | for (int i=0; i < 20; i++) |
| 2536 | | { |
| 2537 | | ide_features[10*2+(i^1)] = serial[i]; |
| 2538 | | } |
| 2539 | | } |
| 2540 | | |
| 2541 | | |
| 2542 | 2529 | void taitotz_state::machine_reset() |
| 2543 | 2530 | { |
| 2544 | 2531 | if (m_hdd_serial_number != NULL) |
| 2545 | 2532 | { |
| 2546 | | set_ide_drive_serial_number(m_ide, 0, m_hdd_serial_number); |
| 2533 | UINT8 *ide_features = m_ide->ide_get_features(0); |
| 2534 | |
| 2535 | for (int i=0; i < 20; i++) |
| 2536 | { |
| 2537 | ide_features[10*2+(i^1)] = m_hdd_serial_number[i]; |
| 2538 | } |
| 2547 | 2539 | } |
| 2548 | 2540 | } |
| 2549 | 2541 | |
trunk/src/mame/drivers/cobra.c
| r23540 | r23541 | |
| 610 | 610 | m_gfx_pagetable(*this, "pagetable"), |
| 611 | 611 | m_k001604(*this, "k001604"), |
| 612 | 612 | m_ide(*this, "ide") |
| 613 | | { } |
| 613 | { |
| 614 | } |
| 614 | 615 | |
| 615 | 616 | required_device<cpu_device> m_maincpu; |
| 616 | 617 | required_device<cpu_device> m_subcpu; |
| r23540 | r23541 | |
| 638 | 639 | DECLARE_WRITE32_MEMBER(sub_config_w); |
| 639 | 640 | DECLARE_READ32_MEMBER(sub_mainbd_r); |
| 640 | 641 | DECLARE_WRITE32_MEMBER(sub_mainbd_w); |
| 641 | | DECLARE_READ32_MEMBER(sub_ata0_r); |
| 642 | | DECLARE_WRITE32_MEMBER(sub_ata0_w); |
| 643 | | DECLARE_READ32_MEMBER(sub_ata1_r); |
| 644 | | DECLARE_WRITE32_MEMBER(sub_ata1_w); |
| 642 | DECLARE_READ16_MEMBER(sub_ata0_r); |
| 643 | DECLARE_WRITE16_MEMBER(sub_ata0_w); |
| 644 | DECLARE_READ16_MEMBER(sub_ata1_r); |
| 645 | DECLARE_WRITE16_MEMBER(sub_ata1_w); |
| 645 | 646 | DECLARE_READ32_MEMBER(sub_psac2_r); |
| 646 | 647 | DECLARE_WRITE32_MEMBER(sub_psac2_w); |
| 647 | 648 | DECLARE_WRITE32_MEMBER(sub_psac_palette_w); |
| r23540 | r23541 | |
| 1814 | 1815 | { |
| 1815 | 1816 | } |
| 1816 | 1817 | |
| 1817 | | READ32_MEMBER(cobra_state::sub_ata0_r) |
| 1818 | READ16_MEMBER(cobra_state::sub_ata0_r) |
| 1818 | 1819 | { |
| 1819 | | UINT32 r = 0; |
| 1820 | mem_mask = ( mem_mask << 8 ) | ( mem_mask >> 8 ); |
| 1820 | 1821 | |
| 1821 | | if (ACCESSING_BITS_16_31) |
| 1822 | | { |
| 1823 | | UINT16 v = m_ide->ide_bus_r(0, (offset << 1) + 0); |
| 1824 | | r |= ((v << 8) | (v >> 8)) << 16; |
| 1825 | | } |
| 1826 | | if (ACCESSING_BITS_0_15) |
| 1827 | | { |
| 1828 | | UINT16 v = m_ide->ide_bus_r(0, (offset << 1) + 1); |
| 1829 | | r |= ((v << 8) | (v >> 8)) << 0; |
| 1830 | | } |
| 1822 | UINT32 data = m_ide->read_cs0(space, offset, mem_mask); |
| 1823 | data = ( data << 8 ) | ( data >> 8 ); |
| 1831 | 1824 | |
| 1832 | | return r; |
| 1825 | return data; |
| 1833 | 1826 | } |
| 1834 | 1827 | |
| 1835 | | WRITE32_MEMBER(cobra_state::sub_ata0_w) |
| 1828 | WRITE16_MEMBER(cobra_state::sub_ata0_w) |
| 1836 | 1829 | { |
| 1837 | | if (ACCESSING_BITS_16_31) |
| 1838 | | { |
| 1839 | | UINT16 d = ((data >> 24) & 0xff) | ((data >> 8) & 0xff00); |
| 1840 | | m_ide->ide_bus_w(0, (offset << 1) + 0, d); |
| 1841 | | } |
| 1842 | | if (ACCESSING_BITS_0_15) |
| 1843 | | { |
| 1844 | | UINT16 d = ((data >> 8) & 0xff) | ((data << 8) & 0xff00); |
| 1845 | | m_ide->ide_bus_w(0, (offset << 1) + 1, d); |
| 1846 | | } |
| 1830 | mem_mask = ( mem_mask << 8 ) | ( mem_mask >> 8 ); |
| 1831 | data = ( data << 8 ) | ( data >> 8 ); |
| 1832 | |
| 1833 | m_ide->write_cs0(space, offset, data, mem_mask); |
| 1847 | 1834 | } |
| 1848 | 1835 | |
| 1849 | | READ32_MEMBER(cobra_state::sub_ata1_r) |
| 1836 | READ16_MEMBER(cobra_state::sub_ata1_r) |
| 1850 | 1837 | { |
| 1851 | | UINT32 r = 0; |
| 1838 | mem_mask = ( mem_mask << 8 ) | ( mem_mask >> 8 ); |
| 1852 | 1839 | |
| 1853 | | if (ACCESSING_BITS_16_31) |
| 1854 | | { |
| 1855 | | UINT16 v = m_ide->ide_bus_r(1, (offset << 1) + 0); |
| 1856 | | r |= ((v << 8) | (v >> 8)) << 16; |
| 1857 | | } |
| 1858 | | if (ACCESSING_BITS_0_15) |
| 1859 | | { |
| 1860 | | UINT16 v = m_ide->ide_bus_r(1, (offset << 1) + 1); |
| 1861 | | r |= ((v << 8) | (v >> 8)) << 0; |
| 1862 | | } |
| 1840 | UINT32 data = m_ide->read_cs1(space, offset, mem_mask); |
| 1863 | 1841 | |
| 1864 | | return r; |
| 1842 | return ( data << 8 ) | ( data >> 8 ); |
| 1865 | 1843 | } |
| 1866 | 1844 | |
| 1867 | | WRITE32_MEMBER(cobra_state::sub_ata1_w) |
| 1845 | WRITE16_MEMBER(cobra_state::sub_ata1_w) |
| 1868 | 1846 | { |
| 1869 | | if (ACCESSING_BITS_16_31) |
| 1870 | | { |
| 1871 | | UINT16 d = ((data >> 24) & 0xff) | ((data >> 8) & 0xff00); |
| 1872 | | m_ide->ide_bus_w(1, (offset << 1) + 0, d); |
| 1873 | | } |
| 1874 | | if (ACCESSING_BITS_0_15) |
| 1875 | | { |
| 1876 | | UINT16 d = ((data >> 8) & 0xff) | ((data << 8) & 0xff00); |
| 1877 | | m_ide->ide_bus_w(1, (offset << 1) + 1, d); |
| 1878 | | } |
| 1847 | mem_mask = ( mem_mask << 8 ) | ( mem_mask >> 8 ); |
| 1848 | data = ( data << 8 ) | ( data >> 8 ); |
| 1849 | |
| 1850 | m_ide->write_cs1(space, offset, data, mem_mask); |
| 1879 | 1851 | } |
| 1880 | 1852 | |
| 1881 | 1853 | READ32_MEMBER(cobra_state::sub_comram_r) |
| r23540 | r23541 | |
| 1983 | 1955 | AM_RANGE(0x70000000, 0x7003ffff) AM_MIRROR(0x80000000) AM_READWRITE(sub_comram_r, sub_comram_w) // Double buffered shared RAM between Main and Sub |
| 1984 | 1956 | // AM_RANGE(0x78000000, 0x780000ff) AM_MIRROR(0x80000000) AM_NOP // SCSI controller (unused) |
| 1985 | 1957 | AM_RANGE(0x78040000, 0x7804ffff) AM_MIRROR(0x80000000) AM_DEVREADWRITE16("rfsnd", rf5c400_device, rf5c400_r, rf5c400_w, 0xffffffff) |
| 1986 | | AM_RANGE(0x78080000, 0x7808000f) AM_MIRROR(0x80000000) AM_READWRITE(sub_ata0_r, sub_ata0_w) |
| 1987 | | AM_RANGE(0x780c0010, 0x780c001f) AM_MIRROR(0x80000000) AM_READWRITE(sub_ata1_r, sub_ata1_w) |
| 1958 | AM_RANGE(0x78080000, 0x7808000f) AM_MIRROR(0x80000000) AM_READWRITE16(sub_ata0_r, sub_ata0_w, 0xffffffff) |
| 1959 | AM_RANGE(0x780c0010, 0x780c001f) AM_MIRROR(0x80000000) AM_READWRITE16(sub_ata1_r, sub_ata1_w, 0xffffffff) |
| 1988 | 1960 | AM_RANGE(0x78200000, 0x782000ff) AM_MIRROR(0x80000000) AM_DEVREADWRITE_LEGACY("k001604", k001604_reg_r, k001604_reg_w) // PSAC registers |
| 1989 | 1961 | AM_RANGE(0x78210000, 0x78217fff) AM_MIRROR(0x80000000) AM_RAM_WRITE(sub_psac_palette_w) AM_SHARE("paletteram") // PSAC palette RAM |
| 1990 | 1962 | AM_RANGE(0x78220000, 0x7823ffff) AM_MIRROR(0x80000000) AM_DEVREADWRITE_LEGACY("k001604", k001604_tile_r, k001604_tile_w) // PSAC tile RAM |
trunk/src/mame/drivers/zn.c
| r23540 | r23541 | |
| 82 | 82 | DECLARE_WRITE8_MEMBER(coh1002m_bank_w); |
| 83 | 83 | DECLARE_READ8_MEMBER(cbaj_sound_main_status_r); |
| 84 | 84 | DECLARE_READ8_MEMBER(cbaj_sound_z80_status_r); |
| 85 | | DECLARE_READ8_MEMBER(jdredd_idestat_r); |
| 86 | | DECLARE_READ16_MEMBER(jdredd_ide_r); |
| 87 | | DECLARE_WRITE16_MEMBER(jdredd_ide_w); |
| 88 | 85 | DECLARE_DRIVER_INIT(coh1000ta); |
| 89 | 86 | DECLARE_DRIVER_INIT(coh1000tb); |
| 90 | 87 | DECLARE_DRIVER_INIT(coh1000c); |
| r23540 | r23541 | |
| 109 | 106 | |
| 110 | 107 | private: |
| 111 | 108 | inline void ATTR_PRINTF(3,4) verboselog( int n_level, const char *s_fmt, ... ); |
| 112 | | inline UINT8 psxreadbyte( UINT32 *p_n_psxram, UINT32 n_address ); |
| 113 | | inline void psxwritebyte( UINT32 *p_n_psxram, UINT32 n_address, UINT8 n_data ); |
| 109 | inline UINT16 psxreadword( UINT32 *p_n_psxram, UINT32 n_address ); |
| 110 | inline void psxwriteword( UINT32 *p_n_psxram, UINT32 n_address, UINT16 n_data ); |
| 114 | 111 | |
| 115 | 112 | UINT8 m_n_znsecsel; |
| 116 | 113 | |
| r23540 | r23541 | |
| 147 | 144 | } |
| 148 | 145 | |
| 149 | 146 | #ifdef UNUSED_FUNCTION |
| 150 | | inline UINT8 zn_state::psxreadbyte( UINT32 *p_n_psxram, UINT32 n_address ) |
| 147 | inline UINT16 zn_state::psxreadword( UINT32 *p_n_psxram, UINT32 n_address ) |
| 151 | 148 | { |
| 152 | | return *( (UINT8 *)p_n_psxram + BYTE4_XOR_LE( n_address ) ); |
| 149 | return *( (UINT16 *)( (UINT8 *)p_n_psxram + WORD_XOR_LE( n_address ) ) ); |
| 153 | 150 | } |
| 154 | 151 | #endif |
| 155 | 152 | |
| 156 | | inline void zn_state::psxwritebyte( UINT32 *p_n_psxram, UINT32 n_address, UINT8 n_data ) |
| 153 | inline void zn_state::psxwriteword( UINT32 *p_n_psxram, UINT32 n_address, UINT16 n_data ) |
| 157 | 154 | { |
| 158 | | *( (UINT8 *)p_n_psxram + BYTE4_XOR_LE( n_address ) ) = n_data; |
| 155 | *( (UINT16 *)( (UINT8 *)p_n_psxram + WORD_XOR_LE( n_address ) ) ) = n_data; |
| 159 | 156 | } |
| 160 | 157 | |
| 161 | 158 | static const UINT8 ac01[ 8 ] = { 0x80, 0x1c, 0xe2, 0xfa, 0xf9, 0xf1, 0x30, 0xc0 }; |
| r23540 | r23541 | |
| 1341 | 1338 | return; |
| 1342 | 1339 | } |
| 1343 | 1340 | |
| 1344 | | /* dma size is in 32-bit words, convert to bytes */ |
| 1345 | | n_size <<= 2; |
| 1341 | // printf( "%08x %08x %08x\n", n_address, n_size * 4, n_address + n_size * 4 ); |
| 1342 | |
| 1343 | /* dma size is in 32-bit words, convert to words */ |
| 1344 | n_size <<= 1; |
| 1346 | 1345 | address_space &space = machine().firstcpu->space(AS_PROGRAM); |
| 1347 | 1346 | while( n_size > 0 ) |
| 1348 | 1347 | { |
| 1349 | | psxwritebyte( p_n_psxram, n_address, m_ide->ide_controller32_r( space, 0x1f0 / 4, 0x000000ff ) ); |
| 1350 | | n_address++; |
| 1348 | psxwriteword( p_n_psxram, n_address, m_ide->read_cs0( space, 0, 0xffff ) ); |
| 1349 | n_address += 2; |
| 1351 | 1350 | n_size--; |
| 1352 | 1351 | } |
| 1352 | |
| 1353 | // printf( "%08x\n", n_address ); |
| 1353 | 1354 | } |
| 1354 | 1355 | |
| 1355 | 1356 | void zn_state::atpsx_dma_write( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size ) |
| r23540 | r23541 | |
| 1361 | 1362 | AM_RANGE(0x1f000000, 0x1f1fffff) AM_ROM AM_REGION("roms", 0) |
| 1362 | 1363 | AM_RANGE(0x1f000000, 0x1f000003) AM_WRITENOP |
| 1363 | 1364 | AM_RANGE(0x1f7e8000, 0x1f7e8003) AM_NOP |
| 1364 | | AM_RANGE(0x1f7e4000, 0x1f7e4fff) AM_DEVREADWRITE("ide", ide_controller_device, ide_controller32_r, ide_controller32_w ) |
| 1365 | | AM_RANGE(0x1f7f4000, 0x1f7f4fff) AM_DEVREADWRITE("ide", ide_controller_device, ide_controller32_r, ide_controller32_w ) |
| 1365 | AM_RANGE(0x1f7e4030, 0x1f7e403f) AM_DEVREADWRITE8("ide", ide_controller_device, read_via_config, write_via_config, 0xffffffff) |
| 1366 | AM_RANGE(0x1f7e41f0, 0x1f7e41f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0_pc, write_cs0_pc, 0xffffffff) |
| 1367 | AM_RANGE(0x1f7e43f0, 0x1f7e43f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1_pc, write_cs1_pc, 0xffffffff) |
| 1368 | AM_RANGE(0x1f7f41f0, 0x1f7f41f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0_pc, write_cs0_pc, 0xffffffff) |
| 1369 | AM_RANGE(0x1f7f43f0, 0x1f7f43f7) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1_pc, write_cs1_pc, 0xffffffff) |
| 1366 | 1370 | |
| 1367 | 1371 | AM_IMPORT_FROM(zn_map) |
| 1368 | 1372 | ADDRESS_MAP_END |
| r23540 | r23541 | |
| 1874 | 1878 | * - Unpopulated DIP42 socket |
| 1875 | 1879 | */ |
| 1876 | 1880 | |
| 1877 | | READ8_MEMBER(zn_state::jdredd_idestat_r) |
| 1878 | | { |
| 1879 | | return m_ide->ide_controller_r( 0x1f7, 1 ); |
| 1880 | | } |
| 1881 | | |
| 1882 | | READ16_MEMBER(zn_state::jdredd_ide_r) |
| 1883 | | { |
| 1884 | | UINT16 data = 0; |
| 1885 | | |
| 1886 | | if( ACCESSING_BITS_0_7 ) |
| 1887 | | { |
| 1888 | | data |= m_ide->ide_controller_r( 0x1f0 + offset, 1 ) << 0; |
| 1889 | | } |
| 1890 | | if( ACCESSING_BITS_8_15 ) |
| 1891 | | { |
| 1892 | | data |= m_ide->ide_controller_r( 0x1f0 + offset, 1 ) << 8; |
| 1893 | | } |
| 1894 | | |
| 1895 | | return data; |
| 1896 | | } |
| 1897 | | |
| 1898 | | WRITE16_MEMBER(zn_state::jdredd_ide_w) |
| 1899 | | { |
| 1900 | | if( ACCESSING_BITS_0_7 ) |
| 1901 | | { |
| 1902 | | m_ide->ide_controller_w( 0x1f0 + offset, 1, data >> 0 ); |
| 1903 | | } |
| 1904 | | if( ACCESSING_BITS_8_15 ) |
| 1905 | | { |
| 1906 | | m_ide->ide_controller_w( 0x1f0 + offset, 1, data >> 8 ); |
| 1907 | | } |
| 1908 | | } |
| 1909 | | |
| 1910 | 1881 | CUSTOM_INPUT_MEMBER(zn_state::jdredd_gun_mux_read) |
| 1911 | 1882 | { |
| 1912 | 1883 | return m_jdredd_gun_mux; |
| r23540 | r23541 | |
| 1988 | 1959 | ADDRESS_MAP_END |
| 1989 | 1960 | |
| 1990 | 1961 | static ADDRESS_MAP_START(jdredd_map, AS_PROGRAM, 32, zn_state) |
| 1991 | | AM_RANGE(0x1fbfff8c, 0x1fbfff8f) AM_READ8(jdredd_idestat_r, 0x000000ff) AM_WRITENOP |
| 1992 | | AM_RANGE(0x1fbfff90, 0x1fbfff9f) AM_READWRITE16(jdredd_ide_r, jdredd_ide_w, 0xffffffff) |
| 1962 | AM_RANGE(0x1fbfff80, 0x1fbfff8f) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs1, write_cs1, 0xffffffff) |
| 1963 | AM_RANGE(0x1fbfff90, 0x1fbfff9f) AM_DEVREADWRITE16("ide", ide_controller_device, read_cs0, write_cs0, 0xffffffff) |
| 1993 | 1964 | |
| 1994 | 1965 | AM_IMPORT_FROM(coh1000a_map) |
| 1995 | 1966 | ADDRESS_MAP_END |
trunk/src/mame/drivers/qdrmfgp.c
| r23540 | r23541 | |
| 181 | 181 | |
| 182 | 182 | /*************/ |
| 183 | 183 | |
| 184 | | READ16_MEMBER(qdrmfgp_state::ide_std_r) |
| 185 | | { |
| 186 | | if (offset & 0x01) |
| 187 | | return m_ide->ide_controller16_r(space, 0x1f0/2 + offset/2, 0xff00) >> 8; |
| 188 | | else |
| 189 | | return m_ide->ide_controller16_r(space, 0x1f0/2 + offset/2, 0xffff); |
| 190 | | } |
| 191 | 184 | |
| 192 | | WRITE16_MEMBER(qdrmfgp_state::ide_std_w) |
| 193 | | { |
| 194 | | if (offset & 0x01) |
| 195 | | m_ide->ide_controller16_w(space, 0x1f0/2 + offset/2, data << 8, 0xff00); |
| 196 | | else |
| 197 | | m_ide->ide_controller16_w(space, 0x1f0/2 + offset/2, data, 0xffff); |
| 198 | | } |
| 199 | | |
| 200 | | READ16_MEMBER(qdrmfgp_state::ide_alt_r) |
| 201 | | { |
| 202 | | if (offset == 0) |
| 203 | | return m_ide->ide_controller16_r(space, 0x3f6/2, 0x00ff); |
| 204 | | |
| 205 | | return 0; |
| 206 | | } |
| 207 | | |
| 208 | | WRITE16_MEMBER(qdrmfgp_state::ide_alt_w) |
| 209 | | { |
| 210 | | if (offset == 0) |
| 211 | | m_ide->ide_controller16_w(space, 0x3f6/2, data, 0x00ff); |
| 212 | | } |
| 213 | | |
| 214 | | |
| 215 | 185 | READ16_MEMBER(qdrmfgp_state::gp2_ide_std_r) |
| 216 | 186 | { |
| 217 | | if (offset & 0x01) |
| 187 | if (offset == 0x07) |
| 218 | 188 | { |
| 219 | | if (offset == 0x07) |
| 189 | switch (space.device().safe_pcbase()) |
| 220 | 190 | { |
| 221 | | switch (space.device().safe_pcbase()) |
| 222 | | { |
| 223 | | case 0xdb4c: |
| 224 | | if ((m_workram[0x5fa4/2] - space.device().state().state_int(M68K_D0)) <= 0x10) |
| 225 | | m_gp2_irq_control = 1; |
| 226 | | break; |
| 227 | | case 0xdec2: |
| 191 | case 0xdb4c: |
| 192 | if ((m_workram[0x5fa4/2] - space.device().state().state_int(M68K_D0)) <= 0x10) |
| 228 | 193 | m_gp2_irq_control = 1; |
| 229 | | default: |
| 230 | | break; |
| 231 | | } |
| 194 | break; |
| 195 | case 0xdec2: |
| 196 | m_gp2_irq_control = 1; |
| 197 | default: |
| 198 | break; |
| 232 | 199 | } |
| 233 | | |
| 234 | | return m_ide->ide_controller16_r(space, 0x1f0/2 + offset/2, 0xff00) >> 8; |
| 235 | 200 | } |
| 236 | | else |
| 237 | | { |
| 238 | | return m_ide->ide_controller16_r(space, 0x1f0/2 + offset/2, 0xffff); |
| 239 | | } |
| 201 | |
| 202 | return m_ide->read_cs0(space, offset, mem_mask); |
| 240 | 203 | } |
| 241 | 204 | |
| 242 | 205 | |
| r23540 | r23541 | |
| 328 | 291 | AM_RANGE(0x880000, 0x881fff) AM_DEVREADWRITE_LEGACY("k056832", k056832_ram_word_r, k056832_ram_word_w) /* vram */ |
| 329 | 292 | AM_RANGE(0x882000, 0x883fff) AM_DEVREADWRITE_LEGACY("k056832", k056832_ram_word_r, k056832_ram_word_w) /* vram (mirror) */ |
| 330 | 293 | AM_RANGE(0x900000, 0x901fff) AM_READ(v_rom_r) /* gfxrom through */ |
| 331 | | AM_RANGE(0xa00000, 0xa0000f) AM_READWRITE(ide_std_r,ide_std_w) /* IDE control regs */ |
| 332 | | AM_RANGE(0xa4000c, 0xa4000f) AM_READWRITE(ide_alt_r,ide_alt_w) /* IDE status control reg */ |
| 294 | AM_RANGE(0xa00000, 0xa0000f) AM_DEVREADWRITE("ide", ide_controller_device, read_cs0, write_cs0) /* IDE control regs */ |
| 295 | AM_RANGE(0xa40000, 0xa4000f) AM_DEVREADWRITE("ide", ide_controller_device, read_cs1, write_cs1) /* IDE status control reg */ |
| 333 | 296 | AM_RANGE(0xc00000, 0xcbffff) AM_READWRITE(sndram_r, sndram_w) /* sound ram */ |
| 334 | 297 | ADDRESS_MAP_END |
| 335 | 298 | |
| r23540 | r23541 | |
| 351 | 314 | AM_RANGE(0x880000, 0x881fff) AM_READWRITE(gp2_vram_r, gp2_vram_w) /* vram */ |
| 352 | 315 | AM_RANGE(0x89f000, 0x8a0fff) AM_READWRITE(gp2_vram_mirror_r, gp2_vram_mirror_w) /* vram (mirror) */ |
| 353 | 316 | AM_RANGE(0x900000, 0x901fff) AM_READ(v_rom_r) /* gfxrom through */ |
| 354 | | AM_RANGE(0xa00000, 0xa0000f) AM_READ(gp2_ide_std_r) AM_WRITE(ide_std_w) /* IDE control regs */ |
| 355 | | AM_RANGE(0xa4000c, 0xa4000f) AM_READWRITE(ide_alt_r,ide_alt_w) /* IDE status control reg */ |
| 317 | AM_RANGE(0xa00000, 0xa0000f) AM_READ(gp2_ide_std_r) AM_DEVWRITE("ide", ide_controller_device, write_cs0) /* IDE control regs */ |
| 318 | AM_RANGE(0xa40000, 0xa4000f) AM_DEVREADWRITE("ide", ide_controller_device, read_cs1, write_cs1) /* IDE status control reg */ |
| 356 | 319 | AM_RANGE(0xc00000, 0xcbffff) AM_READWRITE(sndram_r,sndram_w) /* sound ram */ |
| 357 | 320 | ADDRESS_MAP_END |
| 358 | 321 | |
trunk/src/emu/machine/idectrl.c
| r23540 | r23541 | |
| 42 | 42 | #define IDE_STATUS_DRIVE_READY 0x40 |
| 43 | 43 | #define IDE_STATUS_BUSY 0x80 |
| 44 | 44 | |
| 45 | | #define BANK(b, v) (((v) << 4) | (b)) |
| 45 | #define IDE_BANK0_DATA 0 |
| 46 | #define IDE_BANK0_ERROR 1 |
| 47 | #define IDE_BANK0_SECTOR_COUNT 2 |
| 48 | #define IDE_BANK0_SECTOR_NUMBER 3 |
| 49 | #define IDE_BANK0_CYLINDER_LSB 4 |
| 50 | #define IDE_BANK0_CYLINDER_MSB 5 |
| 51 | #define IDE_BANK0_HEAD_NUMBER 6 |
| 52 | #define IDE_BANK0_STATUS_COMMAND 7 |
| 46 | 53 | |
| 47 | | #define IDE_BANK0_DATA BANK(0, 0) |
| 48 | | #define IDE_BANK0_ERROR BANK(0, 1) |
| 49 | | #define IDE_BANK0_SECTOR_COUNT BANK(0, 2) |
| 50 | | #define IDE_BANK0_SECTOR_NUMBER BANK(0, 3) |
| 51 | | #define IDE_BANK0_CYLINDER_LSB BANK(0, 4) |
| 52 | | #define IDE_BANK0_CYLINDER_MSB BANK(0, 5) |
| 53 | | #define IDE_BANK0_HEAD_NUMBER BANK(0, 6) |
| 54 | | #define IDE_BANK0_STATUS_COMMAND BANK(0, 7) |
| 54 | #define IDE_BANK1_STATUS_CONTROL 6 |
| 55 | 55 | |
| 56 | | #define IDE_BANK1_STATUS_CONTROL BANK(1, 6) |
| 56 | #define IDE_BANK2_CONFIG_UNK 4 |
| 57 | #define IDE_BANK2_CONFIG_REGISTER 8 |
| 58 | #define IDE_BANK2_CONFIG_DATA 0xc |
| 57 | 59 | |
| 58 | | #define IDE_BANK2_CONFIG_UNK BANK(2, 4) |
| 59 | | #define IDE_BANK2_CONFIG_REGISTER BANK(2, 8) |
| 60 | | #define IDE_BANK2_CONFIG_DATA BANK(2, 0xc) |
| 61 | | |
| 62 | 60 | #define IDE_COMMAND_READ_MULTIPLE 0x20 |
| 63 | 61 | #define IDE_COMMAND_READ_MULTIPLE_NORETRY 0x21 |
| 64 | 62 | #define IDE_COMMAND_WRITE_MULTIPLE 0x30 |
| r23540 | r23541 | |
| 226 | 224 | return size; |
| 227 | 225 | } |
| 228 | 226 | |
| 229 | | INLINE int convert_to_offset_and_size16(offs_t *offset, UINT32 mem_mask) |
| 230 | | { |
| 231 | | int size = 2; |
| 232 | 227 | |
| 233 | | /* determine which real offset */ |
| 234 | | if (!ACCESSING_BITS_0_7) |
| 235 | | (*offset)++, size = 1; |
| 236 | 228 | |
| 237 | | if (ACCESSING_BITS_8_15) |
| 238 | | return size; |
| 239 | | size--; |
| 240 | | return size; |
| 241 | | } |
| 242 | | |
| 243 | | |
| 244 | | |
| 245 | 229 | /************************************* |
| 246 | 230 | * |
| 247 | 231 | * Advance to the next sector |
| r23540 | r23541 | |
| 968 | 952 | * |
| 969 | 953 | *************************************/ |
| 970 | 954 | |
| 971 | | UINT32 ide_controller_device::ide_controller_read(int bank, offs_t offset, int size) |
| 955 | READ8_MEMBER( ide_controller_device::read_via_config ) |
| 972 | 956 | { |
| 973 | | UINT32 result = 0; |
| 957 | UINT16 result = 0; |
| 958 | |
| 959 | /* logit */ |
| 960 | LOG(("%s:IDE via config read at %X, mem_mask=%d\n", machine().describe_context(), offset, mem_mask)); |
| 961 | |
| 962 | switch(offset) |
| 963 | { |
| 964 | /* unknown config register */ |
| 965 | case IDE_BANK2_CONFIG_UNK: |
| 966 | result = config_unknown; |
| 967 | break; |
| 968 | |
| 969 | /* active config register */ |
| 970 | case IDE_BANK2_CONFIG_REGISTER: |
| 971 | result = config_register_num; |
| 972 | break; |
| 973 | |
| 974 | /* data from active config register */ |
| 975 | case IDE_BANK2_CONFIG_DATA: |
| 976 | if (config_register_num < IDE_CONFIG_REGISTERS) |
| 977 | result = config_register[config_register_num]; |
| 978 | break; |
| 979 | |
| 980 | default: |
| 981 | logerror("%s:unknown IDE via config read at %03X, mem_mask=%d\n", machine().describe_context(), offset, mem_mask); |
| 982 | break; |
| 983 | } |
| 984 | |
| 985 | // printf( "read via config %04x %04x %04x\n", offset, result, mem_mask ); |
| 986 | return result; |
| 987 | } |
| 988 | |
| 989 | READ16_MEMBER( ide_controller_device::read_cs0_pc ) |
| 990 | { |
| 991 | if (mem_mask == 0xffff && offset == 1 ) offset = 0; // hack for 32 bit read of data register |
| 992 | if (mem_mask == 0xff00) |
| 993 | { |
| 994 | return read_cs0(space, (offset * 2) + 1, 0xff) << 8; |
| 995 | } |
| 996 | else |
| 997 | { |
| 998 | return read_cs0(space, offset * 2, mem_mask); |
| 999 | } |
| 1000 | } |
| 1001 | |
| 1002 | READ16_MEMBER( ide_controller_device::read_cs0 ) |
| 1003 | { |
| 1004 | UINT16 result = 0; |
| 974 | 1005 | ide_device_interface *dev = slot[cur_drive]->dev(); |
| 975 | 1006 | |
| 976 | 1007 | /* logit */ |
| 977 | | // if (BANK(bank, offset) != IDE_BANK0_DATA && BANK(bank, offset) != IDE_BANK0_STATUS_COMMAND && BANK(bank, offset) != IDE_BANK1_STATUS_CONTROL) |
| 978 | | LOG(("%s:IDE read at %d:%X, size=%d\n", machine().describe_context(), bank, offset, size)); |
| 1008 | // if (offset != IDE_BANK0_DATA && offset != IDE_BANK0_STATUS_COMMAND) |
| 1009 | LOG(("%s:IDE cs0 read at %X, mem_mask=%d\n", machine().describe_context(), offset, mem_mask)); |
| 979 | 1010 | |
| 980 | 1011 | if (dev != NULL) |
| 981 | 1012 | { |
| r23540 | r23541 | |
| 993 | 1024 | return status; |
| 994 | 1025 | } |
| 995 | 1026 | |
| 996 | | switch (BANK(bank, offset)) |
| 1027 | switch (offset) |
| 997 | 1028 | { |
| 998 | | /* unknown config register */ |
| 999 | | case IDE_BANK2_CONFIG_UNK: |
| 1000 | | return config_unknown; |
| 1001 | | |
| 1002 | | /* active config register */ |
| 1003 | | case IDE_BANK2_CONFIG_REGISTER: |
| 1004 | | return config_register_num; |
| 1005 | | |
| 1006 | | /* data from active config register */ |
| 1007 | | case IDE_BANK2_CONFIG_DATA: |
| 1008 | | if (config_register_num < IDE_CONFIG_REGISTERS) |
| 1009 | | return config_register[config_register_num]; |
| 1010 | | return 0; |
| 1011 | | |
| 1012 | 1029 | /* read data if there's data to be read */ |
| 1013 | 1030 | case IDE_BANK0_DATA: |
| 1014 | 1031 | if (status & IDE_STATUS_BUFFER_READY) |
| 1015 | 1032 | { |
| 1016 | 1033 | /* fetch the correct amount of data */ |
| 1017 | 1034 | result = buffer[buffer_offset++]; |
| 1018 | | if (size > 1) |
| 1035 | if (mem_mask == 0xffff) |
| 1019 | 1036 | result |= buffer[buffer_offset++] << 8; |
| 1020 | | if (size > 2) |
| 1021 | | { |
| 1022 | | result |= buffer[buffer_offset++] << 16; |
| 1023 | | result |= buffer[buffer_offset++] << 24; |
| 1024 | | } |
| 1025 | 1037 | |
| 1026 | 1038 | /* if we're at the end of the buffer, handle it */ |
| 1027 | 1039 | if (buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| r23540 | r23541 | |
| 1035 | 1047 | |
| 1036 | 1048 | /* return the current error */ |
| 1037 | 1049 | case IDE_BANK0_ERROR: |
| 1038 | | return error; |
| 1050 | result = error; |
| 1051 | break; |
| 1039 | 1052 | |
| 1040 | 1053 | /* return the current sector count */ |
| 1041 | 1054 | case IDE_BANK0_SECTOR_COUNT: |
| 1042 | | return sector_count; |
| 1055 | result = sector_count; |
| 1056 | break; |
| 1043 | 1057 | |
| 1044 | 1058 | /* return the current sector */ |
| 1045 | 1059 | case IDE_BANK0_SECTOR_NUMBER: |
| 1046 | | return dev->cur_sector; |
| 1060 | result = dev->cur_sector; |
| 1061 | break; |
| 1047 | 1062 | |
| 1048 | 1063 | /* return the current cylinder LSB */ |
| 1049 | 1064 | case IDE_BANK0_CYLINDER_LSB: |
| 1050 | | return dev->cur_cylinder & 0xff; |
| 1065 | result = dev->cur_cylinder & 0xff; |
| 1066 | break; |
| 1051 | 1067 | |
| 1052 | 1068 | /* return the current cylinder MSB */ |
| 1053 | 1069 | case IDE_BANK0_CYLINDER_MSB: |
| 1054 | | return dev->cur_cylinder >> 8; |
| 1070 | result = dev->cur_cylinder >> 8; |
| 1071 | break; |
| 1055 | 1072 | |
| 1056 | 1073 | /* return the current head */ |
| 1057 | 1074 | case IDE_BANK0_HEAD_NUMBER: |
| 1058 | | return dev->cur_head_reg; |
| 1075 | result = dev->cur_head_reg; |
| 1076 | break; |
| 1059 | 1077 | |
| 1060 | 1078 | /* return the current status and clear any pending interrupts */ |
| 1061 | 1079 | case IDE_BANK0_STATUS_COMMAND: |
| 1062 | | /* return the current status but don't clear interrupts */ |
| 1063 | | case IDE_BANK1_STATUS_CONTROL: |
| 1064 | 1080 | result = status; |
| 1065 | 1081 | if (last_status_timer->elapsed() > TIME_PER_ROTATION) |
| 1066 | 1082 | { |
| 1067 | 1083 | result |= IDE_STATUS_HIT_INDEX; |
| 1068 | 1084 | last_status_timer->adjust(attotime::never); |
| 1069 | 1085 | } |
| 1086 | if (interrupt_pending) |
| 1087 | clear_interrupt(); |
| 1088 | break; |
| 1070 | 1089 | |
| 1071 | | /* clear interrutps only when reading the real status */ |
| 1072 | | if (BANK(bank, offset) == IDE_BANK0_STATUS_COMMAND) |
| 1090 | /* log anything else */ |
| 1091 | default: |
| 1092 | logerror("%s:unknown IDE cs0 read at %03X, mem_mask=%d\n", machine().describe_context(), offset, mem_mask); |
| 1093 | break; |
| 1094 | } |
| 1095 | |
| 1096 | // printf( "read cs0 %04x %04x %04x\n", offset, result, mem_mask ); |
| 1097 | |
| 1098 | /* return the result */ |
| 1099 | return result; |
| 1100 | } |
| 1101 | |
| 1102 | |
| 1103 | READ16_MEMBER( ide_controller_device::read_cs1_pc ) |
| 1104 | { |
| 1105 | if (mem_mask == 0xff00) |
| 1106 | { |
| 1107 | return read_cs1(space, (offset * 2) + 1, 0xff) << 8; |
| 1108 | } |
| 1109 | else |
| 1110 | { |
| 1111 | return read_cs1(space, offset * 2, mem_mask); |
| 1112 | } |
| 1113 | } |
| 1114 | |
| 1115 | READ16_MEMBER( ide_controller_device::read_cs1 ) |
| 1116 | { |
| 1117 | UINT16 result = 0; |
| 1118 | ide_device_interface *dev = slot[cur_drive]->dev(); |
| 1119 | |
| 1120 | if (dev != NULL) |
| 1121 | { |
| 1122 | if (dev->is_ready()) { |
| 1123 | status |= IDE_STATUS_DRIVE_READY; |
| 1124 | } else { |
| 1125 | status &= ~IDE_STATUS_DRIVE_READY; |
| 1126 | } |
| 1127 | } |
| 1128 | else |
| 1129 | { |
| 1130 | /* even a do-nothing operation should take a little time */ |
| 1131 | |
| 1132 | status ^= IDE_STATUS_BUSY; |
| 1133 | return status; |
| 1134 | } |
| 1135 | |
| 1136 | /* logit */ |
| 1137 | // if (offset != IDE_BANK1_STATUS_CONTROL) |
| 1138 | LOG(("%s:IDE cs1 read at %X, mem_mask=%d\n", machine().describe_context(), offset, mem_mask)); |
| 1139 | /* return the current status but don't clear interrupts */ |
| 1140 | |
| 1141 | switch (offset) |
| 1142 | { |
| 1143 | case IDE_BANK1_STATUS_CONTROL: |
| 1144 | result = status; |
| 1145 | if (last_status_timer->elapsed() > TIME_PER_ROTATION) |
| 1073 | 1146 | { |
| 1074 | | if (interrupt_pending) |
| 1075 | | clear_interrupt(); |
| 1147 | result |= IDE_STATUS_HIT_INDEX; |
| 1148 | last_status_timer->adjust(attotime::never); |
| 1076 | 1149 | } |
| 1077 | 1150 | break; |
| 1078 | 1151 | |
| 1079 | 1152 | /* log anything else */ |
| 1080 | 1153 | default: |
| 1081 | | logerror("%s:unknown IDE read at %03X, size=%d\n", machine().describe_context(), offset, size); |
| 1154 | logerror("%s:unknown IDE cs1 read at %03X, mem_mask=%d\n", machine().describe_context(), offset, mem_mask); |
| 1082 | 1155 | break; |
| 1083 | 1156 | } |
| 1084 | 1157 | |
| 1158 | // printf( "read cs1 %04x %04x %04x\n", offset, result, mem_mask ); |
| 1159 | |
| 1085 | 1160 | /* return the result */ |
| 1086 | 1161 | return result; |
| 1087 | 1162 | } |
| 1088 | 1163 | |
| 1089 | 1164 | |
| 1090 | | |
| 1091 | 1165 | /************************************* |
| 1092 | 1166 | * |
| 1093 | 1167 | * IDE controller write |
| 1094 | 1168 | * |
| 1095 | 1169 | *************************************/ |
| 1096 | 1170 | |
| 1097 | | void ide_controller_device::ide_controller_write(int bank, offs_t offset, int size, UINT32 data) |
| 1171 | WRITE8_MEMBER( ide_controller_device::write_via_config ) |
| 1098 | 1172 | { |
| 1099 | | switch (BANK(bank, offset)) |
| 1100 | | { |
| 1101 | | case IDE_BANK0_HEAD_NUMBER: |
| 1102 | | cur_drive = (data & 0x10) >> 4; |
| 1103 | | break; |
| 1104 | | } |
| 1173 | // printf( "write via config %04x %04x %04x\n", offset, data, mem_mask ); |
| 1105 | 1174 | |
| 1106 | | ide_device_interface *dev = slot[cur_drive]->dev(); |
| 1107 | | if (dev == NULL) |
| 1108 | | return; |
| 1109 | | |
| 1110 | 1175 | /* logit */ |
| 1111 | | if (BANK(bank, offset) != IDE_BANK0_DATA) |
| 1112 | | LOG(("%s:IDE write to %d:%X = %08X, size=%d\n", machine().describe_context(), bank, offset, data, size)); |
| 1113 | | // fprintf(stderr, "ide write %03x %02x size=%d\n", offset, data, size); |
| 1114 | | switch (BANK(bank, offset)) |
| 1176 | LOG(("%s:IDE via config write to %X = %08X, mem_mask=%d\n", machine().describe_context(), offset, data, mem_mask)); |
| 1177 | |
| 1178 | switch (offset) |
| 1115 | 1179 | { |
| 1116 | 1180 | /* unknown config register */ |
| 1117 | 1181 | case IDE_BANK2_CONFIG_UNK: |
| r23540 | r23541 | |
| 1128 | 1192 | if (config_register_num < IDE_CONFIG_REGISTERS) |
| 1129 | 1193 | config_register[config_register_num] = data; |
| 1130 | 1194 | break; |
| 1195 | } |
| 1196 | } |
| 1131 | 1197 | |
| 1198 | WRITE16_MEMBER( ide_controller_device::write_cs0_pc ) |
| 1199 | { |
| 1200 | if (mem_mask == 0xffff && offset == 1 ) offset = 0; // hack for 32 bit write to data register |
| 1201 | if (mem_mask == 0xff00) |
| 1202 | { |
| 1203 | return write_cs0(space, (offset * 2) + 1, data >> 8, 0xff); |
| 1204 | } |
| 1205 | else |
| 1206 | { |
| 1207 | return write_cs0(space, offset * 2, data, mem_mask); |
| 1208 | } |
| 1209 | } |
| 1210 | |
| 1211 | WRITE16_MEMBER( ide_controller_device::write_cs0 ) |
| 1212 | { |
| 1213 | // printf( "write cs0 %04x %04x %04x\n", offset, data, mem_mask ); |
| 1214 | |
| 1215 | switch (offset) |
| 1216 | { |
| 1217 | case IDE_BANK0_HEAD_NUMBER: |
| 1218 | cur_drive = (data & 0x10) >> 4; |
| 1219 | break; |
| 1220 | } |
| 1221 | |
| 1222 | ide_device_interface *dev = slot[cur_drive]->dev(); |
| 1223 | if (dev == NULL) |
| 1224 | return; |
| 1225 | |
| 1226 | /* logit */ |
| 1227 | if (offset != IDE_BANK0_DATA) |
| 1228 | LOG(("%s:IDE cs0 write to %X = %08X, mem_mask=%d\n", machine().describe_context(), offset, data, mem_mask)); |
| 1229 | // fprintf(stderr, "ide write %03x %02x mem_mask=%d\n", offset, data, size); |
| 1230 | switch (offset) |
| 1231 | { |
| 1132 | 1232 | /* write data */ |
| 1133 | 1233 | case IDE_BANK0_DATA: |
| 1134 | 1234 | if (status & IDE_STATUS_BUFFER_READY) |
| 1135 | 1235 | { |
| 1136 | 1236 | /* store the correct amount of data */ |
| 1137 | 1237 | buffer[buffer_offset++] = data; |
| 1138 | | if (size > 1) |
| 1238 | if (mem_mask == 0xffff) |
| 1139 | 1239 | buffer[buffer_offset++] = data >> 8; |
| 1140 | | if (size > 2) |
| 1141 | | { |
| 1142 | | buffer[buffer_offset++] = data >> 16; |
| 1143 | | buffer[buffer_offset++] = data >> 24; |
| 1144 | | } |
| 1145 | 1240 | |
| 1146 | 1241 | /* if we're at the end of the buffer, handle it */ |
| 1147 | 1242 | if (buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| r23540 | r23541 | |
| 1245 | 1340 | case IDE_BANK0_STATUS_COMMAND: |
| 1246 | 1341 | handle_command(data); |
| 1247 | 1342 | break; |
| 1343 | } |
| 1344 | } |
| 1248 | 1345 | |
| 1346 | WRITE16_MEMBER( ide_controller_device::write_cs1_pc ) |
| 1347 | { |
| 1348 | if (mem_mask == 0xff00) |
| 1349 | { |
| 1350 | return write_cs1(space, (offset * 2) + 1, data >> 8, 0xff); |
| 1351 | } |
| 1352 | else |
| 1353 | { |
| 1354 | return write_cs1(space, offset * 2, data, mem_mask); |
| 1355 | } |
| 1356 | } |
| 1357 | |
| 1358 | WRITE16_MEMBER( ide_controller_device::write_cs1 ) |
| 1359 | { |
| 1360 | // printf( "write cs1 %04x %04x %04x\n", offset, data, mem_mask ); |
| 1361 | |
| 1362 | /* logit */ |
| 1363 | LOG(("%s:IDE cs1 write to %X = %08X, mem_mask=%d\n", machine().describe_context(), offset, data, mem_mask)); |
| 1364 | |
| 1365 | switch (offset) |
| 1366 | { |
| 1249 | 1367 | /* adapter control */ |
| 1250 | 1368 | case IDE_BANK1_STATUS_CONTROL: |
| 1251 | 1369 | adapter_control = data; |
| r23540 | r23541 | |
| 1263 | 1381 | } |
| 1264 | 1382 | |
| 1265 | 1383 | |
| 1266 | | |
| 1267 | 1384 | /************************************* |
| 1268 | 1385 | * |
| 1269 | 1386 | * Bus master read |
| r23540 | r23541 | |
| 1354 | 1471 | bus_master_descriptor = data & 0xfffffffc; |
| 1355 | 1472 | } |
| 1356 | 1473 | |
| 1357 | | |
| 1358 | | |
| 1359 | | /************************************* |
| 1360 | | * |
| 1361 | | * IDE direct handlers (16-bit) |
| 1362 | | * |
| 1363 | | *************************************/ |
| 1364 | | |
| 1365 | | /* |
| 1366 | | ide_bus_r() |
| 1367 | | |
| 1368 | | Read a 16-bit word from the IDE bus directly. |
| 1369 | | |
| 1370 | | select: 0->CS1Fx active, 1->CS3Fx active |
| 1371 | | offset: register offset (state of DA2-DA0) |
| 1372 | | */ |
| 1373 | | int ide_controller_device::ide_bus_r(int select, int offset) |
| 1374 | | { |
| 1375 | | return ide_controller_read(select ? 1 : 0, offset, select == 0 && offset == 0 ? 2 : 1); |
| 1376 | | } |
| 1377 | | |
| 1378 | | /* |
| 1379 | | ide_bus_w() |
| 1380 | | |
| 1381 | | Write a 16-bit word to the IDE bus directly. |
| 1382 | | |
| 1383 | | select: 0->CS1Fx active, 1->CS3Fx active |
| 1384 | | offset: register offset (state of DA2-DA0) |
| 1385 | | data: data written (state of D0-D15 or D0-D7) |
| 1386 | | */ |
| 1387 | | void ide_controller_device::ide_bus_w(int select, int offset, int data) |
| 1388 | | { |
| 1389 | | if (select == 0 && offset == 0) |
| 1390 | | ide_controller_write(0, 0, 2, data); |
| 1391 | | else |
| 1392 | | ide_controller_write(select ? 1 : 0, offset, 1, data & 0xff); |
| 1393 | | } |
| 1394 | | |
| 1395 | | UINT32 ide_controller_device::ide_controller_r(int reg, int size) |
| 1396 | | { |
| 1397 | | if (reg >= 0x1f0 && reg < 0x1f8) |
| 1398 | | return ide_controller_read(0, reg & 7, size); |
| 1399 | | if (reg >= 0x3f0 && reg < 0x3f8) |
| 1400 | | return ide_controller_read(1, reg & 7, size); |
| 1401 | | if (reg >= 0x030 && reg < 0x040) |
| 1402 | | return ide_controller_read(2, reg & 0xf, size); |
| 1403 | | return 0xffffffff; |
| 1404 | | } |
| 1405 | | |
| 1406 | | void ide_controller_device::ide_controller_w(int reg, int size, UINT32 data) |
| 1407 | | { |
| 1408 | | if (reg >= 0x1f0 && reg < 0x1f8) |
| 1409 | | ide_controller_write(0, reg & 7, size, data); |
| 1410 | | if (reg >= 0x3f0 && reg < 0x3f8) |
| 1411 | | ide_controller_write(1, reg & 7, size, data); |
| 1412 | | if (reg >= 0x030 && reg < 0x040) |
| 1413 | | ide_controller_write(2, reg & 0xf, size, data); |
| 1414 | | } |
| 1415 | | |
| 1416 | | |
| 1417 | | /************************************* |
| 1418 | | * |
| 1419 | | * 32-bit IDE handlers |
| 1420 | | * |
| 1421 | | *************************************/ |
| 1422 | | |
| 1423 | | READ32_MEMBER( ide_controller_device::ide_controller32_r ) |
| 1424 | | { |
| 1425 | | int size; |
| 1426 | | |
| 1427 | | offset *= 4; |
| 1428 | | size = convert_to_offset_and_size32(&offset, mem_mask); |
| 1429 | | |
| 1430 | | return ide_controller_r(offset, size) << ((offset & 3) * 8); |
| 1431 | | } |
| 1432 | | |
| 1433 | | |
| 1434 | | WRITE32_MEMBER( ide_controller_device::ide_controller32_w ) |
| 1435 | | { |
| 1436 | | int size; |
| 1437 | | |
| 1438 | | offset *= 4; |
| 1439 | | size = convert_to_offset_and_size32(&offset, mem_mask); |
| 1440 | | data = data >> ((offset & 3) * 8); |
| 1441 | | |
| 1442 | | ide_controller_w(offset, size, data); |
| 1443 | | } |
| 1444 | | |
| 1445 | | |
| 1446 | | READ16_MEMBER( ide_controller_device::ide_controller16_pcmcia_r ) |
| 1447 | | { |
| 1448 | | int size; |
| 1449 | | UINT32 res = 0xffff; |
| 1450 | | |
| 1451 | | offset *= 2; |
| 1452 | | size = convert_to_offset_and_size16(&offset, mem_mask); |
| 1453 | | |
| 1454 | | if (offset < 0x008) |
| 1455 | | res = ide_controller_read(0, offset & 7, size); |
| 1456 | | if (offset >= 0x008 && offset < 0x010) |
| 1457 | | res = ide_controller_read(1, offset & 7, size); |
| 1458 | | |
| 1459 | | return res << ((offset & 1) * 8); |
| 1460 | | } |
| 1461 | | |
| 1462 | | |
| 1463 | | WRITE16_MEMBER( ide_controller_device::ide_controller16_pcmcia_w ) |
| 1464 | | { |
| 1465 | | int size; |
| 1466 | | |
| 1467 | | offset *= 2; |
| 1468 | | size = convert_to_offset_and_size16(&offset, mem_mask); |
| 1469 | | data = data >> ((offset & 1) * 8); |
| 1470 | | |
| 1471 | | if (offset < 0x008) |
| 1472 | | ide_controller_write(0, offset & 7, size, data); |
| 1473 | | if (offset >= 0x008 && offset < 0x010) |
| 1474 | | ide_controller_write(1, offset & 7, size, data); |
| 1475 | | } |
| 1476 | | |
| 1477 | 1474 | READ32_MEMBER( ide_controller_device::ide_bus_master32_r ) |
| 1478 | 1475 | { |
| 1479 | 1476 | int size; |
| r23540 | r23541 | |
| 1496 | 1493 | } |
| 1497 | 1494 | |
| 1498 | 1495 | |
| 1499 | | |
| 1500 | | /************************************* |
| 1501 | | * |
| 1502 | | * 16-bit IDE handlers |
| 1503 | | * |
| 1504 | | *************************************/ |
| 1505 | | |
| 1506 | | READ16_MEMBER( ide_controller_device::ide_controller16_r ) |
| 1507 | | { |
| 1508 | | int size; |
| 1509 | | |
| 1510 | | offset *= 2; |
| 1511 | | size = convert_to_offset_and_size16(&offset, mem_mask); |
| 1512 | | |
| 1513 | | return ide_controller_r(offset, size) << ((offset & 1) * 8); |
| 1514 | | } |
| 1515 | | |
| 1516 | | |
| 1517 | | WRITE16_MEMBER( ide_controller_device::ide_controller16_w ) |
| 1518 | | { |
| 1519 | | int size; |
| 1520 | | |
| 1521 | | offset *= 2; |
| 1522 | | size = convert_to_offset_and_size16(&offset, mem_mask); |
| 1523 | | |
| 1524 | | ide_controller_w(offset, size, data >> ((offset & 1) * 8)); |
| 1525 | | } |
| 1526 | | |
| 1527 | 1496 | SLOT_INTERFACE_START(ide_devices) |
| 1528 | 1497 | SLOT_INTERFACE("hdd", IDE_HARDDISK) |
| 1529 | 1498 | SLOT_INTERFACE_END |