CoCalc -- md

GitHub Repository: alexbevi/BizHawk
Path: blob/master/genplus-gx/core/cart_hw/md_cart.c
² views
1
/****************************************************************************
2
 *  Genesis Plus
3
 *  Mega Drive cartridge hardware support
4
 *
5
 *  Copyright (C) 2007-2013  Eke-Eke (Genesis Plus GX)
6
 *
7
 *  Many cartridge protections were initially documented by Haze
8
 *  (http://haze.mameworld.info/)
9
 *
10
 *  Realtec mapper was documented by TascoDeluxe
11
 *
12
 *  Redistribution and use of this code or any derivative works are permitted
13
 *  provided that the following conditions are met:
14
 *
15
 *   - Redistributions may not be sold, nor may they be used in a commercial
16
 *     product or activity.
17
 *
18
 *   - Redistributions that are modified from the original source must include the
19
 *     complete source code, including the source code for all components used by a
20
 *     binary built from the modified sources. However, as a special exception, the
21
 *     source code distributed need not include anything that is normally distributed
22
 *     (in either source or binary form) with the major components (compiler, kernel,
23
 *     and so on) of the operating system on which the executable runs, unless that
24
 *     component itself accompanies the executable.
25
 *
26
 *   - Redistributions must reproduce the above copyright notice, this list of
27
 *     conditions and the following disclaimer in the documentation and/or other
28
 *     materials provided with the distribution.
29
 *
30
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
31
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
34
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
35
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
36
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
37
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
38
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40
 *  POSSIBILITY OF SUCH DAMAGE.
41
 *
42
 ****************************************************************************************/
43

44
#include "shared.h"
45
#include "eeprom_i2c.h"
46
#include "eeprom_spi.h"
47
#include "gamepad.h"
48

49
#define CART_CNT (55)
50

51
/* Cart database entry */
52
typedef struct
53
{
54
  uint16 chk_1;       /* header checksum */
55
  uint16 chk_2;       /* real checksum */
56
  uint8 bank_start;   /* first mapped bank in $400000-$7fffff region */
57
  uint8 bank_end;     /* last mapped bank in $400000-$7fffff region */
58
  cart_hw_t cart_hw;  /* hardware description */
59
} md_entry_t;
60

61
/* Function prototypes */
62
static void mapper_sega_w(uint32 data);
63
static void mapper_ssf2_w(uint32 address, uint32 data);
64
static void mapper_sf001_w(uint32 address, uint32 data);
65
static void mapper_sf002_w(uint32 address, uint32 data);
66
static void mapper_sf004_w(uint32 address, uint32 data);
67
static uint32 mapper_sf004_r(uint32 address);
68
static void mapper_t5740_w(uint32 address, uint32 data);
69
static uint32 mapper_t5740_r(uint32 address);
70
static uint32 mapper_smw_64_r(uint32 address);
71
static void mapper_smw_64_w(uint32 address, uint32 data);
72
static void mapper_realtec_w(uint32 address, uint32 data);
73
static void mapper_seganet_w(uint32 address, uint32 data);
74
static void mapper_32k_w(uint32 data);
75
static void mapper_64k_w(uint32 data);
76
static void mapper_64k_multi_w(uint32 address);
77
static uint32 mapper_radica_r(uint32 address);
78
static void default_time_w(uint32 address, uint32 data);
79
static void default_regs_w(uint32 address, uint32 data);
80
static uint32 default_regs_r(uint32 address);
81
static uint32 default_regs_r_16(uint32 address);
82
static uint32 custom_regs_r(uint32 address);
83
static void custom_regs_w(uint32 address, uint32 data);
84
static void custom_alt_regs_w(uint32 address, uint32 data);
85
static uint32 topshooter_r(uint32 address);
86
static void topshooter_w(uint32 address, uint32 data);
87
static uint32 tekken_regs_r(uint32 address);
88
static void tekken_regs_w(uint32 address, uint32 data);
89

90
/* Games that need extra hardware emulation:
91
  - copy protection device
92
  - custom ROM banking device
93
*/
94
static const md_entry_t rom_database[CART_CNT] =
95
{
96
/* Funny World & Balloon Boy */
97
  {0x0000,0x06ab,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},1,0,NULL,NULL,NULL,mapper_realtec_w}},
98
/* Whac-a-Critter */
99
  {0xffff,0xf863,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},1,0,NULL,NULL,NULL,mapper_realtec_w}},
100
/* Earth Defense */
101
  {0xffff,0x44fb,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},1,0,NULL,NULL,NULL,mapper_realtec_w}},
102

103

104
/* RADICA (Volume 1) (bad dump ?) */
105
  {0x0000,0x2326,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,1,mapper_radica_r,NULL,NULL,NULL}},
106
/* RADICA (Volume 1) */
107
  {0x24f4,0xfc84,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,0,mapper_radica_r,NULL,NULL,NULL}},
108
/* RADICA (Volume 2) */
109
  {0x104f,0x32e9,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,0,mapper_radica_r,NULL,NULL,NULL}},
110

111

112
/* Tenchi wo Kurau III: Sangokushi Gaiden - Chinese Fighter */
113
  {0x9490,0x8180,0x40,0x6f,{{0x00,0x00,0x00,0x00},{0xf0000c,0xf0000c,0xf0000c,0xf0000c},{0x400000,0x400004,0x400008,0x40000c},0,1,NULL,NULL,default_regs_r,custom_alt_regs_w}},
114

115

116
/* Top Fighter */
117
  {0x4eb9,0x5d8b,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,custom_regs_w}},
118
/* Soul Edge VS Samurai Spirits  */
119
  {0x00ff,0x5d34,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,custom_regs_w}},
120
/* Mulan */
121
  {0x0404,0x1b40,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,custom_regs_w}},
122
/* Pocket Monsters II */
123
  {0x47f9,0x17e5,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,custom_regs_w}},
124
/* Lion King 3 */
125
  {0x0000,0x507c,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,custom_regs_w}},
126
/* Super King Kong 99 */
127
  {0x0000,0x7d6e,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,custom_regs_w}},
128
/* Gunfight 3-in-1 */
129
  {0x0000,0x6ff8,0x60,0x7f,{{0x00,0x00,0x00,0x00},{0xf00007,0xf00007,0xf00007,0xffffff},{0x600001,0x600003,0x600005,0x000000},0,1,NULL,NULL,default_regs_r,custom_regs_w}}, 
130
/* Pokemon Stadium */
131
  {0x0000,0x843c,0x70,0x7f,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,1,NULL,NULL,NULL,custom_regs_w}},
132

133

134
/* Tekken 3 Special (original dump) (a bootleg version also exists, with patched protection & different boot routine which reads unused !TIME mapped area) */
135
  {0x0000,0xc2f0,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,0,NULL,NULL,tekken_regs_r,tekken_regs_w}},
136

137

138
/* Lion King 2 */
139
  {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}},
140
/* Squirell King */
141
  {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}},
142
/* Tiny Toon Adventures 3 */
143
  {0x2020,0xed9c,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xfffffd,0xfffffd,0xffffff,0xffffff},{0x400000,0x400004,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,default_regs_w}},
144
/* Lian Huan Pao - Barver Battle Saga (registers accessed by Z80, related to sound engine ?) */
145
  {0x30b9,0x1c2a,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xfffffd,0xfffffd,0xffffff,0xffffff},{0x400000,0x400004,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,default_regs_w}},
146
/* Shui Hu Zhuan (registers accessed by Z80, related to sound engine ?) */
147
  {0x6001,0x0211,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xfffffd,0xfffffd,0xffffff,0xffffff},{0x400000,0x400004,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,default_regs_w}},
148
/* Feng Shen Ying Jie Chuan (registers accessed by Z80, related to sound engine ?) */
149
  {0xffff,0x5d98,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xfffffd,0xfffffd,0xffffff,0xffffff},{0x400000,0x400004,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,default_regs_w}},
150
/* (*) Shui Hu - Feng Yun Zhuan (patched ROM, unused registers) */
151
  {0x3332,0x872b,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xfffffd,0xfffffd,0xffffff,0xffffff},{0x400000,0x400004,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,default_regs_w}},
152

153

154
/* (*) Chao Ji Da Fu Weng (patched ROM, various words witten to register, long word also read from $7E0000, unknown banking hardware ?) */
155
  {0xa697,0xa697,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x000000,0x000000,0x000000},0,0,NULL,NULL,NULL,default_regs_w}},
156

157
/* (*) Aq Renkan Awa (patched ROM, ON/OFF bit sequence is written to register, unknown banking hardware ?) */
158
  {0x8104,0x0517,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400001,0x000000,0x000000,0x000000},0,0,NULL,NULL,NULL,default_regs_w}},
159

160

161
/* (*) Tun Shi Tian Di III (patched ROM, unused register) */
162
  {0x0000,0x9c5e,0x40,0x40,{{0xab,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400046,0x000000,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,NULL}},
163

164

165
/* Ma Jiang Qing Ren - Ji Ma Jiang Zhi */
166
  {0x0000,0x7037,0x40,0x40,{{0x90,0xd3,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x401000,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,NULL}},
167
/* Super Majon Club */
168
  {0x0000,0x3b95,0x40,0x40,{{0x90,0xd3,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x401000,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,NULL}},
169
/* Feng Kuang Tao Hua Yuan (original version from Creaton Softec Inc) (a bootleg version also exists with patched protection and minor title screen variations) */
170
  {0x0000,0x9dc4,0x40,0x40,{{0x90,0xd3,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x401000,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,NULL}},
171

172

173
/* (*) Jiu Ji Ma Jiang II - Ye Yan Bian (patched ROM, using expected register value - $0f - crashes the game) (uses 16-bits reads) */
174
  {0x0c44,0xba81,0x40,0x40,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x400006},0,0,NULL,NULL,default_regs_r_16,NULL}},
175
/* 16 Zhang Ma Jiang (uses 16-bits reads) */
176
  {0xfb40,0x4bed,0x40,0x40,{{0x00,0xaa,0x00,0xf0},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x400002,0x000000,0x400006},0,0,NULL,NULL,default_regs_r_16,NULL}},
177
/* 16 Tiles Mahjong II (uses 16-bits reads) */
178
  {0xffff,0x0903,0x40,0x40,{{0x00,0x00,0xc9,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x400004,0x000000},0,0,NULL,NULL,default_regs_r_16,NULL}},
179
/* Thunderbolt II (uses 16-bits reads) */
180
  {0x0000,0x1585,0x40,0x40,{{0x55,0x0f,0xaa,0xf0},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r_16,NULL}},
181

182

183
/* Super Bubble Bobble */
184
  {0x0000,0x16cd,0x40,0x40,{{0x55,0x0f,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x000000,0x000000},0,0,NULL,NULL,default_regs_r,NULL}},
185
/* Tenchi wo Kurau II - The Battle of Red Cliffs (Unl) */
186
  {0x0000,0xed61,0x40,0x40,{{0x55,0x0f,0xaa,0xf0},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
187
/* Huan Le Tao Qi Shu - Smart Mouse */
188
  {0x0000,0x1a28,0x40,0x40,{{0x55,0x0f,0xaa,0xf0},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
189
/* (*) Hei Tao 2 - Super Big 2 (patched ROM, unused registers) */
190
  {0x0000,0x5843,0x40,0x40,{{0x55,0x0f,0xaa,0xf0},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
191
/* Mighty Morphin Power Rangers - The Fighting Edition */
192
  {0x0000,0x2288,0x40,0x40,{{0x55,0x0f,0xc9,0x18},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
193
/* Elf Wor */
194
  {0x0080,0x3dba,0x40,0x40,{{0x55,0x0f,0xc9,0x18},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
195
/* Ya-Se Chuanshuo */
196
  {0xffff,0xd472,0x40,0x40,{{0x63,0x98,0xc9,0x18},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
197
/* 777 Casino (For first one, 0x55 works as well. Other values are never used so they are guessed from on other unlicensed games using similar mapper) */
198
  {0x0000,0xf8d9,0x40,0x40,{{0x63,0x98,0xc9,0x18},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
199
/* Wu Kong Wai Zhuan (original) (a bootleg version also exists, with patched protection & modified SRAM test routine ?) */
200
  {0x0000,0x19ff,0x40,0x40,{{0x63,0x98,0xc9,0x18},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
201
/* Soul Blade */
202
  {0x0000,0x0c5b,0x40,0x40,{{0x63,0x98,0xc9,0xf0},{0xffffff,0xffffff,0xffffff,0xffffff},{0x400000,0x400002,0x400004,0x400006},0,0,NULL,NULL,default_regs_r,NULL}},
203

204

205
/* King of Fighter 98 */
206
  {0x0000,0xd0a0,0x48,0x4f,{{0x00,0x00,0xaa,0xf0},{0xffffff,0xffffff,0xfc0000,0xfc0000},{0x000000,0x000000,0x480000,0x4c0000},0,0,NULL,NULL,default_regs_r,NULL}},
207

208

209
/* Rockman X3 (bootleg version ? two last register returned values are ignored, note that 0xaa/0x18 would work as well) */
210
  {0x0000,0x9d0e,0x40,0x40,{{0x0c,0x00,0xc9,0xf0},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0x000000,0x400004,0x400006},0,0,default_regs_r,NULL,default_regs_r,NULL}},
211

212

213
/* (*) Dragon Ball Final Bout  (patched ROM, in original code, different switches occurs depending on returned value $00-$0f) */
214
  {0xc65a,0xc65a,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0x000000,0x000000,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
215
/* (*) Yang Jia Jiang - Yang Warrior Family (patched ROM, register value unused) */
216
  {0x0000,0x96b0,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0x000000,0x000000,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
217
/* Super Mario 2 1998 */
218
  {0xffff,0x0474,0x00,0x00,{{0x0a,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0x000000,0x000000,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
219
/* Super Mario World */
220
  {0x2020,0xb4eb,0x00,0x00,{{0x1c,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0x000000,0x000000,0x000000},0,0,default_regs_r,NULL,NULL,NULL}},
221

222

223
/* King of Fighter 99 */
224
  {0x0000,0x021e,0x00,0x00,{{0x00,0x01,0x1f,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0xa13002,0xa1303e,0x000000},0,0,custom_regs_r,default_regs_w,NULL,NULL}},
225
/* Pocket Monster */
226
  {0xd6fc,0x1eb1,0x00,0x00,{{0x00,0x01,0x1f,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0xa13002,0xa1303e,0x000000},0,0,custom_regs_r,default_regs_w,NULL,NULL}},
227
/* Pocket Monster (bootleg version ? two last register returned values are ignored & first register test has been modified) */
228
  {0xd6fc,0x6319,0x00,0x00,{{0x14,0x01,0x1f,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0xa13002,0xa1303e,0x000000},0,0,default_regs_r,m68k_unused_8_w,NULL,NULL}},
229
/* A Bug's Life (bootleg version ? two last register returned values are ignored & first register test has been modified ?) */
230
  {0x7f7f,0x2aad,0x00,0x00,{{0x28,0x01,0x1f,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0xa13000,0xa13002,0xa1303e,0x000000},0,0,default_regs_r,m68k_unused_8_w,NULL,NULL}},
231

232

233
/* Game no Kanzume Otokuyou */
234
  {0x0000,0xf9d1,0x00,0x00,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,0,NULL,mapper_seganet_w,NULL,NULL}},
235

236

237
/* Top Shooter (arcade hardware) */
238
  {0xffff,0x3632,0x20,0x20,{{0x00,0x00,0x00,0x00},{0xffffff,0xffffff,0xffffff,0xffffff},{0x000000,0x000000,0x000000,0x000000},0,0,NULL,NULL,topshooter_r,topshooter_w}}
239
};
240

241

242
/************************************************************
243
          Cart Hardware initialization 
244
*************************************************************/
245

246
void md_cart_init(void)
247
{
248
  int i;
249

250
  /***************************************************************************************************************
251
                CARTRIDGE ROM MIRRORING                                                                                   
252
   ***************************************************************************************************************
253
  
254
    MD Cartridge area is mapped to $000000-$3fffff:
255

256
      -> when accessing ROM, 68k address lines A1 to A21 can be used by the internal cartridge hardware to decode
257
         full 4MB address range.
258
      -> depending on ROM total size and additional decoding hardware, some address lines might be ignored,
259
         resulting in ROM mirroring.
260

261
    Cartridges can use either 8-bits (x2) or 16-bits (x1, x2) Mask ROM chips, each chip size is a factor of 2 bytes:
262

263
      -> two 8-bits chips are equivalent to one 16-bits chip, no specific address decoding is required, needed
264
         address lines are simply connected to each chip, upper address lines are ignored and data lines are
265
         connected appropriately to each chip (D0-D7 to one chip, D8-D15 to the other one).
266
         ROM is generally mirrored each N bytes where N=2^(k+1) is the total ROM size (ROM1+ROM2,ROM1+ROM2,...)
267

268
      -> one single 16-bits chip do not need specific address decoding, address lines are simply connected
269
         depending on the ROM size, upper address lines being ignored.
270
         ROM is generally mirrored each N bytes where N=2^k is the size of the ROM chip (ROM1,ROM1,ROM1,...)
271

272
      -> two 16-bits chips of the same size are equivalent to one chip of double size, address decoding generally
273
         is the same except that specific hardware is used (one address line is generally used for chip selection,
274
         lower ones being used to address the chips and upper ones being ignored).
275
         ROM is generally mirrored each N bytes where N=2^(k+1) is the total ROM size (ROM1,ROM2,ROM1,ROM2,...)
276

277
      -> two 16-bits chips with different size are mapped differently. Address decoding is done the same way as
278
         above (one address line used for chip selection) but the ignored & required address lines differ from
279
         one chip to another, which makes ROM mirroring different.
280
         ROM2 size is generally half of ROM1 size and upper half ignored (ROM1,ROM2,XXXX,ROM1,ROM2,XXXX,...)
281

282
      From the emulator point of view, we only need to distinguish 2 cases:
283

284
      1/ total ROM size is a factor of 2: ROM is mirrored each 2^k bytes.
285

286
      2/ total ROM size is not a factor of 2: ROM is padded up to 2^k then mirrored each 2^k bytes.
287

288
  ******************************************************************************************************************/
289
  
290
  /* calculate nearest size with factor of 2 */
291
  unsigned int size = 0x10000;
292
  while (cart.romsize > size)
293
    size <<= 1;
294

295
  /* Sonic & Knuckles */
296
  if (strstr(rominfo.international,"SONIC & KNUCKLES"))
297
  {
298
    /* disable ROM mirroring at $200000-$3fffff (normally mapped to external cartridge) */
299
    size = 0x400000;
300
  }
301

302
  /* total ROM size is not a factor of 2  */
303
  /* TODO: handle all possible ROM configurations using cartridge database */
304
  if (cart.romsize < size)
305
  {
306
    if (size < MAXROMSIZE)
307
    {
308
      /* ROM is padded up to 2^k bytes */
309
      memset(cart.rom + cart.romsize, 0xff, size - cart.romsize);
310
    }
311
    else
312
    {
313
      /* ROM is padded up to max ROM size */
314
      memset(cart.rom + cart.romsize, 0xff, MAXROMSIZE - cart.romsize);
315
    }
316
  }
317

318
  /* ROM is mirrored each 2^k bytes */
319
  cart.mask = size - 1;
320

321
  /**********************************************
322
          DEFAULT CARTRIDGE MAPPING 
323
  ***********************************************/
324
  for (i=0; i<0x40; i++)
325
  {
326
    /* cartridge ROM */
327
    m68k.memory_map[i].base     = cart.rom + ((i<<16) & cart.mask);
328
    m68k.memory_map[i].read8    = NULL;
329
    m68k.memory_map[i].read16   = NULL;
330
    m68k.memory_map[i].write8   = m68k_unused_8_w;
331
    m68k.memory_map[i].write16  = m68k_unused_16_w;
332
    zbank_memory_map[i].read    = NULL;
333
    zbank_memory_map[i].write   = zbank_unused_w;
334
  }
335

336
  for (i=0x40; i<0x80; i++)
337
  {
338
    /* unused area */
339
    m68k.memory_map[i].base     = cart.rom + (i<<16);
340
    m68k.memory_map[i].read8    = m68k_read_bus_8;
341
    m68k.memory_map[i].read16   = m68k_read_bus_16;
342
    m68k.memory_map[i].write8   = m68k_unused_8_w;
343
    m68k.memory_map[i].write16  = m68k_unused_16_w;
344
    zbank_memory_map[i].read    = zbank_unused_r;
345
    zbank_memory_map[i].write   = zbank_unused_w;
346
  }
347

348
  /* support for Quackshot REV 01 (real) dump */
349
  if (strstr(rominfo.product,"00004054-01") && (cart.romsize == 0x80000))
350
  {
351
    /* $000000-$0fffff: first 256K mirrored (A18 not connected to ROM chip, A19 not decoded) */
352
    for (i=0x00; i<0x10; i++)
353
    {
354
      /* $200000-$3fffff: mirror of $000000-$1fffff (A21 not decoded) */
355
      m68k.memory_map[i].base = m68k.memory_map[i + 0x20].base = cart.rom + ((i & 0x03) << 16);
356
    }
357

358
    /* $100000-$1fffff: second 256K mirrored (A20 connected to ROM chip A18) */
359
    for (i=0x10; i<0x20; i++)
360
    {
361
      /* $200000-$3fffff: mirror of $000000-$1fffff (A21 not decoded) */
362
      m68k.memory_map[i].base = m68k.memory_map[i + 0x20].base = cart.rom + 0x40000 + ((i & 0x03) << 16);
363
    }
364
  }
365

366
  /**********************************************
367
          BACKUP MEMORY 
368
  ***********************************************/
369
  sram_init();
370
  eeprom_i2c_init();
371

372
  /* external SRAM */
373
  if (sram.on && !sram.custom)
374
  {
375
    /* disabled on startup if ROM is mapped in same area */
376
    if (cart.romsize <= sram.start)
377
    {
378
      /* initialize m68k bus handlers */
379
      m68k.memory_map[sram.start >> 16].base    = sram.sram;
380
      m68k.memory_map[sram.start >> 16].read8   = sram_read_byte;
381
      m68k.memory_map[sram.start >> 16].read16  = sram_read_word;
382
      m68k.memory_map[sram.start >> 16].write8  = sram_write_byte;
383
      m68k.memory_map[sram.start >> 16].write16 = sram_write_word;
384
      zbank_memory_map[sram.start >> 16].read   = sram_read_byte;
385
      zbank_memory_map[sram.start >> 16].write  = sram_write_byte;
386
    }
387
  }
388

389
  /**********************************************
390
          SVP CHIP 
391
  ***********************************************/
392
  svp = NULL;
393
  if (strstr(rominfo.international,"Virtua Racing"))
394
  {
395
    svp_init();
396

397
    m68k.memory_map[0x30].base    = svp->dram;
398
    m68k.memory_map[0x30].read16  = NULL;
399
    m68k.memory_map[0x30].write16 = svp_write_dram;
400

401
    m68k.memory_map[0x31].base    = svp->dram + 0x10000;
402
    m68k.memory_map[0x31].read16  = NULL;
403
    m68k.memory_map[0x31].write16 = svp_write_dram;
404

405
    m68k.memory_map[0x39].read16  = svp_read_cell_1;
406
    m68k.memory_map[0x3a].read16  = svp_read_cell_2;
407
  }
408

409
  /**********************************************
410
          J-CART 
411
  ***********************************************/
412
  cart.special = 0;
413
  if ((strstr(rominfo.product,"00000000") && (rominfo.checksum == 0x168b)) || /* Super Skidmarks, Micro Machines Military */
414
      (strstr(rominfo.product,"00000000") && (rominfo.checksum == 0x165e)) || /* Pete Sampras Tennis (1991), Micro Machines 96 */
415
      (strstr(rominfo.product,"00000000") && (rominfo.checksum == 0xcee0)) || /* Micro Machines Military (bad) */
416
      (strstr(rominfo.product,"00000000") && (rominfo.checksum == 0x2c41)) || /* Micro Machines 96 (bad) */
417
      (strstr(rominfo.product,"XXXXXXXX") && (rominfo.checksum == 0xdf39)) || /* Sampras Tennis 96 */
418
      (strstr(rominfo.product,"T-123456") && (rominfo.checksum == 0x1eae)) || /* Sampras Tennis 96 */
419
      (strstr(rominfo.product,"T-120066") && (rominfo.checksum == 0x16a4)) || /* Pete Sampras Tennis (1994)*/
420
       strstr(rominfo.product,"T-120096"))                                     /* Micro Machines 2 */
421
  {
422
    if (cart.romsize <= 0x380000)  /* just to be sure (checksum might not be enough) */
423
    {
424
      cart.special |= HW_J_CART;
425

426
      /* force port 1 setting */
427
      if (input.system[1] != SYSTEM_WAYPLAY)
428
      {
429
        old_system[1] = input.system[1];
430
        input.system[1] = SYSTEM_MD_GAMEPAD;
431
      }
432

433
      /* extra connectors mapped at $38xxxx or $3Fxxxx */
434
      m68k.memory_map[0x38].read16  = jcart_read;
435
      m68k.memory_map[0x38].write16 = jcart_write;
436
      m68k.memory_map[0x3f].read16  = jcart_read;
437
      m68k.memory_map[0x3f].write16 = jcart_write;
438
    }
439
  }
440

441
  /**********************************************
442
          LOCK-ON 
443
  ***********************************************/
444
  
445
  /* clear existing patches */
446
  ggenie_shutdown();
447
  areplay_shutdown();
448

449
  /* initialize extra hardware */
450
  switch (config.lock_on)
451
  {
452
    case TYPE_GG:
453
    {
454
      ggenie_init();
455
      break;
456
    }
457

458
    case TYPE_AR:
459
    {
460
      areplay_init();
461
      break;
462
    }
463

464
    case TYPE_SK:
465
    {
466
      FILE *f;
467
      
468
      /* store S&K ROM above cartridge ROM (and before backup memory) */
469
      if (cart.romsize > 0x600000) break;
470

471
      /* load Sonic & Knuckles ROM (2 MB) */
472
      f = fopen(SK_ROM,"rb");
473
      if (!f) break;
474
      for (i=0; i<0x200000; i+=0x1000)
475
      {
476
        fread(cart.rom + 0x600000 + i, 0x1000, 1, f);
477
      }
478
      fclose(f);
479

480
      /* load Sonic 2 UPMEM ROM (256 KB) */
481
      f = fopen(SK_UPMEM,"rb");
482
      if (!f) break;
483
      for (i=0; i<0x40000; i+=0x1000)
484
      {
485
        fread(cart.rom + 0x900000 + i, 0x1000, 1, f);
486
      }
487
      fclose(f);
488
          
489
#ifdef LSB_FIRST
490
      for (i=0; i<0x200000; i+=2)
491
      {
492
        /* Byteswap ROM */
493
        uint8 temp = cart.rom[i + 0x600000];
494
        cart.rom[i + 0x600000] = cart.rom[i + 0x600000 + 1];
495
        cart.rom[i + 0x600000 + 1] = temp;
496
      }
497
      
498
      for (i=0; i<0x40000; i+=2)
499
      {
500
        /* Byteswap ROM */
501
        uint8 temp = cart.rom[i + 0x900000];
502
        cart.rom[i + 0x900000] = cart.rom[i + 0x900000 + 1];
503
        cart.rom[i + 0x900000 + 1] = temp;
504
      }
505
#endif
506

507
      /* $000000-$1FFFFF is mapped to S&K ROM */
508
      for (i=0x00; i<0x20; i++)
509
      {
510
        m68k.memory_map[i].base = cart.rom + 0x600000 + (i << 16);
511
      }
512

513
      cart.special |= HW_LOCK_ON;
514
      break;
515
    }
516

517
    default:
518
    {
519
      break;
520
    }
521
  }
522

523
  /**********************************************
524
        CARTRIDGE EXTRA HARDWARE
525
  ***********************************************/
526
  memset(&cart.hw, 0, sizeof(cart.hw));
527

528
  /* search for game into database */
529
  for (i=0; i<CART_CNT; i++)
530
  {
531
    /* known cart found ! */
532
    if ((rominfo.checksum == rom_database[i].chk_1) &&
533
        (rominfo.realchecksum == rom_database[i].chk_2))
534
    {
535
      int j = rom_database[i].bank_start;
536

537
      /* retrieve hardware information */
538
      memcpy(&cart.hw, &(rom_database[i].cart_hw), sizeof(cart.hw));
539

540
      /* initialize memory handlers for $400000-$7FFFFF region */
541
      while (j <= rom_database[i].bank_end)
542
      {
543
        if (cart.hw.regs_r)
544
        {
545
          m68k.memory_map[j].read8    = cart.hw.regs_r;
546
          m68k.memory_map[j].read16   = cart.hw.regs_r;
547
          zbank_memory_map[j].read    = cart.hw.regs_r;
548
        }
549
        if (cart.hw.regs_w)
550
        {
551
          m68k.memory_map[j].write8   = cart.hw.regs_w;
552
          m68k.memory_map[j].write16  = cart.hw.regs_w;
553
          zbank_memory_map[j].write   = cart.hw.regs_w;
554
        }
555
        j++;
556
      }
557

558
      /* leave loop */
559
      i = CART_CNT;
560
    }
561
  }
562

563
  /* Realtec mapper */
564
  if (cart.hw.realtec)
565
  {
566
    /* 8k BOOT ROM */
567
    for (i=0; i<8; i++)
568
    {
569
      memcpy(cart.rom + 0x900000 + i*0x2000, cart.rom + 0x7e000, 0x2000);
570
    }
571

572
    /* BOOT ROM is mapped to $000000-$3FFFFF */
573
    for (i=0x00; i<0x40; i++)
574
    {
575
      m68k.memory_map[i].base = cart.rom + 0x900000;
576
    }
577
  }
578

579
  /* detect specific mappers */
580
  if (strstr(rominfo.domestic,"SUPER STREET FIGHTER2"))
581
  {
582
    /* SSF2 mapper */
583
    cart.hw.bankshift = 1;
584

585
    /* specific !TIME handler */
586
    cart.hw.time_w = mapper_ssf2_w;
587
  }
588
  else if (strstr(rominfo.product,"T-5740"))
589
  {
590
    /* T-5740XX-XX mapper */
591
    cart.hw.bankshift = 1;
592
    m68k.memory_map[0x01].read8 = mapper_t5740_r;
593
    zbank_memory_map[0x01].read = mapper_t5740_r;
594

595
    /* specific !TIME handlers */
596
    cart.hw.time_w = mapper_t5740_w;
597
    cart.hw.time_r = eeprom_spi_read;
598

599
    /* initialize SPI EEPROM board */
600
    eeprom_spi_init();
601
  }
602
  else if (strstr(rominfo.ROMType,"SF") && strstr(rominfo.product,"001"))
603
  {
604
    /* SF-001 mapper */
605
    m68k.memory_map[0x00].write8 = mapper_sf001_w;
606
    m68k.memory_map[0x00].write16 = mapper_sf001_w;
607
    zbank_memory_map[0x00].write = mapper_sf001_w;
608

609
    /* no !TIME handler */
610
    cart.hw.time_w = m68k_unused_8_w;
611
  }
612
  else if (strstr(rominfo.ROMType,"SF") && strstr(rominfo.product,"002"))
613
  {
614
    /* SF-002 mapper */
615
    m68k.memory_map[0x00].write8 = mapper_sf002_w;
616
    m68k.memory_map[0x00].write16 = mapper_sf002_w;
617
    zbank_memory_map[0x00].write = mapper_sf002_w;
618

619
    /* no !TIME handler */
620
    cart.hw.time_w = m68k_unused_8_w;
621
  }
622
  else if (strstr(rominfo.ROMType,"SF") && strstr(rominfo.product,"004"))
623
  {
624
    /* SF-004 mapper */
625
    m68k.memory_map[0x00].write8 = mapper_sf004_w;
626
    m68k.memory_map[0x00].write16 = mapper_sf004_w;
627
    zbank_memory_map[0x00].write = mapper_sf004_w;
628

629
    /* specific !TIME handlers */
630
    cart.hw.time_r = mapper_sf004_r;
631
    cart.hw.time_w = m68k_unused_8_w;
632

633
    /* first 256K ROM bank is initially mirrored into $000000-$1FFFFF */
634
    for (i=0x00; i<0x20; i++)
635
    {
636
      m68k.memory_map[i].base = cart.rom + ((i & 0x03) << 16);
637
    }
638

639
    /* 32K static RAM is mapped to $200000-$2FFFFF (disabled on startup) */
640
    for (i=0x20; i<0x30; i++)
641
    {
642
      m68k.memory_map[i].base    = sram.sram;
643
      m68k.memory_map[i].read8   = m68k_read_bus_8;
644
      m68k.memory_map[i].read16  = m68k_read_bus_16;
645
      m68k.memory_map[i].write8  = m68k_unused_8_w;
646
      m68k.memory_map[i].write16 = m68k_unused_16_w;
647
      zbank_memory_map[i].read   = m68k_read_bus_8;
648
      zbank_memory_map[i].write  = zbank_unused_w;
649
    }
650

651
    /* $300000-$3FFFFF is not mapped */
652
    for (i=0x30; i<0x40; i++)
653
    {
654
      m68k.memory_map[i].read8   = m68k_read_bus_8;
655
      m68k.memory_map[i].read16  = m68k_read_bus_16;
656
      m68k.memory_map[i].write8  = m68k_unused_8_w;
657
      m68k.memory_map[i].write16 = m68k_unused_16_w;
658
      zbank_memory_map[i].read   = m68k_read_bus_8;
659
      zbank_memory_map[i].write  = zbank_unused_w;
660
    }
661
  }
662
  else if ((*(uint16 *)(cart.rom + 0x08) == 0x6000) && (*(uint16 *)(cart.rom + 0x0a) == 0x01f6) && (rominfo.realchecksum == 0xf894))
663
  {
664
    /* Super Mario World 64 (unlicensed) mapper */
665
    for (i=0x08; i<0x10; i++)
666
    {
667
      /* lower 512KB mirrored */
668
      m68k.memory_map[i].base = cart.rom + ((i & 7) << 16);
669
    }
670

671
    for (i=0x10; i<0x40; i++)
672
    {
673
      /* unused area */
674
      m68k.memory_map[i].read8   = m68k_read_bus_8;
675
      m68k.memory_map[i].read16  = m68k_read_bus_16;
676
      m68k.memory_map[i].write8  = m68k_unused_8_w;
677
      m68k.memory_map[i].write16 = m68k_unused_16_w;
678
      zbank_memory_map[i].read   = m68k_read_bus_8;
679
      zbank_memory_map[i].write  = zbank_unused_w;
680
    }
681

682
    for (i=0x60; i<0x70; i++)
683
    {
684
      /* custom hardware */
685
      m68k.memory_map[i].base   = cart.rom + 0x0f0000;
686
      m68k.memory_map[i].read8  = ((i & 0x07) < 0x04) ? NULL : mapper_smw_64_r;
687
      m68k.memory_map[i].read16  = ((i & 0x07) < 0x04) ? NULL : mapper_smw_64_r;
688
      m68k.memory_map[i].write8 = mapper_smw_64_w;
689
      m68k.memory_map[i].write16 = mapper_smw_64_w;
690
      zbank_memory_map[i].read  = ((i & 0x07) < 0x04) ? NULL : mapper_smw_64_r;
691
      zbank_memory_map[i].write = mapper_smw_64_w;
692
    }
693
  }
694
  else if (cart.romsize > 0x400000)
695
  {
696
    /* assume linear ROM mapper without bankswitching (max. 10MB) */
697
    for (i=0x40; i<0xA0; i++)
698
    {
699
      m68k.memory_map[i].base   = cart.rom + (i<<16);
700
      m68k.memory_map[i].read8  = NULL;
701
      m68k.memory_map[i].read16 = NULL;
702
      zbank_memory_map[i].read  = NULL;
703
    }
704
  }
705

706
  /* default write handler for !TIME range ($A130xx)*/
707
  if (!cart.hw.time_w)
708
  {
709
    cart.hw.time_w = default_time_w;
710
  }
711
}
712

713
/* hardware that need to be reseted on power on */
714
void md_cart_reset(int hard_reset)
715
{
716
  int i;
717

718
  /* reset cartridge mapping */
719
  if (cart.hw.bankshift)
720
  {
721
    for (i=0x00; i<0x40; i++)
722
    {
723
      m68k.memory_map[i].base = cart.rom + ((i<<16) & cart.mask);
724
    }
725
  }
726
  
727
  /* SVP chip */
728
  if (svp)
729
  {
730
    svp_reset();
731
  }
732

733
  /* Lock-ON */
734
  switch (config.lock_on)
735
  {
736
    case TYPE_GG:
737
    {
738
      ggenie_reset(hard_reset);
739
      break;
740
    }
741

742
    case TYPE_AR:
743
    {
744
      areplay_reset(hard_reset);
745
      break;
746
    }
747

748
    case TYPE_SK:
749
    {
750
      if (cart.special & HW_LOCK_ON)
751
      {
752
        /* disable UPMEM chip at $300000-$3fffff */
753
        for (i=0x30; i<0x40; i++)
754
        {
755
          m68k.memory_map[i].base = cart.rom + ((i<<16) & cart.mask);
756
        }
757
      }
758
      break;
759
    }
760

761
    default:
762
    {
763
      break;
764
    }
765
  }
766
}
767

768
int md_cart_context_save(uint8 *state)
769
{
770
  int i;
771
  int bufferptr = 0;
772
  uint8 *base;
773

774
  /* cartridge mapping */
775
  for (i=0; i<0x40; i++)
776
  {
777
    /* get base address */
778
    base = m68k.memory_map[i].base;
779
      
780
    if (base == sram.sram)
781
    {
782
      /* SRAM */
783
      state[bufferptr++] = 0xff;
784
    }
785
    else
786
    {
787
      /* ROM */
788
      state[bufferptr++] = ((base - cart.rom) >> 16) & 0xff;
789
    }
790
  }
791

792
  /* hardware registers */
793
  save_param(cart.hw.regs, sizeof(cart.hw.regs));
794

795
  /* SVP */
796
  if (svp)
797
  {
798
    save_param(svp->iram_rom, 0x800);
799
    save_param(svp->dram,sizeof(svp->dram));
800
    save_param(&svp->ssp1601,sizeof(ssp1601_t));
801
  }
802

803
  return bufferptr;
804
}
805

806
int md_cart_context_load(uint8 *state)
807
{
808
  int i;
809
  int bufferptr = 0;
810
  uint8 offset;
811

812
  /* cartridge mapping */
813
  for (i=0; i<0x40; i++)
814
  {
815
    /* get offset */
816
    offset = state[bufferptr++];
817

818
    if (offset == 0xff)
819
    {
820
      /* SRAM */
821
      m68k.memory_map[i].base     = sram.sram;
822
      m68k.memory_map[i].read8    = sram_read_byte;
823
      m68k.memory_map[i].read16   = sram_read_word;
824
      m68k.memory_map[i].write8   = sram_write_byte;
825
      m68k.memory_map[i].write16  = sram_write_word;
826
      zbank_memory_map[i].read    = sram_read_byte;
827
      zbank_memory_map[i].write   = sram_write_byte;
828

829
    }
830
    else
831
    {
832
      /* check if SRAM was mapped there before loading state */
833
      if (m68k.memory_map[i].base == sram.sram)
834
      {
835
        m68k.memory_map[i].read8    = NULL;
836
        m68k.memory_map[i].read16   = NULL;
837
        m68k.memory_map[i].write8   = m68k_unused_8_w;
838
        m68k.memory_map[i].write16  = m68k_unused_16_w;
839
        zbank_memory_map[i].read    = NULL;
840
        zbank_memory_map[i].write   = zbank_unused_w;
841
      }
842

843
      /* ROM */
844
      m68k.memory_map[i].base = cart.rom + (offset << 16);
845
    }
846
  }
847

848
  /* hardware registers */
849
  load_param(cart.hw.regs, sizeof(cart.hw.regs));
850

851
  /* SVP */
852
  if (svp)
853
  {
854
    load_param(svp->iram_rom, 0x800);
855
    load_param(svp->dram,sizeof(svp->dram));
856
    load_param(&svp->ssp1601,sizeof(ssp1601_t));
857
  }
858

859
  return bufferptr;
860
}
861

862
/************************************************************
863
          MAPPER handlers 
864
*************************************************************/
865

866
/* 
867
  "official" ROM/SRAM bankswitch (Phantasy Star IV, Story of Thor/Beyond Oasis, Sonic 3 & Knuckles)
868
*/
869
static void mapper_sega_w(uint32 data)
870
{
871
  int i;
872

873
  if (data & 1)
874
  {
875
    if (sram.on)
876
    {
877
      /* Backup RAM mapped to $200000-$20ffff (normally mirrored up to $3fffff but this breaks Sonic Megamix and no game need it) */
878
      m68k.memory_map[0x20].base    = sram.sram;
879
      m68k.memory_map[0x20].read8   = sram_read_byte;
880
      m68k.memory_map[0x20].read16  = sram_read_word;
881
      zbank_memory_map[0x20].read   = sram_read_byte;
882

883
      /* Backup RAM write protection */
884
      if (data & 2)
885
      {
886
        m68k.memory_map[0x20].write8  = m68k_unused_8_w;
887
        m68k.memory_map[0x20].write16 = m68k_unused_16_w;
888
        zbank_memory_map[0x20].write  = zbank_unused_w;
889
      }
890
      else
891
      {
892
        m68k.memory_map[0x20].write8  = sram_write_byte;
893
        m68k.memory_map[0x20].write16 = sram_write_word;
894
        zbank_memory_map[0x20].write  = sram_write_byte;
895
      }
896
    }
897

898
    /* S&K lock-on chip */
899
    if ((cart.special & HW_LOCK_ON) && (config.lock_on == TYPE_SK))
900
    {
901
      /* S2K upmem chip mapped to $300000-$3fffff (256K mirrored) */
902
      for (i=0x30; i<0x40; i++)
903
      {
904
        m68k.memory_map[i].base = (cart.rom + 0x900000) + ((i & 3) << 16);
905
      }
906
    }
907
  }
908
  else
909
  {
910
    /* cartridge ROM mapped to $200000-$3fffff */
911
    for (i=0x20; i<0x40; i++)
912
    {
913
      m68k.memory_map[i].base     = cart.rom + ((i<<16) & cart.mask);
914
      m68k.memory_map[i].read8    = NULL;
915
      m68k.memory_map[i].read16   = NULL;
916
      zbank_memory_map[i].read    = NULL;
917
      m68k.memory_map[i].write8   = m68k_unused_8_w;
918
      m68k.memory_map[i].write16  = m68k_unused_16_w;
919
      zbank_memory_map[i].write   = zbank_unused_w;
920
    }
921
  }
922
}
923

924
/*
925
   Super Street Fighter 2 ROM bankswitch
926
   documented by Bart Trzynadlowski (http://www.trzy.org/files/ssf2.txt) 
927
*/
928
static void mapper_ssf2_w(uint32 address, uint32 data)
929
{
930
  /* 8 x 512k banks */
931
  address = (address << 2) & 0x38;
932
  
933
  /* bank 0 remains unchanged */
934
  if (address)
935
  {
936
    uint32 i;
937
    uint8 *src = cart.rom + (data << 19);
938

939
    for (i=0; i<8; i++)
940
    {
941
      m68k.memory_map[address++].base = src + (i<<16);
942
    }
943
  }
944
}
945

946
/* 
947
  SF-001 mapper
948
*/
949
static void mapper_sf001_w(uint32 address, uint32 data)
950
{
951
  switch ((address >> 8) & 0xf)
952
  {
953
    case 0xe:
954
    {
955
      int i;
956

957
      /* bit 6: enable / disable cartridge access  */
958
      if (data & 0x40)
959
      {
960
        /* $000000-$3FFFFF is not mapped */
961
        for (i=0x00; i<0x40; i++)
962
        {
963
          m68k.memory_map[i].base     = cart.rom + (i << 16);
964
          m68k.memory_map[i].read8    = m68k_read_bus_8;
965
          m68k.memory_map[i].read16   = m68k_read_bus_16;
966
          m68k.memory_map[i].write8   = (i > 0x00) ? m68k_unused_8_w : mapper_sf001_w;
967
          m68k.memory_map[i].write16  = (i > 0x00) ? m68k_unused_16_w : mapper_sf001_w;
968
          zbank_memory_map[i].read    = zbank_unused_r;
969
          zbank_memory_map[i].write   = (i > 0x00) ? m68k_unused_8_w : mapper_sf001_w;
970
        }
971
      }
972

973
      /* bit 7: enable / disable SRAM & ROM bankswitching */
974
      else if (data & 0x80)
975
      {
976
        /* 256K ROM bank #15 mapped to $000000-$03FFFF  */
977
        for (i=0x00; i<0x04; i++)
978
        {
979
          m68k.memory_map[i].base     = cart.rom + ((0x38 + i) << 16);
980
          m68k.memory_map[i].read8    = NULL;
981
          m68k.memory_map[i].read16   = NULL;
982
          zbank_memory_map[i].read    = NULL;
983
        }
984

985
        /* 256K ROM banks #2 to #15 mapped to $040000-$3BFFFF (last revision) or $040000-$3FFFFF (older revisions) */
986
        for (i=0x04; i<(sram.start >> 16); i++)
987
        {
988
          m68k.memory_map[i].base     = cart.rom + (i << 16);
989
          m68k.memory_map[i].read8    = NULL;
990
          m68k.memory_map[i].read16   = NULL;
991
          zbank_memory_map[i].read    = NULL;
992
        }
993

994
        /* 32K static RAM mirrored into $3C0000-$3FFFFF (odd bytes only) (last revision only) */
995
        while (i<0x40)
996
        {
997
          m68k.memory_map[i].base     = sram.sram;
998
          m68k.memory_map[i].read8    = sram_read_byte;
999
          m68k.memory_map[i].read16   = sram_read_word;
1000
          m68k.memory_map[i].write8   = sram_write_byte;
1001
          m68k.memory_map[i].write16  = sram_write_word;
1002
          zbank_memory_map[i].read    = sram_read_byte;
1003
          zbank_memory_map[i].write   = sram_write_byte;
1004
          i++;
1005
        }
1006
      }
1007
      else
1008
      {
1009
        /* 256K ROM banks #1 to #16 mapped to $000000-$3FFFFF (default) */
1010
        for (i=0x00; i<0x40; i++)
1011
        {
1012
          m68k.memory_map[i].base     = cart.rom + (i << 16);
1013
          m68k.memory_map[i].read8    = NULL;
1014
          m68k.memory_map[i].read16   = NULL;
1015
          m68k.memory_map[i].write8   = (i > 0x00) ? m68k_unused_8_w : mapper_sf001_w;
1016
          m68k.memory_map[i].write16  = (i > 0x00) ? m68k_unused_16_w : mapper_sf001_w;
1017
          zbank_memory_map[i].read    = NULL;
1018
          zbank_memory_map[i].write   = (i > 0x00) ? m68k_unused_8_w : mapper_sf001_w;
1019
        }
1020
      }
1021

1022
      /* bit 5: lock bankswitch hardware when set */
1023
      if (data & 0x20)
1024
      {
1025
        /* disable bankswitch hardware access until hard reset */
1026
        m68k.memory_map[0x00].write8  = m68k_unused_8_w;
1027
        m68k.memory_map[0x00].write16 = m68k_unused_16_w;
1028
        zbank_memory_map[0x00].write  = m68k_unused_8_w;
1029
      }
1030

1031
      return;
1032
    }
1033

1034
    default:
1035
    {
1036
      m68k_unused_8_w(address, data);
1037
      return;
1038
    }
1039
  }
1040
}
1041

1042
/* 
1043
  SF-002 mapper
1044
*/
1045
static void mapper_sf002_w(uint32 address, uint32 data)
1046
{
1047
  int i;
1048
  if (data & 0x80)
1049
  {
1050
    /* $000000-$1BFFFF mapped to $200000-$3BFFFF */
1051
    for (i=0x20; i<0x3C; i++)
1052
    {
1053
      m68k.memory_map[i].base = cart.rom + ((i & 0x1F) << 16);
1054
    }
1055
  }
1056
  else
1057
  {
1058
    /* $200000-$3BFFFF mapped to $200000-$3BFFFF */
1059
    for (i=0x20; i<0x3C; i++)
1060
    {
1061
      m68k.memory_map[i].base = cart.rom + (i << 16);
1062
    }
1063
  }
1064
}
1065

1066
/* 
1067
  SF-004 mapper
1068
*/
1069
static void mapper_sf004_w(uint32 address, uint32 data)
1070
{
1071
  int i;
1072
  switch ((address >> 8) & 0xf)
1073
  {
1074
    case 0xd:
1075
    {
1076
      /* bit 7: enable/disable static RAM access */
1077
      if (data & 0x80)
1078
      {
1079
        /* 32KB static RAM mirrored into $200000-$2FFFFF (odd bytes only) */
1080
        for (i=0x20; i<0x30; i++)
1081
        {
1082
          m68k.memory_map[i].read8   = sram_read_byte;
1083
          m68k.memory_map[i].read16  = sram_read_word;
1084
          m68k.memory_map[i].write8  = sram_write_byte;
1085
          m68k.memory_map[i].write16 = sram_write_word;
1086
          zbank_memory_map[i].read   = sram_read_byte;
1087
          zbank_memory_map[i].write  = sram_write_byte;
1088
        }
1089
      }
1090
      else
1091
      {
1092
        /* 32KB static RAM disabled at $200000-$2FFFFF */
1093
        for (i=0x20; i<0x30; i++)
1094
        {
1095
          m68k.memory_map[i].read8   = m68k_read_bus_8;
1096
          m68k.memory_map[i].read16  = m68k_read_bus_16;
1097
          m68k.memory_map[i].write8  = m68k_unused_8_w;
1098
          m68k.memory_map[i].write16 = m68k_unused_16_w;
1099
          zbank_memory_map[i].read   = m68k_read_bus_8;
1100
          zbank_memory_map[i].write  = m68k_unused_8_w;
1101
        }
1102
      }
1103

1104
      return;
1105
    }
1106

1107
    case 0x0e:
1108
    {
1109
      /* bit 5: enable / disable cartridge ROM access */
1110
      if (data & 0x20)
1111
      {
1112
        /* $000000-$1FFFFF is not mapped */
1113
        for (i=0x00; i<0x20; i++)
1114
        {
1115
          m68k.memory_map[i].read8  = m68k_read_bus_8;
1116
          m68k.memory_map[i].read16 = m68k_read_bus_16;
1117
          zbank_memory_map[i].read  = m68k_read_bus_8;
1118
        }
1119
      }
1120

1121
      /* bit 6: enable / disable first page mirroring */
1122
      else if (data & 0x40)
1123
      {
1124
        /* first page ROM bank */
1125
        uint8 base = (m68k.memory_map[0x00].base - cart.rom) >> 16;
1126

1127
        /* 5 x 256K ROM banks mapped to $000000-$13FFFF, starting from first page ROM bank */
1128
        for (i=0x00; i<0x14; i++)
1129
        {
1130
          m68k.memory_map[i].base   = cart.rom + (((base + i) & 0x1f) << 16);
1131
          m68k.memory_map[i].read8  = NULL;
1132
          m68k.memory_map[i].read16 = NULL;
1133
          zbank_memory_map[i].read  = NULL;
1134
        }
1135

1136
        /* $140000-$1FFFFF is not mapped */
1137
        for (i=0x14; i<0x20; i++)
1138
        {
1139
          m68k.memory_map[i].read8  = m68k_read_bus_8;
1140
          m68k.memory_map[i].read16 = m68k_read_bus_16;
1141
          zbank_memory_map[i].read  = m68k_read_bus_8;
1142
        }
1143
      }
1144
      else
1145
      {
1146
        /* first page 256K ROM bank mirrored into $000000-$1FFFFF */
1147
        for (i=0x00; i<0x20; i++)
1148
        {
1149
          m68k.memory_map[i].base = m68k.memory_map[0].base + ((i & 0x03) << 16);
1150
          m68k.memory_map[i].read8  = NULL;
1151
          m68k.memory_map[i].read16 = NULL;
1152
          zbank_memory_map[i].read  = NULL;
1153
        }
1154
      }
1155

1156
      /* bit 7: lock ROM bankswitching hardware when cleared */
1157
      if (!(data & 0x80))
1158
      {
1159
        /* disable bankswitch hardware access */
1160
        m68k.memory_map[0x00].write8 = m68k_unused_8_w;
1161
        m68k.memory_map[0x00].write16 = m68k_unused_16_w;
1162
        zbank_memory_map[0x00].write = m68k_unused_8_w;
1163
      }
1164

1165
      return;
1166
    }
1167

1168
    case 0x0f:
1169
    {
1170
      /* bits 6-4: select first page ROM bank (8 x 256K ROM banks) */
1171
      uint8 base = ((data >> 4) & 7) << 2;
1172

1173
      if (m68k.memory_map[0].base == m68k.memory_map[4].base)
1174
      {
1175
        /* selected 256K ROM bank mirrored into $000000-$1FFFFF */
1176
        for (i=0x00; i<0x20; i++)
1177
        {
1178
          m68k.memory_map[i].base = cart.rom + ((base + (i & 0x03)) << 16);
1179
        }
1180
      }
1181
      else
1182
      {
1183
        /* 5 x 256K ROM banks mapped to $000000-$13FFFF, starting from selected bank */
1184
        for (i=0x00; i<0x14; i++)
1185
        {
1186
          m68k.memory_map[i].base = cart.rom + (((base + i) & 0x1f) << 16);
1187
        }
1188
      }
1189

1190
      return;
1191
    }
1192

1193
    default:
1194
    {
1195
      m68k_unused_8_w(address, data);
1196
      return;
1197
    }
1198
  }
1199
}
1200

1201
static uint32 mapper_sf004_r(uint32 address)
1202
{
1203
  /* return first page 256K bank index ($00,$10,$20,...,$70) */
1204
  return (((m68k.memory_map[0x00].base - cart.rom) >> 18) << 4);
1205
}
1206

1207
/* 
1208
  T-5740xx-xx mapper
1209
*/
1210
static void mapper_t5740_w(uint32 address, uint32 data)
1211
{
1212
  int i;
1213
  uint8 *base;
1214

1215
  switch (address & 0xff)
1216
  {
1217
    case 0x01: /* mode register */
1218
    {
1219
      /* bits 7-4: unused ?                           */
1220
      /* bit 3: enable SPI registers access ?         */
1221
      /* bit 2: not used ?                            */
1222
      /* bit 1: enable bankswitch registers access ?  */
1223
      /* bit 0: always set, enable hardware access ?  */
1224
      return;
1225
    }
1226

1227
    case 0x03: /* page #5 register */
1228
    {
1229
      /* map any of 16 x 512K ROM banks to $280000-$2FFFFF */
1230
      base = cart.rom + ((data & 0x0f) << 19);
1231
      for (i=0x28; i<0x30; i++)
1232
      {
1233
        m68k.memory_map[i].base = base + ((i & 0x07) << 16);
1234
      }
1235
      return;
1236
    }
1237

1238
    case 0x05: /* page #6 register */
1239
    {
1240
      /* map any of 16 x 512K ROM banks to $300000-$37FFFF */
1241
      base = cart.rom + ((data & 0x0f) << 19);
1242
      for (i=0x30; i<0x38; i++)
1243
      {
1244
        m68k.memory_map[i].base = base + ((i & 0x07) << 16);
1245
      }
1246
      return;
1247
    }
1248

1249
    case 0x07: /* page #7 register */
1250
    {
1251
      /* map any of 16 x 512K ROM banks to $380000-$3FFFFF */
1252
      base = cart.rom + ((data & 0x0f) << 19);
1253
      for (i=0x38; i<0x40; i++)
1254
      {
1255
        m68k.memory_map[i].base = base + ((i & 0x07) << 16);
1256
      }
1257
      return;
1258
    }
1259

1260
    case 0x09: /* serial EEPROM SPI board support */
1261
    {
1262
      eeprom_spi_write(data);
1263
      return;
1264
    }
1265

1266
    default:
1267
    {
1268
      /* unknown registers */
1269
      m68k_unused_8_w(address, data);
1270
      return;
1271
    }
1272
  }
1273
}
1274

1275
static uint32 mapper_t5740_r(uint32 address)
1276
{
1277
  /* By default, first 32K of each eight 512K pages mapped in $000000-$3FFFFF are mirrored in the 512K page   */
1278
  /* mirroring is disabled/enabled when a specific number of words is being read from specific ROM addresses  */
1279
  /* Exact decoding isn't known but mirrored data is expected on startup when reading a few times from $181xx */
1280
  /* this area doesn't seem to be accessed as byte later so it seems safe to always return mirrored data here */
1281
  if ((address & 0xff00) == 0x8100)
1282
  {
1283
    return READ_BYTE(cart.rom , (address & 0x7fff));
1284
  }
1285

1286
  return READ_BYTE(cart.rom, address);
1287
}
1288

1289
/* 
1290
  Super Mario World 64 (unlicensed) mapper
1291
*/
1292
static void mapper_smw_64_w(uint32 address, uint32 data)
1293
{
1294
  /* internal registers (saved to backup RAM) */
1295
  switch ((address >> 16) & 0x07)
1296
  {
1297
    case 0x00:  /* $60xxxx */
1298
    {
1299
      if (address & 2)
1300
      {
1301
        /* $600003 data write mode ? */
1302
        switch (sram.sram[0x00] & 0x07)
1303
        {
1304
          case 0x00:
1305
          {
1306
            /* update value returned at $660001-$660003 */
1307
            sram.sram[0x06] = ((sram.sram[0x06] ^ sram.sram[0x01]) ^ data) & 0xFE;
1308
            break;
1309
          }
1310

1311
          case 0x01:
1312
          {
1313
            /* update value returned at $660005-$660007 */
1314
            sram.sram[0x07] = data & 0xFE;
1315
            break;
1316
          }
1317

1318
          case 0x07:
1319
          {
1320
            /* update selected ROM bank (upper 512K) mapped at $610000-$61ffff */
1321
            m68k.memory_map[0x61].base = m68k.memory_map[0x69].base = cart.rom + 0x080000 + ((data & 0x1c) << 14);
1322
            break;
1323
          }
1324

1325
          default:
1326
          {
1327
            /* unknown mode */
1328
            break;
1329
          }
1330
        }
1331

1332
        /* $600003 data register */
1333
        sram.sram[0x01] = data;
1334
      }
1335
      else
1336
      {
1337
        /* $600001 ctrl register */
1338
        sram.sram[0x00] = data;
1339
      }
1340
      return;
1341
    }
1342

1343
    case 0x01:  /* $61xxxx */
1344
    {
1345
      if (address & 2)
1346
      {
1347
        /* $610003 ctrl register */
1348
        sram.sram[0x02] = data;
1349
      }
1350
      return;
1351
    }
1352

1353
    case 0x04:  /* $64xxxx */
1354
    {
1355
      if (address & 2)
1356
      {
1357
        /* $640003 data register */
1358
        sram.sram[0x04] = data;
1359
      }
1360
      else
1361
      {
1362
        /* $640001 data register */
1363
        sram.sram[0x03] = data;
1364
      }
1365
      return;
1366
    }
1367

1368
    case 0x06:  /* $66xxxx */
1369
    {
1370
      /* unknown */
1371
      return;
1372
    }
1373

1374
    case 0x07:  /* $67xxxx */
1375
    {
1376
      if (!(address & 2))
1377
      {
1378
        /* $670001 ctrl register */
1379
        sram.sram[0x05] = data;
1380

1381
        /* upper 512K ROM bank-switching enabled ? */
1382
        if (sram.sram[0x02] & 0x80)
1383
        {
1384
          /* update selected ROM bank (upper 512K) mapped at $600000-$60ffff */
1385
          m68k.memory_map[0x60].base = m68k.memory_map[0x68].base = cart.rom + 0x080000 + ((data & 0x1c) << 14);
1386
        }
1387
      }
1388
      return;
1389
    }
1390

1391
    default:  /* not used */
1392
    {
1393
      m68k_unused_8_w(address, data);
1394
      return;
1395
    }
1396
  }
1397
}
1398

1399
static uint32 mapper_smw_64_r(uint32 address)
1400
{
1401
  /* internal registers (saved to backup RAM) */
1402
  switch ((address >> 16) & 0x03)
1403
  {
1404
    case 0x02:  /* $66xxxx */
1405
    {
1406
      switch ((address >> 1) & 7)
1407
      {
1408
        case 0x00:  return sram.sram[0x06];
1409
        case 0x01:  return sram.sram[0x06] + 1;
1410
        case 0x02:  return sram.sram[0x07];
1411
        case 0x03:  return sram.sram[0x07] + 1;
1412
        case 0x04:  return sram.sram[0x08];
1413
        case 0x05:  return sram.sram[0x08] + 1;
1414
        case 0x06:  return sram.sram[0x08] + 2;
1415
        case 0x07:  return sram.sram[0x08] + 3;
1416
      }
1417
    }
1418

1419
    case 0x03:  /* $67xxxx */
1420
    {
1421
      uint8 data = (sram.sram[0x02] & 0x80) ? ((sram.sram[0x05] & 0x40) ? (sram.sram[0x03] & sram.sram[0x04]) : (sram.sram[0x03] ^ 0xFF)) : 0x00;
1422

1423
      if (address & 2)
1424
      {
1425
        /* $670003 */
1426
        data &= 0x7f;
1427
      }
1428
      else
1429
      {
1430
        /* $66xxxx data registers update */
1431
        if (sram.sram[0x05] & 0x80)
1432
        {
1433
          if (sram.sram[0x05] & 0x20)
1434
          {
1435
            /* update $660009-$66000f data register */
1436
            sram.sram[0x08] = (sram.sram[0x04] << 2) & 0xFC;
1437
          }
1438
          else
1439
          {
1440
            /* update $660001-$660003 data register */
1441
            sram.sram[0x06] = (sram.sram[0x01] ^ (sram.sram[0x03] << 1)) & 0xFE;
1442
          }
1443
        }
1444
      }
1445

1446
      return data;
1447
    }
1448

1449
    default:  /* 64xxxx-$65xxxx */
1450
    {
1451
      return 0x00;
1452
    }
1453
  }
1454
}
1455

1456
/* 
1457
  Realtec ROM bankswitch (Earth Defend, Balloon Boy & Funny World, Whac-A-Critter)
1458
  (Note: register usage is inverted in TascoDlx documentation)
1459
*/
1460
static void mapper_realtec_w(uint32 address, uint32 data)
1461
{
1462
  switch (address)
1463
  {
1464
    case 0x402000:  
1465
    {
1466
      /* number of mapped 64k blocks (the written value is a number of 128k blocks) */
1467
      cart.hw.regs[2] = data << 1;
1468
      return;
1469
    }
1470

1471
    case 0x404000:
1472
    {
1473
      /* 00000xxx */
1474
      cart.hw.regs[0] = data & 7;
1475
      return;
1476
    }
1477

1478
    case 0x400000:  
1479
    {
1480
      /* 00000yy1 */
1481
      cart.hw.regs[1] = data & 6;
1482

1483
      /* ensure mapped size is not null */
1484
      if (cart.hw.regs[2])
1485
      {
1486
        /* mapped start address is 00yy xxx0 0000 0000 0000 0000 */
1487
        uint32 base = (cart.hw.regs[0] << 1) | (cart.hw.regs[1] << 3);
1488

1489
        /* selected blocks are mirrored into the whole cartridge area */
1490
        int i;
1491
        for (i=0x00; i<0x40; i++)
1492
        {
1493
          m68k.memory_map[i].base = &cart.rom[(base + (i % cart.hw.regs[2])) << 16];
1494
        }
1495
      }
1496
      return;
1497
    }
1498
  }
1499
}
1500

1501
/* Game no Kanzume Otokuyou ROM Mapper */
1502
static void mapper_seganet_w(uint32 address, uint32 data)
1503
{
1504
  if ((address & 0xff) == 0xf1)
1505
  {
1506
    int i;
1507
    if (data & 1)
1508
    {
1509
      /* ROM Write protected */
1510
      for (i=0; i<0x40; i++)
1511
      {
1512
        m68k.memory_map[i].write8   = m68k_unused_8_w;
1513
        m68k.memory_map[i].write16  = m68k_unused_16_w;
1514
        zbank_memory_map[i].write   = zbank_unused_w;
1515
      }
1516
    }
1517
    else
1518
    {
1519
      /* ROM Write enabled */
1520
      for (i=0; i<0x40; i++)
1521
      {
1522
        m68k.memory_map[i].write8   = NULL;
1523
        m68k.memory_map[i].write16  = NULL;
1524
        zbank_memory_map[i].write   = NULL;
1525
      }
1526
    }
1527
  }
1528
}
1529

1530
/* 
1531
  Custom ROM Bankswitch used in Soul Edge VS Samurai Spirits, Top Fighter, Mulan, Pocket Monsters II, Lion King 3, Super King Kong 99, Pokemon Stadium
1532
*/
1533
static void mapper_32k_w(uint32 data)
1534
{
1535
  int i;
1536
  
1537
  /* 64 x 32k banks */
1538
  if (data)
1539
  {
1540
    for (i=0; i<0x10; i++)
1541
    {
1542
      /* Remap to unused ROM area  */
1543
      m68k.memory_map[i].base = &cart.rom[0x400000 + (i << 16)];
1544

1545
      /* address = address OR (value << 15) */
1546
      memcpy(m68k.memory_map[i].base, cart.rom + ((i << 16) | (data & 0x3f) << 15), 0x8000);
1547
      memcpy(m68k.memory_map[i].base + 0x8000, cart.rom + ((i << 16) | ((data | 1) & 0x3f) << 15), 0x8000);
1548
    }
1549
  }
1550
  else
1551
  {
1552
    /* reset default $000000-$0FFFFF mapping */
1553
    for (i=0; i<16; i++)
1554
    {
1555
      m68k.memory_map[i].base = &cart.rom[i << 16];
1556
    }
1557
  }
1558
}
1559

1560
/* 
1561
  Custom ROM Bankswitch used in Chinese Fighter III
1562
*/
1563
static void mapper_64k_w(uint32 data)
1564
{
1565
  int i;
1566

1567
  /* 16 x 64k banks */
1568
  if (data)
1569
  {
1570
    /* bank is mapped at $000000-$0FFFFF */
1571
    for (i=0; i<16; i++)
1572
    {
1573
      m68k.memory_map[i].base = &cart.rom[(data & 0xf) << 16];
1574
    }
1575
  }
1576
  else
1577
  {
1578
    /* reset default $000000-$0FFFFF mapping */
1579
    for (i=0; i<16; i++)
1580
    {
1581
      m68k.memory_map[i].base = &cart.rom[(i & 0xf) << 16];
1582
    }
1583
  }
1584
}
1585

1586
/* 
1587
  Custom ROM Bankswitch used in pirate "Multi-in-1" cartridges, A Bug's Life, King of Fighter 99, Pocket Monster, Rockman X3
1588
 */
1589
static void mapper_64k_multi_w(uint32 address)
1590
{
1591
  int i;
1592

1593
  /* 64 x 64k banks */
1594
  for (i=0; i<64; i++)
1595
  {
1596
    m68k.memory_map[i].base = &cart.rom[((address++) & 0x3f) << 16];
1597
  }
1598
}
1599

1600
/*
1601
  Custom ROM Bankswitch used in RADICA cartridges
1602
*/
1603
static uint32 mapper_radica_r(uint32 address)
1604
{
1605
  int i = 0;
1606
  address = (address >> 1);
1607
  
1608
  /* 64 x 64k banks */
1609
  for (i = 0; i < 64; i++)
1610
  {
1611
    m68k.memory_map[i].base = &cart.rom[((address++)& 0x3f)<< 16];
1612
  }
1613

1614
  return 0xffff;
1615
}
1616

1617

1618
/************************************************************
1619
          default !TIME signal handler 
1620
*************************************************************/
1621

1622
static void default_time_w(uint32 address, uint32 data)
1623
{
1624
  if (address < 0xa13040)
1625
  {
1626
    /* unlicensed cartridges mapper (default) */
1627
    mapper_64k_multi_w(address);
1628
    return;
1629
  }
1630

1631
  /* official cartridges mapper (default) */
1632
  mapper_sega_w(data);
1633
}
1634

1635

1636
/************************************************************
1637
          Internal register handlers
1638
*************************************************************/
1639

1640
static uint32 default_regs_r(uint32 address)
1641
{
1642
  int i;
1643
  for (i=0; i<4; i++)
1644
  {
1645
    if ((address & cart.hw.mask[i]) == cart.hw.addr[i])
1646
    {
1647
      return cart.hw.regs[i];
1648
    }
1649
  }
1650
  return m68k_read_bus_8(address);
1651
}
1652

1653
static uint32 default_regs_r_16(uint32 address)
1654
{
1655
  int i;
1656
  for (i=0; i<4; i++)
1657
  {
1658
    if ((address & cart.hw.mask[i]) == cart.hw.addr[i])
1659
    {
1660
      return (cart.hw.regs[i] << 8);
1661
    }
1662
  }
1663
  return m68k_read_bus_16(address);
1664
}
1665

1666
static void default_regs_w(uint32 address, uint32 data)
1667
{
1668
  int i;
1669
  for (i=0; i<4; i++)
1670
  {
1671
    if ((address & cart.hw.mask[i]) == cart.hw.addr[i])
1672
    {
1673
      cart.hw.regs[i] = data;
1674
      return;
1675
    }
1676
  }
1677
  m68k_unused_8_w(address, data);
1678
}
1679

1680
/* basic register shifting hardware (Bug's Life, Pocket Monster) */
1681
static uint32 custom_regs_r(uint32 address)
1682
{
1683
  int i;
1684
  for (i=0; i<4; i++)
1685
  {
1686
    if ((address & cart.hw.mask[i]) == cart.hw.addr[i])
1687
    {
1688
      return cart.hw.regs[i] >> 1;
1689
    }
1690
  }
1691

1692
  return m68k_read_bus_8(address);
1693
}
1694

1695
/* custom register hardware (Top Fighter, Lion King III, Super Donkey Kong  99, Mulan, Pocket Monsters II, Pokemon Stadium) */
1696
static void custom_regs_w(uint32 address, uint32 data)
1697
{
1698
  uint8 temp;
1699
  
1700
  /* ROM bankswitch */
1701
  if ((address >> 16) > 0x6f)
1702
  {
1703
    mapper_32k_w(data);
1704
    return;
1705
  }
1706

1707
  /* write register */
1708
  default_regs_w(address, data);
1709

1710
  /* bitswapping */
1711
  temp = cart.hw.regs[0];
1712
  switch (cart.hw.regs[1] & 3)
1713
  {
1714
    case 0:
1715
      cart.hw.regs[2] = (temp << 1);
1716
      break;
1717

1718
    case 1:
1719
      cart.hw.regs[2] = (temp >> 1);
1720
      return;
1721

1722
    case 2:
1723
      cart.hw.regs[2] = ((temp >> 4) | ((temp & 0x0F) << 4));
1724
      return;
1725

1726
    default:
1727
      cart.hw.regs[2] = (((temp >> 7) & 0x01) | ((temp >> 5) & 0x02) |
1728
                         ((temp >> 3) & 0x04) | ((temp >> 1) & 0x08) |
1729
                         ((temp << 1) & 0x10) | ((temp << 3) & 0x20) |
1730
                         ((temp << 5) & 0x40) | ((temp << 7) & 0x80));
1731
      return;
1732
  }
1733
}
1734

1735
/* alternate custom register hardware (Chinese Fighters III) */
1736
static void custom_alt_regs_w(uint32 address, uint32 data)
1737
{
1738
  /* ROM bankswitch */
1739
  if ((address >> 16) > 0x5f)
1740
  {
1741
    mapper_64k_w(data);
1742
    return;
1743
  }
1744

1745
  /* write regs */
1746
  default_regs_w(address, data);
1747
}
1748

1749

1750
/* "Tekken 3 Special" custom register hardware */
1751
static uint32 tekken_regs_r(uint32 address)
1752
{
1753
  /* data output */
1754
  if ((address & 0x0e) == 0x02)
1755
  {
1756
    /* maybe depends on mode bits ? */
1757
    return (cart.hw.regs[0] - 1);
1758
  }
1759

1760
  return m68k_read_bus_16(address);
1761
}
1762

1763
static void tekken_regs_w(uint32 address, uint32 data)
1764
{
1765
  switch (address & 0x0e)
1766
  {
1767
    case 0x00:
1768
    {
1769
      /* data output reset ? (game writes $FF before & after protection check) */
1770
      cart.hw.regs[0]= 0x00;
1771
      break;
1772
    }
1773
  
1774
    case 0x02:
1775
    {
1776
      /* read only ? */
1777
      break;
1778
    }
1779
  
1780
    case 0x0c:
1781
    {
1782
      /* data output mode bit 0 ? (game writes $01) */
1783
      break;
1784
    }
1785
  
1786
    case 0x0e:
1787
    {
1788
      /* data output mode bit 1 ? (never written by game) */
1789
      break;
1790
    }
1791
  
1792
    default:
1793
    {
1794
      /* data input (only connected to D0 ?)*/
1795
      if (data & 1)
1796
      {
1797
        /* 4-bit hardware register ($400004 corresponds to bit0, $400006 to bit1, etc) */
1798
        cart.hw.regs[0] |= 1 << (((address - 0x04) >> 1) & 3);
1799
      }
1800
      break;
1801
    }
1802
  }
1803
}
1804

1805
/* "Top Shooter" arcade board hardware */
1806
static uint32 topshooter_r(uint32 address)
1807
{
1808
  if (address < 0x202000)
1809
  {
1810
    uint8 temp = 0xff;
1811

1812
    switch (address & 0xff)
1813
    {
1814
      case 0x43:
1815
      {
1816
        if (input.pad[0] & INPUT_A)     temp &= ~0x80; /* Shoot */
1817
        if (input.pad[0] & INPUT_B)     temp &= ~0x10; /* Bet */
1818
        if (input.pad[0] & INPUT_START) temp &= ~0x20; /* Start */
1819
        break;
1820
      }
1821

1822
      case 0x45:  /* ??? (DOWN) & Service Mode (UP) */
1823
      {
1824
        if (input.pad[0] & INPUT_UP)    temp &= ~0x08; /* Service Mode */
1825
        if (input.pad[0] & INPUT_DOWN)  temp &= ~0x10; /* ???, used in service menu to select next option */
1826
        break;
1827
      }
1828

1829
      case 0x47:
1830
      {
1831
        if (input.pad[0] & INPUT_RIGHT) temp &= ~0x03; /* Insert 10 coins */
1832
        break;
1833
      }
1834

1835
      case 0x49:
1836
      {
1837
        if (input.pad[0] & INPUT_LEFT)  temp &= ~0x03; /* Clear coins */
1838
        if (input.pad[0] & INPUT_C)     temp &= ~0x01; /* Insert XXX coins */
1839
        break;
1840
      }
1841

1842
      case 0x51:
1843
      {
1844
        temp = 0xA5;
1845
        break;
1846
      }
1847

1848
      default:
1849
      {
1850
        temp = m68k_read_bus_8(address);
1851
        break;
1852
      }
1853
    }
1854
    return temp;
1855
  }
1856

1857
  return READ_BYTE(sram.sram , address & 0xffff);
1858
}
1859

1860
static void topshooter_w(uint32 address, uint32 data)
1861
{
1862
  if (address >= 0x202000)
1863
  {
1864
    WRITE_BYTE(sram.sram , address & 0xffff, data);
1865
    return;
1866
  }
1867

1868
  m68k_unused_8_w(address, data);
1869
}
1870

1871

1872
/* Sega Channel hardware (not emulated) */
1873
/* 
1874

1875
$A13004: BUSY ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 
1876

1877
Unused read16 00A13004 (00005B54)
1878
Unused read16 00A13004 (00005B70)
1879
Unused read16 00A13006 (00005B7C)
1880

1881
Unused read16 00A13004 (00005BC4)
1882
Unused read16 00A13004 (00005BDA)
1883

1884
Unused write16 00A13032 = 0004 (00005706)
1885
Unused write16 00A130F0 = 0000 (0000570E)
1886

1887
Unused write16 00A130F0 = 0000 (0000463E)
1888
Unused write16 00A130F2 = 0001 (00004646)
1889
Unused write16 00A130F4 = 0002 (0000464E)
1890
Unused write16 00A130F6 = 0003 (00004656)
1891
Unused write16 00A130F8 = 0004 (0000465E)
1892
Unused write16 00A130FA = 0005 (00004666)
1893

1894
Unused write16 00A13032 = 0004 (00005706)
1895
Unused write16 00A13032 = 0104 (0000579E)
1896

1897
Unused write16 00380000 = ACDC (00005718)
1898
Unused write16 00380002 = 0000 (00005722)
1899
Unused read16 00380000 (0000572C)
1900
Unused write16 00A13032 = 0104 (0000579E)
1901
Unused write16 00300000 = ACDC (000057B2)
1902
Unused write16 00380000 = 0000 (000057BC)
1903
Unused read16 00300000 (000057C6)
1904

1905
static uint32 sega_channel_r(uint32 address)
1906
{
1907
  return m68k_read_bus_16(address);;
1908
}
1909

1910
static void sega_channel_w(uint32 address, uint32 data)
1911
{
1912
  m68k_unused_16_w(address, data);
1913
}
1914
*/
1915

1916
Product

Resources

Company
