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