pico/state.c

   1 /*\r
   2  * PicoDrive\r
   3  * (C) notaz, 2010\r
   4  *\r
   5  * This work is licensed under the terms of MAME license.\r
   6  * See COPYING file in the top-level directory.\r
   7  */\r
   8 \r
   9 #include "pico_int.h"\r
  10 #include <zlib.h>\r
  11 \r
  12 #include "../cpu/sh2/sh2.h"\r
  13 #include "sound/ym2612.h"\r
  14 #include "state.h"\r
  15 \r
  16 // sn76496\r
  17 extern int *sn76496_regs;\r
  18 \r
  19 static arearw    *areaRead;\r
  20 static arearw    *areaWrite;\r
  21 static areaeof   *areaEof;\r
  22 static areaseek  *areaSeek;\r
  23 static areaclose *areaClose;\r
  24 \r
  25 carthw_state_chunk *carthw_chunks;\r
  26 void (*PicoStateProgressCB)(const char *str);\r
  27 void (*PicoLoadStateHook)(void);\r
  28 \r
  29 \r
  30 /* I/O functions */\r
  31 static size_t gzRead2(void *p, size_t _size, size_t _n, void *file)\r
  32 {\r
  33   return gzread(file, p, _size * _n);\r
  34 }\r
  35 \r
  36 static size_t gzWrite2(void *p, size_t _size, size_t _n, void *file)\r
  37 {\r
  38   return gzwrite(file, p, _size * _n);\r
  39 }\r
  40 \r
  41 static void set_cbs(int gz)\r
  42 {\r
  43   if (gz) {\r
  44     areaRead  = gzRead2;\r
  45     areaWrite = gzWrite2;\r
  46     areaEof   = (areaeof *) gzeof;\r
  47     areaSeek  = (areaseek *) gzseek;\r
  48     areaClose = (areaclose *) gzclose;\r
  49   } else {\r
  50     areaRead  = (arearw *) fread;\r
  51     areaWrite = (arearw *) fwrite;\r
  52     areaEof   = (areaeof *) feof;\r
  53     areaSeek  = (areaseek *) fseek;\r
  54     areaClose = (areaclose *) fclose;\r
  55   }\r
  56 }\r
  57 \r
  58 static void *open_save_file(const char *fname, int is_save)\r
  59 {\r
  60   int len = strlen(fname);\r
  61   void *afile = NULL;\r
  62 \r
  63   if (len > 3 && strcmp(fname + len - 3, ".gz") == 0)\r
  64   {\r
  65     if ( (afile = gzopen(fname, is_save ? "wb" : "rb")) ) {\r
  66       set_cbs(1);\r
  67       if (is_save)\r
  68         gzsetparams(afile, 9, Z_DEFAULT_STRATEGY);\r
  69     }\r
  70   }\r
  71   else\r
  72   {\r
  73     if ( (afile = fopen(fname, is_save ? "wb" : "rb")) ) {\r
  74       set_cbs(0);\r
  75     }\r
  76   }\r
  77 \r
  78   return afile;\r
  79 }\r
  80 \r
  81 // legacy savestate loading\r
  82 #define SCANP(f, x) areaRead(&Pico.x, sizeof(Pico.x), 1, f)\r
  83 \r
  84 static int state_load_legacy(void *file)\r
  85 {\r
  86   unsigned char head[32];\r
  87   unsigned char cpu[0x60];\r
  88   unsigned char cpu_z80[Z80_STATE_SIZE];\r
  89   void *ym2612_regs;\r
  90   int ok;\r
  91 \r
  92   memset(&cpu,0,sizeof(cpu));\r
  93   memset(&cpu_z80,0,sizeof(cpu_z80));\r
  94 \r
  95   memset(head, 0, sizeof(head));\r
  96   areaRead(head, sizeof(head), 1, file);\r
  97   if (strcmp((char *)head, "Pico") != 0)\r
  98     return -1;\r
  99 \r
 100   elprintf(EL_STATUS, "legacy savestate");\r
 101 \r
 102   // Scan all the memory areas:\r
 103   SCANP(file, ram);\r
 104   SCANP(file, vram);\r
 105   SCANP(file, zram);\r
 106   SCANP(file, cram);\r
 107   SCANP(file, vsram);\r
 108 \r
 109   // Pack, scan and unpack the cpu data:\r
 110   areaRead(cpu, sizeof(cpu), 1, file);\r
 111   SekUnpackCpu(cpu, 0);\r
 112 \r
 113   SCANP(file, m);\r
 114   SCANP(file, video);\r
 115 \r
 116   ok = areaRead(cpu_z80, sizeof(cpu_z80), 1, file) == sizeof(cpu_z80);\r
 117   // do not unpack if we fail to load z80 state\r
 118   if (!ok) z80_reset();\r
 119   else     z80_unpack(cpu_z80);\r
 120 \r
 121   ym2612_regs = YM2612GetRegs();\r
 122   areaRead(sn76496_regs, 28*4, 1, file);\r
 123   areaRead(ym2612_regs, 0x200+4, 1, file);\r
 124   ym2612_unpack_state();\r
 125 \r
 126   return 0;\r
 127 }\r
 128 \r
 129 // ---------------------------------------------------------------------------\r
 130 \r
 131 typedef enum {\r
 132   CHUNK_M68K = 1,\r
 133   CHUNK_RAM,\r
 134   CHUNK_VRAM,\r
 135   CHUNK_ZRAM,\r
 136   CHUNK_CRAM,    // 5\r
 137   CHUNK_VSRAM,\r
 138   CHUNK_MISC,\r
 139   CHUNK_VIDEO,\r
 140   CHUNK_Z80,\r
 141   CHUNK_PSG,     // 10\r
 142   CHUNK_FM,\r
 143   // CD stuff\r
 144   CHUNK_S68K,\r
 145   CHUNK_PRG_RAM,\r
 146   CHUNK_WORD_RAM,\r
 147   CHUNK_PCM_RAM, // 15\r
 148   CHUNK_BRAM,\r
 149   CHUNK_GA_REGS,\r
 150   CHUNK_PCM,\r
 151   CHUNK_CDC,     // old\r
 152   CHUNK_CDD,     // 20 old\r
 153   CHUNK_SCD,     // old\r
 154   CHUNK_RC,      // old\r
 155   CHUNK_MISC_CD,\r
 156   //\r
 157   CHUNK_IOPORTS, // versions < 1.70 did not save that..\r
 158   CHUNK_SMS,     // 25\r
 159   // 32x\r
 160   CHUNK_MSH2,\r
 161   CHUNK_MSH2_DATA,\r
 162   CHUNK_MSH2_PERI,\r
 163   CHUNK_SSH2,\r
 164   CHUNK_SSH2_DATA, // 30\r
 165   CHUNK_SSH2_PERI,\r
 166   CHUNK_32XSYS,\r
 167   CHUNK_M68K_BIOS,\r
 168   CHUNK_MSH2_BIOS,\r
 169   CHUNK_SSH2_BIOS, // 35\r
 170   CHUNK_SDRAM,\r
 171   CHUNK_DRAM,\r
 172   CHUNK_32XPAL,\r
 173   CHUNK_32X_EVT,\r
 174   CHUNK_32X_FIRST = CHUNK_MSH2,\r
 175   CHUNK_32X_LAST = CHUNK_32X_EVT,\r
 176   // add new stuff here\r
 177   CHUNK_CD_EVT = 50,\r
 178   CHUNK_CD_GFX,\r
 179   CHUNK_CD_CDC,\r
 180   CHUNK_CD_CDD,\r
 181   //\r
 182   CHUNK_DEFAULT_COUNT,\r
 183   CHUNK_CARTHW_ = CHUNK_CARTHW,  // 64 (defined in PicoInt)\r
 184 } chunk_name_e;\r
 185 \r
 186 static const char * const chunk_names[CHUNK_DEFAULT_COUNT] = {\r
 187   "INVALID!",\r
 188   "M68K state",\r
 189   "RAM",\r
 190   "VRAM",\r
 191   "ZRAM",\r
 192   "CRAM",      // 5\r
 193   "VSRAM",\r
 194   "emu state",\r
 195   "VIDEO",\r
 196   "Z80 state",\r
 197   "PSG",       // 10\r
 198   "FM",\r
 199   // CD stuff\r
 200   "S68K state",\r
 201   "PRG_RAM",\r
 202   "WORD_RAM",\r
 203   "PCM_RAM",   // 15\r
 204   "BRAM",\r
 205   "GATE ARRAY regs",\r
 206   "PCM state",\r
 207   "CDC",\r
 208   "CDD",       // 20\r
 209   "SCD",\r
 210   "GFX chip",\r
 211   "MCD state",\r
 212   //\r
 213   "IO",\r
 214   "SMS state", // 25\r
 215   // 32x\r
 216   "MSH2",\r
 217   "MSH2 data",\r
 218   "MSH2 peri",\r
 219   "SSH2",\r
 220   "SSH2 data", // 30\r
 221   "SSH2 peri",\r
 222   "32X system regs",\r
 223   "M68K BIOS",\r
 224   "MSH2 BIOS",\r
 225   "SSH2 BIOS", // 35\r
 226   "SDRAM",\r
 227   "DRAM",\r
 228   "PAL",\r
 229   "events",\r
 230 };\r
 231 \r
 232 static int write_chunk(chunk_name_e name, int len, void *data, void *file)\r
 233 {\r
 234   size_t bwritten = 0;\r
 235   bwritten += areaWrite(&name, 1, 1, file);\r
 236   bwritten += areaWrite(&len, 1, 4, file);\r
 237   bwritten += areaWrite(data, 1, len, file);\r
 238 \r
 239   return (bwritten == len + 4 + 1);\r
 240 }\r
 241 \r
 242 #define CHUNK_LIMIT_W 18772 // sizeof(cdc)\r
 243 \r
 244 #define CHECKED_WRITE(name,len,data) { \\r
 245   if (PicoStateProgressCB && name < CHUNK_DEFAULT_COUNT && chunk_names[name]) { \\r
 246     strncpy(sbuff + 9, chunk_names[name], sizeof(sbuff) - 9); \\r
 247     PicoStateProgressCB(sbuff); \\r
 248   } \\r
 249   if (data == buf2 && len > CHUNK_LIMIT_W) \\r
 250     goto out; \\r
 251   if (!write_chunk(name, len, data, file)) \\r
 252     goto out; \\r
 253 }\r
 254 \r
 255 #define CHECKED_WRITE_BUFF(name,buff) { \\r
 256   if (PicoStateProgressCB && name < CHUNK_DEFAULT_COUNT && chunk_names[name]) { \\r
 257     strncpy(sbuff + 9, chunk_names[name], sizeof(sbuff) - 9); \\r
 258     PicoStateProgressCB(sbuff); \\r
 259   } \\r
 260   if (!write_chunk(name, sizeof(buff), &buff, file)) \\r
 261     goto out; \\r
 262 }\r
 263 \r
 264 static int state_save(void *file)\r
 265 {\r
 266   char sbuff[32] = "Saving.. ";\r
 267   unsigned char buff[0x60], buff_z80[Z80_STATE_SIZE];\r
 268   void *ym2612_regs = YM2612GetRegs();\r
 269   void *buf2 = NULL;\r
 270   int ver = 0x0191; // not really used..\r
 271   int retval = -1;\r
 272   int len;\r
 273 \r
 274   areaWrite("PicoSEXT", 1, 8, file);\r
 275   areaWrite(&ver, 1, 4, file);\r
 276 \r
 277   if (!(PicoAHW & PAHW_SMS)) {\r
 278     memset(buff, 0, sizeof(buff));\r
 279     SekPackCpu(buff, 0);\r
 280     CHECKED_WRITE_BUFF(CHUNK_M68K,  buff);\r
 281     CHECKED_WRITE_BUFF(CHUNK_RAM,   Pico.ram);\r
 282     CHECKED_WRITE_BUFF(CHUNK_VSRAM, Pico.vsram);\r
 283     CHECKED_WRITE_BUFF(CHUNK_IOPORTS, Pico.ioports);\r
 284     ym2612_pack_state();\r
 285     CHECKED_WRITE(CHUNK_FM, 0x200+4, ym2612_regs);\r
 286   }\r
 287   else {\r
 288     CHECKED_WRITE_BUFF(CHUNK_SMS, Pico.ms);\r
 289   }\r
 290 \r
 291   CHECKED_WRITE_BUFF(CHUNK_VRAM,  Pico.vram);\r
 292   CHECKED_WRITE_BUFF(CHUNK_ZRAM,  Pico.zram);\r
 293   CHECKED_WRITE_BUFF(CHUNK_CRAM,  Pico.cram);\r
 294   CHECKED_WRITE_BUFF(CHUNK_MISC,  Pico.m);\r
 295   CHECKED_WRITE_BUFF(CHUNK_VIDEO, Pico.video);\r
 296 \r
 297   z80_pack(buff_z80);\r
 298   CHECKED_WRITE_BUFF(CHUNK_Z80, buff_z80);\r
 299   CHECKED_WRITE(CHUNK_PSG, 28*4, sn76496_regs);\r
 300 \r
 301   if (PicoAHW & PAHW_MCD)\r
 302   {\r
 303     buf2 = malloc(CHUNK_LIMIT_W);\r
 304     if (buf2 == NULL)\r
 305       return -1;\r
 306 \r
 307     memset(buff, 0, sizeof(buff));\r
 308     SekPackCpu(buff, 1);\r
 309     if (Pico_mcd->s68k_regs[3] & 4) // 1M mode?\r
 310       wram_1M_to_2M(Pico_mcd->word_ram2M);\r
 311     memcpy(&Pico_mcd->m.hint_vector, Pico_mcd->bios + 0x72,\r
 312       sizeof(Pico_mcd->m.hint_vector));\r
 313 \r
 314     CHECKED_WRITE_BUFF(CHUNK_S68K,     buff);\r
 315     CHECKED_WRITE_BUFF(CHUNK_PRG_RAM,  Pico_mcd->prg_ram);\r
 316     CHECKED_WRITE_BUFF(CHUNK_WORD_RAM, Pico_mcd->word_ram2M); // in 2M format\r
 317     CHECKED_WRITE_BUFF(CHUNK_PCM_RAM,  Pico_mcd->pcm_ram);\r
 318     CHECKED_WRITE_BUFF(CHUNK_BRAM,     Pico_mcd->bram);\r
 319     CHECKED_WRITE_BUFF(CHUNK_GA_REGS,  Pico_mcd->s68k_regs); // GA regs, not CPU regs\r
 320     CHECKED_WRITE_BUFF(CHUNK_PCM,      Pico_mcd->pcm);\r
 321     CHECKED_WRITE_BUFF(CHUNK_MISC_CD,  Pico_mcd->m);\r
 322     memset(buff, 0, 0x40);\r
 323     memcpy(buff, pcd_event_times, sizeof(pcd_event_times));\r
 324     CHECKED_WRITE(CHUNK_CD_EVT, 0x40, buff);\r
 325 \r
 326     len = gfx_context_save(buf2);\r
 327     CHECKED_WRITE(CHUNK_CD_GFX, len, buf2);\r
 328     len = cdc_context_save(buf2);\r
 329     CHECKED_WRITE(CHUNK_CD_CDC, len, buf2);\r
 330     len = cdd_context_save(buf2);\r
 331     CHECKED_WRITE(CHUNK_CD_CDD, len, buf2);\r
 332 \r
 333     if (Pico_mcd->s68k_regs[3] & 4) // convert back\r
 334       wram_2M_to_1M(Pico_mcd->word_ram2M);\r
 335   }\r
 336 \r
 337 #ifndef NO_32X\r
 338   if (PicoAHW & PAHW_32X)\r
 339   {\r
 340     unsigned char cpubuff[SH2_STATE_SIZE];\r
 341 \r
 342     memset(cpubuff, 0, sizeof(cpubuff));\r
 343 \r
 344     sh2_pack(&sh2s[0], cpubuff);\r
 345     CHECKED_WRITE_BUFF(CHUNK_MSH2,      cpubuff);\r
 346     CHECKED_WRITE_BUFF(CHUNK_MSH2_DATA, sh2s[0].data_array);\r
 347     CHECKED_WRITE_BUFF(CHUNK_MSH2_PERI, sh2s[0].peri_regs);\r
 348 \r
 349     sh2_pack(&sh2s[1], cpubuff);\r
 350     CHECKED_WRITE_BUFF(CHUNK_SSH2,      cpubuff);\r
 351     CHECKED_WRITE_BUFF(CHUNK_SSH2_DATA, sh2s[1].data_array);\r
 352     CHECKED_WRITE_BUFF(CHUNK_SSH2_PERI, sh2s[1].peri_regs);\r
 353 \r
 354     CHECKED_WRITE_BUFF(CHUNK_32XSYS,    Pico32x);\r
 355     CHECKED_WRITE_BUFF(CHUNK_M68K_BIOS, Pico32xMem->m68k_rom);\r
 356     CHECKED_WRITE_BUFF(CHUNK_MSH2_BIOS, Pico32xMem->sh2_rom_m);\r
 357     CHECKED_WRITE_BUFF(CHUNK_SSH2_BIOS, Pico32xMem->sh2_rom_s);\r
 358     CHECKED_WRITE_BUFF(CHUNK_SDRAM,     Pico32xMem->sdram);\r
 359     CHECKED_WRITE_BUFF(CHUNK_DRAM,      Pico32xMem->dram);\r
 360     CHECKED_WRITE_BUFF(CHUNK_32XPAL,    Pico32xMem->pal);\r
 361 \r
 362     memset(buff, 0, 0x40);\r
 363     memcpy(buff, p32x_event_times, sizeof(p32x_event_times));\r
 364     CHECKED_WRITE(CHUNK_32X_EVT, 0x40, buff);\r
 365   }\r
 366 #endif\r
 367 \r
 368   if (carthw_chunks != NULL)\r
 369   {\r
 370     carthw_state_chunk *chwc;\r
 371     if (PicoStateProgressCB)\r
 372       PicoStateProgressCB("Saving.. cart hw state");\r
 373     for (chwc = carthw_chunks; chwc->ptr != NULL; chwc++)\r
 374       CHECKED_WRITE(chwc->chunk, chwc->size, chwc->ptr);\r
 375   }\r
 376 \r
 377   retval = 0;\r
 378 \r
 379 out:\r
 380   if (buf2 != NULL)\r
 381     free(buf2);\r
 382   return retval;\r
 383 }\r
 384 \r
 385 static int g_read_offs = 0;\r
 386 \r
 387 #define R_ERROR_RETURN(error) \\r
 388 { \\r
 389   elprintf(EL_STATUS, "load_state @ %x: " error, g_read_offs); \\r
 390   goto out; \\r
 391 }\r
 392 \r
 393 // when is eof really set?\r
 394 #define CHECKED_READ(len,data) { \\r
 395   if (areaRead(data, 1, len, file) != len) { \\r
 396     if (len == 1 && areaEof(file)) goto readend; \\r
 397     R_ERROR_RETURN("areaRead: premature EOF\n"); \\r
 398   } \\r
 399   g_read_offs += len; \\r
 400 }\r
 401 \r
 402 #define CHECKED_READ2(len2,data) { \\r
 403   if (len2 != len) { \\r
 404     elprintf(EL_STATUS, "unexpected len %i, wanted %i (%s)", len, len2, #len2); \\r
 405     if (len > len2) R_ERROR_RETURN("failed."); \\r
 406     /* else read anyway and hope for the best.. */ \\r
 407   } \\r
 408   CHECKED_READ(len, data); \\r
 409 }\r
 410 \r
 411 #define CHECKED_READ_BUFF(buff) CHECKED_READ2(sizeof(buff), &buff);\r
 412 \r
 413 #define CHUNK_LIMIT_R 0x10960 // sizeof(old_cdc)\r
 414 \r
 415 #define CHECKED_READ_LIM(data) { \\r
 416   if (len > CHUNK_LIMIT_R) \\r
 417     R_ERROR_RETURN("chunk size over limit."); \\r
 418   CHECKED_READ(len, data); \\r
 419 }\r
 420 \r
 421 static int state_load(void *file)\r
 422 {\r
 423   unsigned char buff_m68k[0x60], buff_s68k[0x60];\r
 424   unsigned char buff_z80[Z80_STATE_SIZE];\r
 425   unsigned char buff_sh2[SH2_STATE_SIZE];\r
 426   unsigned char *buf = NULL;\r
 427   unsigned char chunk;\r
 428   void *ym2612_regs;\r
 429   int len_check;\r
 430   int retval = -1;\r
 431   char header[8];\r
 432   int ver, len;\r
 433 \r
 434   memset(buff_m68k, 0, sizeof(buff_m68k));\r
 435   memset(buff_s68k, 0, sizeof(buff_s68k));\r
 436   memset(buff_z80, 0, sizeof(buff_z80));\r
 437 \r
 438   buf = malloc(CHUNK_LIMIT_R);\r
 439   if (buf == NULL)\r
 440     return -1;\r
 441 \r
 442   g_read_offs = 0;\r
 443   CHECKED_READ(8, header);\r
 444   if (strncmp(header, "PicoSMCD", 8) && strncmp(header, "PicoSEXT", 8))\r
 445     R_ERROR_RETURN("bad header");\r
 446   CHECKED_READ(4, &ver);\r
 447 \r
 448   memset(pcd_event_times, 0, sizeof(pcd_event_times));\r
 449   memset(p32x_event_times, 0, sizeof(p32x_event_times));\r
 450 \r
 451   while (!areaEof(file))\r
 452   {\r
 453     len_check = 0;\r
 454     CHECKED_READ(1, &chunk);\r
 455     CHECKED_READ(4, &len);\r
 456     if (len < 0 || len > 1024*512) R_ERROR_RETURN("bad length");\r
 457     if (CHUNK_S68K <= chunk && chunk <= CHUNK_MISC_CD && !(PicoAHW & PAHW_MCD))\r
 458       R_ERROR_RETURN("cd chunk in non CD state?");\r
 459     if (CHUNK_32X_FIRST <= chunk && chunk <= CHUNK_32X_LAST && !(PicoAHW & PAHW_32X))\r
 460       Pico32xStartup();\r
 461 \r
 462     switch (chunk)\r
 463     {\r
 464       case CHUNK_M68K:\r
 465         CHECKED_READ_BUFF(buff_m68k);\r
 466         break;\r
 467 \r
 468       case CHUNK_Z80:\r
 469         CHECKED_READ_BUFF(buff_z80);\r
 470         break;\r
 471 \r
 472       case CHUNK_RAM:     CHECKED_READ_BUFF(Pico.ram); break;\r
 473       case CHUNK_VRAM:    CHECKED_READ_BUFF(Pico.vram); break;\r
 474       case CHUNK_ZRAM:    CHECKED_READ_BUFF(Pico.zram); break;\r
 475       case CHUNK_CRAM:    CHECKED_READ_BUFF(Pico.cram); break;\r
 476       case CHUNK_VSRAM:   CHECKED_READ_BUFF(Pico.vsram); break;\r
 477       case CHUNK_MISC:    CHECKED_READ_BUFF(Pico.m); break;\r
 478       case CHUNK_VIDEO:   CHECKED_READ_BUFF(Pico.video); break;\r
 479       case CHUNK_IOPORTS: CHECKED_READ_BUFF(Pico.ioports); break;\r
 480       case CHUNK_PSG:     CHECKED_READ2(28*4, sn76496_regs); break;\r
 481       case CHUNK_FM:\r
 482         ym2612_regs = YM2612GetRegs();\r
 483         CHECKED_READ2(0x200+4, ym2612_regs);\r
 484         ym2612_unpack_state();\r
 485         break;\r
 486 \r
 487       case CHUNK_SMS:\r
 488         CHECKED_READ_BUFF(Pico.ms);\r
 489         break;\r
 490 \r
 491       // cd stuff\r
 492       case CHUNK_S68K:\r
 493         CHECKED_READ_BUFF(buff_s68k);\r
 494         break;\r
 495 \r
 496       case CHUNK_PRG_RAM:  CHECKED_READ_BUFF(Pico_mcd->prg_ram); break;\r
 497       case CHUNK_WORD_RAM: CHECKED_READ_BUFF(Pico_mcd->word_ram2M); break;\r
 498       case CHUNK_PCM_RAM:  CHECKED_READ_BUFF(Pico_mcd->pcm_ram); break;\r
 499       case CHUNK_BRAM:     CHECKED_READ_BUFF(Pico_mcd->bram); break;\r
 500       case CHUNK_GA_REGS:  CHECKED_READ_BUFF(Pico_mcd->s68k_regs); break;\r
 501       case CHUNK_PCM:      CHECKED_READ_BUFF(Pico_mcd->pcm); break;\r
 502       case CHUNK_MISC_CD:  CHECKED_READ_BUFF(Pico_mcd->m); break;\r
 503 \r
 504       case CHUNK_CD_EVT:\r
 505         CHECKED_READ2(0x40, buf);\r
 506         memcpy(pcd_event_times, buf, sizeof(pcd_event_times));\r
 507         break;\r
 508 \r
 509       case CHUNK_CD_GFX:\r
 510         CHECKED_READ_LIM(buf);\r
 511         len_check = gfx_context_load(buf);\r
 512         break;\r
 513 \r
 514       case CHUNK_CD_CDC:\r
 515         CHECKED_READ_LIM(buf);\r
 516         len_check = cdc_context_load(buf);\r
 517         break;\r
 518 \r
 519       case CHUNK_CD_CDD:\r
 520         CHECKED_READ_LIM(buf);\r
 521         len_check = cdd_context_load(buf);\r
 522         break;\r
 523 \r
 524       // old, to be removed:\r
 525       case CHUNK_CDC:\r
 526         CHECKED_READ_LIM(buf);\r
 527         cdc_context_load_old(buf);\r
 528         break;\r
 529 \r
 530       case CHUNK_SCD:\r
 531         CHECKED_READ_LIM(buf);\r
 532         cdd_context_load_old(buf);\r
 533         break;\r
 534 \r
 535       // 32x stuff\r
 536 #ifndef NO_32X\r
 537       case CHUNK_MSH2:\r
 538         CHECKED_READ_BUFF(buff_sh2);\r
 539         sh2_unpack(&sh2s[0], buff_sh2);\r
 540         break;\r
 541 \r
 542       case CHUNK_SSH2:\r
 543         CHECKED_READ_BUFF(buff_sh2);\r
 544         sh2_unpack(&sh2s[1], buff_sh2);\r
 545         break;\r
 546 \r
 547       case CHUNK_MSH2_DATA:   CHECKED_READ_BUFF(sh2s[0].data_array); break;\r
 548       case CHUNK_MSH2_PERI:   CHECKED_READ_BUFF(sh2s[0].peri_regs); break;\r
 549       case CHUNK_SSH2_DATA:   CHECKED_READ_BUFF(sh2s[1].data_array); break;\r
 550       case CHUNK_SSH2_PERI:   CHECKED_READ_BUFF(sh2s[1].peri_regs); break;\r
 551       case CHUNK_32XSYS:      CHECKED_READ_BUFF(Pico32x); break;\r
 552       case CHUNK_M68K_BIOS:   CHECKED_READ_BUFF(Pico32xMem->m68k_rom); break;\r
 553       case CHUNK_MSH2_BIOS:   CHECKED_READ_BUFF(Pico32xMem->sh2_rom_m); break;\r
 554       case CHUNK_SSH2_BIOS:   CHECKED_READ_BUFF(Pico32xMem->sh2_rom_s); break;\r
 555       case CHUNK_SDRAM:       CHECKED_READ_BUFF(Pico32xMem->sdram); break;\r
 556       case CHUNK_DRAM:        CHECKED_READ_BUFF(Pico32xMem->dram); break;\r
 557       case CHUNK_32XPAL:      CHECKED_READ_BUFF(Pico32xMem->pal); break;\r
 558 \r
 559       case CHUNK_32X_EVT:\r
 560         CHECKED_READ2(0x40, buf);\r
 561         memcpy(p32x_event_times, buf, sizeof(p32x_event_times));\r
 562         break;\r
 563 #endif\r
 564       default:\r
 565         if (carthw_chunks != NULL)\r
 566         {\r
 567           carthw_state_chunk *chwc;\r
 568           for (chwc = carthw_chunks; chwc->ptr != NULL; chwc++) {\r
 569             if (chwc->chunk == chunk) {\r
 570               CHECKED_READ2(chwc->size, chwc->ptr);\r
 571               goto breakswitch;\r
 572             }\r
 573           }\r
 574         }\r
 575         elprintf(EL_STATUS, "load_state: skipping unknown chunk %i of size %i", chunk, len);\r
 576         areaSeek(file, len, SEEK_CUR);\r
 577         break;\r
 578     }\r
 579 breakswitch:\r
 580     if (len_check != 0 && len_check != len)\r
 581       elprintf(EL_STATUS, "load_state: chunk %d has bad len %d/%d",\r
 582         len, len_check);\r
 583   }\r
 584 \r
 585 readend:\r
 586   if (PicoAHW & PAHW_SMS)\r
 587     PicoStateLoadedMS();\r
 588 \r
 589   if (PicoAHW & PAHW_32X)\r
 590     Pico32xStateLoaded(1);\r
 591 \r
 592   if (PicoLoadStateHook != NULL)\r
 593     PicoLoadStateHook();\r
 594 \r
 595   // must unpack 68k and z80 after banks are set up\r
 596   if (!(PicoAHW & PAHW_SMS))\r
 597     SekUnpackCpu(buff_m68k, 0);\r
 598   if (PicoAHW & PAHW_MCD)\r
 599     SekUnpackCpu(buff_s68k, 1);\r
 600 \r
 601   z80_unpack(buff_z80);\r
 602 \r
 603   // due to dep from 68k cycles..\r
 604   SekCycleAim = SekCycleCnt;\r
 605   if (PicoAHW & PAHW_32X)\r
 606     Pico32xStateLoaded(0);\r
 607   if (PicoAHW & PAHW_MCD)\r
 608   {\r
 609     SekCycleAimS68k = SekCycleCntS68k;\r
 610     pcd_state_loaded();\r
 611   }\r
 612 \r
 613   retval = 0;\r
 614 \r
 615 out:\r
 616   free(buf);\r
 617   return retval;\r
 618 }\r
 619 \r
 620 static int state_load_gfx(void *file)\r
 621 {\r
 622   int ver, len, found = 0, to_find = 4;\r
 623   char buff[8];\r
 624 \r
 625   if (PicoAHW & PAHW_32X)\r
 626     to_find += 2;\r
 627 \r
 628   g_read_offs = 0;\r
 629   CHECKED_READ(8, buff);\r
 630   if (strncmp((char *)buff, "PicoSMCD", 8) && strncmp((char *)buff, "PicoSEXT", 8))\r
 631     R_ERROR_RETURN("bad header");\r
 632   CHECKED_READ(4, &ver);\r
 633 \r
 634   while (!areaEof(file) && found < to_find)\r
 635   {\r
 636     CHECKED_READ(1, buff);\r
 637     CHECKED_READ(4, &len);\r
 638     if (len < 0 || len > 1024*512) R_ERROR_RETURN("bad length");\r
 639     if (buff[0] > CHUNK_FM && buff[0] <= CHUNK_MISC_CD && !(PicoAHW & PAHW_MCD))\r
 640       R_ERROR_RETURN("cd chunk in non CD state?");\r
 641 \r
 642     switch (buff[0])\r
 643     {\r
 644       case CHUNK_VRAM:  CHECKED_READ_BUFF(Pico.vram);  found++; break;\r
 645       case CHUNK_CRAM:  CHECKED_READ_BUFF(Pico.cram);  found++; break;\r
 646       case CHUNK_VSRAM: CHECKED_READ_BUFF(Pico.vsram); found++; break;\r
 647       case CHUNK_VIDEO: CHECKED_READ_BUFF(Pico.video); found++; break;\r
 648 \r
 649 #ifndef NO_32X\r
 650       case CHUNK_DRAM:\r
 651         if (Pico32xMem != NULL)\r
 652           CHECKED_READ_BUFF(Pico32xMem->dram);\r
 653         break;\r
 654 \r
 655       case CHUNK_32XPAL:\r
 656         if (Pico32xMem != NULL)\r
 657           CHECKED_READ_BUFF(Pico32xMem->pal);\r
 658         Pico32x.dirty_pal = 1;\r
 659         break;\r
 660 \r
 661       case CHUNK_32XSYS:\r
 662         CHECKED_READ_BUFF(Pico32x);\r
 663         break;\r
 664 #endif\r
 665       default:\r
 666         areaSeek(file, len, SEEK_CUR);\r
 667         break;\r
 668     }\r
 669   }\r
 670 \r
 671 out:\r
 672 readend:\r
 673   return 0;\r
 674 }\r
 675 \r
 676 static int pico_state_internal(void *afile, int is_save)\r
 677 {\r
 678   int ret;\r
 679 \r
 680   if (is_save)\r
 681     ret = state_save(afile);\r
 682   else {\r
 683     ret = state_load(afile);\r
 684     if (ret != 0) {\r
 685       areaSeek(afile, 0, SEEK_SET);\r
 686       ret = state_load_legacy(afile);\r
 687     }\r
 688 \r
 689     Pico.m.dirtyPal = 1;\r
 690     Pico.video.status &= ~(SR_VB | SR_F);\r
 691   }\r
 692 \r
 693   return ret;\r
 694 }\r
 695 \r
 696 int PicoState(const char *fname, int is_save)\r
 697 {\r
 698   void *afile = NULL;\r
 699   int ret;\r
 700 \r
 701   afile = open_save_file(fname, is_save);\r
 702   if (afile == NULL)\r
 703     return -1;\r
 704 \r
 705   ret = pico_state_internal(afile, is_save);\r
 706   areaClose(afile);\r
 707   return ret;\r
 708 }\r
 709 \r
 710 int PicoStateFP(void *afile, int is_save,\r
 711   arearw *read, arearw *write, areaeof *eof, areaseek *seek)\r
 712 {\r
 713   areaRead  = read;\r
 714   areaWrite = write;\r
 715   areaEof   = eof;\r
 716   areaSeek  = seek;\r
 717   areaClose = NULL;\r
 718 \r
 719   return pico_state_internal(afile, is_save);\r
 720 }\r
 721 \r
 722 int PicoStateLoadGfx(const char *fname)\r
 723 {\r
 724   void *afile;\r
 725   int ret;\r
 726 \r
 727   afile = open_save_file(fname, 0);\r
 728   if (afile == NULL)\r
 729     return -1;\r
 730 \r
 731   ret = state_load_gfx(afile);\r
 732   if (ret != 0) {\r
 733     // assume legacy\r
 734     areaSeek(afile, 0x10020, SEEK_SET);  // skip header and RAM\r
 735     areaRead(Pico.vram, 1, sizeof(Pico.vram), afile);\r
 736     areaSeek(afile, 0x2000, SEEK_CUR);\r
 737     areaRead(Pico.cram, 1, sizeof(Pico.cram), afile);\r
 738     areaRead(Pico.vsram, 1, sizeof(Pico.vsram), afile);\r
 739     areaSeek(afile, 0x221a0, SEEK_SET);\r
 740     areaRead(&Pico.video, 1, sizeof(Pico.video), afile);\r
 741   }\r
 742   areaClose(afile);\r
 743   return 0;\r
 744 }\r
 745 \r
 746 // tmp state\r
 747 struct PicoTmp\r
 748 {\r
 749   unsigned short vram[0x8000];\r
 750   unsigned short cram[0x40];\r
 751   unsigned short vsram[0x40];\r
 752 \r
 753   //struct PicoMisc m;\r
 754   struct PicoVideo video;\r
 755 \r
 756   struct {\r
 757     struct Pico32x p32x;\r
 758     unsigned short dram[2][0x20000/2];\r
 759     unsigned short pal[0x100];\r
 760   } t32x;\r
 761 };\r
 762 \r
 763 // returns data ptr to free() or PicoTmpStateRestore()\r
 764 void *PicoTmpStateSave(void)\r
 765 {\r
 766   // gfx only for now\r
 767   struct PicoTmp *t = malloc(sizeof(*t));\r
 768   if (t == NULL)\r
 769     return NULL;\r
 770 \r
 771   memcpy(t->vram, Pico.vram, sizeof(Pico.vram));\r
 772   memcpy(t->cram, Pico.cram, sizeof(Pico.cram));\r
 773   memcpy(t->vsram, Pico.vsram, sizeof(Pico.vsram));\r
 774   memcpy(&t->video, &Pico.video, sizeof(Pico.video));\r
 775 \r
 776 #ifndef NO_32X\r
 777   if (PicoAHW & PAHW_32X) {\r
 778     memcpy(&t->t32x.p32x, &Pico32x, sizeof(Pico32x));\r
 779     memcpy(t->t32x.dram, Pico32xMem->dram, sizeof(Pico32xMem->dram));\r
 780     memcpy(t->t32x.pal, Pico32xMem->pal, sizeof(Pico32xMem->pal));\r
 781   }\r
 782 #endif\r
 783 \r
 784   return t;\r
 785 }\r
 786 \r
 787 void PicoTmpStateRestore(void *data)\r
 788 {\r
 789   struct PicoTmp *t = data;\r
 790   if (t == NULL)\r
 791     return;\r
 792 \r
 793   memcpy(Pico.vram, t->vram, sizeof(Pico.vram));\r
 794   memcpy(Pico.cram, t->cram, sizeof(Pico.cram));\r
 795   memcpy(Pico.vsram, t->vsram, sizeof(Pico.vsram));\r
 796   memcpy(&Pico.video, &t->video, sizeof(Pico.video));\r
 797   Pico.m.dirtyPal = 1;\r
 798 \r
 799 #ifndef NO_32X\r
 800   if (PicoAHW & PAHW_32X) {\r
 801     memcpy(&Pico32x, &t->t32x.p32x, sizeof(Pico32x));\r
 802     memcpy(Pico32xMem->dram, t->t32x.dram, sizeof(Pico32xMem->dram));\r
 803     memcpy(Pico32xMem->pal, t->t32x.pal, sizeof(Pico32xMem->pal));\r
 804     Pico32x.dirty_pal = 1;\r
 805   }\r
 806 #endif\r
 807 }\r
 808 \r
 809 // vim:shiftwidth=2:ts=2:expandtab\r