[Qemu-devel] [PULL 00/32] usb patch queue

[Qemu-devel] [PULL 00/32] usb patch queue

[Gerd Hoffmann]

  Hi,

Time to flush the pretty full usb patch queue, with alot of patches, all
posted to the list before xmas.  A large part of it are performance
improvements and and correctness fixes for ehci+uhci from Hans.  Also
some ehci sysbus bits and little fixes+cleanups here and there.

please pull,
  Gerd

The following changes since commit 8e4a424b305e29dc0e454f52df3b35577f342975:

  Revert "virtio-pci: replace byte swap hack" (2013-01-06 18:30:17 +0000)

are available in the git repository at:
  git://git.kraxel.org/qemu usb.75

Andreas Färber (3):
      usb/ehci: Clean up SysBus and PCI EHCI split
      usb/ehci: Move capsbase and opregbase into SysBus EHCI class
      usb/ehci: Add SysBus EHCI device for Exynos4210

Gerd Hoffmann (2):
      xhci: call set-address with dummy usbpacket
      uhci: stop using portio lists

Hans de Goede (26):
      ehci: Add a ehci_writeback_async_complete_packet helper function
      ehci: Add ehci_verify_qh and ehci_verify_qtd helper functions
      ehci: Verify guest does not change the token of inflight qtd-s
      ehci: Move get / put_dwords upwards
      ehci: writeback_async_complete_packet: verify qh and qtd
      ehci: Verify qtd for async completed packets
      ehci: Add an ehci_get_pid helper function
      ehci: Verify a queue's ep direction does not change
      ehci: Use uframe precision for interrupt threshold checking (v2)
      ehci: Further speedup rescanning if async schedule after raising an interrupt
      ehci: Don't call commit_irq after raising PCD
      uhci: Fix 1 ms delay in interrupt reporting to the guest
      uhci: Fix pending interrupts getting lost on migration
      uhci: Add a QH_VALID define
      uhci: Limit amount of frames processed in one go
      uhci: Maximize how many frames we catch up when behind
      hid: Change idle handling to use a timer
      usb: Fix usb_ep_find_packet_by_id
      usb: Add an usb_device_ep_stopped USBDevice method
      usbredir: Add an usbredir_stop_ep helper function
      usbredir: Add USBEP2I and I2USBEP helper macros
      usbredir: Add ep_stopped USBDevice method
      usbredir: Verify we have 32 bits bulk length cap when redirecting to xhci
      usbredir: Add usbredir_init_endpoints() helper
      usb-redir: Add debugging to bufpq save / restore
      usbredir: Add support for buffered bulk input (v2)

Liming Wang (1):
      exynos4210: Add EHCI support

 configure                  |    2 +-
 hw/exynos4210.c            |    7 +
 hw/exynos4210_gic.c        |    2 +-
 hw/hid.c                   |   43 ++-
 hw/hid.h                   |    5 +-
 hw/usb.h                   |   20 +-
 hw/usb/Makefile.objs       |    2 +-
 hw/usb/bus.c               |    8 +
 hw/usb/core.c              |    2 +-
 hw/usb/dev-hid.c           |    8 +-
 hw/usb/hcd-ehci-pci.c      |   39 +-
 hw/usb/hcd-ehci-sysbus.c   |   49 ++-
 hw/usb/hcd-ehci.c          |  347 ++++++++-----
 hw/usb/hcd-ehci.h          |   42 ++
 hw/usb/hcd-ohci.c          |   30 +-
 hw/usb/hcd-uhci.c          |  174 +++----
 hw/usb/hcd-xhci.c          |   14 +-
 hw/usb/quirks-ftdi-ids.h   | 1255 ++++++++++++++++++++++++++++++++++++++++++++
 hw/usb/quirks-pl2303-ids.h |  150 ++++++
 hw/usb/quirks.c            |   53 ++
 hw/usb/quirks.h            |  910 ++++++++++++++++++++++++++++++++
 hw/usb/redirect.c          |  449 ++++++++++++++--
 trace-events               |    2 -
 23 files changed, 3280 insertions(+), 333 deletions(-)
 create mode 100644 hw/usb/quirks-ftdi-ids.h
 create mode 100644 hw/usb/quirks-pl2303-ids.h
 create mode 100644 hw/usb/quirks.c
 create mode 100644 hw/usb/quirks.h

[Qemu-devel] [PATCH 01/32] ehci: Add a ehci_writeback_async_complete_packet helper function

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Also drop the warning printf, which was there mainly because this was an
untested code path (as the previous bug fixes to it show), but that no
longer is the case now :)

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   28 +++++++++++++++++-----------
 1 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 7536837..218b1d7 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -438,6 +438,22 @@ static inline bool ehci_periodic_enabled(EHCIState *s)
     return ehci_enabled(s) && (s->usbcmd & USBCMD_PSE);
 }
 
+/* Finish executing and writeback a packet outside of the regular
+   fetchqh -> fetchqtd -> execute -> writeback cycle */
+static void ehci_writeback_async_complete_packet(EHCIPacket *p)
+{
+    EHCIQueue *q = p->queue;
+    int state;
+
+    state = ehci_get_state(q->ehci, q->async);
+    ehci_state_executing(q);
+    ehci_state_writeback(q); /* Frees the packet! */
+    if (!(q->qh.token & QTD_TOKEN_HALT)) {
+        ehci_state_advqueue(q);
+    }
+    ehci_set_state(q->ehci, q->async, state);
+}
+
 /* packet management */
 
 static EHCIPacket *ehci_alloc_packet(EHCIQueue *q)
@@ -455,17 +471,7 @@ static EHCIPacket *ehci_alloc_packet(EHCIQueue *q)
 static void ehci_free_packet(EHCIPacket *p)
 {
     if (p->async == EHCI_ASYNC_FINISHED) {
-        EHCIQueue *q = p->queue;
-        int state = ehci_get_state(q->ehci, q->async);
-        /* This is a normal, but rare condition (cancel racing completion) */
-        fprintf(stderr, "EHCI: Warning packet completed but not processed\n");
-        ehci_state_executing(q);
-        ehci_state_writeback(q);
-        if (!(q->qh.token & QTD_TOKEN_HALT)) {
-            ehci_state_advqueue(q);
-        }
-        ehci_set_state(q->ehci, q->async, state);
-        /* state_writeback recurses into us with async == EHCI_ASYNC_NONE!! */
+        ehci_writeback_async_complete_packet(p);
         return;
     }
     trace_usb_ehci_packet_action(p->queue, p, "free");
-- 
1.7.1

[Qemu-devel] [PATCH 02/32] ehci: Add ehci_verify_qh and ehci_verify_qtd helper functions

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   51 +++++++++++++++++++++++++++++++++++----------------
 1 files changed, 35 insertions(+), 16 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 218b1d7..0d31597 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -438,6 +438,36 @@ static inline bool ehci_periodic_enabled(EHCIState *s)
     return ehci_enabled(s) && (s->usbcmd & USBCMD_PSE);
 }
 
+static bool ehci_verify_qh(EHCIQueue *q, EHCIqh *qh)
+{
+    uint32_t devaddr = get_field(qh->epchar, QH_EPCHAR_DEVADDR);
+    uint32_t endp    = get_field(qh->epchar, QH_EPCHAR_EP);
+    if ((devaddr != get_field(q->qh.epchar, QH_EPCHAR_DEVADDR)) ||
+        (endp    != get_field(q->qh.epchar, QH_EPCHAR_EP)) ||
+        (qh->current_qtd != q->qh.current_qtd) ||
+        (q->async && qh->next_qtd != q->qh.next_qtd) ||
+        (memcmp(&qh->altnext_qtd, &q->qh.altnext_qtd,
+                                 7 * sizeof(uint32_t)) != 0) ||
+        (q->dev != NULL && q->dev->addr != devaddr)) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+static bool ehci_verify_qtd(EHCIPacket *p, EHCIqtd *qtd)
+{
+    if (p->qtdaddr != p->queue->qtdaddr ||
+        (p->queue->async && !NLPTR_TBIT(p->qtd.next) &&
+            (p->qtd.next != qtd->next)) ||
+        (!NLPTR_TBIT(p->qtd.altnext) && (p->qtd.altnext != qtd->altnext)) ||
+        p->qtd.bufptr[0] != qtd->bufptr[0]) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
 /* Finish executing and writeback a packet outside of the regular
    fetchqh -> fetchqtd -> execute -> writeback cycle */
 static void ehci_writeback_async_complete_packet(EHCIPacket *p)
@@ -1557,8 +1587,8 @@ out:
 
 static EHCIQueue *ehci_state_fetchqh(EHCIState *ehci, int async)
 {
+    uint32_t entry;
     EHCIPacket *p;
-    uint32_t entry, devaddr, endp;
     EHCIQueue *q;
     EHCIqh qh;
 
@@ -1588,15 +1618,7 @@ static EHCIQueue *ehci_state_fetchqh(EHCIState *ehci, int async)
      * The overlay area of the qh should never be changed by the guest,
      * except when idle, in which case the reset is a nop.
      */
-    devaddr = get_field(qh.epchar, QH_EPCHAR_DEVADDR);
-    endp    = get_field(qh.epchar, QH_EPCHAR_EP);
-    if ((devaddr != get_field(q->qh.epchar, QH_EPCHAR_DEVADDR)) ||
-        (endp    != get_field(q->qh.epchar, QH_EPCHAR_EP)) ||
-        (qh.current_qtd != q->qh.current_qtd) ||
-        (q->async && qh.next_qtd != q->qh.next_qtd) ||
-        (memcmp(&qh.altnext_qtd, &q->qh.altnext_qtd,
-                                 7 * sizeof(uint32_t)) != 0) ||
-        (q->dev != NULL && q->dev->addr != devaddr)) {
+    if (!ehci_verify_qh(q, &qh)) {
         if (ehci_reset_queue(q) > 0) {
             ehci_trace_guest_bug(ehci, "guest updated active QH");
         }
@@ -1610,7 +1632,8 @@ static EHCIQueue *ehci_state_fetchqh(EHCIState *ehci, int async)
     }
 
     if (q->dev == NULL) {
-        q->dev = ehci_find_device(q->ehci, devaddr);
+        q->dev = ehci_find_device(q->ehci,
+                                  get_field(q->qh.epchar, QH_EPCHAR_DEVADDR));
     }
 
     if (p && p->async == EHCI_ASYNC_FINISHED) {
@@ -1768,11 +1791,7 @@ static int ehci_state_fetchqtd(EHCIQueue *q)
 
     p = QTAILQ_FIRST(&q->packets);
     if (p != NULL) {
-        if (p->qtdaddr != q->qtdaddr ||
-            (q->async && !NLPTR_TBIT(p->qtd.next) &&
-                (p->qtd.next != qtd.next)) ||
-            (!NLPTR_TBIT(p->qtd.altnext) && (p->qtd.altnext != qtd.altnext)) ||
-            p->qtd.bufptr[0] != qtd.bufptr[0]) {
+        if (!ehci_verify_qtd(p, &qtd)) {
             ehci_cancel_queue(q);
             ehci_trace_guest_bug(q->ehci, "guest updated active QH or qTD");
             p = NULL;
-- 
1.7.1

[Qemu-devel] [PATCH 03/32] ehci: Verify guest does not change the token of inflight qtd-s

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

This is not allowed, except for clearing active on cancellation, so don't
warn when the new token does not have its active bit set.

This unifies the cancellation path for modified qtd-s, and prepares
ehci_verify_qtd to be used ad an extra check inside
ehci_writeback_async_complete_packet().

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   10 ++++------
 1 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 0d31597..04301ce 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -461,6 +461,7 @@ static bool ehci_verify_qtd(EHCIPacket *p, EHCIqtd *qtd)
         (p->queue->async && !NLPTR_TBIT(p->qtd.next) &&
             (p->qtd.next != qtd->next)) ||
         (!NLPTR_TBIT(p->qtd.altnext) && (p->qtd.altnext != qtd->altnext)) ||
+        p->qtd.token != qtd->token ||
         p->qtd.bufptr[0] != qtd->bufptr[0]) {
         return false;
     } else {
@@ -1793,7 +1794,9 @@ static int ehci_state_fetchqtd(EHCIQueue *q)
     if (p != NULL) {
         if (!ehci_verify_qtd(p, &qtd)) {
             ehci_cancel_queue(q);
-            ehci_trace_guest_bug(q->ehci, "guest updated active QH or qTD");
+            if (qtd.token & QTD_TOKEN_ACTIVE) {
+                ehci_trace_guest_bug(q->ehci, "guest updated active qTD");
+            }
             p = NULL;
         } else {
             p->qtd = qtd;
@@ -1802,11 +1805,6 @@ static int ehci_state_fetchqtd(EHCIQueue *q)
     }
 
     if (!(qtd.token & QTD_TOKEN_ACTIVE)) {
-        if (p != NULL) {
-            /* transfer canceled by guest (clear active) */
-            ehci_cancel_queue(q);
-            p = NULL;
-        }
         ehci_set_state(q->ehci, q->async, EST_HORIZONTALQH);
     } else if (p != NULL) {
         switch (p->async) {
-- 
1.7.1

[Qemu-devel] [PATCH 04/32] ehci: Move get / put_dwords upwards

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

No other changes.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   84 ++++++++++++++++++++++++++--------------------------
 1 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 04301ce..934af55 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -438,6 +438,48 @@ static inline bool ehci_periodic_enabled(EHCIState *s)
     return ehci_enabled(s) && (s->usbcmd & USBCMD_PSE);
 }
 
+/* Get an array of dwords from main memory */
+static inline int get_dwords(EHCIState *ehci, uint32_t addr,
+                             uint32_t *buf, int num)
+{
+    int i;
+
+    if (!ehci->dma) {
+        ehci_raise_irq(ehci, USBSTS_HSE);
+        ehci->usbcmd &= ~USBCMD_RUNSTOP;
+        trace_usb_ehci_dma_error();
+        return -1;
+    }
+
+    for (i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
+        dma_memory_read(ehci->dma, addr, buf, sizeof(*buf));
+        *buf = le32_to_cpu(*buf);
+    }
+
+    return num;
+}
+
+/* Put an array of dwords in to main memory */
+static inline int put_dwords(EHCIState *ehci, uint32_t addr,
+                             uint32_t *buf, int num)
+{
+    int i;
+
+    if (!ehci->dma) {
+        ehci_raise_irq(ehci, USBSTS_HSE);
+        ehci->usbcmd &= ~USBCMD_RUNSTOP;
+        trace_usb_ehci_dma_error();
+        return -1;
+    }
+
+    for (i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
+        uint32_t tmp = cpu_to_le32(*buf);
+        dma_memory_write(ehci->dma, addr, &tmp, sizeof(tmp));
+    }
+
+    return num;
+}
+
 static bool ehci_verify_qh(EHCIQueue *q, EHCIqh *qh)
 {
     uint32_t devaddr = get_field(qh->epchar, QH_EPCHAR_DEVADDR);
@@ -1054,48 +1096,6 @@ static void ehci_opreg_write(void *ptr, hwaddr addr,
                                 *mmio, old);
 }
 
-/* Get an array of dwords from main memory */
-static inline int get_dwords(EHCIState *ehci, uint32_t addr,
-                             uint32_t *buf, int num)
-{
-    int i;
-
-    if (!ehci->dma) {
-        ehci_raise_irq(ehci, USBSTS_HSE);
-        ehci->usbcmd &= ~USBCMD_RUNSTOP;
-        trace_usb_ehci_dma_error();
-        return -1;
-    }
-
-    for(i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
-        dma_memory_read(ehci->dma, addr, buf, sizeof(*buf));
-        *buf = le32_to_cpu(*buf);
-    }
-
-    return num;
-}
-
-/* Put an array of dwords in to main memory */
-static inline int put_dwords(EHCIState *ehci, uint32_t addr,
-                             uint32_t *buf, int num)
-{
-    int i;
-
-    if (!ehci->dma) {
-        ehci_raise_irq(ehci, USBSTS_HSE);
-        ehci->usbcmd &= ~USBCMD_RUNSTOP;
-        trace_usb_ehci_dma_error();
-        return -1;
-    }
-
-    for(i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
-        uint32_t tmp = cpu_to_le32(*buf);
-        dma_memory_write(ehci->dma, addr, &tmp, sizeof(tmp));
-    }
-
-    return num;
-}
-
 /*
  *  Write the qh back to guest physical memory.  This step isn't
  *  in the EHCI spec but we need to do it since we don't share
-- 
1.7.1

[Qemu-devel] [PATCH 05/32] ehci: writeback_async_complete_packet: verify qh and qtd

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   14 ++++++++++++++
 1 files changed, 14 insertions(+), 0 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 934af55..96a0144 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -192,6 +192,7 @@ static int ehci_state_executing(EHCIQueue *q);
 static int ehci_state_writeback(EHCIQueue *q);
 static int ehci_state_advqueue(EHCIQueue *q);
 static int ehci_fill_queue(EHCIPacket *p);
+static void ehci_free_packet(EHCIPacket *p);
 
 static const char *nr2str(const char **n, size_t len, uint32_t nr)
 {
@@ -516,8 +517,21 @@ static bool ehci_verify_qtd(EHCIPacket *p, EHCIqtd *qtd)
 static void ehci_writeback_async_complete_packet(EHCIPacket *p)
 {
     EHCIQueue *q = p->queue;
+    EHCIqtd qtd;
+    EHCIqh qh;
     int state;
 
+    /* Verify the qh + qtd, like we do when going through fetchqh & fetchqtd */
+    get_dwords(q->ehci, NLPTR_GET(q->qhaddr),
+               (uint32_t *) &qh, sizeof(EHCIqh) >> 2);
+    get_dwords(q->ehci, NLPTR_GET(q->qtdaddr),
+               (uint32_t *) &qtd, sizeof(EHCIqtd) >> 2);
+    if (!ehci_verify_qh(q, &qh) || !ehci_verify_qtd(p, &qtd)) {
+        p->async = EHCI_ASYNC_INITIALIZED;
+        ehci_free_packet(p);
+        return;
+    }
+
     state = ehci_get_state(q->ehci, q->async);
     ehci_state_executing(q);
     ehci_state_writeback(q); /* Frees the packet! */
-- 
1.7.1

[Qemu-devel] [PATCH 06/32] ehci: Verify qtd for async completed packets

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Remove the short-circuiting of fetchqtd in fetchqh, so that the
qtd gets properly verified before completing the transaction.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   15 +--------------
 1 files changed, 1 insertions(+), 14 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 96a0144..dde2ff3 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -1603,7 +1603,6 @@ out:
 static EHCIQueue *ehci_state_fetchqh(EHCIState *ehci, int async)
 {
     uint32_t entry;
-    EHCIPacket *p;
     EHCIQueue *q;
     EHCIqh qh;
 
@@ -1612,7 +1611,6 @@ static EHCIQueue *ehci_state_fetchqh(EHCIState *ehci, int async)
     if (NULL == q) {
         q = ehci_alloc_queue(ehci, entry, async);
     }
-    p = QTAILQ_FIRST(&q->packets);
 
     q->seen++;
     if (q->seen > 1) {
@@ -1637,7 +1635,6 @@ static EHCIQueue *ehci_state_fetchqh(EHCIState *ehci, int async)
         if (ehci_reset_queue(q) > 0) {
             ehci_trace_guest_bug(ehci, "guest updated active QH");
         }
-        p = NULL;
     }
     q->qh = qh;
 
@@ -1651,13 +1648,6 @@ static EHCIQueue *ehci_state_fetchqh(EHCIState *ehci, int async)
                                   get_field(q->qh.epchar, QH_EPCHAR_DEVADDR));
     }
 
-    if (p && p->async == EHCI_ASYNC_FINISHED) {
-        /* I/O finished -- continue processing queue */
-        trace_usb_ehci_packet_action(p->queue, p, "complete");
-        ehci_set_state(ehci, async, EST_EXECUTING);
-        goto out;
-    }
-
     if (async && (q->qh.epchar & QH_EPCHAR_H)) {
 
         /*  EHCI spec version 1.0 Section 4.8.3 & 4.10.1 */
@@ -1834,10 +1824,7 @@ static int ehci_state_fetchqtd(EHCIQueue *q)
             ehci_set_state(q->ehci, q->async, EST_HORIZONTALQH);
             break;
         case EHCI_ASYNC_FINISHED:
-            /*
-             * We get here when advqueue moves to a packet which is already
-             * finished, which can happen with packets queued up by fill_queue
-             */
+            /* Complete executing of the packet */
             ehci_set_state(q->ehci, q->async, EST_EXECUTING);
             break;
         }
-- 
1.7.1

[Qemu-devel] [PATCH 07/32] ehci: Add an ehci_get_pid helper function

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   32 ++++++++++++++++----------------
 1 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index dde2ff3..dae414a 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -481,6 +481,21 @@ static inline int put_dwords(EHCIState *ehci, uint32_t addr,
     return num;
 }
 
+static int ehci_get_pid(EHCIqtd *qtd)
+{
+    switch (get_field(qtd->token, QTD_TOKEN_PID)) {
+    case 0:
+        return USB_TOKEN_OUT;
+    case 1:
+        return USB_TOKEN_IN;
+    case 2:
+        return USB_TOKEN_SETUP;
+    default:
+        fprintf(stderr, "bad token\n");
+        return 0;
+    }
+}
+
 static bool ehci_verify_qh(EHCIQueue *q, EHCIqh *qh)
 {
     uint32_t devaddr = get_field(qh->epchar, QH_EPCHAR_DEVADDR);
@@ -1352,22 +1367,7 @@ static int ehci_execute(EHCIPacket *p, const char *action)
         return -1;
     }
 
-    p->pid = (p->qtd.token & QTD_TOKEN_PID_MASK) >> QTD_TOKEN_PID_SH;
-    switch (p->pid) {
-    case 0:
-        p->pid = USB_TOKEN_OUT;
-        break;
-    case 1:
-        p->pid = USB_TOKEN_IN;
-        break;
-    case 2:
-        p->pid = USB_TOKEN_SETUP;
-        break;
-    default:
-        fprintf(stderr, "bad token\n");
-        break;
-    }
-
+    p->pid = ehci_get_pid(&p->qtd);
     endp = get_field(p->queue->qh.epchar, QH_EPCHAR_EP);
     ep = usb_ep_get(p->queue->dev, p->pid, endp);
 
-- 
1.7.1

[Qemu-devel] [PATCH 08/32] ehci: Verify a queue's ep direction does not change

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

ehci_fill_queue assumes that there is a one on one relationship between an ep
and a qh, this patch adds a check to ensure this.

Note I don't expect this to ever trigger, this is just something I noticed
the guest might do while working on other stuff. The only way this check can
trigger is if a guest mixes in and out qtd-s in a single qh for a non
control ep.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   19 +++++++++++++++++++
 hw/usb/hcd-ehci.h |    1 +
 2 files changed, 20 insertions(+), 0 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index dae414a..5d314a0 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -527,6 +527,19 @@ static bool ehci_verify_qtd(EHCIPacket *p, EHCIqtd *qtd)
     }
 }
 
+static bool ehci_verify_pid(EHCIQueue *q, EHCIqtd *qtd)
+{
+    int ep  = get_field(q->qh.epchar, QH_EPCHAR_EP);
+    int pid = ehci_get_pid(qtd);
+
+    /* Note the pid changing is normal for ep 0 (the control ep) */
+    if (q->last_pid && ep != 0 && pid != q->last_pid) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
 /* Finish executing and writeback a packet outside of the regular
    fetchqh -> fetchqtd -> execute -> writeback cycle */
 static void ehci_writeback_async_complete_packet(EHCIPacket *p)
@@ -634,6 +647,7 @@ static int ehci_reset_queue(EHCIQueue *q)
     packets = ehci_cancel_queue(q);
     q->dev = NULL;
     q->qtdaddr = 0;
+    q->last_pid = 0;
     return packets;
 }
 
@@ -1368,6 +1382,7 @@ static int ehci_execute(EHCIPacket *p, const char *action)
     }
 
     p->pid = ehci_get_pid(&p->qtd);
+    p->queue->last_pid = p->pid;
     endp = get_field(p->queue->qh.epchar, QH_EPCHAR_EP);
     ep = usb_ep_get(p->queue->dev, p->pid, endp);
 
@@ -1883,6 +1898,10 @@ static int ehci_fill_queue(EHCIPacket *p)
         if (!(qtd.token & QTD_TOKEN_ACTIVE)) {
             break;
         }
+        if (!ehci_verify_pid(q, &qtd)) {
+            ehci_trace_guest_bug(q->ehci, "guest queued token with wrong pid");
+            break;
+        }
         p = ehci_alloc_packet(q);
         p->qtdaddr = qtdaddr;
         p->qtd = qtd;
diff --git a/hw/usb/hcd-ehci.h b/hw/usb/hcd-ehci.h
index e35144d..14ee3be 100644
--- a/hw/usb/hcd-ehci.h
+++ b/hw/usb/hcd-ehci.h
@@ -248,6 +248,7 @@ struct EHCIQueue {
     EHCIqh qh;             /* copy of current QH (being worked on) */
     uint32_t qhaddr;       /* address QH read from                 */
     uint32_t qtdaddr;      /* address QTD read from                */
+    int last_pid;          /* pid of last packet executed          */
     USBDevice *dev;
     QTAILQ_HEAD(pkts_head, EHCIPacket) packets;
 };
-- 
1.7.1

[Qemu-devel] [PATCH 09/32] ehci: Use uframe precision for interrupt threshold checking (v2)

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Before this patch, the following could happen:
1) Transfer completes, raises interrupt
2) .5 ms later we check if the guest has queued up any new transfers
3) We find and execute a new transfer
4) .2 ms later the new transfer completes
5) We re-run our frame_timer to write back the completion, but less then
   1 ms has passed since our last run, so frindex is not changed, so the
   interrupt threshold code delays the interrupt
6) 1 ms from the re-run our frame-timer runs again and finally delivers
   the interrupt

This leads to unnecessary large delays of interrupts, this code fixes this
by changing frindex to uframe precision and using that for interrupt threshold
control, making the interrupt fire at step 5 for guest which have low interrupt
threshold settings (like Linux).

Note that the guest still sees the frindex move in steps of 8 for migration
compatibility.

This boosts Linux read speed of a simple cheap USB thumb drive by 6 %.

Changes in v2:
-Make the guest see frindex move in steps of 8 by modifying ehci_opreg_read,
 rather then using a shadow variable

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |   70 +++++++++++++++++++++++++++++++++++-----------------
 1 files changed, 47 insertions(+), 23 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 5d314a0..efa1d77 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -109,12 +109,13 @@
 
 #define FRAME_TIMER_FREQ 1000
 #define FRAME_TIMER_NS   (1000000000 / FRAME_TIMER_FREQ)
+#define UFRAME_TIMER_NS  (FRAME_TIMER_NS / 8)
 
 #define NB_MAXINTRATE    8        // Max rate at which controller issues ints
 #define BUFF_SIZE        5*4096   // Max bytes to transfer per transaction
 #define MAX_QH           100      // Max allowable queue heads in a chain
-#define MIN_FR_PER_TICK  3        // Min frames to process when catching up
-#define PERIODIC_ACTIVE  64
+#define MIN_UFR_PER_TICK 24       /* Min frames to process when catching up */
+#define PERIODIC_ACTIVE  512      /* Micro-frames */
 
 /*  Internal periodic / asynchronous schedule state machine states
  */
@@ -955,7 +956,15 @@ static uint64_t ehci_opreg_read(void *ptr, hwaddr addr,
     EHCIState *s = ptr;
     uint32_t val;
 
-    val = s->opreg[addr >> 2];
+    switch (addr) {
+    case FRINDEX:
+        /* Round down to mult of 8, else it can go backwards on migration */
+        val = s->frindex & ~7;
+        break;
+    default:
+        val = s->opreg[addr >> 2];
+    }
+
     trace_usb_ehci_opreg_read(addr + s->opregbase, addr2str(addr), val);
     return val;
 }
@@ -1106,7 +1115,8 @@ static void ehci_opreg_write(void *ptr, hwaddr addr,
         break;
 
     case FRINDEX:
-        val &= 0x00003ff8; /* frindex is 14bits and always a multiple of 8 */
+        val &= 0x00003fff; /* frindex is 14bits */
+        s->usbsts_frindex = val;
         break;
 
     case CONFIGFLAG:
@@ -2219,16 +2229,16 @@ static void ehci_advance_periodic_state(EHCIState *ehci)
     }
 }
 
-static void ehci_update_frindex(EHCIState *ehci, int frames)
+static void ehci_update_frindex(EHCIState *ehci, int uframes)
 {
     int i;
 
-    if (!ehci_enabled(ehci)) {
+    if (!ehci_enabled(ehci) && ehci->pstate == EST_INACTIVE) {
         return;
     }
 
-    for (i = 0; i < frames; i++) {
-        ehci->frindex += 8;
+    for (i = 0; i < uframes; i++) {
+        ehci->frindex++;
 
         if (ehci->frindex == 0x00002000) {
             ehci_raise_irq(ehci, USBSTS_FLR);
@@ -2252,33 +2262,33 @@ static void ehci_frame_timer(void *opaque)
     int need_timer = 0;
     int64_t expire_time, t_now;
     uint64_t ns_elapsed;
-    int frames, skipped_frames;
+    int uframes, skipped_uframes;
     int i;
 
     t_now = qemu_get_clock_ns(vm_clock);
     ns_elapsed = t_now - ehci->last_run_ns;
-    frames = ns_elapsed / FRAME_TIMER_NS;
+    uframes = ns_elapsed / UFRAME_TIMER_NS;
 
     if (ehci_periodic_enabled(ehci) || ehci->pstate != EST_INACTIVE) {
         need_timer++;
 
-        if (frames > ehci->maxframes) {
-            skipped_frames = frames - ehci->maxframes;
-            ehci_update_frindex(ehci, skipped_frames);
-            ehci->last_run_ns += FRAME_TIMER_NS * skipped_frames;
-            frames -= skipped_frames;
-            DPRINTF("WARNING - EHCI skipped %d frames\n", skipped_frames);
+        if (uframes > (ehci->maxframes * 8)) {
+            skipped_uframes = uframes - (ehci->maxframes * 8);
+            ehci_update_frindex(ehci, skipped_uframes);
+            ehci->last_run_ns += UFRAME_TIMER_NS * skipped_uframes;
+            uframes -= skipped_uframes;
+            DPRINTF("WARNING - EHCI skipped %d uframes\n", skipped_uframes);
         }
 
-        for (i = 0; i < frames; i++) {
+        for (i = 0; i < uframes; i++) {
             /*
              * If we're running behind schedule, we should not catch up
              * too fast, as that will make some guests unhappy:
-             * 1) We must process a minimum of MIN_FR_PER_TICK frames,
+             * 1) We must process a minimum of MIN_UFR_PER_TICK frames,
              *    otherwise we will never catch up
              * 2) Process frames until the guest has requested an irq (IOC)
              */
-            if (i >= MIN_FR_PER_TICK) {
+            if (i >= MIN_UFR_PER_TICK) {
                 ehci_commit_irq(ehci);
                 if ((ehci->usbsts & USBINTR_MASK) & ehci->usbintr) {
                     break;
@@ -2288,13 +2298,15 @@ static void ehci_frame_timer(void *opaque)
                 ehci->periodic_sched_active--;
             }
             ehci_update_frindex(ehci, 1);
-            ehci_advance_periodic_state(ehci);
-            ehci->last_run_ns += FRAME_TIMER_NS;
+            if ((ehci->frindex & 7) == 0) {
+                ehci_advance_periodic_state(ehci);
+            }
+            ehci->last_run_ns += UFRAME_TIMER_NS;
         }
     } else {
         ehci->periodic_sched_active = 0;
-        ehci_update_frindex(ehci, frames);
-        ehci->last_run_ns += FRAME_TIMER_NS * frames;
+        ehci_update_frindex(ehci, uframes);
+        ehci->last_run_ns += UFRAME_TIMER_NS * uframes;
     }
 
     if (ehci->periodic_sched_active) {
@@ -2373,6 +2385,17 @@ static USBBusOps ehci_bus_ops = {
     .wakeup_endpoint = ehci_wakeup_endpoint,
 };
 
+static void usb_ehci_pre_save(void *opaque)
+{
+    EHCIState *ehci = opaque;
+    uint32_t new_frindex;
+
+    /* Round down frindex to a multiple of 8 for migration compatibility */
+    new_frindex = ehci->frindex & ~7;
+    ehci->last_run_ns -= (ehci->frindex - new_frindex) * UFRAME_TIMER_NS;
+    ehci->frindex = new_frindex;
+}
+
 static int usb_ehci_post_load(void *opaque, int version_id)
 {
     EHCIState *s = opaque;
@@ -2423,6 +2446,7 @@ const VMStateDescription vmstate_ehci = {
     .name        = "ehci-core",
     .version_id  = 2,
     .minimum_version_id  = 1,
+    .pre_save    = usb_ehci_pre_save,
     .post_load   = usb_ehci_post_load,
     .fields      = (VMStateField[]) {
         /* mmio registers */
-- 
1.7.1

[Qemu-devel] [PATCH 10/32] ehci: Further speedup rescanning if async schedule after raising an interrupt

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

I tried lowering the time between raising an interrupt and rescanning the
async schedule to see if the guest has queued a new transfer before, but
that did not have any positive effect. I now believe the cause for this is
that lowering this time made it more likely to hit the 1 ms interrupt
threshold penalty for the next packet, as described in my
"ehci: Use uframe precision for interrupt threshold checking" commit.

Now that we do interrupt threshold handling with uframe precision, futher
lowering this time from .5 to .25 ms gives an extra 15% improvement in speed
(MB/s) reading from a simple USB-2.0 thumb-drive.

While at it also properly set the int_req_by_async flag for short packet
completions.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |    5 ++++-
 1 files changed, 4 insertions(+), 1 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index efa1d77..8da4b6a 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -1347,6 +1347,9 @@ static void ehci_execute_complete(EHCIQueue *q)
         if (tbytes) {
             /* 4.15.1.2 must raise int on a short input packet */
             ehci_raise_irq(q->ehci, USBSTS_INT);
+            if (q->async) {
+                q->ehci->int_req_by_async = true;
+            }
         }
     } else {
         tbytes = 0;
@@ -2337,7 +2340,7 @@ static void ehci_frame_timer(void *opaque)
         /* If we've raised int, we speed up the timer, so that we quickly
          * notice any new packets queued up in response */
         if (ehci->int_req_by_async && (ehci->usbsts & USBSTS_INT)) {
-            expire_time = t_now + get_ticks_per_sec() / (FRAME_TIMER_FREQ * 2);
+            expire_time = t_now + get_ticks_per_sec() / (FRAME_TIMER_FREQ * 4);
             ehci->int_req_by_async = false;
         } else {
             expire_time = t_now + (get_ticks_per_sec()
-- 
1.7.1

[Qemu-devel] [PATCH 11/32] ehci: Don't call commit_irq after raising PCD

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

ehci_raise_irq(s, USBSTS_PCD), gets applied immediately so there is no need
to call commit_irq after it.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci.c |    2 --
 1 files changed, 0 insertions(+), 2 deletions(-)

diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 8da4b6a..1713394 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -757,7 +757,6 @@ static void ehci_attach(USBPort *port)
     *portsc |= PORTSC_CSC;
 
     ehci_raise_irq(s, USBSTS_PCD);
-    ehci_commit_irq(s);
 }
 
 static void ehci_detach(USBPort *port)
@@ -787,7 +786,6 @@ static void ehci_detach(USBPort *port)
     *portsc |= PORTSC_CSC;
 
     ehci_raise_irq(s, USBSTS_PCD);
-    ehci_commit_irq(s);
 }
 
 static void ehci_child_detach(USBPort *port, USBDevice *child)
-- 
1.7.1

[Qemu-devel] [PATCH 12/32] uhci: Fix 1 ms delay in interrupt reporting to the guest

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Re-arrange how we process frames / increase frnum / report pending interrupts,
to avoid a 1 ms delay in interrupt reporting to the guest. This increases
the packet throughput for cases where the guest submits a single packet,
then waits for its completion then re-submits from 500 pkts / sec to
1000 pkts / sec. This impacts for example the use of redirected / virtual
usb to serial convertors.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-uhci.c |   24 +++++++++++++-----------
 1 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/hw/usb/hcd-uhci.c b/hw/usb/hcd-uhci.c
index 2af754b..5685b9f 100644
--- a/hw/usb/hcd-uhci.c
+++ b/hw/usb/hcd-uhci.c
@@ -1191,17 +1191,7 @@ static void uhci_frame_timer(void *opaque)
         return;
     }
 
-    /* Complete the previous frame */
-    if (s->pending_int_mask) {
-        s->status2 |= s->pending_int_mask;
-        s->status  |= UHCI_STS_USBINT;
-        uhci_update_irq(s);
-    }
-    s->pending_int_mask = 0;
-
-    /* Start new frame */
-    s->frnum = (s->frnum + 1) & 0x7ff;
-
+    /* Process the current frame */
     trace_usb_uhci_frame_start(s->frnum);
 
     uhci_async_validate_begin(s);
@@ -1210,6 +1200,18 @@ static void uhci_frame_timer(void *opaque)
 
     uhci_async_validate_end(s);
 
+    /* The uhci spec says frnum reflects the frame currently being processed,
+     * and the guest must look at frnum - 1 on interrupt, so inc frnum now */
+    s->frnum = (s->frnum + 1) & 0x7ff;
+
+    /* Complete the previous frame */
+    if (s->pending_int_mask) {
+        s->status2 |= s->pending_int_mask;
+        s->status  |= UHCI_STS_USBINT;
+        uhci_update_irq(s);
+    }
+    s->pending_int_mask = 0;
+
     qemu_mod_timer(s->frame_timer, s->expire_time);
 }
 
-- 
1.7.1

[Qemu-devel] [PATCH 13/32] uhci: Fix pending interrupts getting lost on migration

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-uhci.c |    3 ++-
 1 files changed, 2 insertions(+), 1 deletions(-)

diff --git a/hw/usb/hcd-uhci.c b/hw/usb/hcd-uhci.c
index 5685b9f..e82e5cc 100644
--- a/hw/usb/hcd-uhci.c
+++ b/hw/usb/hcd-uhci.c
@@ -433,7 +433,7 @@ static int uhci_post_load(void *opaque, int version_id)
 
 static const VMStateDescription vmstate_uhci = {
     .name = "uhci",
-    .version_id = 2,
+    .version_id = 3,
     .minimum_version_id = 1,
     .minimum_version_id_old = 1,
     .post_load = uhci_post_load,
@@ -451,6 +451,7 @@ static const VMStateDescription vmstate_uhci = {
         VMSTATE_UINT8(status2, UHCIState),
         VMSTATE_TIMER(frame_timer, UHCIState),
         VMSTATE_INT64_V(expire_time, UHCIState, 2),
+        VMSTATE_UINT32_V(pending_int_mask, UHCIState, 3),
         VMSTATE_END_OF_LIST()
     }
 };
-- 
1.7.1

[Qemu-devel] [PATCH 14/32] uhci: Add a QH_VALID define

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Rather then using the magic 32 value in various places.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-uhci.c |    9 +++++----
 1 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/hw/usb/hcd-uhci.c b/hw/usb/hcd-uhci.c
index e82e5cc..d61d879 100644
--- a/hw/usb/hcd-uhci.c
+++ b/hw/usb/hcd-uhci.c
@@ -75,6 +75,9 @@
 
 #define FRAME_MAX_LOOPS  256
 
+/* Must be large enough to handle 10 frame delay for initial isoc requests */
+#define QH_VALID         32
+
 #define NB_PORTS 2
 
 enum {
@@ -206,9 +209,7 @@ static UHCIQueue *uhci_queue_new(UHCIState *s, uint32_t qh_addr, UHCI_TD *td,
     queue->ep = ep;
     QTAILQ_INIT(&queue->asyncs);
     QTAILQ_INSERT_HEAD(&s->queues, queue, next);
-    /* valid needs to be large enough to handle 10 frame delay
-     * for initial isochronous requests */
-    queue->valid = 32;
+    queue->valid = QH_VALID;
     trace_usb_uhci_queue_add(queue->token);
     return queue;
 }
@@ -854,7 +855,7 @@ static int uhci_handle_td(UHCIState *s, UHCIQueue *q, uint32_t qh_addr,
     }
 
     if (q) {
-        q->valid = 32;
+        q->valid = QH_VALID;
     }
 
     /* Is active ? */
-- 
1.7.1

[Qemu-devel] [PATCH 15/32] uhci: Limit amount of frames processed in one go

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Before this patch uhci would process an unlimited amount of frames when
behind on schedule, by setting the timer to a time already past, causing the
timer subsys to immediately recall the frame_timer function gain.

This would cause invalid cancellations of bulk queues when the catching up
processed more then 32 frames at a moment when the bulk qh was temporarily
unlinked (which the Linux uhci driver does).

This patch fixes this by processing maximum 16 frames in one go, and always
setting the timer one ms later, making the code behave more like the ehci
code.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-uhci.c |   43 +++++++++++++++++++++++++++----------------
 1 files changed, 27 insertions(+), 16 deletions(-)

diff --git a/hw/usb/hcd-uhci.c b/hw/usb/hcd-uhci.c
index d61d879..e5c3e59 100644
--- a/hw/usb/hcd-uhci.c
+++ b/hw/usb/hcd-uhci.c
@@ -78,6 +78,8 @@
 /* Must be large enough to handle 10 frame delay for initial isoc requests */
 #define QH_VALID         32
 
+#define MAX_FRAMES_PER_TICK    (QH_VALID / 2)
+
 #define NB_PORTS 2
 
 enum {
@@ -500,7 +502,7 @@ static void uhci_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
             trace_usb_uhci_schedule_start();
             s->expire_time = qemu_get_clock_ns(vm_clock) +
                 (get_ticks_per_sec() / FRAME_TIMER_FREQ);
-            qemu_mod_timer(s->frame_timer, qemu_get_clock_ns(vm_clock));
+            qemu_mod_timer(s->frame_timer, s->expire_time);
             s->status &= ~UHCI_STS_HCHALTED;
         } else if (!(val & UHCI_CMD_RS)) {
             s->status |= UHCI_STS_HCHALTED;
@@ -1176,10 +1178,10 @@ static void uhci_bh(void *opaque)
 static void uhci_frame_timer(void *opaque)
 {
     UHCIState *s = opaque;
+    uint64_t t_now, t_last_run;
+    int i, frames;
+    const uint64_t frame_t = get_ticks_per_sec() / FRAME_TIMER_FREQ;
 
-    /* prepare the timer for the next frame */
-    s->expire_time += (get_ticks_per_sec() / FRAME_TIMER_FREQ);
-    s->frame_bytes = 0;
     s->completions_only = false;
     qemu_bh_cancel(s->bh);
 
@@ -1193,20 +1195,29 @@ static void uhci_frame_timer(void *opaque)
         return;
     }
 
-    /* Process the current frame */
-    trace_usb_uhci_frame_start(s->frnum);
-
-    uhci_async_validate_begin(s);
-
-    uhci_process_frame(s);
+    /* We still store expire_time in our state, for migration */
+    t_last_run = s->expire_time - frame_t;
+    t_now = qemu_get_clock_ns(vm_clock);
 
-    uhci_async_validate_end(s);
+    /* Process up to MAX_FRAMES_PER_TICK frames */
+    frames = (t_now - t_last_run) / frame_t;
+    if (frames > MAX_FRAMES_PER_TICK) {
+        frames = MAX_FRAMES_PER_TICK;
+    }
 
-    /* The uhci spec says frnum reflects the frame currently being processed,
-     * and the guest must look at frnum - 1 on interrupt, so inc frnum now */
-    s->frnum = (s->frnum + 1) & 0x7ff;
+    for (i = 0; i < frames; i++) {
+        s->frame_bytes = 0;
+        trace_usb_uhci_frame_start(s->frnum);
+        uhci_async_validate_begin(s);
+        uhci_process_frame(s);
+        uhci_async_validate_end(s);
+        /* The spec says frnum is the frame currently being processed, and
+         * the guest must look at frnum - 1 on interrupt, so inc frnum now */
+        s->frnum = (s->frnum + 1) & 0x7ff;
+        s->expire_time += frame_t;
+    }
 
-    /* Complete the previous frame */
+    /* Complete the previous frame(s) */
     if (s->pending_int_mask) {
         s->status2 |= s->pending_int_mask;
         s->status  |= UHCI_STS_USBINT;
@@ -1214,7 +1225,7 @@ static void uhci_frame_timer(void *opaque)
     }
     s->pending_int_mask = 0;
 
-    qemu_mod_timer(s->frame_timer, s->expire_time);
+    qemu_mod_timer(s->frame_timer, t_now + frame_t);
 }
 
 static const MemoryRegionPortio uhci_portio[] = {
-- 
1.7.1

[Qemu-devel] [PATCH 16/32] uhci: Maximize how many frames we catch up when behind

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

If somehow we've gotten behind a lot, simply skip ahead, like the ehci code
does.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-uhci.c |    8 ++++++++
 1 files changed, 8 insertions(+), 0 deletions(-)

diff --git a/hw/usb/hcd-uhci.c b/hw/usb/hcd-uhci.c
index e5c3e59..bd3377e 100644
--- a/hw/usb/hcd-uhci.c
+++ b/hw/usb/hcd-uhci.c
@@ -171,6 +171,7 @@ struct UHCIState {
     /* Properties */
     char *masterbus;
     uint32_t firstport;
+    uint32_t maxframes;
 };
 
 typedef struct UHCI_TD {
@@ -1201,6 +1202,12 @@ static void uhci_frame_timer(void *opaque)
 
     /* Process up to MAX_FRAMES_PER_TICK frames */
     frames = (t_now - t_last_run) / frame_t;
+    if (frames > s->maxframes) {
+        int skipped = frames - s->maxframes;
+        s->expire_time += skipped * frame_t;
+        s->frnum = (s->frnum + skipped) & 0x7ff;
+        frames -= skipped;
+    }
     if (frames > MAX_FRAMES_PER_TICK) {
         frames = MAX_FRAMES_PER_TICK;
     }
@@ -1326,6 +1333,7 @@ static Property uhci_properties[] = {
     DEFINE_PROP_STRING("masterbus", UHCIState, masterbus),
     DEFINE_PROP_UINT32("firstport", UHCIState, firstport, 0),
     DEFINE_PROP_UINT32("bandwidth", UHCIState, frame_bandwidth, 1280),
+    DEFINE_PROP_UINT32("maxframes", UHCIState, maxframes, 128),
     DEFINE_PROP_END_OF_LIST(),
 };
 
-- 
1.7.1

[Qemu-devel] [PATCH 17/32] hid: Change idle handling to use a timer

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

This leads to cleaner code in usb-hid, and removes up to a 1000 calls / sec to
qemu_get_clock_ns(vm_clock) if idle-time is set to its default value of 0.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/hid.c         |   43 +++++++++++++++++++++++++++++++++++++------
 hw/hid.h         |    5 +++--
 hw/usb/dev-hid.c |    8 +++-----
 3 files changed, 43 insertions(+), 13 deletions(-)

diff --git a/hw/hid.c b/hw/hid.c
index 0fee3b6..89b5415 100644
--- a/hw/hid.c
+++ b/hw/hid.c
@@ -71,12 +71,38 @@ static const uint8_t hid_usage_keys[0x100] = {
 
 bool hid_has_events(HIDState *hs)
 {
-    return hs->n > 0;
+    return hs->n > 0 || hs->idle_pending;
 }
 
-void hid_set_next_idle(HIDState *hs, int64_t curtime)
+static void hid_idle_timer(void *opaque)
 {
-    hs->next_idle_clock = curtime + (get_ticks_per_sec() * hs->idle * 4) / 1000;
+    HIDState *hs = opaque;
+
+    hs->idle_pending = true;
+    hs->event(hs);
+}
+
+static void hid_del_idle_timer(HIDState *hs)
+{
+    if (hs->idle_timer) {
+        qemu_del_timer(hs->idle_timer);
+        qemu_free_timer(hs->idle_timer);
+        hs->idle_timer = NULL;
+    }
+}
+
+void hid_set_next_idle(HIDState *hs)
+{
+    if (hs->idle) {
+        uint64_t expire_time = qemu_get_clock_ns(vm_clock) +
+                               get_ticks_per_sec() * hs->idle * 4 / 1000;
+        if (!hs->idle_timer) {
+            hs->idle_timer = qemu_new_timer_ns(vm_clock, hid_idle_timer, hs);
+        }
+        qemu_mod_timer_ns(hs->idle_timer, expire_time);
+    } else {
+        hid_del_idle_timer(hs);
+    }
 }
 
 static void hid_pointer_event_clear(HIDPointerEvent *e, int buttons)
@@ -232,6 +258,8 @@ int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len)
     int index;
     HIDPointerEvent *e;
 
+    hs->idle_pending = false;
+
     hid_pointer_activate(hs);
 
     /* When the buffer is empty, return the last event.  Relative
@@ -319,6 +347,8 @@ int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len)
 
 int hid_keyboard_poll(HIDState *hs, uint8_t *buf, int len)
 {
+    hs->idle_pending = false;
+
     if (len < 2) {
         return 0;
     }
@@ -377,6 +407,8 @@ void hid_reset(HIDState *hs)
     hs->n = 0;
     hs->protocol = 1;
     hs->idle = 0;
+    hs->idle_pending = false;
+    hid_del_idle_timer(hs);
 }
 
 void hid_free(HIDState *hs)
@@ -390,6 +422,7 @@ void hid_free(HIDState *hs)
         qemu_remove_mouse_event_handler(hs->ptr.eh_entry);
         break;
     }
+    hid_del_idle_timer(hs);
 }
 
 void hid_init(HIDState *hs, int kind, HIDEventFunc event)
@@ -412,9 +445,7 @@ static int hid_post_load(void *opaque, int version_id)
 {
     HIDState *s = opaque;
 
-    if (s->idle) {
-        hid_set_next_idle(s, qemu_get_clock_ns(vm_clock));
-    }
+    hid_set_next_idle(s);
     return 0;
 }
 
diff --git a/hw/hid.h b/hw/hid.h
index 100b121..56c71ed 100644
--- a/hw/hid.h
+++ b/hw/hid.h
@@ -43,7 +43,8 @@ struct HIDState {
     int kind;
     int32_t protocol;
     uint8_t idle;
-    int64_t next_idle_clock;
+    bool idle_pending;
+    QEMUTimer *idle_timer;
     HIDEventFunc event;
 };
 
@@ -52,7 +53,7 @@ void hid_reset(HIDState *hs);
 void hid_free(HIDState *hs);
 
 bool hid_has_events(HIDState *hs);
-void hid_set_next_idle(HIDState *hs, int64_t curtime);
+void hid_set_next_idle(HIDState *hs);
 void hid_pointer_activate(HIDState *hs);
 int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len);
 int hid_keyboard_poll(HIDState *hs, uint8_t *buf, int len);
diff --git a/hw/usb/dev-hid.c b/hw/usb/dev-hid.c
index ce38fef..b4ace04 100644
--- a/hw/usb/dev-hid.c
+++ b/hw/usb/dev-hid.c
@@ -501,7 +501,7 @@ static void usb_hid_handle_control(USBDevice *dev, USBPacket *p,
         break;
     case SET_IDLE:
         hs->idle = (uint8_t) (value >> 8);
-        hid_set_next_idle(hs, qemu_get_clock_ns(vm_clock));
+        hid_set_next_idle(hs);
         if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
             hid_pointer_activate(hs);
         }
@@ -523,16 +523,14 @@ static void usb_hid_handle_data(USBDevice *dev, USBPacket *p)
     switch (p->pid) {
     case USB_TOKEN_IN:
         if (p->ep->nr == 1) {
-            int64_t curtime = qemu_get_clock_ns(vm_clock);
             if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
                 hid_pointer_activate(hs);
             }
-            if (!hid_has_events(hs) &&
-                (!hs->idle || hs->next_idle_clock - curtime > 0)) {
+            if (!hid_has_events(hs)) {
                 p->status = USB_RET_NAK;
                 return;
             }
-            hid_set_next_idle(hs, curtime);
+            hid_set_next_idle(hs);
             if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
                 len = hid_pointer_poll(hs, buf, p->iov.size);
             } else if (hs->kind == HID_KEYBOARD) {
-- 
1.7.1

[Qemu-devel] [PATCH 18/32] usb: Fix usb_ep_find_packet_by_id

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

usb_ep_find_packet_by_id mistakenly only checks the first packet and if that
is not a match, keeps trying the first packet! This patch fixes this.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/core.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

diff --git a/hw/usb/core.c b/hw/usb/core.c
index e315fc1..d057aab 100644
--- a/hw/usb/core.c
+++ b/hw/usb/core.c
@@ -761,7 +761,7 @@ USBPacket *usb_ep_find_packet_by_id(USBDevice *dev, int pid, int ep,
     struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
     USBPacket *p;
 
-    while ((p = QTAILQ_FIRST(&uep->queue)) != NULL) {
+    QTAILQ_FOREACH(p, &uep->queue, queue) {
         if (p->id == id) {
             return p;
         }
-- 
1.7.1

[Qemu-devel] [PATCH 19/32] usb: Add an usb_device_ep_stopped USBDevice method

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Some usb devices (host or network redirection) can benefit from knowing when
the guest stops using an endpoint. Redirection may involve submitting packets
independently from the guest (in combination with a fifo buffer between the
redirection code and the guest), to ensure that buffers of the real usb device
are timely emptied. This is done for example for isoc traffic and for interrupt
input endpoints. But when the (re)submission of packets is done by the device
code, then how does it know when to stop this?

For isoc endpoints this is handled by detecting a set interface (change alt
setting) command, which works well for isoc endpoints. But for interrupt
endpoints currently the redirection code never stops receiving data from
the device, which is less then ideal.

However the controller emulation is aware when a guest looses interest, as
then the qh for the endpoint gets unlinked (ehci, ohci, uhci) or the endpoint
is explicitly stopped (xhci). This patch adds a new ep_stopped USBDevice
method and modifies the hcd code to call this on queue unlink / ep stop.

This makes it possible for the redirection code to properly stop receiving
interrupt input (*) data when the guest no longer has interest in it.

*) And in the future also buffered bulk input.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb.h          |    8 ++++++++
 hw/usb/bus.c      |    8 ++++++++
 hw/usb/hcd-ehci.c |   19 ++++++++++++++++++-
 hw/usb/hcd-ohci.c |   30 ++++++++++++++++++++++++++----
 hw/usb/hcd-uhci.c |    1 +
 hw/usb/hcd-xhci.c |    7 +++++++
 6 files changed, 68 insertions(+), 5 deletions(-)

diff --git a/hw/usb.h b/hw/usb.h
index 81e265c..aca8ff6 100644
--- a/hw/usb.h
+++ b/hw/usb.h
@@ -307,6 +307,12 @@ typedef struct USBDeviceClass {
      */
     void (*flush_ep_queue)(USBDevice *dev, USBEndpoint *ep);
 
+    /*
+     * Called by the hcd to let the device know the queue for an endpoint
+     * has been unlinked / stopped. Optional may be NULL.
+     */
+    void (*ep_stopped)(USBDevice *dev, USBEndpoint *ep);
+
     const char *product_desc;
     const USBDesc *usb_desc;
 } USBDeviceClass;
@@ -539,6 +545,8 @@ void usb_device_set_interface(USBDevice *dev, int interface,
 
 void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep);
 
+void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep);
+
 const char *usb_device_get_product_desc(USBDevice *dev);
 
 const USBDesc *usb_device_get_usb_desc(USBDevice *dev);
diff --git a/hw/usb/bus.c b/hw/usb/bus.c
index 10260a1..180d1d7 100644
--- a/hw/usb/bus.c
+++ b/hw/usb/bus.c
@@ -189,6 +189,14 @@ void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
     }
 }
 
+void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
+{
+    USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
+    if (klass->ep_stopped) {
+        klass->ep_stopped(dev, ep);
+    }
+}
+
 static int usb_qdev_init(DeviceState *qdev)
 {
     USBDevice *dev = USB_DEVICE(qdev);
diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c
index 1713394..320b7e7 100644
--- a/hw/usb/hcd-ehci.c
+++ b/hw/usb/hcd-ehci.c
@@ -622,6 +622,17 @@ static EHCIQueue *ehci_alloc_queue(EHCIState *ehci, uint32_t addr, int async)
     return q;
 }
 
+static void ehci_queue_stopped(EHCIQueue *q)
+{
+    int endp  = get_field(q->qh.epchar, QH_EPCHAR_EP);
+
+    if (!q->last_pid || !q->dev) {
+        return;
+    }
+
+    usb_device_ep_stopped(q->dev, usb_ep_get(q->dev, q->last_pid, endp));
+}
+
 static int ehci_cancel_queue(EHCIQueue *q)
 {
     EHCIPacket *p;
@@ -629,7 +640,7 @@ static int ehci_cancel_queue(EHCIQueue *q)
 
     p = QTAILQ_FIRST(&q->packets);
     if (p == NULL) {
-        return 0;
+        goto leave;
     }
 
     trace_usb_ehci_queue_action(q, "cancel");
@@ -637,6 +648,9 @@ static int ehci_cancel_queue(EHCIQueue *q)
         ehci_free_packet(p);
         packets++;
     } while ((p = QTAILQ_FIRST(&q->packets)) != NULL);
+
+leave:
+    ehci_queue_stopped(q);
     return packets;
 }
 
@@ -1392,6 +1406,9 @@ static int ehci_execute(EHCIPacket *p, const char *action)
         return -1;
     }
 
+    if (!ehci_verify_pid(p->queue, &p->qtd)) {
+        ehci_queue_stopped(p->queue); /* Mark the ep in the prev dir stopped */
+    }
     p->pid = ehci_get_pid(&p->qtd);
     p->queue->last_pid = p->pid;
     endp = get_field(p->queue->qh.epchar, QH_EPCHAR_EP);
diff --git a/hw/usb/hcd-ohci.c b/hw/usb/hcd-ohci.c
index 052c4a3..29bafa6 100644
--- a/hw/usb/hcd-ohci.c
+++ b/hw/usb/hcd-ohci.c
@@ -430,6 +430,23 @@ static USBDevice *ohci_find_device(OHCIState *ohci, uint8_t addr)
     return NULL;
 }
 
+static void ohci_stop_endpoints(OHCIState *ohci)
+{
+    USBDevice *dev;
+    int i, j;
+
+    for (i = 0; i < ohci->num_ports; i++) {
+        dev = ohci->rhport[i].port.dev;
+        if (dev && dev->attached) {
+            usb_device_ep_stopped(dev, &dev->ep_ctl);
+            for (j = 0; j < USB_MAX_ENDPOINTS; j++) {
+                usb_device_ep_stopped(dev, &dev->ep_in[j]);
+                usb_device_ep_stopped(dev, &dev->ep_out[j]);
+            }
+        }
+    }
+}
+
 /* Reset the controller */
 static void ohci_reset(void *opaque)
 {
@@ -478,6 +495,7 @@ static void ohci_reset(void *opaque)
         usb_cancel_packet(&ohci->usb_packet);
         ohci->async_td = 0;
     }
+    ohci_stop_endpoints(ohci);
     DPRINTF("usb-ohci: Reset %s\n", ohci->name);
 }
 
@@ -1147,6 +1165,8 @@ static int ohci_service_ed_list(OHCIState *ohci, uint32_t head, int completion)
             if (ohci->async_td && addr == ohci->async_td) {
                 usb_cancel_packet(&ohci->usb_packet);
                 ohci->async_td = 0;
+                usb_device_ep_stopped(ohci->usb_packet.ep->dev,
+                                      ohci->usb_packet.ep);
             }
             continue;
         }
@@ -1227,10 +1247,12 @@ static void ohci_frame_boundary(void *opaque)
     }
 
     /* Cancel all pending packets if either of the lists has been disabled.  */
-    if (ohci->async_td &&
-        ohci->old_ctl & (~ohci->ctl) & (OHCI_CTL_BLE | OHCI_CTL_CLE)) {
-        usb_cancel_packet(&ohci->usb_packet);
-        ohci->async_td = 0;
+    if (ohci->old_ctl & (~ohci->ctl) & (OHCI_CTL_BLE | OHCI_CTL_CLE)) {
+        if (ohci->async_td) {
+            usb_cancel_packet(&ohci->usb_packet);
+            ohci->async_td = 0;
+        }
+        ohci_stop_endpoints(ohci);
     }
     ohci->old_ctl = ohci->ctl;
     ohci_process_lists(ohci, 0);
diff --git a/hw/usb/hcd-uhci.c b/hw/usb/hcd-uhci.c
index bd3377e..0cd68cf 100644
--- a/hw/usb/hcd-uhci.c
+++ b/hw/usb/hcd-uhci.c
@@ -226,6 +226,7 @@ static void uhci_queue_free(UHCIQueue *queue, const char *reason)
         async = QTAILQ_FIRST(&queue->asyncs);
         uhci_async_cancel(async);
     }
+    usb_device_ep_stopped(queue->ep->dev, queue->ep);
 
     trace_usb_uhci_queue_del(queue->token, reason);
     QTAILQ_REMOVE(&s->queues, queue, next);
diff --git a/hw/usb/hcd-xhci.c b/hw/usb/hcd-xhci.c
index e2de71e..40542b8 100644
--- a/hw/usb/hcd-xhci.c
+++ b/hw/usb/hcd-xhci.c
@@ -1177,6 +1177,7 @@ static int xhci_ep_nuke_xfers(XHCIState *xhci, unsigned int slotid,
     XHCISlot *slot;
     XHCIEPContext *epctx;
     int i, xferi, killed = 0;
+    USBEndpoint *ep = NULL;
     assert(slotid >= 1 && slotid <= xhci->numslots);
     assert(epid >= 1 && epid <= 31);
 
@@ -1192,9 +1193,15 @@ static int xhci_ep_nuke_xfers(XHCIState *xhci, unsigned int slotid,
 
     xferi = epctx->next_xfer;
     for (i = 0; i < TD_QUEUE; i++) {
+        if (epctx->transfers[xferi].packet.ep) {
+            ep = epctx->transfers[xferi].packet.ep;
+        }
         killed += xhci_ep_nuke_one_xfer(&epctx->transfers[xferi]);
         xferi = (xferi + 1) % TD_QUEUE;
     }
+    if (ep) {
+        usb_device_ep_stopped(ep->dev, ep);
+    }
     return killed;
 }
 
-- 
1.7.1

[Qemu-devel] [PATCH 20/32] usbredir: Add an usbredir_stop_ep helper function

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/redirect.c |   41 +++++++++++++++++++----------------------
 1 files changed, 19 insertions(+), 22 deletions(-)

diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
index 0abe1ff..c5704c1 100644
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -752,6 +752,23 @@ static void usbredir_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
     }
 }
 
+static void usbredir_stop_ep(USBRedirDevice *dev, int i)
+{
+    uint8_t ep = I2EP(i);
+
+    switch (dev->endpoint[i].type) {
+    case USB_ENDPOINT_XFER_ISOC:
+        usbredir_stop_iso_stream(dev, ep);
+        break;
+    case USB_ENDPOINT_XFER_INT:
+        if (ep & USB_DIR_IN) {
+            usbredir_stop_interrupt_receiving(dev, ep);
+        }
+        break;
+    }
+    usbredir_free_bufpq(dev, ep);
+}
+
 static void usbredir_set_config(USBRedirDevice *dev, USBPacket *p,
                                 int config)
 {
@@ -761,17 +778,7 @@ static void usbredir_set_config(USBRedirDevice *dev, USBPacket *p,
     DPRINTF("set config %d id %"PRIu64"\n", config, p->id);
 
     for (i = 0; i < MAX_ENDPOINTS; i++) {
-        switch (dev->endpoint[i].type) {
-        case USB_ENDPOINT_XFER_ISOC:
-            usbredir_stop_iso_stream(dev, I2EP(i));
-            break;
-        case USB_ENDPOINT_XFER_INT:
-            if (i & 0x10) {
-                usbredir_stop_interrupt_receiving(dev, I2EP(i));
-            }
-            break;
-        }
-        usbredir_free_bufpq(dev, I2EP(i));
+        usbredir_stop_ep(dev, i);
     }
 
     set_config.configuration = config;
@@ -799,17 +806,7 @@ static void usbredir_set_interface(USBRedirDevice *dev, USBPacket *p,
 
     for (i = 0; i < MAX_ENDPOINTS; i++) {
         if (dev->endpoint[i].interface == interface) {
-            switch (dev->endpoint[i].type) {
-            case USB_ENDPOINT_XFER_ISOC:
-                usbredir_stop_iso_stream(dev, I2EP(i));
-                break;
-            case USB_ENDPOINT_XFER_INT:
-                if (i & 0x10) {
-                    usbredir_stop_interrupt_receiving(dev, I2EP(i));
-                }
-                break;
-            }
-            usbredir_free_bufpq(dev, I2EP(i));
+            usbredir_stop_ep(dev, i);
         }
     }
 
-- 
1.7.1

[Qemu-devel] [PATCH 21/32] usbredir: Add USBEP2I and I2USBEP helper macros

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/redirect.c |   10 +++++++---
 1 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
index c5704c1..0ffcc7d 100644
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -44,6 +44,11 @@
 #define NO_INTERFACE_INFO 255 /* Valid interface_count always <= 32 */
 #define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f))
 #define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f))
+#define USBEP2I(usb_ep) (((usb_ep)->pid == USB_TOKEN_IN) ? \
+                         ((usb_ep)->nr | 0x10) : ((usb_ep)->nr))
+#define I2USBEP(d, i) (usb_ep_get(&(d)->dev, \
+                       ((i) & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT, \
+                       (i) & 0x0f))
 
 typedef struct USBRedirDevice USBRedirDevice;
 
@@ -1351,11 +1356,10 @@ static void usbredir_set_pipeline(USBRedirDevice *dev, struct USBEndpoint *uep)
 static void usbredir_setup_usb_eps(USBRedirDevice *dev)
 {
     struct USBEndpoint *usb_ep;
-    int i, pid;
+    int i;
 
     for (i = 0; i < MAX_ENDPOINTS; i++) {
-        pid = (i & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT;
-        usb_ep = usb_ep_get(&dev->dev, pid, i & 0x0f);
+        usb_ep = I2USBEP(dev, i);
         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;
-- 
1.7.1

[Qemu-devel] [PATCH 22/32] usbredir: Add ep_stopped USBDevice method

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

To ensure that interrupt receiving is properly stopped when the guest is
no longer interested in an interrupt endpoint.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/redirect.c |    9 +++++++++
 1 files changed, 9 insertions(+), 0 deletions(-)

diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
index 0ffcc7d..855c765 100644
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -774,6 +774,14 @@ static void usbredir_stop_ep(USBRedirDevice *dev, int i)
     usbredir_free_bufpq(dev, ep);
 }
 
+static void usbredir_ep_stopped(USBDevice *udev, USBEndpoint *uep)
+{
+    USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
+
+    usbredir_stop_ep(dev, USBEP2I(uep));
+    usbredirparser_do_write(dev->parser);
+}
+
 static void usbredir_set_config(USBRedirDevice *dev, USBPacket *p,
                                 int config)
 {
@@ -1995,6 +2003,7 @@ static void usbredir_class_initfn(ObjectClass *klass, void *data)
     uc->handle_data    = usbredir_handle_data;
     uc->handle_control = usbredir_handle_control;
     uc->flush_ep_queue = usbredir_flush_ep_queue;
+    uc->ep_stopped     = usbredir_ep_stopped;
     dc->vmsd           = &usbredir_vmstate;
     dc->props          = usbredir_properties;
 }
-- 
1.7.1

[Qemu-devel] [PATCH 23/32] usbredir: Verify we have 32 bits bulk length cap when redirecting to xhci

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

The xhci-hcd may submit bulk transfers > 65535 bytes even when not using
bulk-in pipeling, so usbredir can only be used in combination with an xhci
hcd if the client has the 32 bits bulk length capability.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/redirect.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
index 855c765..566737d 100644
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -980,6 +980,8 @@ static void usbredir_do_attach(void *opaque)
         usbredirparser_peer_has_cap(dev->parser,
                                     usb_redir_cap_ep_info_max_packet_size) &&
         usbredirparser_peer_has_cap(dev->parser,
+                                    usb_redir_cap_32bits_bulk_length) &&
+        usbredirparser_peer_has_cap(dev->parser,
                                     usb_redir_cap_64bits_ids))) {
         ERROR("usb-redir-host lacks capabilities needed for use with XHCI\n");
         usbredir_reject_device(dev);
-- 
1.7.1

[Qemu-devel] [PATCH 24/32] usbredir: Add usbredir_init_endpoints() helper

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/redirect.c |   22 +++++++++++++---------
 1 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
index 566737d..ad22491 100644
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -1063,6 +1063,17 @@ static void usbredir_vm_state_change(void *priv, int running, RunState state)
     }
 }
 
+static void usbredir_init_endpoints(USBRedirDevice *dev)
+{
+    int i;
+
+    usb_ep_init(&dev->dev);
+    memset(dev->endpoint, 0, sizeof(dev->endpoint));
+    for (i = 0; i < MAX_ENDPOINTS; i++) {
+        QTAILQ_INIT(&dev->endpoint[i].bufpq);
+    }
+}
+
 static int usbredir_initfn(USBDevice *udev)
 {
     USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
@@ -1089,9 +1100,7 @@ static int usbredir_initfn(USBDevice *udev)
 
     packet_id_queue_init(&dev->cancelled, dev, "cancelled");
     packet_id_queue_init(&dev->already_in_flight, dev, "already-in-flight");
-    for (i = 0; i < MAX_ENDPOINTS; i++) {
-        QTAILQ_INIT(&dev->endpoint[i].bufpq);
-    }
+    usbredir_init_endpoints(dev);
 
     /* We'll do the attach once we receive the speed from the usb-host */
     udev->auto_attach = 0;
@@ -1295,7 +1304,6 @@ static void usbredir_device_connect(void *priv,
 static void usbredir_device_disconnect(void *priv)
 {
     USBRedirDevice *dev = priv;
-    int i;
 
     /* Stop any pending attaches */
     qemu_del_timer(dev->attach_timer);
@@ -1312,11 +1320,7 @@ static void usbredir_device_disconnect(void *priv)
 
     /* Reset state so that the next dev connected starts with a clean slate */
     usbredir_cleanup_device_queues(dev);
-    memset(dev->endpoint, 0, sizeof(dev->endpoint));
-    for (i = 0; i < MAX_ENDPOINTS; i++) {
-        QTAILQ_INIT(&dev->endpoint[i].bufpq);
-    }
-    usb_ep_init(&dev->dev);
+    usbredir_init_endpoints(dev);
     dev->interface_info.interface_count = NO_INTERFACE_INFO;
     dev->dev.addr = 0;
     dev->dev.speed = 0;
-- 
1.7.1

[Qemu-devel] [PATCH 25/32] usb-redir: Add debugging to bufpq save / restore

[Gerd Hoffmann]

From: Hans de Goede <hdegoede@redhat.com>

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/redirect.c |   14 +++++++++++---
 1 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
index ad22491..f15dc91 100644
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -61,6 +61,7 @@ struct buf_packet {
 };
 
 struct endp_data {
+    USBRedirDevice *dev;
     uint8_t type;
     uint8_t interval;
     uint8_t interface; /* bInterfaceNumber this ep belongs to */
@@ -1070,6 +1071,7 @@ static void usbredir_init_endpoints(USBRedirDevice *dev)
     usb_ep_init(&dev->dev);
     memset(dev->endpoint, 0, sizeof(dev->endpoint));
     for (i = 0; i < MAX_ENDPOINTS; i++) {
+        dev->endpoint[i].dev = dev;
         QTAILQ_INIT(&dev->endpoint[i].bufpq);
     }
 }
@@ -1783,22 +1785,26 @@ static const VMStateInfo usbredir_parser_vmstate_info = {
 static void usbredir_put_bufpq(QEMUFile *f, void *priv, size_t unused)
 {
     struct endp_data *endp = priv;
+    USBRedirDevice *dev = endp->dev;
     struct buf_packet *bufp;
-    int remain = endp->bufpq_size;
+    int i = 0;
 
     qemu_put_be32(f, endp->bufpq_size);
     QTAILQ_FOREACH(bufp, &endp->bufpq, next) {
+        DPRINTF("put_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size,
+                bufp->len, bufp->status);
         qemu_put_be32(f, bufp->len);
         qemu_put_be32(f, bufp->status);
         qemu_put_buffer(f, bufp->data, bufp->len);
-        remain--;
+        i++;
     }
-    assert(remain == 0);
+    assert(i == endp->bufpq_size);
 }
 
 static int usbredir_get_bufpq(QEMUFile *f, void *priv, size_t unused)
 {
     struct endp_data *endp = priv;
+    USBRedirDevice *dev = endp->dev;
     struct buf_packet *bufp;
     int i;
 
@@ -1810,6 +1816,8 @@ static int usbredir_get_bufpq(QEMUFile *f, void *priv, size_t unused)
         bufp->data = qemu_oom_check(malloc(bufp->len)); /* regular malloc! */
         qemu_get_buffer(f, bufp->data, bufp->len);
         QTAILQ_INSERT_TAIL(&endp->bufpq, bufp, next);
+        DPRINTF("get_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size,
+                bufp->len, bufp->status);
     }
     return 0;
 }
-- 
1.7.1

[Qemu-devel] [PATCH 26/32] xhci: call set-address with dummy usbpacket

[Gerd Hoffmann]

Due to the way devices are addressed with xhci (done by hardware, not
the guest os) there is no packet when invoking the set-address control
request.  Create a dummy packet in that case to avoid null pointer
dereferences.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-xhci.c |    7 ++++++-
 1 files changed, 6 insertions(+), 1 deletions(-)

diff --git a/hw/usb/hcd-xhci.c b/hw/usb/hcd-xhci.c
index 40542b8..9132920 100644
--- a/hw/usb/hcd-xhci.c
+++ b/hw/usb/hcd-xhci.c
@@ -1970,13 +1970,18 @@ static TRBCCode xhci_address_slot(XHCIState *xhci, unsigned int slotid,
     if (bsr) {
         slot_ctx[3] = SLOT_DEFAULT << SLOT_STATE_SHIFT;
     } else {
+        USBPacket p;
         slot->devaddr = xhci->devaddr++;
         slot_ctx[3] = (SLOT_ADDRESSED << SLOT_STATE_SHIFT) | slot->devaddr;
         DPRINTF("xhci: device address is %d\n", slot->devaddr);
         usb_device_reset(dev);
-        usb_device_handle_control(dev, NULL,
+        usb_packet_setup(&p, USB_TOKEN_OUT,
+                         usb_ep_get(dev, USB_TOKEN_OUT, 0),
+                         0, false, false);
+        usb_device_handle_control(dev, &p,
                                   DeviceOutRequest | USB_REQ_SET_ADDRESS,
                                   slot->devaddr, 0, 0, NULL);
+        assert(p.status != USB_RET_ASYNC);
     }
 
     res = xhci_enable_ep(xhci, slotid, 1, octx+32, ep0_ctx);
-- 
1.7.1

[Qemu-devel] [PATCH 27/32] usb/ehci: Clean up SysBus and PCI EHCI split

[Gerd Hoffmann]

From: Andreas Färber <andreas.faerber@web.de>

SysBus EHCI was introduced in a hurry before 1.3 Soft Freeze.
To use QOM casts in place of DO_UPCAST() / FROM_SYSBUS(), we need an
identifying type. Introduce generic abstract base types for PCI and
SysBus EHCI to allow multiple types to access the shared fields.

While at it, move the state structs being amended with macros to the
header file so that they can be embedded.

The VMSTATE_PCI_DEVICE() macro does not play nice with the QOM
parent_obj naming convention, so defer that cleanup.

Signed-off-by: Andreas Färber <andreas.faerber@web.de>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci-pci.c    |   39 ++++++++++++++++++++++++---------------
 hw/usb/hcd-ehci-sysbus.c |   19 ++++++++++---------
 hw/usb/hcd-ehci.h        |   26 ++++++++++++++++++++++++++
 3 files changed, 60 insertions(+), 24 deletions(-)

diff --git a/hw/usb/hcd-ehci-pci.c b/hw/usb/hcd-ehci-pci.c
index ee77d41..0eb7826 100644
--- a/hw/usb/hcd-ehci-pci.c
+++ b/hw/usb/hcd-ehci-pci.c
@@ -16,14 +16,8 @@
  */
 
 #include "hw/usb/hcd-ehci.h"
-#include "hw/pci/pci.h"
 #include "qemu/range.h"
 
-typedef struct EHCIPCIState {
-    PCIDevice pcidev;
-    EHCIState ehci;
-} EHCIPCIState;
-
 typedef struct EHCIPCIInfo {
     const char *name;
     uint16_t vendor_id;
@@ -33,7 +27,7 @@ typedef struct EHCIPCIInfo {
 
 static int usb_ehci_pci_initfn(PCIDevice *dev)
 {
-    EHCIPCIState *i = DO_UPCAST(EHCIPCIState, pcidev, dev);
+    EHCIPCIState *i = PCI_EHCI(dev);
     EHCIState *s = &i->ehci;
     uint8_t *pci_conf = dev->config;
 
@@ -83,7 +77,7 @@ static int usb_ehci_pci_initfn(PCIDevice *dev)
 static void usb_ehci_pci_write_config(PCIDevice *dev, uint32_t addr,
                                       uint32_t val, int l)
 {
-    EHCIPCIState *i = DO_UPCAST(EHCIPCIState, pcidev, dev);
+    EHCIPCIState *i = PCI_EHCI(dev);
     bool busmaster;
 
     pci_default_write_config(dev, addr, val, l);
@@ -115,12 +109,8 @@ static void ehci_class_init(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
-    EHCIPCIInfo *i = data;
 
     k->init = usb_ehci_pci_initfn;
-    k->vendor_id = i->vendor_id;
-    k->device_id = i->device_id;
-    k->revision = i->revision;
     k->class_id = PCI_CLASS_SERIAL_USB;
     k->config_write = usb_ehci_pci_write_config;
     k->no_hotplug = 1;
@@ -128,6 +118,24 @@ static void ehci_class_init(ObjectClass *klass, void *data)
     dc->props = ehci_pci_properties;
 }
 
+static const TypeInfo ehci_pci_type_info = {
+    .name = TYPE_PCI_EHCI,
+    .parent = TYPE_PCI_DEVICE,
+    .instance_size = sizeof(EHCIPCIState),
+    .abstract = true,
+    .class_init = ehci_class_init,
+};
+
+static void ehci_data_class_init(ObjectClass *klass, void *data)
+{
+    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+    EHCIPCIInfo *i = data;
+
+    k->vendor_id = i->vendor_id;
+    k->device_id = i->device_id;
+    k->revision = i->revision;
+}
+
 static struct EHCIPCIInfo ehci_pci_info[] = {
     {
         .name      = "usb-ehci",
@@ -150,12 +158,13 @@ static struct EHCIPCIInfo ehci_pci_info[] = {
 static void ehci_pci_register_types(void)
 {
     TypeInfo ehci_type_info = {
-        .parent        = TYPE_PCI_DEVICE,
-        .instance_size = sizeof(EHCIPCIState),
-        .class_init    = ehci_class_init,
+        .parent        = TYPE_PCI_EHCI,
+        .class_init    = ehci_data_class_init,
     };
     int i;
 
+    type_register_static(&ehci_pci_type_info);
+
     for (i = 0; i < ARRAY_SIZE(ehci_pci_info); i++) {
         ehci_type_info.name = ehci_pci_info[i].name;
         ehci_type_info.class_data = ehci_pci_info + i;
diff --git a/hw/usb/hcd-ehci-sysbus.c b/hw/usb/hcd-ehci-sysbus.c
index 803df92..d431193 100644
--- a/hw/usb/hcd-ehci-sysbus.c
+++ b/hw/usb/hcd-ehci-sysbus.c
@@ -16,12 +16,6 @@
  */
 
 #include "hw/usb/hcd-ehci.h"
-#include "hw/sysbus.h"
-
-typedef struct EHCISysBusState {
-    SysBusDevice busdev;
-    EHCIState ehci;
-} EHCISysBusState;
 
 static const VMStateDescription vmstate_ehci_sysbus = {
     .name        = "ehci-sysbus",
@@ -40,7 +34,7 @@ static Property ehci_sysbus_properties[] = {
 
 static int usb_ehci_sysbus_initfn(SysBusDevice *dev)
 {
-    EHCISysBusState *i = FROM_SYSBUS(EHCISysBusState, dev);
+    EHCISysBusState *i = SYS_BUS_EHCI(dev);
     EHCIState *s = &i->ehci;
 
     s->capsbase = 0x100;
@@ -63,15 +57,22 @@ static void ehci_sysbus_class_init(ObjectClass *klass, void *data)
     dc->props = ehci_sysbus_properties;
 }
 
-TypeInfo ehci_xlnx_type_info = {
-    .name          = "xlnx,ps7-usb",
+static const TypeInfo ehci_type_info = {
+    .name          = TYPE_SYS_BUS_EHCI,
     .parent        = TYPE_SYS_BUS_DEVICE,
     .instance_size = sizeof(EHCISysBusState),
+    .abstract      = true,
     .class_init    = ehci_sysbus_class_init,
 };
 
+static const TypeInfo ehci_xlnx_type_info = {
+    .name          = "xlnx,ps7-usb",
+    .parent        = TYPE_SYS_BUS_EHCI,
+};
+
 static void ehci_sysbus_register_types(void)
 {
+    type_register_static(&ehci_type_info);
     type_register_static(&ehci_xlnx_type_info);
 }
 
diff --git a/hw/usb/hcd-ehci.h b/hw/usb/hcd-ehci.h
index 14ee3be..5ba3faf 100644
--- a/hw/usb/hcd-ehci.h
+++ b/hw/usb/hcd-ehci.h
@@ -24,6 +24,8 @@
 #include "trace.h"
 #include "sysemu/dma.h"
 #include "sysemu/sysemu.h"
+#include "hw/pci/pci.h"
+#include "hw/sysbus.h"
 
 #ifndef EHCI_DEBUG
 #define EHCI_DEBUG   0
@@ -322,4 +324,28 @@ extern const VMStateDescription vmstate_ehci;
 
 void usb_ehci_initfn(EHCIState *s, DeviceState *dev);
 
+#define TYPE_PCI_EHCI "pci-ehci-usb"
+#define PCI_EHCI(obj) OBJECT_CHECK(EHCIPCIState, (obj), TYPE_PCI_EHCI)
+
+typedef struct EHCIPCIState {
+    /*< private >*/
+    PCIDevice pcidev;
+    /*< public >*/
+
+    EHCIState ehci;
+} EHCIPCIState;
+
+
+#define TYPE_SYS_BUS_EHCI "sysbus-ehci-usb"
+#define SYS_BUS_EHCI(obj) \
+    OBJECT_CHECK(EHCISysBusState, (obj), TYPE_SYS_BUS_EHCI)
+
+typedef struct EHCISysBusState {
+    /*< private >*/
+    SysBusDevice parent_obj;
+    /*< public >*/
+
+    EHCIState ehci;
+} EHCISysBusState;
+
 #endif
-- 
1.7.1

[Qemu-devel] [PATCH 28/32] usb/ehci: Move capsbase and opregbase into SysBus EHCI class

[Gerd Hoffmann]

From: Andreas Färber <andreas.faerber@web.de>

This allows specific derived models to use different values.

Signed-off-by: Andreas Färber <andreas.faerber@web.de>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci-sysbus.c |   15 +++++++++++++--
 hw/usb/hcd-ehci.h        |   13 +++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/hw/usb/hcd-ehci-sysbus.c b/hw/usb/hcd-ehci-sysbus.c
index d431193..5a94ce3 100644
--- a/hw/usb/hcd-ehci-sysbus.c
+++ b/hw/usb/hcd-ehci-sysbus.c
@@ -35,10 +35,11 @@ static Property ehci_sysbus_properties[] = {
 static int usb_ehci_sysbus_initfn(SysBusDevice *dev)
 {
     EHCISysBusState *i = SYS_BUS_EHCI(dev);
+    SysBusEHCIClass *sec = SYS_BUS_EHCI_GET_CLASS(dev);
     EHCIState *s = &i->ehci;
 
-    s->capsbase = 0x100;
-    s->opregbase = 0x140;
+    s->capsbase = sec->capsbase;
+    s->opregbase = sec->opregbase;
     s->dma = &dma_context_memory;
 
     usb_ehci_initfn(s, DEVICE(dev));
@@ -63,11 +64,21 @@ static const TypeInfo ehci_type_info = {
     .instance_size = sizeof(EHCISysBusState),
     .abstract      = true,
     .class_init    = ehci_sysbus_class_init,
+    .class_size    = sizeof(SysBusEHCIClass),
 };
 
+static void ehci_xlnx_class_init(ObjectClass *oc, void *data)
+{
+    SysBusEHCIClass *sec = SYS_BUS_EHCI_CLASS(oc);
+
+    sec->capsbase = 0x100;
+    sec->opregbase = 0x140;
+}
+
 static const TypeInfo ehci_xlnx_type_info = {
     .name          = "xlnx,ps7-usb",
     .parent        = TYPE_SYS_BUS_EHCI,
+    .class_init    = ehci_xlnx_class_init,
 };
 
 static void ehci_sysbus_register_types(void)
diff --git a/hw/usb/hcd-ehci.h b/hw/usb/hcd-ehci.h
index 5ba3faf..2b0b5a1 100644
--- a/hw/usb/hcd-ehci.h
+++ b/hw/usb/hcd-ehci.h
@@ -339,6 +339,10 @@ typedef struct EHCIPCIState {
 #define TYPE_SYS_BUS_EHCI "sysbus-ehci-usb"
 #define SYS_BUS_EHCI(obj) \
     OBJECT_CHECK(EHCISysBusState, (obj), TYPE_SYS_BUS_EHCI)
+#define SYS_BUS_EHCI_CLASS(class) \
+    OBJECT_CLASS_CHECK(SysBusEHCIClass, (class), TYPE_SYS_BUS_EHCI)
+#define SYS_BUS_EHCI_GET_CLASS(obj) \
+    OBJECT_GET_CLASS(SysBusEHCIClass, (obj), TYPE_SYS_BUS_EHCI)
 
 typedef struct EHCISysBusState {
     /*< private >*/
@@ -348,4 +352,13 @@ typedef struct EHCISysBusState {
     EHCIState ehci;
 } EHCISysBusState;
 
+typedef struct SysBusEHCIClass {
+    /*< private >*/
+    SysBusDeviceClass parent_class;
+    /*< public >*/
+
+    uint16_t capsbase;
+    uint16_t opregbase;
+} SysBusEHCIClass;
+
 #endif
-- 
1.7.1

[Qemu-devel] [PATCH 29/32] usb/ehci: Add SysBus EHCI device for Exynos4210

[Gerd Hoffmann]

From: Andreas Färber <andreas.faerber@web.de>

It uses a different capsbase and opregbase than the Xilinx device.

Signed-off-by: Liming Wang <walimisdev@gmail.com>
Signed-off-by: Andreas Färber <andreas.faerber@web.de>
Cc: Igor Mitsyanko <i.mitsyanko@samsung.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-ehci-sysbus.c |   15 +++++++++++++++
 hw/usb/hcd-ehci.h        |    2 ++
 2 files changed, 17 insertions(+), 0 deletions(-)

diff --git a/hw/usb/hcd-ehci-sysbus.c b/hw/usb/hcd-ehci-sysbus.c
index 5a94ce3..b68a66a 100644
--- a/hw/usb/hcd-ehci-sysbus.c
+++ b/hw/usb/hcd-ehci-sysbus.c
@@ -81,10 +81,25 @@ static const TypeInfo ehci_xlnx_type_info = {
     .class_init    = ehci_xlnx_class_init,
 };
 
+static void ehci_exynos4210_class_init(ObjectClass *oc, void *data)
+{
+    SysBusEHCIClass *sec = SYS_BUS_EHCI_CLASS(oc);
+
+    sec->capsbase = 0x0;
+    sec->opregbase = 0x10;
+}
+
+static const TypeInfo ehci_exynos4210_type_info = {
+    .name          = TYPE_EXYNOS4210_EHCI,
+    .parent        = TYPE_SYS_BUS_EHCI,
+    .class_init    = ehci_exynos4210_class_init,
+};
+
 static void ehci_sysbus_register_types(void)
 {
     type_register_static(&ehci_type_info);
     type_register_static(&ehci_xlnx_type_info);
+    type_register_static(&ehci_exynos4210_type_info);
 }
 
 type_init(ehci_sysbus_register_types)
diff --git a/hw/usb/hcd-ehci.h b/hw/usb/hcd-ehci.h
index 2b0b5a1..e95bb7e 100644
--- a/hw/usb/hcd-ehci.h
+++ b/hw/usb/hcd-ehci.h
@@ -337,6 +337,8 @@ typedef struct EHCIPCIState {
 
 
 #define TYPE_SYS_BUS_EHCI "sysbus-ehci-usb"
+#define TYPE_EXYNOS4210_EHCI "exynos4210-ehci-usb"
+
 #define SYS_BUS_EHCI(obj) \
     OBJECT_CHECK(EHCISysBusState, (obj), TYPE_SYS_BUS_EHCI)
 #define SYS_BUS_EHCI_CLASS(class) \
-- 
1.7.1

[Qemu-devel] [PATCH 30/32] exynos4210: Add EHCI support

[Gerd Hoffmann]

From: Liming Wang <walimisdev@gmail.com>

Add EHCI USB host controller to exynos4210.

Signed-off-by: Liming Wang <walimisdev@gmail.com>
Signed-off-by: Andreas Färber <andreas.faerber@web.de>
Reviewed-by: Igor Mitsyanko <i.mitsyanko@samsung.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/exynos4210.c     |    7 +++++++
 hw/exynos4210_gic.c |    2 +-
 2 files changed, 8 insertions(+), 1 deletions(-)

diff --git a/hw/exynos4210.c b/hw/exynos4210.c
index a7b84d6..246a0fc 100644
--- a/hw/exynos4210.c
+++ b/hw/exynos4210.c
@@ -27,6 +27,7 @@
 #include "arm-misc.h"
 #include "loader.h"
 #include "exynos4210.h"
+#include "usb/hcd-ehci.h"
 
 #define EXYNOS4210_CHIPID_ADDR         0x10000000
 
@@ -72,6 +73,9 @@
 /* Display controllers (FIMD) */
 #define EXYNOS4210_FIMD0_BASE_ADDR          0x11C00000
 
+/* EHCI */
+#define EXYNOS4210_EHCI_BASE_ADDR           0x12580000
+
 static uint8_t chipid_and_omr[] = { 0x11, 0x02, 0x21, 0x43,
                                     0x09, 0x00, 0x00, 0x00 };
 
@@ -338,5 +342,8 @@ Exynos4210State *exynos4210_init(MemoryRegion *system_mem,
             s->irq_table[exynos4210_get_irq(11, 2)],
             NULL);
 
+    sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,
+            s->irq_table[exynos4210_get_irq(28, 3)]);
+
     return s;
 }
diff --git a/hw/exynos4210_gic.c b/hw/exynos4210_gic.c
index 4fea098..959de56 100644
--- a/hw/exynos4210_gic.c
+++ b/hw/exynos4210_gic.c
@@ -140,7 +140,7 @@ combiner_grp_to_gic_id[64-EXYNOS4210_MAX_EXT_COMBINER_OUT_IRQ][8] = {
             EXT_GIC_ID_I2C4, EXT_GIC_ID_I2C5, EXT_GIC_ID_I2C6,
             EXT_GIC_ID_I2C7 },
     /* int combiner group 28 */
-    { EXT_GIC_ID_SPI0, EXT_GIC_ID_SPI1, EXT_GIC_ID_SPI2 },
+    { EXT_GIC_ID_SPI0, EXT_GIC_ID_SPI1, EXT_GIC_ID_SPI2 , EXT_GIC_ID_USB_HOST},
     /* int combiner group 29 */
     { EXT_GIC_ID_HSMMC0, EXT_GIC_ID_HSMMC1, EXT_GIC_ID_HSMMC2,
      EXT_GIC_ID_HSMMC3, EXT_GIC_ID_SDMMC },
-- 
1.7.1

[Qemu-devel] [PATCH 31/32] usbredir: Add support for buffered bulk input (v2)

[Gerd Hoffmann]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 132765 bytes --]

From: Hans de Goede <hdegoede@redhat.com>

Buffered bulk mode is intended for bulk *input* endpoints, where the data is
of a streaming nature (not part of a command-response protocol). These
endpoints' input buffer may overflow if data is not read quickly enough.
So in buffered bulk mode the usb-host takes care of the submitting and
re-submitting of bulk transfers.

Buffered bulk mode is necessary for reliable operation with the bulk in
endpoints of usb to serial convertors. Unfortunatelty buffered bulk input
mode will only work with certain devices, therefor this patch also adds a
usb-id table to enable it for devices which need it, while leaving the
bulk ep handling for other devices unmodified.

Note that the bumping of the required usbredir from 0.5.3 to 0.6 does
not mean that we will now need a newer usbredir release then qemu-1.3,
.pc files reporting 0.5.3 have only ever existed in usbredir builds directly
from git, so qemu-1.3 needs the 0.6 release too.

Changes in v2:
-Split of quirk handling into quirks.c

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
---
 configure                  |    2 +-
 hw/usb.h                   |   12 +-
 hw/usb/Makefile.objs       |    2 +-
 hw/usb/quirks-ftdi-ids.h   | 1255 ++++++++++++++++++++++++++++++++++++++++++++
 hw/usb/quirks-pl2303-ids.h |  150 ++++++
 hw/usb/quirks.c            |   53 ++
 hw/usb/quirks.h            |  910 ++++++++++++++++++++++++++++++++
 hw/usb/redirect.c          |  355 ++++++++++++-
 8 files changed, 2718 insertions(+), 21 deletions(-)
 create mode 100644 hw/usb/quirks-ftdi-ids.h
 create mode 100644 hw/usb/quirks-pl2303-ids.h
 create mode 100644 hw/usb/quirks.c
 create mode 100644 hw/usb/quirks.h

diff --git a/configure b/configure
index fe18ed2..82f6e71 100755
--- a/configure
+++ b/configure
@@ -2851,7 +2851,7 @@ fi
 
 # check for usbredirparser for usb network redirection support
 if test "$usb_redir" != "no" ; then
-    if $pkg_config --atleast-version=0.5.3 libusbredirparser-0.5 >/dev/null 2>&1 ; then
+    if $pkg_config --atleast-version=0.6 libusbredirparser-0.5 >/dev/null 2>&1 ; then
         usb_redir="yes"
         usb_redir_cflags=$($pkg_config --cflags libusbredirparser-0.5 2>/dev/null)
         usb_redir_libs=$($pkg_config --libs libusbredirparser-0.5 2>/dev/null)
diff --git a/hw/usb.h b/hw/usb.h
index aca8ff6..50c297f 100644
--- a/hw/usb.h
+++ b/hw/usb.h
@@ -553,5 +553,15 @@ const USBDesc *usb_device_get_usb_desc(USBDevice *dev);
 
 int ehci_create_ich9_with_companions(PCIBus *bus, int slot);
 
-#endif
+/* quirks.c */
+
+/* In bulk endpoints are streaming data sources (iow behave like isoc eps) */
+#define USB_QUIRK_BUFFER_BULK_IN	0x01
+/* Bulk pkts in FTDI format, need special handling when combining packets */
+#define USB_QUIRK_IS_FTDI		0x02
 
+int usb_get_quirks(uint16_t vendor_id, uint16_t product_id,
+                   uint8_t interface_class, uint8_t interface_subclass,
+                   uint8_t interface_protocol);
+
+#endif
diff --git a/hw/usb/Makefile.objs b/hw/usb/Makefile.objs
index 5a4eeb6..dad4cb9 100644
--- a/hw/usb/Makefile.objs
+++ b/hw/usb/Makefile.objs
@@ -5,7 +5,7 @@ common-obj-$(CONFIG_USB_XHCI) += hcd-xhci.o
 common-obj-y += libhw.o
 
 common-obj-$(CONFIG_SMARTCARD) += dev-smartcard-reader.o
-common-obj-$(CONFIG_USB_REDIR) += redirect.o
+common-obj-$(CONFIG_USB_REDIR) += redirect.o quirks.o
 
 common-obj-y += core.o combined-packet.o bus.o desc.o dev-hub.o
 common-obj-y += host-$(HOST_USB).o dev-bluetooth.o
diff --git a/hw/usb/quirks-ftdi-ids.h b/hw/usb/quirks-ftdi-ids.h
new file mode 100644
index 0000000..57c12ef
--- /dev/null
+++ b/hw/usb/quirks-ftdi-ids.h
@@ -0,0 +1,1255 @@
+/*
+ * vendor/product IDs (VID/PID) of devices using FTDI USB serial converters.
+ * Please keep numerically sorted within individual areas, thanks!
+ *
+ * Philipp Gühring - pg@futureware.at - added the Device ID of the USB relais
+ * from Rudolf Gugler
+ *
+ */
+
+
+/**********************************/
+/***** devices using FTDI VID *****/
+/**********************************/
+
+
+#define FTDI_VID	0x0403	/* Vendor Id */
+
+
+/*** "original" FTDI device PIDs ***/
+
+#define FTDI_8U232AM_PID 0x6001 /* Similar device to SIO above */
+#define FTDI_8U232AM_ALT_PID 0x6006 /* FTDI's alternate PID for above */
+#define FTDI_8U2232C_PID 0x6010 /* Dual channel device */
+#define FTDI_4232H_PID 0x6011 /* Quad channel hi-speed device */
+#define FTDI_232H_PID  0x6014 /* Single channel hi-speed device */
+#define FTDI_FTX_PID   0x6015 /* FT-X series (FT201X, FT230X, FT231X, etc) */
+#define FTDI_SIO_PID	0x8372	/* Product Id SIO application of 8U100AX */
+#define FTDI_232RL_PID  0xFBFA  /* Product ID for FT232RL */
+
+
+/*** third-party PIDs (using FTDI_VID) ***/
+
+#define FTDI_LUMEL_PD12_PID	0x6002
+
+/*
+ * Marvell OpenRD Base, Client
+ * http://www.open-rd.org
+ * OpenRD Base, Client use VID 0x0403
+ */
+#define MARVELL_OPENRD_PID	0x9e90
+
+/* www.candapter.com Ewert Energy Systems CANdapter device */
+#define FTDI_CANDAPTER_PID 0x9F80 /* Product Id */
+
+/*
+ * Texas Instruments XDS100v2 JTAG / BeagleBone A3
+ * http://processors.wiki.ti.com/index.php/XDS100
+ * http://beagleboard.org/bone
+ */
+#define TI_XDS100V2_PID		0xa6d0
+
+#define FTDI_NXTCAM_PID		0xABB8 /* NXTCam for Mindstorms NXT */
+
+/* US Interface Navigator (http://www.usinterface.com/) */
+#define FTDI_USINT_CAT_PID	0xb810	/* Navigator CAT and 2nd PTT lines */
+#define FTDI_USINT_WKEY_PID	0xb811	/* Navigator WKEY and FSK lines */
+#define FTDI_USINT_RS232_PID	0xb812	/* Navigator RS232 and CONFIG lines */
+
+/* OOCDlink by Joern Kaipf <joernk@web.de>
+ * (http://www.joernonline.de/) */
+#define FTDI_OOCDLINK_PID	0xbaf8	/* Amontec JTAGkey */
+
+/* Luminary Micro Stellaris Boards, VID = FTDI_VID */
+/* FTDI 2332C Dual channel device, side A=245 FIFO (JTAG), Side B=RS232 UART */
+#define LMI_LM3S_DEVEL_BOARD_PID	0xbcd8
+#define LMI_LM3S_EVAL_BOARD_PID		0xbcd9
+#define LMI_LM3S_ICDI_BOARD_PID		0xbcda
+
+#define FTDI_TURTELIZER_PID	0xBDC8 /* JTAG/RS-232 adapter by egnite GmbH */
+
+/* OpenDCC (www.opendcc.de) product id */
+#define FTDI_OPENDCC_PID	0xBFD8
+#define FTDI_OPENDCC_SNIFFER_PID	0xBFD9
+#define FTDI_OPENDCC_THROTTLE_PID	0xBFDA
+#define FTDI_OPENDCC_GATEWAY_PID	0xBFDB
+#define FTDI_OPENDCC_GBM_PID	0xBFDC
+
+/* NZR SEM 16+ USB (http://www.nzr.de) */
+#define FTDI_NZR_SEM_USB_PID	0xC1E0	/* NZR SEM-LOG16+ */
+
+/*
+ * RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
+ */
+#define FTDI_RRCIRKITS_LOCOBUFFER_PID	0xc7d0	/* LocoBuffer USB */
+
+/* DMX4ALL DMX Interfaces */
+#define FTDI_DMX4ALL 0xC850
+
+/*
+ * ASK.fr devices
+ */
+#define FTDI_ASK_RDR400_PID	0xC991	/* ASK RDR 400 series card reader */
+
+/* www.starting-point-systems.com µChameleon device */
+#define FTDI_MICRO_CHAMELEON_PID	0xCAA0	/* Product Id */
+
+/*
+ * Tactrix OpenPort (ECU) devices.
+ * OpenPort 1.3M submitted by Donour Sizemore.
+ * OpenPort 1.3S and 1.3U submitted by Ian Abbott.
+ */
+#define FTDI_TACTRIX_OPENPORT_13M_PID	0xCC48	/* OpenPort 1.3 Mitsubishi */
+#define FTDI_TACTRIX_OPENPORT_13S_PID	0xCC49	/* OpenPort 1.3 Subaru */
+#define FTDI_TACTRIX_OPENPORT_13U_PID	0xCC4A	/* OpenPort 1.3 Universal */
+
+#define FTDI_DISTORTEC_JTAG_LOCK_PICK_PID	0xCFF8
+
+/* SCS HF Radio Modems PID's (http://www.scs-ptc.com) */
+/* the VID is the standard ftdi vid (FTDI_VID) */
+#define FTDI_SCS_DEVICE_0_PID 0xD010    /* SCS PTC-IIusb */
+#define FTDI_SCS_DEVICE_1_PID 0xD011    /* SCS Tracker / DSP TNC */
+#define FTDI_SCS_DEVICE_2_PID 0xD012
+#define FTDI_SCS_DEVICE_3_PID 0xD013
+#define FTDI_SCS_DEVICE_4_PID 0xD014
+#define FTDI_SCS_DEVICE_5_PID 0xD015
+#define FTDI_SCS_DEVICE_6_PID 0xD016
+#define FTDI_SCS_DEVICE_7_PID 0xD017
+
+/* iPlus device */
+#define FTDI_IPLUS_PID 0xD070 /* Product Id */
+#define FTDI_IPLUS2_PID 0xD071 /* Product Id */
+
+/*
+ * Gamma Scout (http://gamma-scout.com/). Submitted by rsc@runtux.com.
+ */
+#define FTDI_GAMMA_SCOUT_PID		0xD678	/* Gamma Scout online */
+
+/* Propox devices */
+#define FTDI_PROPOX_JTAGCABLEII_PID	0xD738
+#define FTDI_PROPOX_ISPCABLEIII_PID	0xD739
+
+/* Lenz LI-USB Computer Interface. */
+#define FTDI_LENZ_LIUSB_PID	0xD780
+
+/* Vardaan Enterprises Serial Interface VEUSB422R3 */
+#define FTDI_VARDAAN_PID	0xF070
+
+/*
+ * Xsens Technologies BV products (http://www.xsens.com).
+ */
+#define XSENS_CONVERTER_0_PID	0xD388
+#define XSENS_CONVERTER_1_PID	0xD389
+#define XSENS_CONVERTER_2_PID	0xD38A
+#define XSENS_CONVERTER_3_PID	0xD38B
+#define XSENS_CONVERTER_4_PID	0xD38C
+#define XSENS_CONVERTER_5_PID	0xD38D
+#define XSENS_CONVERTER_6_PID	0xD38E
+#define XSENS_CONVERTER_7_PID	0xD38F
+
+/*
+ * NDI (www.ndigital.com) product ids
+ */
+#define FTDI_NDI_HUC_PID		0xDA70	/* NDI Host USB Converter */
+#define FTDI_NDI_SPECTRA_SCU_PID	0xDA71	/* NDI Spectra SCU */
+#define FTDI_NDI_FUTURE_2_PID		0xDA72	/* NDI future device #2 */
+#define FTDI_NDI_FUTURE_3_PID		0xDA73	/* NDI future device #3 */
+#define FTDI_NDI_AURORA_SCU_PID		0xDA74	/* NDI Aurora SCU */
+
+/*
+ * ChamSys Limited (www.chamsys.co.uk) USB wing/interface product IDs
+ */
+#define FTDI_CHAMSYS_24_MASTER_WING_PID        0xDAF8
+#define FTDI_CHAMSYS_PC_WING_PID       0xDAF9
+#define FTDI_CHAMSYS_USB_DMX_PID       0xDAFA
+#define FTDI_CHAMSYS_MIDI_TIMECODE_PID 0xDAFB
+#define FTDI_CHAMSYS_MINI_WING_PID     0xDAFC
+#define FTDI_CHAMSYS_MAXI_WING_PID     0xDAFD
+#define FTDI_CHAMSYS_MEDIA_WING_PID    0xDAFE
+#define FTDI_CHAMSYS_WING_PID  0xDAFF
+
+/*
+ * Westrex International devices submitted by Cory Lee
+ */
+#define FTDI_WESTREX_MODEL_777_PID	0xDC00	/* Model 777 */
+#define FTDI_WESTREX_MODEL_8900F_PID	0xDC01	/* Model 8900F */
+
+/*
+ * ACG Identification Technologies GmbH products (http://www.acg.de/).
+ * Submitted by anton -at- goto10 -dot- org.
+ */
+#define FTDI_ACG_HFDUAL_PID		0xDD20	/* HF Dual ISO Reader (RFID) */
+
+/*
+ * Definitions for Artemis astronomical USB based cameras
+ * Check it at http://www.artemisccd.co.uk/
+ */
+#define FTDI_ARTEMIS_PID	0xDF28	/* All Artemis Cameras */
+
+/*
+ * Definitions for ATIK Instruments astronomical USB based cameras
+ * Check it at http://www.atik-instruments.com/
+ */
+#define FTDI_ATIK_ATK16_PID	0xDF30	/* ATIK ATK-16 Grayscale Camera */
+#define FTDI_ATIK_ATK16C_PID	0xDF32	/* ATIK ATK-16C Colour Camera */
+#define FTDI_ATIK_ATK16HR_PID	0xDF31	/* ATIK ATK-16HR Grayscale Camera */
+#define FTDI_ATIK_ATK16HRC_PID	0xDF33	/* ATIK ATK-16HRC Colour Camera */
+#define FTDI_ATIK_ATK16IC_PID   0xDF35  /* ATIK ATK-16IC Grayscale Camera */
+
+/*
+ * Yost Engineering, Inc. products (www.yostengineering.com).
+ * PID 0xE050 submitted by Aaron Prose.
+ */
+#define FTDI_YEI_SERVOCENTER31_PID	0xE050	/* YEI ServoCenter3.1 USB */
+
+/*
+ * ELV USB devices submitted by Christian Abt of ELV (www.elv.de).
+ * All of these devices use FTDI's vendor ID (0x0403).
+ * Further IDs taken from ELV Windows .inf file.
+ *
+ * The previously included PID for the UO 100 module was incorrect.
+ * In fact, that PID was for ELV's UR 100 USB-RS232 converter (0xFB58).
+ *
+ * Armin Laeuger originally sent the PID for the UM 100 module.
+ */
+#define FTDI_ELV_USR_PID	0xE000	/* ELV Universal-Sound-Recorder */
+#define FTDI_ELV_MSM1_PID	0xE001	/* ELV Mini-Sound-Modul */
+#define FTDI_ELV_KL100_PID	0xE002	/* ELV Kfz-Leistungsmesser KL 100 */
+#define FTDI_ELV_WS550_PID	0xE004	/* WS 550 */
+#define FTDI_ELV_EC3000_PID	0xE006	/* ENERGY CONTROL 3000 USB */
+#define FTDI_ELV_WS888_PID	0xE008	/* WS 888 */
+#define FTDI_ELV_TWS550_PID	0xE009	/* Technoline WS 550 */
+#define FTDI_ELV_FEM_PID	0xE00A	/* Funk Energie Monitor */
+#define FTDI_ELV_FHZ1300PC_PID	0xE0E8	/* FHZ 1300 PC */
+#define FTDI_ELV_WS500_PID	0xE0E9	/* PC-Wetterstation (WS 500) */
+#define FTDI_ELV_HS485_PID	0xE0EA	/* USB to RS-485 adapter */
+#define FTDI_ELV_UMS100_PID	0xE0EB	/* ELV USB Master-Slave Schaltsteckdose UMS 100 */
+#define FTDI_ELV_TFD128_PID	0xE0EC	/* ELV Temperatur-Feuchte-Datenlogger TFD 128 */
+#define FTDI_ELV_FM3RX_PID	0xE0ED	/* ELV Messwertuebertragung FM3 RX */
+#define FTDI_ELV_WS777_PID	0xE0EE	/* Conrad WS 777 */
+#define FTDI_ELV_EM1010PC_PID	0xE0EF	/* Energy monitor EM 1010 PC */
+#define FTDI_ELV_CSI8_PID	0xE0F0	/* Computer-Schalt-Interface (CSI 8) */
+#define FTDI_ELV_EM1000DL_PID	0xE0F1	/* PC-Datenlogger fuer Energiemonitor (EM 1000 DL) */
+#define FTDI_ELV_PCK100_PID	0xE0F2	/* PC-Kabeltester (PCK 100) */
+#define FTDI_ELV_RFP500_PID	0xE0F3	/* HF-Leistungsmesser (RFP 500) */
+#define FTDI_ELV_FS20SIG_PID	0xE0F4	/* Signalgeber (FS 20 SIG) */
+#define FTDI_ELV_UTP8_PID	0xE0F5	/* ELV UTP 8 */
+#define FTDI_ELV_WS300PC_PID	0xE0F6	/* PC-Wetterstation (WS 300 PC) */
+#define FTDI_ELV_WS444PC_PID	0xE0F7	/* Conrad WS 444 PC */
+#define FTDI_PHI_FISCO_PID      0xE40B  /* PHI Fisco USB to Serial cable */
+#define FTDI_ELV_UAD8_PID	0xF068	/* USB-AD-Wandler (UAD 8) */
+#define FTDI_ELV_UDA7_PID	0xF069	/* USB-DA-Wandler (UDA 7) */
+#define FTDI_ELV_USI2_PID	0xF06A	/* USB-Schrittmotoren-Interface (USI 2) */
+#define FTDI_ELV_T1100_PID	0xF06B	/* Thermometer (T 1100) */
+#define FTDI_ELV_PCD200_PID	0xF06C	/* PC-Datenlogger (PCD 200) */
+#define FTDI_ELV_ULA200_PID	0xF06D	/* USB-LCD-Ansteuerung (ULA 200) */
+#define FTDI_ELV_ALC8500_PID	0xF06E	/* ALC 8500 Expert */
+#define FTDI_ELV_FHZ1000PC_PID	0xF06F	/* FHZ 1000 PC */
+#define FTDI_ELV_UR100_PID	0xFB58	/* USB-RS232-Umsetzer (UR 100) */
+#define FTDI_ELV_UM100_PID	0xFB5A	/* USB-Modul UM 100 */
+#define FTDI_ELV_UO100_PID	0xFB5B	/* USB-Modul UO 100 */
+/* Additional ELV PIDs that default to using the FTDI D2XX drivers on
+ * MS Windows, rather than the FTDI Virtual Com Port drivers.
+ * Maybe these will be easier to use with the libftdi/libusb user-space
+ * drivers, or possibly the Comedi drivers in some cases. */
+#define FTDI_ELV_CLI7000_PID	0xFB59	/* Computer-Light-Interface (CLI 7000) */
+#define FTDI_ELV_PPS7330_PID	0xFB5C	/* Processor-Power-Supply (PPS 7330) */
+#define FTDI_ELV_TFM100_PID	0xFB5D	/* Temperatur-Feuchte-Messgeraet (TFM 100) */
+#define FTDI_ELV_UDF77_PID	0xFB5E	/* USB DCF Funkuhr (UDF 77) */
+#define FTDI_ELV_UIO88_PID	0xFB5F	/* USB-I/O Interface (UIO 88) */
+
+/*
+ * EVER Eco Pro UPS (http://www.ever.com.pl/)
+ */
+
+#define	EVER_ECO_PRO_CDS	0xe520	/* RS-232 converter */
+
+/*
+ * Active Robots product ids.
+ */
+#define FTDI_ACTIVE_ROBOTS_PID	0xE548	/* USB comms board */
+
+/* Pyramid Computer GmbH */
+#define FTDI_PYRAMID_PID	0xE6C8	/* Pyramid Appliance Display */
+
+/* www.elsterelectricity.com Elster Unicom III Optical Probe */
+#define FTDI_ELSTER_UNICOM_PID		0xE700 /* Product Id */
+
+/*
+ * Gude Analog- und Digitalsysteme GmbH
+ */
+#define FTDI_GUDEADS_E808_PID    0xE808
+#define FTDI_GUDEADS_E809_PID    0xE809
+#define FTDI_GUDEADS_E80A_PID    0xE80A
+#define FTDI_GUDEADS_E80B_PID    0xE80B
+#define FTDI_GUDEADS_E80C_PID    0xE80C
+#define FTDI_GUDEADS_E80D_PID    0xE80D
+#define FTDI_GUDEADS_E80E_PID    0xE80E
+#define FTDI_GUDEADS_E80F_PID    0xE80F
+#define FTDI_GUDEADS_E888_PID    0xE888  /* Expert ISDN Control USB */
+#define FTDI_GUDEADS_E889_PID    0xE889  /* USB RS-232 OptoBridge */
+#define FTDI_GUDEADS_E88A_PID    0xE88A
+#define FTDI_GUDEADS_E88B_PID    0xE88B
+#define FTDI_GUDEADS_E88C_PID    0xE88C
+#define FTDI_GUDEADS_E88D_PID    0xE88D
+#define FTDI_GUDEADS_E88E_PID    0xE88E
+#define FTDI_GUDEADS_E88F_PID    0xE88F
+
+/*
+ * Eclo (http://www.eclo.pt/) product IDs.
+ * PID 0xEA90 submitted by Martin Grill.
+ */
+#define FTDI_ECLO_COM_1WIRE_PID	0xEA90	/* COM to 1-Wire USB adaptor */
+
+/* TNC-X USB-to-packet-radio adapter, versions prior to 3.0 (DLP module) */
+#define FTDI_TNC_X_PID		0xEBE0
+
+/*
+ * Teratronik product ids.
+ * Submitted by O. Wölfelschneider.
+ */
+#define FTDI_TERATRONIK_VCP_PID	 0xEC88	/* Teratronik device (preferring VCP driver on windows) */
+#define FTDI_TERATRONIK_D2XX_PID 0xEC89	/* Teratronik device (preferring D2XX driver on windows) */
+
+/* Rig Expert Ukraine devices */
+#define FTDI_REU_TINY_PID		0xED22	/* RigExpert Tiny */
+
+/*
+ * Hameg HO820 and HO870 interface (using VID 0x0403)
+ */
+#define HAMEG_HO820_PID			0xed74
+#define HAMEG_HO730_PID			0xed73
+#define HAMEG_HO720_PID			0xed72
+#define HAMEG_HO870_PID			0xed71
+
+/*
+ *  MaxStream devices	www.maxstream.net
+ */
+#define FTDI_MAXSTREAM_PID	0xEE18	/* Xbee PKG-U Module */
+
+/*
+ * microHAM product IDs (http://www.microham.com).
+ * Submitted by Justin Burket (KL1RL) <zorton@jtan.com>
+ * and Mike Studer (K6EEP) <k6eep@hamsoftware.org>.
+ * Ian Abbott <abbotti@mev.co.uk> added a few more from the driver INF file.
+ */
+#define FTDI_MHAM_KW_PID	0xEEE8	/* USB-KW interface */
+#define FTDI_MHAM_YS_PID	0xEEE9	/* USB-YS interface */
+#define FTDI_MHAM_Y6_PID	0xEEEA	/* USB-Y6 interface */
+#define FTDI_MHAM_Y8_PID	0xEEEB	/* USB-Y8 interface */
+#define FTDI_MHAM_IC_PID	0xEEEC	/* USB-IC interface */
+#define FTDI_MHAM_DB9_PID	0xEEED	/* USB-DB9 interface */
+#define FTDI_MHAM_RS232_PID	0xEEEE	/* USB-RS232 interface */
+#define FTDI_MHAM_Y9_PID	0xEEEF	/* USB-Y9 interface */
+
+/* Domintell products  http://www.domintell.com */
+#define FTDI_DOMINTELL_DGQG_PID	0xEF50	/* Master */
+#define FTDI_DOMINTELL_DUSB_PID	0xEF51	/* DUSB01 module */
+
+/*
+ * The following are the values for the Perle Systems
+ * UltraPort USB serial converters
+ */
+#define FTDI_PERLE_ULTRAPORT_PID 0xF0C0	/* Perle UltraPort Product Id */
+
+/* Sprog II (Andrew Crosland's SprogII DCC interface) */
+#define FTDI_SPROG_II		0xF0C8
+
+/* an infrared receiver for user access control with IR tags */
+#define FTDI_PIEGROUP_PID	0xF208	/* Product Id */
+
+/* ACT Solutions HomePro ZWave interface
+   (http://www.act-solutions.com/HomePro-Product-Matrix.html) */
+#define FTDI_ACTZWAVE_PID	0xF2D0
+
+/*
+ * 4N-GALAXY.DE PIDs for CAN-USB, USB-RS232, USB-RS422, USB-RS485,
+ * USB-TTY aktiv, USB-TTY passiv.  Some PIDs are used by several devices
+ * and I'm not entirely sure which are used by which.
+ */
+#define FTDI_4N_GALAXY_DE_1_PID	0xF3C0
+#define FTDI_4N_GALAXY_DE_2_PID	0xF3C1
+#define FTDI_4N_GALAXY_DE_3_PID	0xF3C2
+
+/*
+ * Linx Technologies product ids
+ */
+#define LINX_SDMUSBQSS_PID	0xF448	/* Linx SDM-USB-QS-S */
+#define LINX_MASTERDEVEL2_PID   0xF449	/* Linx Master Development 2.0 */
+#define LINX_FUTURE_0_PID   0xF44A	/* Linx future device */
+#define LINX_FUTURE_1_PID   0xF44B	/* Linx future device */
+#define LINX_FUTURE_2_PID   0xF44C	/* Linx future device */
+
+/*
+ * Oceanic product ids
+ */
+#define FTDI_OCEANIC_PID	0xF460  /* Oceanic dive instrument */
+
+/*
+ * SUUNTO product ids
+ */
+#define FTDI_SUUNTO_SPORTS_PID	0xF680	/* Suunto Sports instrument */
+
+/* USB-UIRT - An infrared receiver and transmitter using the 8U232AM chip */
+/* http://www.usbuirt.com/ */
+#define FTDI_USB_UIRT_PID	0xF850	/* Product Id */
+
+/* CCS Inc. ICDU/ICDU40 product ID -
+ * the FT232BM is used in an in-circuit-debugger unit for PIC16's/PIC18's */
+#define FTDI_CCSICDU20_0_PID    0xF9D0
+#define FTDI_CCSICDU40_1_PID    0xF9D1
+#define FTDI_CCSMACHX_2_PID     0xF9D2
+#define FTDI_CCSLOAD_N_GO_3_PID 0xF9D3
+#define FTDI_CCSICDU64_4_PID    0xF9D4
+#define FTDI_CCSPRIME8_5_PID    0xF9D5
+
+/*
+ * The following are the values for the Matrix Orbital LCD displays,
+ * which are the FT232BM ( similar to the 8U232AM )
+ */
+#define FTDI_MTXORB_0_PID      0xFA00  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_1_PID      0xFA01  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_2_PID      0xFA02  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_3_PID      0xFA03  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_4_PID      0xFA04  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_5_PID      0xFA05  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_6_PID      0xFA06  /* Matrix Orbital Product Id */
+
+/*
+ * Home Electronics (www.home-electro.com) USB gadgets
+ */
+#define FTDI_HE_TIRA1_PID	0xFA78	/* Tira-1 IR transceiver */
+
+/* Inside Accesso contactless reader (http://www.insidecontactless.com/) */
+#define INSIDE_ACCESSO		0xFAD0
+
+/*
+ * ThorLabs USB motor drivers
+ */
+#define FTDI_THORLABS_PID		0xfaf0 /* ThorLabs USB motor drivers */
+
+/*
+ * Protego product ids
+ */
+#define PROTEGO_SPECIAL_1	0xFC70	/* special/unknown device */
+#define PROTEGO_R2X0		0xFC71	/* R200-USB TRNG unit (R210, R220, and R230) */
+#define PROTEGO_SPECIAL_3	0xFC72	/* special/unknown device */
+#define PROTEGO_SPECIAL_4	0xFC73	/* special/unknown device */
+
+/*
+ * Sony Ericsson product ids
+ */
+#define FTDI_DSS20_PID		0xFC82	/* DSS-20 Sync Station for Sony Ericsson P800 */
+#define FTDI_URBAN_0_PID	0xFC8A	/* Sony Ericsson Urban, uart #0 */
+#define FTDI_URBAN_1_PID	0xFC8B	/* Sony Ericsson Urban, uart #1 */
+
+/* www.irtrans.de device */
+#define FTDI_IRTRANS_PID 0xFC60 /* Product Id */
+
+/*
+ * RM Michaelides CANview USB (http://www.rmcan.com) (FTDI_VID)
+ * CAN fieldbus interface adapter, added by port GmbH www.port.de)
+ * Ian Abbott changed the macro names for consistency.
+ */
+#define FTDI_RM_CANVIEW_PID	0xfd60	/* Product Id */
+/* www.thoughttechnology.com/ TT-USB provide with procomp use ftdi_sio */
+#define FTDI_TTUSB_PID 0xFF20 /* Product Id */
+
+#define FTDI_USBX_707_PID 0xF857	/* ADSTech IR Blaster USBX-707 (FTDI_VID) */
+
+#define FTDI_RELAIS_PID	0xFA10  /* Relais device from Rudolf Gugler */
+
+/*
+ * PCDJ use ftdi based dj-controllers. The following PID is
+ * for their DAC-2 device http://www.pcdjhardware.com/DAC2.asp
+ * (the VID is the standard ftdi vid (FTDI_VID), PID sent by Wouter Paesen)
+ */
+#define FTDI_PCDJ_DAC2_PID 0xFA88
+
+#define FTDI_R2000KU_TRUE_RNG	0xFB80  /* R2000KU TRUE RNG (FTDI_VID) */
+
+/*
+ * DIEBOLD BCS SE923 (FTDI_VID)
+ */
+#define DIEBOLD_BCS_SE923_PID	0xfb99
+
+/* www.crystalfontz.com devices
+ * - thanx for providing free devices for evaluation !
+ * they use the ftdi chipset for the USB interface
+ * and the vendor id is the same
+ */
+#define FTDI_XF_632_PID 0xFC08	/* 632: 16x2 Character Display */
+#define FTDI_XF_634_PID 0xFC09	/* 634: 20x4 Character Display */
+#define FTDI_XF_547_PID 0xFC0A	/* 547: Two line Display */
+#define FTDI_XF_633_PID 0xFC0B	/* 633: 16x2 Character Display with Keys */
+#define FTDI_XF_631_PID 0xFC0C	/* 631: 20x2 Character Display */
+#define FTDI_XF_635_PID 0xFC0D	/* 635: 20x4 Character Display */
+#define FTDI_XF_640_PID 0xFC0E	/* 640: Two line Display */
+#define FTDI_XF_642_PID 0xFC0F	/* 642: Two line Display */
+
+/*
+ * Video Networks Limited / Homechoice in the UK use an ftdi-based device
+ * for their 1Mb broadband internet service.  The following PID is exhibited
+ * by the usb device supplied (the VID is the standard ftdi vid (FTDI_VID)
+ */
+#define FTDI_VNHCPCUSB_D_PID 0xfe38 /* Product Id */
+
+/* AlphaMicro Components AMC-232USB01 device (FTDI_VID) */
+#define FTDI_AMC232_PID 0xFF00 /* Product Id */
+
+/*
+ * IBS elektronik product ids (FTDI_VID)
+ * Submitted by Thomas Schleusener
+ */
+#define FTDI_IBS_US485_PID	0xff38  /* IBS US485 (USB<-->RS422/485 interface) */
+#define FTDI_IBS_PICPRO_PID	0xff39  /* IBS PIC-Programmer */
+#define FTDI_IBS_PCMCIA_PID	0xff3a  /* IBS Card reader for PCMCIA SRAM-cards */
+#define FTDI_IBS_PK1_PID	0xff3b  /* IBS PK1 - Particel counter */
+#define FTDI_IBS_RS232MON_PID	0xff3c  /* IBS RS232 - Monitor */
+#define FTDI_IBS_APP70_PID	0xff3d  /* APP 70 (dust monitoring system) */
+#define FTDI_IBS_PEDO_PID	0xff3e  /* IBS PEDO-Modem (RF modem 868.35 MHz) */
+#define FTDI_IBS_PROD_PID	0xff3f  /* future device */
+/* www.canusb.com Lawicel CANUSB device (FTDI_VID) */
+#define FTDI_CANUSB_PID 0xFFA8 /* Product Id */
+
+/*
+ * TavIR AVR product ids (FTDI_VID)
+ */
+#define FTDI_TAVIR_STK500_PID	0xFA33	/* STK500 AVR programmer */
+
+/*
+ * TIAO product ids (FTDI_VID)
+ * http://www.tiaowiki.com/w/Main_Page
+ */
+#define FTDI_TIAO_UMPA_PID	0x8a98	/* TIAO/DIYGADGET USB Multi-Protocol Adapter */
+
+
+/********************************/
+/** third-party VID/PID combos **/
+/********************************/
+
+
+
+/*
+ * Atmel STK541
+ */
+#define ATMEL_VID		0x03eb /* Vendor ID */
+#define STK541_PID		0x2109 /* Zigbee Controller */
+
+/*
+ * Blackfin gnICE JTAG
+ * http://docs.blackfin.uclinux.org/doku.php?id=hw:jtag:gnice
+ */
+#define ADI_VID			0x0456
+#define ADI_GNICE_PID		0xF000
+#define ADI_GNICEPLUS_PID	0xF001
+
+/*
+ * Microchip Technology, Inc.
+ *
+ * MICROCHIP_VID (0x04D8) and MICROCHIP_USB_BOARD_PID (0x000A) are
+ * used by single function CDC ACM class based firmware demo
+ * applications.  The VID/PID has also been used in firmware
+ * emulating FTDI serial chips by:
+ * Hornby Elite - Digital Command Control Console
+ * http://www.hornby.com/hornby-dcc/controllers/
+ */
+#define MICROCHIP_VID		0x04D8
+#define MICROCHIP_USB_BOARD_PID	0x000A /* CDC RS-232 Emulation Demo */
+
+/*
+ * RATOC REX-USB60F
+ */
+#define RATOC_VENDOR_ID		0x0584
+#define RATOC_PRODUCT_ID_USB60F	0xb020
+
+/*
+ * Acton Research Corp.
+ */
+#define ACTON_VID		0x0647	/* Vendor ID */
+#define ACTON_SPECTRAPRO_PID	0x0100
+
+/*
+ * Contec products (http://www.contec.com)
+ * Submitted by Daniel Sangorrin
+ */
+#define CONTEC_VID		0x06CE	/* Vendor ID */
+#define CONTEC_COM1USBH_PID	0x8311	/* COM-1(USB)H */
+
+/*
+ * Definitions for B&B Electronics products.
+ */
+#define BANDB_VID		0x0856	/* B&B Electronics Vendor ID */
+#define BANDB_USOTL4_PID	0xAC01	/* USOTL4 Isolated RS-485 Converter */
+#define BANDB_USTL4_PID		0xAC02	/* USTL4 RS-485 Converter */
+#define BANDB_USO9ML2_PID	0xAC03	/* USO9ML2 Isolated RS-232 Converter */
+#define BANDB_USOPTL4_PID	0xAC11
+#define BANDB_USPTL4_PID	0xAC12
+#define BANDB_USO9ML2DR_2_PID	0xAC16
+#define BANDB_USO9ML2DR_PID	0xAC17
+#define BANDB_USOPTL4DR2_PID	0xAC18	/* USOPTL4R-2 2-port Isolated RS-232 Converter */
+#define BANDB_USOPTL4DR_PID	0xAC19
+#define BANDB_485USB9F_2W_PID	0xAC25
+#define BANDB_485USB9F_4W_PID	0xAC26
+#define BANDB_232USB9M_PID	0xAC27
+#define BANDB_485USBTB_2W_PID	0xAC33
+#define BANDB_485USBTB_4W_PID	0xAC34
+#define BANDB_TTL5USB9M_PID	0xAC49
+#define BANDB_TTL3USB9M_PID	0xAC50
+#define BANDB_ZZ_PROG1_USB_PID	0xBA02
+
+/*
+ * Intrepid Control Systems (http://www.intrepidcs.com/) ValueCAN and NeoVI
+ */
+#define INTREPID_VID		0x093C
+#define INTREPID_VALUECAN_PID	0x0601
+#define INTREPID_NEOVI_PID	0x0701
+
+/*
+ * Definitions for ID TECH (www.idt-net.com) devices
+ */
+#define IDTECH_VID		0x0ACD	/* ID TECH Vendor ID */
+#define IDTECH_IDT1221U_PID	0x0300	/* IDT1221U USB to RS-232 adapter */
+
+/*
+ * Definitions for Omnidirectional Control Technology, Inc. devices
+ */
+#define OCT_VID			0x0B39	/* OCT vendor ID */
+/* Note: OCT US101 is also rebadged as Dick Smith Electronics (NZ) XH6381 */
+/* Also rebadged as Dick Smith Electronics (Aus) XH6451 */
+/* Also rebadged as SIIG Inc. model US2308 hardware version 1 */
+#define OCT_DK201_PID		0x0103	/* OCT DK201 USB docking station */
+#define OCT_US101_PID		0x0421	/* OCT US101 USB to RS-232 */
+
+/*
+ * Definitions for Icom Inc. devices
+ */
+#define ICOM_VID		0x0C26 /* Icom vendor ID */
+/* Note: ID-1 is a communications tranceiver for HAM-radio operators */
+#define ICOM_ID_1_PID		0x0004 /* ID-1 USB to RS-232 */
+/* Note: OPC is an Optional cable to connect an Icom Tranceiver */
+#define ICOM_OPC_U_UC_PID	0x0018 /* OPC-478UC, OPC-1122U cloning cable */
+/* Note: ID-RP* devices are Icom Repeater Devices for HAM-radio */
+#define ICOM_ID_RP2C1_PID	0x0009 /* ID-RP2C Asset 1 to RS-232 */
+#define ICOM_ID_RP2C2_PID	0x000A /* ID-RP2C Asset 2 to RS-232 */
+#define ICOM_ID_RP2D_PID	0x000B /* ID-RP2D configuration port*/
+#define ICOM_ID_RP2VT_PID	0x000C /* ID-RP2V Transmit config port */
+#define ICOM_ID_RP2VR_PID	0x000D /* ID-RP2V Receive config port */
+#define ICOM_ID_RP4KVT_PID	0x0010 /* ID-RP4000V Transmit config port */
+#define ICOM_ID_RP4KVR_PID	0x0011 /* ID-RP4000V Receive config port */
+#define ICOM_ID_RP2KVT_PID	0x0012 /* ID-RP2000V Transmit config port */
+#define ICOM_ID_RP2KVR_PID	0x0013 /* ID-RP2000V Receive config port */
+
+/*
+ * GN Otometrics (http://www.otometrics.com)
+ * Submitted by Ville Sundberg.
+ */
+#define GN_OTOMETRICS_VID	0x0c33	/* Vendor ID */
+#define AURICAL_USB_PID		0x0010	/* Aurical USB Audiometer */
+
+/*
+ * The following are the values for the Sealevel SeaLINK+ adapters.
+ * (Original list sent by Tuan Hoang.  Ian Abbott renamed the macros and
+ * removed some PIDs that don't seem to match any existing products.)
+ */
+#define SEALEVEL_VID		0x0c52	/* Sealevel Vendor ID */
+#define SEALEVEL_2101_PID	0x2101	/* SeaLINK+232 (2101/2105) */
+#define SEALEVEL_2102_PID	0x2102	/* SeaLINK+485 (2102) */
+#define SEALEVEL_2103_PID	0x2103	/* SeaLINK+232I (2103) */
+#define SEALEVEL_2104_PID	0x2104	/* SeaLINK+485I (2104) */
+#define SEALEVEL_2106_PID	0x9020	/* SeaLINK+422 (2106) */
+#define SEALEVEL_2201_1_PID	0x2211	/* SeaPORT+2/232 (2201) Port 1 */
+#define SEALEVEL_2201_2_PID	0x2221	/* SeaPORT+2/232 (2201) Port 2 */
+#define SEALEVEL_2202_1_PID	0x2212	/* SeaPORT+2/485 (2202) Port 1 */
+#define SEALEVEL_2202_2_PID	0x2222	/* SeaPORT+2/485 (2202) Port 2 */
+#define SEALEVEL_2203_1_PID	0x2213	/* SeaPORT+2 (2203) Port 1 */
+#define SEALEVEL_2203_2_PID	0x2223	/* SeaPORT+2 (2203) Port 2 */
+#define SEALEVEL_2401_1_PID	0x2411	/* SeaPORT+4/232 (2401) Port 1 */
+#define SEALEVEL_2401_2_PID	0x2421	/* SeaPORT+4/232 (2401) Port 2 */
+#define SEALEVEL_2401_3_PID	0x2431	/* SeaPORT+4/232 (2401) Port 3 */
+#define SEALEVEL_2401_4_PID	0x2441	/* SeaPORT+4/232 (2401) Port 4 */
+#define SEALEVEL_2402_1_PID	0x2412	/* SeaPORT+4/485 (2402) Port 1 */
+#define SEALEVEL_2402_2_PID	0x2422	/* SeaPORT+4/485 (2402) Port 2 */
+#define SEALEVEL_2402_3_PID	0x2432	/* SeaPORT+4/485 (2402) Port 3 */
+#define SEALEVEL_2402_4_PID	0x2442	/* SeaPORT+4/485 (2402) Port 4 */
+#define SEALEVEL_2403_1_PID	0x2413	/* SeaPORT+4 (2403) Port 1 */
+#define SEALEVEL_2403_2_PID	0x2423	/* SeaPORT+4 (2403) Port 2 */
+#define SEALEVEL_2403_3_PID	0x2433	/* SeaPORT+4 (2403) Port 3 */
+#define SEALEVEL_2403_4_PID	0x2443	/* SeaPORT+4 (2403) Port 4 */
+#define SEALEVEL_2801_1_PID	0X2811	/* SeaLINK+8/232 (2801) Port 1 */
+#define SEALEVEL_2801_2_PID	0X2821	/* SeaLINK+8/232 (2801) Port 2 */
+#define SEALEVEL_2801_3_PID	0X2831	/* SeaLINK+8/232 (2801) Port 3 */
+#define SEALEVEL_2801_4_PID	0X2841	/* SeaLINK+8/232 (2801) Port 4 */
+#define SEALEVEL_2801_5_PID	0X2851	/* SeaLINK+8/232 (2801) Port 5 */
+#define SEALEVEL_2801_6_PID	0X2861	/* SeaLINK+8/232 (2801) Port 6 */
+#define SEALEVEL_2801_7_PID	0X2871	/* SeaLINK+8/232 (2801) Port 7 */
+#define SEALEVEL_2801_8_PID	0X2881	/* SeaLINK+8/232 (2801) Port 8 */
+#define SEALEVEL_2802_1_PID	0X2812	/* SeaLINK+8/485 (2802) Port 1 */
+#define SEALEVEL_2802_2_PID	0X2822	/* SeaLINK+8/485 (2802) Port 2 */
+#define SEALEVEL_2802_3_PID	0X2832	/* SeaLINK+8/485 (2802) Port 3 */
+#define SEALEVEL_2802_4_PID	0X2842	/* SeaLINK+8/485 (2802) Port 4 */
+#define SEALEVEL_2802_5_PID	0X2852	/* SeaLINK+8/485 (2802) Port 5 */
+#define SEALEVEL_2802_6_PID	0X2862	/* SeaLINK+8/485 (2802) Port 6 */
+#define SEALEVEL_2802_7_PID	0X2872	/* SeaLINK+8/485 (2802) Port 7 */
+#define SEALEVEL_2802_8_PID	0X2882	/* SeaLINK+8/485 (2802) Port 8 */
+#define SEALEVEL_2803_1_PID	0X2813	/* SeaLINK+8 (2803) Port 1 */
+#define SEALEVEL_2803_2_PID	0X2823	/* SeaLINK+8 (2803) Port 2 */
+#define SEALEVEL_2803_3_PID	0X2833	/* SeaLINK+8 (2803) Port 3 */
+#define SEALEVEL_2803_4_PID	0X2843	/* SeaLINK+8 (2803) Port 4 */
+#define SEALEVEL_2803_5_PID	0X2853	/* SeaLINK+8 (2803) Port 5 */
+#define SEALEVEL_2803_6_PID	0X2863	/* SeaLINK+8 (2803) Port 6 */
+#define SEALEVEL_2803_7_PID	0X2873	/* SeaLINK+8 (2803) Port 7 */
+#define SEALEVEL_2803_8_PID	0X2883	/* SeaLINK+8 (2803) Port 8 */
+#define SEALEVEL_2803R_1_PID	0Xa02a	/* SeaLINK+8 (2803-ROHS) Port 1+2 */
+#define SEALEVEL_2803R_2_PID	0Xa02b	/* SeaLINK+8 (2803-ROHS) Port 3+4 */
+#define SEALEVEL_2803R_3_PID	0Xa02c	/* SeaLINK+8 (2803-ROHS) Port 5+6 */
+#define SEALEVEL_2803R_4_PID	0Xa02d	/* SeaLINK+8 (2803-ROHS) Port 7+8 */
+
+/*
+ * JETI SPECTROMETER SPECBOS 1201
+ * http://www.jeti.com/cms/index.php/instruments/other-instruments/specbos-2101
+ */
+#define JETI_VID		0x0c6c
+#define JETI_SPC1201_PID	0x04b2
+
+/*
+ * FTDI USB UART chips used in construction projects from the
+ * Elektor Electronics magazine (http://www.elektor.com/)
+ */
+#define ELEKTOR_VID		0x0C7D
+#define ELEKTOR_FT323R_PID	0x0005	/* RFID-Reader, issue 09-2006 */
+
+/*
+ * Posiflex inc retail equipment (http://www.posiflex.com.tw)
+ */
+#define POSIFLEX_VID		0x0d3a  /* Vendor ID */
+#define POSIFLEX_PP7000_PID	0x0300  /* PP-7000II thermal printer */
+
+/*
+ * The following are the values for two KOBIL chipcard terminals.
+ */
+#define KOBIL_VID		0x0d46	/* KOBIL Vendor ID */
+#define KOBIL_CONV_B1_PID	0x2020	/* KOBIL Konverter for B1 */
+#define KOBIL_CONV_KAAN_PID	0x2021	/* KOBIL_Konverter for KAAN */
+
+#define FTDI_NF_RIC_VID	0x0DCD	/* Vendor Id */
+#define FTDI_NF_RIC_PID	0x0001	/* Product Id */
+
+/*
+ * Falcom Wireless Communications GmbH
+ */
+#define FALCOM_VID		0x0F94	/* Vendor Id */
+#define FALCOM_TWIST_PID	0x0001	/* Falcom Twist USB GPRS modem */
+#define FALCOM_SAMBA_PID	0x0005	/* Falcom Samba USB GPRS modem */
+
+/* Larsen and Brusgaard AltiTrack/USBtrack */
+#define LARSENBRUSGAARD_VID		0x0FD8
+#define LB_ALTITRACK_PID		0x0001
+
+/*
+ * TTi (Thurlby Thandar Instruments)
+ */
+#define TTI_VID			0x103E	/* Vendor Id */
+#define TTI_QL355P_PID		0x03E8	/* TTi QL355P power supply */
+
+/* Interbiometrics USB I/O Board */
+/* Developed for Interbiometrics by Rudolf Gugler */
+#define INTERBIOMETRICS_VID              0x1209
+#define INTERBIOMETRICS_IOBOARD_PID      0x1002
+#define INTERBIOMETRICS_MINI_IOBOARD_PID 0x1006
+
+/*
+ * Testo products (http://www.testo.com/)
+ * Submitted by Colin Leroy
+ */
+#define TESTO_VID			0x128D
+#define TESTO_USB_INTERFACE_PID		0x0001
+
+/*
+ * Mobility Electronics products.
+ */
+#define MOBILITY_VID			0x1342
+#define MOBILITY_USB_SERIAL_PID		0x0202	/* EasiDock USB 200 serial */
+
+/*
+ * FIC / OpenMoko, Inc. http://wiki.openmoko.org/wiki/Neo1973_Debug_Board_v3
+ * Submitted by Harald Welte <laforge@openmoko.org>
+ */
+#define	FIC_VID			0x1457
+#define	FIC_NEO1973_DEBUG_PID	0x5118
+
+/* Olimex */
+#define OLIMEX_VID			0x15BA
+#define OLIMEX_ARM_USB_OCD_PID		0x0003
+#define OLIMEX_ARM_USB_OCD_H_PID	0x002b
+
+/*
+ * Telldus Technologies
+ */
+#define TELLDUS_VID			0x1781	/* Vendor ID */
+#define TELLDUS_TELLSTICK_PID		0x0C30	/* RF control dongle 433 MHz using FT232RL */
+
+/*
+ * RT Systems programming cables for various ham radios
+ */
+#define RTSYSTEMS_VID			0x2100	/* Vendor ID */
+#define RTSYSTEMS_SERIAL_VX7_PID	0x9e52	/* Serial converter for VX-7 Radios using FT232RL */
+#define RTSYSTEMS_CT29B_PID		0x9e54	/* CT29B Radio Cable */
+#define RTSYSTEMS_RTS01_PID		0x9e57	/* USB-RTS01 Radio Cable */
+
+
+/*
+ * Physik Instrumente
+ * http://www.physikinstrumente.com/en/products/
+ */
+/* These two devices use the VID of FTDI */
+#define PI_C865_PID	0xe0a0  /* PI C-865 Piezomotor Controller */
+#define PI_C857_PID	0xe0a1  /* PI Encoder Trigger Box */
+
+#define PI_VID              0x1a72  /* Vendor ID */
+#define PI_C866_PID	0x1000  /* PI C-866 Piezomotor Controller */
+#define PI_C663_PID	0x1001  /* PI C-663 Mercury-Step */
+#define PI_C725_PID	0x1002  /* PI C-725 Piezomotor Controller */
+#define PI_E517_PID	0x1005  /* PI E-517 Digital Piezo Controller Operation Module */
+#define PI_C863_PID	0x1007  /* PI C-863 */
+#define PI_E861_PID	0x1008  /* PI E-861 Piezomotor Controller */
+#define PI_C867_PID	0x1009  /* PI C-867 Piezomotor Controller */
+#define PI_E609_PID	0x100D  /* PI E-609 Digital Piezo Controller */
+#define PI_E709_PID	0x100E  /* PI E-709 Digital Piezo Controller */
+#define PI_100F_PID	0x100F  /* PI Digital Piezo Controller */
+#define PI_1011_PID	0x1011  /* PI Digital Piezo Controller */
+#define PI_1012_PID	0x1012  /* PI Motion Controller */
+#define PI_1013_PID	0x1013  /* PI Motion Controller */
+#define PI_1014_PID	0x1014  /* PI Device */
+#define PI_1015_PID	0x1015  /* PI Device */
+#define PI_1016_PID	0x1016  /* PI Digital Servo Module */
+
+/*
+ * Kondo Kagaku Co.Ltd.
+ * http://www.kondo-robot.com/EN
+ */
+#define KONDO_VID 		0x165c
+#define KONDO_USB_SERIAL_PID	0x0002
+
+/*
+ * Bayer Ascensia Contour blood glucose meter USB-converter cable.
+ * http://winglucofacts.com/cables/
+ */
+#define BAYER_VID                      0x1A79
+#define BAYER_CONTOUR_CABLE_PID        0x6001
+
+/*
+ * The following are the values for the Matrix Orbital FTDI Range
+ * Anything in this range will use an FT232RL.
+ */
+#define MTXORB_VID			0x1B3D
+#define MTXORB_FTDI_RANGE_0100_PID	0x0100
+#define MTXORB_FTDI_RANGE_0101_PID	0x0101
+#define MTXORB_FTDI_RANGE_0102_PID	0x0102
+#define MTXORB_FTDI_RANGE_0103_PID	0x0103
+#define MTXORB_FTDI_RANGE_0104_PID	0x0104
+#define MTXORB_FTDI_RANGE_0105_PID	0x0105
+#define MTXORB_FTDI_RANGE_0106_PID	0x0106
+#define MTXORB_FTDI_RANGE_0107_PID	0x0107
+#define MTXORB_FTDI_RANGE_0108_PID	0x0108
+#define MTXORB_FTDI_RANGE_0109_PID	0x0109
+#define MTXORB_FTDI_RANGE_010A_PID	0x010A
+#define MTXORB_FTDI_RANGE_010B_PID	0x010B
+#define MTXORB_FTDI_RANGE_010C_PID	0x010C
+#define MTXORB_FTDI_RANGE_010D_PID	0x010D
+#define MTXORB_FTDI_RANGE_010E_PID	0x010E
+#define MTXORB_FTDI_RANGE_010F_PID	0x010F
+#define MTXORB_FTDI_RANGE_0110_PID	0x0110
+#define MTXORB_FTDI_RANGE_0111_PID	0x0111
+#define MTXORB_FTDI_RANGE_0112_PID	0x0112
+#define MTXORB_FTDI_RANGE_0113_PID	0x0113
+#define MTXORB_FTDI_RANGE_0114_PID	0x0114
+#define MTXORB_FTDI_RANGE_0115_PID	0x0115
+#define MTXORB_FTDI_RANGE_0116_PID	0x0116
+#define MTXORB_FTDI_RANGE_0117_PID	0x0117
+#define MTXORB_FTDI_RANGE_0118_PID	0x0118
+#define MTXORB_FTDI_RANGE_0119_PID	0x0119
+#define MTXORB_FTDI_RANGE_011A_PID	0x011A
+#define MTXORB_FTDI_RANGE_011B_PID	0x011B
+#define MTXORB_FTDI_RANGE_011C_PID	0x011C
+#define MTXORB_FTDI_RANGE_011D_PID	0x011D
+#define MTXORB_FTDI_RANGE_011E_PID	0x011E
+#define MTXORB_FTDI_RANGE_011F_PID	0x011F
+#define MTXORB_FTDI_RANGE_0120_PID	0x0120
+#define MTXORB_FTDI_RANGE_0121_PID	0x0121
+#define MTXORB_FTDI_RANGE_0122_PID	0x0122
+#define MTXORB_FTDI_RANGE_0123_PID	0x0123
+#define MTXORB_FTDI_RANGE_0124_PID	0x0124
+#define MTXORB_FTDI_RANGE_0125_PID	0x0125
+#define MTXORB_FTDI_RANGE_0126_PID	0x0126
+#define MTXORB_FTDI_RANGE_0127_PID	0x0127
+#define MTXORB_FTDI_RANGE_0128_PID	0x0128
+#define MTXORB_FTDI_RANGE_0129_PID	0x0129
+#define MTXORB_FTDI_RANGE_012A_PID	0x012A
+#define MTXORB_FTDI_RANGE_012B_PID	0x012B
+#define MTXORB_FTDI_RANGE_012C_PID	0x012C
+#define MTXORB_FTDI_RANGE_012D_PID	0x012D
+#define MTXORB_FTDI_RANGE_012E_PID	0x012E
+#define MTXORB_FTDI_RANGE_012F_PID	0x012F
+#define MTXORB_FTDI_RANGE_0130_PID	0x0130
+#define MTXORB_FTDI_RANGE_0131_PID	0x0131
+#define MTXORB_FTDI_RANGE_0132_PID	0x0132
+#define MTXORB_FTDI_RANGE_0133_PID	0x0133
+#define MTXORB_FTDI_RANGE_0134_PID	0x0134
+#define MTXORB_FTDI_RANGE_0135_PID	0x0135
+#define MTXORB_FTDI_RANGE_0136_PID	0x0136
+#define MTXORB_FTDI_RANGE_0137_PID	0x0137
+#define MTXORB_FTDI_RANGE_0138_PID	0x0138
+#define MTXORB_FTDI_RANGE_0139_PID	0x0139
+#define MTXORB_FTDI_RANGE_013A_PID	0x013A
+#define MTXORB_FTDI_RANGE_013B_PID	0x013B
+#define MTXORB_FTDI_RANGE_013C_PID	0x013C
+#define MTXORB_FTDI_RANGE_013D_PID	0x013D
+#define MTXORB_FTDI_RANGE_013E_PID	0x013E
+#define MTXORB_FTDI_RANGE_013F_PID	0x013F
+#define MTXORB_FTDI_RANGE_0140_PID	0x0140
+#define MTXORB_FTDI_RANGE_0141_PID	0x0141
+#define MTXORB_FTDI_RANGE_0142_PID	0x0142
+#define MTXORB_FTDI_RANGE_0143_PID	0x0143
+#define MTXORB_FTDI_RANGE_0144_PID	0x0144
+#define MTXORB_FTDI_RANGE_0145_PID	0x0145
+#define MTXORB_FTDI_RANGE_0146_PID	0x0146
+#define MTXORB_FTDI_RANGE_0147_PID	0x0147
+#define MTXORB_FTDI_RANGE_0148_PID	0x0148
+#define MTXORB_FTDI_RANGE_0149_PID	0x0149
+#define MTXORB_FTDI_RANGE_014A_PID	0x014A
+#define MTXORB_FTDI_RANGE_014B_PID	0x014B
+#define MTXORB_FTDI_RANGE_014C_PID	0x014C
+#define MTXORB_FTDI_RANGE_014D_PID	0x014D
+#define MTXORB_FTDI_RANGE_014E_PID	0x014E
+#define MTXORB_FTDI_RANGE_014F_PID	0x014F
+#define MTXORB_FTDI_RANGE_0150_PID	0x0150
+#define MTXORB_FTDI_RANGE_0151_PID	0x0151
+#define MTXORB_FTDI_RANGE_0152_PID	0x0152
+#define MTXORB_FTDI_RANGE_0153_PID	0x0153
+#define MTXORB_FTDI_RANGE_0154_PID	0x0154
+#define MTXORB_FTDI_RANGE_0155_PID	0x0155
+#define MTXORB_FTDI_RANGE_0156_PID	0x0156
+#define MTXORB_FTDI_RANGE_0157_PID	0x0157
+#define MTXORB_FTDI_RANGE_0158_PID	0x0158
+#define MTXORB_FTDI_RANGE_0159_PID	0x0159
+#define MTXORB_FTDI_RANGE_015A_PID	0x015A
+#define MTXORB_FTDI_RANGE_015B_PID	0x015B
+#define MTXORB_FTDI_RANGE_015C_PID	0x015C
+#define MTXORB_FTDI_RANGE_015D_PID	0x015D
+#define MTXORB_FTDI_RANGE_015E_PID	0x015E
+#define MTXORB_FTDI_RANGE_015F_PID	0x015F
+#define MTXORB_FTDI_RANGE_0160_PID	0x0160
+#define MTXORB_FTDI_RANGE_0161_PID	0x0161
+#define MTXORB_FTDI_RANGE_0162_PID	0x0162
+#define MTXORB_FTDI_RANGE_0163_PID	0x0163
+#define MTXORB_FTDI_RANGE_0164_PID	0x0164
+#define MTXORB_FTDI_RANGE_0165_PID	0x0165
+#define MTXORB_FTDI_RANGE_0166_PID	0x0166
+#define MTXORB_FTDI_RANGE_0167_PID	0x0167
+#define MTXORB_FTDI_RANGE_0168_PID	0x0168
+#define MTXORB_FTDI_RANGE_0169_PID	0x0169
+#define MTXORB_FTDI_RANGE_016A_PID	0x016A
+#define MTXORB_FTDI_RANGE_016B_PID	0x016B
+#define MTXORB_FTDI_RANGE_016C_PID	0x016C
+#define MTXORB_FTDI_RANGE_016D_PID	0x016D
+#define MTXORB_FTDI_RANGE_016E_PID	0x016E
+#define MTXORB_FTDI_RANGE_016F_PID	0x016F
+#define MTXORB_FTDI_RANGE_0170_PID	0x0170
+#define MTXORB_FTDI_RANGE_0171_PID	0x0171
+#define MTXORB_FTDI_RANGE_0172_PID	0x0172
+#define MTXORB_FTDI_RANGE_0173_PID	0x0173
+#define MTXORB_FTDI_RANGE_0174_PID	0x0174
+#define MTXORB_FTDI_RANGE_0175_PID	0x0175
+#define MTXORB_FTDI_RANGE_0176_PID	0x0176
+#define MTXORB_FTDI_RANGE_0177_PID	0x0177
+#define MTXORB_FTDI_RANGE_0178_PID	0x0178
+#define MTXORB_FTDI_RANGE_0179_PID	0x0179
+#define MTXORB_FTDI_RANGE_017A_PID	0x017A
+#define MTXORB_FTDI_RANGE_017B_PID	0x017B
+#define MTXORB_FTDI_RANGE_017C_PID	0x017C
+#define MTXORB_FTDI_RANGE_017D_PID	0x017D
+#define MTXORB_FTDI_RANGE_017E_PID	0x017E
+#define MTXORB_FTDI_RANGE_017F_PID	0x017F
+#define MTXORB_FTDI_RANGE_0180_PID	0x0180
+#define MTXORB_FTDI_RANGE_0181_PID	0x0181
+#define MTXORB_FTDI_RANGE_0182_PID	0x0182
+#define MTXORB_FTDI_RANGE_0183_PID	0x0183
+#define MTXORB_FTDI_RANGE_0184_PID	0x0184
+#define MTXORB_FTDI_RANGE_0185_PID	0x0185
+#define MTXORB_FTDI_RANGE_0186_PID	0x0186
+#define MTXORB_FTDI_RANGE_0187_PID	0x0187
+#define MTXORB_FTDI_RANGE_0188_PID	0x0188
+#define MTXORB_FTDI_RANGE_0189_PID	0x0189
+#define MTXORB_FTDI_RANGE_018A_PID	0x018A
+#define MTXORB_FTDI_RANGE_018B_PID	0x018B
+#define MTXORB_FTDI_RANGE_018C_PID	0x018C
+#define MTXORB_FTDI_RANGE_018D_PID	0x018D
+#define MTXORB_FTDI_RANGE_018E_PID	0x018E
+#define MTXORB_FTDI_RANGE_018F_PID	0x018F
+#define MTXORB_FTDI_RANGE_0190_PID	0x0190
+#define MTXORB_FTDI_RANGE_0191_PID	0x0191
+#define MTXORB_FTDI_RANGE_0192_PID	0x0192
+#define MTXORB_FTDI_RANGE_0193_PID	0x0193
+#define MTXORB_FTDI_RANGE_0194_PID	0x0194
+#define MTXORB_FTDI_RANGE_0195_PID	0x0195
+#define MTXORB_FTDI_RANGE_0196_PID	0x0196
+#define MTXORB_FTDI_RANGE_0197_PID	0x0197
+#define MTXORB_FTDI_RANGE_0198_PID	0x0198
+#define MTXORB_FTDI_RANGE_0199_PID	0x0199
+#define MTXORB_FTDI_RANGE_019A_PID	0x019A
+#define MTXORB_FTDI_RANGE_019B_PID	0x019B
+#define MTXORB_FTDI_RANGE_019C_PID	0x019C
+#define MTXORB_FTDI_RANGE_019D_PID	0x019D
+#define MTXORB_FTDI_RANGE_019E_PID	0x019E
+#define MTXORB_FTDI_RANGE_019F_PID	0x019F
+#define MTXORB_FTDI_RANGE_01A0_PID	0x01A0
+#define MTXORB_FTDI_RANGE_01A1_PID	0x01A1
+#define MTXORB_FTDI_RANGE_01A2_PID	0x01A2
+#define MTXORB_FTDI_RANGE_01A3_PID	0x01A3
+#define MTXORB_FTDI_RANGE_01A4_PID	0x01A4
+#define MTXORB_FTDI_RANGE_01A5_PID	0x01A5
+#define MTXORB_FTDI_RANGE_01A6_PID	0x01A6
+#define MTXORB_FTDI_RANGE_01A7_PID	0x01A7
+#define MTXORB_FTDI_RANGE_01A8_PID	0x01A8
+#define MTXORB_FTDI_RANGE_01A9_PID	0x01A9
+#define MTXORB_FTDI_RANGE_01AA_PID	0x01AA
+#define MTXORB_FTDI_RANGE_01AB_PID	0x01AB
+#define MTXORB_FTDI_RANGE_01AC_PID	0x01AC
+#define MTXORB_FTDI_RANGE_01AD_PID	0x01AD
+#define MTXORB_FTDI_RANGE_01AE_PID	0x01AE
+#define MTXORB_FTDI_RANGE_01AF_PID	0x01AF
+#define MTXORB_FTDI_RANGE_01B0_PID	0x01B0
+#define MTXORB_FTDI_RANGE_01B1_PID	0x01B1
+#define MTXORB_FTDI_RANGE_01B2_PID	0x01B2
+#define MTXORB_FTDI_RANGE_01B3_PID	0x01B3
+#define MTXORB_FTDI_RANGE_01B4_PID	0x01B4
+#define MTXORB_FTDI_RANGE_01B5_PID	0x01B5
+#define MTXORB_FTDI_RANGE_01B6_PID	0x01B6
+#define MTXORB_FTDI_RANGE_01B7_PID	0x01B7
+#define MTXORB_FTDI_RANGE_01B8_PID	0x01B8
+#define MTXORB_FTDI_RANGE_01B9_PID	0x01B9
+#define MTXORB_FTDI_RANGE_01BA_PID	0x01BA
+#define MTXORB_FTDI_RANGE_01BB_PID	0x01BB
+#define MTXORB_FTDI_RANGE_01BC_PID	0x01BC
+#define MTXORB_FTDI_RANGE_01BD_PID	0x01BD
+#define MTXORB_FTDI_RANGE_01BE_PID	0x01BE
+#define MTXORB_FTDI_RANGE_01BF_PID	0x01BF
+#define MTXORB_FTDI_RANGE_01C0_PID	0x01C0
+#define MTXORB_FTDI_RANGE_01C1_PID	0x01C1
+#define MTXORB_FTDI_RANGE_01C2_PID	0x01C2
+#define MTXORB_FTDI_RANGE_01C3_PID	0x01C3
+#define MTXORB_FTDI_RANGE_01C4_PID	0x01C4
+#define MTXORB_FTDI_RANGE_01C5_PID	0x01C5
+#define MTXORB_FTDI_RANGE_01C6_PID	0x01C6
+#define MTXORB_FTDI_RANGE_01C7_PID	0x01C7
+#define MTXORB_FTDI_RANGE_01C8_PID	0x01C8
+#define MTXORB_FTDI_RANGE_01C9_PID	0x01C9
+#define MTXORB_FTDI_RANGE_01CA_PID	0x01CA
+#define MTXORB_FTDI_RANGE_01CB_PID	0x01CB
+#define MTXORB_FTDI_RANGE_01CC_PID	0x01CC
+#define MTXORB_FTDI_RANGE_01CD_PID	0x01CD
+#define MTXORB_FTDI_RANGE_01CE_PID	0x01CE
+#define MTXORB_FTDI_RANGE_01CF_PID	0x01CF
+#define MTXORB_FTDI_RANGE_01D0_PID	0x01D0
+#define MTXORB_FTDI_RANGE_01D1_PID	0x01D1
+#define MTXORB_FTDI_RANGE_01D2_PID	0x01D2
+#define MTXORB_FTDI_RANGE_01D3_PID	0x01D3
+#define MTXORB_FTDI_RANGE_01D4_PID	0x01D4
+#define MTXORB_FTDI_RANGE_01D5_PID	0x01D5
+#define MTXORB_FTDI_RANGE_01D6_PID	0x01D6
+#define MTXORB_FTDI_RANGE_01D7_PID	0x01D7
+#define MTXORB_FTDI_RANGE_01D8_PID	0x01D8
+#define MTXORB_FTDI_RANGE_01D9_PID	0x01D9
+#define MTXORB_FTDI_RANGE_01DA_PID	0x01DA
+#define MTXORB_FTDI_RANGE_01DB_PID	0x01DB
+#define MTXORB_FTDI_RANGE_01DC_PID	0x01DC
+#define MTXORB_FTDI_RANGE_01DD_PID	0x01DD
+#define MTXORB_FTDI_RANGE_01DE_PID	0x01DE
+#define MTXORB_FTDI_RANGE_01DF_PID	0x01DF
+#define MTXORB_FTDI_RANGE_01E0_PID	0x01E0
+#define MTXORB_FTDI_RANGE_01E1_PID	0x01E1
+#define MTXORB_FTDI_RANGE_01E2_PID	0x01E2
+#define MTXORB_FTDI_RANGE_01E3_PID	0x01E3
+#define MTXORB_FTDI_RANGE_01E4_PID	0x01E4
+#define MTXORB_FTDI_RANGE_01E5_PID	0x01E5
+#define MTXORB_FTDI_RANGE_01E6_PID	0x01E6
+#define MTXORB_FTDI_RANGE_01E7_PID	0x01E7
+#define MTXORB_FTDI_RANGE_01E8_PID	0x01E8
+#define MTXORB_FTDI_RANGE_01E9_PID	0x01E9
+#define MTXORB_FTDI_RANGE_01EA_PID	0x01EA
+#define MTXORB_FTDI_RANGE_01EB_PID	0x01EB
+#define MTXORB_FTDI_RANGE_01EC_PID	0x01EC
+#define MTXORB_FTDI_RANGE_01ED_PID	0x01ED
+#define MTXORB_FTDI_RANGE_01EE_PID	0x01EE
+#define MTXORB_FTDI_RANGE_01EF_PID	0x01EF
+#define MTXORB_FTDI_RANGE_01F0_PID	0x01F0
+#define MTXORB_FTDI_RANGE_01F1_PID	0x01F1
+#define MTXORB_FTDI_RANGE_01F2_PID	0x01F2
+#define MTXORB_FTDI_RANGE_01F3_PID	0x01F3
+#define MTXORB_FTDI_RANGE_01F4_PID	0x01F4
+#define MTXORB_FTDI_RANGE_01F5_PID	0x01F5
+#define MTXORB_FTDI_RANGE_01F6_PID	0x01F6
+#define MTXORB_FTDI_RANGE_01F7_PID	0x01F7
+#define MTXORB_FTDI_RANGE_01F8_PID	0x01F8
+#define MTXORB_FTDI_RANGE_01F9_PID	0x01F9
+#define MTXORB_FTDI_RANGE_01FA_PID	0x01FA
+#define MTXORB_FTDI_RANGE_01FB_PID	0x01FB
+#define MTXORB_FTDI_RANGE_01FC_PID	0x01FC
+#define MTXORB_FTDI_RANGE_01FD_PID	0x01FD
+#define MTXORB_FTDI_RANGE_01FE_PID	0x01FE
+#define MTXORB_FTDI_RANGE_01FF_PID	0x01FF
+
+
+
+/*
+ * The Mobility Lab (TML)
+ * Submitted by Pierre Castella
+ */
+#define TML_VID			0x1B91	/* Vendor ID */
+#define TML_USB_SERIAL_PID	0x0064	/* USB - Serial Converter */
+
+/* Alti-2 products  http://www.alti-2.com */
+#define ALTI2_VID	0x1BC9
+#define ALTI2_N3_PID	0x6001	/* Neptune 3 */
+
+/*
+ * Ionics PlugComputer
+ */
+#define IONICS_VID			0x1c0c
+#define IONICS_PLUGCOMPUTER_PID		0x0102
+
+/*
+ * Dresden Elektronik Sensor Terminal Board
+ */
+#define DE_VID			0x1cf1 /* Vendor ID */
+#define STB_PID			0x0001 /* Sensor Terminal Board */
+#define WHT_PID			0x0004 /* Wireless Handheld Terminal */
+
+/*
+ * STMicroelectonics
+ */
+#define ST_VID			0x0483
+#define ST_STMCLT1030_PID	0x3747 /* ST Micro Connect Lite STMCLT1030 */
+
+/*
+ * Papouch products (http://www.papouch.com/)
+ * Submitted by Folkert van Heusden
+ */
+
+#define PAPOUCH_VID			0x5050	/* Vendor ID */
+#define PAPOUCH_SB485_PID		0x0100	/* Papouch SB485 USB-485/422 Converter */
+#define PAPOUCH_AP485_PID		0x0101	/* AP485 USB-RS485 Converter */
+#define PAPOUCH_SB422_PID		0x0102	/* Papouch SB422 USB-RS422 Converter  */
+#define PAPOUCH_SB485_2_PID		0x0103	/* Papouch SB485 USB-485/422 Converter */
+#define PAPOUCH_AP485_2_PID		0x0104	/* AP485 USB-RS485 Converter */
+#define PAPOUCH_SB422_2_PID		0x0105	/* Papouch SB422 USB-RS422 Converter  */
+#define PAPOUCH_SB485S_PID		0x0106	/* Papouch SB485S USB-485/422 Converter */
+#define PAPOUCH_SB485C_PID		0x0107	/* Papouch SB485C USB-485/422 Converter */
+#define PAPOUCH_LEC_PID			0x0300	/* LEC USB Converter */
+#define PAPOUCH_SB232_PID		0x0301	/* Papouch SB232 USB-RS232 Converter */
+#define PAPOUCH_TMU_PID			0x0400	/* TMU USB Thermometer */
+#define PAPOUCH_IRAMP_PID		0x0500	/* Papouch IRAmp Duplex */
+#define PAPOUCH_DRAK5_PID		0x0700	/* Papouch DRAK5 */
+#define PAPOUCH_QUIDO8x8_PID		0x0800	/* Papouch Quido 8/8 Module */
+#define PAPOUCH_QUIDO4x4_PID		0x0900	/* Papouch Quido 4/4 Module */
+#define PAPOUCH_QUIDO2x2_PID		0x0a00	/* Papouch Quido 2/2 Module */
+#define PAPOUCH_QUIDO10x1_PID		0x0b00	/* Papouch Quido 10/1 Module */
+#define PAPOUCH_QUIDO30x3_PID		0x0c00	/* Papouch Quido 30/3 Module */
+#define PAPOUCH_QUIDO60x3_PID		0x0d00	/* Papouch Quido 60(100)/3 Module */
+#define PAPOUCH_QUIDO2x16_PID		0x0e00	/* Papouch Quido 2/16 Module */
+#define PAPOUCH_QUIDO3x32_PID		0x0f00	/* Papouch Quido 3/32 Module */
+#define PAPOUCH_DRAK6_PID		0x1000	/* Papouch DRAK6 */
+#define PAPOUCH_UPSUSB_PID		0x8000	/* Papouch UPS-USB adapter */
+#define PAPOUCH_MU_PID			0x8001	/* MU controller */
+#define PAPOUCH_SIMUKEY_PID		0x8002	/* Papouch SimuKey */
+#define PAPOUCH_AD4USB_PID		0x8003	/* AD4USB Measurement Module */
+#define PAPOUCH_GMUX_PID		0x8004	/* Papouch GOLIATH MUX */
+#define PAPOUCH_GMSR_PID		0x8005	/* Papouch GOLIATH MSR */
+
+/*
+ * Marvell SheevaPlug
+ */
+#define MARVELL_VID		0x9e88
+#define MARVELL_SHEEVAPLUG_PID	0x9e8f
+
+/*
+ * Evolution Robotics products (http://www.evolution.com/).
+ * Submitted by Shawn M. Lavelle.
+ */
+#define EVOLUTION_VID		0xDEEE	/* Vendor ID */
+#define EVOLUTION_ER1_PID	0x0300	/* ER1 Control Module */
+#define EVO_8U232AM_PID		0x02FF	/* Evolution robotics RCM2 (FT232AM)*/
+#define EVO_HYBRID_PID		0x0302	/* Evolution robotics RCM4 PID (FT232BM)*/
+#define EVO_RCM4_PID		0x0303	/* Evolution robotics RCM4 PID */
+
+/*
+ * MJS Gadgets HD Radio / XM Radio / Sirius Radio interfaces (using VID 0x0403)
+ */
+#define MJSG_GENERIC_PID	0x9378
+#define MJSG_SR_RADIO_PID	0x9379
+#define MJSG_XM_RADIO_PID	0x937A
+#define MJSG_HD_RADIO_PID	0x937C
+
+/*
+ * D.O.Tec products (http://www.directout.eu)
+ */
+#define FTDI_DOTEC_PID 0x9868
+
+/*
+ * Xverve Signalyzer tools (http://www.signalyzer.com/)
+ */
+#define XVERVE_SIGNALYZER_ST_PID	0xBCA0
+#define XVERVE_SIGNALYZER_SLITE_PID	0xBCA1
+#define XVERVE_SIGNALYZER_SH2_PID	0xBCA2
+#define XVERVE_SIGNALYZER_SH4_PID	0xBCA4
+
+/*
+ * Segway Robotic Mobility Platform USB interface (using VID 0x0403)
+ * Submitted by John G. Rogers
+ */
+#define SEGWAY_RMP200_PID	0xe729
+
+
+/*
+ * Accesio USB Data Acquisition products (http://www.accesio.com/)
+ */
+#define ACCESIO_COM4SM_PID 	0xD578
+
+/* www.sciencescope.co.uk educational dataloggers */
+#define FTDI_SCIENCESCOPE_LOGBOOKML_PID		0xFF18
+#define FTDI_SCIENCESCOPE_LS_LOGBOOK_PID	0xFF1C
+#define FTDI_SCIENCESCOPE_HS_LOGBOOK_PID	0xFF1D
+
+/*
+ * Milkymist One JTAG/Serial
+ */
+#define QIHARDWARE_VID			0x20B7
+#define MILKYMISTONE_JTAGSERIAL_PID	0x0713
+
+/*
+ * CTI GmbH RS485 Converter http://www.cti-lean.com/
+ */
+/* USB-485-Mini*/
+#define FTDI_CTI_MINI_PID	0xF608
+/* USB-Nano-485*/
+#define FTDI_CTI_NANO_PID	0xF60B
+
+/*
+ * ZeitControl cardsystems GmbH rfid-readers http://zeitconrol.de
+ */
+/* TagTracer MIFARE*/
+#define FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID	0xF7C0
+
+/*
+ * Rainforest Automation
+ */
+/* ZigBee controller */
+#define FTDI_RF_R106		0x8A28
+
+/*
+ * Product: HCP HIT GPRS modem
+ * Manufacturer: HCP d.o.o.
+ * ATI command output: Cinterion MC55i
+ */
+#define FTDI_CINTERION_MC55I_PID	0xA951
diff --git a/hw/usb/quirks-pl2303-ids.h b/hw/usb/quirks-pl2303-ids.h
new file mode 100644
index 0000000..8dbdb46
--- /dev/null
+++ b/hw/usb/quirks-pl2303-ids.h
@@ -0,0 +1,150 @@
+/*
+ * Prolific PL2303 USB to serial adaptor driver header file
+ *
+ *	This program is free software; you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation; either version 2 of the License, or
+ *	(at your option) any later version.
+ *
+ */
+
+#define BENQ_VENDOR_ID			0x04a5
+#define BENQ_PRODUCT_ID_S81		0x4027
+
+#define PL2303_VENDOR_ID	0x067b
+#define PL2303_PRODUCT_ID	0x2303
+#define PL2303_PRODUCT_ID_RSAQ2		0x04bb
+#define PL2303_PRODUCT_ID_DCU11		0x1234
+#define PL2303_PRODUCT_ID_PHAROS	0xaaa0
+#define PL2303_PRODUCT_ID_RSAQ3		0xaaa2
+#define PL2303_PRODUCT_ID_ALDIGA	0x0611
+#define PL2303_PRODUCT_ID_MMX		0x0612
+#define PL2303_PRODUCT_ID_GPRS		0x0609
+#define PL2303_PRODUCT_ID_HCR331	0x331a
+#define PL2303_PRODUCT_ID_MOTOROLA	0x0307
+
+#define ATEN_VENDOR_ID		0x0557
+#define ATEN_VENDOR_ID2		0x0547
+#define ATEN_PRODUCT_ID		0x2008
+
+#define IODATA_VENDOR_ID	0x04bb
+#define IODATA_PRODUCT_ID	0x0a03
+#define IODATA_PRODUCT_ID_RSAQ5	0x0a0e
+
+#define ELCOM_VENDOR_ID		0x056e
+#define ELCOM_PRODUCT_ID	0x5003
+#define ELCOM_PRODUCT_ID_UCSGT	0x5004
+
+#define ITEGNO_VENDOR_ID	0x0eba
+#define ITEGNO_PRODUCT_ID	0x1080
+#define ITEGNO_PRODUCT_ID_2080	0x2080
+
+#define MA620_VENDOR_ID		0x0df7
+#define MA620_PRODUCT_ID	0x0620
+
+#define RATOC_VENDOR_ID		0x0584
+#define RATOC_PRODUCT_ID	0xb000
+
+#define TRIPP_VENDOR_ID		0x2478
+#define TRIPP_PRODUCT_ID	0x2008
+
+#define RADIOSHACK_VENDOR_ID	0x1453
+#define RADIOSHACK_PRODUCT_ID	0x4026
+
+#define DCU10_VENDOR_ID		0x0731
+#define DCU10_PRODUCT_ID	0x0528
+
+#define SITECOM_VENDOR_ID	0x6189
+#define SITECOM_PRODUCT_ID	0x2068
+
+/* Alcatel OT535/735 USB cable */
+#define ALCATEL_VENDOR_ID	0x11f7
+#define ALCATEL_PRODUCT_ID	0x02df
+
+/* Samsung I330 phone cradle */
+#define SAMSUNG_VENDOR_ID	0x04e8
+#define SAMSUNG_PRODUCT_ID	0x8001
+
+#define SIEMENS_VENDOR_ID	0x11f5
+#define SIEMENS_PRODUCT_ID_SX1	0x0001
+#define SIEMENS_PRODUCT_ID_X65	0x0003
+#define SIEMENS_PRODUCT_ID_X75	0x0004
+#define SIEMENS_PRODUCT_ID_EF81	0x0005
+
+#define SYNTECH_VENDOR_ID	0x0745
+#define SYNTECH_PRODUCT_ID	0x0001
+
+/* Nokia CA-42 Cable */
+#define NOKIA_CA42_VENDOR_ID	0x078b
+#define NOKIA_CA42_PRODUCT_ID	0x1234
+
+/* CA-42 CLONE Cable www.ca-42.com chipset: Prolific Technology Inc */
+#define CA_42_CA42_VENDOR_ID	0x10b5
+#define CA_42_CA42_PRODUCT_ID	0xac70
+
+#define SAGEM_VENDOR_ID		0x079b
+#define SAGEM_PRODUCT_ID	0x0027
+
+/* Leadtek GPS 9531 (ID 0413:2101) */
+#define LEADTEK_VENDOR_ID	0x0413
+#define LEADTEK_9531_PRODUCT_ID	0x2101
+
+/* USB GSM cable from Speed Dragon Multimedia, Ltd */
+#define SPEEDDRAGON_VENDOR_ID	0x0e55
+#define SPEEDDRAGON_PRODUCT_ID	0x110b
+
+/* DATAPILOT Universal-2 Phone Cable */
+#define DATAPILOT_U2_VENDOR_ID	0x0731
+#define DATAPILOT_U2_PRODUCT_ID	0x2003
+
+/* Belkin "F5U257" Serial Adapter */
+#define BELKIN_VENDOR_ID	0x050d
+#define BELKIN_PRODUCT_ID	0x0257
+
+/* Alcor Micro Corp. USB 2.0 TO RS-232 */
+#define ALCOR_VENDOR_ID		0x058F
+#define ALCOR_PRODUCT_ID	0x9720
+
+/* Willcom WS002IN Data Driver (by NetIndex Inc.) */
+#define WS002IN_VENDOR_ID	0x11f6
+#define WS002IN_PRODUCT_ID	0x2001
+
+/* Corega CG-USBRS232R Serial Adapter */
+#define COREGA_VENDOR_ID	0x07aa
+#define COREGA_PRODUCT_ID	0x002a
+
+/* Y.C. Cable U.S.A., Inc - USB to RS-232 */
+#define YCCABLE_VENDOR_ID	0x05ad
+#define YCCABLE_PRODUCT_ID	0x0fba
+
+/* "Superial" USB - Serial */
+#define SUPERIAL_VENDOR_ID	0x5372
+#define SUPERIAL_PRODUCT_ID	0x2303
+
+/* Hewlett-Packard LD220-HP POS Pole Display */
+#define HP_VENDOR_ID		0x03f0
+#define HP_LD220_PRODUCT_ID	0x3524
+
+/* Cressi Edy (diving computer) PC interface */
+#define CRESSI_VENDOR_ID	0x04b8
+#define CRESSI_EDY_PRODUCT_ID	0x0521
+
+/* Zeagle dive computer interface */
+#define ZEAGLE_VENDOR_ID	0x04b8
+#define ZEAGLE_N2ITION3_PRODUCT_ID	0x0522
+
+/* Sony, USB data cable for CMD-Jxx mobile phones */
+#define SONY_VENDOR_ID		0x054c
+#define SONY_QN3USB_PRODUCT_ID	0x0437
+
+/* Sanwa KB-USB2 multimeter cable (ID: 11ad:0001) */
+#define SANWA_VENDOR_ID		0x11ad
+#define SANWA_PRODUCT_ID	0x0001
+
+/* ADLINK ND-6530 RS232,RS485 and RS422 adapter */
+#define ADLINK_VENDOR_ID		0x0b63
+#define ADLINK_ND6530_PRODUCT_ID	0x6530
+
+/* SMART USB Serial Adapter */
+#define SMART_VENDOR_ID	0x0b8c
+#define SMART_PRODUCT_ID	0x2303
diff --git a/hw/usb/quirks.c b/hw/usb/quirks.c
new file mode 100644
index 0000000..a761a96
--- /dev/null
+++ b/hw/usb/quirks.c
@@ -0,0 +1,53 @@
+/*
+ * USB quirk handling
+ *
+ * Copyright (c) 2012 Red Hat, Inc.
+ *
+ * Red Hat Authors:
+ * Hans de Goede <hdegoede@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include "quirks.h"
+#include "hw/usb.h"
+
+static bool usb_id_match(const struct usb_device_id *ids,
+                         uint16_t vendor_id, uint16_t product_id,
+                         uint8_t interface_class, uint8_t interface_subclass,
+                         uint8_t interface_protocol) {
+    int i;
+
+    for (i = 0; ids[i].vendor_id != -1; i++) {
+        if (ids[i].vendor_id  == vendor_id &&
+            ids[i].product_id == product_id &&
+            (ids[i].interface_class == -1 ||
+             (ids[i].interface_class == interface_class &&
+              ids[i].interface_subclass == interface_subclass &&
+              ids[i].interface_protocol == interface_protocol))) {
+            return true;
+        }
+    }
+    return false;
+}
+
+int usb_get_quirks(uint16_t vendor_id, uint16_t product_id,
+                   uint8_t interface_class, uint8_t interface_subclass,
+                   uint8_t interface_protocol)
+{
+    int quirks = 0;
+
+    if (usb_id_match(usbredir_raw_serial_ids, vendor_id, product_id,
+                   interface_class, interface_subclass, interface_protocol)) {
+        quirks |= USB_QUIRK_BUFFER_BULK_IN;
+    }
+    if (usb_id_match(usbredir_ftdi_serial_ids, vendor_id, product_id,
+                   interface_class, interface_subclass, interface_protocol)) {
+        quirks |= USB_QUIRK_BUFFER_BULK_IN | USB_QUIRK_IS_FTDI;
+    }
+
+    return quirks;
+}
diff --git a/hw/usb/quirks.h b/hw/usb/quirks.h
new file mode 100644
index 0000000..8dc6065
--- /dev/null
+++ b/hw/usb/quirks.h
@@ -0,0 +1,910 @@
+/*
+ * USB quirk handling
+ *
+ * Copyright (c) 2012 Red Hat, Inc.
+ *
+ * Red Hat Authors:
+ * Hans de Goede <hdegoede@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+/* 1 on 1 copy of linux/drivers/usb/serial/ftdi_sio_ids.h */
+#include "quirks-ftdi-ids.h"
+/* 1 on 1 copy of linux/drivers/usb/serial/pl2303.h */
+#include "quirks-pl2303-ids.h"
+
+struct usb_device_id {
+    int vendor_id;
+    int product_id;
+    int interface_class;
+    int interface_subclass;
+    int interface_protocol;
+};
+
+#define USB_DEVICE(vendor, product) \
+    .vendor_id = vendor, .product_id = product, .interface_class = -1,
+
+#define USB_DEVICE_AND_INTERFACE_INFO(vend, prod, iclass, isubclass, iproto) \
+    .vendor_id = vend, .product_id = prod, .interface_class = iclass, \
+    .interface_subclass = isubclass, .interface_protocol = iproto
+
+static const struct usb_device_id usbredir_raw_serial_ids[] = {
+    /*
+     * Silicon Laboratories CP210x USB to RS232 serial adapter ids
+     * copied from linux/drivers/usb/serial/cp210x.c
+     *
+     * Copyright (C) 2005 Craig Shelley (craig@microtron.org.uk)
+     */
+    { USB_DEVICE(0x045B, 0x0053) }, /* Renesas RX610 RX-Stick */
+    { USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
+    { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
+    { USB_DEVICE(0x0489, 0xE003) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
+    { USB_DEVICE(0x0745, 0x1000) }, /* CipherLab USB CCD Barcode Scanner 1000 */
+    { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
+    { USB_DEVICE(0x08FD, 0x000A) }, /* Digianswer A/S , ZigBee/802.15.4 MAC Device */
+    { USB_DEVICE(0x0BED, 0x1100) }, /* MEI (TM) Cashflow-SC Bill/Voucher Acceptor */
+    { USB_DEVICE(0x0BED, 0x1101) }, /* MEI series 2000 Combo Acceptor */
+    { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
+    { USB_DEVICE(0x0FCF, 0x1004) }, /* Dynastream ANT2USB */
+    { USB_DEVICE(0x0FCF, 0x1006) }, /* Dynastream ANT development board */
+    { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
+    { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
+    { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
+    { USB_DEVICE(0x10C4, 0x0F91) }, /* Vstabi */
+    { USB_DEVICE(0x10C4, 0x1101) }, /* Arkham Technology DS101 Bus Monitor */
+    { USB_DEVICE(0x10C4, 0x1601) }, /* Arkham Technology DS101 Adapter */
+    { USB_DEVICE(0x10C4, 0x800A) }, /* SPORTident BSM7-D-USB main station */
+    { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
+    { USB_DEVICE(0x10C4, 0x8044) }, /* Cygnal Debug Adapter */
+    { USB_DEVICE(0x10C4, 0x804E) }, /* Software Bisque Paramount ME build-in converter */
+    { USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */
+    { USB_DEVICE(0x10C4, 0x8054) }, /* Enfora GSM2228 */
+    { USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */
+    { USB_DEVICE(0x10C4, 0x806F) }, /* IMS USB to RS422 Converter Cable */
+    { USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
+    { USB_DEVICE(0x10C4, 0x80C4) }, /* Cygnal Integrated Products, Inc., Optris infrared thermometer */
+    { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
+    { USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */
+    { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
+    { USB_DEVICE(0x10C4, 0x8115) }, /* Arygon NFC/Mifare Reader */
+    { USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */
+    { USB_DEVICE(0x10C4, 0x813F) }, /* Tams Master Easy Control */
+    { USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */
+    { USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */
+    { USB_DEVICE(0x10C4, 0x8156) }, /* B&G H3000 link cable */
+    { USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
+    { USB_DEVICE(0x10C4, 0x815F) }, /* Timewave HamLinkUSB */
+    { USB_DEVICE(0x10C4, 0x818B) }, /* AVIT Research USB to TTL */
+    { USB_DEVICE(0x10C4, 0x819F) }, /* MJS USB Toslink Switcher */
+    { USB_DEVICE(0x10C4, 0x81A6) }, /* ThinkOptics WavIt */
+    { USB_DEVICE(0x10C4, 0x81A9) }, /* Multiplex RC Interface */
+    { USB_DEVICE(0x10C4, 0x81AC) }, /* MSD Dash Hawk */
+    { USB_DEVICE(0x10C4, 0x81AD) }, /* INSYS USB Modem */
+    { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
+    { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
+    { USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */
+    { USB_DEVICE(0x10C4, 0x81E8) }, /* Zephyr Bioharness */
+    { USB_DEVICE(0x10C4, 0x81F2) }, /* C1007 HF band RFID controller */
+    { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
+    { USB_DEVICE(0x10C4, 0x822B) }, /* Modem EDGE(GSM) Comander 2 */
+    { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
+    { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
+    { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
+    { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
+    { USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */
+    { USB_DEVICE(0x10C4, 0x83A8) }, /* Amber Wireless AMB2560 */
+    { USB_DEVICE(0x10C4, 0x83D8) }, /* DekTec DTA Plus VHF/UHF Booster/Attenuator */
+    { USB_DEVICE(0x10C4, 0x8411) }, /* Kyocera GPS Module */
+    { USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
+    { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
+    { USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
+    { USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
+    { USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
+    { USB_DEVICE(0x10C4, 0x8664) }, /* AC-Services CAN-IF */
+    { USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
+    { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
+    { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
+    { USB_DEVICE(0x10C4, 0xEA70) }, /* Silicon Labs factory default */
+    { USB_DEVICE(0x10C4, 0xEA80) }, /* Silicon Labs factory default */
+    { USB_DEVICE(0x10C4, 0xEA71) }, /* Infinity GPS-MIC-1 Radio Monophone */
+    { USB_DEVICE(0x10C4, 0xF001) }, /* Elan Digital Systems USBscope50 */
+    { USB_DEVICE(0x10C4, 0xF002) }, /* Elan Digital Systems USBwave12 */
+    { USB_DEVICE(0x10C4, 0xF003) }, /* Elan Digital Systems USBpulse100 */
+    { USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */
+    { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
+    { USB_DEVICE(0x10CE, 0xEA6A) }, /* Silicon Labs MobiData GPRS USB Modem 100EU */
+    { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
+    { USB_DEVICE(0x1555, 0x0004) }, /* Owen AC4 USB-RS485 Converter */
+    { USB_DEVICE(0x166A, 0x0201) }, /* Clipsal 5500PACA C-Bus Pascal Automation Controller */
+    { USB_DEVICE(0x166A, 0x0301) }, /* Clipsal 5800PC C-Bus Wireless PC Interface */
+    { USB_DEVICE(0x166A, 0x0303) }, /* Clipsal 5500PCU C-Bus USB interface */
+    { USB_DEVICE(0x166A, 0x0304) }, /* Clipsal 5000CT2 C-Bus Black and White Touchscreen */
+    { USB_DEVICE(0x166A, 0x0305) }, /* Clipsal C-5000CT2 C-Bus Spectrum Colour Touchscreen */
+    { USB_DEVICE(0x166A, 0x0401) }, /* Clipsal L51xx C-Bus Architectural Dimmer */
+    { USB_DEVICE(0x166A, 0x0101) }, /* Clipsal 5560884 C-Bus Multi-room Audio Matrix Switcher */
+    { USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */
+    { USB_DEVICE(0x16DC, 0x0010) }, /* W-IE-NE-R Plein & Baus GmbH PL512 Power Supply */
+    { USB_DEVICE(0x16DC, 0x0011) }, /* W-IE-NE-R Plein & Baus GmbH RCM Remote Control for MARATON Power Supply */
+    { USB_DEVICE(0x16DC, 0x0012) }, /* W-IE-NE-R Plein & Baus GmbH MPOD Multi Channel Power Supply */
+    { USB_DEVICE(0x16DC, 0x0015) }, /* W-IE-NE-R Plein & Baus GmbH CML Control, Monitoring and Data Logger */
+    { USB_DEVICE(0x17A8, 0x0001) }, /* Kamstrup Optical Eye/3-wire */
+    { USB_DEVICE(0x17A8, 0x0005) }, /* Kamstrup M-Bus Master MultiPort 250D */
+    { USB_DEVICE(0x17F4, 0xAAAA) }, /* Wavesense Jazz blood glucose meter */
+    { USB_DEVICE(0x1843, 0x0200) }, /* Vaisala USB Instrument Cable */
+    { USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
+    { USB_DEVICE(0x1BE3, 0x07A6) }, /* WAGO 750-923 USB Service Cable */
+    { USB_DEVICE(0x1E29, 0x0102) }, /* Festo CPX-USB */
+    { USB_DEVICE(0x1E29, 0x0501) }, /* Festo CMSP */
+    { USB_DEVICE(0x3195, 0xF190) }, /* Link Instruments MSO-19 */
+    { USB_DEVICE(0x3195, 0xF280) }, /* Link Instruments MSO-28 */
+    { USB_DEVICE(0x3195, 0xF281) }, /* Link Instruments MSO-28 */
+    { USB_DEVICE(0x413C, 0x9500) }, /* DW700 GPS USB interface */
+
+    /*
+     * Prolific pl2303 USB to RS232 serial adapter ids
+     * copied from linux/drivers/usb/serial/pl2303.c
+     *
+     * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
+     * Copyright (C) 2003 IBM Corp.
+     */
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
+    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
+    { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
+    { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
+    { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
+    { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
+    { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
+    { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
+    { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
+    { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
+    { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
+    { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
+    { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
+    { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
+    { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
+    { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
+    { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
+    { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
+    { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
+    { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
+    { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
+    { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
+    { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
+    { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
+    { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
+    { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
+    { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
+    { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
+    { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
+    { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
+    { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
+    { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
+    { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
+    { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
+    { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
+    { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
+    { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
+    { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
+    { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
+    { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
+    { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
+    { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
+    { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
+
+    { USB_DEVICE(-1, -1) } /* Terminating Entry */
+};
+
+static const struct usb_device_id usbredir_ftdi_serial_ids[] = {
+    /*
+     * FTDI USB to RS232 serial adapter ids
+     * copied from linux/drivers/usb/serial/ftdi_sio.c
+     *
+     * Copyright (C) 2009 - 2010
+     *    Johan Hovold (jhovold@gmail.com)
+     * Copyright (C) 1999 - 2001
+     *    Greg Kroah-Hartman (greg@kroah.com)
+     *    Bill Ryder (bryder@sgi.com)
+     * Copyright (C) 2002
+     *    Kuba Ober (kuba@mareimbrium.org)
+     */
+    { USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_NXTCAM_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_0_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_1_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_3_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_4_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_5_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_6_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_7_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_USINT_CAT_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_USINT_WKEY_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_USINT_RS232_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
+    { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_4232H_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_232H_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_FTX_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_PID) },
+    { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
+    { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
+    { USB_DEVICE(FTDI_VID, FTDI_LENZ_LIUSB_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_URBAN_0_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_URBAN_1_PID) },
+    { USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_1_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_3_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_R2000KU_TRUE_RNG) },
+    { USB_DEVICE(FTDI_VID, FTDI_VARDAAN_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0100_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0101_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0102_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0103_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0104_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0105_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0106_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0107_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0108_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0109_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0110_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0111_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0112_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0113_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0114_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0115_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0116_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0117_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0118_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0119_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0120_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0121_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0122_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0123_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0124_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0125_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0126_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0127_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0128_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0129_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0130_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0131_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0132_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0133_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0134_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0135_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0136_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0137_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0138_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0139_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0140_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0141_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0142_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0143_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0144_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0145_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0146_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0147_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0148_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0149_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0150_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0151_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0152_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0153_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0154_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0155_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0156_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0157_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0158_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0159_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0160_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0161_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0162_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0163_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0164_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0165_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0166_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0167_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0168_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0169_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0170_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0171_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0172_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0173_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0174_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0175_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0176_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0177_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0178_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0179_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0180_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0181_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0182_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0183_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0184_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0185_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0186_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0187_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0188_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0189_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0190_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0191_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0192_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0193_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0194_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0195_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0196_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0197_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0198_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0199_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019A_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019B_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019C_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019D_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019E_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019F_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A0_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A1_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A2_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A3_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A4_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A5_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A6_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A7_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A8_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A9_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AA_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AB_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AC_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AD_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AE_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AF_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B0_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B1_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B2_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B3_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B4_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B5_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B6_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B7_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B8_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B9_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BA_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BB_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BC_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BD_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BE_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BF_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C0_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C1_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C2_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C3_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C4_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C5_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C6_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C7_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C8_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C9_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CA_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CB_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CC_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CD_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CE_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CF_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D0_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D1_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D2_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D3_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D4_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D5_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D6_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D7_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D8_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D9_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DA_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DB_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DC_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DD_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DE_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DF_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E0_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E1_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E2_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E3_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E4_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E5_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E6_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E7_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E8_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E9_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EA_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EB_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EC_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01ED_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EE_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EF_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F0_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F1_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F2_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F3_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F4_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F5_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F6_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F7_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F8_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F9_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FA_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FB_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FC_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FD_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FE_PID) },
+    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FF_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_USBX_707_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2106_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_1_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_2_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_3_PID) },
+    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_4_PID) },
+    { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
+    { USB_DEVICE(OCT_VID, OCT_US101_PID) },
+    { USB_DEVICE(OCT_VID, OCT_DK201_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID) },
+    { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
+    { USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
+    { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
+    { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E808_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E809_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80A_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80B_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80C_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80D_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80E_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80F_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E888_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E889_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88A_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88B_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88C_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88D_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88E_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IBS_US485_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IBS_PICPRO_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IBS_PCMCIA_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IBS_PK1_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IBS_RS232MON_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TIAO_UMPA_PID) },
+    /*
+     * ELV devices:
+     */
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_USR_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_MSM1_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_KL100_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS550_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_EC3000_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS888_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_TWS550_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_FEM_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UTP8_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS444PC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_HS485_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_UMS100_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_TFD128_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_FM3RX_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS777_PID) },
+    { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
+    { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
+    { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
+    { USB_DEVICE(FTDI_VID, LINX_FUTURE_1_PID) },
+    { USB_DEVICE(FTDI_VID, LINX_FUTURE_2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CCSMACHX_2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CCSLOAD_N_GO_3_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CCSICDU64_4_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CCSPRIME8_5_PID) },
+    { USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
+    { USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
+    { USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
+    { USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
+    { USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_OCEANIC_PID) },
+    { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
+    { USB_DEVICE(ACTON_VID, ACTON_SPECTRAPRO_PID) },
+    { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USOPTL4_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USPTL4_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_2_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR2_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_485USB9F_2W_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_485USB9F_4W_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_232USB9M_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_485USBTB_2W_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_485USBTB_4W_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_TTL5USB9M_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_TTL3USB9M_PID) },
+    { USB_DEVICE(BANDB_VID, BANDB_ZZ_PROG1_USB_PID) },
+    { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
+    { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_3_PID) },
+    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
+    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
+    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
+    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
+    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
+    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
+    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
+    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
+    { USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MHAM_KW_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MHAM_YS_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MHAM_IC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MHAM_DB9_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MHAM_RS232_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y9_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) },
+    { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
+    { USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
+    { USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HRC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16IC_PID) },
+    { USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) },
+    { USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) },
+    { USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TTUSB_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ECLO_COM_1WIRE_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_NZR_SEM_USB_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_1_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_OPC_U_UC_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C1_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C2_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2D_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VT_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VR_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVT_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVR_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVT_PID) },
+    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVR_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
+    { USB_DEVICE(TESTO_VID, TESTO_USB_INTERFACE_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_GAMMA_SCOUT_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13M_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13S_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13U_PID) },
+    { USB_DEVICE(ELEKTOR_VID, ELEKTOR_FT323R_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_NDI_HUC_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_NDI_SPECTRA_SCU_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_2_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_3_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_NDI_AURORA_SCU_PID) },
+    { USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
+    { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_SERIAL_VX7_PID) },
+    { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_CT29B_PID) },
+    { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_RTS01_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_PHI_FISCO_PID) },
+    { USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_ELSTER_UNICOM_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_PROPOX_JTAGCABLEII_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_PROPOX_ISPCABLEIII_PID) },
+    { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID) },
+    { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_H_PID) },
+    { USB_DEVICE(FIC_VID, FIC_NEO1973_DEBUG_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID) },
+    { USB_DEVICE(FTDI_VID, LMI_LM3S_DEVEL_BOARD_PID) },
+    { USB_DEVICE(FTDI_VID, LMI_LM3S_EVAL_BOARD_PID) },
+    { USB_DEVICE(FTDI_VID, LMI_LM3S_ICDI_BOARD_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_TURTELIZER_PID) },
+    { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
+    { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
+
+    /* Papouch devices based on FTDI chip */
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_2_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_2_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_2_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485S_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485C_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_LEC_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB232_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_IRAMP_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK5_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO8x8_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x2_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO10x1_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO30x3_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO60x3_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x16_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO3x32_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK6_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_UPSUSB_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_MU_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SIMUKEY_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMUX_PID) },
+    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMSR_PID) },
+
+    { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
+    { USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
+    { USB_DEVICE(FTDI_VID, DIEBOLD_BCS_SE923_PID) },
+    { USB_DEVICE(ATMEL_VID, STK541_PID) },
+    { USB_DEVICE(DE_VID, STB_PID) },
+    { USB_DEVICE(DE_VID, WHT_PID) },
+    { USB_DEVICE(ADI_VID, ADI_GNICE_PID) },
+    { USB_DEVICE(ADI_VID, ADI_GNICEPLUS_PID) },
+    { USB_DEVICE_AND_INTERFACE_INFO(MICROCHIP_VID, MICROCHIP_USB_BOARD_PID,
+                                    0xff, 0xff, 0x00) },
+    { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) },
+    { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID) },
+    { USB_DEVICE(LARSENBRUSGAARD_VID, LB_ALTITRACK_PID) },
+    { USB_DEVICE(GN_OTOMETRICS_VID, AURICAL_USB_PID) },
+    { USB_DEVICE(FTDI_VID, PI_C865_PID) },
+    { USB_DEVICE(FTDI_VID, PI_C857_PID) },
+    { USB_DEVICE(PI_VID, PI_C866_PID) },
+    { USB_DEVICE(PI_VID, PI_C663_PID) },
+    { USB_DEVICE(PI_VID, PI_C725_PID) },
+    { USB_DEVICE(PI_VID, PI_E517_PID) },
+    { USB_DEVICE(PI_VID, PI_C863_PID) },
+    { USB_DEVICE(PI_VID, PI_E861_PID) },
+    { USB_DEVICE(PI_VID, PI_C867_PID) },
+    { USB_DEVICE(PI_VID, PI_E609_PID) },
+    { USB_DEVICE(PI_VID, PI_E709_PID) },
+    { USB_DEVICE(PI_VID, PI_100F_PID) },
+    { USB_DEVICE(PI_VID, PI_1011_PID) },
+    { USB_DEVICE(PI_VID, PI_1012_PID) },
+    { USB_DEVICE(PI_VID, PI_1013_PID) },
+    { USB_DEVICE(PI_VID, PI_1014_PID) },
+    { USB_DEVICE(PI_VID, PI_1015_PID) },
+    { USB_DEVICE(PI_VID, PI_1016_PID) },
+    { USB_DEVICE(KONDO_VID, KONDO_USB_SERIAL_PID) },
+    { USB_DEVICE(BAYER_VID, BAYER_CONTOUR_CABLE_PID) },
+    { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID) },
+    { USB_DEVICE(FTDI_VID, TI_XDS100V2_PID) },
+    { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
+    { USB_DEVICE(FTDI_VID, HAMEG_HO720_PID) },
+    { USB_DEVICE(FTDI_VID, HAMEG_HO730_PID) },
+    { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
+    { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
+    { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
+    { USB_DEVICE(FTDI_VID, MJSG_HD_RADIO_PID) },
+    { USB_DEVICE(FTDI_VID, MJSG_XM_RADIO_PID) },
+    { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_ST_PID) },
+    { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SLITE_PID) },
+    { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH2_PID) },
+    { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH4_PID) },
+    { USB_DEVICE(FTDI_VID, SEGWAY_RMP200_PID) },
+    { USB_DEVICE(FTDI_VID, ACCESIO_COM4SM_PID) },
+    { USB_DEVICE(IONICS_VID, IONICS_PLUGCOMPUTER_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_24_MASTER_WING_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_PC_WING_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_USB_DMX_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MIDI_TIMECODE_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MINI_WING_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MAXI_WING_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MEDIA_WING_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_WING_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_CINTERION_MC55I_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_DOTEC_PID) },
+    { USB_DEVICE(QIHARDWARE_VID, MILKYMISTONE_JTAGSERIAL_PID) },
+    { USB_DEVICE(ST_VID, ST_STMCLT1030_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_RF_R106) },
+    { USB_DEVICE(FTDI_VID, FTDI_DISTORTEC_JTAG_LOCK_PICK_PID) },
+    { USB_DEVICE(FTDI_VID, FTDI_LUMEL_PD12_PID) },
+
+    { USB_DEVICE(-1, -1) } /* Terminating Entry */
+};
+
+#undef USB_DEVICE
+#undef USB_DEVICE_AND_INTERFACE_INFO
diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
index f15dc91..f1bf84c 100644
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -52,11 +52,13 @@
 
 typedef struct USBRedirDevice USBRedirDevice;
 
-/* Struct to hold buffered packets (iso or int input packets) */
+/* Struct to hold buffered packets */
 struct buf_packet {
     uint8_t *data;
-    int len;
-    int status;
+    void *free_on_destroy;
+    uint16_t len;
+    uint16_t offset;
+    uint8_t status;
     QTAILQ_ENTRY(buf_packet)next;
 };
 
@@ -70,11 +72,14 @@ struct endp_data {
     uint8_t iso_error; /* For reporting iso errors to the HC */
     uint8_t interrupt_started;
     uint8_t interrupt_error;
+    uint8_t bulk_receiving_enabled;
+    uint8_t bulk_receiving_started;
     uint8_t bufpq_prefilled;
     uint8_t bufpq_dropping_packets;
     QTAILQ_HEAD(, buf_packet) bufpq;
     int32_t bufpq_size;
     int32_t bufpq_target_size;
+    USBPacket *pending_async_packet;
 };
 
 struct PacketIdQueueEntry {
@@ -108,6 +113,7 @@ struct USBRedirDevice {
     struct endp_data endpoint[MAX_ENDPOINTS];
     struct PacketIdQueue cancelled;
     struct PacketIdQueue already_in_flight;
+    void (*buffered_bulk_in_complete)(USBRedirDevice *, USBPacket *, uint8_t);
     /* Data for device filtering */
     struct usb_redir_device_connect_header device_info;
     struct usb_redir_interface_info_header interface_info;
@@ -135,6 +141,8 @@ static void usbredir_interrupt_receiving_status(void *priv, uint64_t id,
     *interrupt_receiving_status);
 static void usbredir_bulk_streams_status(void *priv, uint64_t id,
     struct usb_redir_bulk_streams_status_header *bulk_streams_status);
+static void usbredir_bulk_receiving_status(void *priv, uint64_t id,
+    struct usb_redir_bulk_receiving_status_header *bulk_receiving_status);
 static void usbredir_control_packet(void *priv, uint64_t id,
     struct usb_redir_control_packet_header *control_packet,
     uint8_t *data, int data_len);
@@ -147,6 +155,9 @@ static void usbredir_iso_packet(void *priv, uint64_t id,
 static void usbredir_interrupt_packet(void *priv, uint64_t id,
     struct usb_redir_interrupt_packet_header *interrupt_header,
     uint8_t *data, int data_len);
+static void usbredir_buffered_bulk_packet(void *priv, uint64_t id,
+    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_packet,
+    uint8_t *data, int data_len);
 
 static void usbredir_handle_status(USBRedirDevice *dev, USBPacket *p,
     int status);
@@ -320,12 +331,19 @@ static void packet_id_queue_empty(struct PacketIdQueue *q)
 static void usbredir_cancel_packet(USBDevice *udev, USBPacket *p)
 {
     USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
+    int i = USBEP2I(p->ep);
 
     if (p->combined) {
         usb_combined_packet_cancel(udev, p);
         return;
     }
 
+    if (dev->endpoint[i].pending_async_packet) {
+        assert(dev->endpoint[i].pending_async_packet == p);
+        dev->endpoint[i].pending_async_packet = NULL;
+        return;
+    }
+
     packet_id_queue_add(&dev->cancelled, p->id);
     usbredirparser_send_cancel_data_packet(dev->parser, p->id);
     usbredirparser_do_write(dev->parser);
@@ -344,6 +362,11 @@ static void usbredir_fill_already_in_flight_from_ep(USBRedirDevice *dev,
 {
     static USBPacket *p;
 
+    /* async handled packets for bulk receiving eps do not count as inflight */
+    if (dev->endpoint[USBEP2I(ep)].bulk_receiving_started) {
+        return;
+    }
+
     QTAILQ_FOREACH(p, &ep->queue, queue) {
         /* Skip combined packets, except for the first */
         if (p->combined && p != p->combined->first) {
@@ -391,8 +414,8 @@ static USBPacket *usbredir_find_packet_by_id(USBRedirDevice *dev,
     return p;
 }
 
-static void bufp_alloc(USBRedirDevice *dev,
-    uint8_t *data, int len, int status, uint8_t ep)
+static void bufp_alloc(USBRedirDevice *dev, uint8_t *data, uint16_t len,
+    uint8_t status, uint8_t ep, void *free_on_destroy)
 {
     struct buf_packet *bufp;
 
@@ -416,7 +439,9 @@ static void bufp_alloc(USBRedirDevice *dev,
     bufp = g_malloc(sizeof(struct buf_packet));
     bufp->data   = data;
     bufp->len    = len;
+    bufp->offset = 0;
     bufp->status = status;
+    bufp->free_on_destroy = free_on_destroy;
     QTAILQ_INSERT_TAIL(&dev->endpoint[EP2I(ep)].bufpq, bufp, next);
     dev->endpoint[EP2I(ep)].bufpq_size++;
 }
@@ -426,7 +451,7 @@ static void bufp_free(USBRedirDevice *dev, struct buf_packet *bufp,
 {
     QTAILQ_REMOVE(&dev->endpoint[EP2I(ep)].bufpq, bufp, next);
     dev->endpoint[EP2I(ep)].bufpq_size--;
-    free(bufp->data);
+    free(bufp->free_on_destroy);
     g_free(bufp);
 }
 
@@ -577,19 +602,162 @@ static void usbredir_stop_iso_stream(USBRedirDevice *dev, uint8_t ep)
     usbredir_free_bufpq(dev, ep);
 }
 
+/*
+ * The usb-host may poll the endpoint faster then our guest, resulting in lots
+ * of smaller bulkp-s. The below buffered_bulk_in_complete* functions combine
+ * data from multiple bulkp-s into a single packet, avoiding bufpq overflows.
+ */
+static void usbredir_buffered_bulk_add_data_to_packet(USBRedirDevice *dev,
+    struct buf_packet *bulkp, int count, USBPacket *p, uint8_t ep)
+{
+    usb_packet_copy(p, bulkp->data + bulkp->offset, count);
+    bulkp->offset += count;
+    if (bulkp->offset == bulkp->len) {
+        /* Store status in the last packet with data from this bulkp */
+        usbredir_handle_status(dev, p, bulkp->status);
+        bufp_free(dev, bulkp, ep);
+    }
+}
+
+static void usbredir_buffered_bulk_in_complete_raw(USBRedirDevice *dev,
+    USBPacket *p, uint8_t ep)
+{
+    struct buf_packet *bulkp;
+    int count;
+
+    while ((bulkp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq)) &&
+           p->actual_length < p->iov.size && p->status == USB_RET_SUCCESS) {
+        count = bulkp->len - bulkp->offset;
+        if (count > (p->iov.size - p->actual_length)) {
+            count = p->iov.size - p->actual_length;
+        }
+        usbredir_buffered_bulk_add_data_to_packet(dev, bulkp, count, p, ep);
+    }
+}
+
+static void usbredir_buffered_bulk_in_complete_ftdi(USBRedirDevice *dev,
+    USBPacket *p, uint8_t ep)
+{
+    const int maxp = dev->endpoint[EP2I(ep)].max_packet_size;
+    uint8_t header[2] = { 0, 0 };
+    struct buf_packet *bulkp;
+    int count;
+
+    while ((bulkp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq)) &&
+           p->actual_length < p->iov.size && p->status == USB_RET_SUCCESS) {
+        if (bulkp->len < 2) {
+            WARNING("malformed ftdi bulk in packet\n");
+            bufp_free(dev, bulkp, ep);
+            continue;
+        }
+
+        if ((p->actual_length % maxp) == 0) {
+            usb_packet_copy(p, bulkp->data, 2);
+            memcpy(header, bulkp->data, 2);
+        } else {
+            if (bulkp->data[0] != header[0] || bulkp->data[1] != header[1]) {
+                break; /* Different header, add to next packet */
+            }
+        }
+
+        if (bulkp->offset == 0) {
+            bulkp->offset = 2; /* Skip header */
+        }
+        count = bulkp->len - bulkp->offset;
+        /* Must repeat the header at maxp interval */
+        if (count > (maxp - (p->actual_length % maxp))) {
+            count = maxp - (p->actual_length % maxp);
+        }
+        usbredir_buffered_bulk_add_data_to_packet(dev, bulkp, count, p, ep);
+    }
+}
+
+static void usbredir_buffered_bulk_in_complete(USBRedirDevice *dev,
+    USBPacket *p, uint8_t ep)
+{
+    p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
+    dev->buffered_bulk_in_complete(dev, p, ep);
+    DPRINTF("bulk-token-in ep %02X status %d len %d id %"PRIu64"\n",
+            ep, p->status, p->actual_length, p->id);
+}
+
+static void usbredir_handle_buffered_bulk_in_data(USBRedirDevice *dev,
+    USBPacket *p, uint8_t ep)
+{
+    /* Input bulk endpoint, buffered packet input */
+    if (!dev->endpoint[EP2I(ep)].bulk_receiving_started) {
+        int bpt;
+        struct usb_redir_start_bulk_receiving_header start = {
+            .endpoint = ep,
+            .stream_id = 0,
+            .no_transfers = 5,
+        };
+        /* Round bytes_per_transfer up to a multiple of max_packet_size */
+        bpt = 512 + dev->endpoint[EP2I(ep)].max_packet_size - 1;
+        bpt /= dev->endpoint[EP2I(ep)].max_packet_size;
+        bpt *= dev->endpoint[EP2I(ep)].max_packet_size;
+        start.bytes_per_transfer = bpt;
+        /* No id, we look at the ep when receiving a status back */
+        usbredirparser_send_start_bulk_receiving(dev->parser, 0, &start);
+        usbredirparser_do_write(dev->parser);
+        DPRINTF("bulk receiving started bytes/transfer %u count %d ep %02X\n",
+                start.bytes_per_transfer, start.no_transfers, ep);
+        dev->endpoint[EP2I(ep)].bulk_receiving_started = 1;
+        /* We don't really want to drop bulk packets ever, but
+           having some upper limit to how much we buffer is good. */
+        dev->endpoint[EP2I(ep)].bufpq_target_size = 5000;
+        dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
+    }
+
+    if (QTAILQ_EMPTY(&dev->endpoint[EP2I(ep)].bufpq)) {
+        DPRINTF("bulk-token-in ep %02X, no bulkp\n", ep);
+        assert(dev->endpoint[EP2I(ep)].pending_async_packet == NULL);
+        dev->endpoint[EP2I(ep)].pending_async_packet = p;
+        p->status = USB_RET_ASYNC;
+        return;
+    }
+    usbredir_buffered_bulk_in_complete(dev, p, ep);
+}
+
+static void usbredir_stop_bulk_receiving(USBRedirDevice *dev, uint8_t ep)
+{
+    struct usb_redir_stop_bulk_receiving_header stop_bulk = {
+        .endpoint = ep,
+        .stream_id = 0,
+    };
+    if (dev->endpoint[EP2I(ep)].bulk_receiving_started) {
+        usbredirparser_send_stop_bulk_receiving(dev->parser, 0, &stop_bulk);
+        DPRINTF("bulk receiving stopped ep %02X\n", ep);
+        dev->endpoint[EP2I(ep)].bulk_receiving_started = 0;
+    }
+    usbredir_free_bufpq(dev, ep);
+}
+
 static void usbredir_handle_bulk_data(USBRedirDevice *dev, USBPacket *p,
                                       uint8_t ep)
 {
     struct usb_redir_bulk_packet_header bulk_packet;
     size_t size = (p->combined) ? p->combined->iov.size : p->iov.size;
-
-    DPRINTF("bulk-out ep %02X len %zd id %"PRIu64"\n", ep, size, p->id);
+    const int maxp = dev->endpoint[EP2I(ep)].max_packet_size;
 
     if (usbredir_already_in_flight(dev, p->id)) {
         p->status = USB_RET_ASYNC;
         return;
     }
 
+    if (dev->endpoint[EP2I(ep)].bulk_receiving_enabled) {
+        if (size != 0 && (size % maxp) == 0) {
+            usbredir_handle_buffered_bulk_in_data(dev, p, ep);
+            return;
+        }
+        WARNING("bulk recv invalid size %zd ep %02x, disabling\n", size, ep);
+        assert(dev->endpoint[EP2I(ep)].pending_async_packet == NULL);
+        usbredir_stop_bulk_receiving(dev, ep);
+        dev->endpoint[EP2I(ep)].bulk_receiving_enabled = 0;
+    }
+
+    DPRINTF("bulk-out ep %02X len %zd id %"PRIu64"\n", ep, size, p->id);
+
     bulk_packet.endpoint  = ep;
     bulk_packet.length    = size;
     bulk_packet.stream_id = 0;
@@ -726,9 +894,6 @@ static void usbredir_handle_data(USBDevice *udev, USBPacket *p)
         ERROR("handle_data called for control transfer on ep %02X\n", ep);
         p->status = USB_RET_NAK;
         break;
-    case USB_ENDPOINT_XFER_ISOC:
-        usbredir_handle_iso_data(dev, p, ep);
-        break;
     case USB_ENDPOINT_XFER_BULK:
         if (p->state == USB_PACKET_SETUP && p->pid == USB_TOKEN_IN &&
                 p->ep->pipeline) {
@@ -737,6 +902,9 @@ static void usbredir_handle_data(USBDevice *udev, USBPacket *p)
         }
         usbredir_handle_bulk_data(dev, p, ep);
         break;
+    case USB_ENDPOINT_XFER_ISOC:
+        usbredir_handle_iso_data(dev, p, ep);
+        break;
     case USB_ENDPOINT_XFER_INT:
         if (ep & USB_DIR_IN) {
             usbredir_handle_interrupt_in_data(dev, p, ep);
@@ -763,6 +931,11 @@ static void usbredir_stop_ep(USBRedirDevice *dev, int i)
     uint8_t ep = I2EP(i);
 
     switch (dev->endpoint[i].type) {
+    case USB_ENDPOINT_XFER_BULK:
+        if (ep & USB_DIR_IN) {
+            usbredir_stop_bulk_receiving(dev, ep);
+        }
+        break;
     case USB_ENDPOINT_XFER_ISOC:
         usbredir_stop_iso_stream(dev, ep);
         break;
@@ -942,10 +1115,12 @@ static void usbredir_create_parser(USBRedirDevice *dev)
     dev->parser->interrupt_receiving_status_func =
         usbredir_interrupt_receiving_status;
     dev->parser->bulk_streams_status_func = usbredir_bulk_streams_status;
+    dev->parser->bulk_receiving_status_func = usbredir_bulk_receiving_status;
     dev->parser->control_packet_func = usbredir_control_packet;
     dev->parser->bulk_packet_func = usbredir_bulk_packet;
     dev->parser->iso_packet_func = usbredir_iso_packet;
     dev->parser->interrupt_packet_func = usbredir_interrupt_packet;
+    dev->parser->buffered_bulk_packet_func = usbredir_buffered_bulk_packet;
     dev->read_buf = NULL;
     dev->read_buf_size = 0;
 
@@ -954,6 +1129,7 @@ static void usbredir_create_parser(USBRedirDevice *dev)
     usbredirparser_caps_set_cap(caps, usb_redir_cap_ep_info_max_packet_size);
     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 (runstate_check(RUN_STATE_INMIGRATE)) {
         flags |= usbredirparser_fl_no_hello;
@@ -1192,6 +1368,52 @@ error:
     return -1;
 }
 
+static void usbredir_check_bulk_receiving(USBRedirDevice *dev)
+{
+    int i, j, quirks;
+
+    if (!usbredirparser_peer_has_cap(dev->parser,
+                                     usb_redir_cap_bulk_receiving)) {
+        return;
+    }
+
+    for (i = EP2I(USB_DIR_IN); i < MAX_ENDPOINTS; i++) {
+        dev->endpoint[i].bulk_receiving_enabled = 0;
+    }
+    for (i = 0; i < dev->interface_info.interface_count; i++) {
+        quirks = usb_get_quirks(dev->device_info.vendor_id,
+                                dev->device_info.product_id,
+                                dev->interface_info.interface_class[i],
+                                dev->interface_info.interface_subclass[i],
+                                dev->interface_info.interface_protocol[i]);
+        if (!(quirks & USB_QUIRK_BUFFER_BULK_IN)) {
+            continue;
+        }
+        if (quirks & USB_QUIRK_IS_FTDI) {
+            dev->buffered_bulk_in_complete =
+                usbredir_buffered_bulk_in_complete_ftdi;
+        } else {
+            dev->buffered_bulk_in_complete =
+                usbredir_buffered_bulk_in_complete_raw;
+        }
+
+        for (j = EP2I(USB_DIR_IN); j < MAX_ENDPOINTS; j++) {
+            if (dev->endpoint[j].interface ==
+                                    dev->interface_info.interface[i] &&
+                    dev->endpoint[j].type == USB_ENDPOINT_XFER_BULK &&
+                    dev->endpoint[j].max_packet_size != 0) {
+                dev->endpoint[j].bulk_receiving_enabled = 1;
+                /*
+                 * With buffering pipelining is not necessary. Also packet
+                 * combining and bulk in buffering don't play nice together!
+                 */
+                I2USBEP(dev, j)->pipeline = false;
+                break; /* Only buffer for the first ep of each intf */
+            }
+        }
+    }
+}
+
 /*
  * usbredirparser packet complete callbacks
  */
@@ -1300,6 +1522,7 @@ static void usbredir_device_connect(void *priv,
         return;
     }
 
+    usbredir_check_bulk_receiving(dev);
     qemu_mod_timer(dev->attach_timer, dev->next_attach_time);
 }
 
@@ -1338,9 +1561,10 @@ static void usbredir_interface_info(void *priv,
 
     /*
      * If we receive interface info after the device has already been
-     * connected (ie on a set_config), re-check the filter.
+     * connected (ie on a set_config), re-check interface dependent things.
      */
     if (qemu_timer_pending(dev->attach_timer) || dev->dev.attached) {
+        usbredir_check_bulk_receiving(dev);
         if (usbredir_check_filter(dev)) {
             ERROR("Device no longer matches filter after interface info "
                   "change, disconnecting!\n");
@@ -1441,6 +1665,7 @@ static void usbredir_ep_info(void *priv,
         return;
     }
     usbredir_setup_usb_eps(dev);
+    usbredir_check_bulk_receiving(dev);
 }
 
 static void usbredir_configuration_status(void *priv, uint64_t id,
@@ -1531,6 +1756,25 @@ static void usbredir_bulk_streams_status(void *priv, uint64_t id,
 {
 }
 
+static void usbredir_bulk_receiving_status(void *priv, uint64_t id,
+    struct usb_redir_bulk_receiving_status_header *bulk_receiving_status)
+{
+    USBRedirDevice *dev = priv;
+    uint8_t ep = bulk_receiving_status->endpoint;
+
+    DPRINTF("bulk recv status %d ep %02X id %"PRIu64"\n",
+            bulk_receiving_status->status, ep, id);
+
+    if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].bulk_receiving_started) {
+        return;
+    }
+
+    if (bulk_receiving_status->status == usb_redir_stall) {
+        DPRINTF("bulk receiving stopped by peer ep %02X\n", ep);
+        dev->endpoint[EP2I(ep)].bulk_receiving_started = 0;
+    }
+}
+
 static void usbredir_control_packet(void *priv, uint64_t id,
     struct usb_redir_control_packet_header *control_packet,
     uint8_t *data, int data_len)
@@ -1636,7 +1880,7 @@ static void usbredir_iso_packet(void *priv, uint64_t id,
     }
 
     /* bufp_alloc also adds the packet to the ep queue */
-    bufp_alloc(dev, data, data_len, iso_packet->status, ep);
+    bufp_alloc(dev, data, data_len, iso_packet->status, ep, data);
 }
 
 static void usbredir_interrupt_packet(void *priv, uint64_t id,
@@ -1667,7 +1911,7 @@ static void usbredir_interrupt_packet(void *priv, uint64_t id,
         }
 
         /* bufp_alloc also adds the packet to the ep queue */
-        bufp_alloc(dev, data, data_len, interrupt_packet->status, ep);
+        bufp_alloc(dev, data, data_len, interrupt_packet->status, ep, data);
     } else {
         /*
          * We report output interrupt packets as completed directly upon
@@ -1680,6 +1924,52 @@ static void usbredir_interrupt_packet(void *priv, uint64_t id,
     }
 }
 
+static void usbredir_buffered_bulk_packet(void *priv, uint64_t id,
+    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_packet,
+    uint8_t *data, int data_len)
+{
+    USBRedirDevice *dev = priv;
+    uint8_t status, ep = buffered_bulk_packet->endpoint;
+    void *free_on_destroy;
+    int i, len;
+
+    DPRINTF("buffered-bulk-in status %d ep %02X len %d id %"PRIu64"\n",
+            buffered_bulk_packet->status, ep, data_len, id);
+
+    if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_BULK) {
+        ERROR("received buffered-bulk packet for non bulk ep %02X\n", ep);
+        free(data);
+        return;
+    }
+
+    if (dev->endpoint[EP2I(ep)].bulk_receiving_started == 0) {
+        DPRINTF("received buffered-bulk packet on not started ep %02X\n", ep);
+        free(data);
+        return;
+    }
+
+    /* Data must be in maxp chunks for buffered_bulk_add_*_data_to_packet */
+    len = dev->endpoint[EP2I(ep)].max_packet_size;
+    status = usb_redir_success;
+    free_on_destroy = NULL;
+    for (i = 0; i < data_len; i += len) {
+        if (len >= (data_len - i)) {
+            len = data_len - i;
+            status = buffered_bulk_packet->status;
+            free_on_destroy = data;
+        }
+        /* bufp_alloc also adds the packet to the ep queue */
+        bufp_alloc(dev, data + i, len, status, ep, free_on_destroy);
+    }
+
+    if (dev->endpoint[EP2I(ep)].pending_async_packet) {
+        USBPacket *p = dev->endpoint[EP2I(ep)].pending_async_packet;
+        dev->endpoint[EP2I(ep)].pending_async_packet = NULL;
+        usbredir_buffered_bulk_in_complete(dev, p, ep);
+        usb_packet_complete(&dev->dev, p);
+    }
+}
+
 /*
  * Migration code
  */
@@ -1714,6 +2004,7 @@ static int usbredir_post_load(void *priv, int version_id)
     dev->dev.speedmask = (1 << dev->dev.speed);
 
     usbredir_setup_usb_eps(dev);
+    usbredir_check_bulk_receiving(dev);
 
     return 0;
 }
@@ -1787,15 +2078,16 @@ static void usbredir_put_bufpq(QEMUFile *f, void *priv, size_t unused)
     struct endp_data *endp = priv;
     USBRedirDevice *dev = endp->dev;
     struct buf_packet *bufp;
-    int i = 0;
+    int len, i = 0;
 
     qemu_put_be32(f, endp->bufpq_size);
     QTAILQ_FOREACH(bufp, &endp->bufpq, next) {
+        len = bufp->len - bufp->offset;
         DPRINTF("put_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size,
-                bufp->len, bufp->status);
-        qemu_put_be32(f, bufp->len);
+                len, bufp->status);
+        qemu_put_be32(f, len);
         qemu_put_be32(f, bufp->status);
-        qemu_put_buffer(f, bufp->data, bufp->len);
+        qemu_put_buffer(f, bufp->data + bufp->offset, len);
         i++;
     }
     assert(i == endp->bufpq_size);
@@ -1813,7 +2105,9 @@ static int usbredir_get_bufpq(QEMUFile *f, void *priv, size_t unused)
         bufp = g_malloc(sizeof(struct buf_packet));
         bufp->len = qemu_get_be32(f);
         bufp->status = qemu_get_be32(f);
+        bufp->offset = 0;
         bufp->data = qemu_oom_check(malloc(bufp->len)); /* regular malloc! */
+        bufp->free_on_destroy = bufp->data;
         qemu_get_buffer(f, bufp->data, bufp->len);
         QTAILQ_INSERT_TAIL(&endp->bufpq, bufp, next);
         DPRINTF("get_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size,
@@ -1830,6 +2124,23 @@ static const VMStateInfo usbredir_ep_bufpq_vmstate_info = {
 
 
 /* For endp_data migration */
+static const VMStateDescription usbredir_bulk_receiving_vmstate = {
+    .name = "usb-redir-ep/bulk-receiving",
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .fields = (VMStateField[]) {
+        VMSTATE_UINT8(bulk_receiving_started, struct endp_data),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
+static bool usbredir_bulk_receiving_needed(void *priv)
+{
+    struct endp_data *endp = priv;
+
+    return endp->bulk_receiving_started;
+}
+
 static const VMStateDescription usbredir_ep_vmstate = {
     .name = "usb-redir-ep",
     .version_id = 1,
@@ -1856,6 +2167,14 @@ static const VMStateDescription usbredir_ep_vmstate = {
         },
         VMSTATE_INT32(bufpq_target_size, struct endp_data),
         VMSTATE_END_OF_LIST()
+    },
+    .subsections = (VMStateSubsection[]) {
+        {
+            .vmsd = &usbredir_bulk_receiving_vmstate,
+            .needed = usbredir_bulk_receiving_needed,
+        }, {
+            /* empty */
+        }
     }
 };
 
-- 
1.7.1

Re: [Qemu-devel] [PATCH 31/32] usbredir: Add support for buffered bulk input (v2)

[Blue Swirl]

On Tue, Jan 8, 2013 at 1:14 PM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> From: Hans de Goede <hdegoede@redhat.com>
>
> Buffered bulk mode is intended for bulk *input* endpoints, where the data is
> of a streaming nature (not part of a command-response protocol). These
> endpoints' input buffer may overflow if data is not read quickly enough.
> So in buffered bulk mode the usb-host takes care of the submitting and
> re-submitting of bulk transfers.
>
> Buffered bulk mode is necessary for reliable operation with the bulk in
> endpoints of usb to serial convertors. Unfortunatelty buffered bulk input
> mode will only work with certain devices, therefor this patch also adds a
> usb-id table to enable it for devices which need it, while leaving the
> bulk ep handling for other devices unmodified.
>
> Note that the bumping of the required usbredir from 0.5.3 to 0.6 does
> not mean that we will now need a newer usbredir release then qemu-1.3,
> .pc files reporting 0.5.3 have only ever existed in usbredir builds directly
> from git, so qemu-1.3 needs the 0.6 release too.
>
> Changes in v2:
> -Split of quirk handling into quirks.c
>
> Signed-off-by: Hans de Goede <hdegoede@redhat.com>
> ---
>  configure                  |    2 +-
>  hw/usb.h                   |   12 +-
>  hw/usb/Makefile.objs       |    2 +-
>  hw/usb/quirks-ftdi-ids.h   | 1255 ++++++++++++++++++++++++++++++++++++++++++++
>  hw/usb/quirks-pl2303-ids.h |  150 ++++++
>  hw/usb/quirks.c            |   53 ++
>  hw/usb/quirks.h            |  910 ++++++++++++++++++++++++++++++++
>  hw/usb/redirect.c          |  355 ++++++++++++-
>  8 files changed, 2718 insertions(+), 21 deletions(-)
>  create mode 100644 hw/usb/quirks-ftdi-ids.h
>  create mode 100644 hw/usb/quirks-pl2303-ids.h
>  create mode 100644 hw/usb/quirks.c
>  create mode 100644 hw/usb/quirks.h
>
> diff --git a/configure b/configure
> index fe18ed2..82f6e71 100755
> --- a/configure
> +++ b/configure
> @@ -2851,7 +2851,7 @@ fi
>
>  # check for usbredirparser for usb network redirection support
>  if test "$usb_redir" != "no" ; then
> -    if $pkg_config --atleast-version=0.5.3 libusbredirparser-0.5 >/dev/null 2>&1 ; then
> +    if $pkg_config --atleast-version=0.6 libusbredirparser-0.5 >/dev/null 2>&1 ; then
>          usb_redir="yes"
>          usb_redir_cflags=$($pkg_config --cflags libusbredirparser-0.5 2>/dev/null)
>          usb_redir_libs=$($pkg_config --libs libusbredirparser-0.5 2>/dev/null)
> diff --git a/hw/usb.h b/hw/usb.h
> index aca8ff6..50c297f 100644
> --- a/hw/usb.h
> +++ b/hw/usb.h
> @@ -553,5 +553,15 @@ const USBDesc *usb_device_get_usb_desc(USBDevice *dev);
>
>  int ehci_create_ich9_with_companions(PCIBus *bus, int slot);
>
> -#endif
> +/* quirks.c */
> +
> +/* In bulk endpoints are streaming data sources (iow behave like isoc eps) */
> +#define USB_QUIRK_BUFFER_BULK_IN       0x01
> +/* Bulk pkts in FTDI format, need special handling when combining packets */
> +#define USB_QUIRK_IS_FTDI              0x02
>
> +int usb_get_quirks(uint16_t vendor_id, uint16_t product_id,
> +                   uint8_t interface_class, uint8_t interface_subclass,
> +                   uint8_t interface_protocol);
> +
> +#endif
> diff --git a/hw/usb/Makefile.objs b/hw/usb/Makefile.objs
> index 5a4eeb6..dad4cb9 100644
> --- a/hw/usb/Makefile.objs
> +++ b/hw/usb/Makefile.objs
> @@ -5,7 +5,7 @@ common-obj-$(CONFIG_USB_XHCI) += hcd-xhci.o
>  common-obj-y += libhw.o
>
>  common-obj-$(CONFIG_SMARTCARD) += dev-smartcard-reader.o
> -common-obj-$(CONFIG_USB_REDIR) += redirect.o
> +common-obj-$(CONFIG_USB_REDIR) += redirect.o quirks.o
>
>  common-obj-y += core.o combined-packet.o bus.o desc.o dev-hub.o
>  common-obj-y += host-$(HOST_USB).o dev-bluetooth.o
> diff --git a/hw/usb/quirks-ftdi-ids.h b/hw/usb/quirks-ftdi-ids.h
> new file mode 100644
> index 0000000..57c12ef
> --- /dev/null
> +++ b/hw/usb/quirks-ftdi-ids.h
> @@ -0,0 +1,1255 @@
> +/*
> + * vendor/product IDs (VID/PID) of devices using FTDI USB serial converters.
> + * Please keep numerically sorted within individual areas, thanks!
> + *
> + * Philipp Gühring - pg@futureware.at - added the Device ID of the USB relais
> + * from Rudolf Gugler

License information is missing.

Where is this file coming from, Linux? Should we use linux-headers instead?

> + *
> + */
> +
> +
> +/**********************************/
> +/***** devices using FTDI VID *****/
> +/**********************************/
> +
> +
> +#define FTDI_VID       0x0403  /* Vendor Id */
> +
> +
> +/*** "original" FTDI device PIDs ***/
> +
> +#define FTDI_8U232AM_PID 0x6001 /* Similar device to SIO above */
> +#define FTDI_8U232AM_ALT_PID 0x6006 /* FTDI's alternate PID for above */
> +#define FTDI_8U2232C_PID 0x6010 /* Dual channel device */
> +#define FTDI_4232H_PID 0x6011 /* Quad channel hi-speed device */
> +#define FTDI_232H_PID  0x6014 /* Single channel hi-speed device */
> +#define FTDI_FTX_PID   0x6015 /* FT-X series (FT201X, FT230X, FT231X, etc) */
> +#define FTDI_SIO_PID   0x8372  /* Product Id SIO application of 8U100AX */
> +#define FTDI_232RL_PID  0xFBFA  /* Product ID for FT232RL */
> +
> +
> +/*** third-party PIDs (using FTDI_VID) ***/
> +
> +#define FTDI_LUMEL_PD12_PID    0x6002
> +
> +/*
> + * Marvell OpenRD Base, Client
> + * http://www.open-rd.org
> + * OpenRD Base, Client use VID 0x0403
> + */
> +#define MARVELL_OPENRD_PID     0x9e90
> +
> +/* www.candapter.com Ewert Energy Systems CANdapter device */
> +#define FTDI_CANDAPTER_PID 0x9F80 /* Product Id */
> +
> +/*
> + * Texas Instruments XDS100v2 JTAG / BeagleBone A3
> + * http://processors.wiki.ti.com/index.php/XDS100
> + * http://beagleboard.org/bone
> + */
> +#define TI_XDS100V2_PID                0xa6d0
> +
> +#define FTDI_NXTCAM_PID                0xABB8 /* NXTCam for Mindstorms NXT */
> +
> +/* US Interface Navigator (http://www.usinterface.com/) */
> +#define FTDI_USINT_CAT_PID     0xb810  /* Navigator CAT and 2nd PTT lines */
> +#define FTDI_USINT_WKEY_PID    0xb811  /* Navigator WKEY and FSK lines */
> +#define FTDI_USINT_RS232_PID   0xb812  /* Navigator RS232 and CONFIG lines */
> +
> +/* OOCDlink by Joern Kaipf <joernk@web.de>
> + * (http://www.joernonline.de/) */
> +#define FTDI_OOCDLINK_PID      0xbaf8  /* Amontec JTAGkey */
> +
> +/* Luminary Micro Stellaris Boards, VID = FTDI_VID */
> +/* FTDI 2332C Dual channel device, side A=245 FIFO (JTAG), Side B=RS232 UART */
> +#define LMI_LM3S_DEVEL_BOARD_PID       0xbcd8
> +#define LMI_LM3S_EVAL_BOARD_PID                0xbcd9
> +#define LMI_LM3S_ICDI_BOARD_PID                0xbcda
> +
> +#define FTDI_TURTELIZER_PID    0xBDC8 /* JTAG/RS-232 adapter by egnite GmbH */
> +
> +/* OpenDCC (www.opendcc.de) product id */
> +#define FTDI_OPENDCC_PID       0xBFD8
> +#define FTDI_OPENDCC_SNIFFER_PID       0xBFD9
> +#define FTDI_OPENDCC_THROTTLE_PID      0xBFDA
> +#define FTDI_OPENDCC_GATEWAY_PID       0xBFDB
> +#define FTDI_OPENDCC_GBM_PID   0xBFDC
> +
> +/* NZR SEM 16+ USB (http://www.nzr.de) */
> +#define FTDI_NZR_SEM_USB_PID   0xC1E0  /* NZR SEM-LOG16+ */
> +
> +/*
> + * RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
> + */
> +#define FTDI_RRCIRKITS_LOCOBUFFER_PID  0xc7d0  /* LocoBuffer USB */
> +
> +/* DMX4ALL DMX Interfaces */
> +#define FTDI_DMX4ALL 0xC850
> +
> +/*
> + * ASK.fr devices
> + */
> +#define FTDI_ASK_RDR400_PID    0xC991  /* ASK RDR 400 series card reader */
> +
> +/* www.starting-point-systems.com µChameleon device */
> +#define FTDI_MICRO_CHAMELEON_PID       0xCAA0  /* Product Id */
> +
> +/*
> + * Tactrix OpenPort (ECU) devices.
> + * OpenPort 1.3M submitted by Donour Sizemore.
> + * OpenPort 1.3S and 1.3U submitted by Ian Abbott.
> + */
> +#define FTDI_TACTRIX_OPENPORT_13M_PID  0xCC48  /* OpenPort 1.3 Mitsubishi */
> +#define FTDI_TACTRIX_OPENPORT_13S_PID  0xCC49  /* OpenPort 1.3 Subaru */
> +#define FTDI_TACTRIX_OPENPORT_13U_PID  0xCC4A  /* OpenPort 1.3 Universal */
> +
> +#define FTDI_DISTORTEC_JTAG_LOCK_PICK_PID      0xCFF8
> +
> +/* SCS HF Radio Modems PID's (http://www.scs-ptc.com) */
> +/* the VID is the standard ftdi vid (FTDI_VID) */
> +#define FTDI_SCS_DEVICE_0_PID 0xD010    /* SCS PTC-IIusb */
> +#define FTDI_SCS_DEVICE_1_PID 0xD011    /* SCS Tracker / DSP TNC */
> +#define FTDI_SCS_DEVICE_2_PID 0xD012
> +#define FTDI_SCS_DEVICE_3_PID 0xD013
> +#define FTDI_SCS_DEVICE_4_PID 0xD014
> +#define FTDI_SCS_DEVICE_5_PID 0xD015
> +#define FTDI_SCS_DEVICE_6_PID 0xD016
> +#define FTDI_SCS_DEVICE_7_PID 0xD017
> +
> +/* iPlus device */
> +#define FTDI_IPLUS_PID 0xD070 /* Product Id */
> +#define FTDI_IPLUS2_PID 0xD071 /* Product Id */
> +
> +/*
> + * Gamma Scout (http://gamma-scout.com/). Submitted by rsc@runtux.com.
> + */
> +#define FTDI_GAMMA_SCOUT_PID           0xD678  /* Gamma Scout online */
> +
> +/* Propox devices */
> +#define FTDI_PROPOX_JTAGCABLEII_PID    0xD738
> +#define FTDI_PROPOX_ISPCABLEIII_PID    0xD739
> +
> +/* Lenz LI-USB Computer Interface. */
> +#define FTDI_LENZ_LIUSB_PID    0xD780
> +
> +/* Vardaan Enterprises Serial Interface VEUSB422R3 */
> +#define FTDI_VARDAAN_PID       0xF070
> +
> +/*
> + * Xsens Technologies BV products (http://www.xsens.com).
> + */
> +#define XSENS_CONVERTER_0_PID  0xD388
> +#define XSENS_CONVERTER_1_PID  0xD389
> +#define XSENS_CONVERTER_2_PID  0xD38A
> +#define XSENS_CONVERTER_3_PID  0xD38B
> +#define XSENS_CONVERTER_4_PID  0xD38C
> +#define XSENS_CONVERTER_5_PID  0xD38D
> +#define XSENS_CONVERTER_6_PID  0xD38E
> +#define XSENS_CONVERTER_7_PID  0xD38F
> +
> +/*
> + * NDI (www.ndigital.com) product ids
> + */
> +#define FTDI_NDI_HUC_PID               0xDA70  /* NDI Host USB Converter */
> +#define FTDI_NDI_SPECTRA_SCU_PID       0xDA71  /* NDI Spectra SCU */
> +#define FTDI_NDI_FUTURE_2_PID          0xDA72  /* NDI future device #2 */
> +#define FTDI_NDI_FUTURE_3_PID          0xDA73  /* NDI future device #3 */
> +#define FTDI_NDI_AURORA_SCU_PID                0xDA74  /* NDI Aurora SCU */
> +
> +/*
> + * ChamSys Limited (www.chamsys.co.uk) USB wing/interface product IDs
> + */
> +#define FTDI_CHAMSYS_24_MASTER_WING_PID        0xDAF8
> +#define FTDI_CHAMSYS_PC_WING_PID       0xDAF9
> +#define FTDI_CHAMSYS_USB_DMX_PID       0xDAFA
> +#define FTDI_CHAMSYS_MIDI_TIMECODE_PID 0xDAFB
> +#define FTDI_CHAMSYS_MINI_WING_PID     0xDAFC
> +#define FTDI_CHAMSYS_MAXI_WING_PID     0xDAFD
> +#define FTDI_CHAMSYS_MEDIA_WING_PID    0xDAFE
> +#define FTDI_CHAMSYS_WING_PID  0xDAFF
> +
> +/*
> + * Westrex International devices submitted by Cory Lee
> + */
> +#define FTDI_WESTREX_MODEL_777_PID     0xDC00  /* Model 777 */
> +#define FTDI_WESTREX_MODEL_8900F_PID   0xDC01  /* Model 8900F */
> +
> +/*
> + * ACG Identification Technologies GmbH products (http://www.acg.de/).
> + * Submitted by anton -at- goto10 -dot- org.
> + */
> +#define FTDI_ACG_HFDUAL_PID            0xDD20  /* HF Dual ISO Reader (RFID) */
> +
> +/*
> + * Definitions for Artemis astronomical USB based cameras
> + * Check it at http://www.artemisccd.co.uk/
> + */
> +#define FTDI_ARTEMIS_PID       0xDF28  /* All Artemis Cameras */
> +
> +/*
> + * Definitions for ATIK Instruments astronomical USB based cameras
> + * Check it at http://www.atik-instruments.com/
> + */
> +#define FTDI_ATIK_ATK16_PID    0xDF30  /* ATIK ATK-16 Grayscale Camera */
> +#define FTDI_ATIK_ATK16C_PID   0xDF32  /* ATIK ATK-16C Colour Camera */
> +#define FTDI_ATIK_ATK16HR_PID  0xDF31  /* ATIK ATK-16HR Grayscale Camera */
> +#define FTDI_ATIK_ATK16HRC_PID 0xDF33  /* ATIK ATK-16HRC Colour Camera */
> +#define FTDI_ATIK_ATK16IC_PID   0xDF35  /* ATIK ATK-16IC Grayscale Camera */
> +
> +/*
> + * Yost Engineering, Inc. products (www.yostengineering.com).
> + * PID 0xE050 submitted by Aaron Prose.
> + */
> +#define FTDI_YEI_SERVOCENTER31_PID     0xE050  /* YEI ServoCenter3.1 USB */
> +
> +/*
> + * ELV USB devices submitted by Christian Abt of ELV (www.elv.de).
> + * All of these devices use FTDI's vendor ID (0x0403).
> + * Further IDs taken from ELV Windows .inf file.
> + *
> + * The previously included PID for the UO 100 module was incorrect.
> + * In fact, that PID was for ELV's UR 100 USB-RS232 converter (0xFB58).
> + *
> + * Armin Laeuger originally sent the PID for the UM 100 module.
> + */
> +#define FTDI_ELV_USR_PID       0xE000  /* ELV Universal-Sound-Recorder */
> +#define FTDI_ELV_MSM1_PID      0xE001  /* ELV Mini-Sound-Modul */
> +#define FTDI_ELV_KL100_PID     0xE002  /* ELV Kfz-Leistungsmesser KL 100 */
> +#define FTDI_ELV_WS550_PID     0xE004  /* WS 550 */
> +#define FTDI_ELV_EC3000_PID    0xE006  /* ENERGY CONTROL 3000 USB */
> +#define FTDI_ELV_WS888_PID     0xE008  /* WS 888 */
> +#define FTDI_ELV_TWS550_PID    0xE009  /* Technoline WS 550 */
> +#define FTDI_ELV_FEM_PID       0xE00A  /* Funk Energie Monitor */
> +#define FTDI_ELV_FHZ1300PC_PID 0xE0E8  /* FHZ 1300 PC */
> +#define FTDI_ELV_WS500_PID     0xE0E9  /* PC-Wetterstation (WS 500) */
> +#define FTDI_ELV_HS485_PID     0xE0EA  /* USB to RS-485 adapter */
> +#define FTDI_ELV_UMS100_PID    0xE0EB  /* ELV USB Master-Slave Schaltsteckdose UMS 100 */
> +#define FTDI_ELV_TFD128_PID    0xE0EC  /* ELV Temperatur-Feuchte-Datenlogger TFD 128 */
> +#define FTDI_ELV_FM3RX_PID     0xE0ED  /* ELV Messwertuebertragung FM3 RX */
> +#define FTDI_ELV_WS777_PID     0xE0EE  /* Conrad WS 777 */
> +#define FTDI_ELV_EM1010PC_PID  0xE0EF  /* Energy monitor EM 1010 PC */
> +#define FTDI_ELV_CSI8_PID      0xE0F0  /* Computer-Schalt-Interface (CSI 8) */
> +#define FTDI_ELV_EM1000DL_PID  0xE0F1  /* PC-Datenlogger fuer Energiemonitor (EM 1000 DL) */
> +#define FTDI_ELV_PCK100_PID    0xE0F2  /* PC-Kabeltester (PCK 100) */
> +#define FTDI_ELV_RFP500_PID    0xE0F3  /* HF-Leistungsmesser (RFP 500) */
> +#define FTDI_ELV_FS20SIG_PID   0xE0F4  /* Signalgeber (FS 20 SIG) */
> +#define FTDI_ELV_UTP8_PID      0xE0F5  /* ELV UTP 8 */
> +#define FTDI_ELV_WS300PC_PID   0xE0F6  /* PC-Wetterstation (WS 300 PC) */
> +#define FTDI_ELV_WS444PC_PID   0xE0F7  /* Conrad WS 444 PC */
> +#define FTDI_PHI_FISCO_PID      0xE40B  /* PHI Fisco USB to Serial cable */
> +#define FTDI_ELV_UAD8_PID      0xF068  /* USB-AD-Wandler (UAD 8) */
> +#define FTDI_ELV_UDA7_PID      0xF069  /* USB-DA-Wandler (UDA 7) */
> +#define FTDI_ELV_USI2_PID      0xF06A  /* USB-Schrittmotoren-Interface (USI 2) */
> +#define FTDI_ELV_T1100_PID     0xF06B  /* Thermometer (T 1100) */
> +#define FTDI_ELV_PCD200_PID    0xF06C  /* PC-Datenlogger (PCD 200) */
> +#define FTDI_ELV_ULA200_PID    0xF06D  /* USB-LCD-Ansteuerung (ULA 200) */
> +#define FTDI_ELV_ALC8500_PID   0xF06E  /* ALC 8500 Expert */
> +#define FTDI_ELV_FHZ1000PC_PID 0xF06F  /* FHZ 1000 PC */
> +#define FTDI_ELV_UR100_PID     0xFB58  /* USB-RS232-Umsetzer (UR 100) */
> +#define FTDI_ELV_UM100_PID     0xFB5A  /* USB-Modul UM 100 */
> +#define FTDI_ELV_UO100_PID     0xFB5B  /* USB-Modul UO 100 */
> +/* Additional ELV PIDs that default to using the FTDI D2XX drivers on
> + * MS Windows, rather than the FTDI Virtual Com Port drivers.
> + * Maybe these will be easier to use with the libftdi/libusb user-space
> + * drivers, or possibly the Comedi drivers in some cases. */
> +#define FTDI_ELV_CLI7000_PID   0xFB59  /* Computer-Light-Interface (CLI 7000) */
> +#define FTDI_ELV_PPS7330_PID   0xFB5C  /* Processor-Power-Supply (PPS 7330) */
> +#define FTDI_ELV_TFM100_PID    0xFB5D  /* Temperatur-Feuchte-Messgeraet (TFM 100) */
> +#define FTDI_ELV_UDF77_PID     0xFB5E  /* USB DCF Funkuhr (UDF 77) */
> +#define FTDI_ELV_UIO88_PID     0xFB5F  /* USB-I/O Interface (UIO 88) */
> +
> +/*
> + * EVER Eco Pro UPS (http://www.ever.com.pl/)
> + */
> +
> +#define        EVER_ECO_PRO_CDS        0xe520  /* RS-232 converter */
> +
> +/*
> + * Active Robots product ids.
> + */
> +#define FTDI_ACTIVE_ROBOTS_PID 0xE548  /* USB comms board */
> +
> +/* Pyramid Computer GmbH */
> +#define FTDI_PYRAMID_PID       0xE6C8  /* Pyramid Appliance Display */
> +
> +/* www.elsterelectricity.com Elster Unicom III Optical Probe */
> +#define FTDI_ELSTER_UNICOM_PID         0xE700 /* Product Id */
> +
> +/*
> + * Gude Analog- und Digitalsysteme GmbH
> + */
> +#define FTDI_GUDEADS_E808_PID    0xE808
> +#define FTDI_GUDEADS_E809_PID    0xE809
> +#define FTDI_GUDEADS_E80A_PID    0xE80A
> +#define FTDI_GUDEADS_E80B_PID    0xE80B
> +#define FTDI_GUDEADS_E80C_PID    0xE80C
> +#define FTDI_GUDEADS_E80D_PID    0xE80D
> +#define FTDI_GUDEADS_E80E_PID    0xE80E
> +#define FTDI_GUDEADS_E80F_PID    0xE80F
> +#define FTDI_GUDEADS_E888_PID    0xE888  /* Expert ISDN Control USB */
> +#define FTDI_GUDEADS_E889_PID    0xE889  /* USB RS-232 OptoBridge */
> +#define FTDI_GUDEADS_E88A_PID    0xE88A
> +#define FTDI_GUDEADS_E88B_PID    0xE88B
> +#define FTDI_GUDEADS_E88C_PID    0xE88C
> +#define FTDI_GUDEADS_E88D_PID    0xE88D
> +#define FTDI_GUDEADS_E88E_PID    0xE88E
> +#define FTDI_GUDEADS_E88F_PID    0xE88F
> +
> +/*
> + * Eclo (http://www.eclo.pt/) product IDs.
> + * PID 0xEA90 submitted by Martin Grill.
> + */
> +#define FTDI_ECLO_COM_1WIRE_PID        0xEA90  /* COM to 1-Wire USB adaptor */
> +
> +/* TNC-X USB-to-packet-radio adapter, versions prior to 3.0 (DLP module) */
> +#define FTDI_TNC_X_PID         0xEBE0
> +
> +/*
> + * Teratronik product ids.
> + * Submitted by O. Wölfelschneider.
> + */
> +#define FTDI_TERATRONIK_VCP_PID         0xEC88 /* Teratronik device (preferring VCP driver on windows) */
> +#define FTDI_TERATRONIK_D2XX_PID 0xEC89        /* Teratronik device (preferring D2XX driver on windows) */
> +
> +/* Rig Expert Ukraine devices */
> +#define FTDI_REU_TINY_PID              0xED22  /* RigExpert Tiny */
> +
> +/*
> + * Hameg HO820 and HO870 interface (using VID 0x0403)
> + */
> +#define HAMEG_HO820_PID                        0xed74
> +#define HAMEG_HO730_PID                        0xed73
> +#define HAMEG_HO720_PID                        0xed72
> +#define HAMEG_HO870_PID                        0xed71
> +
> +/*
> + *  MaxStream devices  www.maxstream.net
> + */
> +#define FTDI_MAXSTREAM_PID     0xEE18  /* Xbee PKG-U Module */
> +
> +/*
> + * microHAM product IDs (http://www.microham.com).
> + * Submitted by Justin Burket (KL1RL) <zorton@jtan.com>
> + * and Mike Studer (K6EEP) <k6eep@hamsoftware.org>.
> + * Ian Abbott <abbotti@mev.co.uk> added a few more from the driver INF file.
> + */
> +#define FTDI_MHAM_KW_PID       0xEEE8  /* USB-KW interface */
> +#define FTDI_MHAM_YS_PID       0xEEE9  /* USB-YS interface */
> +#define FTDI_MHAM_Y6_PID       0xEEEA  /* USB-Y6 interface */
> +#define FTDI_MHAM_Y8_PID       0xEEEB  /* USB-Y8 interface */
> +#define FTDI_MHAM_IC_PID       0xEEEC  /* USB-IC interface */
> +#define FTDI_MHAM_DB9_PID      0xEEED  /* USB-DB9 interface */
> +#define FTDI_MHAM_RS232_PID    0xEEEE  /* USB-RS232 interface */
> +#define FTDI_MHAM_Y9_PID       0xEEEF  /* USB-Y9 interface */
> +
> +/* Domintell products  http://www.domintell.com */
> +#define FTDI_DOMINTELL_DGQG_PID        0xEF50  /* Master */
> +#define FTDI_DOMINTELL_DUSB_PID        0xEF51  /* DUSB01 module */
> +
> +/*
> + * The following are the values for the Perle Systems
> + * UltraPort USB serial converters
> + */
> +#define FTDI_PERLE_ULTRAPORT_PID 0xF0C0        /* Perle UltraPort Product Id */
> +
> +/* Sprog II (Andrew Crosland's SprogII DCC interface) */
> +#define FTDI_SPROG_II          0xF0C8
> +
> +/* an infrared receiver for user access control with IR tags */
> +#define FTDI_PIEGROUP_PID      0xF208  /* Product Id */
> +
> +/* ACT Solutions HomePro ZWave interface
> +   (http://www.act-solutions.com/HomePro-Product-Matrix.html) */
> +#define FTDI_ACTZWAVE_PID      0xF2D0
> +
> +/*
> + * 4N-GALAXY.DE PIDs for CAN-USB, USB-RS232, USB-RS422, USB-RS485,
> + * USB-TTY aktiv, USB-TTY passiv.  Some PIDs are used by several devices
> + * and I'm not entirely sure which are used by which.
> + */
> +#define FTDI_4N_GALAXY_DE_1_PID        0xF3C0
> +#define FTDI_4N_GALAXY_DE_2_PID        0xF3C1
> +#define FTDI_4N_GALAXY_DE_3_PID        0xF3C2
> +
> +/*
> + * Linx Technologies product ids
> + */
> +#define LINX_SDMUSBQSS_PID     0xF448  /* Linx SDM-USB-QS-S */
> +#define LINX_MASTERDEVEL2_PID   0xF449 /* Linx Master Development 2.0 */
> +#define LINX_FUTURE_0_PID   0xF44A     /* Linx future device */
> +#define LINX_FUTURE_1_PID   0xF44B     /* Linx future device */
> +#define LINX_FUTURE_2_PID   0xF44C     /* Linx future device */
> +
> +/*
> + * Oceanic product ids
> + */
> +#define FTDI_OCEANIC_PID       0xF460  /* Oceanic dive instrument */
> +
> +/*
> + * SUUNTO product ids
> + */
> +#define FTDI_SUUNTO_SPORTS_PID 0xF680  /* Suunto Sports instrument */
> +
> +/* USB-UIRT - An infrared receiver and transmitter using the 8U232AM chip */
> +/* http://www.usbuirt.com/ */
> +#define FTDI_USB_UIRT_PID      0xF850  /* Product Id */
> +
> +/* CCS Inc. ICDU/ICDU40 product ID -
> + * the FT232BM is used in an in-circuit-debugger unit for PIC16's/PIC18's */
> +#define FTDI_CCSICDU20_0_PID    0xF9D0
> +#define FTDI_CCSICDU40_1_PID    0xF9D1
> +#define FTDI_CCSMACHX_2_PID     0xF9D2
> +#define FTDI_CCSLOAD_N_GO_3_PID 0xF9D3
> +#define FTDI_CCSICDU64_4_PID    0xF9D4
> +#define FTDI_CCSPRIME8_5_PID    0xF9D5
> +
> +/*
> + * The following are the values for the Matrix Orbital LCD displays,
> + * which are the FT232BM ( similar to the 8U232AM )
> + */
> +#define FTDI_MTXORB_0_PID      0xFA00  /* Matrix Orbital Product Id */
> +#define FTDI_MTXORB_1_PID      0xFA01  /* Matrix Orbital Product Id */
> +#define FTDI_MTXORB_2_PID      0xFA02  /* Matrix Orbital Product Id */
> +#define FTDI_MTXORB_3_PID      0xFA03  /* Matrix Orbital Product Id */
> +#define FTDI_MTXORB_4_PID      0xFA04  /* Matrix Orbital Product Id */
> +#define FTDI_MTXORB_5_PID      0xFA05  /* Matrix Orbital Product Id */
> +#define FTDI_MTXORB_6_PID      0xFA06  /* Matrix Orbital Product Id */
> +
> +/*
> + * Home Electronics (www.home-electro.com) USB gadgets
> + */
> +#define FTDI_HE_TIRA1_PID      0xFA78  /* Tira-1 IR transceiver */
> +
> +/* Inside Accesso contactless reader (http://www.insidecontactless.com/) */
> +#define INSIDE_ACCESSO         0xFAD0
> +
> +/*
> + * ThorLabs USB motor drivers
> + */
> +#define FTDI_THORLABS_PID              0xfaf0 /* ThorLabs USB motor drivers */
> +
> +/*
> + * Protego product ids
> + */
> +#define PROTEGO_SPECIAL_1      0xFC70  /* special/unknown device */
> +#define PROTEGO_R2X0           0xFC71  /* R200-USB TRNG unit (R210, R220, and R230) */
> +#define PROTEGO_SPECIAL_3      0xFC72  /* special/unknown device */
> +#define PROTEGO_SPECIAL_4      0xFC73  /* special/unknown device */
> +
> +/*
> + * Sony Ericsson product ids
> + */
> +#define FTDI_DSS20_PID         0xFC82  /* DSS-20 Sync Station for Sony Ericsson P800 */
> +#define FTDI_URBAN_0_PID       0xFC8A  /* Sony Ericsson Urban, uart #0 */
> +#define FTDI_URBAN_1_PID       0xFC8B  /* Sony Ericsson Urban, uart #1 */
> +
> +/* www.irtrans.de device */
> +#define FTDI_IRTRANS_PID 0xFC60 /* Product Id */
> +
> +/*
> + * RM Michaelides CANview USB (http://www.rmcan.com) (FTDI_VID)
> + * CAN fieldbus interface adapter, added by port GmbH www.port.de)
> + * Ian Abbott changed the macro names for consistency.
> + */
> +#define FTDI_RM_CANVIEW_PID    0xfd60  /* Product Id */
> +/* www.thoughttechnology.com/ TT-USB provide with procomp use ftdi_sio */
> +#define FTDI_TTUSB_PID 0xFF20 /* Product Id */
> +
> +#define FTDI_USBX_707_PID 0xF857       /* ADSTech IR Blaster USBX-707 (FTDI_VID) */
> +
> +#define FTDI_RELAIS_PID        0xFA10  /* Relais device from Rudolf Gugler */
> +
> +/*
> + * PCDJ use ftdi based dj-controllers. The following PID is
> + * for their DAC-2 device http://www.pcdjhardware.com/DAC2.asp
> + * (the VID is the standard ftdi vid (FTDI_VID), PID sent by Wouter Paesen)
> + */
> +#define FTDI_PCDJ_DAC2_PID 0xFA88
> +
> +#define FTDI_R2000KU_TRUE_RNG  0xFB80  /* R2000KU TRUE RNG (FTDI_VID) */
> +
> +/*
> + * DIEBOLD BCS SE923 (FTDI_VID)
> + */
> +#define DIEBOLD_BCS_SE923_PID  0xfb99
> +
> +/* www.crystalfontz.com devices
> + * - thanx for providing free devices for evaluation !
> + * they use the ftdi chipset for the USB interface
> + * and the vendor id is the same
> + */
> +#define FTDI_XF_632_PID 0xFC08 /* 632: 16x2 Character Display */
> +#define FTDI_XF_634_PID 0xFC09 /* 634: 20x4 Character Display */
> +#define FTDI_XF_547_PID 0xFC0A /* 547: Two line Display */
> +#define FTDI_XF_633_PID 0xFC0B /* 633: 16x2 Character Display with Keys */
> +#define FTDI_XF_631_PID 0xFC0C /* 631: 20x2 Character Display */
> +#define FTDI_XF_635_PID 0xFC0D /* 635: 20x4 Character Display */
> +#define FTDI_XF_640_PID 0xFC0E /* 640: Two line Display */
> +#define FTDI_XF_642_PID 0xFC0F /* 642: Two line Display */
> +
> +/*
> + * Video Networks Limited / Homechoice in the UK use an ftdi-based device
> + * for their 1Mb broadband internet service.  The following PID is exhibited
> + * by the usb device supplied (the VID is the standard ftdi vid (FTDI_VID)
> + */
> +#define FTDI_VNHCPCUSB_D_PID 0xfe38 /* Product Id */
> +
> +/* AlphaMicro Components AMC-232USB01 device (FTDI_VID) */
> +#define FTDI_AMC232_PID 0xFF00 /* Product Id */
> +
> +/*
> + * IBS elektronik product ids (FTDI_VID)
> + * Submitted by Thomas Schleusener
> + */
> +#define FTDI_IBS_US485_PID     0xff38  /* IBS US485 (USB<-->RS422/485 interface) */
> +#define FTDI_IBS_PICPRO_PID    0xff39  /* IBS PIC-Programmer */
> +#define FTDI_IBS_PCMCIA_PID    0xff3a  /* IBS Card reader for PCMCIA SRAM-cards */
> +#define FTDI_IBS_PK1_PID       0xff3b  /* IBS PK1 - Particel counter */
> +#define FTDI_IBS_RS232MON_PID  0xff3c  /* IBS RS232 - Monitor */
> +#define FTDI_IBS_APP70_PID     0xff3d  /* APP 70 (dust monitoring system) */
> +#define FTDI_IBS_PEDO_PID      0xff3e  /* IBS PEDO-Modem (RF modem 868.35 MHz) */
> +#define FTDI_IBS_PROD_PID      0xff3f  /* future device */
> +/* www.canusb.com Lawicel CANUSB device (FTDI_VID) */
> +#define FTDI_CANUSB_PID 0xFFA8 /* Product Id */
> +
> +/*
> + * TavIR AVR product ids (FTDI_VID)
> + */
> +#define FTDI_TAVIR_STK500_PID  0xFA33  /* STK500 AVR programmer */
> +
> +/*
> + * TIAO product ids (FTDI_VID)
> + * http://www.tiaowiki.com/w/Main_Page
> + */
> +#define FTDI_TIAO_UMPA_PID     0x8a98  /* TIAO/DIYGADGET USB Multi-Protocol Adapter */
> +
> +
> +/********************************/
> +/** third-party VID/PID combos **/
> +/********************************/
> +
> +
> +
> +/*
> + * Atmel STK541
> + */
> +#define ATMEL_VID              0x03eb /* Vendor ID */
> +#define STK541_PID             0x2109 /* Zigbee Controller */
> +
> +/*
> + * Blackfin gnICE JTAG
> + * http://docs.blackfin.uclinux.org/doku.php?id=hw:jtag:gnice
> + */
> +#define ADI_VID                        0x0456
> +#define ADI_GNICE_PID          0xF000
> +#define ADI_GNICEPLUS_PID      0xF001
> +
> +/*
> + * Microchip Technology, Inc.
> + *
> + * MICROCHIP_VID (0x04D8) and MICROCHIP_USB_BOARD_PID (0x000A) are
> + * used by single function CDC ACM class based firmware demo
> + * applications.  The VID/PID has also been used in firmware
> + * emulating FTDI serial chips by:
> + * Hornby Elite - Digital Command Control Console
> + * http://www.hornby.com/hornby-dcc/controllers/
> + */
> +#define MICROCHIP_VID          0x04D8
> +#define MICROCHIP_USB_BOARD_PID        0x000A /* CDC RS-232 Emulation Demo */
> +
> +/*
> + * RATOC REX-USB60F
> + */
> +#define RATOC_VENDOR_ID                0x0584
> +#define RATOC_PRODUCT_ID_USB60F        0xb020
> +
> +/*
> + * Acton Research Corp.
> + */
> +#define ACTON_VID              0x0647  /* Vendor ID */
> +#define ACTON_SPECTRAPRO_PID   0x0100
> +
> +/*
> + * Contec products (http://www.contec.com)
> + * Submitted by Daniel Sangorrin
> + */
> +#define CONTEC_VID             0x06CE  /* Vendor ID */
> +#define CONTEC_COM1USBH_PID    0x8311  /* COM-1(USB)H */
> +
> +/*
> + * Definitions for B&B Electronics products.
> + */
> +#define BANDB_VID              0x0856  /* B&B Electronics Vendor ID */
> +#define BANDB_USOTL4_PID       0xAC01  /* USOTL4 Isolated RS-485 Converter */
> +#define BANDB_USTL4_PID                0xAC02  /* USTL4 RS-485 Converter */
> +#define BANDB_USO9ML2_PID      0xAC03  /* USO9ML2 Isolated RS-232 Converter */
> +#define BANDB_USOPTL4_PID      0xAC11
> +#define BANDB_USPTL4_PID       0xAC12
> +#define BANDB_USO9ML2DR_2_PID  0xAC16
> +#define BANDB_USO9ML2DR_PID    0xAC17
> +#define BANDB_USOPTL4DR2_PID   0xAC18  /* USOPTL4R-2 2-port Isolated RS-232 Converter */
> +#define BANDB_USOPTL4DR_PID    0xAC19
> +#define BANDB_485USB9F_2W_PID  0xAC25
> +#define BANDB_485USB9F_4W_PID  0xAC26
> +#define BANDB_232USB9M_PID     0xAC27
> +#define BANDB_485USBTB_2W_PID  0xAC33
> +#define BANDB_485USBTB_4W_PID  0xAC34
> +#define BANDB_TTL5USB9M_PID    0xAC49
> +#define BANDB_TTL3USB9M_PID    0xAC50
> +#define BANDB_ZZ_PROG1_USB_PID 0xBA02
> +
> +/*
> + * Intrepid Control Systems (http://www.intrepidcs.com/) ValueCAN and NeoVI
> + */
> +#define INTREPID_VID           0x093C
> +#define INTREPID_VALUECAN_PID  0x0601
> +#define INTREPID_NEOVI_PID     0x0701
> +
> +/*
> + * Definitions for ID TECH (www.idt-net.com) devices
> + */
> +#define IDTECH_VID             0x0ACD  /* ID TECH Vendor ID */
> +#define IDTECH_IDT1221U_PID    0x0300  /* IDT1221U USB to RS-232 adapter */
> +
> +/*
> + * Definitions for Omnidirectional Control Technology, Inc. devices
> + */
> +#define OCT_VID                        0x0B39  /* OCT vendor ID */
> +/* Note: OCT US101 is also rebadged as Dick Smith Electronics (NZ) XH6381 */
> +/* Also rebadged as Dick Smith Electronics (Aus) XH6451 */
> +/* Also rebadged as SIIG Inc. model US2308 hardware version 1 */
> +#define OCT_DK201_PID          0x0103  /* OCT DK201 USB docking station */
> +#define OCT_US101_PID          0x0421  /* OCT US101 USB to RS-232 */
> +
> +/*
> + * Definitions for Icom Inc. devices
> + */
> +#define ICOM_VID               0x0C26 /* Icom vendor ID */
> +/* Note: ID-1 is a communications tranceiver for HAM-radio operators */
> +#define ICOM_ID_1_PID          0x0004 /* ID-1 USB to RS-232 */
> +/* Note: OPC is an Optional cable to connect an Icom Tranceiver */
> +#define ICOM_OPC_U_UC_PID      0x0018 /* OPC-478UC, OPC-1122U cloning cable */
> +/* Note: ID-RP* devices are Icom Repeater Devices for HAM-radio */
> +#define ICOM_ID_RP2C1_PID      0x0009 /* ID-RP2C Asset 1 to RS-232 */
> +#define ICOM_ID_RP2C2_PID      0x000A /* ID-RP2C Asset 2 to RS-232 */
> +#define ICOM_ID_RP2D_PID       0x000B /* ID-RP2D configuration port*/
> +#define ICOM_ID_RP2VT_PID      0x000C /* ID-RP2V Transmit config port */
> +#define ICOM_ID_RP2VR_PID      0x000D /* ID-RP2V Receive config port */
> +#define ICOM_ID_RP4KVT_PID     0x0010 /* ID-RP4000V Transmit config port */
> +#define ICOM_ID_RP4KVR_PID     0x0011 /* ID-RP4000V Receive config port */
> +#define ICOM_ID_RP2KVT_PID     0x0012 /* ID-RP2000V Transmit config port */
> +#define ICOM_ID_RP2KVR_PID     0x0013 /* ID-RP2000V Receive config port */
> +
> +/*
> + * GN Otometrics (http://www.otometrics.com)
> + * Submitted by Ville Sundberg.
> + */
> +#define GN_OTOMETRICS_VID      0x0c33  /* Vendor ID */
> +#define AURICAL_USB_PID                0x0010  /* Aurical USB Audiometer */
> +
> +/*
> + * The following are the values for the Sealevel SeaLINK+ adapters.
> + * (Original list sent by Tuan Hoang.  Ian Abbott renamed the macros and
> + * removed some PIDs that don't seem to match any existing products.)
> + */
> +#define SEALEVEL_VID           0x0c52  /* Sealevel Vendor ID */
> +#define SEALEVEL_2101_PID      0x2101  /* SeaLINK+232 (2101/2105) */
> +#define SEALEVEL_2102_PID      0x2102  /* SeaLINK+485 (2102) */
> +#define SEALEVEL_2103_PID      0x2103  /* SeaLINK+232I (2103) */
> +#define SEALEVEL_2104_PID      0x2104  /* SeaLINK+485I (2104) */
> +#define SEALEVEL_2106_PID      0x9020  /* SeaLINK+422 (2106) */
> +#define SEALEVEL_2201_1_PID    0x2211  /* SeaPORT+2/232 (2201) Port 1 */
> +#define SEALEVEL_2201_2_PID    0x2221  /* SeaPORT+2/232 (2201) Port 2 */
> +#define SEALEVEL_2202_1_PID    0x2212  /* SeaPORT+2/485 (2202) Port 1 */
> +#define SEALEVEL_2202_2_PID    0x2222  /* SeaPORT+2/485 (2202) Port 2 */
> +#define SEALEVEL_2203_1_PID    0x2213  /* SeaPORT+2 (2203) Port 1 */
> +#define SEALEVEL_2203_2_PID    0x2223  /* SeaPORT+2 (2203) Port 2 */
> +#define SEALEVEL_2401_1_PID    0x2411  /* SeaPORT+4/232 (2401) Port 1 */
> +#define SEALEVEL_2401_2_PID    0x2421  /* SeaPORT+4/232 (2401) Port 2 */
> +#define SEALEVEL_2401_3_PID    0x2431  /* SeaPORT+4/232 (2401) Port 3 */
> +#define SEALEVEL_2401_4_PID    0x2441  /* SeaPORT+4/232 (2401) Port 4 */
> +#define SEALEVEL_2402_1_PID    0x2412  /* SeaPORT+4/485 (2402) Port 1 */
> +#define SEALEVEL_2402_2_PID    0x2422  /* SeaPORT+4/485 (2402) Port 2 */
> +#define SEALEVEL_2402_3_PID    0x2432  /* SeaPORT+4/485 (2402) Port 3 */
> +#define SEALEVEL_2402_4_PID    0x2442  /* SeaPORT+4/485 (2402) Port 4 */
> +#define SEALEVEL_2403_1_PID    0x2413  /* SeaPORT+4 (2403) Port 1 */
> +#define SEALEVEL_2403_2_PID    0x2423  /* SeaPORT+4 (2403) Port 2 */
> +#define SEALEVEL_2403_3_PID    0x2433  /* SeaPORT+4 (2403) Port 3 */
> +#define SEALEVEL_2403_4_PID    0x2443  /* SeaPORT+4 (2403) Port 4 */
> +#define SEALEVEL_2801_1_PID    0X2811  /* SeaLINK+8/232 (2801) Port 1 */
> +#define SEALEVEL_2801_2_PID    0X2821  /* SeaLINK+8/232 (2801) Port 2 */
> +#define SEALEVEL_2801_3_PID    0X2831  /* SeaLINK+8/232 (2801) Port 3 */
> +#define SEALEVEL_2801_4_PID    0X2841  /* SeaLINK+8/232 (2801) Port 4 */
> +#define SEALEVEL_2801_5_PID    0X2851  /* SeaLINK+8/232 (2801) Port 5 */
> +#define SEALEVEL_2801_6_PID    0X2861  /* SeaLINK+8/232 (2801) Port 6 */
> +#define SEALEVEL_2801_7_PID    0X2871  /* SeaLINK+8/232 (2801) Port 7 */
> +#define SEALEVEL_2801_8_PID    0X2881  /* SeaLINK+8/232 (2801) Port 8 */
> +#define SEALEVEL_2802_1_PID    0X2812  /* SeaLINK+8/485 (2802) Port 1 */
> +#define SEALEVEL_2802_2_PID    0X2822  /* SeaLINK+8/485 (2802) Port 2 */
> +#define SEALEVEL_2802_3_PID    0X2832  /* SeaLINK+8/485 (2802) Port 3 */
> +#define SEALEVEL_2802_4_PID    0X2842  /* SeaLINK+8/485 (2802) Port 4 */
> +#define SEALEVEL_2802_5_PID    0X2852  /* SeaLINK+8/485 (2802) Port 5 */
> +#define SEALEVEL_2802_6_PID    0X2862  /* SeaLINK+8/485 (2802) Port 6 */
> +#define SEALEVEL_2802_7_PID    0X2872  /* SeaLINK+8/485 (2802) Port 7 */
> +#define SEALEVEL_2802_8_PID    0X2882  /* SeaLINK+8/485 (2802) Port 8 */
> +#define SEALEVEL_2803_1_PID    0X2813  /* SeaLINK+8 (2803) Port 1 */
> +#define SEALEVEL_2803_2_PID    0X2823  /* SeaLINK+8 (2803) Port 2 */
> +#define SEALEVEL_2803_3_PID    0X2833  /* SeaLINK+8 (2803) Port 3 */
> +#define SEALEVEL_2803_4_PID    0X2843  /* SeaLINK+8 (2803) Port 4 */
> +#define SEALEVEL_2803_5_PID    0X2853  /* SeaLINK+8 (2803) Port 5 */
> +#define SEALEVEL_2803_6_PID    0X2863  /* SeaLINK+8 (2803) Port 6 */
> +#define SEALEVEL_2803_7_PID    0X2873  /* SeaLINK+8 (2803) Port 7 */
> +#define SEALEVEL_2803_8_PID    0X2883  /* SeaLINK+8 (2803) Port 8 */
> +#define SEALEVEL_2803R_1_PID   0Xa02a  /* SeaLINK+8 (2803-ROHS) Port 1+2 */
> +#define SEALEVEL_2803R_2_PID   0Xa02b  /* SeaLINK+8 (2803-ROHS) Port 3+4 */
> +#define SEALEVEL_2803R_3_PID   0Xa02c  /* SeaLINK+8 (2803-ROHS) Port 5+6 */
> +#define SEALEVEL_2803R_4_PID   0Xa02d  /* SeaLINK+8 (2803-ROHS) Port 7+8 */
> +
> +/*
> + * JETI SPECTROMETER SPECBOS 1201
> + * http://www.jeti.com/cms/index.php/instruments/other-instruments/specbos-2101
> + */
> +#define JETI_VID               0x0c6c
> +#define JETI_SPC1201_PID       0x04b2
> +
> +/*
> + * FTDI USB UART chips used in construction projects from the
> + * Elektor Electronics magazine (http://www.elektor.com/)
> + */
> +#define ELEKTOR_VID            0x0C7D
> +#define ELEKTOR_FT323R_PID     0x0005  /* RFID-Reader, issue 09-2006 */
> +
> +/*
> + * Posiflex inc retail equipment (http://www.posiflex.com.tw)
> + */
> +#define POSIFLEX_VID           0x0d3a  /* Vendor ID */
> +#define POSIFLEX_PP7000_PID    0x0300  /* PP-7000II thermal printer */
> +
> +/*
> + * The following are the values for two KOBIL chipcard terminals.
> + */
> +#define KOBIL_VID              0x0d46  /* KOBIL Vendor ID */
> +#define KOBIL_CONV_B1_PID      0x2020  /* KOBIL Konverter for B1 */
> +#define KOBIL_CONV_KAAN_PID    0x2021  /* KOBIL_Konverter for KAAN */
> +
> +#define FTDI_NF_RIC_VID        0x0DCD  /* Vendor Id */
> +#define FTDI_NF_RIC_PID        0x0001  /* Product Id */
> +
> +/*
> + * Falcom Wireless Communications GmbH
> + */
> +#define FALCOM_VID             0x0F94  /* Vendor Id */
> +#define FALCOM_TWIST_PID       0x0001  /* Falcom Twist USB GPRS modem */
> +#define FALCOM_SAMBA_PID       0x0005  /* Falcom Samba USB GPRS modem */
> +
> +/* Larsen and Brusgaard AltiTrack/USBtrack */
> +#define LARSENBRUSGAARD_VID            0x0FD8
> +#define LB_ALTITRACK_PID               0x0001
> +
> +/*
> + * TTi (Thurlby Thandar Instruments)
> + */
> +#define TTI_VID                        0x103E  /* Vendor Id */
> +#define TTI_QL355P_PID         0x03E8  /* TTi QL355P power supply */
> +
> +/* Interbiometrics USB I/O Board */
> +/* Developed for Interbiometrics by Rudolf Gugler */
> +#define INTERBIOMETRICS_VID              0x1209
> +#define INTERBIOMETRICS_IOBOARD_PID      0x1002
> +#define INTERBIOMETRICS_MINI_IOBOARD_PID 0x1006
> +
> +/*
> + * Testo products (http://www.testo.com/)
> + * Submitted by Colin Leroy
> + */
> +#define TESTO_VID                      0x128D
> +#define TESTO_USB_INTERFACE_PID                0x0001
> +
> +/*
> + * Mobility Electronics products.
> + */
> +#define MOBILITY_VID                   0x1342
> +#define MOBILITY_USB_SERIAL_PID                0x0202  /* EasiDock USB 200 serial */
> +
> +/*
> + * FIC / OpenMoko, Inc. http://wiki.openmoko.org/wiki/Neo1973_Debug_Board_v3
> + * Submitted by Harald Welte <laforge@openmoko.org>
> + */
> +#define        FIC_VID                 0x1457
> +#define        FIC_NEO1973_DEBUG_PID   0x5118
> +
> +/* Olimex */
> +#define OLIMEX_VID                     0x15BA
> +#define OLIMEX_ARM_USB_OCD_PID         0x0003
> +#define OLIMEX_ARM_USB_OCD_H_PID       0x002b
> +
> +/*
> + * Telldus Technologies
> + */
> +#define TELLDUS_VID                    0x1781  /* Vendor ID */
> +#define TELLDUS_TELLSTICK_PID          0x0C30  /* RF control dongle 433 MHz using FT232RL */
> +
> +/*
> + * RT Systems programming cables for various ham radios
> + */
> +#define RTSYSTEMS_VID                  0x2100  /* Vendor ID */
> +#define RTSYSTEMS_SERIAL_VX7_PID       0x9e52  /* Serial converter for VX-7 Radios using FT232RL */
> +#define RTSYSTEMS_CT29B_PID            0x9e54  /* CT29B Radio Cable */
> +#define RTSYSTEMS_RTS01_PID            0x9e57  /* USB-RTS01 Radio Cable */
> +
> +
> +/*
> + * Physik Instrumente
> + * http://www.physikinstrumente.com/en/products/
> + */
> +/* These two devices use the VID of FTDI */
> +#define PI_C865_PID    0xe0a0  /* PI C-865 Piezomotor Controller */
> +#define PI_C857_PID    0xe0a1  /* PI Encoder Trigger Box */
> +
> +#define PI_VID              0x1a72  /* Vendor ID */
> +#define PI_C866_PID    0x1000  /* PI C-866 Piezomotor Controller */
> +#define PI_C663_PID    0x1001  /* PI C-663 Mercury-Step */
> +#define PI_C725_PID    0x1002  /* PI C-725 Piezomotor Controller */
> +#define PI_E517_PID    0x1005  /* PI E-517 Digital Piezo Controller Operation Module */
> +#define PI_C863_PID    0x1007  /* PI C-863 */
> +#define PI_E861_PID    0x1008  /* PI E-861 Piezomotor Controller */
> +#define PI_C867_PID    0x1009  /* PI C-867 Piezomotor Controller */
> +#define PI_E609_PID    0x100D  /* PI E-609 Digital Piezo Controller */
> +#define PI_E709_PID    0x100E  /* PI E-709 Digital Piezo Controller */
> +#define PI_100F_PID    0x100F  /* PI Digital Piezo Controller */
> +#define PI_1011_PID    0x1011  /* PI Digital Piezo Controller */
> +#define PI_1012_PID    0x1012  /* PI Motion Controller */
> +#define PI_1013_PID    0x1013  /* PI Motion Controller */
> +#define PI_1014_PID    0x1014  /* PI Device */
> +#define PI_1015_PID    0x1015  /* PI Device */
> +#define PI_1016_PID    0x1016  /* PI Digital Servo Module */
> +
> +/*
> + * Kondo Kagaku Co.Ltd.
> + * http://www.kondo-robot.com/EN
> + */
> +#define KONDO_VID              0x165c
> +#define KONDO_USB_SERIAL_PID   0x0002
> +
> +/*
> + * Bayer Ascensia Contour blood glucose meter USB-converter cable.
> + * http://winglucofacts.com/cables/
> + */
> +#define BAYER_VID                      0x1A79
> +#define BAYER_CONTOUR_CABLE_PID        0x6001
> +
> +/*
> + * The following are the values for the Matrix Orbital FTDI Range
> + * Anything in this range will use an FT232RL.
> + */
> +#define MTXORB_VID                     0x1B3D
> +#define MTXORB_FTDI_RANGE_0100_PID     0x0100
> +#define MTXORB_FTDI_RANGE_0101_PID     0x0101
> +#define MTXORB_FTDI_RANGE_0102_PID     0x0102
> +#define MTXORB_FTDI_RANGE_0103_PID     0x0103
> +#define MTXORB_FTDI_RANGE_0104_PID     0x0104
> +#define MTXORB_FTDI_RANGE_0105_PID     0x0105
> +#define MTXORB_FTDI_RANGE_0106_PID     0x0106
> +#define MTXORB_FTDI_RANGE_0107_PID     0x0107
> +#define MTXORB_FTDI_RANGE_0108_PID     0x0108
> +#define MTXORB_FTDI_RANGE_0109_PID     0x0109
> +#define MTXORB_FTDI_RANGE_010A_PID     0x010A
> +#define MTXORB_FTDI_RANGE_010B_PID     0x010B
> +#define MTXORB_FTDI_RANGE_010C_PID     0x010C
> +#define MTXORB_FTDI_RANGE_010D_PID     0x010D
> +#define MTXORB_FTDI_RANGE_010E_PID     0x010E
> +#define MTXORB_FTDI_RANGE_010F_PID     0x010F
> +#define MTXORB_FTDI_RANGE_0110_PID     0x0110
> +#define MTXORB_FTDI_RANGE_0111_PID     0x0111
> +#define MTXORB_FTDI_RANGE_0112_PID     0x0112
> +#define MTXORB_FTDI_RANGE_0113_PID     0x0113
> +#define MTXORB_FTDI_RANGE_0114_PID     0x0114
> +#define MTXORB_FTDI_RANGE_0115_PID     0x0115
> +#define MTXORB_FTDI_RANGE_0116_PID     0x0116
> +#define MTXORB_FTDI_RANGE_0117_PID     0x0117
> +#define MTXORB_FTDI_RANGE_0118_PID     0x0118
> +#define MTXORB_FTDI_RANGE_0119_PID     0x0119
> +#define MTXORB_FTDI_RANGE_011A_PID     0x011A
> +#define MTXORB_FTDI_RANGE_011B_PID     0x011B
> +#define MTXORB_FTDI_RANGE_011C_PID     0x011C
> +#define MTXORB_FTDI_RANGE_011D_PID     0x011D
> +#define MTXORB_FTDI_RANGE_011E_PID     0x011E
> +#define MTXORB_FTDI_RANGE_011F_PID     0x011F
> +#define MTXORB_FTDI_RANGE_0120_PID     0x0120
> +#define MTXORB_FTDI_RANGE_0121_PID     0x0121
> +#define MTXORB_FTDI_RANGE_0122_PID     0x0122
> +#define MTXORB_FTDI_RANGE_0123_PID     0x0123
> +#define MTXORB_FTDI_RANGE_0124_PID     0x0124
> +#define MTXORB_FTDI_RANGE_0125_PID     0x0125
> +#define MTXORB_FTDI_RANGE_0126_PID     0x0126
> +#define MTXORB_FTDI_RANGE_0127_PID     0x0127
> +#define MTXORB_FTDI_RANGE_0128_PID     0x0128
> +#define MTXORB_FTDI_RANGE_0129_PID     0x0129
> +#define MTXORB_FTDI_RANGE_012A_PID     0x012A
> +#define MTXORB_FTDI_RANGE_012B_PID     0x012B
> +#define MTXORB_FTDI_RANGE_012C_PID     0x012C
> +#define MTXORB_FTDI_RANGE_012D_PID     0x012D
> +#define MTXORB_FTDI_RANGE_012E_PID     0x012E
> +#define MTXORB_FTDI_RANGE_012F_PID     0x012F
> +#define MTXORB_FTDI_RANGE_0130_PID     0x0130
> +#define MTXORB_FTDI_RANGE_0131_PID     0x0131
> +#define MTXORB_FTDI_RANGE_0132_PID     0x0132
> +#define MTXORB_FTDI_RANGE_0133_PID     0x0133
> +#define MTXORB_FTDI_RANGE_0134_PID     0x0134
> +#define MTXORB_FTDI_RANGE_0135_PID     0x0135
> +#define MTXORB_FTDI_RANGE_0136_PID     0x0136
> +#define MTXORB_FTDI_RANGE_0137_PID     0x0137
> +#define MTXORB_FTDI_RANGE_0138_PID     0x0138
> +#define MTXORB_FTDI_RANGE_0139_PID     0x0139
> +#define MTXORB_FTDI_RANGE_013A_PID     0x013A
> +#define MTXORB_FTDI_RANGE_013B_PID     0x013B
> +#define MTXORB_FTDI_RANGE_013C_PID     0x013C
> +#define MTXORB_FTDI_RANGE_013D_PID     0x013D
> +#define MTXORB_FTDI_RANGE_013E_PID     0x013E
> +#define MTXORB_FTDI_RANGE_013F_PID     0x013F
> +#define MTXORB_FTDI_RANGE_0140_PID     0x0140
> +#define MTXORB_FTDI_RANGE_0141_PID     0x0141
> +#define MTXORB_FTDI_RANGE_0142_PID     0x0142
> +#define MTXORB_FTDI_RANGE_0143_PID     0x0143
> +#define MTXORB_FTDI_RANGE_0144_PID     0x0144
> +#define MTXORB_FTDI_RANGE_0145_PID     0x0145
> +#define MTXORB_FTDI_RANGE_0146_PID     0x0146
> +#define MTXORB_FTDI_RANGE_0147_PID     0x0147
> +#define MTXORB_FTDI_RANGE_0148_PID     0x0148
> +#define MTXORB_FTDI_RANGE_0149_PID     0x0149
> +#define MTXORB_FTDI_RANGE_014A_PID     0x014A
> +#define MTXORB_FTDI_RANGE_014B_PID     0x014B
> +#define MTXORB_FTDI_RANGE_014C_PID     0x014C
> +#define MTXORB_FTDI_RANGE_014D_PID     0x014D
> +#define MTXORB_FTDI_RANGE_014E_PID     0x014E
> +#define MTXORB_FTDI_RANGE_014F_PID     0x014F
> +#define MTXORB_FTDI_RANGE_0150_PID     0x0150
> +#define MTXORB_FTDI_RANGE_0151_PID     0x0151
> +#define MTXORB_FTDI_RANGE_0152_PID     0x0152
> +#define MTXORB_FTDI_RANGE_0153_PID     0x0153
> +#define MTXORB_FTDI_RANGE_0154_PID     0x0154
> +#define MTXORB_FTDI_RANGE_0155_PID     0x0155
> +#define MTXORB_FTDI_RANGE_0156_PID     0x0156
> +#define MTXORB_FTDI_RANGE_0157_PID     0x0157
> +#define MTXORB_FTDI_RANGE_0158_PID     0x0158
> +#define MTXORB_FTDI_RANGE_0159_PID     0x0159
> +#define MTXORB_FTDI_RANGE_015A_PID     0x015A
> +#define MTXORB_FTDI_RANGE_015B_PID     0x015B
> +#define MTXORB_FTDI_RANGE_015C_PID     0x015C
> +#define MTXORB_FTDI_RANGE_015D_PID     0x015D
> +#define MTXORB_FTDI_RANGE_015E_PID     0x015E
> +#define MTXORB_FTDI_RANGE_015F_PID     0x015F
> +#define MTXORB_FTDI_RANGE_0160_PID     0x0160
> +#define MTXORB_FTDI_RANGE_0161_PID     0x0161
> +#define MTXORB_FTDI_RANGE_0162_PID     0x0162
> +#define MTXORB_FTDI_RANGE_0163_PID     0x0163
> +#define MTXORB_FTDI_RANGE_0164_PID     0x0164
> +#define MTXORB_FTDI_RANGE_0165_PID     0x0165
> +#define MTXORB_FTDI_RANGE_0166_PID     0x0166
> +#define MTXORB_FTDI_RANGE_0167_PID     0x0167
> +#define MTXORB_FTDI_RANGE_0168_PID     0x0168
> +#define MTXORB_FTDI_RANGE_0169_PID     0x0169
> +#define MTXORB_FTDI_RANGE_016A_PID     0x016A
> +#define MTXORB_FTDI_RANGE_016B_PID     0x016B
> +#define MTXORB_FTDI_RANGE_016C_PID     0x016C
> +#define MTXORB_FTDI_RANGE_016D_PID     0x016D
> +#define MTXORB_FTDI_RANGE_016E_PID     0x016E
> +#define MTXORB_FTDI_RANGE_016F_PID     0x016F
> +#define MTXORB_FTDI_RANGE_0170_PID     0x0170
> +#define MTXORB_FTDI_RANGE_0171_PID     0x0171
> +#define MTXORB_FTDI_RANGE_0172_PID     0x0172
> +#define MTXORB_FTDI_RANGE_0173_PID     0x0173
> +#define MTXORB_FTDI_RANGE_0174_PID     0x0174
> +#define MTXORB_FTDI_RANGE_0175_PID     0x0175
> +#define MTXORB_FTDI_RANGE_0176_PID     0x0176
> +#define MTXORB_FTDI_RANGE_0177_PID     0x0177
> +#define MTXORB_FTDI_RANGE_0178_PID     0x0178
> +#define MTXORB_FTDI_RANGE_0179_PID     0x0179
> +#define MTXORB_FTDI_RANGE_017A_PID     0x017A
> +#define MTXORB_FTDI_RANGE_017B_PID     0x017B
> +#define MTXORB_FTDI_RANGE_017C_PID     0x017C
> +#define MTXORB_FTDI_RANGE_017D_PID     0x017D
> +#define MTXORB_FTDI_RANGE_017E_PID     0x017E
> +#define MTXORB_FTDI_RANGE_017F_PID     0x017F
> +#define MTXORB_FTDI_RANGE_0180_PID     0x0180
> +#define MTXORB_FTDI_RANGE_0181_PID     0x0181
> +#define MTXORB_FTDI_RANGE_0182_PID     0x0182
> +#define MTXORB_FTDI_RANGE_0183_PID     0x0183
> +#define MTXORB_FTDI_RANGE_0184_PID     0x0184
> +#define MTXORB_FTDI_RANGE_0185_PID     0x0185
> +#define MTXORB_FTDI_RANGE_0186_PID     0x0186
> +#define MTXORB_FTDI_RANGE_0187_PID     0x0187
> +#define MTXORB_FTDI_RANGE_0188_PID     0x0188
> +#define MTXORB_FTDI_RANGE_0189_PID     0x0189
> +#define MTXORB_FTDI_RANGE_018A_PID     0x018A
> +#define MTXORB_FTDI_RANGE_018B_PID     0x018B
> +#define MTXORB_FTDI_RANGE_018C_PID     0x018C
> +#define MTXORB_FTDI_RANGE_018D_PID     0x018D
> +#define MTXORB_FTDI_RANGE_018E_PID     0x018E
> +#define MTXORB_FTDI_RANGE_018F_PID     0x018F
> +#define MTXORB_FTDI_RANGE_0190_PID     0x0190
> +#define MTXORB_FTDI_RANGE_0191_PID     0x0191
> +#define MTXORB_FTDI_RANGE_0192_PID     0x0192
> +#define MTXORB_FTDI_RANGE_0193_PID     0x0193
> +#define MTXORB_FTDI_RANGE_0194_PID     0x0194
> +#define MTXORB_FTDI_RANGE_0195_PID     0x0195
> +#define MTXORB_FTDI_RANGE_0196_PID     0x0196
> +#define MTXORB_FTDI_RANGE_0197_PID     0x0197
> +#define MTXORB_FTDI_RANGE_0198_PID     0x0198
> +#define MTXORB_FTDI_RANGE_0199_PID     0x0199
> +#define MTXORB_FTDI_RANGE_019A_PID     0x019A
> +#define MTXORB_FTDI_RANGE_019B_PID     0x019B
> +#define MTXORB_FTDI_RANGE_019C_PID     0x019C
> +#define MTXORB_FTDI_RANGE_019D_PID     0x019D
> +#define MTXORB_FTDI_RANGE_019E_PID     0x019E
> +#define MTXORB_FTDI_RANGE_019F_PID     0x019F
> +#define MTXORB_FTDI_RANGE_01A0_PID     0x01A0
> +#define MTXORB_FTDI_RANGE_01A1_PID     0x01A1
> +#define MTXORB_FTDI_RANGE_01A2_PID     0x01A2
> +#define MTXORB_FTDI_RANGE_01A3_PID     0x01A3
> +#define MTXORB_FTDI_RANGE_01A4_PID     0x01A4
> +#define MTXORB_FTDI_RANGE_01A5_PID     0x01A5
> +#define MTXORB_FTDI_RANGE_01A6_PID     0x01A6
> +#define MTXORB_FTDI_RANGE_01A7_PID     0x01A7
> +#define MTXORB_FTDI_RANGE_01A8_PID     0x01A8
> +#define MTXORB_FTDI_RANGE_01A9_PID     0x01A9
> +#define MTXORB_FTDI_RANGE_01AA_PID     0x01AA
> +#define MTXORB_FTDI_RANGE_01AB_PID     0x01AB
> +#define MTXORB_FTDI_RANGE_01AC_PID     0x01AC
> +#define MTXORB_FTDI_RANGE_01AD_PID     0x01AD
> +#define MTXORB_FTDI_RANGE_01AE_PID     0x01AE
> +#define MTXORB_FTDI_RANGE_01AF_PID     0x01AF
> +#define MTXORB_FTDI_RANGE_01B0_PID     0x01B0
> +#define MTXORB_FTDI_RANGE_01B1_PID     0x01B1
> +#define MTXORB_FTDI_RANGE_01B2_PID     0x01B2
> +#define MTXORB_FTDI_RANGE_01B3_PID     0x01B3
> +#define MTXORB_FTDI_RANGE_01B4_PID     0x01B4
> +#define MTXORB_FTDI_RANGE_01B5_PID     0x01B5
> +#define MTXORB_FTDI_RANGE_01B6_PID     0x01B6
> +#define MTXORB_FTDI_RANGE_01B7_PID     0x01B7
> +#define MTXORB_FTDI_RANGE_01B8_PID     0x01B8
> +#define MTXORB_FTDI_RANGE_01B9_PID     0x01B9
> +#define MTXORB_FTDI_RANGE_01BA_PID     0x01BA
> +#define MTXORB_FTDI_RANGE_01BB_PID     0x01BB
> +#define MTXORB_FTDI_RANGE_01BC_PID     0x01BC
> +#define MTXORB_FTDI_RANGE_01BD_PID     0x01BD
> +#define MTXORB_FTDI_RANGE_01BE_PID     0x01BE
> +#define MTXORB_FTDI_RANGE_01BF_PID     0x01BF
> +#define MTXORB_FTDI_RANGE_01C0_PID     0x01C0
> +#define MTXORB_FTDI_RANGE_01C1_PID     0x01C1
> +#define MTXORB_FTDI_RANGE_01C2_PID     0x01C2
> +#define MTXORB_FTDI_RANGE_01C3_PID     0x01C3
> +#define MTXORB_FTDI_RANGE_01C4_PID     0x01C4
> +#define MTXORB_FTDI_RANGE_01C5_PID     0x01C5
> +#define MTXORB_FTDI_RANGE_01C6_PID     0x01C6
> +#define MTXORB_FTDI_RANGE_01C7_PID     0x01C7
> +#define MTXORB_FTDI_RANGE_01C8_PID     0x01C8
> +#define MTXORB_FTDI_RANGE_01C9_PID     0x01C9
> +#define MTXORB_FTDI_RANGE_01CA_PID     0x01CA
> +#define MTXORB_FTDI_RANGE_01CB_PID     0x01CB
> +#define MTXORB_FTDI_RANGE_01CC_PID     0x01CC
> +#define MTXORB_FTDI_RANGE_01CD_PID     0x01CD
> +#define MTXORB_FTDI_RANGE_01CE_PID     0x01CE
> +#define MTXORB_FTDI_RANGE_01CF_PID     0x01CF
> +#define MTXORB_FTDI_RANGE_01D0_PID     0x01D0
> +#define MTXORB_FTDI_RANGE_01D1_PID     0x01D1
> +#define MTXORB_FTDI_RANGE_01D2_PID     0x01D2
> +#define MTXORB_FTDI_RANGE_01D3_PID     0x01D3
> +#define MTXORB_FTDI_RANGE_01D4_PID     0x01D4
> +#define MTXORB_FTDI_RANGE_01D5_PID     0x01D5
> +#define MTXORB_FTDI_RANGE_01D6_PID     0x01D6
> +#define MTXORB_FTDI_RANGE_01D7_PID     0x01D7
> +#define MTXORB_FTDI_RANGE_01D8_PID     0x01D8
> +#define MTXORB_FTDI_RANGE_01D9_PID     0x01D9
> +#define MTXORB_FTDI_RANGE_01DA_PID     0x01DA
> +#define MTXORB_FTDI_RANGE_01DB_PID     0x01DB
> +#define MTXORB_FTDI_RANGE_01DC_PID     0x01DC
> +#define MTXORB_FTDI_RANGE_01DD_PID     0x01DD
> +#define MTXORB_FTDI_RANGE_01DE_PID     0x01DE
> +#define MTXORB_FTDI_RANGE_01DF_PID     0x01DF
> +#define MTXORB_FTDI_RANGE_01E0_PID     0x01E0
> +#define MTXORB_FTDI_RANGE_01E1_PID     0x01E1
> +#define MTXORB_FTDI_RANGE_01E2_PID     0x01E2
> +#define MTXORB_FTDI_RANGE_01E3_PID     0x01E3
> +#define MTXORB_FTDI_RANGE_01E4_PID     0x01E4
> +#define MTXORB_FTDI_RANGE_01E5_PID     0x01E5
> +#define MTXORB_FTDI_RANGE_01E6_PID     0x01E6
> +#define MTXORB_FTDI_RANGE_01E7_PID     0x01E7
> +#define MTXORB_FTDI_RANGE_01E8_PID     0x01E8
> +#define MTXORB_FTDI_RANGE_01E9_PID     0x01E9
> +#define MTXORB_FTDI_RANGE_01EA_PID     0x01EA
> +#define MTXORB_FTDI_RANGE_01EB_PID     0x01EB
> +#define MTXORB_FTDI_RANGE_01EC_PID     0x01EC
> +#define MTXORB_FTDI_RANGE_01ED_PID     0x01ED
> +#define MTXORB_FTDI_RANGE_01EE_PID     0x01EE
> +#define MTXORB_FTDI_RANGE_01EF_PID     0x01EF
> +#define MTXORB_FTDI_RANGE_01F0_PID     0x01F0
> +#define MTXORB_FTDI_RANGE_01F1_PID     0x01F1
> +#define MTXORB_FTDI_RANGE_01F2_PID     0x01F2
> +#define MTXORB_FTDI_RANGE_01F3_PID     0x01F3
> +#define MTXORB_FTDI_RANGE_01F4_PID     0x01F4
> +#define MTXORB_FTDI_RANGE_01F5_PID     0x01F5
> +#define MTXORB_FTDI_RANGE_01F6_PID     0x01F6
> +#define MTXORB_FTDI_RANGE_01F7_PID     0x01F7
> +#define MTXORB_FTDI_RANGE_01F8_PID     0x01F8
> +#define MTXORB_FTDI_RANGE_01F9_PID     0x01F9
> +#define MTXORB_FTDI_RANGE_01FA_PID     0x01FA
> +#define MTXORB_FTDI_RANGE_01FB_PID     0x01FB
> +#define MTXORB_FTDI_RANGE_01FC_PID     0x01FC
> +#define MTXORB_FTDI_RANGE_01FD_PID     0x01FD
> +#define MTXORB_FTDI_RANGE_01FE_PID     0x01FE
> +#define MTXORB_FTDI_RANGE_01FF_PID     0x01FF
> +
> +
> +
> +/*
> + * The Mobility Lab (TML)
> + * Submitted by Pierre Castella
> + */
> +#define TML_VID                        0x1B91  /* Vendor ID */
> +#define TML_USB_SERIAL_PID     0x0064  /* USB - Serial Converter */
> +
> +/* Alti-2 products  http://www.alti-2.com */
> +#define ALTI2_VID      0x1BC9
> +#define ALTI2_N3_PID   0x6001  /* Neptune 3 */
> +
> +/*
> + * Ionics PlugComputer
> + */
> +#define IONICS_VID                     0x1c0c
> +#define IONICS_PLUGCOMPUTER_PID                0x0102
> +
> +/*
> + * Dresden Elektronik Sensor Terminal Board
> + */
> +#define DE_VID                 0x1cf1 /* Vendor ID */
> +#define STB_PID                        0x0001 /* Sensor Terminal Board */
> +#define WHT_PID                        0x0004 /* Wireless Handheld Terminal */
> +
> +/*
> + * STMicroelectonics
> + */
> +#define ST_VID                 0x0483
> +#define ST_STMCLT1030_PID      0x3747 /* ST Micro Connect Lite STMCLT1030 */
> +
> +/*
> + * Papouch products (http://www.papouch.com/)
> + * Submitted by Folkert van Heusden
> + */
> +
> +#define PAPOUCH_VID                    0x5050  /* Vendor ID */
> +#define PAPOUCH_SB485_PID              0x0100  /* Papouch SB485 USB-485/422 Converter */
> +#define PAPOUCH_AP485_PID              0x0101  /* AP485 USB-RS485 Converter */
> +#define PAPOUCH_SB422_PID              0x0102  /* Papouch SB422 USB-RS422 Converter  */
> +#define PAPOUCH_SB485_2_PID            0x0103  /* Papouch SB485 USB-485/422 Converter */
> +#define PAPOUCH_AP485_2_PID            0x0104  /* AP485 USB-RS485 Converter */
> +#define PAPOUCH_SB422_2_PID            0x0105  /* Papouch SB422 USB-RS422 Converter  */
> +#define PAPOUCH_SB485S_PID             0x0106  /* Papouch SB485S USB-485/422 Converter */
> +#define PAPOUCH_SB485C_PID             0x0107  /* Papouch SB485C USB-485/422 Converter */
> +#define PAPOUCH_LEC_PID                        0x0300  /* LEC USB Converter */
> +#define PAPOUCH_SB232_PID              0x0301  /* Papouch SB232 USB-RS232 Converter */
> +#define PAPOUCH_TMU_PID                        0x0400  /* TMU USB Thermometer */
> +#define PAPOUCH_IRAMP_PID              0x0500  /* Papouch IRAmp Duplex */
> +#define PAPOUCH_DRAK5_PID              0x0700  /* Papouch DRAK5 */
> +#define PAPOUCH_QUIDO8x8_PID           0x0800  /* Papouch Quido 8/8 Module */
> +#define PAPOUCH_QUIDO4x4_PID           0x0900  /* Papouch Quido 4/4 Module */
> +#define PAPOUCH_QUIDO2x2_PID           0x0a00  /* Papouch Quido 2/2 Module */
> +#define PAPOUCH_QUIDO10x1_PID          0x0b00  /* Papouch Quido 10/1 Module */
> +#define PAPOUCH_QUIDO30x3_PID          0x0c00  /* Papouch Quido 30/3 Module */
> +#define PAPOUCH_QUIDO60x3_PID          0x0d00  /* Papouch Quido 60(100)/3 Module */
> +#define PAPOUCH_QUIDO2x16_PID          0x0e00  /* Papouch Quido 2/16 Module */
> +#define PAPOUCH_QUIDO3x32_PID          0x0f00  /* Papouch Quido 3/32 Module */
> +#define PAPOUCH_DRAK6_PID              0x1000  /* Papouch DRAK6 */
> +#define PAPOUCH_UPSUSB_PID             0x8000  /* Papouch UPS-USB adapter */
> +#define PAPOUCH_MU_PID                 0x8001  /* MU controller */
> +#define PAPOUCH_SIMUKEY_PID            0x8002  /* Papouch SimuKey */
> +#define PAPOUCH_AD4USB_PID             0x8003  /* AD4USB Measurement Module */
> +#define PAPOUCH_GMUX_PID               0x8004  /* Papouch GOLIATH MUX */
> +#define PAPOUCH_GMSR_PID               0x8005  /* Papouch GOLIATH MSR */
> +
> +/*
> + * Marvell SheevaPlug
> + */
> +#define MARVELL_VID            0x9e88
> +#define MARVELL_SHEEVAPLUG_PID 0x9e8f
> +
> +/*
> + * Evolution Robotics products (http://www.evolution.com/).
> + * Submitted by Shawn M. Lavelle.
> + */
> +#define EVOLUTION_VID          0xDEEE  /* Vendor ID */
> +#define EVOLUTION_ER1_PID      0x0300  /* ER1 Control Module */
> +#define EVO_8U232AM_PID                0x02FF  /* Evolution robotics RCM2 (FT232AM)*/
> +#define EVO_HYBRID_PID         0x0302  /* Evolution robotics RCM4 PID (FT232BM)*/
> +#define EVO_RCM4_PID           0x0303  /* Evolution robotics RCM4 PID */
> +
> +/*
> + * MJS Gadgets HD Radio / XM Radio / Sirius Radio interfaces (using VID 0x0403)
> + */
> +#define MJSG_GENERIC_PID       0x9378
> +#define MJSG_SR_RADIO_PID      0x9379
> +#define MJSG_XM_RADIO_PID      0x937A
> +#define MJSG_HD_RADIO_PID      0x937C
> +
> +/*
> + * D.O.Tec products (http://www.directout.eu)
> + */
> +#define FTDI_DOTEC_PID 0x9868
> +
> +/*
> + * Xverve Signalyzer tools (http://www.signalyzer.com/)
> + */
> +#define XVERVE_SIGNALYZER_ST_PID       0xBCA0
> +#define XVERVE_SIGNALYZER_SLITE_PID    0xBCA1
> +#define XVERVE_SIGNALYZER_SH2_PID      0xBCA2
> +#define XVERVE_SIGNALYZER_SH4_PID      0xBCA4
> +
> +/*
> + * Segway Robotic Mobility Platform USB interface (using VID 0x0403)
> + * Submitted by John G. Rogers
> + */
> +#define SEGWAY_RMP200_PID      0xe729
> +
> +
> +/*
> + * Accesio USB Data Acquisition products (http://www.accesio.com/)
> + */
> +#define ACCESIO_COM4SM_PID     0xD578
> +
> +/* www.sciencescope.co.uk educational dataloggers */
> +#define FTDI_SCIENCESCOPE_LOGBOOKML_PID                0xFF18
> +#define FTDI_SCIENCESCOPE_LS_LOGBOOK_PID       0xFF1C
> +#define FTDI_SCIENCESCOPE_HS_LOGBOOK_PID       0xFF1D
> +
> +/*
> + * Milkymist One JTAG/Serial
> + */
> +#define QIHARDWARE_VID                 0x20B7
> +#define MILKYMISTONE_JTAGSERIAL_PID    0x0713
> +
> +/*
> + * CTI GmbH RS485 Converter http://www.cti-lean.com/
> + */
> +/* USB-485-Mini*/
> +#define FTDI_CTI_MINI_PID      0xF608
> +/* USB-Nano-485*/
> +#define FTDI_CTI_NANO_PID      0xF60B
> +
> +/*
> + * ZeitControl cardsystems GmbH rfid-readers http://zeitconrol.de
> + */
> +/* TagTracer MIFARE*/
> +#define FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID   0xF7C0
> +
> +/*
> + * Rainforest Automation
> + */
> +/* ZigBee controller */
> +#define FTDI_RF_R106           0x8A28
> +
> +/*
> + * Product: HCP HIT GPRS modem
> + * Manufacturer: HCP d.o.o.
> + * ATI command output: Cinterion MC55i
> + */
> +#define FTDI_CINTERION_MC55I_PID       0xA951
> diff --git a/hw/usb/quirks-pl2303-ids.h b/hw/usb/quirks-pl2303-ids.h
> new file mode 100644
> index 0000000..8dbdb46
> --- /dev/null
> +++ b/hw/usb/quirks-pl2303-ids.h
> @@ -0,0 +1,150 @@
> +/*
> + * Prolific PL2303 USB to serial adaptor driver header file
> + *
> + *     This program is free software; you can redistribute it and/or modify
> + *     it under the terms of the GNU General Public License as published by
> + *     the Free Software Foundation; either version 2 of the License, or
> + *     (at your option) any later version.
> + *
> + */
> +
> +#define BENQ_VENDOR_ID                 0x04a5
> +#define BENQ_PRODUCT_ID_S81            0x4027
> +
> +#define PL2303_VENDOR_ID       0x067b
> +#define PL2303_PRODUCT_ID      0x2303
> +#define PL2303_PRODUCT_ID_RSAQ2                0x04bb
> +#define PL2303_PRODUCT_ID_DCU11                0x1234
> +#define PL2303_PRODUCT_ID_PHAROS       0xaaa0
> +#define PL2303_PRODUCT_ID_RSAQ3                0xaaa2
> +#define PL2303_PRODUCT_ID_ALDIGA       0x0611
> +#define PL2303_PRODUCT_ID_MMX          0x0612
> +#define PL2303_PRODUCT_ID_GPRS         0x0609
> +#define PL2303_PRODUCT_ID_HCR331       0x331a
> +#define PL2303_PRODUCT_ID_MOTOROLA     0x0307
> +
> +#define ATEN_VENDOR_ID         0x0557
> +#define ATEN_VENDOR_ID2                0x0547
> +#define ATEN_PRODUCT_ID                0x2008
> +
> +#define IODATA_VENDOR_ID       0x04bb
> +#define IODATA_PRODUCT_ID      0x0a03
> +#define IODATA_PRODUCT_ID_RSAQ5        0x0a0e
> +
> +#define ELCOM_VENDOR_ID                0x056e
> +#define ELCOM_PRODUCT_ID       0x5003
> +#define ELCOM_PRODUCT_ID_UCSGT 0x5004
> +
> +#define ITEGNO_VENDOR_ID       0x0eba
> +#define ITEGNO_PRODUCT_ID      0x1080
> +#define ITEGNO_PRODUCT_ID_2080 0x2080
> +
> +#define MA620_VENDOR_ID                0x0df7
> +#define MA620_PRODUCT_ID       0x0620
> +
> +#define RATOC_VENDOR_ID                0x0584
> +#define RATOC_PRODUCT_ID       0xb000
> +
> +#define TRIPP_VENDOR_ID                0x2478
> +#define TRIPP_PRODUCT_ID       0x2008
> +
> +#define RADIOSHACK_VENDOR_ID   0x1453
> +#define RADIOSHACK_PRODUCT_ID  0x4026
> +
> +#define DCU10_VENDOR_ID                0x0731
> +#define DCU10_PRODUCT_ID       0x0528
> +
> +#define SITECOM_VENDOR_ID      0x6189
> +#define SITECOM_PRODUCT_ID     0x2068
> +
> +/* Alcatel OT535/735 USB cable */
> +#define ALCATEL_VENDOR_ID      0x11f7
> +#define ALCATEL_PRODUCT_ID     0x02df
> +
> +/* Samsung I330 phone cradle */
> +#define SAMSUNG_VENDOR_ID      0x04e8
> +#define SAMSUNG_PRODUCT_ID     0x8001
> +
> +#define SIEMENS_VENDOR_ID      0x11f5
> +#define SIEMENS_PRODUCT_ID_SX1 0x0001
> +#define SIEMENS_PRODUCT_ID_X65 0x0003
> +#define SIEMENS_PRODUCT_ID_X75 0x0004
> +#define SIEMENS_PRODUCT_ID_EF81        0x0005
> +
> +#define SYNTECH_VENDOR_ID      0x0745
> +#define SYNTECH_PRODUCT_ID     0x0001
> +
> +/* Nokia CA-42 Cable */
> +#define NOKIA_CA42_VENDOR_ID   0x078b
> +#define NOKIA_CA42_PRODUCT_ID  0x1234
> +
> +/* CA-42 CLONE Cable www.ca-42.com chipset: Prolific Technology Inc */
> +#define CA_42_CA42_VENDOR_ID   0x10b5
> +#define CA_42_CA42_PRODUCT_ID  0xac70
> +
> +#define SAGEM_VENDOR_ID                0x079b
> +#define SAGEM_PRODUCT_ID       0x0027
> +
> +/* Leadtek GPS 9531 (ID 0413:2101) */
> +#define LEADTEK_VENDOR_ID      0x0413
> +#define LEADTEK_9531_PRODUCT_ID        0x2101
> +
> +/* USB GSM cable from Speed Dragon Multimedia, Ltd */
> +#define SPEEDDRAGON_VENDOR_ID  0x0e55
> +#define SPEEDDRAGON_PRODUCT_ID 0x110b
> +
> +/* DATAPILOT Universal-2 Phone Cable */
> +#define DATAPILOT_U2_VENDOR_ID 0x0731
> +#define DATAPILOT_U2_PRODUCT_ID        0x2003
> +
> +/* Belkin "F5U257" Serial Adapter */
> +#define BELKIN_VENDOR_ID       0x050d
> +#define BELKIN_PRODUCT_ID      0x0257
> +
> +/* Alcor Micro Corp. USB 2.0 TO RS-232 */
> +#define ALCOR_VENDOR_ID                0x058F
> +#define ALCOR_PRODUCT_ID       0x9720
> +
> +/* Willcom WS002IN Data Driver (by NetIndex Inc.) */
> +#define WS002IN_VENDOR_ID      0x11f6
> +#define WS002IN_PRODUCT_ID     0x2001
> +
> +/* Corega CG-USBRS232R Serial Adapter */
> +#define COREGA_VENDOR_ID       0x07aa
> +#define COREGA_PRODUCT_ID      0x002a
> +
> +/* Y.C. Cable U.S.A., Inc - USB to RS-232 */
> +#define YCCABLE_VENDOR_ID      0x05ad
> +#define YCCABLE_PRODUCT_ID     0x0fba
> +
> +/* "Superial" USB - Serial */
> +#define SUPERIAL_VENDOR_ID     0x5372
> +#define SUPERIAL_PRODUCT_ID    0x2303
> +
> +/* Hewlett-Packard LD220-HP POS Pole Display */
> +#define HP_VENDOR_ID           0x03f0
> +#define HP_LD220_PRODUCT_ID    0x3524
> +
> +/* Cressi Edy (diving computer) PC interface */
> +#define CRESSI_VENDOR_ID       0x04b8
> +#define CRESSI_EDY_PRODUCT_ID  0x0521
> +
> +/* Zeagle dive computer interface */
> +#define ZEAGLE_VENDOR_ID       0x04b8
> +#define ZEAGLE_N2ITION3_PRODUCT_ID     0x0522
> +
> +/* Sony, USB data cable for CMD-Jxx mobile phones */
> +#define SONY_VENDOR_ID         0x054c
> +#define SONY_QN3USB_PRODUCT_ID 0x0437
> +
> +/* Sanwa KB-USB2 multimeter cable (ID: 11ad:0001) */
> +#define SANWA_VENDOR_ID                0x11ad
> +#define SANWA_PRODUCT_ID       0x0001
> +
> +/* ADLINK ND-6530 RS232,RS485 and RS422 adapter */
> +#define ADLINK_VENDOR_ID               0x0b63
> +#define ADLINK_ND6530_PRODUCT_ID       0x6530
> +
> +/* SMART USB Serial Adapter */
> +#define SMART_VENDOR_ID        0x0b8c
> +#define SMART_PRODUCT_ID       0x2303
> diff --git a/hw/usb/quirks.c b/hw/usb/quirks.c
> new file mode 100644
> index 0000000..a761a96
> --- /dev/null
> +++ b/hw/usb/quirks.c
> @@ -0,0 +1,53 @@
> +/*
> + * USB quirk handling
> + *
> + * Copyright (c) 2012 Red Hat, Inc.
> + *
> + * Red Hat Authors:
> + * Hans de Goede <hdegoede@redhat.com>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + */
> +
> +#include "quirks.h"
> +#include "hw/usb.h"
> +
> +static bool usb_id_match(const struct usb_device_id *ids,
> +                         uint16_t vendor_id, uint16_t product_id,
> +                         uint8_t interface_class, uint8_t interface_subclass,
> +                         uint8_t interface_protocol) {
> +    int i;
> +
> +    for (i = 0; ids[i].vendor_id != -1; i++) {
> +        if (ids[i].vendor_id  == vendor_id &&
> +            ids[i].product_id == product_id &&
> +            (ids[i].interface_class == -1 ||
> +             (ids[i].interface_class == interface_class &&
> +              ids[i].interface_subclass == interface_subclass &&
> +              ids[i].interface_protocol == interface_protocol))) {
> +            return true;
> +        }
> +    }
> +    return false;
> +}
> +
> +int usb_get_quirks(uint16_t vendor_id, uint16_t product_id,
> +                   uint8_t interface_class, uint8_t interface_subclass,
> +                   uint8_t interface_protocol)
> +{
> +    int quirks = 0;
> +
> +    if (usb_id_match(usbredir_raw_serial_ids, vendor_id, product_id,
> +                   interface_class, interface_subclass, interface_protocol)) {
> +        quirks |= USB_QUIRK_BUFFER_BULK_IN;
> +    }
> +    if (usb_id_match(usbredir_ftdi_serial_ids, vendor_id, product_id,
> +                   interface_class, interface_subclass, interface_protocol)) {
> +        quirks |= USB_QUIRK_BUFFER_BULK_IN | USB_QUIRK_IS_FTDI;
> +    }
> +
> +    return quirks;
> +}
> diff --git a/hw/usb/quirks.h b/hw/usb/quirks.h
> new file mode 100644
> index 0000000..8dc6065
> --- /dev/null
> +++ b/hw/usb/quirks.h
> @@ -0,0 +1,910 @@
> +/*
> + * USB quirk handling
> + *
> + * Copyright (c) 2012 Red Hat, Inc.
> + *
> + * Red Hat Authors:
> + * Hans de Goede <hdegoede@redhat.com>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + */
> +
> +/* 1 on 1 copy of linux/drivers/usb/serial/ftdi_sio_ids.h */
> +#include "quirks-ftdi-ids.h"
> +/* 1 on 1 copy of linux/drivers/usb/serial/pl2303.h */
> +#include "quirks-pl2303-ids.h"
> +
> +struct usb_device_id {
> +    int vendor_id;
> +    int product_id;
> +    int interface_class;
> +    int interface_subclass;
> +    int interface_protocol;
> +};
> +
> +#define USB_DEVICE(vendor, product) \
> +    .vendor_id = vendor, .product_id = product, .interface_class = -1,
> +
> +#define USB_DEVICE_AND_INTERFACE_INFO(vend, prod, iclass, isubclass, iproto) \
> +    .vendor_id = vend, .product_id = prod, .interface_class = iclass, \
> +    .interface_subclass = isubclass, .interface_protocol = iproto
> +
> +static const struct usb_device_id usbredir_raw_serial_ids[] = {
> +    /*
> +     * Silicon Laboratories CP210x USB to RS232 serial adapter ids
> +     * copied from linux/drivers/usb/serial/cp210x.c
> +     *
> +     * Copyright (C) 2005 Craig Shelley (craig@microtron.org.uk)
> +     */
> +    { USB_DEVICE(0x045B, 0x0053) }, /* Renesas RX610 RX-Stick */
> +    { USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
> +    { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
> +    { USB_DEVICE(0x0489, 0xE003) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
> +    { USB_DEVICE(0x0745, 0x1000) }, /* CipherLab USB CCD Barcode Scanner 1000 */
> +    { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
> +    { USB_DEVICE(0x08FD, 0x000A) }, /* Digianswer A/S , ZigBee/802.15.4 MAC Device */
> +    { USB_DEVICE(0x0BED, 0x1100) }, /* MEI (TM) Cashflow-SC Bill/Voucher Acceptor */
> +    { USB_DEVICE(0x0BED, 0x1101) }, /* MEI series 2000 Combo Acceptor */
> +    { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
> +    { USB_DEVICE(0x0FCF, 0x1004) }, /* Dynastream ANT2USB */
> +    { USB_DEVICE(0x0FCF, 0x1006) }, /* Dynastream ANT development board */
> +    { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
> +    { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
> +    { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
> +    { USB_DEVICE(0x10C4, 0x0F91) }, /* Vstabi */
> +    { USB_DEVICE(0x10C4, 0x1101) }, /* Arkham Technology DS101 Bus Monitor */
> +    { USB_DEVICE(0x10C4, 0x1601) }, /* Arkham Technology DS101 Adapter */
> +    { USB_DEVICE(0x10C4, 0x800A) }, /* SPORTident BSM7-D-USB main station */
> +    { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
> +    { USB_DEVICE(0x10C4, 0x8044) }, /* Cygnal Debug Adapter */
> +    { USB_DEVICE(0x10C4, 0x804E) }, /* Software Bisque Paramount ME build-in converter */
> +    { USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */
> +    { USB_DEVICE(0x10C4, 0x8054) }, /* Enfora GSM2228 */
> +    { USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */
> +    { USB_DEVICE(0x10C4, 0x806F) }, /* IMS USB to RS422 Converter Cable */
> +    { USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
> +    { USB_DEVICE(0x10C4, 0x80C4) }, /* Cygnal Integrated Products, Inc., Optris infrared thermometer */
> +    { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
> +    { USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */
> +    { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
> +    { USB_DEVICE(0x10C4, 0x8115) }, /* Arygon NFC/Mifare Reader */
> +    { USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */
> +    { USB_DEVICE(0x10C4, 0x813F) }, /* Tams Master Easy Control */
> +    { USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */
> +    { USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */
> +    { USB_DEVICE(0x10C4, 0x8156) }, /* B&G H3000 link cable */
> +    { USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
> +    { USB_DEVICE(0x10C4, 0x815F) }, /* Timewave HamLinkUSB */
> +    { USB_DEVICE(0x10C4, 0x818B) }, /* AVIT Research USB to TTL */
> +    { USB_DEVICE(0x10C4, 0x819F) }, /* MJS USB Toslink Switcher */
> +    { USB_DEVICE(0x10C4, 0x81A6) }, /* ThinkOptics WavIt */
> +    { USB_DEVICE(0x10C4, 0x81A9) }, /* Multiplex RC Interface */
> +    { USB_DEVICE(0x10C4, 0x81AC) }, /* MSD Dash Hawk */
> +    { USB_DEVICE(0x10C4, 0x81AD) }, /* INSYS USB Modem */
> +    { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
> +    { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
> +    { USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */
> +    { USB_DEVICE(0x10C4, 0x81E8) }, /* Zephyr Bioharness */
> +    { USB_DEVICE(0x10C4, 0x81F2) }, /* C1007 HF band RFID controller */
> +    { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
> +    { USB_DEVICE(0x10C4, 0x822B) }, /* Modem EDGE(GSM) Comander 2 */
> +    { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
> +    { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
> +    { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
> +    { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
> +    { USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */
> +    { USB_DEVICE(0x10C4, 0x83A8) }, /* Amber Wireless AMB2560 */
> +    { USB_DEVICE(0x10C4, 0x83D8) }, /* DekTec DTA Plus VHF/UHF Booster/Attenuator */
> +    { USB_DEVICE(0x10C4, 0x8411) }, /* Kyocera GPS Module */
> +    { USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
> +    { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
> +    { USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
> +    { USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
> +    { USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
> +    { USB_DEVICE(0x10C4, 0x8664) }, /* AC-Services CAN-IF */
> +    { USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
> +    { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
> +    { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
> +    { USB_DEVICE(0x10C4, 0xEA70) }, /* Silicon Labs factory default */
> +    { USB_DEVICE(0x10C4, 0xEA80) }, /* Silicon Labs factory default */
> +    { USB_DEVICE(0x10C4, 0xEA71) }, /* Infinity GPS-MIC-1 Radio Monophone */
> +    { USB_DEVICE(0x10C4, 0xF001) }, /* Elan Digital Systems USBscope50 */
> +    { USB_DEVICE(0x10C4, 0xF002) }, /* Elan Digital Systems USBwave12 */
> +    { USB_DEVICE(0x10C4, 0xF003) }, /* Elan Digital Systems USBpulse100 */
> +    { USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */
> +    { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
> +    { USB_DEVICE(0x10CE, 0xEA6A) }, /* Silicon Labs MobiData GPRS USB Modem 100EU */
> +    { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
> +    { USB_DEVICE(0x1555, 0x0004) }, /* Owen AC4 USB-RS485 Converter */
> +    { USB_DEVICE(0x166A, 0x0201) }, /* Clipsal 5500PACA C-Bus Pascal Automation Controller */
> +    { USB_DEVICE(0x166A, 0x0301) }, /* Clipsal 5800PC C-Bus Wireless PC Interface */
> +    { USB_DEVICE(0x166A, 0x0303) }, /* Clipsal 5500PCU C-Bus USB interface */
> +    { USB_DEVICE(0x166A, 0x0304) }, /* Clipsal 5000CT2 C-Bus Black and White Touchscreen */
> +    { USB_DEVICE(0x166A, 0x0305) }, /* Clipsal C-5000CT2 C-Bus Spectrum Colour Touchscreen */
> +    { USB_DEVICE(0x166A, 0x0401) }, /* Clipsal L51xx C-Bus Architectural Dimmer */
> +    { USB_DEVICE(0x166A, 0x0101) }, /* Clipsal 5560884 C-Bus Multi-room Audio Matrix Switcher */
> +    { USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */
> +    { USB_DEVICE(0x16DC, 0x0010) }, /* W-IE-NE-R Plein & Baus GmbH PL512 Power Supply */
> +    { USB_DEVICE(0x16DC, 0x0011) }, /* W-IE-NE-R Plein & Baus GmbH RCM Remote Control for MARATON Power Supply */
> +    { USB_DEVICE(0x16DC, 0x0012) }, /* W-IE-NE-R Plein & Baus GmbH MPOD Multi Channel Power Supply */
> +    { USB_DEVICE(0x16DC, 0x0015) }, /* W-IE-NE-R Plein & Baus GmbH CML Control, Monitoring and Data Logger */
> +    { USB_DEVICE(0x17A8, 0x0001) }, /* Kamstrup Optical Eye/3-wire */
> +    { USB_DEVICE(0x17A8, 0x0005) }, /* Kamstrup M-Bus Master MultiPort 250D */
> +    { USB_DEVICE(0x17F4, 0xAAAA) }, /* Wavesense Jazz blood glucose meter */
> +    { USB_DEVICE(0x1843, 0x0200) }, /* Vaisala USB Instrument Cable */
> +    { USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
> +    { USB_DEVICE(0x1BE3, 0x07A6) }, /* WAGO 750-923 USB Service Cable */
> +    { USB_DEVICE(0x1E29, 0x0102) }, /* Festo CPX-USB */
> +    { USB_DEVICE(0x1E29, 0x0501) }, /* Festo CMSP */
> +    { USB_DEVICE(0x3195, 0xF190) }, /* Link Instruments MSO-19 */
> +    { USB_DEVICE(0x3195, 0xF280) }, /* Link Instruments MSO-28 */
> +    { USB_DEVICE(0x3195, 0xF281) }, /* Link Instruments MSO-28 */
> +    { USB_DEVICE(0x413C, 0x9500) }, /* DW700 GPS USB interface */
> +
> +    /*
> +     * Prolific pl2303 USB to RS232 serial adapter ids
> +     * copied from linux/drivers/usb/serial/pl2303.c
> +     *
> +     * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
> +     * Copyright (C) 2003 IBM Corp.
> +     */
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
> +    { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
> +    { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
> +    { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
> +    { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
> +    { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
> +    { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
> +    { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
> +    { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
> +    { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
> +    { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
> +    { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
> +    { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
> +    { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
> +    { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
> +    { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
> +    { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
> +    { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
> +    { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
> +    { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
> +    { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
> +    { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
> +    { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
> +    { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
> +    { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
> +    { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
> +    { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
> +    { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
> +    { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
> +    { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
> +    { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
> +    { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
> +    { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
> +    { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
> +    { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
> +    { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
> +    { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
> +    { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
> +    { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
> +    { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
> +    { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
> +    { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
> +    { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
> +
> +    { USB_DEVICE(-1, -1) } /* Terminating Entry */
> +};
> +
> +static const struct usb_device_id usbredir_ftdi_serial_ids[] = {
> +    /*
> +     * FTDI USB to RS232 serial adapter ids
> +     * copied from linux/drivers/usb/serial/ftdi_sio.c
> +     *
> +     * Copyright (C) 2009 - 2010
> +     *    Johan Hovold (jhovold@gmail.com)
> +     * Copyright (C) 1999 - 2001
> +     *    Greg Kroah-Hartman (greg@kroah.com)
> +     *    Bill Ryder (bryder@sgi.com)
> +     * Copyright (C) 2002
> +     *    Kuba Ober (kuba@mareimbrium.org)
> +     */
> +    { USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_NXTCAM_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_0_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_1_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_3_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_4_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_5_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_6_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_7_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_USINT_CAT_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_USINT_WKEY_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_USINT_RS232_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_4232H_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_232H_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_FTX_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_PID) },
> +    { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
> +    { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
> +    { USB_DEVICE(FTDI_VID, FTDI_LENZ_LIUSB_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_URBAN_0_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_URBAN_1_PID) },
> +    { USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_1_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_3_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_R2000KU_TRUE_RNG) },
> +    { USB_DEVICE(FTDI_VID, FTDI_VARDAAN_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0100_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0101_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0102_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0103_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0104_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0105_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0106_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0107_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0108_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0109_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0110_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0111_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0112_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0113_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0114_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0115_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0116_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0117_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0118_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0119_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0120_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0121_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0122_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0123_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0124_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0125_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0126_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0127_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0128_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0129_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0130_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0131_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0132_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0133_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0134_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0135_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0136_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0137_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0138_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0139_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0140_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0141_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0142_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0143_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0144_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0145_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0146_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0147_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0148_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0149_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0150_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0151_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0152_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0153_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0154_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0155_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0156_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0157_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0158_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0159_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0160_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0161_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0162_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0163_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0164_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0165_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0166_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0167_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0168_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0169_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0170_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0171_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0172_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0173_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0174_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0175_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0176_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0177_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0178_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0179_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0180_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0181_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0182_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0183_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0184_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0185_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0186_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0187_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0188_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0189_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0190_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0191_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0192_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0193_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0194_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0195_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0196_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0197_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0198_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0199_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019A_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019B_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019C_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019D_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019E_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019F_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A0_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A1_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A2_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A3_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A4_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A5_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A6_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A7_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A8_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A9_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AA_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AB_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AC_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AD_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AE_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AF_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B0_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B1_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B2_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B3_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B4_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B5_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B6_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B7_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B8_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B9_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BA_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BB_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BC_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BD_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BE_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BF_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C0_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C1_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C2_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C3_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C4_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C5_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C6_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C7_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C8_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C9_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CA_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CB_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CC_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CD_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CE_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CF_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D0_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D1_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D2_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D3_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D4_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D5_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D6_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D7_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D8_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D9_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DA_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DB_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DC_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DD_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DE_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DF_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E0_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E1_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E2_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E3_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E4_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E5_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E6_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E7_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E8_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E9_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EA_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EB_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EC_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01ED_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EE_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EF_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F0_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F1_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F2_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F3_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F4_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F5_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F6_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F7_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F8_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F9_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FA_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FB_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FC_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FD_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FE_PID) },
> +    { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FF_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_USBX_707_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2106_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_1_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_2_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_3_PID) },
> +    { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_4_PID) },
> +    { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
> +    { USB_DEVICE(OCT_VID, OCT_US101_PID) },
> +    { USB_DEVICE(OCT_VID, OCT_DK201_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID) },
> +    { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
> +    { USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
> +    { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
> +    { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E808_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E809_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80A_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80B_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80C_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80D_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80E_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80F_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E888_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E889_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88A_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88B_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88C_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88D_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88E_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IBS_US485_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IBS_PICPRO_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IBS_PCMCIA_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IBS_PK1_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IBS_RS232MON_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TIAO_UMPA_PID) },
> +    /*
> +     * ELV devices:
> +     */
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_USR_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_MSM1_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_KL100_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS550_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_EC3000_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS888_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_TWS550_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_FEM_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UTP8_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS444PC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_HS485_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_UMS100_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_TFD128_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_FM3RX_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELV_WS777_PID) },
> +    { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
> +    { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
> +    { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
> +    { USB_DEVICE(FTDI_VID, LINX_FUTURE_1_PID) },
> +    { USB_DEVICE(FTDI_VID, LINX_FUTURE_2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CCSMACHX_2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CCSLOAD_N_GO_3_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CCSICDU64_4_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CCSPRIME8_5_PID) },
> +    { USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
> +    { USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
> +    { USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
> +    { USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
> +    { USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_OCEANIC_PID) },
> +    { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
> +    { USB_DEVICE(ACTON_VID, ACTON_SPECTRAPRO_PID) },
> +    { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USOPTL4_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USPTL4_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_2_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR2_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_485USB9F_2W_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_485USB9F_4W_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_232USB9M_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_485USBTB_2W_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_485USBTB_4W_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_TTL5USB9M_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_TTL3USB9M_PID) },
> +    { USB_DEVICE(BANDB_VID, BANDB_ZZ_PROG1_USB_PID) },
> +    { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
> +    { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_3_PID) },
> +    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
> +    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
> +    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
> +    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
> +    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
> +    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
> +    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
> +    { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
> +    { USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MHAM_KW_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MHAM_YS_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MHAM_IC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MHAM_DB9_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MHAM_RS232_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y9_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) },
> +    { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
> +    { USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
> +    { USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HRC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16IC_PID) },
> +    { USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) },
> +    { USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) },
> +    { USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TTUSB_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ECLO_COM_1WIRE_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_NZR_SEM_USB_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_1_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_OPC_U_UC_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C1_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C2_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2D_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VT_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VR_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVT_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVR_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVT_PID) },
> +    { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVR_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
> +    { USB_DEVICE(TESTO_VID, TESTO_USB_INTERFACE_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_GAMMA_SCOUT_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13M_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13S_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13U_PID) },
> +    { USB_DEVICE(ELEKTOR_VID, ELEKTOR_FT323R_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_NDI_HUC_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_NDI_SPECTRA_SCU_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_2_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_3_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_NDI_AURORA_SCU_PID) },
> +    { USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
> +    { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_SERIAL_VX7_PID) },
> +    { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_CT29B_PID) },
> +    { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_RTS01_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_PHI_FISCO_PID) },
> +    { USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_ELSTER_UNICOM_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_PROPOX_JTAGCABLEII_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_PROPOX_ISPCABLEIII_PID) },
> +    { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID) },
> +    { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_H_PID) },
> +    { USB_DEVICE(FIC_VID, FIC_NEO1973_DEBUG_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID) },
> +    { USB_DEVICE(FTDI_VID, LMI_LM3S_DEVEL_BOARD_PID) },
> +    { USB_DEVICE(FTDI_VID, LMI_LM3S_EVAL_BOARD_PID) },
> +    { USB_DEVICE(FTDI_VID, LMI_LM3S_ICDI_BOARD_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_TURTELIZER_PID) },
> +    { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
> +    { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
> +
> +    /* Papouch devices based on FTDI chip */
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_2_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_2_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_2_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485S_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485C_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_LEC_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB232_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_IRAMP_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK5_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO8x8_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x2_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO10x1_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO30x3_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO60x3_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x16_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO3x32_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK6_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_UPSUSB_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_MU_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SIMUKEY_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMUX_PID) },
> +    { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMSR_PID) },
> +
> +    { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
> +    { USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
> +    { USB_DEVICE(FTDI_VID, DIEBOLD_BCS_SE923_PID) },
> +    { USB_DEVICE(ATMEL_VID, STK541_PID) },
> +    { USB_DEVICE(DE_VID, STB_PID) },
> +    { USB_DEVICE(DE_VID, WHT_PID) },
> +    { USB_DEVICE(ADI_VID, ADI_GNICE_PID) },
> +    { USB_DEVICE(ADI_VID, ADI_GNICEPLUS_PID) },
> +    { USB_DEVICE_AND_INTERFACE_INFO(MICROCHIP_VID, MICROCHIP_USB_BOARD_PID,
> +                                    0xff, 0xff, 0x00) },
> +    { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) },
> +    { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID) },
> +    { USB_DEVICE(LARSENBRUSGAARD_VID, LB_ALTITRACK_PID) },
> +    { USB_DEVICE(GN_OTOMETRICS_VID, AURICAL_USB_PID) },
> +    { USB_DEVICE(FTDI_VID, PI_C865_PID) },
> +    { USB_DEVICE(FTDI_VID, PI_C857_PID) },
> +    { USB_DEVICE(PI_VID, PI_C866_PID) },
> +    { USB_DEVICE(PI_VID, PI_C663_PID) },
> +    { USB_DEVICE(PI_VID, PI_C725_PID) },
> +    { USB_DEVICE(PI_VID, PI_E517_PID) },
> +    { USB_DEVICE(PI_VID, PI_C863_PID) },
> +    { USB_DEVICE(PI_VID, PI_E861_PID) },
> +    { USB_DEVICE(PI_VID, PI_C867_PID) },
> +    { USB_DEVICE(PI_VID, PI_E609_PID) },
> +    { USB_DEVICE(PI_VID, PI_E709_PID) },
> +    { USB_DEVICE(PI_VID, PI_100F_PID) },
> +    { USB_DEVICE(PI_VID, PI_1011_PID) },
> +    { USB_DEVICE(PI_VID, PI_1012_PID) },
> +    { USB_DEVICE(PI_VID, PI_1013_PID) },
> +    { USB_DEVICE(PI_VID, PI_1014_PID) },
> +    { USB_DEVICE(PI_VID, PI_1015_PID) },
> +    { USB_DEVICE(PI_VID, PI_1016_PID) },
> +    { USB_DEVICE(KONDO_VID, KONDO_USB_SERIAL_PID) },
> +    { USB_DEVICE(BAYER_VID, BAYER_CONTOUR_CABLE_PID) },
> +    { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID) },
> +    { USB_DEVICE(FTDI_VID, TI_XDS100V2_PID) },
> +    { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
> +    { USB_DEVICE(FTDI_VID, HAMEG_HO720_PID) },
> +    { USB_DEVICE(FTDI_VID, HAMEG_HO730_PID) },
> +    { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
> +    { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
> +    { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
> +    { USB_DEVICE(FTDI_VID, MJSG_HD_RADIO_PID) },
> +    { USB_DEVICE(FTDI_VID, MJSG_XM_RADIO_PID) },
> +    { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_ST_PID) },
> +    { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SLITE_PID) },
> +    { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH2_PID) },
> +    { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH4_PID) },
> +    { USB_DEVICE(FTDI_VID, SEGWAY_RMP200_PID) },
> +    { USB_DEVICE(FTDI_VID, ACCESIO_COM4SM_PID) },
> +    { USB_DEVICE(IONICS_VID, IONICS_PLUGCOMPUTER_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_24_MASTER_WING_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_PC_WING_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_USB_DMX_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MIDI_TIMECODE_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MINI_WING_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MAXI_WING_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MEDIA_WING_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_WING_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_CINTERION_MC55I_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_DOTEC_PID) },
> +    { USB_DEVICE(QIHARDWARE_VID, MILKYMISTONE_JTAGSERIAL_PID) },
> +    { USB_DEVICE(ST_VID, ST_STMCLT1030_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_RF_R106) },
> +    { USB_DEVICE(FTDI_VID, FTDI_DISTORTEC_JTAG_LOCK_PICK_PID) },
> +    { USB_DEVICE(FTDI_VID, FTDI_LUMEL_PD12_PID) },
> +
> +    { USB_DEVICE(-1, -1) } /* Terminating Entry */
> +};
> +
> +#undef USB_DEVICE
> +#undef USB_DEVICE_AND_INTERFACE_INFO
> diff --git a/hw/usb/redirect.c b/hw/usb/redirect.c
> index f15dc91..f1bf84c 100644
> --- a/hw/usb/redirect.c
> +++ b/hw/usb/redirect.c
> @@ -52,11 +52,13 @@
>
>  typedef struct USBRedirDevice USBRedirDevice;
>
> -/* Struct to hold buffered packets (iso or int input packets) */
> +/* Struct to hold buffered packets */
>  struct buf_packet {
>      uint8_t *data;
> -    int len;
> -    int status;
> +    void *free_on_destroy;
> +    uint16_t len;
> +    uint16_t offset;
> +    uint8_t status;
>      QTAILQ_ENTRY(buf_packet)next;
>  };
>
> @@ -70,11 +72,14 @@ struct endp_data {
>      uint8_t iso_error; /* For reporting iso errors to the HC */
>      uint8_t interrupt_started;
>      uint8_t interrupt_error;
> +    uint8_t bulk_receiving_enabled;
> +    uint8_t bulk_receiving_started;
>      uint8_t bufpq_prefilled;
>      uint8_t bufpq_dropping_packets;
>      QTAILQ_HEAD(, buf_packet) bufpq;
>      int32_t bufpq_size;
>      int32_t bufpq_target_size;
> +    USBPacket *pending_async_packet;
>  };
>
>  struct PacketIdQueueEntry {
> @@ -108,6 +113,7 @@ struct USBRedirDevice {
>      struct endp_data endpoint[MAX_ENDPOINTS];
>      struct PacketIdQueue cancelled;
>      struct PacketIdQueue already_in_flight;
> +    void (*buffered_bulk_in_complete)(USBRedirDevice *, USBPacket *, uint8_t);
>      /* Data for device filtering */
>      struct usb_redir_device_connect_header device_info;
>      struct usb_redir_interface_info_header interface_info;
> @@ -135,6 +141,8 @@ static void usbredir_interrupt_receiving_status(void *priv, uint64_t id,
>      *interrupt_receiving_status);
>  static void usbredir_bulk_streams_status(void *priv, uint64_t id,
>      struct usb_redir_bulk_streams_status_header *bulk_streams_status);
> +static void usbredir_bulk_receiving_status(void *priv, uint64_t id,
> +    struct usb_redir_bulk_receiving_status_header *bulk_receiving_status);
>  static void usbredir_control_packet(void *priv, uint64_t id,
>      struct usb_redir_control_packet_header *control_packet,
>      uint8_t *data, int data_len);
> @@ -147,6 +155,9 @@ static void usbredir_iso_packet(void *priv, uint64_t id,
>  static void usbredir_interrupt_packet(void *priv, uint64_t id,
>      struct usb_redir_interrupt_packet_header *interrupt_header,
>      uint8_t *data, int data_len);
> +static void usbredir_buffered_bulk_packet(void *priv, uint64_t id,
> +    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_packet,
> +    uint8_t *data, int data_len);
>
>  static void usbredir_handle_status(USBRedirDevice *dev, USBPacket *p,
>      int status);
> @@ -320,12 +331,19 @@ static void packet_id_queue_empty(struct PacketIdQueue *q)
>  static void usbredir_cancel_packet(USBDevice *udev, USBPacket *p)
>  {
>      USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
> +    int i = USBEP2I(p->ep);
>
>      if (p->combined) {
>          usb_combined_packet_cancel(udev, p);
>          return;
>      }
>
> +    if (dev->endpoint[i].pending_async_packet) {
> +        assert(dev->endpoint[i].pending_async_packet == p);
> +        dev->endpoint[i].pending_async_packet = NULL;
> +        return;
> +    }
> +
>      packet_id_queue_add(&dev->cancelled, p->id);
>      usbredirparser_send_cancel_data_packet(dev->parser, p->id);
>      usbredirparser_do_write(dev->parser);
> @@ -344,6 +362,11 @@ static void usbredir_fill_already_in_flight_from_ep(USBRedirDevice *dev,
>  {
>      static USBPacket *p;
>
> +    /* async handled packets for bulk receiving eps do not count as inflight */
> +    if (dev->endpoint[USBEP2I(ep)].bulk_receiving_started) {
> +        return;
> +    }
> +
>      QTAILQ_FOREACH(p, &ep->queue, queue) {
>          /* Skip combined packets, except for the first */
>          if (p->combined && p != p->combined->first) {
> @@ -391,8 +414,8 @@ static USBPacket *usbredir_find_packet_by_id(USBRedirDevice *dev,
>      return p;
>  }
>
> -static void bufp_alloc(USBRedirDevice *dev,
> -    uint8_t *data, int len, int status, uint8_t ep)
> +static void bufp_alloc(USBRedirDevice *dev, uint8_t *data, uint16_t len,
> +    uint8_t status, uint8_t ep, void *free_on_destroy)
>  {
>      struct buf_packet *bufp;
>
> @@ -416,7 +439,9 @@ static void bufp_alloc(USBRedirDevice *dev,
>      bufp = g_malloc(sizeof(struct buf_packet));
>      bufp->data   = data;
>      bufp->len    = len;
> +    bufp->offset = 0;
>      bufp->status = status;
> +    bufp->free_on_destroy = free_on_destroy;
>      QTAILQ_INSERT_TAIL(&dev->endpoint[EP2I(ep)].bufpq, bufp, next);
>      dev->endpoint[EP2I(ep)].bufpq_size++;
>  }
> @@ -426,7 +451,7 @@ static void bufp_free(USBRedirDevice *dev, struct buf_packet *bufp,
>  {
>      QTAILQ_REMOVE(&dev->endpoint[EP2I(ep)].bufpq, bufp, next);
>      dev->endpoint[EP2I(ep)].bufpq_size--;
> -    free(bufp->data);
> +    free(bufp->free_on_destroy);
>      g_free(bufp);
>  }
>
> @@ -577,19 +602,162 @@ static void usbredir_stop_iso_stream(USBRedirDevice *dev, uint8_t ep)
>      usbredir_free_bufpq(dev, ep);
>  }
>
> +/*
> + * The usb-host may poll the endpoint faster then our guest, resulting in lots
> + * of smaller bulkp-s. The below buffered_bulk_in_complete* functions combine
> + * data from multiple bulkp-s into a single packet, avoiding bufpq overflows.
> + */
> +static void usbredir_buffered_bulk_add_data_to_packet(USBRedirDevice *dev,
> +    struct buf_packet *bulkp, int count, USBPacket *p, uint8_t ep)
> +{
> +    usb_packet_copy(p, bulkp->data + bulkp->offset, count);
> +    bulkp->offset += count;
> +    if (bulkp->offset == bulkp->len) {
> +        /* Store status in the last packet with data from this bulkp */
> +        usbredir_handle_status(dev, p, bulkp->status);
> +        bufp_free(dev, bulkp, ep);
> +    }
> +}
> +
> +static void usbredir_buffered_bulk_in_complete_raw(USBRedirDevice *dev,
> +    USBPacket *p, uint8_t ep)
> +{
> +    struct buf_packet *bulkp;
> +    int count;
> +
> +    while ((bulkp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq)) &&
> +           p->actual_length < p->iov.size && p->status == USB_RET_SUCCESS) {
> +        count = bulkp->len - bulkp->offset;
> +        if (count > (p->iov.size - p->actual_length)) {
> +            count = p->iov.size - p->actual_length;
> +        }
> +        usbredir_buffered_bulk_add_data_to_packet(dev, bulkp, count, p, ep);
> +    }
> +}
> +
> +static void usbredir_buffered_bulk_in_complete_ftdi(USBRedirDevice *dev,
> +    USBPacket *p, uint8_t ep)
> +{
> +    const int maxp = dev->endpoint[EP2I(ep)].max_packet_size;
> +    uint8_t header[2] = { 0, 0 };
> +    struct buf_packet *bulkp;
> +    int count;
> +
> +    while ((bulkp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq)) &&
> +           p->actual_length < p->iov.size && p->status == USB_RET_SUCCESS) {
> +        if (bulkp->len < 2) {
> +            WARNING("malformed ftdi bulk in packet\n");
> +            bufp_free(dev, bulkp, ep);
> +            continue;
> +        }
> +
> +        if ((p->actual_length % maxp) == 0) {
> +            usb_packet_copy(p, bulkp->data, 2);
> +            memcpy(header, bulkp->data, 2);
> +        } else {
> +            if (bulkp->data[0] != header[0] || bulkp->data[1] != header[1]) {
> +                break; /* Different header, add to next packet */
> +            }
> +        }
> +
> +        if (bulkp->offset == 0) {
> +            bulkp->offset = 2; /* Skip header */
> +        }
> +        count = bulkp->len - bulkp->offset;
> +        /* Must repeat the header at maxp interval */
> +        if (count > (maxp - (p->actual_length % maxp))) {
> +            count = maxp - (p->actual_length % maxp);
> +        }
> +        usbredir_buffered_bulk_add_data_to_packet(dev, bulkp, count, p, ep);
> +    }
> +}
> +
> +static void usbredir_buffered_bulk_in_complete(USBRedirDevice *dev,
> +    USBPacket *p, uint8_t ep)
> +{
> +    p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
> +    dev->buffered_bulk_in_complete(dev, p, ep);
> +    DPRINTF("bulk-token-in ep %02X status %d len %d id %"PRIu64"\n",
> +            ep, p->status, p->actual_length, p->id);
> +}
> +
> +static void usbredir_handle_buffered_bulk_in_data(USBRedirDevice *dev,
> +    USBPacket *p, uint8_t ep)
> +{
> +    /* Input bulk endpoint, buffered packet input */
> +    if (!dev->endpoint[EP2I(ep)].bulk_receiving_started) {
> +        int bpt;
> +        struct usb_redir_start_bulk_receiving_header start = {
> +            .endpoint = ep,
> +            .stream_id = 0,
> +            .no_transfers = 5,
> +        };
> +        /* Round bytes_per_transfer up to a multiple of max_packet_size */
> +        bpt = 512 + dev->endpoint[EP2I(ep)].max_packet_size - 1;
> +        bpt /= dev->endpoint[EP2I(ep)].max_packet_size;
> +        bpt *= dev->endpoint[EP2I(ep)].max_packet_size;
> +        start.bytes_per_transfer = bpt;
> +        /* No id, we look at the ep when receiving a status back */
> +        usbredirparser_send_start_bulk_receiving(dev->parser, 0, &start);
> +        usbredirparser_do_write(dev->parser);
> +        DPRINTF("bulk receiving started bytes/transfer %u count %d ep %02X\n",
> +                start.bytes_per_transfer, start.no_transfers, ep);
> +        dev->endpoint[EP2I(ep)].bulk_receiving_started = 1;
> +        /* We don't really want to drop bulk packets ever, but
> +           having some upper limit to how much we buffer is good. */
> +        dev->endpoint[EP2I(ep)].bufpq_target_size = 5000;
> +        dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
> +    }
> +
> +    if (QTAILQ_EMPTY(&dev->endpoint[EP2I(ep)].bufpq)) {
> +        DPRINTF("bulk-token-in ep %02X, no bulkp\n", ep);
> +        assert(dev->endpoint[EP2I(ep)].pending_async_packet == NULL);
> +        dev->endpoint[EP2I(ep)].pending_async_packet = p;
> +        p->status = USB_RET_ASYNC;
> +        return;
> +    }
> +    usbredir_buffered_bulk_in_complete(dev, p, ep);
> +}
> +
> +static void usbredir_stop_bulk_receiving(USBRedirDevice *dev, uint8_t ep)
> +{
> +    struct usb_redir_stop_bulk_receiving_header stop_bulk = {
> +        .endpoint = ep,
> +        .stream_id = 0,
> +    };
> +    if (dev->endpoint[EP2I(ep)].bulk_receiving_started) {
> +        usbredirparser_send_stop_bulk_receiving(dev->parser, 0, &stop_bulk);
> +        DPRINTF("bulk receiving stopped ep %02X\n", ep);
> +        dev->endpoint[EP2I(ep)].bulk_receiving_started = 0;
> +    }
> +    usbredir_free_bufpq(dev, ep);
> +}
> +
>  static void usbredir_handle_bulk_data(USBRedirDevice *dev, USBPacket *p,
>                                        uint8_t ep)
>  {
>      struct usb_redir_bulk_packet_header bulk_packet;
>      size_t size = (p->combined) ? p->combined->iov.size : p->iov.size;
> -
> -    DPRINTF("bulk-out ep %02X len %zd id %"PRIu64"\n", ep, size, p->id);
> +    const int maxp = dev->endpoint[EP2I(ep)].max_packet_size;
>
>      if (usbredir_already_in_flight(dev, p->id)) {
>          p->status = USB_RET_ASYNC;
>          return;
>      }
>
> +    if (dev->endpoint[EP2I(ep)].bulk_receiving_enabled) {
> +        if (size != 0 && (size % maxp) == 0) {
> +            usbredir_handle_buffered_bulk_in_data(dev, p, ep);
> +            return;
> +        }
> +        WARNING("bulk recv invalid size %zd ep %02x, disabling\n", size, ep);
> +        assert(dev->endpoint[EP2I(ep)].pending_async_packet == NULL);
> +        usbredir_stop_bulk_receiving(dev, ep);
> +        dev->endpoint[EP2I(ep)].bulk_receiving_enabled = 0;
> +    }
> +
> +    DPRINTF("bulk-out ep %02X len %zd id %"PRIu64"\n", ep, size, p->id);
> +
>      bulk_packet.endpoint  = ep;
>      bulk_packet.length    = size;
>      bulk_packet.stream_id = 0;
> @@ -726,9 +894,6 @@ static void usbredir_handle_data(USBDevice *udev, USBPacket *p)
>          ERROR("handle_data called for control transfer on ep %02X\n", ep);
>          p->status = USB_RET_NAK;
>          break;
> -    case USB_ENDPOINT_XFER_ISOC:
> -        usbredir_handle_iso_data(dev, p, ep);
> -        break;
>      case USB_ENDPOINT_XFER_BULK:
>          if (p->state == USB_PACKET_SETUP && p->pid == USB_TOKEN_IN &&
>                  p->ep->pipeline) {
> @@ -737,6 +902,9 @@ static void usbredir_handle_data(USBDevice *udev, USBPacket *p)
>          }
>          usbredir_handle_bulk_data(dev, p, ep);
>          break;
> +    case USB_ENDPOINT_XFER_ISOC:
> +        usbredir_handle_iso_data(dev, p, ep);
> +        break;
>      case USB_ENDPOINT_XFER_INT:
>          if (ep & USB_DIR_IN) {
>              usbredir_handle_interrupt_in_data(dev, p, ep);
> @@ -763,6 +931,11 @@ static void usbredir_stop_ep(USBRedirDevice *dev, int i)
>      uint8_t ep = I2EP(i);
>
>      switch (dev->endpoint[i].type) {
> +    case USB_ENDPOINT_XFER_BULK:
> +        if (ep & USB_DIR_IN) {
> +            usbredir_stop_bulk_receiving(dev, ep);
> +        }
> +        break;
>      case USB_ENDPOINT_XFER_ISOC:
>          usbredir_stop_iso_stream(dev, ep);
>          break;
> @@ -942,10 +1115,12 @@ static void usbredir_create_parser(USBRedirDevice *dev)
>      dev->parser->interrupt_receiving_status_func =
>          usbredir_interrupt_receiving_status;
>      dev->parser->bulk_streams_status_func = usbredir_bulk_streams_status;
> +    dev->parser->bulk_receiving_status_func = usbredir_bulk_receiving_status;
>      dev->parser->control_packet_func = usbredir_control_packet;
>      dev->parser->bulk_packet_func = usbredir_bulk_packet;
>      dev->parser->iso_packet_func = usbredir_iso_packet;
>      dev->parser->interrupt_packet_func = usbredir_interrupt_packet;
> +    dev->parser->buffered_bulk_packet_func = usbredir_buffered_bulk_packet;
>      dev->read_buf = NULL;
>      dev->read_buf_size = 0;
>
> @@ -954,6 +1129,7 @@ static void usbredir_create_parser(USBRedirDevice *dev)
>      usbredirparser_caps_set_cap(caps, usb_redir_cap_ep_info_max_packet_size);
>      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 (runstate_check(RUN_STATE_INMIGRATE)) {
>          flags |= usbredirparser_fl_no_hello;
> @@ -1192,6 +1368,52 @@ error:
>      return -1;
>  }
>
> +static void usbredir_check_bulk_receiving(USBRedirDevice *dev)
> +{
> +    int i, j, quirks;
> +
> +    if (!usbredirparser_peer_has_cap(dev->parser,
> +                                     usb_redir_cap_bulk_receiving)) {
> +        return;
> +    }
> +
> +    for (i = EP2I(USB_DIR_IN); i < MAX_ENDPOINTS; i++) {
> +        dev->endpoint[i].bulk_receiving_enabled = 0;
> +    }
> +    for (i = 0; i < dev->interface_info.interface_count; i++) {
> +        quirks = usb_get_quirks(dev->device_info.vendor_id,
> +                                dev->device_info.product_id,
> +                                dev->interface_info.interface_class[i],
> +                                dev->interface_info.interface_subclass[i],
> +                                dev->interface_info.interface_protocol[i]);
> +        if (!(quirks & USB_QUIRK_BUFFER_BULK_IN)) {
> +            continue;
> +        }
> +        if (quirks & USB_QUIRK_IS_FTDI) {
> +            dev->buffered_bulk_in_complete =
> +                usbredir_buffered_bulk_in_complete_ftdi;
> +        } else {
> +            dev->buffered_bulk_in_complete =
> +                usbredir_buffered_bulk_in_complete_raw;
> +        }
> +
> +        for (j = EP2I(USB_DIR_IN); j < MAX_ENDPOINTS; j++) {
> +            if (dev->endpoint[j].interface ==
> +                                    dev->interface_info.interface[i] &&
> +                    dev->endpoint[j].type == USB_ENDPOINT_XFER_BULK &&
> +                    dev->endpoint[j].max_packet_size != 0) {
> +                dev->endpoint[j].bulk_receiving_enabled = 1;
> +                /*
> +                 * With buffering pipelining is not necessary. Also packet
> +                 * combining and bulk in buffering don't play nice together!
> +                 */
> +                I2USBEP(dev, j)->pipeline = false;
> +                break; /* Only buffer for the first ep of each intf */
> +            }
> +        }
> +    }
> +}
> +
>  /*
>   * usbredirparser packet complete callbacks
>   */
> @@ -1300,6 +1522,7 @@ static void usbredir_device_connect(void *priv,
>          return;
>      }
>
> +    usbredir_check_bulk_receiving(dev);
>      qemu_mod_timer(dev->attach_timer, dev->next_attach_time);
>  }
>
> @@ -1338,9 +1561,10 @@ static void usbredir_interface_info(void *priv,
>
>      /*
>       * If we receive interface info after the device has already been
> -     * connected (ie on a set_config), re-check the filter.
> +     * connected (ie on a set_config), re-check interface dependent things.
>       */
>      if (qemu_timer_pending(dev->attach_timer) || dev->dev.attached) {
> +        usbredir_check_bulk_receiving(dev);
>          if (usbredir_check_filter(dev)) {
>              ERROR("Device no longer matches filter after interface info "
>                    "change, disconnecting!\n");
> @@ -1441,6 +1665,7 @@ static void usbredir_ep_info(void *priv,
>          return;
>      }
>      usbredir_setup_usb_eps(dev);
> +    usbredir_check_bulk_receiving(dev);
>  }
>
>  static void usbredir_configuration_status(void *priv, uint64_t id,
> @@ -1531,6 +1756,25 @@ static void usbredir_bulk_streams_status(void *priv, uint64_t id,
>  {
>  }
>
> +static void usbredir_bulk_receiving_status(void *priv, uint64_t id,
> +    struct usb_redir_bulk_receiving_status_header *bulk_receiving_status)
> +{
> +    USBRedirDevice *dev = priv;
> +    uint8_t ep = bulk_receiving_status->endpoint;
> +
> +    DPRINTF("bulk recv status %d ep %02X id %"PRIu64"\n",
> +            bulk_receiving_status->status, ep, id);
> +
> +    if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].bulk_receiving_started) {
> +        return;
> +    }
> +
> +    if (bulk_receiving_status->status == usb_redir_stall) {
> +        DPRINTF("bulk receiving stopped by peer ep %02X\n", ep);
> +        dev->endpoint[EP2I(ep)].bulk_receiving_started = 0;
> +    }
> +}
> +
>  static void usbredir_control_packet(void *priv, uint64_t id,
>      struct usb_redir_control_packet_header *control_packet,
>      uint8_t *data, int data_len)
> @@ -1636,7 +1880,7 @@ static void usbredir_iso_packet(void *priv, uint64_t id,
>      }
>
>      /* bufp_alloc also adds the packet to the ep queue */
> -    bufp_alloc(dev, data, data_len, iso_packet->status, ep);
> +    bufp_alloc(dev, data, data_len, iso_packet->status, ep, data);
>  }
>
>  static void usbredir_interrupt_packet(void *priv, uint64_t id,
> @@ -1667,7 +1911,7 @@ static void usbredir_interrupt_packet(void *priv, uint64_t id,
>          }
>
>          /* bufp_alloc also adds the packet to the ep queue */
> -        bufp_alloc(dev, data, data_len, interrupt_packet->status, ep);
> +        bufp_alloc(dev, data, data_len, interrupt_packet->status, ep, data);
>      } else {
>          /*
>           * We report output interrupt packets as completed directly upon
> @@ -1680,6 +1924,52 @@ static void usbredir_interrupt_packet(void *priv, uint64_t id,
>      }
>  }
>
> +static void usbredir_buffered_bulk_packet(void *priv, uint64_t id,
> +    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_packet,
> +    uint8_t *data, int data_len)
> +{
> +    USBRedirDevice *dev = priv;
> +    uint8_t status, ep = buffered_bulk_packet->endpoint;
> +    void *free_on_destroy;
> +    int i, len;
> +
> +    DPRINTF("buffered-bulk-in status %d ep %02X len %d id %"PRIu64"\n",
> +            buffered_bulk_packet->status, ep, data_len, id);
> +
> +    if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_BULK) {
> +        ERROR("received buffered-bulk packet for non bulk ep %02X\n", ep);
> +        free(data);
> +        return;
> +    }
> +
> +    if (dev->endpoint[EP2I(ep)].bulk_receiving_started == 0) {
> +        DPRINTF("received buffered-bulk packet on not started ep %02X\n", ep);
> +        free(data);
> +        return;
> +    }
> +
> +    /* Data must be in maxp chunks for buffered_bulk_add_*_data_to_packet */
> +    len = dev->endpoint[EP2I(ep)].max_packet_size;
> +    status = usb_redir_success;
> +    free_on_destroy = NULL;
> +    for (i = 0; i < data_len; i += len) {
> +        if (len >= (data_len - i)) {
> +            len = data_len - i;
> +            status = buffered_bulk_packet->status;
> +            free_on_destroy = data;
> +        }
> +        /* bufp_alloc also adds the packet to the ep queue */
> +        bufp_alloc(dev, data + i, len, status, ep, free_on_destroy);
> +    }
> +
> +    if (dev->endpoint[EP2I(ep)].pending_async_packet) {
> +        USBPacket *p = dev->endpoint[EP2I(ep)].pending_async_packet;
> +        dev->endpoint[EP2I(ep)].pending_async_packet = NULL;
> +        usbredir_buffered_bulk_in_complete(dev, p, ep);
> +        usb_packet_complete(&dev->dev, p);
> +    }
> +}
> +
>  /*
>   * Migration code
>   */
> @@ -1714,6 +2004,7 @@ static int usbredir_post_load(void *priv, int version_id)
>      dev->dev.speedmask = (1 << dev->dev.speed);
>
>      usbredir_setup_usb_eps(dev);
> +    usbredir_check_bulk_receiving(dev);
>
>      return 0;
>  }
> @@ -1787,15 +2078,16 @@ static void usbredir_put_bufpq(QEMUFile *f, void *priv, size_t unused)
>      struct endp_data *endp = priv;
>      USBRedirDevice *dev = endp->dev;
>      struct buf_packet *bufp;
> -    int i = 0;
> +    int len, i = 0;
>
>      qemu_put_be32(f, endp->bufpq_size);
>      QTAILQ_FOREACH(bufp, &endp->bufpq, next) {
> +        len = bufp->len - bufp->offset;
>          DPRINTF("put_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size,
> -                bufp->len, bufp->status);
> -        qemu_put_be32(f, bufp->len);
> +                len, bufp->status);
> +        qemu_put_be32(f, len);
>          qemu_put_be32(f, bufp->status);
> -        qemu_put_buffer(f, bufp->data, bufp->len);
> +        qemu_put_buffer(f, bufp->data + bufp->offset, len);
>          i++;
>      }
>      assert(i == endp->bufpq_size);
> @@ -1813,7 +2105,9 @@ static int usbredir_get_bufpq(QEMUFile *f, void *priv, size_t unused)
>          bufp = g_malloc(sizeof(struct buf_packet));
>          bufp->len = qemu_get_be32(f);
>          bufp->status = qemu_get_be32(f);
> +        bufp->offset = 0;
>          bufp->data = qemu_oom_check(malloc(bufp->len)); /* regular malloc! */
> +        bufp->free_on_destroy = bufp->data;
>          qemu_get_buffer(f, bufp->data, bufp->len);
>          QTAILQ_INSERT_TAIL(&endp->bufpq, bufp, next);
>          DPRINTF("get_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size,
> @@ -1830,6 +2124,23 @@ static const VMStateInfo usbredir_ep_bufpq_vmstate_info = {
>
>
>  /* For endp_data migration */
> +static const VMStateDescription usbredir_bulk_receiving_vmstate = {
> +    .name = "usb-redir-ep/bulk-receiving",
> +    .version_id = 1,
> +    .minimum_version_id = 1,
> +    .fields = (VMStateField[]) {
> +        VMSTATE_UINT8(bulk_receiving_started, struct endp_data),
> +        VMSTATE_END_OF_LIST()
> +    }
> +};
> +
> +static bool usbredir_bulk_receiving_needed(void *priv)
> +{
> +    struct endp_data *endp = priv;
> +
> +    return endp->bulk_receiving_started;
> +}
> +
>  static const VMStateDescription usbredir_ep_vmstate = {
>      .name = "usb-redir-ep",
>      .version_id = 1,
> @@ -1856,6 +2167,14 @@ static const VMStateDescription usbredir_ep_vmstate = {
>          },
>          VMSTATE_INT32(bufpq_target_size, struct endp_data),
>          VMSTATE_END_OF_LIST()
> +    },
> +    .subsections = (VMStateSubsection[]) {
> +        {
> +            .vmsd = &usbredir_bulk_receiving_vmstate,
> +            .needed = usbredir_bulk_receiving_needed,
> +        }, {
> +            /* empty */
> +        }
>      }
>  };
>
> --
> 1.7.1
>
>

Re: [Qemu-devel] [PATCH 31/32] usbredir: Add support for buffered bulk input (v2)

[Hans de Goede]

Hi,

On 01/09/2013 09:52 PM, Blue Swirl wrote:

<snip>

>> diff --git a/hw/usb/quirks-ftdi-ids.h b/hw/usb/quirks-ftdi-ids.h
>> new file mode 100644
>> index 0000000..57c12ef
>> --- /dev/null
>> +++ b/hw/usb/quirks-ftdi-ids.h
>> @@ -0,0 +1,1255 @@
>> +/*
>> + * vendor/product IDs (VID/PID) of devices using FTDI USB serial converters.
>> + * Please keep numerically sorted within individual areas, thanks!
>> + *
>> + * Philipp Gühring - pg@futureware.at - added the Device ID of the USB relais
>> + * from Rudolf Gugler
>
> License information is missing.
>
> Where is this file coming from, Linux?

Yes, it is a one on one copy of linux/drivers/usb/serial/ftdi_sio_ids.h,
so I did not think it would be a good idea to simply slap a copyright header on top
...

One could argue it is an integral part of linux/drivers/usb/serial/ftdi_sio.c and use
the copy right headers from there.

> Should we use linux-headers instead?

Since this is a copy of an internal kernel header, rather then of one from the
linux/include/linux or linux/include/asm "public" hierarchies it seemed wrong to me to
use linux-headers for this.

Regards,

Hans

Re: [Qemu-devel] [PATCH 31/32] usbredir: Add support for buffered bulk input (v2)

[Blue Swirl]

On Wed, Jan 9, 2013 at 10:04 PM, Hans de Goede <hdegoede@redhat.com> wrote:
> Hi,
>
> On 01/09/2013 09:52 PM, Blue Swirl wrote:
>
> <snip>
>
>
>>> diff --git a/hw/usb/quirks-ftdi-ids.h b/hw/usb/quirks-ftdi-ids.h
>>> new file mode 100644
>>> index 0000000..57c12ef
>>> --- /dev/null
>>> +++ b/hw/usb/quirks-ftdi-ids.h
>>> @@ -0,0 +1,1255 @@
>>> +/*
>>> + * vendor/product IDs (VID/PID) of devices using FTDI USB serial
>>> converters.
>>> + * Please keep numerically sorted within individual areas, thanks!
>>> + *
>>> + * Philipp Gühring - pg@futureware.at - added the Device ID of the USB
>>> relais
>>> + * from Rudolf Gugler
>>
>>
>> License information is missing.
>>
>> Where is this file coming from, Linux?
>
>
> Yes, it is a one on one copy of linux/drivers/usb/serial/ftdi_sio_ids.h,
> so I did not think it would be a good idea to simply slap a copyright header
> on top
> ...
>
> One could argue it is an integral part of
> linux/drivers/usb/serial/ftdi_sio.c and use
> the copy right headers from there.

That file uses GPLv2+ which would be nicer than the default GPLv2.
ftdi_sio_ids.h was extracted from ftdi_sio.h by
31844d55800e1b93fe75c4d6188a4a44db2e1bbe. ftdi_sio.h reaches beyond
git history but there were several contributors already during that
period.

Perhaps the license should be clarified with the Linux developers.

In this case the license is most probably either GPLv2 or GPLv2+ and
either is fine for QEMU use, but the lesson here is that committing
external files with no license information may be asking for trouble.

>
>
>> Should we use linux-headers instead?
>
>
> Since this is a copy of an internal kernel header, rather then of one from
> the
> linux/include/linux or linux/include/asm "public" hierarchies it seemed
> wrong to me to
> use linux-headers for this.

OK.

>
> Regards,
>
> Hans

[Qemu-devel] [PATCH 32/32] uhci: stop using portio lists

[Gerd Hoffmann]

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 hw/usb/hcd-uhci.c |  106 +++++++++++++++--------------------------------------
 trace-events      |    2 -
 2 files changed, 30 insertions(+), 78 deletions(-)

diff --git a/hw/usb/hcd-uhci.c b/hw/usb/hcd-uhci.c
index 0cd68cf..60645aa 100644
--- a/hw/usb/hcd-uhci.c
+++ b/hw/usb/hcd-uhci.c
@@ -461,40 +461,11 @@ static const VMStateDescription vmstate_uhci = {
     }
 };
 
-static void uhci_ioport_writeb(void *opaque, uint32_t addr, uint32_t val)
+static void uhci_port_write(void *opaque, hwaddr addr,
+                            uint64_t val, unsigned size)
 {
     UHCIState *s = opaque;
 
-    addr &= 0x1f;
-    switch(addr) {
-    case 0x0c:
-        s->sof_timing = val;
-        break;
-    }
-}
-
-static uint32_t uhci_ioport_readb(void *opaque, uint32_t addr)
-{
-    UHCIState *s = opaque;
-    uint32_t val;
-
-    addr &= 0x1f;
-    switch(addr) {
-    case 0x0c:
-        val = s->sof_timing;
-        break;
-    default:
-        val = 0xff;
-        break;
-    }
-    return val;
-}
-
-static void uhci_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
-{
-    UHCIState *s = opaque;
-
-    addr &= 0x1f;
     trace_usb_uhci_mmio_writew(addr, val);
 
     switch(addr) {
@@ -543,6 +514,17 @@ static void uhci_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
         if (s->status & UHCI_STS_HCHALTED)
             s->frnum = val & 0x7ff;
         break;
+    case 0x08:
+        s->fl_base_addr &= 0xffff0000;
+        s->fl_base_addr |= val & ~0xfff;
+        break;
+    case 0x0a:
+        s->fl_base_addr &= 0x0000ffff;
+        s->fl_base_addr |= (val << 16);
+        break;
+    case 0x0c:
+        s->sof_timing = val & 0xff;
+        break;
     case 0x10 ... 0x1f:
         {
             UHCIPort *port;
@@ -574,12 +556,11 @@ static void uhci_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
     }
 }
 
-static uint32_t uhci_ioport_readw(void *opaque, uint32_t addr)
+static uint64_t uhci_port_read(void *opaque, hwaddr addr, unsigned size)
 {
     UHCIState *s = opaque;
     uint32_t val;
 
-    addr &= 0x1f;
     switch(addr) {
     case 0x00:
         val = s->cmd;
@@ -593,6 +574,15 @@ static uint32_t uhci_ioport_readw(void *opaque, uint32_t addr)
     case 0x06:
         val = s->frnum;
         break;
+    case 0x08:
+        val = s->fl_base_addr & 0xffff;
+        break;
+    case 0x0a:
+        val = (s->fl_base_addr >> 16) & 0xffff;
+        break;
+    case 0x0c:
+        val = s->sof_timing;
+        break;
     case 0x10 ... 0x1f:
         {
             UHCIPort *port;
@@ -615,38 +605,6 @@ static uint32_t uhci_ioport_readw(void *opaque, uint32_t addr)
     return val;
 }
 
-static void uhci_ioport_writel(void *opaque, uint32_t addr, uint32_t val)
-{
-    UHCIState *s = opaque;
-
-    addr &= 0x1f;
-    trace_usb_uhci_mmio_writel(addr, val);
-
-    switch(addr) {
-    case 0x08:
-        s->fl_base_addr = val & ~0xfff;
-        break;
-    }
-}
-
-static uint32_t uhci_ioport_readl(void *opaque, uint32_t addr)
-{
-    UHCIState *s = opaque;
-    uint32_t val;
-
-    addr &= 0x1f;
-    switch(addr) {
-    case 0x08:
-        val = s->fl_base_addr;
-        break;
-    default:
-        val = 0xffffffff;
-        break;
-    }
-    trace_usb_uhci_mmio_readl(addr, val);
-    return val;
-}
-
 /* signal resume if controller suspended */
 static void uhci_resume (void *opaque)
 {
@@ -1236,18 +1194,14 @@ static void uhci_frame_timer(void *opaque)
     qemu_mod_timer(s->frame_timer, t_now + frame_t);
 }
 
-static const MemoryRegionPortio uhci_portio[] = {
-    { 0, 32, 2, .write = uhci_ioport_writew, },
-    { 0, 32, 2, .read = uhci_ioport_readw, },
-    { 0, 32, 4, .write = uhci_ioport_writel, },
-    { 0, 32, 4, .read = uhci_ioport_readl, },
-    { 0, 32, 1, .write = uhci_ioport_writeb, },
-    { 0, 32, 1, .read = uhci_ioport_readb, },
-    PORTIO_END_OF_LIST()
-};
-
 static const MemoryRegionOps uhci_ioport_ops = {
-    .old_portio = uhci_portio,
+    .read  = uhci_port_read,
+    .write = uhci_port_write,
+    .valid.min_access_size = 1,
+    .valid.max_access_size = 4,
+    .impl.min_access_size = 2,
+    .impl.max_access_size = 2,
+    .endianness = DEVICE_LITTLE_ENDIAN,
 };
 
 static USBPortOps uhci_port_ops = {
diff --git a/trace-events b/trace-events
index 4023a4c..2183183 100644
--- a/trace-events
+++ b/trace-events
@@ -307,8 +307,6 @@ usb_uhci_frame_loop_stop_idle(void) ""
 usb_uhci_frame_loop_continue(void) ""
 usb_uhci_mmio_readw(uint32_t addr, uint32_t val) "addr 0x%04x, ret 0x%04x"
 usb_uhci_mmio_writew(uint32_t addr, uint32_t val) "addr 0x%04x, val 0x%04x"
-usb_uhci_mmio_readl(uint32_t addr, uint32_t val) "addr 0x%04x, ret 0x%08x"
-usb_uhci_mmio_writel(uint32_t addr, uint32_t val) "addr 0x%04x, val 0x%08x"
 usb_uhci_queue_add(uint32_t token) "token 0x%x"
 usb_uhci_queue_del(uint32_t token, const char *reason) "token 0x%x: %s"
 usb_uhci_packet_add(uint32_t token, uint32_t addr) "token 0x%x, td 0x%x"
-- 
1.7.1

Re: [Qemu-devel] [PULL 00/32] usb patch queue

[Anthony Liguori]

Pulled, thanks.

N.B.  This note may be extraneous because the pull request was sent by a
version of git older than 1.7.9 making the pull request ambigious.  Please
consider upgrading to a newer version of git.

Regards,

Anthony Liguori