From 82b5d4ce1ba5e74f7d700af30d3e4b0a4e2d243e Mon Sep 17 00:00:00 2001 From: Marcin Juszkiewicz Date: Thu, 23 Oct 2008 17:40:41 +0200 Subject: [PATCH] qemu: added SVN version (from Poky) --- .../05_non-fatal_if_linux_hd_missing.patch | 17 + .../qemu-0.9.1+svn/06_exit_segfault.patch | 45 + .../qemu/qemu-0.9.1+svn/10_signal_jobs.patch | 26 + .../qemu-0.9.1+svn/11_signal_sigaction.patch | 21 + .../qemu-0.9.1+svn/22_net_tuntap_stall.patch | 18 + .../qemu/qemu-0.9.1+svn/31_syscalls.patch | 48 + .../qemu-0.9.1+svn/32_syscall_sysctl.patch | 55 + .../qemu-0.9.1+svn/33_syscall_ppc_clone.patch | 22 + .../qemu-0.9.1+svn/39_syscall_fadvise64.patch | 21 + .../qemu-0.9.1+svn/52_ne2000_return.patch | 17 + .../qemu-0.9.1+svn/61_safe_64bit_int.patch | 27 + .../qemu/qemu-0.9.1+svn/63_sparc_build.patch | 18 + .../64_ppc_asm_constraints.patch | 18 + .../qemu/qemu-0.9.1+svn/65_kfreebsd.patch | 35 + packages/qemu/qemu-0.9.1+svn/66_tls_ld.patch | 55 + .../qemu-0.9.1+svn/91-oh-sdl-cursor.patch | 18 + .../configure_symlinkpath_fix.patch | 28 + packages/qemu/qemu-0.9.1+svn/fix_brk.patch | 59 + .../qemu-0.9.1+svn/fix_protection_bits.patch | 14 + .../qemu/qemu-0.9.1+svn/fix_segfault.patch | 37 + packages/qemu/qemu-0.9.1+svn/no-strip.patch | 26 + .../qemu/qemu-0.9.1+svn/qemu-0.9.0-nptl.patch | 1100 ++++++++ .../qemu-amd64-32b-mapping-0.9.0.patch | 37 + .../qemu-0.9.1+svn/qemu-n800-support.patch | 2381 +++++++++++++++++ .../qemu-0.9.1+svn/revert_arm_tcg.patch.gz | Bin 0 -> 97991 bytes packages/qemu/qemu-0.9.1+svn/series | 25 + .../workaround_bad_futex_headers.patch | 25 + packages/qemu/qemu-native_svn.bb | 2 + packages/qemu/qemu_svn.bb | 48 + 29 files changed, 4243 insertions(+) create mode 100644 packages/qemu/qemu-0.9.1+svn/05_non-fatal_if_linux_hd_missing.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/06_exit_segfault.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/10_signal_jobs.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/11_signal_sigaction.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/22_net_tuntap_stall.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/31_syscalls.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/32_syscall_sysctl.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/33_syscall_ppc_clone.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/39_syscall_fadvise64.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/52_ne2000_return.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/61_safe_64bit_int.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/63_sparc_build.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/64_ppc_asm_constraints.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/65_kfreebsd.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/66_tls_ld.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/91-oh-sdl-cursor.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/configure_symlinkpath_fix.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/fix_brk.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/fix_protection_bits.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/fix_segfault.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/no-strip.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/qemu-0.9.0-nptl.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/qemu-amd64-32b-mapping-0.9.0.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/qemu-n800-support.patch create mode 100644 packages/qemu/qemu-0.9.1+svn/revert_arm_tcg.patch.gz create mode 100644 packages/qemu/qemu-0.9.1+svn/series create mode 100644 packages/qemu/qemu-0.9.1+svn/workaround_bad_futex_headers.patch create mode 100644 packages/qemu/qemu-native_svn.bb create mode 100644 packages/qemu/qemu_svn.bb diff --git a/packages/qemu/qemu-0.9.1+svn/05_non-fatal_if_linux_hd_missing.patch b/packages/qemu/qemu-0.9.1+svn/05_non-fatal_if_linux_hd_missing.patch new file mode 100644 index 0000000000..a66737d9ce --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/05_non-fatal_if_linux_hd_missing.patch @@ -0,0 +1,17 @@ +#DPATCHLEVEL=1 +--- +# hw/pc.c | 1 - +# 1 file changed, 1 deletion(-) +# +Index: trunk/hw/pc.c +=================================================================== +--- trunk.orig/hw/pc.c 2008-04-24 20:15:46.000000000 +0100 ++++ trunk/hw/pc.c 2008-04-24 20:15:49.000000000 +0100 +@@ -399,7 +399,6 @@ + if (hda == -1) { + fprintf(stderr, "A disk image must be given for 'hda' when booting " + "a Linux kernel\n"); +- exit(1); + } + + memset(bootsect, 0, sizeof(bootsect)); diff --git a/packages/qemu/qemu-0.9.1+svn/06_exit_segfault.patch b/packages/qemu/qemu-0.9.1+svn/06_exit_segfault.patch new file mode 100644 index 0000000000..bc02d31839 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/06_exit_segfault.patch @@ -0,0 +1,45 @@ +#DPATCHLEVEL=0 +--- +# linux-user/main.c | 8 ++++---- +# 1 file changed, 4 insertions(+), 4 deletions(-) +# +Index: linux-user/main.c +=================================================================== +--- linux-user/main.c.orig 2008-04-24 20:15:46.000000000 +0100 ++++ linux-user/main.c 2008-04-24 20:15:53.000000000 +0100 +@@ -765,7 +765,7 @@ + default: + printf ("Unhandled trap: 0x%x\n", trapnr); + cpu_dump_state(env, stderr, fprintf, 0); +- exit (1); ++ _exit (1); + } + process_pending_signals (env); + } +@@ -1697,7 +1697,7 @@ + default: + printf ("Unhandled trap: 0x%x\n", trapnr); + cpu_dump_state(env, stderr, fprintf, 0); +- exit (1); ++ _exit (1); + } + process_pending_signals (env); + } +@@ -2026,7 +2026,7 @@ + for(item = cpu_log_items; item->mask != 0; item++) { + printf("%-10s %s\n", item->name, item->help); + } +- exit(1); ++ _exit(1); + } + cpu_set_log(mask); + } else if (!strcmp(r, "s")) { +@@ -2045,7 +2045,7 @@ + if (qemu_host_page_size == 0 || + (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) { + fprintf(stderr, "page size must be a power of two\n"); +- exit(1); ++ _exit(1); + } + } else if (!strcmp(r, "g")) { + gdbstub_port = atoi(argv[optind++]); diff --git a/packages/qemu/qemu-0.9.1+svn/10_signal_jobs.patch b/packages/qemu/qemu-0.9.1+svn/10_signal_jobs.patch new file mode 100644 index 0000000000..d79482d2f4 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/10_signal_jobs.patch @@ -0,0 +1,26 @@ +#DPATCHLEVEL=0 +--- +# linux-user/signal.c | 7 ++++++- +# 1 file changed, 6 insertions(+), 1 deletion(-) +# +Index: linux-user/signal.c +=================================================================== +--- linux-user/signal.c.orig 2008-04-24 20:15:46.000000000 +0100 ++++ linux-user/signal.c 2008-04-24 20:15:55.000000000 +0100 +@@ -364,10 +364,15 @@ + k = &sigact_table[sig - 1]; + handler = k->sa._sa_handler; + if (handler == TARGET_SIG_DFL) { ++ if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) { ++ kill(getpid(),SIGSTOP); ++ return 0; ++ } else + /* default handler : ignore some signal. The other are fatal */ + if (sig != TARGET_SIGCHLD && + sig != TARGET_SIGURG && +- sig != TARGET_SIGWINCH) { ++ sig != TARGET_SIGWINCH && ++ sig != TARGET_SIGCONT) { + force_sig(sig); + } else { + return 0; /* indicate ignored */ diff --git a/packages/qemu/qemu-0.9.1+svn/11_signal_sigaction.patch b/packages/qemu/qemu-0.9.1+svn/11_signal_sigaction.patch new file mode 100644 index 0000000000..cd56541b71 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/11_signal_sigaction.patch @@ -0,0 +1,21 @@ +#DPATCHLEVEL=0 +--- +# linux-user/signal.c | 5 +++++ +# 1 file changed, 5 insertions(+) +# +Index: linux-user/signal.c +=================================================================== +--- linux-user/signal.c.orig 2008-04-24 20:15:55.000000000 +0100 ++++ linux-user/signal.c 2008-04-24 20:15:57.000000000 +0100 +@@ -512,6 +512,11 @@ + + if (sig < 1 || sig > TARGET_NSIG || sig == SIGKILL || sig == SIGSTOP) + return -EINVAL; ++ ++ /* no point doing the stuff as those are not allowed for sigaction */ ++ if ((sig == TARGET_SIGKILL) || (sig == TARGET_SIGSTOP)) ++ return -EINVAL; ++ + k = &sigact_table[sig - 1]; + #if defined(DEBUG_SIGNAL) + fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n", diff --git a/packages/qemu/qemu-0.9.1+svn/22_net_tuntap_stall.patch b/packages/qemu/qemu-0.9.1+svn/22_net_tuntap_stall.patch new file mode 100644 index 0000000000..0e1038983b --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/22_net_tuntap_stall.patch @@ -0,0 +1,18 @@ +#DPATCHLEVEL=0 +--- +# vl.c | 2 +- +# 1 file changed, 1 insertion(+), 1 deletion(-) +# +Index: vl.c +=================================================================== +--- vl.c.orig 2008-04-24 20:15:46.000000000 +0100 ++++ vl.c 2008-04-24 20:15:58.000000000 +0100 +@@ -4155,7 +4155,7 @@ + return -1; + } + memset(&ifr, 0, sizeof(ifr)); +- ifr.ifr_flags = IFF_TAP | IFF_NO_PI; ++ ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_ONE_QUEUE; + if (ifname[0] != '\0') + pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname); + else diff --git a/packages/qemu/qemu-0.9.1+svn/31_syscalls.patch b/packages/qemu/qemu-0.9.1+svn/31_syscalls.patch new file mode 100644 index 0000000000..15565ae11d --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/31_syscalls.patch @@ -0,0 +1,48 @@ +#DPATCHLEVEL=0 +--- +# linux-user/syscall.c | 11 ++++++++--- +# 1 file changed, 8 insertions(+), 3 deletions(-) +# +Index: linux-user/syscall.c +=================================================================== +--- linux-user/syscall.c.orig 2008-04-24 20:15:46.000000000 +0100 ++++ linux-user/syscall.c 2008-04-24 20:15:59.000000000 +0100 +@@ -250,6 +250,7 @@ + extern int setresgid(gid_t, gid_t, gid_t); + extern int getresgid(gid_t *, gid_t *, gid_t *); + extern int setgroups(int, gid_t *); ++extern int uselib(const char*); + + #define ERRNO_TABLE_SIZE 1200 + +@@ -4041,7 +4042,8 @@ + #endif + #ifdef TARGET_NR_uselib + case TARGET_NR_uselib: +- goto unimplemented; ++ ret = get_errno(uselib(path((const char*)arg1))); ++ break; + #endif + #ifdef TARGET_NR_swapon + case TARGET_NR_swapon: +@@ -5322,7 +5324,9 @@ + goto unimplemented; + #ifdef TARGET_NR_mincore + case TARGET_NR_mincore: +- goto unimplemented; ++ /*page_unprotect_range((void*)arg3, ((size_t)arg2 + TARGET_PAGE_SIZE - 1) / TARGET_PAGE_SIZE);*/ ++ ret = get_errno(mincore((void*)arg1, (size_t)arg2, (unsigned char*)arg3)); ++ break; + #endif + #ifdef TARGET_NR_madvise + case TARGET_NR_madvise: +@@ -5462,7 +5466,8 @@ + break; + #ifdef TARGET_NR_readahead + case TARGET_NR_readahead: +- goto unimplemented; ++ ret = get_errno(readahead((int)arg1, (off64_t)arg2, (size_t)arg3)); ++ break; + #endif + #ifdef TARGET_NR_setxattr + case TARGET_NR_setxattr: diff --git a/packages/qemu/qemu-0.9.1+svn/32_syscall_sysctl.patch b/packages/qemu/qemu-0.9.1+svn/32_syscall_sysctl.patch new file mode 100644 index 0000000000..d42c44cebc --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/32_syscall_sysctl.patch @@ -0,0 +1,55 @@ +#DPATCHLEVEL=0 +--- +# linux-user/syscall.c | 32 +++++++++++++++++++++++++++++--- +# 1 file changed, 29 insertions(+), 3 deletions(-) +# +Index: linux-user/syscall.c +=================================================================== +--- linux-user/syscall.c.orig 2008-04-24 20:15:59.000000000 +0100 ++++ linux-user/syscall.c 2008-04-24 20:16:01.000000000 +0100 +@@ -52,6 +52,7 @@ + //#include + #include + #include ++#include + + #define termios host_termios + #define winsize host_winsize +@@ -4758,9 +4759,34 @@ + break; + #endif + case TARGET_NR__sysctl: +- /* We don't implement this, but ENOTDIR is always a safe +- return value. */ +- ret = -TARGET_ENOTDIR; ++ { ++ struct __sysctl_args *args = (struct __sysctl_args *) arg1; ++ int *name_target, *name, nlen, *oldlenp, oldlen, newlen, i; ++ void *oldval, *newval; ++ ++ name_target = (int *) tswapl((long) args->name); ++ nlen = tswapl(args->nlen); ++ oldval = (void *) tswapl((long) args->oldval); ++ oldlenp = (int *) tswapl((long) args->oldlenp); ++ oldlen = tswapl(*oldlenp); ++ newval = (void *) tswapl((long) args->newval); ++ newlen = tswapl(args->newlen); ++ ++ name = alloca(nlen * sizeof (int)); ++ for (i = 0; i < nlen; i++) ++ name[i] = tswapl(name_target[i]); ++ ++ if (nlen == 2 && name[0] == CTL_KERN && name[1] == KERN_VERSION) { ++ ret = get_errno( ++ sysctl(name, nlen, oldval, &oldlen, newval, newlen)); ++ if (!is_error(ret)) { ++ *oldlenp = tswapl(oldlen); ++ } ++ } else { ++ gemu_log("qemu: Unsupported sysctl name\n"); ++ ret = -ENOSYS; ++ } ++ } + break; + case TARGET_NR_sched_setparam: + { diff --git a/packages/qemu/qemu-0.9.1+svn/33_syscall_ppc_clone.patch b/packages/qemu/qemu-0.9.1+svn/33_syscall_ppc_clone.patch new file mode 100644 index 0000000000..962f821523 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/33_syscall_ppc_clone.patch @@ -0,0 +1,22 @@ +#DPATCHLEVEL=0 +--- +# linux-user/syscall.c | 6 +----- +# 1 file changed, 1 insertion(+), 5 deletions(-) +# +Index: linux-user/syscall.c +=================================================================== +--- linux-user/syscall.c.orig 2008-04-24 20:16:01.000000000 +0100 ++++ linux-user/syscall.c 2008-04-24 20:16:02.000000000 +0100 +@@ -2760,11 +2760,7 @@ + if (!newsp) + newsp = env->gpr[1]; + new_env->gpr[1] = newsp; +- { +- int i; +- for (i = 7; i < 32; i++) +- new_env->gpr[i] = 0; +- } ++ new_env->gpr[3] = 0; + #elif defined(TARGET_SH4) + if (!newsp) + newsp = env->gregs[15]; diff --git a/packages/qemu/qemu-0.9.1+svn/39_syscall_fadvise64.patch b/packages/qemu/qemu-0.9.1+svn/39_syscall_fadvise64.patch new file mode 100644 index 0000000000..845232cfca --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/39_syscall_fadvise64.patch @@ -0,0 +1,21 @@ +--- + linux-user/syscall.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +Index: linux-user/syscall.c +=================================================================== +--- linux-user/syscall.c.orig 2008-04-24 20:16:02.000000000 +0100 ++++ linux-user/syscall.c 2008-04-24 20:16:03.000000000 +0100 +@@ -5350,6 +5350,12 @@ + ret = get_errno(mincore((void*)arg1, (size_t)arg2, (unsigned char*)arg3)); + break; + #endif ++#ifdef TARGET_NR_fadvise64_64 ++ case TARGET_NR_fadvise64_64: ++ /* Just return success */ ++ ret = get_errno(0); ++ break; ++#endif + #ifdef TARGET_NR_madvise + case TARGET_NR_madvise: + /* A straight passthrough may not be safe because qemu sometimes diff --git a/packages/qemu/qemu-0.9.1+svn/52_ne2000_return.patch b/packages/qemu/qemu-0.9.1+svn/52_ne2000_return.patch new file mode 100644 index 0000000000..e364bff731 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/52_ne2000_return.patch @@ -0,0 +1,17 @@ +--- + hw/ne2000.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Index: trunk/hw/ne2000.c +=================================================================== +--- trunk.orig/hw/ne2000.c 2008-04-24 20:15:46.000000000 +0100 ++++ trunk/hw/ne2000.c 2008-04-24 20:16:05.000000000 +0100 +@@ -217,7 +217,7 @@ + NE2000State *s = opaque; + + if (s->cmd & E8390_STOP) +- return 1; ++ return 0; + return !ne2000_buffer_full(s); + } + diff --git a/packages/qemu/qemu-0.9.1+svn/61_safe_64bit_int.patch b/packages/qemu/qemu-0.9.1+svn/61_safe_64bit_int.patch new file mode 100644 index 0000000000..9a67feac6b --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/61_safe_64bit_int.patch @@ -0,0 +1,27 @@ +#DPATCHLEVEL=0 +--- +# dyngen-exec.h | 4 ++-- +# 1 file changed, 2 insertions(+), 2 deletions(-) +# +Index: dyngen-exec.h +=================================================================== +--- dyngen-exec.h.orig 2008-04-24 20:15:46.000000000 +0100 ++++ dyngen-exec.h 2008-04-24 20:16:06.000000000 +0100 +@@ -38,7 +38,7 @@ + // Linux/Sparc64 defines uint64_t + #if !(defined (__sparc_v9__) && defined(__linux__)) + /* XXX may be done for all 64 bits targets ? */ +-#if defined (__x86_64__) || defined(__ia64) || defined(__s390x__) || defined(__alpha__) ++#if defined (__x86_64__) || defined(__ia64) || defined(__s390x__) || defined(__alpha__) || defined(__sparc__) + typedef unsigned long uint64_t; + #else + typedef unsigned long long uint64_t; +@@ -55,7 +55,7 @@ + typedef signed int int32_t; + // Linux/Sparc64 defines int64_t + #if !(defined (__sparc_v9__) && defined(__linux__)) +-#if defined (__x86_64__) || defined(__ia64) || defined(__s390x__) || defined(__alpha__) ++#if defined (__x86_64__) || defined(__ia64) || defined(__s390x__) || defined(__alpha__) || defined(__sparc__) + typedef signed long int64_t; + #else + typedef signed long long int64_t; diff --git a/packages/qemu/qemu-0.9.1+svn/63_sparc_build.patch b/packages/qemu/qemu-0.9.1+svn/63_sparc_build.patch new file mode 100644 index 0000000000..097f55a09e --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/63_sparc_build.patch @@ -0,0 +1,18 @@ +#DPATCHLEVEL=0 +--- +# sparc.ld | 2 +- +# 1 file changed, 1 insertion(+), 1 deletion(-) +# +Index: sparc.ld +=================================================================== +--- sparc.ld.orig 2008-04-24 20:15:46.000000000 +0100 ++++ sparc.ld 2008-04-24 20:16:07.000000000 +0100 +@@ -6,7 +6,7 @@ + SECTIONS + { + /* Read-only sections, merged into text segment: */ +- . = 0x60000000 + SIZEOF_HEADERS; ++ . = 0x60000000 + 0x400; + .interp : { *(.interp) } + .hash : { *(.hash) } + .dynsym : { *(.dynsym) } diff --git a/packages/qemu/qemu-0.9.1+svn/64_ppc_asm_constraints.patch b/packages/qemu/qemu-0.9.1+svn/64_ppc_asm_constraints.patch new file mode 100644 index 0000000000..7d19817278 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/64_ppc_asm_constraints.patch @@ -0,0 +1,18 @@ +#DPATCHLEVEL=1 +--- +# cpu-all.h | 2 +- +# 1 file changed, 1 insertion(+), 1 deletion(-) +# +Index: trunk/cpu-all.h +=================================================================== +--- trunk.orig/cpu-all.h 2008-04-24 20:15:46.000000000 +0100 ++++ trunk/cpu-all.h 2008-04-24 20:16:08.000000000 +0100 +@@ -285,7 +285,7 @@ + static inline void stl_le_p(void *ptr, int v) + { + #ifdef __powerpc__ +- __asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*(uint32_t *)ptr) : "r" (v), "r" (ptr)); ++ __asm__ __volatile__ ("stwbrx %0,0,%1" : : "r" (v), "r" (ptr) : "memory"); + #else + uint8_t *p = ptr; + p[0] = v; diff --git a/packages/qemu/qemu-0.9.1+svn/65_kfreebsd.patch b/packages/qemu/qemu-0.9.1+svn/65_kfreebsd.patch new file mode 100644 index 0000000000..028e85a878 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/65_kfreebsd.patch @@ -0,0 +1,35 @@ +--- + configure | 6 ++++++ + vl.c | 2 ++ + 2 files changed, 8 insertions(+) + +Index: configure +=================================================================== +--- configure.orig 2008-04-24 20:15:46.000000000 +0100 ++++ configure 2008-04-24 20:16:09.000000000 +0100 +@@ -135,6 +135,12 @@ + kqemu="yes" + fi + ;; ++GNU/kFreeBSD) ++oss="yes" ++if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then ++ kqemu="yes" ++fi ++;; + FreeBSD) + bsd="yes" + oss="yes" +Index: vl.c +=================================================================== +--- vl.c.orig 2008-04-24 20:15:58.000000000 +0100 ++++ vl.c 2008-04-24 20:16:09.000000000 +0100 +@@ -97,6 +97,8 @@ + #include + #endif + #endif ++#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__) ++#include + #else + #include + int inet_aton(const char *cp, struct in_addr *ia); diff --git a/packages/qemu/qemu-0.9.1+svn/66_tls_ld.patch b/packages/qemu/qemu-0.9.1+svn/66_tls_ld.patch new file mode 100644 index 0000000000..cbd3f873d8 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/66_tls_ld.patch @@ -0,0 +1,55 @@ +--- + arm.ld | 7 +++++++ + i386.ld | 7 +++++++ + 2 files changed, 14 insertions(+) + +Index: arm.ld +=================================================================== +--- arm.ld.orig 2008-04-24 20:15:45.000000000 +0100 ++++ arm.ld 2008-04-24 20:16:11.000000000 +0100 +@@ -26,6 +26,10 @@ + { *(.rel.rodata) *(.rel.gnu.linkonce.r*) } + .rela.rodata : + { *(.rela.rodata) *(.rela.gnu.linkonce.r*) } ++ .rel.tdata : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) } ++ .rela.tdata : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) } ++ .rel.tbss : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) } ++ .rela.tbss : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) } + .rel.got : { *(.rel.got) } + .rela.got : { *(.rela.got) } + .rel.ctors : { *(.rel.ctors) } +@@ -58,6 +62,9 @@ + .ARM.exidx : { *(.ARM.exidx* .gnu.linkonce.armexidx.*) } + __exidx_end = .; + .reginfo : { *(.reginfo) } ++ /* Thread Local Storage sections */ ++ .tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) } ++ .tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } + /* Adjust the address for the data segment. We want to adjust up to + the same address within the page on the next page up. */ + . = ALIGN(0x100000) + (. & (0x100000 - 1)); +Index: i386.ld +=================================================================== +--- i386.ld.orig 2008-04-24 20:15:45.000000000 +0100 ++++ i386.ld 2008-04-24 20:16:11.000000000 +0100 +@@ -28,6 +28,10 @@ + { *(.rel.rodata) *(.rel.gnu.linkonce.r*) } + .rela.rodata : + { *(.rela.rodata) *(.rela.gnu.linkonce.r*) } ++ .rel.tdata : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) } ++ .rela.tdata : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) } ++ .rel.tbss : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) } ++ .rela.tbss : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) } + .rel.got : { *(.rel.got) } + .rela.got : { *(.rela.got) } + .rel.ctors : { *(.rel.ctors) } +@@ -53,6 +57,9 @@ + _etext = .; + PROVIDE (etext = .); + .fini : { *(.fini) } =0x47ff041f ++ /* Thread Local Storage sections */ ++ .tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) } ++ .tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } + . = ALIGN(32 / 8); + PROVIDE (__preinit_array_start = .); + .preinit_array : { *(.preinit_array) } diff --git a/packages/qemu/qemu-0.9.1+svn/91-oh-sdl-cursor.patch b/packages/qemu/qemu-0.9.1+svn/91-oh-sdl-cursor.patch new file mode 100644 index 0000000000..b3d95a4534 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/91-oh-sdl-cursor.patch @@ -0,0 +1,18 @@ +=== modified file 'sdl.c' +--- + sdl.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Index: sdl.c +=================================================================== +--- sdl.c.orig 2008-04-24 20:15:45.000000000 +0100 ++++ sdl.c 2008-04-24 20:16:12.000000000 +0100 +@@ -247,7 +247,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/packages/qemu/qemu-0.9.1+svn/configure_symlinkpath_fix.patch b/packages/qemu/qemu-0.9.1+svn/configure_symlinkpath_fix.patch new file mode 100644 index 0000000000..3ec304a38c --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/configure_symlinkpath_fix.patch @@ -0,0 +1,28 @@ +Index: qemu-0.9.1/configure +=================================================================== +--- qemu-0.9.1.orig/configure 2008-01-24 15:33:13.000000000 +0000 ++++ qemu-0.9.1/configure 2008-01-24 15:45:50.000000000 +0000 +@@ -209,15 +209,17 @@ + + # find source path + source_path=`dirname "$0"` ++source_path_used="no" ++workdir=`pwd` ++workdir=`readlink -f $workdir` + if [ -z "$source_path" ]; then +- source_path=`pwd` ++ source_path=$workdir + else + source_path=`cd "$source_path"; pwd` +-fi +-if test "$source_path" = `pwd` ; then +- source_path_used="no" +-else +- source_path_used="yes" ++ source_path=`readlink -f $source_path` ++ if test "$source_path" != "$workdir" ; then ++ source_path_used="yes" ++ fi + fi + + werror="no" diff --git a/packages/qemu/qemu-0.9.1+svn/fix_brk.patch b/packages/qemu/qemu-0.9.1+svn/fix_brk.patch new file mode 100644 index 0000000000..f15e001dd6 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/fix_brk.patch @@ -0,0 +1,59 @@ +Index: trunk/linux-user/syscall.c +=================================================================== +--- trunk.orig/linux-user/syscall.c 2008-04-24 20:16:24.000000000 +0100 ++++ trunk/linux-user/syscall.c 2008-04-24 20:16:32.000000000 +0100 +@@ -440,7 +440,7 @@ + if (!new_brk) + return target_brk; + if (new_brk < target_original_brk) +- return -TARGET_ENOMEM; ++ return target_brk; + + brk_page = HOST_PAGE_ALIGN(target_brk); + +@@ -455,12 +455,11 @@ + mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size, + PROT_READ|PROT_WRITE, + MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0)); +- if (is_error(mapped_addr)) { +- return mapped_addr; +- } else { ++ ++ if (!is_error(mapped_addr)) + target_brk = new_brk; +- return target_brk; +- } ++ ++ return target_brk; + } + + static inline abi_long copy_from_user_fdset(fd_set *fds, +Index: trunk/linux-user/mmap.c +=================================================================== +--- trunk.orig/linux-user/mmap.c 2008-04-24 20:16:16.000000000 +0100 ++++ trunk/linux-user/mmap.c 2008-04-24 20:16:32.000000000 +0100 +@@ -264,6 +264,9 @@ + host_start += offset - host_offset; + start = h2g(host_start); + } else { ++ int flg; ++ target_ulong addr; ++ + if (start & ~TARGET_PAGE_MASK) { + errno = EINVAL; + return -1; +@@ -271,6 +274,14 @@ + end = start + len; + real_end = HOST_PAGE_ALIGN(end); + ++ for(addr = real_start; addr < real_end; addr += TARGET_PAGE_SIZE) { ++ flg = page_get_flags(addr); ++ if( flg & PAGE_RESERVED ) { ++ errno = ENXIO; ++ return -1; ++ } ++ } ++ + /* worst case: we cannot map the file because the offset is not + aligned, so we read it */ + if (!(flags & MAP_ANONYMOUS) && diff --git a/packages/qemu/qemu-0.9.1+svn/fix_protection_bits.patch b/packages/qemu/qemu-0.9.1+svn/fix_protection_bits.patch new file mode 100644 index 0000000000..ee2b077602 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/fix_protection_bits.patch @@ -0,0 +1,14 @@ +Index: qemu-0.9.1/linux-user/mmap.c +=================================================================== +--- qemu-0.9.1.orig/linux-user/mmap.c 2008-04-16 14:10:26.000000000 +0100 ++++ qemu-0.9.1/linux-user/mmap.c 2008-04-16 14:10:51.000000000 +0100 +@@ -49,8 +49,7 @@ + end = start + len; + if (end < start) + return -EINVAL; +- if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC)) +- return -EINVAL; ++ prot = prot & (PROT_READ | PROT_WRITE | PROT_EXEC); + if (len == 0) + return 0; + diff --git a/packages/qemu/qemu-0.9.1+svn/fix_segfault.patch b/packages/qemu/qemu-0.9.1+svn/fix_segfault.patch new file mode 100644 index 0000000000..224a8b813d --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/fix_segfault.patch @@ -0,0 +1,37 @@ +--- + linux-user/syscall.c | 22 ---------------------- + 1 file changed, 22 deletions(-) + +Index: trunk/linux-user/syscall.c +=================================================================== +--- trunk.orig/linux-user/syscall.c 2008-04-24 20:16:21.000000000 +0100 ++++ trunk/linux-user/syscall.c 2008-04-24 20:16:24.000000000 +0100 +@@ -5728,28 +5728,6 @@ + goto unimplemented_nowarn; + #endif + +-#ifdef TARGET_NR_clock_gettime +- case TARGET_NR_clock_gettime: +- { +- struct timespec ts; +- ret = get_errno(clock_gettime(arg1, &ts)); +- if (!is_error(ret)) { +- host_to_target_timespec(arg2, &ts); +- } +- break; +- } +-#endif +-#ifdef TARGET_NR_clock_getres +- case TARGET_NR_clock_getres: +- { +- struct timespec ts; +- ret = get_errno(clock_getres(arg1, &ts)); +- if (!is_error(ret)) { +- host_to_target_timespec(arg2, &ts); +- } +- break; +- } +-#endif + + #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address) + case TARGET_NR_set_tid_address: diff --git a/packages/qemu/qemu-0.9.1+svn/no-strip.patch b/packages/qemu/qemu-0.9.1+svn/no-strip.patch new file mode 100644 index 0000000000..4813dd4e2b --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/no-strip.patch @@ -0,0 +1,26 @@ +Index: trunk/Makefile +=================================================================== +--- trunk.orig/Makefile 2008-04-24 20:15:37.000000000 +0100 ++++ trunk/Makefile 2008-04-24 20:16:30.000000000 +0100 +@@ -196,7 +196,7 @@ + install: all $(if $(BUILD_DOCS),install-doc) + mkdir -p "$(DESTDIR)$(bindir)" + ifneq ($(TOOLS),) +- $(INSTALL) -m 755 -s $(TOOLS) "$(DESTDIR)$(bindir)" ++ $(INSTALL) -m 755 $(TOOLS) "$(DESTDIR)$(bindir)" + endif + mkdir -p "$(DESTDIR)$(datadir)" + set -e; for x in bios.bin vgabios.bin vgabios-cirrus.bin ppc_rom.bin \ +Index: trunk/Makefile.target +=================================================================== +--- trunk.orig/Makefile.target 2008-04-24 20:15:37.000000000 +0100 ++++ trunk/Makefile.target 2008-04-24 20:16:30.000000000 +0100 +@@ -685,7 +685,7 @@ + + install: all + ifneq ($(PROGS),) +- $(INSTALL) -m 755 -s $(PROGS) "$(DESTDIR)$(bindir)" ++ $(INSTALL) -m 755 $(PROGS) "$(DESTDIR)$(bindir)" + endif + + # Include automatically generated dependency files diff --git a/packages/qemu/qemu-0.9.1+svn/qemu-0.9.0-nptl.patch b/packages/qemu/qemu-0.9.1+svn/qemu-0.9.0-nptl.patch new file mode 100644 index 0000000000..ac68ebf460 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/qemu-0.9.0-nptl.patch @@ -0,0 +1,1100 @@ +--- + configure | 25 ++++++ + exec-all.h | 165 ------------------------------------------ + linux-user/arm/syscall.h | 4 - + linux-user/main.c | 94 +++++++++++++++++++++--- + linux-user/qemu.h | 3 + linux-user/syscall.c | 91 ++++++++++++++++++++++- + qemu_spinlock.h | 181 +++++++++++++++++++++++++++++++++++++++++++++++ + target-arm/cpu.h | 10 ++ + target-arm/op.c | 6 + + target-arm/translate.c | 9 ++ + 10 files changed, 405 insertions(+), 183 deletions(-) + +Index: trunk/configure +=================================================================== +--- trunk.orig/configure 2008-04-24 20:16:52.000000000 +0100 ++++ trunk/configure 2008-04-24 20:16:53.000000000 +0100 +@@ -112,6 +112,7 @@ + build_docs="no" + uname_release="" + curses="yes" ++nptl="yes" + + # OS specific + targetos=`uname -s` +@@ -339,6 +340,8 @@ + ;; + *) echo "ERROR: unknown option $opt"; show_help="yes" + ;; ++ --disable-nptl) nptl="no" ++ ;; + esac + done + +@@ -436,6 +439,7 @@ + echo " --disable-linux-user disable all linux usermode emulation targets" + echo " --enable-darwin-user enable all darwin usermode emulation targets" + echo " --disable-darwin-user disable all darwin usermode emulation targets" ++echo " --disable-nptl disable usermode NPTL guest support" + echo " --fmod-lib path to FMOD library" + echo " --fmod-inc path to FMOD includes" + echo " --enable-uname-release=R Return R for uname -r in usermode emulation" +@@ -647,6 +651,23 @@ + } + EOF + ++# 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 + +@@ -845,6 +866,7 @@ + echo "Documentation $build_docs" + [ ! -z "$uname_release" ] && \ + echo "uname -r $uname_release" ++echo "NPTL support $nptl" + + if test $sdl_too_old = "yes"; then + echo "-> Your SDL version is too old - please upgrade to have SDL support" +@@ -1228,6 +1250,9 @@ + echo "#define TARGET_ARM 1" >> $config_h + echo "#define CONFIG_NO_DYNGEN_OP 1" >> $config_h + bflt="yes" ++ if test "$nptl" = "yes" ; then ++ echo "#define USE_NPTL 1" >> $config_h ++ fi + ;; + cris) + echo "TARGET_ARCH=cris" >> $config_mak +Index: trunk/exec-all.h +=================================================================== +--- trunk.orig/exec-all.h 2008-04-24 20:16:41.000000000 +0100 ++++ trunk/exec-all.h 2008-04-24 20:16:53.000000000 +0100 +@@ -303,217 +303,7 @@ + extern CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4]; + extern void *io_mem_opaque[IO_MEM_NB_ENTRIES]; + +-#if defined(__hppa__) +- +-typedef int spinlock_t[4]; +- +-#define SPIN_LOCK_UNLOCKED { 1, 1, 1, 1 } +- +-static inline void resetlock (spinlock_t *p) +-{ +- (*p)[0] = (*p)[1] = (*p)[2] = (*p)[3] = 1; +-} +- +-#else +- +-typedef int spinlock_t; +- +-#define SPIN_LOCK_UNLOCKED 0 +- +-static inline void resetlock (spinlock_t *p) +-{ +- *p = SPIN_LOCK_UNLOCKED; +-} +- +-#endif +- +-#if defined(__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; +-} +-#elif defined(__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; +-} +-#elif defined(__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; +-} +-#elif defined(__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; +-} +-#elif defined(__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; +-} +-#elif defined(__sparc__) +-static inline int testandset (int *p) +-{ +- int ret; +- +- __asm__ __volatile__("ldstub [%1], %0" +- : "=r" (ret) +- : "r" (p) +- : "memory"); +- +- return (ret ? 1 : 0); +-} +-#elif defined(__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; +-} +-#elif defined(__mc68000) +-static inline int testandset (int *p) +-{ +- char ret; +- __asm__ __volatile__("tas %1; sne %0" +- : "=r" (ret) +- : "m" (p) +- : "cc","memory"); +- return ret; +-} +-#elif defined(__hppa__) +- +-/* Because malloc only guarantees 8-byte alignment for malloc'd data, +- and GCC only guarantees 8-byte alignment for stack locals, we can't +- be assured of 16-byte alignment for atomic lock data even if we +- specify "__attribute ((aligned(16)))" in the type declaration. So, +- we use a struct containing an array of four ints for the atomic lock +- type and dynamically select the 16-byte aligned int from the array +- for the semaphore. */ +-#define __PA_LDCW_ALIGNMENT 16 +-static inline void *ldcw_align (void *p) { +- unsigned long a = (unsigned long)p; +- a = (a + __PA_LDCW_ALIGNMENT - 1) & ~(__PA_LDCW_ALIGNMENT - 1); +- return (void *)a; +-} +- +-static inline int testandset (spinlock_t *p) +-{ +- unsigned int ret; +- p = ldcw_align(p); +- __asm__ __volatile__("ldcw 0(%1),%0" +- : "=r" (ret) +- : "r" (p) +- : "memory" ); +- return !ret; +-} +- +-#elif defined(__ia64) +- +-#include +- +-static inline int testandset (int *p) +-{ +- return __sync_lock_test_and_set (p, 1); +-} +-#elif defined(__mips__) +-static inline int testandset (int *p) +-{ +- int ret; +- +- __asm__ __volatile__ ( +- " .set push \n" +- " .set noat \n" +- " .set mips2 \n" +- "1: li $1, 1 \n" +- " ll %0, %1 \n" +- " sc $1, %1 \n" +- " beqz $1, 1b \n" +- " .set pop " +- : "=r" (ret), "+R" (*p) +- : +- : "memory"); +- +- return ret; +-} +-#else +-#error unimplemented CPU support +-#endif +- +-#if defined(CONFIG_USER_ONLY) +-static inline void spin_lock(spinlock_t *lock) +-{ +- while (testandset(lock)); +-} +- +-static inline void spin_unlock(spinlock_t *lock) +-{ +- resetlock(lock); +-} +- +-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: trunk/linux-user/arm/syscall.h +=================================================================== +--- trunk.orig/linux-user/arm/syscall.h 2008-04-24 20:16:41.000000000 +0100 ++++ trunk/linux-user/arm/syscall.h 2008-04-24 20:16: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: trunk/linux-user/main.c +=================================================================== +--- trunk.orig/linux-user/main.c 2008-04-24 20:16:47.000000000 +0100 ++++ trunk/linux-user/main.c 2008-04-24 20:17:38.000000000 +0100 +@@ -365,6 +365,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_tls2; ++ 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; +@@ -475,10 +519,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)) { +@@ -489,14 +531,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; + } +@@ -535,6 +597,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", +@@ -1994,6 +2060,11 @@ + int drop_ld_preload = 0, environ_count = 0; + char **target_environ, **wrk, **dst; + ++ char *assume_kernel = getenv("QEMU_ASSUME_KERNEL"); ++ ++ if (assume_kernel) ++ setenv("LD_ASSUME_KERNEL", assume_kernel, 1); ++ + if (argc <= 1) + usage(); + +@@ -2403,6 +2474,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); + #endif + + if (gdbstub_port) { +Index: trunk/linux-user/qemu.h +=================================================================== +--- trunk.orig/linux-user/qemu.h 2008-04-24 20:16:41.000000000 +0100 ++++ trunk/linux-user/qemu.h 2008-04-24 20:16:53.000000000 +0100 +@@ -107,6 +107,9 @@ + uint32_t heap_base; + uint32_t heap_limit; + #endif ++#ifdef USE_NPTL ++ uint32_t *child_tidptr; ++#endif + int used; /* non zero if used */ + struct image_info *info; + uint8_t stack[0]; +Index: trunk/linux-user/syscall.c +=================================================================== +--- trunk.orig/linux-user/syscall.c 2008-04-24 20:16:50.000000000 +0100 ++++ trunk/linux-user/syscall.c 2008-04-24 20:19:52.000000000 +0100 +@@ -61,6 +61,7 @@ + #define tchars host_tchars /* same as target */ + #define ltchars host_ltchars /* same as target */ + ++#include + #include + #include + #include +@@ -71,9 +72,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) \ + || defined(TARGET_M68K) || defined(TARGET_SH4) || defined(TARGET_CRIS) + /* 16 bit uid wrappers emulation */ +@@ -2695,16 +2705,25 @@ + return 0; + } + #endif +- + #endif /* defined(TARGET_I386) */ + + /* this stack is the equivalent of the kernel stack associated with a + 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; +@@ -2712,15 +2731,27 @@ + + /* do_fork() Must return host values and target errnos (unlike most + do_*() functions). */ +-int do_fork(CPUState *env, unsigned int flags, abi_ulong 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; ++#if defined(TARGET_I386) ++ uint64_t *new_gdt_table; ++#endif ++#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); ++ if (!ts) ++ return -ENOMEM; + memset(ts, 0, sizeof(TaskState)); + new_stack = ts->stack; + ts->used = 1; +@@ -2732,6 +2763,29 @@ + #if defined(TARGET_I386) + if (!newsp) + newsp = env->regs[R_ESP]; ++ new_gdt_table = malloc(9 * 8); ++ if (!new_gdt_table) { ++ free(new_env); ++ return -ENOMEM; ++ } ++ /* Copy main GDT table from parent, but clear TLS entries */ ++ memcpy(new_gdt_table, g2h(env->gdt.base), 6 * 8); ++ memset(&new_gdt_table[6], 0, 3 * 8); ++ new_env->gdt.base = h2g(new_gdt_table); ++ if (flags & 0x00080000 /* CLONE_SETTLS */) { ++ ret = do_set_thread_area(new_env, new_env->regs[R_ESI]); ++ if (ret) { ++ free(new_gdt_table); ++ free(new_env); ++ return ret; ++ } ++ } ++ cpu_x86_load_seg(env, R_CS, new_env->regs[R_CS]); ++ cpu_x86_load_seg(env, R_DS, new_env->regs[R_DS]); ++ cpu_x86_load_seg(env, R_ES, new_env->regs[R_ES]); ++ cpu_x86_load_seg(env, R_SS, new_env->regs[R_SS]); ++ cpu_x86_load_seg(env, R_FS, new_env->regs[R_FS]); ++ cpu_x86_load_seg(env, R_GS, new_env->regs[R_GS]); + new_env->regs[R_ESP] = newsp; + new_env->regs[R_EAX] = 0; + #elif defined(TARGET_ARM) +@@ -2784,16 +2838,67 @@ + #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 ++ ++ if (CLONE_VFORK & flags) ++ flags ^= CLONE_VM; + #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) ++ 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; + } +@@ -3052,6 +3157,68 @@ + unlock_user_struct(target_ts, target_addr, 1); + } + ++static long do_futex(target_ulong uaddr, int op, uint32_t val, ++ target_ulong utime, target_ulong uaddr2, ++ uint32_t val3) ++{ ++ struct timespec host_utime; ++ unsigned long val2 = utime; ++ ++ if (utime && (op == FUTEX_WAIT || op == FUTEX_LOCK_PI)) { ++ target_to_host_timespec(&host_utime, utime); ++ val2 = (unsigned long)&host_utime; ++ } ++ ++#ifdef BSWAP_NEEDED ++ switch(op) { ++ case FUTEX_CMP_REQUEUE: ++ val3 = tswap32(val3); ++ case FUTEX_REQUEUE: ++ val2 = tswap32(val2); ++ case FUTEX_WAIT: ++ case FUTEX_WAKE: ++ val = tswap32(val); ++ case FUTEX_LOCK_PI: /* This one's icky, but comes out OK */ ++ case FUTEX_UNLOCK_PI: ++ break; ++ default: ++ gemu_log("qemu: Unsupported futex op %d\n", op); ++ return -ENOSYS; ++ } ++#if 0 /* No, it's worse than this */ ++ if (op == FUTEX_WAKE_OP) { ++ /* Need to munge the secondary operation (val3) */ ++ val3 = tswap32(val3); ++ int op2 = (val3 >> 28) & 7; ++ int cmp = (val3 >> 24) & 15; ++ int oparg = (val3 << 8) >> 20; ++ int cmparg = (val3 << 20) >> 20; ++ int shift = val3 & (FUTEX_OP_OPARG_SHIFT << 28); ++ ++ if (shift) ++ oparg = (oparg & 7) + 24 - (oparg & 24); ++ else oparg = ++ if (op2 == FUTEX_OP_ADD) { ++ gemu_log("qemu: Unsupported wrong-endian FUTEX_OP_ADD\n"); ++ return -ENOSYS; ++ } ++ if (cmparg == FUTEX_OP_CMP_LT || cmparg == FUTEX_OP_CMP_GE || ++ cmparg == FUTEX_OP_CMP_LE || cmparg == FUTEX_OP_CMP_GT) { ++ gemu_log("qemu: Unsupported wrong-endian futex cmparg %d\n", cmparg); ++ return -ENOSYS; ++ } ++ val3 = shift | (op2<<28) | (cmp<<24) | (oparg<<12) | cmparg; ++ } ++#endif ++#endif ++ return syscall(__NR_futex, g2h(uaddr), op, val, val2, g2h(uaddr2), val3); ++} ++ ++int do_set_tid_address(target_ulong tidptr) ++{ ++ return syscall(__NR_set_tid_address, g2h(tidptr)); ++} ++ + /* do_syscall() should always have a single exit point at the end so + that actions, such as logging of syscall results, can be performed. + All errnos that do_syscall() returns must be -TARGET_. */ +@@ -3076,7 +3243,7 @@ + _mcleanup(); + #endif + gdb_exit(cpu_env, arg1); +- /* XXX: should free thread stack and CPU env */ ++ /* XXX: should free thread stack, GDT and CPU env */ + _exit(arg1); + ret = 0; /* avoid warning */ + break; +@@ -3118,7 +3285,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; + #ifdef TARGET_NR_waitpid + case TARGET_NR_waitpid: +@@ -4482,7 +4649,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 */ +@@ -4943,7 +5111,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 +@@ -5521,6 +5690,9 @@ + #elif defined(TARGET_I386) && defined(TARGET_ABI32) + ret = do_set_thread_area(cpu_env, arg1); + break; ++#elif TARGET_i386 ++ ret = get_errno(do_set_thread_area(cpu_env, arg1)); ++ break; + #else + goto unimplemented_nowarn; + #endif +@@ -5538,6 +5710,12 @@ + goto unimplemented_nowarn; + #endif + ++#ifdef TARGET_NR_futex ++ case TARGET_NR_futex: ++ ret = get_errno(do_futex(arg1, arg2, arg3, arg4, arg5, arg6)); ++ break; ++#endif ++ + #ifdef TARGET_NR_clock_gettime + case TARGET_NR_clock_gettime: + { +Index: trunk/qemu_spinlock.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ trunk/qemu_spinlock.h 2008-04-24 20:16:53.000000000 +0100 +@@ -0,0 +1,250 @@ ++/* ++ * Atomic operation helper include ++ * ++ * Copyright (c) 2005 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 __hppa__ ++/* Because malloc only guarantees 8-byte alignment for malloc'd data, ++ and GCC only guarantees 8-byte alignment for stack locals, we can't ++ be assured of 16-byte alignment for atomic lock data even if we ++ specify "__attribute ((aligned(16)))" in the type declaration. So, ++ we use a struct containing an array of four ints for the atomic lock ++ type and dynamically select the 16-byte aligned int from the array ++ for the semaphore. */ ++#define __PA_LDCW_ALIGNMENT 16 ++static inline void *ldcw_align (void *p) { ++ unsigned long a = (unsigned long)p; ++ a = (a + __PA_LDCW_ALIGNMENT - 1) & ~(__PA_LDCW_ALIGNMENT - 1); ++ return (void *)a; ++} ++ ++static inline int testandset (spinlock_t *p) ++{ ++ unsigned int ret; ++ p = ldcw_align(p); ++ __asm__ __volatile__("ldcw 0(%1),%0" ++ : "=r" (ret) ++ : "r" (p) ++ : "memory" ); ++ return !ret; ++} ++#endif ++ ++#ifdef __ia64 ++#include ++ ++static inline int testandset (int *p) ++{ ++ return __sync_lock_test_and_set (p, 1); ++} ++#endif ++ ++#ifdef __mips__ ++static inline int testandset (int *p) ++{ ++ int ret; ++ ++ __asm__ __volatile__ ( ++ " .set push \n" ++ " .set noat \n" ++ " .set mips2 \n" ++ "1: li $1, 1 \n" ++ " ll %0, %1 \n" ++ " sc $1, %1 \n" ++ " beqz $1, 1b \n" ++ " .set pop " ++ : "=r" (ret), "+R" (*p) ++ : ++ : "memory"); ++ ++ return ret; ++} ++#endif ++ ++#if defined(__hppa__) ++ ++typedef int spinlock_t[4]; ++ ++#define SPIN_LOCK_UNLOCKED { 1, 1, 1, 1 } ++ ++static inline void resetlock (spinlock_t *p) ++{ ++ (*p)[0] = (*p)[1] = (*p)[2] = (*p)[3] = 1; ++} ++ ++#else ++ ++typedef int spinlock_t; ++ ++#define SPIN_LOCK_UNLOCKED 0 ++ ++static inline void resetlock (spinlock_t *p) ++{ ++ *p = SPIN_LOCK_UNLOCKED; ++} ++ ++#endif ++ ++#if defined(CONFIG_USER_ONLY) ++static inline void spin_lock(spinlock_t *lock) ++{ ++ while (testandset(lock)); ++} ++ ++static inline void spin_unlock(spinlock_t *lock) ++{ ++ resetlock(lock); ++} ++ ++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 +Index: trunk/target-arm/cpu.h +=================================================================== +--- trunk.orig/target-arm/cpu.h 2008-04-24 20:16:41.000000000 +0100 ++++ trunk/target-arm/cpu.h 2008-04-24 20:16:53.000000000 +0100 +@@ -38,6 +38,7 @@ + #define EXCP_FIQ 6 + #define EXCP_BKPT 7 + #define EXCP_EXCEPTION_EXIT 8 /* Return from v7M exception. */ ++#define EXCP_KERNEL_TRAP 9 /* Jumped to kernel code page. */ + + #define ARMV7M_EXCP_RESET 1 + #define ARMV7M_EXCP_NMI 2 +@@ -218,6 +219,15 @@ + void cpu_lock(void); + void cpu_unlock(void); + ++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_tls2 = (uint32_t)(long)newtls; ++} ++#endif ++ + #define CPSR_M (0x1f) + #define CPSR_T (1 << 5) + #define CPSR_F (1 << 6) +Index: trunk/target-arm/translate.c +=================================================================== +--- trunk.orig/target-arm/translate.c 2008-04-24 20:16:41.000000000 +0100 ++++ trunk/target-arm/translate.c 2008-04-24 20:16:53.000000000 +0100 +@@ -8606,7 +8606,14 @@ + gen_exception(EXCP_EXCEPTION_EXIT); + } + #endif +- ++#ifdef CONFIG_USER_ONLY ++ /* Intercept jump to the magic kernel page. */ ++ if (dc->pc > 0xffff0000) { ++ gen_exception(EXCP_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) { diff --git a/packages/qemu/qemu-0.9.1+svn/qemu-amd64-32b-mapping-0.9.0.patch b/packages/qemu/qemu-0.9.1+svn/qemu-amd64-32b-mapping-0.9.0.patch new file mode 100644 index 0000000000..02f093abb9 --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/qemu-amd64-32b-mapping-0.9.0.patch @@ -0,0 +1,37 @@ +--- + linux-user/mmap.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +Index: trunk/linux-user/mmap.c +=================================================================== +--- trunk.orig/linux-user/mmap.c 2008-04-24 20:15:37.000000000 +0100 ++++ trunk/linux-user/mmap.c 2008-04-24 20:16:16.000000000 +0100 +@@ -29,6 +29,10 @@ + + //#define DEBUG_MMAP + ++#ifndef MAP_32BIT ++#define MAP_32BIT 0 ++#endif ++ + /* NOTE: all the constants are the HOST ones, but addresses are target. */ + int target_mprotect(abi_ulong start, abi_ulong len, int prot) + { +@@ -251,7 +255,7 @@ + especially important if qemu_host_page_size > + qemu_real_host_page_size */ + p = mmap(g2h(mmap_start), +- host_len, prot, flags | MAP_FIXED, fd, host_offset); ++ host_len, prot, flags | MAP_FIXED | MAP_32BIT, fd, host_offset); + if (p == MAP_FAILED) + return -1; + /* update start so that it points to the file position at 'offset' */ +@@ -406,7 +410,7 @@ + unsigned long host_addr; + + /* XXX: use 5 args syscall */ +- host_addr = (long)mremap(g2h(old_addr), old_size, new_size, flags); ++ host_addr = (long)mremap(g2h(old_addr), old_size, new_size, flags | MAP_32BIT); + if (host_addr == -1) + return -1; + new_addr = h2g(host_addr); diff --git a/packages/qemu/qemu-0.9.1+svn/qemu-n800-support.patch b/packages/qemu/qemu-0.9.1+svn/qemu-n800-support.patch new file mode 100644 index 0000000000..1224fb4cbd --- /dev/null +++ b/packages/qemu/qemu-0.9.1+svn/qemu-n800-support.patch @@ -0,0 +1,2381 @@ +diff -urN 4242/cpu-all.h qemu-omap/cpu-all.h +--- 4242/cpu-all.h 2008-04-24 21:26:19.000000000 +0100 ++++ qemu-omap/cpu-all.h 2008-04-23 09:57:55.000000000 +0100 +@@ -816,7 +816,7 @@ + /* physical memory access */ + #define TLB_INVALID_MASK (1 << 3) + #define IO_MEM_SHIFT 4 +-#define IO_MEM_NB_ENTRIES (1 << (TARGET_PAGE_BITS - IO_MEM_SHIFT)) ++#define IO_MEM_NB_ENTRIES (16 << (TARGET_PAGE_BITS - IO_MEM_SHIFT)) + + #define IO_MEM_RAM (0 << IO_MEM_SHIFT) /* hardcoded offset */ + #define IO_MEM_ROM (1 << IO_MEM_SHIFT) /* hardcoded offset */ +diff -urN 4242/exec.c qemu-omap/exec.c +--- 4242/exec.c 2008-04-24 18:11:49.000000000 +0100 ++++ qemu-omap/exec.c 2008-04-23 09:57:55.000000000 +0100 +@@ -1664,7 +1664,7 @@ + { + if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) { + /* IO memory case */ +- address = vaddr | pd; ++ address = vaddr | (pd & ~TARGET_PAGE_MASK); + addend = paddr; + } else { + /* standard memory */ +@@ -1698,7 +1698,9 @@ + } else { + te->addr_read = -1; + } +- if (prot & PAGE_EXEC) { ++ if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) { ++ te->addr_code = pd; ++ } else if (prot & PAGE_EXEC) { + te->addr_code = address; + } else { + te->addr_code = -1; +@@ -2493,7 +2495,9 @@ + if (io_index <= 0) { + if (io_mem_nb >= IO_MEM_NB_ENTRIES) + return -1; +- io_index = io_mem_nb++; ++ do io_index = io_mem_nb++; ++ while (((io_index << IO_MEM_SHIFT) & ~TARGET_PAGE_MASK) ++ <= IO_MEM_NOTDIRTY); + } else { + if (io_index >= IO_MEM_NB_ENTRIES) + return -1; +diff -urN 4242/hw/max7310.c qemu-omap/hw/max7310.c +--- 4242/hw/max7310.c 2008-04-24 18:11:49.000000000 +0100 ++++ qemu-omap/hw/max7310.c 2008-03-02 19:31:55.000000000 +0000 +@@ -134,8 +134,8 @@ + s->i2c_command_byte = 1; + break; + case I2C_FINISH: +- if (s->len == 1) + #ifdef VERBOSE ++ if (s->len == 1) + printf("%s: message too short (%i bytes)\n", __FUNCTION__, s->len); + #endif + break; +diff -urN 4242/hw/ndis.h qemu-omap/hw/ndis.h +--- 4242/hw/ndis.h 1970-01-01 01:00:00.000000000 +0100 ++++ qemu-omap/hw/ndis.h 2008-04-23 09:57:56.000000000 +0100 +@@ -0,0 +1,217 @@ ++/* ++ * ndis.h ++ * ++ * ntddndis.h modified by Benedikt Spranger ++ * ++ * Thanks to the cygwin development team, ++ * espacially to Casper S. Hornstrup ++ * ++ * THIS SOFTWARE IS NOT COPYRIGHTED ++ * ++ * This source code is offered for use in the public domain. You may ++ * use, modify or distribute it freely. ++ * ++ * This code is distributed in the hope that it will be useful but ++ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY ++ * DISCLAIMED. This includes but is not limited to warranties of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ++ * ++ */ ++ ++#ifndef _LINUX_NDIS_H ++#define _LINUX_NDIS_H ++ ++ ++#define NDIS_STATUS_MULTICAST_FULL 0xC0010009 ++#define NDIS_STATUS_MULTICAST_EXISTS 0xC001000A ++#define NDIS_STATUS_MULTICAST_NOT_FOUND 0xC001000B ++ ++enum NDIS_DEVICE_POWER_STATE { ++ NdisDeviceStateUnspecified = 0, ++ NdisDeviceStateD0, ++ NdisDeviceStateD1, ++ NdisDeviceStateD2, ++ NdisDeviceStateD3, ++ NdisDeviceStateMaximum ++}; ++ ++struct NDIS_PM_WAKE_UP_CAPABILITIES { ++ enum NDIS_DEVICE_POWER_STATE MinMagicPacketWakeUp; ++ enum NDIS_DEVICE_POWER_STATE MinPatternWakeUp; ++ enum NDIS_DEVICE_POWER_STATE MinLinkChangeWakeUp; ++}; ++ ++/* NDIS_PNP_CAPABILITIES.Flags constants */ ++#define NDIS_DEVICE_WAKE_UP_ENABLE 0x00000001 ++#define NDIS_DEVICE_WAKE_ON_PATTERN_MATCH_ENABLE 0x00000002 ++#define NDIS_DEVICE_WAKE_ON_MAGIC_PACKET_ENABLE 0x00000004 ++ ++struct NDIS_PNP_CAPABILITIES { ++ __le32 Flags; ++ struct NDIS_PM_WAKE_UP_CAPABILITIES WakeUpCapabilities; ++}; ++ ++struct NDIS_PM_PACKET_PATTERN { ++ __le32 Priority; ++ __le32 Reserved; ++ __le32 MaskSize; ++ __le32 PatternOffset; ++ __le32 PatternSize; ++ __le32 PatternFlags; ++}; ++ ++ ++/* Required Object IDs (OIDs) */ ++#define OID_GEN_SUPPORTED_LIST 0x00010101 ++#define OID_GEN_HARDWARE_STATUS 0x00010102 ++#define OID_GEN_MEDIA_SUPPORTED 0x00010103 ++#define OID_GEN_MEDIA_IN_USE 0x00010104 ++#define OID_GEN_MAXIMUM_LOOKAHEAD 0x00010105 ++#define OID_GEN_MAXIMUM_FRAME_SIZE 0x00010106 ++#define OID_GEN_LINK_SPEED 0x00010107 ++#define OID_GEN_TRANSMIT_BUFFER_SPACE 0x00010108 ++#define OID_GEN_RECEIVE_BUFFER_SPACE 0x00010109 ++#define OID_GEN_TRANSMIT_BLOCK_SIZE 0x0001010A ++#define OID_GEN_RECEIVE_BLOCK_SIZE 0x0001010B ++#define OID_GEN_VENDOR_ID 0x0001010C ++#define OID_GEN_VENDOR_DESCRIPTION 0x0001010D ++#define OID_GEN_CURRENT_PACKET_FILTER 0x0001010E ++#define OID_GEN_CURRENT_LOOKAHEAD 0x0001010F ++#define OID_GEN_DRIVER_VERSION 0x00010110 ++#define OID_GEN_MAXIMUM_TOTAL_SIZE 0x00010111 ++#define OID_GEN_PROTOCOL_OPTIONS 0x00010112 ++#define OID_GEN_MAC_OPTIONS 0x00010113 ++#define OID_GEN_MEDIA_CONNECT_STATUS 0x00010114 ++#define OID_GEN_MAXIMUM_SEND_PACKETS 0x00010115 ++#define OID_GEN_VENDOR_DRIVER_VERSION 0x00010116 ++#define OID_GEN_SUPPORTED_GUIDS 0x00010117 ++#define OID_GEN_NETWORK_LAYER_ADDRESSES 0x00010118 ++#define OID_GEN_TRANSPORT_HEADER_OFFSET 0x00010119 ++#define OID_GEN_MACHINE_NAME 0x0001021A ++#define OID_GEN_RNDIS_CONFIG_PARAMETER 0x0001021B ++#define OID_GEN_VLAN_ID 0x0001021C ++ ++/* Optional OIDs */ ++#define OID_GEN_MEDIA_CAPABILITIES 0x00010201 ++#define OID_GEN_PHYSICAL_MEDIUM 0x00010202 ++ ++/* Required statistics OIDs */ ++#define OID_GEN_XMIT_OK 0x00020101 ++#define OID_GEN_RCV_OK 0x00020102 ++#define OID_GEN_XMIT_ERROR 0x00020103 ++#define OID_GEN_RCV_ERROR 0x00020104 ++#define OID_GEN_RCV_NO_BUFFER 0x00020105 ++ ++/* Optional statistics OIDs */ ++#define OID_GEN_DIRECTED_BYTES_XMIT 0x00020201 ++#define OID_GEN_DIRECTED_FRAMES_XMIT 0x00020202 ++#define OID_GEN_MULTICAST_BYTES_XMIT 0x00020203 ++#define OID_GEN_MULTICAST_FRAMES_XMIT 0x00020204 ++#define OID_GEN_BROADCAST_BYTES_XMIT 0x00020205 ++#define OID_GEN_BROADCAST_FRAMES_XMIT 0x00020206 ++#define OID_GEN_DIRECTED_BYTES_RCV 0x00020207 ++#define OID_GEN_DIRECTED_FRAMES_RCV 0x00020208 ++#define OID_GEN_MULTICAST_BYTES_RCV 0x00020209 ++#define OID_GEN_MULTICAST_FRAMES_RCV 0x0002020A ++#define OID_GEN_BROADCAST_BYTES_RCV 0x0002020B ++#define OID_GEN_BROADCAST_FRAMES_RCV 0x0002020C ++#define OID_GEN_RCV_CRC_ERROR 0x0002020D ++#define OID_GEN_TRANSMIT_QUEUE_LENGTH 0x0002020E ++#define OID_GEN_GET_TIME_CAPS 0x0002020F ++#define OID_GEN_GET_NETCARD_TIME 0x00020210 ++#define OID_GEN_NETCARD_LOAD 0x00020211 ++#define OID_GEN_DEVICE_PROFILE 0x00020212 ++#define OID_GEN_INIT_TIME_MS 0x00020213 ++#define OID_GEN_RESET_COUNTS 0x00020214 ++#define OID_GEN_MEDIA_SENSE_COUNTS 0x00020215 ++#define OID_GEN_FRIENDLY_NAME 0x00020216 ++#define OID_GEN_MINIPORT_INFO 0x00020217 ++#define OID_GEN_RESET_VERIFY_PARAMETERS 0x00020218 ++ ++/* IEEE 802.3 (Ethernet) OIDs */ ++#define NDIS_802_3_MAC_OPTION_PRIORITY 0x00000001 ++ ++#define OID_802_3_PERMANENT_ADDRESS 0x01010101 ++#define OID_802_3_CURRENT_ADDRESS 0x01010102 ++#define OID_802_3_MULTICAST_LIST 0x01010103 ++#define OID_802_3_MAXIMUM_LIST_SIZE 0x01010104 ++#define OID_802_3_MAC_OPTIONS 0x01010105 ++#define OID_802_3_RCV_ERROR_ALIGNMENT 0x01020101 ++#define OID_802_3_XMIT_ONE_COLLISION 0x01020102 ++#define OID_802_3_XMIT_MORE_COLLISIONS 0x01020103 ++#define OID_802_3_XMIT_DEFERRED 0x01020201 ++#define OID_802_3_XMIT_MAX_COLLISIONS 0x01020202 ++#define OID_802_3_RCV_OVERRUN 0x01020203 ++#define OID_802_3_XMIT_UNDERRUN 0x01020204 ++#define OID_802_3_XMIT_HEARTBEAT_FAILURE 0x01020205 ++#define OID_802_3_XMIT_TIMES_CRS_LOST 0x01020206 ++#define OID_802_3_XMIT_LATE_COLLISIONS 0x01020207 ++ ++/* OID_GEN_MINIPORT_INFO constants */ ++#define NDIS_MINIPORT_BUS_MASTER 0x00000001 ++#define NDIS_MINIPORT_WDM_DRIVER 0x00000002 ++#define NDIS_MINIPORT_SG_LIST 0x00000004 ++#define NDIS_MINIPORT_SUPPORTS_MEDIA_QUERY 0x00000008 ++#define NDIS_MINIPORT_INDICATES_PACKETS 0x00000010 ++#define NDIS_MINIPORT_IGNORE_PACKET_QUEUE 0x00000020 ++#define NDIS_MINIPORT_IGNORE_REQUEST_QUEUE 0x00000040 ++#define NDIS_MINIPORT_IGNORE_TOKEN_RING_ERRORS 0x00000080 ++#define NDIS_MINIPORT_INTERMEDIATE_DRIVER 0x00000100 ++#define NDIS_MINIPORT_IS_NDIS_5 0x00000200 ++#define NDIS_MINIPORT_IS_CO 0x00000400 ++#define NDIS_MINIPORT_DESERIALIZE 0x00000800 ++#define NDIS_MINIPORT_REQUIRES_MEDIA_POLLING 0x00001000 ++#define NDIS_MINIPORT_SUPPORTS_MEDIA_SENSE 0x00002000 ++#define NDIS_MINIPORT_NETBOOT_CARD 0x00004000 ++#define NDIS_MINIPORT_PM_SUPPORTED 0x00008000 ++#define NDIS_MINIPORT_SUPPORTS_MAC_ADDRESS_OVERWRITE 0x00010000 ++#define NDIS_MINIPORT_USES_SAFE_BUFFER_APIS 0x00020000 ++#define NDIS_MINIPORT_HIDDEN 0x00040000 ++#define NDIS_MINIPORT_SWENUM 0x00080000 ++#define NDIS_MINIPORT_SURPRISE_REMOVE_OK 0x00100000 ++#define NDIS_MINIPORT_NO_HALT_ON_SUSPEND 0x00200000 ++#define NDIS_MINIPORT_HARDWARE_DEVICE 0x00400000 ++#define NDIS_MINIPORT_SUPPORTS_CANCEL_SEND_PACKETS 0x00800000 ++#define NDIS_MINIPORT_64BITS_DMA 0x01000000 ++ ++#define NDIS_MEDIUM_802_3 0x00000000 ++#define NDIS_MEDIUM_802_5 0x00000001 ++#define NDIS_MEDIUM_FDDI 0x00000002 ++#define NDIS_MEDIUM_WAN 0x00000003 ++#define NDIS_MEDIUM_LOCAL_TALK 0x00000004 ++#define NDIS_MEDIUM_DIX 0x00000005 ++#define NDIS_MEDIUM_ARCENT_RAW 0x00000006 ++#define NDIS_MEDIUM_ARCENT_878_2 0x00000007 ++#define NDIS_MEDIUM_ATM 0x00000008 ++#define NDIS_MEDIUM_WIRELESS_LAN 0x00000009 ++#define NDIS_MEDIUM_IRDA 0x0000000A ++#define NDIS_MEDIUM_BPC 0x0000000B ++#define NDIS_MEDIUM_CO_WAN 0x0000000C ++#define NDIS_MEDIUM_1394 0x0000000D ++ ++#define NDIS_PACKET_TYPE_DIRECTED 0x00000001 ++#define NDIS_PACKET_TYPE_MULTICAST 0x00000002 ++#define NDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004 ++#define NDIS_PACKET_TYPE_BROADCAST 0x00000008 ++#define NDIS_PACKET_TYPE_SOURCE_ROUTING 0x00000010 ++#define NDIS_PACKET_TYPE_PROMISCUOUS 0x00000020 ++#define NDIS_PACKET_TYPE_SMT 0x00000040 ++#define NDIS_PACKET_TYPE_ALL_LOCAL 0x00000080 ++#define NDIS_PACKET_TYPE_GROUP 0x00000100 ++#define NDIS_PACKET_TYPE_ALL_FUNCTIONAL 0x00000200 ++#define NDIS_PACKET_TYPE_FUNCTIONAL 0x00000400 ++#define NDIS_PACKET_TYPE_MAC_FRAME 0x00000800 ++ ++#define NDIS_MEDIA_STATE_CONNECTED 0x00000000 ++#define NDIS_MEDIA_STATE_DISCONNECTED 0x00000001 ++ ++#define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA 0x00000001 ++#define NDIS_MAC_OPTION_RECEIVE_SERIALIZED 0x00000002 ++#define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND 0x00000004 ++#define NDIS_MAC_OPTION_NO_LOOPBACK 0x00000008 ++#define NDIS_MAC_OPTION_FULL_DUPLEX 0x00000010 ++#define NDIS_MAC_OPTION_EOTX_INDICATION 0x00000020 ++#define NDIS_MAC_OPTION_8021P_PRIORITY 0x00000040 ++#define NDIS_MAC_OPTION_RESERVED 0x80000000 ++ ++#endif /* _LINUX_NDIS_H */ +diff -urN 4242/hw/nseries.c qemu-omap/hw/nseries.c +--- 4242/hw/nseries.c 2008-04-24 18:11:49.000000000 +0100 ++++ qemu-omap/hw/nseries.c 2008-04-23 09:57:56.000000000 +0100 +@@ -602,6 +602,37 @@ + (void *) &config7, sizeof(config7)); + } + ++#if 0 ++static uint32_t n800_pinout[104] = { ++ 0x080f00d8, 0x00d40808, 0x03080808, 0x080800d0, ++ 0x00dc0808, 0x0b0f0f00, 0x080800b4, 0x00c00808, ++ 0x08080808, 0x180800c4, 0x00b80000, 0x08080808, ++ 0x080800bc, 0x00cc0808, 0x08081818, 0x18180128, ++ 0x01241800, 0x18181818, 0x000000f0, 0x01300000, ++ 0x00001b0b, 0x1b0f0138, 0x00e0181b, 0x1b031b0b, ++ 0x180f0078, 0x00740018, 0x0f0f0f1a, 0x00000080, ++ 0x007c0000, 0x00000000, 0x00000088, 0x00840000, ++ 0x00000000, 0x00000094, 0x00980300, 0x0f180003, ++ 0x0000008c, 0x00900f0f, 0x0f0f1b00, 0x0f00009c, ++ 0x01140000, 0x1b1b0f18, 0x0818013c, 0x01400008, ++ 0x00001818, 0x000b0110, 0x010c1800, 0x0b030b0f, ++ 0x181800f4, 0x00f81818, 0x00000018, 0x000000fc, ++ 0x00401808, 0x00000000, 0x0f1b0030, 0x003c0008, ++ 0x00000000, 0x00000038, 0x00340000, 0x00000000, ++ 0x1a080070, 0x00641a1a, 0x08080808, 0x08080060, ++ 0x005c0808, 0x08080808, 0x08080058, 0x00540808, ++ 0x08080808, 0x0808006c, 0x00680808, 0x08080808, ++ 0x000000a8, 0x00b00000, 0x08080808, 0x000000a0, ++ 0x00a40000, 0x00000000, 0x08ff0050, 0x004c0808, ++ 0xffffffff, 0xffff0048, 0x0044ffff, 0xffffffff, ++ 0x000000ac, 0x01040800, 0x08080b0f, 0x18180100, ++ 0x01081818, 0x0b0b1808, 0x1a0300e4, 0x012c0b1a, ++ 0x02020018, 0x0b000134, 0x011c0800, 0x0b1b1b00, ++ 0x0f0000c8, 0x00ec181b, 0x000f0f02, 0x00180118, ++ 0x01200000, 0x0f0b1b1b, 0x0f0200e8, 0x0000020b, ++}; ++#endif ++ + /* Setup sequence done by the bootloader */ + static void n800_boot_init(void *opaque) + { +@@ -942,3 +973,71 @@ + "Nokia N800 aka. RX-34 tablet (OMAP2420)", + n800_init, + }; ++ ++#if 0 ++/* cx3110x.c */ ++#define CY_ARM_INT 0x00 ++#define CY_ARM_INT_ENA 0x00 ++#define CY_HOST_INT 0x00 ++#define CY_HOST_INT_ENA 0x00 ++#define CY_HOST_INT_ACK 0x00 ++#define CY_GP1_COMM 0x00 ++#define CY_GP2_COMM 0x00 ++#define CY_DEV_CTRL_STA 0x00 ++#define CY_DMA_DATA 0x00 /* 16-bit */ ++#define CY_DMA_WR_CTRL 0x00 /* 16-bit */ ++#define CY_DMA_WR_LEN 0x00 /* 16-bit */ ++#define CY_DMA_WR_BASE 0x00 ++#define CY_DMA_RD_CTRL 0x00 /* 16-bit */ ++#define CY_DMA_RD_LEN 0x00 /* 16-bit */ ++#define CY_DMA_RD_BASE 0x00 ++ ++HW: ++(spi bus 1.0) ++ tsc2005 ++(spi bus 1.1) ++ lcd_mipid ++(spi bus 2.0) ++ cx3110x (WLAN) ++(spi somewhere?) ++ pc2400m (WiMAX) ++(i2c bus 0) ++ TLV320AIC33 (audio codec on i2c) ++ TCM825x (camera on i2c) ++ lp5521 (LED on i2c) ++ tsl2563 (light sensor, hwmon on i2c) ++ lm8323 (keypad on i2c) ++(i2c bus 1) ++ tmp105 (temperature sensor, hwmon on i2c) ++ menelaus (power on i2c) ++ ++GPIO 0: out hi ++GPIO 8: in hi ++GPIO 9: out hi ++GPIO 10: out lo ++GPIO 12: out lo ++GPIO 15: out lo ++GPIO 23: out hi ++GPIO 26: in hi, irq-186 rising ++GPIO 53: out lo ++GPIO 58: in hi, irq-218 low wakeup ++GPIO 62: out lo ++GPIO 64: out hi ++GPIO 65: in hi ++GPIO 66: out lo ++GPIO 93: out lo ++GPIO 94: in hi ++GPIO 95: out lo ++GPIO 96: out hi ++GPIO 101: out lo ++GPIO 102: in hi, irq-262 bothedge ++GPIO 106: in hi, irq-266 falling wakeup ++GPIO 107: in hi, irq-267 bothedge ++GPIO 108: in lo, irq-268 rising wakeup ++GPIO 109: in hi, irq-269 falling wakeup ++GPIO 110: in hi, irq-270 bothedge ++GPIO 111: in lo, irq-271 rising ++GPIO 112: out hi ++GPIO 118: out hi ++GPIO 125: in lo, irq-285 rising ++#endif +diff -urN 4242/hw/omap2.c qemu-omap/hw/omap2.c +--- 4242/hw/omap2.c 2008-04-24 18:11:49.000000000 +0100 ++++ qemu-omap/hw/omap2.c 2008-04-23 09:57:56.000000000 +0100 +@@ -3675,152 +3675,152 @@ + omap_findclk(s, "dss_l4_iclk")); + + /* All register mappings (includin those not currenlty implemented): +- * SystemControlMod 48000000 - 48000fff +- * SystemControlL4 48001000 - 48001fff +- * 32kHz Timer Mod 48004000 - 48004fff +- * 32kHz Timer L4 48005000 - 48005fff +- * PRCM ModA 48008000 - 480087ff ++ * SystemControlMod 48000000 - 48000fff (REV 0x00000010) ++ * SystemControlL4 48001000 - 48001fff (0x00200010, 0x01000200, 0x00000000) ++ * 32kHz Timer Mod 48004000 - 48004fff (REV 0x00000011) ++ * 32kHz Timer L4 48005000 - 48005fff (0x00200010, 0x01000200, 0x00000000) ++ * PRCM ModA 48008000 - 480087ff (REV 0x00000010) + * PRCM ModB 48008800 - 48008fff +- * PRCM L4 48009000 - 48009fff +- * TEST-BCM Mod 48012000 - 48012fff +- * TEST-BCM L4 48013000 - 48013fff +- * TEST-TAP Mod 48014000 - 48014fff +- * TEST-TAP L4 48015000 - 48015fff +- * GPIO1 Mod 48018000 - 48018fff +- * GPIO Top 48019000 - 48019fff +- * GPIO2 Mod 4801a000 - 4801afff +- * GPIO L4 4801b000 - 4801bfff +- * GPIO3 Mod 4801c000 - 4801cfff +- * GPIO4 Mod 4801e000 - 4801efff +- * WDTIMER1 Mod 48020000 - 48010fff ++ * PRCM L4 48009000 - 48009fff (0x00200010, 0x00000200, 0x00000000) ++ * TEST-BCM Mod 48012000 - 48012fff (REV 0x00000010) ++ * TEST-BCM L4 48013000 - 48013fff (0x00200010, 0x00000200, 0x00000000) ++ * TEST-TAP Mod 48014000 - 48014fff (REV 0x00000010) ++ * TEST-TAP L4 48015000 - 48015fff (0x00200010, 0x00000200, 0x00000000) ++ * GPIO1 Mod 48018000 - 48018fff (REV 0x00000018) ++ * GPIO Top 48019000 - 48019fff (REV 0x00000011) ++ * GPIO2 Mod 4801a000 - 4801afff (REV 0x00000018) ++ * GPIO L4 4801b000 - 4801bfff (0x00200010, 0x00000200, 0x00000000) ++ * GPIO3 Mod 4801c000 - 4801cfff (REV 0x00000018) ++ * GPIO4 Mod 4801e000 - 4801efff (REV 0x00000018) ++ * WDTIMER1 Mod 48020000 - 48010fff (REV Abort) + * WDTIMER Top 48021000 - 48011fff +- * WDTIMER2 Mod 48022000 - 48012fff +- * WDTIMER L4 48023000 - 48013fff +- * WDTIMER3 Mod 48024000 - 48014fff +- * WDTIMER3 L4 48025000 - 48015fff +- * WDTIMER4 Mod 48026000 - 48016fff +- * WDTIMER4 L4 48027000 - 48017fff +- * GPTIMER1 Mod 48028000 - 48018fff +- * GPTIMER1 L4 48029000 - 48019fff +- * GPTIMER2 Mod 4802a000 - 4801afff +- * GPTIMER2 L4 4802b000 - 4801bfff ++ * WDTIMER2 Mod 48022000 - 48012fff (REV 0x00000011) ++ * WDTIMER L4 48023000 - 48013fff (0x00200010, 0x00000200, 0x00000000) ++ * WDTIMER3 Mod 48024000 - 48014fff (REV 0x00000011) ++ * WDTIMER3 L4 48025000 - 48015fff (0x00200010, 0x00000200, 0x00000000) ++ * WDTIMER4 Mod 48026000 - 48016fff (REV 0x00000011) ++ * WDTIMER4 L4 48027000 - 48017fff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER1 Mod 48028000 - 48018fff (REV 0x00000013) ++ * GPTIMER1 L4 48029000 - 48019fff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER2 Mod 4802a000 - 4801afff (REV Abort) ++ * GPTIMER2 L4 4802b000 - 4801bfff (0x00200010, 0x00000200, 0x00000000) + * L4-Config AP 48040000 - 480407ff + * L4-Config IP 48040800 - 48040fff + * L4-Config LA 48041000 - 48041fff +- * ARM11ETB Mod 48048000 - 48049fff +- * ARM11ETB L4 4804a000 - 4804afff +- * DISPLAY Top 48050000 - 480503ff +- * DISPLAY DISPC 48050400 - 480507ff +- * DISPLAY RFBI 48050800 - 48050bff +- * DISPLAY VENC 48050c00 - 48050fff +- * DISPLAY L4 48051000 - 48051fff +- * CAMERA Top 48052000 - 480523ff +- * CAMERA core 48052400 - 480527ff +- * CAMERA DMA 48052800 - 48052bff +- * CAMERA MMU 48052c00 - 48052fff +- * CAMERA L4 48053000 - 48053fff +- * SDMA Mod 48056000 - 48056fff +- * SDMA L4 48057000 - 48057fff +- * SSI Top 48058000 - 48058fff +- * SSI GDD 48059000 - 48059fff +- * SSI Port1 4805a000 - 4805afff +- * SSI Port2 4805b000 - 4805bfff +- * SSI L4 4805c000 - 4805cfff +- * USB Mod 4805e000 - 480fefff +- * USB L4 4805f000 - 480fffff +- * WIN_TRACER1 Mod 48060000 - 48060fff +- * WIN_TRACER1 L4 48061000 - 48061fff +- * WIN_TRACER2 Mod 48062000 - 48062fff +- * WIN_TRACER2 L4 48063000 - 48063fff +- * WIN_TRACER3 Mod 48064000 - 48064fff +- * WIN_TRACER3 L4 48065000 - 48065fff +- * WIN_TRACER4 Top 48066000 - 480660ff +- * WIN_TRACER4 ETT 48066100 - 480661ff +- * WIN_TRACER4 WT 48066200 - 480662ff +- * WIN_TRACER4 L4 48067000 - 48067fff +- * XTI Mod 48068000 - 48068fff +- * XTI L4 48069000 - 48069fff +- * UART1 Mod 4806a000 - 4806afff +- * UART1 L4 4806b000 - 4806bfff +- * UART2 Mod 4806c000 - 4806cfff +- * UART2 L4 4806d000 - 4806dfff +- * UART3 Mod 4806e000 - 4806efff +- * UART3 L4 4806f000 - 4806ffff +- * I2C1 Mod 48070000 - 48070fff +- * I2C1 L4 48071000 - 48071fff +- * I2C2 Mod 48072000 - 48072fff +- * I2C2 L4 48073000 - 48073fff +- * McBSP1 Mod 48074000 - 48074fff +- * McBSP1 L4 48075000 - 48075fff +- * McBSP2 Mod 48076000 - 48076fff +- * McBSP2 L4 48077000 - 48077fff +- * GPTIMER3 Mod 48078000 - 48078fff +- * GPTIMER3 L4 48079000 - 48079fff +- * GPTIMER4 Mod 4807a000 - 4807afff +- * GPTIMER4 L4 4807b000 - 4807bfff +- * GPTIMER5 Mod 4807c000 - 4807cfff +- * GPTIMER5 L4 4807d000 - 4807dfff +- * GPTIMER6 Mod 4807e000 - 4807efff +- * GPTIMER6 L4 4807f000 - 4807ffff +- * GPTIMER7 Mod 48080000 - 48080fff +- * GPTIMER7 L4 48081000 - 48081fff +- * GPTIMER8 Mod 48082000 - 48082fff +- * GPTIMER8 L4 48083000 - 48083fff +- * GPTIMER9 Mod 48084000 - 48084fff +- * GPTIMER9 L4 48085000 - 48085fff +- * GPTIMER10 Mod 48086000 - 48086fff +- * GPTIMER10 L4 48087000 - 48087fff +- * GPTIMER11 Mod 48088000 - 48088fff +- * GPTIMER11 L4 48089000 - 48089fff +- * GPTIMER12 Mod 4808a000 - 4808afff +- * GPTIMER12 L4 4808b000 - 4808bfff +- * EAC Mod 48090000 - 48090fff +- * EAC L4 48091000 - 48091fff +- * FAC Mod 48092000 - 48092fff +- * FAC L4 48093000 - 48093fff +- * MAILBOX Mod 48094000 - 48094fff +- * MAILBOX L4 48095000 - 48095fff +- * SPI1 Mod 48098000 - 48098fff +- * SPI1 L4 48099000 - 48099fff +- * SPI2 Mod 4809a000 - 4809afff +- * SPI2 L4 4809b000 - 4809bfff +- * MMC/SDIO Mod 4809c000 - 4809cfff +- * MMC/SDIO L4 4809d000 - 4809dfff +- * MS_PRO Mod 4809e000 - 4809efff +- * MS_PRO L4 4809f000 - 4809ffff +- * RNG Mod 480a0000 - 480a0fff +- * RNG L4 480a1000 - 480a1fff +- * DES3DES Mod 480a2000 - 480a2fff +- * DES3DES L4 480a3000 - 480a3fff +- * SHA1MD5 Mod 480a4000 - 480a4fff +- * SHA1MD5 L4 480a5000 - 480a5fff +- * AES Mod 480a6000 - 480a6fff +- * AES L4 480a7000 - 480a7fff +- * PKA Mod 480a8000 - 480a9fff +- * PKA L4 480aa000 - 480aafff +- * MG Mod 480b0000 - 480b0fff +- * MG L4 480b1000 - 480b1fff +- * HDQ/1-wire Mod 480b2000 - 480b2fff +- * HDQ/1-wire L4 480b3000 - 480b3fff +- * MPU interrupt 480fe000 - 480fefff +- * IVA RAM 5c000000 - 5c01ffff +- * IVA ROM 5c020000 - 5c027fff +- * IMG_BUF_A 5c040000 - 5c040fff +- * IMG_BUF_B 5c042000 - 5c042fff +- * VLCDS 5c048000 - 5c0487ff +- * IMX_COEF 5c049000 - 5c04afff +- * IMX_CMD 5c051000 - 5c051fff +- * VLCDQ 5c053000 - 5c0533ff +- * VLCDH 5c054000 - 5c054fff +- * SEQ_CMD 5c055000 - 5c055fff +- * IMX_REG 5c056000 - 5c0560ff +- * VLCD_REG 5c056100 - 5c0561ff +- * SEQ_REG 5c056200 - 5c0562ff +- * IMG_BUF_REG 5c056300 - 5c0563ff +- * SEQIRQ_REG 5c056400 - 5c0564ff +- * OCP_REG 5c060000 - 5c060fff +- * SYSC_REG 5c070000 - 5c070fff +- * MMU_REG 5d000000 - 5d000fff ++ * ARM11ETB Mod 48048000 - 48049fff (REV 0x00000011) ++ * ARM11ETB L4 4804a000 - 4804afff (0x00200010, 0x00000200, 0x00000000) ++ * DISPLAY Top 48050000 - 480503ff (REV 0x00000003) ++ * DISPLAY DISPC 48050400 - 480507ff (REV 0x00000020) ++ * DISPLAY RFBI 48050800 - 48050bff (REV 0x00000010) ++ * DISPLAY VENC 48050c00 - 48050fff (REV Abort) ++ * DISPLAY L4 48051000 - 48051fff (0x00200010, 0x00000200, 0x00000100) ++ * CAMERA Top 48052000 - 480523ff (REV 0x00000020) ++ * CAMERA core 48052400 - 480527ff (REV 0x00000020) ++ * CAMERA DMA 48052800 - 48052bff (REV 0x00000020) ++ * CAMERA MMU 48052c00 - 48052fff (REV 0x00000010) ++ * CAMERA L4 48053000 - 48053fff (0x00200010, 0x00000200, 0x00000000) ++ * SDMA Mod 48056000 - 48056fff (REV 0x00000020) ++ * SDMA L4 48057000 - 48057fff (0x00200010, 0x00000200, 0x00000000) ++ * SSI Top 48058000 - 48058fff (REV Abort) ++ * SSI GDD 48059000 - 48059fff (REV Abort) ++ * SSI Port1 4805a000 - 4805afff (REV Abort) ++ * SSI Port2 4805b000 - 4805bfff (REV Abort) ++ * SSI L4 4805c000 - 4805cfff (0x00200010, 0x00000200, 0x00000100) ++ * USB Mod 4805e000 - 480fefff (REV Abort) ++ * USB L4 4805f000 - 480fffff (0x00200010, 0x01000200, 0x00000100) ++ * WIN_TRACER1 Mod 48060000 - 48060fff (REV 0x00000020) ++ * WIN_TRACER1 L4 48061000 - 48061fff (0x00200010, 0x00000200, 0x00000000) ++ * WIN_TRACER2 Mod 48062000 - 48062fff (REV 0x00000020) ++ * WIN_TRACER2 L4 48063000 - 48063fff (0x00200010, 0x00000200, 0x00000000) ++ * WIN_TRACER3 Mod 48064000 - 48064fff (REV 0x00000020) ++ * WIN_TRACER3 L4 48065000 - 48065fff (0x00200010, 0x00000200, 0x00000000) ++ * WIN_TRACER4 Top 48066000 - 480660ff (REV 0x00000011) ++ * WIN_TRACER4 ETT 48066100 - 480661ff (REV 0x00000011) ++ * WIN_TRACER4 WT 48066200 - 480662ff (REV 0x00000020) ++ * WIN_TRACER4 L4 48067000 - 48067fff (0x00200010, 0x00000200, 0x00000000) ++ * XTI Mod 48068000 - 48068fff (REV 0x00000010) ++ * XTI L4 48069000 - 48069fff (0x00200010, 0x00000200, 0x00000000) ++ * UART1 Mod 4806a000 - 4806afff (MVR Abort) ++ * UART1 L4 4806b000 - 4806bfff (0x00200010, 0x00000200, 0x00000000) ++ * UART2 Mod 4806c000 - 4806cfff (MVR Abort) ++ * UART2 L4 4806d000 - 4806dfff (0x00200010, 0x00000200, 0x00000000) ++ * UART3 Mod 4806e000 - 4806efff (MVR 0x20) ++ * UART3 L4 4806f000 - 4806ffff (0x00200010, 0x00000200, 0x00000000) ++ * I2C1 Mod 48070000 - 48070fff (REV 0x0034) ++ * I2C1 L4 48071000 - 48071fff (0x00200010, 0x01000200, 0x01000000) ++ * I2C2 Mod 48072000 - 48072fff (REV 0x0034) ++ * I2C2 L4 48073000 - 48073fff (0x00200010, 0x01000200, 0x01000000) ++ * McBSP1 Mod 48074000 - 48074fff (REV Abort) ++ * McBSP1 L4 48075000 - 48075fff (0x00200010, 0x01000200, 0x01000000) ++ * McBSP2 Mod 48076000 - 48076fff (REV Abort) ++ * McBSP2 L4 48077000 - 48077fff (0x00200010, 0x01000200, 0x01000000) ++ * GPTIMER3 Mod 48078000 - 48078fff (REV Abort) ++ * GPTIMER3 L4 48079000 - 48079fff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER4 Mod 4807a000 - 4807afff (REV Abort) ++ * GPTIMER4 L4 4807b000 - 4807bfff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER5 Mod 4807c000 - 4807cfff (REV Abort) ++ * GPTIMER5 L4 4807d000 - 4807dfff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER6 Mod 4807e000 - 4807efff (REV Abort) ++ * GPTIMER6 L4 4807f000 - 4807ffff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER7 Mod 48080000 - 48080fff (REV Abort) ++ * GPTIMER7 L4 48081000 - 48081fff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER8 Mod 48082000 - 48082fff (REV Abort) ++ * GPTIMER8 L4 48083000 - 48083fff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER9 Mod 48084000 - 48084fff (REV Abort) ++ * GPTIMER9 L4 48085000 - 48085fff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER10 Mod 48086000 - 48086fff (REV Abort) ++ * GPTIMER10 L4 48087000 - 48087fff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER11 Mod 48088000 - 48088fff (REV Abort) ++ * GPTIMER11 L4 48089000 - 48089fff (0x00200010, 0x00000200, 0x00000000) ++ * GPTIMER12 Mod 4808a000 - 4808afff (REV Abort) ++ * GPTIMER12 L4 4808b000 - 4808bfff (0x00200010, 0x00000200, 0x00000000) ++ * EAC Mod 48090000 - 48090fff (REV Abort) ++ * EAC L4 48091000 - 48091fff (0x00200010, 0x00000200, 0x00000000) ++ * FAC Mod 48092000 - 48092fff (REV Abort) ++ * FAC L4 48093000 - 48093fff (0x00200010, 0x00000200, 0x00000000) ++ * MAILBOX Mod 48094000 - 48094fff (REV 0x00000010) ++ * MAILBOX L4 48095000 - 48095fff (0x00200010, 0x00000200, 0x00000000) ++ * SPI1 Mod 48098000 - 48098fff (REV Abort) ++ * SPI1 L4 48099000 - 48099fff (0x00200010, 0x00000200, 0x00000000) ++ * SPI2 Mod 4809a000 - 4809afff (REV Abort) ++ * SPI2 L4 4809b000 - 4809bfff (0x00200010, 0x00000200, 0x00000000) ++ * MMC/SDIO Mod 4809c000 - 4809cfff (REV 0x0044) ++ * MMC/SDIO L4 4809d000 - 4809dfff (0x00200010, 0x01000200, 0x01000000) ++ * MS_PRO Mod 4809e000 - 4809efff (REV Abort) ++ * MS_PRO L4 4809f000 - 4809ffff (0x00200010, 0x01000200, 0x01000000) ++ * RNG Mod 480a0000 - 480a0fff (REV 0xFC066F93?) ++ * RNG L4 480a1000 - 480a1fff (0x00200010, 0x01000200, 0x00000000) ++ * DES3DES Mod 480a2000 - 480a2fff (REV 0x00000000?) ++ * DES3DES L4 480a3000 - 480a3fff (0x00200010, 0x01000200, 0x00000000) ++ * SHA1MD5 Mod 480a4000 - 480a4fff (REV 0x00000000?) ++ * SHA1MD5 L4 480a5000 - 480a5fff (0x00200010, 0x01000200, 0x00000000) ++ * AES Mod 480a6000 - 480a6fff (REV 0x00000000?) ++ * AES L4 480a7000 - 480a7fff (0x00200010, 0x00000200, 0x00000000) ++ * PKA Mod 480a8000 - 480a9fff (REV 0x00000000?) ++ * PKA L4 480aa000 - 480aafff (0x00200010, 0x00000200, 0x00000000) ++ * MG Mod 480b0000 - 480b0fff (REV Abort) ++ * MG L4 480b1000 - 480b1fff (0x00200010, 0x01000200, 0x01000000) ++ * HDQ/1-wire Mod 480b2000 - 480b2fff (REV 0x00000002) ++ * HDQ/1-wire L4 480b3000 - 480b3fff (0x00200010, 0x00000200, 0x00000000) ++ * MPU interrupt 480fe000 - 480fefff (REV 0x00000020) ++ * IVA RAM 5c000000 - 5c01ffff (REV Abort) ++ * IVA ROM 5c020000 - 5c027fff (REV Abort) ++ * IMG_BUF_A 5c040000 - 5c040fff (REV Abort) ++ * IMG_BUF_B 5c042000 - 5c042fff (REV Abort) ++ * VLCDS 5c048000 - 5c0487ff (REV Abort) ++ * IMX_COEF 5c049000 - 5c04afff (REV Abort) ++ * IMX_CMD 5c051000 - 5c051fff (REV Abort) ++ * VLCDQ 5c053000 - 5c0533ff (REV Abort) ++ * VLCDH 5c054000 - 5c054fff (REV Abort) ++ * SEQ_CMD 5c055000 - 5c055fff (REV Abort) ++ * IMX_REG 5c056000 - 5c0560ff (REV Abort) ++ * VLCD_REG 5c056100 - 5c0561ff (REV Abort) ++ * SEQ_REG 5c056200 - 5c0562ff (REV Abort) ++ * IMG_BUF_REG 5c056300 - 5c0563ff (REV Abort) ++ * SEQIRQ_REG 5c056400 - 5c0564ff (REV Abort) ++ * OCP_REG 5c060000 - 5c060fff (REV Abort) ++ * SYSC_REG 5c070000 - 5c070fff (REV Abort) ++ * MMU_REG 5d000000 - 5d000fff (REV Abort) + * sDMA R 68000400 - 680005ff + * sDMA W 68000600 - 680007ff + * Display Control 68000800 - 680009ff +@@ -3849,9 +3849,9 @@ + * GPMC (firewall) 68006000 - 680063ff + * GPMC (err login) 68006400 - 680067ff + * SMS (err login) 68006c00 - 68006fff +- * SMS registers 68008000 - 68008fff +- * SDRC registers 68009000 - 68009fff +- * GPMC registers 6800a000 6800afff ++ * SMS registers 68008000 - 68008fff (REV 0x00000020) ++ * SDRC registers 68009000 - 68009fff (REV 0x00000020) ++ * GPMC registers 6800a000 6800afff (REV 0x00000020) + */ + + qemu_register_reset(omap2_mpu_reset, s); +diff -urN 4242/hw/pc.c qemu-omap/hw/pc.c +--- 4242/hw/pc.c 2008-04-24 21:26:22.000000000 +0100 ++++ qemu-omap/hw/pc.c 2008-04-23 09:57:56.000000000 +0100 +@@ -445,6 +445,37 @@ + bdrv_set_boot_sector(drives_table[hda].bdrv, bootsect, sizeof(bootsect)); + } + ++static int load_kernel(const char *filename, uint8_t *addr, ++ uint8_t *real_addr) ++{ ++ int fd, size; ++ int setup_sects; ++ ++ fd = open(filename, O_RDONLY | O_BINARY); ++ if (fd < 0) ++ return -1; ++ ++ /* load 16 bit code */ ++ if (read(fd, real_addr, 512) != 512) ++ goto fail; ++ setup_sects = real_addr[0x1F1]; ++ if (!setup_sects) ++ setup_sects = 4; ++ if (read(fd, real_addr + 512, setup_sects * 512) != ++ setup_sects * 512) ++ goto fail; ++ ++ /* load 32 bit code */ ++ size = read(fd, addr, 16 * 1024 * 1024); ++ if (size < 0) ++ goto fail; ++ close(fd); ++ return size; ++ fail: ++ close(fd); ++ return -1; ++} ++ + static long get_file_size(FILE *f) + { + long where, size; +diff -urN 4242/hw/tusb6010.c qemu-omap/hw/tusb6010.c +--- 4242/hw/tusb6010.c 2008-04-23 12:18:54.000000000 +0100 ++++ qemu-omap/hw/tusb6010.c 2008-04-23 09:57:56.000000000 +0100 +@@ -287,9 +287,6 @@ + /* TODO: How is this signalled? */ + } + +-extern CPUReadMemoryFunc *musb_read[]; +-extern CPUWriteMemoryFunc *musb_write[]; +- + static uint32_t tusb_async_readb(void *opaque, target_phys_addr_t addr) + { + struct tusb_s *s = (struct tusb_s *) opaque; +diff -urN 4242/hw/usb.h qemu-omap/hw/usb.h +--- 4242/hw/usb.h 2008-04-23 12:18:54.000000000 +0100 ++++ qemu-omap/hw/usb.h 2008-04-23 09:57:56.000000000 +0100 +@@ -219,6 +219,9 @@ + /* usb-msd.c */ + USBDevice *usb_msd_init(const char *filename); + ++/* usb-net.c */ ++USBDevice *usb_net_init(NICInfo *nd); ++ + /* usb-wacom.c */ + USBDevice *usb_wacom_init(void); + +@@ -254,3 +257,7 @@ + uint32_t musb_core_intr_get(struct musb_s *s); + void musb_core_intr_clear(struct musb_s *s, uint32_t mask); + void musb_set_size(struct musb_s *s, int epnum, int size, int is_tx); ++#ifdef NEED_CPU_H ++extern CPUReadMemoryFunc *musb_read[]; ++extern CPUWriteMemoryFunc *musb_write[]; ++#endif +diff -urN 4242/hw/usb-hub.c qemu-omap/hw/usb-hub.c +--- 4242/hw/usb-hub.c 2008-04-23 11:43:37.000000000 +0100 ++++ qemu-omap/hw/usb-hub.c 2008-04-23 09:57:56.000000000 +0100 +@@ -146,8 +146,8 @@ + 0x07, /* u8 ep_bLength; */ + 0x05, /* u8 ep_bDescriptorType; Endpoint */ + 0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */ +- 0x03, /* u8 ep_bmAttributes; Interrupt */ +- 0x02, 0x00, /* u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */ ++ 0x03, /* u8 ep_bmAttributes; Interrupt */ ++ 0x02, 0x00, /* u16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */ + 0xff /* u8 ep_bInterval; (255ms -- usb 2.0 spec) */ + }; + +diff -urN 4242/hw/usb-net.c qemu-omap/hw/usb-net.c +--- 4242/hw/usb-net.c 1970-01-01 01:00:00.000000000 +0100 ++++ qemu-omap/hw/usb-net.c 2008-04-23 09:57:56.000000000 +0100 +@@ -0,0 +1,1334 @@ ++/* ++ * QEMU USB Net devices ++ * ++ * Copyright (c) 2006 Thomas Sailer ++ * based on 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 "qemu-common.h" ++#include "usb.h" ++#include "net.h" ++#include "../audio/sys-queue.h" ++ ++typedef uint32_t __le32; ++#include "ndis.h" ++ ++/*#define TRAFFIC_DEBUG*/ ++/* Thanks to NetChip Technologies for donating this product ID. ++ * It's for devices with only CDC Ethernet configurations. ++ */ ++#define CDC_VENDOR_NUM 0x0525 /* NetChip */ ++#define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */ ++/* For hardware that can talk RNDIS and either of the above protocols, ++ * use this ID ... the windows INF files will know it. ++ */ ++#define RNDIS_VENDOR_NUM 0x0525 /* NetChip */ ++#define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */ ++ ++#define STRING_MANUFACTURER 1 ++#define STRING_PRODUCT 2 ++#define STRING_ETHADDR 3 ++#define STRING_DATA 4 ++#define STRING_CONTROL 5 ++#define STRING_RNDIS_CONTROL 6 ++#define STRING_CDC 7 ++#define STRING_SUBSET 8 ++#define STRING_RNDIS 9 ++#define STRING_SERIALNUMBER 10 ++ ++#define DEV_CONFIG_VALUE 1 /* cdc or subset */ ++#define DEV_RNDIS_CONFIG_VALUE 2 /* rndis; optional */ ++ ++#define USB_CDC_SUBCLASS_ACM 0x02 ++#define USB_CDC_SUBCLASS_ETHERNET 0x06 ++ ++#define USB_CDC_PROTO_NONE 0 ++#define USB_CDC_ACM_PROTO_VENDOR 0xff ++ ++#define USB_CDC_HEADER_TYPE 0x00 /* header_desc */ ++#define USB_CDC_CALL_MANAGEMENT_TYPE 0x01 /* call_mgmt_descriptor */ ++#define USB_CDC_ACM_TYPE 0x02 /* acm_descriptor */ ++#define USB_CDC_UNION_TYPE 0x06 /* union_desc */ ++#define USB_CDC_ETHERNET_TYPE 0x0f /* ether_desc */ ++ ++#define USB_DT_CS_INTERFACE 0x24 ++#define USB_DT_CS_ENDPOINT 0x25 ++ ++#define ClassInterfaceRequest \ ++ ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8) ++#define ClassInterfaceOutRequest \ ++ ((USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8) ++ ++#define USB_CDC_SEND_ENCAPSULATED_COMMAND 0x00 ++#define USB_CDC_GET_ENCAPSULATED_RESPONSE 0x01 ++#define USB_CDC_REQ_SET_LINE_CODING 0x20 ++#define USB_CDC_REQ_GET_LINE_CODING 0x21 ++#define USB_CDC_REQ_SET_CONTROL_LINE_STATE 0x22 ++#define USB_CDC_REQ_SEND_BREAK 0x23 ++#define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS 0x40 ++#define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER 0x41 ++#define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER 0x42 ++#define USB_CDC_SET_ETHERNET_PACKET_FILTER 0x43 ++#define USB_CDC_GET_ETHERNET_STATISTIC 0x44 ++ ++#define USB_ENDPOINT_XFER_BULK 2 ++#define USB_ENDPOINT_XFER_INT 3 ++ ++#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */ ++#define STATUS_BYTECOUNT 16 /* 8 byte header + data */ ++ ++#define ETH_FRAME_LEN 1514 /* Max. octets in frame sans FCS */ ++ ++/* ++ * mostly the same descriptor as the linux gadget rndis driver ++ */ ++static const uint8_t qemu_net_dev_descriptor[] = { ++ 0x12, /* u8 bLength; */ ++ USB_DT_DEVICE, /* u8 bDescriptorType; Device */ ++ 0x00, 0x02, /* u16 bcdUSB; v2.0 */ ++ USB_CLASS_COMM, /* u8 bDeviceClass; */ ++ 0x00, /* u8 bDeviceSubClass; */ ++ 0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */ ++ 0x40, /* u8 bMaxPacketSize0 */ ++ RNDIS_VENDOR_NUM & 0xff, RNDIS_VENDOR_NUM >> 8, /* u16 idVendor; */ ++ RNDIS_PRODUCT_NUM & 0xff, RNDIS_PRODUCT_NUM >> 8, /* u16 idProduct; */ ++ 0x00, 0x00, /* u16 bcdDevice */ ++ STRING_MANUFACTURER, /* u8 iManufacturer; */ ++ STRING_PRODUCT, /* u8 iProduct; */ ++ STRING_SERIALNUMBER, /* u8 iSerialNumber; */ ++ 0x02 /* u8 bNumConfigurations; */ ++}; ++ ++static const uint8_t qemu_net_rndis_config_descriptor[] = { ++ /* Configuration Descriptor */ ++ 0x09, /* u8 bLength */ ++ USB_DT_CONFIG, /* u8 bDescriptorType */ ++ 0x43, 0x00, /* le16 wTotalLength */ ++ 0x02, /* u8 bNumInterfaces */ ++ DEV_RNDIS_CONFIG_VALUE, /* u8 bConfigurationValue */ ++ STRING_RNDIS, /* u8 iConfiguration */ ++ 0xc0, /* u8 bmAttributes */ ++ 0x32, /* u8 bMaxPower */ ++ /* RNDIS Control Interface */ ++ 0x09, /* u8 bLength */ ++ USB_DT_INTERFACE, /* u8 bDescriptorType */ ++ 0x00, /* u8 bInterfaceNumber */ ++ 0x00, /* u8 bAlternateSetting */ ++ 0x01, /* u8 bNumEndpoints */ ++ USB_CLASS_COMM, /* u8 bInterfaceClass */ ++ USB_CDC_SUBCLASS_ACM, /* u8 bInterfaceSubClass */ ++ USB_CDC_ACM_PROTO_VENDOR, /* u8 bInterfaceProtocol */ ++ STRING_RNDIS_CONTROL, /* u8 iInterface */ ++ /* Header Descriptor */ ++ 0x05, /* u8 bLength */ ++ USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ ++ USB_CDC_HEADER_TYPE, /* u8 bDescriptorSubType */ ++ 0x10, 0x01, /* le16 bcdCDC */ ++ /* Call Management Descriptor */ ++ 0x05, /* u8 bLength */ ++ USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ ++ USB_CDC_CALL_MANAGEMENT_TYPE, /* u8 bDescriptorSubType */ ++ 0x00, /* u8 bmCapabilities */ ++ 0x01, /* u8 bDataInterface */ ++ /* ACM Descriptor */ ++ 0x04, /* u8 bLength */ ++ USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ ++ USB_CDC_ACM_TYPE, /* u8 bDescriptorSubType */ ++ 0x00, /* u8 bmCapabilities */ ++ /* Union Descriptor */ ++ 0x05, /* u8 bLength */ ++ USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ ++ USB_CDC_UNION_TYPE, /* u8 bDescriptorSubType */ ++ 0x00, /* u8 bMasterInterface0 */ ++ 0x01, /* u8 bSlaveInterface0 */ ++ /* Status Descriptor */ ++ 0x07, /* u8 bLength */ ++ USB_DT_ENDPOINT, /* u8 bDescriptorType */ ++ USB_DIR_IN | 1, /* u8 bEndpointAddress */ ++ USB_ENDPOINT_XFER_INT, /* u8 bmAttributes */ ++ STATUS_BYTECOUNT & 0xff, STATUS_BYTECOUNT >> 8, /* le16 wMaxPacketSize */ ++ 1 << LOG2_STATUS_INTERVAL_MSEC, /* u8 bInterval */ ++ /* RNDIS Data Interface */ ++ 0x09, /* u8 bLength */ ++ USB_DT_INTERFACE, /* u8 bDescriptorType */ ++ 0x01, /* u8 bInterfaceNumber */ ++ 0x00, /* u8 bAlternateSetting */ ++ 0x02, /* u8 bNumEndpoints */ ++ USB_CLASS_CDC_DATA, /* u8 bInterfaceClass */ ++ 0x00, /* u8 bInterfaceSubClass */ ++ 0x00, /* u8 bInterfaceProtocol */ ++ STRING_DATA, /* u8 iInterface */ ++ /* Source Endpoint */ ++ 0x07, /* u8 bLength */ ++ USB_DT_ENDPOINT, /* u8 bDescriptorType */ ++ USB_DIR_IN | 2, /* u8 bEndpointAddress */ ++ USB_ENDPOINT_XFER_BULK, /* u8 bmAttributes */ ++ 0x40, 0x00, /* le16 wMaxPacketSize */ ++ 0x00, /* u8 bInterval */ ++ /* Sink Endpoint */ ++ 0x07, /* u8 bLength */ ++ USB_DT_ENDPOINT, /* u8 bDescriptorType */ ++ USB_DIR_OUT | 2, /* u8 bEndpointAddress */ ++ USB_ENDPOINT_XFER_BULK, /* u8 bmAttributes */ ++ 0x40, 0x00, /* le16 wMaxPacketSize */ ++ 0x00 /* u8 bInterval */ ++}; ++ ++static const uint8_t qemu_net_cdc_config_descriptor[] = { ++ /* Configuration Descriptor */ ++ 0x09, /* u8 bLength */ ++ USB_DT_CONFIG, /* u8 bDescriptorType */ ++ 0x50, 0x00, /* le16 wTotalLength */ ++ 0x02, /* u8 bNumInterfaces */ ++ DEV_CONFIG_VALUE, /* u8 bConfigurationValue */ ++ STRING_CDC, /* u8 iConfiguration */ ++ 0xc0, /* u8 bmAttributes */ ++ 0x32, /* u8 bMaxPower */ ++ /* CDC Control Interface */ ++ 0x09, /* u8 bLength */ ++ USB_DT_INTERFACE, /* u8 bDescriptorType */ ++ 0x00, /* u8 bInterfaceNumber */ ++ 0x00, /* u8 bAlternateSetting */ ++ 0x01, /* u8 bNumEndpoints */ ++ USB_CLASS_COMM, /* u8 bInterfaceClass */ ++ USB_CDC_SUBCLASS_ETHERNET, /* u8 bInterfaceSubClass */ ++ USB_CDC_PROTO_NONE, /* u8 bInterfaceProtocol */ ++ STRING_CONTROL, /* u8 iInterface */ ++ /* Header Descriptor */ ++ 0x05, /* u8 bLength */ ++ USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ ++ USB_CDC_HEADER_TYPE, /* u8 bDescriptorSubType */ ++ 0x10, 0x01, /* le16 bcdCDC */ ++ /* Union Descriptor */ ++ 0x05, /* u8 bLength */ ++ USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ ++ USB_CDC_UNION_TYPE, /* u8 bDescriptorSubType */ ++ 0x00, /* u8 bMasterInterface0 */ ++ 0x01, /* u8 bSlaveInterface0 */ ++ /* Ethernet Descriptor */ ++ 0x0d, /* u8 bLength */ ++ USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ ++ USB_CDC_ETHERNET_TYPE, /* u8 bDescriptorSubType */ ++ STRING_ETHADDR, /* u8 iMACAddress */ ++ 0x00, 0x00, 0x00, 0x00, /* le32 bmEthernetStatistics */ ++ ETH_FRAME_LEN & 0xff, ETH_FRAME_LEN >> 8, /* le16 wMaxSegmentSize */ ++ 0x00, 0x00, /* le16 wNumberMCFilters */ ++ 0x00, /* u8 bNumberPowerFilters */ ++ /* Status Descriptor */ ++ 0x07, /* u8 bLength */ ++ USB_DT_ENDPOINT, /* u8 bDescriptorType */ ++ USB_DIR_IN | 1, /* u8 bEndpointAddress */ ++ USB_ENDPOINT_XFER_INT, /* u8 bmAttributes */ ++ STATUS_BYTECOUNT & 0xff, STATUS_BYTECOUNT >> 8, /* le16 wMaxPacketSize */ ++ 1 << LOG2_STATUS_INTERVAL_MSEC, /* u8 bInterval */ ++ /* CDC Data (nop) Interface */ ++ 0x09, /* u8 bLength */ ++ USB_DT_INTERFACE, /* u8 bDescriptorType */ ++ 0x01, /* u8 bInterfaceNumber */ ++ 0x00, /* u8 bAlternateSetting */ ++ 0x00, /* u8 bNumEndpoints */ ++ USB_CLASS_CDC_DATA, /* u8 bInterfaceClass */ ++ 0x00, /* u8 bInterfaceSubClass */ ++ 0x00, /* u8 bInterfaceProtocol */ ++ 0x00, /* u8 iInterface */ ++ /* CDC Data Interface */ ++ 0x09, /* u8 bLength */ ++ USB_DT_INTERFACE, /* u8 bDescriptorType */ ++ 0x01, /* u8 bInterfaceNumber */ ++ 0x01, /* u8 bAlternateSetting */ ++ 0x02, /* u8 bNumEndpoints */ ++ USB_CLASS_CDC_DATA, /* u8 bInterfaceClass */ ++ 0x00, /* u8 bInterfaceSubClass */ ++ 0x00, /* u8 bInterfaceProtocol */ ++ STRING_DATA, /* u8 iInterface */ ++ /* Source Endpoint */ ++ 0x07, /* u8 bLength */ ++ USB_DT_ENDPOINT, /* u8 bDescriptorType */ ++ USB_DIR_IN | 2, /* u8 bEndpointAddress */ ++ USB_ENDPOINT_XFER_BULK, /* u8 bmAttributes */ ++ 0x40, 0x00, /* le16 wMaxPacketSize */ ++ 0x00, /* u8 bInterval */ ++ /* Sink Endpoint */ ++ 0x07, /* u8 bLength */ ++ USB_DT_ENDPOINT, /* u8 bDescriptorType */ ++ USB_DIR_OUT | 2, /* u8 bEndpointAddress */ ++ USB_ENDPOINT_XFER_BULK, /* u8 bmAttributes */ ++ 0x40, 0x00, /* le16 wMaxPacketSize */ ++ 0x00 /* u8 bInterval */ ++}; ++ ++/* ++ * RNDIS Status ++ */ ++ ++#define RNDIS_MAXIMUM_FRAME_SIZE 1518 ++#define RNDIS_MAX_TOTAL_SIZE 1558 ++ ++/* Remote NDIS Versions */ ++#define RNDIS_MAJOR_VERSION 1 ++#define RNDIS_MINOR_VERSION 0 ++ ++/* Status Values */ ++#define RNDIS_STATUS_SUCCESS 0x00000000U /* Success */ ++#define RNDIS_STATUS_FAILURE 0xC0000001U /* Unspecified error */ ++#define RNDIS_STATUS_INVALID_DATA 0xC0010015U /* Invalid data */ ++#define RNDIS_STATUS_NOT_SUPPORTED 0xC00000BBU /* Unsupported request */ ++#define RNDIS_STATUS_MEDIA_CONNECT 0x4001000BU /* Device connected */ ++#define RNDIS_STATUS_MEDIA_DISCONNECT 0x4001000CU /* Device disconnected */ ++ ++/* Message Set for Connectionless (802.3) Devices */ ++#define REMOTE_NDIS_PACKET_MSG 0x00000001U ++#define REMOTE_NDIS_INITIALIZE_MSG 0x00000002U /* Initialize device */ ++#define REMOTE_NDIS_HALT_MSG 0x00000003U ++#define REMOTE_NDIS_QUERY_MSG 0x00000004U ++#define REMOTE_NDIS_SET_MSG 0x00000005U ++#define REMOTE_NDIS_RESET_MSG 0x00000006U ++#define REMOTE_NDIS_INDICATE_STATUS_MSG 0x00000007U ++#define REMOTE_NDIS_KEEPALIVE_MSG 0x00000008U ++ ++/* Message completion */ ++#define REMOTE_NDIS_INITIALIZE_CMPLT 0x80000002U ++#define REMOTE_NDIS_QUERY_CMPLT 0x80000004U ++#define REMOTE_NDIS_SET_CMPLT 0x80000005U ++#define REMOTE_NDIS_RESET_CMPLT 0x80000006U ++#define REMOTE_NDIS_KEEPALIVE_CMPLT 0x80000008U ++ ++/* Device Flags */ ++#define RNDIS_DF_CONNECTIONLESS 0x00000001U ++#define RNDIS_DF_CONNECTION_ORIENTED 0x00000002U ++ ++#define RNDIS_MEDIUM_802_3 0x00000000U ++ ++/* from drivers/net/sk98lin/h/skgepnmi.h */ ++#define OID_PNP_CAPABILITIES 0xFD010100 ++#define OID_PNP_SET_POWER 0xFD010101 ++#define OID_PNP_QUERY_POWER 0xFD010102 ++#define OID_PNP_ADD_WAKE_UP_PATTERN 0xFD010103 ++#define OID_PNP_REMOVE_WAKE_UP_PATTERN 0xFD010104 ++#define OID_PNP_ENABLE_WAKE_UP 0xFD010106 ++ ++typedef struct rndis_init_msg_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++ __le32 MajorVersion; ++ __le32 MinorVersion; ++ __le32 MaxTransferSize; ++} rndis_init_msg_type; ++ ++typedef struct rndis_init_cmplt_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++ __le32 Status; ++ __le32 MajorVersion; ++ __le32 MinorVersion; ++ __le32 DeviceFlags; ++ __le32 Medium; ++ __le32 MaxPacketsPerTransfer; ++ __le32 MaxTransferSize; ++ __le32 PacketAlignmentFactor; ++ __le32 AFListOffset; ++ __le32 AFListSize; ++} rndis_init_cmplt_type; ++ ++typedef struct rndis_halt_msg_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++} rndis_halt_msg_type; ++ ++typedef struct rndis_query_msg_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++ __le32 OID; ++ __le32 InformationBufferLength; ++ __le32 InformationBufferOffset; ++ __le32 DeviceVcHandle; ++} rndis_query_msg_type; ++ ++typedef struct rndis_query_cmplt_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++ __le32 Status; ++ __le32 InformationBufferLength; ++ __le32 InformationBufferOffset; ++} rndis_query_cmplt_type; ++ ++typedef struct rndis_set_msg_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++ __le32 OID; ++ __le32 InformationBufferLength; ++ __le32 InformationBufferOffset; ++ __le32 DeviceVcHandle; ++} rndis_set_msg_type; ++ ++typedef struct rndis_set_cmplt_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++ __le32 Status; ++} rndis_set_cmplt_type; ++ ++typedef struct rndis_reset_msg_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 Reserved; ++} rndis_reset_msg_type; ++ ++typedef struct rndis_reset_cmplt_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 Status; ++ __le32 AddressingReset; ++} rndis_reset_cmplt_type; ++ ++typedef struct rndis_indicate_status_msg_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 Status; ++ __le32 StatusBufferLength; ++ __le32 StatusBufferOffset; ++} rndis_indicate_status_msg_type; ++ ++typedef struct rndis_keepalive_msg_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++} rndis_keepalive_msg_type; ++ ++typedef struct rndis_keepalive_cmplt_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 RequestID; ++ __le32 Status; ++} rndis_keepalive_cmplt_type; ++ ++struct rndis_packet_msg_type ++{ ++ __le32 MessageType; ++ __le32 MessageLength; ++ __le32 DataOffset; ++ __le32 DataLength; ++ __le32 OOBDataOffset; ++ __le32 OOBDataLength; ++ __le32 NumOOBDataElements; ++ __le32 PerPacketInfoOffset; ++ __le32 PerPacketInfoLength; ++ __le32 VcHandle; ++ __le32 Reserved; ++}; ++ ++struct rndis_config_parameter ++{ ++ __le32 ParameterNameOffset; ++ __le32 ParameterNameLength; ++ __le32 ParameterType; ++ __le32 ParameterValueOffset; ++ __le32 ParameterValueLength; ++}; ++ ++/* implementation specific */ ++enum rndis_state ++{ ++ RNDIS_UNINITIALIZED, ++ RNDIS_INITIALIZED, ++ RNDIS_DATA_INITIALIZED, ++}; ++ ++static const uint32_t oid_supported_list[] = ++{ ++ /* the general stuff */ ++ OID_GEN_SUPPORTED_LIST, ++ OID_GEN_HARDWARE_STATUS, ++ OID_GEN_MEDIA_SUPPORTED, ++ OID_GEN_MEDIA_IN_USE, ++ OID_GEN_MAXIMUM_FRAME_SIZE, ++ OID_GEN_LINK_SPEED, ++ OID_GEN_TRANSMIT_BLOCK_SIZE, ++ OID_GEN_RECEIVE_BLOCK_SIZE, ++ OID_GEN_VENDOR_ID, ++ OID_GEN_VENDOR_DESCRIPTION, ++ OID_GEN_VENDOR_DRIVER_VERSION, ++ OID_GEN_CURRENT_PACKET_FILTER, ++ OID_GEN_MAXIMUM_TOTAL_SIZE, ++ OID_GEN_MEDIA_CONNECT_STATUS, ++ OID_GEN_PHYSICAL_MEDIUM, ++ /* the statistical stuff */ ++ OID_GEN_XMIT_OK, ++ OID_GEN_RCV_OK, ++ OID_GEN_XMIT_ERROR, ++ OID_GEN_RCV_ERROR, ++ OID_GEN_RCV_NO_BUFFER, ++ /* mandatory 802.3 */ ++ /* the general stuff */ ++ OID_802_3_PERMANENT_ADDRESS, ++ OID_802_3_CURRENT_ADDRESS, ++ OID_802_3_MULTICAST_LIST, ++ OID_802_3_MAC_OPTIONS, ++ OID_802_3_MAXIMUM_LIST_SIZE, ++ ++ /* the statistical stuff */ ++ OID_802_3_RCV_ERROR_ALIGNMENT, ++ OID_802_3_XMIT_ONE_COLLISION, ++ OID_802_3_XMIT_MORE_COLLISIONS ++}; ++ ++struct rndis_response { ++ TAILQ_ENTRY(rndis_response) entries; ++ uint32_t length; ++ uint8_t buf[0]; ++}; ++ ++ ++typedef struct USBNetState { ++ USBDevice dev; ++ ++ unsigned int rndis; ++ enum rndis_state rndis_state; ++ uint32_t medium; ++ uint32_t speed; ++ uint32_t media_state; ++ uint16_t filter; ++ uint32_t vendorid; ++ uint8_t mac[6]; ++ ++ unsigned int out_ptr; ++ uint8_t out_buf[2048]; ++ ++ USBPacket *inpkt; ++ unsigned int in_ptr, in_len; ++ uint8_t in_buf[2048]; ++ ++ VLANClientState *vc; ++ TAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp; ++} USBNetState; ++ ++ ++static int ndis_query(USBNetState *s, uint32_t oid, uint8_t *inbuf, unsigned int inlen, uint8_t *outbuf) ++{ ++ switch (oid) { ++ /* general oids (table 4-1) */ ++ /* mandatory */ ++ case OID_GEN_SUPPORTED_LIST: ++ { ++ unsigned int i, count = sizeof(oid_supported_list) / sizeof(uint32_t); ++ for (i = 0; i < count; i++) ++ ((__le32 *)outbuf)[i] = cpu_to_le32(oid_supported_list[i]); ++ return sizeof(oid_supported_list); ++ } ++ ++ /* mandatory */ ++ case OID_GEN_HARDWARE_STATUS: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_MEDIA_SUPPORTED: ++ *((__le32 *)outbuf) = cpu_to_le32(s->medium); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_MEDIA_IN_USE: ++ *((__le32 *)outbuf) = cpu_to_le32(s->medium); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_MAXIMUM_FRAME_SIZE: ++ *((__le32 *)outbuf) = cpu_to_le32(ETH_FRAME_LEN); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_LINK_SPEED: ++ *((__le32 *)outbuf) = cpu_to_le32(s->speed); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_TRANSMIT_BLOCK_SIZE: ++ *((__le32 *)outbuf) = cpu_to_le32(ETH_FRAME_LEN); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_RECEIVE_BLOCK_SIZE: ++ *((__le32 *)outbuf) = cpu_to_le32(ETH_FRAME_LEN); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_VENDOR_ID: ++ *((__le32 *)outbuf) = cpu_to_le32(0x1234); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_VENDOR_DESCRIPTION: ++ strcpy(outbuf, "QEMU USB RNDIS Net"); ++ return strlen(outbuf) + 1; ++ ++ case OID_GEN_VENDOR_DRIVER_VERSION: ++ *((__le32 *)outbuf) = cpu_to_le32(1); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_CURRENT_PACKET_FILTER: ++ *((__le32 *)outbuf) = cpu_to_le32(s->filter); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_MAXIMUM_TOTAL_SIZE: ++ *((__le32 *)outbuf) = cpu_to_le32(RNDIS_MAX_TOTAL_SIZE); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_MEDIA_CONNECT_STATUS: ++ *((__le32 *)outbuf) = cpu_to_le32(s->media_state); ++ return sizeof(__le32); ++ ++ case OID_GEN_PHYSICAL_MEDIUM: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ case OID_GEN_MAC_OPTIONS: ++ *((__le32 *)outbuf) = cpu_to_le32(NDIS_MAC_OPTION_RECEIVE_SERIALIZED | NDIS_MAC_OPTION_FULL_DUPLEX); ++ return sizeof(__le32); ++ ++ /* statistics OIDs (table 4-2) */ ++ /* mandatory */ ++ case OID_GEN_XMIT_OK: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_RCV_OK: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_XMIT_ERROR: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_RCV_ERROR: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_GEN_RCV_NO_BUFFER: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ /* ieee802.3 OIDs (table 4-3) */ ++ /* mandatory */ ++ case OID_802_3_PERMANENT_ADDRESS: ++ memcpy(outbuf, s->mac, 6); ++ return 6; ++ ++ /* mandatory */ ++ case OID_802_3_CURRENT_ADDRESS: ++ memcpy(outbuf, s->mac, 6); ++ return 6; ++ ++ /* mandatory */ ++ case OID_802_3_MULTICAST_LIST: ++ *((__le32 *)outbuf) = cpu_to_le32(0xE0000000); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_802_3_MAXIMUM_LIST_SIZE: ++ *((__le32 *)outbuf) = cpu_to_le32(1); ++ return sizeof(__le32); ++ ++ case OID_802_3_MAC_OPTIONS: ++ return 0; ++ ++ /* ieee802.3 statistics OIDs (table 4-4) */ ++ /* mandatory */ ++ case OID_802_3_RCV_ERROR_ALIGNMENT: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_802_3_XMIT_ONE_COLLISION: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ /* mandatory */ ++ case OID_802_3_XMIT_MORE_COLLISIONS: ++ *((__le32 *)outbuf) = cpu_to_le32(0); ++ return sizeof(__le32); ++ ++ default: ++ fprintf(stderr, "usbnet: unknown OID 0x%08x\n", oid); ++ return 0; ++ } ++ return -1; ++} ++ ++static int ndis_set(USBNetState *s, uint32_t oid, uint8_t *inbuf, unsigned int inlen) ++{ ++ switch (oid) { ++ case OID_GEN_CURRENT_PACKET_FILTER: ++ s->filter = le32_to_cpup((__le32 *)inbuf); ++ if (s->filter) { ++ s->rndis_state = RNDIS_DATA_INITIALIZED; ++ } else { ++ s->rndis_state = RNDIS_INITIALIZED; ++ } ++ return 0; ++ ++ case OID_802_3_MULTICAST_LIST: ++ return 0; ++ ++ } ++ return -1; ++} ++ ++static int rndis_get_response(USBNetState *s, uint8_t *buf) ++{ ++ int ret = 0; ++ struct rndis_response *r = s->rndis_resp.tqh_first; ++ if (!r) ++ return ret; ++ TAILQ_REMOVE(&s->rndis_resp, r, entries); ++ ret = r->length; ++ memcpy(buf, r->buf, r->length); ++ qemu_free(r); ++ return ret; ++} ++ ++static void *rndis_queue_response(USBNetState *s, unsigned int length) ++{ ++ struct rndis_response *r = qemu_mallocz(sizeof(struct rndis_response) + length); ++ if (!r) ++ return NULL; ++ TAILQ_INSERT_TAIL(&s->rndis_resp, r, entries); ++ r->length = length; ++ return &r->buf[0]; ++} ++ ++static void rndis_clear_responsequeue(USBNetState *s) ++{ ++ struct rndis_response *r; ++ ++ while ((r = s->rndis_resp.tqh_first)) { ++ TAILQ_REMOVE(&s->rndis_resp, r, entries); ++ qemu_free(r); ++ } ++} ++ ++static int rndis_init_response(USBNetState *s, rndis_init_msg_type *buf) ++{ ++ rndis_init_cmplt_type *resp = rndis_queue_response(s, sizeof(rndis_init_cmplt_type)); ++ if (!resp) ++ return USB_RET_STALL; ++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_INITIALIZE_CMPLT); ++ resp->MessageLength = cpu_to_le32(sizeof(rndis_init_cmplt_type)); ++ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */ ++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); ++ resp->MajorVersion = cpu_to_le32(RNDIS_MAJOR_VERSION); ++ resp->MinorVersion = cpu_to_le32(RNDIS_MINOR_VERSION); ++ resp->DeviceFlags = cpu_to_le32(RNDIS_DF_CONNECTIONLESS); ++ resp->Medium = cpu_to_le32(RNDIS_MEDIUM_802_3); ++ resp->MaxPacketsPerTransfer = cpu_to_le32(1); ++ resp->MaxTransferSize = cpu_to_le32(ETH_FRAME_LEN + sizeof(struct rndis_packet_msg_type) + 22); ++ resp->PacketAlignmentFactor = cpu_to_le32(0); ++ resp->AFListOffset = cpu_to_le32(0); ++ resp->AFListSize = cpu_to_le32(0); ++ return 0; ++} ++ ++static int rndis_query_response(USBNetState *s, rndis_query_msg_type *buf, unsigned int length) ++{ ++ rndis_query_cmplt_type *resp; ++ uint8_t infobuf[sizeof(oid_supported_list)]; /* oid_supported_list is the largest data reply */ ++ uint32_t bufoffs, buflen; ++ int infobuflen; ++ unsigned int resplen; ++ bufoffs = le32_to_cpu(buf->InformationBufferOffset) + 8; ++ buflen = le32_to_cpu(buf->InformationBufferLength); ++ if (bufoffs + buflen > length) ++ return USB_RET_STALL; ++ infobuflen = ndis_query(s, le32_to_cpu(buf->OID), bufoffs + (uint8_t *)buf, buflen, infobuf); ++ resplen = sizeof(rndis_query_cmplt_type) + ((infobuflen < 0) ? 0 : infobuflen); ++ resp = rndis_queue_response(s, resplen); ++ if (!resp) ++ return USB_RET_STALL; ++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_QUERY_CMPLT); ++ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */ ++ resp->MessageLength = cpu_to_le32(resplen); ++ if (infobuflen < 0) { ++ /* OID not supported */ ++ resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED); ++ resp->InformationBufferLength = cpu_to_le32(0); ++ resp->InformationBufferOffset = cpu_to_le32(0); ++ return 0; ++ } ++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); ++ resp->InformationBufferOffset = cpu_to_le32(infobuflen ? sizeof(rndis_query_cmplt_type) - 8 : 0); ++ resp->InformationBufferLength = cpu_to_le32(infobuflen); ++ memcpy(resp + 1, infobuf, infobuflen); ++ return 0; ++} ++ ++static int rndis_set_response(USBNetState *s, rndis_set_msg_type *buf, unsigned int length) ++{ ++ rndis_set_cmplt_type *resp = rndis_queue_response(s, sizeof(rndis_set_cmplt_type)); ++ uint32_t bufoffs, buflen; ++ if (!resp) ++ return USB_RET_STALL; ++ bufoffs = le32_to_cpu(buf->InformationBufferOffset) + 8; ++ buflen = le32_to_cpu(buf->InformationBufferLength); ++ if (bufoffs + buflen > length) ++ return USB_RET_STALL; ++ int ret = ndis_set(s, le32_to_cpu(buf->OID), bufoffs + (uint8_t *)buf, buflen); ++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_SET_CMPLT); ++ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */ ++ resp->MessageLength = cpu_to_le32(sizeof(rndis_set_cmplt_type)); ++ if (ret < 0) { ++ /* OID not supported */ ++ resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED); ++ return 0; ++ } ++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); ++ return 0; ++} ++ ++static int rndis_reset_response(USBNetState *s, rndis_reset_msg_type *buf) ++{ ++ rndis_reset_cmplt_type *resp = rndis_queue_response(s, sizeof(rndis_reset_cmplt_type)); ++ if (!resp) ++ return USB_RET_STALL; ++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_RESET_CMPLT); ++ resp->MessageLength = cpu_to_le32(sizeof(rndis_reset_cmplt_type)); ++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); ++ /* resent information */ ++ resp->AddressingReset = cpu_to_le32(1); ++ return 0; ++} ++ ++static int rndis_keepalive_response(USBNetState *s, rndis_keepalive_msg_type *buf) ++{ ++ rndis_keepalive_cmplt_type *resp = rndis_queue_response(s, sizeof(rndis_keepalive_cmplt_type)); ++ if (!resp) ++ return USB_RET_STALL; ++ resp->MessageType = cpu_to_le32(REMOTE_NDIS_KEEPALIVE_CMPLT); ++ resp->MessageLength = cpu_to_le32(sizeof(rndis_keepalive_cmplt_type)); ++ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */ ++ resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); ++ return 0; ++} ++ ++static int rndis_parse(USBNetState *s, uint8_t *data, int length) ++{ ++ uint32_t MsgType, MsgLength; ++ __le32 *tmp = (__le32 *)data; ++ MsgType = le32_to_cpup(tmp++); ++ MsgLength = le32_to_cpup(tmp++); ++ ++ switch (MsgType) { ++ case REMOTE_NDIS_INITIALIZE_MSG: ++ s->rndis_state = RNDIS_INITIALIZED; ++ return rndis_init_response(s, (rndis_init_msg_type *)data); ++ ++ case REMOTE_NDIS_HALT_MSG: ++ s->rndis_state = RNDIS_UNINITIALIZED; ++ return 0; ++ ++ case REMOTE_NDIS_QUERY_MSG: ++ return rndis_query_response(s, (rndis_query_msg_type *)data, length); ++ ++ case REMOTE_NDIS_SET_MSG: ++ return rndis_set_response(s, (rndis_set_msg_type *)data, length); ++ ++ case REMOTE_NDIS_RESET_MSG: ++ rndis_clear_responsequeue(s); ++ s->out_ptr = s->in_ptr = s->in_len = 0; ++ return rndis_reset_response(s, (rndis_reset_msg_type *)data); ++ ++ case REMOTE_NDIS_KEEPALIVE_MSG: ++ /* For USB: host does this every 5 seconds */ ++ return rndis_keepalive_response(s, (rndis_keepalive_msg_type *)data); ++ } ++ return USB_RET_STALL; ++} ++ ++static void usb_net_handle_reset(USBDevice *dev) ++{ ++} ++ ++static int usb_net_handle_control(USBDevice *dev, int request, int value, ++ int index, int length, uint8_t *data) ++{ ++ USBNetState *s = (USBNetState *)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 ClassInterfaceOutRequest | USB_CDC_SEND_ENCAPSULATED_COMMAND: ++ if (!s->rndis || value || index != 0) ++ goto fail; ++#if TRAFFIC_DEBUG ++ { ++ unsigned int i; ++ fprintf(stderr, "SEND_ENCAPSULATED_COMMAND:"); ++ for (i = 0; i < length; i++) { ++ if (!(i & 15)) ++ fprintf(stderr, "\n%04X:", i); ++ fprintf(stderr, " %02X", data[i]); ++ } ++ fprintf(stderr, "\n\n"); ++ } ++#endif ++ ret = rndis_parse(s, data, length); ++ break; ++ ++ case ClassInterfaceRequest | USB_CDC_GET_ENCAPSULATED_RESPONSE: ++ if (!s->rndis || value || index != 0) ++ goto fail; ++ ret = rndis_get_response(s, data); ++ if (!ret) { ++ data[0] = 0; ++ ret = 1; ++ } ++#if TRAFFIC_DEBUG ++ { ++ unsigned int i; ++ fprintf(stderr, "GET_ENCAPSULATED_RESPONSE:"); ++ for (i = 0; i < ret; i++) { ++ if (!(i & 15)) ++ fprintf(stderr, "\n%04X:", i); ++ fprintf(stderr, " %02X", data[i]); ++ } ++ fprintf(stderr, "\n\n"); ++ } ++#endif ++ break; ++ ++ case DeviceRequest | USB_REQ_GET_DESCRIPTOR: ++ switch(value >> 8) { ++ case USB_DT_DEVICE: ++ ret = sizeof(qemu_net_dev_descriptor); ++ memcpy(data, qemu_net_dev_descriptor, ret); ++ break; ++ ++ case USB_DT_CONFIG: ++ switch (value & 0xff) { ++ case 0: ++ ret = sizeof(qemu_net_rndis_config_descriptor); ++ memcpy(data, qemu_net_rndis_config_descriptor, ++ ret); ++ break; ++ ++ case 1: ++ ret = sizeof(qemu_net_cdc_config_descriptor); ++ memcpy(data, qemu_net_cdc_config_descriptor, ++ ret); ++ break; ++ ++ default: ++ goto fail; ++ } ++ data[2] = ret & 0xff; ++ data[3] = ret >> 8; ++ 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 STRING_MANUFACTURER: ++ ret = set_usb_string(data, "QEMU"); ++ break; ++ ++ case STRING_PRODUCT: ++ ret = set_usb_string(data, "RNDIS/QEMU USB Network Device"); ++ break; ++ ++ case STRING_ETHADDR: ++ ret = set_usb_string(data, "400102030405"); ++ break; ++ ++ case STRING_DATA: ++ ret = set_usb_string(data, "QEMU USB Net Data Interface"); ++ break; ++ ++ case STRING_CONTROL: ++ ret = set_usb_string(data, "QEMU USB Net Control Interface"); ++ break; ++ ++ case STRING_RNDIS_CONTROL: ++ ret = set_usb_string(data, "QEMU USB Net RNDIS Control Interface"); ++ break; ++ ++ case STRING_CDC: ++ ret = set_usb_string(data, "QEMU USB Net CDC"); ++ break; ++ ++ case STRING_SUBSET: ++ ret = set_usb_string(data, "QEMU USB Net Subset"); ++ break; ++ ++ case STRING_RNDIS: ++ ret = set_usb_string(data, "QEMU USB Net RNDIS"); ++ break; ++ ++ case STRING_SERIALNUMBER: ++ ret = set_usb_string(data, "1"); ++ break; ++ ++ default: ++ goto fail; ++ } ++ break; ++ ++ default: ++ goto fail; ++ } ++ break; ++ ++ case DeviceRequest | USB_REQ_GET_CONFIGURATION: ++ data[0] = s->rndis ? DEV_RNDIS_CONFIG_VALUE : DEV_CONFIG_VALUE; ++ ret = 1; ++ break; ++ ++ case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: ++ switch (value & 0xff) { ++ case DEV_CONFIG_VALUE: ++ s->rndis = 0; ++ break; ++ ++ case DEV_RNDIS_CONFIG_VALUE: ++ s->rndis = 1; ++ break; ++ ++ default: ++ goto fail; ++ } ++ ret = 0; ++ break; ++ ++ case DeviceRequest | USB_REQ_GET_INTERFACE: ++ case InterfaceRequest | USB_REQ_GET_INTERFACE: ++ data[0] = 0; ++ ret = 1; ++ break; ++ ++ case DeviceOutRequest | USB_REQ_SET_INTERFACE: ++ case InterfaceOutRequest | USB_REQ_SET_INTERFACE: ++ ret = 0; ++ break; ++ ++ default: ++ fail: ++ fprintf(stderr, "usbnet: failed control transaction: request 0x%x value 0x%x index 0x%x length 0x%x\n", ++ request, value, index, length); ++ ret = USB_RET_STALL; ++ break; ++ } ++ return ret; ++} ++ ++static int usb_net_handle_statusin(USBNetState *s, USBPacket *p) ++{ ++ int ret = 8; ++ if (p->len < 8) ++ return USB_RET_STALL; ++ ((__le32 *)p->data)[0] = cpu_to_le32(1); ++ ((__le32 *)p->data)[1] = cpu_to_le32(0); ++ if (!s->rndis_resp.tqh_first) ++ ret = USB_RET_NAK; ++#if DEBUG ++ fprintf(stderr, "usbnet: interrupt poll len %u return %d", p->len, ret); ++ { ++ int i; ++ fprintf(stderr, ":"); ++ for (i = 0; i < ret; i++) { ++ if (!(i & 15)) ++ fprintf(stderr, "\n%04X:", i); ++ fprintf(stderr, " %02X", p->data[i]); ++ } ++ fprintf(stderr, "\n\n"); ++ } ++#endif ++ return ret; ++} ++ ++static int usb_net_handle_datain(USBNetState *s, USBPacket *p) ++{ ++ int ret = USB_RET_NAK; ++ ++ if (s->in_ptr > s->in_len) { ++ s->in_ptr = s->in_len = 0; ++ ret = USB_RET_NAK; ++ return ret; ++ } ++ if (!s->in_len) { ++ ret = USB_RET_NAK; ++ return ret; ++ } ++ ret = s->in_len - s->in_ptr; ++ if (ret > p->len) ++ ret = p->len; ++ memcpy(p->data, &s->in_buf[s->in_ptr], ret); ++ s->in_ptr += ret; ++ if (s->in_ptr >= s->in_len && (s->rndis || (s->in_len & (64-1)) || !ret)) { ++ /* no short packet necessary */ ++ s->in_ptr = s->in_len = 0; ++ } ++#if TRAFFIC_DEBUG ++ fprintf(stderr, "usbnet: data in len %u return %d", p->len, ret); ++ { ++ int i; ++ fprintf(stderr, ":"); ++ for (i = 0; i < ret; i++) { ++ if (!(i & 15)) ++ fprintf(stderr, "\n%04X:", i); ++ fprintf(stderr, " %02X", p->data[i]); ++ } ++ fprintf(stderr, "\n\n"); ++ } ++#endif ++ return ret; ++} ++ ++static int usb_net_handle_dataout(USBNetState *s, USBPacket *p) ++{ ++ int ret = p->len; ++ int sz = sizeof(s->out_buf) - s->out_ptr; ++ struct rndis_packet_msg_type *msg = (struct rndis_packet_msg_type *)s->out_buf; ++ uint32_t len; ++ ++#if TRAFFIC_DEBUG ++ fprintf(stderr, "usbnet: data out len %u\n", p->len); ++ { ++ int i; ++ fprintf(stderr, ":"); ++ for (i = 0; i < p->len; i++) { ++ if (!(i & 15)) ++ fprintf(stderr, "\n%04X:", i); ++ fprintf(stderr, " %02X", p->data[i]); ++ } ++ fprintf(stderr, "\n\n"); ++ } ++#endif ++ if (sz > ret) ++ sz = ret; ++ memcpy(&s->out_buf[s->out_ptr], p->data, sz); ++ s->out_ptr += sz; ++ if (!s->rndis) { ++ if (ret < 64) { ++ qemu_send_packet(s->vc, s->out_buf, s->out_ptr); ++ s->out_ptr = 0; ++ } ++ return ret; ++ } ++ len = le32_to_cpu(msg->MessageLength); ++ if (s->out_ptr < 8 || s->out_ptr < len) ++ return ret; ++ if (le32_to_cpu(msg->MessageType) == REMOTE_NDIS_PACKET_MSG) { ++ uint32_t offs = 8 + le32_to_cpu(msg->DataOffset); ++ uint32_t size = le32_to_cpu(msg->DataLength); ++ if (offs + size <= len) ++ qemu_send_packet(s->vc, s->out_buf + offs, size); ++ } ++ s->out_ptr -= len; ++ memmove(s->out_buf, &s->out_buf[len], s->out_ptr); ++ return ret; ++} ++ ++static int usb_net_handle_data(USBDevice *dev, USBPacket *p) ++{ ++ USBNetState *s = (USBNetState *)dev; ++ int ret = 0; ++ ++ switch(p->pid) { ++ case USB_TOKEN_IN: ++ switch (p->devep) { ++ case 1: ++ ret = usb_net_handle_statusin(s, p); ++ break; ++ ++ case 2: ++ ret = usb_net_handle_datain(s, p); ++ break; ++ ++ default: ++ goto fail; ++ } ++ break; ++ ++ case USB_TOKEN_OUT: ++ switch (p->devep) { ++ case 2: ++ ret = usb_net_handle_dataout(s, p); ++ break; ++ ++ default: ++ goto fail; ++ } ++ break; ++ ++ default: ++ fail: ++ ret = USB_RET_STALL; ++ break; ++ } ++ if (ret == USB_RET_STALL) ++ fprintf(stderr, "usbnet: failed data transaction: pid 0x%x ep 0x%x len 0x%x\n", p->pid, p->devep, p->len); ++ return ret; ++} ++ ++static void usbnet_receive(void *opaque, const uint8_t *buf, int size) ++{ ++ USBNetState *s = opaque; ++ ++ if (s->rndis) { ++ struct rndis_packet_msg_type *msg = (struct rndis_packet_msg_type *)s->in_buf; ++ if (!s->rndis_state == RNDIS_DATA_INITIALIZED) ++ return; ++ if (size + sizeof(struct rndis_packet_msg_type) > sizeof(s->in_buf)) ++ return; ++ memset(msg, 0, sizeof(struct rndis_packet_msg_type)); ++ msg->MessageType = cpu_to_le32(REMOTE_NDIS_PACKET_MSG); ++ msg->MessageLength = cpu_to_le32(size + sizeof(struct rndis_packet_msg_type)); ++ msg->DataOffset = cpu_to_le32(sizeof(struct rndis_packet_msg_type) - 8); ++ msg->DataLength = cpu_to_le32(size); ++ //msg->OOBDataOffset; ++ //msg->OOBDataLength; ++ //msg->NumOOBDataElements; ++ //msg->PerPacketInfoOffset; ++ //msg->PerPacketInfoLength; ++ //msg->VcHandle; ++ //msg->Reserved; ++ memcpy(msg + 1, buf, size); ++ s->in_len = size + sizeof(struct rndis_packet_msg_type); ++ } else { ++ if (size > sizeof(s->in_buf)) ++ return; ++ memcpy(s->in_buf, buf, size); ++ s->in_len = size; ++ } ++ s->in_ptr = 0; ++} ++ ++static int usbnet_can_receive(void *opaque) ++{ ++ USBNetState *s = opaque; ++ ++ if (s->rndis && !s->rndis_state == RNDIS_DATA_INITIALIZED) ++ return 1; ++ return !s->in_len; ++} ++ ++static void usb_net_handle_destroy(USBDevice *dev) ++{ ++ USBNetState *s = (USBNetState *)dev; ++ rndis_clear_responsequeue(s); ++ qemu_free(s); ++} ++ ++USBDevice *usb_net_init(NICInfo *nd) ++{ ++ USBNetState *s; ++ ++ s = qemu_mallocz(sizeof(USBNetState)); ++ if (!s) ++ return NULL; ++ s->dev.speed = USB_SPEED_FULL; ++ s->dev.handle_packet = usb_generic_handle_packet; ++ ++ s->dev.handle_reset = usb_net_handle_reset; ++ s->dev.handle_control = usb_net_handle_control; ++ s->dev.handle_data = usb_net_handle_data; ++ s->dev.handle_destroy = usb_net_handle_destroy; ++ ++ s->rndis = 1; ++ s->rndis_state = RNDIS_UNINITIALIZED; ++ s->medium = NDIS_MEDIUM_802_3; ++ s->speed = 1000000; /* 100MBps, in 100Bps units */ ++ s->media_state = NDIS_MEDIA_STATE_CONNECTED; ++ s->filter = 0; ++ s->vendorid = 0x1234; ++ memcpy(s->mac, nd->macaddr, 6); ++ TAILQ_INIT(&s->rndis_resp); ++ ++ pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Network Interface"); ++ s->vc = qemu_new_vlan_client(nd->vlan, usbnet_receive, usbnet_can_receive, s); ++ snprintf(s->vc->info_str, sizeof(s->vc->info_str), ++ "usbnet macaddr=%02x:%02x:%02x:%02x:%02x:%02x", ++ s->mac[0], s->mac[1], s->mac[2], ++ s->mac[3], s->mac[4], s->mac[5]); ++ fprintf(stderr, "usbnet: initialized mac %02x:%02x:%02x:%02x:%02x:%02x\n", ++ s->mac[0], s->mac[1], s->mac[2], ++ s->mac[3], s->mac[4], s->mac[5]); ++ return (USBDevice *)s; ++} +diff -urN 4242/Makefile qemu-omap/Makefile +--- 4242/Makefile 2008-04-24 20:17:05.000000000 +0100 ++++ qemu-omap/Makefile 2008-04-23 09:57:55.000000000 +0100 +@@ -55,7 +55,8 @@ + OBJS+=tmp105.o + OBJS+=scsi-disk.o cdrom.o + OBJS+=scsi-generic.o +-OBJS+=usb.o usb-hub.o usb-linux.o usb-hid.o usb-msd.o usb-wacom.o usb-serial.o ++OBJS+=usb.o usb-hub.o usb-linux.o usb-hid.o usb-msd.o usb-net.o ++OBJS+=usb-wacom.o usb-serial.o + OBJS+=sd.o ssi-sd.o + + ifdef CONFIG_BRLAPI +diff -urN 4242/softmmu_template.h qemu-omap/softmmu_template.h +--- 4242/softmmu_template.h 2008-04-24 18:11:49.000000000 +0100 ++++ qemu-omap/softmmu_template.h 2008-04-23 09:57:56.000000000 +0100 +@@ -51,12 +51,15 @@ + int mmu_idx, + void *retaddr); + static inline DATA_TYPE glue(io_read, SUFFIX)(target_phys_addr_t physaddr, +- target_ulong tlb_addr) ++ target_ulong tlb_addr, ++ target_ulong tlb_io) + { + DATA_TYPE res; + int index; + +- index = (tlb_addr >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1); ++ index = (tlb_addr & ~TARGET_PAGE_MASK) >> IO_MEM_SHIFT; ++ if (index > 4) ++ index = (tlb_io >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1); + #if SHIFT <= 2 + res = io_mem_read[index][SHIFT](io_mem_opaque[index], physaddr); + #else +@@ -95,7 +98,9 @@ + /* IO access */ + if ((addr & (DATA_SIZE - 1)) != 0) + goto do_unaligned_access; +- res = glue(io_read, SUFFIX)(physaddr, tlb_addr); ++ res = glue(io_read, SUFFIX)(physaddr, tlb_addr, ++ env->tlb_table[mmu_idx] ++ [index].addr_code); + } else if (((addr & ~TARGET_PAGE_MASK) + DATA_SIZE - 1) >= TARGET_PAGE_SIZE) { + /* slow unaligned access (it spans two pages or IO) */ + do_unaligned_access: +@@ -147,7 +152,9 @@ + /* IO access */ + if ((addr & (DATA_SIZE - 1)) != 0) + goto do_unaligned_access; +- res = glue(io_read, SUFFIX)(physaddr, tlb_addr); ++ res = glue(io_read, SUFFIX)(physaddr, tlb_addr, ++ env->tlb_table[mmu_idx] ++ [index].addr_code); + } else if (((addr & ~TARGET_PAGE_MASK) + DATA_SIZE - 1) >= TARGET_PAGE_SIZE) { + do_unaligned_access: + /* slow unaligned access (it spans two pages) */ +@@ -186,11 +193,14 @@ + static inline void glue(io_write, SUFFIX)(target_phys_addr_t physaddr, + DATA_TYPE val, + target_ulong tlb_addr, +- void *retaddr) ++ void *retaddr, ++ target_ulong tlb_io) + { + int index; + +- index = (tlb_addr >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1); ++ index = (tlb_addr & ~TARGET_PAGE_MASK) >> IO_MEM_SHIFT; ++ if (index > 4) ++ index = (tlb_io >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1); + env->mem_write_vaddr = tlb_addr; + env->mem_write_pc = (unsigned long)retaddr; + #if SHIFT <= 2 +@@ -228,7 +238,8 @@ + if ((addr & (DATA_SIZE - 1)) != 0) + goto do_unaligned_access; + retaddr = GETPC(); +- glue(io_write, SUFFIX)(physaddr, val, tlb_addr, retaddr); ++ glue(io_write, SUFFIX)(physaddr, val, tlb_addr, retaddr, ++ env->tlb_table[mmu_idx][index].addr_code); + } else if (((addr & ~TARGET_PAGE_MASK) + DATA_SIZE - 1) >= TARGET_PAGE_SIZE) { + do_unaligned_access: + retaddr = GETPC(); +@@ -278,7 +289,8 @@ + /* IO access */ + if ((addr & (DATA_SIZE - 1)) != 0) + goto do_unaligned_access; +- glue(io_write, SUFFIX)(physaddr, val, tlb_addr, retaddr); ++ glue(io_write, SUFFIX)(physaddr, val, tlb_addr, retaddr, ++ env->tlb_table[mmu_idx][index].addr_code); + } else if (((addr & ~TARGET_PAGE_MASK) + DATA_SIZE - 1) >= TARGET_PAGE_SIZE) { + do_unaligned_access: + /* XXX: not efficient, but simple */ +diff -urN 4242/target-i386/cpu.h qemu-omap/target-i386/cpu.h +--- 4242/target-i386/cpu.h 2008-04-23 12:18:51.000000000 +0100 ++++ qemu-omap/target-i386/cpu.h 2008-04-23 09:57:56.000000000 +0100 +@@ -499,7 +499,7 @@ + SegmentCache idt; /* only base and limit are used */ + + target_ulong cr[9]; /* NOTE: cr1, cr5-7 are unused */ +- uint64_t a20_mask; ++ uint32_t a20_mask; + + /* FPU state */ + unsigned int fpstt; /* top of stack index */ +diff -urN 4242/target-i386/helper2.c qemu-omap/target-i386/helper2.c +--- 4242/target-i386/helper2.c 2008-04-23 12:18:51.000000000 +0100 ++++ qemu-omap/target-i386/helper2.c 2008-04-23 09:57:56.000000000 +0100 +@@ -377,7 +377,7 @@ + env->hflags |= HF_GIF_MASK; + + cpu_x86_update_cr0(env, 0x60000010); +- env->a20_mask = ~0x0; ++ env->a20_mask = 0xffffffff; + env->smbase = 0x30000; + + env->idt.limit = 0xffff; +@@ -695,7 +695,7 @@ + /* when a20 is changed, all the MMU mappings are invalid, so + we must flush everything */ + tlb_flush(env, 1); +- env->a20_mask = (~0x100000) | (a20_state << 20); ++ env->a20_mask = 0xffefffff | (a20_state << 20); + } + } + +@@ -800,8 +800,7 @@ + + #else + +-/* Bits 52-62 of a PTE are reserved. Bit 63 is the NX bit. */ +-#define PHYS_ADDR_MASK 0xffffffffff000L ++#define PHYS_ADDR_MASK 0xfffff000 + + /* return value: + -1 = cannot handle fault +@@ -813,10 +812,9 @@ + int is_write1, int mmu_idx, int is_softmmu) + { + uint64_t ptep, pte; +- target_ulong pde_addr, pte_addr; ++ uint32_t pdpe_addr, pde_addr, pte_addr; + int error_code, is_dirty, prot, page_size, ret, is_write, is_user; +- target_phys_addr_t paddr; +- uint32_t page_offset; ++ unsigned long paddr, page_offset; + target_ulong vaddr, virt_addr; + + is_user = mmu_idx == MMU_USER_IDX; +@@ -836,11 +834,12 @@ + + if (env->cr[4] & CR4_PAE_MASK) { + uint64_t pde, pdpe; +- target_ulong pdpe_addr; + ++ /* XXX: we only use 32 bit physical addresses */ + #ifdef TARGET_X86_64 + if (env->hflags & HF_LMA_MASK) { +- uint64_t pml4e_addr, pml4e; ++ uint32_t pml4e_addr; ++ uint64_t pml4e; + int32_t sext; + + /* test virtual address sign extension */ +@@ -1102,19 +1101,17 @@ + + target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr) + { +- target_ulong pde_addr, pte_addr; +- uint64_t pte; +- target_phys_addr_t paddr; +- uint32_t page_offset; +- int page_size; ++ uint32_t pde_addr, pte_addr; ++ uint32_t pde, pte, paddr, page_offset, page_size; + + if (env->cr[4] & CR4_PAE_MASK) { +- target_ulong pdpe_addr; +- uint64_t pde, pdpe; ++ uint32_t pdpe_addr, pde_addr, pte_addr; ++ uint32_t pdpe; + ++ /* XXX: we only use 32 bit physical addresses */ + #ifdef TARGET_X86_64 + if (env->hflags & HF_LMA_MASK) { +- uint64_t pml4e_addr, pml4e; ++ uint32_t pml4e_addr, pml4e; + int32_t sext; + + /* test virtual address sign extension */ +@@ -1124,13 +1121,13 @@ + + pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) & + env->a20_mask; +- pml4e = ldq_phys(pml4e_addr); ++ pml4e = ldl_phys(pml4e_addr); + if (!(pml4e & PG_PRESENT_MASK)) + return -1; + + pdpe_addr = ((pml4e & ~0xfff) + (((addr >> 30) & 0x1ff) << 3)) & + env->a20_mask; +- pdpe = ldq_phys(pdpe_addr); ++ pdpe = ldl_phys(pdpe_addr); + if (!(pdpe & PG_PRESENT_MASK)) + return -1; + } else +@@ -1138,14 +1135,14 @@ + { + pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) & + env->a20_mask; +- pdpe = ldq_phys(pdpe_addr); ++ pdpe = ldl_phys(pdpe_addr); + if (!(pdpe & PG_PRESENT_MASK)) + return -1; + } + + pde_addr = ((pdpe & ~0xfff) + (((addr >> 21) & 0x1ff) << 3)) & + env->a20_mask; +- pde = ldq_phys(pde_addr); ++ pde = ldl_phys(pde_addr); + if (!(pde & PG_PRESENT_MASK)) { + return -1; + } +@@ -1158,11 +1155,9 @@ + pte_addr = ((pde & ~0xfff) + (((addr >> 12) & 0x1ff) << 3)) & + env->a20_mask; + page_size = 4096; +- pte = ldq_phys(pte_addr); ++ pte = ldl_phys(pte_addr); + } + } else { +- uint32_t pde; +- + if (!(env->cr[0] & CR0_PG_MASK)) { + pte = addr; + page_size = 4096; +diff -urN 4242/vl.c qemu-omap/vl.c +--- 4242/vl.c 2008-04-24 21:26:21.000000000 +0100 ++++ qemu-omap/vl.c 2008-04-23 09:57:57.000000000 +0100 +@@ -5284,6 +5284,11 @@ + dev = usb_keyboard_init(); + } else if (strstart(devname, "disk:", &p)) { + dev = usb_msd_init(p); ++ } else if (strstart(devname, "net:", &p)) { ++ unsigned int nr = strtoul(p, NULL, 0); ++ if (nr >= (unsigned int) nb_nics || strcmp(nd_table[nr].model, "usb")) ++ return -1; ++ dev = usb_net_init(&nd_table[nr]); + } else if (!strcmp(devname, "wacom-tablet")) { + dev = usb_wacom_init(); + } else if (strstart(devname, "serial:", &p)) { diff --git a/packages/qemu/qemu-0.9.1+svn/revert_arm_tcg.patch.gz b/packages/qemu/qemu-0.9.1+svn/revert_arm_tcg.patch.gz new file mode 100644 index 0000000000000000000000000000000000000000..eb2a76c1672d382acb97dfb4b258a0dc8213220c GIT binary patch literal 97991 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 ++#define FUTEX_WAIT 0 ++#define FUTEX_WAKE 1 ++#define FUTEX_FD 2 ++#define FUTEX_REQUEUE 3 ++#define FUTEX_CMP_REQUEUE 4 ++#define FUTEX_WAKE_OP 5 ++#define FUTEX_LOCK_PI 6 ++#define FUTEX_UNLOCK_PI 7 ++ + #include + #include + #include diff --git a/packages/qemu/qemu-native_svn.bb b/packages/qemu/qemu-native_svn.bb new file mode 100644 index 0000000000..1e3a4dbbfa --- /dev/null +++ b/packages/qemu/qemu-native_svn.bb @@ -0,0 +1,2 @@ +require qemu_svn.bb +require qemu-native.inc diff --git a/packages/qemu/qemu_svn.bb b/packages/qemu/qemu_svn.bb new file mode 100644 index 0000000000..6e52a1513f --- /dev/null +++ b/packages/qemu/qemu_svn.bb @@ -0,0 +1,48 @@ +LICENSE = "GPL" +DEPENDS = "zlib" +PV = "0.9.1+svnr${SRCREV}" +PR = "r12" + +FILESPATH = "${FILE_DIRNAME}/qemu-${PV}/:${FILE_DIRNAME}/qemu-0.9.1+svn/" + +SRC_URI = "\ + svn://svn.savannah.nongnu.org/qemu;module=trunk \ + file://05_non-fatal_if_linux_hd_missing.patch;patch=1;pnum=1 \ + file://06_exit_segfault.patch;patch=1;pnum=0 \ + file://10_signal_jobs.patch;patch=1;pnum=0 \ + file://11_signal_sigaction.patch;patch=1;pnum=0 \ + file://22_net_tuntap_stall.patch;patch=1;pnum=0 \ + file://31_syscalls.patch;patch=1;pnum=0 \ + file://32_syscall_sysctl.patch;patch=1;pnum=0 \ + file://33_syscall_ppc_clone.patch;patch=1;pnum=0 \ + file://39_syscall_fadvise64.patch;patch=1;pnum=0 \ + file://41_arm_fpa_sigfpe.patch;patch=1;pnum=0;maxrev=4028 \ + file://52_ne2000_return.patch;patch=1;pnum=1 \ + file://61_safe_64bit_int.patch;patch=1;pnum=0 \ + file://63_sparc_build.patch;patch=1;pnum=0 \ + file://64_ppc_asm_constraints.patch;patch=1;pnum=1 \ + file://65_kfreebsd.patch;patch=1;pnum=0 \ + file://66_tls_ld.patch;patch=1;pnum=0 \ + file://91-oh-sdl-cursor.patch;patch=1;pnum=0 \ + file://qemu-0.9.0-nptl.patch;patch=1 \ + file://qemu-0.9.0-nptl-update.patch;patch=1;maxrev=4028 \ + file://qemu-amd64-32b-mapping-0.9.0.patch;patch=1 \ + file://workaround_bad_futex_headers.patch;patch=1 \ + file://fix_segfault.patch;patch=1 \ + file://no-strip.patch;patch=1 \ + file://fix_brk.patch;patch=1 \ + file://fix_protection_bits.patch;patch=1 \ + file://revert_arm_tcg.patch.gz;patch=1;minrev=4242 \ + file://qemu-n800-support.patch;patch=1" + +S = "${WORKDIR}/trunk" + +#EXTRA_OECONF += "--disable-sdl" +#EXTRA_OECONF += "--target-list=arm-linux-user,arm-softmmu,i386-softmmu" +EXTRA_OECONF += "--disable-gfx-check" + +inherit autotools + +do_configure() { + ${S}/configure --prefix=${prefix} ${EXTRA_OECONF} +} -- 2.39.5