src/mess/drivers/nanos.c
| r11051 | r11052 | |
| 5 | 5 | 12/05/2009 Skeleton driver. |
| 6 | 6 | |
| 7 | 7 | ****************************************************************************/ |
| 8 | #define ADDRESS_MAP_MODERN |
| 8 | 9 | |
| 9 | 10 | #include "emu.h" |
| 10 | 11 | #include "cpu/z80/z80.h" |
| r11051 | r11052 | |
| 17 | 18 | #include "formats/basicdsk.h" |
| 18 | 19 | #include "machine/ram.h" |
| 19 | 20 | |
| 21 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 22 | #define MACHINE_START_MEMBER(name) void name::machine_start() |
| 23 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 24 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 20 | 25 | |
| 21 | 26 | class nanos_state : public driver_device |
| 22 | 27 | { |
| 23 | 28 | public: |
| 24 | 29 | nanos_state(running_machine &machine, const driver_device_config_base &config) |
| 25 | | : driver_device(machine, config) { } |
| 30 | : driver_device(machine, config), |
| 31 | m_maincpu(*this, "maincpu"), |
| 32 | m_pio(*this, "z80pio"), |
| 33 | m_pio_0(*this, "z80pio_0"), |
| 34 | m_pio_1(*this, "z80pio_1"), |
| 35 | m_sio_0(*this, "z80sio_0"), |
| 36 | m_sio_1(*this, "z80sio_1"), |
| 37 | m_ctc_0(*this, "z80ctc_0"), |
| 38 | m_ctc_1(*this, "z80ctc_1"), |
| 39 | m_fdc(*this, "upd765"), |
| 40 | m_key_t(*this, "keyboard_timer") |
| 41 | { } |
| 26 | 42 | |
| 27 | | const UINT8 *m_FNT; |
| 43 | required_device<cpu_device> m_maincpu; |
| 44 | required_device<device_t> m_pio; |
| 45 | required_device<device_t> m_pio_0; |
| 46 | required_device<device_t> m_pio_1; |
| 47 | required_device<device_t> m_sio_0; |
| 48 | required_device<device_t> m_sio_1; |
| 49 | required_device<device_t> m_ctc_0; |
| 50 | required_device<device_t> m_ctc_1; |
| 51 | required_device<device_t> m_fdc; |
| 52 | required_device<device_t> m_key_t; |
| 53 | const UINT8 *m_p_chargen; |
| 28 | 54 | UINT8 m_key_command; |
| 29 | 55 | UINT8 m_last_code; |
| 30 | 56 | UINT8 m_key_pressed; |
| 57 | DECLARE_WRITE8_MEMBER( nanos_tc_w ); |
| 58 | DECLARE_WRITE_LINE_MEMBER( ctc_z0_w ); |
| 59 | DECLARE_WRITE_LINE_MEMBER( ctc_z1_w ); |
| 60 | DECLARE_WRITE_LINE_MEMBER( ctc_z2_w ); |
| 61 | virtual void machine_reset(); |
| 62 | virtual void machine_start(); |
| 63 | virtual void video_start(); |
| 64 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 31 | 65 | }; |
| 32 | 66 | |
| 33 | 67 | |
| 34 | 68 | |
| 35 | | static ADDRESS_MAP_START(nanos_mem, AS_PROGRAM, 8) |
| 69 | static ADDRESS_MAP_START(nanos_mem, AS_PROGRAM, 8, nanos_state) |
| 36 | 70 | AM_RANGE( 0x0000, 0x0fff ) AM_READ_BANK("bank1") AM_WRITE_BANK("bank3") |
| 37 | 71 | AM_RANGE( 0x1000, 0xffff ) AM_RAMBANK("bank2") |
| 38 | 72 | ADDRESS_MAP_END |
| 39 | 73 | |
| 40 | | static WRITE8_HANDLER(nanos_tc_w) |
| 74 | WRITE8_MEMBER(nanos_state::nanos_tc_w) |
| 41 | 75 | { |
| 42 | | device_t *fdc = space->machine().device("upd765"); |
| 43 | | upd765_tc_w(fdc, BIT(data,1)); |
| 76 | upd765_tc_w(m_fdc, BIT(data,1)); |
| 44 | 77 | } |
| 45 | 78 | |
| 46 | 79 | |
| 47 | 80 | /* Z80-CTC Interface */ |
| 48 | 81 | |
| 49 | | static WRITE_LINE_DEVICE_HANDLER( ctc_z0_w ) |
| 82 | WRITE_LINE_MEMBER( nanos_state::ctc_z0_w ) |
| 50 | 83 | { |
| 51 | 84 | } |
| 52 | 85 | |
| 53 | | static WRITE_LINE_DEVICE_HANDLER( ctc_z1_w ) |
| 86 | WRITE_LINE_MEMBER( nanos_state::ctc_z1_w ) |
| 54 | 87 | { |
| 55 | 88 | } |
| 56 | 89 | |
| 57 | | static WRITE_LINE_DEVICE_HANDLER( ctc_z2_w ) |
| 90 | WRITE_LINE_MEMBER( nanos_state::ctc_z2_w ) |
| 58 | 91 | { |
| 59 | 92 | } |
| 60 | 93 | |
| r11051 | r11052 | |
| 62 | 95 | { |
| 63 | 96 | 0, /* timer disables */ |
| 64 | 97 | DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_IRQ0), /* interrupt handler */ |
| 65 | | DEVCB_LINE(ctc_z0_w), /* ZC/TO0 callback */ |
| 66 | | DEVCB_LINE(ctc_z1_w), /* ZC/TO1 callback */ |
| 67 | | DEVCB_LINE(ctc_z2_w) /* ZC/TO2 callback */ |
| 98 | DEVCB_DRIVER_LINE_MEMBER(nanos_state, ctc_z0_w), /* ZC/TO0 callback */ |
| 99 | DEVCB_DRIVER_LINE_MEMBER(nanos_state, ctc_z1_w), /* ZC/TO1 callback */ |
| 100 | DEVCB_DRIVER_LINE_MEMBER(nanos_state, ctc_z2_w) /* ZC/TO2 callback */ |
| 68 | 101 | }; |
| 69 | 102 | |
| 70 | 103 | /* Z80-PIO Interface */ |
| r11051 | r11052 | |
| 121 | 154 | { "z80ctc_1" }, |
| 122 | 155 | { NULL } |
| 123 | 156 | }; |
| 124 | | static ADDRESS_MAP_START( nanos_io , AS_IO, 8) |
| 157 | static ADDRESS_MAP_START( nanos_io , AS_IO, 8, nanos_state) |
| 125 | 158 | ADDRESS_MAP_UNMAP_HIGH |
| 126 | 159 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 127 | 160 | /* CPU card */ |
| 128 | | AM_RANGE(0x00, 0x03) AM_DEVREADWRITE("z80pio", z80pio_cd_ba_r, z80pio_cd_ba_w) |
| 161 | AM_RANGE(0x00, 0x03) AM_DEVREADWRITE_LEGACY("z80pio", z80pio_cd_ba_r, z80pio_cd_ba_w) |
| 129 | 162 | |
| 130 | 163 | /* I/O card */ |
| 131 | | AM_RANGE(0x80, 0x83) AM_DEVREADWRITE("z80pio_0", z80pio_cd_ba_r, z80pio_cd_ba_w) |
| 132 | | AM_RANGE(0x84, 0x84) AM_DEVREADWRITE("z80sio_0", z80sio_d_r, z80sio_d_w) |
| 133 | | AM_RANGE(0x85, 0x85) AM_DEVREADWRITE("z80sio_0", z80sio_c_r, z80sio_c_w) |
| 134 | | AM_RANGE(0x86, 0x86) AM_DEVREADWRITE("z80sio_0", z80sio_d_r, z80sio_d_w) |
| 135 | | AM_RANGE(0x87, 0x87) AM_DEVREADWRITE("z80sio_0", z80sio_c_r, z80sio_c_w) |
| 136 | | AM_RANGE(0x88, 0x8B) AM_DEVREADWRITE("z80pio_1", z80pio_cd_ba_r, z80pio_cd_ba_w) |
| 137 | | AM_RANGE(0x8C, 0x8F) AM_DEVREADWRITE("z80ctc_0", z80ctc_r, z80ctc_w) |
| 164 | AM_RANGE(0x80, 0x83) AM_DEVREADWRITE_LEGACY("z80pio_0", z80pio_cd_ba_r, z80pio_cd_ba_w) |
| 165 | AM_RANGE(0x84, 0x84) AM_DEVREADWRITE_LEGACY("z80sio_0", z80sio_d_r, z80sio_d_w) |
| 166 | AM_RANGE(0x85, 0x85) AM_DEVREADWRITE_LEGACY("z80sio_0", z80sio_c_r, z80sio_c_w) |
| 167 | AM_RANGE(0x86, 0x86) AM_DEVREADWRITE_LEGACY("z80sio_0", z80sio_d_r, z80sio_d_w) |
| 168 | AM_RANGE(0x87, 0x87) AM_DEVREADWRITE_LEGACY("z80sio_0", z80sio_c_r, z80sio_c_w) |
| 169 | AM_RANGE(0x88, 0x8B) AM_DEVREADWRITE_LEGACY("z80pio_1", z80pio_cd_ba_r, z80pio_cd_ba_w) |
| 170 | AM_RANGE(0x8C, 0x8F) AM_DEVREADWRITE_LEGACY("z80ctc_0", z80ctc_r, z80ctc_w) |
| 138 | 171 | |
| 139 | 172 | /* FDC card */ |
| 140 | 173 | AM_RANGE(0x92, 0x92) AM_WRITE(nanos_tc_w) |
| 141 | | AM_RANGE(0x94, 0x94) AM_DEVREAD("upd765", upd765_status_r) |
| 142 | | AM_RANGE(0x95, 0x95) AM_DEVREADWRITE("upd765", upd765_data_r, upd765_data_w) |
| 174 | AM_RANGE(0x94, 0x94) AM_DEVREAD_LEGACY("upd765", upd765_status_r) |
| 175 | AM_RANGE(0x95, 0x95) AM_DEVREADWRITE_LEGACY("upd765", upd765_data_r, upd765_data_w) |
| 143 | 176 | /* V24+IFSS card */ |
| 144 | | AM_RANGE(0xA0, 0xA0) AM_DEVREADWRITE("z80sio_1", z80sio_d_r, z80sio_d_w) |
| 145 | | AM_RANGE(0xA1, 0xA1) AM_DEVREADWRITE("z80sio_1", z80sio_c_r, z80sio_c_w) |
| 146 | | AM_RANGE(0xA2, 0xA2) AM_DEVREADWRITE("z80sio_1", z80sio_d_r, z80sio_d_w) |
| 147 | | AM_RANGE(0xA3, 0xA3) AM_DEVREADWRITE("z80sio_1", z80sio_c_r, z80sio_c_w) |
| 148 | | AM_RANGE(0xA4, 0xA7) AM_DEVREADWRITE("z80ctc_1", z80ctc_r, z80ctc_w) |
| 177 | AM_RANGE(0xA0, 0xA0) AM_DEVREADWRITE_LEGACY("z80sio_1", z80sio_d_r, z80sio_d_w) |
| 178 | AM_RANGE(0xA1, 0xA1) AM_DEVREADWRITE_LEGACY("z80sio_1", z80sio_c_r, z80sio_c_w) |
| 179 | AM_RANGE(0xA2, 0xA2) AM_DEVREADWRITE_LEGACY("z80sio_1", z80sio_d_r, z80sio_d_w) |
| 180 | AM_RANGE(0xA3, 0xA3) AM_DEVREADWRITE_LEGACY("z80sio_1", z80sio_c_r, z80sio_c_w) |
| 181 | AM_RANGE(0xA4, 0xA7) AM_DEVREADWRITE_LEGACY("z80ctc_1", z80ctc_r, z80ctc_w) |
| 149 | 182 | |
| 150 | 183 | /* 256-k RAM card I - 64k OS-Memory + 192k-RAM-Floppy */ |
| 151 | 184 | //AM_RANGE(0xC0, 0xC7) |
| r11051 | r11052 | |
| 238 | 271 | INPUT_PORTS_END |
| 239 | 272 | |
| 240 | 273 | |
| 241 | | static VIDEO_START( nanos ) |
| 274 | VIDEO_START_MEMBER( nanos_state ) |
| 242 | 275 | { |
| 243 | | nanos_state *state = machine.driver_data<nanos_state>(); |
| 244 | | state->m_FNT = machine.region("gfx1")->base(); |
| 276 | m_p_chargen = m_machine.region("chargen")->base(); |
| 245 | 277 | } |
| 246 | 278 | |
| 247 | | static SCREEN_UPDATE( nanos ) |
| 279 | SCREEN_UPDATE_MEMBER( nanos_state ) |
| 248 | 280 | { |
| 249 | | nanos_state *state = screen->machine().driver_data<nanos_state>(); |
| 250 | 281 | // static UINT8 framecnt=0; |
| 251 | 282 | UINT8 y,ra,chr,gfx; |
| 252 | 283 | UINT16 sy=0,ma=0,x; |
| r11051 | r11052 | |
| 257 | 288 | { |
| 258 | 289 | for (ra = 0; ra < 10; ra++) |
| 259 | 290 | { |
| 260 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 291 | UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0); |
| 261 | 292 | |
| 262 | 293 | for (x = ma; x < ma + 80; x++) |
| 263 | 294 | { |
| 264 | 295 | if (ra < 8) |
| 265 | 296 | { |
| 266 | | chr = ram_get_ptr(screen->machine().device(RAM_TAG))[0xf800+ x]; |
| 297 | chr = ram_get_ptr(machine().device(RAM_TAG))[0xf800+ x]; |
| 267 | 298 | |
| 268 | 299 | /* get pattern of pixels for that character scanline */ |
| 269 | | gfx = state->m_FNT[(chr<<3) | ra ]; |
| 300 | gfx = m_p_chargen[(chr<<3) | ra ]; |
| 270 | 301 | } |
| 271 | 302 | else |
| 272 | 303 | gfx = 0; |
| 273 | 304 | |
| 274 | 305 | /* Display a scanline of a character (8 pixels) */ |
| 275 | | *p++ = ( gfx & 0x80 ) ? 1 : 0; |
| 276 | | *p++ = ( gfx & 0x40 ) ? 1 : 0; |
| 277 | | *p++ = ( gfx & 0x20 ) ? 1 : 0; |
| 278 | | *p++ = ( gfx & 0x10 ) ? 1 : 0; |
| 279 | | *p++ = ( gfx & 0x08 ) ? 1 : 0; |
| 280 | | *p++ = ( gfx & 0x04 ) ? 1 : 0; |
| 281 | | *p++ = ( gfx & 0x02 ) ? 1 : 0; |
| 282 | | *p++ = ( gfx & 0x01 ) ? 1 : 0; |
| 306 | *p++ = BIT(gfx, 7); |
| 307 | *p++ = BIT(gfx, 6); |
| 308 | *p++ = BIT(gfx, 5); |
| 309 | *p++ = BIT(gfx, 4); |
| 310 | *p++ = BIT(gfx, 3); |
| 311 | *p++ = BIT(gfx, 2); |
| 312 | *p++ = BIT(gfx, 1); |
| 313 | *p++ = BIT(gfx, 0); |
| 283 | 314 | } |
| 284 | 315 | } |
| 285 | 316 | ma+=80; |
| r11051 | r11052 | |
| 316 | 347 | memory_set_bankptr(device->machine(), "bank1", ram_get_ptr(device->machine().device(RAM_TAG))); |
| 317 | 348 | } |
| 318 | 349 | } |
| 350 | |
| 319 | 351 | static UINT8 row_number(UINT8 code) { |
| 320 | 352 | if BIT(code,0) return 0; |
| 321 | 353 | if BIT(code,1) return 1; |
| r11051 | r11052 | |
| 412 | 444 | } |
| 413 | 445 | } |
| 414 | 446 | |
| 415 | | static MACHINE_START(nanos) |
| 447 | MACHINE_START_MEMBER(nanos_state) |
| 416 | 448 | { |
| 417 | | nanos_state *state = machine.driver_data<nanos_state>(); |
| 418 | | state->m_key_pressed = 0xff; |
| 449 | m_key_pressed = 0xff; |
| 419 | 450 | } |
| 420 | 451 | |
| 421 | | static MACHINE_RESET(nanos) |
| 452 | MACHINE_RESET_MEMBER(nanos_state) |
| 422 | 453 | { |
| 423 | | address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM); |
| 454 | address_space *space = m_machine.device("maincpu")->memory().space(AS_PROGRAM); |
| 424 | 455 | |
| 425 | 456 | space->install_write_bank(0x0000, 0x0fff, "bank3"); |
| 426 | 457 | space->install_write_bank(0x1000, 0xffff, "bank2"); |
| 427 | 458 | |
| 428 | | memory_set_bankptr(machine, "bank1", machine.region("maincpu")->base()); |
| 429 | | memory_set_bankptr(machine, "bank2", ram_get_ptr(machine.device(RAM_TAG)) + 0x1000); |
| 430 | | memory_set_bankptr(machine, "bank3", ram_get_ptr(machine.device(RAM_TAG))); |
| 459 | memory_set_bankptr(m_machine, "bank1", m_machine.region("maincpu")->base()); |
| 460 | memory_set_bankptr(m_machine, "bank2", ram_get_ptr(m_machine.device(RAM_TAG)) + 0x1000); |
| 461 | memory_set_bankptr(m_machine, "bank3", ram_get_ptr(m_machine.device(RAM_TAG))); |
| 431 | 462 | |
| 432 | 463 | floppy_mon_w(floppy_get_device(space->machine(), 0), CLEAR_LINE); |
| 433 | 464 | floppy_drive_set_ready_state(floppy_get_device(space->machine(), 0), 1,1); |
| r11051 | r11052 | |
| 490 | 521 | }; |
| 491 | 522 | |
| 492 | 523 | static GFXDECODE_START( nanos ) |
| 493 | | GFXDECODE_ENTRY( "gfx1", 0x0000, nanos_charlayout, 0, 1 ) |
| 524 | GFXDECODE_ENTRY( "chargen", 0x0000, nanos_charlayout, 0, 1 ) |
| 494 | 525 | GFXDECODE_END |
| 495 | 526 | |
| 496 | 527 | static MACHINE_CONFIG_START( nanos, nanos_state ) |
| r11051 | r11052 | |
| 500 | 531 | MCFG_CPU_IO_MAP(nanos_io) |
| 501 | 532 | MCFG_CPU_CONFIG(nanos_daisy_chain) |
| 502 | 533 | |
| 503 | | MCFG_MACHINE_START(nanos) |
| 504 | | MCFG_MACHINE_RESET(nanos) |
| 505 | | |
| 506 | 534 | /* video hardware */ |
| 507 | 535 | MCFG_SCREEN_ADD("screen", RASTER) |
| 508 | 536 | MCFG_SCREEN_REFRESH_RATE(50) |
| r11051 | r11052 | |
| 510 | 538 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 511 | 539 | MCFG_SCREEN_SIZE(80*8, 25*10) |
| 512 | 540 | MCFG_SCREEN_VISIBLE_AREA(0,80*8-1,0,25*10-1) |
| 513 | | MCFG_SCREEN_UPDATE(nanos) |
| 514 | | |
| 515 | 541 | MCFG_GFXDECODE(nanos) |
| 516 | 542 | MCFG_PALETTE_LENGTH(2) |
| 517 | 543 | MCFG_PALETTE_INIT(black_and_white) |
| 518 | 544 | |
| 519 | | MCFG_VIDEO_START(nanos) |
| 520 | | |
| 521 | 545 | /* devices */ |
| 522 | 546 | MCFG_Z80CTC_ADD( "z80ctc_0", XTAL_4MHz, ctc_intf) |
| 523 | 547 | MCFG_Z80CTC_ADD( "z80ctc_1", XTAL_4MHz, ctc_intf) |
| r11051 | r11052 | |
| 544 | 568 | ROM_LOAD( "k7634_1.rom", 0x0000, 0x0800, CRC(8e34e6ac) SHA1(fd342f6effe991823c2a310737fbfcba213c4fe3)) |
| 545 | 569 | ROM_LOAD( "k7634_2.rom", 0x0800, 0x0180, CRC(4e01b02b) SHA1(8a279da886555c7470a1afcbb3a99693ea13c237)) |
| 546 | 570 | |
| 547 | | ROM_REGION( 0x0800, "gfx1", 0 ) |
| 571 | ROM_REGION( 0x0800, "chargen", 0 ) |
| 548 | 572 | ROM_LOAD( "zg_nanos.rom", 0x0000, 0x0800, CRC(5682d3f9) SHA1(5b738972c815757821c050ee38b002654f8da163)) |
| 549 | 573 | ROM_END |
| 550 | 574 | |
src/mess/drivers/c10.c
| r11051 | r11052 | |
| 9 | 9 | constantly looking at. |
| 10 | 10 | |
| 11 | 11 | ****************************************************************************/ |
| 12 | #define ADDRESS_MAP_MODERN |
| 12 | 13 | |
| 13 | 14 | #include "emu.h" |
| 14 | 15 | #include "cpu/z80/z80.h" |
| 15 | 16 | |
| 17 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 18 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 19 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 16 | 20 | |
| 17 | 21 | class c10_state : public driver_device |
| 18 | 22 | { |
| 19 | 23 | public: |
| 20 | 24 | c10_state(running_machine &machine, const driver_device_config_base &config) |
| 21 | | : driver_device(machine, config) { } |
| 25 | : driver_device(machine, config), |
| 26 | m_maincpu(*this, "maincpu") |
| 27 | { } |
| 22 | 28 | |
| 23 | | const UINT8 *m_FNT; |
| 24 | | const UINT8 *m_videoram; |
| 29 | required_device<cpu_device> m_maincpu; |
| 30 | const UINT8 *m_p_chargen; |
| 31 | const UINT8 *m_p_videoram; |
| 32 | virtual void machine_reset(); |
| 33 | virtual void video_start(); |
| 34 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 25 | 35 | }; |
| 26 | 36 | |
| 27 | 37 | |
| 28 | 38 | |
| 29 | | static ADDRESS_MAP_START(c10_mem, AS_PROGRAM, 8) |
| 39 | static ADDRESS_MAP_START(c10_mem, AS_PROGRAM, 8, c10_state) |
| 30 | 40 | ADDRESS_MAP_UNMAP_HIGH |
| 31 | 41 | AM_RANGE(0x0000, 0x0fff) AM_RAMBANK("boot") |
| 32 | 42 | AM_RANGE(0x1000, 0x7fff) AM_RAM |
| 33 | 43 | AM_RANGE(0x8000, 0xbfff) AM_ROM |
| 34 | | AM_RANGE(0xc000, 0xffff) AM_RAM AM_REGION("maincpu", 0xc000) |
| 44 | AM_RANGE(0xc000, 0xf0a1) AM_RAM |
| 45 | AM_RANGE(0xf0a2, 0xffff) AM_RAM AM_BASE(m_p_videoram) |
| 35 | 46 | ADDRESS_MAP_END |
| 36 | 47 | |
| 37 | | static ADDRESS_MAP_START( c10_io, AS_IO, 8 ) |
| 48 | static ADDRESS_MAP_START( c10_io, AS_IO, 8, c10_state) |
| 38 | 49 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 39 | 50 | ADDRESS_MAP_END |
| 40 | 51 | |
| r11051 | r11052 | |
| 48 | 59 | memory_set_bank(machine, "boot", 0); |
| 49 | 60 | } |
| 50 | 61 | |
| 51 | | static MACHINE_RESET(c10) |
| 62 | MACHINE_RESET_MEMBER(c10_state) |
| 52 | 63 | { |
| 53 | | memory_set_bank(machine, "boot", 1); |
| 54 | | machine.scheduler().timer_set(attotime::from_usec(4), FUNC(c10_reset)); |
| 64 | memory_set_bank(m_machine, "boot", 1); |
| 65 | m_machine.scheduler().timer_set(attotime::from_usec(4), FUNC(c10_reset)); |
| 55 | 66 | } |
| 56 | 67 | |
| 57 | | static VIDEO_START( c10 ) |
| 68 | VIDEO_START_MEMBER( c10_state ) |
| 58 | 69 | { |
| 59 | | c10_state *state = machine.driver_data<c10_state>(); |
| 60 | | state->m_FNT = machine.region("chargen")->base(); |
| 61 | | state->m_videoram = machine.region("maincpu")->base()+0xf0a2; |
| 70 | m_p_chargen = m_machine.region("chargen")->base(); |
| 62 | 71 | } |
| 63 | 72 | |
| 64 | 73 | /* This system appears to have inline attribute bytes of unknown meaning. |
| 65 | 74 | Currently they are ignored. The word at FAB5 looks like it might be cursor location. */ |
| 66 | | static SCREEN_UPDATE( c10 ) |
| 75 | SCREEN_UPDATE_MEMBER( c10_state ) |
| 67 | 76 | { |
| 68 | | c10_state *state = screen->machine().driver_data<c10_state>(); |
| 69 | 77 | //static UINT8 framecnt=0; |
| 70 | 78 | UINT8 y,ra,chr,gfx; |
| 71 | 79 | UINT16 sy=0,ma=0,x,xx; |
| r11051 | r11052 | |
| 76 | 84 | { |
| 77 | 85 | for (ra = 0; ra < 10; ra++) |
| 78 | 86 | { |
| 79 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 87 | UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0); |
| 80 | 88 | |
| 81 | 89 | xx = ma; |
| 82 | 90 | for (x = ma; x < ma + 80; x++) |
| r11051 | r11052 | |
| 84 | 92 | gfx = 0; |
| 85 | 93 | if (ra < 9) |
| 86 | 94 | { |
| 87 | | chr = state->m_videoram[xx++]; |
| 95 | chr = m_p_videoram[xx++]; |
| 88 | 96 | |
| 89 | 97 | // /* Take care of flashing characters */ |
| 90 | 98 | // if ((chr < 0x80) && (framecnt & 0x08)) |
| 91 | 99 | // chr |= 0x80; |
| 92 | 100 | |
| 93 | | if (chr & 0x80) // ignore attribute bytes |
| 101 | if BIT(chr, 7) // ignore attribute bytes |
| 94 | 102 | x--; |
| 95 | 103 | else |
| 96 | 104 | { |
| 97 | | gfx = state->m_FNT[(chr<<4) | ra ]; |
| 105 | gfx = m_p_chargen[(chr<<4) | ra ]; |
| 98 | 106 | |
| 99 | 107 | /* Display a scanline of a character */ |
| 100 | | *p++ = ( gfx & 0x80 ) ? 1 : 0; |
| 101 | | *p++ = ( gfx & 0x40 ) ? 1 : 0; |
| 102 | | *p++ = ( gfx & 0x20 ) ? 1 : 0; |
| 103 | | *p++ = ( gfx & 0x10 ) ? 1 : 0; |
| 104 | | *p++ = ( gfx & 0x08 ) ? 1 : 0; |
| 105 | | *p++ = ( gfx & 0x04 ) ? 1 : 0; |
| 106 | | *p++ = ( gfx & 0x02 ) ? 1 : 0; |
| 107 | | *p++ = ( gfx & 0x01 ) ? 1 : 0; |
| 108 | *p++ = BIT(gfx, 7); |
| 109 | *p++ = BIT(gfx, 6); |
| 110 | *p++ = BIT(gfx, 5); |
| 111 | *p++ = BIT(gfx, 4); |
| 112 | *p++ = BIT(gfx, 3); |
| 113 | *p++ = BIT(gfx, 2); |
| 114 | *p++ = BIT(gfx, 1); |
| 115 | *p++ = BIT(gfx, 0); |
| 108 | 116 | } |
| 109 | 117 | } |
| 110 | 118 | } |
| r11051 | r11052 | |
| 139 | 147 | MCFG_CPU_PROGRAM_MAP(c10_mem) |
| 140 | 148 | MCFG_CPU_IO_MAP(c10_io) |
| 141 | 149 | |
| 142 | | MCFG_MACHINE_RESET(c10) |
| 143 | | |
| 144 | 150 | /* video hardware */ |
| 145 | 151 | MCFG_SCREEN_ADD("screen", RASTER) |
| 146 | 152 | MCFG_SCREEN_REFRESH_RATE(60) |
| r11051 | r11052 | |
| 148 | 154 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 149 | 155 | MCFG_SCREEN_SIZE(640, 250) |
| 150 | 156 | MCFG_SCREEN_VISIBLE_AREA(0, 639, 0, 249) |
| 151 | | MCFG_SCREEN_UPDATE(c10) |
| 152 | | |
| 153 | 157 | MCFG_GFXDECODE(c10) |
| 154 | | |
| 155 | 158 | MCFG_PALETTE_LENGTH(2) |
| 156 | 159 | MCFG_PALETTE_INIT(black_and_white) |
| 157 | | |
| 158 | | MCFG_VIDEO_START(c10) |
| 159 | 160 | MACHINE_CONFIG_END |
| 160 | 161 | |
| 161 | 162 | DRIVER_INIT( c10 ) |
| r11051 | r11052 | |
| 168 | 169 | ROM_START( c10 ) |
| 169 | 170 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF ) |
| 170 | 171 | ROM_LOAD( "c10_cros.bin", 0x8000, 0x4000, CRC(2ccf5983) SHA1(52f7c497f5284bf5df9eb0d6e9142bb1869d8c24)) |
| 172 | |
| 171 | 173 | ROM_REGION( 0x2000, "chargen", 0 ) |
| 172 | 174 | ROM_LOAD( "c10_char.bin", 0x0000, 0x2000, CRC(cb530b6f) SHA1(95590bbb433db9c4317f535723b29516b9b9fcbf)) |
| 173 | 175 | ROM_END |
| r11051 | r11052 | |
| 175 | 177 | /* Driver */ |
| 176 | 178 | |
| 177 | 179 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 178 | | COMP( 1982, c10, 0, 0, c10, c10, c10, "Cromemco", "C-10", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 180 | COMP( 1982, c10, 0, 0, c10, c10, c10, "Cromemco", "C-10", GAME_NOT_WORKING | GAME_NO_SOUND) |