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