[fceu.git] / boards / 164.c

/* FCE Ultra - NES/Famicom Emulator
 *
 * Copyright notice for this file:
 *  Copyright (C) 2002 Xodnizel 2006 CaH4e3
 *
 * 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
 *
 * It seems that 162/163/164 mappers are the same mapper with just different
 * mapper modes enabled or disabled in software or hardware, need more nanjing
 * carts
 */

#include "mapinc.h"

static uint8 laststrobe, trigger;
static uint8 reg[8];
static uint8 *WRAM=NULL;
static uint32 WRAMSIZE;

static void(*WSync)(void);

static SFORMAT StateRegs[]=
{
  {&laststrobe, 1, "STB"},
  {&trigger, 1, "TRG"},
  {reg, 8, "REGS"},
  {0}
};

/*
const EEPROM_interface eeprom_interface. =
{
	9,				   // address bits 9
	8,				   // data bits    8
	"*110",			   // read         1 10 aaaaaaaaa
	"*101",			   // write        1 01 aaaaaaaaa dddddddd
.	"*10000xxxxxxx",   // lock         1 00 00xxxxxxx
	"*10011xxxxxxx",   // unlock       1 00 11xxxxxxx
	1,
	5
};

static const EEPROM_interface *intf;

static int serial_count = 0;
static u8  serial_buffer[SERIAL_BUFFER_LENGTH];

static int eeprom_data_bits;
static int eeprom_clock_count;
static int eeprom_read_address;
static u8  *eeprom_data;

static int latch = 0;
static int locked = 1;
static int sending = 0;
static int reset_line = ASSERT_LINE;
static int clock_line = ASSERT_LINE;
static int reset_delay;

void EEPROM_Init(u8 *data, u8 bit)
{
	eeprom_data = data;
	if(bit == 8)
		intf = &eeprom_interface_93C46_8;
	else
		intf = &eeprom_interface_93C46_16;
}

u8 *EEPROM_GetData()
{
	return eeprom_data;
}

static int EEPROM_command_match(const char *buf, const char *cmd, int len)
{
	if ( cmd == 0 )	return 0;
	if ( len == 0 )	return 0;

	for (;len>0;)
	{
		char b = *buf;
		char c = *cmd;

		if ((b==0) || (c==0))
			return (b==c);

		switch ( c )
		{
		case '0':
		case '1':
			if (b != c)	return 0;
		case 'X':
		case 'x':
			buf++;
			len--;
			cmd++;
			break;

		case '*':
			c = cmd[1];
			switch( c )
			{
			case '0':
			case '1':
				if (b == c)	{	cmd++;			}
				else		{	buf++;	len--;	}
				break;
			default:	return 0;
			}
		}
	}
	return (*cmd==0);
}

static void EEPROM_write(int bit)
{
	if (serial_count >= SERIAL_BUFFER_LENGTH-1)
	{
		return;
	}

	serial_buffer[serial_count++] = (bit ? '1' : '0');
	serial_buffer[serial_count] = 0;

	if ( (serial_count > intf->address_bits) &&
	      EEPROM_command_match((char*)serial_buffer,intf->cmd_read,(int)strlen((char*)serial_buffer)-intf->address_bits) )
	{
		int i,address;

		address = 0;
		for (i = serial_count-intf->address_bits;i < serial_count;i++)
		{
			address <<= 1;
			if (serial_buffer[i] == '1') address |= 1;
		}
		if (intf->data_bits == 16)
			eeprom_data_bits = (eeprom_data[2*address+0] << 8) + eeprom_data[2*address+1];
		else
			eeprom_data_bits = eeprom_data[address];
		eeprom_read_address = address;
		eeprom_clock_count = 0;
		sending = 1;
		serial_count = 0;
	}
	else if ( (serial_count > intf->address_bits) &&
	           EEPROM_command_match((char*)serial_buffer,intf->cmd_erase,(int)strlen((char*)serial_buffer)-intf->address_bits) )
	{
		int i,address;

		address = 0;
		for (i = serial_count-intf->address_bits;i < serial_count;i++)
		{
			address <<= 1;
			if (serial_buffer[i] == '1') address |= 1;
		}

		if (locked == 0)
		{
			if (intf->data_bits == 16)
			{
				eeprom_data[2*address+0] = 0x00;
				eeprom_data[2*address+1] = 0x00;
			}
			else
				eeprom_data[address] = 0x00;
		}
		else
		serial_count = 0;
	}
	else if ( (serial_count > (intf->address_bits + intf->data_bits)) &&
	           EEPROM_command_match((char*)serial_buffer,intf->cmd_write,(int)strlen((char*)serial_buffer)-(intf->address_bits + intf->data_bits)) )
	{
		int i,address,data;

		address = 0;
		for (i = serial_count-intf->data_bits-intf->address_bits;i < (serial_count-intf->data_bits);i++)
		{
			address <<= 1;
			if (serial_buffer[i] == '1') address |= 1;
		}
		data = 0;
		for (i = serial_count-intf->data_bits;i < serial_count;i++)
		{
			data <<= 1;
			if (serial_buffer[i] == '1') data |= 1;
		}
		if (locked == 0)
		{
			if (intf->data_bits == 16)
			{
				eeprom_data[2*address+0] = data >> 8;
				eeprom_data[2*address+1] = data & 0xff;
			}
			else
				eeprom_data[address] = data;
		}
		else
		serial_count = 0;
	}
	else if ( EEPROM_command_match((char*)serial_buffer,intf->cmd_lock,(int)strlen((char*)serial_buffer)) )
	{
		locked = 1;
		serial_count = 0;
	}
	else if ( EEPROM_command_match((char*)serial_buffer,intf->cmd_unlock,(int)strlen((char*)serial_buffer)) )
	{
		locked = 0;
		serial_count = 0;
	}
}

static void EEPROM_reset()
{
	serial_count = 0;
	sending = 0;
	reset_delay = intf->reset_delay;
}

void EEPROM_set_cs_line(int state)
{
	reset_line = state;

	if (reset_line != CLEAR_LINE)
		EEPROM_reset();
}

void EEPROM_set_clock_line(int state)
{
	if (state == PULSE_LINE || (clock_line == CLEAR_LINE && state != CLEAR_LINE))
	{
		if (reset_line == CLEAR_LINE)
		{
			if (sending)
			{
				if (eeprom_clock_count == intf->data_bits)
				{
					if(intf->enable_multi_read)
					{
						eeprom_read_address = (eeprom_read_address + 1) & ((1 << intf->address_bits) - 1);
						if (intf->data_bits == 16)
							eeprom_data_bits = (eeprom_data[2*eeprom_read_address+0] << 8) + eeprom_data[2*eeprom_read_address+1];
						else
							eeprom_data_bits = eeprom_data[eeprom_read_address];
						eeprom_clock_count = 0;
					}
					else
					{
						sending = 0;
					}
				}
				eeprom_data_bits = (eeprom_data_bits << 1) | 1;
				eeprom_clock_count++;
			}
			else
				EEPROM_write(latch);
		}
	}

	clock_line = state;
}


void EEPROM_write_bit(int bit)
{
	latch = bit;
}

int EEPROM_read_bit(void)
{
	int res;

	if (sending)
		res = (eeprom_data_bits >> intf->data_bits) & 1;
	else
	{
		if (reset_delay > 0)
		{
			reset_delay--;
			res = 0;
		}
		else
			res = 1;
	}

	return res;
}
*/

static void Sync(void)
{
  setprg8r(0x10,0x6000,0);
  setprg32(0x8000,(reg[0]<<4)|(reg[1]&0xF));
  setchr8(0);
}

static void StateRestore(int version)
{
  WSync();
}

static DECLFR(ReadLow)
{
  switch (A&0x7700)
  {
    case 0x5100: return reg[2]|reg[0]|reg[1]|reg[3]^0xff; break;
    case 0x5500: if(trigger)
                   return reg[2]|reg[1]; // Lei Dian Huang Bi Ka Qiu Chuan Shuo (NJ046) may broke other games
                 else
                   return 0;
  }
  return 4;
}

static void M163HB(void)
{
    if(reg[1]&0x80)
    {
      if(scanline==239)
      {
        setchr4(0x0000,0);
        setchr4(0x1000,0);
      }
      else if(scanline==127)
      {
        setchr4(0x0000,1);
        setchr4(0x1000,1);
      }
/*
      if(scanline>=127)     // Hu Lu Jin Gang (NJ039) (Ch) [!] don't like it
      {
        setchr4(0x0000,1);
        setchr4(0x1000,1);
      }
      else
      {
        setchr4(0x0000,0);
        setchr4(0x1000,0);
      }
*/      
    }
}

static DECLFW(Write)
{
  switch (A&0x7300)
  {
    case 0x5100: reg[0]=V; WSync(); break;
    case 0x5000: reg[1]=V; WSync(); break;
    case 0x5300: reg[2]=V; break;
    case 0x5200: reg[3]=V; WSync(); break;
  }
}

static void Power(void)
{
  memset(reg,0,8);
  reg[1]=0xFF;
  SetWriteHandler(0x5000,0x5FFF,Write);
  SetReadHandler(0x6000,0xFFFF,CartBR);
  SetWriteHandler(0x6000,0x7FFF,CartBW);
  WSync();
}

static void Close(void)
{
  if(WRAM)
    FCEU_gfree(WRAM);
  WRAM=NULL;
}

void Mapper164_Init(CartInfo *info)
{
  info->Power=Power;
  info->Close=Close;
  WSync = Sync;

  WRAMSIZE = 8192;
  WRAM=(uint8*)FCEU_gmalloc(WRAMSIZE);
  SetupCartPRGMapping(0x10,WRAM,WRAMSIZE,1);
  AddExState(WRAM, WRAMSIZE, 0, "WRAM");

  if(info->battery)
  {
    info->SaveGame[0]=WRAM;
    info->SaveGameLen[0]=WRAMSIZE;
  }

  GameStateRestore=StateRestore;
  AddExState(&StateRegs, ~0, 0, 0);
}

static DECLFW(Write2)
{
  if(A==0x5101)
  {
    if(laststrobe&&!V)
    {
      trigger^=1;
    }
    laststrobe=V;
  }else if(A==0x5100&&V==6) //damn thoose protected games
    setprg32(0x8000,3);
  else
  switch (A&0x7300)
  {
    case 0x5200: reg[0]=V; WSync(); break;
    case 0x5000: reg[1]=V; WSync(); if(!(reg[1]&0x80)&&(scanline<128)) setchr8(0); /* setchr8(0); */ break;
    case 0x5300: reg[2]=V; break;
    case 0x5100: reg[3]=V; WSync(); break;
  }
}

static void Power2(void)
{
  memset(reg,0,8);
  laststrobe=1;
  SetReadHandler(0x5000,0x5FFF,ReadLow);
  SetWriteHandler(0x5000,0x5FFF,Write2);
  SetReadHandler(0x6000,0xFFFF,CartBR);
  SetWriteHandler(0x6000,0x7FFF,CartBW);
  WSync();
}

void Mapper163_Init(CartInfo *info)
{
  info->Power=Power2;
  info->Close=Close;
  WSync = Sync;
  GameHBIRQHook=M163HB;

  WRAMSIZE = 8192;
  WRAM=(uint8*)FCEU_gmalloc(WRAMSIZE);
  SetupCartPRGMapping(0x10,WRAM,WRAMSIZE,1);
  AddExState(WRAM, WRAMSIZE, 0, "WRAM");

  if(info->battery)
  {
    info->SaveGame[0]=WRAM;
    info->SaveGameLen[0]=WRAMSIZE;
  }
  GameStateRestore=StateRestore;
  AddExState(&StateRegs, ~0, 0, 0);
}

static void Sync3(void)
{
  setchr8(0);
  setprg8r(0x10,0x6000,0);
  switch(reg[3]&7){
    case 0:
    case 2: setprg32(0x8000,(reg[0]&0xc)|(reg[1]&2)|((reg[2]&0xf)<<4)); break;
    case 1:
    case 3: setprg32(0x8000,(reg[0]&0xc)|(reg[2]&0xf)<<4); break;
    case 4: 
    case 6: setprg32(0x8000,(reg[0]&0xe)|((reg[1]>>1)&1)|((reg[2]&0xf)<<4)); break;
    case 5:
    case 7: setprg32(0x8000,(reg[0]&0xf)|((reg[2]&0xf)<<4)); break;
  }
}

static DECLFW(Write3)
{
//  FCEU_printf("bs %04x %02x\n",A,V);
  reg[(A>>8)&3]=V;
  WSync();
}

static void Power3(void)
{
  reg[0]=3;
  reg[1]=0;
  reg[2]=0;
  reg[3]=7;
  SetWriteHandler(0x5000,0x5FFF,Write3);
  SetReadHandler(0x6000,0xFFFF,CartBR);
  SetWriteHandler(0x6000,0x7FFF,CartBW);
  WSync();
}

void UNLFS304_Init(CartInfo *info)
{
  info->Power=Power3;
  info->Close=Close;
  WSync = Sync3;
  
  WRAMSIZE = 8192;
  WRAM=(uint8*)FCEU_gmalloc(WRAMSIZE);
  SetupCartPRGMapping(0x10,WRAM,WRAMSIZE,1);
  AddExState(WRAM, WRAMSIZE, 0, "WRAM");

  if(info->battery)
  {
    info->SaveGame[0]=WRAM;
    info->SaveGameLen[0]=WRAMSIZE;
  }
  
  GameStateRestore=StateRestore;
  AddExState(&StateRegs, ~0, 0, 0);
}
Commit	Line	Data
d97315ac	1	/* FCE Ultra - NES/Famicom Emulator
	2	*
	3	* Copyright notice for this file:
386f5371	4	* Copyright (C) 2002 Xodnizel 2006 CaH4e3
d97315ac	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
43725da7	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	* It seems that 162/163/164 mappers are the same mapper with just different
	21	* mapper modes enabled or disabled in software or hardware, need more nanjing
	22	* carts
d97315ac	23	*/
	24
	25	#include "mapinc.h"
	26
43725da7	27	static uint8 laststrobe, trigger;
	28	static uint8 reg[8];
	29	static uint8 *WRAM=NULL;
	30	static uint32 WRAMSIZE;
	31
	32	static void(*WSync)(void);
	33
d97315ac	34	static SFORMAT StateRegs[]=
d97315ac	35	{
386f5371	36	{&laststrobe, 1, "STB"},
386f5371	37	{&trigger, 1, "TRG"},
43725da7	38	{reg, 8, "REGS"},
d97315ac	39	{0}
	40	};
	41
43725da7	42	/*
	43	const EEPROM_interface eeprom_interface. =
	44	{
	45	9, // address bits 9
	46	8, // data bits 8
	47	"*110", // read 1 10 aaaaaaaaa
	48	"*101", // write 1 01 aaaaaaaaa dddddddd
	49	. "*10000xxxxxxx", // lock 1 00 00xxxxxxx
	50	"*10011xxxxxxx", // unlock 1 00 11xxxxxxx
	51	1,
	52	5
	53	};
	54
	55	static const EEPROM_interface *intf;
	56
	57	static int serial_count = 0;
	58	static u8 serial_buffer[SERIAL_BUFFER_LENGTH];
	59
	60	static int eeprom_data_bits;
	61	static int eeprom_clock_count;
	62	static int eeprom_read_address;
	63	static u8 *eeprom_data;
	64
	65	static int latch = 0;
	66	static int locked = 1;
	67	static int sending = 0;
	68	static int reset_line = ASSERT_LINE;
	69	static int clock_line = ASSERT_LINE;
	70	static int reset_delay;
	71
	72	void EEPROM_Init(u8 *data, u8 bit)
	73	{
	74	eeprom_data = data;
	75	if(bit == 8)
	76	intf = &eeprom_interface_93C46_8;
	77	else
	78	intf = &eeprom_interface_93C46_16;
	79	}
	80
	81	u8 *EEPROM_GetData()
	82	{
	83	return eeprom_data;
	84	}
	85
	86	static int EEPROM_command_match(const char buf, const char cmd, int len)
	87	{
	88	if ( cmd == 0 ) return 0;
	89	if ( len == 0 ) return 0;
	90
	91	for (;len>0;)
	92	{
	93	char b = *buf;
	94	char c = *cmd;
	95
	96	if ((b==0) \|\| (c==0))
	97	return (b==c);
	98
	99	switch ( c )
	100	{
	101	case '0':
	102	case '1':
	103	if (b != c) return 0;
	104	case 'X':
	105	case 'x':
106	buf++;
107	len--;
108	cmd++;
109	break;
110
111	case '*':
112	c = cmd[1];
113	switch( c )
114	{
115	case '0':
116	case '1':
117	if (b == c) { cmd++; }
118	else { buf++; len--; }
119	break;
120	default: return 0;
121	}
122	}
123	}
124	return (*cmd==0);
125	}
126
127	static void EEPROM_write(int bit)
128	{
129	if (serial_count >= SERIAL_BUFFER_LENGTH-1)
130	{
131	return;
132	}
133
134	serial_buffer[serial_count++] = (bit ? '1' : '0');
135	serial_buffer[serial_count] = 0;
136
137	if ( (serial_count > intf->address_bits) &&
138	EEPROM_command_match((char)serial_buffer,intf->cmd_read,(int)strlen((char)serial_buffer)-intf->address_bits) )
139	{
140	int i,address;
141
142	address = 0;
143	for (i = serial_count-intf->address_bits;i < serial_count;i++)
144	{
145	address <<= 1;
146	if (serial_buffer[i] == '1') address \|= 1;
147	}
148	if (intf->data_bits == 16)
149	eeprom_data_bits = (eeprom_data[2address+0] << 8) + eeprom_data[2address+1];
150	else
151	eeprom_data_bits = eeprom_data[address];
152	eeprom_read_address = address;
153	eeprom_clock_count = 0;
154	sending = 1;
155	serial_count = 0;
156	}
157	else if ( (serial_count > intf->address_bits) &&
158	EEPROM_command_match((char)serial_buffer,intf->cmd_erase,(int)strlen((char)serial_buffer)-intf->address_bits) )
159	{
160	int i,address;
161
162	address = 0;
163	for (i = serial_count-intf->address_bits;i < serial_count;i++)
164	{
165	address <<= 1;
166	if (serial_buffer[i] == '1') address \|= 1;
167	}
168
169	if (locked == 0)
170	{
171	if (intf->data_bits == 16)
172	{
173	eeprom_data[2*address+0] = 0x00;
174	eeprom_data[2*address+1] = 0x00;
175	}
176	else
177	eeprom_data[address] = 0x00;
178	}
179	else
180	serial_count = 0;
181	}
182	else if ( (serial_count > (intf->address_bits + intf->data_bits)) &&
183	EEPROM_command_match((char)serial_buffer,intf->cmd_write,(int)strlen((char)serial_buffer)-(intf->address_bits + intf->data_bits)) )
184	{
185	int i,address,data;
186
187	address = 0;
188	for (i = serial_count-intf->data_bits-intf->address_bits;i < (serial_count-intf->data_bits);i++)
189	{
190	address <<= 1;
191	if (serial_buffer[i] == '1') address \|= 1;
192	}
193	data = 0;
194	for (i = serial_count-intf->data_bits;i < serial_count;i++)
195	{
196	data <<= 1;
197	if (serial_buffer[i] == '1') data \|= 1;
198	}
199	if (locked == 0)
200	{
201	if (intf->data_bits == 16)
202	{
203	eeprom_data[2*address+0] = data >> 8;
204	eeprom_data[2*address+1] = data & 0xff;
205	}
206	else
207	eeprom_data[address] = data;
208	}
209	else
210	serial_count = 0;
211	}
212	else if ( EEPROM_command_match((char)serial_buffer,intf->cmd_lock,(int)strlen((char)serial_buffer)) )
213	{
214	locked = 1;
215	serial_count = 0;
216	}
217	else if ( EEPROM_command_match((char)serial_buffer,intf->cmd_unlock,(int)strlen((char)serial_buffer)) )
218	{
219	locked = 0;
220	serial_count = 0;
221	}
222	}
223
224	static void EEPROM_reset()
225	{
226	serial_count = 0;
227	sending = 0;
228	reset_delay = intf->reset_delay;
229	}
230
231	void EEPROM_set_cs_line(int state)
232	{
233	reset_line = state;
234
235	if (reset_line != CLEAR_LINE)
236	EEPROM_reset();
237	}
238
239	void EEPROM_set_clock_line(int state)
240	{
241	if (state == PULSE_LINE \|\| (clock_line == CLEAR_LINE && state != CLEAR_LINE))
242	{
243	if (reset_line == CLEAR_LINE)
244	{
245	if (sending)
246	{
247	if (eeprom_clock_count == intf->data_bits)
248	{
249	if(intf->enable_multi_read)
250	{
251	eeprom_read_address = (eeprom_read_address + 1) & ((1 << intf->address_bits) - 1);
252	if (intf->data_bits == 16)
253	eeprom_data_bits = (eeprom_data[2eeprom_read_address+0] << 8) + eeprom_data[2eeprom_read_address+1];
254	else
255	eeprom_data_bits = eeprom_data[eeprom_read_address];
256	eeprom_clock_count = 0;
257	}
258	else
259	{
260	sending = 0;
261	}
262	}
263	eeprom_data_bits = (eeprom_data_bits << 1) \| 1;
264	eeprom_clock_count++;
265	}
266	else
267	EEPROM_write(latch);
268	}
269	}
270
271	clock_line = state;
272	}
273
274
275	void EEPROM_write_bit(int bit)
276	{
277	latch = bit;
278	}
279
280	int EEPROM_read_bit(void)
281	{
282	int res;
283
284	if (sending)
285	res = (eeprom_data_bits >> intf->data_bits) & 1;
286	else
287	{
288	if (reset_delay > 0)
289	{
290	reset_delay--;
291	res = 0;
292	}
293	else
294	res = 1;
295	}
296
297	return res;
298	}
299	*/
300
d97315ac	301	static void Sync(void)
d97315ac	302	{
43725da7	303	setprg8r(0x10,0x6000,0);
	304	setprg32(0x8000,(reg[0]<<4)\|(reg[1]&0xF));
	305	setchr8(0);
d97315ac	306	}
	307
	308	static void StateRestore(int version)
	309	{
43725da7	310	WSync();
d97315ac	311	}
d97315ac	312
386f5371	313	static DECLFR(ReadLow)
	314	{
	315	switch (A&0x7700)
	316	{
43725da7	317	case 0x5100: return reg[2]\|reg[0]\|reg[1]\|reg[3]^0xff; break;
386f5371	318	case 0x5500: if(trigger)
43725da7	319	return reg[2]\|reg[1]; // Lei Dian Huang Bi Ka Qiu Chuan Shuo (NJ046) may broke other games
386f5371	320	else
	321	return 0;
	322	}
	323	return 4;
	324	}
	325
43725da7	326	static void M163HB(void)
	327	{
	328	if(reg[1]&0x80)
	329	{
	330	if(scanline==239)
	331	{
	332	setchr4(0x0000,0);
	333	setchr4(0x1000,0);
	334	}
	335	else if(scanline==127)
	336	{
	337	setchr4(0x0000,1);
	338	setchr4(0x1000,1);
	339	}
	340	/*
	341	if(scanline>=127) // Hu Lu Jin Gang (NJ039) (Ch) [!] don't like it
	342	{
	343	setchr4(0x0000,1);
	344	setchr4(0x1000,1);
	345	}
	346	else
	347	{
	348	setchr4(0x0000,0);
	349	setchr4(0x1000,0);
	350	}
	351	*/
	352	}
	353	}
	354
d97315ac	355	static DECLFW(Write)
	356	{
	357	switch (A&0x7300)
	358	{
43725da7	359	case 0x5100: reg[0]=V; WSync(); break;
	360	case 0x5000: reg[1]=V; WSync(); break;
	361	case 0x5300: reg[2]=V; break;
	362	case 0x5200: reg[3]=V; WSync(); break;
d97315ac	363	}
	364	}
	365
43725da7	366	static void Power(void)
	367	{
	368	memset(reg,0,8);
	369	reg[1]=0xFF;
	370	SetWriteHandler(0x5000,0x5FFF,Write);
	371	SetReadHandler(0x6000,0xFFFF,CartBR);
	372	SetWriteHandler(0x6000,0x7FFF,CartBW);
	373	WSync();
	374	}
	375
	376	static void Close(void)
	377	{
	378	if(WRAM)
	379	FCEU_gfree(WRAM);
	380	WRAM=NULL;
	381	}
	382
	383	void Mapper164_Init(CartInfo *info)
	384	{
	385	info->Power=Power;
	386	info->Close=Close;
	387	WSync = Sync;
	388
	389	WRAMSIZE = 8192;
	390	WRAM=(uint8*)FCEU_gmalloc(WRAMSIZE);
	391	SetupCartPRGMapping(0x10,WRAM,WRAMSIZE,1);
	392	AddExState(WRAM, WRAMSIZE, 0, "WRAM");
	393
	394	if(info->battery)
	395	{
	396	info->SaveGame[0]=WRAM;
	397	info->SaveGameLen[0]=WRAMSIZE;
	398	}
	399
	400	GameStateRestore=StateRestore;
	401	AddExState(&StateRegs, ~0, 0, 0);
	402	}
	403
d97315ac	404	static DECLFW(Write2)
d97315ac	405	{
386f5371	406	if(A==0x5101)
	407	{
	408	if(laststrobe&&!V)
	409	{
	410	trigger^=1;
	411	}
	412	laststrobe=V;
	413	}else if(A==0x5100&&V==6) //damn thoose protected games
	414	setprg32(0x8000,3);
	415	else
d97315ac	416	switch (A&0x7300)
d97315ac	417	{
43725da7	418	case 0x5200: reg[0]=V; WSync(); break;
	419	case 0x5000: reg[1]=V; WSync(); if(!(reg[1]&0x80)&&(scanline<128)) setchr8(0); /* setchr8(0); */ break;
	420	case 0x5300: reg[2]=V; break;
	421	case 0x5100: reg[3]=V; WSync(); break;
d97315ac	422	}
	423	}
	424
43725da7	425	static void Power2(void)
d97315ac	426	{
43725da7	427	memset(reg,0,8);
	428	laststrobe=1;
	429	SetReadHandler(0x5000,0x5FFF,ReadLow);
	430	SetWriteHandler(0x5000,0x5FFF,Write2);
	431	SetReadHandler(0x6000,0xFFFF,CartBR);
	432	SetWriteHandler(0x6000,0x7FFF,CartBW);
	433	WSync();
d97315ac	434	}
d97315ac	435
43725da7	436	void Mapper163_Init(CartInfo *info)
d97315ac	437	{
43725da7	438	info->Power=Power2;
	439	info->Close=Close;
	440	WSync = Sync;
	441	GameHBIRQHook=M163HB;
	442
	443	WRAMSIZE = 8192;
	444	WRAM=(uint8*)FCEU_gmalloc(WRAMSIZE);
	445	SetupCartPRGMapping(0x10,WRAM,WRAMSIZE,1);
	446	AddExState(WRAM, WRAMSIZE, 0, "WRAM");
	447
	448	if(info->battery)
	449	{
	450	info->SaveGame[0]=WRAM;
	451	info->SaveGameLen[0]=WRAMSIZE;
	452	}
	453	GameStateRestore=StateRestore;
	454	AddExState(&StateRegs, ~0, 0, 0);
d97315ac	455	}
d97315ac	456
43725da7	457	static void Sync3(void)
d97315ac	458	{
386f5371	459	setchr8(0);
43725da7	460	setprg8r(0x10,0x6000,0);
	461	switch(reg[3]&7){
	462	case 0:
	463	case 2: setprg32(0x8000,(reg[0]&0xc)\|(reg[1]&2)\|((reg[2]&0xf)<<4)); break;
	464	case 1:
	465	case 3: setprg32(0x8000,(reg[0]&0xc)\|(reg[2]&0xf)<<4); break;
	466	case 4:
	467	case 6: setprg32(0x8000,(reg[0]&0xe)\|((reg[1]>>1)&1)\|((reg[2]&0xf)<<4)); break;
	468	case 5:
	469	case 7: setprg32(0x8000,(reg[0]&0xf)\|((reg[2]&0xf)<<4)); break;
	470	}
d97315ac	471	}
d97315ac	472
43725da7	473	static DECLFW(Write3)
e2d0dd92	474	{
43725da7	475	// FCEU_printf("bs %04x %02x\n",A,V);
	476	reg[(A>>8)&3]=V;
	477	WSync();
e2d0dd92	478	}
e2d0dd92	479
43725da7	480	static void Power3(void)
d97315ac	481	{
43725da7	482	reg[0]=3;
	483	reg[1]=0;
	484	reg[2]=0;
	485	reg[3]=7;
	486	SetWriteHandler(0x5000,0x5FFF,Write3);
	487	SetReadHandler(0x6000,0xFFFF,CartBR);
	488	SetWriteHandler(0x6000,0x7FFF,CartBW);
	489	WSync();
d97315ac	490	}
d97315ac	491
43725da7	492	void UNLFS304_Init(CartInfo *info)
d97315ac	493	{
43725da7	494	info->Power=Power3;
	495	info->Close=Close;
	496	WSync = Sync3;
	497
	498	WRAMSIZE = 8192;
	499	WRAM=(uint8*)FCEU_gmalloc(WRAMSIZE);
	500	SetupCartPRGMapping(0x10,WRAM,WRAMSIZE,1);
	501	AddExState(WRAM, WRAMSIZE, 0, "WRAM");
d97315ac	502
43725da7	503	if(info->battery)
	504	{
	505	info->SaveGame[0]=WRAM;
	506	info->SaveGameLen[0]=WRAMSIZE;
	507	}
	508
d97315ac	509	GameStateRestore=StateRestore;
	510	AddExState(&StateRegs, ~0, 0, 0);
	511	}