X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=ginge.git;a=blobdiff_plain;f=loader%2Femu.c;h=313bd062b90c65e40517ed5deec2db221773cf86;hp=0d908d7a08615b1c0ad18db7bd40e4edebf33007;hb=f01759de2aca10619ab74e6f2cda92a7799e6234;hpb=7fd42181a7f66b4403076cd9de98e18140a7eaf8 diff --git a/loader/emu.c b/loader/emu.c index 0d908d7..313bd06 100644 --- a/loader/emu.c +++ b/loader/emu.c @@ -1,8 +1,18 @@ -// vim:shiftwidth=2:expandtab +/* + * GINGE - GINGE Is Not Gp2x Emulator + * (C) notaz, 2010-2011,2016 + * + * This work is licensed under the MAME license, see COPYING file for details. + */ +// a "gentle" reminder +#ifdef __ARM_EABI__ +#error loader is meant to be OABI! +#endif #include #include #include #include +#include #include #include #include @@ -11,24 +21,27 @@ #include #include #include -#include #include #include +#include #include #include +#include #include #include +#include #include "header.h" #include "../common/host_fb.h" #include "../common/cmn.h" -#include "sys_cacheflush.h" +#include "syscalls.h" #include "realfuncs.h" +#include "llibc.h" -#if (dbg & 2) +#if (DBG & 2) && !(DBG & 4) #define LOG_IO_UNK #endif -#if (dbg & 4) +#if (DBG & 4) #define LOG_IO #endif //#define LOG_SEGV @@ -46,7 +59,7 @@ #endif #ifdef LOG_SEGV -#define segvlog printf +#define segvlog g_printf #else #define segvlog(...) #endif @@ -55,21 +68,15 @@ #include "mmsp2-regs.h" #endif +typedef unsigned long long u64; typedef unsigned int u32; typedef unsigned short u16; typedef unsigned char u8; -static pthread_mutex_t fb_mutex = PTHREAD_MUTEX_INITIALIZER; -static pthread_cond_t fb_cond = PTHREAD_COND_INITIALIZER; - -struct uppermem_block { - u32 addr; // physical - u32 size; - void *mem; - struct uppermem_block *next; -}; +#define THREAD_STACK_SIZE 0x200000 -static struct uppermem_block *upper_mem; +static int fb_sync_thread_paused; +static int fb_sync_thread_futex; static struct { u32 dstctrl; @@ -95,9 +102,10 @@ static struct { #define CTRL_TRANSPARENCYENB (1 << 11) static struct { + // mmsp2 u16 mlc_stl_cntl; union { - u32 mlc_stl_adr; + u32 mlc_stl_adr; // mlcaddress for pollux struct { u16 mlc_stl_adrl; u16 mlc_stl_adrh; @@ -109,15 +117,26 @@ static struct { u32 mlc_stl_pallt_d32[256]; }; + // pollux + u32 mlccontrol; + u16 mlcpalette[256]; + // state - u16 host_pal[256]; + void *umem; u32 old_mlc_stl_adr; - u32 btn_state; // as seen through /dev/GPIO - u32 dirty_pal:1; + u32 btn_state; // as seen through /dev/GPIO: 0PVdVu YXBA RLSeSt 0Ri0Dn 0Le0Up + struct { + u32 width, height; + u32 stride; + u32 bpp; + u32 dirty_pal:2; + } v; } mmsp2; - -static u16 *host_screen; -static int host_stride; +#define pollux mmsp2 // so that code doesn't look that weird +enum { + DIRTY_PAL_MMSP2 = 1, + DIRTY_PAL_POLLUX = 2, +}; #if defined(LOG_IO) || defined(LOG_IO_UNK) @@ -133,7 +152,7 @@ static void log_io(const char *pfx, u32 a, u32 d, int size) if ((a & ~0xffff) == 0x7f000000) reg = regnames[a & 0xffff]; - printf(fmt, pfx, a, d, reg); + g_printf(fmt, pfx, a, d, reg); } #endif @@ -174,24 +193,20 @@ static void blt_tr(void *dst, void *src, u32 trc, int w) u32 *r = &blitter.dstctrl; \ int i; \ for (i = 0; i < 4*4; i++, r++) { \ - printf("%08x ", *r); \ + g_printf("%08x ", *r); \ if ((i & 3) == 3) \ - printf("\n"); \ + g_printf("\n"); \ } \ } static void *uppermem_lookup(u32 addr, u8 **mem_end) { - struct uppermem_block *ub; - - for (ub = upper_mem; ub != NULL; ub = ub->next) { - if (ub->addr <= addr && addr < ub->addr + ub->size) { - *mem_end = (u8 *)ub->mem + ub->size; - return (u8 *)ub->mem + addr - ub->addr; - } - } + // XXX: maybe support mirroring? + if ((addr & 0xfe000000) != 0x02000000) + return NULL; - return NULL; + *mem_end = (u8 *)mmsp2.umem + 0x02000000; + return (u8 *)mmsp2.umem - 0x02000000 + addr; } static void blitter_do(void) @@ -271,8 +286,10 @@ static void blitter_do(void) } } - if (to_screen) - pthread_cond_signal(&fb_cond); + if (to_screen) { + fb_sync_thread_futex = 1; + g_futex_raw(&fb_sync_thread_futex, FUTEX_WAKE, 1, NULL); + } return; bad_blit: @@ -281,121 +298,100 @@ bad_blit: dump_blitter(); } -// TODO: hw scaler stuff -static void mlc_flip(u8 *src, int bpp) +// FIXME: pass real dimensions to blitters +static void mlc_flip(void *src, int bpp, int stride) { - u16 *dst = host_screen; - u16 *hpal = mmsp2.host_pal; - int i, u; + static int old_bpp; - if (bpp <= 8 && mmsp2.dirty_pal) { - u32 *srcp = mmsp2.mlc_stl_pallt_d32; - u16 *dstp = hpal; + // only pass pal to host if it's dirty + if (bpp <= 8 && mmsp2.v.dirty_pal) { + if (mmsp2.v.dirty_pal == DIRTY_PAL_MMSP2) + host_video_update_pal32(mmsp2.mlc_stl_pallt_d32); + else + host_video_update_pal16(mmsp2.mlcpalette); + mmsp2.v.dirty_pal = 0; + } - for (i = 0; i < 256; i++, srcp++, dstp++) { - u32 t = *srcp; - *dstp = ((t >> 8) & 0xf800) | ((t >> 5) & 0x07e0) | ((t >> 3) & 0x001f); - } - mmsp2.dirty_pal = 0; + if (bpp != old_bpp) { + host_video_change_bpp(bpp); + old_bpp = bpp; } switch (bpp) { case 4: - for (i = 0; i < 240; i++, dst += host_stride / 2 - 320) { - for (u = 320 / 2; u > 0; u--, src++) { - *dst++ = hpal[*src >> 4]; - *dst++ = hpal[*src & 0x0f]; - } - } + host_video_blit4(src, 320, 240, stride); break; case 8: - for (i = 0; i < 240; i++, dst += host_stride / 2 - 320) { - for (u = 320 / 4; u > 0; u--) { - *dst++ = hpal[*src++]; - *dst++ = hpal[*src++]; - *dst++ = hpal[*src++]; - *dst++ = hpal[*src++]; - } - } + host_video_blit8(src, 320, 240, stride); break; case 16: - for (i = 0; i < 240; i++, dst += host_stride / 2, src += 320*2) - memcpy(dst, src, 320*2); + host_video_blit16(src, 320, 240, stride); break; case 24: // TODO break; } - - host_screen = host_video_flip(); -} - -#define ts_add_nsec(ts, ns) { \ - ts.tv_nsec += ns; \ - if (ts.tv_nsec >= 1000000000) { \ - ts.tv_sec++; \ - ts.tv_nsec -= 1000000000; \ - } \ } static void *fb_sync_thread(void *arg) { + unsigned long sigmask[2] = { ~0ul, ~0ul }; + struct timespec ts = { 0, 0 }; int invalid_fb_addr = 1; int manual_refresh = 0; - struct timespec ts; - int ret, wait_ret; + int frame_counter = 0; + int wait_ret; + + // this thread can't run any signal handlers since the + // app's stack/tls stuff will never be set up here + sigmask[0] &= ~(1ul << (SIGSEGV - 1)); + g_rt_sigprocmask_raw(SIG_SETMASK, sigmask, NULL, sizeof(sigmask)); - //ret = pthread_setschedprio(pthread_self(), -1); - //log("pthread_setschedprio %d\n", ret); //ret = setpriority(PRIO_PROCESS, 0, -1); //log("setpriority %d\n", ret); - ret = clock_gettime(CLOCK_REALTIME, &ts); - if (ret != 0) { - perror(PFX "clock_gettime"); - exit(1); - } + // tell the main thread we're done init + fb_sync_thread_futex = 0; + g_futex_raw(&fb_sync_thread_futex, FUTEX_WAKE, 1, NULL); while (1) { u8 *gp2x_fb, *gp2x_fb_end; - int mode, bpp; - ret = pthread_mutex_lock(&fb_mutex); - wait_ret = pthread_cond_timedwait(&fb_cond, &fb_mutex, &ts); - ret |= pthread_mutex_unlock(&fb_mutex); + wait_ret = g_futex_raw(&fb_sync_thread_futex, FUTEX_WAIT, 0, &ts); + + // this is supposed to be done atomically, but to make life + // easier ignore it for now, race impact is low anyway + fb_sync_thread_futex = 0; - if (ret != 0) { - err("fb_thread: mutex error: %d\n", ret); + if (wait_ret != 0 && wait_ret != -EWOULDBLOCK + && wait_ret != -ETIMEDOUT) + { + err("fb_thread: futex error: %d\n", wait_ret); sleep(1); - continue; + goto check_keys; } - if (wait_ret != 0 && wait_ret != ETIMEDOUT) { - err("fb_thread: cond error: %d\n", wait_ret); - sleep(1); - continue; + if (fb_sync_thread_paused) { + ts.tv_nsec = 100000000; + goto check_keys; } - if (wait_ret != ETIMEDOUT) { - clock_gettime(CLOCK_REALTIME, &ts); - ts_add_nsec(ts, 50000000); + if (wait_ret == 0) { + ts.tv_nsec = 50000000; manual_refresh++; if (manual_refresh == 2) - log("fb_thread: switch to manual refresh\n"); + dbg("fb_thread: switch to manual refresh\n"); } else { - ts_add_nsec(ts, 16666667); + ts.tv_nsec = 16666667; if (manual_refresh > 1) - log("fb_thread: switch to auto refresh\n"); + dbg("fb_thread: switch to auto refresh\n"); manual_refresh = 0; } - mode = (mmsp2.mlc_stl_cntl >> 9) & 3; - bpp = mode ? mode * 8 : 4; - gp2x_fb = uppermem_lookup(mmsp2.mlc_stl_adr, &gp2x_fb_end); - if (gp2x_fb == NULL || gp2x_fb + 320*240 * bpp / 8 > gp2x_fb_end) { + if (gp2x_fb == NULL || gp2x_fb + 320*240 * mmsp2.v.bpp / 8 > gp2x_fb_end) { if (!invalid_fb_addr) { err("fb_thread: %08x is out of range\n", mmsp2.mlc_stl_adr); invalid_fb_addr = 1; @@ -403,10 +399,78 @@ static void *fb_sync_thread(void *arg) continue; } - mlc_flip(gp2x_fb, bpp); + invalid_fb_addr = 0; + mlc_flip(gp2x_fb, mmsp2.v.bpp, mmsp2.v.stride); + + frame_counter++; + if (frame_counter & 0x0f) + continue; + +check_keys: + // this is to check for kill key, in case main thread hung + // or something else went wrong. + pollux.btn_state = host_read_btns(); } } +static void fb_thread_pause(void) +{ + fb_sync_thread_paused = 1; + // wait until it finishes last refresh + // that it might be doing now + usleep(10000); +} + +static void fb_thread_resume(void) +{ + fb_sync_thread_paused = 0; +} + +static u32 xread32_io_cmn(u32 a, u32 *handled) +{ + u32 d = 0; + + *handled = 1; + switch (a) { + // Wiz stuff + case 0x402c: // MLCVSTRIDE0 + case 0x4060: // MLCVSTRIDE1 + d = pollux.v.stride; + break; + case 0x4038: // MLCADDRESS0 + case 0x406c: // MLCADDRESS1 + d = pollux.mlc_stl_adr; + break; + // wiz_lib reads: + // ???? ???? YXBA DURiLe ???? VdVuMS LR?? ???? + // | GPIOC[31:16] | GPIOB[31:16] | + case 0xa058: // GPIOBPAD + d = (pollux.btn_state >> 1) & 0x0100; + d |= (pollux.btn_state << 1) & 0x0200; + d |= (pollux.btn_state >> 3) & 0x0080; + d |= (pollux.btn_state >> 5) & 0x0040; + d |= (pollux.btn_state >> 6) & 0x0c00; + d <<= 16; + d = ~d; + break; + case 0xa098: // GPIOCPAD + pollux.btn_state = host_read_btns(); + d = (pollux.btn_state >> 8) & 0x00f0; + d |= (pollux.btn_state >> 1) & 0x0008; + d |= (pollux.btn_state << 2) & 0x0004; + d |= (pollux.btn_state >> 5) & 0x0002; + d |= (pollux.btn_state >> 2) & 0x0001; + d <<= 16; + d = ~d; + break; + default: + *handled = 0; + break; + } + + return d; +} + static u32 xread8(u32 a) { iolog("r8 ", a, 0, 8); @@ -427,8 +491,8 @@ static u32 xread16(u32 a) d = 0x9407; break; // minilib reads as: - // 0000 P000 VuVd00 0000 YXBA RLSeSt 0R0D 0L0U - // | GPIOD |GPIOC[8:15]|GPIOM[0:7]| + // 0000 P000 VuVd00 0000 YXBA RLSeSt 0Ri0D 0Le0U + // | GPIOD |GPIOC[8:15]|GPIOM[0:7] | // /dev/GPIO: // ... 0PVdVu ... case 0x1184: // GPIOC @@ -470,13 +534,19 @@ static u32 xread16(u32 a) case 0x2958: d = mmsp2.mlc_stl_pallt_a; break; + default: - goto unh; + d = xread32_io_cmn(a_, &t); + if (!t) + goto unk; + if (!(a_ & 2)) + d >>= 16; + break; } goto out; } -unh: +unk: if (a == old_a) { d = fudge; fudge = ~fudge; @@ -495,11 +565,26 @@ static u32 xread32(u32 a) u32 d = 0; if ((a & 0xfff00000) == 0x7f000000) { u32 a_ = a & 0xffff; + struct timespec ts; + u64 t64; + u32 t; + switch (a_) { case 0x0a00: // TCOUNT, 1/7372800s - // TODO + g_clock_gettime_raw(CLOCK_REALTIME, &ts); + t64 = (u64)ts.tv_sec * 1000000000 + ts.tv_nsec; + // t * 7372800.0 / 1000000000 * 0x100000000 ~= t * 31665935 + t64 *= 31665935; + d = t64 >> 32; + break; + + default: + d = xread32_io_cmn(a_, &t); + if (!t) + goto unh; break; } + goto out; } if ((a & 0xfff00000) == 0x7f100000) { u32 *bl = &blitter.dstctrl; @@ -511,6 +596,8 @@ static u32 xread32(u32 a) goto out; } } + +unh: iolog_unh("r32", a, d, 32); out: @@ -530,31 +617,40 @@ static void xwrite16(u32 a, u32 d) if ((a & 0xfff00000) == 0x7f000000) { u32 a_ = a & 0xffff; switch (a_) { - case 0x28da: - mmsp2.mlc_stl_cntl = d | 0xaa; - break; - case 0x290e: - case 0x2910: - // odd addresses don't affect LCD. What about TV? - return; - case 0x2912: - mmsp2.mlc_stl_adrl = d; - return; - case 0x2914: - mmsp2.mlc_stl_adrh = d; - if (mmsp2.mlc_stl_adr != mmsp2.old_mlc_stl_adr) - // ask for refresh - pthread_cond_signal(&fb_cond); - mmsp2.old_mlc_stl_adr = mmsp2.mlc_stl_adr; - return; - case 0x2958: - mmsp2.mlc_stl_pallt_a = d & 0x1ff; - return; - case 0x295a: - mmsp2.mlc_stl_pallt_d[mmsp2.mlc_stl_pallt_a++] = d; - mmsp2.mlc_stl_pallt_a &= 0x1ff; - mmsp2.dirty_pal = 1; - return; + case 0x28da: { + int mode; + mmsp2.mlc_stl_cntl = d | 0xaa; + mode = (d >> 9) & 3; + mmsp2.v.bpp = mode ? mode * 8 : 4; + break; + } + case 0x290c: + mmsp2.v.stride = d; + return; + case 0x290e: + case 0x2910: + // odd addresses don't affect LCD. What about TV? + return; + case 0x2912: + mmsp2.mlc_stl_adrl = d; + return; + case 0x2914: + mmsp2.mlc_stl_adrh = d; + if (mmsp2.mlc_stl_adr != mmsp2.old_mlc_stl_adr) { + // ask for refresh + fb_sync_thread_futex = 1; + g_futex_raw(&fb_sync_thread_futex, FUTEX_WAKE, 1, NULL); + } + mmsp2.old_mlc_stl_adr = mmsp2.mlc_stl_adr; + return; + case 0x2958: // MLC_STL_PALLT_A + mmsp2.mlc_stl_pallt_a = d & 0x1ff; + return; + case 0x295a: // MLC_STL_PALLT_D + mmsp2.mlc_stl_pallt_d[mmsp2.mlc_stl_pallt_a++] = d; + mmsp2.mlc_stl_pallt_a &= 0x1ff; + mmsp2.v.dirty_pal = DIRTY_PAL_MMSP2; + return; } } iolog_unh("w16", a, d, 16); @@ -564,6 +660,49 @@ static void xwrite32(u32 a, u32 d) { iolog("w32", a, d, 32); + if ((a & 0xfff00000) == 0x7f000000) { + u32 a_ = a & 0xffff; + switch (a_) { + // GP2X + case 0x295a: // MLC_STL_PALLT_D + // special unaligned 32bit write, allegro seems to rely on it + mmsp2.mlc_stl_pallt_d[mmsp2.mlc_stl_pallt_a++ & 0x1ff] = d; + mmsp2.mlc_stl_pallt_d[mmsp2.mlc_stl_pallt_a++ & 0x1ff] = d >> 16; + mmsp2.mlc_stl_pallt_a &= 0x1ff; + mmsp2.v.dirty_pal = DIRTY_PAL_MMSP2; + return; + // Wiz + case 0x4024: // MLCCONTROL0 + case 0x4058: // MLCCONTROL1 + pollux.mlccontrol = d; + if (!(d & 0x20)) + return; // layer not enabled + if ((d >> 16) == 0x443A) + pollux.v.bpp = 8; + else + pollux.v.bpp = 16; + return; + case 0x402c: // MLCVSTRIDE0 + case 0x4060: // MLCVSTRIDE1 + pollux.v.stride = d; + return; + case 0x4038: // MLCADDRESS0 + case 0x406c: // MLCADDRESS1 + pollux.mlc_stl_adr = d; + if (d != mmsp2.old_mlc_stl_adr) { + // ask for refresh + fb_sync_thread_futex = 1; + g_futex_raw(&fb_sync_thread_futex, FUTEX_WAKE, 1, NULL); + } + mmsp2.old_mlc_stl_adr = d; + return; + case 0x403c: // MLCPALETTE0 + case 0x4070: // MLCPALETTE1 + pollux.mlcpalette[d >> 24] = d; + pollux.v.dirty_pal = DIRTY_PAL_POLLUX; + return; + } + } if ((a & 0xfff00000) == 0x7f100000) { u32 *bl = &blitter.dstctrl; u32 a_ = a & 0xfff; @@ -587,32 +726,60 @@ struct op_context { u32 code[0]; }; -struct linkpage { - u32 saved_regs[15]; - u32 cpsr; - u32 *handler_stack; +struct op_linkpage { void (*handler)(struct op_context *op_ctx); u32 code[0]; }; -static struct linkpage *g_linkpage; +struct op_stackframe { + u32 saved_regs[15]; + u32 cpsr; +}; + +static struct op_linkpage *g_linkpage; static u32 *g_code_ptr; static int g_linkpage_count; -static void *g_handler_stack_end; +enum opcond { + C_EQ, C_NE, C_CS, C_CC, C_MI, C_PL, C_VS, C_VC, + C_HI, C_LS, C_GE, C_LT, C_GT, C_LE, C_AL, +}; +enum cpsr_cond { + CPSR_N = (1u << 31), + CPSR_Z = (1u << 30), + CPSR_C = (1u << 29), + CPSR_V = (1u << 28), +}; #define BIT_SET(v, b) (v & (1 << (b))) -static void handle_op(struct op_context *op_ctx) +void emu_handle_op(struct op_context *op_ctx, struct op_stackframe *sframe) { - u32 *regs = g_linkpage->saved_regs; + u32 *regs = sframe->saved_regs; + u32 cpsr = sframe->cpsr; u32 op = op_ctx->op; u32 t, shift, ret, addr; - int rn, rd; + int i, rn, rd, cond; + cond = (op & 0xf0000000) >> 28; rd = (op & 0x0000f000) >> 12; rn = (op & 0x000f0000) >> 16; + if (cond != 0x0e) { + switch (cond) { + case C_EQ: if ( (cpsr & CPSR_Z)) break; return; + case C_NE: if (!(cpsr & CPSR_Z)) break; return; + case C_CS: if ( (cpsr & CPSR_C)) break; return; + case C_CC: if (!(cpsr & CPSR_C)) break; return; + case C_MI: if ( (cpsr & CPSR_N)) break; return; + case C_PL: if (!(cpsr & CPSR_N)) break; return; + case C_VS: if ( (cpsr & CPSR_V)) break; return; + case C_VC: if (!(cpsr & CPSR_V)) break; return; + default: + goto unhandled; + } + } + if ((op & 0x0f200090) == 0x01000090) { // AM3: LDRH, STRH if (!BIT_SET(op, 5)) // !H goto unhandled; @@ -639,10 +806,12 @@ static void handle_op(struct op_context *op_ctx) else xwrite16(addr, regs[rd]); } - else if ((op & 0x0d200000) == 0x05000000) { // AM2: LDR[B], STR[B] + else if ((op & 0x0c000000) == 0x04000000) { // load/store word/byte + if (BIT_SET(op, 21)) + goto unhandled; // unprivileged if (BIT_SET(op, 25)) { // reg offs if (BIT_SET(op, 4)) - goto unhandled; + goto unhandled; // nah it's media t = regs[op & 0x000f]; shift = (op & 0x0f80) >> 7; @@ -658,7 +827,12 @@ static void handle_op(struct op_context *op_ctx) if (!BIT_SET(op, 23)) t = -t; - addr = regs[rn] + t; + + addr = regs[rn]; + if (BIT_SET(op, 24)) // pre-indexed + addr += t; + if (!BIT_SET(op, 24) || BIT_SET(op, 21)) + regs[rn] += t; // writeback if (BIT_SET(op, 20)) { // Load if (BIT_SET(op, 22)) // Byte @@ -687,6 +861,10 @@ static void handle_op(struct op_context *op_ctx) unhandled: err("unhandled IO op %08x @ %08x\n", op, op_ctx->pc); + for (i = 0; i < 8-1; i++) + err(" r%d=%08x r%-2d=%08x\n", i, regs[i], i+8, regs[i+8]); + err(" r%d=%08x cpsr=%08x\n", i, regs[i], cpsr); + abort(); } static u32 make_offset12(u32 *pc, u32 *target) @@ -732,30 +910,8 @@ static void emit_op_io(u32 op, u32 *target) static void init_linkpage(void) { - g_linkpage->handler = handle_op; - g_linkpage->handler_stack = g_handler_stack_end; + g_linkpage->handler = emu_call_handle_op; g_code_ptr = g_linkpage->code; - - // common_code. - // r0 and r14 must be saved by caller, r0 is arg for handle_op - // on return everything is restored except lr, which is used to return - emit_op_io(0xe50f1000, &g_linkpage->saved_regs[1]); // str r1, [->saved_regs[1]] @ save r1 - emit_op (0xe24f1000 + // sub r1, pc, =offs(saved_regs[2]) - (g_code_ptr - &g_linkpage->saved_regs[2] + 2) * 4); - emit_op (0xe8813ffc); // stmia r1, {r2-r13} - emit_op_io(0xe51fd000, // ldr sp, [->handler_stack] - (u32 *)&g_linkpage->handler_stack); - emit_op (0xe2414008); // sub r4, r1, #4*2 - emit_op (0xe10f1000); // mrs r1, cpsr - emit_op_io(0xe50f1000, &g_linkpage->cpsr); // str r1, [->cpsr] - emit_op (0xe1a0500e); // mov r5, lr - emit_op (0xe1a0e00f); // mov lr, pc - emit_op_io(0xe51ff000, (u32 *)&g_linkpage->handler); // ldr pc, =handle_op - emit_op_io(0xe51f1000, &g_linkpage->cpsr); // ldr r1, [->cpsr] - emit_op (0xe128f001); // msr cpsr_f, r1 - emit_op (0xe1a0e005); // mov lr, r5 - emit_op (0xe8943fff); // ldmia r4, {r0-r13} - emit_op (0xe12fff1e); // bx lr @ return } static void segv_sigaction(int num, siginfo_t *info, void *ctx) @@ -773,7 +929,7 @@ static void segv_sigaction(int num, siginfo_t *info, void *ctx) // real crash - time to die err("segv %d %p @ %08x\n", info->si_code, info->si_addr, regs[15]); for (i = 0; i < 8; i++) - err(" r%d=%08x r%2d=%08x\n", i, regs[i], i+8, regs[i+8]); + dbg(" r%d=%08x r%-2d=%08x\n", i, regs[i], i+8, regs[i+8]); signal(num, SIG_DFL); raise(num); return; @@ -790,12 +946,12 @@ static void segv_sigaction(int num, siginfo_t *info, void *ctx) *pc = make_jmp(pc, g_code_ptr, 0); // generate code: - // TODO: multithreading - emit_op_io(0xe50f0000, &g_linkpage->saved_regs[0]); // str r0, [->saved_regs[0]] @ save r0 - emit_op_io(0xe50fe000, &g_linkpage->saved_regs[14]); // str r14, [->saved_regs[14]] + emit_op (0xe50d0000 + 0xf00 - 4 * 0); // str r0, [sp, #(-0xf00 + r0_offs)] + emit_op (0xe50de000 + 0xf00 - 4 * 14); // str lr, [sp, #(-0xf00 + lr_offs)] emit_op (0xe24f0000 + (g_code_ptr - (u32 *)op_ctx + 2) * 4); // sub r0, pc, #op_ctx - emit_op (make_jmp(g_code_ptr, &g_linkpage->code[0], 1)); // bl common_code - emit_op_io(0xe51fe000, &g_linkpage->saved_regs[14]); // ldr r14, [->saved_regs[14]] + emit_op (0xe1a0e00f); // mov lr, pc + emit_op_io(0xe51ff000, (u32 *)&g_linkpage->handler); // ldr pc, =handle_op + emit_op (0xe51de000 + 0xf00 - 4 * 14); // ldr lr, [sp, #(-0xf00 + lr_offs)] emit_op (make_jmp(g_code_ptr, pc + 1, 0)); // jmp // sync caches @@ -824,18 +980,20 @@ void emu_init(void *map_bottom) .sa_sigaction = segv_sigaction, .sa_flags = SA_SIGINFO, }; - pthread_t tid; void *pret; int ret; - g_handler_stack_end = (void *)((long)alloca(1536 * 1024) & ~0xffff); - log("handler stack @ %p (current %p)\n", g_handler_stack_end, &ret); - // touch it now. If we crash now we'll know why - *((char *)g_handler_stack_end - 4096) = 1; +#ifdef PND + if (geteuid() == 0) { + err("don't try to run as root, device registers or memory " + "might get trashed crashing the OS or even damaging the device.\n"); + exit(1); + } +#endif g_linkpage = (void *)(((u32)map_bottom - LINKPAGE_ALLOC) & ~0xfff); pret = mmap(g_linkpage, LINKPAGE_ALLOC, PROT_READ|PROT_WRITE, - MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); + MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0); if (pret != g_linkpage) { perror(PFX "mmap linkpage"); exit(1); @@ -844,103 +1002,108 @@ void emu_init(void *map_bottom) init_linkpage(); // host stuff - ret = host_video_init(&host_stride, 0); + ret = host_init(); if (ret != 0) { - err("can't init video\n"); + err("can't init host\n"); exit(1); } - host_screen = host_video_flip(); - ret = pthread_create(&tid, NULL, fb_sync_thread, NULL); + ret = host_video_init(NULL, 0); if (ret != 0) { - err("failed to create fb_sync_thread: %d\n", ret); + err("can't init host video\n"); + exit(1); + } + + // TODO: check if this really fails on Wiz.. + mmsp2.umem = mmap(NULL, 0x2000000, PROT_READ|PROT_WRITE|PROT_EXEC, + MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); +#ifdef WIZ + if (mmsp2.umem == MAP_FAILED) { + // we are short on memmory on Wiz, need special handling + extern void *host_mmap_upper(void); + mmsp2.umem = host_mmap_upper(); + } +#endif + if (mmsp2.umem == MAP_FAILED) { + perror(PFX "mmap upper mem"); + exit(1); + } + + pret = mmap(NULL, THREAD_STACK_SIZE, PROT_READ|PROT_WRITE|PROT_EXEC, + MAP_PRIVATE|MAP_ANONYMOUS|MAP_GROWSDOWN, -1, 0); + if (mmsp2.umem == MAP_FAILED) { + perror(PFX "mmap thread stack"); + exit(1); + } + fb_sync_thread_futex = 1; + ret = g_clone(CLONE_VM | CLONE_FS | CLONE_FILES + | CLONE_SIGHAND | CLONE_THREAD, + (char *)pret + THREAD_STACK_SIZE, 0, 0, 0, + fb_sync_thread); + if (ret == 0 || ret == -1) { + perror(PFX "start fb thread"); exit(1); } - pthread_detach(tid); + g_futex_raw(&fb_sync_thread_futex, FUTEX_WAIT, 1, NULL); - // mmsp2 defaults + // defaults mmsp2.mlc_stl_adr = 0x03101000; // fb2 is at 0x03381000 mmsp2.mlc_stl_cntl = 0x4ab; // 16bpp, region 1 active + mmsp2.v.width = 320; + mmsp2.v.height = 240; + mmsp2.v.stride = 320*2; + mmsp2.v.bpp = 16; + mmsp2.v.dirty_pal = 1; sigemptyset(&segv_action.sa_mask); sigaction(SIGSEGV, &segv_action, NULL); } -int emu_read_gpiodev(void *buf, int count) +long emu_read_gpiodev(void *buf, int count) { - unsigned int btns; - - if (count < 4) { + if (count <= 0) { err("gpiodev read %d?\n", count); - return -1; + return -EINVAL; } + if (count > 4) + count = 4; - btns = host_read_btns(); - memcpy(buf, &btns, 4); - return 4; + mmsp2.btn_state = host_read_btns(); + memcpy(buf, &mmsp2.btn_state, count); + return count; } -struct dev_fd_t emu_interesting_fds[] = { - [IFD_SOUND] = { "/dev/dsp", -1 }, - { NULL, 0 }, -}; - -static void *emu_mmap_dev(unsigned int length, int prot, int flags, unsigned int offset) +static long emu_mmap_dev(unsigned int length, int prot, int flags, unsigned int offset) { - struct uppermem_block *umem; - char name[32]; - int fd; + u8 *umem, *umem_end; // SoC regs - if ((offset & ~0xffff) == 0xc0000000) { - return mmap((void *)0x7f000000, length, PROT_NONE, + if ((offset & ~0x1ffff) == 0xc0000000) { + return g_mmap2_raw((void *)0x7f000000, length, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED|MAP_NORESERVE, -1, 0); } - // blitter + // MMSP2 blitter if ((offset & ~0xffff) == 0xe0020000) { - return mmap((void *)0x7f100000, length, PROT_NONE, + return g_mmap2_raw((void *)0x7f100000, length, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED|MAP_NORESERVE, -1, 0); } // upper mem - if ((offset & 0xfe000000) != 0x02000000) + if ((offset & 0xfe000000) != 0x02000000) { err("unexpected devmem mmap @ %08x\n", offset); - - umem = calloc(1, sizeof(*umem)); - if (umem == NULL) { - err("OOM\n"); - return MAP_FAILED; + return -EINVAL; } - umem->addr = offset; - umem->size = length; - umem->mem = mmap(NULL, length, prot, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); - if (umem->mem != MAP_FAILED) - goto done; - - log("upper mem @ %08x %d mmap fail, trying backing file\n", offset, length); - sprintf(name, "m%08x", offset); - fd = open(name, O_CREAT|O_RDWR, 0644); - lseek(fd, length - 1, SEEK_SET); - name[0] = 0; - write(fd, name, 1); - - umem->mem = mmap(NULL, length, prot, MAP_SHARED, fd, 0); - if (umem->mem == MAP_FAILED) { - err("failed, giving up\n"); - close(fd); - free(umem); - errno = EINVAL; - return MAP_FAILED; - } + umem = uppermem_lookup(offset, &umem_end); + if (umem + length > umem_end) + err("warning: uppermem @ %08x overflows by %d bytes\n", + offset, umem + length - umem_end); -done: - log("upper mem @ %08x %d\n", offset, length); - umem->next = upper_mem; - upper_mem = umem; - return umem->mem; + dbg("upper mem @ %08x %x = %p\n", offset, length, umem); + return (long)umem; } -void *emu_do_mmap(unsigned int length, int prot, int flags, int fd, unsigned int offset) +long emu_do_mmap(unsigned int length, int prot, int flags, int fd, + unsigned int offset) { if (fd == FAKEDEV_MEM) return emu_mmap_dev(length, prot, flags, offset); @@ -952,11 +1115,36 @@ void *emu_do_mmap(unsigned int length, int prot, int flags, int fd, unsigned int return emu_mmap_dev(length, prot, flags, offset + 0x03381000); err("bad/ni mmap(?, %d, %x, %x, %d, %08x)\n", length, prot, flags, fd, offset); - errno = EINVAL; - return MAP_FAILED; + return -EINVAL; +} + +long emu_do_munmap(void *addr, unsigned int length) +{ + u8 *p = addr; + + // don't allow to unmap upper mem + if ((u8 *)mmsp2.umem <= p && p < (u8 *)mmsp2.umem + 0x2000000) { + dbg("ignoring munmap: %p %x\n", addr, length); + return 0; + } + + return -EAGAIN; } -static int emu_sound_ioctl(int fd, int request, void *argp) +static void emu_sound_open(int fd) +{ +#ifdef PND + int ret, frag; + + // set default buffer size to 16 * 1K + frag = (16<<16) | 10; // 16K + ret = g_ioctl_raw(fd, SNDCTL_DSP_SETFRAGMENT, &frag); + if (ret != 0) + err("snd ioctl SETFRAGMENT %08x: %d\n", frag, ret); +#endif +} + +static long emu_sound_ioctl(int fd, int request, void *argp) { int *arg = argp; @@ -970,29 +1158,53 @@ static int emu_sound_ioctl(int fd, int request, void *argp) /* People set strange frag settings on GP2X, which even manage * to break audio on pandora (causes writes to fail). * Catch this and set to something that works. */ - if (request == SNDCTL_DSP_SPEED) { - int ret, bsize, frag; - - // ~4ms. gpSP wants small buffers or else it stutters - // because of it's audio thread sync stuff - bsize = *arg / 250 * 4; - for (frag = 0; bsize; bsize >>= 1, frag++) - ; - - frag |= 16 << 16; // fragment count - ret = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &frag); - if (ret != 0) { - err("snd ioctl SETFRAGMENT %08x: ", frag); - perror(NULL); + switch(request) { + case SNDCTL_DSP_SETFRAGMENT: { + int bsize, frag, frag_cnt; + long ret; + + if (arg == NULL) + break; + + frag = *arg & 0xffff; + frag_cnt = *arg >> 16; + bsize = frag_cnt << frag; + if (frag < 10 || bsize < 4096*4 || bsize > 4096*4*2) { + /* + * ~4ms. gpSP wants small buffers or else it stutters + * because of it's audio thread sync stuff + * XXX: hardcoding, as low samplerates will result in small fragment size, + * which itself causes ALSA stall and hangs the program. + * Also some apps change samplerate without reopening /dev/dsp, + * which causes ALSA to reject SNDCTL_DSP_SETFRAGMENT. + */ + bsize = 44100 / 250 * 4; + + for (frag = 0; bsize; bsize >>= 1, frag++) + ; + + frag_cnt = 16; + } + + frag |= frag_cnt << 16; + ret = g_ioctl_raw(fd, SNDCTL_DSP_SETFRAGMENT, &frag); + if (ret != 0) + err("snd ioctl SETFRAGMENT %08x: %ld\n", frag, ret); + // indicate success even if we fail (because of ALSA mostly), + // things like MikMod will bail out otherwise. + return 0; } + case SNDCTL_DSP_SYNC: + // Franxis tends to use sync/write loops, bad idea under ALSA + return 0; + default: + break; } - else if (request == SNDCTL_DSP_SETFRAGMENT) - return 0; - return ioctl(fd, request, argp); + return g_ioctl_raw(fd, request, argp); } -int emu_do_ioctl(int fd, int request, void *argp) +long emu_do_ioctl(int fd, int request, void *argp) { if (fd == emu_interesting_fds[IFD_SOUND].fd) return emu_sound_ioctl(fd, request, argp); @@ -1058,60 +1270,144 @@ int emu_do_ioctl(int fd, int request, void *argp) fail: err("bad/ni ioctl(%d, %08x, %p)\n", fd, request, argp); - errno = EINVAL; - return -1; + return -EINVAL; } +struct dev_fd_t emu_interesting_fds[] = { + [IFD_SOUND] = { "/dev/dsp", -1, emu_sound_open }, + { NULL, 0, NULL }, +}; + static const struct { const char *from; const char *to; } path_map[] = { - { "/mnt/tmp/", "/tmp/" }, + { "/mnt/tmp", "./tmp" }, }; -// FIXME: threads.. static const char *wrap_path(const char *path) { - static char tmp_path[512]; + char *buff, *p; + size_t size; int i, len; // do only path mapping for now for (i = 0; i < ARRAY_SIZE(path_map); i++) { - len = strlen(path_map[i].from); - if (strncmp(path, path_map[i].from, len) == 0) { - snprintf(tmp_path, sizeof(tmp_path), "%s%s", path_map[i].to, path + len); - dbg("mapped path \"%s\" -> \"%s\"\n", path, tmp_path); - return tmp_path; + p = strstr(path, path_map[i].from); + if (p != NULL) { + size = strlen(path) + strlen(path_map[i].to) + 1; + buff = malloc(size); + if (buff == NULL) + break; + len = p - path; + strncpy(buff, path, len); + snprintf(buff + len, size - len, "%s%s", path_map[i].to, + path + len + strlen(path_map[i].from)); + dbg("mapped path \"%s\" -> \"%s\"\n", path, buff); + return buff; } } return path; } +static void wrap_path_free(const char *w_path, const char *old_path) +{ + if (w_path != old_path) + free((void *)w_path); +} + void *emu_do_fopen(const char *path, const char *mode) { - return fopen(wrap_path(path), mode); + const char *w_path; + FILE *ret; + + w_path = wrap_path(path); + ret = fopen(w_path, mode); + wrap_path_free(w_path, path); + + return ret; } +// FIXME: threads.. int emu_do_system(const char *command) { static char tmp_path[512]; - char *p, *p2; + int need_ginge = 0; + const char *p2; + char *p; + int ret; if (command == NULL) return -1; - // pass through stuff in PATH - p = strchr(command, ' '); - p2 = strchr(command, '/'); - if (p2 == NULL || (p != NULL && p2 > p)) - return system(command); + for (p2 = command; *p2 && isspace(*p2); p2++) + ; + + if (*p2 == '.') // relative path? + need_ginge = 1; + else if (*p2 == '/' && strncmp(p2, "/bin", 4) && strncmp(p2, "/lib", 4) + && strncmp(p2, "/sbin", 4) && strncmp(p2, "/usr", 4)) + // absolute path, but not a system command + need_ginge = 1; - make_local_path(tmp_path, sizeof(tmp_path), "ginge_prep"); - p = tmp_path + strlen(tmp_path); + p2 = wrap_path(command); + if (need_ginge) { + make_local_path(tmp_path, sizeof(tmp_path), "ginge_prep"); + p = tmp_path + strlen(tmp_path); + + snprintf(p, sizeof(tmp_path) - (p - tmp_path), " --nomenu %s", p2); + } + else + snprintf(tmp_path, sizeof(tmp_path), "%s", p2); + wrap_path_free(p2, command); - snprintf(p, sizeof(tmp_path) - (p - tmp_path), " %s", wrap_path(command)); dbg("system: \"%s\"\n", tmp_path); - return system(tmp_path); + + // the app might want the screen too.. + fb_thread_pause(); + ret = system(tmp_path); + fb_thread_resume(); + return ret; +} + +int emu_do_execve(const char *filename, char *const argv[], char *const envp[]) +{ + const char **new_argv; + char *prep_path; + int i, ret, argc; + + if (filename == NULL) + return -1; + + if (strstr(filename, "/gp2xmenu") != NULL) + exit(0); + + for (i = 0; argv[i] != NULL; i++) + ; + argc = i + 1; + + new_argv = calloc(argc + 2, sizeof(new_argv[0])); + if (new_argv == NULL) + return -1; + + prep_path = malloc(512); + if (prep_path == NULL) + return -1; + + make_local_path(prep_path, 512, "ginge_prep"); + new_argv[0] = prep_path; + new_argv[1] = "--nomenu"; + new_argv[2] = wrap_path(filename); + + if (argv[0] != NULL) + for (i = 1; argv[i] != NULL; i++) + new_argv[i + 2] = argv[i]; + + dbg("execve \"%s\" %s \"%s\"\n", new_argv[0], new_argv[1], new_argv[2]); + ret = execve(new_argv[0], (char **)new_argv, envp); + perror("execve"); + return ret; } +// vim:shiftwidth=2:expandtab