cdrom: change pause timing again

[pcsx_rearmed.git] / libpcsxcore / psxmem.c

diff --git a/libpcsxcore/psxmem.c b/libpcsxcore/psxmem.c
index 54219ae..4e03b24 100644 (file)
--- a/libpcsxcore/psxmem.c
+++ b/libpcsxcore/psxmem.c
@@ -44,15 +44,39 @@
 static void * psxMapDefault(unsigned long addr, size_t size,
                            int is_fixed, enum psxMapTag tag)
 {
+       void *ptr;
+#if !P_HAVE_MMAP
+       ptr = calloc(1, size);
+       return ptr ? ptr : MAP_FAILED;
+#else
        int flags = MAP_PRIVATE | MAP_ANONYMOUS;
 
-       return mmap((void *)(uintptr_t)addr, size,
+       ptr = mmap((void *)(uintptr_t)addr, size,
                    PROT_READ | PROT_WRITE, flags, -1, 0);
+#ifdef MADV_HUGEPAGE
+       if (size >= 2*1024*1024) {
+               if (ptr != MAP_FAILED && ((uintptr_t)ptr & (2*1024*1024 - 1))) {
+                       // try to manually realign assuming bottom-to-top alloc
+                       munmap(ptr, size);
+                       addr = (uintptr_t)ptr & ~(2*1024*1024 - 1);
+                       ptr = mmap((void *)(uintptr_t)addr, size,
+                               PROT_READ | PROT_WRITE, flags, -1, 0);
+               }
+               if (ptr != MAP_FAILED)
+                       madvise(ptr, size, MADV_HUGEPAGE);
+       }
+#endif
+       return ptr;
+#endif
 }
 
 static void psxUnmapDefault(void *ptr, size_t size, enum psxMapTag tag)
 {
+#if !P_HAVE_MMAP
+       free(ptr);
+#else
        munmap(ptr, size);
+#endif
 }
 
 void *(*psxMapHook)(unsigned long addr, size_t size, int is_fixed,
@@ -182,6 +206,9 @@ int psxMemInit(void)
                return -1;
        }
 
+       if (DISABLE_MEM_LUTS)
+               return 0;
+
        psxMemRLUT = (u8 **)malloc(0x10000 * sizeof(void *));
        psxMemWLUT = (u8 **)malloc(0x10000 * sizeof(void *));
 
@@ -261,19 +288,25 @@ void psxMemShutdown() {
        free(psxMemWLUT); psxMemWLUT = NULL;
 }
 
+int cache_isolated;
+
 void psxMemOnIsolate(int enable)
 {
-       if (enable) {
-               memset(psxMemWLUT + 0x0000, (int)(uintptr_t)INVALID_PTR, 0x80 * sizeof(void *));
-               memset(psxMemWLUT + 0x8000, (int)(uintptr_t)INVALID_PTR, 0x80 * sizeof(void *));
-               //memset(psxMemWLUT + 0xa000, (int)(uintptr_t)INVALID_PTR, 0x80 * sizeof(void *));
-       } else {
-               int i;
-               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 *));
+       if (!DISABLE_MEM_LUTS) {
+               if (enable) {
+                       memset(psxMemWLUT + 0x0000, (int)(uintptr_t)INVALID_PTR, 0x80 * sizeof(void *));
+                       memset(psxMemWLUT + 0x8000, (int)(uintptr_t)INVALID_PTR, 0x80 * sizeof(void *));
+                       //memset(psxMemWLUT + 0xa000, (int)(uintptr_t)INVALID_PTR, 0x80 * sizeof(void *));
+               } else {
+                       int i;
+                       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 *));
+               }
        }
+
+       cache_isolated = enable;
        psxCpu->Notify(enable ? R3000ACPU_NOTIFY_CACHE_ISOLATED
                        : R3000ACPU_NOTIFY_CACHE_UNISOLATED, NULL);
 }
@@ -289,11 +322,11 @@ u8 psxMemRead8(u32 mem) {
                else
                        return psxHwRead8(mem);
        } else {
-               p = (char *)(psxMemRLUT[t]);
+               p = psxm(mem, 0);
                if (p != INVALID_PTR) {
                        if (Config.Debug)
                                DebugCheckBP((mem & 0xffffff) | 0x80000000, R1);
-                       return *(u8 *)(p + (mem & 0xffff));
+                       return *(u8 *)p;
                } else {
 #ifdef PSXMEM_LOG
                        PSXMEM_LOG("err lb %8.8lx\n", mem);
@@ -314,11 +347,11 @@ u16 psxMemRead16(u32 mem) {
                else
                        return psxHwRead16(mem);
        } else {
-               p = (char *)(psxMemRLUT[t]);
+               p = psxm(mem, 0);
                if (p != INVALID_PTR) {
                        if (Config.Debug)
                                DebugCheckBP((mem & 0xffffff) | 0x80000000, R2);
-                       return SWAPu16(*(u16 *)(p + (mem & 0xffff)));
+                       return SWAPu16(*(u16 *)p);
                } else {
 #ifdef PSXMEM_LOG
                        PSXMEM_LOG("err lh %8.8lx\n", mem);
@@ -339,11 +372,11 @@ u32 psxMemRead32(u32 mem) {
                else
                        return psxHwRead32(mem);
        } else {
-               p = (char *)(psxMemRLUT[t]);
+               p = psxm(mem, 0);
                if (p != INVALID_PTR) {
                        if (Config.Debug)
                                DebugCheckBP((mem & 0xffffff) | 0x80000000, R4);
-                       return SWAPu32(*(u32 *)(p + (mem & 0xffff)));
+                       return SWAPu32(*(u32 *)p);
                } else {
                        if (mem == 0xfffe0130)
                                return psxRegs.biuReg;
@@ -355,7 +388,7 @@ u32 psxMemRead32(u32 mem) {
        }
 }
 
-void psxMemWrite8(u32 mem, u8 value) {
+void psxMemWrite8(u32 mem, u32 value) {
        char *p;
        u32 t;
 
@@ -366,11 +399,11 @@ void psxMemWrite8(u32 mem, u8 value) {
                else
                        psxHwWrite8(mem, value);
        } else {
-               p = (char *)(psxMemWLUT[t]);
+               p = psxm(mem, 1);
                if (p != INVALID_PTR) {
                        if (Config.Debug)
                                DebugCheckBP((mem & 0xffffff) | 0x80000000, W1);
-                       *(u8 *)(p + (mem & 0xffff)) = value;
+                       *(u8 *)p = value;
 #ifndef DRC_DISABLE
                        psxCpu->Clear((mem & (~3)), 1);
 #endif
@@ -382,7 +415,7 @@ void psxMemWrite8(u32 mem, u8 value) {
        }
 }
 
-void psxMemWrite16(u32 mem, u16 value) {
+void psxMemWrite16(u32 mem, u32 value) {
        char *p;
        u32 t;
 
@@ -393,11 +426,11 @@ void psxMemWrite16(u32 mem, u16 value) {
                else
                        psxHwWrite16(mem, value);
        } else {
-               p = (char *)(psxMemWLUT[t]);
+               p = psxm(mem, 1);
                if (p != INVALID_PTR) {
                        if (Config.Debug)
                                DebugCheckBP((mem & 0xffffff) | 0x80000000, W2);
-                       *(u16 *)(p + (mem & 0xffff)) = SWAPu16(value);
+                       *(u16 *)p = SWAPu16(value);
 #ifndef DRC_DISABLE
                        psxCpu->Clear((mem & (~3)), 1);
 #endif
@@ -421,11 +454,11 @@ void psxMemWrite32(u32 mem, u32 value) {
                else
                        psxHwWrite32(mem, value);
        } else {
-               p = (char *)(psxMemWLUT[t]);
+               p = psxm(mem, 1);
                if (p != INVALID_PTR) {
                        if (Config.Debug)
                                DebugCheckBP((mem & 0xffffff) | 0x80000000, W4);
-                       *(u32 *)(p + (mem & 0xffff)) = SWAPu32(value);
+                       *(u32 *)p = SWAPu32(value);
 #ifndef DRC_DISABLE
                        psxCpu->Clear(mem, 1);
 #endif
@@ -452,9 +485,9 @@ void *psxMemPointer(u32 mem) {
                else
                        return NULL;
        } else {
-               p = (char *)(psxMemWLUT[t]);
+               p = psxm(mem, 1);
                if (p != INVALID_PTR) {
-                       return (void *)(p + (mem & 0xffff));
+                       return (void *)p;
                }
                return NULL;
        }