libpcsxcore/psxmem.h

   1 /***************************************************************************
   2  *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team              *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
  18  ***************************************************************************/
  19
  20 #ifndef __PSXMEMORY_H__
  21 #define __PSXMEMORY_H__
  22
  23 #ifdef __cplusplus
  24 extern "C" {
  25 #endif
  26
  27 #include "psxcommon.h"
  28
  29 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
  30
  31 #define SWAP16(v) __builtin_bswap16(v)
  32 #define SWAP32(v) __builtin_bswap32(v)
  33 #define SWAPu32(v) SWAP32((u32)(v))
  34 #define SWAPs32(v) SWAP32((s32)(v))
  35
  36 #define SWAPu16(v) SWAP16((u16)(v))
  37 #define SWAPs16(v) SWAP16((s16)(v))
  38
  39 #else
  40
  41 #define SWAP16(b) (b)
  42 #define SWAP32(b) (b)
  43
  44 #define SWAPu16(b) (b)
  45 #define SWAPu32(b) (b)
  46
  47 #endif
  48
  49 #ifdef LIGHTREC
  50 #define INVALID_PTR ((void *)-1)
  51 #else
  52 #define INVALID_PTR NULL
  53 #endif
  54
  55 extern s8 *psxM;
  56 #define psxMs8(mem)             psxM[(mem) & 0x1fffff]
  57 #define psxMs16(mem)    (SWAP16(*(s16 *)&psxM[(mem) & 0x1fffff]))
  58 #define psxMs32(mem)    (SWAP32(*(s32 *)&psxM[(mem) & 0x1fffff]))
  59 #define psxMu8(mem)             (*(u8 *)&psxM[(mem) & 0x1fffff])
  60 #define psxMu16(mem)    (SWAP16(*(u16 *)&psxM[(mem) & 0x1fffff]))
  61 #define psxMu32(mem)    (SWAP32(*(u32 *)&psxM[(mem) & 0x1fffff]))
  62
  63 #define psxMs8ref(mem)  psxM[(mem) & 0x1fffff]
  64 #define psxMs16ref(mem) (*(s16 *)&psxM[(mem) & 0x1fffff])
  65 #define psxMs32ref(mem) (*(s32 *)&psxM[(mem) & 0x1fffff])
  66 #define psxMu8ref(mem)  (*(u8 *)&psxM[(mem) & 0x1fffff])
  67 #define psxMu16ref(mem) (*(u16 *)&psxM[(mem) & 0x1fffff])
  68 #define psxMu32ref(mem) (*(u32 *)&psxM[(mem) & 0x1fffff])
  69
  70 extern s8 *psxP;
  71 #define psxPs8(mem)         psxP[(mem) & 0xffff]
  72 #define psxPs16(mem)    (SWAP16(*(s16 *)&psxP[(mem) & 0xffff]))
  73 #define psxPs32(mem)    (SWAP32(*(s32 *)&psxP[(mem) & 0xffff]))
  74 #define psxPu8(mem)             (*(u8 *)&psxP[(mem) & 0xffff])
  75 #define psxPu16(mem)    (SWAP16(*(u16 *)&psxP[(mem) & 0xffff]))
  76 #define psxPu32(mem)    (SWAP32(*(u32 *)&psxP[(mem) & 0xffff]))
  77
  78 #define psxPs8ref(mem)  psxP[(mem) & 0xffff]
  79 #define psxPs16ref(mem) (*(s16 *)&psxP[(mem) & 0xffff])
  80 #define psxPs32ref(mem) (*(s32 *)&psxP[(mem) & 0xffff])
  81 #define psxPu8ref(mem)  (*(u8 *)&psxP[(mem) & 0xffff])
  82 #define psxPu16ref(mem) (*(u16 *)&psxP[(mem) & 0xffff])
  83 #define psxPu32ref(mem) (*(u32 *)&psxP[(mem) & 0xffff])
  84
  85 extern s8 *psxR;
  86 #define psxRs8(mem)             psxR[(mem) & 0x7ffff]
  87 #define psxRs16(mem)    (SWAP16(*(s16 *)&psxR[(mem) & 0x7ffff]))
  88 #define psxRs32(mem)    (SWAP32(*(s32 *)&psxR[(mem) & 0x7ffff]))
  89 #define psxRu8(mem)             (*(u8* )&psxR[(mem) & 0x7ffff])
  90 #define psxRu16(mem)    (SWAP16(*(u16 *)&psxR[(mem) & 0x7ffff]))
  91 #define psxRu32(mem)    (SWAP32(*(u32 *)&psxR[(mem) & 0x7ffff]))
  92
  93 #define psxRs8ref(mem)  psxR[(mem) & 0x7ffff]
  94 #define psxRs16ref(mem) (*(s16*)&psxR[(mem) & 0x7ffff])
  95 #define psxRs32ref(mem) (*(s32*)&psxR[(mem) & 0x7ffff])
  96 #define psxRu8ref(mem)  (*(u8 *)&psxR[(mem) & 0x7ffff])
  97 #define psxRu16ref(mem) (*(u16*)&psxR[(mem) & 0x7ffff])
  98 #define psxRu32ref(mem) (*(u32*)&psxR[(mem) & 0x7ffff])
  99
 100 extern s8 *psxH;
 101 #define psxHs8(mem)             psxH[(mem) & 0xffff]
 102 #define psxHs16(mem)    (SWAP16(*(s16 *)&psxH[(mem) & 0xffff]))
 103 #define psxHs32(mem)    (SWAP32(*(s32 *)&psxH[(mem) & 0xffff]))
 104 #define psxHu8(mem)             (*(u8 *)&psxH[(mem) & 0xffff])
 105 #define psxHu16(mem)    (SWAP16(*(u16 *)&psxH[(mem) & 0xffff]))
 106 #define psxHu32(mem)    (SWAP32(*(u32 *)&psxH[(mem) & 0xffff]))
 107
 108 #define psxHs8ref(mem)  psxH[(mem) & 0xffff]
 109 #define psxHs16ref(mem) (*(s16 *)&psxH[(mem) & 0xffff])
 110 #define psxHs32ref(mem) (*(s32 *)&psxH[(mem) & 0xffff])
 111 #define psxHu8ref(mem)  (*(u8 *)&psxH[(mem) & 0xffff])
 112 #define psxHu16ref(mem) (*(u16 *)&psxH[(mem) & 0xffff])
 113 #define psxHu32ref(mem) (*(u32 *)&psxH[(mem) & 0xffff])
 114
 115 extern u8 **psxMemWLUT;
 116 extern u8 **psxMemRLUT;
 117 extern int cache_isolated;
 118
 119 #ifndef DISABLE_MEM_LUTS
 120 #define DISABLE_MEM_LUTS 0
 121 #endif
 122
 123 static inline void * psxm_lut(u32 mem, int write, u8 **lut)
 124 {
 125         if (!DISABLE_MEM_LUTS) {
 126                 void *ptr = lut[mem >> 16];
 127
 128                 return ptr == INVALID_PTR ? INVALID_PTR
 129                         : (void *)((uintptr_t)ptr + (u16)mem);
 130         }
 131
 132         if (mem >= 0xa0000000)
 133                 mem -= 0xa0000000;
 134         else
 135                 mem &= ~0x80000000;
 136
 137         if (mem < 0x800000) {
 138                 if (cache_isolated)
 139                         return INVALID_PTR;
 140
 141                 return &psxM[mem & 0x1fffff];
 142         }
 143
 144         if (mem > 0x1f800000 && mem <= 0x1f810000)
 145                 return &psxH[mem - 0x1f800000];
 146
 147         if (!write) {
 148                 if (mem > 0x1fc00000 && mem <= 0x1fc80000)
 149                         return &psxR[mem - 0x1fc00000];
 150
 151                 if (mem > 0x1f000000 && mem <= 0x1f010000)
 152                         return &psxP[mem - 0x1f000000];
 153         }
 154
 155         return INVALID_PTR;
 156 }
 157
 158 static inline void * psxm(u32 mem, int write)
 159 {
 160         return psxm_lut(mem, write, write ? psxMemWLUT : psxMemRLUT);
 161 }
 162
 163 #define PSXM(mem) psxm(mem, 0)
 164 #define PSXMs8(mem)             (*(s8 *)PSXM(mem))
 165 #define PSXMs16(mem)    (SWAP16(*(s16 *)PSXM(mem)))
 166 #define PSXMs32(mem)    (SWAP32(*(s32 *)PSXM(mem)))
 167 #define PSXMu8(mem)             (*(u8 *)PSXM(mem))
 168 #define PSXMu16(mem)    (SWAP16(*(u16 *)PSXM(mem)))
 169 #define PSXMu32(mem)    (SWAP32(*(u32 *)PSXM(mem)))
 170
 171 #define PSXMu32ref(mem) (*(u32 *)PSXM(mem))
 172
 173 int psxMemInit();
 174 void psxMemReset();
 175 void psxMemOnIsolate(int enable);
 176 void psxMemShutdown();
 177
 178 u8 psxMemRead8 (u32 mem);
 179 u16 psxMemRead16(u32 mem);
 180 u32 psxMemRead32(u32 mem);
 181 void psxMemWrite8 (u32 mem, u32 value);
 182 void psxMemWrite16(u32 mem, u32 value);
 183 void psxMemWrite32(u32 mem, u32 value);
 184 void *psxMemPointer(u32 mem);
 185
 186 #ifdef __cplusplus
 187 }
 188 #endif
 189 #endif