c7807f66ecd459f7de32f076e07dfce6299df48a
[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 log_io printf
20 #define log_io(...)
21 #define log_anomaly printf
22
23 struct psx_gpu gpu __attribute__((aligned(64)));
24
25 static noinline void do_reset(void)
26 {
27   memset(gpu.regs, 0, sizeof(gpu.regs));
28   gpu.status.reg = 0x14802000;
29   gpu.gp0 = 0;
30   gpu.regs[3] = 1;
31   gpu.screen.hres = gpu.screen.w = 256;
32   gpu.screen.vres = gpu.screen.h = 240;
33 }
34
35 static noinline void update_width(void)
36 {
37   int sw = gpu.screen.x2 - gpu.screen.x1;
38   if (sw <= 0 || sw >= 2560)
39     // full width
40     gpu.screen.w = gpu.screen.hres;
41   else
42     gpu.screen.w = sw * gpu.screen.hres / 2560;
43 }
44
45 static noinline void update_height(void)
46 {
47   int sh = gpu.screen.y2 - gpu.screen.y1;
48   if (gpu.status.dheight)
49     sh *= 2;
50   if (sh <= 0)
51     sh = gpu.screen.vres;
52
53   gpu.screen.h = sh;
54 }
55
56 static noinline void decide_frameskip(void)
57 {
58   gpu.frameskip.frame_ready = !gpu.frameskip.active;
59
60   if (!gpu.frameskip.active && *gpu.frameskip.advice)
61     gpu.frameskip.active = 1;
62   else
63     gpu.frameskip.active = 0;
64 }
65
66 static noinline void get_gpu_info(uint32_t data)
67 {
68   switch (data & 0x0f) {
69     case 0x02:
70     case 0x03:
71     case 0x04:
72     case 0x05:
73       gpu.gp0 = gpu.ex_regs[data & 7] & 0xfffff;
74       break;
75     case 0x06:
76       gpu.gp0 = gpu.ex_regs[5] & 0xfffff;
77       break;
78     case 0x07:
79       gpu.gp0 = 2;
80       break;
81     default:
82       gpu.gp0 = 0;
83       break;
84   }
85 }
86
87 long GPUinit(void)
88 {
89   int ret = vout_init();
90   do_reset();
91   gpu.lcf_hc = &gpu.zero;
92   return ret;
93 }
94
95 long GPUshutdown(void)
96 {
97   return vout_finish();
98 }
99
100 void GPUwriteStatus(uint32_t data)
101 {
102   static const short hres[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
103   static const short vres[4] = { 240, 480, 256, 480 };
104   uint32_t cmd = data >> 24;
105
106   if (cmd < ARRAY_SIZE(gpu.regs)) {
107     if (cmd != 0 && gpu.regs[cmd] == data)
108       return;
109     gpu.regs[cmd] = data;
110   }
111
112   gpu.state.fb_dirty = 1;
113
114   switch (cmd) {
115     case 0x00:
116       do_reset();
117       break;
118     case 0x03:
119       gpu.status.blanking = data & 1;
120       break;
121     case 0x04:
122       gpu.status.dma = data & 3;
123       break;
124     case 0x05:
125       gpu.screen.x = data & 0x3ff;
126       gpu.screen.y = (data >> 10) & 0x3ff;
127       if (gpu.frameskip.enabled)
128         decide_frameskip();
129       break;
130     case 0x06:
131       gpu.screen.x1 = data & 0xfff;
132       gpu.screen.x2 = (data >> 12) & 0xfff;
133       update_width();
134       break;
135     case 0x07:
136       gpu.screen.y1 = data & 0x3ff;
137       gpu.screen.y2 = (data >> 10) & 0x3ff;
138       update_height();
139       break;
140     case 0x08:
141       gpu.status.reg = (gpu.status.reg & ~0x7f0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
142       gpu.screen.hres = hres[(gpu.status.reg >> 16) & 7];
143       gpu.screen.vres = vres[(gpu.status.reg >> 19) & 3];
144       update_width();
145       update_height();
146       break;
147     case 0x10 ... 0x1f:
148       get_gpu_info(data);
149       break;
150   }
151 }
152
153 const unsigned char cmd_lengths[256] =
154 {
155         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
156         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
157         3, 3, 3, 3, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8, 8, 8, // 20
158         5, 5, 5, 5, 8, 8, 8, 8, 7, 7, 7, 7, 11, 11, 11, 11,
159         2, 2, 2, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, // 40
160         3, 3, 3, 3, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4,
161         2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 1, 2, 2, 2, 2, // 60
162         1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2,
163         3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 80
164         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
165         2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // a0
166         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
167         2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // c0
168         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
169         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // e0
170         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
171 };
172
173 #define VRAM_MEM_XY(x, y) &gpu.vram[(y) * 1024 + (x)]
174
175 static inline void do_vram_line(int x, int y, uint16_t *mem, int l, int is_read)
176 {
177   uint16_t *vram = VRAM_MEM_XY(x, y);
178   if (is_read)
179     memcpy(mem, vram, l * 2);
180   else
181     memcpy(vram, mem, l * 2);
182 }
183
184 static int do_vram_io(uint32_t *data, int count, int is_read)
185 {
186   int count_initial = count;
187   uint16_t *sdata = (uint16_t *)data;
188   int x = gpu.dma.x, y = gpu.dma.y;
189   int w = gpu.dma.w, h = gpu.dma.h;
190   int o = gpu.dma.offset;
191   int l;
192   count *= 2; // operate in 16bpp pixels
193
194   if (gpu.dma.offset) {
195     l = w - gpu.dma.offset;
196     if (count < l)
197       l = count;
198
199     do_vram_line(x + o, y, sdata, l, is_read);
200
201     if (o + l < w)
202       o += l;
203     else {
204       o = 0;
205       y++;
206       h--;
207     }
208     sdata += l;
209     count -= l;
210   }
211
212   for (; h > 0 && count >= w; sdata += w, count -= w, y++, h--) {
213     y &= 511;
214     do_vram_line(x, y, sdata, w, is_read);
215   }
216
217   if (h > 0 && count > 0) {
218     y &= 511;
219     do_vram_line(x, y, sdata, count, is_read);
220     o = count;
221     count = 0;
222   }
223   gpu.dma.y = y;
224   gpu.dma.h = h;
225   gpu.dma.offset = o;
226
227   return count_initial - count / 2;
228 }
229
230 static void start_vram_transfer(uint32_t pos_word, uint32_t size_word, int is_read)
231 {
232   if (gpu.dma.h)
233     log_anomaly("start_vram_transfer while old unfinished\n");
234
235   gpu.dma.x = pos_word & 1023;
236   gpu.dma.y = (pos_word >> 16) & 511;
237   gpu.dma.w = size_word & 0xffff; // ?
238   gpu.dma.h = size_word >> 16;
239   gpu.dma.offset = 0;
240
241   if (is_read)
242     gpu.status.img = 1;
243
244   log_io("start_vram_transfer %c (%d, %d) %dx%d\n", is_read ? 'r' : 'w',
245     gpu.dma.x, gpu.dma.y, gpu.dma.w, gpu.dma.h);
246 }
247
248 static int check_cmd(uint32_t *data, int count)
249 {
250   int len, cmd, start, pos;
251   int vram_dirty = 0;
252
253   // process buffer
254   for (start = pos = 0; pos < count; )
255   {
256     cmd = -1;
257     len = 0;
258
259     if (gpu.dma.h) {
260       pos += do_vram_io(data + pos, count - pos, 0);
261       if (pos == count)
262         break;
263       start = pos;
264     }
265
266     // do look-ahead pass to detect SR changes and VRAM i/o
267     while (pos < count) {
268       uint32_t *list = data + pos;
269       cmd = list[0] >> 24;
270       len = 1 + cmd_lengths[cmd];
271
272       //printf("  %3d: %02x %d\n", pos, cmd, len);
273       if ((cmd & 0xf4) == 0x24) {
274         // flat textured prim
275         gpu.status.reg &= ~0x1ff;
276         gpu.status.reg |= list[4] & 0x1ff;
277       }
278       else if ((cmd & 0xf4) == 0x34) {
279         // shaded textured prim
280         gpu.status.reg &= ~0x1ff;
281         gpu.status.reg |= list[5] & 0x1ff;
282       }
283       else switch (cmd)
284       {
285         case 0xe1:
286           gpu.status.reg &= ~0x7ff;
287           gpu.status.reg |= list[0] & 0x7ff;
288           break;
289         case 0xe6:
290           gpu.status.reg &= ~0x1800;
291           gpu.status.reg |= (list[0] & 3) << 11;
292           break;
293       }
294       if (2 <= cmd && cmd < 0xc0)
295         vram_dirty = 1;
296       else if ((cmd & 0xf8) == 0xe0)
297         gpu.ex_regs[cmd & 7] = list[0];
298
299       if (pos + len > count) {
300         cmd = -1;
301         break; // incomplete cmd
302       }
303       if (cmd == 0xa0 || cmd == 0xc0)
304         break; // image i/o
305       pos += len;
306     }
307
308     if (pos - start > 0) {
309       if (!gpu.frameskip.active)
310         do_cmd_list(data + start, pos - start);
311       start = pos;
312     }
313
314     if (cmd == 0xa0 || cmd == 0xc0) {
315       // consume vram write/read cmd
316       start_vram_transfer(data[pos + 1], data[pos + 2], cmd == 0xc0);
317       pos += len;
318     }
319
320     if (cmd == -1)
321       break;
322   }
323
324   gpu.state.fb_dirty |= vram_dirty;
325
326   return count - pos;
327 }
328
329 static void flush_cmd_buffer(void)
330 {
331   int left = check_cmd(gpu.cmd_buffer, gpu.cmd_len);
332   if (left > 0)
333     memmove(gpu.cmd_buffer, gpu.cmd_buffer + gpu.cmd_len - left, left * 4);
334   gpu.cmd_len = left;
335 }
336
337 void GPUwriteDataMem(uint32_t *mem, int count)
338 {
339   int left;
340
341   log_io("gpu_dma_write %p %d\n", mem, count);
342
343   if (unlikely(gpu.cmd_len > 0))
344     flush_cmd_buffer();
345
346   left = check_cmd(mem, count);
347   if (left)
348     log_anomaly("GPUwriteDataMem: discarded %d/%d words\n", left, count);
349 }
350
351 void GPUwriteData(uint32_t data)
352 {
353   log_io("gpu_write %08x\n", data);
354   gpu.cmd_buffer[gpu.cmd_len++] = data;
355   if (gpu.cmd_len >= CMD_BUFFER_LEN)
356     flush_cmd_buffer();
357 }
358
359 long GPUdmaChain(uint32_t *rambase, uint32_t start_addr)
360 {
361   uint32_t addr, *list;
362   int len, left, count;
363
364   if (unlikely(gpu.cmd_len > 0))
365     flush_cmd_buffer();
366
367   log_io("gpu_dma_chain\n");
368   addr = start_addr & 0xffffff;
369   for (count = 0; addr != 0xffffff; count++)
370   {
371     log_io(".chain %08x\n", addr);
372
373     list = rambase + (addr & 0x1fffff) / 4;
374     len = list[0] >> 24;
375     addr = list[0] & 0xffffff;
376
377     // loop detection marker
378     // (bit23 set causes DMA error on real machine, so
379     //  unlikely to be ever set by the game)
380     list[0] |= 0x800000;
381
382     if (len) {
383       left = check_cmd(list + 1, len);
384       if (left)
385         log_anomaly("GPUwriteDataMem: discarded %d/%d words\n", left, len);
386     }
387
388     if (addr & 0x800000)
389       break;
390   }
391
392   // remove loop detection markers
393   addr = start_addr & 0x1fffff;
394   while (count-- > 0) {
395     list = rambase + addr / 4;
396     addr = list[0] & 0x1fffff;
397     list[0] &= ~0x800000;
398   }
399
400   return 0;
401 }
402
403 void GPUreadDataMem(uint32_t *mem, int count)
404 {
405   log_io("gpu_dma_read  %p %d\n", mem, count);
406
407   if (unlikely(gpu.cmd_len > 0))
408     flush_cmd_buffer();
409
410   if (gpu.dma.h)
411     do_vram_io(mem, count, 1);
412 }
413
414 uint32_t GPUreadData(void)
415 {
416   log_io("gpu_read\n");
417
418   if (unlikely(gpu.cmd_len > 0))
419     flush_cmd_buffer();
420
421   if (gpu.dma.h)
422     do_vram_io(&gpu.gp0, 1, 1);
423
424   return gpu.gp0;
425 }
426
427 uint32_t GPUreadStatus(void)
428 {
429   uint32_t ret;
430
431   if (unlikely(gpu.cmd_len > 0))
432     flush_cmd_buffer();
433
434   ret = gpu.status.reg | (*gpu.lcf_hc << 31);
435   log_io("gpu_read_status %08x\n", ret);
436   return ret;
437 }
438
439 typedef struct GPUFREEZETAG
440 {
441   uint32_t ulFreezeVersion;      // should be always 1 for now (set by main emu)
442   uint32_t ulStatus;             // current gpu status
443   uint32_t ulControl[256];       // latest control register values
444   unsigned char psxVRam[1024*1024*2]; // current VRam image (full 2 MB for ZN)
445 } GPUFreeze_t;
446
447 long GPUfreeze(uint32_t type, GPUFreeze_t *freeze)
448 {
449   int i;
450
451   switch (type) {
452     case 1: // save
453       if (gpu.cmd_len > 0)
454         flush_cmd_buffer();
455       memcpy(freeze->psxVRam, gpu.vram, sizeof(gpu.vram));
456       memcpy(freeze->ulControl, gpu.regs, sizeof(gpu.regs));
457       memcpy(freeze->ulControl + 0xe0, gpu.ex_regs, sizeof(gpu.ex_regs));
458       freeze->ulStatus = gpu.status.reg;
459       break;
460     case 0: // load
461       memcpy(gpu.vram, freeze->psxVRam, sizeof(gpu.vram));
462       memcpy(gpu.regs, freeze->ulControl, sizeof(gpu.regs));
463       memcpy(gpu.ex_regs, freeze->ulControl + 0xe0, sizeof(gpu.ex_regs));
464       gpu.status.reg = freeze->ulStatus;
465       for (i = 8; i > 0; i--) {
466         gpu.regs[i] ^= 1; // avoid reg change detection
467         GPUwriteStatus((i << 24) | (gpu.regs[i] ^ 1));
468       }
469       break;
470   }
471
472   return 1;
473 }
474
475 void GPUvBlank(int val, uint32_t *hcnt)
476 {
477   gpu.lcf_hc = &gpu.zero;
478   if (gpu.status.interlace) {
479     if (val)
480       gpu.status.lcf ^= 1;
481   }
482   else {
483     gpu.status.lcf = 0;
484     if (!val)
485       gpu.lcf_hc = hcnt;
486   }
487 }
488
489 // vim:shiftwidth=2:expandtab