mirror of
https://github.com/ekeeke/Genesis-Plus-GX.git
synced 2024-06-02 16:48:43 +02:00
Removed state saving/loading routines
This commit is contained in:
SergioMartin86
parent
d5a8fb4232
commit
2436b16608
|
|
@ -52,7 +52,6 @@
|
|||
#include "../genesis.h"
|
||||
#include "../mem68k.h"
|
||||
#include "../membnk.h"
|
||||
#include "../state.h"
|
||||
#include "eeprom_i2c.h"
|
||||
#include "eeprom_spi.h"
|
||||
#include "megasd.h"
|
||||
|
|
@ -900,117 +899,6 @@ void md_cart_reset(int hard_reset)
|
|||
}
|
||||
}
|
||||
|
||||
int md_cart_context_save(uint8 *state)
|
||||
{
|
||||
int i;
|
||||
int bufferptr = 0;
|
||||
uint8 *base;
|
||||
|
||||
/* cartridge mapping */
|
||||
for (i=0; i<0x40; i++)
|
||||
{
|
||||
/* get base address */
|
||||
base = m68k.memory_map[i].base;
|
||||
|
||||
if (base == sram.sram)
|
||||
{
|
||||
/* SRAM */
|
||||
state[bufferptr++] = 0xff;
|
||||
}
|
||||
else if (base == boot_rom)
|
||||
{
|
||||
/* Boot ROM */
|
||||
state[bufferptr++] = 0xfe;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Cartridge ROM */
|
||||
state[bufferptr++] = ((base - cart.rom) >> 16) & 0xff;
|
||||
}
|
||||
}
|
||||
|
||||
/* hardware registers */
|
||||
save_param(cart.hw.regs, sizeof(cart.hw.regs));
|
||||
|
||||
/* SVP */
|
||||
if (svp)
|
||||
{
|
||||
save_param(svp->iram_rom, 0x800);
|
||||
save_param(svp->dram,sizeof(svp->dram));
|
||||
save_param(&svp->ssp1601,sizeof(ssp1601_t));
|
||||
}
|
||||
|
||||
/* MegaSD hardware */
|
||||
if (cart.special & HW_MEGASD)
|
||||
{
|
||||
bufferptr += megasd_context_save(&state[bufferptr]);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int md_cart_context_load(uint8 *state)
|
||||
{
|
||||
int i;
|
||||
int bufferptr = 0;
|
||||
uint8 offset;
|
||||
|
||||
/* cartridge mapping */
|
||||
for (i=0; i<0x40; i++)
|
||||
{
|
||||
/* get offset */
|
||||
offset = state[bufferptr++];
|
||||
|
||||
if (offset == 0xff)
|
||||
{
|
||||
/* SRAM */
|
||||
m68k.memory_map[i].base = sram.sram;
|
||||
m68k.memory_map[i].read8 = sram_read_byte;
|
||||
m68k.memory_map[i].read16 = sram_read_word;
|
||||
m68k.memory_map[i].write8 = sram_write_byte;
|
||||
m68k.memory_map[i].write16 = sram_write_word;
|
||||
zbank_memory_map[i].read = sram_read_byte;
|
||||
zbank_memory_map[i].write = sram_write_byte;
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
/* check if SRAM was mapped there before loading state */
|
||||
if (m68k.memory_map[i].base == sram.sram)
|
||||
{
|
||||
m68k.memory_map[i].read8 = NULL;
|
||||
m68k.memory_map[i].read16 = NULL;
|
||||
m68k.memory_map[i].write8 = m68k_unused_8_w;
|
||||
m68k.memory_map[i].write16 = m68k_unused_16_w;
|
||||
zbank_memory_map[i].read = NULL;
|
||||
zbank_memory_map[i].write = zbank_unused_w;
|
||||
}
|
||||
|
||||
/* ROM */
|
||||
m68k.memory_map[i].base = (offset == 0xfe) ? boot_rom : (cart.rom + (offset << 16));
|
||||
}
|
||||
}
|
||||
|
||||
/* hardware registers */
|
||||
load_param(cart.hw.regs, sizeof(cart.hw.regs));
|
||||
|
||||
/* SVP */
|
||||
if (svp)
|
||||
{
|
||||
load_param(svp->iram_rom, 0x800);
|
||||
load_param(svp->dram,sizeof(svp->dram));
|
||||
load_param(&svp->ssp1601,sizeof(ssp1601_t));
|
||||
}
|
||||
|
||||
/* MegaSD hardware */
|
||||
if (cart.special & HW_MEGASD)
|
||||
{
|
||||
bufferptr += megasd_context_load(&state[bufferptr]);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
/************************************************************
|
||||
MAPPER handlers
|
||||
*************************************************************/
|
||||
|
|
|
|||
|
|
@ -35,12 +35,12 @@
|
|||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
****************************************************************************************/
|
||||
#include <string.h>
|
||||
#include "../system.h"
|
||||
#include "../genesis.h"
|
||||
#include "../m68k/m68k.h"
|
||||
#include "../mem68k.h"
|
||||
#include "../membnk.h"
|
||||
#include "../state.h"
|
||||
#include "sram.h"
|
||||
|
||||
typedef struct
|
||||
|
|
@ -106,40 +106,6 @@ void megasd_reset(void)
|
|||
}
|
||||
}
|
||||
|
||||
int megasd_context_save(uint8 *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
|
||||
save_param(&megasd_hw, sizeof(megasd_hw));
|
||||
|
||||
/* save needed CD hardware state (only if not already saved) */
|
||||
if (system_hw != SYSTEM_MCD)
|
||||
{
|
||||
bufferptr += cdd_context_save(&state[bufferptr]);
|
||||
bufferptr += pcm_context_save(&state[bufferptr]);
|
||||
save_param(&scd.regs[0x36>>1].byte.h, 1);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int megasd_context_load(uint8 *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
|
||||
load_param(&megasd_hw, sizeof(megasd_hw));
|
||||
|
||||
/* load needed CD hardware state (only if not already loaded) */
|
||||
if (system_hw != SYSTEM_MCD)
|
||||
{
|
||||
bufferptr += cdd_context_load(&state[bufferptr], STATE_VERSION);
|
||||
bufferptr += pcm_context_load(&state[bufferptr]);
|
||||
load_param(&scd.regs[0x36>>1].byte.h, 1);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
/*
|
||||
Enhanced "SSF2" mapper
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -44,7 +44,6 @@
|
|||
#include <string.h>
|
||||
#include "../input_hw/terebi_oekaki.h"
|
||||
#include "../input_hw/input.h"
|
||||
#include "../state.h"
|
||||
#include "../system.h"
|
||||
#include "../loadrom.h"
|
||||
#include "../z80/z80.h"
|
||||
|
|
@ -873,118 +872,6 @@ int sms_cart_region_detect(void)
|
|||
return REGION_USA;
|
||||
}
|
||||
|
||||
int sms_cart_context_save(uint8_t *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
|
||||
/* check if cartridge ROM is disabled */
|
||||
if (io_reg[0x0E] & 0x40)
|
||||
{
|
||||
/* save Boot ROM mapper settings */
|
||||
save_param(bios_rom.fcr, 4);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* save cartridge mapper settings */
|
||||
save_param(cart_rom.fcr, 4);
|
||||
}
|
||||
|
||||
/* support for SG-1000 games with extra RAM */
|
||||
if ((cart_rom.mapper == MAPPER_RAM_8K) || (cart_rom.mapper == MAPPER_RAM_8K_EXT1))
|
||||
{
|
||||
/* 8KB extra RAM */
|
||||
save_param(work_ram + 0x2000, 0x2000);
|
||||
}
|
||||
else if (cart_rom.mapper == MAPPER_RAM_2K)
|
||||
{
|
||||
/* 2KB extra RAM */
|
||||
save_param(work_ram + 0x2000, 0x800);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int sms_cart_context_load(uint8_t *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
|
||||
/* check if cartridge ROM is disabled */
|
||||
if (io_reg[0x0E] & 0x40)
|
||||
{
|
||||
/* load Boot ROM mapper settings */
|
||||
load_param(bios_rom.fcr, 4);
|
||||
|
||||
/* set default cartridge ROM paging */
|
||||
switch (cart_rom.mapper)
|
||||
{
|
||||
case MAPPER_SEGA:
|
||||
case MAPPER_SEGA_X:
|
||||
cart_rom.fcr[0] = 0;
|
||||
cart_rom.fcr[1] = 0;
|
||||
cart_rom.fcr[2] = 1;
|
||||
cart_rom.fcr[3] = 2;
|
||||
break;
|
||||
|
||||
case MAPPER_ZEMINA_16K_32K:
|
||||
cart_rom.fcr[0] = 0;
|
||||
cart_rom.fcr[1] = 0;
|
||||
cart_rom.fcr[2] = 1;
|
||||
cart_rom.fcr[3] = 1;
|
||||
break;
|
||||
|
||||
case MAPPER_ZEMINA_4x8K:
|
||||
cart_rom.fcr[0] = 3;
|
||||
cart_rom.fcr[1] = 2;
|
||||
cart_rom.fcr[2] = 1;
|
||||
cart_rom.fcr[3] = 0;
|
||||
break;
|
||||
|
||||
case MAPPER_KOREA_8K:
|
||||
case MAPPER_MSX:
|
||||
case MAPPER_MSX_NEMESIS:
|
||||
case MAPPER_MULTI_4x8K:
|
||||
case MAPPER_MULTI_8K:
|
||||
cart_rom.fcr[0] = 0;
|
||||
cart_rom.fcr[1] = 0;
|
||||
cart_rom.fcr[2] = 0;
|
||||
cart_rom.fcr[3] = 0;
|
||||
break;
|
||||
|
||||
default:
|
||||
cart_rom.fcr[0] = 0;
|
||||
cart_rom.fcr[1] = 0;
|
||||
cart_rom.fcr[2] = 1;
|
||||
cart_rom.fcr[3] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* load cartridge mapper settings */
|
||||
load_param(cart_rom.fcr, 4);
|
||||
|
||||
/* set default BIOS ROM paging (SEGA mapper by default) */
|
||||
bios_rom.fcr[0] = 0;
|
||||
bios_rom.fcr[1] = 0;
|
||||
bios_rom.fcr[2] = 1;
|
||||
bios_rom.fcr[3] = 2;
|
||||
}
|
||||
|
||||
/* support for SG-1000 games with extra RAM */
|
||||
if ((cart_rom.mapper == MAPPER_RAM_8K) || (cart_rom.mapper == MAPPER_RAM_8K_EXT1))
|
||||
{
|
||||
/* 8KB extra RAM */
|
||||
load_param(work_ram + 0x2000, 0x2000);
|
||||
}
|
||||
else if (cart_rom.mapper == MAPPER_RAM_2K)
|
||||
{
|
||||
/* 2KB extra RAM */
|
||||
load_param(work_ram + 0x2000, 0x800);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
static void mapper_reset(void)
|
||||
{
|
||||
int i;
|
||||
|
|
|
|||
115
core/cd_hw/cdc.c
115
core/cd_hw/cdc.c
|
|
@ -38,7 +38,6 @@
|
|||
|
||||
#include <string.h>
|
||||
#include "../genesis.h"
|
||||
#include "../state.h"
|
||||
#include "../m68k/m68k.h"
|
||||
|
||||
/* IFSTAT register bitmasks */
|
||||
|
|
@ -131,120 +130,6 @@ void cdc_reset(void)
|
|||
}
|
||||
}
|
||||
|
||||
int cdc_context_save(uint8 *state)
|
||||
{
|
||||
uint8 tmp8;
|
||||
int bufferptr = 0;
|
||||
|
||||
if (cdc.dma_w == pcm_ram_dma_w)
|
||||
{
|
||||
tmp8 = 1;
|
||||
}
|
||||
else if (cdc.dma_w == prg_ram_dma_w)
|
||||
{
|
||||
tmp8 = 2;
|
||||
}
|
||||
else if (cdc.dma_w == word_ram_0_dma_w)
|
||||
{
|
||||
tmp8 = 3;
|
||||
}
|
||||
else if (cdc.dma_w == word_ram_1_dma_w)
|
||||
{
|
||||
tmp8 = 4;
|
||||
}
|
||||
else if (cdc.dma_w == word_ram_2M_dma_w)
|
||||
{
|
||||
tmp8 = 5;
|
||||
}
|
||||
else if (cdc.halted_dma_w == prg_ram_dma_w)
|
||||
{
|
||||
tmp8 = 6;
|
||||
}
|
||||
else if (cdc.halted_dma_w == word_ram_2M_dma_w)
|
||||
{
|
||||
tmp8 = 7;
|
||||
}
|
||||
else
|
||||
{
|
||||
tmp8 = 0;
|
||||
}
|
||||
|
||||
save_param(&cdc.ifstat, sizeof(cdc.ifstat));
|
||||
save_param(&cdc.ifctrl, sizeof(cdc.ifctrl));
|
||||
save_param(&cdc.dbc, sizeof(cdc.dbc));
|
||||
save_param(&cdc.dac, sizeof(cdc.dac));
|
||||
save_param(&cdc.pt, sizeof(cdc.pt));
|
||||
save_param(&cdc.wa, sizeof(cdc.wa));
|
||||
save_param(&cdc.ctrl, sizeof(cdc.ctrl));
|
||||
save_param(&cdc.head, sizeof(cdc.head));
|
||||
save_param(&cdc.stat, sizeof(cdc.stat));
|
||||
save_param(&cdc.cycles, sizeof(cdc.cycles));
|
||||
save_param(&cdc.ram, sizeof(cdc.ram));
|
||||
save_param(&tmp8, 1);
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int cdc_context_load(uint8 *state)
|
||||
{
|
||||
uint8 tmp8;
|
||||
int bufferptr = 0;
|
||||
|
||||
load_param(&cdc.ifstat, sizeof(cdc.ifstat));
|
||||
load_param(&cdc.ifctrl, sizeof(cdc.ifctrl));
|
||||
load_param(&cdc.dbc, sizeof(cdc.dbc));
|
||||
load_param(&cdc.dac, sizeof(cdc.dac));
|
||||
load_param(&cdc.pt, sizeof(cdc.pt));
|
||||
load_param(&cdc.wa, sizeof(cdc.wa));
|
||||
load_param(&cdc.ctrl, sizeof(cdc.ctrl));
|
||||
load_param(&cdc.head, sizeof(cdc.head));
|
||||
load_param(&cdc.stat, sizeof(cdc.stat));
|
||||
load_param(&cdc.cycles, sizeof(cdc.cycles));
|
||||
load_param(&cdc.ram, sizeof(cdc.ram));
|
||||
|
||||
load_param(&tmp8, 1);
|
||||
|
||||
switch (tmp8)
|
||||
{
|
||||
case 1:
|
||||
cdc.dma_w = pcm_ram_dma_w;
|
||||
cdc.halted_dma_w = 0;
|
||||
break;
|
||||
case 2:
|
||||
cdc.dma_w = prg_ram_dma_w;
|
||||
cdc.halted_dma_w = 0;
|
||||
break;
|
||||
case 3:
|
||||
cdc.dma_w = word_ram_0_dma_w;
|
||||
cdc.halted_dma_w = 0;
|
||||
break;
|
||||
case 4:
|
||||
cdc.dma_w = word_ram_1_dma_w;
|
||||
cdc.halted_dma_w = 0;
|
||||
break;
|
||||
case 5:
|
||||
cdc.dma_w = word_ram_2M_dma_w;
|
||||
cdc.halted_dma_w = 0;
|
||||
break;
|
||||
case 6:
|
||||
cdc.dma_w = 0;
|
||||
cdc.halted_dma_w = prg_ram_dma_w;
|
||||
break;
|
||||
case 7:
|
||||
cdc.dma_w = 0;
|
||||
cdc.halted_dma_w = word_ram_2M_dma_w;
|
||||
break;
|
||||
default:
|
||||
cdc.dma_w = 0;
|
||||
cdc.halted_dma_w = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
cdc.irq = ~cdc.ifstat & cdc.ifctrl & (BIT_DTEIEN | BIT_DECIEN);
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
void cdc_dma_init(void)
|
||||
{
|
||||
/* no effect if data transfer is not started */
|
||||
|
|
|
|||
145
core/cd_hw/cdd.c
145
core/cd_hw/cdd.c
|
|
@ -38,10 +38,10 @@
|
|||
|
||||
#include <config.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "../cart_hw/megasd.h"
|
||||
#include "../system.h"
|
||||
#include "../genesis.h"
|
||||
#include "../state.h"
|
||||
#include "../m68k/m68k.h"
|
||||
|
||||
#if defined(USE_LIBTREMOR) || defined(USE_LIBVORBIS)
|
||||
|
|
@ -222,149 +222,6 @@ void cdd_reset(void)
|
|||
cdd.audio[0] = cdd.audio[1] = 0;
|
||||
}
|
||||
|
||||
int cdd_context_save(uint8 *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
unsigned int offset = 0;
|
||||
|
||||
save_param(&cdd.cycles, sizeof(cdd.cycles));
|
||||
save_param(&cdd.latency, sizeof(cdd.latency));
|
||||
save_param(&cdd.index, sizeof(cdd.index));
|
||||
save_param(&cdd.lba, sizeof(cdd.lba));
|
||||
save_param(&cdd.scanOffset, sizeof(cdd.scanOffset));
|
||||
save_param(&cdd.fader, sizeof(cdd.fader));
|
||||
save_param(&cdd.status, sizeof(cdd.status));
|
||||
|
||||
/* current track is an audio track ? */
|
||||
if (cdd.toc.tracks[cdd.index].type == TYPE_AUDIO)
|
||||
{
|
||||
/* get file read offset */
|
||||
#if defined(USE_LIBCHDR)
|
||||
if (cdd.chd.file)
|
||||
{
|
||||
/* CHD file offset */
|
||||
offset = cdd.chd.hunkofs;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#if defined(USE_LIBTREMOR) || defined(USE_LIBVORBIS)
|
||||
if (cdd.toc.tracks[cdd.index].vf.seekable)
|
||||
{
|
||||
/* VORBIS file sample offset */
|
||||
offset = ov_pcm_tell(&cdd.toc.tracks[cdd.index].vf);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (cdd.toc.tracks[cdd.index].fd)
|
||||
{
|
||||
/* PCM file offset */
|
||||
offset = cdStreamTell(cdd.toc.tracks[cdd.index].fd);
|
||||
}
|
||||
}
|
||||
|
||||
save_param(&offset, sizeof(offset));
|
||||
save_param(&cdd.audio, sizeof(cdd.audio));
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int cdd_context_load(uint8 *state, char *version)
|
||||
{
|
||||
unsigned int offset, lba, index;
|
||||
int bufferptr = 0;
|
||||
|
||||
load_param(&cdd.cycles, sizeof(cdd.cycles));
|
||||
load_param(&cdd.latency, sizeof(cdd.latency));
|
||||
load_param(&index, sizeof(cdd.index));
|
||||
load_param(&lba, sizeof(cdd.lba));
|
||||
load_param(&cdd.scanOffset, sizeof(cdd.scanOffset));
|
||||
load_param(&cdd.fader, sizeof(cdd.fader));
|
||||
load_param(&cdd.status, sizeof(cdd.status));
|
||||
|
||||
/* update current sector */
|
||||
cdd.lba = lba;
|
||||
|
||||
/* support for previous state version (1.7.5) */
|
||||
if ((version[11] == 0x31) && (version[13] == 0x37) && (version[15] == 0x35))
|
||||
{
|
||||
/* current track is an audio track ? */
|
||||
if (cdd.toc.tracks[index].type == TYPE_AUDIO)
|
||||
{
|
||||
/* stay within track limits when seeking files */
|
||||
if (lba < cdd.toc.tracks[index].start)
|
||||
{
|
||||
lba = cdd.toc.tracks[index].start;
|
||||
}
|
||||
|
||||
/* seek to current track sector */
|
||||
cdd_seek_audio(index, lba);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
load_param(&offset, sizeof(offset));
|
||||
load_param(&cdd.audio, sizeof(cdd.audio));
|
||||
|
||||
/* current track is an audio track ? */
|
||||
if (cdd.toc.tracks[index].type == TYPE_AUDIO)
|
||||
{
|
||||
#if defined(USE_LIBTREMOR) || defined(USE_LIBVORBIS)
|
||||
#ifdef DISABLE_MANY_OGG_OPEN_FILES
|
||||
/* check if track index has changed */
|
||||
if (index != cdd.index)
|
||||
{
|
||||
/* close previous track VORBIS file structure to save memory */
|
||||
if (cdd.toc.tracks[cdd.index].vf.datasource)
|
||||
{
|
||||
ogg_free(cdd.index);
|
||||
}
|
||||
|
||||
/* open current track VORBIS file */
|
||||
if (cdd.toc.tracks[index].vf.seekable)
|
||||
{
|
||||
ov_open_callbacks(cdd.toc.tracks[index].fd,&cdd.toc.tracks[index].vf,0,0,cb);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
/* seek to current file read offset */
|
||||
#if defined(USE_LIBCHDR)
|
||||
if (cdd.chd.file)
|
||||
{
|
||||
/* CHD file offset */
|
||||
cdd.chd.hunkofs = offset;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#if defined(USE_LIBTREMOR) || defined(USE_LIBVORBIS)
|
||||
if (cdd.toc.tracks[index].vf.seekable)
|
||||
{
|
||||
/* VORBIS file sample offset */
|
||||
ov_pcm_seek(&cdd.toc.tracks[index].vf, offset);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (cdd.toc.tracks[index].fd)
|
||||
{
|
||||
/* PCM file offset */
|
||||
cdStreamSeek(cdd.toc.tracks[index].fd, offset, SEEK_SET);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* seek to current subcode position */
|
||||
if (cdd.toc.sub)
|
||||
{
|
||||
/* 96 bytes per sector */
|
||||
cdStreamSeek(cdd.toc.sub, lba * 96, SEEK_SET);
|
||||
}
|
||||
|
||||
/* update current track index */
|
||||
cdd.index = index;
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int cdd_load(char *filename, char *header)
|
||||
{
|
||||
char fname[256+10];
|
||||
|
|
|
|||
|
|
@ -38,7 +38,6 @@
|
|||
|
||||
#include <string.h>
|
||||
#include "../genesis.h"
|
||||
#include "../state.h"
|
||||
#include "../m68k/m68k.h"
|
||||
|
||||
/***************************************************************/
|
||||
|
|
@ -423,50 +422,6 @@ void gfx_reset(void)
|
|||
gfx.cycles = 0;
|
||||
}
|
||||
|
||||
int gfx_context_save(uint8_t *state)
|
||||
{
|
||||
uint32_t tmp32;
|
||||
int bufferptr = 0;
|
||||
|
||||
save_param(&gfx.cycles, sizeof(gfx.cycles));
|
||||
save_param(&gfx.cyclesPerLine, sizeof(gfx.cyclesPerLine));
|
||||
save_param(&gfx.dotMask, sizeof(gfx.dotMask));
|
||||
save_param(&gfx.stampShift, sizeof(gfx.stampShift));
|
||||
save_param(&gfx.mapShift, sizeof(gfx.mapShift));
|
||||
save_param(&gfx.bufferOffset, sizeof(gfx.bufferOffset));
|
||||
save_param(&gfx.bufferStart, sizeof(gfx.bufferStart));
|
||||
|
||||
tmp32 = (uint8_t *)(gfx.tracePtr) - scd.word_ram_2M;
|
||||
save_param(&tmp32, 4);
|
||||
|
||||
tmp32 = (uint8_t *)(gfx.mapPtr) - scd.word_ram_2M;
|
||||
save_param(&tmp32, 4);
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int gfx_context_load(uint8_t *state)
|
||||
{
|
||||
uint32_t tmp32;
|
||||
int bufferptr = 0;
|
||||
|
||||
load_param(&gfx.cycles, sizeof(gfx.cycles));
|
||||
load_param(&gfx.cyclesPerLine, sizeof(gfx.cyclesPerLine));
|
||||
load_param(&gfx.dotMask, sizeof(gfx.dotMask));
|
||||
load_param(&gfx.stampShift, sizeof(gfx.stampShift));
|
||||
load_param(&gfx.mapShift, sizeof(gfx.mapShift));
|
||||
load_param(&gfx.bufferOffset, sizeof(gfx.bufferOffset));
|
||||
load_param(&gfx.bufferStart, sizeof(gfx.bufferStart));
|
||||
|
||||
load_param(&tmp32, 4);
|
||||
gfx.tracePtr = (uint16_t *)(scd.word_ram_2M + tmp32);
|
||||
|
||||
load_param(&tmp32, 4);
|
||||
gfx.mapPtr = (uint16_t *)(scd.word_ram_2M + tmp32);
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
INLINE void gfx_render(uint32_t bufferIndex, uint32_t width)
|
||||
{
|
||||
uint8_t pixel_in, pixel_out;
|
||||
|
|
|
|||
|
|
@ -38,7 +38,6 @@
|
|||
|
||||
#include <config.h>
|
||||
#include <string.h>
|
||||
#include "../state.h"
|
||||
#include "../system.h"
|
||||
#include "../genesis.h"
|
||||
|
||||
|
|
@ -78,43 +77,6 @@ void pcm_reset(void)
|
|||
blip_clear(snd.blips[1]);
|
||||
}
|
||||
|
||||
int pcm_context_save(uint8_t *state)
|
||||
{
|
||||
uint8_t tmp8;
|
||||
int bufferptr = 0;
|
||||
|
||||
tmp8 = (pcm.bank - pcm.ram) >> 12;
|
||||
|
||||
save_param(pcm.chan, sizeof(pcm.chan));
|
||||
save_param(pcm.out, sizeof(pcm.out));
|
||||
save_param(&tmp8, 1);
|
||||
save_param(&pcm.enabled, sizeof(pcm.enabled));
|
||||
save_param(&pcm.status, sizeof(pcm.status));
|
||||
save_param(&pcm.index, sizeof(pcm.index));
|
||||
save_param(pcm.ram, sizeof(pcm.ram));
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int pcm_context_load(uint8_t *state)
|
||||
{
|
||||
uint8_t tmp8;
|
||||
int bufferptr = 0;
|
||||
|
||||
load_param(pcm.chan, sizeof(pcm.chan));
|
||||
load_param(pcm.out, sizeof(pcm.out));
|
||||
|
||||
load_param(&tmp8, 1);
|
||||
pcm.bank = &pcm.ram[(tmp8 & 0x0f) << 12];
|
||||
|
||||
load_param(&pcm.enabled, sizeof(pcm.enabled));
|
||||
load_param(&pcm.status, sizeof(pcm.status));
|
||||
load_param(&pcm.index, sizeof(pcm.index));
|
||||
load_param(pcm.ram, sizeof(pcm.ram));
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
void pcm_run(unsigned int length)
|
||||
{
|
||||
#ifdef LOG_PCM
|
||||
|
|
|
|||
346
core/cd_hw/scd.c
346
core/cd_hw/scd.c
|
|
@ -42,7 +42,6 @@
|
|||
#include "../m68k/m68k.h"
|
||||
#include "../mem68k.h"
|
||||
#include "../membnk.h"
|
||||
#include "../state.h"
|
||||
|
||||
/*--------------------------------------------------------------------------*/
|
||||
/* Unused area (return open bus data, i.e prefetched instruction word) */
|
||||
|
|
@ -2013,351 +2012,6 @@ void scd_end_frame(unsigned int cycles)
|
|||
s68k.poll.cycle = 0;
|
||||
}
|
||||
|
||||
int scd_context_save(uint8 *state)
|
||||
{
|
||||
uint16 tmp16;
|
||||
uint32 tmp32;
|
||||
int bufferptr = 0;
|
||||
|
||||
/* internal harware */
|
||||
save_param(scd.regs, sizeof(scd.regs));
|
||||
save_param(&scd.cycles, sizeof(scd.cycles));
|
||||
save_param(&scd.stopwatch, sizeof(scd.stopwatch));
|
||||
save_param(&scd.timer, sizeof(scd.timer));
|
||||
save_param(&scd.pending, sizeof(scd.pending));
|
||||
save_param(&scd.dmna, sizeof(scd.dmna));
|
||||
|
||||
/* GFX processor */
|
||||
bufferptr += gfx_context_save(&state[bufferptr]);
|
||||
|
||||
/* CD Data controller */
|
||||
bufferptr += cdc_context_save(&state[bufferptr]);
|
||||
|
||||
/* CD Drive processor */
|
||||
bufferptr += cdd_context_save(&state[bufferptr]);
|
||||
|
||||
/* PCM chip */
|
||||
bufferptr += pcm_context_save(&state[bufferptr]);
|
||||
|
||||
/* PRG-RAM */
|
||||
save_param(scd.prg_ram, sizeof(scd.prg_ram));
|
||||
|
||||
/* Word-RAM */
|
||||
if (scd.regs[0x03>>1].byte.l & 0x04)
|
||||
{
|
||||
/* 1M mode */
|
||||
save_param(scd.word_ram, sizeof(scd.word_ram));
|
||||
}
|
||||
else
|
||||
{
|
||||
/* 2M mode */
|
||||
save_param(scd.word_ram_2M, sizeof(scd.word_ram_2M));
|
||||
}
|
||||
|
||||
/* MAIN-CPU & SUB-CPU polling */
|
||||
save_param(&m68k.poll, sizeof(m68k.poll));
|
||||
save_param(&s68k.poll, sizeof(s68k.poll));
|
||||
|
||||
/* H-INT default vector */
|
||||
tmp16 = *(uint16 *)(m68k.memory_map[scd.cartridge.boot].base + 0x72);
|
||||
save_param(&tmp16, 2);
|
||||
|
||||
/* SUB-CPU registers */
|
||||
tmp32 = s68k_get_reg(M68K_REG_D0); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_D1); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_D2); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_D3); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_D4); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_D5); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_D6); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_D7); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_A0); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_A1); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_A2); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_A3); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_A4); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_A5); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_A6); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_A7); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_PC); save_param(&tmp32, 4);
|
||||
tmp16 = s68k_get_reg(M68K_REG_SR); save_param(&tmp16, 2);
|
||||
tmp32 = s68k_get_reg(M68K_REG_USP); save_param(&tmp32, 4);
|
||||
tmp32 = s68k_get_reg(M68K_REG_ISP); save_param(&tmp32, 4);
|
||||
|
||||
/* SUB-CPU internal state */
|
||||
save_param(&s68k.cycles, sizeof(s68k.cycles));
|
||||
save_param(&s68k.int_level, sizeof(s68k.int_level));
|
||||
save_param(&s68k.stopped, sizeof(s68k.stopped));
|
||||
|
||||
/* bootable MD cartridge */
|
||||
if (scd.cartridge.boot)
|
||||
{
|
||||
bufferptr += md_cart_context_save(&state[bufferptr]);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int scd_context_load(uint8 *state, char *version)
|
||||
{
|
||||
int i;
|
||||
uint16 tmp16;
|
||||
uint32 tmp32;
|
||||
int bufferptr = 0;
|
||||
|
||||
/* internal harware */
|
||||
load_param(scd.regs, sizeof(scd.regs));
|
||||
load_param(&scd.cycles, sizeof(scd.cycles));
|
||||
load_param(&scd.stopwatch, sizeof(scd.stopwatch));
|
||||
load_param(&scd.timer, sizeof(scd.timer));
|
||||
load_param(&scd.pending, sizeof(scd.pending));
|
||||
load_param(&scd.dmna, sizeof(scd.dmna));
|
||||
|
||||
/* GFX processor */
|
||||
bufferptr += gfx_context_load(&state[bufferptr]);
|
||||
|
||||
/* CD Data controller */
|
||||
bufferptr += cdc_context_load(&state[bufferptr]);
|
||||
|
||||
/* CD Drive processor */
|
||||
bufferptr += cdd_context_load(&state[bufferptr], version);
|
||||
|
||||
/* PCM chip */
|
||||
bufferptr += pcm_context_load(&state[bufferptr]);
|
||||
|
||||
/* PRG-RAM */
|
||||
load_param(scd.prg_ram, sizeof(scd.prg_ram));
|
||||
|
||||
/* PRG-RAM 128K bank mapped on MAIN-CPU side */
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].base = scd.prg_ram + ((scd.regs[0x03>>1].byte.l & 0xc0) << 11);
|
||||
m68k.memory_map[scd.cartridge.boot + 0x03].base = m68k.memory_map[scd.cartridge.boot + 0x02].base + 0x10000;
|
||||
|
||||
/* PRG-RAM can only be accessed from MAIN 68K & Z80 if SUB-CPU is halted (Dungeon Explorer USA version) */
|
||||
if ((scd.regs[0x00].byte.l & 0x03) != 0x01)
|
||||
{
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].read8 = m68k.memory_map[scd.cartridge.boot + 0x03].read8 = NULL;
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].read16 = m68k.memory_map[scd.cartridge.boot + 0x03].read16 = NULL;
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].write8 = m68k.memory_map[scd.cartridge.boot + 0x03].write8 = NULL;
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].write16 = m68k.memory_map[scd.cartridge.boot + 0x03].write16 = NULL;
|
||||
zbank_memory_map[scd.cartridge.boot + 0x02].read = zbank_memory_map[scd.cartridge.boot + 0x03].read = NULL;
|
||||
zbank_memory_map[scd.cartridge.boot + 0x02].write = zbank_memory_map[scd.cartridge.boot + 0x03].write = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].read8 = m68k.memory_map[scd.cartridge.boot + 0x03].read8 = m68k_read_bus_8;
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].read16 = m68k.memory_map[scd.cartridge.boot + 0x03].read16 = m68k_read_bus_16;
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].write8 = m68k.memory_map[scd.cartridge.boot + 0x03].write8 = m68k_unused_8_w;
|
||||
m68k.memory_map[scd.cartridge.boot + 0x02].write16 = m68k.memory_map[scd.cartridge.boot + 0x03].write16 = m68k_unused_16_w;
|
||||
zbank_memory_map[scd.cartridge.boot + 0x02].read = zbank_memory_map[scd.cartridge.boot + 0x03].read = zbank_unused_r;
|
||||
zbank_memory_map[scd.cartridge.boot + 0x02].write = zbank_memory_map[scd.cartridge.boot + 0x03].write = zbank_unused_w;
|
||||
}
|
||||
|
||||
/* Word-RAM */
|
||||
if (scd.regs[0x03>>1].byte.l & 0x04)
|
||||
{
|
||||
/* 1M Mode */
|
||||
load_param(scd.word_ram, sizeof(scd.word_ram));
|
||||
|
||||
if (scd.regs[0x03>>1].byte.l & 0x01)
|
||||
{
|
||||
/* Word-RAM 1 assigned to MAIN-CPU */
|
||||
for (i=scd.cartridge.boot+0x20; i<scd.cartridge.boot+0x22; i++)
|
||||
{
|
||||
/* Word-RAM 1 data mapped at $200000-$21FFFF */
|
||||
m68k.memory_map[i].base = scd.word_ram[1] + ((i & 0x01) << 16);
|
||||
m68k.memory_map[i].read8 = NULL;
|
||||
m68k.memory_map[i].read16 = NULL;
|
||||
m68k.memory_map[i].write8 = NULL;
|
||||
m68k.memory_map[i].write16 = NULL;
|
||||
zbank_memory_map[i].read = NULL;
|
||||
zbank_memory_map[i].write = NULL;
|
||||
}
|
||||
|
||||
for (i=scd.cartridge.boot+0x22; i<scd.cartridge.boot+0x24; i++)
|
||||
{
|
||||
/* VRAM cell image mapped at $220000-$23FFFF */
|
||||
m68k.memory_map[i].read8 = cell_ram_1_read8;
|
||||
m68k.memory_map[i].read16 = cell_ram_1_read16;
|
||||
m68k.memory_map[i].write8 = cell_ram_1_write8;
|
||||
m68k.memory_map[i].write16 = cell_ram_1_write16;
|
||||
zbank_memory_map[i].read = cell_ram_1_read8;
|
||||
zbank_memory_map[i].write = cell_ram_1_write8;
|
||||
}
|
||||
|
||||
/* Word-RAM 0 assigned to SUB-CPU */
|
||||
for (i=0x08; i<0x0c; i++)
|
||||
{
|
||||
/* DOT image mapped at $080000-$0BFFFF */
|
||||
s68k.memory_map[i].read8 = dot_ram_0_read8;
|
||||
s68k.memory_map[i].read16 = dot_ram_0_read16;
|
||||
s68k.memory_map[i].write8 = dot_ram_0_write8;
|
||||
s68k.memory_map[i].write16 = dot_ram_0_write16;
|
||||
}
|
||||
|
||||
for (i=0x0c; i<0x0e; i++)
|
||||
{
|
||||
/* Word-RAM 0 data mapped at $0C0000-$0DFFFF */
|
||||
s68k.memory_map[i].base = scd.word_ram[0] + ((i & 0x01) << 16);
|
||||
s68k.memory_map[i].read8 = NULL;
|
||||
s68k.memory_map[i].read16 = NULL;
|
||||
s68k.memory_map[i].write8 = NULL;
|
||||
s68k.memory_map[i].write16 = NULL;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Word-RAM 0 assigned to MAIN-CPU */
|
||||
for (i=scd.cartridge.boot+0x20; i<scd.cartridge.boot+0x22; i++)
|
||||
{
|
||||
/* Word-RAM 0 data mapped at $200000-$21FFFF */
|
||||
m68k.memory_map[i].base = scd.word_ram[0] + ((i & 0x01) << 16);
|
||||
m68k.memory_map[i].read8 = NULL;
|
||||
m68k.memory_map[i].read16 = NULL;
|
||||
m68k.memory_map[i].write8 = NULL;
|
||||
m68k.memory_map[i].write16 = NULL;
|
||||
zbank_memory_map[i].read = NULL;
|
||||
zbank_memory_map[i].write = NULL;
|
||||
}
|
||||
|
||||
for (i=scd.cartridge.boot+0x22; i<scd.cartridge.boot+0x24; i++)
|
||||
{
|
||||
/* VRAM cell image mapped at $220000-$23FFFF */
|
||||
m68k.memory_map[i].read8 = cell_ram_0_read8;
|
||||
m68k.memory_map[i].read16 = cell_ram_0_read16;
|
||||
m68k.memory_map[i].write8 = cell_ram_0_write8;
|
||||
m68k.memory_map[i].write16 = cell_ram_0_write16;
|
||||
zbank_memory_map[i].read = cell_ram_0_read8;
|
||||
zbank_memory_map[i].write = cell_ram_0_write8;
|
||||
}
|
||||
|
||||
/* Word-RAM 1 assigned to SUB-CPU */
|
||||
for (i=0x08; i<0x0c; i++)
|
||||
{
|
||||
/* DOT image mapped at $080000-$0BFFFF */
|
||||
s68k.memory_map[i].read8 = dot_ram_1_read8;
|
||||
s68k.memory_map[i].read16 = dot_ram_1_read16;
|
||||
s68k.memory_map[i].write8 = dot_ram_1_write8;
|
||||
s68k.memory_map[i].write16 = dot_ram_1_write16;
|
||||
}
|
||||
|
||||
for (i=0x0c; i<0x0e; i++)
|
||||
{
|
||||
/* Word-RAM 1 data mapped at $0C0000-$0DFFFF */
|
||||
s68k.memory_map[i].base = scd.word_ram[1] + ((i & 0x01) << 16);
|
||||
s68k.memory_map[i].read8 = NULL;
|
||||
s68k.memory_map[i].read16 = NULL;
|
||||
s68k.memory_map[i].write8 = NULL;
|
||||
s68k.memory_map[i].write16 = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* 2M mode */
|
||||
load_param(scd.word_ram_2M, sizeof(scd.word_ram_2M));
|
||||
|
||||
/* check RET bit */
|
||||
if (scd.regs[0x03>>1].byte.l & 0x01)
|
||||
{
|
||||
/* MAIN-CPU: $200000-$23FFFF is mapped to 256K Word-RAM */
|
||||
for (i=scd.cartridge.boot+0x20; i<scd.cartridge.boot+0x24; i++)
|
||||
{
|
||||
m68k.memory_map[i].base = scd.word_ram_2M + ((i & 0x03) << 16);
|
||||
m68k.memory_map[i].read8 = NULL;
|
||||
m68k.memory_map[i].read16 = NULL;
|
||||
m68k.memory_map[i].write8 = NULL;
|
||||
m68k.memory_map[i].write16 = NULL;
|
||||
zbank_memory_map[i].read = NULL;
|
||||
zbank_memory_map[i].write = NULL;
|
||||
}
|
||||
|
||||
/* SUB-CPU: access to Word-RAM at $080000-$0BFFFF is locked (/DTACK not asserted) */
|
||||
for (i=0x08; i<0x0c; i++)
|
||||
{
|
||||
s68k.memory_map[i].read8 = s68k_lockup_r_8;
|
||||
s68k.memory_map[i].read16 = s68k_lockup_r_16;
|
||||
s68k.memory_map[i].write8 = s68k_lockup_w_8;
|
||||
s68k.memory_map[i].write16 = s68k_lockup_w_16;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* MAIN-CPU: $200000-$23FFFF is unmapped */
|
||||
for (i=scd.cartridge.boot+0x20; i<scd.cartridge.boot+0x24; i++)
|
||||
{
|
||||
m68k.memory_map[i].base = scd.word_ram_2M + ((i & 0x03) << 16);
|
||||
m68k.memory_map[i].read8 = m68k_read_bus_8;
|
||||
m68k.memory_map[i].read16 = m68k_read_bus_16;
|
||||
m68k.memory_map[i].write8 = m68k_unused_8_w;
|
||||
m68k.memory_map[i].write16 = m68k_unused_16_w;
|
||||
zbank_memory_map[i].read = zbank_unused_r;
|
||||
zbank_memory_map[i].write = zbank_unused_w;
|
||||
}
|
||||
|
||||
/* SUB-CPU: access to Word-RAM at $080000-$0BFFFF is unlocked (/DTACK asserted) */
|
||||
for (i=0x08; i<0x0c; i++)
|
||||
{
|
||||
s68k.memory_map[i].read8 = NULL;
|
||||
s68k.memory_map[i].read16 = NULL;
|
||||
s68k.memory_map[i].write8 = NULL;
|
||||
s68k.memory_map[i].write16 = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* SUB-CPU: $0C0000-$0DFFFF is unmapped */
|
||||
for (i=0x0c; i<0x0e; i++)
|
||||
{
|
||||
s68k.memory_map[i].read8 = s68k_read_bus_8;
|
||||
s68k.memory_map[i].read16 = s68k_read_bus_16;
|
||||
s68k.memory_map[i].write8 = s68k_unused_8_w;
|
||||
s68k.memory_map[i].write16 = s68k_unused_16_w;
|
||||
}
|
||||
}
|
||||
|
||||
/* MAIN-CPU & SUB-CPU polling */
|
||||
load_param(&m68k.poll, sizeof(m68k.poll));
|
||||
load_param(&s68k.poll, sizeof(s68k.poll));
|
||||
|
||||
/* H-INT default vector */
|
||||
load_param(&tmp16, 2);
|
||||
*(uint16 *)(m68k.memory_map[scd.cartridge.boot].base + 0x72) = tmp16;
|
||||
|
||||
/* SUB-CPU registers */
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_D0, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_D1, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_D2, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_D3, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_D4, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_D5, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_D6, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_D7, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_A0, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_A1, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_A2, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_A3, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_A4, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_A5, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_A6, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_A7, tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_PC, tmp32);
|
||||
load_param(&tmp16, 2); s68k_set_reg(M68K_REG_SR, tmp16);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_USP,tmp32);
|
||||
load_param(&tmp32, 4); s68k_set_reg(M68K_REG_ISP,tmp32);
|
||||
|
||||
/* SUB-CPU internal state */
|
||||
load_param(&s68k.cycles, sizeof(s68k.cycles));
|
||||
load_param(&s68k.int_level, sizeof(s68k.int_level));
|
||||
load_param(&s68k.stopped, sizeof(s68k.stopped));
|
||||
|
||||
/* bootable MD cartridge hardware */
|
||||
if (scd.cartridge.boot)
|
||||
{
|
||||
bufferptr += md_cart_context_load(&state[bufferptr]);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int scd_68k_irq_ack(int level)
|
||||
{
|
||||
#ifdef LOG_SCD
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@
|
|||
|
||||
#include <config.h>
|
||||
#include "../system.h"
|
||||
#include "../state.h"
|
||||
#include "blip_buf.h"
|
||||
#include "psg.h"
|
||||
|
||||
|
|
@ -143,88 +142,6 @@ void psg_reset(void)
|
|||
psg.clocks = 0;
|
||||
}
|
||||
|
||||
int psg_context_save(uint8_t *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
|
||||
save_param(&psg.clocks,sizeof(psg.clocks));
|
||||
save_param(&psg.latch,sizeof(psg.latch));
|
||||
save_param(&psg.noiseShiftValue,sizeof(psg.noiseShiftValue));
|
||||
save_param(psg.regs,sizeof(psg.regs));
|
||||
save_param(psg.freqInc,sizeof(psg.freqInc));
|
||||
save_param(psg.freqCounter,sizeof(psg.freqCounter));
|
||||
save_param(psg.polarity,sizeof(psg.polarity));
|
||||
save_param(psg.chanOut,sizeof(psg.chanOut));
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int psg_context_load(uint8_t *state)
|
||||
{
|
||||
int delta[2];
|
||||
int i, bufferptr = 0;
|
||||
|
||||
/* initialize delta with current noise channel output */
|
||||
if (psg.noiseShiftValue & 1)
|
||||
{
|
||||
delta[0] = -psg.chanOut[3][0];
|
||||
delta[1] = -psg.chanOut[3][1];
|
||||
}
|
||||
else
|
||||
{
|
||||
delta[0] = 0;
|
||||
delta[1] = 0;
|
||||
}
|
||||
|
||||
/* add current tone channels output */
|
||||
for (i=0; i<3; i++)
|
||||
{
|
||||
if (psg.polarity[i] > 0)
|
||||
{
|
||||
delta[0] -= psg.chanOut[i][0];
|
||||
delta[1] -= psg.chanOut[i][1];
|
||||
}
|
||||
}
|
||||
|
||||
load_param(&psg.clocks,sizeof(psg.clocks));
|
||||
load_param(&psg.latch,sizeof(psg.latch));
|
||||
load_param(&psg.noiseShiftValue,sizeof(psg.noiseShiftValue));
|
||||
load_param(psg.regs,sizeof(psg.regs));
|
||||
load_param(psg.freqInc,sizeof(psg.freqInc));
|
||||
load_param(psg.freqCounter,sizeof(psg.freqCounter));
|
||||
load_param(psg.polarity,sizeof(psg.polarity));
|
||||
load_param(psg.chanOut,sizeof(psg.chanOut));
|
||||
|
||||
/* add noise channel output variation */
|
||||
if (psg.noiseShiftValue & 1)
|
||||
{
|
||||
delta[0] += psg.chanOut[3][0];
|
||||
delta[1] += psg.chanOut[3][1];
|
||||
}
|
||||
|
||||
/* add tone channels output variation */
|
||||
for (i=0; i<3; i++)
|
||||
{
|
||||
if (psg.polarity[i] > 0)
|
||||
{
|
||||
delta[0] += psg.chanOut[i][0];
|
||||
delta[1] += psg.chanOut[i][1];
|
||||
}
|
||||
}
|
||||
|
||||
/* update mixed channels output */
|
||||
if (config.hq_psg)
|
||||
{
|
||||
blip_add_delta(snd.blips[0], psg.clocks, delta[0], delta[1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
blip_add_delta_fast(snd.blips[0], psg.clocks, delta[0], delta[1]);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
void psg_write(unsigned int clocks, unsigned int data)
|
||||
{
|
||||
int index;
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@
|
|||
#include "../system.h"
|
||||
#include "../genesis.h"
|
||||
#include "../macros.h"
|
||||
#include "../state.h"
|
||||
#include "blip_buf.h"
|
||||
#include "psg.h"
|
||||
#include "ym2413.h"
|
||||
|
|
@ -479,103 +478,3 @@ int sound_update(unsigned int cycles)
|
|||
return blip_samples_avail(snd.blips[0]);
|
||||
}
|
||||
|
||||
int sound_context_save(uint8_t *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
|
||||
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
#ifdef HAVE_YM3438_CORE
|
||||
save_param(&config.ym3438, sizeof(config.ym3438));
|
||||
if (config.ym3438)
|
||||
{
|
||||
save_param(&ym3438, sizeof(ym3438));
|
||||
save_param(&ym3438_accm, sizeof(ym3438_accm));
|
||||
save_param(&ym3438_sample, sizeof(ym3438_sample));
|
||||
save_param(&ym3438_cycles, sizeof(ym3438_cycles));
|
||||
}
|
||||
else
|
||||
{
|
||||
bufferptr += YM2612SaveContext(state + sizeof(config.ym3438));
|
||||
}
|
||||
#else
|
||||
bufferptr = YM2612SaveContext(state);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef HAVE_OPLL_CORE
|
||||
save_param(&config.opll, sizeof(config.opll));
|
||||
if (config.opll)
|
||||
{
|
||||
save_param(&opll, sizeof(opll));
|
||||
save_param(&opll_accm, sizeof(opll_accm));
|
||||
save_param(&opll_sample, sizeof(opll_sample));
|
||||
save_param(&opll_cycles, sizeof(opll_cycles));
|
||||
save_param(&opll_status, sizeof(opll_status));
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
save_param(YM2413GetContextPtr(),YM2413GetContextSize());
|
||||
}
|
||||
}
|
||||
|
||||
bufferptr += psg_context_save(&state[bufferptr]);
|
||||
|
||||
save_param(&fm_cycles_start,sizeof(fm_cycles_start));
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int sound_context_load(uint8_t *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
|
||||
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
#ifdef HAVE_YM3438_CORE
|
||||
uint8_t config_ym3438;
|
||||
load_param(&config_ym3438, sizeof(config_ym3438));
|
||||
if (config_ym3438)
|
||||
{
|
||||
load_param(&ym3438, sizeof(ym3438));
|
||||
load_param(&ym3438_accm, sizeof(ym3438_accm));
|
||||
load_param(&ym3438_sample, sizeof(ym3438_sample));
|
||||
load_param(&ym3438_cycles, sizeof(ym3438_cycles));
|
||||
}
|
||||
else
|
||||
{
|
||||
bufferptr += YM2612LoadContext(state + sizeof(config_ym3438));
|
||||
}
|
||||
#else
|
||||
bufferptr = YM2612LoadContext(state);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef HAVE_OPLL_CORE
|
||||
uint8_t config_opll;
|
||||
load_param(&config_opll, sizeof(config_opll));
|
||||
if (config_opll)
|
||||
{
|
||||
load_param(&opll, sizeof(opll));
|
||||
load_param(&opll_accm, sizeof(opll_accm));
|
||||
load_param(&opll_sample, sizeof(opll_sample));
|
||||
load_param(&opll_cycles, sizeof(opll_cycles));
|
||||
load_param(&opll_status, sizeof(opll_status));
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
load_param(YM2413GetContextPtr(),YM2413GetContextSize());
|
||||
}
|
||||
}
|
||||
|
||||
bufferptr += psg_context_load(&state[bufferptr]);
|
||||
|
||||
load_param(&fm_cycles_start,sizeof(fm_cycles_start));
|
||||
fm_cycles_count = fm_cycles_start;
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -151,7 +151,6 @@
|
|||
#include <string.h>
|
||||
#include "../macros.h"
|
||||
#include "../genesis.h"
|
||||
#include "../state.h"
|
||||
#include "ym2612.h"
|
||||
|
||||
/* envelope generator */
|
||||
|
|
@ -2210,56 +2209,3 @@ void YM2612Config(int type)
|
|||
}
|
||||
}
|
||||
|
||||
int YM2612LoadContext(unsigned char *state)
|
||||
{
|
||||
int c,s;
|
||||
uint8_t index;
|
||||
int bufferptr = 0;
|
||||
|
||||
/* restore YM2612 context */
|
||||
load_param(&ym2612, sizeof(ym2612));
|
||||
|
||||
/* restore DT table address pointer for each channel slots */
|
||||
for (c=0; c<6; c++)
|
||||
{
|
||||
for (s=0; s<4; s++)
|
||||
{
|
||||
load_param(&index,sizeof(index));
|
||||
bufferptr += sizeof(index);
|
||||
ym2612.CH[c].SLOT[s].DT = ym2612.OPN.ST.dt_tab[index&7];
|
||||
}
|
||||
}
|
||||
|
||||
/* restore outputs connections */
|
||||
setup_connection(&ym2612.CH[0],0);
|
||||
setup_connection(&ym2612.CH[1],1);
|
||||
setup_connection(&ym2612.CH[2],2);
|
||||
setup_connection(&ym2612.CH[3],3);
|
||||
setup_connection(&ym2612.CH[4],4);
|
||||
setup_connection(&ym2612.CH[5],5);
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int YM2612SaveContext(unsigned char *state)
|
||||
{
|
||||
int c,s;
|
||||
uint8_t index;
|
||||
int bufferptr = 0;
|
||||
|
||||
/* save YM2612 context */
|
||||
save_param(&ym2612, sizeof(ym2612));
|
||||
|
||||
/* save DT table index for each channel slots */
|
||||
for (c=0; c<6; c++)
|
||||
{
|
||||
for (s=0; s<4; s++)
|
||||
{
|
||||
index = (ym2612.CH[c].SLOT[s].DT - ym2612.OPN.ST.dt_tab[0]) >> 5;
|
||||
save_param(&index,sizeof(index));
|
||||
bufferptr += sizeof(index);
|
||||
}
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
|
|
|||
294
core/state.c
294
core/state.c
|
|
@ -1,294 +0,0 @@
|
|||
/***************************************************************************************
|
||||
* Genesis Plus
|
||||
* Savestate support
|
||||
*
|
||||
* Copyright (C) 2007-2021 Eke-Eke (Genesis Plus GX)
|
||||
*
|
||||
* Redistribution and use of this code or any derivative works are permitted
|
||||
* provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions may not be sold, nor may they be used in a commercial
|
||||
* product or activity.
|
||||
*
|
||||
* - Redistributions that are modified from the original source must include the
|
||||
* complete source code, including the source code for all components used by a
|
||||
* binary built from the modified sources. However, as a special exception, the
|
||||
* source code distributed need not include anything that is normally distributed
|
||||
* (in either source or binary form) with the major components (compiler, kernel,
|
||||
* and so on) of the operating system on which the executable runs, unless that
|
||||
* component itself accompanies the executable.
|
||||
*
|
||||
* - Redistributions must reproduce the above copyright notice, this list of
|
||||
* conditions and the following disclaimer in the documentation and/or other
|
||||
* materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
****************************************************************************************/
|
||||
|
||||
#include <config.h>
|
||||
#include "m68k/m68k.h"
|
||||
#include "z80/z80.h"
|
||||
#include "sound/sound.h"
|
||||
#include "sound/psg.h"
|
||||
#include "system.h"
|
||||
#include "genesis.h"
|
||||
#include "vdp_ctrl.h"
|
||||
#include "mem68k.h"
|
||||
#include "membnk.h"
|
||||
#include "io_ctrl.h"
|
||||
#include "state.h"
|
||||
|
||||
int state_load(unsigned char *state)
|
||||
{
|
||||
int i, bufferptr = 0;
|
||||
|
||||
/* signature check (GENPLUS-GX x.x.x) */
|
||||
char version[17];
|
||||
load_param(version,16);
|
||||
version[16] = 0;
|
||||
if (memcmp(version,STATE_VERSION,11))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* version check */
|
||||
if ((version[11] < 0x31) || (version[13] < 0x37) || (version[15] < 0x35))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* reset system */
|
||||
system_reset();
|
||||
|
||||
/* enable VDP access for TMSS systems */
|
||||
for (i=0xc0; i<0xe0; i+=8)
|
||||
{
|
||||
m68k.memory_map[i].read8 = vdp_read_byte;
|
||||
m68k.memory_map[i].read16 = vdp_read_word;
|
||||
m68k.memory_map[i].write8 = vdp_write_byte;
|
||||
m68k.memory_map[i].write16 = vdp_write_word;
|
||||
zbank_memory_map[i].read = zbank_read_vdp;
|
||||
zbank_memory_map[i].write = zbank_write_vdp;
|
||||
}
|
||||
|
||||
/* GENESIS */
|
||||
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
load_param(work_ram, sizeof(work_ram));
|
||||
load_param(zram, sizeof(zram));
|
||||
load_param(&zstate, sizeof(zstate));
|
||||
load_param(&zbank, sizeof(zbank));
|
||||
if (zstate == 3)
|
||||
{
|
||||
m68k.memory_map[0xa0].read8 = z80_read_byte;
|
||||
m68k.memory_map[0xa0].read16 = z80_read_word;
|
||||
m68k.memory_map[0xa0].write8 = z80_write_byte;
|
||||
m68k.memory_map[0xa0].write16 = z80_write_word;
|
||||
}
|
||||
else
|
||||
{
|
||||
m68k.memory_map[0xa0].read8 = m68k_read_bus_8;
|
||||
m68k.memory_map[0xa0].read16 = m68k_read_bus_16;
|
||||
m68k.memory_map[0xa0].write8 = m68k_unused_8_w;
|
||||
m68k.memory_map[0xa0].write16 = m68k_unused_16_w;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
load_param(work_ram, 0x2000);
|
||||
}
|
||||
|
||||
/* IO */
|
||||
load_param(io_reg, sizeof(io_reg));
|
||||
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
io_reg[0] = region_code | 0x20 | (config.bios & 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
io_reg[0] = 0x80 | (region_code >> 1);
|
||||
}
|
||||
|
||||
/* VDP */
|
||||
bufferptr += vdp_context_load(&state[bufferptr]);
|
||||
|
||||
/* SOUND */
|
||||
bufferptr += sound_context_load(&state[bufferptr]);
|
||||
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
psg_config(0, config.psg_preamp, 0xff);
|
||||
}
|
||||
else
|
||||
{
|
||||
psg_config(0, config.psg_preamp, io_reg[6]);
|
||||
}
|
||||
|
||||
/* 68000 */
|
||||
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
uint16 tmp16;
|
||||
uint32 tmp32;
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D0, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D1, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D2, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D3, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D4, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D5, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D6, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D7, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A0, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A1, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A2, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A3, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A4, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A5, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A6, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A7, tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_PC, tmp32);
|
||||
load_param(&tmp16, 2); m68k_set_reg(M68K_REG_SR, tmp16);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_USP,tmp32);
|
||||
load_param(&tmp32, 4); m68k_set_reg(M68K_REG_ISP,tmp32);
|
||||
|
||||
load_param(&m68k.cycles, sizeof(m68k.cycles));
|
||||
load_param(&m68k.int_level, sizeof(m68k.int_level));
|
||||
load_param(&m68k.stopped, sizeof(m68k.stopped));
|
||||
}
|
||||
|
||||
/* Z80 */
|
||||
load_param(&Z80, sizeof(Z80_Regs));
|
||||
Z80.irq_callback = z80_irq_callback;
|
||||
|
||||
/* Extra HW */
|
||||
if (system_hw == SYSTEM_MCD)
|
||||
{
|
||||
/* handle case of MD cartridge using or not CD hardware */
|
||||
char id[5];
|
||||
load_param(id,4);
|
||||
id[4] = 0;
|
||||
|
||||
/* check if CD hardware was enabled before attempting to restore */
|
||||
if (memcmp(id,"SCD!",4))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* CD hardware */
|
||||
bufferptr += scd_context_load(&state[bufferptr], version);
|
||||
}
|
||||
else if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
/* MD cartridge hardware */
|
||||
bufferptr += md_cart_context_load(&state[bufferptr]);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* MS cartridge hardware */
|
||||
bufferptr += sms_cart_context_load(&state[bufferptr]);
|
||||
sms_cart_switch(~io_reg[0x0E]);
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int state_save(unsigned char *state)
|
||||
{
|
||||
/* buffer size */
|
||||
int bufferptr = 0;
|
||||
|
||||
/* version string */
|
||||
char version[16];
|
||||
memcpy(version,STATE_VERSION,16);
|
||||
save_param(version, 16);
|
||||
|
||||
/* GENESIS */
|
||||
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
save_param(work_ram, sizeof(work_ram));
|
||||
save_param(zram, sizeof(zram));
|
||||
save_param(&zstate, sizeof(zstate));
|
||||
save_param(&zbank, sizeof(zbank));
|
||||
}
|
||||
else
|
||||
{
|
||||
save_param(work_ram, 0x2000);
|
||||
}
|
||||
|
||||
/* IO */
|
||||
save_param(io_reg, sizeof(io_reg));
|
||||
|
||||
/* VDP */
|
||||
bufferptr += vdp_context_save(&state[bufferptr]);
|
||||
|
||||
/* SOUND */
|
||||
bufferptr += sound_context_save(&state[bufferptr]);
|
||||
|
||||
/* 68000 */
|
||||
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
uint16 tmp16;
|
||||
uint32 tmp32;
|
||||
tmp32 = m68k_get_reg(M68K_REG_D0); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_D1); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_D2); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_D3); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_D4); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_D5); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_D6); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_D7); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_A0); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_A1); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_A2); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_A3); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_A4); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_A5); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_A6); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_A7); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_PC); save_param(&tmp32, 4);
|
||||
tmp16 = m68k_get_reg(M68K_REG_SR); save_param(&tmp16, 2);
|
||||
tmp32 = m68k_get_reg(M68K_REG_USP); save_param(&tmp32, 4);
|
||||
tmp32 = m68k_get_reg(M68K_REG_ISP); save_param(&tmp32, 4);
|
||||
|
||||
save_param(&m68k.cycles, sizeof(m68k.cycles));
|
||||
save_param(&m68k.int_level, sizeof(m68k.int_level));
|
||||
save_param(&m68k.stopped, sizeof(m68k.stopped));
|
||||
}
|
||||
|
||||
/* Z80 */
|
||||
save_param(&Z80, sizeof(Z80_Regs));
|
||||
|
||||
/* External HW */
|
||||
if (system_hw == SYSTEM_MCD)
|
||||
{
|
||||
/* CD hardware ID flag */
|
||||
char id[4];
|
||||
memcpy(id,"SCD!",4);
|
||||
save_param(id, 4);
|
||||
|
||||
/* CD hardware */
|
||||
bufferptr += scd_context_save(&state[bufferptr]);
|
||||
}
|
||||
else if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
|
||||
{
|
||||
/* MD cartridge hardware */
|
||||
bufferptr += md_cart_context_save(&state[bufferptr]);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* MS cartridge hardware */
|
||||
bufferptr += sms_cart_context_save(&state[bufferptr]);
|
||||
}
|
||||
|
||||
/* return total size */
|
||||
return bufferptr;
|
||||
}
|
||||
56
core/state.h
56
core/state.h
|
|
@ -1,56 +0,0 @@
|
|||
/***************************************************************************************
|
||||
* Genesis Plus
|
||||
* Savestate support
|
||||
*
|
||||
* Copyright (C) 2007-2021 Eke-Eke (Genesis Plus GX)
|
||||
*
|
||||
* Redistribution and use of this code or any derivative works are permitted
|
||||
* provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions may not be sold, nor may they be used in a commercial
|
||||
* product or activity.
|
||||
*
|
||||
* - Redistributions that are modified from the original source must include the
|
||||
* complete source code, including the source code for all components used by a
|
||||
* binary built from the modified sources. However, as a special exception, the
|
||||
* source code distributed need not include anything that is normally distributed
|
||||
* (in either source or binary form) with the major components (compiler, kernel,
|
||||
* and so on) of the operating system on which the executable runs, unless that
|
||||
* component itself accompanies the executable.
|
||||
*
|
||||
* - Redistributions must reproduce the above copyright notice, this list of
|
||||
* conditions and the following disclaimer in the documentation and/or other
|
||||
* materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
****************************************************************************************/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#define STATE_SIZE 0xfd000
|
||||
#define STATE_VERSION "GENPLUS-GX 1.7.6"
|
||||
|
||||
#define load_param(param, size) \
|
||||
memcpy(param, &state[bufferptr], size); \
|
||||
bufferptr+= size;
|
||||
|
||||
#define save_param(param, size) \
|
||||
memcpy(&state[bufferptr], param, size); \
|
||||
bufferptr+= size;
|
||||
|
||||
/* Function prototypes */
|
||||
extern int state_load(unsigned char *state);
|
||||
extern int state_save(unsigned char *state);
|
||||
132
core/vdp_ctrl.c
132
core/vdp_ctrl.c
|
|
@ -44,7 +44,6 @@
|
|||
#include "cart_hw/svp/svp.h"
|
||||
#include "m68k/m68k.h"
|
||||
#include "z80/z80.h"
|
||||
#include "state.h"
|
||||
#include "hvc.h"
|
||||
#include "system.h"
|
||||
#include "genesis.h"
|
||||
|
|
@ -465,137 +464,6 @@ void vdp_reset(void)
|
|||
color_update_m4(0x40, 0x00);
|
||||
}
|
||||
|
||||
int vdp_context_save(uint8 *state)
|
||||
{
|
||||
int bufferptr = 0;
|
||||
|
||||
save_param(sat, sizeof(sat));
|
||||
save_param(vram, sizeof(vram));
|
||||
save_param(cram, sizeof(cram));
|
||||
save_param(vsram, sizeof(vsram));
|
||||
save_param(reg, sizeof(reg));
|
||||
save_param(&addr, sizeof(addr));
|
||||
save_param(&addr_latch, sizeof(addr_latch));
|
||||
save_param(&code, sizeof(code));
|
||||
save_param(&pending, sizeof(pending));
|
||||
save_param(&status, sizeof(status));
|
||||
save_param(&dmafill, sizeof(dmafill));
|
||||
save_param(&fifo_idx, sizeof(fifo_idx));
|
||||
save_param(&fifo, sizeof(fifo));
|
||||
save_param(&h_counter, sizeof(h_counter));
|
||||
save_param(&hint_pending, sizeof(hint_pending));
|
||||
save_param(&vint_pending, sizeof(vint_pending));
|
||||
save_param(&dma_length, sizeof(dma_length));
|
||||
save_param(&dma_type, sizeof(dma_type));
|
||||
save_param(&dma_src, sizeof(dma_src));
|
||||
save_param(&cached_write, sizeof(cached_write));
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
int vdp_context_load(uint8 *state)
|
||||
{
|
||||
int i, bufferptr = 0;
|
||||
uint8 temp_reg[0x20];
|
||||
|
||||
load_param(sat, sizeof(sat));
|
||||
load_param(vram, sizeof(vram));
|
||||
load_param(cram, sizeof(cram));
|
||||
load_param(vsram, sizeof(vsram));
|
||||
load_param(temp_reg, sizeof(temp_reg));
|
||||
|
||||
/* restore VDP registers */
|
||||
if (system_hw < SYSTEM_MD)
|
||||
{
|
||||
if (system_hw >= SYSTEM_MARKIII)
|
||||
{
|
||||
for (i=0;i<0x10;i++)
|
||||
{
|
||||
pending = 1;
|
||||
addr_latch = temp_reg[i];
|
||||
vdp_sms_ctrl_w(0x80 | i);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* TMS-99xx registers are updated directly to prevent spurious 4K->16K VRAM switching */
|
||||
for (i=0;i<0x08;i++)
|
||||
{
|
||||
reg[i] = temp_reg[i];
|
||||
}
|
||||
|
||||
/* Rendering mode */
|
||||
render_bg = render_bg_modes[((reg[0] & 0x02) | (reg[1] & 0x18)) >> 1];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=0;i<0x20;i++)
|
||||
{
|
||||
vdp_reg_w(i, temp_reg[i], 0);
|
||||
}
|
||||
}
|
||||
|
||||
load_param(&addr, sizeof(addr));
|
||||
load_param(&addr_latch, sizeof(addr_latch));
|
||||
load_param(&code, sizeof(code));
|
||||
load_param(&pending, sizeof(pending));
|
||||
load_param(&status, sizeof(status));
|
||||
load_param(&dmafill, sizeof(dmafill));
|
||||
load_param(&fifo_idx, sizeof(fifo_idx));
|
||||
load_param(&fifo, sizeof(fifo));
|
||||
load_param(&h_counter, sizeof(h_counter));
|
||||
load_param(&hint_pending, sizeof(hint_pending));
|
||||
load_param(&vint_pending, sizeof(vint_pending));
|
||||
load_param(&dma_length, sizeof(dma_length));
|
||||
load_param(&dma_type, sizeof(dma_type));
|
||||
load_param(&dma_src, sizeof(dma_src));
|
||||
load_param(&cached_write, sizeof(cached_write));
|
||||
|
||||
/* restore FIFO byte access flag */
|
||||
fifo_byte_access = ((code & 0x0F) < 0x03);
|
||||
|
||||
/* restore current NTSC/PAL mode */
|
||||
if (system_hw & SYSTEM_MD)
|
||||
{
|
||||
status = (status & ~1) | vdp_pal;
|
||||
}
|
||||
|
||||
if (reg[1] & 0x04)
|
||||
{
|
||||
/* Mode 5 */
|
||||
bg_list_index = 0x800;
|
||||
|
||||
/* reinitialize palette */
|
||||
color_update_m5(0, *(uint16 *)&cram[border << 1]);
|
||||
for(i = 1; i < 0x40; i++)
|
||||
{
|
||||
color_update_m5(i, *(uint16 *)&cram[i << 1]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Modes 0,1,2,3,4 */
|
||||
bg_list_index = 0x200;
|
||||
|
||||
/* reinitialize palette */
|
||||
for(i = 0; i < 0x20; i ++)
|
||||
{
|
||||
color_update_m4(i, *(uint16 *)&cram[i << 1]);
|
||||
}
|
||||
color_update_m4(0x40, *(uint16 *)&cram[(0x10 | (border & 0x0F)) << 1]);
|
||||
}
|
||||
|
||||
/* invalidate tile cache */
|
||||
for (i=0;i<bg_list_index;i++)
|
||||
{
|
||||
bg_name_list[i]=i;
|
||||
bg_name_dirty[i]=0xFF;
|
||||
}
|
||||
|
||||
return bufferptr;
|
||||
}
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------------*/
|
||||
/* DMA update function (Mega Drive VDP only) */
|
||||
/*--------------------------------------------------------------------------*/
|
||||
|
|
|
|||
|
|
@ -9,7 +9,6 @@
|
|||
#include <vdp_ctrl.h>
|
||||
#include <input_hw/input.h>
|
||||
#include <cart_hw/sram.h>
|
||||
#include <state.h>
|
||||
|
||||
#include <ntsc/sms_ntsc.h>
|
||||
#include <ntsc/md_ntsc.h>
|
||||
|
|
@ -378,32 +377,32 @@ static int sdl_control_update(SDL_Keycode keystate)
|
|||
|
||||
case SDLK_F7:
|
||||
{
|
||||
const char fileName[] = "game.gp0";
|
||||
FILE *f = fopen(fileName,"rb");
|
||||
if (f)
|
||||
{
|
||||
uint8_t buf[STATE_SIZE];
|
||||
int status = fread(&buf, STATE_SIZE, 1, f);
|
||||
if (status < 0) { fprintf(stderr, "Error loading file `%s'.", fileName); exit(-1); }
|
||||
state_load(buf);
|
||||
fclose(f);
|
||||
}
|
||||
break;
|
||||
// const char fileName[] = "game.gp0";
|
||||
// FILE *f = fopen(fileName,"rb");
|
||||
// if (f)
|
||||
// {
|
||||
// uint8_t buf[STATE_SIZE];
|
||||
// int status = fread(&buf, STATE_SIZE, 1, f);
|
||||
// if (status < 0) { fprintf(stderr, "Error loading file `%s'.", fileName); exit(-1); }
|
||||
// state_load(buf);
|
||||
// fclose(f);
|
||||
// }
|
||||
// break;
|
||||
}
|
||||
|
||||
case SDLK_F8:
|
||||
{
|
||||
const char fileName[] = "game.gp0";
|
||||
FILE *f = fopen(fileName,"wb");
|
||||
if (f)
|
||||
{
|
||||
uint8_t buf[STATE_SIZE];
|
||||
int len = state_save(buf);
|
||||
int status = fwrite(&buf, len, 1, f);
|
||||
if (status < 0) { fprintf(stderr, "Error saving file `%s'.", fileName); exit(-1); }
|
||||
fclose(f);
|
||||
}
|
||||
break;
|
||||
// const char fileName[] = "game.gp0";
|
||||
// FILE *f = fopen(fileName,"wb");
|
||||
// if (f)
|
||||
// {
|
||||
// uint8_t buf[STATE_SIZE];
|
||||
// int len = state_save(buf);
|
||||
// int status = fwrite(&buf, len, 1, f);
|
||||
// if (status < 0) { fprintf(stderr, "Error saving file `%s'.", fileName); exit(-1); }
|
||||
// fclose(f);
|
||||
// }
|
||||
// break;
|
||||
}
|
||||
|
||||
case SDLK_F9:
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user