[picodrive.git] / pico / state.c

/*\r
 * PicoDrive\r
 * (C) notaz, 2010\r
 *\r
 * This work is licensed under the terms of MAME license.\r
 * See COPYING file in the top-level directory.\r
 */\r
\r
#include "pico_int.h"\r
#include <zlib.h>\r
\r
#include <cpu/sh2/sh2.h>\r
#include "sound/ym2612.h"\r
#include "sound/ym2413.h"\r
#include "sound/sn76496.h"\r
#include "cd/megasd.h"\r
#include "state.h"\r
\r
static arearw    *areaRead;\r
static arearw    *areaWrite;\r
static areaeof   *areaEof;\r
static areaseek  *areaSeek;\r
static areaclose *areaClose;\r
\r
carthw_state_chunk *carthw_chunks;\r
void (*PicoStateProgressCB)(const char *str);\r
void (*PicoLoadStateHook)(void);\r
\r
\r
/* I/O functions */\r
static size_t gzRead2(void *p, size_t _size, size_t _n, void *file)\r
{\r
  return gzread(file, p, _size * _n);\r
}\r
\r
static size_t gzWrite2(void *p, size_t _size, size_t _n, void *file)\r
{\r
  return gzwrite(file, p, _size * _n);\r
}\r
\r
static void set_cbs(int gz)\r
{\r
  if (gz) {\r
    areaRead  = gzRead2;\r
    areaWrite = gzWrite2;\r
    areaEof   = (areaeof *) gzeof;\r
    areaSeek  = (areaseek *) gzseek;\r
    areaClose = (areaclose *) gzclose;\r
  } else {\r
    areaRead  = (arearw *) fread;\r
    areaWrite = (arearw *) fwrite;\r
    areaEof   = (areaeof *) feof;\r
    areaSeek  = (areaseek *) fseek;\r
    areaClose = (areaclose *) fclose;\r
  }\r
}\r
\r
static void *open_save_file(const char *fname, int is_save)\r
{\r
  int len = strlen(fname);\r
  void *afile = NULL;\r
\r
  if (len > 3 && strcasecmp(fname + len - 3, ".gz") == 0)\r
  {\r
    if ( (afile = gzopen(fname, is_save ? "wb" : "rb")) ) {\r
      set_cbs(1);\r
      if (is_save)\r
        gzsetparams(afile, 9, Z_DEFAULT_STRATEGY);\r
    }\r
  }\r
  else\r
  {\r
    if ( (afile = fopen(fname, is_save ? "wb" : "rb")) ) {\r
      set_cbs(0);\r
    }\r
  }\r
\r
  return afile;\r
}\r
\r
// ---------------------------------------------------------------------------\r
\r
typedef enum {\r
  CHUNK_M68K = 1,\r
  CHUNK_RAM,\r
  CHUNK_VRAM,\r
  CHUNK_ZRAM,\r
  CHUNK_CRAM,    // 5\r
  CHUNK_VSRAM,\r
  CHUNK_MISC,\r
  CHUNK_VIDEO,\r
  CHUNK_Z80,\r
  CHUNK_PSG,     // 10\r
  CHUNK_FM,\r
  // CD stuff\r
  CHUNK_S68K,\r
  CHUNK_PRG_RAM,\r
  CHUNK_WORD_RAM,\r
  CHUNK_PCM_RAM, // 15\r
  CHUNK_BRAM,\r
  CHUNK_GA_REGS,\r
  CHUNK_PCM,\r
  CHUNK_CDC,     // old\r
  CHUNK_CDD,     // 20 old\r
  CHUNK_SCD,     // old\r
  CHUNK_RC,      // old\r
  CHUNK_MISC_CD,\r
  //\r
  CHUNK_IOPORTS, // old\r
  CHUNK_SMS,     // 25\r
  // 32x\r
  CHUNK_MSH2,\r
  CHUNK_MSH2_DATA,\r
  CHUNK_MSH2_PERI,\r
  CHUNK_SSH2,\r
  CHUNK_SSH2_DATA, // 30\r
  CHUNK_SSH2_PERI,\r
  CHUNK_32XSYS,\r
  CHUNK_M68K_BIOS,\r
  CHUNK_MSH2_BIOS,\r
  CHUNK_SSH2_BIOS, // 35\r
  CHUNK_SDRAM,\r
  CHUNK_DRAM,\r
  CHUNK_32XPAL,\r
  CHUNK_32X_EVT,\r
  //rename\r
  CHUNK_32X_FIRST = CHUNK_MSH2,\r
  CHUNK_32X_LAST = CHUNK_32X_EVT,\r
  // add new stuff here\r
  CHUNK_CD_EVT = 50,\r
  CHUNK_CD_GFX,\r
  CHUNK_CD_CDC,\r
  CHUNK_CD_CDD,\r
  CHUNK_YM2413,\r
  CHUNK_PICO_PCM,\r
  CHUNK_PICO,\r
  CHUNK_CD_MSD,\r
  CHUNK_VDP,\r
  CHUNK_FM_TIMERS,\r
  CHUNK_FMv3 = 60,\r
  CHUNK_IOPORTSv2,\r
  //\r
  CHUNK_DEFAULT_COUNT,\r
  CHUNK_CARTHW_ = CHUNK_CARTHW,  // 64 (defined in PicoInt)\r
\r
} chunk_name_e;\r
\r
static const char * const chunk_names[CHUNK_DEFAULT_COUNT] = {\r
  "INVALID!",\r
  "M68K state",\r
  "RAM",\r
  "VRAM",\r
  "ZRAM",\r
  "CRAM",      // 5\r
  "VSRAM",\r
  "emu state",\r
  "VIDEO",\r
  "Z80 state",\r
  "PSG",       // 10\r
  "FM",\r
  // CD stuff\r
  "S68K state",\r
  "PRG_RAM",\r
  "WORD_RAM",\r
  "PCM_RAM",   // 15\r
  "BRAM",\r
  "GATE ARRAY regs",\r
  "PCM state",\r
  "CDC",\r
  "CDD",       // 20\r
  "SCD",\r
  "GFX chip",\r
  "MCD state",\r
  //\r
  "IO",\r
  "SMS state", // 25\r
  // 32x\r
  "MSH2",\r
  "MSH2 data",\r
  "MSH2 peri",\r
  "SSH2",\r
  "SSH2 data", // 30\r
  "SSH2 peri",\r
  "32X system regs",\r
  "M68K BIOS",\r
  "MSH2 BIOS",\r
  "SSH2 BIOS", // 35\r
  "SDRAM",\r
  "DRAM",\r
  "32X palette",\r
  "32X events",\r
};\r
\r
static int write_chunk(unsigned char name, int len, void *data, void *file)\r
{\r
  size_t bwritten = 0;\r
  bwritten += areaWrite(&name, 1, 1, file);\r
  bwritten += areaWrite(&len, 1, 4, file);\r
  bwritten += areaWrite(data, 1, len, file);\r
\r
  return (bwritten == len + 4 + 1);\r
}\r
\r
#define CHUNK_LIMIT_W 18772 // sizeof(cdc)\r
\r
#define CHECKED_WRITE(name,len,data) { \\r
  if (PicoStateProgressCB && name < CHUNK_DEFAULT_COUNT && chunk_names[name]) { \\r
    strncpy(sbuff + 9, chunk_names[name], sizeof(sbuff)-1 - 9); \\r
    sbuff[sizeof(sbuff)-1] = '\0'; \\r
    PicoStateProgressCB(sbuff); \\r
  } \\r
  if (data == buf2 && len > CHUNK_LIMIT_W) \\r
    goto out; \\r
  if (!write_chunk(name, len, data, file)) \\r
    goto out; \\r
}\r
\r
#define CHECKED_WRITE_BUFF(name,buff) { \\r
  if (PicoStateProgressCB && name < CHUNK_DEFAULT_COUNT && chunk_names[name]) { \\r
    strncpy(sbuff + 9, chunk_names[name], sizeof(sbuff)-1 - 9); \\r
    sbuff[sizeof(sbuff)-1] = '\0'; \\r
    PicoStateProgressCB(sbuff); \\r
  } \\r
  if (!write_chunk(name, sizeof(buff), &buff, file)) \\r
    goto out; \\r
}\r
\r
static int state_save(void *file)\r
{\r
  char sbuff[32] = "Saving.. ";\r
  unsigned char buff[0x60], buff_z80[Z80_STATE_SIZE];\r
  void *buf2 = NULL;\r
  int ver = 0x0191; // not really used..\r
  int retval = -1;\r
  int len;\r
\r
  buf2 = malloc(CHUNK_LIMIT_W);\r
  if (buf2 == NULL)\r
    return -1;\r
\r
  areaWrite("PicoSEXT", 1, 8, file);\r
  areaWrite(&ver, 1, 4, file);\r
\r
  if (!(PicoIn.AHW & PAHW_SMS)) {\r
    // the patches can cause incompatible saves with no-idle\r
    SekFinishIdleDet();\r
\r
    memset(buff, 0, sizeof(buff));\r
    SekPackCpu(buff, 0);\r
    CHECKED_WRITE_BUFF(CHUNK_M68K,  buff);\r
    CHECKED_WRITE_BUFF(CHUNK_RAM,   PicoMem.ram);\r
    CHECKED_WRITE_BUFF(CHUNK_VSRAM, PicoMem.vsram);\r
    CHECKED_WRITE_BUFF(CHUNK_IOPORTS, PicoMem.ioports);\r
    len = io_ports_pack(buf2, CHUNK_LIMIT_W);\r
    CHECKED_WRITE(CHUNK_IOPORTSv2, len, buf2);\r
    if (PicoIn.AHW & PAHW_PICO) {\r
      len = PicoPicoPCMSave(buf2, CHUNK_LIMIT_W);\r
      CHECKED_WRITE(CHUNK_PICO_PCM, len, buf2);\r
      CHECKED_WRITE(CHUNK_PICO, sizeof(PicoPicohw), &PicoPicohw);\r
    } else {\r
#ifdef __GP2X__\r
      void *ym_regs = YM2612GetRegs();\r
      ym2612_pack_state_old();\r
      CHECKED_WRITE(CHUNK_FM, 0x200+4, ym_regs);\r
#else\r
      // write fm state first since timer load needs OPN.ST.mode\r
      len = YM2612PicoStateSave3(buf2, CHUNK_LIMIT_W);\r
      CHECKED_WRITE(CHUNK_FMv3, len, buf2);\r
      len = ym2612_pack_timers(buf2, CHUNK_LIMIT_W);\r
      CHECKED_WRITE(CHUNK_FM_TIMERS, len, buf2);\r
#endif\r
    }\r
\r
    if (!(PicoIn.opt & POPT_DIS_IDLE_DET))\r
      SekInitIdleDet();\r
  }\r
  else {\r
    CHECKED_WRITE_BUFF(CHUNK_SMS, Pico.ms);\r
    // only store the FM unit state if it was really used\r
    if (Pico.m.hardware & PMS_HW_FMUSED) {\r
      len = ym2413_pack_state(buf2, CHUNK_LIMIT_W);\r
      CHECKED_WRITE(CHUNK_YM2413, len, buf2);\r
    }\r
  }\r
  CHECKED_WRITE(CHUNK_PSG, 28*4, sn76496_regs);\r
\r
  if (!(PicoIn.AHW & PAHW_PICO)) {\r
    z80_pack(buff_z80);\r
    CHECKED_WRITE_BUFF(CHUNK_Z80, buff_z80);\r
    CHECKED_WRITE_BUFF(CHUNK_ZRAM,  PicoMem.zram);\r
  }\r
\r
  CHECKED_WRITE_BUFF(CHUNK_VRAM,  PicoMem.vram);\r
  CHECKED_WRITE_BUFF(CHUNK_CRAM,  PicoMem.cram);\r
\r
  CHECKED_WRITE_BUFF(CHUNK_MISC,  Pico.m);\r
  len = PicoVideoSave(buf2);\r
  CHECKED_WRITE(CHUNK_VDP, len, buf2);\r
  CHECKED_WRITE_BUFF(CHUNK_VIDEO, Pico.video);\r
\r
  if (PicoIn.AHW & PAHW_MCD)\r
  {\r
    memset(buff, 0, sizeof(buff));\r
    SekPackCpu(buff, 1);\r
    if (Pico_mcd->s68k_regs[3] & 4) // 1M mode?\r
      wram_1M_to_2M(Pico_mcd->word_ram2M);\r
    memcpy(&Pico_mcd->m.hint_vector, Pico_mcd->bios + 0x72,\r
      sizeof(Pico_mcd->m.hint_vector));\r
\r
    CHECKED_WRITE_BUFF(CHUNK_S68K,     buff);\r
    CHECKED_WRITE_BUFF(CHUNK_PRG_RAM,  Pico_mcd->prg_ram);\r
    CHECKED_WRITE_BUFF(CHUNK_WORD_RAM, Pico_mcd->word_ram2M); // in 2M format\r
    CHECKED_WRITE_BUFF(CHUNK_PCM_RAM,  Pico_mcd->pcm_ram);\r
    CHECKED_WRITE_BUFF(CHUNK_BRAM,     Pico_mcd->bram);\r
    CHECKED_WRITE_BUFF(CHUNK_GA_REGS,  Pico_mcd->s68k_regs); // GA regs, not CPU regs\r
    CHECKED_WRITE_BUFF(CHUNK_PCM,      Pico_mcd->pcm);\r
    CHECKED_WRITE_BUFF(CHUNK_MISC_CD,  Pico_mcd->m);\r
    memset(buff, 0, 0x40);\r
    memcpy(buff, pcd_event_times, sizeof(pcd_event_times));\r
    CHECKED_WRITE(CHUNK_CD_EVT, 0x40, buff);\r
\r
    len = gfx_context_save(buf2);\r
    CHECKED_WRITE(CHUNK_CD_GFX, len, buf2);\r
    len = cdc_context_save(buf2);\r
    CHECKED_WRITE(CHUNK_CD_CDC, len, buf2);\r
    len = cdd_context_save(buf2);\r
    CHECKED_WRITE(CHUNK_CD_CDD, len, buf2);\r
\r
    CHECKED_WRITE_BUFF(CHUNK_CD_MSD, Pico_msd);\r
\r
    if (Pico_mcd->s68k_regs[3] & 4) // convert back\r
      wram_2M_to_1M(Pico_mcd->word_ram2M);\r
  }\r
\r
#ifndef NO_32X\r
  if (PicoIn.AHW & PAHW_32X)\r
  {\r
    unsigned char cpubuff[SH2_STATE_SIZE];\r
\r
    memset(cpubuff, 0, sizeof(cpubuff));\r
\r
    sh2_pack(&sh2s[0], cpubuff);\r
    CHECKED_WRITE_BUFF(CHUNK_MSH2,      cpubuff);\r
    CHECKED_WRITE_BUFF(CHUNK_MSH2_DATA, sh2s[0].data_array);\r
    CHECKED_WRITE_BUFF(CHUNK_MSH2_PERI, sh2s[0].peri_regs);\r
\r
    sh2_pack(&sh2s[1], cpubuff);\r
    CHECKED_WRITE_BUFF(CHUNK_SSH2,      cpubuff);\r
    CHECKED_WRITE_BUFF(CHUNK_SSH2_DATA, sh2s[1].data_array);\r
    CHECKED_WRITE_BUFF(CHUNK_SSH2_PERI, sh2s[1].peri_regs);\r
\r
    CHECKED_WRITE_BUFF(CHUNK_32XSYS,    Pico32x);\r
    CHECKED_WRITE_BUFF(CHUNK_M68K_BIOS, Pico32xMem->m68k_rom);\r
    CHECKED_WRITE_BUFF(CHUNK_MSH2_BIOS, Pico32xMem->sh2_rom_m);\r
    CHECKED_WRITE_BUFF(CHUNK_SSH2_BIOS, Pico32xMem->sh2_rom_s);\r
    CHECKED_WRITE_BUFF(CHUNK_SDRAM,     Pico32xMem->sdram);\r
    CHECKED_WRITE_BUFF(CHUNK_DRAM,      Pico32xMem->dram);\r
    CHECKED_WRITE_BUFF(CHUNK_32XPAL,    Pico32xMem->pal);\r
\r
    memset(buff, 0, 0x40);\r
    memcpy(buff, p32x_event_times, sizeof(p32x_event_times));\r
    CHECKED_WRITE(CHUNK_32X_EVT, 0x40, buff);\r
  }\r
#endif\r
\r
  if (carthw_chunks != NULL)\r
  {\r
    carthw_state_chunk *chwc;\r
    if (PicoStateProgressCB)\r
      PicoStateProgressCB("Saving.. cart hw state");\r
    for (chwc = carthw_chunks; chwc->ptr != NULL; chwc++)\r
      CHECKED_WRITE(chwc->chunk, chwc->size, chwc->ptr);\r
  }\r
\r
  CHECKED_WRITE(0, 0, NULL);\r
  retval = 0;\r
\r
out:\r
  if (buf2 != NULL)\r
    free(buf2);\r
  return retval;\r
}\r
\r
static int g_read_offs = 0;\r
\r
#define R_ERROR_RETURN(error) \\r
{ \\r
  elprintf(EL_STATUS, "load_state @ %x: " error, g_read_offs); \\r
  goto out; \\r
}\r
\r
// when is eof really set?\r
#define CHECKED_READ(len,data) { \\r
  if (areaRead(data, 1, len, file) != len) { \\r
    if (len == 1 && areaEof(file)) goto readend; \\r
    R_ERROR_RETURN("areaRead: premature EOF\n"); \\r
  } \\r
  g_read_offs += len; \\r
}\r
\r
#define CHECKED_READ2(len2,data) { \\r
  if (len2 != len) { \\r
    elprintf(EL_STATUS, "unexpected len %i, wanted %i (%s)", len, len2, #len2); \\r
    if (len > len2) R_ERROR_RETURN("failed."); \\r
    /* else read anyway and hope for the best.. */ \\r
  } \\r
  CHECKED_READ(len, data); \\r
}\r
\r
#define CHECKED_READ_BUFF(buff) CHECKED_READ2(sizeof(buff), &buff);\r
\r
#define CHUNK_LIMIT_R 0x10960 // sizeof(old_cdc)\r
\r
#define CHECKED_READ_LIM(data) { \\r
  if (len > CHUNK_LIMIT_R) \\r
    R_ERROR_RETURN("chunk size over limit."); \\r
  CHECKED_READ(len, data); \\r
}\r
\r
static int state_load(void *file)\r
{\r
  unsigned char buff_m68k[0x60], buff_s68k[0x60];\r
  unsigned char buff_z80[Z80_STATE_SIZE];\r
  unsigned char buff_sh2[SH2_STATE_SIZE];\r
  unsigned char buff_vdp[0x200];\r
  unsigned char *buf = NULL;\r
  unsigned char chunk;\r
  void *ym_regs;\r
  int len_check;\r
  int retval = -1;\r
  char header[8];\r
  int ver, has_32x = 0;\r
  int len, len_vdp = 0;\r
\r
  memset(buff_m68k, 0, sizeof(buff_m68k));\r
  memset(buff_s68k, 0, sizeof(buff_s68k));\r
  memset(buff_z80, 0, sizeof(buff_z80));\r
\r
  buf = malloc(CHUNK_LIMIT_R);\r
  if (buf == NULL)\r
    return -1;\r
\r
  g_read_offs = 0;\r
  CHECKED_READ(8, header);\r
  if (strncmp(header, "PicoSMCD", 8) && strncmp(header, "PicoSEXT", 8))\r
    R_ERROR_RETURN("bad header");\r
  CHECKED_READ(4, &ver);\r
\r
  memset(pcd_event_times, 0, sizeof(pcd_event_times));\r
  memset(p32x_event_times, 0, sizeof(p32x_event_times));\r
\r
  while (!areaEof(file))\r
  {\r
    len_check = 0;\r
    CHECKED_READ(1, &chunk);\r
    CHECKED_READ(4, &len);\r
    if (len < 0 || len > 1024*512) R_ERROR_RETURN("bad length");\r
    if (CHUNK_S68K <= chunk && chunk <= CHUNK_MISC_CD && !(PicoIn.AHW & PAHW_MCD))\r
      R_ERROR_RETURN("cd chunk in non CD state?");\r
\r
    // 32X only appears in PicoDrive after it has been enabled, so track this\r
    has_32x |= CHUNK_32X_FIRST <= chunk && chunk <= CHUNK_32X_LAST;\r
    if (has_32x && !(PicoIn.AHW & PAHW_32X))\r
      Pico32xStartup();\r
\r
    switch (chunk)\r
    {\r
      case CHUNK_M68K:\r
        CHECKED_READ_BUFF(buff_m68k);\r
        break;\r
\r
      case CHUNK_Z80:\r
        CHECKED_READ_BUFF(buff_z80);\r
        break;\r
\r
      case CHUNK_RAM:     CHECKED_READ_BUFF(PicoMem.ram); break;\r
      case CHUNK_VRAM:    CHECKED_READ_BUFF(PicoMem.vram); break;\r
      case CHUNK_ZRAM:    CHECKED_READ_BUFF(PicoMem.zram); break;\r
      case CHUNK_CRAM:    CHECKED_READ_BUFF(PicoMem.cram); break;\r
      case CHUNK_VSRAM:   CHECKED_READ_BUFF(PicoMem.vsram); break;\r
      case CHUNK_MISC:    CHECKED_READ_BUFF(Pico.m); break;\r
      case CHUNK_VIDEO:   CHECKED_READ_BUFF(Pico.video); break;\r
      case CHUNK_VDP:     CHECKED_READ2((len_vdp = len), buff_vdp); break;\r
\r
      case CHUNK_IOPORTS: CHECKED_READ_BUFF(PicoMem.ioports); break;\r
      case CHUNK_PSG:     CHECKED_READ2(28*4, sn76496_regs); break;\r
      case CHUNK_YM2413:\r
        CHECKED_READ(len, buf);\r
        ym2413_unpack_state(buf, len);\r
        Pico.m.hardware |= PMS_HW_FMUSED;\r
        break;\r
      case CHUNK_FM:\r
        ym_regs = YM2612GetRegs();\r
        CHECKED_READ2(0x200+4, ym_regs);\r
        ym2612_unpack_state_old();\r
        break;\r
      case CHUNK_FM_TIMERS: CHECKED_READ(len, buf); ym2612_unpack_timers(buf, len); break;\r
      case CHUNK_FMv3:      CHECKED_READ(len, buf); YM2612PicoStateLoad3(buf, len); break;\r
      case CHUNK_IOPORTSv2: CHECKED_READ(len, buf); io_ports_unpack(buf, len); break;\r
\r
      case CHUNK_PICO_PCM:\r
        CHECKED_READ(len, buf);\r
        PicoPicoPCMLoad(buf, len);\r
        break;\r
      case CHUNK_PICO:\r
        CHECKED_READ_BUFF(PicoPicohw);\r
        break;\r
\r
      case CHUNK_SMS:\r
        CHECKED_READ_BUFF(Pico.ms);\r
        break;\r
\r
      // cd stuff\r
      case CHUNK_S68K:\r
        CHECKED_READ_BUFF(buff_s68k);\r
        break;\r
\r
      case CHUNK_PRG_RAM:  CHECKED_READ_BUFF(Pico_mcd->prg_ram); break;\r
      case CHUNK_WORD_RAM: CHECKED_READ_BUFF(Pico_mcd->word_ram2M); break;\r
      case CHUNK_PCM_RAM:  CHECKED_READ_BUFF(Pico_mcd->pcm_ram); break;\r
      case CHUNK_BRAM:     CHECKED_READ_BUFF(Pico_mcd->bram); break;\r
      case CHUNK_GA_REGS:  CHECKED_READ_BUFF(Pico_mcd->s68k_regs); break;\r
      case CHUNK_PCM:      CHECKED_READ_BUFF(Pico_mcd->pcm); break;\r
      case CHUNK_MISC_CD:  CHECKED_READ_BUFF(Pico_mcd->m); break;\r
      case CHUNK_CD_MSD:   CHECKED_READ_BUFF(Pico_msd); break;\r
\r
      case CHUNK_CD_EVT:\r
        CHECKED_READ2(0x40, buf);\r
        memcpy(pcd_event_times, buf, sizeof(pcd_event_times));\r
        break;\r
\r
      case CHUNK_CD_GFX:\r
        CHECKED_READ_LIM(buf);\r
        len_check = gfx_context_load(buf);\r
        break;\r
\r
      case CHUNK_CD_CDC:\r
        CHECKED_READ_LIM(buf);\r
        len_check = cdc_context_load(buf);\r
        break;\r
\r
      case CHUNK_CD_CDD:\r
        CHECKED_READ_LIM(buf);\r
        len_check = cdd_context_load(buf);\r
        break;\r
\r
      // old, to be removed:\r
      case CHUNK_CDC:\r
        CHECKED_READ_LIM(buf);\r
        cdc_context_load_old(buf);\r
        break;\r
\r
      case CHUNK_SCD:\r
        CHECKED_READ_LIM(buf);\r
        cdd_context_load_old(buf);\r
        break;\r
\r
      // 32x stuff\r
#ifndef NO_32X\r
      case CHUNK_MSH2:\r
        CHECKED_READ_BUFF(buff_sh2);\r
        sh2_unpack(&sh2s[0], buff_sh2);\r
        break;\r
\r
      case CHUNK_SSH2:\r
        CHECKED_READ_BUFF(buff_sh2);\r
        sh2_unpack(&sh2s[1], buff_sh2);\r
        break;\r
\r
      case CHUNK_MSH2_DATA:   CHECKED_READ_BUFF(sh2s[0].data_array); break;\r
      case CHUNK_MSH2_PERI:   CHECKED_READ_BUFF(sh2s[0].peri_regs); break;\r
      case CHUNK_SSH2_DATA:   CHECKED_READ_BUFF(sh2s[1].data_array); break;\r
      case CHUNK_SSH2_PERI:   CHECKED_READ_BUFF(sh2s[1].peri_regs); break;\r
      case CHUNK_32XSYS:      CHECKED_READ_BUFF(Pico32x); break;\r
      case CHUNK_M68K_BIOS:   CHECKED_READ_BUFF(Pico32xMem->m68k_rom); break;\r
      case CHUNK_MSH2_BIOS:   CHECKED_READ_BUFF(Pico32xMem->sh2_rom_m); break;\r
      case CHUNK_SSH2_BIOS:   CHECKED_READ_BUFF(Pico32xMem->sh2_rom_s); break;\r
      case CHUNK_SDRAM:       CHECKED_READ_BUFF(Pico32xMem->sdram); break;\r
      case CHUNK_DRAM:        CHECKED_READ_BUFF(Pico32xMem->dram); break;\r
      case CHUNK_32XPAL:      CHECKED_READ_BUFF(Pico32xMem->pal); break;\r
\r
      case CHUNK_32X_EVT:\r
        CHECKED_READ2(0x40, buf);\r
        memcpy(p32x_event_times, buf, sizeof(p32x_event_times));\r
        break;\r
#endif\r
      default:\r
        if (!len && !chunk)\r
           goto readend;\r
        if (carthw_chunks != NULL)\r
        {\r
          carthw_state_chunk *chwc;\r
          for (chwc = carthw_chunks; chwc->ptr != NULL; chwc++) {\r
            if (chwc->chunk == chunk) {\r
              CHECKED_READ2(chwc->size, chwc->ptr);\r
              goto breakswitch;\r
            }\r
          }\r
        }\r
        elprintf(EL_STATUS, "load_state: skipping unknown chunk %i of size %i", chunk, len);\r
        areaSeek(file, len, SEEK_CUR);\r
        break;\r
    }\r
breakswitch:\r
    if (len_check != 0 && len_check != len)\r
      elprintf(EL_STATUS, "load_state: chunk %d has bad len %d/%d",\r
        len, len_check);\r
  }\r
\r
readend:\r
  PicoVideoLoad(buff_vdp, len_vdp);\r
\r
  if (PicoIn.AHW & PAHW_32X)\r
    if (!has_32x)\r
      Pico32xShutdown(); // in case of loading a state with 32X disabled\r
\r
  if (PicoIn.AHW & PAHW_SMS)\r
    PicoStateLoadedMS();\r
\r
  if (PicoIn.AHW & PAHW_32X)\r
    Pico32xStateLoaded(1);\r
\r
  if (PicoLoadStateHook != NULL)\r
    PicoLoadStateHook();\r
\r
  // must unpack 68k and z80 after banks are set up\r
  if (!(PicoIn.AHW & PAHW_SMS))\r
    SekUnpackCpu(buff_m68k, 0);\r
  if (PicoIn.AHW & PAHW_MCD)\r
    SekUnpackCpu(buff_s68k, 1);\r
\r
  z80_unpack(buff_z80);\r
\r
  if (PicoIn.AHW & PAHW_32X)\r
    Pico32xStateLoaded(0);\r
  if (PicoIn.AHW & PAHW_MCD)\r
    pcd_state_loaded();\r
  if (!(PicoIn.AHW & PAHW_SMS)) {\r
    Pico.video.status &= ~(SR_VB | SR_F);\r
    Pico.video.status |= ((Pico.video.reg[1] >> 3) ^ SR_VB) & SR_VB;\r
    Pico.video.status |= (Pico.video.pending_ints << 2) & SR_F;\r
  }\r
\r
  Pico.m.dirtyPal = 1;\r
  retval = 0;\r
\r
out:\r
  free(buf);\r
  return retval;\r
}\r
\r
static int state_load_gfx(void *file)\r
{\r
  int ver, len, found = 0, to_find = 4;\r
  u8 buff_vdp[0x200];\r
  int len_vdp = 0;\r
  char buff[8];\r
\r
  if (PicoIn.AHW & PAHW_32X)\r
    to_find += 3;\r
\r
  g_read_offs = 0;\r
  CHECKED_READ(8, buff);\r
  if (strncmp((char *)buff, "PicoSMCD", 8) && strncmp((char *)buff, "PicoSEXT", 8))\r
    R_ERROR_RETURN("bad header");\r
  CHECKED_READ(4, &ver);\r
\r
  while (!areaEof(file) && found < to_find)\r
  {\r
    CHECKED_READ(1, buff);\r
    CHECKED_READ(4, &len);\r
    if (len < 0 || len > 1024*512) R_ERROR_RETURN("bad length");\r
    if (buff[0] > CHUNK_FM && buff[0] <= CHUNK_MISC_CD && !(PicoIn.AHW & PAHW_MCD))\r
      R_ERROR_RETURN("cd chunk in non CD state?");\r
\r
    switch (buff[0])\r
    {\r
      case CHUNK_VRAM:  CHECKED_READ_BUFF(PicoMem.vram);  found++; break;\r
      case CHUNK_CRAM:  CHECKED_READ_BUFF(PicoMem.cram);  found++; break;\r
      case CHUNK_VSRAM: CHECKED_READ_BUFF(PicoMem.vsram); found++; break;\r
      case CHUNK_VIDEO: CHECKED_READ_BUFF(Pico.video); found++; break;\r
      case CHUNK_VDP:   CHECKED_READ2((len_vdp = len), buff_vdp); break;\r
\r
#ifndef NO_32X\r
      case CHUNK_DRAM:\r
        if (Pico32xMem != NULL)\r
          CHECKED_READ_BUFF(Pico32xMem->dram);\r
        found++;\r
        break;\r
\r
      case CHUNK_32XPAL:\r
        if (Pico32xMem != NULL)\r
          CHECKED_READ_BUFF(Pico32xMem->pal);\r
        found++;\r
        Pico32x.dirty_pal = 1;\r
        break;\r
\r
      case CHUNK_32XSYS:\r
        CHECKED_READ_BUFF(Pico32x);\r
        found++;\r
        break;\r
#endif\r
      default:\r
        areaSeek(file, len, SEEK_CUR);\r
        break;\r
    }\r
  }\r
  PicoVideoLoad(buff_vdp, len_vdp);\r
\r
out:\r
readend:\r
  return 0;\r
}\r
\r
static int pico_state_internal(void *afile, int is_save)\r
{\r
  int ret;\r
\r
  if (is_save)\r
    ret = state_save(afile);\r
  else\r
    ret = state_load(afile);\r
\r
  return ret;\r
}\r
\r
int PicoState(const char *fname, int is_save)\r
{\r
  void *afile = NULL;\r
  int ret;\r
\r
  afile = open_save_file(fname, is_save);\r
  if (afile == NULL)\r
    return -1;\r
\r
  ret = pico_state_internal(afile, is_save);\r
  areaClose(afile);\r
  return ret;\r
}\r
\r
int PicoStateFP(void *afile, int is_save,\r
  arearw *read, arearw *write, areaeof *eof, areaseek *seek)\r
{\r
  areaRead  = read;\r
  areaWrite = write;\r
  areaEof   = eof;\r
  areaSeek  = seek;\r
  areaClose = NULL;\r
\r
  return pico_state_internal(afile, is_save);\r
}\r
\r
int PicoStateLoadGfx(const char *fname)\r
{\r
  void *afile;\r
  int ret;\r
\r
  afile = open_save_file(fname, 0);\r
  if (afile == NULL)\r
    return -1;\r
\r
  ret = state_load_gfx(afile);\r
  if (ret != 0) {\r
    // assume legacy\r
    areaSeek(afile, 0x10020, SEEK_SET);  // skip header and RAM\r
    areaRead(PicoMem.vram, 1, sizeof(PicoMem.vram), afile);\r
    areaSeek(afile, 0x2000, SEEK_CUR);\r
    areaRead(PicoMem.cram, 1, sizeof(PicoMem.cram), afile);\r
    areaRead(PicoMem.vsram, 1, sizeof(PicoMem.vsram), afile);\r
    areaSeek(afile, 0x221a0, SEEK_SET);\r
    areaRead(&Pico.video, 1, sizeof(Pico.video), afile);\r
    PicoVideoCacheSAT(1);\r
  }\r
  areaClose(afile);\r
\r
  Pico.est.rendstatus = -1;\r
  return 0;\r
}\r
\r
// tmp state\r
struct PicoTmp\r
{\r
  unsigned short vram[0x8000];\r
  unsigned short cram[0x40];\r
  unsigned short vsram[0x40];\r
  unsigned int satcache[2*0x80];\r
\r
  //struct PicoMisc m;\r
  struct PicoVideo video;\r
  u8 vdp[0x200];\r
  int vdp_len;\r
\r
  struct {\r
    struct Pico32x p32x;\r
    unsigned short dram[2][0x20000/2];\r
    unsigned short pal[0x100];\r
  } t32x;\r
};\r
\r
// returns data ptr to free() or PicoTmpStateRestore()\r
void *PicoTmpStateSave(void)\r
{\r
  // gfx only for now\r
  struct PicoTmp *t = malloc(sizeof(*t));\r
  if (t == NULL)\r
    return NULL;\r
\r
  memcpy(t->vram, PicoMem.vram, sizeof(PicoMem.vram));\r
  memcpy(t->cram, PicoMem.cram, sizeof(PicoMem.cram));\r
  memcpy(t->vsram, PicoMem.vsram, sizeof(PicoMem.vsram));\r
  memcpy(t->satcache, VdpSATCache, sizeof(VdpSATCache));\r
  memcpy(&t->video, &Pico.video, sizeof(Pico.video));\r
  t->vdp_len = PicoVideoSave(t->vdp);\r
\r
#ifndef NO_32X\r
  if (PicoIn.AHW & PAHW_32X) {\r
    memcpy(&t->t32x.p32x, &Pico32x, sizeof(Pico32x));\r
    memcpy(t->t32x.dram, Pico32xMem->dram, sizeof(Pico32xMem->dram));\r
    memcpy(t->t32x.pal, Pico32xMem->pal, sizeof(Pico32xMem->pal));\r
  }\r
#endif\r
\r
  return t;\r
}\r
\r
void PicoTmpStateRestore(void *data)\r
{\r
  struct PicoTmp *t = data;\r
  if (t == NULL)\r
    return;\r
\r
  memcpy(PicoMem.vram, t->vram, sizeof(PicoMem.vram));\r
  memcpy(PicoMem.cram, t->cram, sizeof(PicoMem.cram));\r
  memcpy(PicoMem.vsram, t->vsram, sizeof(PicoMem.vsram));\r
  memcpy(VdpSATCache, t->satcache, sizeof(VdpSATCache));\r
  memcpy(&Pico.video, &t->video, sizeof(Pico.video));\r
  Pico.m.dirtyPal = 1;\r
  PicoVideoLoad(t->vdp, t->vdp_len);\r
\r
#ifndef NO_32X\r
  if (PicoIn.AHW & PAHW_32X) {\r
    memcpy(&Pico32x, &t->t32x.p32x, sizeof(Pico32x));\r
    memcpy(Pico32xMem->dram, t->t32x.dram, sizeof(Pico32xMem->dram));\r
    memcpy(Pico32xMem->pal, t->t32x.pal, sizeof(Pico32xMem->pal));\r
    Pico32x.dirty_pal = 1;\r
  }\r
#endif\r
  free(t);\r
}\r
\r
// vim:shiftwidth=2:ts=2:expandtab\r