static int fb_sync_thread_paused;
static int fb_sync_thread_futex;
+static int emu_is_dl;
+
static struct {
u32 dstctrl;
u32 dstaddr;
&& wait_ret != -ETIMEDOUT)
{
err("fb_thread: futex error: %d\n", wait_ret);
- g_sleep(1);
+ sleep(1);
goto check_keys;
}
if (fb_sync_thread_paused) {
static u32 xread32_io_cmn(u32 a, u32 *handled)
{
+ struct timespec ts;
u32 d = 0;
*handled = 1;
switch (a) {
// Wiz stuff
+ case 0x1980: // TIMER3 TMRCOUNT
+ // assume the timer is set up for microsec time
+ g_clock_gettime_raw(CLOCK_REALTIME, &ts);
+ d = ts.tv_sec * 1000000 + ((u64)(u32)ts.tv_nsec * 4294968 >> 32);
+ break;
case 0x402c: // MLCVSTRIDE0
case 0x4060: // MLCVSTRIDE1
d = pollux.v.stride;
}
mmsp2.old_mlc_stl_adr = mmsp2.mlc_stl_adr;
return;
- case 0x2958:
+ case 0x2958: // MLC_STL_PALLT_A
mmsp2.mlc_stl_pallt_a = d & 0x1ff;
return;
- case 0x295a:
+ 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;
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
};
struct op_linkpage {
+ u32 *code_ptr;
void (*handler)(struct op_context *op_ctx);
u32 code[0];
};
u32 cpsr;
};
-static struct op_linkpage *g_linkpage;
-static u32 *g_code_ptr;
+static struct op_linkpage *g_linkpages[2];
static int g_linkpage_count;
enum opcond {
int jmp_val;
jmp_val = target - pc - 2;
- if (jmp_val < (int)0xff000000 || jmp_val > 0x00ffffff) {
+ if (jmp_val < (int)0xff800000 || jmp_val > 0x007fffff) {
err("jump out of range (%p -> %p)\n", pc, target);
abort();
}
return 0xea000000 | (bl << 24) | (jmp_val & 0x00ffffff);
}
-static void emit_op(u32 op)
+static void emit_op(struct op_linkpage *linkpage, u32 op)
{
- *g_code_ptr++ = op;
+ *linkpage->code_ptr++ = op;
}
-static void emit_op_io(u32 op, u32 *target)
+static void emit_op_io(struct op_linkpage *linkpage,
+ u32 op, u32 *target)
{
- op |= make_offset12(g_code_ptr, target);
- emit_op(op);
+ op |= make_offset12(linkpage->code_ptr, target);
+ emit_op(linkpage, op);
}
-static void init_linkpage(void)
+static void init_linkpage(struct op_linkpage *linkpage)
{
- g_linkpage->handler = emu_call_handle_op;
- g_code_ptr = g_linkpage->code;
+ linkpage->handler = emu_call_handle_op;
+ linkpage->code_ptr = linkpage->code;
}
static void segv_sigaction(int num, siginfo_t *info, void *ctx)
{
+ extern char _init, _end;
struct ucontext *context = ctx;
u32 *regs = (u32 *)&context->uc_mcontext.arm_r0;
u32 *pc = (u32 *)regs[15];
+ u32 self_start, self_end;
+ struct op_linkpage *lp = NULL;
struct op_context *op_ctx;
- int i, lp_size;
+ int i, ret, lp_i, lp_size;
+
+ self_start = (u32)&_init & ~0xfff;
+ self_end = (u32)&_end;
- if (((regs[15] ^ (u32)&segv_sigaction) & 0xff000000) == 0 || // PC is in our segment or
- (((regs[15] ^ (u32)g_linkpage) & ~(LINKPAGE_ALLOC - 1)) == 0) || // .. in linkpage
- ((long)info->si_addr & 0xffe00000) != 0x7f000000) // faulting not where expected
+ if ((self_start <= regs[15] && regs[15] <= self_end) || // PC is in our segment or
+ !((regs[15] ^ (u32)g_linkpages[0]) & ~(LINKPAGE_ALLOC - 1)) || // .. in linkpage
+ ((long)info->si_addr & 0xffe00000) != 0x7f000000) // faulting not where expected
{
// real crash - time to die
err("segv %d %p @ %08x\n", info->si_code, info->si_addr, regs[15]);
}
segvlog("segv %d %p @ %08x\n", info->si_code, info->si_addr, regs[15]);
+ // find nearby linkpage
+ for (lp_i = 0; lp_i < ARRAY_SIZE(g_linkpages); lp_i++) {
+ if (g_linkpages[lp_i] == NULL)
+ continue;
+ i = g_linkpages[lp_i]->code_ptr + 2 - pc - 2;
+ if ((int)0xff800000 <= i && i <= 0x007fffff) {
+ lp = g_linkpages[lp_i];
+ break;
+ }
+ }
+
+ if (lp == NULL) {
+ err("fatal: no nearby linkpage for %08x\n", regs[15]);
+ abort();
+ }
+
+ if (emu_is_dl) {
+ ret = mprotect((void *)((long)pc & ~0xfff), 0x1000, PROT_READ|PROT_WRITE|PROT_EXEC);
+ if (ret != 0)
+ perror("warning: mprotect");
+ }
+
// spit PC and op
- op_ctx = (void *)g_code_ptr;
+ op_ctx = (void *)lp->code_ptr;
op_ctx->pc = (u32)pc;
op_ctx->op = *pc;
- g_code_ptr = &op_ctx->code[0];
+ lp->code_ptr = &op_ctx->code[0];
// emit jump to code ptr
- *pc = make_jmp(pc, g_code_ptr, 0);
+ *pc = make_jmp(pc, lp->code_ptr, 0);
// generate code:
- 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 (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 <back>
+ emit_op (lp, 0xe50d0000 + 0xf00 - 4 * 0); // str r0, [sp, #(-0xf00 + r0_offs)]
+ emit_op (lp, 0xe50de000 + 0xf00 - 4 * 14); // str lr, [sp, #(-0xf00 + lr_offs)]
+ emit_op (lp, 0xe24f0000 + (lp->code_ptr - (u32 *)op_ctx + 2) * 4); // sub r0, pc, #op_ctx
+ emit_op (lp, 0xe1a0e00f); // mov lr, pc
+ emit_op_io(lp, 0xe51ff000, (u32 *)&lp->handler); // ldr pc, =handle_op
+ emit_op (lp, 0xe51de000 + 0xf00 - 4 * 14); // ldr lr, [sp, #(-0xf00 + lr_offs)]
+ emit_op (lp, make_jmp(lp->code_ptr, pc + 1, 0)); // jmp <back>
// sync caches
sys_cacheflush(pc, pc + 1);
- sys_cacheflush(g_linkpage, g_code_ptr);
+ sys_cacheflush(lp, lp->code_ptr);
- lp_size = (char *)g_code_ptr - (char *)g_linkpage;
+ lp_size = (char *)lp->code_ptr - (char *)lp;
segvlog("code #%d %d/%d\n", g_linkpage_count, lp_size, LINKPAGE_SIZE);
- if (lp_size + 13*4 > LINKPAGE_SIZE) {
+ if (lp_size + 14*4 > LINKPAGE_SIZE) {
g_linkpage_count++;
if (g_linkpage_count >= LINKPAGE_COUNT) {
err("too many linkpages needed\n");
abort();
}
- g_linkpage = (void *)((char *)g_linkpage + LINKPAGE_SIZE);
- init_linkpage();
+ g_linkpages[lp_i] = (void *)((char *)g_linkpages[lp_i] + LINKPAGE_SIZE);
+ init_linkpage(g_linkpages[lp_i]);
}
//handle_op(regs[15], op, regs, (u32)info->si_addr);
//regs[15] += 4;
}
-void emu_init(void *map_bottom)
+void emu_init(void *map_bottom[2], int is_dl)
{
sigaction_t segv_action = {
.sa_sigaction = segv_sigaction,
.sa_flags = SA_SIGINFO,
};
void *pret;
- int ret;
+ int i, ret;
#ifdef PND
if (geteuid() == 0) {
- fprintf(stderr, "don't try to run as root, device registers or memory "
- "might get trashed crashing the OS or even damaging the device.\n");
+ 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|MAP_FIXED, -1, 0);
- if (pret != g_linkpage) {
- perror(PFX "mmap linkpage");
- exit(1);
+ emu_is_dl = is_dl;
+
+ for (i = 0; i < 2; i++) {
+ if (map_bottom[i] == NULL)
+ continue;
+ g_linkpages[i] = (void *)(((u32)map_bottom[i] - LINKPAGE_ALLOC) & ~0xfff);
+ pret = mmap(g_linkpages[i], LINKPAGE_ALLOC, PROT_READ|PROT_WRITE,
+ MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
+ if (pret != g_linkpages[i]) {
+ err("linkpage alloc @ %p: ", g_linkpages[i]);
+ perror(NULL);
+ exit(1);
+ }
+ log("linkpages @ %p\n", g_linkpages[i]);
+ init_linkpage(g_linkpages[i]);
}
- log("linkpages @ %p\n", g_linkpage);
- init_linkpage();
// host stuff
ret = host_init();
sigaction(SIGSEGV, &segv_action, NULL);
}
-int emu_read_gpiodev(void *buf, int count)
-{
- if (count <= 0) {
- err("gpiodev read %d?\n", count);
- return -1;
- }
- if (count > 4)
- count = 4;
-
- mmsp2.btn_state = host_read_btns();
- memcpy(buf, &mmsp2.btn_state, count);
- return count;
-}
-
-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)
{
u8 *umem, *umem_end;
// SoC regs
if ((offset & ~0x1ffff) == 0xc0000000) {
- return mmap((void *)0x7f000000, length, PROT_NONE,
+ return g_mmap2_raw((void *)0x7f000000, length, PROT_NONE,
MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED|MAP_NORESERVE, -1, 0);
}
// 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) {
err("unexpected devmem mmap @ %08x\n", offset);
- errno = EINVAL;
- return MAP_FAILED;
+ return -EINVAL;
}
umem = uppermem_lookup(offset, &umem_end);
offset, umem + length - umem_end);
dbg("upper mem @ %08x %x = %p\n", offset, length, umem);
- return 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);
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;
}
-int emu_do_munmap(void *addr, unsigned int length)
+long emu_do_munmap(void *addr, unsigned int length)
{
u8 *p = addr;
// set default buffer size to 16 * 1K
frag = (16<<16) | 10; // 16K
- ret = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &frag);
- if (ret != 0) {
- err("snd ioctl SETFRAGMENT %08x: ", frag);
- perror(NULL);
- }
+ ret = g_ioctl_raw(fd, SNDCTL_DSP_SETFRAGMENT, &frag);
+ if (ret != 0)
+ err("snd ioctl SETFRAGMENT %08x: %d\n", frag, ret);
#endif
}
-static int emu_sound_ioctl(int fd, int request, void *argp)
+static long emu_sound_ioctl(int fd, int request, void *argp)
{
int *arg = argp;
* Catch this and set to something that works. */
switch(request) {
case SNDCTL_DSP_SETFRAGMENT: {
- int ret, bsize, frag, frag_cnt;
+ int bsize, frag, frag_cnt;
+ long ret;
+
if (arg == NULL)
break;
}
frag |= frag_cnt << 16;
- ret = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &frag);
- if (ret != 0) {
- err("snd ioctl SETFRAGMENT %08x: ", frag);
- perror(NULL);
- }
+ 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;
break;
}
- 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);
fail:
err("bad/ni ioctl(%d, %08x, %p)\n", fd, request, argp);
- errno = EINVAL;
- return -1;
+ return -EINVAL;
+}
+
+static const char wm97xx_p[] =
+ "5507 0 -831476 0 -4218 16450692 65536"; // from 4.0 fw
+
+long emu_do_read(int fd, void *buf, int count)
+{
+ int ret, pressed = 0, x, y;
+ struct {
+ u16 pressure, x, y;
+ } wm97xx;
+
+ if (count < 0) {
+ err("read(%d, %d)\n", fd, count);
+ return -EINVAL;
+ }
+
+ switch (fd) {
+ case FAKEDEV_GPIO:
+ mmsp2.btn_state = host_read_btns();
+
+ if (count > 4)
+ count = 4;
+ memcpy(buf, &mmsp2.btn_state, count);
+ break;
+ case FAKEDEV_WM97XX:
+ ret = host_read_ts(&pressed, &x, &y);
+ if (ret == 0 && pressed) {
+ wm97xx.pressure = 0x8001; // TODO: check the real thing
+ wm97xx.x = x * 3750 / 1024 + 200;
+ wm97xx.y = 3750 - y * 3750 / 1024 + 200;
+ }
+ else {
+ wm97xx.pressure = 0;
+ wm97xx.x = wm97xx.y = 200;
+ }
+
+ if (count > sizeof(wm97xx))
+ count = sizeof(wm97xx);
+ memcpy(buf, &wm97xx, count);
+ break;
+ case FAKEDEV_WM97XX_P:
+ if (count < sizeof(wm97xx_p))
+ err("incomplete pointercal read\n");
+ strncpy(buf, wm97xx_p, count);
+ break;
+ default:
+ dbg("read(%d, %d)\n", fd, count);
+ return -EINVAL;
+ }
+ return count;
}
struct dev_fd_t emu_interesting_fds[] = {
const char *to;
} path_map[] = {
{ "/mnt/tmp", "./tmp" },
+ { "/mnt/sd", "./mntsd" },
};
-static const char *wrap_path(const char *path)
+const char *emu_wrap_path(const char *path)
{
char *buff, *p;
size_t size;
int i, len;
+ long ret;
// do only path mapping for now
for (i = 0; i < ARRAY_SIZE(path_map); i++) {
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);
+
+ ret = g_mkdir_raw(path_map[i].to, 0666);
+ if (ret != 0 && ret != -EEXIST)
+ err("mkdir(%s): %ld\n", path_map[i].to, ret);
+
return buff;
}
}
return path;
}
-static void wrap_path_free(const char *w_path, const char *old_path)
+void emu_wrap_path_free(const char *w_path, const char *old_path)
{
if (w_path != old_path)
free((void *)w_path);
const char *w_path;
FILE *ret;
- w_path = wrap_path(path);
- ret = fopen(w_path, mode);
- wrap_path_free(w_path, path);
+ if (strcmp(path, "/etc/pointercal") == 0) {
+ // use local pontercal, not host's
+ ret = fopen("pointercal", mode);
+ if (ret == NULL) {
+ ret = fopen("pointercal", "w");
+ if (ret != NULL) {
+ fwrite(wm97xx_p, 1, sizeof(wm97xx_p), ret);
+ fclose(ret);
+ }
+ ret = fopen("pointercal", mode);
+ }
+ }
+ else {
+ w_path = emu_wrap_path(path);
+ ret = fopen(w_path, mode);
+ emu_wrap_path_free(w_path, path);
+ }
return ret;
}
// absolute path, but not a system command
need_ginge = 1;
- p2 = wrap_path(command);
+ p2 = emu_wrap_path(command);
if (need_ginge) {
make_local_path(tmp_path, sizeof(tmp_path), "ginge_prep");
p = tmp_path + strlen(tmp_path);
}
else
snprintf(tmp_path, sizeof(tmp_path), "%s", p2);
- wrap_path_free(p2, command);
+ emu_wrap_path_free(p2, command);
dbg("system: \"%s\"\n", tmp_path);
return ret;
}
-int emu_do_execve(const char *filename, char *const argv[], char *const envp[])
+long emu_do_execve(const char *filename, char * const argv[],
+ char * const envp[])
{
const char **new_argv;
char *prep_path;
- int i, ret, argc;
+ int i, argc;
+ long ret;
if (filename == NULL)
return -1;
- if (strstr(filename, "/gp2xmenu") != NULL)
- exit(0);
+ if (strstr(filename, "gp2xmenu") != NULL)
+ host_forced_exit(0);
for (i = 0; argv[i] != NULL; i++)
;
make_local_path(prep_path, 512, "ginge_prep");
new_argv[0] = prep_path;
new_argv[1] = "--nomenu";
- new_argv[2] = wrap_path(filename);
+ new_argv[2] = emu_wrap_path(filename);
if (argv[0] != NULL)
for (i = 1; argv[i] != NULL; 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");
+ err("execve(%s): %ld\n", new_argv[0], ret);
return ret;
}
notaz.gp2x.de / ginge.git / blobdiff