src/mess/machine/msx_slot.c
| r9705 | r9706 | |
| 30 | 30 | |
| 31 | 31 | static void msx_cpu_setbank (running_machine *machine, int page, UINT8 *mem) |
| 32 | 32 | { |
| 33 | msx_state *state = machine->driver_data<msx_state>(); |
| 33 | 34 | address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 34 | 35 | switch (page) |
| 35 | 36 | { |
| r9705 | r9706 | |
| 62 | 63 | break; |
| 63 | 64 | case 8: |
| 64 | 65 | memory_set_bankptr (machine,"bank11", mem); |
| 65 | | msx1.top_page = mem; |
| 66 | state->top_page = mem; |
| 66 | 67 | break; |
| 67 | 68 | } |
| 68 | 69 | } |
| r9705 | r9706 | |
| 81 | 82 | |
| 82 | 83 | MSX_SLOT_MAP(empty) |
| 83 | 84 | { |
| 84 | | msx_cpu_setbank (machine, page * 2 + 1, msx1.empty); |
| 85 | | msx_cpu_setbank (machine, page * 2 + 2, msx1.empty); |
| 85 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 86 | msx_cpu_setbank (machine, page * 2 + 1, drvstate->empty); |
| 87 | msx_cpu_setbank (machine, page * 2 + 2, drvstate->empty); |
| 86 | 88 | } |
| 87 | 89 | |
| 88 | 90 | MSX_SLOT_INIT(rom) |
| r9705 | r9706 | |
| 121 | 123 | |
| 122 | 124 | MSX_SLOT_MAP(ram) |
| 123 | 125 | { |
| 126 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 124 | 127 | UINT8 *mem = state->mem + (page - state->start_page) * 0x4000; |
| 125 | 128 | |
| 126 | | msx1.ram_pages[page] = mem; |
| 129 | drvstate->ram_pages[page] = mem; |
| 127 | 130 | msx_cpu_setbank (machine, page * 2 + 1, mem); |
| 128 | 131 | msx_cpu_setbank (machine, page * 2 + 2, mem + 0x2000); |
| 129 | 132 | } |
| r9705 | r9706 | |
| 179 | 182 | |
| 180 | 183 | MSX_SLOT_RESET(rammm) |
| 181 | 184 | { |
| 185 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 182 | 186 | int i; |
| 183 | 187 | |
| 184 | 188 | for (i=0; i<4; i++) |
| 185 | 189 | { |
| 186 | | msx1.ram_mapper[i] = 3 - i; |
| 190 | drvstate->ram_mapper[i] = 3 - i; |
| 187 | 191 | } |
| 188 | 192 | } |
| 189 | 193 | |
| 190 | 194 | MSX_SLOT_MAP(rammm) |
| 191 | 195 | { |
| 196 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 192 | 197 | UINT8 *mem = state->mem + |
| 193 | | 0x4000 * (msx1.ram_mapper[page] & state->bank_mask); |
| 198 | 0x4000 * (drvstate->ram_mapper[page] & state->bank_mask); |
| 194 | 199 | |
| 195 | | msx1.ram_pages[page] = mem; |
| 200 | drvstate->ram_pages[page] = mem; |
| 196 | 201 | msx_cpu_setbank (machine, page * 2 + 1, mem); |
| 197 | 202 | msx_cpu_setbank (machine, page * 2 + 2, mem + 0x2000); |
| 198 | 203 | } |
| r9705 | r9706 | |
| 218 | 223 | |
| 219 | 224 | MSX_SLOT_MAP(msxdos2) |
| 220 | 225 | { |
| 226 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 221 | 227 | if (page != 1) |
| 222 | 228 | { |
| 223 | | msx_cpu_setbank (machine, page * 2 + 1, msx1.empty); |
| 224 | | msx_cpu_setbank (machine, page * 2 + 2, msx1.empty); |
| 229 | msx_cpu_setbank (machine, page * 2 + 1, drvstate->empty); |
| 230 | msx_cpu_setbank (machine, page * 2 + 2, drvstate->empty); |
| 225 | 231 | } |
| 226 | 232 | else |
| 227 | 233 | { |
| r9705 | r9706 | |
| 294 | 300 | |
| 295 | 301 | MSX_SLOT_WRITE(konami) |
| 296 | 302 | { |
| 303 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 297 | 304 | switch (addr) |
| 298 | 305 | { |
| 299 | 306 | case 0x6000: |
| 300 | 307 | state->banks[1] = val & state->bank_mask; |
| 301 | 308 | slot_konami_map (machine, state, 1); |
| 302 | | if (msx1.state[0] == state) |
| 309 | if (drvstate->state[0] == state) |
| 303 | 310 | { |
| 304 | 311 | slot_konami_map (machine, state, 0); |
| 305 | 312 | } |
| r9705 | r9706 | |
| 307 | 314 | case 0x8000: |
| 308 | 315 | state->banks[2] = val & state->bank_mask; |
| 309 | 316 | slot_konami_map (machine, state, 2); |
| 310 | | if (msx1.state[3] == state) |
| 317 | if (drvstate->state[3] == state) |
| 311 | 318 | { |
| 312 | 319 | slot_konami_map (machine, state, 3); |
| 313 | 320 | } |
| r9705 | r9706 | |
| 315 | 322 | case 0xa000: |
| 316 | 323 | state->banks[3] = val & state->bank_mask; |
| 317 | 324 | slot_konami_map (machine, state, 2); |
| 318 | | if (msx1.state[3] == state) |
| 325 | if (drvstate->state[3] == state) |
| 319 | 326 | { |
| 320 | 327 | slot_konami_map (machine, state, 3); |
| 321 | 328 | } |
| r9705 | r9706 | |
| 402 | 409 | |
| 403 | 410 | MSX_SLOT_WRITE(konami_scc) |
| 404 | 411 | { |
| 412 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 405 | 413 | address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 406 | 414 | if (addr >= 0x5000 && addr < 0x5800) |
| 407 | 415 | { |
| 408 | 416 | state->banks[0] = val & state->bank_mask; |
| 409 | 417 | slot_konami_scc_map (machine, state, 1); |
| 410 | | if (msx1.state[3] == state) |
| 418 | if (drvstate->state[3] == state) |
| 411 | 419 | { |
| 412 | 420 | slot_konami_scc_map (machine, state, 3); |
| 413 | 421 | } |
| r9705 | r9706 | |
| 416 | 424 | { |
| 417 | 425 | state->banks[1] = val & state->bank_mask; |
| 418 | 426 | slot_konami_scc_map (machine, state, 1); |
| 419 | | if (msx1.state[3] == state) |
| 427 | if (drvstate->state[3] == state) |
| 420 | 428 | { |
| 421 | 429 | slot_konami_scc_map (machine, state, 3); |
| 422 | 430 | } |
| r9705 | r9706 | |
| 426 | 434 | state->banks[2] = val & state->bank_mask; |
| 427 | 435 | state->cart.scc.active = ((val & 0x3f) == 0x3f); |
| 428 | 436 | slot_konami_scc_map (machine, state, 2); |
| 429 | | if (msx1.state[0] == state) |
| 437 | if (drvstate->state[0] == state) |
| 430 | 438 | { |
| 431 | 439 | slot_konami_scc_map (machine, state, 0); |
| 432 | 440 | } |
| r9705 | r9706 | |
| 467 | 475 | { |
| 468 | 476 | state->banks[3] = val & state->bank_mask; |
| 469 | 477 | slot_konami_scc_map (machine, state, 2); |
| 470 | | if (msx1.state[0] == state) |
| 478 | if (drvstate->state[0] == state) |
| 471 | 479 | { |
| 472 | 480 | slot_konami_scc_map (machine, state, 0); |
| 473 | 481 | } |
| r9705 | r9706 | |
| 507 | 515 | |
| 508 | 516 | MSX_SLOT_MAP(ascii8) |
| 509 | 517 | { |
| 518 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 510 | 519 | switch (page) |
| 511 | 520 | { |
| 512 | 521 | case 0: |
| 513 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 514 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 522 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 523 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 515 | 524 | break; |
| 516 | 525 | case 1: |
| 517 | 526 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x2000); |
| r9705 | r9706 | |
| 522 | 531 | msx_cpu_setbank (machine, 6, state->mem + state->banks[3] * 0x2000); |
| 523 | 532 | break; |
| 524 | 533 | case 3: |
| 525 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 526 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 534 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 535 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 527 | 536 | } |
| 528 | 537 | } |
| 529 | 538 | |
| 530 | 539 | MSX_SLOT_WRITE(ascii8) |
| 531 | 540 | { |
| 541 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 532 | 542 | int bank; |
| 533 | 543 | |
| 534 | 544 | if (addr >= 0x6000 && addr < 0x8000) |
| r9705 | r9706 | |
| 540 | 550 | { |
| 541 | 551 | slot_ascii8_map (machine, state, 1); |
| 542 | 552 | } |
| 543 | | else if (msx1.state[2] == state) |
| 553 | else if (drvstate->state[2] == state) |
| 544 | 554 | { |
| 545 | 555 | slot_ascii8_map (machine, state, 2); |
| 546 | 556 | } |
| r9705 | r9706 | |
| 580 | 590 | |
| 581 | 591 | MSX_SLOT_MAP(ascii16) |
| 582 | 592 | { |
| 593 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 583 | 594 | UINT8 *mem; |
| 584 | 595 | |
| 585 | 596 | switch (page) |
| 586 | 597 | { |
| 587 | 598 | case 0: |
| 588 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 589 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 599 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 600 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 590 | 601 | break; |
| 591 | 602 | case 1: |
| 592 | 603 | mem = state->mem + state->banks[0] * 0x4000; |
| r9705 | r9706 | |
| 599 | 610 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 600 | 611 | break; |
| 601 | 612 | case 3: |
| 602 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 603 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 613 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 614 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 604 | 615 | } |
| 605 | 616 | } |
| 606 | 617 | |
| 607 | 618 | MSX_SLOT_WRITE(ascii16) |
| 608 | 619 | { |
| 620 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 609 | 621 | if (addr >= 0x6000 && addr < 0x6800) |
| 610 | 622 | { |
| 611 | 623 | state->banks[0] = val & state->bank_mask; |
| r9705 | r9706 | |
| 614 | 626 | else if (addr >= 0x7000 && addr < 0x7800) |
| 615 | 627 | { |
| 616 | 628 | state->banks[1] = val & state->bank_mask; |
| 617 | | if (msx1.state[2] == state) |
| 629 | if (drvstate->state[2] == state) |
| 618 | 630 | { |
| 619 | 631 | slot_ascii16_map (machine, state, 2); |
| 620 | 632 | } |
| r9705 | r9706 | |
| 661 | 673 | for (i=0; i<4; i++) state->banks[i] = i; |
| 662 | 674 | } |
| 663 | 675 | |
| 664 | | static UINT8 *ascii8_sram_bank_select (slot_state *state, int bankno) |
| 676 | static UINT8 *ascii8_sram_bank_select (msx_state *drvstate, slot_state *state, int bankno) |
| 665 | 677 | { |
| 666 | 678 | int bank = state->banks[bankno]; |
| 667 | 679 | |
| 668 | 680 | if (bank & state->cart.sram.empty_mask) |
| 669 | 681 | { |
| 670 | | return msx1.empty; |
| 682 | return drvstate->empty; |
| 671 | 683 | } |
| 672 | 684 | else if (bank & state->cart.sram.sram_mask) |
| 673 | 685 | { |
| r9705 | r9706 | |
| 681 | 693 | |
| 682 | 694 | MSX_SLOT_MAP(ascii8_sram) |
| 683 | 695 | { |
| 696 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 684 | 697 | switch (page) |
| 685 | 698 | { |
| 686 | 699 | case 0: |
| 687 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 688 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 700 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 701 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 689 | 702 | break; |
| 690 | 703 | case 1: |
| 691 | | msx_cpu_setbank (machine, 3, ascii8_sram_bank_select (state, 0)); |
| 692 | | msx_cpu_setbank (machine, 4, ascii8_sram_bank_select (state, 1)); |
| 704 | msx_cpu_setbank (machine, 3, ascii8_sram_bank_select (drvstate, state, 0)); |
| 705 | msx_cpu_setbank (machine, 4, ascii8_sram_bank_select (drvstate, state, 1)); |
| 693 | 706 | break; |
| 694 | 707 | case 2: |
| 695 | | msx_cpu_setbank (machine, 5, ascii8_sram_bank_select (state, 2)); |
| 696 | | msx_cpu_setbank (machine, 6, ascii8_sram_bank_select (state, 3)); |
| 708 | msx_cpu_setbank (machine, 5, ascii8_sram_bank_select (drvstate, state, 2)); |
| 709 | msx_cpu_setbank (machine, 6, ascii8_sram_bank_select (drvstate, state, 3)); |
| 697 | 710 | break; |
| 698 | 711 | case 3: |
| 699 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 700 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 712 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 713 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 701 | 714 | } |
| 702 | 715 | } |
| 703 | 716 | |
| 704 | 717 | MSX_SLOT_WRITE(ascii8_sram) |
| 705 | 718 | { |
| 719 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 706 | 720 | int bank; |
| 707 | 721 | |
| 708 | 722 | if (addr >= 0x6000 && addr < 0x8000) |
| r9705 | r9706 | |
| 714 | 728 | { |
| 715 | 729 | slot_ascii8_sram_map (machine, state, 1); |
| 716 | 730 | } |
| 717 | | else if (msx1.state[2] == state) |
| 731 | else if (drvstate->state[2] == state) |
| 718 | 732 | { |
| 719 | 733 | slot_ascii8_sram_map (machine, state, 2); |
| 720 | 734 | } |
| r9705 | r9706 | |
| 827 | 841 | for (i=0; i<2; i++) state->banks[i] = i; |
| 828 | 842 | } |
| 829 | 843 | |
| 830 | | static UINT8 *ascii16_sram_bank_select (slot_state *state, int bankno) |
| 844 | static UINT8 *ascii16_sram_bank_select (msx_state *drvstate, slot_state *state, int bankno) |
| 831 | 845 | { |
| 832 | 846 | int bank = state->banks[bankno]; |
| 833 | 847 | |
| 834 | 848 | if (bank & state->cart.sram.empty_mask) |
| 835 | 849 | { |
| 836 | | return msx1.empty; |
| 850 | return drvstate->empty; |
| 837 | 851 | } |
| 838 | 852 | else if (bank & state->cart.sram.sram_mask) |
| 839 | 853 | { |
| r9705 | r9706 | |
| 847 | 861 | |
| 848 | 862 | MSX_SLOT_MAP(ascii16_sram) |
| 849 | 863 | { |
| 864 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 850 | 865 | UINT8 *mem; |
| 851 | 866 | |
| 852 | 867 | switch (page) |
| 853 | 868 | { |
| 854 | 869 | case 0: |
| 855 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 856 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 870 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 871 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 857 | 872 | break; |
| 858 | 873 | case 1: |
| 859 | | mem = ascii16_sram_bank_select (state, 0); |
| 874 | mem = ascii16_sram_bank_select (drvstate, state, 0); |
| 860 | 875 | msx_cpu_setbank (machine, 3, mem); |
| 861 | 876 | msx_cpu_setbank (machine, 4, mem + 0x2000); |
| 862 | 877 | break; |
| 863 | 878 | case 2: |
| 864 | | mem = ascii16_sram_bank_select (state, 1); |
| 879 | mem = ascii16_sram_bank_select (drvstate, state, 1); |
| 865 | 880 | msx_cpu_setbank (machine, 5, mem); |
| 866 | 881 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 867 | 882 | break; |
| 868 | 883 | case 3: |
| 869 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 870 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 884 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 885 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 871 | 886 | } |
| 872 | 887 | } |
| 873 | 888 | |
| 874 | 889 | MSX_SLOT_WRITE(ascii16_sram) |
| 875 | 890 | { |
| 891 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 876 | 892 | if (addr >= 0x6000 && addr < 0x6800) |
| 877 | 893 | { |
| 878 | 894 | state->banks[0] = val; |
| r9705 | r9706 | |
| 881 | 897 | else if (addr >= 0x7000 && addr < 0x7800) |
| 882 | 898 | { |
| 883 | 899 | state->banks[1] = val; |
| 884 | | if (msx1.state[2] == state) |
| 900 | if (drvstate->state[2] == state) |
| 885 | 901 | { |
| 886 | 902 | slot_ascii16_sram_map (machine, state, 2); |
| 887 | 903 | } |
| r9705 | r9706 | |
| 994 | 1010 | |
| 995 | 1011 | MSX_SLOT_MAP(rtype) |
| 996 | 1012 | { |
| 1013 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 997 | 1014 | UINT8 *mem; |
| 998 | 1015 | |
| 999 | 1016 | switch (page) |
| 1000 | 1017 | { |
| 1001 | 1018 | case 0: |
| 1002 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1003 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1019 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 1020 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 1004 | 1021 | break; |
| 1005 | 1022 | case 1: |
| 1006 | 1023 | mem = state->mem + 15 * 0x4000; |
| r9705 | r9706 | |
| 1013 | 1030 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 1014 | 1031 | break; |
| 1015 | 1032 | case 3: |
| 1016 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1017 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1033 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 1034 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 1018 | 1035 | } |
| 1019 | 1036 | } |
| 1020 | 1037 | |
| 1021 | 1038 | MSX_SLOT_WRITE(rtype) |
| 1022 | 1039 | { |
| 1040 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1023 | 1041 | if (addr >= 0x7000 && addr < 0x8000) |
| 1024 | 1042 | { |
| 1025 | 1043 | int data ; |
| r9705 | r9706 | |
| 1033 | 1051 | data = val & 0x0f; |
| 1034 | 1052 | } |
| 1035 | 1053 | state->banks[0] = data; |
| 1036 | | if (msx1.state[2] == state) |
| 1054 | if (drvstate->state[2] == state) |
| 1037 | 1055 | { |
| 1038 | 1056 | slot_rtype_map (machine, state, 2); |
| 1039 | 1057 | } |
| r9705 | r9706 | |
| 1118 | 1136 | |
| 1119 | 1137 | MSX_SLOT_WRITE(gmaster2) |
| 1120 | 1138 | { |
| 1139 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1121 | 1140 | if (addr >= 0x6000 && addr < 0x7000) |
| 1122 | 1141 | { |
| 1123 | 1142 | if (val & 0x10) |
| r9705 | r9706 | |
| 1130 | 1149 | } |
| 1131 | 1150 | state->banks[1] = val; |
| 1132 | 1151 | slot_gmaster2_map (machine, state, 1); |
| 1133 | | if (msx1.state[0] == state) |
| 1152 | if (drvstate->state[0] == state) |
| 1134 | 1153 | { |
| 1135 | 1154 | slot_gmaster2_map (machine, state, 0); |
| 1136 | 1155 | } |
| r9705 | r9706 | |
| 1147 | 1166 | } |
| 1148 | 1167 | state->banks[2] = val; |
| 1149 | 1168 | slot_gmaster2_map (machine, state, 2); |
| 1150 | | if (msx1.state[3] == state) |
| 1169 | if (drvstate->state[3] == state) |
| 1151 | 1170 | { |
| 1152 | 1171 | slot_gmaster2_map (machine, state, 3); |
| 1153 | 1172 | } |
| r9705 | r9706 | |
| 1164 | 1183 | } |
| 1165 | 1184 | state->banks[3] = val; |
| 1166 | 1185 | slot_gmaster2_map (machine, state, 2); |
| 1167 | | if (msx1.state[3] == state) |
| 1186 | if (drvstate->state[3] == state) |
| 1168 | 1187 | { |
| 1169 | 1188 | slot_gmaster2_map (machine, state, 3); |
| 1170 | 1189 | } |
| r9705 | r9706 | |
| 1258 | 1277 | |
| 1259 | 1278 | static READ8_HANDLER (msx_diskrom_page1_r) |
| 1260 | 1279 | { |
| 1280 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1261 | 1281 | running_device *fdc = space->machine->device("wd179x"); |
| 1262 | 1282 | switch (offset) |
| 1263 | 1283 | { |
| r9705 | r9706 | |
| 1265 | 1285 | case 1: return wd17xx_track_r (fdc, 0); |
| 1266 | 1286 | case 2: return wd17xx_sector_r (fdc, 0); |
| 1267 | 1287 | case 3: return wd17xx_data_r (fdc, 0); |
| 1268 | | case 7: return msx1.dsk_stat; |
| 1288 | case 7: return state->dsk_stat; |
| 1269 | 1289 | default: |
| 1270 | | return msx1.state[1]->mem[offset + 0x3ff8]; |
| 1290 | return state->state[1]->mem[offset + 0x3ff8]; |
| 1271 | 1291 | } |
| 1272 | 1292 | } |
| 1273 | 1293 | |
| 1274 | 1294 | static READ8_HANDLER (msx_diskrom_page2_r) |
| 1275 | 1295 | { |
| 1296 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1276 | 1297 | running_device *fdc = space->machine->device("wd179x"); |
| 1277 | 1298 | if (offset >= 0x7f8) |
| 1278 | 1299 | { |
| r9705 | r9706 | |
| 1287 | 1308 | case 0x7fb: |
| 1288 | 1309 | return wd17xx_data_r (fdc, 0); |
| 1289 | 1310 | case 0x7ff: |
| 1290 | | return msx1.dsk_stat; |
| 1311 | return state->dsk_stat; |
| 1291 | 1312 | default: |
| 1292 | | return msx1.state[2]->mem[offset + 0x3800]; |
| 1313 | return state->state[2]->mem[offset + 0x3800]; |
| 1293 | 1314 | } |
| 1294 | 1315 | } |
| 1295 | 1316 | else |
| r9705 | r9706 | |
| 1300 | 1321 | |
| 1301 | 1322 | MSX_SLOT_MAP(diskrom) |
| 1302 | 1323 | { |
| 1324 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1303 | 1325 | address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 1304 | 1326 | switch (page) |
| 1305 | 1327 | { |
| 1306 | 1328 | case 0: |
| 1307 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1308 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1329 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 1330 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 1309 | 1331 | break; |
| 1310 | 1332 | case 1: |
| 1311 | 1333 | msx_cpu_setbank (machine, 3, state->mem); |
| r9705 | r9706 | |
| 1313 | 1335 | memory_install_read8_handler(space, 0x7ff8, 0x7fff, 0, 0, msx_diskrom_page1_r); |
| 1314 | 1336 | break; |
| 1315 | 1337 | case 2: |
| 1316 | | msx_cpu_setbank (machine, 5, msx1.empty); |
| 1317 | | msx_cpu_setbank (machine, 6, msx1.empty); |
| 1338 | msx_cpu_setbank (machine, 5, drvstate->empty); |
| 1339 | msx_cpu_setbank (machine, 6, drvstate->empty); |
| 1318 | 1340 | memory_install_read8_handler(space, 0xb800, 0xbfff, 0, 0, msx_diskrom_page2_r); |
| 1319 | 1341 | break; |
| 1320 | 1342 | case 3: |
| 1321 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1322 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1343 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 1344 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 1323 | 1345 | break; |
| 1324 | 1346 | } |
| 1325 | 1347 | } |
| r9705 | r9706 | |
| 1383 | 1405 | |
| 1384 | 1406 | static READ8_HANDLER (msx_diskrom2_page1_r) |
| 1385 | 1407 | { |
| 1408 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1386 | 1409 | running_device *fdc = space->machine->device("wd179x"); |
| 1387 | 1410 | switch (offset) |
| 1388 | 1411 | { |
| r9705 | r9706 | |
| 1390 | 1413 | case 1: return wd17xx_track_r(fdc, 0); |
| 1391 | 1414 | case 2: return wd17xx_sector_r(fdc, 0); |
| 1392 | 1415 | case 3: return wd17xx_data_r(fdc, 0); |
| 1393 | | case 4: return msx1.dsk_stat; |
| 1416 | case 4: return state->dsk_stat; |
| 1394 | 1417 | default: |
| 1395 | | return msx1.state[1]->mem[offset + 0x3ff8]; |
| 1418 | return state->state[1]->mem[offset + 0x3ff8]; |
| 1396 | 1419 | } |
| 1397 | 1420 | } |
| 1398 | 1421 | |
| 1399 | 1422 | static READ8_HANDLER (msx_diskrom2_page2_r) |
| 1400 | 1423 | { |
| 1424 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1401 | 1425 | running_device *fdc = space->machine->device("wd179x"); |
| 1402 | 1426 | if (offset >= 0x7b8) |
| 1403 | 1427 | { |
| r9705 | r9706 | |
| 1412 | 1436 | case 0x7bb: |
| 1413 | 1437 | return wd17xx_data_r (fdc, 0); |
| 1414 | 1438 | case 0x7bc: |
| 1415 | | return msx1.dsk_stat; |
| 1439 | return state->dsk_stat; |
| 1416 | 1440 | default: |
| 1417 | | return msx1.state[2]->mem[offset + 0x3800]; |
| 1441 | return state->state[2]->mem[offset + 0x3800]; |
| 1418 | 1442 | } |
| 1419 | 1443 | } |
| 1420 | 1444 | else |
| r9705 | r9706 | |
| 1425 | 1449 | |
| 1426 | 1450 | MSX_SLOT_MAP(diskrom2) |
| 1427 | 1451 | { |
| 1452 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1428 | 1453 | address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 1429 | 1454 | switch (page) |
| 1430 | 1455 | { |
| 1431 | 1456 | case 0: |
| 1432 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1433 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1457 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 1458 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 1434 | 1459 | break; |
| 1435 | 1460 | case 1: |
| 1436 | 1461 | msx_cpu_setbank (machine, 3, state->mem); |
| r9705 | r9706 | |
| 1438 | 1463 | memory_install_read8_handler(space, 0x7fb8, 0x7fbc, 0, 0, msx_diskrom2_page1_r); |
| 1439 | 1464 | break; |
| 1440 | 1465 | case 2: |
| 1441 | | msx_cpu_setbank (machine, 5, msx1.empty); |
| 1442 | | msx_cpu_setbank (machine, 6, msx1.empty); |
| 1466 | msx_cpu_setbank (machine, 5, drvstate->empty); |
| 1467 | msx_cpu_setbank (machine, 6, drvstate->empty); |
| 1443 | 1468 | memory_install_read8_handler(space, 0xb800, 0xbfbc, 0, 0, msx_diskrom2_page2_r); |
| 1444 | 1469 | break; |
| 1445 | 1470 | case 3: |
| 1446 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1447 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1471 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 1472 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 1448 | 1473 | } |
| 1449 | 1474 | } |
| 1450 | 1475 | |
| r9705 | r9706 | |
| 1503 | 1528 | |
| 1504 | 1529 | MSX_SLOT_MAP(synthesizer) |
| 1505 | 1530 | { |
| 1531 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1506 | 1532 | switch (page) |
| 1507 | 1533 | { |
| 1508 | 1534 | case 0: |
| 1509 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1510 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1535 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 1536 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 1511 | 1537 | break; |
| 1512 | 1538 | case 1: |
| 1513 | 1539 | msx_cpu_setbank (machine, 3, state->mem); |
| r9705 | r9706 | |
| 1518 | 1544 | msx_cpu_setbank (machine, 6, state->mem + 0x6000); |
| 1519 | 1545 | break; |
| 1520 | 1546 | case 3: |
| 1521 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1522 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1547 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 1548 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 1523 | 1549 | } |
| 1524 | 1550 | } |
| 1525 | 1551 | |
| r9705 | r9706 | |
| 1581 | 1607 | |
| 1582 | 1608 | MSX_SLOT_WRITE(majutsushi) |
| 1583 | 1609 | { |
| 1610 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1584 | 1611 | if (addr >= 0x5000 && addr < 0x6000) |
| 1585 | 1612 | { |
| 1586 | 1613 | dac_data_w (machine->device("dac"), val); |
| r9705 | r9706 | |
| 1589 | 1616 | { |
| 1590 | 1617 | state->banks[1] = val & 0x0f; |
| 1591 | 1618 | slot_majutsushi_map (machine, state, 1); |
| 1592 | | if (msx1.state[0] == state) |
| 1619 | if (drvstate->state[0] == state) |
| 1593 | 1620 | { |
| 1594 | 1621 | slot_konami_map (machine, state, 0); |
| 1595 | 1622 | } |
| r9705 | r9706 | |
| 1598 | 1625 | { |
| 1599 | 1626 | state->banks[addr < 0xa000 ? 2 : 3] = val & 0x0f; |
| 1600 | 1627 | slot_majutsushi_map (machine, state, 2); |
| 1601 | | if (msx1.state[3] == state) |
| 1628 | if (drvstate->state[3] == state) |
| 1602 | 1629 | { |
| 1603 | 1630 | slot_konami_map (machine, state, 3); |
| 1604 | 1631 | } |
| r9705 | r9706 | |
| 1651 | 1678 | |
| 1652 | 1679 | MSX_SLOT_RESET(fmpac) |
| 1653 | 1680 | { |
| 1681 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1654 | 1682 | int i; |
| 1655 | 1683 | |
| 1656 | 1684 | state->banks[0] = 0; |
| 1657 | 1685 | state->cart.fmpac.sram_active = 0; |
| 1658 | 1686 | state->cart.fmpac.opll_active = 0; |
| 1659 | | msx1.opll_active = 0; |
| 1687 | drvstate->opll_active = 0; |
| 1660 | 1688 | for (i=0; i<=state->bank_mask; i++) |
| 1661 | 1689 | { |
| 1662 | 1690 | state->mem[0x3ff6 + i * 0x4000] = 0; |
| r9705 | r9706 | |
| 1674 | 1702 | |
| 1675 | 1703 | MSX_SLOT_MAP(fmpac) |
| 1676 | 1704 | { |
| 1705 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1677 | 1706 | if (page == 1) |
| 1678 | 1707 | { |
| 1679 | 1708 | if (state->cart.fmpac.sram_active) |
| r9705 | r9706 | |
| 1689 | 1718 | } |
| 1690 | 1719 | else |
| 1691 | 1720 | { |
| 1692 | | msx_cpu_setbank (machine, page * 2 + 1, msx1.empty); |
| 1693 | | msx_cpu_setbank (machine, page * 2 + 2, msx1.empty); |
| 1721 | msx_cpu_setbank (machine, page * 2 + 1, drvstate->empty); |
| 1722 | msx_cpu_setbank (machine, page * 2 + 2, drvstate->empty); |
| 1694 | 1723 | } |
| 1695 | 1724 | } |
| 1696 | 1725 | |
| 1697 | 1726 | MSX_SLOT_WRITE(fmpac) |
| 1698 | 1727 | { |
| 1728 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1699 | 1729 | address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 1700 | 1730 | int i, data; |
| 1701 | 1731 | |
| r9705 | r9706 | |
| 1733 | 1763 | } |
| 1734 | 1764 | state->cart.fmpac.mem[0x3ff6] = data; |
| 1735 | 1765 | state->cart.fmpac.opll_active = val & 1; |
| 1736 | | if ((msx1.opll_active ^ val) & 1) |
| 1766 | if ((drvstate->opll_active ^ val) & 1) |
| 1737 | 1767 | { |
| 1738 | 1768 | logerror ("FM-PAC: OPLL %sactivated\n", val & 1 ? "" : "de"); |
| 1739 | 1769 | } |
| 1740 | | msx1.opll_active = val & 1; |
| 1770 | drvstate->opll_active = val & 1; |
| 1741 | 1771 | break; |
| 1742 | 1772 | case 0x7ff7: |
| 1743 | 1773 | state->banks[0] = val & state->bank_mask; |
| r9705 | r9706 | |
| 1843 | 1873 | |
| 1844 | 1874 | MSX_SLOT_RESET(superloadrunner) |
| 1845 | 1875 | { |
| 1846 | | msx1.superloadrunner_bank = 0; |
| 1876 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1877 | drvstate->superloadrunner_bank = 0; |
| 1847 | 1878 | } |
| 1848 | 1879 | |
| 1849 | 1880 | MSX_SLOT_MAP(superloadrunner) |
| 1850 | 1881 | { |
| 1882 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1851 | 1883 | if (page == 2) |
| 1852 | 1884 | { |
| 1853 | 1885 | UINT8 *mem = state->mem + |
| 1854 | | (msx1.superloadrunner_bank & state->bank_mask) * 0x4000; |
| 1886 | (drvstate->superloadrunner_bank & state->bank_mask) * 0x4000; |
| 1855 | 1887 | |
| 1856 | 1888 | msx_cpu_setbank (machine, 5, mem); |
| 1857 | 1889 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 1858 | 1890 | } |
| 1859 | 1891 | else |
| 1860 | 1892 | { |
| 1861 | | msx_cpu_setbank (machine, page * 2 + 1, msx1.empty); |
| 1862 | | msx_cpu_setbank (machine, page * 2 + 2, msx1.empty); |
| 1893 | msx_cpu_setbank (machine, page * 2 + 1, drvstate->empty); |
| 1894 | msx_cpu_setbank (machine, page * 2 + 2, drvstate->empty); |
| 1863 | 1895 | } |
| 1864 | 1896 | } |
| 1865 | 1897 | |
| r9705 | r9706 | |
| 1884 | 1916 | |
| 1885 | 1917 | MSX_SLOT_MAP(crossblaim) |
| 1886 | 1918 | { |
| 1919 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1887 | 1920 | UINT8 *mem; |
| 1888 | 1921 | |
| 1889 | 1922 | /* This might look odd, but it's what happens on the real cartridge */ |
| r9705 | r9706 | |
| 1898 | 1931 | } |
| 1899 | 1932 | else |
| 1900 | 1933 | { |
| 1901 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1902 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1934 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 1935 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 1903 | 1936 | } |
| 1904 | 1937 | break; |
| 1905 | 1938 | case 1: |
| r9705 | r9706 | |
| 1919 | 1952 | } |
| 1920 | 1953 | else |
| 1921 | 1954 | { |
| 1922 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1923 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1955 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 1956 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 1924 | 1957 | } |
| 1925 | 1958 | } |
| 1926 | 1959 | } |
| 1927 | 1960 | |
| 1928 | 1961 | MSX_SLOT_WRITE(crossblaim) |
| 1929 | 1962 | { |
| 1963 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1930 | 1964 | UINT8 block = val & 3; |
| 1931 | 1965 | |
| 1932 | 1966 | if (!block) block = 1; |
| 1933 | 1967 | state->banks[0] = block; |
| 1934 | 1968 | |
| 1935 | | if (msx1.state[0] == state) |
| 1969 | if (drvstate->state[0] == state) |
| 1936 | 1970 | { |
| 1937 | 1971 | slot_crossblaim_map (machine, state, 0); |
| 1938 | 1972 | } |
| 1939 | | if (msx1.state[2] == state) |
| 1973 | if (drvstate->state[2] == state) |
| 1940 | 1974 | { |
| 1941 | 1975 | slot_crossblaim_map (machine, state, 2); |
| 1942 | 1976 | } |
| 1943 | | if (msx1.state[3] == state) |
| 1977 | if (drvstate->state[3] == state) |
| 1944 | 1978 | { |
| 1945 | 1979 | slot_crossblaim_map (machine, state, 3); |
| 1946 | 1980 | } |
| r9705 | r9706 | |
| 1981 | 2015 | |
| 1982 | 2016 | MSX_SLOT_MAP(korean80in1) |
| 1983 | 2017 | { |
| 2018 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 1984 | 2019 | switch (page) |
| 1985 | 2020 | { |
| 1986 | 2021 | case 0: |
| 1987 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1988 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 2022 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 2023 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 1989 | 2024 | break; |
| 1990 | 2025 | case 1: |
| 1991 | 2026 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x2000); |
| r9705 | r9706 | |
| 1996 | 2031 | msx_cpu_setbank (machine, 6, state->mem + state->banks[3] * 0x2000); |
| 1997 | 2032 | break; |
| 1998 | 2033 | case 3: |
| 1999 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 2000 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 2034 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 2035 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 2001 | 2036 | } |
| 2002 | 2037 | } |
| 2003 | 2038 | |
| 2004 | 2039 | MSX_SLOT_WRITE(korean80in1) |
| 2005 | 2040 | { |
| 2041 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 2006 | 2042 | int bank; |
| 2007 | 2043 | |
| 2008 | 2044 | if (addr >= 0x4000 && addr < 0x4004) |
| r9705 | r9706 | |
| 2014 | 2050 | { |
| 2015 | 2051 | slot_korean80in1_map (machine, state, 1); |
| 2016 | 2052 | } |
| 2017 | | else if (msx1.state[2] == state) |
| 2053 | else if (drvstate->state[2] == state) |
| 2018 | 2054 | { |
| 2019 | 2055 | slot_korean80in1_map (machine, state, 2); |
| 2020 | 2056 | } |
| r9705 | r9706 | |
| 2046 | 2082 | |
| 2047 | 2083 | MSX_SLOT_RESET(korean90in1) |
| 2048 | 2084 | { |
| 2049 | | msx1.korean90in1_bank = 0; |
| 2085 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 2086 | drvstate->korean90in1_bank = 0; |
| 2050 | 2087 | } |
| 2051 | 2088 | |
| 2052 | 2089 | MSX_SLOT_MAP(korean90in1) |
| 2053 | 2090 | { |
| 2091 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 2054 | 2092 | UINT8 *mem; |
| 2055 | | UINT8 mask = (msx1.korean90in1_bank & 0xc0) == 0x80 ? 0x3e : 0x3f; |
| 2093 | UINT8 mask = (drvstate->korean90in1_bank & 0xc0) == 0x80 ? 0x3e : 0x3f; |
| 2056 | 2094 | mem = state->mem + |
| 2057 | | ((msx1.korean90in1_bank & mask) & state->bank_mask) * 0x4000; |
| 2095 | ((drvstate->korean90in1_bank & mask) & state->bank_mask) * 0x4000; |
| 2058 | 2096 | |
| 2059 | 2097 | switch (page) |
| 2060 | 2098 | { |
| 2061 | 2099 | case 0: |
| 2062 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 2063 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 2100 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 2101 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 2064 | 2102 | break; |
| 2065 | 2103 | case 1: |
| 2066 | 2104 | msx_cpu_setbank (machine, 3, mem); |
| 2067 | 2105 | msx_cpu_setbank (machine, 4, mem + 0x2000); |
| 2068 | 2106 | break; |
| 2069 | 2107 | case 2: |
| 2070 | | switch (msx1.korean90in1_bank & 0xc0) |
| 2108 | switch (drvstate->korean90in1_bank & 0xc0) |
| 2071 | 2109 | { |
| 2072 | 2110 | case 0x80: /* 32 kb mode */ |
| 2073 | 2111 | mem += 0x4000; |
| r9705 | r9706 | |
| 2082 | 2120 | } |
| 2083 | 2121 | break; |
| 2084 | 2122 | case 3: |
| 2085 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 2086 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 2123 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 2124 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 2087 | 2125 | } |
| 2088 | 2126 | } |
| 2089 | 2127 | |
| r9705 | r9706 | |
| 2120 | 2158 | |
| 2121 | 2159 | MSX_SLOT_MAP(korean126in1) |
| 2122 | 2160 | { |
| 2161 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 2123 | 2162 | UINT8 *mem; |
| 2124 | 2163 | |
| 2125 | 2164 | switch (page) |
| 2126 | 2165 | { |
| 2127 | 2166 | case 0: |
| 2128 | | msx_cpu_setbank (machine, 1, msx1.empty); |
| 2129 | | msx_cpu_setbank (machine, 2, msx1.empty); |
| 2167 | msx_cpu_setbank (machine, 1, drvstate->empty); |
| 2168 | msx_cpu_setbank (machine, 2, drvstate->empty); |
| 2130 | 2169 | break; |
| 2131 | 2170 | case 1: |
| 2132 | 2171 | mem = state->mem + state->banks[0] * 0x4000; |
| r9705 | r9706 | |
| 2139 | 2178 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 2140 | 2179 | break; |
| 2141 | 2180 | case 3: |
| 2142 | | msx_cpu_setbank (machine, 7, msx1.empty); |
| 2143 | | msx_cpu_setbank (machine, 8, msx1.empty); |
| 2181 | msx_cpu_setbank (machine, 7, drvstate->empty); |
| 2182 | msx_cpu_setbank (machine, 8, drvstate->empty); |
| 2144 | 2183 | } |
| 2145 | 2184 | } |
| 2146 | 2185 | |
| 2147 | 2186 | MSX_SLOT_WRITE(korean126in1) |
| 2148 | 2187 | { |
| 2188 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 2149 | 2189 | if (addr >= 0x4000 && addr < 0x4002) |
| 2150 | 2190 | { |
| 2151 | 2191 | int bank = addr & 1; |
| r9705 | r9706 | |
| 2154 | 2194 | { |
| 2155 | 2195 | slot_korean126in1_map (machine, state, 1); |
| 2156 | 2196 | } |
| 2157 | | else if (msx1.state[2] == state) |
| 2197 | else if (drvstate->state[2] == state) |
| 2158 | 2198 | { |
| 2159 | 2199 | slot_korean126in1_map (machine, state, 2); |
| 2160 | 2200 | } |
| r9705 | r9706 | |
| 2193 | 2233 | |
| 2194 | 2234 | static READ8_HANDLER (soundcartridge_scc) |
| 2195 | 2235 | { |
| 2236 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 2196 | 2237 | int reg; |
| 2197 | 2238 | |
| 2198 | 2239 | |
| 2199 | 2240 | if (offset >= 0x7e0) |
| 2200 | 2241 | { |
| 2201 | | return msx1.state[2]->mem[ |
| 2202 | | msx1.state[2]->banks[2] * 0x2000 + 0x1800 + offset]; |
| 2242 | return state->state[2]->mem[ |
| 2243 | state->state[2]->banks[2] * 0x2000 + 0x1800 + offset]; |
| 2203 | 2244 | } |
| 2204 | 2245 | |
| 2205 | 2246 | reg = offset & 0xff; |
| r9705 | r9706 | |
| 2229 | 2270 | |
| 2230 | 2271 | static READ8_HANDLER (soundcartridge_sccp) |
| 2231 | 2272 | { |
| 2273 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 2232 | 2274 | int reg; |
| 2233 | 2275 | |
| 2234 | 2276 | if (offset >= 0x7e0) |
| 2235 | 2277 | { |
| 2236 | | return msx1.state[2]->mem[ |
| 2237 | | msx1.state[2]->banks[3] * 0x2000 + 0x1800 + offset]; |
| 2278 | return state->state[2]->mem[ |
| 2279 | state->state[2]->banks[3] * 0x2000 + 0x1800 + offset]; |
| 2238 | 2280 | } |
| 2239 | 2281 | |
| 2240 | 2282 | reg = offset & 0xff; |
| r9705 | r9706 | |
| 2289 | 2331 | |
| 2290 | 2332 | MSX_SLOT_WRITE(soundcartridge) |
| 2291 | 2333 | { |
| 2334 | msx_state *drvstate = machine->driver_data<msx_state>(); |
| 2292 | 2335 | address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 2293 | 2336 | int i; |
| 2294 | 2337 | |
| r9705 | r9706 | |
| 2307 | 2350 | state->banks[0] = val & state->bank_mask; |
| 2308 | 2351 | state->cart.sccp.banks_saved[0] = val; |
| 2309 | 2352 | slot_soundcartridge_map (machine, state, 1); |
| 2310 | | if (msx1.state[3] == state) |
| 2353 | if (drvstate->state[3] == state) |
| 2311 | 2354 | { |
| 2312 | 2355 | slot_soundcartridge_map (machine, state, 3); |
| 2313 | 2356 | } |
| r9705 | r9706 | |
| 2323 | 2366 | { |
| 2324 | 2367 | state->banks[1] = val & state->bank_mask; |
| 2325 | 2368 | state->cart.sccp.banks_saved[1] = val; |
| 2326 | | if (msx1.state[3] == state) |
| 2369 | if (drvstate->state[3] == state) |
| 2327 | 2370 | { |
| 2328 | 2371 | slot_soundcartridge_map (machine, state, 3); |
| 2329 | 2372 | } |
| r9705 | r9706 | |
| 2344 | 2387 | (((val & 0x3f) == 0x3f) && !(state->cart.sccp.mode & 0x20)); |
| 2345 | 2388 | |
| 2346 | 2389 | slot_soundcartridge_map (machine, state, 2); |
| 2347 | | if (msx1.state[0] == state) |
| 2390 | if (drvstate->state[0] == state) |
| 2348 | 2391 | { |
| 2349 | 2392 | slot_soundcartridge_map (machine, state, 0); |
| 2350 | 2393 | } |
| r9705 | r9706 | |
| 2396 | 2439 | state->cart.sccp.sccp_active = |
| 2397 | 2440 | (val & 0x80) && (state->cart.sccp.mode & 0x20); |
| 2398 | 2441 | slot_soundcartridge_map (machine, state, 2); |
| 2399 | | if (msx1.state[0] == state) |
| 2442 | if (drvstate->state[0] == state) |
| 2400 | 2443 | { |
| 2401 | 2444 | slot_soundcartridge_map (machine, state, 0); |
| 2402 | 2445 | } |
src/mess/machine/msx.c
| r9705 | r9706 | |
| 31 | 31 | |
| 32 | 32 | #define VERBOSE 0 |
| 33 | 33 | |
| 34 | | MSX msx1; |
| 35 | | static slot_state *cart_state[MSX_MAX_CARTS]; |
| 34 | static void msx_memory_map_all (running_machine *machine); |
| 35 | static void msx_memory_map_page (running_machine *machine, int page); |
| 36 | static void msx_memory_init (running_machine *machine); |
| 37 | static void msx_memory_set_carts (running_machine *machine); |
| 38 | static void msx_memory_reset (running_machine *machine); |
| 36 | 39 | |
| 40 | |
| 41 | |
| 37 | 42 | static int msx_probe_type (UINT8* pmem, int size) |
| 38 | 43 | { |
| 39 | 44 | int kon4, kon5, asc8, asc16, i; |
| r9705 | r9706 | |
| 84 | 89 | |
| 85 | 90 | DEVICE_IMAGE_LOAD (msx_cart) |
| 86 | 91 | { |
| 92 | msx_state *state = image.device().machine->driver_data<msx_state>(); |
| 87 | 93 | int size; |
| 88 | 94 | int size_aligned; |
| 89 | 95 | UINT8 *mem; |
| 90 | 96 | int type; |
| 91 | 97 | const char *extra = NULL; |
| 92 | 98 | char *sramfile; |
| 93 | | slot_state *state; |
| 99 | slot_state *st; |
| 94 | 100 | int id = -1; |
| 95 | 101 | |
| 96 | 102 | if (strcmp(image.device().tag(),"cart1")==0) { |
| r9705 | r9706 | |
| 245 | 251 | } |
| 246 | 252 | |
| 247 | 253 | /* allocate and set slot_state for this cartridge */ |
| 248 | | state = (slot_state*) image.image_malloc(sizeof (slot_state)); |
| 249 | | if (!state) |
| 254 | st = (slot_state*) image.image_malloc(sizeof (slot_state)); |
| 255 | if (!st) |
| 250 | 256 | { |
| 251 | 257 | logerror ("cart #%d: error: cannot allocate memory for " |
| 252 | 258 | "cartridge state\n", id); |
| 253 | 259 | return IMAGE_INIT_FAIL; |
| 254 | 260 | } |
| 255 | | memset (state, 0, sizeof (slot_state)); |
| 261 | memset (st, 0, sizeof (slot_state)); |
| 256 | 262 | |
| 257 | | state->type = type; |
| 263 | st->type = type; |
| 258 | 264 | sramfile = (char*)image.image_malloc(strlen (image.filename () + 1)); |
| 259 | 265 | |
| 260 | 266 | if (sramfile) { |
| r9705 | r9706 | |
| 265 | 271 | if (ext) { |
| 266 | 272 | *ext = 0; |
| 267 | 273 | } |
| 268 | | state->sramfile = sramfile; |
| 274 | st->sramfile = sramfile; |
| 269 | 275 | } |
| 270 | 276 | |
| 271 | | if (msx_slot_list[type].init (image.device().machine, state, 0, mem, size_aligned)) { |
| 277 | if (msx_slot_list[type].init (image.device().machine, st, 0, mem, size_aligned)) { |
| 272 | 278 | return IMAGE_INIT_FAIL; |
| 273 | 279 | } |
| 274 | 280 | if (msx_slot_list[type].loadsram) { |
| 275 | | msx_slot_list[type].loadsram (state); |
| 281 | msx_slot_list[type].loadsram (st); |
| 276 | 282 | } |
| 277 | 283 | |
| 278 | | msx1.cart_state[id] = cart_state[id] = state; |
| 279 | | msx_memory_set_carts (); |
| 284 | state->cart_state[id] = st; |
| 285 | msx_memory_set_carts (image.device().machine); |
| 280 | 286 | |
| 281 | 287 | return IMAGE_INIT_PASS; |
| 282 | 288 | } |
| 283 | 289 | |
| 284 | 290 | DEVICE_IMAGE_UNLOAD (msx_cart) |
| 285 | 291 | { |
| 292 | msx_state *state = image.device().machine->driver_data<msx_state>(); |
| 286 | 293 | int id = -1; |
| 287 | 294 | |
| 288 | 295 | if (strcmp(image.device().tag(),"cart1")==0) { |
| r9705 | r9706 | |
| 297 | 304 | return; |
| 298 | 305 | } |
| 299 | 306 | |
| 300 | | if (msx_slot_list[msx1.cart_state[id]->type].savesram) |
| 307 | if (msx_slot_list[state->cart_state[id]->type].savesram) |
| 301 | 308 | { |
| 302 | | msx_slot_list[msx1.cart_state[id]->type].savesram (msx1.cart_state[id]); |
| 309 | msx_slot_list[state->cart_state[id]->type].savesram (state->cart_state[id]); |
| 303 | 310 | } |
| 304 | 311 | } |
| 305 | 312 | |
| r9705 | r9706 | |
| 331 | 338 | |
| 332 | 339 | MACHINE_START( msx2 ) |
| 333 | 340 | { |
| 334 | | msx1.dsk_stat = 0x7f; |
| 341 | msx_state *state = machine->driver_data<msx_state>(); |
| 342 | state->dsk_stat = 0x7f; |
| 335 | 343 | } |
| 336 | 344 | |
| 337 | 345 | MACHINE_RESET( msx ) |
| r9705 | r9706 | |
| 479 | 487 | |
| 480 | 488 | DRIVER_INIT( msx ) |
| 481 | 489 | { |
| 482 | | int i; |
| 483 | | |
| 484 | | memset (&msx1, 0, sizeof (MSX)); |
| 485 | | /* LOAD_DEVICE is called before DRIVER_INIT */ |
| 486 | | for (i=0; i<MSX_MAX_CARTS; i++) |
| 487 | | { |
| 488 | | msx1.cart_state[i] = cart_state[i]; |
| 489 | | } |
| 490 | | |
| 491 | 490 | cpu_set_input_line_vector (machine->device("maincpu"), 0, 0xff); |
| 492 | 491 | |
| 493 | 492 | msx_memory_init (machine); |
| r9705 | r9706 | |
| 504 | 503 | |
| 505 | 504 | INTERRUPT_GEN( msx_interrupt ) |
| 506 | 505 | { |
| 506 | msx_state *state = device->machine->driver_data<msx_state>(); |
| 507 | 507 | int i; |
| 508 | 508 | |
| 509 | 509 | for (i=0; i<2; i++) |
| 510 | 510 | { |
| 511 | | msx1.mouse[i] = input_port_read(device->machine, i ? "MOUSE1" : "MOUSE0"); |
| 512 | | msx1.mouse_stat[i] = -1; |
| 511 | state->mouse[i] = input_port_read(device->machine, i ? "MOUSE1" : "MOUSE0"); |
| 512 | state->mouse_stat[i] = -1; |
| 513 | 513 | } |
| 514 | 514 | |
| 515 | 515 | TMS9928A_set_spriteslimit (input_port_read(device->machine, "DSW") & 0x20); |
| r9705 | r9706 | |
| 527 | 527 | |
| 528 | 528 | READ8_HANDLER ( msx_psg_port_a_r ) |
| 529 | 529 | { |
| 530 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 530 | 531 | int data, inp; |
| 531 | 532 | |
| 532 | 533 | data = (cassette_input(cassette_device_image(space->machine)) > 0.0038 ? 0x80 : 0); |
| 533 | 534 | |
| 534 | | if ( (msx1.psg_b ^ input_port_read(space->machine, "DSW") ) & 0x40) |
| 535 | if ( (state->psg_b ^ input_port_read(space->machine, "DSW") ) & 0x40) |
| 535 | 536 | { |
| 536 | 537 | /* game port 2 */ |
| 537 | 538 | inp = input_port_read(space->machine, "JOY1") & 0x7f; |
| r9705 | r9706 | |
| 547 | 548 | { |
| 548 | 549 | /* mouse */ |
| 549 | 550 | data |= inp & 0x70; |
| 550 | | if (msx1.mouse_stat[1] < 0) |
| 551 | if (state->mouse_stat[1] < 0) |
| 551 | 552 | inp = 0xf; |
| 552 | 553 | else |
| 553 | | inp = ~(msx1.mouse[1] >> (4*msx1.mouse_stat[1]) ) & 15; |
| 554 | inp = ~(state->mouse[1] >> (4*state->mouse_stat[1]) ) & 15; |
| 554 | 555 | |
| 555 | 556 | return data | inp; |
| 556 | 557 | } |
| r9705 | r9706 | |
| 572 | 573 | { |
| 573 | 574 | /* mouse */ |
| 574 | 575 | data |= inp & 0x70; |
| 575 | | if (msx1.mouse_stat[0] < 0) |
| 576 | if (state->mouse_stat[0] < 0) |
| 576 | 577 | inp = 0xf; |
| 577 | 578 | else |
| 578 | | inp = ~(msx1.mouse[0] >> (4*msx1.mouse_stat[0]) ) & 15; |
| 579 | inp = ~(state->mouse[0] >> (4*state->mouse_stat[0]) ) & 15; |
| 579 | 580 | |
| 580 | 581 | return data | inp; |
| 581 | 582 | } |
| r9705 | r9706 | |
| 587 | 588 | |
| 588 | 589 | READ8_HANDLER ( msx_psg_port_b_r ) |
| 589 | 590 | { |
| 590 | | return msx1.psg_b; |
| 591 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 592 | return state->psg_b; |
| 591 | 593 | } |
| 592 | 594 | |
| 593 | 595 | WRITE8_HANDLER ( msx_psg_port_a_w ) |
| r9705 | r9706 | |
| 596 | 598 | |
| 597 | 599 | WRITE8_HANDLER ( msx_psg_port_b_w ) |
| 598 | 600 | { |
| 601 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 599 | 602 | /* Arabic or kana mode led */ |
| 600 | | if ( (data ^ msx1.psg_b) & 0x80) |
| 603 | if ( (data ^ state->psg_b) & 0x80) |
| 601 | 604 | set_led_status (space->machine, 2, !(data & 0x80) ); |
| 602 | 605 | |
| 603 | | if ( (msx1.psg_b ^ data) & 0x10) |
| 606 | if ( (state->psg_b ^ data) & 0x10) |
| 604 | 607 | { |
| 605 | | if (++msx1.mouse_stat[0] > 3) msx1.mouse_stat[0] = -1; |
| 608 | if (++state->mouse_stat[0] > 3) state->mouse_stat[0] = -1; |
| 606 | 609 | } |
| 607 | | if ( (msx1.psg_b ^ data) & 0x20) |
| 610 | if ( (state->psg_b ^ data) & 0x20) |
| 608 | 611 | { |
| 609 | | if (++msx1.mouse_stat[1] > 3) msx1.mouse_stat[1] = -1; |
| 612 | if (++state->mouse_stat[1] > 3) state->mouse_stat[1] = -1; |
| 610 | 613 | } |
| 611 | 614 | |
| 612 | | msx1.psg_b = data; |
| 615 | state->psg_b = data; |
| 613 | 616 | } |
| 614 | 617 | |
| 615 | 618 | WRITE8_DEVICE_HANDLER( msx_printer_strobe_w ) |
| r9705 | r9706 | |
| 644 | 647 | |
| 645 | 648 | WRITE8_HANDLER (msx_fmpac_w) |
| 646 | 649 | { |
| 647 | | if (msx1.opll_active) |
| 650 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 651 | if (state->opll_active) |
| 648 | 652 | { |
| 649 | 653 | running_device *ym = space->machine->device("ym2413"); |
| 650 | 654 | |
| r9705 | r9706 | |
| 661 | 665 | |
| 662 | 666 | WRITE8_HANDLER (msx_rtc_latch_w) |
| 663 | 667 | { |
| 664 | | msx1.rtc_latch = data & 15; |
| 668 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 669 | state->rtc_latch = data & 15; |
| 665 | 670 | } |
| 666 | 671 | |
| 667 | 672 | WRITE8_HANDLER (msx_rtc_reg_w) |
| 668 | 673 | { |
| 674 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 669 | 675 | running_device *rtc = space->machine->device("rtc"); |
| 670 | | tc8521_w(rtc, msx1.rtc_latch, data); |
| 676 | tc8521_w(rtc, state->rtc_latch, data); |
| 671 | 677 | } |
| 672 | 678 | |
| 673 | 679 | READ8_HANDLER (msx_rtc_reg_r) |
| 674 | 680 | { |
| 681 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 675 | 682 | running_device *rtc = space->machine->device("rtc"); |
| 676 | | return tc8521_r(rtc, msx1.rtc_latch); |
| 683 | return tc8521_r(rtc, state->rtc_latch); |
| 677 | 684 | } |
| 678 | 685 | |
| 679 | 686 | NVRAM_HANDLER( msx2 ) |
| r9705 | r9706 | |
| 721 | 728 | |
| 722 | 729 | static WRITE_LINE_DEVICE_HANDLER( msx_wd179x_intrq_w ) |
| 723 | 730 | { |
| 731 | msx_state *drvstate = device->machine->driver_data<msx_state>(); |
| 724 | 732 | if (state) |
| 725 | | msx1.dsk_stat &= ~0x40; |
| 733 | drvstate->dsk_stat &= ~0x40; |
| 726 | 734 | else |
| 727 | | msx1.dsk_stat |= 0x40; |
| 735 | drvstate->dsk_stat |= 0x40; |
| 728 | 736 | } |
| 729 | 737 | |
| 730 | 738 | static WRITE_LINE_DEVICE_HANDLER( msx_wd179x_drq_w ) |
| 731 | 739 | { |
| 740 | msx_state *drvstate = device->machine->driver_data<msx_state>(); |
| 732 | 741 | if (state) |
| 733 | | msx1.dsk_stat &= ~0x80; |
| 742 | drvstate->dsk_stat &= ~0x80; |
| 734 | 743 | else |
| 735 | | msx1.dsk_stat |= 0x80; |
| 744 | drvstate->dsk_stat |= 0x80; |
| 736 | 745 | } |
| 737 | 746 | |
| 738 | 747 | const wd17xx_interface msx_wd17xx_interface = |
| r9705 | r9706 | |
| 764 | 773 | |
| 765 | 774 | static WRITE8_DEVICE_HANDLER ( msx_ppi_port_a_w ) |
| 766 | 775 | { |
| 767 | | msx1.primary_slot = data; |
| 776 | msx_state *state = device->machine->driver_data<msx_state>(); |
| 777 | state->primary_slot = data; |
| 768 | 778 | |
| 769 | 779 | if (VERBOSE) |
| 770 | | logerror ("write to primary slot select: %02x\n", msx1.primary_slot); |
| 780 | logerror ("write to primary slot select: %02x\n", state->primary_slot); |
| 771 | 781 | msx_memory_map_all (device->machine); |
| 772 | 782 | } |
| 773 | 783 | |
| r9705 | r9706 | |
| 821 | 831 | * |
| 822 | 832 | ***********************************************************************/ |
| 823 | 833 | |
| 824 | | void msx_memory_init (running_machine *machine) |
| 834 | static void msx_memory_init (running_machine *machine) |
| 825 | 835 | { |
| 836 | msx_state *state = machine->driver_data<msx_state>(); |
| 826 | 837 | int prim, sec, page, extent, option; |
| 827 | 838 | int size = 0; |
| 828 | 839 | const msx_slot_layout *layout= (msx_slot_layout*)NULL; |
| r9705 | r9706 | |
| 831 | 842 | slot_state *st; |
| 832 | 843 | UINT8 *mem = NULL; |
| 833 | 844 | |
| 834 | | msx1.empty = auto_alloc_array(machine, UINT8, 0x4000); |
| 835 | | memset (msx1.empty, 0xff, 0x4000); |
| 845 | state->empty = auto_alloc_array(machine, UINT8, 0x4000); |
| 846 | memset (state->empty, 0xff, 0x4000); |
| 836 | 847 | |
| 837 | 848 | for (prim=0; prim<4; prim++) { |
| 838 | 849 | for (sec=0; sec<4; sec++) { |
| 839 | 850 | for (page=0; page<4; page++) { |
| 840 | | msx1.all_state[prim][sec][page]= (slot_state*)NULL; |
| 851 | state->all_state[prim][sec][page]= (slot_state*)NULL; |
| 841 | 852 | } |
| 842 | 853 | } |
| 843 | 854 | } |
| r9705 | r9706 | |
| 854 | 865 | return; |
| 855 | 866 | } |
| 856 | 867 | |
| 857 | | msx1.layout = layout; |
| 868 | state->layout = layout; |
| 858 | 869 | |
| 859 | 870 | for (; layout->entry != MSX_LAYOUT_LAST; layout++) { |
| 860 | 871 | |
| r9705 | r9706 | |
| 866 | 877 | extent = layout->page_extent; |
| 867 | 878 | |
| 868 | 879 | if (layout->slot_secondary) { |
| 869 | | msx1.slot_expanded[layout->slot_primary]= TRUE; |
| 880 | state->slot_expanded[layout->slot_primary]= TRUE; |
| 870 | 881 | } |
| 871 | 882 | |
| 872 | 883 | slot = &msx_slot_list[layout->type]; |
| r9705 | r9706 | |
| 886 | 897 | |
| 887 | 898 | st = (slot_state*)NULL; |
| 888 | 899 | if (layout->type == SLOT_CARTRIDGE1) { |
| 889 | | st = msx1.cart_state[0]; |
| 900 | st = state->cart_state[0]; |
| 890 | 901 | if (!st) { |
| 891 | 902 | slot = &msx_slot_list[SLOT_SOUNDCARTRIDGE]; |
| 892 | 903 | size = 0x20000; |
| 893 | 904 | } |
| 894 | 905 | } |
| 895 | 906 | if (layout->type == SLOT_CARTRIDGE2) { |
| 896 | | st = msx1.cart_state[1]; |
| 907 | st = state->cart_state[1]; |
| 897 | 908 | if (!st) { |
| 898 | 909 | /* Check whether the optional FM-PAC rom is present */ |
| 899 | 910 | option = 0x10000; |
| r9705 | r9706 | |
| 933 | 944 | "page + extent > 3\n"); |
| 934 | 945 | break; |
| 935 | 946 | } |
| 936 | | msx1.all_state[prim][sec][page] = st; |
| 947 | state->all_state[prim][sec][page] = st; |
| 937 | 948 | page++; |
| 938 | 949 | } |
| 939 | 950 | break; |
| 940 | 951 | case MSX_LAYOUT_KANJI_ENTRY: |
| 941 | | msx1.kanji_mem = memory_region(machine, "maincpu") + layout->option; |
| 952 | state->kanji_mem = memory_region(machine, "maincpu") + layout->option; |
| 942 | 953 | break; |
| 943 | 954 | case MSX_LAYOUT_RAMIO_SET_BITS_ENTRY: |
| 944 | | msx1.ramio_set_bits = (UINT8)layout->option; |
| 955 | state->ramio_set_bits = (UINT8)layout->option; |
| 945 | 956 | break; |
| 946 | 957 | } |
| 947 | 958 | } |
| 948 | 959 | } |
| 949 | 960 | |
| 950 | | void msx_memory_reset (running_machine *machine) |
| 961 | static void msx_memory_reset (running_machine *machine) |
| 951 | 962 | { |
| 952 | | slot_state *state, *last_state= (slot_state*)NULL; |
| 963 | msx_state *state = machine->driver_data<msx_state>(); |
| 964 | slot_state *st, *last_st = (slot_state*)NULL; |
| 953 | 965 | int prim, sec, page; |
| 954 | 966 | |
| 955 | | msx1.primary_slot = 0; |
| 967 | state->primary_slot = 0; |
| 956 | 968 | |
| 957 | 969 | for (prim=0; prim<4; prim++) { |
| 958 | | msx1.secondary_slot[prim] = 0; |
| 970 | state->secondary_slot[prim] = 0; |
| 959 | 971 | for (sec=0; sec<4; sec++) { |
| 960 | 972 | for (page=0; page<4; page++) { |
| 961 | | state = msx1.all_state[prim][sec][page]; |
| 962 | | if (state && state != last_state) { |
| 963 | | msx_slot_list[state->type].reset (machine, state); |
| 973 | st = state->all_state[prim][sec][page]; |
| 974 | if (st && st != last_st) { |
| 975 | msx_slot_list[st->type].reset (machine, st); |
| 964 | 976 | } |
| 965 | | last_state = state; |
| 977 | last_st = st; |
| 966 | 978 | } |
| 967 | 979 | } |
| 968 | 980 | } |
| 969 | 981 | } |
| 970 | 982 | |
| 971 | | void msx_memory_set_carts (void) |
| 983 | static void msx_memory_set_carts (running_machine *machine) |
| 972 | 984 | { |
| 985 | msx_state *state = machine->driver_data<msx_state>(); |
| 973 | 986 | const msx_slot_layout *layout; |
| 974 | 987 | int page; |
| 975 | 988 | |
| 976 | | if (!msx1.layout) { |
| 989 | if (!state->layout) { |
| 977 | 990 | return; |
| 978 | 991 | } |
| 979 | 992 | |
| 980 | | for (layout = msx1.layout; layout->entry != MSX_LAYOUT_LAST; layout++) { |
| 993 | for (layout = state->layout; layout->entry != MSX_LAYOUT_LAST; layout++) { |
| 981 | 994 | |
| 982 | 995 | if (layout->entry == MSX_LAYOUT_SLOT_ENTRY) { |
| 983 | 996 | |
| 984 | 997 | switch (layout->type) { |
| 985 | 998 | case SLOT_CARTRIDGE1: |
| 986 | 999 | for (page=0; page<4; page++) { |
| 987 | | msx1.all_state[layout->slot_primary] |
| 1000 | state->all_state[layout->slot_primary] |
| 988 | 1001 | [layout->slot_secondary] |
| 989 | | [page] = msx1.cart_state[0]; |
| 1002 | [page] = state->cart_state[0]; |
| 990 | 1003 | } |
| 991 | 1004 | break; |
| 992 | 1005 | case SLOT_CARTRIDGE2: |
| 993 | 1006 | for (page=0; page<4; page++) { |
| 994 | | msx1.all_state[layout->slot_primary] |
| 1007 | state->all_state[layout->slot_primary] |
| 995 | 1008 | [layout->slot_secondary] |
| 996 | | [page] = msx1.cart_state[1]; |
| 1009 | [page] = state->cart_state[1]; |
| 997 | 1010 | } |
| 998 | 1011 | break; |
| 999 | 1012 | } |
| r9705 | r9706 | |
| 1001 | 1014 | } |
| 1002 | 1015 | } |
| 1003 | 1016 | |
| 1004 | | void msx_memory_map_page (running_machine *machine, int page) |
| 1017 | static void msx_memory_map_page (running_machine *machine, int page) |
| 1005 | 1018 | { |
| 1019 | msx_state *state = machine->driver_data<msx_state>(); |
| 1006 | 1020 | int slot_primary; |
| 1007 | 1021 | int slot_secondary; |
| 1008 | | slot_state *state; |
| 1022 | slot_state *st; |
| 1009 | 1023 | const msx_slot *slot; |
| 1010 | 1024 | |
| 1011 | | slot_primary = (msx1.primary_slot >> (page * 2)) & 3; |
| 1012 | | slot_secondary = (msx1.secondary_slot[slot_primary] >> (page * 2)) & 3; |
| 1025 | slot_primary = (state->primary_slot >> (page * 2)) & 3; |
| 1026 | slot_secondary = (state->secondary_slot[slot_primary] >> (page * 2)) & 3; |
| 1013 | 1027 | |
| 1014 | | state = msx1.all_state[slot_primary][slot_secondary][page]; |
| 1015 | | slot = state ? &msx_slot_list[state->type] : &msx_slot_list[SLOT_EMPTY]; |
| 1016 | | msx1.state[page] = state; |
| 1017 | | msx1.slot[page] = slot; |
| 1028 | st = state->all_state[slot_primary][slot_secondary][page]; |
| 1029 | slot = st ? &msx_slot_list[st->type] : &msx_slot_list[SLOT_EMPTY]; |
| 1030 | state->state[page] = st; |
| 1031 | state->slot[page] = slot; |
| 1018 | 1032 | |
| 1019 | 1033 | if (VERBOSE) |
| 1020 | 1034 | { |
| 1021 | 1035 | logerror ("mapping %s in %d/%d/%d\n", slot->name, slot_primary, |
| 1022 | 1036 | slot_secondary, page); |
| 1023 | 1037 | } |
| 1024 | | slot->map (machine, state, page); |
| 1038 | slot->map (machine, st, page); |
| 1025 | 1039 | } |
| 1026 | 1040 | |
| 1027 | | void msx_memory_map_all (running_machine *machine) |
| 1041 | static void msx_memory_map_all (running_machine *machine) |
| 1028 | 1042 | { |
| 1029 | 1043 | int i; |
| 1030 | 1044 | |
| r9705 | r9706 | |
| 1035 | 1049 | |
| 1036 | 1050 | WRITE8_HANDLER (msx_page0_w) |
| 1037 | 1051 | { |
| 1052 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1038 | 1053 | if ( offset == 0 ) |
| 1039 | 1054 | { |
| 1040 | | msx1.superloadrunner_bank = data; |
| 1041 | | if (msx1.slot[2]->slot_type == SLOT_SUPERLOADRUNNER) { |
| 1042 | | msx1.slot[2]->map (space->machine, msx1.state[2], 2); |
| 1055 | state->superloadrunner_bank = data; |
| 1056 | if (state->slot[2]->slot_type == SLOT_SUPERLOADRUNNER) { |
| 1057 | state->slot[2]->map (space->machine, state->state[2], 2); |
| 1043 | 1058 | } |
| 1044 | 1059 | } |
| 1045 | 1060 | |
| 1046 | | switch (msx1.slot[0]->mem_type) { |
| 1061 | switch (state->slot[0]->mem_type) { |
| 1047 | 1062 | case MSX_MEM_RAM: |
| 1048 | | msx1.ram_pages[0][offset] = data; |
| 1063 | state->ram_pages[0][offset] = data; |
| 1049 | 1064 | break; |
| 1050 | 1065 | case MSX_MEM_HANDLER: |
| 1051 | | msx1.slot[0]->write (space->machine, msx1.state[0], offset, data); |
| 1066 | state->slot[0]->write (space->machine, state->state[0], offset, data); |
| 1052 | 1067 | } |
| 1053 | 1068 | } |
| 1054 | 1069 | |
| r9705 | r9706 | |
| 1059 | 1074 | |
| 1060 | 1075 | WRITE8_HANDLER (msx_page1_w) |
| 1061 | 1076 | { |
| 1062 | | switch (msx1.slot[1]->mem_type) { |
| 1077 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1078 | switch (state->slot[1]->mem_type) { |
| 1063 | 1079 | case MSX_MEM_RAM: |
| 1064 | | msx1.ram_pages[1][offset] = data; |
| 1080 | state->ram_pages[1][offset] = data; |
| 1065 | 1081 | break; |
| 1066 | 1082 | case MSX_MEM_HANDLER: |
| 1067 | | msx1.slot[1]->write (space->machine, msx1.state[1], 0x4000 + offset, data); |
| 1083 | state->slot[1]->write (space->machine, state->state[1], 0x4000 + offset, data); |
| 1068 | 1084 | } |
| 1069 | 1085 | } |
| 1070 | 1086 | |
| r9705 | r9706 | |
| 1080 | 1096 | |
| 1081 | 1097 | WRITE8_HANDLER (msx_page2_w) |
| 1082 | 1098 | { |
| 1083 | | switch (msx1.slot[2]->mem_type) { |
| 1099 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1100 | switch (state->slot[2]->mem_type) { |
| 1084 | 1101 | case MSX_MEM_RAM: |
| 1085 | | msx1.ram_pages[2][offset] = data; |
| 1102 | state->ram_pages[2][offset] = data; |
| 1086 | 1103 | break; |
| 1087 | 1104 | case MSX_MEM_HANDLER: |
| 1088 | | msx1.slot[2]->write (space->machine, msx1.state[2], 0x8000 + offset, data); |
| 1105 | state->slot[2]->write (space->machine, state->state[2], 0x8000 + offset, data); |
| 1089 | 1106 | } |
| 1090 | 1107 | } |
| 1091 | 1108 | |
| r9705 | r9706 | |
| 1106 | 1123 | |
| 1107 | 1124 | WRITE8_HANDLER (msx_page3_w) |
| 1108 | 1125 | { |
| 1109 | | switch (msx1.slot[3]->mem_type) { |
| 1126 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1127 | switch (state->slot[3]->mem_type) { |
| 1110 | 1128 | case MSX_MEM_RAM: |
| 1111 | | msx1.ram_pages[3][offset] = data; |
| 1129 | state->ram_pages[3][offset] = data; |
| 1112 | 1130 | break; |
| 1113 | 1131 | case MSX_MEM_HANDLER: |
| 1114 | | msx1.slot[3]->write (space->machine, msx1.state[3], 0xc000 + offset, data); |
| 1132 | state->slot[3]->write (space->machine, state->state[3], 0xc000 + offset, data); |
| 1115 | 1133 | } |
| 1116 | 1134 | } |
| 1117 | 1135 | |
| r9705 | r9706 | |
| 1122 | 1140 | |
| 1123 | 1141 | WRITE8_HANDLER (msx_sec_slot_w) |
| 1124 | 1142 | { |
| 1125 | | int slot = msx1.primary_slot >> 6; |
| 1126 | | if (msx1.slot_expanded[slot]) |
| 1143 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1144 | int slot = state->primary_slot >> 6; |
| 1145 | if (state->slot_expanded[slot]) |
| 1127 | 1146 | { |
| 1128 | 1147 | if (VERBOSE) |
| 1129 | 1148 | logerror ("write to secondary slot %d select: %02x\n", slot, data); |
| 1130 | 1149 | |
| 1131 | | msx1.secondary_slot[slot] = data; |
| 1150 | state->secondary_slot[slot] = data; |
| 1132 | 1151 | msx_memory_map_all (space->machine); |
| 1133 | 1152 | } |
| 1134 | 1153 | else { |
| r9705 | r9706 | |
| 1138 | 1157 | |
| 1139 | 1158 | READ8_HANDLER (msx_sec_slot_r) |
| 1140 | 1159 | { |
| 1160 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1141 | 1161 | UINT8 result; |
| 1142 | | int slot = msx1.primary_slot >> 6; |
| 1162 | int slot = state->primary_slot >> 6; |
| 1143 | 1163 | |
| 1144 | | if (msx1.slot_expanded[slot]) |
| 1145 | | result = ~msx1.secondary_slot[slot]; |
| 1164 | if (state->slot_expanded[slot]) |
| 1165 | result = ~state->secondary_slot[slot]; |
| 1146 | 1166 | else |
| 1147 | | result = msx1.top_page[0x1fff]; |
| 1167 | result = state->top_page[0x1fff]; |
| 1148 | 1168 | |
| 1149 | 1169 | return result; |
| 1150 | 1170 | } |
| 1151 | 1171 | |
| 1152 | 1172 | WRITE8_HANDLER (msx_ram_mapper_w) |
| 1153 | 1173 | { |
| 1154 | | msx1.ram_mapper[offset] = data; |
| 1155 | | if (msx1.slot[offset]->slot_type == SLOT_RAM_MM) { |
| 1156 | | msx1.slot[offset]->map (space->machine, msx1.state[offset], offset); |
| 1174 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1175 | state->ram_mapper[offset] = data; |
| 1176 | if (state->slot[offset]->slot_type == SLOT_RAM_MM) { |
| 1177 | state->slot[offset]->map (space->machine, state->state[offset], offset); |
| 1157 | 1178 | } |
| 1158 | 1179 | } |
| 1159 | 1180 | |
| 1160 | 1181 | READ8_HANDLER (msx_ram_mapper_r) |
| 1161 | 1182 | { |
| 1162 | | return msx1.ram_mapper[offset] | msx1.ramio_set_bits; |
| 1183 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1184 | return state->ram_mapper[offset] | state->ramio_set_bits; |
| 1163 | 1185 | } |
| 1164 | 1186 | |
| 1165 | 1187 | WRITE8_HANDLER (msx_90in1_w) |
| 1166 | 1188 | { |
| 1167 | | msx1.korean90in1_bank = data; |
| 1168 | | if (msx1.slot[1]->slot_type == SLOT_KOREAN_90IN1) |
| 1189 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1190 | state->korean90in1_bank = data; |
| 1191 | if (state->slot[1]->slot_type == SLOT_KOREAN_90IN1) |
| 1169 | 1192 | { |
| 1170 | | msx1.slot[1]->map (space->machine, msx1.state[1], 1); |
| 1193 | state->slot[1]->map (space->machine, state->state[1], 1); |
| 1171 | 1194 | } |
| 1172 | | if (msx1.slot[2]->slot_type == SLOT_KOREAN_90IN1) |
| 1195 | if (state->slot[2]->slot_type == SLOT_KOREAN_90IN1) |
| 1173 | 1196 | { |
| 1174 | | msx1.slot[2]->map (space->machine, msx1.state[2], 2); |
| 1197 | state->slot[2]->map (space->machine, state->state[2], 2); |
| 1175 | 1198 | } |
| 1176 | 1199 | } |
| 1177 | 1200 | |
| 1178 | 1201 | READ8_HANDLER (msx_kanji_r) |
| 1179 | 1202 | { |
| 1203 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1180 | 1204 | UINT8 result = 0xff; |
| 1181 | 1205 | |
| 1182 | | if (offset && msx1.kanji_mem) |
| 1206 | if (offset && state->kanji_mem) |
| 1183 | 1207 | { |
| 1184 | 1208 | int latch; |
| 1185 | 1209 | UINT8 ret; |
| 1186 | 1210 | |
| 1187 | | latch = msx1.kanji_latch; |
| 1188 | | ret = msx1.kanji_mem[latch++]; |
| 1211 | latch = state->kanji_latch; |
| 1212 | ret = state->kanji_mem[latch++]; |
| 1189 | 1213 | |
| 1190 | | msx1.kanji_latch &= ~0x1f; |
| 1191 | | msx1.kanji_latch |= latch & 0x1f; |
| 1214 | state->kanji_latch &= ~0x1f; |
| 1215 | state->kanji_latch |= latch & 0x1f; |
| 1192 | 1216 | |
| 1193 | 1217 | result = ret; |
| 1194 | 1218 | } |
| r9705 | r9706 | |
| 1197 | 1221 | |
| 1198 | 1222 | WRITE8_HANDLER (msx_kanji_w) |
| 1199 | 1223 | { |
| 1224 | msx_state *state = space->machine->driver_data<msx_state>(); |
| 1200 | 1225 | if (offset) |
| 1201 | 1226 | { |
| 1202 | | msx1.kanji_latch = |
| 1203 | | (msx1.kanji_latch & 0x007E0) | ((data & 0x3f) << 11); |
| 1227 | state->kanji_latch = |
| 1228 | (state->kanji_latch & 0x007E0) | ((data & 0x3f) << 11); |
| 1204 | 1229 | } |
| 1205 | 1230 | else |
| 1206 | 1231 | { |
| 1207 | | msx1.kanji_latch = |
| 1208 | | (msx1.kanji_latch & 0x1f800) | ((data & 0x3f) << 5); |
| 1232 | state->kanji_latch = |
| 1233 | (state->kanji_latch & 0x1f800) | ((data & 0x3f) << 5); |
| 1209 | 1234 | } |
| 1210 | 1235 | } |