trunk/src/mess/machine/pet.c
| r21304 | r21305 | |
| 1 | | /*************************************************************************** |
| 2 | | commodore pet series computer |
| 3 | | |
| 4 | | peter.trauner@jk.uni-linz.ac.at |
| 5 | | ***************************************************************************/ |
| 6 | | |
| 7 | | #include "emu.h" |
| 8 | | #include "cpu/m6502/m6502.h" |
| 9 | | #include "cpu/m6809/m6809.h" |
| 10 | | |
| 11 | | #include "machine/6821pia.h" |
| 12 | | #include "machine/6522via.h" |
| 13 | | #include "machine/ieee488.h" |
| 14 | | |
| 15 | | #include "includes/pet.h" |
| 16 | | |
| 17 | | #include "imagedev/cartslot.h" |
| 18 | | #include "machine/ram.h" |
| 19 | | |
| 20 | | #define VERBOSE_LEVEL 0 |
| 21 | | #define DBG_LOG( MACHINE, N, M, A ) \ |
| 22 | | do { \ |
| 23 | | if(VERBOSE_LEVEL >= N) \ |
| 24 | | { \ |
| 25 | | if( M ) \ |
| 26 | | logerror("%11.6f: %-24s", MACHINE.time().as_double(), (char*) M ); \ |
| 27 | | logerror A; \ |
| 28 | | } \ |
| 29 | | } while (0) |
| 30 | | |
| 31 | | |
| 32 | | |
| 33 | | /* pia at 0xe810 |
| 34 | | port a |
| 35 | | 7 sense input (low for diagnostics) |
| 36 | | 6 ieee eoi in |
| 37 | | 5 cassette 2 switch in |
| 38 | | 4 cassette 1 switch in |
| 39 | | 3..0 keyboard line select |
| 40 | | |
| 41 | | ca1 cassette 1 read |
| 42 | | ca2 ieee eoi out |
| 43 | | |
| 44 | | cb1 video sync in |
| 45 | | cb2 cassette 1 motor out |
| 46 | | */ |
| 47 | | READ8_MEMBER(pet_state::pia0_pa_r) |
| 48 | | { |
| 49 | | /* |
| 50 | | |
| 51 | | bit description |
| 52 | | |
| 53 | | PA0 KEY A |
| 54 | | PA1 KEY B |
| 55 | | PA2 KEY C |
| 56 | | PA3 KEY D |
| 57 | | PA4 #1 CASS SWITCH |
| 58 | | PA5 #2 CASS SWITCH |
| 59 | | PA6 _EOI IN |
| 60 | | PA7 DIAG JUMPER |
| 61 | | |
| 62 | | */ |
| 63 | | |
| 64 | | UINT8 data = 0; |
| 65 | | |
| 66 | | /* key */ |
| 67 | | data |= m_keyline_select; |
| 68 | | |
| 69 | | /* #1 cassette switch */ |
| 70 | | data |= m_cassette->sense_r() << 4; |
| 71 | | |
| 72 | | /* #2 cassette switch */ |
| 73 | | data |= m_cassette2->sense_r() << 5; |
| 74 | | |
| 75 | | /* end or identify in */ |
| 76 | | data |= m_ieee->eoi_r() << 6; |
| 77 | | |
| 78 | | /* diagnostic jumper */ |
| 79 | | data |= 0x80; |
| 80 | | |
| 81 | | return data; |
| 82 | | } |
| 83 | | |
| 84 | | WRITE8_MEMBER(pet_state::pia0_pa_w) |
| 85 | | { |
| 86 | | /* |
| 87 | | |
| 88 | | bit description |
| 89 | | |
| 90 | | PA0 KEY A |
| 91 | | PA1 KEY B |
| 92 | | PA2 KEY C |
| 93 | | PA3 KEY D |
| 94 | | PA4 #1 CASS SWITCH |
| 95 | | PA5 #2 CASS SWITCH |
| 96 | | PA6 _EOI IN |
| 97 | | PA7 DIAG JUMPER |
| 98 | | |
| 99 | | */ |
| 100 | | |
| 101 | | /* key */ |
| 102 | | m_keyline_select = data & 0x0f; |
| 103 | | } |
| 104 | | |
| 105 | | /* Keyboard reading/handling for regular keyboard */ |
| 106 | | READ8_MEMBER(pet_state::kin_r) |
| 107 | | { |
| 108 | | /* |
| 109 | | |
| 110 | | bit description |
| 111 | | |
| 112 | | PB0 KIN0 |
| 113 | | PB1 KIN1 |
| 114 | | PB2 KIN2 |
| 115 | | PB3 KIN3 |
| 116 | | PB4 KIN4 |
| 117 | | PB5 KIN5 |
| 118 | | PB6 KIN6 |
| 119 | | PB7 KIN7 |
| 120 | | |
| 121 | | */ |
| 122 | | |
| 123 | | UINT8 data = 0xff; |
| 124 | | static const char *const keynames[] = { |
| 125 | | "ROW0", "ROW1", "ROW2", "ROW3", "ROW4", |
| 126 | | "ROW5", "ROW6", "ROW7", "ROW8", "ROW9" |
| 127 | | }; |
| 128 | | |
| 129 | | if (m_keyline_select < 10) |
| 130 | | { |
| 131 | | data = machine().root_device().ioport(keynames[m_keyline_select])->read(); |
| 132 | | /* Check for left-shift lock */ |
| 133 | | if ((m_keyline_select == 8) && (machine().root_device().ioport("SPECIAL")->read() & 0x80)) |
| 134 | | data &= 0xfe; |
| 135 | | } |
| 136 | | return data; |
| 137 | | } |
| 138 | | |
| 139 | | /* Keyboard handling for business keyboard */ |
| 140 | | READ8_MEMBER(pet_state::petb_kin_r) |
| 141 | | { |
| 142 | | UINT8 data = 0xff; |
| 143 | | static const char *const keynames[] = { |
| 144 | | "ROW0", "ROW1", "ROW2", "ROW3", "ROW4", |
| 145 | | "ROW5", "ROW6", "ROW7", "ROW8", "ROW9" |
| 146 | | }; |
| 147 | | |
| 148 | | if (m_keyline_select < 10) |
| 149 | | { |
| 150 | | data = machine().root_device().ioport(keynames[m_keyline_select])->read(); |
| 151 | | /* Check for left-shift lock */ |
| 152 | | /* 2008-05 FP: For some reason, superpet read it in the opposite way!! */ |
| 153 | | /* While waiting for confirmation from docs, we add a workaround here. */ |
| 154 | | if (m_superpet) |
| 155 | | { |
| 156 | | if ((m_keyline_select == 6) && !(machine().root_device().ioport("SPECIAL")->read() & 0x80)) |
| 157 | | data &= 0xfe; |
| 158 | | } |
| 159 | | else |
| 160 | | { |
| 161 | | if ((m_keyline_select == 6) && (machine().root_device().ioport("SPECIAL")->read() & 0x80)) |
| 162 | | data &= 0xfe; |
| 163 | | } |
| 164 | | } |
| 165 | | return data; |
| 166 | | } |
| 167 | | |
| 168 | | READ8_MEMBER(pet_state::cass1_r) |
| 169 | | { |
| 170 | | // cassette 1 read |
| 171 | | return m_cassette->read(); |
| 172 | | } |
| 173 | | |
| 174 | | WRITE8_MEMBER(pet_state::cass1_motor_w) |
| 175 | | { |
| 176 | | m_cassette->motor_w(data); |
| 177 | | } |
| 178 | | |
| 179 | | WRITE_LINE_MEMBER(pet_state::pia0_irq_w) |
| 180 | | { |
| 181 | | m_pia0_irq = state; |
| 182 | | int level = (m_pia0_irq | m_pia1_irq | m_via_irq) ? ASSERT_LINE : CLEAR_LINE; |
| 183 | | |
| 184 | | machine().firstcpu->set_input_line(INPUT_LINE_IRQ0, level); |
| 185 | | } |
| 186 | | |
| 187 | | const pia6821_interface pet_pia0 = |
| 188 | | { |
| 189 | | DEVCB_DRIVER_MEMBER(pet_state,pia0_pa_r), /* in_a_func */ |
| 190 | | DEVCB_DRIVER_MEMBER(pet_state,kin_r), /* in_b_func */ |
| 191 | | DEVCB_DRIVER_MEMBER(pet_state,cass1_r), /* in_ca1_func */ |
| 192 | | DEVCB_NULL, /* in_cb1_func */ |
| 193 | | DEVCB_NULL, /* in_ca2_func */ |
| 194 | | DEVCB_NULL, /* in_cb2_func */ |
| 195 | | DEVCB_DRIVER_MEMBER(pet_state,pia0_pa_w), /* out_a_func */ |
| 196 | | DEVCB_NULL, /* out_b_func */ |
| 197 | | DEVCB_DEVICE_LINE_MEMBER(IEEE488_TAG, ieee488_device, eoi_w), /* out_ca2_func */ |
| 198 | | DEVCB_DRIVER_MEMBER(pet_state,cass1_motor_w), /* out_cb2_func */ |
| 199 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,pia0_irq_w), /* irq_a_func */ |
| 200 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,pia0_irq_w) /* irq_b_func */ |
| 201 | | }; |
| 202 | | |
| 203 | | const pia6821_interface petb_pia0 = |
| 204 | | { |
| 205 | | DEVCB_DRIVER_MEMBER(pet_state,pia0_pa_r), /* in_a_func */ |
| 206 | | DEVCB_DRIVER_MEMBER(pet_state,petb_kin_r), /* in_b_func */ |
| 207 | | DEVCB_DRIVER_MEMBER(pet_state,cass1_r), /* in_ca1_func */ |
| 208 | | DEVCB_NULL, /* in_cb1_func */ |
| 209 | | DEVCB_NULL, /* in_ca2_func */ |
| 210 | | DEVCB_NULL, /* in_cb2_func */ |
| 211 | | DEVCB_DRIVER_MEMBER(pet_state,pia0_pa_w), /* out_a_func */ |
| 212 | | DEVCB_NULL, /* out_b_func */ |
| 213 | | DEVCB_DEVICE_LINE_MEMBER(IEEE488_TAG, ieee488_device, eoi_w), /* out_ca2_func */ |
| 214 | | DEVCB_DRIVER_MEMBER(pet_state,cass1_motor_w), /* out_cb2_func */ |
| 215 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,pia0_irq_w), /* irq_a_func */ |
| 216 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,pia0_irq_w) /* irq_b_func */ |
| 217 | | }; |
| 218 | | |
| 219 | | /* pia at 0xe820 (ieee488) |
| 220 | | port a data in |
| 221 | | port b data out |
| 222 | | ca1 atn in |
| 223 | | ca2 ndac out |
| 224 | | cb1 srq in |
| 225 | | cb2 dav out |
| 226 | | */ |
| 227 | | |
| 228 | | WRITE_LINE_MEMBER(pet_state::pia1_irq_w) |
| 229 | | { |
| 230 | | m_pia1_irq = state; |
| 231 | | int level = (m_pia0_irq || m_pia1_irq || m_via_irq) ? ASSERT_LINE : CLEAR_LINE; |
| 232 | | |
| 233 | | machine().firstcpu->set_input_line(INPUT_LINE_IRQ0, level); |
| 234 | | } |
| 235 | | |
| 236 | | const pia6821_interface pet_pia1 = |
| 237 | | { |
| 238 | | DEVCB_DEVICE_MEMBER(IEEE488_TAG, ieee488_device, dio_r),/* in_a_func */ |
| 239 | | DEVCB_NULL, /* in_b_func */ |
| 240 | | DEVCB_DEVICE_LINE_MEMBER(IEEE488_TAG, ieee488_device, atn_r), /* in_ca1_func */ |
| 241 | | DEVCB_DEVICE_LINE_MEMBER(IEEE488_TAG, ieee488_device, srq_r), /* in_cb1_func */ |
| 242 | | DEVCB_NULL, /* in_ca2_func */ |
| 243 | | DEVCB_NULL, /* in_cb2_func */ |
| 244 | | DEVCB_NULL, /* out_a_func */ |
| 245 | | DEVCB_DEVICE_MEMBER(IEEE488_TAG, ieee488_device, dio_w), /* out_b_func */ |
| 246 | | DEVCB_DEVICE_LINE_MEMBER(IEEE488_TAG, ieee488_device, ndac_w), /* out_ca2_func */ |
| 247 | | DEVCB_DEVICE_LINE_MEMBER(IEEE488_TAG, ieee488_device, dav_w), /* out_cb2_func */ |
| 248 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,pia1_irq_w), /* irq_a_func */ |
| 249 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,pia1_irq_w) /* irq_b_func */ |
| 250 | | }; |
| 251 | | |
| 252 | | /* userport, cassettes, rest ieee488 |
| 253 | | ca1 userport |
| 254 | | ca2 character rom address line 11 |
| 255 | | pa user port |
| 256 | | |
| 257 | | pb0 ieee ndac in |
| 258 | | pb1 ieee nrfd out |
| 259 | | pb2 ieee atn out |
| 260 | | pb3 userport/cassettes |
| 261 | | pb4 cassettes |
| 262 | | pb5 userport/??? |
| 263 | | pb6 ieee nrfd in |
| 264 | | pb7 ieee dav in |
| 265 | | |
| 266 | | cb1 cassettes |
| 267 | | cb2 user port |
| 268 | | */ |
| 269 | | READ8_MEMBER(pet_state::via_pb_r) |
| 270 | | { |
| 271 | | /* |
| 272 | | |
| 273 | | bit description |
| 274 | | |
| 275 | | PB0 _NDAC IN |
| 276 | | PB1 _NRFD OUT |
| 277 | | PB2 _ATN OUT |
| 278 | | PB3 CASS WRITE |
| 279 | | PB4 #2 CASS MOTOR |
| 280 | | PB5 SYNC IN |
| 281 | | PB6 _NRFD IN |
| 282 | | PB7 _DAV IN |
| 283 | | |
| 284 | | */ |
| 285 | | |
| 286 | | UINT8 data = 0; |
| 287 | | |
| 288 | | /* not data accepted in */ |
| 289 | | data |= m_ieee->ndac_r(); |
| 290 | | |
| 291 | | /* sync in */ |
| 292 | | |
| 293 | | /* not ready for data in */ |
| 294 | | data |= m_ieee->nrfd_r() << 6; |
| 295 | | |
| 296 | | /* data valid in */ |
| 297 | | data |= m_ieee->dav_r() << 7; |
| 298 | | |
| 299 | | return data; |
| 300 | | } |
| 301 | | |
| 302 | | READ_LINE_MEMBER(pet_state::cass2_r) |
| 303 | | { |
| 304 | | return m_cassette2->read(); |
| 305 | | } |
| 306 | | |
| 307 | | WRITE8_MEMBER(pet_state::via_pb_w) |
| 308 | | { |
| 309 | | /* |
| 310 | | |
| 311 | | bit description |
| 312 | | |
| 313 | | PB0 _NDAC IN |
| 314 | | PB1 _NRFD OUT |
| 315 | | PB2 _ATN OUT |
| 316 | | PB3 CASS WRITE |
| 317 | | PB4 #2 CASS MOTOR |
| 318 | | PB5 SYNC IN |
| 319 | | PB6 _NRFD IN |
| 320 | | PB7 _DAV IN |
| 321 | | |
| 322 | | */ |
| 323 | | |
| 324 | | /* not ready for data out */ |
| 325 | | m_ieee->nrfd_w(BIT(data, 1)); |
| 326 | | |
| 327 | | /* attention out */ |
| 328 | | m_ieee->atn_w(BIT(data, 2)); |
| 329 | | |
| 330 | | /* cassette write */ |
| 331 | | m_cassette->write(BIT(data, 3)); |
| 332 | | m_cassette2->write(BIT(data, 3)); |
| 333 | | |
| 334 | | /* #2 cassette motor */ |
| 335 | | m_cassette2->motor_w(BIT(data, 4)); |
| 336 | | } |
| 337 | | |
| 338 | | WRITE_LINE_MEMBER(pet_state::gb_w) |
| 339 | | { |
| 340 | | DBG_LOG(machine(), 1, "address line", ("%d\n", state)); |
| 341 | | if (state) m_font |= 1; |
| 342 | | else m_font &= ~1; |
| 343 | | } |
| 344 | | |
| 345 | | WRITE_LINE_MEMBER(pet_state::via_irq_w) |
| 346 | | { |
| 347 | | m_via_irq = state; |
| 348 | | int level = (m_pia0_irq | m_pia1_irq | m_via_irq) ? ASSERT_LINE : CLEAR_LINE; |
| 349 | | |
| 350 | | machine().firstcpu->set_input_line(INPUT_LINE_IRQ0, level); |
| 351 | | } |
| 352 | | |
| 353 | | const via6522_interface pet_via = |
| 354 | | { |
| 355 | | DEVCB_NULL, /* in_a_func */ |
| 356 | | DEVCB_DRIVER_MEMBER(pet_state,via_pb_r), /* in_b_func */ |
| 357 | | DEVCB_NULL, /* in_ca1_func */ |
| 358 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,cass2_r), /* in_cb1_func */ |
| 359 | | DEVCB_NULL, /* in_ca2_func */ |
| 360 | | DEVCB_NULL, /* in_cb2_func */ |
| 361 | | DEVCB_NULL, /* out_a_func */ |
| 362 | | DEVCB_DRIVER_MEMBER(pet_state,via_pb_w), /* out_b_func */ |
| 363 | | DEVCB_NULL, /* out_ca1_func */ |
| 364 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,gb_w), /* out_ca2_func */ |
| 365 | | DEVCB_NULL, /* out_ca2_func */ |
| 366 | | DEVCB_NULL, /* out_cb2_func */ |
| 367 | | DEVCB_DRIVER_LINE_MEMBER(pet_state,via_irq_w) /* out_irq_func */ |
| 368 | | }; |
| 369 | | |
| 370 | | |
| 371 | | static WRITE8_HANDLER( cbm8096_io_w ) |
| 372 | | { |
| 373 | | via6522_device *via_0 = space.machine().device<via6522_device>("via6522_0"); |
| 374 | | pia6821_device *pia_0 = space.machine().device<pia6821_device>("pia_0"); |
| 375 | | pia6821_device *pia_1 = space.machine().device<pia6821_device>("pia_1"); |
| 376 | | mc6845_device *mc6845 = space.machine().device<mc6845_device>("crtc"); |
| 377 | | |
| 378 | | if (offset < 0x10) ; |
| 379 | | else if (offset < 0x14) pia_0->write(space, offset & 3, data); |
| 380 | | else if (offset < 0x20) ; |
| 381 | | else if (offset < 0x24) pia_1->write(space, offset & 3, data); |
| 382 | | else if (offset < 0x40) ; |
| 383 | | else if (offset < 0x50) via_0->write(space, offset & 0xf, data); |
| 384 | | else if (offset < 0x80) ; |
| 385 | | else if (offset == 0x80) mc6845->address_w(space, 0, data); |
| 386 | | else if (offset == 0x81) mc6845->register_w(space, 0, data); |
| 387 | | } |
| 388 | | |
| 389 | | static READ8_HANDLER( cbm8096_io_r ) |
| 390 | | { |
| 391 | | via6522_device *via_0 = space.machine().device<via6522_device>("via6522_0"); |
| 392 | | pia6821_device *pia_0 = space.machine().device<pia6821_device>("pia_0"); |
| 393 | | pia6821_device *pia_1 = space.machine().device<pia6821_device>("pia_1"); |
| 394 | | mc6845_device *mc6845 = space.machine().device<mc6845_device>("crtc"); |
| 395 | | |
| 396 | | int data = 0xff; |
| 397 | | if (offset < 0x10) ; |
| 398 | | else if (offset < 0x14) data = pia_0->read(space, offset & 3); |
| 399 | | else if (offset < 0x20) ; |
| 400 | | else if (offset < 0x24) data = pia_1->read(space, offset & 3); |
| 401 | | else if (offset < 0x40) ; |
| 402 | | else if (offset < 0x50) data = via_0->read(space, offset & 0xf); |
| 403 | | else if (offset < 0x80) ; |
| 404 | | else if (offset == 0x81) data = mc6845->register_r(space, 0); |
| 405 | | return data; |
| 406 | | } |
| 407 | | |
| 408 | | static WRITE8_HANDLER( pet80_bank1_w ) |
| 409 | | { |
| 410 | | pet_state *state = space.machine().driver_data<pet_state>(); |
| 411 | | state->m_pet80_bank1_base[offset] = data; |
| 412 | | } |
| 413 | | |
| 414 | | /* |
| 415 | | 65520 8096 memory control register |
| 416 | | bit 0 1=write protect $8000-BFFF |
| 417 | | bit 1 1=write protect $C000-FFFF |
| 418 | | bit 2 $8000-BFFF bank select |
| 419 | | bit 3 $C000-FFFF bank select |
| 420 | | bit 5 1=screen peek through |
| 421 | | bit 6 1=I/O peek through |
| 422 | | bit 7 1=enable expansion memory |
| 423 | | |
| 424 | | */ |
| 425 | | WRITE8_HANDLER( cbm8096_w ) |
| 426 | | { |
| 427 | | pet_state *state = space.machine().driver_data<pet_state>(); |
| 428 | | if (data & 0x80) |
| 429 | | { |
| 430 | | if (data & 0x40) |
| 431 | | { |
| 432 | | space.install_legacy_read_handler(0xe800, 0xefff, FUNC(cbm8096_io_r)); |
| 433 | | space.install_legacy_write_handler(0xe800, 0xefff, FUNC(cbm8096_io_w)); |
| 434 | | } |
| 435 | | else |
| 436 | | { |
| 437 | | space.install_read_bank(0xe800, 0xefff, "bank7"); |
| 438 | | if (!(data & 2)) |
| 439 | | space.install_write_bank(0xe800, 0xefff, "bank7"); |
| 440 | | else |
| 441 | | space.nop_write(0xe800, 0xefff); |
| 442 | | } |
| 443 | | |
| 444 | | |
| 445 | | if ((data & 2) == 0) { |
| 446 | | space.install_write_bank(0xc000, 0xe7ff, "bank6"); |
| 447 | | space.install_write_bank(0xf000, 0xffef, "bank8"); |
| 448 | | space.install_write_bank(0xfff1, 0xffff, "bank9"); |
| 449 | | } else { |
| 450 | | space.nop_write(0xc000, 0xe7ff); |
| 451 | | space.nop_write(0xf000, 0xffef); |
| 452 | | space.nop_write(0xfff1, 0xffff); |
| 453 | | } |
| 454 | | |
| 455 | | if (data & 0x20) |
| 456 | | { |
| 457 | | state->m_pet80_bank1_base = state->m_memory + 0x8000; |
| 458 | | state->membank("bank1")->set_base(state->m_pet80_bank1_base); |
| 459 | | space.install_legacy_write_handler(0x8000, 0x8fff, FUNC(pet80_bank1_w)); |
| 460 | | } |
| 461 | | else |
| 462 | | { |
| 463 | | if (!(data & 1)) |
| 464 | | space.install_write_bank(0x8000, 0x8fff, "bank1"); |
| 465 | | else |
| 466 | | space.nop_write(0x8000, 0x8fff); |
| 467 | | } |
| 468 | | |
| 469 | | if ((data & 1) == 0 ){ |
| 470 | | space.install_write_bank(0x9000, 0x9fff, "bank2"); |
| 471 | | space.install_write_bank(0xa000, 0xafff, "bank3"); |
| 472 | | space.install_write_bank(0xb000, 0xbfff, "bank4"); |
| 473 | | } else { |
| 474 | | space.nop_write(0x9000, 0x9fff); |
| 475 | | space.nop_write(0xa000, 0xafff); |
| 476 | | space.nop_write(0xb000, 0xbfff); |
| 477 | | } |
| 478 | | |
| 479 | | if (data & 4) |
| 480 | | { |
| 481 | | if (!(data & 0x20)) |
| 482 | | { |
| 483 | | state->m_pet80_bank1_base = state->m_memory + 0x14000; |
| 484 | | state->membank("bank1")->set_base(state->m_pet80_bank1_base); |
| 485 | | } |
| 486 | | state->membank("bank2")->set_base(state->m_memory + 0x15000); |
| 487 | | state->membank("bank3")->set_base(state->m_memory + 0x16000); |
| 488 | | state->membank("bank4")->set_base(state->m_memory + 0x17000); |
| 489 | | } |
| 490 | | else |
| 491 | | { |
| 492 | | if (!(data & 0x20)) |
| 493 | | { |
| 494 | | state->m_pet80_bank1_base = state->m_memory + 0x10000; |
| 495 | | state->membank("bank1")->set_base(state->m_pet80_bank1_base); |
| 496 | | } |
| 497 | | state->membank("bank2")->set_base(state->m_memory + 0x11000); |
| 498 | | state->membank("bank3")->set_base(state->m_memory + 0x12000); |
| 499 | | state->membank("bank4")->set_base(state->m_memory + 0x13000); |
| 500 | | } |
| 501 | | |
| 502 | | if (data & 8) |
| 503 | | { |
| 504 | | if (!(data & 0x40)) |
| 505 | | { |
| 506 | | state->membank("bank7")->set_base(state->m_memory + 0x1e800); |
| 507 | | } |
| 508 | | state->membank("bank6")->set_base(state->m_memory + 0x1c000); |
| 509 | | state->membank("bank8")->set_base(state->m_memory + 0x1f000); |
| 510 | | state->membank("bank9")->set_base(state->m_memory + 0x1fff1); |
| 511 | | } |
| 512 | | else |
| 513 | | { |
| 514 | | if (!(data & 0x40)) |
| 515 | | { |
| 516 | | state->membank("bank7")->set_base(state->m_memory+ 0x1a800); |
| 517 | | } |
| 518 | | state->membank("bank6")->set_base(state->m_memory + 0x18000); |
| 519 | | state->membank("bank8")->set_base(state->m_memory + 0x1b000); |
| 520 | | state->membank("bank9")->set_base(state->m_memory + 0x1bff1); |
| 521 | | } |
| 522 | | } |
| 523 | | else |
| 524 | | { |
| 525 | | state->m_pet80_bank1_base = state->m_memory + 0x8000; |
| 526 | | state->membank("bank1")->set_base(state->m_pet80_bank1_base ); |
| 527 | | space.install_legacy_write_handler(0x8000, 0x8fff, FUNC(pet80_bank1_w)); |
| 528 | | |
| 529 | | state->membank("bank2")->set_base(state->m_memory + 0x9000); |
| 530 | | space.unmap_write(0x9000, 0x9fff); |
| 531 | | |
| 532 | | state->membank("bank3")->set_base(state->m_memory + 0xa000); |
| 533 | | space.unmap_write(0xa000, 0xafff); |
| 534 | | |
| 535 | | state->membank("bank4")->set_base(state->m_memory + 0xb000); |
| 536 | | space.unmap_write(0xb000, 0xbfff); |
| 537 | | |
| 538 | | state->membank("bank6")->set_base(state->m_memory + 0xc000); |
| 539 | | space.unmap_write(0xc000, 0xe7ff); |
| 540 | | |
| 541 | | space.install_legacy_read_handler(0xe800, 0xefff, FUNC(cbm8096_io_r)); |
| 542 | | space.install_legacy_write_handler(0xe800, 0xefff, FUNC(cbm8096_io_w)); |
| 543 | | |
| 544 | | state->membank("bank8")->set_base(state->m_memory + 0xf000); |
| 545 | | space.unmap_write(0xf000, 0xffef); |
| 546 | | |
| 547 | | state->membank("bank9")->set_base(state->m_memory + 0xfff1); |
| 548 | | space.unmap_write(0xfff1, 0xffff); |
| 549 | | } |
| 550 | | } |
| 551 | | |
| 552 | | READ8_HANDLER( superpet_r ) |
| 553 | | { |
| 554 | | return 0xff; |
| 555 | | } |
| 556 | | |
| 557 | | WRITE8_HANDLER( superpet_w ) |
| 558 | | { |
| 559 | | pet_state *state = space.machine().driver_data<pet_state>(); |
| 560 | | switch (offset) |
| 561 | | { |
| 562 | | case 0: |
| 563 | | case 1: |
| 564 | | case 2: |
| 565 | | case 3: |
| 566 | | /* 3: 1 pull down diagnostic pin on the userport |
| 567 | | 1: 1 if jumpered programable ram r/w |
| 568 | | 0: 0 if jumpered programable m6809, 1 m6502 selected */ |
| 569 | | break; |
| 570 | | |
| 571 | | case 4: |
| 572 | | case 5: |
| 573 | | state->m_spet.bank = data & 0xf; |
| 574 | | state->membank("bank1")->configure_entries(0, 16, state->m_supermemory, 0x1000); |
| 575 | | state->membank("bank1")->set_entry(state->m_spet.bank); |
| 576 | | /* 7 low writeprotects systemlatch */ |
| 577 | | break; |
| 578 | | |
| 579 | | case 6: |
| 580 | | case 7: |
| 581 | | state->m_spet.rom = data & 1; |
| 582 | | break; |
| 583 | | } |
| 584 | | } |
| 585 | | |
| 586 | | TIMER_CALLBACK_MEMBER(pet_state::pet_interrupt) |
| 587 | | { |
| 588 | | pia6821_device *pia_0 = machine().device<pia6821_device>("pia_0"); |
| 589 | | |
| 590 | | pia_0->cb1_w(m_pia_level); |
| 591 | | m_pia_level = !m_pia_level; |
| 592 | | } |
| 593 | | |
| 594 | | |
| 595 | | static void pet_common_driver_init( running_machine &machine ) |
| 596 | | { |
| 597 | | int i; |
| 598 | | pet_state *state = machine.driver_data<pet_state>(); |
| 599 | | |
| 600 | | state->m_font = 0; |
| 601 | | |
| 602 | | state->m_pet_basic1 = 0; |
| 603 | | state->m_superpet = 0; |
| 604 | | state->m_cbm8096 = 0; |
| 605 | | |
| 606 | | machine.device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_bank(0x0000, machine.device<ram_device>(RAM_TAG)->size() - 1, "bank10"); |
| 607 | | state->membank("bank10")->set_base(state->m_memory); |
| 608 | | |
| 609 | | if (machine.device<ram_device>(RAM_TAG)->size() < 0x8000) |
| 610 | | { |
| 611 | | machine.device("maincpu")->memory().space(AS_PROGRAM).nop_readwrite(machine.device<ram_device>(RAM_TAG)->size(), 0x7FFF); |
| 612 | | } |
| 613 | | |
| 614 | | /* 2114 poweron ? 64 x 0xff, 64x 0, and so on */ |
| 615 | | for (i = 0; i < machine.device<ram_device>(RAM_TAG)->size(); i += 0x40) |
| 616 | | { |
| 617 | | memset (state->m_memory + i, i & 0x40 ? 0 : 0xff, 0x40); |
| 618 | | } |
| 619 | | |
| 620 | | /* pet clock */ |
| 621 | | machine.scheduler().timer_pulse(attotime::from_msec(10), timer_expired_delegate(FUNC(pet_state::pet_interrupt),state)); |
| 622 | | } |
| 623 | | |
| 624 | | |
| 625 | | DRIVER_INIT_MEMBER(pet_state,pet2001) |
| 626 | | { |
| 627 | | m_memory.set_target(machine().device<ram_device>(RAM_TAG)->pointer(),m_memory.bytes()); |
| 628 | | pet_common_driver_init(machine()); |
| 629 | | m_pet_basic1 = 1; |
| 630 | | pet_vh_init(machine()); |
| 631 | | } |
| 632 | | |
| 633 | | DRIVER_INIT_MEMBER(pet_state,pet) |
| 634 | | { |
| 635 | | m_memory.set_target(machine().device<ram_device>(RAM_TAG)->pointer(),m_memory.bytes()); |
| 636 | | pet_common_driver_init(machine()); |
| 637 | | pet_vh_init(machine()); |
| 638 | | } |
| 639 | | |
| 640 | | DRIVER_INIT_MEMBER(pet_state,pet80) |
| 641 | | { |
| 642 | | m_memory.set_target(memregion("maincpu")->base(),m_memory.bytes()); |
| 643 | | |
| 644 | | pet_common_driver_init(machine()); |
| 645 | | m_cbm8096 = 1; |
| 646 | | m_videoram.set_target(&m_memory[0x8000],m_videoram.bytes()); |
| 647 | | pet80_vh_init(machine()); |
| 648 | | |
| 649 | | } |
| 650 | | |
| 651 | | DRIVER_INIT_MEMBER(pet_state,superpet) |
| 652 | | { |
| 653 | | m_memory.set_target(machine().device<ram_device>(RAM_TAG)->pointer(),m_memory.bytes()); |
| 654 | | pet_common_driver_init(machine()); |
| 655 | | m_superpet = 1; |
| 656 | | |
| 657 | | m_supermemory = auto_alloc_array(machine(), UINT8, 0x10000); |
| 658 | | |
| 659 | | membank("bank1")->configure_entries(0, 16, m_supermemory, 0x1000); |
| 660 | | membank("bank1")->set_entry(0); |
| 661 | | |
| 662 | | superpet_vh_init(machine()); |
| 663 | | } |
| 664 | | |
| 665 | | void pet_state::machine_reset() |
| 666 | | { |
| 667 | | if (m_superpet) |
| 668 | | { |
| 669 | | m_spet.rom = 0; |
| 670 | | if (machine().root_device().ioport("CFG")->read() & 0x04) |
| 671 | | { |
| 672 | | machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, 1); |
| 673 | | machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, 0); |
| 674 | | m_font = 2; |
| 675 | | } |
| 676 | | else |
| 677 | | { |
| 678 | | machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, 0); |
| 679 | | machine().device("maincpu")->execute().set_input_line(INPUT_LINE_HALT, 1); |
| 680 | | m_font = 0; |
| 681 | | } |
| 682 | | } |
| 683 | | |
| 684 | | if (m_cbm8096) |
| 685 | | { |
| 686 | | if (machine().root_device().ioport("CFG")->read() & 0x08) |
| 687 | | { |
| 688 | | machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_write_handler(0xfff0, 0xfff0, FUNC(cbm8096_w)); |
| 689 | | } |
| 690 | | else |
| 691 | | { |
| 692 | | machine().device("maincpu")->memory().space(AS_PROGRAM).nop_write(0xfff0, 0xfff0); |
| 693 | | } |
| 694 | | cbm8096_w(machine().device("maincpu")->memory().space(AS_PROGRAM), 0, 0); |
| 695 | | } |
| 696 | | |
| 697 | | //removed cbm_drive_0_config (machine().root_device().ioport("CFG")->read() & 2 ? IEEE : 0, 8); |
| 698 | | //removed cbm_drive_1_config (machine().root_device().ioport("CFG")->read() & 1 ? IEEE : 0, 9); |
| 699 | | machine().device("maincpu")->reset(); |
| 700 | | |
| 701 | | m_ieee->ren_w(0); |
| 702 | | m_ieee->ifc_w(0); |
| 703 | | m_ieee->ifc_w(1); |
| 704 | | } |
| 705 | | |
| 706 | | |
| 707 | | INTERRUPT_GEN_MEMBER(pet_state::pet_frame_interrupt) |
| 708 | | { |
| 709 | | if (m_superpet) |
| 710 | | { |
| 711 | | if (ioport("CFG")->read() & 0x04) |
| 712 | | { |
| 713 | | device.execute().set_input_line(INPUT_LINE_HALT, 1); |
| 714 | | device.execute().set_input_line(INPUT_LINE_HALT, 0); |
| 715 | | m_font |= 2; |
| 716 | | } |
| 717 | | else |
| 718 | | { |
| 719 | | device.execute().set_input_line(INPUT_LINE_HALT, 0); |
| 720 | | device.execute().set_input_line(INPUT_LINE_HALT, 1); |
| 721 | | m_font &= ~2; |
| 722 | | } |
| 723 | | } |
| 724 | | |
| 725 | | set_led_status (machine(),1, machine().root_device().ioport("SPECIAL")->read() & 0x80 ? 1 : 0); /* Shift Lock */ |
| 726 | | } |
| 727 | | |
| 728 | | |
| 729 | | /*********************************************** |
| 730 | | |
| 731 | | PET Cartridges |
| 732 | | |
| 733 | | ***********************************************/ |
| 734 | | |
| 735 | | static DEVICE_IMAGE_LOAD(pet_cart) |
| 736 | | { |
| 737 | | pet_state *state = image.device().machine().driver_data<pet_state>(); |
| 738 | | UINT32 size = image.length(); |
| 739 | | const char *filetype = image.filetype(); |
| 740 | | int address = 0; |
| 741 | | |
| 742 | | /* Assign loading address according to extension */ |
| 743 | | if (!mame_stricmp(filetype, "90")) |
| 744 | | address = 0x9000; |
| 745 | | else if (!mame_stricmp(filetype, "a0")) |
| 746 | | address = 0xa000; |
| 747 | | else if (!mame_stricmp(filetype, "b0")) |
| 748 | | address = 0xb000; |
| 749 | | |
| 750 | | logerror("Loading cart %s at %.4x size:%.4x\n", image.filename(), address, size); |
| 751 | | |
| 752 | | image.fread(state->m_memory + address, size); |
| 753 | | |
| 754 | | return IMAGE_INIT_PASS; |
| 755 | | } |
| 756 | | |
| 757 | | MACHINE_CONFIG_FRAGMENT(pet_cartslot) |
| 758 | | MCFG_CARTSLOT_ADD("cart1") |
| 759 | | MCFG_CARTSLOT_EXTENSION_LIST("90,a0,b0") |
| 760 | | MCFG_CARTSLOT_NOT_MANDATORY |
| 761 | | MCFG_CARTSLOT_LOAD(pet_cart) |
| 762 | | |
| 763 | | MCFG_CARTSLOT_ADD("cart2") |
| 764 | | MCFG_CARTSLOT_EXTENSION_LIST("90,a0,b0") |
| 765 | | MCFG_CARTSLOT_NOT_MANDATORY |
| 766 | | MCFG_CARTSLOT_LOAD(pet_cart) |
| 767 | | MACHINE_CONFIG_END |
| 768 | | |
| 769 | | // 2010-08, FP: this is used by CBM40 & CBM80, and I actually have only found .prg files for these... does cart dumps exist? |
| 770 | | MACHINE_CONFIG_FRAGMENT(pet4_cartslot) |
| 771 | | MCFG_CARTSLOT_MODIFY("cart1") |
| 772 | | MCFG_CARTSLOT_EXTENSION_LIST("a0") |
| 773 | | MCFG_CARTSLOT_NOT_MANDATORY |
| 774 | | MCFG_CARTSLOT_LOAD(pet_cart) |
| 775 | | |
| 776 | | MCFG_CARTSLOT_MODIFY("cart2") |
| 777 | | MCFG_CARTSLOT_EXTENSION_LIST("a0") |
| 778 | | MCFG_CARTSLOT_NOT_MANDATORY |
| 779 | | MCFG_CARTSLOT_LOAD(pet_cart) |
| 780 | | MACHINE_CONFIG_END |
trunk/src/mess/drivers/pet.c
| r21304 | r21305 | |
| 1 | | /*************************************************************************** |
| 2 | | commodore pet series computer |
| 3 | | |
| 4 | | PeT mess@utanet.at |
| 5 | | |
| 6 | | documentation |
| 7 | | vice emulator |
| 8 | | www.funet.fi |
| 9 | | andre fachat (vice emulator, docu, web site, excellent keyboard pictures) |
| 10 | | |
| 11 | | ***************************************************************************/ |
| 12 | | |
| 13 | | /* |
| 14 | | |
| 15 | | 2008 - Driver Updates |
| 16 | | --------------------- |
| 17 | | |
| 18 | | (most of the informations are taken from http://www.zimmers.net/cbmpics/ ) |
| 19 | | (also, check |
| 20 | | http://www.6502.org/users/andre/petindex/local/cbm-model-list.1.0.txt |
| 21 | | for a more comprehensive list of models) |
| 22 | | |
| 23 | | [CBM systems which belong to this driver] |
| 24 | | |
| 25 | | * Commodore PET 2001 (1977) - board design 1 |
| 26 | | * PET 2001 Series / CBM 20XX Series (1979) - board design 2, upgraded ROMs |
| 27 | | |
| 28 | | PET 2001, the first of the series came initially with a calculator style |
| 29 | | keyboard, later changed to a larger and better full-stroke one (actually |
| 30 | | it was available in two versions: Businness and Home Computer, the latter |
| 31 | | also containing graphics on the keys). Plenty of models were released in |
| 32 | | this series, depending on the RAM size, the keyboard type and the screen |
| 33 | | dimension (see below). |
| 34 | | |
| 35 | | CPU: MOS 6502 (1 MHz) |
| 36 | | RAM: 4K and 8K early models (Expandable to 32k addressable, more banked); |
| 37 | | 8K, 16K, 32K later models (Expandable again to larger RAM config) |
| 38 | | ROM: 18 kilobytes early models; 20 kilobytes later ones |
| 39 | | Video: MOS Technology 6545 CRTC (9" Monochrome display; 40 columns x 25 |
| 40 | | rows ) |
| 41 | | Sound: None ine arlier models; Piezo electronic speaker later ones(One |
| 42 | | square wave voice; Three octaves) |
| 43 | | Ports: MOS 6520 PIA, MOS 6522 VIA (IEEE-488 edge-connector Port; 2 |
| 44 | | Commodore Datasette ports; 'EXPANSION' port; CBM parallel |
| 45 | | programmable "User" port |
| 46 | | Keyboard: "Calculator" 69 key QWERTY in early models and Full 69 keys QWERTY |
| 47 | | in later ones (16 key numeric keypad!; 4 direction 2-key cursor-pad ) |
| 48 | | Additional hardware: Datasette |
| 49 | | |
| 50 | | Model Table (*): |
| 51 | | |
| 52 | | PET 2001-4K Calculator Keyboard, Black Trim |
| 53 | | PET 2001-8K Calculator Keyboard, Blue Trim, 9" Screen |
| 54 | | PET 2001-8C Calculator Keyboard, Blue Trim, 9" Screen B&W (**) |
| 55 | | PET 2001B-8 Business Keyboard, 12" Screen |
| 56 | | PET 2001B-16 Business Keyboard, 12" Screen |
| 57 | | PET 2001B-32 Business Keyboard, 12" Screen (***) |
| 58 | | PET 2001N-8 Home Computer Keyboard, 12" Screen |
| 59 | | PET 2001N-16 Home Computer Keyboard, 9" and 12" Screen |
| 60 | | PET 2001N-32 Home Computer Keyboard, BASIC 4.0 |
| 61 | | |
| 62 | | Notes: B&W = Black and White Screen |
| 63 | | G&W = Green and White Screen |
| 64 | | Calculator Keyboard models also had a built-in datasette |
| 65 | | Home Computer Keyboard also features graphics on keys |
| 66 | | |
| 67 | | (*) Models 2001B-XX & 2001-XXB are the same. Same applies to 2001N-XX & |
| 68 | | 2001-XXN |
| 69 | | (**) Also confirmed with Black Trim and 9" Screen G&W |
| 70 | | (***) Also confirmed with Black Trim and 9" Screen B&W |
| 71 | | |
| 72 | | |
| 73 | | * Commodore CBM 3008 / 3016 / 3032 (1979) - board design 2, upgraded ROMs |
| 74 | | |
| 75 | | In Europe, Philips was already selling a machine called PET, so they |
| 76 | | forced Commodore to change name. The result was the CBM 30XX Series, where |
| 77 | | XX is equal to the RAM size. These were basically PET models with 9" Screen |
| 78 | | and upgraded ROMs. There also existed a German CBM 3001, which was a PET |
| 79 | | 2001, B or N. Notice that these systems used to boot |
| 80 | | |
| 81 | | CPU: MOS 6502 (1MHz) |
| 82 | | RAM: 8K, 16k, and 32k models (Expandable to even more banked memory) |
| 83 | | ROM: 20 Kilobytes |
| 84 | | Video: MOS Technology 6545 CRTC (9" Monochrome display; 40 columns x 25 rows) |
| 85 | | Sound: Piezo electronic speaker (One square wave voice; Three octaves) |
| 86 | | Ports: MOS 6520 PIA, MOS 6522 VIA (IEEE-488 edge-connector Port; 2 Commodore |
| 87 | | Datasette ports; 'EXPANSION' port; CBM parallel programmable "User" port) |
| 88 | | Keyboard: Full 69 key QWERTY (16 key numeric keypad!; 4 direction 2-key cursor-pad) |
| 89 | | |
| 90 | | |
| 91 | | * Commodore PET 40XX / CBM 40XX (1980) - board design 2, BASIC 4, 9" Screen |
| 92 | | * Commodore PET 40XX / CBM 40XX (1981) - board design 3, BASIC 4, 12" Screen |
| 93 | | |
| 94 | | While the 40XX machines (again 4008, 4016, 4032) coming with design 2 were |
| 95 | | quite similar to the previous ones (except for the new BASIC version), the |
| 96 | | machines with design 3 were quite different: there was CRTC support, it was |
| 97 | | possible to upgrade to 80 cols and a piezo beeper. |
| 98 | | |
| 99 | | CPU: MOS 6502 (1 MHz) |
| 100 | | RAM: 8K, 16k, and 32k models (Expandable to even more banked memory) |
| 101 | | ROM: 20 Kilobytes |
| 102 | | Video: MOS Technology 6545 CRTC (9" and 12" Monochrome displays; 40 |
| 103 | | columns x 25 rows) |
| 104 | | Sound: Piezo electronic speaker (One square wave voice; Three octaves) |
| 105 | | Ports: MOS 6520 PIA, MOS 6522 VIA (IEEE-488 edge-connector Port; 2 Commodore |
| 106 | | Datasette ports; 'EXPANSION' port; CBM parallel programmable "User" port) |
| 107 | | Keyboard: Full 69 key QWERTY (16 key numeric keypad!; 4 direction 2-key cursor-pad) |
| 108 | | |
| 109 | | |
| 110 | | * Commodore PET 8032 / CBM 8032 (1981) - board design 3, BASIC 4, 12" Screen |
| 111 | | |
| 112 | | Again, 80 columns screen and piezo beeper; BASIC 4 has a 80 columns editor |
| 113 | | ROM. It was possible to expand it to a 8096. |
| 114 | | |
| 115 | | CPU: MOS 6502 (1 MHz) |
| 116 | | RAM: 32k standard (Expandable to even more banked memory) |
| 117 | | ROM: 20 Kilobytes |
| 118 | | Video: MOS Technology 6545 CRTC (12" Monochrome displays; 80 columns x 25 rows) |
| 119 | | Sound: Piezo electronic speaker (One square wave voice; Three octaves) |
| 120 | | Ports: MOS 6520 PIA, MOS 6522 VIA (IEEE-488 edge-connector Port; 2 Commodore |
| 121 | | Datasette ports; 'EXPANSION' port; CBM parallel programmable "User" port) |
| 122 | | Keyboard: Full 73 key QWERTY (11 key numeric keypad!; 4 direction 2-key cursor-pad) |
| 123 | | |
| 124 | | |
| 125 | | * Commodore PET 8032-SK / CBM 8032-SK - board design 3 & 4, BASIC 4, 12" Screen |
| 126 | | |
| 127 | | New (smaller) case with detachable keyboard (SK=Separate Keyboard). Board |
| 128 | | with design 3 didn't fit very well the new case and required extra cables. |
| 129 | | It was possible to expand it to a 8096-SK. |
| 130 | | |
| 131 | | CPU: MOS 6502 (1 MHz) |
| 132 | | RAM: 32k standard (8096 expanded to 96k, 64k is banked memory) |
| 133 | | ROM: 20 Kilobytes |
| 134 | | Video: MOS Technology 6545 CRTC (12" Monochrome display; 80 columns x 25 rows) |
| 135 | | Sound: Piezo electronic speaker (One square wave voice; Three octaves) |
| 136 | | Ports: MOS 6520 PIA, MOS 6522 VIA (IEEE-488 square-connector Port; 2 Commodore |
| 137 | | Datasette ports; 'EXPANSION' port; CBM parallel programmable "User" port) |
| 138 | | Keyboard: Full 73 key QWERTY (11 key numeric keypad!; 4 direction 2-key cursor-pad) |
| 139 | | |
| 140 | | |
| 141 | | * Commodore CBM 200 Series (198?) |
| 142 | | |
| 143 | | Rebadged CMB 80XX models: the CBM 200 was basically a CBM 8032-SK and the |
| 144 | | CBM 220 was a CBM 8096-SK. |
| 145 | | |
| 146 | | |
| 147 | | * Commodore Super PET / MMF9000 (1981) - BASIC 4, 12" Screen |
| 148 | | |
| 149 | | Based on PET 8032. Sold in Germany as MMF (MicroMainFrame) 9000. Machines |
| 150 | | sold in Italy had 134kB of RAM. |
| 151 | | |
| 152 | | CPU: MOS Technology 6502 & 6809 (1 MHz clock speeds) |
| 153 | | RAM: 96 kilobytes (64K was contained on an expansion board above the motherboard; |
| 154 | | Early SP9000 models had two boards above the motherboard; Some models also |
| 155 | | had 3 or more switches) |
| 156 | | ROM: 48 kilobytes |
| 157 | | Video: MOS Technology 6545 CRTC (12" Monochrome display; 80 columns x 25 rows; |
| 158 | | 3+ character sets, 256 characters each) |
| 159 | | Sound: Piezo electronic speaker (One square wave voice; Three octaves) |
| 160 | | Ports: 6551 ACIA, MOS 6520 PIA, MOS 6522 VIA (IEEE-488 edge-connector Port; 2 |
| 161 | | Commodore Datasette ports; 'EXPANSION' port; RS232 Internal port; CBM |
| 162 | | parallel programmable "User" port; Memory and Processor selection switches) |
| 163 | | Keyboard: Full-sized 73 key QWERTY (Multi-Font 62 key keyboard; APL Symbols on |
| 164 | | the front of the keys; 11 key numeric keypad; Editor functions on the front |
| 165 | | of the keys; 2-key 4-direction cursor-pad) |
| 166 | | |
| 167 | | |
| 168 | | * Commodore CBM SP9000 |
| 169 | | |
| 170 | | Similar to Super PET. Dual uP 6502/6809, 96kB RAM, business keyboard. |
| 171 | | |
| 172 | | |
| 173 | | * Commodore PET 8296 / CBM 8296 (1984) - BASIC 4, 12" Screen |
| 174 | | |
| 175 | | Shipped with 128k RAM and separate keyboard, it is a complete redesign of the |
| 176 | | PET universal board. It fits into the separate keyboard case, and directly holds |
| 177 | | 128k RAM, of which 96k can be used as in the 8096. In addition, using "user |
| 178 | | jumpers" on the motherboard, the ROM can be completely switched off to access |
| 179 | | the RAM "under the ROM", so that the complete 128k RAM are accessible. The "user |
| 180 | | jumpers" could be set to connect to the userport, so this could even be done |
| 181 | | under program control. |
| 182 | | |
| 183 | | CPU: MOS 6502 (1 MHz) |
| 184 | | RAM: 160K (32k standard) |
| 185 | | ROM: 24 Kilobytes |
| 186 | | Video: MOS Technology 6545 CRTC (12" Monochrome displays; 80 columns x 25 rows) |
| 187 | | Sound: Piezo electronic speaker (One square wave voice; Three octaves) |
| 188 | | Ports: MOS 6520 PIA, MOS 6522 VIA (IEEE-488 Port; Commodore Datasette port; |
| 189 | | 'EXPANSION' port; CBM parallel programmable "User" port) |
| 190 | | Keyboard: Full 73 key QWERTY (11 key numeric keypad!; 4 direction 2-key cursor-pad) |
| 191 | | |
| 192 | | see http://www.6502.org/users/andre/petindex/8x96.html and |
| 193 | | http://www.sothius.com/hypertxt/welcome.html?./additional/cbm8296addition.html for |
| 194 | | more informations |
| 195 | | |
| 196 | | |
| 197 | | * Commodore PET 8296D / CBM 8296D (1984) - BASIC 4, 12" Screen |
| 198 | | |
| 199 | | It was a 8296 with built-in 8250-LP disk drive. |
| 200 | | |
| 201 | | * Commodore CBM 8296GD |
| 202 | | |
| 203 | | Mentioned at http://www.commodore.ca/products/pet/commodore_pet.htm#Commodore%20PET%20Chronology |
| 204 | | as a 8296 with a high resolution graphics board and drive. No other info available. |
| 205 | | |
| 206 | | [Other models] |
| 207 | | |
| 208 | | |
| 209 | | * Teacher's PET Simply a PET 2001-N with a different label, due to a |
| 210 | | marketing campaign in US schools |
| 211 | | * MDS 6500 Modified 2001N-32 with matching 2040 drive. 500 made. |
| 212 | | * "CASSIE" Synergistics Inc. rebadged 8032 |
| 213 | | |
| 214 | | |
| 215 | | [Board Designs] |
| 216 | | |
| 217 | | All these models can be reduced to four board types (source William Levak's |
| 218 | | doc, layouts from PETFAQ): |
| 219 | | |
| 220 | | Static Board (PET 2001) |
| 221 | | ----------------------- |
| 222 | | |
| 223 | | Four variations based on type of RAM(6550 or 2114) and ROM(6540 or 2316B). |
| 224 | | 4K or 8K static RAM (selected by jumper). |
| 225 | | 40 column display |
| 226 | | A video interrupt interferes with disk drive operation. |
| 227 | | Display timing not compatible with Basic 4.0. |
| 228 | | ROM sockets: A2 2K character ROM sockets: A2 2K character |
| 229 | | (2316B) H1 C000-CFFF (6540) H1 C000-C7FF |
| 230 | | H2 D000-DFFF H2 D000-D7FF |
| 231 | | H3 E000-E7FF H3 E000-E7FF |
| 232 | | H4 F000-FFFF H4 F000-F7FF |
| 233 | | H5 C000-CFFF H5 C800-CFFF |
| 234 | | H6 D000-DFFF H6 D800-DFFF |
| 235 | | H7 F000-FFFF H7 F800-FFFF |
| 236 | | |
| 237 | | |
| 238 | | IEEE user tape #2 |
| 239 | | +------####-####--##-+ |
| 240 | | ! # |
| 241 | | ! # |
| 242 | | ! # exp |
| 243 | | ! # bus |
| 244 | | ! # |
| 245 | | ! # 2000 Series |
| 246 | | ! ! circa 1977/78 Max RAM - 8k |
| 247 | | ! (2k) ROMS ! [w/daughter board exp to 32k shown] |
| 248 | | ! F F E D D C C ! |
| 249 | | ! 8 0 0 8 0 8 0 ! |
| 250 | | ! ! |
| 251 | | tape # RAM MEMORY ! |
| 252 | | #1 # ! |
| 253 | | +--------------------+ |
| 254 | | |
| 255 | | |
| 256 | | Dynamic Board (PET/CBM 2001-N/2001-B/4000) |
| 257 | | ------------------------------------------ |
| 258 | | |
| 259 | | 4K, 8K, 16K or 32K dynamic RAM (selected by jumper). |
| 260 | | 40 column display |
| 261 | | Can run all versions of 40 column Basic (Basic 1 must be copied to 4K ROMs) |
| 262 | | Can be jumpered to replace the older board. |
| 263 | | ROM sockets: UD3 9000-9FFF |
| 264 | | UD4 A000-AFFF |
| 265 | | UD5 B000-BFFF |
| 266 | | UD6 C000-CFFF |
| 267 | | UD7 D000-DFFF |
| 268 | | UD8 E000-E7FF |
| 269 | | UD9 F000-FFFF |
| 270 | | UF10 2K character |
| 271 | | |
| 272 | | |
| 273 | | IEEE user tape #1 |
| 274 | | +------####-####--##-+ |
| 275 | | ! #! |
| 276 | | ! #! |
| 277 | | ! #! exp |
| 278 | | ! ROMS #! bus |
| 279 | | ! F E D C B A 9 #! |
| 280 | | ! #! 3000, 4000 Series |
| 281 | | ! ! (3000 series is European version) |
| 282 | | ! ! circa 1979/80 Max RAM - 32k |
| 283 | | ! ! |
| 284 | | ! ! |
| 285 | | ! ! |
| 286 | | tape # RAM MEMORY ! |
| 287 | | #2 # ! |
| 288 | | +--------------------+ |
| 289 | | |
| 290 | | |
| 291 | | 80 Column Board (CBM 8000) |
| 292 | | -------------------------- |
| 293 | | |
| 294 | | 16K or 32K RAM (selected by jumper). |
| 295 | | Uses CTRC to generate 80 column display. |
| 296 | | Can only run the 80 column version of Basic 4.0. |
| 297 | | Not compatible with older boards. |
| 298 | | ROM sockets: UA3 2K or 4K character |
| 299 | | UD6 F000-FFFF |
| 300 | | UD7 E000-E7FF |
| 301 | | UD8 D000-DFFF |
| 302 | | UD9 C000-CFFF |
| 303 | | UD10 B000-BFFF |
| 304 | | UD11 A000-AFFF |
| 305 | | UD12 9000-9FFF |
| 306 | | |
| 307 | | The layout is the same of the one used in Universal Boards below. |
| 308 | | |
| 309 | | |
| 310 | | Universal Board (CBM 8000/PET 4000-12) |
| 311 | | -------------------------------------- |
| 312 | | |
| 313 | | This is an 80 column board with jumpers for different configurations. |
| 314 | | 16K or 32K RAM (selected by jumper). |
| 315 | | Uses CTRC to generate 40 or 80 column display (selected by jumpers). |
| 316 | | Can only run Basic 4.0 versions that support the CRTC. |
| 317 | | Can be jumpered to replace all older boards. |
| 318 | | ROM sockets: UA3 2K or 4K character |
| 319 | | UD6 F000-FFFF |
| 320 | | UD7 E000-E7FF |
| 321 | | UD8 D000-DFFF |
| 322 | | UD9 C000-CFFF |
| 323 | | UD10 B000-BFFF |
| 324 | | UD11 A000-AFFF |
| 325 | | UD12 9000-9FFF |
| 326 | | |
| 327 | | |
| 328 | | IEEE user tape #1 |
| 329 | | +------####-####--##-+ |
| 330 | | ! # # tape |
| 331 | | ! # # #2 |
| 332 | | ! R exp bus # ! |
| 333 | | ! A #! |
| 334 | | ! M 9 #! |
| 335 | | ! A #! 4000, 8000 Series |
| 336 | | ! M R B ! circa 1981 Max RAM - 32k* |
| 337 | | ! E O C ! [8296 layout not shown] |
| 338 | | ! M M D ! |
| 339 | | ! O S E ! |
| 340 | | ! R F ! |
| 341 | | ! Y ! |
| 342 | | ! spkr! |
| 343 | | +--------------------+ |
| 344 | | |
| 345 | | |
| 346 | | [TO DO] |
| 347 | | |
| 348 | | * Verify if pre-CRTC models had differences between NTSC & PAL systems. |
| 349 | | If no differences arise we can merge back the following sets: |
| 350 | | + cbm30 (same as pet2001n) & cbm30b (same as pet2001b) |
| 351 | | + cbm40o (same as pet40on) & cbm40ob (same as pet40ob) |
| 352 | | |
| 353 | | * Emulate SuperPET / SP9000 / MMF9000 and their differences |
| 354 | | |
| 355 | | * Emulate CBM 8296 & 8296D (basically only a placeholder now) |
| 356 | | |
| 357 | | * Add proper tape support |
| 358 | | |
| 359 | | * Add sound support, for systems which had it |
| 360 | | |
| 361 | | * Find out answers to the following details: |
| 362 | | |
| 363 | | + Did BASIC 2 also come as upgrade ROMs for PET 2001 with Static Board? If |
| 364 | | this is the case, we need to support the splitted versions of the ROMs as |
| 365 | | an alternative BIOS to pet2001. |
| 366 | | + Did final PET 40XX & CBM 40XX with 40 Columns & CRTC support had business or |
| 367 | | normal keyboards? |
| 368 | | |
| 369 | | * Find confirmation about some models (which I don't believe ever existed, |
| 370 | | but...): |
| 371 | | |
| 372 | | + were there PET 2001-16k & PET 2001-32k with Calculator type keyboard? |
| 373 | | + were there CBM 20XX in Europe? |
| 374 | | + what about the following unrealistic RAM configurations: 4004? 8008? 8016? |
| 375 | | 8064? |
| 376 | | + did a CBM 210 exist? |
| 377 | | |
| 378 | | */ |
| 379 | | |
| 380 | | |
| 381 | | #include "emu.h" |
| 382 | | #include "cpu/m6809/m6809.h" |
| 383 | | #include "cpu/m6502/m6502.h" |
| 384 | | |
| 385 | | #include "machine/6821pia.h" |
| 386 | | #include "machine/6522via.h" |
| 387 | | #include "includes/pet.h" |
| 388 | | #include "machine/cbmipt.h" |
| 389 | | #include "video/mc6845.h" |
| 390 | | #include "machine/ram.h" |
| 391 | | |
| 392 | | /* devices config */ |
| 393 | | #include "includes/cbm.h" |
| 394 | | #include "formats/cbm_snqk.h" |
| 395 | | #include "machine/ieee488.h" |
| 396 | | |
| 397 | | /************************************* |
| 398 | | * |
| 399 | | * Main CPU memory handlers |
| 400 | | * |
| 401 | | *************************************/ |
| 402 | | |
| 403 | | static ADDRESS_MAP_START(pet_mem , AS_PROGRAM, 8, pet_state ) |
| 404 | | AM_RANGE(0x8000, 0x83ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("videoram") |
| 405 | | AM_RANGE(0xa000, 0xe7ff) AM_ROM |
| 406 | | AM_RANGE(0xe810, 0xe813) AM_DEVREADWRITE("pia_0", pia6821_device, read, write) |
| 407 | | AM_RANGE(0xe820, 0xe823) AM_DEVREADWRITE("pia_1", pia6821_device, read, write) |
| 408 | | AM_RANGE(0xe840, 0xe84f) AM_DEVREADWRITE("via6522_0", via6522_device, read, write) |
| 409 | | /* AM_RANGE(0xe900, 0xe91f) AM_DEVREAD_LEGACY("ieee_bus", cbm_ieee_state) // for debugging */ |
| 410 | | AM_RANGE(0xf000, 0xffff) AM_ROM |
| 411 | | ADDRESS_MAP_END |
| 412 | | |
| 413 | | static ADDRESS_MAP_START( pet40_mem , AS_PROGRAM, 8, pet_state ) |
| 414 | | AM_RANGE(0x8000, 0x83ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("videoram") |
| 415 | | AM_RANGE(0xa000, 0xe7ff) AM_ROM |
| 416 | | AM_RANGE(0xe810, 0xe813) AM_DEVREADWRITE("pia_0", pia6821_device, read, write) |
| 417 | | AM_RANGE(0xe820, 0xe823) AM_DEVREADWRITE("pia_1", pia6821_device, read, write) |
| 418 | | AM_RANGE(0xe840, 0xe84f) AM_DEVREADWRITE("via6522_0", via6522_device, read, write) |
| 419 | | AM_RANGE(0xe880, 0xe880) AM_DEVWRITE("crtc", mc6845_device, address_w) |
| 420 | | AM_RANGE(0xe881, 0xe881) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w) |
| 421 | | AM_RANGE(0xf000, 0xffff) AM_ROM |
| 422 | | ADDRESS_MAP_END |
| 423 | | |
| 424 | | static ADDRESS_MAP_START( pet80_mem , AS_PROGRAM, 8, pet_state ) |
| 425 | | AM_RANGE(0x8000, 0x8fff) AM_RAMBANK("bank1") |
| 426 | | AM_RANGE(0x9000, 0x9fff) AM_RAMBANK("bank2") |
| 427 | | AM_RANGE(0xa000, 0xafff) AM_RAMBANK("bank3") |
| 428 | | AM_RANGE(0xb000, 0xbfff) AM_RAMBANK("bank4") |
| 429 | | AM_RANGE(0xc000, 0xe7ff) AM_RAMBANK("bank6") |
| 430 | | #if 1 |
| 431 | | AM_RANGE(0xe800, 0xefff) AM_RAMBANK("bank7") |
| 432 | | #else |
| 433 | | AM_RANGE(0xe810, 0xe813) AM_DEVREADWRITE_LEGACY("pia_0", pia6821_r, pia6821_w) |
| 434 | | AM_RANGE(0xe820, 0xe823) AM_DEVREADWRITE_LEGACY("pia_1", pia6821_r, pia6821_w) |
| 435 | | AM_RANGE(0xe840, 0xe84f) AM_DEVREADWRITE("via6522_0", via6522_device, read, write) |
| 436 | | AM_RANGE(0xe880, 0xe880) AM_DEVWRITE("crtc", mc6845_device, address_w) |
| 437 | | AM_RANGE(0xe881, 0xe881) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w) |
| 438 | | #endif |
| 439 | | AM_RANGE(0xf000, 0xffff) AM_READ_BANK("bank8") |
| 440 | | AM_RANGE(0xf000, 0xffef) AM_WRITE_BANK("bank8") |
| 441 | | AM_RANGE(0xfff1, 0xffff) AM_WRITE_BANK("bank9") |
| 442 | | ADDRESS_MAP_END |
| 443 | | |
| 444 | | |
| 445 | | /* 0xe880 crtc |
| 446 | | 0xefe0 6702 encoder |
| 447 | | 0xeff0 acia6551 |
| 448 | | |
| 449 | | 0xeff8 super pet system latch |
| 450 | | 61432 SuperPET system latch |
| 451 | | bit 0 1=6502, 0=6809 |
| 452 | | bit 1 0=read only |
| 453 | | bit 3 diagnostic sense: set to 1 to switch to 6502 |
| 454 | | |
| 455 | | 61436 SuperPET bank select latch |
| 456 | | bit 0-3 bank |
| 457 | | bit 7 1=enable system latch |
| 458 | | |
| 459 | | */ |
| 460 | | static ADDRESS_MAP_START( superpet_mem , AS_PROGRAM, 8, pet_state ) |
| 461 | | AM_RANGE(0x0000, 0x7fff) AM_RAM AM_SHARE("memory") |
| 462 | | AM_RANGE(0x8000, 0x87ff) AM_RAM AM_SHARE("videoram") |
| 463 | | AM_RANGE(0xa000, 0xe7ff) AM_ROM |
| 464 | | AM_RANGE(0xe810, 0xe813) AM_DEVREADWRITE("pia_0", pia6821_device, read, write) |
| 465 | | AM_RANGE(0xe820, 0xe823) AM_DEVREADWRITE("pia_1", pia6821_device, read, write) |
| 466 | | AM_RANGE(0xe840, 0xe84f) AM_DEVREADWRITE("via6522_0", via6522_device, read, write) |
| 467 | | AM_RANGE(0xe880, 0xe880) AM_DEVWRITE("crtc", mc6845_device, address_w) |
| 468 | | AM_RANGE(0xe881, 0xe881) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w) |
| 469 | | /* 0xefe0, 0xefe3, mos 6702 */ |
| 470 | | /* 0xeff0, 0xeff3, acia6551 */ |
| 471 | | AM_RANGE(0xeff8, 0xefff) AM_READWRITE_LEGACY(superpet_r, superpet_w) |
| 472 | | AM_RANGE(0xf000, 0xffff) AM_ROM |
| 473 | | ADDRESS_MAP_END |
| 474 | | |
| 475 | | static ADDRESS_MAP_START( superpet_m6809_mem, AS_PROGRAM, 8, pet_state ) |
| 476 | | AM_RANGE(0x0000, 0x7fff) AM_RAM AM_SHARE("memory") /* same memory as m6502 */ |
| 477 | | AM_RANGE(0x8000, 0x87ff) AM_RAM AM_SHARE("videoram") /* same memory as m6502 */ |
| 478 | | AM_RANGE(0x9000, 0x9fff) AM_RAMBANK("bank1") /* 64 kbyte ram turned in */ |
| 479 | | AM_RANGE(0xa000, 0xe7ff) AM_ROM |
| 480 | | AM_RANGE(0xe810, 0xe813) AM_DEVREADWRITE("pia_0", pia6821_device, read, write) |
| 481 | | AM_RANGE(0xe820, 0xe823) AM_DEVREADWRITE("pia_1", pia6821_device, read, write) |
| 482 | | AM_RANGE(0xe840, 0xe84f) AM_DEVREADWRITE("via6522_0", via6522_device, read, write) |
| 483 | | AM_RANGE(0xe880, 0xe880) AM_DEVWRITE("crtc", mc6845_device, address_w) |
| 484 | | AM_RANGE(0xe881, 0xe881) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w) |
| 485 | | AM_RANGE(0xeff8, 0xefff) AM_READWRITE_LEGACY(superpet_r, superpet_w) |
| 486 | | AM_RANGE(0xf000, 0xffff) AM_ROM |
| 487 | | ADDRESS_MAP_END |
| 488 | | |
| 489 | | |
| 490 | | |
| 491 | | /************************************* |
| 492 | | * |
| 493 | | * Input Ports |
| 494 | | * |
| 495 | | *************************************/ |
| 496 | | |
| 497 | | |
| 498 | | static INPUT_PORTS_START( pet ) |
| 499 | | PORT_INCLUDE( pet_keyboard ) /* ROW0 -> ROW9 */ |
| 500 | | |
| 501 | | PORT_INCLUDE( pet_special ) /* SPECIAL */ |
| 502 | | |
| 503 | | PORT_INCLUDE( pet_config ) /* CFG */ |
| 504 | | INPUT_PORTS_END |
| 505 | | |
| 506 | | |
| 507 | | static INPUT_PORTS_START( petb ) |
| 508 | | PORT_INCLUDE( pet_business_keyboard ) /* ROW0 -> ROW9 */ |
| 509 | | |
| 510 | | PORT_INCLUDE( pet_special ) /* SPECIAL */ |
| 511 | | |
| 512 | | PORT_INCLUDE( pet_config ) /* CFG */ |
| 513 | | |
| 514 | | PORT_MODIFY("CFG") |
| 515 | | PORT_BIT( 0x180, 0x000, IPT_UNUSED ) |
| 516 | | INPUT_PORTS_END |
| 517 | | |
| 518 | | |
| 519 | | static INPUT_PORTS_START( cbm8096 ) |
| 520 | | PORT_INCLUDE( petb ) |
| 521 | | |
| 522 | | PORT_MODIFY("CFG") |
| 523 | | PORT_DIPNAME( 0x08, 0x08, "CBM8096, 8296 Expansion Memory") |
| 524 | | PORT_DIPSETTING( 0x00, DEF_STR( No ) ) |
| 525 | | PORT_DIPSETTING( 0x08, DEF_STR( Yes ) ) |
| 526 | | INPUT_PORTS_END |
| 527 | | |
| 528 | | |
| 529 | | static INPUT_PORTS_START (superpet) |
| 530 | | PORT_INCLUDE( petb ) |
| 531 | | |
| 532 | | PORT_MODIFY("CFG") |
| 533 | | PORT_DIPNAME( 0x04, 0x04, "CPU Select") |
| 534 | | PORT_DIPSETTING( 0x00, "M6502" ) |
| 535 | | PORT_DIPSETTING( 0x04, "M6809" ) |
| 536 | | INPUT_PORTS_END |
| 537 | | |
| 538 | | |
| 539 | | |
| 540 | | /************************************* |
| 541 | | * |
| 542 | | * Graphics definitions |
| 543 | | * |
| 544 | | *************************************/ |
| 545 | | |
| 546 | | |
| 547 | | static const unsigned char pet_palette[] = |
| 548 | | { |
| 549 | | 0,0,0, /* black */ |
| 550 | | 0,0x80,0, /* green */ |
| 551 | | }; |
| 552 | | |
| 553 | | static const gfx_layout pet_charlayout = |
| 554 | | { |
| 555 | | 8,8, |
| 556 | | 256, /* 256 characters */ |
| 557 | | 1, /* 1 bits per pixel */ |
| 558 | | { 0 }, /* no bitplanes; 1 bit per pixel */ |
| 559 | | /* x offsets */ |
| 560 | | { 0,1,2,3,4,5,6,7 }, |
| 561 | | /* y offsets */ |
| 562 | | { 0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8, |
| 563 | | }, |
| 564 | | 8*8 |
| 565 | | }; |
| 566 | | |
| 567 | | static const gfx_layout pet80_charlayout = |
| 568 | | { |
| 569 | | 8,16, |
| 570 | | 256, /* 256 characters */ |
| 571 | | 1, /* 1 bits per pixel */ |
| 572 | | { 0 }, /* no bitplanes; 1 bit per pixel */ |
| 573 | | /* x offsets */ |
| 574 | | { 0,1,2,3,4,5,6,7 }, |
| 575 | | /* y offsets */ |
| 576 | | { |
| 577 | | 0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8, |
| 578 | | 8*8, 9*8, 10*8, 11*8, 12*8, 13*8, 14*8, 15*8 |
| 579 | | }, |
| 580 | | 8*16 |
| 581 | | }; |
| 582 | | |
| 583 | | static GFXDECODE_START( pet ) |
| 584 | | GFXDECODE_ENTRY( "gfx1", 0x0000, pet_charlayout, 0, 1 ) |
| 585 | | GFXDECODE_ENTRY( "gfx1", 0x0800, pet_charlayout, 0, 1 ) |
| 586 | | GFXDECODE_END |
| 587 | | |
| 588 | | static GFXDECODE_START( pet80 ) |
| 589 | | GFXDECODE_ENTRY( "gfx1", 0x0000, pet80_charlayout, 0, 1 ) |
| 590 | | GFXDECODE_ENTRY( "gfx1", 0x1000, pet80_charlayout, 0, 1 ) |
| 591 | | GFXDECODE_END |
| 592 | | |
| 593 | | static GFXDECODE_START( superpet ) |
| 594 | | GFXDECODE_ENTRY( "gfx1", 0x0000, pet80_charlayout, 0, 1 ) |
| 595 | | GFXDECODE_ENTRY( "gfx1", 0x1000, pet80_charlayout, 0, 1 ) |
| 596 | | GFXDECODE_ENTRY( "gfx1", 0x2000, pet80_charlayout, 0, 1 ) |
| 597 | | GFXDECODE_ENTRY( "gfx1", 0x3000, pet80_charlayout, 0, 1 ) |
| 598 | | GFXDECODE_END |
| 599 | | |
| 600 | | |
| 601 | | static MC6845_INTERFACE( crtc_pet40 ) |
| 602 | | { |
| 603 | | "screen", |
| 604 | | false, |
| 605 | | 8, |
| 606 | | NULL, |
| 607 | | pet40_update_row, |
| 608 | | NULL, |
| 609 | | DEVCB_DRIVER_LINE_MEMBER(pet_state, pet_display_enable_changed), |
| 610 | | DEVCB_NULL, |
| 611 | | DEVCB_NULL, |
| 612 | | DEVCB_NULL, |
| 613 | | NULL |
| 614 | | }; |
| 615 | | |
| 616 | | static MC6845_INTERFACE( crtc_pet80 ) |
| 617 | | { |
| 618 | | "screen", |
| 619 | | false, |
| 620 | | 16, |
| 621 | | NULL, |
| 622 | | pet80_update_row, |
| 623 | | NULL, |
| 624 | | DEVCB_DRIVER_LINE_MEMBER(pet_state, pet_display_enable_changed), |
| 625 | | DEVCB_NULL, |
| 626 | | DEVCB_NULL, |
| 627 | | DEVCB_NULL, |
| 628 | | NULL |
| 629 | | }; |
| 630 | | |
| 631 | | void pet_state::palette_init() |
| 632 | | { |
| 633 | | int i; |
| 634 | | |
| 635 | | for ( i = 0; i < sizeof(pet_palette) / 3; i++ ) { |
| 636 | | palette_set_color_rgb(machine(), i, pet_palette[i*3], pet_palette[i*3+1], pet_palette[i*3+2]); |
| 637 | | } |
| 638 | | } |
| 639 | | |
| 640 | | VIDEO_START_MEMBER(pet_state,pet_crtc) |
| 641 | | { |
| 642 | | } |
| 643 | | |
| 644 | | static IEEE488_INTERFACE( ieee488_intf ) |
| 645 | | { |
| 646 | | DEVCB_NULL, |
| 647 | | DEVCB_NULL, |
| 648 | | DEVCB_NULL, |
| 649 | | DEVCB_NULL, |
| 650 | | DEVCB_NULL, |
| 651 | | DEVCB_DEVICE_LINE_MEMBER("pia_1", pia6821_device, cb1_w), |
| 652 | | DEVCB_DEVICE_LINE_MEMBER("pia_1", pia6821_device, ca1_w), |
| 653 | | DEVCB_NULL |
| 654 | | }; |
| 655 | | |
| 656 | | //------------------------------------------------- |
| 657 | | // PET_DATASSETTE_PORT_INTERFACE( datassette_intf ) |
| 658 | | //------------------------------------------------- |
| 659 | | |
| 660 | | static PET_DATASSETTE_PORT_INTERFACE( datassette_intf ) |
| 661 | | { |
| 662 | | DEVCB_DEVICE_LINE_MEMBER("pia_0", pia6821_device, cb1_w) |
| 663 | | }; |
| 664 | | |
| 665 | | //------------------------------------------------- |
| 666 | | // PET_DATASSETTE_PORT_INTERFACE( datassette2_intf ) |
| 667 | | //------------------------------------------------- |
| 668 | | |
| 669 | | static PET_DATASSETTE_PORT_INTERFACE( datassette2_intf ) |
| 670 | | { |
| 671 | | DEVCB_DEVICE_LINE_MEMBER("via6522_0", via6522_device, write_cb1) |
| 672 | | }; |
| 673 | | |
| 674 | | |
| 675 | | /************************************* |
| 676 | | * |
| 677 | | * Machine driver |
| 678 | | * |
| 679 | | *************************************/ |
| 680 | | |
| 681 | | static MACHINE_CONFIG_START( pet_general, pet_state ) |
| 682 | | /* basic machine hardware */ |
| 683 | | MCFG_CPU_ADD("maincpu", M6502, XTAL_8MHz/8) |
| 684 | | MCFG_CPU_PROGRAM_MAP(pet_mem) |
| 685 | | MCFG_CPU_VBLANK_INT_DRIVER("screen", pet_state, pet_frame_interrupt) |
| 686 | | |
| 687 | | |
| 688 | | /* video hardware */ |
| 689 | | MCFG_SCREEN_ADD("screen", RASTER) |
| 690 | | MCFG_SCREEN_REFRESH_RATE(60) |
| 691 | | MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */ |
| 692 | | MCFG_SCREEN_SIZE(320, 200) |
| 693 | | MCFG_SCREEN_VISIBLE_AREA(0, 320 - 1, 0, 200 - 1) |
| 694 | | MCFG_SCREEN_UPDATE_DRIVER(pet_state, screen_update_pet) |
| 695 | | |
| 696 | | MCFG_GFXDECODE( pet ) |
| 697 | | MCFG_PALETTE_LENGTH(ARRAY_LENGTH(pet_palette) / 3) |
| 698 | | |
| 699 | | /* cassette */ |
| 700 | | MCFG_PET_DATASSETTE_PORT_ADD(PET_DATASSETTE_PORT_TAG, datassette_intf, cbm_datassette_devices, "c1530", NULL) |
| 701 | | MCFG_PET_DATASSETTE_PORT_ADD(PET_DATASSETTE_PORT2_TAG, datassette2_intf, cbm_datassette_devices, NULL, NULL) |
| 702 | | |
| 703 | | /* via */ |
| 704 | | MCFG_VIA6522_ADD( "via6522_0", 0, pet_via) |
| 705 | | |
| 706 | | /* pias */ |
| 707 | | MCFG_PIA6821_ADD( "pia_0", pet_pia0) |
| 708 | | MCFG_PIA6821_ADD( "pia_1", pet_pia1) |
| 709 | | |
| 710 | | /* software lists */ |
| 711 | | MCFG_SOFTWARE_LIST_ADD("rom_list", "pet_rom") |
| 712 | | MCFG_SOFTWARE_LIST_ADD("flop_list", "pet_flop") |
| 713 | | MACHINE_CONFIG_END |
| 714 | | |
| 715 | | |
| 716 | | static MACHINE_CONFIG_DERIVED( pet, pet_general ) |
| 717 | | MCFG_QUICKLOAD_ADD("quickload", cbm_pet, "p00,prg", CBM_QUICKLOAD_DELAY_SECONDS) |
| 718 | | MCFG_FRAGMENT_ADD(pet_cartslot) |
| 719 | | |
| 720 | | /* internal ram */ |
| 721 | | MCFG_RAM_ADD(RAM_TAG) |
| 722 | | MCFG_RAM_DEFAULT_SIZE("32K") |
| 723 | | MCFG_RAM_EXTRA_OPTIONS("8K,16K") |
| 724 | | |
| 725 | | /* IEEE bus */ |
| 726 | | MCFG_CBM_IEEE488_ADD(ieee488_intf, "c4040") |
| 727 | | MACHINE_CONFIG_END |
| 728 | | |
| 729 | | |
| 730 | | static MACHINE_CONFIG_DERIVED( petb, pet ) |
| 731 | | MCFG_PIA6821_MODIFY( "pia_0", petb_pia0 ) |
| 732 | | MACHINE_CONFIG_END |
| 733 | | |
| 734 | | static MACHINE_CONFIG_DERIVED( pet2001, pet_general ) |
| 735 | | MCFG_QUICKLOAD_ADD("quickload", cbm_pet1, "p00,prg", CBM_QUICKLOAD_DELAY_SECONDS) |
| 736 | | MCFG_FRAGMENT_ADD(pet_cartslot) |
| 737 | | |
| 738 | | /* internal ram */ |
| 739 | | MCFG_RAM_ADD(RAM_TAG) |
| 740 | | MCFG_RAM_DEFAULT_SIZE("8K") |
| 741 | | MCFG_RAM_EXTRA_OPTIONS("4K") |
| 742 | | |
| 743 | | /* IEEE bus */ |
| 744 | | MCFG_CBM_IEEE488_ADD(ieee488_intf, "c4040") |
| 745 | | MACHINE_CONFIG_END |
| 746 | | |
| 747 | | |
| 748 | | static MACHINE_CONFIG_DERIVED( pet40, pet ) |
| 749 | | MCFG_CPU_MODIFY( "maincpu" ) |
| 750 | | MCFG_CPU_PROGRAM_MAP( pet40_mem) |
| 751 | | |
| 752 | | MCFG_MC6845_ADD("crtc", MC6845, XTAL_17_73447MHz/3 /* This is a wild guess and mostly likely incorrect */, crtc_pet40) |
| 753 | | |
| 754 | | MCFG_VIDEO_START_OVERRIDE(pet_state, pet_crtc ) |
| 755 | | MCFG_SCREEN_MODIFY("screen") |
| 756 | | MCFG_SCREEN_UPDATE_DEVICE( "crtc", mc6845_device, screen_update ) |
| 757 | | |
| 758 | | MCFG_FRAGMENT_ADD(pet4_cartslot) |
| 759 | | MACHINE_CONFIG_END |
| 760 | | |
| 761 | | |
| 762 | | static MACHINE_CONFIG_DERIVED( pet40pal, pet40 ) |
| 763 | | |
| 764 | | MCFG_SCREEN_MODIFY("screen") |
| 765 | | MCFG_SCREEN_REFRESH_RATE(50) |
| 766 | | MACHINE_CONFIG_END |
| 767 | | |
| 768 | | |
| 769 | | static MACHINE_CONFIG_DERIVED( pet80, pet_general ) |
| 770 | | MCFG_QUICKLOAD_ADD("quickload", cbm_pet, "p00,prg", CBM_QUICKLOAD_DELAY_SECONDS) |
| 771 | | MCFG_FRAGMENT_ADD(pet_cartslot) |
| 772 | | |
| 773 | | MCFG_CPU_MODIFY( "maincpu" ) |
| 774 | | MCFG_CPU_PROGRAM_MAP( pet80_mem) |
| 775 | | |
| 776 | | /* video hardware */ |
| 777 | | MCFG_SCREEN_MODIFY("screen") |
| 778 | | MCFG_SCREEN_SIZE(640, 250) |
| 779 | | MCFG_SCREEN_VISIBLE_AREA(0, 640 - 1, 0, 250 - 1) |
| 780 | | MCFG_SCREEN_UPDATE_DEVICE( "crtc", mc6845_device, screen_update ) |
| 781 | | |
| 782 | | MCFG_MC6845_ADD("crtc", MC6845, XTAL_12MHz / 2 /* This is a wild guess and mostly likely incorrect */, crtc_pet80) |
| 783 | | |
| 784 | | MCFG_GFXDECODE( pet80 ) |
| 785 | | MCFG_VIDEO_START_OVERRIDE(pet_state, pet_crtc ) |
| 786 | | |
| 787 | | MCFG_PIA6821_MODIFY( "pia_0", petb_pia0 ) |
| 788 | | |
| 789 | | MCFG_FRAGMENT_ADD(pet4_cartslot) |
| 790 | | |
| 791 | | /* internal ram */ |
| 792 | | MCFG_RAM_ADD(RAM_TAG) |
| 793 | | MCFG_RAM_DEFAULT_SIZE("32K") |
| 794 | | |
| 795 | | /* IEEE bus */ |
| 796 | | MCFG_CBM_IEEE488_ADD(ieee488_intf, "c8050") |
| 797 | | MACHINE_CONFIG_END |
| 798 | | |
| 799 | | |
| 800 | | static MACHINE_CONFIG_DERIVED( pet80pal, pet80 ) |
| 801 | | MCFG_SCREEN_MODIFY("screen") |
| 802 | | MCFG_SCREEN_REFRESH_RATE(50) |
| 803 | | MACHINE_CONFIG_END |
| 804 | | |
| 805 | | |
| 806 | | static MACHINE_CONFIG_DERIVED( superpet, pet80 ) |
| 807 | | MCFG_CPU_MODIFY( "maincpu" ) |
| 808 | | MCFG_CPU_PROGRAM_MAP( superpet_mem) |
| 809 | | |
| 810 | | /* m6809 cpu */ |
| 811 | | MCFG_CPU_ADD("m6809", M6809, 1000000) |
| 812 | | MCFG_CPU_PROGRAM_MAP(superpet_m6809_mem) |
| 813 | | MCFG_CPU_VBLANK_INT_DRIVER("screen", pet_state, pet_frame_interrupt) |
| 814 | | |
| 815 | | MCFG_SCREEN_MODIFY("screen") |
| 816 | | MCFG_SCREEN_REFRESH_RATE(50) |
| 817 | | MCFG_GFXDECODE( superpet ) |
| 818 | | |
| 819 | | MCFG_PIA6821_MODIFY( "pia_0", petb_pia0 ) |
| 820 | | |
| 821 | | MCFG_SOFTWARE_LIST_ADD("flop_list2", "superpet_flop") |
| 822 | | MACHINE_CONFIG_END |
| 823 | | |
| 824 | | |
| 825 | | static MACHINE_CONFIG_DERIVED( cbm8296, pet80pal ) |
| 826 | | MCFG_SOFTWARE_LIST_ADD("flop_list2", "cbm8296_flop") |
| 827 | | MACHINE_CONFIG_END |
| 828 | | |
| 829 | | |
| 830 | | |
| 831 | | /************************************* |
| 832 | | * |
| 833 | | * ROM definition(s) |
| 834 | | * |
| 835 | | *************************************/ |
| 836 | | |
| 837 | | |
| 838 | | /* PET 2001 - Board type 1 (Static Board) */ |
| 839 | | /* BASIC 1 - "*** COMMODORE BASIC ***" at boot */ |
| 840 | | /* Four board variations depending on |
| 841 | | ROM sockets: either 6540 or 2316B |
| 842 | | RAM: either 6550 or 2114 |
| 843 | | The ROM content is the same in both cases, but the labels differ. Below we use labels |
| 844 | | from the 2316B version. For documentation sake, these would have been the labels based on |
| 845 | | the board with 6540 ROMs |
| 846 | | |
| 847 | | 901439-01.h1 / 901439-09.h1 |
| 848 | | 901439-05.h5 |
| 849 | | 901439-02.h2 |
| 850 | | 901439-06.h6 |
| 851 | | 901439-03.h3 |
| 852 | | 901439-04.h4 |
| 853 | | 901439-07.h7 |
| 854 | | 901439-08.a2 |
| 855 | | |
| 856 | | Also, in some board with 2316B, the location of the ROMs changes h1 <-> h5, h2 <-> h6 and |
| 857 | | h4 <-> h7 |
| 858 | | */ |
| 859 | | |
| 860 | | ROM_START( pet2001 ) |
| 861 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 862 | | ROM_SYSTEM_BIOS( 0, "basic1", "BASIC 1r" ) |
| 863 | | ROMX_LOAD( "901447-09.h1", 0xc000, 0x800, CRC(03cf16d0) SHA1(1330580c0614d3556a389da4649488ba04a60908), ROM_BIOS(1) ) |
| 864 | | ROM_SYSTEM_BIOS( 1, "basic1o", "BASIC 1" ) |
| 865 | | ROMX_LOAD( "901447-01.h1", 0xc000, 0x800, CRC(a055e33a) SHA1(831db40324113ee996c434d38b4add3fd1f820bd), ROM_BIOS(2) ) |
| 866 | | ROM_LOAD( "901447-02.h5", 0xc800, 0x800, CRC(69fd8a8f) SHA1(70c0f4fa67a70995b168668c957c3fcf2c8641bd) ) |
| 867 | | ROM_LOAD( "901447-03.h2", 0xd000, 0x800, CRC(d349f2d4) SHA1(4bf2c20c51a63d213886957485ebef336bb803d0) ) |
| 868 | | ROM_LOAD( "901447-04.h6", 0xd800, 0x800, CRC(850544eb) SHA1(d293972d529023d8fd1f493149e4777b5c253a69) ) |
| 869 | | ROM_LOAD( "901447-05.h3", 0xe000, 0x800, CRC(9e1c5cea) SHA1(f02f5fb492ba93dbbd390f24c10f7a832dec432a) ) |
| 870 | | ROM_LOAD( "901447-06.h4", 0xf000, 0x800, CRC(661a814a) SHA1(960717282878e7de893d87242ddf9d1512be162e) ) |
| 871 | | ROM_LOAD( "901447-07.h7", 0xf800, 0x800, CRC(c4f47ad1) SHA1(d440f2510bc52e20c3d6bc8b9ded9cea7f462a9c) ) |
| 872 | | |
| 873 | | ROM_REGION( 0x1000, "gfx1", 0 ) |
| 874 | | ROM_LOAD( "901447-08.a2", 0x0000, 0x800, CRC(54f32f45) SHA1(3e067cc621e4beafca2b90cb8f6dba975df2855b) ) |
| 875 | | ROM_END |
| 876 | | |
| 877 | | |
| 878 | | /* PET 2001-N / 2001-B / CBM 30XX / PET 40XX (early) / CBM 40XX (early) - Board type 2 (Dynamic Board) */ |
| 879 | | /* BASIC 1 upgraded / BASIC 2 - "### COMMODORE BASIC ###" at boot */ |
| 880 | | /* Again different kind of ROM sockets can be found. */ |
| 881 | | /* These boards would support BASIC 1 as well, if the content would be put on 4K ROMs */ |
| 882 | | |
| 883 | | /* BASIC 2 */ |
| 884 | | ROM_START( pet2001n ) |
| 885 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 886 | | ROM_LOAD( "901465-01.ud6", 0xc000, 0x1000, CRC(63a7fe4a) SHA1(3622111f486d0e137022523657394befa92bde44) ) // BASIC 2 |
| 887 | | ROM_LOAD( "901465-02.ud7", 0xd000, 0x1000, CRC(ae4cb035) SHA1(1bc0ebf27c9bb62ad71bca40313e874234cab6ac) ) // BASIC 2 |
| 888 | | ROM_LOAD( "901447-24.ud8", 0xe000, 0x800, CRC(e459ab32) SHA1(5e5502ce32f5a7e387d65efe058916282041e54b) ) // Screen Editor (40 columns, no CRTC, Normal Keyb) |
| 889 | | ROM_LOAD( "901465-03.ud9", 0xf000, 0x1000, CRC(f02238e2) SHA1(38742bdf449f629bcba6276ef24d3daeb7da6e84) ) // Kernal |
| 890 | | |
| 891 | | ROM_REGION( 0x1000, "gfx1", 0 ) |
| 892 | | ROM_LOAD( "901447-10.uf10", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 893 | | ROM_END |
| 894 | | |
| 895 | | /* BASIC 2 - Business Keyboard (Number keys, etc.) */ |
| 896 | | ROM_START( pet2001b ) |
| 897 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 898 | | ROM_LOAD( "901465-01.ud6", 0xc000, 0x1000, CRC(63a7fe4a) SHA1(3622111f486d0e137022523657394befa92bde44) ) // BASIC 2 |
| 899 | | ROM_LOAD( "901465-02.ud7", 0xd000, 0x1000, CRC(ae4cb035) SHA1(1bc0ebf27c9bb62ad71bca40313e874234cab6ac) ) // BASIC 2 |
| 900 | | ROM_LOAD( "901474-01.ud8", 0xe000, 0x800, CRC(05db957e) SHA1(174ace3a8c0348cd21d39cc864e2adc58b0101a9) ) // Screen Editor (40 columns, no CRTC, Business Keyb) |
| 901 | | ROM_LOAD( "901465-03.ud9", 0xf000, 0x1000, CRC(f02238e2) SHA1(38742bdf449f629bcba6276ef24d3daeb7da6e84) ) // Kernal |
| 902 | | |
| 903 | | ROM_REGION( 0x1000, "gfx1", 0 ) |
| 904 | | ROM_LOAD( "901447-10.uf10", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 905 | | ROM_END |
| 906 | | |
| 907 | | #define rom_cbm30 rom_pet2001n |
| 908 | | #define rom_cbm30b rom_pet2001b |
| 909 | | |
| 910 | | /* BASIC 4, but 40 columns only and no CRTC */ |
| 911 | | ROM_START( pet40on ) |
| 912 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 913 | | ROM_SYSTEM_BIOS( 0, "basic4", "BASIC 4r" ) |
| 914 | | ROMX_LOAD( "901465-23.ud5", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc), ROM_BIOS(1) ) // BASIC 4 |
| 915 | | ROM_SYSTEM_BIOS( 1, "basic4o", "BASIC 4" ) |
| 916 | | ROMX_LOAD( "901465-19.ud5", 0xb000, 0x1000, CRC(3a5f5721) SHA1(bc2b7c99495fea3eda950ee9e3d6cabe448a452b), ROM_BIOS(2) ) |
| 917 | | ROM_LOAD( "901465-20.ud6", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 918 | | ROM_LOAD( "901465-21.ud7", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 919 | | ROM_LOAD( "901447-29.ud8", 0xe000, 0x800, CRC(e5714d4c) SHA1(e88f56e5c54b0e8d8d4e8cb39a4647c803c1f51c) ) // Screen Editor (40 columns, no CRTC, Normal Keyb) |
| 920 | | ROM_LOAD( "901465-22.ud9", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 921 | | |
| 922 | | ROM_REGION( 0x1000, "gfx1", 0 ) |
| 923 | | ROM_LOAD( "901447-10.uf10", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 924 | | ROM_END |
| 925 | | |
| 926 | | /* BASIC 4, but 40 columns only and no CRTC - Business Keyboard (Number keys, etc.) */ |
| 927 | | ROM_START( pet40ob ) |
| 928 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 929 | | ROM_SYSTEM_BIOS( 0, "basic4", "BASIC 4r" ) |
| 930 | | ROMX_LOAD( "901465-23.ud5", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc), ROM_BIOS(1) ) |
| 931 | | ROM_SYSTEM_BIOS( 1, "basic4o", "BASIC 4" ) |
| 932 | | ROMX_LOAD( "901465-19.ud5", 0xb000, 0x1000, CRC(3a5f5721) SHA1(bc2b7c99495fea3eda950ee9e3d6cabe448a452b), ROM_BIOS(2) ) |
| 933 | | ROM_LOAD( "901465-20.ud6", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 934 | | ROM_LOAD( "901465-21.ud7", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 935 | | ROM_LOAD( "901474-02.ud8", 0xe000, 0x800, CRC(75ff4af7) SHA1(0ca5c4e8f532f914cb0bf86ea9900f20f0a655ce) ) // Screen Editor (40 columns, no CRTC, Business Keyb) |
| 936 | | ROM_LOAD( "901465-22.ud9", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 937 | | |
| 938 | | ROM_REGION( 0x1000, "gfx1", 0 ) |
| 939 | | ROM_LOAD( "901447-10.uf10", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 940 | | ROM_END |
| 941 | | |
| 942 | | #define rom_cbm40o rom_pet40on |
| 943 | | #define rom_cbm40ob rom_pet40ob |
| 944 | | |
| 945 | | /* PET 40XX (later) / PET 80XX / CBM 400XX (later) / CBM 80XX - Board type 3 (80 columns Board) & 4 (Universal Board) */ |
| 946 | | /* BASIC 4, Board 3: 80 columns only using CRTC - Board 4: 40 or 80 columns using CRTC, changed through a jumper on the board */ |
| 947 | | /* Board 3 ones can only run the 80 columns BASIC 4, Board 4 can run all BASIC versions supporting CRTC */ |
| 948 | | |
| 949 | | /* 40 columns - 60 Hz */ |
| 950 | | ROM_START( pet40n ) |
| 951 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 952 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 953 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 954 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 955 | | ROM_LOAD( "901499-01.ud7", 0xe000, 0x800, CRC(5f85bdf8) SHA1(8cbf086c1ce4dfb2a2fe24c47476dfb878493dee) ) // Screen Editor (40 columns, CRTC 60Hz, Normal Keyb?) |
| 956 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 957 | | |
| 958 | | ROM_REGION( 0x1000, "gfx1", 0 ) |
| 959 | | ROM_LOAD( "901447-10.ua3", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 960 | | ROM_END |
| 961 | | |
| 962 | | /* 40 columns - 50 Hz */ |
| 963 | | ROM_START( cbm40n ) |
| 964 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 965 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 966 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 967 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 968 | | ROM_LOAD( "901498-01.ud7", 0xe000, 0x800, CRC(3370e359) SHA1(05af284c914d53a52987b5f602466de75765f650) ) // Screen Editor (40 columns, CRTC 50Hz, Normal Keyb?) |
| 969 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 970 | | |
| 971 | | ROM_REGION( 0x1000, "gfx1", 0 ) |
| 972 | | ROM_LOAD( "901447-10.ua3", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 973 | | ROM_END |
| 974 | | |
| 975 | | /* 80 columns - 60 Hz */ |
| 976 | | ROM_START( pet40b ) |
| 977 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 978 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 979 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 980 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 981 | | ROM_LOAD( "901474-03.ud7", 0xe000, 0x800, CRC(5674dd5e) SHA1(c605fa343fd77c73cbe1e0e9567e2f014f6e7e30) ) // Screen Editor (80 columns, CRTC 60Hz, Business Keyb) |
| 982 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 983 | | |
| 984 | | ROM_REGION( 0x2000, "gfx1", 0 ) |
| 985 | | ROM_LOAD( "901447-10.ua3", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 986 | | ROM_END |
| 987 | | |
| 988 | | /* 80 columns - 50 Hz */ |
| 989 | | ROM_START( cbm40b ) |
| 990 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 991 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 992 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 993 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 994 | | ROM_SYSTEM_BIOS( 0, "default", "BASIC 4" ) |
| 995 | | ROMX_LOAD( "901474-04.ud7", 0xe000, 0x800, CRC(abb000e7) SHA1(66887061b6c4ebef7d6efb90af9afd5e2c3b08ba), ROM_BIOS(1) ) // Screen Editor (80 columns, CRTC 50Hz, Business Keyb) |
| 996 | | ROM_SYSTEM_BIOS( 1, "alt", "BASIC 4 (alt Editor)" ) |
| 997 | | ROMX_LOAD( "901474-04a.ud7", 0xe000, 0x800, BAD_DUMP CRC(845a44e6) SHA1(81975eab31a8f4f51ae2a20d099a567c7b3f2dd1), ROM_BIOS(2) ) |
| 998 | | ROM_SYSTEM_BIOS( 2, "old", "BASIC 4 (Editor dated 3681)" ) |
| 999 | | ROMX_LOAD( "901474-04o.ud7", 0xe000, 0x800, CRC(c1ffca3a) SHA1(7040b283ba39e9630e3d147f7d076b7abc39bc70), ROM_BIOS(3) ) |
| 1000 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 1001 | | |
| 1002 | | ROM_REGION( 0x2000, "gfx1", 0 ) |
| 1003 | | ROM_LOAD( "901447-10.ua3", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 1004 | | ROM_END |
| 1005 | | |
| 1006 | | /* 80 columns - 60 Hz - can be expanded to 96k RAM */ |
| 1007 | | ROM_START( pet80 ) |
| 1008 | | ROM_REGION( 0x20000, "maincpu", 0 ) |
| 1009 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 1010 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 1011 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 1012 | | ROM_LOAD( "901474-03.ud7", 0xe000, 0x800, CRC(5674dd5e) SHA1(c605fa343fd77c73cbe1e0e9567e2f014f6e7e30) ) // Screen Editor (80 columns, CRTC 60Hz, Business Keyb) |
| 1013 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 1014 | | |
| 1015 | | ROM_REGION( 0x2000, "gfx1", 0 ) |
| 1016 | | ROM_LOAD( "901447-10.ua3", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 1017 | | ROM_END |
| 1018 | | |
| 1019 | | /* 80 columns - 50 Hz - can be expanded to 96k RAM */ |
| 1020 | | ROM_START( cbm80 ) |
| 1021 | | ROM_REGION( 0x20000, "maincpu", 0 ) |
| 1022 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 1023 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 1024 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 1025 | | ROM_SYSTEM_BIOS( 0, "default", "BASIC 4" ) |
| 1026 | | ROMX_LOAD( "901474-04.ud7", 0xe000, 0x800, CRC(abb000e7) SHA1(66887061b6c4ebef7d6efb90af9afd5e2c3b08ba), ROM_BIOS(1) ) // Screen Editor (80 columns, CRTC 50Hz, Business Keyb) |
| 1027 | | ROM_SYSTEM_BIOS( 1, "alt", "BASIC 4 (alt Editor)" ) |
| 1028 | | ROMX_LOAD( "901474-04a.ud7", 0xe000, 0x800, BAD_DUMP CRC(845a44e6) SHA1(81975eab31a8f4f51ae2a20d099a567c7b3f2dd1), ROM_BIOS(2) ) |
| 1029 | | ROM_SYSTEM_BIOS( 2, "old", "BASIC 4 (Editor dated 3681)" ) |
| 1030 | | ROMX_LOAD( "901474-04o.ud7", 0xe000, 0x800, CRC(c1ffca3a) SHA1(7040b283ba39e9630e3d147f7d076b7abc39bc70), ROM_BIOS(3) ) |
| 1031 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 1032 | | |
| 1033 | | ROM_REGION( 0x2000, "gfx1", 0 ) |
| 1034 | | ROM_LOAD( "901447-10.ua3", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 1035 | | ROM_END |
| 1036 | | |
| 1037 | | |
| 1038 | | /* Two different layouts are documented for the m6809 */ |
| 1039 | | /* The 2532 EEPROM listed below (2516 for the .u21 one) could have been replaced by three 2764 EEPROM. |
| 1040 | | In this case the labels would have been as follows |
| 1041 | | |
| 1042 | | 970018-12.u47 (contents: u17+u18 below) |
| 1043 | | 970019-12.u48 (contents: u19+u20 below) |
| 1044 | | 970020-12.u49 (contents: u21+u22 below) |
| 1045 | | |
| 1046 | | */ |
| 1047 | | |
| 1048 | | ROM_START( superpet ) |
| 1049 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 1050 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 1051 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 1052 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 1053 | | ROM_LOAD( "901474-04.ud7", 0xe000, 0x800, CRC(abb000e7) SHA1(66887061b6c4ebef7d6efb90af9afd5e2c3b08ba) ) // Screen Editor (80 columns, CRTC 50Hz, Business Keyb) |
| 1054 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 1055 | | |
| 1056 | | ROM_REGION( 0x10000, "m6809", 0 ) |
| 1057 | | ROM_LOAD( "901898-01.u17", 0xa000, 0x1000, CRC(728a998b) SHA1(0414b3ab847c8977eb05c2fcc72efcf2f9d92871) ) |
| 1058 | | ROM_LOAD( "901898-02.u18", 0xb000, 0x1000, CRC(6beb7c62) SHA1(df154939b934d0aeeb376813ec1ba0d43c2a3378) ) |
| 1059 | | ROM_LOAD( "901898-03.u19", 0xc000, 0x1000, CRC(5db4983d) SHA1(6c5b0cce97068f8841112ba6d5cd8e568b562fa3) ) |
| 1060 | | ROM_LOAD( "901898-04.u20", 0xd000, 0x1000, CRC(f55fc559) SHA1(b42a2050a319a1ffca7868a8d8d635fadd37ec37) ) |
| 1061 | | ROM_LOAD( "901897-01.u21", 0xe000, 0x800, CRC(b2cee903) SHA1(e8ce8347451a001214a5e71a13081b38b4be23bc) ) |
| 1062 | | ROM_LOAD( "901898-05.u22", 0xf000, 0x1000, CRC(f42df0cb) SHA1(9b4a5134d20345171e7303445f87c4e0b9addc96) ) |
| 1063 | | |
| 1064 | | ROM_REGION( 0x4000, "gfx1", 0 ) |
| 1065 | | ROM_LOAD( "901640-01.ub3", 0x0000, 0x1000, CRC(ee8229c4) SHA1(bf346f11595a3e65e55d6aeeaa2c0cec807b66c7) ) |
| 1066 | | ROM_END |
| 1067 | | |
| 1068 | | #define rom_sp9000 rom_superpet |
| 1069 | | |
| 1070 | | |
| 1071 | | /* CBM 8296 / 8296D - only ROM loading added */ |
| 1072 | | ROM_START( cbm8296 ) |
| 1073 | | ROM_REGION( 0x20000, "maincpu", 0 ) |
| 1074 | | ROM_LOAD( "324746-01.ue7", 0xb000, 0x3000, CRC(7935b528) SHA1(5ab17ee70467152bf2130e3f48a2aa81e9df93c9) ) // BASIC 4 // FIX ME!! |
| 1075 | | ROM_CONTINUE( 0xf000, 0x1000 ) |
| 1076 | | ROM_LOAD( "901474-04.ue8", 0xe000, 0x800, CRC(c1ffca3a) SHA1(7040b283ba39e9630e3d147f7d076b7abc39bc70) ) // Dated 0384, coincides with 3681 above according to Andr? Fachat's notes |
| 1077 | | |
| 1078 | | ROM_REGION( 0x4000, "gfx1", 0 ) |
| 1079 | | ROM_LOAD( "901447-10.uc5", 0x0000, 0x800, CRC(d8408674) SHA1(0157a2d55b7ac4eaeb38475889ebeea52e2593db) ) // Character Generator |
| 1080 | | ROM_END |
| 1081 | | |
| 1082 | | #define rom_cbm8296d rom_cbm8296 |
| 1083 | | |
| 1084 | | |
| 1085 | | /* PAL regional variants */ |
| 1086 | | |
| 1087 | | ROM_START( cbm80ger ) |
| 1088 | | ROM_REGION( 0x20000, "maincpu", 0 ) |
| 1089 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 1090 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 1091 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 1092 | | ROM_LOAD( "german.bin", 0xe000, 0x800, CRC(1c1e597d) SHA1(7ac75ed73832847623c9f4f197fe7fb1a73bb41c) ) |
| 1093 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 1094 | | |
| 1095 | | ROM_REGION( 0x2000, "gfx1", 0 ) |
| 1096 | | ROM_LOAD( "chargen.de", 0x0000, 0x800, CRC(3bb8cb87) SHA1(a4f0df13473d7f9cd31fd62cfcab11318e2fb1dc) ) |
| 1097 | | ROM_END |
| 1098 | | |
| 1099 | | ROM_START( cbm80swe ) |
| 1100 | | ROM_REGION( 0x20000, "maincpu", 0 ) |
| 1101 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 1102 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 1103 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 1104 | | ROM_LOAD( "swedish.bin", 0xe000, 0x800, CRC(75901dd7) SHA1(2ead0d83255a344a42bb786428353ca48d446d03) ) // It had a label "8000-UD7, SCREEN-04" |
| 1105 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 1106 | | |
| 1107 | | ROM_REGION( 0x2000, "gfx1", 0 ) |
| 1108 | | ROM_LOAD( "901447-14.ua3", 0x0000, 0x800, CRC(48c77d29) SHA1(aa7c8ff844d16ec05e2b32acc586c58d9e35388c) ) // Character Generator |
| 1109 | | ROM_END |
| 1110 | | |
| 1111 | | /* This had only the CharGen dumped, the editor needs to be dumped as well (and the other ones verified)!! */ |
| 1112 | | ROM_START( cbm30nor ) |
| 1113 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 1114 | | ROM_LOAD( "901465-01.ud6", 0xc000, 0x1000, CRC(63a7fe4a) SHA1(3622111f486d0e137022523657394befa92bde44) ) // BASIC 2 |
| 1115 | | ROM_LOAD( "901465-02.ud7", 0xd000, 0x1000, CRC(ae4cb035) SHA1(1bc0ebf27c9bb62ad71bca40313e874234cab6ac) ) // BASIC 2 |
| 1116 | | ROM_LOAD( "901474-01.ud8", 0xe000, 0x800, BAD_DUMP CRC(05db957e) SHA1(174ace3a8c0348cd21d39cc864e2adc58b0101a9) ) // Screen Editor to be redumped |
| 1117 | | ROM_LOAD( "901465-03.ud9", 0xf000, 0x1000, CRC(f02238e2) SHA1(38742bdf449f629bcba6276ef24d3daeb7da6e84) ) // Kernal |
| 1118 | | |
| 1119 | | ROM_REGION( 0x1000, "gfx1", 0 ) |
| 1120 | | ROM_LOAD( "norwegian.uf10", 0x0000, 0x800, CRC(7c00534a) SHA1(2c46bd5f5351530ceb52686e5196de995e28e24f) ) // Character Generator dumped from a CBM 3032 // FIX ME!! |
| 1121 | | ROM_END |
| 1122 | | |
| 1123 | | /* This had only the CharGen dumped, the editor needs to be dumped as well (and the other ones verified)!! */ |
| 1124 | | ROM_START( cbm80hun ) |
| 1125 | | ROM_REGION( 0x20000, "maincpu", 0 ) |
| 1126 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 1127 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 1128 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 1129 | | ROM_LOAD( "901474-04.ud7", 0xe000, 0x800, BAD_DUMP CRC(abb000e7) SHA1(66887061b6c4ebef7d6efb90af9afd5e2c3b08ba) ) // Screen Editor (80 columns, CRTC 50Hz, Business Keyb) |
| 1130 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 1131 | | |
| 1132 | | ROM_REGION( 0x2000, "gfx1", 0 ) |
| 1133 | | ROM_LOAD( "hungarian.ua3", 0x0000, 0x800, CRC(a02d8122) SHA1(2fedbb59068b457d98f28de79f1817e25f745604) ) // Character Generator // FIX ME!! |
| 1134 | | ROM_END |
| 1135 | | |
| 1136 | | /* Swedish M6809 roms needed */ |
| 1137 | | ROM_START( mmf9000s ) |
| 1138 | | ROM_REGION( 0x10000, "maincpu", 0 ) |
| 1139 | | ROM_LOAD( "901465-23.ud10", 0xb000, 0x1000, CRC(ae3deac0) SHA1(975ee25e28ff302879424587e5fb4ba19f403adc) ) // BASIC 4 |
| 1140 | | ROM_LOAD( "901465-20.ud9", 0xc000, 0x1000, CRC(0fc17b9c) SHA1(242f98298931d21eaacb55fe635e44b7fc192b0a) ) // BASIC 4 |
| 1141 | | ROM_LOAD( "901465-21.ud8", 0xd000, 0x1000, CRC(36d91855) SHA1(1bb236c72c726e8fb029c68f9bfa5ee803faf0a8) ) // BASIC 4 |
| 1142 | | ROM_LOAD( "swedish.bin", 0xe000, 0x800, CRC(75901dd7) SHA1(2ead0d83255a344a42bb786428353ca48d446d03) ) |
| 1143 | | ROM_LOAD( "901465-22.ud6", 0xf000, 0x1000, CRC(cc5298a1) SHA1(96a0fa56e0c937da92971d9c99d504e44e898806) ) // Kernal |
| 1144 | | |
| 1145 | | ROM_REGION( 0x20000, "m6809", 0 ) |
| 1146 | | ROM_LOAD( "901898-01.u17", 0xa000, 0x1000, BAD_DUMP CRC(728a998b) SHA1(0414b3ab847c8977eb05c2fcc72efcf2f9d92871) ) |
| 1147 | | ROM_LOAD( "901898-02.u18", 0xb000, 0x1000, BAD_DUMP CRC(6beb7c62) SHA1(df154939b934d0aeeb376813ec1ba0d43c2a3378) ) |
| 1148 | | ROM_LOAD( "901898-03.u19", 0xc000, 0x1000, BAD_DUMP CRC(5db4983d) SHA1(6c5b0cce97068f8841112ba6d5cd8e568b562fa3) ) |
| 1149 | | ROM_LOAD( "901898-04.u20", 0xd000, 0x1000, BAD_DUMP CRC(f55fc559) SHA1(b42a2050a319a1ffca7868a8d8d635fadd37ec37) ) |
| 1150 | | ROM_LOAD( "901897-01.u21", 0xe000, 0x800, BAD_DUMP CRC(b2cee903) SHA1(e8ce8347451a001214a5e71a13081b38b4be23bc) ) |
| 1151 | | ROM_LOAD( "901898-05.u22", 0xf000, 0x1000, BAD_DUMP CRC(f42df0cb) SHA1(9b4a5134d20345171e7303445f87c4e0b9addc96) ) |
| 1152 | | |
| 1153 | | ROM_REGION( 0x4000, "gfx1", 0 ) |
| 1154 | | ROM_LOAD("skand.gen.ub3", 0x0000, 0x1000, CRC(da1cd630) SHA1(35f472114ff001259bdbae073ae041b0759e32cb) ) // Actual label was "901640-01 SKAND.GEN." |
| 1155 | | ROM_END |
| 1156 | | |
| 1157 | | /*************************************************************************** |
| 1158 | | |
| 1159 | | Game driver(s) |
| 1160 | | |
| 1161 | | ***************************************************************************/ |
| 1162 | | |
| 1163 | | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME */ |
| 1164 | | |
| 1165 | | COMP(1977, pet2001, 0, 0, pet2001, pet, pet_state, pet2001, "Commodore Business Machines", "PET 2001", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1166 | | COMP(1979, pet2001n, pet2001, 0, pet, pet, pet_state, pet, "Commodore Business Machines", "PET 2001-N", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1167 | | COMP(1979, pet2001b, pet2001, 0, petb, petb, pet_state, pet, "Commodore Business Machines", "PET 2001-B", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1168 | | COMP(1979, cbm30, pet2001, 0, pet, pet, pet_state, pet, "Commodore Business Machines", "CBM 30xx", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1169 | | COMP(1979, cbm30b, pet2001, 0, petb, petb, pet_state, pet, "Commodore Business Machines", "CBM 30xx (Business keyboard)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1170 | | COMP(1979, cbm30nor, pet2001, 0, petb, petb, pet_state, pet, "Commodore Business Machines", "CBM 30xx (Norway, Business keyboard)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1171 | | |
| 1172 | | /* So called, THIN-40 */ |
| 1173 | | COMP(1980, pet40on, pet2001, 0, pet, pet, pet_state, pet, "Commodore Business Machines", "PET 40xx (Basic 4, no CRTC, Normal keyboard)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1174 | | COMP(1980, pet40ob, pet2001, 0, petb, petb, pet_state, pet, "Commodore Business Machines", "PET 40xx (Basic 4, no CRTC, Business keyboard)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1175 | | COMP(1980, cbm40o, pet2001, 0, pet, pet, pet_state, pet, "Commodore Business Machines", "CBM 40xx (Basic 4, no CRTC, Normal keyboard)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1176 | | COMP(1980, cbm40ob, pet2001, 0, petb, petb, pet_state, pet, "Commodore Business Machines", "CBM 40xx (Basic 4, no CRTC, Business keyboard)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1177 | | |
| 1178 | | COMP(1981, pet80, 0, 0, pet80, cbm8096, pet_state, pet80, "Commodore Business Machines", "PET 80xx (Basic 4, CRTC 60Hz, 80 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1179 | | COMP(1981, cbm80, pet80, 0, pet80pal, cbm8096, pet_state, pet80, "Commodore Business Machines", "CBM 80xx (Basic 4, CRTC 50Hz, 80 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1180 | | COMP(1981, cbm80ger, pet80, 0, pet80pal, cbm8096, pet_state, pet80, "Commodore Business Machines", "CBM 80xx (Germany, Basic 4, CRTC 50Hz, 80 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1181 | | COMP(1981, cbm80hun, pet80, 0, pet80pal, cbm8096, pet_state, pet80, "Commodore Business Machines", "CBM 80xx (Hungary, Basic 4, CRTC 50Hz, 80 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1182 | | COMP(1981, cbm80swe, pet80, 0, pet80pal, cbm8096, pet_state, pet80, "Commodore Business Machines", "CBM 80xx (Sweden, Basic 4, CRTC 50Hz, 80 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1183 | | |
| 1184 | | /* So called, FAT-40 */ |
| 1185 | | COMP(1981, pet40b, pet80, 0, pet80, cbm8096, pet_state, pet80, "Commodore Business Machines", "PET 40xx (Basic 4, CRTC 60Hz, 80 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1186 | | COMP(1981, pet40n, pet2001, 0, pet40, pet, pet_state, pet, "Commodore Business Machines", "PET 40xx (Basic 4, CRTC 60Hz, 40 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1187 | | COMP(1981, cbm40b, pet80, 0, pet80pal, cbm8096, pet_state, pet80, "Commodore Business Machines", "CBM 40xx (Basic 4, CRTC 50Hz, 80 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1188 | | COMP(1981, cbm40n, pet2001, 0, pet40pal, pet, pet_state, pet, "Commodore Business Machines", "CBM 40xx (Basic 4, CRTC 50Hz, 40 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1189 | | |
| 1190 | | COMP(1981, superpet, 0, 0, superpet, superpet, pet_state, superpet,"Commodore Business Machines", "SuperPET (CRTC 50Hz)", GAME_NOT_WORKING | GAME_NO_SOUND | GAME_NOT_WORKING) |
| 1191 | | COMP(1981, sp9000, superpet, 0, superpet, superpet, pet_state, superpet,"Commodore Business Machines", "CBM SP9000 / MicroMainFrame 9000 (CRTC 50Hz)", GAME_NOT_WORKING | GAME_NO_SOUND | GAME_NOT_WORKING) |
| 1192 | | COMP(198?, mmf9000s, superpet, 0, superpet, superpet, pet_state, superpet,"Commodore Business Machines", "MicroMainFrame 9000 (Sweden, CRTC 50Hz)", GAME_NOT_WORKING | GAME_NO_SOUND | GAME_NOT_WORKING) |
| 1193 | | |
| 1194 | | COMP(1984, cbm8296, pet80, 0, cbm8296, cbm8096, pet_state, pet80, "Commodore Business Machines", "CBM 8296 (Basic 4, CRTC 50Hz, 80 columns)", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 1195 | | COMP(1984, cbm8296d, pet80, 0, cbm8296, cbm8096, pet_state, pet80, "Commodore Business Machines", "CBM 8296D", GAME_NOT_WORKING | GAME_NO_SOUND) |