mirror of
https://github.com/ekeeke/Genesis-Plus-GX.git
synced 2024-11-05 02:15:07 +01:00
f7ccaffa9f
.improved emulation of copy protection hardware used in some unlicensed games (now bypass all checks in Mulan & Pocket Monsters II)
778 lines
27 KiB
C
778 lines
27 KiB
C
|
|
/****************************************************************************
|
|
* Genesis Plus
|
|
* Cartridge Hardware support
|
|
*
|
|
* Copyright (C) 2007, 2008, 2009 Eke-Eke (GCN/Wii port)
|
|
*
|
|
* Most cartridge protections documented by Haze
|
|
* (http://haze.mameworld.info/)
|
|
*
|
|
* Realtec mapper documented by TascoDeluxe
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
***************************************************************************/
|
|
|
|
#include "shared.h"
|
|
|
|
#define CART_CNT 28
|
|
|
|
extern int emulate_address_error;
|
|
|
|
/* Global Variables */
|
|
T_CART cart;
|
|
|
|
/* Cart database entry */
|
|
typedef struct
|
|
{
|
|
uint16 chk_1; /* header checksum */
|
|
uint16 chk_2; /* real checksum */
|
|
uint8 bank_start; /* first mapped bank in $400000-$7fffff region */
|
|
uint8 bank_end; /* last mapped bank in $400000-$7fffff region */
|
|
T_CART_HW cart_hw; /* hardware description */
|
|
} T_CART_ENTRY;
|
|
|
|
/* Function prototypes */
|
|
static void sega_mapper_w(uint32 address, uint32 data);
|
|
static void special_mapper_w(uint32 address, uint32 data);
|
|
static void realtec_mapper_w(uint32 address, uint32 data);
|
|
static void seganet_mapper_w(uint32 address, uint32 data);
|
|
static uint32 radica_mapper_r(uint32 address);
|
|
static void default_time_w(uint32 address, uint32 data);
|
|
static void default_regs_w(uint32 address, uint32 data);
|
|
static uint32 default_regs_r(uint32 address);
|
|
static void special_regs_w(uint32 address, uint32 data);
|
|
|
|
/* Games that need extra hardware emulation:
|
|
- copy protection device
|
|
- custom ROM banking device
|
|
*/
|
|
static const T_CART_ENTRY rom_database[CART_CNT] =
|
|
{
|
|
/* Funny World & Balloon Boy */
|
|
{0x0000,0x06ab,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},1,1,NULL,NULL,NULL,realtec_mapper_w}},
|
|
/* Whac-a-Critter */
|
|
{0xffff,0xf863,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},1,1,NULL,NULL,NULL,realtec_mapper_w}},
|
|
/* Earth Defense */
|
|
{0xffff,0x44fb,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},1,1,NULL,NULL,NULL,realtec_mapper_w}},
|
|
/* RADICA (Volume 1) (not byteswapped) */
|
|
{0x0000,0x2326,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,1,radica_mapper_r,NULL,NULL,NULL}},
|
|
/* RADICA (Volume 2) */
|
|
{0x4f10,0x0836,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,1,radica_mapper_r,NULL,NULL,NULL}},
|
|
/* RADICA (Volume 1) */
|
|
{0xf424,0x9f82,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,1,radica_mapper_r,NULL,NULL,NULL}},
|
|
/* Mulan */
|
|
{0x0404,0x1b40,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,special_regs_w}},
|
|
/* Pocket Monsters II */
|
|
{0x47f9,0x17e5,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,special_regs_w}},
|
|
/* Lion King 3 */
|
|
{0x0000,0x507c,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,special_regs_w}},
|
|
/* Super King Kong 99 */
|
|
{0x0000,0x7d6e,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,special_regs_w}},
|
|
/* Pokemon Stadium */
|
|
{0x0000,0x843c,0x70,0x7f,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,1,NULL,NULL,NULL,special_regs_w}},
|
|
/* Lion King 2 */
|
|
{0xffff,0x1d9b,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xfffffd,0xfffffd,0xffffff,0xffffff},{0x400000,0x400004,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,default_regs_w}},
|
|
/* Squirell King */
|
|
{0x0000,0x8ec8,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xfffffd,0xfffffd,0xffffff,0xffffff},{0x400000,0x400004,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,default_regs_w}},
|
|
/* Supper Bubble Bobble */
|
|
{0x0000,0x16cd,0x40,0x40,{{0x55,0x0f,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,NULL}},
|
|
/* Mahjong Lover */
|
|
{0x0000,0x7037,0x40,0x40,{{0x90,0xd3,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x401000,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,NULL}},
|
|
/* Elf Wor */
|
|
{0x0080,0x3dba,0x40,0x40,{{0x55,0x0f,0xc9,0x18},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
|
|
/* Huan Le Tao Qi Shu - Smart Mouse */
|
|
{0x0000,0x1a28,0x40,0x40,{{0x55,0x0f,0xaa,0xf0},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
|
|
/* Ya-Se Chuanshuo */
|
|
{0xffff,0xd472,0x40,0x40,{{0x63,0x98,0xc9,0x18},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
|
|
/* Soul Blade */
|
|
{0x0000,0x0c5b,0x40,0x40,{{0x00,0x98,0xc9,0xF0},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
|
|
/* King of Fighter 98 */
|
|
{0x0000,0xd0a0,0x48,0x4f,{{0xaa,0xa0,0xf0,0xa0},{0xfc0000,0xffffff,0xffffff,0xffffff},{0x480000,0x4c82c0,0x4cdda0,0x4f8820},0,0,NULL,NULL,default_regs_r,NULL}},
|
|
/* Lian Huan Pao - Barver Battle Saga */
|
|
{0x30b9,0x1c2a,0x40,0x40,{{0x00,0x00,0x00,0x00},{0x000000,0x000000,0x000000,0x000000},{0x000000,0x000000,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,NULL}},
|
|
/* Rockman X3 */
|
|
{0x0000,0x9d0e,0x40,0x40,{{0x0c,0x88,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0x400004,0x000000,0x000000},0,0,default_regs_r,NULL,default_regs_r,NULL}},
|
|
/* Super Mario 2 1998 */
|
|
{0xffff,0x0474,0x00,0x00,{{0x0a,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0x000000,0x000000,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
|
|
/* Super Mario 2 1998 */
|
|
{0x2020,0xb4eb,0x00,0x00,{{0x1c,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0x000000,0x000000,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
|
|
/* A Bug's Life */
|
|
{0x7f7f,0x2aad,0x00,0x00,{{0x28,0x1f,0x01,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0xa13002,0xa1303e,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
|
|
/* King of Fighter 99 */
|
|
{0x0000,0x021e,0x00,0x00,{{0x00,0x01,0x1f,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0xa13002,0xa1303e,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
|
|
/* Pocket Monster */
|
|
{0xd6fc,0x1eb1,0x00,0x00,{{0x00,0x01,0x1f,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0xa13002,0xa1303e,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
|
|
/* Game no Kanzume Otokuyou */
|
|
{0x0000,0xf9d1,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,0,NULL,seganet_mapper_w,NULL,NULL}}
|
|
};
|
|
|
|
|
|
/************************************************************
|
|
Cart Hardware initialization
|
|
*************************************************************/
|
|
|
|
/* cart hardware detection */
|
|
void cart_hw_init()
|
|
{
|
|
int i;
|
|
|
|
/***************************************************************************************************************
|
|
CARTRIDGE ROM MIRRORING
|
|
***************************************************************************************************************
|
|
|
|
Cartridge area is mapped to $000000-$3fffff:
|
|
|
|
-> when accessing ROM, 68k address lines A1 to A21 are used by the internal cartridge hardware to decode the
|
|
full 4MB address range.
|
|
-> depending on the ROM total size, some address lines might be ignored, resulting in ROM mirroring.
|
|
|
|
|
|
Cartridges can use either 8-bits (x2) or 16-bits (x1, x2) Mask ROM chips, each chip size is a factor of 2 bytes:
|
|
|
|
-> two 8-bits chips are equivalent to one 16-bits chip, no specific address decoding is required, needed
|
|
address lines are simply connected to each chip, upper address lines are ignored and data lines are
|
|
connected appropriately to each chip (D0-D7 to one chip, D8-D15 to the other one).
|
|
ROM is mirrored each N bytes where N=2^(k+1) is the total ROM size (ROM1+ROM2,ROM1+ROM2,...).
|
|
|
|
-> one single 16-bits chip do not need specific address decoding, address lines are simply connected
|
|
depending on the ROM size, upper address lines being ignored.
|
|
ROM is mirrored each N bytes where N=2^k is the size of the ROM chip (ROM1,ROM1,ROM1,...).
|
|
|
|
-> two 16-bits chips of the same size are equivalent to one chip of double size, address decoding generally
|
|
is the same except that specific hardware is used (one address line is generally used for chip selection,
|
|
lower ones being used to address the chips and upper ones being ignored).
|
|
ROM is mirrored continuously each N bytes where N=2^(k+1) is the total ROM size (ROM1,ROM2,ROM1,ROM2,...).
|
|
|
|
-> two 16-bits chips with different size are mapped differently. Address decoding is done the same way as
|
|
above (one address line used for chip selection) but the ignored & required address lines differ from
|
|
one chip to another, which makes ROM mirroring different.
|
|
ROM2 size is generally half of ROM1 size and ROM are mirrored like that : ROM1,ROM2,ROM2,ROM1,ROM2,ROM2,...
|
|
|
|
From the emulator point of view, we only need to distinguish 3 cases:
|
|
|
|
1/ total ROM size is a factor of 2: ROM is mirrored each 2^k bytes.
|
|
|
|
2/ total ROM size is not a factor of 2 and cartridge uses one or two chips of the same size (Type A):
|
|
ROM is padded up to 2^k and mirrored each 2^k bytes.
|
|
|
|
3/ total ROM size is not a factor of 2 and cartridge uses two chips of different sizes (Type B):
|
|
ROM is not padded and the first 2^(k-1) bytes are mirrored each 2^k bytes while the next 2^(k-2) bytes are
|
|
mirrored in the last 2^(k-2) bytes.
|
|
|
|
******************************************************************************************************************/
|
|
|
|
/* calculate nearest size with factor of 2 */
|
|
unsigned int size = 0x10000;
|
|
while (cart.romsize > size)
|
|
size <<= 1;
|
|
|
|
/* total ROM size is not a factor of 2 */
|
|
/* TODO: handle more possible ROM configurations (using cartridge database ???) */
|
|
if ((size < MAXROMSIZE) && (cart.romsize < size))
|
|
{
|
|
/* two chips with different size */
|
|
if (config.romtype)
|
|
{
|
|
/* third ROM section is mirrored in the last section */
|
|
memcpy(cart.rom + cart.romsize, cart.rom + 2*cart.romsize - size, size - cart.romsize);
|
|
}
|
|
else
|
|
{
|
|
/* ROM is padded up to 2^k bytes */
|
|
memset(cart.rom + cart.romsize, 0xff, size - cart.romsize);
|
|
}
|
|
}
|
|
|
|
/* special case: Sonic & Knuckles */
|
|
/* $200000-$3fffff is mapped to external cartridge */
|
|
if (strstr(rominfo.international,"SONIC & KNUCKLES") != NULL)
|
|
{
|
|
/* disable ROM mirroring */
|
|
size = 0x400000;
|
|
}
|
|
|
|
/* ROM is mirrored each 2^k bytes */
|
|
cart.mask = size - 1;
|
|
|
|
/**********************************************
|
|
DEFAULT CARTRIDGE MAPPING
|
|
***********************************************/
|
|
for (i=0; i<0x40; i++)
|
|
{
|
|
/* cartridge ROM */
|
|
m68k_memory_map[i].base = cart.rom + ((i<<16) & cart.mask);
|
|
m68k_memory_map[i].read8 = NULL;
|
|
m68k_memory_map[i].read16 = NULL;
|
|
m68k_memory_map[i].write8 = m68k_unused_8_w;
|
|
m68k_memory_map[i].write16 = m68k_unused_16_w;
|
|
zbank_memory_map[i].read = NULL;
|
|
zbank_memory_map[i].write = zbank_unused_w;
|
|
}
|
|
|
|
for (i=0x40; i<0x80; i++)
|
|
{
|
|
/* unused area */
|
|
m68k_memory_map[i].base = cart.rom + (i<<16);
|
|
m68k_memory_map[i].read8 = m68k_read_bus_8;
|
|
m68k_memory_map[i].read16 = m68k_read_bus_16;
|
|
m68k_memory_map[i].write8 = m68k_unused_8_w;
|
|
m68k_memory_map[i].write16 = m68k_unused_16_w;
|
|
zbank_memory_map[i].read = zbank_unused_r;
|
|
zbank_memory_map[i].write = zbank_unused_w;
|
|
}
|
|
|
|
/**********************************************
|
|
BACKUP MEMORY
|
|
***********************************************/
|
|
sram_init();
|
|
eeprom_init();
|
|
if (sram.on)
|
|
{
|
|
if (sram.custom)
|
|
{
|
|
/* Serial EEPROM */
|
|
m68k_memory_map[eeprom.type.sda_out_adr >> 16].read8 = eeprom_read_byte;
|
|
m68k_memory_map[eeprom.type.sda_out_adr >> 16].read16 = eeprom_read_word;
|
|
m68k_memory_map[eeprom.type.sda_in_adr >> 16].read8 = eeprom_read_byte;
|
|
m68k_memory_map[eeprom.type.sda_in_adr >> 16].read16 = eeprom_read_word;
|
|
m68k_memory_map[eeprom.type.scl_adr >> 16].write8 = eeprom_write_byte;
|
|
m68k_memory_map[eeprom.type.scl_adr >> 16].write16 = eeprom_write_word;
|
|
zbank_memory_map[eeprom.type.sda_out_adr >> 16].read = eeprom_read_byte;
|
|
zbank_memory_map[eeprom.type.sda_in_adr >> 16].read = eeprom_read_byte;
|
|
zbank_memory_map[eeprom.type.scl_adr >> 16].write = eeprom_write_byte;
|
|
}
|
|
else
|
|
{
|
|
/* Static RAM (64k max.) */
|
|
m68k_memory_map[sram.start >> 16].base = sram.sram;
|
|
m68k_memory_map[sram.start >> 16].read8 = NULL;
|
|
m68k_memory_map[sram.start >> 16].read16 = NULL;
|
|
m68k_memory_map[sram.start >> 16].write8 = NULL;
|
|
m68k_memory_map[sram.start >> 16].write16 = NULL;
|
|
zbank_memory_map[sram.start >> 16].read = NULL;
|
|
zbank_memory_map[sram.start >> 16].write = NULL;
|
|
}
|
|
}
|
|
|
|
/**********************************************
|
|
SVP CHIP
|
|
***********************************************/
|
|
svp = NULL;
|
|
if (strstr(rominfo.international,"Virtua Racing") != NULL)
|
|
{
|
|
svp_init();
|
|
|
|
m68k_memory_map[0x30].base = svp->dram;
|
|
m68k_memory_map[0x30].read16 = NULL;
|
|
m68k_memory_map[0x30].write16 = svp_write_dram;
|
|
|
|
m68k_memory_map[0x31].base = svp->dram + 0x10000;
|
|
m68k_memory_map[0x31].read16 = NULL;
|
|
m68k_memory_map[0x31].write16 = svp_write_dram;
|
|
|
|
m68k_memory_map[0x39].read16 = svp_read_cell_1;
|
|
m68k_memory_map[0x3a].read16 = svp_read_cell_2;
|
|
}
|
|
|
|
/**********************************************
|
|
J-CART
|
|
***********************************************/
|
|
if (cart.jcart)
|
|
{
|
|
m68k_memory_map[0x38].read16 = jcart_read;
|
|
m68k_memory_map[0x38].write16 = jcart_write;
|
|
m68k_memory_map[0x3f].read16 = jcart_read;
|
|
m68k_memory_map[0x3f].write16 = jcart_write;
|
|
}
|
|
|
|
/**********************************************
|
|
LOCK-ON
|
|
***********************************************/
|
|
|
|
/* clear all existing patches */
|
|
ggenie_shutdown();
|
|
datel_shutdown();
|
|
|
|
/* initialize extra hardware */
|
|
cart.lock_on = 0;
|
|
switch (config.lock_on)
|
|
{
|
|
case TYPE_GG:
|
|
ggenie_init();
|
|
break;
|
|
|
|
case TYPE_AR:
|
|
datel_init();
|
|
break;
|
|
|
|
case TYPE_SK:
|
|
{
|
|
/* store S&K ROM above cartridge ROM + SRAM */
|
|
if (cart.romsize > 0x600000) break;
|
|
|
|
/* load Sonic & Knuckles ROM (2 MBytes) */
|
|
FILE *f = fopen(SK_ROM,"r+b");
|
|
if (!f) break;
|
|
int done = 0;
|
|
while (done < 0x200000)
|
|
{
|
|
fread(cart.rom + 0x600000 + done, 2048, 1, f);
|
|
done += 2048;
|
|
}
|
|
fclose(f);
|
|
|
|
/* load Sonic 2 UPMEM ROM (256 KBytes) */
|
|
f = fopen(SK_UPMEM,"r+b");
|
|
if (!f) break;
|
|
done = 0;
|
|
while (done < 0x40000)
|
|
{
|
|
fread(cart.rom + 0x800000 + done, 2048, 1, f);
|
|
done += 2048;
|
|
}
|
|
fclose(f);
|
|
|
|
#ifdef LSB_FIRST
|
|
/* Byteswap ROM */
|
|
int i;
|
|
uint8 temp;
|
|
for(i = 0; i < 0x240000; i += 2)
|
|
{
|
|
temp = cart.rom[i + 0x600000];
|
|
cart.rom[i + 0x600000] = cart.rom[i + 0x600000 + 1];
|
|
cart.rom[i + 0x600000 + 1] = temp;
|
|
}
|
|
#endif
|
|
|
|
/*$000000-$1fffff is mapped to S&K ROM */
|
|
for (i=0x00; i<0x20; i++)
|
|
m68k_memory_map[i].base = (cart.rom + 0x600000) + (i<<16);
|
|
|
|
cart.lock_on = 1;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/**********************************************
|
|
Cartridge Extra Hardware
|
|
***********************************************/
|
|
memset(&cart.hw, 0, sizeof(T_CART_HW));
|
|
|
|
/* search for game into database */
|
|
for (i=0; i < CART_CNT + 1; i++)
|
|
{
|
|
/* known cart found ! */
|
|
if ((rominfo.checksum == rom_database[i].chk_1) &&
|
|
(rominfo.realchecksum == rom_database[i].chk_2))
|
|
{
|
|
/* retrieve hardware information */
|
|
memcpy(&cart.hw, &(rom_database[i].cart_hw), sizeof(T_CART_HW));
|
|
|
|
/* initialize memory handlers for $400000-$7fffff region */
|
|
int j = rom_database[i].bank_start;
|
|
while (j <= rom_database[i].bank_end)
|
|
{
|
|
if (cart.hw.regs_r)
|
|
{
|
|
m68k_memory_map[j].read8 = cart.hw.regs_r;
|
|
m68k_memory_map[j].read16 = cart.hw.regs_r;
|
|
zbank_memory_map[j].read = cart.hw.regs_r;
|
|
}
|
|
if (cart.hw.regs_w)
|
|
{
|
|
m68k_memory_map[j].write8 = cart.hw.regs_w;
|
|
m68k_memory_map[j].write16 = cart.hw.regs_w;
|
|
zbank_memory_map[j].write = cart.hw.regs_w;
|
|
}
|
|
j++;
|
|
}
|
|
|
|
/* leave loop */
|
|
i = CART_CNT + 1;
|
|
}
|
|
}
|
|
|
|
#if M68K_EMULATE_ADDRESS_ERROR
|
|
/* default behavior */
|
|
emulate_address_error = config.addr_error;
|
|
#endif
|
|
|
|
/* detect special cartridges */
|
|
if (cart.romsize > 0x800000)
|
|
{
|
|
/* Ultimate MK3 (hack) */
|
|
for (i=0x40; i<0xA0; i++)
|
|
{
|
|
m68k_memory_map[i].base = cart.rom + (i<<16);
|
|
m68k_memory_map[i].read8 = NULL;
|
|
m68k_memory_map[i].read16 = NULL;
|
|
zbank_memory_map[i].read = NULL;
|
|
}
|
|
|
|
#if M68K_EMULATE_ADDRESS_ERROR
|
|
/* this game does not work properly on real hardware */
|
|
emulate_address_error = 0;
|
|
#endif
|
|
}
|
|
else if (cart.romsize > 0x400000)
|
|
{
|
|
/* assume SSF2 mapper */
|
|
cart.hw.bankshift = 1;
|
|
cart.hw.time_w = sega_mapper_w;
|
|
}
|
|
|
|
/* default write handler for !TIME signal */
|
|
if (!cart.hw.time_w)
|
|
cart.hw.time_w = default_time_w;
|
|
}
|
|
|
|
/* hardware that need to be reseted on power on */
|
|
void cart_hw_reset()
|
|
{
|
|
int i;
|
|
|
|
/* reset bankshifting */
|
|
if (cart.hw.bankshift)
|
|
{
|
|
for (i=0x00; i<0x40; i++)
|
|
m68k_memory_map[i].base = cart.rom + ((i<<16) & cart.mask);
|
|
}
|
|
|
|
/* Realtec mapper */
|
|
if (cart.hw.realtec & 1)
|
|
{
|
|
/* enable BOOTROM */
|
|
for (i=0; i<8; i++)
|
|
memcpy(cart.rom + 0x900000 + i*0x2000, cart.rom + 0x7e000, 0x2000);
|
|
for (i=0x00; i<0x40; i++)
|
|
m68k_memory_map[i].base = cart.rom + 0x900000;
|
|
cart.hw.realtec |= 2;
|
|
}
|
|
|
|
/* SVP chip */
|
|
if (svp)
|
|
svp_reset();
|
|
|
|
/* Lock-ON */
|
|
switch (config.lock_on)
|
|
{
|
|
case TYPE_GG:
|
|
ggenie_reset();
|
|
break;
|
|
|
|
case TYPE_AR:
|
|
datel_reset(1);
|
|
break;
|
|
|
|
case TYPE_SK:
|
|
if (cart.lock_on)
|
|
{
|
|
/* disable UPMEM chip at $300000-$3fffff */
|
|
for (i=0x30; i<0x40; i++)
|
|
m68k_memory_map[i].base = cart.rom + ((i<<16) & cart.mask);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* save default cartridge slot mapping */
|
|
cart.base = m68k_memory_map[0].base;
|
|
}
|
|
|
|
|
|
/************************************************************
|
|
MAPPER handlers
|
|
*************************************************************/
|
|
|
|
/*
|
|
"official" ROM/RAM switch
|
|
*/
|
|
static void sega_mapper_w(uint32 address, uint32 data)
|
|
{
|
|
uint32 i,slot = (address >> 1) & 7;
|
|
uint8 *src;
|
|
|
|
switch (slot)
|
|
{
|
|
case 0:
|
|
/* ROM/SRAM switch (Phantasy Star IV, Story of Thor/Beyond Oasis, Sonic 3 & Knuckles) */
|
|
if (data & 1)
|
|
{
|
|
/* $200000-$3fffff is mapped to SRAM (only if SRAM exists) */
|
|
if (sram.on)
|
|
{
|
|
for (i=0x20; i<0x40; i++)
|
|
m68k_memory_map[i].base = sram.sram;
|
|
|
|
if (data & 2)
|
|
{
|
|
/* SRAM write disabled */
|
|
for (i=0x20; i<0x40; i++)
|
|
{
|
|
m68k_memory_map[i].write8 = m68k_unused_8_w;
|
|
m68k_memory_map[i].write16 = m68k_unused_16_w;
|
|
zbank_memory_map[i].write = zbank_unused_w;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* SRAM write enabled */
|
|
for (i=0x20; i<0x40; i++)
|
|
{
|
|
m68k_memory_map[i].write8 = NULL;
|
|
m68k_memory_map[i].write16 = NULL;
|
|
zbank_memory_map[i].write = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (cart.lock_on)
|
|
{
|
|
/* enable UPMEM chip at $300000-$3fffff */
|
|
for (i=0x30; i<0x40; i++)
|
|
m68k_memory_map[i].base = (cart.rom + 0x800000) + ((i & 3)<<16);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* ROM enabled */
|
|
for (i=0x20; i<0x40; i++)
|
|
m68k_memory_map[i].base = cart.rom + ((i<<16) & cart.mask);
|
|
|
|
if (cart.lock_on)
|
|
{
|
|
/* enable cartridge ROM at $300000-$3fffff */
|
|
for (i=0x30; i<0x40; i++)
|
|
m68k_memory_map[i].base = cart.rom + ((i<<16) & cart.mask);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
/* ROM Bankswitch (Super Street Fighter 2)
|
|
documented by Bart Trzynadlowski (http://www.trzy.org/files/ssf2.txt)
|
|
*/
|
|
slot = slot << 3; /* 8 x 512k banks */
|
|
src = cart.rom + (data << 19);
|
|
for (i=0; i<8; i++)
|
|
m68k_memory_map[slot++].base = src + (i<<16);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
custom ROM Bankswitch used by pirate "Multi-in-1" carts
|
|
*/
|
|
static void multi_mapper_w(uint32 address, uint32 data)
|
|
{
|
|
int i;
|
|
|
|
cart.hw.bankshift = 1;
|
|
|
|
/* 64 x 64k banks */
|
|
for (i=0; i<64; i++)
|
|
m68k_memory_map[i].base = &cart.rom[((address++) & 0x3f) << 16];
|
|
}
|
|
|
|
/*
|
|
Special ROM Bankswitch used for copy protection
|
|
Used by unlicensed cartridges (Lion King III, Super King Kong 99)
|
|
*/
|
|
static void special_mapper_w(uint32 address, uint32 data)
|
|
{
|
|
/* 1 x 32k bank */
|
|
memcpy(cart.rom + 0x900000, cart.rom + ((data & 0x7f) << 15), 0x8000);
|
|
memcpy(cart.rom + 0x908000, cart.rom + 0x8000, 0x8000);
|
|
m68k_memory_map[0].base = cart.rom + 0x900000;
|
|
}
|
|
|
|
/*
|
|
Realtec ROM Bankswitch (Earth Defend, Balloon Boy & Funny World, Whac-A-Critter)
|
|
(Note: register usage is inverted in TascoDlx documentation)
|
|
*/
|
|
static void realtec_mapper_w(uint32 address, uint32 data)
|
|
{
|
|
switch (address)
|
|
{
|
|
case 0x402000:
|
|
{
|
|
/* number of mapped 64k blocks (the written value is a number of 128k blocks) */
|
|
cart.hw.regs[2] = data << 1;
|
|
return;
|
|
}
|
|
|
|
case 0x404000:
|
|
{
|
|
/* 00000xxx */
|
|
cart.hw.regs[0] = data & 7;
|
|
return;
|
|
}
|
|
|
|
case 0x400000:
|
|
{
|
|
/* 00000yy1 */
|
|
cart.hw.regs[1] = data & 6;
|
|
|
|
/* mapped start address is 00yy xxx0 0000 0000 0000 0000 */
|
|
uint32 base = (cart.hw.regs[0] << 1) | (cart.hw.regs[1] << 3);
|
|
|
|
/* ensure mapped size is not null */
|
|
if (cart.hw.regs[2])
|
|
{
|
|
/* selected blocks are mirrored into the whole cartridge area */
|
|
int i;
|
|
for (i=0x00; i<0x40; i++)
|
|
m68k_memory_map[i].base = &cart.rom[(base + (i % cart.hw.regs[2])) << 16];
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Game no Kanzume Otokuyou ROM Mapper */
|
|
static void seganet_mapper_w(uint32 address, uint32 data)
|
|
{
|
|
if ((address & 0xff) == 0xf1)
|
|
{
|
|
int i;
|
|
if (data & 1)
|
|
{
|
|
/* ROM Write protected */
|
|
for (i=0; i<0x40; i++)
|
|
{
|
|
m68k_memory_map[i].write8 = m68k_unused_8_w;
|
|
m68k_memory_map[i].write16 = m68k_unused_16_w;
|
|
zbank_memory_map[i].write = zbank_unused_w;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* ROM Write enabled */
|
|
for (i=0; i<0x40; i++)
|
|
{
|
|
m68k_memory_map[i].write8 = NULL;
|
|
m68k_memory_map[i].write16 = NULL;
|
|
zbank_memory_map[i].write = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
RADICA ROM Bankswitch (use !TIME)
|
|
*/
|
|
static uint32 radica_mapper_r(uint32 address)
|
|
{
|
|
int i = 0;
|
|
address = (address >> 1);
|
|
|
|
/* 64 x 64k banks */
|
|
for (i = 0; i < 64; i++)
|
|
m68k_memory_map[i].base = &cart.rom[((address++)& 0x3f)<< 16];
|
|
|
|
return 0xff;
|
|
}
|
|
|
|
|
|
/************************************************************
|
|
default !TIME signal handler
|
|
*************************************************************/
|
|
|
|
/* default ROM bankswitch */
|
|
static void default_time_w(uint32 address, uint32 data)
|
|
{
|
|
if ((address & 0xf1) == 0xf1)
|
|
sega_mapper_w(address, data);
|
|
|
|
else if (address < 0xa13040)
|
|
multi_mapper_w(address, data);
|
|
}
|
|
|
|
|
|
/************************************************************
|
|
Internal register handlers
|
|
*************************************************************/
|
|
|
|
static uint32 default_regs_r(uint32 address)
|
|
{
|
|
int i;
|
|
for (i=0; i<4; i++)
|
|
{
|
|
if ((address & cart.hw.mask[i]) == cart.hw.addr[i])
|
|
return cart.hw.regs[i];
|
|
}
|
|
|
|
/* unused */
|
|
return m68k_read_bus_8(address);
|
|
}
|
|
|
|
static void default_regs_w(uint32 address, uint32 data)
|
|
{
|
|
int i;
|
|
for (i=0; i<4; i++)
|
|
{
|
|
if ((address & cart.hw.mask[i]) == cart.hw.addr[i])
|
|
{
|
|
cart.hw.regs[i] = data;
|
|
return;
|
|
}
|
|
}
|
|
m68k_unused_8_w(address, data);
|
|
}
|
|
|
|
/* special register behaviour (Lion King III, Super Donkey Kong 99, Mulan, Pocket Monsters II) */
|
|
static void special_regs_w(uint32 address, uint32 data)
|
|
{
|
|
/* ROM bankswitch */
|
|
if ((address >> 16) > 0x6f)
|
|
{
|
|
special_mapper_w(address, data);
|
|
return;
|
|
}
|
|
|
|
/* write regs */
|
|
default_regs_w(address, data);
|
|
|
|
/* bitswapping (documented by Haze) */
|
|
uint32 temp = cart.hw.regs[0];
|
|
switch (cart.hw.regs[1])
|
|
{
|
|
case 0:
|
|
cart.hw.regs[2] = (temp << 1);
|
|
break;
|
|
|
|
case 1:
|
|
cart.hw.regs[2] = (temp >> 1);
|
|
return;
|
|
|
|
case 2:
|
|
cart.hw.regs[2] = ((temp >> 4) | ((temp & 0x0F) << 4));
|
|
return;
|
|
|
|
default:
|
|
cart.hw.regs[2] = (((temp >> 7) & 0x01) | ((temp >> 5) & 0x02) |
|
|
((temp >> 3) & 0x04) | ((temp >> 1) & 0x08) |
|
|
((temp << 1) & 0x10) | ((temp << 3) & 0x20) |
|
|
((temp << 5) & 0x40) | ((temp << 7) & 0x80));
|
|
return;
|
|
}
|
|
}
|