339cdfdc0aae576c770d0152e0f3a7ea01e5d02e
[pcsx_rearmed.git] / plugins / gpu_neon / gpu.c
1 /*
2  * (C) Gra┼żvydas "notaz" Ignotas, 2011
3  *
4  * This work is licensed under the terms of any of these licenses
5  * (at your option):
6  *  - GNU GPL, version 2 or later.
7  *  - GNU LGPL, version 2.1 or later.
8  * See the COPYING file in the top-level directory.
9  */
10
11 #include <stdio.h>
12 #include <string.h>
13 #include "gpu.h"
14
15 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
16 #define unlikely(x) __builtin_expect((x), 0)
17 #define noinline __attribute__((noinline))
18
19 #define gpu_log(fmt, ...) \
20   printf("%d:%03d: " fmt, *gpu.state.frame_count, *gpu.state.hcnt, ##__VA_ARGS__)
21
22 //#define log_io gpu_log
23 #define log_io(...)
24 //#define log_anomaly gpu_log
25 #define log_anomaly(...)
26
27 struct psx_gpu gpu __attribute__((aligned(2048)));
28
29 static noinline void do_reset(void)
30 {
31   memset(gpu.regs, 0, sizeof(gpu.regs));
32   memset(gpu.ex_regs, 0, sizeof(gpu.ex_regs));
33   gpu.status.reg = 0x14802000;
34   gpu.gp0 = 0;
35   gpu.regs[3] = 1;
36   gpu.screen.hres = gpu.screen.w = 256;
37   gpu.screen.vres = gpu.screen.h = 240;
38 }
39
40 static noinline void update_width(void)
41 {
42   int sw = gpu.screen.x2 - gpu.screen.x1;
43   if (sw <= 0 || sw >= 2560)
44     // full width
45     gpu.screen.w = gpu.screen.hres;
46   else
47     gpu.screen.w = sw * gpu.screen.hres / 2560;
48 }
49
50 static noinline void update_height(void)
51 {
52   int sh = gpu.screen.y2 - gpu.screen.y1;
53   if (gpu.status.dheight)
54     sh *= 2;
55   if (sh <= 0)
56     sh = gpu.screen.vres;
57
58   gpu.screen.h = sh;
59 }
60
61 static noinline void decide_frameskip(void)
62 {
63   if (gpu.frameskip.active)
64     gpu.frameskip.cnt++;
65   else {
66     gpu.frameskip.cnt = 0;
67     gpu.frameskip.frame_ready = 1;
68   }
69
70   if (!gpu.frameskip.active && *gpu.frameskip.advice)
71     gpu.frameskip.active = 1;
72   else if (gpu.frameskip.set > 0 && gpu.frameskip.cnt < gpu.frameskip.set)
73     gpu.frameskip.active = 1;
74   else
75     gpu.frameskip.active = 0;
76 }
77
78 static noinline void decide_frameskip_allow(uint32_t cmd_e3)
79 {
80   // no frameskip if it decides to draw to display area,
81   // but not for interlace since it'll most likely always do that
82   uint32_t x = cmd_e3 & 0x3ff;
83   uint32_t y = (cmd_e3 >> 10) & 0x3ff;
84   gpu.frameskip.allow = gpu.status.interlace ||
85     (uint32_t)(x - gpu.screen.x) >= (uint32_t)gpu.screen.w ||
86     (uint32_t)(y - gpu.screen.y) >= (uint32_t)gpu.screen.h;
87 }
88
89 static noinline void get_gpu_info(uint32_t data)
90 {
91   switch (data & 0x0f) {
92     case 0x02:
93     case 0x03:
94     case 0x04:
95     case 0x05:
96       gpu.gp0 = gpu.ex_regs[data & 7] & 0xfffff;
97       break;
98     case 0x06:
99       gpu.gp0 = gpu.ex_regs[5] & 0xfffff;
100       break;
101     case 0x07:
102       gpu.gp0 = 2;
103       break;
104     default:
105       gpu.gp0 = 0;
106       break;
107   }
108 }
109
110 long GPUinit(void)
111 {
112   int ret;
113   ret  = vout_init();
114   ret |= renderer_init();
115
116   gpu.state.frame_count = &gpu.zero;
117   gpu.state.hcnt = &gpu.zero;
118   do_reset();
119   return ret;
120 }
121
122 long GPUshutdown(void)
123 {
124   return vout_finish();
125 }
126
127 void GPUwriteStatus(uint32_t data)
128 {
129   static const short hres[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
130   static const short vres[4] = { 240, 480, 256, 480 };
131   uint32_t cmd = data >> 24;
132
133   if (cmd < ARRAY_SIZE(gpu.regs)) {
134     if (cmd != 0 && cmd != 5 && gpu.regs[cmd] == data)
135       return;
136     gpu.regs[cmd] = data;
137   }
138
139   gpu.state.fb_dirty = 1;
140
141   switch (cmd) {
142     case 0x00:
143       do_reset();
144       break;
145     case 0x03:
146       gpu.status.blanking = data & 1;
147       break;
148     case 0x04:
149       gpu.status.dma = data & 3;
150       break;
151     case 0x05:
152       gpu.screen.x = data & 0x3ff;
153       gpu.screen.y = (data >> 10) & 0x3ff;
154       if (gpu.frameskip.set) {
155         decide_frameskip_allow(gpu.ex_regs[3]);
156         if (gpu.frameskip.last_flip_frame != *gpu.state.frame_count) {
157           decide_frameskip();
158           gpu.frameskip.last_flip_frame = *gpu.state.frame_count;
159         }
160       }
161       break;
162     case 0x06:
163       gpu.screen.x1 = data & 0xfff;
164       gpu.screen.x2 = (data >> 12) & 0xfff;
165       update_width();
166       break;
167     case 0x07:
168       gpu.screen.y1 = data & 0x3ff;
169       gpu.screen.y2 = (data >> 10) & 0x3ff;
170       update_height();
171       break;
172     case 0x08:
173       gpu.status.reg = (gpu.status.reg & ~0x7f0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
174       gpu.screen.hres = hres[(gpu.status.reg >> 16) & 7];
175       gpu.screen.vres = vres[(gpu.status.reg >> 19) & 3];
176       update_width();
177       update_height();
178       break;
179     default:
180       if ((cmd & 0xf0) == 0x10)
181         get_gpu_info(data);
182       break;
183   }
184 }
185
186 const unsigned char cmd_lengths[256] =
187 {
188         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
189         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
190         3, 3, 3, 3, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8, 8, 8, // 20
191         5, 5, 5, 5, 8, 8, 8, 8, 7, 7, 7, 7, 11, 11, 11, 11,
192         2, 2, 2, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, // 40
193         3, 3, 3, 3, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4,
194         2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 1, 2, 2, 2, 2, // 60
195         1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2,
196         3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 80
197         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
198         2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // a0
199         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
200         2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // c0
201         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
202         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // e0
203         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
204 };
205
206 #define VRAM_MEM_XY(x, y) &gpu.vram[(y) * 1024 + (x)]
207
208 static inline void do_vram_line(int x, int y, uint16_t *mem, int l, int is_read)
209 {
210   uint16_t *vram = VRAM_MEM_XY(x, y);
211   if (is_read)
212     memcpy(mem, vram, l * 2);
213   else
214     memcpy(vram, mem, l * 2);
215 }
216
217 static int do_vram_io(uint32_t *data, int count, int is_read)
218 {
219   int count_initial = count;
220   uint16_t *sdata = (uint16_t *)data;
221   int x = gpu.dma.x, y = gpu.dma.y;
222   int w = gpu.dma.w, h = gpu.dma.h;
223   int o = gpu.dma.offset;
224   int l;
225   count *= 2; // operate in 16bpp pixels
226
227   if (gpu.dma.offset) {
228     l = w - gpu.dma.offset;
229     if (count < l)
230       l = count;
231
232     do_vram_line(x + o, y, sdata, l, is_read);
233
234     if (o + l < w)
235       o += l;
236     else {
237       o = 0;
238       y++;
239       h--;
240     }
241     sdata += l;
242     count -= l;
243   }
244
245   for (; h > 0 && count >= w; sdata += w, count -= w, y++, h--) {
246     y &= 511;
247     do_vram_line(x, y, sdata, w, is_read);
248   }
249
250   if (h > 0 && count > 0) {
251     y &= 511;
252     do_vram_line(x, y, sdata, count, is_read);
253     o = count;
254     count = 0;
255   }
256   gpu.dma.y = y;
257   gpu.dma.h = h;
258   gpu.dma.offset = o;
259
260   return count_initial - count / 2;
261 }
262
263 static void start_vram_transfer(uint32_t pos_word, uint32_t size_word, int is_read)
264 {
265   if (gpu.dma.h)
266     log_anomaly("start_vram_transfer while old unfinished\n");
267
268   gpu.dma.x = pos_word & 0x3ff;
269   gpu.dma.y = (pos_word >> 16) & 0x1ff;
270   gpu.dma.w = size_word & 0x3ff;
271   gpu.dma.h = (size_word >> 16) & 0x1ff;
272   gpu.dma.offset = 0;
273
274   renderer_flush_queues();
275   if (is_read) {
276     gpu.status.img = 1;
277     // XXX: wrong for width 1
278     memcpy(&gpu.gp0, VRAM_MEM_XY(gpu.dma.x, gpu.dma.y), 4);
279     gpu.state.last_vram_read_frame = *gpu.state.frame_count;
280   }
281   else {
282     renderer_invalidate_caches(gpu.dma.x, gpu.dma.y, gpu.dma.w, gpu.dma.h);
283   }
284
285   log_io("start_vram_transfer %c (%d, %d) %dx%d\n", is_read ? 'r' : 'w',
286     gpu.dma.x, gpu.dma.y, gpu.dma.w, gpu.dma.h);
287 }
288
289 static int check_cmd(uint32_t *data, int count)
290 {
291   int len, cmd, start, pos;
292   int vram_dirty = 0;
293
294   // process buffer
295   for (start = pos = 0; pos < count; )
296   {
297     cmd = -1;
298     len = 0;
299
300     if (gpu.dma.h) {
301       pos += do_vram_io(data + pos, count - pos, 0);
302       if (pos == count)
303         break;
304       start = pos;
305     }
306
307     // do look-ahead pass to detect SR changes and VRAM i/o
308     while (pos < count) {
309       uint32_t *list = data + pos;
310       cmd = list[0] >> 24;
311       len = 1 + cmd_lengths[cmd];
312
313       //printf("  %3d: %02x %d\n", pos, cmd, len);
314       if ((cmd & 0xf4) == 0x24) {
315         // flat textured prim
316         gpu.ex_regs[1] &= ~0x1ff;
317         gpu.ex_regs[1] |= list[4] & 0x1ff;
318       }
319       else if ((cmd & 0xf4) == 0x34) {
320         // shaded textured prim
321         gpu.ex_regs[1] &= ~0x1ff;
322         gpu.ex_regs[1] |= list[5] & 0x1ff;
323       }
324       else if (cmd == 0xe3)
325         decide_frameskip_allow(list[0]);
326
327       if (2 <= cmd && cmd < 0xc0)
328         vram_dirty = 1;
329       else if ((cmd & 0xf8) == 0xe0)
330         gpu.ex_regs[cmd & 7] = list[0];
331
332       if (pos + len > count) {
333         cmd = -1;
334         break; // incomplete cmd
335       }
336       if (cmd == 0xa0 || cmd == 0xc0)
337         break; // image i/o
338       pos += len;
339     }
340
341     if (pos - start > 0) {
342       if (!gpu.frameskip.active || !gpu.frameskip.allow)
343         do_cmd_list(data + start, pos - start);
344       start = pos;
345     }
346
347     if (cmd == 0xa0 || cmd == 0xc0) {
348       // consume vram write/read cmd
349       start_vram_transfer(data[pos + 1], data[pos + 2], cmd == 0xc0);
350       pos += len;
351     }
352     else if (cmd == -1)
353       break;
354   }
355
356   gpu.status.reg &= ~0x1fff;
357   gpu.status.reg |= gpu.ex_regs[1] & 0x7ff;
358   gpu.status.reg |= (gpu.ex_regs[6] & 3) << 11;
359
360   if (gpu.frameskip.active)
361     renderer_sync_ecmds(gpu.ex_regs);
362   gpu.state.fb_dirty |= vram_dirty;
363
364   return count - pos;
365 }
366
367 static void flush_cmd_buffer(void)
368 {
369   int left = check_cmd(gpu.cmd_buffer, gpu.cmd_len);
370   if (left > 0)
371     memmove(gpu.cmd_buffer, gpu.cmd_buffer + gpu.cmd_len - left, left * 4);
372   gpu.cmd_len = left;
373 }
374
375 void GPUwriteDataMem(uint32_t *mem, int count)
376 {
377   int left;
378
379   log_io("gpu_dma_write %p %d\n", mem, count);
380
381   if (unlikely(gpu.cmd_len > 0))
382     flush_cmd_buffer();
383
384   left = check_cmd(mem, count);
385   if (left)
386     log_anomaly("GPUwriteDataMem: discarded %d/%d words\n", left, count);
387 }
388
389 void GPUwriteData(uint32_t data)
390 {
391   log_io("gpu_write %08x\n", data);
392   gpu.cmd_buffer[gpu.cmd_len++] = data;
393   if (gpu.cmd_len >= CMD_BUFFER_LEN)
394     flush_cmd_buffer();
395 }
396
397 long GPUdmaChain(uint32_t *rambase, uint32_t start_addr)
398 {
399   uint32_t addr, *list;
400   uint32_t *llist_entry = NULL;
401   int len, left, count;
402   long cpu_cycles = 0;
403
404   if (unlikely(gpu.cmd_len > 0))
405     flush_cmd_buffer();
406
407   // ff7 sends it's main list twice, detect this
408   if (*gpu.state.frame_count == gpu.state.last_list.frame &&
409       *gpu.state.hcnt - gpu.state.last_list.hcnt <= 1 &&
410        gpu.state.last_list.cycles > 2048)
411   {
412     llist_entry = rambase + (gpu.state.last_list.addr & 0x1fffff) / 4;
413     *llist_entry |= 0x800000;
414   }
415
416   log_io("gpu_dma_chain\n");
417   addr = start_addr & 0xffffff;
418   for (count = 0; addr != 0xffffff; count++)
419   {
420     list = rambase + (addr & 0x1fffff) / 4;
421     len = list[0] >> 24;
422     addr = list[0] & 0xffffff;
423     cpu_cycles += 10;
424     if (len > 0)
425       cpu_cycles += 5 + len;
426
427     log_io(".chain %08x #%d\n", (list - rambase) * 4, len);
428
429     // loop detection marker
430     // (bit23 set causes DMA error on real machine, so
431     //  unlikely to be ever set by the game)
432     list[0] |= 0x800000;
433
434     if (len) {
435       left = check_cmd(list + 1, len);
436       if (left)
437         log_anomaly("GPUdmaChain: discarded %d/%d words\n", left, len);
438     }
439
440     if (addr & 0x800000)
441       break;
442   }
443
444   // remove loop detection markers
445   addr = start_addr & 0x1fffff;
446   while (count-- > 0) {
447     list = rambase + addr / 4;
448     addr = list[0] & 0x1fffff;
449     list[0] &= ~0x800000;
450   }
451   if (llist_entry)
452     *llist_entry &= ~0x800000;
453
454   gpu.state.last_list.frame = *gpu.state.frame_count;
455   gpu.state.last_list.hcnt = *gpu.state.hcnt;
456   gpu.state.last_list.cycles = cpu_cycles;
457   gpu.state.last_list.addr = start_addr;
458
459   return cpu_cycles;
460 }
461
462 void GPUreadDataMem(uint32_t *mem, int count)
463 {
464   log_io("gpu_dma_read  %p %d\n", mem, count);
465
466   if (unlikely(gpu.cmd_len > 0))
467     flush_cmd_buffer();
468
469   if (gpu.dma.h)
470     do_vram_io(mem, count, 1);
471 }
472
473 uint32_t GPUreadData(void)
474 {
475   uint32_t ret;
476
477   if (unlikely(gpu.cmd_len > 0))
478     flush_cmd_buffer();
479
480   ret = gpu.gp0;
481   if (gpu.dma.h)
482     do_vram_io(&ret, 1, 1);
483
484   log_io("gpu_read %08x\n", ret);
485   return ret;
486 }
487
488 uint32_t GPUreadStatus(void)
489 {
490   uint32_t ret;
491
492   if (unlikely(gpu.cmd_len > 0))
493     flush_cmd_buffer();
494
495   ret = gpu.status.reg;
496   log_io("gpu_read_status %08x\n", ret);
497   return ret;
498 }
499
500 struct GPUFreeze
501 {
502   uint32_t ulFreezeVersion;      // should be always 1 for now (set by main emu)
503   uint32_t ulStatus;             // current gpu status
504   uint32_t ulControl[256];       // latest control register values
505   unsigned char psxVRam[1024*1024*2]; // current VRam image (full 2 MB for ZN)
506 };
507
508 long GPUfreeze(uint32_t type, struct GPUFreeze *freeze)
509 {
510   int i;
511
512   switch (type) {
513     case 1: // save
514       if (gpu.cmd_len > 0)
515         flush_cmd_buffer();
516       memcpy(freeze->psxVRam, gpu.vram, sizeof(gpu.vram));
517       memcpy(freeze->ulControl, gpu.regs, sizeof(gpu.regs));
518       memcpy(freeze->ulControl + 0xe0, gpu.ex_regs, sizeof(gpu.ex_regs));
519       freeze->ulStatus = gpu.status.reg;
520       break;
521     case 0: // load
522       renderer_invalidate_caches(0, 0, 1024, 512);
523       memcpy(gpu.vram, freeze->psxVRam, sizeof(gpu.vram));
524       memcpy(gpu.regs, freeze->ulControl, sizeof(gpu.regs));
525       memcpy(gpu.ex_regs, freeze->ulControl + 0xe0, sizeof(gpu.ex_regs));
526       gpu.status.reg = freeze->ulStatus;
527       for (i = 8; i > 0; i--) {
528         gpu.regs[i] ^= 1; // avoid reg change detection
529         GPUwriteStatus((i << 24) | (gpu.regs[i] ^ 1));
530       }
531       renderer_sync_ecmds(gpu.ex_regs);
532       break;
533   }
534
535   return 1;
536 }
537
538 void GPUupdateLace(void)
539 {
540   if (gpu.cmd_len > 0)
541     flush_cmd_buffer();
542   renderer_flush_queues();
543
544   if (gpu.status.blanking || !gpu.state.fb_dirty)
545     return;
546
547   if (gpu.frameskip.set) {
548     if (!gpu.frameskip.frame_ready) {
549       if (*gpu.state.frame_count - gpu.frameskip.last_flip_frame < 9)
550         return;
551       gpu.frameskip.active = 0;
552     }
553     gpu.frameskip.frame_ready = 0;
554   }
555
556   vout_update();
557   gpu.state.fb_dirty = 0;
558 }
559
560 void GPUvBlank(int is_vblank, int lcf)
561 {
562   int interlace = gpu.state.allow_interlace
563     && gpu.status.interlace && gpu.status.dheight;
564   // interlace doesn't look nice on progressive displays,
565   // so we have this "auto" mode here for games that don't read vram
566   if (gpu.state.allow_interlace == 2
567       && *gpu.state.frame_count - gpu.state.last_vram_read_frame > 1)
568   {
569     interlace = 0;
570   }
571   if (interlace || interlace != gpu.state.old_interlace) {
572     gpu.state.old_interlace = interlace;
573
574     if (gpu.cmd_len > 0)
575       flush_cmd_buffer();
576     renderer_flush_queues();
577     renderer_set_interlace(interlace, !lcf);
578   }
579 }
580
581 #include "../../frontend/plugin_lib.h"
582
583 void GPUrearmedCallbacks(const struct rearmed_cbs *cbs)
584 {
585   gpu.frameskip.set = cbs->frameskip;
586   gpu.frameskip.advice = &cbs->fskip_advice;
587   gpu.frameskip.active = 0;
588   gpu.frameskip.frame_ready = 1;
589   gpu.state.hcnt = cbs->gpu_hcnt;
590   gpu.state.frame_count = cbs->gpu_frame_count;
591   gpu.state.allow_interlace = cbs->gpu_neon.allow_interlace;
592
593   if (cbs->pl_vout_set_raw_vram)
594     cbs->pl_vout_set_raw_vram(gpu.vram);
595   renderer_set_config(cbs);
596   vout_set_config(cbs);
597 }
598
599 // vim:shiftwidth=2:expandtab