libpcsxcore/psxbios.c

   1 /***************************************************************************
   2  *   Copyright (C) 2019 Ryan Schultz, PCSX-df Team, PCSX team, gameblabla, *
   3  *   dmitrysmagin, senquack                                                *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
  19  ***************************************************************************/
  20
  21 /* Gameblabla 2018-2019 :
  22  * Numerous changes to bios calls as well as improvements in order to conform to nocash's findings
  23  * for the PSX bios calls. Thanks senquack for helping out with some of the changes
  24  * and helping to spot issues and refine my patches.
  25  * */
  26
  27 /*
  28  * Internal simulated HLE BIOS.
  29  */
  30
  31 // TODO: implement all system calls, count the exact CPU cycles of system calls.
  32
  33 #include "psxbios.h"
  34 #include "psxhw.h"
  35 #include "gpu.h"
  36 #include "sio.h"
  37 #include <zlib.h>
  38
  39 #undef SysPrintf
  40 #define SysPrintf if (Config.PsxOut) printf
  41
  42 char *biosA0n[256] = {
  43 // 0x00
  44         "open",         "lseek",        "read",         "write",
  45         "close",        "ioctl",        "exit",         "sys_a0_07",
  46         "getc",         "putc",         "todigit",      "atof",
  47         "strtoul",      "strtol",       "abs",          "labs",
  48 // 0x10
  49         "atoi",         "atol",         "atob",         "setjmp",
  50         "longjmp",      "strcat",       "strncat",      "strcmp",
  51         "strncmp",      "strcpy",       "strncpy",      "strlen",
  52         "index",        "rindex",       "strchr",       "strrchr",
  53 // 0x20
  54         "strpbrk",      "strspn",       "strcspn",      "strtok",
  55         "strstr",       "toupper",      "tolower",      "bcopy",
  56         "bzero",        "bcmp",         "memcpy",       "memset",
  57         "memmove",      "memcmp",       "memchr",       "rand",
  58 // 0x30
  59         "srand",        "qsort",        "strtod",       "malloc",
  60         "free",         "lsearch",      "bsearch",      "calloc",
  61         "realloc",      "InitHeap",     "_exit",        "getchar",
  62         "putchar",      "gets",         "puts",         "printf",
  63 // 0x40
  64         "sys_a0_40",            "LoadTest",                                     "Load",         "Exec",
  65         "FlushCache",           "InstallInterruptHandler",      "GPU_dw",       "mem2vram",
  66         "SendGPUStatus",        "GPU_cw",                                       "GPU_cwb",      "SendPackets",
  67         "sys_a0_4c",            "GetGPUStatus",                         "GPU_sync",     "sys_a0_4f",
  68 // 0x50
  69         "sys_a0_50",            "LoadExec",                             "GetSysSp",             "sys_a0_53",
  70         "_96_init()",           "_bu_init()",                   "_96_remove()", "sys_a0_57",
  71         "sys_a0_58",            "sys_a0_59",                    "sys_a0_5a",    "dev_tty_init",
  72         "dev_tty_open",         "sys_a0_5d",                    "dev_tty_ioctl","dev_cd_open",
  73 // 0x60
  74         "dev_cd_read",          "dev_cd_close",                 "dev_cd_firstfile",     "dev_cd_nextfile",
  75         "dev_cd_chdir",         "dev_card_open",                "dev_card_read",        "dev_card_write",
  76         "dev_card_close",       "dev_card_firstfile",   "dev_card_nextfile","dev_card_erase",
  77         "dev_card_undelete","dev_card_format",          "dev_card_rename",      "dev_card_6f",
  78 // 0x70
  79         "_bu_init",                     "_96_init",             "_96_remove",           "sys_a0_73",
  80         "sys_a0_74",            "sys_a0_75",    "sys_a0_76",            "sys_a0_77",
  81         "_96_CdSeekL",          "sys_a0_79",    "sys_a0_7a",            "sys_a0_7b",
  82         "_96_CdGetStatus",      "sys_a0_7d",    "_96_CdRead",           "sys_a0_7f",
  83 // 0x80
  84         "sys_a0_80",            "sys_a0_81",    "sys_a0_82",            "sys_a0_83",
  85         "sys_a0_84",            "_96_CdStop",   "sys_a0_86",            "sys_a0_87",
  86         "sys_a0_88",            "sys_a0_89",    "sys_a0_8a",            "sys_a0_8b",
  87         "sys_a0_8c",            "sys_a0_8d",    "sys_a0_8e",            "sys_a0_8f",
  88 // 0x90
  89         "sys_a0_90",            "sys_a0_91",    "sys_a0_92",            "sys_a0_93",
  90         "sys_a0_94",            "sys_a0_95",    "AddCDROMDevice",       "AddMemCardDevide",
  91         "DisableKernelIORedirection",           "EnableKernelIORedirection", "sys_a0_9a", "sys_a0_9b",
  92         "SetConf",                      "GetConf",              "sys_a0_9e",            "SetMem",
  93 // 0xa0
  94         "_boot",                        "SystemError",  "EnqueueCdIntr",        "DequeueCdIntr",
  95         "sys_a0_a4",            "ReadSector",   "get_cd_status",        "bufs_cb_0",
  96         "bufs_cb_1",            "bufs_cb_2",    "bufs_cb_3",            "_card_info",
  97         "_card_load",           "_card_auto",   "bufs_cd_4",            "sys_a0_af",
  98 // 0xb0
  99         "sys_a0_b0",            "sys_a0_b1",    "do_a_long_jmp",        "sys_a0_b3",
 100         "?? sub_function",
 101 };
 102
 103 char *biosB0n[256] = {
 104 // 0x00
 105         "SysMalloc",            "sys_b0_01",    "sys_b0_02",    "sys_b0_03",
 106         "sys_b0_04",            "sys_b0_05",    "sys_b0_06",    "DeliverEvent",
 107         "OpenEvent",            "CloseEvent",   "WaitEvent",    "TestEvent",
 108         "EnableEvent",          "DisableEvent", "OpenTh",               "CloseTh",
 109 // 0x10
 110         "ChangeTh",                     "sys_b0_11",    "InitPAD",              "StartPAD",
 111         "StopPAD",                      "PAD_init",             "PAD_dr",               "ReturnFromExecption",
 112         "ResetEntryInt",        "HookEntryInt", "sys_b0_1a",    "sys_b0_1b",
 113         "sys_b0_1c",            "sys_b0_1d",    "sys_b0_1e",    "sys_b0_1f",
 114 // 0x20
 115         "UnDeliverEvent",       "sys_b0_21",    "sys_b0_22",    "sys_b0_23",
 116         "sys_b0_24",            "sys_b0_25",    "sys_b0_26",    "sys_b0_27",
 117         "sys_b0_28",            "sys_b0_29",    "sys_b0_2a",    "sys_b0_2b",
 118         "sys_b0_2c",            "sys_b0_2d",    "sys_b0_2e",    "sys_b0_2f",
 119 // 0x30
 120         "sys_b0_30",            "sys_b0_31",    "open",                 "lseek",
 121         "read",                         "write",                "close",                "ioctl",
 122         "exit",                         "sys_b0_39",    "getc",                 "putc",
 123         "getchar",                      "putchar",              "gets",                 "puts",
 124 // 0x40
 125         "cd",                           "format",               "firstfile",    "nextfile",
 126         "rename",                       "delete",               "undelete",             "AddDevice",
 127         "RemoteDevice",         "PrintInstalledDevices", "InitCARD", "StartCARD",
 128         "StopCARD",                     "sys_b0_4d",    "_card_write",  "_card_read",
 129 // 0x50
 130         "_new_card",            "Krom2RawAdd",  "sys_b0_52",    "sys_b0_53",
 131         "_get_errno",           "_get_error",   "GetC0Table",   "GetB0Table",
 132         "_card_chan",           "sys_b0_59",    "sys_b0_5a",    "ChangeClearPAD",
 133         "_card_status",         "_card_wait",
 134 };
 135
 136 char *biosC0n[256] = {
 137 // 0x00
 138         "InitRCnt",                       "InitException",              "SysEnqIntRP",          "SysDeqIntRP",
 139         "get_free_EvCB_slot", "get_free_TCB_slot",      "ExceptionHandler",     "InstallExeptionHandler",
 140         "SysInitMemory",          "SysInitKMem",                "ChangeClearRCnt",      "SystemError",
 141         "InitDefInt",             "sys_c0_0d",                  "sys_c0_0e",            "sys_c0_0f",
 142 // 0x10
 143         "sys_c0_10",              "sys_c0_11",                  "InstallDevices",       "FlushStfInOutPut",
 144         "sys_c0_14",              "_cdevinput",                 "_cdevscan",            "_circgetc",
 145         "_circputc",              "ioabort",                    "sys_c0_1a",            "KernelRedirect",
 146         "PatchAOTable",
 147 };
 148
 149 //#define r0 (psxRegs.GPR.n.r0)
 150 #define at (psxRegs.GPR.n.at)
 151 #define v0 (psxRegs.GPR.n.v0)
 152 #define v1 (psxRegs.GPR.n.v1)
 153 #define a0 (psxRegs.GPR.n.a0)
 154 #define a1 (psxRegs.GPR.n.a1)
 155 #define a2 (psxRegs.GPR.n.a2)
 156 #define a3 (psxRegs.GPR.n.a3)
 157 #define t0 (psxRegs.GPR.n.t0)
 158 #define t1 (psxRegs.GPR.n.t1)
 159 #define t2 (psxRegs.GPR.n.t2)
 160 #define t3 (psxRegs.GPR.n.t3)
 161 #define t4 (psxRegs.GPR.n.t4)
 162 #define t5 (psxRegs.GPR.n.t5)
 163 #define t6 (psxRegs.GPR.n.t6)
 164 #define t7 (psxRegs.GPR.n.t7)
 165 #define t8 (psxRegs.GPR.n.t8)
 166 #define t9 (psxRegs.GPR.n.t9)
 167 #define s0 (psxRegs.GPR.n.s0)
 168 #define s1 (psxRegs.GPR.n.s1)
 169 #define s2 (psxRegs.GPR.n.s2)
 170 #define s3 (psxRegs.GPR.n.s3)
 171 #define s4 (psxRegs.GPR.n.s4)
 172 #define s5 (psxRegs.GPR.n.s5)
 173 #define s6 (psxRegs.GPR.n.s6)
 174 #define s7 (psxRegs.GPR.n.s7)
 175 #define k0 (psxRegs.GPR.n.k0)
 176 #define k1 (psxRegs.GPR.n.k1)
 177 #define gp (psxRegs.GPR.n.gp)
 178 #define sp (psxRegs.GPR.n.sp)
 179 #define fp (psxRegs.GPR.n.s8)
 180 #define ra (psxRegs.GPR.n.ra)
 181 #define pc0 (psxRegs.pc)
 182
 183 #define Ra0 ((char *)PSXM(a0))
 184 #define Ra1 ((char *)PSXM(a1))
 185 #define Ra2 ((char *)PSXM(a2))
 186 #define Ra3 ((char *)PSXM(a3))
 187 #define Rv0 ((char *)PSXM(v0))
 188 #define Rsp ((char *)PSXM(sp))
 189
 190 typedef struct {
 191         u32 desc;
 192         s32 status;
 193         s32 mode;
 194         u32 fhandler;
 195 } EvCB[32];
 196
 197 #define EvStUNUSED      0x0000
 198 #define EvStWAIT        0x1000
 199 #define EvStACTIVE      0x2000
 200 #define EvStALREADY 0x4000
 201
 202 #define EvMdINTR        0x1000
 203 #define EvMdNOINTR      0x2000
 204
 205 /*
 206 typedef struct {
 207         s32 next;
 208         s32 func1;
 209         s32 func2;
 210         s32 pad;
 211 } SysRPst;
 212 */
 213
 214 typedef struct {
 215         s32 status;
 216         s32 mode;
 217         u32 reg[32];
 218         u32 func;
 219 } TCB;
 220
 221 typedef struct {
 222         u32 _pc0;
 223         u32 gp0;
 224         u32 t_addr;
 225         u32 t_size;
 226         u32 d_addr;
 227         u32 d_size;
 228         u32 b_addr;
 229         u32 b_size;
 230         u32 S_addr;
 231         u32 s_size;
 232         u32 _sp, _fp, _gp, ret, base;
 233 } EXEC;
 234
 235 struct DIRENTRY {
 236         char name[20];
 237         s32 attr;
 238         s32 size;
 239         u32 next;
 240         s32 head;
 241         char system[4];
 242 };
 243
 244 typedef struct {
 245         char name[32];
 246         u32  mode;
 247         u32  offset;
 248         u32  size;
 249         u32  mcfile;
 250 } FileDesc;
 251
 252 static u32 *jmp_int = NULL;
 253 static int *pad_buf = NULL;
 254 static char *pad_buf1 = NULL, *pad_buf2 = NULL;
 255 static int pad_buf1len, pad_buf2len;
 256 static int pad_stopped = 0;
 257
 258 static u32 regs[35];
 259 static EvCB *EventCB;
 260 static EvCB *HwEV; // 0xf0
 261 static EvCB *EvEV; // 0xf1
 262 static EvCB *RcEV; // 0xf2
 263 static EvCB *UeEV; // 0xf3
 264 static EvCB *SwEV; // 0xf4
 265 static EvCB *ThEV; // 0xff
 266 static u32 heap_size = 0;
 267 static u32 *heap_addr = NULL;
 268 static u32 *heap_end = NULL;
 269 static u32 SysIntRP[8];
 270 static int CardState = -1;
 271 static TCB ThreadCB[8];
 272 static int CurThread = 0;
 273 static FileDesc FDesc[32];
 274 static u32 card_active_chan = 0;
 275
 276 boolean hleSoftCall = FALSE;
 277
 278 static inline void softCall(u32 pc) {
 279         pc0 = pc;
 280         ra = 0x80001000;
 281
 282         hleSoftCall = TRUE;
 283
 284         while (pc0 != 0x80001000) psxCpu->ExecuteBlock();
 285
 286         hleSoftCall = FALSE;
 287 }
 288
 289 static inline void softCall2(u32 pc) {
 290         u32 sra = ra;
 291         pc0 = pc;
 292         ra = 0x80001000;
 293
 294         hleSoftCall = TRUE;
 295
 296         while (pc0 != 0x80001000) psxCpu->ExecuteBlock();
 297         ra = sra;
 298
 299         hleSoftCall = FALSE;
 300 }
 301
 302 static inline void DeliverEvent(u32 ev, u32 spec) {
 303         if (EventCB[ev][spec].status != EvStACTIVE) return;
 304
 305 //      EventCB[ev][spec].status = EvStALREADY;
 306         if (EventCB[ev][spec].mode == EvMdINTR) {
 307                 softCall2(EventCB[ev][spec].fhandler);
 308         } else EventCB[ev][spec].status = EvStALREADY;
 309 }
 310
 311 static unsigned interrupt_r26=0x8004E8B0;
 312
 313 static inline void SaveRegs() {
 314         memcpy(regs, psxRegs.GPR.r, 32*4);
 315         regs[32] = psxRegs.GPR.n.lo;
 316         regs[33] = psxRegs.GPR.n.hi;
 317         regs[34] = psxRegs.pc;
 318 }
 319
 320 static inline void LoadRegs() {
 321         memcpy(psxRegs.GPR.r, regs, 32*4);
 322         psxRegs.GPR.n.lo = regs[32];
 323         psxRegs.GPR.n.hi = regs[33];
 324 }
 325
 326 /*                                           *
 327 //                                           *
 328 //                                           *
 329 //               System calls A0             */
 330
 331
 332 #define buread(Ra1, mcd, length) { \
 333         SysPrintf("read %d: %x,%x (%s)\n", FDesc[1 + mcd].mcfile, FDesc[1 + mcd].offset, a2, Mcd##mcd##Data + 128 * FDesc[1 + mcd].mcfile + 0xa); \
 334         ptr = Mcd##mcd##Data + 8192 * FDesc[1 + mcd].mcfile + FDesc[1 + mcd].offset; \
 335         memcpy(Ra1, ptr, length); \
 336         if (FDesc[1 + mcd].mode & 0x8000) { \
 337         DeliverEvent(0x11, 0x2); /* 0xf0000011, 0x0004 */ \
 338         DeliverEvent(0x81, 0x2); /* 0xf4000001, 0x0004 */ \
 339         v0 = 0; } \
 340         else v0 = length; \
 341         FDesc[1 + mcd].offset += v0; \
 342 }
 343
 344 #define buwrite(Ra1, mcd, length) { \
 345         u32 offset =  + 8192 * FDesc[1 + mcd].mcfile + FDesc[1 + mcd].offset; \
 346         SysPrintf("write %d: %x,%x\n", FDesc[1 + mcd].mcfile, FDesc[1 + mcd].offset, a2); \
 347         ptr = Mcd##mcd##Data + offset; \
 348         memcpy(ptr, Ra1, length); \
 349         FDesc[1 + mcd].offset += length; \
 350         SaveMcd(Config.Mcd##mcd, Mcd##mcd##Data, offset, length); \
 351         if (FDesc[1 + mcd].mode & 0x8000) { \
 352         DeliverEvent(0x11, 0x2); /* 0xf0000011, 0x0004 */ \
 353         DeliverEvent(0x81, 0x2); /* 0xf4000001, 0x0004 */ \
 354         v0 = 0; } \
 355         else v0 = length; \
 356 }
 357
 358
 359 /* Internally redirects to "FileRead(fd,tempbuf,1)".*/
 360 /* For some strange reason, the returned character is sign-expanded; */
 361 /* So if a return value of FFFFFFFFh could mean either character FFh, or error. */
 362 /* TODO FIX ME : Properly implement this behaviour */
 363 void psxBios_getc(void) // 0x03, 0x35
 364 {
 365         char *ptr;
 366         void *pa1 = Ra1;
 367 #ifdef PSXBIOS_LOG
 368         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x03]);
 369 #endif
 370         v0 = -1;
 371
 372         if (pa1) {
 373                 switch (a0) {
 374                         case 2: buread(pa1, 1, 1); break;
 375                         case 3: buread(pa1, 2, 1); break;
 376                 }
 377         }
 378
 379         pc0 = ra;
 380 }
 381
 382 /* Copy of psxBios_write, except size is 1. */
 383 void psxBios_putc(void) // 0x09, 0x3B
 384 {
 385         char *ptr;
 386         void *pa1 = Ra1;
 387 #ifdef PSXBIOS_LOG
 388         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x09]);
 389 #endif
 390         v0 = -1;
 391         if (!pa1) {
 392                 pc0 = ra;
 393                 return;
 394         }
 395
 396         if (a0 == 1) { // stdout
 397                 char *ptr = (char *)pa1;
 398
 399                 v0 = a2;
 400                 while (a2 > 0) {
 401                         printf("%c", *ptr++); a2--;
 402                 }
 403                 pc0 = ra; return;
 404         }
 405
 406         switch (a0) {
 407                 case 2: buwrite(pa1, 1, 1); break;
 408                 case 3: buwrite(pa1, 2, 1); break;
 409         }
 410
 411         pc0 = ra;
 412 }
 413
 414 void psxBios_todigit(void) // 0x0a
 415 {
 416         int c = a0;
 417 #ifdef PSXBIOS_LOG
 418         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x0a]);
 419 #endif
 420         c &= 0xFF;
 421         if (c >= 0x30 && c < 0x3A) {
 422                 c -= 0x30;
 423         }
 424         else if (c > 0x60 && c < 0x7B) {
 425                 c -= 0x20;
 426         }
 427         else if (c > 0x40 && c < 0x5B) {
 428                 c = c - 0x41 + 10;
 429         }
 430         else if (c >= 0x80) {
 431                 c = -1;
 432         }
 433         else
 434         {
 435                 c = 0x0098967F;
 436         }
 437         v0 = c;
 438         pc0 = ra;
 439 }
 440
 441 void psxBios_abs() { // 0x0e
 442         if ((s32)a0 < 0) v0 = -(s32)a0;
 443         else v0 = a0;
 444         pc0 = ra;
 445 }
 446
 447 void psxBios_labs() { // 0x0f
 448         psxBios_abs();
 449 }
 450
 451 void psxBios_atoi() { // 0x10
 452         s32 n = 0, f = 0;
 453         char *p = (char *)Ra0;
 454
 455         for (;;p++) {
 456                 switch (*p) {
 457                         case ' ': case '\t': continue;
 458                         case '-': f++;
 459                         case '+': p++;
 460                 }
 461                 break;
 462         }
 463
 464         while (*p >= '0' && *p <= '9') {
 465                 n = n * 10 + *p++ - '0';
 466         }
 467
 468         v0 = (f ? -n : n);
 469         pc0 = ra;
 470 }
 471
 472 void psxBios_atol() { // 0x11
 473         psxBios_atoi();
 474 }
 475
 476 void psxBios_setjmp() { // 0x13
 477         u32 *jmp_buf = (u32 *)Ra0;
 478         int i;
 479
 480 #ifdef PSXBIOS_LOG
 481         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x13]);
 482 #endif
 483
 484         jmp_buf[0] = ra;
 485         jmp_buf[1] = sp;
 486         jmp_buf[2] = fp;
 487         for (i = 0; i < 8; i++) // s0-s7
 488                 jmp_buf[3 + i] = psxRegs.GPR.r[16 + i];
 489         jmp_buf[11] = gp;
 490
 491         v0 = 0; pc0 = ra;
 492 }
 493
 494 void psxBios_longjmp() { // 0x14
 495         u32 *jmp_buf = (u32 *)Ra0;
 496         int i;
 497
 498 #ifdef PSXBIOS_LOG
 499         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x14]);
 500 #endif
 501
 502         ra = jmp_buf[0]; /* ra */
 503         sp = jmp_buf[1]; /* sp */
 504         fp = jmp_buf[2]; /* fp */
 505         for (i = 0; i < 8; i++) // s0-s7
 506                 psxRegs.GPR.r[16 + i] = jmp_buf[3 + i];
 507         gp = jmp_buf[11]; /* gp */
 508
 509         v0 = a1; pc0 = ra;
 510 }
 511
 512 void psxBios_strcat() { // 0x15
 513         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 514
 515 #ifdef PSXBIOS_LOG
 516         PSXBIOS_LOG("psxBios_%s: %s, %s\n", biosA0n[0x15], Ra0, Ra1);
 517 #endif
 518         if (a0 == 0 || a1 == 0)
 519         {
 520                 v0 = 0;
 521                 pc0 = ra;
 522                 return;
 523         }
 524         while (*p1++);
 525         --p1;
 526         while ((*p1++ = *p2++) != '\0');
 527
 528         v0 = a0; pc0 = ra;
 529 }
 530
 531 void psxBios_strncat() { // 0x16
 532         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 533         s32 n = a2;
 534
 535 #ifdef PSXBIOS_LOG
 536         PSXBIOS_LOG("psxBios_%s: %s (%x), %s (%x), %d\n", biosA0n[0x16], Ra0, a0, Ra1, a1, a2);
 537 #endif
 538         if (a0 == 0 || a1 == 0)
 539         {
 540                 v0 = 0;
 541                 pc0 = ra;
 542                 return;
 543         }
 544         while (*p1++);
 545         --p1;
 546         while ((*p1++ = *p2++) != '\0') {
 547                 if (--n < 0) {
 548                         *--p1 = '\0';
 549                         break;
 550                 }
 551         }
 552
 553         v0 = a0; pc0 = ra;
 554 }
 555
 556 void psxBios_strcmp() { // 0x17
 557         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 558         s32 n=0;
 559         if (a0 == 0 && a1 == 0)
 560         {
 561                 v0 = 0;
 562                 pc0 = ra;
 563                 return;
 564         }
 565         else if (a0 == 0 && a1 != 0)
 566         {
 567                 v0 = -1;
 568                 pc0 = ra;
 569                 return;
 570         }
 571         else if (a0 != 0 && a1 == 0)
 572         {
 573                 v0 = 1;
 574                 pc0 = ra;
 575                 return;
 576         }
 577 #ifdef PSXBIOS_LOG
 578         PSXBIOS_LOG("psxBios_%s: %s (%x), %s (%x)\n", biosA0n[0x17], Ra0, a0, Ra1, a1);
 579 #endif
 580
 581         while (*p1 == *p2++) {
 582                 n++;
 583                 if (*p1++ == '\0') {
 584                         v1=n-1;
 585                         a0+=n;
 586                         a1+=n;
 587                         v0 = 0;
 588                         pc0 = ra;
 589                         return;
 590                 }
 591         }
 592
 593         v0 = (*p1 - *--p2);
 594         v1 = n;
 595         a0+=n;
 596         a1+=n;
 597         pc0 = ra;
 598 }
 599
 600 void psxBios_strncmp() { // 0x18
 601         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 602         s32 n = a2;
 603         if (a0 == 0 && a1 == 0)
 604         {
 605                 v0 = 0;
 606                 pc0 = ra;
 607                 return;
 608         }
 609         else if (a0 == 0 && a1 != 0)
 610         {
 611                 v0 = -1;
 612                 pc0 = ra;
 613                 return;
 614         }
 615         else if (a0 != 0 && a1 == 0)
 616         {
 617                 v0 = 1;
 618                 pc0 = ra;
 619                 return;
 620         }
 621 #ifdef PSXBIOS_LOG
 622         PSXBIOS_LOG("psxBios_%s: %s (%x), %s (%x), %d\n", biosA0n[0x18], Ra0, a0, Ra1, a1, a2);
 623 #endif
 624
 625         while (--n >= 0 && *p1 == *p2++) {
 626                 if (*p1++ == '\0') {
 627                         v0 = 0;
 628                         pc0 = ra;
 629                         v1 = a2 - ((a2-n) - 1);
 630                         a0 += (a2-n) - 1;
 631                         a1 += (a2-n) - 1;
 632                         a2 = n;
 633                         return;
 634                 }
 635         }
 636
 637         v0 = (n < 0 ? 0 : *p1 - *--p2);
 638         pc0 = ra;
 639         v1 = a2 - ((a2-n) - 1);
 640         a0 += (a2-n) - 1;
 641         a1 += (a2-n) - 1;
 642         a2 = n;
 643 }
 644
 645 void psxBios_strcpy() { // 0x19
 646         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 647         if (a0 == 0 || a1 == 0)
 648         {
 649                 v0 = 0;
 650                 pc0 = ra;
 651                 return;
 652         }
 653         while ((*p1++ = *p2++) != '\0');
 654
 655         v0 = a0; pc0 = ra;
 656 }
 657
 658 void psxBios_strncpy() { // 0x1a
 659         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 660         s32 n = a2, i;
 661         if (a0 == 0 || a1 == 0)
 662         {
 663                 v0 = 0;
 664                 pc0 = ra;
 665                 return;
 666         }
 667         for (i = 0; i < n; i++) {
 668                 if ((*p1++ = *p2++) == '\0') {
 669                         while (++i < n) {
 670                                 *p1++ = '\0';
 671                         }
 672                         v0 = a0; pc0 = ra;
 673                         return;
 674                 }
 675         }
 676
 677         v0 = a0; pc0 = ra;
 678 }
 679
 680 void psxBios_strlen() { // 0x1b
 681         char *p = (char *)Ra0;
 682         v0 = 0;
 683         if (a0 == 0)
 684         {
 685                 pc0 = ra;
 686                 return;
 687         }
 688         while (*p++) v0++;
 689         pc0 = ra;
 690 }
 691
 692 void psxBios_index() { // 0x1c
 693         char *p = (char *)Ra0;
 694         if (a0 == 0)
 695         {
 696                 v0 = 0;
 697                 pc0 = ra;
 698                 return;
 699         }
 700
 701         do {
 702                 if (*p == a1) {
 703                         v0 = a0 + (p - (char *)Ra0);
 704                         pc0 = ra;
 705                         return;
 706                 }
 707         } while (*p++ != '\0');
 708
 709         v0 = 0; pc0 = ra;
 710 }
 711
 712 void psxBios_rindex() { // 0x1d
 713         char *p = (char *)Ra0;
 714
 715         v0 = 0;
 716         if (a0 == 0)
 717         {
 718                 pc0 = ra;
 719                 return;
 720         }
 721         do {
 722                 if (*p == a1)
 723                         v0 = a0 + (p - (char *)Ra0);
 724         } while (*p++ != '\0');
 725
 726         pc0 = ra;
 727 }
 728
 729 void psxBios_strchr() { // 0x1e
 730         psxBios_index();
 731 }
 732
 733 void psxBios_strrchr() { // 0x1f
 734         psxBios_rindex();
 735 }
 736
 737 void psxBios_strpbrk() { // 0x20
 738         char *p1 = (char *)Ra0, *p2 = (char *)Ra1, *scanp, c, sc;
 739
 740         while ((c = *p1++) != '\0') {
 741                 for (scanp = p2; (sc = *scanp++) != '\0';) {
 742                         if (sc == c) {
 743                                 v0 = a0 + (p1 - 1 - (char *)Ra0);
 744                                 pc0 = ra;
 745                                 return;
 746                         }
 747                 }
 748         }
 749
 750         // BUG: return a0 instead of NULL if not found
 751         v0 = a0; pc0 = ra;
 752 }
 753
 754 void psxBios_strspn() { // 0x21
 755         char *p1, *p2;
 756
 757         for (p1 = (char *)Ra0; *p1 != '\0'; p1++) {
 758                 for (p2 = (char *)Ra1; *p2 != '\0' && *p2 != *p1; p2++);
 759                 if (*p2 == '\0') break;
 760         }
 761
 762         v0 = p1 - (char *)Ra0; pc0 = ra;
 763 }
 764
 765 void psxBios_strcspn() { // 0x22
 766         char *p1, *p2;
 767
 768         for (p1 = (char *)Ra0; *p1 != '\0'; p1++) {
 769                 for (p2 = (char *)Ra1; *p2 != '\0' && *p2 != *p1; p2++);
 770                 if (*p2 != '\0') break;
 771         }
 772
 773         v0 = p1 - (char *)Ra0; pc0 = ra;
 774 }
 775
 776 void psxBios_strtok() { // 0x23
 777         char *pcA0 = (char *)Ra0;
 778         char *pcRet = strtok(pcA0, (char *)Ra1);
 779         if (pcRet)
 780                 v0 = a0 + pcRet - pcA0;
 781         else
 782                 v0 = 0;
 783         pc0 = ra;
 784 }
 785
 786 void psxBios_strstr() { // 0x24
 787         char *p = (char *)Ra0, *p1, *p2;
 788
 789         while (*p != '\0') {
 790                 p1 = p;
 791                 p2 = (char *)Ra1;
 792
 793                 while (*p1 != '\0' && *p2 != '\0' && *p1 == *p2) {
 794                         p1++; p2++;
 795                 }
 796
 797                 if (*p2 == '\0') {
 798                         v0 = a0 + (p - (char *)Ra0);
 799                         pc0 = ra;
 800                         return;
 801                 }
 802
 803                 p++;
 804         }
 805
 806         v0 = 0; pc0 = ra;
 807 }
 808
 809 void psxBios_toupper() { // 0x25
 810         v0 = (s8)(a0 & 0xff);
 811         if (v0 >= 'a' && v0 <= 'z') v0 -= 'a' - 'A';
 812         pc0 = ra;
 813 }
 814
 815 void psxBios_tolower() { // 0x26
 816         v0 = (s8)(a0 & 0xff);
 817         if (v0 >= 'A' && v0 <= 'Z') v0 += 'a' - 'A';
 818         pc0 = ra;
 819 }
 820
 821 void psxBios_bcopy() { // 0x27
 822         char *p1 = (char *)Ra1, *p2 = (char *)Ra0;
 823         v0 = a0;
 824         if (a0 == 0 || a2 > 0x7FFFFFFF)
 825         {
 826                 pc0 = ra;
 827                 return;
 828         }
 829         while ((s32)a2-- > 0) *p1++ = *p2++;
 830         a2 = 0;
 831         pc0 = ra;
 832 }
 833
 834 void psxBios_bzero() { // 0x28
 835         char *p = (char *)Ra0;
 836         v0 = a0;
 837         /* Same as memset here (See memset below) */
 838         if (a1 > 0x7FFFFFFF || a1 == 0)
 839         {
 840                 v0 = 0;
 841                 pc0 = ra;
 842                 return;
 843         }
 844         else if (a0 == 0)
 845         {
 846                 pc0 = ra;
 847                 return;
 848         }
 849         while ((s32)a1-- > 0) *p++ = '\0';
 850         a1 = 0;
 851         pc0 = ra;
 852 }
 853
 854 void psxBios_bcmp() { // 0x29
 855         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 856
 857         if (a0 == 0 || a1 == 0) { v0 = 0; pc0 = ra; return; }
 858
 859         while ((s32)a2-- > 0) {
 860                 if (*p1++ != *p2++) {
 861                         v0 = *p1 - *p2; // BUG: compare the NEXT byte
 862                         pc0 = ra;
 863                         return;
 864                 }
 865         }
 866
 867         v0 = 0; pc0 = ra;
 868 }
 869
 870 void psxBios_memcpy() { // 0x2a
 871         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 872         v0 = a0;
 873         if (a0 == 0 || a2 > 0x7FFFFFFF)
 874         {
 875                 pc0 = ra;
 876                 return;
 877         }
 878         while ((s32)a2-- > 0) {
 879                 *p1++ = *p2++;
 880         }
 881         a2 = 0;
 882         pc0 = ra;
 883 }
 884
 885 void psxBios_memset() { // 0x2b
 886         char *p = (char *)Ra0;
 887         v0 = a0;
 888         if (a2 > 0x7FFFFFFF || a2 == 0)
 889         {
 890                 v0 = 0;
 891                 pc0 = ra;
 892                 return;
 893         }
 894         if (a0 == 0)
 895         {
 896                 pc0 = ra;
 897                 return;
 898         }
 899         while ((s32)a2-- > 0) *p++ = (char)a1;
 900         a2 = 0;
 901         v0 = a0; pc0 = ra;
 902 }
 903
 904 void psxBios_memmove() { // 0x2c
 905         char *p1 = (char *)Ra0, *p2 = (char *)Ra1;
 906         v0 = a0;
 907         if (a0 == 0 || a2 > 0x7FFFFFFF)
 908         {
 909                 pc0 = ra;
 910                 return;
 911         }
 912         if (p2 <= p1 && p2 + a2 > p1) {
 913                 a2++; // BUG: copy one more byte here
 914                 p1 += a2;
 915                 p2 += a2;
 916                 while ((s32)a2-- > 0) *--p1 = *--p2;
 917         } else {
 918                 while ((s32)a2-- > 0) *p1++ = *p2++;
 919         }
 920         pc0 = ra;
 921 }
 922
 923 void psxBios_memcmp() { // 0x2d
 924         psxBios_bcmp();
 925 }
 926
 927 void psxBios_memchr() { // 0x2e
 928         char *p = (char *)Ra0;
 929
 930         if (a0 == 0 || a2 > 0x7FFFFFFF)
 931         {
 932                 pc0 = ra;
 933                 return;
 934         }
 935
 936         while ((s32)a2-- > 0) {
 937                 if (*p++ != (s8)a1) continue;
 938                 v0 = a0 + (p - (char *)Ra0 - 1);
 939                 pc0 = ra;
 940                 return;
 941         }
 942
 943         v0 = 0; pc0 = ra;
 944 }
 945
 946 void psxBios_rand() { // 0x2f
 947         u32 s = psxMu32(0x9010) * 1103515245 + 12345;
 948         v0 = (s >> 16) & 0x7fff;
 949         psxMu32ref(0x9010) = SWAPu32(s);
 950         pc0 = ra;
 951 }
 952
 953 void psxBios_srand() { // 0x30
 954         psxMu32ref(0x9010) = SWAPu32(a0);
 955         pc0 = ra;
 956 }
 957
 958 static u32 qscmpfunc, qswidth;
 959
 960 static inline int qscmp(char *a, char *b) {
 961         u32 sa0 = a0;
 962
 963         a0 = sa0 + (a - (char *)PSXM(sa0));
 964         a1 = sa0 + (b - (char *)PSXM(sa0));
 965
 966         softCall2(qscmpfunc);
 967
 968         a0 = sa0;
 969         return (s32)v0;
 970 }
 971
 972 static inline void qexchange(char *i, char *j) {
 973         char t;
 974         int n = qswidth;
 975
 976         do {
 977                 t = *i;
 978                 *i++ = *j;
 979                 *j++ = t;
 980         } while (--n);
 981 }
 982
 983 static inline void q3exchange(char *i, char *j, char *k) {
 984         char t;
 985         int n = qswidth;
 986
 987         do {
 988                 t = *i;
 989                 *i++ = *k;
 990                 *k++ = *j;
 991                 *j++ = t;
 992         } while (--n);
 993 }
 994
 995 static void qsort_main(char *a, char *l) {
 996         char *i, *j, *lp, *hp;
 997         int c;
 998         unsigned int n;
 999
1000 start:
1001         if ((n = l - a) <= qswidth)
1002                 return;
1003         n = qswidth * (n / (2 * qswidth));
1004         hp = lp = a + n;
1005         i = a;
1006         j = l - qswidth;
1007         while (TRUE) {
1008                 if (i < lp) {
1009                         if ((c = qscmp(i, lp)) == 0) {
1010                                 qexchange(i, lp -= qswidth);
1011                                 continue;
1012                         }
1013                         if (c < 0) {
1014                                 i += qswidth;
1015                                 continue;
1016                         }
1017                 }
1018
1019 loop:
1020                 if (j > hp) {
1021                         if ((c = qscmp(hp, j)) == 0) {
1022                                 qexchange(hp += qswidth, j);
1023                                 goto loop;
1024                         }
1025                         if (c > 0) {
1026                                 if (i == lp) {
1027                                         q3exchange(i, hp += qswidth, j);
1028                                         i = lp += qswidth;
1029                                         goto loop;
1030                                 }
1031                                 qexchange(i, j);
1032                                 j -= qswidth;
1033                                 i += qswidth;
1034                                 continue;
1035                         }
1036                         j -= qswidth;
1037                         goto loop;
1038                 }
1039
1040                 if (i == lp) {
1041                         if (lp - a >= l - hp) {
1042                                 qsort_main(hp + qswidth, l);
1043                                 l = lp;
1044                         } else {
1045                                 qsort_main(a, lp);
1046                                 a = hp + qswidth;
1047                         }
1048                         goto start;
1049                 }
1050
1051                 q3exchange(j, lp -= qswidth, i);
1052                 j = hp -= qswidth;
1053         }
1054 }
1055
1056 void psxBios_qsort() { // 0x31
1057         qswidth = a2;
1058         qscmpfunc = a3;
1059         qsort_main((char *)Ra0, (char *)Ra0 + a1 * a2);
1060
1061         pc0 = ra;
1062 }
1063
1064 void psxBios_malloc() { // 0x33
1065         unsigned int *chunk, *newchunk = NULL;
1066         unsigned int dsize = 0, csize, cstat;
1067         int colflag;
1068 #ifdef PSXBIOS_LOG
1069         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x33]);
1070 #endif
1071         if (!a0 || (!heap_size || !heap_addr)) {
1072                 v0 = 0;
1073                 pc0 = ra;
1074                 return;
1075         }
1076
1077         // scan through heap and combine free chunks of space
1078         chunk = heap_addr;
1079         colflag = 0;
1080         while(chunk < heap_end) {
1081                 // get size and status of actual chunk
1082                 csize = ((u32)*chunk) & 0xfffffffc;
1083                 cstat = ((u32)*chunk) & 1;
1084
1085                 // most probably broken heap descriptor
1086                 // this fixes Burning Road
1087                 if (*chunk == 0) {
1088                         newchunk = chunk;
1089                         dsize = ((uptr)heap_end - (uptr)chunk) - 4;
1090                         colflag = 1;
1091                         break;
1092                 }
1093
1094                 // it's a free chunk
1095                 if(cstat == 1) {
1096                         if(colflag == 0) {
1097                                 newchunk = chunk;
1098                                 dsize = csize;
1099                                 colflag = 1;                    // let's begin a new collection of free memory
1100                         }
1101                         else dsize += (csize+4);        // add the new size including header
1102                 }
1103                 // not a free chunk: did we start a collection ?
1104                 else {
1105                         if(colflag == 1) {                      // collection is over
1106                                 colflag = 0;
1107                                 *newchunk = SWAP32(dsize | 1);
1108                         }
1109                 }
1110
1111                 // next chunk
1112                 chunk = (u32*)((uptr)chunk + csize + 4);
1113         }
1114         // if neccessary free memory on end of heap
1115         if (colflag == 1)
1116                 *newchunk = SWAP32(dsize | 1);
1117
1118         chunk = heap_addr;
1119         csize = ((u32)*chunk) & 0xfffffffc;
1120         cstat = ((u32)*chunk) & 1;
1121         dsize = (a0 + 3) & 0xfffffffc;
1122
1123         // exit on uninitialized heap
1124         if (chunk == NULL) {
1125                 printf("malloc %x,%x: Uninitialized Heap!\n", v0, a0);
1126                 v0 = 0;
1127                 pc0 = ra;
1128                 return;
1129         }
1130
1131         // search an unused chunk that is big enough until the end of the heap
1132         while ((dsize > csize || cstat==0) && chunk < heap_end ) {
1133                 chunk = (u32*)((uptr)chunk + csize + 4);
1134
1135                         // catch out of memory
1136                         if(chunk >= heap_end) {
1137                                 printf("malloc %x,%x: Out of memory error!\n",
1138                                         v0, a0);
1139                                 v0 = 0; pc0 = ra;
1140                                 return;
1141                         }
1142
1143                 csize = ((u32)*chunk) & 0xfffffffc;
1144                 cstat = ((u32)*chunk) & 1;
1145         }
1146
1147         // allocate memory
1148         if(dsize == csize) {
1149                 // chunk has same size
1150                 *chunk &= 0xfffffffc;
1151         } else if (dsize > csize) {
1152                 v0 = 0; pc0 = ra;
1153                 return;
1154         } else {
1155                 // split free chunk
1156                 *chunk = SWAP32(dsize);
1157                 newchunk = (u32*)((uptr)chunk + dsize + 4);
1158                 *newchunk = SWAP32(((csize - dsize - 4) & 0xfffffffc) | 1);
1159         }
1160
1161         // return pointer to allocated memory
1162         v0 = ((uptr)chunk - (uptr)psxM) + 4;
1163         v0|= 0x80000000;
1164         //printf ("malloc %x,%x\n", v0, a0);
1165         pc0 = ra;
1166 }
1167
1168 void psxBios_free() { // 0x34
1169
1170 #ifdef PSXBIOS_LOG
1171         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x34]);
1172 #endif
1173
1174         SysPrintf("free %x: %x bytes\n", a0, *(u32*)(Ra0-4));
1175
1176         if (a0)
1177                 *(u32*)(Ra0-4) |= 1;    // set chunk to free
1178         pc0 = ra;
1179 }
1180
1181 void psxBios_calloc() { // 0x37
1182         void *pv0;
1183 #ifdef PSXBIOS_LOG
1184         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x37]);
1185 #endif
1186
1187         a0 = a0 * a1;
1188         psxBios_malloc();
1189         pv0 = Rv0;
1190         if (pv0)
1191                 memset(pv0, 0, a0);
1192 }
1193
1194 void psxBios_realloc() { // 0x38
1195         u32 block = a0;
1196         u32 size = a1;
1197 #ifdef PSXBIOS_LOG
1198         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x38]);
1199 #endif
1200
1201         a0 = block;
1202         /* If "old_buf" is zero, executes malloc(new_size), and returns r2=new_buf (or 0=failed). */
1203         if (block == 0)
1204         {
1205                 psxBios_malloc();
1206         }
1207         /* Else, if "new_size" is zero, executes free(old_buf), and returns r2=garbage. */
1208         else if (size == 0)
1209         {
1210                 psxBios_free();
1211         }
1212         /* Else, executes malloc(new_size), bcopy(old_buf,new_buf,new_size), and free(old_buf), and returns r2=new_buf (or 0=failed). */
1213         /* Note that it is not quite implemented this way here. */
1214         else
1215         {
1216                 psxBios_free();
1217                 a0 = size;
1218                 psxBios_malloc();
1219         }
1220 }
1221
1222
1223 /* InitHeap(void *block , int n) */
1224 void psxBios_InitHeap() { // 0x39
1225         unsigned int size;
1226
1227 #ifdef PSXBIOS_LOG
1228         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x39]);
1229 #endif
1230
1231         if (((a0 & 0x1fffff) + a1)>= 0x200000) size = 0x1ffffc - (a0 & 0x1fffff);
1232         else size = a1;
1233
1234         size &= 0xfffffffc;
1235
1236         heap_addr = (u32 *)Ra0;
1237         heap_size = size;
1238         heap_end = (u32 *)((u8 *)heap_addr + heap_size);
1239         /* HACKFIX: Commenting out this line fixes GTA2 crash */
1240         //*heap_addr = SWAP32(size | 1);
1241
1242         SysPrintf("InitHeap %x,%x : %x %x\n",a0,a1, (int)((uptr)heap_addr-(uptr)psxM), size);
1243
1244         pc0 = ra;
1245 }
1246
1247 void psxBios_getchar() { //0x3b
1248         v0 = getchar(); pc0 = ra;
1249 }
1250
1251 void psxBios_printf() { // 0x3f
1252         char tmp[1024];
1253         char tmp2[1024];
1254         u32 save[4];
1255         char *ptmp = tmp;
1256         int n=1, i=0, j;
1257         void *psp;
1258
1259         psp = PSXM(sp);
1260         if (psp) {
1261                 memcpy(save, psp, 4 * 4);
1262                 psxMu32ref(sp) = SWAP32((u32)a0);
1263                 psxMu32ref(sp + 4) = SWAP32((u32)a1);
1264                 psxMu32ref(sp + 8) = SWAP32((u32)a2);
1265                 psxMu32ref(sp + 12) = SWAP32((u32)a3);
1266         }
1267
1268         while (Ra0[i]) {
1269                 switch (Ra0[i]) {
1270                         case '%':
1271                                 j = 0;
1272                                 tmp2[j++] = '%';
1273 _start:
1274                                 switch (Ra0[++i]) {
1275                                         case '.':
1276                                         case 'l':
1277                                                 tmp2[j++] = Ra0[i]; goto _start;
1278                                         default:
1279                                                 if (Ra0[i] >= '0' && Ra0[i] <= '9') {
1280                                                         tmp2[j++] = Ra0[i];
1281                                                         goto _start;
1282                                                 }
1283                                                 break;
1284                                 }
1285                                 tmp2[j++] = Ra0[i];
1286                                 tmp2[j] = 0;
1287
1288                                 switch (Ra0[i]) {
1289                                         case 'f': case 'F':
1290                                                 ptmp += sprintf(ptmp, tmp2, (float)psxMu32(sp + n * 4)); n++; break;
1291                                         case 'a': case 'A':
1292                                         case 'e': case 'E':
1293                                         case 'g': case 'G':
1294                                                 ptmp += sprintf(ptmp, tmp2, (double)psxMu32(sp + n * 4)); n++; break;
1295                                         case 'p':
1296                                         case 'i': case 'u':
1297                                         case 'd': case 'D':
1298                                         case 'o': case 'O':
1299                                         case 'x': case 'X':
1300                                                 ptmp += sprintf(ptmp, tmp2, (unsigned int)psxMu32(sp + n * 4)); n++; break;
1301                                         case 'c':
1302                                                 ptmp += sprintf(ptmp, tmp2, (unsigned char)psxMu32(sp + n * 4)); n++; break;
1303                                         case 's':
1304                                                 ptmp += sprintf(ptmp, tmp2, (char*)PSXM(psxMu32(sp + n * 4))); n++; break;
1305                                         case '%':
1306                                                 *ptmp++ = Ra0[i]; break;
1307                                 }
1308                                 i++;
1309                                 break;
1310                         default:
1311                                 *ptmp++ = Ra0[i++];
1312                 }
1313         }
1314         *ptmp = 0;
1315
1316         if (psp)
1317                 memcpy(psp, save, 4 * 4);
1318
1319         SysPrintf("%s", tmp);
1320
1321         pc0 = ra;
1322 }
1323
1324 void psxBios_format() { // 0x41
1325         if (strcmp(Ra0, "bu00:") == 0 && Config.Mcd1[0] != '\0')
1326         {
1327                 CreateMcd(Config.Mcd1);
1328                 LoadMcd(1, Config.Mcd1);
1329                 v0 = 1;
1330         }
1331         else if (strcmp(Ra0, "bu10:") == 0 && Config.Mcd2[0] != '\0')
1332         {
1333                 CreateMcd(Config.Mcd2);
1334                 LoadMcd(2, Config.Mcd2);
1335                 v0 = 1;
1336         }
1337         else
1338         {
1339                 v0 = 0;
1340         }
1341         pc0 = ra;
1342 }
1343
1344 /*
1345  *      long Load(char *name, struct EXEC *header);
1346  */
1347
1348 void psxBios_Load() { // 0x42
1349         EXE_HEADER eheader;
1350         void *pa1;
1351
1352 #ifdef PSXBIOS_LOG
1353         PSXBIOS_LOG("psxBios_%s: %s, %x\n", biosA0n[0x42], Ra0, a1);
1354 #endif
1355
1356         pa1 = Ra1;
1357         if (pa1 && LoadCdromFile(Ra0, &eheader) == 0) {
1358                 memcpy(pa1, ((char*)&eheader)+16, sizeof(EXEC));
1359                 v0 = 1;
1360         } else v0 = 0;
1361
1362         pc0 = ra;
1363 }
1364
1365 /*
1366  *      int Exec(struct EXEC *header , int argc , char **argv);
1367  */
1368
1369 void psxBios_Exec() { // 43
1370         EXEC *header = (EXEC*)Ra0;
1371         u32 tmp;
1372
1373 #ifdef PSXBIOS_LOG
1374         PSXBIOS_LOG("psxBios_%s: %x, %x, %x\n", biosA0n[0x43], a0, a1, a2);
1375 #endif
1376
1377         header->_sp = sp;
1378         header->_fp = fp;
1379         header->_sp = sp;
1380         header->_gp = gp;
1381         header->ret = ra;
1382         header->base = s0;
1383
1384         if (header->S_addr != 0) {
1385                 tmp = header->S_addr + header->s_size;
1386                 sp = tmp;
1387                 fp = sp;
1388         }
1389
1390         gp = header->gp0;
1391
1392         s0 = a0;
1393
1394         a0 = a1;
1395         a1 = a2;
1396
1397         ra = 0x8000;
1398         pc0 = header->_pc0;
1399 }
1400
1401 void psxBios_FlushCache() { // 44
1402 #ifdef PSXBIOS_LOG
1403         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x44]);
1404 #endif
1405
1406         pc0 = ra;
1407 }
1408
1409 void psxBios_GPU_dw() { // 0x46
1410         int size;
1411         u32 *ptr;
1412
1413 #ifdef PSXBIOS_LOG
1414         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x46]);
1415 #endif
1416
1417         GPU_writeData(0xa0000000);
1418         GPU_writeData((a1<<0x10)|(a0&0xffff));
1419         GPU_writeData((a3<<0x10)|(a2&0xffff));
1420         size = (a2*a3)/2;
1421         ptr = (u32*)PSXM(Rsp[4]);  //that is correct?
1422         while(size--)
1423         {
1424                 GPU_writeData(SWAPu32(*ptr++));
1425         }
1426
1427         pc0 = ra;
1428 }
1429
1430 void psxBios_mem2vram() { // 0x47
1431         int size;
1432         gpuSyncPluginSR();
1433         GPU_writeData(0xa0000000);
1434         GPU_writeData((a1<<0x10)|(a0&0xffff));
1435         GPU_writeData((a3<<0x10)|(a2&0xffff));
1436         size = ((((a2 * a3) / 2) >> 4) << 16);
1437         GPU_writeStatus(0x04000002);
1438         psxHwWrite32(0x1f8010f4,0);
1439         psxHwWrite32(0x1f8010f0,psxHwRead32(0x1f8010f0)|0x800);
1440         psxHwWrite32(0x1f8010a0,Rsp[4]);//might have a buggy...
1441         psxHwWrite32(0x1f8010a4, size | 0x10);
1442         psxHwWrite32(0x1f8010a8,0x01000201);
1443
1444         pc0 = ra;
1445 }
1446
1447 void psxBios_SendGPU() { // 0x48
1448         GPU_writeStatus(a0);
1449         gpuSyncPluginSR();
1450         pc0 = ra;
1451 }
1452
1453 void psxBios_GPU_cw() { // 0x49
1454         gpuSyncPluginSR();
1455         GPU_writeData(a0);
1456         v0 = HW_GPU_STATUS;
1457         pc0 = ra;
1458 }
1459
1460 void psxBios_GPU_cwb() { // 0x4a
1461         u32 *ptr = (u32*)Ra0;
1462         int size = a1;
1463         gpuSyncPluginSR();
1464         while(size--)
1465         {
1466                 GPU_writeData(SWAPu32(*ptr++));
1467         }
1468
1469         pc0 = ra;
1470 }
1471
1472 void psxBios_GPU_SendPackets() { //4b:
1473         gpuSyncPluginSR();
1474         GPU_writeStatus(0x04000002);
1475         psxHwWrite32(0x1f8010f4,0);
1476         psxHwWrite32(0x1f8010f0,psxHwRead32(0x1f8010f0)|0x800);
1477         psxHwWrite32(0x1f8010a0,a0);
1478         psxHwWrite32(0x1f8010a4,0);
1479         psxHwWrite32(0x1f8010a8,0x010000401);
1480         pc0 = ra;
1481 }
1482
1483 void psxBios_sys_a0_4c() { // 0x4c GPU relate
1484         psxHwWrite32(0x1f8010a8,0x00000401);
1485         GPU_writeData(0x0400000);
1486         GPU_writeData(0x0200000);
1487         GPU_writeData(0x0100000);
1488         v0 = 0x1f801814;
1489         pc0 = ra;
1490 }
1491
1492 void psxBios_GPU_GetGPUStatus() { // 0x4d
1493         v0 = GPU_readStatus();
1494         pc0 = ra;
1495 }
1496
1497 #undef s_addr
1498
1499 void psxBios_LoadExec() { // 51
1500         EXEC *header = (EXEC*)PSXM(0xf000);
1501         u32 s_addr, s_size;
1502
1503 #ifdef PSXBIOS_LOG
1504         PSXBIOS_LOG("psxBios_%s: %s: %x,%x\n", biosA0n[0x51], Ra0, a1, a2);
1505 #endif
1506         s_addr = a1; s_size = a2;
1507
1508         a1 = 0xf000;
1509         psxBios_Load();
1510
1511         header->S_addr = s_addr;
1512         header->s_size = s_size;
1513
1514         a0 = 0xf000; a1 = 0; a2 = 0;
1515         psxBios_Exec();
1516 }
1517
1518 void psxBios__bu_init() { // 70
1519 #ifdef PSXBIOS_LOG
1520         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x70]);
1521 #endif
1522
1523         DeliverEvent(0x11, 0x2); // 0xf0000011, 0x0004
1524         DeliverEvent(0x81, 0x2); // 0xf4000001, 0x0004
1525
1526         pc0 = ra;
1527 }
1528
1529 void psxBios__96_init() { // 71
1530 #ifdef PSXBIOS_LOG
1531         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x71]);
1532 #endif
1533
1534         pc0 = ra;
1535 }
1536
1537 void psxBios__96_remove() { // 72
1538 #ifdef PSXBIOS_LOG
1539         PSXBIOS_LOG("psxBios_%s\n", biosA0n[0x72]);
1540 #endif
1541
1542         pc0 = ra;
1543 }
1544
1545 void psxBios_SetMem() { // 9f
1546         u32 new = psxHu32(0x1060);
1547
1548 #ifdef PSXBIOS_LOG
1549         PSXBIOS_LOG("psxBios_%s: %x, %x\n", biosA0n[0x9f], a0, a1);
1550 #endif
1551
1552         switch(a0) {
1553                 case 2:
1554                         psxHu32ref(0x1060) = SWAP32(new);
1555                         psxMu32ref(0x060) = a0;
1556                         SysPrintf("Change effective memory : %d MBytes\n",a0);
1557                         break;
1558
1559                 case 8:
1560                         psxHu32ref(0x1060) = SWAP32(new | 0x300);
1561                         psxMu32ref(0x060) = a0;
1562                         SysPrintf("Change effective memory : %d MBytes\n",a0);
1563
1564                 default:
1565                         SysPrintf("Effective memory must be 2/8 MBytes\n");
1566                 break;
1567         }
1568
1569         pc0 = ra;
1570 }
1571
1572 /* TODO FIXME : Not compliant. -1 indicates failure but using 1 for now. */
1573 void psxBios_get_cd_status(void) //a6
1574 {
1575         v0 = 1;
1576         pc0 = ra;
1577 }
1578
1579 void psxBios__card_info() { // ab
1580 #ifdef PSXBIOS_LOG
1581         PSXBIOS_LOG("psxBios_%s: %x\n", biosA0n[0xab], a0);
1582 #endif
1583         u32 ret, port;
1584         card_active_chan = a0;
1585         port = card_active_chan >> 4;
1586
1587         switch (port) {
1588         case 0x0:
1589         case 0x1:
1590                 ret = 0x2;
1591                 if (McdDisable[port & 1])
1592                         ret = 0x8;
1593                 break;
1594         default:
1595 #ifdef PSXBIOS_LOG
1596                 PSXBIOS_LOG("psxBios_%s: UNKNOWN PORT 0x%x\n", biosA0n[0xab], card_active_chan);
1597 #endif
1598                 ret = 0x11;
1599                 break;
1600         }
1601
1602         if (McdDisable[0] && McdDisable[1])
1603                 ret = 0x8;
1604
1605         DeliverEvent(0x11, 0x2); // 0xf0000011, 0x0004
1606 //      DeliverEvent(0x81, 0x2); // 0xf4000001, 0x0004
1607         DeliverEvent(0x81, ret); // 0xf4000001, 0x0004
1608         v0 = 1; pc0 = ra;
1609 }
1610
1611 void psxBios__card_load() { // ac
1612 #ifdef PSXBIOS_LOG
1613         PSXBIOS_LOG("psxBios_%s: %x\n", biosA0n[0xac], a0);
1614 #endif
1615
1616         card_active_chan = a0;
1617
1618 //      DeliverEvent(0x11, 0x2); // 0xf0000011, 0x0004
1619         DeliverEvent(0x81, 0x2); // 0xf4000001, 0x0004
1620
1621         v0 = 1; pc0 = ra;
1622 }
1623
1624 /* System calls B0 */
1625
1626 void psxBios_SetRCnt() { // 02
1627 #ifdef PSXBIOS_LOG
1628         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x02]);
1629 #endif
1630
1631         a0&= 0x3;
1632         if (a0 != 3) {
1633                 u32 mode=0;
1634
1635                 psxRcntWtarget(a0, a1);
1636                 if (a2&0x1000) mode|= 0x050; // Interrupt Mode
1637                 if (a2&0x0100) mode|= 0x008; // Count to 0xffff
1638                 if (a2&0x0010) mode|= 0x001; // Timer stop mode
1639                 if (a0 == 2) { if (a2&0x0001) mode|= 0x200; } // System Clock mode
1640                 else         { if (a2&0x0001) mode|= 0x100; } // System Clock mode
1641
1642                 psxRcntWmode(a0, mode);
1643         }
1644         pc0 = ra;
1645 }
1646
1647 void psxBios_GetRCnt() { // 03
1648 #ifdef PSXBIOS_LOG
1649         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x03]);
1650 #endif
1651
1652         a0&= 0x3;
1653         if (a0 != 3) v0 = psxRcntRcount(a0);
1654         else v0 = 0;
1655         pc0 = ra;
1656 }
1657
1658 void psxBios_StartRCnt() { // 04
1659 #ifdef PSXBIOS_LOG
1660         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x04]);
1661 #endif
1662
1663         a0&= 0x3;
1664         if (a0 != 3) psxHu32ref(0x1074)|= SWAP32((u32)((1<<(a0+4))));
1665         else psxHu32ref(0x1074)|= SWAPu32(0x1);
1666         v0 = 1; pc0 = ra;
1667 }
1668
1669 void psxBios_StopRCnt() { // 05
1670 #ifdef PSXBIOS_LOG
1671         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x05]);
1672 #endif
1673
1674         a0&= 0x3;
1675         if (a0 != 3) psxHu32ref(0x1074)&= SWAP32((u32)(~(1<<(a0+4))));
1676         else psxHu32ref(0x1074)&= SWAPu32(~0x1);
1677         pc0 = ra;
1678 }
1679
1680 void psxBios_ResetRCnt() { // 06
1681 #ifdef PSXBIOS_LOG
1682         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x06]);
1683 #endif
1684
1685         a0&= 0x3;
1686         if (a0 != 3) {
1687                 psxRcntWmode(a0, 0);
1688                 psxRcntWtarget(a0, 0);
1689                 psxRcntWcount(a0, 0);
1690         }
1691         pc0 = ra;
1692 }
1693
1694
1695 /* gets ev for use with EventCB */
1696 #define GetEv() \
1697         ev = (a0 >> 24) & 0xf; \
1698         if (ev == 0xf) ev = 0x5; \
1699         ev*= 32; \
1700         ev+= a0&0x1f;
1701
1702 /* gets spec for use with EventCB */
1703 #define GetSpec() \
1704         spec = 0; \
1705         switch (a1) { \
1706                 case 0x0301: spec = 16; break; \
1707                 case 0x0302: spec = 17; break; \
1708                 default: \
1709                         for (i=0; i<16; i++) if (a1 & (1 << i)) { spec = i; break; } \
1710                         break; \
1711         }
1712
1713 void psxBios_DeliverEvent() { // 07
1714         int ev, spec;
1715         int i;
1716
1717         GetEv();
1718         GetSpec();
1719
1720 #ifdef PSXBIOS_LOG
1721         PSXBIOS_LOG("psxBios_%s %x,%x\n", biosB0n[0x07], ev, spec);
1722 #endif
1723
1724         DeliverEvent(ev, spec);
1725
1726         pc0 = ra;
1727 }
1728
1729 void psxBios_OpenEvent() { // 08
1730         int ev, spec;
1731         int i;
1732
1733         GetEv();
1734         GetSpec();
1735
1736 #ifdef PSXBIOS_LOG
1737         PSXBIOS_LOG("psxBios_%s %x,%x (class:%x, spec:%x, mode:%x, func:%x)\n", biosB0n[0x08], ev, spec, a0, a1, a2, a3);
1738 #endif
1739
1740         EventCB[ev][spec].status = EvStWAIT;
1741         EventCB[ev][spec].mode = a2;
1742         EventCB[ev][spec].fhandler = a3;
1743
1744         v0 = ev | (spec << 8);
1745         pc0 = ra;
1746 }
1747
1748 void psxBios_CloseEvent() { // 09
1749         int ev, spec;
1750
1751         ev   = a0 & 0xff;
1752         spec = (a0 >> 8) & 0xff;
1753
1754 #ifdef PSXBIOS_LOG
1755         PSXBIOS_LOG("psxBios_%s %x,%x\n", biosB0n[0x09], ev, spec);
1756 #endif
1757
1758         EventCB[ev][spec].status = EvStUNUSED;
1759
1760         v0 = 1; pc0 = ra;
1761 }
1762
1763 void psxBios_WaitEvent() { // 0a
1764         int ev, spec;
1765
1766         ev   = a0 & 0xff;
1767         spec = (a0 >> 8) & 0xff;
1768 #ifdef PSXBIOS_LOG
1769         PSXBIOS_LOG("psxBios_%s %x,%x\n", biosB0n[0x0a], ev, spec);
1770 #endif
1771         if (EventCB[ev][spec].status == EvStUNUSED)
1772         {
1773                 v0 = 0;
1774                 pc0 = ra;
1775                 return;
1776         }
1777
1778         if (EventCB[ev][spec].status == EvStALREADY)
1779         {
1780                 /* Callback events (mode=EvMdINTR) do never set the ready flag (and thus WaitEvent would hang forever). */
1781                 if (!(EventCB[ev][spec].mode == EvMdINTR)) EventCB[ev][spec].status = EvStACTIVE;
1782                 v0 = 1;
1783                 pc0 = ra;
1784                 return;
1785         }
1786
1787         v0 = 0;
1788         pc0 = ra;
1789 }
1790
1791 void psxBios_TestEvent() { // 0b
1792         int ev, spec;
1793
1794         ev   = a0 & 0xff;
1795         spec = (a0 >> 8) & 0xff;
1796
1797         if (EventCB[ev][spec].status == EvStALREADY)
1798         {
1799                 if (!(EventCB[ev][spec].mode == EvMdINTR)) EventCB[ev][spec].status = EvStACTIVE;
1800                 v0 = 1;
1801         }
1802         else
1803         {
1804                 v0 = 0;
1805         }
1806
1807 #ifdef PSXBIOS_LOG
1808         PSXBIOS_LOG("psxBios_%s %x,%x: %x\n", biosB0n[0x0b], ev, spec, v0);
1809 #endif
1810
1811         pc0 = ra;
1812 }
1813
1814 void psxBios_EnableEvent() { // 0c
1815         int ev, spec;
1816
1817         ev   = a0 & 0xff;
1818         spec = (a0 >> 8) & 0xff;
1819
1820 #ifdef PSXBIOS_LOG
1821         PSXBIOS_LOG("psxBios_%s %x,%x\n", biosB0n[0x0c], ev, spec);
1822 #endif
1823
1824         EventCB[ev][spec].status = EvStACTIVE;
1825
1826         v0 = 1; pc0 = ra;
1827 }
1828
1829 void psxBios_DisableEvent() { // 0d
1830         int ev, spec;
1831
1832         ev   = a0 & 0xff;
1833         spec = (a0 >> 8) & 0xff;
1834
1835 #ifdef PSXBIOS_LOG
1836         PSXBIOS_LOG("psxBios_%s %x,%x\n", biosB0n[0x0d], ev, spec);
1837 #endif
1838
1839         EventCB[ev][spec].status = EvStWAIT;
1840
1841         v0 = 1; pc0 = ra;
1842 }
1843
1844 /*
1845  *      long OpenTh(long (*func)(), unsigned long sp, unsigned long gp);
1846  */
1847
1848 void psxBios_OpenTh() { // 0e
1849         int th;
1850
1851         for (th=1; th<8; th++)
1852         {
1853                 if (ThreadCB[th].status == 0) break;
1854
1855         }
1856         if (th == 8) {
1857                 // Feb 2019 - Added out-of-bounds fix caught by cppcheck:
1858                 // When no free TCB is found, return 0xffffffff according to Nocash doc.
1859 #ifdef PSXBIOS_LOG
1860                 PSXBIOS_LOG("\t%s() WARNING! No Free TCBs found!\n", __func__);
1861 #endif
1862                 v0 = 0xffffffff;
1863                 pc0 = ra;
1864                 return;
1865         }
1866 #ifdef PSXBIOS_LOG
1867         PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x0e], th);
1868 #endif
1869
1870         ThreadCB[th].status = 1;
1871         ThreadCB[th].func    = a0;
1872         ThreadCB[th].reg[29] = a1;
1873         ThreadCB[th].reg[28] = a2;
1874
1875         v0 = th; pc0 = ra;
1876 }
1877
1878 /*
1879  *      int CloseTh(long thread);
1880  */
1881
1882 void psxBios_CloseTh() { // 0f
1883         int th = a0 & 0xff;
1884
1885 #ifdef PSXBIOS_LOG
1886         PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x0f], th);
1887 #endif
1888         /* The return value is always 1 (even if the handle was already closed). */
1889         v0 = 1;
1890         if (ThreadCB[th].status != 0) {
1891                 ThreadCB[th].status = 0;
1892         }
1893
1894         pc0 = ra;
1895 }
1896
1897 /*
1898  *      int ChangeTh(long thread);
1899  */
1900
1901 void psxBios_ChangeTh() { // 10
1902         int th = a0 & 0xff;
1903
1904 #ifdef PSXBIOS_LOG
1905 //      PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x10], th);
1906 #endif
1907         /* The return value is always 1. */
1908         v0 = 1;
1909         if (ThreadCB[th].status == 0 || CurThread == th) {
1910                 pc0 = ra;
1911         } else {
1912                 if (ThreadCB[CurThread].status == 2) {
1913                         ThreadCB[CurThread].status = 1;
1914                         ThreadCB[CurThread].func = ra;
1915                         memcpy(ThreadCB[CurThread].reg, psxRegs.GPR.r, 32*4);
1916                 }
1917
1918                 memcpy(psxRegs.GPR.r, ThreadCB[th].reg, 32*4);
1919                 pc0 = ThreadCB[th].func;
1920                 ThreadCB[th].status = 2;
1921                 CurThread = th;
1922         }
1923 }
1924
1925 void psxBios_InitPAD() { // 0x12
1926 #ifdef PSXBIOS_LOG
1927         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x12]);
1928 #endif
1929
1930         pad_buf1 = (char*)Ra0;
1931         pad_buf1len = a1;
1932         pad_buf2 = (char*)Ra2;
1933         pad_buf2len = a3;
1934
1935         v0 = 1; pc0 = ra;
1936 }
1937
1938 void psxBios_StartPAD() { // 13
1939 #ifdef PSXBIOS_LOG
1940         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x13]);
1941 #endif
1942         pad_stopped = 0;
1943         psxHwWrite16(0x1f801074, (unsigned short)(psxHwRead16(0x1f801074) | 0x1));
1944         psxRegs.CP0.n.Status |= 0x401;
1945         pc0 = ra;
1946 }
1947
1948 void psxBios_StopPAD() { // 14
1949 #ifdef PSXBIOS_LOG
1950         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x14]);
1951 #endif
1952         pad_stopped = 1;
1953         pad_buf1 = NULL;
1954         pad_buf2 = NULL;
1955         pc0 = ra;
1956 }
1957
1958 void psxBios_PAD_init() { // 15
1959 #ifdef PSXBIOS_LOG
1960         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x15]);
1961 #endif
1962         if (!(a0 == 0x20000000 || a0 == 0x20000001))
1963         {
1964                 v0 = 0;
1965                 pc0 = ra;
1966                 return;
1967         }
1968         psxHwWrite16(0x1f801074, (u16)(psxHwRead16(0x1f801074) | 0x1));
1969         pad_buf = (int *)Ra1;
1970         *pad_buf = -1;
1971         psxRegs.CP0.n.Status |= 0x401;
1972         v0 = 2;
1973         pc0 = ra;
1974 }
1975
1976 void psxBios_PAD_dr() { // 16
1977 #ifdef PSXBIOS_LOG
1978         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x16]);
1979 #endif
1980
1981         v0 = -1; pc0 = ra;
1982 }
1983
1984 void psxBios_ReturnFromException() { // 17
1985         LoadRegs();
1986
1987         pc0 = psxRegs.CP0.n.EPC;
1988         k0 = interrupt_r26;
1989         if (psxRegs.CP0.n.Cause & 0x80000000) pc0 += 4;
1990
1991         psxRegs.CP0.n.Status = (psxRegs.CP0.n.Status & 0xfffffff0) |
1992                                                   ((psxRegs.CP0.n.Status & 0x3c) >> 2);
1993 }
1994
1995 void psxBios_ResetEntryInt() { // 18
1996 #ifdef PSXBIOS_LOG
1997         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x18]);
1998 #endif
1999
2000         jmp_int = NULL;
2001         pc0 = ra;
2002 }
2003
2004 void psxBios_HookEntryInt() { // 19
2005 #ifdef PSXBIOS_LOG
2006         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x19]);
2007 #endif
2008
2009         jmp_int = (u32*)Ra0;
2010         pc0 = ra;
2011 }
2012
2013 void psxBios_UnDeliverEvent() { // 0x20
2014         int ev, spec;
2015         int i;
2016
2017         GetEv();
2018         GetSpec();
2019
2020 #ifdef PSXBIOS_LOG
2021         PSXBIOS_LOG("psxBios_%s %x,%x\n", biosB0n[0x20], ev, spec);
2022 #endif
2023
2024         if (EventCB[ev][spec].status == EvStALREADY &&
2025                 EventCB[ev][spec].mode == EvMdNOINTR)
2026                 EventCB[ev][spec].status = EvStACTIVE;
2027
2028         pc0 = ra;
2029 }
2030
2031 char ffile[64], *pfile;
2032 int nfile;
2033
2034 static void buopen(int mcd, char *ptr, char *cfg)
2035 {
2036         int i;
2037         char *mcd_data = ptr;
2038
2039         strcpy(FDesc[1 + mcd].name, Ra0+5);
2040         FDesc[1 + mcd].offset = 0;
2041         FDesc[1 + mcd].mode   = a1;
2042
2043         for (i=1; i<16; i++) {
2044                 const char *fptr = mcd_data + 128 * i;
2045                 if ((*fptr & 0xF0) != 0x50) continue;
2046                 if (strcmp(FDesc[1 + mcd].name, fptr+0xa)) continue;
2047                 FDesc[1 + mcd].mcfile = i;
2048                 SysPrintf("open %s\n", fptr+0xa);
2049                 v0 = 1 + mcd;
2050                 break;
2051         }
2052         if (a1 & 0x200 && v0 == -1) { /* FCREAT */
2053                 for (i=1; i<16; i++) {
2054                         int j, xor, nblk = a1 >> 16;
2055                         char *pptr, *fptr2;
2056                         char *fptr = mcd_data + 128 * i;
2057
2058                         if ((*fptr & 0xF0) != 0xa0) continue;
2059
2060                         FDesc[1 + mcd].mcfile = i;
2061                         fptr[0] = 0x51;
2062                         fptr[4] = 0x00;
2063                         fptr[5] = 0x20 * nblk;
2064                         fptr[6] = 0x00;
2065                         fptr[7] = 0x00;
2066                         strcpy(fptr+0xa, FDesc[1 + mcd].name);
2067                         pptr = fptr2 = fptr;
2068                         for(j=2; j<=nblk; j++) {
2069                                 int k;
2070                                 for(i++; i<16; i++) {
2071                                         fptr2 += 128;
2072
2073                                         memset(fptr2, 0, 128);
2074                                         fptr2[0] = j < nblk ? 0x52 : 0x53;
2075                                         pptr[8] = i - 1;
2076                                         pptr[9] = 0;
2077                                         for (k=0, xor=0; k<127; k++) xor^= pptr[k];
2078                                         pptr[127] = xor;
2079                                         pptr = fptr2;
2080                                         break;
2081                                 }
2082                                 /* shouldn't this return ENOSPC if i == 16? */
2083                         }
2084                         pptr[8] = pptr[9] = 0xff;
2085                         for (j=0, xor=0; j<127; j++) xor^= pptr[j];
2086                         pptr[127] = xor;
2087                         SysPrintf("openC %s %d\n", ptr, nblk);
2088                         v0 = 1 + mcd;
2089                         /* just go ahead and resave them all */
2090                         SaveMcd(cfg, ptr, 128, 128 * 15);
2091                         break;
2092                 }
2093                 /* shouldn't this return ENOSPC if i == 16? */
2094         }
2095 }
2096
2097 /*
2098  *      int open(char *name , int mode);
2099  */
2100
2101 void psxBios_open() { // 0x32
2102         void *pa0 = Ra0;
2103
2104 #ifdef PSXBIOS_LOG
2105         PSXBIOS_LOG("psxBios_%s: %s,%x\n", biosB0n[0x32], Ra0, a1);
2106 #endif
2107
2108         v0 = -1;
2109
2110         if (pa0) {
2111                 if (!strncmp(pa0, "bu00", 4)) {
2112                         buopen(1, Mcd1Data, Config.Mcd1);
2113                 }
2114
2115                 if (!strncmp(pa0, "bu10", 4)) {
2116                         buopen(2, Mcd2Data, Config.Mcd2);
2117                 }
2118         }
2119
2120         pc0 = ra;
2121 }
2122
2123 /*
2124  *      int lseek(int fd , int offset , int whence);
2125  */
2126
2127 void psxBios_lseek() { // 0x33
2128 #ifdef PSXBIOS_LOG
2129         PSXBIOS_LOG("psxBios_%s: %x, %x, %x\n", biosB0n[0x33], a0, a1, a2);
2130 #endif
2131
2132         switch (a2) {
2133                 case 0: // SEEK_SET
2134                         FDesc[a0].offset = a1;
2135                         v0 = a1;
2136 //                      DeliverEvent(0x11, 0x2); // 0xf0000011, 0x0004
2137 //                      DeliverEvent(0x81, 0x2); // 0xf4000001, 0x0004
2138                         break;
2139
2140                 case 1: // SEEK_CUR
2141                         FDesc[a0].offset+= a1;
2142                         v0 = FDesc[a0].offset;
2143                         break;
2144         }
2145
2146         pc0 = ra;
2147 }
2148
2149
2150 /*
2151  *      int read(int fd , void *buf , int nbytes);
2152  */
2153
2154 void psxBios_read() { // 0x34
2155         char *ptr;
2156         void *pa1 = Ra1;
2157
2158 #ifdef PSXBIOS_LOG
2159         PSXBIOS_LOG("psxBios_%s: %x, %x, %x\n", biosB0n[0x34], a0, a1, a2);
2160 #endif
2161
2162         v0 = -1;
2163
2164         if (pa1) {
2165                 switch (a0) {
2166                         case 2: buread(pa1, 1, a2); break;
2167                         case 3: buread(pa1, 2, a2); break;
2168                 }
2169         }
2170
2171         pc0 = ra;
2172 }
2173
2174 /*
2175  *      int write(int fd , void *buf , int nbytes);
2176  */
2177
2178 void psxBios_write() { // 0x35/0x03
2179         char *ptr;
2180         void *pa1 = Ra1;
2181
2182 #ifdef PSXBIOS_LOG
2183         PSXBIOS_LOG("psxBios_%s: %x,%x,%x\n", biosB0n[0x35], a0, a1, a2);
2184 #endif
2185
2186         v0 = -1;
2187         if (!pa1) {
2188                 pc0 = ra;
2189                 return;
2190         }
2191
2192         if (a0 == 1) { // stdout
2193                 char *ptr = pa1;
2194
2195                 v0 = a2;
2196                 while (a2 > 0) {
2197                         SysPrintf("%c", *ptr++); a2--;
2198                 }
2199                 pc0 = ra; return;
2200         }
2201
2202         switch (a0) {
2203                 case 2: buwrite(pa1, 1, a2); break;
2204                 case 3: buwrite(pa1, 2, a2); break;
2205         }
2206
2207         pc0 = ra;
2208 }
2209
2210 /*
2211  *      int close(int fd);
2212  */
2213
2214 void psxBios_close() { // 0x36
2215 #ifdef PSXBIOS_LOG
2216         PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x36], a0);
2217 #endif
2218
2219         v0 = a0;
2220         pc0 = ra;
2221 }
2222
2223 void psxBios_putchar() { // 3d
2224         SysPrintf("%c", (char)a0);
2225         pc0 = ra;
2226 }
2227
2228 void psxBios_puts() { // 3e/3f
2229         SysPrintf("%s", Ra0);
2230         pc0 = ra;
2231 }
2232
2233
2234 /* To avoid any issues with different behaviour when using the libc's own strlen instead.
2235  * We want to mimic the PSX's behaviour in this case for bufile. */
2236 static size_t strlen_internal(char* p)
2237 {
2238         size_t size_of_array = 0;
2239         while (*p++) size_of_array++;
2240         return size_of_array;
2241 }
2242
2243 #define bufile(mcd) { \
2244         size_t size_of_name = strlen_internal(dir->name); \
2245         while (nfile < 16) { \
2246                 int match=1; \
2247  \
2248                 ptr = Mcd##mcd##Data + 128 * (nfile + 1); \
2249                 nfile++; \
2250                 if ((*ptr & 0xF0) != 0x50) continue; \
2251                 /* Bug link files show up as free block. */ \
2252                 if (!ptr[0xa]) continue; \
2253                 ptr+= 0xa; \
2254                 if (pfile[0] == 0) { \
2255                         strncpy(dir->name, ptr, sizeof(dir->name) - 1); \
2256                         if (size_of_name < sizeof(dir->name)) dir->name[size_of_name] = '\0'; \
2257                 } else for (i=0; i<20; i++) { \
2258                         if (pfile[i] == ptr[i]) { \
2259                                                                 dir->name[i] = ptr[i]; continue; } \
2260                         if (pfile[i] == '?') { \
2261                                 dir->name[i] = ptr[i]; continue; } \
2262                         if (pfile[i] == '*') { \
2263                                 strcpy(dir->name+i, ptr+i); break; } \
2264                         match = 0; break; \
2265                 } \
2266                 SysPrintf("%d : %s = %s + %s (match=%d)\n", nfile, dir->name, pfile, ptr, match); \
2267                 if (match == 0) { continue; } \
2268                 dir->size = 8192; \
2269                 v0 = _dir; \
2270                 break; \
2271         } \
2272 }
2273
2274 /*
2275  *      struct DIRENTRY* firstfile(char *name,struct DIRENTRY *dir);
2276  */
2277
2278 void psxBios_firstfile() { // 42
2279         struct DIRENTRY *dir = (struct DIRENTRY *)Ra1;
2280         void *pa0 = Ra0;
2281         u32 _dir = a1;
2282         char *ptr;
2283         int i;
2284
2285 #ifdef PSXBIOS_LOG
2286         PSXBIOS_LOG("psxBios_%s: %s\n", biosB0n[0x42], Ra0);
2287 #endif
2288
2289         v0 = 0;
2290
2291         if (pa0) {
2292                 strcpy(ffile, pa0);
2293                 pfile = ffile+5;
2294                 nfile = 0;
2295                 if (!strncmp(pa0, "bu00", 4)) {
2296                         // firstfile() calls _card_read() internally, so deliver it's event
2297                         DeliverEvent(0x11, 0x2);
2298                         bufile(1);
2299                 } else if (!strncmp(pa0, "bu10", 4)) {
2300                         // firstfile() calls _card_read() internally, so deliver it's event
2301                         DeliverEvent(0x11, 0x2);
2302                         bufile(2);
2303                 }
2304         }
2305
2306         pc0 = ra;
2307 }
2308
2309 /*
2310  *      struct DIRENTRY* nextfile(struct DIRENTRY *dir);
2311  */
2312
2313 void psxBios_nextfile() { // 43
2314         struct DIRENTRY *dir = (struct DIRENTRY *)Ra0;
2315         u32 _dir = a0;
2316         char *ptr;
2317         int i;
2318
2319 #ifdef PSXBIOS_LOG
2320         PSXBIOS_LOG("psxBios_%s: %s\n", biosB0n[0x43], dir->name);
2321 #endif
2322
2323         v0 = 0;
2324
2325         if (!strncmp(ffile, "bu00", 4)) {
2326                 bufile(1);
2327         }
2328
2329         if (!strncmp(ffile, "bu10", 4)) {
2330                 bufile(2);
2331         }
2332
2333         pc0 = ra;
2334 }
2335
2336 #define burename(mcd) { \
2337         for (i=1; i<16; i++) { \
2338                 int namelen, j, xor = 0; \
2339                 ptr = Mcd##mcd##Data + 128 * i; \
2340                 if ((*ptr & 0xF0) != 0x50) continue; \
2341                 if (strcmp(Ra0+5, ptr+0xa)) continue; \
2342                 namelen = strlen(Ra1+5); \
2343                 memcpy(ptr+0xa, Ra1+5, namelen); \
2344                 memset(ptr+0xa+namelen, 0, 0x75-namelen); \
2345                 for (j=0; j<127; j++) xor^= ptr[j]; \
2346                 ptr[127] = xor; \
2347                 SaveMcd(Config.Mcd##mcd, Mcd##mcd##Data, 128 * i + 0xa, 0x76); \
2348                 v0 = 1; \
2349                 break; \
2350         } \
2351 }
2352
2353 /*
2354  *      int rename(char *old, char *new);
2355  */
2356
2357 void psxBios_rename() { // 44
2358         void *pa0 = Ra0;
2359         void *pa1 = Ra1;
2360         char *ptr;
2361         int i;
2362
2363 #ifdef PSXBIOS_LOG
2364         PSXBIOS_LOG("psxBios_%s: %s,%s\n", biosB0n[0x44], Ra0, Ra1);
2365 #endif
2366
2367         v0 = 0;
2368
2369         if (pa0 && pa1) {
2370                 if (!strncmp(pa0, "bu00", 4) && !strncmp(pa1, "bu00", 4)) {
2371                         burename(1);
2372                 }
2373
2374                 if (!strncmp(pa0, "bu10", 4) && !strncmp(pa1, "bu10", 4)) {
2375                         burename(2);
2376                 }
2377         }
2378
2379         pc0 = ra;
2380 }
2381
2382
2383 #define budelete(mcd) { \
2384         for (i=1; i<16; i++) { \
2385                 ptr = Mcd##mcd##Data + 128 * i; \
2386                 if ((*ptr & 0xF0) != 0x50) continue; \
2387                 if (strcmp(Ra0+5, ptr+0xa)) continue; \
2388                 *ptr = (*ptr & 0xf) | 0xA0; \
2389                 SaveMcd(Config.Mcd##mcd, Mcd##mcd##Data, 128 * i, 1); \
2390                 SysPrintf("delete %s\n", ptr+0xa); \
2391                 v0 = 1; \
2392                 break; \
2393         } \
2394 }
2395
2396 /*
2397  *      int delete(char *name);
2398  */
2399
2400 void psxBios_delete() { // 45
2401         void *pa0 = Ra0;
2402         char *ptr;
2403         int i;
2404
2405 #ifdef PSXBIOS_LOG
2406         PSXBIOS_LOG("psxBios_%s: %s\n", biosB0n[0x45], Ra0);
2407 #endif
2408
2409         v0 = 0;
2410
2411         if (pa0) {
2412                 if (!strncmp(pa0, "bu00", 4)) {
2413                         budelete(1);
2414                 }
2415
2416                 if (!strncmp(pa0, "bu10", 4)) {
2417                         budelete(2);
2418                 }
2419         }
2420
2421         pc0 = ra;
2422 }
2423
2424 void psxBios_InitCARD() { // 4a
2425 #ifdef PSXBIOS_LOG
2426         PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x4a], a0);
2427 #endif
2428
2429         CardState = 0;
2430
2431         pc0 = ra;
2432 }
2433
2434 void psxBios_StartCARD() { // 4b
2435 #ifdef PSXBIOS_LOG
2436         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x4b]);
2437 #endif
2438
2439         if (CardState == 0) CardState = 1;
2440
2441         pc0 = ra;
2442 }
2443
2444 void psxBios_StopCARD() { // 4c
2445 #ifdef PSXBIOS_LOG
2446         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x4c]);
2447 #endif
2448
2449         if (CardState == 1) CardState = 0;
2450
2451         pc0 = ra;
2452 }
2453
2454 void psxBios__card_write() { // 0x4e
2455         void *pa2 = Ra2;
2456         int port;
2457
2458 #ifdef PSXBIOS_LOG
2459         PSXBIOS_LOG("psxBios_%s: %x,%x,%x\n", biosB0n[0x4e], a0, a1, a2);
2460 #endif
2461         /*
2462         Function also accepts sector 400h (a bug).
2463         But notaz said we shouldn't allow sector 400h because it can corrupt the emulator.
2464         */
2465         if (!(a1 <= 0x3FF))
2466         {
2467                 /* Invalid sectors */
2468                 v0 = 0; pc0 = ra;
2469                 return;
2470         }
2471         card_active_chan = a0;
2472         port = a0 >> 4;
2473
2474         if (pa2) {
2475                 if (port == 0) {
2476                         memcpy(Mcd1Data + a1 * 128, pa2, 128);
2477                         SaveMcd(Config.Mcd1, Mcd1Data, a1 * 128, 128);
2478                 } else {
2479                         memcpy(Mcd2Data + a1 * 128, pa2, 128);
2480                         SaveMcd(Config.Mcd2, Mcd2Data, a1 * 128, 128);
2481                 }
2482         }
2483
2484         DeliverEvent(0x11, 0x2); // 0xf0000011, 0x0004
2485 //      DeliverEvent(0x81, 0x2); // 0xf4000001, 0x0004
2486
2487         v0 = 1; pc0 = ra;
2488 }
2489
2490 void psxBios__card_read() { // 0x4f
2491         void *pa2 = Ra2;
2492         int port;
2493
2494 #ifdef PSXBIOS_LOG
2495         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x4f]);
2496 #endif
2497         /*
2498         Function also accepts sector 400h (a bug).
2499         But notaz said we shouldn't allow sector 400h because it can corrupt the emulator.
2500         */
2501         if (!(a1 <= 0x3FF))
2502         {
2503                 /* Invalid sectors */
2504                 v0 = 0; pc0 = ra;
2505                 return;
2506         }
2507         card_active_chan = a0;
2508         port = a0 >> 4;
2509
2510         if (pa2) {
2511                 if (port == 0) {
2512                         memcpy(pa2, Mcd1Data + a1 * 128, 128);
2513                 } else {
2514                         memcpy(pa2, Mcd2Data + a1 * 128, 128);
2515                 }
2516         }
2517
2518         DeliverEvent(0x11, 0x2); // 0xf0000011, 0x0004
2519 //      DeliverEvent(0x81, 0x2); // 0xf4000001, 0x0004
2520
2521         v0 = 1; pc0 = ra;
2522 }
2523
2524 void psxBios__new_card() { // 0x50
2525 #ifdef PSXBIOS_LOG
2526         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x50]);
2527 #endif
2528
2529         pc0 = ra;
2530 }
2531
2532 /* According to a user, this allows Final Fantasy Tactics to save/load properly */
2533 void psxBios__get_error(void) // 55
2534 {
2535         v0 = 0;
2536         pc0 = ra;
2537 }
2538
2539 void psxBios_Krom2RawAdd() { // 0x51
2540         int i = 0;
2541
2542         const u32 table_8140[][2] = {
2543                 {0x8140, 0x0000}, {0x8180, 0x0762}, {0x81ad, 0x0cc6}, {0x81b8, 0x0ca8},
2544                 {0x81c0, 0x0f00}, {0x81c8, 0x0d98}, {0x81cf, 0x10c2}, {0x81da, 0x0e6a},
2545                 {0x81e9, 0x13ce}, {0x81f0, 0x102c}, {0x81f8, 0x1590}, {0x81fc, 0x111c},
2546                 {0x81fd, 0x1626}, {0x824f, 0x113a}, {0x8259, 0x20ee}, {0x8260, 0x1266},
2547                 {0x827a, 0x24cc}, {0x8281, 0x1572}, {0x829b, 0x28aa}, {0x829f, 0x187e},
2548                 {0x82f2, 0x32dc}, {0x8340, 0x2238}, {0x837f, 0x4362}, {0x8380, 0x299a},
2549                 {0x8397, 0x4632}, {0x839f, 0x2c4c}, {0x83b7, 0x49f2}, {0x83bf, 0x2f1c},
2550                 {0x83d7, 0x4db2}, {0x8440, 0x31ec}, {0x8461, 0x5dde}, {0x8470, 0x35ca},
2551                 {0x847f, 0x6162}, {0x8480, 0x378c}, {0x8492, 0x639c}, {0x849f, 0x39a8},
2552                 {0xffff, 0}
2553         };
2554
2555         const u32 table_889f[][2] = {
2556                 {0x889f, 0x3d68},  {0x8900, 0x40ec},  {0x897f, 0x4fb0},  {0x8a00, 0x56f4},
2557                 {0x8a7f, 0x65b8},  {0x8b00, 0x6cfc},  {0x8b7f, 0x7bc0},  {0x8c00, 0x8304},
2558                 {0x8c7f, 0x91c8},  {0x8d00, 0x990c},  {0x8d7f, 0xa7d0},  {0x8e00, 0xaf14},
2559                 {0x8e7f, 0xbdd8},  {0x8f00, 0xc51c},  {0x8f7f, 0xd3e0},  {0x9000, 0xdb24},
2560                 {0x907f, 0xe9e8},  {0x9100, 0xf12c},  {0x917f, 0xfff0},  {0x9200, 0x10734},
2561                 {0x927f, 0x115f8}, {0x9300, 0x11d3c}, {0x937f, 0x12c00}, {0x9400, 0x13344},
2562                 {0x947f, 0x14208}, {0x9500, 0x1494c}, {0x957f, 0x15810}, {0x9600, 0x15f54},
2563                 {0x967f, 0x16e18}, {0x9700, 0x1755c}, {0x977f, 0x18420}, {0x9800, 0x18b64},
2564                 {0xffff, 0}
2565         };
2566
2567         if (a0 >= 0x8140 && a0 <= 0x84be) {
2568                 while (table_8140[i][0] <= a0) i++;
2569                 a0 -= table_8140[i - 1][0];
2570                 v0 = 0xbfc66000 + (a0 * 0x1e + table_8140[i - 1][1]);
2571         } else if (a0 >= 0x889f && a0 <= 0x9872) {
2572                 while (table_889f[i][0] <= a0) i++;
2573                 a0 -= table_889f[i - 1][0];
2574                 v0 = 0xbfc66000 + (a0 * 0x1e + table_889f[i - 1][1]);
2575         } else {
2576                 v0 = 0xffffffff;
2577         }
2578
2579         pc0 = ra;
2580 }
2581
2582 void psxBios_GetC0Table() { // 56
2583 #ifdef PSXBIOS_LOG
2584         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x56]);
2585 #endif
2586
2587         v0 = 0x674; pc0 = ra;
2588 }
2589
2590 void psxBios_GetB0Table() { // 57
2591 #ifdef PSXBIOS_LOG
2592         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x57]);
2593 #endif
2594
2595         v0 = 0x874; pc0 = ra;
2596 }
2597
2598 void psxBios__card_chan() { // 0x58
2599 #ifdef PSXBIOS_LOG
2600         PSXBIOS_LOG("psxBios_%s\n", biosB0n[0x58]);
2601 #endif
2602
2603         v0 = card_active_chan;
2604         pc0 = ra;
2605 }
2606
2607 void psxBios_ChangeClearPad() { // 5b
2608 #ifdef PSXBIOS_LOG
2609         PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x5b], a0);
2610 #endif
2611
2612         pc0 = ra;
2613 }
2614
2615 void psxBios__card_status() { // 5c
2616 #ifdef PSXBIOS_LOG
2617         PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x5c], a0);
2618 #endif
2619
2620         v0 = card_active_chan;
2621         pc0 = ra;
2622 }
2623
2624 void psxBios__card_wait() { // 5d
2625 #ifdef PSXBIOS_LOG
2626         PSXBIOS_LOG("psxBios_%s: %x\n", biosB0n[0x5d], a0);
2627 #endif
2628
2629         v0 = 1;
2630         pc0 = ra;
2631 }
2632
2633 /* System calls C0 */
2634
2635 /*
2636  * int SysEnqIntRP(int index , long *queue);
2637  */
2638
2639 void psxBios_SysEnqIntRP() { // 02
2640 #ifdef PSXBIOS_LOG
2641         PSXBIOS_LOG("psxBios_%s: %x\n", biosC0n[0x02] ,a0);
2642 #endif
2643
2644         SysIntRP[a0] = a1;
2645
2646         v0 = 0; pc0 = ra;
2647 }
2648
2649 /*
2650  * int SysDeqIntRP(int index , long *queue);
2651  */
2652
2653 void psxBios_SysDeqIntRP() { // 03
2654 #ifdef PSXBIOS_LOG
2655         PSXBIOS_LOG("psxBios_%s: %x\n", biosC0n[0x03], a0);
2656 #endif
2657
2658         SysIntRP[a0] = 0;
2659
2660         v0 = 0; pc0 = ra;
2661 }
2662
2663 void psxBios_ChangeClearRCnt() { // 0a
2664         u32 *ptr;
2665
2666 #ifdef PSXBIOS_LOG
2667         PSXBIOS_LOG("psxBios_%s: %x, %x\n", biosC0n[0x0a], a0, a1);
2668 #endif
2669
2670         ptr = (u32*)PSXM((a0 << 2) + 0x8600);
2671         v0 = *ptr;
2672         *ptr = a1;
2673
2674 //      psxRegs.CP0.n.Status|= 0x404;
2675         pc0 = ra;
2676 }
2677
2678 void psxBios_dummy() {
2679 #ifdef PSXBIOS_LOG
2680         PSXBIOS_LOG("unk %x call: %x\n", pc0 & 0x1fffff, t1);
2681 #endif
2682         pc0 = ra;
2683 }
2684
2685 void (*biosA0[256])();
2686 void (*biosB0[256])();
2687 void (*biosC0[256])();
2688
2689 #include "sjisfont.h"
2690
2691 void psxBiosInit() {
2692         u32 base, size;
2693         u32 *ptr;
2694         int i;
2695         uLongf len;
2696
2697         for(i = 0; i < 256; i++) {
2698                 biosA0[i] = NULL;
2699                 biosB0[i] = NULL;
2700                 biosC0[i] = NULL;
2701         }
2702         biosA0[0x3e] = psxBios_puts;
2703         biosA0[0x3f] = psxBios_printf;
2704
2705         biosB0[0x3d] = psxBios_putchar;
2706         biosB0[0x3f] = psxBios_puts;
2707
2708         if (!Config.HLE) return;
2709
2710         for(i = 0; i < 256; i++) {
2711                 if (biosA0[i] == NULL) biosA0[i] = psxBios_dummy;
2712                 if (biosB0[i] == NULL) biosB0[i] = psxBios_dummy;
2713                 if (biosC0[i] == NULL) biosC0[i] = psxBios_dummy;
2714         }
2715
2716         biosA0[0x00] = psxBios_open;
2717         biosA0[0x01] = psxBios_lseek;
2718         biosA0[0x02] = psxBios_read;
2719         biosA0[0x03] = psxBios_write;
2720         biosA0[0x04] = psxBios_close;
2721         //biosA0[0x05] = psxBios_ioctl;
2722         //biosA0[0x06] = psxBios_exit;
2723         //biosA0[0x07] = psxBios_sys_a0_07;
2724         biosA0[0x08] = psxBios_getc;
2725         biosA0[0x09] = psxBios_putc;
2726         biosA0[0x0a] = psxBios_todigit;
2727         //biosA0[0x0b] = psxBios_atof;
2728         //biosA0[0x0c] = psxBios_strtoul;
2729         //biosA0[0x0d] = psxBios_strtol;
2730         biosA0[0x0e] = psxBios_abs;
2731         biosA0[0x0f] = psxBios_labs;
2732         biosA0[0x10] = psxBios_atoi;
2733         biosA0[0x11] = psxBios_atol;
2734         //biosA0[0x12] = psxBios_atob;
2735         biosA0[0x13] = psxBios_setjmp;
2736         biosA0[0x14] = psxBios_longjmp;
2737         biosA0[0x15] = psxBios_strcat;
2738         biosA0[0x16] = psxBios_strncat;
2739         biosA0[0x17] = psxBios_strcmp;
2740         biosA0[0x18] = psxBios_strncmp;
2741         biosA0[0x19] = psxBios_strcpy;
2742         biosA0[0x1a] = psxBios_strncpy;
2743         biosA0[0x1b] = psxBios_strlen;
2744         biosA0[0x1c] = psxBios_index;
2745         biosA0[0x1d] = psxBios_rindex;
2746         biosA0[0x1e] = psxBios_strchr;
2747         biosA0[0x1f] = psxBios_strrchr;
2748         biosA0[0x20] = psxBios_strpbrk;
2749         biosA0[0x21] = psxBios_strspn;
2750         biosA0[0x22] = psxBios_strcspn;
2751         biosA0[0x23] = psxBios_strtok;
2752         biosA0[0x24] = psxBios_strstr;
2753         biosA0[0x25] = psxBios_toupper;
2754         biosA0[0x26] = psxBios_tolower;
2755         biosA0[0x27] = psxBios_bcopy;
2756         biosA0[0x28] = psxBios_bzero;
2757         biosA0[0x29] = psxBios_bcmp;
2758         biosA0[0x2a] = psxBios_memcpy;
2759         biosA0[0x2b] = psxBios_memset;
2760         biosA0[0x2c] = psxBios_memmove;
2761         biosA0[0x2d] = psxBios_memcmp;
2762         biosA0[0x2e] = psxBios_memchr;
2763         biosA0[0x2f] = psxBios_rand;
2764         biosA0[0x30] = psxBios_srand;
2765         biosA0[0x31] = psxBios_qsort;
2766         //biosA0[0x32] = psxBios_strtod;
2767         biosA0[0x33] = psxBios_malloc;
2768         biosA0[0x34] = psxBios_free;
2769         //biosA0[0x35] = psxBios_lsearch;
2770         //biosA0[0x36] = psxBios_bsearch;
2771         biosA0[0x37] = psxBios_calloc;
2772         biosA0[0x38] = psxBios_realloc;
2773         biosA0[0x39] = psxBios_InitHeap;
2774         //biosA0[0x3a] = psxBios__exit;
2775         biosA0[0x3b] = psxBios_getchar;
2776         biosA0[0x3c] = psxBios_putchar;
2777         //biosA0[0x3d] = psxBios_gets;
2778         //biosA0[0x40] = psxBios_sys_a0_40;
2779         //biosA0[0x41] = psxBios_LoadTest;
2780         biosA0[0x42] = psxBios_Load;
2781         biosA0[0x43] = psxBios_Exec;
2782         biosA0[0x44] = psxBios_FlushCache;
2783         //biosA0[0x45] = psxBios_InstallInterruptHandler;
2784         biosA0[0x46] = psxBios_GPU_dw;
2785         biosA0[0x47] = psxBios_mem2vram;
2786         biosA0[0x48] = psxBios_SendGPU;
2787         biosA0[0x49] = psxBios_GPU_cw;
2788         biosA0[0x4a] = psxBios_GPU_cwb;
2789         biosA0[0x4b] = psxBios_GPU_SendPackets;
2790         biosA0[0x4c] = psxBios_sys_a0_4c;
2791         biosA0[0x4d] = psxBios_GPU_GetGPUStatus;
2792         //biosA0[0x4e] = psxBios_GPU_sync;
2793         //biosA0[0x4f] = psxBios_sys_a0_4f;
2794         //biosA0[0x50] = psxBios_sys_a0_50;
2795         biosA0[0x51] = psxBios_LoadExec;
2796         //biosA0[0x52] = psxBios_GetSysSp;
2797         //biosA0[0x53] = psxBios_sys_a0_53;
2798         //biosA0[0x54] = psxBios__96_init_a54;
2799         //biosA0[0x55] = psxBios__bu_init_a55;
2800         //biosA0[0x56] = psxBios__96_remove_a56;
2801         //biosA0[0x57] = psxBios_sys_a0_57;
2802         //biosA0[0x58] = psxBios_sys_a0_58;
2803         //biosA0[0x59] = psxBios_sys_a0_59;
2804         //biosA0[0x5a] = psxBios_sys_a0_5a;
2805         //biosA0[0x5b] = psxBios_dev_tty_init;
2806         //biosA0[0x5c] = psxBios_dev_tty_open;
2807         //biosA0[0x5d] = psxBios_sys_a0_5d;
2808         //biosA0[0x5e] = psxBios_dev_tty_ioctl;
2809         //biosA0[0x5f] = psxBios_dev_cd_open;
2810         //biosA0[0x60] = psxBios_dev_cd_read;
2811         //biosA0[0x61] = psxBios_dev_cd_close;
2812         //biosA0[0x62] = psxBios_dev_cd_firstfile;
2813         //biosA0[0x63] = psxBios_dev_cd_nextfile;
2814         //biosA0[0x64] = psxBios_dev_cd_chdir;
2815         //biosA0[0x65] = psxBios_dev_card_open;
2816         //biosA0[0x66] = psxBios_dev_card_read;
2817         //biosA0[0x67] = psxBios_dev_card_write;
2818         //biosA0[0x68] = psxBios_dev_card_close;
2819         //biosA0[0x69] = psxBios_dev_card_firstfile;
2820         //biosA0[0x6a] = psxBios_dev_card_nextfile;
2821         //biosA0[0x6b] = psxBios_dev_card_erase;
2822         //biosA0[0x6c] = psxBios_dev_card_undelete;
2823         //biosA0[0x6d] = psxBios_dev_card_format;
2824         //biosA0[0x6e] = psxBios_dev_card_rename;
2825         //biosA0[0x6f] = psxBios_dev_card_6f;
2826         biosA0[0x70] = psxBios__bu_init;
2827         biosA0[0x71] = psxBios__96_init;
2828         biosA0[0x72] = psxBios__96_remove;
2829         //biosA0[0x73] = psxBios_sys_a0_73;
2830         //biosA0[0x74] = psxBios_sys_a0_74;
2831         //biosA0[0x75] = psxBios_sys_a0_75;
2832         //biosA0[0x76] = psxBios_sys_a0_76;
2833         //biosA0[0x77] = psxBios_sys_a0_77;
2834         //biosA0[0x78] = psxBios__96_CdSeekL;
2835         //biosA0[0x79] = psxBios_sys_a0_79;
2836         //biosA0[0x7a] = psxBios_sys_a0_7a;
2837         //biosA0[0x7b] = psxBios_sys_a0_7b;
2838         //biosA0[0x7c] = psxBios__96_CdGetStatus;
2839         //biosA0[0x7d] = psxBios_sys_a0_7d;
2840         //biosA0[0x7e] = psxBios__96_CdRead;
2841         //biosA0[0x7f] = psxBios_sys_a0_7f;
2842         //biosA0[0x80] = psxBios_sys_a0_80;
2843         //biosA0[0x81] = psxBios_sys_a0_81;
2844         //biosA0[0x82] = psxBios_sys_a0_82;
2845         //biosA0[0x83] = psxBios_sys_a0_83;
2846         //biosA0[0x84] = psxBios_sys_a0_84;
2847         //biosA0[0x85] = psxBios__96_CdStop;
2848         //biosA0[0x86] = psxBios_sys_a0_86;
2849         //biosA0[0x87] = psxBios_sys_a0_87;
2850         //biosA0[0x88] = psxBios_sys_a0_88;
2851         //biosA0[0x89] = psxBios_sys_a0_89;
2852         //biosA0[0x8a] = psxBios_sys_a0_8a;
2853         //biosA0[0x8b] = psxBios_sys_a0_8b;
2854         //biosA0[0x8c] = psxBios_sys_a0_8c;
2855         //biosA0[0x8d] = psxBios_sys_a0_8d;
2856         //biosA0[0x8e] = psxBios_sys_a0_8e;
2857         //biosA0[0x8f] = psxBios_sys_a0_8f;
2858         //biosA0[0x90] = psxBios_sys_a0_90;
2859         //biosA0[0x91] = psxBios_sys_a0_91;
2860         //biosA0[0x92] = psxBios_sys_a0_92;
2861         //biosA0[0x93] = psxBios_sys_a0_93;
2862         //biosA0[0x94] = psxBios_sys_a0_94;
2863         //biosA0[0x95] = psxBios_sys_a0_95;
2864         //biosA0[0x96] = psxBios_AddCDROMDevice;
2865         //biosA0[0x97] = psxBios_AddMemCardDevide;
2866         //biosA0[0x98] = psxBios_DisableKernelIORedirection;
2867         //biosA0[0x99] = psxBios_EnableKernelIORedirection;
2868         //biosA0[0x9a] = psxBios_sys_a0_9a;
2869         //biosA0[0x9b] = psxBios_sys_a0_9b;
2870         //biosA0[0x9c] = psxBios_SetConf;
2871         //biosA0[0x9d] = psxBios_GetConf;
2872         //biosA0[0x9e] = psxBios_sys_a0_9e;
2873         biosA0[0x9f] = psxBios_SetMem;
2874         //biosA0[0xa0] = psxBios__boot;
2875         //biosA0[0xa1] = psxBios_SystemError;
2876         //biosA0[0xa2] = psxBios_EnqueueCdIntr;
2877         //biosA0[0xa3] = psxBios_DequeueCdIntr;
2878         //biosA0[0xa4] = psxBios_sys_a0_a4;
2879         //biosA0[0xa5] = psxBios_ReadSector;
2880         biosA0[0xa6] = psxBios_get_cd_status;
2881         //biosA0[0xa7] = psxBios_bufs_cb_0;
2882         //biosA0[0xa8] = psxBios_bufs_cb_1;
2883         //biosA0[0xa9] = psxBios_bufs_cb_2;
2884         //biosA0[0xaa] = psxBios_bufs_cb_3;
2885         biosA0[0xab] = psxBios__card_info;
2886         biosA0[0xac] = psxBios__card_load;
2887         //biosA0[0axd] = psxBios__card_auto;
2888         //biosA0[0xae] = psxBios_bufs_cd_4;
2889         //biosA0[0xaf] = psxBios_sys_a0_af;
2890         //biosA0[0xb0] = psxBios_sys_a0_b0;
2891         //biosA0[0xb1] = psxBios_sys_a0_b1;
2892         //biosA0[0xb2] = psxBios_do_a_long_jmp
2893         //biosA0[0xb3] = psxBios_sys_a0_b3;
2894         //biosA0[0xb4] = psxBios_sub_function;
2895 //*******************B0 CALLS****************************
2896         //biosB0[0x00] = psxBios_SysMalloc;
2897         //biosB0[0x01] = psxBios_sys_b0_01;
2898         biosB0[0x02] = psxBios_SetRCnt;
2899         biosB0[0x03] = psxBios_GetRCnt;
2900         biosB0[0x04] = psxBios_StartRCnt;
2901         biosB0[0x05] = psxBios_StopRCnt;
2902         biosB0[0x06] = psxBios_ResetRCnt;
2903         biosB0[0x07] = psxBios_DeliverEvent;
2904         biosB0[0x08] = psxBios_OpenEvent;
2905         biosB0[0x09] = psxBios_CloseEvent;
2906         biosB0[0x0a] = psxBios_WaitEvent;
2907         biosB0[0x0b] = psxBios_TestEvent;
2908         biosB0[0x0c] = psxBios_EnableEvent;
2909         biosB0[0x0d] = psxBios_DisableEvent;
2910         biosB0[0x0e] = psxBios_OpenTh;
2911         biosB0[0x0f] = psxBios_CloseTh;
2912         biosB0[0x10] = psxBios_ChangeTh;
2913         //biosB0[0x11] = psxBios_psxBios_b0_11;
2914         biosB0[0x12] = psxBios_InitPAD;
2915         biosB0[0x13] = psxBios_StartPAD;
2916         biosB0[0x14] = psxBios_StopPAD;
2917         biosB0[0x15] = psxBios_PAD_init;
2918         biosB0[0x16] = psxBios_PAD_dr;
2919         biosB0[0x17] = psxBios_ReturnFromException;
2920         biosB0[0x18] = psxBios_ResetEntryInt;
2921         biosB0[0x19] = psxBios_HookEntryInt;
2922         //biosB0[0x1a] = psxBios_sys_b0_1a;
2923         //biosB0[0x1b] = psxBios_sys_b0_1b;
2924         //biosB0[0x1c] = psxBios_sys_b0_1c;
2925         //biosB0[0x1d] = psxBios_sys_b0_1d;
2926         //biosB0[0x1e] = psxBios_sys_b0_1e;
2927         //biosB0[0x1f] = psxBios_sys_b0_1f;
2928         biosB0[0x20] = psxBios_UnDeliverEvent;
2929         //biosB0[0x21] = psxBios_sys_b0_21;
2930         //biosB0[0x22] = psxBios_sys_b0_22;
2931         //biosB0[0x23] = psxBios_sys_b0_23;
2932         //biosB0[0x24] = psxBios_sys_b0_24;
2933         //biosB0[0x25] = psxBios_sys_b0_25;
2934         //biosB0[0x26] = psxBios_sys_b0_26;
2935         //biosB0[0x27] = psxBios_sys_b0_27;
2936         //biosB0[0x28] = psxBios_sys_b0_28;
2937         //biosB0[0x29] = psxBios_sys_b0_29;
2938         //biosB0[0x2a] = psxBios_sys_b0_2a;
2939         //biosB0[0x2b] = psxBios_sys_b0_2b;
2940         //biosB0[0x2c] = psxBios_sys_b0_2c;
2941         //biosB0[0x2d] = psxBios_sys_b0_2d;
2942         //biosB0[0x2e] = psxBios_sys_b0_2e;
2943         //biosB0[0x2f] = psxBios_sys_b0_2f;
2944         //biosB0[0x30] = psxBios_sys_b0_30;
2945         //biosB0[0x31] = psxBios_sys_b0_31;
2946         biosB0[0x32] = psxBios_open;
2947         biosB0[0x33] = psxBios_lseek;
2948         biosB0[0x34] = psxBios_read;
2949         biosB0[0x35] = psxBios_write;
2950         biosB0[0x36] = psxBios_close;
2951         //biosB0[0x37] = psxBios_ioctl;
2952         //biosB0[0x38] = psxBios_exit;
2953         //biosB0[0x39] = psxBios_sys_b0_39;
2954         //biosB0[0x3a] = psxBios_getc;
2955         //biosB0[0x3b] = psxBios_putc;
2956         biosB0[0x3c] = psxBios_getchar;
2957         //biosB0[0x3e] = psxBios_gets;
2958         //biosB0[0x40] = psxBios_cd;
2959         biosB0[0x41] = psxBios_format;
2960         biosB0[0x42] = psxBios_firstfile;
2961         biosB0[0x43] = psxBios_nextfile;
2962         biosB0[0x44] = psxBios_rename;
2963         biosB0[0x45] = psxBios_delete;
2964         //biosB0[0x46] = psxBios_undelete;
2965         //biosB0[0x47] = psxBios_AddDevice;
2966         //biosB0[0x48] = psxBios_RemoteDevice;
2967         //biosB0[0x49] = psxBios_PrintInstalledDevices;
2968         biosB0[0x4a] = psxBios_InitCARD;
2969         biosB0[0x4b] = psxBios_StartCARD;
2970         biosB0[0x4c] = psxBios_StopCARD;
2971         //biosB0[0x4d] = psxBios_sys_b0_4d;
2972         biosB0[0x4e] = psxBios__card_write;
2973         biosB0[0x4f] = psxBios__card_read;
2974         biosB0[0x50] = psxBios__new_card;
2975         biosB0[0x51] = psxBios_Krom2RawAdd;
2976         //biosB0[0x52] = psxBios_sys_b0_52;
2977         //biosB0[0x53] = psxBios_sys_b0_53;
2978         //biosB0[0x54] = psxBios__get_errno;
2979         biosB0[0x55] = psxBios__get_error;
2980         biosB0[0x56] = psxBios_GetC0Table;
2981         biosB0[0x57] = psxBios_GetB0Table;
2982         biosB0[0x58] = psxBios__card_chan;
2983         //biosB0[0x59] = psxBios_sys_b0_59;
2984         //biosB0[0x5a] = psxBios_sys_b0_5a;
2985         biosB0[0x5b] = psxBios_ChangeClearPad;
2986         biosB0[0x5c] = psxBios__card_status;
2987         biosB0[0x5d] = psxBios__card_wait;
2988 //*******************C0 CALLS****************************
2989         //biosC0[0x00] = psxBios_InitRCnt;
2990         //biosC0[0x01] = psxBios_InitException;
2991         biosC0[0x02] = psxBios_SysEnqIntRP;
2992         biosC0[0x03] = psxBios_SysDeqIntRP;
2993         //biosC0[0x04] = psxBios_get_free_EvCB_slot;
2994         //biosC0[0x05] = psxBios_get_free_TCB_slot;
2995         //biosC0[0x06] = psxBios_ExceptionHandler;
2996         //biosC0[0x07] = psxBios_InstallExeptionHandler;
2997         //biosC0[0x08] = psxBios_SysInitMemory;
2998         //biosC0[0x09] = psxBios_SysInitKMem;
2999         biosC0[0x0a] = psxBios_ChangeClearRCnt;
3000         //biosC0[0x0b] = psxBios_SystemError;
3001         //biosC0[0x0c] = psxBios_InitDefInt;
3002         //biosC0[0x0d] = psxBios_sys_c0_0d;
3003         //biosC0[0x0e] = psxBios_sys_c0_0e;
3004         //biosC0[0x0f] = psxBios_sys_c0_0f;
3005         //biosC0[0x10] = psxBios_sys_c0_10;
3006         //biosC0[0x11] = psxBios_sys_c0_11;
3007         //biosC0[0x12] = psxBios_InstallDevices;
3008         //biosC0[0x13] = psxBios_FlushStfInOutPut;
3009         //biosC0[0x14] = psxBios_sys_c0_14;
3010         //biosC0[0x15] = psxBios__cdevinput;
3011         //biosC0[0x16] = psxBios__cdevscan;
3012         //biosC0[0x17] = psxBios__circgetc;
3013         //biosC0[0x18] = psxBios__circputc;
3014         //biosC0[0x19] = psxBios_ioabort;
3015         //biosC0[0x1a] = psxBios_sys_c0_1a
3016         //biosC0[0x1b] = psxBios_KernelRedirect;
3017         //biosC0[0x1c] = psxBios_PatchAOTable;
3018 //************** THE END ***************************************
3019 /**/
3020         base = 0x1000;
3021         size = sizeof(EvCB) * 32;
3022         EventCB = (void *)&psxR[base]; base += size * 6;
3023         memset(EventCB, 0, size * 6);
3024         HwEV = EventCB;
3025         EvEV = EventCB + 32;
3026         RcEV = EventCB + 32 * 2;
3027         UeEV = EventCB + 32 * 3;
3028         SwEV = EventCB + 32 * 4;
3029         ThEV = EventCB + 32 * 5;
3030
3031         ptr = (u32 *)&psxM[0x0874]; // b0 table
3032         ptr[0] = SWAPu32(0x4c54 - 0x884);
3033
3034         ptr = (u32 *)&psxM[0x0674]; // c0 table
3035         ptr[6] = SWAPu32(0xc80);
3036
3037         memset(SysIntRP, 0, sizeof(SysIntRP));
3038         memset(ThreadCB, 0, sizeof(ThreadCB));
3039         ThreadCB[0].status = 2; // main thread
3040
3041         pad_stopped = 1;
3042         jmp_int = NULL;
3043         pad_buf = NULL;
3044         pad_buf1 = NULL;
3045         pad_buf2 = NULL;
3046         pad_buf1len = pad_buf2len = 0;
3047         heap_addr = NULL;
3048         heap_end = NULL;
3049         heap_size = 0;
3050         CardState = -1;
3051         CurThread = 0;
3052         memset(FDesc, 0, sizeof(FDesc));
3053         card_active_chan = 0;
3054
3055         psxMu32ref(0x0150) = SWAPu32(0x160);
3056         psxMu32ref(0x0154) = SWAPu32(0x320);
3057         psxMu32ref(0x0160) = SWAPu32(0x248);
3058         strcpy((char *)&psxM[0x248], "bu");
3059 /*      psxMu32ref(0x0ca8) = SWAPu32(0x1f410004);
3060         psxMu32ref(0x0cf0) = SWAPu32(0x3c020000);
3061         psxMu32ref(0x0cf4) = SWAPu32(0x2442641c);
3062         psxMu32ref(0x09e0) = SWAPu32(0x43d0);
3063         psxMu32ref(0x4d98) = SWAPu32(0x946f000a);
3064 */
3065         // opcode HLE
3066         psxRu32ref(0x0000) = SWAPu32((0x3b << 26) | 4);
3067         /* Whatever this does, it actually breaks CTR, even without the uninitiliazed memory patch.
3068         Normally games shouldn't read from address 0 yet they do. See explanation below in details. */
3069         //psxMu32ref(0x0000) = SWAPu32((0x3b << 26) | 0);
3070         psxMu32ref(0x00a0) = SWAPu32((0x3b << 26) | 1);
3071         psxMu32ref(0x00b0) = SWAPu32((0x3b << 26) | 2);
3072         psxMu32ref(0x00c0) = SWAPu32((0x3b << 26) | 3);
3073         psxMu32ref(0x4c54) = SWAPu32((0x3b << 26) | 0);
3074         psxMu32ref(0x8000) = SWAPu32((0x3b << 26) | 5);
3075         psxMu32ref(0x07a0) = SWAPu32((0x3b << 26) | 0);
3076         psxMu32ref(0x0884) = SWAPu32((0x3b << 26) | 0);
3077         psxMu32ref(0x0894) = SWAPu32((0x3b << 26) | 0);
3078
3079         // initial stack pointer for BIOS interrupt
3080         psxMu32ref(0x6c80) = SWAPu32(0x000085c8);
3081
3082         // initial RNG seed
3083         psxMu32ref(0x9010) = SWAPu32(0xac20cc00);
3084
3085         // fonts
3086         len = 0x80000 - 0x66000;
3087         uncompress((Bytef *)(psxR + 0x66000), &len, font_8140, sizeof(font_8140));
3088         len = 0x80000 - 0x69d68;
3089         uncompress((Bytef *)(psxR + 0x69d68), &len, font_889f, sizeof(font_889f));
3090
3091         // memory size 2 MB
3092         psxHu32ref(0x1060) = SWAPu32(0x00000b88);
3093
3094         hleSoftCall = FALSE;
3095
3096         /*      Some games like R-Types, CTR, Fade to Black read from adress 0x00000000 due to uninitialized pointers.
3097                 See Garbage Area at Address 00000000h in Nocash PSX Specfications for more information.
3098                 Here are some examples of games not working with this fix in place :
3099                 R-type won't get past the Irem logo if not implemented.
3100                 Crash Team Racing will softlock after the Sony logo.
3101         */
3102
3103         psxMu32ref(0x0000) = SWAPu32(0x00000003);
3104         /*
3105         But overwritten by 00000003h after soon.
3106         psxMu32ref(0x0000) = SWAPu32(0x00001A3C);
3107         */
3108         psxMu32ref(0x0004) = SWAPu32(0x800C5A27);
3109         psxMu32ref(0x0008) = SWAPu32(0x08000403);
3110         psxMu32ref(0x000C) = SWAPu32(0x00000000);
3111 }
3112
3113 void psxBiosShutdown() {
3114 }
3115
3116 #define psxBios_PADpoll(pad) { \
3117         PAD##pad##_startPoll(pad); \
3118         pad_buf##pad[0] = 0; \
3119         pad_buf##pad[1] = PAD##pad##_poll(0x42); \
3120         if (!(pad_buf##pad[1] & 0x0f)) { \
3121                 bufcount = 32; \
3122         } else { \
3123                 bufcount = (pad_buf##pad[1] & 0x0f) * 2; \
3124         } \
3125         PAD##pad##_poll(0); \
3126         i = 2; \
3127         while (bufcount--) { \
3128                 pad_buf##pad[i++] = PAD##pad##_poll(0); \
3129         } \
3130 }
3131
3132 void biosInterrupt() {
3133         int i, bufcount;
3134
3135 //      if (psxHu32(0x1070) & 0x1) { // Vsync
3136                 if (pad_buf != NULL) {
3137                         u32 *buf = (u32*)pad_buf;
3138
3139                         if (!Config.UseNet) {
3140                                 PAD1_startPoll(1);
3141                                 if (PAD1_poll(0x42) == 0x23) {
3142                                         PAD1_poll(0);
3143                                         *buf = PAD1_poll(0) << 8;
3144                                         *buf |= PAD1_poll(0);
3145                                         PAD1_poll(0);
3146                                         *buf &= ~((PAD1_poll(0) > 0x20) ? 1 << 6 : 0);
3147                                         *buf &= ~((PAD1_poll(0) > 0x20) ? 1 << 7 : 0);
3148                                 } else {
3149                                         PAD1_poll(0);
3150                                         *buf = PAD1_poll(0) << 8;
3151                                         *buf|= PAD1_poll(0);
3152                                 }
3153
3154                                 PAD2_startPoll(2);
3155                                 if (PAD2_poll(0x42) == 0x23) {
3156                                         PAD2_poll(0);
3157                                         *buf |= PAD2_poll(0) << 24;
3158                                         *buf |= PAD2_poll(0) << 16;
3159                                         PAD2_poll(0);
3160                                         *buf &= ~((PAD2_poll(0) > 0x20) ? 1 << 22 : 0);
3161                                         *buf &= ~((PAD2_poll(0) > 0x20) ? 1 << 23 : 0);
3162                                 } else {
3163                                         PAD2_poll(0);
3164                                         *buf |= PAD2_poll(0) << 24;
3165                                         *buf |= PAD2_poll(0) << 16;
3166                                 }
3167                         } else {
3168                                 u16 data;
3169
3170                                 PAD1_startPoll(1);
3171                                 PAD1_poll(0x42);
3172                                 PAD1_poll(0);
3173                                 data = PAD1_poll(0) << 8;
3174                                 data |= PAD1_poll(0);
3175
3176                                 if (NET_sendPadData(&data, 2) == -1)
3177                                         netError();
3178
3179                                 if (NET_recvPadData(&((u16*)buf)[0], 1) == -1)
3180                                         netError();
3181                                 if (NET_recvPadData(&((u16*)buf)[1], 2) == -1)
3182                                         netError();
3183                         }
3184                 }
3185                 if (Config.UseNet && pad_buf1 != NULL && pad_buf2 != NULL) {
3186                         psxBios_PADpoll(1);
3187
3188                         if (NET_sendPadData(pad_buf1, i) == -1)
3189                                 netError();
3190
3191                         if (NET_recvPadData(pad_buf1, 1) == -1)
3192                                 netError();
3193                         if (NET_recvPadData(pad_buf2, 2) == -1)
3194                                 netError();
3195                 } else {
3196                         if (!pad_stopped)  {
3197                                 if (pad_buf1) {
3198                                         psxBios_PADpoll(1);
3199                                 }
3200
3201                                 if (pad_buf2) {
3202                                         psxBios_PADpoll(2);
3203                                 }
3204                         }
3205                 }
3206
3207         if (psxHu32(0x1070) & 0x1) { // Vsync
3208                 if (RcEV[3][1].status == EvStACTIVE) {
3209                         softCall(RcEV[3][1].fhandler);
3210 //                      hwWrite32(0x1f801070, ~(1));
3211                 }
3212         }
3213
3214         if (psxHu32(0x1070) & 0x70) { // Rcnt 0,1,2
3215                 int i;
3216
3217                 for (i = 0; i < 3; i++) {
3218                         if (psxHu32(0x1070) & (1 << (i + 4))) {
3219                                 if (RcEV[i][1].status == EvStACTIVE) {
3220                                         softCall(RcEV[i][1].fhandler);
3221                                 }
3222                                 psxHwWrite32(0x1f801070, ~(1 << (i + 4)));
3223                         }
3224                 }
3225         }
3226 }
3227
3228 void psxBiosException() {
3229         int i;
3230
3231         switch (psxRegs.CP0.n.Cause & 0x3c) {
3232                 case 0x00: // Interrupt
3233                         interrupt_r26=psxRegs.CP0.n.EPC;
3234 #ifdef PSXCPU_LOG
3235 //                      PSXCPU_LOG("interrupt\n");
3236 #endif
3237                         SaveRegs();
3238
3239                         sp = psxMu32(0x6c80); // create new stack for interrupt handlers
3240
3241                         biosInterrupt();
3242
3243                         for (i = 0; i < 8; i++) {
3244                                 if (SysIntRP[i]) {
3245                                         u32 *queue = (u32 *)PSXM(SysIntRP[i]);
3246
3247                                         s0 = queue[2];
3248                                         softCall(queue[1]);
3249                                 }
3250                         }
3251
3252                         if (jmp_int != NULL) {
3253                                 int i;
3254
3255                                 psxHwWrite32(0x1f801070, 0xffffffff);
3256
3257                                 ra = jmp_int[0];
3258                                 sp = jmp_int[1];
3259                                 fp = jmp_int[2];
3260                                 for (i = 0; i < 8; i++) // s0-s7
3261                                          psxRegs.GPR.r[16 + i] = jmp_int[3 + i];
3262                                 gp = jmp_int[11];
3263
3264                                 v0 = 1;
3265                                 pc0 = ra;
3266                                 return;
3267                         }
3268                         psxHwWrite16(0x1f801070, 0);
3269                         break;
3270
3271                 case 0x20: // Syscall
3272 #ifdef PSXCPU_LOG
3273                         PSXCPU_LOG("syscall exp %x\n", a0);
3274 #endif
3275                         switch (a0) {
3276                                 case 1: // EnterCritical - disable irq's
3277                                         /* Fixes Medievil 2 not loading up new game, Digimon World not booting up and possibly others */
3278                                         v0 = (psxRegs.CP0.n.Status & 0x404) == 0x404;
3279                                         psxRegs.CP0.n.Status &= ~0x404;
3280                                         break;
3281
3282                                 case 2: // ExitCritical - enable irq's
3283                                         psxRegs.CP0.n.Status |= 0x404;
3284                                         break;
3285                                 /* Normally this should cover SYS(00h, SYS(04h but they don't do anything relevant so... */
3286                                 default:
3287                                         break;
3288                         }
3289                         pc0 = psxRegs.CP0.n.EPC + 4;
3290
3291                         psxRegs.CP0.n.Status = (psxRegs.CP0.n.Status & 0xfffffff0) |
3292                                                                   ((psxRegs.CP0.n.Status & 0x3c) >> 2);
3293                         return;
3294
3295                 default:
3296 #ifdef PSXCPU_LOG
3297                         PSXCPU_LOG("unknown bios exception!\n");
3298 #endif
3299                         break;
3300         }
3301
3302         pc0 = psxRegs.CP0.n.EPC;
3303         if (psxRegs.CP0.n.Cause & 0x80000000) pc0+=4;
3304
3305         psxRegs.CP0.n.Status = (psxRegs.CP0.n.Status & 0xfffffff0) |
3306                                                   ((psxRegs.CP0.n.Status & 0x3c) >> 2);
3307 }
3308
3309 #define bfreeze(ptr, size) { \
3310         if (Mode == 1) memcpy(&psxR[base], ptr, size); \
3311         if (Mode == 0) memcpy(ptr, &psxR[base], size); \
3312         base += size; \
3313 }
3314
3315 #define bfreezes(ptr) bfreeze(ptr, sizeof(ptr))
3316 #define bfreezel(ptr) bfreeze(ptr, sizeof(*ptr))
3317
3318 #define bfreezepsxMptr(ptr, type) { \
3319         if (Mode == 1) { \
3320                 if (ptr) psxRu32ref(base) = SWAPu32((s8 *)(ptr) - psxM); \
3321                 else psxRu32ref(base) = 0; \
3322         } else { \
3323                 if (psxRu32(base) != 0) ptr = (type *)(psxM + psxRu32(base)); \
3324                 else (ptr) = NULL; \
3325         } \
3326         base += sizeof(u32); \
3327 }
3328
3329 void psxBiosFreeze(int Mode) {
3330         u32 base = 0x40000;
3331
3332         bfreezepsxMptr(jmp_int, u32);
3333         bfreezepsxMptr(pad_buf, int);
3334         bfreezepsxMptr(pad_buf1, char);
3335         bfreezepsxMptr(pad_buf2, char);
3336         bfreezepsxMptr(heap_addr, u32);
3337         bfreezel(&pad_buf1len);
3338         bfreezel(&pad_buf2len);
3339         bfreezes(regs);
3340         bfreezes(SysIntRP);
3341         bfreezel(&CardState);
3342         bfreezes(ThreadCB);
3343         bfreezel(&CurThread);
3344         bfreezes(FDesc);
3345         bfreezel(&card_active_chan);
3346         bfreezel(&pad_stopped);
3347         bfreezel(&heap_size);
3348 }