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