From: Mika Laitio Date: Fri, 10 Nov 2006 15:16:56 +0000 (+0200) Subject: updated to qemu 0.82 from oe.dev to familiar with patches to enable building with... X-Git-Url: http://pilppa.org/gitweb/?a=commitdiff_plain;h=8c5e4f89c83f82a1b99e06b5d781a52753423a39;p=familiar-h63xx-build.git updated to qemu 0.82 from oe.dev to familiar with patches to enable building with gcc 4.x --- diff --git a/org.handhelds.familiar/packages/qemu/files/arm_nptl.patch b/org.handhelds.familiar/packages/qemu/files/arm_nptl.patch new file mode 100644 index 0000000..f9b10ae --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/arm_nptl.patch @@ -0,0 +1,857 @@ +Index: qemu/configure +=================================================================== +--- qemu.orig/configure 2006-08-26 16:31:53.000000000 +0100 ++++ qemu/configure 2006-08-26 16:31:53.000000000 +0100 +@@ -97,6 +97,7 @@ + build_docs="no" + build_acpi_tables="no" + uname_release="" ++nptl="yes" + + # OS specific + targetos=`uname -s` +@@ -243,6 +244,8 @@ + ;; + --enable-iasl) build_acpi_tables="yes" + ;; ++ --disable-nptl) nptl="no" ++ ;; + esac + done + +@@ -441,6 +444,23 @@ + fi + fi + ++# check NPTL support ++cat > $TMPC < ++void foo() ++{ ++#ifndef CLONE_SETTLS ++#error bork ++#endif ++} ++EOF ++ ++if $cc -c -o $TMPO $TMPC 2> /dev/null ; then ++ : ++else ++ nptl="no" ++fi ++ + ########################################## + # SDL probe + +@@ -559,6 +579,7 @@ + fi + echo "FMOD support $fmod $fmod_support" + echo "kqemu support $kqemu" ++echo "NPTL support $nptl" + echo "Documentation $build_docs" + [ ! -z "$uname_release" ] && \ + echo "uname -r $uname_release" +@@ -880,6 +901,14 @@ + echo "SDL_CFLAGS=`$sdl_config --cflags`" >> $config_mak + fi + fi ++else ++ if test "$nptl" = "yes" ; then ++ case "$target_cpu" in ++ arm | armeb) ++ echo "#define USE_NPTL 1" >> $config_h ++ ;; ++ esac ++ fi + fi + + if test "$cocoa" = "yes" ; then +Index: qemu/exec-all.h +=================================================================== +--- qemu.orig/exec-all.h 2006-08-26 16:28:32.000000000 +0100 ++++ qemu/exec-all.h 2006-08-26 16:31:53.000000000 +0100 +@@ -347,163 +347,7 @@ + extern CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4]; + extern void *io_mem_opaque[IO_MEM_NB_ENTRIES]; + +-#ifdef __powerpc__ +-static inline int testandset (int *p) +-{ +- int ret; +- __asm__ __volatile__ ( +- "0: lwarx %0,0,%1\n" +- " xor. %0,%3,%0\n" +- " bne 1f\n" +- " stwcx. %2,0,%1\n" +- " bne- 0b\n" +- "1: " +- : "=&r" (ret) +- : "r" (p), "r" (1), "r" (0) +- : "cr0", "memory"); +- return ret; +-} +-#endif +- +-#ifdef __i386__ +-static inline int testandset (int *p) +-{ +- long int readval = 0; +- +- __asm__ __volatile__ ("lock; cmpxchgl %2, %0" +- : "+m" (*p), "+a" (readval) +- : "r" (1) +- : "cc"); +- return readval; +-} +-#endif +- +-#ifdef __x86_64__ +-static inline int testandset (int *p) +-{ +- long int readval = 0; +- +- __asm__ __volatile__ ("lock; cmpxchgl %2, %0" +- : "+m" (*p), "+a" (readval) +- : "r" (1) +- : "cc"); +- return readval; +-} +-#endif +- +-#ifdef __s390__ +-static inline int testandset (int *p) +-{ +- int ret; +- +- __asm__ __volatile__ ("0: cs %0,%1,0(%2)\n" +- " jl 0b" +- : "=&d" (ret) +- : "r" (1), "a" (p), "0" (*p) +- : "cc", "memory" ); +- return ret; +-} +-#endif +- +-#ifdef __alpha__ +-static inline int testandset (int *p) +-{ +- int ret; +- unsigned long one; +- +- __asm__ __volatile__ ("0: mov 1,%2\n" +- " ldl_l %0,%1\n" +- " stl_c %2,%1\n" +- " beq %2,1f\n" +- ".subsection 2\n" +- "1: br 0b\n" +- ".previous" +- : "=r" (ret), "=m" (*p), "=r" (one) +- : "m" (*p)); +- return ret; +-} +-#endif +- +-#ifdef __sparc__ +-static inline int testandset (int *p) +-{ +- int ret; +- +- __asm__ __volatile__("ldstub [%1], %0" +- : "=r" (ret) +- : "r" (p) +- : "memory"); +- +- return (ret ? 1 : 0); +-} +-#endif +- +-#ifdef __arm__ +-static inline int testandset (int *spinlock) +-{ +- register unsigned int ret; +- __asm__ __volatile__("swp %0, %1, [%2]" +- : "=r"(ret) +- : "0"(1), "r"(spinlock)); +- +- return ret; +-} +-#endif +- +-#ifdef __mc68000 +-static inline int testandset (int *p) +-{ +- char ret; +- __asm__ __volatile__("tas %1; sne %0" +- : "=r" (ret) +- : "m" (p) +- : "cc","memory"); +- return ret; +-} +-#endif +- +-#ifdef __ia64 +-#include +- +-static inline int testandset (int *p) +-{ +- return __sync_lock_test_and_set (p, 1); +-} +-#endif +- +-typedef int spinlock_t; +- +-#define SPIN_LOCK_UNLOCKED 0 +- +-#if defined(CONFIG_USER_ONLY) +-static inline void spin_lock(spinlock_t *lock) +-{ +- while (testandset(lock)); +-} +- +-static inline void spin_unlock(spinlock_t *lock) +-{ +- *lock = 0; +-} +- +-static inline int spin_trylock(spinlock_t *lock) +-{ +- return !testandset(lock); +-} +-#else +-static inline void spin_lock(spinlock_t *lock) +-{ +-} +- +-static inline void spin_unlock(spinlock_t *lock) +-{ +-} +- +-static inline int spin_trylock(spinlock_t *lock) +-{ +- return 1; +-} +-#endif ++#include "qemu_spinlock.h" + + extern spinlock_t tb_lock; + +Index: qemu/linux-user/arm/syscall.h +=================================================================== +--- qemu.orig/linux-user/arm/syscall.h 2006-03-09 19:18:11.000000000 +0000 ++++ qemu/linux-user/arm/syscall.h 2006-08-26 16:31:53.000000000 +0100 +@@ -28,7 +28,9 @@ + #define ARM_SYSCALL_BASE 0x900000 + #define ARM_THUMB_SYSCALL 0 + +-#define ARM_NR_cacheflush (ARM_SYSCALL_BASE + 0xf0000 + 2) ++#define ARM_NR_BASE 0xf0000 ++#define ARM_NR_cacheflush (ARM_NR_BASE + 2) ++#define ARM_NR_set_tls (ARM_NR_BASE + 5) + + #define ARM_NR_semihosting 0x123456 + #define ARM_NR_thumb_semihosting 0xAB +Index: qemu/linux-user/main.c +=================================================================== +--- qemu.orig/linux-user/main.c 2006-08-26 16:28:40.000000000 +0100 ++++ qemu/linux-user/main.c 2006-08-26 16:31:53.000000000 +0100 +@@ -309,6 +309,50 @@ + } + } + ++/* Handle a jump to the kernel code page. */ ++static int ++do_kernel_trap(CPUARMState *env) ++{ ++ uint32_t addr; ++ uint32_t *ptr; ++ uint32_t cpsr; ++ ++ switch (env->regs[15]) { ++ case 0xffff0fc0: /* __kernel_cmpxchg */ ++ /* XXX: This only works between threads, not between processes. ++ Use native atomic operations. */ ++ /* ??? This probably breaks horribly if the access segfaults. */ ++ cpu_lock(); ++ ptr = (uint32_t *)env->regs[2]; ++ cpsr = cpsr_read(env); ++ if (*ptr == env->regs[0]) { ++ *ptr = env->regs[1]; ++ env->regs[0] = 0; ++ cpsr |= CPSR_C; ++ } else { ++ env->regs[0] = -1; ++ cpsr &= ~CPSR_C; ++ } ++ cpsr_write(env, cpsr, CPSR_C); ++ cpu_unlock(); ++ break; ++ case 0xffff0fe0: /* __kernel_get_tls */ ++ env->regs[0] = env->cp15.c13_tls; ++ break; ++ default: ++ return 1; ++ } ++ /* Jump back to the caller. */ ++ addr = env->regs[14]; ++ if (addr & 1) { ++ env->thumb = 1; ++ addr &= ~1; ++ } ++ env->regs[15] = addr; ++ ++ return 0; ++} ++ + void cpu_loop(CPUARMState *env) + { + int trapnr; +@@ -365,10 +409,8 @@ + } + } + +- if (n == ARM_NR_cacheflush) { +- arm_cache_flush(env->regs[0], env->regs[1]); +- } else if (n == ARM_NR_semihosting +- || n == ARM_NR_thumb_semihosting) { ++ if (n == ARM_NR_semihosting ++ || n == ARM_NR_thumb_semihosting) { + env->regs[0] = do_arm_semihosting (env); + } else if (n == 0 || n >= ARM_SYSCALL_BASE + || (env->thumb && n == ARM_THUMB_SYSCALL)) { +@@ -379,14 +421,34 @@ + n -= ARM_SYSCALL_BASE; + env->eabi = 0; + } +- env->regs[0] = do_syscall(env, +- n, +- env->regs[0], +- env->regs[1], +- env->regs[2], +- env->regs[3], +- env->regs[4], +- env->regs[5]); ++ if ( n > ARM_NR_BASE) { ++ switch (n) ++ { ++ case ARM_NR_cacheflush: ++ arm_cache_flush(env->regs[0], env->regs[1]); ++ break; ++#ifdef USE_NPTL ++ case ARM_NR_set_tls: ++ cpu_set_tls(env, env->regs[0]); ++ env->regs[0] = 0; ++ break; ++#endif ++ default: ++ printf ("Error: Bad syscall: %x\n", n); ++ goto error; ++ } ++ } ++ else ++ { ++ env->regs[0] = do_syscall(env, ++ n, ++ env->regs[0], ++ env->regs[1], ++ env->regs[2], ++ env->regs[3], ++ env->regs[4], ++ env->regs[5]); ++ } + } else { + goto error; + } +@@ -425,6 +487,10 @@ + } + } + break; ++ case EXCP_KERNEL_TRAP: ++ if (do_kernel_trap(env)) ++ goto error; ++ break; + default: + error: + fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", +@@ -1639,6 +1705,10 @@ + ts->heap_base = info->brk; + /* This will be filled in on the first SYS_HEAPINFO call. */ + ts->heap_limit = 0; ++ /* Register the magic kernel code page. The cpu will generate a ++ special exception when it tries to execute code here. We can't ++ put real code here because it may be in use by the host kernel. */ ++ page_set_flags(0xffff0000, 0xffff0fff, 0); + } + #elif defined(TARGET_SPARC) + { +Index: qemu/linux-user/qemu.h +=================================================================== +--- qemu.orig/linux-user/qemu.h 2006-08-26 16:28:40.000000000 +0100 ++++ qemu/linux-user/qemu.h 2006-08-26 16:33:50.000000000 +0100 +@@ -75,6 +75,9 @@ + uint32_t v86mask; + #endif + int used; /* non zero if used */ ++#ifdef USE_NPTL ++ uint32_t *child_tidptr; ++#endif + struct image_info *info; + uint8_t stack[0]; + } __attribute__((aligned(16))) TaskState; +Index: qemu/linux-user/syscall.c +=================================================================== +--- qemu.orig/linux-user/syscall.c 2006-08-26 16:28:40.000000000 +0100 ++++ qemu/linux-user/syscall.c 2006-08-26 16:31:53.000000000 +0100 +@@ -66,9 +66,18 @@ + #include + + #include "qemu.h" ++#include "qemu_spinlock.h" + + //#define DEBUG + ++#ifdef USE_NPTL ++#define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \ ++ CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID) ++#else ++/* XXX: Hardcode the above values. */ ++#define CLONE_NPTL_FLAGS2 0 ++#endif ++ + #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) + /* 16 bit uid wrappers emulation */ + #define USE_UID16 +@@ -1602,20 +1611,38 @@ + thread/process */ + #define NEW_STACK_SIZE 8192 + ++#ifdef USE_NPTL ++static spinlock_t nptl_lock = SPIN_LOCK_UNLOCKED; ++#endif ++ + static int clone_func(void *arg) + { + CPUState *env = arg; ++#ifdef HAVE_NPTL ++ /* Wait until the parent has finshed initializing the tls state. */ ++ while (!spin_trylock(&nptl_lock)) ++ usleep(1); ++ spin_unlock(&nptl_lock); ++#endif + cpu_loop(env); + /* never exits */ + return 0; + } + +-int do_fork(CPUState *env, unsigned int flags, unsigned long newsp) ++int do_fork(CPUState *env, unsigned int flags, unsigned long newsp, ++ uint32_t *parent_tidptr, void *newtls, ++ uint32_t *child_tidptr) + { + int ret; + TaskState *ts; + uint8_t *new_stack; + CPUState *new_env; ++#ifdef USE_NPTL ++ unsigned int nptl_flags; ++ ++ if (flags & CLONE_PARENT_SETTID) ++ *parent_tidptr = gettid(); ++#endif + + if (flags & CLONE_VM) { + ts = malloc(sizeof(TaskState) + NEW_STACK_SIZE); +@@ -1665,16 +1692,60 @@ + #error unsupported target CPU + #endif + new_env->opaque = ts; ++#ifdef USE_NPTL ++ nptl_flags = flags; ++ flags &= ~CLONE_NPTL_FLAGS2; ++ if (nptl_flags & CLONE_CHILD_CLEARTID) { ++ ts->child_tidptr = child_tidptr; ++ } ++ if (nptl_flags & CLONE_SETTLS) ++ cpu_set_tls (new_env, newtls); ++ /* Grab the global cpu lock so that the thread setup appears ++ atomic. */ ++ if (nptl_flags & CLONE_CHILD_SETTID) ++ spin_lock(&nptl_lock); ++#else ++ if (flags & CLONE_NPTL_FLAGS2) ++ return -EINVAL; ++#endif ++ + #ifdef __ia64__ + ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env); + #else + ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env); + #endif ++#ifdef USE_NPTL ++ if (ret != -1) { ++ if (nptl_flags & CLONE_CHILD_SETTID) ++ *child_tidptr = ret; ++ } ++ /* Allow the child to continue. */ ++ if (nptl_flags & CLONE_CHILD_SETTID) ++ spin_unlock(&nptl_lock); ++#endif + } else { +- /* if no CLONE_VM, we consider it is a fork */ +- if ((flags & ~CSIGNAL) != 0) +- return -EINVAL; +- ret = fork(); ++ /* if no CLONE_VM, we consider it is a fork */ ++ if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0) ++ return -EINVAL; ++ ret = fork(); ++#ifdef USE_NPTL ++ /* There is a race condition here. The parent process could ++ theoretically read the TID in the child process before the child ++ tid is set. This would require using either ptrace ++ (not implemented) or having *_tidptr to point at a shared memory ++ mapping. We can't repeat the spinlock hack used above because ++ the child process gets its own copy of the lock. */ ++ if (ret == 0) { ++ /* Child Process. */ ++ if (flags & CLONE_CHILD_SETTID) ++ *child_tidptr = gettid(); ++ ts = (TaskState *)env->opaque; ++ if (flags & CLONE_CHILD_CLEARTID) ++ ts->child_tidptr = child_tidptr; ++ if (flags & CLONE_SETTLS) ++ cpu_set_tls (env, newtls); ++ } ++#endif + } + return ret; + } +@@ -1918,7 +1989,7 @@ + ret = do_brk(arg1); + break; + case TARGET_NR_fork: +- ret = get_errno(do_fork(cpu_env, SIGCHLD, 0)); ++ ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, NULL, NULL, NULL)); + break; + case TARGET_NR_waitpid: + { +@@ -2989,7 +3060,8 @@ + ret = get_errno(fsync(arg1)); + break; + case TARGET_NR_clone: +- ret = get_errno(do_fork(cpu_env, arg1, arg2)); ++ ret = get_errno(do_fork(cpu_env, arg1, arg2, (uint32_t *)arg3, ++ (void *)arg4, (uint32_t *)arg5)); + break; + #ifdef __NR_exit_group + /* new thread calls */ +@@ -3339,7 +3411,8 @@ + #endif + #ifdef TARGET_NR_vfork + case TARGET_NR_vfork: +- ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0)); ++ ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0, ++ NULL, NULL, NULL)); + break; + #endif + #ifdef TARGET_NR_ugetrlimit +@@ -3838,4 +3911,3 @@ + #endif + return ret; + } +- +Index: qemu/target-arm/cpu.h +=================================================================== +--- qemu.orig/target-arm/cpu.h 2006-03-09 19:18:27.000000000 +0000 ++++ qemu/target-arm/cpu.h 2006-08-26 16:31:53.000000000 +0100 +@@ -35,6 +35,9 @@ + #define EXCP_IRQ 5 + #define EXCP_FIQ 6 + #define EXCP_BKPT 7 ++#define EXCP_KERNEL_TRAP 8 /* Jumped to kernel code page. */ ++ ++ + + /* We currently assume float and double are IEEE single and double + precision respectively. +@@ -85,6 +88,7 @@ + uint32_t c9_data; + uint32_t c13_fcse; /* FCSE PID. */ + uint32_t c13_context; /* Context ID. */ ++ uint32_t c13_tls; /* Paul Brook told me to just add this ;) */ + } cp15; + + /* Internal CPU feature flags. */ +@@ -135,6 +139,15 @@ + int cpu_arm_signal_handler(int host_signum, struct siginfo *info, + void *puc); + ++void cpu_lock(void); ++void cpu_unlock(void); ++#if defined(USE_NPTL) ++static inline void cpu_set_tls(CPUARMState *env, void *newtls) ++{ ++ env->cp15.c13_tls = (uint32_t)newtls; ++} ++#endif ++ + #define CPSR_M (0x1f) + #define CPSR_T (1 << 5) + #define CPSR_F (1 << 6) +@@ -146,7 +159,11 @@ + #define CPSR_J (1 << 24) + #define CPSR_IT_0_1 (3 << 25) + #define CPSR_Q (1 << 27) +-#define CPSR_NZCV (0xf << 28) ++#define CPSR_V (1 << 28) ++#define CPSR_C (1 << 29) ++#define CPSR_Z (1 << 30) ++#define CPSR_N (1 << 31) ++#define CPSR_NZCV (CPSR_N | CPSR_Z | CPSR_C | CPSR_V) + + #define CACHED_CPSR_BITS (CPSR_T | CPSR_Q | CPSR_NZCV) + /* Return the current CPSR value. */ +Index: qemu/target-arm/exec.h +=================================================================== +--- qemu.orig/target-arm/exec.h 2006-03-09 19:18:27.000000000 +0000 ++++ qemu/target-arm/exec.h 2006-08-26 16:31:53.000000000 +0100 +@@ -51,8 +51,6 @@ + + /* In op_helper.c */ + +-void cpu_lock(void); +-void cpu_unlock(void); + void helper_set_cp15(CPUState *, uint32_t, uint32_t); + uint32_t helper_get_cp15(CPUState *, uint32_t); + +Index: qemu/target-arm/op.c +=================================================================== +--- qemu.orig/target-arm/op.c 2006-08-26 16:28:48.000000000 +0100 ++++ qemu/target-arm/op.c 2006-08-26 16:31:53.000000000 +0100 +@@ -891,6 +891,12 @@ + cpu_loop_exit(); + } + ++void OPPROTO op_kernel_trap(void) ++{ ++ env->exception_index = EXCP_KERNEL_TRAP; ++ cpu_loop_exit(); ++} ++ + /* VFP support. We follow the convention used for VFP instrunctions: + Single precition routines have a "s" suffix, double precision a + "d" suffix. */ +Index: qemu/target-arm/translate.c +=================================================================== +--- qemu.orig/target-arm/translate.c 2006-08-26 16:28:48.000000000 +0100 ++++ qemu/target-arm/translate.c 2006-08-26 16:31:53.000000000 +0100 +@@ -2382,6 +2382,7 @@ + s->is_jmp = DISAS_JUMP; + } + ++ + /* generate intermediate code in gen_opc_buf and gen_opparam_buf for + basic block 'tb'. If search_pc is TRUE, also generate PC + information for each intermediate instruction. */ +@@ -2416,6 +2417,15 @@ + nb_gen_labels = 0; + lj = -1; + do { ++#ifdef CONFIG_USER_ONLY ++ /* Intercept jump to the magic kernel page. */ ++ if (dc->pc > 0xffff0000) { ++ gen_op_kernel_trap(); ++ dc->is_jmp = DISAS_UPDATE; ++ break; ++ } ++#endif ++ + if (env->nb_breakpoints > 0) { + for(j = 0; j < env->nb_breakpoints; j++) { + if (env->breakpoints[j] == dc->pc) { +Index: qemu/qemu_spinlock.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qemu/qemu_spinlock.h 2006-08-26 16:31:53.000000000 +0100 +@@ -0,0 +1,182 @@ ++/* ++ * internal execution defines for qemu ++ * ++ * Copyright (c) 2003 Fabrice Bellard ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ */ ++ ++#ifndef _QEMU_SPINLOCK_H ++#define _QEMU_SPINLOCK_H ++ ++#ifdef __powerpc__ ++static inline int testandset (int *p) ++{ ++ int ret; ++ __asm__ __volatile__ ( ++ "0: lwarx %0,0,%1\n" ++ " xor. %0,%3,%0\n" ++ " bne 1f\n" ++ " stwcx. %2,0,%1\n" ++ " bne- 0b\n" ++ "1: " ++ : "=&r" (ret) ++ : "r" (p), "r" (1), "r" (0) ++ : "cr0", "memory"); ++ return ret; ++} ++#endif ++ ++#ifdef __i386__ ++static inline int testandset (int *p) ++{ ++ long int readval = 0; ++ ++ __asm__ __volatile__ ("lock; cmpxchgl %2, %0" ++ : "+m" (*p), "+a" (readval) ++ : "r" (1) ++ : "cc"); ++ return readval; ++} ++#endif ++ ++#ifdef __x86_64__ ++static inline int testandset (int *p) ++{ ++ long int readval = 0; ++ ++ __asm__ __volatile__ ("lock; cmpxchgl %2, %0" ++ : "+m" (*p), "+a" (readval) ++ : "r" (1) ++ : "cc"); ++ return readval; ++} ++#endif ++ ++#ifdef __s390__ ++static inline int testandset (int *p) ++{ ++ int ret; ++ ++ __asm__ __volatile__ ("0: cs %0,%1,0(%2)\n" ++ " jl 0b" ++ : "=&d" (ret) ++ : "r" (1), "a" (p), "0" (*p) ++ : "cc", "memory" ); ++ return ret; ++} ++#endif ++ ++#ifdef __alpha__ ++static inline int testandset (int *p) ++{ ++ int ret; ++ unsigned long one; ++ ++ __asm__ __volatile__ ("0: mov 1,%2\n" ++ " ldl_l %0,%1\n" ++ " stl_c %2,%1\n" ++ " beq %2,1f\n" ++ ".subsection 2\n" ++ "1: br 0b\n" ++ ".previous" ++ : "=r" (ret), "=m" (*p), "=r" (one) ++ : "m" (*p)); ++ return ret; ++} ++#endif ++ ++#ifdef __sparc__ ++static inline int testandset (int *p) ++{ ++ int ret; ++ ++ __asm__ __volatile__("ldstub [%1], %0" ++ : "=r" (ret) ++ : "r" (p) ++ : "memory"); ++ ++ return (ret ? 1 : 0); ++} ++#endif ++ ++#ifdef __arm__ ++static inline int testandset (int *spinlock) ++{ ++ register unsigned int ret; ++ __asm__ __volatile__("swp %0, %1, [%2]" ++ : "=r"(ret) ++ : "0"(1), "r"(spinlock)); ++ ++ return ret; ++} ++#endif ++ ++#ifdef __mc68000 ++static inline int testandset (int *p) ++{ ++ char ret; ++ __asm__ __volatile__("tas %1; sne %0" ++ : "=r" (ret) ++ : "m" (p) ++ : "cc","memory"); ++ return ret; ++} ++#endif ++ ++#ifdef __ia64 ++#include ++ ++static inline int testandset (int *p) ++{ ++ return __sync_lock_test_and_set (p, 1); ++} ++#endif ++ ++typedef int spinlock_t; ++ ++#define SPIN_LOCK_UNLOCKED 0 ++ ++#if defined(CONFIG_USER_ONLY) ++static inline void spin_lock(spinlock_t *lock) ++{ ++ while (testandset(lock)); ++} ++ ++static inline void spin_unlock(spinlock_t *lock) ++{ ++ *lock = 0; ++} ++ ++static inline int spin_trylock(spinlock_t *lock) ++{ ++ return !testandset(lock); ++} ++#else ++static inline void spin_lock(spinlock_t *lock) ++{ ++} ++ ++static inline void spin_unlock(spinlock_t *lock) ++{ ++} ++ ++static inline int spin_trylock(spinlock_t *lock) ++{ ++ return 1; ++} ++#endif ++ ++#endif /* ! _QEMU_SPINLOCK_H */ diff --git a/org.handhelds.familiar/packages/qemu/files/compiler.patch b/org.handhelds.familiar/packages/qemu/files/compiler.patch new file mode 100644 index 0000000..dad18b3 --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/compiler.patch @@ -0,0 +1,10 @@ +--- qemu/usb-linux.c~ 2006-07-19 19:06:15.000000000 +0100 ++++ qemu/usb-linux.c 2006-10-02 12:49:00.000000000 +0100 +@@ -26,7 +26,6 @@ + #if defined(__linux__) + #include + #include +-#include + #include + #include + diff --git a/org.handhelds.familiar/packages/qemu/files/configure.patch b/org.handhelds.familiar/packages/qemu/files/configure.patch new file mode 100644 index 0000000..ea83f8c --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/configure.patch @@ -0,0 +1,13 @@ +Index: qemu/configure +=================================================================== +--- qemu.orig/configure 2006-02-09 17:58:47.000000000 +0000 ++++ qemu/configure 2006-02-21 17:47:31.000000000 +0000 +@@ -482,7 +482,7 @@ + fi + echo "HOST_CC=$host_cc" >> $config_mak + echo "AR=$ar" >> $config_mak +-echo "STRIP=$strip -s -R .comment -R .note" >> $config_mak ++echo "STRIP=$strip" >> $config_mak + echo "CFLAGS=$CFLAGS" >> $config_mak + echo "LDFLAGS=$LDFLAGS" >> $config_mak + echo "EXESUF=$EXESUF" >> $config_mak diff --git a/org.handhelds.familiar/packages/qemu/files/pl110_rgb-r0.patch b/org.handhelds.familiar/packages/qemu/files/pl110_rgb-r0.patch new file mode 100644 index 0000000..09e5898 --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/pl110_rgb-r0.patch @@ -0,0 +1,219 @@ +Index: qemu/hw/pl110.c +=================================================================== +--- qemu.orig/hw/pl110.c 2006-04-11 21:49:46.000000000 +0100 ++++ qemu/hw/pl110.c 2006-05-24 22:53:00.000000000 +0100 +@@ -10,6 +10,7 @@ + #include "vl.h" + + #define PL110_CR_EN 0x001 ++#define PL110_CR_BGR 0x100 + #define PL110_CR_BEBO 0x200 + #define PL110_CR_BEPO 0x400 + #define PL110_CR_PWR 0x800 +@@ -115,6 +116,7 @@ + int first, last = 0; + int dirty, new_dirty; + int i; ++ int bpp_offset; + + if (!pl110_enabled(s)) + return; +@@ -146,12 +148,17 @@ + fprintf(stderr, "pl110: Bad color depth\n"); + exit(1); + } ++ if (s->cr & PL110_CR_BGR) ++ bpp_offset = 0; ++ else ++ bpp_offset = 18; ++ + if (s->cr & PL110_CR_BEBO) +- fn = fntable[s->bpp + 6]; ++ fn = fntable[s->bpp + 6 + bpp_offset]; + else if (s->cr & PL110_CR_BEPO) +- fn = fntable[s->bpp + 12]; ++ fn = fntable[s->bpp + 12 + bpp_offset]; + else +- fn = fntable[s->bpp]; ++ fn = fntable[s->bpp + bpp_offset]; + + src_width = s->cols; + switch (s->bpp) { +Index: qemu/hw/pl110_template.h +=================================================================== +--- qemu.orig/hw/pl110_template.h 2006-02-19 12:31:32.000000000 +0000 ++++ qemu/hw/pl110_template.h 2006-05-24 23:04:03.000000000 +0100 +@@ -24,6 +24,16 @@ + #error unknown bit depth + #endif + ++#undef RGB ++#define BORDER bgr ++#define ORDER 0 ++#include "pl110_template.h" ++#define ORDER 1 ++#include "pl110_template.h" ++#define ORDER 2 ++#include "pl110_template.h" ++#define RGB ++#define BORDER rgb + #define ORDER 0 + #include "pl110_template.h" + #define ORDER 1 +@@ -33,26 +43,47 @@ + + static drawfn glue(pl110_draw_fn_,BITS)[18] = + { +- glue(pl110_draw_line1_lblp,BITS), +- glue(pl110_draw_line2_lblp,BITS), +- glue(pl110_draw_line4_lblp,BITS), +- glue(pl110_draw_line8_lblp,BITS), +- glue(pl110_draw_line16_lblp,BITS), +- glue(pl110_draw_line32_lblp,BITS), +- +- glue(pl110_draw_line1_bbbp,BITS), +- glue(pl110_draw_line2_bbbp,BITS), +- glue(pl110_draw_line4_bbbp,BITS), +- glue(pl110_draw_line8_bbbp,BITS), +- glue(pl110_draw_line16_bbbp,BITS), +- glue(pl110_draw_line32_bbbp,BITS), +- +- glue(pl110_draw_line1_lbbp,BITS), +- glue(pl110_draw_line2_lbbp,BITS), +- glue(pl110_draw_line4_lbbp,BITS), +- glue(pl110_draw_line8_lbbp,BITS), +- glue(pl110_draw_line16_lbbp,BITS), +- glue(pl110_draw_line32_lbbp,BITS) ++ glue(pl110_draw_line1_lblp_bgr,BITS), ++ glue(pl110_draw_line2_lblp_bgr,BITS), ++ glue(pl110_draw_line4_lblp_bgr,BITS), ++ glue(pl110_draw_line8_lblp_bgr,BITS), ++ glue(pl110_draw_line16_lblp_bgr,BITS), ++ glue(pl110_draw_line32_lblp_bgr,BITS), ++ ++ glue(pl110_draw_line1_bbbp_bgr,BITS), ++ glue(pl110_draw_line2_bbbp_bgr,BITS), ++ glue(pl110_draw_line4_bbbp_bgr,BITS), ++ glue(pl110_draw_line8_bbbp_bgr,BITS), ++ glue(pl110_draw_line16_bbbp_bgr,BITS), ++ glue(pl110_draw_line32_bbbp_bgr,BITS), ++ ++ glue(pl110_draw_line1_lbbp_bgr,BITS), ++ glue(pl110_draw_line2_lbbp_bgr,BITS), ++ glue(pl110_draw_line4_lbbp_bgr,BITS), ++ glue(pl110_draw_line8_lbbp_bgr,BITS), ++ glue(pl110_draw_line16_lbbp_bgr,BITS), ++ glue(pl110_draw_line32_lbbp_bgr,BITS), ++ ++ glue(pl110_draw_line1_lblp_rgb,BITS), ++ glue(pl110_draw_line2_lblp_rgb,BITS), ++ glue(pl110_draw_line4_lblp_rgb,BITS), ++ glue(pl110_draw_line8_lblp_rgb,BITS), ++ glue(pl110_draw_line16_lblp_rgb,BITS), ++ glue(pl110_draw_line32_lblp_rgb,BITS), ++ ++ glue(pl110_draw_line1_bbbp_rgb,BITS), ++ glue(pl110_draw_line2_bbbp_rgb,BITS), ++ glue(pl110_draw_line4_bbbp_rgb,BITS), ++ glue(pl110_draw_line8_bbbp_rgb,BITS), ++ glue(pl110_draw_line16_bbbp_rgb,BITS), ++ glue(pl110_draw_line32_bbbp_rgb,BITS), ++ ++ glue(pl110_draw_line1_lbbp_rgb,BITS), ++ glue(pl110_draw_line2_lbbp_rgb,BITS), ++ glue(pl110_draw_line4_lbbp_rgb,BITS), ++ glue(pl110_draw_line8_lbbp_rgb,BITS), ++ glue(pl110_draw_line16_lbbp_rgb,BITS), ++ glue(pl110_draw_line32_lbbp_rgb,BITS), + }; + + #undef BITS +@@ -61,18 +92,18 @@ + #else + + #if ORDER == 0 +-#define NAME glue(lblp, BITS) ++#define NAME glue(glue(lblp_, BORDER), BITS) + #ifdef WORDS_BIGENDIAN + #define SWAP_WORDS 1 + #endif + #elif ORDER == 1 +-#define NAME glue(bbbp, BITS) ++#define NAME glue(glue(bbbp_, BORDER), BITS) + #ifndef WORDS_BIGENDIAN + #define SWAP_WORDS 1 + #endif + #else + #define SWAP_PIXELS 1 +-#define NAME glue(lbbp, BITS) ++#define NAME glue(glue(lbbp_, BORDER), BITS) + #ifdef WORDS_BIGENDIAN + #define SWAP_WORDS 1 + #endif +@@ -195,27 +226,34 @@ + #ifdef SWAP_WORDS + data = bswap32(data); + #endif ++#ifdef RGB ++#define LSB r ++#define MSB b ++#else ++#define LSB b ++#define MSB r ++#endif + #if 0 +- r = data & 0x1f; ++ LSB = data & 0x1f; + data >>= 5; + g = data & 0x3f; + data >>= 6; +- b = data & 0x1f; ++ MSB = data & 0x1f; + data >>= 5; + #else +- r = (data & 0x1f) << 3; ++ LSB = (data & 0x1f) << 3; + data >>= 5; + g = (data & 0x3f) << 2; + data >>= 6; +- b = (data & 0x1f) << 3; ++ MSB = (data & 0x1f) << 3; + data >>= 5; + #endif + COPY_PIXEL(d, glue(rgb_to_pixel,BITS)(r, g, b)); +- r = (data & 0x1f) << 3; ++ LSB = (data & 0x1f) << 3; + data >>= 5; + g = (data & 0x3f) << 2; + data >>= 6; +- b = (data & 0x1f) << 3; ++ MSB = (data & 0x1f) << 3; + data >>= 5; + COPY_PIXEL(d, glue(rgb_to_pixel,BITS)(r, g, b)); + width -= 2; +@@ -229,14 +267,21 @@ + unsigned int r, g, b; + while (width > 0) { + data = *(uint32_t *)src; ++#ifdef RGB ++#define LSB r ++#define MSB b ++#else ++#define LSB b ++#define MSB r ++#endif + #ifdef SWAP_WORDS +- r = data & 0xff; ++ LSB = data & 0xff; + g = (data >> 8) & 0xff; +- b = (data >> 16) & 0xff; ++ MSB = (data >> 16) & 0xff; + #else +- r = (data >> 24) & 0xff; ++ LSB = (data >> 24) & 0xff; + g = (data >> 16) & 0xff; +- b = (data >> 8) & 0xff; ++ MSB = (data >> 8) & 0xff; + #endif + COPY_PIXEL(d, glue(rgb_to_pixel,BITS)(r, g, b)); + width--; diff --git a/org.handhelds.familiar/packages/qemu/files/qemu-pci-irq-sharing.patch b/org.handhelds.familiar/packages/qemu/files/qemu-pci-irq-sharing.patch new file mode 100644 index 0000000..c47e898 --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/qemu-pci-irq-sharing.patch @@ -0,0 +1,52 @@ +diff -pNaur qemu-cvs-ts-orig/hw/pci.c qemu-cvs-ts/hw/pci.c +--- qemu-cvs-ts-orig/hw/pci.c 2006-08-17 10:46:34.000000000 +0000 ++++ qemu-cvs-ts/hw/pci.c 2006-09-23 17:02:41.000000000 +0000 +@@ -34,6 +34,7 @@ struct PCIBus { + SetIRQFunc *low_set_irq; + void *irq_opaque; + PCIDevice *devices[256]; ++ int irq_count[4]; + }; + + static void pci_update_mappings(PCIDevice *d); +@@ -49,6 +50,7 @@ PCIBus *pci_register_bus(pci_set_irq_fn + bus->set_irq = set_irq; + bus->irq_opaque = pic; + bus->devfn_min = devfn_min; ++ memset(bus->irq_count, 0, sizeof(bus->irq_count)); + first_bus = bus; + return bus; + } +@@ -100,6 +102,7 @@ PCIDevice *pci_register_device(PCIBus *b + pci_dev->bus = bus; + pci_dev->devfn = devfn; + pstrcpy(pci_dev->name, sizeof(pci_dev->name), name); ++ memset(pci_dev->irq_state, 0, sizeof(pci_dev->irq_state)); + + if (!config_read) + config_read = pci_default_read_config; +@@ -404,7 +407,10 @@ uint32_t pci_data_read(void *opaque, uin + void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level) + { + PCIBus *bus = pci_dev->bus; +- bus->set_irq(pci_dev, bus->irq_opaque, irq_num, level); ++ bus->irq_count[irq_num] += level - pci_dev->irq_state[irq_num]; ++ pci_dev->irq_state[irq_num] = level; ++ bus->set_irq(pci_dev, bus->irq_opaque, ++ irq_num, !!bus->irq_count[irq_num]); + } + + /***********************************************************/ +diff -pNaur qemu-cvs-ts-orig/vl.h qemu-cvs-ts/vl.h +--- qemu-cvs-ts-orig/vl.h 2006-09-18 01:15:29.000000000 +0000 ++++ qemu-cvs-ts/vl.h 2006-09-23 17:15:21.000000000 +0000 +@@ -733,6 +733,9 @@ struct PCIDevice { + PCIConfigWriteFunc *config_write; + /* ??? This is a PC-specific hack, and should be removed. */ + int irq_index; ++ ++ /* remember last irq levels */ ++ int irq_state[4]; + }; + + PCIDevice *pci_register_device(PCIBus *bus, const char *name, diff --git a/org.handhelds.familiar/packages/qemu/files/qemu-sdl-cursor.patch b/org.handhelds.familiar/packages/qemu/files/qemu-sdl-cursor.patch new file mode 100644 index 0000000..bd6a51a --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/qemu-sdl-cursor.patch @@ -0,0 +1,13 @@ +Index: qemu/sdl.c +=================================================================== +--- qemu.orig/sdl.c 2006-10-02 17:06:12.000000000 +0100 ++++ qemu/sdl.c 2006-10-02 17:06:59.000000000 +0100 +@@ -287,7 +287,7 @@ + { + if (kbd_mouse_is_absolute()) { + SDL_ShowCursor(1); +- SDL_SetCursor(sdl_cursor_hidden); ++ /* SDL_SetCursor(sdl_cursor_hidden); */ + } else { + SDL_ShowCursor(0); + } diff --git a/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-0.8.2.patch b/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-0.8.2.patch new file mode 100644 index 0000000..33a6db3 --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-0.8.2.patch @@ -0,0 +1,445 @@ +diff -pNaur qemu-cvs-ts-orig/hw/usb-wacom.c qemu-cvs-ts/hw/usb-wacom.c +--- qemu-cvs-ts-orig/hw/usb-wacom.c 1970-01-01 01:00:00.000000000 +0100 ++++ qemu-cvs-ts/hw/usb-wacom.c 2006-09-22 20:44:26.000000000 +0200 +@@ -0,0 +1,408 @@ ++/* ++ * Wacom PenPartner USB tablet emulation. ++ * ++ * Copyright (c) 2006 Openedhand Ltd. ++ * ++ * Author: Andrzej Zaborowski ++ * ++ * Based on hw/usb-hid.c: ++ * Copyright (c) 2005 Fabrice Bellard ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a copy ++ * of this software and associated documentation files (the "Software"), to deal ++ * in the Software without restriction, including without limitation the rights ++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++ * copies of the Software, and to permit persons to whom the Software is ++ * furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++ * THE SOFTWARE. ++ */ ++#include "vl.h" ++ ++/* Interface requests */ ++#define WACOM_GET_REPORT 0x2101 ++#define WACOM_SET_REPORT 0x2109 ++ ++/* HID interface requests */ ++#define HID_GET_REPORT 0xa101 ++#define HID_GET_IDLE 0xa102 ++#define HID_GET_PROTOCOL 0xa103 ++#define HID_SET_IDLE 0x210a ++#define HID_SET_PROTOCOL 0x210b ++ ++#define WACOM_MODE_HID 1 ++#define WACOM_MODE_WACOM 2 ++ ++typedef struct USBWacomState { ++ USBDevice dev; ++ int dx, dy, dz, buttons_state; ++ int x, y; ++ int mouse_grabbed; ++ int mode; ++} USBWacomState; ++ ++static const uint8_t qemu_wacom_dev_descriptor[] = { ++ 0x12, /* u8 bLength; */ ++ 0x01, /* u8 bDescriptorType; Device */ ++ 0x10, 0x10, /* u16 bcdUSB; v1.10 */ ++ ++ 0x00, /* u8 bDeviceClass; */ ++ 0x00, /* u8 bDeviceSubClass; */ ++ 0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */ ++ 0x08, /* u8 bMaxPacketSize0; 8 Bytes */ ++ ++ 0x6a, 0x05, /* u16 idVendor; */ ++ 0x00, 0x00, /* u16 idProduct; */ ++ 0x10, 0x42, /* u16 bcdDevice */ ++ ++ 0x01, /* u8 iManufacturer; */ ++ 0x02, /* u8 iProduct; */ ++ 0x00, /* u8 iSerialNumber; */ ++ 0x01, /* u8 bNumConfigurations; */ ++}; ++ ++static const uint8_t qemu_wacom_config_descriptor[] = { ++ /* one configuration */ ++ 0x09, /* u8 bLength; */ ++ 0x02, /* u8 bDescriptorType; Configuration */ ++ 0x22, 0x00, /* u16 wTotalLength; */ ++ 0x01, /* u8 bNumInterfaces; (1) */ ++ 0x01, /* u8 bConfigurationValue; */ ++ 0x00, /* u8 iConfiguration; */ ++ 0x80, /* u8 bmAttributes; ++ Bit 7: must be set, ++ 6: Self-powered, ++ 5: Remote wakeup, ++ 4..0: resvd */ ++ 40, /* u8 MaxPower; */ ++ ++ /* one interface */ ++ 0x09, /* u8 if_bLength; */ ++ 0x04, /* u8 if_bDescriptorType; Interface */ ++ 0x00, /* u8 if_bInterfaceNumber; */ ++ 0x00, /* u8 if_bAlternateSetting; */ ++ 0x01, /* u8 if_bNumEndpoints; */ ++ 0x03, /* u8 if_bInterfaceClass; HID */ ++ 0x01, /* u8 if_bInterfaceSubClass; Boot */ ++ 0x02, /* u8 if_bInterfaceProtocol; [usb1.1 or single tt] */ ++ 0x00, /* u8 if_iInterface; */ ++ ++ /* HID descriptor */ ++ 0x09, /* u8 bLength; */ ++ 0x21, /* u8 bDescriptorType; */ ++ 0x01, 0x10, /* u16 HID_class */ ++ 0x00, /* u8 country_code */ ++ 0x01, /* u8 num_descriptors */ ++ 0x22, /* u8 type; Report */ ++ 0x6e, 0x00, /* u16 len */ ++ ++ /* one endpoint (status change endpoint) */ ++ 0x07, /* u8 ep_bLength; */ ++ 0x05, /* u8 ep_bDescriptorType; Endpoint */ ++ 0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */ ++ 0x03, /* u8 ep_bmAttributes; Interrupt */ ++ 0x08, 0x00, /* u16 ep_wMaxPacketSize; */ ++ 0x0a, /* u8 ep_bInterval; */ ++}; ++ ++static void usb_mouse_event(void *opaque, ++ int dx1, int dy1, int dz1, int buttons_state) ++{ ++ USBWacomState *s = opaque; ++ ++ s->dx += dx1; ++ s->dy += dy1; ++ s->dz += dz1; ++ s->buttons_state = buttons_state; ++} ++ ++static void usb_wacom_event(void *opaque, ++ int x, int y, int dz, int buttons_state) ++{ ++ USBWacomState *s = opaque; ++ ++ s->x = x; ++ s->y = y; ++ s->dz += dz; ++ s->buttons_state = buttons_state; ++} ++ ++static inline int int_clamp(int val, int vmin, int vmax) ++{ ++ if (val < vmin) ++ return vmin; ++ else if (val > vmax) ++ return vmax; ++ else ++ return val; ++} ++ ++static int usb_mouse_poll(USBWacomState *s, uint8_t *buf, int len) ++{ ++ int dx, dy, dz, b, l; ++ ++ if (!s->mouse_grabbed) { ++ qemu_add_mouse_event_handler(usb_mouse_event, s, 1); ++ s->mouse_grabbed = 1; ++ } ++ ++ dx = int_clamp(s->dx, -128, 127); ++ dy = int_clamp(s->dy, -128, 127); ++ dz = int_clamp(s->dz, -128, 127); ++ ++ s->dx -= dx; ++ s->dy -= dy; ++ s->dz -= dz; ++ ++ b = 0; ++ if (s->buttons_state & MOUSE_EVENT_LBUTTON) ++ b |= 0x01; ++ if (s->buttons_state & MOUSE_EVENT_RBUTTON) ++ b |= 0x02; ++ if (s->buttons_state & MOUSE_EVENT_MBUTTON) ++ b |= 0x04; ++ ++ buf[0] = b; ++ buf[1] = dx; ++ buf[2] = dy; ++ l = 3; ++ if (len >= 4) { ++ buf[3] = dz; ++ l = 4; ++ } ++ return l; ++} ++ ++static int usb_wacom_poll(USBWacomState *s, uint8_t *buf, int len) ++{ ++ int b; ++ ++ if (!s->mouse_grabbed) { ++ qemu_add_mouse_event_handler(usb_wacom_event, s, 1); ++ s->mouse_grabbed = 1; ++ } ++ ++ b = 0; ++ if (s->buttons_state & MOUSE_EVENT_LBUTTON) ++ b |= 0x01; ++ if (s->buttons_state & MOUSE_EVENT_RBUTTON) ++ b |= 0x02; ++ if (s->buttons_state & MOUSE_EVENT_MBUTTON) ++ b |= 0x04; ++ ++ if (len < 7) ++ return 0; ++ ++ buf[0] = s->mode; ++ buf[1] = s->x & 0xff; ++ buf[2] = s->x >> 8; ++ buf[3] = s->y & 0xff; ++ buf[4] = s->y >> 8; ++ if (b) { ++ buf[5] = 0x40; ++ buf[6] = 0; ++ } else { ++ buf[5] = 0x00; ++ buf[6] = (unsigned char) -120; ++ } ++ ++ return 7; ++} ++ ++static void usb_wacom_handle_reset(USBDevice *dev) ++{ ++ USBWacomState *s = (USBWacomState *) dev; ++ ++ s->dx = 0; ++ s->dy = 0; ++ s->dz = 0; ++ s->x = 0; ++ s->y = 0; ++ s->buttons_state = 0; ++ s->mode = WACOM_MODE_HID; ++} ++ ++static int usb_wacom_handle_control(USBDevice *dev, int request, int value, ++ int index, int length, uint8_t *data) ++{ ++ USBWacomState *s = (USBWacomState *) dev; ++ int ret = 0; ++ ++ switch (request) { ++ case DeviceRequest | USB_REQ_GET_STATUS: ++ data[0] = (1 << USB_DEVICE_SELF_POWERED) | ++ (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP); ++ data[1] = 0x00; ++ ret = 2; ++ break; ++ case DeviceOutRequest | USB_REQ_CLEAR_FEATURE: ++ if (value == USB_DEVICE_REMOTE_WAKEUP) { ++ dev->remote_wakeup = 0; ++ } else { ++ goto fail; ++ } ++ ret = 0; ++ break; ++ case DeviceOutRequest | USB_REQ_SET_FEATURE: ++ if (value == USB_DEVICE_REMOTE_WAKEUP) { ++ dev->remote_wakeup = 1; ++ } else { ++ goto fail; ++ } ++ ret = 0; ++ break; ++ case DeviceOutRequest | USB_REQ_SET_ADDRESS: ++ dev->addr = value; ++ ret = 0; ++ break; ++ case DeviceRequest | USB_REQ_GET_DESCRIPTOR: ++ switch (value >> 8) { ++ case USB_DT_DEVICE: ++ memcpy(data, qemu_wacom_dev_descriptor, ++ sizeof(qemu_wacom_dev_descriptor)); ++ ret = sizeof(qemu_wacom_dev_descriptor); ++ break; ++ case USB_DT_CONFIG: ++ memcpy(data, qemu_wacom_config_descriptor, ++ sizeof(qemu_wacom_config_descriptor)); ++ ret = sizeof(qemu_wacom_config_descriptor); ++ break; ++ case USB_DT_STRING: ++ switch (value & 0xff) { ++ case 0: ++ /* language ids */ ++ data[0] = 4; ++ data[1] = 3; ++ data[2] = 0x09; ++ data[3] = 0x04; ++ ret = 4; ++ break; ++ case 1: ++ /* serial number */ ++ ret = set_usb_string(data, "1"); ++ break; ++ case 2: ++ ret = set_usb_string(data, "Wacom PenPartner"); ++ break; ++ case 3: ++ /* vendor description */ ++ ret = set_usb_string(data, "QEMU " QEMU_VERSION); ++ break; ++ case 4: ++ ret = set_usb_string(data, "Wacom Tablet"); ++ break; ++ case 5: ++ ret = set_usb_string(data, "Endpoint1 Interrupt Pipe"); ++ break; ++ default: ++ goto fail; ++ } ++ break; ++ default: ++ goto fail; ++ } ++ break; ++ case DeviceRequest | USB_REQ_GET_CONFIGURATION: ++ data[0] = 1; ++ ret = 1; ++ break; ++ case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: ++ ret = 0; ++ break; ++ case DeviceRequest | USB_REQ_GET_INTERFACE: ++ data[0] = 0; ++ ret = 1; ++ break; ++ case DeviceOutRequest | USB_REQ_SET_INTERFACE: ++ ret = 0; ++ break; ++ case WACOM_SET_REPORT: ++ qemu_add_mouse_event_handler(NULL, NULL, 0); ++ s->mouse_grabbed = 0; ++ s->mode = data[0]; ++ ret = 0; ++ break; ++ case WACOM_GET_REPORT: ++ data[0] = 0; ++ data[1] = s->mode; ++ ret = 2; ++ break; ++ /* USB HID requests */ ++ case HID_GET_REPORT: ++ if (s->mode == WACOM_MODE_HID) ++ ret = usb_mouse_poll(s, data, length); ++ else if (s->mode == WACOM_MODE_WACOM) ++ ret = usb_wacom_poll(s, data, length); ++ break; ++ case HID_SET_IDLE: ++ ret = 0; ++ break; ++ default: ++ fail: ++ ret = USB_RET_STALL; ++ break; ++ } ++ return ret; ++} ++ ++static int usb_wacom_handle_data(USBDevice *dev, int pid, ++ uint8_t devep, uint8_t *data, int len) ++{ ++ USBWacomState *s = (USBWacomState *) dev; ++ int ret = 0; ++ ++ switch (pid) { ++ case USB_TOKEN_IN: ++ if (devep == 1) { ++ if (s->mode == WACOM_MODE_HID) ++ ret = usb_mouse_poll(s, data, len); ++ else if (s->mode == WACOM_MODE_WACOM) ++ ret = usb_wacom_poll(s, data, len); ++ break; ++ } ++ /* Fall through. */ ++ case USB_TOKEN_OUT: ++ default: ++ ret = USB_RET_STALL; ++ break; ++ } ++ return ret; ++} ++ ++static void usb_wacom_handle_destroy(USBDevice *dev) ++{ ++ USBWacomState *s = (USBWacomState *) dev; ++ ++ qemu_add_mouse_event_handler(NULL, NULL, 0); ++ qemu_free(s); ++} ++ ++USBDevice *usb_wacom_init(void) ++{ ++ USBWacomState *s; ++ ++ s = qemu_mallocz(sizeof(USBWacomState)); ++ if (!s) ++ return NULL; ++ s->dev.speed = USB_SPEED_FULL; ++ s->dev.handle_packet = usb_generic_handle_packet; ++ ++ s->dev.handle_reset = usb_wacom_handle_reset; ++ s->dev.handle_control = usb_wacom_handle_control; ++ s->dev.handle_data = usb_wacom_handle_data; ++ s->dev.handle_destroy = usb_wacom_handle_destroy; ++ ++ pstrcpy(s->dev.devname, sizeof(s->dev.devname), ++ "QEMU PenPartner Tablet"); ++ ++ return (USBDevice *) s; ++} +diff -pNaur qemu-cvs-ts-orig/hw/usb.h qemu-cvs-ts/hw/usb.h +--- qemu-cvs-ts-orig/hw/usb.h 2006-08-12 03:04:27.000000000 +0200 ++++ qemu-cvs-ts/hw/usb.h 2006-09-21 01:40:40.000000000 +0200 +@@ -218,3 +218,6 @@ USBDevice *usb_tablet_init(void); + + /* usb-msd.c */ + USBDevice *usb_msd_init(const char *filename); ++ ++/* usb-wacom.c */ ++USBDevice *usb_wacom_init(void); +diff -pNaur qemu-cvs-ts-orig/vl.c qemu-cvs-ts/vl.c +--- qemu-cvs-ts-orig/vl.c 2006-09-10 16:39:54.000000000 +0200 ++++ qemu-cvs-ts/vl.c 2006-09-21 01:45:16.000000000 +0200 +@@ -3765,6 +3765,8 @@ static int usb_device_add(const char *de + dev = usb_tablet_init(); + } else if (strstart(devname, "disk:", &p)) { + dev = usb_msd_init(p); ++ } else if (!strcmp(devname, "wacom-tablet")) { ++ dev = usb_wacom_init(); + } else { + return -1; + } +diff -pNaur qemu-cvs-ts-orig/Makefile.target qemu-cvs-ts/Makefile.target +--- qemu-cvs-ts-orig/Makefile.target 2006-09-18 03:15:29.000000000 +0200 ++++ qemu-cvs-ts/Makefile.target 2006-09-21 02:32:19.000000000 +0200 +@@ -330,6 +330,7 @@ VL_OBJS+= scsi-disk.o cdrom.o lsi53c895a + + # USB layer + VL_OBJS+= usb.o usb-hub.o usb-linux.o usb-hid.o usb-ohci.o usb-msd.o ++VL_OBJS+= usb-wacom.o + + # PCI network cards + VL_OBJS+= ne2000.o rtl8139.o pcnet.o diff --git a/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-buttons.patch b/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-buttons.patch new file mode 100644 index 0000000..ee24c15 --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-buttons.patch @@ -0,0 +1,23 @@ +--- qemu-cvs-ts-orig/hw/usb-wacom.c 2006-09-29 22:53:06.000000000 +0000 ++++ qemu-cvs-ts/hw/usb-wacom.c 2006-09-29 22:44:14.000000000 +0000 +@@ -203,19 +203,18 @@ static int usb_wacom_poll(USBWacomState + return 0; + + buf[0] = s->mode; ++ buf[5] = 0x00; + if (b) { + buf[1] = s->x & 0xff; + buf[2] = s->x >> 8; + buf[3] = s->y & 0xff; + buf[4] = s->y >> 8; +- buf[5] = 0x40; + buf[6] = 0; + } else { + buf[1] = 0; + buf[2] = 0; + buf[3] = 0; + buf[4] = 0; +- buf[5] = 0x00; + buf[6] = (unsigned char) -127; + } + diff --git a/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-pressure.patch b/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-pressure.patch new file mode 100644 index 0000000..668d50d --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-pressure.patch @@ -0,0 +1,28 @@ +--- qemu-cvs-ts-orig/hw/usb-wacom.c 2006-09-29 17:27:43.000000000 +0000 ++++ qemu-cvs-ts/hw/usb-wacom.c 2006-09-29 17:48:13.000000000 +0000 +@@ -203,16 +203,20 @@ static int usb_wacom_poll(USBWacomState + return 0; + + buf[0] = s->mode; +- buf[1] = s->x & 0xff; +- buf[2] = s->x >> 8; +- buf[3] = s->y & 0xff; +- buf[4] = s->y >> 8; + if (b) { ++ buf[1] = s->x & 0xff; ++ buf[2] = s->x >> 8; ++ buf[3] = s->y & 0xff; ++ buf[4] = s->y >> 8; + buf[5] = 0x40; + buf[6] = 0; + } else { ++ buf[1] = 0; ++ buf[2] = 0; ++ buf[3] = 0; ++ buf[4] = 0; + buf[5] = 0x00; +- buf[6] = (unsigned char) -120; ++ buf[6] = (unsigned char) -127; + } + + return 7; diff --git a/org.handhelds.familiar/packages/qemu/qemu-native.inc b/org.handhelds.familiar/packages/qemu/qemu-native.inc new file mode 100644 index 0000000..758c81a --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/qemu-native.inc @@ -0,0 +1,25 @@ +FILESPATH =. "${@os.path.dirname(bb.data.getVar('FILE',d,1))}/qemu-${PV}:" +# prefix = "${STAGING_DIR}/${BUILD_SYS}" +DEPENDS = "libsdl-native" + +do_configure_prepend() { + sed -i -e s,sdl-config,sdl-config-native, configure +} + +python __anonymous() { + from bb import which, data + + path = data.getVar('PATH', d) + oldOeConf = data.getVar('EXTRA_OECONF', d) + if not oldOeConf: oldOeConf = "" + if len(which(path, 'gcc-3.4')) != 0: + data.setVar('EXTRA_OECONF', oldOeConf + " --cc=gcc-3.4", d) + elif len(which(path, 'gcc-3.3')) != 0: + data.setVar('EXTRA_OECONF', oldOeConf + " --cc=gcc-3.3", d) + elif len(which(path, 'gcc-3.3.6')) != 0: + data.setVar('EXTRA_OECONF', oldOeConf + " --cc=gcc-3.3.6", d) +} + +do_stage() { + find . -name "qemu-*" -type f -perm -755 -exec install -m 0755 {} ${STAGING_BINDIR} \; +} diff --git a/org.handhelds.familiar/packages/qemu/qemu-native_cvs.bb b/org.handhelds.familiar/packages/qemu/qemu-native_cvs.bb new file mode 100644 index 0000000..639f9a6 --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/qemu-native_cvs.bb @@ -0,0 +1,3 @@ +require qemu_cvs.bb +inherit native +require qemu-native.inc diff --git a/org.handhelds.familiar/packages/qemu/qemu-qop-nogfx-native_svn.bb b/org.handhelds.familiar/packages/qemu/qemu-qop-nogfx-native_svn.bb new file mode 100644 index 0000000..d37b7e6 --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/qemu-qop-nogfx-native_svn.bb @@ -0,0 +1,18 @@ +LICENSE = "GPL" +PV = "0.8.0+svn${CVSDATE}" +PROVIDES = "qemu-native" + +SRC_URI = "svn://nowt.dyndns.org/svn/qemu;module=trunk;proto=https \ + file://configure.patch;patch=1 \ + " + +S = "${WORKDIR}/trunk" + +inherit autotools native + +EXTRA_OECONF = "--disable-gcc-check --target-list=arm-user,arm-softmmu --disable-gfx-check" + +prefix = "${STAGING_DIR}/${BUILD_SYS}" + +# tested to work with gcc4 for arm target only +# this is purely for others to test, not intended to be used as a replacement for the real qemu diff --git a/org.handhelds.familiar/packages/qemu/qemu_cvs.bb b/org.handhelds.familiar/packages/qemu/qemu_cvs.bb new file mode 100644 index 0000000..8d8fcc4 --- /dev/null +++ b/org.handhelds.familiar/packages/qemu/qemu_cvs.bb @@ -0,0 +1,21 @@ +DESCRIPTION = "Qemu is an open source processor emulator." +HOMEPAGE = "http://fabrice.bellard.free.fr/qemu/" +SECTION = "devel" +LICENSE = "GPL" +PV = "0.8.2+cvs${CVSDATE}" +PR = "r1" + +SRC_URI = "cvs://anonymous@cvs.savannah.nongnu.org/sources/qemu;method=pserver;rsh=ssh;module=qemu \ + file://configure.patch;patch=1 \ + file://qemu-sdl-cursor.patch;patch=1 \ + file://arm_nptl.patch;patch=1 \ + file://pl110_rgb-r0.patch;patch=1 \ + file://qemu-pci-irq-sharing.patch;patch=1 \ + file://compiler.patch;patch=1 \ + file://qemu-usb-wacom-0.8.2.patch;patch=1 \ + file://qemu-usb-wacom-pressure.patch;patch=1 \ + file://qemu-usb-wacom-buttons.patch;patch=1" +S = "${WORKDIR}/qemu" + +inherit autotools +