notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
psxbios: implement some cdrom related stuff
[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
630b122b 24#include <stddef.h>
38f70ea4 25#include <errno.h>
f5f5f5dd 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"
584fc319 32#include "psxbios.h"
630b122b 33#include "database.h"
496d88d4 34#include <zlib.h>
ef79bbde
P		 35
36char CdromId[10] = "";
37char CdromLabel[33] = "";
ec92465a 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
6d8f88c4 62static void mmssdd( char *b, char *p )
ef79bbde
P		 63{
64 int m, s, d;
6d8f88c4 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;
3e42b115 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() \
1290ebe4 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
c35a25f6 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
6c62131f 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;
7575a4aa 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;
6c62131f 162
163 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
164}
165
b7f50ee7 166int BiosBootBypass() {
167 struct CdrStat stat = { 0, 0, };
f5f5f5dd 168 assert(psxRegs.pc == 0x80030000);
169
b7f50ee7 170 // no bypass if the lid is open
171 CDR__getStatus(&stat);
172 if (stat.Status & 0x10)
173 return 0;
174
f5f5f5dd 175 // skip BIOS logos and region check
176 psxCpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
177 psxRegs.pc = psxRegs.GPR.n.ra;
b7f50ee7 178 return 1;
f5f5f5dd 179}
180
9415f066 181static void getFromCnf(char *buf, const char *key, u32 *val)
182{
183 buf = strstr(buf, key);
184 if (buf)
185 buf = strchr(buf, '=');
38f70ea4 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 }
9415f066 193}
194
ef79bbde 195int LoadCdrom() {
584fc319 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];
9415f066 204 u32 cnf_tcb = 4;
205 u32 cnf_event = 16;
206 u32 cnf_stack = 0;
584fc319 207 u32 t_addr;
208 u32 t_size;
9415f066 209 u32 sp = 0;
584fc319 210 int i, ret;
ef79bbde 211
f5f5f5dd 212 if (!Config.HLE) {
f3bc907d 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
3e42b115 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;
f5f5f5dd 234 strcpy(exename, "PSX.EXE;1");
ef79bbde
P		 235
236 READTRACK();
237 }
238 else {
239 // read the SYSTEM.CNF
240 READTRACK();
9415f066 241 buf[1023] = 0;
ef79bbde 242
9415f066 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 }
9415f066 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)
c89fac55 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));
584fc319 273 for (i = 2; i < sizeof(tmpHead.d) / sizeof(tmpHead.d[0]); i++)
274 tmpHead.d[i] = SWAP32(tmpHead.d[i]);
ef79bbde 275
584fc319 276 SysPrintf("manual booting '%s' pc=%x\n", exename, tmpHead.h.pc0);
277 sp = tmpHead.h.s_addr;
9415f066 278 if (cnf_stack)
279 sp = cnf_stack;
584fc319 280 SetBootRegs(tmpHead.h.pc0, tmpHead.h.gp0, sp);
ebe6ff2b 281
ef79bbde 282 // Read the rest of the main executable
584fc319 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
b012a437 289 if (ptr != INVALID_PTR) memcpy(ptr, buf+12, 2048);
ef79bbde 290
584fc319 291 t_addr += 2048;
292 t_size -= 2048;
ef79bbde
P		 293 }
294
584fc319 295 psxCpu->Clear(tmpHead.h.t_addr, tmpHead.h.t_size / 4);
296 //psxCpu->Reset();
297
298 if (Config.HLE)
403a6290 299 psxBiosCheckExe(tmpHead.h.t_addr, tmpHead.h.t_size, 0);
584fc319 300
ef79bbde
P		 301 return 0;
302}
303
c1a58212 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];
867297ae 309 const char *p1, *p2;
ef79bbde 310 u32 size, addr;
305c8c93 311 void *mem;
ef79bbde 312
de6bb534 313 if (filename == INVALID_PTR)
314 return -1;
315
867297ae 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
3e42b115 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();
c1a58212 337 incTime();
ef79bbde
P		 338
339 memcpy(head, buf + 12, sizeof(EXE_HEADER));
de6bb534 340 size = SWAP32(head->t_size);
341 addr = SWAP32(head->t_addr);
ef79bbde 342
ebe6ff2b 343 psxCpu->Clear(addr, size / 4);
de6bb534 344 //psxCpu->Reset();
ebe6ff2b 345
346 while (size & ~2047) {
ef79bbde 347 READTRACK();
c1a58212 348 incTime();
ef79bbde 349
305c8c93 350 mem = PSXM(addr);
b012a437 351 if (mem != INVALID_PTR)
305c8c93 352 memcpy(mem, buf + 12, 2048);
ef79bbde
P		 353
354 size -= 2048;
355 addr += 2048;
356 }
c1a58212 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
3e42b115 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 }
1893f408 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)
630b122b 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] == ' ') {
630b122b 455 strncpy(CdromLabel, CdromId, 9);
ef79bbde
P		 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);
630b122b 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);
5b568098 476 if (fread(&mybuf, 1, sizeof(mybuf), f) != sizeof(mybuf))
9361a5aa
EC		 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;
9361a5aa
EC		 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;
3e42b115 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
3e42b115 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:
5b568098 537 if (fread(&tmpHead, 1, sizeof(EXE_HEADER), tmpFile) != sizeof(EXE_HEADER))
9361a5aa 538 goto fail_io;
ebe6ff2b 539 section_address = SWAP32(tmpHead.t_addr);
540 section_size = SWAP32(tmpHead.t_size);
541 mem = PSXM(section_address);
b012a437 542 if (mem != INVALID_PTR) {
3e42b115 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 }
6c62131f 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 {
5b568098 554 if (fread(&opcode, 1, sizeof(opcode), tmpFile) != sizeof(opcode))
9361a5aa 555 goto fail_io;
ef79bbde
P		 556 switch (opcode) {
557 case 1: /* Section loading */
5b568098 558 if (fread(&section_address, 1, sizeof(section_address), tmpFile) != sizeof(section_address))
9361a5aa 559 goto fail_io;
5b568098 560 if (fread(&section_size, 1, sizeof(section_size), tmpFile) != sizeof(section_size))
9361a5aa 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);
b012a437 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 */
5b568098 575 if (fread(&psxRegs.pc, 1, sizeof(psxRegs.pc), tmpFile) != sizeof(psxRegs.pc))
9361a5aa 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
5b568098 605 if (tmpFile)
606 fclose(tmpFile);
ef79bbde 607 return retval;
9361a5aa
EC		 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
202b29d4 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
ec92465a 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) {
ec92465a 668 struct misc_save_data *misc = (void *)(psxH + 0xf000);
496d88d4 669 void *f;
ab91a058 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
ec92465a 677 assert(!psxRegs.branching);
678 assert(!psxRegs.cpuInRecursion);
679 assert(!misc->magic);
680 misc->magic = MISC_MAGIC;
681 misc->gteBusyCycle = psxRegs.gteBusyCycle;
682 misc->muldivBusyCycle = psxRegs.muldivBusyCycle;
683 misc->biuReg = psxRegs.biuReg;
684 misc->biosBranchCheck = psxRegs.biosBranchCheck;
685 misc->gpuIdleAfter = psxRegs.gpuIdleAfter;
686 misc->gpuSr = HW_GPU_STATUS;
687 misc->frame_counter = frame_counter;
688 misc->CdromFrontendId = CdromFrontendId;
689
496d88d4 690 f = SaveFuncs.open(file, "wb");
ef79bbde
P		 691 if (f == NULL) return -1;
692
20196899 693 psxCpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
6962f770 694
496d88d4 695 SaveFuncs.write(f, (void *)PcsxHeader, 32);
696 SaveFuncs.write(f, (void *)&SaveVersion, sizeof(u32));
697 SaveFuncs.write(f, (void *)&Config.HLE, sizeof(boolean));
ef79bbde
P		 698
699 pMem = (unsigned char *)malloc(128 * 96 * 3);
ab91a058 700 if (pMem == NULL) goto cleanup;
ef79bbde 701 GPU_getScreenPic(pMem);
496d88d4 702 SaveFuncs.write(f, pMem, 128 * 96 * 3);
ef79bbde
P		 703 free(pMem);
704
705 if (Config.HLE)
706 psxBiosFreeze(1);
707
496d88d4 708 SaveFuncs.write(f, psxM, 0x00200000);
709 SaveFuncs.write(f, psxR, 0x00080000);
710 SaveFuncs.write(f, psxH, 0x00010000);
630b122b 711 // only partial save of psxRegisters to maintain savestate compat
712 SaveFuncs.write(f, &psxRegs, offsetof(psxRegisters, gteBusyCycle));
ef79bbde
P		 713
714 // gpu
715 gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t));
ab91a058 716 if (gpufP == NULL) goto cleanup;
ef79bbde
P		 717 gpufP->ulFreezeVersion = 1;
718 GPU_freeze(1, gpufP);
496d88d4 719 SaveFuncs.write(f, gpufP, sizeof(GPUFreeze_t));
ab91a058 720 free(gpufP); gpufP = NULL;
ef79bbde
P		 721
722 // spu
ab91a058 723 SPU_freeze(2, (SPUFreeze_t *)&spufH, psxRegs.cycle);
724 Size = spufH.Size; SaveFuncs.write(f, &Size, 4);
ef79bbde 725 spufP = (SPUFreeze_t *) malloc(Size);
ab91a058 726 if (spufP == NULL) goto cleanup;
650adfd2 727 SPU_freeze(1, spufP, psxRegs.cycle);
496d88d4 728 SaveFuncs.write(f, spufP, Size);
ab91a058 729 free(spufP); spufP = NULL;
ef79bbde
P		 730
731 sioFreeze(f, 1);
732 cdrFreeze(f, 1);
733 psxHwFreeze(f, 1);
734 psxRcntFreeze(f, 1);
735 mdecFreeze(f, 1);
03f55e6b 736 new_dyna_freeze(f, 1);
bdeee1a1 737 padFreeze(f, 1);
ef79bbde 738
ab91a058 739 result = 0;
740cleanup:
ec92465a 741 memset(misc, 0, sizeof(*misc));
496d88d4 742 SaveFuncs.close(f);
ab91a058 743 return result;
ef79bbde
P		 744}
745
746int LoadState(const char *file) {
ec92465a 747 struct misc_save_data *misc = (void *)(psxH + 0xf000);
584fc319 748 u32 biosBranchCheckOld = psxRegs.biosBranchCheck;
496d88d4 749 void *f;
ab91a058 750 GPUFreeze_t *gpufP = NULL;
751 SPUFreeze_t *spufP = NULL;
ef79bbde
P		 752 int Size;
753 char header[32];
754 u32 version;
755 boolean hle;
ab91a058 756 int result = -1;
ef79bbde 757
496d88d4 758 f = SaveFuncs.open(file, "rb");
ef79bbde
P		 759 if (f == NULL) return -1;
760
496d88d4 761 SaveFuncs.read(f, header, sizeof(header));
762 SaveFuncs.read(f, &version, sizeof(u32));
763 SaveFuncs.read(f, &hle, sizeof(boolean));
ef79bbde 764
33f56da1 765 if (strncmp("STv4 PCSX", header, 9) != 0 || version != SaveVersion) {
ab91a058 766 SysPrintf("incompatible savestate version %x\n", version);
767 goto cleanup;
ef79bbde 768 }
33f56da1 769 Config.HLE = hle;
770
771 if (Config.HLE)
772 psxBiosInit();
ef79bbde 773
496d88d4 774 SaveFuncs.seek(f, 128 * 96 * 3, SEEK_CUR);
496d88d4 775 SaveFuncs.read(f, psxM, 0x00200000);
776 SaveFuncs.read(f, psxR, 0x00080000);
777 SaveFuncs.read(f, psxH, 0x00010000);
630b122b 778 SaveFuncs.read(f, &psxRegs, offsetof(psxRegisters, gteBusyCycle));
779 psxRegs.gteBusyCycle = psxRegs.cycle;
584fc319 780 psxRegs.biosBranchCheck = ~0;
8cba0a22 781 psxRegs.gpuIdleAfter = psxRegs.cycle - 1;
782 HW_GPU_STATUS &= SWAP32(~PSXGPU_nBUSY);
ec92465a 783 if (misc->magic == MISC_MAGIC) {
784 psxRegs.gteBusyCycle = misc->gteBusyCycle;
785 psxRegs.muldivBusyCycle = misc->muldivBusyCycle;
786 psxRegs.biuReg = misc->biuReg;
787 psxRegs.biosBranchCheck = misc->biosBranchCheck;
788 psxRegs.gpuIdleAfter = misc->gpuIdleAfter;
789 HW_GPU_STATUS = misc->gpuSr;
790 frame_counter = misc->frame_counter;
791 CdromFrontendId = misc->CdromFrontendId;
792 }
ef79bbde 793
20196899 794 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
6962f770 795
ef79bbde
P		 796 if (Config.HLE)
797 psxBiosFreeze(0);
798
799 // gpu
800 gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t));
ab91a058 801 if (gpufP == NULL) goto cleanup;
496d88d4 802 SaveFuncs.read(f, gpufP, sizeof(GPUFreeze_t));
ef79bbde
P		 803 GPU_freeze(0, gpufP);
804 free(gpufP);
8cba0a22 805 gpuSyncPluginSR();
ef79bbde
P		 806
807 // spu
496d88d4 808 SaveFuncs.read(f, &Size, 4);
ef79bbde 809 spufP = (SPUFreeze_t *)malloc(Size);
ab91a058 810 if (spufP == NULL) goto cleanup;
496d88d4 811 SaveFuncs.read(f, spufP, Size);
650adfd2 812 SPU_freeze(0, spufP, psxRegs.cycle);
ef79bbde
P		 813 free(spufP);
814
815 sioFreeze(f, 0);
816 cdrFreeze(f, 0);
817 psxHwFreeze(f, 0);
818 psxRcntFreeze(f, 0);
819 mdecFreeze(f, 0);
03f55e6b 820 new_dyna_freeze(f, 0);
bdeee1a1 821 padFreeze(f, 0);
ef79bbde 822
c6a249e3 823 events_restore();
584fc319 824 if (Config.HLE)
403a6290 825 psxBiosCheckExe(biosBranchCheckOld, 0x60, 1);
584fc319 826
ab91a058 827 result = 0;
828cleanup:
ec92465a 829 memset(misc, 0, sizeof(*misc));
496d88d4 830 SaveFuncs.close(f);
ab91a058 831 return result;
ef79bbde
P		 832}
833
834int CheckState(const char *file) {
496d88d4 835 void *f;
ef79bbde
P		 836 char header[32];
837 u32 version;
838 boolean hle;
839
496d88d4 840 f = SaveFuncs.open(file, "rb");
ef79bbde
P		 841 if (f == NULL) return -1;
842
496d88d4 843 SaveFuncs.read(f, header, sizeof(header));
844 SaveFuncs.read(f, &version, sizeof(u32));
845 SaveFuncs.read(f, &hle, sizeof(boolean));
ef79bbde 846
496d88d4 847 SaveFuncs.close(f);
ef79bbde 848
33f56da1 849 if (strncmp("STv4 PCSX", header, 9) != 0 || version != SaveVersion)
ef79bbde
P		 850 return -1;
851
852 return 0;
853}
854
855// NET Function Helpers
856
857int SendPcsxInfo() {
858 if (NET_recvData == NULL || NET_sendData == NULL)
859 return 0;
860
840639a5 861 boolean Sio_old = 0;
862 boolean SpuIrq_old = 0;
863 boolean RCntFix_old = 0;
ef79bbde 864 NET_sendData(&Config.Xa, sizeof(Config.Xa), PSE_NET_BLOCKING);
840639a5 865 NET_sendData(&Sio_old, sizeof(Sio_old), PSE_NET_BLOCKING);
866 NET_sendData(&SpuIrq_old, sizeof(SpuIrq_old), PSE_NET_BLOCKING);
867 NET_sendData(&RCntFix_old, sizeof(RCntFix_old), PSE_NET_BLOCKING);
ef79bbde
P		 868 NET_sendData(&Config.PsxType, sizeof(Config.PsxType), PSE_NET_BLOCKING);
869 NET_sendData(&Config.Cpu, sizeof(Config.Cpu), PSE_NET_BLOCKING);
870
871 return 0;
872}
873
874int RecvPcsxInfo() {
875 int tmp;
876
877 if (NET_recvData == NULL || NET_sendData == NULL)
878 return 0;
879
840639a5 880 boolean Sio_old = 0;
881 boolean SpuIrq_old = 0;
882 boolean RCntFix_old = 0;
ef79bbde 883 NET_recvData(&Config.Xa, sizeof(Config.Xa), PSE_NET_BLOCKING);
840639a5 884 NET_recvData(&Sio_old, sizeof(Sio_old), PSE_NET_BLOCKING);
885 NET_recvData(&SpuIrq_old, sizeof(SpuIrq_old), PSE_NET_BLOCKING);
886 NET_recvData(&RCntFix_old, sizeof(RCntFix_old), PSE_NET_BLOCKING);
ef79bbde
P		 887 NET_recvData(&Config.PsxType, sizeof(Config.PsxType), PSE_NET_BLOCKING);
888
ef79bbde
P		 889 tmp = Config.Cpu;
890 NET_recvData(&Config.Cpu, sizeof(Config.Cpu), PSE_NET_BLOCKING);
891 if (tmp != Config.Cpu) {
892 psxCpu->Shutdown();
630b122b 893#ifndef DRC_DISABLE
ef79bbde
P		 894 if (Config.Cpu == CPU_INTERPRETER) psxCpu = &psxInt;
895 else psxCpu = &psxRec;
896#else
897 psxCpu = &psxInt;
898#endif
899 if (psxCpu->Init() == -1) {
900 SysClose(); return -1;
901 }
902 psxCpu->Reset();
20196899 903 psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
ef79bbde
P		 904 }
905
906 return 0;
907}
908
909// remove the leading and trailing spaces in a string
910void trim(char *str) {
911 int pos = 0;
912 char *dest = str;
913
914 // skip leading blanks
915 while (str[pos] <= ' ' && str[pos] > 0)
916 pos++;
917
918 while (str[pos]) {
919 *(dest++) = str[pos];
920 pos++;
921 }
922
923 *(dest--) = '\0'; // store the null
924
925 // remove trailing blanks
926 while (dest >= str && *dest <= ' ' && *dest > 0)
927 *(dest--) = '\0';
928}
929
930// lookup table for crc calculation
931static unsigned short crctab[256] = {
932 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
933 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210,
934 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B,
935 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401,
936 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE,
937 0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6,
938 0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D,
939 0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
940 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
941 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC,
942 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4,
943 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD,
944 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13,
945 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
946 0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E,
947 0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
948 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
949 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB,
950 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
951 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8,
952 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657,
953 0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9,
954 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882,
955 0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
956 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
957 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07,
958 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D,
959 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
960 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
961};
962
963u16 calcCrc(u8 *d, int len) {
964 u16 crc = 0;
965 int i;
966
967 for (i = 0; i < len; i++) {
968 crc = crctab[(crc >> 8) ^ d[i]] ^ (crc << 8);
969 }
970
971 return ~crc;
972}
ARM optimized PCSX fork