X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fpsxmem.c;h=a85fb27d3773d3c6c96b6e08655c8dbdb028c5da;hb=ee8fd5674f74f307878f2dabef7641a837fb2a99;hp=c2bed4c296e2d5562647b3d1f6e66eae6718e1f6;hpb=cd2d587936d9d83af6fd47360103f0e79dcb4341;p=pcsx_rearmed.git diff --git a/libpcsxcore/psxmem.c b/libpcsxcore/psxmem.c index c2bed4c2..a85fb27d 100644 --- a/libpcsxcore/psxmem.c +++ b/libpcsxcore/psxmem.c @@ -29,6 +29,7 @@ #include "psxhw.h" #include "debug.h" +#include "lightrec/mem.h" #include "memmap.h" #ifdef USE_LIBRETRO_VFS @@ -41,7 +42,7 @@ boolean writeok = TRUE; -#ifndef NDEBUG +#if 0 //ndef NDEBUG #include "debug.h" #else void DebugCheckBP(u32 address, enum breakpoint_types type) {} @@ -54,16 +55,7 @@ void (*psxUnmapHook)(void *ptr, size_t size, enum psxMapTag tag); void *psxMap(unsigned long addr, size_t size, int is_fixed, enum psxMapTag tag) { -#ifdef LIGHTREC -#ifdef MAP_FIXED_NOREPLACE - int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE; -#else - int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED; -#endif -#else int flags = MAP_PRIVATE | MAP_ANONYMOUS; -#endif - int try_ = 0; unsigned long mask; void *req, *ret; @@ -72,36 +64,36 @@ retry: if (psxMapHook != NULL) { ret = psxMapHook(addr, size, 0, tag); if (ret == NULL) - return NULL; + return MAP_FAILED; } else { /* avoid MAP_FIXED, it overrides existing mappings.. */ /* if (is_fixed) flags |= MAP_FIXED; */ - req = (void *)addr; + req = (void *)(uintptr_t)addr; ret = mmap(req, size, PROT_READ | PROT_WRITE, flags, -1, 0); if (ret == MAP_FAILED) - return NULL; + return ret; } - if (addr != 0 && ret != (void *)addr) { + 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 NULL; + return MAP_FAILED; } - if (((addr ^ (unsigned long)ret) & ~0xff000000l) && try_ < 2) + 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 = ((unsigned long)ret + mask) & ~mask; + addr = ((uintptr_t)ret + mask) & ~mask; try_++; goto retry; } @@ -148,52 +140,63 @@ 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 *)); - -#ifdef LIGHTREC - psxM = psxMap(0x30000000, 0x00210000, 1, MAP_TAG_RAM); - if (psxM == NULL) - psxM = psxMap(0x70000000, 0x00210000, 1, MAP_TAG_RAM); - -#else +static int psxMemInitMap(void) +{ psxM = psxMap(0x80000000, 0x00210000, 1, MAP_TAG_RAM); -#endif -#ifndef RAM_FIXED - if (psxM == NULL) + if (psxM == MAP_FAILED) psxM = psxMap(0x77000000, 0x00210000, 0, MAP_TAG_RAM); -#endif - if (psxM == NULL) { + if (psxM == MAP_FAILED) { SysMessage(_("mapping main RAM failed")); return -1; } psxP = &psxM[0x200000]; -#ifdef LIGHTREC - psxH = psxMap(0x4f800000, 0x10000, 0, MAP_TAG_OTHER); - if (psxH == NULL) - psxH = psxMap(0x8f800000, 0x10000, 0, MAP_TAG_OTHER); - - psxR = psxMap(0x4fc00000, 0x80000, 0, MAP_TAG_OTHER); - if (psxR == NULL) - psxR = psxMap(0x8fc00000, 0x80000, 0, MAP_TAG_OTHER); -#else psxH = psxMap(0x1f800000, 0x10000, 0, MAP_TAG_OTHER); psxR = psxMap(0x1fc00000, 0x80000, 0, MAP_TAG_OTHER); -#endif - if (psxMemRLUT == NULL || psxMemWLUT == NULL || - psxR == NULL || psxP == NULL || psxH == NULL) { + if (psxR == MAP_FAILED || psxH == MAP_FAILED) { SysMessage(_("Error allocating memory!")); psxMemShutdown(); return -1; } + return 0; +} + +static void psxMemFreeMap(void) +{ + psxUnmap(psxM, 0x00210000, MAP_TAG_RAM); psxM = NULL; + psxUnmap(psxH, 0x10000, MAP_TAG_OTHER); psxH = NULL; + psxUnmap(psxR, 0x80000, MAP_TAG_OTHER); psxR = NULL; +} + +int psxMemInit(void) +{ + unsigned int i; + int ret; + + 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, 0xff, 0x10000 * sizeof(void *)); + memset(psxMemWLUT, 0xff, 0x10000 * sizeof(void *)); + // MemR for (i = 0; i < 0x80; i++) psxMemRLUT[i + 0x0000] = (u8 *)&psxM[(i & 0x1f) << 16]; @@ -214,7 +217,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; @@ -248,9 +255,10 @@ void psxMemReset() { } void psxMemShutdown() { - psxUnmap(psxM, 0x00210000, MAP_TAG_RAM); psxM = NULL; - psxUnmap(psxH, 0x10000, MAP_TAG_OTHER); psxH = NULL; - psxUnmap(psxR, 0x80000, MAP_TAG_OTHER); psxR = NULL; + if (LIGHTREC_CUSTOM_MAP) + lightrec_free_mmap(); + else + psxMemFreeMap(); free(psxMemRLUT); psxMemRLUT = NULL; free(psxMemWLUT); psxMemWLUT = NULL; @@ -268,7 +276,7 @@ u8 psxMemRead8(u32 mem) { 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)); @@ -293,7 +301,7 @@ u16 psxMemRead16(u32 mem) { 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))); @@ -318,7 +326,7 @@ u32 psxMemRead32(u32 mem) { 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))); @@ -343,11 +351,11 @@ void psxMemWrite8(u32 mem, u8 value) { 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 { @@ -370,11 +378,11 @@ void psxMemWrite16(u32 mem, u16 value) { 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 { @@ -387,51 +395,27 @@ void psxMemWrite16(u32 mem, u16 value) { void psxMemWrite32(u32 mem, u32 value) { char *p; -#if defined(ICACHE_EMULATION) - /* Stores in PS1 code during cache isolation invalidate cachelines. - * It is assumed that cache-flush routines write to the lowest 4KB of - * address space for Icache, or 1KB for Dcache/scratchpad. - * Originally, stores had to check 'writeok' in psxRegs struct before - * writing to RAM. To eliminate this necessity, we could simply patch the - * BIOS 0x44 FlushCache() A0 jumptable entry. Unfortunately, this won't - * work for some games that use less-buggy non-BIOS cache-flush routines - * like '007 Tomorrow Never Dies', often provided by SN-systems, the PS1 - * toolchain provider. - * Instead, we backup the lowest 64KB PS1 RAM when the cache is isolated. - * All stores write to RAM regardless of cache state. Thus, cache-flush - * routines temporarily trash the lowest 4KB of PS1 RAM. Fortunately, they - * ran in a 'critical section' with interrupts disabled, so there's little - * worry of PS1 code ever reading the trashed contents. - * We point the relevant portions of psxMemRLUT[] to the 64KB backup while - * cache is isolated. This is in case the dynarec needs to recompile some - * code during isolation. As long as it reads code using psxMemRLUT[] ptrs, - * it should never see trashed RAM contents. - * - * -senquack, mips dynarec team, 2017 - */ - static u32 mem_bak[0x10000/4]; -#endif u32 t; - u32 m = mem & 0xffff; + // if ((mem&0x1fffff) == 0x71E18 || value == 0x48088800) SysPrintf("t2fix!!\n"); t = mem >> 16; if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) { - if (m < 0x400) + 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 @@ -444,39 +428,22 @@ void psxMemWrite32(u32 mem, u32 value) { switch (value) { case 0x800: case 0x804: - if (writeok == FALSE) break; - writeok = FALSE; - memset(psxMemWLUT + 0x0000, 0, 0x80 * sizeof(void *)); - memset(psxMemWLUT + 0x8000, 0, 0x80 * sizeof(void *)); - memset(psxMemWLUT + 0xa000, 0, 0x80 * sizeof(void *)); -#ifdef ICACHE_EMULATION - /* Cache is now isolated, pending cache-flush sequence: - * Backup lower 64KB of PS1 RAM, adjust psxMemRLUT[]. - */ - memcpy((void*)mem_bak, (void*)psxM, sizeof(mem_bak)); - psxMemRLUT[0x0000] = psxMemRLUT[0x0020] = psxMemRLUT[0x0040] = psxMemRLUT[0x0060] = (u8 *)mem_bak; - psxMemRLUT[0x8000] = psxMemRLUT[0x8020] = psxMemRLUT[0x8040] = psxMemRLUT[0x8060] = (u8 *)mem_bak; - psxMemRLUT[0xa000] = psxMemRLUT[0xa020] = psxMemRLUT[0xa040] = psxMemRLUT[0xa060] = (u8 *)mem_bak; + if (writeok == 0) break; + writeok = 0; + memset(psxMemWLUT + 0x0000, 0xff, 0x80 * sizeof(void *)); + memset(psxMemWLUT + 0x8000, 0xff, 0x80 * sizeof(void *)); + memset(psxMemWLUT + 0xa000, 0xff, 0x80 * sizeof(void *)); + /* Required for icache interpreter otherwise Armored Core won't boot on icache interpreter */ psxCpu->Notify(R3000ACPU_NOTIFY_CACHE_ISOLATED, NULL); -#endif break; case 0x00: case 0x1e988: - if (writeok == TRUE) break; - writeok = TRUE; + if (writeok == 1) break; + writeok = 1; 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 *)); -#ifdef ICACHE_EMULATION - /* Cache is now unisolated: - * Restore lower 64KB RAM contents and psxMemRLUT[]. - */ - memcpy((void*)psxM, (void*)mem_bak, sizeof(mem_bak)); - psxMemRLUT[0x0000] = psxMemRLUT[0x0020] = psxMemRLUT[0x0040] = psxMemRLUT[0x0060] = (u8 *)psxM; - psxMemRLUT[0x8000] = psxMemRLUT[0x8020] = psxMemRLUT[0x8040] = psxMemRLUT[0x8060] = (u8 *)psxM; - psxMemRLUT[0xa000] = psxMemRLUT[0xa020] = psxMemRLUT[0xa040] = psxMemRLUT[0xa060] = (u8 *)psxM; /* Dynarecs might take this opportunity to flush their code cache */ psxCpu->Notify(R3000ACPU_NOTIFY_CACHE_UNISOLATED, NULL); -#endif break; default: #ifdef PSXMEM_LOG @@ -501,7 +468,7 @@ void *psxMemPointer(u32 mem) { return NULL; } else { p = (char *)(psxMemWLUT[t]); - if (p != NULL) { + if (p != INVALID_PTR) { return (void *)(p + (mem & 0xffff)); } return NULL;