src/mess/drivers/abc80x.c
| r3475 | r3476 | |
| 55 | 55 | |
| 56 | 56 | TODO: |
| 57 | 57 | |
| 58 | | - rewrite Z80DART for bit level serial I/O |
| 59 | | - connect ABC77 keyboard to DART |
| 60 | | - COM port DIP switch |
| 58 | - CTC interrupt breaks ABC802/806 |
| 59 | - bit level accurate Z80 DART (keyboard) |
| 60 | - bit level accurate Z80 SIO/2 (cassette) |
| 61 | 61 | - floppy controller board |
| 62 | 62 | - Facit DTC (recased ABC-800?) |
| 63 | 63 | - hard disks (ABC-850 10MB, ABC-852 20MB, ABC-856 60MB) |
| r3475 | r3476 | |
| 86 | 86 | #include "devices/cassette.h" |
| 87 | 87 | #include "devices/printer.h" |
| 88 | 88 | |
| 89 | static const device_config *cassette_device_image(running_machine *machine) |
| 90 | { |
| 91 | return device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette" ); |
| 92 | } |
| 93 | |
| 89 | 94 | /* Keyboard HACK */ |
| 90 | 95 | |
| 91 | 96 | static int keylatch; |
| r3475 | r3476 | |
| 129 | 134 | { 0x5f, 0x09, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00 } |
| 130 | 135 | }; |
| 131 | 136 | |
| 132 | | static void abc800_keyboard_scan(running_machine *machine) |
| 137 | static void scan_keyboard(running_machine *machine) |
| 133 | 138 | { |
| 134 | 139 | UINT8 keycode = 0; |
| 135 | 140 | UINT8 data; |
| r3475 | r3476 | |
| 168 | 173 | { |
| 169 | 174 | if (!keylatch) |
| 170 | 175 | { |
| 171 | | abc800_state *state = machine->driver_data; |
| 176 | const device_config *z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 172 | 177 | |
| 173 | | z80dart_set_dcd(state->z80dart, 1, 1); |
| 174 | | z80dart_receive_data(state->z80dart, 1, keycode); |
| 178 | z80dart_set_dcd(z80dart, 1, 1); |
| 179 | z80dart_receive_data(z80dart, 1, keycode); |
| 180 | |
| 175 | 181 | keylatch = keycode; |
| 176 | 182 | } |
| 177 | 183 | } |
| r3475 | r3476 | |
| 179 | 185 | { |
| 180 | 186 | if (keylatch) |
| 181 | 187 | { |
| 182 | | abc800_state *state = machine->driver_data; |
| 188 | const device_config *z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 183 | 189 | |
| 184 | | z80dart_set_dcd(state->z80dart, 1, 0); |
| 185 | | z80dart_receive_data(state->z80dart, 1, 0); |
| 190 | z80dart_set_dcd(z80dart, 1, 0); |
| 191 | z80dart_receive_data(z80dart, 1, 0); |
| 192 | |
| 186 | 193 | keylatch = 0; |
| 187 | 194 | } |
| 188 | 195 | } |
| 189 | 196 | } |
| 190 | 197 | |
| 191 | | static TIMER_DEVICE_CALLBACK( abc800_keyboard_tick ) |
| 198 | static TIMER_DEVICE_CALLBACK( keyboard_tick ) |
| 192 | 199 | { |
| 193 | | abc800_keyboard_scan(timer->machine); |
| 200 | scan_keyboard(timer->machine); |
| 194 | 201 | } |
| 195 | 202 | |
| 196 | 203 | /* Read/Write Handlers */ |
| r3475 | r3476 | |
| 508 | 515 | static ADDRESS_MAP_START( abc802_io_map, ADDRESS_SPACE_IO, 8 ) |
| 509 | 516 | ADDRESS_MAP_UNMAP_HIGH |
| 510 | 517 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 511 | | AM_RANGE(0x00, 0x00) AM_READWRITE(abcbus_data_r, abcbus_data_w) |
| 512 | | AM_RANGE(0x01, 0x01) AM_READWRITE(abcbus_status_r, abcbus_channel_w) |
| 513 | | AM_RANGE(0x02, 0x05) AM_WRITE(abcbus_command_w) |
| 514 | | AM_RANGE(0x07, 0x07) AM_READ(abcbus_reset_r) |
| 515 | | AM_RANGE(0x20, 0x23) AM_DEVREADWRITE(Z80DART, Z80DART_TAG, dart_r, dart_w) |
| 516 | | AM_RANGE(0x31, 0x31) AM_DEVREAD(MC6845, MC6845_TAG, mc6845_register_r) |
| 517 | | AM_RANGE(0x32, 0x35) AM_DEVREADWRITE(Z80SIO, Z80SIO_TAG, sio2_r, sio2_w) |
| 518 | | AM_RANGE(0x38, 0x38) AM_DEVWRITE(MC6845, MC6845_TAG, mc6845_address_w) |
| 519 | | AM_RANGE(0x39, 0x39) AM_DEVWRITE(MC6845, MC6845_TAG, mc6845_register_w) |
| 520 | | AM_RANGE(0x60, 0x63) AM_DEVREADWRITE(Z80CTC, Z80CTC_TAG, z80ctc_r, z80ctc_w) |
| 521 | | AM_RANGE(0x80, 0xff) AM_READWRITE(abcbus_strobe_r, abcbus_strobe_w) |
| 518 | AM_RANGE(0x00, 0x00) AM_MIRROR(0x08) AM_READWRITE(abcbus_data_r, abcbus_data_w) |
| 519 | AM_RANGE(0x01, 0x01) AM_MIRROR(0x08) AM_READWRITE(abcbus_status_r, abcbus_channel_w) |
| 520 | AM_RANGE(0x02, 0x05) AM_MIRROR(0x08) AM_WRITE(abcbus_command_w) |
| 521 | // AM_RANGE(0x05, 0x05) AM_MIRROR(0x08) AM_READ(pling_r) |
| 522 | AM_RANGE(0x07, 0x07) AM_MIRROR(0x08) AM_READ(abcbus_reset_r) |
| 523 | AM_RANGE(0x20, 0x23) AM_MIRROR(0x0c) AM_DEVREADWRITE(Z80DART, Z80DART_TAG, dart_r, dart_w) |
| 524 | AM_RANGE(0x31, 0x31) AM_MIRROR(0x06) AM_DEVREAD(MC6845, MC6845_TAG, mc6845_register_r) |
| 525 | AM_RANGE(0x38, 0x38) AM_MIRROR(0x06) AM_DEVWRITE(MC6845, MC6845_TAG, mc6845_address_w) |
| 526 | AM_RANGE(0x39, 0x39) AM_MIRROR(0x06) AM_DEVWRITE(MC6845, MC6845_TAG, mc6845_register_w) |
| 527 | AM_RANGE(0x40, 0x43) AM_MIRROR(0x1c) AM_DEVREADWRITE(Z80SIO, Z80SIO_TAG, sio2_r, sio2_w) |
| 528 | AM_RANGE(0x60, 0x63) AM_MIRROR(0x1c) AM_DEVREADWRITE(Z80CTC, Z80CTC_TAG, z80ctc_r, z80ctc_w) |
| 529 | AM_RANGE(0x80, 0x80) AM_MIRROR(0x7f) AM_READWRITE(abcbus_strobe_r, abcbus_strobe_w) |
| 522 | 530 | ADDRESS_MAP_END |
| 523 | 531 | |
| 524 | 532 | // ABC 806 |
| r3475 | r3476 | |
| 559 | 567 | AM_RANGE(0x37, 0x37) AM_MIRROR(0xff00) AM_MASK(0xff00) AM_READWRITE(abc806_cli_r, abc806_sso_w) |
| 560 | 568 | AM_RANGE(0x38, 0x38) AM_MIRROR(0xff06) AM_DEVWRITE(MC6845, MC6845_TAG, mc6845_address_w) |
| 561 | 569 | AM_RANGE(0x39, 0x39) AM_MIRROR(0xff06) AM_DEVWRITE(MC6845, MC6845_TAG, mc6845_register_w) |
| 562 | | AM_RANGE(0x40, 0x41) AM_MIRROR(0xff1c) AM_DEVREADWRITE(Z80SIO, Z80SIO_TAG, sio2_r, sio2_w) |
| 570 | AM_RANGE(0x40, 0x43) AM_MIRROR(0xff1c) AM_DEVREADWRITE(Z80SIO, Z80SIO_TAG, sio2_r, sio2_w) |
| 563 | 571 | AM_RANGE(0x60, 0x63) AM_MIRROR(0xff1c) AM_DEVREADWRITE(Z80CTC, "z80ctc", z80ctc_r, z80ctc_w) |
| 564 | 572 | AM_RANGE(0x80, 0x80) AM_MIRROR(0xff7f) AM_READWRITE(abcbus_strobe_r, abcbus_strobe_w) |
| 565 | 573 | ADDRESS_MAP_END |
| r3475 | r3476 | |
| 687 | 695 | PORT_DIPSETTING( 0x2c, "ABC 832/834/850" ) |
| 688 | 696 | PORT_DIPSETTING( 0x2d, "ABC 830" ) |
| 689 | 697 | PORT_DIPSETTING( 0x2e, "ABC 838" ) |
| 698 | |
| 699 | PORT_START("SB") |
| 700 | PORT_DIPNAME( 0xff, 0xaa, "Serial Communications" ) PORT_DIPLOCATION("SB:1,2,3,4,5,6,7,8") |
| 701 | PORT_DIPSETTING( 0xaa, "Asynchronous, Single Speed" ) |
| 702 | PORT_DIPSETTING( 0x2e, "Asynchronous, Split Speed" ) |
| 703 | PORT_DIPSETTING( 0x50, "Synchronous" ) |
| 704 | PORT_DIPSETTING( 0x8b, "ABC NET" ) |
| 690 | 705 | INPUT_PORTS_END |
| 691 | 706 | |
| 692 | 707 | static INPUT_PORTS_START( abc802 ) |
| 693 | | PORT_INCLUDE(abc77) |
| 708 | PORT_INCLUDE(abc800) |
| 694 | 709 | INPUT_PORTS_END |
| 695 | 710 | |
| 696 | 711 | static INPUT_PORTS_START( abc806 ) |
| 697 | | PORT_INCLUDE(abc77) |
| 712 | PORT_INCLUDE(abc800) |
| 698 | 713 | INPUT_PORTS_END |
| 699 | 714 | |
| 700 | | /* Machine Initialization */ |
| 715 | /* ABC 77 */ |
| 701 | 716 | |
| 702 | 717 | static ABC77_ON_TXD_CHANGED( abc800_abc77_txd_changed ) |
| 703 | 718 | { |
| r3475 | r3476 | |
| 706 | 721 | state->abc77_txd = level; |
| 707 | 722 | } |
| 708 | 723 | |
| 709 | | static ABC77_ON_CLOCK_CHANGED( abc800_abc77_clock_changed ) |
| 724 | static ABC77_ON_CLOCK_CHANGED( abc77_clock_changed ) |
| 710 | 725 | { |
| 711 | | // abc800_state *state = device->machine->driver_data; |
| 726 | // const device_config *z80dart = devtag_get_device(device->machine, Z80DART, Z80DART_TAG); |
| 712 | 727 | |
| 713 | | /* clock into DART RxTxCB (Receiver/Transmitter Clock B) */ |
| 728 | /* connected to DART channel B RxTxCB (pin ) */ |
| 729 | //z80dart_rxtxc_w(z80dart, 1, level); |
| 714 | 730 | } |
| 715 | 731 | |
| 716 | | static ABC77_ON_KEYDOWN_CHANGED( abc800_abc77_keydown_changed ) |
| 732 | static ABC77_ON_KEYDOWN_CHANGED( abc77_keydown_changed ) |
| 717 | 733 | { |
| 718 | | abc800_state *state = device->machine->driver_data; |
| 734 | const device_config *z80dart = devtag_get_device(device->machine, Z80DART, Z80DART_TAG); |
| 719 | 735 | |
| 720 | | z80dart_set_dcd(state->z80dart, 1, level); |
| 736 | /* connected to DART channel B DCD (pin ) */ |
| 737 | z80dart_set_dcd(z80dart, 1, level); |
| 721 | 738 | } |
| 722 | 739 | |
| 723 | 740 | static ABC77_INTERFACE( abc800_abc77_intf ) |
| 724 | 741 | { |
| 725 | 742 | abc800_abc77_txd_changed, |
| 726 | | abc800_abc77_clock_changed, |
| 727 | | abc800_abc77_keydown_changed |
| 743 | abc77_clock_changed, |
| 744 | abc77_keydown_changed |
| 728 | 745 | }; |
| 729 | 746 | |
| 730 | | static WRITE8_DEVICE_HANDLER( abc800_ctc_z2_w ) |
| 747 | static ABC77_ON_TXD_CHANGED( abc802_abc77_txd_changed ) |
| 731 | 748 | { |
| 732 | | //abc800_state *state = device->machine->driver_data; |
| 749 | abc802_state *state = device->machine->driver_data; |
| 733 | 750 | |
| 734 | | /* write to DART channel A RxC/TxC */ |
| 751 | state->abc77_txd = level; |
| 735 | 752 | } |
| 736 | 753 | |
| 737 | | static const z80ctc_interface abc800_ctc_intf = |
| 754 | static ABC77_INTERFACE( abc802_abc77_intf ) |
| 738 | 755 | { |
| 739 | | Z80_TAG, /* cpu */ |
| 740 | | ABC800_X01/2/2, /* clock */ |
| 741 | | 0, /* timer disables */ |
| 742 | | 0, /* interrupt handler */ |
| 743 | | 0, /* ZC/TO0 callback */ |
| 744 | | 0, /* ZC/TO1 callback */ |
| 745 | | abc800_ctc_z2_w /* ZC/TO2 callback */ |
| 756 | abc802_abc77_txd_changed, |
| 757 | abc77_clock_changed, |
| 758 | abc77_keydown_changed |
| 746 | 759 | }; |
| 747 | 760 | |
| 748 | | static WRITE8_DEVICE_HANDLER( sio_serial_transmit ) |
| 761 | static ABC77_ON_TXD_CHANGED( abc806_abc77_txd_changed ) |
| 749 | 762 | { |
| 750 | | } |
| 763 | abc806_state *state = device->machine->driver_data; |
| 751 | 764 | |
| 752 | | static int sio_serial_receive( const device_config *device, int channel ) |
| 753 | | { |
| 754 | | return -1; |
| 765 | state->abc77_txd = level; |
| 755 | 766 | } |
| 756 | 767 | |
| 757 | | static z80sio_interface abc800_sio_intf = |
| 768 | static ABC77_INTERFACE( abc806_abc77_intf ) |
| 758 | 769 | { |
| 759 | | Z80_TAG, /* cpu */ |
| 760 | | ABC800_X01/2/2, /* clock */ |
| 761 | | 0, /* interrupt handler */ |
| 762 | | 0, /* DTR changed handler */ |
| 763 | | 0, /* RTS changed handler */ |
| 764 | | 0, /* BREAK changed handler */ |
| 765 | | sio_serial_transmit, /* transmit handler */ |
| 766 | | sio_serial_receive /* receive handler */ |
| 770 | abc806_abc77_txd_changed, |
| 771 | abc77_clock_changed, |
| 772 | abc77_keydown_changed |
| 767 | 773 | }; |
| 768 | 774 | |
| 769 | | static WRITE8_DEVICE_HANDLER( dart_serial_transmit ) |
| 770 | | { |
| 771 | | } |
| 775 | /* Z80 CTC */ |
| 772 | 776 | |
| 773 | | static int dart_serial_receive(const device_config *device, int ch) |
| 777 | static TIMER_DEVICE_CALLBACK( ctc_tick ) |
| 774 | 778 | { |
| 775 | | return -1; |
| 776 | | } |
| 779 | const device_config *z80ctc = devtag_get_device(timer->machine, Z80CTC, Z80CTC_TAG); |
| 777 | 780 | |
| 778 | | static void dart_interrupt(const device_config *device, int state) |
| 779 | | { |
| 780 | | cpunum_set_input_line(device->machine, 0, 0, state); |
| 781 | | } |
| 782 | | |
| 783 | | static const z80dart_interface abc800_dart_intf = |
| 784 | | { |
| 785 | | Z80_TAG, /* cpu */ |
| 786 | | ABC800_X01/2/2, /* clock */ |
| 787 | | dart_interrupt, /* interrupt handler */ |
| 788 | | 0, /* DTR changed handler */ |
| 789 | | 0, /* RTS changed handler */ |
| 790 | | 0, /* BREAK changed handler */ |
| 791 | | dart_serial_transmit, /* transmit handler */ |
| 792 | | dart_serial_receive /* receive handler */ |
| 793 | | }; |
| 794 | | |
| 795 | | static const z80_daisy_chain abc800_daisy_chain[] = |
| 796 | | { |
| 797 | | { Z80CTC, "z80ctc" }, |
| 798 | | { Z80SIO, Z80SIO_TAG }, |
| 799 | | { Z80DART, Z80DART_TAG }, |
| 800 | | { NULL } |
| 801 | | }; |
| 802 | | |
| 803 | | static void abc800_ctc_trg_w(const device_config *z80ctc) |
| 804 | | { |
| 805 | 781 | z80ctc_trg_w(z80ctc, 0, 1); |
| 806 | 782 | z80ctc_trg_w(z80ctc, 0, 0); |
| 807 | 783 | |
| r3475 | r3476 | |
| 812 | 788 | z80ctc_trg_w(z80ctc, 2, 0); |
| 813 | 789 | } |
| 814 | 790 | |
| 815 | | static TIMER_DEVICE_CALLBACK( abc800_ctc_tick ) |
| 791 | static void ctc_interrupt(const device_config *device, int state) |
| 816 | 792 | { |
| 817 | | abc800_state *state = timer->machine->driver_data; |
| 818 | | |
| 819 | | abc800_ctc_trg_w(state->z80ctc); |
| 793 | cpunum_set_input_line(device->machine, 0, INPUT_LINE_IRQ0, state); |
| 820 | 794 | } |
| 821 | 795 | |
| 822 | | static MACHINE_START( abc800 ) |
| 796 | static WRITE8_DEVICE_HANDLER( ctc_z0_w ) |
| 823 | 797 | { |
| 824 | | abc800_state *state = machine->driver_data; |
| 798 | //const device_config *z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 825 | 799 | |
| 826 | | /* find devices */ |
| 800 | UINT8 sb = input_port_read(device->machine, "SB"); |
| 827 | 801 | |
| 828 | | state->z80ctc = devtag_get_device(machine, Z80CTC, Z80CTC_TAG); |
| 829 | | state->z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 830 | | state->z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 831 | | //state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 832 | | } |
| 802 | if (BIT(sb, 2)) |
| 803 | { |
| 804 | /* connected to SIO/2 TxCA, CTC CLK/TRG3 */ |
| 805 | //z80sio_txc_w(z80sio, 0, data); |
| 806 | z80ctc_trg_w(device, 3, data); |
| 807 | } |
| 833 | 808 | |
| 834 | | // ABC802 |
| 809 | /* connected to SIO/2 RxCB through a thingy */ |
| 810 | //z80sio_rxcb = ? |
| 811 | //z80sio_rxc_w(z80sio, 1, z80sio_rxcb); |
| 835 | 812 | |
| 836 | | static ABC77_ON_TXD_CHANGED( abc802_abc77_txd_changed ) |
| 837 | | { |
| 838 | | abc802_state *state = device->machine->driver_data; |
| 839 | | |
| 840 | | state->abc77_txd = level; |
| 813 | /* connected to SIO/2 TxCB through a JK divide by 2 */ |
| 814 | //z80sio_txcb = !z80sio_txcb; |
| 815 | //z80sio_txc_w(z80sio, 1, z80sio_txcb); |
| 841 | 816 | } |
| 842 | 817 | |
| 843 | | static ABC77_ON_CLOCK_CHANGED( abc802_abc77_clock_changed ) |
| 818 | static WRITE8_DEVICE_HANDLER( ctc_z1_w ) |
| 844 | 819 | { |
| 845 | | // abc802_state *state = device->machine->driver_data; |
| 820 | //const device_config *z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 846 | 821 | |
| 847 | | /* clock into DART RxTxCB (Receiver/Transmitter Clock B) */ |
| 822 | UINT8 sb = input_port_read(device->machine, "SB"); |
| 823 | |
| 824 | if (BIT(sb, 3)) |
| 825 | { |
| 826 | /* connected to SIO/2 RxCA */ |
| 827 | //z80sio_rxc_w(z80sio, 0, data); |
| 828 | } |
| 829 | |
| 830 | if (BIT(sb, 8)) |
| 831 | { |
| 832 | /* connected to SIO/2 TxCA, CTC CLK/TRG3 */ |
| 833 | //z80sio_txc_w(z80sio, 0, data); |
| 834 | z80ctc_trg_w(device, 3, data); |
| 835 | } |
| 848 | 836 | } |
| 849 | 837 | |
| 850 | | static ABC77_ON_KEYDOWN_CHANGED( abc802_abc77_keydown_changed ) |
| 838 | static WRITE8_DEVICE_HANDLER( ctc_z2_w ) |
| 851 | 839 | { |
| 852 | | abc802_state *state = device->machine->driver_data; |
| 840 | // const device_config *z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 853 | 841 | |
| 854 | | z80dart_set_dcd(state->z80dart, 1, level); |
| 842 | /* connected to DART RxCA/TxCA (pin ) */ |
| 843 | //z80dart_rxtxc_w(z80dart, 0, data); |
| 855 | 844 | } |
| 856 | 845 | |
| 857 | | static ABC77_INTERFACE( abc802_abc77_intf ) |
| 846 | static const z80ctc_interface ctc_intf = |
| 858 | 847 | { |
| 859 | | abc802_abc77_txd_changed, |
| 860 | | abc802_abc77_clock_changed, |
| 861 | | abc802_abc77_keydown_changed |
| 848 | Z80_TAG, /* cpu */ |
| 849 | ABC800_X01/2/2, /* clock */ |
| 850 | 0, /* timer disables */ |
| 851 | ctc_interrupt, /* interrupt handler */ |
| 852 | ctc_z0_w, /* ZC/TO0 callback */ |
| 853 | ctc_z1_w, /* ZC/TO1 callback */ |
| 854 | ctc_z2_w /* ZC/TO2 callback */ |
| 862 | 855 | }; |
| 863 | 856 | |
| 864 | | static WRITE8_DEVICE_HANDLER( abc802_dart_dtr_w ) |
| 857 | /* Z80 SIO/2 */ |
| 858 | |
| 859 | static void sio_interrupt(const device_config *device, int state) |
| 865 | 860 | { |
| 861 | cpunum_set_input_line(device->machine, 0, INPUT_LINE_IRQ0, state); |
| 862 | } |
| 863 | |
| 864 | static WRITE8_DEVICE_HANDLER( sio_dtr_w ) |
| 865 | { |
| 866 | 866 | if (offset == 1) |
| 867 | 867 | { |
| 868 | | memory_set_bank(1, data); |
| 868 | /* cassette motor control */ |
| 869 | cassette_change_state(cassette_device_image(device->machine), data ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); |
| 869 | 870 | } |
| 870 | 871 | } |
| 871 | 872 | |
| 872 | | static WRITE8_DEVICE_HANDLER( abc802_dart_rts_w ) |
| 873 | static WRITE8_DEVICE_HANDLER( sio_serial_transmit ) |
| 873 | 874 | { |
| 874 | | abc802_state *state = device->machine->driver_data; |
| 875 | | |
| 876 | 875 | if (offset == 1) |
| 877 | 876 | { |
| 878 | | state->mux80_40 = !BIT(data, 0); |
| 877 | /* cassette dfd out */ |
| 879 | 878 | } |
| 880 | 879 | } |
| 881 | 880 | |
| 882 | | static const z80dart_interface abc802_dart_intf = |
| 881 | static int sio_serial_receive( const device_config *device, int channel ) |
| 883 | 882 | { |
| 884 | | Z80_TAG, /* cpu */ |
| 885 | | ABC800_X01/2/2, /* clock */ |
| 886 | | 0, /* interrupt handler */ |
| 887 | | abc802_dart_dtr_w, /* DTR changed handler */ |
| 888 | | abc802_dart_rts_w, /* RTS changed handler */ |
| 889 | | 0, /* BREAK changed handler */ |
| 890 | | dart_serial_transmit, /* transmit handler */ |
| 891 | | dart_serial_receive /* receive handler */ |
| 892 | | }; |
| 883 | if (channel == 1) |
| 884 | { |
| 885 | /* cassette dfd in */ |
| 886 | } |
| 893 | 887 | |
| 894 | | static TIMER_DEVICE_CALLBACK( abc802_ctc_tick ) |
| 895 | | { |
| 896 | | abc802_state *state = timer->machine->driver_data; |
| 897 | | |
| 898 | | abc800_ctc_trg_w(state->z80ctc); |
| 888 | return -1; |
| 899 | 889 | } |
| 900 | 890 | |
| 901 | | static WRITE8_DEVICE_HANDLER( abc802_ctc_z2_w ) |
| 891 | static z80sio_interface sio_intf = |
| 902 | 892 | { |
| 903 | | // abc802_state *state = device->machine->driver_data; |
| 904 | | |
| 905 | | /* write to DART channel A RxC/TxC */ |
| 906 | | } |
| 907 | | |
| 908 | | static const z80ctc_interface abc802_ctc_intf = |
| 909 | | { |
| 910 | 893 | Z80_TAG, /* cpu */ |
| 911 | 894 | ABC800_X01/2/2, /* clock */ |
| 912 | | 0, /* timer disables */ |
| 913 | | 0, /* interrupt handler */ |
| 914 | | 0, /* ZC/TO0 callback */ |
| 915 | | 0, /* ZC/TO1 callback */ |
| 916 | | abc802_ctc_z2_w /* ZC/TO2 callback */ |
| 895 | sio_interrupt, /* interrupt handler */ |
| 896 | sio_dtr_w, /* DTR changed handler */ |
| 897 | 0, /* RTS changed handler */ |
| 898 | 0, /* BREAK changed handler */ |
| 899 | sio_serial_transmit, /* transmit handler */ |
| 900 | sio_serial_receive /* receive handler */ |
| 917 | 901 | }; |
| 918 | 902 | |
| 919 | | static MACHINE_START( abc802 ) |
| 903 | /* Z80 DART */ |
| 904 | |
| 905 | static WRITE8_DEVICE_HANDLER( dart_serial_transmit ) |
| 920 | 906 | { |
| 921 | | abc802_state *state = machine->driver_data; |
| 922 | | |
| 923 | | /* find devices */ |
| 924 | | |
| 925 | | state->z80ctc = devtag_get_device(machine, Z80CTC, Z80CTC_TAG); |
| 926 | | state->z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 927 | | state->z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 928 | | state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 929 | | |
| 930 | | /* configure memory */ |
| 931 | | |
| 932 | | memory_configure_bank(1, 0, 1, memory_region(machine, Z80_TAG), 0); |
| 933 | | memory_configure_bank(1, 1, 1, mess_ram, 0); |
| 934 | 907 | } |
| 935 | 908 | |
| 936 | | static MACHINE_RESET( abc802 ) |
| 909 | static int dart_serial_receive(const device_config *device, int ch) |
| 937 | 910 | { |
| 938 | | memory_set_bank(1, 0); |
| 911 | return -1; |
| 939 | 912 | } |
| 940 | 913 | |
| 941 | | // ABC806 |
| 942 | | |
| 943 | | static ABC77_ON_TXD_CHANGED( abc806_abc77_txd_changed ) |
| 914 | static void dart_interrupt(const device_config *device, int state) |
| 944 | 915 | { |
| 945 | | abc806_state *state = device->machine->driver_data; |
| 946 | | |
| 947 | | state->abc77_txd = level; |
| 916 | cpunum_set_input_line(device->machine, 0, INPUT_LINE_IRQ0, state); |
| 948 | 917 | } |
| 949 | 918 | |
| 950 | | static ABC77_ON_CLOCK_CHANGED( abc806_abc77_clock_changed ) |
| 919 | static const z80dart_interface abc800_dart_intf = |
| 951 | 920 | { |
| 952 | | // abc806_state *state = device->machine->driver_data; |
| 921 | Z80_TAG, /* cpu */ |
| 922 | ABC800_X01/2/2, /* clock */ |
| 923 | dart_interrupt, /* interrupt handler */ |
| 924 | 0, /* DTR changed handler */ |
| 925 | 0, /* RTS changed handler */ |
| 926 | 0, /* BREAK changed handler */ |
| 927 | dart_serial_transmit, /* transmit handler */ |
| 928 | dart_serial_receive /* receive handler */ |
| 929 | }; |
| 953 | 930 | |
| 954 | | /* clock into DART RxTxCB (Receiver/Transmitter Clock B) */ |
| 931 | static WRITE8_DEVICE_HANDLER( abc802_dart_dtr_w ) |
| 932 | { |
| 933 | if (offset == 1) |
| 934 | { |
| 935 | /* _LRS */ |
| 936 | memory_set_bank(1, data); |
| 937 | } |
| 955 | 938 | } |
| 956 | 939 | |
| 957 | | static ABC77_ON_KEYDOWN_CHANGED( abc806_abc77_keydown_changed ) |
| 940 | static WRITE8_DEVICE_HANDLER( abc802_dart_rts_w ) |
| 958 | 941 | { |
| 959 | | abc806_state *state = device->machine->driver_data; |
| 942 | abc802_state *state = device->machine->driver_data; |
| 960 | 943 | |
| 961 | | z80dart_set_dcd(state->z80dart, 1, level); |
| 944 | if (offset == 1) |
| 945 | { |
| 946 | /* _MUX 80/40 */ |
| 947 | state->mux80_40 = !BIT(data, 0); |
| 948 | } |
| 962 | 949 | } |
| 963 | 950 | |
| 964 | | static ABC77_INTERFACE( abc806_abc77_intf ) |
| 951 | static const z80dart_interface abc802_dart_intf = |
| 965 | 952 | { |
| 966 | | abc806_abc77_txd_changed, |
| 967 | | abc806_abc77_clock_changed, |
| 968 | | abc806_abc77_keydown_changed |
| 953 | Z80_TAG, /* cpu */ |
| 954 | ABC800_X01/2/2, /* clock */ |
| 955 | 0, /* interrupt handler */ |
| 956 | abc802_dart_dtr_w, /* DTR changed handler */ |
| 957 | abc802_dart_rts_w, /* RTS changed handler */ |
| 958 | 0, /* BREAK changed handler */ |
| 959 | dart_serial_transmit, /* transmit handler */ |
| 960 | dart_serial_receive /* receive handler */ |
| 969 | 961 | }; |
| 970 | 962 | |
| 971 | | static const e0516_interface abc806_e0516_intf = |
| 972 | | { |
| 973 | | ABC806_X02 |
| 974 | | }; |
| 975 | | |
| 976 | 963 | static WRITE8_DEVICE_HANDLER( abc806_dart_dtr_w ) |
| 977 | 964 | { |
| 978 | 965 | abc806_state *state = device->machine->driver_data; |
| r3475 | r3476 | |
| 995 | 982 | dart_serial_receive /* receive handler */ |
| 996 | 983 | }; |
| 997 | 984 | |
| 998 | | static TIMER_DEVICE_CALLBACK( abc806_ctc_tick ) |
| 985 | /* E05-16 */ |
| 986 | |
| 987 | static const e0516_interface abc806_e0516_intf = |
| 999 | 988 | { |
| 1000 | | abc806_state *state = timer->machine->driver_data; |
| 989 | ABC806_X02 |
| 990 | }; |
| 1001 | 991 | |
| 1002 | | abc800_ctc_trg_w(state->z80ctc); |
| 992 | /* Z80 Daisy Chain */ |
| 993 | |
| 994 | static const z80_daisy_chain abc800_daisy_chain[] = |
| 995 | { |
| 996 | { Z80CTC, Z80CTC_TAG }, |
| 997 | { Z80SIO, Z80SIO_TAG }, |
| 998 | { Z80DART, Z80DART_TAG }, |
| 999 | { NULL } |
| 1000 | }; |
| 1001 | |
| 1002 | /* Machine Initialization */ |
| 1003 | |
| 1004 | static MACHINE_START( abc800 ) |
| 1005 | { |
| 1006 | abc800_state *state = machine->driver_data; |
| 1007 | |
| 1008 | /* find devices */ |
| 1009 | |
| 1010 | state->z80ctc = devtag_get_device(machine, Z80CTC, Z80CTC_TAG); |
| 1011 | state->z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 1012 | state->z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 1013 | //state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 1003 | 1014 | } |
| 1004 | 1015 | |
| 1005 | | static WRITE8_DEVICE_HANDLER( abc806_ctc_z2_w ) |
| 1016 | static MACHINE_START( abc802 ) |
| 1006 | 1017 | { |
| 1007 | | // abc806_state *state = device->machine->driver_data; |
| 1018 | abc802_state *state = machine->driver_data; |
| 1008 | 1019 | |
| 1009 | | /* write to DART channel A RxC/TxC */ |
| 1020 | /* find devices */ |
| 1021 | |
| 1022 | state->z80ctc = devtag_get_device(machine, Z80CTC, Z80CTC_TAG); |
| 1023 | state->z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 1024 | state->z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 1025 | // state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 1026 | |
| 1027 | /* configure memory */ |
| 1028 | |
| 1029 | memory_configure_bank(1, 0, 1, memory_region(machine, Z80_TAG), 0); |
| 1030 | memory_configure_bank(1, 1, 1, mess_ram, 0); |
| 1010 | 1031 | } |
| 1011 | 1032 | |
| 1012 | | static const z80ctc_interface abc806_ctc_intf = |
| 1033 | static MACHINE_RESET( abc802 ) |
| 1013 | 1034 | { |
| 1014 | | Z80_TAG, /* cpu */ |
| 1015 | | ABC800_X01/2/2, /* clock */ |
| 1016 | | 0, /* timer disables */ |
| 1017 | | 0, /* interrupt handler */ |
| 1018 | | 0, /* ZC/TO0 callback */ |
| 1019 | | 0, /* ZC/TO1 callback */ |
| 1020 | | abc806_ctc_z2_w /* ZC/TO2 callback */ |
| 1021 | | }; |
| 1035 | abc802_state *state = machine->driver_data; |
| 1022 | 1036 | |
| 1037 | /* memory banking */ |
| 1038 | memory_set_bank(1, 0); |
| 1039 | |
| 1040 | /* clear screen time out (S1) */ |
| 1041 | z80sio_set_dcd(state->z80sio, 1, 0); |
| 1042 | |
| 1043 | /* unknown (S2) */ |
| 1044 | z80sio_set_cts(state->z80sio, 1, 0); |
| 1045 | |
| 1046 | /* 40/80 char (S3) */ |
| 1047 | z80dart_set_ri(state->z80dart, 0, 0); // 0 = 40, 1 = 80 |
| 1048 | |
| 1049 | /* 50/60 Hz */ |
| 1050 | z80dart_set_cts(state->z80dart, 1, 0); // 0 = 50Hz, 1 = 60Hz ??? |
| 1051 | } |
| 1052 | |
| 1023 | 1053 | static MACHINE_START( abc806 ) |
| 1024 | 1054 | { |
| 1025 | 1055 | abc806_state *state = machine->driver_data; |
| r3475 | r3476 | |
| 1033 | 1063 | state->z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 1034 | 1064 | state->z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 1035 | 1065 | state->e0516 = devtag_get_device(machine, E0516, E0516_TAG); |
| 1036 | | state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 1066 | //state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 1037 | 1067 | |
| 1038 | 1068 | /* setup memory banking */ |
| 1039 | 1069 | |
| r3475 | r3476 | |
| 1085 | 1115 | MDRV_MACHINE_START(abc800) |
| 1086 | 1116 | |
| 1087 | 1117 | /* fake keyboard */ |
| 1088 | | MDRV_TIMER_ADD_PERIODIC("keyboard", abc800_keyboard_tick, USEC(2500)) |
| 1118 | MDRV_TIMER_ADD_PERIODIC("keyboard", keyboard_tick, USEC(2500)) |
| 1089 | 1119 | |
| 1090 | 1120 | /* ABC-77 keyboard */ |
| 1091 | | /* MDRV_SPEAKER_STANDARD_MONO("mono") |
| 1092 | | MDRV_DEVICE_ADD(ABC77_TAG, ABC77) |
| 1093 | | MDRV_DEVICE_CONFIG(abc800_abc77_intf)*/ |
| 1121 | // MDRV_ABC77_ADD(abc800_abc77_intf) |
| 1094 | 1122 | |
| 1095 | 1123 | /* video hardware */ |
| 1096 | 1124 | MDRV_IMPORT_FROM(abc800m_video) |
| 1097 | 1125 | |
| 1098 | 1126 | /* Z80 CTC */ |
| 1099 | | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc800_ctc_intf ) |
| 1100 | | MDRV_TIMER_ADD_PERIODIC("ctc", abc800_ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1127 | MDRV_Z80CTC_ADD(Z80CTC_TAG, ctc_intf) |
| 1128 | MDRV_TIMER_ADD_PERIODIC("ctc", ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1101 | 1129 | |
| 1102 | 1130 | /* Z80 SIO/2 */ |
| 1103 | | MDRV_Z80SIO_ADD( Z80SIO_TAG, abc800_sio_intf ) |
| 1131 | MDRV_Z80SIO_ADD(Z80SIO_TAG, sio_intf) |
| 1104 | 1132 | |
| 1105 | 1133 | /* Z80 DART */ |
| 1106 | | MDRV_Z80DART_ADD( Z80DART_TAG, abc800_dart_intf ) |
| 1134 | MDRV_Z80DART_ADD(Z80DART_TAG, abc800_dart_intf) |
| 1107 | 1135 | |
| 1108 | 1136 | /* printer */ |
| 1109 | 1137 | MDRV_DEVICE_ADD("printer", PRINTER) |
| r3475 | r3476 | |
| 1124 | 1152 | MDRV_MACHINE_START(abc800) |
| 1125 | 1153 | |
| 1126 | 1154 | /* fake keyboard */ |
| 1127 | | MDRV_TIMER_ADD_PERIODIC("keyboard", abc800_keyboard_tick, USEC(2500)) |
| 1155 | MDRV_TIMER_ADD_PERIODIC("keyboard", keyboard_tick, USEC(2500)) |
| 1128 | 1156 | |
| 1129 | 1157 | /* ABC-77 keyboard */ |
| 1130 | | /* MDRV_SPEAKER_STANDARD_MONO("mono") |
| 1131 | | MDRV_DEVICE_ADD(ABC77_TAG, ABC77) |
| 1132 | | MDRV_DEVICE_CONFIG(abc800_abc77_intf)*/ |
| 1158 | // MDRV_ABC77_ADD(abc800_abc77_intf) |
| 1133 | 1159 | |
| 1134 | 1160 | /* video hardware */ |
| 1135 | 1161 | MDRV_IMPORT_FROM(abc800c_video) |
| 1136 | 1162 | |
| 1137 | 1163 | /* Z80 CTC */ |
| 1138 | | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc800_ctc_intf ) |
| 1139 | | MDRV_TIMER_ADD_PERIODIC("ctc", abc800_ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1164 | MDRV_Z80CTC_ADD(Z80CTC_TAG, ctc_intf) |
| 1165 | MDRV_TIMER_ADD_PERIODIC("ctc", ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1140 | 1166 | |
| 1141 | 1167 | /* Z80 SIO/2 */ |
| 1142 | | MDRV_Z80SIO_ADD( Z80SIO_TAG, abc800_sio_intf ) |
| 1168 | MDRV_Z80SIO_ADD(Z80SIO_TAG, sio_intf) |
| 1143 | 1169 | |
| 1144 | 1170 | /* Z80 DART */ |
| 1145 | | MDRV_Z80DART_ADD( Z80DART_TAG, abc800_dart_intf ) |
| 1171 | MDRV_Z80DART_ADD(Z80DART_TAG, abc800_dart_intf) |
| 1146 | 1172 | |
| 1147 | 1173 | /* printer */ |
| 1148 | 1174 | MDRV_DEVICE_ADD("printer", PRINTER) |
| r3475 | r3476 | |
| 1163 | 1189 | MDRV_MACHINE_START(abc802) |
| 1164 | 1190 | MDRV_MACHINE_RESET(abc802) |
| 1165 | 1191 | |
| 1192 | /* fake keyboard */ |
| 1193 | MDRV_TIMER_ADD_PERIODIC("keyboard", keyboard_tick, USEC(2500)) |
| 1194 | |
| 1166 | 1195 | /* ABC-77 keyboard */ |
| 1167 | | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 1168 | | MDRV_DEVICE_ADD(ABC77_TAG, ABC77) |
| 1169 | | MDRV_DEVICE_CONFIG(abc802_abc77_intf) |
| 1196 | // MDRV_ABC77_ADD(abc802_abc77_intf) |
| 1170 | 1197 | |
| 1171 | 1198 | /* video hardware */ |
| 1172 | 1199 | MDRV_IMPORT_FROM(abc802_video) |
| 1173 | 1200 | |
| 1174 | 1201 | /* Z80 CTC */ |
| 1175 | | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc802_ctc_intf ) |
| 1176 | | MDRV_TIMER_ADD_PERIODIC("ctc", abc802_ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1202 | MDRV_Z80CTC_ADD(Z80CTC_TAG, ctc_intf) |
| 1203 | MDRV_TIMER_ADD_PERIODIC("ctc", ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1177 | 1204 | |
| 1178 | 1205 | /* Z80 SIO/2 */ |
| 1179 | | MDRV_Z80SIO_ADD( Z80SIO_TAG, abc800_sio_intf ) |
| 1206 | MDRV_Z80SIO_ADD(Z80SIO_TAG, sio_intf) |
| 1180 | 1207 | |
| 1181 | 1208 | /* Z80 DART */ |
| 1182 | | MDRV_Z80DART_ADD( Z80DART_TAG, abc800_dart_intf ) |
| 1209 | MDRV_Z80DART_ADD(Z80DART_TAG, abc802_dart_intf) |
| 1183 | 1210 | |
| 1184 | 1211 | /* printer */ |
| 1185 | 1212 | MDRV_DEVICE_ADD("printer", PRINTER) |
| r3475 | r3476 | |
| 1199 | 1226 | |
| 1200 | 1227 | MDRV_MACHINE_START(abc806) |
| 1201 | 1228 | MDRV_MACHINE_RESET(abc806) |
| 1229 | |
| 1230 | /* fake keyboard */ |
| 1231 | MDRV_TIMER_ADD_PERIODIC("keyboard", keyboard_tick, USEC(2500)) |
| 1202 | 1232 | |
| 1203 | 1233 | /* ABC-77 keyboard */ |
| 1204 | | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 1205 | | MDRV_DEVICE_ADD(ABC77_TAG, ABC77) |
| 1206 | | MDRV_DEVICE_CONFIG(abc806_abc77_intf) |
| 1234 | //MDRV_ABC77_ADD(abc806_abc77_intf) |
| 1207 | 1235 | |
| 1208 | 1236 | /* video hardware */ |
| 1209 | 1237 | MDRV_IMPORT_FROM(abc806_video) |
| 1210 | 1238 | |
| 1211 | 1239 | /* Z80 CTC */ |
| 1212 | | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc806_ctc_intf ) |
| 1213 | | MDRV_TIMER_ADD_PERIODIC("ctc", abc806_ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1240 | MDRV_Z80CTC_ADD(Z80CTC_TAG, ctc_intf) |
| 1241 | MDRV_TIMER_ADD_PERIODIC("ctc", ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1214 | 1242 | |
| 1215 | 1243 | /* Z80 SIO/2 */ |
| 1216 | | MDRV_Z80SIO_ADD( Z80SIO_TAG, abc800_sio_intf ) |
| 1244 | MDRV_Z80SIO_ADD(Z80SIO_TAG, sio_intf) |
| 1217 | 1245 | |
| 1218 | 1246 | /* Z80 DART */ |
| 1219 | | MDRV_Z80DART_ADD( Z80DART_TAG, abc800_dart_intf ) |
| 1247 | MDRV_Z80DART_ADD(Z80DART_TAG, abc806_dart_intf) |
| 1220 | 1248 | |
| 1221 | 1249 | /* real time clock */ |
| 1222 | 1250 | MDRV_DEVICE_ADD(E0516_TAG, E0516) |