notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
misc: avoid assertion failure when state save fails
[pcsx_rearmed.git] / libpcsxcore / misc.c
CommitLineData
ef79bbde
P		 1/***************************************************************************
2 * Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
18 ***************************************************************************/
19
20/*
21* Miscellaneous functions, including savestates and CD-ROM loading.
22*/
23
81dbbf4c 24#include <stddef.h>
dc3178e9 25#include <errno.h>
7b75929b 26#include <assert.h>
ef79bbde
P		 27#include "misc.h"
28#include "cdrom.h"
29#include "mdec.h"
ddbaf678 30#include "gpu.h"
ef79bbde 31#include "ppf.h"
de74f599 32#include "psxbios.h"
eedfe806 33#include "database.h"
496d88d4 34#include <zlib.h>
ef79bbde
P		 35
36char CdromId[10] = "";
37char CdromLabel[33] = "";
6a131b03 38int CdromFrontendId; // for frontend use
ef79bbde
P		 39
40// PSX Executable types
41#define PSX_EXE 1
42#define CPE_EXE 2
43#define COFF_EXE 3
44#define INVALID_EXE 4
45
46#define ISODCL(from, to) (to - from + 1)
47
48struct iso_directory_record {
49 char length [ISODCL (1, 1)]; /* 711 */
50 char ext_attr_length [ISODCL (2, 2)]; /* 711 */
51 char extent [ISODCL (3, 10)]; /* 733 */
52 char size [ISODCL (11, 18)]; /* 733 */
53 char date [ISODCL (19, 25)]; /* 7 by 711 */
54 char flags [ISODCL (26, 26)];
55 char file_unit_size [ISODCL (27, 27)]; /* 711 */
56 char interleave [ISODCL (28, 28)]; /* 711 */
57 char volume_sequence_number [ISODCL (29, 32)]; /* 723 */
58 unsigned char name_len [ISODCL (33, 33)]; /* 711 */
59 char name [1];
60};
61
1c654475 62static void mmssdd( char *b, char *p )
ef79bbde
P		 63{
64 int m, s, d;
1c654475 65 unsigned char *ub = (void *)b;
66 int block = (ub[3] << 24) | (ub[2] << 16) | (ub[1] << 8) | ub[0];
ef79bbde
P		 67
68 block += 150;
69 m = block / 4500; // minutes
70 block = block - m * 4500; // minutes rest
71 s = block / 75; // seconds
72 d = block - s * 75; // seconds rest
73
74 m = ((m / 10) << 4) | m % 10;
75 s = ((s / 10) << 4) | s % 10;
7a8d521f 76 d = ((d / 10) << 4) | d % 10;
ef79bbde
P		 77
78 p[0] = m;
79 p[1] = s;
80 p[2] = d;
81}
82
83#define incTime() \
84 time[0] = btoi(time[0]); time[1] = btoi(time[1]); time[2] = btoi(time[2]); \
85 time[2]++; \
86 if(time[2] == 75) { \
87 time[2] = 0; \
88 time[1]++; \
89 if (time[1] == 60) { \
90 time[1] = 0; \
91 time[0]++; \
92 } \
93 } \
94 time[0] = itob(time[0]); time[1] = itob(time[1]); time[2] = itob(time[2]);
95
96#define READTRACK() \
415213c9 97 if (!CDR_readTrack(time)) return -1; \
305c8c93 98 buf = (void *)CDR_getBuffer(); \
99 if (buf == NULL) return -1; \
100 else CheckPPFCache((u8 *)buf, time[0], time[1], time[2]);
ef79bbde
P		 101
102#define READDIR(_dir) \
103 READTRACK(); \
104 memcpy(_dir, buf + 12, 2048); \
105 \
106 incTime(); \
107 READTRACK(); \
108 memcpy(_dir + 2048, buf + 12, 2048);
109
305c8c93 110int GetCdromFile(u8 *mdir, u8 *time, char *filename) {
ef79bbde 111 struct iso_directory_record *dir;
5be6eaeb 112 int retval = -1;
305c8c93 113 u8 ddir[4096];
ef79bbde
P		 114 u8 *buf;
115 int i;
116
117 // only try to scan if a filename is given
0a50313e 118 if (filename == INVALID_PTR || !strlen(filename)) return -1;
ef79bbde
P		 119
120 i = 0;
121 while (i < 4096) {
122 dir = (struct iso_directory_record*) &mdir[i];
123 if (dir->length[0] == 0) {
124 return -1;
125 }
1c2c2bfb 126 i += (u8)dir->length[0];
ef79bbde
P		 127
128 if (dir->flags[0] & 0x2) { // it's a dir
129 if (!strnicmp((char *)&dir->name[0], filename, dir->name_len[0])) {
130 if (filename[dir->name_len[0]] != '\\') continue;
131
132 filename += dir->name_len[0] + 1;
133
134 mmssdd(dir->extent, (char *)time);
135 READDIR(ddir);
136 i = 0;
137 mdir = ddir;
138 }
139 } else {
140 if (!strnicmp((char *)&dir->name[0], filename, strlen(filename))) {
141 mmssdd(dir->extent, (char *)time);
5be6eaeb 142 retval = 0;
ef79bbde
P		 143 break;
144 }
145 }
146 }
5be6eaeb 147 return retval;
ef79bbde
P		 148}
149
6d75addf 150static void SetBootRegs(u32 pc, u32 gp, u32 sp)
151{
152 //printf("%s %08x %08x %08x\n", __func__, pc, gp, sp);
153 psxCpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
154
155 psxRegs.pc = pc;
156 psxRegs.GPR.n.gp = gp;
157 psxRegs.GPR.n.sp = sp ? sp : 0x801fff00;
14b3bd95 158 psxRegs.GPR.n.fp = psxRegs.GPR.n.sp;
159
160 psxRegs.GPR.n.t0 = psxRegs.GPR.n.sp; // mimic A(43)
161 psxRegs.GPR.n.t3 = pc;
6d75addf 162
163 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
164}
165
02b1a085 166int BiosBootBypass() {
167 struct CdrStat stat = { 0, 0, };
7b75929b 168 assert(psxRegs.pc == 0x80030000);
169
02b1a085 170 // no bypass if the lid is open
171 CDR__getStatus(&stat);
172 if (stat.Status & 0x10)
173 return 0;
174
7b75929b 175 // skip BIOS logos and region check
176 psxCpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
177 psxRegs.pc = psxRegs.GPR.n.ra;
02b1a085 178 return 1;
7b75929b 179}
180
dc4fa8bc 181static void getFromCnf(char *buf, const char *key, u32 *val)
182{
183 buf = strstr(buf, key);
184 if (buf)
185 buf = strchr(buf, '=');
dc3178e9 186 if (buf) {
187 unsigned long v;
188 errno = 0;
189 v = strtoul(buf + 1, NULL, 16);
190 if (errno == 0)
191 *val = v;
192 }
dc4fa8bc 193}
194
ef79bbde 195int LoadCdrom() {
de74f599 196 union {
197 EXE_HEADER h;
198 u32 d[sizeof(EXE_HEADER) / sizeof(u32)];
199 } tmpHead;
ef79bbde
P		 200 struct iso_directory_record *dir;
201 u8 time[4], *buf;
202 u8 mdir[4096];
305c8c93 203 char exename[256];
dc4fa8bc 204 u32 cnf_tcb = 4;
205 u32 cnf_event = 16;
206 u32 cnf_stack = 0;
de74f599 207 u32 t_addr;
208 u32 t_size;
dc4fa8bc 209 u32 sp = 0;
de74f599 210 int i, ret;
ef79bbde 211
7b75929b 212 if (!Config.HLE) {
da65071f 213 if (psxRegs.pc != 0x80030000) // BiosBootBypass'ed or custom BIOS?
214 return 0;
215 if (Config.SlowBoot)
216 return 0;
ef79bbde
P		 217 }
218
219 time[0] = itob(0); time[1] = itob(2); time[2] = itob(0x10);
220
221 READTRACK();
222
223 // skip head and sub, and go to the root directory record
7a8d521f 224 dir = (struct iso_directory_record*) &buf[12+156];
ef79bbde
P		 225
226 mmssdd(dir->extent, (char*)time);
227
228 READDIR(mdir);
229
230 // Load SYSTEM.CNF and scan for the main executable
231 if (GetCdromFile(mdir, time, "SYSTEM.CNF;1") == -1) {
232 // if SYSTEM.CNF is missing, start an existing PSX.EXE
233 if (GetCdromFile(mdir, time, "PSX.EXE;1") == -1) return -1;
7b75929b 234 strcpy(exename, "PSX.EXE;1");
ef79bbde
P		 235
236 READTRACK();
237 }
238 else {
239 // read the SYSTEM.CNF
240 READTRACK();
dc4fa8bc 241 buf[1023] = 0;
ef79bbde 242
dc4fa8bc 243 ret = sscanf((char *)buf + 12, "BOOT = cdrom:\\%255s", exename);
244 if (ret < 1 || GetCdromFile(mdir, time, exename) == -1) {
245 ret = sscanf((char *)buf + 12, "BOOT = cdrom:%255s", exename);
246 if (ret < 1 || GetCdromFile(mdir, time, exename) == -1) {
305c8c93 247 char *ptr = strstr((char *)buf + 12, "cdrom:");
ef79bbde
P		 248 if (ptr != NULL) {
249 ptr += 6;
250 while (*ptr == '\\' || *ptr == '/') ptr++;
251 strncpy(exename, ptr, 255);
252 exename[255] = '\0';
253 ptr = exename;
254 while (*ptr != '\0' && *ptr != '\r' && *ptr != '\n') ptr++;
255 *ptr = '\0';
256 if (GetCdromFile(mdir, time, exename) == -1)
257 return -1;
258 } else
259 return -1;
260 }
261 }
dc4fa8bc 262 getFromCnf((char *)buf + 12, "TCB", &cnf_tcb);
263 getFromCnf((char *)buf + 12, "EVENT", &cnf_event);
264 getFromCnf((char *)buf + 12, "STACK", &cnf_stack);
265 if (Config.HLE)
5c8119b8 266 psxBiosCnfLoaded(cnf_tcb, cnf_event, cnf_stack);
ef79bbde
P		 267
268 // Read the EXE-Header
269 READTRACK();
270 }
271
272 memcpy(&tmpHead, buf + 12, sizeof(EXE_HEADER));
de74f599 273 for (i = 2; i < sizeof(tmpHead.d) / sizeof(tmpHead.d[0]); i++)
274 tmpHead.d[i] = SWAP32(tmpHead.d[i]);
ef79bbde 275
de74f599 276 SysPrintf("manual booting '%s' pc=%x\n", exename, tmpHead.h.pc0);
277 sp = tmpHead.h.s_addr;
dc4fa8bc 278 if (cnf_stack)
279 sp = cnf_stack;
de74f599 280 SetBootRegs(tmpHead.h.pc0, tmpHead.h.gp0, sp);
ebe6ff2b 281
ef79bbde 282 // Read the rest of the main executable
de74f599 283 for (t_addr = tmpHead.h.t_addr, t_size = tmpHead.h.t_size; t_size & ~2047; ) {
284 void *ptr = (void *)PSXM(t_addr);
ef79bbde
P		 285
286 incTime();
287 READTRACK();
288
7a8d521f 289 if (ptr != INVALID_PTR) memcpy(ptr, buf+12, 2048);
ef79bbde 290
de74f599 291 t_addr += 2048;
292 t_size -= 2048;
ef79bbde
P		 293 }
294
de74f599 295 psxCpu->Clear(tmpHead.h.t_addr, tmpHead.h.t_size / 4);
296 //psxCpu->Reset();
297
298 if (Config.HLE)
b34d6a80 299 psxBiosCheckExe(tmpHead.h.t_addr, tmpHead.h.t_size, 0);
de74f599 300
ef79bbde
P		 301 return 0;
302}
303
1dc68512 304int LoadCdromFile(const char *filename, EXE_HEADER *head, u8 *time_bcd_out) {
ef79bbde
P		 305 struct iso_directory_record *dir;
306 u8 time[4],*buf;
305c8c93 307 u8 mdir[4096];
308 char exename[256];
457a46ec 309 const char *p1, *p2;
ef79bbde 310 u32 size, addr;
305c8c93 311 void *mem;
ef79bbde 312
86c70511 313 if (filename == INVALID_PTR)
314 return -1;
315
457a46ec 316 p1 = filename;
317 if ((p2 = strchr(p1, ':')))
318 p1 = p2 + 1;
319 while (*p1 == '\\')
320 p1++;
321 snprintf(exename, sizeof(exename), "%s", p1);
ef79bbde
P		 322
323 time[0] = itob(0); time[1] = itob(2); time[2] = itob(0x10);
324
325 READTRACK();
326
327 // skip head and sub, and go to the root directory record
7a8d521f 328 dir = (struct iso_directory_record *)&buf[12 + 156];
ef79bbde
P		 329
330 mmssdd(dir->extent, (char*)time);
331
332 READDIR(mdir);
333
334 if (GetCdromFile(mdir, time, exename) == -1) return -1;
335
336 READTRACK();
1dc68512 337 incTime();
ef79bbde
P		 338
339 memcpy(head, buf + 12, sizeof(EXE_HEADER));
86c70511 340 size = SWAP32(head->t_size);
341 addr = SWAP32(head->t_addr);
ef79bbde 342
ebe6ff2b 343 psxCpu->Clear(addr, size / 4);
86c70511 344 //psxCpu->Reset();
ebe6ff2b 345
346 while (size & ~2047) {
ef79bbde 347 READTRACK();
1dc68512 348 incTime();
ef79bbde 349
305c8c93 350 mem = PSXM(addr);
7a8d521f 351 if (mem != INVALID_PTR)
305c8c93 352 memcpy(mem, buf + 12, 2048);
ef79bbde
P		 353
354 size -= 2048;
355 addr += 2048;
356 }
1dc68512 357 if (time_bcd_out)
358 memcpy(time_bcd_out, time, 3);
ef79bbde
P		 359
360 return 0;
361}
362
363int CheckCdrom() {
364 struct iso_directory_record *dir;
305c8c93 365 unsigned char time[4];
366 char *buf;
ef79bbde
P		 367 unsigned char mdir[4096];
368 char exename[256];
e06ee7f4 369 int i, len, c;
ef79bbde
P		 370
371 FreePPFCache();
372
373 time[0] = itob(0);
374 time[1] = itob(2);
375 time[2] = itob(0x10);
376
377 READTRACK();
378
e06ee7f4 379 memset(CdromLabel, 0, sizeof(CdromLabel));
380 memset(CdromId, 0, sizeof(CdromId));
381 memset(exename, 0, sizeof(exename));
ef79bbde
P		 382
383 strncpy(CdromLabel, buf + 52, 32);
384
385 // skip head and sub, and go to the root directory record
7a8d521f 386 dir = (struct iso_directory_record *)&buf[12 + 156];
ef79bbde
P		 387
388 mmssdd(dir->extent, (char *)time);
389
390 READDIR(mdir);
391
392 if (GetCdromFile(mdir, time, "SYSTEM.CNF;1") != -1) {
393 READTRACK();
394
9a9bcd78 395 sscanf(buf + 12, "BOOT = cdrom:\\%255s", exename);
ef79bbde 396 if (GetCdromFile(mdir, time, exename) == -1) {
9a9bcd78 397 sscanf(buf + 12, "BOOT = cdrom:%255s", exename);
ef79bbde
P		 398 if (GetCdromFile(mdir, time, exename) == -1) {
399 char *ptr = strstr(buf + 12, "cdrom:"); // possibly the executable is in some subdir
400 if (ptr != NULL) {
401 ptr += 6;
402 while (*ptr == '\\' || *ptr == '/') ptr++;
403 strncpy(exename, ptr, 255);
404 exename[255] = '\0';
405 ptr = exename;
406 while (*ptr != '\0' && *ptr != '\r' && *ptr != '\n') ptr++;
407 *ptr = '\0';
408 if (GetCdromFile(mdir, time, exename) == -1)
409 return -1; // main executable not found
410 } else
411 return -1;
412 }
413 }
7a8d521f 414 /* Workaround for Wild Arms EU/US which has non-standard string causing incorrect region detection */
415 if (exename[0] == 'E' && exename[1] == 'X' && exename[2] == 'E' && exename[3] == '\\') {
416 size_t offset = 4;
417 size_t i, len = strlen(exename) - offset;
418 for (i = 0; i < len; i++)
419 exename[i] = exename[i + offset];
420 exename[i] = '\0';
421 }
ef79bbde
P		 422 } else if (GetCdromFile(mdir, time, "PSX.EXE;1") != -1) {
423 strcpy(exename, "PSX.EXE;1");
424 strcpy(CdromId, "SLUS99999");
425 } else
426 return -1; // SYSTEM.CNF and PSX.EXE not found
427
428 if (CdromId[0] == '\0') {
e06ee7f4 429 len = strlen(exename);
430 c = 0;
431 for (i = 0; i < len; ++i) {
432 if (exename[i] == ';' || c >= sizeof(CdromId) - 1)
433 break;
434 if (isalnum(exename[i]))
435 CdromId[c++] = exename[i];
ef79bbde
P		 436 }
437 }
438
0e2e3f49 439 if (CdromId[0] == '\0')
440 strcpy(CdromId, "SLUS99999");
441
ef79bbde 442 if (Config.PsxAuto) { // autodetect system (pal or ntsc)
40337130 443 if (
444 /* Make sure Wild Arms SCUS-94608 is not detected as a PAL game. */
445 ((CdromId[0] == 's' || CdromId[0] == 'S') && (CdromId[2] == 'e' || CdromId[2] == 'E')) ||
446 !strncmp(CdromId, "DTLS3035", 8) ||
447 !strncmp(CdromId, "PBPX95001", 9) || // according to redump.org, these PAL
448 !strncmp(CdromId, "PBPX95007", 9) || // discs have a non-standard ID;
449 !strncmp(CdromId, "PBPX95008", 9)) // add more serials if they are discovered.
ef79bbde
P		 450 Config.PsxType = PSX_TYPE_PAL; // pal
451 else Config.PsxType = PSX_TYPE_NTSC; // ntsc
452 }
453
454 if (CdromLabel[0] == ' ') {
455 strncpy(CdromLabel, CdromId, 9);
456 }
457 SysPrintf(_("CD-ROM Label: %.32s\n"), CdromLabel);
458 SysPrintf(_("CD-ROM ID: %.9s\n"), CdromId);
e06ee7f4 459 SysPrintf(_("CD-ROM EXE Name: %.255s\n"), exename);
eedfe806 460
461 Apply_Hacks_Cdrom();
ef79bbde
P		 462
463 BuildPPFCache();
464
465 return 0;
466}
467
468static int PSXGetFileType(FILE *f) {
469 unsigned long current;
470 u8 mybuf[2048];
471 EXE_HEADER *exe_hdr;
472 FILHDR *coff_hdr;
473
474 current = ftell(f);
475 fseek(f, 0L, SEEK_SET);
7a8d521f 476 if (fread(&mybuf, 1, sizeof(mybuf), f) != sizeof(mybuf))
477 goto io_fail;
478
ef79bbde
P		 479 fseek(f, current, SEEK_SET);
480
481 exe_hdr = (EXE_HEADER *)mybuf;
482 if (memcmp(exe_hdr->id, "PS-X EXE", 8) == 0)
483 return PSX_EXE;
484
485 if (mybuf[0] == 'C' && mybuf[1] == 'P' && mybuf[2] == 'E')
486 return CPE_EXE;
487
488 coff_hdr = (FILHDR *)mybuf;
489 if (SWAPu16(coff_hdr->f_magic) == 0x0162)
490 return COFF_EXE;
491
492 return INVALID_EXE;
7a8d521f 493
494io_fail:
495#ifndef NDEBUG
496 SysPrintf(_("File IO error in <%s:%s>.\n"), __FILE__, __func__);
497#endif
498 return INVALID_EXE;
ef79bbde
P		 499}
500
96bef96f 501// temporary pandora workaround..
502// FIXME: remove
503size_t fread_to_ram(void *ptr, size_t size, size_t nmemb, FILE *stream)
504{
505 void *tmp;
506 size_t ret = 0;
7a8d521f 507
96bef96f 508 tmp = malloc(size * nmemb);
509 if (tmp) {
510 ret = fread(tmp, size, nmemb, stream);
511 memcpy(ptr, tmp, size * nmemb);
512 free(tmp);
513 }
514 return ret;
515}
516
ef79bbde
P		 517int Load(const char *ExePath) {
518 FILE *tmpFile;
519 EXE_HEADER tmpHead;
520 int type;
521 int retval = 0;
522 u8 opcode;
523 u32 section_address, section_size;
ebe6ff2b 524 void *mem;
ef79bbde 525
7a8d521f 526 strcpy(CdromId, "SLUS99999");
527 strcpy(CdromLabel, "SLUS_999.99");
ef79bbde
P		 528
529 tmpFile = fopen(ExePath, "rb");
530 if (tmpFile == NULL) {
531 SysPrintf(_("Error opening file: %s.\n"), ExePath);
532 retval = -1;
533 } else {
534 type = PSXGetFileType(tmpFile);
535 switch (type) {
536 case PSX_EXE:
7a8d521f 537 if (fread(&tmpHead, 1, sizeof(EXE_HEADER), tmpFile) != sizeof(EXE_HEADER))
538 goto fail_io;
ebe6ff2b 539 section_address = SWAP32(tmpHead.t_addr);
540 section_size = SWAP32(tmpHead.t_size);
541 mem = PSXM(section_address);
7a8d521f 542 if (mem != INVALID_PTR) {
543 fseek(tmpFile, 0x800, SEEK_SET);
96bef96f 544 fread_to_ram(mem, section_size, 1, tmpFile);
ebe6ff2b 545 psxCpu->Clear(section_address, section_size / 4);
546 }
6d75addf 547 SetBootRegs(SWAP32(tmpHead.pc0), SWAP32(tmpHead.gp0),
548 SWAP32(tmpHead.s_addr));
ef79bbde
P		 549 retval = 0;
550 break;
551 case CPE_EXE:
552 fseek(tmpFile, 6, SEEK_SET); /* Something tells me we should go to 4 and read the "08 00" here... */
553 do {
7a8d521f 554 if (fread(&opcode, 1, sizeof(opcode), tmpFile) != sizeof(opcode))
555 goto fail_io;
ef79bbde
P		 556 switch (opcode) {
557 case 1: /* Section loading */
7a8d521f 558 if (fread(&section_address, 1, sizeof(section_address), tmpFile) != sizeof(section_address))
559 goto fail_io;
560 if (fread(&section_size, 1, sizeof(section_size), tmpFile) != sizeof(section_size))
561 goto fail_io;
ef79bbde
P		 562 section_address = SWAPu32(section_address);
563 section_size = SWAPu32(section_size);
564#ifdef EMU_LOG
565 EMU_LOG("Loading %08X bytes from %08X to %08X\n", section_size, ftell(tmpFile), section_address);
566#endif
ebe6ff2b 567 mem = PSXM(section_address);
7a8d521f 568 if (mem != INVALID_PTR) {
96bef96f 569 fread_to_ram(mem, section_size, 1, tmpFile);
ebe6ff2b 570 psxCpu->Clear(section_address, section_size / 4);
571 }
ef79bbde
P		 572 break;
573 case 3: /* register loading (PC only?) */
574 fseek(tmpFile, 2, SEEK_CUR); /* unknown field */
7a8d521f 575 if (fread(&psxRegs.pc, 1, sizeof(psxRegs.pc), tmpFile) != sizeof(psxRegs.pc))
576 goto fail_io;
ef79bbde
P		 577 psxRegs.pc = SWAPu32(psxRegs.pc);
578 break;
579 case 0: /* End of file */
580 break;
581 default:
582 SysPrintf(_("Unknown CPE opcode %02x at position %08x.\n"), opcode, ftell(tmpFile) - 1);
583 retval = -1;
584 break;
585 }
586 } while (opcode != 0 && retval == 0);
587 break;
588 case COFF_EXE:
589 SysPrintf(_("COFF files not supported.\n"));
590 retval = -1;
591 break;
592 case INVALID_EXE:
8f00f96c 593 SysPrintf(_("This file does not appear to be a valid PSX EXE file.\n"));
594 SysPrintf(_("(did you forget -cdfile ?)\n"));
ef79bbde
P		 595 retval = -1;
596 break;
597 }
598 }
599
600 if (retval != 0) {
601 CdromId[0] = '\0';
602 CdromLabel[0] = '\0';
603 }
604
7a8d521f 605 if (tmpFile)
606 fclose(tmpFile);
ef79bbde 607 return retval;
7a8d521f 608
609fail_io:
610#ifndef NDEBUG
611 SysPrintf(_("File IO error in <%s:%s>.\n"), __FILE__, __func__);
612#endif
613 fclose(tmpFile);
614 return -1;
ef79bbde
P		 615}
616
617// STATES
618
496d88d4 619static void *zlib_open(const char *name, const char *mode)
620{
621 return gzopen(name, mode);
622}
623
624static int zlib_read(void *file, void *buf, u32 len)
625{
626 return gzread(file, buf, len);
627}
628
629static int zlib_write(void *file, const void *buf, u32 len)
630{
631 return gzwrite(file, buf, len);
632}
633
634static long zlib_seek(void *file, long offs, int whence)
635{
636 return gzseek(file, offs, whence);
637}
638
639static void zlib_close(void *file)
640{
641 gzclose(file);
642}
643
644struct PcsxSaveFuncs SaveFuncs = {
645 zlib_open, zlib_read, zlib_write, zlib_seek, zlib_close
646};
647
7a8d521f 648static const char PcsxHeader[32] = "STv4 PCSX v" PCSX_VERSION;
ef79bbde
P		 649
650// Savestate Versioning!
651// If you make changes to the savestate version, please increment the value below.
df656dde 652static const u32 SaveVersion = 0x8b410006;
ef79bbde 653
6a131b03 654#define MISC_MAGIC 0x4353494d
655struct misc_save_data {
656 u32 magic;
657 u32 gteBusyCycle;
658 u32 muldivBusyCycle;
659 u32 biuReg;
660 u32 biosBranchCheck;
661 u32 gpuIdleAfter;
662 u32 gpuSr;
663 u32 frame_counter;
664 int CdromFrontendId;
665};
666
ef79bbde 667int SaveState(const char *file) {
6a131b03 668 struct misc_save_data *misc = (void *)(psxH + 0xf000);
496d88d4 669 void *f;
cfa5a2af 670 GPUFreeze_t *gpufP = NULL;
671 SPUFreezeHdr_t spufH;
672 SPUFreeze_t *spufP = NULL;
673 unsigned char *pMem = NULL;
674 int result = -1;
ef79bbde 675 int Size;
ef79bbde 676
6a131b03 677 assert(!psxRegs.branching);
678 assert(!psxRegs.cpuInRecursion);
679 assert(!misc->magic);
8338889c 680
681 f = SaveFuncs.open(file, "wb");
682 if (f == NULL) return -1;
683
6a131b03 684 misc->magic = MISC_MAGIC;
685 misc->gteBusyCycle = psxRegs.gteBusyCycle;
686 misc->muldivBusyCycle = psxRegs.muldivBusyCycle;
687 misc->biuReg = psxRegs.biuReg;
688 misc->biosBranchCheck = psxRegs.biosBranchCheck;
689 misc->gpuIdleAfter = psxRegs.gpuIdleAfter;
690 misc->gpuSr = HW_GPU_STATUS;
691 misc->frame_counter = frame_counter;
692 misc->CdromFrontendId = CdromFrontendId;
693
980f7a58 694 psxCpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
52082bc1 695
496d88d4 696 SaveFuncs.write(f, (void *)PcsxHeader, 32);
697 SaveFuncs.write(f, (void *)&SaveVersion, sizeof(u32));
698 SaveFuncs.write(f, (void *)&Config.HLE, sizeof(boolean));
ef79bbde
P		 699
700 pMem = (unsigned char *)malloc(128 * 96 * 3);
cfa5a2af 701 if (pMem == NULL) goto cleanup;
ef79bbde 702 GPU_getScreenPic(pMem);
496d88d4 703 SaveFuncs.write(f, pMem, 128 * 96 * 3);
ef79bbde
P		 704 free(pMem);
705
706 if (Config.HLE)
707 psxBiosFreeze(1);
708
496d88d4 709 SaveFuncs.write(f, psxM, 0x00200000);
710 SaveFuncs.write(f, psxR, 0x00080000);
711 SaveFuncs.write(f, psxH, 0x00010000);
81dbbf4c 712 // only partial save of psxRegisters to maintain savestate compat
713 SaveFuncs.write(f, &psxRegs, offsetof(psxRegisters, gteBusyCycle));
ef79bbde
P		 714
715 // gpu
716 gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t));
cfa5a2af 717 if (gpufP == NULL) goto cleanup;
ef79bbde
P		 718 gpufP->ulFreezeVersion = 1;
719 GPU_freeze(1, gpufP);
496d88d4 720 SaveFuncs.write(f, gpufP, sizeof(GPUFreeze_t));
cfa5a2af 721 free(gpufP); gpufP = NULL;
ef79bbde
P		 722
723 // spu
cfa5a2af 724 SPU_freeze(2, (SPUFreeze_t *)&spufH, psxRegs.cycle);
725 Size = spufH.Size; SaveFuncs.write(f, &Size, 4);
ef79bbde 726 spufP = (SPUFreeze_t *) malloc(Size);
cfa5a2af 727 if (spufP == NULL) goto cleanup;
650adfd2 728 SPU_freeze(1, spufP, psxRegs.cycle);
496d88d4 729 SaveFuncs.write(f, spufP, Size);
cfa5a2af 730 free(spufP); spufP = NULL;
ef79bbde
P		 731
732 sioFreeze(f, 1);
733 cdrFreeze(f, 1);
734 psxHwFreeze(f, 1);
735 psxRcntFreeze(f, 1);
736 mdecFreeze(f, 1);
03f55e6b 737 new_dyna_freeze(f, 1);
3faf5c23 738 padFreeze(f, 1);
ef79bbde 739
cfa5a2af 740 result = 0;
741cleanup:
6a131b03 742 memset(misc, 0, sizeof(*misc));
496d88d4 743 SaveFuncs.close(f);
cfa5a2af 744 return result;
ef79bbde
P		 745}
746
747int LoadState(const char *file) {
6a131b03 748 struct misc_save_data *misc = (void *)(psxH + 0xf000);
de74f599 749 u32 biosBranchCheckOld = psxRegs.biosBranchCheck;
496d88d4 750 void *f;
cfa5a2af 751 GPUFreeze_t *gpufP = NULL;
752 SPUFreeze_t *spufP = NULL;
ef79bbde
P		 753 int Size;
754 char header[32];
755 u32 version;
756 boolean hle;
cfa5a2af 757 int result = -1;
ef79bbde 758
496d88d4 759 f = SaveFuncs.open(file, "rb");
ef79bbde
P		 760 if (f == NULL) return -1;
761
496d88d4 762 SaveFuncs.read(f, header, sizeof(header));
763 SaveFuncs.read(f, &version, sizeof(u32));
764 SaveFuncs.read(f, &hle, sizeof(boolean));
ef79bbde 765
33f56da1 766 if (strncmp("STv4 PCSX", header, 9) != 0 || version != SaveVersion) {
cfa5a2af 767 SysPrintf("incompatible savestate version %x\n", version);
768 goto cleanup;
ef79bbde 769 }
33f56da1 770 Config.HLE = hle;
771
772 if (Config.HLE)
773 psxBiosInit();
ef79bbde 774
496d88d4 775 SaveFuncs.seek(f, 128 * 96 * 3, SEEK_CUR);
496d88d4 776 SaveFuncs.read(f, psxM, 0x00200000);
777 SaveFuncs.read(f, psxR, 0x00080000);
778 SaveFuncs.read(f, psxH, 0x00010000);
81dbbf4c 779 SaveFuncs.read(f, &psxRegs, offsetof(psxRegisters, gteBusyCycle));
780 psxRegs.gteBusyCycle = psxRegs.cycle;
de74f599 781 psxRegs.biosBranchCheck = ~0;
f8896d18 782 psxRegs.gpuIdleAfter = psxRegs.cycle - 1;
783 HW_GPU_STATUS &= SWAP32(~PSXGPU_nBUSY);
6a131b03 784 if (misc->magic == MISC_MAGIC) {
785 psxRegs.gteBusyCycle = misc->gteBusyCycle;
786 psxRegs.muldivBusyCycle = misc->muldivBusyCycle;
787 psxRegs.biuReg = misc->biuReg;
788 psxRegs.biosBranchCheck = misc->biosBranchCheck;
789 psxRegs.gpuIdleAfter = misc->gpuIdleAfter;
790 HW_GPU_STATUS = misc->gpuSr;
791 frame_counter = misc->frame_counter;
792 CdromFrontendId = misc->CdromFrontendId;
793 }
ef79bbde 794
980f7a58 795 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
796
ef79bbde
P		 797 if (Config.HLE)
798 psxBiosFreeze(0);
799
800 // gpu
801 gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t));
cfa5a2af 802 if (gpufP == NULL) goto cleanup;
496d88d4 803 SaveFuncs.read(f, gpufP, sizeof(GPUFreeze_t));
ef79bbde
P		 804 GPU_freeze(0, gpufP);
805 free(gpufP);
f8896d18 806 gpuSyncPluginSR();
ef79bbde
P		 807
808 // spu
496d88d4 809 SaveFuncs.read(f, &Size, 4);
ef79bbde 810 spufP = (SPUFreeze_t *)malloc(Size);
cfa5a2af 811 if (spufP == NULL) goto cleanup;
496d88d4 812 SaveFuncs.read(f, spufP, Size);
650adfd2 813 SPU_freeze(0, spufP, psxRegs.cycle);
ef79bbde
P		 814 free(spufP);
815
816 sioFreeze(f, 0);
817 cdrFreeze(f, 0);
818 psxHwFreeze(f, 0);
819 psxRcntFreeze(f, 0);
820 mdecFreeze(f, 0);
03f55e6b 821 new_dyna_freeze(f, 0);
3faf5c23 822 padFreeze(f, 0);
ef79bbde 823
9a0a61d2 824 events_restore();
de74f599 825 if (Config.HLE)
b34d6a80 826 psxBiosCheckExe(biosBranchCheckOld, 0x60, 1);
de74f599 827
cfa5a2af 828 result = 0;
829cleanup:
6a131b03 830 memset(misc, 0, sizeof(*misc));
496d88d4 831 SaveFuncs.close(f);
cfa5a2af 832 return result;
ef79bbde
P		 833}
834
835int CheckState(const char *file) {
496d88d4 836 void *f;
ef79bbde
P		 837 char header[32];
838 u32 version;
839 boolean hle;
840
496d88d4 841 f = SaveFuncs.open(file, "rb");
ef79bbde
P		 842 if (f == NULL) return -1;
843
496d88d4 844 SaveFuncs.read(f, header, sizeof(header));
845 SaveFuncs.read(f, &version, sizeof(u32));
846 SaveFuncs.read(f, &hle, sizeof(boolean));
ef79bbde 847
496d88d4 848 SaveFuncs.close(f);
ef79bbde 849
33f56da1 850 if (strncmp("STv4 PCSX", header, 9) != 0 || version != SaveVersion)
ef79bbde
P		 851 return -1;
852
853 return 0;
854}
855
856// NET Function Helpers
857
858int SendPcsxInfo() {
859 if (NET_recvData == NULL || NET_sendData == NULL)
860 return 0;
861
d014a471 862 boolean Sio_old = 0;
863 boolean SpuIrq_old = 0;
864 boolean RCntFix_old = 0;
ef79bbde 865 NET_sendData(&Config.Xa, sizeof(Config.Xa), PSE_NET_BLOCKING);
d014a471 866 NET_sendData(&Sio_old, sizeof(Sio_old), PSE_NET_BLOCKING);
867 NET_sendData(&SpuIrq_old, sizeof(SpuIrq_old), PSE_NET_BLOCKING);
868 NET_sendData(&RCntFix_old, sizeof(RCntFix_old), PSE_NET_BLOCKING);
ef79bbde
P		 869 NET_sendData(&Config.PsxType, sizeof(Config.PsxType), PSE_NET_BLOCKING);
870 NET_sendData(&Config.Cpu, sizeof(Config.Cpu), PSE_NET_BLOCKING);
871
872 return 0;
873}
874
875int RecvPcsxInfo() {
876 int tmp;
877
878 if (NET_recvData == NULL || NET_sendData == NULL)
879 return 0;
880
d014a471 881 boolean Sio_old = 0;
882 boolean SpuIrq_old = 0;
883 boolean RCntFix_old = 0;
ef79bbde 884 NET_recvData(&Config.Xa, sizeof(Config.Xa), PSE_NET_BLOCKING);
d014a471 885 NET_recvData(&Sio_old, sizeof(Sio_old), PSE_NET_BLOCKING);
886 NET_recvData(&SpuIrq_old, sizeof(SpuIrq_old), PSE_NET_BLOCKING);
887 NET_recvData(&RCntFix_old, sizeof(RCntFix_old), PSE_NET_BLOCKING);
ef79bbde
P		 888 NET_recvData(&Config.PsxType, sizeof(Config.PsxType), PSE_NET_BLOCKING);
889
ef79bbde
P		 890 tmp = Config.Cpu;
891 NET_recvData(&Config.Cpu, sizeof(Config.Cpu), PSE_NET_BLOCKING);
892 if (tmp != Config.Cpu) {
893 psxCpu->Shutdown();
41e82ad4 894#ifndef DRC_DISABLE
ef79bbde
P		 895 if (Config.Cpu == CPU_INTERPRETER) psxCpu = &psxInt;
896 else psxCpu = &psxRec;
897#else
898 psxCpu = &psxInt;
899#endif
900 if (psxCpu->Init() == -1) {
901 SysClose(); return -1;
902 }
903 psxCpu->Reset();
980f7a58 904 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
ef79bbde
P		 905 }
906
907 return 0;
908}
909
910// remove the leading and trailing spaces in a string
911void trim(char *str) {
912 int pos = 0;
913 char *dest = str;
914
915 // skip leading blanks
916 while (str[pos] <= ' ' && str[pos] > 0)
917 pos++;
918
919 while (str[pos]) {
920 *(dest++) = str[pos];
921 pos++;
922 }
923
924 *(dest--) = '\0'; // store the null
925
926 // remove trailing blanks
927 while (dest >= str && *dest <= ' ' && *dest > 0)
928 *(dest--) = '\0';
929}
930
931// lookup table for crc calculation
932static unsigned short crctab[256] = {
933 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
934 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210,
935 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B,
936 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401,
937 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE,
938 0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6,
939 0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D,
940 0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
941 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
942 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC,
943 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4,
944 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD,
945 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13,
946 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
947 0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E,
948 0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
949 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
950 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB,
951 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
952 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8,
953 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657,
954 0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9,
955 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882,
956 0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
957 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
958 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07,
959 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D,
960 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
961 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
962};
963
964u16 calcCrc(u8 *d, int len) {
965 u16 crc = 0;
966 int i;
967
968 for (i = 0; i < len; i++) {
969 crc = crctab[(crc >> 8) ^ d[i]] ^ (crc << 8);
970 }
971
972 return ~crc;
973}
ARM optimized PCSX fork