trunk/src/mess/includes/wangpc.h
| r20152 | r20153 | |
| 10 | 10 | #include "machine/ctronics.h" |
| 11 | 11 | #include "machine/i8255.h" |
| 12 | 12 | #include "machine/im6402.h" |
| 13 | | #include "machine/pic8259.h" |
| 13 | #include "machine/mc2661.h" |
| 14 | 14 | #include "machine/pit8253.h" |
| 15 | #include "machine/pic8259.h" |
| 15 | 16 | #include "machine/ram.h" |
| 16 | | #include "machine/mc2661.h" |
| 17 | 17 | #include "machine/upd765.h" |
| 18 | 18 | #include "machine/wangpcbus.h" |
| 19 | 19 | #include "machine/wangpckb.h" |
| r20152 | r20153 | |
| 71 | 71 | m_fdc_dd0(0), |
| 72 | 72 | m_fdc_dd1(0), |
| 73 | 73 | m_fdc_tc(0), |
| 74 | | m_ds1(1), |
| 75 | | m_ds2(1) |
| 74 | m_ds1(false), |
| 75 | m_ds2(false) |
| 76 | 76 | { } |
| 77 | 77 | |
| 78 | 78 | required_device<cpu_device> m_maincpu; |
| r20152 | r20153 | |
| 93 | 93 | virtual void machine_start(); |
| 94 | 94 | virtual void machine_reset(); |
| 95 | 95 | |
| 96 | | void select_drive(int drive, bool select); |
| 97 | | void set_motor(int drive, bool motor); |
| 98 | | void fdc_reset(); |
| 99 | | void fdc_tc(); |
| 96 | void select_drive(); |
| 100 | 97 | void check_level1_interrupts(); |
| 101 | 98 | void check_level2_interrupts(); |
| 102 | 99 | void update_fdc_drq(); |
| r20152 | r20153 | |
| 165 | 162 | DECLARE_WRITE_LINE_MEMBER( busy_w ); |
| 166 | 163 | DECLARE_WRITE_LINE_MEMBER( bus_irq2_w ); |
| 167 | 164 | |
| 165 | DECLARE_FLOPPY_FORMATS( floppy_formats ); |
| 166 | |
| 168 | 167 | void fdc_irq(bool state); |
| 169 | 168 | void fdc_drq(bool state); |
| 170 | 169 | |
| r20152 | r20153 | |
| 195 | 194 | int m_ds1; |
| 196 | 195 | int m_ds2; |
| 197 | 196 | |
| 198 | | int m_led[6]; // HACK until keyboard works |
| 197 | int m_led[6]; |
| 199 | 198 | }; |
| 200 | 199 | |
| 201 | 200 | |
trunk/src/mess/drivers/bw12.c
| r20152 | r20153 | |
| 29 | 29 | |
| 30 | 30 | TODO: |
| 31 | 31 | |
| 32 | | - floppy is broken |
| 33 | 32 | - floppy motor off timer |
| 34 | 33 | |
| 35 | 34 | */ |
| r20152 | r20153 | |
| 126 | 125 | |
| 127 | 126 | case 5: /* MOTOR 0 */ |
| 128 | 127 | m_motor0 = data; |
| 129 | | |
| 130 | | if (data) |
| 131 | | { |
| 132 | | m_floppy0->mon_w(0); |
| 133 | | } |
| 134 | | |
| 135 | | set_floppy_motor_off_timer(); |
| 136 | 128 | break; |
| 137 | 129 | |
| 138 | 130 | case 6: /* MOTOR 1 */ |
| 139 | 131 | m_motor1 = data; |
| 140 | | |
| 141 | | if (data) |
| 142 | | { |
| 143 | | m_floppy1->mon_w(0); |
| 144 | | } |
| 145 | | |
| 146 | | set_floppy_motor_off_timer(); |
| 147 | 132 | break; |
| 148 | 133 | |
| 149 | 134 | case 7: /* FDC TC */ |
| 150 | 135 | m_fdc->tc_w(data); |
| 151 | 136 | break; |
| 152 | 137 | } |
| 138 | |
| 139 | m_motor_on = m_motor0 || m_motor1; |
| 140 | |
| 141 | m_floppy0->mon_w(!m_motor_on); |
| 142 | m_floppy1->mon_w(!m_motor_on); |
| 153 | 143 | } |
| 154 | 144 | |
| 155 | 145 | WRITE8_MEMBER( bw12_state::ls259_w ) |
| r20152 | r20153 | |
| 664 | 654 | |
| 665 | 655 | /* devices */ |
| 666 | 656 | MCFG_TIMER_DRIVER_ADD(FLOPPY_TIMER_TAG, bw12_state, floppy_motor_off_tick) |
| 667 | | MCFG_UPD765A_ADD(UPD765_TAG, true, true) |
| 657 | MCFG_UPD765A_ADD(UPD765_TAG, false, true) |
| 668 | 658 | MCFG_PIA6821_ADD(PIA6821_TAG, pia_intf) |
| 669 | 659 | MCFG_Z80SIO0_ADD(Z80SIO_TAG, XTAL_16MHz/4, sio_intf) |
| 670 | 660 | MCFG_PIT8253_ADD(PIT8253_TAG, pit_intf) |
| r20152 | r20153 | |
| 676 | 666 | |
| 677 | 667 | static MACHINE_CONFIG_DERIVED( bw12, common ) |
| 678 | 668 | /* floppy drives */ |
| 679 | | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":0", bw12_floppies, "525dd", 0, bw12_state::bw12_floppy_formats) |
| 680 | 669 | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":1", bw12_floppies, "525dd", 0, bw12_state::bw12_floppy_formats) |
| 670 | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":2", bw12_floppies, "525dd", 0, bw12_state::bw12_floppy_formats) |
| 681 | 671 | |
| 682 | 672 | // software lists |
| 683 | 673 | MCFG_SOFTWARE_LIST_ADD("flop_list", "bw12") |
| r20152 | r20153 | |
| 689 | 679 | |
| 690 | 680 | static MACHINE_CONFIG_DERIVED( bw14, common ) |
| 691 | 681 | /* floppy drives */ |
| 692 | | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":0", bw14_floppies, "525dd", 0, bw12_state::bw14_floppy_formats) |
| 693 | 682 | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":1", bw14_floppies, "525dd", 0, bw12_state::bw14_floppy_formats) |
| 683 | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":2", bw14_floppies, "525dd", 0, bw12_state::bw14_floppy_formats) |
| 694 | 684 | |
| 695 | 685 | /* internal ram */ |
| 696 | 686 | MCFG_RAM_ADD(RAM_TAG) |
| r20152 | r20153 | |
| 712 | 702 | /* System Drivers */ |
| 713 | 703 | |
| 714 | 704 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 715 | | COMP( 1984, bw12, 0, 0, bw12, bw12, driver_device, 0, "Bondwell Holding", "Bondwell 12", GAME_NOT_WORKING | GAME_SUPPORTS_SAVE ) |
| 716 | | COMP( 1984, bw14, bw12, 0, bw14, bw12, driver_device, 0, "Bondwell Holding", "Bondwell 14", GAME_NOT_WORKING | GAME_SUPPORTS_SAVE ) |
| 705 | COMP( 1984, bw12, 0, 0, bw12, bw12, driver_device, 0, "Bondwell Holding", "Bondwell 12", GAME_SUPPORTS_SAVE ) |
| 706 | COMP( 1984, bw14, bw12, 0, bw14, bw12, driver_device, 0, "Bondwell Holding", "Bondwell 14", GAME_SUPPORTS_SAVE ) |
trunk/src/mess/drivers/xerox820.c
| r20152 | r20153 | |
| 170 | 170 | } |
| 171 | 171 | } |
| 172 | 172 | |
| 173 | READ8_MEMBER( xerox820_state::fdc_r ) |
| 174 | { |
| 175 | return m_fdc->gen_r(offset) ^ 0xff; |
| 176 | } |
| 177 | |
| 178 | WRITE8_MEMBER( xerox820_state::fdc_w ) |
| 179 | { |
| 180 | m_fdc->gen_w(offset, data ^ 0xff); |
| 181 | } |
| 182 | |
| 173 | 183 | WRITE8_MEMBER( xerox820_state::scroll_w ) |
| 174 | 184 | { |
| 175 | 185 | m_scroll = (offset >> 8) & 0x1f; |
| r20152 | r20153 | |
| 241 | 251 | AM_RANGE(0x05, 0x05) AM_MIRROR(0xff02) AM_DEVREADWRITE_LEGACY(Z80SIO_TAG, z80dart_c_r, z80dart_c_w) |
| 242 | 252 | AM_RANGE(0x08, 0x0b) AM_MIRROR(0xff00) AM_DEVREADWRITE(Z80PIO_GP_TAG, z80pio_device, read_alt, write_alt) |
| 243 | 253 | AM_RANGE(0x0c, 0x0c) AM_MIRROR(0xff03) AM_DEVWRITE(COM8116_TAG, com8116_device, stt_w) |
| 244 | | AM_RANGE(0x10, 0x13) AM_MIRROR(0xff00) AM_DEVREADWRITE(FD1771_TAG, wd_fdc_t, read, write) |
| 254 | AM_RANGE(0x10, 0x13) AM_MIRROR(0xff00) AM_READWRITE(fdc_r, fdc_w) |
| 245 | 255 | AM_RANGE(0x14, 0x14) AM_MIRROR(0xff03) AM_MASK(0xff00) AM_WRITE(scroll_w) |
| 246 | 256 | AM_RANGE(0x18, 0x1b) AM_MIRROR(0xff00) AM_DEVREADWRITE(Z80CTC_TAG, z80ctc_device, read, write) |
| 247 | 257 | AM_RANGE(0x1c, 0x1f) AM_MIRROR(0xff00) AM_DEVREADWRITE(Z80PIO_KB_TAG, z80pio_device, read_alt, write_alt) |
| r20152 | r20153 | |
| 652 | 662 | SLOT_INTERFACE( "sa850", FLOPPY_8_DSDD ) // Shugart SA-850 |
| 653 | 663 | SLOT_INTERFACE_END |
| 654 | 664 | |
| 665 | void xerox820_state::update_nmi() |
| 666 | { |
| 667 | int halt = m_maincpu->state_int(Z80_HALT); |
| 668 | int state = (halt && (m_fdc_irq || m_fdc_drq)) ? ASSERT_LINE : CLEAR_LINE; |
| 669 | |
| 670 | m_maincpu->set_input_line(INPUT_LINE_NMI, state); |
| 671 | } |
| 672 | |
| 655 | 673 | void xerox820_state::fdc_intrq_w(bool state) |
| 656 | 674 | { |
| 657 | 675 | m_fdc_irq = state; |
| 658 | 676 | |
| 659 | | int halt = m_maincpu->state_int(Z80_HALT); |
| 660 | | |
| 661 | | if (halt && (m_fdc_irq || m_fdc_drq)) |
| 662 | | m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE); |
| 663 | | else |
| 664 | | m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE); |
| 677 | update_nmi(); |
| 665 | 678 | } |
| 666 | 679 | |
| 667 | 680 | void xerox820_state::fdc_drq_w(bool state) |
| 668 | 681 | { |
| 669 | 682 | m_fdc_drq = state; |
| 670 | 683 | |
| 671 | | int halt = m_maincpu->state_int(Z80_HALT); |
| 672 | | |
| 673 | | if (halt && (m_fdc_irq || m_fdc_drq)) |
| 674 | | m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE); |
| 675 | | else |
| 676 | | m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE); |
| 684 | update_nmi(); |
| 677 | 685 | } |
| 678 | 686 | |
| 679 | 687 | /* COM8116 Interface */ |
| r20152 | r20153 | |
| 749 | 757 | // floppy callbacks |
| 750 | 758 | m_fdc->setup_intrq_cb(wd_fdc_t::line_cb(FUNC(xerox820_state::fdc_intrq_w), this)); |
| 751 | 759 | m_fdc->setup_drq_cb(wd_fdc_t::line_cb(FUNC(xerox820_state::fdc_drq_w), this)); |
| 752 | | m_fdc->dden_w(1); |
| 753 | 760 | |
| 754 | 761 | // state saving |
| 755 | 762 | save_item(NAME(m_keydata)); |
trunk/src/mess/drivers/wangpc.c
| r20152 | r20153 | |
| 12 | 12 | |
| 13 | 13 | TODO: |
| 14 | 14 | |
| 15 | - with quantum perfect cpu gets stuck @ 49c3 mov ss,cs:[52ah] |
| 15 | 16 | - hard disk |
| 16 | 17 | |
| 17 | 18 | */ |
| r20152 | r20153 | |
| 33 | 34 | |
| 34 | 35 | |
| 35 | 36 | //************************************************************************** |
| 36 | | // DIRECT MEMORY ACCESS |
| 37 | // IMPLEMENTATION |
| 37 | 38 | //************************************************************************** |
| 38 | 39 | |
| 39 | | void wangpc_state::select_drive(int drive, bool select) |
| 40 | void wangpc_state::select_drive() |
| 40 | 41 | { |
| 41 | | if (LOG) logerror("%s: %sselect drive %u\n", machine().describe_context(), select ? "" : "De", drive + 1); |
| 42 | floppy_image_device *floppy = NULL; |
| 42 | 43 | |
| 43 | | int state = select ? 0 : 1; |
| 44 | if (m_ds1) floppy = m_floppy0; |
| 45 | if (m_ds2) floppy = m_floppy1; |
| 44 | 46 | |
| 45 | | if (!drive) |
| 46 | | { |
| 47 | | m_ds1 = state; |
| 48 | | if(state) |
| 49 | | m_fdc->set_floppy(m_floppy0); |
| 50 | | } |
| 51 | | else |
| 52 | | { |
| 53 | | m_ds2 = state; |
| 54 | | if(state) |
| 55 | | m_fdc->set_floppy(m_floppy1); |
| 56 | | } |
| 57 | | if(!m_ds1 && !m_ds2) |
| 58 | | m_fdc->set_floppy(NULL); |
| 47 | m_fdc->set_floppy(floppy); |
| 59 | 48 | } |
| 60 | 49 | |
| 61 | | void wangpc_state::set_motor(int drive, bool motor) |
| 62 | | { |
| 63 | | if (LOG) logerror("%s: Motor %u %s\n", machine().describe_context(), drive + 1, motor ? "on" : "off"); |
| 64 | | |
| 65 | | int state = motor ? 0 : 1; |
| 66 | | |
| 67 | | if (!drive) |
| 68 | | { |
| 69 | | m_floppy0->mon_w(state); |
| 70 | | } |
| 71 | | else |
| 72 | | { |
| 73 | | m_floppy1->mon_w(state); |
| 74 | | } |
| 75 | | } |
| 76 | | |
| 77 | | void wangpc_state::fdc_reset() |
| 78 | | { |
| 79 | | if (LOG) logerror("%s: FDC reset\n", machine().describe_context()); |
| 80 | | |
| 81 | | m_fdc->reset(); |
| 82 | | } |
| 83 | | |
| 84 | | void wangpc_state::fdc_tc() |
| 85 | | { |
| 86 | | if (LOG) logerror("%s: FDC TC\n", machine().describe_context()); |
| 87 | | |
| 88 | | m_fdc->tc_w(true); |
| 89 | | m_fdc->tc_w(false); |
| 90 | | } |
| 91 | | |
| 92 | 50 | WRITE8_MEMBER( wangpc_state::fdc_ctrl_w ) |
| 93 | 51 | { |
| 94 | 52 | /* |
| r20152 | r20153 | |
| 125 | 83 | |
| 126 | 84 | READ8_MEMBER( wangpc_state::deselect_drive1_r ) |
| 127 | 85 | { |
| 128 | | select_drive(0, false); |
| 86 | m_ds1 = false; |
| 87 | select_drive(); |
| 129 | 88 | |
| 130 | 89 | return 0xff; |
| 131 | 90 | } |
| 132 | 91 | |
| 133 | | |
| 134 | 92 | WRITE8_MEMBER( wangpc_state::deselect_drive1_w ) |
| 135 | 93 | { |
| 136 | | select_drive(0, false); |
| 94 | deselect_drive1_r(space, offset); |
| 137 | 95 | } |
| 138 | 96 | |
| 139 | | |
| 140 | 97 | READ8_MEMBER( wangpc_state::select_drive1_r ) |
| 141 | 98 | { |
| 142 | | select_drive(0, true); |
| 99 | m_ds1 = true; |
| 100 | select_drive(); |
| 143 | 101 | |
| 144 | 102 | return 0xff; |
| 145 | 103 | } |
| 146 | 104 | |
| 147 | | |
| 148 | 105 | WRITE8_MEMBER( wangpc_state::select_drive1_w ) |
| 149 | 106 | { |
| 150 | | select_drive(0, true); |
| 107 | select_drive1_r(space, offset); |
| 151 | 108 | } |
| 152 | 109 | |
| 153 | | |
| 154 | 110 | READ8_MEMBER( wangpc_state::deselect_drive2_r ) |
| 155 | 111 | { |
| 156 | | select_drive(1, false); |
| 112 | m_ds2 = false; |
| 113 | select_drive(); |
| 157 | 114 | |
| 158 | 115 | return 0xff; |
| 159 | 116 | } |
| 160 | 117 | |
| 161 | | |
| 162 | 118 | WRITE8_MEMBER( wangpc_state::deselect_drive2_w ) |
| 163 | 119 | { |
| 164 | | select_drive(1, false); |
| 120 | deselect_drive2_r(space, offset); |
| 165 | 121 | } |
| 166 | 122 | |
| 167 | | |
| 168 | 123 | READ8_MEMBER( wangpc_state::select_drive2_r ) |
| 169 | 124 | { |
| 170 | | select_drive(1, true); |
| 125 | m_ds2 = true; |
| 126 | select_drive(); |
| 171 | 127 | |
| 172 | 128 | return 0xff; |
| 173 | 129 | } |
| 174 | 130 | |
| 175 | | |
| 176 | 131 | WRITE8_MEMBER( wangpc_state::select_drive2_w ) |
| 177 | 132 | { |
| 178 | | select_drive(1, true); |
| 133 | select_drive2_r(space, offset); |
| 179 | 134 | } |
| 180 | 135 | |
| 181 | | |
| 182 | 136 | READ8_MEMBER( wangpc_state::motor1_off_r ) |
| 183 | 137 | { |
| 184 | | set_motor(0, false); |
| 138 | if (LOG) logerror("%s: Drive 1 motor OFF\n", machine().describe_context()); |
| 185 | 139 | |
| 140 | m_floppy0->mon_w(1); |
| 141 | |
| 186 | 142 | return 0xff; |
| 187 | 143 | } |
| 188 | 144 | |
| 189 | | |
| 190 | 145 | WRITE8_MEMBER( wangpc_state::motor1_off_w ) |
| 191 | 146 | { |
| 192 | | set_motor(0, false); |
| 147 | motor1_off_r(space, offset); |
| 193 | 148 | } |
| 194 | 149 | |
| 195 | | |
| 196 | 150 | READ8_MEMBER( wangpc_state::motor1_on_r ) |
| 197 | 151 | { |
| 198 | | set_motor(0, true); |
| 152 | if (LOG) logerror("%s: Drive 1 motor ON\n", machine().describe_context()); |
| 199 | 153 | |
| 154 | m_floppy0->mon_w(0); |
| 155 | |
| 200 | 156 | return 0xff; |
| 201 | 157 | } |
| 202 | 158 | |
| 203 | | |
| 204 | 159 | WRITE8_MEMBER( wangpc_state::motor1_on_w ) |
| 205 | 160 | { |
| 206 | | set_motor(0, true); |
| 161 | motor1_on_r(space, offset); |
| 207 | 162 | } |
| 208 | 163 | |
| 209 | | |
| 210 | 164 | READ8_MEMBER( wangpc_state::motor2_off_r ) |
| 211 | 165 | { |
| 212 | | set_motor(1, false); |
| 166 | if (LOG) logerror("%s: Drive 2 motor OFF\n", machine().describe_context()); |
| 213 | 167 | |
| 168 | m_floppy1->mon_w(1); |
| 169 | |
| 214 | 170 | return 0xff; |
| 215 | 171 | } |
| 216 | 172 | |
| 217 | | |
| 218 | 173 | WRITE8_MEMBER( wangpc_state::motor2_off_w ) |
| 219 | 174 | { |
| 220 | | set_motor(1, false); |
| 175 | motor2_off_r(space, offset); |
| 221 | 176 | } |
| 222 | 177 | |
| 223 | | |
| 224 | 178 | READ8_MEMBER( wangpc_state::motor2_on_r ) |
| 225 | 179 | { |
| 226 | | set_motor(1, true); |
| 180 | if (LOG) logerror("%s: Drive 2 motor ON\n", machine().describe_context()); |
| 227 | 181 | |
| 182 | m_floppy1->mon_w(0); |
| 183 | |
| 228 | 184 | return 0xff; |
| 229 | 185 | } |
| 230 | 186 | |
| 231 | | |
| 232 | 187 | WRITE8_MEMBER( wangpc_state::motor2_on_w ) |
| 233 | 188 | { |
| 234 | | set_motor(1, true); |
| 189 | motor2_on_r(space, offset); |
| 235 | 190 | } |
| 236 | 191 | |
| 237 | | |
| 238 | 192 | READ8_MEMBER( wangpc_state::fdc_reset_r ) |
| 239 | 193 | { |
| 240 | | fdc_reset(); |
| 194 | if (LOG) logerror("%s: FDC reset\n", machine().describe_context()); |
| 241 | 195 | |
| 196 | m_fdc->reset(); |
| 197 | |
| 242 | 198 | return 0xff; |
| 243 | 199 | } |
| 244 | 200 | |
| 245 | | |
| 246 | 201 | WRITE8_MEMBER( wangpc_state::fdc_reset_w ) |
| 247 | 202 | { |
| 248 | | fdc_reset(); |
| 203 | fdc_reset_r(space, offset); |
| 249 | 204 | } |
| 250 | 205 | |
| 251 | | |
| 252 | 206 | READ8_MEMBER( wangpc_state::fdc_tc_r ) |
| 253 | 207 | { |
| 254 | | fdc_tc(); |
| 208 | if (LOG) logerror("%s: FDC TC\n", machine().describe_context()); |
| 255 | 209 | |
| 210 | m_fdc->tc_w(1); |
| 211 | m_fdc->tc_w(0); |
| 212 | |
| 256 | 213 | return 0xff; |
| 257 | 214 | } |
| 258 | 215 | |
| 259 | | |
| 260 | 216 | WRITE8_MEMBER( wangpc_state::fdc_tc_w ) |
| 261 | 217 | { |
| 262 | | fdc_tc(); |
| 218 | fdc_tc_r(space, offset); |
| 263 | 219 | } |
| 264 | 220 | |
| 265 | 221 | |
| 266 | | |
| 267 | 222 | //------------------------------------------------- |
| 268 | 223 | // dma_page_w - |
| 269 | 224 | //------------------------------------------------- |
| r20152 | r20153 | |
| 559 | 514 | UINT8 data = 0; |
| 560 | 515 | |
| 561 | 516 | // FDC interrupt |
| 562 | | data |= (m_fdc_dd0 | m_fdc_dd1 | (int) m_fdc->get_irq()) << 7; |
| 517 | data |= (m_fdc_dd0 || m_fdc_dd1 || (int) m_fdc->get_irq()) << 7; |
| 563 | 518 | |
| 564 | 519 | return data; |
| 565 | 520 | } |
| r20152 | r20153 | |
| 668 | 623 | if (m_enable_eop) |
| 669 | 624 | m_fdc->tc_w(m_fdc_tc); |
| 670 | 625 | else |
| 671 | | m_fdc->tc_w(false); |
| 626 | m_fdc->tc_w(0); |
| 672 | 627 | } |
| 673 | 628 | |
| 674 | 629 | WRITE_LINE_MEMBER( wangpc_state::hrq_w ) |
| r20152 | r20153 | |
| 682 | 637 | { |
| 683 | 638 | if (m_dack == 2) |
| 684 | 639 | { |
| 685 | | m_fdc_tc = !state; |
| 640 | m_fdc_tc = state; |
| 686 | 641 | update_fdc_tc(); |
| 687 | 642 | } |
| 688 | 643 | |
| 689 | | if (!state) |
| 644 | if (state) |
| 690 | 645 | { |
| 691 | 646 | if (LOG) logerror("EOP set\n"); |
| 692 | 647 | |
| r20152 | r20153 | |
| 1035 | 990 | SLOT_INTERFACE( "525dd", FLOPPY_525_DD ) |
| 1036 | 991 | SLOT_INTERFACE_END |
| 1037 | 992 | |
| 993 | FLOPPY_FORMATS_MEMBER( wangpc_state::floppy_formats ) |
| 994 | FLOPPY_PC_FORMAT |
| 995 | FLOPPY_FORMATS_END |
| 996 | |
| 1038 | 997 | void wangpc_state::fdc_irq(bool state) |
| 1039 | 998 | { |
| 1040 | 999 | if (LOG) logerror("FDC INT %u\n", state); |
| r20152 | r20153 | |
| 1242 | 1201 | MCFG_CPU_ADD(I8086_TAG, I8086, 8000000) |
| 1243 | 1202 | MCFG_CPU_PROGRAM_MAP(wangpc_mem) |
| 1244 | 1203 | MCFG_CPU_IO_MAP(wangpc_io) |
| 1204 | //MCFG_QUANTUM_PERFECT_CPU(I8086_TAG) |
| 1245 | 1205 | |
| 1246 | 1206 | // devices |
| 1247 | 1207 | MCFG_AM9517A_ADD(AM9517A_TAG, 4000000, dmac_intf) |
| r20152 | r20153 | |
| 1251 | 1211 | MCFG_IM6402_ADD(IM6402_TAG, uart_intf) |
| 1252 | 1212 | MCFG_MC2661_ADD(SCN2661_TAG, 0, epci_intf) |
| 1253 | 1213 | MCFG_UPD765A_ADD(UPD765_TAG, false, false) |
| 1254 | | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":0", wangpc_floppies, "525dd", 0, floppy_image_device::default_floppy_formats) |
| 1255 | | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":1", wangpc_floppies, "525dd", 0, floppy_image_device::default_floppy_formats) |
| 1214 | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":0", wangpc_floppies, "525dd", 0, wangpc_state::floppy_formats) |
| 1215 | MCFG_FLOPPY_DRIVE_ADD(UPD765_TAG ":1", wangpc_floppies, "525dd", 0, wangpc_state::floppy_formats) |
| 1256 | 1216 | MCFG_CENTRONICS_PRINTER_ADD(CENTRONICS_TAG, centronics_intf) |
| 1257 | 1217 | MCFG_WANGPC_KEYBOARD_ADD() |
| 1258 | 1218 | |