merge of 5d13f311dd93df73db461d6abca7480b39bbecbc

and 6bdfd4680fb56e499b8a254034efb752dead5002
author: Kristoffer Ericson <kristoffer_e1@hotmail.com> 2006-10-25 23:27:19 +0000
committer: Kristoffer Ericson <kristoffer_e1@hotmail.com> 2006-10-25 23:27:19 +0000
commit: e26108affb65e89fcf248a58564b9c25934a04a0 (patch)
tree: 3c27feb6d440ed2df41309dae277afc13427c12f /packages/qemu
parent: d7fd0e38cb60cb0ac871723c34616bf542d423cc (diff)
parent: 12f3d309156ac047b0826904ef729b83b997b8b5 (diff)
23 files changed, 1712 insertions, 1767 deletions
diff --git a/packages/qemu/files/compiler.patch b/packages/qemu/files/compiler.patch
new file mode 100644
index 0000000000..dad18b3a61
--- /dev/null
+++ b/packages/qemu/files/compiler.patch
@@ -0,0 +1,10 @@
+--- qemu/usb-linux.c~	2006-07-19 19:06:15.000000000 +0100
++++ qemu/usb-linux.c	2006-10-02 12:49:00.000000000 +0100
+@@ -26,7 +26,6 @@
+ #if defined(__linux__)
+ #include <dirent.h>
+ #include <sys/ioctl.h>
+-#include <linux/compiler.h>
+ #include <linux/usbdevice_fs.h>
+ #include <linux/version.h>
+ 
diff --git a/packages/qemu/files/nodocs_cvs.patch b/packages/qemu/files/nodocs_cvs.patch
new file mode 100644
index 0000000000..b52d860fb0
--- /dev/null
+++ b/packages/qemu/files/nodocs_cvs.patch
@@ -0,0 +1,44 @@
+Index: qemu/Makefile
+===================================================================
+--- qemu.orig/Makefile	2006-04-18 11:11:37.000000000 +0100
++++ qemu/Makefile	2006-04-18 11:14:34.000000000 +0100
+@@ -11,7 +11,7 @@
+ ifdef CONFIG_STATIC
+ LDFLAGS+=-static
+ endif
+-DOCS=qemu-doc.html qemu-tech.html qemu.1 qemu-img.1
++DOCS=
+ 
+ all: dyngen$(EXESUF) $(TOOLS) $(DOCS)
+ 	for d in $(TARGET_DIRS); do \
+@@ -51,11 +51,11 @@
+ 			video.x proll.elf linux_boot.bin; do \
+ 		$(INSTALL) -m 644 $(SRC_PATH)/pc-bios/$$x "$(DESTDIR)$(datadir)"; \
+ 	done
+-	mkdir -p "$(DESTDIR)$(docdir)"
+-	$(INSTALL) -m 644 qemu-doc.html  qemu-tech.html "$(DESTDIR)$(docdir)"
++#	mkdir -p "$(DESTDIR)$(docdir)"
++#	$(INSTALL) -m 644 qemu-doc.html  qemu-tech.html "$(DESTDIR)$(docdir)"
+ ifndef CONFIG_WIN32
+-	mkdir -p "$(DESTDIR)$(mandir)/man1"
+-	$(INSTALL) qemu.1 qemu-img.1 "$(DESTDIR)$(mandir)/man1"
++#	mkdir -p "$(DESTDIR)$(mandir)/man1"
++#	$(INSTALL) qemu.1 qemu-img.1 "$(DESTDIR)$(mandir)/man1"
+ 	mkdir -p "$(DESTDIR)$(datadir)/keymaps"
+ 	for x in $(KEYMAPS); do \
+ 		$(INSTALL) -m 644 $(SRC_PATH)/keymaps/$$x "$(DESTDIR)$(datadir)/keymaps"; \
+@@ -122,10 +122,10 @@
+ 	$(datadir)/ppc_rom.bin \
+ 	$(datadir)/video.x \
+ 	$(datadir)/proll.elf \
+-	$(datadir)/linux_boot.bin \
+-	$(docdir)/qemu-doc.html \
+-	$(docdir)/qemu-tech.html \
+-	$(mandir)/man1/qemu.1 $(mandir)/man1/qemu-img.1 )
++	$(datadir)/linux_boot.bin
++#	$(docdir)/qemu-doc.html \
++#	$(docdir)/qemu-tech.html \
++#	$(mandir)/man1/qemu.1 $(mandir)/man1/qemu-img.1 )
+ 
+ ifneq ($(wildcard .depend),)
+ include .depend
diff --git a/packages/qemu/files/qemu-pci-irq-sharing.patch b/packages/qemu/files/qemu-pci-irq-sharing.patch
new file mode 100644
index 0000000000..c47e89895f
--- /dev/null
+++ b/packages/qemu/files/qemu-pci-irq-sharing.patch
@@ -0,0 +1,52 @@
+diff -pNaur qemu-cvs-ts-orig/hw/pci.c qemu-cvs-ts/hw/pci.c
+--- qemu-cvs-ts-orig/hw/pci.c	2006-08-17 10:46:34.000000000 +0000
++++ qemu-cvs-ts/hw/pci.c	2006-09-23 17:02:41.000000000 +0000
+@@ -34,6 +34,7 @@ struct PCIBus {
+     SetIRQFunc *low_set_irq;
+     void *irq_opaque;
+     PCIDevice *devices[256];
++    int irq_count[4];
+ };
+ 
+ static void pci_update_mappings(PCIDevice *d);
+@@ -49,6 +50,7 @@ PCIBus *pci_register_bus(pci_set_irq_fn 
+     bus->set_irq = set_irq;
+     bus->irq_opaque = pic;
+     bus->devfn_min = devfn_min;
++    memset(bus->irq_count, 0, sizeof(bus->irq_count));
+     first_bus = bus;
+     return bus;
+ }
+@@ -100,6 +102,7 @@ PCIDevice *pci_register_device(PCIBus *b
+     pci_dev->bus = bus;
+     pci_dev->devfn = devfn;
+     pstrcpy(pci_dev->name, sizeof(pci_dev->name), name);
++    memset(pci_dev->irq_state, 0, sizeof(pci_dev->irq_state));
+ 
+     if (!config_read)
+         config_read = pci_default_read_config;
+@@ -404,7 +407,10 @@ uint32_t pci_data_read(void *opaque, uin
+ void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level)
+ {
+     PCIBus *bus = pci_dev->bus;
+-    bus->set_irq(pci_dev, bus->irq_opaque, irq_num, level);
++    bus->irq_count[irq_num] += level - pci_dev->irq_state[irq_num];
++    pci_dev->irq_state[irq_num] = level;
++    bus->set_irq(pci_dev, bus->irq_opaque,
++                 irq_num, !!bus->irq_count[irq_num]);
+ }
+ 
+ /***********************************************************/
+diff -pNaur qemu-cvs-ts-orig/vl.h qemu-cvs-ts/vl.h
+--- qemu-cvs-ts-orig/vl.h	2006-09-18 01:15:29.000000000 +0000
++++ qemu-cvs-ts/vl.h	2006-09-23 17:15:21.000000000 +0000
+@@ -733,6 +733,9 @@ struct PCIDevice {
+     PCIConfigWriteFunc *config_write;
+     /* ??? This is a PC-specific hack, and should be removed.  */
+     int irq_index;
++
++    /* remember last irq levels */
++    int irq_state[4];
+ };
+ 
+ PCIDevice *pci_register_device(PCIBus *bus, const char *name,
diff --git a/packages/qemu/files/qemu-sdl-cursor.patch b/packages/qemu/files/qemu-sdl-cursor.patch
new file mode 100644
index 0000000000..bd6a51a1f5
--- /dev/null
+++ b/packages/qemu/files/qemu-sdl-cursor.patch
@@ -0,0 +1,13 @@
+Index: qemu/sdl.c
+===================================================================
+--- qemu.orig/sdl.c	2006-10-02 17:06:12.000000000 +0100
++++ qemu/sdl.c	2006-10-02 17:06:59.000000000 +0100
+@@ -287,7 +287,7 @@
+ {
+     if (kbd_mouse_is_absolute()) {
+         SDL_ShowCursor(1);
+-        SDL_SetCursor(sdl_cursor_hidden);
++        /* SDL_SetCursor(sdl_cursor_hidden); */
+     } else {
+         SDL_ShowCursor(0);
+     }
diff --git a/packages/qemu/files/qemu-usb-wacom-0.8.2.patch b/packages/qemu/files/qemu-usb-wacom-0.8.2.patch
new file mode 100644
index 0000000000..33a6db3f18
--- /dev/null
+++ b/packages/qemu/files/qemu-usb-wacom-0.8.2.patch
@@ -0,0 +1,445 @@
+diff -pNaur qemu-cvs-ts-orig/hw/usb-wacom.c qemu-cvs-ts/hw/usb-wacom.c
+--- qemu-cvs-ts-orig/hw/usb-wacom.c	1970-01-01 01:00:00.000000000 +0100
++++ qemu-cvs-ts/hw/usb-wacom.c	2006-09-22 20:44:26.000000000 +0200
+@@ -0,0 +1,408 @@
++/*
++ * Wacom PenPartner USB tablet emulation.
++ *
++ * Copyright (c) 2006 Openedhand Ltd.
++ *
++ * Author: Andrzej Zaborowski <balrog@zabor.org>
++ *
++ * Based on hw/usb-hid.c:
++ * Copyright (c) 2005 Fabrice Bellard
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to deal
++ * in the Software without restriction, including without limitation the rights
++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++ * copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in
++ * all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++ * THE SOFTWARE.
++ */
++#include "vl.h"
++
++/* Interface requests */
++#define WACOM_GET_REPORT	0x2101
++#define WACOM_SET_REPORT	0x2109
++
++/* HID interface requests */
++#define HID_GET_REPORT		0xa101
++#define HID_GET_IDLE		0xa102
++#define HID_GET_PROTOCOL	0xa103
++#define HID_SET_IDLE		0x210a
++#define HID_SET_PROTOCOL	0x210b
++
++#define WACOM_MODE_HID		1
++#define WACOM_MODE_WACOM	2
++
++typedef struct USBWacomState {
++    USBDevice dev;
++    int dx, dy, dz, buttons_state;
++    int x, y;
++    int mouse_grabbed;
++    int mode;
++} USBWacomState;
++
++static const uint8_t qemu_wacom_dev_descriptor[] = {
++    0x12,	/*  u8 bLength; */
++    0x01,	/*  u8 bDescriptorType; Device */
++    0x10, 0x10,	/*  u16 bcdUSB; v1.10 */
++
++    0x00,	/*  u8  bDeviceClass; */
++    0x00,	/*  u8  bDeviceSubClass; */
++    0x00,	/*  u8  bDeviceProtocol; [ low/full speeds only ] */
++    0x08,	/*  u8  bMaxPacketSize0; 8 Bytes */
++
++    0x6a, 0x05,	/*  u16 idVendor; */
++    0x00, 0x00,	/*  u16 idProduct; */
++    0x10, 0x42,	/*  u16 bcdDevice */
++
++    0x01,	/*  u8  iManufacturer; */
++    0x02,	/*  u8  iProduct; */
++    0x00,	/*  u8  iSerialNumber; */
++    0x01,	/*  u8  bNumConfigurations; */
++};
++
++static const uint8_t qemu_wacom_config_descriptor[] = {
++    /* one configuration */
++    0x09,	/*  u8  bLength; */
++    0x02,	/*  u8  bDescriptorType; Configuration */
++    0x22, 0x00,	/*  u16 wTotalLength; */
++    0x01,	/*  u8  bNumInterfaces; (1) */
++    0x01,	/*  u8  bConfigurationValue; */
++    0x00,	/*  u8  iConfiguration; */
++    0x80,	/*  u8  bmAttributes; 
++				 Bit 7: must be set,
++				     6: Self-powered,
++				     5: Remote wakeup,
++				     4..0: resvd */
++    40,		/*  u8  MaxPower; */
++
++    /* one interface */
++    0x09,	/*  u8  if_bLength; */
++    0x04,	/*  u8  if_bDescriptorType; Interface */
++    0x00,	/*  u8  if_bInterfaceNumber; */
++    0x00,	/*  u8  if_bAlternateSetting; */
++    0x01,	/*  u8  if_bNumEndpoints; */
++    0x03,	/*  u8  if_bInterfaceClass; HID */
++    0x01,	/*  u8  if_bInterfaceSubClass; Boot */
++    0x02,	/*  u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
++    0x00,	/*  u8  if_iInterface; */
++
++    /* HID descriptor */
++    0x09,	/*  u8  bLength; */
++    0x21,	/*  u8  bDescriptorType; */
++    0x01, 0x10,	/*  u16 HID_class */
++    0x00,	/*  u8  country_code */
++    0x01,	/*  u8  num_descriptors */
++    0x22,	/*  u8  type; Report */
++    0x6e, 0x00,	/*  u16 len */
++
++    /* one endpoint (status change endpoint) */
++    0x07,	/*  u8  ep_bLength; */
++    0x05,	/*  u8  ep_bDescriptorType; Endpoint */
++    0x81,	/*  u8  ep_bEndpointAddress; IN Endpoint 1 */
++    0x03,	/*  u8  ep_bmAttributes; Interrupt */
++    0x08, 0x00,	/*  u16 ep_wMaxPacketSize; */
++    0x0a,	/*  u8  ep_bInterval; */
++};
++
++static void usb_mouse_event(void *opaque,
++                            int dx1, int dy1, int dz1, int buttons_state)
++{
++    USBWacomState *s = opaque;
++
++    s->dx += dx1;
++    s->dy += dy1;
++    s->dz += dz1;
++    s->buttons_state = buttons_state;
++}
++
++static void usb_wacom_event(void *opaque,
++                            int x, int y, int dz, int buttons_state)
++{
++    USBWacomState *s = opaque;
++
++    s->x = x;
++    s->y = y;
++    s->dz += dz;
++    s->buttons_state = buttons_state;
++}
++
++static inline int int_clamp(int val, int vmin, int vmax)
++{
++    if (val < vmin)
++        return vmin;
++    else if (val > vmax)
++        return vmax;
++    else
++        return val;
++}
++
++static int usb_mouse_poll(USBWacomState *s, uint8_t *buf, int len)
++{
++    int dx, dy, dz, b, l;
++
++    if (!s->mouse_grabbed) {
++        qemu_add_mouse_event_handler(usb_mouse_event, s, 1);
++        s->mouse_grabbed = 1;
++    }
++
++    dx = int_clamp(s->dx, -128, 127);
++    dy = int_clamp(s->dy, -128, 127);
++    dz = int_clamp(s->dz, -128, 127);
++
++    s->dx -= dx;
++    s->dy -= dy;
++    s->dz -= dz;
++
++    b = 0;
++    if (s->buttons_state & MOUSE_EVENT_LBUTTON)
++        b |= 0x01;
++    if (s->buttons_state & MOUSE_EVENT_RBUTTON)
++        b |= 0x02;
++    if (s->buttons_state & MOUSE_EVENT_MBUTTON)
++        b |= 0x04;
++
++    buf[0] = b;
++    buf[1] = dx;
++    buf[2] = dy;
++    l = 3;
++    if (len >= 4) {
++        buf[3] = dz;
++        l = 4;
++    }
++    return l;
++}
++
++static int usb_wacom_poll(USBWacomState *s, uint8_t *buf, int len)
++{
++    int b;
++
++    if (!s->mouse_grabbed) {
++        qemu_add_mouse_event_handler(usb_wacom_event, s, 1);
++        s->mouse_grabbed = 1;
++    }
++
++    b = 0;
++    if (s->buttons_state & MOUSE_EVENT_LBUTTON)
++        b |= 0x01;
++    if (s->buttons_state & MOUSE_EVENT_RBUTTON)
++        b |= 0x02;
++    if (s->buttons_state & MOUSE_EVENT_MBUTTON)
++        b |= 0x04;
++
++    if (len < 7)
++        return 0;
++
++    buf[0] = s->mode;
++    buf[1] = s->x & 0xff;
++    buf[2] = s->x >> 8;
++    buf[3] = s->y & 0xff;
++    buf[4] = s->y >> 8;
++    if (b) {
++        buf[5] = 0x40;
++        buf[6] = 0;
++    } else {
++        buf[5] = 0x00;
++        buf[6] = (unsigned char) -120;
++    }
++
++    return 7;
++}
++
++static void usb_wacom_handle_reset(USBDevice *dev)
++{
++    USBWacomState *s = (USBWacomState *) dev;
++
++    s->dx = 0;
++    s->dy = 0;
++    s->dz = 0;
++    s->x = 0;
++    s->y = 0;
++    s->buttons_state = 0;
++    s->mode = WACOM_MODE_HID;
++}
++
++static int usb_wacom_handle_control(USBDevice *dev, int request, int value,
++                                    int index, int length, uint8_t *data)
++{
++    USBWacomState *s = (USBWacomState *) dev;
++    int ret = 0;
++
++    switch (request) {
++    case DeviceRequest | USB_REQ_GET_STATUS:
++        data[0] = (1 << USB_DEVICE_SELF_POWERED) |
++            (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
++        data[1] = 0x00;
++        ret = 2;
++        break;
++    case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
++        if (value == USB_DEVICE_REMOTE_WAKEUP) {
++            dev->remote_wakeup = 0;
++        } else {
++            goto fail;
++        }
++        ret = 0;
++        break;
++    case DeviceOutRequest | USB_REQ_SET_FEATURE:
++        if (value == USB_DEVICE_REMOTE_WAKEUP) {
++            dev->remote_wakeup = 1;
++        } else {
++            goto fail;
++        }
++        ret = 0;
++        break;
++    case DeviceOutRequest | USB_REQ_SET_ADDRESS:
++        dev->addr = value;
++        ret = 0;
++        break;
++    case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
++        switch (value >> 8) {
++        case USB_DT_DEVICE:
++            memcpy(data, qemu_wacom_dev_descriptor, 
++                   sizeof(qemu_wacom_dev_descriptor));
++            ret = sizeof(qemu_wacom_dev_descriptor);
++            break;
++        case USB_DT_CONFIG:
++       	    memcpy(data, qemu_wacom_config_descriptor, 
++                   sizeof(qemu_wacom_config_descriptor));
++            ret = sizeof(qemu_wacom_config_descriptor);
++            break;
++        case USB_DT_STRING:
++            switch (value & 0xff) {
++            case 0:
++                /* language ids */
++                data[0] = 4;
++                data[1] = 3;
++                data[2] = 0x09;
++                data[3] = 0x04;
++                ret = 4;
++                break;
++            case 1:
++                /* serial number */
++                ret = set_usb_string(data, "1");
++                break;
++            case 2:
++		ret = set_usb_string(data, "Wacom PenPartner");
++                break;
++            case 3:
++                /* vendor description */
++                ret = set_usb_string(data, "QEMU " QEMU_VERSION);
++                break;
++            case 4:
++                ret = set_usb_string(data, "Wacom Tablet");
++                break;
++            case 5:
++                ret = set_usb_string(data, "Endpoint1 Interrupt Pipe");
++                break;
++            default:
++                goto fail;
++            }
++            break;
++        default:
++            goto fail;
++        }
++        break;
++    case DeviceRequest | USB_REQ_GET_CONFIGURATION:
++        data[0] = 1;
++        ret = 1;
++        break;
++    case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
++        ret = 0;
++        break;
++    case DeviceRequest | USB_REQ_GET_INTERFACE:
++        data[0] = 0;
++        ret = 1;
++        break;
++    case DeviceOutRequest | USB_REQ_SET_INTERFACE:
++        ret = 0;
++        break;
++    case WACOM_SET_REPORT:
++        qemu_add_mouse_event_handler(NULL, NULL, 0);
++	s->mouse_grabbed = 0;
++        s->mode = data[0];
++        ret = 0;
++        break;
++    case WACOM_GET_REPORT:
++        data[0] = 0;
++        data[1] = s->mode;
++        ret = 2;
++        break;
++    /* USB HID requests */
++    case HID_GET_REPORT:
++        if (s->mode == WACOM_MODE_HID)
++            ret = usb_mouse_poll(s, data, length);
++        else if (s->mode == WACOM_MODE_WACOM)
++            ret = usb_wacom_poll(s, data, length);
++        break;
++    case HID_SET_IDLE:
++        ret = 0;
++        break;
++    default:
++    fail:
++        ret = USB_RET_STALL;
++        break;
++    }
++    return ret;
++}
++
++static int usb_wacom_handle_data(USBDevice *dev, int pid, 
++                                 uint8_t devep, uint8_t *data, int len)
++{
++    USBWacomState *s = (USBWacomState *) dev;
++    int ret = 0;
++
++    switch (pid) {
++    case USB_TOKEN_IN:
++        if (devep == 1) {
++            if (s->mode == WACOM_MODE_HID)
++                ret = usb_mouse_poll(s, data, len);
++            else if (s->mode == WACOM_MODE_WACOM)
++                ret = usb_wacom_poll(s, data, len);
++            break;
++        }
++        /* Fall through.  */
++    case USB_TOKEN_OUT:
++    default:
++        ret = USB_RET_STALL;
++        break;
++    }
++    return ret;
++}
++
++static void usb_wacom_handle_destroy(USBDevice *dev)
++{
++    USBWacomState *s = (USBWacomState *) dev;
++
++    qemu_add_mouse_event_handler(NULL, NULL, 0);
++    qemu_free(s);
++}
++
++USBDevice *usb_wacom_init(void)
++{
++    USBWacomState *s;
++
++    s = qemu_mallocz(sizeof(USBWacomState));
++    if (!s)
++        return NULL;
++    s->dev.speed = USB_SPEED_FULL;
++    s->dev.handle_packet = usb_generic_handle_packet;
++
++    s->dev.handle_reset = usb_wacom_handle_reset;
++    s->dev.handle_control = usb_wacom_handle_control;
++    s->dev.handle_data = usb_wacom_handle_data;
++    s->dev.handle_destroy = usb_wacom_handle_destroy;
++
++    pstrcpy(s->dev.devname, sizeof(s->dev.devname),
++            "QEMU PenPartner Tablet");
++
++    return (USBDevice *) s;
++}
+diff -pNaur qemu-cvs-ts-orig/hw/usb.h qemu-cvs-ts/hw/usb.h
+--- qemu-cvs-ts-orig/hw/usb.h	2006-08-12 03:04:27.000000000 +0200
++++ qemu-cvs-ts/hw/usb.h	2006-09-21 01:40:40.000000000 +0200
+@@ -218,3 +218,6 @@ USBDevice *usb_tablet_init(void);
+ 
+ /* usb-msd.c */
+ USBDevice *usb_msd_init(const char *filename);
++
++/* usb-wacom.c */
++USBDevice *usb_wacom_init(void);
+diff -pNaur qemu-cvs-ts-orig/vl.c qemu-cvs-ts/vl.c
+--- qemu-cvs-ts-orig/vl.c	2006-09-10 16:39:54.000000000 +0200
++++ qemu-cvs-ts/vl.c	2006-09-21 01:45:16.000000000 +0200
+@@ -3765,6 +3765,8 @@ static int usb_device_add(const char *de
+ 	dev = usb_tablet_init();
+     } else if (strstart(devname, "disk:", &p)) {
+         dev = usb_msd_init(p);
++    } else if (!strcmp(devname, "wacom-tablet")) {
++        dev = usb_wacom_init();
+     } else {
+         return -1;
+     }
+diff -pNaur qemu-cvs-ts-orig/Makefile.target qemu-cvs-ts/Makefile.target
+--- qemu-cvs-ts-orig/Makefile.target	2006-09-18 03:15:29.000000000 +0200
++++ qemu-cvs-ts/Makefile.target	2006-09-21 02:32:19.000000000 +0200
+@@ -330,6 +330,7 @@ VL_OBJS+= scsi-disk.o cdrom.o lsi53c895a
+ 
+ # USB layer
+ VL_OBJS+= usb.o usb-hub.o usb-linux.o usb-hid.o usb-ohci.o usb-msd.o
++VL_OBJS+= usb-wacom.o
+ 
+ # PCI network cards
+ VL_OBJS+= ne2000.o rtl8139.o pcnet.o
diff --git a/packages/qemu/files/qemu-usb-wacom-buttons.patch b/packages/qemu/files/qemu-usb-wacom-buttons.patch
new file mode 100644
index 0000000000..ee24c15780
--- /dev/null
+++ b/packages/qemu/files/qemu-usb-wacom-buttons.patch
@@ -0,0 +1,23 @@
+--- qemu-cvs-ts-orig/hw/usb-wacom.c	2006-09-29 22:53:06.000000000 +0000
++++ qemu-cvs-ts/hw/usb-wacom.c	2006-09-29 22:44:14.000000000 +0000
+@@ -203,19 +203,18 @@ static int usb_wacom_poll(USBWacomState 
+         return 0;
+ 
+     buf[0] = s->mode;
++    buf[5] = 0x00;
+     if (b) {
+         buf[1] = s->x & 0xff;
+         buf[2] = s->x >> 8;
+         buf[3] = s->y & 0xff;
+         buf[4] = s->y >> 8;
+-        buf[5] = 0x40;
+         buf[6] = 0;
+     } else {
+         buf[1] = 0;
+         buf[2] = 0;
+         buf[3] = 0;
+         buf[4] = 0;
+-        buf[5] = 0x00;
+         buf[6] = (unsigned char) -127;
+     }
+ 
diff --git a/packages/qemu/files/qemu-usb-wacom-pressure.patch b/packages/qemu/files/qemu-usb-wacom-pressure.patch
new file mode 100644
index 0000000000..668d50d5f2
--- /dev/null
+++ b/packages/qemu/files/qemu-usb-wacom-pressure.patch
@@ -0,0 +1,28 @@
+--- qemu-cvs-ts-orig/hw/usb-wacom.c	2006-09-29 17:27:43.000000000 +0000
++++ qemu-cvs-ts/hw/usb-wacom.c	2006-09-29 17:48:13.000000000 +0000
+@@ -203,16 +203,20 @@ static int usb_wacom_poll(USBWacomState 
+         return 0;
+ 
+     buf[0] = s->mode;
+-    buf[1] = s->x & 0xff;
+-    buf[2] = s->x >> 8;
+-    buf[3] = s->y & 0xff;
+-    buf[4] = s->y >> 8;
+     if (b) {
++        buf[1] = s->x & 0xff;
++        buf[2] = s->x >> 8;
++        buf[3] = s->y & 0xff;
++        buf[4] = s->y >> 8;
+         buf[5] = 0x40;
+         buf[6] = 0;
+     } else {
++        buf[1] = 0;
++        buf[2] = 0;
++        buf[3] = 0;
++        buf[4] = 0;
+         buf[5] = 0x00;
+-        buf[6] = (unsigned char) -120;
++        buf[6] = (unsigned char) -127;
+     }
+ 
+     return 7;
diff --git a/packages/qemu/files/qemu-usb-wacom.patch b/packages/qemu/files/qemu-usb-wacom.patch
new file mode 100644
index 0000000000..c1c39eccaf
--- /dev/null
+++ b/packages/qemu/files/qemu-usb-wacom.patch
@@ -0,0 +1,444 @@
+diff -pNaur qemu-cvs-ts-orig/hw/usb-wacom.c qemu-cvs-ts/hw/usb-wacom.c
+--- qemu-cvs-ts-orig/hw/usb-wacom.c	1970-01-01 01:00:00.000000000 +0100
++++ qemu-cvs-ts/hw/usb-wacom.c	2006-09-22 20:44:26.000000000 +0200
+@@ -0,0 +1,407 @@
++/*
++ * Wacom PenPartner USB tablet emulation.
++ *
++ * Copyright (c) 2006 Openedhand Ltd.
++ *
++ * Author: Andrzej Zaborowski <balrog@zabor.org>
++ *
++ * Based on hw/usb-hid.c:
++ * Copyright (c) 2005 Fabrice Bellard
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to deal
++ * in the Software without restriction, including without limitation the rights
++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++ * copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in
++ * all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++ * THE SOFTWARE.
++ */
++#include "vl.h"
++
++/* Interface requests */
++#define WACOM_GET_REPORT	0x2101
++#define WACOM_SET_REPORT	0x2109
++
++/* HID interface requests */
++#define HID_GET_REPORT		0xa101
++#define HID_GET_IDLE		0xa102
++#define HID_GET_PROTOCOL	0xa103
++#define HID_SET_IDLE		0x210a
++#define HID_SET_PROTOCOL	0x210b
++
++#define WACOM_MODE_HID		1
++#define WACOM_MODE_WACOM	2
++
++typedef struct USBWacomState {
++    USBDevice dev;
++    int dx, dy, dz, buttons_state;
++    int x, y;
++    int mouse_grabbed;
++    int mode;
++} USBWacomState;
++
++static const uint8_t qemu_wacom_dev_descriptor[] = {
++    0x12,	/*  u8 bLength; */
++    0x01,	/*  u8 bDescriptorType; Device */
++    0x10, 0x10,	/*  u16 bcdUSB; v1.10 */
++
++    0x00,	/*  u8  bDeviceClass; */
++    0x00,	/*  u8  bDeviceSubClass; */
++    0x00,	/*  u8  bDeviceProtocol; [ low/full speeds only ] */
++    0x08,	/*  u8  bMaxPacketSize0; 8 Bytes */
++
++    0x6a, 0x05,	/*  u16 idVendor; */
++    0x00, 0x00,	/*  u16 idProduct; */
++    0x10, 0x42,	/*  u16 bcdDevice */
++
++    0x01,	/*  u8  iManufacturer; */
++    0x02,	/*  u8  iProduct; */
++    0x00,	/*  u8  iSerialNumber; */
++    0x01,	/*  u8  bNumConfigurations; */
++};
++
++static const uint8_t qemu_wacom_config_descriptor[] = {
++    /* one configuration */
++    0x09,	/*  u8  bLength; */
++    0x02,	/*  u8  bDescriptorType; Configuration */
++    0x22, 0x00,	/*  u16 wTotalLength; */
++    0x01,	/*  u8  bNumInterfaces; (1) */
++    0x01,	/*  u8  bConfigurationValue; */
++    0x00,	/*  u8  iConfiguration; */
++    0x80,	/*  u8  bmAttributes; 
++				 Bit 7: must be set,
++				     6: Self-powered,
++				     5: Remote wakeup,
++				     4..0: resvd */
++    40,		/*  u8  MaxPower; */
++
++    /* one interface */
++    0x09,	/*  u8  if_bLength; */
++    0x04,	/*  u8  if_bDescriptorType; Interface */
++    0x00,	/*  u8  if_bInterfaceNumber; */
++    0x00,	/*  u8  if_bAlternateSetting; */
++    0x01,	/*  u8  if_bNumEndpoints; */
++    0x03,	/*  u8  if_bInterfaceClass; HID */
++    0x01,	/*  u8  if_bInterfaceSubClass; Boot */
++    0x02,	/*  u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
++    0x00,	/*  u8  if_iInterface; */
++
++    /* HID descriptor */
++    0x09,	/*  u8  bLength; */
++    0x21,	/*  u8  bDescriptorType; */
++    0x01, 0x10,	/*  u16 HID_class */
++    0x00,	/*  u8  country_code */
++    0x01,	/*  u8  num_descriptors */
++    0x22,	/*  u8  type; Report */
++    0x6e, 0x00,	/*  u16 len */
++
++    /* one endpoint (status change endpoint) */
++    0x07,	/*  u8  ep_bLength; */
++    0x05,	/*  u8  ep_bDescriptorType; Endpoint */
++    0x81,	/*  u8  ep_bEndpointAddress; IN Endpoint 1 */
++    0x03,	/*  u8  ep_bmAttributes; Interrupt */
++    0x08, 0x00,	/*  u16 ep_wMaxPacketSize; */
++    0x0a,	/*  u8  ep_bInterval; */
++};
++
++static void usb_mouse_event(void *opaque,
++                            int dx1, int dy1, int dz1, int buttons_state)
++{
++    USBWacomState *s = opaque;
++
++    s->dx += dx1;
++    s->dy += dy1;
++    s->dz += dz1;
++    s->buttons_state = buttons_state;
++}
++
++static void usb_wacom_event(void *opaque,
++                            int x, int y, int dz, int buttons_state)
++{
++    USBWacomState *s = opaque;
++
++    s->x = x;
++    s->y = y;
++    s->dz += dz;
++    s->buttons_state = buttons_state;
++}
++
++static inline int int_clamp(int val, int vmin, int vmax)
++{
++    if (val < vmin)
++        return vmin;
++    else if (val > vmax)
++        return vmax;
++    else
++        return val;
++}
++
++static int usb_mouse_poll(USBWacomState *s, uint8_t *buf, int len)
++{
++    int dx, dy, dz, b, l;
++
++    if (!s->mouse_grabbed) {
++        qemu_add_mouse_event_handler(usb_mouse_event, s, 1);
++        s->mouse_grabbed = 1;
++    }
++
++    dx = int_clamp(s->dx, -128, 127);
++    dy = int_clamp(s->dy, -128, 127);
++    dz = int_clamp(s->dz, -128, 127);
++
++    s->dx -= dx;
++    s->dy -= dy;
++    s->dz -= dz;
++
++    b = 0;
++    if (s->buttons_state & MOUSE_EVENT_LBUTTON)
++        b |= 0x01;
++    if (s->buttons_state & MOUSE_EVENT_RBUTTON)
++        b |= 0x02;
++    if (s->buttons_state & MOUSE_EVENT_MBUTTON)
++        b |= 0x04;
++
++    buf[0] = b;
++    buf[1] = dx;
++    buf[2] = dy;
++    l = 3;
++    if (len >= 4) {
++        buf[3] = dz;
++        l = 4;
++    }
++    return l;
++}
++
++static int usb_wacom_poll(USBWacomState *s, uint8_t *buf, int len)
++{
++    int b;
++
++    if (!s->mouse_grabbed) {
++        qemu_add_mouse_event_handler(usb_wacom_event, s, 1);
++        s->mouse_grabbed = 1;
++    }
++
++    b = 0;
++    if (s->buttons_state & MOUSE_EVENT_LBUTTON)
++        b |= 0x01;
++    if (s->buttons_state & MOUSE_EVENT_RBUTTON)
++        b |= 0x02;
++    if (s->buttons_state & MOUSE_EVENT_MBUTTON)
++        b |= 0x04;
++
++    if (len < 7)
++        return 0;
++
++    buf[0] = s->mode;
++    buf[1] = s->x & 0xff;
++    buf[2] = s->x >> 8;
++    buf[3] = s->y & 0xff;
++    buf[4] = s->y >> 8;
++    if (b) {
++        buf[5] = 0x40;
++        buf[6] = 0;
++    } else {
++        buf[5] = 0x00;
++        buf[6] = (unsigned char) -120;
++    }
++
++    return 7;
++}
++
++static void usb_wacom_handle_reset(USBDevice *dev)
++{
++    USBWacomState *s = (USBWacomState *) dev;
++
++    s->dx = 0;
++    s->dy = 0;
++    s->dz = 0;
++    s->x = 0;
++    s->y = 0;
++    s->buttons_state = 0;
++    s->mode = WACOM_MODE_HID;
++}
++
++static int usb_wacom_handle_control(USBDevice *dev, int request, int value,
++                                    int index, int length, uint8_t *data)
++{
++    USBWacomState *s = (USBWacomState *) dev;
++    int ret = 0;
++
++    switch (request) {
++    case DeviceRequest | USB_REQ_GET_STATUS:
++        data[0] = (1 << USB_DEVICE_SELF_POWERED) |
++            (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
++        data[1] = 0x00;
++        ret = 2;
++        break;
++    case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
++        if (value == USB_DEVICE_REMOTE_WAKEUP) {
++            dev->remote_wakeup = 0;
++        } else {
++            goto fail;
++        }
++        ret = 0;
++        break;
++    case DeviceOutRequest | USB_REQ_SET_FEATURE:
++        if (value == USB_DEVICE_REMOTE_WAKEUP) {
++            dev->remote_wakeup = 1;
++        } else {
++            goto fail;
++        }
++        ret = 0;
++        break;
++    case DeviceOutRequest | USB_REQ_SET_ADDRESS:
++        dev->addr = value;
++        ret = 0;
++        break;
++    case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
++        switch (value >> 8) {
++        case USB_DT_DEVICE:
++            memcpy(data, qemu_wacom_dev_descriptor, 
++                   sizeof(qemu_wacom_dev_descriptor));
++            ret = sizeof(qemu_wacom_dev_descriptor);
++            break;
++        case USB_DT_CONFIG:
++       	    memcpy(data, qemu_wacom_config_descriptor, 
++                   sizeof(qemu_wacom_config_descriptor));
++            ret = sizeof(qemu_wacom_config_descriptor);
++            break;
++        case USB_DT_STRING:
++            switch (value & 0xff) {
++            case 0:
++                /* language ids */
++                data[0] = 4;
++                data[1] = 3;
++                data[2] = 0x09;
++                data[3] = 0x04;
++                ret = 4;
++                break;
++            case 1:
++                /* serial number */
++                ret = set_usb_string(data, "1");
++                break;
++            case 2:
++		ret = set_usb_string(data, "Wacom PenPartner");
++                break;
++            case 3:
++                /* vendor description */
++                ret = set_usb_string(data, "QEMU " QEMU_VERSION);
++                break;
++            case 4:
++                ret = set_usb_string(data, "Wacom Tablet");
++                break;
++            case 5:
++                ret = set_usb_string(data, "Endpoint1 Interrupt Pipe");
++                break;
++            default:
++                goto fail;
++            }
++            break;
++        default:
++            goto fail;
++        }
++        break;
++    case DeviceRequest | USB_REQ_GET_CONFIGURATION:
++        data[0] = 1;
++        ret = 1;
++        break;
++    case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
++        ret = 0;
++        break;
++    case DeviceRequest | USB_REQ_GET_INTERFACE:
++        data[0] = 0;
++        ret = 1;
++        break;
++    case DeviceOutRequest | USB_REQ_SET_INTERFACE:
++        ret = 0;
++        break;
++    case WACOM_SET_REPORT:
++        qemu_add_mouse_event_handler(NULL, NULL, 0);
++	s->mouse_grabbed = 0;
++        s->mode = data[0];
++        ret = 0;
++        break;
++    case WACOM_GET_REPORT:
++        data[0] = 0;
++        data[1] = s->mode;
++        ret = 2;
++        break;
++    /* USB HID requests */
++    case HID_GET_REPORT:
++        if (s->mode == WACOM_MODE_HID)
++            ret = usb_mouse_poll(s, data, length);
++        else if (s->mode == WACOM_MODE_WACOM)
++            ret = usb_wacom_poll(s, data, length);
++        break;
++    case HID_SET_IDLE:
++        ret = 0;
++        break;
++    default:
++    fail:
++        ret = USB_RET_STALL;
++        break;
++    }
++    return ret;
++}
++
++static int usb_wacom_handle_data(USBDevice *dev, USBPacket *p)
++{
++    USBWacomState *s = (USBWacomState *) dev;
++    int ret = 0;
++
++    switch (p->pid) {
++    case USB_TOKEN_IN:
++        if (p->devep == 1) {
++            if (s->mode == WACOM_MODE_HID)
++                ret = usb_mouse_poll(s, p->data, p->len);
++            else if (s->mode == WACOM_MODE_WACOM)
++                ret = usb_wacom_poll(s, p->data, p->len);
++            break;
++        }
++        /* Fall through.  */
++    case USB_TOKEN_OUT:
++    default:
++        ret = USB_RET_STALL;
++        break;
++    }
++    return ret;
++}
++
++static void usb_wacom_handle_destroy(USBDevice *dev)
++{
++    USBWacomState *s = (USBWacomState *) dev;
++
++    qemu_add_mouse_event_handler(NULL, NULL, 0);
++    qemu_free(s);
++}
++
++USBDevice *usb_wacom_init(void)
++{
++    USBWacomState *s;
++
++    s = qemu_mallocz(sizeof(USBWacomState));
++    if (!s)
++        return NULL;
++    s->dev.speed = USB_SPEED_FULL;
++    s->dev.handle_packet = usb_generic_handle_packet;
++
++    s->dev.handle_reset = usb_wacom_handle_reset;
++    s->dev.handle_control = usb_wacom_handle_control;
++    s->dev.handle_data = usb_wacom_handle_data;
++    s->dev.handle_destroy = usb_wacom_handle_destroy;
++
++    pstrcpy(s->dev.devname, sizeof(s->dev.devname),
++            "QEMU PenPartner Tablet");
++
++    return (USBDevice *) s;
++}
+diff -pNaur qemu-cvs-ts-orig/hw/usb.h qemu-cvs-ts/hw/usb.h
+--- qemu-cvs-ts-orig/hw/usb.h	2006-08-12 03:04:27.000000000 +0200
++++ qemu-cvs-ts/hw/usb.h	2006-09-21 01:40:40.000000000 +0200
+@@ -218,3 +218,6 @@ USBDevice *usb_tablet_init(void);
+ 
+ /* usb-msd.c */
+ USBDevice *usb_msd_init(const char *filename);
++
++/* usb-wacom.c */
++USBDevice *usb_wacom_init(void);
+diff -pNaur qemu-cvs-ts-orig/vl.c qemu-cvs-ts/vl.c
+--- qemu-cvs-ts-orig/vl.c	2006-09-10 16:39:54.000000000 +0200
++++ qemu-cvs-ts/vl.c	2006-09-21 01:45:16.000000000 +0200
+@@ -3765,6 +3765,8 @@ static int usb_device_add(const char *de
+ 	dev = usb_tablet_init();
+     } else if (strstart(devname, "disk:", &p)) {
+         dev = usb_msd_init(p);
++    } else if (!strcmp(devname, "wacom-tablet")) {
++        dev = usb_wacom_init();
+     } else {
+         return -1;
+     }
+diff -pNaur qemu-cvs-ts-orig/Makefile.target qemu-cvs-ts/Makefile.target
+--- qemu-cvs-ts-orig/Makefile.target	2006-09-18 03:15:29.000000000 +0200
++++ qemu-cvs-ts/Makefile.target	2006-09-21 02:32:19.000000000 +0200
+@@ -330,6 +330,7 @@ VL_OBJS+= scsi-disk.o cdrom.o lsi53c895a
+ 
+ # USB layer
+ VL_OBJS+= usb.o usb-hub.o usb-linux.o usb-hid.o usb-ohci.o usb-msd.o
++VL_OBJS+= usb-wacom.o
+ 
+ # PCI network cards
+ VL_OBJS+= ne2000.o rtl8139.o pcnet.o
diff --git a/packages/qemu/files/qemu-x-no-sdl.patch b/packages/qemu/files/qemu-x-no-sdl.patch
new file mode 100644
index 0000000000..eb00d9806b
--- /dev/null
+++ b/packages/qemu/files/qemu-x-no-sdl.patch
@@ -0,0 +1,630 @@
+diff -urN qemu-0.8.2/configure qemu-0.8.2-x/configure
+--- qemu-0.8.2/configure	2006-07-22 18:23:34.000000000 +0100
++++ qemu-0.8.2-x/configure	2006-08-24 14:24:33.000000000 +0100
+@@ -492,6 +492,21 @@
+ fi # cross compilation
+ fi # -z $sdl
+ 
++##########################################
++# X Probe
++
++x11=no
++if test -z "$sdl" || test "$sdl" = "no"; then
++  x11=yes
++fi
++
++if test "$x11" = "yes"; then
++  x11=no
++  if `pkg-config --exists x11 xext`; then
++    x11=yes
++  fi
++fi
++
+ # Check if tools are available to build documentation.
+ if [ -x "`which texi2html`" ] && [ -x "`which pod2man`" ]; then
+   build_docs="yes"
+@@ -540,6 +555,7 @@
+ if test "$sdl" != "no" ; then
+     echo "SDL static link   $sdl_static"
+ fi
++echo "X11 support       $x11"
+ echo "mingw32 support   $mingw32"
+ echo "Adlib support     $adlib"
+ echo "CoreAudio support $coreaudio"
+@@ -748,14 +764,14 @@
+ fi
+ 
+ if test "$target_user_only" = "no" -a "$check_gfx" = "yes" \
+-        -a "$sdl" = "no" -a "$cocoa" = "no" ; then
++        -a "$sdl" = "no" -a "$x11" = "no" -a "$cocoa" = "no" ; then
+     echo "ERROR: QEMU requires SDL or Cocoa for graphical output"
+     echo "To build QEMU without graphical output configure with --disable-gfx-check"
+     echo "Note that this will disable all output from the virtual graphics card."
+     exit 1;
+ fi
+ 
+-#echo "Creating $config_mak, $config_h and $target_dir/Makefile"
++echo "Creating $config_mak, $config_h and $target_dir/Makefile"
+ 
+ mkdir -p $target_dir
+ mkdir -p $target_dir/fpu
+@@ -882,6 +898,14 @@
+     fi
+ fi
+ 
++# x11
++if test "$x11" = "yes"; then
++  echo "#define CONFIG_X11 1" >> $config_h
++  echo "CONFIG_X11=yes" >> $config_mak
++  echo "X11_LIBS=`pkg-config --libs x11 xext`" >> $config_mak
++  echo "X11_CFLAGS=`pkg-config --cflags x11 xext`" >> $config_mak
++fi
++
+ if test "$cocoa" = "yes" ; then
+     echo "#define CONFIG_COCOA 1" >> $config_h
+     echo "CONFIG_COCOA=yes" >> $config_mak
+diff -urN qemu-0.8.2/Makefile.target qemu-0.8.2-x/Makefile.target
+--- qemu-0.8.2/Makefile.target	2006-07-22 18:23:34.000000000 +0100
++++ qemu-0.8.2-x/Makefile.target	2006-08-23 14:47:17.000000000 +0100
+@@ -376,6 +376,9 @@
+ ifdef CONFIG_SDL
+ VL_OBJS+=sdl.o
+ endif
++ifdef CONFIG_X11
++VL_OBJS+=x.o
++endif
+ VL_OBJS+=vnc.o
+ ifdef CONFIG_COCOA
+ VL_OBJS+=cocoa.o
+@@ -426,7 +429,7 @@
+ endif
+ 
+ $(QEMU_SYSTEM): $(VL_OBJS) libqemu.a
+-	$(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(VL_LIBS)
++	$(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(X11_LIBS) $(COCOA_LIBS) $(VL_LIBS)
+ 
+ cocoa.o: cocoa.m
+ 	$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
+@@ -434,6 +437,10 @@
+ sdl.o: sdl.c keymaps.c sdl_keysym.h
+ 	$(CC) $(CFLAGS) $(DEFINES) $(SDL_CFLAGS) -c -o $@ $<
+ 
++x.o: x.c keymaps.c
++	$(CC) $(CFLAGS) $(DEFINES) $(X11_CFLAGS) -c -o $@ $<
++
++
+ vnc.o: vnc.c keymaps.c sdl_keysym.h vnchextile.h
+ 	$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
+ 
+diff -urN qemu-0.8.2/vl.c qemu-0.8.2-x/vl.c
+--- qemu-0.8.2/vl.c	2006-07-22 18:23:34.000000000 +0100
++++ qemu-0.8.2-x/vl.c	2006-09-29 18:58:26.000000000 +0100
+@@ -5217,6 +5217,9 @@
+ #ifdef USE_CODE_COPY
+            "-no-code-copy   disable code copy acceleration\n"
+ #endif
++#if defined(CONFIG_X11)
++	   "-parent xid    Use pre-existing window as qemu output window\n"
++#endif
+ #ifdef TARGET_I386
+            "-std-vga        simulate a standard VGA card with VESA Bochs Extensions\n"
+            "                (default is CL-GD5446 PCI VGA)\n"
+@@ -5302,6 +5305,8 @@
+     QEMU_OPTION_smp,
+     QEMU_OPTION_vnc,
+     QEMU_OPTION_no_acpi,
++
++    QEMU_OPTION_parent_xid,
+ };
+ 
+ typedef struct QEMUOption {
+@@ -5361,6 +5366,9 @@
+ #if defined(TARGET_PPC) || defined(TARGET_SPARC)
+     { "g", 1, QEMU_OPTION_g },
+ #endif
++#if defined(CONFIG_X11)
++    { "parent", HAS_ARG, QEMU_OPTION_parent_xid },
++#endif
+     { "localtime", 0, QEMU_OPTION_localtime },
+     { "std-vga", 0, QEMU_OPTION_std_vga },
+     { "monitor", 1, QEMU_OPTION_monitor },
+@@ -5608,6 +5616,10 @@
+     char usb_devices[MAX_USB_CMDLINE][128];
+     int usb_devices_index;
+ 
++#if defined(CONFIG_X11)
++    unsigned long parent_xid = 0;
++#endif
++
+     LIST_INIT (&vm_change_state_head);
+ #ifndef _WIN32
+     {
+@@ -6021,6 +6033,11 @@
+             case QEMU_OPTION_no_acpi:
+                 acpi_enabled = 0;
+                 break;
++#if defined(CONFIG_X11)
++	    case QEMU_OPTION_parent_xid:
++	      parent_xid = strtol(optarg, NULL, 0);
++	      break;
++#endif
+             }
+         }
+     }
+@@ -6142,6 +6159,8 @@
+         sdl_display_init(ds, full_screen);
+ #elif defined(CONFIG_COCOA)
+         cocoa_display_init(ds, full_screen);
++#elif defined(CONFIG_X11)
++        x_display_init(ds, full_screen, parent_xid);
+ #else
+         dumb_display_init(ds);
+ #endif
+diff -urN qemu-0.8.2/vl.h qemu-0.8.2-x/vl.h
+--- qemu-0.8.2/vl.h	2006-07-22 18:23:34.000000000 +0100
++++ qemu-0.8.2-x/vl.h	2006-09-29 18:35:32.000000000 +0100
+@@ -767,6 +767,9 @@
+ /* vnc.c */
+ void vnc_display_init(DisplayState *ds, int display);
+ 
++/* x.c */
++void x_display_init(DisplayState *ds, int display, unsigned long parent_xid);
++
+ /* ide.c */
+ #define MAX_DISKS 4
+ 
+diff -urN qemu-0.8.2/x.c qemu-0.8.2-x/x.c
+--- qemu-0.8.2/x.c	1970-01-01 01:00:00.000000000 +0100
++++ qemu-0.8.2-x/x.c	2006-09-29 18:35:02.000000000 +0100
+@@ -0,0 +1,451 @@
++#include "vl.h"
++
++#include <X11/Xlib.h>
++#include <X11/Xutil.h>
++#include <X11/Xatom.h>
++#include <X11/keysym.h>
++#include <X11/extensions/XShm.h>
++
++#include <sys/ipc.h>
++#include <sys/shm.h>
++
++typedef struct XHostScreen
++{
++  Display        *xdpy;
++  int             xscreen;
++  Visual         *xvisual;
++  Window          xwin, xwinroot;
++  GC              xgc;
++  int             xdepth;
++  XImage         *ximg;
++  int             xwin_width, xwin_height;
++  Bool            use_fullscreen;
++  Bool            have_shm;
++  unsigned char  *fb_data;   
++  unsigned long   cmap[256];
++  XShmSegmentInfo shminfo;
++}
++XHostScreen;
++
++static XHostScreen *xscreen;
++static int          trapped_error_code = 0;
++static int          (*old_error_handler) (Display *d, XErrorEvent *e);
++
++static void 
++x_update(DisplayState *ds, int x, int y, int w, int h);
++
++static int
++error_handler(Display     *display,
++              XErrorEvent *error)
++{
++  trapped_error_code = error->error_code;
++  return 0;
++}
++
++static void
++x_errors_trap(void)
++{
++  trapped_error_code = 0;
++  old_error_handler = XSetErrorHandler(error_handler);
++}
++
++static int
++x_errors_untrap(void)
++{
++  XSetErrorHandler(old_error_handler);
++  return trapped_error_code;
++}
++
++static void 
++x_update(DisplayState *ds, int x, int y, int w, int h)
++{
++  if (xscreen->have_shm)
++    {
++      XShmPutImage(xscreen->xdpy, xscreen->xwin, xscreen->xgc, xscreen->ximg, 
++		   x, y, x, y, w, h, False);
++    }
++  else
++    {
++      XPutImage(xscreen->xdpy, xscreen->xwin, xscreen->xgc, xscreen->ximg, 
++		x, y, x, y, w, h);
++    }
++
++  XSync(xscreen->xdpy, False);
++}
++
++static void 
++x_resize(DisplayState *ds, int w, int h)
++{
++  Bool        shm_success = False;
++  int         bitmap_pad;
++  XSizeHints *size_hints;
++
++  if (xscreen->ximg != NULL)
++    {
++      if (xscreen->have_shm)
++	{
++	  XShmDetach(xscreen->xdpy, &xscreen->shminfo);
++	  XDestroyImage (xscreen->ximg);
++	  shmdt(xscreen->shminfo.shmaddr);
++	  shmctl(xscreen->shminfo.shmid, IPC_RMID, 0);
++	}
++      else
++	{
++	  if (xscreen->ximg->data) 
++	    {
++	      free(xscreen->ximg->data);
++	      xscreen->ximg->data = NULL;
++	    } 
++
++	  XDestroyImage(xscreen->ximg);
++	}
++    }
++
++  if (xscreen->have_shm)
++    {
++      xscreen->ximg = XShmCreateImage(xscreen->xdpy, 
++				      xscreen->xvisual, 
++				      xscreen->xdepth, 
++				      ZPixmap, 
++				      NULL, 
++				      &xscreen->shminfo,
++				      w, h );
++      
++      xscreen->shminfo.shmid 
++	= shmget(IPC_PRIVATE,
++		 xscreen->ximg->bytes_per_line * h,
++		 IPC_CREAT|0777);
++      xscreen->shminfo.shmaddr = xscreen->ximg->data 
++	= shmat(xscreen->shminfo.shmid, 0, 0);
++
++      if (xscreen->ximg->data == (char *)-1)
++	{
++	  xscreen->have_shm = False;
++	  XDestroyImage(xscreen->ximg);
++	  shmctl(xscreen->shminfo.shmid, IPC_RMID, 0);
++	}
++      else
++	{
++	  xscreen->shminfo.readOnly = False;
++	  XShmAttach(xscreen->xdpy, &xscreen->shminfo);
++	  shm_success = True;
++	}
++    }
++
++  if (!shm_success)
++    {
++      bitmap_pad = ( xscreen->xdepth > 16 ) ? 
++	                    32 : (( xscreen->xdepth > 8 )? 16 : 8 );
++	  
++      xscreen->ximg = XCreateImage( xscreen->xdpy, 
++				    xscreen->xvisual, 
++				    xscreen->xdepth, 
++				    ZPixmap, 0, 0,
++				    w, 
++				    h, 
++				    bitmap_pad, 
++				    0);
++
++      xscreen->ximg->data 
++	 = malloc( xscreen->ximg->bytes_per_line * h );
++    }
++
++  XResizeWindow(xscreen->xdpy, xscreen->xwin, w, h);
++
++  /* Ask the WM to keep our size static */
++  size_hints = XAllocSizeHints();
++  size_hints->max_width = size_hints->min_width = w;
++  size_hints->max_height = size_hints->min_height = h;
++  size_hints->flags = PMinSize|PMaxSize;
++  XSetWMNormalHints(xscreen->xdpy, xscreen->xwin, size_hints);
++  XFree(size_hints);
++
++  XMapWindow(xscreen->xdpy, xscreen->xwin);
++
++  XSync(xscreen->xdpy, False);
++
++  xscreen->xwin_width  = w;
++  xscreen->xwin_height = h;
++
++  if (1) // (ds->depth == xscreen->xdepth)
++    {
++      ds->data = xscreen->ximg->data;
++    }
++  else
++    {
++      xscreen->fb_data = malloc(w*h*(ds->depth>>3));
++      ds->data = xscreen->fb_data;
++    }
++  
++  ds->linesize = xscreen->ximg->bytes_per_line;
++  ds->depth    = (xscreen->xdepth >= 24) ? 32 : xscreen->xdepth;
++  ds->bgr      = 0;
++
++#if 0
++    if (ds->depth == 32 && screen->format->Rshift == 0) {
++        ds->bgr = 1;
++    } else {
++        ds->bgr = 0;
++    }
++#endif
++
++    ds->width = w;
++    ds->height = h;
++
++}
++
++static void 
++x_refresh(DisplayState *ds)
++{
++  vga_hw_update();
++}
++
++static int 
++x_listen_poll(void *opaque)
++{
++  return XPending(xscreen->xdpy);
++}
++
++static void
++x_grab(void)
++{
++  static Bool grab = False;
++
++  if (!grab)
++    {
++      if (XGrabPointer (xscreen->xdpy, xscreen->xwin,
++			True, 
++			NoEventMask, 
++			GrabModeAsync, 
++			GrabModeAsync, 
++			xscreen->xwin, None, CurrentTime) == 0
++	  && XGrabKeyboard (xscreen->xdpy, xscreen->xwin, True, 
++			    GrabModeAsync, 
++			    GrabModeAsync, 
++			    CurrentTime) == 0)
++	{
++	  grab = True;
++	  XStoreName(xscreen->xdpy, xscreen->xwin, 
++		     "QEmu (ctrl+shift releases mouse and keyboard )");
++	}
++    }
++  else
++    {
++      XUngrabPointer (xscreen->xdpy, CurrentTime);
++      XUngrabKeyboard (xscreen->xdpy, CurrentTime);
++      grab = False;
++      XStoreName(xscreen->xdpy, xscreen->xwin, 
++		 "QEmu (ctrl+shift grabs mouse and keyboard )");
++    }
++}
++
++static void 
++x_listen_read(void *opaque)
++{
++  XEvent        xev;
++  DisplayState *ds = opaque;
++  Bool          grabbed = False;
++  static  int   last_x = 0, last_y = 0, button_state = 0, state;
++
++  if (XPending(xscreen->xdpy))
++    {
++      XNextEvent(xscreen->xdpy, &xev);
++
++      switch (xev.type) 
++	{
++	case EnterNotify:
++	case LeaveNotify:
++	  break;
++	case FocusIn:
++	  if (!kbd_mouse_is_absolute()) 
++	    x_grab();
++	  break;
++	case FocusOut:
++	  break;
++	case Expose:
++	  while (XCheckTypedWindowEvent(xscreen->xdpy, xev.xexpose.window, 
++					Expose, &xev));
++	  x_update(ds, 0, 0, 
++		   xscreen->xwin_width,
++		   xscreen->xwin_height);
++	  break;
++	case KeyRelease:
++	  if ((XKeycodeToKeysym(xscreen->xdpy,
++				xev.xkey.keycode,0) == XK_Shift_L
++	       || XKeycodeToKeysym(xscreen->xdpy,
++				   xev.xkey.keycode,0) == XK_Shift_R)
++	      && (xev.xkey.state & ControlMask))
++	    {
++	      x_grab();
++	      break;
++	    }
++	case KeyPress:
++	  {
++	    int keycode = xev.xkey.keycode-8; /* X adds 8 to keycode  */
++
++	    /* FIXME: LUT needed here me thinks */
++
++	    if (keycode & 0x80)  	      /* Extended */
++	      kbd_put_keycode(0xe0);
++	    
++	    if (xev.type == KeyPress)
++	      kbd_put_keycode(keycode & 0x7f);
++	    else
++	      kbd_put_keycode(keycode | 0x80);
++	  }
++	  break;
++	case ButtonPress:
++	case ButtonRelease:
++	case MotionNotify:
++	  {
++	    int ev_state, ev_x, ev_y, dx, dy;
++
++	    state = 0;
++
++	    if (xev.type == MotionNotify)
++	      {
++		ev_state = xev.xmotion.state;
++		ev_x     = xev.xmotion.x;
++		ev_y     = xev.xmotion.y;
++
++		if (ev_state & Button1Mask)
++		  state |= MOUSE_EVENT_LBUTTON;
++		if (ev_state & Button2Mask)
++		  state |= MOUSE_EVENT_RBUTTON;
++		if (ev_state & Button3Mask)
++		  state |= MOUSE_EVENT_MBUTTON;
++
++		/* Touchscreen dont send motion notifys */
++		if (kbd_mouse_is_absolute() && state == 0) 
++		  break;
++	      }
++	    else
++	      {
++		ev_state = xev.xbutton.state;
++		ev_x     = xev.xbutton.x;
++		ev_y     = xev.xbutton.y;
++
++		if (xev.type == ButtonPress) 
++		  {
++		    if (xev.xbutton.button == Button1)
++		      state |= MOUSE_EVENT_LBUTTON;
++		    if (xev.xbutton.state == Button1)
++		      state |= MOUSE_EVENT_RBUTTON;
++		    if (xev.xbutton.state & Button3)
++		      state |= MOUSE_EVENT_MBUTTON;
++		  }
++	      }
++
++	    if (kbd_mouse_is_absolute()) 
++	      {
++		dx = ev_x * 0x7FFF / xscreen->xwin_width;
++		dy = ev_y * 0x7FFF / xscreen->xwin_height;
++	      }
++	    else
++	      {
++		dx = ev_x - last_x;
++		dy = ev_y - last_y;
++	      }
++
++	    kbd_mouse_event(dx, dy, 0, state);
++	    
++	    last_x = ev_x;
++	    last_y = ev_y;
++	  }
++	  break;
++	default:
++	  break;
++
++	}
++    }
++  return;
++}
++
++void 
++x_display_init(DisplayState *ds, int full_screen, unsigned long parent_xid)
++{
++  Cursor                empty_cursor;
++  Pixmap                cursor_pxm;
++  XColor                col;
++  XSetWindowAttributes  attr;
++
++  xscreen = malloc(sizeof(XHostScreen));
++  memset(xscreen, 0, sizeof(XHostScreen));
++  
++  if ((xscreen->xdpy = XOpenDisplay(getenv("DISPLAY"))) == NULL)
++    {
++      fprintf(stderr, "\nqemu cannot open host display. Is DISPLAY set?\n");
++      exit(-1);
++    }
++  
++  xscreen->xscreen  = DefaultScreen(xscreen->xdpy);
++  xscreen->xwinroot = RootWindow(xscreen->xdpy, xscreen->xscreen);
++  xscreen->xgc      = XCreateGC(xscreen->xdpy, xscreen->xwinroot, 0, NULL);
++  xscreen->xdepth   = DefaultDepth(xscreen->xdpy, xscreen->xscreen);
++  xscreen->xvisual  = DefaultVisual(xscreen->xdpy, xscreen->xscreen); 
++  
++  attr.event_mask = ButtonPressMask|ButtonReleaseMask|PointerMotionMask
++                      |KeyPressMask|KeyReleaseMask|ExposureMask
++                      |FocusChangeMask|EnterWindowMask|LeaveWindowMask;
++  
++  xscreen->xwin = XCreateWindow(xscreen->xdpy,
++				xscreen->xwinroot,
++				0,0,640,480,
++				0,
++				CopyFromParent,
++				CopyFromParent,
++				CopyFromParent,
++				CWEventMask,
++				&attr);
++
++  xscreen->have_shm = True;
++
++  if (!XShmQueryExtension(xscreen->xdpy) || getenv("QEMU_X_NO_SHM")) 
++    {
++      xscreen->have_shm = False;
++    } 
++  else 		            
++    {	
++      XShmSegmentInfo shminfo; 
++
++      shminfo.shmid=shmget(IPC_PRIVATE, 1, IPC_CREAT|0777);
++      shminfo.shmaddr=shmat(shminfo.shmid,0,0);
++      shminfo.readOnly=True;
++
++      x_errors_trap();
++      
++      XShmAttach(xscreen->xdpy, &shminfo);
++      XSync(xscreen->xdpy, False);
++
++      if (x_errors_untrap())
++	{
++	  fprintf(stderr, "QEmu unable to use SHM XImages\n");
++	  xscreen->have_shm = False;
++	}
++
++      shmdt(shminfo.shmaddr);
++      shmctl(shminfo.shmid, IPC_RMID, 0);
++    }
++
++  if (!kbd_mouse_is_absolute()) 
++    {
++      /* Only hide cursor if were not a touchscreen */
++      cursor_pxm = XCreatePixmap (xscreen->xdpy, xscreen->xwinroot, 1, 1, 1);
++      memset (&col, 0, sizeof (col));
++      empty_cursor = XCreatePixmapCursor (xscreen->xdpy, 
++					  cursor_pxm, cursor_pxm, 
++					  &col, &col, 1, 1);
++      XDefineCursor (xscreen->xdpy, xscreen->xwin, empty_cursor);
++      XFreePixmap (xscreen->xdpy, cursor_pxm);
++    }
++
++  ds->dpy_update =  x_update;
++  ds->dpy_resize =  x_resize;
++  ds->dpy_refresh = x_refresh;
++
++  if ((qemu_set_fd_handler2 (ConnectionNumber(xscreen->xdpy), 
++			     x_listen_poll, x_listen_read, NULL, ds)) == -1)
++    exit(-1);
++
++  x_resize(ds, 640, 480);
++}
diff --git a/packages/qemu/qemu-0.8.0/.mtn2git_empty b/packages/qemu/qemu-0.8.0/.mtn2git_empty
deleted file mode 100644
index e69de29bb2..0000000000
--- a/packages/qemu/qemu-0.8.0/.mtn2git_empty
+++ /dev/null
diff --git a/packages/qemu/qemu-0.8.0/arm_nptl.patch b/packages/qemu/qemu-0.8.0/arm_nptl.patch
deleted file mode 100644
index daf105071c..0000000000
--- a/packages/qemu/qemu-0.8.0/arm_nptl.patch
+++ /dev/null
@@ -1,854 +0,0 @@
-diff -ur qemu-0.8.0.orig/configure qemu-0.8.0/configure
---- qemu-0.8.0.orig/configure	2005-12-20 00:51:53.000000000 +0200
-+++ qemu-0.8.0/configure	2006-07-12 15:26:40.000000000 +0300
-@@ -89,6 +89,7 @@
- cocoa="no"
- check_gfx="yes"
- check_gcc="yes"
-+nptl=yes
- 
- # OS specific
- targetos=`uname -s`
-@@ -205,6 +206,8 @@
-   ;;
-   --disable-gcc-check) check_gcc="no"
-   ;;
-+  --disable-nptl) nptl="no"
-+  ;;
-   esac
- done
- 
-@@ -299,6 +302,23 @@
-     fi
- fi
- 
-+# check NPTL support
-+cat > $TMPC <<EOF
-+#include <sched.h>
-+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
- 
-@@ -489,6 +509,7 @@
- fi
- echo ""
- echo "kqemu support     $kqemu"
-+echo "NPTL support      $nptl"
- if test $kqemu = "yes" -a $linux = "yes" ; then
- echo ""
- echo "KQEMU Linux module configuration:"
-@@ -793,6 +814,14 @@
-         fi
-         echo "" >> $config_mak
-     fi
-+else
-+    if test "$nptl" = "yes" ; then
-+        case "$target_cpu" in
-+          arm | armeb)
-+            echo "#define USE_NPTL 1" >> $config_h
-+          ;;
-+        esac
-+    fi
- fi
- 
- if test "$cocoa" = "yes" ; then
-Only in qemu-0.8.0: configure.rej~
-Only in qemu-0.8.0: configure~
-diff -ur qemu-0.8.0.orig/exec-all.h qemu-0.8.0/exec-all.h
---- qemu-0.8.0.orig/exec-all.h	2005-12-20 00:51:53.000000000 +0200
-+++ qemu-0.8.0/exec-all.h	2006-07-12 15:23:46.000000000 +0300
-@@ -347,163 +347,7 @@
- extern CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
- extern void *io_mem_opaque[IO_MEM_NB_ENTRIES];
- 
--#ifdef __powerpc__
--static inline int testandset (int *p)
--{
--    int ret;
--    __asm__ __volatile__ (
--                          "0:    lwarx %0,0,%1\n"
--                          "      xor. %0,%3,%0\n"
--                          "      bne 1f\n"
--                          "      stwcx. %2,0,%1\n"
--                          "      bne- 0b\n"
--                          "1:    "
--                          : "=&r" (ret)
--                          : "r" (p), "r" (1), "r" (0)
--                          : "cr0", "memory");
--    return ret;
--}
--#endif
--
--#ifdef __i386__
--static inline int testandset (int *p)
--{
--    long int readval = 0;
--    
--    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
--                          : "+m" (*p), "+a" (readval)
--                          : "r" (1)
--                          : "cc");
--    return readval;
--}
--#endif
--
--#ifdef __x86_64__
--static inline int testandset (int *p)
--{
--    long int readval = 0;
--    
--    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
--                          : "+m" (*p), "+a" (readval)
--                          : "r" (1)
--                          : "cc");
--    return readval;
--}
--#endif
--
--#ifdef __s390__
--static inline int testandset (int *p)
--{
--    int ret;
--
--    __asm__ __volatile__ ("0: cs    %0,%1,0(%2)\n"
--			  "   jl    0b"
--			  : "=&d" (ret)
--			  : "r" (1), "a" (p), "0" (*p) 
--			  : "cc", "memory" );
--    return ret;
--}
--#endif
--
--#ifdef __alpha__
--static inline int testandset (int *p)
--{
--    int ret;
--    unsigned long one;
--
--    __asm__ __volatile__ ("0:	mov 1,%2\n"
--			  "	ldl_l %0,%1\n"
--			  "	stl_c %2,%1\n"
--			  "	beq %2,1f\n"
--			  ".subsection 2\n"
--			  "1:	br 0b\n"
--			  ".previous"
--			  : "=r" (ret), "=m" (*p), "=r" (one)
--			  : "m" (*p));
--    return ret;
--}
--#endif
--
--#ifdef __sparc__
--static inline int testandset (int *p)
--{
--	int ret;
--
--	__asm__ __volatile__("ldstub	[%1], %0"
--			     : "=r" (ret)
--			     : "r" (p)
--			     : "memory");
--
--	return (ret ? 1 : 0);
--}
--#endif
--
--#ifdef __arm__
--static inline int testandset (int *spinlock)
--{
--    register unsigned int ret;
--    __asm__ __volatile__("swp %0, %1, [%2]"
--                         : "=r"(ret)
--                         : "0"(1), "r"(spinlock));
--    
--    return ret;
--}
--#endif
--
--#ifdef __mc68000
--static inline int testandset (int *p)
--{
--    char ret;
--    __asm__ __volatile__("tas %1; sne %0"
--                         : "=r" (ret)
--                         : "m" (p)
--                         : "cc","memory");
--    return ret;
--}
--#endif
--
--#ifdef __ia64
--#include <ia64intrin.h>
--
--static inline int testandset (int *p)
--{
--    return __sync_lock_test_and_set (p, 1);
--}
--#endif
--
--typedef int spinlock_t;
--
--#define SPIN_LOCK_UNLOCKED 0
--
--#if defined(CONFIG_USER_ONLY)
--static inline void spin_lock(spinlock_t *lock)
--{
--    while (testandset(lock));
--}
--
--static inline void spin_unlock(spinlock_t *lock)
--{
--    *lock = 0;
--}
--
--static inline int spin_trylock(spinlock_t *lock)
--{
--    return !testandset(lock);
--}
--#else
--static inline void spin_lock(spinlock_t *lock)
--{
--}
--
--static inline void spin_unlock(spinlock_t *lock)
--{
--}
--
--static inline int spin_trylock(spinlock_t *lock)
--{
--    return 1;
--}
--#endif
-+#include "qemu_spinlock.h"
- 
- extern spinlock_t tb_lock;
- 
-diff -ur qemu-0.8.0.orig/linux-user/arm/syscall.h qemu-0.8.0/linux-user/arm/syscall.h
---- qemu-0.8.0.orig/linux-user/arm/syscall.h	2005-12-20 00:51:53.000000000 +0200
-+++ qemu-0.8.0/linux-user/arm/syscall.h	2006-07-12 15:23:46.000000000 +0300
-@@ -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
-diff -ur qemu-0.8.0.orig/linux-user/main.c qemu-0.8.0/linux-user/main.c
---- qemu-0.8.0.orig/linux-user/main.c	2006-07-12 15:20:37.000000000 +0300
-+++ qemu-0.8.0/linux-user/main.c	2006-07-12 15:23:46.000000000 +0300
-@@ -326,6 +326,50 @@
-     }
- }
- 
-+/* Handle a jump to the kernel code page.  */
-+static int
-+do_kernel_trap(CPUARMState *env)
-+{
-+    uint32_t addr;
-+    uint32_t *ptr;
-+    uint32_t cpsr;
-+
-+    switch (env->regs[15]) {
-+    case 0xffff0fc0: /* __kernel_cmpxchg */
-+        /* XXX: This only works between threads, not between processes.
-+           Use native atomic operations.  */
-+        /* ??? This probably breaks horribly if the access segfaults.  */
-+        cpu_lock();
-+        ptr = (uint32_t *)env->regs[2];
-+        cpsr = cpsr_read(env);
-+        if (*ptr == env->regs[0]) {
-+            *ptr = env->regs[1];
-+            env->regs[0] = 0;
-+            cpsr |= CPSR_C;
-+        } else {
-+            env->regs[0] = -1;
-+            cpsr &= ~CPSR_C;
-+        }
-+        cpsr_write(env, cpsr, CPSR_C);
-+        cpu_unlock();
-+        break;
-+    case 0xffff0fe0: /* __kernel_get_tls */
-+        env->regs[0] = env->cp15.c13_tls;
-+        break;
-+    default:
-+        return 1;
-+    }
-+    /* Jump back to the caller.  */
-+    addr = env->regs[14];
-+    if (addr & 1) {
-+        env->thumb = 1;
-+        addr &= ~1;
-+    }
-+    env->regs[15] = addr;
-+
-+    return 0;
-+}
-+
- void cpu_loop(CPUARMState *env)
- {
-     int trapnr;
-@@ -368,10 +412,8 @@
-                     n = insn & 0xffffff;
-                 }
- 
--                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 >= ARM_SYSCALL_BASE
-                            || (env->thumb && n == ARM_THUMB_SYSCALL)) {
-@@ -381,14 +423,34 @@
-                     } else {
-                         n -= ARM_SYSCALL_BASE;
-                     }
--                    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;
-                 }
-@@ -427,6 +489,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", 
-@@ -1602,6 +1668,10 @@
-         ts->heap_base = info->brk;
-         /* This will be filled in on the first SYS_HEAPINFO call.  */
-         ts->heap_limit = 0;
-+        /* Register the magic kernel code page.  The cpu will generate a
-+           special exception when it tries to execute code here.  We can't
-+           put real code here because it may be in use by the host kernel.  */
-+        page_set_flags(0xffff0000, 0xffff0fff, 0);
-     }
- #elif defined(TARGET_SPARC)
-     {
-diff -ur qemu-0.8.0.orig/linux-user/qemu.h qemu-0.8.0/linux-user/qemu.h
---- qemu-0.8.0.orig/linux-user/qemu.h	2005-12-20 00:51:53.000000000 +0200
-+++ qemu-0.8.0/linux-user/qemu.h	2006-07-12 15:23:46.000000000 +0300
-@@ -76,6 +76,9 @@
-     uint32_t v86mask;
- #endif
-     int used; /* non zero if used */
-+#ifdef USE_NPTL
-+    uint32_t *child_tidptr;
-+#endif
-     uint8_t stack[0];
- } __attribute__((aligned(16))) TaskState;
- 
-Only in qemu-0.8.0.orig/linux-user: signal.c.orig
-diff -ur qemu-0.8.0.orig/linux-user/syscall.c qemu-0.8.0/linux-user/syscall.c
---- qemu-0.8.0.orig/linux-user/syscall.c	2006-07-12 15:20:37.000000000 +0300
-+++ qemu-0.8.0/linux-user/syscall.c	2006-07-12 15:36:51.000000000 +0300
-@@ -72,9 +72,18 @@
- #include <linux/kd.h>
- 
- #include "qemu.h"
-+#include "qemu_spinlock.h"
- 
- //#define DEBUG
- 
-+#ifdef USE_NPTL
-+#define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
-+    CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
-+#else
-+/* XXX: Hardcode the above values.  */
-+#define CLONE_NPTL_FLAGS2 0
-+#endif
-+
- #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC)
- /* 16 bit uid wrappers emulation */
- #define USE_UID16
-@@ -1527,20 +1536,38 @@
-    thread/process */
- #define NEW_STACK_SIZE 8192
- 
-+#ifdef USE_NPTL
-+static spinlock_t nptl_lock = SPIN_LOCK_UNLOCKED;
-+#endif
-+
- static int clone_func(void *arg)
- {
-     CPUState *env = arg;
-+#ifdef HAVE_NPTL
-+    /* Wait until the parent has finshed initializing the tls state.  */
-+    while (!spin_trylock(&nptl_lock))
-+        usleep(1);
-+    spin_unlock(&nptl_lock);
-+#endif
-     cpu_loop(env);
-     /* never exits */
-     return 0;
- }
- 
--int do_fork(CPUState *env, unsigned int flags, unsigned long newsp)
-+int do_fork(CPUState *env, unsigned int flags, unsigned long newsp,
-+            uint32_t *parent_tidptr, void *newtls,
-+            uint32_t *child_tidptr)
- {
-     int ret;
-     TaskState *ts;
-     uint8_t *new_stack;
-     CPUState *new_env;
-+#ifdef USE_NPTL
-+    unsigned int nptl_flags;
-+
-+    if (flags & CLONE_PARENT_SETTID)
-+        *parent_tidptr = gettid();
-+#endif
-     
-     if (flags & CLONE_VM) {
-         ts = malloc(sizeof(TaskState) + NEW_STACK_SIZE);
-@@ -1576,16 +1603,62 @@
- #error unsupported target CPU
- #endif
-         new_env->opaque = ts;
-+#ifdef USE_NPTL
-+        nptl_flags = flags;
-+        flags &= ~CLONE_NPTL_FLAGS2;
-+
-+        if (nptl_flags & CLONE_CHILD_CLEARTID) {
-+             ts->child_tidptr = child_tidptr;
-+        }
-+
-+        if (nptl_flags & CLONE_SETTLS)
-+            cpu_set_tls (new_env, newtls);
-+        /* Grab the global cpu lock so that the thread setup appears
-+           atomic.  */
-+        if (nptl_flags & CLONE_CHILD_SETTID)
-+            spin_lock(&nptl_lock);
-+#else
-+        if (flags & CLONE_NPTL_FLAGS2)
-+            return -EINVAL;
-+#endif
-+
- #ifdef __ia64__
-         ret = clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
- #else
- 	ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
- #endif
-+#ifdef USE_NPTL
-+        if (ret != -1) {
-+            if (nptl_flags & CLONE_CHILD_SETTID)
-+                *child_tidptr = ret;
-+        }
-+        /* Allow the child to continue.  */
-+        if (nptl_flags & CLONE_CHILD_SETTID)
-+            spin_unlock(&nptl_lock);
-+#endif
-     } else {
-         /* if no CLONE_VM, we consider it is a fork */
--        if ((flags & ~CSIGNAL) != 0)
-+	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;
- }
-@@ -1757,7 +1830,7 @@
-         ret = do_brk((char *)arg1);
-         break;
-     case TARGET_NR_fork:
--        ret = get_errno(do_fork(cpu_env, SIGCHLD, 0));
-+        ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, NULL, NULL, NULL));
-         break;
-     case TARGET_NR_waitpid:
-         {
-@@ -2564,7 +2637,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 */
-@@ -2925,7 +2999,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
-@@ -3347,4 +3422,3 @@
- #endif
-     return ret;
- }
--
-Only in qemu-0.8.0.orig/linux-user: syscall.c.orig
-Only in qemu-0.8.0/linux-user: syscall.c.rej~
-Only in qemu-0.8.0/linux-user: syscall.c~
-Only in qemu-0.8.0: qemu_spinlock.h
-diff -ur qemu-0.8.0.orig/target-arm/cpu.h qemu-0.8.0/target-arm/cpu.h
---- qemu-0.8.0.orig/target-arm/cpu.h	2005-12-20 00:51:53.000000000 +0200
-+++ qemu-0.8.0/target-arm/cpu.h	2006-07-12 15:27:28.000000000 +0300
-@@ -34,6 +34,9 @@
- #define EXCP_DATA_ABORT      4
- #define EXCP_IRQ             5
- #define EXCP_FIQ             6
-+#define EXCP_BKPT            7
-+#define EXCP_KERNEL_TRAP     8   /* Jumped to kernel code page.  */
-+
- 
- /* We currently assume float and double are IEEE single and double
-    precision respectively.
-@@ -83,6 +86,7 @@
-         uint32_t c9_data;
-         uint32_t c13_fcse; /* FCSE PID.  */
-         uint32_t c13_context; /* Context ID.  */
-+        uint32_t c13_tls; /* Paul Brook told me to just add this ;)  */
-     } cp15;
-     
-     /* exception/interrupt handling */
-@@ -126,6 +130,15 @@
- int cpu_arm_signal_handler(int host_signum, struct siginfo *info, 
-                            void *puc);
- 
-+void cpu_lock(void);
-+void cpu_unlock(void);
-+#if defined(USE_NPTL)
-+static inline void cpu_set_tls(CPUARMState *env, void *newtls)
-+{
-+  env->cp15.c13_tls = (uint32_t)newtls;
-+}
-+#endif
-+
- #define CPSR_M (0x1f)
- #define CPSR_T (1 << 5)
- #define CPSR_F (1 << 6)
-@@ -137,7 +150,11 @@
- #define CPSR_J (1 << 24)
- #define CPSR_IT_0_1 (3 << 25)
- #define CPSR_Q (1 << 27)
--#define CPSR_NZCV (0xf << 28)
-+#define CPSR_V (1 << 28)
-+#define CPSR_C (1 << 29)
-+#define CPSR_Z (1 << 30)
-+#define CPSR_N (1 << 31)
-+#define CPSR_NZCV (CPSR_N | CPSR_Z | CPSR_C | CPSR_V)
- 
- #define CACHED_CPSR_BITS (CPSR_T | CPSR_Q | CPSR_NZCV)
- /* Return the current CPSR value.  */
-Only in qemu-0.8.0/target-arm: cpu.h~
-diff -ur qemu-0.8.0.orig/target-arm/exec.h qemu-0.8.0/target-arm/exec.h
---- qemu-0.8.0.orig/target-arm/exec.h	2005-12-20 00:51:53.000000000 +0200
-+++ qemu-0.8.0/target-arm/exec.h	2006-07-12 15:23:46.000000000 +0300
-@@ -51,8 +51,6 @@
- 
- /* In op_helper.c */
- 
--void cpu_lock(void);
--void cpu_unlock(void);
- void helper_set_cp15(CPUState *, uint32_t, uint32_t);
- uint32_t helper_get_cp15(CPUState *, uint32_t);
- 
-diff -ur qemu-0.8.0.orig/target-arm/op.c qemu-0.8.0/target-arm/op.c
---- qemu-0.8.0.orig/target-arm/op.c	2005-12-20 00:51:53.000000000 +0200
-+++ qemu-0.8.0/target-arm/op.c	2006-07-12 15:23:46.000000000 +0300
-@@ -885,6 +885,12 @@
-     cpu_loop_exit();
- }
- 
-+void OPPROTO op_kernel_trap(void)
-+{
-+    env->exception_index = EXCP_KERNEL_TRAP;
-+    cpu_loop_exit();
-+}
-+
- /* VFP support.  We follow the convention used for VFP instrunctions:
-    Single precition routines have a "s" suffix, double precision a
-    "d" suffix.  */
-diff -ur qemu-0.8.0.orig/target-arm/translate.c qemu-0.8.0/target-arm/translate.c
---- qemu-0.8.0.orig/target-arm/translate.c	2005-12-20 00:51:53.000000000 +0200
-+++ qemu-0.8.0/target-arm/translate.c	2006-07-12 15:23:46.000000000 +0300
-@@ -2282,6 +2282,7 @@
-     s->is_jmp = DISAS_JUMP;
- }
- 
-+
- /* generate intermediate code in gen_opc_buf and gen_opparam_buf for
-    basic block 'tb'. If search_pc is TRUE, also generate PC
-    information for each intermediate instruction. */
-@@ -2316,6 +2317,15 @@
-     nb_gen_labels = 0;
-     lj = -1;
-     do {
-+#ifdef CONFIG_USER_ONLY
-+        /* Intercept jump to the magic kernel page.  */
-+        if (dc->pc > 0xffff0000) {
-+            gen_op_kernel_trap();
-+            dc->is_jmp = DISAS_UPDATE;
-+            break;
-+        }
-+#endif
-+
-         if (env->nb_breakpoints > 0) {
-             for(j = 0; j < env->nb_breakpoints; j++) {
-                 if (env->breakpoints[j] == dc->pc) {
-diff -urN qemu-0.8.1.orig/qemu_spinlock.h qemu-0.8.1/qemu_spinlock.h
---- qemu-0.8.1.orig/qemu_spinlock.h     1970-01-01 02:00:00.000000000 +0200
-+++ qemu-0.8.1/qemu_spinlock.h  2006-06-04 00:59:23.000000000 +0300
-@@ -0,0 +1,182 @@
-+/*
-+ * internal execution defines for qemu
-+ *
-+ *  Copyright (c) 2003 Fabrice Bellard
-+ *
-+ * This library is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU Lesser General Public
-+ * License as published by the Free Software Foundation; either
-+ * version 2 of the License, or (at your option) any later version.
-+ *
-+ * This library is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * Lesser General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU Lesser General Public
-+ * License along with this library; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-+ */
-+
-+#ifndef _QEMU_SPINLOCK_H
-+#define _QEMU_SPINLOCK_H
-+
-+#ifdef __powerpc__
-+static inline int testandset (int *p)
-+{
-+    int ret;
-+    __asm__ __volatile__ (
-+                          "0:    lwarx %0,0,%1\n"
-+                          "      xor. %0,%3,%0\n"
-+                          "      bne 1f\n"
-+                          "      stwcx. %2,0,%1\n"
-+                          "      bne- 0b\n"
-+                          "1:    "
-+                          : "=&r" (ret)
-+                          : "r" (p), "r" (1), "r" (0)
-+                          : "cr0", "memory");
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __i386__
-+static inline int testandset (int *p)
-+{
-+    long int readval = 0;
-+
-+    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
-+                          : "+m" (*p), "+a" (readval)
-+                          : "r" (1)
-+                          : "cc");
-+    return readval;
-+}
-+#endif
-+
-+#ifdef __x86_64__
-+static inline int testandset (int *p)
-+{
-+    long int readval = 0;
-+
-+    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
-+                          : "+m" (*p), "+a" (readval)
-+                          : "r" (1)
-+                          : "cc");
-+    return readval;
-+}
-+#endif
-+
-+#ifdef __s390__
-+static inline int testandset (int *p)
-+{
-+    int ret;
-+
-+    __asm__ __volatile__ ("0: cs    %0,%1,0(%2)\n"
-+                         "   jl    0b"
-+                         : "=&d" (ret)
-+                         : "r" (1), "a" (p), "0" (*p)
-+                         : "cc", "memory" );
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __alpha__
-+static inline int testandset (int *p)
-+{
-+    int ret;
-+    unsigned long one;
-+
-+    __asm__ __volatile__ ("0:  mov 1,%2\n"
-+                         "     ldl_l %0,%1\n"
-+                         "     stl_c %2,%1\n"
-+                         "     beq %2,1f\n"
-+                         ".subsection 2\n"
-+                         "1:   br 0b\n"
-+                         ".previous"
-+                         : "=r" (ret), "=m" (*p), "=r" (one)
-+                         : "m" (*p));
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __sparc__
-+static inline int testandset (int *p)
-+{
-+       int ret;
-+
-+       __asm__ __volatile__("ldstub    [%1], %0"
-+                            : "=r" (ret)
-+                            : "r" (p)
-+                            : "memory");
-+
-+       return (ret ? 1 : 0);
-+}
-+#endif
-+
-+#ifdef __arm__
-+static inline int testandset (int *spinlock)
-+{
-+    register unsigned int ret;
-+    __asm__ __volatile__("swp %0, %1, [%2]"
-+                         : "=r"(ret)
-+                         : "0"(1), "r"(spinlock));
-+
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __mc68000
-+static inline int testandset (int *p)
-+{
-+    char ret;
-+    __asm__ __volatile__("tas %1; sne %0"
-+                         : "=r" (ret)
-+                         : "m" (p)
-+                         : "cc","memory");
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __ia64
-+#include <ia64intrin.h>
-+
-+static inline int testandset (int *p)
-+{
-+    return __sync_lock_test_and_set (p, 1);
-+}
-+#endif
-+
-+typedef int spinlock_t;
-+
-+#define SPIN_LOCK_UNLOCKED 0
-+
-+#if defined(CONFIG_USER_ONLY)
-+static inline void spin_lock(spinlock_t *lock)
-+{
-+    while (testandset(lock));
-+}
-+
-+static inline void spin_unlock(spinlock_t *lock)
-+{
-+    *lock = 0;
-+}
-+
-+static inline int spin_trylock(spinlock_t *lock)
-+{
-+    return !testandset(lock);
-+}
-+#else
-+static inline void spin_lock(spinlock_t *lock)
-+{
-+}
-+
-+static inline void spin_unlock(spinlock_t *lock)
-+{
-+}
-+
-+static inline int spin_trylock(spinlock_t *lock)
-+{
-+    return 1;
-+}
-+#endif
-+
-+#endif /* ! _QEMU_SPINLOCK_H */
-
diff --git a/packages/qemu/qemu-0.8.2/.mtn2git_empty b/packages/qemu/qemu-0.8.2/.mtn2git_empty
deleted file mode 100644
index e69de29bb2..0000000000
--- a/packages/qemu/qemu-0.8.2/.mtn2git_empty
+++ /dev/null
diff --git a/packages/qemu/qemu-0.8.2/arm_nptl.patch b/packages/qemu/qemu-0.8.2/arm_nptl.patch
deleted file mode 100644
index f9b10aebc5..0000000000
--- a/packages/qemu/qemu-0.8.2/arm_nptl.patch
+++ /dev/null
@@ -1,857 +0,0 @@
-Index: qemu/configure
-===================================================================
---- qemu.orig/configure	2006-08-26 16:31:53.000000000 +0100
-+++ qemu/configure	2006-08-26 16:31:53.000000000 +0100
-@@ -97,6 +97,7 @@
- build_docs="no"
- build_acpi_tables="no"
- uname_release=""
-+nptl="yes"
- 
- # OS specific
- targetos=`uname -s`
-@@ -243,6 +244,8 @@
-   ;;
-   --enable-iasl) build_acpi_tables="yes"
-   ;;
-+  --disable-nptl) nptl="no"
-+  ;;
-   esac
- done
- 
-@@ -441,6 +444,23 @@
-     fi
- fi
- 
-+# check NPTL support
-+cat > $TMPC <<EOF
-+#include <sched.h>
-+void foo()
-+{
-+#ifndef CLONE_SETTLS
-+#error bork
-+#endif
-+}
-+EOF
-+
-+if $cc -c -o $TMPO $TMPC 2> /dev/null ; then
-+  :
-+else
-+   nptl="no"
-+fi
-+
- ##########################################
- # SDL probe
- 
-@@ -559,6 +579,7 @@
- fi
- echo "FMOD support      $fmod $fmod_support"
- echo "kqemu support     $kqemu"
-+echo "NPTL support      $nptl"
- echo "Documentation     $build_docs"
- [ ! -z "$uname_release" ] && \
- echo "uname -r          $uname_release"
-@@ -880,6 +901,14 @@
-             echo "SDL_CFLAGS=`$sdl_config --cflags`" >> $config_mak
-         fi
-     fi
-+else
-+    if test "$nptl" = "yes" ; then
-+        case "$target_cpu" in
-+          arm | armeb)
-+            echo "#define USE_NPTL 1" >> $config_h
-+          ;;
-+        esac
-+    fi
- fi
- 
- if test "$cocoa" = "yes" ; then
-Index: qemu/exec-all.h
-===================================================================
---- qemu.orig/exec-all.h	2006-08-26 16:28:32.000000000 +0100
-+++ qemu/exec-all.h	2006-08-26 16:31:53.000000000 +0100
-@@ -347,163 +347,7 @@
- extern CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
- extern void *io_mem_opaque[IO_MEM_NB_ENTRIES];
- 
--#ifdef __powerpc__
--static inline int testandset (int *p)
--{
--    int ret;
--    __asm__ __volatile__ (
--                          "0:    lwarx %0,0,%1\n"
--                          "      xor. %0,%3,%0\n"
--                          "      bne 1f\n"
--                          "      stwcx. %2,0,%1\n"
--                          "      bne- 0b\n"
--                          "1:    "
--                          : "=&r" (ret)
--                          : "r" (p), "r" (1), "r" (0)
--                          : "cr0", "memory");
--    return ret;
--}
--#endif
--
--#ifdef __i386__
--static inline int testandset (int *p)
--{
--    long int readval = 0;
--    
--    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
--                          : "+m" (*p), "+a" (readval)
--                          : "r" (1)
--                          : "cc");
--    return readval;
--}
--#endif
--
--#ifdef __x86_64__
--static inline int testandset (int *p)
--{
--    long int readval = 0;
--    
--    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
--                          : "+m" (*p), "+a" (readval)
--                          : "r" (1)
--                          : "cc");
--    return readval;
--}
--#endif
--
--#ifdef __s390__
--static inline int testandset (int *p)
--{
--    int ret;
--
--    __asm__ __volatile__ ("0: cs    %0,%1,0(%2)\n"
--			  "   jl    0b"
--			  : "=&d" (ret)
--			  : "r" (1), "a" (p), "0" (*p) 
--			  : "cc", "memory" );
--    return ret;
--}
--#endif
--
--#ifdef __alpha__
--static inline int testandset (int *p)
--{
--    int ret;
--    unsigned long one;
--
--    __asm__ __volatile__ ("0:	mov 1,%2\n"
--			  "	ldl_l %0,%1\n"
--			  "	stl_c %2,%1\n"
--			  "	beq %2,1f\n"
--			  ".subsection 2\n"
--			  "1:	br 0b\n"
--			  ".previous"
--			  : "=r" (ret), "=m" (*p), "=r" (one)
--			  : "m" (*p));
--    return ret;
--}
--#endif
--
--#ifdef __sparc__
--static inline int testandset (int *p)
--{
--	int ret;
--
--	__asm__ __volatile__("ldstub	[%1], %0"
--			     : "=r" (ret)
--			     : "r" (p)
--			     : "memory");
--
--	return (ret ? 1 : 0);
--}
--#endif
--
--#ifdef __arm__
--static inline int testandset (int *spinlock)
--{
--    register unsigned int ret;
--    __asm__ __volatile__("swp %0, %1, [%2]"
--                         : "=r"(ret)
--                         : "0"(1), "r"(spinlock));
--    
--    return ret;
--}
--#endif
--
--#ifdef __mc68000
--static inline int testandset (int *p)
--{
--    char ret;
--    __asm__ __volatile__("tas %1; sne %0"
--                         : "=r" (ret)
--                         : "m" (p)
--                         : "cc","memory");
--    return ret;
--}
--#endif
--
--#ifdef __ia64
--#include <ia64intrin.h>
--
--static inline int testandset (int *p)
--{
--    return __sync_lock_test_and_set (p, 1);
--}
--#endif
--
--typedef int spinlock_t;
--
--#define SPIN_LOCK_UNLOCKED 0
--
--#if defined(CONFIG_USER_ONLY)
--static inline void spin_lock(spinlock_t *lock)
--{
--    while (testandset(lock));
--}
--
--static inline void spin_unlock(spinlock_t *lock)
--{
--    *lock = 0;
--}
--
--static inline int spin_trylock(spinlock_t *lock)
--{
--    return !testandset(lock);
--}
--#else
--static inline void spin_lock(spinlock_t *lock)
--{
--}
--
--static inline void spin_unlock(spinlock_t *lock)
--{
--}
--
--static inline int spin_trylock(spinlock_t *lock)
--{
--    return 1;
--}
--#endif
-+#include "qemu_spinlock.h"
- 
- extern spinlock_t tb_lock;
- 
-Index: qemu/linux-user/arm/syscall.h
-===================================================================
---- qemu.orig/linux-user/arm/syscall.h	2006-03-09 19:18:11.000000000 +0000
-+++ qemu/linux-user/arm/syscall.h	2006-08-26 16:31:53.000000000 +0100
-@@ -28,7 +28,9 @@
- #define ARM_SYSCALL_BASE	0x900000
- #define ARM_THUMB_SYSCALL	0
- 
--#define ARM_NR_cacheflush (ARM_SYSCALL_BASE + 0xf0000 + 2)
-+#define ARM_NR_BASE	  0xf0000
-+#define ARM_NR_cacheflush (ARM_NR_BASE + 2)
-+#define ARM_NR_set_tls	  (ARM_NR_BASE + 5)
- 
- #define ARM_NR_semihosting	  0x123456
- #define ARM_NR_thumb_semihosting  0xAB
-Index: qemu/linux-user/main.c
-===================================================================
---- qemu.orig/linux-user/main.c	2006-08-26 16:28:40.000000000 +0100
-+++ qemu/linux-user/main.c	2006-08-26 16:31:53.000000000 +0100
-@@ -309,6 +309,50 @@
-     }
- }
- 
-+/* Handle a jump to the kernel code page.  */
-+static int
-+do_kernel_trap(CPUARMState *env)
-+{
-+    uint32_t addr;
-+    uint32_t *ptr;
-+    uint32_t cpsr;
-+
-+    switch (env->regs[15]) {
-+    case 0xffff0fc0: /* __kernel_cmpxchg */
-+        /* XXX: This only works between threads, not between processes.
-+           Use native atomic operations.  */
-+        /* ??? This probably breaks horribly if the access segfaults.  */
-+        cpu_lock();
-+        ptr = (uint32_t *)env->regs[2];
-+        cpsr = cpsr_read(env);
-+        if (*ptr == env->regs[0]) {
-+            *ptr = env->regs[1];
-+            env->regs[0] = 0;
-+            cpsr |= CPSR_C;
-+        } else {
-+            env->regs[0] = -1;
-+            cpsr &= ~CPSR_C;
-+        }
-+        cpsr_write(env, cpsr, CPSR_C);
-+        cpu_unlock();
-+        break;
-+    case 0xffff0fe0: /* __kernel_get_tls */
-+        env->regs[0] = env->cp15.c13_tls;
-+        break;
-+    default:
-+        return 1;
-+    }
-+    /* Jump back to the caller.  */
-+    addr = env->regs[14];
-+    if (addr & 1) {
-+        env->thumb = 1;
-+        addr &= ~1;
-+    }
-+    env->regs[15] = addr;
-+
-+    return 0;
-+}
-+
- void cpu_loop(CPUARMState *env)
- {
-     int trapnr;
-@@ -365,10 +409,8 @@
-                     }
-                 }
- 
--                if (n == ARM_NR_cacheflush) {
--                    arm_cache_flush(env->regs[0], env->regs[1]);
--                } else if (n == ARM_NR_semihosting
--                           || n == ARM_NR_thumb_semihosting) {
-+                if (n == ARM_NR_semihosting
-+                    || n == ARM_NR_thumb_semihosting) {
-                     env->regs[0] = do_arm_semihosting (env);
-                 } else if (n == 0 || n >= ARM_SYSCALL_BASE
-                            || (env->thumb && n == ARM_THUMB_SYSCALL)) {
-@@ -379,14 +421,34 @@
-                         n -= ARM_SYSCALL_BASE;
-                         env->eabi = 0;
-                     }
--                    env->regs[0] = do_syscall(env, 
--                                              n, 
--                                              env->regs[0],
--                                              env->regs[1],
--                                              env->regs[2],
--                                              env->regs[3],
--                                              env->regs[4],
--                                              env->regs[5]);
-+                    if ( n > ARM_NR_BASE) {
-+                        switch (n)
-+                          {
-+                          case ARM_NR_cacheflush:
-+                              arm_cache_flush(env->regs[0], env->regs[1]);
-+                              break;
-+#ifdef USE_NPTL
-+                          case ARM_NR_set_tls:
-+                              cpu_set_tls(env, env->regs[0]);
-+                              env->regs[0] = 0;
-+                              break;
-+#endif
-+                          default:
-+                              printf ("Error: Bad syscall: %x\n", n);
-+                              goto error;
-+                          }
-+                      }
-+                    else
-+                      {
-+                        env->regs[0] = do_syscall(env, 
-+                                                  n, 
-+                                                  env->regs[0],
-+                                                  env->regs[1],
-+                                                  env->regs[2],
-+                                                  env->regs[3],
-+                                                  env->regs[4],
-+                                                  env->regs[5]);
-+                      }
-                 } else {
-                     goto error;
-                 }
-@@ -425,6 +487,10 @@
-                   }
-             }
-             break;
-+        case EXCP_KERNEL_TRAP:
-+            if (do_kernel_trap(env))
-+              goto error;
-+            break;
-         default:
-         error:
-             fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", 
-@@ -1639,6 +1705,10 @@
-         ts->heap_base = info->brk;
-         /* This will be filled in on the first SYS_HEAPINFO call.  */
-         ts->heap_limit = 0;
-+        /* Register the magic kernel code page.  The cpu will generate a
-+           special exception when it tries to execute code here.  We can't
-+           put real code here because it may be in use by the host kernel.  */
-+        page_set_flags(0xffff0000, 0xffff0fff, 0);
-     }
- #elif defined(TARGET_SPARC)
-     {
-Index: qemu/linux-user/qemu.h
-===================================================================
---- qemu.orig/linux-user/qemu.h	2006-08-26 16:28:40.000000000 +0100
-+++ qemu/linux-user/qemu.h	2006-08-26 16:33:50.000000000 +0100
-@@ -75,6 +75,9 @@
-     uint32_t v86mask;
- #endif
-     int used; /* non zero if used */
-+#ifdef USE_NPTL
-+    uint32_t *child_tidptr;
-+#endif
-     struct image_info *info;
-     uint8_t stack[0];
- } __attribute__((aligned(16))) TaskState;
-Index: qemu/linux-user/syscall.c
-===================================================================
---- qemu.orig/linux-user/syscall.c	2006-08-26 16:28:40.000000000 +0100
-+++ qemu/linux-user/syscall.c	2006-08-26 16:31:53.000000000 +0100
-@@ -66,9 +66,18 @@
- #include <linux/kd.h>
- 
- #include "qemu.h"
-+#include "qemu_spinlock.h"
- 
- //#define DEBUG
- 
-+#ifdef USE_NPTL
-+#define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
-+    CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
-+#else
-+/* XXX: Hardcode the above values.  */
-+#define CLONE_NPTL_FLAGS2 0
-+#endif
-+
- #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC)
- /* 16 bit uid wrappers emulation */
- #define USE_UID16
-@@ -1602,20 +1611,38 @@
-    thread/process */
- #define NEW_STACK_SIZE 8192
- 
-+#ifdef USE_NPTL
-+static spinlock_t nptl_lock = SPIN_LOCK_UNLOCKED;
-+#endif
-+
- static int clone_func(void *arg)
- {
-     CPUState *env = arg;
-+#ifdef HAVE_NPTL
-+    /* Wait until the parent has finshed initializing the tls state.  */
-+    while (!spin_trylock(&nptl_lock))
-+        usleep(1);
-+    spin_unlock(&nptl_lock);
-+#endif
-     cpu_loop(env);
-     /* never exits */
-     return 0;
- }
- 
--int do_fork(CPUState *env, unsigned int flags, unsigned long newsp)
-+int do_fork(CPUState *env, unsigned int flags, unsigned long newsp,
-+            uint32_t *parent_tidptr, void *newtls,
-+            uint32_t *child_tidptr)
- {
-     int ret;
-     TaskState *ts;
-     uint8_t *new_stack;
-     CPUState *new_env;
-+#ifdef USE_NPTL
-+    unsigned int nptl_flags;
-+
-+    if (flags & CLONE_PARENT_SETTID)
-+        *parent_tidptr = gettid();
-+#endif
-     
-     if (flags & CLONE_VM) {
-         ts = malloc(sizeof(TaskState) + NEW_STACK_SIZE);
-@@ -1665,16 +1692,60 @@
- #error unsupported target CPU
- #endif
-         new_env->opaque = ts;
-+#ifdef USE_NPTL
-+     nptl_flags = flags;
-+     flags &= ~CLONE_NPTL_FLAGS2;
-+     if (nptl_flags & CLONE_CHILD_CLEARTID) {
-+          ts->child_tidptr = child_tidptr;
-+     }
-+     if (nptl_flags & CLONE_SETTLS)
-+         cpu_set_tls (new_env, newtls);
-+     /* Grab the global cpu lock so that the thread setup appears
-+        atomic.  */
-+     if (nptl_flags & CLONE_CHILD_SETTID)
-+         spin_lock(&nptl_lock);
-+#else
-+     if (flags & CLONE_NPTL_FLAGS2)
-+         return -EINVAL;
-+#endif
-+
- #ifdef __ia64__
-         ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
- #else
- 	ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
- #endif
-+#ifdef USE_NPTL
-+     if (ret != -1) {
-+         if (nptl_flags & CLONE_CHILD_SETTID)
-+             *child_tidptr = ret;
-+     }
-+     /* Allow the child to continue.  */
-+     if (nptl_flags & CLONE_CHILD_SETTID)
-+         spin_unlock(&nptl_lock);
-+#endif
-     } else {
--        /* if no CLONE_VM, we consider it is a fork */
--        if ((flags & ~CSIGNAL) != 0)
--            return -EINVAL;
--        ret = fork();
-+    /* if no CLONE_VM, we consider it is a fork */
-+    if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0)
-+          return -EINVAL;
-+      ret = fork();
-+#ifdef USE_NPTL
-+     /* There is a race condition here.  The parent process could
-+        theoretically read the TID in the child process before the child
-+        tid is set.  This would require using either ptrace
-+        (not implemented) or having *_tidptr to point at a shared memory
-+        mapping.  We can't repeat the spinlock hack used above because
-+        the child process gets its own copy of the lock.  */
-+     if (ret == 0) {
-+         /* Child Process.  */
-+         if (flags & CLONE_CHILD_SETTID)
-+             *child_tidptr = gettid();
-+         ts = (TaskState *)env->opaque;
-+         if (flags & CLONE_CHILD_CLEARTID)
-+             ts->child_tidptr = child_tidptr;
-+         if (flags & CLONE_SETTLS)
-+             cpu_set_tls (env, newtls);
-+     }
-+#endif
-     }
-     return ret;
- }
-@@ -1918,7 +1989,7 @@
-         ret = do_brk(arg1);
-         break;
-     case TARGET_NR_fork:
--        ret = get_errno(do_fork(cpu_env, SIGCHLD, 0));
-+        ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, NULL, NULL, NULL));
-         break;
-     case TARGET_NR_waitpid:
-         {
-@@ -2989,7 +3060,8 @@
-         ret = get_errno(fsync(arg1));
-         break;
-     case TARGET_NR_clone:
--        ret = get_errno(do_fork(cpu_env, arg1, arg2));
-+        ret = get_errno(do_fork(cpu_env, arg1, arg2, (uint32_t *)arg3,
-+                        (void *)arg4, (uint32_t *)arg5));
-         break;
- #ifdef __NR_exit_group
-         /* new thread calls */
-@@ -3339,7 +3411,8 @@
- #endif
- #ifdef TARGET_NR_vfork
-     case TARGET_NR_vfork:
--        ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0));
-+        ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
-+                                NULL, NULL, NULL));
-         break;
- #endif
- #ifdef TARGET_NR_ugetrlimit
-@@ -3838,4 +3911,3 @@
- #endif
-     return ret;
- }
--
-Index: qemu/target-arm/cpu.h
-===================================================================
---- qemu.orig/target-arm/cpu.h	2006-03-09 19:18:27.000000000 +0000
-+++ qemu/target-arm/cpu.h	2006-08-26 16:31:53.000000000 +0100
-@@ -35,6 +35,9 @@
- #define EXCP_IRQ             5
- #define EXCP_FIQ             6
- #define EXCP_BKPT            7
-+#define EXCP_KERNEL_TRAP     8   /* Jumped to kernel code page.  */
-+
-+
- 
- /* We currently assume float and double are IEEE single and double
-    precision respectively.
-@@ -85,6 +88,7 @@
-         uint32_t c9_data;
-         uint32_t c13_fcse; /* FCSE PID.  */
-         uint32_t c13_context; /* Context ID.  */
-+        uint32_t c13_tls; /* Paul Brook told me to just add this ;)  */
-     } cp15;
- 
-     /* Internal CPU feature flags.  */
-@@ -135,6 +139,15 @@
- int cpu_arm_signal_handler(int host_signum, struct siginfo *info, 
-                            void *puc);
- 
-+void cpu_lock(void);
-+void cpu_unlock(void);
-+#if defined(USE_NPTL)
-+static inline void cpu_set_tls(CPUARMState *env, void *newtls)
-+{
-+  env->cp15.c13_tls = (uint32_t)newtls;
-+}
-+#endif
-+
- #define CPSR_M (0x1f)
- #define CPSR_T (1 << 5)
- #define CPSR_F (1 << 6)
-@@ -146,7 +159,11 @@
- #define CPSR_J (1 << 24)
- #define CPSR_IT_0_1 (3 << 25)
- #define CPSR_Q (1 << 27)
--#define CPSR_NZCV (0xf << 28)
-+#define CPSR_V (1 << 28)
-+#define CPSR_C (1 << 29)
-+#define CPSR_Z (1 << 30)
-+#define CPSR_N (1 << 31)
-+#define CPSR_NZCV (CPSR_N | CPSR_Z | CPSR_C | CPSR_V)
- 
- #define CACHED_CPSR_BITS (CPSR_T | CPSR_Q | CPSR_NZCV)
- /* Return the current CPSR value.  */
-Index: qemu/target-arm/exec.h
-===================================================================
---- qemu.orig/target-arm/exec.h	2006-03-09 19:18:27.000000000 +0000
-+++ qemu/target-arm/exec.h	2006-08-26 16:31:53.000000000 +0100
-@@ -51,8 +51,6 @@
- 
- /* In op_helper.c */
- 
--void cpu_lock(void);
--void cpu_unlock(void);
- void helper_set_cp15(CPUState *, uint32_t, uint32_t);
- uint32_t helper_get_cp15(CPUState *, uint32_t);
- 
-Index: qemu/target-arm/op.c
-===================================================================
---- qemu.orig/target-arm/op.c	2006-08-26 16:28:48.000000000 +0100
-+++ qemu/target-arm/op.c	2006-08-26 16:31:53.000000000 +0100
-@@ -891,6 +891,12 @@
-     cpu_loop_exit();
- }
- 
-+void OPPROTO op_kernel_trap(void)
-+{
-+    env->exception_index = EXCP_KERNEL_TRAP;
-+    cpu_loop_exit();
-+}
-+
- /* VFP support.  We follow the convention used for VFP instrunctions:
-    Single precition routines have a "s" suffix, double precision a
-    "d" suffix.  */
-Index: qemu/target-arm/translate.c
-===================================================================
---- qemu.orig/target-arm/translate.c	2006-08-26 16:28:48.000000000 +0100
-+++ qemu/target-arm/translate.c	2006-08-26 16:31:53.000000000 +0100
-@@ -2382,6 +2382,7 @@
-     s->is_jmp = DISAS_JUMP;
- }
- 
-+
- /* generate intermediate code in gen_opc_buf and gen_opparam_buf for
-    basic block 'tb'. If search_pc is TRUE, also generate PC
-    information for each intermediate instruction. */
-@@ -2416,6 +2417,15 @@
-     nb_gen_labels = 0;
-     lj = -1;
-     do {
-+#ifdef CONFIG_USER_ONLY
-+        /* Intercept jump to the magic kernel page.  */
-+        if (dc->pc > 0xffff0000) {
-+            gen_op_kernel_trap();
-+            dc->is_jmp = DISAS_UPDATE;
-+            break;
-+        }
-+#endif
-+
-         if (env->nb_breakpoints > 0) {
-             for(j = 0; j < env->nb_breakpoints; j++) {
-                 if (env->breakpoints[j] == dc->pc) {
-Index: qemu/qemu_spinlock.h
-===================================================================
---- /dev/null	1970-01-01 00:00:00.000000000 +0000
-+++ qemu/qemu_spinlock.h	2006-08-26 16:31:53.000000000 +0100
-@@ -0,0 +1,182 @@
-+/*
-+ * internal execution defines for qemu
-+ *
-+ *  Copyright (c) 2003 Fabrice Bellard
-+ *
-+ * This library is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU Lesser General Public
-+ * License as published by the Free Software Foundation; either
-+ * version 2 of the License, or (at your option) any later version.
-+ *
-+ * This library is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * Lesser General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU Lesser General Public
-+ * License along with this library; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-+ */
-+
-+#ifndef _QEMU_SPINLOCK_H
-+#define _QEMU_SPINLOCK_H
-+
-+#ifdef __powerpc__
-+static inline int testandset (int *p)
-+{
-+    int ret;
-+    __asm__ __volatile__ (
-+                          "0:    lwarx %0,0,%1\n"
-+                          "      xor. %0,%3,%0\n"
-+                          "      bne 1f\n"
-+                          "      stwcx. %2,0,%1\n"
-+                          "      bne- 0b\n"
-+                          "1:    "
-+                          : "=&r" (ret)
-+                          : "r" (p), "r" (1), "r" (0)
-+                          : "cr0", "memory");
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __i386__
-+static inline int testandset (int *p)
-+{
-+    long int readval = 0;
-+
-+    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
-+                          : "+m" (*p), "+a" (readval)
-+                          : "r" (1)
-+                          : "cc");
-+    return readval;
-+}
-+#endif
-+
-+#ifdef __x86_64__
-+static inline int testandset (int *p)
-+{
-+    long int readval = 0;
-+
-+    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"
-+                          : "+m" (*p), "+a" (readval)
-+                          : "r" (1)
-+                          : "cc");
-+    return readval;
-+}
-+#endif
-+
-+#ifdef __s390__
-+static inline int testandset (int *p)
-+{
-+    int ret;
-+
-+    __asm__ __volatile__ ("0: cs    %0,%1,0(%2)\n"
-+                         "   jl    0b"
-+                         : "=&d" (ret)
-+                         : "r" (1), "a" (p), "0" (*p)
-+                         : "cc", "memory" );
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __alpha__
-+static inline int testandset (int *p)
-+{
-+    int ret;
-+    unsigned long one;
-+
-+    __asm__ __volatile__ ("0:  mov 1,%2\n"
-+                         "     ldl_l %0,%1\n"
-+                         "     stl_c %2,%1\n"
-+                         "     beq %2,1f\n"
-+                         ".subsection 2\n"
-+                         "1:   br 0b\n"
-+                         ".previous"
-+                         : "=r" (ret), "=m" (*p), "=r" (one)
-+                         : "m" (*p));
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __sparc__
-+static inline int testandset (int *p)
-+{
-+       int ret;
-+
-+       __asm__ __volatile__("ldstub    [%1], %0"
-+                            : "=r" (ret)
-+                            : "r" (p)
-+                            : "memory");
-+
-+       return (ret ? 1 : 0);
-+}
-+#endif
-+
-+#ifdef __arm__
-+static inline int testandset (int *spinlock)
-+{
-+    register unsigned int ret;
-+    __asm__ __volatile__("swp %0, %1, [%2]"
-+                         : "=r"(ret)
-+                         : "0"(1), "r"(spinlock));
-+
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __mc68000
-+static inline int testandset (int *p)
-+{
-+    char ret;
-+    __asm__ __volatile__("tas %1; sne %0"
-+                         : "=r" (ret)
-+                         : "m" (p)
-+                         : "cc","memory");
-+    return ret;
-+}
-+#endif
-+
-+#ifdef __ia64
-+#include <ia64intrin.h>
-+
-+static inline int testandset (int *p)
-+{
-+    return __sync_lock_test_and_set (p, 1);
-+}
-+#endif
-+
-+typedef int spinlock_t;
-+
-+#define SPIN_LOCK_UNLOCKED 0
-+
-+#if defined(CONFIG_USER_ONLY)
-+static inline void spin_lock(spinlock_t *lock)
-+{
-+    while (testandset(lock));
-+}
-+
-+static inline void spin_unlock(spinlock_t *lock)
-+{
-+    *lock = 0;
-+}
-+
-+static inline int spin_trylock(spinlock_t *lock)
-+{
-+    return !testandset(lock);
-+}
-+#else
-+static inline void spin_lock(spinlock_t *lock)
-+{
-+}
-+
-+static inline void spin_unlock(spinlock_t *lock)
-+{
-+}
-+
-+static inline int spin_trylock(spinlock_t *lock)
-+{
-+    return 1;
-+}
-+#endif
-+
-+#endif /* ! _QEMU_SPINLOCK_H */
diff --git a/packages/qemu/qemu-native.inc b/packages/qemu/qemu-native.inc
index bab02f7ddf..758c81a1a4 100644
--- a/packages/qemu/qemu-native.inc
+++ b/packages/qemu/qemu-native.inc
@@ -1,5 +1,10 @@
 FILESPATH =. "${@os.path.dirname(bb.data.getVar('FILE',d,1))}/qemu-${PV}:"
-prefix = "${STAGING_DIR}/${BUILD_SYS}"
+# prefix = "${STAGING_DIR}/${BUILD_SYS}"
+DEPENDS = "libsdl-native"
+
+do_configure_prepend() {
+	sed -i -e s,sdl-config,sdl-config-native, configure
+}
 
 python __anonymous() {
     from bb import which, data
@@ -11,5 +16,10 @@ python __anonymous() {
         data.setVar('EXTRA_OECONF', oldOeConf + " --cc=gcc-3.4", d)
     elif len(which(path, 'gcc-3.3')) != 0:
         data.setVar('EXTRA_OECONF', oldOeConf + " --cc=gcc-3.3", d)
+    elif len(which(path, 'gcc-3.3.6')) != 0:
+        data.setVar('EXTRA_OECONF', oldOeConf + " --cc=gcc-3.3.6", d)
+}
 
+do_stage() {
+	find . -name "qemu-*" -type f -perm -755 -exec install -m 0755 {} ${STAGING_BINDIR} \;
 }
diff --git a/packages/qemu/qemu-native_0.7.0.bb b/packages/qemu/qemu-native_0.7.0.bb
deleted file mode 100644
index bad8bd7bf4..0000000000
--- a/packages/qemu/qemu-native_0.7.0.bb
+++ /dev/null
@@ -1,4 +0,0 @@
-require qemu_${PV}.bb
-inherit native
-S = "${WORKDIR}/qemu-${PV}"
-require qemu-native.inc
diff --git a/packages/qemu/qemu-native_0.8.0.bb b/packages/qemu/qemu-native_0.8.0.bb
deleted file mode 100644
index 9613f7d614..0000000000
--- a/packages/qemu/qemu-native_0.8.0.bb
+++ /dev/null
@@ -1,5 +0,0 @@
-require qemu_${PV}.bb
-inherit native
-require qemu-native.inc
-S = "${WORKDIR}/qemu-${PV}"
-
diff --git a/packages/qemu/qemu-native_0.8.1.bb b/packages/qemu/qemu-native_0.8.1.bb
deleted file mode 100644
index 9613f7d614..0000000000
--- a/packages/qemu/qemu-native_0.8.1.bb
+++ /dev/null
@@ -1,5 +0,0 @@
-require qemu_${PV}.bb
-inherit native
-require qemu-native.inc
-S = "${WORKDIR}/qemu-${PV}"
-
diff --git a/packages/qemu/qemu-native_0.8.2.bb b/packages/qemu/qemu-native_0.8.2.bb
deleted file mode 100644
index c0b1cd4ee3..0000000000
--- a/packages/qemu/qemu-native_0.8.2.bb
+++ /dev/null
@@ -1,6 +0,0 @@
-require qemu_${PV}.bb
-EXTRA_OECONF = ""
-inherit native
-require qemu-native.inc
-S = "${WORKDIR}/qemu-${PV}"
-
diff --git a/packages/qemu/qemu_0.7.0.bb b/packages/qemu/qemu_0.7.0.bb
deleted file mode 100644
index fd7a892347..0000000000
--- a/packages/qemu/qemu_0.7.0.bb
+++ /dev/null
@@ -1,6 +0,0 @@
-LICENSE = "GPL"
-
-SRC_URI = "http://fabrice.bellard.free.fr/qemu/qemu-${PV}.tar.gz"
-
-inherit autotools
-
diff --git a/packages/qemu/qemu_0.8.0.bb b/packages/qemu/qemu_0.8.0.bb
deleted file mode 100644
index 38bbcbacad..0000000000
--- a/packages/qemu/qemu_0.8.0.bb
+++ /dev/null
@@ -1,9 +0,0 @@
-LICENSE = "GPL"
-
-SRC_URI = "http://fabrice.bellard.free.fr/qemu/qemu-${PV}.tar.gz \
-           file://configure.patch;patch=1 \
-           file://arm_nptl.patch;patch=1"
-PR = "r1"
-
-inherit autotools
-
diff --git a/packages/qemu/qemu_0.8.1.bb b/packages/qemu/qemu_0.8.1.bb
deleted file mode 100644
index fd7a892347..0000000000
--- a/packages/qemu/qemu_0.8.1.bb
+++ /dev/null
@@ -1,6 +0,0 @@
-LICENSE = "GPL"
-
-SRC_URI = "http://fabrice.bellard.free.fr/qemu/qemu-${PV}.tar.gz"
-
-inherit autotools
-
diff --git a/packages/qemu/qemu_0.8.2.bb b/packages/qemu/qemu_0.8.2.bb
deleted file mode 100644
index 49032fa59d..0000000000
--- a/packages/qemu/qemu_0.8.2.bb
+++ /dev/null
@@ -1,11 +0,0 @@
-LICENSE = "GPL"
-
-SRC_URI = "http://fabrice.bellard.free.fr/qemu/qemu-${PV}.tar.gz \
-           file://configure.patch;patch=1 \
-           file://pl110_rgb-r0.patch;patch=1 \
-           file://arm_nptl.patch;patch=1"
-
-inherit autotools
-
-EXTRA_OECONF = "--cc=${CC}"
-
diff --git a/packages/qemu/qemu_cvs.bb b/packages/qemu/qemu_cvs.bb
index 0dfe01aa11..8d22a6f1f8 100644
--- a/packages/qemu/qemu_cvs.bb
+++ b/packages/qemu/qemu_cvs.bb
@@ -1,11 +1,20 @@
+DESCRIPTION = "Qemu is an open source processor emulator."
+HOMEPAGE = "http://fabrice.bellard.free.fr/qemu/"
+SECTION = "devel"
 LICENSE = "GPL"
 PV = "0.8.2+cvs${SRCDATE}"
+PR = "r1"
 
 SRC_URI = "cvs://anonymous@cvs.savannah.nongnu.org/sources/qemu;method=pserver;rsh=ssh;module=qemu \
            file://configure.patch;patch=1 \
-	   file://pl110_rgb-r0.patch;patch=1 \
-	   file://arm_nptl.patch;patch=1"
-
+           file://qemu-sdl-cursor.patch;patch=1 \
+           file://arm_nptl.patch;patch=1 \
+           file://pl110_rgb-r0.patch;patch=1 \
+           file://qemu-pci-irq-sharing.patch;patch=1 \
+           file://compiler.patch;patch=1 \
+           file://qemu-usb-wacom-0.8.2.patch;patch=1 \
+           file://qemu-usb-wacom-pressure.patch;patch=1 \
+           file://qemu-usb-wacom-buttons.patch;patch=1"
 S = "${WORKDIR}/qemu"
 
 inherit autotools
author	Kristoffer Ericson <kristoffer_e1@hotmail.com>	2006-10-25 23:27:19 +0000
committer	Kristoffer Ericson <kristoffer_e1@hotmail.com>	2006-10-25 23:27:19 +0000
commit	e26108affb65e89fcf248a58564b9c25934a04a0 (patch)
tree	3c27feb6d440ed2df41309dae277afc13427c12f /packages/qemu
parent	d7fd0e38cb60cb0ac871723c34616bf542d423cc (diff)
parent	12f3d309156ac047b0826904ef729b83b997b8b5 (diff)