mirror of
https://github.com/ekeeke/Genesis-Plus-GX.git
synced 2024-09-19 12:49:43 +02:00
267 lines
7.1 KiB
C
267 lines
7.1 KiB
C
/****************************************************************************
|
|
* Genesis Plus
|
|
* Game Genie Hardware emulation
|
|
*
|
|
* Copyright (C) 2009 Eke-Eke (GCN/Wii port)
|
|
*
|
|
* Based on documentation from Charles McDonald
|
|
* (http://cgfm2.emuviews.com/txt/genie.txt)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
***************************************************************************/
|
|
|
|
#include "shared.h"
|
|
|
|
static struct
|
|
{
|
|
uint8 enabled;
|
|
uint8 rom[0x10000];
|
|
uint16 regs[0x20];
|
|
uint16 old[6];
|
|
uint16 data[6];
|
|
uint32 addr[6];
|
|
} ggenie;
|
|
|
|
static void ggenie_write_byte(uint32 address, uint32 data);
|
|
static void ggenie_write_word(uint32 address, uint32 data);
|
|
static void ggenie_write_regs(uint8 offset, uint32 data, uint8 type);
|
|
static uint32 ggenie_read_regs(uint32 address);
|
|
|
|
void ggenie_init(void)
|
|
{
|
|
memset(&ggenie,0,sizeof(ggenie));
|
|
|
|
/* Open Game Genie ROM */
|
|
FILE *f = fopen(GG_ROM,"rb");
|
|
if (!f) return;
|
|
|
|
/* Load ROM */
|
|
int i = 0;
|
|
while (i < 0x8000)
|
|
{
|
|
fread(ggenie.rom+i,0x1000,1,f);
|
|
i += 0x1000;
|
|
}
|
|
fclose(f);
|
|
|
|
#ifdef LSB_FIRST
|
|
/* Byteswap ROM */
|
|
int i;
|
|
uint8 temp;
|
|
for(i = 0; i < 0x8000; i += 2)
|
|
{
|
|
temp = ggenie.rom[i];
|
|
ggenie.rom[i] = ggenie.rom[i+1];
|
|
ggenie.rom[i+1] = temp;
|
|
}
|
|
#endif
|
|
|
|
/* $0000-$7fff mirrored into $8000-$ffff */
|
|
memcpy(ggenie.rom+0x8000,ggenie.rom,0x8000);
|
|
|
|
/* set flag */
|
|
ggenie.enabled = 1;
|
|
}
|
|
|
|
void ggenie_shutdown(void)
|
|
{
|
|
if (ggenie.enabled)
|
|
{
|
|
ggenie_switch(0);
|
|
ggenie.enabled = 0;
|
|
}
|
|
}
|
|
|
|
void ggenie_reset(void)
|
|
{
|
|
if (!ggenie.enabled)
|
|
return;
|
|
|
|
/* clear codes */
|
|
ggenie_switch(0);
|
|
|
|
/* reset internal state */
|
|
memset(ggenie.regs,0,sizeof(ggenie.regs));
|
|
memset(ggenie.old,0,sizeof(ggenie.old));
|
|
memset(ggenie.data,0,sizeof(ggenie.data));
|
|
memset(ggenie.addr,0,sizeof(ggenie.addr));
|
|
|
|
/* Game Genie ROM is mapped at $000000-$007fff */
|
|
m68k_memory_map[0].base = ggenie.rom;
|
|
|
|
/* Internal registers are mapped at $000000-$00001f */
|
|
m68k_memory_map[0].write8 = ggenie_write_byte;
|
|
m68k_memory_map[0].write16 = ggenie_write_word;
|
|
|
|
/* Disable registers reads */
|
|
m68k_memory_map[0].read16 = NULL;
|
|
}
|
|
|
|
void ggenie_switch(int enable)
|
|
{
|
|
int i,j;
|
|
if (enable)
|
|
{
|
|
for (i=0; i<6; i++)
|
|
{
|
|
/* patch is enabled ? */
|
|
if (ggenie.regs[0] & (1 << i))
|
|
{
|
|
/* first look if address has not already been patched */
|
|
for (j=0;j<i;j++)
|
|
{
|
|
if (ggenie.addr[i] == ggenie.addr[j])
|
|
{
|
|
/* disable code for later initialization */
|
|
ggenie.regs[0] &= ~(1 << i);
|
|
j = i;
|
|
}
|
|
}
|
|
|
|
/* save old value and patch ROM if enabled */
|
|
if (ggenie.regs[0] & (1 << i))
|
|
{
|
|
ggenie.old[i] = *(uint16 *)(cart.rom + ggenie.addr[i]);
|
|
*(uint16 *)(cart.rom + ggenie.addr[i]) = ggenie.data[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* restore old values */
|
|
for (i=0; i<6; i++)
|
|
{
|
|
/* patch is enabled ? */
|
|
if (ggenie.regs[0] & (1 << i))
|
|
{
|
|
*(uint16 *)(cart.rom + ggenie.addr[i]) = ggenie.old[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Byte write handler */
|
|
/* Note: 2nd revision of the Game Genie software use byte writes to set register values on exit */
|
|
static void ggenie_write_byte(uint32 address, uint32 data)
|
|
{
|
|
/* Register offset */
|
|
uint8 offset = (address >> 1) & 0x1f;
|
|
|
|
/* Write internal register (lower or upper BYTE) */
|
|
ggenie_write_regs(offset,data,address & 1);
|
|
}
|
|
|
|
/* Word write handler */
|
|
static void ggenie_write_word(uint32 address, uint32 data)
|
|
{
|
|
/* Register offset */
|
|
uint8 offset = (address >> 1) & 0x1f;
|
|
|
|
/* Write internal register (full WORD) */
|
|
ggenie_write_regs(offset,data,2);
|
|
}
|
|
|
|
static void ggenie_write_regs(uint8 offset, uint32 data, uint8 type)
|
|
{
|
|
/* access type */
|
|
switch (type)
|
|
{
|
|
case 0: /* upper byte write */
|
|
data = (ggenie.regs[offset] & 0x00ff) | ((data & 0xff) << 8);
|
|
break;
|
|
|
|
case 1: /* lower byte write */
|
|
data = (ggenie.regs[offset] & 0xff00) | (data & 0xff);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* update internal register */
|
|
ggenie.regs[offset] = data;
|
|
|
|
/* Mode Register */
|
|
if (offset == 0)
|
|
{
|
|
/* by default, registers are write only */
|
|
m68k_memory_map[0].read16 = NULL;
|
|
|
|
/* MODE bits */
|
|
if (data & 0x400)
|
|
{
|
|
/* $0000-$7ffff reads mapped to Cartridge ROM */
|
|
m68k_memory_map[0].base = cart.rom;
|
|
m68k_memory_map[0].read16 = NULL;
|
|
}
|
|
else
|
|
{
|
|
/* $0000-$7ffff reads mapped to Game Genie ROM */
|
|
m68k_memory_map[0].base = ggenie.rom;
|
|
m68k_memory_map[0].read16 = NULL;
|
|
|
|
if (data & 0x200)
|
|
{
|
|
/* $0000-$7ffff reads mapped to Game Genie Registers */
|
|
/* code doing this should execute in RAM so we don't need to modify base address */
|
|
m68k_memory_map[0].read16 = ggenie_read_regs;
|
|
}
|
|
}
|
|
|
|
/* LOCK bit */
|
|
if (data & 0x100)
|
|
{
|
|
/* decode patch address (ROM area only)*/
|
|
/* note: Charles's doc is wrong, first register holds bits 23-16 of patch address */
|
|
ggenie.addr[0] = ((ggenie.regs[2] & 0x3f) << 16) | ggenie.regs[3];
|
|
ggenie.addr[1] = ((ggenie.regs[5] & 0x3f) << 16) | ggenie.regs[6];
|
|
ggenie.addr[2] = ((ggenie.regs[8] & 0x3f) << 16) | ggenie.regs[9];
|
|
ggenie.addr[3] = ((ggenie.regs[11] & 0x3f) << 16) | ggenie.regs[12];
|
|
ggenie.addr[4] = ((ggenie.regs[14] & 0x3f) << 16) | ggenie.regs[15];
|
|
ggenie.addr[5] = ((ggenie.regs[17] & 0x3f) << 16) | ggenie.regs[18];
|
|
|
|
/* decode patch data */
|
|
ggenie.data[0] = ggenie.regs[4];
|
|
ggenie.data[1] = ggenie.regs[7];
|
|
ggenie.data[2] = ggenie.regs[10];
|
|
ggenie.data[3] = ggenie.regs[13];
|
|
ggenie.data[4] = ggenie.regs[16];
|
|
ggenie.data[5] = ggenie.regs[19];
|
|
|
|
/* disable internal registers */
|
|
m68k_memory_map[0].write8 = m68k_unused_8_w;
|
|
m68k_memory_map[0].write16 = m68k_unused_16_w;
|
|
|
|
/* patch ROM when GG program exits (LOCK bit set) */
|
|
/* this is done here to handle patched program reads faster & more easily */
|
|
/* on real HW, address decoding would be done on each reads */
|
|
ggenie_switch(1);
|
|
}
|
|
}
|
|
|
|
/* RESET register */
|
|
else if (offset == 1)
|
|
{
|
|
ggenie.regs[1] |= 1;
|
|
}
|
|
}
|
|
|
|
static uint32 ggenie_read_regs(uint32 address)
|
|
{
|
|
return ggenie.regs[(address >> 1) & 0x1f];
|
|
}
|
|
|