trunk/src/lib/formats/comx35_dsk.c
| r19197 | r19198 | |
| 1 | /*************************************************************************** |
| 2 | |
| 3 | Copyright Olivier Galibert |
| 4 | All rights reserved. |
| 5 | |
| 6 | Redistribution and use in source and binary forms, with or without |
| 7 | modification, are permitted provided that the following conditions are |
| 8 | met: |
| 9 | |
| 10 | * Redistributions of source code must retain the above copyright |
| 11 | notice, this list of conditions and the following disclaimer. |
| 12 | * Redistributions in binary form must reproduce the above copyright |
| 13 | notice, this list of conditions and the following disclaimer in |
| 14 | the documentation and/or other materials provided with the |
| 15 | distribution. |
| 16 | * Neither the name 'MAME' nor the names of its contributors may be |
| 17 | used to endorse or promote products derived from this software |
| 18 | without specific prior written permission. |
| 19 | |
| 20 | THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR |
| 21 | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| 22 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| 23 | DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT, |
| 24 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| 25 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| 26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 27 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| 28 | STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING |
| 29 | IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| 30 | POSSIBILITY OF SUCH DAMAGE. |
| 31 | |
| 32 | ****************************************************************************/ |
| 33 | |
| 1 | 34 | /********************************************************************* |
| 2 | 35 | |
| 3 | 36 | formats/comx35_dsk.c |
| r19197 | r19198 | |
| 2 | 35 | |
| 36 | COMX-35 disk image format |
| 37 | |
| 38 | *********************************************************************/ |
| 39 | |
| 40 | /* |
| 41 | |
| 42 | TODO: |
| 43 | |
| 44 | - implement 70 track image detection |
| 45 | |
| 46 | */ |
| 47 | |
| 48 | #include "emu.h" |
| 49 | #include "formats/comx35_dsk.h" |
| 50 | |
| 51 | comx35_format::comx35_format() : wd177x_format(formats) |
| 52 | { |
| 53 | } |
| 54 | |
| 55 | const char *comx35_format::name() const |
| 56 | { |
| 57 | return "comx35"; |
| 58 | } |
| 59 | |
| 60 | const char *comx35_format::description() const |
| 61 | { |
| 62 | return "COMX-35 disk image"; |
| 63 | } |
| 64 | |
| 65 | const char *comx35_format::extensions() const |
| 66 | { |
| 67 | return "img"; |
| 68 | } |
| 69 | |
| 70 | // Unverified gap sizes |
| 71 | const comx35_format::format comx35_format::formats[] = { |
| 72 | { // 70K 5 1/4 inch single density single sided 35 tracks |
| 73 | floppy_image::FF_525, floppy_image::SSSD, |
| 74 | 2000, 16, 35, 1, 128, {}, 0, {}, 100, 22, 84 |
| 75 | }, |
| 76 | { // 140K 5 1/4 inch single density double sided 35 tracks |
| 77 | floppy_image::FF_525, floppy_image::DSSD, |
| 78 | 2000, 16, 35, 2, 128, {}, 0, {}, 100, 22, 84 |
| 79 | }, |
| 80 | /*{ // 140K 5 1/4 inch quad density single sided 70 tracks |
| 81 | floppy_image::FF_525, floppy_image::SSQD, |
| 82 | 2000, 16, 70, 1, 128, {}, 0, {}, 100, 22, 84 |
| 83 | },*/ |
| 84 | {} |
| 85 | }; |
| 86 | |
| 87 | const floppy_format_type FLOPPY_COMX35_FORMAT = &floppy_image_format_creator<comx35_format>; |
| 88 | |
| 89 | |
| 90 | #ifdef UNUSED_CODE |
| 91 | |
| 92 | /********************************************************************* |
| 93 | |
| 94 | formats/comx35_dsk.c |
| 95 | |
| 3 | 96 | COMX35 disk images |
| r19197 | r19198 | |
| 76 | 169 | LEGACY_FLOPPY_OPTIONS_START( comx35 ) |
| 77 | 170 | LEGACY_FLOPPY_OPTION( comx35, "img", "COMX35 floppy disk image", comx35_dsk_identify, comx35_dsk_construct, NULL, NULL ) |
| 78 | 171 | LEGACY_FLOPPY_OPTIONS_END |
| 172 | |
| 173 | #endif |
trunk/src/mess/drivers/comx35.c
| r19197 | r19198 | |
| 24 | 24 | |
| 25 | 25 | READ8_MEMBER( comx35_state::mem_r ) |
| 26 | 26 | { |
| 27 | | UINT8 *rom = memregion(CDP1802_TAG)->base(); |
| 28 | | UINT8 *ram = m_ram->pointer(); |
| 29 | 27 | int extrom = 1; |
| 30 | 28 | |
| 31 | | UINT8 data = m_expansion->mrd_r(offset, &extrom); |
| 29 | UINT8 data = m_exp->mrd_r(space, offset, &extrom); |
| 32 | 30 | |
| 33 | 31 | if (offset < 0x4000) |
| 34 | 32 | { |
| 35 | | if (extrom) data = rom[offset & 0x3fff]; |
| 33 | if (extrom) data = m_rom[offset & 0x3fff]; |
| 36 | 34 | } |
| 37 | 35 | else if (offset >= 0x4000 && offset < 0xc000) |
| 38 | 36 | { |
| 39 | | data = ram[offset - 0x4000]; |
| 37 | data = m_ram->pointer()[offset - 0x4000]; |
| 40 | 38 | } |
| 41 | 39 | else if (offset >= 0xf400 && offset < 0xf800) |
| 42 | 40 | { |
| r19197 | r19198 | |
| 53 | 51 | |
| 54 | 52 | WRITE8_MEMBER( comx35_state::mem_w ) |
| 55 | 53 | { |
| 56 | | UINT8 *ram = m_ram->pointer(); |
| 54 | m_exp->mwr_w(space, offset, data); |
| 57 | 55 | |
| 58 | | m_expansion->mwr_w(offset, data); |
| 59 | | |
| 60 | 56 | if (offset >= 0x4000 && offset < 0xc000) |
| 61 | 57 | { |
| 62 | | ram[offset - 0x4000] = data; |
| 58 | m_ram->pointer()[offset - 0x4000] = data; |
| 63 | 59 | } |
| 64 | 60 | else if (offset >= 0xf400 && offset < 0xf800) |
| 65 | 61 | { |
| r19197 | r19198 | |
| 78 | 74 | |
| 79 | 75 | READ8_MEMBER( comx35_state::io_r ) |
| 80 | 76 | { |
| 81 | | UINT8 data = m_expansion->io_r(offset); |
| 77 | UINT8 data = m_exp->io_r(space, offset); |
| 82 | 78 | |
| 83 | 79 | if (offset == 3) |
| 84 | 80 | { |
| r19197 | r19198 | |
| 95 | 91 | |
| 96 | 92 | WRITE8_MEMBER( comx35_state::io_w ) |
| 97 | 93 | { |
| 98 | | m_expansion->io_w(offset, data); |
| 94 | m_exp->io_w(space, offset, data); |
| 99 | 95 | |
| 100 | 96 | if (offset >= 3) |
| 101 | 97 | { |
| r19197 | r19198 | |
| 279 | 275 | |
| 280 | 276 | READ_LINE_MEMBER( comx35_state::ef4_r ) |
| 281 | 277 | { |
| 282 | | return m_ef4; // | (m_cassette->input() > 0.0f); |
| 278 | return m_exp->ef4_r(); // | (m_cassette->input() > 0.0f); |
| 283 | 279 | } |
| 284 | 280 | |
| 285 | 281 | static COSMAC_SC_WRITE( comx35_sc_w ) |
| r19197 | r19198 | |
| 335 | 331 | m_cassette->output(state ? +1.0 : -1.0); |
| 336 | 332 | |
| 337 | 333 | // expansion bus |
| 338 | | m_expansion->q_w(state); |
| 334 | m_exp->q_w(state); |
| 339 | 335 | } |
| 340 | 336 | |
| 341 | 337 | static COSMAC_INTERFACE( cosmac_intf ) |
| 342 | 338 | { |
| 343 | | DEVCB_LINE_VCC, // wait |
| 339 | DEVCB_LINE_VCC, // wait |
| 344 | 340 | DEVCB_DRIVER_LINE_MEMBER(comx35_state, clear_r),// clear |
| 345 | | DEVCB_NULL, // EF1 |
| 346 | | DEVCB_DRIVER_LINE_MEMBER(comx35_state, ef2_r), // EF2 |
| 347 | | DEVCB_NULL, // EF3 |
| 348 | | DEVCB_DRIVER_LINE_MEMBER(comx35_state, ef4_r), // EF4 |
| 349 | | DEVCB_DRIVER_LINE_MEMBER(comx35_state, q_w), // Q |
| 350 | | DEVCB_NULL, // DMA in |
| 351 | | DEVCB_NULL, // DMA out |
| 352 | | comx35_sc_w, // SC |
| 353 | | DEVCB_NULL, // TPA |
| 354 | | DEVCB_NULL // TPB |
| 341 | DEVCB_NULL, // EF1 |
| 342 | DEVCB_DRIVER_LINE_MEMBER(comx35_state, ef2_r), // EF2 |
| 343 | DEVCB_NULL, // EF3 |
| 344 | DEVCB_DRIVER_LINE_MEMBER(comx35_state, ef4_r), // EF4 |
| 345 | DEVCB_DRIVER_LINE_MEMBER(comx35_state, q_w), // Q |
| 346 | DEVCB_NULL, // DMA in |
| 347 | DEVCB_NULL, // DMA out |
| 348 | comx35_sc_w, // SC |
| 349 | DEVCB_NULL, // TPA |
| 350 | DEVCB_NULL // TPB |
| 355 | 351 | }; |
| 356 | 352 | |
| 357 | 353 | |
| r19197 | r19198 | |
| 414 | 410 | check_interrupt(); |
| 415 | 411 | } |
| 416 | 412 | |
| 417 | | WRITE_LINE_MEMBER( comx35_state::ef4_w ) |
| 418 | | { |
| 419 | | m_ef4 = state; |
| 420 | | } |
| 421 | | |
| 422 | 413 | static COMX_EXPANSION_INTERFACE( expansion_intf ) |
| 423 | 414 | { |
| 424 | 415 | DEVCB_DRIVER_LINE_MEMBER(comx35_state, int_w), |
| 425 | | DEVCB_DRIVER_LINE_MEMBER(comx35_state, ef4_w), |
| 426 | 416 | DEVCB_NULL, |
| 427 | 417 | DEVCB_NULL |
| 428 | 418 | }; |
| r19197 | r19198 | |
| 469 | 459 | UINT8 *ram = m_ram->pointer(); |
| 470 | 460 | memset(ram, 0, 0x8000); |
| 471 | 461 | |
| 462 | // find memory regions |
| 463 | m_rom = memregion(CDP1802_TAG)->base(); |
| 464 | |
| 472 | 465 | // register for state saving |
| 473 | 466 | save_item(NAME(m_clear)); |
| 474 | 467 | save_item(NAME(m_q)); |
| 475 | | save_item(NAME(m_ef4)); |
| 476 | 468 | save_item(NAME(m_iden)); |
| 477 | 469 | save_item(NAME(m_dma)); |
| 478 | 470 | save_item(NAME(m_int)); |
| r19197 | r19198 | |
| 487 | 479 | |
| 488 | 480 | void comx35_state::machine_reset() |
| 489 | 481 | { |
| 482 | m_exp->reset(); |
| 483 | |
| 490 | 484 | int t = RES_K(27) * CAP_U(1) * 1000; // t = R1 * C1 |
| 491 | 485 | |
| 492 | 486 | m_clear = 0; |
| 493 | 487 | m_iden = 1; |
| 494 | 488 | m_cr1 = 1; |
| 495 | | m_ef4 = CLEAR_LINE; |
| 496 | 489 | m_int = CLEAR_LINE; |
| 497 | 490 | m_prd = CLEAR_LINE; |
| 498 | 491 | |
| r19197 | r19198 | |
| 523 | 516 | MCFG_CDP1871_ADD(CDP1871_TAG, kbc_intf, CDP1869_CPU_CLK_PAL / 8) |
| 524 | 517 | MCFG_QUICKLOAD_ADD("quickload", comx35_comx, "comx", 0) |
| 525 | 518 | MCFG_CASSETTE_ADD(CASSETTE_TAG, cassette_intf) |
| 526 | | MCFG_PRINTER_ADD("printer") |
| 527 | 519 | |
| 528 | | MCFG_COMXPL80_ADD() |
| 529 | | |
| 530 | 520 | // expansion bus |
| 531 | 521 | MCFG_COMX_EXPANSION_SLOT_ADD(EXPANSION_TAG, expansion_intf, comx_expansion_cards, "eb", NULL) |
| 532 | 522 | |
| 533 | 523 | // internal ram |
| 534 | 524 | MCFG_RAM_ADD(RAM_TAG) |
| 535 | 525 | MCFG_RAM_DEFAULT_SIZE("32K") |
| 526 | |
| 527 | // software lists |
| 528 | MCFG_SOFTWARE_LIST_ADD("flop_list", "comx35_flop") |
| 536 | 529 | MACHINE_CONFIG_END |
| 537 | 530 | |
| 538 | 531 | |
| r19197 | r19198 | |
| 554 | 547 | MCFG_CDP1871_ADD(CDP1871_TAG, kbc_intf, CDP1869_CPU_CLK_NTSC / 8) |
| 555 | 548 | MCFG_QUICKLOAD_ADD("quickload", comx35_comx, "comx", 0) |
| 556 | 549 | MCFG_CASSETTE_ADD(CASSETTE_TAG, cassette_intf) |
| 557 | | MCFG_PRINTER_ADD("printer") |
| 558 | 550 | |
| 559 | | MCFG_COMXPL80_ADD() |
| 560 | | |
| 561 | 551 | // expansion bus |
| 562 | 552 | MCFG_COMX_EXPANSION_SLOT_ADD(EXPANSION_TAG, expansion_intf, comx_expansion_cards, "eb", NULL) |
| 563 | 553 | |
| 564 | 554 | // internal ram |
| 565 | 555 | MCFG_RAM_ADD(RAM_TAG) |
| 566 | 556 | MCFG_RAM_DEFAULT_SIZE("32K") |
| 557 | |
| 558 | // software lists |
| 559 | MCFG_SOFTWARE_LIST_ADD("flop_list", "comx35_flop") |
| 567 | 560 | MACHINE_CONFIG_END |
| 568 | 561 | |
| 569 | 562 | |
| r19197 | r19198 | |
| 577 | 570 | //------------------------------------------------- |
| 578 | 571 | |
| 579 | 572 | ROM_START( comx35p ) |
| 580 | | ROM_REGION( 0x10000, CDP1802_TAG, 0 ) |
| 573 | ROM_REGION( 0x4000, CDP1802_TAG, 0 ) |
| 581 | 574 | ROM_DEFAULT_BIOS( "basic100" ) |
| 582 | 575 | ROM_SYSTEM_BIOS( 0, "basic100", "COMX BASIC V1.00" ) |
| 583 | 576 | ROMX_LOAD( "comx_10.u21", 0x0000, 0x4000, CRC(68d0db2d) SHA1(062328361629019ceed9375afac18e2b7849ce47), ROM_BIOS(1) ) |
| r19197 | r19198 | |
| 599 | 592 | //************************************************************************** |
| 600 | 593 | |
| 601 | 594 | // YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS |
| 602 | | COMP( 1983, comx35p, 0, 0, pal, comx35, driver_device, 0, "Comx World Operations Ltd", "COMX 35 (PAL)", GAME_IMPERFECT_SOUND ) |
| 603 | | COMP( 1983, comx35n, comx35p,0, ntsc, comx35, driver_device, 0, "Comx World Operations Ltd", "COMX 35 (NTSC)", GAME_IMPERFECT_SOUND ) |
| 595 | COMP( 1983, comx35p, 0, 0, pal, comx35, driver_device, 0, "Comx World Operations Ltd", "COMX 35 (PAL)", GAME_IMPERFECT_SOUND ) |
| 596 | COMP( 1983, comx35n, comx35p,0, ntsc, comx35, driver_device, 0, "Comx World Operations Ltd", "COMX 35 (NTSC)", GAME_IMPERFECT_SOUND ) |
trunk/src/mess/machine/comx_prn.c
| r19197 | r19198 | |
| 15 | 15 | // MACROS/CONSTANTS |
| 16 | 16 | //************************************************************************** |
| 17 | 17 | |
| 18 | #define CENTRONICS_TAG "centronics" |
| 18 | 19 | |
| 19 | 20 | |
| 21 | |
| 20 | 22 | //************************************************************************** |
| 21 | 23 | // DEVICE DEFINITIONS |
| 22 | 24 | //************************************************************************** |
| r19197 | r19198 | |
| 30 | 32 | |
| 31 | 33 | ROM_START( comx_prn ) |
| 32 | 34 | ROM_REGION( 0x2000, "c000", 0 ) |
| 33 | | ROM_LOAD( "printer.bin", 0x0000, 0x0800, CRC(3bbc2b2e) SHA1(08bf7ea4174713ab24969c553affd5c1401876b8) ) |
| 34 | | |
| 35 | | ROM_REGION( 0x2000, "printer_fm", 0 ) |
| 36 | | ROM_LOAD( "f&m.printer.1.2.bin", 0x0000, 0x1000, CRC(2feb997d) SHA1(ee9cb91042696c88ff5f2f44d2f702dc93369ba0) ) |
| 37 | | |
| 38 | | ROM_REGION( 0x2000, "rs232", 0 ) |
| 39 | | ROM_LOAD( "rs232.bin", 0x0000, 0x0800, CRC(926ff2d1) SHA1(be02bd388bba0211ea72d4868264a63308e4318d) ) |
| 35 | ROM_SYSTEM_BIOS( 0, "comx", "COMX" ) |
| 36 | ROMX_LOAD( "printer.bin", 0x0000, 0x0800, CRC(3bbc2b2e) SHA1(08bf7ea4174713ab24969c553affd5c1401876b8), ROM_BIOS(1) ) |
| 37 | ROM_SYSTEM_BIOS( 1, "fm12", "F&M v1.2" ) |
| 38 | ROMX_LOAD( "f&m.printer.1.2.bin", 0x0000, 0x1000, CRC(2feb997d) SHA1(ee9cb91042696c88ff5f2f44d2f702dc93369ba0), ROM_BIOS(2) ) |
| 39 | ROM_LOAD( "rs232.bin", 0x1000, 0x0800, CRC(926ff2d1) SHA1(be02bd388bba0211ea72d4868264a63308e4318d) ) |
| 40 | 40 | ROM_END |
| 41 | 41 | |
| 42 | 42 | |
| r19197 | r19198 | |
| 50 | 50 | } |
| 51 | 51 | |
| 52 | 52 | |
| 53 | //------------------------------------------------- |
| 54 | // SLOT_INTERFACE( comx_centronics_printer ) |
| 55 | //------------------------------------------------- |
| 56 | |
| 57 | SLOT_INTERFACE_START(comx_centronics_printer) |
| 58 | SLOT_INTERFACE("printer", CENTRONICS_PRINTER) |
| 59 | SLOT_INTERFACE("pl80", COMX_PL80) |
| 60 | SLOT_INTERFACE_END |
| 61 | |
| 62 | |
| 63 | //------------------------------------------------- |
| 64 | // MACHINE_CONFIG_FRAGMENT( comx_prn ) |
| 65 | //------------------------------------------------- |
| 66 | |
| 67 | static MACHINE_CONFIG_FRAGMENT( comx_prn ) |
| 68 | MCFG_CENTRONICS_ADD(CENTRONICS_TAG, standard_centronics, comx_centronics_printer, "pl80", NULL) |
| 69 | MACHINE_CONFIG_END |
| 70 | |
| 71 | |
| 72 | //------------------------------------------------- |
| 73 | // machine_config_additions - device-specific |
| 74 | // machine configurations |
| 75 | //------------------------------------------------- |
| 76 | |
| 77 | machine_config_constructor comx_prn_device::device_mconfig_additions() const |
| 78 | { |
| 79 | return MACHINE_CONFIG_NAME( comx_prn ); |
| 80 | } |
| 81 | |
| 82 | |
| 83 | |
| 53 | 84 | //************************************************************************** |
| 54 | 85 | // LIVE DEVICE |
| 55 | 86 | //************************************************************************** |
| r19197 | r19198 | |
| 59 | 90 | //------------------------------------------------- |
| 60 | 91 | |
| 61 | 92 | comx_prn_device::comx_prn_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : |
| 62 | | device_t(mconfig, COMX_PRN, "COMX-35 F&M Printer Card", tag, owner, clock), |
| 63 | | device_comx_expansion_card_interface(mconfig, *this) |
| 93 | device_t(mconfig, COMX_PRN, "COMX-35 Printer Card", tag, owner, clock), |
| 94 | device_comx_expansion_card_interface(mconfig, *this), |
| 95 | m_centronics(*this, CENTRONICS_TAG) |
| 64 | 96 | { |
| 65 | 97 | } |
| 66 | 98 | |
| r19197 | r19198 | |
| 88 | 120 | // comx_mrd_r - memory read |
| 89 | 121 | //------------------------------------------------- |
| 90 | 122 | |
| 91 | | UINT8 comx_prn_device::comx_mrd_r(offs_t offset, int *extrom) |
| 123 | UINT8 comx_prn_device::comx_mrd_r(address_space &space, offs_t offset, int *extrom) |
| 92 | 124 | { |
| 93 | 125 | UINT8 data = 0; |
| 94 | 126 | |
| 95 | | if (offset >= 0xc000 && offset < 0xd000) |
| 127 | if (offset >= 0xc000 && offset < 0xe000) |
| 96 | 128 | { |
| 97 | | data = m_rom[offset & 0xfff]; |
| 129 | data = m_rom[offset & 0x1fff]; |
| 98 | 130 | } |
| 99 | 131 | |
| 100 | 132 | return data; |
| r19197 | r19198 | |
| 105 | 137 | // comx_io_r - I/O read |
| 106 | 138 | //------------------------------------------------- |
| 107 | 139 | |
| 108 | | UINT8 comx_prn_device::comx_io_r(offs_t offset) |
| 140 | UINT8 comx_prn_device::comx_io_r(address_space &space, offs_t offset) |
| 109 | 141 | { |
| 110 | 142 | /* |
| 111 | | Parallel: |
| 143 | Parallel: |
| 112 | 144 | |
| 113 | | INP 2 for the printer status, where: |
| 114 | | b0=1: Acknowledge Fault |
| 115 | | b1=0: Device Busy |
| 116 | | b2=0: Paper Empty |
| 117 | | b3=1: Device Not Selected |
| 145 | INP 2 for the printer status, where: |
| 146 | b0=1: Acknowledge Fault |
| 147 | b1=0: Device Busy |
| 148 | b2=0: Paper Empty |
| 149 | b3=1: Device Not Selected |
| 118 | 150 | |
| 119 | | Serial: |
| 151 | Serial: |
| 120 | 152 | |
| 121 | | INP 2 for the printer status and to start a new range of bits for the next byte. |
| 122 | | */ |
| 153 | INP 2 for the printer status and to start a new range of bits for the next byte. |
| 154 | */ |
| 123 | 155 | |
| 124 | | return 0; |
| 156 | /* |
| 157 | |
| 158 | bit description |
| 159 | |
| 160 | 0 Acknowledge Fault |
| 161 | 1 Device Busy |
| 162 | 2 Paper Empty |
| 163 | 3 Device Not Selected |
| 164 | 4 |
| 165 | 5 |
| 166 | 6 |
| 167 | 7 |
| 168 | |
| 169 | */ |
| 170 | |
| 171 | UINT8 data = 0; |
| 172 | |
| 173 | data |= m_centronics->ack_r(); |
| 174 | data |= m_centronics->not_busy_r() << 1; |
| 175 | data |= m_centronics->pe_r() << 2; |
| 176 | data |= m_centronics->vcc_r() << 3; |
| 177 | |
| 178 | return data; |
| 125 | 179 | } |
| 126 | 180 | |
| 127 | 181 | |
| r19197 | r19198 | |
| 129 | 183 | // comx_io_w - I/O write |
| 130 | 184 | //------------------------------------------------- |
| 131 | 185 | |
| 132 | | void comx_prn_device::comx_io_w(offs_t offset, UINT8 data) |
| 186 | void comx_prn_device::comx_io_w(address_space &space, offs_t offset, UINT8 data) |
| 133 | 187 | { |
| 134 | 188 | /* |
| 135 | | Parallel: |
| 189 | Parallel: |
| 136 | 190 | |
| 137 | | OUT 2 is used to send a byte to the printer |
| 191 | OUT 2 is used to send a byte to the printer |
| 138 | 192 | |
| 139 | | Serial: |
| 193 | Serial: |
| 140 | 194 | |
| 141 | | OUT 2 is used to send a bit to the printer |
| 142 | | */ |
| 195 | OUT 2 is used to send a bit to the printer |
| 196 | */ |
| 197 | |
| 198 | m_centronics->write(data); |
| 143 | 199 | } |
trunk/src/mess/machine/comx_prn.h
| r19197 | r19198 | |
| 15 | 15 | |
| 16 | 16 | #include "emu.h" |
| 17 | 17 | #include "machine/comxexp.h" |
| 18 | #include "machine/comxpl80.h" |
| 19 | #include "machine/ctronics.h" |
| 18 | 20 | |
| 19 | 21 | |
| 20 | 22 | |
| r19197 | r19198 | |
| 25 | 27 | // ======================> comx_prn_device |
| 26 | 28 | |
| 27 | 29 | class comx_prn_device : public device_t, |
| 28 | | public device_comx_expansion_card_interface |
| 30 | public device_comx_expansion_card_interface |
| 29 | 31 | { |
| 30 | 32 | public: |
| 31 | 33 | // construction/destruction |
| r19197 | r19198 | |
| 33 | 35 | |
| 34 | 36 | // optional information overrides |
| 35 | 37 | virtual const rom_entry *device_rom_region() const; |
| 38 | virtual machine_config_constructor device_mconfig_additions() const; |
| 36 | 39 | |
| 37 | 40 | protected: |
| 38 | 41 | // device-level overrides |
| 39 | 42 | virtual void device_start(); |
| 40 | 43 | virtual void device_reset(); |
| 41 | | virtual void device_config_complete() { m_shortname = "comx_prn"; } |
| 44 | virtual void device_config_complete() { m_shortname = "comx_prn"; } |
| 42 | 45 | |
| 43 | 46 | // device_comx_expansion_card_interface overrides |
| 44 | | virtual UINT8 comx_mrd_r(offs_t offset, int *extrom); |
| 45 | | virtual UINT8 comx_io_r(offs_t offset); |
| 46 | | virtual void comx_io_w(offs_t offset, UINT8 data); |
| 47 | virtual UINT8 comx_mrd_r(address_space &space, offs_t offset, int *extrom); |
| 48 | virtual UINT8 comx_io_r(address_space &space, offs_t offset); |
| 49 | virtual void comx_io_w(address_space &space, offs_t offset, UINT8 data); |
| 47 | 50 | |
| 48 | 51 | private: |
| 49 | | UINT8 *m_rom; // program ROM |
| 52 | required_device<centronics_device> m_centronics; |
| 53 | |
| 54 | UINT8 *m_rom; // program ROM |
| 50 | 55 | }; |
| 51 | 56 | |
| 52 | 57 | |
trunk/src/mess/machine/comxexp.c
| r19197 | r19198 | |
| 28 | 28 | //------------------------------------------------- |
| 29 | 29 | |
| 30 | 30 | device_comx_expansion_card_interface::device_comx_expansion_card_interface(const machine_config &mconfig, device_t &device) |
| 31 | | : device_slot_card_interface(mconfig,device) |
| 31 | : device_slot_card_interface(mconfig, device), |
| 32 | m_ds(1) |
| 32 | 33 | { |
| 33 | 34 | m_slot = dynamic_cast<comx_expansion_slot_device *>(device.owner()); |
| 34 | 35 | } |
| r19197 | r19198 | |
| 53 | 54 | //------------------------------------------------- |
| 54 | 55 | |
| 55 | 56 | comx_expansion_slot_device::comx_expansion_slot_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : |
| 56 | | device_t(mconfig, COMX_EXPANSION_SLOT, "COMX-35 expansion slot", tag, owner, clock), |
| 57 | device_t(mconfig, COMX_EXPANSION_SLOT, "COMX-35 expansion slot", tag, owner, clock), |
| 57 | 58 | device_slot_interface(mconfig, *this) |
| 58 | 59 | { |
| 59 | 60 | } |
| r19197 | r19198 | |
| 86 | 87 | // or initialize to defaults if none provided |
| 87 | 88 | else |
| 88 | 89 | { |
| 89 | | memset(&m_out_int_cb, 0, sizeof(m_out_int_cb)); |
| 90 | | memset(&m_out_ef4_cb, 0, sizeof(m_out_ef4_cb)); |
| 91 | | memset(&m_out_wait_cb, 0, sizeof(m_out_wait_cb)); |
| 92 | | memset(&m_out_clear_cb, 0, sizeof(m_out_clear_cb)); |
| 90 | memset(&m_out_int_cb, 0, sizeof(m_out_int_cb)); |
| 91 | memset(&m_out_wait_cb, 0, sizeof(m_out_wait_cb)); |
| 92 | memset(&m_out_clear_cb, 0, sizeof(m_out_clear_cb)); |
| 93 | 93 | } |
| 94 | 94 | } |
| 95 | 95 | |
| r19197 | r19198 | |
| 104 | 104 | |
| 105 | 105 | // resolve callbacks |
| 106 | 106 | m_out_int_func.resolve(m_out_int_cb, *this); |
| 107 | | m_out_ef4_func.resolve(m_out_ef4_cb, *this); |
| 108 | 107 | m_out_wait_func.resolve(m_out_wait_cb, *this); |
| 109 | 108 | m_out_clear_func.resolve(m_out_clear_cb, *this); |
| 110 | 109 | } |
| r19197 | r19198 | |
| 123 | 122 | // mrd_r - memory read |
| 124 | 123 | //------------------------------------------------- |
| 125 | 124 | |
| 126 | | UINT8 comx_expansion_slot_device::mrd_r(offs_t offset, int *extrom) |
| 125 | UINT8 comx_expansion_slot_device::mrd_r(address_space &space, offs_t offset, int *extrom) |
| 127 | 126 | { |
| 128 | 127 | UINT8 data = 0; |
| 129 | 128 | |
| 130 | 129 | if (m_card != NULL) |
| 131 | 130 | { |
| 132 | | data = m_card->comx_mrd_r(offset, extrom); |
| 131 | data = m_card->comx_mrd_r(space, offset, extrom); |
| 133 | 132 | } |
| 134 | 133 | |
| 135 | 134 | return data; |
| r19197 | r19198 | |
| 140 | 139 | // mwr_w - memory write |
| 141 | 140 | //------------------------------------------------- |
| 142 | 141 | |
| 143 | | void comx_expansion_slot_device::mwr_w(offs_t offset, UINT8 data) |
| 142 | void comx_expansion_slot_device::mwr_w(address_space &space, offs_t offset, UINT8 data) |
| 144 | 143 | { |
| 145 | 144 | if (m_card != NULL) |
| 146 | 145 | { |
| 147 | | m_card->comx_mwr_w(offset, data); |
| 146 | m_card->comx_mwr_w(space, offset, data); |
| 148 | 147 | } |
| 149 | 148 | } |
| 150 | 149 | |
| r19197 | r19198 | |
| 153 | 152 | // io_r - I/O read |
| 154 | 153 | //------------------------------------------------- |
| 155 | 154 | |
| 156 | | UINT8 comx_expansion_slot_device::io_r(offs_t offset) |
| 155 | UINT8 comx_expansion_slot_device::io_r(address_space &space, offs_t offset) |
| 157 | 156 | { |
| 158 | 157 | UINT8 data = 0; |
| 159 | 158 | |
| 160 | 159 | if (m_card != NULL) |
| 161 | 160 | { |
| 162 | | data = m_card->comx_io_r(offset); |
| 161 | data = m_card->comx_io_r(space, offset); |
| 163 | 162 | } |
| 164 | 163 | |
| 165 | 164 | return data; |
| r19197 | r19198 | |
| 170 | 169 | // sout_w - I/O write |
| 171 | 170 | //------------------------------------------------- |
| 172 | 171 | |
| 173 | | void comx_expansion_slot_device::io_w(offs_t offset, UINT8 data) |
| 172 | void comx_expansion_slot_device::io_w(address_space &space, offs_t offset, UINT8 data) |
| 174 | 173 | { |
| 175 | 174 | if (m_card != NULL) |
| 176 | 175 | { |
| 177 | | m_card->comx_io_w(offset, data); |
| 176 | m_card->comx_io_w(space, offset, data); |
| 178 | 177 | } |
| 179 | 178 | } |
| 180 | 179 | |
| r19197 | r19198 | |
| 204 | 203 | } |
| 205 | 204 | } |
| 206 | 205 | |
| 206 | READ_LINE_MEMBER( comx_expansion_slot_device::ef4_r ) |
| 207 | { |
| 208 | int state = CLEAR_LINE; |
| 207 | 209 | |
| 210 | if (m_card != NULL) |
| 211 | { |
| 212 | state = m_card->comx_ef4_r(); |
| 213 | } |
| 214 | |
| 215 | return state; |
| 216 | } |
| 217 | |
| 208 | 218 | WRITE_LINE_MEMBER( comx_expansion_slot_device::int_w ) { m_out_int_func(state); } |
| 209 | | WRITE_LINE_MEMBER( comx_expansion_slot_device::ef4_w ) { m_out_ef4_func(state); } |
| 210 | 219 | WRITE_LINE_MEMBER( comx_expansion_slot_device::wait_w ) { m_out_wait_func(state); } |
| 211 | 220 | WRITE_LINE_MEMBER( comx_expansion_slot_device::clear_w ) { m_out_clear_func(state); } |
trunk/src/mess/machine/comxexp.h
| r19197 | r19198 | |
| 45 | 45 | // CONSTANTS |
| 46 | 46 | //************************************************************************** |
| 47 | 47 | |
| 48 | | #define COMX_EXPANSION_BUS_TAG "comxexp" |
| 48 | #define COMX_EXPANSION_BUS_TAG "comxexp" |
| 49 | 49 | |
| 50 | 50 | |
| 51 | 51 | |
| r19197 | r19198 | |
| 58 | 58 | |
| 59 | 59 | |
| 60 | 60 | #define MCFG_COMX_EXPANSION_SLOT_ADD(_tag, _config, _slot_intf, _def_slot, _def_inp) \ |
| 61 | | MCFG_DEVICE_ADD(_tag, COMX_EXPANSION_SLOT, 0) \ |
| 62 | | MCFG_DEVICE_CONFIG(_config) \ |
| 61 | MCFG_DEVICE_ADD(_tag, COMX_EXPANSION_SLOT, 0) \ |
| 62 | MCFG_DEVICE_CONFIG(_config) \ |
| 63 | 63 | MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, _def_inp, false) |
| 64 | 64 | |
| 65 | 65 | |
| r19197 | r19198 | |
| 72 | 72 | |
| 73 | 73 | struct comx_expansion_slot_interface |
| 74 | 74 | { |
| 75 | | devcb_write_line m_out_int_cb; |
| 76 | | devcb_write_line m_out_ef4_cb; |
| 77 | | devcb_write_line m_out_wait_cb; |
| 78 | | devcb_write_line m_out_clear_cb; |
| 75 | devcb_write_line m_out_int_cb; |
| 76 | devcb_write_line m_out_wait_cb; |
| 77 | devcb_write_line m_out_clear_cb; |
| 79 | 78 | }; |
| 80 | 79 | |
| 81 | 80 | |
| r19197 | r19198 | |
| 84 | 83 | class device_comx_expansion_card_interface; |
| 85 | 84 | |
| 86 | 85 | class comx_expansion_slot_device : public device_t, |
| 87 | | public comx_expansion_slot_interface, |
| 88 | | public device_slot_interface |
| 86 | public comx_expansion_slot_interface, |
| 87 | public device_slot_interface |
| 89 | 88 | { |
| 90 | 89 | public: |
| 91 | 90 | // construction/destruction |
| 92 | 91 | comx_expansion_slot_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 93 | 92 | virtual ~comx_expansion_slot_device(); |
| 94 | 93 | |
| 95 | | UINT8 mrd_r(offs_t offset, int *extrom); |
| 96 | | void mwr_w(offs_t offset, UINT8 data); |
| 94 | UINT8 mrd_r(address_space &space, offs_t offset, int *extrom); |
| 95 | void mwr_w(address_space &space, offs_t offset, UINT8 data); |
| 97 | 96 | |
| 98 | | UINT8 io_r(offs_t offset); |
| 99 | | void io_w(offs_t offset, UINT8 data); |
| 97 | UINT8 io_r(address_space &space, offs_t offset); |
| 98 | void io_w(address_space &space, offs_t offset, UINT8 data); |
| 100 | 99 | |
| 100 | DECLARE_READ_LINE_MEMBER( ef4_r ); |
| 101 | |
| 101 | 102 | DECLARE_WRITE_LINE_MEMBER( ds_w ); |
| 102 | 103 | DECLARE_WRITE_LINE_MEMBER( q_w ); |
| 103 | 104 | |
| 104 | 105 | DECLARE_WRITE_LINE_MEMBER( int_w ); |
| 105 | | DECLARE_WRITE_LINE_MEMBER( ef4_w ); |
| 106 | 106 | DECLARE_WRITE_LINE_MEMBER( wait_w ); |
| 107 | 107 | DECLARE_WRITE_LINE_MEMBER( clear_w ); |
| 108 | 108 | |
| r19197 | r19198 | |
| 114 | 114 | virtual void device_reset(); |
| 115 | 115 | virtual void device_config_complete(); |
| 116 | 116 | |
| 117 | | devcb_resolved_write_line m_out_int_func; |
| 118 | | devcb_resolved_write_line m_out_ef4_func; |
| 119 | | devcb_resolved_write_line m_out_wait_func; |
| 120 | | devcb_resolved_write_line m_out_clear_func; |
| 117 | devcb_resolved_write_line m_out_int_func; |
| 118 | devcb_resolved_write_line m_out_wait_func; |
| 119 | devcb_resolved_write_line m_out_clear_func; |
| 121 | 120 | |
| 122 | 121 | device_comx_expansion_card_interface *m_card; |
| 123 | 122 | }; |
| r19197 | r19198 | |
| 137 | 136 | |
| 138 | 137 | protected: |
| 139 | 138 | // signals |
| 140 | | virtual void comx_ds_w(int state) { }; |
| 139 | virtual int comx_ef4_r() { return CLEAR_LINE; } |
| 140 | virtual void comx_ds_w(int state) { m_ds = state; }; |
| 141 | 141 | virtual void comx_q_w(int state) { }; |
| 142 | 142 | |
| 143 | 143 | // memory access |
| 144 | | virtual UINT8 comx_mrd_r(offs_t offset, int *extrom) { return 0; }; |
| 145 | | virtual void comx_mwr_w(offs_t offset, UINT8 data) { }; |
| 144 | virtual UINT8 comx_mrd_r(address_space &space, offs_t offset, int *extrom) { return 0; }; |
| 145 | virtual void comx_mwr_w(address_space &space, offs_t offset, UINT8 data) { }; |
| 146 | 146 | |
| 147 | 147 | // I/O access |
| 148 | | virtual UINT8 comx_io_r(offs_t offset) { return 0; }; |
| 149 | | virtual void comx_io_w(offs_t offset, UINT8 data) { }; |
| 148 | virtual UINT8 comx_io_r(address_space &space, offs_t offset) { return 0; }; |
| 149 | virtual void comx_io_w(address_space &space, offs_t offset, UINT8 data) { }; |
| 150 | 150 | |
| 151 | 151 | comx_expansion_slot_device *m_slot; |
| 152 | |
| 153 | int m_ds; |
| 152 | 154 | }; |
| 153 | 155 | |
| 154 | 156 | |
trunk/src/mess/machine/comx_thm.c
| r19197 | r19198 | |
| 82 | 82 | // comx_mrd_r - memory read |
| 83 | 83 | //------------------------------------------------- |
| 84 | 84 | |
| 85 | | UINT8 comx_thm_device::comx_mrd_r(offs_t offset, int *extrom) |
| 85 | UINT8 comx_thm_device::comx_mrd_r(address_space &space, offs_t offset, int *extrom) |
| 86 | 86 | { |
| 87 | 87 | UINT8 data = 0; |
| 88 | 88 | |
| r19197 | r19198 | |
| 99 | 99 | // comx_io_r - I/O read |
| 100 | 100 | //------------------------------------------------- |
| 101 | 101 | |
| 102 | | UINT8 comx_thm_device::comx_io_r(offs_t offset) |
| 102 | UINT8 comx_thm_device::comx_io_r(address_space &space, offs_t offset) |
| 103 | 103 | { |
| 104 | 104 | /* |
| 105 | | INP 2 is used for the printer status, where: |
| 106 | | b0=1: Printer Not Ready |
| 107 | | b1=1: Energizing Head |
| 108 | | b2=1: Head At Position 0 |
| 109 | | */ |
| 105 | INP 2 is used for the printer status, where: |
| 106 | b0=1: Printer Not Ready |
| 107 | b1=1: Energizing Head |
| 108 | b2=1: Head At Position 0 |
| 109 | */ |
| 110 | 110 | |
| 111 | 111 | return 0; |
| 112 | 112 | } |
| r19197 | r19198 | |
| 116 | 116 | // comx_io_w - I/O write |
| 117 | 117 | //------------------------------------------------- |
| 118 | 118 | |
| 119 | | void comx_thm_device::comx_io_w(offs_t offset, UINT8 data) |
| 119 | void comx_thm_device::comx_io_w(address_space &space, offs_t offset, UINT8 data) |
| 120 | 120 | { |
| 121 | 121 | /* |
| 122 | | OUT 2 is used to control the thermal printer where: |
| 123 | | Q = 0, b0-7: Pixel 1 to 8 |
| 124 | | Q = 1, b7: Pixel 9 (if b0-6=#21) |
| 125 | | Q = 1, b3=1: Move head right |
| 126 | | Q = 1, b0-7=#12: Move head left |
| 127 | | */ |
| 122 | OUT 2 is used to control the thermal printer where: |
| 123 | Q = 0, b0-7: Pixel 1 to 8 |
| 124 | Q = 1, b7: Pixel 9 (if b0-6=#21) |
| 125 | Q = 1, b3=1: Move head right |
| 126 | Q = 1, b0-7=#12: Move head left |
| 127 | */ |
| 128 | 128 | } |
trunk/src/mess/machine/comx_eb.c
| r19197 | r19198 | |
| 55 | 55 | // MACROS/CONSTANTS |
| 56 | 56 | //************************************************************************** |
| 57 | 57 | |
| 58 | | #define SLOT1_TAG "slot1" |
| 59 | | #define SLOT2_TAG "slot2" |
| 60 | | #define SLOT3_TAG "slot3" |
| 61 | | #define SLOT4_TAG "slot4" |
| 58 | #define SLOT1_TAG "slot1" |
| 59 | #define SLOT2_TAG "slot2" |
| 60 | #define SLOT3_TAG "slot3" |
| 61 | #define SLOT4_TAG "slot4" |
| 62 | 62 | |
| 63 | 63 | |
| 64 | 64 | |
| r19197 | r19198 | |
| 76 | 76 | ROM_START( comx_eb ) |
| 77 | 77 | ROM_REGION( 0x1000, "e000", 0 ) |
| 78 | 78 | ROM_SYSTEM_BIOS( 0, "comx", "Original" ) |
| 79 | | ROMX_LOAD( "expansion.e5", 0x0000, 0x1000, CRC(52cb44e2) SHA1(3f9a3d9940b36d4fee5eca9f1359c99d7ed545b9), ROM_BIOS(1) ) |
| 79 | ROMX_LOAD( "expansion.e5", 0x0000, 0x1000, CRC(52cb44e2) SHA1(3f9a3d9940b36d4fee5eca9f1359c99d7ed545b9), ROM_BIOS(1) ) |
| 80 | 80 | ROM_SYSTEM_BIOS( 1, "fm31", "F&M 3.1" ) |
| 81 | 81 | ROMX_LOAD( "f&m.expansion.3.1.e5", 0x0000, 0x1000, CRC(818ca2ef) SHA1(ea000097622e7fd472d53e7899e3c83773433045), ROM_BIOS(2) ) |
| 82 | 82 | ROM_SYSTEM_BIOS( 2, "fm32", "F&M 3.2" ) |
| r19197 | r19198 | |
| 114 | 114 | eb->set_int(device->tag(), state); |
| 115 | 115 | } |
| 116 | 116 | |
| 117 | | WRITE_LINE_DEVICE_HANDLER( ef4_w ) |
| 118 | | { |
| 119 | | comx_eb_device *eb = downcast<comx_eb_device *>(device->owner()); |
| 120 | | eb->set_ef4(device->tag(), state); |
| 121 | | } |
| 122 | | |
| 123 | 117 | WRITE_LINE_DEVICE_HANDLER( wait_w ) |
| 124 | 118 | { |
| 125 | 119 | comx_expansion_slot_device *slot = dynamic_cast<comx_expansion_slot_device *>(device->owner()->owner()); |
| r19197 | r19198 | |
| 135 | 129 | static COMX_EXPANSION_INTERFACE( expansion_intf ) |
| 136 | 130 | { |
| 137 | 131 | DEVCB_LINE(int_w), |
| 138 | | DEVCB_LINE(ef4_w), |
| 139 | 132 | DEVCB_LINE(wait_w), |
| 140 | 133 | DEVCB_LINE(clear_w) |
| 141 | 134 | }; |
| r19197 | r19198 | |
| 197 | 190 | } |
| 198 | 191 | |
| 199 | 192 | |
| 200 | | //------------------------------------------------- |
| 201 | | // set_ef4 - set EF4 line state |
| 202 | | //------------------------------------------------- |
| 203 | 193 | |
| 204 | | void comx_eb_device::set_ef4(const char *tag, int state) |
| 205 | | { |
| 206 | | int slot = 0; |
| 207 | | |
| 208 | | for (slot = 0; slot < MAX_EB_SLOTS; slot++) |
| 209 | | { |
| 210 | | if (!strcmp(tag, m_expansion_slot[slot]->tag())) break; |
| 211 | | } |
| 212 | | |
| 213 | | assert(slot < MAX_EB_SLOTS); |
| 214 | | |
| 215 | | m_ef4[slot] = state; |
| 216 | | |
| 217 | | int ef4 = CLEAR_LINE; |
| 218 | | |
| 219 | | for (slot = 0; slot < MAX_EB_SLOTS; slot++) |
| 220 | | { |
| 221 | | ef4 |= m_ef4[slot]; |
| 222 | | } |
| 223 | | |
| 224 | | m_slot->ef4_w(ef4); |
| 225 | | } |
| 226 | | |
| 227 | | |
| 228 | | |
| 229 | 194 | //************************************************************************** |
| 230 | 195 | // LIVE DEVICE |
| 231 | 196 | //************************************************************************** |
| r19197 | r19198 | |
| 256 | 221 | for (int slot = 0; slot < MAX_EB_SLOTS; slot++) |
| 257 | 222 | { |
| 258 | 223 | m_int[slot] = CLEAR_LINE; |
| 259 | | m_ef4[slot] = CLEAR_LINE; |
| 260 | 224 | } |
| 261 | 225 | |
| 262 | 226 | m_rom = memregion("e000")->base(); |
| r19197 | r19198 | |
| 269 | 233 | |
| 270 | 234 | void comx_eb_device::device_reset() |
| 271 | 235 | { |
| 236 | for (int slot = 0; slot < MAX_EB_SLOTS; slot++) |
| 237 | { |
| 238 | if (m_expansion_slot[slot] != NULL) |
| 239 | { |
| 240 | m_expansion_slot[slot]->device().reset(); |
| 241 | m_expansion_slot[slot]->ds_w(0); |
| 242 | } |
| 243 | } |
| 272 | 244 | } |
| 273 | 245 | |
| 274 | 246 | |
| 275 | 247 | //------------------------------------------------- |
| 248 | // comx_ef4_r - external flag 4 read |
| 249 | //------------------------------------------------- |
| 250 | |
| 251 | int comx_eb_device::comx_ef4_r() |
| 252 | { |
| 253 | int state = CLEAR_LINE; |
| 254 | |
| 255 | for (int slot = 0; slot < MAX_EB_SLOTS; slot++) |
| 256 | { |
| 257 | if (m_expansion_slot[slot] != NULL) |
| 258 | { |
| 259 | if (m_expansion_slot[slot]->ef4_r() == ASSERT_LINE) |
| 260 | { |
| 261 | state = ASSERT_LINE; |
| 262 | break; |
| 263 | } |
| 264 | } |
| 265 | } |
| 266 | |
| 267 | return state; |
| 268 | } |
| 269 | |
| 270 | |
| 271 | //------------------------------------------------- |
| 276 | 272 | // comx_q_w - Q write |
| 277 | 273 | //------------------------------------------------- |
| 278 | 274 | |
| r19197 | r19198 | |
| 292 | 288 | // comx_mrd_r - memory read |
| 293 | 289 | //------------------------------------------------- |
| 294 | 290 | |
| 295 | | UINT8 comx_eb_device::comx_mrd_r(offs_t offset, int *extrom) |
| 291 | UINT8 comx_eb_device::comx_mrd_r(address_space &space, offs_t offset, int *extrom) |
| 296 | 292 | { |
| 297 | 293 | UINT8 data = 0; |
| 298 | 294 | |
| r19197 | r19198 | |
| 311 | 307 | { |
| 312 | 308 | if (BIT(m_select, slot) && m_expansion_slot[slot] != NULL) |
| 313 | 309 | { |
| 314 | | data |= m_expansion_slot[slot]->mrd_r(offset, extrom); |
| 310 | data |= m_expansion_slot[slot]->mrd_r(space, offset, extrom); |
| 315 | 311 | } |
| 316 | 312 | } |
| 317 | 313 | } |
| r19197 | r19198 | |
| 324 | 320 | // comx_mwr_w - memory write |
| 325 | 321 | //------------------------------------------------- |
| 326 | 322 | |
| 327 | | void comx_eb_device::comx_mwr_w(offs_t offset, UINT8 data) |
| 323 | void comx_eb_device::comx_mwr_w(address_space &space, offs_t offset, UINT8 data) |
| 328 | 324 | { |
| 329 | 325 | for (int slot = 0; slot < MAX_EB_SLOTS; slot++) |
| 330 | 326 | { |
| 331 | 327 | if (BIT(m_select, slot) && m_expansion_slot[slot] != NULL) |
| 332 | 328 | { |
| 333 | | m_expansion_slot[slot]->mwr_w(offset, data); |
| 329 | m_expansion_slot[slot]->mwr_w(space, offset, data); |
| 334 | 330 | } |
| 335 | 331 | } |
| 336 | 332 | } |
| r19197 | r19198 | |
| 340 | 336 | // comx_io_r - I/O read |
| 341 | 337 | //------------------------------------------------- |
| 342 | 338 | |
| 343 | | UINT8 comx_eb_device::comx_io_r(offs_t offset) |
| 339 | UINT8 comx_eb_device::comx_io_r(address_space &space, offs_t offset) |
| 344 | 340 | { |
| 345 | 341 | UINT8 data = 0; |
| 346 | 342 | |
| r19197 | r19198 | |
| 348 | 344 | { |
| 349 | 345 | if (BIT(m_select, slot) && m_expansion_slot[slot] != NULL) |
| 350 | 346 | { |
| 351 | | data |= m_expansion_slot[slot]->io_r(offset); |
| 347 | data |= m_expansion_slot[slot]->io_r(space, offset); |
| 352 | 348 | } |
| 353 | 349 | } |
| 354 | 350 | |
| r19197 | r19198 | |
| 360 | 356 | // comx_io_w - I/O write |
| 361 | 357 | //------------------------------------------------- |
| 362 | 358 | |
| 363 | | void comx_eb_device::comx_io_w(offs_t offset, UINT8 data) |
| 359 | void comx_eb_device::comx_io_w(address_space &space, offs_t offset, UINT8 data) |
| 364 | 360 | { |
| 365 | | if (offset == 1) |
| 361 | if (offset == 1 && !(BIT(data, 0))) |
| 366 | 362 | { |
| 367 | 363 | m_select = data >> 1; |
| 368 | 364 | |
| r19197 | r19198 | |
| 379 | 375 | { |
| 380 | 376 | if (BIT(m_select, slot) && m_expansion_slot[slot] != NULL) |
| 381 | 377 | { |
| 382 | | m_expansion_slot[slot]->io_w(offset, data); |
| 378 | m_expansion_slot[slot]->io_w(space, offset, data); |
| 383 | 379 | } |
| 384 | 380 | } |
| 385 | 381 | } |
trunk/src/mess/machine/comx_eb.h
| r19197 | r19198 | |
| 29 | 29 | // CONSTANTS |
| 30 | 30 | //************************************************************************** |
| 31 | 31 | |
| 32 | | #define MAX_EB_SLOTS 4 |
| 32 | #define MAX_EB_SLOTS 4 |
| 33 | 33 | |
| 34 | 34 | |
| 35 | 35 | |
| r19197 | r19198 | |
| 40 | 40 | // ======================> comx_eb_device |
| 41 | 41 | |
| 42 | 42 | class comx_eb_device : public device_t, |
| 43 | | public device_comx_expansion_card_interface |
| 43 | public device_comx_expansion_card_interface |
| 44 | 44 | { |
| 45 | 45 | public: |
| 46 | 46 | // construction/destruction |
| r19197 | r19198 | |
| 52 | 52 | |
| 53 | 53 | // not really public |
| 54 | 54 | void set_int(const char *tag, int state); |
| 55 | | void set_ef4(const char *tag, int state); |
| 56 | 55 | |
| 57 | 56 | protected: |
| 58 | 57 | // device-level overrides |
| 59 | 58 | virtual void device_start(); |
| 60 | 59 | virtual void device_reset(); |
| 61 | | virtual void device_config_complete() { m_shortname = "comx_eb"; } |
| 60 | virtual void device_config_complete() { m_shortname = "comx_eb"; } |
| 62 | 61 | |
| 63 | 62 | // device_comx_expansion_card_interface overrides |
| 63 | virtual int comx_ef4_r(); |
| 64 | 64 | virtual void comx_q_w(int state); |
| 65 | | virtual UINT8 comx_mrd_r(offs_t offset, int *extrom); |
| 66 | | virtual void comx_mwr_w(offs_t offset, UINT8 data); |
| 67 | | virtual UINT8 comx_io_r(offs_t offset); |
| 68 | | virtual void comx_io_w(offs_t offset, UINT8 data); |
| 65 | virtual UINT8 comx_mrd_r(address_space &space, offs_t offset, int *extrom); |
| 66 | virtual void comx_mwr_w(address_space &space, offs_t offset, UINT8 data); |
| 67 | virtual UINT8 comx_io_r(address_space &space, offs_t offset); |
| 68 | virtual void comx_io_w(address_space &space, offs_t offset, UINT8 data); |
| 69 | 69 | |
| 70 | 70 | private: |
| 71 | | UINT8 *m_rom; // program ROM |
| 71 | UINT8 *m_rom; // program ROM |
| 72 | 72 | |
| 73 | | comx_expansion_slot_device *m_expansion_slot[MAX_EB_SLOTS]; |
| 73 | comx_expansion_slot_device *m_expansion_slot[MAX_EB_SLOTS]; |
| 74 | 74 | int m_int[MAX_EB_SLOTS]; |
| 75 | | int m_ef4[MAX_EB_SLOTS]; |
| 76 | 75 | |
| 77 | 76 | UINT8 m_select; |
| 78 | 77 | }; |
trunk/src/mess/machine/comx_clm.c
| r19197 | r19198 | |
| 53 | 53 | // MACROS/CONSTANTS |
| 54 | 54 | //************************************************************************** |
| 55 | 55 | |
| 56 | | #define MC6845_TAG "mc6845" |
| 57 | | #define MC6845_SCREEN_TAG "screen80" |
| 58 | | #define VIDEORAM_SIZE 0x800 |
| 56 | #define MC6845_TAG "mc6845" |
| 57 | #define MC6845_SCREEN_TAG "screen80" |
| 58 | #define VIDEORAM_SIZE 0x800 |
| 59 | 59 | |
| 60 | 60 | |
| 61 | 61 | |
| r19197 | r19198 | |
| 72 | 72 | |
| 73 | 73 | ROM_START( comx_clm ) |
| 74 | 74 | ROM_REGION( 0x2000, "c000", 0 ) |
| 75 | | ROM_LOAD( "p 1.0.cl1", 0x0000, 0x0800, CRC(b417d30a) SHA1(d428b0467945ecb9aec884211d0f4b1d8d56d738) ) // V1.0 |
| 76 | | ROM_LOAD( "p 1.1.cl1", 0x0000, 0x0800, CRC(0a2eaf19) SHA1(3f1f640caef964fb47aaa147cab6d215c2b30e9d) ) // V1.1 |
| 75 | ROM_DEFAULT_BIOS( "v11" ) |
| 76 | ROM_SYSTEM_BIOS( 0, "v10", "v1.0" ) |
| 77 | ROMX_LOAD( "p 1.0.cl1", 0x0000, 0x0800, CRC(b417d30a) SHA1(d428b0467945ecb9aec884211d0f4b1d8d56d738), ROM_BIOS(1) ) |
| 78 | ROM_SYSTEM_BIOS( 1, "v11", "v1.1" ) |
| 79 | ROMX_LOAD( "p 1.1.cl1", 0x0000, 0x0800, CRC(0a2eaf19) SHA1(3f1f640caef964fb47aaa147cab6d215c2b30e9d), ROM_BIOS(2) ) |
| 77 | 80 | |
| 78 | 81 | ROM_REGION( 0x800, MC6845_TAG, 0 ) |
| 79 | | ROM_LOAD( "c 1.0.cl4", 0x0000, 0x0800, CRC(69dd7b07) SHA1(71d368adbb299103d165eab8359a97769e463e26) ) // V1.0 |
| 80 | | ROM_LOAD( "c 1.1.cl4", 0x0000, 0x0800, CRC(dc9b5046) SHA1(4e041cec03dda6dba5e2598d060c49908a4fab2a) ) // V1.1 |
| 82 | ROMX_LOAD( "c 1.0.cl4", 0x0000, 0x0800, CRC(69dd7b07) SHA1(71d368adbb299103d165eab8359a97769e463e26), ROM_BIOS(1) ) |
| 83 | ROMX_LOAD( "c 1.1.cl4", 0x0000, 0x0800, CRC(dc9b5046) SHA1(4e041cec03dda6dba5e2598d060c49908a4fab2a), ROM_BIOS(2) ) |
| 81 | 84 | ROM_END |
| 82 | 85 | |
| 83 | 86 | |
| r19197 | r19198 | |
| 97 | 100 | |
| 98 | 101 | void comx_clm_device::crtc_update_row(mc6845_device *device, bitmap_rgb32 &bitmap, const rectangle &cliprect, UINT16 ma, UINT8 ra, UINT16 y, UINT8 x_count, INT8 cursor_x, void *param) |
| 99 | 102 | { |
| 100 | | const rgb_t *palette = palette_entry_list_raw(bitmap.palette()); |
| 101 | 103 | for (int column = 0; column < x_count; column++) |
| 102 | 104 | { |
| 103 | 105 | UINT8 code = m_video_ram[((ma + column) & 0x7ff)]; |
| r19197 | r19198 | |
| 114 | 116 | int x = (column * 8) + bit; |
| 115 | 117 | int color = BIT(data, 7) ? 7 : 0; |
| 116 | 118 | |
| 117 | | bitmap.pix32(y, x) = palette[color]; |
| 119 | bitmap.pix32(y, x) = RGB_MONOCHROME_WHITE[color]; |
| 118 | 120 | |
| 119 | 121 | data <<= 1; |
| 120 | 122 | } |
| r19197 | r19198 | |
| 127 | 129 | clm->crtc_update_row(device,bitmap,cliprect,ma,ra,y,x_count,cursor_x,param); |
| 128 | 130 | } |
| 129 | 131 | |
| 130 | | WRITE_LINE_MEMBER( comx_clm_device::hsync_w ) |
| 131 | | { |
| 132 | | if (m_ds) |
| 133 | | { |
| 134 | | m_slot->ef4_w(state); |
| 135 | | } |
| 136 | | else |
| 137 | | { |
| 138 | | m_slot->ef4_w(CLEAR_LINE); |
| 139 | | } |
| 140 | | } |
| 141 | | |
| 142 | 132 | static const mc6845_interface crtc_intf = |
| 143 | 133 | { |
| 144 | 134 | MC6845_SCREEN_TAG, |
| r19197 | r19198 | |
| 148 | 138 | NULL, |
| 149 | 139 | DEVCB_NULL, |
| 150 | 140 | DEVCB_NULL, |
| 151 | | DEVCB_DEVICE_LINE_MEMBER(DEVICE_SELF_OWNER, comx_clm_device, hsync_w), |
| 152 | 141 | DEVCB_NULL, |
| 142 | DEVCB_NULL, |
| 153 | 143 | NULL |
| 154 | 144 | }; |
| 155 | 145 | |
| r19197 | r19198 | |
| 205 | 195 | device_t(mconfig, COMX_CLM, "COMX 80 Column Card", tag, owner, clock), |
| 206 | 196 | device_comx_expansion_card_interface(mconfig, *this), |
| 207 | 197 | m_crtc(*this, MC6845_TAG), |
| 208 | | m_ds(0) |
| 198 | m_video_ram(*this, "video_ram") |
| 209 | 199 | { |
| 210 | 200 | } |
| 211 | 201 | |
| r19197 | r19198 | |
| 216 | 206 | |
| 217 | 207 | void comx_clm_device::device_start() |
| 218 | 208 | { |
| 209 | // find memory regions |
| 219 | 210 | m_rom = memregion("c000")->base(); |
| 220 | 211 | m_char_rom = memregion(MC6845_TAG)->base(); |
| 221 | | m_video_ram = auto_alloc_array(machine(), UINT8, VIDEORAM_SIZE); |
| 222 | 212 | |
| 213 | // allocate memory |
| 214 | m_video_ram.allocate(VIDEORAM_SIZE); |
| 215 | |
| 223 | 216 | // state saving |
| 224 | 217 | save_item(NAME(m_ds)); |
| 225 | | save_pointer(NAME(m_video_ram), VIDEORAM_SIZE); |
| 226 | 218 | } |
| 227 | 219 | |
| 228 | 220 | |
| r19197 | r19198 | |
| 236 | 228 | |
| 237 | 229 | |
| 238 | 230 | //------------------------------------------------- |
| 239 | | // comx_ds_w - device select write |
| 231 | // comx_ef4_r - external flag 4 read |
| 240 | 232 | //------------------------------------------------- |
| 241 | 233 | |
| 242 | | void comx_clm_device::comx_ds_w(int state) |
| 234 | int comx_clm_device::comx_ef4_r() |
| 243 | 235 | { |
| 244 | | m_ds = state; |
| 236 | return m_ds ? m_crtc->hsync_r() : CLEAR_LINE; |
| 245 | 237 | } |
| 246 | 238 | |
| 247 | 239 | |
| r19197 | r19198 | |
| 249 | 241 | // comx_mrd_r - memory read |
| 250 | 242 | //------------------------------------------------- |
| 251 | 243 | |
| 252 | | UINT8 comx_clm_device::comx_mrd_r(offs_t offset, int *extrom) |
| 244 | UINT8 comx_clm_device::comx_mrd_r(address_space &space, offs_t offset, int *extrom) |
| 253 | 245 | { |
| 254 | | address_space &space = machine().firstcpu->space(AS_PROGRAM); |
| 255 | | |
| 256 | 246 | UINT8 data = 0xff; |
| 257 | 247 | |
| 258 | 248 | if (offset >= 0xc000 && offset < 0xc800) |
| r19197 | r19198 | |
| 276 | 266 | // comx_mwr_w - memory write |
| 277 | 267 | //------------------------------------------------- |
| 278 | 268 | |
| 279 | | void comx_clm_device::comx_mwr_w(offs_t offset, UINT8 data) |
| 269 | void comx_clm_device::comx_mwr_w(address_space &space, offs_t offset, UINT8 data) |
| 280 | 270 | { |
| 281 | | address_space &space = machine().firstcpu->space(AS_PROGRAM); |
| 282 | | |
| 283 | 271 | if (offset >= 0xd000 && offset < 0xd800) |
| 284 | 272 | { |
| 285 | 273 | m_video_ram[offset & 0x7ff] = data; |
trunk/src/mess/machine/comx_clm.h
| r19197 | r19198 | |
| 26 | 26 | // ======================> comx_clm_device |
| 27 | 27 | |
| 28 | 28 | class comx_clm_device : public device_t, |
| 29 | | public device_comx_expansion_card_interface |
| 29 | public device_comx_expansion_card_interface |
| 30 | 30 | { |
| 31 | 31 | public: |
| 32 | 32 | // construction/destruction |
| r19197 | r19198 | |
| 38 | 38 | |
| 39 | 39 | // not really public |
| 40 | 40 | void crtc_update_row(mc6845_device *device, bitmap_rgb32 &bitmap, const rectangle &cliprect, UINT16 ma, UINT8 ra, UINT16 y, UINT8 x_count, INT8 cursor_x, void *param); |
| 41 | | DECLARE_WRITE_LINE_MEMBER( hsync_w ); |
| 42 | 41 | |
| 43 | 42 | protected: |
| 44 | 43 | // device-level overrides |
| 45 | 44 | virtual void device_start(); |
| 46 | 45 | virtual void device_reset(); |
| 47 | | virtual void device_config_complete() { m_shortname = "comx_clm"; } |
| 46 | virtual void device_config_complete() { m_shortname = "comx_clm"; } |
| 48 | 47 | |
| 49 | 48 | // device_comx_expansion_card_interface overrides |
| 50 | | virtual void comx_ds_w(int state); |
| 51 | | virtual UINT8 comx_mrd_r(offs_t offset, int *extrom); |
| 52 | | virtual void comx_mwr_w(offs_t offset, UINT8 data); |
| 49 | virtual int comx_ef4_r(); |
| 50 | virtual UINT8 comx_mrd_r(address_space &space, offs_t offset, int *extrom); |
| 51 | virtual void comx_mwr_w(address_space &space, offs_t offset, UINT8 data); |
| 53 | 52 | |
| 54 | 53 | private: |
| 55 | 54 | required_device<mc6845_device> m_crtc; |
| 55 | optional_shared_ptr<UINT8> m_video_ram; |
| 56 | 56 | |
| 57 | | int m_ds; // device select |
| 58 | | UINT8 *m_rom; // program ROM |
| 59 | | UINT8 *m_char_rom; // character ROM |
| 60 | | UINT8 *m_video_ram; // video RAM |
| 57 | UINT8 *m_rom; // program ROM |
| 58 | UINT8 *m_char_rom; // character ROM |
| 61 | 59 | }; |
| 62 | 60 | |
| 63 | 61 | |
trunk/src/mess/machine/comxpl80.c
| r19197 | r19198 | |
| 31 | 31 | // DEVICE DEFINITIONS |
| 32 | 32 | //************************************************************************** |
| 33 | 33 | |
| 34 | | const device_type COMXPL80 = &device_creator<comxpl80_device>; |
| 34 | const device_type COMX_PL80 = &device_creator<comx_pl80_device>; |
| 35 | 35 | |
| 36 | | //------------------------------------------------- |
| 37 | | // device_config_complete - perform any |
| 38 | | // operations now that the configuration is |
| 39 | | // complete |
| 40 | | //------------------------------------------------- |
| 41 | 36 | |
| 42 | | void comxpl80_device::device_config_complete() |
| 43 | | { |
| 44 | | // inherit a copy of the static data |
| 45 | | const comxpl80_interface *intf = reinterpret_cast<const comxpl80_interface *>(static_config()); |
| 46 | | if (intf != NULL) |
| 47 | | *static_cast<comxpl80_interface *>(this) = *intf; |
| 48 | | |
| 49 | | // or initialize to defaults if none provided |
| 50 | | else |
| 51 | | { |
| 52 | | } |
| 53 | | |
| 54 | | m_shortname = "comxpl80"; |
| 55 | | } |
| 56 | | |
| 57 | | |
| 58 | 37 | //------------------------------------------------- |
| 59 | 38 | // ROM( comxpl80 ) |
| 60 | 39 | //------------------------------------------------- |
| r19197 | r19198 | |
| 73 | 52 | // rom_region - device-specific ROM region |
| 74 | 53 | //------------------------------------------------- |
| 75 | 54 | |
| 76 | | const rom_entry *comxpl80_device::device_rom_region() const |
| 55 | const rom_entry *comx_pl80_device::device_rom_region() const |
| 77 | 56 | { |
| 78 | 57 | return ROM_NAME( comxpl80 ); |
| 79 | 58 | } |
| r19197 | r19198 | |
| 83 | 62 | // ADDRESS_MAP( comxpl80_mem ) |
| 84 | 63 | //------------------------------------------------- |
| 85 | 64 | |
| 86 | | static ADDRESS_MAP_START( comxpl80_mem, AS_PROGRAM, 8, comxpl80_device ) |
| 65 | static ADDRESS_MAP_START( comxpl80_mem, AS_PROGRAM, 8, comx_pl80_device ) |
| 87 | 66 | /* AM_RANGE(0x000, 0x000) AM_READWRITE(cx005_port_a_r, cx005_port_a_w) |
| 88 | 67 | AM_RANGE(0x001, 0x001) AM_READWRITE(cx005_port_b_r, cx005_port_b_w) |
| 89 | 68 | AM_RANGE(0x002, 0x002) AM_READWRITE(cx005_port_c_r, cx005_port_c_w) |
| r19197 | r19198 | |
| 106 | 85 | // ADDRESS_MAP( comxpl80_io ) |
| 107 | 86 | //------------------------------------------------- |
| 108 | 87 | |
| 109 | | static ADDRESS_MAP_START( comxpl80_io, AS_IO, 8, comxpl80_device ) |
| 88 | static ADDRESS_MAP_START( comxpl80_io, AS_IO, 8, comx_pl80_device ) |
| 110 | 89 | ADDRESS_MAP_UNMAP_HIGH |
| 111 | 90 | AM_RANGE(0x00, 0x00) AM_WRITE(pa_w) |
| 112 | 91 | AM_RANGE(0x01, 0x01) AM_WRITE(pb_w) |
| r19197 | r19198 | |
| 132 | 111 | // machine configurations |
| 133 | 112 | //------------------------------------------------- |
| 134 | 113 | |
| 135 | | machine_config_constructor comxpl80_device::device_mconfig_additions() const |
| 114 | machine_config_constructor comx_pl80_device::device_mconfig_additions() const |
| 136 | 115 | { |
| 137 | 116 | return MACHINE_CONFIG_NAME( comxpl80 ); |
| 138 | 117 | } |
| r19197 | r19198 | |
| 165 | 144 | // input_ports - device-specific input ports |
| 166 | 145 | //------------------------------------------------- |
| 167 | 146 | |
| 168 | | ioport_constructor comxpl80_device::device_input_ports() const |
| 147 | ioport_constructor comx_pl80_device::device_input_ports() const |
| 169 | 148 | { |
| 170 | 149 | return INPUT_PORTS_NAME( comxpl80 ); |
| 171 | 150 | } |
| r19197 | r19198 | |
| 177 | 156 | //************************************************************************** |
| 178 | 157 | |
| 179 | 158 | //------------------------------------------------- |
| 180 | | // comxpl80_device - constructor |
| 159 | // comx_pl80_device - constructor |
| 181 | 160 | //------------------------------------------------- |
| 182 | 161 | |
| 183 | | comxpl80_device::comxpl80_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) |
| 184 | | : device_t(mconfig, COMXPL80, "COMX PL-80", tag, owner, clock) |
| 162 | comx_pl80_device::comx_pl80_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) |
| 163 | : device_t(mconfig, COMX_PL80, "COMX PL-80", tag, owner, clock), |
| 164 | device_centronics_peripheral_interface(mconfig, *this) |
| 185 | 165 | { |
| 186 | 166 | } |
| 187 | 167 | |
| r19197 | r19198 | |
| 190 | 170 | // device_start - device-specific startup |
| 191 | 171 | //------------------------------------------------- |
| 192 | 172 | |
| 193 | | void comxpl80_device::device_start() |
| 173 | void comx_pl80_device::device_start() |
| 194 | 174 | { |
| 195 | 175 | // state saving |
| 196 | | save_item(NAME(m_centronics_data)); |
| 197 | 176 | save_item(NAME(m_font_addr)); |
| 198 | 177 | save_item(NAME(m_x_motor_phase)); |
| 199 | 178 | save_item(NAME(m_y_motor_phase)); |
| r19197 | r19198 | |
| 208 | 187 | // device_reset - device-specific reset |
| 209 | 188 | //------------------------------------------------- |
| 210 | 189 | |
| 211 | | void comxpl80_device::device_reset() |
| 190 | void comx_pl80_device::device_reset() |
| 212 | 191 | { |
| 213 | 192 | } |
| 214 | 193 | |
| r19197 | r19198 | |
| 217 | 196 | // pa_w - |
| 218 | 197 | //------------------------------------------------- |
| 219 | 198 | |
| 220 | | WRITE8_MEMBER( comxpl80_device::pa_w ) |
| 199 | WRITE8_MEMBER( comx_pl80_device::pa_w ) |
| 221 | 200 | { |
| 222 | 201 | /* |
| 223 | 202 | |
| r19197 | r19198 | |
| 254 | 233 | if (!BIT(data, 6)) |
| 255 | 234 | { |
| 256 | 235 | // read data from Centronics bus |
| 257 | | m_plotter_data = m_centronics_data; |
| 236 | m_plotter_data = m_data; |
| 258 | 237 | } |
| 259 | 238 | |
| 260 | 239 | if (BIT(data, 7)) |
| r19197 | r19198 | |
| 269 | 248 | // pb_w - |
| 270 | 249 | //------------------------------------------------- |
| 271 | 250 | |
| 272 | | WRITE8_MEMBER( comxpl80_device::pb_w ) |
| 251 | WRITE8_MEMBER( comx_pl80_device::pb_w ) |
| 273 | 252 | { |
| 274 | 253 | /* |
| 275 | 254 | |
| r19197 | r19198 | |
| 296 | 275 | // pc_w - |
| 297 | 276 | //------------------------------------------------- |
| 298 | 277 | |
| 299 | | WRITE8_MEMBER( comxpl80_device::pc_w ) |
| 278 | WRITE8_MEMBER( comx_pl80_device::pc_w ) |
| 300 | 279 | { |
| 301 | 280 | /* |
| 302 | 281 | |
| r19197 | r19198 | |
| 326 | 305 | // pd_r - |
| 327 | 306 | //------------------------------------------------- |
| 328 | 307 | |
| 329 | | READ8_MEMBER( comxpl80_device::pd_r ) |
| 308 | READ8_MEMBER( comx_pl80_device::pd_r ) |
| 330 | 309 | { |
| 331 | 310 | /* |
| 332 | 311 | |
trunk/src/mess/machine/comxpl80.h
| r19197 | r19198 | |
| 9 | 9 | |
| 10 | 10 | #pragma once |
| 11 | 11 | |
| 12 | | #ifndef __COMXPL80__ |
| 13 | | #define __COMXPL80__ |
| 12 | #ifndef __COMX_PL80__ |
| 13 | #define __COMX_PL80__ |
| 14 | 14 | |
| 15 | 15 | #include "emu.h" |
| 16 | 16 | #include "cpu/m6805/m6805.h" |
| 17 | #include "machine/ctronics.h" |
| 17 | 18 | |
| 18 | 19 | |
| 19 | 20 | |
| 20 | 21 | //************************************************************************** |
| 21 | | // MACROS / CONSTANTS |
| 22 | | //************************************************************************** |
| 23 | | |
| 24 | | #define COMXPL80_TAG "comxpl80" |
| 25 | | |
| 26 | | |
| 27 | | |
| 28 | | //************************************************************************** |
| 29 | | // INTERFACE CONFIGURATION MACROS |
| 30 | | //************************************************************************** |
| 31 | | |
| 32 | | #define MCFG_COMXPL80_ADD() \ |
| 33 | | MCFG_DEVICE_ADD(COMXPL80_TAG, COMXPL80, 0) |
| 34 | | |
| 35 | | |
| 36 | | #define COMXPL80_INTERFACE(_name) \ |
| 37 | | const comxpl80_interface (_name) = |
| 38 | | |
| 39 | | |
| 40 | | |
| 41 | | //************************************************************************** |
| 42 | 22 | // TYPE DEFINITIONS |
| 43 | 23 | //************************************************************************** |
| 44 | 24 | |
| 45 | | // ======================> comxpl80_interface |
| 25 | // ======================> comx_pl80_device |
| 46 | 26 | |
| 47 | | struct comxpl80_interface |
| 27 | class comx_pl80_device : public device_t, |
| 28 | public device_centronics_peripheral_interface |
| 48 | 29 | { |
| 49 | | devcb_write_line m_out_txd_cb; |
| 50 | | devcb_write_line m_out_clock_cb; |
| 51 | | devcb_write_line m_out_keydown_cb; |
| 52 | | }; |
| 53 | | |
| 54 | | // ======================> comxpl80_device |
| 55 | | |
| 56 | | class comxpl80_device : public device_t, |
| 57 | | public comxpl80_interface |
| 58 | | { |
| 59 | 30 | public: |
| 60 | 31 | // construction/destruction |
| 61 | | comxpl80_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 32 | comx_pl80_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 33 | |
| 62 | 34 | // optional information overrides |
| 63 | 35 | virtual const rom_entry *device_rom_region() const; |
| 64 | 36 | virtual machine_config_constructor device_mconfig_additions() const; |
| 65 | 37 | virtual ioport_constructor device_input_ports() const; |
| 66 | 38 | |
| 39 | // not really public |
| 67 | 40 | DECLARE_WRITE8_MEMBER( pa_w ); |
| 68 | 41 | DECLARE_WRITE8_MEMBER( pb_w ); |
| 69 | 42 | DECLARE_WRITE8_MEMBER( pc_w ); |
| r19197 | r19198 | |
| 71 | 44 | |
| 72 | 45 | protected: |
| 73 | 46 | // device-level overrides |
| 47 | virtual void device_config_complete() { m_shortname = "comx_pl80"; } |
| 74 | 48 | virtual void device_start(); |
| 75 | 49 | virtual void device_reset(); |
| 76 | | virtual void device_config_complete(); |
| 77 | 50 | |
| 78 | 51 | private: |
| 79 | | // printer state |
| 80 | | UINT8 m_centronics_data; // centronics data |
| 81 | | |
| 82 | 52 | // PL-80 plotter state |
| 83 | 53 | UINT16 m_font_addr; // font ROM pack address latch |
| 84 | 54 | UINT8 m_x_motor_phase; // X motor phase |
| r19197 | r19198 | |
| 91 | 61 | |
| 92 | 62 | |
| 93 | 63 | // device type definition |
| 94 | | extern const device_type COMXPL80; |
| 64 | extern const device_type COMX_PL80; |
| 95 | 65 | |
| 96 | 66 | |
| 97 | 67 | |
trunk/src/mess/machine/comx_fd.c
| r19197 | r19198 | |
| 50 | 50 | // MACROS/CONSTANTS |
| 51 | 51 | //************************************************************************** |
| 52 | 52 | |
| 53 | | #define WD1770_TAG "wd1770" |
| 53 | #define WD1770_TAG "wd1770" |
| 54 | 54 | |
| 55 | 55 | |
| 56 | 56 | |
| r19197 | r19198 | |
| 67 | 67 | |
| 68 | 68 | ROM_START( comx_fd ) |
| 69 | 69 | ROM_REGION( 0x2000, "c000", 0 ) |
| 70 | | ROM_LOAD( "d.o.s. v1.2.f4", 0x0000, 0x2000, CRC(cf4ecd2e) SHA1(290e19bdc89e3c8059e63d5ae3cca4daa194e1fe) ) |
| 70 | ROM_LOAD( "d.o.s. v1.2.f4", 0x0000, 0x2000, CRC(cf4ecd2e) SHA1(290e19bdc89e3c8059e63d5ae3cca4daa194e1fe) ) |
| 71 | 71 | ROM_END |
| 72 | 72 | |
| 73 | 73 | |
| r19197 | r19198 | |
| 85 | 85 | // wd17xx_interface fdc_intf |
| 86 | 86 | //------------------------------------------------- |
| 87 | 87 | |
| 88 | | static const floppy_interface floppy_intf = |
| 89 | | { |
| 90 | | DEVCB_NULL, |
| 91 | | DEVCB_NULL, |
| 92 | | DEVCB_NULL, |
| 93 | | DEVCB_NULL, |
| 94 | | DEVCB_NULL, |
| 95 | | FLOPPY_STANDARD_5_25_DSSD, |
| 96 | | LEGACY_FLOPPY_OPTIONS_NAME(comx35), |
| 97 | | "floppy_5_25", |
| 98 | | NULL |
| 99 | | }; |
| 88 | FLOPPY_FORMATS_MEMBER( comx_fd_device::floppy_formats ) |
| 89 | FLOPPY_COMX35_FORMAT |
| 90 | FLOPPY_FORMATS_END |
| 100 | 91 | |
| 101 | | WRITE_LINE_MEMBER( comx_fd_device::intrq_w ) |
| 92 | static SLOT_INTERFACE_START( comx_fd_floppies ) |
| 93 | SLOT_INTERFACE( "525sd35t", FLOPPY_525_SD_35T ) |
| 94 | SLOT_INTERFACE( "525qd", FLOPPY_525_QD ) |
| 95 | SLOT_INTERFACE_END |
| 96 | |
| 97 | void comx_fd_device::intrq_w(bool state) |
| 102 | 98 | { |
| 103 | 99 | m_intrq = state; |
| 104 | 100 | } |
| 105 | 101 | |
| 106 | | WRITE_LINE_MEMBER( comx_fd_device::drq_w ) |
| 102 | void comx_fd_device::drq_w(bool state) |
| 107 | 103 | { |
| 108 | 104 | m_drq = state; |
| 109 | | |
| 110 | | update_ef4(); |
| 111 | 105 | } |
| 112 | 106 | |
| 113 | | static const wd17xx_interface fdc_intf = |
| 114 | | { |
| 115 | | DEVCB_LINE_VCC, |
| 116 | | DEVCB_DEVICE_LINE_MEMBER(DEVICE_SELF_OWNER, comx_fd_device, intrq_w), |
| 117 | | DEVCB_DEVICE_LINE_MEMBER(DEVICE_SELF_OWNER, comx_fd_device, drq_w), |
| 118 | | { FLOPPY_0, FLOPPY_1, NULL, NULL } |
| 119 | | }; |
| 120 | 107 | |
| 121 | | |
| 122 | 108 | //------------------------------------------------- |
| 123 | 109 | // MACHINE_CONFIG_FRAGMENT( comx_fd ) |
| 124 | 110 | //------------------------------------------------- |
| 125 | 111 | |
| 126 | 112 | static MACHINE_CONFIG_FRAGMENT( comx_fd ) |
| 127 | | MCFG_WD1770_ADD(WD1770_TAG, fdc_intf) |
| 128 | | MCFG_LEGACY_FLOPPY_2_DRIVES_ADD(floppy_intf) |
| 113 | MCFG_WD1770x_ADD(WD1770_TAG, XTAL_8MHz) |
| 114 | |
| 115 | MCFG_FLOPPY_DRIVE_ADD(WD1770_TAG":0", comx_fd_floppies, "525sd35t", NULL, comx_fd_device::floppy_formats) |
| 116 | MCFG_FLOPPY_DRIVE_ADD(WD1770_TAG":1", comx_fd_floppies, NULL, NULL, comx_fd_device::floppy_formats) |
| 129 | 117 | MACHINE_CONFIG_END |
| 130 | 118 | |
| 131 | 119 | |
| r19197 | r19198 | |
| 142 | 130 | |
| 143 | 131 | |
| 144 | 132 | //************************************************************************** |
| 145 | | // INLINE HELPERS |
| 146 | | //************************************************************************** |
| 147 | | |
| 148 | | //------------------------------------------------- |
| 149 | | // update_ef4 - |
| 150 | | //------------------------------------------------- |
| 151 | | |
| 152 | | inline void comx_fd_device::update_ef4() |
| 153 | | { |
| 154 | | if (m_ds && !m_disb) |
| 155 | | { |
| 156 | | m_slot->ef4_w(!m_drq); |
| 157 | | } |
| 158 | | else |
| 159 | | { |
| 160 | | m_slot->ef4_w(CLEAR_LINE); |
| 161 | | } |
| 162 | | } |
| 163 | | |
| 164 | | |
| 165 | | |
| 166 | | //************************************************************************** |
| 167 | 133 | // LIVE DEVICE |
| 168 | 134 | //************************************************************************** |
| 169 | 135 | |
| r19197 | r19198 | |
| 175 | 141 | device_t(mconfig, COMX_FD, "COMX FD", tag, owner, clock), |
| 176 | 142 | device_comx_expansion_card_interface(mconfig, *this), |
| 177 | 143 | m_fdc(*this, WD1770_TAG), |
| 178 | | m_floppy0(*this, FLOPPY_0), |
| 179 | | m_floppy1(*this, FLOPPY_1), |
| 144 | m_floppy0(*this, WD1770_TAG":0"), |
| 145 | m_floppy1(*this, WD1770_TAG":1"), |
| 180 | 146 | m_ds(0), |
| 181 | 147 | m_q(0), |
| 182 | 148 | m_addr(0), |
| 183 | | m_intrq(0), |
| 184 | | m_drq(0), |
| 149 | m_intrq(false), |
| 150 | m_drq(false), |
| 185 | 151 | m_disb(1) |
| 186 | 152 | { |
| 187 | 153 | } |
| r19197 | r19198 | |
| 193 | 159 | |
| 194 | 160 | void comx_fd_device::device_start() |
| 195 | 161 | { |
| 162 | // find memory regions |
| 196 | 163 | m_rom = memregion("c000")->base(); |
| 197 | 164 | |
| 165 | // initialize floppy controller |
| 166 | m_fdc->setup_intrq_cb(wd1770_t::line_cb(FUNC(comx_fd_device::intrq_w), this)); |
| 167 | m_fdc->setup_drq_cb(wd1770_t::line_cb(FUNC(comx_fd_device::drq_w), this)); |
| 168 | m_fdc->dden_w(1); |
| 169 | |
| 198 | 170 | // state saving |
| 199 | 171 | save_item(NAME(m_ds)); |
| 200 | 172 | save_item(NAME(m_q)); |
| r19197 | r19198 | |
| 211 | 183 | |
| 212 | 184 | void comx_fd_device::device_reset() |
| 213 | 185 | { |
| 214 | | wd17xx_reset(m_fdc); |
| 186 | m_fdc->reset(); |
| 215 | 187 | } |
| 216 | 188 | |
| 217 | 189 | |
| 218 | 190 | //------------------------------------------------- |
| 219 | | // comx_q_w - Q write |
| 191 | // comx_ef4_r - external flag 4 read |
| 220 | 192 | //------------------------------------------------- |
| 221 | 193 | |
| 222 | | void comx_fd_device::comx_q_w(int state) |
| 194 | int comx_fd_device::comx_ef4_r() |
| 223 | 195 | { |
| 224 | | m_q = state; |
| 196 | int state = CLEAR_LINE; |
| 197 | |
| 198 | if (m_ds && !m_disb) |
| 199 | { |
| 200 | state = m_drq ? ASSERT_LINE : CLEAR_LINE; |
| 201 | } |
| 202 | |
| 203 | return state; |
| 225 | 204 | } |
| 226 | 205 | |
| 227 | 206 | |
| 228 | 207 | //------------------------------------------------- |
| 229 | | // comx_ds_w - device select write |
| 208 | // comx_q_w - Q write |
| 230 | 209 | //------------------------------------------------- |
| 231 | 210 | |
| 232 | | void comx_fd_device::comx_ds_w(int state) |
| 211 | void comx_fd_device::comx_q_w(int state) |
| 233 | 212 | { |
| 234 | | m_ds = state; |
| 235 | | |
| 236 | | update_ef4(); |
| 213 | m_q = state; |
| 237 | 214 | } |
| 238 | 215 | |
| 239 | 216 | |
| r19197 | r19198 | |
| 241 | 218 | // comx_mrd_r - memory read |
| 242 | 219 | //------------------------------------------------- |
| 243 | 220 | |
| 244 | | UINT8 comx_fd_device::comx_mrd_r(offs_t offset, int *extrom) |
| 221 | UINT8 comx_fd_device::comx_mrd_r(address_space &space, offs_t offset, int *extrom) |
| 245 | 222 | { |
| 246 | 223 | UINT8 data = 0xff; |
| 247 | 224 | |
| r19197 | r19198 | |
| 263 | 240 | // comx_io_r - I/O read |
| 264 | 241 | //------------------------------------------------- |
| 265 | 242 | |
| 266 | | UINT8 comx_fd_device::comx_io_r(offs_t offset) |
| 243 | UINT8 comx_fd_device::comx_io_r(address_space &space, offs_t offset) |
| 267 | 244 | { |
| 268 | 245 | UINT8 data = 0xff; |
| 269 | 246 | |
| r19197 | r19198 | |
| 271 | 248 | { |
| 272 | 249 | if (m_q) |
| 273 | 250 | { |
| 274 | | data = m_intrq; |
| 251 | data = m_intrq ? 1 : 0; |
| 275 | 252 | } |
| 276 | 253 | else |
| 277 | 254 | { |
| 278 | | data = wd17xx_r(m_fdc, machine().driver_data()->generic_space(), m_addr); |
| 255 | data = m_fdc->gen_r(m_addr); |
| 279 | 256 | } |
| 280 | 257 | } |
| 281 | 258 | |
| r19197 | r19198 | |
| 287 | 264 | // comx_io_w - I/O write |
| 288 | 265 | //------------------------------------------------- |
| 289 | 266 | |
| 290 | | void comx_fd_device::comx_io_w(offs_t offset, UINT8 data) |
| 267 | void comx_fd_device::comx_io_w(address_space &space, offs_t offset, UINT8 data) |
| 291 | 268 | { |
| 292 | 269 | if (offset == 2) |
| 293 | 270 | { |
| r19197 | r19198 | |
| 295 | 272 | { |
| 296 | 273 | /* |
| 297 | 274 | |
| 298 | | bit description |
| 275 | bit description |
| 299 | 276 | |
| 300 | | 0 A0 |
| 301 | | 1 A1 |
| 302 | | 2 DRIVE0 |
| 303 | | 3 DRIVE1 |
| 304 | | 4 F9 DISB |
| 305 | | 5 SIDE SELECT |
| 277 | 0 FDC A0 |
| 278 | 1 FDC A1 |
| 279 | 2 DRIVE0 |
| 280 | 3 DRIVE1 |
| 281 | 4 F9 DISB |
| 282 | 5 SIDE SELECT |
| 306 | 283 | |
| 307 | | */ |
| 284 | */ |
| 308 | 285 | |
| 309 | 286 | // latch data to F3 |
| 310 | 287 | m_addr = data & 0x03; |
| 311 | 288 | |
| 312 | | if (BIT(data, 2)) |
| 313 | | { |
| 314 | | wd17xx_set_drive(m_fdc, 0); |
| 315 | | } |
| 316 | | else if (BIT(data, 3)) |
| 317 | | { |
| 318 | | wd17xx_set_drive(m_fdc, 1); |
| 319 | | } |
| 289 | // drive select |
| 290 | floppy_image_device *floppy = NULL; |
| 320 | 291 | |
| 321 | | m_disb = !BIT(data, 4); |
| 322 | | update_ef4(); |
| 292 | if (BIT(data, 2)) floppy = m_floppy0->get_device(); |
| 293 | if (BIT(data, 3)) floppy = m_floppy1->get_device(); |
| 323 | 294 | |
| 324 | | wd17xx_set_side(m_fdc, BIT(data, 5)); |
| 295 | m_fdc->set_floppy(floppy); |
| 296 | |
| 297 | if (floppy) floppy->ss_w(BIT(data, 5)); |
| 298 | |
| 299 | m_disb = !BIT(data, 4); |
| 325 | 300 | } |
| 326 | 301 | else |
| 327 | 302 | { |
| 328 | 303 | // write data to WD1770 |
| 329 | | wd17xx_w(m_fdc, machine().driver_data()->generic_space(), m_addr, data); |
| 304 | m_fdc->gen_w(m_addr, data); |
| 330 | 305 | } |
| 331 | 306 | } |
| 332 | 307 | } |
trunk/src/mess/machine/comx_fd.h
| r19197 | r19198 | |
| 14 | 14 | |
| 15 | 15 | |
| 16 | 16 | #include "emu.h" |
| 17 | | #include "formats/basicdsk.h" |
| 18 | 17 | #include "formats/comx35_dsk.h" |
| 19 | | #include "imagedev/flopdrv.h" |
| 20 | 18 | #include "machine/comxexp.h" |
| 21 | | #include "machine/wd17xx.h" |
| 19 | #include "machine/wd_fdc.h" |
| 22 | 20 | |
| 23 | 21 | |
| 24 | 22 | |
| r19197 | r19198 | |
| 29 | 27 | // ======================> comx_fd_device |
| 30 | 28 | |
| 31 | 29 | class comx_fd_device : public device_t, |
| 32 | | public device_comx_expansion_card_interface |
| 30 | public device_comx_expansion_card_interface |
| 33 | 31 | { |
| 34 | 32 | public: |
| 35 | 33 | // construction/destruction |
| r19197 | r19198 | |
| 40 | 38 | virtual machine_config_constructor device_mconfig_additions() const; |
| 41 | 39 | |
| 42 | 40 | // not really public |
| 43 | | DECLARE_WRITE_LINE_MEMBER( intrq_w ); |
| 44 | | DECLARE_WRITE_LINE_MEMBER( drq_w ); |
| 41 | void intrq_w(bool state); |
| 42 | void drq_w(bool state); |
| 45 | 43 | |
| 44 | DECLARE_FLOPPY_FORMATS( floppy_formats ); |
| 45 | |
| 46 | 46 | protected: |
| 47 | 47 | // device-level overrides |
| 48 | 48 | virtual void device_start(); |
| 49 | 49 | virtual void device_reset(); |
| 50 | | virtual void device_config_complete() { m_shortname = "comx_fd"; } |
| 50 | virtual void device_config_complete() { m_shortname = "comx_fd"; } |
| 51 | 51 | |
| 52 | 52 | // device_comx_expansion_card_interface overrides |
| 53 | | virtual void comx_ds_w(int state); |
| 53 | virtual int comx_ef4_r(); |
| 54 | 54 | virtual void comx_q_w(int state); |
| 55 | | virtual UINT8 comx_mrd_r(offs_t offset, int *extrom); |
| 56 | | virtual UINT8 comx_io_r(offs_t offset); |
| 57 | | virtual void comx_io_w(offs_t offset, UINT8 data); |
| 55 | virtual UINT8 comx_mrd_r(address_space &space, offs_t offset, int *extrom); |
| 56 | virtual UINT8 comx_io_r(address_space &space, offs_t offset); |
| 57 | virtual void comx_io_w(address_space &space, offs_t offset, UINT8 data); |
| 58 | 58 | |
| 59 | 59 | private: |
| 60 | 60 | inline void update_ef4(); |
| 61 | 61 | |
| 62 | 62 | // internal state |
| 63 | | required_device<wd1770_device> m_fdc; |
| 64 | | required_device<legacy_floppy_image_device> m_floppy0; |
| 65 | | required_device<legacy_floppy_image_device> m_floppy1; |
| 63 | required_device<wd1770_t> m_fdc; |
| 64 | required_device<floppy_connector> m_floppy0; |
| 65 | required_device<floppy_connector> m_floppy1; |
| 66 | 66 | |
| 67 | 67 | // floppy state |
| 68 | | int m_ds; // device select |
| 68 | int m_ds; // device select |
| 69 | 69 | UINT8 *m_rom; |
| 70 | | int m_q; // FDC register select |
| 71 | | int m_addr; // FDC address |
| 72 | | int m_intrq; // interrupt request |
| 73 | | int m_drq; // data request |
| 74 | | int m_disb; // data request disable |
| 70 | int m_q; // FDC register select |
| 71 | int m_addr; // FDC address |
| 72 | bool m_intrq; // interrupt request |
| 73 | bool m_drq; // data request |
| 74 | int m_disb; // data request disable |
| 75 | 75 | }; |
| 76 | 76 | |
| 77 | 77 | |
trunk/src/mess/includes/comx35.h
| r19197 | r19198 | |
| 6 | 6 | |
| 7 | 7 | #include "emu.h" |
| 8 | 8 | #include "cpu/cosmac/cosmac.h" |
| 9 | | #include "sound/cdp1869.h" |
| 10 | | #include "sound/wave.h" |
| 11 | 9 | #include "formats/comx35_comx.h" |
| 12 | 10 | #include "imagedev/cassette.h" |
| 13 | 11 | #include "imagedev/printer.h" |
| r19197 | r19198 | |
| 25 | 23 | #include "machine/comx_thm.h" |
| 26 | 24 | #include "machine/ram.h" |
| 27 | 25 | #include "machine/rescap.h" |
| 26 | #include "sound/cdp1869.h" |
| 27 | #include "sound/wave.h" |
| 28 | 28 | |
| 29 | | #define SCREEN_TAG "screen" |
| 29 | #define SCREEN_TAG "screen" |
| 30 | 30 | |
| 31 | | #define CDP1870_TAG "u1" |
| 32 | | #define CDP1869_TAG "u2" |
| 33 | | #define CDP1802_TAG "u3" |
| 34 | | #define CDP1871_TAG "u4" |
| 35 | | #define EXPANSION_TAG "slot" |
| 31 | #define CDP1870_TAG "u1" |
| 32 | #define CDP1869_TAG "u2" |
| 33 | #define CDP1802_TAG "u3" |
| 34 | #define CDP1871_TAG "u4" |
| 35 | #define EXPANSION_TAG "exp" |
| 36 | 36 | |
| 37 | 37 | #define COMX35_CHARRAM_SIZE 0x800 |
| 38 | 38 | #define COMX35_CHARRAM_MASK 0x7ff |
| r19197 | r19198 | |
| 42 | 42 | public: |
| 43 | 43 | comx35_state(const machine_config &mconfig, device_type type, const char *tag) |
| 44 | 44 | : driver_device(mconfig, type, tag), |
| 45 | | m_maincpu(*this, CDP1802_TAG), |
| 46 | | m_vis(*this, CDP1869_TAG), |
| 47 | | m_kbe(*this, CDP1871_TAG), |
| 48 | | m_cassette(*this, CASSETTE_TAG), |
| 49 | | m_ram(*this, RAM_TAG), |
| 50 | | m_expansion(*this, EXPANSION_TAG), |
| 51 | | m_ef4(0) |
| 45 | m_maincpu(*this, CDP1802_TAG), |
| 46 | m_vis(*this, CDP1869_TAG), |
| 47 | m_kbe(*this, CDP1871_TAG), |
| 48 | m_cassette(*this, CASSETTE_TAG), |
| 49 | m_ram(*this, RAM_TAG), |
| 50 | m_exp(*this, EXPANSION_TAG), |
| 51 | m_char_ram(*this, "char_ram") |
| 52 | 52 | { } |
| 53 | 53 | |
| 54 | 54 | required_device<cosmac_device> m_maincpu; |
| r19197 | r19198 | |
| 56 | 56 | required_device<cdp1871_device> m_kbe; |
| 57 | 57 | required_device<cassette_image_device> m_cassette; |
| 58 | 58 | required_device<ram_device> m_ram; |
| 59 | | required_device<comx_expansion_slot_device> m_expansion; |
| 59 | required_device<comx_expansion_slot_device> m_exp; |
| 60 | optional_shared_ptr<UINT8> m_char_ram; |
| 60 | 61 | |
| 61 | 62 | virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr); |
| 62 | 63 | virtual void machine_start(); |
| r19197 | r19198 | |
| 82 | 83 | DECLARE_WRITE_LINE_MEMBER( q_w ); |
| 83 | 84 | DECLARE_READ_LINE_MEMBER( shift_r ); |
| 84 | 85 | DECLARE_READ_LINE_MEMBER( control_r ); |
| 85 | | DECLARE_WRITE_LINE_MEMBER( ef4_w ); |
| 86 | 86 | DECLARE_WRITE_LINE_MEMBER( int_w ); |
| 87 | 87 | DECLARE_WRITE_LINE_MEMBER( prd_w ); |
| 88 | 88 | DECLARE_INPUT_CHANGED_MEMBER( trigger_reset ); |
| 89 | 89 | |
| 90 | 90 | // processor state |
| 91 | | int m_clear; // CPU mode |
| 92 | | int m_q; // Q flag |
| 93 | | int m_ef4; // EF4 flag |
| 94 | | int m_iden; // interrupt/DMA enable |
| 95 | | int m_dma; // memory refresh DMA |
| 96 | | int m_int; // interrupt request |
| 97 | | int m_prd; // predisplay |
| 98 | | int m_cr1; // interrupt enable |
| 91 | int m_clear; // CPU mode |
| 92 | int m_q; // Q flag |
| 93 | int m_iden; // interrupt/DMA enable |
| 94 | int m_dma; // memory refresh DMA |
| 95 | int m_int; // interrupt request |
| 96 | int m_prd; // predisplay |
| 97 | int m_cr1; // interrupt enable |
| 99 | 98 | |
| 100 | | // video state |
| 101 | | UINT8 *m_charram; // character memory |
| 99 | const UINT8 *m_rom; |
| 102 | 100 | }; |
| 103 | 101 | |
| 104 | 102 | // ---------- defined in video/comx35.c ---------- |