state.c 21 KB

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