Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 879 insertions, 0 deletions

diff --git a/src/VBox/Devices/USB/os2/USBProxyDevice-os2.cpp b/src/VBox/Devices/USB/os2/USBProxyDevice-os2.cpp
new file mode 100644
index 00000000..291db1bd
--- /dev/null
+++ b/src/VBox/Devices/USB/os2/USBProxyDevice-os2.cpp
@@ -0,0 +1,879 @@
+/* $Id: USBProxyDevice-os2.cpp $ */
+/** @file
+ * USB device proxy - the Linux backend.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * 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, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DRV_USBPROXY
+#include <VBox/vmm/pdm.h>
+#include <VBox/err.h>
+#include <VBox/log.h>
+#include <iprt/assert.h>
+#include <iprt/stream.h>
+#include <iprt/alloc.h>
+#include <iprt/thread.h>
+#include <iprt/time.h>
+#include <iprt/asm.h>
+#include <iprt/string.h>
+#include <iprt/semaphore.h>
+#include <iprt/file.h>
+#include "../USBProxyDevice.h"
+
+#define INCL_BASE
+#define INCL_ERRORS
+#include <os2.h>
+#include <usbcalls.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Structure for keeping track of the URBs for a device.
+ */
+typedef struct USBPROXYURBOS2
+{
+    /** Pointer to the virtual URB. */
+    PVUSBURB                pUrb;
+    /** Pointer to the next OS/2 URB. */
+    struct USBPROXYURBOS2  *pNext;
+    /** Pointer to the previous OS/2 URB. */
+    struct USBPROXYURBOS2  *pPrev;
+} USBPROXYURBOS2, *PUSBPROXYURBOS2;
+
+/**
+ * Data for the OS/2 usb proxy backend.
+ */
+typedef struct USBPROXYDEVOS2
+{
+    /** The async thread for this device.
+     * Currently only one thread is used, but this might have to change... */
+    RTTHREAD            Thread;
+    /** Thread termination indicator. */
+    bool volatile       fTerminate;
+    /** The USB handle. */
+    USBHANDLE           hDevice;
+    /** Critical section protecting the lists. */
+    RTCRITSECT          CritSect;
+    /** For blocking reap calls. */
+    RTSEMEVENT          EventSyncWait;
+    /** List of URBs to process. Doubly linked. */
+    PUSBPROXYURBOS2     pTodoHead;
+    /** The tail pointer. */
+    PUSBPROXYURBOS2     pTodoTail;
+    /** The list of free linux URBs. Singly linked. */
+    PUSBPROXYURBOS2     pFreeHead;
+    /** The list of active linux URBs. Doubly linked.
+     * We must maintain this so we can properly reap URBs of a detached device.
+     * Only the split head will appear in this list. */
+    PUSBPROXYURBOS2     pInFlightHead;
+    /** The list of landed linux URBs. Doubly linked.
+     * Only the split head will appear in this list. */
+    PUSBPROXYURBOS2     pTaxingHead;
+    /** The tail of the landed linux URBs. */
+    PUSBPROXYURBOS2     pTaxingTail;
+} USBPROXYDEVOS2, *PUSBPROXYDEVOS2;
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+#ifdef DYNAMIC_USBCALLS
+static int usbProxyOs2GlobalInit(void);
+#endif
+static PUSBPROXYURBOS2 usbProxyOs2UrbAlloc(PUSBPROXYDEV pProxyDev);
+static void usbProxyOs2UrbFree(PUSBPROXYDEV pProxyDev, PUSBPROXYURBOS2 pUrbOs2);
+static DECLCALLBACK(int) usbProxyOs2AsyncThread(RTTHREAD Thread, void *pvProxyDev);
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+#ifdef DYNAMIC_USBCALLS
+static HMODULE g_hmod;
+static APIRET (APIENTRY *g_pfnUsbOpen)(PUSBHANDLE, USHORT, USHORT, USHORT, USHORT);
+static APIRET (APIENTRY *g_pfnUsbClose)(USBHANDLE);
+static APIRET (APIENTRY *g_pfnUsbCtrlMessage)(USBHANDLE, UCHAR, UCHAR, USHORT, USHORT, USHORT, void *, ULONG);
+static APIRET (APIENTRY *g_pfnUsbBulkRead2)(USBHANDLE, UCHAR, UCHAR, BOOL, PULONG, void *, ULONG);
+static APIRET (APIENTRY *g_pfnUsbBulkWrite2)(USBHANDLE, UCHAR, UCHAR, BOOL, ULONG, void *, ULONG);
+#else
+# define g_pfnUsbOpen UsbOpen
+# define g_pfnUsbClose UsbClose
+# define g_pfnUsbCtrlMessage UsbCtrlMessage
+# define g_pfnUsbBulkRead2 UsbBulkRead2
+# define g_pfnUsbBulkWrite2 UsbBulkWrite2
+#endif
+
+
+
+#ifdef DYNAMIC_USBCALLS
+/**
+ * Loads usbcalls.dll and resolves the symbols we need.
+ *
+ * The usbcalls.dll will not be unloaded.
+ *
+ * @returns VBox status code.
+ */
+static int usbProxyOs2GlobalInit(void)
+{
+    int rc = DosLoadModule(NULL, 0, (PCSZ)"usbcalls", &g_hmod);
+    rc = RTErrConvertFromOS2(rc);
+    if (RT_SUCCESS(rc))
+    {
+        if (    (rc = DosQueryProcAddr(g_hmod, 0, (PCSZ)"UsbOpen", (PPFN)&g_pfnUsbOpen)) == NO_ERROR
+            &&  (rc = DosQueryProcAddr(g_hmod, 0, (PCSZ)"UsbClose", (PPFN)&g_pfnUsbClose)) == NO_ERROR
+            &&  (rc = DosQueryProcAddr(g_hmod, 0, (PCSZ)"UsbCtrlMessage", (PPFN)&g_pfnUsbCtrlMessage)) == NO_ERROR
+            &&  (rc = DosQueryProcAddr(g_hmod, 0, (PCSZ)"UsbBulkRead", (PPFN)&g_pfnUsbBulkRead)) == NO_ERROR
+            &&  (rc = DosQueryProcAddr(g_hmod, 0, (PCSZ)"UsbBulkWrite", (PPFN)&g_pfnUsbBulkWrite)) == NO_ERROR
+           )
+        {
+
+            return VINF_SUCCESS;
+        }
+
+        g_pfnUsbOpen = NULL;
+        g_pfnUsbClose = NULL;
+        g_pfnUsbCtrlMessage = NULL;
+        g_pfnUsbBulkRead = NULL;
+        g_pfnUsbBulkWrite = NULL;
+        DosFreeModule(g_hmod);
+    }
+
+    g_hmod = NULLHANDLE;
+    return rc;
+}
+#endif
+
+
+
+/**
+ * Allocates a OS/2 URB request structure.
+ * @returns Pointer to an active URB request.
+ * @returns NULL on failure.
+ * @param   pProxyDev       The proxy device instance.
+ */
+static PUSBPROXYURBOS2 usbProxyOs2UrbAlloc(PUSBPROXYDEV pProxyDev)
+{
+    PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)pProxyDev->Backend.pv;
+    PUSBPROXYURBOS2 pUrbOs2;
+
+    RTCritSectEnter(&pDevOs2->CritSect);
+
+    /*
+     * Try remove a linux URB from the free list, if none there allocate a new one.
+     */
+    pUrbOs2 = pDevOs2->pFreeHead;
+    if (pUrbOs2)
+        pDevOs2->pFreeHead = pUrbOs2->pNext;
+    else
+    {
+        RTCritSectLeave(&pDevOs2->CritSect);
+        pUrbOs2 = (PUSBPROXYURBOS2)RTMemAlloc(sizeof(*pUrbOs2));
+        if (!pUrbOs2)
+            return NULL;
+        RTCritSectEnter(&pDevOs2->CritSect);
+    }
+
+    /*
+     * Link it into the active list
+     */
+    pUrbOs2->pPrev = NULL;
+    pUrbOs2->pNext = pDevOs2->pInFlightHead;
+    if (pUrbOs2->pNext)
+        pUrbOs2->pNext->pPrev = pUrbOs2;
+    pDevOs2->pInFlightHead = pUrbOs2;
+
+    RTCritSectLeave(&pDevOs2->CritSect);
+    return pUrbOs2;
+}
+
+
+/**
+ * Frees a linux URB request structure.
+ *
+ * @param   pProxyDev       The proxy device instance.
+ * @param   pUrbOs2         The linux URB to free.
+ */
+static void usbProxyOs2UrbFree(PUSBPROXYDEV pProxyDev, PUSBPROXYURBOS2 pUrbOs2)
+{
+    PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)pProxyDev->Backend.pv;
+
+    RTCritSectEnter(&pDevOs2->CritSect);
+
+    /*
+     * Remove from the active list.
+     */
+    if (pUrbOs2->pNext)
+        pUrbOs2->pNext->pPrev = pUrbOs2->pPrev;
+    else if (pDevOs2->pTaxingTail == pUrbOs2)
+        pDevOs2->pTaxingTail = pUrbOs2->pPrev;
+    else if (pDevOs2->pTodoTail == pUrbOs2)
+        pDevOs2->pTodoTail = pUrbOs2->pPrev;
+
+    if (pUrbOs2->pPrev)
+        pUrbOs2->pPrev->pNext = pUrbOs2->pNext;
+    else if (pDevOs2->pTaxingHead == pUrbOs2)
+        pDevOs2->pTaxingHead  = pUrbOs2->pNext;
+    else if (pDevOs2->pInFlightHead == pUrbOs2)
+        pDevOs2->pInFlightHead  = pUrbOs2->pNext;
+    else if (pDevOs2->pTodoHead == pUrbOs2)
+        pDevOs2->pTodoHead  = pUrbOs2->pNext;
+
+    /*
+     * Link it into the free list.
+     */
+    pUrbOs2->pPrev = NULL;
+    pUrbOs2->pNext = pDevOs2->pFreeHead;
+    pDevOs2->pFreeHead = pUrbOs2;
+
+    RTCritSectLeave(&pDevOs2->CritSect);
+}
+
+
+/**
+ * Thread for executing the URBs asynchronously.
+ *
+ * @returns VINF_SUCCESS.
+ * @param   Thread      Thread handle (IPRT).
+ * @param   pvProxyDev  Pointer to the proxy device we're servicing.
+ */
+static DECLCALLBACK(int) usbProxyOs2AsyncThread(RTTHREAD Thread, void *pvProxyDev)
+{
+    PUSBPROXYDEV pProxyDev = (PUSBPROXYDEV)pvProxyDev;
+    PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)pProxyDev->Backend.pv;
+    size_t cbLow = 0;
+    void *pvLow = NULL;
+
+
+    /*
+     * The main loop.
+     *
+     * We're always in the critsect, except when waiting or submitting a URB.
+     */
+    int rc = RTCritSectEnter(&pDevOs2->CritSect); AssertRC(rc);
+
+    while (!pDevOs2->fTerminate)
+    {
+        /*
+         * Anything to do?
+         */
+        PUSBPROXYURBOS2 pUrbOs2 = pDevOs2->pTodoHead;
+        if (pUrbOs2)
+        {
+            pDevOs2->pTodoHead = pUrbOs2->pNext;
+            if (pUrbOs2->pNext)
+                pUrbOs2->pNext->pPrev = NULL;
+            else
+                pDevOs2->pTodoTail = NULL;
+
+            /*
+             * Move it to the in-flight list and submit it.
+             */
+            pUrbOs2->pPrev = NULL;
+            pUrbOs2->pNext = pDevOs2->pInFlightHead;
+            if (pDevOs2->pInFlightHead)
+                pDevOs2->pInFlightHead->pPrev = pUrbOs2;
+            //else
+            //    pDevOs2->pInFlightTail = pUrbOs2;
+            Log3(("%s: usbProxyOs2AsyncThread: pPickup\n", pUrbOs2->pUrb->pszDesc));
+
+            RTCritSectLeave(&pDevOs2->CritSect);
+
+            /*
+             * Process the URB.
+             */
+            PVUSBURB pUrb = pUrbOs2->pUrb;
+            uint8_t *pbData = &pUrb->abData[0];
+            ULONG cbData = pUrb->cbData;
+            if (    (uintptr_t)pbData >= 0x20000000
+                ||  ((uintptr_t)pbData & 0xfff))
+            {
+                if (cbData > cbLow)
+                {
+                    if (pvLow)
+                        DosFreeMem(pvLow);
+                    cbLow = (cbData + 0xffff) & ~0xffff;
+                    rc = DosAllocMem(&pvLow, cbLow, PAG_WRITE | PAG_READ | OBJ_TILE | PAG_COMMIT);
+                    if (rc)
+                    {
+                        cbLow = 0;
+                        pvLow = NULL;
+                    }
+                }
+                if (pvLow)
+                    pbData = (uint8_t *)memcpy(pvLow, pbData, cbData);
+            }
+
+            switch (pUrb->enmType)
+            {
+                case VUSBXFERTYPE_MSG:
+                {
+                    PVUSBSETUP pSetup = (PVUSBSETUP)&pbData[0];
+                    Log2(("%s: usbProxyOs2AsyncThread: CtlrMsg\n", pUrb->pszDesc));
+                    rc = g_pfnUsbCtrlMessage(pDevOs2->hDevice,  /** @todo this API must take a endpoint number! */
+                                             pSetup->bmRequestType,
+                                             pSetup->bRequest,
+                                             pSetup->wValue,
+                                             pSetup->wIndex,
+                                             pSetup->wLength,
+                                             pSetup + 1,
+                                             5*60000 /* min */);
+                    break;
+                }
+
+                case VUSBXFERTYPE_BULK:
+                {
+                    /* there is a thing with altnative interface thing here...  */
+
+                    if (pUrb->enmDir == VUSBDIRECTION_IN)
+                    {
+                        Log2(("%s: usbProxyOs2AsyncThread: BulkRead %d\n", pUrb->pszDesc, cbData));
+                        rc = g_pfnUsbBulkRead2(pDevOs2->hDevice, pUrb->EndPt | 0x80, 0, !pUrb->fShortNotOk, &cbData, pbData, 500);//5*6000);
+                    }
+                    else
+                    {
+                        Log2(("%s: usbProxyOs2AsyncThread: BulkWrite %d\n", pUrb->pszDesc, cbData));
+                        rc = g_pfnUsbBulkWrite2(pDevOs2->hDevice, pUrb->EndPt, 0, !pUrb->fShortNotOk, cbData, pbData, 500);//5*6000);
+                    }
+                    break;
+                }
+
+                case VUSBXFERTYPE_INTR:
+                case VUSBXFERTYPE_ISOC:
+                default:
+                    Log2(("%s: usbProxyOs2AsyncThread: Unsupported\n", pUrb->pszDesc));
+                    rc = USB_IORB_FAILED;
+                    break;
+            }
+
+            /* unbuffer */
+            if (pbData == pvLow)
+                memcpy(pUrb->abData, pbData, pUrb->cbData);
+
+            /* Convert rc to USB status code. */
+            int orc = rc;
+            if (!rc)
+                pUrb->enmStatus = VUSBSTATUS_OK;
+            else  if (rc == USB_ERROR_LESSTRANSFERED && !pUrb->fShortNotOk)
+            {
+                Assert(pUrb->cbData >= cbData);
+                pUrb->cbData = cbData;
+                pUrb->enmStatus = VUSBSTATUS_DATA_UNDERRUN;
+            }
+            else
+                pUrb->enmStatus = VUSBSTATUS_STALL;
+            Log2(("%s: usbProxyOs2AsyncThread: orc=%d enmStatus=%d cbData=%d \n", pUrb->pszDesc, orc, pUrb->enmStatus, pUrb->cbData)); NOREF(orc);
+
+            /*
+             * Retire it to the completed list
+             */
+            RTCritSectEnter(&pDevOs2->CritSect);
+
+            pUrbOs2->pNext = NULL;
+            pUrbOs2->pPrev = pDevOs2->pTaxingTail;
+            if (pDevOs2->pTaxingTail)
+                pDevOs2->pTaxingTail->pNext = pUrbOs2;
+            else
+                pDevOs2->pTaxingHead = pUrbOs2;
+            pDevOs2->pTaxingTail = pUrbOs2;
+
+            RTSemEventSignal(pDevOs2->EventSyncWait);
+            Log2(("%s: usbProxyOs2AsyncThread: orc=%d enmStatus=%d cbData=%d!\n", pUrb->pszDesc, orc, pUrb->enmStatus, pUrb->cbData)); NOREF(orc);
+        }
+        else
+        {
+            RTThreadUserReset(Thread);
+            RTCritSectLeave(&pDevOs2->CritSect);
+
+            /*
+             * Wait for something to do.
+             */
+            RTThreadUserWait(Thread, 30*1000 /* 30 sec */);
+
+            RTCritSectEnter(&pDevOs2->CritSect);
+        }
+    }
+
+    RTCritSectLeave(&pDevOs2->CritSect);
+    if (pvLow)
+        DosFreeMem(pvLow);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Opens the /proc/bus/usb/bus/addr file.
+ *
+ * @returns VBox status code.
+ * @param   pProxyDev       The device instance.
+ * @param   pszAddress      The path to the device.
+ */
+static int usbProxyOs2Open(PUSBPROXYDEV pProxyDev, const char *pszAddress)
+{
+    LogFlow(("usbProxyOs2Open: pProxyDev=%p pszAddress=%s\n", pProxyDev, pszAddress));
+    int rc;
+
+    /*
+     * Lazy init.
+     */
+#ifdef DYNAMIC_USBCALLS
+    if (!g_pfnUsbOpen)
+    {
+        rc = usbProxyOs2GlobalInit();
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+#else
+static bool g_fInitialized = false;
+    if (!g_fInitialized)
+    {
+        rc = InitUsbCalls();
+        if (rc != NO_ERROR)
+            return RTErrConvertFromOS2(rc);
+        g_fInitialized = true;
+    }
+#endif
+
+    /*
+     * Parse out the open parameters from the address string.
+     */
+    uint16_t idProduct = 0;
+    uint16_t idVendor = 0;
+    uint16_t bcdDevice = 0;
+    uint32_t iEnum = 0;
+    const char *psz = pszAddress;
+    do
+    {
+        const char chValue = *psz;
+        AssertReleaseReturn(psz[1] == '=', VERR_INTERNAL_ERROR);
+        uint64_t u64Value;
+        int rc = RTStrToUInt64Ex(psz + 2, (char **)&psz, 0, &u64Value);
+        AssertReleaseRCReturn(rc, rc);
+        AssertReleaseReturn(!*psz || *psz == ';', rc);
+        switch (chValue)
+        {
+            case 'p':   idProduct = (uint16_t)u64Value; break;
+            case 'v':   idVendor = (uint16_t)u64Value; break;
+            case 'r':   bcdDevice = (uint16_t)u64Value; break;
+            case 'e':   iEnum = (uint16_t)u64Value; break;
+            default:
+                AssertReleaseMsgFailedReturn(("chValue=%#x\n", chValue), VERR_INTERNAL_ERROR);
+        }
+        if (*psz == ';')
+            psz++;
+    } while (*psz);
+
+
+    /*
+     * Try open (acquire) it.
+     */
+    USBHANDLE hDevice = 0;
+    int urc = rc = g_pfnUsbOpen(&hDevice, idVendor, idProduct, bcdDevice, iEnum);
+    if (!rc)
+    {
+        /*
+         * Allocate and initialize the OS/2 backend data.
+         */
+        PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)RTMemAllocZ(sizeof(*pDevOs2));
+        if (pDevOs2)
+        {
+            pDevOs2->hDevice = hDevice;
+            pDevOs2->fTerminate = false;
+            rc = RTCritSectInit(&pDevOs2->CritSect);
+            if (RT_SUCCESS(rc))
+            {
+                rc = RTSemEventCreate(&pDevOs2->EventSyncWait);
+                if (RT_SUCCESS(rc))
+                {
+                    pProxyDev->Backend.pv = pDevOs2;
+
+                    /** @todo
+                     * Determine the active configuration.
+                     */
+                    //pProxyDev->cIgnoreSetConfigs = 1;
+                    //pProxyDev->iActiveCfg = 1;
+                    pProxyDev->cIgnoreSetConfigs = 0;
+                    pProxyDev->iActiveCfg = -1;
+
+                    /*
+                     * Create the async worker thread and we're done.
+                     */
+                    rc = RTThreadCreate(&pDevOs2->Thread, usbProxyOs2AsyncThread, pProxyDev, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "usbproxy");
+                    if (RT_SUCCESS(rc))
+                    {
+                        LogFlow(("usbProxyOs2Open(%p, %s): returns successfully - iActiveCfg=%d\n",
+                                 pProxyDev, pszAddress, pProxyDev->iActiveCfg));
+                        return VINF_SUCCESS;
+                    }
+
+                    /* failure */
+                    RTSemEventDestroy(pDevOs2->EventSyncWait);
+                }
+                RTCritSectDelete(&pDevOs2->CritSect);
+            }
+            RTMemFree(pDevOs2);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+        g_pfnUsbClose(hDevice);
+    }
+    else
+        rc = VERR_VUSB_USBFS_PERMISSION; /** @todo fix me */
+
+    Log(("usbProxyOs2Open(%p, %s) failed, rc=%Rrc! urc=%d\n", pProxyDev, pszAddress, rc, urc)); NOREF(urc);
+    pProxyDev->Backend.pv = NULL;
+
+    NOREF(pvBackend);
+    return rc;
+}
+
+
+/**
+ * Closes the proxy device.
+ */
+static void usbProxyOs2Close(PUSBPROXYDEV pProxyDev)
+{
+    LogFlow(("usbProxyOs2Close: pProxyDev=%s\n", pProxyDev->pUsbIns->pszName));
+    PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)pProxyDev->Backend.pv;
+    Assert(pDevOs2);
+    if (!pDevOs2)
+        return;
+
+    /*
+     * Tell the thread to terminate.
+     */
+    ASMAtomicXchgBool(&pDevOs2->fTerminate, true);
+    int rc = RTThreadUserSignal(pDevOs2->Thread); AssertRC(rc);
+    rc = RTThreadWait(pDevOs2->Thread, 60*1000 /* 1 min */, NULL); AssertRC(rc);
+
+    /*
+     * Now we can free all the resources and close the device.
+     */
+    RTCritSectDelete(&pDevOs2->CritSect);
+    RTSemEventDestroy(pDevOs2->EventSyncWait);
+
+    Assert(!pDevOs2->pInFlightHead);
+    Assert(!pDevOs2->pTodoHead);
+    Assert(!pDevOs2->pTodoTail);
+    Assert(!pDevOs2->pTaxingHead);
+    Assert(!pDevOs2->pTaxingTail);
+
+    PUSBPROXYURBOS2 pUrbOs2;
+    while ((pUrbOs2 = pDevOs2->pFreeHead) != NULL)
+    {
+        pDevOs2->pFreeHead = pUrbOs2->pNext;
+        RTMemFree(pUrbOs2);
+    }
+
+    g_pfnUsbClose(pDevOs2->hDevice);
+    pDevOs2->hDevice = 0;
+
+    RTMemFree(pDevOs2);
+    pProxyDev->Backend.pv = NULL;
+    LogFlow(("usbProxyOs2Close: returns\n"));
+}
+
+
+/** @interface_method_impl{USBPROXYBACK,pfnReset} */
+static int usbProxyOs2Reset(PUSBPROXYDEV pProxyDev, bool fResetOnLinux)
+{
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * SET_CONFIGURATION.
+ *
+ * The caller makes sure that it's not called first time after open or reset
+ * with the active interface.
+ *
+ * @returns success indicator.
+ * @param   pProxyDev       The device instance data.
+ * @param   iCfg            The configuration to set.
+ */
+static int usbProxyOs2SetConfig(PUSBPROXYDEV pProxyDev, int iCfg)
+{
+    PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)pProxyDev->Backend.pv;
+    LogFlow(("usbProxyOs2SetConfig: pProxyDev=%s cfg=%#x\n",
+             pProxyDev->pUsbIns->pszName, iCfg));
+
+    /*
+     * This is sync - bad.
+     */
+    int rc = g_pfnUsbCtrlMessage(pDevOs2->hDevice,
+                                 0x00,       /* bmRequestType - ?? */
+                                 0x09,       /* bRequest      - ?? */
+                                 iCfg,       /* wValue        - configuration */
+                                 0,          /* wIndex*/
+                                 0,          /* wLength */
+                                 NULL,       /* pvData  */
+                                 50          /* Timeout (ms) */);
+    if (rc)
+        LogFlow(("usbProxyOs2SetConfig: pProxyDev=%s cfg=%#X -> rc=%d\n", pProxyDev->pUsbIns->pszName, iCfg, rc));
+    return rc == 0;
+}
+
+
+/**
+ * Claims an interface.
+ * @returns success indicator.
+ */
+static int usbProxyOs2ClaimInterface(PUSBPROXYDEV pProxyDev, int iIf)
+{
+    LogFlow(("usbProxyOs2ClaimInterface: pProxyDev=%s ifnum=%#x\n", pProxyDev->pUsbIns->pszName, iIf));
+    return true;
+}
+
+
+/**
+ * Releases an interface.
+ * @returns success indicator.
+ */
+static int usbProxyOs2ReleaseInterface(PUSBPROXYDEV pProxyDev, int iIf)
+{
+    LogFlow(("usbProxyOs2ReleaseInterface: pProxyDev=%s ifnum=%#x\n", pProxyDev->pUsbIns->pszName, iIf));
+    return true;
+}
+
+
+/**
+ * SET_INTERFACE.
+ *
+ * @returns success indicator.
+ */
+static int usbProxyOs2SetInterface(PUSBPROXYDEV pProxyDev, int iIf, int iAlt)
+{
+    LogFlow(("usbProxyOs2SetInterface: pProxyDev=%p iIf=%#x iAlt=%#x\n", pProxyDev, iIf, iAlt));
+    return true;
+}
+
+
+/**
+ * Clears the halted endpoint 'EndPt'.
+ */
+static bool usbProxyOs2ClearHaltedEp(PUSBPROXYDEV pProxyDev, unsigned int EndPt)
+{
+    PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)pProxyDev->Backend.pv;
+    LogFlow(("usbProxyOs2ClearHaltedEp: pProxyDev=%s EndPt=%x\n", pProxyDev->pUsbIns->pszName, EndPt));
+
+    /*
+     * This is sync - bad.
+     */
+    int rc = g_pfnUsbCtrlMessage(pDevOs2->hDevice,
+                                 0x02,       /* bmRequestType - ?? */
+                                 0x01,       /* bRequest      - ?? */
+                                 0,          /* wValue        - endpoint halt */
+                                 EndPt,      /* wIndex        - endpoint # */
+                                 0,          /* wLength */
+                                 NULL,       /* pvData  */
+                                 50          /* Timeout (ms) */);
+    if (rc)
+        LogFlow(("usbProxyOs2ClearHaltedEp: pProxyDev=%s EndPt=%u -> rc=%d\n", pProxyDev->pUsbIns->pszName, EndPt, rc));
+    return rc == 0;
+}
+
+
+/**
+ * @interface_method_impl{USBPROXYBACK,pfnUrbQueue}
+ */
+static int usbProxyOs2UrbQueue(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
+{
+    PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)pProxyDev->Backend.pv;
+    LogFlow(("usbProxyOs2UrbQueue: pProxyDev=%s pUrb=%p EndPt=%d cbData=%d\n",
+             pProxyDev->pUsbIns->pszName, pUrb, pUrb->EndPt, pUrb->cbData));
+
+    /*
+     * Quickly validate the input.
+     */
+    switch (pUrb->enmDir)
+    {
+        case VUSBDIRECTION_IN:
+        case VUSBDIRECTION_OUT:
+            break;
+        default:
+            AssertMsgFailed(("usbProxyOs2UrbQueue: Invalid direction %d\n", pUrb->enmDir));
+            return false;
+    }
+
+    switch (pUrb->enmType)
+    {
+        case VUSBXFERTYPE_MSG:
+            break;
+        case VUSBXFERTYPE_BULK:
+            break;
+/// @todo        case VUSBXFERTYPE_INTR:
+//            break;
+//        case VUSBXFERTYPE_ISOC:
+//            break;
+        default:
+            return false;
+    }
+
+    /*
+     * Allocate an OS/2 urb tracking structure, initialize it,
+     * add it to the todo list, and wake up the async thread.
+     */
+    PUSBPROXYURBOS2 pUrbOs2 = usbProxyOs2UrbAlloc(pProxyDev);
+    if (!pUrbOs2)
+        return false;
+
+    pUrbOs2->pUrb = pUrb;
+
+    RTCritSectEnter(&pDevOs2->CritSect);
+
+    pUrbOs2->pNext = NULL;
+    pUrbOs2->pPrev = pDevOs2->pTodoTail;
+    if (pDevOs2->pTodoTail)
+        pDevOs2->pTodoTail->pNext = pUrbOs2;
+    else
+        pDevOs2->pTodoHead = pUrbOs2;
+    pDevOs2->pTodoTail = pUrbOs2;
+
+    RTCritSectLeave(&pDevOs2->CritSect);
+
+    RTThreadUserSignal(pDevOs2->Thread);
+    return true;
+}
+
+
+/**
+ * Reap URBs in-flight on a device.
+ *
+ * @returns Pointer to a completed URB.
+ * @returns NULL if no URB was completed.
+ * @param   pProxyDev   The device.
+ * @param   cMillies    Number of milliseconds to wait. Use 0 to not wait at all.
+ */
+static PVUSBURB usbProxyOs2UrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
+{
+    PVUSBURB pUrb = NULL;
+    PUSBPROXYDEVOS2 pDevOs2 = (PUSBPROXYDEVOS2)pProxyDev->Backend.pv;
+
+    RTCritSectEnter(&pDevOs2->CritSect);
+    for (;;)
+    {
+        /*
+         * Any URBs pending delivery?
+         */
+        PUSBPROXYURBOS2 pUrbOs2 = pDevOs2->pTaxingHead;
+        if (pUrbOs2)
+        {
+            pUrb = pUrbOs2->pUrb;
+            usbProxyOs2UrbFree(pProxyDev, pUrbOs2);
+            break;
+        }
+
+        /*
+         * Block for something to completed, if requested and sensible.
+         */
+        if (!cMillies)
+            break;
+        if (    !pDevOs2->pInFlightHead
+            &&  !pDevOs2->pTodoHead)
+            break;
+
+        RTCritSectLeave(&pDevOs2->CritSect);
+
+        int rc = RTSemEventWait(pDevOs2->EventSyncWait, cMillies);
+        Assert(RT_SUCCESS(rc) || rc == VERR_TIMEOUT); NOREF(rc);
+        cMillies = 0;
+
+        RTCritSectEnter(&pDevOs2->CritSect);
+    }
+    RTCritSectLeave(&pDevOs2->CritSect);
+
+    LogFlow(("usbProxyOs2UrbReap: dev=%s returns %p\n", pProxyDev->pUsbIns->pszName, pUrb));
+    return pUrb;
+}
+
+
+/**
+ * Cancels the URB.
+ * The URB requires reaping, so we don't change its state.
+ */
+static void usbProxyOs2UrbCancel(PVUSBURB pUrb)
+{
+#if 0
+    PUSBPROXYDEV pProxyDev = (PUSBPROXYDEV)pUrb->pDev;
+    PUSBPROXYURBOS2 pUrbOs2 = (PUSBPROXYURBOS2)pUrb->Dev.pvProxyUrb;
+    if (pUrbOs2->pSplitHead)
+    {
+        /* split */
+        Assert(pUrbOs2 == pUrbOs2->pSplitHead);
+        for (PUSBPROXYURBOS2 pCur = pUrbOs2; pCur; pCur = pCur->pSplitNext)
+        {
+            if (pCur->fSplitElementReaped)
+                continue;
+            if (    !usbProxyOs2DoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pCur->KUrb, true, UINT32_MAX)
+                ||  errno == ENOENT)
+                continue;
+            if (errno == ENODEV)
+                break;
+            Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%s!!! (split)\n",
+                 pUrb, errno, pProxyDev->pUsbIns->pszName));
+        }
+    }
+    else
+    {
+        /* unsplit */
+        if (    usbProxyOs2DoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbOs2->KUrb, true, UINT32_MAX)
+            &&  errno != ENODEV /* deal with elsewhere. */
+            &&  errno != ENOENT)
+            Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%s!!!\n",
+                 pUrb, errno, pProxyDev->pUsbIns->pszName));
+    }
+#endif
+}
+
+
+/**
+ * The Linux USB Proxy Backend.
+ */
+extern const USBPROXYBACK g_USBProxyDeviceHost =
+{
+    "host",
+    usbProxyOs2Open,
+    NULL,
+    usbProxyOs2Close,
+    usbProxyOs2Reset,
+    usbProxyOs2SetConfig,
+    usbProxyOs2ClaimInterface,
+    usbProxyOs2ReleaseInterface,
+    usbProxyOs2SetInterface,
+    usbProxyOs2ClearHaltedEp,
+    usbProxyOs2UrbQueue,
+    usbProxyOs2UrbCancel,
+    usbProxyOs2UrbReap,
+    0
+};
+