trunk/src/mess/machine/msx_slot.c
| r29193 | r29194 | |
| 347 | 347 | state->m_cart.scc.active = 0; |
| 348 | 348 | } |
| 349 | 349 | |
| 350 | | static READ8_HANDLER (konami_scc_bank5) |
| 350 | READ8_MEMBER(msx_state::konami_scc_bank5) |
| 351 | 351 | { |
| 352 | | msx_state *drvstate = space.machine().driver_data<msx_state>(); |
| 353 | 352 | if (offset & 0x80) |
| 354 | 353 | { |
| 355 | 354 | if ((offset & 0xff) >= 0xe0) |
| 356 | 355 | { |
| 357 | | return drvstate->m_k051649->k051649_test_r(space, offset & 0xff); |
| 356 | return m_k051649->k051649_test_r(space, offset & 0xff); |
| 358 | 357 | } |
| 359 | 358 | return 0xff; |
| 360 | 359 | } |
| 361 | 360 | else |
| 362 | 361 | { |
| 363 | | return drvstate->m_k051649->k051649_waveform_r(space, offset & 0x7f); |
| 362 | return m_k051649->k051649_waveform_r(space, offset & 0x7f); |
| 364 | 363 | } |
| 365 | 364 | } |
| 366 | 365 | |
| r29193 | r29194 | |
| 381 | 380 | msx_cpu_setbank (machine, 6, state->m_mem + state->m_banks[3] * 0x2000); |
| 382 | 381 | if (state->m_cart.scc.active ) { |
| 383 | 382 | msx_state *drvstate = machine.driver_data<msx_state>(); |
| 384 | | drvstate->m_maincpu->space(AS_PROGRAM).install_legacy_read_handler(0x9800, 0x9fff, FUNC(konami_scc_bank5)); |
| 383 | drvstate->m_maincpu->space(AS_PROGRAM).install_read_handler(0x9800, 0x9fff, read8_delegate(FUNC(msx_state::konami_scc_bank5),drvstate)); |
| 385 | 384 | } else { |
| 386 | 385 | msx_state *drvstate = machine.driver_data<msx_state>(); |
| 387 | 386 | drvstate->m_maincpu->space(AS_PROGRAM).install_read_bank(0x9800, 0x9fff,"bank7"); |
| r29193 | r29194 | |
| 1234 | 1233 | drvstate->m_wd179x->reset(); |
| 1235 | 1234 | } |
| 1236 | 1235 | |
| 1237 | | static READ8_HANDLER (msx_diskrom_page1_r) |
| 1236 | READ8_MEMBER(msx_state::msx_diskrom_page1_r) |
| 1238 | 1237 | { |
| 1239 | | msx_state *state = space.machine().driver_data<msx_state>(); |
| 1240 | 1238 | switch (offset) |
| 1241 | 1239 | { |
| 1242 | | case 0: return state->m_wd179x->status_r (space, 0); |
| 1243 | | case 1: return state->m_wd179x->track_r (space, 0); |
| 1244 | | case 2: return state->m_wd179x->sector_r (space, 0); |
| 1245 | | case 3: return state->m_wd179x->data_r (space, 0); |
| 1246 | | case 7: return state->m_dsk_stat; |
| 1240 | case 0: return m_wd179x->status_r (space, 0); |
| 1241 | case 1: return m_wd179x->track_r (space, 0); |
| 1242 | case 2: return m_wd179x->sector_r (space, 0); |
| 1243 | case 3: return m_wd179x->data_r (space, 0); |
| 1244 | case 7: return m_dsk_stat; |
| 1247 | 1245 | default: |
| 1248 | | return state->m_state[1]->m_mem[offset + 0x3ff8]; |
| 1246 | return m_state[1]->m_mem[offset + 0x3ff8]; |
| 1249 | 1247 | } |
| 1250 | 1248 | } |
| 1251 | 1249 | |
| 1252 | | static READ8_HANDLER (msx_diskrom_page2_r) |
| 1250 | READ8_MEMBER(msx_state::msx_diskrom_page2_r) |
| 1253 | 1251 | { |
| 1254 | | msx_state *state = space.machine().driver_data<msx_state>(); |
| 1255 | 1252 | if (offset >= 0x7f8) |
| 1256 | 1253 | { |
| 1257 | 1254 | switch (offset) |
| 1258 | 1255 | { |
| 1259 | 1256 | case 0x7f8: |
| 1260 | | return state->m_wd179x->status_r (space, 0); |
| 1257 | return m_wd179x->status_r (space, 0); |
| 1261 | 1258 | case 0x7f9: |
| 1262 | | return state->m_wd179x->track_r (space, 0); |
| 1259 | return m_wd179x->track_r (space, 0); |
| 1263 | 1260 | case 0x7fa: |
| 1264 | | return state->m_wd179x->sector_r (space, 0); |
| 1261 | return m_wd179x->sector_r (space, 0); |
| 1265 | 1262 | case 0x7fb: |
| 1266 | | return state->m_wd179x->data_r (space, 0); |
| 1263 | return m_wd179x->data_r (space, 0); |
| 1267 | 1264 | case 0x7ff: |
| 1268 | | return state->m_dsk_stat; |
| 1265 | return m_dsk_stat; |
| 1269 | 1266 | default: |
| 1270 | | return state->m_state[2]->m_mem[offset + 0x3800]; |
| 1267 | return m_state[2]->m_mem[offset + 0x3800]; |
| 1271 | 1268 | } |
| 1272 | 1269 | } |
| 1273 | 1270 | else |
| r29193 | r29194 | |
| 1289 | 1286 | case 1: |
| 1290 | 1287 | msx_cpu_setbank (machine, 3, state->m_mem); |
| 1291 | 1288 | msx_cpu_setbank (machine, 4, state->m_mem + 0x2000); |
| 1292 | | space.install_legacy_read_handler(0x7ff8, 0x7fff, FUNC(msx_diskrom_page1_r)); |
| 1289 | space.install_read_handler(0x7ff8, 0x7fff, read8_delegate(FUNC(msx_state::msx_diskrom_page1_r),drvstate)); |
| 1293 | 1290 | break; |
| 1294 | 1291 | case 2: |
| 1295 | 1292 | msx_cpu_setbank (machine, 5, drvstate->m_empty); |
| 1296 | 1293 | msx_cpu_setbank (machine, 6, drvstate->m_empty); |
| 1297 | | space.install_legacy_read_handler(0xb800, 0xbfff, FUNC(msx_diskrom_page2_r)); |
| 1294 | space.install_read_handler(0xb800, 0xbfff, read8_delegate(FUNC(msx_state::msx_diskrom_page2_r),drvstate)); |
| 1298 | 1295 | break; |
| 1299 | 1296 | case 3: |
| 1300 | 1297 | msx_cpu_setbank (machine, 7, drvstate->m_empty); |
| r29193 | r29194 | |
| 1361 | 1358 | drvstate->m_wd179x->reset(); |
| 1362 | 1359 | } |
| 1363 | 1360 | |
| 1364 | | static READ8_HANDLER (msx_diskrom2_page1_r) |
| 1361 | READ8_MEMBER(msx_state::msx_diskrom2_page1_r) |
| 1365 | 1362 | { |
| 1366 | | msx_state *state = space.machine().driver_data<msx_state>(); |
| 1367 | 1363 | switch (offset) |
| 1368 | 1364 | { |
| 1369 | | case 0: return state->m_wd179x->status_r(space, 0); |
| 1370 | | case 1: return state->m_wd179x->track_r(space, 0); |
| 1371 | | case 2: return state->m_wd179x->sector_r(space, 0); |
| 1372 | | case 3: return state->m_wd179x->data_r(space, 0); |
| 1373 | | case 4: return state->m_dsk_stat; |
| 1365 | case 0: return m_wd179x->status_r(space, 0); |
| 1366 | case 1: return m_wd179x->track_r(space, 0); |
| 1367 | case 2: return m_wd179x->sector_r(space, 0); |
| 1368 | case 3: return m_wd179x->data_r(space, 0); |
| 1369 | case 4: return m_dsk_stat; |
| 1374 | 1370 | default: |
| 1375 | | return state->m_state[1]->m_mem[offset + 0x3ff8]; |
| 1371 | return m_state[1]->m_mem[offset + 0x3ff8]; |
| 1376 | 1372 | } |
| 1377 | 1373 | } |
| 1378 | 1374 | |
| 1379 | | static READ8_HANDLER (msx_diskrom2_page2_r) |
| 1375 | READ8_MEMBER(msx_state::msx_diskrom2_page2_r) |
| 1380 | 1376 | { |
| 1381 | | msx_state *state = space.machine().driver_data<msx_state>(); |
| 1382 | 1377 | if (offset >= 0x7b8) |
| 1383 | 1378 | { |
| 1384 | 1379 | switch (offset) |
| 1385 | 1380 | { |
| 1386 | 1381 | case 0x7b8: |
| 1387 | | return state->m_wd179x->status_r (space, 0); |
| 1382 | return m_wd179x->status_r (space, 0); |
| 1388 | 1383 | case 0x7b9: |
| 1389 | | return state->m_wd179x->track_r (space, 0); |
| 1384 | return m_wd179x->track_r (space, 0); |
| 1390 | 1385 | case 0x7ba: |
| 1391 | | return state->m_wd179x->sector_r (space, 0); |
| 1386 | return m_wd179x->sector_r (space, 0); |
| 1392 | 1387 | case 0x7bb: |
| 1393 | | return state->m_wd179x->data_r (space, 0); |
| 1388 | return m_wd179x->data_r (space, 0); |
| 1394 | 1389 | case 0x7bc: |
| 1395 | | return state->m_dsk_stat; |
| 1390 | return m_dsk_stat; |
| 1396 | 1391 | default: |
| 1397 | | return state->m_state[2]->m_mem[offset + 0x3800]; |
| 1392 | return m_state[2]->m_mem[offset + 0x3800]; |
| 1398 | 1393 | } |
| 1399 | 1394 | } |
| 1400 | 1395 | else |
| r29193 | r29194 | |
| 1416 | 1411 | case 1: |
| 1417 | 1412 | msx_cpu_setbank (machine, 3, state->m_mem); |
| 1418 | 1413 | msx_cpu_setbank (machine, 4, state->m_mem + 0x2000); |
| 1419 | | space.install_legacy_read_handler(0x7fb8, 0x7fbc, FUNC(msx_diskrom2_page1_r)); |
| 1414 | space.install_read_handler(0x7fb8, 0x7fbc, read8_delegate(FUNC(msx_state::msx_diskrom2_page1_r),drvstate)); |
| 1420 | 1415 | break; |
| 1421 | 1416 | case 2: |
| 1422 | 1417 | msx_cpu_setbank (machine, 5, drvstate->m_empty); |
| 1423 | 1418 | msx_cpu_setbank (machine, 6, drvstate->m_empty); |
| 1424 | | space.install_legacy_read_handler(0xb800, 0xbfbc, FUNC(msx_diskrom2_page2_r)); |
| 1419 | space.install_read_handler(0xb800, 0xbfbc, read8_delegate(FUNC(msx_state::msx_diskrom2_page2_r),drvstate)); |
| 1425 | 1420 | break; |
| 1426 | 1421 | case 3: |
| 1427 | 1422 | msx_cpu_setbank (machine, 7, drvstate->m_empty); |
| r29193 | r29194 | |
| 2181 | 2176 | state->m_cart.sccp.sccp_active = 0; |
| 2182 | 2177 | } |
| 2183 | 2178 | |
| 2184 | | static READ8_HANDLER (soundcartridge_scc) |
| 2179 | READ8_MEMBER(msx_state::soundcartridge_scc) |
| 2185 | 2180 | { |
| 2186 | | msx_state *state = space.machine().driver_data<msx_state>(); |
| 2187 | 2181 | int reg; |
| 2188 | 2182 | |
| 2189 | 2183 | |
| 2190 | 2184 | if (offset >= 0x7e0) |
| 2191 | 2185 | { |
| 2192 | | return state->m_state[2]->m_mem[ |
| 2193 | | state->m_state[2]->m_banks[2] * 0x2000 + 0x1800 + offset]; |
| 2186 | return m_state[2]->m_mem[ |
| 2187 | m_state[2]->m_banks[2] * 0x2000 + 0x1800 + offset]; |
| 2194 | 2188 | } |
| 2195 | 2189 | |
| 2196 | 2190 | reg = offset & 0xff; |
| 2197 | 2191 | |
| 2198 | 2192 | if (reg < 0x80) |
| 2199 | 2193 | { |
| 2200 | | return state->m_k051649->k051649_waveform_r (space, reg); |
| 2194 | return m_k051649->k051649_waveform_r (space, reg); |
| 2201 | 2195 | } |
| 2202 | 2196 | else if (reg < 0xa0) |
| 2203 | 2197 | { |
| r29193 | r29194 | |
| 2206 | 2200 | else if (reg < 0xc0) |
| 2207 | 2201 | { |
| 2208 | 2202 | /* read wave 5 */ |
| 2209 | | return state->m_k051649->k051649_waveform_r (space, 0x80 + (reg & 0x1f)); |
| 2203 | return m_k051649->k051649_waveform_r (space, 0x80 + (reg & 0x1f)); |
| 2210 | 2204 | } |
| 2211 | 2205 | else if (reg < 0xe0) |
| 2212 | 2206 | { |
| 2213 | | return state->m_k051649->k051649_test_r (space, reg); |
| 2207 | return m_k051649->k051649_test_r (space, reg); |
| 2214 | 2208 | } |
| 2215 | 2209 | |
| 2216 | 2210 | return 0xff; |
| 2217 | 2211 | } |
| 2218 | 2212 | |
| 2219 | | static READ8_HANDLER (soundcartridge_sccp) |
| 2213 | READ8_MEMBER(msx_state::soundcartridge_sccp) |
| 2220 | 2214 | { |
| 2221 | | msx_state *state = space.machine().driver_data<msx_state>(); |
| 2222 | 2215 | int reg; |
| 2223 | 2216 | |
| 2224 | 2217 | if (offset >= 0x7e0) |
| 2225 | 2218 | { |
| 2226 | | return state->m_state[2]->m_mem[ |
| 2227 | | state->m_state[2]->m_banks[3] * 0x2000 + 0x1800 + offset]; |
| 2219 | return m_state[2]->m_mem[ |
| 2220 | m_state[2]->m_banks[3] * 0x2000 + 0x1800 + offset]; |
| 2228 | 2221 | } |
| 2229 | 2222 | |
| 2230 | 2223 | reg = offset & 0xff; |
| 2231 | 2224 | |
| 2232 | 2225 | if (reg < 0xa0) |
| 2233 | 2226 | { |
| 2234 | | return state->m_k051649->k051649_waveform_r (space, reg); |
| 2227 | return m_k051649->k051649_waveform_r (space, reg); |
| 2235 | 2228 | } |
| 2236 | 2229 | else if (reg >= 0xc0 && reg < 0xe0) |
| 2237 | 2230 | { |
| 2238 | | return state->m_k051649->k051649_test_r (space, reg); |
| 2231 | return m_k051649->k051649_test_r (space, reg); |
| 2239 | 2232 | } |
| 2240 | 2233 | |
| 2241 | 2234 | return 0xff; |
| r29193 | r29194 | |
| 2259 | 2252 | msx_cpu_setbank (machine, 5, state->m_mem + state->m_banks[2] * 0x2000); |
| 2260 | 2253 | msx_cpu_setbank (machine, 6, state->m_mem + state->m_banks[3] * 0x2000); |
| 2261 | 2254 | if (state->m_cart.sccp.scc_active) { |
| 2262 | | space.install_legacy_read_handler(0x9800, 0x9fff, FUNC(soundcartridge_scc)); |
| 2255 | space.install_read_handler(0x9800, 0x9fff, read8_delegate(FUNC(msx_state::soundcartridge_scc),drvstate)); |
| 2263 | 2256 | } else { |
| 2264 | 2257 | space.install_read_bank(0x9800, 0x9fff, "bank7"); |
| 2265 | 2258 | } |
| 2266 | 2259 | if (state->m_cart.sccp.scc_active) { |
| 2267 | | space.install_legacy_read_handler(0xb800, 0xbfff, FUNC(soundcartridge_sccp)); |
| 2260 | space.install_read_handler(0xb800, 0xbfff, read8_delegate(FUNC(msx_state::soundcartridge_sccp),drvstate)); |
| 2268 | 2261 | } else { |
| 2269 | 2262 | space.install_read_bank(0xb800, 0xbfff, "bank9"); |
| 2270 | 2263 | } |