src/mess/drivers/bw2.c
| r9654 | r9655 | |
| 27 | 27 | |
| 28 | 28 | ***************************************************************************/ |
| 29 | 29 | |
| 30 | #define ADDRESS_MAP_MODERN |
| 31 | |
| 30 | 32 | #include "emu.h" |
| 31 | | #include "includes/bw2.h" |
| 32 | 33 | #include "cpu/z80/z80.h" |
| 34 | #include "devices/flopdrv.h" |
| 35 | #include "devices/messram.h" |
| 36 | #include "formats/basicdsk.h" |
| 33 | 37 | #include "machine/serial.h" |
| 34 | 38 | #include "machine/i8255a.h" |
| 35 | 39 | #include "machine/ctronics.h" |
| 36 | 40 | #include "machine/msm8251.h" |
| 37 | 41 | #include "machine/wd17xx.h" |
| 38 | 42 | #include "machine/pit8253.h" |
| 39 | | #include "devices/flopdrv.h" |
| 40 | | #include "formats/basicdsk.h" |
| 41 | 43 | #include "video/msm6255.h" |
| 42 | | #include "devices/messram.h" |
| 44 | #include "includes/bw2.h" |
| 43 | 45 | |
| 44 | | static running_device *get_floppy_image(running_machine *machine, int drive) |
| 46 | int bw2_state::get_ramdisk_size() |
| 45 | 47 | { |
| 46 | | return floppy_get_device(machine, drive); |
| 47 | | } |
| 48 | | |
| 49 | | static int get_ramdisk_size(running_machine *machine) |
| 50 | | { |
| 51 | 48 | return input_port_read(machine, "RAMCARD") * 256; |
| 52 | 49 | } |
| 53 | 50 | |
| 54 | 51 | /* Memory */ |
| 55 | 52 | |
| 56 | | static void bw2_set_banks(running_machine *machine, UINT8 data) |
| 53 | void bw2_state::bankswitch(UINT8 data) |
| 57 | 54 | { |
| 58 | 55 | /* |
| 59 | 56 | |
| r9654 | r9655 | |
| 68 | 65 | |
| 69 | 66 | */ |
| 70 | 67 | |
| 71 | | bw2_state *state = machine->driver_data<bw2_state>(); |
| 68 | address_space *program = cpu_get_address_space(m_maincpu, ADDRESS_SPACE_PROGRAM); |
| 72 | 69 | |
| 73 | 70 | int max_ram_bank = 0; |
| 74 | 71 | |
| 75 | | state->bank = data & 0x07; |
| 72 | m_bank = data & 0x07; |
| 76 | 73 | |
| 77 | | switch (messram_get_size(machine->device("messram"))) |
| 74 | switch (messram_get_size(m_ram)) |
| 78 | 75 | { |
| 79 | 76 | case 64 * 1024: |
| 80 | 77 | max_ram_bank = BANK_RAM1; |
| r9654 | r9655 | |
| 101 | 98 | break; |
| 102 | 99 | } |
| 103 | 100 | |
| 104 | | switch (state->bank) |
| 101 | switch (m_bank) |
| 105 | 102 | { |
| 106 | 103 | case BANK_RAM1: |
| 107 | | memory_install_readwrite_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank1"); |
| 104 | memory_install_readwrite_bank(program, 0x0000, 0x7fff, 0, 0, "bank1"); |
| 108 | 105 | break; |
| 109 | 106 | |
| 110 | 107 | case BANK_VRAM: |
| 111 | | memory_install_readwrite_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, "bank1"); |
| 108 | memory_install_readwrite_bank(program, 0x0000, 0x3fff, 0, 0x4000, "bank1"); |
| 112 | 109 | break; |
| 113 | 110 | |
| 114 | 111 | case BANK_RAM2: |
| r9654 | r9655 | |
| 116 | 113 | case BANK_RAM4: |
| 117 | 114 | case BANK_RAM5: |
| 118 | 115 | case BANK_RAM6: |
| 119 | | if (state->bank > max_ram_bank) |
| 116 | if (m_bank > max_ram_bank) |
| 120 | 117 | { |
| 121 | | memory_unmap_readwrite(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0); |
| 118 | memory_unmap_readwrite(program, 0x0000, 0x7fff, 0, 0); |
| 122 | 119 | } |
| 123 | 120 | else |
| 124 | 121 | { |
| 125 | | memory_install_readwrite_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank1"); |
| 122 | memory_install_readwrite_bank(program, 0x0000, 0x7fff, 0, 0, "bank1"); |
| 126 | 123 | } |
| 127 | 124 | break; |
| 128 | 125 | |
| 129 | 126 | case BANK_ROM: |
| 130 | | memory_install_read_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank1"); |
| 131 | | memory_unmap_write(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0); |
| 127 | memory_install_read_bank(program, 0x0000, 0x7fff, 0, 0, "bank1"); |
| 128 | memory_unmap_write(program, 0x0000, 0x7fff, 0, 0); |
| 132 | 129 | break; |
| 133 | 130 | } |
| 134 | 131 | |
| 135 | | memory_set_bank(machine, "bank1", state->bank); |
| 132 | memory_set_bank(machine, "bank1", m_bank); |
| 136 | 133 | } |
| 137 | 134 | |
| 138 | | static void ramcard_set_banks(running_machine *machine, UINT8 data) |
| 135 | void bw2_state::ramcard_bankswitch(UINT8 data) |
| 139 | 136 | { |
| 140 | 137 | /* |
| 141 | 138 | |
| r9654 | r9655 | |
| 150 | 147 | |
| 151 | 148 | */ |
| 152 | 149 | |
| 153 | | bw2_state *state = machine->driver_data<bw2_state>(); |
| 150 | address_space *program = cpu_get_address_space(m_maincpu, ADDRESS_SPACE_PROGRAM); |
| 154 | 151 | |
| 155 | 152 | int max_ram_bank = BANK_RAM1; |
| 156 | 153 | |
| 157 | | state->bank = data & 0x07; |
| 154 | m_bank = data & 0x07; |
| 158 | 155 | |
| 159 | | switch (messram_get_size(machine->device("messram"))) |
| 156 | switch (messram_get_size(m_ram)) |
| 160 | 157 | { |
| 161 | 158 | case 64 * 1024: |
| 162 | 159 | case 96 * 1024: |
| r9654 | r9655 | |
| 177 | 174 | break; |
| 178 | 175 | } |
| 179 | 176 | |
| 180 | | switch (state->bank) |
| 177 | switch (m_bank) |
| 181 | 178 | { |
| 182 | 179 | case BANK_RAM1: |
| 183 | 180 | case BANK_RAMCARD_RAM: |
| 184 | | memory_install_readwrite_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank1"); |
| 181 | memory_install_readwrite_bank(program, 0x0000, 0x7fff, 0, 0, "bank1"); |
| 185 | 182 | break; |
| 186 | 183 | |
| 187 | 184 | case BANK_VRAM: |
| 188 | | memory_install_readwrite_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, "bank1"); |
| 185 | memory_install_readwrite_bank(program, 0x0000, 0x3fff, 0, 0x4000, "bank1"); |
| 189 | 186 | break; |
| 190 | 187 | |
| 191 | 188 | case BANK_RAM3: |
| 192 | 189 | case BANK_RAM4: |
| 193 | 190 | case BANK_RAM6: |
| 194 | | if (state->bank > max_ram_bank) |
| 191 | if (m_bank > max_ram_bank) |
| 195 | 192 | { |
| 196 | | memory_unmap_readwrite(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0); |
| 193 | memory_unmap_readwrite(program, 0x0000, 0x7fff, 0, 0); |
| 197 | 194 | } |
| 198 | 195 | else |
| 199 | 196 | { |
| 200 | | memory_install_readwrite_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank1"); |
| 197 | memory_install_readwrite_bank(program, 0x0000, 0x7fff, 0, 0, "bank1"); |
| 201 | 198 | } |
| 202 | 199 | break; |
| 203 | 200 | |
| 204 | 201 | case BANK_RAMCARD_ROM: |
| 205 | | memory_install_read_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, "bank1"); |
| 206 | | memory_unmap_write(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000); |
| 202 | memory_install_read_bank(program, 0x0000, 0x3fff, 0, 0x4000, "bank1"); |
| 203 | memory_unmap_write(program, 0x0000, 0x3fff, 0, 0x4000); |
| 207 | 204 | break; |
| 208 | 205 | |
| 209 | 206 | case BANK_ROM: |
| 210 | | memory_install_read_bank(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank1"); |
| 211 | | memory_unmap_write(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0); |
| 207 | memory_install_read_bank(program, 0x0000, 0x7fff, 0, 0, "bank1"); |
| 208 | memory_unmap_write(program, 0x0000, 0x7fff, 0, 0); |
| 212 | 209 | break; |
| 213 | 210 | } |
| 214 | 211 | |
| 215 | | memory_set_bank(machine, "bank1", state->bank); |
| 212 | memory_set_bank(machine, "bank1", m_bank); |
| 216 | 213 | } |
| 217 | 214 | |
| 218 | | static WRITE8_HANDLER( ramcard_bank_w ) |
| 215 | WRITE8_MEMBER( bw2_state::ramcard_bank_w ) |
| 219 | 216 | { |
| 220 | | bw2_state *state = space->machine->driver_data<bw2_state>(); |
| 217 | address_space *program = cpu_get_address_space(m_maincpu, ADDRESS_SPACE_PROGRAM); |
| 221 | 218 | |
| 222 | 219 | UINT8 ramcard_bank = data & 0x0f; |
| 223 | 220 | UINT32 bank_offset = ramcard_bank * 0x8000; |
| 224 | 221 | |
| 225 | | if ((get_ramdisk_size(space->machine) == 256) && (ramcard_bank > 7)) |
| 222 | if ((get_ramdisk_size() == 256) && (ramcard_bank > 7)) |
| 226 | 223 | { |
| 227 | | memory_unmap_readwrite(cputag_get_address_space(space->machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0); |
| 224 | memory_unmap_readwrite(program, 0x0000, 0x7fff, 0, 0); |
| 228 | 225 | } |
| 229 | 226 | else |
| 230 | 227 | { |
| 231 | | memory_install_readwrite_bank(cputag_get_address_space(space->machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank1"); |
| 228 | memory_install_readwrite_bank(program, 0x0000, 0x7fff, 0, 0, "bank1"); |
| 232 | 229 | } |
| 233 | 230 | |
| 234 | | memory_configure_bank(space->machine, "bank1", BANK_RAMCARD_RAM, 1, state->ramcard_ram + bank_offset, 0); |
| 235 | | memory_set_bank(space->machine, "bank1", state->bank); |
| 231 | memory_configure_bank(machine, "bank1", BANK_RAMCARD_RAM, 1, m_ramcard_ram + bank_offset, 0); |
| 232 | memory_set_bank(machine, "bank1", m_bank); |
| 236 | 233 | } |
| 237 | 234 | |
| 238 | 235 | /* Floppy */ |
| 239 | | static WRITE_LINE_DEVICE_HANDLER( bw2_wd17xx_drq_w ) |
| 236 | |
| 237 | WRITE_LINE_MEMBER( bw2_state::fdc_drq_w ) |
| 240 | 238 | { |
| 241 | 239 | if (state) |
| 242 | 240 | { |
| 243 | | if (cpu_get_reg(device->machine->device(Z80_TAG), Z80_HALT)) |
| 244 | | cputag_set_input_line(device->machine, Z80_TAG, INPUT_LINE_NMI, HOLD_LINE); |
| 241 | if (cpu_get_reg(m_maincpu, Z80_HALT)) |
| 242 | { |
| 243 | cpu_set_input_line(m_maincpu, INPUT_LINE_NMI, HOLD_LINE); |
| 244 | } |
| 245 | 245 | } |
| 246 | 246 | else |
| 247 | 247 | { |
| 248 | | cputag_set_input_line(device->machine, Z80_TAG, INPUT_LINE_NMI, CLEAR_LINE); |
| 248 | cpu_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE); |
| 249 | 249 | } |
| 250 | 250 | } |
| 251 | 251 | |
| 252 | | static READ8_HANDLER( bw2_wd2797_r ) |
| 252 | READ8_MEMBER( bw2_state::fdc_r ) |
| 253 | 253 | { |
| 254 | | UINT8 result = 0xff; |
| 255 | | running_device *fdc = space->machine->device("wd179x"); |
| 254 | UINT8 data = 0xff; |
| 256 | 255 | |
| 257 | 256 | switch (offset & 0x03) |
| 258 | 257 | { |
| 259 | | case 0: |
| 260 | | result = wd17xx_status_r(fdc, 0); |
| 261 | | break; |
| 262 | | case 1: |
| 263 | | result = wd17xx_track_r(fdc, 0); |
| 264 | | break; |
| 265 | | case 2: |
| 266 | | result = wd17xx_sector_r(fdc, 0); |
| 267 | | break; |
| 268 | | case 3: |
| 269 | | result = wd17xx_data_r(fdc, 0); |
| 270 | | break; |
| 258 | case 0: |
| 259 | data = wd17xx_status_r(m_fdc, 0); |
| 260 | break; |
| 261 | case 1: |
| 262 | data = wd17xx_track_r(m_fdc, 0); |
| 263 | break; |
| 264 | case 2: |
| 265 | data = wd17xx_sector_r(m_fdc, 0); |
| 266 | break; |
| 267 | case 3: |
| 268 | data = wd17xx_data_r(m_fdc, 0); |
| 269 | break; |
| 271 | 270 | } |
| 272 | 271 | |
| 273 | | return result; |
| 272 | return data; |
| 274 | 273 | } |
| 275 | 274 | |
| 276 | | static WRITE8_HANDLER( bw2_wd2797_w ) |
| 275 | WRITE8_MEMBER( bw2_state::fdc_w ) |
| 277 | 276 | { |
| 278 | | running_device *fdc = space->machine->device("wd179x"); |
| 279 | 277 | switch (offset & 0x3) |
| 280 | 278 | { |
| 281 | | case 0: |
| 282 | | /* disk side is encoded in bit 1 of Type II/III commands */ |
| 279 | case 0: |
| 280 | /* disk side is encoded in bit 1 of Type II/III commands */ |
| 283 | 281 | |
| 284 | | if (BIT(data, 7)) |
| 282 | if (BIT(data, 7)) |
| 283 | { |
| 284 | if ((data & 0xf0) != 0xd0) |
| 285 | 285 | { |
| 286 | | if ((data & 0xf0) != 0xd0) |
| 287 | | { |
| 288 | | int side = BIT(data, 1); |
| 286 | int side = BIT(data, 1); |
| 289 | 287 | |
| 290 | | wd17xx_set_side(fdc,side); |
| 288 | wd17xx_set_side(m_fdc, side); |
| 291 | 289 | |
| 292 | | data &= ~0x02; |
| 293 | | } |
| 290 | data &= ~0x02; |
| 294 | 291 | } |
| 295 | | |
| 296 | | wd17xx_command_w(fdc, 0, data); |
| 297 | | |
| 298 | | break; |
| 299 | | case 1: |
| 300 | | wd17xx_track_w(fdc, 0, data); |
| 301 | | break; |
| 302 | | case 2: |
| 303 | | wd17xx_sector_w(fdc, 0, data); |
| 304 | | break; |
| 305 | | case 3: |
| 306 | | wd17xx_data_w(fdc, 0, data); |
| 307 | | break; |
| 308 | | }; |
| 309 | | } |
| 310 | | |
| 311 | | |
| 312 | | /* PPI */ |
| 313 | | |
| 314 | | static WRITE8_DEVICE_HANDLER( bw2_8255_a_w ) |
| 315 | | { |
| 316 | | running_device *fdc = device->machine->device("wd179x"); |
| 317 | | /* |
| 318 | | |
| 319 | | PA0 KB0 Keyboard line select 0 |
| 320 | | PA1 KB1 Keyboard line select 1 |
| 321 | | PA2 KB2 Keyboard line select 2 |
| 322 | | PA3 KB3 Keyboard line select 3 |
| 323 | | PA4 /DS0 Drive select 0 |
| 324 | | PA5 /DS1 Drive select 1 |
| 325 | | PA6 Select RS232 connector |
| 326 | | PA7 /STROBE to centronics printer |
| 327 | | |
| 328 | | */ |
| 329 | | |
| 330 | | bw2_state *state = device->machine->driver_data<bw2_state>(); |
| 331 | | |
| 332 | | state->keyboard_row = data & 0x0f; |
| 333 | | |
| 334 | | if (BIT(data, 4)) |
| 335 | | { |
| 336 | | state->selected_drive = 0; |
| 337 | | wd17xx_set_drive(fdc,state->selected_drive); |
| 338 | | } |
| 339 | | |
| 340 | | if (BIT(data, 5)) |
| 341 | | { |
| 342 | | state->selected_drive = 1; |
| 343 | | wd17xx_set_drive(fdc,state->selected_drive); |
| 344 | | } |
| 345 | | |
| 346 | | centronics_strobe_w(state->centronics, BIT(data, 7)); |
| 347 | | } |
| 348 | | |
| 349 | | static READ8_DEVICE_HANDLER( bw2_8255_b_r ) |
| 350 | | { |
| 351 | | /* |
| 352 | | |
| 353 | | PB0 Keyboard column status of selected line |
| 354 | | PB1 Keyboard column status of selected line |
| 355 | | PB2 Keyboard column status of selected line |
| 356 | | PB3 Keyboard column status of selected line |
| 357 | | PB4 Keyboard column status of selected line |
| 358 | | PB5 Keyboard column status of selected line |
| 359 | | PB6 Keyboard column status of selected line |
| 360 | | PB7 Keyboard column status of selected line |
| 361 | | |
| 362 | | */ |
| 363 | | |
| 364 | | bw2_state *state = device->machine->driver_data<bw2_state>(); |
| 365 | | |
| 366 | | UINT8 row; |
| 367 | | static const char *const rownames[] = { "ROW0", "ROW1", "ROW2", "ROW3", "ROW4", "ROW5", "ROW6", "ROW7", "ROW8", "ROW9" }; |
| 368 | | |
| 369 | | row = state->keyboard_row; |
| 370 | | |
| 371 | | if (row <= 9) |
| 372 | | return input_port_read(device->machine, rownames[row]); |
| 373 | | |
| 374 | | return 0xff; |
| 375 | | } |
| 376 | | |
| 377 | | static WRITE8_DEVICE_HANDLER( bw2_8255_c_w ) |
| 378 | | { |
| 379 | | /* |
| 380 | | |
| 381 | | PC0 Memory bank select |
| 382 | | PC1 Memory bank select |
| 383 | | PC2 Memory bank select |
| 384 | | PC3 Not connected |
| 385 | | |
| 386 | | */ |
| 387 | | |
| 388 | | if (get_ramdisk_size(device->machine) > 0) |
| 389 | | { |
| 390 | | ramcard_set_banks(device->machine, data & 0x07); |
| 391 | | } |
| 392 | | else |
| 393 | | { |
| 394 | | bw2_set_banks(device->machine, data & 0x07); |
| 395 | | } |
| 396 | | } |
| 397 | | |
| 398 | | static READ8_DEVICE_HANDLER( bw2_8255_c_r ) |
| 399 | | { |
| 400 | | /* |
| 401 | | |
| 402 | | PC4 BUSY from centronics printer |
| 403 | | PC5 M/FDBK motor feedback |
| 404 | | PC6 RLSD Carrier detect from RS232 |
| 405 | | PC7 /PROT Write protected disk |
| 406 | | |
| 407 | | */ |
| 408 | | |
| 409 | | bw2_state *state = device->machine->driver_data<bw2_state>(); |
| 410 | | |
| 411 | | UINT8 data = 0; |
| 412 | | |
| 413 | | data |= centronics_busy_r(state->centronics) << 4; |
| 414 | | data |= state->mfdbk << 5; |
| 415 | | |
| 416 | | data |= floppy_wpt_r(get_floppy_image(device->machine, state->selected_drive)) << 7; |
| 417 | | |
| 418 | | return data; |
| 419 | | } |
| 420 | | |
| 421 | | static I8255A_INTERFACE( bw2_8255_interface ) |
| 422 | | { |
| 423 | | DEVCB_NULL, |
| 424 | | DEVCB_HANDLER(bw2_8255_b_r), |
| 425 | | DEVCB_HANDLER(bw2_8255_c_r), |
| 426 | | DEVCB_HANDLER(bw2_8255_a_w), |
| 427 | | DEVCB_NULL, |
| 428 | | DEVCB_HANDLER(bw2_8255_c_w), |
| 429 | | }; |
| 430 | | |
| 431 | | /* PIT */ |
| 432 | | |
| 433 | | static WRITE_LINE_DEVICE_HANDLER( bw2_timer0_w ) |
| 434 | | { |
| 435 | | bw2_state *driver_state = device->machine->driver_data<bw2_state>(); |
| 436 | | |
| 437 | | msm8251_transmit_clock(driver_state->msm8251); |
| 438 | | msm8251_receive_clock(driver_state->msm8251); |
| 439 | | } |
| 440 | | |
| 441 | | static WRITE_LINE_DEVICE_HANDLER( bw2_timer2_w ) |
| 442 | | { |
| 443 | | bw2_state *driver_state = device->machine->driver_data<bw2_state>(); |
| 444 | | |
| 445 | | driver_state->mtron = state; |
| 446 | | driver_state->mfdbk = !state; |
| 447 | | |
| 448 | | floppy_mon_w(get_floppy_image(device->machine, 0), driver_state->mtron); |
| 449 | | floppy_mon_w(get_floppy_image(device->machine, 1), driver_state->mtron); |
| 450 | | |
| 451 | | floppy_drive_set_ready_state(get_floppy_image(device->machine, 0), 1, 1); |
| 452 | | floppy_drive_set_ready_state(get_floppy_image(device->machine, 1), 1, 1); |
| 453 | | } |
| 454 | | |
| 455 | | static const struct pit8253_config bw2_pit8253_interface = |
| 456 | | { |
| 457 | | { |
| 458 | | { |
| 459 | | XTAL_4MHz, /* 8251 USART TXC, RXC */ |
| 460 | | DEVCB_LINE_VCC, |
| 461 | | DEVCB_LINE(bw2_timer0_w) |
| 462 | | }, |
| 463 | | { |
| 464 | | 11000, /* LCD controller */ |
| 465 | | DEVCB_LINE_VCC, |
| 466 | | DEVCB_LINE(pit8253_clk2_w) |
| 467 | | }, |
| 468 | | { |
| 469 | | 0, /* Floppy /MTRON */ |
| 470 | | DEVCB_LINE_VCC, |
| 471 | | DEVCB_LINE(bw2_timer2_w) |
| 472 | 292 | } |
| 473 | | } |
| 474 | | }; |
| 475 | 293 | |
| 294 | wd17xx_command_w(m_fdc, 0, data); |
| 295 | break; |
| 476 | 296 | |
| 477 | | /* Video */ |
| 297 | case 1: |
| 298 | wd17xx_track_w(m_fdc, 0, data); |
| 299 | break; |
| 478 | 300 | |
| 479 | | static PALETTE_INIT( bw2 ) |
| 480 | | { |
| 481 | | palette_set_color_rgb(machine, 0, 0xa5, 0xad, 0xa5); |
| 482 | | palette_set_color_rgb(machine, 1, 0x31, 0x39, 0x10); |
| 483 | | } |
| 301 | case 2: |
| 302 | wd17xx_sector_w(m_fdc, 0, data); |
| 303 | break; |
| 484 | 304 | |
| 485 | | static VIDEO_START( bw2 ) |
| 486 | | { |
| 305 | case 3: |
| 306 | wd17xx_data_w(m_fdc, 0, data); |
| 307 | break; |
| 308 | }; |
| 487 | 309 | } |
| 488 | 310 | |
| 489 | | static VIDEO_UPDATE( bw2 ) |
| 490 | | { |
| 491 | | bw2_state *state = screen->machine->driver_data<bw2_state>(); |
| 492 | | |
| 493 | | msm6255_update(state->msm6255, bitmap, cliprect); |
| 494 | | |
| 495 | | return 0; |
| 496 | | } |
| 497 | | |
| 498 | | /* Machine */ |
| 499 | | |
| 500 | | static DRIVER_INIT( bw2 ) |
| 501 | | { |
| 502 | | bw2_state *state = machine->driver_data<bw2_state>(); |
| 503 | | |
| 504 | | /* allocate work memory */ |
| 505 | | state->work_ram = auto_alloc_array(machine, UINT8, messram_get_size(machine->device("messram"))); |
| 506 | | |
| 507 | | /* allocate video memory */ |
| 508 | | state->video_ram = auto_alloc_array(machine, UINT8, BW2_VIDEORAM_SIZE); |
| 509 | | |
| 510 | | /* allocate RAMcard memory */ |
| 511 | | state->ramcard_ram = auto_alloc_array(machine, UINT8, BW2_RAMCARD_SIZE); |
| 512 | | } |
| 513 | | |
| 514 | | static MACHINE_START( bw2 ) |
| 515 | | { |
| 516 | | bw2_state *state = machine->driver_data<bw2_state>(); |
| 517 | | |
| 518 | | /* find devices */ |
| 519 | | state->msm8251 = machine->device(MSM8251_TAG); |
| 520 | | state->msm6255 = machine->device(MSM6255_TAG); |
| 521 | | state->centronics = machine->device(CENTRONICS_TAG); |
| 522 | | |
| 523 | | /* memory banking */ |
| 524 | | memory_configure_bank(machine, "bank1", BANK_RAM1, 1, state->work_ram, 0); |
| 525 | | memory_configure_bank(machine, "bank1", BANK_VRAM, 1, state->video_ram, 0); |
| 526 | | memory_configure_bank(machine, "bank1", BANK_ROM, 1, memory_region(machine, "ic1"), 0); |
| 527 | | |
| 528 | | /* register for state saving */ |
| 529 | | state_save_register_global(machine, state->keyboard_row); |
| 530 | | state_save_register_global_pointer(machine, state->work_ram, messram_get_size(machine->device("messram"))); |
| 531 | | state_save_register_global_pointer(machine, state->ramcard_ram, BW2_RAMCARD_SIZE); |
| 532 | | state_save_register_global(machine, state->bank); |
| 533 | | state_save_register_global(machine, state->selected_drive); |
| 534 | | state_save_register_global(machine, state->mtron); |
| 535 | | state_save_register_global(machine, state->mfdbk); |
| 536 | | state_save_register_global_pointer(machine, state->video_ram, BW2_VIDEORAM_SIZE); |
| 537 | | } |
| 538 | | |
| 539 | | static MACHINE_RESET( bw2 ) |
| 540 | | { |
| 541 | | bw2_state *state = machine->driver_data<bw2_state>(); |
| 542 | | |
| 543 | | if (get_ramdisk_size(machine) > 0) |
| 544 | | { |
| 545 | | // RAMCARD installed |
| 546 | | |
| 547 | | memory_configure_bank(machine, "bank1", BANK_RAMCARD_ROM, 1, memory_region(machine, "ramcard"), 0); |
| 548 | | memory_configure_bank(machine, "bank1", BANK_RAM3, 2, state->work_ram + 0x8000, 0x8000); |
| 549 | | memory_configure_bank(machine, "bank1", BANK_RAMCARD_RAM, 1, state->ramcard_ram, 0); |
| 550 | | memory_configure_bank(machine, "bank1", BANK_RAM6, 1, state->work_ram + 0x18000, 0); |
| 551 | | |
| 552 | | memory_install_write8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_IO), 0x30, 0x30, 0, 0x0f, &ramcard_bank_w); |
| 553 | | } |
| 554 | | else |
| 555 | | { |
| 556 | | // no RAMCARD |
| 557 | | |
| 558 | | memory_configure_bank(machine, "bank1", BANK_RAM2, 5, state->work_ram + 0x8000, 0x8000); |
| 559 | | |
| 560 | | memory_unmap_write(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_IO), 0x30, 0x30, 0, 0x0f); |
| 561 | | } |
| 562 | | |
| 563 | | memory_set_bank(machine, "bank1", BANK_ROM); |
| 564 | | } |
| 565 | | |
| 566 | | static ADDRESS_MAP_START( bw2_mem, ADDRESS_SPACE_PROGRAM, 8 ) |
| 311 | static ADDRESS_MAP_START( bw2_mem, ADDRESS_SPACE_PROGRAM, 8, bw2_state ) |
| 567 | 312 | ADDRESS_MAP_UNMAP_HIGH |
| 568 | 313 | AM_RANGE(0x0000, 0x7fff) AM_RAMBANK("bank1") |
| 569 | 314 | AM_RANGE(0x8000, 0xffff) AM_RAM |
| 570 | 315 | ADDRESS_MAP_END |
| 571 | 316 | |
| 572 | | static ADDRESS_MAP_START( bw2_io, ADDRESS_SPACE_IO, 8 ) |
| 317 | static ADDRESS_MAP_START( bw2_io, ADDRESS_SPACE_IO, 8, bw2_state ) |
| 573 | 318 | ADDRESS_MAP_UNMAP_HIGH |
| 574 | 319 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 575 | | AM_RANGE( 0x00, 0x03 ) AM_DEVREADWRITE(I8255A_TAG, i8255a_r, i8255a_w ) |
| 576 | | AM_RANGE( 0x10, 0x13 ) AM_DEVREADWRITE(PIT8253_TAG, pit8253_r, pit8253_w ) |
| 577 | | AM_RANGE( 0x20, 0x21 ) AM_DEVREADWRITE(MSM6255_TAG, msm6255_register_r, msm6255_register_w ) |
| 320 | AM_RANGE( 0x00, 0x03 ) AM_DEVREADWRITE_LEGACY(I8255A_TAG, i8255a_r, i8255a_w ) |
| 321 | AM_RANGE( 0x10, 0x13 ) AM_DEVREADWRITE_LEGACY(PIT8253_TAG, pit8253_r, pit8253_w ) |
| 322 | AM_RANGE( 0x20, 0x21 ) AM_DEVREADWRITE_LEGACY(MSM6255_TAG, msm6255_register_r, msm6255_register_w ) |
| 578 | 323 | // AM_RANGE( 0x30, 0x3f ) SLOT |
| 579 | | AM_RANGE( 0x40, 0x40 ) AM_DEVREADWRITE( MSM8251_TAG, msm8251_data_r, msm8251_data_w ) |
| 580 | | AM_RANGE( 0x41, 0x41 ) AM_DEVREADWRITE( MSM8251_TAG, msm8251_status_r, msm8251_control_w ) |
| 581 | | AM_RANGE( 0x50, 0x50 ) AM_DEVWRITE(CENTRONICS_TAG, centronics_data_w) |
| 582 | | AM_RANGE( 0x60, 0x63 ) AM_READWRITE( bw2_wd2797_r, bw2_wd2797_w ) |
| 324 | AM_RANGE( 0x40, 0x40 ) AM_DEVREADWRITE_LEGACY( MSM8251_TAG, msm8251_data_r, msm8251_data_w ) |
| 325 | AM_RANGE( 0x41, 0x41 ) AM_DEVREADWRITE_LEGACY( MSM8251_TAG, msm8251_status_r, msm8251_control_w ) |
| 326 | AM_RANGE( 0x50, 0x50 ) AM_DEVWRITE_LEGACY(CENTRONICS_TAG, centronics_data_w) |
| 327 | AM_RANGE( 0x60, 0x63 ) AM_READWRITE(fdc_r, fdc_w) |
| 583 | 328 | // AM_RANGE( 0x70, 0x7f ) MODEMSEL |
| 584 | 329 | ADDRESS_MAP_END |
| 585 | 330 | |
| r9654 | r9655 | |
| 726 | 471 | PORT_CONFSETTING( 0x02, "512 KB" ) |
| 727 | 472 | INPUT_PORTS_END |
| 728 | 473 | |
| 474 | /* PPI */ |
| 475 | |
| 476 | WRITE8_MEMBER( bw2_state::ppi_pa_w ) |
| 477 | { |
| 478 | /* |
| 479 | |
| 480 | PA0 KB0 Keyboard line select 0 |
| 481 | PA1 KB1 Keyboard line select 1 |
| 482 | PA2 KB2 Keyboard line select 2 |
| 483 | PA3 KB3 Keyboard line select 3 |
| 484 | PA4 /DS0 Drive select 0 |
| 485 | PA5 /DS1 Drive select 1 |
| 486 | PA6 Select RS232 connector |
| 487 | PA7 /STROBE to centronics printer |
| 488 | |
| 489 | */ |
| 490 | |
| 491 | m_kb_row = data & 0x0f; |
| 492 | |
| 493 | if (BIT(data, 4)) |
| 494 | { |
| 495 | m_drive = 0; |
| 496 | |
| 497 | wd17xx_set_drive(m_fdc, m_drive); |
| 498 | } |
| 499 | |
| 500 | if (BIT(data, 5)) |
| 501 | { |
| 502 | m_drive = 1; |
| 503 | |
| 504 | wd17xx_set_drive(m_fdc, m_drive); |
| 505 | } |
| 506 | |
| 507 | centronics_strobe_w(m_centronics, BIT(data, 7)); |
| 508 | } |
| 509 | |
| 510 | READ8_MEMBER( bw2_state::ppi_pb_r ) |
| 511 | { |
| 512 | /* |
| 513 | |
| 514 | PB0 Keyboard column status of selected line |
| 515 | PB1 Keyboard column status of selected line |
| 516 | PB2 Keyboard column status of selected line |
| 517 | PB3 Keyboard column status of selected line |
| 518 | PB4 Keyboard column status of selected line |
| 519 | PB5 Keyboard column status of selected line |
| 520 | PB6 Keyboard column status of selected line |
| 521 | PB7 Keyboard column status of selected line |
| 522 | |
| 523 | */ |
| 524 | |
| 525 | static const char *const rownames[] = { "ROW0", "ROW1", "ROW2", "ROW3", "ROW4", "ROW5", "ROW6", "ROW7", "ROW8", "ROW9" }; |
| 526 | |
| 527 | UINT8 data = 0xff; |
| 528 | |
| 529 | if (m_kb_row <= 9) |
| 530 | { |
| 531 | data = input_port_read(machine, rownames[m_kb_row]); |
| 532 | } |
| 533 | |
| 534 | return data; |
| 535 | } |
| 536 | |
| 537 | WRITE8_MEMBER( bw2_state::ppi_pc_w ) |
| 538 | { |
| 539 | /* |
| 540 | |
| 541 | PC0 Memory bank select |
| 542 | PC1 Memory bank select |
| 543 | PC2 Memory bank select |
| 544 | PC3 Not connected |
| 545 | |
| 546 | */ |
| 547 | |
| 548 | if (get_ramdisk_size() > 0) |
| 549 | { |
| 550 | ramcard_bankswitch(data & 0x07); |
| 551 | } |
| 552 | else |
| 553 | { |
| 554 | bankswitch(data & 0x07); |
| 555 | } |
| 556 | } |
| 557 | |
| 558 | READ8_MEMBER( bw2_state::ppi_pc_r ) |
| 559 | { |
| 560 | /* |
| 561 | |
| 562 | PC4 BUSY from centronics printer |
| 563 | PC5 M/FDBK motor feedback |
| 564 | PC6 RLSD Carrier detect from RS232 |
| 565 | PC7 /PROT Write protected disk |
| 566 | |
| 567 | */ |
| 568 | |
| 569 | UINT8 data = 0; |
| 570 | |
| 571 | data |= centronics_busy_r(m_centronics) << 4; |
| 572 | data |= m_mfdbk << 5; |
| 573 | |
| 574 | data |= floppy_wpt_r(m_drive ? m_floppy1 : m_floppy0) << 7; |
| 575 | |
| 576 | return data; |
| 577 | } |
| 578 | |
| 579 | static I8255A_INTERFACE( ppi_intf ) |
| 580 | { |
| 581 | DEVCB_NULL, |
| 582 | DEVCB_DRIVER_MEMBER(bw2_state, ppi_pb_r), |
| 583 | DEVCB_DRIVER_MEMBER(bw2_state, ppi_pc_r), |
| 584 | DEVCB_DRIVER_MEMBER(bw2_state, ppi_pa_w), |
| 585 | DEVCB_NULL, |
| 586 | DEVCB_DRIVER_MEMBER(bw2_state, ppi_pc_w), |
| 587 | }; |
| 588 | |
| 589 | /* PIT */ |
| 590 | |
| 591 | WRITE_LINE_MEMBER( bw2_state::pit_out0_w ) |
| 592 | { |
| 593 | msm8251_transmit_clock(m_uart); |
| 594 | msm8251_receive_clock(m_uart); |
| 595 | } |
| 596 | |
| 597 | WRITE_LINE_MEMBER( bw2_state::mtron_w ) |
| 598 | { |
| 599 | m_mtron = state; |
| 600 | m_mfdbk = !state; |
| 601 | |
| 602 | floppy_mon_w(m_floppy0, m_mtron); |
| 603 | floppy_mon_w(m_floppy1, m_mtron); |
| 604 | |
| 605 | floppy_drive_set_ready_state(m_floppy0, 1, 1); |
| 606 | floppy_drive_set_ready_state(m_floppy1, 1, 1); |
| 607 | } |
| 608 | |
| 609 | static const struct pit8253_config bw2_pit8253_interface = |
| 610 | { |
| 611 | { |
| 612 | { |
| 613 | XTAL_4MHz, /* 8251 USART TXC, RXC */ |
| 614 | DEVCB_LINE_VCC, |
| 615 | DEVCB_DRIVER_LINE_MEMBER(bw2_state, pit_out0_w) |
| 616 | }, |
| 617 | { |
| 618 | 11000, /* LCD controller */ |
| 619 | DEVCB_LINE_VCC, |
| 620 | DEVCB_LINE(pit8253_clk2_w) |
| 621 | }, |
| 622 | { |
| 623 | 0, /* Floppy /MTRON */ |
| 624 | DEVCB_LINE_VCC, |
| 625 | DEVCB_DRIVER_LINE_MEMBER(bw2_state, mtron_w) |
| 626 | } |
| 627 | } |
| 628 | }; |
| 629 | |
| 630 | |
| 631 | /* Video */ |
| 632 | |
| 633 | static PALETTE_INIT( bw2 ) |
| 634 | { |
| 635 | palette_set_color_rgb(machine, 0, 0xa5, 0xad, 0xa5); |
| 636 | palette_set_color_rgb(machine, 1, 0x31, 0x39, 0x10); |
| 637 | } |
| 638 | |
| 639 | bool bw2_state::video_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 640 | { |
| 641 | msm6255_update(m_lcdc, &bitmap, &cliprect); |
| 642 | |
| 643 | return 0; |
| 644 | } |
| 645 | |
| 729 | 646 | static MSM6255_CHAR_RAM_READ( bw2_charram_r ) |
| 730 | 647 | { |
| 731 | 648 | bw2_state *state = device->machine->driver_data<bw2_state>(); |
| 732 | 649 | |
| 733 | | return state->video_ram[ma & 0x3fff]; |
| 650 | return state->m_video_ram[ma & 0x3fff]; |
| 734 | 651 | } |
| 735 | 652 | |
| 736 | 653 | static MSM6255_INTERFACE( bw2_msm6255_intf ) |
| r9654 | r9655 | |
| 771 | 688 | { |
| 772 | 689 | DEVCB_LINE_GND, |
| 773 | 690 | DEVCB_CPU_INPUT_LINE(Z80_TAG, INPUT_LINE_IRQ0), |
| 774 | | DEVCB_LINE(bw2_wd17xx_drq_w), |
| 775 | | {FLOPPY_0, FLOPPY_1, NULL, NULL} |
| 691 | DEVCB_DRIVER_LINE_MEMBER(bw2_state, fdc_drq_w), |
| 692 | { FLOPPY_0, FLOPPY_1, NULL, NULL } |
| 776 | 693 | }; |
| 777 | 694 | |
| 778 | 695 | /* Serial */ |
| r9654 | r9655 | |
| 785 | 702 | { |
| 786 | 703 | serial_device_setup(image, 9600 >> input_port_read(image.device().machine, "BAUD"), 8, 1, SERIAL_PARITY_NONE); |
| 787 | 704 | |
| 788 | | msm8251_connect_to_serial_device(state->msm8251, image); |
| 705 | msm8251_connect_to_serial_device(state->m_uart, image); |
| 789 | 706 | |
| 790 | 707 | serial_device_set_transmit_state(image, 1); |
| 791 | 708 | |
| r9654 | r9655 | |
| 795 | 712 | return IMAGE_INIT_FAIL; |
| 796 | 713 | } |
| 797 | 714 | |
| 798 | | |
| 799 | 715 | DEVICE_GET_INFO( bw2_serial ) |
| 800 | 716 | { |
| 801 | 717 | switch ( state ) |
| r9654 | r9655 | |
| 813 | 729 | DECLARE_LEGACY_IMAGE_DEVICE(BW2_SERIAL, bw2_serial); |
| 814 | 730 | DEFINE_LEGACY_IMAGE_DEVICE(BW2_SERIAL, bw2_serial); |
| 815 | 731 | |
| 732 | /* Machine */ |
| 733 | |
| 734 | void bw2_state::machine_start() |
| 735 | { |
| 736 | /* allocate memory */ |
| 737 | m_work_ram = auto_alloc_array(machine, UINT8, messram_get_size(m_ram)); |
| 738 | m_video_ram = auto_alloc_array(machine, UINT8, BW2_VIDEORAM_SIZE); |
| 739 | m_ramcard_ram = auto_alloc_array(machine, UINT8, BW2_RAMCARD_SIZE); |
| 740 | |
| 741 | /* memory banking */ |
| 742 | memory_configure_bank(machine, "bank1", BANK_RAM1, 1, m_work_ram, 0); |
| 743 | memory_configure_bank(machine, "bank1", BANK_VRAM, 1, m_video_ram, 0); |
| 744 | memory_configure_bank(machine, "bank1", BANK_ROM, 1, memory_region(machine, "ic1"), 0); |
| 745 | |
| 746 | /* register for state saving */ |
| 747 | state_save_register_global(machine, m_kb_row); |
| 748 | state_save_register_global_pointer(machine, m_work_ram, messram_get_size(m_ram)); |
| 749 | state_save_register_global_pointer(machine, m_ramcard_ram, BW2_RAMCARD_SIZE); |
| 750 | state_save_register_global(machine, m_bank); |
| 751 | state_save_register_global(machine, m_drive); |
| 752 | state_save_register_global(machine, m_mtron); |
| 753 | state_save_register_global(machine, m_mfdbk); |
| 754 | state_save_register_global_pointer(machine, m_video_ram, BW2_VIDEORAM_SIZE); |
| 755 | } |
| 756 | |
| 757 | void bw2_state::machine_reset() |
| 758 | { |
| 759 | address_space *io = cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_IO); |
| 760 | |
| 761 | if (get_ramdisk_size() > 0) |
| 762 | { |
| 763 | // RAMCARD installed |
| 764 | |
| 765 | memory_configure_bank(machine, "bank1", BANK_RAMCARD_ROM, 1, memory_region(machine, "ramcard"), 0); |
| 766 | memory_configure_bank(machine, "bank1", BANK_RAM3, 2, m_work_ram + 0x8000, 0x8000); |
| 767 | memory_configure_bank(machine, "bank1", BANK_RAMCARD_RAM, 1, m_ramcard_ram, 0); |
| 768 | memory_configure_bank(machine, "bank1", BANK_RAM6, 1, m_work_ram + 0x18000, 0); |
| 769 | |
| 770 | io->install_handler(0x30, 0x30, 0, 0x0f, write8_delegate_create(bw2_state, ramcard_bank_w, *this), 0); |
| 771 | } |
| 772 | else |
| 773 | { |
| 774 | // no RAMCARD |
| 775 | |
| 776 | memory_configure_bank(machine, "bank1", BANK_RAM2, 5, m_work_ram + 0x8000, 0x8000); |
| 777 | |
| 778 | memory_unmap_write(io, 0x30, 0x30, 0, 0x0f); |
| 779 | } |
| 780 | |
| 781 | memory_set_bank(machine, "bank1", BANK_ROM); |
| 782 | } |
| 783 | |
| 816 | 784 | #define MDRV_BW2_SERIAL_ADD(_tag) \ |
| 817 | 785 | MDRV_DEVICE_ADD(_tag, BW2_SERIAL, 0) |
| 818 | 786 | |
| 819 | | |
| 820 | 787 | static MACHINE_CONFIG_START( bw2, bw2_state ) |
| 821 | | |
| 822 | 788 | /* basic machine hardware */ |
| 823 | 789 | MDRV_CPU_ADD( Z80_TAG, Z80, XTAL_16MHz/4 ) |
| 824 | 790 | MDRV_CPU_PROGRAM_MAP( bw2_mem) |
| 825 | 791 | MDRV_CPU_IO_MAP( bw2_io) |
| 826 | 792 | |
| 827 | | MDRV_MACHINE_START( bw2 ) |
| 828 | | MDRV_MACHINE_RESET( bw2 ) |
| 829 | | |
| 830 | 793 | MDRV_PIT8253_ADD( PIT8253_TAG, bw2_pit8253_interface ) |
| 831 | | MDRV_I8255A_ADD( I8255A_TAG, bw2_8255_interface ) |
| 794 | MDRV_I8255A_ADD( I8255A_TAG, ppi_intf ) |
| 832 | 795 | |
| 833 | 796 | /* video hardware */ |
| 834 | 797 | MDRV_SCREEN_ADD( SCREEN_TAG, LCD ) |
| r9654 | r9655 | |
| 840 | 803 | |
| 841 | 804 | MDRV_PALETTE_LENGTH( 2 ) |
| 842 | 805 | MDRV_PALETTE_INIT( bw2 ) |
| 843 | | MDRV_VIDEO_START( bw2 ) |
| 844 | | MDRV_VIDEO_UPDATE( bw2 ) |
| 845 | 806 | |
| 846 | 807 | MDRV_MSM6255_ADD(MSM6255_TAG, XTAL_16MHz, bw2_msm6255_intf) |
| 847 | 808 | |
| r9654 | r9655 | |
| 851 | 812 | /* uart */ |
| 852 | 813 | MDRV_MSM8251_ADD(MSM8251_TAG, default_msm8251_interface) |
| 853 | 814 | |
| 854 | | MDRV_WD179X_ADD("wd179x", bw2_wd17xx_interface ) |
| 815 | MDRV_WD179X_ADD(WD2797_TAG, bw2_wd17xx_interface ) |
| 855 | 816 | |
| 856 | 817 | MDRV_FLOPPY_2_DRIVES_ADD(bw2_floppy_config) |
| 857 | 818 | MDRV_SOFTWARE_LIST_ADD("flop_list","bw2") |
| r9654 | r9655 | |
| 882 | 843 | ROM_END |
| 883 | 844 | |
| 884 | 845 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 885 | | COMP( 1985, bw2, 0, 0, bw2, bw2, bw2, "Bondwell Holding", "Bondwell Model 2", GAME_NO_SOUND ) |
| 846 | COMP( 1985, bw2, 0, 0, bw2, bw2, 0, "Bondwell Holding", "Bondwell Model 2", GAME_NO_SOUND ) |