Adds auto frameskip based on free audio buffer space
[pcsx_rearmed.git] / plugins / gpulib / gpu.c
1 /*
2  * (C) GraÅžvydas "notaz" Ignotas, 2011-2012
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 <stdlib.h> /* for calloc */
14
15 #include "gpu.h"
16
17 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
18 #ifdef __GNUC__
19 #define unlikely(x) __builtin_expect((x), 0)
20 #define preload __builtin_prefetch
21 #define noinline __attribute__((noinline))
22 #else
23 #define unlikely(x)
24 #define preload(...)
25 #define noinline
26 #endif
27
28 #define gpu_log(fmt, ...) \
29   printf("%d:%03d: " fmt, *gpu.state.frame_count, *gpu.state.hcnt, ##__VA_ARGS__)
30
31 //#define log_io gpu_log
32 #define log_io(...)
33 //#define log_anomaly gpu_log
34 #define log_anomaly(...)
35
36 struct psx_gpu gpu;
37
38 static noinline int do_cmd_buffer(uint32_t *data, int count);
39 static void finish_vram_transfer(int is_read);
40
41 static noinline void do_cmd_reset(void)
42 {
43   renderer_sync();
44
45   if (unlikely(gpu.cmd_len > 0))
46     do_cmd_buffer(gpu.cmd_buffer, gpu.cmd_len);
47   gpu.cmd_len = 0;
48
49   if (unlikely(gpu.dma.h > 0))
50     finish_vram_transfer(gpu.dma_start.is_read);
51   gpu.dma.h = 0;
52 }
53
54 static noinline void do_reset(void)
55 {
56   unsigned int i;
57   do_cmd_reset();
58
59   memset(gpu.regs, 0, sizeof(gpu.regs));
60   for (i = 0; i < sizeof(gpu.ex_regs) / sizeof(gpu.ex_regs[0]); i++)
61     gpu.ex_regs[i] = (0xe0 + i) << 24;
62   gpu.status.reg = 0x14802000;
63   gpu.gp0 = 0;
64   gpu.regs[3] = 1;
65   gpu.screen.hres = gpu.screen.w = 256;
66   gpu.screen.vres = gpu.screen.h = 240;
67 }
68
69 static noinline void update_width(void)
70 {
71   int sw = gpu.screen.x2 - gpu.screen.x1;
72   if (sw <= 0 || sw >= 2560)
73     // full width
74     gpu.screen.w = gpu.screen.hres;
75   else
76     gpu.screen.w = sw * gpu.screen.hres / 2560;
77 }
78
79 static noinline void update_height(void)
80 {
81   // TODO: emulate this properly..
82   int sh = gpu.screen.y2 - gpu.screen.y1;
83   if (gpu.status.dheight)
84     sh *= 2;
85   if (sh <= 0 || sh > gpu.screen.vres)
86     sh = gpu.screen.vres;
87
88   gpu.screen.h = sh;
89 }
90
91 static noinline void decide_frameskip(void)
92 {
93   *gpu.frameskip.dirty = 1;
94
95   if (gpu.frameskip.active)
96     gpu.frameskip.cnt++;
97   else {
98     gpu.frameskip.cnt = 0;
99     gpu.frameskip.frame_ready = 1;
100   }
101
102   if (*gpu.frameskip.force)
103     gpu.frameskip.active = 1;
104   else if (!gpu.frameskip.active && *gpu.frameskip.advice)
105     gpu.frameskip.active = 1;
106   else if (gpu.frameskip.set > 0 && gpu.frameskip.cnt < gpu.frameskip.set)
107     gpu.frameskip.active = 1;
108   else
109     gpu.frameskip.active = 0;
110
111   if (!gpu.frameskip.active && gpu.frameskip.pending_fill[0] != 0) {
112     int dummy;
113     do_cmd_list(gpu.frameskip.pending_fill, 3, &dummy);
114     gpu.frameskip.pending_fill[0] = 0;
115   }
116 }
117
118 static noinline int decide_frameskip_allow(uint32_t cmd_e3)
119 {
120   // no frameskip if it decides to draw to display area,
121   // but not for interlace since it'll most likely always do that
122   uint32_t x = cmd_e3 & 0x3ff;
123   uint32_t y = (cmd_e3 >> 10) & 0x3ff;
124   gpu.frameskip.allow = gpu.status.interlace ||
125     (uint32_t)(x - gpu.screen.x) >= (uint32_t)gpu.screen.w ||
126     (uint32_t)(y - gpu.screen.y) >= (uint32_t)gpu.screen.h;
127   return gpu.frameskip.allow;
128 }
129
130 static noinline void get_gpu_info(uint32_t data)
131 {
132   switch (data & 0x0f) {
133     case 0x02:
134     case 0x03:
135     case 0x04:
136       gpu.gp0 = gpu.ex_regs[data & 7] & 0xfffff;
137       break;
138     case 0x05:
139     case 0x06:
140       gpu.gp0 = gpu.ex_regs[5] & 0x3fffff;
141       break;
142     case 0x07:
143       gpu.gp0 = 2;
144       break;
145     default:
146       gpu.gp0 = 0;
147       break;
148   }
149 }
150
151 // double, for overdraw guard
152 #define VRAM_SIZE ((1024 * 512 * 2 * 2) + 4096)
153
154 //  Minimum 16-byte VRAM alignment needed by gpu_unai's pixel-skipping
155 //  renderer/downscaler it uses in high res modes:
156 #ifdef GCW_ZERO
157         // On GCW platform (MIPS), align to 8192 bytes (1 TLB entry) to reduce # of
158         // fills. (Will change this value if it ever gets large page support)
159         #define VRAM_ALIGN 8192
160 #else
161         #define VRAM_ALIGN 16
162 #endif
163
164 // vram ptr received from mmap/malloc/alloc (will deallocate using this)
165 static uint16_t *vram_ptr_orig = NULL;
166
167 #ifdef GPULIB_USE_MMAP
168 static int map_vram(void)
169 {
170   gpu.vram = vram_ptr_orig = gpu.mmap(VRAM_SIZE + (VRAM_ALIGN-1));
171   if (gpu.vram != NULL) {
172         // 4kb guard in front
173     gpu.vram += (4096 / 2);
174         // Align
175         gpu.vram = (uint16_t*)(((uintptr_t)gpu.vram + (VRAM_ALIGN-1)) & ~(VRAM_ALIGN-1));
176     return 0;
177   }
178   else {
179     fprintf(stderr, "could not map vram, expect crashes\n");
180     return -1;
181   }
182 }
183 #else
184 static int map_vram(void)
185 {
186   gpu.vram = vram_ptr_orig = (uint16_t*)calloc(VRAM_SIZE + (VRAM_ALIGN-1), 1);
187   if (gpu.vram != NULL) {
188         // 4kb guard in front
189     gpu.vram += (4096 / 2);
190         // Align
191         gpu.vram = (uint16_t*)(((uintptr_t)gpu.vram + (VRAM_ALIGN-1)) & ~(VRAM_ALIGN-1));
192     return 0;
193   } else {
194     fprintf(stderr, "could not allocate vram, expect crashes\n");
195     return -1;
196   }
197 }
198
199 static int allocate_vram(void)
200 {
201   gpu.vram = vram_ptr_orig = (uint16_t*)calloc(VRAM_SIZE + (VRAM_ALIGN-1), 1);
202   if (gpu.vram != NULL) {
203         // 4kb guard in front
204     gpu.vram += (4096 / 2);
205         // Align
206         gpu.vram = (uint16_t*)(((uintptr_t)gpu.vram + (VRAM_ALIGN-1)) & ~(VRAM_ALIGN-1));
207     return 0;
208   } else {
209     fprintf(stderr, "could not allocate vram, expect crashes\n");
210     return -1;
211   }
212 }
213 #endif
214
215 long GPUinit(void)
216 {
217 #ifndef GPULIB_USE_MMAP
218   if (gpu.vram == NULL) {
219     if (allocate_vram() != 0) {
220       printf("ERROR: could not allocate VRAM, exiting..\n");
221           exit(1);
222         }
223   }
224 #endif
225
226   //extern uint32_t hSyncCount;         // in psxcounters.cpp
227   //extern uint32_t frame_counter;      // in psxcounters.cpp
228   //gpu.state.hcnt = &hSyncCount;
229   //gpu.state.frame_count = &frame_counter;
230
231   int ret;
232   ret  = vout_init();
233   ret |= renderer_init();
234
235   gpu.state.frame_count = &gpu.zero;
236   gpu.state.hcnt = &gpu.zero;
237   gpu.frameskip.active = 0;
238   gpu.cmd_len = 0;
239   do_reset();
240
241   /*if (gpu.mmap != NULL) {
242     if (map_vram() != 0)
243       ret = -1;
244   }*/
245   return ret;
246 }
247
248 long GPUshutdown(void)
249 {
250   long ret;
251
252   renderer_finish();
253   ret = vout_finish();
254
255   if (vram_ptr_orig != NULL) {
256 #ifdef GPULIB_USE_MMAP
257     gpu.munmap(vram_ptr_orig, VRAM_SIZE);
258 #else
259     free(vram_ptr_orig);
260 #endif
261   }
262   vram_ptr_orig = gpu.vram = NULL;
263
264   return ret;
265 }
266
267 void GPUwriteStatus(uint32_t data)
268 {
269         //senquack TODO: Would it be wise to add cmd buffer flush here, since
270         // status settings can affect commands already in buffer?
271
272   static const short hres[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
273   static const short vres[4] = { 240, 480, 256, 480 };
274   uint32_t cmd = data >> 24;
275
276   if (cmd < ARRAY_SIZE(gpu.regs)) {
277     if (cmd > 1 && cmd != 5 && gpu.regs[cmd] == data)
278       return;
279     gpu.regs[cmd] = data;
280   }
281
282   gpu.state.fb_dirty = 1;
283
284   switch (cmd) {
285     case 0x00:
286       do_reset();
287       break;
288     case 0x01:
289       do_cmd_reset();
290       break;
291     case 0x03:
292       gpu.status.blanking = data & 1;
293       break;
294     case 0x04:
295       gpu.status.dma = data & 3;
296       break;
297     case 0x05:
298       gpu.screen.x = data & 0x3ff;
299       gpu.screen.y = (data >> 10) & 0x1ff;
300       if (gpu.frameskip.set) {
301         decide_frameskip_allow(gpu.ex_regs[3]);
302         if (gpu.frameskip.last_flip_frame != *gpu.state.frame_count) {
303           decide_frameskip();
304           gpu.frameskip.last_flip_frame = *gpu.state.frame_count;
305         }
306       }
307       break;
308     case 0x06:
309       gpu.screen.x1 = data & 0xfff;
310       gpu.screen.x2 = (data >> 12) & 0xfff;
311       update_width();
312       break;
313     case 0x07:
314       gpu.screen.y1 = data & 0x3ff;
315       gpu.screen.y2 = (data >> 10) & 0x3ff;
316       update_height();
317       break;
318     case 0x08:
319       gpu.status.reg = (gpu.status.reg & ~0x7f0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
320       gpu.screen.hres = hres[(gpu.status.reg >> 16) & 7];
321       gpu.screen.vres = vres[(gpu.status.reg >> 19) & 3];
322       update_width();
323       update_height();
324       renderer_notify_res_change();
325       break;
326     default:
327       if ((cmd & 0xf0) == 0x10)
328         get_gpu_info(data);
329       break;
330   }
331
332 #ifdef GPUwriteStatus_ext
333   GPUwriteStatus_ext(data);
334 #endif
335 }
336
337 const unsigned char cmd_lengths[256] =
338 {
339         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
340         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
341         3, 3, 3, 3, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8, 8, 8, // 20
342         5, 5, 5, 5, 8, 8, 8, 8, 7, 7, 7, 7, 11, 11, 11, 11,
343         2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, // 40
344         3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
345         2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 1, 0, 0, 0, 0, // 60
346         1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2,
347         3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 80
348         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
349         2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // a0
350         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
351         2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // c0
352         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
353         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // e0
354         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
355 };
356
357 #define VRAM_MEM_XY(x, y) &gpu.vram[(y) * 1024 + (x)]
358
359 static inline void do_vram_line(int x, int y, uint16_t *mem, int l, int is_read)
360 {
361   uint16_t *vram = VRAM_MEM_XY(x, y);
362   if (is_read)
363     memcpy(mem, vram, l * 2);
364   else
365     memcpy(vram, mem, l * 2);
366 }
367
368 static int do_vram_io(uint32_t *data, int count, int is_read)
369 {
370   int count_initial = count;
371   uint16_t *sdata = (uint16_t *)data;
372   int x = gpu.dma.x, y = gpu.dma.y;
373   int w = gpu.dma.w, h = gpu.dma.h;
374   int o = gpu.dma.offset;
375   int l;
376   count *= 2; // operate in 16bpp pixels
377
378   renderer_sync();
379
380   if (gpu.dma.offset) {
381     l = w - gpu.dma.offset;
382     if (count < l)
383       l = count;
384
385     do_vram_line(x + o, y, sdata, l, is_read);
386
387     if (o + l < w)
388       o += l;
389     else {
390       o = 0;
391       y++;
392       h--;
393     }
394     sdata += l;
395     count -= l;
396   }
397
398   for (; h > 0 && count >= w; sdata += w, count -= w, y++, h--) {
399     y &= 511;
400     do_vram_line(x, y, sdata, w, is_read);
401   }
402
403   if (h > 0) {
404     if (count > 0) {
405       y &= 511;
406       do_vram_line(x, y, sdata, count, is_read);
407       o = count;
408       count = 0;
409     }
410   }
411   else
412     finish_vram_transfer(is_read);
413   gpu.dma.y = y;
414   gpu.dma.h = h;
415   gpu.dma.offset = o;
416
417   return count_initial - count / 2;
418 }
419
420 static void start_vram_transfer(uint32_t pos_word, uint32_t size_word, int is_read)
421 {
422   if (gpu.dma.h)
423     log_anomaly("start_vram_transfer while old unfinished\n");
424
425   gpu.dma.x = pos_word & 0x3ff;
426   gpu.dma.y = (pos_word >> 16) & 0x1ff;
427   gpu.dma.w = ((size_word - 1) & 0x3ff) + 1;
428   gpu.dma.h = (((size_word >> 16) - 1) & 0x1ff) + 1;
429   gpu.dma.offset = 0;
430   gpu.dma.is_read = is_read;
431   gpu.dma_start = gpu.dma;
432
433   renderer_flush_queues();
434   if (is_read) {
435     gpu.status.img = 1;
436     // XXX: wrong for width 1
437     memcpy(&gpu.gp0, VRAM_MEM_XY(gpu.dma.x, gpu.dma.y), 4);
438     gpu.state.last_vram_read_frame = *gpu.state.frame_count;
439   }
440
441   log_io("start_vram_transfer %c (%d, %d) %dx%d\n", is_read ? 'r' : 'w',
442     gpu.dma.x, gpu.dma.y, gpu.dma.w, gpu.dma.h);
443 }
444
445 static void finish_vram_transfer(int is_read)
446 {
447   if (is_read)
448     gpu.status.img = 0;
449   else
450     renderer_update_caches(gpu.dma_start.x, gpu.dma_start.y,
451                            gpu.dma_start.w, gpu.dma_start.h);
452 }
453
454 static noinline int do_cmd_list_skip(uint32_t *data, int count, int *last_cmd)
455 {
456   int cmd = 0, pos = 0, len, dummy, v;
457   int skip = 1;
458
459   gpu.frameskip.pending_fill[0] = 0;
460
461   while (pos < count && skip) {
462     uint32_t *list = data + pos;
463     cmd = list[0] >> 24;
464     len = 1 + cmd_lengths[cmd];
465
466     switch (cmd) {
467       case 0x02:
468         if ((int)(list[2] & 0x3ff) > gpu.screen.w || (int)((list[2] >> 16) & 0x1ff) > gpu.screen.h)
469           // clearing something large, don't skip
470           do_cmd_list(list, 3, &dummy);
471         else
472           memcpy(gpu.frameskip.pending_fill, list, 3 * 4);
473         break;
474       case 0x24 ... 0x27:
475       case 0x2c ... 0x2f:
476       case 0x34 ... 0x37:
477       case 0x3c ... 0x3f:
478         gpu.ex_regs[1] &= ~0x1ff;
479         gpu.ex_regs[1] |= list[4 + ((cmd >> 4) & 1)] & 0x1ff;
480         break;
481       case 0x48 ... 0x4F:
482         for (v = 3; pos + v < count; v++)
483         {
484           if ((list[v] & 0xf000f000) == 0x50005000)
485             break;
486         }
487         len += v - 3;
488         break;
489       case 0x58 ... 0x5F:
490         for (v = 4; pos + v < count; v += 2)
491         {
492           if ((list[v] & 0xf000f000) == 0x50005000)
493             break;
494         }
495         len += v - 4;
496         break;
497       default:
498         if (cmd == 0xe3)
499           skip = decide_frameskip_allow(list[0]);
500         if ((cmd & 0xf8) == 0xe0)
501           gpu.ex_regs[cmd & 7] = list[0];
502         break;
503     }
504
505     if (pos + len > count) {
506       cmd = -1;
507       break; // incomplete cmd
508     }
509     if (0xa0 <= cmd && cmd <= 0xdf)
510       break; // image i/o
511
512     pos += len;
513   }
514
515   renderer_sync_ecmds(gpu.ex_regs);
516   *last_cmd = cmd;
517   return pos;
518 }
519
520 static noinline int do_cmd_buffer(uint32_t *data, int count)
521 {
522   int cmd, pos;
523   uint32_t old_e3 = gpu.ex_regs[3];
524   int vram_dirty = 0;
525
526   // process buffer
527   for (pos = 0; pos < count; )
528   {
529     if (gpu.dma.h && !gpu.dma_start.is_read) { // XXX: need to verify
530       vram_dirty = 1;
531       pos += do_vram_io(data + pos, count - pos, 0);
532       if (pos == count)
533         break;
534     }
535
536     cmd = data[pos] >> 24;
537     if (0xa0 <= cmd && cmd <= 0xdf) {
538       if (unlikely((pos+2) >= count)) {
539         // incomplete vram write/read cmd, can't consume yet
540         cmd = -1;
541         break;
542       }
543
544       // consume vram write/read cmd
545       start_vram_transfer(data[pos + 1], data[pos + 2], (cmd & 0xe0) == 0xc0);
546       pos += 3;
547       continue;
548     }
549
550     // 0xex cmds might affect frameskip.allow, so pass to do_cmd_list_skip
551     if (gpu.frameskip.active && (gpu.frameskip.allow || ((data[pos] >> 24) & 0xf0) == 0xe0))
552       pos += do_cmd_list_skip(data + pos, count - pos, &cmd);
553     else {
554       pos += do_cmd_list(data + pos, count - pos, &cmd);
555       vram_dirty = 1;
556     }
557
558     if (cmd == -1)
559       // incomplete cmd
560       break;
561   }
562
563   gpu.status.reg &= ~0x1fff;
564   gpu.status.reg |= gpu.ex_regs[1] & 0x7ff;
565   gpu.status.reg |= (gpu.ex_regs[6] & 3) << 11;
566
567   gpu.state.fb_dirty |= vram_dirty;
568
569   if (old_e3 != gpu.ex_regs[3])
570     decide_frameskip_allow(gpu.ex_regs[3]);
571
572   return count - pos;
573 }
574
575 static void flush_cmd_buffer(void)
576 {
577   int left = do_cmd_buffer(gpu.cmd_buffer, gpu.cmd_len);
578   if (left > 0)
579     memmove(gpu.cmd_buffer, gpu.cmd_buffer + gpu.cmd_len - left, left * 4);
580   gpu.cmd_len = left;
581 }
582
583 void GPUwriteDataMem(uint32_t *mem, int count)
584 {
585   int left;
586
587   log_io("gpu_dma_write %p %d\n", mem, count);
588
589   if (unlikely(gpu.cmd_len > 0))
590     flush_cmd_buffer();
591
592   left = do_cmd_buffer(mem, count);
593   if (left)
594     log_anomaly("GPUwriteDataMem: discarded %d/%d words\n", left, count);
595 }
596
597 void GPUwriteData(uint32_t data)
598 {
599   log_io("gpu_write %08x\n", data);
600   gpu.cmd_buffer[gpu.cmd_len++] = data;
601   if (gpu.cmd_len >= CMD_BUFFER_LEN)
602     flush_cmd_buffer();
603 }
604
605 long GPUdmaChain(uint32_t *rambase, uint32_t start_addr)
606 {
607   uint32_t addr, *list, ld_addr = 0;
608   int len, left, count;
609   long cpu_cycles = 0;
610
611   preload(rambase + (start_addr & 0x1fffff) / 4);
612
613   if (unlikely(gpu.cmd_len > 0))
614     flush_cmd_buffer();
615
616   log_io("gpu_dma_chain\n");
617   addr = start_addr & 0xffffff;
618   for (count = 0; (addr & 0x800000) == 0; count++)
619   {
620     list = rambase + (addr & 0x1fffff) / 4;
621     len = list[0] >> 24;
622     addr = list[0] & 0xffffff;
623     preload(rambase + (addr & 0x1fffff) / 4);
624
625     cpu_cycles += 10;
626     if (len > 0)
627       cpu_cycles += 5 + len;
628
629     log_io(".chain %08x #%d\n", (list - rambase) * 4, len);
630
631     if (len) {
632       left = do_cmd_buffer(list + 1, len);
633       if (left)
634         log_anomaly("GPUdmaChain: discarded %d/%d words\n", left, len);
635     }
636
637     #define LD_THRESHOLD (8*1024)
638     if (count >= LD_THRESHOLD) {
639       if (count == LD_THRESHOLD) {
640         ld_addr = addr;
641         continue;
642       }
643
644       // loop detection marker
645       // (bit23 set causes DMA error on real machine, so
646       //  unlikely to be ever set by the game)
647       list[0] |= 0x800000;
648     }
649   }
650
651   if (ld_addr != 0) {
652     // remove loop detection markers
653     count -= LD_THRESHOLD + 2;
654     addr = ld_addr & 0x1fffff;
655     while (count-- > 0) {
656       list = rambase + addr / 4;
657       addr = list[0] & 0x1fffff;
658       list[0] &= ~0x800000;
659     }
660   }
661
662   gpu.state.last_list.frame = *gpu.state.frame_count;
663   gpu.state.last_list.hcnt = *gpu.state.hcnt;
664   gpu.state.last_list.cycles = cpu_cycles;
665   gpu.state.last_list.addr = start_addr;
666
667   return cpu_cycles;
668 }
669
670 void GPUreadDataMem(uint32_t *mem, int count)
671 {
672   log_io("gpu_dma_read  %p %d\n", mem, count);
673
674   if (unlikely(gpu.cmd_len > 0))
675     flush_cmd_buffer();
676
677   if (gpu.dma.h)
678     do_vram_io(mem, count, 1);
679 }
680
681 uint32_t GPUreadData(void)
682 {
683   uint32_t ret;
684
685   if (unlikely(gpu.cmd_len > 0))
686     flush_cmd_buffer();
687
688   ret = gpu.gp0;
689   if (gpu.dma.h)
690     do_vram_io(&ret, 1, 1);
691
692   log_io("gpu_read %08x\n", ret);
693   return ret;
694 }
695
696 uint32_t GPUreadStatus(void)
697 {
698   uint32_t ret;
699
700   if (unlikely(gpu.cmd_len > 0))
701     flush_cmd_buffer();
702
703   ret = gpu.status.reg;
704   log_io("gpu_read_status %08x\n", ret);
705   return ret;
706 }
707
708 struct GPUFreeze
709 {
710   uint32_t ulFreezeVersion;      // should be always 1 for now (set by main emu)
711   uint32_t ulStatus;             // current gpu status
712   uint32_t ulControl[256];       // latest control register values
713   unsigned char psxVRam[1024*1024*2]; // current VRam image (full 2 MB for ZN)
714 };
715
716 long GPUfreeze(uint32_t type, struct GPUFreeze *freeze)
717 {
718   int i;
719
720   switch (type) {
721     case 1: // save
722       if (gpu.cmd_len > 0)
723         flush_cmd_buffer();
724
725       renderer_sync();
726       memcpy(freeze->psxVRam, gpu.vram, 1024 * 512 * 2);
727       memcpy(freeze->ulControl, gpu.regs, sizeof(gpu.regs));
728       memcpy(freeze->ulControl + 0xe0, gpu.ex_regs, sizeof(gpu.ex_regs));
729       freeze->ulStatus = gpu.status.reg;
730       break;
731     case 0: // load
732       renderer_sync();
733       memcpy(gpu.vram, freeze->psxVRam, 1024 * 512 * 2);
734       memcpy(gpu.regs, freeze->ulControl, sizeof(gpu.regs));
735       memcpy(gpu.ex_regs, freeze->ulControl + 0xe0, sizeof(gpu.ex_regs));
736       gpu.status.reg = freeze->ulStatus;
737       gpu.cmd_len = 0;
738       for (i = 8; i > 0; i--) {
739         gpu.regs[i] ^= 1; // avoid reg change detection
740         GPUwriteStatus((i << 24) | (gpu.regs[i] ^ 1));
741       }
742       renderer_sync_ecmds(gpu.ex_regs);
743       renderer_update_caches(0, 0, 1024, 512);
744       break;
745   }
746
747   return 1;
748 }
749
750 void GPUupdateLace(void)
751 {
752   if (gpu.cmd_len > 0)
753     flush_cmd_buffer();
754   renderer_flush_queues();
755
756   if (gpu.status.blanking) {
757     if (!gpu.state.blanked) {
758       vout_blank();
759       gpu.state.blanked = 1;
760       gpu.state.fb_dirty = 1;
761     }
762     return;
763   }
764
765   renderer_notify_update_lace(0);
766
767   if (!gpu.state.fb_dirty)
768     return;
769
770   if (gpu.frameskip.set) {
771     if (!gpu.frameskip.frame_ready) {
772       if (*gpu.state.frame_count - gpu.frameskip.last_flip_frame < 9)
773         return;
774       gpu.frameskip.active = 0;
775     }
776     gpu.frameskip.frame_ready = 0;
777   }
778
779   vout_update();
780   gpu.state.fb_dirty = 0;
781   gpu.state.blanked = 0;
782   renderer_notify_update_lace(1);
783 }
784
785 void GPUvBlank(int is_vblank, int lcf)
786 {
787   int interlace = gpu.state.allow_interlace
788     && gpu.status.interlace && gpu.status.dheight;
789   // interlace doesn't look nice on progressive displays,
790   // so we have this "auto" mode here for games that don't read vram
791   if (gpu.state.allow_interlace == 2
792       && *gpu.state.frame_count - gpu.state.last_vram_read_frame > 1)
793   {
794     interlace = 0;
795   }
796   if (interlace || interlace != gpu.state.old_interlace) {
797     gpu.state.old_interlace = interlace;
798
799     if (gpu.cmd_len > 0)
800       flush_cmd_buffer();
801     renderer_flush_queues();
802     renderer_set_interlace(interlace, !lcf);
803   }
804 }
805
806 #include "../../frontend/plugin_lib.h"
807
808 void GPUrearmedCallbacks(const struct rearmed_cbs *cbs)
809 {
810   gpu.frameskip.set = cbs->frameskip;
811   gpu.frameskip.advice = &cbs->fskip_advice;
812   gpu.frameskip.force = &cbs->fskip_force;
813   gpu.frameskip.dirty = &cbs->fskip_dirty;
814   gpu.frameskip.active = 0;
815   gpu.frameskip.frame_ready = 1;
816   gpu.state.hcnt = cbs->gpu_hcnt;
817   gpu.state.frame_count = cbs->gpu_frame_count;
818   gpu.state.allow_interlace = cbs->gpu_neon.allow_interlace;
819   gpu.state.enhancement_enable = cbs->gpu_neon.enhancement_enable;
820
821   gpu.useDithering = cbs->gpu_neon.allow_dithering;
822   gpu.mmap = cbs->mmap;
823   gpu.munmap = cbs->munmap;
824
825   // delayed vram mmap
826   if (gpu.vram == NULL)
827     map_vram();
828
829   if (cbs->pl_vout_set_raw_vram)
830     cbs->pl_vout_set_raw_vram(gpu.vram);
831   renderer_set_config(cbs);
832   vout_set_config(cbs);
833 }
834
835 // vim:shiftwidth=2:expandtab