src/mess/machine/nes_pcb.c
| r8305 | r8306 | |
| 22 | 22 | { "HVC-NROM-256", STD_NROM }, |
| 23 | 23 | { "HVC-RROM", STD_NROM }, |
| 24 | 24 | { "HVC-RROM-128", STD_NROM }, |
| 25 | { "HVC-RTROM", STD_NROM }, |
| 25 | 26 | { "HVC-SROM", STD_NROM }, |
| 26 | 27 | { "HVC-STROM", STD_NROM }, |
| 27 | 28 | { "NES-HROM", STD_NROM }, |
| r8305 | r8306 | |
| 39 | 40 | { "BANDAI-NROM-256", STD_NROM }, |
| 40 | 41 | { "KONAMI-NROM-128", STD_NROM }, |
| 41 | 42 | { "SETA-NROM-128", STD_NROM }, |
| 43 | { "SUNSOFT-NROM-128", STD_NROM }, |
| 42 | 44 | { "SUNSOFT-NROM-256", STD_NROM }, |
| 43 | 45 | { "TAITO-NROM-128", STD_NROM }, |
| 44 | 46 | { "TAITO-NROM-256", STD_NROM }, |
| 45 | 47 | { "NAMCOT-3301", STD_NROM }, |
| 46 | 48 | { "NAMCOT-3302", STD_NROM }, |
| 47 | 49 | { "NAMCOT-3303", STD_NROM }, |
| 50 | { "NAMCOT-3304", STD_NROM }, |
| 48 | 51 | { "NAMCOT-3305", STD_NROM }, |
| 49 | 52 | { "NAMCOT-3311", STD_NROM }, |
| 53 | { "NAMCOT-3312", STD_NROM }, |
| 50 | 54 | { "NAMCOT-3411", STD_NROM }, |
| 51 | 55 | { "JALECO-JF-01", STD_NROM }, |
| 52 | 56 | { "JALECO-JF-02", STD_NROM }, |
| 53 | 57 | { "JALECO-JF-03", STD_NROM }, |
| 54 | 58 | { "JALECO-JF-04", STD_NROM }, |
| 55 | 59 | { "TENGEN-800003", STD_NROM }, |
| 60 | { "SACHEN-NROM", STD_NROM }, |
| 56 | 61 | /* Nintendo Family BASIC pcb (NROM + 2K or 4K WRAM) */ |
| 57 | 62 | { "HVC-FAMILYBASIC", HVC_FAMBASIC }, |
| 58 | 63 | /* Game Genie */ |
| r8305 | r8306 | |
| 60 | 65 | // |
| 61 | 66 | /* Nintendo UNROM/UOROM */ |
| 62 | 67 | { "HVC-UNROM", STD_UXROM }, |
| 68 | { "HVC-UNEPROM", STD_UXROM }, |
| 63 | 69 | { "HVC-UOROM", STD_UXROM }, |
| 64 | 70 | { "NES-UNROM", STD_UXROM }, |
| 71 | { "NES-UNEPROM", STD_UXROM }, |
| 65 | 72 | { "NES-UOROM", STD_UXROM }, |
| 66 | 73 | { "HVC-UNROM+74HC08", UXROM_CC }, |
| 67 | 74 | /* UxROM boards by other manufacturer */ |
| r8305 | r8306 | |
| 71 | 78 | { "JALECO-JF-15", STD_UXROM }, |
| 72 | 79 | { "JALECO-JF-18", STD_UXROM }, |
| 73 | 80 | { "JALECO-JF-39", STD_UXROM }, |
| 74 | | { "UNL-UXROM", STD_UXROM }, // e.g. mapper 2 mod (see Korean Igo) |
| 75 | 81 | // |
| 76 | 82 | /* Nintendo CNROM */ |
| 77 | 83 | { "HVC-CNROM", STD_CNROM }, |
| r8305 | r8306 | |
| 79 | 85 | /* CxROM boards by other manufacturer */ |
| 80 | 86 | { "BANDAI-CNROM", STD_CNROM }, |
| 81 | 87 | { "KONAMI-CNROM", STD_CNROM }, |
| 88 | { "NAMCOT-CNROM+WRAM", STD_CNROM }, |
| 82 | 89 | { "TAITO-CNROM", STD_CNROM }, |
| 83 | 90 | { "AVE-74*161", STD_CNROM }, |
| 91 | { "NTDEC-N715061", STD_CNROM }, |
| 84 | 92 | { "NTDEC-N715062", STD_CNROM }, |
| 85 | 93 | { "SACHEN-CNROM", STD_CNROM }, |
| 86 | 94 | /* Bandai Aerobics Studio (CNROM boards + special audio chip) */ |
| r8305 | r8306 | |
| 165 | 173 | { "HVC-SGROM", STD_SXROM }, |
| 166 | 174 | { "HVC-SH1ROM", STD_SXROM }, |
| 167 | 175 | { "HVC-SHROM", STD_SXROM }, |
| 176 | { "HVC-SIROM", STD_SXROM }, |
| 168 | 177 | { "HVC-SJROM", STD_SXROM }, |
| 169 | 178 | { "HVC-SKROM", STD_SXROM }, |
| 179 | { "HVC-SKEPROM", STD_SXROM }, |
| 170 | 180 | { "HVC-SL1ROM", STD_SXROM }, |
| 171 | 181 | { "HVC-SL2ROM", STD_SXROM }, |
| 172 | 182 | { "HVC-SL3ROM", STD_SXROM }, |
| 173 | 183 | { "HVC-SLROM", STD_SXROM }, |
| 174 | 184 | { "HVC-SLRROM", STD_SXROM }, |
| 185 | { "HVC-SMROM", STD_SXROM }, |
| 175 | 186 | { "HVC-SNROM", STD_SXROM }, |
| 176 | 187 | { "HVC-SUROM", STD_SXROM }, |
| 177 | 188 | { "HVC-SXROM", STD_SXROM }, |
| r8305 | r8306 | |
| 185 | 196 | { "NES-SGROM", STD_SXROM }, |
| 186 | 197 | { "NES-SH1ROM", STD_SXROM }, |
| 187 | 198 | { "NES-SHROM", STD_SXROM }, |
| 199 | { "NES-SIROM", STD_SXROM }, |
| 188 | 200 | { "NES-SJROM", STD_SXROM }, |
| 189 | 201 | { "NES-SKROM", STD_SXROM }, |
| 202 | { "NES-SKEPROM", STD_SXROM }, |
| 190 | 203 | { "NES-SL1ROM", STD_SXROM }, |
| 191 | 204 | { "NES-SL2ROM", STD_SXROM }, |
| 192 | 205 | { "NES-SL3ROM", STD_SXROM }, |
| 193 | 206 | { "NES-SLROM", STD_SXROM }, |
| 194 | 207 | { "NES-SLRROM", STD_SXROM }, |
| 208 | { "NES-SMROM", STD_SXROM }, |
| 195 | 209 | { "NES-SNROM", STD_SXROM }, |
| 196 | 210 | { "NES-SUROM", STD_SXROM }, |
| 197 | 211 | { "NES-SXROM", STD_SXROM }, |
| r8305 | r8306 | |
| 303 | 317 | /* Discrete board IC_74x161x138 */ |
| 304 | 318 | { "BIT-CORP-74*161/138", DIS_74X161X138 }, |
| 305 | 319 | // |
| 306 | | { "BANDAI-LZ93D50+24C01", BANDAI_LZ93 }, |
| 307 | | { "BANDAI-LZ93D50+24C02", BANDAI_LZ93 }, |
| 320 | { "BANDAI-LZ93D50", BANDAI_LZ93 }, |
| 321 | { "BANDAI-LZ93D50+24C01", BANDAI_LZ93EX }, |
| 322 | { "BANDAI-LZ93D50+24C02", BANDAI_LZ93EX }, |
| 308 | 323 | { "BANDAI-FCG-1", BANDAI_FCG }, |
| 309 | 324 | { "BANDAI-FCG-2", BANDAI_FCG }, |
| 310 | 325 | { "BANDAI-JUMP2", BANDAI_JUMP2 }, |
| r8305 | r8306 | |
| 316 | 331 | { "IREM-G101", IREM_G101 }, |
| 317 | 332 | { "IREM-74*161/161/21/138", IREM_LROG017 }, |
| 318 | 333 | { "IREM-H-3001", IREM_H3001 }, |
| 334 | { "IREM-H3001", IREM_H3001 }, |
| 319 | 335 | { "IREM-HOLYDIVER", IREM_HOLYDIV }, |
| 320 | 336 | { "IREM-TAM-S1", IREM_TAM_S1 }, |
| 321 | 337 | // |
| r8305 | r8306 | |
| 357 | 373 | { "UNL-VRC7", KONAMI_VRC7 }, |
| 358 | 374 | // |
| 359 | 375 | { "NAMCOT-163", NAMCOT_163 }, |
| 376 | { "NAMCOT-175", NAMCOT_163 }, |
| 377 | { "NAMCOT-340", NAMCOT_163 }, |
| 360 | 378 | { "NAMCOT-3425", NAMCOT_3425 }, |
| 361 | 379 | { "NAMCOT-3433", NAMCOT_34X3 }, |
| 362 | 380 | { "NAMCOT-3443", NAMCOT_34X3 }, |
| r8305 | r8306 | |
| 369 | 387 | // |
| 370 | 388 | { "TAITO-TC0190FMC", TAITO_TC0190FMC }, |
| 371 | 389 | { "TAITO-TC0190FMC+PAL16R4", TAITO_TC0190FMCP }, |
| 390 | { "TAITO-TC0350FMR", TAITO_TC0190FMC }, |
| 372 | 391 | { "TAITO-X1-005", TAITO_X1_005 }, // two variants exist, depending on pin17 & pin31 connections |
| 373 | 392 | { "TAITO-X1-017", TAITO_X1_017 }, |
| 374 | 393 | // |
| r8305 | r8306 | |
| 378 | 397 | { "AVE-NINA-03", AVE_NINA06 }, |
| 379 | 398 | { "AVE-NINA-06", AVE_NINA06 }, |
| 380 | 399 | { "AVE-MB-91", AVE_NINA06 }, |
| 400 | { "TXC-74*138/175", AVE_NINA06 }, |
| 381 | 401 | { "UNL-SA-016-1M", AVE_NINA06 }, |
| 382 | 402 | { "CAMERICA-ALGN", CAMERICA_BF9093 }, |
| 383 | 403 | { "CAMERICA-BF9093", CAMERICA_BF9093 }, |
| r8305 | r8306 | |
| 432 | 452 | { "WAIXING-SH2", UNSUPPORTED_BOARD }, |
| 433 | 453 | // |
| 434 | 454 | { "TXC-TW", TXC_TW }, |
| 455 | { "TXC-STRIKEWOLF", TXC_STRIKEWOLF }, |
| 435 | 456 | { "TXC-MXMDHTWO", TXC_MXMDHTWO }, |
| 436 | 457 | { "UNL-22211", TXC_22211A }, |
| 437 | 458 | /* FIXME: Made up boards the different mirroring handling */ |
| r8305 | r8306 | |
| 481 | 502 | { "UNL-A9746", UNSUPPORTED_BOARD },// mapper 219 |
| 482 | 503 | { "UNL-603-5052", UNSUPPORTED_BOARD },// mapper 238? |
| 483 | 504 | { "UNL-SHJY3", UNSUPPORTED_BOARD },// mapper 253 |
| 505 | { "UNL-RACERMATE", UNL_RACERMATE },// mapper 168 |
| 484 | 506 | { "UNL-N625092", UNL_N625092 }, |
| 485 | 507 | { "BMC-N625092", UNL_N625092 }, |
| 486 | 508 | { "UNL-SC-127", UNL_SC127 }, |
| 487 | 509 | { "UNL-SMB2J", UNL_SMB2J }, |
| 510 | { "BTL-SMB2C", UNL_SMB2J }, |
| 488 | 511 | { "UNL-MK2", UNL_MK2 }, |
| 489 | 512 | { "UNL-XZY", UNL_XZY }, |
| 490 | 513 | { "UNL-KOF96", UNL_KOF96 }, |
| r8305 | r8306 | |
| 551 | 574 | { "BMC-411120-C", UNSUPPORTED_BOARD }, |
| 552 | 575 | { "BMC-830118C", UNSUPPORTED_BOARD }, |
| 553 | 576 | { "BMC-12-IN-1", UNSUPPORTED_BOARD }, |
| 577 | { "BMC-NTD-03", UNSUPPORTED_BOARD }, |
| 554 | 578 | { "BMC-8157", UNSUPPORTED_BOARD /*BMC_8157*/ }, |
| 555 | 579 | { "BMC-BS-5", UNSUPPORTED_BOARD /*BENSHENG_BS5*/ }, |
| 556 | 580 | { "BMC-FK23C", UNSUPPORTED_BOARD /*BMC_FK23C*/ }, |
| 557 | 581 | { "BMC-FK23CA", UNSUPPORTED_BOARD /*BMC_FK23C*/ }, // diff reg init |
| 558 | 582 | { "BMC-GHOSTBUSTERS63IN1", UNSUPPORTED_BOARD /*BMC_G63IN1*/ }, |
| 559 | | { "BMC-SUPERVISION16IN1", UNSUPPORTED_BOARD }, // mapper 53 |
| 560 | | { "BMC-RESETBASED-4IN1", UNSUPPORTED_BOARD },// mapper 60 with 64k prg and 32k chr |
| 583 | { "BMC-SUPERVISION16IN1", UNSUPPORTED_BOARD }, // mapper 53 |
| 584 | { "BMC-RESETBASED-4IN1", UNSUPPORTED_BOARD },// mapper 60 with 64k prg and 32k chr |
| 561 | 585 | { "BMC-VT5201", UNSUPPORTED_BOARD },// mapper 60 otherwise |
| 562 | | { "BMC-42IN1RESETSWITCH", UNSUPPORTED_BOARD }, // mapper 60? |
| 586 | { "BMC-42IN1RESETSWITCH", UNSUPPORTED_BOARD }, // mapper 60? |
| 563 | 587 | { "BMC-D1038", UNSUPPORTED_BOARD }, // mapper 60? |
| 564 | 588 | { "BMC-SUPER22GAMES", UNSUPPORTED_BOARD },// mapper 233 |
| 565 | | { "BMC-GOLDENGAME-150IN1", UNSUPPORTED_BOARD },// mapper 235 with 2M PRG |
| 566 | | { "BMC-GOLDENGAME-260IN1", UNSUPPORTED_BOARD },// mapper 235 with 4M PRG |
| 589 | { "BMC-GOLDENGAME-150IN1", UNSUPPORTED_BOARD },// mapper 235 with 2M PRG |
| 590 | { "BMC-GOLDENGAME-260IN1", UNSUPPORTED_BOARD },// mapper 235 with 4M PRG |
| 567 | 591 | { "BMC-70IN1", UNSUPPORTED_BOARD }, // mapper 236? |
| 568 | 592 | { "BMC-70IN1B", UNSUPPORTED_BOARD }, // mapper 236? |
| 569 | 593 | { "BMC-SUPERHIK-KOF", UNSUPPORTED_BOARD },// mapper 251 |
| 570 | | { "BMC-POWERJOY", UNSUPPORTED_BOARD },// mapper 126 |
| 594 | { "BMC-POWERJOY", UNSUPPORTED_BOARD },// mapper 126 |
| 571 | 595 | // are there dumps of games with these boards? |
| 572 | 596 | { "WAIXING-I", UNSUPPORTED_BOARD }, // [supported by NEStopia - we need more info] |
| 573 | 597 | { "WAIXING-J", UNSUPPORTED_BOARD }, // [supported by NEStopia - we need more info] |
| r8305 | r8306 | |
| 579 | 603 | { "UNL-C-N22M", UNSUPPORTED_BOARD }, // [mentioned in FCEUMM source - we need more info] |
| 580 | 604 | { "UNL-KS7017", UNSUPPORTED_BOARD }, // [mentioned in FCEUMM source - we need more info] |
| 581 | 605 | { "UNL-PEC-586", UNSUPPORTED_BOARD }, // [mentioned in FCEUMM source - we need more info] |
| 582 | | { "UNL-SA-009", UNSUPPORTED_BOARD } // [mentioned in FCEUMM source - we need more info] |
| 606 | { "UNL-SA-009", UNSUPPORTED_BOARD }, // [mentioned in FCEUMM source - we need more info] |
| 607 | // |
| 608 | { "UNKNOWN", UNSUPPORTED_BOARD } // a few pirate dumps uses the wrong mapper... |
| 583 | 609 | }; |
| 584 | 610 | |
| 585 | 611 | const nes_pcb *nes_pcb_lookup( const char *board ) |
| r8305 | r8306 | |
| 817 | 843 | |
| 818 | 844 | *************************************************************/ |
| 819 | 845 | |
| 846 | static TIMER_CALLBACK( mmc1_resync_callback ) |
| 847 | { |
| 848 | nes_state *state = (nes_state *)machine->driver_data; |
| 849 | state->mmc1_reg_write_enable = 1; |
| 850 | } |
| 851 | |
| 852 | |
| 820 | 853 | static void mmc1_set_wram( const address_space *space, int board ) |
| 821 | 854 | { |
| 822 | 855 | running_machine *machine = space->machine; |
| r8305 | r8306 | |
| 868 | 901 | However, quoting Disch's docs: When in 4k CHR mode, 0x10 in both $A000 and $C000 *must* be |
| 869 | 902 | set to the same value, or else pages will constantly be swapped as graphics render! |
| 870 | 903 | Hence, we use only mmc_reg[1]&0x10 for prg_offset */ |
| 871 | | |
| 904 | |
| 872 | 905 | switch (prg_mode) |
| 873 | 906 | { |
| 874 | 907 | case 0x00: |
| 875 | 908 | case 0x04: |
| 876 | | prg32(machine, prg_offset + state->mmc_reg[3]); |
| 909 | // printf("PRG 32 bank %d \n", (prg_offset + state->mmc_reg[3]) >> 1); |
| 910 | prg32(machine, (prg_offset + state->mmc_reg[3]) >> 1); |
| 877 | 911 | break; |
| 878 | 912 | case 0x08: |
| 913 | // printf("PRG 16 bank %d (high) \n", prg_offset + state->mmc_reg[3]); |
| 879 | 914 | prg16_89ab(machine, prg_offset + 0); |
| 880 | 915 | prg16_cdef(machine, prg_offset + state->mmc_reg[3]); |
| 881 | 916 | break; |
| 882 | 917 | case 0x0c: |
| 918 | // printf("PRG 16 bank %d (low) \n", prg_offset + state->mmc_reg[3]); |
| 883 | 919 | prg16_89ab(machine, prg_offset + state->mmc_reg[3]); |
| 884 | 920 | prg16_cdef(machine, prg_offset + 0x0f); |
| 885 | 921 | break; |
| r8305 | r8306 | |
| 895 | 931 | static void mmc1_set_chr( running_machine *machine ) |
| 896 | 932 | { |
| 897 | 933 | nes_state *state = (nes_state *)machine->driver_data; |
| 898 | | UINT8 chr_mode = state->mmc_reg[0] & 0x10; |
| 934 | UINT8 chr_mode = BIT(state->mmc_reg[0], 4); |
| 899 | 935 | |
| 900 | 936 | if (chr_mode) |
| 901 | 937 | { |
| r8305 | r8306 | |
| 915 | 951 | |
| 916 | 952 | /* here we would need to add an if(cpu_cycles_passed>1) test, and |
| 917 | 953 | if requirement is not met simply return without writing anything. |
| 918 | | AD&D Hillsfar and Bill & Ted rely on this behavior!! */ |
| 954 | Some games (AD&D Hillsfar, Bill & Ted Excellent Adventure, Cosmic |
| 955 | Wars, Rocket Ranger, Sesame Street 123 and Snow Brothers) rely on |
| 956 | this behavior!! */ |
| 957 | if (state->mmc1_reg_write_enable == 0) |
| 958 | { |
| 959 | return; |
| 960 | } |
| 961 | else |
| 962 | { |
| 963 | state->mmc1_reg_write_enable = 0; |
| 964 | timer_call_after_resynch(space->machine, NULL, 0, mmc1_resync_callback); |
| 965 | } |
| 966 | |
| 919 | 967 | if (data & 0x80) |
| 920 | 968 | { |
| 921 | 969 | state->mmc_count = 0; |
| r8305 | r8306 | |
| 1090 | 1138 | nes_state *state = (nes_state *)machine->driver_data; |
| 1091 | 1139 | |
| 1092 | 1140 | if (BIT(state->mmc_latch2, 7)) |
| 1093 | | memory_install_readwrite_bank(space, 0x6000, 0x7fff, 0, 0, "bank5"); |
| 1141 | memory_install_readwrite_bank(space, 0x6000, 0x7fff, 0, 0, "bank5"); |
| 1094 | 1142 | else |
| 1095 | 1143 | { |
| 1096 | 1144 | memory_unmap_readwrite(space, 0x6000, 0x7fff, 0, 0); |
| 1097 | 1145 | return; |
| 1098 | 1146 | } |
| 1099 | 1147 | |
| 1100 | | if (BIT(state->mmc_latch2, 6)) |
| 1148 | if (!BIT(state->mmc_latch2, 6)) |
| 1101 | 1149 | memory_install_write_bank(space, 0x6000, 0x7fff, 0, 0, "bank5"); |
| 1102 | 1150 | else |
| 1103 | 1151 | { |
| 1104 | 1152 | memory_unmap_write(space, 0x6000, 0x7fff, 0, 0); |
| 1105 | 1153 | return; |
| 1106 | 1154 | } |
| 1107 | | |
| 1108 | | wram_bank(machine, 0, state->battery_size ? NES_BATTERY : NES_WRAM); |
| 1109 | 1155 | } |
| 1110 | 1156 | |
| 1111 | 1157 | static void mmc3_set_prg( running_machine *machine, int prg_base, int prg_mask ) |
| r8305 | r8306 | |
| 1147 | 1193 | else |
| 1148 | 1194 | state->IRQ_count--; |
| 1149 | 1195 | |
| 1150 | | if (state->IRQ_enable && !blanked && (state->IRQ_count == 0) && (priorCount || state->IRQ_clear || !state->mmc3_alt_irq)) |
| 1196 | if (state->IRQ_enable && !blanked && (state->IRQ_count == 0) && (priorCount || state->IRQ_clear /*|| !state->mmc3_alt_irq*/)) // according to blargg the latter should be present as well, but it breaks Rampart and Joe & Mac US: they probably use the alt irq! |
| 1151 | 1197 | { |
| 1152 | 1198 | LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline, |
| 1153 | 1199 | video_screen_get_vpos(device->machine->primary_screen), video_screen_get_hpos(device->machine->primary_screen))); |
| r8305 | r8306 | |
| 1244 | 1290 | if (offset < 0x1000) |
| 1245 | 1291 | return; |
| 1246 | 1292 | |
| 1247 | | offset &= 0x3ff; |
| 1248 | 1293 | // banks can be written only if both read & write is enabled! |
| 1249 | 1294 | write_hi = ((state->mmc6_reg & 0xc0) == 0xc0); |
| 1250 | | write_lo = ((state->mmc6_reg & 0x60) == 0x60); |
| 1295 | write_lo = ((state->mmc6_reg & 0x30) == 0x30); |
| 1251 | 1296 | |
| 1252 | 1297 | if (BIT(offset, 9) && write_hi) // access to upper 1k |
| 1253 | | state->battery_ram[offset] = data; |
| 1298 | state->mapper_ram[offset & (state->mapper_ram_size - 1)] = data; |
| 1254 | 1299 | |
| 1255 | 1300 | if (!BIT(offset, 9) && write_lo) // access to lower 1k |
| 1256 | | state->battery_ram[offset] = data; |
| 1301 | state->mapper_ram[offset & (state->mapper_ram_size - 1)] = data; |
| 1257 | 1302 | } |
| 1258 | 1303 | |
| 1259 | 1304 | static READ8_HANDLER( hkrom_m_r ) |
| r8305 | r8306 | |
| 1266 | 1311 | |
| 1267 | 1312 | if (!(state->mmc6_reg & 0xa0)) |
| 1268 | 1313 | return 0xff; // here it should be open bus |
| 1269 | | |
| 1270 | | offset &= 0x3ff; |
| 1271 | 1314 | |
| 1272 | 1315 | if (BIT(offset, 9) && BIT(state->mmc6_reg, 7)) // access to upper 1k when upper read is enabled |
| 1273 | | return state->battery_ram[offset]; |
| 1316 | return state->mapper_ram[offset & (state->mapper_ram_size - 1)]; |
| 1274 | 1317 | |
| 1275 | 1318 | if (!BIT(offset, 9) && BIT(state->mmc6_reg, 5)) // access to lower 1k when lower read is enabled |
| 1276 | | return state->battery_ram[offset]; |
| 1319 | return state->mapper_ram[offset & (state->mapper_ram_size - 1)]; |
| 1277 | 1320 | |
| 1278 | 1321 | // If only one bank is enabled for reading, the other reads back as zero |
| 1279 | 1322 | return 0x00; |
| r8305 | r8306 | |
| 1484 | 1527 | { |
| 1485 | 1528 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 1486 | 1529 | UINT8 map37_helper; |
| 1487 | | LOG_MMC(("mapper37_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 1530 | LOG_MMC(("zz_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 1488 | 1531 | |
| 1489 | | map37_helper = (data & 0x06) >> 1; |
| 1532 | map37_helper = data & 0x07; |
| 1490 | 1533 | |
| 1491 | | state->mmc_prg_base = map37_helper << 3; |
| 1492 | | state->mmc_prg_mask = (map37_helper == 2) ? 0x0f : 0x07; |
| 1493 | | state->mmc_chr_base = map37_helper << 6; |
| 1534 | state->mmc_prg_base = (BIT(map37_helper, 2) << 4) | (((map37_helper & 0x03) == 0x03) ? 0x08 : 0); |
| 1535 | state->mmc_prg_mask = (map37_helper << 1) | 0x07; |
| 1536 | state->mmc_chr_base = BIT(map37_helper, 2) << 7; |
| 1494 | 1537 | state->mmc_chr_mask = 0x7f; |
| 1495 | 1538 | mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask); |
| 1496 | 1539 | mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask); |
| r8305 | r8306 | |
| 1510 | 1553 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 1511 | 1554 | LOG_MMC(("qj_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 1512 | 1555 | |
| 1513 | | state->mmc_prg_base = (data & 0x01) << 4; |
| 1556 | state->mmc_prg_base = BIT(data, 0) << 4; |
| 1514 | 1557 | state->mmc_prg_mask = 0x0f; |
| 1515 | | state->mmc_chr_base = (data & 0x01) << 7; |
| 1558 | state->mmc_chr_base = BIT(data, 0) << 7; |
| 1516 | 1559 | state->mmc_chr_mask = 0x7f; |
| 1517 | 1560 | mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask); |
| 1518 | 1561 | mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask); |
| r8305 | r8306 | |
| 2323 | 2366 | { |
| 2324 | 2367 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 2325 | 2368 | LOG_MMC(("dxrom_w, offset: %04x, data: %02x\n", offset, data)); |
| 2326 | | |
| 2327 | | if (offset >= 0x2000) |
| 2369 | |
| 2370 | if (offset >= 0x2000) |
| 2328 | 2371 | return; |
| 2329 | | |
| 2372 | |
| 2330 | 2373 | switch (offset & 1) |
| 2331 | 2374 | { |
| 2332 | 2375 | case 1: |
| r8305 | r8306 | |
| 2348 | 2391 | } |
| 2349 | 2392 | } |
| 2350 | 2393 | |
| 2394 | |
| 2351 | 2395 | /************************************************************* |
| 2352 | 2396 | |
| 2353 | 2397 | Namcot 3453 board emulation |
| r8305 | r8306 | |
| 2355 | 2399 | These are the same as Namcot 34x3, but with additional mirroring |
| 2356 | 2400 | control |
| 2357 | 2401 | |
| 2358 | | iNES: mappers 154 |
| 2402 | iNES: mapper 154 |
| 2359 | 2403 | |
| 2360 | 2404 | *************************************************************/ |
| 2361 | 2405 | |
| r8305 | r8306 | |
| 2376 | 2420 | |
| 2377 | 2421 | These are similar Namcot 34x3, but different bankswitch capabilities |
| 2378 | 2422 | |
| 2379 | | iNES: mappers 76 |
| 2423 | iNES: mapper 76 |
| 2380 | 2424 | |
| 2381 | 2425 | *************************************************************/ |
| 2382 | 2426 | |
| r8305 | r8306 | |
| 2612 | 2656 | LOG_MMC(("lz93d50_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 2613 | 2657 | |
| 2614 | 2658 | if (!state->battery && !state->wram) |
| 2615 | | lz93d50_w(space, offset, data); |
| 2659 | lz93d50_w(space, offset & 0x0f, data); |
| 2616 | 2660 | else if (state->battery) |
| 2617 | 2661 | state->battery_ram[offset] = data; |
| 2618 | 2662 | else |
| r8305 | r8306 | |
| 2628 | 2672 | for (i = 0; i < 8; i++) |
| 2629 | 2673 | mmc_helper |= ((state->mmc_reg[i] & 0x01) << 4); |
| 2630 | 2674 | |
| 2631 | | state->mmc_latch1 = mmc_helper | (state->mmc_latch1 & 0x0f); |
| 2632 | | |
| 2633 | | prg16_89ab(machine, state->mmc_latch1); |
| 2675 | prg16_89ab(machine, mmc_helper | state->mmc_latch1); |
| 2634 | 2676 | prg16_cdef(machine, mmc_helper | 0x0f); |
| 2635 | 2677 | } |
| 2636 | 2678 | |
| 2637 | 2679 | static WRITE8_HANDLER( fjump2_w ) |
| 2638 | 2680 | { |
| 2639 | 2681 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 2640 | | |
| 2641 | 2682 | LOG_MMC(("fjump2_w, offset: %04x, data: %02x\n", offset, data)); |
| 2642 | 2683 | |
| 2643 | 2684 | switch (offset & 0x000f) |
| r8305 | r8306 | |
| 2648 | 2689 | fjump2_set_prg(space->machine); |
| 2649 | 2690 | break; |
| 2650 | 2691 | case 8: |
| 2651 | | state->mmc_latch1 = (data & 0x0f) | (state->mmc_latch1 & 0x10); |
| 2652 | | prg16_89ab(space->machine, state->mmc_latch1); |
| 2692 | state->mmc_latch1 = (data & 0x0f); |
| 2693 | fjump2_set_prg(space->machine); |
| 2653 | 2694 | break; |
| 2654 | 2695 | default: |
| 2655 | 2696 | lz93d50_m_w(space, offset & 0x0f, data); |
| r8305 | r8306 | |
| 2694 | 2735 | |
| 2695 | 2736 | state->mmc_latch1 = data; |
| 2696 | 2737 | mmc_helper = (state->mmc_latch1 & 0x03) | (data & 0x04); |
| 2697 | | chr4_0(space->machine, mmc_helper, state->mmc_chr_source); |
| 2698 | | chr4_4(space->machine, 0x03 | (data & 0x04), state->mmc_chr_source); |
| 2738 | chr4_0(space->machine, mmc_helper, CHRRAM); |
| 2739 | chr4_4(space->machine, 0x03 | (data & 0x04), CHRRAM); |
| 2699 | 2740 | } |
| 2700 | 2741 | |
| 2701 | 2742 | /************************************************************* |
| r8305 | r8306 | |
| 3109 | 3150 | if (BIT(data, 6)) |
| 3110 | 3151 | chr8(space->machine, data & 0x0f, CHRROM); |
| 3111 | 3152 | if (BIT(data, 5) && !BIT(data,4)) |
| 3112 | | LOG_MMC(("Jaleco JF-17 sound write, data: %02x\n", data & 0x1f)); |
| 3153 | LOG_MMC(("Jaleco JF-19 sound write, data: %02x\n", data & 0x1f)); |
| 3113 | 3154 | } |
| 3114 | 3155 | |
| 3115 | 3156 | /************************************************************* |
| r8305 | r8306 | |
| 3169 | 3210 | static WRITE8_HANDLER( konami_vrc2_w ) |
| 3170 | 3211 | { |
| 3171 | 3212 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 3172 | | UINT8 bank, shift; |
| 3213 | UINT8 bank, shift, mask; |
| 3173 | 3214 | UINT32 shifted_offs = (offset & 0x7000) |
| 3174 | 3215 | | ((offset << (9 - state->vrc_ls_prg_a)) & 0x200) |
| 3175 | 3216 | | ((offset << (8 - state->vrc_ls_prg_b)) & 0x100); |
| r8305 | r8306 | |
| 3191 | 3232 | prg8_ab(space->machine, data); |
| 3192 | 3233 | else if (offset < 0x7000) |
| 3193 | 3234 | { |
| 3235 | bank = ((shifted_offs & 0x7000) - 0x3000) / 0x0800 + BIT(shifted_offs, 9); |
| 3194 | 3236 | shift = BIT(shifted_offs, 8) * 4; |
| 3195 | | bank = ((shifted_offs & 0x7000) - 0x3000) / 0x0800 + BIT(shifted_offs, 9); |
| 3196 | | state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & (0xf0 >> shift)) |
| 3197 | | | ((data >> state->vrc_ls_chr) << shift); |
| 3237 | mask = (0xf0 >> shift); |
| 3238 | state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & mask) |
| 3239 | | (((data >> state->vrc_ls_chr) & 0x0f) << shift); |
| 3198 | 3240 | chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM); |
| 3199 | 3241 | } |
| 3200 | 3242 | else |
| r8305 | r8306 | |
| 3286 | 3328 | static WRITE8_HANDLER( konami_vrc4_w ) |
| 3287 | 3329 | { |
| 3288 | 3330 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 3289 | | UINT8 bank, shift; |
| 3331 | UINT8 bank, shift, mask; |
| 3290 | 3332 | UINT32 shifted_offs = (offset & 0x7000) |
| 3291 | 3333 | | ((offset << (9 - state->vrc_ls_prg_a)) & 0x200) |
| 3292 | 3334 | | ((offset << (8 - state->vrc_ls_prg_b)) & 0x100); |
| r8305 | r8306 | |
| 3298 | 3340 | vrc4_set_prg(space->machine); |
| 3299 | 3341 | } |
| 3300 | 3342 | else if (offset >= 0x2000 && offset < 0x3000) |
| 3301 | | prg8_cd(space->machine, data); |
| 3343 | prg8_ab(space->machine, data); |
| 3302 | 3344 | else |
| 3303 | 3345 | { |
| 3304 | 3346 | switch (shifted_offs & 0x7300) |
| r8305 | r8306 | |
| 3306 | 3348 | case 0x1000: |
| 3307 | 3349 | case 0x1100: |
| 3308 | 3350 | switch (data & 0x03) |
| 3309 | | { |
| 3351 | { |
| 3310 | 3352 | case 0x00: set_nt_mirroring(space->machine, PPU_MIRROR_VERT); break; |
| 3311 | 3353 | case 0x01: set_nt_mirroring(space->machine, PPU_MIRROR_HORZ); break; |
| 3312 | 3354 | case 0x02: set_nt_mirroring(space->machine, PPU_MIRROR_LOW); break; |
| 3313 | 3355 | case 0x03: set_nt_mirroring(space->machine, PPU_MIRROR_HIGH); break; |
| 3314 | | } |
| 3356 | } |
| 3315 | 3357 | break; |
| 3316 | 3358 | case 0x1200: |
| 3317 | 3359 | case 0x1300: |
| r8305 | r8306 | |
| 3334 | 3376 | case 0x6100: |
| 3335 | 3377 | case 0x6200: |
| 3336 | 3378 | case 0x6300: |
| 3379 | bank = ((shifted_offs & 0x7000) - 0x3000) / 0x0800 + BIT(shifted_offs, 9); |
| 3337 | 3380 | shift = BIT(shifted_offs, 8) * 4; |
| 3338 | | bank = ((shifted_offs & 0x7000) - 0x3000) / 0x0800 + BIT(shifted_offs, 9); |
| 3339 | | state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & (0xf0 >> shift)) | (data << shift); |
| 3381 | mask = (0xf0 >> shift); |
| 3382 | state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & mask) | ((data & 0x0f) << shift); |
| 3340 | 3383 | chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM); |
| 3341 | 3384 | break; |
| 3342 | 3385 | case 0x7000: |
| r8305 | r8306 | |
| 3366 | 3409 | |
| 3367 | 3410 | Konami VRC-6 |
| 3368 | 3411 | |
| 3369 | | In MESS: Supported. It also uses konami_irq. |
| 3412 | In MESS: Supported. It also uses konami_irq (there are IRQ |
| 3413 | issues though: see Akumajou Densetsu intro). |
| 3370 | 3414 | |
| 3371 | 3415 | *************************************************************/ |
| 3372 | 3416 | |
| r8305 | r8306 | |
| 3644 | 3688 | |
| 3645 | 3689 | Sunsoft-1 board emulation |
| 3646 | 3690 | |
| 3647 | | iNES: mapper 184 |
| 3691 | iNES: mapper 184 (Fantasy Zone uses this board with no |
| 3692 | CHRROM, and the register switches PRG banks) |
| 3648 | 3693 | |
| 3649 | 3694 | *************************************************************/ |
| 3650 | 3695 | |
| 3651 | 3696 | static WRITE8_HANDLER( sunsoft1_m_w ) |
| 3652 | 3697 | { |
| 3698 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 3653 | 3699 | LOG_MMC(("sunsoft1_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 3654 | 3700 | |
| 3655 | | chr4_0(space->machine, data & 0x0f, CHRROM); |
| 3656 | | chr4_4(space->machine, data >> 4, CHRROM); |
| 3701 | if (state->chr_chunks) |
| 3702 | { |
| 3703 | chr4_0(space->machine, data & 0x0f, CHRROM); |
| 3704 | chr4_4(space->machine, data >> 4, CHRROM); |
| 3705 | } |
| 3706 | else |
| 3707 | prg16_89ab(space->machine, data & 0x0f); |
| 3657 | 3708 | } |
| 3658 | 3709 | |
| 3659 | 3710 | /************************************************************* |
| r8305 | r8306 | |
| 3671 | 3722 | { |
| 3672 | 3723 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 3673 | 3724 | UINT8 sunsoft_helper = (data & 0x07) | ((data & 0x80) ? 0x08 : 0x00); |
| 3674 | | LOG_MMC(("mapper93_w, offset: %04x, data: %02x\n", offset, data)); |
| 3725 | LOG_MMC(("sunsoft2_w, offset: %04x, data: %02x\n", offset, data)); |
| 3675 | 3726 | |
| 3676 | 3727 | if (!state->hard_mirroring) // there are two 'variants' depending on hardwired or mapper ctrl mirroring |
| 3677 | 3728 | set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW); |
| 3729 | if (state->chr_chunks) |
| 3730 | chr8(space->machine, sunsoft_helper, CHRROM); |
| 3731 | |
| 3678 | 3732 | prg16_89ab(space->machine, data >> 4); |
| 3679 | | chr8(space->machine, sunsoft_helper, CHRROM); |
| 3680 | 3733 | } |
| 3681 | 3734 | |
| 3682 | 3735 | /************************************************************* |
| r8305 | r8306 | |
| 3864 | 3917 | |
| 3865 | 3918 | static WRITE8_HANDLER( x1005_m_w ) |
| 3866 | 3919 | { |
| 3920 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 3867 | 3921 | LOG_MMC(("x1005_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 3868 | 3922 | |
| 3869 | 3923 | switch (offset) |
| r8305 | r8306 | |
| 3890 | 3944 | case 0x1ef7: |
| 3891 | 3945 | set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_VERT : PPU_MIRROR_HORZ); |
| 3892 | 3946 | break; |
| 3947 | case 0x1ef8: |
| 3948 | case 0x1ef9: |
| 3949 | state->mmc_latch1 = data; |
| 3950 | break; |
| 3893 | 3951 | case 0x1efa: |
| 3894 | 3952 | case 0x1efb: |
| 3895 | 3953 | prg8_89(space->machine, data); |
| r8305 | r8306 | |
| 3906 | 3964 | logerror("mapper80_m_w uncaught addr: %04x, value: %02x\n", offset + 0x6000, data); |
| 3907 | 3965 | break; |
| 3908 | 3966 | } |
| 3967 | |
| 3968 | if (offset >= 0x1f00 && state->mapper_ram != NULL && state->mmc_latch1 == 0xa3) |
| 3969 | state->mapper_ram[offset & (state->mapper_ram_size - 1)] = data; |
| 3909 | 3970 | } |
| 3910 | 3971 | |
| 3972 | static READ8_HANDLER( x1005_m_r ) |
| 3973 | { |
| 3974 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 3975 | LOG_MMC(("x1005a_m_r, offset: %04x\n", offset)); |
| 3976 | |
| 3977 | if (offset >= 0x1f00 && state->mapper_ram != NULL && state->mmc_latch1 == 0xa3) |
| 3978 | return state->mapper_ram[offset & (state->mapper_ram_size - 1)]; |
| 3979 | |
| 3980 | return 0xff; |
| 3981 | } |
| 3982 | |
| 3911 | 3983 | static WRITE8_HANDLER( x1005a_m_w ) |
| 3912 | 3984 | { |
| 3913 | 3985 | LOG_MMC(("x1005a_m_w, offset: %04x, data: %02x\n", offset, data)); |
| 3914 | 3986 | |
| 3987 | // similar to x1005_m_w but mirroring is handled differently |
| 3988 | if (offset == 0x1ef6 || offset == 0x1ef7) |
| 3989 | return; |
| 3990 | |
| 3915 | 3991 | switch (offset) |
| 3916 | 3992 | { |
| 3917 | 3993 | case 0x1ef0: |
| 3918 | 3994 | set_nt_page(space->machine, 0, CIRAM, (data & 0x80) ? 1 : 0, 1); |
| 3919 | 3995 | set_nt_page(space->machine, 1, CIRAM, (data & 0x80) ? 1 : 0, 1); |
| 3920 | | chr2_0(space->machine, (data & 0x7f) >> 1, CHRROM); |
| 3921 | 3996 | break; |
| 3922 | 3997 | case 0x1ef1: |
| 3923 | 3998 | set_nt_page(space->machine, 2, CIRAM, (data & 0x80) ? 1 : 0, 1); |
| 3924 | 3999 | set_nt_page(space->machine, 3, CIRAM, (data & 0x80) ? 1 : 0, 1); |
| 3925 | | chr2_2(space->machine, (data & 0x7f) >> 1, CHRROM); |
| 3926 | 4000 | break; |
| 3927 | | case 0x1ef2: |
| 3928 | | chr1_4(space->machine, data, CHRROM); |
| 3929 | | break; |
| 3930 | | case 0x1ef3: |
| 3931 | | chr1_5(space->machine, data, CHRROM); |
| 3932 | | break; |
| 3933 | | case 0x1ef4: |
| 3934 | | chr1_6(space->machine, data, CHRROM); |
| 3935 | | break; |
| 3936 | | case 0x1ef5: |
| 3937 | | chr1_7(space->machine, data, CHRROM); |
| 3938 | | break; |
| 3939 | | case 0x1efa: |
| 3940 | | case 0x1efb: |
| 3941 | | prg8_89(space->machine, data); |
| 3942 | | break; |
| 3943 | | case 0x1efc: |
| 3944 | | case 0x1efd: |
| 3945 | | prg8_ab(space->machine, data); |
| 3946 | | break; |
| 3947 | | case 0x1efe: |
| 3948 | | case 0x1eff: |
| 3949 | | prg8_cd(space->machine, data); |
| 3950 | | break; |
| 3951 | | default: |
| 3952 | | logerror("x1005a_m_w uncaught write, addr: %04x, value: %02x\n", offset + 0x6000, data); |
| 3953 | | break; |
| 3954 | 4001 | } |
| 4002 | |
| 4003 | x1005_m_w(space, offset, data); |
| 3955 | 4004 | } |
| 3956 | 4005 | |
| 3957 | 4006 | /************************************************************* |
| r8305 | r8306 | |
| 4015 | 4064 | state->mmc_latch1 = ((data & 0x02) << 1); |
| 4016 | 4065 | x1017_set_chr(space->machine); |
| 4017 | 4066 | break; |
| 4067 | case 0x1ef7: |
| 4068 | case 0x1ef8: |
| 4069 | case 0x1ef9: |
| 4070 | state->mmc_reg[(offset & 0x0f) - 7] = data; |
| 4071 | break; |
| 4018 | 4072 | case 0x1efa: |
| 4019 | 4073 | prg8_89(space->machine, data >> 2); |
| 4020 | 4074 | break; |
| r8305 | r8306 | |
| 4030 | 4084 | } |
| 4031 | 4085 | } |
| 4032 | 4086 | |
| 4087 | static READ8_HANDLER( x1017_m_r ) |
| 4088 | { |
| 4089 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 4090 | LOG_MMC(("x1017_m_r, offset: %04x\n", offset)); |
| 4091 | |
| 4092 | // 2+2+1 KB of Internal RAM can be independently enabled/disabled! |
| 4093 | if (offset < 0x0800 && state->mapper_ram != NULL && state->mmc_reg[0] == 0xca) |
| 4094 | return state->mapper_ram[offset & (state->mapper_ram_size - 1)]; |
| 4095 | if (offset < 0x1000 && state->mapper_ram != NULL && state->mmc_reg[1] == 0x69) |
| 4096 | return state->mapper_ram[offset & (state->mapper_ram_size - 1)]; |
| 4097 | if (offset < 0x1800 && state->mapper_ram != NULL && state->mmc_reg[2] == 0x84) |
| 4098 | return state->mapper_ram[offset & (state->mapper_ram_size - 1)]; |
| 4099 | |
| 4100 | return 0xff; |
| 4101 | } |
| 4102 | |
| 4033 | 4103 | /************************************************************* |
| 4034 | 4104 | |
| 4035 | 4105 | MISC UNLICENSED BOARDS |
| r8305 | r8306 | |
| 4048 | 4118 | { |
| 4049 | 4119 | LOG_MMC(("agci_50282_w, offset: %04x, data: %02x\n", offset, data)); |
| 4050 | 4120 | |
| 4121 | offset += 0x8000; |
| 4051 | 4122 | data |= (memory_read_byte(space, offset) & 1); |
| 4052 | 4123 | |
| 4053 | 4124 | chr8(space->machine, data >> 4, CHRROM); |
| r8305 | r8306 | |
| 4109 | 4180 | |
| 4110 | 4181 | static WRITE8_HANDLER( ae_act52_w ) |
| 4111 | 4182 | { |
| 4112 | | nes_state *state = (nes_state *)space->machine->driver_data; |
| 4113 | | int pbank, pchip, cbank; |
| 4183 | int pbank, cbank; |
| 4114 | 4184 | UINT8 pmode; |
| 4115 | | LOG_MMC(("mapper228_w, offset: %04x, data: %02x\n", offset, data)); |
| 4185 | LOG_MMC(("ae_act52_w, offset: %04x, data: %02x\n", offset, data)); |
| 4116 | 4186 | |
| 4117 | | set_nt_mirroring(space->machine, (offset & 0x2000) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT); |
| 4187 | set_nt_mirroring(space->machine, BIT(offset, 13) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT); |
| 4118 | 4188 | |
| 4119 | 4189 | cbank = (data & 0x03) | ((offset & 0x0f) << 2); |
| 4120 | 4190 | chr8(space->machine, cbank, CHRROM); |
| 4121 | 4191 | |
| 4122 | | pbank = (offset & 0x7c0) >> 6; |
| 4123 | | pchip = (offset & 0x1800) >> 11; |
| 4124 | 4192 | pmode = offset & 0x20; |
| 4125 | | |
| 4126 | | if (!state->crc_hack) |
| 4127 | | pbank += (0x10 * pchip); |
| 4128 | | else // FIXME: iNES loading for this mapper should be fixed as well to have the last bank at the correct offset) |
| 4129 | | { |
| 4130 | | switch (pchip) |
| 4131 | | { |
| 4132 | | case 0: break; // we are already at the correct bank |
| 4133 | | case 1: pbank += 0x10; break; // chip 1 starts at block 16 |
| 4134 | | case 2: break; // chip 2 was an empty socket |
| 4135 | | case 3: pbank += 0x20; break; // chip 3 starts at block 32 |
| 4136 | | } |
| 4137 | | } |
| 4138 | | |
| 4193 | pbank = (offset & 0x1fc0) >> 6; |
| 4139 | 4194 | if (pmode) |
| 4140 | 4195 | { |
| 4141 | 4196 | prg16_89ab(space->machine, pbank); |
| r8305 | r8306 | |
| 4231 | 4286 | } |
| 4232 | 4287 | } |
| 4233 | 4288 | else |
| 4234 | | state->wram[offset] = data; |
| 4289 | state->battery_ram[offset] = data; |
| 4235 | 4290 | } |
| 4236 | 4291 | |
| 4237 | 4292 | /************************************************************* |
| r8305 | r8306 | |
| 4309 | 4364 | |
| 4310 | 4365 | static WRITE8_HANDLER( bf9093_w ) |
| 4311 | 4366 | { |
| 4367 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 4312 | 4368 | LOG_MMC(("bf9093_w, offset: %04x, data: %02x\n", offset, data)); |
| 4313 | 4369 | |
| 4314 | 4370 | switch (offset & 0x7000) |
| 4315 | 4371 | { |
| 4316 | 4372 | case 0x0000: |
| 4317 | 4373 | case 0x1000: |
| 4374 | if (!state->hard_mirroring) |
| 4375 | set_nt_mirroring(space->machine, BIT(data, 4) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW); |
| 4318 | 4376 | break; |
| 4319 | 4377 | case 0x4000: |
| 4320 | 4378 | case 0x5000: |
| r8305 | r8306 | |
| 4325 | 4383 | } |
| 4326 | 4384 | } |
| 4327 | 4385 | |
| 4328 | | static WRITE8_HANDLER( bf9097_w ) |
| 4329 | | { |
| 4330 | | LOG_MMC(("bf9097_w, offset: %04x, data: %02x\n", offset, data)); |
| 4331 | | |
| 4332 | | switch (offset & 0x7000) |
| 4333 | | { |
| 4334 | | case 0x0000: |
| 4335 | | case 0x1000: |
| 4336 | | set_nt_mirroring(space->machine, BIT(data, 4) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW); |
| 4337 | | break; |
| 4338 | | case 0x4000: |
| 4339 | | case 0x5000: |
| 4340 | | case 0x6000: |
| 4341 | | case 0x7000: |
| 4342 | | prg16_89ab(space->machine, data); |
| 4343 | | break; |
| 4344 | | } |
| 4345 | | } |
| 4346 | | |
| 4347 | 4386 | /************************************************************* |
| 4348 | 4387 | |
| 4349 | 4388 | Camerica BF9096 & ALGQV11 Boards |
| r8305 | r8306 | |
| 4434 | 4473 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 4435 | 4474 | LOG_MMC(("cony_l_w, offset: %04x, data: %02x\n", offset, data)); |
| 4436 | 4475 | |
| 4437 | | state->mapper83_low_reg[offset & 0x03] = data; |
| 4476 | if (offset >= 0x1000 && offset < 0x1103) // from 0x5100-0x51ff |
| 4477 | state->mapper83_low_reg[offset & 0x03] = data; |
| 4438 | 4478 | } |
| 4439 | 4479 | |
| 4440 | 4480 | static READ8_HANDLER( cony_l_r ) |
| 4441 | 4481 | { |
| 4442 | 4482 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 4443 | 4483 | LOG_MMC(("cony_l_r, offset: %04x\n", offset)); |
| 4444 | | return state->mapper83_low_reg[offset & 0x03]; |
| 4484 | |
| 4485 | if (offset == 0x0f00) // 0x5000 |
| 4486 | { |
| 4487 | // read dipswitch bit! - currently unimplemented |
| 4488 | } |
| 4489 | if (offset >= 0x1000 && offset < 0x1103) // from 0x5100-0x51ff |
| 4490 | return state->mapper83_low_reg[offset & 0x03]; |
| 4491 | else |
| 4492 | return 0x00; |
| 4445 | 4493 | } |
| 4446 | 4494 | |
| 4447 | 4495 | static void cony_set_prg( running_machine *machine ) |
| r8305 | r8306 | |
| 4454 | 4502 | static void cony_set_chr( running_machine *machine ) |
| 4455 | 4503 | { |
| 4456 | 4504 | nes_state *state = (nes_state *)machine->driver_data; |
| 4457 | | chr1_0(machine, state->mapper83_reg[0] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4458 | | chr1_1(machine, state->mapper83_reg[1] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4459 | | chr1_2(machine, state->mapper83_reg[2] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4460 | | chr1_3(machine, state->mapper83_reg[3] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4461 | | chr1_4(machine, state->mapper83_reg[4] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4462 | | chr1_5(machine, state->mapper83_reg[5] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4463 | | chr1_6(machine, state->mapper83_reg[6] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4464 | | chr1_7(machine, state->mapper83_reg[7] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4505 | // FIXME: here we emulate at least 3 different boards!!! |
| 4506 | // one board switches 1k VROM banks only |
| 4507 | // one writes to 0x8000 and then switches 2k VROM banks only |
| 4508 | // one writes to 0x831n (n=2,3,4,5) and then switches 2k VROM banks only |
| 4509 | // we should split them and possibly document the proper behavior of each variant |
| 4510 | if (state->mmc_latch1 && !state->mmc_latch2) |
| 4511 | { |
| 4512 | chr2_0(machine, state->mapper83_reg[0], CHRROM); |
| 4513 | chr2_2(machine, state->mapper83_reg[1], CHRROM); |
| 4514 | chr2_4(machine, state->mapper83_reg[6], CHRROM); |
| 4515 | chr2_6(machine, state->mapper83_reg[7], CHRROM); |
| 4516 | } |
| 4517 | else |
| 4518 | { |
| 4519 | chr1_0(machine, state->mapper83_reg[0] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4520 | chr1_1(machine, state->mapper83_reg[1] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4521 | chr1_2(machine, state->mapper83_reg[2] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4522 | chr1_3(machine, state->mapper83_reg[3] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4523 | chr1_4(machine, state->mapper83_reg[4] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4524 | chr1_5(machine, state->mapper83_reg[5] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4525 | chr1_6(machine, state->mapper83_reg[6] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4526 | chr1_7(machine, state->mapper83_reg[7] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM); |
| 4527 | } |
| 4465 | 4528 | } |
| 4466 | 4529 | |
| 4467 | 4530 | static WRITE8_HANDLER( cony_w ) |
| r8305 | r8306 | |
| 4472 | 4535 | switch (offset) |
| 4473 | 4536 | { |
| 4474 | 4537 | case 0x0000: |
| 4538 | state->mmc_latch1 = 1; |
| 4475 | 4539 | case 0x3000: |
| 4476 | 4540 | case 0x30ff: |
| 4477 | 4541 | case 0x31ff: |
| r8305 | r8306 | |
| 4480 | 4544 | cony_set_chr(space->machine); |
| 4481 | 4545 | break; |
| 4482 | 4546 | case 0x0100: |
| 4547 | state->mmc_reg[0] = data & 0x80; |
| 4483 | 4548 | switch (data & 0x03) |
| 4484 | 4549 | { |
| 4485 | 4550 | case 0: |
| r8305 | r8306 | |
| 4500 | 4565 | state->IRQ_count = (state->IRQ_count & 0xff00) | data; |
| 4501 | 4566 | break; |
| 4502 | 4567 | case 0x0201: |
| 4503 | | state->IRQ_enable = 1; |
| 4568 | state->IRQ_enable = state->mmc_reg[0]; |
| 4504 | 4569 | state->IRQ_count = (data << 8) | (state->IRQ_count & 0xff); |
| 4505 | 4570 | break; |
| 4506 | 4571 | case 0x0300: |
| r8305 | r8306 | |
| 4512 | 4577 | case 0x0302: |
| 4513 | 4578 | prg8_cd(space->machine, data); |
| 4514 | 4579 | break; |
| 4515 | | case 0x0310: |
| 4516 | | case 0x0311: |
| 4517 | 4580 | case 0x0312: |
| 4518 | 4581 | case 0x0313: |
| 4519 | 4582 | case 0x0314: |
| 4520 | 4583 | case 0x0315: |
| 4584 | state->mmc_latch2 = 1; |
| 4585 | case 0x0310: |
| 4586 | case 0x0311: |
| 4521 | 4587 | case 0x0316: |
| 4522 | 4588 | case 0x0317: |
| 4523 | 4589 | state->mapper83_reg[offset - 0x0310] = data; |
| r8305 | r8306 | |
| 4920 | 4986 | |
| 4921 | 4987 | iNES: mapper 121 |
| 4922 | 4988 | |
| 4923 | | In MESS: Supported. |
| 4924 | | |
| 4989 | In MESS: Only preliminarly supported (Panda Prince works, |
| 4990 | other games require handling properly the protection). |
| 4991 | |
| 4925 | 4992 | *************************************************************/ |
| 4926 | 4993 | |
| 4927 | 4994 | static WRITE8_HANDLER( kay_pp_l_w ) |
| r8305 | r8306 | |
| 4934 | 5001 | { |
| 4935 | 5002 | switch (data & 0x03) |
| 4936 | 5003 | { |
| 4937 | | case 0x00: |
| 4938 | 5004 | case 0x03: |
| 4939 | 5005 | state->mapper121_reg[2] = 0x00; |
| 4940 | 5006 | break; |
| 5007 | case 0x00: |
| 4941 | 5008 | case 0x01: |
| 4942 | 5009 | state->mapper121_reg[2] = 0x83; |
| 4943 | 5010 | break; |
| r8305 | r8306 | |
| 4960 | 5027 | return 0; |
| 4961 | 5028 | } |
| 4962 | 5029 | |
| 5030 | static void kay_pp_update_regs( running_machine *machine, UINT8 data ) |
| 5031 | { |
| 5032 | nes_state *state = (nes_state *)machine->driver_data; |
| 5033 | |
| 5034 | switch (data & 0x3f) |
| 5035 | { |
| 5036 | case 0x20: |
| 5037 | case 0x29: |
| 5038 | case 0x2b: |
| 5039 | case 0x3f: |
| 5040 | // printf("reg (%x) %x \n", data, state->mapper121_reg[3]); |
| 5041 | state->mapper121_reg[1] = state->mapper121_reg[3]; |
| 5042 | break; |
| 5043 | case 0x2c: |
| 5044 | // printf("reg (%x) %x \n", data, state->mapper121_reg[3]); |
| 5045 | state->mapper121_reg[1] = state->mapper121_reg[3]; |
| 5046 | break; |
| 5047 | |
| 5048 | case 0x28: |
| 5049 | // printf("reg (%x) %x \n", data, state->mapper121_reg[3]); |
| 5050 | state->mapper121_reg[0] = state->mapper121_reg[3]; |
| 5051 | break; |
| 5052 | |
| 5053 | case 0x2a: |
| 5054 | // printf("reg (%x) %x \n", data, state->mapper121_reg[3]); |
| 5055 | state->mapper121_reg[4] = state->mapper121_reg[3]; |
| 5056 | break; |
| 5057 | |
| 5058 | case 0x2f: |
| 5059 | break; |
| 5060 | |
| 5061 | default: |
| 5062 | state->mapper121_reg[0] = 0x0; |
| 5063 | state->mapper121_reg[1] = 0x0; |
| 5064 | state->mapper121_reg[4] = 0x0; |
| 5065 | break; |
| 5066 | } |
| 5067 | } |
| 5068 | |
| 4963 | 5069 | static void kay_pp_set_prg( running_machine *machine, int prg_base, int prg_mask ) |
| 4964 | 5070 | { |
| 4965 | 5071 | nes_state *state = (nes_state *)machine->driver_data; |
| 4966 | 5072 | UINT8 prg_flip = (state->mmc_latch1 & 0x40) ? 2 : 0; |
| 4967 | | UINT8 new_bank2, new_bank3; |
| 5073 | UINT8 new_bank1, new_bank2, new_bank3; |
| 4968 | 5074 | |
| 4969 | 5075 | new_bank2 = state->mapper121_reg[0] ? state->mapper121_reg[0] : state->mmc_prg_bank[2 ^ prg_flip]; |
| 4970 | 5076 | new_bank3 = state->mapper121_reg[1] ? state->mapper121_reg[1] : state->mmc_prg_bank[3]; |
| 5077 | new_bank1 = state->mapper121_reg[4] ? state->mapper121_reg[4] : state->mmc_prg_bank[1]; |
| 4971 | 5078 | |
| 4972 | 5079 | prg8_89(machine, prg_base | (state->mmc_prg_bank[0 ^ prg_flip] & prg_mask)); |
| 4973 | | prg8_ab(machine, prg_base | (state->mmc_prg_bank[1] & prg_mask)); |
| 5080 | prg8_ab(machine, prg_base | (new_bank1 & prg_mask)); |
| 4974 | 5081 | prg8_cd(machine, prg_base | (new_bank2 & prg_mask)); |
| 4975 | 5082 | prg8_ef(machine, prg_base | (new_bank3 & prg_mask)); |
| 4976 | 5083 | } |
| r8305 | r8306 | |
| 4983 | 5090 | |
| 4984 | 5091 | if ((offset < 0x2000) && (offset & 0x03) == 0x03) |
| 4985 | 5092 | { |
| 4986 | | switch (data) |
| 4987 | | { |
| 4988 | | case 0x20: |
| 4989 | | state->mapper121_reg[1] = 0x13; |
| 4990 | | break; |
| 4991 | | case 0x26: |
| 4992 | | state->mapper121_reg[1] = 0x08; |
| 4993 | | break; |
| 4994 | | case 0x28: |
| 4995 | | state->mapper121_reg[0] = 0x0c; |
| 4996 | | break; |
| 4997 | | case 0x29: |
| 4998 | | state->mapper121_reg[1] = 0x1b; |
| 4999 | | break; |
| 5000 | | case 0xab: |
| 5001 | | state->mapper121_reg[1] = 0x07; |
| 5002 | | break; |
| 5003 | | case 0xec: |
| 5004 | | case 0xef: |
| 5005 | | state->mapper121_reg[1] = 0x0d; |
| 5006 | | break; |
| 5007 | | case 0xff: |
| 5008 | | state->mapper121_reg[1] = 0x09; |
| 5009 | | break; |
| 5010 | | default: |
| 5011 | | state->mapper121_reg[0] = 0x0; |
| 5012 | | state->mapper121_reg[1] = 0x0; |
| 5013 | | break; |
| 5014 | | } |
| 5093 | kay_pp_update_regs(space->machine, data); |
| 5094 | kay_pp_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask); |
| 5015 | 5095 | } |
| 5016 | 5096 | else |
| 5017 | 5097 | { |
| r8305 | r8306 | |
| 5031 | 5111 | break; |
| 5032 | 5112 | |
| 5033 | 5113 | case 0x0001: |
| 5114 | state->mapper121_reg[3] = (BIT(data, 0) << 5) | (BIT(data, 1) << 4) | (BIT(data, 2) << 3) |
| 5115 | | (BIT(data, 3) << 2) | (BIT(data, 4) << 1) | BIT(data, 5); |
| 5034 | 5116 | cmd = state->mmc_latch1 & 0x07; |
| 5035 | 5117 | switch (cmd) |
| 5036 | | { |
| 5118 | { |
| 5037 | 5119 | case 0: case 1: |
| 5038 | 5120 | case 2: case 3: case 4: case 5: |
| 5039 | 5121 | state->mmc_vrom_bank[cmd] = data; |
| r8305 | r8306 | |
| 5044 | 5126 | state->mmc_prg_bank[cmd - 6] = data; |
| 5045 | 5127 | kay_pp_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask); |
| 5046 | 5128 | break; |
| 5047 | | } |
| 5129 | } |
| 5048 | 5130 | break; |
| 5049 | 5131 | |
| 5050 | 5132 | default: |
| r8305 | r8306 | |
| 5052 | 5134 | break; |
| 5053 | 5135 | } |
| 5054 | 5136 | } |
| 5055 | | kay_pp_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask); |
| 5056 | 5137 | } |
| 5057 | 5138 | |
| 5139 | |
| 5058 | 5140 | /************************************************************* |
| 5059 | 5141 | |
| 5060 | 5142 | Bootleg Board by Kasing |
| r8305 | r8306 | |
| 6816 | 6898 | |
| 6817 | 6899 | /************************************************************* |
| 6818 | 6900 | |
| 6901 | Bootleg Board 'Strike Wolf' by TXC |
| 6902 | |
| 6903 | Games: Strike Wolf (also Policeman?? according to Nestopia) |
| 6904 | |
| 6905 | iNES: mapper 36 |
| 6906 | |
| 6907 | Known Boards: Bootleg Board by TXC |
| 6908 | |
| 6909 | In MESS: Supported. |
| 6910 | |
| 6911 | *************************************************************/ |
| 6912 | |
| 6913 | static WRITE8_HANDLER( txc_strikewolf_w ) |
| 6914 | { |
| 6915 | LOG_MMC(("txc_strikewolf_w, offset: %04x, data: %02x\n", offset, data)); |
| 6916 | |
| 6917 | if ((offset >= 0x400) && (offset < 0x7fff)) |
| 6918 | { |
| 6919 | prg32(space->machine, data >> 4); |
| 6920 | chr8(space->machine, data & 0x0f, CHRROM); |
| 6921 | } |
| 6922 | } |
| 6923 | |
| 6924 | /************************************************************* |
| 6925 | |
| 6819 | 6926 | Bootleg Board MXMDHTWO by TXC |
| 6820 | 6927 | |
| 6821 | 6928 | Games: Commandos, Journey to the West, Ma Bu Mi Zhen & |
| r8305 | r8306 | |
| 8570 | 8677 | |
| 8571 | 8678 | /************************************************************* |
| 8572 | 8679 | |
| 8573 | | Bootleg Board |
| 8680 | BTL-SMB2B |
| 8681 | |
| 8682 | Games: Super Mario Bros. 2 Pirate (Jpn version of SMB2) |
| 8683 | |
| 8684 | This was marked as Alt. Levels. is it true? |
| 8685 | |
| 8686 | iNES: mapper 50 |
| 8574 | 8687 | |
| 8575 | | Games: Super Fighter III |
| 8688 | In MESS: Supported. |
| 8576 | 8689 | |
| 8690 | *************************************************************/ |
| 8691 | |
| 8692 | static void smb2jb_irq( running_device *device, int scanline, int vblank, int blanked ) |
| 8693 | { |
| 8694 | nes_state *state = (nes_state *)device->machine->driver_data; |
| 8695 | if (state->IRQ_enable) |
| 8696 | { |
| 8697 | if (state->IRQ_count < 0x1000) |
| 8698 | { |
| 8699 | if ((0x1000 - state->IRQ_count) <= 114) |
| 8700 | cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE); |
| 8701 | else |
| 8702 | state->IRQ_count += 114; |
| 8703 | } |
| 8704 | else |
| 8705 | state->IRQ_count += 114; |
| 8706 | |
| 8707 | state->IRQ_count &= 0xffff; // according to docs is 16bit counter -> it wraps only after 0xffff |
| 8708 | } |
| 8709 | } |
| 8710 | |
| 8711 | static WRITE8_HANDLER( smb2jb_l_w ) |
| 8712 | { |
| 8713 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 8714 | UINT8 prg; |
| 8715 | LOG_MMC(("smb2jb_l_w, offset: %04x, data: %02x\n", offset, data)); |
| 8716 | offset += 0x100; |
| 8717 | |
| 8718 | switch (offset & 0x160) |
| 8719 | { |
| 8720 | case 0x020: |
| 8721 | prg = (data & 0x08) | ((data & 0x06) >> 1) | ((data & 0x01) << 2); |
| 8722 | prg8_cd(space->machine, prg); |
| 8723 | break; |
| 8724 | case 0x120: |
| 8725 | state->IRQ_enable = data & 0x01; |
| 8726 | break; |
| 8727 | } |
| 8728 | } |
| 8729 | |
| 8730 | /* This goes to 0x4020-0x403f */ |
| 8731 | WRITE8_HANDLER( smb2jb_extra_w ) |
| 8732 | { |
| 8733 | UINT8 prg; |
| 8734 | LOG_MMC(("smb2jb_extra_w, offset: %04x, data: %02x\n", offset, data)); |
| 8735 | |
| 8736 | prg = (data & 0x08) | ((data & 0x06) >> 1) | ((data & 0x01) << 2); |
| 8737 | prg8_cd(space->machine, prg); |
| 8738 | } |
| 8739 | |
| 8740 | /************************************************************* |
| 8741 | |
| 8742 | Bootleg Board for Super Fighter III |
| 8743 | |
| 8577 | 8744 | MMC3 clone |
| 8578 | 8745 | |
| 8579 | 8746 | In MESS: Supported. |
| r8305 | r8306 | |
| 8663 | 8830 | |
| 8664 | 8831 | /************************************************************* |
| 8665 | 8832 | |
| 8833 | Board UNL-RACERMATE |
| 8834 | |
| 8835 | In MESS: *VERY* preliminary support. Also, it seems that this |
| 8836 | board saves to battery the CHRRAM!!! |
| 8837 | |
| 8838 | *************************************************************/ |
| 8839 | |
| 8840 | static void racmate_update_banks( running_machine *machine ) |
| 8841 | { |
| 8842 | nes_state *state = (nes_state *)machine->driver_data; |
| 8843 | chr4_4(machine, state->mmc_latch1 & 0x0f, state->mmc_chr_source); |
| 8844 | prg16_89ab(machine, state->mmc_latch1 >> 1); |
| 8845 | } |
| 8846 | |
| 8847 | static WRITE8_HANDLER( unl_racmate_w ) |
| 8848 | { |
| 8849 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 8850 | LOG_MMC(("unl_racmate_w offset: %04x, data: %02x\n", offset, data)); |
| 8851 | |
| 8852 | if (offset == 0x3000) |
| 8853 | { |
| 8854 | state->mmc_latch1 = data; |
| 8855 | racmate_update_banks(space->machine); |
| 8856 | } |
| 8857 | } |
| 8858 | |
| 8859 | /************************************************************* |
| 8860 | |
| 8666 | 8861 | BOOTLEG CART VERSIONS OF FDS GAMES |
| 8667 | 8862 | |
| 8668 | 8863 | *************************************************************/ |
| r8305 | r8306 | |
| 9347 | 9542 | |
| 9348 | 9543 | static WRITE8_HANDLER( bmc_gkb_w ) |
| 9349 | 9544 | { |
| 9545 | nes_state *state = (nes_state *)space->machine->driver_data; |
| 9350 | 9546 | UINT8 bank = (offset & 0x40) ? 0 : 1; |
| 9351 | 9547 | LOG_MMC(("bmc_gkb_w, offset: %04x, data: %02x\n", offset, data)); |
| 9352 | 9548 | |
| 9353 | 9549 | prg16_89ab(space->machine, offset & ~bank); |
| 9354 | 9550 | prg16_cdef(space->machine, offset | bank); |
| 9355 | | chr8(space->machine, offset >> 3, CHRROM); |
| 9551 | chr8(space->machine, offset >> 3, state->mmc_chr_source); |
| 9356 | 9552 | set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT); |
| 9357 | 9553 | } |
| 9358 | 9554 | |
| r8305 | r8306 | |
| 9900 | 10096 | |
| 9901 | 10097 | /* This bit is the "register lock". Once register are locked, writes go to WRAM |
| 9902 | 10098 | and there is no way to unlock them (except by resetting the machine) */ |
| 9903 | | if (state->mapper45_reg[3] & 0x40) |
| 10099 | if ((state->mapper45_reg[3] & 0x40) && state->wram != NULL) |
| 9904 | 10100 | state->wram[offset] = data; |
| 9905 | 10101 | else |
| 9906 | 10102 | { |
| r8305 | r8306 | |
| 9914 | 10110 | |
| 9915 | 10111 | state->mmc_prg_base = state->mapper45_reg[1]; |
| 9916 | 10112 | state->mmc_prg_mask = 0x3f ^ (state->mapper45_reg[3] & 0x3f); |
| 9917 | | state->mmc_chr_base = ((state->mapper45_reg[2] & 0xf0) << 4) + state->mapper45_reg[0]; |
| 9918 | | state->mmc_chr_mask = 0xff >> (~state->mapper45_reg[2] & 0x0f); |
| 10113 | state->mmc_chr_base = ((state->mapper45_reg[2] & 0xf0) << 4) | state->mapper45_reg[0]; |
| 10114 | if (BIT(state->mapper45_reg[2], 3)) |
| 10115 | state->mmc_chr_mask = (1 << ((state->mapper45_reg[2] & 7) + 1)) - 1; |
| 10116 | else if (state->mapper45_reg[2]) |
| 10117 | state->mmc_chr_mask = 0; |
| 10118 | else |
| 10119 | state->mmc_chr_mask = 0xff; // i.e. we use the vrom_bank with no masking |
| 10120 | |
| 9919 | 10121 | mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask); |
| 9920 | 10122 | mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask); |
| 9921 | 10123 | } |
| r8305 | r8306 | |
| 10300 | 10502 | #define NES_WRITEONLY(a) \ |
| 10301 | 10503 | {a, NULL} |
| 10302 | 10504 | |
| 10505 | #if 0 |
| 10506 | static WRITE8_HANDLER( dummy_w ) |
| 10507 | { |
| 10508 | } |
| 10509 | |
| 10510 | static READ8_HANDLER( dummy_r ) |
| 10511 | { |
| 10512 | return 0x00; |
| 10513 | } |
| 10514 | #endif |
| 10515 | |
| 10303 | 10516 | // further review needed for: TXROM, PXROM, FXROM, Bandai LZ93D50, Irem G-101, Konami VRC3 |
| 10304 | 10517 | // all multicart pcb, many unl/btl pcbs |
| 10305 | 10518 | static const nes_pcb_intf nes_intf_list[] = |
| r8305 | r8306 | |
| 10326 | 10539 | { STD_SXROM_A, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sxrom_w), NULL, NULL, NULL }, |
| 10327 | 10540 | { STD_SOROM_A, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sxrom_w), NULL, NULL, NULL }, |
| 10328 | 10541 | { STD_TXROM, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(txrom_w), NULL, NULL, mmc3_irq }, |
| 10329 | | { STD_HKROM, NES_NOACCESS, {hkrom_m_w, hkrom_m_r}, NES_WRITEONLY(hkrom_w), NULL, NULL, mmc3_irq }, |
| 10542 | { STD_TVROM, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(txrom_w), NULL, NULL, mmc3_irq }, |
| 10543 | { STD_TKROM, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(txrom_w), NULL, NULL, mmc3_irq }, |
| 10544 | { STD_HKROM, NES_NOACCESS, {hkrom_m_w, hkrom_m_r}, NES_WRITEONLY(hkrom_w), NULL, NULL, mmc3_irq }, |
| 10330 | 10545 | { STD_TQROM, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tqrom_w), NULL, NULL, mmc3_irq }, |
| 10331 | 10546 | { STD_TXSROM, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(txsrom_w), NULL, NULL, mmc3_irq }, |
| 10332 | 10547 | { STD_DXROM, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dxrom_w), NULL, NULL, NULL }, |
| r8305 | r8306 | |
| 10345 | 10560 | { DIS_74X161X161X32, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dis_74x161x161x32_w), NULL, NULL, NULL }, |
| 10346 | 10561 | { DIS_74X161X138, NES_NOACCESS, NES_WRITEONLY(dis_74x161x138_m_w), NES_NOACCESS, NULL, NULL, NULL }, |
| 10347 | 10562 | { BANDAI_LZ93, NES_NOACCESS, NES_WRITEONLY(lz93d50_m_w), NES_WRITEONLY(lz93d50_w), NULL, NULL, bandai_lz_irq }, |
| 10563 | { BANDAI_LZ93EX, NES_NOACCESS, NES_WRITEONLY(lz93d50_m_w), NES_WRITEONLY(lz93d50_w), NULL, NULL, bandai_lz_irq }, |
| 10348 | 10564 | { BANDAI_FCG, NES_NOACCESS, NES_WRITEONLY(lz93d50_m_w), NES_WRITEONLY(lz93d50_w), NULL, NULL, bandai_lz_irq }, |
| 10349 | 10565 | { BANDAI_DATACH, NES_NOACCESS, NES_WRITEONLY(lz93d50_m_w), NES_WRITEONLY(lz93d50_w), NULL, NULL, bandai_lz_irq }, |
| 10350 | 10566 | { BANDAI_JUMP2, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(fjump2_w), NULL, NULL, bandai_lz_irq }, |
| 10351 | 10567 | { BANDAI_KARAOKE, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bandai_ks_w), NULL, NULL, NULL }, |
| 10352 | | { BANDAI_OEKAKIDS, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bandai_ok_w), NULL, NULL, NULL }, |
| 10568 | { BANDAI_OEKAKIDS, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bandai_ok_w), NULL, NULL, NULL }, |
| 10353 | 10569 | { IREM_G101, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(g101_w), NULL, NULL, NULL }, |
| 10354 | 10570 | { IREM_LROG017, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(lrog017_w), NULL, NULL, NULL }, |
| 10355 | 10571 | { IREM_H3001, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(h3001_w), NULL, NULL, h3001_irq }, |
| r8305 | r8306 | |
| 10373 | 10589 | { SUNSOFT_3, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sunsoft3_w), NULL, NULL, sunsoft3_irq }, |
| 10374 | 10590 | { TAITO_TC0190FMC, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tc0190fmc_w), NULL, NULL, NULL }, |
| 10375 | 10591 | { TAITO_TC0190FMCP, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tc0190fmc_p16_w), NULL, NULL, mmc3_irq }, |
| 10376 | | { TAITO_X1_005, NES_NOACCESS, NES_WRITEONLY(x1005_m_w), NES_NOACCESS, NULL, NULL, NULL }, |
| 10377 | | { TAITO_X1_005_A, NES_NOACCESS, NES_WRITEONLY(x1005a_m_w), NES_NOACCESS, NULL, NULL, NULL }, |
| 10378 | | { TAITO_X1_017, NES_NOACCESS, NES_WRITEONLY(x1017_m_w), NES_NOACCESS, NULL, NULL, NULL }, |
| 10592 | { TAITO_X1_005, NES_NOACCESS, {x1005_m_w, x1005_m_r}, NES_NOACCESS, NULL, NULL, NULL }, |
| 10593 | { TAITO_X1_005_A, NES_NOACCESS, {x1005a_m_w, x1005_m_r}, NES_NOACCESS, NULL, NULL, NULL }, |
| 10594 | { TAITO_X1_017, NES_NOACCESS, {x1017_m_w, x1017_m_r}, NES_NOACCESS, NULL, NULL, NULL }, |
| 10379 | 10595 | // |
| 10380 | 10596 | { AGCI_50282, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(agci_50282_w), NULL, NULL, NULL }, |
| 10381 | 10597 | { ACTENT_ACT52, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(ae_act52_w), NULL, NULL, NULL }, |
| r8305 | r8306 | |
| 10386 | 10602 | { CNE_SHLZ, NES_WRITEONLY(cne_shlz_l_w), NES_NOACCESS, NES_NOACCESS, NULL, NULL, NULL }, |
| 10387 | 10603 | { CALTRON_6IN1, NES_NOACCESS, NES_WRITEONLY(caltron6in1_m_w), NES_WRITEONLY(caltron6in1_w), NULL, NULL, NULL }, |
| 10388 | 10604 | { CAMERICA_BF9093, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bf9093_w), NULL, NULL, NULL }, |
| 10389 | | { CAMERICA_BF9097, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bf9097_w), NULL, NULL, NULL }, |
| 10605 | { CAMERICA_BF9097, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bf9093_w), NULL, NULL, NULL }, |
| 10390 | 10606 | { CAMERICA_BF9096, NES_NOACCESS, NES_WRITEONLY(bf9096_w), NES_WRITEONLY(bf9096_w), NULL, NULL, NULL }, |
| 10391 | 10607 | { CAMERICA_GOLDENFIVE, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(golden5_w), NULL, NULL, NULL }, |
| 10392 | | { CONY_BOARD, {cony_l_w, cony_l_r}, NES_NOACCESS, NES_WRITEONLY(cony_w), NULL, NULL, NULL }, |
| 10608 | { CONY_BOARD, {cony_l_w, cony_l_r}, NES_NOACCESS, NES_WRITEONLY(cony_w), NULL, NULL, sunsoft3_irq }, |
| 10393 | 10609 | { DREAMTECH_BOARD, NES_WRITEONLY(dreamtech_l_w), NES_NOACCESS, NES_NOACCESS, NULL, NULL, NULL }, |
| 10394 | 10610 | { FUTUREMEDIA_BOARD, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(futuremedia_w), NULL, NULL, futuremedia_irq }, |
| 10395 | 10611 | { GOUDER_37017, {gouder_sf4_l_w, gouder_sf4_l_r}, NES_NOACCESS, NES_WRITEONLY(gouder_sf4_w), NULL, NULL, mmc3_irq }, |
| r8305 | r8306 | |
| 10435 | 10651 | { TXC_22211B, {txc_22211_l_w, txc_22211_l_r}, NES_NOACCESS, NES_WRITEONLY(txc_22211b_w), NULL, NULL, NULL }, |
| 10436 | 10652 | { TXC_22211C, {txc_22211_l_w, txc_22211c_l_r}, NES_NOACCESS, NES_WRITEONLY(txc_22211_w), NULL, NULL, NULL }, |
| 10437 | 10653 | { TXC_TW, NES_WRITEONLY(txc_tw_l_w), NES_WRITEONLY(txc_tw_m_w), NES_WRITEONLY(txc_tw_w), NULL, NULL, mmc3_irq }, |
| 10654 | { TXC_STRIKEWOLF, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(txc_strikewolf_w), NULL, NULL, NULL }, |
| 10438 | 10655 | { TXC_MXMDHTWO, NES_READONLY(txc_mxmdhtwo_l_r), NES_NOACCESS, NES_WRITEONLY(txc_mxmdhtwo_w), NULL, NULL, NULL }, |
| 10439 | 10656 | { WAIXING_TYPE_A, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_a_w), NULL, NULL, mmc3_irq }, |
| 10440 | 10657 | { WAIXING_TYPE_B, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_b_w), NULL, NULL, mmc3_irq }, |
| r8305 | r8306 | |
| 10463 | 10680 | { UNL_SMB2J, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(smb2j_w), NULL, NULL, NULL }, |
| 10464 | 10681 | { UNL_SUPERFIGHTER3, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(unl_sf3_w), NULL, NULL, mmc3_irq }, |
| 10465 | 10682 | { UNL_XZY, NES_WRITEONLY(unl_xzy_l_w), NES_NOACCESS, NES_NOACCESS, NULL, NULL, NULL }, |
| 10683 | { UNL_RACERMATE, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(unl_racmate_w), NULL, NULL, NULL }, |
| 10466 | 10684 | // |
| 10467 | 10685 | { BTL_AISENSHINICOL, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_mariobaby_w), NULL, NULL, NULL }, |
| 10468 | 10686 | { BTL_DRAGONNINJA, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_dn_w), NULL, NULL, btl_dn_irq }, |
| 10469 | 10687 | { BTL_MARIOBABY, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_mariobaby_w), NULL, NULL, NULL }, |
| 10470 | 10688 | { BTL_SMB2A, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_smb2a_w), NULL, NULL, btl_smb2a_irq }, |
| 10689 | { BTL_SMB2B, NES_WRITEONLY(smb2jb_l_w), NES_NOACCESS, NES_NOACCESS, NULL, NULL, smb2jb_irq }, |
| 10471 | 10690 | { BTL_SMB3, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_smb3_w), NULL, NULL, btl_smb3_irq }, |
| 10472 | 10691 | { BTL_SUPERBROS11, NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_smb11_w), NULL, NULL, mmc3_irq }, |
| 10473 | 10692 | // |
| r8305 | r8306 | |
| 10509 | 10728 | { BMC_GOLDENCARD_6IN1, NES_WRITEONLY(bmc_gc6in1_l_w), NES_NOACCESS, NES_WRITEONLY(bmc_gc6in1_w), NULL, NULL, mmc3_irq }, |
| 10510 | 10729 | { UNSUPPORTED_BOARD, NES_NOACCESS, NES_NOACCESS, NES_NOACCESS, NULL, NULL, NULL }, |
| 10511 | 10730 | // |
| 10512 | | // { BTL_SMB2B, NES_WRITEONLY(mapper50_l_w), NES_NOACCESS, NES_NOACCESS, NULL, NULL, mapper50_irq }, |
| 10513 | 10731 | }; |
| 10514 | 10732 | |
| 10515 | 10733 | |
| r8305 | r8306 | |
| 10571 | 10789 | state->mmc_write_mid = intf->mmc_m.write; |
| 10572 | 10790 | state->mmc_write = intf->mmc_h.write; |
| 10573 | 10791 | state->mmc_read_low = intf->mmc_l.read; |
| 10574 | | state->mmc_read_mid = NULL; // in progress |
| 10575 | | state->mmc_read = NULL; // in progress |
| 10792 | state->mmc_read_mid = intf->mmc_m.read; // in progress |
| 10793 | state->mmc_read = intf->mmc_h.read; // in progress |
| 10576 | 10794 | ppu_latch = intf->mmc_ppu_latch; |
| 10577 | 10795 | } |
| 10578 | 10796 | else |