src/mess/machine/pet.c
| r4827 | r4828 | |
| 76 | 76 | */ |
| 77 | 77 | static READ8_DEVICE_HANDLER ( pet_pia0_port_a_read ) |
| 78 | 78 | { |
| 79 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 79 | 80 | int data = 0xf0 | pet_keyline_select; |
| 80 | 81 | |
| 81 | 82 | if ((cassette_get_state(devtag_get_device(device->machine, "cassette1")) & CASSETTE_MASK_UISTATE) != CASSETTE_STOPPED) |
| r4827 | r4828 | |
| 84 | 85 | if ((cassette_get_state(devtag_get_device(device->machine, "cassette2")) & CASSETTE_MASK_UISTATE) != CASSETTE_STOPPED) |
| 85 | 86 | data &= ~0x20; |
| 86 | 87 | |
| 87 | | if (!cbm_ieee_eoi_r(device->machine)) |
| 88 | if (!cbm_ieee_eoi_r(ieeebus, 0)) |
| 88 | 89 | data &= ~0x40; |
| 89 | 90 | |
| 90 | 91 | return data; |
| r4827 | r4828 | |
| 150 | 151 | |
| 151 | 152 | static WRITE8_DEVICE_HANDLER( pet_pia0_ca2_out ) |
| 152 | 153 | { |
| 153 | | cbm_ieee_eoi_w(device->machine, 0, data); |
| 154 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 155 | cbm_ieee_eoi_write(ieeebus, 0, data); |
| 154 | 156 | } |
| 155 | 157 | |
| 156 | 158 | static WRITE8_DEVICE_HANDLER( pet_pia0_cb2_out ) |
| r4827 | r4828 | |
| 194 | 196 | */ |
| 195 | 197 | static READ8_DEVICE_HANDLER ( pet_pia1_port_a_read ) |
| 196 | 198 | { |
| 197 | | return cbm_ieee_data_r(device->machine); |
| 199 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 200 | return cbm_ieee_data_r(ieeebus, 0); |
| 198 | 201 | } |
| 199 | 202 | |
| 200 | 203 | static WRITE8_DEVICE_HANDLER ( pet_pia1_port_b_write ) |
| 201 | 204 | { |
| 202 | | cbm_ieee_data_w(device->machine, 0, data); |
| 205 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 206 | cbm_ieee_data_write(ieeebus, 0, data); |
| 203 | 207 | } |
| 204 | 208 | |
| 205 | 209 | static READ8_DEVICE_HANDLER ( pet_pia1_ca1_read ) |
| 206 | 210 | { |
| 207 | | return cbm_ieee_atn_r(device->machine); |
| 211 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 212 | return cbm_ieee_atn_r(ieeebus,0 ); |
| 208 | 213 | } |
| 209 | 214 | |
| 210 | 215 | static WRITE8_DEVICE_HANDLER ( pet_pia1_ca2_write ) |
| 211 | 216 | { |
| 212 | | cbm_ieee_ndac_w(device->machine, 0, data); |
| 217 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 218 | cbm_ieee_ndac_write(ieeebus, 0, data); |
| 213 | 219 | } |
| 214 | 220 | |
| 215 | 221 | static WRITE8_DEVICE_HANDLER ( pet_pia1_cb2_write ) |
| 216 | 222 | { |
| 217 | | cbm_ieee_dav_w(device->machine, 0, data); |
| 223 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 224 | cbm_ieee_dav_write(ieeebus, 0, data); |
| 218 | 225 | } |
| 219 | 226 | |
| 220 | 227 | static READ8_DEVICE_HANDLER ( pet_pia1_cb1_read ) |
| 221 | 228 | { |
| 222 | | return cbm_ieee_srq_r(device->machine); |
| 229 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 230 | return cbm_ieee_srq_r(ieeebus, 0); |
| 223 | 231 | } |
| 224 | 232 | |
| 225 | 233 | const pia6821_interface pet_pia0 = |
| r4827 | r4828 | |
| 297 | 305 | */ |
| 298 | 306 | static READ8_DEVICE_HANDLER( pet_via_port_b_r ) |
| 299 | 307 | { |
| 308 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 300 | 309 | UINT8 data = 0; |
| 301 | 310 | |
| 302 | | if (cbm_ieee_ndac_r(device->machine)) data |= 0x01; |
| 311 | if (cbm_ieee_ndac_r(ieeebus, 0)) |
| 312 | data |= 0x01; |
| 303 | 313 | |
| 304 | 314 | // data & 0x08 -> cassette write (it seems to BOTH cassettes from schematics) |
| 305 | 315 | |
| r4827 | r4828 | |
| 314 | 324 | timer_reset(datasette2_timer, attotime_never); |
| 315 | 325 | } |
| 316 | 326 | |
| 317 | | if (cbm_ieee_nrfd_r(device->machine)) data |= 0x40; |
| 327 | if (cbm_ieee_nrfd_r(ieeebus, 0)) |
| 328 | data |= 0x40; |
| 318 | 329 | |
| 319 | | if (cbm_ieee_dav_r(device->machine)) data |= 0x80; |
| 330 | if (cbm_ieee_dav_r(ieeebus, 0)) |
| 331 | data |= 0x80; |
| 320 | 332 | |
| 321 | 333 | return data; |
| 322 | 334 | } |
| r4827 | r4828 | |
| 331 | 343 | |
| 332 | 344 | static WRITE8_DEVICE_HANDLER( pet_via_port_b_w ) |
| 333 | 345 | { |
| 334 | | cbm_ieee_nrfd_w(device->machine, 0, data & 2); |
| 335 | | cbm_ieee_atn_w(device->machine, 0, data & 4); |
| 346 | const device_config *ieeebus = devtag_get_device(device->machine, "ieee_bus"); |
| 347 | cbm_ieee_nrfd_write(ieeebus, 0, data & 2); |
| 348 | cbm_ieee_atn_write(ieeebus, 0, data & 4); |
| 336 | 349 | } |
| 337 | 350 | |
| 338 | 351 | |
| r4827 | r4828 | |
| 617 | 630 | /* datasette */ |
| 618 | 631 | datasette1_timer = timer_alloc(machine, pet_tape1_timer, NULL); |
| 619 | 632 | datasette2_timer = timer_alloc(machine, pet_tape2_timer, NULL); |
| 620 | | |
| 621 | | cbm_ieee_open(); |
| 622 | 633 | } |
| 623 | 634 | |
| 624 | 635 | |
src/mess/machine/cbmdrive.c
| r4827 | r4828 | |
| 1320 | 1320 | |
| 1321 | 1321 | void c2031_state(running_machine *machine, CBM_Drive *drive) |
| 1322 | 1322 | { |
| 1323 | const device_config *ieeebus = devtag_get_device(machine, "ieee_bus"); |
| 1323 | 1324 | int oldstate = drive->i.ieee.state; |
| 1324 | 1325 | int data; |
| 1325 | 1326 | |
| 1326 | 1327 | switch (drive->i.ieee.state) |
| 1327 | 1328 | { |
| 1328 | 1329 | case 0: |
| 1329 | | if (!cbm_ieee_dav_r(machine)) |
| 1330 | if (!cbm_ieee_dav_r(ieeebus, 0)) |
| 1330 | 1331 | { |
| 1331 | 1332 | drive->i.ieee.state = 10; |
| 1332 | 1333 | } |
| 1333 | | else if (!cbm_ieee_atn_r(machine)) |
| 1334 | else if (!cbm_ieee_atn_r(ieeebus, 0)) |
| 1334 | 1335 | { |
| 1335 | 1336 | drive->i.ieee.state = 11; |
| 1336 | | cbm_ieee_ndac_w(machine, 1, 0); |
| 1337 | cbm_ieee_ndac_w(ieeebus, 1, 0); |
| 1337 | 1338 | logerror("arsch\n"); |
| 1338 | 1339 | } |
| 1339 | 1340 | break; |
| 1340 | 1341 | case 1: |
| 1341 | 1342 | break; |
| 1342 | 1343 | case 10: |
| 1343 | | if (cbm_ieee_dav_r(machine)) |
| 1344 | if (cbm_ieee_dav_r(ieeebus, 0)) |
| 1344 | 1345 | { |
| 1345 | 1346 | drive->i.ieee.state++; |
| 1346 | | cbm_ieee_nrfd_w(machine, 1, 1); |
| 1347 | | cbm_ieee_ndac_w(machine, 1, 0); |
| 1347 | cbm_ieee_nrfd_w(ieeebus, 1, 1); |
| 1348 | cbm_ieee_ndac_w(ieeebus, 1, 0); |
| 1348 | 1349 | } |
| 1349 | 1350 | break; |
| 1350 | 1351 | case 11: |
| 1351 | | if (!cbm_ieee_dav_r(machine)) |
| 1352 | if (!cbm_ieee_dav_r(ieeebus, 0)) |
| 1352 | 1353 | { |
| 1353 | | cbm_ieee_nrfd_w(machine, 1, 0); |
| 1354 | | data = cbm_ieee_data_r(machine) ^ 0xff; |
| 1355 | | cbm_ieee_ndac_w(machine, 1, 1); |
| 1354 | cbm_ieee_nrfd_w(ieeebus, 1, 0); |
| 1355 | data = cbm_ieee_data_r(ieeebus, 0) ^ 0xff; |
| 1356 | cbm_ieee_ndac_w(ieeebus, 1, 1); |
| 1356 | 1357 | logerror("byte received %.2x\n",data); |
| 1357 | | if (!cbm_ieee_atn_r(machine) && ((data & 0x0f) == drive->i.ieee.device)) |
| 1358 | if (!cbm_ieee_atn_r(ieeebus, 0) && ((data & 0x0f) == drive->i.ieee.device)) |
| 1358 | 1359 | { |
| 1359 | 1360 | if ((data & 0xf0) == 0x40) |
| 1360 | 1361 | drive->i.ieee.state = 30; |
| r4827 | r4828 | |
| 1375 | 1376 | break; |
| 1376 | 1377 | /* wait until atn is released */ |
| 1377 | 1378 | case 12: |
| 1378 | | if (cbm_ieee_atn_r(machine)) |
| 1379 | if (cbm_ieee_atn_r(ieeebus, 0)) |
| 1379 | 1380 | { |
| 1380 | 1381 | drive->i.ieee.state++; |
| 1381 | | cbm_ieee_nrfd_w(machine, 1, 0); |
| 1382 | cbm_ieee_nrfd_w(ieeebus, 1, 0); |
| 1382 | 1383 | } |
| 1383 | 1384 | break; |
| 1384 | 1385 | case 13: |
| 1385 | | if (!cbm_ieee_atn_r(machine)) |
| 1386 | if (!cbm_ieee_atn_r(ieeebus, 0)) |
| 1386 | 1387 | { |
| 1387 | 1388 | drive->i.ieee.state = 10; |
| 1388 | | /* cbm_ieee_nrfd_w(machine, 1, 0); */ |
| 1389 | /* cbm_ieee_nrfd_w(ieeebus, 1, 0); */ |
| 1389 | 1390 | } |
| 1390 | 1391 | break; |
| 1391 | 1392 | |
| 1392 | 1393 | /* receiving rest of command */ |
| 1393 | 1394 | case 20: |
| 1394 | | if (cbm_ieee_dav_r(machine)) |
| 1395 | if (cbm_ieee_dav_r(ieeebus, 0)) |
| 1395 | 1396 | { |
| 1396 | 1397 | drive->i.ieee.state++; |
| 1397 | | cbm_ieee_nrfd_w(machine, 1, 1); |
| 1398 | | cbm_ieee_ndac_w(machine, 1, 0); |
| 1398 | cbm_ieee_nrfd_w(ieeebus, 1, 1); |
| 1399 | cbm_ieee_ndac_w(ieeebus, 1, 0); |
| 1399 | 1400 | } |
| 1400 | 1401 | break; |
| 1401 | 1402 | case 21: |
| 1402 | | if (!cbm_ieee_dav_r(machine)) |
| 1403 | if (!cbm_ieee_dav_r(ieeebus, 0)) |
| 1403 | 1404 | { |
| 1404 | | cbm_ieee_nrfd_w(machine, 1, 0); |
| 1405 | | data = cbm_ieee_data_r(machine) ^ 0xff; |
| 1405 | cbm_ieee_nrfd_w(ieeebus, 1, 0); |
| 1406 | data = cbm_ieee_data_r(ieeebus, 0) ^ 0xff; |
| 1406 | 1407 | logerror("byte received %.2x\n",data); |
| 1407 | 1408 | if (drive->cmdpos < sizeof (drive->cmdbuffer)) |
| 1408 | 1409 | drive->cmdbuffer[drive->cmdpos++] = data; |
| 1409 | | if (!cbm_ieee_atn_r(machine) && ((data & 0xf) == 0xf)) |
| 1410 | if (!cbm_ieee_atn_r(ieeebus, 0) && ((data & 0xf) == 0xf)) |
| 1410 | 1411 | { |
| 1411 | 1412 | cbm_command(machine, drive); |
| 1412 | 1413 | drive->i.ieee.state = 10; |
| r4827 | r4828 | |
| 1414 | 1415 | else |
| 1415 | 1416 | drive->i.ieee.state = 20; |
| 1416 | 1417 | |
| 1417 | | cbm_ieee_ndac_w(machine, 1, 1); |
| 1418 | cbm_ieee_ndac_w(ieeebus, 1, 1); |
| 1418 | 1419 | } |
| 1419 | 1420 | break; |
| 1420 | 1421 | |
| 1421 | 1422 | /* read command */ |
| 1422 | 1423 | case 30: |
| 1423 | | if (cbm_ieee_dav_r(machine)) |
| 1424 | if (cbm_ieee_dav_r(ieeebus, 0)) |
| 1424 | 1425 | { |
| 1425 | 1426 | drive->i.ieee.state++; |
| 1426 | | cbm_ieee_nrfd_w(machine, 1, 1); |
| 1427 | | cbm_ieee_ndac_w(machine, 1, 0); |
| 1427 | cbm_ieee_nrfd_w(ieeebus, 1, 1); |
| 1428 | cbm_ieee_ndac_w(ieeebus, 1, 0); |
| 1428 | 1429 | } |
| 1429 | 1430 | break; |
| 1430 | 1431 | case 31: |
| 1431 | | if (!cbm_ieee_dav_r(machine)) |
| 1432 | if (!cbm_ieee_dav_r(ieeebus, 0)) |
| 1432 | 1433 | { |
| 1433 | | cbm_ieee_nrfd_w(machine, 1, 0); |
| 1434 | | data = cbm_ieee_data_r(machine) ^ 0xff; |
| 1434 | cbm_ieee_nrfd_w(ieeebus, 1, 0); |
| 1435 | data = cbm_ieee_data_r(ieeebus, 0) ^ 0xff; |
| 1435 | 1436 | logerror("byte received %.2x\n", data); |
| 1436 | 1437 | if (drive->cmdpos < sizeof (drive->cmdbuffer)) |
| 1437 | 1438 | drive->cmdbuffer[drive->cmdpos++] = data; |
| r4827 | r4828 | |
| 1440 | 1441 | drive->i.ieee.state++; |
| 1441 | 1442 | else |
| 1442 | 1443 | drive->i.ieee.state = 10; |
| 1443 | | cbm_ieee_ndac_w(machine, 1, 1); |
| 1444 | cbm_ieee_ndac_w(ieeebus, 1, 1); |
| 1444 | 1445 | } |
| 1445 | 1446 | break; |
| 1446 | 1447 | case 32: |
| 1447 | | if (cbm_ieee_dav_r(machine)) |
| 1448 | if (cbm_ieee_dav_r(ieeebus, 0)) |
| 1448 | 1449 | { |
| 1449 | | cbm_ieee_nrfd_w(machine, 1, 1); |
| 1450 | cbm_ieee_nrfd_w(ieeebus, 1, 1); |
| 1450 | 1451 | drive->i.ieee.state = 40; |
| 1451 | 1452 | } |
| 1452 | 1453 | break; |
| 1453 | 1454 | case 40: |
| 1454 | | if (!cbm_ieee_ndac_r(machine)) |
| 1455 | if (!cbm_ieee_ndac_r(ieeebus, 0)) |
| 1455 | 1456 | { |
| 1456 | | cbm_ieee_data_w(machine, 1, drive->buffer[drive->pos++] ^ 0xff); |
| 1457 | cbm_ieee_data_w(ieeebus, 1, drive->buffer[drive->pos++] ^ 0xff); |
| 1457 | 1458 | if (drive->pos >= drive->size) |
| 1458 | | cbm_ieee_eoi_w(machine, 1, 0); |
| 1459 | | cbm_ieee_dav_w(machine, 1, 0); |
| 1459 | cbm_ieee_eoi_w(ieeebus, 1, 0); |
| 1460 | cbm_ieee_dav_w(ieeebus, 1, 0); |
| 1460 | 1461 | drive->i.ieee.state++; |
| 1461 | 1462 | } |
| 1462 | 1463 | break; |
| 1463 | 1464 | case 41: |
| 1464 | | if (!cbm_ieee_nrfd_r(machine)) |
| 1465 | if (!cbm_ieee_nrfd_r(ieeebus, 0)) |
| 1465 | 1466 | { |
| 1466 | 1467 | drive->i.ieee.state++; |
| 1467 | 1468 | } |
| 1468 | 1469 | break; |
| 1469 | 1470 | case 42: |
| 1470 | | if (cbm_ieee_ndac_r(machine)) |
| 1471 | if (cbm_ieee_ndac_r(ieeebus, 0)) |
| 1471 | 1472 | { |
| 1472 | | if (cbm_ieee_eoi_r(machine)) |
| 1473 | if (cbm_ieee_eoi_r(ieeebus, 0)) |
| 1473 | 1474 | drive->i.ieee.state = 40; |
| 1474 | 1475 | |
| 1475 | 1476 | else |
| 1476 | 1477 | { |
| 1477 | | cbm_ieee_data_w(machine, 1, 0xff); |
| 1478 | | cbm_ieee_ndac_w(machine, 1, 0); |
| 1479 | | cbm_ieee_nrfd_w(machine, 1, 0); |
| 1480 | | cbm_ieee_eoi_w(machine, 1, 1); |
| 1478 | cbm_ieee_data_w(ieeebus, 1, 0xff); |
| 1479 | cbm_ieee_ndac_w(ieeebus, 1, 0); |
| 1480 | cbm_ieee_nrfd_w(ieeebus, 1, 0); |
| 1481 | cbm_ieee_eoi_w(ieeebus, 1, 1); |
| 1481 | 1482 | drive->i.ieee.state = 10; |
| 1482 | 1483 | } |
| 1483 | | cbm_ieee_dav_w(machine, 1, 1); |
| 1484 | cbm_ieee_dav_w(ieeebus, 1, 1); |
| 1484 | 1485 | } |
| 1485 | 1486 | break; |
| 1486 | 1487 | } |
src/mess/machine/cbmieeeb.c
| r4827 | r4828 | |
| 1 | | /* |
| 2 | | commodore ieee 488 (parallel) bus |
| 3 | | */ |
| 1 | /*************************************************************************** |
| 4 | 2 | |
| 3 | Commodore IEEE 488 (Parallel) Bus |
| 4 | |
| 5 | |
| 6 | |
| 7 | 2009-05 FP: Changed the implementation to be a MAME device. However, |
| 8 | the main code has been kept the same as before (to reduce the risk of |
| 9 | regressions, at this early stage). More work will be eventually done |
| 10 | to improve emulation and to allow more devices (possibly of different |
| 11 | kinds) to be connected to the bus like in the real thing. |
| 12 | Notice that write handlers which are passed to the drivers, are always |
| 13 | calling functions with the "device" parameter as 0. In turn, this calls |
| 14 | c2031_state from machine/cbmdrive.c which calls again the functions with |
| 15 | "device" parameter = 1! This forces the current code to export both the |
| 16 | DEVICE_HANDLERs and the functions called by them. |
| 17 | Eventually, proper emulation will remove the need of c2031_state (multiple |
| 18 | devices would be identified by their tags) and it will allow to only export |
| 19 | the DEVICE_HANDLERs, as it would be preferable. |
| 20 | |
| 21 | As I have written in cbmserb.c, you should not use this driver as an |
| 22 | example of the right way to implement parallel devices in MAME/MESS! |
| 23 | |
| 24 | ***************************************************************************/ |
| 25 | |
| 26 | /* Documentation: */ |
| 5 | 27 | /* |
| 6 | 28 | |
| 7 | 29 | IEEE-488 |
| r4827 | r4828 | |
| 298 | 320 | My Commodore Site: http://www.worldaccess.nl/~rbaltiss/cbm.htm |
| 299 | 321 | */ |
| 300 | 322 | |
| 323 | |
| 301 | 324 | #include "driver.h" |
| 302 | 325 | |
| 326 | #include "includes/cbmieeeb.h" |
| 327 | |
| 328 | /*************************************************************************** |
| 329 | TYPE DEFINITIONS |
| 330 | ***************************************************************************/ |
| 331 | |
| 332 | typedef struct _cbm_ieee_bus_t cbm_ieee_bus_t; |
| 333 | struct _cbm_ieee_bus_t |
| 334 | { |
| 335 | struct { |
| 336 | UINT8 data; |
| 337 | /* int fic; */ |
| 338 | int dav, nrfd, ndac, atn, eoi, ren; |
| 339 | int srq; |
| 340 | } bus[2]; |
| 341 | }; |
| 342 | |
| 343 | /*************************************************************************** |
| 344 | INLINE FUNCTIONS |
| 345 | ***************************************************************************/ |
| 346 | |
| 347 | INLINE cbm_ieee_bus_t *get_safe_token(const device_config *device) |
| 348 | { |
| 349 | assert(device != NULL); |
| 350 | assert(device->token != NULL); |
| 351 | assert(device->type == CBM_IEEEBUS); |
| 352 | return (cbm_ieee_bus_t *)device->token; |
| 353 | } |
| 354 | |
| 355 | /*************************************************************************** |
| 356 | IMPLEMENTATION |
| 357 | ***************************************************************************/ |
| 358 | |
| 359 | /* This is needed for c2031_state - It will eventually disappear */ |
| 303 | 360 | #include "includes/cbmdrive.h" |
| 304 | | #include "includes/cbmserb.h" |
| 305 | 361 | |
| 306 | | #include "includes/cbmieeeb.h" |
| 307 | 362 | |
| 308 | 363 | #define VERBOSE_LEVEL 0 |
| 309 | | #define DBG_LOG(N,M,A) \ |
| 364 | #define DBG_LOG( N, M, A ) \ |
| 310 | 365 | do { \ |
| 311 | 366 | if(VERBOSE_LEVEL >= N) \ |
| 312 | 367 | { \ |
| r4827 | r4828 | |
| 335 | 390 | srq serial request master input, other output |
| 336 | 391 | */ |
| 337 | 392 | |
| 338 | | static struct { |
| 339 | | struct { |
| 340 | | UINT8 data; |
| 341 | | /* int fic; */ |
| 342 | | int dav, nrfd, ndac, atn, eoi, ren; |
| 343 | | int srq; |
| 344 | | } bus[2]; |
| 345 | | } cbmieee= { { { 0 } } }; |
| 393 | /* TODO - These functions are used in the write handlers but also in c2031_state, hence |
| 394 | cannot be static. However, it would be better if only the WRITE8_DEVICE_HANDLER would be |
| 395 | made available to the rest of the source. */ |
| 346 | 396 | |
| 347 | | void cbm_ieee_open(void) |
| 397 | void cbm_ieee_dav_w( const device_config *ieeedev, int device, int data ) |
| 348 | 398 | { |
| 349 | | int i; |
| 350 | | for (i=0; i<2; i++) { |
| 351 | | cbmieee.bus[i].dav=1; |
| 352 | | cbmieee.bus[i].nrfd=1; |
| 353 | | cbmieee.bus[i].ndac=1; |
| 354 | | cbmieee.bus[i].atn=1; |
| 355 | | cbmieee.bus[i].eoi=1; |
| 356 | | cbmieee.bus[i].srq=1; |
| 399 | cbm_ieee_bus_t *ieeebus = get_safe_token(ieeedev); |
| 357 | 400 | |
| 358 | | cbmieee.bus[i].data=0xff; |
| 359 | | } |
| 401 | // DBG_LOG(1, "cbm ieee dav", ("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 402 | ieeebus->bus[device].dav = data; |
| 403 | if (device == 0) |
| 404 | c2031_state(ieeedev->machine, cbm_drive); |
| 360 | 405 | } |
| 361 | 406 | |
| 362 | | void cbm_ieee_dav_w(running_machine *machine, int device, int data) |
| 407 | WRITE8_DEVICE_HANDLER( cbm_ieee_dav_write ) |
| 363 | 408 | { |
| 364 | | // DBG_LOG(1,"cbm ieee dav",("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 365 | | cbmieee.bus[device].dav=data; |
| 366 | | if (device==0) c2031_state(machine, cbm_drive); |
| 409 | cbm_ieee_dav_w(device, 0, data ); |
| 367 | 410 | } |
| 368 | 411 | |
| 369 | | void cbm_ieee_nrfd_w(running_machine *machine, int device, int data) |
| 412 | void cbm_ieee_nrfd_w( const device_config *ieeedev, int device, int data ) |
| 370 | 413 | { |
| 371 | | // DBG_LOG(1,"cbm ieee nrfd",("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 372 | | cbmieee.bus[device].nrfd=data; |
| 373 | | if (device==0) c2031_state(machine, cbm_drive); |
| 414 | cbm_ieee_bus_t *ieeebus = get_safe_token(ieeedev); |
| 415 | |
| 416 | // DBG_LOG(1, "cbm ieee nrfd", ("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 417 | ieeebus->bus[device].nrfd = data; |
| 418 | if (device == 0) |
| 419 | c2031_state(ieeedev->machine, cbm_drive); |
| 374 | 420 | } |
| 375 | 421 | |
| 376 | | void cbm_ieee_ndac_w(running_machine *machine, int device, int data) |
| 422 | WRITE8_DEVICE_HANDLER( cbm_ieee_nrfd_write ) |
| 377 | 423 | { |
| 378 | | // DBG_LOG(1,"cbm ieee ndac",("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 379 | | cbmieee.bus[device].ndac=data; |
| 380 | | if (device==0) c2031_state(machine, cbm_drive); |
| 424 | cbm_ieee_nrfd_w(device, 0, data ); |
| 381 | 425 | } |
| 382 | 426 | |
| 383 | | void cbm_ieee_atn_w(running_machine *machine, int device, int data) |
| 427 | void cbm_ieee_ndac_w( const device_config *ieeedev, int device, int data ) |
| 384 | 428 | { |
| 385 | | // DBG_LOG(1,"cbm ieee atn",("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 386 | | cbmieee.bus[device].atn=data; |
| 387 | | if (device==0) c2031_state(machine, cbm_drive); |
| 429 | cbm_ieee_bus_t *ieeebus = get_safe_token(ieeedev); |
| 430 | |
| 431 | // DBG_LOG(1, "cbm ieee ndac",("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 432 | ieeebus->bus[device].ndac = data; |
| 433 | if (device == 0) |
| 434 | c2031_state(ieeedev->machine, cbm_drive); |
| 388 | 435 | } |
| 389 | 436 | |
| 390 | | void cbm_ieee_eoi_w(running_machine *machine, int device, int data) |
| 437 | WRITE8_DEVICE_HANDLER( cbm_ieee_ndac_write ) |
| 391 | 438 | { |
| 392 | | // DBG_LOG(1,"cbm ieee eoi",("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 393 | | cbmieee.bus[device].eoi=data; |
| 394 | | if (device==0) c2031_state(machine, cbm_drive); |
| 439 | cbm_ieee_ndac_w(device, 0, data ); |
| 395 | 440 | } |
| 396 | 441 | |
| 397 | | void cbm_ieee_data_w(running_machine *machine, int device, int data) |
| 442 | void cbm_ieee_atn_w( const device_config *ieeedev, int device, int data ) |
| 398 | 443 | { |
| 399 | | // DBG_LOG(1,"cbm ieee data",("%.4x dev:%d %.2x\n", activecpu_get_pc(), device, data)); |
| 400 | | cbmieee.bus[device].data=data; |
| 401 | | if (device==0) c2031_state(machine, cbm_drive); |
| 444 | cbm_ieee_bus_t *ieeebus = get_safe_token(ieeedev); |
| 445 | |
| 446 | // DBG_LOG(1, "cbm ieee atn",("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 447 | ieeebus->bus[device].atn = data; |
| 448 | if (device == 0) |
| 449 | c2031_state(ieeedev->machine, cbm_drive); |
| 402 | 450 | } |
| 403 | 451 | |
| 404 | | int cbm_ieee_srq_r(running_machine *machine) |
| 452 | WRITE8_DEVICE_HANDLER( cbm_ieee_atn_write ) |
| 405 | 453 | { |
| 406 | | int data=cbmieee.bus[1].srq; |
| 407 | | DBG_LOG(1,"cbm ieee srq",("read %d\n", data)); |
| 454 | cbm_ieee_atn_w(device, 0, data ); |
| 455 | } |
| 456 | |
| 457 | void cbm_ieee_eoi_w( const device_config *ieeedev, int device, int data ) |
| 458 | { |
| 459 | cbm_ieee_bus_t *ieeebus = get_safe_token(ieeedev); |
| 460 | |
| 461 | // DBG_LOG(1, "cbm ieee eoi", ("%.4x dev:%d %d\n", activecpu_get_pc(), device, data)); |
| 462 | ieeebus->bus[device].eoi = data; |
| 463 | if (device == 0) |
| 464 | c2031_state(ieeedev->machine, cbm_drive); |
| 465 | } |
| 466 | |
| 467 | WRITE8_DEVICE_HANDLER( cbm_ieee_eoi_write ) |
| 468 | { |
| 469 | cbm_ieee_eoi_w(device, 0, data ); |
| 470 | } |
| 471 | |
| 472 | void cbm_ieee_data_w( const device_config *ieeedev, int device, int data ) |
| 473 | { |
| 474 | cbm_ieee_bus_t *ieeebus = get_safe_token(ieeedev); |
| 475 | |
| 476 | // DBG_LOG(1, "cbm ieee data", ("%.4x dev:%d %.2x\n", activecpu_get_pc(), device, data)); |
| 477 | ieeebus->bus[device].data = data; |
| 478 | if (device == 0) |
| 479 | c2031_state(ieeedev->machine, cbm_drive); |
| 480 | } |
| 481 | |
| 482 | WRITE8_DEVICE_HANDLER( cbm_ieee_data_write ) |
| 483 | { |
| 484 | cbm_ieee_data_w(device, 0, data ); |
| 485 | } |
| 486 | |
| 487 | |
| 488 | READ8_DEVICE_HANDLER( cbm_ieee_srq_r ) |
| 489 | { |
| 490 | running_machine *machine = device->machine; |
| 491 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 492 | int data = ieeebus->bus[1].srq; |
| 493 | |
| 494 | DBG_LOG(1, "cbm ieee srq", ("read %d\n", data)); |
| 408 | 495 | return data; |
| 409 | 496 | } |
| 410 | 497 | |
| 411 | | int cbm_ieee_dav_r(running_machine *machine) |
| 498 | READ8_DEVICE_HANDLER( cbm_ieee_dav_r ) |
| 412 | 499 | { |
| 413 | | int data=cbmieee.bus[0].dav&&cbmieee.bus[1].dav; |
| 414 | | DBG_LOG(1,"cbm ieee dav",("read %d\n", data)); |
| 500 | running_machine *machine = device->machine; |
| 501 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 502 | int data = ieeebus->bus[0].dav && ieeebus->bus[1].dav; |
| 503 | |
| 504 | DBG_LOG(1, "cbm ieee dav", ("read %d\n", data)); |
| 415 | 505 | return data; |
| 416 | 506 | } |
| 417 | 507 | |
| 418 | | int cbm_ieee_nrfd_r(running_machine *machine) |
| 508 | READ8_DEVICE_HANDLER( cbm_ieee_nrfd_r ) |
| 419 | 509 | { |
| 420 | | int data=cbmieee.bus[0].nrfd && cbmieee.bus[1].nrfd; |
| 421 | | DBG_LOG(1,"cbm ieee nrfd",("read %d\n", data)); |
| 510 | running_machine *machine = device->machine; |
| 511 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 512 | int data = ieeebus->bus[0].nrfd && ieeebus->bus[1].nrfd; |
| 513 | |
| 514 | DBG_LOG(1, "cbm ieee nrfd", ("read %d\n", data)); |
| 422 | 515 | return data; |
| 423 | 516 | } |
| 424 | 517 | |
| 425 | | int cbm_ieee_ndac_r(running_machine *machine) |
| 518 | READ8_DEVICE_HANDLER( cbm_ieee_ndac_r ) |
| 426 | 519 | { |
| 427 | | int data=cbmieee.bus[0].ndac&&cbmieee.bus[1].ndac; |
| 428 | | DBG_LOG(1,"cbm ieee ndac",("read %d\n", data)); |
| 520 | running_machine *machine = device->machine; |
| 521 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 522 | int data = ieeebus->bus[0].ndac && ieeebus->bus[1].ndac; |
| 523 | |
| 524 | DBG_LOG(1,"cbm ieee ndac", ("read %d\n", data)); |
| 429 | 525 | return data; |
| 430 | 526 | } |
| 431 | 527 | |
| 432 | | int cbm_ieee_atn_r(running_machine *machine) |
| 528 | READ8_DEVICE_HANDLER( cbm_ieee_atn_r ) |
| 433 | 529 | { |
| 434 | | int data=cbmieee.bus[0].atn&&cbmieee.bus[1].atn; |
| 435 | | DBG_LOG(1,"cbm ieee atn",("read %d\n", data)); |
| 530 | running_machine *machine = device->machine; |
| 531 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 532 | int data = ieeebus->bus[0].atn && ieeebus->bus[1].atn; |
| 533 | |
| 534 | DBG_LOG(1,"cbm ieee atn", ("read %d\n", data)); |
| 436 | 535 | return data; |
| 437 | 536 | } |
| 438 | 537 | |
| 439 | | int cbm_ieee_eoi_r(running_machine *machine) |
| 538 | READ8_DEVICE_HANDLER( cbm_ieee_eoi_r ) |
| 440 | 539 | { |
| 441 | | int data=cbmieee.bus[0].eoi&&cbmieee.bus[1].eoi; |
| 442 | | /* DBG_LOG(1,"cbm ieee eoi",("read %d\n", data)); */ |
| 540 | // running_machine *machine = device->machine; |
| 541 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 542 | int data = ieeebus->bus[0].eoi && ieeebus->bus[1].eoi; |
| 543 | |
| 544 | /* DBG_LOG(1, "cbm ieee eoi", ("read %d\n", data)); */ |
| 443 | 545 | return data; |
| 444 | 546 | } |
| 445 | 547 | |
| 446 | | int cbm_ieee_data_r(running_machine *machine) |
| 548 | READ8_DEVICE_HANDLER( cbm_ieee_data_r ) |
| 447 | 549 | { |
| 448 | | int data=cbmieee.bus[0].data&cbmieee.bus[1].data; |
| 449 | | DBG_LOG(1,"cbm ieee data",("read %.2x\n", data)); |
| 550 | running_machine *machine = device->machine; |
| 551 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 552 | int data = ieeebus->bus[0].data & ieeebus->bus[1].data; |
| 553 | |
| 554 | DBG_LOG(1, "cbm ieee data", ("read %.2x\n", data)); |
| 450 | 555 | return data; |
| 451 | 556 | } |
| 452 | 557 | |
| 453 | 558 | |
| 454 | | READ8_HANDLER(cbm_ieee_state) |
| 559 | READ8_DEVICE_HANDLER( cbm_ieee_state ) |
| 455 | 560 | { |
| 456 | | switch (offset) { |
| 457 | | case 0: return cbmieee.bus[0].data; |
| 458 | | case 1: return cbmieee.bus[0].atn; |
| 459 | | case 2: return cbmieee.bus[0].dav; |
| 460 | | case 3: return cbmieee.bus[0].ndac; |
| 461 | | case 4: return cbmieee.bus[0].nrfd; |
| 462 | | case 5: return cbmieee.bus[0].eoi; |
| 463 | | case 6: return cbmieee.bus[0].ren; |
| 464 | | case 7: return cbmieee.bus[0].srq; |
| 561 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 465 | 562 | |
| 466 | | case 0x10: return cbmieee.bus[1].data; |
| 467 | | case 0x11: return cbmieee.bus[1].atn; |
| 468 | | case 0x12: return cbmieee.bus[1].dav; |
| 469 | | case 0x13: return cbmieee.bus[1].ndac; |
| 470 | | case 0x14: return cbmieee.bus[1].nrfd; |
| 471 | | case 0x15: return cbmieee.bus[1].eoi; |
| 472 | | case 0x16: return cbmieee.bus[1].ren; |
| 473 | | case 0x17: return cbmieee.bus[1].srq; |
| 563 | switch (offset) |
| 564 | { |
| 565 | case 0: return ieeebus->bus[0].data; |
| 566 | case 1: return ieeebus->bus[0].atn; |
| 567 | case 2: return ieeebus->bus[0].dav; |
| 568 | case 3: return ieeebus->bus[0].ndac; |
| 569 | case 4: return ieeebus->bus[0].nrfd; |
| 570 | case 5: return ieeebus->bus[0].eoi; |
| 571 | case 6: return ieeebus->bus[0].ren; |
| 572 | case 7: return ieeebus->bus[0].srq; |
| 573 | |
| 574 | case 0x10: return ieeebus->bus[1].data; |
| 575 | case 0x11: return ieeebus->bus[1].atn; |
| 576 | case 0x12: return ieeebus->bus[1].dav; |
| 577 | case 0x13: return ieeebus->bus[1].ndac; |
| 578 | case 0x14: return ieeebus->bus[1].nrfd; |
| 579 | case 0x15: return ieeebus->bus[1].eoi; |
| 580 | case 0x16: return ieeebus->bus[1].ren; |
| 581 | case 0x17: return ieeebus->bus[1].srq; |
| 474 | 582 | } |
| 583 | |
| 475 | 584 | return 0; |
| 476 | 585 | } |
| 586 | |
| 587 | /*------------------------------------------------- |
| 588 | DEVICE_START( cbm_ieee_bus ) |
| 589 | -------------------------------------------------*/ |
| 590 | |
| 591 | static DEVICE_START( cbm_ieee_bus ) |
| 592 | { |
| 593 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 594 | |
| 595 | memset(ieeebus, 0, sizeof(*ieeebus)); |
| 596 | |
| 597 | /* register for state saving */ |
| 598 | // We need to save here ieeebus->bus[i]! |
| 599 | } |
| 600 | |
| 601 | /*------------------------------------------------- |
| 602 | DEVICE_RESET( cbm_ieee_bus ) |
| 603 | -------------------------------------------------*/ |
| 604 | |
| 605 | static DEVICE_RESET( cbm_ieee_bus ) |
| 606 | { |
| 607 | cbm_ieee_bus_t *ieeebus = get_safe_token(device); |
| 608 | int i; |
| 609 | |
| 610 | for (i = 0; i < 2; i++) |
| 611 | { |
| 612 | ieeebus->bus[i].dav = 1; |
| 613 | ieeebus->bus[i].nrfd = 1; |
| 614 | ieeebus->bus[i].ndac = 1; |
| 615 | ieeebus->bus[i].atn = 1; |
| 616 | ieeebus->bus[i].eoi = 1; |
| 617 | ieeebus->bus[i].srq = 1; |
| 618 | |
| 619 | ieeebus->bus[i].data = 0xff; |
| 620 | } |
| 621 | } |
| 622 | |
| 623 | /*------------------------------------------------- |
| 624 | DEVICE_GET_INFO( cbm_ieee_bus ) |
| 625 | -------------------------------------------------*/ |
| 626 | |
| 627 | DEVICE_GET_INFO( cbm_ieee_bus ) |
| 628 | { |
| 629 | switch (state) |
| 630 | { |
| 631 | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 632 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(cbm_ieee_bus_t); break; |
| 633 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break; |
| 634 | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break; |
| 635 | |
| 636 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 637 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(cbm_ieee_bus); break; |
| 638 | case DEVINFO_FCT_STOP: /* Nothing */ break; |
| 639 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(cbm_ieee_bus); break; |
| 640 | |
| 641 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 642 | case DEVINFO_STR_NAME: strcpy(info->s, "Commodore IEEE Bus"); break; |
| 643 | case DEVINFO_STR_FAMILY: strcpy(info->s, "Commodore IEEE Bus"); break; |
| 644 | case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break; |
| 645 | case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; |
| 646 | case DEVINFO_STR_CREDITS: /* Nothing */ break; |
| 647 | } |
| 648 | } |