[picodrive.git] / pico / patch.c

/* Decode a Game Genie code into an M68000 address/data pair.
 * The Game Genie code is made of the characters
 * ABCDEFGHJKLMNPRSTVWXYZ0123456789 (notice the missing I, O, Q and U).
 * Where A = 00000, B = 00001, C = 00010, ... , on to 9 = 11111.
 *
 * These come out to a very scrambled bit pattern like this:
 * (SCRA-MBLE is just an example)
 *
 *   S     C     R     A  -  M     B     L     E
 * 01111 00010 01110 00000 01011 00001 01010 00100
 * ijklm nopIJ KLMNO PABCD EFGHd efgha bcQRS TUVWX
 *
 * Our goal is to rearrange that to this:
 *
 * 0000 0101 1001 1100 0100 0100 : 1011 0000 0111 1000
 * ABCD EFGH IJKL MNOP QRST UVWX : abcd efgh ijkl mnop
 *
 * which in Hexadecimal is 059C44:B078. Simple, huh? ;)
 *
 * So, then, we dutifully change memory location 059C44 to B078!
 * (of course, that's handled by a different source file :)
 */

#include "pico_int.h"
#include "memory.h"
#include "patch.h"

struct patch
{
	unsigned int addr;
	unsigned short data;
};

struct patch_inst *PicoPatches = NULL;
int PicoPatchCount = 0;

static char genie_chars[] = "AaBbCcDdEeFfGgHhJjKkLlMmNnPpRrSsTtVvWwXxYyZz0O1I2233445566778899";

/* genie_decode
 * This function converts a Game Genie code to an address:data pair.
 * The code is given as an 8-character string, like "BJX0SA1C". It need not
 * be null terminated, since only the first 8 characters are taken. It is
 * assumed that the code is already made of valid characters, i.e. there are no
 * Q's, U's, or symbols. If such a character is
 * encountered, the function will return with a warning on stderr.
 *
 * The resulting address:data pair is returned in the struct patch pointed to
 * by result. If an error results, both the address and data will be set to -1.
 */

static void genie_decode(const char* code, struct patch* result)
{
  int i = 0, n;
  char* x;

  for(; i < 8; ++i)
  {
    /* If strchr returns NULL, we were given a bad character */
    if(!(x = strchr(genie_chars, code[i])))
    {
      result->addr = -1; result->data = -1;
      return;
    }
    n = (x - genie_chars) >> 1;
    /* Now, based on which character this is, fit it into the result */
    switch(i)
    {
    case 0:
      /* ____ ____ ____ ____ ____ ____ : ____ ____ ABCD E___ */
      result->data |= n << 3;
      break;
    case 1:
      /* ____ ____ DE__ ____ ____ ____ : ____ ____ ____ _ABC */
      result->data |= n >> 2;
      result->addr |= (n & 3) << 14;
      break;
    case 2:
      /* ____ ____ __AB CDE_ ____ ____ : ____ ____ ____ ____ */
      result->addr |= n << 9;
      break;
    case 3:
      /* BCDE ____ ____ ___A ____ ____ : ____ ____ ____ ____ */
      result->addr |= (n & 0xF) << 20 | (n >> 4) << 8;
      break;
    case 4:
      /* ____ ABCD ____ ____ ____ ____ : ___E ____ ____ ____ */
      result->data |= (n & 1) << 12;
      result->addr |= (n >> 1) << 16;
      break;
    case 5:
      /* ____ ____ ____ ____ ____ ____ : E___ ABCD ____ ____ */
      result->data |= (n & 1) << 15 | (n >> 1) << 8;
      break;
    case 6:
      /* ____ ____ ____ ____ CDE_ ____ : _AB_ ____ ____ ____ */
      result->data |= (n >> 3) << 13;
      result->addr |= (n & 7) << 5;
      break;
    case 7:
      /* ____ ____ ____ ____ ___A BCDE : ____ ____ ____ ____ */
      result->addr |= n;
      break;
    }
    /* Go around again */
  }
  return;
}

/* "Decode" an address/data pair into a structure. This is for "012345:ABCD"
 * type codes. You're more likely to find Genie codes circulating around, but
 * there's a chance you could come on to one of these. Which is nice, since
 * they're MUCH easier to implement ;) Once again, the input should be depunc-
 * tuated already. */

static char hex_chars[] = "00112233445566778899AaBbCcDdEeFf";

static void hex_decode(const char *code, struct patch *result)
{
  char *x;
  int i;
  /* 6 digits for address */
  for(i = 0; i < 6; ++i)
    {
      if(!(x = strchr(hex_chars, code[i])))
      {
	result->addr = result->data = -1;
	return;
      }
      result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
    }
  /* 4 digits for data */
  for(i = 6; i < 10; ++i)
    {
      if(!(x = strchr(hex_chars, code[i])))
      {
	result->addr = result->data = -1;
	return;
      }
      result->data = (result->data << 4) | ((x - hex_chars) >> 1);
    }
}

/* THIS is the function you call from the MegaDrive or whatever. This figures
 * out whether it's a genie or hex code, depunctuates it, and calls the proper
 * decoder. */
void decode(const char* code, struct patch* result)
{
  int len = strlen(code), i, j;
  char code_to_pass[16], *x;
  const char *ad, *da;
  int adl, dal;

  /* Initialize the result */
  result->addr = result->data = 0;

  /* Just assume 8 char long string to be Game Genie code */
  if (len == 8)
  {
    genie_decode(code, result);
    return;
  }

  /* If it's 9 chars long and the 5th is a hyphen, we have a Game Genie
   * code. */
    if(len == 9 && code[4] == '-')
    {
      /* Remove the hyphen and pass to genie_decode */
      code_to_pass[0] = code[0];
      code_to_pass[1] = code[1];
      code_to_pass[2] = code[2];
      code_to_pass[3] = code[3];
      code_to_pass[4] = code[5];
      code_to_pass[5] = code[6];
      code_to_pass[6] = code[7];
      code_to_pass[7] = code[8];
      code_to_pass[8] = '\0';
      genie_decode(code_to_pass, result);
      return;
    }

  /* Otherwise, we assume it's a hex code.
   * Find the colon so we know where address ends and data starts. If there's
   * no colon, then we haven't a code at all! */
  if(!(x = strchr(code, ':'))) goto bad_code;
  ad = code; da = x + 1; adl = x - code; dal = len - adl - 1;

  /* If a section is empty or too long, toss it */
  if(adl == 0 || adl > 6 || dal == 0 || dal > 4) goto bad_code;

  /* Pad the address with zeros, then fill it with the value */
  for(i = 0; i < (6 - adl); ++i) code_to_pass[i] = '0';
  for(j = 0; i < 6; ++i, ++j) code_to_pass[i] = ad[j];

  /* Do the same for data */
  for(i = 6; i < (10 - dal); ++i) code_to_pass[i] = '0';
  for(j = 0; i < 10; ++i, ++j) code_to_pass[i] = da[j];

  code_to_pass[10] = '\0';

  /* Decode and goodbye */
  hex_decode(code_to_pass, result);
  return;

bad_code:

  /* AGH! Invalid code! */
  result->data = result->addr = -1;
  return;
}


unsigned int PicoRead16(unsigned int a);
void PicoWrite16(unsigned int a, unsigned short d);


void PicoPatchUnload(void)
{
	if (PicoPatches != NULL)
	{
		free(PicoPatches);
		PicoPatches = NULL;
	}
	PicoPatchCount = 0;
}

int PicoPatchLoad(const char *fname)
{
	FILE *f;
	char buff[256];
	struct patch pt;
	int array_len = 0;

	PicoPatchUnload();

	f = fopen(fname, "r");
	if (f == NULL)
	{
		return -1;
	}

	while (fgets(buff, sizeof(buff), f))
	{
		int llen, clen;

		llen = strlen(buff);
		for (clen = 0; clen < llen; clen++)
			if (isspace_(buff[clen]))
				break;
		buff[clen] = 0;

		if (clen > 11 || clen < 8)
			continue;

		decode(buff, &pt);
		if (pt.addr == (unsigned int)-1 || pt.data == (unsigned short)-1)
			continue;

		/* code was good, add it */
		if (array_len < PicoPatchCount + 1)
		{
			void *ptr;
			array_len *= 2;
			array_len++;
			ptr = realloc(PicoPatches, array_len * sizeof(PicoPatches[0]));
			if (ptr == NULL) break;
			PicoPatches = ptr;
		}
		strcpy(PicoPatches[PicoPatchCount].code, buff);
		/* strip */
		for (clen++; clen < llen; clen++)
			if (!isspace_(buff[clen]))
				break;
		for (llen--; llen > 0; llen--)
			if (!isspace_(buff[llen]))
				break;
		buff[llen+1] = 0;
		strncpy(PicoPatches[PicoPatchCount].name, buff + clen, 51);
		PicoPatches[PicoPatchCount].name[51] = 0;
		PicoPatches[PicoPatchCount].active = 0;
		PicoPatches[PicoPatchCount].addr = pt.addr;
		PicoPatches[PicoPatchCount].data = pt.data;
		PicoPatches[PicoPatchCount].data_old = 0;
		PicoPatchCount++;
		// fprintf(stderr, "loaded patch #%i: %06x:%04x \"%s\"\n", PicoPatchCount-1, pt.addr, pt.data,
		//	PicoPatches[PicoPatchCount-1].name);
	}
	fclose(f);

	return 0;
}

/* to be called when the Rom is loaded and byteswapped */
void PicoPatchPrepare(void)
{
	int i;

	for (i = 0; i < PicoPatchCount; i++)
	{
		PicoPatches[i].addr &= ~1;
		if (PicoPatches[i].addr < Pico.romsize)
			PicoPatches[i].data_old = *(unsigned short *)(Pico.rom + PicoPatches[i].addr);
		else
			PicoPatches[i].data_old = (unsigned short) m68k_read16(PicoPatches[i].addr);
		if (strstr(PicoPatches[i].name, "AUTO"))
			PicoPatches[i].active = 1;
	}
}

void PicoPatchApply(void)
{
	int i, u;
	unsigned int addr;

	for (i = 0; i < PicoPatchCount; i++)
	{
		addr = PicoPatches[i].addr;
		if (addr < Pico.romsize)
		{
			if (PicoPatches[i].active)
				*(unsigned short *)(Pico.rom + addr) = PicoPatches[i].data;
			else {
				// if current addr is not patched by older patch, write back original val
				for (u = 0; u < i; u++)
					if (PicoPatches[u].addr == addr) break;
				if (u == i)
					*(unsigned short *)(Pico.rom + addr) = PicoPatches[i].data_old;
			}
			// fprintf(stderr, "patched %i: %06x:%04x\n", PicoPatches[i].active, addr,
			//	*(unsigned short *)(Pico.rom + addr));
		}
		else
		{
			if (PicoPatches[i].active)
				m68k_write16(PicoPatches[i].addr,PicoPatches[i].data);
			else {
				// if current addr is not patched by older patch, write back original val
				for (u = 0; u < i; u++)
					if (PicoPatches[u].addr == addr) break;
				if (u == i)
					m68k_write16(PicoPatches[i].addr,PicoPatches[i].data_old);
			}
		}
	}
}
Commit	Line	Data
b67ef287	1	/* Decode a Game Genie code into an M68000 address/data pair.
	2	* The Game Genie code is made of the characters
	3	* ABCDEFGHJKLMNPRSTVWXYZ0123456789 (notice the missing I, O, Q and U).
	4	* Where A = 00000, B = 00001, C = 00010, ... , on to 9 = 11111.
	5	*
	6	* These come out to a very scrambled bit pattern like this:
	7	* (SCRA-MBLE is just an example)
	8	*
	9	* S C R A - M B L E
	10	* 01111 00010 01110 00000 01011 00001 01010 00100
	11	* ijklm nopIJ KLMNO PABCD EFGHd efgha bcQRS TUVWX
	12	*
	13	* Our goal is to rearrange that to this:
	14	*
	15	* 0000 0101 1001 1100 0100 0100 : 1011 0000 0111 1000
	16	* ABCD EFGH IJKL MNOP QRST UVWX : abcd efgh ijkl mnop
	17	*
	18	* which in Hexadecimal is 059C44:B078. Simple, huh? ;)
	19	*
	20	* So, then, we dutifully change memory location 059C44 to B078!
	21	* (of course, that's handled by a different source file :)
	22	*/
	23
efcba75f	24	#include "pico_int.h"
8655fd04	25	#include "memory.h"
efcba75f	26	#include "patch.h"
b67ef287	27
	28	struct patch
	29	{
	30	unsigned int addr;
	31	unsigned short data;
	32	};
	33
	34	struct patch_inst *PicoPatches = NULL;
	35	int PicoPatchCount = 0;
	36
	37	static char genie_chars[] = "AaBbCcDdEeFfGgHhJjKkLlMmNnPpRrSsTtVvWwXxYyZz0O1I2233445566778899";
	38
	39	/* genie_decode
	40	* This function converts a Game Genie code to an address:data pair.
	41	* The code is given as an 8-character string, like "BJX0SA1C". It need not
	42	* be null terminated, since only the first 8 characters are taken. It is
	43	* assumed that the code is already made of valid characters, i.e. there are no
	44	* Q's, U's, or symbols. If such a character is
	45	* encountered, the function will return with a warning on stderr.
	46	*
	47	* The resulting address:data pair is returned in the struct patch pointed to
	48	* by result. If an error results, both the address and data will be set to -1.
	49	*/
	50
	51	static void genie_decode(const char* code, struct patch* result)
	52	{
	53	int i = 0, n;
	54	char* x;
	55
	56	for(; i < 8; ++i)
	57	{
	58	/* If strchr returns NULL, we were given a bad character */
	59	if(!(x = strchr(genie_chars, code[i])))
	60	{
	61	result->addr = -1; result->data = -1;
	62	return;
	63	}
	64	n = (x - genie_chars) >> 1;
	65	/* Now, based on which character this is, fit it into the result */
	66	switch(i)
	67	{
	68	case 0:
	69	/* ____ ____ ____ ____ ____ ____ : ____ ____ ABCD E___ */
	70	result->data \|= n << 3;
	71	break;
	72	case 1:
	73	/* ____ ____ DE__ ____ ____ ____ : ____ ____ ____ _ABC */
	74	result->data \|= n >> 2;
	75	result->addr \|= (n & 3) << 14;
	76	break;
	77	case 2:
	78	/* ____ ____ __AB CDE_ ____ ____ : ____ ____ ____ ____ */
	79	result->addr \|= n << 9;
	80	break;
	81	case 3:
	82	/* BCDE ____ ____ ___A ____ ____ : ____ ____ ____ ____ */
	83	result->addr \|= (n & 0xF) << 20 \| (n >> 4) << 8;
	84	break;
	85	case 4:
	86	/* ____ ABCD ____ ____ ____ ____ : ___E ____ ____ ____ */
	87	result->data \|= (n & 1) << 12;
	88	result->addr \|= (n >> 1) << 16;
	89	break;
	90	case 5:
91	/* ____ ____ ____ ____ ____ ____ : E___ ABCD ____ ____ */
92	result->data \|= (n & 1) << 15 \| (n >> 1) << 8;
93	break;
94	case 6:
95	/* ____ ____ ____ ____ CDE_ ____ : _AB_ ____ ____ ____ */
96	result->data \|= (n >> 3) << 13;
97	result->addr \|= (n & 7) << 5;
98	break;
99	case 7:
100	/* ____ ____ ____ ____ ___A BCDE : ____ ____ ____ ____ */
101	result->addr \|= n;
102	break;
103	}
104	/* Go around again */
105	}
106	return;
107	}
108
109	/* "Decode" an address/data pair into a structure. This is for "012345:ABCD"
110	* type codes. You're more likely to find Genie codes circulating around, but
111	* there's a chance you could come on to one of these. Which is nice, since
112	* they're MUCH easier to implement ;) Once again, the input should be depunc-
113	* tuated already. */
114
115	static char hex_chars[] = "00112233445566778899AaBbCcDdEeFf";
116
117	static void hex_decode(const char code, struct patch result)
118	{
119	char *x;
120	int i;
121	/* 6 digits for address */
122	for(i = 0; i < 6; ++i)
123	{
124	if(!(x = strchr(hex_chars, code[i])))
125	{
126	result->addr = result->data = -1;
127	return;
128	}
129	result->addr = (result->addr << 4) \| ((x - hex_chars) >> 1);
130	}
131	/* 4 digits for data */
132	for(i = 6; i < 10; ++i)
133	{
134	if(!(x = strchr(hex_chars, code[i])))
135	{
136	result->addr = result->data = -1;
137	return;
138	}
139	result->data = (result->data << 4) \| ((x - hex_chars) >> 1);
140	}
141	}
142
143	/* THIS is the function you call from the MegaDrive or whatever. This figures
144	* out whether it's a genie or hex code, depunctuates it, and calls the proper
145	* decoder. */
8655fd04	146	void decode(const char* code, struct patch* result)
b67ef287	147	{
	148	int len = strlen(code), i, j;
	149	char code_to_pass[16], *x;
	150	const char ad, da;
	151	int adl, dal;
	152
	153	/* Initialize the result */
	154	result->addr = result->data = 0;
	155
	156	/* Just assume 8 char long string to be Game Genie code */
	157	if (len == 8)
	158	{
	159	genie_decode(code, result);
	160	return;
	161	}
	162
	163	/* If it's 9 chars long and the 5th is a hyphen, we have a Game Genie
	164	* code. */
	165	if(len == 9 && code[4] == '-')
	166	{
	167	/* Remove the hyphen and pass to genie_decode */
	168	code_to_pass[0] = code[0];
	169	code_to_pass[1] = code[1];
	170	code_to_pass[2] = code[2];
	171	code_to_pass[3] = code[3];
	172	code_to_pass[4] = code[5];
	173	code_to_pass[5] = code[6];
	174	code_to_pass[6] = code[7];
	175	code_to_pass[7] = code[8];
	176	code_to_pass[8] = '\0';
	177	genie_decode(code_to_pass, result);
	178	return;
	179	}
	180
	181	/* Otherwise, we assume it's a hex code.
	182	* Find the colon so we know where address ends and data starts. If there's
	183	* no colon, then we haven't a code at all! */
	184	if(!(x = strchr(code, ':'))) goto bad_code;
	185	ad = code; da = x + 1; adl = x - code; dal = len - adl - 1;
	186
	187	/* If a section is empty or too long, toss it */
	188	if(adl == 0 \|\| adl > 6 \|\| dal == 0 \|\| dal > 4) goto bad_code;
	189
	190	/* Pad the address with zeros, then fill it with the value */
	191	for(i = 0; i < (6 - adl); ++i) code_to_pass[i] = '0';
	192	for(j = 0; i < 6; ++i, ++j) code_to_pass[i] = ad[j];
	193
	194	/* Do the same for data */
	195	for(i = 6; i < (10 - dal); ++i) code_to_pass[i] = '0';
	196	for(j = 0; i < 10; ++i, ++j) code_to_pass[i] = da[j];
	197
	198	code_to_pass[10] = '\0';
	199
	200	/* Decode and goodbye */
	201	hex_decode(code_to_pass, result);
	202	return;
	203
	204	bad_code:
	205
	206	/* AGH! Invalid code! */
	207	result->data = result->addr = -1;
	208	return;
	209	}
	210
211
212
eff55556	213	unsigned int PicoRead16(unsigned int a);
b67ef287	214	void PicoWrite16(unsigned int a, unsigned short d);
	215
	216
	217	void PicoPatchUnload(void)
	218	{
	219	if (PicoPatches != NULL)
	220	{
	221	free(PicoPatches);
	222	PicoPatches = NULL;
	223	}
	224	PicoPatchCount = 0;
	225	}
	226
	227	int PicoPatchLoad(const char *fname)
	228	{
	229	FILE *f;
	230	char buff[256];
	231	struct patch pt;
	232	int array_len = 0;
	233
	234	PicoPatchUnload();
	235
	236	f = fopen(fname, "r");
	237	if (f == NULL)
	238	{
	239	return -1;
	240	}
	241
	242	while (fgets(buff, sizeof(buff), f))
	243	{
	244	int llen, clen;
	245
	246	llen = strlen(buff);
	247	for (clen = 0; clen < llen; clen++)
ee2a3bdf	248	if (isspace_(buff[clen]))
ee2a3bdf	249	break;
b67ef287	250	buff[clen] = 0;
	251
	252	if (clen > 11 \|\| clen < 8)
	253	continue;
	254
	255	decode(buff, &pt);
	256	if (pt.addr == (unsigned int)-1 \|\| pt.data == (unsigned short)-1)
	257	continue;
	258
	259	/* code was good, add it */
	260	if (array_len < PicoPatchCount + 1)
	261	{
	262	void *ptr;
	263	array_len *= 2;
	264	array_len++;
	265	ptr = realloc(PicoPatches, array_len * sizeof(PicoPatches[0]));
	266	if (ptr == NULL) break;
	267	PicoPatches = ptr;
	268	}
	269	strcpy(PicoPatches[PicoPatchCount].code, buff);
	270	/* strip */
	271	for (clen++; clen < llen; clen++)
ee2a3bdf	272	if (!isspace_(buff[clen]))
ee2a3bdf	273	break;
b67ef287	274	for (llen--; llen > 0; llen--)
ee2a3bdf	275	if (!isspace_(buff[llen]))
ee2a3bdf	276	break;
b67ef287	277	buff[llen+1] = 0;
	278	strncpy(PicoPatches[PicoPatchCount].name, buff + clen, 51);
	279	PicoPatches[PicoPatchCount].name[51] = 0;
	280	PicoPatches[PicoPatchCount].active = 0;
	281	PicoPatches[PicoPatchCount].addr = pt.addr;
	282	PicoPatches[PicoPatchCount].data = pt.data;
	283	PicoPatches[PicoPatchCount].data_old = 0;
	284	PicoPatchCount++;
	285	// fprintf(stderr, "loaded patch #%i: %06x:%04x \"%s\"\n", PicoPatchCount-1, pt.addr, pt.data,
	286	// PicoPatches[PicoPatchCount-1].name);
	287	}
	288	fclose(f);
	289
	290	return 0;
	291	}
	292
	293	/* to be called when the Rom is loaded and byteswapped */
	294	void PicoPatchPrepare(void)
	295	{
	296	int i;
	297
	298	for (i = 0; i < PicoPatchCount; i++)
	299	{
	300	PicoPatches[i].addr &= ~1;
af37bca8	301	if (PicoPatches[i].addr < Pico.romsize)
af37bca8	302	PicoPatches[i].data_old = (unsigned short )(Pico.rom + PicoPatches[i].addr);
8655fd04	303	else
8655fd04	304	PicoPatches[i].data_old = (unsigned short) m68k_read16(PicoPatches[i].addr);
b67ef287	305	if (strstr(PicoPatches[i].name, "AUTO"))
	306	PicoPatches[i].active = 1;
	307	}
	308	}
	309
	310	void PicoPatchApply(void)
	311	{
	312	int i, u;
	313	unsigned int addr;
	314
	315	for (i = 0; i < PicoPatchCount; i++)
	316	{
	317	addr = PicoPatches[i].addr;
	318	if (addr < Pico.romsize)
	319	{
	320	if (PicoPatches[i].active)
	321	(unsigned short )(Pico.rom + addr) = PicoPatches[i].data;
	322	else {
	323	// if current addr is not patched by older patch, write back original val
	324	for (u = 0; u < i; u++)
	325	if (PicoPatches[u].addr == addr) break;
	326	if (u == i)
	327	(unsigned short )(Pico.rom + addr) = PicoPatches[i].data_old;
	328	}
	329	// fprintf(stderr, "patched %i: %06x:%04x\n", PicoPatches[i].active, addr,
	330	// (unsigned short )(Pico.rom + addr));
	331	}
	332	else
	333	{
8655fd04	334	if (PicoPatches[i].active)
	335	m68k_write16(PicoPatches[i].addr,PicoPatches[i].data);
	336	else {
	337	// if current addr is not patched by older patch, write back original val
	338	for (u = 0; u < i; u++)
	339	if (PicoPatches[u].addr == addr) break;
	340	if (u == i)
	341	m68k_write16(PicoPatches[i].addr,PicoPatches[i].data_old);
	342	}
b67ef287	343	}
	344	}
	345	}
	346