drc: starting arm64 support
[pcsx_rearmed.git] / libpcsxcore / new_dynarec / pcsxmem.c
1 /*
2  * (C) GraÅžvydas "notaz" Ignotas, 2010-2011
3  *
4  * This work is licensed under the terms of GNU GPL version 2 or later.
5  * See the COPYING file in the top-level directory.
6  */
7
8 #include <stdio.h>
9 #include "../psxhw.h"
10 #include "../cdrom.h"
11 #include "../mdec.h"
12 #include "../gpu.h"
13 #include "../psxmem_map.h"
14 #include "emu_if.h"
15 #include "pcsxmem.h"
16
17 #ifdef __thumb__
18 #error the dynarec is incompatible with Thumb functions,
19 #error please add -marm to compile flags
20 #endif
21
22 //#define memprintf printf
23 #define memprintf(...)
24
25 static uintptr_t *mem_readtab;
26 static uintptr_t *mem_writetab;
27 static uintptr_t mem_iortab[(1+2+4) * 0x1000 / 4];
28 static uintptr_t mem_iowtab[(1+2+4) * 0x1000 / 4];
29 static uintptr_t mem_ffwtab[(1+2+4) * 0x1000 / 4];
30 //static uintptr_t mem_unmrtab[(1+2+4) * 0x1000 / 4];
31 static uintptr_t mem_unmwtab[(1+2+4) * 0x1000 / 4];
32
33 static
34 #ifdef __clang__
35 // When this is called in a loop, and 'h' is a function pointer, clang will crash.
36 __attribute__ ((noinline))
37 #endif
38 void map_item(uintptr_t *out, const void *h, uintptr_t flag)
39 {
40         uintptr_t hv = (uintptr_t)h;
41         if (hv & 1) {
42                 SysPrintf("FATAL: %p has LSB set\n", h);
43                 abort();
44         }
45         *out = (hv >> 1) | (flag << (sizeof(hv) * 8 - 1));
46 }
47
48 // size must be power of 2, at least 4k
49 #define map_l1_mem(tab, i, addr, size, base) \
50         map_item(&tab[((addr)>>12) + i], (u8 *)(base) - (u32)(addr) - ((i << 12) & ~(size - 1)), 0)
51
52 #define IOMEM32(a) (((a) & 0xfff) / 4)
53 #define IOMEM16(a) (0x1000/4 + (((a) & 0xfff) / 2))
54 #define IOMEM8(a)  (0x1000/4 + 0x1000/2 + ((a) & 0xfff))
55
56 u8 zero_mem[0x1000];
57
58 u32 read_mem_dummy()
59 {
60         return 0;
61 }
62
63 static void write_mem_dummy(u32 data)
64 {
65         memprintf("unmapped w %08x, %08x @%08x %u\n", address, data, psxRegs.pc, psxRegs.cycle);
66 }
67
68 /* IO handlers */
69 static u32 io_read_sio16()
70 {
71         return sioRead8() | (sioRead8() << 8);
72 }
73
74 static u32 io_read_sio32()
75 {
76         return sioRead8() | (sioRead8() << 8) | (sioRead8() << 16) | (sioRead8() << 24);
77 }
78
79 static void io_write_sio16(u32 value)
80 {
81         sioWrite8((unsigned char)value);
82         sioWrite8((unsigned char)(value>>8));
83 }
84
85 static void io_write_sio32(u32 value)
86 {
87         sioWrite8((unsigned char)value);
88         sioWrite8((unsigned char)(value >>  8));
89         sioWrite8((unsigned char)(value >> 16));
90         sioWrite8((unsigned char)(value >> 24));
91 }
92
93 #if !defined(DRC_DBG) && defined(__arm__)
94
95 static void map_rcnt_rcount0(u32 mode)
96 {
97         if (mode & 0x100) { // pixel clock
98                 map_item(&mem_iortab[IOMEM32(0x1100)], rcnt0_read_count_m1, 1);
99                 map_item(&mem_iortab[IOMEM16(0x1100)], rcnt0_read_count_m1, 1);
100         }
101         else {
102                 map_item(&mem_iortab[IOMEM32(0x1100)], rcnt0_read_count_m0, 1);
103                 map_item(&mem_iortab[IOMEM16(0x1100)], rcnt0_read_count_m0, 1);
104         }
105 }
106
107 static void map_rcnt_rcount1(u32 mode)
108 {
109         if (mode & 0x100) { // hcnt
110                 map_item(&mem_iortab[IOMEM32(0x1110)], rcnt1_read_count_m1, 1);
111                 map_item(&mem_iortab[IOMEM16(0x1110)], rcnt1_read_count_m1, 1);
112         }
113         else {
114                 map_item(&mem_iortab[IOMEM32(0x1110)], rcnt1_read_count_m0, 1);
115                 map_item(&mem_iortab[IOMEM16(0x1110)], rcnt1_read_count_m0, 1);
116         }
117 }
118
119 static void map_rcnt_rcount2(u32 mode)
120 {
121         if (mode & 0x01) { // gate
122                 map_item(&mem_iortab[IOMEM32(0x1120)], &psxH[0x1000], 0);
123                 map_item(&mem_iortab[IOMEM16(0x1120)], &psxH[0x1000], 0);
124         }
125         else if (mode & 0x200) { // clk/8
126                 map_item(&mem_iortab[IOMEM32(0x1120)], rcnt2_read_count_m1, 1);
127                 map_item(&mem_iortab[IOMEM16(0x1120)], rcnt2_read_count_m1, 1);
128         }
129         else {
130                 map_item(&mem_iortab[IOMEM32(0x1120)], rcnt2_read_count_m0, 1);
131                 map_item(&mem_iortab[IOMEM16(0x1120)], rcnt2_read_count_m0, 1);
132         }
133 }
134
135 #else
136 #define map_rcnt_rcount0(mode)
137 #define map_rcnt_rcount1(mode)
138 #define map_rcnt_rcount2(mode)
139 #endif
140
141 #define make_rcnt_funcs(i) \
142 static u32 io_rcnt_read_count##i()  { return psxRcntRcount(i); } \
143 static u32 io_rcnt_read_mode##i()   { return psxRcntRmode(i); } \
144 static u32 io_rcnt_read_target##i() { return psxRcntRtarget(i); } \
145 static void io_rcnt_write_count##i(u32 val)  { psxRcntWcount(i, val & 0xffff); } \
146 static void io_rcnt_write_mode##i(u32 val)   { psxRcntWmode(i, val); map_rcnt_rcount##i(val); } \
147 static void io_rcnt_write_target##i(u32 val) { psxRcntWtarget(i, val & 0xffff); }
148
149 make_rcnt_funcs(0)
150 make_rcnt_funcs(1)
151 make_rcnt_funcs(2)
152
153 static void io_write_ireg16(u32 value)
154 {
155         //if (Config.Sio) psxHu16ref(0x1070) |= 0x80;
156         if (Config.SpuIrq) psxHu16ref(0x1070) |= 0x200;
157         psxHu16ref(0x1070) &= value;
158 }
159
160 static void io_write_imask16(u32 value)
161 {
162         psxHu16ref(0x1074) = value;
163         if (psxHu16ref(0x1070) & value)
164                 new_dyna_set_event(PSXINT_NEWDRC_CHECK, 1);
165 }
166
167 static void io_write_ireg32(u32 value)
168 {
169         //if (Config.Sio) psxHu32ref(0x1070) |= 0x80;
170         if (Config.SpuIrq) psxHu32ref(0x1070) |= 0x200;
171         psxHu32ref(0x1070) &= value;
172 }
173
174 static void io_write_imask32(u32 value)
175 {
176         psxHu32ref(0x1074) = value;
177         if (psxHu32ref(0x1070) & value)
178                 new_dyna_set_event(PSXINT_NEWDRC_CHECK, 1);
179 }
180
181 static void io_write_dma_icr32(u32 value)
182 {
183         u32 tmp = value & 0x00ff803f;
184         tmp |= (SWAPu32(HW_DMA_ICR) & ~value) & 0x7f000000;
185         if ((tmp & HW_DMA_ICR_GLOBAL_ENABLE && tmp & 0x7f000000)
186             || tmp & HW_DMA_ICR_BUS_ERROR) {
187                 if (!(SWAPu32(HW_DMA_ICR) & HW_DMA_ICR_IRQ_SENT))
188                         psxHu32ref(0x1070) |= SWAP32(8);
189                 tmp |= HW_DMA_ICR_IRQ_SENT;
190         }
191         HW_DMA_ICR = SWAPu32(tmp);
192 }
193
194 #define make_dma_func(n) \
195 static void io_write_chcr##n(u32 value) \
196 { \
197         HW_DMA##n##_CHCR = value; \
198         if (value & 0x01000000 && HW_DMA_PCR & (8 << (n * 4))) { \
199                 psxDma##n(HW_DMA##n##_MADR, HW_DMA##n##_BCR, value); \
200         } \
201 }
202
203 make_dma_func(0)
204 make_dma_func(1)
205 make_dma_func(2)
206 make_dma_func(3)
207 make_dma_func(4)
208 make_dma_func(6)
209
210 static void io_spu_write16(u32 value)
211 {
212         // meh
213         SPU_writeRegister(address, value, psxRegs.cycle);
214 }
215
216 static void io_spu_write32(u32 value)
217 {
218         SPUwriteRegister wfunc = SPU_writeRegister;
219         u32 a = address;
220
221         wfunc(a, value & 0xffff, psxRegs.cycle);
222         wfunc(a + 2, value >> 16, psxRegs.cycle);
223 }
224
225 static u32 io_gpu_read_status(void)
226 {
227         u32 v;
228
229         // meh2, syncing for img bit, might want to avoid it..
230         gpuSyncPluginSR();
231         v = HW_GPU_STATUS;
232
233         // XXX: because of large timeslices can't use hSyncCount, using rough
234         // approximization instead. Perhaps better use hcounter code here or something.
235         if (hSyncCount < 240 && (HW_GPU_STATUS & PSXGPU_ILACE_BITS) != PSXGPU_ILACE_BITS)
236                 v |= PSXGPU_LCF & (psxRegs.cycle << 20);
237         return v;
238 }
239
240 static void io_gpu_write_status(u32 value)
241 {
242         GPU_writeStatus(value);
243         gpuSyncPluginSR();
244 }
245
246 static void map_ram_write(void)
247 {
248         int i;
249
250         for (i = 0; i < (0x800000 >> 12); i++) {
251                 map_l1_mem(mem_writetab, i, 0x80000000, 0x200000, psxM);
252                 map_l1_mem(mem_writetab, i, 0x00000000, 0x200000, psxM);
253                 map_l1_mem(mem_writetab, i, 0xa0000000, 0x200000, psxM);
254         }
255 }
256
257 static void unmap_ram_write(void)
258 {
259         int i;
260
261         for (i = 0; i < (0x800000 >> 12); i++) {
262                 map_item(&mem_writetab[0x80000|i], mem_unmwtab, 1);
263                 map_item(&mem_writetab[0x00000|i], mem_unmwtab, 1);
264                 map_item(&mem_writetab[0xa0000|i], mem_unmwtab, 1);
265         }
266 }
267
268 static void write_biu(u32 value)
269 {
270         memprintf("write_biu %08x, %08x @%08x %u\n", address, value, psxRegs.pc, psxRegs.cycle);
271
272         if (address != 0xfffe0130)
273                 return;
274
275         switch (value) {
276         case 0x800: case 0x804:
277                 unmap_ram_write();
278                 break;
279         case 0: case 0x1e988:
280                 map_ram_write();
281                 break;
282         default:
283                 printf("write_biu: unexpected val: %08x\n", value);
284                 break;
285         }
286 }
287
288 void new_dyna_pcsx_mem_load_state(void)
289 {
290         map_rcnt_rcount0(rcnts[0].mode);
291         map_rcnt_rcount1(rcnts[1].mode);
292         map_rcnt_rcount2(rcnts[2].mode);
293 }
294
295 int pcsxmem_is_handler_dynamic(unsigned int addr)
296 {
297         if ((addr & 0xfffff000) != 0x1f801000)
298                 return 0;
299
300         addr &= 0xffff;
301         return addr == 0x1100 || addr == 0x1110 || addr == 0x1120;
302 }
303
304 void new_dyna_pcsx_mem_init(void)
305 {
306         int i;
307
308         // have to map these further to keep tcache close to .text
309         mem_readtab = psxMap(0x08000000, 0x200000 * sizeof(mem_readtab[0]), 0, MAP_TAG_LUTS);
310         if (mem_readtab == NULL) {
311                 SysPrintf("failed to map mem tables\n");
312                 exit(1);
313         }
314         mem_writetab = mem_readtab + 0x100000;
315
316         // 1st level lookup:
317         //   0: direct mem
318         //   1: use 2nd lookup
319         // 2nd level lookup:
320         //   0: direct mem variable
321         //   1: memhandler
322
323         // default/unmapped memhandlers
324         for (i = 0; i < 0x100000; i++) {
325                 //map_item(&mem_readtab[i], mem_unmrtab, 1);
326                 map_l1_mem(mem_readtab, i, 0, 0x1000, zero_mem);
327                 map_item(&mem_writetab[i], mem_unmwtab, 1);
328         }
329
330         // RAM and it's mirrors
331         for (i = 0; i < (0x800000 >> 12); i++) {
332                 map_l1_mem(mem_readtab,  i, 0x80000000, 0x200000, psxM);
333                 map_l1_mem(mem_readtab,  i, 0x00000000, 0x200000, psxM);
334                 map_l1_mem(mem_readtab,  i, 0xa0000000, 0x200000, psxM);
335         }
336         map_ram_write();
337
338         // BIOS and it's mirrors
339         for (i = 0; i < (0x80000 >> 12); i++) {
340                 map_l1_mem(mem_readtab, i, 0x1fc00000, 0x80000, psxR);
341                 map_l1_mem(mem_readtab, i, 0xbfc00000, 0x80000, psxR);
342         }
343
344         // scratchpad
345         map_l1_mem(mem_readtab, 0, 0x1f800000, 0x1000, psxH);
346         map_l1_mem(mem_readtab, 0, 0x9f800000, 0x1000, psxH);
347         map_l1_mem(mem_writetab, 0, 0x1f800000, 0x1000, psxH);
348         map_l1_mem(mem_writetab, 0, 0x9f800000, 0x1000, psxH);
349
350         // I/O
351         map_item(&mem_readtab[0x1f801000 >> 12], mem_iortab, 1);
352         map_item(&mem_readtab[0x9f801000 >> 12], mem_iortab, 1);
353         map_item(&mem_readtab[0xbf801000 >> 12], mem_iortab, 1);
354         map_item(&mem_writetab[0x1f801000 >> 12], mem_iowtab, 1);
355         map_item(&mem_writetab[0x9f801000 >> 12], mem_iowtab, 1);
356         map_item(&mem_writetab[0xbf801000 >> 12], mem_iowtab, 1);
357
358         // L2
359         // unmapped tables
360         for (i = 0; i < (1+2+4) * 0x1000 / 4; i++)
361                 map_item(&mem_unmwtab[i], write_mem_dummy, 1);
362
363         // fill IO tables
364         for (i = 0; i < 0x1000/4; i++) {
365           &