src/mess/drivers/tmc1800.c
| r11028 | r11029 | |
| 111 | 111 | |
| 112 | 112 | */ |
| 113 | 113 | |
| 114 | | #include "emu.h" |
| 115 | 114 | #include "includes/tmc1800.h" |
| 116 | | #include "cpu/cosmac/cosmac.h" |
| 117 | | #include "video/cdp1861.h" |
| 118 | | #include "sound/cdp1864.h" |
| 119 | | #include "imagedev/cassette.h" |
| 120 | | #include "imagedev/snapquik.h" |
| 121 | | #include "machine/rescap.h" |
| 122 | | #include "sound/beep.h" |
| 123 | | #include "machine/ram.h" |
| 124 | 115 | |
| 125 | | #define TMC2000_BANK_RAM 0 |
| 126 | | #define TMC2000_BANK_ROM 1 |
| 127 | | #define TMC2000_BANK_MONITOR 0 |
| 128 | | #define TMC2000_BANK_COLORRAM 1 |
| 129 | | #define TMC2000_COLORRAM_SIZE 0x200 |
| 130 | | |
| 131 | | #define OSCNANO_BANK_RAM 0 |
| 132 | | #define OSCNANO_BANK_ROM 1 |
| 133 | | |
| 134 | | static QUICKLOAD_LOAD( tmc1800 ); |
| 135 | | |
| 136 | | static MACHINE_RESET( tmc1800 ); |
| 137 | | static MACHINE_RESET( tmc2000 ); |
| 138 | | static MACHINE_RESET( nano ); |
| 139 | | |
| 140 | 116 | /* Read/Write Handlers */ |
| 141 | 117 | |
| 142 | | static WRITE8_HANDLER( tmc1800_keylatch_w ) |
| 118 | WRITE8_MEMBER( tmc1800_state::keylatch_w ) |
| 143 | 119 | { |
| 144 | | tmc1800_state *state = space->machine().driver_data<tmc1800_state>(); |
| 120 | m_keylatch = data; |
| 121 | } |
| 145 | 122 | |
| 146 | | state->keylatch = data; |
| 123 | WRITE8_MEMBER( osc1000b_state::keylatch_w ) |
| 124 | { |
| 125 | m_keylatch = data; |
| 147 | 126 | } |
| 148 | 127 | |
| 149 | | static WRITE8_HANDLER( tmc2000_keylatch_w ) |
| 128 | WRITE8_MEMBER( tmc2000_state::keylatch_w ) |
| 150 | 129 | { |
| 151 | 130 | /* |
| 152 | 131 | |
| r11028 | r11029 | |
| 163 | 142 | |
| 164 | 143 | */ |
| 165 | 144 | |
| 166 | | tmc2000_state *state = space->machine().driver_data<tmc2000_state>(); |
| 167 | | |
| 168 | | state->keylatch = data & 0x3f; |
| 145 | m_keylatch = data & 0x3f; |
| 169 | 146 | } |
| 170 | 147 | |
| 171 | | static WRITE8_HANDLER( nano_keylatch_w ) |
| 148 | WRITE8_MEMBER( nano_state::keylatch_w ) |
| 172 | 149 | { |
| 173 | 150 | /* |
| 174 | 151 | |
| r11028 | r11029 | |
| 185 | 162 | |
| 186 | 163 | */ |
| 187 | 164 | |
| 188 | | nano_state *state = space->machine().driver_data<nano_state>(); |
| 189 | | |
| 190 | | state->keylatch = data & 0x0f; |
| 165 | m_keylatch = data & 0x0f; |
| 191 | 166 | } |
| 192 | 167 | |
| 193 | | static WRITE8_DEVICE_HANDLER( tmc2000_bankswitch_w ) |
| 168 | void tmc2000_state::bankswitch() |
| 194 | 169 | { |
| 195 | | int bank = data & 0x01; |
| 196 | | |
| 197 | | /* enable RAM */ |
| 198 | | |
| 199 | | memory_set_bank(device->machine(), "bank1", TMC2000_BANK_RAM); |
| 200 | | |
| 201 | | switch (ram_get_size(device->machine().device(RAM_TAG))) |
| 170 | address_space *program = m_maincpu->memory().space(AS_PROGRAM); |
| 171 | UINT8 *ram = ram_get_ptr(m_ram); |
| 172 | UINT8 *rom = m_machine.region(CDP1802_TAG)->base(); |
| 173 | |
| 174 | if (m_roc) |
| 202 | 175 | { |
| 203 | | case 4 * 1024: |
| 204 | | device->machine().device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_readwrite_bank(0x0000, 0x0fff, 0, 0x7000, "bank1"); |
| 205 | | break; |
| 176 | // monitor ROM |
| 177 | program->install_rom(0x0000, 0x01ff, 0, 0x7e00, rom); |
| 178 | } |
| 179 | else |
| 180 | { |
| 181 | // RAM |
| 182 | switch (ram_get_size(m_ram)) |
| 183 | { |
| 184 | case 4 * 1024: |
| 185 | program->install_ram(0x0000, 0x0fff, 0, 0x7000, ram); |
| 186 | break; |
| 206 | 187 | |
| 207 | | case 16 * 1024: |
| 208 | | device->machine().device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_readwrite_bank(0x0000, 0x3fff, 0, 0x4000, "bank1"); |
| 209 | | break; |
| 188 | case 16 * 1024: |
| 189 | program->install_ram(0x0000, 0x3fff, 0, 0x4000, ram); |
| 190 | break; |
| 210 | 191 | |
| 211 | | case 32 * 1024: |
| 212 | | device->machine().device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_readwrite_bank(0x0000, 0x7fff, "bank1"); |
| 213 | | break; |
| 192 | case 32 * 1024: |
| 193 | program->install_ram(0x0000, 0x7fff, ram); |
| 194 | break; |
| 195 | } |
| 214 | 196 | } |
| 215 | 197 | |
| 216 | | /* enable monitor or color RAM */ |
| 217 | | |
| 218 | | memory_set_bank(device->machine(), "bank2", bank); |
| 219 | | |
| 220 | | switch (bank) |
| 198 | if (m_rac) |
| 221 | 199 | { |
| 222 | | case TMC2000_BANK_MONITOR: |
| 223 | | device->machine().device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_read_bank(0x8000, 0x81ff, 0, 0x7e00, "bank2"); |
| 224 | | device->machine().device(CDP1802_TAG)->memory().space(AS_PROGRAM)->unmap_write(0x8000, 0x81ff, 0, 0x7e00 ); |
| 225 | | break; |
| 226 | | |
| 227 | | case TMC2000_BANK_COLORRAM: // write-only |
| 228 | | device->machine().device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_write_bank(0x8000, 0x81ff, 0, 0x7e00, "bank2"); |
| 229 | | device->machine().device(CDP1802_TAG)->memory().space(AS_PROGRAM)->unmap_read(0x8000, 0x81ff, 0, 0x7e00); |
| 230 | | break; |
| 200 | // color RAM |
| 201 | program->install_ram(0x8000, 0x81ff, 0, 0x7e00, m_colorram); |
| 202 | program->unmap_read(0x8000, 0x81ff, 0, 0x7e00); |
| 231 | 203 | } |
| 204 | else |
| 205 | { |
| 206 | // monitor ROM |
| 207 | program->install_rom(0x8000, 0x81ff, 0, 0x7e00, rom); |
| 208 | } |
| 209 | } |
| 232 | 210 | |
| 233 | | /* write to CDP1864 tone latch */ |
| 211 | WRITE8_MEMBER( tmc2000_state::bankswitch_w ) |
| 212 | { |
| 213 | m_roc = 0; |
| 214 | m_rac = BIT(data, 0); |
| 215 | bankswitch(); |
| 234 | 216 | |
| 235 | | cdp1864_tone_latch_w(device, 0, data); |
| 217 | cdp1864_tone_latch_w(m_cti, 0, data); |
| 236 | 218 | } |
| 237 | 219 | |
| 238 | | static WRITE8_DEVICE_HANDLER( nano_bankswitch_w ) |
| 220 | WRITE8_MEMBER( nano_state::bankswitch_w ) |
| 239 | 221 | { |
| 240 | 222 | /* enable RAM */ |
| 223 | address_space *program = m_maincpu->memory().space(AS_PROGRAM); |
| 224 | UINT8 *ram = ram_get_ptr(m_ram); |
| 225 | program->install_ram(0x0000, 0x0fff, 0, 0x7000, ram); |
| 241 | 226 | |
| 242 | | memory_set_bank(device->machine(), "bank1", OSCNANO_BANK_RAM); |
| 243 | | |
| 244 | | device->machine().device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_readwrite_bank(0x0000, 0x0fff, 0, 0x7000, "bank1"); |
| 245 | | |
| 246 | 227 | /* write to CDP1864 tone latch */ |
| 247 | | |
| 248 | | cdp1864_tone_latch_w(device, 0, data); |
| 228 | cdp1864_tone_latch_w(m_cti, 0, data); |
| 249 | 229 | } |
| 250 | 230 | |
| 251 | | static READ8_DEVICE_HANDLER( tmc1800_cdp1861_dispon_r ) |
| 231 | READ8_MEMBER( tmc1800_state::dispon_r ) |
| 252 | 232 | { |
| 253 | | cdp1861_dispon_w(device, 1); |
| 254 | | cdp1861_dispon_w(device, 0); |
| 233 | cdp1861_dispon_w(m_vdc, 1); |
| 234 | cdp1861_dispon_w(m_vdc, 0); |
| 255 | 235 | |
| 256 | 236 | return 0xff; |
| 257 | 237 | } |
| 258 | 238 | |
| 259 | | static WRITE8_DEVICE_HANDLER( tmc1800_cdp1861_dispoff_w ) |
| 239 | WRITE8_MEMBER( tmc1800_state::dispoff_w ) |
| 260 | 240 | { |
| 261 | | cdp1861_dispoff_w(device, 1); |
| 262 | | cdp1861_dispoff_w(device, 0); |
| 241 | cdp1861_dispoff_w(m_vdc, 1); |
| 242 | cdp1861_dispoff_w(m_vdc, 0); |
| 263 | 243 | } |
| 264 | 244 | |
| 265 | 245 | /* Memory Maps */ |
| 266 | 246 | |
| 267 | 247 | // Telmac 1800 |
| 268 | 248 | |
| 269 | | static ADDRESS_MAP_START( tmc1800_map, AS_PROGRAM, 8 ) |
| 270 | | AM_RANGE(0x0000, 0x07ff) AM_RAM |
| 271 | | AM_RANGE(0x8000, 0x81ff) AM_ROM |
| 249 | static ADDRESS_MAP_START( tmc1800_map, AS_PROGRAM, 8, tmc1800_state ) |
| 250 | AM_RANGE(0x0000, 0x07ff) AM_MIRROR(0x7800) AM_RAM |
| 251 | AM_RANGE(0x8000, 0x81ff) AM_MIRROR(0x7e00) AM_ROM AM_REGION(CDP1802_TAG, 0) |
| 272 | 252 | ADDRESS_MAP_END |
| 273 | 253 | |
| 274 | | static ADDRESS_MAP_START( tmc1800_io_map, AS_IO, 8 ) |
| 275 | | AM_RANGE(0x01, 0x01) AM_DEVREADWRITE(CDP1861_TAG, tmc1800_cdp1861_dispon_r, tmc1800_cdp1861_dispoff_w) |
| 276 | | AM_RANGE(0x02, 0x02) AM_WRITE(tmc1800_keylatch_w) |
| 254 | static ADDRESS_MAP_START( tmc1800_io_map, AS_IO, 8, tmc1800_state ) |
| 255 | AM_RANGE(0x01, 0x01) AM_READWRITE(dispon_r, dispoff_w) |
| 256 | AM_RANGE(0x02, 0x02) AM_WRITE(keylatch_w) |
| 277 | 257 | ADDRESS_MAP_END |
| 278 | 258 | |
| 279 | 259 | // OSCOM 1000B |
| 280 | 260 | |
| 281 | | static ADDRESS_MAP_START( osc1000b_map, AS_PROGRAM, 8 ) |
| 282 | | AM_RANGE(0x0000, 0x07ff) AM_RAM |
| 283 | | AM_RANGE(0x8000, 0x81ff) AM_ROM |
| 261 | static ADDRESS_MAP_START( osc1000b_map, AS_PROGRAM, 8, osc1000b_state ) |
| 262 | AM_RANGE(0x0000, 0x07ff) AM_MIRROR(0x7800) AM_RAM |
| 263 | AM_RANGE(0x8000, 0x81ff) AM_MIRROR(0x7e00) AM_ROM AM_REGION(CDP1802_TAG, 0) |
| 284 | 264 | ADDRESS_MAP_END |
| 285 | 265 | |
| 286 | | static ADDRESS_MAP_START( osc1000b_io_map, AS_IO, 8 ) |
| 287 | | AM_RANGE(0x02, 0x02) AM_WRITE(tmc1800_keylatch_w) |
| 266 | static ADDRESS_MAP_START( osc1000b_io_map, AS_IO, 8, osc1000b_state ) |
| 267 | AM_RANGE(0x02, 0x02) AM_WRITE(keylatch_w) |
| 288 | 268 | ADDRESS_MAP_END |
| 289 | 269 | |
| 290 | 270 | // Telmac 2000 |
| 291 | 271 | |
| 292 | | static ADDRESS_MAP_START( tmc2000_map, AS_PROGRAM, 8 ) |
| 272 | static ADDRESS_MAP_START( tmc2000_map, AS_PROGRAM, 8, tmc2000_state ) |
| 293 | 273 | ADDRESS_MAP_UNMAP_HIGH |
| 294 | | AM_RANGE(0x0000, 0x7fff) AM_RAMBANK("bank1") |
| 295 | | AM_RANGE(0x8000, 0xffff) AM_RAMBANK("bank2") |
| 274 | AM_RANGE(0x0000, 0x7fff) // RAM / monitor ROM |
| 275 | AM_RANGE(0x8000, 0xffff) // color RAM / monitor ROM |
| 296 | 276 | ADDRESS_MAP_END |
| 297 | 277 | |
| 298 | | static ADDRESS_MAP_START( tmc2000_io_map, AS_IO, 8 ) |
| 278 | static ADDRESS_MAP_START( tmc2000_io_map, AS_IO, 8, tmc2000_state ) |
| 299 | 279 | ADDRESS_MAP_UNMAP_HIGH |
| 300 | | AM_RANGE(0x01, 0x01) AM_DEVREADWRITE(CDP1864_TAG, cdp1864_dispon_r, cdp1864_step_bgcolor_w) |
| 301 | | AM_RANGE(0x02, 0x02) AM_WRITE(tmc2000_keylatch_w) |
| 302 | | AM_RANGE(0x04, 0x04) AM_DEVREADWRITE(CDP1864_TAG, cdp1864_dispoff_r, tmc2000_bankswitch_w) |
| 280 | AM_RANGE(0x01, 0x01) AM_DEVREADWRITE_LEGACY(CDP1864_TAG, cdp1864_dispon_r, cdp1864_step_bgcolor_w) |
| 281 | AM_RANGE(0x02, 0x02) AM_WRITE(keylatch_w) |
| 282 | AM_RANGE(0x04, 0x04) AM_DEVREAD_LEGACY(CDP1864_TAG, cdp1864_dispoff_r) AM_WRITE(bankswitch_w) |
| 303 | 283 | ADDRESS_MAP_END |
| 304 | 284 | |
| 305 | 285 | // OSCOM Nano |
| 306 | 286 | |
| 307 | | static ADDRESS_MAP_START( nano_map, AS_PROGRAM, 8 ) |
| 308 | | AM_RANGE(0x0000, 0x7fff) AM_RAMBANK("bank1") |
| 309 | | AM_RANGE(0x8000, 0x83ff) AM_ROM |
| 287 | static ADDRESS_MAP_START( nano_map, AS_PROGRAM, 8, nano_state ) |
| 288 | AM_RANGE(0x0000, 0x7fff) // RAM / monitor ROM |
| 289 | AM_RANGE(0x8000, 0x81ff) AM_MIRROR(0x7e00) AM_ROM AM_REGION(CDP1802_TAG, 0) |
| 310 | 290 | ADDRESS_MAP_END |
| 311 | 291 | |
| 312 | | static ADDRESS_MAP_START( nano_io_map, AS_IO, 8 ) |
| 313 | | AM_RANGE(0x01, 0x01) AM_DEVREADWRITE(CDP1864_TAG, cdp1864_dispon_r, cdp1864_step_bgcolor_w) |
| 314 | | AM_RANGE(0x02, 0x02) AM_WRITE(nano_keylatch_w) |
| 315 | | AM_RANGE(0x04, 0x04) AM_DEVREADWRITE(CDP1864_TAG, cdp1864_dispoff_r, nano_bankswitch_w) |
| 292 | static ADDRESS_MAP_START( nano_io_map, AS_IO, 8, nano_state ) |
| 293 | AM_RANGE(0x01, 0x01) AM_DEVREADWRITE_LEGACY(CDP1864_TAG, cdp1864_dispon_r, cdp1864_step_bgcolor_w) |
| 294 | AM_RANGE(0x02, 0x02) AM_WRITE(keylatch_w) |
| 295 | AM_RANGE(0x04, 0x04) AM_DEVREAD_LEGACY(CDP1864_TAG, cdp1864_dispoff_r) AM_WRITE(bankswitch_w) |
| 316 | 296 | ADDRESS_MAP_END |
| 317 | 297 | |
| 318 | 298 | /* Input Ports */ |
| r11028 | r11029 | |
| 342 | 322 | PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYPAD ) PORT_NAME("Run/Reset") PORT_CODE(KEYCODE_R) PORT_TOGGLE |
| 343 | 323 | INPUT_PORTS_END |
| 344 | 324 | |
| 325 | static INPUT_CHANGED( tmc2000_run_pressed ) |
| 326 | { |
| 327 | running_machine &machine = field->port->machine(); |
| 328 | tmc2000_state *state = machine.driver_data<tmc2000_state>(); |
| 329 | |
| 330 | if (oldval && !newval) |
| 331 | { |
| 332 | state->machine_reset(); |
| 333 | } |
| 334 | } |
| 335 | |
| 345 | 336 | static INPUT_PORTS_START( tmc2000 ) |
| 346 | | PORT_INCLUDE(tmc1800) |
| 337 | PORT_START("IN0") |
| 338 | PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_0) PORT_CODE(KEYCODE_0_PAD) PORT_CHAR('0') |
| 339 | PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_1) PORT_CODE(KEYCODE_1_PAD) PORT_CHAR('1') |
| 340 | PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_2) PORT_CODE(KEYCODE_2_PAD) PORT_CHAR('2') |
| 341 | PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_3) PORT_CODE(KEYCODE_3_PAD) PORT_CHAR('3') |
| 342 | PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_4) PORT_CODE(KEYCODE_4_PAD) PORT_CHAR('4') |
| 343 | PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_5) PORT_CODE(KEYCODE_5_PAD) PORT_CHAR('5') |
| 344 | PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_6) PORT_CODE(KEYCODE_6_PAD) PORT_CHAR('6') |
| 345 | PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_7) PORT_CODE(KEYCODE_7_PAD) PORT_CHAR('7') |
| 347 | 346 | |
| 347 | PORT_START("IN1") |
| 348 | PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_8) PORT_CODE(KEYCODE_8_PAD) PORT_CHAR('8') |
| 349 | PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_9) PORT_CODE(KEYCODE_9_PAD) PORT_CHAR('9') |
| 350 | PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_A) PORT_CHAR('A') |
| 351 | PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_B) PORT_CHAR('B') |
| 352 | PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_C) PORT_CHAR('C') |
| 353 | PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_D) PORT_CHAR('D') |
| 354 | PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_E) PORT_CHAR('E') |
| 355 | PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_KEYPAD ) PORT_CODE(KEYCODE_F) PORT_CHAR('F') |
| 356 | |
| 357 | PORT_START("RUN") |
| 358 | PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYPAD ) PORT_NAME("Run/Reset") PORT_CODE(KEYCODE_R) PORT_TOGGLE PORT_CHANGED(tmc2000_run_pressed, 0) |
| 359 | |
| 348 | 360 | PORT_START("IN2") |
| 349 | 361 | PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_KEYBOARD ) PORT_CODE(KEYCODE_G) PORT_CHAR('G') |
| 350 | 362 | PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_KEYBOARD ) PORT_CODE(KEYCODE_H) PORT_CHAR('H') |
| r11028 | r11029 | |
| 408 | 420 | |
| 409 | 421 | static INPUT_CHANGED( run_pressed ) |
| 410 | 422 | { |
| 423 | running_machine &machine = field->port->machine(); |
| 424 | nano_state *state = machine.driver_data<nano_state>(); |
| 425 | |
| 411 | 426 | if (oldval && !newval) |
| 412 | 427 | { |
| 413 | | running_machine &machine = field->port->machine(); |
| 414 | | MACHINE_RESET_CALL(nano); |
| 428 | state->machine_reset(); |
| 415 | 429 | } |
| 416 | 430 | } |
| 417 | 431 | |
| r11028 | r11029 | |
| 422 | 436 | |
| 423 | 437 | if (oldval && !newval) |
| 424 | 438 | { |
| 425 | | MACHINE_RESET_CALL(nano); |
| 439 | state->machine_reset(); |
| 426 | 440 | |
| 427 | | cputag_set_input_line(machine, CDP1802_TAG, COSMAC_INPUT_LINE_EF4, CLEAR_LINE); |
| 441 | state->m_maincpu->set_input_line(COSMAC_INPUT_LINE_EF4, CLEAR_LINE); |
| 428 | 442 | } |
| 429 | 443 | else if (!oldval && newval) |
| 430 | 444 | { |
| 431 | 445 | // TODO: what are the correct values? |
| 432 | 446 | int t = RES_K(27) * CAP_U(1) * 1000; // t = R26 * C1 |
| 433 | | state->ef4_timer->adjust(attotime::from_msec(t)); |
| 447 | state->m_ef4_timer->adjust(attotime::from_msec(t)); |
| 434 | 448 | } |
| 435 | 449 | } |
| 436 | 450 | |
| r11028 | r11029 | |
| 466 | 480 | |
| 467 | 481 | // Telmac 1800 |
| 468 | 482 | |
| 469 | | static READ_LINE_DEVICE_HANDLER( clear_r ) |
| 483 | READ_LINE_MEMBER( tmc1800_state::clear_r ) |
| 470 | 484 | { |
| 471 | | return BIT(input_port_read(device->machine(), "RUN"), 0); |
| 485 | return BIT(input_port_read(m_machine, "RUN"), 0); |
| 472 | 486 | } |
| 473 | 487 | |
| 474 | | static READ_LINE_DEVICE_HANDLER( ef2_r ) |
| 488 | READ_LINE_MEMBER( tmc1800_state::ef2_r ) |
| 475 | 489 | { |
| 476 | | return cassette_input(device) < 0; |
| 490 | return cassette_input(m_cassette) < 0; |
| 477 | 491 | } |
| 478 | 492 | |
| 479 | | static READ_LINE_DEVICE_HANDLER( ef3_r ) |
| 493 | READ_LINE_MEMBER( tmc1800_state::ef3_r ) |
| 480 | 494 | { |
| 481 | | tmc1800_state *state = device->machine().driver_data<tmc1800_state>(); |
| 482 | 495 | static const char *const keynames[] = { "IN0", "IN1", "IN2", "IN3", "IN4", "IN5", "IN6", "IN7" }; |
| 483 | | UINT8 data = ~input_port_read(device->machine(), keynames[state->keylatch / 8]); |
| 496 | UINT8 data = ~input_port_read(m_machine, keynames[m_keylatch / 8]); |
| 484 | 497 | |
| 485 | | return BIT(data, state->keylatch % 8); |
| 498 | return BIT(data, m_keylatch % 8); |
| 486 | 499 | } |
| 487 | 500 | |
| 488 | | static WRITE_LINE_DEVICE_HANDLER( tmc1800_q_w ) |
| 501 | WRITE_LINE_MEMBER( tmc1800_state::q_w ) |
| 489 | 502 | { |
| 490 | | tmc1800_state *driver_state = device->machine().driver_data<tmc1800_state>(); |
| 491 | | |
| 492 | | /* tape output */ |
| 493 | | cassette_output(driver_state->cassette, state ? 1.0 : -1.0); |
| 503 | cassette_output(m_cassette, state ? 1.0 : -1.0); |
| 494 | 504 | } |
| 495 | 505 | |
| 496 | 506 | static COSMAC_INTERFACE( tmc1800_config ) |
| 497 | 507 | { |
| 498 | 508 | DEVCB_LINE_VCC, |
| 499 | | DEVCB_LINE(clear_r), |
| 509 | DEVCB_DRIVER_LINE_MEMBER(tmc1800_state, clear_r), |
| 500 | 510 | DEVCB_NULL, |
| 501 | | DEVCB_DEVICE_LINE(CASSETTE_TAG, ef2_r), |
| 502 | | DEVCB_LINE(ef3_r), |
| 511 | DEVCB_DRIVER_LINE_MEMBER(tmc1800_state, ef2_r), |
| 512 | DEVCB_DRIVER_LINE_MEMBER(tmc1800_state, ef3_r), |
| 503 | 513 | DEVCB_NULL, |
| 504 | | DEVCB_LINE(tmc1800_q_w), |
| 514 | DEVCB_DRIVER_LINE_MEMBER(tmc1800_state, q_w), |
| 505 | 515 | DEVCB_NULL, |
| 506 | 516 | DEVCB_DEVICE_HANDLER(CDP1861_TAG, cdp1861_dma_w), |
| 507 | 517 | NULL, |
| r11028 | r11029 | |
| 509 | 519 | DEVCB_NULL |
| 510 | 520 | }; |
| 511 | 521 | |
| 522 | // Oscom 1000B |
| 523 | |
| 524 | READ_LINE_MEMBER( osc1000b_state::clear_r ) |
| 525 | { |
| 526 | return BIT(input_port_read(m_machine, "RUN"), 0); |
| 527 | } |
| 528 | |
| 529 | READ_LINE_MEMBER( osc1000b_state::ef2_r ) |
| 530 | { |
| 531 | return cassette_input(m_cassette) < 0; |
| 532 | } |
| 533 | |
| 534 | READ_LINE_MEMBER( osc1000b_state::ef3_r ) |
| 535 | { |
| 536 | static const char *const keynames[] = { "IN0", "IN1", "IN2", "IN3", "IN4", "IN5", "IN6", "IN7" }; |
| 537 | UINT8 data = ~input_port_read(m_machine, keynames[m_keylatch / 8]); |
| 538 | |
| 539 | return BIT(data, m_keylatch % 8); |
| 540 | } |
| 541 | |
| 542 | WRITE_LINE_MEMBER( osc1000b_state::q_w ) |
| 543 | { |
| 544 | cassette_output(m_cassette, state ? 1.0 : -1.0); |
| 545 | } |
| 546 | |
| 512 | 547 | static COSMAC_INTERFACE( osc1000b_config ) |
| 513 | 548 | { |
| 514 | 549 | DEVCB_LINE_VCC, |
| 515 | | DEVCB_LINE(clear_r), |
| 550 | DEVCB_DRIVER_LINE_MEMBER(osc1000b_state, clear_r), |
| 516 | 551 | DEVCB_NULL, |
| 517 | | DEVCB_DEVICE_LINE(CASSETTE_TAG, ef2_r), |
| 518 | | DEVCB_LINE(ef3_r), |
| 552 | DEVCB_DRIVER_LINE_MEMBER(osc1000b_state, ef2_r), |
| 553 | DEVCB_DRIVER_LINE_MEMBER(osc1000b_state, ef3_r), |
| 519 | 554 | DEVCB_NULL, |
| 520 | | DEVCB_LINE(tmc1800_q_w), |
| 555 | DEVCB_DRIVER_LINE_MEMBER(osc1000b_state, q_w), |
| 521 | 556 | DEVCB_NULL, |
| 522 | 557 | DEVCB_NULL, |
| 523 | 558 | NULL, |
| r11028 | r11029 | |
| 527 | 562 | |
| 528 | 563 | // Telmac 2000 |
| 529 | 564 | |
| 530 | | static WRITE_LINE_DEVICE_HANDLER( tmc2000_q_w ) |
| 565 | READ_LINE_MEMBER( tmc2000_state::clear_r ) |
| 531 | 566 | { |
| 532 | | tmc2000_state *driver_state = device->machine().driver_data<tmc2000_state>(); |
| 567 | return BIT(input_port_read(m_machine, "RUN"), 0); |
| 568 | } |
| 533 | 569 | |
| 570 | READ_LINE_MEMBER( tmc2000_state::ef2_r ) |
| 571 | { |
| 572 | return cassette_input(m_cassette) < 0; |
| 573 | } |
| 574 | |
| 575 | READ_LINE_MEMBER( tmc2000_state::ef3_r ) |
| 576 | { |
| 577 | static const char *const keynames[] = { "IN0", "IN1", "IN2", "IN3", "IN4", "IN5", "IN6", "IN7" }; |
| 578 | UINT8 data = ~input_port_read(m_machine, keynames[m_keylatch / 8]); |
| 579 | |
| 580 | return BIT(data, m_keylatch % 8); |
| 581 | } |
| 582 | |
| 583 | WRITE_LINE_MEMBER( tmc2000_state::q_w ) |
| 584 | { |
| 534 | 585 | /* CDP1864 audio output enable */ |
| 535 | | cdp1864_aoe_w(driver_state->cdp1864, state); |
| 586 | cdp1864_aoe_w(m_cti, state); |
| 536 | 587 | |
| 537 | 588 | /* set Q led status */ |
| 538 | | set_led_status(device->machine(), 1, state); |
| 589 | set_led_status(m_machine, 1, state); |
| 539 | 590 | |
| 540 | 591 | /* tape output */ |
| 541 | | cassette_output(driver_state->cassette, state ? 1.0 : -1.0); |
| 592 | cassette_output(m_cassette, state ? 1.0 : -1.0); |
| 542 | 593 | } |
| 543 | 594 | |
| 544 | | static WRITE8_DEVICE_HANDLER( tmc2000_dma_w ) |
| 595 | WRITE8_MEMBER( tmc2000_state::dma_w ) |
| 545 | 596 | { |
| 546 | | tmc2000_state *state = device->machine().driver_data<tmc2000_state>(); |
| 597 | m_color = ~(m_colorram[offset & 0x1ff]) & 0x07; |
| 547 | 598 | |
| 548 | | state->color = ~(state->colorram[offset & 0x1ff]) & 0x07; |
| 549 | | |
| 550 | | cdp1864_con_w(state->cdp1864, 0); // HACK |
| 551 | | cdp1864_dma_w(state->cdp1864, offset, data); |
| 599 | cdp1864_con_w(m_cti, 0); // HACK |
| 600 | cdp1864_dma_w(m_cti, offset, data); |
| 552 | 601 | } |
| 553 | 602 | |
| 554 | 603 | static COSMAC_INTERFACE( tmc2000_config ) |
| 555 | 604 | { |
| 556 | 605 | DEVCB_LINE_VCC, |
| 557 | | DEVCB_LINE(clear_r), |
| 606 | DEVCB_DRIVER_LINE_MEMBER(tmc2000_state, clear_r), |
| 558 | 607 | DEVCB_NULL, |
| 559 | | DEVCB_DEVICE_LINE(CASSETTE_TAG, ef2_r), |
| 560 | | DEVCB_LINE(ef3_r), |
| 608 | DEVCB_DRIVER_LINE_MEMBER(tmc2000_state, ef2_r), |
| 609 | DEVCB_DRIVER_LINE_MEMBER(tmc2000_state, ef3_r), |
| 561 | 610 | DEVCB_NULL, |
| 562 | | DEVCB_LINE(tmc2000_q_w), |
| 611 | DEVCB_DRIVER_LINE_MEMBER(tmc2000_state, q_w), |
| 563 | 612 | DEVCB_NULL, |
| 564 | | DEVCB_HANDLER(tmc2000_dma_w), |
| 613 | DEVCB_DRIVER_MEMBER(tmc2000_state, dma_w), |
| 565 | 614 | NULL, |
| 566 | 615 | DEVCB_NULL, |
| 567 | 616 | DEVCB_NULL |
| r11028 | r11029 | |
| 574 | 623 | cputag_set_input_line(machine, CDP1802_TAG, COSMAC_INPUT_LINE_EF4, ASSERT_LINE); |
| 575 | 624 | } |
| 576 | 625 | |
| 577 | | static READ_LINE_DEVICE_HANDLER( nano_clear_r ) |
| 626 | READ_LINE_MEMBER( nano_state::clear_r ) |
| 578 | 627 | { |
| 579 | | int run = BIT(input_port_read(device->machine(), "RUN"), 0); |
| 580 | | int monitor = BIT(input_port_read(device->machine(), "MONITOR"), 0); |
| 628 | int run = BIT(input_port_read(m_machine, "RUN"), 0); |
| 629 | int monitor = BIT(input_port_read(m_machine, "MONITOR"), 0); |
| 581 | 630 | |
| 582 | 631 | return run & monitor; |
| 583 | 632 | } |
| 584 | 633 | |
| 585 | | static READ_LINE_DEVICE_HANDLER( nano_ef2_r ) |
| 634 | READ_LINE_MEMBER( nano_state::ef2_r ) |
| 586 | 635 | { |
| 587 | | return cassette_input(device) < 0; |
| 636 | return cassette_input(m_cassette) < 0; |
| 588 | 637 | } |
| 589 | 638 | |
| 590 | | static READ_LINE_DEVICE_HANDLER( nano_ef3_r ) |
| 639 | READ_LINE_MEMBER( nano_state::ef3_r ) |
| 591 | 640 | { |
| 592 | | nano_state *state = device->machine().driver_data<nano_state>(); |
| 593 | 641 | static const char *const keynames[] = { "IN0", "IN1", "IN2", "IN3", "IN4", "IN5", "IN6", "IN7" }; |
| 594 | | UINT8 data = ~input_port_read(device->machine(), keynames[state->keylatch / 8]); |
| 642 | UINT8 data = ~input_port_read(m_machine, keynames[m_keylatch / 8]); |
| 595 | 643 | |
| 596 | | return BIT(data, state->keylatch % 8); |
| 644 | return BIT(data, m_keylatch % 8); |
| 597 | 645 | } |
| 598 | 646 | |
| 599 | | static WRITE_LINE_DEVICE_HANDLER( nano_q_w ) |
| 647 | WRITE_LINE_MEMBER( nano_state::q_w ) |
| 600 | 648 | { |
| 601 | | nano_state *driver_state = device->machine().driver_data<nano_state>(); |
| 602 | | |
| 603 | 649 | /* CDP1864 audio output enable */ |
| 604 | | cdp1864_aoe_w(driver_state->cdp1864, state); |
| 650 | cdp1864_aoe_w(m_cti, state); |
| 605 | 651 | |
| 606 | 652 | /* set Q led status */ |
| 607 | | set_led_status(device->machine(), 1, state); |
| 653 | set_led_status(m_machine, 1, state); |
| 608 | 654 | |
| 609 | 655 | /* tape output */ |
| 610 | | cassette_output(driver_state->cassette, state ? 1.0 : -1.0); |
| 656 | cassette_output(m_cassette, state ? 1.0 : -1.0); |
| 611 | 657 | } |
| 612 | 658 | |
| 613 | 659 | static COSMAC_INTERFACE( nano_config ) |
| 614 | 660 | { |
| 615 | 661 | DEVCB_LINE_VCC, |
| 616 | | DEVCB_LINE(nano_clear_r), |
| 662 | DEVCB_DRIVER_LINE_MEMBER(nano_state, clear_r), |
| 617 | 663 | DEVCB_NULL, |
| 618 | | DEVCB_DEVICE_LINE(CASSETTE_TAG, nano_ef2_r), |
| 619 | | DEVCB_LINE(nano_ef3_r), |
| 664 | DEVCB_DRIVER_LINE_MEMBER(nano_state, ef2_r), |
| 665 | DEVCB_DRIVER_LINE_MEMBER(nano_state, ef3_r), |
| 620 | 666 | DEVCB_NULL, |
| 621 | | DEVCB_LINE(nano_q_w), |
| 667 | DEVCB_DRIVER_LINE_MEMBER(nano_state, q_w), |
| 622 | 668 | DEVCB_NULL, |
| 623 | 669 | DEVCB_DEVICE_HANDLER(CDP1864_TAG, cdp1864_dma_w), |
| 624 | 670 | NULL, |
| r11028 | r11029 | |
| 630 | 676 | |
| 631 | 677 | // Telmac 1800 |
| 632 | 678 | |
| 633 | | static MACHINE_START( tmc1800 ) |
| 679 | void tmc1800_state::machine_start() |
| 634 | 680 | { |
| 635 | | tmc1800_state *state = machine.driver_data<tmc1800_state>(); |
| 636 | | |
| 637 | | /* find devices */ |
| 638 | | state->cdp1861 = machine.device(CDP1861_TAG); |
| 639 | | state->cassette = machine.device(CASSETTE_TAG); |
| 640 | | |
| 641 | 681 | /* register for state saving */ |
| 642 | | state->save_item(NAME(state->keylatch)); |
| 682 | save_item(NAME(m_keylatch)); |
| 643 | 683 | } |
| 644 | 684 | |
| 645 | | static MACHINE_RESET( tmc1800 ) |
| 685 | void tmc1800_state::machine_reset() |
| 646 | 686 | { |
| 647 | | tmc1800_state *state = machine.driver_data<tmc1800_state>(); |
| 648 | | |
| 649 | 687 | /* reset CDP1861 */ |
| 650 | | state->cdp1861->reset(); |
| 688 | m_vdc->reset(); |
| 651 | 689 | } |
| 652 | 690 | |
| 653 | 691 | // OSCOM 1000B |
| 654 | 692 | |
| 655 | | static MACHINE_START( osc1000b ) |
| 693 | void osc1000b_state::machine_start() |
| 656 | 694 | { |
| 657 | | osc1000b_state *state = machine.driver_data<osc1000b_state>(); |
| 658 | | |
| 659 | | /* find devices */ |
| 660 | | state->cassette = machine.device(CASSETTE_TAG); |
| 661 | | |
| 662 | 695 | /* register for state saving */ |
| 663 | | state->save_item(NAME(state->keylatch)); |
| 696 | save_item(NAME(m_keylatch)); |
| 664 | 697 | } |
| 665 | 698 | |
| 666 | | static MACHINE_RESET( osc1000b ) |
| 699 | void osc1000b_state::machine_reset() |
| 667 | 700 | { |
| 668 | 701 | } |
| 669 | 702 | |
| 670 | 703 | // Telmac 2000 |
| 671 | 704 | |
| 672 | | static MACHINE_START( tmc2000 ) |
| 705 | void tmc2000_state::machine_start() |
| 673 | 706 | { |
| 674 | | tmc2000_state *state = machine.driver_data<tmc2000_state>(); |
| 675 | | |
| 676 | 707 | UINT16 addr; |
| 677 | 708 | |
| 678 | | /* RAM banking */ |
| 679 | | memory_configure_bank(machine, "bank1", 0, 2, machine.region(CDP1802_TAG)->base(), 0x8000); |
| 709 | m_colorram = auto_alloc_array(m_machine, UINT8, TMC2000_COLORRAM_SIZE); |
| 680 | 710 | |
| 681 | | /* ROM/colorram banking */ |
| 682 | | state->colorram = auto_alloc_array(machine, UINT8, TMC2000_COLORRAM_SIZE); |
| 683 | | |
| 684 | | memory_configure_bank(machine, "bank2", TMC2000_BANK_MONITOR, 1, machine.region(CDP1802_TAG)->base() + 0x8000, 0); |
| 685 | | memory_configure_bank(machine, "bank2", TMC2000_BANK_COLORRAM, 1, state->colorram, 0); |
| 686 | | |
| 687 | | /* randomize color RAM contents */ |
| 711 | // randomize color RAM contents |
| 688 | 712 | for (addr = 0; addr < TMC2000_COLORRAM_SIZE; addr++) |
| 689 | 713 | { |
| 690 | | state->colorram[addr] = machine.rand() & 0xff; |
| 714 | m_colorram[addr] = m_machine.rand() & 0xff; |
| 691 | 715 | } |
| 692 | 716 | |
| 693 | | /* find devices */ |
| 694 | | state->cdp1864 = machine.device(CDP1864_TAG); |
| 695 | | state->cassette = machine.device(CASSETTE_TAG); |
| 696 | | |
| 697 | | /* register for state saving */ |
| 698 | | state->save_pointer(NAME(state->colorram), TMC2000_COLORRAM_SIZE); |
| 699 | | state->save_item(NAME(state->keylatch)); |
| 717 | // state saving |
| 718 | save_pointer(NAME(m_colorram), TMC2000_COLORRAM_SIZE); |
| 719 | save_item(NAME(m_keylatch)); |
| 720 | save_item(NAME(m_rac)); |
| 721 | save_item(NAME(m_roc)); |
| 700 | 722 | } |
| 701 | 723 | |
| 702 | | static MACHINE_RESET( tmc2000 ) |
| 724 | void tmc2000_state::machine_reset() |
| 703 | 725 | { |
| 704 | | tmc2000_state *state = machine.driver_data<tmc2000_state>(); |
| 726 | // reset CDP1864 |
| 727 | m_cti->reset(); |
| 705 | 728 | |
| 706 | | /* reset CDP1864 */ |
| 707 | | state->cdp1864->reset(); |
| 708 | | |
| 709 | | /* enable monitor mirror at 0x0000 */ |
| 710 | | memory_set_bank(machine, "bank1", TMC2000_BANK_ROM); |
| 711 | | machine.device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_readwrite_bank(0x0000, 0x01ff, 0, 0x7e00, "bank1"); |
| 712 | | machine.device(CDP1802_TAG)->memory().space(AS_PROGRAM)->unmap_write(0x0000, 0x01ff, 0, 0x7e00); |
| 713 | | |
| 714 | | /* enable monitor */ |
| 715 | | memory_set_bank(machine, "bank2", TMC2000_BANK_MONITOR); |
| 716 | | machine.device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_readwrite_bank(0x8000, 0x81ff, 0, 0x7e00, "bank2"); |
| 717 | | machine.device(CDP1802_TAG)->memory().space(AS_PROGRAM)->unmap_write(0x8000, 0x81ff, 0, 0x7e00); |
| 729 | // banking |
| 730 | m_roc = 1; |
| 731 | m_rac = 0; |
| 732 | bankswitch(); |
| 718 | 733 | } |
| 719 | 734 | |
| 720 | 735 | // OSCOM Nano |
| 721 | 736 | |
| 722 | | static MACHINE_START( nano ) |
| 737 | void nano_state::machine_start() |
| 723 | 738 | { |
| 724 | | nano_state *state = machine.driver_data<nano_state>(); |
| 725 | | |
| 726 | | /* RAM/ROM banking */ |
| 727 | | memory_configure_bank(machine, "bank1", 0, 2, machine.region(CDP1802_TAG)->base(), 0x8000); |
| 728 | | |
| 729 | 739 | /* allocate monitor timer */ |
| 730 | | state->ef4_timer = machine.scheduler().timer_alloc(FUNC(nano_ef4_tick)); |
| 740 | m_ef4_timer = m_machine.scheduler().timer_alloc(FUNC(nano_ef4_tick)); |
| 731 | 741 | |
| 732 | | /* find devices */ |
| 733 | | state->cdp1864 = machine.device(CDP1864_TAG); |
| 734 | | state->cassette = machine.device(CASSETTE_TAG); |
| 735 | | |
| 736 | 742 | /* register for state saving */ |
| 737 | | state->save_item(NAME(state->keylatch)); |
| 743 | save_item(NAME(m_keylatch)); |
| 738 | 744 | } |
| 739 | 745 | |
| 740 | | static MACHINE_RESET( nano ) |
| 746 | void nano_state::machine_reset() |
| 741 | 747 | { |
| 742 | | nano_state *state = machine.driver_data<nano_state>(); |
| 743 | | |
| 744 | 748 | /* assert EF4 */ |
| 745 | | cputag_set_input_line(machine, CDP1802_TAG, COSMAC_INPUT_LINE_EF4, ASSERT_LINE); |
| 749 | m_maincpu->set_input_line(COSMAC_INPUT_LINE_EF4, ASSERT_LINE); |
| 746 | 750 | |
| 747 | 751 | /* reset CDP1864 */ |
| 748 | | state->cdp1864->reset(); |
| 752 | m_cti->reset(); |
| 749 | 753 | |
| 750 | 754 | /* enable ROM */ |
| 751 | | memory_set_bank(machine, "bank1", OSCNANO_BANK_ROM); |
| 752 | | machine.device(CDP1802_TAG)->memory().space(AS_PROGRAM)->install_readwrite_bank(0x0000, 0x01ff, 0, 0x7e00, "bank1"); |
| 755 | address_space *program = m_maincpu->memory().space(AS_PROGRAM); |
| 756 | UINT8 *rom = m_machine.region(CDP1802_TAG)->base(); |
| 757 | program->install_rom(0x0000, 0x01ff, 0, 0x7e00, rom); |
| 753 | 758 | } |
| 754 | 759 | |
| 755 | 760 | /* Machine Drivers */ |
| r11028 | r11029 | |
| 762 | 767 | NULL |
| 763 | 768 | }; |
| 764 | 769 | |
| 770 | static QUICKLOAD_LOAD( tmc1800 ) |
| 771 | { |
| 772 | UINT8 *ptr = image.device().machine().region(CDP1802_TAG)->base(); |
| 773 | int size = image.length(); |
| 765 | 774 | |
| 775 | if (size > ram_get_size(image.device().machine().device(RAM_TAG))) |
| 776 | { |
| 777 | return IMAGE_INIT_FAIL; |
| 778 | } |
| 779 | |
| 780 | image.fread( ptr, size); |
| 781 | |
| 782 | return IMAGE_INIT_PASS; |
| 783 | } |
| 784 | |
| 766 | 785 | static MACHINE_CONFIG_START( tmc1800, tmc1800_state ) |
| 767 | 786 | // basic system hardware |
| 768 | 787 | MCFG_CPU_ADD(CDP1802_TAG, COSMAC, XTAL_1_75MHz) |
| r11028 | r11029 | |
| 770 | 789 | MCFG_CPU_IO_MAP(tmc1800_io_map) |
| 771 | 790 | MCFG_CPU_CONFIG(tmc1800_config) |
| 772 | 791 | |
| 773 | | MCFG_MACHINE_START(tmc1800) |
| 774 | | MCFG_MACHINE_RESET(tmc1800) |
| 775 | | |
| 776 | 792 | // video hardware |
| 777 | 793 | MCFG_FRAGMENT_ADD(tmc1800_video) |
| 778 | 794 | |
| r11028 | r11029 | |
| 799 | 815 | MCFG_CPU_IO_MAP(osc1000b_io_map) |
| 800 | 816 | MCFG_CPU_CONFIG(osc1000b_config) |
| 801 | 817 | |
| 802 | | MCFG_MACHINE_START(osc1000b) |
| 803 | | MCFG_MACHINE_RESET(osc1000b) |
| 804 | | |
| 805 | 818 | // video hardware |
| 806 | 819 | MCFG_FRAGMENT_ADD(osc1000b_video) |
| 807 | 820 | |
| r11028 | r11029 | |
| 815 | 828 | MCFG_QUICKLOAD_ADD("quickload", tmc1800, "bin", 0) |
| 816 | 829 | MCFG_CASSETTE_ADD( "cassette", tmc1800_cassette_config ) |
| 817 | 830 | |
| 818 | | /* internal ram */ |
| 831 | // internal ram |
| 819 | 832 | MCFG_RAM_ADD(RAM_TAG) |
| 820 | 833 | MCFG_RAM_DEFAULT_SIZE("2K") |
| 821 | 834 | MCFG_RAM_EXTRA_OPTIONS("4K") |
| r11028 | r11029 | |
| 828 | 841 | MCFG_CPU_IO_MAP(tmc2000_io_map) |
| 829 | 842 | MCFG_CPU_CONFIG(tmc2000_config) |
| 830 | 843 | |
| 831 | | MCFG_MACHINE_START(tmc2000) |
| 832 | | MCFG_MACHINE_RESET(tmc2000) |
| 833 | | |
| 834 | 844 | // video hardware |
| 835 | 845 | MCFG_FRAGMENT_ADD(tmc2000_video) |
| 836 | 846 | |
| r11028 | r11029 | |
| 838 | 848 | MCFG_QUICKLOAD_ADD("quickload", tmc1800, "bin", 0) |
| 839 | 849 | MCFG_CASSETTE_ADD( "cassette", tmc1800_cassette_config ) |
| 840 | 850 | |
| 841 | | /* internal ram */ |
| 851 | // internal ram |
| 842 | 852 | MCFG_RAM_ADD(RAM_TAG) |
| 843 | 853 | MCFG_RAM_DEFAULT_SIZE("4K") |
| 844 | 854 | MCFG_RAM_EXTRA_OPTIONS("16K,32K") |
| r11028 | r11029 | |
| 851 | 861 | MCFG_CPU_IO_MAP(nano_io_map) |
| 852 | 862 | MCFG_CPU_CONFIG(nano_config) |
| 853 | 863 | |
| 854 | | MCFG_MACHINE_START(nano) |
| 855 | | MCFG_MACHINE_RESET(nano) |
| 856 | | |
| 857 | 864 | // video hardware |
| 858 | 865 | MCFG_FRAGMENT_ADD(nano_video) |
| 859 | 866 | |
| r11028 | r11029 | |
| 861 | 868 | MCFG_QUICKLOAD_ADD("quickload", tmc1800, "bin", 0) |
| 862 | 869 | MCFG_CASSETTE_ADD( "cassette", tmc1800_cassette_config ) |
| 863 | 870 | |
| 864 | | /* internal ram */ |
| 871 | // internal ram |
| 865 | 872 | MCFG_RAM_ADD(RAM_TAG) |
| 866 | 873 | MCFG_RAM_DEFAULT_SIZE("4K") |
| 867 | 874 | MACHINE_CONFIG_END |
| r11028 | r11029 | |
| 869 | 876 | /* ROMs */ |
| 870 | 877 | |
| 871 | 878 | ROM_START( tmc1800 ) |
| 872 | | ROM_REGION( 0x10000, CDP1802_TAG, 0 ) |
| 873 | | ROM_LOAD( "mmi6341-1.ic2", 0x8000, 0x0200, NO_DUMP ) // equivalent to 82S141 |
| 879 | ROM_REGION( 0x200, CDP1802_TAG, 0 ) |
| 880 | ROM_LOAD( "mmi6341-1.ic2", 0x000, 0x200, NO_DUMP ) // equivalent to 82S141 |
| 874 | 881 | ROM_END |
| 875 | 882 | |
| 876 | 883 | ROM_START( osc1000b ) |
| 877 | | ROM_REGION( 0x10000, CDP1802_TAG, 0 ) |
| 878 | | ROM_LOAD( "mmi6341-1.ic2", 0x8000, 0x0200, NO_DUMP ) // equivalent to 82S141 |
| 884 | ROM_REGION( 0x200, CDP1802_TAG, 0 ) |
| 885 | ROM_LOAD( "mmi6341-1.ic2", 0x000, 0x0200, NO_DUMP ) // equivalent to 82S141 |
| 879 | 886 | |
| 880 | 887 | ROM_REGION( 0x400, "gfx1", 0 ) |
| 881 | | ROM_LOAD( "mmi6349.5d", 0x0000, 0x0200, NO_DUMP ) // equivalent to 82S147 |
| 882 | | ROM_LOAD( "mmi6349.5c", 0x0200, 0x0200, NO_DUMP ) // equivalent to 82S147 |
| 888 | ROM_LOAD( "mmi6349.5d", 0x000, 0x200, NO_DUMP ) // equivalent to 82S147 |
| 889 | ROM_LOAD( "mmi6349.5c", 0x200, 0x200, NO_DUMP ) // equivalent to 82S147 |
| 883 | 890 | ROM_END |
| 884 | 891 | |
| 885 | 892 | ROM_START( tmc2000 ) |
| 886 | | ROM_REGION( 0x10000, CDP1802_TAG, 0 ) |
| 893 | ROM_REGION( 0x800, CDP1802_TAG, 0 ) |
| 887 | 894 | ROM_SYSTEM_BIOS( 0, "prom200", "PROM N:o 200" ) |
| 888 | | ROMX_LOAD( "200.m5", 0x8000, 0x0200, BAD_DUMP CRC(79da3221) SHA1(008da3ef4f69ab1a493362dfca856375b19c94bd), ROM_BIOS(1) ) // typed in from the manual |
| 895 | ROMX_LOAD( "200.m5", 0x000, 0x200, BAD_DUMP CRC(79da3221) SHA1(008da3ef4f69ab1a493362dfca856375b19c94bd), ROM_BIOS(1) ) // typed in from the manual |
| 889 | 896 | ROM_SYSTEM_BIOS( 1, "prom202", "PROM N:o 202" ) |
| 890 | | ROMX_LOAD( "202.m5", 0x8000, 0x0200, NO_DUMP, ROM_BIOS(2) ) |
| 897 | ROMX_LOAD( "202.m5", 0x000, 0x200, NO_DUMP, ROM_BIOS(2) ) |
| 891 | 898 | ROM_SYSTEM_BIOS( 2, "tool2000", "TOOL-2000" ) |
| 892 | | ROMX_LOAD( "tool2000", 0x8000, 0x0800, NO_DUMP, ROM_BIOS(3) ) |
| 899 | ROMX_LOAD( "tool2000", 0x000, 0x800, NO_DUMP, ROM_BIOS(3) ) |
| 893 | 900 | ROM_END |
| 894 | 901 | |
| 895 | 902 | ROM_START( nano ) |
| 896 | | ROM_REGION( 0x10000, CDP1802_TAG, 0 ) |
| 897 | | ROM_LOAD( "mmi6349.ic", 0x8000, 0x0200, BAD_DUMP CRC(1ec1b432) SHA1(ac41f5e38bcd4b80bd7a5b277a2c600899fd5fb8) ) // equivalent to 82S141 |
| 903 | ROM_REGION( 0x200, CDP1802_TAG, 0 ) |
| 904 | ROM_LOAD( "mmi6349.ic", 0x000, 0x200, BAD_DUMP CRC(1ec1b432) SHA1(ac41f5e38bcd4b80bd7a5b277a2c600899fd5fb8) ) // equivalent to 82S141 |
| 898 | 905 | ROM_END |
| 899 | 906 | |
| 900 | | /* System Configuration */ |
| 901 | | |
| 902 | | static QUICKLOAD_LOAD( tmc1800 ) |
| 903 | | { |
| 904 | | UINT8 *ptr = image.device().machine().region(CDP1802_TAG)->base(); |
| 905 | | int size = image.length(); |
| 906 | | |
| 907 | | if (size > ram_get_size(image.device().machine().device(RAM_TAG))) |
| 908 | | { |
| 909 | | return IMAGE_INIT_FAIL; |
| 910 | | } |
| 911 | | |
| 912 | | image.fread( ptr, size); |
| 913 | | |
| 914 | | return IMAGE_INIT_PASS; |
| 915 | | } |
| 916 | | |
| 917 | 907 | /* Driver Initialization */ |
| 918 | 908 | |
| 919 | 909 | static TIMER_CALLBACK(setup_beep) |
| r11028 | r11029 | |
| 934 | 924 | COMP( 1977, tmc1800, 0, 0, tmc1800, tmc1800, tmc1800, "Telercas Oy", "Telmac 1800", GAME_NOT_WORKING ) |
| 935 | 925 | COMP( 1977, osc1000b, tmc1800,0, osc1000b, tmc1800, tmc1800, "OSCOM Oy", "OSCOM 1000B", GAME_NOT_WORKING ) |
| 936 | 926 | COMP( 1980, tmc2000, 0, 0, tmc2000, tmc2000, 0, "Telercas Oy", "Telmac 2000", GAME_SUPPORTS_SAVE ) |
| 937 | | COMP( 1980, nano, tmc2000,0, nano, nano, 0, "OSCOM Oy", "OSCOM Nano", GAME_SUPPORTS_SAVE ) |
| 927 | COMP( 1980, nano, tmc2000,0, nano, nano, 0, "OSCOM Oy", "OSCOM Nano", GAME_SUPPORTS_SAVE ) |