X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fpsxmem.c;h=37a0efd0d2bb13a4571366bd5224adf423860a0a;hb=7a8d521fba9c86ae7b51369ce061bf63112b745f;hp=1cabd53cfd236b7e5ea012b4915f660d8b9ed642;hpb=a327ad27099341fb6eed61aa0419dff418429f96;p=pcsx_rearmed.git diff --git a/libpcsxcore/psxmem.c b/libpcsxcore/psxmem.c index 1cabd53c..37a0efd0 100644 --- a/libpcsxcore/psxmem.c +++ b/libpcsxcore/psxmem.c @@ -24,15 +24,88 @@ // TODO: Implement caches & cycle penalty. #include "psxmem.h" +#include "psxmem_map.h" #include "r3000a.h" #include "psxhw.h" -#include "debug.h" -#include +//#include "debug.h" +#define DebugCheckBP(...) + +#include "lightrec/mem.h" +#include "memmap.h" + +#ifdef USE_LIBRETRO_VFS +#include +#endif #ifndef MAP_ANONYMOUS #define MAP_ANONYMOUS MAP_ANON #endif +void *(*psxMapHook)(unsigned long addr, size_t size, int is_fixed, + enum psxMapTag tag); +void (*psxUnmapHook)(void *ptr, size_t size, enum psxMapTag tag); + +void *psxMap(unsigned long addr, size_t size, int is_fixed, + enum psxMapTag tag) +{ + int flags = MAP_PRIVATE | MAP_ANONYMOUS; + int try_ = 0; + unsigned long mask; + void *req, *ret; + +retry: + if (psxMapHook != NULL) { + ret = psxMapHook(addr, size, 0, tag); + if (ret == NULL) + return MAP_FAILED; + } + else { + /* avoid MAP_FIXED, it overrides existing mappings.. */ + /* if (is_fixed) + flags |= MAP_FIXED; */ + + req = (void *)(uintptr_t)addr; + ret = mmap(req, size, PROT_READ | PROT_WRITE, flags, -1, 0); + if (ret == MAP_FAILED) + return ret; + } + + if (addr != 0 && ret != (void *)(uintptr_t)addr) { + SysMessage("psxMap: warning: wanted to map @%08x, got %p\n", + addr, ret); + + if (is_fixed) { + psxUnmap(ret, size, tag); + return MAP_FAILED; + } + + if (((addr ^ (unsigned long)(uintptr_t)ret) & ~0xff000000l) && try_ < 2) + { + psxUnmap(ret, size, tag); + + // try to use similarly aligned memory instead + // (recompiler needs this) + mask = try_ ? 0xffff : 0xffffff; + addr = ((uintptr_t)ret + mask) & ~mask; + try_++; + goto retry; + } + } + + return ret; +} + +void psxUnmap(void *ptr, size_t size, enum psxMapTag tag) +{ + if (psxUnmapHook != NULL) { + psxUnmapHook(ptr, size, tag); + return; + } + + if (ptr) + munmap(ptr, size); +} + s8 *psxM = NULL; // Kernel & User Memory (2 Meg) s8 *psxP = NULL; // Parallel Port (64K) s8 *psxR = NULL; // BIOS ROM (512K) @@ -60,40 +133,71 @@ u8 **psxMemRLUT = NULL; 0xbfc0_0000-0xbfc7_ffff BIOS Mirror (512K) Uncached */ -int psxMemInit() { - int i; - - psxMemRLUT = (u8 **)malloc(0x10000 * sizeof(void *)); - psxMemWLUT = (u8 **)malloc(0x10000 * sizeof(void *)); - memset(psxMemRLUT, 0, 0x10000 * sizeof(void *)); - memset(psxMemWLUT, 0, 0x10000 * sizeof(void *)); - - psxM = mmap((void *)0x80000000, 0x00210000, - PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0); -#ifndef RAM_FIXED +static int psxMemInitMap(void) +{ + psxM = psxMap(0x80000000, 0x00210000, 1, MAP_TAG_RAM); if (psxM == MAP_FAILED) - psxM = mmap((void *)0x70000000, 0x00210000, - PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0); -#endif + psxM = psxMap(0x77000000, 0x00210000, 0, MAP_TAG_RAM); if (psxM == MAP_FAILED) { SysMessage(_("mapping main RAM failed")); + psxM = NULL; return -1; } - psxP = &psxM[0x200000]; - psxH = mmap((void *)0x1f800000, 0x00010000, - PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0); - psxR = mmap((void *)0x1fc00000, 0x80000, - PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + psxH = psxMap(0x1f800000, 0x10000, 0, MAP_TAG_OTHER); + if (psxH == MAP_FAILED) { + SysMessage(_("Error allocating memory!")); + psxMemShutdown(); + return -1; + } + + psxR = psxMap(0x1fc00000, 0x80000, 0, MAP_TAG_OTHER); + if (psxR == MAP_FAILED) { + SysMessage(_("Error allocating memory!")); + psxMemShutdown(); + return -1; + } + + return 0; +} + +static void psxMemFreeMap(void) +{ + if (psxM) psxUnmap(psxM, 0x00210000, MAP_TAG_RAM); + if (psxH) psxUnmap(psxH, 0x10000, MAP_TAG_OTHER); + if (psxR) psxUnmap(psxR, 0x80000, MAP_TAG_OTHER); + psxM = psxH = psxR = NULL; + psxP = NULL; +} + +int psxMemInit(void) +{ + unsigned int i; + int ret; - if (psxMemRLUT == NULL || psxMemWLUT == NULL || - psxR == MAP_FAILED || - psxP == NULL || psxH != (void *)0x1f800000) { + if (LIGHTREC_CUSTOM_MAP) + ret = lightrec_init_mmap(); + else + ret = psxMemInitMap(); + if (ret) { SysMessage(_("Error allocating memory!")); + psxMemShutdown(); return -1; } + psxMemRLUT = (u8 **)malloc(0x10000 * sizeof(void *)); + psxMemWLUT = (u8 **)malloc(0x10000 * sizeof(void *)); + + if (psxMemRLUT == NULL || psxMemWLUT == NULL) { + SysMessage(_("Error allocating memory!")); + psxMemShutdown(); + return -1; + } + + memset(psxMemRLUT, (uintptr_t)INVALID_PTR, 0x10000 * sizeof(void *)); + memset(psxMemWLUT, (uintptr_t)INVALID_PTR, 0x10000 * sizeof(void *)); + // MemR for (i = 0; i < 0x80; i++) psxMemRLUT[i + 0x0000] = (u8 *)&psxM[(i & 0x1f) << 16]; @@ -114,7 +218,11 @@ int psxMemInit() { memcpy(psxMemWLUT + 0x8000, psxMemWLUT, 0x80 * sizeof(void *)); memcpy(psxMemWLUT + 0xa000, psxMemWLUT, 0x80 * sizeof(void *)); - psxMemWLUT[0x1f00] = (u8 *)psxP; + // Don't allow writes to PIO Expansion region (psxP) to take effect. + // NOTE: Not sure if this is needed to fix any games but seems wise, + // seeing as some games do read from PIO as part of copy-protection + // check. (See fix in psxMemReset() regarding psxP region reads). + psxMemWLUT[0x1f00] = INVALID_PTR; psxMemWLUT[0x1f80] = (u8 *)psxH; return 0; @@ -125,7 +233,9 @@ void psxMemReset() { char bios[1024]; memset(psxM, 0, 0x00200000); - memset(psxP, 0, 0x00010000); + memset(psxP, 0xff, 0x00010000); + + Config.HLE = TRUE; if (strcmp(Config.Bios, "HLE") != 0) { sprintf(bios, "%s/%s", Config.BiosDir, Config.Bios); @@ -134,22 +244,25 @@ void psxMemReset() { if (f == NULL) { SysMessage(_("Could not open BIOS:\"%s\". Enabling HLE Bios!\n"), bios); memset(psxR, 0, 0x80000); - Config.HLE = TRUE; } else { - fread(psxR, 1, 0x80000, f); + if (fread(psxR, 1, 0x80000, f) == 0x80000) { + Config.HLE = FALSE; + } else { + SysMessage(_("The selected BIOS:\"%s\" is of wrong size. Enabling HLE Bios!\n"), bios); + } fclose(f); - Config.HLE = FALSE; } - } else Config.HLE = TRUE; + } } void psxMemShutdown() { - munmap(psxM, 0x00210000); - munmap(psxH, 0x1f800000); - munmap(psxR, 0x80000); + if (LIGHTREC_CUSTOM_MAP) + lightrec_free_mmap(); + else + psxMemFreeMap(); - free(psxMemRLUT); - free(psxMemWLUT); + free(psxMemRLUT); psxMemRLUT = NULL; + free(psxMemWLUT); psxMemWLUT = NULL; } static int writeok = 1; @@ -159,14 +272,14 @@ u8 psxMemRead8(u32 mem) { u32 t; t = mem >> 16; - if (t == 0x1f80) { - if (mem < 0x1f801000) + if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) { + if ((mem & 0xffff) < 0x400) return psxHu8(mem); else return psxHwRead8(mem); } else { p = (char *)(psxMemRLUT[t]); - if (p != NULL) { + if (p != INVALID_PTR) { if (Config.Debug) DebugCheckBP((mem & 0xffffff) | 0x80000000, R1); return *(u8 *)(p + (mem & 0xffff)); @@ -174,7 +287,7 @@ u8 psxMemRead8(u32 mem) { #ifdef PSXMEM_LOG PSXMEM_LOG("err lb %8.8lx\n", mem); #endif - return 0; + return 0xFF; } } } @@ -184,14 +297,14 @@ u16 psxMemRead16(u32 mem) { u32 t; t = mem >> 16; - if (t == 0x1f80) { - if (mem < 0x1f801000) + if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) { + if ((mem & 0xffff) < 0x400) return psxHu16(mem); else return psxHwRead16(mem); } else { p = (char *)(psxMemRLUT[t]); - if (p != NULL) { + if (p != INVALID_PTR) { if (Config.Debug) DebugCheckBP((mem & 0xffffff) | 0x80000000, R2); return SWAPu16(*(u16 *)(p + (mem & 0xffff))); @@ -199,7 +312,7 @@ u16 psxMemRead16(u32 mem) { #ifdef PSXMEM_LOG PSXMEM_LOG("err lh %8.8lx\n", mem); #endif - return 0; + return 0xFFFF; } } } @@ -209,14 +322,14 @@ u32 psxMemRead32(u32 mem) { u32 t; t = mem >> 16; - if (t == 0x1f80) { - if (mem < 0x1f801000) + if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) { + if ((mem & 0xffff) < 0x400) return psxHu32(mem); else return psxHwRead32(mem); } else { p = (char *)(psxMemRLUT[t]); - if (p != NULL) { + if (p != INVALID_PTR) { if (Config.Debug) DebugCheckBP((mem & 0xffffff) | 0x80000000, R4); return SWAPu32(*(u32 *)(p + (mem & 0xffff))); @@ -224,7 +337,7 @@ u32 psxMemRead32(u32 mem) { #ifdef PSXMEM_LOG if (writeok) { PSXMEM_LOG("err lw %8.8lx\n", mem); } #endif - return 0; + return 0xFFFFFFFF; } } } @@ -234,18 +347,18 @@ void psxMemWrite8(u32 mem, u8 value) { u32 t; t = mem >> 16; - if (t == 0x1f80) { - if (mem < 0x1f801000) + if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) { + if ((mem & 0xffff) < 0x400) psxHu8(mem) = value; else psxHwWrite8(mem, value); } else { p = (char *)(psxMemWLUT[t]); - if (p != NULL) { + if (p != INVALID_PTR) { if (Config.Debug) DebugCheckBP((mem & 0xffffff) | 0x80000000, W1); *(u8 *)(p + (mem & 0xffff)) = value; -#ifdef PSXREC +#ifndef DRC_DISABLE psxCpu->Clear((mem & (~3)), 1); #endif } else { @@ -261,18 +374,18 @@ void psxMemWrite16(u32 mem, u16 value) { u32 t; t = mem >> 16; - if (t == 0x1f80) { - if (mem < 0x1f801000) + if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) { + if ((mem & 0xffff) < 0x400) psxHu16ref(mem) = SWAPu16(value); else psxHwWrite16(mem, value); } else { p = (char *)(psxMemWLUT[t]); - if (p != NULL) { + if (p != INVALID_PTR) { if (Config.Debug) DebugCheckBP((mem & 0xffffff) | 0x80000000, W2); *(u16 *)(p + (mem & 0xffff)) = SWAPu16(value); -#ifdef PSXREC +#ifndef DRC_DISABLE psxCpu->Clear((mem & (~3)), 1); #endif } else { @@ -289,23 +402,23 @@ void psxMemWrite32(u32 mem, u32 value) { // if ((mem&0x1fffff) == 0x71E18 || value == 0x48088800) SysPrintf("t2fix!!\n"); t = mem >> 16; - if (t == 0x1f80) { - if (mem < 0x1f801000) + if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) { + if ((mem & 0xffff) < 0x400) psxHu32ref(mem) = SWAPu32(value); else psxHwWrite32(mem, value); } else { p = (char *)(psxMemWLUT[t]); - if (p != NULL) { + if (p != INVALID_PTR) { if (Config.Debug) DebugCheckBP((mem & 0xffffff) | 0x80000000, W4); *(u32 *)(p + (mem & 0xffff)) = SWAPu32(value); -#ifdef PSXREC +#ifndef DRC_DISABLE psxCpu->Clear(mem, 1); #endif } else { if (mem != 0xfffe0130) { -#ifdef PSXREC +#ifndef DRC_DISABLE if (!writeok) psxCpu->Clear(mem, 1); #endif @@ -320,9 +433,11 @@ void psxMemWrite32(u32 mem, u32 value) { case 0x800: case 0x804: if (writeok == 0) break; writeok = 0; - memset(psxMemWLUT + 0x0000, 0, 0x80 * sizeof(void *)); - memset(psxMemWLUT + 0x8000, 0, 0x80 * sizeof(void *)); - memset(psxMemWLUT + 0xa000, 0, 0x80 * sizeof(void *)); + memset(psxMemWLUT + 0x0000, (uintptr_t)INVALID_PTR, 0x80 * sizeof(void *)); + memset(psxMemWLUT + 0x8000, (uintptr_t)INVALID_PTR, 0x80 * sizeof(void *)); + memset(psxMemWLUT + 0xa000, (uintptr_t)INVALID_PTR, 0x80 * sizeof(void *)); + /* Required for icache interpreter otherwise Armored Core won't boot on icache interpreter */ + psxCpu->Notify(R3000ACPU_NOTIFY_CACHE_ISOLATED, NULL); break; case 0x00: case 0x1e988: if (writeok == 1) break; @@ -330,6 +445,8 @@ void psxMemWrite32(u32 mem, u32 value) { for (i = 0; i < 0x80; i++) psxMemWLUT[i + 0x0000] = (void *)&psxM[(i & 0x1f) << 16]; memcpy(psxMemWLUT + 0x8000, psxMemWLUT, 0x80 * sizeof(void *)); memcpy(psxMemWLUT + 0xa000, psxMemWLUT, 0x80 * sizeof(void *)); + /* Dynarecs might take this opportunity to flush their code cache */ + psxCpu->Notify(R3000ACPU_NOTIFY_CACHE_UNISOLATED, NULL); break; default: #ifdef PSXMEM_LOG @@ -347,14 +464,14 @@ void *psxMemPointer(u32 mem) { u32 t; t = mem >> 16; - if (t == 0x1f80) { - if (mem < 0x1f801000) + if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) { + if ((mem & 0xffff) < 0x400) return (void *)&psxH[mem]; else return NULL; } else { p = (char *)(psxMemWLUT[t]); - if (p != NULL) { + if (p != INVALID_PTR) { return (void *)(p + (mem & 0xffff)); } return NULL;