src/mess/messdriv.c
| r3964 | r3965 | |
| 196 | 196 | |
| 197 | 197 | /****************COMPUTERS***************************************************/ |
| 198 | 198 | /* ACORN */ |
| 199 | | //0128u7 DRIVER( acrnsys1 ) /* 1979 Acorn System 1 (Microcomputer Kit) */ |
| 200 | | //0128u7 DRIVER( atom ) /* 1979 Acorn Atom */ |
| 201 | | //0128u7 DRIVER( atomeb ) /* 1979 Acorn Atom */ |
| 202 | | //0128u7 DRIVER( bbca ) /* 1981 BBC Micro Model A */ |
| 203 | | //0128u7 DRIVER( bbcb ) /* 1981 BBC Micro Model B */ |
| 204 | | //0128u7 DRIVER( bbcbp ) /* 198? BBC Micro Model B+ 64K */ |
| 205 | | //0128u7 DRIVER( bbcbp128 ) /* 198? BBC Micro Model B+ 128K */ |
| 206 | | //0128u7 DRIVER( bbcm) /* 198? BBC Master */ |
| 207 | | //0128u7 DRIVER( bbcbc ) /* 1985 BBC Bridge Companion */ |
| 208 | | //0128u7 DRIVER( electron ) /* 1983 Acorn Electron */ |
| 209 | | // DRIVER( a310 ) /* 1988 Acorn Archimedes 310 */ |
| 199 | DRIVER( acrnsys1 ) /* 1979 Acorn System 1 (Microcomputer Kit) */ |
| 200 | DRIVER( atom ) /* 1979 Acorn Atom */ |
| 201 | DRIVER( atomeb ) /* 1979 Acorn Atom */ |
| 202 | DRIVER( bbca ) /* 1981 BBC Micro Model A */ |
| 203 | DRIVER( bbcb ) /* 1981 BBC Micro Model B */ |
| 204 | DRIVER( bbcbp ) /* 198? BBC Micro Model B+ 64K */ |
| 205 | DRIVER( bbcbp128 ) /* 198? BBC Micro Model B+ 128K */ |
| 206 | DRIVER( bbcm) /* 198? BBC Master */ |
| 207 | DRIVER( bbcbc ) /* 1985 BBC Bridge Companion */ |
| 208 | DRIVER( electron ) /* 1983 Acorn Electron */ |
| 209 | //128u7 DRIVER( a310 ) /* 1988 Acorn Archimedes 310 */ |
| 210 | 210 | |
| 211 | 211 | /* CAMBRIDGE COMPUTERS */ |
| 212 | | //0128u7 DRIVER( z88 ) /* */ |
| 212 | DRIVER( z88 ) /* */ |
| 213 | 213 | |
| 214 | 214 | /* AMSTRAD */ |
| 215 | 215 | DRIVER( cpc464 ) /* Amstrad (Schneider in Germany) 1984 */ |
| r3964 | r3965 | |
| 559 | 559 | DRIVER( jupiter ) /* Jupiter Ace */ |
| 560 | 560 | |
| 561 | 561 | /* SORD */ |
| 562 | | //0128u7 DRIVER( sordm5 ) |
| 563 | | //0128u7 DRIVER( srdm5fd5 ) |
| 562 | DRIVER( sordm5 ) |
| 563 | DRIVER( srdm5fd5 ) |
| 564 | 564 | |
| 565 | 565 | /* APF Electronics Inc. */ |
| 566 | 566 | DRIVER( apfm1000 ) |
| r3964 | r3965 | |
| 578 | 578 | |
| 579 | 579 | /* VEB MIKROELEKTRONIK */ |
| 580 | 580 | /* KC compact is partial CPC compatible */ |
| 581 | | //0128u7 DRIVER( kc85_4 ) /* VEB KC 85/4 */ |
| 582 | | //0128u7 DRIVER( kc85_3 ) /* VEB KC 85/3 */ |
| 583 | | //0128u7 DRIVER( kc85_4d ) /* VEB KC 85/4 with disk interface */ |
| 581 | //128u7 DRIVER( kc85_4 ) /* VEB KC 85/4 */ |
| 582 | //128u7 DRIVER( kc85_3 ) /* VEB KC 85/3 */ |
| 583 | //128u7 DRIVER( kc85_4d ) /* VEB KC 85/4 with disk interface */ |
| 584 | 584 | |
| 585 | 585 | /* MICROBEE SYSTEMS */ |
| 586 | | //0128u7 DRIVER( mbee ) /* Microbee 16 Standard or Plus */ |
| 587 | | //0128u7 DRIVER( mbeeic ) /* Microbee 32 IC */ |
| 588 | | //0128u7 DRIVER( mbeepc ) /* Microbee 32 PC */ |
| 589 | | //0128u7 DRIVER( mbeepc85 ) /* Microbee 32 PC85 */ |
| 590 | | //0128u7 DRIVER( mbee56 ) /* Microbee 56K (CP/M) */ |
| 586 | DRIVER( mbee ) /* Microbee 16 Standard or Plus */ |
| 587 | DRIVER( mbeeic ) /* Microbee 32 IC */ |
| 588 | DRIVER( mbeepc ) /* Microbee 32 PC */ |
| 589 | DRIVER( mbeepc85 ) /* Microbee 32 PC85 */ |
| 590 | DRIVER( mbee56 ) /* Microbee 56K (CP/M) */ |
| 591 | 591 | |
| 592 | 592 | /* TANDY RADIO SHACK */ |
| 593 | 593 | DRIVER( trs80 ) /* TRS-80 Model I - Level I BASIC */ |
| r3964 | r3965 | |
| 787 | 787 | |
| 788 | 788 | |
| 789 | 789 | /* NASCOM MICROCOMPUTERS */ |
| 790 | | //0128u7 DRIVER( nascom1 ) /* 1978 Nascom 1 */ |
| 791 | | //0128u7 DRIVER( nascom2 ) /* 1979 Nascom 2 */ |
| 790 | DRIVER( nascom1 ) /* 1978 Nascom 1 */ |
| 791 | DRIVER( nascom2 ) /* 1979 Nascom 2 */ |
| 792 | 792 | |
| 793 | 793 | /* MILES GORDON TECHNOLOGY */ |
| 794 | 794 | DRIVER( samcoupe ) /* 1989 Sam Coupe */ |
| r3964 | r3965 | |
| 884 | 884 | DRIVER(compis) /* 1985 Telenova Compis */ |
| 885 | 885 | |
| 886 | 886 | /* Multitech */ |
| 887 | | //0128u7 DRIVER(mpf1) /* 1979 Multitech Micro Professor 1 */ |
| 888 | | //0128u7 DRIVER(mpf1b) /* 1979 Multitech Micro Professor 1B */ |
| 887 | DRIVER(mpf1) /* 1979 Multitech Micro Professor 1 */ |
| 888 | DRIVER(mpf1b) /* 1979 Multitech Micro Professor 1B */ |
| 889 | 889 | |
| 890 | 890 | /* Telercas Oy */ |
| 891 | 891 | // DRIVER(tmc1800) |
| r3964 | r3965 | |
| 903 | 903 | DRIVER( tx0_8kw ) /* 1962 MIT TX-0 (8kw RAM) */ |
| 904 | 904 | |
| 905 | 905 | /* Luxor Datorer AB */ |
| 906 | | //0128u7 DRIVER( abc80 ) |
| 907 | | //0128u7 DRIVER( abc802 ) |
| 908 | | //0128u7 DRIVER( abc800m ) |
| 909 | | //0128u7 DRIVER( abc800c ) |
| 910 | | //0128u7 DRIVER( abc806 ) |
| 906 | DRIVER( abc80 ) |
| 907 | DRIVER( abc802 ) |
| 908 | DRIVER( abc800m ) |
| 909 | DRIVER( abc800c ) |
| 910 | DRIVER( abc806 ) |
| 911 | 911 | |
| 912 | 912 | /* Be Incorporated */ |
| 913 | 913 | DRIVER( bebox ) /* BeBox Dual603-66 */ |
| r3964 | r3965 | |
| 937 | 937 | // DRIVER( cybikoxt ) /* Cybiko Wireless Intertainment System - Xtreme */ |
| 938 | 938 | |
| 939 | 939 | /* Dick Smith */ |
| 940 | | //0128u7 DRIVER( super80 ) |
| 941 | | //0128u7 DRIVER( super80d ) |
| 942 | | //0128u7 DRIVER( super80e ) |
| 943 | | //0128u7 DRIVER( super80m ) |
| 944 | | //0128u7 DRIVER( super80r ) |
| 945 | | //0128u7 DRIVER( super80v ) |
| 940 | DRIVER( super80 ) |
| 941 | DRIVER( super80d ) |
| 942 | DRIVER( super80e ) |
| 943 | DRIVER( super80m ) |
| 944 | DRIVER( super80r ) |
| 945 | DRIVER( super80v ) |
| 946 | 946 | |
| 947 | 947 | /* Galeb */ |
| 948 | 948 | DRIVER( galeb ) |
src/mess/machine/conkort.c
| r3964 | r3965 | |
| 151 | 151 | return get_safe_token_fast(device); |
| 152 | 152 | } |
| 153 | 153 | |
| 154 | | static const device_config *get_floppy_image(int drive) |
| 154 | static const device_config *get_floppy_image(running_machine *machine, int drive) |
| 155 | 155 | { |
| 156 | 156 | return image_from_devtype_and_index(machine, IO_FLOPPY, drive); |
| 157 | 157 | } |
| 158 | 158 | |
| 159 | |
| 159 | 160 | /* Slow Controller */ |
| 160 | 161 | |
| 161 | 162 | static READ8_HANDLER( slow_bus_data_r ) |
| r3964 | r3965 | |
| 254 | 255 | // if (!BIT(data, 2)) wd17xx_set_drive(fdc,2); |
| 255 | 256 | |
| 256 | 257 | /* motor enable */ |
| 257 | | floppy_drive_set_motor_state(get_floppy_image(0), !BIT(data, 3)); |
| 258 | | floppy_drive_set_motor_state(get_floppy_image(1), !BIT(data, 3)); |
| 259 | | floppy_drive_set_ready_state(get_floppy_image(0), 1, 1); |
| 260 | | floppy_drive_set_ready_state(get_floppy_image(1), 1, 1); |
| 258 | floppy_drive_set_motor_state(get_floppy_image(space->machine, 0), !BIT(data, 3)); |
| 259 | floppy_drive_set_motor_state(get_floppy_image(space->machine, 1), !BIT(data, 3)); |
| 260 | floppy_drive_set_ready_state(get_floppy_image(space->machine, 0), 1, 1); |
| 261 | floppy_drive_set_ready_state(get_floppy_image(space->machine, 1), 1, 1); |
| 261 | 262 | |
| 262 | 263 | /* disk side selection */ |
| 263 | 264 | wd17xx_set_side(fdc,!BIT(data, 4)); |
| r3964 | r3965 | |
| 386 | 387 | conkort->status = data; |
| 387 | 388 | } |
| 388 | 389 | |
| 390 | static READ8_DEVICE_HANDLER(z80pio_alt_r) |
| 391 | { |
| 392 | int channel = BIT(offset, 1); |
| 393 | |
| 394 | return (offset & 1) ? z80pio_c_r(device, channel) : z80pio_d_r(device, channel); |
| 395 | } |
| 396 | |
| 397 | static WRITE8_DEVICE_HANDLER(z80pio_alt_w) |
| 398 | { |
| 399 | int channel = BIT(offset, 1); |
| 400 | |
| 401 | if (offset & 1) |
| 402 | z80pio_c_w(device, channel, data); |
| 403 | else |
| 404 | z80pio_d_w(device, channel, data); |
| 405 | } |
| 406 | |
| 389 | 407 | /* Memory Maps */ |
| 390 | 408 | |
| 391 | 409 | // Slow Controller |
| r3964 | r3965 | |
| 476 | 494 | |
| 477 | 495 | /* Z80 PIO */ |
| 478 | 496 | |
| 479 | | static Z80PIO_ON_INT_CHANGED( pio_interrupt ) |
| 497 | static void conkort_pio_interrupt(const device_config *device, int state) |
| 480 | 498 | { |
| 481 | 499 | slow_t *conkort = get_safe_token_machine_slow(device->machine); |
| 482 | 500 | |
| 483 | 501 | cpu_set_input_line(conkort->cpu, INPUT_LINE_IRQ0, state); |
| 484 | 502 | } |
| 485 | 503 | |
| 486 | | static READ8_DEVICE_HANDLER( pio_port_a_r ) |
| 504 | static READ8_DEVICE_HANDLER( conkort_pio_port_a_r ) |
| 487 | 505 | { |
| 488 | 506 | slow_t *conkort = get_safe_token_machine_slow(device->machine); |
| 489 | 507 | |
| 490 | 508 | return conkort->data; |
| 491 | 509 | } |
| 492 | 510 | |
| 493 | | static WRITE8_DEVICE_HANDLER( pio_port_a_w ) |
| 511 | static WRITE8_DEVICE_HANDLER( conkort_pio_port_a_w ) |
| 494 | 512 | { |
| 495 | 513 | slow_t *conkort = get_safe_token_machine_slow(device->machine); |
| 496 | 514 | |
| 497 | 515 | conkort->data = data; |
| 498 | 516 | } |
| 499 | 517 | |
| 500 | | static READ8_DEVICE_HANDLER( pio_port_b_r ) |
| 518 | static READ8_DEVICE_HANDLER( conkort_pio_port_b_r ) |
| 501 | 519 | { |
| 502 | 520 | /* |
| 503 | 521 | |
| r3964 | r3965 | |
| 519 | 537 | return conkort->fdc_irq << 7; |
| 520 | 538 | } |
| 521 | 539 | |
| 522 | | static WRITE8_DEVICE_HANDLER( pio_port_b_w ) |
| 540 | static WRITE8_DEVICE_HANDLER( conkort_pio_port_b_w ) |
| 523 | 541 | { |
| 524 | 542 | /* |
| 525 | 543 | |
| r3964 | r3965 | |
| 538 | 556 | |
| 539 | 557 | } |
| 540 | 558 | |
| 541 | | static Z80PIO_ON_ARDY_CHANGED( pio_ardy_w ) |
| 559 | static void conkort_pio_ardy_w(const device_config *device, int state) |
| 542 | 560 | { |
| 543 | 561 | slow_t *conkort = get_safe_token_machine_slow(device->machine); |
| 544 | 562 | |
| 545 | 563 | conkort->pio_ardy = state; |
| 546 | 564 | } |
| 547 | 565 | |
| 548 | | static Z80PIO_INTERFACE( pio_intf ) |
| 566 | static const z80pio_interface conkort_pio_intf = |
| 549 | 567 | { |
| 550 | | NULL, /* CPU (cannot use from within device) */ |
| 551 | | XTAL_4MHz/2, /* chip clock */ |
| 552 | | pio_interrupt, /* interrupt callback */ |
| 553 | | pio_port_a_r, /* port A read callback */ |
| 554 | | pio_port_b_r, /* port B read callback */ |
| 555 | | pio_port_a_w, /* port A write callback */ |
| 556 | | pio_port_b_w, /* port B write callback */ |
| 557 | | pio_ardy_w, /* port A ready callback */ |
| 568 | conkort_pio_interrupt, /* interrupt callback */ |
| 569 | conkort_pio_port_a_r, /* port A read callback */ |
| 570 | conkort_pio_port_b_r, /* port B read callback */ |
| 571 | conkort_pio_port_a_w, /* port A write callback */ |
| 572 | conkort_pio_port_b_w, /* port B write callback */ |
| 573 | conkort_pio_ardy_w, /* port A ready callback */ |
| 558 | 574 | NULL /* port B ready callback */ |
| 559 | 575 | }; |
| 560 | 576 | |
| r3964 | r3965 | |
| 732 | 748 | MDRV_CPU_IO_MAP(slow_io_map, 0) |
| 733 | 749 | MDRV_CPU_CONFIG(slow_daisy_chain) |
| 734 | 750 | |
| 735 | | MDRV_Z80PIO_ADD(CONKORT_Z80PIO_TAG, pio_intf) |
| 751 | MDRV_Z80PIO_ADD(CONKORT_Z80PIO_TAG, conkort_pio_intf) |
| 736 | 752 | MDRV_WD179X_ADD("wd179x", slow_wd17xx_interface ) |
| 737 | 753 | MACHINE_DRIVER_END |
| 738 | 754 | |
src/mess/machine/vtech1.c
| r3964 | r3965 | |
| 277 | 277 | return INIT_PASS; |
| 278 | 278 | } |
| 279 | 279 | |
| 280 | | static void vtech1_get_track(void) |
| 280 | static void vtech1_get_track(running_machine *machine) |
| 281 | 281 | { |
| 282 | 282 | /* drive selected or and image file ok? */ |
| 283 | | if (vtech1_drive >= 0 && image_exists(vtech1_file())) |
| 283 | if (vtech1_drive >= 0 && image_exists(vtech1_file(machine))) |
| 284 | 284 | { |
| 285 | 285 | int size, offs; |
| 286 | 286 | size = TRKSIZE_VZ; |
| 287 | 287 | offs = TRKSIZE_VZ * vtech1_track_x2[vtech1_drive]/2; |
| 288 | | image_fseek(vtech1_file(), offs, SEEK_SET); |
| 289 | | size = image_fread(vtech1_file(), vtech1_fdc_data, size); |
| 288 | image_fseek(vtech1_file(machine), offs, SEEK_SET); |
| 289 | size = image_fread(vtech1_file(machine), vtech1_fdc_data, size); |
| 290 | 290 | if (LOG_VTECH1_FDC) |
| 291 | 291 | logerror("get track @$%05x $%04x bytes\n", offs, size); |
| 292 | 292 | } |
| r3964 | r3965 | |
| 294 | 294 | vtech1_fdc_write = 0; |
| 295 | 295 | } |
| 296 | 296 | |
| 297 | | static void vtech1_put_track(void) |
| 297 | static void vtech1_put_track(running_machine *machine) |
| 298 | 298 | { |
| 299 | 299 | /* drive selected and image file ok? */ |
| 300 | | if (vtech1_drive >= 0 && vtech1_file() != NULL) |
| 300 | if (vtech1_drive >= 0 && vtech1_file(machine) != NULL) |
| 301 | 301 | { |
| 302 | 302 | int size, offs; |
| 303 | 303 | offs = TRKSIZE_VZ * vtech1_track_x2[vtech1_drive]/2; |
| 304 | | image_fseek(vtech1_file(), offs + vtech1_fdc_start, SEEK_SET); |
| 305 | | size = image_fwrite(vtech1_file(), &vtech1_fdc_data[vtech1_fdc_start], vtech1_fdc_write); |
| 304 | image_fseek(vtech1_file(machine), offs + vtech1_fdc_start, SEEK_SET); |
| 305 | size = image_fwrite(vtech1_file(machine), &vtech1_fdc_data[vtech1_fdc_start], vtech1_fdc_write); |
| 306 | 306 | if (LOG_VTECH1_FDC) |
| 307 | 307 | logerror("put track @$%05X+$%X $%04X/$%04X bytes\n", offs, vtech1_fdc_start, size, vtech1_fdc_write); |
| 308 | 308 | } |
| r3964 | r3965 | |
| 371 | 371 | { |
| 372 | 372 | vtech1_drive = drive; |
| 373 | 373 | if (vtech1_drive >= 0) |
| 374 | | vtech1_get_track(); |
| 374 | vtech1_get_track(space->machine); |
| 375 | 375 | } |
| 376 | 376 | if (vtech1_drive >= 0) |
| 377 | 377 | { |
| r3964 | r3965 | |
| 385 | 385 | if (LOG_VTECH1_FDC) |
| 386 | 386 | logerror("vtech1_fdc_w(%d) $%02X drive %d: stepout track #%2d.%d\n", offset, data, vtech1_drive, vtech1_track_x2[vtech1_drive]/2,5*(vtech1_track_x2[vtech1_drive]&1)); |
| 387 | 387 | if ((vtech1_track_x2[vtech1_drive] & 1) == 0) |
| 388 | | vtech1_get_track(); |
| 388 | vtech1_get_track(space->machine); |
| 389 | 389 | } |
| 390 | 390 | else |
| 391 | 391 | if ((PHI0(data) && !(PHI1(data) || PHI2(data) || PHI3(data)) && PHI3(vtech1_fdc_latch)) || |
| r3964 | r3965 | |
| 398 | 398 | if (LOG_VTECH1_FDC) |
| 399 | 399 | logerror("vtech1_fdc_w(%d) $%02X drive %d: stepin track #%2d.%d\n", offset, data, vtech1_drive, vtech1_track_x2[vtech1_drive]/2,5*(vtech1_track_x2[vtech1_drive]&1)); |
| 400 | 400 | if ((vtech1_track_x2[vtech1_drive] & 1) == 0) |
| 401 | | vtech1_get_track(); |
| 401 | vtech1_get_track(space->machine); |
| 402 | 402 | } |
| 403 | 403 | if ((data & 0x40) == 0) |
| 404 | 404 | { |
| r3964 | r3965 | |
| 441 | 441 | { |
| 442 | 442 | /* data written to track before? */ |
| 443 | 443 | if (vtech1_fdc_write) |
| 444 | | vtech1_put_track(); |
| 444 | vtech1_put_track(space->machine); |
| 445 | 445 | } |
| 446 | 446 | vtech1_fdc_bits = 8; |
| 447 | 447 | vtech1_fdc_write = 0; |
src/mess/machine/vtech2.c
| r3964 | r3965 | |
| 372 | 372 | return INIT_PASS; |
| 373 | 373 | } |
| 374 | 374 | |
| 375 | | static const device_config *laser_file(void) |
| 375 | static const device_config *laser_file(running_machine *machine) |
| 376 | 376 | { |
| 377 | 377 | return image_from_devtype_and_index(machine, IO_FLOPPY, laser_drive); |
| 378 | 378 | } |
| 379 | 379 | |
| 380 | | static void laser_get_track(void) |
| 380 | static void laser_get_track(running_machine *machine) |
| 381 | 381 | { |
| 382 | 382 | sprintf(laser_frame_message, "#%d get track %02d", laser_drive, laser_track_x2[laser_drive]/2); |
| 383 | 383 | laser_frame_time = 30; |
| r3964 | r3965 | |
| 387 | 387 | int size, offs; |
| 388 | 388 | size = TRKSIZE_VZ; |
| 389 | 389 | offs = TRKSIZE_VZ * laser_track_x2[laser_drive]/2; |
| 390 | | image_fseek(laser_file(), offs, SEEK_SET); |
| 391 | | size = image_fread(laser_file(), laser_fdc_data, size); |
| 390 | image_fseek(laser_file(machine), offs, SEEK_SET); |
| 391 | size = image_fread(laser_file(machine), laser_fdc_data, size); |
| 392 | 392 | logerror("get track @$%05x $%04x bytes\n", offs, size); |
| 393 | 393 | } |
| 394 | 394 | laser_fdc_offs = 0; |
| 395 | 395 | laser_fdc_write = 0; |
| 396 | 396 | } |
| 397 | 397 | |
| 398 | | static void laser_put_track(void) |
| 398 | static void laser_put_track(running_machine *machine) |
| 399 | 399 | { |
| 400 | 400 | /* drive selected and image file ok? */ |
| 401 | | if( laser_drive >= 0 && laser_file() != NULL ) |
| 401 | if( laser_drive >= 0 && laser_file(machine) != NULL ) |
| 402 | 402 | { |
| 403 | 403 | int size, offs; |
| 404 | 404 | offs = TRKSIZE_VZ * laser_track_x2[laser_drive]/2; |
| 405 | | image_fseek(laser_file(), offs + laser_fdc_start, SEEK_SET); |
| 406 | | size = image_fwrite(laser_file(), &laser_fdc_data[laser_fdc_start], laser_fdc_write); |
| 405 | image_fseek(laser_file(machine), offs + laser_fdc_start, SEEK_SET); |
| 406 | size = image_fwrite(laser_file(machine), &laser_fdc_data[laser_fdc_start], laser_fdc_write); |
| 407 | 407 | logerror("put track @$%05X+$%X $%04X/$%04X bytes\n", offs, laser_fdc_start, size, laser_fdc_write); |
| 408 | 408 | } |
| 409 | 409 | } |
| r3964 | r3965 | |
| 469 | 469 | { |
| 470 | 470 | laser_drive = drive; |
| 471 | 471 | if( laser_drive >= 0 ) |
| 472 | | laser_get_track(); |
| 472 | laser_get_track(space->machine); |
| 473 | 473 | } |
| 474 | 474 | if( laser_drive >= 0 ) |
| 475 | 475 | { |
| r3964 | r3965 | |
| 482 | 482 | laser_track_x2[laser_drive]--; |
| 483 | 483 | logerror("laser_fdc_w(%d) $%02X drive %d: stepout track #%2d.%d\n", offset, data, laser_drive, laser_track_x2[laser_drive]/2,5*(laser_track_x2[laser_drive]&1)); |
| 484 | 484 | if( (laser_track_x2[laser_drive] & 1) == 0 ) |
| 485 | | laser_get_track(); |
| 485 | laser_get_track(space->machine); |
| 486 | 486 | } |
| 487 | 487 | else |
| 488 | 488 | if( (PHI0(data) && !(PHI1(data) || PHI2(data) || PHI3(data)) && PHI3(laser_fdc_latch)) || |
| r3964 | r3965 | |
| 494 | 494 | laser_track_x2[laser_drive]++; |
| 495 | 495 | logerror("laser_fdc_w(%d) $%02X drive %d: stepin track #%2d.%d\n", offset, data, laser_drive, laser_track_x2[laser_drive]/2,5*(laser_track_x2[laser_drive]&1)); |
| 496 | 496 | if( (laser_track_x2[laser_drive] & 1) == 0 ) |
| 497 | | laser_get_track(); |
| 497 | laser_get_track(space->machine); |
| 498 | 498 | } |
| 499 | 499 | if( (data & 0x40) == 0 ) |
| 500 | 500 | { |
| r3964 | r3965 | |
| 538 | 538 | { |
| 539 | 539 | /* data written to track before? */ |
| 540 | 540 | if( laser_fdc_write ) |
| 541 | | laser_put_track(); |
| 541 | laser_put_track(space->machine); |
| 542 | 542 | } |
| 543 | 543 | laser_fdc_bits = 8; |
| 544 | 544 | laser_fdc_write = 0; |
src/mess/machine/kc.c
| r3964 | r3965 | |
| 1734 | 1734 | z80ctc_w(device, offset,data); |
| 1735 | 1735 | } |
| 1736 | 1736 | |
| 1737 | | static Z80PIO_ON_INT_CHANGED( kc85_pio_interrupt ) |
| 1737 | static void kc85_pio_interrupt(const device_config *device, int state) |
| 1738 | 1738 | { |
| 1739 | 1739 | cpu_set_input_line(device->machine->cpu[0], 0, state); |
| 1740 | 1740 | } |
| r3964 | r3965 | |
| 1746 | 1746 | |
| 1747 | 1747 | /* callback for ardy output from PIO */ |
| 1748 | 1748 | /* used in KC85/4 & KC85/3 cassette interface */ |
| 1749 | | static Z80PIO_ON_ARDY_CHANGED( kc85_pio_ardy_callback ) |
| 1749 | static void kc85_pio_ardy_callback(const device_config *device, int state) |
| 1750 | 1750 | { |
| 1751 | 1751 | kc_ardy = state & 0x01; |
| 1752 | 1752 | |
| r3964 | r3965 | |
| 1758 | 1758 | |
| 1759 | 1759 | /* callback for brdy output from PIO */ |
| 1760 | 1760 | /* used in KC85/4 & KC85/3 keyboard interface */ |
| 1761 | | static Z80PIO_ON_BRDY_CHANGED( kc85_pio_brdy_callback ) |
| 1761 | static void kc85_pio_brdy_callback(const device_config *device, int state) |
| 1762 | 1762 | { |
| 1763 | 1763 | kc_brdy = state & 0x01; |
| 1764 | 1764 | |
| r3964 | r3965 | |
| 1768 | 1768 | } |
| 1769 | 1769 | } |
| 1770 | 1770 | |
| 1771 | | Z80PIO_INTERFACE( kc85_pio_intf ) |
| 1771 | const z80pio_interface kc85_pio_intf = |
| 1772 | 1772 | { |
| 1773 | | "main", |
| 1774 | | 0, |
| 1775 | 1773 | kc85_pio_interrupt, /* callback when change interrupt status */ |
| 1776 | 1774 | NULL, |
| 1777 | 1775 | NULL, |
src/mess/drivers/sord.c
| r3964 | r3965 | |
| 123 | 123 | |
| 124 | 124 | LOG(("fd5 drive state w: %02x\n",state)); |
| 125 | 125 | |
| 126 | | floppy_drive_set_motor_state(image_from_devtype_and_index(machine, IO_FLOPPY, 0), state); |
| 127 | | floppy_drive_set_motor_state(image_from_devtype_and_index(machine, IO_FLOPPY, 0), state); |
| 128 | | floppy_drive_set_ready_state(image_from_devtype_and_index(machine, IO_FLOPPY, 1), 1,1); |
| 129 | | floppy_drive_set_ready_state(image_from_devtype_and_index(machine, IO_FLOPPY, 1), 1,1); |
| 126 | floppy_drive_set_motor_state(image_from_devtype_and_index(space->machine, IO_FLOPPY, 0), state); |
| 127 | floppy_drive_set_motor_state(image_from_devtype_and_index(space->machine, IO_FLOPPY, 0), state); |
| 128 | floppy_drive_set_ready_state(image_from_devtype_and_index(space->machine, IO_FLOPPY, 1), 1,1); |
| 129 | floppy_drive_set_ready_state(image_from_devtype_and_index(space->machine, IO_FLOPPY, 1), 1,1); |
| 130 | 130 | } |
| 131 | 131 | |
| 132 | 132 | static WRITE8_HANDLER(fd5_tc_w) |
| r3964 | r3965 | |
| 692 | 692 | ROM_END |
| 693 | 693 | |
| 694 | 694 | static FLOPPY_OPTIONS_START( sordm5 ) |
| 695 | | FLOPPY_OPTION( sordm5, "dsk", "Sord M5 disk image", basicdsk_identify_default, basicdsk_construct_default, |
| 695 | FLOPPY_OPTION( sordm5, "dsk", "Sord M5 disk image", basicdsk_identify_default, basicdsk_construct_default, |
| 696 | 696 | HEADS([1]) |
| 697 | 697 | TRACKS([40]) |
| 698 | 698 | SECTORS([18]) |
| r3964 | r3965 | |
| 727 | 727 | SYSTEM_CONFIG_END |
| 728 | 728 | |
| 729 | 729 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME */ |
| 730 | | COMP( 1983, sordm5, 0, 0, sord_m5, sord_m5, 0, sordm5, "Sord", "Sord M5", 0) |
| 731 | | COMP(1983, srdm5fd5, sordm5, 0, sord_m5_fd5, sord_m5, 0, srdm5fd5, "Sord", "Sord M5 + PI5 + FD5", 0 ) |
| 730 | COMP(1983, sordm5, 0, 0, sord_m5, sord_m5, 0, sordm5, "Sord", "Sord M5", 0) |
| 731 | COMP(1983, srdm5fd5, sordm5, 0, sord_m5_fd5, sord_m5, 0, srdm5fd5, "Sord", "Sord M5 + PI5 + FD5", 0 ) |
src/mess/drivers/mbee.c
| r3964 | r3965 | |
| 62 | 62 | return device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette" ); |
| 63 | 63 | } |
| 64 | 64 | |
| 65 | static READ8_DEVICE_HANDLER(z80pio_alt_r) |
| 66 | { |
| 67 | int channel = BIT(offset, 1); |
| 68 | |
| 69 | return (offset & 1) ? z80pio_c_r(device, channel) : z80pio_d_r(device, channel); |
| 70 | } |
| 71 | |
| 72 | static WRITE8_DEVICE_HANDLER(z80pio_alt_w) |
| 73 | { |
| 74 | int channel = BIT(offset, 1); |
| 75 | |
| 76 | if (offset & 1) |
| 77 | z80pio_c_w(device, channel, data); |
| 78 | else |
| 79 | z80pio_d_w(device, channel, data); |
| 80 | } |
| 81 | |
| 65 | 82 | static QUICKLOAD_LOAD( mbee ); |
| 66 | 83 | static Z80BIN_EXECUTE( mbee ); |
| 67 | 84 | |
| r3964 | r3965 | |
| 288 | 305 | |
| 289 | 306 | static int mbee_vsync; |
| 290 | 307 | |
| 291 | | static Z80PIO_ON_INT_CHANGED( pio_interrupt ) |
| 308 | static void mbee_pio_interrupt(const device_config *device, int state) |
| 292 | 309 | { |
| 293 | 310 | cpu_set_input_line(device->machine->cpu[0], 0, state); |
| 294 | 311 | } |
| r3964 | r3965 | |
| 338 | 355 | |
| 339 | 356 | static const z80pio_interface mbee_z80pio_intf = |
| 340 | 357 | { |
| 341 | | "main", |
| 342 | | 0, |
| 343 | | pio_interrupt, /* callback when change interrupt status */ |
| 358 | mbee_pio_interrupt, /* callback when change interrupt status */ |
| 344 | 359 | NULL, |
| 345 | 360 | pio_port_b_r, |
| 346 | 361 | NULL, |
| r3964 | r3965 | |
| 357 | 372 | |
| 358 | 373 | static INTERRUPT_GEN( mbee_interrupt ) |
| 359 | 374 | { |
| 360 | | /* once per frame, pulse the PIO B bit 7 */ |
| 375 | /* once per frame, pulse the PIO B bit 7 - only needed for networked bees */ |
| 361 | 376 | mbee_vsync = 1; |
| 362 | 377 | } |
| 363 | 378 | |
src/mess/drivers/super80.c
| r3964 | r3965 | |
| 347 | 347 | |
| 348 | 348 | static UINT8 keylatch; |
| 349 | 349 | |
| 350 | | static Z80PIO_ON_INT_CHANGED( pio_interrupt ) |
| 350 | static void super80_pio_interrupt(const device_config *device, int state) |
| 351 | 351 | { |
| 352 | | cpu_set_input_line( device->machine->cpu[0], 0, state ? ASSERT_LINE : CLEAR_LINE ); |
| 352 | //128u7 cputag_set_input_line(device->machine, "main", 0, state ); |
| 353 | 353 | } |
| 354 | 354 | |
| 355 | 355 | static WRITE8_DEVICE_HANDLER( pio_port_a_w ) |
| r3964 | r3965 | |
| 372 | 372 | return data; |
| 373 | 373 | }; |
| 374 | 374 | |
| 375 | | static Z80PIO_INTERFACE( pio_intf ) |
| 375 | static const z80pio_interface super80_pio_intf = |
| 376 | 376 | { |
| 377 | | "main", |
| 378 | | 0, |
| 379 | | pio_interrupt, /* callback when change interrupt status */ |
| 377 | super80_pio_interrupt, /* callback when change interrupt status */ |
| 380 | 378 | NULL, |
| 381 | 379 | pio_port_b_r, |
| 382 | 380 | pio_port_a_w, |
| r3964 | r3965 | |
| 1024 | 1022 | |
| 1025 | 1023 | MDRV_MACHINE_RESET( super80 ) |
| 1026 | 1024 | |
| 1027 | | MDRV_Z80PIO_ADD( "z80pio", pio_intf ) |
| 1025 | MDRV_Z80PIO_ADD( "z80pio", super80_pio_intf ) |
| 1028 | 1026 | |
| 1029 | 1027 | MDRV_GFXDECODE(super80) |
| 1030 | 1028 | MDRV_SCREEN_ADD("main", RASTER) |
| r3964 | r3965 | |
| 1078 | 1076 | |
| 1079 | 1077 | MDRV_MACHINE_RESET( super80 ) |
| 1080 | 1078 | |
| 1081 | | MDRV_Z80PIO_ADD( "z80pio", pio_intf ) |
| 1079 | MDRV_Z80PIO_ADD( "z80pio", super80_pio_intf ) |
| 1082 | 1080 | |
| 1083 | 1081 | MDRV_GFXDECODE(super80v) |
| 1084 | 1082 | MDRV_SCREEN_ADD("main", RASTER) |
src/mess/drivers/einstein.c
| r3964 | r3965 | |
| 411 | 411 | cpu_set_input_line(device->machine->cpu[0], 1, state); |
| 412 | 412 | } |
| 413 | 413 | |
| 414 | | static Z80PIO_ON_INT_CHANGED( einstein_pio_interrupt ) |
| 414 | static void einstein_pio_interrupt(const device_config *device, int state) |
| 415 | 415 | { |
| 416 | 416 | logerror("pio irq state: %02x\n",state); |
| 417 | 417 | cpu_set_input_line(device->machine->cpu[0], 3, state); |
| r3964 | r3965 | |
| 431 | 431 | |
| 432 | 432 | static const z80ctc_interface einstein_ctc_intf = |
| 433 | 433 | { |
| 434 | | "main", |
| 435 | | EINSTEIN_SYSTEM_CLOCK, |
| 436 | 434 | 0, |
| 437 | 435 | einstein_ctc_interrupt, |
| 438 | 436 | einstein_serial_transmit_clock, |
| r3964 | r3965 | |
| 440 | 438 | z80ctc_trg3_w |
| 441 | 439 | }; |
| 442 | 440 | |
| 443 | | static Z80PIO_ON_ARDY_CHANGED( einstein_pio_ardy ) |
| 441 | static void einstein_pio_ardy(const device_config *device, int state) |
| 444 | 442 | { |
| 445 | 443 | int handshake; |
| 446 | 444 | |
| r3964 | r3965 | |
| 461 | 459 | } |
| 462 | 460 | |
| 463 | 461 | |
| 464 | | static Z80PIO_INTERFACE( einstein_pio_intf ) |
| 462 | static const z80pio_interface einstein_pio_intf = |
| 465 | 463 | { |
| 466 | | "main", |
| 467 | | 0, |
| 468 | 464 | einstein_pio_interrupt, |
| 469 | 465 | NULL, |
| 470 | 466 | NULL, |
| r3964 | r3965 | |
| 1727 | 1723 | MDRV_MACHINE_RESET( einstein ) |
| 1728 | 1724 | |
| 1729 | 1725 | MDRV_Z80PIO_ADD( "z80pio", einstein_pio_intf ) |
| 1730 | | MDRV_Z80CTC_ADD( "z80ctc", einstein_ctc_intf ) |
| 1726 | MDRV_Z80CTC_ADD( "z80ctc", EINSTEIN_SYSTEM_CLOCK, einstein_ctc_intf ) |
| 1731 | 1727 | MDRV_DEVICE_ADD( "keyboard_daisy", DEVICE_GET_INFO_NAME( einstein_daisy ) ) |
| 1732 | 1728 | MDRV_DEVICE_ADD( "adc_daisy", DEVICE_GET_INFO_NAME( einstein_daisy ) ) |
| 1733 | 1729 | |
src/mess/drivers/bbcbc.c
| r3964 | r3965 | |
| 13 | 13 | #include "cpu/z80/z80.h" |
| 14 | 14 | #include "video/tms9928a.h" |
| 15 | 15 | #include "machine/z80pio.h" |
| 16 | #include "cpu/z80/z80daisy.h" |
| 16 | 17 | #include "devices/cartslot.h" |
| 17 | 18 | |
| 18 | 19 | static ADDRESS_MAP_START( bbcbc_prg, ADDRESS_SPACE_PROGRAM, 8 ) |
| r3964 | r3965 | |
| 35 | 36 | |
| 36 | 37 | static INTERRUPT_GEN( bbcbc_interrupt ) |
| 37 | 38 | { |
| 38 | | TMS9928A_interrupt(device->machine); |
| 39 | TMS9928A_interrupt(device->machine); |
| 39 | 40 | } |
| 40 | 41 | |
| 41 | 42 | static const TMS9928a_interface tms9129_interface = |
| r3964 | r3965 | |
| 58 | 59 | NULL /* ready b */ |
| 59 | 60 | }; |
| 60 | 61 | |
| 62 | static const z80_daisy_chain bbcbc_daisy_chain[] = |
| 63 | { |
| 64 | { Z80PIO, "z80pio" }, |
| 65 | { NULL } |
| 66 | }; |
| 67 | |
| 61 | 68 | static MACHINE_START( bbcbc ) |
| 62 | 69 | { |
| 63 | 70 | TMS9928A_configure(&tms9129_interface); |
| r3964 | r3965 | |
| 72 | 79 | MDRV_CPU_ADD( "main", Z80, 4000000 ) |
| 73 | 80 | MDRV_CPU_PROGRAM_MAP( bbcbc_prg, 0 ) |
| 74 | 81 | MDRV_CPU_IO_MAP( bbcbc_io, 0 ) |
| 82 | MDRV_CPU_CONFIG(bbcbc_daisy_chain) |
| 83 | MDRV_CPU_VBLANK_INT("main", bbcbc_interrupt) |
| 75 | 84 | |
| 76 | 85 | MDRV_MACHINE_START( bbcbc ) |
| 77 | 86 | MDRV_MACHINE_RESET( bbcbc ) |
| 78 | 87 | |
| 79 | 88 | MDRV_Z80PIO_ADD( "z80pio", bbcbc_z80pio_intf ) |
| 80 | 89 | |
| 81 | | MDRV_CPU_VBLANK_INT("main", bbcbc_interrupt) |
| 82 | 90 | MDRV_IMPORT_FROM( tms9928a ) |
| 83 | 91 | MDRV_SCREEN_MODIFY("main") |
| 84 | 92 | MDRV_SCREEN_REFRESH_RATE( 50 ) |
| r3964 | r3965 | |
| 93 | 101 | ROM_END |
| 94 | 102 | |
| 95 | 103 | static SYSTEM_CONFIG_START( bbcbc ) |
| 96 | | CONFIG_DEVICE(cartslot_device_getinfo) |
| 104 | CONFIG_DEVICE(cartslot_device_getinfo) |
| 97 | 105 | SYSTEM_CONFIG_END |
| 98 | 106 | |
| 99 | 107 | /*************************************************************************** |