Previous 15994 Revisions Next

r8271 Monday 14th June, 2010 at 14:34:55 UTC by Fabio Priuli
[NES] WIP:
* merged most of the UNIF code with pcb code,
* made pcb initialization mostly independent from the mapper code,
* added most handlers for pcb emulation

(the latter changes result in a lot of duplicate code, but I will start soon to replace the mapper-based code with the new version and dupe functions will be removed)
[src/mess/includes]nes.h
[src/mess/machine]nes.c nes_ines.c nes_mmc.c nes_mmc.h nes_pcb.c nes_unif.c

src/mess/includes/nes.h
r8270r8271
7777   name_table    nt_page[4];  //quick banking structure for a maximum of 4K of RAM/ROM/ExRAM
7878
7979   int chr_open_bus;
80   int prgram_bank5_start, battery_bank5_start;
80   int prgram_bank5_start, battery_bank5_start, empty_bank5_start;
8181
8282   UINT8 ce_mask, ce_state;
8383
src/mess/machine/nes_pcb.c
r8270r8271
6363   { "HVC-UOROM",        STD_UXROM },
6464   { "NES-UNROM",        STD_UXROM },
6565   { "NES-UOROM",        STD_UXROM },
66   { "HVC-UNROM+74HC08", UXROM_CC },
6667   /* UxROM boards by other manufacturer */
6768   { "IREM-UNROM",       STD_UXROM },
6869   { "KONAMI-UNROM",     STD_UXROM },
r8270r8271
144145   { "NES-JSROM",        STD_JXROM },
145146   { "NES-BTR",          STD_JXROM },
146147   /* JxROM boards by other manufacturer (this board was mainly used by Sunsoft?) */
148   { "SUNSOFT-5A",       STD_JXROM },
147149   { "SUNSOFT-5B",       STD_JXROM },
148150   { "SUNSOFT-FME-7",    STD_JXROM },
149151//
150   /* Nintendo UN1sROM */
152   /* Nintendo UN1ROM */
151153   { "HVC-UN1ROM",       STD_UN1ROM },
152154   { "NES-UN1ROM",       STD_UN1ROM },
153155//
r8270r8271
212214   { "HVC-TL2ROM",       STD_TXROM },
213215   { "HVC-TLROM",        STD_TXROM },
214216   { "HVC-TNROM",        STD_TXROM },
215   { "HVC-TR1ROM",       STD_TXROM },
217   { "HVC-TR1ROM",       STD_TVROM },
216218   { "HVC-TSROM",        STD_TXROM },
217   { "HVC-TVROM",        STD_TXROM },
219   { "HVC-TVROM",        STD_TVROM },
218220   { "NES-B4",           STD_TXROM },
219221   { "NES-TBROM",        STD_TXROM },
220222   { "NES-TEROM",        STD_TXROM },
r8270r8271
225227   { "NES-TL2ROM",       STD_TXROM },
226228   { "NES-TLROM",        STD_TXROM },
227229   { "NES-TNROM",        STD_TXROM },
228   { "NES-TR1ROM",       STD_TXROM },
230   { "NES-TR1ROM",       STD_TVROM },
229231   { "NES-TSROM",        STD_TXROM },
230   { "NES-TVROM",        STD_TXROM },
232   { "NES-TVROM",        STD_TVROM },
231233   /* TxROM boards by other manufacturer */
232234   { "ACCLAIM-MC-ACC",   STD_TXROM },
233235   { "ACCLAIM-TLROM",    STD_TXROM },
r8270r8271
236238   /* Nintendo DxROM */
237239   { "HVC-DE1ROM",       STD_DXROM },
238240   { "HVC-DEROM",        STD_DXROM },
239   { "HVC-DRROM",        STD_DXROM },
241   { "HVC-DRROM",        STD_DRROM },
240242   { "NES-DE1ROM",       STD_DXROM },
241243   { "NES-DEROM",        STD_DXROM },
242   { "NES-DRROM",        STD_DXROM },
244   { "NES-DRROM",        STD_DRROM },
243245   /* DxROM boards by other manufacturer */
244246   { "NAMCOT-3401",      STD_DXROM },
245247   { "NAMCOT-3405",      STD_DXROM },
r8270r8271
252254   { "NAMCOT-3417",      STD_DXROM },
253255   { "NAMCOT-3451",      STD_DXROM },
254256   { "TENGEN-800002",    STD_DXROM },
255   { "TENGEN-800004",    STD_DXROM },
257   { "TENGEN-800004",    STD_DRROM },
256258   { "TENGEN-800030",    STD_DXROM },
257259//
258260   /* Nintendo HKROM */
r8270r8271
300302   /* Discrete board IC_74x161x161x32 */
301303   { "BANDAI-74*161/161/32", DIS_74X161X161X32 },
302304   { "TAITO-74*161/161/32", DIS_74X161X161X32 },
305   /* FIXME: Made up boards the different mirroring handling */
306   { "BANDAI-74*161/161/32-A", DIS_74X161X161X32_A },
303307   /* Discrete board IC_74x161x138 */
304308   { "BIT-CORP-74*161/138", DIS_74X161X138 },
305309//
306   { "BANDAI-LZ93D50+24C01", BANDAI_LZ93EX },
307   { "BANDAI-LZ93D50+24C02", BANDAI_LZ93EX },
310   { "BANDAI-LZ93D50+24C01", BANDAI_LZ93 },
311   { "BANDAI-LZ93D50+24C02", BANDAI_LZ93 },
308312   { "BANDAI-FCG-1",     BANDAI_FCG },
309313   { "BANDAI-FCG-2",     BANDAI_FCG },
310314   { "BANDAI-JUMP2",     BANDAI_JUMP2 },   
311315   { "BANDAI-DATACH",    BANDAI_DATACH },
312316   { "BANDAI-KARAOKE",   BANDAI_KARAOKE },
313317   { "BANDAI-OEKAKIDS",  BANDAI_OEKAKIDS },
318   { "IREM-FCG-1",       BANDAI_FCG },
314319//
315320   { "IREM-G101",        IREM_G101 },
316   { "IREM-G101-A",      IREM_G101 },
317   { "IREM-G101-B",      IREM_G101 },
318321   { "IREM-74*161/161/21/138", IREM_LROG017 },
319322   { "IREM-H-3001",      IREM_H3001 },
320323   { "IREM-HOLYDIVER",   IREM_HOLYDIV },
324   { "IREM-TAM-S1",      IREM_TAM_S1 },
325   /* FIXME: Made up boards the different mirroring handling */
326   { "IREM-G101-A",      IREM_G101_A },
321327//
322328   { "JALECO-JF-23",     JALECO_SS88006 },
323329   { "JALECO-JF-24",     JALECO_SS88006 },
r8270r8271
361367   { "NAMCOT-3433",      NAMCOT_34X3 },
362368   { "NAMCOT-3443",      NAMCOT_34X3 },
363369   { "NAMCOT-3446",      NAMCOT_3446 },
370   { "NAMCOT-3453",      NAMCOT_3453 },
364371//
365372   { "SUNSOFT-1",        SUNSOFT_1 },
366   { "SUNSOFT-2",        SUNSOFT_2 },
373   { "SUNSOFT-2",        SUNSOFT_2_B },
367374   { "SUNSOFT-3",        SUNSOFT_3 },
368//
375   /* FIXME: Made up boards the different mirroring handling */
376   { "SUNSOFT-2A",       SUNSOFT_2_A },
377   { "SUNSOFT-2B",       SUNSOFT_2_B },
378   //
369379   { "TAITO-TC0190FMC",  TAITO_TC0190FMC },
370380   { "TAITO-TC0190FMC+PAL16R4", TAITO_TC0190FMCP },
371   { "TAITO-X1-005",     TAITO_X1005 },
372   { "TAITO-X1-017",     TAITO_X1017 },
381   { "TAITO-X1-005",     TAITO_X1_005 },
382   { "TAITO-X1-017",     TAITO_X1_017 },
383   /* FIXME: Made up boards the different mirroring handling */
384   { "TAITO-X1-005-A",   TAITO_X1_005_A },
373385//
374386   { "AGCI-50282",       AGCI_50282 },
375387   { "AVE-NINA-01",      AVE_NINA01 },
r8270r8271
378390   { "AVE-NINA-06",      AVE_NINA06 },
379391   { "AVE-MB-91",        AVE_NINA06 },
380392   { "UNL-SA-016-1M",    AVE_NINA06 },
381   { "CAMERICA-ALGN",    CAMERICA_ALGN },
382   { "CAMERICA-BF9093",  CAMERICA_ALGN },
383   { "CAMERICA-BF9097",  CAMERICA_9097 },
384   { "CAMERICA-ALGQ",    CAMERICA_ALGQ },
385   { "CAMERICA-BF9096",  CAMERICA_ALGQ },
393   { "CAMERICA-ALGN",    CAMERICA_BF9093 },
394   { "CAMERICA-BF9093",  CAMERICA_BF9093 },
395   { "CAMERICA-BF9097",  CAMERICA_BF9097 },
396   { "CAMERICA-ALGQ",    CAMERICA_BF9096 },
397   { "CAMERICA-BF9096",  CAMERICA_BF9096 },
386398   { "CAMERICA-GOLDENFIVE", CAMERICA_GOLDENFIVE },
387399   { "CNE-DECATHLON",    CNE_DECATHLON },
388   { "CNE-PSB",          CNE_PSB },
400   { "CNE-PSB",          CNE_FSB },
389401   { "CNE-SHLZ",         CNE_SHLZ },
390402   { "JYCOMPANY-A",      UNSUPPORTED_BOARD },   // mapper 90
391403   { "JYCOMPANY-B",      UNSUPPORTED_BOARD },   // mapper 209
r8270r8271
409421   { "SACHEN-8259D",     SACHEN_8259D },
410422   { "UNL-SACHEN-8259D", SACHEN_8259D },
411423   { "UNL-SACHEN-74LS374N", SACHEN_74LS374 },
424   { "UNL-SACHEN-74LS374N-A", SACHEN_74LS374_A },/* FIXME: Made up boards the different mirroring handling */
412425   { "UNL-TC-U01-1.5M",  SACHEN_TCU01 },
413426   { "TENGEN-800032",    TENGEN_800032 },
414427   { "TENGEN-800037",    TENGEN_800037 },
r8270r8271
426439   { "WAIXING-PS2",      WAIXING_PS2 },
427440   { "WAIXING-FFV",      WAIXING_FFV },
428441   { "WAIXING-ZS",       WAIXING_ZS },
442   { "WAIXING-DQ8",      WAIXING_DQ8 },
429443   { "WAIXING-SH2",      UNSUPPORTED_BOARD },
430444//
431445   { "TXC-TW",           TXC_TW },
432446   { "TXC-MXMDHTWO",     TXC_MXMDHTWO },
433447   { "UNL-22211",        TXC_22211A },
448   /* FIXME: Made up boards the different mirroring handling */
449   { "UNL-22211-A",      TXC_22211A },
450   { "UNL-22211-B",      TXC_22211B },
451   { "UNL-22211-C",      TXC_22211C },
434452   { "UNL-REXSOFT-DBZ5", REXSOFT_DBZ5 },
435453   { "UNL-SL1632",       REXSOFT_SL1632 },
436454   { "SUBOR-BOARD-0",    SUBOR_TYPE0 },
r8270r8271
445463   { "DREAMTECH01",      DREAMTECH_BOARD },
446464   { "DAOU-306",         OPENCORP_DAOU306 },
447465   { "HES",              HES_BOARD },
466   /* FIXME: Made up boards the different mirroring handling? */
467   { "HES-6IN1",         HES6IN1_BOARD },
448468   { "SUPERGAME-BOOGERMAN", SUPERGAME_BOOGERMAN },
449469   { "FUTUREMEDIA",      FUTUREMEDIA_BOARD },
450   { "MAGICSERIES",      MAGICSERIES_MAGICDRAGON },
470   { "MAGICSERIES",      MAGICSERIES_MD },
451471   { "KASING",           KASING_BOARD },
452472   { "HENGGEDIANZI",     HENGEDIANZI_BOARD },
473   { "HENGGEDIANZI-XJZB", HENGEDIANZI_XJZB },
453474   { "KAISER-KS7058",    KAISER_KS7058 },
454475   { "KAISER-KS202",     UNSUPPORTED_BOARD },// mapper 56
455476   { "KAISER-KS7022",    UNSUPPORTED_BOARD },// mapper 175
r8270r8271
504525   { "BMC-GS-2004",         BMC_GS2004 },
505526   { "BMC-GS-2013",         BMC_GS2013 },
506527   { "BMC-NOVELDIAMOND9999999IN1", BMC_NOVELDIAMOND },
528   { "BMC-9999999IN1",      BMC_9999999IN1 }, // mapper 213... same as BMC-NOVELDIAMOND9999999IN1 ??
507529   { "BMC-SUPER24IN1SC03",  BMC_S24IN1SC03 },
508530   { "BMC-SUPERHIK8IN1",    BMC_HIK8IN1 },
509531   { "BMC-T-262",           BMC_T262 },
r8270r8271
526548   { "BMC-64IN1",           BMC_64IN1 },
527549   { "BMC-15IN1",           BMC_15IN1 },
528550   { "BMC-SUPERHIK-300IN1", BMC_SUPERHIK_300IN1 },
529   { "BMC-9999999IN1",      BMC_9999999IN1 }, // mapper 213... same as BMC-NOVELDIAMOND9999999IN1 ??
530551   { "BMC-SUPERGUN-20IN1",  BMC_SUPERGUN_20IN1 },
531552   { "BMC-GOLDENCARD-6IN1", BMC_GOLDENCARD_6IN1 },
532553   { "BMC-72IN1",           BMC_72IN1 },
r8270r8271
560581// are there dumps of games with these boards?
561582   { "WAIXING-I",        UNSUPPORTED_BOARD }, // [supported by NEStopia - we need more info]
562583   { "WAIXING-J",        UNSUPPORTED_BOARD }, // [supported by NEStopia - we need more info]
563   { "BMC-13IN1JY110",  UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
564   { "BMC-GK-192",      UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
565   { "KONAMI-QTAI",     UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
566   { "UNL-8157",        UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
567   { "UNL-3D-BLOCK",    UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
568   { "UNL-C-N22M",      UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
569   { "UNL-KS7017",      UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
570   { "UNL-PEC-586",     UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
571   { "UNL-SA-009",      UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
572   {0}
584   { "BMC-13IN1JY110",   UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
585   { "BMC-GK-192",       UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
586   { "KONAMI-QTAI",      UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
587   { "UNL-8157",         UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
588   { "UNL-3D-BLOCK",     UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
589   { "UNL-C-N22M",       UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
590   { "UNL-KS7017",       UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
591   { "UNL-PEC-586",      UNSUPPORTED_BOARD }, //  [mentioned in FCEUMM source - we need more info]
592   { "UNL-SA-009",       UNSUPPORTED_BOARD }  //  [mentioned in FCEUMM source - we need more info]
573593};
574594
575595const nes_pcb *nes_pcb_lookup( const char *board )
r8270r8271
624644
625645/*************************************************************
626646 
647 Nihon Bussan UNROM
648
649 Games: Crazy Climber Jpn
650 
651 Very simple mapper: prg16_89ab is always set to bank 0,
652 while prg16_cdef is set by writes to 0x8000-0xffff. The game
653 uses a custim controller.
654 
655 iNES: mapper 180
656 
657 In MESS: Supported.
658 
659 *************************************************************/
660
661static WRITE8_HANDLER( uxrom_cc_w )
662{
663   LOG_MMC(("uxrom_cc_w, offset: %04x, data: %02x\n", offset, data));
664   
665   prg16_cdef(space->machine, data & 0x07);
666}
667
668/*************************************************************
669 
627670 UN1ROM board emulation
628671 
629672 writes to 0x8000-0xffff change PRG 16K lower banks
r8270r8271
662705   nes_state *state = (nes_state *)space->machine->driver_data;
663706   LOG_MMC(("cnrom_w, offset: %04x, data: %02x\n", offset, data));
664707
665//   printf("%x\n", data);
666708   if (state->ce_mask)
667709   {
668710      chr8(space->machine, data & ~state->ce_mask, CHRROM);
r8270r8271
678720
679721/*************************************************************
680722 
723 Bandai PT-554 board emulation
724 
725 This is used by Aerobics Studio. It is basically a CNROM board
726 with an additional sound chip which is not currently emulated by
727 MESS
728 
729 iNES: mapper 3?
730
731 *************************************************************/
732
733static WRITE8_HANDLER( bandai_pt554_m_w )
734{
735   LOG_MMC(("Bandai PT-554 Sound write, data: %02x\n", data));
736   
737   // according to NEStopia, this is the effect
738   if (!BIT(data, 6))
739   {
740      // send command (data & 0x07) to sound chip
741   }
742}
743
744/*************************************************************
745 
681746 CPROM board emulation
682747 
683748 writes to 0x8000-0xffff change CHR 4K lower banks
r8270r8271
783848         else
784849            memory_unmap_readwrite(space, 0x6000, 0x7fff, 0, 0);
785850      case STD_SXROM_A:   // ignore WRAM enable bit
786         if (state->battery)
851         if (state->battery_size > 0x2000)
787852            wram_bank(machine, ((state->mmc_reg[1] & 3) >> 2), NES_BATTERY);
853         else
854            wram_bank(machine, 0, NES_BATTERY);
788855         break;
789856   }
790857}
r8270r8271
10851152   nes_state *state = (nes_state *)space->machine->driver_data;
10861153   UINT8 MMC3_helper, cmd;
10871154   
1088   LOG_MMC(("mapper4_w, offset: %04x, data: %02x\n", offset, data));
1155   LOG_MMC(("txrom_w, offset: %04x, data: %02x\n", offset, data));
10891156   
10901157   switch (offset & 0x6001)
10911158   {
r8270r8271
11481215         break;
11491216         
11501217      default:
1151         logerror("mapper4_w uncaught: %04x value: %02x\n", offset + 0x8000, data);
1218         logerror("txrom_w uncaught: %04x value: %02x\n", offset + 0x8000, data);
11521219         break;
11531220   }
11541221}
r8270r8271
11701237
11711238/*************************************************************
11721239 
1173 DxROM (MMC3 based) board emulation
1174 
1175 iNES: mapper 206
1176 
1177 *************************************************************/
1178
1179static WRITE8_HANDLER( dxrom_w )
1180{
1181   LOG_MMC(("mapper206_w, offset: %04x, data: %02x\n", offset, data));
1182
1183   if ((offset & 0x6001) == 0x2000)
1184      return;
1185   
1186   txrom_w(space, offset, data);
1187}
1188
1189
1190/*************************************************************
1191 
11921240 TxSROM (MMC3 based) board emulation
11931241 
11941242 iNES: mapper 118
r8270r8271
13761424static WRITE8_HANDLER( qj_m_w )
13771425{
13781426   nes_state *state = (nes_state *)space->machine->driver_data;
1379   LOG_MMC(("mapper47_m_w, offset: %04x, data: %02x\n", offset, data));
1427   LOG_MMC(("qj_m_w, offset: %04x, data: %02x\n", offset, data));
13801428   
13811429   state->mmc_prg_base = (data & 0x01) << 4;
13821430   state->mmc_prg_mask = 0x0f;
r8270r8271
15531601         
15541602      case 0x1013: /* $5113 */
15551603         LOG_MMC(("MMC5 mid RAM bank select: %02x\n", data & 0x07));
1556         state->prg_bank[4] = state->prgram_bank5_start + (data & 0x07);
1604         // FIXME: a few Koei games have both WRAM & BWRAM but here we don't support this (yet)
1605         if (state->battery)
1606            state->prg_bank[4] = state->battery_bank5_start + (data & 0x07);
1607         else
1608            state->prg_bank[4] = state->prgram_bank5_start + (data & 0x07);
15571609         memory_set_bank(space->machine, "bank5", state->prg_bank[4]);
1610         //wram_bank(space->machine, data & 0x07, NES_WRAM);
15581611         break;
15591612         
15601613      case 0x1014: /* $5114 */
r8270r8271
19622015
19632016/*************************************************************
19642017 
1965 NTBROM board emulation
2018 NTBROM & Sunsoft-4 board emulation
2019
2020 Part of this can be used also for Sunsoft Double Cassette
2021 System... which games use it?
19662022 
1967 if PRG > 128k -> SUNSOFT_DCS (additional handlers at 0x6000
1968 0x8000-0xbfff and 0xf000-0xffff), otherwise SUNSOFT_4
1969 
19702023 iNES: mapper 68
19712024 
19722025 *************************************************************/
r8270r8271
20182071{
20192072   nes_state *state = (nes_state *)space->machine->driver_data;
20202073   
2021   LOG_MMC(("mapper68_w, offset %04x, data: %02x\n", offset, data));
2074   LOG_MMC(("ntbrom_w, offset %04x, data: %02x\n", offset, data));
20222075   
20232076   switch (offset & 0x7000)
20242077   {
r8270r8271
20352088         chr2_6(space->machine, data, CHRROM);
20362089         break;
20372090      case 0x4000:
2038         state->m0 = data & 0x7f;
2039         ntbrom_mirror(space->machine, state->m68_mirror, state->m0, state->m1);
2091         state->mmc_latch1 = data & 0x7f;
2092         ntbrom_mirror(space->machine, state->mmc_reg[0], state->mmc_latch1, state->mmc_latch2);
20402093         break;
20412094      case 0x5000:
2042         state->m1 = data & 0x7f;
2043         ntbrom_mirror(space->machine, state->m68_mirror, state->m0, state->m1);
2095         state->mmc_latch2 = data & 0x7f;
2096         ntbrom_mirror(space->machine, state->mmc_reg[0], state->mmc_latch1, state->mmc_latch2);
20442097         break;
20452098      case 0x6000:
2046         state->m68_mirror = data & 0x13;
2047         ntbrom_mirror(space->machine, state->m68_mirror, state->m0, state->m1);
2099         state->mmc_reg[0] = data & 0x13;
2100         ntbrom_mirror(space->machine, state->mmc_reg[0], state->mmc_latch1, state->mmc_latch2);
20482101         break;
20492102      case 0x7000:
20502103         prg16_89ab(space->machine, data);
20512104         break;
20522105      default:
2053         LOG_MMC(("mapper68_w uncaught offset: %04x, data: %02x\n", offset, data));
2106         LOG_MMC(("ntbrom_w uncaught offset: %04x, data: %02x\n", offset, data));
20542107         break;
20552108   }
20562109}
20572110
20582111/*************************************************************
20592112 
2060 JxROM board emulation
2113 JxROM & Sunsoft 5A / 5B / FME7 board emulation
20612114 
2062 Sunsoft 5b / FME7 (5b = FME7 + sound chip)
2115 Notice that Sunsoft-5B = FME7 + sound chip (the latter being
2116 currently unemulated in MESS)
20632117 
20642118 iNES: mapper 69
20652119 
r8270r8271
20832137      else
20842138         state->IRQ_count -= 114;
20852139   }
2086   else if (state->IRQ_enable & 0x01)   // if enable bit is not set, only decrement the counter!
2140   else if (state->IRQ_enable & 0x01)   // if enable bit 7 is not set, only decrement the counter!
20872141   {
20882142      if (state->IRQ_count <= 114)
20892143         state->IRQ_count = 0xffff;
r8270r8271
20952149static WRITE8_HANDLER( jxrom_w )
20962150{
20972151   nes_state *state = (nes_state *)space->machine->driver_data;
2098   LOG_MMC(("mapper69_w, offset %04x, data: %02x\n", offset, data));
2152   LOG_MMC(("jxrom_w, offset %04x, data: %02x\n", offset, data));
20992153   
21002154   switch (offset & 0x6000)
21012155   {
r8270r8271
21052159         
21062160      case 0x2000:
21072161         switch (state->mmc_latch1)
2108      {
2162         {
21092163         case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
21102164            chr1_x(space->machine, state->mmc_latch1, data, CHRROM);
21112165            break;
21122166           
2113            /* TODO: deal properly with bankswitching/write-protecting the mid-mapper area */
21142167         case 8:
21152168            if (!(data & 0x40))
21162169            {
r8270r8271
21222175            {
21232176               // is PRG RAM
21242177               memory_install_write_bank(space, 0x6000, 0x7fff, 0, 0, "bank5");
2125               state->prg_bank[4] = state->prg_chunks + (data & 0x3f);
2178               state->prg_bank[4] = state->battery_bank5_start + (data & 0x3f);
21262179               memory_set_bank(space->machine, "bank5", state->prg_bank[4]);
21272180            }
21282181            break;
r8270r8271
21382191            break;
21392192         case 0x0c:
21402193            switch (data & 0x03)
2141         {
2194            {
21422195            case 0x00: set_nt_mirroring(space->machine, PPU_MIRROR_VERT); break;
21432196            case 0x01: set_nt_mirroring(space->machine, PPU_MIRROR_HORZ); break;
21442197            case 0x02: set_nt_mirroring(space->machine, PPU_MIRROR_LOW); break;
21452198            case 0x03: set_nt_mirroring(space->machine, PPU_MIRROR_HIGH); break;
2146         }
2199            }
21472200            break;
21482201         case 0x0d:
21492202            state->IRQ_enable = data;
r8270r8271
21542207         case 0x0f:
21552208            state->IRQ_count = (state->IRQ_count & 0x00ff) | (data << 8);
21562209            break;
2157      }
2210         }
21582211         break;
21592212         
21602213         /* Here we would have sound command for Sunsoft 5b variant */
21612214         //      case 0x4000:
21622215         //      case 0x6000:
21632216         
2217      case 0x4000:
2218         LOG_MMC(("Sunsoft-5B Sound: Register select write, data: %02x\n", data));
2219         break;
2220      case 0x6000:
2221         LOG_MMC(("Sunsoft-5B Sound: Register write, data: %02x\n", data));
2222         break;
21642223      default:
2165         logerror("mapper69_w uncaught %04x value: %02x\n", offset + 0x8000, data);
2224         logerror("jxrom_w uncaught %04x value: %02x\n", offset + 0x8000, data);
21662225         break;
21672226   }
21682227}
21692228
2229/*************************************************************
2230 
2231 DxROM & Namcot 3433 - 3443 board emulation
2232 
2233 These are the same board, but DRROM (and Tengen 800004) have
2234 4-screen mirroring
2235 
2236 iNES: mappers 88, 206 (same as 88 but possibly 4-screen mirroring)
2237 
2238 *************************************************************/
21702239
2240static WRITE8_HANDLER( dxrom_w )
2241{
2242   nes_state *state = (nes_state *)space->machine->driver_data;
2243   LOG_MMC(("dxrom_w, offset: %04x, data: %02x\n", offset, data));
2244   
2245   if (offset >= 0x2000)
2246      return;
2247   
2248   switch (offset & 1)
2249   {
2250      case 1:
2251         switch (state->mmc_latch1 & 0x07)
2252         {
2253         case 0: chr2_0(space->machine, data >> 1, CHRROM); break;
2254         case 1: chr2_2(space->machine, data >> 1, CHRROM); break;
2255         case 2: chr1_4(space->machine, data | 0x40, CHRROM); break;
2256         case 3: chr1_5(space->machine, data | 0x40, CHRROM); break;
2257         case 4: chr1_6(space->machine, data | 0x40, CHRROM); break;
2258         case 5: chr1_7(space->machine, data | 0x40, CHRROM); break;
2259         case 6: prg8_89(space->machine, data); break;
2260         case 7: prg8_ab(space->machine, data); break;
2261         }
2262         break;
2263      case 0:
2264         state->mmc_latch1 = data;
2265         break;
2266   }
2267}
2268
21712269/*************************************************************
21722270 
2173 NINA-001 board by AVE emulation
2271 Namcot 3453 board emulation
21742272 
2273 These are the same as Namcot 34x3, but with additional mirroring
2274 control
2275 
2276 iNES: mappers 154
2277 
2278 *************************************************************/
2279
2280static WRITE8_HANDLER( namcot3453_w )
2281{
2282   LOG_MMC(("namcot3453_w, offset: %04x, data: %02x\n", offset, data));
2283   
2284   // additional mirroring control when writing to even addresses
2285   if (!(offset & 1))
2286      set_nt_mirroring(space->machine, BIT(data, 6) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
2287
2288   dxrom_w(space, offset, data);
2289}
2290
2291/*************************************************************
2292 
2293 Namcot 3446 board emulation
2294 
2295 These are similar Namcot 34x3, but different bankswitch capabilities
2296 
2297 iNES: mappers 76
2298 
2299 *************************************************************/
2300
2301static WRITE8_HANDLER( namcot3446_w )
2302{
2303   nes_state *state = (nes_state *)space->machine->driver_data;
2304   LOG_MMC(("namcot3446_w, offset: %04x, data: %02x\n", offset, data));
2305   
2306   // NEStopia does not have this!
2307   if (offset >= 0x2000)
2308   {
2309      if (!(offset & 1))
2310         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
2311      return;
2312   }
2313   
2314   switch (offset & 1)
2315   {
2316      case 1:
2317         switch (state->mmc_latch1 & 0x07)
2318         {
2319         case 2: chr2_0(space->machine, data, CHRROM); break;
2320         case 3: chr2_2(space->machine, data, CHRROM); break;
2321         case 4: chr2_4(space->machine, data, CHRROM); break;
2322         case 5: chr2_6(space->machine, data, CHRROM); break;
2323         case 6: BIT(state->mmc_latch1, 6) ? prg8_cd(space->machine, data) : prg8_89(space->machine, data); break;
2324         case 7: prg8_ab(space->machine, data); break;
2325         }
2326         break;
2327      case 0:
2328         state->mmc_latch1 = data;
2329         break;
2330   }
2331}
2332
2333/*************************************************************
2334 
2335 Namcot 3425 board emulation
2336 
2337 These are similar Namcot 34x3, but with NT mirroring (two
2338 different modes)
2339 
2340 iNES: mappers 95
2341 
2342 *************************************************************/
2343
2344static WRITE8_HANDLER( namcot3425_w )
2345{
2346   nes_state *state = (nes_state *)space->machine->driver_data;
2347   UINT8 mode;
2348   LOG_MMC(("namcot3425_w, offset: %04x, data: %02x\n", offset, data));
2349   if (offset >= 0x2000)
2350      return;
2351   
2352   switch (offset & 1)
2353   {
2354      case 1:
2355         mode = state->mmc_latch1 & 0x07;
2356         switch (mode)
2357         {
2358         case 0: chr2_0(space->machine, data >> 1, CHRROM); break;
2359         case 1: chr2_2(space->machine, data >> 1, CHRROM); break;
2360         case 2:
2361         case 3:
2362         case 4:
2363         case 5:
2364            chr1_x(space->machine, 2 + mode, data, CHRROM);
2365            state->mmc_reg[mode - 2] = BIT(data, 5);
2366            if (!BIT(state->mmc_latch1, 7))
2367            {
2368                  set_nt_page(space->machine, 0, CIRAM, state->mmc_reg[0], 1);
2369                  set_nt_page(space->machine, 1, CIRAM, state->mmc_reg[1], 1);
2370                  set_nt_page(space->machine, 2, CIRAM, state->mmc_reg[2], 1);
2371                  set_nt_page(space->machine, 3, CIRAM, state->mmc_reg[3], 1);
2372            }
2373            else
2374               set_nt_mirroring(space->machine, PPU_MIRROR_HORZ);
2375            break;
2376         case 6: prg8_89(space->machine, data); break;
2377         case 7: prg8_ab(space->machine, data); break;
2378         }
2379         break;
2380      case 0:
2381         state->mmc_latch1 = data;
2382         break;
2383   }
2384}
2385
2386/*************************************************************
2387 
2388 Discrete Logic board IC 74x377 by Color Dreams / Nina-007 emulation
2389 
2390 iNES: mappers 11
2391 
2392 *************************************************************/
2393
2394static WRITE8_HANDLER( dis_74x377_w )
2395{
2396   nes_state *state = (nes_state *)space->machine->driver_data;
2397   LOG_MMC(("dis_74x377_w, offset: %04x, data: %02x\n", offset, data));
2398   
2399   chr8(space->machine, data >> 4, state->mmc_chr_source);
2400   prg32(space->machine, data & 0x0f);
2401}
2402
2403/*************************************************************
2404 
2405 Discrete Logic board IC 74x139x74 by Konami & Jaleco
2406 
2407 iNES: mappers 87
2408 
2409 *************************************************************/
2410
2411static WRITE8_HANDLER( dis_74x139x74_m_w )
2412{
2413   LOG_MMC(("dis_74x139x74_m_w, offset: %04x, data: %02x\n", offset, data));
2414   
2415   chr8(space->machine, ((data & 0x02) >> 1) | ((data & 0x01) << 1), CHRROM);
2416}
2417
2418/*************************************************************
2419 
2420 Discrete Logic board IC 74x161x138
2421 
2422 iNES: mappers 38
2423 
2424 *************************************************************/
2425
2426static WRITE8_HANDLER( dis_74x161x138_m_w )
2427{
2428   LOG_MMC(("dis_74x161x138_m_w, offset: %04x, data: %02x\n", offset, data));
2429   
2430   chr8(space->machine, data >> 2, CHRROM);
2431   prg32(space->machine, data);
2432}
2433
2434/*************************************************************
2435 
2436 Discrete Logic board IC 74x161x161x32
2437 
2438 There are two variants (one with hardwired mirroring, the
2439 other with a mirroring control), making necessary two distinct
2440 mappers & pcb_id
2441 
2442 iNES: mapper 70 & 152
2443 
2444 *************************************************************/
2445
2446static WRITE8_HANDLER( dis_74x161x161x32a_w )
2447{
2448   LOG_MMC(("dis_74x161x161x32_w, offset: %04x, data: %02x\n", offset, data));
2449   
2450   chr8(space->machine, data, CHRROM);
2451   prg16_89ab(space->machine, data >> 4);
2452}
2453
2454static WRITE8_HANDLER( dis_74x161x161x32_w )
2455{
2456   LOG_MMC(("dis_74x161x161x32_w, offset: %04x, data: %02x\n", offset, data));
2457   
2458   set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
2459   dis_74x161x161x32a_w(space, offset, data);
2460}
2461
2462/*************************************************************
2463 
2464 Bandai LZ93D50 boards emulation
2465 
2466 There are several variants: plain board, board + 24C01 EEPROM,
2467 board + 24C02 EEPROM, board + Barcode Reader (DATACH).
2468 We currently only emulate the base hardware.
2469 
2470 iNES: mapper 16, 153 & 157
2471 
2472 *************************************************************/
2473
2474/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
2475 we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
2476 there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
2477static void bandai_lz_irq( running_device *device, int scanline, int vblank, int blanked )
2478{
2479   nes_state *state = (nes_state *)device->machine->driver_data;
2480   
2481   /* 114 is the number of cycles per scanline */
2482   /* TODO: change to reflect the actual number of cycles spent */
2483   if (state->IRQ_enable)
2484   {
2485      if (state->IRQ_count <= 114)
2486      {
2487         cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
2488         state->IRQ_count = (0xffff - 114 + state->IRQ_count);   // wrap around the 16 bits counter
2489      }
2490      state->IRQ_count -= 114;
2491   }
2492}
2493
2494static WRITE8_HANDLER( lz93d50_w )
2495{
2496   nes_state *state = (nes_state *)space->machine->driver_data;
2497   LOG_MMC(("lz93d50_w, offset: %04x, data: %02x\n", offset, data));
2498   
2499   switch (offset & 0x000f)
2500   {
2501      case 0: case 1: case 2: case 3:
2502      case 4: case 5: case 6: case 7:
2503         chr1_x(space->machine, offset & 0x07, data, state->mmc_chr_source);
2504         break;
2505      case 8:
2506         prg16_89ab(space->machine, data);
2507         break;
2508      case 9:
2509         switch (data & 0x03)
2510         {
2511         case 0: set_nt_mirroring(space->machine, PPU_MIRROR_VERT); break;
2512         case 1: set_nt_mirroring(space->machine, PPU_MIRROR_HORZ); break;
2513         case 2: set_nt_mirroring(space->machine, PPU_MIRROR_LOW); break;
2514         case 3: set_nt_mirroring(space->machine, PPU_MIRROR_HIGH); break;
2515         }
2516         break;
2517      case 0x0a:
2518         state->IRQ_enable = data & 0x01;
2519         break;
2520      case 0x0b:
2521         state->IRQ_count = (state->IRQ_count & 0xff00) | data;
2522         break;
2523      case 0x0c:
2524         state->IRQ_count = (state->IRQ_count & 0x00ff) | (data << 8);
2525         break;
2526      default:
2527         logerror("lz93d50_w uncaught write, offset: %04x, data: %02x\n", offset, data);
2528         break;
2529   }
2530}
2531
2532static WRITE8_HANDLER( lz93d50_m_w )
2533{
2534   nes_state *state = (nes_state *)space->machine->driver_data;
2535   LOG_MMC(("lz93d50_m_w, offset: %04x, data: %02x\n", offset, data));
2536
2537   if (!state->battery && !state->wram)
2538      lz93d50_w(space, offset, data);
2539   else if (state->battery)
2540      state->battery_ram[offset] = data;
2541   else
2542      state->wram[offset] = data;
2543}
2544
2545static void fjump2_set_prg( running_machine *machine )
2546{
2547   nes_state *state = (nes_state *)machine->driver_data;
2548   UINT8 mmc_helper = 0;
2549   int i;
2550   
2551   for (i = 0; i < 8; i++)
2552      mmc_helper |= ((state->mmc_reg[i] & 0x01) << 4);
2553   
2554   state->mmc_latch1 = mmc_helper | (state->mmc_latch1 & 0x0f);
2555   
2556   prg16_89ab(machine, state->mmc_latch1);
2557   prg16_cdef(machine, mmc_helper | 0x0f);
2558}
2559
2560static WRITE8_HANDLER( fjump2_w )
2561{
2562   nes_state *state = (nes_state *)space->machine->driver_data;
2563
2564   LOG_MMC(("fjump2_w, offset: %04x, data: %02x\n", offset, data));
2565   
2566   switch (offset & 0x000f)
2567   {
2568      case 0: case 1: case 2: case 3:
2569      case 4: case 5: case 6: case 7:
2570         state->mmc_reg[offset & 0x000f] = data;
2571         fjump2_set_prg(space->machine);
2572         break;
2573      case 8:
2574         state->mmc_latch1 = (data & 0x0f) | (state->mmc_latch1 & 0x10);
2575         prg16_89ab(space->machine, state->mmc_latch1);
2576         break;
2577      default:
2578         lz93d50_m_w(space, offset & 0x0f, data);
2579         break;
2580   }
2581}
2582
2583/*************************************************************
2584 
2585 Bandai Karaoke Studio board emulation
2586 
2587 Note: we currently do not emulate the mic
2588 
2589 iNES: mapper 188
2590 
2591 *************************************************************/
2592
2593static WRITE8_HANDLER( bandai_ks_w )
2594{
2595   LOG_MMC(("bandai_ks_w, offset: %04x, data: %02x\n", offset, data));
2596   
2597   prg16_89ab(space->machine, data ^ 0x08);
2598}
2599
2600/*************************************************************
2601 
2602 Bandai Oeka Kids board emulation
2603 
2604 Note: we currently do support the correct mirroring
2605 
2606 iNES: mapper 96
2607 
2608 *************************************************************/
2609
2610static WRITE8_HANDLER( bandai_ok_w )
2611{
2612   nes_state *state = (nes_state *)space->machine->driver_data;
2613   UINT8 mmc_helper;
2614   LOG_MMC(("mapper96_w, offset: %04x, data: %02x\n", offset, data));
2615
2616   prg32(space->machine, data);
2617
2618   state->mmc_latch1 = data;
2619   mmc_helper = (state->mmc_latch1 & 0x03) | data & 0x04;
2620   chr4_0(space->machine, mmc_helper, state->mmc_chr_source);
2621   chr4_4(space->machine, 0x03 | (data & 0x04), state->mmc_chr_source);
2622}
2623
2624/*************************************************************
2625 
2626 Irem Discrete board emulation (74*161/161/21/138)
2627 
2628 iNES: mapper 77
2629 
2630 *************************************************************/
2631
2632static WRITE8_HANDLER( lrog017_w )
2633{
2634   LOG_MMC(("lrog017_w, offset: %04x, data: %02x\n", offset, data));
2635   
2636   prg32(space->machine, data);
2637   chr2_0(space->machine, (data >> 4), CHRROM);
2638}
2639
2640/*************************************************************
2641 
2642 Irem Holy Diver board emulation
2643 
2644 iNES: mapper 78 (shared with JF-16)
2645 
2646 *************************************************************/
2647
2648static WRITE8_HANDLER( irem_hd_w )
2649{
2650   LOG_MMC(("irem_hd_w, offset: %04x, data: %02x\n", offset, data));
2651   
2652   set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_VERT : PPU_MIRROR_HORZ);
2653   chr8(space->machine, data >> 4, CHRROM);
2654   prg16_89ab(space->machine, data);
2655}
2656
2657/*************************************************************
2658 
2659 Irem TAM-S1 board emulation
2660 
2661 iNES: mapper 97
2662 
2663 *************************************************************/
2664
2665static WRITE8_HANDLER( tam_s1_w )
2666{
2667   LOG_MMC(("tam_s1_w, offset: %04x, data: %02x\n", offset, data));
2668   
2669   if (offset < 0x4000)
2670   {
2671      set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_VERT : PPU_MIRROR_HORZ);
2672      prg16_cdef(space->machine, data & 0x0f);
2673   }
2674}
2675
2676/*************************************************************
2677 
2678 Irem G-101 board emulation
2679 
2680 Major League uses hardwired mirroring, making necessary two
2681 distinct pcb_id
2682
2683 iNES: mapper 32
2684 
2685 *************************************************************/
2686
2687static WRITE8_HANDLER( g101a_w )
2688{
2689   nes_state *state = (nes_state *)space->machine->driver_data;
2690   LOG_MMC(("g101_w, offset: %04x, data: %02x\n", offset, data));
2691   
2692   switch (offset & 0x7000)
2693   {
2694      case 0x0000:
2695         // NEStopia here differs a little bit
2696         state->mmc_latch1 ? prg8_cd(space->machine, data) : prg8_89(space->machine, data);
2697         break;
2698      case 0x1000:
2699         state->mmc_latch1 = BIT(data, 1);
2700         break;
2701      case 0x2000:
2702         prg8_ab(space->machine, data);
2703         break;
2704      case 0x3000:
2705         chr1_x(space->machine, offset & 0x07, data, CHRROM);
2706         break;
2707   }
2708}
2709
2710static WRITE8_HANDLER( g101_w )
2711{
2712   LOG_MMC(("g101_w, offset: %04x, data: %02x\n", offset, data));
2713
2714   if ((offset & 0x7000) == 0x1000)
2715      set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
2716
2717   g101a_w(space, offset, data);
2718}
2719
2720
2721/*************************************************************
2722 
2723 Irem H-3001 board emulation
2724 
2725 iNES: mapper 65
2726 
2727 *************************************************************/
2728
2729/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
2730 we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
2731 there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
2732static void h3001_irq( running_device *device, int scanline, int vblank, int blanked )
2733{
2734   nes_state *state = (nes_state *)device->machine->driver_data;
2735   if (state->IRQ_enable)
2736   {
2737      state->IRQ_count -= 114;
2738     
2739      if (state->IRQ_count <= 114)
2740      {
2741         state->IRQ_enable = 0;
2742         cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
2743      }
2744   }
2745}
2746
2747static WRITE8_HANDLER( h3001_w )
2748{
2749   nes_state *state = (nes_state *)space->machine->driver_data;
2750   LOG_MMC(("h3001_w, offset %04x, data: %02x\n", offset, data));
2751   
2752   switch (offset & 0x7fff)
2753   {
2754      case 0x0000:
2755         prg8_89(space->machine, data);
2756         break;
2757         
2758      case 0x1001:
2759         set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
2760         break;
2761         
2762      case 0x1003:
2763         state->IRQ_enable = data & 0x80;
2764         break;
2765         
2766      case 0x1004:
2767         state->IRQ_count = state->IRQ_count_latch;
2768         break;
2769         
2770      case 0x1005:
2771         state->IRQ_count_latch = (state->IRQ_count_latch & 0x00ff) | (data << 8);
2772         break;
2773         
2774      case 0x1006:
2775         state->IRQ_count_latch = (state->IRQ_count_latch & 0xff00) | data;
2776         break;
2777         
2778      case 0x2000:
2779         prg8_ab(space->machine, data);
2780         break;
2781         
2782      case 0x3000: case 0x3001: case 0x3002: case 0x3003:
2783      case 0x3004: case 0x3005: case 0x3006: case 0x3007:
2784         chr1_x(space->machine, offset & 0x07, data, CHRROM);
2785         break;
2786         
2787      case 0x4000:
2788         prg8_cd(space->machine, data);
2789         break;
2790         
2791      default:
2792         break;
2793   }
2794}
2795
2796/*************************************************************
2797 
2798 Jaleco SS88006 board emulation, aka JF-27, JF-29, JF-30, ...,
2799 JF-38, JF-40, JF-41
2800 
2801 iNES: mapper 18
2802 
2803 *************************************************************/
2804
2805/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
2806 we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
2807 there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
2808static void ss88006_irq( running_device *device, int scanline, int vblank, int blanked )
2809{
2810   nes_state *state = (nes_state *)device->machine->driver_data;
2811   
2812   /* Increment & check the IRQ scanline counter */
2813   if (state->IRQ_enable)
2814   {
2815      LOG_MMC(("scanline: %d, irq count: %04x\n", scanline, state->IRQ_count));
2816      if (state->IRQ_mode & 0x08)
2817      {
2818         if ((state->IRQ_count & 0x000f) < 114)   // always true, but we only update the IRQ once per scanlines so we cannot be more precise :(
2819         {
2820            cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
2821            state->IRQ_count = (state->IRQ_count & ~0x000f) | (0x0f - (114 & 0x0f) + (state->IRQ_count & 0x000f)); // sort of wrap around the counter
2822         }
2823         // decrements should not affect upper bits, so we don't do anything here (114 > 0x0f)
2824      }
2825      else if (state->IRQ_mode & 0x04)
2826      {
2827         if ((state->IRQ_count & 0x00ff) < 114)
2828         {
2829            cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
2830            state->IRQ_count = (state->IRQ_count & ~0x00ff) | (0xff - 114 + (state->IRQ_count & 0x00ff));   // wrap around the 8 bits counter
2831         }
2832         else
2833            state->IRQ_count -= 114;
2834      }
2835      else if (state->IRQ_mode & 0x02)
2836      {
2837         if ((state->IRQ_count & 0x0fff)  < 114)
2838         {
2839            cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
2840            state->IRQ_count = (state->IRQ_count & ~0x0fff) | (0xfff - 114 + (state->IRQ_count & 0x0fff));   // wrap around the 12 bits counter
2841         }
2842         else
2843            state->IRQ_count -= 114;
2844      }
2845      else if (state->IRQ_count < 114)
2846      {
2847         cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
2848         state->IRQ_count = (0xffff - 114 + state->IRQ_count);   // wrap around the 16 bits counter
2849      }
2850      else
2851         state->IRQ_count -= 114;
2852   }
2853}
2854
2855static WRITE8_HANDLER( ss88006_w )
2856{
2857   nes_state *state = (nes_state *)space->machine->driver_data;
2858   UINT8 bank;
2859   LOG_MMC(("mapper18_w, offset: %04x, data: %02x\n", offset, data));
2860   
2861   switch (offset & 0x7003)
2862   {
2863      case 0x0000:
2864         state->mmc_prg_bank[0] = (state->mmc_prg_bank[0] & 0xf0) | (data & 0x0f);
2865         prg8_89(space->machine, state->mmc_prg_bank[0]);
2866         break;
2867      case 0x0001:
2868         state->mmc_prg_bank[0] = (state->mmc_prg_bank[0] & 0x0f) | (data << 4);
2869         prg8_89(space->machine, state->mmc_prg_bank[0]);
2870         break;
2871      case 0x0002:
2872         state->mmc_prg_bank[1] = (state->mmc_prg_bank[1] & 0xf0) | (data & 0x0f);
2873         prg8_ab(space->machine, state->mmc_prg_bank[1]);
2874         break;
2875      case 0x0003:
2876         state->mmc_prg_bank[1] = (state->mmc_prg_bank[1] & 0x0f) | (data << 4);
2877         prg8_ab(space->machine, state->mmc_prg_bank[1]);
2878         break;
2879      case 0x1000:
2880         state->mmc_prg_bank[2] = (state->mmc_prg_bank[2] & 0xf0) | (data & 0x0f);
2881         prg8_cd(space->machine, state->mmc_prg_bank[2]);
2882         break;
2883      case 0x1001:
2884         state->mmc_prg_bank[2] = (state->mmc_prg_bank[2] & 0x0f) | (data << 4);
2885         prg8_cd(space->machine, state->mmc_prg_bank[2]);
2886         break;
2887         
2888         /* $9002, 3 (1002, 3) uncaught = Jaleco Baseball writes 0 */
2889         /* believe it's related to battery-backed ram enable/disable */
2890         
2891      case 0x2000: case 0x2001: case 0x2002: case 0x2003:
2892      case 0x3000: case 0x3001: case 0x3002: case 0x3003:
2893      case 0x4000: case 0x4001: case 0x4002: case 0x4003:
2894      case 0x5000: case 0x5001: case 0x5002: case 0x5003:
2895         bank = ((offset & 0x7000) - 0x2000) / 0x0800 + ((offset & 0x0002) >> 1);
2896         if (offset & 0x0001)
2897            state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0x0f) | ((data & 0x0f)<< 4);
2898         else
2899            state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0xf0) | (data & 0x0f);
2900         
2901         chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
2902         break;
2903         
2904      case 0x6000:
2905         state->IRQ_count_latch = (state->IRQ_count_latch & 0xfff0) | (data & 0x0f);
2906         break;
2907      case 0x6001:
2908         state->IRQ_count_latch = (state->IRQ_count_latch & 0xff0f) | ((data & 0x0f) << 4);
2909         break;
2910      case 0x6002:
2911         state->IRQ_count_latch = (state->IRQ_count_latch & 0xf0ff) | ((data & 0x0f) << 8);
2912         break;
2913      case 0x6003:
2914         state->IRQ_count_latch = (state->IRQ_count_latch & 0x0fff) | ((data & 0x0f) << 12);
2915         break;
2916         
2917      case 0x7000:
2918         state->IRQ_count = state->IRQ_count_latch;
2919         break;
2920      case 0x7001:
2921         state->IRQ_enable = data & 0x01;
2922         state->IRQ_mode = data & 0x0e;
2923         break;
2924         
2925      case 0x7002:
2926         switch (data & 0x03)
2927         {
2928         case 0: set_nt_mirroring(space->machine, PPU_MIRROR_HORZ); break;
2929         case 1: set_nt_mirroring(space->machine, PPU_MIRROR_VERT); break;
2930         case 2: set_nt_mirroring(space->machine, PPU_MIRROR_LOW); break;
2931         case 3: set_nt_mirroring(space->machine, PPU_MIRROR_HIGH); break;
2932         }
2933         break;
2934         
2935      default:
2936         logerror("Jaleco SS88006 uncaught write, addr: %04x, value: %02x\n", offset + 0x8000, data);
2937         break;
2938   }
2939}
2940
2941/*************************************************************
2942 
2943 Jaleco JF-11, JF-12 & JF-14 boards emulation
2944 
2945 iNES: mapper 140
2946 
2947 *************************************************************/
2948
2949static WRITE8_HANDLER( jf11_m_w )
2950{
2951   LOG_MMC(("jf11_m_w, offset: %04x, data: %02x\n", offset, data));
2952   chr8(space->machine, data, CHRROM);
2953   prg32(space->machine, data >> 4);
2954}
2955
2956/*************************************************************
2957 
2958 Jaleco JF-13 board emulation
2959 
2960 Note: we don't emulate the additional sound hardware.
2961
2962 iNES: mapper 86
2963 
2964 *************************************************************/
2965
2966static WRITE8_HANDLER( jf13_m_w )
2967{
2968   LOG_MMC(("jf13_m_w, offset: %04x, data: %02x\n", offset, data));
2969   
2970   if (offset == 0)
2971   {
2972      prg32(space->machine, (data >> 4) & 0x03);
2973      chr8(space->machine, ((data >> 4) & 0x04) | (data & 0x03), CHRROM);
2974   }
2975
2976   if (offset == 0x1000)
2977   {
2978      LOG_MMC(("Jaleco JF-13 sound write, data: %02x\n", data));
2979      // according to NEStopia, this is the effect
2980      if ((data & 0x30) == 0x20)
2981      {
2982         // send command (data & 0x1f) to sound chip
2983      }
2984   }
2985}
2986
2987/*************************************************************
2988 
2989 Jaleco JF-16 board emulation
2990 
2991 iNES: mapper 78 (shared with a diff Irem board)
2992 
2993 *************************************************************/
2994
2995static WRITE8_HANDLER( jf16_w )
2996{
2997   LOG_MMC(("jf16_w, offset: %04x, data: %02x\n", offset, data));
2998
2999   set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
3000   chr8(space->machine, data >> 4, CHRROM);
3001   prg16_89ab(space->machine, data);
3002}
3003
3004/*************************************************************
3005 
3006 Jaleco JF-17, JF-26 & JF-28 boards emulation
3007 
3008 Note: we don't emulate the additional sound hardware.
3009
3010 iNES: mapper 72
3011 
3012 *************************************************************/
3013
3014static WRITE8_HANDLER( jf17_w )
3015{
3016   LOG_MMC(("jf17_w, offset: %04x, data: %02x\n", offset, data));
3017
3018   if (BIT(data, 7))
3019      prg16_89ab(space->machine, data & 0x0f);
3020   if (BIT(data, 6))
3021      chr8(space->machine, data & 0x0f, CHRROM);
3022   if (BIT(data, 5) && !BIT(data,4))
3023      LOG_MMC(("Jaleco JF-17 sound write, data: %02x\n", data & 0x1f));
3024}
3025
3026/*************************************************************
3027 
3028 Jaleco JF-19 & JF-21 boards emulation
3029 
3030 Note: we don't emulate the additional sound hardware.
3031 
3032 iNES: mapper 92
3033 
3034 *************************************************************/
3035
3036static WRITE8_HANDLER( jf19_w )
3037{
3038   LOG_MMC(("jf19_w, offset: %04x, data: %02x\n", offset, data));
3039
3040   if (BIT(data, 7))
3041      prg16_cdef(space->machine, data & 0x0f);
3042   if (BIT(data, 6))
3043      chr8(space->machine, data & 0x0f, CHRROM);
3044   if (BIT(data, 5) && !BIT(data,4))
3045      LOG_MMC(("Jaleco JF-17 sound write, data: %02x\n", data & 0x1f));
3046}
3047
3048/*************************************************************
3049 
3050 Konami VRC1 and Jaleco JF20, JF22
3051
3052 Games: Exciting Boxing, Ganbare Goemon!, Tetsuwan Atom
3053 
3054 iNES: mapper 75
3055 
3056 In MESS: Supported.
3057 
3058 *************************************************************/
3059
3060static WRITE8_HANDLER( konami_vrc1_w )
3061{
3062   nes_state *state = (nes_state *)space->machine->driver_data;
3063   LOG_MMC(("konami_vrc1_w, offset: %04x, data: %02x\n", offset, data));
3064   
3065   switch (offset & 0x7000)
3066   {
3067      case 0x0000:
3068         prg8_89(space->machine, data);
3069         break;
3070      case 0x1000:
3071         set_nt_mirroring(space->machine, (data & 0x01) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
3072         state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & 0x0f) | ((data & 0x02) << 3);
3073         state->mmc_vrom_bank[1] = (state->mmc_vrom_bank[1] & 0x0f) | ((data & 0x04) << 2);
3074         chr4_0(space->machine, state->mmc_vrom_bank[0], CHRROM);
3075         chr4_4(space->machine, state->mmc_vrom_bank[1], CHRROM);
3076         break;
3077      case 0x2000:
3078         prg8_ab(space->machine, data);
3079         break;
3080      case 0x4000:
3081         prg8_cd(space->machine, data);
3082         break;
3083      case 0x6000:
3084         state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & 0x10) | (data & 0x0f);
3085         chr4_0(space->machine, state->mmc_vrom_bank[0], CHRROM);
3086         break;
3087      case 0x7000:
3088         state->mmc_vrom_bank[1] = (state->mmc_vrom_bank[1] & 0x10) | (data & 0x0f);
3089         chr4_4(space->machine, state->mmc_vrom_bank[1], CHRROM);
3090         break;
3091   }
3092}
3093
3094/*************************************************************
3095 
3096 Konami VRC3
3097
3098 Games: Salamander
3099 
3100 iNES: mapper 73
3101 
3102 In MESS: Supported. It also uses konami_irq.
3103 
3104 *************************************************************/
3105
3106static WRITE8_HANDLER( konami_vrc3_w )
3107{
3108   LOG_MMC(("konami_vrc3_w, offset: %04x, data: %02x\n", offset, data));
3109   nes_state *state = (nes_state *)space->machine->driver_data;
3110   
3111   switch (offset & 0x7000)
3112   {
3113      case 0x0000:
3114      case 0x1000:
3115         /* dunno which address controls these */
3116         state->IRQ_count_latch = data;
3117         state->IRQ_enable_latch = data;
3118         break;
3119      case 0x2000:
3120         state->IRQ_enable = data;
3121         break;
3122      case 0x3000:
3123         state->IRQ_count &= ~0x0f;
3124         state->IRQ_count |= data & 0x0f;
3125         break;
3126      case 0x4000:
3127         state->IRQ_count &= ~0xf0;
3128         state->IRQ_count |= (data & 0x0f) << 4;
3129         break;
3130      case 0x7000:
3131         prg16_89ab(space->machine, data);
3132         break;
3133      default:
3134         logerror("konami_vrc3_w uncaught write, offset %04x, data: %02x\n", offset, data);
3135         break;
3136   }
3137}
3138
3139/*************************************************************
3140 
3141 Konami VRC7
3142
3143 Games: Lagrange Point, Tiny Toon Adventures 2
3144 
3145 iNES: mapper 85
3146 
3147 In MESS: Supported. It also uses konami_irq.
3148 
3149 *************************************************************/
3150
3151#if 0
3152static WRITE8_HANDLER( konami_vrc7_w )
3153{
3154   nes_state *state = (nes_state *)space->machine->driver_data;
3155   UINT8 bank;
3156   LOG_MMC(("konami_vrc7_w, offset: %04x, data: %02x\n", offset, data));
3157   
3158   switch (offset & 0x7018)
3159   {
3160      case 0x0000:
3161         prg8_89(space->machine, data);
3162         break;
3163      case 0x0008:
3164      case 0x0010:
3165      case 0x0018:
3166         prg8_ab(space->machine, data);
3167         break;
3168         
3169      case 0x1000:
3170         prg8_cd(space->machine, data);
3171         break;
3172         
3173         /* TODO: there are sound regs in here */
3174         
3175      case 0x2000:
3176      case 0x2008:
3177      case 0x2010:
3178      case 0x2018:
3179      case 0x3000:
3180      case 0x3008:
3181      case 0x3010:
3182      case 0x3018:
3183      case 0x4000:
3184      case 0x4008:
3185      case 0x4010:
3186      case 0x4018:
3187      case 0x5000:
3188      case 0x5008:
3189      case 0x5010:
3190      case 0x5018:
3191         bank = ((offset & 0x7000) - 0x2000) / 0x0800 + ((offset & 0x0018) ? 1 : 0);
3192         chr1_x(space->machine, bank, data, state->mmc_chr_source);
3193         break;
3194         
3195      case 0x6000:
3196         switch (data & 0x03)
3197      {
3198         case 0x00: set_nt_mirroring(space->machine, PPU_MIRROR_VERT); break;
3199         case 0x01: set_nt_mirroring(space->machine, PPU_MIRROR_HORZ); break;
3200         case 0x02: set_nt_mirroring(space->machine, PPU_MIRROR_LOW); break;
3201         case 0x03: set_nt_mirroring(space->machine, PPU_MIRROR_HIGH); break;
3202      }
3203         break;
3204      case 0x6008: case 0x6010: case 0x6018:
3205         state->IRQ_count_latch = data;
3206         break;
3207      case 0x7000:
3208         state->IRQ_mode = data & 0x04;   // currently not implemented: 0 = prescaler mode / 1 = CPU mode
3209         state->IRQ_enable = data & 0x02;
3210         state->IRQ_enable_latch = data & 0x01;
3211         if (data & 0x02)
3212            state->IRQ_count = state->IRQ_count_latch;
3213         break;
3214      case 0x7008: case 0x7010: case 0x7018:
3215         state->IRQ_enable = state->IRQ_enable_latch;
3216         break;
3217         
3218      default:
3219         logerror("konami_vrc7_w uncaught write, addr: %04x value: %02x\n", offset + 0x8000, data);
3220         break;
3221   }
3222}
3223
3224#endif
3225/*************************************************************
3226 
3227 Namcot-163 board emulation
3228 
3229 iNES: mapper 19
3230 
3231 *************************************************************/
3232
3233/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
3234 we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
3235 there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
3236static void namcot163_irq( running_device *device, int scanline, int vblank, int blanked )
3237{
3238   nes_state *state = (nes_state *)device->machine->driver_data;
3239   
3240   if (state->IRQ_enable)
3241   {
3242      if (state->IRQ_count >= (0x7fff - 114))
3243      {
3244         cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
3245         state->IRQ_count = 0;
3246      }
3247      else
3248         state->IRQ_count += 114;
3249   }
3250}
3251
3252static WRITE8_HANDLER( namcot163_l_w )
3253{
3254   nes_state *state = (nes_state *)space->machine->driver_data;
3255   LOG_MMC(("namcot163_l_w, offset: %04x, data: %02x\n", offset, data));
3256   offset += 0x100;
3257   
3258   switch (offset & 0x1800)
3259   {
3260      case 0x0800:
3261         LOG_MMC(("Namcot-163 sound reg write, data: %02x\n", data));
3262         break;
3263      case 0x1000: /* low byte of IRQ */
3264         state->IRQ_count = (state->IRQ_count & 0x7f00) | data;
3265         break;
3266      case 0x1800: /* high byte of IRQ, IRQ enable in high bit */
3267         state->IRQ_count = (state->IRQ_count & 0xff) | ((data & 0x7f) << 8);
3268         state->IRQ_enable = data & 0x80;
3269         break;
3270   }
3271}
3272
3273static READ8_HANDLER( namcot163_l_r )
3274{
3275   nes_state *state = (nes_state *)space->machine->driver_data;
3276   LOG_MMC(("namcot163_l_r, offset: %04x\n", offset));
3277   offset += 0x100;
3278   
3279   switch (offset & 0x1800)
3280   {
3281      case 0x1000:
3282         return state->IRQ_count & 0xff;
3283      case 0x1800:
3284         return (state->IRQ_count >> 8) & 0xff;
3285      case 0x0800:
3286         LOG_MMC(("Namcot-163 sound reg read\n"));
3287      default:
3288         return 0x00;
3289   }
3290}
3291
3292static void namcot163_set_mirror( running_machine *machine, UINT8 page, UINT8 data )
3293{
3294   if (!(data < 0xe0))
3295      set_nt_page(machine, page, CIRAM, data & 0x01, 1);
3296   else
3297      set_nt_page(machine, page, ROM, data, 0);
3298}
3299
3300static WRITE8_HANDLER( namcot163_w )
3301{
3302   nes_state *state = (nes_state *)space->machine->driver_data;
3303   LOG_MMC(("namcot163_w, offset: %04x, data: %02x\n", offset, data));
3304   switch (offset & 0x7800)
3305   {
3306      case 0x0000: case 0x0800:
3307      case 0x1000: case 0x1800:
3308      case 0x2000: case 0x2800:
3309      case 0x3000: case 0x3800:
3310         chr1_x(space->machine, offset / 0x800, data, CHRROM);
3311         break;
3312      case 0x4000:
3313         namcot163_set_mirror(space->machine, 0, data);
3314         break;
3315      case 0x4800:
3316         namcot163_set_mirror(space->machine, 1, data);
3317         break;
3318      case 0x5000:
3319         namcot163_set_mirror(space->machine, 2, data);
3320         break;
3321      case 0x5800:
3322         namcot163_set_mirror(space->machine, 3, data);
3323         break;
3324      case 0x6000:
3325         prg8_89(space->machine, data & 0x3f);
3326         break;
3327      case 0x6800:
3328         state->mmc_latch1 = data & 0xc0;      // this should enable High CHRRAM, but we still have to properly implement it!
3329         prg8_ab(space->machine, data & 0x3f);
3330         break;
3331      case 0x7000:
3332         prg8_cd(space->machine, data & 0x3f);
3333         break;
3334      case 0x7800:
3335         LOG_MMC(("Namcot-163 sound address write, data: %02x\n", data));
3336         break;
3337   }
3338}
3339
3340/*************************************************************
3341 
3342 Sunsoft-1 board emulation
3343 
3344 iNES: mapper 184
3345 
3346 *************************************************************/
3347
3348static WRITE8_HANDLER( sunsoft1_m_w )
3349{
3350   LOG_MMC(("sunsoft1_m_w, offset: %04x, data: %02x\n", offset, data));
3351   
3352   chr4_0(space->machine, data & 0x0f, CHRROM);
3353   chr4_4(space->machine, data >> 4, CHRROM);
3354}
3355
3356/*************************************************************
3357 
3358 Sunsoft-2 board emulation
3359 
3360 The two games using this board have incompatible mirroring
3361 wiring, making necessary two distinct mappers & pcb_id
3362 
3363 iNES: mapper 89 & 93
3364 
3365 *************************************************************/
3366
3367static WRITE8_HANDLER( sunsoft2a_w )
3368{
3369   UINT8 sunsoft_helper = (data & 0x07) | ((data & 0x80) ? 0x08 : 0x00);
3370   LOG_MMC(("mapper93_w, offset: %04x, data: %02x\n", offset, data));
3371   
3372   prg16_89ab(space->machine, data >> 4);
3373   chr8(space->machine, sunsoft_helper, CHRROM);
3374}
3375
3376static WRITE8_HANDLER( sunsoft2b_w )
3377{
3378   LOG_MMC(("mapper89_m_w, offset: %04x, data: %02x\n", offset, data));
3379
3380   set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
3381   sunsoft2a_w(space, offset, data);
3382}
3383
3384/*************************************************************
3385 
3386 Sunsoft-3 board emulation
3387 
3388 The two games using this board have incompatible mirroring
3389 wiring, making necessary two distinct mappers & pcb_id
3390 
3391 iNES: mapper 67
3392 
3393 *************************************************************/
3394
3395/* Here, IRQ counter decrements every CPU cycle. Since we update it every scanline,
3396 we need to decrement it by 114 (Each scanline consists of 341 dots and, on NTSC,
3397 there are 3 dots to every 1 CPU cycle, hence 114 is the number of cycles per scanline ) */
3398static void sunsoft3_irq( running_device *device, int scanline, int vblank, int blanked )
3399{
3400   nes_state *state = (nes_state *)device->machine->driver_data;
3401   
3402   /* TODO: change to reflect the actual number of cycles spent: both using 114 or cycling 114,114,113
3403    produces a 1-line glitch in Fantasy Zone 2: it really requires the counter to be updated each CPU cycle! */
3404   if (state->IRQ_enable)
3405   {
3406      if (state->IRQ_count <= 114)
3407      {
3408         state->IRQ_enable = 0;
3409         state->IRQ_count = 0xffff;
3410         cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
3411      }
3412      else
3413         state->IRQ_count -= 114;
3414   }
3415}
3416
3417static WRITE8_HANDLER( sunsoft3_w )
3418{
3419   nes_state *state = (nes_state *)space->machine->driver_data;
3420   LOG_MMC(("sunsoft3_w, offset %04x, data: %02x\n", offset, data));
3421   
3422   switch (offset & 0x7800)
3423   {
3424      case 0x0800:
3425         chr2_0(space->machine, data, CHRROM);
3426         break;
3427      case 0x1800:
3428         chr2_2(space->machine, data, CHRROM);
3429         break;
3430      case 0x2800:
3431         chr2_4(space->machine, data, CHRROM);
3432         break;
3433      case 0x3800:
3434         chr2_6(space->machine, data, CHRROM);
3435         break;
3436      case 0x4000:
3437      case 0x4800:
3438         state->IRQ_toggle ^= 1;
3439         if (state->IRQ_toggle)
3440            state->IRQ_count = (state->IRQ_count & 0x00ff) | (data << 8);
3441         else
3442            state->IRQ_count = (state->IRQ_count & 0xff00) | data;
3443         break;
3444      case 0x5800:
3445         state->IRQ_enable = BIT(data, 4);
3446         state->IRQ_toggle = 0;
3447         break;
3448      case 0x6800:
3449         switch (data & 3)
3450         {
3451         case 0x00: set_nt_mirroring(space->machine, PPU_MIRROR_VERT); break;
3452         case 0x01: set_nt_mirroring(space->machine, PPU_MIRROR_HORZ); break;
3453         case 0x02: set_nt_mirroring(space->machine, PPU_MIRROR_LOW); break;
3454         case 0x03: set_nt_mirroring(space->machine, PPU_MIRROR_HIGH); break;
3455         }
3456         break;
3457      case 0x7800:
3458         prg16_89ab(space->machine, data);
3459         break;
3460      default:
3461         LOG_MMC(("sunsoft3_w uncaught write, offset: %04x, data: %02x\n", offset, data));
3462         break;
3463   }
3464}
3465
3466/*************************************************************
3467 
3468 Taito TC0190FMC + board emulation
3469 
3470 iNES: mapper 33
3471 
3472 *************************************************************/
3473
3474static WRITE8_HANDLER( tc0190fmc_w )
3475{
3476   LOG_MMC(("tc0190fmc_w, offset: %04x, data: %02x\n", offset, data));
3477   
3478   switch (offset & 0x7003)
3479   {
3480      case 0x0000:
3481         set_nt_mirroring(space->machine, BIT(data, 6) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
3482         prg8_89(space->machine, data);
3483         break;
3484      case 0x0001:
3485         prg8_ab(space->machine, data);
3486         break;
3487      case 0x0002:
3488         chr2_0(space->machine, data, CHRROM);
3489         break;
3490      case 0x0003:
3491         chr2_2(space->machine, data, CHRROM);
3492         break;
3493      case 0x2000:
3494         chr1_4(space->machine, data, CHRROM);
3495         break;
3496      case 0x2001:
3497         chr1_5(space->machine, data, CHRROM);
3498         break;
3499      case 0x2002:
3500         chr1_6(space->machine, data, CHRROM);
3501         break;
3502      case 0x2003:
3503         chr1_7(space->machine, data, CHRROM);
3504         break;
3505   }
3506}
3507
3508/*************************************************************
3509 
3510 Taito TC0190FMC + PAL16R4 board emulation
3511 
3512 iNES: mapper 48
3513 
3514 *************************************************************/
3515
3516static WRITE8_HANDLER( tc0190fmc_p16_w )
3517{
3518   nes_state *state = (nes_state *)space->machine->driver_data;
3519   LOG_MMC(("tc0190fmc_p16_w, offset: %04x, data: %02x\n", offset, data));
3520   
3521   switch (offset & 0x7003)
3522   {
3523      case 0x0000:
3524         prg8_89(space->machine, data);
3525         break;
3526      case 0x0001:
3527      case 0x0002:
3528      case 0x0003:
3529      case 0x2000:
3530      case 0x2001:
3531      case 0x2002:
3532      case 0x2003:
3533         tc0190fmc_w(space, offset, data);
3534         break;
3535      case 0x4000:
3536         state->IRQ_count_latch = (0x100 - data) & 0xff;
3537         break;
3538      case 0x4001:
3539         state->IRQ_count = state->IRQ_count_latch;
3540         break;
3541      case 0x4002:
3542         state->IRQ_enable = 1;
3543         break;
3544      case 0x4003:
3545         state->IRQ_enable = 0;
3546         break;
3547      case 0x6000:
3548         set_nt_mirroring(space->machine, BIT(data, 6) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
3549         break;
3550   }
3551}
3552
3553/*************************************************************
3554 
3555 Taito X1-005 board emulation
3556 
3557 Actually, Fudou Myouou Den uses a variant of the board with
3558 CIRAM, making necessary two distinct mappers & pcb_id.
3559 
3560 Also, we miss to emulate the security check at 0x7ef8 / 0x7ef9
3561 and the 0x80 ram!
3562 
3563 iNES: mappers 80 & 207
3564 
3565 *************************************************************/
3566
3567static WRITE8_HANDLER( x1005_m_w )
3568{
3569   LOG_MMC(("x1005_m_w, offset: %04x, data: %02x\n", offset, data));
3570   
3571   switch (offset)
3572   {
3573      case 0x1ef0:
3574         chr2_0(space->machine, (data & 0x7f) >> 1, CHRROM);
3575         break;
3576      case 0x1ef1:
3577         chr2_2(space->machine, (data & 0x7f) >> 1, CHRROM);
3578         break;
3579      case 0x1ef2:
3580         chr1_4(space->machine, data, CHRROM);
3581         break;
3582      case 0x1ef3:
3583         chr1_5(space->machine, data, CHRROM);
3584         break;
3585      case 0x1ef4:
3586         chr1_6(space->machine, data, CHRROM);
3587         break;
3588      case 0x1ef5:
3589         chr1_7(space->machine, data, CHRROM);
3590         break;
3591      case 0x1ef6:
3592      case 0x1ef7:
3593         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_VERT : PPU_MIRROR_HORZ);
3594         break;
3595      case 0x1efa:
3596      case 0x1efb:
3597         prg8_89(space->machine, data);
3598         break;
3599      case 0x1efc:
3600      case 0x1efd:
3601         prg8_ab(space->machine, data);
3602         break;
3603      case 0x1efe:
3604      case 0x1eff:
3605         prg8_cd(space->machine, data);
3606         break;
3607      default:
3608         logerror("mapper80_m_w uncaught addr: %04x, value: %02x\n", offset + 0x6000, data);
3609         break;
3610   }
3611}
3612
3613static WRITE8_HANDLER( x1005a_m_w )
3614{
3615   LOG_MMC(("x1005a_m_w, offset: %04x, data: %02x\n", offset, data));
3616   
3617   switch (offset)
3618   {
3619      case 0x1ef0:
3620         set_nt_page(space->machine, 0, CIRAM, (data & 0x80) ? 1 : 0, 1);
3621         set_nt_page(space->machine, 1, CIRAM, (data & 0x80) ? 1 : 0, 1);
3622         chr2_0(space->machine, (data & 0x7f) >> 1, CHRROM);
3623         break;
3624      case 0x1ef1:
3625         set_nt_page(space->machine, 2, CIRAM, (data & 0x80) ? 1 : 0, 1);
3626         set_nt_page(space->machine, 3, CIRAM, (data & 0x80) ? 1 : 0, 1);
3627         chr2_2(space->machine, (data & 0x7f) >> 1, CHRROM);
3628         break;
3629      case 0x1ef2:
3630         chr1_4(space->machine, data, CHRROM);
3631         break;
3632      case 0x1ef3:
3633         chr1_5(space->machine, data, CHRROM);
3634         break;
3635      case 0x1ef4:
3636         chr1_6(space->machine, data, CHRROM);
3637         break;
3638      case 0x1ef5:
3639         chr1_7(space->machine, data, CHRROM);
3640         break;
3641      case 0x1efa:
3642      case 0x1efb:
3643         prg8_89(space->machine, data);
3644         break;
3645      case 0x1efc:
3646      case 0x1efd:
3647         prg8_ab(space->machine, data);
3648         break;
3649      case 0x1efe:
3650      case 0x1eff:
3651         prg8_cd(space->machine, data);
3652         break;
3653      default:
3654         logerror("x1005a_m_w uncaught write, addr: %04x, value: %02x\n", offset + 0x6000, data);
3655         break;
3656   }
3657}
3658
3659/*************************************************************
3660 
3661 Taito X1-017 board emulation
3662 
3663 Actually, Fudou Myouou Den uses a variant of the board with
3664 CIRAM, making necessary two distinct mappers & pcb_id.
3665 
3666 Also, we miss to emulate the security check at 0x6000-0x73ff
3667 and the ram!
3668 
3669 iNES: mapper 82
3670 
3671 *************************************************************/
3672
3673static void x1017_set_chr( running_machine *machine )
3674{
3675   nes_state *state = (nes_state *)machine->driver_data;
3676   if (state->mmc_latch1)
3677   {
3678      chr2_4(machine, state->mmc_vrom_bank[0] >> 1, CHRROM);
3679      chr2_6(machine, state->mmc_vrom_bank[1] >> 1, CHRROM);
3680   }
3681   else
3682   {
3683      chr2_0(machine, state->mmc_vrom_bank[0] >> 1, CHRROM);
3684      chr2_2(machine, state->mmc_vrom_bank[1] >> 1, CHRROM);
3685   }
3686   chr1_x(machine, 4 ^ state->mmc_latch1, state->mmc_vrom_bank[2], CHRROM);
3687   chr1_x(machine, 5 ^ state->mmc_latch1, state->mmc_vrom_bank[3], CHRROM);
3688   chr1_x(machine, 6 ^ state->mmc_latch1, state->mmc_vrom_bank[4], CHRROM);
3689   chr1_x(machine, 7 ^ state->mmc_latch1, state->mmc_vrom_bank[5], CHRROM);
3690}   
3691
3692static WRITE8_HANDLER( x1017_m_w )
3693{
3694   nes_state *state = (nes_state *)space->machine->driver_data;
3695   UINT8 reg = offset & 0x07;
3696   LOG_MMC(("x1017_m_w, offset: %04x, data: %02x\n", offset, data));
3697   
3698   switch (offset)
3699   {
3700      case 0x1ef0:
3701      case 0x1ef1:
3702         if (state->mmc_vrom_bank[reg] != data)
3703         {
3704            state->mmc_vrom_bank[reg] = data;
3705            x1017_set_chr(space->machine);
3706         }
3707         break;
3708      case 0x1ef2:
3709      case 0x1ef3:
3710      case 0x1ef4:
3711      case 0x1ef5:
3712         if (state->mmc_vrom_bank[reg] != data)
3713         {
3714            state->mmc_vrom_bank[reg] = data;
3715            x1017_set_chr(space->machine);
3716         }
3717         break;
3718      case 0x1ef6:
3719         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_VERT : PPU_MIRROR_HORZ);
3720         state->mmc_latch1 = ((data & 0x02) << 1);
3721         x1017_set_chr(space->machine);
3722         break;
3723      case 0x1efa:
3724         prg8_89(space->machine, data >> 2);
3725         break;
3726      case 0x1efb:
3727         prg8_ab(space->machine, data >> 2);
3728         break;
3729      case 0x1efc:
3730         prg8_cd(space->machine, data >> 2);
3731         break;
3732      default:
3733         logerror("x1017_m_w uncaught write, addr: %04x, value: %02x\n", offset + 0x6000, data);
3734         break;
3735   }
3736}
3737
3738/*************************************************************
3739 
3740      MISC UNLICENSED BOARDS
3741 
3742 *************************************************************/
3743
3744/*************************************************************
3745 
3746 AGCI 50282 bootleg board emulation
3747 
3748 iNES: mapper 144
3749 
3750 *************************************************************/
3751
3752static WRITE8_HANDLER( agci_50282_w )
3753{
3754   LOG_MMC(("agci_50282_w, offset: %04x, data: %02x\n", offset, data));
3755   
3756   data |= (memory_read_byte(space, offset) & 1);
3757   
3758   chr8(space->machine, data >> 4, CHRROM);
3759   prg32(space->machine, data);
3760}
3761
3762/*************************************************************
3763 
3764 AVE NINA-001 board emulation
3765 
21753766 iNES: mapper 34
21763767 
21773768 *************************************************************/
21783769
21793770static WRITE8_HANDLER( nina01_m_w )
21803771{
2181   LOG_MMC(("mapper34_m_w, offset: %04x, data: %02x\n", offset, data));
3772   LOG_MMC(("nina01_m_w, offset: %04x, data: %02x\n", offset, data));
21823773   
21833774   switch (offset)
21843775   {
r8270r8271
21943785   }
21953786}
21963787
3788/*************************************************************
3789 
3790 AVE NINA-003, NINA-006 and MB-91 boards emulation
3791 
3792 iNES: mapper 79
3793 
3794 *************************************************************/
21973795
3796static WRITE8_HANDLER( nina06_l_w )
3797{
3798   LOG_MMC(("nina06_l_w, offset: %04x, data: %02x\n", offset, data));
3799   
3800   if (!(offset & 0x0100))
3801   {
3802      prg32(space->machine, data >> 3);
3803      chr8(space->machine, data, CHRROM);
3804   }
3805}
3806
3807/*************************************************************
3808 
3809 Active Entertainment Action 52 board emulation
3810 
3811 iNES: mapper 228
3812 
3813 *************************************************************/
3814
3815static WRITE8_HANDLER( ae_act52_w )
3816{
3817   nes_state *state = (nes_state *)space->machine->driver_data;
3818   int pbank, pchip, cbank;
3819   UINT8 pmode;
3820   LOG_MMC(("mapper228_w, offset: %04x, data: %02x\n", offset, data));
3821   
3822   set_nt_mirroring(space->machine, (offset & 0x2000) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
3823   
3824   cbank = (data & 0x03) | ((offset & 0x0f) << 2);
3825   chr8(space->machine, cbank, CHRROM);
3826   
3827   pbank = (offset & 0x7c0) >> 6;
3828   pchip = (offset & 0x1800) >> 11;
3829   pmode = offset & 0x20;
3830
3831   if (!state->crc_hack)
3832      pbank += (0x10 * pchip);
3833   else   // FIXME: iNES loading for this mapper should be fixed as well to have the last bank at the correct offset)
3834   {
3835      switch (pchip)
3836      {
3837      case 0: break;         // we are already at the correct bank
3838      case 1: pbank += 0x10; break;   // chip 1 starts at block 16
3839      case 2: break;         // chip 2 was an empty socket
3840      case 3: pbank += 0x20; break;   // chip 3 starts at block 32
3841      }
3842   }
3843   
3844   if (pmode)
3845   {
3846      prg16_89ab(space->machine, pbank);
3847      prg16_cdef(space->machine, pbank);
3848   }
3849   else
3850      prg32(space->machine, pbank >> 1);
3851}
3852
3853
3854/*************************************************************
3855 
3856 C & E Bootleg Board for Decathlon
3857 
3858 Games: Decathlon
3859 
3860 Pretty simple mapper: writes to 0x8065-0x80a4 set prg32 to
3861 data & 3; writes to 0x80a5-0x80e4 set chr8 to data & 7
3862 
3863 iNES: mapper 244
3864 
3865 In MESS: Supported.
3866 
3867 *************************************************************/
3868
3869static WRITE8_HANDLER( cne_decathl_w )
3870{
3871   LOG_MMC(("cne_decathl_w, offset: %04x, data: %02x\n", offset, data));
3872   
3873   if (offset < 0x0065)
3874      return;
3875   if (offset < 0x00a5)
3876   {
3877      prg32(space->machine, (offset - 0x0065) & 0x03);
3878      return;
3879   }
3880   if (offset < 0x00e5)
3881   {
3882      chr8(space->machine, (offset - 0x00a5) & 0x07, CHRROM);
3883   }
3884}
3885
3886/*************************************************************
3887 
3888 C & E Bootleg Board for Fong Shen Bang
3889 
3890 Games: Fong Shen Bang - Zhu Lu Zhi Zhan
3891 
3892 Simple mapper: writes to 0x6000-0x67ff set PRG and CHR banks.
3893 Namely, 0x6000->0x6003 select resp. prg8_89, prg8_ab, prg8_cd
3894 and prg8_ef. 0x6004->0x6007 select resp. crh2_0, chr2_2,
3895 chr2_4 and chr2_6. In 0x6800-0x7fff lies WRAM.
3896 
3897 iNES: mapper 246
3898 
3899 In MESS: Supported.
3900 
3901 *************************************************************/
3902
3903static WRITE8_HANDLER( cne_fsb_m_w )
3904{
3905   nes_state *state = (nes_state *)space->machine->driver_data;
3906   LOG_MMC(("cne_fsb_m_w, offset: %04x, data: %02x\n", offset, data));
3907   
3908   if (offset < 0x0800)
3909   {
3910      switch (offset & 0x0007)
3911      {
3912         case 0x0000:
3913            prg8_89(space->machine, data);
3914            break;
3915         case 0x0001:
3916            prg8_ab(space->machine, data);
3917            break;
3918         case 0x0002:
3919            prg8_cd(space->machine, data);
3920            break;
3921         case 0x0003:
3922            prg8_ef(space->machine, data);
3923            break;
3924         case 0x0004:
3925            chr2_0(space->machine, data, CHRROM);
3926            break;
3927         case 0x0005:
3928            chr2_2(space->machine, data, CHRROM);
3929            break;
3930         case 0x0006:
3931            chr2_4(space->machine, data, CHRROM);
3932            break;
3933         case 0x0007:
3934            chr2_6(space->machine, data, CHRROM);
3935            break;
3936      }
3937   }
3938   else
3939      state->wram[offset] = data;
3940}
3941
3942/*************************************************************
3943 
3944 C & E Bootleg Board for Sheng Huo Lie Zhuan
3945 
3946 Games: Jing Ke Xin Zhuan, Sheng Huo Lie Zhuan
3947 
3948 Simple Mapper: writes to 0x4020-0x5fff sets prg32 to
3949 data>>4 and chr8 to data&f. We currently do not map
3950 writes to 0x4020-0x40ff (to do: verify if this produces
3951 issues)
3952 
3953 iNES: mapper 240
3954 
3955 In MESS: Supported.
3956 
3957 *************************************************************/
3958
3959static WRITE8_HANDLER( cne_shlz_l_w )
3960{
3961   LOG_MMC(("cne_shlz_l_w, offset: %04x, data: %02x\n", offset, data));
3962   
3963   prg32(space->machine, data >> 4);
3964   chr8(space->machine, data & 0x0f, CHRROM);
3965}
3966
3967/*************************************************************
3968 
3969 Caltron 6 in 1 Board
3970
3971 Games: 6 in 1 by Caltron
3972 
3973 iNES: mapper 41
3974 
3975 In MESS: Supported.
3976 
3977 *************************************************************/
3978
3979static WRITE8_HANDLER( caltron6in1_m_w )
3980{
3981   nes_state *state = (nes_state *)space->machine->driver_data;
3982   LOG_MMC(("caltron6in1_m_w, offset: %04x, data: %02x\n", offset, data));
3983   
3984   state->mmc_latch1 = offset & 0xff;
3985   set_nt_mirroring(space->machine, BIT(data, 5) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
3986   prg32(space->machine, offset & 0x07);
3987}
3988
3989static WRITE8_HANDLER( caltron6in1_w )
3990{
3991   nes_state *state = (nes_state *)space->machine->driver_data;
3992   LOG_MMC(("caltron6in1_w, offset: %04x, data: %02x\n", offset, data));
3993   
3994   if (state->mmc_latch1 & 0x04)
3995      chr8(space->machine, ((state->mmc_latch1 & 0x18) >> 1) | (data & 0x03), CHRROM);
3996}
3997
3998/*************************************************************
3999 
4000 Camerica Boards (BF9093, BF9097, BF909X, ALGNV11)
4001
4002 Games: Linus Spacehead's Cosmic Crusade, Micro Machines,
4003 Mig-29, Stunt Kids
4004 
4005 To emulate NT mirroring for BF9097 board (missing in BF9093)
4006 we use crc_hack, however Fire Hawk is broken (but without
4007 mirroring there would be no helicopter graphics).
4008 
4009 iNES: mapper 71
4010 
4011 In MESS: Partially Supported.
4012 
4013 *************************************************************/
4014
4015static WRITE8_HANDLER( bf9093_w )
4016{
4017   LOG_MMC(("bf9093_w, offset: %04x, data: %02x\n", offset, data));
4018   
4019   switch (offset & 0x7000)
4020   {
4021      case 0x0000:
4022      case 0x1000:
4023         break;
4024      case 0x4000:
4025      case 0x5000:
4026      case 0x6000:
4027      case 0x7000:
4028         prg16_89ab(space->machine, data);
4029         break;
4030   }
4031}
4032
4033static WRITE8_HANDLER( bf9097_w )
4034{
4035   LOG_MMC(("bf9097_w, offset: %04x, data: %02x\n", offset, data));
4036   
4037   switch (offset & 0x7000)
4038   {
4039      case 0x0000:
4040      case 0x1000:
4041         set_nt_mirroring(space->machine, BIT(data, 4) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
4042         break;
4043      case 0x4000:
4044      case 0x5000:
4045      case 0x6000:
4046      case 0x7000:
4047         prg16_89ab(space->machine, data);
4048         break;
4049   }
4050}
4051
4052/*************************************************************
4053 
4054 Camerica BF9096 & ALGQV11 Boards
4055
4056 Games: Quattro Adventure, Quattro Arcade, Quattro Sports
4057 
4058 Writes to 0x8000-0x9fff set prg block to (data&0x18)>>1,
4059 writes to 0xa000-0xbfff set prg page to data&3. selected
4060 prg are: prg16_89ab = block|page, prg_cdef = 3|page.
4061 For more info on the hardware to bypass the NES lockout, see
4062 Kevtris' Camerica Mappers documentation.
4063 
4064 iNES: mapper 232
4065 
4066 In MESS: Supported.
4067 
4068 *************************************************************/
4069
4070static void bf9096_set_prg( running_machine *machine )
4071{
4072   nes_state *state = (nes_state *)machine->driver_data;
4073   prg16_89ab(machine, (state->mmc_latch2 & 0x03) | ((state->mmc_latch1 & 0x18) >> 1));
4074   prg16_cdef(machine, 0x03 | ((state->mmc_latch1 & 0x18) >> 1));
4075}
4076
4077static WRITE8_HANDLER( bf9096_w )
4078{
4079   nes_state *state = (nes_state *)space->machine->driver_data;
4080   LOG_MMC(("bf9096_w, offset: %04x, data: %02x\n", offset, data));
4081   
4082   if (offset < 0x2000)
4083      state->mmc_latch1 = data;
4084   else
4085      state->mmc_latch2 = data;
4086   
4087   bf9096_set_prg(space->machine);
4088}
4089
4090/*************************************************************
4091 
4092 Camerica Golden Five board
4093
4094 Games: Pegasus 5 in 1
4095 
4096 iNES: mapper 104
4097 
4098 In MESS: Supported.
4099 
4100 *************************************************************/
4101
4102static WRITE8_HANDLER( golden5_w )
4103{
4104   nes_state *state = (nes_state *)space->machine->driver_data;
4105   LOG_MMC(("golden5_w, offset: %04x, data: %02x\n", offset, data));
4106   
4107   if (offset < 0x4000)
4108   {
4109      if (data & 0x08)
4110      {
4111         state->mmc_prg_bank[0] = ((data & 0x07) << 4) | (state->mmc_prg_bank[0] & 0x0f);
4112         prg16_89ab(space->machine, state->mmc_prg_bank[0]);
4113         prg16_cdef(space->machine, ((data & 0x07) << 4) | 0x0f);
4114      }
4115     
4116   }
4117   else
4118   {
4119      state->mmc_prg_bank[0] = (state->mmc_prg_bank[0] & 0x70) | (data & 0x0f);
4120      prg16_89ab(space->machine, state->mmc_prg_bank[0]);
4121   }
4122}
4123
4124/*************************************************************
4125 
4126 Cony Bootleg Board
4127
4128 Games: Dragon Ball Party, Fatal Fury 2, Street Blaster II
4129 Pro, World Heroes 2
4130 
4131 iNES: mapper 83
4132 
4133 In MESS: Supported.
4134 
4135 *************************************************************/
4136
4137static WRITE8_HANDLER( cony_l_w )
4138{
4139   nes_state *state = (nes_state *)space->machine->driver_data;
4140   LOG_MMC(("cony_l_w, offset: %04x, data: %02x\n", offset, data));
4141
4142   state->mapper83_low_reg[offset & 0x03] = data;
4143}
4144
4145static READ8_HANDLER( cony_l_r )
4146{
4147   nes_state *state = (nes_state *)space->machine->driver_data;
4148   LOG_MMC(("cony_l_r, offset: %04x\n", offset));
4149   return state->mapper83_low_reg[offset & 0x03];
4150}
4151
4152static void cony_set_prg( running_machine *machine )
4153{
4154   nes_state *state = (nes_state *)machine->driver_data;
4155   prg16_89ab(machine, state->mapper83_reg[8] & 0x3f);
4156   prg16_cdef(machine, (state->mapper83_reg[8] & 0x30) | 0x0f);
4157}
4158
4159static void cony_set_chr( running_machine *machine )
4160{
4161   nes_state *state = (nes_state *)machine->driver_data;
4162   chr1_0(machine, state->mapper83_reg[0] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM);
4163   chr1_1(machine, state->mapper83_reg[1] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM);
4164   chr1_2(machine, state->mapper83_reg[2] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM);
4165   chr1_3(machine, state->mapper83_reg[3] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM);
4166   chr1_4(machine, state->mapper83_reg[4] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM);
4167   chr1_5(machine, state->mapper83_reg[5] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM);
4168   chr1_6(machine, state->mapper83_reg[6] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM);
4169   chr1_7(machine, state->mapper83_reg[7] | ((state->mapper83_reg[8] & 0x30) << 4), CHRROM);
4170}
4171
4172static WRITE8_HANDLER( cony_w )
4173{
4174   nes_state *state = (nes_state *)space->machine->driver_data;
4175   LOG_MMC(("cony_w, offset: %04x, data: %02x\n", offset, data));
4176
4177   switch (offset)
4178   {
4179      case 0x0000:
4180      case 0x3000:
4181      case 0x30ff:
4182      case 0x31ff:
4183         state->mapper83_reg[8] = data;
4184         cony_set_prg(space->machine);
4185         cony_set_chr(space->machine);
4186         break;
4187      case 0x0100:
4188         switch (data & 0x03)
4189         {
4190         case 0:
4191            set_nt_mirroring(space->machine, PPU_MIRROR_VERT);
4192            break;
4193         case 1:
4194            set_nt_mirroring(space->machine, PPU_MIRROR_HORZ);
4195            break;
4196         case 2:
4197            set_nt_mirroring(space->machine, PPU_MIRROR_LOW);
4198            break;
4199         case 3:
4200            set_nt_mirroring(space->machine, PPU_MIRROR_HIGH);
4201            break;
4202         }
4203         break;
4204      case 0x0200:
4205         state->IRQ_count = (state->IRQ_count & 0xff00) | data;
4206         break;
4207      case 0x0201:
4208         state->IRQ_enable = 1;
4209         state->IRQ_count = (data << 8) | (state->IRQ_count & 0xff);
4210         break;
4211      case 0x0300:
4212         prg8_89(space->machine, data);
4213         break;
4214      case 0x0301:
4215         prg8_ab(space->machine, data);
4216         break;
4217      case 0x0302:
4218         prg8_cd(space->machine, data);
4219         break;
4220      case 0x0310:
4221      case 0x0311:
4222      case 0x0312:
4223      case 0x0313:
4224      case 0x0314:
4225      case 0x0315:
4226      case 0x0316:
4227      case 0x0317:
4228         state->mapper83_reg[offset - 0x0310] = data;
4229         cony_set_chr(space->machine);
4230         break;
4231      case 0x0318:
4232         state->mapper83_reg[9] = data;
4233         cony_set_prg(space->machine);
4234         break;
4235   }
4236}
4237
4238/*************************************************************
4239 
4240 Board DREAMTECH01
4241 
4242 Games: Korean Igo
4243 
4244 In MESS: Supported
4245 
4246 *************************************************************/
4247
4248static WRITE8_HANDLER( dreamtech_l_w )
4249{
4250   LOG_MMC(("dreamtech_l_w offset: %04x, data: %02x\n", offset, data));
4251   offset += 0x100;
4252   
4253   if (offset == 0x1020)   /* 0x5020 */
4254      prg16_89ab(space->machine, data);
4255}
4256
4257/*************************************************************
4258 
4259 Bootleg Board by Future Media
4260
4261 Games: Crayon Shin-chan (C), San Guo Zhi 4 - Chi Bi Feng Yun
4262 
4263 iNES: mapper 117
4264 
4265 In MESS: Unsupported.
4266 
4267 *************************************************************/
4268
4269static void futuremedia_irq( running_device *device, int scanline, int vblank, int blanked )
4270{
4271   nes_state *state = (nes_state *)device->machine->driver_data;
4272   //  if (scanline < PPU_BOTTOM_VISIBLE_SCANLINE)
4273   {
4274      if (state->IRQ_enable && state->IRQ_count)
4275      {
4276         state->IRQ_count--;
4277         if (!state->IRQ_count)
4278            cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
4279      }
4280   }
4281}
4282
4283static WRITE8_HANDLER( futuremedia_w )
4284{
4285   nes_state *state = (nes_state *)space->machine->driver_data;
4286   LOG_MMC(("futuremedia_w, offset: %04x, data: %02x\n", offset, data));
4287   
4288   switch (offset)
4289   {
4290      case 0x0000:
4291         prg8_89(space->machine, data);
4292         break;
4293      case 0x0001:
4294         prg8_ab(space->machine, data);
4295         break;
4296      case 0x0002:
4297         prg8_cd(space->machine, data);
4298         break;
4299      case 0x0003:
4300         prg8_ef(space->machine, data);
4301         break;
4302      case 0x2000:
4303      case 0x2001:
4304      case 0x2002:
4305      case 0x2003:
4306      case 0x2004:
4307      case 0x2005:
4308      case 0x2006:
4309      case 0x2007:
4310         chr1_x(space->machine, offset & 0x07, data, CHRROM);
4311         break;
4312         
4313      case 0x5000:
4314         set_nt_mirroring(space->machine, BIT(data, 0) ?  PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
4315         break;
4316         
4317      case 0x4001:
4318         state->IRQ_count_latch = data;
4319         break;
4320      case 0x4002:
4321         // IRQ cleared
4322         break;
4323      case 0x4003:
4324         state->IRQ_count = state->IRQ_count_latch;
4325         break;
4326      case 0x6000:
4327         state->IRQ_enable = data & 0x01;
4328         break;
4329   }
4330}
4331
4332/*************************************************************
4333 
4334 Bootleg Board 37017 (?) by Gouder
4335
4336 Games: Street Fighter IV
4337 
4338 MMC3 clone. It also requires reads from 0x5000-0x7fff.
4339 
4340 iNES: mapper 208
4341 
4342 In MESS: Preliminary Support.
4343 
4344 *************************************************************/
4345
4346static WRITE8_HANDLER( gouder_sf4_l_w )
4347{
4348   nes_state *state = (nes_state *)space->machine->driver_data;
4349   static const UINT8 conv_table[256] =
4350   {
4351      0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x49,0x19,0x09,0x59,0x49,0x19,0x09,
4352      0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x51,0x41,0x11,0x01,0x51,0x41,0x11,0x01,
4353      0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x49,0x19,0x09,0x59,0x49,0x19,0x09,
4354      0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x51,0x41,0x11,0x01,0x51,0x41,0x11,0x01,
4355      0x00,0x10,0x40,0x50,0x00,0x10,0x40,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
4356      0x08,0x18,0x48,0x58,0x08,0x18,0x48,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
4357      0x00,0x10,0x40,0x50,0x00,0x10,0x40,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
4358      0x08,0x18,0x48,0x58,0x08,0x18,0x48,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
4359      0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x58,0x48,0x18,0x08,0x58,0x48,0x18,0x08,
4360      0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x50,0x40,0x10,0x00,0x50,0x40,0x10,0x00,
4361      0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x58,0x48,0x18,0x08,0x58,0x48,0x18,0x08,
4362      0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x50,0x40,0x10,0x00,0x50,0x40,0x10,0x00,
4363      0x01,0x11,0x41,0x51,0x01,0x11,0x41,0x51,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
4364      0x09,0x19,0x49,0x59,0x09,0x19,0x49,0x59,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
4365      0x01,0x11,0x41,0x51,0x01,0x11,0x41,0x51,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
4366      0x09,0x19,0x49,0x59,0x09,0x19,0x49,0x59,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
4367   };
4368   
4369   LOG_MMC(("gouder_sf4_l_w, offset: %04x, data: %02x\n", offset, data));
4370   
4371   if (!(offset < 0x1700))
4372      state->map208_reg[offset & 0x03] = data ^ conv_table[state->map208_reg[4]];
4373   else if (!(offset < 0xf00))
4374      state->map208_reg[4] = data;
4375   else if (!(offset < 0x700))
4376      prg32(space->machine, ((data >> 3) & 0x02) | (data & 0x01));
4377}
4378
4379static READ8_HANDLER( gouder_sf4_l_r )
4380{
4381   nes_state *state = (nes_state *)space->machine->driver_data;
4382   LOG_MMC(("gouder_sf4_l_r, offset: %04x\n", offset));
4383   
4384   if (!(offset < 0x1700))
4385      return state->map208_reg[offset & 0x03];
4386   
4387   return 0x00;
4388}
4389
4390/* This is like mmc3 but with no PRG bankswitch (beacuse it is handled by low writes) */
4391// replace with map189_w... they are the same!!
4392static WRITE8_HANDLER( gouder_sf4_w )
4393{
4394   nes_state *state = (nes_state *)space->machine->driver_data;
4395   UINT8 MMC3_helper, cmd;
4396   LOG_MMC(("gouder_sf4_w, offset: %04x, data: %02x\n", offset, data));
4397   
4398   switch (offset & 0x6001)
4399   {
4400      case 0x0000:
4401         MMC3_helper = state->mmc_latch1 ^ data;
4402         state->mmc_latch1 = data;
4403         
4404         /* Has CHR Mode changed? */
4405         if (MMC3_helper & 0x80)
4406            mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
4407         break;
4408         
4409      case 0x0001:
4410         cmd = state->mmc_latch1 & 0x07;
4411         switch (cmd)
4412         {
4413         case 0: case 1:
4414         case 2: case 3: case 4: case 5:
4415            state->mmc_vrom_bank[cmd] = data;
4416            mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
4417            break;
4418         }
4419         break;
4420         
4421      default:
4422         txrom_w(space, offset, data);
4423         break;
4424   }
4425}
4426
4427/*************************************************************
4428 
4429 Bootleg Board by Henggedianzi
4430
4431 Games: Mei Guo Fu Hao, Shang Gu Shen Jian , Wang Zi Fu
4432 Chou Ji
4433 
4434 Writes to 0x8000-0xffff set prg32. Moreover, data&0x20 sets
4435 NT mirroring.
4436 
4437 iNES: mapper 177
4438 
4439 In MESS: Supported.
4440 
4441 *************************************************************/
4442
4443static WRITE8_HANDLER( henggedianzi_w )
4444{
4445   LOG_MMC(("henggedianzi_w, offset: %04x, data: %02x\n", offset, data));
4446   
4447   prg32(space->machine, data);
4448   set_nt_mirroring(space->machine, BIT(data, 5) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
4449}
4450
4451/*************************************************************
4452 
4453 Bootleg Board by Henggedianzi
4454 
4455 Games: Xing He Zhan Shi
4456 
4457 Writes to 0x5000-0x5fff set prg32 banks, writes to 0x8000-
4458 0xffff set NT mirroring
4459 
4460 iNES: mapper 179
4461 
4462 In MESS: Supported.
4463 
4464 *************************************************************/
4465
4466static WRITE8_HANDLER( heng_xjzb_l_w )
4467{
4468   LOG_MMC(("heng_xjzb_l_w, offset: %04x, data: %02x\n", offset, data));
4469   offset += 0x4100;
4470   
4471   if (offset & 0x5000)
4472      prg32(space->machine, data >> 1);
4473}
4474
4475static WRITE8_HANDLER( heng_xjzb_w )
4476{
4477   LOG_MMC(("heng_xjzb_w, offset: %04x, data: %02x\n", offset, data));
4478   
4479   set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
4480}
4481
4482/*************************************************************
4483 
4484 Bootleg Board by HES (also used by others)
4485
4486 Games: AV Hanafuda Club, AV Soccer, Papillon, Sidewinder,
4487 Total Funpack
4488 
4489 Actually, two variant: one for HES 6-in-1 with mirroring control
4490 and one for AV Soccer and others with hardwired mirroring
4491
4492 iNES: mapper 113
4493 
4494 In MESS: Supported.
4495 
4496 *************************************************************/
4497
4498static WRITE8_HANDLER( hes6in1_l_w )
4499{
4500   LOG_MMC(("hes6in1_l_w, offset: %04x, data: %02x\n", offset, data));
4501   
4502   if (!(offset & 0x100))
4503   {
4504      prg32(space->machine, (data & 0x38) >> 3);
4505      chr8(space->machine, (data & 0x07) | ((data & 0x40) >> 3), CHRROM);
4506      set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_VERT : PPU_MIRROR_HORZ);
4507   }
4508}
4509
4510static WRITE8_HANDLER( hes_l_w )
4511{
4512   LOG_MMC(("hes_l_w, offset: %04x, data: %02x\n", offset, data));
4513   
4514   if (!(offset & 0x100))
4515   {
4516      prg32(space->machine, (data & 0x38) >> 3);
4517      chr8(space->machine, (data & 0x07) | ((data & 0x40) >> 3), CHRROM);
4518   }
4519}
4520
4521/*************************************************************
4522 
4523 Bootleg Board by Hosenkan
4524
4525 Games: Pocahontas, Super Donkey Kong
4526 
4527 iNES: mapper 182
4528 
4529 In MESS: Supported.
4530 
4531 *************************************************************/
4532
4533static WRITE8_HANDLER( hosenkan_w )
4534{
4535   nes_state *state = (nes_state *)space->machine->driver_data;
4536   LOG_MMC(("hosenkan_w, offset: %04x, data: %02x\n", offset, data));
4537   
4538   switch (offset & 0x7003)
4539   {
4540      case 0x0001:
4541         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
4542         break;
4543      case 0x2000:
4544         state->mmc_latch1 = data;
4545         break;
4546      case 0x4000:
4547         switch (state->mmc_latch1)
4548      {
4549         case 0:
4550            chr2_0(space->machine, data >> 1, CHRROM);
4551            break;
4552         case 1:
4553            chr1_5(space->machine, data, CHRROM);
4554            break;
4555         case 2:
4556            chr2_2(space->machine, data >> 1, CHRROM);
4557            break;
4558         case 3:
4559            chr1_7(space->machine, data, CHRROM);
4560            break;
4561         case 4:
4562            prg8_89(space->machine, data);
4563            break;
4564         case 5:
4565            prg8_ab(space->machine, data);
4566            break;
4567         case 6:
4568            chr1_4(space->machine, data, CHRROM);
4569            break;
4570         case 7:
4571            chr1_6(space->machine, data, CHRROM);
4572            break;
4573      }
4574         break;
4575      case 0x6003:
4576         if (data)
4577         {
4578            state->IRQ_count = data;
4579            state->IRQ_enable = 1;
4580         }
4581         else
4582            state->IRQ_enable = 0;
4583         break;
4584   }
4585}
4586
4587/*************************************************************
4588 
4589 Bootleg Board by Kaiser (KS7058)
4590
4591 Games: Tui Do Woo Ma Jeung
4592 
4593 Writes to 0xf000-0xffff set 4k chr banks. Namely, if
4594 offset&0x80 is 0 the lower 4k are set, if it is 1 the
4595 upper 4k are set.
4596 
4597 iNES: mapper 171
4598 
4599 In MESS: Supported.
4600 
4601 *************************************************************/
4602
4603static WRITE8_HANDLER( ks7058_w )
4604{
4605   LOG_MMC(("ks7058_w, offset: %04x, data: %02x\n", offset, data));
4606   
4607   switch (offset & 0x7080)
4608   {
4609      case 0x7000:
4610         chr4_0(space->machine, data, CHRROM);
4611         break;
4612      case 0x7080:
4613         chr4_4(space->machine, data, CHRROM);
4614         break;
4615   }
4616}
4617
4618/*************************************************************
4619 
4620 Bootleg Board by Kay (for Panda Prince)
4621
4622 Games: The Panda Prince
4623 
4624 MMC3 clone
4625 
4626 iNES: mapper 121
4627 
4628 In MESS: Supported.
4629 
4630 *************************************************************/
4631
4632static WRITE8_HANDLER( kay_pp_l_w )
4633{
4634   nes_state *state = (nes_state *)space->machine->driver_data;
4635   LOG_MMC(("kay_pp_l_w, offset: %04x, data: %02x\n", offset, data));
4636   offset += 0x100;
4637   
4638   if (!(offset < 0x1000))
4639   {
4640      switch (data & 0x03)
4641      {
4642         case 0x00:
4643         case 0x03:
4644            state->mapper121_reg[2] = 0x00;
4645            break;
4646         case 0x01:
4647            state->mapper121_reg[2] = 0x83;
4648            break;
4649         case 0x02:
4650            state->mapper121_reg[2] = 0x42;
4651            break;
4652      }
4653   }
4654}
4655
4656static READ8_HANDLER( kay_pp_l_r )
4657{
4658   nes_state *state = (nes_state *)space->machine->driver_data;
4659   LOG_MMC(("kay_pp_l_r, offset: %04x\n", offset));
4660   offset += 0x100;
4661   
4662   if (!(offset < 0x1000))
4663      return state->mapper121_reg[2];
4664   else
4665      return 0;
4666}
4667
4668static void kay_pp_set_prg( running_machine *machine, int prg_base, int prg_mask )
4669{
4670   nes_state *state = (nes_state *)machine->driver_data;
4671   UINT8 prg_flip = (state->mmc_latch1 & 0x40) ? 2 : 0;
4672   UINT8 new_bank2, new_bank3;
4673   
4674   new_bank2 = state->mapper121_reg[0] ? state->mapper121_reg[0] : state->mmc_prg_bank[2 ^ prg_flip];
4675   new_bank3 = state->mapper121_reg[1] ? state->mapper121_reg[1] : state->mmc_prg_bank[3];
4676   
4677   prg8_89(machine, prg_base | (state->mmc_prg_bank[0 ^ prg_flip] & prg_mask));
4678   prg8_ab(machine, prg_base | (state->mmc_prg_bank[1] & prg_mask));
4679   prg8_cd(machine, prg_base | (new_bank2 & prg_mask));
4680   prg8_ef(machine, prg_base | (new_bank3 & prg_mask));
4681}
4682
4683static WRITE8_HANDLER( kay_pp_w )
4684{
4685   nes_state *state = (nes_state *)space->machine->driver_data;
4686   UINT8 MMC3_helper, cmd;
4687   LOG_MMC(("kay_pp_w, offset: %04x, data: %02x\n", offset, data));
4688   
4689   if ((offset < 0x2000) && (offset & 0x03) == 0x03)
4690   {
4691      switch (data)
4692      {
4693         case 0x20:
4694            state->mapper121_reg[1] = 0x13;
4695            break;
4696         case 0x26:
4697            state->mapper121_reg[1] = 0x08;
4698            break;
4699         case 0x28:
4700            state->mapper121_reg[0] = 0x0c;
4701            break;
4702         case 0x29:
4703            state->mapper121_reg[1] = 0x1b;
4704            break;
4705         case 0xab:
4706            state->mapper121_reg[1] = 0x07;
4707            break;
4708         case 0xec:
4709         case 0xef:
4710            state->mapper121_reg[1] = 0x0d;
4711            break;
4712         case 0xff:
4713            state->mapper121_reg[1] = 0x09;
4714            break;
4715         default:
4716            state->mapper121_reg[0] = 0x0;
4717            state->mapper121_reg[1] = 0x0;
4718            break;
4719      }
4720   }
4721   else
4722   {
4723      switch (offset & 0x6001)
4724      {
4725         case 0x0000:
4726            MMC3_helper = state->mmc_latch1 ^ data;
4727            state->mmc_latch1 = data;
4728           
4729            /* Has PRG Mode changed? */
4730            if (MMC3_helper & 0x40)
4731               kay_pp_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
4732           
4733            /* Has CHR Mode changed? */
4734            if (MMC3_helper & 0x80)
4735               mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
4736            break;
4737           
4738         case 0x0001:
4739            cmd = state->mmc_latch1 & 0x07;
4740            switch (cmd)
4741         {
4742            case 0: case 1:
4743            case 2: case 3: case 4: case 5:
4744               state->mmc_vrom_bank[cmd] = data;
4745               mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
4746               break;
4747            case 6:
4748            case 7:
4749               state->mmc_prg_bank[cmd - 6] = data;
4750               kay_pp_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
4751               break;
4752         }
4753            break;
4754           
4755         default:
4756            txrom_w(space, offset, data);
4757            break;
4758      }
4759   }
4760   kay_pp_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
4761}
4762
4763/*************************************************************
4764 
4765 Bootleg Board by Kasing
4766
4767 Games: AV Jiu Ji Mahjong, Bao Qing Tian, Thunderbolt 2,
4768 Shisen Mahjong 2
4769 
4770 MMC3 clone
4771 
4772 iNES: mapper 115
4773 
4774 In MESS: Supported
4775 
4776 *************************************************************/
4777
4778static void kasing_set_prg( running_machine *machine, int prg_base, int prg_mask  )
4779{
4780   nes_state *state = (nes_state *)machine->driver_data;
4781   if (state->mapper115_reg[0] & 0x80)
4782      prg32(machine, state->mapper115_reg[0] >> 1);
4783   else
4784      mmc3_set_prg(machine, prg_base, prg_mask);
4785}
4786
4787static WRITE8_HANDLER( kasing_m_w )
4788{
4789   nes_state *state = (nes_state *)space->machine->driver_data;
4790   LOG_MMC(("kasing_m_w, offset: %04x, data: %02x\n", offset, data));
4791   
4792   switch (offset & 0x01)
4793   {
4794      case 0x00:
4795         state->mapper115_reg[0] = data;
4796         kasing_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
4797         break;
4798      case 0x01:
4799         state->mmc_chr_base = (data & 0x01) ? 0x100 : 0x000;
4800         mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
4801         break;
4802   }
4803}
4804
4805static WRITE8_HANDLER( kasing_w )
4806{
4807   nes_state *state = (nes_state *)space->machine->driver_data;
4808   UINT8 map115_helper, cmd;
4809   LOG_MMC(("kasing_w, offset: %04x, data: %02x\n", offset, data));
4810   
4811   switch (offset & 0x6001)
4812   {
4813      case 0x0000:
4814         map115_helper = state->mmc_latch1 ^ data;
4815         state->mmc_latch1 = data;
4816         
4817         /* Has PRG Mode changed? */
4818         if (map115_helper & 0x40)
4819            kasing_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
4820         
4821         /* Has CHR Mode changed? */
4822         if (map115_helper & 0x80)
4823            mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
4824         break;
4825         
4826      case 0x0001:
4827         cmd = state->mmc_latch1 & 0x07;
4828         switch (cmd)
4829      {
4830         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
4831         case 2: case 3: case 4: case 5:
4832            state->mmc_vrom_bank[cmd] = data;
4833            mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
4834            break;
4835         case 6:
4836         case 7:
4837            state->mmc_prg_bank[cmd - 6] = data;
4838            kasing_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
4839            break;
4840      }
4841         break;
4842         
4843      default:
4844         txrom_w(space, offset, data);
4845         break;
4846   }
4847}
4848
4849/*************************************************************
4850 
4851 Bootleg Board by Magic Series
4852
4853 Games: Magic Dragon
4854 
4855 Very simple mapper: writes to 0x8000-0xffff set prg32 and chr8
4856 banks
4857 
4858 iNES: mapper 107
4859 
4860 In MESS: Supported.
4861 
4862 *************************************************************/
4863
4864static WRITE8_HANDLER( magics_md_w )
4865{
4866   LOG_MMC(("magics_md_w, offset: %04x, data: %02x\n", offset, data));
4867   
4868   prg32(space->machine, data >> 1);
4869   chr8(space->machine, data, CHRROM);
4870}
4871
4872/*************************************************************
4873 
4874 Bootleg Board by Nitra
4875
4876 Games: Time Diver Avenger
4877 
4878 This acts basically like a MMC3 with different use of write
4879 address.
4880 
4881 iNES: mapper 250
4882 
4883 In MESS: Supported.
4884 
4885 *************************************************************/
4886
4887static WRITE8_HANDLER( nitra_w )
4888{
4889   LOG_MMC(("nitra_w, offset: %04x, data: %02x\n", offset, data));
4890   
4891   txrom_w(space, (offset & 0x6000) | ((offset & 0x400) >> 10), offset & 0xff);
4892}
4893
4894/*************************************************************
4895 
4896 NTDEC ASDER Bootleg Board
4897
4898 Games: Cobra Mission, Fighting Hero III, Huang Di, Master
4899 Shooter
4900 
4901 iNES: mapper 112
4902 
4903 In MESS: Supported.
4904 
4905 *************************************************************/
4906
4907static WRITE8_HANDLER( ntdec_asder_w )
4908{
4909   nes_state *state = (nes_state *)space->machine->driver_data;
4910   LOG_MMC(("ntdec_asder_w, offset: %04x, data: %02x\n", offset, data));
4911   
4912   switch (offset)
4913   {
4914      case 0x0000:
4915         state->mmc_latch1 = data & 0x07;
4916         break;
4917      case 0x2000:
4918         switch (state->mmc_latch1)
4919      {
4920         case 0:
4921            prg8_89(space->machine, data);
4922            break;
4923         case 1:
4924            prg8_ab(space->machine, data);
4925            break;
4926         case 2:
4927            data &= 0xfe;
4928            chr1_0(space->machine, data, CHRROM);
4929            chr1_1(space->machine, data + 1, CHRROM);
4930            break;
4931         case 3:
4932            data &= 0xfe;
4933            chr1_2(space->machine, data, CHRROM);
4934            chr1_3(space->machine, data + 1, CHRROM);
4935            break;
4936         case 4:
4937            chr1_4(space->machine, data, CHRROM);
4938            break;
4939         case 5:
4940            chr1_5(space->machine, data, CHRROM);
4941            break;
4942         case 6:
4943            chr1_6(space->machine, data, CHRROM);
4944            break;
4945         case 7:
4946            chr1_7(space->machine, data, CHRROM);
4947            break;
4948      }
4949         break;
4950      case 0x6000:
4951         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
4952         break;
4953   }
4954}
4955
4956/*************************************************************
4957 
4958 Bootleg Board by NTDEC for Fighting Hero
4959
4960 Games: Fighting Hero
4961 
4962 Very simple mapper: writes to 0x6000-0x7fff swap PRG and
4963 CHR banks.
4964 
4965 iNES: mapper 193
4966 
4967 In MESS: Supported.
4968 
4969 *************************************************************/
4970
4971static WRITE8_HANDLER( ntdec_fh_m_w )
4972{
4973   LOG_MMC(("ntdec_fh_m_w, offset: %04x, data: %02x\n", offset, data));
4974   
4975   switch (offset & 0x03)
4976   {
4977      case 0:
4978         chr4_0(space->machine, data >> 2, CHRROM);
4979         break;
4980      case 1:
4981         chr2_4(space->machine, data >> 1, CHRROM);
4982         break;
4983      case 2:
4984         chr2_6(space->machine, data >> 1 , CHRROM);
4985         break;
4986      case 3:
4987         prg8_89(space->machine, data);
4988         break;
4989   }
4990}
4991
4992/*************************************************************
4993 
4994 Open Corp DAOU306 board
4995
4996 Games: Metal Force (K)
4997 
4998 iNES: mapper 156
4999 
5000 In MESS: Supported.
5001 
5002 *************************************************************/
5003
5004static WRITE8_HANDLER( daou306_w )
5005{
5006   LOG_MMC(("daou306_w, offset: %04x, data: %02x\n", offset, data));
5007   
5008   switch (offset)
5009   {
5010      case 0x4000:
5011         chr1_0(space->machine, data, CHRROM);
5012         break;
5013      case 0x4001:
5014         chr1_1(space->machine, data, CHRROM);
5015         break;
5016      case 0x4002:
5017         chr1_2(space->machine, data, CHRROM);
5018         break;
5019      case 0x4003:
5020         chr1_3(space->machine, data, CHRROM);
5021         break;
5022      case 0x4008:
5023         chr1_4(space->machine, data, CHRROM);
5024         break;
5025      case 0x4009:
5026         chr1_5(space->machine, data, CHRROM);
5027         break;
5028      case 0x400a:
5029         chr1_6(space->machine, data, CHRROM);
5030         break;
5031      case 0x400b:
5032         chr1_7(space->machine, data, CHRROM);
5033         break;
5034      case 0x4010:
5035         prg16_89ab(space->machine, data);
5036         break;
5037   }
5038}
5039
5040/*************************************************************
5041 
5042 RCM GS2015 Board
5043
5044 Games: Bonza, Magic Jewelry 2
5045 
5046 Very simple mapper: writes to 0x8000-0xffff sets prg32
5047 to offset and chr8 to offset>>1 (when chrrom is present)
5048 
5049 iNES: mapper 216
5050 
5051 In MESS: Supported.
5052 
5053 *************************************************************/
5054
5055static WRITE8_HANDLER( gs2015_w )
5056{
5057   nes_state *state = (nes_state *)space->machine->driver_data;
5058   LOG_MMC(("gs2015_w, offset: %04x, data: %02x\n", offset, data));
5059   
5060   prg32(space->machine, offset);
5061   chr8(space->machine, offset >> 1, state->mmc_chr_source);
5062}
5063
5064/*************************************************************
5065 
5066 Bootleg Board by RCM for Tetris Family
5067
5068 Games: Tetris Family 9 in 1, 20 in 1
5069 
5070 Simple Mapper: prg/chr/nt are swapped depending on the offset
5071 of writes in 0x8000-0xffff. offset&0x80 set NT mirroring,
5072 when (offset&0x30) is 0,3 prg32 is set; when it is 1,2
5073 two 16k prg banks are set. See below for the values used in
5074 these banks.
5075 
5076 iNES: mapper 61
5077 
5078 In MESS: Supported.
5079 
5080 *************************************************************/
5081
5082static WRITE8_HANDLER( rcm_tf_w )
5083{
5084   LOG_MMC(("rcm_tf_w, offset: %04x, data: %02x\n", offset, data));
5085   
5086   switch (offset & 0x30)
5087   {
5088      case 0x00:
5089      case 0x30:
5090         prg32(space->machine, offset & 0x0f);
5091         break;
5092      case 0x10:
5093      case 0x20:
5094         prg16_89ab(space->machine, ((offset & 0x0f) << 1) | ((offset & 0x20) >> 4));
5095         prg16_cdef(space->machine, ((offset & 0x0f) << 1) | ((offset & 0x20) >> 4));
5096         break;
5097   }
5098   set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
5099}
5100
5101/*************************************************************
5102 
5103 Bootleg Board by Rex Soft
5104
5105 Games: Dragon Ball Z 5, Dragon Ball Z Super
5106 
5107 MMC3 clone
5108 
5109 iNES: mapper 12
5110 
5111 In MESS: Partially Supported
5112 
5113 *************************************************************/
5114
5115static WRITE8_HANDLER( rex_dbz_l_w )
5116{
5117   nes_state *state = (nes_state *)space->machine->driver_data;
5118   
5119   LOG_MMC(("rex_dbz_l_w, offset: %04x, data: %02x\n", offset, data));
5120   
5121   state->mapper12_reg = data;
5122}
5123
5124/* we would need to use this read handler in 0x6000-0x7fff as well */
5125static READ8_HANDLER( rex_dbz_l_r )
5126{
5127   LOG_MMC(("rex_dbz_l_r, offset: %04x\n", offset));
5128   return 0x01;
5129}
5130
5131static void rex_dbz_set_chr( running_machine *machine )
5132{
5133   nes_state *state = (nes_state *)machine->driver_data;
5134   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
5135   
5136   chr1_x(machine, chr_page ^ 0, ((state->mapper12_reg & 0x01) << 8) | (state->mmc_vrom_bank[0] & ~0x01), CHRROM);
5137   chr1_x(machine, chr_page ^ 1, ((state->mapper12_reg & 0x01) << 8) | (state->mmc_vrom_bank[0] |  0x01), CHRROM);
5138   chr1_x(machine, chr_page ^ 2, ((state->mapper12_reg & 0x01) << 8) | (state->mmc_vrom_bank[1] & ~0x01), CHRROM);
5139   chr1_x(machine, chr_page ^ 3, ((state->mapper12_reg & 0x01) << 8) | (state->mmc_vrom_bank[1] |  0x01), CHRROM);
5140   chr1_x(machine, chr_page ^ 4, ((state->mapper12_reg & 0x10) << 4) | state->mmc_vrom_bank[2], CHRROM);
5141   chr1_x(machine, chr_page ^ 5, ((state->mapper12_reg & 0x10) << 4) | state->mmc_vrom_bank[3], CHRROM);
5142   chr1_x(machine, chr_page ^ 6, ((state->mapper12_reg & 0x10) << 4) | state->mmc_vrom_bank[4], CHRROM);
5143   chr1_x(machine, chr_page ^ 7, ((state->mapper12_reg & 0x10) << 4) | state->mmc_vrom_bank[5], CHRROM);
5144}
5145
5146static WRITE8_HANDLER( rex_dbz_w )
5147{
5148   nes_state *state = (nes_state *)space->machine->driver_data;
5149   UINT8 MMC3_helper, cmd;
5150   LOG_MMC(("rex_dbz_w, offset: %04x, data: %02x\n", offset, data));
5151   
5152   switch (offset & 0x6001)
5153   {
5154      case 0x0000:
5155         MMC3_helper = state->mmc_latch1 ^ data;
5156         state->mmc_latch1 = data;
5157         
5158         /* Has PRG Mode changed? */
5159         if (MMC3_helper & 0x40)
5160            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5161         
5162         /* Has CHR Mode changed? */
5163         if (MMC3_helper & 0x80)
5164            rex_dbz_set_chr(space->machine);
5165         break;
5166         
5167      case 0x0001:
5168         cmd = state->mmc_latch1 & 0x07;
5169         switch (cmd)
5170      {
5171         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
5172         case 2: case 3: case 4: case 5:
5173            state->mmc_vrom_bank[cmd] = data;
5174            rex_dbz_set_chr(space->machine);
5175            break;
5176         case 6:
5177         case 7:
5178            state->mmc_prg_bank[cmd - 6] = data;
5179            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5180            break;
5181      }
5182         break;
5183         
5184      default:
5185         txrom_w(space, offset, data);
5186         break;
5187   }
5188}
5189
5190/*************************************************************
5191 
5192 Rex Soft SL1632 Board
5193
5194 Games: Samurai Spirits
5195 
5196 MMC3 clone
5197 
5198 iNES: mapper 14
5199 
5200 In MESS: Supported
5201 
5202 *************************************************************/
5203
5204static void rex_sl1632_set_prg( running_machine *machine, int prg_base, int prg_mask )
5205{
5206   nes_state *state = (nes_state *)machine->driver_data;
5207   
5208   if (state->map14_reg[0] & 0x02)
5209   {
5210      mmc3_set_prg(machine, prg_base, prg_mask);
5211   }
5212   else
5213   {
5214      prg8_89(machine, state->mmc_extra_bank[0]);
5215      prg8_ab(machine, state->mmc_extra_bank[1]);
5216      prg8_cd(machine, state->mmc_extra_bank[2]);
5217      prg8_ef(machine, state->mmc_extra_bank[3]);
5218   }
5219}
5220
5221static void rex_sl1632_set_chr( running_machine *machine, UINT8 chr, int chr_base, int chr_mask )
5222{
5223   nes_state *state = (nes_state *)machine->driver_data;
5224   static const UINT8 conv_table[8] = {5, 5, 5, 5, 3, 3, 1, 1};
5225   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
5226   UINT8 bank[8];
5227   UINT8 chr_base2[8];
5228   int i;
5229   
5230   if (state->map14_reg[0] & 0x02)
5231   {
5232      for(i = 0; i < 8; i++)
5233      {
5234         bank[i] = state->mmc_vrom_bank[i];
5235         chr_base2[i] = chr_base | ((state->map14_reg[0] << conv_table[i]) & 0x100);
5236      }
5237   }
5238   else
5239   {
5240      for(i = 0; i < 8; i++)
5241      {
5242         bank[i] = state->mmc_extra_bank[i + 4];   // first 4 state->mmc_extra_banks are PRG
5243         chr_base2[i] = chr_base;
5244      }
5245   }
5246   
5247   chr1_x(machine, chr_page ^ 0, chr_base2[0] | (bank[0] & chr_mask), chr);
5248   chr1_x(machine, chr_page ^ 1, chr_base2[1] | (bank[1] & chr_mask), chr);
5249   chr1_x(machine, chr_page ^ 2, chr_base2[2] | (bank[2] & chr_mask), chr);
5250   chr1_x(machine, chr_page ^ 3, chr_base2[3] | (bank[3] & chr_mask), chr);
5251   chr1_x(machine, chr_page ^ 4, chr_base2[4] | (bank[4] & chr_mask), chr);
5252   chr1_x(machine, chr_page ^ 5, chr_base2[5] | (bank[5] & chr_mask), chr);
5253   chr1_x(machine, chr_page ^ 6, chr_base2[6] | (bank[6] & chr_mask), chr);
5254   chr1_x(machine, chr_page ^ 7, chr_base2[7] | (bank[7] & chr_mask), chr);
5255}
5256
5257static WRITE8_HANDLER( rex_sl1632_w )
5258{
5259   nes_state *state = (nes_state *)space->machine->driver_data;
5260   UINT8 map14_helper1, map14_helper2, MMC3_helper, cmd;
5261   LOG_MMC(("rex_sl1632_w, offset: %04x, data: %02x\n", offset, data));
5262   
5263   if (offset == 0x2131)
5264   {
5265      state->map14_reg[0] = data;
5266      rex_sl1632_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5267      rex_sl1632_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
5268     
5269      if (!(state->map14_reg[0] & 0x02))
5270         set_nt_mirroring(space->machine, BIT(state->map14_reg[1], 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
5271   }
5272   
5273   if (state->map14_reg[0] & 0x02)
5274   {
5275      switch (offset & 0x6001)
5276      {
5277         case 0x0000:
5278            MMC3_helper = state->mmc_latch1 ^ data;
5279            state->mmc_latch1 = data;
5280           
5281            /* Has PRG Mode changed? */
5282            if (MMC3_helper & 0x40)
5283               rex_sl1632_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5284           
5285            /* Has CHR Mode changed? */
5286            if (MMC3_helper & 0x80)
5287               rex_sl1632_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
5288            break;
5289           
5290         case 0x0001:
5291            cmd = state->mmc_latch1 & 0x07;
5292            switch (cmd)
5293         {
5294            case 0: case 1:   // these have to be changed due to the different way rex_sl1632_set_chr works (it handles 1k banks)!
5295               state->mmc_vrom_bank[2 * cmd] = data;
5296               state->mmc_vrom_bank[2 * cmd + 1] = data;
5297               rex_sl1632_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
5298               break;
5299            case 2: case 3: case 4: case 5:
5300               state->mmc_vrom_bank[cmd + 2] = data;
5301               rex_sl1632_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
5302               break;
5303            case 6:
5304            case 7:
5305               state->mmc_prg_bank[cmd - 6] = data;
5306               rex_sl1632_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5307               break;
5308         }
5309            break;
5310           
5311         case 0x2000:
5312            set_nt_mirroring(space->machine, BIT(state->map14_reg[1], 0) ? PPU_MIRROR_VERT : PPU_MIRROR_HORZ);
5313            break;
5314           
5315         default:
5316            txrom_w(space, offset, data);
5317            break;
5318      }
5319   }
5320   else if (offset >= 0x3000 && offset <= 0x6003 )
5321   {
5322      map14_helper1 = (offset & 0x01) << 2;
5323      offset = ((offset & 0x02) | (offset >> 10)) >> 1;
5324      map14_helper2 = ((offset + 2) & 0x07) + 4; // '+4' because first 4 state->mmc_extra_banks are for PRG!
5325      state->mmc_extra_bank[map14_helper2] = (state->mmc_extra_bank[map14_helper2] & (0xf0 >> map14_helper1)) | ((data & 0x0f) << map14_helper1);
5326      rex_sl1632_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
5327   }
5328   else
5329   {
5330      switch (offset & 0x7003)
5331      {
5332         case 0x0000:
5333         case 0x2000:
5334            state->mmc_extra_bank[offset >> 13] = data;
5335            rex_sl1632_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5336            break;
5337           
5338         case 0x1000:
5339            state->map14_reg[1] = data;
5340            set_nt_mirroring(space->machine, BIT(state->map14_reg[1], 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
5341            break;
5342      }
5343   }
5344}
5345
5346/*************************************************************
5347 
5348 Rumblestation Board
5349
5350 Games: Rumblestation 15 in 1
5351 
5352 iNES: mapper 46
5353 
5354 In MESS: Supported.
5355 
5356 *************************************************************/
5357
5358static WRITE8_HANDLER( rumblestation_m_w )
5359{
5360   nes_state *state = (nes_state *)space->machine->driver_data;
5361   LOG_MMC(("rumblestation_m_w, offset: %04x, data: %02x\n", offset, data));
5362   
5363   state->mmc_prg_bank[0] = (state->mmc_prg_bank[0] & 0x01) | ((data & 0x0f) << 1);
5364   state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & 0x07) | ((data & 0xf0) >> 1);
5365   prg32(space->machine, state->mmc_prg_bank[0]);
5366   chr8(space->machine, state->mmc_vrom_bank[0], CHRROM);
5367}
5368
5369static WRITE8_HANDLER( rumblestation_w )
5370{
5371   nes_state *state = (nes_state *)space->machine->driver_data;
5372   LOG_MMC(("rumblestation_w, offset: %04x, data: %02x\n", offset, data));
5373   
5374   state->mmc_prg_bank[0] = (state->mmc_prg_bank[0] & ~0x01) | (data & 0x01);
5375   state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & ~0x07) | ((data & 0x70) >> 4);
5376   prg32(space->machine, state->mmc_prg_bank[0]);
5377   chr8(space->machine, state->mmc_vrom_bank[0], CHRROM);
5378}
5379
5380/*************************************************************
5381 
5382 Sachen 74x374 bootleg boards
5383 
5384 iNES: mapper 150 & 243
5385 
5386 *************************************************************/
5387
5388#if 0
5389static void sachen_set_mirror( running_machine *machine, UINT8 nt ) // used by mappers 137, 138, 139, 141
5390{
5391   switch (nt)
5392   {
5393      case 0:
5394      case 1:
5395         set_nt_mirroring(machine, nt ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
5396         break;
5397      case 2:
5398         set_nt_page(machine, 0, CIRAM, 0, 1);
5399         set_nt_page(machine, 1, CIRAM, 1, 1);
5400         set_nt_page(machine, 2, CIRAM, 1, 1);
5401         set_nt_page(machine, 3, CIRAM, 1, 1);
5402         break;
5403      case 3:
5404         set_nt_mirroring(machine, PPU_MIRROR_LOW);
5405         break;
5406      default:
5407         LOG_MMC(("Mapper set NT to invalid value %02x", nt));
5408         break;
5409   }
5410}
5411#endif
5412
5413static WRITE8_HANDLER( sachen_74x374_l_w )
5414{
5415   nes_state *state = (nes_state *)space->machine->driver_data;
5416   LOG_MMC(("sachen_74x374_l_w, offset: %04x, data: %02x\n", offset, data));
5417   
5418   /* write happens only if we are at 0x4100 + k * 0x200, but 0x4100 is offset = 0 */
5419   if (!(offset & 0x100))
5420   {
5421      if (!(offset & 0x01))
5422         state->mmc_latch1 = data & 0x07;
5423      else
5424      {
5425         switch (state->mmc_latch1)
5426         {
5427            case 0x02:
5428               state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & ~0x08) | ((data << 3) & 0x08);
5429               chr8(space->machine, state->mmc_vrom_bank[0], CHRROM);
5430               prg32(space->machine, data & 0x01);
5431               break;
5432            case 0x04:
5433               state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & ~0x04) | ((data << 2) & 0x04);
5434               chr8(space->machine, state->mmc_vrom_bank[0], CHRROM);
5435               break;
5436            case 0x05:
5437               prg32(space->machine, data & 0x07);
5438               break;
5439            case 0x06:
5440               state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & ~0x03) | ((data << 0) & 0x03);
5441               chr8(space->machine, state->mmc_vrom_bank[0], CHRROM);
5442               break;
5443            case 0x07:
5444               sachen_set_mirror(space->machine, (data >> 1) & 0x03);
5445               break;
5446            default:
5447               break;
5448         }
5449      }
5450   }
5451}
5452
5453static READ8_HANDLER( sachen_74x374_l_r )
5454{
5455   nes_state *state = (nes_state *)space->machine->driver_data;
5456   LOG_MMC(("sachen_74x374_l_r, offset: %04x", offset));
5457   
5458   /* read  happens only if we are at 0x4100 + k * 0x200, but 0x4100 is offset = 0 */
5459   if (!(offset & 0x100))
5460      return (~state->mmc_latch1 & 0x3f) /* ^ dips*/;   // we would need to check the Dips here
5461   else
5462      return 0;
5463}
5464
5465static WRITE8_HANDLER( sachen_74x374a_l_w )
5466{
5467   nes_state *state = (nes_state *)space->machine->driver_data;
5468   LOG_MMC(("sachen_74x374a_l_w, offset: %04x, data: %02x\n", offset, data));
5469   
5470   /* write happens only if we are at 0x4100 + k * 0x200, but 0x4100 is offset = 0 */
5471   if (!(offset & 0x100))
5472   {
5473      if (!(offset & 0x01))
5474         state->mmc_latch1 = data;
5475      else
5476      {
5477         switch (state->mmc_latch1 & 0x07)
5478         {
5479            case 0x00:
5480               prg32(space->machine, 0);
5481               chr8(space->machine, 3, CHRROM);
5482               break;
5483            case 0x02:
5484               state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & ~0x08) | ((data << 3) & 0x08);
5485               chr8(space->machine, state->mmc_vrom_bank[0], CHRROM);
5486               break;
5487            case 0x04:
5488               state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & ~0x01) | ((data << 0) & 0x01);
5489               chr8(space->machine, state->mmc_vrom_bank[0], CHRROM);
5490               break;
5491            case 0x05:
5492               prg32(space->machine, data & 0x01);
5493               break;
5494            case 0x06:
5495               state->mmc_vrom_bank[0] = (state->mmc_vrom_bank[0] & ~0x06) | ((data << 1) & 0x06);
5496               chr8(space->machine, state->mmc_vrom_bank[0], CHRROM);
5497               break;
5498            case 0x07:
5499               sachen_set_mirror(space->machine, BIT(data, 0));
5500               break;
5501            default:
5502               break;
5503         }
5504      }
5505   }
5506}
5507
5508/*************************************************************
5509 
5510 Sachen S8259 bootleg boards
5511 
5512 iNES: mapper 141 (A), 138 (B), 139 (C), 137 (D)
5513 
5514 *************************************************************/
5515
5516static void common_s8259_write_handler( const address_space *space, offs_t offset, UINT8 data, int board )
5517{
5518   nes_state *state = (nes_state *)space->machine->driver_data;
5519   UINT8 bank_helper1, bank_helper2, shift, add1, add2, add3;
5520
5521   /* write happens only if we are at 0x4100 + k * 0x200, but 0x4100 is offset = 0 */
5522   if (!(offset & 0x100))
5523   {
5524      if (!(offset & 0x01))
5525         state->mmc_latch1 = data & 0x07;
5526      else
5527      {
5528         state->sachen_reg[state->mmc_latch1] = data;
5529         
5530         switch (state->mmc_latch1)
5531         {
5532            case 0x05:
5533               prg32(space->machine, data);
5534               break;
5535            case 0x07:
5536               sachen_set_mirror(space->machine, BIT(data, 0) ? 0 : (data >> 1) & 0x03);
5537               break;
5538            default:
5539               if (board == SACHEN_8259D)
5540               {
5541                  if (state->mmc_chr_source == CHRROM)
5542                  {
5543                     chr1_0(space->machine, (state->sachen_reg[0] & 0x07), CHRROM);
5544                     chr1_1(space->machine, (state->sachen_reg[1] & 0x07) | (state->sachen_reg[4] << 4 & 0x10), CHRROM);
5545                     chr1_2(space->machine, (state->sachen_reg[2] & 0x07) | (state->sachen_reg[4] << 3 & 0x10), CHRROM);
5546                     chr1_3(space->machine, (state->sachen_reg[3] & 0x07) | (state->sachen_reg[4] << 2 & 0x10) | (state->sachen_reg[6] << 3 & 0x08), CHRROM);
5547                  }
5548               }
5549               else
5550               {
5551                  bank_helper1 = state->sachen_reg[7] & 0x01;
5552                  bank_helper2 = (state->sachen_reg[4] & 0x07) << 3;
5553                  shift = (board == SACHEN_8259A) ? 1 : (board == SACHEN_8259C) ? 2 : 0;
5554                  add1 = (board == SACHEN_8259B) ? 0 : 1;
5555                  add2 = (board == SACHEN_8259C) ? 2 : 0;
5556                  add3 = (board == SACHEN_8259A) ? 1 : (board == SACHEN_8259C) ? 3 : 0;
5557                 
5558                  if (state->mmc_chr_source == CHRROM)
5559                  {
5560                     chr2_0(space->machine, ((state->sachen_reg[bank_helper1 ? 0 : 0] & 0x07) | bank_helper2) << shift, CHRROM);
5561                     chr2_2(space->machine, ((state->sachen_reg[bank_helper1 ? 0 : 1] & 0x07) | bank_helper2) << shift | add1, CHRROM);
5562                     chr2_4(space->machine, ((state->sachen_reg[bank_helper1 ? 0 : 2] & 0x07) | bank_helper2) << shift | add2, CHRROM);
5563                     chr2_6(space->machine, ((state->sachen_reg[bank_helper1 ? 0 : 3] & 0x07) | bank_helper2) << shift | add3, CHRROM);
5564                  }
5565               }
5566               break;
5567         }
5568      }
5569   }
5570}
5571
5572static WRITE8_HANDLER( s8259_l_w )
5573{
5574   nes_state *state = (nes_state *)space->machine->driver_data;
5575   LOG_MMC(("s8259_w, type: %d, offset: %04x, data: %02x\n", state->pcb_id, offset, data));
5576   
5577   common_s8259_write_handler(space, offset, data, state->pcb_id);
5578}
5579
5580static WRITE8_HANDLER( s8259_m_w )
5581{
5582   nes_state *state = (nes_state *)space->machine->driver_data;
5583   LOG_MMC(("s8259_w, type: %d, offset: %04x, data: %02x\n", state->pcb_id, offset, data));
5584   
5585   common_s8259_write_handler(space, (offset + 0x100) & 0xfff, data, state->pcb_id);
5586}
5587
5588
5589/*************************************************************
5590 
5591 Sachen SA0036 bootleg boards
5592 
5593 iNES: mapper 149
5594 
5595 *************************************************************/
5596
5597static WRITE8_HANDLER( sa0036_w )
5598{
5599   LOG_MMC(("sa0036_w, offset: %04x, data: %02x\n", offset, data));
5600   
5601   chr8(space->machine, data >> 7, CHRROM);
5602}
5603
5604/*************************************************************
5605 
5606 Sachen SA0037 bootleg boards
5607 
5608 iNES: mapper 148
5609 
5610 *************************************************************/
5611
5612static WRITE8_HANDLER( sa0037_w )
5613{
5614   LOG_MMC(("sa0037_w, offset: %04x, data: %02x\n", offset, data));
5615   
5616   prg32(space->machine, data >> 3);
5617   chr8(space->machine, data, CHRROM);
5618}
5619
5620/*************************************************************
5621 
5622 Sachen SA72007 bootleg boards
5623 
5624 iNES: mapper 145
5625 
5626 *************************************************************/
5627
5628static WRITE8_HANDLER( sa72007_l_w )
5629{
5630   LOG_MMC(("sa72007_l_w, offset: %04x, data: %02x\n", offset, data));
5631   
5632   /* only if we are at 0x4100 + k * 0x200, but 0x4100 is offset = 0 */
5633   if (!(offset & 0x100))
5634      chr8(space->machine, data >> 7, CHRROM);
5635}
5636
5637/*************************************************************
5638 
5639 Sachen SA72008 bootleg boards
5640 
5641 iNES: mapper 133
5642 
5643 *************************************************************/
5644
5645static WRITE8_HANDLER( sa72008_l_w )
5646{
5647   LOG_MMC(("sa72008_l_w, offset: %04x, data: %02x\n", offset, data));
5648   
5649   prg32(space->machine, data >> 2);
5650   chr8(space->machine, data, CHRROM);
5651}
5652
5653/*************************************************************
5654 
5655 Sachen TCA-01 bootleg boards
5656 
5657 iNES: mapper 143
5658 
5659 *************************************************************/
5660
5661static READ8_HANDLER( tca01_l_r )
5662{
5663   LOG_MMC(("tca01_l_r, offset: %04x\n", offset));
5664   
5665   /* the address is read only if we are at 0x4100 + k * 0x200, but 0x4100 is offset = 0 */
5666   if (!(offset & 0x100))
5667      return (~offset & 0x3f) | 0x40;
5668   else
5669      return 0x00;
5670}
5671
5672/*************************************************************
5673 
5674 Sachen TCU-01 bootleg boards
5675 
5676 iNES: mapper 147
5677 
5678 *************************************************************/
5679
5680static WRITE8_HANDLER( tcu01_l_w )
5681{
5682   LOG_MMC(("tcu01_l_w, offset: %04x, data: %02x\n", offset, data));
5683   
5684   if ((offset & 0x103) == 0x002)
5685   {
5686      prg32(space->machine, ((data >> 6) & 0x02) | ((data >> 2) & 0x01));
5687      chr8(space->machine, data >> 3, CHRROM);
5688   }
5689}
5690
5691static WRITE8_HANDLER( tcu01_m_w )
5692{
5693   LOG_MMC(("tcu01_m_w, offset: %04x, data: %02x\n", offset, data));
5694   
5695   tcu01_l_w(space, (offset + 0x100) & 0xfff, data);
5696}
5697
5698static WRITE8_HANDLER( tcu01_w )
5699{
5700   LOG_MMC(("tcu01_w, offset: %04x, data: %02x\n", offset, data));
5701   
5702   tcu01_l_w(space, (offset + 0x100) & 0xfff, data);
5703}
5704
5705/*************************************************************
5706 
5707 Sachen TCU-02 bootleg boards
5708 
5709 iNES: mapper 136
5710 
5711 *************************************************************/
5712
5713static WRITE8_HANDLER( tcu02_l_w )
5714{
5715   nes_state *state = (nes_state *)space->machine->driver_data;
5716   LOG_MMC(("tcu02_l_w, offset: %04x, data: %02x\n", offset, data));
5717   
5718   if ((offset & 0x103) == 0x002)
5719   {
5720      state->mmc_latch1 = (data & 0x30) | ((data + 3) & 0x0f);
5721      chr8(space->machine, state->mmc_latch1, CHRROM);
5722   }
5723}
5724
5725static READ8_HANDLER( tcu02_l_r )
5726{
5727   nes_state *state = (nes_state *)space->machine->driver_data;
5728   LOG_MMC(("tcu02_l_r, offset: %04x\n", offset));
5729   
5730   if ((offset & 0x103) == 0x000)
5731      return state->mmc_latch1 | 0x40;
5732   else
5733      return 0x00;
5734}
5735
5736
5737/*************************************************************
5738 
5739 Subor bootleg board Type 0
5740 
5741 iNES: mapper 167
5742 
5743 *************************************************************/
5744
5745static WRITE8_HANDLER( subor0_w )
5746{
5747   nes_state *state = (nes_state *)space->machine->driver_data;
5748   UINT8 subor_helper1, subor_helper2;
5749   LOG_MMC(("subor0_w, offset: %04x, data: %02x\n", offset, data));
5750   
5751   state->subor_reg[(offset >> 13) & 0x03] = data;
5752   subor_helper1 = ((state->subor_reg[0] ^ state->subor_reg[1]) << 1) & 0x20;
5753   subor_helper2 = ((state->subor_reg[2] ^ state->subor_reg[3]) << 0) & 0x1f;
5754   
5755   if (state->subor_reg[1] & 0x08)
5756   {
5757      subor_helper1 += subor_helper2 & 0xfe;
5758      subor_helper2 = subor_helper1;
5759      subor_helper1 += 1;
5760   }
5761   else if (state->subor_reg[1] & 0x04)
5762   {
5763      subor_helper2 += subor_helper1;
5764      subor_helper1 = 0x1f;
5765   }
5766   else
5767   {
5768      subor_helper1 += subor_helper2;
5769      subor_helper2 = 0x20;
5770   }
5771   
5772   prg16_89ab(space->machine, subor_helper1);
5773   prg16_cdef(space->machine, subor_helper2);
5774}
5775
5776/*************************************************************
5777 
5778 Subor bootleg board Type 1
5779 
5780 iNES: mapper 166
5781 
5782 *************************************************************/
5783
5784static WRITE8_HANDLER( subor1_w )
5785{
5786   nes_state *state = (nes_state *)space->machine->driver_data;
5787   UINT8 subor_helper1, subor_helper2;
5788   LOG_MMC(("subor1_w, offset: %04x, data: %02x\n", offset, data));
5789   
5790   state->subor_reg[(offset >> 13) & 0x03] = data;
5791   subor_helper1 = ((state->subor_reg[0] ^ state->subor_reg[1]) << 1) & 0x20;
5792   subor_helper2 = ((state->subor_reg[2] ^ state->subor_reg[3]) << 0) & 0x1f;
5793   
5794   if (state->subor_reg[1] & 0x08)
5795   {
5796      subor_helper1 += subor_helper2 & 0xfe;
5797      subor_helper2 = subor_helper1;
5798      subor_helper2 += 1;
5799   }
5800   else if (state->subor_reg[1] & 0x04)
5801   {
5802      subor_helper2 += subor_helper1;
5803      subor_helper1 = 0x1f;
5804   }
5805   else
5806   {
5807      subor_helper1 += subor_helper2;
5808      subor_helper2 = 0x07;
5809   }
5810   
5811   prg16_89ab(space->machine, subor_helper1);
5812   prg16_cdef(space->machine, subor_helper2);
5813}
5814
5815/*************************************************************
5816 
5817 Bootleg Board by Super Game
5818
5819 Games: Boogerman, Mortal Kombat III
5820 
5821 MMC3 clone. Also, it probably needs a hack to support both
5822 variants (Boogerman & MK3).
5823 
5824 iNES: mapper 215
5825 
5826 In MESS: Preliminary support.
5827 
5828 *************************************************************/
5829
5830// remove mask & base parameters!
5831static void sgame_boog_set_prg( running_machine *machine, int prg_base, int prg_mask )
5832{
5833   nes_state *state = (nes_state *)machine->driver_data;
5834   if (state->map215_reg[0] & 0x80)
5835   {
5836      prg16_89ab(machine, (state->map215_reg[0] & 0xf0) | (state->map215_reg[1] & 0x10));
5837      prg16_cdef(machine, (state->map215_reg[0] & 0xf0) | (state->map215_reg[1] & 0x10));
5838   }
5839   else
5840   {
5841      state->mmc_prg_base = (state->map215_reg[1] & 0x08) ? 0x20 : (state->map215_reg[1] & 0x10);
5842      state->mmc_prg_mask = (state->map215_reg[1] & 0x08) ? 0x1f : 0x0f;
5843     
5844      mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
5845   }
5846}
5847
5848static void sgame_boog_set_chr( running_machine *machine, UINT8 chr )
5849{
5850   nes_state *state = (nes_state *)machine->driver_data;
5851   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
5852   int chr_base = (state->map215_reg[1] & 0x04) ? 0x100 : ((state->map215_reg[1] & 0x10) << 3);
5853   int chr_mask = (state->map215_reg[1] & 0x04) ? 0xff : 0x7f;
5854   
5855   chr1_x(machine, chr_page ^ 0, chr_base | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), chr);
5856   chr1_x(machine, chr_page ^ 1, chr_base | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), chr);
5857   chr1_x(machine, chr_page ^ 2, chr_base | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), chr);
5858   chr1_x(machine, chr_page ^ 3, chr_base | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), chr);
5859   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr);
5860   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), chr);
5861   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), chr);
5862   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), chr);
5863}
5864
5865static WRITE8_HANDLER( sgame_boog_l_w )
5866{
5867   nes_state *state = (nes_state *)space->machine->driver_data;
5868   LOG_MMC(("sgame_boog_l_w, offset: %04x, data: %02x\n", offset, data));
5869   offset += 0x100;
5870   
5871   if (offset == 0x1000)
5872   {
5873      state->map215_reg[0] = data;
5874      sgame_boog_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5875   }
5876   else if (offset == 0x1001)
5877   {
5878      state->map215_reg[1] = data;
5879      sgame_boog_set_chr(space->machine, state->mmc_chr_source);
5880   }
5881   else if (offset == 0x1007)
5882   {
5883      state->mmc_latch1 = 0;
5884      state->map215_reg[2] = data;
5885      sgame_boog_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5886      sgame_boog_set_chr(space->machine, state->mmc_chr_source);
5887   }
5888}
5889
5890static WRITE8_HANDLER( sgame_boog_w )
5891{
5892   nes_state *state = (nes_state *)space->machine->driver_data;
5893   UINT8 MMC3_helper, cmd;
5894   static const UINT8 conv_table[8] = {0,2,5,3,6,1,7,4};
5895   LOG_MMC(("sgame_boog_w, offset: %04x, data: %02x\n", offset, data));
5896   
5897   if (!state->map215_reg[2]) // in this case we act like MMC3, only with alt prg/chr handlers
5898   {
5899      switch (offset & 0x6001)
5900      {
5901         case 0x0000:
5902            MMC3_helper = state->mmc_latch1 ^ data;
5903            state->mmc_latch1 = data;
5904           
5905            /* Has PRG Mode changed? */
5906            if (MMC3_helper & 0x40)
5907               sgame_boog_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5908           
5909            /* Has CHR Mode changed? */
5910            if (MMC3_helper & 0x80)
5911               sgame_boog_set_chr(space->machine, state->mmc_chr_source);
5912            break;
5913           
5914         case 0x0001:
5915            cmd = state->mmc_latch1 & 0x07;
5916            switch (cmd)
5917         {
5918            case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
5919            case 2: case 3: case 4: case 5:
5920               state->mmc_vrom_bank[cmd] = data;
5921               sgame_boog_set_chr(space->machine, state->mmc_chr_source);
5922               break;
5923            case 6:
5924            case 7:
5925               state->mmc_prg_bank[cmd - 6] = data;
5926               sgame_boog_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5927               break;
5928         }
5929            break;
5930           
5931         default:
5932            txrom_w(space, offset, data);
5933            break;
5934      }
5935   }
5936   else
5937   {
5938      switch (offset & 0x6001)
5939      {
5940         case 0x0000:
5941            break;
5942           
5943         case 0x0001:
5944            cmd = state->mmc_latch1 & 0x07;
5945            if (state->map215_reg[3] && ((state->map215_reg[0] & 0x80) == 0 || cmd < 6))   // if we use the prg16 banks and cmd=6,7 DON'T enter!
5946            {
5947               state->map215_reg[3] = 0;
5948               switch (cmd)
5949               {
5950                  case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
5951                  case 2: case 3: case 4: case 5:
5952                     state->mmc_vrom_bank[cmd] = data;
5953                     sgame_boog_set_chr(space->machine, state->mmc_chr_source);
5954                     break;
5955                  case 6:
5956                  case 7:
5957                     state->mmc_prg_bank[cmd - 6] = data;
5958                     sgame_boog_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5959                     break;
5960               }
5961            }
5962            break;
5963           
5964         case 0x2000:
5965            data = (data & 0xc0) | conv_table[data & 0x07];
5966            MMC3_helper = state->mmc_latch1 ^ data;
5967            state->mmc_latch1 = data;
5968           
5969            /* Has PRG Mode changed? */
5970            if (MMC3_helper & 0x40)
5971               sgame_boog_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
5972           
5973            /* Has CHR Mode changed? */
5974            if (MMC3_helper & 0x80)
5975               sgame_boog_set_chr(space->machine, state->mmc_chr_source);
5976           
5977            state->map215_reg[3] = 1;
5978            break;
5979           
5980            //      case 0x2001:
5981            //          txrom_w(space, 0x4001, data);
5982            //          break;
5983           
5984         case 0x4000:
5985            set_nt_mirroring(space->machine, ((data >> 7) | data) & 0x01 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
5986            break;
5987           
5988         case 0x4001:
5989            txrom_w(space, 0x6001, data);
5990            break;
5991           
5992            //      case 0x6000:
5993            //          txrom_w(space, 0x6000, data);
5994            //          break;
5995           
5996         case 0x6001:
5997            txrom_w(space, 0x4000, data);
5998            txrom_w(space, 0x4001, data);
5999            break;
6000           
6001         default:
6002            txrom_w(space, offset, data);
6003            break;
6004      }
6005   }
6006}
6007
6008/*************************************************************
6009 
6010 Bootleg Board by Super Game
6011 
6012 Games: The Lion King
6013 
6014 MMC3 clone.
6015 
6016 iNES: mapper 114
6017 
6018 In MESS: Supported.
6019 
6020 *************************************************************/
6021
6022static WRITE8_HANDLER( sgame_lion_m_w )
6023{
6024   nes_state *state = (nes_state *)space->machine->driver_data;
6025   LOG_MMC(("sgame_lion_m_w, offset: %04x, data: %02x\n", offset, data));
6026   
6027   state->map114_reg = data;
6028   
6029   if (state->map114_reg & 0x80)
6030   {
6031      prg16_89ab(space->machine, data & 0x1f);
6032      prg16_cdef(space->machine, data & 0x1f);
6033   }
6034   else
6035      mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6036   
6037}
6038
6039static WRITE8_HANDLER( sgame_lion_w )
6040{
6041   nes_state *state = (nes_state *)space->machine->driver_data;
6042   static const UINT8 conv_table[8] = {0, 3, 1, 5, 6, 7, 2, 4};
6043   LOG_MMC(("sgame_lion_w, offset: %04x, data: %02x\n", offset, data));
6044   
6045   if (offset < 0x6000)
6046   {
6047      switch (offset & 0x6000)
6048      {
6049         case 0x0000:
6050            set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
6051            break;
6052         case 0x2000:
6053            state->map114_reg_enabled = 1;
6054            data = (data & 0xc0) | conv_table[data & 0x07];
6055            txrom_w(space, 0x8000, data);
6056            break;
6057         case 0x4000:
6058            if (state->map114_reg_enabled && (state->map114_reg & 0x80) == 0)
6059            {
6060               state->map114_reg_enabled = 0;
6061               txrom_w(space, 0x8001, data);
6062            }
6063            break;
6064      }
6065   }
6066   else
6067   {
6068      switch (offset & 0x03)
6069      {
6070         case 0x02:
6071            txrom_w(space, 0xe000, data);
6072            break;
6073         case 0x03:
6074            txrom_w(space, 0xe001, data);
6075            txrom_w(space, 0xc000, data);
6076            txrom_w(space, 0xc001, data);
6077            break;
6078      }
6079   }
6080}
6081
6082/*************************************************************
6083 
6084 Tengen 800032 Board
6085
6086 Games: Klax, Road Runner, Rolling Thunder, Shinobi, Skulls
6087 & Croosbones, Xybots
6088 
6089 iNES: mapper 64
6090 
6091 In MESS: Partially Supported.
6092 
6093 *************************************************************/
6094
6095static void tengen_800032_irq( running_device *device, int scanline, int vblank, int blanked )
6096{
6097   nes_state *state = (nes_state *)device->machine->driver_data;
6098   if (!state->IRQ_mode)   // we are in scanline mode!
6099   {
6100      if (scanline < PPU_BOTTOM_VISIBLE_SCANLINE)
6101      {
6102         if (!state->IRQ_reset)
6103         {
6104            if (!state->IRQ_count)
6105               state->IRQ_count = state->IRQ_count_latch;
6106            else
6107            {
6108               state->IRQ_count--;
6109               if (state->IRQ_enable && !blanked && !state->IRQ_count)
6110               {
6111                  LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
6112                         video_screen_get_vpos(device->machine->primary_screen), video_screen_get_hpos(device->machine->primary_screen)));
6113                  cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
6114               }
6115            }
6116         }
6117         else
6118         {
6119            state->IRQ_reset = 0;
6120            state->IRQ_count = state->IRQ_count_latch + 1;
6121         }
6122      }
6123   }
6124   /* otherwise, we are in CPU cycles mode --> decrement count of 114 every scanline
6125     --> in the meanwhile anything can have happened to IRQ_reset and we would not know
6126     --> Skulls and Crossbones does not show anything!! */
6127   else
6128   {
6129      //      if (!state->IRQ_reset)
6130      {
6131         if (state->IRQ_count <= 114)
6132            state->IRQ_count = state->IRQ_count_latch;
6133         else
6134         {
6135            state->IRQ_count -= 114;
6136            if (state->IRQ_enable && !blanked && (state->IRQ_count <= 114))
6137            {
6138               LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
6139                      video_screen_get_vpos(device->machine->primary_screen), video_screen_get_hpos(device->machine->primary_screen)));
6140               cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
6141            }
6142         }
6143      }
6144      //      else
6145      //      {
6146      //          state->IRQ_reset = 0;
6147      //          state->IRQ_count = state->IRQ_count_latch + 1;
6148      //      }
6149   }
6150}
6151
6152static void tengen_800032_set_prg( running_machine *machine )
6153{
6154   nes_state *state = (nes_state *)machine->driver_data;
6155   UINT8 prg_mode = state->mmc_latch1 & 0x40;
6156   
6157   prg8_89(machine, state->mmc_prg_bank[prg_mode ? 2: 0]);
6158   prg8_ab(machine, state->mmc_prg_bank[prg_mode ? 0: 1]);
6159   prg8_cd(machine, state->mmc_prg_bank[prg_mode ? 1: 2]);
6160}
6161
6162static void tengen_800032_set_chr( running_machine *machine )
6163{
6164   nes_state *state = (nes_state *)machine->driver_data;
6165   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
6166   
6167   if (state->mmc_latch1 & 0x20)
6168   {
6169      chr1_x(machine, 0 ^ chr_page, state->mmc_vrom_bank[0], CHRROM);
6170      chr1_x(machine, 1 ^ chr_page, state->mmc_vrom_bank[8], CHRROM);
6171      chr1_x(machine, 2 ^ chr_page, state->mmc_vrom_bank[1], CHRROM);
6172      chr1_x(machine, 3 ^ chr_page, state->mmc_vrom_bank[9], CHRROM);
6173   }
6174   else
6175   {
6176      chr1_x(machine, 0 ^ chr_page, state->mmc_vrom_bank[0] & ~0x01, CHRROM);
6177      chr1_x(machine, 1 ^ chr_page, state->mmc_vrom_bank[0] |  0x01, CHRROM);
6178      chr1_x(machine, 2 ^ chr_page, state->mmc_vrom_bank[1] & ~0x01, CHRROM);
6179      chr1_x(machine, 3 ^ chr_page, state->mmc_vrom_bank[1] |  0x01, CHRROM);
6180   }
6181   
6182   chr1_x(machine, 4 ^ chr_page, state->mmc_vrom_bank[2], CHRROM);
6183   chr1_x(machine, 5 ^ chr_page, state->mmc_vrom_bank[3], CHRROM);
6184   chr1_x(machine, 6 ^ chr_page, state->mmc_vrom_bank[4], CHRROM);
6185   chr1_x(machine, 7 ^ chr_page, state->mmc_vrom_bank[5], CHRROM);
6186}
6187
6188static WRITE8_HANDLER( tengen_800032_w )
6189{
6190   nes_state *state = (nes_state *)space->machine->driver_data;
6191   UINT8 map64_helper, cmd;
6192   LOG_MMC(("tengen_800032_w, offset: %04x, data: %02x\n", offset, data));
6193   
6194   switch (offset & 0x6001)
6195   {
6196      case 0x0000:
6197         map64_helper = state->mmc_latch1 ^ data;
6198         state->mmc_latch1 = data;
6199         
6200         /* Has PRG Mode changed? */
6201         if (map64_helper & 0x40)
6202            tengen_800032_set_prg(space->machine);
6203         
6204         /* Has CHR Mode changed? */
6205         if (map64_helper & 0xa0)
6206            tengen_800032_set_chr(space->machine);
6207         break;
6208         
6209      case 0x0001:
6210         cmd = state->mmc_latch1 & 0x0f;
6211         switch (cmd)
6212      {
6213         case 0: case 1:
6214         case 2: case 3:
6215         case 4: case 5:
6216            state->mmc_vrom_bank[cmd] = data;
6217            tengen_800032_set_chr(space->machine);
6218            break;
6219         case 6: case 7:
6220            state->mmc_prg_bank[cmd - 6] = data;
6221            tengen_800032_set_prg(space->machine);
6222            break;
6223         case 8: case 9:
6224            state->mmc_vrom_bank[cmd - 2] = data;
6225            tengen_800032_set_chr(space->machine);
6226            break;
6227         case 0x0f:
6228            state->mmc_prg_bank[2] = data;
6229            tengen_800032_set_prg(space->machine);
6230            break;
6231      }
6232         break;
6233         
6234      case 0x2000:
6235         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
6236         break;
6237         
6238      case 0x4000:
6239         state->IRQ_count_latch = data;
6240         break;
6241         
6242      case 0x4001: /* $c001 - IRQ scanline latch */
6243         state->IRQ_mode = data & 0x01;
6244         state->IRQ_reset = 1;
6245         break;
6246         
6247      case 0x6000:
6248         state->IRQ_enable = 0;
6249         break;
6250         
6251      case 0x6001:
6252         state->IRQ_enable = 1;
6253         break;
6254         
6255      default:
6256         LOG_MMC(("Mapper 64 write. addr: %04x value: %02x\n", offset + 0x8000, data));
6257         break;
6258   }
6259}
6260
6261/*************************************************************
6262 
6263 Tengen 800037 Board
6264 
6265 Games: Alien Syndrome
6266 
6267 iNES: mapper 158
6268 
6269 In MESS: Very preliminary support.
6270 
6271 *************************************************************/
6272
6273// probably wrong...
6274static void tengen_800037_set_mirror( running_machine *machine )
6275{
6276   nes_state *state = (nes_state *)machine->driver_data;
6277   UINT8 nt_mode = state->mmc_latch1 & 0x80;
6278   
6279   set_nt_page(machine, 0, ROM, state->mmc_vrom_bank[nt_mode ? 2 : 0], 0);
6280   set_nt_page(machine, 1, ROM, state->mmc_vrom_bank[nt_mode ? 3 : 0], 0);
6281   set_nt_page(machine, 2, ROM, state->mmc_vrom_bank[nt_mode ? 4 : 1], 0);
6282   set_nt_page(machine, 3, ROM, state->mmc_vrom_bank[nt_mode ? 5 : 1], 0);
6283}
6284
6285static WRITE8_HANDLER( tengen_800037_w )
6286{
6287   nes_state *state = (nes_state *)space->machine->driver_data;
6288   UINT8 map158_helper, cmd;
6289   LOG_MMC(("tengen_800037_w, offset: %04x, data: %02x\n", offset, data));
6290   
6291   switch (offset & 0x6001)
6292   {
6293      case 0x0000:
6294         map158_helper = state->mmc_latch1 ^ data;
6295         state->mmc_latch1 = data;
6296         
6297         /* Has PRG Mode changed? */
6298         if (map158_helper & 0x40)
6299            tengen_800032_set_prg(space->machine);
6300         
6301         /* Has CHR Mode changed? */
6302         if (map158_helper & 0xa0)
6303         {
6304            tengen_800032_set_chr(space->machine);
6305            tengen_800037_set_mirror(space->machine);
6306         }
6307         break;
6308         
6309      case 0x0001:
6310         cmd = state->mmc_latch1 & 0x0f;
6311         switch (cmd)
6312      {
6313         case 0: case 1:
6314         case 2: case 3:
6315         case 4: case 5:
6316            state->mmc_vrom_bank[cmd] = data;
6317            tengen_800032_set_chr(space->machine);
6318            tengen_800037_set_mirror(space->machine);
6319            break;
6320         case 6: case 7:
6321            state->mmc_prg_bank[cmd - 6] = data;
6322            tengen_800032_set_prg(space->machine);
6323            break;
6324         case 8: case 9:
6325            state->mmc_vrom_bank[cmd - 2] = data;
6326            tengen_800032_set_chr(space->machine);
6327            tengen_800037_set_mirror(space->machine);
6328            break;
6329         case 0x0f:
6330            state->mmc_prg_bank[2] = data;
6331            tengen_800032_set_prg(space->machine);
6332            break;
6333      }
6334         break;
6335         
6336      case 0x2000:
6337         break;
6338         
6339      default:
6340         tengen_800032_w(space, offset, data);
6341         break;
6342   }
6343}
6344
6345/*************************************************************
6346 
6347 Bootleg Board 22211 by TXC (Type A)
6348
6349 Games: Creatom
6350 
6351 Info from NEStopia: this mapper features write to four
6352 registers (0x4100-0x4103). The third one is used to select
6353 PRG and CHR banks.
6354 
6355 iNES: mapper 132
6356 
6357 In MESS: Supported.
6358 
6359 *************************************************************/
6360
6361static WRITE8_HANDLER( txc_22211_l_w )
6362{
6363   nes_state *state = (nes_state *)space->machine->driver_data;
6364   LOG_MMC(("txc_22211_l_w, offset: %04x, data: %02x\n", offset, data));
6365   
6366   if (offset < 4)
6367      state->txc_reg[offset & 0x03] = data;
6368}
6369
6370static READ8_HANDLER( txc_22211_l_r )
6371{
6372   nes_state *state = (nes_state *)space->machine->driver_data;
6373   LOG_MMC(("txc_22211_l_r, offset: %04x\n", offset));
6374   
6375   if (offset == 0x0000)
6376      return (state->txc_reg[1] ^ state->txc_reg[2]) | 0x40;
6377   else
6378      return 0x00;
6379}
6380
6381static WRITE8_HANDLER( txc_22211_w )
6382{
6383   nes_state *state = (nes_state *)space->machine->driver_data;
6384   LOG_MMC(("txc_22211_w, offset: %04x, data: %02x\n", offset, data));
6385   
6386   prg32(space->machine, state->txc_reg[2] >> 2);
6387   chr8(space->machine, state->txc_reg[2], CHRROM);
6388}
6389
6390/*************************************************************
6391 
6392 Bootleg Board 22211 by TXC (Type B)
6393 
6394 Games: 1991 Du Ma Racing
6395 
6396 This mapper is basically the same as Type A. Only difference is
6397 in the way CHR banks are selected (see below)
6398 
6399 iNES: mapper 172
6400 
6401 In MESS: Supported.
6402 
6403 *************************************************************/
6404
6405static WRITE8_HANDLER( txc_22211b_w )
6406{
6407   nes_state *state = (nes_state *)space->machine->driver_data;
6408   LOG_MMC(("txc_22211b_w, offset: %04x, data: %02x\n", offset, data));
6409   
6410   prg32(space->machine, state->txc_reg[2] >> 2);
6411   chr8(space->machine, (((data ^ state->txc_reg[2]) >> 3) & 0x02) | (((data ^ state->txc_reg[2]) >> 5) & 0x01), CHRROM);
6412}
6413
6414/*************************************************************
6415 
6416 Bootleg Board 22211 by TXC (Type C)
6417 
6418 Games: Mahjong Block, Xiao Ma Li
6419 
6420 This mapper is basically the same as 132 too. Only difference is
6421 in 0x4100 reads which expect also bit 0 to be set
6422 
6423 iNES: mapper 172
6424 
6425 In MESS: Supported.
6426 
6427 *************************************************************/
6428
6429static READ8_HANDLER( txc_22211c_l_r )
6430{
6431   nes_state *state = (nes_state *)space->machine->driver_data;
6432   LOG_MMC(("txc_22211c_l_r, offset: %04x\n", offset));
6433   
6434   if (offset == 0x0000)
6435      return (state->txc_reg[1] ^ state->txc_reg[2]) | 0x41;
6436   else
6437      return 0x00;
6438}
6439
6440/*************************************************************
6441 
6442 Bootleg Board 'Thunder Warrior' by TXC
6443
6444 Games: Master Fighter II, Master Fighter 3, Thunder Warrior
6445 
6446 MMC3 clone
6447 
6448 iNES: mapper 189
6449 
6450 In MESS: Supported.
6451 
6452 *************************************************************/
6453
6454static WRITE8_HANDLER( txc_tw_l_w )
6455{
6456   LOG_MMC(("txctw_l_w, offset: %04x, data: %02x\n", offset, data));
6457   
6458   prg32(space->machine, (data >> 4) | data);
6459}
6460
6461static WRITE8_HANDLER( txc_tw_m_w )
6462{
6463   LOG_MMC(("txctw_m_w, offset: %04x, data: %04x\n", offset, data));
6464   
6465   txc_tw_l_w(space, offset & 0xff, data);   // offset does not really count for this mapper
6466}
6467
6468/* This is like mmc3 but with no PRG bankswitch (beacuse it is handled by low writes) */
6469static WRITE8_HANDLER( txc_tw_w )
6470{
6471   nes_state *state = (nes_state *)space->machine->driver_data;
6472   UINT8 MMC3_helper, cmd;
6473   LOG_MMC(("txctw_w, offset: %04x, data: %02x\n", offset, data));
6474   
6475   switch (offset & 0x6001)
6476   {
6477      case 0x0000:
6478         MMC3_helper = state->mmc_latch1 ^ data;
6479         state->mmc_latch1 = data;
6480         
6481         /* Has CHR Mode changed? */
6482         if (MMC3_helper & 0x80)
6483            mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
6484         break;
6485         
6486      case 0x0001:
6487         cmd = state->mmc_latch1 & 0x07;
6488         switch (cmd)
6489         {
6490         case 0: case 1:
6491         case 2: case 3: case 4: case 5:
6492            state->mmc_vrom_bank[cmd] = data;
6493            mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
6494            break;
6495         }
6496         break;
6497         
6498      default:
6499         txrom_w(space, offset, data);
6500         break;
6501   }
6502}
6503
6504/*************************************************************
6505 
6506 Bootleg Board MXMDHTWO by TXC
6507
6508 Games: Commandos, Journey to the West, Ma Bu Mi Zhen &
6509 Qu Wei Cheng Yu Wu, Si Lu Chuan Qi
6510 
6511 Simple Mapper: writes to 0x8000-0xffff sets the prg32 bank.
6512 Not sure if returning 0x50 for reads in 0x4100-0x5000 is correct.
6513 
6514 iNES: mapper 241
6515 
6516 In MESS: Supported.
6517 
6518 *************************************************************/
6519
6520static READ8_HANDLER( txc_mxmdhtwo_l_r )
6521{
6522   return 0x50;
6523}
6524
6525static WRITE8_HANDLER( txc_mxmdhtwo_w )
6526{
6527   LOG_MMC(("txc_mxmdhtwo_w, offset: %04x, data: %02x\n", offset, data));
6528   
6529   prg32(space->machine, data);
6530}
6531
6532/*************************************************************
6533 
6534 Waixing Board Type A
6535
6536 Games: Columbus - Ougon no Yoake (C), Ji Jia Zhan Shi,
6537 Jia A Fung Yun, Wei Luo Chuan Qi
6538 
6539 This mapper is quite similar to MMC3, but with two differences:
6540 mirroring is not the same, and when VROM banks 8,9 are accessed
6541 they point to CHRRAM and not CHRROM.
6542 
6543 iNES: mapper 74
6544 
6545 In MESS: Supported
6546 
6547 *************************************************************/
6548
6549#if 0
6550/* MIRROR_LOW and MIRROR_HIGH are swapped! */
6551static void waixing_set_mirror( running_machine *machine, UINT8 nt )
6552{
6553   switch (nt)
6554   {
6555      case 0:
6556      case 1:
6557         set_nt_mirroring(machine, nt ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
6558         break;
6559      case 2:
6560         set_nt_mirroring(machine, PPU_MIRROR_LOW);
6561         break;
6562      case 3:
6563         set_nt_mirroring(machine, PPU_MIRROR_HIGH);
6564         break;
6565      default:
6566         LOG_MMC(("Mapper set NT to invalid value %02x", nt));
6567         break;
6568   }
6569}
6570#endif
6571
6572static void waixing_a_set_chr( running_machine *machine, int chr_base, int chr_mask )
6573{
6574   nes_state *state = (nes_state *)machine->driver_data;
6575   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
6576   UINT8 chr_src[6];
6577   int i;
6578   
6579   for (i = 0; i < 6; i++)
6580      chr_src[i] = ((state->mmc_vrom_bank[i] == 8) || (state->mmc_vrom_bank[i] == 9)) ? CHRRAM : CHRROM;
6581   
6582   chr1_x(machine, chr_page ^ 0, chr_base | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), chr_src[0]);
6583   chr1_x(machine, chr_page ^ 1, chr_base | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), chr_src[0]);
6584   chr1_x(machine, chr_page ^ 2, chr_base | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), chr_src[1]);
6585   chr1_x(machine, chr_page ^ 3, chr_base | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), chr_src[1]);
6586   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr_src[2]);
6587   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), chr_src[3]);
6588   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), chr_src[4]);
6589   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), chr_src[5]);
6590}
6591
6592static WRITE8_HANDLER( waixing_a_w )
6593{
6594   nes_state *state = (nes_state *)space->machine->driver_data;
6595   UINT8 MMC3_helper, cmd;
6596   LOG_MMC(("waixing_a_w, offset: %04x, data: %02x\n", offset, data));
6597   
6598   switch (offset & 0x6001)
6599   {
6600      case 0x0000:
6601         MMC3_helper = state->mmc_latch1 ^ data;
6602         state->mmc_latch1 = data;
6603         
6604         /* Has PRG Mode changed? */
6605         if (MMC3_helper & 0x40)
6606            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6607         
6608         /* Has CHR Mode changed? */
6609         if (MMC3_helper & 0x80)
6610            waixing_a_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6611         break;
6612         
6613      case 0x0001:
6614         cmd = state->mmc_latch1 & 0x07;
6615         switch (cmd)
6616         {
6617         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
6618         case 2: case 3: case 4: case 5:
6619            state->mmc_vrom_bank[cmd] = data;
6620            waixing_a_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6621            break;
6622         case 6:
6623         case 7:
6624            state->mmc_prg_bank[cmd - 6] = data;
6625            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6626            break;
6627         }
6628         break;
6629         
6630      case 0x2000:
6631         waixing_set_mirror(space->machine, data);   //maybe data & 0x03?
6632         break;
6633         
6634      case 0x2001:
6635         break;
6636         
6637      default:
6638         txrom_w(space, offset, data);
6639         break;
6640   }
6641}
6642
6643/*************************************************************
6644 
6645 Waixing Board Type B
6646 
6647 Games: Sugoro Quest (C)
6648 
6649 MMC3 clone. This is a minor modification of Mapper 74,
6650 in the sense that it is the same board except for the
6651 CHRRAM pages.
6652 
6653 iNES: mapper 191
6654 
6655 In MESS: Supported.
6656 
6657 *************************************************************/
6658
6659static void waixing_b_set_chr( running_machine *machine, int chr_base, int chr_mask )
6660{
6661   nes_state *state = (nes_state *)machine->driver_data;
6662   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
6663   UINT8 chr_src[6];
6664   int i;
6665   
6666   for (i = 0; i < 6; i++)
6667      chr_src[i] = (state->mmc_vrom_bank[i] & 0x80) ? CHRRAM : CHRROM;
6668   
6669   chr1_x(machine, chr_page ^ 0, chr_base | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), chr_src[0]);
6670   chr1_x(machine, chr_page ^ 1, chr_base | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), chr_src[0]);
6671   chr1_x(machine, chr_page ^ 2, chr_base | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), chr_src[1]);
6672   chr1_x(machine, chr_page ^ 3, chr_base | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), chr_src[1]);
6673   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr_src[2]);
6674   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), chr_src[3]);
6675   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), chr_src[4]);
6676   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), chr_src[5]);
6677}
6678
6679static WRITE8_HANDLER( waixing_b_w )
6680{
6681   nes_state *state = (nes_state *)space->machine->driver_data;
6682   UINT8 MMC3_helper, cmd;
6683   LOG_MMC(("waixing_b_w, offset: %04x, data: %02x\n", offset, data));
6684   
6685   switch (offset & 0x6001)
6686   {
6687      case 0x0000:
6688         MMC3_helper = state->mmc_latch1 ^ data;
6689         state->mmc_latch1 = data;
6690         
6691         /* Has PRG Mode changed? */
6692         if (MMC3_helper & 0x40)
6693            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6694         
6695         /* Has CHR Mode changed? */
6696         if (MMC3_helper & 0x80)
6697            waixing_b_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6698         break;
6699         
6700      case 0x0001:
6701         cmd = state->mmc_latch1 & 0x07;
6702         switch (cmd)
6703         {
6704         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
6705         case 2: case 3: case 4: case 5:
6706            state->mmc_vrom_bank[cmd] = data;
6707            waixing_b_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6708            break;
6709         case 6:
6710         case 7:
6711            state->mmc_prg_bank[cmd - 6] = data;
6712            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6713            break;
6714         }
6715         break;
6716         
6717      default:
6718         waixing_a_w(space, offset, data);
6719         break;
6720   }
6721}
6722
6723/*************************************************************
6724 
6725 Waixing Board Type C
6726 
6727 Games: Ying Lie Qun Xia Zhuan, Young Chivalry
6728 
6729 MMC3 clone. This is a minor modification of Mapper 74,
6730 in the sense that it is the same board except for the
6731 CHRRAM pages.
6732 
6733 iNES: mapper 192
6734 
6735 In MESS: Supported.
6736 
6737 *************************************************************/
6738
6739static void waixing_c_set_chr( running_machine *machine, int chr_base, int chr_mask )
6740{
6741   nes_state *state = (nes_state *)machine->driver_data;
6742   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
6743   UINT8 chr_src[6];
6744   int i;
6745   
6746   for (i = 0; i < 6; i++)
6747      chr_src[i] = ((state->mmc_vrom_bank[i] == 0x08) || (state->mmc_vrom_bank[i] == 0x09) || (state->mmc_vrom_bank[i] == 0x0a) || (state->mmc_vrom_bank[i] == 0x0b)) ? CHRRAM : CHRROM;
6748   
6749   chr1_x(machine, chr_page ^ 0, chr_base | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), chr_src[0]);
6750   chr1_x(machine, chr_page ^ 1, chr_base | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), chr_src[0]);
6751   chr1_x(machine, chr_page ^ 2, chr_base | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), chr_src[1]);
6752   chr1_x(machine, chr_page ^ 3, chr_base | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), chr_src[1]);
6753   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr_src[2]);
6754   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), chr_src[3]);
6755   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), chr_src[4]);
6756   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), chr_src[5]);
6757}
6758
6759static WRITE8_HANDLER( waixing_c_w )
6760{
6761   nes_state *state = (nes_state *)space->machine->driver_data;
6762   UINT8 MMC3_helper, cmd;
6763   LOG_MMC(("waixing_c_w, offset: %04x, data: %02x\n", offset, data));
6764   
6765   switch (offset & 0x6001)
6766   {
6767      case 0x0000:
6768         MMC3_helper = state->mmc_latch1 ^ data;
6769         state->mmc_latch1 = data;
6770         
6771         /* Has PRG Mode changed? */
6772         if (MMC3_helper & 0x40)
6773            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6774         
6775         /* Has CHR Mode changed? */
6776         if (MMC3_helper & 0x80)
6777            waixing_c_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6778         break;
6779         
6780      case 0x0001:
6781         cmd = state->mmc_latch1 & 0x07;
6782         switch (cmd)
6783         {
6784         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
6785         case 2: case 3: case 4: case 5:
6786            state->mmc_vrom_bank[cmd] = data;
6787            waixing_c_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6788            break;
6789         case 6:
6790         case 7:
6791            state->mmc_prg_bank[cmd - 6] = data;
6792            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6793            break;
6794         }
6795         break;
6796         
6797      default:
6798         waixing_a_w(space, offset, data);
6799         break;
6800   }
6801}
6802
6803/*************************************************************
6804 
6805 Waixing Board Type D
6806 
6807 Games: Super Robot Taisen (C)
6808 
6809 MMC3 clone. This is a minor modification of Mapper 74,
6810 in the sense that it is the same board except for the
6811 CHRRAM pages.
6812 
6813 iNES: mapper 194
6814 
6815 In MESS: Supported.
6816 
6817 *************************************************************/
6818
6819static void waixing_d_set_chr( running_machine *machine, int chr_base, int chr_mask )
6820{
6821   nes_state *state = (nes_state *)machine->driver_data;
6822   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
6823   UINT8 chr_src[6];
6824   int i;
6825   
6826   for (i = 0; i < 6; i++)
6827      chr_src[i] = (state->mmc_vrom_bank[i] < 0x02) ? CHRRAM : CHRROM;
6828   
6829   chr1_x(machine, chr_page ^ 0, chr_base | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), chr_src[0]);
6830   chr1_x(machine, chr_page ^ 1, chr_base | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), chr_src[0]);
6831   chr1_x(machine, chr_page ^ 2, chr_base | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), chr_src[1]);
6832   chr1_x(machine, chr_page ^ 3, chr_base | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), chr_src[1]);
6833   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr_src[2]);
6834   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), chr_src[3]);
6835   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), chr_src[4]);
6836   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), chr_src[5]);
6837}
6838
6839static WRITE8_HANDLER( waixing_d_w )
6840{
6841   nes_state *state = (nes_state *)space->machine->driver_data;
6842   UINT8 MMC3_helper, cmd;
6843   LOG_MMC(("waixing_d_w, offset: %04x, data: %02x\n", offset, data));
6844   
6845   switch (offset & 0x6001)
6846   {
6847      case 0x0000:
6848         MMC3_helper = state->mmc_latch1 ^ data;
6849         state->mmc_latch1 = data;
6850         
6851         /* Has PRG Mode changed? */
6852         if (MMC3_helper & 0x40)
6853            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6854         
6855         /* Has CHR Mode changed? */
6856         if (MMC3_helper & 0x80)
6857            waixing_d_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6858         break;
6859         
6860      case 0x0001:
6861         cmd = state->mmc_latch1 & 0x07;
6862         switch (cmd)
6863      {
6864         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
6865         case 2: case 3: case 4: case 5:
6866            state->mmc_vrom_bank[cmd] = data;
6867            waixing_d_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6868            break;
6869         case 6:
6870         case 7:
6871            state->mmc_prg_bank[cmd - 6] = data;
6872            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6873            break;
6874      }
6875         break;
6876         
6877      default:
6878         waixing_a_w(space, offset, data);
6879         break;
6880   }
6881}
6882
6883/*************************************************************
6884 
6885 Waixing Board Type E
6886 
6887 Games: Captain Tsubasa Vol. II (C), Chaos World, God
6888 Slayer (C), Zu Qiu Xiao Jiang
6889 
6890 MMC3 clone. This is a minor modification of Mapper 74,
6891 in the sense that it is the same board except for the
6892 CHRRAM pages.
6893 
6894 iNES: mapper 195
6895 
6896 In MESS: Supported.
6897 
6898 *************************************************************/
6899
6900static void waixing_e_set_chr( running_machine *machine, int chr_base, int chr_mask )
6901{
6902   nes_state *state = (nes_state *)machine->driver_data;
6903   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
6904   UINT8 chr_src[6];
6905   int i;
6906   
6907   for (i = 0; i < 6; i++)
6908      chr_src[i] = (state->mmc_vrom_bank[i] < 0x04) ? CHRRAM : CHRROM;
6909   
6910   chr1_x(machine, chr_page ^ 0, chr_base | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), chr_src[0]);
6911   chr1_x(machine, chr_page ^ 1, chr_base | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), chr_src[0]);
6912   chr1_x(machine, chr_page ^ 2, chr_base | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), chr_src[1]);
6913   chr1_x(machine, chr_page ^ 3, chr_base | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), chr_src[1]);
6914   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr_src[2]);
6915   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), chr_src[3]);
6916   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), chr_src[4]);
6917   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), chr_src[5]);
6918}
6919
6920static WRITE8_HANDLER( waixing_e_w )
6921{
6922   nes_state *state = (nes_state *)space->machine->driver_data;
6923   UINT8 MMC3_helper, cmd;
6924   LOG_MMC(("waixing_e_w, offset: %04x, data: %02x\n", offset, data));
6925   
6926   switch (offset & 0x6001)
6927   {
6928      case 0x0000:
6929         MMC3_helper = state->mmc_latch1 ^ data;
6930         state->mmc_latch1 = data;
6931         
6932         /* Has PRG Mode changed? */
6933         if (MMC3_helper & 0x40)
6934            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6935         
6936         /* Has CHR Mode changed? */
6937         if (MMC3_helper & 0x80)
6938            waixing_e_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6939         break;
6940         
6941      case 0x0001:
6942         cmd = state->mmc_latch1 & 0x07;
6943         switch (cmd)
6944      {
6945         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
6946         case 2: case 3: case 4: case 5:
6947            state->mmc_vrom_bank[cmd] = data;
6948            waixing_e_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
6949            break;
6950         case 6:
6951         case 7:
6952            state->mmc_prg_bank[cmd - 6] = data;
6953            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
6954            break;
6955      }
6956         break;
6957         
6958      default:
6959         waixing_a_w(space, offset, data);
6960         break;
6961   }
6962}
6963
6964/*************************************************************
6965 
6966 Waixing Board Type F
6967 
6968 Games: Tenchi wo Kurau II (C)
6969 
6970 MMC3 clone.
6971 
6972 iNES: mapper 198
6973 
6974 In MESS: Preliminary support.
6975 
6976 *************************************************************/
6977
6978static void waixing_f_set_prg( running_machine *machine, int prg_base, int prg_mask )
6979{
6980   nes_state *state = (nes_state *)machine->driver_data;
6981   UINT8 prg_flip = (state->mmc_latch1 & 0x40) ? 2 : 0;
6982   
6983   prg8_89(machine, prg_base | (state->mmc_prg_bank[0 ^ prg_flip] & prg_mask));
6984   prg8_ab(machine, prg_base | (state->mmc_prg_bank[1] & prg_mask));
6985   prg8_cd(machine, prg_base | (state->mmc_prg_bank[2 ^ prg_flip] & prg_mask));
6986   prg8_ef(machine, prg_base | (state->mmc_prg_bank[3] & prg_mask));
6987}
6988
6989static WRITE8_HANDLER( waixing_f_w )
6990{
6991   nes_state *state = (nes_state *)space->machine->driver_data;
6992   UINT8 MMC3_helper, cmd;
6993   LOG_MMC(("waixing_f_w, offset: %04x, data: %02x\n", offset, data));
6994   
6995   switch (offset & 0x6001)
6996   {
6997      case 0x0000:
6998         MMC3_helper = state->mmc_latch1 ^ data;
6999         state->mmc_latch1 = data;
7000         
7001         /* Has PRG Mode changed? */
7002         if (MMC3_helper & 0x40)
7003            waixing_f_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7004         
7005         /* Has CHR Mode changed? */
7006         if (MMC3_helper & 0x80)
7007            mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
7008         break;
7009         
7010      case 0x0001:
7011         cmd = state->mmc_latch1 & 0x07;
7012         switch (cmd)
7013      {
7014         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
7015         case 2: case 3: case 4: case 5:
7016            state->mmc_vrom_bank[cmd] = data;
7017            mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
7018            break;
7019         case 6:
7020         case 7:
7021            state->mmc_prg_bank[cmd - 6] = data & ((data > 0x3f) ? 0x4f : 0x3f);
7022            waixing_f_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7023            break;
7024      }
7025         break;
7026         
7027      default:
7028         waixing_a_w(space, offset, data);
7029         break;
7030   }
7031}
7032
7033/*************************************************************
7034 
7035 Waixing Board Type G
7036 
7037 Games: San Guo Zhi 2, Dragon Ball Z Gaiden (C), Dragon
7038 Ball Z II (C)
7039 
7040 MMC3 clone
7041 
7042 iNES: mapper 199
7043 
7044 In MESS: Supported.
7045 
7046 *************************************************************/
7047
7048static void waixing_g_set_chr( running_machine *machine, int chr_base, int chr_mask )
7049{
7050   nes_state *state = (nes_state *)machine->driver_data;
7051   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
7052   UINT8 chr_src[8];
7053   int i;
7054   
7055   for (i = 0; i < 8; i++)
7056      chr_src[i] = (state->mmc_vrom_bank[i] < 0x08) ? CHRRAM : CHRROM;
7057   
7058   chr1_x(machine, chr_page ^ 0, chr_base | (state->mmc_vrom_bank[0] & chr_mask), chr_src[0]);
7059   chr1_x(machine, chr_page ^ 1, chr_base | (state->mmc_vrom_bank[6] & chr_mask), chr_src[6]);
7060   chr1_x(machine, chr_page ^ 2, chr_base | (state->mmc_vrom_bank[1] & chr_mask), chr_src[1]);
7061   chr1_x(machine, chr_page ^ 3, chr_base | (state->mmc_vrom_bank[7] & chr_mask), chr_src[7]);
7062   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr_src[2]);
7063   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), chr_src[3]);
7064   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), chr_src[4]);
7065   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), chr_src[5]);
7066}
7067
7068static WRITE8_HANDLER( waixing_g_w )
7069{
7070   nes_state *state = (nes_state *)space->machine->driver_data;
7071   UINT8 MMC3_helper, cmd;
7072   LOG_MMC(("waixing_g_w, offset: %04x, data: %02x\n", offset, data));
7073   
7074   switch (offset & 0x6001)
7075   {
7076      case 0x0000:
7077         MMC3_helper = state->mmc_latch1 ^ data;
7078         state->mmc_latch1 = data;
7079         
7080         /* Has PRG Mode changed? */
7081         if (MMC3_helper & 0x40)
7082            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7083         
7084         /* Has CHR Mode changed? */
7085         if (MMC3_helper & 0x80)
7086            waixing_g_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
7087         break;
7088         
7089      case 0x0001:
7090         cmd = state->mmc_latch1 & 0x0f;
7091         switch (cmd)
7092      {
7093         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
7094         case 2: case 3: case 4: case 5:
7095            state->mmc_vrom_bank[cmd] = data;
7096            waixing_g_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
7097            break;
7098         case 6:
7099         case 7:
7100         case 8:
7101         case 9:
7102            state->mmc_prg_bank[cmd - 6] = data;
7103            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7104            break;
7105         case 0x0a: case 0x0b:
7106            state->mmc_vrom_bank[cmd - 4] = data;
7107            waixing_g_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
7108            break;
7109      }
7110         break;
7111         
7112      default:
7113         txrom_w(space, offset, data);
7114         break;
7115   }
7116}
7117
7118/*************************************************************
7119 
7120 Waixing Board Type H
7121 
7122 Games: Ying Xiong Yuan Yi Jing Chuan Qi, Yong Zhe Dou E
7123 Long - Dragon Quest VII
7124 
7125 MMC3 clone. More info to come.
7126 
7127 iNES: mapper 245
7128 
7129 In MESS: Supported.
7130 
7131 *************************************************************/
7132
7133static WRITE8_HANDLER( waixing_h_w )
7134{
7135   nes_state *state = (nes_state *)space->machine->driver_data;
7136   UINT8 cmd, map245_helper;
7137   LOG_MMC(("waixing_h_w, offset: %04x, data: %02x\n", offset, data));
7138   
7139   switch (offset & 0x6001)
7140   {
7141      case 0x0001:
7142         cmd = state->mmc_latch1 & 0x0f;
7143         switch (cmd)
7144      {
7145         case 0:    // in this case we set prg_base in addition to state->mmc_vrom_bank!
7146            state->mmc_prg_base = (data << 5) & 0x40;
7147            state->mmc_prg_mask = 0x3f;
7148            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7149         case 1: case 2: case 3: case 4: case 5:
7150            state->mmc_vrom_bank[cmd] = data;
7151            if (state->chr_chunks > 0)
7152               mmc3_set_chr(space->machine, CHRROM, state->mmc_chr_base, state->mmc_chr_mask);
7153            else   // according to Disch's docs, state->mmc_latch1&0x80 swaps 4k CHRRAM banks
7154            {
7155               map245_helper = /*(state->mmc_latch1 & 0x80) ? 1 : */0;
7156               chr4_0(space->machine, 0 ^ map245_helper, CHRRAM);
7157               chr4_4(space->machine, 1 ^ map245_helper, CHRRAM);
7158            }
7159            break;
7160         case 6:
7161         case 7:
7162            state->mmc_prg_bank[cmd - 6] = data;
7163            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7164            break;
7165      }
7166         break;
7167         
7168      case 0x2001:
7169         break;
7170         
7171      default:
7172         txrom_w(space, offset, data);
7173         break;
7174   }
7175}
7176
7177/*************************************************************
7178 
7179 Waixing San Guo Zhi Board
7180 
7181 Games: San Guo Zhi
7182 
7183 This board uses Konami IRQ
7184 
7185 iNES: mapper 252
7186 
7187 In MESS: Unsupported.
7188 
7189 *************************************************************/
7190
7191static WRITE8_HANDLER( waixing_sgz_w )
7192{
7193   nes_state *state = (nes_state *)space->machine->driver_data;
7194   UINT8 mmc_helper, bank;
7195   LOG_MMC(("waixing_sgz_w, offset: %04x, data: %02x\n", offset, data));
7196   
7197   switch (offset & 0x7000)
7198   {
7199      case 0x0000:
7200         prg8_89(space->machine, data);
7201         break;
7202      case 0x2000:
7203         prg8_ab(space->machine, data);
7204         break;
7205      case 0x3000:
7206      case 0x4000:
7207      case 0x5000:
7208      case 0x6000:
7209         bank = ((offset & 0x7000) - 0x3000) / 0x0800 + ((offset & 0x0008) >> 3);
7210         mmc_helper = offset & 0x04;
7211         if (mmc_helper)
7212            state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0x0f) | ((data & 0x0f) << 4);
7213         else
7214            state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0xf0) | (data & 0x0f);
7215         chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
7216         break;
7217      case 0x7000:
7218         switch (offset & 0x0c)
7219      {
7220         case 0x00:
7221            state->IRQ_count_latch = (state->IRQ_count_latch & 0xf0) | (data & 0x0f);
7222            break;
7223         case 0x04:
7224            state->IRQ_count_latch = (state->IRQ_count_latch & 0x0f) | ((data & 0x0f) << 4);
7225            break;
7226         case 0x08:
7227            state->IRQ_enable = data & 0x02;
7228            state->IRQ_enable_latch = data & 0x01;
7229            if (data & 0x02)
7230               state->IRQ_count = state->IRQ_count_latch;
7231            break;
7232         case 0x0c:
7233            state->IRQ_enable = state->IRQ_enable_latch;
7234            break;
7235      }
7236         break;
7237   }
7238}
7239
7240
7241/*************************************************************
7242 
7243 Waixing San Guo Zhong Lie Zhuan Board
7244 
7245 Games: Fan Kong Jing Ying, San Guo Zhong Lie Zhuan, Xing
7246 Ji Zheng Ba
7247 
7248 iNES: mapper 178
7249 
7250 In MESS: Supported.
7251 
7252 *************************************************************/
7253
7254static WRITE8_HANDLER( waixing_sgzlz_l_w )
7255{
7256   nes_state *state = (nes_state *)space->machine->driver_data;
7257   LOG_MMC(("waixing_sgzlz_l_w, offset: %04x, data: %02x\n", offset, data));
7258   
7259   switch (offset)
7260   {
7261      case 0x700:
7262         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
7263         break;
7264      case 0x701:
7265         state->mmc_latch1 = (state->mmc_latch1 & 0x0c) | ((data >> 1) & 0x03);
7266         prg32(space->machine, state->mmc_latch1);
7267         break;
7268      case 0x702:
7269         state->mmc_latch1 = (state->mmc_latch1 & 0x03) | ((data << 2) & 0x0c);
7270         break;
7271   }
7272}
7273
7274/*************************************************************
7275 
7276 Waixing Final Fantasy V Board
7277 
7278 Games: Darkseed, Digital Dragon, Final Fantasy V, Pocket
7279 Monster Red
7280 
7281 iNES: mapper 164
7282 
7283 In MESS: Supported.
7284 
7285 *************************************************************/
7286
7287static WRITE8_HANDLER( waixing_ffv_l_w )
7288{
7289   LOG_MMC(("waixing_ffv_l_w, offset: %04x, data: %02x\n", offset, data));
7290   offset += 0x4100; /* the checks work better on addresses */
7291   
7292   if (0x5000 == (offset & 0x7300))
7293      prg32(space->machine, data);
7294}
7295
7296static WRITE8_HANDLER( waixing_ffv_w )
7297{
7298   LOG_MMC(("waixing_ffv_w, offset: %04x, data: %02x\n", offset, data));
7299   if ((offset & 0x7300) == 0x5000)
7300      prg32(space->machine, data);
7301}
7302
7303/*************************************************************
7304 
7305 Waixing Zhan Shi Board
7306 
7307 Games: Wai Xing Zhan Shi
7308 
7309 Simple mapper: writes to 0x8000-0xffff sets prg32 banks to
7310 (offset>>3)&f. written data&3 sets the mirroring (with
7311 switched high/low compared to the standard one). 
7312 
7313 A crc check is required to support Dragon Quest VIII (which
7314 uses a slightly different board)
7315 
7316 iNES: mapper 242
7317 
7318 In MESS: Supported.
7319 
7320 *************************************************************/
7321
7322static WRITE8_HANDLER( waixing_zs_w )
7323{
7324   LOG_MMC(("waixing_zs_w, offset: %04x, data: %02x\n", offset, data));
7325   
7326   prg32(space->machine, offset >> 3);
7327   
7328   switch (data & 0x03)
7329   {
7330      case 0: set_nt_mirroring(space->machine, PPU_MIRROR_VERT); break;
7331      case 1: set_nt_mirroring(space->machine, PPU_MIRROR_HORZ); break;
7332      case 2: set_nt_mirroring(space->machine, PPU_MIRROR_LOW); break;
7333      case 3: set_nt_mirroring(space->machine, PPU_MIRROR_HIGH); break;
7334   }
7335}
7336
7337/*************************************************************
7338 
7339 Waixing Dragon Quest VIII Board
7340 
7341 Games: Dragon Quest VIII
7342 
7343 Simple mapper: writes to 0x8000-0xffff sets prg32 banks to
7344 (offset>>3)&f.
7345 
7346 iNES: mapper 242
7347 
7348 In MESS: Supported.
7349 
7350 *************************************************************/
7351
7352static WRITE8_HANDLER( waixing_dq8_w )
7353{
7354   LOG_MMC(("waixing_dq8_w, offset: %04x, data: %02x\n", offset, data));
7355   
7356   prg32(space->machine, offset >> 3);
7357}
7358
7359
7360/*************************************************************
7361 
7362 Waixing PS2 board
7363
7364 Games: Bao Xiao Tien Guo, Bio Hazard, Pokemon Gold, Subor (R)
7365 
7366 iNES: mapper 15
7367 
7368 In MESS: Supported
7369 
7370 *************************************************************/
7371
7372static WRITE8_HANDLER( waixing_ps2_w )
7373{
7374   UINT8 map15_flip = (data & 0x80) >> 7;
7375   UINT8 map15_helper = (data & 0x7f) << 1;
7376   
7377   LOG_MMC(("waixing_ps2_w, offset: %04x, data: %02x\n", offset, data));
7378   
7379   set_nt_mirroring(space->machine, BIT(data, 6) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
7380   
7381   switch (offset & 0x0fff)
7382   {
7383      case 0x000:
7384         prg8_89(space->machine, (map15_helper + 0) ^ map15_flip);
7385         prg8_ab(space->machine, (map15_helper + 1) ^ map15_flip);
7386         prg8_cd(space->machine, (map15_helper + 2) ^ map15_flip);
7387         prg8_ef(space->machine, (map15_helper + 3) ^ map15_flip);
7388         break;
7389      case 0x001:
7390         map15_helper |= map15_flip;
7391         prg8_89(space->machine, map15_helper);
7392         prg8_ab(space->machine, map15_helper + 1);
7393         prg8_cd(space->machine, map15_helper + 1);
7394         prg8_ef(space->machine, map15_helper + 1);
7395         break;
7396      case 0x002:
7397         map15_helper |= map15_flip;
7398         prg8_89(space->machine, map15_helper);
7399         prg8_ab(space->machine, map15_helper);
7400         prg8_cd(space->machine, map15_helper);
7401         prg8_ef(space->machine, map15_helper);
7402         break;
7403      case 0x003:
7404         map15_helper |= map15_flip;
7405         prg8_89(space->machine, map15_helper);
7406         prg8_ab(space->machine, map15_helper + 1);
7407         prg8_cd(space->machine, map15_helper);
7408         prg8_ef(space->machine, map15_helper + 1);
7409         break;
7410   }
7411}
7412
7413/*************************************************************
7414 
7415 Waixing Board with Security Chip
7416 
7417 Games: Duo Bao Xiao Ying Hao - Guang Ming yu An Hei Chuan Shuo,
7418 Myth Struggle, San Shi Liu Ji, Shui Hu Zhuan
7419 
7420 MMC3 clone
7421 
7422 iNES: mapper 249
7423 
7424 In MESS: Partially Supported.
7425 
7426 *************************************************************/
7427
7428static void waixing_sec_set_prg( running_machine *machine, int prg_base, int prg_mask )
7429{
7430   nes_state *state = (nes_state *)machine->driver_data;
7431   int i;
7432   
7433   if (state->map249_reg)
7434   {
7435      for (i = 0; i < 4; i ++)   // should this apply only to bank[0],bank[1]?
7436      {
7437         state->mmc_prg_bank[i] = ((state->mmc_prg_bank[i] & 0x01)) | ((state->mmc_prg_bank[i] >> 3) & 0x02) |
7438         ((state->mmc_prg_bank[i] >> 1) & 0x04) | ((state->mmc_prg_bank[i] << 2) & 0x18);
7439      }
7440   }
7441   
7442   mmc3_set_prg(machine, prg_base, prg_mask);
7443}
7444
7445static void waixing_sec_set_chr( running_machine *machine, int chr_base, int chr_mask )
7446{
7447   nes_state *state = (nes_state *)machine->driver_data;
7448   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
7449   int i;
7450   
7451   if (state->map249_reg)
7452   {
7453      for (i = 0; i < 6; i ++)
7454      {
7455         state->mmc_vrom_bank[i] = ((state->mmc_vrom_bank[i] & 0x03)) | ((state->mmc_vrom_bank[i] >> 1) & 0x04) |
7456         ((state->mmc_vrom_bank[i] >> 4) & 0x08) | ((state->mmc_vrom_bank[i] >> 2) & 0x10) |
7457         ((state->mmc_vrom_bank[i] << 3) & 0x20) | ((state->mmc_vrom_bank[i] << 2) & 0xc0);
7458      }
7459   }
7460   
7461   chr1_x(machine, chr_page ^ 0, chr_base | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), state->mmc_chr_source);
7462   chr1_x(machine, chr_page ^ 1, chr_base | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), state->mmc_chr_source);
7463   chr1_x(machine, chr_page ^ 2, chr_base | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), state->mmc_chr_source);
7464   chr1_x(machine, chr_page ^ 3, chr_base | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), state->mmc_chr_source);
7465   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), state->mmc_chr_source);
7466   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), state->mmc_chr_source);
7467   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), state->mmc_chr_source);
7468   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), state->mmc_chr_source);
7469}
7470
7471static WRITE8_HANDLER( waixing_sec_l_w )
7472{
7473   nes_state *state = (nes_state *)space->machine->driver_data;
7474   LOG_MMC(("waixing_sec_l_w, offset: %04x, data: %02x\n", offset, data));
7475   
7476   offset += 0x100;
7477   
7478   if (offset == 0x1000)
7479   {
7480      state->map249_reg = data & 0x02;
7481      waixing_sec_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7482      waixing_sec_set_chr(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7483   }
7484}
7485
7486static WRITE8_HANDLER( waixing_sec_w )
7487{
7488   nes_state *state = (nes_state *)space->machine->driver_data;
7489   UINT8 MMC3_helper, cmd;
7490   LOG_MMC(("waixing_sec_w, offset: %04x, data: %02x\n", offset, data));
7491   
7492   switch (offset & 0x6001)
7493   {
7494      case 0x0000:
7495         MMC3_helper = state->mmc_latch1 ^ data;
7496         state->mmc_latch1 = data;
7497         
7498         /* Has PRG Mode changed? */
7499         if (MMC3_helper & 0x40)
7500            waixing_sec_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7501         
7502         /* Has CHR Mode changed? */
7503         if (MMC3_helper & 0x80)
7504            waixing_sec_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
7505         break;
7506         
7507      case 0x0001:
7508         cmd = state->mmc_latch1 & 0x07;
7509         switch (cmd)
7510      {
7511         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
7512         case 2: case 3: case 4: case 5:
7513            state->mmc_vrom_bank[cmd] = data;
7514            waixing_sec_set_chr(space->machine, state->mmc_chr_base, state->mmc_chr_mask);
7515            break;
7516         case 6:
7517         case 7:
7518            state->mmc_prg_bank[cmd - 6] = data;
7519            waixing_sec_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7520            break;
7521      }
7522         break;
7523         
7524      default:
7525         txrom_w(space, offset, data);
7526         break;
7527   }
7528}
7529
7530/*************************************************************
7531 
7532 Board UNL-8237
7533 
7534 Games: Pochahontas 2
7535 
7536 MMC3 clone
7537 
7538 In MESS: Not working
7539 
7540 *************************************************************/
7541
7542static void unl_8237_set_prg( running_machine *machine )
7543{
7544   nes_state *state = (nes_state *)machine->driver_data;
7545   UINT8 prg_flip = (state->mmc_latch1 & 0x40) ? 2 : 0;
7546   
7547   if (!(state->unl_8237_reg[0] & 0x80))
7548   {
7549      prg8_89(machine, state->mmc_prg_bank[0 ^ prg_flip]);
7550      prg8_ab(machine, state->mmc_prg_bank[1]);
7551      prg8_cd(machine, state->mmc_prg_bank[2 ^ prg_flip]);
7552      prg8_ef(machine, state->mmc_prg_bank[3]);
7553   }
7554}
7555
7556static void unl_8237_set_chr( running_machine *machine )
7557{
7558   nes_state *state = (nes_state *)machine->driver_data;
7559   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
7560   UINT8 bank[8];
7561   int i;
7562   
7563   for(i = 0; i < 6; i++)
7564      bank[i] = state->mmc_vrom_bank[i] | ((state->unl_8237_reg[1] << 6) & 0x100);
7565   
7566   chr1_x(machine, chr_page ^ 0, (bank[0] & ~0x01), CHRROM);
7567   chr1_x(machine, chr_page ^ 1, (bank[0] |  0x01), CHRROM);
7568   chr1_x(machine, chr_page ^ 2, (bank[1] & ~0x01), CHRROM);
7569   chr1_x(machine, chr_page ^ 3, (bank[1] |  0x01), CHRROM);
7570   chr1_x(machine, chr_page ^ 4, bank[2], CHRROM);
7571   chr1_x(machine, chr_page ^ 5, bank[3], CHRROM);
7572   chr1_x(machine, chr_page ^ 6, bank[4], CHRROM);
7573   chr1_x(machine, chr_page ^ 7, bank[5], CHRROM);
7574}
7575
7576static WRITE8_HANDLER( unl_8237_l_w )
7577{
7578   nes_state *state = (nes_state *)space->machine->driver_data;
7579   LOG_MMC(("unl_8237_l_w offset: %04x, data: %02x\n", offset, data));
7580   offset += 0x100;
7581   
7582   if (offset == 0x1000)
7583   {
7584      state->unl_8237_reg[0] = data;
7585      if (state->unl_8237_reg[0] & 0x80)
7586      {
7587         if (state->unl_8237_reg[0] & 0x20)
7588            prg32(space->machine, (state->unl_8237_reg[0] & 0x0f) >> 1);
7589         else
7590         {
7591            prg16_89ab(space->machine, state->unl_8237_reg[0] & 0x1f);
7592            prg16_cdef(space->machine, state->unl_8237_reg[0] & 0x1f);
7593         }
7594      }
7595      else
7596         unl_8237_set_prg(space->machine);
7597   }
7598   
7599   if (offset == 0x1001)
7600   {
7601      state->unl_8237_reg[1] = data;
7602      unl_8237_set_chr(space->machine);
7603   }
7604}
7605
7606static WRITE8_HANDLER( unl_8237_w )
7607{
7608   nes_state *state = (nes_state *)space->machine->driver_data;
7609   UINT8 unl_8237_helper, cmd;
7610   static const UINT8 conv_table[8] = {0,2,6,1,7,3,4,5};
7611   LOG_MMC(("unl_8237_w offset: %04x, data: %02x\n", offset, data));
7612   
7613   switch (offset & 0x7000)
7614   {
7615      case 0x2000:
7616      case 0x3000:
7617         state->unl_8237_reg[2] = 1;
7618         data = (data & 0xc0) | conv_table[data & 0x07];
7619         unl_8237_helper = state->mmc_latch1 ^ data;
7620         state->mmc_latch1 = data;
7621         
7622         /* Has PRG Mode changed? */
7623         if (unl_8237_helper & 0x40)
7624            unl_8237_set_prg(space->machine);
7625         
7626         /* Has CHR Mode changed? */
7627         if (unl_8237_helper & 0x80)
7628            unl_8237_set_chr(space->machine);
7629         break;
7630         
7631      case 0x4000:
7632      case 0x5000:
7633         if (state->unl_8237_reg[2])
7634         {
7635            state->unl_8237_reg[2] = 0;
7636            cmd = state->mmc_latch1 & 0x07;
7637            switch (cmd)
7638            {
7639               case 0: case 1:
7640               case 2: case 3: case 4: case 5:
7641                  state->mmc_vrom_bank[cmd] = data;
7642                  unl_8237_set_chr(space->machine);
7643                  break;
7644               case 6:
7645               case 7:
7646                  state->mmc_prg_bank[cmd - 6] = data;
7647                  unl_8237_set_prg(space->machine);
7648                  break;
7649            }
7650         }
7651         break;
7652         
7653      case 0x0000:
7654      case 0x1000:
7655         set_nt_mirroring(space->machine, (data | (data >> 7)) & 0x01 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
7656         break;
7657         
7658      case 0x6000:
7659         break;
7660         
7661      case 0x7000:
7662         txrom_w(space, 0x6001, data);
7663         txrom_w(space, 0x4000, data);
7664         txrom_w(space, 0x4001, data);
7665         break;
7666   }
7667}
7668
7669/*************************************************************
7670 
7671 Board UNL-AX5705
7672 
7673 Games: Super Mario Bros. Pocker Mali (Crayon Shin-chan pirate hack)
7674 
7675 In MESS: Supported
7676 
7677 *************************************************************/
7678
7679static void unl_ax5705_set_prg( running_machine *machine )
7680{
7681   nes_state *state = (nes_state *)machine->driver_data;
7682   prg8_89(machine, state->mmc_prg_bank[0]);
7683   prg8_ab(machine, state->mmc_prg_bank[1]);
7684}
7685
7686static WRITE8_HANDLER( unl_ax5705_w )
7687{
7688   nes_state *state = (nes_state *)space->machine->driver_data;
7689   UINT8 bank;
7690   LOG_MMC(("unl_ax5705_w offset: %04x, data: %02x\n", offset, data));
7691   
7692   switch (offset & 0x700f)
7693   {
7694      case 0x0000:
7695         state->mmc_prg_bank[0] = (data & 0x05) | ((data & 0x08) >> 2) | ((data & 0x02) << 2);
7696         unl_ax5705_set_prg(space->machine);
7697         break;
7698      case 0x0008:
7699         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
7700         break;
7701      case 0x2000:
7702         state->mmc_prg_bank[1] = (data & 0x05) | ((data & 0x08) >> 2) | ((data & 0x02) << 2);
7703         unl_ax5705_set_prg(space->machine);
7704         break;
7705         /* CHR banks 0, 1, 4, 5 */
7706      case 0x2008:
7707      case 0x200a:
7708      case 0x4008:
7709      case 0x400a:
7710         bank = ((offset & 0x4000) ? 4 : 0) + ((offset & 0x0002) ? 1 : 0);
7711         state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0xf0) | (data & 0x0f);
7712         chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
7713         break;
7714      case 0x2009:
7715      case 0x200b:
7716      case 0x4009:
7717      case 0x400b:
7718         bank = ((offset & 0x4000) ? 4 : 0) + ((offset & 0x0002) ? 1 : 0);
7719         state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0x0f) | ((data & 0x04) << 3) | ((data & 0x02) << 5) | ((data & 0x09) << 4);
7720         chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
7721         break;
7722         /* CHR banks 2, 3, 6, 7 */
7723      case 0x4000:
7724      case 0x4002:
7725      case 0x6000:
7726      case 0x6002:
7727         bank = 2 + ((offset & 0x2000) ? 4 : 0) + ((offset & 0x0002) ? 1 : 0);
7728         state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0xf0) | (data & 0x0f);
7729         chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
7730         break;
7731      case 0x4001:
7732      case 0x4003:
7733      case 0x6001:
7734      case 0x6003:
7735         bank = 2 + ((offset & 0x2000) ? 4 : 0) + ((offset & 0x0002) ? 1 : 0);
7736         state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0x0f) | ((data & 0x04) << 3) | ((data & 0x02) << 5) | ((data & 0x09) << 4);
7737         chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
7738         break;
7739   }
7740}
7741
7742/*************************************************************
7743 
7744 Board UNL-CC-21
7745 
7746 Games: Mi Hun Che
7747 
7748 In MESS: Supported
7749 
7750 *************************************************************/
7751
7752static WRITE8_HANDLER( unl_cc21_w )
7753{
7754   LOG_MMC(("unl_cc21_w offset: %04x, data: %02x\n", offset, data));
7755   
7756   set_nt_mirroring(space->machine, BIT(data, 1) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
7757   chr8(space->machine, (offset & 0x01), CHRROM);
7758}
7759
7760/*************************************************************
7761 
7762 Board UNL-KOF97
7763 
7764 Games: King of Fighters 97 (Rex Soft)
7765 
7766 MMC3 clone
7767 
7768 In MESS: Not working
7769 
7770 *************************************************************/
7771
7772static UINT8 unl_kof97_unscramble( UINT8 data )
7773{
7774   return ((data >> 1) & 0x01) | ((data >> 4) & 0x02) | ((data << 2) & 0x04) | ((data >> 0) & 0xd8) | ((data << 3) & 0x20);
7775}
7776
7777static WRITE8_HANDLER( unl_kof97_w )
7778{
7779   LOG_MMC(("unl_kof97_w offset: %04x, data: %02x\n", offset, data));
7780   
7781   /* Addresses 0x9000, 0xa000, 0xd000 & 0xf000 behaves differently than MMC3 */
7782   if (offset == 0x1000)
7783   {
7784      data = unl_kof97_unscramble(data);
7785      txrom_w(space, 0x0001, data);
7786   }
7787   else if (offset == 0x2000)
7788   {
7789      data = unl_kof97_unscramble(data);
7790      txrom_w(space, 0x0000, data);
7791   }
7792   else if (offset == 0x5000)
7793   {
7794      data = unl_kof97_unscramble(data);
7795      txrom_w(space, 0x4001, data);
7796   }
7797   else if (offset == 0x7000)
7798   {
7799      data = unl_kof97_unscramble(data);
7800      txrom_w(space, 0x6001, data);
7801   }
7802   else      /* Other addresses behaves like MMC3, up to unscrambling data */
7803   {
7804      switch (offset & 0x6001)
7805      {
7806         case 0x0000:
7807         case 0x0001:
7808         case 0x4000:
7809         case 0x4001:
7810         case 0x6000:
7811         case 0x6001:
7812         case 0x2000:   /* are these ever called?!? */
7813         case 0x2001:
7814            data = unl_kof97_unscramble(data);
7815            txrom_w(space, offset, data);
7816            break;
7817      }
7818   }
7819}
7820
7821/*************************************************************
7822 
7823 Board UNL-T-230
7824 
7825 Games: Dragon Ball Z IV (Unl)
7826 
7827 In MESS: Supported
7828 
7829 *************************************************************/
7830
7831static WRITE8_HANDLER( unl_t230_w )
7832{
7833   LOG_MMC(("unl_t230_w offset: %04x, data: %02x\n", offset, data));
7834   
7835   switch (offset & 0x7007)
7836   {
7837      case 0x0000:
7838         break;
7839      case 0x2000:
7840         data = (data << 1) & 0x1f;
7841         prg8_89(space->machine, data);
7842         prg8_ab(space->machine, data | 0x01);
7843         break;
7844         
7845      default:
7846         konami_vrc2b_w(space, offset, data);
7847         break;
7848   }
7849}
7850
7851/*************************************************************
7852 
7853 Bootleg Board for KOF96
7854
7855 Games: The King of Fighters 96, Sonic 3D Blast 6, Street
7856 Fighter Zero 2
7857 
7858 MMC3 clone
7859 
7860 iNES: mapper 187
7861 
7862 In MESS: Preliminary Support.
7863 
7864 *************************************************************/
7865
7866static void kof96_set_prg( running_machine *machine, int prg_base, int prg_mask )
7867{
7868   nes_state *state = (nes_state *)machine->driver_data;
7869   UINT8 prg_flip = (state->mmc_latch1 & 0x40) ? 2 : 0;
7870   
7871   if (!(state->mapper187_reg[0] & 0x80))
7872   {
7873      prg8_89(machine, prg_base | (state->mmc_prg_bank[0 ^ prg_flip] & prg_mask));
7874      prg8_ab(machine, prg_base | (state->mmc_prg_bank[1] & prg_mask));
7875      prg8_cd(machine, prg_base | (state->mmc_prg_bank[2 ^ prg_flip] & prg_mask));
7876      prg8_ef(machine, prg_base | (state->mmc_prg_bank[3] & prg_mask));
7877   }
7878}
7879
7880static void kof96_set_chr( running_machine *machine, UINT8 chr, int chr_base, int chr_mask )
7881{
7882   nes_state *state = (nes_state *)machine->driver_data;
7883   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
7884   UINT8 new_base[8];
7885   int i;
7886   
7887   for (i = 0; i < 8; i++)
7888      new_base[i] = ((i & 0x04) == chr_page)? (chr_base | 0x100) : chr_base;
7889   
7890   chr1_x(machine, chr_page ^ 0, new_base[0] | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), chr);
7891   chr1_x(machine, chr_page ^ 1, new_base[1] | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), chr);
7892   chr1_x(machine, chr_page ^ 2, new_base[2] | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), chr);
7893   chr1_x(machine, chr_page ^ 3, new_base[3] | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), chr);
7894   chr1_x(machine, chr_page ^ 4, new_base[4] | (state->mmc_vrom_bank[2] & chr_mask), chr);
7895   chr1_x(machine, chr_page ^ 5, new_base[5] | (state->mmc_vrom_bank[3] & chr_mask), chr);
7896   chr1_x(machine, chr_page ^ 6, new_base[6] | (state->mmc_vrom_bank[4] & chr_mask), chr);
7897   chr1_x(machine, chr_page ^ 7, new_base[7] | (state->mmc_vrom_bank[5] & chr_mask), chr);
7898}
7899
7900static WRITE8_HANDLER( kof96_l_w )
7901{
7902   nes_state *state = (nes_state *)space->machine->driver_data;
7903   UINT8 new_bank;
7904   LOG_MMC(("kof96_l_w, offset: %04x, data: %02x\n", offset, data));
7905   offset += 0x100;
7906   
7907   if (offset == 0x1000)
7908   {
7909      switch (data & 0x03)
7910      {
7911         case 0x00:
7912         case 0x01:
7913            state->mapper187_reg[1] = 0x83;
7914            break;
7915         case 0x02:
7916            state->mapper187_reg[1] = 0x42;
7917            break;
7918         case 0x03:
7919            state->mapper187_reg[1] = 0x00;
7920            break;
7921      }
7922   }
7923   
7924   if (!(offset <= 0x1000))
7925   {
7926      state->mapper187_reg[0] = data;
7927     
7928      if (state->mapper187_reg[0] & 0x80)
7929      {
7930         new_bank = (state->mapper187_reg[0] & 0x1f);
7931         
7932         if (state->mapper187_reg[0] & 0x20)
7933            prg32(space->machine, new_bank >> 2);
7934         else
7935         {
7936            prg16_89ab(space->machine, new_bank);
7937            prg16_cdef(space->machine, new_bank);
7938         }
7939      }
7940      else
7941         kof96_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7942   }
7943}
7944
7945static READ8_HANDLER( kof96_l_r )
7946{
7947   nes_state *state = (nes_state *)space->machine->driver_data;
7948   LOG_MMC(("kof96_l_r, offset: %04x\n", offset));
7949   offset += 0x100;
7950   
7951   if (!(offset < 0x1000))
7952      return state->mapper187_reg[1];
7953   else
7954      return 0;
7955}
7956
7957static WRITE8_HANDLER( kof96_w )
7958{
7959   nes_state *state = (nes_state *)space->machine->driver_data;
7960   UINT8 MMC3_helper, cmd;
7961   LOG_MMC(("kof96_w, offset: %04x, data: %02x\n", offset, data));
7962   
7963   switch (offset & 0x6003)
7964   {
7965      case 0x0000:
7966         state->mapper187_reg[2] = 1;
7967         MMC3_helper = state->mmc_latch1 ^ data;
7968         state->mmc_latch1 = data;
7969         
7970         /* Has PRG Mode changed? */
7971         if (MMC3_helper & 0x40)
7972            kof96_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7973         
7974         /* Has CHR Mode changed? */
7975         if (MMC3_helper & 0x80)
7976            kof96_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
7977         break;
7978         
7979      case 0x0001:
7980         if (state->mapper187_reg[2])
7981         {
7982            cmd = state->mmc_latch1 & 0x07;
7983            switch (cmd)
7984            {
7985               case 0: case 1:
7986               case 2: case 3: case 4: case 5:
7987                  state->mmc_vrom_bank[cmd] = data;
7988                  kof96_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
7989                  break;
7990               case 6:
7991               case 7:
7992                  state->mmc_prg_bank[cmd - 6] = data;
7993                  kof96_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
7994                  break;
7995            }
7996         }
7997         break;
7998         
7999      case 0x0002:
8000         break;
8001         
8002      case 0x0003:
8003         state->mapper187_reg[2] = 0;
8004         
8005         if (data == 0x28)
8006            prg8_cd(space->machine, 0x17);
8007         else if (data == 0x2a)
8008            prg8_ab(space->machine, 0x0f);
8009         break;
8010         
8011      default:
8012         txrom_w(space, offset, data);
8013         break;
8014   }
8015}
8016
8017/*************************************************************
8018 
8019 Bootleg Board for MK2
8020
8021 Games: Mortal Kombat II, Street Fighter III, Super Mario
8022 Kart Rider
8023 
8024 This board uses an IRQ system very similar to MMC3. We indeed
8025 use mapper4_irq, but there is some small glitch!
8026 
8027 iNES: mapper 91
8028 
8029 In MESS: Supported.
8030 
8031 *************************************************************/
8032
8033static WRITE8_HANDLER( mk2_m_w )
8034{
8035   nes_state *state = (nes_state *)space->machine->driver_data;
8036   LOG_MMC(("mk2_m_w, offset: %04x, data: %02x\n", offset, data));
8037   
8038   switch (offset & 0x1000)
8039   {
8040      case 0x0000:
8041         switch (offset & 0x03)
8042      {
8043         case 0x00: chr2_0(space->machine, data, CHRROM); break;
8044         case 0x01: chr2_2(space->machine, data, CHRROM); break;
8045         case 0x02: chr2_4(space->machine, data, CHRROM); break;
8046         case 0x03: chr2_6(space->machine, data, CHRROM); break;
8047      }
8048         break;
8049      case 0x1000:
8050         switch (offset & 0x03)
8051      {
8052         case 0x00: prg8_89(space->machine, data); break;
8053         case 0x01: prg8_ab(space->machine, data); break;
8054         case 0x02: state->IRQ_enable = 0; state->IRQ_count = 0; break;
8055         case 0x03: state->IRQ_enable = 1; state->IRQ_count = 7; break;
8056      }
8057         break;
8058      default:
8059         logerror("mk2_m_w uncaught addr: %04x value: %02x\n", offset + 0x6000, data);
8060         break;
8061   }
8062}
8063
8064/*************************************************************
8065 
8066 Bootleg Board N625092
8067
8068 Games: 400 in 1, 700 in 1, 1000 in 1
8069 
8070 iNES: mapper 221
8071 
8072 In MESS: Supported.
8073 
8074 *************************************************************/
8075
8076static void n625092_set_prg( running_machine *machine, UINT8 reg1, UINT8 reg2 )
8077{
8078   UINT8 map221_helper1, map221_helper2;
8079   
8080   map221_helper1 = !(reg1 & 0x01) ? reg2 :
8081   (reg1 & 0x80) ? reg2 : (reg2 & 0x06) | 0x00;
8082   map221_helper2 = !(reg1 & 0x01) ? reg2 :
8083   (reg1 & 0x80) ? 0x07 : (reg2 & 0x06) | 0x01;
8084   
8085   prg16_89ab(machine, map221_helper1 | ((reg1 & 0x70) >> 1));
8086   prg16_cdef(machine, map221_helper2 | ((reg1 & 0x70) >> 1));
8087}
8088
8089static WRITE8_HANDLER( n625092_w )
8090{
8091   nes_state *state = (nes_state *)space->machine->driver_data;
8092   LOG_MMC(("n625092_w, offset: %04x, data: %02x\n", offset, data));
8093   
8094   if (offset < 0x4000)
8095   {
8096      set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8097      offset = (offset >> 1) & 0xff;
8098     
8099      if (state->mmc_latch1 != offset)
8100      {
8101         state->mmc_latch1 = offset;
8102         n625092_set_prg(space->machine, state->mmc_latch1, state->mmc_latch2);
8103      }
8104   }
8105   else
8106   {
8107      offset &= 0x07;
8108     
8109      if (state->mmc_latch2 != offset)
8110      {
8111         state->mmc_latch2 = offset;
8112         n625092_set_prg(space->machine, state->mmc_latch1, state->mmc_latch2);
8113      }
8114   }
8115}
8116
8117/*************************************************************
8118 
8119 SC-127 Board
8120
8121 Games: Wario World II (Kirby Hack)
8122 
8123 iNES: mapper 35
8124 
8125 In MESS: Supported
8126 
8127 *************************************************************/
8128
8129static void sc127_irq( running_device *device, int scanline, int vblank, int blanked )
8130{
8131   nes_state *state = (nes_state *)device->machine->driver_data;
8132   
8133   if (scanline < PPU_BOTTOM_VISIBLE_SCANLINE && state->IRQ_enable)
8134   {
8135      state->IRQ_count--;
8136     
8137      if (!blanked && (state->IRQ_count == 0))
8138      {
8139         LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
8140                video_screen_get_vpos(device->machine->primary_screen), video_screen_get_hpos(device->machine->primary_screen)));
8141         cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
8142         state->IRQ_enable = 0;
8143      }
8144   }
8145}
8146
8147static WRITE8_HANDLER( sc127_w )
8148{
8149   nes_state *state = (nes_state *)space->machine->driver_data;
8150   LOG_MMC(("sc127_w, offset: %04x, data: %02x\n", offset, data));
8151   
8152   switch (offset)
8153   {
8154      case 0x0000:
8155         prg8_89(space->machine, data);
8156         break;
8157      case 0x0001:
8158         prg8_ab(space->machine, data);
8159         break;
8160      case 0x0002:
8161         //      state->mmc_prg_bank[offset & 0x02] = data;
8162         prg8_cd(space->machine, data);
8163         break;
8164      case 0x1000:
8165      case 0x1001:
8166      case 0x1002:
8167      case 0x1003:
8168      case 0x1004:
8169      case 0x1005:
8170      case 0x1006:
8171      case 0x1007:
8172         //      state->mmc_vrom_bank[offset & 0x07] = data;
8173         chr1_x(space->machine, offset & 0x07, data, CHRROM);
8174         break;
8175      case 0x4002:
8176         state->IRQ_enable = 0;
8177         break;
8178      case 0x4003:
8179         state->IRQ_enable = 1;
8180         break;
8181      case 0x4005:
8182         state->IRQ_count = data;
8183         break;
8184      case 0x5001:
8185         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8186         break;
8187   }
8188}
8189
8190/*************************************************************
8191 
8192 Bootleg Board SMB2J
8193
8194 Games: Super Mario Bros. 2 Pirate (LF36)
8195 
8196 iNES: mapper 43
8197 
8198 In MESS: Supported? The only image I found is not working
8199 (not even in NEStopia).
8200 
8201 *************************************************************/
8202
8203static WRITE8_HANDLER( smb2j_w )
8204{
8205   nes_state *state = (nes_state *)space->machine->driver_data;
8206   int bank = (((offset >> 8) & 0x03) * 0x20) + (offset & 0x1f);
8207   
8208   LOG_MMC(("smb2j_w, offset: %04x, data: %02x\n", offset, data));
8209   
8210   set_nt_mirroring(space->machine, (offset & 0x2000) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8211   
8212   if (offset & 0x0800)
8213   {
8214      if (offset & 0x1000)
8215      {
8216         if (bank * 2 >= state->prg_chunks)
8217         {
8218            memory_set_bankptr(space->machine, "bank3", state->wram);
8219            memory_set_bankptr(space->machine, "bank4", state->wram);
8220         }
8221         else
8222         {
8223            LOG_MMC(("smb2j_w, selecting upper 16KB bank of #%02x\n", bank));
8224            prg16_cdef(space->machine, 2 * bank + 1);
8225         }
8226      }
8227      else
8228      {
8229         if (bank * 2 >= state->prg_chunks)
8230         {
8231            memory_set_bankptr(space->machine, "bank1", state->wram);
8232            memory_set_bankptr(space->machine, "bank2", state->wram);
8233         }
8234         else
8235         {
8236            LOG_MMC(("smb2j_w, selecting lower 16KB bank of #%02x\n", bank));
8237            prg16_89ab(space->machine, 2 * bank);
8238         }
8239      }
8240   }
8241   else
8242   {
8243      if (bank * 2 >= state->prg_chunks)
8244      {
8245         memory_set_bankptr(space->machine, "bank1", state->wram);
8246         memory_set_bankptr(space->machine, "bank2", state->wram);
8247         memory_set_bankptr(space->machine, "bank3", state->wram);
8248         memory_set_bankptr(space->machine, "bank4", state->wram);
8249      }
8250      else
8251      {
8252         LOG_MMC(("smb2j_w, selecting 32KB bank #%02x\n", bank));
8253         prg32(space->machine, bank);
8254      }
8255   }
8256}
8257
8258/*************************************************************
8259 
8260 Bootleg Board
8261
8262 Games: Super Fighter III
8263 
8264 MMC3 clone
8265 
8266 In MESS: Supported.
8267 
8268 *************************************************************/
8269
8270static void unl_sf3_set_chr( running_machine *machine, UINT8 chr_source, int chr_base, int chr_mask )
8271{
8272   nes_state *state = (nes_state *)machine->driver_data;
8273   chr4_0(machine, chr_base | ((state->mmc_vrom_bank[0] >> 1) & chr_mask), chr_source);
8274   chr2_4(machine, chr_base | (state->mmc_vrom_bank[1] & chr_mask), chr_source);
8275   chr2_6(machine, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr_source);
8276}
8277
8278static WRITE8_HANDLER( unl_sf3_w )
8279{
8280   nes_state *state = (nes_state *)space->machine->driver_data;
8281   UINT8 MMC3_helper, cmd;
8282   LOG_MMC(("unl_sf3_w, offset: %04x, data: %02x\n", offset, data));
8283   
8284   switch (offset & 0x6001)
8285   {
8286      case 0x0000:
8287         MMC3_helper = state->mmc_latch1 ^ data;
8288         state->mmc_latch1 = data;
8289         
8290         /* Has PRG Mode changed? */
8291         if (MMC3_helper & 0x40)
8292            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
8293         
8294         /* Has CHR Mode changed? */
8295         if (MMC3_helper & 0x80)
8296            unl_sf3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
8297         break;
8298         
8299      case 0x0001:
8300         cmd = state->mmc_latch1 & 0x0f;
8301         switch (cmd)
8302      {
8303         case 0: case 2: case 4:
8304            state->mmc_vrom_bank[cmd >> 1] = data;
8305            unl_sf3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
8306            break;
8307         case 6:
8308         case 7:
8309            state->mmc_prg_bank[cmd - 6] = data;
8310            mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
8311            break;
8312      }
8313         break;
8314         
8315      default:
8316         txrom_w(space, offset, data);
8317         break;
8318   }
8319}
8320
8321/*************************************************************
8322 
8323 Bootleg Board for Xiao Zhuan Yuan
8324
8325 Games: Shu Qi Yu - Zhi Li Xiao Zhuan Yuan
8326 
8327 Very simple mapper: writes to 0x5ff1 set prg32 (to data>>1),
8328 while writes to 0x5ff2 set chr8
8329 
8330 iNES: mapper 176
8331 
8332 In MESS: Supported.
8333 
8334 *************************************************************/
8335
8336static WRITE8_HANDLER( unl_xzy_l_w )
8337{
8338   LOG_MMC(("unl_xzy_l_w, offset: %04x, data: %02x\n", offset, data));
8339   
8340   switch (offset)
8341   {
8342      case 0x1ef1:   /* 0x5ff1 */
8343         prg32(space->machine, data >> 1);
8344         break;
8345      case 0x1ef2:   /* 0x5ff2 */
8346         chr8(space->machine, data, CHRROM);
8347         break;
8348   }
8349}
8350
8351/*************************************************************
8352 
8353        BOOTLEG CART VERSIONS OF FDS GAMES
8354 
8355 *************************************************************/
8356
8357/*************************************************************
8358 
8359 BTL-SUPERBROS11
8360 
8361 Known Boards: Unknown Bootleg Board
8362 Games: Super Mario Bros. 11, Super Mario Bros. 17
8363 
8364 This acts basically like a MMC3 with different use of write
8365 address.
8366 
8367 iNES: mapper 196
8368 
8369 In MESS: Supported.
8370 
8371 *************************************************************/
8372
8373static WRITE8_HANDLER( btl_smb11_w )
8374{
8375   LOG_MMC(("btl_smb11_w, offset: %04x, data: %02x\n", offset, data));
8376   
8377   txrom_w(space, (offset & 0x6000) | ((offset & 0x04) >> 2), data);
8378}
8379
8380/*************************************************************
8381 
8382 BTL-MARIOBABY
8383 
8384 Known Boards: Unknown Bootleg Board
8385 Games: Mario Baby, Ai Senshi Nicol
8386 
8387 iNES: mapper 42
8388
8389 In MESS: Supported.
8390 
8391 *************************************************************/
8392
8393// is the code fine for ai senshi nicol?!?
8394static WRITE8_HANDLER( btl_mariobaby_w )
8395{
8396   nes_state *state = (nes_state *)space->machine->driver_data;
8397   LOG_MMC(("btl_mariobaby_w, offset: %04x, data: %02x\n", offset, data));
8398   
8399   if (offset >= 0x7000)
8400   {
8401      switch(offset & 0x03)
8402      {
8403         case 0x00:
8404            prg8_67(space->machine, data);
8405            break;
8406         case 0x01:
8407            set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8408            break;
8409         case 0x02:
8410            /* Check if IRQ is being enabled */
8411            if (!state->IRQ_enable && (data & 0x02))
8412            {
8413               state->IRQ_enable = 1;
8414               timer_adjust_oneshot(state->irq_timer, cpu_clocks_to_attotime(state->maincpu, 24576), 0);
8415            }
8416            if (!(data & 0x02))
8417            {
8418               state->IRQ_enable = 0;
8419               timer_adjust_oneshot(state->irq_timer, attotime_never, 0);
8420            }
8421            break;
8422      }
8423   }
8424}
8425
8426/*************************************************************
8427 
8428 BTL-SMB2A
8429 
8430 Known Boards: Unknown Bootleg Board
8431 Games: Super Mario Bros. 2 Pirate (Jpn version of SMB2)
8432 
8433 iNES: mapper 40
8434 
8435 In MESS: Supported.
8436 
8437 *************************************************************/
8438
8439static void btl_smb2a_irq( running_device *device, int scanline, int vblank, int blanked )
8440{
8441   nes_state *state = (nes_state *)device->machine->driver_data;
8442   
8443   if (state->IRQ_enable)
8444   {
8445      if ((0xfff - state->IRQ_count) <= 114)
8446      {
8447         state->IRQ_count = (state->IRQ_count + 1) & 0xfff;
8448         state->IRQ_enable = 0;
8449         cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
8450      }
8451      else
8452         state->IRQ_count += 114;
8453   }
8454}
8455
8456static WRITE8_HANDLER( btl_smb2a_w )
8457{
8458   nes_state *state = (nes_state *)space->machine->driver_data;
8459   LOG_MMC(("btl_smb2a_w, offset: %04x, data: %02x\n", offset, data));
8460   
8461   switch (offset & 0x6000)
8462   {
8463      case 0x0000:
8464         state->IRQ_enable = 0;
8465         state->IRQ_count = 0;
8466         break;
8467      case 0x2000:
8468         state->IRQ_enable = 1;
8469         break;
8470      case 0x6000:
8471         prg8_cd(space->machine, data);
8472         break;
8473   }
8474}
8475
8476/*************************************************************
8477 
8478 BTL-SMB3
8479 
8480 Known Boards: Unknown Bootleg Board
8481 Games: Super Mario Bros. 3 Pirate
8482 
8483 iNES: mapper 106
8484 
8485 In MESS: Supported.
8486 
8487 *************************************************************/
8488
8489static void btl_smb3_irq( running_device *device, int scanline, int vblank, int blanked )
8490{
8491   nes_state *state = (nes_state *)device->machine->driver_data;
8492   
8493   if (state->IRQ_enable)
8494   {
8495      if ((0xffff - state->IRQ_count) < 114)
8496      {
8497         cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
8498         state->IRQ_enable = 0;
8499      }
8500     
8501      state->IRQ_count = (state->IRQ_count + 114) & 0xffff;
8502   }
8503}
8504
8505static WRITE8_HANDLER( btl_smb3_w )
8506{
8507   nes_state *state = (nes_state *)space->machine->driver_data;
8508   LOG_MMC(("btl_smb3_w, offset: %04x, data: %02x\n", offset, data));
8509   switch (offset & 0x0f)
8510   {
8511      case 0x00:
8512      case 0x02:
8513         chr1_x(space->machine, offset & 0x07, data & 0xfe, CHRROM);
8514         break;
8515      case 0x01:
8516      case 0x03:
8517         chr1_x(space->machine, offset & 0x07, data | 0x01, CHRROM);
8518         break;
8519      case 0x04: case 0x05:
8520      case 0x06: case 0x07:
8521         chr1_x(space->machine, offset & 0x07, data, CHRROM);
8522         break;
8523      case 0x08:
8524         prg8_89(space->machine, data | 0x10);
8525         break;
8526      case 0x09:
8527         prg8_ab(space->machine, data);
8528         break;
8529      case 0x0a:
8530         prg8_cd(space->machine, data);
8531         break;
8532      case 0x0b:
8533         prg8_ef(space->machine, data | 0x10);
8534         break;
8535      case 0x0c:
8536         set_nt_mirroring(space->machine, BIT(data, 0) ?  PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8537         break;
8538      case 0x0d:
8539         state->IRQ_count = 0;
8540         state->IRQ_enable = 0;
8541         break;
8542      case 0x0e:
8543         state->IRQ_count = (state->IRQ_count & 0xff00) | data;
8544         break;
8545      case 0x0f:
8546         state->IRQ_count = (state->IRQ_count & 0x00ff) | (data << 8);
8547         state->IRQ_enable = 1;
8548         break;
8549   }
8550}
8551
8552/*************************************************************
8553 
8554 BTL-DRAGONNINJA
8555 
8556 Known Boards: Unknown Bootleg Board
8557 Games: Dragon Ninja (Bootleg), Super Mario Bros. 8
8558 
8559 iNES: mapper 222
8560 
8561 In MESS: Unsupported.
8562 
8563 *************************************************************/
8564
8565/* Scanline based IRQ ? */
8566static void btl_dn_irq( running_device *device, int scanline, int vblank, int blanked )
8567{
8568   nes_state *state = (nes_state *)device->machine->driver_data;
8569   if (scanline < PPU_BOTTOM_VISIBLE_SCANLINE)
8570   {
8571      if (!state->IRQ_count || ++state->IRQ_count < 240)
8572         return;
8573     
8574      state->IRQ_count = 0;
8575      LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
8576             video_screen_get_vpos(device->machine->primary_screen), video_screen_get_hpos(device->machine->primary_screen)));
8577      cpu_set_input_line(state->maincpu, M6502_IRQ_LINE, HOLD_LINE);
8578   }
8579}
8580
8581static WRITE8_HANDLER( btl_dn_w )
8582{
8583   nes_state *state = (nes_state *)space->machine->driver_data;
8584   UINT8 bank;
8585   LOG_MMC(("btl_dn_w, offset: %04x, data: %02x\n", offset, data));
8586   
8587   switch (offset & 0x7003)
8588   {
8589      case 0x0000:
8590         prg8_89(space->machine, data);
8591         break;
8592      case 0x1000:
8593         set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8594         break;
8595      case 0x2000:
8596         prg8_ab(space->machine, data);
8597         break;
8598      case 0x3000:
8599      case 0x3002:
8600      case 0x4000:
8601      case 0x4002:
8602      case 0x5000:
8603      case 0x5002:
8604      case 0x6000:
8605      case 0x6002:
8606         bank = ((offset & 0x7000) - 0x3000) / 0x0800 + ((offset & 0x0002) >> 3);
8607         chr1_x(space->machine, bank, data, CHRROM);
8608         break;
8609      case 0x7000:
8610         state->IRQ_count = data;
8611         break;
8612   }
8613}
8614
8615/*************************************************************
8616
8617          MULTICART
8618
8619 *************************************************************/
8620
8621/*************************************************************
8622 
8623 Board BMC-64IN1NOREPEAT
8624 
8625 Games: 64-in-1 Y2K
8626 
8627 In MESS: Supported
8628 
8629 *************************************************************/
8630
8631static void bmc_64in1nr_set_prg( running_machine *machine )
8632{
8633   nes_state *state = (nes_state *)machine->driver_data;
8634   UINT8 helper1 = (state->bmc_64in1nr_reg[1] & 0x1f);
8635   UINT8 helper2 = (helper1 << 1) | ((state->bmc_64in1nr_reg[1] & 0x40) >> 6);
8636   
8637   if (state->bmc_64in1nr_reg[0] & 0x80)
8638   {
8639      if (state->bmc_64in1nr_reg[1] & 0x80)
8640         prg32(machine, helper1);
8641      else
8642      {
8643         prg16_89ab(machine, helper2);
8644         prg16_cdef(machine, helper2);
8645      }
8646   }
8647   else
8648      prg16_cdef(machine, helper2);
8649}
8650
8651static WRITE8_HANDLER( bmc_64in1nr_l_w )
8652{
8653   nes_state *state = (nes_state *)space->machine->driver_data;
8654   LOG_MMC(("bmc_64in1nr_l_w offset: %04x, data: %02x\n", offset, data));
8655   offset += 0x100;
8656   
8657   switch (offset)
8658   {
8659      case 0x1000:
8660      case 0x1001:
8661      case 0x1002:
8662      case 0x1003:
8663         state->bmc_64in1nr_reg[offset & 0x03] = data;
8664         bmc_64in1nr_set_prg(space->machine);
8665         chr8(space->machine, ((state->bmc_64in1nr_reg[0] >> 1) & 0x03) | (state->bmc_64in1nr_reg[2] << 2), CHRROM);
8666         break;
8667   }
8668   if (offset == 0x1000)   /* reg[0] also sets mirroring */
8669      set_nt_mirroring(space->machine, BIT(data, 5) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8670}
8671
8672static WRITE8_HANDLER( bmc_64in1nr_w )
8673{
8674   nes_state *state = (nes_state *)space->machine->driver_data;
8675   LOG_MMC(("bmc_64in1nr_w offset: %04x, data: %02x\n", offset, data));
8676   
8677   state->bmc_64in1nr_reg[3] = data;   // reg[3] is currently unused?!?
8678}
8679
8680/*************************************************************
8681 
8682 Board BMC-190IN1
8683 
8684 Games: 190-in-1
8685 
8686 In MESS: Supported
8687 
8688 *************************************************************/
8689
8690static WRITE8_HANDLER( bmc_190in1_w )
8691{
8692   LOG_MMC(("bmc_190in1_w offset: %04x, data: %02x\n", offset, data));
8693   
8694   set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8695   data >>= 2;
8696   prg16_89ab(space->machine, data);
8697   prg16_cdef(space->machine, data);
8698   chr8(space->machine, data, CHRROM);
8699}
8700
8701/*************************************************************
8702 
8703 Board BMC-A65AS
8704 
8705 Games: 3-in-1 (N068)
8706 
8707 In MESS: Supported
8708 
8709 *************************************************************/
8710
8711static WRITE8_HANDLER( bmc_a65as_w )
8712{
8713   UINT8 helper = (data & 0x30) >> 1;
8714   LOG_MMC(("bmc_a65as_w offset: %04x, data: %02x\n", offset, data));
8715   
8716   if (data & 0x80)
8717      set_nt_mirroring(space->machine, BIT(data, 5) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
8718   else
8719      set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8720   
8721   if (data & 0x40)
8722      prg32(space->machine, data >> 1);
8723   else
8724   {
8725      prg16_89ab(space->machine, helper | (data & 0x07));
8726      prg16_cdef(space->machine, helper | 0x07);
8727   }
8728}
8729
8730/*************************************************************
8731 
8732 Board BMC-GS2004
8733 
8734 Games: Tetris Family 6-in-1
8735 
8736 In MESS: Preliminary Support. It also misses WRAM handling
8737 (we need reads from 0x6000-0x7fff)
8738 
8739 *************************************************************/
8740
8741static WRITE8_HANDLER( bmc_gs2004_w )
8742{
8743   LOG_MMC(("bmc_gs2004_w offset: %04x, data: %02x\n", offset, data));
8744   
8745   prg32(space->machine, data);
8746}
8747
8748/*************************************************************
8749 
8750 Board BMC-GS2013
8751 
8752 Games: Tetris Family 12-in-1
8753 
8754 In MESS: Preliminary Support. It also misses WRAM handling
8755 (we need reads from 0x6000-0x7fff)
8756 
8757 *************************************************************/
8758
8759static WRITE8_HANDLER( bmc_gs2013_w )
8760{
8761   LOG_MMC(("bmc_gs2013_w offset: %04x, data: %02x\n", offset, data));
8762   
8763   if (data & 0x08)
8764      prg32(space->machine, data & 0x09);
8765   else
8766      prg32(space->machine, data & 0x07);
8767}
8768
8769/*************************************************************
8770 
8771 Board BMC-SUPER24IN1SC03
8772 
8773 Games: Super 24-in-1
8774 
8775 In MESS: Supported
8776 
8777 *************************************************************/
8778
8779static void bmc_s24in1sc03_set_prg( running_machine *machine )
8780{
8781   nes_state *state = (nes_state *)machine->driver_data;
8782   static const UINT8 masks[8] = {0x3f, 0x1f, 0x0f, 0x01, 0x03, 0x00, 0x00, 0x00};
8783   UINT8 prg_flip = (state->mmc_latch1 & 0x40) ? 2 : 0;
8784   int prg_base = state->bmc_s24in1sc03_reg[1] << 1;
8785   int prg_mask = masks[state->bmc_s24in1sc03_reg[0] & 0x07];
8786   
8787   prg8_89(machine, prg_base | (state->mmc_prg_bank[0 ^ prg_flip] & prg_mask));
8788   prg8_ab(machine, prg_base | (state->mmc_prg_bank[1] & prg_mask));
8789   prg8_cd(machine, prg_base | (state->mmc_prg_bank[2 ^ prg_flip] & prg_mask));
8790   prg8_ef(machine, prg_base | (state->mmc_prg_bank[3] & prg_mask));
8791}
8792
8793static void bmc_s24in1sc03_set_chr( running_machine *machine )
8794{
8795   nes_state *state = (nes_state *)machine->driver_data;
8796   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
8797   UINT8 chr = (state->bmc_s24in1sc03_reg[0] & 0x20) ? CHRRAM : CHRROM;
8798   int chr_base = (state->bmc_s24in1sc03_reg[2] << 3) & 0xf00;
8799   
8800   chr1_x(machine, chr_page ^ 0, chr_base | (state->mmc_vrom_bank[0] & ~0x01), chr);
8801   chr1_x(machine, chr_page ^ 1, chr_base | (state->mmc_vrom_bank[0] |  0x01), chr);
8802   chr1_x(machine, chr_page ^ 2, chr_base | (state->mmc_vrom_bank[1] & ~0x01), chr);
8803   chr1_x(machine, chr_page ^ 3, chr_base | (state->mmc_vrom_bank[1] |  0x01), chr);
8804   chr1_x(machine, chr_page ^ 4, chr_base | state->mmc_vrom_bank[2], chr);
8805   chr1_x(machine, chr_page ^ 5, chr_base | state->mmc_vrom_bank[3], chr);
8806   chr1_x(machine, chr_page ^ 6, chr_base | state->mmc_vrom_bank[4], chr);
8807   chr1_x(machine, chr_page ^ 7, chr_base | state->mmc_vrom_bank[5], chr);
8808}
8809
8810static WRITE8_HANDLER( bmc_s24in1sc03_l_w )
8811{
8812   nes_state *state = (nes_state *)space->machine->driver_data;
8813   LOG_MMC(("bmc_s24in1sc03_l_w offset: %04x, data: %02x\n", offset, data));
8814   offset += 0x100;
8815   
8816   if (offset == 0x1ff0)
8817   {
8818      state->bmc_s24in1sc03_reg[0] = data;
8819      bmc_s24in1sc03_set_prg(space->machine);
8820      bmc_s24in1sc03_set_chr(space->machine);
8821   }
8822   
8823   if (offset == 0x1ff1)
8824   {
8825      state->bmc_s24in1sc03_reg[1] = data;
8826      bmc_s24in1sc03_set_prg(space->machine);
8827   }
8828   
8829   if (offset == 0x1ff2)
8830   {
8831      state->bmc_s24in1sc03_reg[2] = data;
8832      bmc_s24in1sc03_set_chr(space->machine);
8833   }
8834}
8835
8836static WRITE8_HANDLER( bmc_s24in1sc03_w )
8837{
8838   nes_state *state = (nes_state *)space->machine->driver_data;
8839   UINT8 cmd, bmc_s24in1sc03_helper;
8840   LOG_MMC(("bmc_s24in1sc03_w offset: %04x, data: %02x\n", offset, data));
8841   
8842   switch (offset & 0x6001)
8843   {
8844      case 0x0000:
8845         bmc_s24in1sc03_helper = state->mmc_latch1 ^ data;
8846         state->mmc_latch1 = data;
8847         
8848         /* Has PRG Mode changed? */
8849         if (bmc_s24in1sc03_helper & 0x40)
8850            bmc_s24in1sc03_set_prg(space->machine);
8851         
8852         /* Has CHR Mode changed? */
8853         if (bmc_s24in1sc03_helper & 0x80)
8854            bmc_s24in1sc03_set_chr(space->machine);
8855         break;
8856         
8857      case 0x0001:
8858         cmd = state->mmc_latch1 & 0x07;
8859         switch (cmd)
8860      {
8861         case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
8862         case 2: case 3: case 4: case 5:
8863            state->mmc_vrom_bank[cmd] = data;
8864            bmc_s24in1sc03_set_chr(space->machine);
8865            break;
8866         case 6:
8867         case 7:
8868            state->mmc_prg_bank[cmd - 6] = data;
8869            bmc_s24in1sc03_set_prg(space->machine);
8870            break;
8871      }
8872         break;
8873         
8874      default:
8875         txrom_w(space, offset, data);
8876         break;
8877   }
8878}
8879
8880/*************************************************************
8881 
8882 Board BMC-T-262
8883 
8884 Games: 4-in-1 (D-010), 8-in-1 (A-020)
8885 
8886 In MESS: Supported
8887 
8888 *************************************************************/
8889
8890static WRITE8_HANDLER( bmc_t262_w )
8891{
8892   nes_state *state = (nes_state *)space->machine->driver_data;
8893   UINT8 mmc_helper;
8894   LOG_MMC(("bmc_t262_w offset: %04x, data: %02x\n", offset, data));
8895   
8896   if (state->mmc_latch2 || offset == 0)
8897   {
8898      state->mmc_latch1 = (state->mmc_latch1 & 0x38) | (data & 0x07);
8899      prg16_89ab(space->machine, state->mmc_latch1);
8900   }
8901   else
8902   {
8903      state->mmc_latch2 = 1;
8904      set_nt_mirroring(space->machine, BIT(data, 1) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8905      mmc_helper = ((offset >> 3) & 0x20) | ((offset >> 2) & 0x18);
8906      state->mmc_latch1 = mmc_helper | (state->mmc_latch1 & 0x07);
8907      prg16_89ab(space->machine, state->mmc_latch1);
8908      prg16_cdef(space->machine, mmc_helper | 0x07);
8909   }
8910}
8911
8912/*************************************************************
8913 
8914 Board BMC-WS
8915 
8916 Games: Super 40-in-1
8917 
8918 In MESS: Supported
8919 
8920 *************************************************************/
8921
8922static WRITE8_HANDLER( bmc_ws_m_w )
8923{
8924   nes_state *state = (nes_state *)space->machine->driver_data;
8925   UINT8 mmc_helper;
8926   LOG_MMC(("bmc_ws_m_w offset: %04x, data: %02x\n", offset, data));
8927   
8928   if (offset < 0x1000)
8929   {
8930      switch (offset & 0x01)
8931      {
8932         case 0:
8933            if (!state->mmc_latch1)
8934            {
8935               state->mmc_latch1 = data & 0x20;
8936               set_nt_mirroring(space->machine, BIT(data, 4) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
8937               mmc_helper = (~data & 0x08) >> 3;
8938               prg16_89ab(space->machine, data & ~mmc_helper);
8939               prg16_cdef(space->machine, data |  mmc_helper);
8940            }
8941            break;
8942         case 1:
8943            if (!state->mmc_latch1)
8944            {
8945               chr8(space->machine, data, CHRROM);
8946            }
8947            break;
8948      }
8949   }
8950}
8951
8952/*************************************************************
8953 
8954 BMC-NOVELDIAMOND and BMC-999999in1
8955 
8956 Unknown Bootleg Multigame Board
8957 Games: I only found 'Novel Diamond 999999-in-1.unf' using
8958 this mapper (hence the code is used for BMC_NOVELDIAMOND
8959 board). The code is included here in case a mapper 54
8960 dump arises.
8961 
8962 iNES: 54 and 213
8963
8964 In MESS: Partial Support.
8965 
8966 *************************************************************/
8967
8968// Are this correct or should they work the same?
8969static WRITE8_HANDLER( novel1_w )
8970{
8971   LOG_MMC(("novel1_w, offset: %04x, data: %02x\n", offset, data));
8972   
8973   prg32(space->machine, offset & 0x03);
8974   chr8(space->machine, offset & 0x07, CHRROM);
8975}
8976
8977static WRITE8_HANDLER( novel2_w )
8978{
8979   LOG_MMC(("novel2_w, offset: %04x, data: %02x\n", offset, data));
8980   
8981   prg32(space->machine, offset >> 1);
8982   chr8(space->machine, offset >> 3, CHRROM);
8983}
8984
8985/*************************************************************
8986 
8987 Board BMC-GKA
8988 
8989 Unknown Bootleg Multigame Board
8990 Games: 6 in 1, 54 in 1, 106 in 1
8991 
8992 iNES: mapper 57
8993
8994 In MESS: Supported.
8995 
8996 *************************************************************/
8997
8998static WRITE8_HANDLER( bmc_gka_w )
8999{
9000   nes_state *state = (nes_state *)space->machine->driver_data;
9001   LOG_MMC(("bmc_gka_w, offset: %04x, data: %02x\n", offset, data));
9002   
9003   if (offset & 0x0800)
9004      state->mmc_latch2 = data;
9005   else
9006      state->mmc_latch1 = data;
9007   
9008   if (state->mmc_latch2 & 0x80)
9009      prg32(space->machine, 2 | (state->mmc_latch2 >> 6));
9010   else
9011   {
9012      prg16_89ab(space->machine, (state->mmc_latch2 >> 5) & 0x03);
9013      prg16_cdef(space->machine, (state->mmc_latch2 >> 5) & 0x03);
9014   }
9015   
9016   set_nt_mirroring(space->machine, (state->mmc_latch2 & 0x08) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9017   
9018   chr8(space->machine, (state->mmc_latch1 & 0x03) | (state->mmc_latch2 & 0x07) | ((state->mmc_latch2 & 0x10) >> 1), CHRROM);
9019}
9020
9021
9022/*************************************************************
9023 
9024 Board BMC-GKB
9025 
9026 Unknown Bootleg Multigame Board
9027 Games: 68 in 1, 73 in 1, 98 in 1
9028 
9029 iNES: mapper 58
9030
9031 In MESS: Supported.
9032 
9033 *************************************************************/
9034
9035static WRITE8_HANDLER( bmc_gkb_w )
9036{
9037   UINT8 bank = (offset & 0x40) ? 0 : 1;
9038   LOG_MMC(("bmc_gkb_w, offset: %04x, data: %02x\n", offset, data));
9039   
9040   prg16_89ab(space->machine, offset & ~bank);
9041   prg16_cdef(space->machine, offset | bank);
9042   chr8(space->machine, offset >> 3, CHRROM);
9043   set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9044}
9045
9046/*************************************************************
9047 
9048 BMC-SUPER-700IN1
9049 
9050 Unknown Bootleg Multigame Board
9051 Games: Super 700 in 1
9052 
9053 iNES: mapper 62
9054
9055 In MESS: Supported.
9056 
9057 *************************************************************/
9058
9059static WRITE8_HANDLER( bmc_super700in1_w )
9060{
9061   LOG_MMC(("bmc_super700in1_w, offset :%04x, data: %02x\n", offset, data));
9062   
9063   chr8(space->machine, ((offset & 0x1f) << 2) | (data & 0x03), CHRROM);
9064   
9065   if (offset & 0x20)
9066   {
9067      prg16_89ab(space->machine, (offset & 0x40) | ((offset >> 8) & 0x3f));
9068      prg16_cdef(space->machine, (offset & 0x40) | ((offset >> 8) & 0x3f));
9069   }
9070   else
9071   {
9072      prg32(space->machine, ((offset & 0x40) | ((offset >> 8) & 0x3f)) >> 1);
9073   }
9074   
9075   set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9076}
9077
9078/*************************************************************
9079 
9080 BMC-36IN1
9081 
9082 Unknown Bootleg Multigame Board
9083 Games: 36 in 1, 1200 in 1
9084 
9085 iNES: mapper 200
9086 
9087 In MESS: Supported.
9088 
9089 *************************************************************/
9090
9091static WRITE8_HANDLER( bmc_36in1_w )
9092{
9093   LOG_MMC(("bmc_36in1_w, offset: %04x, data: %02x\n", offset, data));
9094   
9095   prg16_89ab(space->machine, offset & 0x07);
9096   prg16_cdef(space->machine, offset & 0x07);
9097   chr8(space->machine, offset & 0x07, CHRROM);
9098   
9099   set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9100}
9101
9102/*************************************************************
9103 
9104 BMC-21IN1
9105 
9106 Unknown Bootleg Multigame Board
9107 Games: 8 in 1, 21 in 1
9108 
9109 iNES: mapper 201
9110 
9111 In MESS: Supported.
9112 
9113 *************************************************************/
9114
9115static WRITE8_HANDLER( bmc_21in1_w )
9116{
9117   LOG_MMC(("bmc_21in1_w, offset: %04x, data: %02x\n", offset, data));
9118   
9119   prg32(space->machine, offset & 0x03);
9120   chr8(space->machine, offset & 0x03, CHRROM);
9121}
9122
9123/*************************************************************
9124 
9125 BMC-150IN1
9126 
9127 Unknown Bootleg Multigame Board
9128 Games: 150 in 1
9129 
9130 iNES: mapper 202
9131 
9132 In MESS: Supported.
9133 
9134 *************************************************************/
9135
9136static WRITE8_HANDLER( bmc_150in1_w )
9137{
9138   int bank = (offset >> 1) & 0x07;
9139   
9140   LOG_MMC(("bmc_150in1_w, offset: %04x, data: %02x\n", offset, data));
9141   
9142   prg16_89ab(space->machine, bank);
9143   prg16_cdef(space->machine, bank + (((bank & 0x06) == 0x06) ? 1 : 0));
9144   chr8(space->machine, bank, CHRROM);
9145   
9146   set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ: PPU_MIRROR_VERT);
9147}
9148
9149/*************************************************************
9150 
9151 BMC-35IN1
9152 
9153 Unknown Bootleg Multigame Board
9154 Games: 35 in 1
9155 
9156 iNES: mapper 203
9157 
9158 In MESS: Supported.
9159 
9160 *************************************************************/
9161
9162static WRITE8_HANDLER( bmc_35in1_w )
9163{
9164   LOG_MMC(("bmc_35in1_w, offset: %04x, data: %02x\n", offset, data));
9165   
9166   prg16_89ab(space->machine, (data >> 2) & 0x03);
9167   prg16_cdef(space->machine, (data >> 2) & 0x03);
9168   chr8(space->machine, data & 0x03, CHRROM);
9169}
9170
9171/*************************************************************
9172 
9173 BMC-64IN1
9174 
9175 Unknown Bootleg Multigame Board
9176 Games: 64 in 1
9177 
9178 iNES: mapper 204
9179 
9180 In MESS: Supported.
9181 
9182 *************************************************************/
9183
9184static WRITE8_HANDLER( bmc_64in1_w )
9185{
9186   int bank = (offset >> 1) & (offset >> 2) & 0x01;
9187   
9188   LOG_MMC(("bmc_64in1_w, offset: %04x, data: %02x\n", offset, data));
9189   
9190   prg16_89ab(space->machine, offset & ~bank);
9191   prg16_cdef(space->machine, offset | bank);
9192   chr8(space->machine, offset & ~bank, CHRROM);
9193   
9194   set_nt_mirroring(space->machine, BIT(data, 4) ? PPU_MIRROR_HORZ: PPU_MIRROR_VERT);
9195}
9196
9197/*************************************************************
9198 
9199 BMC-15IN1
9200 
9201 Unknown Bootleg Multigame Board
9202 Games: 3 in 1, 15 in 1
9203 
9204 iNES: mapper 205, MMC3 clone
9205 
9206 In MESS: Supported.
9207 
9208 *************************************************************/
9209
9210static WRITE8_HANDLER( bmc_15in1_m_w )
9211{
9212   nes_state *state = (nes_state *)space->machine->driver_data;
9213   LOG_MMC(("bmc_15in1_m_w, offset: %04x, data: %02x\n", offset, data));
9214   
9215   if (offset & 0x0800)
9216   {
9217      state->mmc_prg_base = (data & 0x03) << 4;
9218      state->mmc_prg_mask = (data & 0x02) ? 0x0f : 0x1f;
9219      state->mmc_chr_base = (data & 0x03) << 7;
9220      state->mmc_chr_mask = (data & 0x02) ? 0x7f : 0xff;
9221      mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9222      mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
9223   }
9224}
9225
9226/*************************************************************
9227 
9228 BMC-SUPERHIK_300IN1
9229 
9230 Unknown Bootleg Multigame Board
9231 Games: 100000 in 1, Super HIK 300 in 1, 1997 in 1
9232 
9233 iNES: mapper 212
9234
9235 In MESS: Supported.
9236 
9237 *************************************************************/
9238
9239static WRITE8_HANDLER( bmc_hik300_w )
9240{
9241   LOG_MMC(("bmc_hik300_w, offset: %04x, data: %02x\n", offset, data));
9242   
9243   set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9244   chr8(space->machine, offset, CHRROM);
9245   
9246   if (offset < 0x4000)
9247   {
9248      prg16_89ab(space->machine, offset);
9249      prg16_cdef(space->machine, offset);
9250   }
9251   else
9252      prg32(space->machine, offset >> 1);
9253}
9254
9255/*************************************************************
9256 
9257 BMC-SUPERGUN-20IN1
9258 
9259 Unknown Bootleg Multigame Board
9260 Games: Super Gun 20 in 1
9261 
9262 iNES: mapper 214
9263 
9264 In MESS: Supported.
9265 
9266 *************************************************************/
9267
9268static WRITE8_HANDLER( supergun20in1_w )
9269{
9270   LOG_MMC(("supergun20in1_w, offset: %04x, data: %02x\n", offset, data));
9271   
9272   prg16_89ab(space->machine, offset >> 2);
9273   prg16_cdef(space->machine, offset >> 2);
9274   chr8(space->machine, offset, CHRROM);
9275}
9276
9277/*************************************************************
9278 
9279 BMC-72IN1
9280 
9281 Unknown Bootleg Multigame Board
9282 Games: 72 in 1, 115 in 1 and other multigame carts
9283 
9284 iNES: mapper 225
9285 
9286 In MESS: Supported.
9287 
9288 *************************************************************/
9289
9290static WRITE8_HANDLER( bmc_72in1_w )
9291{
9292   int hi_bank;
9293   int size_16;
9294   int bank;
9295   
9296   LOG_MMC(("bmc_72in1_w, offset: %04x, data: %02x\n", offset, data));
9297   
9298   chr8(space->machine, offset, CHRROM);
9299   set_nt_mirroring(space->machine, (offset & 0x2000) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9300   
9301   hi_bank = offset & 0x40;
9302   size_16 = offset & 0x1000;
9303   bank = (offset & 0xf80) >> 7;
9304   if (size_16)
9305   {
9306      bank <<= 1;
9307      if (hi_bank)
9308         bank ++;
9309     
9310      prg16_89ab(space->machine, bank);
9311      prg16_cdef(space->machine, bank);
9312   }
9313   else
9314      prg32(space->machine, bank);
9315}
9316
9317/*************************************************************
9318 
9319 BMC-76IN1
9320 
9321 Unknown Bootleg Multigame Board
9322 Games: 76 in 1, Super 42 in 1
9323 
9324 iNES: mapper 226
9325 
9326 In MESS: Supported.
9327 
9328 *************************************************************/
9329
9330// does this work for super42in1 as well?!?
9331static WRITE8_HANDLER( bmc_76in1_w )
9332{
9333   nes_state *state = (nes_state *)space->machine->driver_data;
9334   int hi_bank;
9335   int size_16;
9336   int bank;
9337   
9338   LOG_MMC(("bmc_76in1_w, offset: %04x, data: %02x\n", offset, data));
9339   
9340   if (offset & 0x01)
9341      state->mmc_latch2 = data;
9342   else
9343      state->mmc_latch1 = data;
9344   
9345   set_nt_mirroring(space->machine, BIT(state->mmc_latch1, 6) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9346   
9347   hi_bank = state->mmc_latch1 & 0x01;
9348   size_16 = state->mmc_latch1 & 0x20;
9349   bank = ((state->mmc_latch1 & 0x1e) >> 1) | ((state->mmc_latch1 & 0x80) >> 3) | ((state->mmc_latch2 & 0x01) << 5);
9350   
9351   if (size_16)
9352   {
9353      bank <<= 1;
9354      if (hi_bank)
9355         bank ++;
9356     
9357      prg16_89ab(space->machine, bank);
9358      prg16_cdef(space->machine, bank);
9359   }
9360   else
9361      prg32(space->machine, bank);
9362}
9363
9364/*************************************************************
9365 
9366 BMC-1200IN1
9367 
9368 Unknown Bootleg Multigame Board
9369 Games: 1200 in 1, 295 in 1, 76 in 1
9370 
9371 iNES: mapper 227
9372 
9373 In MESS: Supported.
9374 
9375 *************************************************************/
9376
9377static WRITE8_HANDLER( bmc_1200in1_w )
9378{
9379   int hi_bank;
9380   int size_32;
9381   int bank;
9382   
9383   LOG_MMC(("bmc_1200in1_w, offset: %04x, data: %02x\n", offset, data));
9384   
9385   hi_bank = offset & 0x04;
9386   size_32 = offset & 0x01;
9387   bank = ((offset & 0x78) >> 3) | ((offset & 0x0100) >> 4);
9388   if (!size_32)
9389   {
9390      bank <<= 1;
9391      if (hi_bank)
9392         bank ++;
9393     
9394      prg16_89ab(space->machine, bank);
9395      prg16_cdef(space->machine, bank);
9396   }
9397   else
9398      prg32(space->machine, bank);
9399   
9400   if (!(offset & 0x80))
9401   {
9402      if (offset & 0x200)
9403         prg16_cdef(space->machine, ((bank << 1) & 0x38) + 7);
9404      else
9405         prg16_cdef(space->machine, ((bank << 1) & 0x38));
9406   }
9407   
9408   set_nt_mirroring(space->machine, BIT(data, 1) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9409}
9410
9411/*************************************************************
9412 
9413 BMC-31IN1
9414 
9415 Unknown Bootleg Multigame Board
9416 Games: 31 in 1
9417 
9418 iNES: mapper 229
9419 
9420 In MESS: Supported.
9421 
9422 *************************************************************/
9423
9424static WRITE8_HANDLER( bmc_31in1_w )
9425{
9426   LOG_MMC(("bmc_31in1_w, offset: %04x, data: %02x\n", offset, data));
9427   
9428   set_nt_mirroring(space->machine, BIT(data, 5) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9429   chr8(space->machine, offset, CHRROM);
9430   
9431   if ((offset & 0x1e) == 0)
9432   {
9433      prg16_89ab(space->machine, 0);
9434      prg16_89ab(space->machine, 1);
9435   }
9436   else
9437   {
9438      prg16_89ab(space->machine, offset & 0x1f);
9439      prg16_89ab(space->machine, offset & 0x1f);
9440   }
9441}
9442
9443/*************************************************************
9444 
9445 BMC-22GAMES
9446 
9447 Unknown Bootleg Multigame Board
9448 Games: 22 in 1
9449 
9450 iNES: mapper 230
9451 
9452 In MESS: Partially Supported. It would need a reset
9453 to work (not possible yet)
9454 
9455 *************************************************************/
9456
9457static WRITE8_HANDLER( bmc_22g_w )
9458{
9459   LOG_MMC(("bmc_22g_w, offset: %04x, data: %02x\n", offset, data));
9460   
9461   if (1)   // this should flip at reset
9462   {
9463      prg16_89ab(space->machine, data & 0x07);
9464   }
9465   else
9466   {
9467      if (data & 0x20)
9468      {
9469         prg16_89ab(space->machine, (data & 0x1f) + 8);
9470         prg16_cdef(space->machine, (data & 0x1f) + 8);
9471      }
9472      else
9473      {
9474         prg16_89ab(space->machine, (data & 0x1f) + 8);
9475         prg16_cdef(space->machine, (data & 0x1f) + 9);
9476      }
9477      set_nt_mirroring(space->machine, BIT(data, 6) ? PPU_MIRROR_VERT : PPU_MIRROR_HORZ);
9478   }
9479}
9480
9481/*************************************************************
9482 
9483 BMC-20IN1
9484 
9485 Unknown Bootleg Multigame Board
9486 Games: 20 in 1
9487 
9488 iNES: mapper 231
9489 
9490 In MESS: Supported.
9491 
9492 *************************************************************/
9493
9494static WRITE8_HANDLER( bmc_20in1_w )
9495{
9496   LOG_MMC(("bmc_20in1_w, offset: %04x, data: %02x\n", offset, data));
9497   
9498   set_nt_mirroring(space->machine, BIT(data, 7) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9499   
9500   prg16_89ab(space->machine, (offset & 0x1e));
9501   prg16_cdef(space->machine, (offset & 0x1e) | ((offset & 0x20) ? 1 : 0));
9502}
9503
9504/*************************************************************
9505 
9506 BMC-110IN1
9507 
9508 Known Boards: Unknown Bootleg Board
9509 Games: 110 in 1
9510 
9511 iNES: mapper 255
9512 
9513 In MESS: Preliminary support.
9514 
9515 *************************************************************/
9516
9517static WRITE8_HANDLER( bmc_110in1_w )
9518{
9519   UINT8 map255_helper1 = (offset >> 12) ? 0 : 1;
9520   UINT8 map255_helper2 = ((offset >> 8) & 0x40) | ((offset >> 6) & 0x3f);
9521   
9522   LOG_MMC(("bmc_110in1_w, offset: %04x, data: %02x\n", offset, data));
9523   
9524   set_nt_mirroring(space->machine, (offset & 0x2000) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9525   prg16_89ab(space->machine, map255_helper1 & ~map255_helper2);
9526   prg16_cdef(space->machine, map255_helper1 | map255_helper2);
9527   chr8(space->machine, ((offset >> 8) & 0x40) | (offset & 0x3f), CHRROM);
9528}
9529
9530/*************************************************************
9531 
9532 BMC-SUPERBIG-7IN1
9533 
9534 Known Boards: Unknown Multigame Bootleg Board
9535 Games: Kunio 8 in 1, Super Big 7 in 1
9536 
9537 iNES: mapper 44
9538 
9539 In MESS: Supported. It also uses mmc3_irq.
9540 
9541 *************************************************************/
9542
9543static WRITE8_HANDLER( bmc_sbig7_w )
9544{
9545   nes_state *state = (nes_state *)space->machine->driver_data;
9546   UINT8 page;
9547   LOG_MMC(("bmc_sbig7_w, offset: %04x, data: %02x\n", offset, data));
9548   
9549   switch (offset & 0x6001)
9550   {
9551      case 0x2001: /* $a001 - Select 128K ROM/VROM base (0..5) or last 256K ROM/VRAM base (6) */
9552         page = (data & 0x07);
9553         if (page > 6)
9554            page = 6;
9555         
9556         state->mmc_prg_base = page << 4;
9557         state->mmc_prg_mask = (page > 5) ? 0x1f : 0x0f;
9558         state->mmc_chr_base = page << 7;
9559         state->mmc_chr_mask = (page > 5) ? 0xff : 0x7f;
9560         mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9561         mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
9562         break;
9563         
9564      default:
9565         txrom_w(space, offset, data);
9566         break;
9567   }
9568}
9569
9570/*************************************************************
9571 
9572 BMC-HIK8IN1
9573 
9574 Known Boards: Unknown Multigame Bootleg Board
9575 Games: Street Fighter V, various multigame carts
9576 
9577 iNES: mapper 45
9578 
9579 In MESS: Supported. It also uses mmc3_irq.
9580 
9581 *************************************************************/
9582
9583static WRITE8_HANDLER( bmc_hik8_m_w )
9584{
9585   nes_state *state = (nes_state *)space->machine->driver_data;
9586   LOG_MMC(("bmc_hik8_m_w, offset: %04x, data: %02x\n", offset, data));
9587   
9588   /* This bit is the "register lock". Once register are locked, writes go to WRAM
9589    and there is no way to unlock them (except by resetting the machine) */
9590   if (state->mapper45_reg[3] & 0x40)
9591      state->wram[offset] = data;
9592   else
9593   {
9594      state->mapper45_reg[state->mmc_count] = data;
9595      state->mmc_count = (state->mmc_count + 1) & 0x03;
9596     
9597      if (!state->mmc_count)
9598      {
9599         LOG_MMC(("bmc_hik8_m_w, command completed %02x %02x %02x %02x\n", state->mapper45_reg[3],
9600                state->mapper45_reg[2], state->mapper45_reg[1], state->mapper45_reg[0]));
9601         
9602         state->mmc_prg_base = state->mapper45_reg[1];
9603         state->mmc_prg_mask = 0x3f ^ (state->mapper45_reg[3] & 0x3f);
9604         state->mmc_chr_base = ((state->mapper45_reg[2] & 0xf0) << 4) + state->mapper45_reg[0];
9605         state->mmc_chr_mask = 0xff >> (~state->mapper45_reg[2] & 0x0f);
9606         mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9607         mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
9608      }
9609   }
9610}
9611
9612/*************************************************************
9613 
9614 BMC-SUPERHIK-4IN1
9615 
9616 Known Boards: Unknown Multigame Bootleg Board
9617 Games: Super HIK 4 in 1
9618 
9619 iNES: mapper 49
9620 
9621 In MESS: Supported. It also uses mmc3_irq.
9622 
9623 *************************************************************/
9624
9625static WRITE8_HANDLER( bmc_hik4in1_m_w )
9626{
9627   nes_state *state = (nes_state *)space->machine->driver_data;
9628   LOG_MMC(("bmc_hik4in1_m_w, offset: %04x, data: %02x\n", offset, data));
9629   
9630   /* mid writes only work when WRAM is enabled. not sure if I should
9631    change the condition to state->mmc_latch2==0x80 (i.e. what is the effect of
9632    the read-only bit?) */
9633   if (state->mmc_latch2 & 0x80)
9634   {
9635      if (data & 0x01)   /* if this is 0, then we have 32k PRG blocks */
9636      {
9637         state->mmc_prg_base = (data & 0xc0) >> 2;
9638         state->mmc_prg_mask = 0x0f;
9639         mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9640      }
9641      else
9642         prg32(space->machine, (data & 0x30) >> 4);
9643     
9644      state->mmc_chr_base = (data & 0xc0) << 1;
9645      state->mmc_chr_mask = 0x7f;
9646      mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
9647   }
9648}
9649
9650/*************************************************************
9651 
9652 BMC-BALLGAMES-11IN1
9653 
9654 Known Boards: Unknown Multigame Bootleg Board
9655 Games: 11 in 1 Ball Games
9656 
9657 iNES: mapper 51
9658 
9659 In MESS: Partially Supported.
9660 
9661 *************************************************************/
9662
9663static void bmc_ball11_set_banks( running_machine *machine )
9664{
9665   nes_state *state = (nes_state *)machine->driver_data;
9666   set_nt_mirroring(machine, (state->mapper51_reg[0] == 3) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9667   
9668   if (state->mapper51_reg[0] & 0x01)
9669   {
9670      prg32(machine, state->mapper51_reg[1]);
9671   }
9672   else
9673   {
9674      prg16_89ab(machine, (state->mapper51_reg[1] << 1) | (state->mapper51_reg[0] >> 1));
9675      prg16_cdef(machine, (state->mapper51_reg[1] << 1) | 0x07);
9676   }
9677}
9678
9679static WRITE8_HANDLER( bmc_ball11_m_w )
9680{
9681   nes_state *state = (nes_state *)space->machine->driver_data;
9682   
9683   LOG_MMC(("bmc_ball11_m_w, offset: %04x, data: %02x\n", offset, data));
9684   
9685   state->mapper51_reg[0] = ((data >> 1) & 0x01) | ((data >> 3) & 0x02);
9686   bmc_ball11_set_banks(space->machine);
9687}
9688
9689static WRITE8_HANDLER( bmc_ball11_w )
9690{
9691   nes_state *state = (nes_state *)space->machine->driver_data;
9692   
9693   LOG_MMC(("bmc_ball11_w, offset: %04x, data: %02x\n", offset, data));
9694   
9695   switch (offset & 0x6000)
9696   {
9697      case 0x4000:   // here we also update reg[0] upper bit
9698         state->mapper51_reg[0] = (state->mapper51_reg[0] & 0x01) | ((data >> 3) & 0x02);
9699      case 0x0000:
9700      case 0x2000:
9701      case 0x6000:
9702         state->mapper51_reg[1] = data & 0x0f;
9703         bmc_ball11_set_banks(space->machine);
9704         break;
9705   }
9706}
9707
9708/*************************************************************
9709 
9710 BMC-MARIOPARTY-7IN1
9711 
9712 Known Boards: Unknown Multigame Bootleg Board
9713 Games: Mario 7 in 1
9714 
9715 MMC3 clone
9716 
9717 iNES: mapper 52
9718 
9719 In MESS: Supported.
9720 
9721 *************************************************************/
9722
9723static WRITE8_HANDLER( bmc_mario7in1_m_w )
9724{
9725   nes_state *state = (nes_state *)space->machine->driver_data;
9726   UINT8 map52_helper1, map52_helper2;
9727   LOG_MMC(("bmc_mario7in1_m_w, offset: %04x, data: %02x\n", offset, data));
9728   
9729   /* mid writes only work when WRAM is enabled. not sure if I should
9730    change the condition to state->mmc_latch2==0x80 (i.e. what is the effect of
9731    the read-only bit?) and it only can happen once! */
9732   if ((state->mmc_latch2 & 0x80) && !state->map52_reg_written)
9733   {
9734      map52_helper1 = (data & 0x08);
9735      map52_helper2 = (data & 0x40);
9736     
9737      state->mmc_prg_base = map52_helper1 ? ((data & 0x07) << 4) : ((data & 0x06) << 4);
9738      state->mmc_prg_mask = map52_helper1 ? 0x0f : 0x1f;
9739      state->mmc_chr_base = ((data & 0x20) << 4) | ((data & 0x04) << 6) | (map52_helper2 ? ((data & 0x10) << 3) : 0);
9740      state->mmc_chr_mask = map52_helper2 ? 0x7f : 0xff;
9741      mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9742      mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
9743     
9744      state->map52_reg_written = 1;
9745   }
9746   else
9747      state->wram[offset] = data;
9748}
9749
9750/*************************************************************
9751 
9752 BMC-GOLDENCARD-6IN1
9753 
9754 Known Boards: Unknown Bootleg Multigame Board
9755 Games: Golden Card 6 in 1
9756 
9757 MMC3 clone
9758 
9759 iNES: mapper 217
9760 
9761 In MESS: Supported.
9762 
9763 *************************************************************/
9764
9765// remove mask & base parameters!
9766static void bmc_gc6in1_set_prg( running_machine *machine, int prg_base, int prg_mask )
9767{
9768   nes_state *state = (nes_state *)machine->driver_data;
9769   state->mmc_prg_base = (state->map217_reg[1] & 0x08) ? 0 : (state->map217_reg[1] & 0x10);
9770   state->mmc_prg_mask = (state->map217_reg[1] & 0x08) ? 0x1f : 0x0f;
9771   
9772   state->mmc_prg_base |= ((state->map217_reg[1] & 0x03) << 5);
9773   
9774   mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
9775}
9776
9777static void bmc_gc6in1_set_chr( running_machine *machine, UINT8 chr )
9778{
9779   nes_state *state = (nes_state *)machine->driver_data;
9780   UINT8 chr_page = (state->mmc_latch1 & 0x80) >> 5;
9781   int chr_base = (state->map217_reg[1] & 0x08) ? 0x00 : ((state->map217_reg[1] & 0x10) << 3);
9782   int chr_mask = (state->map217_reg[1] & 0x08) ? 0xff : 0x7f;
9783   
9784   chr_base |= ((state->map217_reg[1] & 0x03) << 8);
9785   
9786   chr1_x(machine, chr_page ^ 0, chr_base | ((state->mmc_vrom_bank[0] & ~0x01) & chr_mask), chr);
9787   chr1_x(machine, chr_page ^ 1, chr_base | ((state->mmc_vrom_bank[0] |  0x01) & chr_mask), chr);
9788   chr1_x(machine, chr_page ^ 2, chr_base | ((state->mmc_vrom_bank[1] & ~0x01) & chr_mask), chr);
9789   chr1_x(machine, chr_page ^ 3, chr_base | ((state->mmc_vrom_bank[1] |  0x01) & chr_mask), chr);
9790   chr1_x(machine, chr_page ^ 4, chr_base | (state->mmc_vrom_bank[2] & chr_mask), chr);
9791   chr1_x(machine, chr_page ^ 5, chr_base | (state->mmc_vrom_bank[3] & chr_mask), chr);
9792   chr1_x(machine, chr_page ^ 6, chr_base | (state->mmc_vrom_bank[4] & chr_mask), chr);
9793   chr1_x(machine, chr_page ^ 7, chr_base | (state->mmc_vrom_bank[5] & chr_mask), chr);
9794}
9795
9796static WRITE8_HANDLER( bmc_gc6in1_l_w )
9797{
9798   nes_state *state = (nes_state *)space->machine->driver_data;
9799   UINT8 bank;
9800   LOG_MMC(("bmc_gc6in1_l_w, offset: %04x, data: %02x\n", offset, data));
9801   offset += 0x100;
9802   
9803   if (offset == 0x1000)
9804   {
9805      state->map217_reg[0] = data;
9806      if (data & 0x80)
9807      {
9808         bank = (data & 0x0f) | ((state->map217_reg[1] & 0x03) << 4);
9809         prg16_89ab(space->machine, bank);
9810         prg16_cdef(space->machine, bank);
9811      }
9812      else
9813         bmc_gc6in1_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9814   }
9815   else if (offset == 0x1001)
9816   {
9817      state->map217_reg[1] = data;
9818      bmc_gc6in1_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9819   }
9820   else if (offset == 0x1007)
9821   {
9822      state->map217_reg[2] = data;
9823   }
9824}
9825
9826static WRITE8_HANDLER( bmc_gc6in1_w )
9827{
9828   nes_state *state = (nes_state *)space->machine->driver_data;
9829   UINT8 MMC3_helper, cmd;
9830   static const UINT8 conv_table[8] = {0, 6, 3, 7, 5, 2, 4, 1};
9831   LOG_MMC(("bmc_gc6in1_w, offset: %04x, data: %02x\n", offset, data));
9832   
9833   if (!state->map217_reg[2]) // in this case we act like MMC3, only with alt prg/chr handlers
9834   {
9835      switch (offset & 0x6001)
9836      {
9837         case 0x0000:
9838            MMC3_helper = state->mmc_latch1 ^ data;
9839            state->mmc_latch1 = data;
9840           
9841            /* Has PRG Mode changed? */
9842            if (MMC3_helper & 0x40)
9843               bmc_gc6in1_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9844           
9845            /* Has CHR Mode changed? */
9846            if (MMC3_helper & 0x80)
9847               bmc_gc6in1_set_chr(space->machine, state->mmc_chr_source);
9848            break;
9849           
9850         case 0x0001:
9851            cmd = state->mmc_latch1 & 0x07;
9852            switch (cmd)
9853         {
9854            case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
9855            case 2: case 3: case 4: case 5:
9856               state->mmc_vrom_bank[cmd] = data;
9857               bmc_gc6in1_set_chr(space->machine, state->mmc_chr_source);
9858               break;
9859            case 6:
9860            case 7:
9861               state->mmc_prg_bank[cmd - 6] = data;
9862               bmc_gc6in1_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9863               break;
9864         }
9865            break;
9866           
9867         default:
9868            txrom_w(space, offset, data);
9869            break;
9870      }
9871   }
9872   else
9873   {
9874      switch (offset & 0x6001)
9875      {
9876         case 0x0000:
9877            txrom_w(space, 0xc000, data);
9878            break;
9879           
9880         case 0x0001:
9881            data = (data & 0xc0) | conv_table[data & 0x07];
9882            MMC3_helper = state->mmc_latch1 ^ data;
9883            state->mmc_latch1 = data;
9884           
9885            /* Has PRG Mode changed? */
9886            if (MMC3_helper & 0x40)
9887               bmc_gc6in1_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9888           
9889            /* Has CHR Mode changed? */
9890            if (MMC3_helper & 0x80)
9891               bmc_gc6in1_set_chr(space->machine, state->mmc_chr_source);
9892           
9893            state->map217_reg[3] = 1;
9894            break;
9895           
9896         case 0x2000:
9897            cmd = state->mmc_latch1 & 0x07;
9898            if (state->map217_reg[3])
9899            {
9900               state->map217_reg[3] = 0;
9901               switch (cmd)
9902               {
9903                  case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
9904                  case 2: case 3: case 4: case 5:
9905                     state->mmc_vrom_bank[cmd] = data;
9906                     bmc_gc6in1_set_chr(space->machine, state->mmc_chr_source);
9907                     break;
9908                  case 6:
9909                  case 7:
9910                     state->mmc_prg_bank[cmd - 6] = data;
9911                     bmc_gc6in1_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9912                     break;
9913               }
9914            }
9915            break;
9916           
9917           
9918         case 0x2001:
9919            set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
9920            break;
9921           
9922         default:
9923            txrom_w(space, offset, data);
9924            break;
9925      }
9926   }
9927}
9928
9929/*************************************************************
9930 
9931 BMC-FAMILY-4646B
9932 
9933 Known Boards: Unknown Multigame Bootleg Board (4646B)
9934 Games: 2 in 1 - Family Kid & Aladdin 4
9935 
9936 MMC3 clone
9937 
9938 iNES: mapper 134
9939 
9940 In MESS: Supported.
9941 
9942 *************************************************************/
9943
9944static WRITE8_HANDLER( bmc_family4646_m_w )
9945{
9946   nes_state *state = (nes_state *)space->machine->driver_data;
9947   LOG_MMC(("bmc_family4646_m_w, offset: %04x, data: %02x\n", offset, data));
9948   
9949   if (offset == 0x01)
9950   {
9951      state->mmc_prg_base = (data & 0x02) << 4;
9952      state->mmc_prg_mask = 0x1f;
9953      state->mmc_chr_base = (data & 0x20) << 3;
9954      state->mmc_chr_mask = 0xff;
9955      mmc3_set_prg(space->machine, state->mmc_prg_base, state->mmc_prg_mask);
9956      mmc3_set_chr(space->machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
9957   }
9958}
9959
9960
21989961typedef void (*nes_ppu_latch)(running_device *device, offs_t offset);
21999962
22009963struct nes_memory_accessor
r8270r8271
22249987#define NES_WRITEONLY(a) \
22259988{a, NULL}
22269989
9990// further review needed for: TXROM, PXROM, FXROM, all multicart pcb, many unl/btl pcbs
22279991static const nes_pcb_intf nes_intf_list[] =
22289992{
22299993   { STD_NROM,             NES_NOACCESS, NES_NOACCESS, NES_NOACCESS,                         NULL, NULL, NULL },
r8270r8271
22339997   { STD_UN1ROM,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(un1rom_w),              NULL, NULL, NULL },
22349998   { STD_CPROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(cprom_w),               NULL, NULL, NULL },
22359999   { STD_CNROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(cnrom_w),               NULL, NULL, NULL },
2236   { BANDAI_PT554,         NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(cnrom_w),               NULL, NULL, NULL },   
10000   { TENGEN_800008,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(cnrom_w),               NULL, NULL, NULL },
10001   { BANDAI_PT554,         NES_NOACCESS, NES_WRITEONLY(bandai_pt554_m_w), NES_WRITEONLY(cnrom_w), NULL, NULL, NULL },   
223710002   { STD_AXROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(axrom_w),               NULL, NULL, NULL },
223810003   { STD_PXROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(pxrom_w),               mmc2_latch, NULL, NULL },
223910004   { STD_FXROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(fxrom_w),               mmc2_latch, NULL, NULL },
r8270r8271
224910014   { STD_HKROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(hkrom_w),               NULL, NULL, mmc3_irq },
225010015   { STD_TQROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tqrom_w),               NULL, NULL, mmc3_irq },
225110016   { STD_TXSROM,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(txsrom_w),              NULL, NULL, mmc3_irq },
2252   { STD_DXROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dxrom_w),               NULL, NULL, mmc3_irq },
10017   { STD_DXROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dxrom_w),               NULL, NULL, NULL },
10018   { STD_DRROM,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dxrom_w),               NULL, NULL, NULL },
10019   { NAMCOT_34X3,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dxrom_w),               NULL, NULL, NULL },
10020   { NAMCOT_3425,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(namcot3425_w),          NULL, NULL, NULL },
10021   { NAMCOT_3446,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(namcot3446_w),          NULL, NULL, NULL },
10022   { NAMCOT_3453,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(namcot3453_w),          NULL, NULL, NULL },
225310023   { STD_EXROM,            {exrom_l_w, exrom_l_r}, NES_NOACCESS, NES_NOACCESS,               NULL, NULL, mmc5_irq },
225410024   { NES_QJ,               NES_NOACCESS, NES_WRITEONLY(qj_m_w), NES_WRITEONLY(txrom_w),      NULL, NULL, mmc3_irq },
225510025   { PAL_ZZ,               NES_NOACCESS, NES_WRITEONLY(zz_m_w), NES_WRITEONLY(txrom_w),      NULL, NULL, mmc3_irq },
10026   { UXROM_CC,             NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(uxrom_cc_w),            NULL, NULL, NULL },
225610027   //
2257   { DIS_74X139X74,        NES_NOACCESS, NES_WRITEONLY(mapper87_m_w), NES_NOACCESS,          NULL, NULL, NULL },
2258   { DIS_74X377,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper11_w),            NULL, NULL, NULL },
2259   { DIS_74X161X161X32,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper70_w),            NULL, NULL, NULL },
2260   { DIS_74X161X138,       NES_NOACCESS, NES_WRITEONLY(mapper38_m_w), NES_NOACCESS,          NULL, NULL, NULL },
2261   { AGCI_50282,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper144_w),           NULL, NULL, NULL },
10028   { DIS_74X139X74,        NES_NOACCESS, NES_WRITEONLY(dis_74x139x74_m_w), NES_NOACCESS,     NULL, NULL, NULL },
10029   { DIS_74X377,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dis_74x377_w),          NULL, NULL, NULL },
10030   { DIS_74X161X161X32,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dis_74x161x161x32_w),   NULL, NULL, NULL },
10031   { DIS_74X161X161X32_A,  NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(dis_74x161x161x32a_w),  NULL, NULL, NULL },
10032   { DIS_74X161X138,       NES_NOACCESS, NES_WRITEONLY(dis_74x161x138_m_w), NES_NOACCESS,    NULL, NULL, NULL },
10033   { BANDAI_LZ93,          NES_NOACCESS, NES_WRITEONLY(lz93d50_m_w), NES_WRITEONLY(lz93d50_w), NULL, NULL, bandai_lz_irq },
10034   { BANDAI_FCG,           NES_NOACCESS, NES_WRITEONLY(lz93d50_m_w), NES_WRITEONLY(lz93d50_w), NULL, NULL, bandai_lz_irq },
10035   { BANDAI_DATACH,        NES_NOACCESS, NES_WRITEONLY(lz93d50_m_w), NES_WRITEONLY(lz93d50_w), NULL, NULL, bandai_lz_irq },
10036   { BANDAI_JUMP2,         NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(fjump2_w),              NULL, NULL, bandai_lz_irq },
10037   { BANDAI_KARAOKE,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bandai_ks_w),           NULL, NULL, NULL },
10038   { BANDAI_OEKAKIDS,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bandai_ok_w),            NULL, NULL, NULL },
10039   { IREM_G101,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(g101_w),                NULL, NULL, NULL },
10040   { IREM_G101_A,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(g101a_w),               NULL, NULL, NULL },
10041   { IREM_LROG017,         NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(lrog017_w),             NULL, NULL, NULL },
10042   { IREM_H3001,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(h3001_w),               NULL, NULL, h3001_irq },
10043   { IREM_TAM_S1,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tam_s1_w),              NULL, NULL, NULL },
10044   { IREM_HOLYDIV,         NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(irem_hd_w),             NULL, NULL, NULL },
10045   { JALECO_SS88006,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(ss88006_w),             NULL, NULL, ss88006_irq },
10046   { JALECO_JF11,          NES_NOACCESS, NES_WRITEONLY(jf11_m_w), NES_NOACCESS,              NULL, NULL, NULL },
10047   { JALECO_JF13,          NES_NOACCESS, NES_WRITEONLY(jf13_m_w), NES_NOACCESS,              NULL, NULL, NULL },
10048   { JALECO_JF16,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(jf16_w),                NULL, NULL, NULL },
10049   { JALECO_JF17,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(jf17_w),                NULL, NULL, NULL },
10050   { JALECO_JF19,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(jf19_w),                NULL, NULL, NULL },
10051   { KONAMI_VRC1,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc1_w),         NULL, NULL, NULL },
10052   { KONAMI_VRC3,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc3_w),         NULL, NULL, konami_irq },
10053   { KONAMI_VRC7,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc7_w),         NULL, NULL, konami_irq },
10054   { NAMCOT_163,           {namcot163_l_w, namcot163_l_r}, NES_NOACCESS, NES_WRITEONLY(namcot163_w), NULL, NULL, namcot163_irq },
10055   { SUNSOFT_1,            NES_NOACCESS, NES_WRITEONLY(sunsoft1_m_w), NES_NOACCESS,          NULL, NULL, NULL },
10056   { SUNSOFT_2_A,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sunsoft2a_w),           NULL, NULL, NULL },
10057   { SUNSOFT_2_B,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sunsoft2b_w),           NULL, NULL, NULL },
10058   { SUNSOFT_3,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sunsoft3_w),            NULL, NULL, sunsoft3_irq },
10059   { TAITO_TC0190FMC,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tc0190fmc_w),           NULL, NULL, NULL },
10060   { TAITO_TC0190FMCP,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tc0190fmc_p16_w),       NULL, NULL, mmc3_irq },
10061   { TAITO_X1_005,         NES_NOACCESS, NES_WRITEONLY(x1005_m_w), NES_NOACCESS,             NULL, NULL, NULL },
10062   { TAITO_X1_005_A,       NES_NOACCESS, NES_WRITEONLY(x1005a_m_w), NES_NOACCESS,            NULL, NULL, NULL },
10063   { TAITO_X1_017,         NES_NOACCESS, NES_WRITEONLY(x1017_m_w), NES_NOACCESS,             NULL, NULL, NULL },
10064   //
10065   { AGCI_50282,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(agci_50282_w),          NULL, NULL, NULL },
10066   { ACTENT_ACT52,         NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(ae_act52_w),            NULL, NULL, NULL },
226210067   { AVE_NINA01,           NES_NOACCESS, NES_WRITEONLY(nina01_m_w), NES_NOACCESS,            NULL, NULL, NULL },
2263   { AVE_NINA06,           NES_WRITEONLY(mapper79_l_w), NES_NOACCESS, NES_NOACCESS,          NULL, NULL, NULL },
2264   { BANDAI_LZ93EX,        NES_NOACCESS, NES_WRITEONLY(mapper16_m_w), NES_WRITEONLY(mapper16_w),   NULL, NULL, bandai_irq },
2265   { BANDAI_FCG,           NES_NOACCESS, NES_WRITEONLY(mapper153_m_w), NES_WRITEONLY(mapper153_w),   NULL, NULL, bandai_irq },
2266   { BANDAI_JUMP2,         NES_NOACCESS, NES_WRITEONLY(mapper153_m_w), NES_WRITEONLY(mapper153_w),   NULL, NULL, bandai_irq },
2267   { BANDAI_DATACH,        NES_NOACCESS, NES_WRITEONLY(mapper16_m_w), NES_WRITEONLY(mapper16_w),   NULL, NULL, bandai_irq },
2268   { BANDAI_KARAOKE,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper188_w),           NULL, NULL, NULL },
2269   { BANDAI_OEKAKIDS,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper96_w),            NULL, NULL, NULL },
2270   { CAMERICA_ALGN,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper71_w),            NULL, NULL, NULL },
2271   { CAMERICA_9097,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper71_w),            NULL, NULL, NULL },
2272   { CAMERICA_ALGQ,        NES_NOACCESS, NES_WRITEONLY(mapper232_w), NES_WRITEONLY(mapper232_w),      NULL, NULL, NULL },
2273   { CAMERICA_GOLDENFIVE,  NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper104_w),           NULL, NULL, NULL },
2274   { CNE_DECATHLON,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper244_w),           NULL, NULL, NULL },
2275   { CNE_PSB,              NES_NOACCESS, NES_WRITEONLY(mapper246_m_w), NES_NOACCESS,         NULL, NULL, NULL },
2276   { CNE_SHLZ,             NES_WRITEONLY(mapper240_l_w), NES_NOACCESS, NES_NOACCESS,         NULL, NULL, NULL },
2277   { CONY_BOARD,           {mapper83_l_w, mapper83_l_r}, NES_NOACCESS, NES_WRITEONLY(mapper83_w),      NULL, NULL, NULL },
10068   { AVE_NINA06,           NES_WRITEONLY(nina06_l_w), NES_NOACCESS, NES_NOACCESS,            NULL, NULL, NULL },
10069   { CNE_DECATHLON,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(cne_decathl_w),         NULL, NULL, NULL },
10070   { CNE_FSB,              NES_NOACCESS, NES_WRITEONLY(cne_fsb_m_w), NES_NOACCESS,           NULL, NULL, NULL },
10071   { CNE_SHLZ,             NES_WRITEONLY(cne_shlz_l_w), NES_NOACCESS, NES_NOACCESS,          NULL, NULL, NULL },
10072   { CALTRON_6IN1,         NES_NOACCESS, NES_WRITEONLY(caltron6in1_m_w), NES_WRITEONLY(caltron6in1_w),      NULL, NULL, NULL },
10073   { CAMERICA_BF9093,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bf9093_w),              NULL, NULL, NULL },
10074   { CAMERICA_BF9097,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bf9097_w),              NULL, NULL, NULL },
10075   { CAMERICA_BF9096,      NES_NOACCESS, NES_WRITEONLY(bf9096_w), NES_WRITEONLY(bf9096_w),   NULL, NULL, NULL },
10076   { CAMERICA_GOLDENFIVE,  NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(golden5_w),             NULL, NULL, NULL },
10077   { CONY_BOARD,           {cony_l_w, cony_l_r}, NES_NOACCESS, NES_WRITEONLY(cony_w),        NULL, NULL, NULL },
227810078   { DREAMTECH_BOARD,      NES_WRITEONLY(dreamtech_l_w), NES_NOACCESS, NES_NOACCESS,         NULL, NULL, NULL },
2279   { FUTUREMEDIA_BOARD,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper117_w),           NULL, NULL, mapper117_irq },
2280   { GOUDER_37017,         {mapper208_l_w, mapper208_l_r}, NES_NOACCESS, NES_WRITEONLY(mapper208_w),      NULL, NULL, mmc3_irq },
2281   { HENGEDIANZI_BOARD,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper177_w),           NULL, NULL, NULL },
2282   { HES_BOARD,            NES_WRITEONLY(mapper113_l_w), NES_NOACCESS, NES_NOACCESS,         NULL, NULL, NULL },
2283   { HOSENKAN_BOARD,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper182_w),           NULL, NULL, mmc3_irq },
2284   { IREM_G101,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper32_w),            NULL, NULL, NULL },
2285   { IREM_LROG017,         NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper77_w),            NULL, NULL, NULL },
2286   { IREM_H3001,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper65_w),            NULL, NULL, irem_irq },
2287   { IREM_HOLYDIV,         NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper78_w),            NULL, NULL, NULL },
2288   { JALECO_SS88006,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper18_w),            NULL, NULL, jaleco_irq },
2289   { JALECO_JF11,          NES_NOACCESS, NES_WRITEONLY(mapper_140_m_w), NES_NOACCESS,        NULL, NULL, NULL },
2290   { JALECO_JF13,          NES_NOACCESS, NES_WRITEONLY(mapper86_m_w), NES_NOACCESS,          NULL, NULL, NULL },
2291   { JALECO_JF16,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper78_w),            NULL, NULL, NULL },
2292   { JALECO_JF17,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper72_w),            NULL, NULL, NULL },
2293   { JALECO_JF19,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper92_w),            NULL, NULL, NULL },
2294   { KAISER_KS7058,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper171_w),           NULL, NULL, NULL },
2295   { KAY_PANDAPRINCE,      {mapper121_l_w, mapper121_l_r}, NES_NOACCESS, NES_WRITEONLY(mapper121_w), NULL, NULL, mmc3_irq },
2296   { KASING_BOARD,         NES_NOACCESS, NES_WRITEONLY(mapper115_m_w), NES_WRITEONLY(mapper115_w),      NULL, NULL, mmc3_irq },
2297   { KONAMI_VRC1,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper75_w),            NULL, NULL, NULL },
2298   { KONAMI_VRC2,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc2a_w),        NULL, NULL, NULL },
2299   { KONAMI_VRC3,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper73_w),            NULL, NULL, konami_irq },
2300   { KONAMI_VRC4,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc4a_w),        NULL, NULL, konami_irq },
2301   { KONAMI_VRC6,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc6a_w),        NULL, NULL, konami_irq },
2302   { KONAMI_VRC7,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc7_w),         NULL, NULL, konami_irq },
2303   { MAGICSERIES_MAGICDRAGON,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper107_w),     NULL, NULL, NULL },
2304   { NAMCOT_163,           {mapper19_l_w, mapper19_l_r}, NES_NOACCESS, NES_WRITEONLY(mapper19_w), NULL, NULL, namcot_irq },
2305   { NAMCOT_3425,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper95_w),            NULL, NULL, NULL },
2306   { NAMCOT_34X3,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper88_w),            NULL, NULL, NULL },
2307   { NAMCOT_3446,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper76_w),            NULL, NULL, NULL },
2308   { NITRA_TDA,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper250_w),           NULL, NULL, mmc3_irq },
2309   { NTDEC_ASDER,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper112_w),           NULL, NULL, NULL },
2310   { NTDEC_FIGHTINGHERO,   NES_NOACCESS, NES_WRITEONLY(mapper193_m_w), NES_NOACCESS,         NULL, NULL, NULL },
2311   { OPENCORP_DAOU306,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper156_w),           NULL, NULL, NULL },
2312   { RCM_GS2015,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper216_w),           NULL, NULL, NULL },
2313   { RCM_TETRISFAMILY,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper61_w),            NULL, NULL, NULL },
2314   { REXSOFT_DBZ5,         {mapper12_l_w, mapper12_l_r}, NES_NOACCESS, NES_WRITEONLY(mapper12_w),      NULL, NULL, mmc3_irq },
2315   { REXSOFT_SL1632,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper14_w),            NULL, NULL, mmc3_irq },
2316   { RUMBLESTATION_BOARD,  NES_NOACCESS, NES_WRITEONLY(mapper46_m_w), NES_WRITEONLY(mapper46_w),      NULL, NULL, NULL },
2317   { SACHEN_74LS374,       {mapper150_l_w, mapper150_l_r}, NES_WRITEONLY(mapper150_m_w), NES_NOACCESS,      NULL, NULL, NULL },
2318   { SACHEN_8259A,         NES_WRITEONLY(mapper141_l_w), NES_WRITEONLY(mapper141_m_w), NES_NOACCESS,      NULL, NULL, NULL },
2319   { SACHEN_8259B,         NES_WRITEONLY(mapper138_l_w), NES_WRITEONLY(mapper138_m_w), NES_NOACCESS,      NULL, NULL, NULL },
2320   { SACHEN_8259C,         NES_WRITEONLY(mapper139_l_w), NES_WRITEONLY(mapper139_m_w), NES_NOACCESS,      NULL, NULL, NULL },
2321   { SACHEN_8259D,         NES_WRITEONLY(mapper137_l_w), NES_WRITEONLY(mapper137_m_w), NES_NOACCESS,      NULL, NULL, NULL },
2322   { SACHEN_SA0036,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper149_w),           NULL, NULL, NULL },
2323   { SACHEN_SA0037,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper148_w),           NULL, NULL, NULL },
2324   { SACHEN_SA72007,       NES_WRITEONLY(mapper145_l_w), NES_NOACCESS, NES_NOACCESS,         NULL, NULL, NULL },
2325   { SACHEN_SA72008,       NES_WRITEONLY(mapper133_l_w), NES_WRITEONLY(mapper133_m_w), NES_NOACCESS,      NULL, NULL, NULL },
2326   { SACHEN_TCA01,         NES_READONLY(mapper143_l_r), NES_NOACCESS, NES_NOACCESS,          NULL, NULL, NULL },
2327   { SACHEN_TCU01,         NES_WRITEONLY(mapper147_l_w), NES_WRITEONLY(mapper147_m_w), NES_WRITEONLY(mapper147_w),      NULL, NULL, NULL },
2328   { SACHEN_TCU02,         {mapper136_l_w, mapper136_l_r}, NES_NOACCESS, NES_NOACCESS,       NULL, NULL, NULL },
2329   { SUBOR_TYPE0,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper167_w),           NULL, NULL, NULL },
2330   { SUBOR_TYPE1,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper166_w),           NULL, NULL, NULL },
2331   { SUNSOFT_1,            NES_NOACCESS, NES_WRITEONLY(mapper184_m_w), NES_NOACCESS,         NULL, NULL, NULL },
2332   { SUNSOFT_2,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper89_w),            NULL, NULL, NULL },
2333   { SUNSOFT_3,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper67_w),            NULL, NULL, mapper67_irq },
2334   { SUPERGAME_BOOGERMAN,  NES_WRITEONLY(mapper215_l_w), NES_NOACCESS, NES_WRITEONLY(mapper215_w),      NULL, NULL, mmc3_irq },
2335   { SUPERGAME_LIONKING,   NES_NOACCESS, NES_WRITEONLY(mapper114_m_w), NES_WRITEONLY(mapper114_w),      NULL, NULL, mmc3_irq },
2336   { TAITO_TC0190FMC,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper33_w),            NULL, NULL, NULL },
2337   { TAITO_TC0190FMCP,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper48_w),            NULL, NULL, mmc3_irq },
2338   { TAITO_X1005,          NES_NOACCESS, NES_WRITEONLY(mapper80_m_w), NES_NOACCESS,          NULL, NULL, NULL },
2339   { TAITO_X1017,          NES_NOACCESS, NES_WRITEONLY(mapper82_m_w), NES_NOACCESS,          NULL, NULL, NULL },
2340   { TENGEN_800032,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper64_w),            NULL, NULL, mapper64_irq },
2341   { TENGEN_800037,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper158_w),           NULL, NULL, mapper64_irq },
2342   { TXC_22211A,           {mapper132_l_w, mapper132_l_r}, NES_NOACCESS, NES_WRITEONLY(mapper132_w),      NULL, NULL, NULL },
2343   { TXC_TW,               NES_WRITEONLY(mapper189_l_w), NES_WRITEONLY(mapper189_m_w), NES_WRITEONLY(mapper189_w),      NULL, NULL, mmc3_irq },
2344   { TXC_MXMDHTWO,         NES_READONLY(mapper241_l_r), NES_NOACCESS, NES_WRITEONLY(mapper241_w),      NULL, NULL, NULL },
10079   { FUTUREMEDIA_BOARD,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(futuremedia_w),         NULL, NULL, futuremedia_irq },
10080   { GOUDER_37017,         {gouder_sf4_l_w, gouder_sf4_l_r}, NES_NOACCESS, NES_WRITEONLY(gouder_sf4_w), NULL, NULL, mmc3_irq },
10081   { HENGEDIANZI_BOARD,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(henggedianzi_w),        NULL, NULL, NULL },
10082   { HENGEDIANZI_XJZB,     NES_WRITEONLY(heng_xjzb_l_w), NES_NOACCESS, NES_WRITEONLY(heng_xjzb_w), NULL, NULL, NULL },
10083   { HES6IN1_BOARD,        NES_WRITEONLY(hes6in1_l_w), NES_NOACCESS, NES_NOACCESS,           NULL, NULL, NULL },
10084   { HES_BOARD,            NES_WRITEONLY(hes_l_w), NES_NOACCESS, NES_NOACCESS,               NULL, NULL, NULL },
10085   { HOSENKAN_BOARD,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(hosenkan_w),            NULL, NULL, mmc3_irq },
10086   { KAISER_KS7058,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(ks7058_w),              NULL, NULL, NULL },
10087   { KAY_PANDAPRINCE,      {kay_pp_l_w, kay_pp_l_r}, NES_NOACCESS, NES_WRITEONLY(kay_pp_w),  NULL, NULL, mmc3_irq },
10088   { KASING_BOARD,         NES_NOACCESS, NES_WRITEONLY(kasing_m_w), NES_WRITEONLY(kasing_w), NULL, NULL, mmc3_irq },
10089   { SACHEN_74LS374,       {sachen_74x374_l_w, sachen_74x374_l_r}, NES_NOACCESS, NES_NOACCESS, NULL, NULL, NULL },
10090   { SACHEN_74LS374_A,     NES_WRITEONLY(sachen_74x374a_l_w), NES_NOACCESS, NES_NOACCESS,    NULL, NULL, NULL },
10091   { SACHEN_8259A,         NES_WRITEONLY(s8259_l_w), NES_WRITEONLY(s8259_m_w), NES_NOACCESS, NULL, NULL, NULL },
10092   { SACHEN_8259B,         NES_WRITEONLY(s8259_l_w), NES_WRITEONLY(s8259_m_w), NES_NOACCESS, NULL, NULL, NULL },
10093   { SACHEN_8259C,         NES_WRITEONLY(s8259_l_w), NES_WRITEONLY(s8259_m_w), NES_NOACCESS, NULL, NULL, NULL },
10094   { SACHEN_8259D,         NES_WRITEONLY(s8259_l_w), NES_WRITEONLY(s8259_m_w), NES_NOACCESS, NULL, NULL, NULL },
10095   { SACHEN_SA0036,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sa0036_w),              NULL, NULL, NULL },
10096   { SACHEN_SA0037,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sa0037_w),              NULL, NULL, NULL },
10097   { SACHEN_SA72007,       NES_WRITEONLY(sa72007_l_w), NES_NOACCESS, NES_NOACCESS,           NULL, NULL, NULL },
10098   { SACHEN_SA72008,       NES_WRITEONLY(sa72008_l_w), NES_NOACCESS, NES_NOACCESS,           NULL, NULL, NULL },
10099   { SACHEN_TCA01,         NES_READONLY(tca01_l_r), NES_NOACCESS, NES_NOACCESS,              NULL, NULL, NULL },
10100   { SACHEN_TCU01,         NES_WRITEONLY(tcu01_l_w), NES_WRITEONLY(tcu01_m_w), NES_WRITEONLY(tcu01_w), NULL, NULL, NULL },
10101   { SACHEN_TCU02,         {tcu02_l_w, tcu02_l_r}, NES_NOACCESS, NES_NOACCESS,               NULL, NULL, NULL },
10102   { SUBOR_TYPE0,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(subor0_w),              NULL, NULL, NULL },
10103   { SUBOR_TYPE1,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(subor1_w),              NULL, NULL, NULL },
10104   { MAGICSERIES_MD,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(magics_md_w),           NULL, NULL, NULL },
10105   { NITRA_TDA,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(nitra_w),               NULL, NULL, mmc3_irq },
10106   { NTDEC_ASDER,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(ntdec_asder_w),         NULL, NULL, NULL },
10107   { NTDEC_FIGHTINGHERO,   NES_NOACCESS, NES_WRITEONLY(ntdec_fh_m_w), NES_NOACCESS,          NULL, NULL, NULL },
10108   { OPENCORP_DAOU306,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(daou306_w),             NULL, NULL, NULL },
10109   { RCM_GS2015,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(gs2015_w),              NULL, NULL, NULL },
10110   { RCM_TETRISFAMILY,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(rcm_tf_w),              NULL, NULL, NULL },
10111   { REXSOFT_DBZ5,         {rex_dbz_l_w, rex_dbz_l_r}, NES_NOACCESS, NES_WRITEONLY(rex_dbz_w), NULL, NULL, mmc3_irq },
10112   { REXSOFT_SL1632,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(rex_sl1632_w),          NULL, NULL, mmc3_irq },
10113   { RUMBLESTATION_BOARD,  NES_NOACCESS, NES_WRITEONLY(rumblestation_m_w), NES_WRITEONLY(rumblestation_w),      NULL, NULL, NULL },
10114   { SUPERGAME_BOOGERMAN,  NES_WRITEONLY(sgame_boog_l_w), NES_NOACCESS, NES_WRITEONLY(sgame_boog_w), NULL, NULL, mmc3_irq },
10115   { SUPERGAME_LIONKING,   NES_NOACCESS, NES_WRITEONLY(sgame_lion_m_w), NES_WRITEONLY(sgame_lion_w), NULL, NULL, mmc3_irq },
10116   { TENGEN_800032,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tengen_800032_w),       NULL, NULL, tengen_800032_irq },
10117   { TENGEN_800037,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(tengen_800037_w),       NULL, NULL, tengen_800032_irq },
10118   { TXC_22211A,           {txc_22211_l_w, txc_22211_l_r}, NES_NOACCESS, NES_WRITEONLY(txc_22211_w), NULL, NULL, NULL },
10119   { TXC_22211B,           {txc_22211_l_w, txc_22211_l_r}, NES_NOACCESS, NES_WRITEONLY(txc_22211b_w), NULL, NULL, NULL },
10120   { TXC_22211C,           {txc_22211_l_w, txc_22211c_l_r}, NES_NOACCESS, NES_WRITEONLY(txc_22211_w), NULL, NULL, NULL },
10121   { TXC_TW,               NES_WRITEONLY(txc_tw_l_w), NES_WRITEONLY(txc_tw_m_w), NES_WRITEONLY(txc_tw_w), NULL, NULL, mmc3_irq },
10122   { TXC_MXMDHTWO,         NES_READONLY(txc_mxmdhtwo_l_r), NES_NOACCESS, NES_WRITEONLY(txc_mxmdhtwo_w), NULL, NULL, NULL },
10123   { WAIXING_TYPE_A,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_a_w),           NULL, NULL, mmc3_irq },
10124   { WAIXING_TYPE_B,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_b_w),           NULL, NULL, mmc3_irq },
10125   { WAIXING_TYPE_C,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_c_w),           NULL, NULL, mmc3_irq },
10126   { WAIXING_TYPE_D,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_d_w),           NULL, NULL, mmc3_irq },
10127   { WAIXING_TYPE_E,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_e_w),           NULL, NULL, mmc3_irq },
10128   { WAIXING_TYPE_F,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_f_w),           NULL, NULL, mmc3_irq },
10129   { WAIXING_TYPE_G,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_g_w),           NULL, NULL, mmc3_irq },
10130   { WAIXING_TYPE_H,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_h_w),           NULL, NULL, mmc3_irq },
10131   { WAIXING_SGZ,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_sgz_w),         NULL, NULL, konami_irq },
10132   { WAIXING_SGZLZ,        NES_WRITEONLY(waixing_sgzlz_l_w), NES_NOACCESS, NES_NOACCESS,     NULL, NULL, NULL },
10133   { WAIXING_FFV,          NES_WRITEONLY(waixing_ffv_l_w), NES_NOACCESS, NES_WRITEONLY(waixing_ffv_w), NULL, NULL, NULL },
10134   { WAIXING_ZS,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_zs_w),          NULL, NULL, NULL },
10135   { WAIXING_DQ8,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_dq8_w),         NULL, NULL, NULL },
10136   { WAIXING_SECURITY,     NES_WRITEONLY(waixing_sec_l_w), NES_NOACCESS, NES_WRITEONLY(waixing_sec_w), NULL, NULL, mmc3_irq },
10137   { WAIXING_PS2,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(waixing_ps2_w),         NULL, NULL, NULL },
234510138   { UNL_8237,             NES_WRITEONLY(unl_8237_l_w), NES_NOACCESS, NES_WRITEONLY(unl_8237_w),      NULL, NULL, mmc3_irq },
234610139   { UNL_AX5705,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(unl_ax5705_w),          NULL, NULL, NULL },
234710140   { UNL_CC21,             NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(unl_cc21_w),            NULL, NULL, NULL },
2348   { UNL_KOF96,            {mapper187_l_w, mapper187_l_r}, NES_NOACCESS, NES_WRITEONLY(mapper187_w),      NULL, NULL, mmc3_irq },
234910141    { UNL_KOF97,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(unl_kof97_w),           NULL, NULL, mmc3_irq },
2350   { UNL_MK2,              NES_NOACCESS, NES_WRITEONLY(mapper91_m_w), NES_NOACCESS,          NULL, NULL, mmc3_irq },
2351   { UNL_N625092,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper221_w),           NULL, NULL, NULL },
2352   { UNL_SC127,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper35_w),            NULL, NULL, mapper35_irq },
2353   { UNL_SMB2J,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper43_w),            NULL, NULL, NULL },
2354   { UNL_SUPERFIGHTER3,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper197_w),           NULL, NULL, mmc3_irq },
235510142    { UNL_T230,             NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(unl_t230_w),            NULL, NULL, konami_irq },
2356   { UNL_XZY,              NES_WRITEONLY(mapper176_l_w), NES_NOACCESS, NES_NOACCESS,         NULL, NULL, NULL },
2357   { WAIXING_TYPE_A,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper74_w),            NULL, NULL, mmc3_irq },
2358   { WAIXING_TYPE_B,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper191_w),           NULL, NULL, mmc3_irq },
2359   { WAIXING_TYPE_C,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper192_w),           NULL, NULL, mmc3_irq },
2360   { WAIXING_TYPE_D,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper194_w),           NULL, NULL, mmc3_irq },
2361   { WAIXING_TYPE_E,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper195_w),           NULL, NULL, mmc3_irq },
2362   { WAIXING_TYPE_F,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper198_w),           NULL, NULL, mmc3_irq },
2363   { WAIXING_TYPE_G,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper199_w),           NULL, NULL, mmc3_irq },
2364   { WAIXING_TYPE_H,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper245_w),           NULL, NULL, mmc3_irq },
2365   { WAIXING_SGZ,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper252_w),           NULL, NULL, konami_irq },
2366   { WAIXING_SGZLZ,        NES_WRITEONLY(mapper178_l_w), NES_NOACCESS, NES_NOACCESS,         NULL, NULL, NULL },
2367   { WAIXING_SECURITY,     NES_WRITEONLY(mapper249_l_w), NES_NOACCESS, NES_WRITEONLY(mapper249_w),      NULL, NULL, mmc3_irq },
2368   { WAIXING_FFV,          NES_WRITEONLY(mapper164_l_w), NES_NOACCESS, NES_WRITEONLY(mapper164_w),      NULL, NULL, NULL },
2369   { WAIXING_PS2,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper15_w),            NULL, NULL, NULL },
2370   { WAIXING_ZS,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper242_w),           NULL, NULL, NULL },
2371   { BTL_AISENSHINICOL,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper42_w),            NULL, NULL, NULL },
2372   { BTL_DRAGONNINJA,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper222_w),           NULL, NULL, mapper222_irq },
2373   { BTL_MARIOBABY,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper42_w),            NULL, NULL, NULL },
2374   { BTL_SMB2A,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper40_w),            NULL, NULL, mapper40_irq },
2375   { BTL_SMB2B,            NES_WRITEONLY(mapper50_l_w), NES_NOACCESS, NES_NOACCESS,          NULL, NULL, mapper50_irq },
2376   { BTL_SMB3,             NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper106_w),           NULL, NULL, mapper106_irq },
2377   { BTL_SUPERBROS11,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper196_w),           NULL, NULL, mmc3_irq },
2378   { ACTENT_ACT52,         NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper228_w),           NULL, NULL, NULL },
2379   { CALTRON_6IN1,         NES_NOACCESS, NES_WRITEONLY(mapper41_m_w), NES_WRITEONLY(mapper41_w),      NULL, NULL, NULL },
10143   { UNL_KOF96,            {kof96_l_w, kof96_l_r}, NES_NOACCESS, NES_WRITEONLY(kof96_w),     NULL, NULL, mmc3_irq },
10144   { UNL_MK2,              NES_NOACCESS, NES_WRITEONLY(mk2_m_w), NES_NOACCESS,               NULL, NULL, mmc3_irq },
10145   { UNL_N625092,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(n625092_w),             NULL, NULL, NULL },
10146   { UNL_SC127,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(sc127_w),               NULL, NULL, sc127_irq },
10147   { UNL_SMB2J,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(smb2j_w),               NULL, NULL, NULL },
10148   { UNL_SUPERFIGHTER3,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(unl_sf3_w),             NULL, NULL, mmc3_irq },
10149   { UNL_XZY,              NES_WRITEONLY(unl_xzy_l_w), NES_NOACCESS, NES_NOACCESS,           NULL, NULL, NULL },
10150   //
10151   { BTL_AISENSHINICOL,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_mariobaby_w),       NULL, NULL, NULL },
10152   { BTL_DRAGONNINJA,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_dn_w),              NULL, NULL, btl_dn_irq },
10153   { BTL_MARIOBABY,        NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_mariobaby_w),       NULL, NULL, NULL },
10154   { BTL_SMB2A,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_smb2a_w),           NULL, NULL, btl_smb2a_irq },
10155   { BTL_SMB3,             NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_smb3_w),            NULL, NULL, btl_smb3_irq },
10156   { BTL_SUPERBROS11,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(btl_smb11_w),           NULL, NULL, mmc3_irq },
10157   //
238010158   { BMC_190IN1,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_190in1_w),          NULL, NULL, NULL },
238110159   { BMC_A65AS,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_a65as_w),           NULL, NULL, NULL },
238210160   { BMC_GS2004,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_gs2004_w),          NULL, NULL, NULL },
238310161   { BMC_GS2013,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_gs2013_w),          NULL, NULL, NULL },
2384   { BMC_NOVELDIAMOND,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper54_w),            NULL, NULL, NULL },
10162   { BMC_NOVELDIAMOND,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(novel1_w),              NULL, NULL, NULL },
10163   { BMC_9999999IN1,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(novel2_w),              NULL, NULL, NULL },
238510164   { BMC_T262,             NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_t262_w),            NULL, NULL, NULL },
238610165   { BMC_WS,               NES_NOACCESS, NES_WRITEONLY(bmc_ws_m_w), NES_NOACCESS,            NULL, NULL, NULL },
2387   { BMC_GKA,              NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper57_w),            NULL, NULL, NULL },
2388   { BMC_GKB,              NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper58_w),            NULL, NULL, NULL },
2389   { BMC_SUPER_700IN1,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper62_w),            NULL, NULL, NULL },
2390   { BMC_36IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper200_w),           NULL, NULL, NULL },
2391   { BMC_21IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper201_w),           NULL, NULL, NULL },
2392   { BMC_150IN1,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper202_w),           NULL, NULL, NULL },
2393   { BMC_35IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper203_w),           NULL, NULL, NULL },
2394   { BMC_64IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper204_w),           NULL, NULL, NULL },
2395   { BMC_SUPERHIK_300IN1,  NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper212_w),           NULL, NULL, NULL },
2396   { BMC_9999999IN1,       NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper213_w),           NULL, NULL, NULL },
2397   { BMC_SUPERGUN_20IN1,   NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper214_w),           NULL, NULL, NULL },
2398   { BMC_72IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper225_w),           NULL, NULL, NULL },
2399   { BMC_76IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper226_w),           NULL, NULL, NULL },
2400   { BMC_SUPER_42IN1,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper226_w),           NULL, NULL, NULL },
2401   { BMC_1200IN1,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper227_w),           NULL, NULL, NULL },
2402   { BMC_31IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper229_w),           NULL, NULL, NULL },
2403   { BMC_22GAMES,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper230_w),           NULL, NULL, NULL },
2404   { BMC_20IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper231_w),           NULL, NULL, NULL },
2405   { BMC_110IN1,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper255_w),           NULL, NULL, NULL },
10166   { BMC_GKA,              NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_gka_w),             NULL, NULL, NULL },
10167   { BMC_GKB,              NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_gkb_w),             NULL, NULL, NULL },
10168   { BMC_SUPER_700IN1,     NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_super700in1_w),     NULL, NULL, NULL },
10169   { BMC_36IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_36in1_w),           NULL, NULL, NULL },
10170   { BMC_21IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_21in1_w),           NULL, NULL, NULL },
10171   { BMC_150IN1,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_150in1_w),          NULL, NULL, NULL },
10172   { BMC_35IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_35in1_w),           NULL, NULL, NULL },
10173   { BMC_64IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_64in1_w),           NULL, NULL, NULL },
10174   { BMC_SUPERHIK_300IN1,  NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_hik300_w),          NULL, NULL, NULL },
10175   { BMC_SUPERGUN_20IN1,   NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(supergun20in1_w),       NULL, NULL, NULL },
10176   { BMC_72IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_72in1_w),           NULL, NULL, NULL },
10177   { BMC_76IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_76in1_w),           NULL, NULL, NULL },
10178   { BMC_SUPER_42IN1,      NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_76in1_w),           NULL, NULL, NULL },
10179   { BMC_1200IN1,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_1200in1_w),         NULL, NULL, NULL },
10180   { BMC_31IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_31in1_w),           NULL, NULL, NULL },
10181   { BMC_22GAMES,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_22g_w),             NULL, NULL, NULL },
10182   { BMC_20IN1,            NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_20in1_w),           NULL, NULL, NULL },
10183   { BMC_110IN1,           NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_110in1_w),          NULL, NULL, NULL },
240610184   { BMC_64IN1NR,          NES_WRITEONLY(bmc_64in1nr_l_w), NES_NOACCESS, NES_WRITEONLY(bmc_64in1nr_w),      NULL, NULL, NULL },
240710185   { BMC_S24IN1SC03,       NES_WRITEONLY(bmc_s24in1sc03_l_w), NES_NOACCESS, NES_WRITEONLY(bmc_s24in1sc03_w),      NULL, NULL, mmc3_irq },
2408   { BMC_HIK8IN1,          NES_NOACCESS, NES_WRITEONLY(mapper45_m_w), NES_WRITEONLY(txrom_w),      NULL, NULL, mmc3_irq },
2409   { BMC_SUPERHIK_4IN1,    NES_NOACCESS, NES_WRITEONLY(mapper49_m_w), NES_WRITEONLY(txrom_w),      NULL, NULL, mmc3_irq },
2410   { BMC_SUPERBIG_7IN1,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(mapper44_w),            NULL, NULL, mmc3_irq },
2411   { BMC_MARIOPARTY_7IN1,  NES_NOACCESS, NES_WRITEONLY(mapper52_m_w), NES_WRITEONLY(txrom_w),      NULL, NULL, mmc3_irq },
2412   { BMC_FAMILY_4646B,     NES_NOACCESS, NES_WRITEONLY(mapper134_m_w), NES_WRITEONLY(txrom_w),      NULL, NULL, mmc3_irq },
2413   { BMC_15IN1,            NES_NOACCESS, NES_WRITEONLY(mapper205_m_w), NES_WRITEONLY(txrom_w),      NULL, NULL, mmc3_irq },
2414   { BMC_BALLGAMES_11IN1,  NES_NOACCESS, NES_WRITEONLY(mapper51_m_w), NES_WRITEONLY(mapper51_w),      NULL, NULL, NULL },
2415   { BMC_GOLDENCARD_6IN1,  NES_WRITEONLY(mapper217_l_w), NES_NOACCESS, NES_WRITEONLY(mapper217_w),      NULL, NULL, mmc3_irq },
10186   { BMC_HIK8IN1,          NES_NOACCESS, NES_WRITEONLY(bmc_hik8_m_w), NES_WRITEONLY(txrom_w), NULL, NULL, mmc3_irq },
10187   { BMC_SUPERHIK_4IN1,    NES_NOACCESS, NES_WRITEONLY(bmc_hik4in1_m_w), NES_WRITEONLY(txrom_w), NULL, NULL, mmc3_irq },
10188   { BMC_SUPERBIG_7IN1,    NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(bmc_sbig7_w),           NULL, NULL, mmc3_irq },
10189   { BMC_MARIOPARTY_7IN1,  NES_NOACCESS, NES_WRITEONLY(bmc_mario7in1_m_w), NES_WRITEONLY(txrom_w), NULL, NULL, mmc3_irq },
10190   { BMC_FAMILY_4646B,     NES_NOACCESS, NES_WRITEONLY(bmc_family4646_m_w), NES_WRITEONLY(txrom_w), NULL, NULL, mmc3_irq },
10191   { BMC_15IN1,            NES_NOACCESS, NES_WRITEONLY(bmc_15in1_m_w), NES_WRITEONLY(txrom_w), NULL, NULL, mmc3_irq },
10192   { BMC_BALLGAMES_11IN1,  NES_NOACCESS, NES_WRITEONLY(bmc_ball11_m_w), NES_WRITEONLY(bmc_ball11_w), NULL, NULL, NULL },
10193   { BMC_GOLDENCARD_6IN1,  NES_WRITEONLY(bmc_gc6in1_l_w), NES_NOACCESS, NES_WRITEONLY(bmc_gc6in1_w), NULL, NULL, mmc3_irq },
241610194   { UNSUPPORTED_BOARD,    NES_NOACCESS, NES_NOACCESS, NES_NOACCESS,                         NULL, NULL, NULL },
10195   //
10196   //   { KONAMI_VRC2,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc2a_w),        NULL, NULL, NULL },
10197   //   { KONAMI_VRC4,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc4a_w),        NULL, NULL, konami_irq },
10198   //   { KONAMI_VRC6,          NES_NOACCESS, NES_NOACCESS, NES_WRITEONLY(konami_vrc6a_w),        NULL, NULL, konami_irq },
10199   //   { BTL_SMB2B,            NES_WRITEONLY(mapper50_l_w), NES_NOACCESS, NES_NOACCESS,          NULL, NULL, mapper50_irq },
241710200};
241810201
241910202
r8270r8271
246110244   return pcb->pcb_id;
246210245}
246310246
10247void nes_pcb_setup( running_machine *machine, int ID )
10248{
10249   nes_state *state = (nes_state *)machine->driver_data;
10250
10251   if (ID == STD_TVROM || ID == STD_DRROM || ID == IREM_LROG017)
10252      state->four_screen_vram = 1;
10253}
10254   
246410255void pcb_handlers_setup( running_machine *machine )
246510256{
246610257   nes_state *state = (nes_state *)machine->driver_data;
src/mess/machine/nes.c
r8270r8271
4343   state->vrom = memory_region(machine, "gfx1");
4444   state->vram = memory_region(machine, "gfx2");
4545   state->ciram = memory_region(machine, "gfx3");
46   // FIXME: this should only be allocated if there is actual wram in the cart!
47   if (state->wram == NULL)
48   {
49      state->wram_size = 0x10000;
50      state->wram = auto_alloc_array(machine, UINT8, state->wram_size);
51   }
5246
5347   /* Brutal hack put in as a consequence of the new memory system; we really need to fix the NES code */
5448   memory_install_readwrite_bank(space, 0x0000, 0x07ff, 0, 0x1800, "bank10");
r8270r8271
119113         memory_configure_bank(machine, "bank5", 0, prg_banks, memory_region(machine, "maincpu") + 0x10000, 0x2000);
120114         state->battery_bank5_start = prg_banks;
121115         state->prgram_bank5_start = prg_banks;
116         state->empty_bank5_start = prg_banks;
117
122118         /* add battery ram, but only if there's no trainer since they share overlapping memory. */
123119         if (state->battery && !state->trainer)
124120         {
r8270r8271
126122            int bank_num = (state->battery_size > 0x2000) ? state->battery_size / 0x2000 : 1;
127123            memory_configure_bank(machine, "bank5", prg_banks, bank_num, state->battery_ram, bank_size);
128124            state->prgram_bank5_start += bank_num;
125            state->empty_bank5_start += bank_num;
129126         }
130127         /* add prg ram. */
131128         if (state->prg_ram)
129         {
132130            memory_configure_bank(machine, "bank5", state->prgram_bank5_start, state->wram_size / 0x2000, state->wram, 0x2000);
131            state->empty_bank5_start += state->wram_size / 0x2000;
132         }
133133
134         memory_configure_bank(machine, "bank5", state->empty_bank5_start, 1, state->rom + 0x6000, 0x2000);
135         
134136         /* if we have any additional PRG RAM, point bank5 to its first bank */
135137         if (state->battery || state->prg_ram)
136138            state->prg_bank[4] = state->battery_bank5_start;
137139         else
138            state->prg_bank[4] = 0; // or shall we point to "maincpu" region at 0x6000? point is that we should never access this region if no sram or wram is present!
140            state->prg_bank[4] = state->empty_bank5_start; // or shall we point to "maincpu" region at 0x6000? point is that we should never access this region if no sram or wram is present!
139141
140142         memory_set_bank(machine, "bank5", state->prg_bank[4]);
141143
144         if (state->four_screen_vram)
145         {
146            state->extended_ntram = auto_alloc_array(machine, UINT8, 0x2000);
147            state_save_register_global_pointer(machine, state->extended_ntram, 0x2000);
148         }
149
150         printf("SRAM %d PRGRAM %d bank5 %d\n", state->battery_bank5_start, state->prgram_bank5_start, state->prg_bank[4]);
142151         // there are still some quirk about writes to bank5... I hope to fix them soon. (mappers 34,45,52,246 have both mid_w and WRAM-->check)
143152         if (state->mmc_write_mid)
144153            memory_install_write8_handler(space, 0x6000, 0x7fff, 0, 0, nes_mid_mapper_w);
r8270r8271
10121021      state->format = 3;
10131022      state->mapper = 0;      // this allows us to set up memory handlers without duplicating code (for the moment)
10141023      state->pcb_id = nes_get_pcb_id(image->machine, image_get_feature(image));
1024     
1025      // setup NMT etc.
1026      nes_pcb_setup(image->machine, state->pcb_id);
10151027
10161028      state->battery = (image_get_software_region(image, "bwram") != NULL) ? 1 : 0;
10171029      state->battery_size = image_get_software_region_length(image, "bwram");
src/mess/machine/nes_unif.c
r8270r8271
2222   int board_idx;
2323} unif;
2424
25/*************************************************************
2625
27    Board BMC-64IN1NOREPEAT
28
29    Games: 64-in-1 Y2K
30
31    In MESS: Supported
32
33*************************************************************/
34
35static void bmc_64in1nr_set_prg( running_machine *machine )
36{
37   nes_state *state = (nes_state *)machine->driver_data;
38   UINT8 helper1 = (state->bmc_64in1nr_reg[1] & 0x1f);
39   UINT8 helper2 = (helper1 << 1) | ((state->bmc_64in1nr_reg[1] & 0x40) >> 6);
40
41   if (state->bmc_64in1nr_reg[0] & 0x80)
42   {
43      if (state->bmc_64in1nr_reg[1] & 0x80)
44         prg32(machine, helper1);
45      else
46      {
47         prg16_89ab(machine, helper2);
48         prg16_cdef(machine, helper2);
49      }
50   }
51   else
52      prg16_cdef(machine, helper2);
53}
54
55static WRITE8_HANDLER( bmc_64in1nr_l_w )
56{
57   nes_state *state = (nes_state *)space->machine->driver_data;
58   LOG_MMC(("bmc_64in1nr_l_w offset: %04x, data: %02x\n", offset, data));
59   offset += 0x100;
60
61   switch (offset)
62   {
63   case 0x1000:
64   case 0x1001:
65   case 0x1002:
66   case 0x1003:
67      state->bmc_64in1nr_reg[offset & 0x03] = data;
68      bmc_64in1nr_set_prg(space->machine);
69      chr8(space->machine, ((state->bmc_64in1nr_reg[0] >> 1) & 0x03) | (state->bmc_64in1nr_reg[2] << 2), CHRROM);
70      break;
71   }
72   if (offset == 0x1000)   /* reg[0] also sets mirroring */
73      set_nt_mirroring(space->machine, BIT(data, 5) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
74}
75
76static WRITE8_HANDLER( bmc_64in1nr_w )
77{
78   nes_state *state = (nes_state *)space->machine->driver_data;
79   LOG_MMC(("bmc_64in1nr_w offset: %04x, data: %02x\n", offset, data));
80
81   state->bmc_64in1nr_reg[3] = data;   // reg[3] is currently unused?!?
82}
83
8426/*************************************************************
8527
86    Board BMC-190IN1
87
88    Games: 190-in-1
89
90    In MESS: Supported
91
92*************************************************************/
93
94static WRITE8_HANDLER( bmc_190in1_w )
95{
96   LOG_MMC(("bmc_190in1_w offset: %04x, data: %02x\n", offset, data));
97
98   set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
99   data >>= 2;
100   prg16_89ab(space->machine, data);
101   prg16_cdef(space->machine, data);
102   chr8(space->machine, data, CHRROM);
103}
104
105/*************************************************************
106
107    Board BMC-A65AS
108
109    Games: 3-in-1 (N068)
110
111    In MESS: Supported
112
113*************************************************************/
114
115static WRITE8_HANDLER( bmc_a65as_w )
116{
117   UINT8 helper = (data & 0x30) >> 1;
118   LOG_MMC(("bmc_a65as_w offset: %04x, data: %02x\n", offset, data));
119
120   if (data & 0x80)
121      set_nt_mirroring(space->machine, BIT(data, 5) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
122   else
123      set_nt_mirroring(space->machine, BIT(data, 3) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
124
125   if (data & 0x40)
126      prg32(space->machine, data >> 1);
127   else
128   {
129      prg16_89ab(space->machine, helper | (data & 0x07));
130      prg16_cdef(space->machine, helper | 0x07);
131   }
132}
133
134/*************************************************************
135
136    Board BMC-GS2004
137
138    Games: Tetris Family 6-in-1
139
140    In MESS: Preliminary Support. It also misses WRAM handling
141       (we need reads from 0x6000-0x7fff)
142
143*************************************************************/
144
145static WRITE8_HANDLER( bmc_gs2004_w )
146{
147   LOG_MMC(("bmc_gs2004_w offset: %04x, data: %02x\n", offset, data));
148
149   prg32(space->machine, data);
150}
151
152/*************************************************************
153
154    Board BMC-GS2013
155
156    Games: Tetris Family 12-in-1
157
158    In MESS: Preliminary Support. It also misses WRAM handling
159       (we need reads from 0x6000-0x7fff)
160
161*************************************************************/
162
163static WRITE8_HANDLER( bmc_gs2013_w )
164{
165   LOG_MMC(("bmc_gs2013_w offset: %04x, data: %02x\n", offset, data));
166
167   if (data & 0x08)
168      prg32(space->machine, data & 0x09);
169   else
170      prg32(space->machine, data & 0x07);
171}
172
173/*************************************************************
174
175    Board BMC-SUPER24IN1SC03
176
177    Games: Super 24-in-1
178
179    In MESS: Supported
180
181*************************************************************/
182
183static void bmc_s24in1sc03_set_prg( running_machine *machine )
184{
185   nes_state *state = (nes_state *)machine->driver_data;
186   static const UINT8 masks[8] = {0x3f, 0x1f, 0x0f, 0x01, 0x03, 0x00, 0x00, 0x00};
187   UINT8 prg_flip = (state->mmc_cmd1 & 0x40) ? 2 : 0;
188   int prg_base = state->bmc_s24in1sc03_reg[1] << 1;
189   int prg_mask = masks[state->bmc_s24in1sc03_reg[0] & 0x07];
190
191   prg8_89(machine, prg_base | (state->mmc_prg_bank[0 ^ prg_flip] & prg_mask));
192   prg8_ab(machine, prg_base | (state->mmc_prg_bank[1] & prg_mask));
193   prg8_cd(machine, prg_base | (state->mmc_prg_bank[2 ^ prg_flip] & prg_mask));
194   prg8_ef(machine, prg_base | (state->mmc_prg_bank[3] & prg_mask));
195}
196
197static void bmc_s24in1sc03_set_chr( running_machine *machine )
198{
199   nes_state *state = (nes_state *)machine->driver_data;
200   UINT8 chr_page = (state->mmc_cmd1 & 0x80) >> 5;
201   UINT8 chr = (state->bmc_s24in1sc03_reg[0] & 0x20) ? CHRRAM : CHRROM;
202   int chr_base = (state->bmc_s24in1sc03_reg[2] << 3) & 0xf00;
203
204   chr1_x(machine, chr_page ^ 0, chr_base | (state->mmc_vrom_bank[0] & ~0x01), chr);
205   chr1_x(machine, chr_page ^ 1, chr_base | (state->mmc_vrom_bank[0] |  0x01), chr);
206   chr1_x(machine, chr_page ^ 2, chr_base | (state->mmc_vrom_bank[1] & ~0x01), chr);
207   chr1_x(machine, chr_page ^ 3, chr_base | (state->mmc_vrom_bank[1] |  0x01), chr);
208   chr1_x(machine, chr_page ^ 4, chr_base | state->mmc_vrom_bank[2], chr);
209   chr1_x(machine, chr_page ^ 5, chr_base | state->mmc_vrom_bank[3], chr);
210   chr1_x(machine, chr_page ^ 6, chr_base | state->mmc_vrom_bank[4], chr);
211   chr1_x(machine, chr_page ^ 7, chr_base | state->mmc_vrom_bank[5], chr);
212}
213
214static WRITE8_HANDLER( bmc_s24in1sc03_l_w )
215{
216   nes_state *state = (nes_state *)space->machine->driver_data;
217   LOG_MMC(("bmc_s24in1sc03_l_w offset: %04x, data: %02x\n", offset, data));
218   offset += 0x100;
219
220   if (offset == 0x1ff0)
221   {
222      state->bmc_s24in1sc03_reg[0] = data;
223      bmc_s24in1sc03_set_prg(space->machine);
224      bmc_s24in1sc03_set_chr(space->machine);
225   }
226
227   if (offset == 0x1ff1)
228   {
229      state->bmc_s24in1sc03_reg[1] = data;
230      bmc_s24in1sc03_set_prg(space->machine);
231   }
232
233   if (offset == 0x1ff2)
234   {
235      state->bmc_s24in1sc03_reg[2] = data;
236      bmc_s24in1sc03_set_chr(space->machine);
237   }
238}
239
240static WRITE8_HANDLER( bmc_s24in1sc03_w )
241{
242   nes_state *state = (nes_state *)space->machine->driver_data;
243   UINT8 cmd, bmc_s24in1sc03_helper;
244   LOG_MMC(("bmc_s24in1sc03_w offset: %04x, data: %02x\n", offset, data));
245
246   switch (offset & 0x6001)
247   {
248      case 0x0000:
249         bmc_s24in1sc03_helper = state->mmc_cmd1 ^ data;
250         state->mmc_cmd1 = data;
251
252         /* Has PRG Mode changed? */
253         if (bmc_s24in1sc03_helper & 0x40)
254            bmc_s24in1sc03_set_prg(space->machine);
255
256         /* Has CHR Mode changed? */
257         if (bmc_s24in1sc03_helper & 0x80)
258            bmc_s24in1sc03_set_chr(space->machine);
259         break;
260
261      case 0x0001:
262         cmd = state->mmc_cmd1 & 0x07;
263         switch (cmd)
264         {
265            case 0: case 1:   // these do not need to be separated: we take care of them in set_chr!
266            case 2: case 3: case 4: case 5:
267               state->mmc_vrom_bank[cmd] = data;
268               bmc_s24in1sc03_set_chr(space->machine);
269               break;
270            case 6:
271            case 7:
272               state->mmc_prg_bank[cmd - 6] = data;
273               bmc_s24in1sc03_set_prg(space->machine);
274               break;
275         }
276         break;
277
278      default:
279         mapper4_w(space, offset, data);
280         break;
281   }
282}
283
284/*************************************************************
285
286    Board BMC-T-262
287
288    Games: 4-in-1 (D-010), 8-in-1 (A-020)
289
290    In MESS: Supported
291
292*************************************************************/
293
294static WRITE8_HANDLER( bmc_t262_w )
295{
296   nes_state *state = (nes_state *)space->machine->driver_data;
297   UINT8 mmc_helper;
298   LOG_MMC(("bmc_t262_w offset: %04x, data: %02x\n", offset, data));
299
300   if (state->mmc_cmd2 || offset == 0)
301   {
302      state->mmc_cmd1 = (state->mmc_cmd1 & 0x38) | (data & 0x07);
303      prg16_89ab(space->machine, state->mmc_cmd1);
304   }
305   else
306   {
307      state->mmc_cmd2 = 1;
308      set_nt_mirroring(space->machine, BIT(data, 1) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
309      mmc_helper = ((offset >> 3) & 0x20) | ((offset >> 2) & 0x18);
310      state->mmc_cmd1 = mmc_helper | (state->mmc_cmd1 & 0x07);
311      prg16_89ab(space->machine, state->mmc_cmd1);
312      prg16_cdef(space->machine, mmc_helper | 0x07);
313   }
314}
315
316/*************************************************************
317
318    Board BMC-WS
319
320    Games: Super 40-in-1
321
322    In MESS: Supported
323
324*************************************************************/
325
326static WRITE8_HANDLER( bmc_ws_m_w )
327{
328   nes_state *state = (nes_state *)space->machine->driver_data;
329   UINT8 mmc_helper;
330   LOG_MMC(("bmc_ws_m_w offset: %04x, data: %02x\n", offset, data));
331
332   if (offset < 0x1000)
333   {
334      switch (offset & 0x01)
335      {
336      case 0:
337         if (!state->mmc_cmd1)
338         {
339            state->mmc_cmd1 = data & 0x20;
340            set_nt_mirroring(space->machine, BIT(data, 4) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
341            mmc_helper = (~data & 0x08) >> 3;
342            prg16_89ab(space->machine, data & ~mmc_helper);
343            prg16_cdef(space->machine, data |  mmc_helper);
344         }
345         break;
346      case 1:
347         if (!state->mmc_cmd1)
348         {
349            chr8(space->machine, data, CHRROM);
350         }
351         break;
352      }
353   }
354}
355
356/*************************************************************
357
358    Board DREAMTECH01
359
360    Games: Korean Igo
361
362    In MESS: Supported
363
364*************************************************************/
365
366static WRITE8_HANDLER( dreamtech_l_w )
367{
368   LOG_MMC(("dreamtech_l_w offset: %04x, data: %02x\n", offset, data));
369   offset += 0x100;
370
371   if (offset == 0x1020)   /* 0x5020 */
372      prg16_89ab(space->machine, data);
373}
374
375/*************************************************************
376
377    Board UNL-8237
378
379    Games: Pochahontas 2
380
381    MMC3 clone
382
383    In MESS: Not working
384
385*************************************************************/
386
387static void unl_8237_set_prg( running_machine *machine )
388{
389   nes_state *state = (nes_state *)machine->driver_data;
390   UINT8 prg_flip = (state->mmc_cmd1 & 0x40) ? 2 : 0;
391
392   if (!(state->unl_8237_reg[0] & 0x80))
393   {
394      prg8_89(machine, state->mmc_prg_bank[0 ^ prg_flip]);
395      prg8_ab(machine, state->mmc_prg_bank[1]);
396      prg8_cd(machine, state->mmc_prg_bank[2 ^ prg_flip]);
397      prg8_ef(machine, state->mmc_prg_bank[3]);
398   }
399}
400
401static void unl_8237_set_chr( running_machine *machine )
402{
403   nes_state *state = (nes_state *)machine->driver_data;
404   UINT8 chr_page = (state->mmc_cmd1 & 0x80) >> 5;
405   UINT8 bank[8];
406   int i;
407
408   for(i = 0; i < 6; i++)
409      bank[i] = state->mmc_vrom_bank[i] | ((state->unl_8237_reg[1] << 6) & 0x100);
410
411   chr1_x(machine, chr_page ^ 0, (bank[0] & ~0x01), CHRROM);
412   chr1_x(machine, chr_page ^ 1, (bank[0] |  0x01), CHRROM);
413   chr1_x(machine, chr_page ^ 2, (bank[1] & ~0x01), CHRROM);
414   chr1_x(machine, chr_page ^ 3, (bank[1] |  0x01), CHRROM);
415   chr1_x(machine, chr_page ^ 4, bank[2], CHRROM);
416   chr1_x(machine, chr_page ^ 5, bank[3], CHRROM);
417   chr1_x(machine, chr_page ^ 6, bank[4], CHRROM);
418   chr1_x(machine, chr_page ^ 7, bank[5], CHRROM);
419}
420
421static WRITE8_HANDLER( unl_8237_l_w )
422{
423   nes_state *state = (nes_state *)space->machine->driver_data;
424   LOG_MMC(("unl_8237_l_w offset: %04x, data: %02x\n", offset, data));
425   offset += 0x100;
426
427   if (offset == 0x1000)
428   {
429      state->unl_8237_reg[0] = data;
430      if (state->unl_8237_reg[0] & 0x80)
431      {
432         if (state->unl_8237_reg[0] & 0x20)
433            prg32(space->machine, (state->unl_8237_reg[0] & 0x0f) >> 1);
434         else
435         {
436            prg16_89ab(space->machine, state->unl_8237_reg[0] & 0x1f);
437            prg16_cdef(space->machine, state->unl_8237_reg[0] & 0x1f);
438         }
439      }
440      else
441         unl_8237_set_prg(space->machine);
442   }
443
444   if (offset == 0x1001)
445   {
446      state->unl_8237_reg[1] = data;
447      unl_8237_set_chr(space->machine);
448   }
449}
450
451static WRITE8_HANDLER( unl_8237_w )
452{
453   nes_state *state = (nes_state *)space->machine->driver_data;
454   UINT8 unl_8237_helper, cmd;
455   static const UINT8 conv_table[8] = {0,2,6,1,7,3,4,5};
456   LOG_MMC(("unl_8237_w offset: %04x, data: %02x\n", offset, data));
457
458   switch (offset & 0x7000)
459   {
460      case 0x2000:
461      case 0x3000:
462         state->unl_8237_reg[2] = 1;
463         data = (data & 0xc0) | conv_table[data & 0x07];
464         unl_8237_helper = state->mmc_cmd1 ^ data;
465         state->mmc_cmd1 = data;
466
467         /* Has PRG Mode changed? */
468         if (unl_8237_helper & 0x40)
469            unl_8237_set_prg(space->machine);
470
471         /* Has CHR Mode changed? */
472         if (unl_8237_helper & 0x80)
473            unl_8237_set_chr(space->machine);
474         break;
475
476      case 0x4000:
477      case 0x5000:
478         if (state->unl_8237_reg[2])
479         {
480            state->unl_8237_reg[2] = 0;
481            cmd = state->mmc_cmd1 & 0x07;
482            switch (cmd)
483            {
484               case 0: case 1:
485               case 2: case 3: case 4: case 5:
486                  state->mmc_vrom_bank[cmd] = data;
487                  unl_8237_set_chr(space->machine);
488                  break;
489               case 6:
490               case 7:
491                  state->mmc_prg_bank[cmd - 6] = data;
492                  unl_8237_set_prg(space->machine);
493                  break;
494            }
495         }
496         break;
497
498      case 0x0000:
499      case 0x1000:
500         set_nt_mirroring(space->machine, (data | (data >> 7)) & 0x01 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
501         break;
502
503      case 0x6000:
504         break;
505
506      case 0x7000:
507         mapper4_w(space, 0x6001, data);
508         mapper4_w(space, 0x4000, data);
509         mapper4_w(space, 0x4001, data);
510         break;
511   }
512}
513
514/*************************************************************
515
516    Board UNL-AX5705
517
518    Games: Super Mario Bros. Pocker Mali (Crayon Shin-chan pirate hack)
519
520    In MESS: Supported
521
522*************************************************************/
523
524static void unl_ax5705_set_prg( running_machine *machine )
525{
526   nes_state *state = (nes_state *)machine->driver_data;
527   prg8_89(machine, state->mmc_prg_bank[0]);
528   prg8_ab(machine, state->mmc_prg_bank[1]);
529}
530
531static WRITE8_HANDLER( unl_ax5705_w )
532{
533   nes_state *state = (nes_state *)space->machine->driver_data;
534   UINT8 bank;
535   LOG_MMC(("unl_ax5705_w offset: %04x, data: %02x\n", offset, data));
536
537   switch (offset & 0x700f)
538   {
539   case 0x0000:
540      state->mmc_prg_bank[0] = (data & 0x05) | ((data & 0x08) >> 2) | ((data & 0x02) << 2);
541      unl_ax5705_set_prg(space->machine);
542      break;
543   case 0x0008:
544      set_nt_mirroring(space->machine, BIT(data, 0) ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
545      break;
546   case 0x2000:
547      state->mmc_prg_bank[1] = (data & 0x05) | ((data & 0x08) >> 2) | ((data & 0x02) << 2);
548      unl_ax5705_set_prg(space->machine);
549      break;
550   /* CHR banks 0, 1, 4, 5 */
551   case 0x2008:
552   case 0x200a:
553   case 0x4008:
554   case 0x400a:
555      bank = ((offset & 0x4000) ? 4 : 0) + ((offset & 0x0002) ? 1 : 0);
556      state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0xf0) | (data & 0x0f);
557      chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
558      break;
559   case 0x2009:
560   case 0x200b:
561   case 0x4009:
562   case 0x400b:
563      bank = ((offset & 0x4000) ? 4 : 0) + ((offset & 0x0002) ? 1 : 0);
564      state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0x0f) | ((data & 0x04) << 3) | ((data & 0x02) << 5) | ((data & 0x09) << 4);
565      chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
566      break;
567   /* CHR banks 2, 3, 6, 7 */
568   case 0x4000:
569   case 0x4002:
570   case 0x6000:
571   case 0x6002:
572      bank = 2 + ((offset & 0x2000) ? 4 : 0) + ((offset & 0x0002) ? 1 : 0);
573      state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0xf0) | (data & 0x0f);
574      chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
575      break;
576   case 0x4001:
577   case 0x4003:
578   case 0x6001:
579   case 0x6003:
580      bank = 2 + ((offset & 0x2000) ? 4 : 0) + ((offset & 0x0002) ? 1 : 0);
581      state->mmc_vrom_bank[bank] = (state->mmc_vrom_bank[bank] & 0x0f) | ((data & 0x04) << 3) | ((data & 0x02) << 5) | ((data & 0x09) << 4);
582      chr1_x(space->machine, bank, state->mmc_vrom_bank[bank], CHRROM);
583      break;
584   }
585}
586
587/*************************************************************
588
589    Board UNL-CC-21
590
591    Games: Mi Hun Che
592
593    In MESS: Supported
594
595*************************************************************/
596
597static WRITE8_HANDLER( unl_cc21_w )
598{
599   LOG_MMC(("unl_cc21_w offset: %04x, data: %02x\n", offset, data));
600
601   set_nt_mirroring(space->machine, BIT(data, 1) ? PPU_MIRROR_HIGH : PPU_MIRROR_LOW);
602   chr8(space->machine, (offset & 0x01), CHRROM);
603}
604
605/*************************************************************
606
607    Board UNL-KOF97
608
609    Games: King of Fighters 97 (Rex Soft)
610
611    MMC3 clone
612
613    In MESS: Not working
614
615*************************************************************/
616
617static UINT8 unl_kof97_unscramble( UINT8 data )
618{
619   return ((data >> 1) & 0x01) | ((data >> 4) & 0x02) | ((data << 2) & 0x04) | ((data >> 0) & 0xd8) | ((data << 3) & 0x20);
620}
621
622static WRITE8_HANDLER( unl_kof97_w )
623{
624   LOG_MMC(("unl_kof97_w offset: %04x, data: %02x\n", offset, data));
625
626   /* Addresses 0x9000, 0xa000, 0xd000 & 0xf000 behaves differently than MMC3 */
627   if (offset == 0x1000)
628   {
629      data = unl_kof97_unscramble(data);
630      mapper4_w(space, 0x0001, data);
631   }
632   else if (offset == 0x2000)
633   {
634      data = unl_kof97_unscramble(data);
635      mapper4_w(space, 0x0000, data);
636   }
637   else if (offset == 0x5000)
638   {
639      data = unl_kof97_unscramble(data);
640      mapper4_w(space, 0x4001, data);
641   }
642   else if (offset == 0x7000)
643   {
644      data = unl_kof97_unscramble(data);
645      mapper4_w(space, 0x6001, data);
646   }
647   else      /* Other addresses behaves like MMC3, up to unscrambling data */
648   {
649      switch (offset & 0x6001)
650      {
651      case 0x0000:
652      case 0x0001:
653      case 0x4000:
654      case 0x4001:
655      case 0x6000:
656      case 0x6001:
657      case 0x2000:   /* are these ever called?!? */
658      case 0x2001:
659         data = unl_kof97_unscramble(data);
660         mapper4_w(space, offset, data);
661         break;
662      }
663   }
664}
665
666/*************************************************************
667
668    Board UNL-T-230
669
670    Games: Dragon Ball Z IV (Unl)
671
672    In MESS: Supported
673
674*************************************************************/
675
676static WRITE8_HANDLER( unl_t230_w )
677{
678   LOG_MMC(("unl_t230_w offset: %04x, data: %02x\n", offset, data));
679
680   switch (offset & 0x7007)
681   {
682      case 0x0000:
683         break;
684      case 0x2000:
685         data = (data << 1) & 0x1f;
686         prg8_89(space->machine, data);
687         prg8_ab(space->machine, data | 0x01);
688         break;
689
690      default:
691         konami_vrc2b_w(space, offset, data);
692         break;
693   }
694}
695
696
697/*************************************************************
698
69928    Constants
70029
70130*************************************************************/
r8270r8271
72554   NT_4SCR_4K
72655};
72756
728/* Boards */
729enum
730{
731   STD_NROM = 0,
732   STD_AXROM, STD_BXROM, STD_CNROM, STD_CPROM,
733   STD_DXROM, STD_EXROM, STD_FXROM, STD_GXROM,
734   STD_HKROM, STD_JXROM, STD_MXROM, STD_NXROM,
735   STD_PXROM, STD_SXROM, STD_TXROM, STD_TXSROM,
736   STD_TQROM, STD_UN1ROM, STD_UXROM,
737   HVC_FAMBASIC, NES_QJ, PAL_ZZ,
738   STD_SXROM_A, STD_SOROM,
739   /* Discrete components boards (by various manufacturer */
740   DIS_74X161X138,
741   DIS_74X139X74, DIS_74X377, DIS_74X161X161X32,
742   /* Active Enterprises */
743   ACTENT_ACT52,
744   /* AGCI */
745   AGCI_50282,
746   /* AVE */
747   AVE_NINA01, AVE_NINA06,
748   /* Bandai */
749   BANDAI_JUMP2, BANDAI_PT554,
750   BANDAI_DATACH, BANDAI_KARAOKE, BANDAI_OEKAKIDS,
751   BANDAI_FCG, BANDAI_LZ93EX,
752   /* Caltron */
753   CALTRON_6IN1,
754   /* Camerica */
755   CAMERICA_ALGN, CAMERICA_ALGQ, CAMERICA_9097,
756   CAMERICA_GOLDENFIVE, GG_NROM,
757   /* Dreamtech */
758   DREAMTECH_BOARD,
759   /* Irem */
760   IREM_G101, IREM_HOLYDIV, IREM_H3001, IREM_LROG017,
761   /* Jaleco */
762   JALECO_SS88006, JALECO_JF11, JALECO_JF13,
763   JALECO_JF16, JALECO_JF17, JALECO_JF19,
764   /* Konami */
765   KONAMI_VRC1, KONAMI_VRC2, KONAMI_VRC3,
766   KONAMI_VRC4, KONAMI_VRC6, KONAMI_VRC7,
767   /* Namcot */
768   NAMCOT_163,
769   NAMCOT_3425, NAMCOT_34X3, NAMCOT_3446,
770   /* NTDEC */
771   NTDEC_ASDER, NTDEC_FIGHTINGHERO,
772   /* Rex Soft */
773   REXSOFT_SL1632, REXSOFT_DBZ5,
774   /* Sachen */
775   SACHEN_8259A, SACHEN_8259B, SACHEN_8259C,
776   SACHEN_8259D, SACHEN_SA0036, SACHEN_SA0037,
777   SACHEN_SA72007, SACHEN_SA72008, SACHEN_TCA01,
778   SACHEN_TCU01, SACHEN_TCU02, SACHEN_74LS374,
779   /* Sunsoft */
780   SUNSOFT_1, SUNSOFT_2, SUNSOFT_3,
781   SUNSOFT_4, SUNSOFT_5B, SUNSOFT_FME7,
782   /* Taito */
783   TAITO_TC0190FMC, TAITO_TC0190FMCP, TAITO_X1005, TAITO_X1017,
784   /* Tengen */
785   TENGEN_800008, TENGEN_800032, TENGEN_800037,
786   /* TXC */
787   TXC_22211A, TXC_MXMDHTWO, TXC_TW,
788   /* Multigame Carts */
789   BMC_64IN1NR, BMC_190IN1, BMC_A65AS, BMC_GS2004, BMC_GS2013,
790   BMC_HIK8IN1, BMC_NOVELDIAMOND, BMC_S24IN1SC03, BMC_T262,
791   BMC_WS, BMC_SUPERBIG_7IN1, BMC_SUPERHIK_4IN1, BMC_BALLGAMES_11IN1,
792   BMC_MARIOPARTY_7IN1, BMC_SUPER_700IN1, BMC_FAMILY_4646B,
793   BMC_36IN1, BMC_21IN1, BMC_150IN1, BMC_35IN1, BMC_64IN1,
794   BMC_15IN1, BMC_SUPERHIK_300IN1, BMC_9999999IN1, BMC_SUPERGUN_20IN1,
795   BMC_GOLDENCARD_6IN1, BMC_72IN1, BMC_SUPER_42IN1, BMC_76IN1,
796   BMC_1200IN1, BMC_31IN1, BMC_22GAMES, BMC_20IN1, BMC_110IN1, BMC_GKA, BMC_GKB,
797   /* Unlicensed */
798   UNL_8237, UNL_CC21, UNL_AX5705, UNL_KOF97,
799   UNL_N625092, UNL_SC127, UNL_SMB2J, UNL_T230,
800   UNL_UXROM, UNL_MK2, UNL_XZY, UNL_KOF96,
801   UNL_SUPERFIGHTER3,
802   /* Bootleg boards */
803   BTL_SMB2A, BTL_MARIOBABY, BTL_AISENSHINICOL,
804   BTL_SMB2B, BTL_SMB3, BTL_SUPERBROS11, BTL_DRAGONNINJA,
805   /* Misc: these are needed to convert mappers to boards, I will sort them later */
806   OPENCORP_DAOU306, HES_BOARD, RUMBLESTATION_BOARD, SUPERGAME_BOOGERMAN,
807   MAGICSERIES_MAGICDRAGON, KASING_BOARD, FUTUREMEDIA_BOARD, SOMERITEAM_SL12,
808   HENGEDIANZI_BOARD, SUBOR_TYPE0, SUBOR_TYPE1, KAISER_KS7058, CONY_BOARD,
809   CNE_DECATHLON, CNE_PSB, CNE_SHLZ, RCM_GS2015, RCM_TETRISFAMILY,
810   WAIXING_TYPE_A, WAIXING_TYPE_B, WAIXING_TYPE_C, WAIXING_TYPE_D,
811   WAIXING_TYPE_E, WAIXING_TYPE_F, WAIXING_TYPE_G, WAIXING_TYPE_H,
812   WAIXING_SGZLZ, WAIXING_SGZ, WAIXING_ZS, WAIXING_SECURITY,
813   WAIXING_FFV, WAIXING_PS2, KAY_PANDAPRINCE, SUPERGAME_LIONKING,
814   HOSENKAN_BOARD, NITRA_TDA, GOUDER_37017,
815   /* Unsupported (for place-holder boards, with no working emulation) */
816   UNSUPPORTED_BOARD
817};
818
81957/*************************************************************
82058
82159    unif_list
r8270r8271
918156static int unif_initialize( running_machine *machine, int idx )
919157{
920158   nes_state *state = (nes_state *)machine->driver_data;
921   int err = 0;
159   int err = 0, i;
922160   
923161   switch (idx)
924162   {
925      case BMC_64IN1NR:
926         state->bmc_64in1nr_reg[0] = 0x80;
927         state->bmc_64in1nr_reg[1] = 0x43;
928         state->bmc_64in1nr_reg[2] = state->bmc_64in1nr_reg[3] = 0;
929         bmc_64in1nr_set_prg(machine);
930         set_nt_mirroring(machine, PPU_MIRROR_VERT);
931         chr8(machine, 0, CHRROM);
932         break;
933      case BMC_190IN1:
934         prg16_89ab(machine, 0);
935         prg16_cdef(machine, 0);
936         chr8(machine, 0, CHRROM);
937         break;
938      case BMC_A65AS:
939         prg16_89ab(machine, 0);
940         prg16_cdef(machine, 7);
941         set_nt_mirroring(machine, PPU_MIRROR_VERT);
942         break;
943      case BMC_GS2004:
944      case BMC_GS2013:
945         prg32(machine, 0xff);
946         chr8(machine, 0, CHRRAM);
947         break;
948      case BMC_S24IN1SC03:
949         state->bmc_s24in1sc03_reg[0] = 0x24;
950         state->bmc_s24in1sc03_reg[1] = 0x9f;
951         state->bmc_s24in1sc03_reg[2] = 0;
952         state->mmc_prg_bank[0] = 0xfe;
953         state->mmc_prg_bank[1] = 0xff;
954         state->mmc_prg_bank[2] = 0xfe;
955         state->mmc_prg_bank[3] = 0xff;
956         state->mmc_cmd1 = 0;
957         state->mmc_cmd2 = 0x80;
958         bmc_s24in1sc03_set_prg(machine);
959         bmc_s24in1sc03_set_chr(machine);
960         break;
961      case BMC_T262:
962         state->mmc_cmd1 = 0;
963         state->mmc_cmd2 = 0;
964         prg16_89ab(machine, 0);
965         prg16_cdef(machine, 7);
966         break;
967      case BMC_WS:
968         state->mmc_cmd1 = 0;
969         prg32(machine, 0);
970         break;
971      case DREAMTECH_BOARD:
972         prg16_89ab(machine, 0);
973         prg16_cdef(machine, 8);
974         chr8(machine, 0, CHRRAM);
975         break;
976      case UNL_8237:
977         state->unl_8237_reg[0] = state->unl_8237_reg[1] = state->unl_8237_reg[2] = 0;
978         state->mmc_prg_bank[0] = 0x00;
979         state->mmc_prg_bank[1] = 0x01;
980         state->mmc_prg_bank[2] = 0xfe;
981         state->mmc_prg_bank[3] = 0xff;
982         state->mmc_cmd1 = 0;
983         state->mmc_cmd2 = 0x80;
984         unl_8237_set_prg(machine);
985         unl_8237_set_chr(machine);
986         break;
987      case UNL_AX5705:
988         state->mmc_prg_bank[0] = 0;
989         state->mmc_prg_bank[1] = 1;
990         prg8_89(machine, state->mmc_prg_bank[0]);
991         prg8_ab(machine, state->mmc_prg_bank[1]);
992         prg8_cd(machine, 0xfe);
993         prg8_ef(machine, 0xff);
994         break;
995      case UNL_CC21:
996         prg32(machine, 0);
997         chr8(machine, 0, CHRROM);
998         break;
999      case UNL_KOF97:
1000         mapper_initialize(machine, 4);
1001         break;
1002      case UNL_T230:
1003         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1004         prg16_89ab(machine, 0);
1005         prg16_cdef(machine, state->prg_chunks - 1);
1006         break;
1007         /* For the Boards corresponding to a Mapper, fall back to the mapper init */
163// mapper 0
1008164      case STD_NROM:
1009165      case HVC_FAMBASIC:
1010166      case GG_NROM:
1011         mapper_initialize(machine, 0);
167         prg32(machine, 0);
1012168         break;
169// mapper 1, 155
1013170      case STD_SXROM:
1014171      case STD_SOROM:
1015172      case STD_SXROM_A:
1016         mapper_initialize(machine, 1);
173         state->mmc_latch1 = 0;
174         state->mmc_count = 0;
175         state->mmc_reg[0] = 0x0f;
176         state->mmc_reg[1] = state->mmc_reg[2] = 0;
177         state->mmc_reg[3] = 0x10;
178         set_nt_mirroring(machine, PPU_MIRROR_HORZ);
179         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
180         mmc1_set_chr(machine);
181         mmc1_set_prg(machine);
1017182         break;
183// mapper 2
1018184      case STD_UXROM:
1019         mapper_initialize(machine, 2);
185         prg16_89ab(machine, 0);
186         prg16_cdef(machine, state->prg_chunks - 1);
1020187         break;
188// mapper 3, 185
1021189      case STD_CNROM:
1022190      case BANDAI_PT554:
1023191      case TENGEN_800008:
1024         mapper_initialize(machine, 3);
192         prg32(machine, 0);
1025193         break;
194// mapper 4
1026195      case STD_HKROM:
1027196      case STD_TXROM:
197      case STD_TVROM:
198// mapper 206
199      case STD_DXROM:
200      case STD_DRROM:
1028201         mapper_initialize(machine, 4);
1029202         break;
203// mapper 5
1030204      case STD_EXROM:
1031         mapper_initialize(machine, 5);
205         state->MMC5_rom_bank_mode = 3;
206         state->MMC5_vrom_bank_mode = 0;
207         state->MMC5_vram_protect = 0;
208         state->mmc5_high_chr = 0;
209         state->mmc5_vram_control = 0;
210         state->mmc5_split_scr = 0;
211         memset(state->MMC5_vrom_bank, 0, ARRAY_LENGTH(state->MMC5_vrom_bank));
212         state->mid_ram_enable = 0;
213         prg16_89ab(machine, state->prg_chunks - 2);
214         prg16_cdef(machine, state->prg_chunks - 1);
1032215         break;
216// mapper 7
1033217      case STD_AXROM:
1034         mapper_initialize(machine, 7);
218         set_nt_mirroring(machine, PPU_MIRROR_LOW);
219         prg16_89ab(machine, 0);
220         prg16_cdef(machine, state->prg_chunks - 1);
1035221         break;
222// mapper 9
1036223      case STD_PXROM:
1037         mapper_initialize(machine, 9);
224         state->MMC2_regs[0] = state->MMC2_regs[2] = 0;
225         state->MMC2_regs[1] = state->MMC2_regs[3] = 0;
226         state->mmc_latch1 = state->mmc_latch2 = 0xfe;
227         prg8_89(machine, 0);
228         prg8_ab(machine, (state->prg_chunks << 1) - 3);
229         prg8_cd(machine, (state->prg_chunks << 1) - 2);
230         prg8_ef(machine, (state->prg_chunks << 1) - 1);
1038231         break;
232// mapper 10
1039233      case STD_FXROM:
1040         mapper_initialize(machine, 10);
234         state->MMC2_regs[0] = state->MMC2_regs[2] = 0;
235         state->MMC2_regs[1] = state->MMC2_regs[3] = 0;
236         state->mmc_latch1 = state->mmc_latch2 = 0xfe;
237         prg16_89ab(machine, 0);
238         prg16_cdef(machine, state->prg_chunks - 1);
1041239         break;
240// mapper 11
1042241      case DIS_74X377:
1043         mapper_initialize(machine, 11);
242         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;   // NINA-07 has no CHRROM
243         prg32(machine, 0);
1044244         break;
245// mapper 12
1045246      case REXSOFT_DBZ5:
247// mapper 74
248      case WAIXING_TYPE_A:
249// mapper 118
250      case STD_TXSROM:
251// mapper 119
252      case STD_TQROM:
253// mapper 191
254      case WAIXING_TYPE_B:
255// mapper 192
256      case WAIXING_TYPE_C:
257// mapper 194
258      case WAIXING_TYPE_D:
259// mapper 195
260      case WAIXING_TYPE_E:
261// mapper 196
262      case BTL_SUPERBROS11:
263// mapper 245
264      case WAIXING_TYPE_H:
265// mapper 250
266      case NITRA_TDA:
1046267         mapper_initialize(machine, 12);
1047268         break;
269// mapper 13
270      case STD_CPROM:
271         chr4_0(machine, 0, CHRRAM);
272         prg32(machine, 0);
273         break;
274// mapper 14
1048275      case REXSOFT_SL1632:
1049         mapper_initialize(machine, 14);
276         state->mmc_extra_bank[2] = 0xfe;
277         state->mmc_extra_bank[3] = 0xff;
278         state->mmc_extra_bank[0] = state->mmc_extra_bank[1] = state->mmc_extra_bank[4] = state->mmc_extra_bank[5] = state->mmc_extra_bank[6] = 0;
279         state->mmc_extra_bank[7] = state->mmc_extra_bank[8] = state->mmc_extra_bank[9] = state->mmc_extra_bank[0xa] = state->mmc_extra_bank[0xb] = 0;
280         state->map14_reg[0] = state->map14_reg[1] = 0;
281         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
282         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
283         state->mmc_latch1 = 0;
284         state->mmc_latch2 = 0x80;
285         state->mmc_prg_base = state->mmc_chr_base = 0;
286         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
287         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
288         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
289         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1050290         break;
291// mapper 15
1051292      case WAIXING_PS2:
1052         mapper_initialize(machine, 15);
293         set_nt_mirroring(machine, PPU_MIRROR_VERT);
294         prg32(machine, 0);
1053295         break;
1054      case BANDAI_LZ93EX:
1055         mapper_initialize(machine, 16);
296// mapper 16, 157
297      case BANDAI_LZ93:
298      case BANDAI_DATACH:
299         state->mmc_latch1 = 0;
300         prg16_89ab(machine, 0);
301         prg16_cdef(machine, state->prg_chunks - 1);
302         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1056303         break;
304// mapper 18
1057305      case JALECO_SS88006:
1058         mapper_initialize(machine, 18);
306         state->mmc_latch1 = 0;
307         prg16_89ab(machine, 0);
308         prg16_cdef(machine, state->prg_chunks - 1);
309         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1059310         break;
311// mapper 19
1060312      case NAMCOT_163:
1061         mapper_initialize(machine, 19);
313         state->mmc_latch1 = 0;
314         prg16_89ab(machine, 0);
315         prg16_cdef(machine, state->prg_chunks - 1);
316         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
317         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1062318         break;
1063      case KONAMI_VRC4:
1064         mapper_initialize(machine, 21);
1065         break;
1066      case KONAMI_VRC2:
1067         mapper_initialize(machine, 22);
1068         break;
1069      case KONAMI_VRC6:
1070         mapper_initialize(machine, 24);
1071         break;
319// mapper 32
320      case IREM_G101_A:
321         set_nt_mirroring(machine, PPU_MIRROR_HIGH);  // needed by Major League
1072322      case IREM_G101:
1073         mapper_initialize(machine, 32);
323         state->mmc_latch1 = 0;
324         prg16_89ab(machine, 0);
325         prg16_cdef(machine, state->prg_chunks - 1);
1074326         break;
327// mapper 33
1075328      case TAITO_TC0190FMC:
1076         mapper_initialize(machine, 33);
329// mapper 48
330      case TAITO_TC0190FMCP:
331         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
332         prg16_89ab(machine, 0);
333         prg16_cdef(machine, state->prg_chunks - 1);
1077334         break;
335// mapper 34
1078336      case STD_BXROM:
1079         mapper_initialize(machine, 34);
337         prg32(machine, 0);
1080338         break;
339// mapper 35
1081340      case UNL_SC127:
1082         mapper_initialize(machine, 35);
341         prg32(machine, 0xff);
1083342         break;
343// mapper 37
1084344      case PAL_ZZ:
1085         mapper_initialize(machine, 37);
345         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
346         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
347         state->mmc_latch1 = 0;
348         state->mmc_latch2 = 0x80;
349         state->mmc_prg_base = state->mmc_chr_base = 0;
350         state->mmc_prg_mask = 0x07;
351         state->mmc_chr_mask = 0x7f;
352         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
353         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
354         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1086355         break;
356// mapper 38
1087357      case DIS_74X161X138:
1088         mapper_initialize(machine, 38);
358         prg32(machine, 0);
1089359         break;
360// mapper 40
1090361      case BTL_SMB2A:
1091         mapper_initialize(machine, 40);
362         prg8_67(machine, 0xfe);
363         prg8_89(machine, 0xfc);
364         prg8_ab(machine, 0xfd);
365         prg8_cd(machine, 0xfe);
366         prg8_ef(machine, 0xff);
1092367         break;
368// mapper 41
1093369      case CALTRON_6IN1:
1094         mapper_initialize(machine, 41);
370         state->mmc_latch1 = 0;
371         prg32(machine, 0);
1095372         break;
373// mapper 42
1096374      case BTL_MARIOBABY:
1097375      case BTL_AISENSHINICOL:
1098         mapper_initialize(machine, 42);
376         prg32(machine, state->prg_chunks - 1);
1099377         break;
378// mapper 43
1100379      case UNL_SMB2J:
1101         mapper_initialize(machine, 43);
380         prg32(machine, 0);
381         if (state->battery)
382            memset(state->battery_ram, 0x2000, 0xff);
383         else if (state->prg_ram)
384            memset(state->wram, 0x2000, 0xff);
1102385         break;
386// mapper 44
1103387      case BMC_SUPERBIG_7IN1:
1104         mapper_initialize(machine, 44);
1105         break;
1106      case RUMBLESTATION_BOARD:
1107         mapper_initialize(machine, 46);
1108         break;
388// mapper 47
1109389      case NES_QJ:
1110         mapper_initialize(machine, 47);
390// mapper 49
391      case BMC_SUPERHIK_4IN1:
392         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
393         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
394         state->mmc_latch1 = 0;
395         state->mmc_latch2 = 0x80;
396         state->mmc_prg_base = state->mmc_chr_base = 0;
397         state->mmc_prg_mask = 0x0f;
398         state->mmc_chr_mask = 0x7f;
399         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
400         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
401         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1111402         break;
1112      case TAITO_TC0190FMCP:
1113         mapper_initialize(machine, 48);
403// mapper 45
404      case BMC_HIK8IN1:
405         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
406         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
407         state->mmc_latch1 = 0;
408         state->mmc_latch2 = 0x80;
409         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
410         state->mapper45_reg[0] = state->mapper45_reg[1] = state->mapper45_reg[2] = state->mapper45_reg[3] = 0;
411         state->mmc_prg_base = 0x30;
412         state->mmc_prg_mask = 0x3f;
413         state->mmc_chr_base = 0;
414         state->mmc_chr_mask = 0x7f;
415         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
416         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
417         //         memory_set_bankptr(machine, "bank5", state->wram);
1114418         break;
1115      case BMC_SUPERHIK_4IN1:
1116         mapper_initialize(machine, 49);
419// mapper 46
420      case RUMBLESTATION_BOARD:
421         prg32(machine, 0);
422         chr8(machine, 0, CHRROM);
1117423         break;
1118424      case BTL_SMB2B:
1119425         mapper_initialize(machine, 50);
1120426         break;
427// mapper 51
1121428      case BMC_BALLGAMES_11IN1:
1122         mapper_initialize(machine, 51);
429         state->mapper51_reg[0] = 0x01;
430         state->mapper51_reg[1] = 0x00;
431         bmc_ball11_set_banks(machine);
1123432         break;
433// mapper 52
1124434      case BMC_MARIOPARTY_7IN1:
1125         mapper_initialize(machine, 52);
435         state->mmc_prg_bank[0] = 0xfe;
436         state->mmc_prg_bank[2] = 0xfe;
437         state->mmc_prg_bank[1] = 0xff;
438         state->mmc_prg_bank[3] = 0xff;
439         state->mmc_latch1 = 0;
440         state->mmc_latch2 = 0x80;
441         state->map52_reg_written = 0;
442         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
443         state->mmc_prg_base = 0;
444         state->mmc_prg_mask = 0x1f;
445         state->mmc_chr_base = 0;
446         state->mmc_chr_mask = 0xff;
447         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
448         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1126449         break;
450// mapper 54
1127451      case BMC_NOVELDIAMOND:
1128         mapper_initialize(machine, 54);
452         prg32(machine, 0);
453         chr8(machine, 0, CHRROM);
454         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1129455         break;
456// mapper 57
1130457      case BMC_GKA:
1131         mapper_initialize(machine, 57);
458         state->mmc_latch1 = 0x00;
459         state->mmc_latch2 = 0x00;
460         prg16_89ab(machine, 0);
461         prg16_cdef(machine, 0);
462         chr8(machine, 0, CHRROM);
1132463         break;
464// mapper 58
1133465      case BMC_GKB:
1134         mapper_initialize(machine, 58);
466         prg32(machine, 0);
467         chr8(machine, 0, CHRROM);
1135468         break;
469// mapper 61
1136470      case RCM_TETRISFAMILY:
1137         mapper_initialize(machine, 61);
471         prg32(machine, 0);
1138472         break;
473// mapper 62
1139474      case BMC_SUPER_700IN1:
1140         mapper_initialize(machine, 62);
475         prg32(machine, 0);
1141476         break;
477// mapper 64
1142478      case TENGEN_800032:
1143         mapper_initialize(machine, 64);
479// mapper 158
480      case TENGEN_800037:
481         state->mmc_latch1 = 0;
482         prg16_89ab(machine, state->prg_chunks - 1);
483         prg16_cdef(machine, state->prg_chunks - 1);
1144484         break;
485// mapper 65
1145486      case IREM_H3001:
1146         mapper_initialize(machine, 65);
487         prg16_89ab(machine, 0);
488         prg16_cdef(machine, state->prg_chunks - 1);
1147489         break;
490// mapper 66
1148491      case STD_GXROM:
1149492      case STD_MXROM:
1150         mapper_initialize(machine, 66);
493         prg32(machine, 0);
1151494         break;
495// mapper 67
1152496      case SUNSOFT_3:
1153         mapper_initialize(machine, 67);
497         prg16_89ab(machine, 0);
498         prg16_cdef(machine, state->prg_chunks - 1);
1154499         break;
500// mapper 68
1155501      case STD_NXROM:
1156         mapper_initialize(machine, 68);
502         state->mmc_reg[0] = state->mmc_latch1 = state->mmc_latch2 = 0;
503         prg16_89ab(machine, 0);
504         prg16_cdef(machine, state->prg_chunks - 1);
1157505         break;
506// mapper 69
1158507      case STD_JXROM:
1159508      case SUNSOFT_5B:
1160509      case SUNSOFT_FME7:
1161         mapper_initialize(machine, 69);
510         prg16_89ab(machine, 0);
511         prg16_cdef(machine, state->prg_chunks - 1);
1162512         break;
1163      case DIS_74X161X161X32:
1164         mapper_initialize(machine, 70);
513// mapper 70
514      case DIS_74X161X161X32_A:
515         prg16_89ab(machine, state->prg_chunks - 2);
516         prg16_cdef(machine, state->prg_chunks - 1);
1165517         break;
1166      case CAMERICA_ALGN:
1167         mapper_initialize(machine, 71);
518// mapper 71
519      case CAMERICA_BF9093:
520      case CAMERICA_BF9097:
521         set_nt_mirroring(machine, PPU_MIRROR_HORZ);
522         prg16_89ab(machine, 0);
523         prg16_cdef(machine, state->prg_chunks - 1);
1168524         break;
1169      case CAMERICA_9097:
1170         state->crc_hack = 0xf0;
1171         mapper_initialize(machine, 71);
1172         break;
525// mapper 72
1173526      case JALECO_JF17:
1174         mapper_initialize(machine, 72);
527         prg16_89ab(machine, 0);
528         prg16_cdef(machine, state->prg_chunks - 1);
1175529         break;
530// mapper 73
1176531      case KONAMI_VRC3:
1177         mapper_initialize(machine, 73);
532         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
533         prg16_89ab(machine, 0);
534         prg16_cdef(machine, state->prg_chunks - 1);
1178535         break;
1179      case WAIXING_TYPE_A:
1180         mapper_initialize(machine, 74);
1181         break;
536// mapper 75
1182537      case KONAMI_VRC1:
1183         mapper_initialize(machine, 75);
538         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
539         prg16_89ab(machine, 0);
540         prg16_cdef(machine, state->prg_chunks - 1);
1184541         break;
542// mapper 76
1185543      case NAMCOT_3446:
1186         mapper_initialize(machine, 76);
544         prg8_89(machine, 0);
545         prg8_ab(machine, 1);
546         //cd is bankable, but this should init all banks just fine.
547         prg16_cdef(machine, state->prg_chunks - 1);
548         chr2_0(machine, 0, CHRROM);
549         chr2_2(machine, 1, CHRROM);
550         chr2_4(machine, 2, CHRROM);
551         chr2_6(machine, 3, CHRROM);
552         state->mmc_latch1 = 0;
1187553         break;
554// mapper 77
1188555      case IREM_LROG017:
1189         mapper_initialize(machine, 77);
556         prg32(machine, 0);
557         chr2_2(machine, 0, CHRROM);
558         chr2_4(machine, 1, CHRROM);
559         chr2_6(machine, 2, CHRROM);
1190560         break;
561// mapper 78
1191562      case IREM_HOLYDIV:
1192563      case JALECO_JF16:
1193         mapper_initialize(machine, 78);
564         prg16_89ab(machine, 0);
565         prg16_cdef(machine, state->prg_chunks - 1);
1194566         break;
567// mapper 79 (& 146)
1195568      case AVE_NINA06:
1196         mapper_initialize(machine, 79);
569         set_nt_mirroring(machine, PPU_MIRROR_HORZ);
570         chr8(machine, 0, CHRROM);
571         prg32(machine, 0);
1197572         break;
1198      case TAITO_X1005:
1199         mapper_initialize(machine, 80);
573// mapper 80
574      case TAITO_X1_005:
575         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
576         prg16_89ab(machine, 0);
577         prg16_cdef(machine, state->prg_chunks - 1);
1200578         break;
1201      case TAITO_X1017:
1202         mapper_initialize(machine, 82);
579// mapper 82
580      case TAITO_X1_017:
581         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
582         prg16_89ab(machine, 0);
583         prg16_cdef(machine, state->prg_chunks - 1);
1203584         break;
585// mapper 83
1204586      case CONY_BOARD:
1205         mapper_initialize(machine, 83);
587         state->mapper83_reg[9] = 0x0f;
588         prg8_cd(machine, 0x1e);
589         prg8_ef(machine, 0x1f);
1206590         break;
591// mapper 85
1207592      case KONAMI_VRC7:
1208         mapper_initialize(machine, 85);
593         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
594         prg16_89ab(machine, 0);
595         prg16_cdef(machine, state->prg_chunks - 1);
1209596         break;
597// mapper 86
1210598      case JALECO_JF13:
1211         mapper_initialize(machine, 86);
599         prg32(machine, 0);
1212600         break;
601// mapper 87
1213602      case DIS_74X139X74:
1214         mapper_initialize(machine, 87);
603         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
604         prg16_89ab(machine, 0);
605         prg16_cdef(machine, state->prg_chunks - 1);
1215606         break;
607// mapper 88
1216608      case NAMCOT_34X3:
1217         mapper_initialize(machine, 88);
609         prg8_89(machine, 0xc);
610         prg8_ab(machine, 0xd);
611         prg8_cd(machine, 0xe);
612         prg8_ef(machine, 0xf);
1218613         break;
1219      case SUNSOFT_2:
1220         mapper_initialize(machine, 89);
614// mapper 89
615      case SUNSOFT_2_B:
616         prg16_89ab(machine, 0);
617         prg16_cdef(machine, state->prg_chunks - 1);
618         set_nt_mirroring(machine, PPU_MIRROR_LOW);
1221619         break;
620// mapper 91
1222621      case UNL_MK2:
1223         mapper_initialize(machine, 91);
622         set_nt_mirroring(machine, PPU_MIRROR_VERT);
623         prg16_89ab(machine, state->prg_chunks - 1);
624         prg16_cdef(machine, state->prg_chunks - 1);
1224625         break;
626// mapper 92
1225627      case JALECO_JF19:
1226         mapper_initialize(machine, 92);
628         prg16_89ab(machine, 0);
629         prg16_cdef(machine, state->prg_chunks - 1);
1227630         break;
631// mapper 93
632      case SUNSOFT_2_A:
633         prg16_89ab(machine, 0);
634         prg16_cdef(machine, state->prg_chunks - 1);
635         break;
636// mapper 94
1228637      case STD_UN1ROM:
1229         mapper_initialize(machine, 94);
638         prg16_89ab(machine, 0);
639         prg16_cdef(machine, state->prg_chunks - 1);
1230640         break;
641// mapper 95
1231642      case NAMCOT_3425:
1232         mapper_initialize(machine, 95);
643         prg16_89ab(machine, 0);
644         prg16_cdef(machine, state->prg_chunks - 1);
1233645         break;
646// mapper 96
1234647      case BANDAI_OEKAKIDS:
1235         mapper_initialize(machine, 96);
648         prg32(machine, 0);
1236649         break;
650// mapper 97
651      case IREM_TAM_S1:
652         prg16_89ab(machine, state->prg_chunks - 1);
653         prg16_cdef(machine, state->prg_chunks - 1);
654         break;
655// mapper 104
1237656      case CAMERICA_GOLDENFIVE:
1238         mapper_initialize(machine, 104);
657         prg16_89ab(machine, 0x00);
658         prg16_cdef(machine, 0x0f);
1239659         break;
660// mapper 106
1240661      case BTL_SMB3:
1241         mapper_initialize(machine, 106);
662         prg8_89(machine, (state->prg_chunks << 1) - 1);
663         prg8_ab(machine, 0);
664         prg8_cd(machine, 0);
665         prg8_ef(machine, (state->prg_chunks << 1) - 1);
1242666         break;
1243      case MAGICSERIES_MAGICDRAGON:
1244         mapper_initialize(machine, 107);
667// mapper 107
668      case MAGICSERIES_MD:
669         prg32(machine, 0);
1245670         break;
671// mapper 112
1246672      case NTDEC_ASDER:
1247         mapper_initialize(machine, 112);
673         state->mmc_latch1 = 0;
674         prg16_89ab(machine, 0);
675         prg16_cdef(machine, state->prg_chunks - 1);
1248676         break;
677// mapper 113
1249678      case HES_BOARD:
1250         mapper_initialize(machine, 113);
679      case HES6IN1_BOARD:
680         prg32(machine, 0);
1251681         break;
682// mapper 114
1252683      case SUPERGAME_LIONKING:
1253         mapper_initialize(machine, 114);
684         state->map114_reg = state->map114_reg_enabled = 0;
685         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
686         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
687         state->mmc_latch1 = 0;
688         state->mmc_latch2 = 0x80;
689         state->mmc_prg_base = state->mmc_chr_base = 0;
690         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
691         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
692         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
693         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1254694         break;
695// mapper 115
1255696      case KASING_BOARD:
1256         mapper_initialize(machine, 115);
697         state->mapper115_reg[0] = 0;
698         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
699         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
700         state->mmc_latch1 = 0;
701         state->mmc_latch2 = 0x80;
702         state->mmc_prg_base = state->mmc_chr_base = 0;
703         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
704         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
705         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
706         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1257707         break;
1258      case SOMERITEAM_SL12:
1259         mapper_initialize(machine, 116);
1260         break;
708// mapper 116
709//      case SOMERITEAM_SL12:
710//         mapper_initialize(machine, 116);
711//         break;
712// mapper 117
1261713      case FUTUREMEDIA_BOARD:
1262         mapper_initialize(machine, 117);
714         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
715         prg16_89ab(machine, 0);
716         prg16_cdef(machine, state->prg_chunks - 1);
1263717         break;
1264      case STD_TXSROM:
1265         mapper_initialize(machine, 118);
1266         break;
1267      case STD_TQROM:
1268         mapper_initialize(machine, 119);
1269         break;
718// mapper 121
1270719      case KAY_PANDAPRINCE:
1271         mapper_initialize(machine, 121);
720         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
721         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
722         state->mapper121_reg[0] = state->mapper121_reg[1] = state->mapper121_reg[2] = 0;
723         state->mmc_latch1 = 0;
724         state->mmc_latch2 = 0x80;
725         state->mmc_prg_base = state->mmc_chr_base = 0;
726         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
727         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
728         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
729         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1272730         break;
731// mapper 132
1273732      case TXC_22211A:
1274         mapper_initialize(machine, 132);
733// mapper 172
734      case TXC_22211B:
735// mapper 173
736      case TXC_22211C:
737         state->txc_reg[0] = state->txc_reg[1] = state->txc_reg[2] = state->txc_reg[3] = 0;
738         prg32(machine, 0);
1275739         break;
740// mapper 133
1276741      case SACHEN_SA72008:
1277         mapper_initialize(machine, 133);
742// mapper 145
743      case SACHEN_SA72007:
744// mapper 147
745      case SACHEN_TCU01:
746// mapper 148
747      case SACHEN_SA0037:
748// mapper 149
749      case SACHEN_SA0036:
750         prg32(machine, 0);
751         chr8(machine, 0, CHRROM);
1278752         break;
753// mapper 134
1279754      case BMC_FAMILY_4646B:
1280         mapper_initialize(machine, 134);
755         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
756         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
757         state->mmc_latch1 = 0;
758         state->mmc_latch2 = 0x80;
759         state->mmc_prg_base = state->mmc_chr_base = 0;
760         state->mmc_prg_mask = 0x1f;
761         state->mmc_chr_mask = 0xff;
762         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
763         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
764         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1281765         break;
766// mapper 136
1282767      case SACHEN_TCU02:
1283         mapper_initialize(machine, 136);
768         state->mmc_latch1 = 0;
769         prg32(machine, 0);
1284770         break;
771// mapper 137
1285772      case SACHEN_8259D:
1286         mapper_initialize(machine, 137);
773         state->mmc_latch1 = 0;
774         prg32(machine, 0);
775         chr8(machine, state->chr_chunks - 1, CHRROM);
776         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1287777         break;
778// mapper 138
1288779      case SACHEN_8259B:
1289         mapper_initialize(machine, 138);
1290         break;
780// mapper 139
1291781      case SACHEN_8259C:
1292         mapper_initialize(machine, 139);
782// mapper 141
783      case SACHEN_8259A:
784         state->mmc_latch1 = 0;
785         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
786         prg32(machine, 0);
787         chr8(machine, 0, state->mmc_chr_source);
788         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1293789         break;
790         // mapper 117
1294791      case JALECO_JF11:
1295         mapper_initialize(machine, 140);
792         prg32(machine, 0);
1296793         break;
1297      case SACHEN_8259A:
1298         mapper_initialize(machine, 141);
1299         break;
794// mapper 143
1300795      case SACHEN_TCA01:
1301         mapper_initialize(machine, 143);
796         prg16_89ab(machine, 0);
797         prg16_cdef(machine, 1);
798         chr8(machine, 0, CHRROM);
1302799         break;
800// mapper 144
1303801      case AGCI_50282:
1304         mapper_initialize(machine, 144);
802         prg32(machine, 0);
1305803         break;
1306      case SACHEN_SA72007:
1307         mapper_initialize(machine, 145);
804// mapper 150
805      case SACHEN_74LS374:
806         state->mmc_latch1 = 0;
807         prg32(machine, 0);
808         chr8(machine, 0, CHRROM);
809         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1308810         break;
1309      case SACHEN_TCU01:
1310         mapper_initialize(machine, 147);
811// mapper 152
812      case DIS_74X161X161X32:
813         prg16_89ab(machine, 0);
814         prg16_cdef(machine, state->prg_chunks - 1);
815         chr8(machine, 0, CHRROM);
1311816         break;
1312      case SACHEN_SA0037:
1313         mapper_initialize(machine, 148);
817// mapper 153
818      case BANDAI_JUMP2:
819         for (i = 0; i < 8; i++)
820            state->mmc_reg[i] = 0;
821         state->mmc_latch1 = 0;
822         prg16_89ab(machine, 0);
823         prg16_cdef(machine, state->prg_chunks - 1);
824         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
825         state->mmc_latch1 = 0;
826         fjump2_set_prg(machine);
1314827         break;
1315      case SACHEN_SA0036:
1316         mapper_initialize(machine, 149);
1317         break;
1318      case SACHEN_74LS374:
1319         mapper_initialize(machine, 150);
1320         break;
1321828      case BANDAI_FCG:
1322      case BANDAI_JUMP2:
1323         mapper_initialize(machine, 153);
829         state->mmc_latch1 = 0;
830         prg16_89ab(machine, 0);
831         prg16_cdef(machine, state->prg_chunks - 1);
832         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
833         state->mmc_latch1 = 0;
1324834         break;
835// mapper 154
836      case NAMCOT_3453:
837         prg16_89ab(machine, state->prg_chunks - 2);
838         prg16_cdef(machine, state->prg_chunks - 1);
839         break;
840// mapper 156
1325841      case OPENCORP_DAOU306:
1326         mapper_initialize(machine, 156);
842         prg16_89ab(machine, state->prg_chunks - 2);
843         prg16_cdef(machine, state->prg_chunks - 1);
844         set_nt_mirroring(machine, PPU_MIRROR_LOW);
1327845         break;
1328      case BANDAI_DATACH:
1329         mapper_initialize(machine, 157);
1330         break;
1331      case TENGEN_800037:
1332         mapper_initialize(machine, 158);
1333         break;
846// mapper 164
1334847      case WAIXING_FFV:
1335         mapper_initialize(machine, 164);
848         prg32(machine, 0xff);
849         state->mid_ram_enable = 1;
1336850         break;
851// mapper 166
1337852      case SUBOR_TYPE1:
1338         mapper_initialize(machine, 166);
853         state->subor_reg[0] = state->subor_reg[1] = state->subor_reg[2] = state->subor_reg[3] = 0;
854         prg16_89ab(machine, 0);
855         prg16_cdef(machine, 0x07);
1339856         break;
857// mapper 167
1340858      case SUBOR_TYPE0:
1341         mapper_initialize(machine, 167);
859         state->subor_reg[0] = state->subor_reg[1] = state->subor_reg[2] = state->subor_reg[3] = 0;
860         prg16_89ab(machine, 0);
861         prg16_cdef(machine, 0x20);
1342862         break;
863// mapper 171
1343864      case KAISER_KS7058:
1344         mapper_initialize(machine, 171);
865         prg32(machine, 0);
866         chr8(machine, 0, CHRROM);
1345867         break;
868// mapper 176
1346869      case UNL_XZY:
1347         mapper_initialize(machine, 176);
870         prg32(machine, (state->prg_chunks - 1) >> 1);
1348871         break;
872// mapper 177
1349873      case HENGEDIANZI_BOARD:
1350         mapper_initialize(machine, 177);
874         prg32(machine, 0);
1351875         break;
876// mapper 178
1352877      case WAIXING_SGZLZ:
1353         mapper_initialize(machine, 178);
878         state->mmc_latch1 = 0;
879         prg32(machine, 0);
1354880         break;
881// mapper 179
882      case HENGEDIANZI_XJZB:
883         prg32(machine, 0);
884         break;
885// mapper 180
886      case UXROM_CC:
887         prg16_89ab(machine, 0);
888         prg16_cdef(machine, 0);
889         break;
890// mapper 182
1355891      case HOSENKAN_BOARD:
1356         mapper_initialize(machine, 182);
892         prg32(machine, (state->prg_chunks - 1) >> 1);
1357893         break;
894// mapper 184
1358895      case SUNSOFT_1:
1359         mapper_initialize(machine, 184);
896         prg32(machine, 0);
1360897         break;
898// mapper 187
1361899      case UNL_KOF96:
1362         mapper_initialize(machine, 187);
900         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
901         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
902         state->mapper187_reg[0] = state->mapper187_reg[1] = state->mapper187_reg[2] = state->mapper187_reg[3] = 0;
903         state->mmc_latch1 = 0;
904         state->mmc_latch2 = 0x80;
905         state->mmc_prg_base = state->mmc_chr_base = 0;
906         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
907         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
908         kof96_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
909         kof96_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1363910         break;
911// mapper 188
1364912      case BANDAI_KARAOKE:
1365         mapper_initialize(machine, 188);
913         prg16_89ab(machine, 0);
914         prg16_cdef(machine, (state->prg_chunks - 1) ^ 0x08);
1366915         break;
916// mapper 189
1367917      case TXC_TW:
1368         mapper_initialize(machine, 189);
918         state->mmc_latch1 = 0;
919         state->mmc_latch2 = 0x80;
920         state->mmc_chr_base = 0;
921         state->mmc_chr_mask = 0xff;
922         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
923         prg32(machine, 0);
924         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1369925         break;
1370      case WAIXING_TYPE_B:
1371         mapper_initialize(machine, 191);
1372         break;
1373      case WAIXING_TYPE_C:
1374         mapper_initialize(machine, 192);
1375         break;
926// mapper 193
1376927      case NTDEC_FIGHTINGHERO:
1377         mapper_initialize(machine, 193);
928         prg32(machine, (state->prg_chunks - 1) >> 1);
929         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1378930         break;
1379      case WAIXING_TYPE_D:
1380         mapper_initialize(machine, 194);
1381         break;
1382      case WAIXING_TYPE_E:
1383         mapper_initialize(machine, 195);
1384         break;
1385      case BTL_SUPERBROS11:
1386         mapper_initialize(machine, 196);
1387         break;
931// mapper 197
1388932      case UNL_SUPERFIGHTER3:
1389         mapper_initialize(machine, 197);
933         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
934         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
935         state->mmc_latch1 = 0;
936         state->mmc_latch2 = 0x80;
937         state->mmc_prg_base = state->mmc_chr_base = 0;
938         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
939         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
940         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
941         unl_sf3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1390942         break;
943// mapper 198
1391944      case WAIXING_TYPE_F:
1392         mapper_initialize(machine, 198);
945         state->mmc_prg_bank[0] = 0x00;
946         state->mmc_prg_bank[1] = 0x01;
947         state->mmc_prg_bank[2] = 0x4e;
948         state->mmc_prg_bank[3] = 0x4f;
949         state->mmc_latch1 = 0;
950         state->mmc_latch2 = 0x80;
951         state->mmc_prg_base = state->mmc_chr_base = 0;
952         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
953         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
954         waixing_f_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
955         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
1393956         break;
957// mapper 199
1394958      case WAIXING_TYPE_G:
1395         mapper_initialize(machine, 199);
959         state->mmc_prg_bank[0] = 0x00;
960         state->mmc_prg_bank[1] = 0x01;
961         state->mmc_prg_bank[2] = 0x3e;
962         state->mmc_prg_bank[3] = 0x3f;
963         state->mmc_latch1 = 0;
964         state->mmc_latch2 = 0x80;
965         state->mmc_prg_base = state->mmc_chr_base = 0;
966         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
967         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
968         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
969         waixing_g_set_chr(machine, state->mmc_chr_base, state->mmc_chr_mask);
1396970         break;
971// mapper 200
1397972      case BMC_36IN1:
1398         mapper_initialize(machine, 200);
973         prg16_89ab(machine, state->prg_chunks - 1);
974         prg16_cdef(machine, state->prg_chunks - 1);
1399975         break;
976// mapper 201
1400977      case BMC_21IN1:
1401         mapper_initialize(machine, 201);
978         prg32(machine, 0);
979         chr8(machine, 0, CHRROM);
1402980         break;
981// mapper 202
1403982      case BMC_150IN1:
1404         mapper_initialize(machine, 202);
1405         break;
983// mapper 203
1406984      case BMC_35IN1:
1407         mapper_initialize(machine, 203);
1408         break;
985// mapper 204
1409986      case BMC_64IN1:
1410         mapper_initialize(machine, 204);
987// mapper 214
988      case BMC_SUPERGUN_20IN1:
989         prg16_89ab(machine, 0);
990         prg16_cdef(machine, 0);
991         chr8(machine, 0, CHRROM);
1411992         break;
993// mapper 205
1412994      case BMC_15IN1:
1413         mapper_initialize(machine, 205);
995         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
996         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
997         state->mmc_latch1 = 0;
998         state->mmc_latch2 = 0x80;
999         state->mmc_prg_base = 0x10;
1000         state->mmc_prg_mask = 0x1f;
1001         state->mmc_chr_base = 0;
1002         state->mmc_chr_mask = 0xff;
1003         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1004         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
1005         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
14141006         break;
1415      case STD_DXROM:
1416         mapper_initialize(machine, 206);
1007// mapper 207
1008      case TAITO_X1_005_A:
1009         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1010         prg16_89ab(machine, 0);
1011         prg16_cdef(machine, state->prg_chunks - 1);
14171012         break;
1013// mapper 208
14181014      case GOUDER_37017:
1419         mapper_initialize(machine, 208);
1015         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
1016         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
1017         state->map208_reg[0] = state->map208_reg[1] = state->map208_reg[2] = state->map208_reg[3] = state->map208_reg[4] = 0;
1018         state->mmc_latch1 = 0;
1019         state->mmc_latch2 = 0x80;
1020         state->mmc_prg_base = state->mmc_chr_base = 0;
1021         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
1022         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1023         mmc3_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
1024         mmc3_set_chr(machine, state->mmc_chr_source, state->mmc_chr_base, state->mmc_chr_mask);
14201025         break;
1026// mapper 212
14211027      case BMC_SUPERHIK_300IN1:
1422         mapper_initialize(machine, 212);
1028         chr8(machine, 0xff, CHRROM);
1029         prg32(machine, 0xff);
14231030         break;
1031// mapper 213
14241032      case BMC_9999999IN1:
1425         mapper_initialize(machine, 213);
1033         prg32(machine, 0);
1034         chr8(machine, 0, CHRROM);
14261035         break;
1427      case BMC_SUPERGUN_20IN1:
1428         mapper_initialize(machine, 214);
1429         break;
1036// mapper 215
14301037      case SUPERGAME_BOOGERMAN:
1431         mapper_initialize(machine, 215);
1038         state->mmc_prg_bank[0] = 0x00;
1039         state->mmc_prg_bank[2] = 0xfe;
1040         state->mmc_prg_bank[1] = 0x01;
1041         state->mmc_prg_bank[3] = 0xff;
1042         state->mmc_latch1 = 0;
1043         state->mmc_latch2 = 0x80;
1044         state->map215_reg[0] = 0x00;
1045         state->map215_reg[1] = 0xff;
1046         state->map215_reg[2] = 0x04;
1047         state->map215_reg[3] = 0;
1048         state->mmc_prg_base = 0;
1049         state->mmc_prg_mask = 0x1f;
1050         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1051         sgame_boog_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
1052         sgame_boog_set_chr(machine, state->mmc_chr_source);
14321053         break;
1054// mapper 216
14331055      case RCM_GS2015:
1434         mapper_initialize(machine, 216);
1056         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1057         prg32(machine, 0);
1058         chr8(machine, 0, state->mmc_chr_source);
14351059         break;
1060// mapper 217
14361061      case BMC_GOLDENCARD_6IN1:
1437         mapper_initialize(machine, 217);
1062         state->map217_reg[0] = 0x00;
1063         state->map217_reg[1] = 0xff;
1064         state->map217_reg[2] = 0x03;
1065         state->map217_reg[3] = 0;
1066         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
1067         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
1068         state->mmc_latch1 = 0;
1069         state->mmc_latch2 = 0x80;
1070         state->mmc_prg_base = state->mmc_chr_base = 0;
1071         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
1072         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1073         bmc_gc6in1_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
1074         bmc_gc6in1_set_chr(machine, state->mmc_chr_source);
14381075         break;
1076// mapper 221
14391077      case UNL_N625092:
1440         mapper_initialize(machine, 221);
1078         state->mmc_latch1 = 0;
1079         state->mmc_latch2 = 0;
1080         prg16_89ab(machine, 0);
1081         prg16_cdef(machine, 0);
14411082         break;
1083// mapper 222
14421084      case BTL_DRAGONNINJA:
1443         mapper_initialize(machine, 222);
1085         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1086         prg16_89ab(machine, 0);
1087         prg16_cdef(machine, state->prg_chunks - 1);
14441088         break;
1089// mapper 225
14451090      case BMC_72IN1:
1446         mapper_initialize(machine, 225);
1091         prg32(machine, 0);
14471092         break;
1093// mapper 226
14481094      case BMC_76IN1:
14491095      case BMC_SUPER_42IN1:
1450         mapper_initialize(machine, 226);
1096         state->mmc_latch1 = 0;
1097         state->mmc_latch2 = 0;
1098         prg32(machine, 0);
14511099         break;
1100// mapper 227
14521101      case BMC_1200IN1:
1453         mapper_initialize(machine, 227);
1102         prg16_89ab(machine, 0);
1103         prg16_cdef(machine, 0);
14541104         break;
1105// mapper 228
14551106      case ACTENT_ACT52:
1456         mapper_initialize(machine, 228);
1107         chr8(machine, 0, CHRROM);
1108         prg32(machine, 0);
14571109         break;
1110// mapper 229
14581111      case BMC_31IN1:
1459         mapper_initialize(machine, 229);
1112         prg16_89ab(machine, 0);
1113         prg16_cdef(machine, 1);
1114         chr8(machine, 0, CHRROM);
1115         set_nt_mirroring(machine, PPU_MIRROR_VERT);
14601116         break;
1117// mapper 230
14611118      case BMC_22GAMES:
1462         mapper_initialize(machine, 230);
1119         prg16_89ab(machine, 0);
1120         prg16_cdef(machine, 7);
14631121         break;
1122// mapper 231
14641123      case BMC_20IN1:
1465         mapper_initialize(machine, 231);
1124         prg16_89ab(machine, 0);
1125         prg16_cdef(machine, state->prg_chunks - 1);
1126         set_nt_mirroring(machine, PPU_MIRROR_VERT);
14661127         break;
1467      case CAMERICA_ALGQ:
1468         mapper_initialize(machine, 232);
1128// mapper 232
1129      case CAMERICA_BF9096:
1130         state->mmc_latch1 = 0x18;
1131         state->mmc_latch2 = 0x00;
1132         bf9096_set_prg(machine);
14691133         break;
1134// mapper 240
14701135      case CNE_SHLZ:
1471         mapper_initialize(machine, 240);
1136         prg32(machine, 0);
14721137         break;
1138// mapper 241
14731139      case TXC_MXMDHTWO:
1474         mapper_initialize(machine, 241);
1140         prg32(machine, 0);
14751141         break;
1142// mapper 242
14761143      case WAIXING_ZS:
1477         mapper_initialize(machine, 242);
1144      case WAIXING_DQ8:
1145         prg32(machine, 0);
14781146         break;
1147// mapper 243
1148      case SACHEN_74LS374_A:
1149         state->mmc_vrom_bank[0] = 3;
1150         state->mmc_latch1 = 0;
1151         chr8(machine, 3, CHRROM);
1152         prg32(machine, 0);
1153         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1154         break;
1155// mapper 244
14791156      case CNE_DECATHLON:
1480         mapper_initialize(machine, 244);
1157         prg32(machine, 0);
14811158         break;
1482      case WAIXING_TYPE_H:
1483         mapper_initialize(machine, 245);
1159// mapper 246
1160      case CNE_FSB:
1161         prg32(machine, 0xff);
14841162         break;
1485      case CNE_PSB:
1486         mapper_initialize(machine, 246);
1487         break;
1163// mapper 249
14881164      case WAIXING_SECURITY:
1489         mapper_initialize(machine, 249);
1165         state->mmc_prg_bank[0] = state->mmc_prg_bank[2] = 0xfe;
1166         state->mmc_prg_bank[1] = state->mmc_prg_bank[3] = 0xff;
1167         state->mmc_latch1 = 0;
1168         state->mmc_latch2 = 0x80;
1169         state->map249_reg = 0;
1170         state->mmc_prg_base = state->mmc_chr_base = 0;
1171         state->mmc_prg_mask = state->mmc_chr_mask = 0xff;
1172         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1173         waixing_sec_set_prg(machine, state->mmc_prg_base, state->mmc_prg_mask);
1174         waixing_sec_set_chr(machine, state->mmc_chr_base, state->mmc_chr_mask);
14901175         break;
1491      case NITRA_TDA:
1492         mapper_initialize(machine, 250);
1493         break;
1176// mapper 252
14941177      case WAIXING_SGZ:
1495         mapper_initialize(machine, 252);
1178         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1179         prg16_89ab(machine, 0);
1180         prg16_cdef(machine, state->prg_chunks - 1);
14961181         break;
1182// mapper 255
14971183      case BMC_110IN1:
1498         mapper_initialize(machine, 255);
1184         prg16_89ab(machine, 0);
1185         prg16_cdef(machine, 1);
1186         chr8(machine, 0, CHRROM);
1187         set_nt_mirroring(machine, PPU_MIRROR_VERT);
14991188         break;
1500         
1189
1190// UNIF only         
1191      case BMC_64IN1NR:
1192         state->bmc_64in1nr_reg[0] = 0x80;
1193         state->bmc_64in1nr_reg[1] = 0x43;
1194         state->bmc_64in1nr_reg[2] = state->bmc_64in1nr_reg[3] = 0;
1195         bmc_64in1nr_set_prg(machine);
1196         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1197         chr8(machine, 0, CHRROM);
1198         break;
1199      case BMC_190IN1:
1200         prg16_89ab(machine, 0);
1201         prg16_cdef(machine, 0);
1202         chr8(machine, 0, CHRROM);
1203         break;
1204      case BMC_A65AS:
1205         prg16_89ab(machine, 0);
1206         prg16_cdef(machine, 7);
1207         set_nt_mirroring(machine, PPU_MIRROR_VERT);
1208         break;
1209      case BMC_GS2004:
1210      case BMC_GS2013:
1211         prg32(machine, 0xff);
1212         chr8(machine, 0, CHRRAM);
1213         break;
1214      case BMC_S24IN1SC03:
1215         state->bmc_s24in1sc03_reg[0] = 0x24;
1216         state->bmc_s24in1sc03_reg[1] = 0x9f;
1217         state->bmc_s24in1sc03_reg[2] = 0;
1218         state->mmc_prg_bank[0] = 0xfe;
1219         state->mmc_prg_bank[1] = 0xff;
1220         state->mmc_prg_bank[2] = 0xfe;
1221         state->mmc_prg_bank[3] = 0xff;
1222         state->mmc_latch1 = 0;
1223         state->mmc_latch2 = 0x80;
1224         bmc_s24in1sc03_set_prg(machine);
1225         bmc_s24in1sc03_set_chr(machine);
1226         break;
1227      case BMC_T262:
1228         state->mmc_latch1 = 0;
1229         state->mmc_latch2 = 0;
1230         prg16_89ab(machine, 0);
1231         prg16_cdef(machine, 7);
1232         break;
1233      case BMC_WS:
1234         state->mmc_latch1 = 0;
1235         prg32(machine, 0);
1236         break;
1237      case DREAMTECH_BOARD:
1238         prg16_89ab(machine, 0);
1239         prg16_cdef(machine, 8);
1240         chr8(machine, 0, CHRRAM);
1241         break;
1242      case UNL_8237:
1243         state->unl_8237_reg[0] = state->unl_8237_reg[1] = state->unl_8237_reg[2] = 0;
1244         state->mmc_prg_bank[0] = 0x00;
1245         state->mmc_prg_bank[1] = 0x01;
1246         state->mmc_prg_bank[2] = 0xfe;
1247         state->mmc_prg_bank[3] = 0xff;
1248         state->mmc_latch1 = 0;
1249         state->mmc_latch2 = 0x80;
1250         unl_8237_set_prg(machine);
1251         unl_8237_set_chr(machine);
1252         break;
1253      case UNL_AX5705:
1254         state->mmc_prg_bank[0] = 0;
1255         state->mmc_prg_bank[1] = 1;
1256         prg8_89(machine, state->mmc_prg_bank[0]);
1257         prg8_ab(machine, state->mmc_prg_bank[1]);
1258         prg8_cd(machine, 0xfe);
1259         prg8_ef(machine, 0xff);
1260         break;
1261      case UNL_CC21:
1262         prg32(machine, 0);
1263         chr8(machine, 0, CHRROM);
1264         break;
1265      case UNL_KOF97:
1266         mapper_initialize(machine, 4);
1267         break;
1268      case UNL_T230:
1269         state->mmc_chr_source = state->chr_chunks ? CHRROM : CHRRAM;
1270         prg16_89ab(machine, 0);
1271         prg16_cdef(machine, state->prg_chunks - 1);
1272         break;
1273
1274      case KONAMI_VRC4:
1275         mapper_initialize(machine, 21);
1276         break;
1277      case KONAMI_VRC2:
1278         mapper_initialize(machine, 22);
1279         break;
1280      case KONAMI_VRC6:
1281         mapper_initialize(machine, 24);
1282         break;
1283
15011284      case UNSUPPORTED_BOARD:
15021285      default:
15031286         /* Mapper not supported */
r8270r8271
15331316   state->battery_size = NES_BATTERY_SIZE; // FIXME: we should allow for smaller battery!
15341317   state->prg_ram = unif_board->wram;   // we should implement WRAM banks based on the size of this...
15351318   // state->hard_mirroring = unif_board->nt;
1536   // state->four_screen_vram = ;
1319   state->four_screen_vram = (unif_board->nt == NT_4SCR_2K || unif_board->nt == NT_4SCR_4K) ? 1 : 0;
15371320}
src/mess/machine/nes_mmc.c
r8270r8271
137137#define LOG_MMC(x) do { if (VERBOSE) logerror x; } while (0)
138138#define LOG_FDS(x) do { if (VERBOSE) logerror x; } while (0)
139139
140static int unif_initialize( running_machine *machine, int idx );
141
140142/*************************************************************
141143
142144    Base emulation (see drivers/nes.c):
r8270r8271
239241
240242   if (state->mmc_write_mid)
241243      (*state->mmc_write_mid)(space, offset, data);
244   else
245      logerror("Unimplemented MID mapper write, offset: %04x, data: %02x\n", offset + 0x6000, data);
242246}
243247
244248// currently, this is not used (but it might become handy for some pirate mapper)
r8270r8271
246250{
247251   nes_state *state = (nes_state *)space->machine->driver_data;
248252
249   if ((state->mid_ram_enable) || (state->mapper == 5))
250   {
251      if (state->battery && !state->trainer)
252         return state->battery_ram[offset];
253      else
254         return state->wram[(state->prg_bank[4] - state->prgram_bank5_start) * 0x2000 + offset];
255   }
253   if (state->mmc_read_mid)
254      (*state->mmc_read_mid)(space, offset);
256255   else
257      logerror("Unimplemented LOW mapper read, offset: %04x\n", offset + 0x6000);
256      logerror("Unimplemented MID mapper read, offset: %04x\n", offset + 0x6000);
258257
259258   return 0;
260259}
r8270r8271
269268      logerror("Unimplemented mapper write, offset: %04x, data: %02x\n", offset + 0x8000, data);
270269}
271270
272// apparently, a few pirate mappers also reads from here!
271// currently, this is not used (but it might become handy for some pirate mapper)
273272READ8_HANDLER( nes_mapper_r )
274273{
275   logerror("Unimplemented mapper read, offset: %04x\n", offset + 0x8000);
274   nes_state *state = (nes_state *)space->machine->driver_data;
275   
276   if (state->mmc_read)
277      (*state->mmc_read)(space, offset);
278   else
279      logerror("Unimplemented mapper read, offset: %04x\n", offset + 0x8000);
280   
276281   return 0;
277282}
278283
r8270r8271
680685
681686
682687/*************************************************************
688 
689 Support for xml list
690 
691 *************************************************************/
683692
693/* Include emulation of NES PCBs for softlist */
694#include "machine/nes_pcb.c"
695
696
697/*************************************************************
698
684699    Support for .unf Files
685700
686701*************************************************************/
r8270r8271
689704#include "machine/nes_unif.c"
690705
691706
692/*************************************************************
693 
694 Support for xml list
695 
696 *************************************************************/
697
698/* Include emulation of NES PCBs for softlist */
699#include "machine/nes_pcb.c"
700
src/mess/machine/nes_mmc.h
r8270r8271
11#ifndef __MMC_H
22#define __MMC_H
33
4/* Boards */
5enum
6{
7   STD_NROM = 0,
8   STD_AXROM, STD_BXROM, STD_CNROM, STD_CPROM,
9   STD_DXROM, STD_EXROM, STD_FXROM, STD_GXROM,
10   STD_HKROM, STD_JXROM, STD_MXROM, STD_NXROM,
11   STD_PXROM, STD_SXROM, STD_TXROM, STD_TXSROM,
12   STD_TQROM, STD_UN1ROM, STD_UXROM,
13   HVC_FAMBASIC, NES_QJ, PAL_ZZ, UXROM_CC,
14   STD_DRROM, STD_SXROM_A, STD_SOROM, STD_TVROM,
15   /* Discrete components boards (by various manufacturer */
16   DIS_74X161X138, DIS_74X139X74, DIS_74X377,
17   DIS_74X161X161X32, DIS_74X161X161X32_A,
18   /* Active Enterprises */
19   ACTENT_ACT52,
20   /* AGCI */
21   AGCI_50282,
22   /* AVE */
23   AVE_NINA01, AVE_NINA06,
24   /* Bandai */
25   BANDAI_JUMP2, BANDAI_PT554,
26   BANDAI_DATACH, BANDAI_KARAOKE, BANDAI_OEKAKIDS,
27   BANDAI_FCG, BANDAI_LZ93,
28   /* Caltron */
29   CALTRON_6IN1,
30   /* Camerica */
31   CAMERICA_BF9093, CAMERICA_BF9097, CAMERICA_BF9096,
32   CAMERICA_GOLDENFIVE, GG_NROM,
33   /* Dreamtech */
34   DREAMTECH_BOARD,
35   /* Irem */
36   IREM_G101, IREM_G101_A, IREM_HOLYDIV,
37   IREM_H3001, IREM_LROG017, IREM_TAM_S1,
38   /* Jaleco */
39   JALECO_SS88006, JALECO_JF11, JALECO_JF13,
40   JALECO_JF16, JALECO_JF17, JALECO_JF19,
41   /* Konami */
42   KONAMI_VRC1, KONAMI_VRC2, KONAMI_VRC3,
43   KONAMI_VRC4, KONAMI_VRC6, KONAMI_VRC7,
44   /* Namcot */
45   NAMCOT_163, NAMCOT_3453,
46   NAMCOT_3425, NAMCOT_34X3, NAMCOT_3446,
47   /* NTDEC */
48   NTDEC_ASDER, NTDEC_FIGHTINGHERO,
49   /* Rex Soft */
50   REXSOFT_SL1632, REXSOFT_DBZ5,
51   /* Sachen */
52   SACHEN_8259A, SACHEN_8259B, SACHEN_8259C,
53   SACHEN_8259D, SACHEN_SA0036, SACHEN_SA0037,
54   SACHEN_SA72007, SACHEN_SA72008, SACHEN_TCA01,
55   SACHEN_TCU01, SACHEN_TCU02,
56   SACHEN_74LS374, SACHEN_74LS374_A,
57   /* Sunsoft */
58   SUNSOFT_1, SUNSOFT_2_A, SUNSOFT_2_B, SUNSOFT_3,
59   SUNSOFT_4, SUNSOFT_5B, SUNSOFT_FME7,
60   /* Taito */
61   TAITO_TC0190FMC, TAITO_TC0190FMCP,
62   TAITO_X1_005, TAITO_X1_005_A, TAITO_X1_017,
63   /* Tengen */
64   TENGEN_800008, TENGEN_800032, TENGEN_800037,
65   /* TXC */
66   TXC_22211A, TXC_22211B, TXC_22211C,
67   TXC_MXMDHTWO, TXC_TW,
68   /* Multigame Carts */
69   BMC_64IN1NR, BMC_190IN1, BMC_A65AS, BMC_GS2004, BMC_GS2013,
70   BMC_HIK8IN1, BMC_NOVELDIAMOND, BMC_S24IN1SC03, BMC_T262,
71   BMC_WS, BMC_SUPERBIG_7IN1, BMC_SUPERHIK_4IN1, BMC_BALLGAMES_11IN1,
72   BMC_MARIOPARTY_7IN1, BMC_SUPER_700IN1, BMC_FAMILY_4646B,
73   BMC_36IN1, BMC_21IN1, BMC_150IN1, BMC_35IN1, BMC_64IN1,
74   BMC_15IN1, BMC_SUPERHIK_300IN1, BMC_9999999IN1, BMC_SUPERGUN_20IN1,
75   BMC_GOLDENCARD_6IN1, BMC_72IN1, BMC_SUPER_42IN1, BMC_76IN1,
76   BMC_1200IN1, BMC_31IN1, BMC_22GAMES, BMC_20IN1, BMC_110IN1, BMC_GKA, BMC_GKB,
77   /* Unlicensed */
78   UNL_8237, UNL_CC21, UNL_AX5705, UNL_KOF97,
79   UNL_N625092, UNL_SC127, UNL_SMB2J, UNL_T230,
80   UNL_UXROM, UNL_MK2, UNL_XZY, UNL_KOF96,
81   UNL_SUPERFIGHTER3,
82   /* Bootleg boards */
83   BTL_SMB2A, BTL_MARIOBABY, BTL_AISENSHINICOL,
84   BTL_SMB2B, BTL_SMB3, BTL_SUPERBROS11, BTL_DRAGONNINJA,
85   /* Misc: these are needed to convert mappers to boards, I will sort them later */
86   OPENCORP_DAOU306, HES_BOARD, HES6IN1_BOARD, RUMBLESTATION_BOARD,
87   MAGICSERIES_MD, KASING_BOARD, FUTUREMEDIA_BOARD, SOMERITEAM_SL12,
88   HENGEDIANZI_BOARD, HENGEDIANZI_XJZB, SUBOR_TYPE0, SUBOR_TYPE1, KAISER_KS7058, CONY_BOARD,
89   CNE_DECATHLON, CNE_FSB, CNE_SHLZ, RCM_GS2015, RCM_TETRISFAMILY,
90   WAIXING_TYPE_A, WAIXING_TYPE_B, WAIXING_TYPE_C, WAIXING_TYPE_D,
91   WAIXING_TYPE_E, WAIXING_TYPE_F, WAIXING_TYPE_G, WAIXING_TYPE_H,
92   WAIXING_SGZLZ, WAIXING_SGZ, WAIXING_ZS, WAIXING_SECURITY,
93   WAIXING_DQ8, WAIXING_FFV, WAIXING_PS2, SUPERGAME_LIONKING, SUPERGAME_BOOGERMAN,
94   KAY_PANDAPRINCE, HOSENKAN_BOARD, NITRA_TDA, GOUDER_37017,
95   /* Unsupported (for place-holder boards, with no working emulation) */
96   UNSUPPORTED_BOARD
97};
98
499//extern int MMC1_extended; /* 0 = normal MMC1 cart, 1 = 512k MMC1, 2 = 1024k MMC1 */
5100
6101#define MMC5_VRAM
r8270r8271
11106void mapper_handlers_setup(running_machine *machine);
12107void pcb_handlers_setup(running_machine *machine);
13108void unif_mapr_setup(running_machine *machine, const char *board);
14extern int nes_get_pcb_id(running_machine *machine, const char *feature);
109int nes_get_pcb_id(running_machine *machine, const char *feature);
110void nes_pcb_setup(running_machine *machine, int ID);
15111
16112WRITE8_HANDLER( nes_low_mapper_w );
17113WRITE8_HANDLER( nes_mid_mapper_w );
src/mess/machine/nes_ines.c
r8270r8271
68146814
68156815*************************************************************/
68166816
6817static WRITE8_HANDLER( mapper_140_m_w )
6817static WRITE8_HANDLER( mapper140_m_w )
68186818{
68196819       chr8(space->machine, data & 0x0f, CHRROM);
68206820       prg32(space->machine, (data >> 4) & 0x03);
r8270r8271
1096510965   { 137, "Sachen 8259D",             mapper137_l_w, NULL, mapper137_m_w, NULL, NULL, NULL, NULL },
1096610966   { 138, "Sachen 8259B",             mapper138_l_w, NULL, mapper138_m_w, NULL, NULL, NULL, NULL },
1096710967   { 139, "Sachen 8259C",             mapper139_l_w, NULL, mapper139_m_w, NULL, NULL, NULL, NULL },
10968   { 140, "Jaleco JF11",              NULL, NULL, mapper_140_m_w, NULL, NULL, NULL, NULL },
10968   { 140, "Jaleco JF11",              NULL, NULL, mapper140_m_w, NULL, NULL, NULL, NULL },
1096910969   { 141, "Sachen 8259A",             mapper141_l_w, NULL, mapper141_m_w, NULL, NULL, NULL, NULL },
1097010970// 142 Kaiser KS7032
1097110971   { 143, "Sachen TCA01",             NULL, mapper143_l_r, NULL, NULL, NULL, NULL, NULL },
r8270r8271
1114811148         /* that much is documented for Nintendo Gauntlet boards */
1114911149         if (state->four_screen_vram)
1115011150         {
11151            state->extended_ntram = auto_alloc_array(machine, UINT8, 0x2000);
11152            state_save_register_global_pointer(machine, state->extended_ntram, 0x2000);
1115311151            set_nt_page(machine, 0, CART_NTRAM, 0, 1);
1115411152            set_nt_page(machine, 1, CART_NTRAM, 1, 1);
1115511153            set_nt_page(machine, 2, CART_NTRAM, 2, 1);

Previous 15994 Revisions Next


© 1998-2018 The MESS Team