usb-host-libusb: Set stream id when submitting bulk-stream transfers

Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
usb-host-libusb: Add alloc / free streams ops
2014-05-26 08:41:07 +02:00 · 2014-05-26 08:41:07 +02:00 · 2014-05-26 08:41:07 +02:00 · 2014-05-26 08:41:07 +02:00 · 2014-05-26 08:41:07 +02:00 · 2014-05-26 08:41:07 +02:00
14 changed files with 343 additions and 334 deletions
--- a/docs/multiseat.txt
+++ b/docs/multiseat.txt
@@ -1,76 +0,0 @@
-
-multiseat howto (with some multihead coverage)
-==============================================
-
-host side
---------
-
-First you must compile qemu with a user interface supporting
-multihead/multiseat and input event routing.  Right now this list is
-pretty short: sdl2.
-
-  ./configure --enable-sdl --with-sdlabi=2.0
-
-
-Next put together the qemu command line:
-
-qemu	-enable-kvm -usb $memory $disk $whatever \
-	-display sdl \
-	-vga std \
-	-device usb-tablet
-
-That is it for the first head, which will use the standard vga, the
-standard ps/2 keyboard (implicitly there) and the usb-tablet.  Now the
-additional switches for the second head:
-
-	-device pci-bridge,addr=12.0,chassis_nr=2,id=head.2 \
-	-device secondary-vga,bus=head.2,addr=02.0,id=video.2 \
-	-device nec-usb-xhci,bus=head.2,addr=0f.0,id=usb.2 \
-	-device usb-kbd,bus=usb.2.0,port=1,display=video.2 \
-	-device usb-tablet,bus=usb.2.0,port=2,display=video.2
-
-This places a pci bridge in slot 12, connects a display adapter and
-xhci (usb) controller to the bridge.  Then it adds a usb keyboard and
-usb mouse, both connected to the xhci and linked to the display.
-
-The "display=video2" sets up the input routing.  Any input coming from
-the window which belongs to the video.2 display adapter will be routed
-to these input devices.
-
-
-guest side
----------
-
-You need a pretty recent linux guest.  systemd with loginctl.  kernel
-3.14+ with CONFIG_DRM_BOCHS enabled.  Fedora 20 will do.  Must be
-fully updated for the new kernel though, i.e. the live iso doesn't cut
-it.
-
-Now we'll have to configure the guest.  Boot and login.  By default
-all devices belong to seat0.  You can use "loginctl seat-status seat0"
-to list them all (and to get the sysfs paths for cut+paste).  Now
-we'll go assign all pci devices connected the pci bridge in slot 12 to
-a new head:
-
-loginctl attach seat-qemu \
-	 /sys/devices/pci0000:00/0000:00:12.0/0000:01:02.0/drm/card1
-loginctl attach seat-qemu \
-	 /sys/devices/pci0000:00/0000:00:12.0/0000:01:02.0/graphics/fb1
-loginctl attach seat-qemu \
-	 /sys/devices/pci0000:00/0000:00:12.0/0000:01:0f.0/usb2
-
-Use "loginctl seat-status seat-qemu" to check the result.  It isn't
-needed to assign the usb devices to the head individually, assigning a
-usb (root) hub will automatically assign all usb devices connected to
-it too.
-
-BTW: loginctl writes udev rules to /etc/udev/rules.d to make these
-device assignments permanent, so you need to do this only once.
-
-Now simply restart gdm (rebooting will do too), and a login screen
-should show up on the second head.
-
-Enjoy!
-
--
-Gerd Hoffmann <kraxel@redhat.com>
--- a/hw/input/hid.c
+++ b/hw/input/hid.c
@@ -105,135 +105,70 @@ void hid_set_next_idle(HIDState *hs)
    }
 }

-static void hid_pointer_event(DeviceState *dev, QemuConsole *src,
-                              InputEvent *evt)
+static void hid_pointer_event_clear(HIDPointerEvent *e, int buttons)
 {
-    static const int bmap[INPUT_BUTTON_MAX] = {
-        [INPUT_BUTTON_LEFT]   = 0x01,
-        [INPUT_BUTTON_RIGHT]  = 0x02,
-        [INPUT_BUTTON_MIDDLE] = 0x04,
-    };
-    HIDState *hs = (HIDState *)dev;
-    HIDPointerEvent *e;
-
-    assert(hs->n < QUEUE_LENGTH);
-    e = &hs->ptr.queue[(hs->head + hs->n) & QUEUE_MASK];
-
-    switch (evt->kind) {
-    case INPUT_EVENT_KIND_REL:
-        if (evt->rel->axis == INPUT_AXIS_X) {
-            e->xdx += evt->rel->value;
-        } else if (evt->rel->axis == INPUT_AXIS_Y) {
-            e->ydy -= evt->rel->value;
-        }
-        break;
-
-    case INPUT_EVENT_KIND_ABS:
-        if (evt->rel->axis == INPUT_AXIS_X) {
-            e->xdx = evt->rel->value;
-        } else if (evt->rel->axis == INPUT_AXIS_Y) {
-            e->ydy = evt->rel->value;
-        }
-        break;
-
-    case INPUT_EVENT_KIND_BTN:
-        if (evt->btn->down) {
-            e->buttons_state |= bmap[evt->btn->button];
-            if (evt->btn->button == INPUT_BUTTON_WHEEL_UP) {
-                e->dz--;
-            } else if (evt->btn->button == INPUT_BUTTON_WHEEL_DOWN) {
-                e->dz++;
-            }
-        } else {
-            e->buttons_state &= ~bmap[evt->btn->button];
-        }
-        break;
-
-    default:
-        /* keep gcc happy */
-        break;
-    }
-
+    e->xdx = e->ydy = e->dz = 0;
+    e->buttons_state = buttons;
 }

-static void hid_pointer_sync(DeviceState *dev)
-{
-    HIDState *hs = (HIDState *)dev;
-    HIDPointerEvent *prev, *curr, *next;
-    bool event_compression = false;
-
-    if (hs->n == QUEUE_LENGTH-1) {
-        /*
-         * Queue full.  We are loosing information, but we at least
-         * keep track of most recent button state.
-         */
-        return;
-    }
-
-    prev = &hs->ptr.queue[(hs->head + hs->n - 1) & QUEUE_MASK];
-    curr = &hs->ptr.queue[(hs->head + hs->n) & QUEUE_MASK];
-    next = &hs->ptr.queue[(hs->head + hs->n + 1) & QUEUE_MASK];
-
-    if (hs->n > 0) {
-        /*
-         * No button state change between previous and current event
-         * (and previous wasn't seen by the guest yet), so there is
-         * motion information only and we can combine the two event
-         * into one.
-         */
-        if (curr->buttons_state == prev->buttons_state) {
-            event_compression = true;
-        }
-    }
-
-    if (event_compression) {
-        /* add current motion to previous, clear current */
-        if (hs->kind == HID_MOUSE) {
-            prev->xdx += curr->xdx;
-            curr->xdx = 0;
-            prev->ydy -= curr->ydy;
-            curr->ydy = 0;
-        } else {
-            prev->xdx = curr->xdx;
-            prev->ydy = curr->ydy;
-        }
-        prev->dz += curr->dz;
-        curr->dz = 0;
+static void hid_pointer_event_combine(HIDPointerEvent *e, int xyrel,
+                                      int x1, int y1, int z1) {
+    if (xyrel) {
+        e->xdx += x1;
+        e->ydy += y1;
    } else {
-        /* prepate next (clear rel, copy abs + btns) */
-        if (hs->kind == HID_MOUSE) {
-            next->xdx = 0;
-            next->ydy = 0;
-        } else {
-            next->xdx = curr->xdx;
-            next->ydy = curr->ydy;
+        e->xdx = x1;
+        e->ydy = y1;
+        /* Windows drivers do not like the 0/0 position and ignore such
+         * events. */
+        if (!(x1 | y1)) {
+            e->xdx = 1;
        }
-        next->dz = 0;
-        next->buttons_state = curr->buttons_state;
-        /* make current guest visible, notify guest */
-        hs->n++;
-        hs->event(hs);
    }
+    e->dz += z1;
 }

-static void hid_keyboard_event(DeviceState *dev, QemuConsole *src,
-                               InputEvent *evt)
+static void hid_pointer_event(void *opaque,
+                              int x1, int y1, int z1, int buttons_state)
 {
-    HIDState *hs = (HIDState *)dev;
-    int scancodes[3], i, count;
+    HIDState *hs = opaque;
+    unsigned use_slot = (hs->head + hs->n - 1) & QUEUE_MASK;
+    unsigned previous_slot = (use_slot - 1) & QUEUE_MASK;
+
+    /* We combine events where feasible to keep the queue small.  We shouldn't
+     * combine anything with the first event of a particular button state, as
+     * that would change the location of the button state change.  When the
+     * queue is empty, a second event is needed because we don't know if
+     * the first event changed the button state.  */
+    if (hs->n == QUEUE_LENGTH) {
+        /* Queue full.  Discard old button state, combine motion normally.  */
+        hs->ptr.queue[use_slot].buttons_state = buttons_state;
+    } else if (hs->n < 2 ||
+               hs->ptr.queue[use_slot].buttons_state != buttons_state ||
+               hs->ptr.queue[previous_slot].buttons_state !=
+               hs->ptr.queue[use_slot].buttons_state) {
+        /* Cannot or should not combine, so add an empty item to the queue.  */
+        QUEUE_INCR(use_slot);
+        hs->n++;
+        hid_pointer_event_clear(&hs->ptr.queue[use_slot], buttons_state);
+    }
+    hid_pointer_event_combine(&hs->ptr.queue[use_slot],
+                              hs->kind == HID_MOUSE,
+                              x1, y1, z1);
+    hs->event(hs);
+}
+
+static void hid_keyboard_event(void *opaque, int keycode)
+{
+    HIDState *hs = opaque;
    int slot;

-    count = qemu_input_key_value_to_scancode(evt->key->key,
-                                             evt->key->down,
-                                             scancodes);
-    if (hs->n + count > QUEUE_LENGTH) {
+    if (hs->n == QUEUE_LENGTH) {
        fprintf(stderr, "usb-kbd: warning: key event queue full\n");
        return;
    }
-    for (i = 0; i < count; i++) {
-        slot = (hs->head + hs->n) & QUEUE_MASK; hs->n++;
-        hs->kbd.keycodes[slot] = scancodes[i];
-    }
+    slot = (hs->head + hs->n) & QUEUE_MASK; hs->n++;
+    hs->kbd.keycodes[slot] = keycode;
    hs->event(hs);
 }

@@ -312,14 +247,14 @@ static inline int int_clamp(int val, int vmin, int vmax)
 void hid_pointer_activate(HIDState *hs)
 {
    if (!hs->ptr.mouse_grabbed) {
-        qemu_input_handler_activate(hs->s);
+        qemu_activate_mouse_event_handler(hs->ptr.eh_entry);
        hs->ptr.mouse_grabbed = 1;
    }
 }

 int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len)
 {
-    int dx, dy, dz, l;
+    int dx, dy, dz, b, l;
    int index;
    HIDPointerEvent *e;

@@ -344,6 +279,17 @@ int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len)
    dz = int_clamp(e->dz, -127, 127);
    e->dz -= dz;

+    b = 0;
+    if (e->buttons_state & MOUSE_EVENT_LBUTTON) {
+        b |= 0x01;
+    }
+    if (e->buttons_state & MOUSE_EVENT_RBUTTON) {
+        b |= 0x02;
+    }
+    if (e->buttons_state & MOUSE_EVENT_MBUTTON) {
+        b |= 0x04;
+    }
+
    if (hs->n &&
        !e->dz &&
        (hs->kind == HID_TABLET || (!e->xdx && !e->ydy))) {
@@ -358,7 +304,7 @@ int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len)
    switch (hs->kind) {
    case HID_MOUSE:
        if (len > l) {
-            buf[l++] = e->buttons_state;
+            buf[l++] = b;
        }
        if (len > l) {
            buf[l++] = dx;
@@ -373,7 +319,7 @@ int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len)

    case HID_TABLET:
        if (len > l) {
-            buf[l++] = e->buttons_state;
+            buf[l++] = b;
        }
        if (len > l) {
            buf[l++] = dx & 0xff;
@@ -467,45 +413,31 @@ void hid_reset(HIDState *hs)

 void hid_free(HIDState *hs)
 {
-    qemu_input_handler_unregister(hs->s);
+    switch (hs->kind) {
+    case HID_KEYBOARD:
+        qemu_remove_kbd_event_handler(hs->kbd.eh_entry);
+        break;
+    case HID_MOUSE:
+    case HID_TABLET:
+        qemu_remove_mouse_event_handler(hs->ptr.eh_entry);
+        break;
+    }
    hid_del_idle_timer(hs);
 }

-static QemuInputHandler hid_keyboard_handler = {
-    .name  = "QEMU HID Keyboard",
-    .mask  = INPUT_EVENT_MASK_KEY,
-    .event = hid_keyboard_event,
-};
-
-static QemuInputHandler hid_mouse_handler = {
-    .name  = "QEMU HID Mouse",
-    .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
-    .event = hid_pointer_event,
-    .sync  = hid_pointer_sync,
-};
-
-static QemuInputHandler hid_tablet_handler = {
-    .name  = "QEMU HID Tablet",
-    .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
-    .event = hid_pointer_event,
-    .sync  = hid_pointer_sync,
-};
-
 void hid_init(HIDState *hs, int kind, HIDEventFunc event)
 {
    hs->kind = kind;
    hs->event = event;

    if (hs->kind == HID_KEYBOARD) {
-        hs->s = qemu_input_handler_register((DeviceState *)hs,
-                                            &hid_keyboard_handler);
-        qemu_input_handler_activate(hs->s);
+        hs->kbd.eh_entry = qemu_add_kbd_event_handler(hid_keyboard_event, hs);
    } else if (hs->kind == HID_MOUSE) {
-        hs->s = qemu_input_handler_register((DeviceState *)hs,
-                                            &hid_mouse_handler);
+        hs->ptr.eh_entry = qemu_add_mouse_event_handler(hid_pointer_event, hs,
+                                                        0, "QEMU HID Mouse");
    } else if (hs->kind == HID_TABLET) {
-        hs->s = qemu_input_handler_register((DeviceState *)hs,
-                                            &hid_tablet_handler);
+        hs->ptr.eh_entry = qemu_add_mouse_event_handler(hid_pointer_event, hs,
+                                                        1, "QEMU HID Tablet");
    }
 }

--- a/hw/usb/dev-hid.c
+++ b/hw/usb/dev-hid.c
@@ -47,8 +47,6 @@ typedef struct USBHIDState {
    USBEndpoint *intr;
    HIDState hid;
    uint32_t usb_version;
-    char *display;
-    uint32_t head;
 } USBHIDState;

 enum {
@@ -576,9 +574,6 @@ static int usb_hid_initfn(USBDevice *dev, int kind)
    usb_desc_init(dev);
    us->intr = usb_ep_get(dev, USB_TOKEN_IN, 1);
    hid_init(&us->hid, kind, usb_hid_changed);
-    if (us->display && us->hid.s) {
-        qemu_input_handler_bind(us->hid.s, us->display, us->head, NULL);
-    }
    return 0;
 }

@@ -658,8 +653,6 @@ static void usb_hid_class_initfn(ObjectClass *klass, void *data)

 static Property usb_tablet_properties[] = {
        DEFINE_PROP_UINT32("usb_version", USBHIDState, usb_version, 2),
-        DEFINE_PROP_STRING("display", USBHIDState, display),
-        DEFINE_PROP_UINT32("head", USBHIDState, head, 0),
        DEFINE_PROP_END_OF_LIST(),
 };

@@ -703,11 +696,6 @@ static const TypeInfo usb_mouse_info = {
    .class_init    = usb_mouse_class_initfn,
 };

-static Property usb_keyboard_properties[] = {
-        DEFINE_PROP_STRING("display", USBHIDState, display),
-        DEFINE_PROP_END_OF_LIST(),
-};
-
 static void usb_keyboard_class_initfn(ObjectClass *klass, void *data)
 {
    DeviceClass *dc = DEVICE_CLASS(klass);
@@ -718,7 +706,6 @@ static void usb_keyboard_class_initfn(ObjectClass *klass, void *data)
    uc->product_desc   = "QEMU USB Keyboard";
    uc->usb_desc       = &desc_keyboard;
    dc->vmsd = &vmstate_usb_kbd;
-    dc->props = usb_keyboard_properties;
    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
 }

--- a/hw/usb/dev-mtp.c
+++ b/hw/usb/dev-mtp.c
@@ -46,6 +46,7 @@ enum mtp_code {

    /* response codes */
    RES_OK                         = 0x2001,
+    RES_GENERAL_ERROR              = 0x2002,
    RES_SESSION_NOT_OPEN           = 0x2003,
    RES_INVALID_TRANSACTION_ID     = 0x2004,
    RES_OPERATION_NOT_SUPPORTED    = 0x2005,
@@ -109,7 +110,8 @@ struct MTPObject {
    struct stat  stat;
    MTPObject    *parent;
    MTPObject    **children;
-    int32_t      nchildren;
+    uint32_t     nchildren;
+    bool         have_children;
    QTAILQ_ENTRY(MTPObject) next;
 };

@@ -273,7 +275,6 @@ static MTPObject *usb_mtp_object_alloc(MTPState *s, uint32_t handle,
    o->handle = handle;
    o->parent = parent;
    o->name = g_strdup(name);
-    o->nchildren = -1;
    if (parent == NULL) {
        o->path = g_strdup(name);
    } else {
@@ -340,7 +341,11 @@ static void usb_mtp_object_readdir(MTPState *s, MTPObject *o)
    struct dirent *entry;
    DIR *dir;

-    o->nchildren = 0;
+    if (o->have_children) {
+        return;
+    }
+    o->have_children = true;
+
    dir = opendir(o->path);
    if (!dir) {
        return;
@@ -698,7 +703,10 @@ static MTPData *usb_mtp_get_partial_object(MTPState *s, MTPControl *c,
    if (offset > o->stat.st_size) {
        offset = o->stat.st_size;
    }
-    lseek(d->fd, offset, SEEK_SET);
+    if (lseek(d->fd, offset, SEEK_SET) < 0) {
+        usb_mtp_data_free(d);
+        return NULL;
+    }

    d->length = c->argv[2];
    if (d->length > o->stat.st_size - offset) {
@@ -789,9 +797,7 @@ static void usb_mtp_command(MTPState *s, MTPControl *c)
                                 c->trans, 0, 0, 0);
            return;
        }
-        if (o->nchildren == -1) {
-            usb_mtp_object_readdir(s, o);
-        }
+        usb_mtp_object_readdir(s, o);
        if (c->code == CMD_GET_NUM_OBJECTS) {
            trace_usb_mtp_op_get_num_objects(s->dev.addr, o->handle, o->path);
            nres = 1;
@@ -823,7 +829,9 @@ static void usb_mtp_command(MTPState *s, MTPControl *c)
        }
        data_in = usb_mtp_get_object(s, c, o);
        if (NULL == data_in) {
-            fprintf(stderr, "%s: TODO: handle error\n", __func__);
+            usb_mtp_queue_result(s, RES_GENERAL_ERROR,
+                                 c->trans, 0, 0, 0);
+            return;
        }
        break;
    case CMD_GET_PARTIAL_OBJECT:
@@ -840,7 +848,9 @@ static void usb_mtp_command(MTPState *s, MTPControl *c)
        }
        data_in = usb_mtp_get_partial_object(s, c, o);
        if (NULL == data_in) {
-            fprintf(stderr, "%s: TODO: handle error\n", __func__);
+            usb_mtp_queue_result(s, RES_GENERAL_ERROR,
+                                 c->trans, 0, 0, 0);
+            return;
        }
        nres = 1;
        res0 = data_in->length;
--- a/hw/usb/hcd-xhci.c
+++ b/hw/usb/hcd-xhci.c
@@ -621,6 +621,11 @@ static const char *ep_state_name(uint32_t state)
                       ARRAY_SIZE(ep_state_names));
 }

+static bool xhci_get_flag(XHCIState *xhci, enum xhci_flags bit)
+{
+    return xhci->flags & (1 << bit);
+}
+
 static uint64_t xhci_mfindex_get(XHCIState *xhci)
 {
    int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
@@ -3435,7 +3440,7 @@ static void xhci_child_detach(USBPort *uport, USBDevice *child)
    USBBus *bus = usb_bus_from_device(child);
    XHCIState *xhci = container_of(bus, XHCIState, bus);

-    xhci_detach_slot(xhci, uport);
+    xhci_detach_slot(xhci, child->port);
 }

 static USBPortOps xhci_uport_ops = {
@@ -3594,13 +3599,15 @@ static int usb_xhci_initfn(struct PCIDevice *dev)
                     PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64,
                     &xhci->mem);

-    ret = pcie_endpoint_cap_init(dev, 0xa0);
-    assert(ret >= 0);
+    if (pci_bus_is_express(dev->bus)) {
+        ret = pcie_endpoint_cap_init(dev, 0xa0);
+        assert(ret >= 0);
+    }

-    if (xhci->flags & (1 << XHCI_FLAG_USE_MSI)) {
+    if (xhci_get_flag(xhci, XHCI_FLAG_USE_MSI)) {
        msi_init(dev, 0x70, xhci->numintrs, true, false);
    }
-    if (xhci->flags & (1 << XHCI_FLAG_USE_MSI_X)) {
+    if (xhci_get_flag(xhci, XHCI_FLAG_USE_MSI_X)) {
        msix_init(dev, xhci->numintrs,
                  &xhci->mem, 0, OFF_MSIX_TABLE,
                  &xhci->mem, 0, OFF_MSIX_PBA,
--- a/hw/usb/host-libusb.c
+++ b/hw/usb/host-libusb.c
@@ -720,6 +720,9 @@ static void usb_host_ep_update(USBHostDevice *s)
    struct libusb_config_descriptor *conf;
    const struct libusb_interface_descriptor *intf;
    const struct libusb_endpoint_descriptor *endp;
+#if LIBUSBX_API_VERSION >= 0x01000103
+    struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;
+#endif
    uint8_t devep, type;
    int pid, ep;
    int rc, i, e;
@@ -765,6 +768,15 @@ static void usb_host_ep_update(USBHostDevice *s)
            usb_ep_set_type(udev, pid, ep, type);
            usb_ep_set_ifnum(udev, pid, ep, i);
            usb_ep_set_halted(udev, pid, ep, 0);
+#if LIBUSBX_API_VERSION >= 0x01000103
+            if (type == LIBUSB_TRANSFER_TYPE_BULK &&
+                    libusb_get_ss_endpoint_companion_descriptor(ctx, endp,
+                        &endp_ss_comp) == LIBUSB_SUCCESS) {
+                usb_ep_set_max_streams(udev, pid, ep,
+                                       endp_ss_comp->bmAttributes);
+                libusb_free_ss_endpoint_companion_descriptor(endp_ss_comp);
+            }
+#endif
        }
    }

@@ -1202,10 +1214,23 @@ static void usb_host_handle_data(USBDevice *udev, USBPacket *p)
            usb_packet_copy(p, r->buffer, size);
        }
        ep = p->ep->nr | (r->in ? USB_DIR_IN : 0);
-        libusb_fill_bulk_transfer(r->xfer, s->dh, ep,
-                                  r->buffer, size,
-                                  usb_host_req_complete_data, r,
-                                  BULK_TIMEOUT);
+        if (p->stream) {
+#if LIBUSBX_API_VERSION >= 0x01000103
+            libusb_fill_bulk_stream_transfer(r->xfer, s->dh, ep, p->stream,
+                                             r->buffer, size,
+                                             usb_host_req_complete_data, r,
+                                             BULK_TIMEOUT);
+#else
+            usb_host_req_free(r);
+            p->status = USB_RET_STALL;
+            return;
+#endif
+        } else {
+            libusb_fill_bulk_transfer(r->xfer, s->dh, ep,
+                                      r->buffer, size,
+                                      usb_host_req_complete_data, r,
+                                      BULK_TIMEOUT);
+        }
        break;
    case USB_ENDPOINT_XFER_INT:
        r = usb_host_req_alloc(s, p, p->pid == USB_TOKEN_IN, p->iov.size);
@@ -1268,6 +1293,54 @@ static void usb_host_handle_reset(USBDevice *udev)
    }
 }

+static int usb_host_alloc_streams(USBDevice *udev, USBEndpoint **eps,
+                                  int nr_eps, int streams)
+{
+#if LIBUSBX_API_VERSION >= 0x01000103
+    USBHostDevice *s = USB_HOST_DEVICE(udev);
+    unsigned char endpoints[30];
+    int i, rc;
+
+    for (i = 0; i < nr_eps; i++) {
+        endpoints[i] = eps[i]->nr;
+        if (eps[i]->pid == USB_TOKEN_IN) {
+            endpoints[i] |= 0x80;
+        }
+    }
+    rc = libusb_alloc_streams(s->dh, streams, endpoints, nr_eps);
+    if (rc < 0) {
+        usb_host_libusb_error("libusb_alloc_streams", rc);
+    } else if (rc != streams) {
+        fprintf(stderr,
+            "libusb_alloc_streams: got less streams then requested %d < %d\n",
+            rc, streams);
+    }
+
+    return (rc == streams) ? 0 : -1;
+#else
+    fprintf(stderr, "libusb_alloc_streams: error not implemented\n");
+    return -1;
+#endif
+}
+
+static void usb_host_free_streams(USBDevice *udev, USBEndpoint **eps,
+                                  int nr_eps)
+{
+#if LIBUSBX_API_VERSION >= 0x01000103
+    USBHostDevice *s = USB_HOST_DEVICE(udev);
+    unsigned char endpoints[30];
+    int i;
+
+    for (i = 0; i < nr_eps; i++) {
+        endpoints[i] = eps[i]->nr;
+        if (eps[i]->pid == USB_TOKEN_IN) {
+            endpoints[i] |= 0x80;
+        }
+    }
+    libusb_free_streams(s->dh, endpoints, nr_eps);
+#endif
+}
+
 /*
 * This is *NOT* about restoring state.  We have absolutely no idea
 * what state the host device is in at the moment and whenever it is
@@ -1349,6 +1422,8 @@ static void usb_host_class_initfn(ObjectClass *klass, void *data)
    uc->handle_reset   = usb_host_handle_reset;
    uc->handle_destroy = usb_host_handle_destroy;
    uc->flush_ep_queue = usb_host_flush_ep_queue;
+    uc->alloc_streams  = usb_host_alloc_streams;
+    uc->free_streams   = usb_host_free_streams;
    dc->vmsd = &vmstate_usb_host;
    dc->props = usb_host_dev_properties;
    set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -50,6 +50,10 @@
                       ((i) & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT, \
                       (i) & 0x0f))

+#ifndef USBREDIR_VERSION /* This is not defined in older usbredir versions */
+#define USBREDIR_VERSION 0
+#endif
+
 typedef struct USBRedirDevice USBRedirDevice;

 /* Struct to hold buffered packets */
@@ -68,6 +72,7 @@ struct endp_data {
    uint8_t interval;
    uint8_t interface; /* bInterfaceNumber this ep belongs to */
    uint16_t max_packet_size; /* In bytes, not wMaxPacketSize format !! */
+    uint32_t max_streams;
    uint8_t iso_started;
    uint8_t iso_error; /* For reporting iso errors to the HC */
    uint8_t interrupt_started;
@@ -106,8 +111,9 @@ struct USBRedirDevice {
    int read_buf_size;
    /* Active chardev-watch-tag */
    guint watch;
-    /* For async handling of close */
+    /* For async handling of close / reject */
    QEMUBH *chardev_close_bh;
+    QEMUBH *device_reject_bh;
    /* To delay the usb attach in case of quick chardev close + open */
    QEMUTimer *attach_timer;
    int64_t next_attach_time;
@@ -780,11 +786,12 @@ static void usbredir_handle_bulk_data(USBRedirDevice *dev, USBPacket *p,
        dev->endpoint[EP2I(ep)].bulk_receiving_enabled = 0;
    }

-    DPRINTF("bulk-out ep %02X len %zd id %"PRIu64"\n", ep, size, p->id);
+    DPRINTF("bulk-out ep %02X stream %u len %zd id %"PRIu64"\n",
+            ep, p->stream, size, p->id);

    bulk_packet.endpoint  = ep;
    bulk_packet.length    = size;
-    bulk_packet.stream_id = 0;
+    bulk_packet.stream_id = p->stream;
    bulk_packet.length_high = size >> 16;
    assert(bulk_packet.length_high == 0 ||
           usbredirparser_peer_has_cap(dev->parser,
@@ -1091,6 +1098,66 @@ static void usbredir_handle_control(USBDevice *udev, USBPacket *p,
    p->status = USB_RET_ASYNC;
 }

+static int usbredir_alloc_streams(USBDevice *udev, USBEndpoint **eps,
+                                  int nr_eps, int streams)
+{
+    USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
+#if USBREDIR_VERSION >= 0x000700
+    struct usb_redir_alloc_bulk_streams_header alloc_streams;
+    int i;
+
+    if (!usbredirparser_peer_has_cap(dev->parser,
+                                     usb_redir_cap_bulk_streams)) {
+        ERROR("peer does not support streams\n");
+        goto reject;
+    }
+
+    if (streams == 0) {
+        ERROR("request to allocate 0 streams\n");
+        return -1;
+    }
+
+    alloc_streams.no_streams = streams;
+    alloc_streams.endpoints = 0;
+    for (i = 0; i < nr_eps; i++) {
+        alloc_streams.endpoints |= 1 << USBEP2I(eps[i]);
+    }
+    usbredirparser_send_alloc_bulk_streams(dev->parser, 0, &alloc_streams);
+    usbredirparser_do_write(dev->parser);
+
+    return 0;
+#else
+    ERROR("usbredir_alloc_streams not implemented\n");
+    goto reject;
+#endif
+reject:
+    ERROR("streams are not available, disconnecting\n");
+    qemu_bh_schedule(dev->device_reject_bh);
+    return -1;
+}
+
+static void usbredir_free_streams(USBDevice *udev, USBEndpoint **eps,
+                                  int nr_eps)
+{
+#if USBREDIR_VERSION >= 0x000700
+    USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
+    struct usb_redir_free_bulk_streams_header free_streams;
+    int i;
+
+    if (!usbredirparser_peer_has_cap(dev->parser,
+                                     usb_redir_cap_bulk_streams)) {
+        return;
+    }
+
+    free_streams.endpoints = 0;
+    for (i = 0; i < nr_eps; i++) {
+        free_streams.endpoints |= 1 << USBEP2I(eps[i]);
+    }
+    usbredirparser_send_free_bulk_streams(dev->parser, 0, &free_streams);
+    usbredirparser_do_write(dev->parser);
+#endif
+}
+
 /*
 * Close events can be triggered by usbredirparser_do_write which gets called
 * from within the USBDevice data / control packet callbacks and doing a
@@ -1102,6 +1169,7 @@ static void usbredir_chardev_close_bh(void *opaque)
 {
    USBRedirDevice *dev = opaque;

+    qemu_bh_cancel(dev->device_reject_bh);
    usbredir_device_disconnect(dev);

    if (dev->parser) {
@@ -1153,6 +1221,9 @@ static void usbredir_create_parser(USBRedirDevice *dev)
    usbredirparser_caps_set_cap(caps, usb_redir_cap_64bits_ids);
    usbredirparser_caps_set_cap(caps, usb_redir_cap_32bits_bulk_length);
    usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_receiving);
+#if USBREDIR_VERSION >= 0x000700
+    usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_streams);
+#endif

    if (runstate_check(RUN_STATE_INMIGRATE)) {
        flags |= usbredirparser_fl_no_hello;
@@ -1171,6 +1242,17 @@ static void usbredir_reject_device(USBRedirDevice *dev)
    }
 }

+/*
+ * We may need to reject the device when the hcd calls alloc_streams, doing
+ * an usb_detach from within a hcd call is not a good idea, hence this bh.
+ */
+static void usbredir_device_reject_bh(void *opaque)
+{
+    USBRedirDevice *dev = opaque;
+
+    usbredir_reject_device(dev);
+}
+
 static void usbredir_do_attach(void *opaque)
 {
    USBRedirDevice *dev = opaque;
@@ -1297,6 +1379,7 @@ static int usbredir_initfn(USBDevice *udev)
    }

    dev->chardev_close_bh = qemu_bh_new(usbredir_chardev_close_bh, dev);
+    dev->device_reject_bh = qemu_bh_new(usbredir_device_reject_bh, dev);
    dev->attach_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, usbredir_do_attach, dev);

    packet_id_queue_init(&dev->cancelled, dev, "cancelled");
@@ -1337,6 +1420,7 @@ static void usbredir_handle_destroy(USBDevice *udev)
    dev->cs = NULL;
    /* Note must be done after qemu_chr_close, as that causes a close event */
    qemu_bh_delete(dev->chardev_close_bh);
+    qemu_bh_delete(dev->device_reject_bh);

    timer_del(dev->attach_timer);
    timer_free(dev->attach_timer);
@@ -1628,6 +1712,7 @@ static void usbredir_setup_usb_eps(USBRedirDevice *dev)
        usb_ep->type = dev->endpoint[i].type;
        usb_ep->ifnum = dev->endpoint[i].interface;
        usb_ep->max_packet_size = dev->endpoint[i].max_packet_size;
+        usb_ep->max_streams = dev->endpoint[i].max_streams;
        usbredir_set_pipeline(dev, usb_ep);
    }
 }
@@ -1646,6 +1731,12 @@ static void usbredir_ep_info(void *priv,
                                     usb_redir_cap_ep_info_max_packet_size)) {
            dev->endpoint[i].max_packet_size = ep_info->max_packet_size[i];
        }
+#if USBREDIR_VERSION >= 0x000700
+        if (usbredirparser_peer_has_cap(dev->parser,
+                                        usb_redir_cap_bulk_streams)) {
+            dev->endpoint[i].max_streams = ep_info->max_streams[i];
+        }
+#endif
        switch (dev->endpoint[i].type) {
        case usb_redir_type_invalid:
            break;
@@ -1779,6 +1870,20 @@ static void usbredir_interrupt_receiving_status(void *priv, uint64_t id,
 static void usbredir_bulk_streams_status(void *priv, uint64_t id,
    struct usb_redir_bulk_streams_status_header *bulk_streams_status)
 {
+#if USBREDIR_VERSION >= 0x000700
+    USBRedirDevice *dev = priv;
+
+    if (bulk_streams_status->status == usb_redir_success) {
+        DPRINTF("bulk streams status %d eps %08x\n",
+                bulk_streams_status->status, bulk_streams_status->endpoints);
+    } else {
+        ERROR("bulk streams %s failed status %d eps %08x\n",
+              (bulk_streams_status->no_streams == 0) ? "free" : "alloc",
+              bulk_streams_status->status, bulk_streams_status->endpoints);
+        ERROR("usb-redir-host does not provide streams, disconnecting\n");
+        usbredir_reject_device(dev);
+    }
+#endif
 }

 static void usbredir_bulk_receiving_status(void *priv, uint64_t id,
@@ -1850,8 +1955,8 @@ static void usbredir_bulk_packet(void *priv, uint64_t id,
    int len = (bulk_packet->length_high << 16) | bulk_packet->length;
    USBPacket *p;

-    DPRINTF("bulk-in status %d ep %02X len %d id %"PRIu64"\n",
-            bulk_packet->status, ep, len, id);
+    DPRINTF("bulk-in status %d ep %02X stream %u len %d id %"PRIu64"\n",
+            bulk_packet->status, ep, bulk_packet->stream_id, len, id);

    p = usbredir_find_packet_by_id(dev, ep, id);
    if (p) {
@@ -2165,6 +2270,23 @@ static bool usbredir_bulk_receiving_needed(void *priv)
    return endp->bulk_receiving_started;
 }

+static const VMStateDescription usbredir_stream_vmstate = {
+    .name = "usb-redir-ep/stream-state",
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .fields = (VMStateField[]) {
+        VMSTATE_UINT32(max_streams, struct endp_data),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
+static bool usbredir_stream_needed(void *priv)
+{
+    struct endp_data *endp = priv;
+
+    return endp->max_streams;
+}
+
 static const VMStateDescription usbredir_ep_vmstate = {
    .name = "usb-redir-ep",
    .version_id = 1,
@@ -2196,6 +2318,9 @@ static const VMStateDescription usbredir_ep_vmstate = {
        {
            .vmsd = &usbredir_bulk_receiving_vmstate,
            .needed = usbredir_bulk_receiving_needed,
+        }, {
+            .vmsd = &usbredir_stream_vmstate,
+            .needed = usbredir_stream_needed,
        }, {
            /* empty */
        }
@@ -2361,6 +2486,8 @@ static void usbredir_class_initfn(ObjectClass *klass, void *data)
    uc->handle_control = usbredir_handle_control;
    uc->flush_ep_queue = usbredir_flush_ep_queue;
    uc->ep_stopped     = usbredir_ep_stopped;
+    uc->alloc_streams  = usbredir_alloc_streams;
+    uc->free_streams   = usbredir_free_streams;
    dc->vmsd           = &usbredir_vmstate;
    dc->props          = usbredir_properties;
    set_bit(DEVICE_CATEGORY_MISC, dc->categories);
--- a/include/hw/input/hid.h
+++ b/include/hw/input/hid.h
@@ -2,7 +2,6 @@
 #define QEMU_HID_H

 #include "migration/vmstate.h"
-#include "ui/input.h"

 #define HID_MOUSE     1
 #define HID_TABLET    2
@@ -23,6 +22,7 @@ typedef void (*HIDEventFunc)(HIDState *s);
 typedef struct HIDMouseState {
    HIDPointerEvent queue[QUEUE_LENGTH];
    int mouse_grabbed;
+    QEMUPutMouseEntry *eh_entry;
 } HIDMouseState;

 typedef struct HIDKeyboardState {
@@ -31,6 +31,7 @@ typedef struct HIDKeyboardState {
    uint8_t leds;
    uint8_t key[16];
    int32_t keys;
+    QEMUPutKbdEntry *eh_entry;
 } HIDKeyboardState;

 struct HIDState {
@@ -46,7 +47,6 @@ struct HIDState {
    bool idle_pending;
    QEMUTimer *idle_timer;
    HIDEventFunc event;
-    QemuInputHandlerState *s;
 };

 void hid_init(HIDState *hs, int kind, HIDEventFunc event);
--- a/include/ui/input.h
+++ b/include/ui/input.h
@@ -29,9 +29,6 @@ QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev,
 void qemu_input_handler_activate(QemuInputHandlerState *s);
 void qemu_input_handler_deactivate(QemuInputHandlerState *s);
 void qemu_input_handler_unregister(QemuInputHandlerState *s);
-void qemu_input_handler_bind(QemuInputHandlerState *s,
-                             const char *device_id, int head,
-                             Error **errp);
 void qemu_input_event_send(QemuConsole *src, InputEvent *evt);
 void qemu_input_event_sync(void);

@@ -39,7 +36,6 @@ InputEvent *qemu_input_event_new_key(KeyValue *key, bool down);
 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down);
 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down);
 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down);
-int qemu_input_key_number_to_qcode(uint8_t nr);
 int qemu_input_key_value_to_number(const KeyValue *value);
 int qemu_input_key_value_to_qcode(const KeyValue *value);
 int qemu_input_key_value_to_scancode(const KeyValue *value, bool down,
--- a/2
+++ b/2
@@ -1050,7 +1050,7 @@ gd_update(int x, int y, int w, int h) "x=%d, y=%d, w=%d, h=%d"
 gd_key_event(int gdk_keycode, int qemu_keycode, const char *action) "translated GDK keycode %d to QEMU keycode %d (%s)"

 # ui/input.c
-input_event_key_number(int conidx, int number, const char *qcode, bool down) "con %d, key number 0x%x [%s], down %d"
+input_event_key_number(int conidx, int number, bool down) "con %d, key number 0x%x, down %d"
 input_event_key_qcode(int conidx, const char *qcode, bool down) "con %d, key qcode %s, down %d"
 input_event_btn(int conidx, const char *btn, bool down) "con %d, button %s, down %d"
 input_event_rel(int conidx, const char *axis, int value) "con %d, axis %s, value %d"
--- a/ui/curses.c
+++ b/ui/curses.c
@@ -288,8 +288,8 @@ static void curses_refresh(DisplayChangeListener *dcl)
                qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, true);
            }

-            qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, true);
-            qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, false);
+            qemu_input_event_send_key_number(NULL, keycode, true);
+            qemu_input_event_send_key_number(NULL, keycode, false);

            if (keycode & ALTGR) {
                qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, false);
--- a/ui/input-keymap.c
+++ b/ui/input-keymap.c
@@ -13,8 +13,6 @@ static const int qcode_to_number[] = {
    [Q_KEY_CODE_CTRL] = 0x1d,
    [Q_KEY_CODE_CTRL_R] = 0x9d,

-    [Q_KEY_CODE_META_L] = 0xdb,
-    [Q_KEY_CODE_META_R] = 0xdc,
    [Q_KEY_CODE_MENU] = 0xdd,

    [Q_KEY_CODE_ESC] = 0x01,
@@ -131,7 +129,7 @@ static const int qcode_to_number[] = {
    [Q_KEY_CODE_MAX] = 0,
 };

-static int number_to_qcode[0x100];
+static int number_to_qcode[0xff];

 int qemu_input_key_value_to_number(const KeyValue *value)
 {
@@ -143,7 +141,7 @@ int qemu_input_key_value_to_number(const KeyValue *value)
    }
 }

-int qemu_input_key_number_to_qcode(uint8_t nr)
+int qemu_input_key_value_to_qcode(const KeyValue *value)
 {
    static int first = true;

@@ -157,16 +155,11 @@ int qemu_input_key_number_to_qcode(uint8_t nr)
        }
    }

-    return number_to_qcode[nr];
-}
-
-int qemu_input_key_value_to_qcode(const KeyValue *value)
-{
    if (value->kind == KEY_VALUE_KIND_QCODE) {
        return value->qcode;
    } else {
        assert(value->kind == KEY_VALUE_KIND_NUMBER);
-        return qemu_input_key_number_to_qcode(value->number);
+        return number_to_qcode[value->number];
    }
 }

--- a/ui/input.c
+++ b/ui/input.c
@@ -1,4 +1,3 @@
-#include "hw/qdev.h"
 #include "sysemu/sysemu.h"
 #include "qapi-types.h"
 #include "qmp-commands.h"
@@ -11,7 +10,6 @@ struct QemuInputHandlerState {
    QemuInputHandler  *handler;
    int               id;
    int               events;
-    QemuConsole       *con;
    QTAILQ_ENTRY(QemuInputHandlerState) node;
 };
 static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
@@ -55,46 +53,12 @@ void qemu_input_handler_unregister(QemuInputHandlerState *s)
    qemu_input_check_mode_change();
 }

-void qemu_input_handler_bind(QemuInputHandlerState *s,
-                             const char *device_id, int head,
-                             Error **errp)
-{
-    DeviceState *dev;
-    QemuConsole *con;
-
-    dev = qdev_find_recursive(sysbus_get_default(), device_id);
-    if (dev == NULL) {
-        error_set(errp, QERR_DEVICE_NOT_FOUND, device_id);
-        return;
-    }
-
-    con = qemu_console_lookup_by_device(dev, head);
-    if (con == NULL) {
-        error_setg(errp, "Device %s is not bound to a QemuConsole", device_id);
-        return;
-    }
-
-    s->con = con;
-}
-
 static QemuInputHandlerState*
-qemu_input_find_handler(uint32_t mask, QemuConsole *con)
+qemu_input_find_handler(uint32_t mask)
 {
    QemuInputHandlerState *s;

    QTAILQ_FOREACH(s, &handlers, node) {
-        if (s->con == NULL || s->con != con) {
-            continue;
-        }
-        if (mask & s->handler->mask) {
-            return s;
-        }
-    }
-
-    QTAILQ_FOREACH(s, &handlers, node) {
-        if (s->con != NULL) {
-            continue;
-        }
        if (mask & s->handler->mask) {
            return s;
        }
@@ -130,7 +94,7 @@ static void qemu_input_transform_abs_rotate(InputEvent *evt)
 static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
 {
    const char *name;
-    int qcode, idx = -1;
+    int idx = -1;

    if (src) {
        idx = qemu_console_get_index(src);
@@ -139,10 +103,8 @@ static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
    case INPUT_EVENT_KIND_KEY:
        switch (evt->key->key->kind) {
        case KEY_VALUE_KIND_NUMBER:
-            qcode = qemu_input_key_number_to_qcode(evt->key->key->number);
-            name = QKeyCode_lookup[qcode];
            trace_input_event_key_number(idx, evt->key->key->number,
-                                         name, evt->key->down);
+                                         evt->key->down);
            break;
        case KEY_VALUE_KIND_QCODE:
            name = QKeyCode_lookup[evt->key->key->qcode];
@@ -187,7 +149,7 @@ void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
    }

    /* send event */
-    s = qemu_input_find_handler(1 << evt->kind, src);
+    s = qemu_input_find_handler(1 << evt->kind);
    if (!s) {
        return;
    }
@@ -288,8 +250,7 @@ bool qemu_input_is_absolute(void)
 {
    QemuInputHandlerState *s;

-    s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS,
-                                NULL);
+    s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS);
    return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
 }

--- a/ui/sdl2.c
+++ b/ui/sdl2.c
@@ -190,33 +190,30 @@ static void sdl_switch(DisplayChangeListener *dcl,
    }
 }

-static void reset_keys(struct sdl2_state *scon)
+static void reset_keys(void)
 {
-    QemuConsole *con = scon ? scon->dcl.con : NULL;
    int i;

    for (i = 0; i < 256; i++) {
        if (modifiers_state[i]) {
            int qcode = sdl2_scancode_to_qcode[i];
-            qemu_input_event_send_key_qcode(con, qcode, false);
+            qemu_input_event_send_key_qcode(NULL, qcode, false);
            modifiers_state[i] = 0;
        }
    }
 }

-static void sdl_process_key(struct sdl2_state *scon,
-                            SDL_KeyboardEvent *ev)
+static void sdl_process_key(SDL_KeyboardEvent *ev)
 {
    int qcode = sdl2_scancode_to_qcode[ev->keysym.scancode];
-    QemuConsole *con = scon ? scon->dcl.con : NULL;

    switch (ev->keysym.scancode) {
 #if 0
    case SDL_SCANCODE_NUMLOCKCLEAR:
    case SDL_SCANCODE_CAPSLOCK:
        /* SDL does not send the key up event, so we generate it */
-        qemu_input_event_send_key_qcode(con, qcode, true);
-        qemu_input_event_send_key_qcode(con, qcode, false);
+        qemu_input_event_send_key_qcode(NULL, qcode, true);
+        qemu_input_event_send_key_qcode(NULL, qcode, false);
        return;
 #endif
    case SDL_SCANCODE_LCTRL:
@@ -234,7 +231,7 @@ static void sdl_process_key(struct sdl2_state *scon,
        }
        /* fall though */
    default:
-        qemu_input_event_send_key_qcode(con, qcode,
+        qemu_input_event_send_key_qcode(NULL, qcode,
                                        ev->type == SDL_KEYDOWN);
    }
 }
@@ -509,7 +506,7 @@ static void handle_keydown(SDL_Event *ev)
        }
    }
    if (!gui_keysym) {
-        sdl_process_key(scon, &ev->key);
+        sdl_process_key(&ev->key);
    }
 }

@@ -534,13 +531,13 @@ static void handle_keyup(SDL_Event *ev)
            }
            /* SDL does not send back all the modifiers key, so we must
             * correct it. */
-            reset_keys(scon);
+            reset_keys();
            return;
        }
        gui_keysym = 0;
    }
    if (!gui_keysym) {
-        sdl_process_key(scon, &ev->key);
+        sdl_process_key(&ev->key);
    }
 }
Author	SHA1	Message	Date
Hans de Goede	8d1bd3c901	usb-host-libusb: Set stream id when submitting bulk-stream transfers Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Hans de Goede	56a9f18051	usb-host-libusb: Add alloc / free streams ops Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Hans de Goede	b664b80f19	usb-host-libusb: Fill in endpoint max_streams when available Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Hans de Goede	19e8393170	usb-redir: Add support for bulk streams Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Gerd Hoffmann	22513a9b44	usb-mtp: handle usb_mtp_get_object failure Cc: Dr. David Alan Gilbert <dgilbert@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Gerd Hoffmann	68206d7342	usb-mtp: handle lseek failure Cc: Dr. David Alan Gilbert <dgilbert@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Gerd Hoffmann	36084d7e31	usb-mtp: use bool to track MTPObject init status Stop setting nchildren to -1. Use separate bool variable to track whenever we've already fetched the child objects instead. Also make nchildren unsigned. Cc: Dr. David Alan Gilbert <dgilbert@redhat.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Gerd Hoffmann	f995523582	xhci: add xhci_get_flag Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Gerd Hoffmann	058fdcf52c	xhci: add endpoint cap on express bus only Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:07 +02:00
Gerd Hoffmann	463c534db5	xhci: child detach fix xhci_child_detach() zaps the wrong slot when unplugging a device connected via usb-hub: Instead of the device's slot the slot of the usb-hub is used. Fix it. https://bugzilla.redhat.com/show_bug.cgi?id=1075846 Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> Reviewed-by: Gonglei <arei.gonglei@huawei.com>	2014-05-26 08:41:07 +02:00