standalone: make unaccelerated fullscreen work
[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 <stdlib.h>
13 #include <string.h>
14 #include <stdlib.h> /* for calloc */
15
16 #include "gpu.h"
17 #include "gpu_timing.h"
18 #include "../../libpcsxcore/gpu.h" // meh
19 #include "../../frontend/plugin_lib.h"
20
21 #ifndef ARRAY_SIZE
22 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
23 #endif
24 #ifdef __GNUC__
25 #define unlikely(x) __builtin_expect((x), 0)
26 #define preload __builtin_prefetch
27 #define noinline __attribute__((noinline))
28 #else
29 #define unlikely(x)
30 #define preload(...)
31 #define noinline
32 #endif
33
34 //#define log_io gpu_log
35 #define log_io(...)
36
37 struct psx_gpu gpu;
38
39 static noinline int do_cmd_buffer(uint32_t *data, int count,
40     int *cycles_sum, int *cycles_last);
41 static void finish_vram_transfer(int is_read);
42
43 static noinline void do_cmd_reset(void)
44 {
45   int dummy = 0;
46   renderer_sync();
47   if (unlikely(gpu.cmd_len > 0))
48     do_cmd_buffer(gpu.cmd_buffer, gpu.cmd_len, &dummy, &dummy);
49   gpu.cmd_len = 0;
50
51   if (unlikely(gpu.dma.h > 0))
52     finish_vram_transfer(gpu.dma_start.is_read);
53   gpu.dma.h = 0;
54 }
55
56 static noinline void do_reset(void)
57 {
58   unsigned int i;
59
60   do_cmd_reset();
61
62   memset(gpu.regs, 0, sizeof(gpu.regs));
63   for (i = 0; i < sizeof(gpu.ex_regs) / sizeof(gpu.ex_regs[0]); i++)
64     gpu.ex_regs[i] = (0xe0 + i) << 24;
65   gpu.status = 0x14802000;
66   gpu.gp0 = 0;
67   gpu.regs[3] = 1;
68   gpu.screen.hres = gpu.screen.w = 256;
69   gpu.screen.vres = gpu.screen.h = 240;
70   gpu.screen.x = gpu.screen.y = 0;
71   renderer_sync_ecmds(gpu.ex_regs);
72   renderer_notify_res_change();
73 }
74
75 static noinline void update_width(void)
76 {
77   static const short hres_all[8] = { 256, 368, 320, 368, 512, 368, 640, 368 };
78   static const uint8_t hdivs[8] = { 10, 7, 8, 7, 5, 7, 4, 7 };
79   uint8_t hdiv = hdivs[(gpu.status >> 16) & 7];
80   int hres = hres_all[(gpu.status >> 16) & 7];
81   int pal = gpu.status & PSX_GPU_STATUS_PAL;
82   int sw = gpu.screen.x2 - gpu.screen.x1;
83   int type = gpu.state.screen_centering_type;
84   int x = 0, x_auto;
85   if (type == C_AUTO)
86     type = gpu.state.screen_centering_type_default;
87   if (sw <= 0)
88     /* nothing displayed? */;
89   else {
90     int s = pal ? 656 : 608; // or 600? pal is just a guess
91     x = (gpu.screen.x1 - s) / hdiv;
92     x = (x + 1) & ~1;   // blitter limitation
93     sw /= hdiv;
94     sw = (sw + 2) & ~3; // according to nocash
95     switch (type) {
96     case C_INGAME:
97       break;
98     case C_MANUAL:
99       x = gpu.state.screen_centering_x;
100       break;
101     default:
102       // correct if slightly miscentered
103       x_auto = (hres - sw) / 2 & ~3;
104       if ((uint32_t)x_auto <= 8u && abs(x) < 24)
105         x = x_auto;
106     }
107     if (x + sw > hres)
108       sw = hres - x;
109     // .x range check is done in vout_update()
110   }
111   // reduce the unpleasant right border that a few games have
112   if (gpu.state.screen_centering_type == 0
113       && x <= 4 && hres - (x + sw) >= 4)
114     hres -= 4;
115   gpu.screen.x = x;
116   gpu.screen.w = sw;
117   gpu.screen.hres = hres;
118   gpu.state.dims_changed = 1;
119   //printf("xx %d %d -> %2d, %d / %d\n",
120   //  gpu.screen.x1, gpu.screen.x2, x, sw, hres);
121 }
122
123 static noinline void update_height(void)
124 {
125   int pal = gpu.status & PSX_GPU_STATUS_PAL;
126   int dheight = gpu.status & PSX_GPU_STATUS_DHEIGHT;
127   int y = gpu.screen.y1 - (pal ? 39 : 16); // 39 for spyro
128   int sh = gpu.screen.y2 - gpu.screen.y1;
129   int center_tol = 16;
130   int vres = 240;
131
132   if (pal && (sh > 240 || gpu.screen.vres == 256))
133     vres = 256;
134   if (dheight)
135     y *= 2, sh *= 2, vres *= 2, center_tol *= 2;
136   if (sh <= 0)
137     /* nothing displayed? */;
138   else {
139     switch (gpu.state.screen_centering_type) {
140     case C_INGAME:
141       break;
142     case C_BORDERLESS:
143       y = 0;
144       break;
145     case C_MANUAL:
146       y = gpu.state.screen_centering_y;
147       break;
148     default:
149       // correct if slightly miscentered
150       if ((uint32_t)(vres - sh) <= 1 && abs(y) <= center_tol)
151         y = 0;
152     }
153     if (y + sh > vres)
154       sh = vres - y;
155   }
156   gpu.screen.y = y;
157   gpu.screen.h = sh;
158   gpu.screen.vres = vres;
159   gpu.state.dims_changed = 1;
160   //printf("yy %d %d -> %d, %d / %d\n",
161   //  gpu.screen.y1, gpu.screen.y2, y, sh, vres);
162 }
163
164 static noinline void decide_frameskip(void)
165 {
166   *gpu.frameskip.dirty = 1;
167
168   if (gpu.frameskip.active)
169     gpu.frameskip.cnt++;
170   else {
171     gpu.frameskip.cnt = 0;
172     gpu.frameskip.frame_ready = 1;
173   }
174
175   if (*gpu.frameskip.force)
176     gpu.frameskip.active = 1;
177   else if (!gpu.frameskip.active && *gpu.frameskip.advice)
178     gpu.frameskip.active = 1;
179   else if (gpu.frameskip.set > 0 && gpu.frameskip.cnt < gpu.frameskip.set)
180     gpu.frameskip.active = 1;
181   else
182     gpu.frameskip.active = 0;
183
184   if (!gpu.frameskip.active && gpu.frameskip.pending_fill[0] != 0) {
185     int dummy = 0;
186     do_cmd_list(gpu.frameskip.pending_fill, 3, &dummy, &dummy, &dummy);
187     gpu.frameskip.pending_fill[0] = 0;
188   }
189 }
190
191 static noinline int decide_frameskip_allow(uint32_t cmd_e3)
192 {
193   // no frameskip if it decides to draw to display area,
194   // but not for interlace since it'll most likely always do that
195   uint32_t x = cmd_e3 & 0x3ff;
196   uint32_t y = (cmd_e3 >> 10) & 0x3ff;
197   gpu.frameskip.allow = (gpu.status & PSX_GPU_STATUS_INTERLACE) ||
198     (uint32_t)(x - gpu.screen.src_x) >= (uint32_t)gpu.screen.w ||
199     (uint32_t)(y - gpu.screen.src_y) >= (uint32_t)gpu.screen.h;
200   return gpu.frameskip.allow;
201 }
202
203 static void flush_cmd_buffer(void);
204
205 static noinline void get_gpu_info(uint32_t data)
206 {
207   if (unlikely(gpu.cmd_len > 0))
208     flush_cmd_buffer();
209   switch (data & 0x0f) {
210     case 0x02:
211     case 0x03:
212     case 0x04:
213       gpu.gp0 = gpu.ex_regs[data & 7] & 0xfffff;
214       break;
215     case 0x05:
216       gpu.gp0 = gpu.ex_regs[5] & 0x3fffff;
217       break;
218     case 0x07:
219       gpu.gp0 = 2;
220       break;
221     default:
222       // gpu.gp0 unchanged
223       break;
224   }
225 }
226
227 #ifndef max
228 #define max(a, b) (((a) > (b)) ? (a) : (b))
229 #endif
230
231 //  Minimum 16-byte VRAM alignment needed by gpu_unai's pixel-skipping
232 //  renderer/downscaler it uses in high res modes:
233 #ifdef GCW_ZERO
234         // On GCW platform (MIPS), align to 8192 bytes (1 TLB entry) to reduce # of
235         // fills. (Will change this value if it ever gets large page support)
236         #define VRAM_ALIGN 8192
237 #else
238         #define VRAM_ALIGN 16
239 #endif
240
241 // double, for overdraw guard + at least 1 page before
242 #define VRAM_SIZE ((1024 * 512 * 2 * 2) + max(VRAM_ALIGN, 4096))
243
244 // vram ptr received from mmap/malloc/alloc (will deallocate using this)
245 static uint16_t *vram_ptr_orig = NULL;
246
247 #ifndef GPULIB_USE_MMAP
248 # ifdef __linux__
249 #  define GPULIB_USE_MMAP 1
250 # else
251 #  define GPULIB_USE_MMAP 0
252 # endif
253 #endif
254 static int map_vram(void)
255 {
256 #if GPULIB_USE_MMAP
257   gpu.vram = vram_ptr_orig = gpu.mmap(VRAM_SIZE);
258 #else
259   gpu.vram = vram_ptr_orig = calloc(VRAM_SIZE, 1);
260 #endif
261   if (gpu.vram != NULL && gpu.vram != (void *)(intptr_t)-1) {
262     // 4kb guard in front
263     gpu.vram += (4096 / 2);
264     // Align
265     gpu.vram = (uint16_t*)(((uintptr_t)gpu.vram + (VRAM_ALIGN-1)) & ~(VRAM_ALIGN-1));
266     return 0;
267   }
268   else {
269     fprintf(stderr, "could not map vram, expect crashes\n");
270     return -1;
271   }
272 }
273
274 long GPUinit(void)
275 {
276   int ret;
277   ret  = vout_init();
278   ret |= renderer_init();
279
280   memset(&gpu.state, 0, sizeof(gpu.state));
281   memset(&gpu.frameskip, 0, sizeof(gpu.frameskip));
282   gpu.zero = 0;
283   gpu.state.frame_count = &gpu.zero;
284   gpu.state.hcnt = &gpu.zero;
285   gpu.cmd_len = 0;
286   do_reset();
287
288   /*if (gpu.mmap != NULL) {
289     if (map_vram() != 0)
290       ret = -1;
291   }*/
292   return ret;
293 }
294
295 long GPUshutdown(void)
296 {
297   long ret;
298
299   renderer_finish();
300   ret = vout_finish();
301
302   if (vram_ptr_orig != NULL) {
303 #if GPULIB_USE_MMAP
304     gpu.munmap(vram_ptr_orig, VRAM_SIZE);
305 #else
306     free(vram_ptr_orig);
307 #endif
308   }
309   vram_ptr_orig = gpu.vram = NULL;
310
311   return ret;
312 }
313
314 void GPUwriteStatus(uint32_t data)
315 {
316   uint32_t cmd = data >> 24;
317   int src_x, src_y;
318
319   if (cmd < ARRAY_SIZE(gpu.regs)) {
320     if (cmd > 1 && cmd != 5 && gpu.regs[cmd] == data)
321       return;
322     gpu.regs[cmd] = data;
323   }
324
325   gpu.state.fb_dirty = 1;
326
327   switch (cmd) {
328     case 0x00:
329       do_reset();
330       break;
331     case 0x01:
332       do_cmd_reset();
333       break;
334     case 0x03:
335       if (data & 1) {
336         gpu.status |= PSX_GPU_STATUS_BLANKING;
337         gpu.state.dims_changed = 1; // for hud clearing
338       }
339       else
340         gpu.status &= ~PSX_GPU_STATUS_BLANKING;
341       break;
342     case 0x04:
343       gpu.status &= ~PSX_GPU_STATUS_DMA_MASK;
344       gpu.status |= PSX_GPU_STATUS_DMA(data & 3);
345       break;
346     case 0x05:
347       src_x = data & 0x3ff; src_y = (data >> 10) & 0x1ff;
348       if (src_x != gpu.screen.src_x || src_y != gpu.screen.src_y) {
349         gpu.screen.src_x = src_x;
350         gpu.screen.src_y = src_y;
351         renderer_notify_scanout_change(src_x, src_y);
352         if (gpu.frameskip.set) {
353           decide_frameskip_allow(gpu.ex_regs[3]);
354           if (gpu.frameskip.last_flip_frame != *gpu.state.frame_count) {
355             decide_frameskip();
356             gpu.frameskip.last_flip_frame = *gpu.state.frame_count;
357           }
358         }
359       }
360       break;
361     case 0x06:
362       gpu.screen.x1 = data & 0xfff;
363       gpu.screen.x2 = (data >> 12) & 0xfff;
364       update_width();
365       break;
366     case 0x07:
367       gpu.screen.y1 = data & 0x3ff;
368       gpu.screen.y2 = (data >> 10) & 0x3ff;
369       update_height();
370       break;
371     case 0x08:
372       gpu.status = (gpu.status & ~0x7f0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
373       update_width();
374       update_height();
375       renderer_notify_res_change();
376       break;
377     default:
378       if ((cmd & 0xf0) == 0x10)
379         get_gpu_info(data);
380       break;
381   }
382
383 #ifdef GPUwriteStatus_ext
384   GPUwriteStatus_ext(data);
385 #endif
386 }
387
388 const unsigned char cmd_lengths[256] =
389 {
390         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
391         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
392         3, 3, 3, 3, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8, 8, 8, // 20
393         5, 5, 5, 5, 8, 8, 8, 8, 7, 7, 7, 7, 11, 11, 11, 11,
394         2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, // 40
395         3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
396         2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 1, 0, 0, 0, 0, // 60
397         1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2,
398         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 80
399         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
400         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // a0
401         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
402         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // c0
403         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
404         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // e0
405         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
406 };
407
408 #define VRAM_MEM_XY(x, y) &gpu.vram[(y) * 1024 + (x)]
409
410 static void cpy_msb(uint16_t *dst, const uint16_t *src, int l, uint16_t msb)
411 {
412   int i;
413   for (i = 0; i < l; i++)
414     dst[i] = src[i] | msb;
415 }
416
417 static inline void do_vram_line(int x, int y, uint16_t *mem, int l,
418     int is_read, uint16_t msb)
419 {
420   uint16_t *vram = VRAM_MEM_XY(x, y);
421   if (unlikely(is_read))
422     memcpy(mem, vram, l * 2);
423   else if (unlikely(msb))
424     cpy_msb(vram, mem, l, msb);
425   else
426     memcpy(vram, mem, l * 2);
427 }
428
429 static int do_vram_io(uint32_t *data, int count, int is_read)
430 {
431   int count_initial = count;
432   uint16_t msb = gpu.ex_regs[6] << 15;
433   uint16_t *sdata = (uint16_t *)data;
434   int x = gpu.dma.x, y = gpu.dma.y;
435   int w = gpu.dma.w, h = gpu.dma.h;
436   int o = gpu.dma.offset;
437   int l;
438   count *= 2; // operate in 16bpp pixels
439
440   renderer_sync();
441
442   if (gpu.dma.offset) {
443     l = w - gpu.dma.offset;
444     if (count < l)
445       l = count;
446
447     do_vram_line(x + o, y, sdata, l, is_read, msb);
448
449     if (o + l < w)
450       o += l;
451     else {
452       o = 0;
453       y++;
454       h--;
455     }
456     sdata += l;
457     count -= l;
458   }
459
460   for (; h > 0 && count >= w; sdata += w, count -= w, y++, h--) {
461     y &= 511;
462     do_vram_line(x, y, sdata, w, is_read, msb);
463   }
464
465   if (h > 0) {
466     if (count > 0) {
467       y &= 511;
468       do_vram_line(x, y, sdata, count, is_read, msb);
469       o = count;
470       count = 0;
471     }
472   }
473   else
474     finish_vram_transfer(is_read);
475   gpu.dma.y = y;
476   gpu.dma.h = h;
477   gpu.dma.offset = o;
478
479   return count_initial - count / 2;
480 }
481
482 static void start_vram_transfer(uint32_t pos_word, uint32_t size_word, int is_read)
483 {
484   if (gpu.dma.h)
485     log_anomaly("start_vram_transfer while old unfinished\n");
486
487   gpu.dma.x = pos_word & 0x3ff;
488   gpu.dma.y = (pos_word >> 16) & 0x1ff;
489   gpu.dma.w = ((size_word - 1) & 0x3ff) + 1;
490   gpu.dma.h = (((size_word >> 16) - 1) & 0x1ff) + 1;
491   gpu.dma.offset = 0;
492   gpu.dma.is_read = is_read;
493   gpu.dma_start = gpu.dma;
494
495   renderer_flush_queues();
496   if (is_read) {
497     gpu.status |= PSX_GPU_STATUS_IMG;
498     // XXX: wrong for width 1
499     gpu.gp0 = LE32TOH(*(uint32_t *) VRAM_MEM_XY(gpu.dma.x, gpu.dma.y));
500     gpu.state.last_vram_read_frame = *gpu.state.frame_count;
501   }
502
503   log_io("start_vram_transfer %c (%d, %d) %dx%d\n", is_read ? 'r' : 'w',
504     gpu.dma.x, gpu.dma.y, gpu.dma.w, gpu.dma.h);
505   if (gpu.gpu_state_change)
506     gpu.gpu_state_change(PGS_VRAM_TRANSFER_START);
507 }
508
509 static void finish_vram_transfer(int is_read)
510 {
511   if (is_read)
512     gpu.status &= ~PSX_GPU_STATUS_IMG;
513   else {
514     gpu.state.fb_dirty = 1;
515     renderer_update_caches(gpu.dma_start.x, gpu.dma_start.y,
516                            gpu.dma_start.w, gpu.dma_start.h, 0);
517   }
518   if (gpu.gpu_state_change)
519     gpu.gpu_state_change(PGS_VRAM_TRANSFER_END);
520 }
521
522 static void do_vram_copy(const uint32_t *params, int *cpu_cycles)
523 {
524   const uint32_t sx =  LE32TOH(params[0]) & 0x3FF;
525   const uint32_t sy = (LE32TOH(params[0]) >> 16) & 0x1FF;
526   const uint32_t dx =  LE32TOH(params[1]) & 0x3FF;
527   const uint32_t dy = (LE32TOH(params[1]) >> 16) & 0x1FF;
528   uint32_t w =  ((LE32TOH(params[2]) - 1) & 0x3FF) + 1;
529   uint32_t h = (((LE32TOH(params[2]) >> 16) - 1) & 0x1FF) + 1;
530   uint16_t msb = gpu.ex_regs[6] << 15;
531   uint16_t lbuf[128];
532   uint32_t x, y;
533
534   *cpu_cycles += gput_copy(w, h);
535   if (sx == dx && sy == dy && msb == 0)
536     return;
537
538   renderer_flush_queues();
539
540   if (unlikely((sx < dx && dx < sx + w) || sx + w > 1024 || dx + w > 1024 || msb))
541   {
542     for (y = 0; y < h; y++)
543     {
544       const uint16_t *src = VRAM_MEM_XY(0, (sy + y) & 0x1ff);
545       uint16_t *dst = VRAM_MEM_XY(0, (dy + y) & 0x1ff);
546       for (x = 0; x < w; x += ARRAY_SIZE(lbuf))
547       {
548         uint32_t x1, w1 = w - x;
549         if (w1 > ARRAY_SIZE(lbuf))
550           w1 = ARRAY_SIZE(lbuf);
551         for (x1 = 0; x1 < w1; x1++)
552           lbuf[x1] = src[(sx + x + x1) & 0x3ff];
553         for (x1 = 0; x1 < w1; x1++)
554           dst[(dx + x + x1) & 0x3ff] = lbuf[x1] | msb;
555       }
556     }
557   }
558   else
559   {
560     uint32_t sy1 = sy, dy1 = dy;
561     for (y = 0; y < h; y++, sy1++, dy1++)
562       memcpy(VRAM_MEM_XY(dx, dy1 & 0x1ff), VRAM_MEM_XY(sx, sy1 & 0x1ff), w * 2);
563   }
564
565   renderer_update_caches(dx, dy, w, h, 0);
566 }
567
568 static noinline int do_cmd_list_skip(uint32_t *data, int count, int *last_cmd)
569 {
570   int cmd = 0, pos = 0, len, dummy = 0, v;
571   int skip = 1;
572
573   gpu.frameskip.pending_fill[0] = 0;
574
575   while (pos < count && skip) {
576     uint32_t *list = data + pos;
577     cmd = LE32TOH(list[0]) >> 24;
578     len = 1 + cmd_lengths[cmd];
579
580     switch (cmd) {
581       case 0x02:
582         if ((LE32TOH(list[2]) & 0x3ff) > gpu.screen.w || ((LE32TOH(list[2]) >> 16) & 0x1ff) > gpu.screen.h)
583           // clearing something large, don't skip
584           do_cmd_list(list, 3, &dummy, &dummy, &dummy);
585         else
586           memcpy(gpu.frameskip.pending_fill, list, 3 * 4);
587         break;
588       case 0x24 ... 0x27:
589       case 0x2c ... 0x2f:
590       case 0x34 ... 0x37:
591       case 0x3c ... 0x3f:
592         gpu.ex_regs[1] &= ~0x1ff;
593         gpu.ex_regs[1] |= LE32TOH(list[4 + ((cmd >> 4) & 1)]) & 0x1ff;
594         break;
595       case 0x48 ... 0x4F:
596         for (v = 3; pos + v < count; v++)
597         {
598           if ((list[v] & HTOLE32(0xf000f000)) == HTOLE32(0x50005000))
599             break;
600         }
601         len += v - 3;
602         break;
603       case 0x58 ... 0x5F:
604         for (v = 4; pos + v < count; v += 2)
605         {
606           if ((list[v] & HTOLE32(0xf000f000)) == HTOLE32(0x50005000))
607             break;
608         }
609         len += v - 4;
610         break;
611       default:
612         if (cmd == 0xe3)
613           skip = decide_frameskip_allow(LE32TOH(list[0]));
614         if ((cmd & 0xf8) == 0xe0)
615           gpu.ex_regs[cmd & 7] = LE32TOH(list[0]);
616         break;
617     }
618
619     if (pos + len > count) {
620       cmd = -1;
621       break; // incomplete cmd
622     }
623     if (0x80 <= cmd && cmd <= 0xdf)
624       break; // image i/o
625
626     pos += len;
627   }
628
629   renderer_sync_ecmds(gpu.ex_regs);
630   *last_cmd = cmd;
631   return pos;
632 }
633
634 static noinline int do_cmd_buffer(uint32_t *data, int count,
635     int *cycles_sum, int *cycles_last)
636 {
637   int cmd, pos;
638   uint32_t old_e3 = gpu.ex_regs[3];
639   int vram_dirty = 0;
640
641   // process buffer
642   for (pos = 0; pos < count; )
643   {
644     if (gpu.dma.h && !gpu.dma_start.is_read) { // XXX: need to verify
645       vram_dirty = 1;
646       pos += do_vram_io(data + pos, count - pos, 0);
647       if (pos == count)
648         break;
649     }
650
651     cmd = LE32TOH(data[pos]) >> 24;
652     if (0xa0 <= cmd && cmd <= 0xdf) {
653       if (unlikely((pos+2) >= count)) {
654         // incomplete vram write/read cmd, can't consume yet
655         cmd = -1;
656         break;
657       }
658
659       // consume vram write/read cmd
660       start_vram_transfer(LE32TOH(data[pos + 1]), LE32TOH(data[pos + 2]), (cmd & 0xe0) == 0xc0);
661       pos += 3;
662       continue;
663     }
664     else if ((cmd & 0xe0) == 0x80) {
665       if (unlikely((pos+3) >= count)) {
666         cmd = -1; // incomplete cmd, can't consume yet
667         break;
668       }
669       renderer_sync();
670       *cycles_sum += *cycles_last;
671       *cycles_last = 0;
672       do_vram_copy(data + pos + 1, cycles_last);
673       vram_dirty = 1;
674       pos += 4;
675       continue;
676     }
677     else if (cmd == 0x1f) {
678       log_anomaly("irq1?\n");
679       pos++;
680       continue;
681     }
682
683     // 0xex cmds might affect frameskip.allow, so pass to do_cmd_list_skip
684     if (gpu.frameskip.active && (gpu.frameskip.allow || ((LE32TOH(data[pos]) >> 24) & 0xf0) == 0xe0))
685       pos += do_cmd_list_skip(data + pos, count - pos, &cmd);
686     else {
687       pos += do_cmd_list(data + pos, count - pos, cycles_sum, cycles_last, &cmd);
688       vram_dirty = 1;
689     }
690
691     if (cmd == -1)
692       // incomplete cmd
693       break;
694   }
695
696   gpu.status &= ~0x1fff;
697   gpu.status |= gpu.ex_regs[1] & 0x7ff;
698   gpu.status |= (gpu.ex_regs[6] & 3) << 11;
699
700   gpu.state.fb_dirty |= vram_dirty;
701
702   if (old_e3 != gpu.ex_regs[3])
703     decide_frameskip_allow(gpu.ex_regs[3]);
704
705   return count - pos;
706 }
707
708 static noinline void flush_cmd_buffer(void)
709 {
710   int dummy = 0, left;
711   left = do_cmd_buffer(gpu.cmd_buffer, gpu.cmd_len, &dummy, &dummy);
712   if (left > 0)
713     memmove(gpu.cmd_buffer, gpu.cmd_buffer + gpu.cmd_len - left, left * 4);
714   if (left != gpu.cmd_len) {
715     if (!gpu.dma.h && gpu.gpu_state_change)
716       gpu.gpu_state_change(PGS_PRIMITIVE_START);
717     gpu.cmd_len = left;
718   }
719 }
720
721 void GPUwriteDataMem(uint32_t *mem, int count)
722 {
723   int dummy = 0, left;
724
725   log_io("gpu_dma_write %p %d\n", mem, count);
726
727   if (unlikely(gpu.cmd_len > 0))
728     flush_cmd_buffer();
729
730   left = do_cmd_buffer(mem, count, &dummy, &dummy);
731   if (left)
732     log_anomaly("GPUwriteDataMem: discarded %d/%d words\n", left, count);
733 }
734
735 void GPUwriteData(uint32_t data)
736 {
737   log_io("gpu_write %08x\n", data);
738   gpu.cmd_buffer[gpu.cmd_len++] = HTOLE32(data);
739   if (gpu.cmd_len >= CMD_BUFFER_LEN)
740     flush_cmd_buffer();
741 }
742
743 long GPUdmaChain(uint32_t *rambase, uint32_t start_addr,
744   uint32_t *progress_addr, int32_t *cycles_last_cmd)
745 {
746   uint32_t addr, *list, ld_addr;
747   int len, left, count, ld_count = 32;
748   int cpu_cycles_sum = 0;
749   int cpu_cycles_last = 0;
750
751   preload(rambase + (start_addr & 0x1fffff) / 4);
752
753   if (unlikely(gpu.cmd_len > 0))
754     flush_cmd_buffer();
755
756   log_io("gpu_dma_chain\n");
757   addr = ld_addr = start_addr & 0xffffff;
758   for (count = 0; (addr & 0x800000) == 0; count++)
759   {
760     list = rambase + (addr & 0x1fffff) / 4;
761     len = LE32TOH(list[0]) >> 24;
762     addr = LE32TOH(list[0]) & 0xffffff;
763     preload(rambase + (addr & 0x1fffff) / 4);
764
765     cpu_cycles_sum += 10;
766     if (len > 0)
767       cpu_cycles_sum += 5 + len;
768
769     log_io(".chain %08lx #%d+%d %u+%u\n",
770       (long)(list - rambase) * 4, len, gpu.cmd_len, cpu_cycles_sum, cpu_cycles_last);
771     if (unlikely(gpu.cmd_len > 0)) {
772       if (gpu.cmd_len + len > ARRAY_SIZE(gpu.cmd_buffer)) {
773         log_anomaly("cmd_buffer overflow, likely garbage commands\n");
774         gpu.cmd_len = 0;
775       }
776       memcpy(gpu.cmd_buffer + gpu.cmd_len, list + 1, len * 4);
777       gpu.cmd_len += len;
778       flush_cmd_buffer();
779       continue;
780     }
781
782     if (len) {
783       left = do_cmd_buffer(list + 1, len, &cpu_cycles_sum, &cpu_cycles_last);
784       if (left) {
785         memcpy(gpu.cmd_buffer, list + 1 + len - left, left * 4);
786         gpu.cmd_len = left;
787         log_anomaly("GPUdmaChain: %d/%d words left\n", left, len);
788       }
789     }
790
791     if (progress_addr) {
792       *progress_addr = addr;
793       break;
794     }
795     if (addr == ld_addr) {
796       log_anomaly("GPUdmaChain: loop @ %08x, cnt=%u\n", addr, count);
797       break;
798     }
799     if (count == ld_count) {
800       ld_addr = addr;
801       ld_count *= 2;
802     }
803   }
804
805   //printf(" -> %d %d\n", cpu_cycles_sum, cpu_cycles_last);
806   gpu.state.last_list.frame = *gpu.state.frame_count;
807   gpu.state.last_list.hcnt = *gpu.state.hcnt;
808   gpu.state.last_list.cycles = cpu_cycles_sum + cpu_cycles_last;
809   gpu.state.last_list.addr = start_addr;
810
811   *cycles_last_cmd = cpu_cycles_last;
812   return cpu_cycles_sum;
813 }
814
815 void GPUreadDataMem(uint32_t *mem, int count)
816 {
817   log_io("gpu_dma_read  %p %d\n", mem, count);
818
819   if (unlikely(gpu.cmd_len > 0))
820     flush_cmd_buffer();
821
822   if (gpu.dma.h)
823     do_vram_io(mem, count, 1);
824 }
825
826 uint32_t GPUreadData(void)
827 {
828   uint32_t ret;
829
830   if (unlikely(gpu.cmd_len > 0))
831     flush_cmd_buffer();
832
833   ret = gpu.gp0;
834   if (gpu.dma.h) {
835     ret = HTOLE32(ret);
836     do_vram_io(&ret, 1, 1);
837     ret = LE32TOH(ret);
838   }
839
840   log_io("gpu_read %08x\n", ret);
841   return ret;
842 }
843
844 uint32_t GPUreadStatus(void)
845 {
846   uint32_t ret;
847
848   if (unlikely(gpu.cmd_len > 0))
849     flush_cmd_buffer();
850
851   ret = gpu.status;
852   log_io("gpu_read_status %08x\n", ret);
853   return ret;
854 }
855
856 struct GPUFreeze
857 {
858   uint32_t ulFreezeVersion;      // should be always 1 for now (set by main emu)
859   uint32_t ulStatus;             // current gpu status
860   uint32_t ulControl[256];       // latest control register values
861   unsigned char psxVRam[1024*1024*2]; // current VRam image (full 2 MB for ZN)
862 };
863
864 long GPUfreeze(uint32_t type, struct GPUFreeze *freeze)
865 {
866   int i;
867
868   switch (type) {
869     case 1: // save
870       if (gpu.cmd_len > 0)
871         flush_cmd_buffer();
872
873       renderer_sync();
874       memcpy(freeze->psxVRam, gpu.vram, 1024 * 512 * 2);
875       memcpy(freeze->ulControl, gpu.regs, sizeof(gpu.regs));
876       memcpy(freeze->ulControl + 0xe0, gpu.ex_regs, sizeof(gpu.ex_regs));
877       freeze->ulStatus = gpu.status;
878       break;
879     case 0: // load
880       renderer_sync();
881       memcpy(gpu.vram, freeze->psxVRam, 1024 * 512 * 2);
882       memcpy(gpu.regs, freeze->ulControl, sizeof(gpu.regs));
883       memcpy(gpu.ex_regs, freeze->ulControl + 0xe0, sizeof(gpu.ex_regs));
884       gpu.status = freeze->ulStatus;
885       gpu.cmd_len = 0;
886       for (i = 8; i > 0; i--) {
887         gpu.regs[i] ^= 1; // avoid reg change detection
888         GPUwriteStatus((i << 24) | (gpu.regs[i] ^ 1));
889       }
890       renderer_sync_ecmds(gpu.ex_regs);
891       renderer_update_caches(0, 0, 1024, 512, 0);
892       break;
893   }
894
895   return 1;
896 }
897
898 void GPUupdateLace(void)
899 {
900   if (gpu.cmd_len > 0)
901     flush_cmd_buffer();
902   renderer_flush_queues();
903
904 #ifndef RAW_FB_DISPLAY
905   if (gpu.status & PSX_GPU_STATUS_BLANKING) {
906     if (!gpu.state.blanked) {
907       vout_blank();
908       gpu.state.blanked = 1;
909       gpu.state.fb_dirty = 1;
910     }
911     return;
912   }
913
914   renderer_notify_update_lace(0);
915
916   if (!gpu.state.fb_dirty)
917     return;
918 #endif
919
920   if (gpu.frameskip.set) {
921     if (!gpu.frameskip.frame_ready) {
922       if (*gpu.state.frame_count - gpu.frameskip.last_flip_frame < 9)
923         return;
924       gpu.frameskip.active = 0;
925     }
926     gpu.frameskip.frame_ready = 0;
927   }
928
929   vout_update();
930   if (gpu.state.enhancement_active && !gpu.state.enhancement_was_active)
931     renderer_update_caches(0, 0, 1024, 512, 1);
932   gpu.state.enhancement_was_active = gpu.state.enhancement_active;
933   gpu.state.fb_dirty = 0;
934   gpu.state.blanked = 0;
935   renderer_notify_update_lace(1);
936 }
937
938 void GPUvBlank(int is_vblank, int lcf)
939 {
940   int interlace = gpu.state.allow_interlace
941     && (gpu.status & PSX_GPU_STATUS_INTERLACE)
942     && (gpu.status & PSX_GPU_STATUS_DHEIGHT);
943   // interlace doesn't look nice on progressive displays,
944   // so we have this "auto" mode here for games that don't read vram
945   if (gpu.state.allow_interlace == 2
946       && *gpu.state.frame_count - gpu.state.last_vram_read_frame > 1)
947   {
948     interlace = 0;
949   }
950   if (interlace || interlace != gpu.state.old_interlace) {
951     gpu.state.old_interlace = interlace;
952
953     if (gpu.cmd_len > 0)
954       flush_cmd_buffer();
955     renderer_flush_queues();
956     renderer_set_interlace(interlace, !lcf);
957   }
958 }
959
960 void GPUgetScreenInfo(int *y, int *base_hres)
961 {
962   *y = gpu.screen.y;
963   *base_hres = gpu.screen.vres;
964   if (gpu.status & PSX_GPU_STATUS_DHEIGHT)
965     *base_hres >>= 1;
966 }
967
968 void GPUrearmedCallbacks(const struct rearmed_cbs *cbs)
969 {
970   gpu.frameskip.set = cbs->frameskip;
971   gpu.frameskip.advice = &cbs->fskip_advice;
972   gpu.frameskip.force = &cbs->fskip_force;
973   gpu.frameskip.dirty = (void *)&cbs->fskip_dirty;
974   gpu.frameskip.active = 0;
975   gpu.frameskip.frame_ready = 1;
976   gpu.state.hcnt = cbs->gpu_hcnt;
977   gpu.state.frame_count = cbs->gpu_frame_count;
978   gpu.state.allow_interlace = cbs->gpu_neon.allow_interlace;
979   gpu.state.enhancement_enable = cbs->gpu_neon.enhancement_enable;
980   gpu.state.screen_centering_type_default = cbs->screen_centering_type_default;
981   if (gpu.state.screen_centering_type != cbs->screen_centering_type
982       || gpu.state.screen_centering_x != cbs->screen_centering_x
983       || gpu.state.screen_centering_y != cbs->screen_centering_y) {
984     gpu.state.screen_centering_type = cbs->screen_centering_type;
985     gpu.state.screen_centering_x = cbs->screen_centering_x;
986     gpu.state.screen_centering_y = cbs->screen_centering_y;
987     update_width();
988     update_height();
989   }
990
991   gpu.mmap = cbs->mmap;
992   gpu.munmap = cbs->munmap;
993   gpu.gpu_state_change = cbs->gpu_state_change;
994
995   // delayed vram mmap
996   if (gpu.vram == NULL)
997     map_vram();
998
999   if (cbs->pl_vout_set_raw_vram)
1000     cbs->pl_vout_set_raw_vram(gpu.vram);
1001   renderer_set_config(cbs);
1002   vout_set_config(cbs);
1003 }
1004
1005 // vim:shiftwidth=2:expandtab