From 4072a330cd6d3fc111f488857cec51130e8a3c29 Mon Sep 17 00:00:00 2001 From: Mika Laitio Date: Tue, 21 Nov 2006 16:44:28 +0200 Subject: [PATCH] qemu: add cvs version from 20060723. bb files contain fix for building qemu with gcc 3.3 or 3.3.6 or 3.4 versions even if user has also the gcc 4.x installed. Patches received from openembedded repository. --- .../conf/distro/familiar-0.8.4.conf | 2 + .../packages/qemu/files/arm_nptl.patch | 857 ++++++++++++++++++ .../packages/qemu/files/compiler.patch | 10 + .../packages/qemu/files/configure.patch | 13 + .../packages/qemu/files/pl110_rgb-r0.patch | 219 +++++ .../qemu/files/qemu-pci-irq-sharing.patch | 52 ++ .../packages/qemu/files/qemu-sdl-cursor.patch | 13 + .../qemu/files/qemu-usb-wacom-0.8.2.patch | 445 +++++++++ .../qemu/files/qemu-usb-wacom-buttons.patch | 23 + .../qemu/files/qemu-usb-wacom-pressure.patch | 28 + .../packages/qemu/qemu-native.inc | 25 + .../packages/qemu/qemu-native_cvs.bb | 3 + .../qemu/qemu-qop-nogfx-native_svn.bb | 18 + .../packages/qemu/qemu_cvs.bb | 21 + 14 files changed, 1729 insertions(+) create mode 100644 org.handhelds.familiar/packages/qemu/files/arm_nptl.patch create mode 100644 org.handhelds.familiar/packages/qemu/files/compiler.patch create mode 100644 org.handhelds.familiar/packages/qemu/files/configure.patch create mode 100644 org.handhelds.familiar/packages/qemu/files/pl110_rgb-r0.patch create mode 100644 org.handhelds.familiar/packages/qemu/files/qemu-pci-irq-sharing.patch create mode 100644 org.handhelds.familiar/packages/qemu/files/qemu-sdl-cursor.patch create mode 100644 org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-0.8.2.patch create mode 100644 org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-buttons.patch create mode 100644 org.handhelds.familiar/packages/qemu/files/qemu-usb-wacom-pressure.patch create mode 100644 org.handhelds.familiar/packages/qemu/qemu-native.inc create mode 100644 org.handhelds.familiar/packages/qemu/qemu-native_cvs.bb create mode 100644 org.handhelds.familiar/packages/qemu/qemu-qop-nogfx-native_svn.bb create mode 100644 org.handhelds.familiar/packages/qemu/qemu_cvs.bb diff --git a/org.handhelds.familiar/conf/distro/familiar-0.8.4.conf b/org.handhelds.familiar/conf/distro/familiar-0.8.4.conf index a359662..9d8e4d9 100644 --- a/org.handhelds.familiar/conf/distro/familiar-0.8.4.conf +++ b/org.handhelds.familiar/conf/distro/familiar-0.8.4.conf @@ -44,6 +44,8 @@ PREFERRED_VERSION_gcc-cross ?= "3.4.4" PREFERRED_VERSION_gcc-cross-initial ?= "3.4.4" PREFERRED_VERSION_gcc-cross-sdk ?= "3.4.4" +CVSDATE_qemu-native ?= "20060723" + # # Machines section 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 + -- 2.41.0