loader/emu.c

   1 // vim:shiftwidth=2:expandtab
   2 // a "gentle" reminder
   3 #ifdef __ARM_EABI__
   4 #error loader is meant to be OABI!
   5 #endif
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <alloca.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <fcntl.h>
  13 #include <sys/mman.h>
  14 #include <sys/types.h>
  15 #include <unistd.h>
  16 #include <signal.h>
  17 #include <asm/ucontext.h>
  18 #include <pthread.h>
  19 #include <errno.h>
  20 #include <time.h>
  21 #include <sys/resource.h>
  22 #include <sys/ioctl.h>
  23 #include <linux/soundcard.h>
  24 #include <linux/fb.h>
  25
  26 #include "header.h"
  27 #include "../common/host_fb.h"
  28 #include "../common/cmn.h"
  29 #include "sys_cacheflush.h"
  30 #include "realfuncs.h"
  31
  32 #if (DBG & 2) && !(DBG & 4)
  33 #define LOG_IO_UNK
  34 #endif
  35 #if (DBG & 4)
  36 #define LOG_IO
  37 #endif
  38 //#define LOG_SEGV
  39
  40 #ifdef LOG_IO
  41 #define iolog log_io
  42 #else
  43 #define iolog(...)
  44 #endif
  45
  46 #ifdef LOG_IO_UNK
  47 #define iolog_unh log_io
  48 #else
  49 #define iolog_unh(...)
  50 #endif
  51
  52 #ifdef LOG_SEGV
  53 #define segvlog printf
  54 #else
  55 #define segvlog(...)
  56 #endif
  57
  58 #if defined(LOG_IO) || defined(LOG_IO_UNK)
  59 #include "mmsp2-regs.h"
  60 #endif
  61
  62 typedef unsigned long long u64;
  63 typedef unsigned int   u32;
  64 typedef unsigned short u16;
  65 typedef unsigned char  u8;
  66
  67 static pthread_mutex_t fb_mutex = PTHREAD_MUTEX_INITIALIZER;
  68 static pthread_cond_t fb_cond = PTHREAD_COND_INITIALIZER;
  69
  70 static struct {
  71   u32 dstctrl;
  72   u32 dstaddr;
  73   u32 dststride;
  74   u32 srcctrl;
  75   u32 srcaddr;          //
  76   u32 srcstride;
  77   u32 srcforcolor;
  78   u32 srcbackcolor;
  79   u32 patctrl;          //
  80   u32 patforcolor;
  81   u32 patbackcolor;
  82   u32 size;
  83   u32 ctrl;             //
  84   u32 run;
  85   u32 intc;
  86   u32 srcfifo;
  87 } blitter;
  88
  89 #define SRCCTRL_INVIDEO         (1 << 8)
  90 #define SRCCTRL_SRCENB          (1 << 7)
  91 #define CTRL_TRANSPARENCYENB    (1 << 11)
  92
  93 static struct {
  94   // mmsp2
  95   u16 mlc_stl_cntl;
  96   union {
  97     u32 mlc_stl_adr; // mlcaddress for pollux
  98     struct {
  99       u16 mlc_stl_adrl;
 100       u16 mlc_stl_adrh;
 101     };
 102   };
 103   u16 mlc_stl_pallt_a;
 104   union {
 105     u16 mlc_stl_pallt_d[256*2];
 106     u32 mlc_stl_pallt_d32[256];
 107   };
 108
 109   // pollux
 110   u32 mlccontrol;
 111   u16 mlcpalette[256];
 112
 113   // state
 114   void *umem;
 115   u32 old_mlc_stl_adr;
 116   u32 btn_state; // as seen through /dev/GPIO: 0PVdVu YXBA RLSeSt 0Ri0Dn 0Le0Up
 117   struct {
 118     u32 width, height;
 119     u32 stride;
 120     u32 bpp;
 121     u32 dirty_pal:2;
 122   } v;
 123 } mmsp2;
 124 #define pollux mmsp2 // so that code doesn't look that weird
 125 enum {
 126   DIRTY_PAL_MMSP2 = 1,
 127   DIRTY_PAL_POLLUX = 2,
 128 };
 129
 130
 131 #if defined(LOG_IO) || defined(LOG_IO_UNK)
 132 static void log_io(const char *pfx, u32 a, u32 d, int size)
 133 {
 134   const char *fmt, *reg = "";
 135   switch (size) {
 136   case  8: fmt = "%s %08x       %02x %s\n"; d &= 0xff; break;
 137   case 32: fmt = "%s %08x %08x %s\n";       break;
 138   default: fmt = "%s %08x     %04x %s\n";   d &= 0xffff; break;
 139   }
 140
 141   if ((a & ~0xffff) == 0x7f000000)
 142     reg = regnames[a & 0xffff];
 143
 144   printf(fmt, pfx, a, d, reg);
 145 }
 146 #endif
 147
 148 static void memset16(void *dst, u32 pattern, int count)
 149 {
 150   u32 *dl;
 151   u16 *d;
 152
 153   d = (u16 *)((long)dst & ~1);
 154   if ((long)d & 2) {
 155     *d++ = pattern;
 156     count--;
 157   }
 158   dl = (void *)d;
 159   pattern |= pattern << 16;
 160
 161   while (count >= 2) {
 162     *dl++ = pattern;
 163     count -= 2;
 164   }
 165   if (count)
 166     *(u16 *)dl = pattern;
 167 }
 168
 169 static void blt_tr(void *dst, void *src, u32 trc, int w)
 170 {
 171   u16 *d = (u16 *)((long)dst & ~1);
 172   u16 *s = (u16 *)((long)src & ~1);
 173
 174   // XXX: optimize
 175   for (; w > 0; d++, s++, w--)
 176     if (*s != trc)
 177       *d = *s;
 178 }
 179
 180 #define dump_blitter() \
 181 { \
 182   u32 *r = &blitter.dstctrl; \
 183   int i; \
 184   for (i = 0; i < 4*4; i++, r++) { \
 185     printf("%08x ", *r); \
 186     if ((i & 3) == 3) \
 187       printf("\n"); \
 188   } \
 189 }
 190
 191 static void *uppermem_lookup(u32 addr, u8 **mem_end)
 192 {
 193   // XXX: maybe support mirroring?
 194   if ((addr & 0xfe000000) != 0x02000000)
 195     return NULL;
 196
 197   *mem_end = (u8 *)mmsp2.umem + 0x02000000;
 198   return (u8 *)mmsp2.umem - 0x02000000 + addr;
 199 }
 200
 201 static void blitter_do(void)
 202 {
 203   u8 *dst, *dste, *src = NULL, *srce = NULL;
 204   int w, h, sstrd, dstrd;
 205   int to_screen = 0;
 206   u32 bpp, addr;
 207
 208   w = blitter.size & 0x7ff;
 209   h = (blitter.size >> 16) & 0x7ff;
 210   sstrd = blitter.srcstride;
 211   dstrd = blitter.dststride;
 212
 213   // XXX: need to confirm this..
 214   addr = (blitter.dstaddr & ~3) | ((blitter.dstctrl & 0x1f) >> 3);
 215
 216   // use dst bpp.. How does it do blits with different src bpp?
 217   bpp = (blitter.dstctrl & 0x20) ? 16 : 8;
 218
 219   // maybe the screen?
 220   if (((w == 320 && h == 240) || // blit whole screen
 221        (w * h >= 320*240/2)) &&  // ..or at least half of the area
 222        mmsp2.mlc_stl_adr <= addr && addr < mmsp2.mlc_stl_adr + 320*240*2)
 223     to_screen = 1;
 224
 225   dst = uppermem_lookup(addr, &dste);
 226
 227   // XXX: assume fill if no SRCENB, but it could be pattern blit..
 228   if (blitter.srcctrl & SRCCTRL_SRCENB) {
 229     if (!(blitter.srcctrl & SRCCTRL_INVIDEO))
 230       goto bad_blit;
 231
 232     addr = (blitter.srcaddr & ~3) | ((blitter.srcctrl & 0x1f) >> 3);
 233     src = uppermem_lookup(addr, &srce);
 234     if (src == NULL)
 235       goto bad_blit;
 236
 237     if (src + sstrd * h > srce) {
 238       err("blit %08x->%08x %dx%d did not fit src\n",
 239         blitter.srcaddr, blitter.dstaddr, w, h);
 240       h = (srce - src) / sstrd;
 241     }
 242   }
 243
 244   if (dst == NULL)
 245     goto bad_blit;
 246
 247   if (dst + dstrd * h > dste) {
 248     err("blit %08x->%08x %dx%d did not fit dst\n",
 249       blitter.srcaddr, blitter.dstaddr, w, h);
 250     h = (dste - dst) / dstrd;
 251   }
 252
 253   if (src != NULL) {
 254     // copy
 255     if (bpp == 16 && (blitter.ctrl & CTRL_TRANSPARENCYENB)) {
 256       u32 trc = blitter.ctrl >> 16;
 257       for (; h > 0; h--, dst += dstrd, src += sstrd)
 258         blt_tr(dst, src, trc, w);
 259     }
 260     else {
 261       for (; h > 0; h--, dst += dstrd, src += sstrd)
 262         memcpy(dst, src, w * bpp / 8);
 263     }
 264   }
 265   else {
 266     // fill. Assume the pattern is cleared and bg color is used
 267     u32 bgc = blitter.patbackcolor & 0xffff;
 268     if (bpp == 16) {
 269       for (; h > 0; h--, dst += dstrd)
 270         memset16(dst, bgc, w);
 271     }
 272     else {
 273       for (; h > 0; h--, dst += dstrd)
 274         memset(dst, bgc, w); // bgc?
 275     }
 276   }
 277
 278   if (to_screen)
 279     pthread_cond_signal(&fb_cond);
 280   return;
 281
 282 bad_blit:
 283   err("blit %08x->%08x %dx%d translated to %p->%p\n",
 284     blitter.srcaddr, blitter.dstaddr, w, h, src, dst);
 285   dump_blitter();
 286 }
 287
 288 // FIXME: pass real dimensions to blitters
 289 static void mlc_flip(void *src, int bpp, int stride)
 290 {
 291   static int old_bpp;
 292
 293   // only pass pal to host if it's dirty
 294   if (bpp <= 8 && mmsp2.v.dirty_pal) {
 295     if (mmsp2.v.dirty_pal == DIRTY_PAL_MMSP2)
 296       host_video_update_pal32(mmsp2.mlc_stl_pallt_d32);
 297     else
 298       host_video_update_pal16(mmsp2.mlcpalette);
 299     mmsp2.v.dirty_pal = 0;
 300   }
 301
 302   if (bpp != old_bpp) {
 303     host_video_change_bpp(bpp);
 304     old_bpp = bpp;
 305   }
 306
 307   switch (bpp) {
 308   case  4:
 309     host_video_blit4(src, 320, 240, stride);
 310     break;
 311
 312   case  8:
 313     host_video_blit8(src, 320, 240, stride);
 314     break;
 315
 316   case 16:
 317     host_video_blit16(src, 320, 240, stride);
 318     break;
 319
 320   case 24:
 321     // TODO
 322     break;
 323   }
 324 }
 325
 326 #define ts_add_nsec(ts, ns) { \
 327   ts.tv_nsec += ns; \
 328   if (ts.tv_nsec >= 1000000000) { \
 329     ts.tv_sec++; \
 330     ts.tv_nsec -= 1000000000; \
 331   } \
 332 }
 333
 334 static int fb_sync_thread_paused;
 335
 336 static void *fb_sync_thread(void *arg)
 337 {
 338   int invalid_fb_addr = 1;
 339   int manual_refresh = 0;
 340   int frame_counter = 0;
 341   struct timespec ts;
 342   int ret, wait_ret;
 343
 344   //ret = pthread_setschedprio(pthread_self(), -1);
 345   //log("pthread_setschedprio %d\n", ret);
 346   //ret = setpriority(PRIO_PROCESS, 0, -1);
 347   //log("setpriority %d\n", ret);
 348
 349   ret = clock_gettime(CLOCK_REALTIME, &ts);
 350   if (ret != 0) {
 351     perror(PFX "clock_gettime");
 352     exit(1);
 353   }
 354
 355   while (1) {
 356     u8 *gp2x_fb, *gp2x_fb_end;
 357
 358     ret =  pthread_mutex_lock(&fb_mutex);
 359     wait_ret = pthread_cond_timedwait(&fb_cond, &fb_mutex, &ts);
 360     ret |= pthread_mutex_unlock(&fb_mutex);
 361
 362     if (ret != 0) {
 363       err("fb_thread: mutex error: %d\n", ret);
 364       sleep(1);
 365       goto check_keys;
 366     }
 367     if (wait_ret != 0 && wait_ret != ETIMEDOUT) {
 368       err("fb_thread: cond error: %d\n", wait_ret);
 369       sleep(1);
 370       goto check_keys;
 371     }
 372     if (fb_sync_thread_paused) {
 373       ts_add_nsec(ts, 100000000);
 374       goto check_keys;
 375     }
 376
 377     if (wait_ret != ETIMEDOUT) {
 378       clock_gettime(CLOCK_REALTIME, &ts);
 379       ts_add_nsec(ts, 50000000);
 380       manual_refresh++;
 381       if (manual_refresh == 2)
 382         dbg("fb_thread: switch to manual refresh\n");
 383     } else {
 384       ts_add_nsec(ts, 16666667);
 385       if (manual_refresh > 1)
 386         dbg("fb_thread: switch to auto refresh\n");
 387       manual_refresh = 0;
 388     }
 389
 390     gp2x_fb = uppermem_lookup(mmsp2.mlc_stl_adr, &gp2x_fb_end);
 391     if (gp2x_fb == NULL || gp2x_fb + 320*240 * mmsp2.v.bpp / 8 > gp2x_fb_end) {
 392       if (!invalid_fb_addr) {
 393         err("fb_thread: %08x is out of range\n", mmsp2.mlc_stl_adr);
 394         invalid_fb_addr = 1;
 395       }
 396       continue;
 397     }
 398
 399     invalid_fb_addr = 0;
 400     mlc_flip(gp2x_fb, mmsp2.v.bpp, mmsp2.v.stride);
 401
 402     frame_counter++;
 403     if (frame_counter & 0x0f)
 404       continue;
 405
 406 check_keys:
 407     // this is to check for kill key, in case main thread hung
 408     // or something else went wrong.
 409     pollux.btn_state = host_read_btns();
 410   }
 411 }
 412
 413 static void fb_thread_pause(void)
 414 {
 415   fb_sync_thread_paused = 1;
 416   // wait until it finishes last refresh
 417   // that it might be doing now
 418   usleep(10000);
 419 }
 420
 421 static void fb_thread_resume(void)
 422 {
 423   fb_sync_thread_paused = 0;
 424 }
 425
 426 static u32 xread32_io_cmn(u32 a, u32 *handled)
 427 {
 428   u32 d = 0;
 429
 430   *handled = 1;
 431   switch (a) {
 432   // Wiz stuff
 433   case 0x402c: // MLCVSTRIDE0
 434   case 0x4060: // MLCVSTRIDE1
 435     d = pollux.v.stride;
 436     break;
 437   case 0x4038: // MLCADDRESS0
 438   case 0x406c: // MLCADDRESS1
 439     d = pollux.mlc_stl_adr;
 440     break;
 441   // wiz_lib reads:
 442   //  ???? ???? YXBA DURiLe ???? VdVuMS LR?? ????
 443   // |     GPIOC[31:16]    |    GPIOB[31:16]     |
 444   case 0xa058: // GPIOBPAD
 445     d =  (pollux.btn_state >> 1) & 0x0100;
 446     d |= (pollux.btn_state << 1) & 0x0200;
 447     d |= (pollux.btn_state >> 3) & 0x0080;
 448     d |= (pollux.btn_state >> 5) & 0x0040;
 449     d |= (pollux.btn_state >> 6) & 0x0c00;
 450     d <<= 16;
 451     d = ~d;
 452     break;
 453   case 0xa098: // GPIOCPAD
 454     pollux.btn_state = host_read_btns();
 455     d =  (pollux.btn_state >> 8) & 0x00f0;
 456     d |= (pollux.btn_state >> 1) & 0x0008;
 457     d |= (pollux.btn_state << 2) & 0x0004;
 458     d |= (pollux.btn_state >> 5) & 0x0002;
 459     d |= (pollux.btn_state >> 2) & 0x0001;
 460     d <<= 16;
 461     d = ~d;
 462     break;
 463   default:
 464     *handled = 0;
 465     break;
 466   }
 467
 468   return d;
 469 }
 470
 471 static u32 xread8(u32 a)
 472 {
 473   iolog("r8 ", a, 0, 8);
 474   iolog_unh("r8 ", a, 0, 8);
 475   return 0;
 476 }
 477
 478 static u32 xread16(u32 a)
 479 {
 480   static u32 fudge, old_a;
 481   u32 d = 0, t;
 482
 483   if ((a & 0xffff0000) == 0x7f000000) {
 484     u32 a_ = a & 0xffff;
 485     switch (a_) {
 486     case 0x0910: // FPLL
 487     case 0x0912:
 488       d = 0x9407;
 489       break;
 490     // minilib reads as:
 491     //  0000 P000 VuVd00 0000 YXBA RLSeSt 0Ri0D 0Le0U
 492     // |        GPIOD        |GPIOC[8:15]|GPIOM[0:7] |
 493     // /dev/GPIO:
 494     //             ... 0PVdVu ...
 495     case 0x1184: // GPIOC
 496       d = ~mmsp2.btn_state & 0xff00;
 497       d |= 0x00ff;
 498       break;
 499     case 0x1186: // GPIOD
 500       t = ~mmsp2.btn_state;
 501       d  = (t >> 9)  & 0x0080;
 502       d |= (t >> 11) & 0x0040;
 503       d |= (t >> 7)  & 0x0800;
 504       d |= 0x373b;
 505       break;
 506     case 0x1198: // GPIOM
 507       mmsp2.btn_state = host_read_btns();
 508       d = ~mmsp2.btn_state & 0xff;
 509       d |= 0x01aa;
 510       break;
 511     case 0x1836: // reserved
 512       d = 0x2330;
 513       break;
 514     case 0x2816: // DPC_X_MAX
 515       d = 319;
 516       break;
 517     case 0x2818: // DPC_Y_MAX
 518       d = 239;
 519       break;
 520     case 0x28da:
 521       d = mmsp2.mlc_stl_cntl;
 522       break;
 523     case 0x290e:
 524     case 0x2912:
 525       d = mmsp2.mlc_stl_adrl;
 526       break;
 527     case 0x2910:
 528     case 0x2914:
 529       d = mmsp2.mlc_stl_adrh;
 530       break;
 531     case 0x2958:
 532       d = mmsp2.mlc_stl_pallt_a;
 533       break;
 534
 535     default:
 536       d = xread32_io_cmn(a_, &t);
 537       if (!t)
 538         goto unk;
 539       if (!(a_ & 2))
 540         d >>= 16;
 541       break;
 542     }
 543     goto out;
 544   }
 545
 546 unk:
 547   if (a == old_a) {
 548     d = fudge;
 549     fudge = ~fudge;
 550   }
 551   old_a = a;
 552   iolog_unh("r16", a, d & 0xffff, 16);
 553
 554 out:
 555   d &= 0xffff;
 556   iolog("r16", a, d, 16);
 557   return d;
 558 }
 559
 560 static u32 xread32(u32 a)
 561 {
 562   u32 d = 0;
 563   if ((a & 0xfff00000) == 0x7f000000) {
 564     u32 a_ = a & 0xffff;
 565     struct timespec ts;
 566     u64 t64;
 567     u32 t;
 568
 569     switch (a_) {
 570     case 0x0a00: // TCOUNT, 1/7372800s
 571       clock_gettime(CLOCK_REALTIME, &ts);
 572       t64 = (u64)ts.tv_sec * 1000000000 + ts.tv_nsec;
 573       // t * 7372800.0 / 1000000000 * 0x100000000 ~= t * 31665935
 574       t64 *= 31665935;
 575       d = t64 >> 32;
 576       break;
 577
 578     default:
 579       d = xread32_io_cmn(a_, &t);
 580       if (!t)
 581         goto unh;
 582       break;
 583     }
 584     goto out;
 585   }
 586   if ((a & 0xfff00000) == 0x7f100000) {
 587     u32 *bl = &blitter.dstctrl;
 588     u32 a_ = a & 0xfff;
 589     if (a_ < 0x40) {
 590       d = bl[a_ / 4];
 591       if (a_ == 0x34)
 592         d = 0; // not busy
 593       goto out;
 594     }
 595   }
 596
 597 unh:
 598   iolog_unh("r32", a, d, 32);
 599
 600 out:
 601   iolog("r32", a, d, 32);
 602   return d;
 603 }
 604
 605 static void xwrite8(u32 a, u32 d)
 606 {
 607   iolog("w8 ", a, d, 8);
 608   iolog_unh("w8 ", a, d, 8);
 609 }
 610
 611 static void xwrite16(u32 a, u32 d)
 612 {
 613   iolog("w16", a, d, 16);
 614   if ((a & 0xfff00000) == 0x7f000000) {
 615     u32 a_ = a & 0xffff;
 616     switch (a_) {
 617       case 0x28da: {
 618         int mode;
 619         mmsp2.mlc_stl_cntl = d | 0xaa;
 620         mode = (d >> 9) & 3;
 621         mmsp2.v.bpp = mode ? mode * 8 : 4;
 622         break;
 623       }
 624       case 0x290c:
 625         mmsp2.v.stride = d;
 626         return;
 627       case 0x290e:
 628       case 0x2910:
 629         // odd addresses don't affect LCD. What about TV?
 630         return;
 631       case 0x2912:
 632         mmsp2.mlc_stl_adrl = d;
 633         return;
 634       case 0x2914:
 635         mmsp2.mlc_stl_adrh = d;
 636         if (mmsp2.mlc_stl_adr != mmsp2.old_mlc_stl_adr)
 637           // ask for refresh
 638           pthread_cond_signal(&fb_cond);
 639         mmsp2.old_mlc_stl_adr = mmsp2.mlc_stl_adr;
 640         return;
 641       case 0x2958:
 642         mmsp2.mlc_stl_pallt_a = d & 0x1ff;
 643         return;
 644       case 0x295a:
 645         mmsp2.mlc_stl_pallt_d[mmsp2.mlc_stl_pallt_a++] = d;
 646         mmsp2.mlc_stl_pallt_a &= 0x1ff;
 647         mmsp2.v.dirty_pal = DIRTY_PAL_MMSP2;
 648         return;
 649     }
 650   }
 651   iolog_unh("w16", a, d, 16);
 652 }
 653
 654 static void xwrite32(u32 a, u32 d)
 655 {
 656   iolog("w32", a, d, 32);
 657
 658   if ((a & 0xfff00000) == 0x7f000000) {
 659     u32 a_ = a & 0xffff;
 660     switch (a_) {
 661     // Wiz
 662     case 0x4024: // MLCCONTROL0
 663     case 0x4058: // MLCCONTROL1
 664       pollux.mlccontrol = d;
 665       if (!(d & 0x20))
 666         return; // layer not enabled
 667       if ((d >> 16) == 0x443A)
 668         pollux.v.bpp = 8;
 669       else
 670         pollux.v.bpp = 16;
 671       return;
 672     case 0x402c: // MLCVSTRIDE0
 673     case 0x4060: // MLCVSTRIDE1
 674       pollux.v.stride = d;
 675       return;
 676     case 0x4038: // MLCADDRESS0
 677     case 0x406c: // MLCADDRESS1
 678       pollux.mlc_stl_adr = d;
 679       if (d != mmsp2.old_mlc_stl_adr)
 680         // ask for refresh
 681         pthread_cond_signal(&fb_cond);
 682       mmsp2.old_mlc_stl_adr = d;
 683       return;
 684     case 0x403c: // MLCPALETTE0
 685     case 0x4070: // MLCPALETTE1
 686       pollux.mlcpalette[d >> 24] = d;
 687       pollux.v.dirty_pal = DIRTY_PAL_POLLUX;
 688       return;
 689     }
 690   }
 691   if ((a & 0xfff00000) == 0x7f100000) {
 692     u32 *bl = &blitter.dstctrl;
 693     u32 a_ = a & 0xfff;
 694     if (a_ < 0x40) {
 695       bl[a_ / 4] = d;
 696       if (a_ == 0x34 && (d & 1))
 697         blitter_do();
 698       return;
 699     }
 700   }
 701   iolog_unh("w32", a, d, 32);
 702 }
 703
 704 #define LINKPAGE_SIZE 0x1000
 705 #define LINKPAGE_COUNT 4
 706 #define LINKPAGE_ALLOC (LINKPAGE_SIZE * LINKPAGE_COUNT)
 707
 708 struct op_context {
 709   u32 pc;
 710   u32 op;
 711   u32 code[0];
 712 };
 713
 714 struct op_linkpage {
 715   void (*handler)(struct op_context *op_ctx);
 716   u32 code[0];
 717 };
 718
 719 struct op_stackframe {
 720   u32 saved_regs[15];
 721   u32 cpsr;
 722 };
 723
 724 static struct op_linkpage *g_linkpage;
 725 static u32 *g_code_ptr;
 726 static int g_linkpage_count;
 727
 728 #define BIT_SET(v, b) (v & (1 << (b)))
 729
 730 void emu_handle_op(struct op_context *op_ctx, struct op_stackframe *sframe)
 731 {
 732   u32 *regs = sframe->saved_regs;
 733   u32 op = op_ctx->op;
 734   u32 t, shift, ret, addr;
 735   int rn, rd;
 736
 737   rd = (op & 0x0000f000) >> 12;
 738   rn = (op & 0x000f0000) >> 16;
 739
 740   if ((op & 0x0f200090) == 0x01000090) { // AM3: LDRH, STRH
 741     if (!BIT_SET(op, 5)) // !H
 742       goto unhandled;
 743     if (BIT_SET(op, 6) && !BIT_SET(op, 20)) // S && !L
 744       goto unhandled;
 745
 746     if (BIT_SET(op, 22))                // imm offset
 747       t = ((op & 0xf00) >> 4) | (op & 0x0f);
 748     else                                // reg offset
 749       t = regs[op & 0x000f];
 750
 751     if (!BIT_SET(op, 23))
 752       t = -t;
 753     addr = regs[rn] + t;
 754
 755     if (BIT_SET(op, 20)) { // Load
 756       ret = xread16(addr);
 757       if (BIT_SET(op, 6)) { // S
 758         ret <<= 16;
 759         ret = (signed int)ret >> 16;
 760       }
 761       regs[rd] = ret;
 762     }
 763     else
 764       xwrite16(addr, regs[rd]);
 765   }
 766   else if ((op & 0x0d200000) == 0x05000000) { // AM2: LDR[B], STR[B]
 767     if (BIT_SET(op, 25)) {              // reg offs
 768       if (BIT_SET(op, 4))
 769         goto unhandled;
 770
 771       t = regs[op & 0x000f];
 772       shift = (op & 0x0f80) >> 7;
 773       switch ((op & 0x0060) >> 5) {
 774         case 0: t = t << shift; break;
 775         case 1: t = t >> (shift + 1); break;
 776         case 2: t = (signed int)t >> (shift + 1); break;
 777         case 3: goto unhandled; // I'm just lazy
 778       }
 779     }
 780     else                                // imm offs
 781       t = op & 0x0fff;
 782
 783     if (!BIT_SET(op, 23))
 784       t = -t;
 785     addr = regs[rn] + t;
 786
 787     if (BIT_SET(op, 20)) { // Load
 788       if (BIT_SET(op, 22)) // Byte
 789         ret = xread8(addr);
 790       else
 791         ret = xread32(addr);
 792       regs[rd] = ret;
 793     }
 794     else {
 795       if (BIT_SET(op, 22)) // Byte
 796         xwrite8(addr, regs[rd]);
 797       else
 798         xwrite32(addr, regs[rd]);
 799     }
 800   }
 801   else
 802     goto unhandled;
 803
 804 #if 0
 805   if (addr != addr_check) {
 806     fprintf(stderr, "bad calculated addr: %08x vs %08x\n", addr, addr_check);
 807     abort();
 808   }
 809 #endif
 810   return;
 811
 812 unhandled:
 813   err("unhandled IO op %08x @ %08x\n", op, op_ctx->pc);
 814 }
 815
 816 static u32 make_offset12(u32 *pc, u32 *target)
 817 {
 818   int lp_offs, u = 1;
 819
 820   lp_offs = (char *)target - (char *)pc - 2*4;
 821   if (lp_offs < 0) {
 822     lp_offs = -lp_offs;
 823     u = 0;
 824   }
 825   if (lp_offs >= LINKPAGE_SIZE) {
 826     err("linkpage too far: %d\n", lp_offs);
 827     abort();
 828   }
 829
 830   return (u << 23) | lp_offs;
 831 }
 832
 833 static u32 make_jmp(u32 *pc, u32 *target, int bl)
 834 {
 835   int jmp_val;
 836
 837   jmp_val = target - pc - 2;
 838   if (jmp_val < (int)0xff000000 || jmp_val > 0x00ffffff) {
 839     err("jump out of range (%p -> %p)\n", pc, target);
 840     abort();
 841   }
 842
 843   return 0xea000000 | (bl << 24) | (jmp_val & 0x00ffffff);
 844 }
 845
 846 static void emit_op(u32 op)
 847 {
 848   *g_code_ptr++ = op;
 849 }
 850
 851 static void emit_op_io(u32 op, u32 *target)
 852 {
 853   op |= make_offset12(g_code_ptr, target);
 854   emit_op(op);
 855 }
 856
 857 static void init_linkpage(void)
 858 {
 859   g_linkpage->handler = emu_call_handle_op;
 860   g_code_ptr = g_linkpage->code;
 861 }
 862
 863 static void segv_sigaction(int num, siginfo_t *info, void *ctx)
 864 {
 865   struct ucontext *context = ctx;
 866   u32 *regs = (u32 *)&context->uc_mcontext.arm_r0;
 867   u32 *pc = (u32 *)regs[15];
 868   struct op_context *op_ctx;
 869   int i, lp_size;
 870
 871   if (((regs[15] ^ (u32)&segv_sigaction) & 0xff000000) == 0 ||         // PC is in our segment or
 872       (((regs[15] ^ (u32)g_linkpage) & ~(LINKPAGE_ALLOC - 1)) == 0) || // .. in linkpage
 873       ((long)info->si_addr & 0xffe00000) != 0x7f000000)                // faulting not where expected
 874   {
 875     // real crash - time to die
 876     err("segv %d %p @ %08x\n", info->si_code, info->si_addr, regs[15]);
 877     for (i = 0; i < 8; i++)
 878       dbg(" r%d=%08x r%2d=%08x\n", i, regs[i], i+8, regs[i+8]);
 879     signal(num, SIG_DFL);
 880     raise(num);
 881     return;
 882   }
 883   segvlog("segv %d %p @ %08x\n", info->si_code, info->si_addr, regs[15]);
 884
 885   // spit PC and op
 886   op_ctx = (void *)g_code_ptr;
 887   op_ctx->pc = (u32)pc;
 888   op_ctx->op = *pc;
 889   g_code_ptr = &op_ctx->code[0];
 890
 891   // emit jump to code ptr
 892   *pc = make_jmp(pc, g_code_ptr, 0);
 893
 894   // generate code:
 895   emit_op   (0xe50d0000 + 0xf00 - 4 * 0);                        // str r0, [sp, #(-0xf00 + r0_offs)]
 896   emit_op   (0xe50de000 + 0xf00 - 4 * 14);                       // str lr, [sp, #(-0xf00 + lr_offs)]
 897   emit_op   (0xe24f0000 + (g_code_ptr - (u32 *)op_ctx + 2) * 4); // sub r0, pc, #op_ctx
 898   emit_op   (0xe1a0e00f);                                        // mov lr, pc
 899   emit_op_io(0xe51ff000, (u32 *)&g_linkpage->handler);           // ldr pc, =handle_op
 900   emit_op   (0xe51de000 + 0xf00 - 4 * 14);                       // ldr lr, [sp, #(-0xf00 + lr_offs)]
 901   emit_op   (make_jmp(g_code_ptr, pc + 1, 0));                   // jmp <back>
 902
 903   // sync caches
 904   sys_cacheflush(pc, pc + 1);
 905   sys_cacheflush(g_linkpage, g_code_ptr);
 906
 907   lp_size = (char *)g_code_ptr - (char *)g_linkpage;
 908   segvlog("code #%d %d/%d\n", g_linkpage_count, lp_size, LINKPAGE_SIZE);
 909
 910   if (lp_size + 13*4 > LINKPAGE_SIZE) {
 911     g_linkpage_count++;
 912     if (g_linkpage_count >= LINKPAGE_COUNT) {
 913       err("too many linkpages needed\n");
 914       abort();
 915     }
 916     g_linkpage = (void *)((char *)g_linkpage + LINKPAGE_SIZE);
 917     init_linkpage();
 918   }
 919   //handle_op(regs[15], op, regs, (u32)info->si_addr);
 920   //regs[15] += 4;
 921 }
 922
 923 void emu_init(void *map_bottom)
 924 {
 925   sigaction_t segv_action = {
 926     .sa_sigaction = segv_sigaction,
 927     .sa_flags = SA_SIGINFO,
 928   };
 929   pthread_t tid;
 930   void *pret;
 931   int ret;
 932
 933 #ifdef PND
 934   if (geteuid() == 0) {
 935     fprintf(stderr, "don't try to run as root, device registers or memory "
 936                     "might get trashed crashing the OS or even damaging the device.\n");
 937     exit(1);
 938   }
 939 #endif
 940
 941   g_linkpage = (void *)(((u32)map_bottom - LINKPAGE_ALLOC) & ~0xfff);
 942   pret = mmap(g_linkpage, LINKPAGE_ALLOC, PROT_READ|PROT_WRITE,
 943               MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
 944   if (pret != g_linkpage) {
 945     perror(PFX "mmap linkpage");
 946     exit(1);
 947   }
 948   log("linkpages @ %p\n", g_linkpage);
 949   init_linkpage();
 950
 951   // host stuff
 952   ret = host_init();
 953   if (ret != 0) {
 954     err("can't init host\n");
 955     exit(1);
 956   }
 957
 958   ret = host_video_init(NULL, 0);
 959   if (ret != 0) {
 960     err("can't init host video\n");
 961     exit(1);
 962   }
 963
 964   // TODO: check if this really fails on Wiz..
 965   mmsp2.umem = mmap(NULL, 0x2000000, PROT_READ|PROT_WRITE|PROT_EXEC,
 966                     MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 967 #ifdef WIZ
 968   if (mmsp2.umem == MAP_FAILED) {
 969     // we are short on memmory on Wiz, need special handling
 970     extern void *host_mmap_upper(void);
 971     mmsp2.umem = host_mmap_upper();
 972   }
 973 #endif
 974   if (mmsp2.umem == MAP_FAILED) {
 975     perror(PFX "mmap upper mem");
 976     exit(1);
 977   }
 978
 979   ret = pthread_create(&tid, NULL, fb_sync_thread, NULL);
 980   if (ret != 0) {
 981     err("failed to create fb_sync_thread: %d\n", ret);
 982     exit(1);
 983   }
 984   pthread_detach(tid);
 985
 986   // defaults
 987   mmsp2.mlc_stl_adr = 0x03101000; // fb2 is at 0x03381000
 988   mmsp2.mlc_stl_cntl = 0x4ab; // 16bpp, region 1 active
 989   mmsp2.v.width = 320;
 990   mmsp2.v.height = 240;
 991   mmsp2.v.stride = 320*2;
 992   mmsp2.v.bpp = 16;
 993   mmsp2.v.dirty_pal = 1;
 994
 995   sigemptyset(&segv_action.sa_mask);
 996   sigaction(SIGSEGV, &segv_action, NULL);
 997 }
 998
 999 int emu_read_gpiodev(void *buf, int count)
1000 {
1001   if (count <= 0) {
1002     err("gpiodev read %d?\n", count);
1003     return -1;
1004   }
1005   if (count > 4)
1006     count = 4;
1007
1008   mmsp2.btn_state = host_read_btns();
1009   memcpy(buf, &mmsp2.btn_state, count);
1010   return count;
1011 }
1012
1013 static void *emu_mmap_dev(unsigned int length, int prot, int flags, unsigned int offset)
1014 {
1015   u8 *umem, *umem_end;
1016
1017   // SoC regs
1018   if ((offset & ~0x1ffff) == 0xc0000000) {
1019     return mmap((void *)0x7f000000, length, PROT_NONE,
1020       MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED|MAP_NORESERVE, -1, 0);
1021   }
1022   // MMSP2 blitter
1023   if ((offset & ~0xffff) == 0xe0020000) {
1024     return mmap((void *)0x7f100000, length, PROT_NONE,
1025       MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED|MAP_NORESERVE, -1, 0);
1026   }
1027   // upper mem
1028   if ((offset & 0xfe000000) != 0x02000000) {
1029     err("unexpected devmem mmap @ %08x\n", offset);
1030     errno = EINVAL;
1031     return MAP_FAILED;
1032   }
1033
1034   umem = uppermem_lookup(offset, &umem_end);
1035   if (umem + length > umem_end)
1036     err("warning: uppermem @ %08x overflows by %d bytes\n",
1037         offset, umem + length - umem_end);
1038
1039   dbg("upper mem @ %08x %d\n", offset, length);
1040   return umem;
1041 }
1042
1043 void *emu_do_mmap(unsigned int length, int prot, int flags, int fd, unsigned int offset)
1044 {
1045   if (fd == FAKEDEV_MEM)
1046     return emu_mmap_dev(length, prot, flags, offset);
1047
1048   if (fd == FAKEDEV_FB0)
1049     return emu_mmap_dev(length, prot, flags, offset + 0x03101000);
1050
1051   if (fd == FAKEDEV_FB1)
1052     return emu_mmap_dev(length, prot, flags, offset + 0x03381000);
1053
1054   err("bad/ni mmap(?, %d, %x, %x, %d, %08x)\n", length, prot, flags, fd, offset);
1055   errno = EINVAL;
1056   return MAP_FAILED;
1057 }
1058
1059 static void emu_sound_open(int fd)
1060 {
1061 #ifdef PND
1062   int ret, frag;
1063
1064   // set default buffer size to 16 * 1K
1065   frag = (16<<16) | 10; // 16K
1066   ret = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &frag);
1067   if (ret != 0) {
1068     err("snd ioctl SETFRAGMENT %08x: ", frag);
1069     perror(NULL);
1070   }
1071 #endif
1072 }
1073
1074 static int emu_sound_ioctl(int fd, int request, void *argp)
1075 {
1076   int *arg = argp;
1077
1078 #if 0
1079   dbg("snd ioctl(%d, %08x, %p)", fd, request, argp);
1080   if (arg != NULL)
1081     dbg_c(" [%d]", *arg);
1082   dbg_c("\n");
1083 #endif
1084
1085   /* People set strange frag settings on GP2X, which even manage
1086    * to break audio on pandora (causes writes to fail).
1087    * Catch this and set to something that works. */
1088   switch(request) {
1089     case SNDCTL_DSP_SETFRAGMENT: {
1090       int ret, bsize, frag, frag_cnt;
1091       if (arg == NULL)
1092         break;
1093
1094       frag = *arg & 0xffff;
1095       frag_cnt = *arg >> 16;
1096       bsize = frag_cnt << frag;
1097       if (frag < 10 || bsize < 4096*4 || bsize > 4096*4*2) {
1098         /*
1099          * ~4ms. gpSP wants small buffers or else it stutters
1100          * because of it's audio thread sync stuff
1101          * XXX: hardcoding, as low samplerates will result in small fragment size,
1102          * which itself causes ALSA stall and hangs the program.
1103          * Also some apps change samplerate without reopening /dev/dsp,
1104          * which causes ALSA to reject SNDCTL_DSP_SETFRAGMENT.
1105          */
1106         bsize = 44100 / 250 * 4;
1107
1108         for (frag = 0; bsize; bsize >>= 1, frag++)
1109           ;
1110
1111         frag_cnt = 16;
1112       }
1113
1114       frag |= frag_cnt << 16;
1115       ret = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &frag);
1116       if (ret != 0) {
1117         err("snd ioctl SETFRAGMENT %08x: ", frag);
1118         perror(NULL);
1119       }
1120       // indicate success even if we fail (because of ALSA mostly),
1121       // things like MikMod will bail out otherwise.
1122       return 0;
1123     }
1124     case SNDCTL_DSP_SYNC:
1125       // Franxis tends to use sync/write loops, bad idea under ALSA
1126       return 0;
1127     default:
1128       break;
1129   }
1130
1131   return ioctl(fd, request, argp);
1132 }
1133
1134 int emu_do_ioctl(int fd, int request, void *argp)
1135 {
1136   if (fd == emu_interesting_fds[IFD_SOUND].fd)
1137     return emu_sound_ioctl(fd, request, argp);
1138
1139   switch (fd) {
1140   /* *********************** */
1141   case FAKEDEV_FB0:
1142   case FAKEDEV_FB1:
1143     if (argp == NULL)
1144       goto fail;
1145
1146     switch (request) {
1147       case FBIOGET_FSCREENINFO: {
1148         struct fb_fix_screeninfo *fix = argp;
1149
1150         memset(fix, 0, sizeof(*fix));
1151         strcpy(fix->id, "mmsp2_RGB0");
1152         fix->type         = FB_TYPE_PACKED_PIXELS;
1153         fix->accel        = FB_ACCEL_NONE;
1154         fix->visual       = FB_VISUAL_TRUECOLOR;
1155         fix->line_length  = 320*2;
1156         fix->smem_start   = (fd == FAKEDEV_FB0) ? 0x03101000 : 0x03381000;
1157         fix->smem_len     = 320*240*2;
1158         return 0;
1159       }
1160       case FBIOGET_VSCREENINFO: {
1161         struct fb_var_screeninfo *var = argp;
1162         static const struct fb_bitfield fbb_red   = { offset: 11, length: 5, };
1163         static const struct fb_bitfield fbb_green = { offset:  5, length: 6, };
1164         static const struct fb_bitfield fbb_blue  = { offset:  0, length: 5, };
1165
1166         memset(var, 0, sizeof(*var));
1167         var->activate     = FB_ACTIVATE_NOW;
1168         var->xres         =
1169         var->xres_virtual = 320;
1170         var->yres         =
1171         var->yres_virtual = 240;
1172         var->width        =
1173         var->height       = -1;
1174         var->vmode        = FB_VMODE_NONINTERLACED;
1175         var->bits_per_pixel = 16;
1176         var->red          = fbb_red;
1177         var->green        = fbb_green;
1178         var->blue         = fbb_blue;
1179         return 0;
1180       }
1181       case FBIOPUT_VSCREENINFO: {
1182         struct fb_var_screeninfo *var = argp;
1183         dbg(" put vscreen: %dx%d@%d\n", var->xres, var->yres, var->bits_per_pixel);
1184         if (var->xres != 320 || var->yres != 240 || var->bits_per_pixel != 16)
1185           return -1;
1186         return 0;
1187       }
1188     }
1189
1190   /* *********************** */
1191   case FAKEDEV_TTY0:
1192     // fake tty0 to make GPH SDL happy
1193     if (request == 0x4b46) // KDGKBENT
1194       return -1;
1195     return 0;
1196   }
1197
1198 fail:
1199   err("bad/ni ioctl(%d, %08x, %p)\n", fd, request, argp);
1200   errno = EINVAL;
1201   return -1;
1202 }
1203
1204 struct dev_fd_t emu_interesting_fds[] = {
1205   [IFD_SOUND] = { "/dev/dsp", -1, emu_sound_open },
1206   { NULL, 0, NULL },
1207 };
1208
1209 static const struct {
1210   const char *from;
1211   const char *to;
1212 } path_map[] = {
1213   { "/mnt/tmp/", "/tmp/" },
1214 };
1215
1216 static const char *wrap_path(const char *path)
1217 {
1218   char *buff;
1219   size_t size;
1220   int i, len;
1221
1222   // do only path mapping for now
1223   for (i = 0; i < ARRAY_SIZE(path_map); i++) {
1224     len = strlen(path_map[i].from);
1225     if (strncmp(path, path_map[i].from, len) == 0) {
1226       size = strlen(path) + strlen(path_map[i].to) + 1;
1227       buff = malloc(size);
1228       if (buff == NULL)
1229         break;
1230       snprintf(buff, size, "%s%s", path_map[i].to, path + len);
1231       dbg("mapped path \"%s\" -> \"%s\"\n", path, buff);
1232       return buff;
1233     }
1234   }
1235
1236   return path;
1237 }
1238
1239 static void wrap_path_free(const char *w_path, const char *old_path)
1240 {
1241   if (w_path != old_path)
1242     free((void *)w_path);
1243 }
1244
1245 void *emu_do_fopen(const char *path, const char *mode)
1246 {
1247   const char *w_path;
1248   FILE *ret;
1249
1250   w_path = wrap_path(path);
1251   ret = fopen(w_path, mode);
1252   wrap_path_free(w_path, path);
1253
1254   return ret;
1255 }
1256
1257 // FIXME: threads..
1258 int emu_do_system(const char *command)
1259 {
1260   static char tmp_path[512];
1261   const char *p2;
1262   char *p;
1263   int ret;
1264
1265   if (command == NULL)
1266     return -1;
1267
1268   // pass through stuff in PATH
1269   p = strchr(command, ' ');
1270   p2 = strchr(command, '/');
1271   if (p2 == NULL || (p != NULL && p2 > p))
1272     return system(command);
1273
1274   make_local_path(tmp_path, sizeof(tmp_path), "ginge_prep");
1275   p = tmp_path + strlen(tmp_path);
1276
1277   p2 = wrap_path(command);
1278   snprintf(p, sizeof(tmp_path) - (p - tmp_path), " --nomenu %s", p2);
1279   wrap_path_free(p2, command);
1280
1281   dbg("system: \"%s\"\n", tmp_path);
1282
1283   // the app might want the screen too..
1284   fb_thread_pause();
1285   ret = system(tmp_path);
1286   fb_thread_resume();
1287   return ret;
1288 }
1289
1290 int emu_do_execve(const char *filename, char *const argv[], char *const envp[])
1291 {
1292   const char **new_argv;
1293   char *prep_path;
1294   int i, ret, argc;
1295
1296   if (filename == NULL)
1297     return -1;
1298
1299   if (strstr(filename, "/gp2xmenu") != NULL)
1300     exit(0);
1301
1302   for (i = 0; argv[i] != NULL; i++)
1303     ;
1304   argc = i + 1;
1305
1306   new_argv = calloc(argc + 2, sizeof(new_argv[0]));
1307   if (new_argv == NULL)
1308     return -1;
1309
1310   prep_path = malloc(512);
1311   if (prep_path == NULL)
1312     return -1;
1313
1314   make_local_path(prep_path, 512, "ginge_prep");
1315   new_argv[0] = prep_path;
1316   new_argv[1] = "--nomenu";
1317   new_argv[2] = wrap_path(filename);
1318
1319   if (argv[0] != NULL)
1320     for (i = 1; argv[i] != NULL; i++)
1321       new_argv[i + 2] = argv[i];
1322
1323   dbg("execve \"%s\" %s \"%s\"\n", new_argv[0], new_argv[1], new_argv[2]);
1324   ret = execve(new_argv[0], (char **)new_argv, envp);
1325   perror("execve");
1326   return ret;
1327 }
1328