src/mess/machine/mtx.c
| r1590 | r1591 | |
| 37 | 37 | |
| 38 | 38 | static UINT8 key_sense;
|
| 39 | 39 | |
| 40 | | static UINT8 mtx_relcpmh;
|
| 41 | | static UINT8 mtx_rampage;
|
| 42 | | static UINT8 mtx_rompage;
|
| 43 | | |
| 44 | | static UINT8 *mtx_null_mem = NULL;
|
| 45 | | static UINT8 *mtx_zero_mem = NULL;
|
| 46 | | |
| 47 | 40 | static char mtx_prt_strobe = 0;
|
| 48 | 41 | static char mtx_prt_data = 0;
|
| 49 | 42 | |
| 50 | | static UINT8 *mtx_tape_buf = NULL;
|
| 51 | | static int mtx_tape_index = 0;
|
| 52 | | static char *mtx_tape_filename = NULL;
|
| 53 | 43 | |
| 54 | 44 | |
| 55 | | |
| 56 | 45 | /*************************************
|
| 57 | 46 | *
|
| 58 | 47 | * TMS9929A video chip
|
| r1590 | r1591 | |
| 61 | 50 | |
| 62 | 51 | static void mtx_tms9929a_interrupt(int data)
|
| 63 | 52 | {
|
| 64 | | // logerror ("tms9929a_interrupt: %d\n", data);
|
| 65 | 53 | z80ctc_0_trg0_w(0, data ? 0 : 1);
|
| 66 | 54 | }
|
| 67 | 55 | |
| r1590 | r1591 | |
| 88 | 76 | |
| 89 | 77 | SNAPSHOT_LOAD( mtx )
|
| 90 | 78 | {
|
| 91 | | UINT8 header[4];
|
| 92 | | |
| 93 | | /* get the header */
|
| 94 | | image_fread(image, &header, sizeof(header));
|
| 95 | | |
| 96 | 79 | return INIT_FAIL;
|
| 97 | 80 | }
|
| 98 | 81 | |
| r1590 | r1591 | |
| 278 | 261 | *
|
| 279 | 262 | *************************************/
|
| 280 | 263 | |
| 281 | | static void mtx_set_bank_offsets (unsigned int bank1, unsigned int bank2,
|
| 282 | | unsigned int bank3, unsigned int bank4,
|
| 283 | | unsigned int bank5, unsigned int bank6,
|
| 284 | | unsigned int bank7, unsigned int bank8)
|
| 285 | | {
|
| 286 | | UINT8 *romimage;
|
| 264 | /*
|
| 265 | There are two memory models on the MTX, the standard one and a
|
| 266 | CBM mode. In standard mode, the memory map is defined as:
|
| 287 | 267 | |
| 288 | | // logerror ("CPM %d RAM %x ROM %x\n", mtx_relcpmh,
|
| 289 | | // mtx_rampage, mtx_rompage);
|
| 290 | | // logerror ("map: [0000] %04x [2000] %04x [4000] %04x [6000] %04x\n",
|
| 291 | | // bank1, bank2, bank3, bank4);
|
| 292 | | // logerror (" [8000] %04x [a000] %04x [c000] %04x [e000] %04x\n",
|
| 293 | | // bank5, bank6, bank7, bank8);
|
| 268 | 0x0000 - 0x1fff OSROM
|
| 269 | 0x2000 - 0x3fff Paged ROM
|
| 270 | 0x4000 - 0x7fff Paged RAM
|
| 271 | 0x8000 - 0xbfff Paged RAM
|
| 272 | 0xc000 - 0xffff RAM
|
| 294 | 273 | |
| 295 | | romimage = memory_region(REGION_CPU1);
|
| 274 | Banks are selected by output port 0. Bits 0-3 define the RAM page
|
| 275 | and bits 4-6 the ROM page.
|
| 296 | 276 | |
| 297 | | if (mtx_relcpmh)
|
| 298 | | {
|
| 299 | | memory_set_bankptr (1, mess_ram + bank1);
|
| 300 | | // bank 9 is handled by the mtx_trap_write function
|
| 301 | | memory_set_bankptr (2, mess_ram + bank2);
|
| 302 | | memory_set_bankptr (10, mess_ram + bank2);
|
| 303 | | }
|
| 304 | | else
|
| 305 | | {
|
| 306 | | memory_set_bankptr (1, romimage + bank1);
|
| 307 | | // bank is 9 handled by the mtx_trap_write function
|
| 308 | | memory_set_bankptr (2, romimage + bank2);
|
| 309 | | memory_set_bankptr (10, mtx_null_mem);
|
| 310 | | }
|
| 277 | CBM mode is selected by bit 7 of output port 0. ROM is replaced
|
| 278 | by RAM in this mode.
|
| 279 | */
|
| 311 | 280 | |
| 312 | | if (bank3 < mess_ram_size)
|
| 313 | | {
|
| 314 | | memory_set_bankptr (3, mess_ram + bank3);
|
| 315 | | memory_set_bankptr (11, mess_ram + bank3);
|
| 316 | | }
|
| 317 | | else
|
| 318 | | {
|
| 319 | | memory_set_bankptr (3, mtx_null_mem);
|
| 320 | | memory_set_bankptr (11, mtx_zero_mem);
|
| 321 | | }
|
| 322 | | |
| 323 | | if (bank4 < mess_ram_size)
|
| 324 | | {
|
| 325 | | memory_set_bankptr (4, mess_ram + bank4);
|
| 326 | | memory_set_bankptr (12, mess_ram + bank4);
|
| 327 | | }
|
| 328 | | else
|
| 329 | | {
|
| 330 | | memory_set_bankptr (4, mtx_null_mem);
|
| 331 | | memory_set_bankptr (12, mtx_zero_mem);
|
| 332 | | }
|
| 333 | | |
| 334 | | if (bank5 < mess_ram_size)
|
| 335 | | {
|
| 336 | | memory_set_bankptr (5, mess_ram + bank5);
|
| 337 | | memory_set_bankptr (13, mess_ram + bank5);
|
| 338 | | }
|
| 339 | | else
|
| 340 | | {
|
| 341 | | memory_set_bankptr (5, mtx_null_mem);
|
| 342 | | memory_set_bankptr (13, mtx_zero_mem);
|
| 343 | | }
|
| 344 | | |
| 345 | | if (bank6 < mess_ram_size)
|
| 346 | | {
|
| 347 | | memory_set_bankptr (6, mess_ram + bank6);
|
| 348 | | memory_set_bankptr (14, mess_ram + bank6);
|
| 349 | | }
|
| 350 | | else
|
| 351 | | {
|
| 352 | | memory_set_bankptr (6, mtx_null_mem);
|
| 353 | | memory_set_bankptr (14, mtx_zero_mem);
|
| 354 | | }
|
| 355 | | |
| 356 | | memory_set_bankptr (7, mess_ram + bank7);
|
| 357 | | memory_set_bankptr (15, mess_ram + bank7);
|
| 358 | | |
| 359 | | memory_set_bankptr (8, mess_ram + bank8);
|
| 360 | | memory_set_bankptr (16, mess_ram + bank8);
|
| 361 | | }
|
| 362 | | |
| 363 | 281 | WRITE8_HANDLER( mtx_bankswitch_w )
|
| 364 | 282 | {
|
| 365 | | unsigned int bank1, bank2, bank3, bank4;
|
| 366 | | unsigned int bank5, bank6, bank7, bank8;
|
| 283 | // UINT8 cbm_mode = data >> 7 & 0x01;
|
| 284 | UINT8 rom_page = data >> 4 & 0x03;
|
| 285 | UINT8 ram_page = data >> 0 & 0x0f;
|
| 367 | 286 | |
| 368 | | mtx_relcpmh = (data & 0x80) >> 7;
|
| 369 | | mtx_rampage = (data & 0x0f);
|
| 370 | | mtx_rompage = (data & 0x70) >> 4;
|
| 287 | /* set rom bank (switches between basic and assembler rom or cartridges) */
|
| 288 | memory_set_bank(2, rom_page);
|
| 371 | 289 | |
| 372 | | if (mtx_relcpmh)
|
| 290 | /* set ram bank, for invalid pages a nop-handler will be installed */
|
| 291 | if (ram_page >= mess_ram_size/0x8000)
|
| 373 | 292 | {
|
| 374 | | bank1 = 0xe000 + mtx_rampage * 0xc000;
|
| 375 | | bank2 = 0xc000 + mtx_rampage * 0xc000;
|
| 376 | | bank3 = 0xa000 + mtx_rampage * 0xc000;
|
| 377 | | bank4 = 0x8000 + mtx_rampage * 0xc000;
|
| 378 | | bank5 = 0x6000 + mtx_rampage * 0xc000;
|
| 379 | | bank6 = 0x4000 + mtx_rampage * 0xc000;
|
| 293 | memory_install_readwrite8_handler(0, ADDRESS_SPACE_PROGRAM, 0x4000, 0x7fff, 0, 0, MRA8_NOP, MWA8_NOP);
|
| 294 | memory_install_readwrite8_handler(0, ADDRESS_SPACE_PROGRAM, 0x8000, 0xbfff, 0, 0, MRA8_NOP, MWA8_NOP);
|
| 380 | 295 | }
|
| 381 | | else
|
| 296 | else if (ram_page + 1 == mess_ram_size/0x8000)
|
| 382 | 297 | {
|
| 383 | | bank1 = 0x0;
|
| 384 | | bank2 = 0x2000 + mtx_rompage * 0x2000;
|
| 385 | | bank3 = 0xa000 + mtx_rampage * 0x8000;
|
| 386 | | bank4 = 0x8000 + mtx_rampage * 0x8000;
|
| 387 | | bank5 = 0x6000 + mtx_rampage * 0x8000;
|
| 388 | | bank6 = 0x4000 + mtx_rampage * 0x8000;
|
| 298 | memory_install_readwrite8_handler(0, ADDRESS_SPACE_PROGRAM, 0x4000, 0x7fff, 0, 0, MRA8_NOP, MWA8_NOP);
|
| 299 | memory_install_readwrite8_handler(0, ADDRESS_SPACE_PROGRAM, 0x8000, 0xbfff, 0, 0, MRA8_BANK4, MWA8_BANK4);
|
| 300 | memory_set_bank(4, ram_page);
|
| 389 | 301 | }
|
| 390 | | |
| 391 | | bank7 = 0x2000;
|
| 392 | | bank8 = 0x0;
|
| 393 | | |
| 394 | | mtx_set_bank_offsets (bank1, bank2, bank3, bank4,
|
| 395 | | bank5, bank6, bank7, bank8);
|
| 396 | | }
|
| 397 | | |
| 398 | | static void mtx_virt_to_phys (const char * what, int vaddress,
|
| 399 | | int * ramspace, int * paddress)
|
| 400 | | {
|
| 401 | | int offset = vaddress & 0x1fff;
|
| 402 | | int vbase = vaddress & ~0x1fff;
|
| 403 | | int pbase = 0x20000;
|
| 404 | | |
| 405 | | *ramspace = mtx_relcpmh || vaddress >= 0x4000;
|
| 406 | | |
| 407 | | if (0xc000 <= vaddress && vaddress < 0x10000)
|
| 408 | | pbase = 0xe000 - vbase;
|
| 409 | | else if (mtx_relcpmh)
|
| 410 | | pbase = 0xe000 - vbase + mtx_rampage * 0xc000;
|
| 411 | | else if (0 <= vaddress && vaddress < 0x2000)
|
| 412 | | pbase = 0;
|
| 413 | | else if (0x2000 <= vaddress && vaddress < 0x4000)
|
| 414 | | pbase = 0x2000 + mtx_rompage * 0x2000;
|
| 415 | | else if (0x4000 <= vaddress && vaddress < 0xc000)
|
| 416 | | pbase = (0xe000 - vbase) + mtx_rampage * 0x8000;
|
| 417 | | |
| 418 | | *paddress = pbase + offset;
|
| 419 | | |
| 420 | | // logerror ("%s (%d,%d,%d,%04x) -> (%d,%06x)\n", what,
|
| 421 | | // mtx_relcpmh, mtx_rompage, mtx_rampage, vaddress,
|
| 422 | | // *ramspace, *paddress);
|
| 423 | | }
|
| 424 | | |
| 425 | | |
| 426 | | |
| 427 | | /*************************************
|
| 428 | | *
|
| 429 | | * Tape hack
|
| 430 | | *
|
| 431 | | *************************************/
|
| 432 | | |
| 433 | | static UINT8 mtx_peek(int vaddress)
|
| 434 | | {
|
| 435 | | UINT8 * romimage;
|
| 436 | | int ramspace;
|
| 437 | | int paddress;
|
| 438 | | |
| 439 | | romimage = memory_region(REGION_CPU1);
|
| 440 | | mtx_virt_to_phys("peek", vaddress, &ramspace, &paddress);
|
| 441 | | |
| 442 | | if (paddress > mess_ram_size) {
|
| 443 | | logerror("peek into non-existing memory\n");
|
| 444 | | return 0;
|
| 445 | | }
|
| 446 | | |
| 447 | | if (ramspace)
|
| 448 | | return mess_ram[paddress];
|
| 449 | 302 | else
|
| 450 | | return romimage[paddress];
|
| 451 | | }
|
| 452 | | |
| 453 | | static void mtx_poke(int vaddress, UINT8 data)
|
| 454 | | {
|
| 455 | | int ramspace;
|
| 456 | | int paddress;
|
| 457 | | |
| 458 | | mtx_virt_to_phys ("poke", vaddress, &ramspace, &paddress);
|
| 459 | | if (!ramspace)
|
| 460 | | logerror ("poke into the ROM address space\n");
|
| 461 | | else if (paddress >= mess_ram_size)
|
| 462 | | logerror ("poke into non-existing RAM\n");
|
| 463 | | else
|
| 464 | | mess_ram[paddress] = data;
|
| 465 | | }
|
| 466 | | |
| 467 | | /*
|
| 468 | | * A filename is at most 14 characters long, always ending with a space.
|
| 469 | | * The save file can be at most 65536 long.
|
| 470 | | * Note: the empty string is saved as a single space.
|
| 471 | | */
|
| 472 | | static void mtx_save_hack(int start, int length)
|
| 473 | | {
|
| 474 | | mame_file * tape_file;
|
| 475 | | file_error filerr;
|
| 476 | | int bytes_saved;
|
| 477 | | int i;
|
| 478 | | |
| 479 | | assert(length <= 32768);
|
| 480 | | |
| 481 | | // logerror("mtx_save_hack: start=%#x length=%#x (%d) index=%#x (%d)\n",
|
| 482 | | // start, length, length, mtx_save_index, mtx_save_index);
|
| 483 | | |
| 484 | | if ((start > 0xc000) && (length == 20)) /* Save the header segment */
|
| 485 | 303 | {
|
| 486 | | for (i = 0; i < 18; i++)
|
| 487 | | mtx_tape_buf[i] = mtx_peek(start + i);
|
| 488 | | length = 18;
|
| 489 | | |
| 490 | | memcpy(mtx_tape_filename, mtx_tape_buf + 1, 15);
|
| 491 | | for (i = 14; i > 0 && mtx_tape_filename[i] == 0x20; i--)
|
| 492 | | ;
|
| 493 | | mtx_tape_filename[i + 1] = '\0';
|
| 494 | | mtx_tape_index = 0;
|
| 495 | | |
| 496 | | filerr = mame_fopen(SEARCHPATH_IMAGE, mtx_tape_filename,
|
| 497 | | OPEN_FLAG_WRITE|OPEN_FLAG_CREATE, &tape_file);
|
| 304 | memory_install_readwrite8_handler(0, ADDRESS_SPACE_PROGRAM, 0x4000, 0x7fff, 0, 0, MRA8_BANK3, MWA8_BANK3);
|
| 305 | memory_install_readwrite8_handler(0, ADDRESS_SPACE_PROGRAM, 0x8000, 0xbfff, 0, 0, MRA8_BANK4, MWA8_BANK4);
|
| 306 | memory_set_bank(3, ram_page);
|
| 307 | memory_set_bank(4, ram_page);
|
| 498 | 308 | }
|
| 499 | | else /* Save system variable, body, or variable store segment */
|
| 500 | | {
|
| 501 | | for (i = 0; i < length; i++)
|
| 502 | | mtx_tape_buf[i] = mtx_peek(start + i);
|
| 503 | | |
| 504 | | filerr = mame_fopen(SEARCHPATH_IMAGE, mtx_tape_filename,
|
| 505 | | OPEN_FLAG_WRITE, &tape_file);
|
| 506 | | }
|
| 507 | | |
| 508 | | if (filerr == FILERR_NONE)
|
| 509 | | {
|
| 510 | | mame_fseek(tape_file, mtx_tape_index, SEEK_SET);
|
| 511 | | bytes_saved = mame_fwrite(tape_file, mtx_tape_buf, length);
|
| 512 | | logerror("saved %d bytes from %d:%04x into '%s' at %d\n", bytes_saved,
|
| 513 | | mtx_rampage, start, mtx_tape_filename, mtx_tape_index);
|
| 514 | | if (length > bytes_saved)
|
| 515 | | logerror("wrote too few bytes from '%s'\n", mtx_tape_filename);
|
| 516 | | |
| 517 | | mame_fclose(tape_file);
|
| 518 | | mtx_tape_index += length;
|
| 519 | | }
|
| 520 | | else
|
| 521 | | logerror("cannot open '%s' for saving\n", mtx_tape_filename);
|
| 522 | 309 | }
|
| 523 | 310 | |
| 524 | | /*
|
| 525 | | * A filename is at most 14 characters long, ending with a space.
|
| 526 | | * At most 65536 bytes are loaded from the file.
|
| 527 | | * Note: the empty string is loaded as a single space (ugly),
|
| 528 | | * not the 'next' file.
|
| 529 | | */
|
| 530 | | static void mtx_load_hack(int start, int length)
|
| 531 | | {
|
| 532 | | mame_file * tape_file;
|
| 533 | | file_error filerr;
|
| 534 | | int bytes_loaded;
|
| 535 | | int i;
|
| 536 | 311 | |
| 537 | | assert(length <= 32768);
|
| 538 | 312 | |
| 539 | | // logerror("mtx_load_hack: start=%#x length=%#x (%d)\n", start, length, length);
|
| 540 | | |
| 541 | | if ((start > 0xc000) && (length == 18))
|
| 542 | | {
|
| 543 | | for (i = 0; i < 15; i++)
|
| 544 | | mtx_tape_filename[i] = mtx_peek(start - 0xf + i);
|
| 545 | | |
| 546 | | for (i = 14; i > 0 && mtx_tape_filename[i] == 0x20; i--)
|
| 547 | | ;
|
| 548 | | |
| 549 | | mtx_tape_filename[i+1] = '\0';
|
| 550 | | mtx_tape_index = 0;
|
| 551 | | }
|
| 552 | | |
| 553 | | filerr = mame_fopen(SEARCHPATH_IMAGE, mtx_tape_filename, OPEN_FLAG_READ,
|
| 554 | | &tape_file);
|
| 555 | | if (filerr == FILERR_NONE)
|
| 556 | | {
|
| 557 | | mame_fseek(tape_file, mtx_tape_index, SEEK_SET);
|
| 558 | | bytes_loaded = mame_fread(tape_file, mtx_tape_buf, length);
|
| 559 | | logerror("loaded %d bytes from '%s' at %d into %d:%04x\n", bytes_loaded,
|
| 560 | | mtx_tape_filename, mtx_tape_index, mtx_rampage, start);
|
| 561 | | if (length > bytes_loaded)
|
| 562 | | logerror("read too few bytes from '%s'\n", mtx_tape_filename);
|
| 563 | | |
| 564 | | for (i = 0; i < length; i++)
|
| 565 | | mtx_poke(start + i, mtx_tape_buf[i]);
|
| 566 | | |
| 567 | | mame_fclose(tape_file);
|
| 568 | | mtx_tape_index += length;
|
| 569 | | }
|
| 570 | | else
|
| 571 | | logerror("cannot open '%s' for loading\n", mtx_tape_filename);
|
| 572 | | }
|
| 573 | | |
| 574 | | static void mtx_verify_hack(int start, int length)
|
| 575 | | {
|
| 576 | | // logerror("mtx_verify_hack: start=0x%x, length=0x%x (%d) not implemented\n", start, length, length);
|
| 577 | | }
|
| 578 | | |
| 579 | | WRITE8_HANDLER( mtx_trap_write )
|
| 580 | | {
|
| 581 | | int pc;
|
| 582 | | int start;
|
| 583 | | int length;
|
| 584 | | |
| 585 | | if (mtx_relcpmh)
|
| 586 | | {
|
| 587 | | mtx_poke(offset, data);
|
| 588 | | return;
|
| 589 | | }
|
| 590 | | |
| 591 | | pc = activecpu_get_reg(Z80_PC);
|
| 592 | | if((offset == 0x0aae) && (pc == 0x0ab1))
|
| 593 | | {
|
| 594 | | start = activecpu_get_reg(Z80_HL);
|
| 595 | | length = activecpu_get_reg(Z80_DE);
|
| 596 | | |
| 597 | | // logerror("PC %04x\nStart %04x, Length %04x, 0xFD67 %02x, 0xFD68 %02x index 0x%04x\n", pc, start, length, mess_ram[0xfd67], mess_ram[0xfd68], mtx_tape_size);
|
| 598 | | |
| 599 | | if(mtx_peek(0xfd68) == 0)
|
| 600 | | mtx_save_hack(start, length);
|
| 601 | | else if(mtx_peek(0xfd67) == 0)
|
| 602 | | mtx_load_hack(start, length);
|
| 603 | | else
|
| 604 | | mtx_verify_hack(start, length);
|
| 605 | | }
|
| 606 | | }
|
| 607 | | |
| 608 | | |
| 609 | | |
| 610 | 313 | /*************************************
|
| 611 | 314 | *
|
| 612 | 315 | * Machine initialization
|
| 613 | 316 | *
|
| 614 | 317 | *************************************/
|
| 615 | 318 | |
| 616 | | MACHINE_START( mtx512 )
|
| 319 | DRIVER_INIT( mtx512 )
|
| 617 | 320 | {
|
| 618 | | UINT8 * romimage;
|
| 321 | /* configure memory */
|
| 322 | memory_set_bankptr(1, memory_region(REGION_USER1));
|
| 323 | memory_configure_bank(2, 0, 8, memory_region(REGION_USER2), 0x2000);
|
| 324 | memory_configure_bank(3, 0, mess_ram_size/0x4000/2, mess_ram, 0x4000);
|
| 325 | memory_configure_bank(4, 0, mess_ram_size/0x4000/2, mess_ram + mess_ram_size/2, 0x4000);
|
| 619 | 326 | |
| 327 | /* setup tms9928a */
|
| 620 | 328 | TMS9928A_configure(&tms9928a_interface);
|
| 621 | 329 | |
| 622 | | mtx_null_mem = (UINT8 *) auto_malloc (16384);
|
| 623 | | mtx_zero_mem = (UINT8 *) auto_malloc (16384);
|
| 624 | | memset (mtx_zero_mem, 0, 16384);
|
| 625 | | |
| 626 | | mtx_tape_buf = auto_malloc (32768);
|
| 627 | | mtx_tape_index = 0;
|
| 628 | | mtx_tape_filename = auto_malloc (16);
|
| 629 | | mtx_tape_filename[0] = 0;
|
| 630 | | |
| 330 | /* setup ctc */
|
| 631 | 331 | z80ctc_init(0, &mtx_ctc_intf);
|
| 632 | | |
| 633 | | // Patch the Rom (Sneaky........ Who needs to trap opcodes?)
|
| 634 | | romimage = memory_region(REGION_CPU1);
|
| 635 | | romimage[0x0aae] = 0x32; // ld ($0aae),a
|
| 636 | | romimage[0x0aaf] = 0xae;
|
| 637 | | romimage[0x0ab0] = 0x0a;
|
| 638 | | romimage[0x0ab1] = 0xc9; // ret
|
| 639 | | |
| 640 | | // Set up the starting memory configuration
|
| 641 | | mtx_relcpmh = 0;
|
| 642 | | mtx_rampage = 0;
|
| 643 | | mtx_rompage = 0;
|
| 644 | | mtx_set_bank_offsets (0, 0x2000, 0xa0000, 0x8000,
|
| 645 | | 0x6000, 0x4000, 0x2000, 0);
|
| 646 | 332 | }
|
| 647 | 333 | |
| 648 | 334 | DRIVER_INIT( rs128 )
|
| 649 | 335 | {
|
| 336 | driver_init_mtx512(machine);
|
| 337 | |
| 650 | 338 | z80dart_init(0, &mtx_dart_intf);
|
| 651 | 339 | |
| 652 | 340 | /* install handlers for dart interface */
|
src/mess/drivers/mtx.c
| r1590 | r1591 | |
| 5 | 5 | Memotech MTX 500, MTX 512 and RS 128 |
| 6 | 6 | |
| 7 | 7 | |
| 8 | | The memory address space of the MTX512 is divided into 8 banks, |
| 9 | | with a size of 8KB each. These banks are mapped differently based |
| 10 | | upon the memory model, selected ROM and RAM page, and the amount |
| 11 | | of available RAM memory. There are two memory models: a ROM-based |
| 12 | | model and a CPM model. The memory model, ROM, and RAM page are |
| 13 | | selected at IO port 0 (i.e., with out (0),a) |
| 14 | | |
| 15 | | 0x0000 - 0x1fff OSROM |
| 16 | | 0x2000 - 0x3fff Paged: Assembler ROM, Basic ROM or RAM |
| 17 | | 0x4000 - 0xbfff Paged: RAM |
| 18 | | 0xc000 - 0xffff RAM |
| 19 | | |
| 20 | | In the CPM model, all banks map to RAM memory. The available RAM |
| 21 | | is (again) allocated from top to bottom. Bank 8 and bank 7, always |
| 22 | | start at offset 0x0 and 0x2000, respectively. Bank 6, 5, 4, 3, 2, |
| 23 | | and 1 are mapped depending on the read-only memory register and |
| 24 | | the available memory. |
| 25 | | |
| 26 | | |
| 27 | | TODO: - Get rid of the tape hacks |
| 28 | | - Finish RS232 support |
| 8 | TODO: - Finish RS232 support |
| 9 | - Cartridge support |
| 29 | 10 | - Floppy disk emulation |
| 30 | 11 | - Hard disk emulation |
| 12 | - CBM mode |
| 31 | 13 | - "Silicon" disk emulation |
| 32 | 14 | - Multi Effect Video Wall emulation (maybe) |
| 33 | 15 | |
| r1590 | r1591 | |
| 58 | 40 | *************************************/ |
| 59 | 41 | |
| 60 | 42 | static ADDRESS_MAP_START( mtx_mem, ADDRESS_SPACE_PROGRAM, 8 ) |
| 61 | | AM_RANGE(0x0000, 0x1fff) AM_READWRITE(MRA8_BANK1, mtx_trap_write) |
| 62 | | AM_RANGE(0x2000, 0x3fff) AM_READWRITE(MRA8_BANK2, MWA8_BANK10) |
| 63 | | AM_RANGE(0x4000, 0x5fff) AM_READWRITE(MRA8_BANK3, MWA8_BANK11) |
| 64 | | AM_RANGE(0x6000, 0x7fff) AM_READWRITE(MRA8_BANK4, MWA8_BANK12) |
| 65 | | AM_RANGE(0x8000, 0x9fff) AM_READWRITE(MRA8_BANK5, MWA8_BANK13) |
| 66 | | AM_RANGE(0xa000, 0xbfff) AM_READWRITE(MRA8_BANK6, MWA8_BANK14) |
| 67 | | AM_RANGE(0xc000, 0xdfff) AM_READWRITE(MRA8_BANK7, MWA8_BANK15) |
| 68 | | AM_RANGE(0xe000, 0xffff) AM_READWRITE(MRA8_BANK8, MWA8_BANK16) |
| 43 | AM_RANGE(0x0000, 0x1fff) AM_ROMBANK(1) |
| 44 | AM_RANGE(0x2000, 0x3fff) AM_ROMBANK(2) |
| 45 | AM_RANGE(0x4000, 0x7fff) AM_RAMBANK(3) |
| 46 | AM_RANGE(0x8000, 0xbfff) AM_RAMBANK(4) |
| 47 | AM_RANGE(0xc000, 0xffff) AM_RAM |
| 69 | 48 | ADDRESS_MAP_END |
| 70 | 49 | |
| 71 | 50 | |
| r1590 | r1591 | |
| 249 | 228 | MDRV_CPU_IO_MAP(mtx_io, 0) |
| 250 | 229 | MDRV_CPU_VBLANK_INT(mtx_interrupt, 1) |
| 251 | 230 | MDRV_CPU_CONFIG(mtx_daisy_chain) |
| 252 | | MDRV_SCREEN_REFRESH_RATE(50) |
| 253 | | MDRV_SCREEN_VBLANK_TIME(DEFAULT_REAL_60HZ_VBLANK_DURATION) |
| 254 | 231 | |
| 255 | | MDRV_MACHINE_START( mtx512 ) |
| 256 | | |
| 257 | 232 | /* video hardware */ |
| 233 | MDRV_SCREEN_REFRESH_RATE(50) |
| 234 | MDRV_SCREEN_VBLANK_TIME(DEFAULT_REAL_60HZ_VBLANK_DURATION) |
| 258 | 235 | MDRV_IMPORT_FROM(tms9928a) |
| 259 | 236 | |
| 260 | 237 | /* sound hardware */ |
| r1590 | r1591 | |
| 278 | 255 | *************************************/ |
| 279 | 256 | |
| 280 | 257 | ROM_START( mtx512 ) |
| 281 | | ROM_REGION(0x12000, REGION_CPU1, 0) |
| 258 | ROM_REGION(0x02000, REGION_USER1, 0) |
| 282 | 259 | ROM_LOAD("osrom", 0x0000, 0x2000, CRC(9ca858cc) SHA1(3804503a58f0bcdea96bb6488833782ebd03976d)) |
| 283 | | ROM_LOAD("basicrom", 0x2000, 0x2000, CRC(87b4e59c) SHA1(c49782a82a7f068c1195cd967882ba9edd546eaf)) |
| 284 | | ROM_LOAD("assemrom", 0x4000, 0x2000, CRC(9d7538c3) SHA1(d1882c4ea61a68b1715bd634ded5603e18a99c5f)) |
| 260 | ROM_REGION(0x10000, REGION_USER2, 0) |
| 261 | ROM_LOAD("basicrom", 0x0000, 0x2000, CRC(87b4e59c) SHA1(c49782a82a7f068c1195cd967882ba9edd546eaf)) |
| 262 | ROM_LOAD("assemrom", 0x2000, 0x2000, CRC(9d7538c3) SHA1(d1882c4ea61a68b1715bd634ded5603e18a99c5f)) |
| 263 | ROM_FILL( 0x4000, 0xc000, 0xff) |
| 285 | 264 | ROM_END |
| 286 | 265 | |
| 287 | 266 | |
| r1590 | r1591 | |
| 374 | 353 | *************************************/ |
| 375 | 354 | |
| 376 | 355 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG, COMPANY FULLNAME FLAGS */ |
| 377 | | COMP( 1983, mtx512, 0, 0, mtx512, mtx512, 0, mtx512, "Memotech Ltd.", "MTX 512", 0 ) |
| 378 | | COMP( 1983, mtx500, mtx512, 0, mtx512, mtx512, 0, mtx500, "Memotech Ltd.", "MTX 500", 0 ) |
| 356 | COMP( 1983, mtx512, 0, 0, mtx512, mtx512, mtx512, mtx512, "Memotech Ltd.", "MTX 512", 0 ) |
| 357 | COMP( 1983, mtx500, mtx512, 0, mtx512, mtx512, mtx512, mtx500, "Memotech Ltd.", "MTX 500", 0 ) |
| 379 | 358 | COMP( 1984, rs128, mtx512, 0, rs128, mtx512, rs128, rs128, "Memotech Ltd.", "RS 128", 0 ) |