don't cast between long and pointers for win64
[pcsx_rearmed.git] / libpcsxcore / psxmem.c
CommitLineData
ef79bbde
P
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/*
21* PSX memory functions.
22*/
23
24// TODO: Implement caches & cycle penalty.
25
26#include "psxmem.h"
87e5b45f 27#include "psxmem_map.h"
ef79bbde
P
28#include "r3000a.h"
29#include "psxhw.h"
fc8145b7 30#include "debug.h"
ce0e7ac9 31
479d58cf 32#include "lightrec/mem.h"
ce0e7ac9 33#include "memmap.h"
ef79bbde 34
226a5691 35#ifdef USE_LIBRETRO_VFS
36#include <streams/file_stream_transforms.h>
37#endif
38
ef79bbde
P
39#ifndef MAP_ANONYMOUS
40#define MAP_ANONYMOUS MAP_ANON
41#endif
42
7a811716 43boolean writeok = TRUE;
44
9361a5aa
EC
45#ifndef NDEBUG
46#include "debug.h"
47#else
11a43034 48void DebugCheckBP(u32 address, enum breakpoint_types type) {}
49#endif
50
87e5b45f 51void *(*psxMapHook)(unsigned long addr, size_t size, int is_fixed,
52 enum psxMapTag tag);
53void (*psxUnmapHook)(void *ptr, size_t size, enum psxMapTag tag);
54
55void *psxMap(unsigned long addr, size_t size, int is_fixed,
56 enum psxMapTag tag)
57{
a62012a7 58 int flags = MAP_PRIVATE | MAP_ANONYMOUS;
5644b26c 59 int try_ = 0;
b0dd9956 60 unsigned long mask;
87e5b45f 61 void *req, *ret;
62
b0dd9956 63retry:
64 if (psxMapHook != NULL) {
85f23982 65 ret = psxMapHook(addr, size, 0, tag);
66 if (ret == NULL)
b012a437 67 return MAP_FAILED;
85f23982 68 }
69 else {
70 /* avoid MAP_FIXED, it overrides existing mappings.. */
71 /* if (is_fixed)
72 flags |= MAP_FIXED; */
73
2d724e28 74 req = (void *)(uintptr_t)addr;
85f23982 75 ret = mmap(req, size, PROT_READ | PROT_WRITE, flags, -1, 0);
76 if (ret == MAP_FAILED)
b012a437 77 return ret;
b0dd9956 78 }
87e5b45f 79
2d724e28 80 if (addr != 0 && ret != (void *)(uintptr_t)addr) {
b0dd9956 81 SysMessage("psxMap: warning: wanted to map @%08x, got %p\n",
82 addr, ret);
83
0069615f 84 if (is_fixed) {
85 psxUnmap(ret, size, tag);
b012a437 86 return MAP_FAILED;
0069615f 87 }
88
2d724e28 89 if (((addr ^ (unsigned long)(uintptr_t)ret) & ~0xff000000l) && try_ < 2)
b0dd9956 90 {
91 psxUnmap(ret, size, tag);
92
93 // try to use similarly aligned memory instead
94 // (recompiler needs this)
5644b26c 95 mask = try_ ? 0xffff : 0xffffff;
2d724e28 96 addr = ((uintptr_t)ret + mask) & ~mask;
5644b26c 97 try_++;
b0dd9956 98 goto retry;
99 }
100 }
87e5b45f 101
102 return ret;
103}
104
105void psxUnmap(void *ptr, size_t size, enum psxMapTag tag)
106{
107 if (psxUnmapHook != NULL) {
108 psxUnmapHook(ptr, size, tag);
109 return;
110 }
111
88901dd2 112 if (ptr)
113 munmap(ptr, size);
87e5b45f 114}
115
ef79bbde
P
116s8 *psxM = NULL; // Kernel & User Memory (2 Meg)
117s8 *psxP = NULL; // Parallel Port (64K)
118s8 *psxR = NULL; // BIOS ROM (512K)
119s8 *psxH = NULL; // Scratch Pad (1K) & Hardware Registers (8K)
120
121u8 **psxMemWLUT = NULL;
122u8 **psxMemRLUT = NULL;
123
124/* Playstation Memory Map (from Playstation doc by Joshua Walker)
1250x0000_0000-0x0000_ffff Kernel (64K)
1260x0001_0000-0x001f_ffff User Memory (1.9 Meg)
127
1280x1f00_0000-0x1f00_ffff Parallel Port (64K)
129
1300x1f80_0000-0x1f80_03ff Scratch Pad (1024 bytes)
131
1320x1f80_1000-0x1f80_2fff Hardware Registers (8K)
133
1340x1fc0_0000-0x1fc7_ffff BIOS (512K)
135
1360x8000_0000-0x801f_ffff Kernel and User Memory Mirror (2 Meg) Cached
1370x9fc0_0000-0x9fc7_ffff BIOS Mirror (512K) Cached
138
1390xa000_0000-0xa01f_ffff Kernel and User Memory Mirror (2 Meg) Uncached
1400xbfc0_0000-0xbfc7_ffff BIOS Mirror (512K) Uncached
141*/
142
479d58cf
PC
143static int psxMemInitMap(void)
144{
a62012a7 145 psxM = psxMap(0x80000000, 0x00210000, 1, MAP_TAG_RAM);
b012a437 146 if (psxM == MAP_FAILED)
f23d3386 147 psxM = psxMap(0x77000000, 0x00210000, 0, MAP_TAG_RAM);
b012a437 148 if (psxM == MAP_FAILED) {
a327ad27 149 SysMessage(_("mapping main RAM failed"));
150 return -1;
151 }
ef79bbde
P
152
153 psxP = &psxM[0x200000];
a62012a7
T
154 psxH = psxMap(0x1f800000, 0x10000, 0, MAP_TAG_OTHER);
155 psxR = psxMap(0x1fc00000, 0x80000, 0, MAP_TAG_OTHER);
ef79bbde 156
b012a437 157 if (psxR == MAP_FAILED || psxH == MAP_FAILED) {
ef79bbde 158 SysMessage(_("Error allocating memory!"));
88901dd2 159 psxMemShutdown();
ef79bbde
P
160 return -1;
161 }
162
479d58cf
PC
163 return 0;
164}
165
166static void psxMemFreeMap(void)
167{
168 psxUnmap(psxM, 0x00210000, MAP_TAG_RAM); psxM = NULL;
169 psxUnmap(psxH, 0x10000, MAP_TAG_OTHER); psxH = NULL;
170 psxUnmap(psxR, 0x80000, MAP_TAG_OTHER); psxR = NULL;
171}
172
173int psxMemInit(void)
174{
175 unsigned int i;
176 int ret;
177
640c8536 178 if (LIGHTREC_CUSTOM_MAP)
479d58cf
PC
179 ret = lightrec_init_mmap();
180 else
181 ret = psxMemInitMap();
182 if (ret) {
183 SysMessage(_("Error allocating memory!"));
184 psxMemShutdown();
185 return -1;
186 }
187
b012a437
PC
188 psxMemRLUT = (u8 **)malloc(0x10000 * sizeof(void *));
189 psxMemWLUT = (u8 **)malloc(0x10000 * sizeof(void *));
190
191 if (psxMemRLUT == NULL || psxMemWLUT == NULL) {
192 SysMessage(_("Error allocating memory!"));
193 psxMemShutdown();
194 return -1;
195 }
196
197 memset(psxMemRLUT, 0xff, 0x10000 * sizeof(void *));
198 memset(psxMemWLUT, 0xff, 0x10000 * sizeof(void *));
199
ef79bbde
P
200// MemR
201 for (i = 0; i < 0x80; i++) psxMemRLUT[i + 0x0000] = (u8 *)&psxM[(i & 0x1f) << 16];
202
203 memcpy(psxMemRLUT + 0x8000, psxMemRLUT, 0x80 * sizeof(void *));
204 memcpy(psxMemRLUT + 0xa000, psxMemRLUT, 0x80 * sizeof(void *));
205
206 psxMemRLUT[0x1f00] = (u8 *)psxP;
207 psxMemRLUT[0x1f80] = (u8 *)psxH;
208
209 for (i = 0; i < 0x08; i++) psxMemRLUT[i + 0x1fc0] = (u8 *)&psxR[i << 16];
210
211 memcpy(psxMemRLUT + 0x9fc0, psxMemRLUT + 0x1fc0, 0x08 * sizeof(void *));
212 memcpy(psxMemRLUT + 0xbfc0, psxMemRLUT + 0x1fc0, 0x08 * sizeof(void *));
213
214// MemW
215 for (i = 0; i < 0x80; i++) psxMemWLUT[i + 0x0000] = (u8 *)&psxM[(i & 0x1f) << 16];
216
217 memcpy(psxMemWLUT + 0x8000, psxMemWLUT, 0x80 * sizeof(void *));
218 memcpy(psxMemWLUT + 0xa000, psxMemWLUT, 0x80 * sizeof(void *));
219
6e4e5efb 220 // Don't allow writes to PIO Expansion region (psxP) to take effect.
221 // NOTE: Not sure if this is needed to fix any games but seems wise,
222 // seeing as some games do read from PIO as part of copy-protection
223 // check. (See fix in psxMemReset() regarding psxP region reads).
b012a437 224 psxMemWLUT[0x1f00] = INVALID_PTR;
ef79bbde
P
225 psxMemWLUT[0x1f80] = (u8 *)psxH;
226
227 return 0;
228}
229
230void psxMemReset() {
231 FILE *f = NULL;
232 char bios[1024];
233
234 memset(psxM, 0, 0x00200000);
23643ee7 235 memset(psxP, 0xff, 0x00010000);
ef79bbde 236
9361a5aa
EC
237 Config.HLE = TRUE;
238
ef79bbde
P
239 if (strcmp(Config.Bios, "HLE") != 0) {
240 sprintf(bios, "%s/%s", Config.BiosDir, Config.Bios);
226a5691 241 f = fopen(bios, "rb");
ef79bbde
P
242
243 if (f == NULL) {
244 SysMessage(_("Could not open BIOS:\"%s\". Enabling HLE Bios!\n"), bios);
245 memset(psxR, 0, 0x80000);
ef79bbde 246 } else {
9361a5aa
EC
247 if (fread(psxR, 1, 0x80000, f) == 0x80000) {
248 Config.HLE = FALSE;
249 } else {
250 SysMessage(_("The selected BIOS:\"%s\" is of wrong size. Enabling HLE Bios!\n"), bios);
251 }
ef79bbde 252 fclose(f);
ef79bbde 253 }
9361a5aa 254 }
ef79bbde
P
255}
256
257void psxMemShutdown() {
640c8536 258 if (LIGHTREC_CUSTOM_MAP)
479d58cf
PC
259 lightrec_free_mmap();
260 else
261 psxMemFreeMap();
ef79bbde 262
88901dd2 263 free(psxMemRLUT); psxMemRLUT = NULL;
264 free(psxMemWLUT); psxMemWLUT = NULL;
ef79bbde
P
265}
266
ef79bbde
P
267u8 psxMemRead8(u32 mem) {
268 char *p;
269 u32 t;
270
271 t = mem >> 16;
9dd7d179 272 if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) {
273 if ((mem & 0xffff) < 0x400)
ef79bbde
P
274 return psxHu8(mem);
275 else
276 return psxHwRead8(mem);
277 } else {
278 p = (char *)(psxMemRLUT[t]);
b012a437 279 if (p != INVALID_PTR) {
ef79bbde
P
280 if (Config.Debug)
281 DebugCheckBP((mem & 0xffffff) | 0x80000000, R1);
282 return *(u8 *)(p + (mem & 0xffff));
283 } else {
284#ifdef PSXMEM_LOG
285 PSXMEM_LOG("err lb %8.8lx\n", mem);
286#endif
e86be808 287 return 0xFF;
ef79bbde
P
288 }
289 }
290}
291
292u16 psxMemRead16(u32 mem) {
293 char *p;
294 u32 t;
295
296 t = mem >> 16;
9dd7d179 297 if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) {
298 if ((mem & 0xffff) < 0x400)
ef79bbde
P
299 return psxHu16(mem);
300 else
301 return psxHwRead16(mem);
302 } else {
303 p = (char *)(psxMemRLUT[t]);
b012a437 304 if (p != INVALID_PTR) {
ef79bbde
P
305 if (Config.Debug)
306 DebugCheckBP((mem & 0xffffff) | 0x80000000, R2);
307 return SWAPu16(*(u16 *)(p + (mem & 0xffff)));
308 } else {
309#ifdef PSXMEM_LOG
310 PSXMEM_LOG("err lh %8.8lx\n", mem);
311#endif
e86be808 312 return 0xFFFF;
ef79bbde
P
313 }
314 }
315}
316
317u32 psxMemRead32(u32 mem) {
318 char *p;
319 u32 t;
320
321 t = mem >> 16;
9dd7d179 322 if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) {
323 if ((mem & 0xffff) < 0x400)
ef79bbde
P
324 return psxHu32(mem);
325 else
326 return psxHwRead32(mem);
327 } else {
328 p = (char *)(psxMemRLUT[t]);
b012a437 329 if (p != INVALID_PTR) {
ef79bbde
P
330 if (Config.Debug)
331 DebugCheckBP((mem & 0xffffff) | 0x80000000, R4);
332 return SWAPu32(*(u32 *)(p + (mem & 0xffff)));
333 } else {
334#ifdef PSXMEM_LOG
335 if (writeok) { PSXMEM_LOG("err lw %8.8lx\n", mem); }
336#endif
e86be808 337 return 0xFFFFFFFF;
ef79bbde
P
338 }
339 }
340}
341
342void psxMemWrite8(u32 mem, u8 value) {
343 char *p;
344 u32 t;
345
346 t = mem >> 16;
9dd7d179 347 if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) {
348 if ((mem & 0xffff) < 0x400)
ef79bbde
P
349 psxHu8(mem) = value;
350 else
351 psxHwWrite8(mem, value);
352 } else {
353 p = (char *)(psxMemWLUT[t]);
b012a437 354 if (p != INVALID_PTR) {
ef79bbde
P
355 if (Config.Debug)
356 DebugCheckBP((mem & 0xffffff) | 0x80000000, W1);
357 *(u8 *)(p + (mem & 0xffff)) = value;
630b122b 358#ifndef DRC_DISABLE
ef79bbde
P
359 psxCpu->Clear((mem & (~3)), 1);
360#endif
361 } else {
362#ifdef PSXMEM_LOG
363 PSXMEM_LOG("err sb %8.8lx\n", mem);
364#endif
365 }
366 }
367}
368
369void psxMemWrite16(u32 mem, u16 value) {
370 char *p;
371 u32 t;
372
373 t = mem >> 16;
9dd7d179 374 if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) {
375 if ((mem & 0xffff) < 0x400)
ef79bbde
P
376 psxHu16ref(mem) = SWAPu16(value);
377 else
378 psxHwWrite16(mem, value);
379 } else {
380 p = (char *)(psxMemWLUT[t]);
b012a437 381 if (p != INVALID_PTR) {
ef79bbde
P
382 if (Config.Debug)
383 DebugCheckBP((mem & 0xffffff) | 0x80000000, W2);
384 *(u16 *)(p + (mem & 0xffff)) = SWAPu16(value);
630b122b 385#ifndef DRC_DISABLE
3e31e934 386 psxCpu->Clear((mem & (~3)), 1);
ef79bbde
P
387#endif
388 } else {
389#ifdef PSXMEM_LOG
390 PSXMEM_LOG("err sh %8.8lx\n", mem);
391#endif
392 }
393 }
394}
395
396void psxMemWrite32(u32 mem, u32 value) {
397 char *p;
398 u32 t;
630b122b 399
ef79bbde
P
400// if ((mem&0x1fffff) == 0x71E18 || value == 0x48088800) SysPrintf("t2fix!!\n");
401 t = mem >> 16;
9dd7d179 402 if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) {
630b122b 403 if ((mem & 0xffff) < 0x400)
ef79bbde
P
404 psxHu32ref(mem) = SWAPu32(value);
405 else
406 psxHwWrite32(mem, value);
407 } else {
408 p = (char *)(psxMemWLUT[t]);
b012a437 409 if (p != INVALID_PTR) {
ef79bbde
P
410 if (Config.Debug)
411 DebugCheckBP((mem & 0xffffff) | 0x80000000, W4);
412 *(u32 *)(p + (mem & 0xffff)) = SWAPu32(value);
630b122b 413#ifndef DRC_DISABLE
ef79bbde
P
414 psxCpu->Clear(mem, 1);
415#endif
416 } else {
417 if (mem != 0xfffe0130) {
630b122b 418#ifndef DRC_DISABLE
ef79bbde
P
419 if (!writeok)
420 psxCpu->Clear(mem, 1);
421#endif
422
423#ifdef PSXMEM_LOG
424 if (writeok) { PSXMEM_LOG("err sw %8.8lx\n", mem); }
425#endif
426 } else {
427 int i;
428
429 switch (value) {
430 case 0x800: case 0x804:
630b122b 431 if (writeok == 0) break;
432 writeok = 0;
b012a437
PC
433 memset(psxMemWLUT + 0x0000, 0xff, 0x80 * sizeof(void *));
434 memset(psxMemWLUT + 0x8000, 0xff, 0x80 * sizeof(void *));
435 memset(psxMemWLUT + 0xa000, 0xff, 0x80 * sizeof(void *));
630b122b 436 /* Required for icache interpreter otherwise Armored Core won't boot on icache interpreter */
7a811716 437 psxCpu->Notify(R3000ACPU_NOTIFY_CACHE_ISOLATED, NULL);
ef79bbde
P
438 break;
439 case 0x00: case 0x1e988:
630b122b 440 if (writeok == 1) break;
441 writeok = 1;
ef79bbde
P
442 for (i = 0; i < 0x80; i++) psxMemWLUT[i + 0x0000] = (void *)&psxM[(i & 0x1f) << 16];
443 memcpy(psxMemWLUT + 0x8000, psxMemWLUT, 0x80 * sizeof(void *));
444 memcpy(psxMemWLUT + 0xa000, psxMemWLUT, 0x80 * sizeof(void *));
7a811716 445 /* Dynarecs might take this opportunity to flush their code cache */
446 psxCpu->Notify(R3000ACPU_NOTIFY_CACHE_UNISOLATED, NULL);
ef79bbde
P
447 break;
448 default:
449#ifdef PSXMEM_LOG
450 PSXMEM_LOG("unk %8.8lx = %x\n", mem, value);
451#endif
452 break;
453 }
454 }
455 }
456 }
457}
458
459void *psxMemPointer(u32 mem) {
460 char *p;
461 u32 t;
462
463 t = mem >> 16;
9dd7d179 464 if (t == 0x1f80 || t == 0x9f80 || t == 0xbf80) {
465 if ((mem & 0xffff) < 0x400)
ef79bbde
P
466 return (void *)&psxH[mem];
467 else
468 return NULL;
469 } else {
470 p = (char *)(psxMemWLUT[t]);
b012a437 471 if (p != INVALID_PTR) {
ef79bbde
P
472 return (void *)(p + (mem & 0xffff));
473 }
474 return NULL;
475 }
476}