USBProxyDevice-linux.cpp revision 0aefc1b31a411a6cdfa560b5d95d96b47f6fd9e4
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * USB device proxy - the Linux backend.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Copyright (C) 2006-2011 Oracle Corporation
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * available from http://www.virtualbox.org. This file is free software;
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * you can redistribute it and/or modify it under the terms of the GNU
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * General Public License (GPL) as published by the Free Software
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync/*******************************************************************************
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync* Defined Constants And Macros *
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync*******************************************************************************/
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync/** Define NO_PORT_RESET to skip the slow and broken linux port reset.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Resetting will break PalmOne. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync/** Define NO_LOGICAL_RECONNECT to skip the broken logical reconnect handling. */
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync/*******************************************************************************
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync* Header Files *
2f0d866e126dd288169fed591c259c1c6b4016e5vboxsync*******************************************************************************/
e95a7aab825fd803ca1f09d072d74fe1bedfbadbvboxsync * Backlevel 2.4 headers doesn't have these two defines.
e95a7aab825fd803ca1f09d072d74fe1bedfbadbvboxsync * They were added some time between 2.4.21 and 2.4.26, probably in 2.4.23.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync# define USBDEVFS_URB_SHORT_NOT_OK 0 /* rhel3 doesn't have this. darn! */
63787aca0a2a16ec959a5294148726ccf898ddf1vboxsync/* FedoraCore 4 does not have the bit defined by default. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync# define RTCRITSECT void *
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsyncstatic inline int rtcsNoop() { return VINF_SUCCESS; }
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync#if defined(NO_PORT_RESET) && !defined(NO_LOGICAL_RECONNECT)
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync/*******************************************************************************
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync* Structures and Typedefs *
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync*******************************************************************************/
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Wrapper around the linux urb request structure.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * This is required to track in-flight and landed URBs.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /** The kernel URB data */
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /** Space filler for the isochronous packets. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync struct usbdevfs_iso_packet_desc aIsocPktsDonUseTheseUseTheOnesInKUrb[8];
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /** The millisecond timestamp when this URB was submitted. */
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /** Pointer to the next linux URB. */
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /** Pointer to the previous linux URB. */
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /** If we've split the VUSBURB up into multiple linux URBs, this is points to the head. */
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /** The next linux URB if split up. */
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /** Whether it has timed out and should be shot down on the next failing reap call. */
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /** Indicates that this URB has been canceled by timeout and should return an CRC error. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /** Don't report these back. */
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /** This split element is reaped. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /** Size to transfer in remaining fragments of a split URB */
2f0d866e126dd288169fed591c259c1c6b4016e5vboxsync * Data for the linux usb proxy backend.
c060166f65b9dd2f1ed53e6e4cffdad948e01722vboxsync /** The open file. */
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /** Critical section protecting the two lists. */
c060166f65b9dd2f1ed53e6e4cffdad948e01722vboxsync /** The list of free linux URBs. Singly linked. */
c060166f65b9dd2f1ed53e6e4cffdad948e01722vboxsync /** The list of active linux URBs. Doubly linked.
c060166f65b9dd2f1ed53e6e4cffdad948e01722vboxsync * We must maintain this so we can properly reap URBs of a detached device.
c060166f65b9dd2f1ed53e6e4cffdad948e01722vboxsync * Only the split head will appear in this list. */
c060166f65b9dd2f1ed53e6e4cffdad948e01722vboxsync /** The list of landed linux URBs. Doubly linked.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Only the split head will appear in this list. */
c060166f65b9dd2f1ed53e6e4cffdad948e01722vboxsync /** The tail of the landed linux URBs. */
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync /** Are we using sysfs to find the active configuration? */
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync /** Pipe handle for waiking up - writing end. */
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync /** Pipe handle for waiking up - reading end. */
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync /** The device node/sysfs path of the device.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Used to figure out the configuration after a reset. */
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync/*******************************************************************************
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync* Internal Functions *
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync*******************************************************************************/
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsyncstatic int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, unsigned long iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsyncstatic void usbProxLinuxUrbUnplugged(PUSBPROXYDEV pProxyDev);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsyncstatic void usbProxyLinuxSetConnected(PUSBPROXYDEV pProyxDev, int iIf, bool fConnect, bool fQuiet);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsyncstatic PUSBPROXYURBLNX usbProxyLinuxUrbAlloc(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pSplitHead);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsyncstatic void usbProxyLinuxUrbFree(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsyncstatic void usbProxyLinuxUrbFreeSplitList(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx);
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsyncstatic int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg);
2f0d866e126dd288169fed591c259c1c6b4016e5vboxsync * Wrapper for the ioctl call.
2f0d866e126dd288169fed591c259c1c6b4016e5vboxsync * This wrapper will repeat the call if we get an EINTR or EAGAIN. It can also
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * handle ENODEV (detached device) errors.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @returns whatever ioctl returns.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @param pProxyDev The proxy device.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param iCmd The ioctl command / function.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pvArg The ioctl argument / data.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @param fHandleNoDev Whether to handle ENODEV.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param cTries The number of retries. Use UINT32_MAX for (kind of) indefinite retries.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @internal
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsyncstatic int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, unsigned long iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries)
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync rc = ioctl(RTFileToNative(pDevLnx->hFile), iCmd, pvArg);
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync Log(("usb-linux: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync } while (cTries-- > 0);
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * The device has been unplugged.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Cancel all in-flight URBs and put them up for reaping.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsyncstatic void usbProxLinuxUrbUnplugged(PUSBPROXYDEV pProxyDev)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Shoot down all flying URBs.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_DISCARDURB, &pCur->KUrb); /* not sure if this is required.. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* insert into the taxing list. */
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /* Append the URBs we shot down to the taxing queue. */
8287c906b9b1d215824d4cdf6c1eaf40681ebfa8vboxsync pDevLnx->pTaxingTail = pDevLnx->pTaxingHead = pUrbTaxing;
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Set the connect state seen by kernel drivers
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @internal
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsyncstatic void usbProxyLinuxSetConnected(PUSBPROXYDEV pProxyDev, int iIf, bool fConnect, bool fQuiet)
7c48fdac0546978ed14617c8096734ce2d18c8e5vboxsync LogFlow(("usbProxyLinuxSetConnected: pProxyDev=%s iIf=%#x fConnect=%s\n",
7c48fdac0546978ed14617c8096734ce2d18c8e5vboxsync usbProxyGetName(pProxyDev), iIf, fConnect ? "true" : "false"));
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync IoCtl.ioctl_code = fConnect ? USBDEVFS_CONNECT : USBDEVFS_DISCONNECT;
7c48fdac0546978ed14617c8096734ce2d18c8e5vboxsync if ( usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_IOCTL, &IoCtl, true, UINT32_MAX)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Log(("usbProxyLinuxSetConnected: failure, errno=%d. pProxyDev=%s\n",
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Allocates a linux URB request structure.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @returns Pointer to an active URB request.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @returns NULL on failure.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pProxyDev The proxy device instance.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pSplitHead The split list head if allocating for a split list.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsyncstatic PUSBPROXYURBLNX usbProxyLinuxUrbAlloc(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pSplitHead)
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Try remove a linux URB from the free list, if none there allocate a new one.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync pUrbLnx = (PUSBPROXYURBLNX)RTMemAlloc(sizeof(*pUrbLnx));
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * Link it into the active list
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync pUrbLnx->pPrev = pUrbLnx->pNext = (PUSBPROXYURBLNX)0xdead;
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Frees a linux URB request structure.
9fe808d44daf9a34cd07713c0c254719e5e8d4f7vboxsync * @param pProxyDev The proxy device instance.
9fe808d44daf9a34cd07713c0c254719e5e8d4f7vboxsync * @param pUrbLnx The linux URB to free.
9fe808d44daf9a34cd07713c0c254719e5e8d4f7vboxsyncstatic void usbProxyLinuxUrbFree(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx)
9fe808d44daf9a34cd07713c0c254719e5e8d4f7vboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
9674ed871d32468dd791ad601151f46d2e843350vboxsync * Remove from the active list.
9674ed871d32468dd791ad601151f46d2e843350vboxsync * Link it into the free list.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Frees split list of a linux URB request structure.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pProxyDev The proxy device instance.
7c48fdac0546978ed14617c8096734ce2d18c8e5vboxsync * @param pUrbLnx A linux URB to in the split list to be freed.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsyncstatic void usbProxyLinuxUrbFreeSplitList(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx)
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * This finds the device in the /proc/bus/usb/bus/addr file and finds
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * the config with an asterix.
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * @returns The Cfg#.
9674ed871d32468dd791ad601151f46d2e843350vboxsync * @returns -1 if no active config.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pszDevNode The path to the device. We infere the location of
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * the devices file, which bus and device number we're
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * looking for.
3b1aa24d99d0f9cc157cf72ca76444b2feca3277vboxsync * @param iFirstCfg The first configuration. (optional)
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync * @internal
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsyncstatic int usbProxyLinuxFindActiveConfigUsbfs(PUSBPROXYDEV pProxyDev, const char *pszDevNode, int *piFirstCfg)
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Set return defaults.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Parse the usbfs device node path and turn it into a path to the "devices" file,
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * picking up the device number and bus along the way.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync char *pszDevices = (char *)RTMemDupEx(pszDevNode, cchDevNode, sizeof("devices"));
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync /* the device number */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync int rc = RTStrToUInt32Ex(psz + 1, NULL, 10, &uDev);
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync /* the bus number */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Open and scan the devices file.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * We're ASSUMING that each device starts off with a 'T:' line.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync while (RT_SUCCESS(RTStrmGetLine(pFile, szLine, sizeof(szLine))))
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync /* we're only interested in 'T:' lines. */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync /* Skip ahead to 'Bus' and compare */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync psz = RTStrStripL(psz + 2); Assert(!strncmp(psz, RT_STR_TUPLE("Bus=")));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* Skip ahead to 'Dev#' and compare */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * Ok, we've found the device.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * Scan until we find a selected configuration, the next device, or EOF.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync while (RT_SUCCESS(RTStrmGetLine(pFile, szLine, sizeof(szLine))))
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* Get the 'Cfg#' value. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * This finds the active configuration from sysfs.
e95a7aab825fd803ca1f09d072d74fe1bedfbadbvboxsync * @returns The Cfg#.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * @returns -1 if no active config.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pszPath The sysfs path for the device.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param piFirstCfg The first configuration. (optional)
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * @internal
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsyncstatic int usbProxyLinuxFindActiveConfigSysfs(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync ? pProxyDev->paCfgDescs[0].Core.bConfigurationValue
648b0a0e189323afe4d836f1848f82c7dded0e58vboxsync return RTLinuxSysFsReadIntFile(10, "%s/bConfigurationValue", pszPath); /* returns -1 on failure */
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync#else /* !VBOX_USB_WITH_SYSFS */
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync#endif /* !VBOX_USB_WITH_SYSFS */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * This finds the active configuration.
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * @returns The Cfg#.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * @returns -1 if no active config.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pszPath The sysfs path for the device, or the usbfs device
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * node path.
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * @param iFirstCfg The first configuration. (optional)
36fbf6dcd3e6b2e5891456b730577ff0eb355c9fvboxsync * @internal
648b0a0e189323afe4d836f1848f82c7dded0e58vboxsyncstatic int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg)
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync return usbProxyLinuxFindActiveConfigSysfs(pProxyDev, pszPath, piFirstCfg);
973e7aa10bdb6c998d3b26b9f6f9d184d42fb4cevboxsync return usbProxyLinuxFindActiveConfigUsbfs(pProxyDev, pszPath, piFirstCfg);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * Extracts the Linux file descriptor associated with the kernel USB device.
7c48fdac0546978ed14617c8096734ce2d18c8e5vboxsync * This is used by rdesktop-vrdp for polling for events.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * @returns the FD, or asserts and returns -1 on error
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * @param pProxyDev The device instance
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsyncRTDECL(int) USBProxyDeviceLinuxGetFD(PUSBPROXYDEV pProxyDev)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * Opens the device file.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @returns VBox status code.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pProxyDev The device instance.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pszAddress If we are using usbfs, this is the path to the
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * device. If we are using sysfs, this is a string of
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * the form "sysfs:<sysfs path>//device:<device node>".
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * In the second case, the two paths are guaranteed
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * not to contain the substring "//".
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * @param pvBackend Backend specific pointer, unused for the linux backend.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsyncstatic DECLCALLBACK(int) usbProxyLinuxOpen(PUSBPROXYDEV pProxyDev, const char *pszAddress, void *pvBackend)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync LogFlow(("usbProxyLinuxOpen: pProxyDev=%p pszAddress=%s\n", pProxyDev, pszAddress));
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync const char *pszPath;
3b1aa24d99d0f9cc157cf72ca76444b2feca3277vboxsync * Are we using sysfs or usbfs?
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync fUsingSysfs = strncmp(pszAddress, RT_STR_TUPLE("sysfs:")) == 0;
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync LogRel(("usbProxyLinuxOpen: Invalid device address: '%s'\n", pszAddress));
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync#endif /* VBOX_USB_WITH_SYSFS */
648b0a0e189323afe4d836f1848f82c7dded0e58vboxsync * Try open the device node.
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync int rc = RTFileOpen(&hFile, pszDevNode, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
648b0a0e189323afe4d836f1848f82c7dded0e58vboxsync * Initialize the linux backend data.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync rc = RTPipeCreate(&pDevLnx->hPipeWakeupR, &pDevLnx->hPipeWakeupW, 0);
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync LogFlow(("usbProxyLinuxOpen(%p, %s): returns successfully File=%RTfile iActiveCfg=%d\n",
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync pProxyDev, pszAddress, pDevLnx->hFile, pProxyDev->iActiveCfg));
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync Log(("usbProxyLinuxOpen(%p, %s) failed, rc=%s!\n", pProxyDev, pszAddress,
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync * Claims all the interfaces and figures out the
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync * current configuration.
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync * @returns VINF_SUCCESS.
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync * @param pProxyDev The proxy device.
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsyncstatic DECLCALLBACK(int) usbProxyLinuxInit(PUSBPROXYDEV pProxyDev)
8a54ed337392872c7cfcfb96f173468bbbb0f7fcvboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Brute force rulez.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * usbProxyLinuxSetConnected check for masked interfaces.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync usbProxyLinuxSetConnected(pProxyDev, iIf, false, true);
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * Determine the active configuration.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync * If there isn't any active configuration, we will get EHOSTUNREACH (113) errors
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * when trying to read the device descriptors in usbProxyDevCreate. So, we'll make
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * the first one active (usually 1) then.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->pszPath, &iFirstCfg);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iFirstCfg, false, UINT32_MAX);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->pszPath, NULL);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Log(("usbProxyLinuxInit: No active config! Tried to set %d: iActiveCfg=%d\n", iFirstCfg, pProxyDev->iActiveCfg));
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Log(("usbProxyLinuxInit(%p): iActiveCfg=%d\n", pProxyDev, pProxyDev->iActiveCfg));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Closes the proxy device.
034f0367d3b0431c6346b1a3af3abb435ee50d4evboxsyncstatic DECLCALLBACK(void) usbProxyLinuxClose(PUSBPROXYDEV pProxyDev)
3614117c1132a61599e6190939e775cafe549411vboxsync LogFlow(("usbProxyLinuxClose: pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
3614117c1132a61599e6190939e775cafe549411vboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Try put the device in a state which linux can cope with before we release it.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Resetting it would be a nice start, although we must remember
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * that it might have been disconnected...
648b0a0e189323afe4d836f1848f82c7dded0e58vboxsync * Don't reset if we're masking interfaces or if construction failed.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync /* ASSUMES: thread == EMT */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync || !usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync /* Connect drivers. */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync usbProxyLinuxSetConnected(pProxyDev, iIf, true, true);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync LogRel(("USB: Successfully reset device pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
fe554d9c0e3a6de4ba221610ac95a44c7d288e01vboxsync LogRel(("USB: Reset failed, errno=%d, pProxyDev=%s.\n", errno, usbProxyGetName(pProxyDev)));
63e3a547845f7c31bb4e892a66684b560dc63611vboxsync Log(("USB: Reset failed, errno=%d (ENODEV), pProxyDev=%s.\n", errno, usbProxyGetName(pProxyDev)));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Now we can free all the resources and close the device.
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync if ( usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, false, UINT32_MAX)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync && usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pFree->KUrb, false, UINT32_MAX)
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync#if defined(NO_PORT_RESET) && !defined(NO_LOGICAL_RECONNECT)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Look for the logically reconnected device.
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * After 5 seconds we'll give up.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @returns VBox status code.
648b0a0e189323afe4d836f1848f82c7dded0e58vboxsync * @thread Reset thread or EMT.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsyncstatic int usb_reset_logical_reconnect(PUSBPROXYDEV pDev)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Log2(("usb_reset_logical_reconnect: pDev=%p:{.bBus=%#x, .bDevNum=%#x, .idVendor=%#x, .idProduct=%#x, .bcdDevice=%#x, .u64SerialHash=%#llx .bDevNumParent=%#x .bPort=%#x .bLevel=%#x}\n",
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync pDev, pDev->Info.bBus, pDev->Info.bDevNum, pDev->Info.idVendor, pDev->Info.idProduct, pDev->Info.bcdDevice,
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync pDev->Info.u64SerialHash, pDev->Info.bDevNumParent, pDev->Info.bPort, pDev->Info.bLevel));
e562a8bb17c0dfa1c316708e085a3a92fcc80521vboxsync /* First, let hubd get a chance to logically reconnect the device. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Search for the new device address.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Loop until found or 5seconds have elapsed.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Since this is kernel ABI we don't need to be too fussy about
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * the parsing.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync AssertMsgFailed(("usb_reset_logical_reconnect: Line to long!!\n"));
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync switch ( buf[0] ) {
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /* Check if we've got enough for a device. */
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync Log2(("usb_reset_logical_reconnect: {.bBus=%#x, .bDevNum=%#x, .idVendor=%#x, .idProduct=%#x, .bcdDevice=%#x, .u64SerialHash=%#llx, .bDevNumParent=%#x, .bPort=%#x, .bLevel=%#x}\n",
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync id.bBus, id.bDevNum, id.idVendor, id.idProduct, id.bcdDevice, id.u64SerialHash, id.bDevNumParent, id.bPort, id.bLevel));
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /* restart */
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /*T: Bus=04 Lev=02 Prnt=02 Port=00 Cnt=01 Dev#= 3 Spd=1.5 MxCh= 0*/
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /* Skip past "S:" and then the whitespace */
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /* If it is a serial number string, skip past
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * "SerialNumber="
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Check last.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* close the existing file descriptor. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* open stuff at the new address. */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Wait for a while and then check the file again.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync break; /* done */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync RTThreadSleep(32); /* paranoia: don't eat cpu on failure */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync } /* for loop */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync#endif /* !NO_PORT_RESET && !NO_LOGICAL_RECONNECT */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Reset a device.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @returns VBox status code.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @param pDev The device to reset.
23603ed361f22874964e3a841add2c58ec2bb1eavboxsyncstatic DECLCALLBACK(int) usbProxyLinuxReset(PUSBPROXYDEV pProxyDev, bool fResetOnLinux)
23603ed361f22874964e3a841add2c58ec2bb1eavboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
9b7ab382b3f9667e8847020e1e58f7143c4d2334vboxsync * Specific device resets are NOPs.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Root hub resets that affects all devices are executed.
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * The reasoning is that when a root hub reset is done, the guest shouldn't
9b7ab382b3f9667e8847020e1e58f7143c4d2334vboxsync * will have to re enumerate the devices after doing this kind of reset.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * So, it doesn't really matter if a device is 'logically disconnected'.
af5224eb6b6676bc892a3f5abeb21f602547d31cvboxsync LogFlow(("usbProxyLinuxReset: pProxyDev=%s - NO_PORT_RESET\n", usbProxyGetName(pProxyDev)));
23603ed361f22874964e3a841add2c58ec2bb1eavboxsync LogFlow(("usbProxyLinuxReset: pProxyDev=%s - Real Reset!\n", usbProxyGetName(pProxyDev)));
23603ed361f22874964e3a841add2c58ec2bb1eavboxsync if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /* find the active config - damn annoying. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->pszPath, NULL);
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync LogFlow(("usbProxyLinuxReset: returns successfully iActiveCfg=%d\n", pProxyDev->iActiveCfg));
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync#else /* !NO_PORT_RESET */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * This is the alternative, we will always reset when asked to do so.
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync * The problem we're facing here is that on reset failure linux will do
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync * a 'logical reconnect' on the device. This will invalidate the current
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync * handle and we'll have to reopen the device. This is problematic to say
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync * the least, especially since it happens pretty often.
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync LogFlow(("usbProxyLinuxReset: pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
90a3b100d6364b9956ab5155b48b91e2d930f4a4vboxsync if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * This usually happens because of a 'logical disconnection'.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * So, we're in for a real treat from our excellent OS now...
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync LogFlow(("usbProxyLinuxReset: returns success (after recovering disconnected device!)\n"));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync# endif /* NO_LOGICAL_RECONNECT */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync LogFlow(("usbProxyLinuxReset: returns success\n"));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync#endif /* !NO_PORT_RESET */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * SET_CONFIGURATION.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * The caller makes sure that it's not called first time after open or reset
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * with the active interface.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * @returns success indicator.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * @param pProxyDev The device instance data.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * @param iCfg The configuration to set.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsyncstatic DECLCALLBACK(int) usbProxyLinuxSetConfig(PUSBPROXYDEV pProxyDev, int iCfg)
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync LogFlow(("usbProxyLinuxSetConfig: pProxyDev=%s cfg=%#x\n",
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iCfg, true, UINT32_MAX))
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync Log(("usb-linux: Set configuration. errno=%d\n", errno));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Claims an interface.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * @returns success indicator.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsyncstatic DECLCALLBACK(int) usbProxyLinuxClaimInterface(PUSBPROXYDEV pProxyDev, int iIf)
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync LogFlow(("usbProxyLinuxClaimInterface: pProxyDev=%s ifnum=%#x\n", usbProxyGetName(pProxyDev), iIf));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync usbProxyLinuxSetConnected(pProxyDev, iIf, false, false);
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_CLAIMINTERFACE, &iIf, true, UINT32_MAX))
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync Log(("usb-linux: Claim interface. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Releases an interface.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * @returns success indicator.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsyncstatic int usbProxyLinuxReleaseInterface(PUSBPROXYDEV pProxyDev, int iIf)
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync LogFlow(("usbProxyLinuxReleaseInterface: pProxyDev=%s ifnum=%#x\n", usbProxyGetName(pProxyDev), iIf));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RELEASEINTERFACE, &iIf, true, UINT32_MAX))
63787aca0a2a16ec959a5294148726ccf898ddf1vboxsync Log(("usb-linux: Release interface, errno=%d. pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * SET_INTERFACE.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * @returns success indicator.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsyncstatic int usbProxyLinuxSetInterface(PUSBPROXYDEV pProxyDev, int iIf, int iAlt)
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync LogFlow(("usbProxyLinuxSetInterface: pProxyDev=%p iIf=%#x iAlt=%#x\n", pProxyDev, iIf, iAlt));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETINTERFACE, &SetIf, true, UINT32_MAX))
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync Log(("usb-linux: Set interface, errno=%d. pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
63e3a547845f7c31bb4e892a66684b560dc63611vboxsync * Clears the halted endpoint 'EndPt'.
63e3a547845f7c31bb4e892a66684b560dc63611vboxsyncstatic int usbProxyLinuxClearHaltedEp(PUSBPROXYDEV pProxyDev, unsigned int EndPt)
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync LogFlow(("usbProxyLinuxClearHaltedEp: pProxyDev=%s EndPt=%u\n", usbProxyGetName(pProxyDev), EndPt));
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_CLEAR_HALT, &EndPt, true, UINT32_MAX))
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * Unfortunately this doesn't work on control pipes.
63e3a547845f7c31bb4e892a66684b560dc63611vboxsync * Windows doing this on the default endpoint and possibly other pipes too,
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync * so we'll feign success for ENOENT errors.
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%s ep=%d - IGNORED\n",
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%s ep=%d\n",
d5a801e98910a0c3c9c65cfc7cf8826f0b0b4450vboxsync * Setup packet byte-swapping routines.
63e3a547845f7c31bb4e892a66684b560dc63611vboxsyncstatic void usbProxyLinuxUrbSwapSetup(PVUSBSETUP pSetup)
63e3a547845f7c31bb4e892a66684b560dc63611vboxsync * Clean up after a failed URB submit.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsyncstatic void usbProxyLinuxCleanupFailedSubmit(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx, PUSBPROXYURBLNX pCur, PVUSBURB pUrb, bool *pfUnplugged)
d5a801e98910a0c3c9c65cfc7cf8826f0b0b4450vboxsync usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
d5a801e98910a0c3c9c65cfc7cf8826f0b0b4450vboxsync /* discard and reap later (walking with pUrbLnx). */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, false, UINT32_MAX))
f7f5cd7b1e530eb5636da51c974b48ae0c1775b3vboxsync LogRel(("USB: Failed to discard %p! errno=%d (pUrb=%p)\n", pUrbLnx->KUrb.usercontext, errno, pUrb)); /* serious! */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* free the unsubmitted ones. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* send unplug event if we failed with ENODEV originally. */
04cdb3815f28f5dbf0e7dffc7957fec59260e76fvboxsync * Submit one URB through the usbfs IOCTL interface, with
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @returns VBox status code.
8287c906b9b1d215824d4cdf6c1eaf40681ebfa8vboxsyncstatic int usbProxyLinuxSubmitURB(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pCur, PVUSBURB pUrb, bool *pfUnplugged)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
7c48fdac0546978ed14617c8096734ce2d18c8e5vboxsync unsigned cTries = 0;
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync while (ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_SUBMITURB, &pCur->KUrb))
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Log(("usbProxyLinuxSubmitURB: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Log(("usb-linux: Submit URB %p -> %d!!! type=%d ep=%#x buffer_length=%#x cTries=%d\n",
04cdb3815f28f5dbf0e7dffc7957fec59260e76fvboxsync pUrb, errno, pCur->KUrb.type, pCur->KUrb.endpoint, pCur->KUrb.buffer_length, cTries));
04cdb3815f28f5dbf0e7dffc7957fec59260e76fvboxsync if (errno != EBUSY && ++cTries < 3) /* this doesn't work for the floppy :/ */
63787aca0a2a16ec959a5294148726ccf898ddf1vboxsync/** The split size. 16K in known Linux kernel versions. */
8742e4a4ddb7b62d21d96d56dd1baf01c9f22cecvboxsync * Create a URB fragment of up to SPLIT_SIZE size and hook it
63787aca0a2a16ec959a5294148726ccf898ddf1vboxsync * into the list of fragments.
8742e4a4ddb7b62d21d96d56dd1baf01c9f22cecvboxsync * @returns pointer to newly allocated URB fragment or NULL.
8742e4a4ddb7b62d21d96d56dd1baf01c9f22cecvboxsyncstatic PUSBPROXYURBLNX usbProxyLinuxSplitURBFragment(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pHead, PUSBPROXYURBLNX pCur)
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync pNew = pCur->pSplitNext = usbProxyLinuxUrbAlloc(pProxyDev, pHead);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Assert(pHead->pNext != pNew); Assert(pHead->pPrev != pNew); Assert(pNew->pNext == pNew->pPrev);
fe554d9c0e3a6de4ba221610ac95a44c7d288e01vboxsync pNew->KUrb.buffer_length = RT_MIN(cbLeft, SPLIT_SIZE);
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * Try splitting up a VUSB URB into smaller URBs which the
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * linux kernel (usbfs) can deal with.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * NB: For ShortOK reads things get a little tricky - we don't
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * know how much data is going to arrive and not all the
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * fragment URBs might be filled. We can only safely set up one
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * URB at a time -> worse performance but correct behaviour.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @returns VBox status code.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @param pProxyDev The proxy device.
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * @param pUrbLnx The linux URB which was rejected because of being too big.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @param pUrb The VUSB URB.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsyncstatic int usbProxyLinuxUrbQueueSplit(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx, PVUSBURB pUrb)
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync * Split it up into SPLIT_SIZE sized blocks.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync const unsigned cKUrbs = (pUrb->cbData + SPLIT_SIZE - 1) / SPLIT_SIZE;
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync LogFlow(("usbProxyLinuxUrbQueueSplit: pUrb=%p cKUrbs=%d cbData=%d\n", pUrb, cKUrbs, pUrb->cbData));
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* the first one (already allocated) */
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync default: /* shut up gcc */
3ebd5757516d21eccdad25ddd456d2913c2fb215vboxsync case VUSBXFERTYPE_BULK: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_BULK; break;
fe554d9c0e3a6de4ba221610ac95a44c7d288e01vboxsync case VUSBXFERTYPE_INTR: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_INTERRUPT; break;
fe554d9c0e3a6de4ba221610ac95a44c7d288e01vboxsync case VUSBXFERTYPE_MSG: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_CONTROL; break;
fe554d9c0e3a6de4ba221610ac95a44c7d288e01vboxsync AssertMsgFailed(("We can't split isochronous URBs!\n"));
8287c906b9b1d215824d4cdf6c1eaf40681ebfa8vboxsync return VERR_INVALID_PARAMETER; /** @todo: Better status code. */
8287c906b9b1d215824d4cdf6c1eaf40681ebfa8vboxsync pUrbLnx->KUrb.flags = pUrb->fShortNotOk ? USBDEVFS_URB_SHORT_NOT_OK : 0; /* ISO_ASAP too? */
572f495840b063427930dbb6f5a81f3147286effvboxsync pUrbLnx->KUrb.buffer_length = RT_MIN(cbLeft, SPLIT_SIZE);
8287c906b9b1d215824d4cdf6c1eaf40681ebfa8vboxsync bool fUnplugged = false;
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync if (pUrb->enmDir == VUSBDIRECTION_IN && !pUrb->fShortNotOk)
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync /* Subsequent fragments will be queued only after the previous fragment is reaped
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsync * and only if necessary.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Log(("usb-linux: Large ShortOK read, only queuing first fragment.\n"));
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync Assert(pUrbLnx->cbSplitRemaining > 0 && pUrbLnx->cbSplitRemaining < 256 * _1K);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync rc = usbProxyLinuxSubmitURB(pProxyDev, pUrbLnx, pUrb, &fUnplugged);
b2bc8de1367ae24e1b27b53921d0b32ee3df7acdvboxsync /* the rest. */
9540eeb13face31ddc1c5f15338556fe46f18a77vboxsync unsigned i;
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync pCur = usbProxyLinuxSplitURBFragment(pProxyDev, pUrbLnx, pCur);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync /* Submit the blocks. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync for (i = 0; i < cKUrbs; i++, pCur = pCur->pSplitNext)
8287c906b9b1d215824d4cdf6c1eaf40681ebfa8vboxsync rc = usbProxyLinuxSubmitURB(pProxyDev, pCur, pUrb, &fUnplugged);
8287c906b9b1d215824d4cdf6c1eaf40681ebfa8vboxsync usbProxyLinuxCleanupFailedSubmit(pProxyDev, pUrbLnx, pCur, pUrb, &fUnplugged);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * @copydoc USBPROXYBACK::pfnUrbQueue
70fc9d0c972c749656d6fb2ffafcdeec3d8874ecvboxsyncstatic DECLCALLBACK(int) usbProxyLinuxUrbQueue(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync LogFlow(("usbProxyLinuxUrbQueue: pProxyDev=%s pUrb=%p EndPt=%d cbData=%d\n",
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync usbProxyGetName(pProxyDev), pUrb, pUrb->EndPt, pUrb->cbData));
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Allocate a linux urb.
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync PUSBPROXYURBLNX pUrbLnx = usbProxyLinuxUrbAlloc(pProxyDev, NULL);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync pUrbLnx->KUrb.endpoint = pUrb->EndPt | (pUrb->enmDir == VUSBDIRECTION_IN ? 0x80 : 0);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync pUrbLnx->KUrb.flags = pUrb->fShortNotOk ? USBDEVFS_URB_SHORT_NOT_OK : 0;
24ca3d27f14cf8a03b8448f6d0898110e915d46avboxsync usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync unsigned i;
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync pUrbLnx->KUrb.iso_frame_desc[i].length = pUrb->aIsocPkts[i].cb;
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync rc = VERR_INVALID_PARAMETER; /** @todo: better status code. */
016096e367cd20c3d3c3fd9a6650b55935c2e31dvboxsync * Submit it.
return rc;
return rc;
pCur;
unsigned cFailures = 0;
Log(("vusbProxyLinuxUrbDoTimeouts: pUrb=%p failed errno=%d (!!split!!)\n", pCur2->KUrb.usercontext, errno));
LogRel(("USB: Cancelled URB (%p) after %llums!!\n", pCur->KUrb.usercontext, (long long unsigned) u64MilliTS - pCur->u64SubmitTS));
else if (u64MilliTS - pCur->u64SubmitTS >= 200*1000 /* 200 sec (180 sec has been observed with XP) */)
* sitd_complete+itd_complete in ehci-sched.c, and qtd_copy_status in
* ehci-q.c.
switch (iStatus)
return VUSBSTATUS_OK;
case -EILSEQ:
return VUSBSTATUS_CRC;
return VUSBSTATUS_DATA_UNDERRUN;
case -EOVERFLOW:
return VUSBSTATUS_DATA_OVERRUN;
case -ETIME:
case -ENODEV:
return VUSBSTATUS_DNR;
case -EPIPE:
return VUSBSTATUS_STALL;
case -ESHUTDOWN:
return VUSBSTATUS_STALL;
return VUSBSTATUS_STALL;
return VUSBSTATUS_CRC;
if (pUrbLnx)
if (!pUrbLnx)
return NULL;
if (cMillies)
return NULL;
Log(("usb-linux: Reap URB - poll -> %d errno=%d pProxyDev=%s\n", rc, errno, usbProxyGetName(pProxyDev)));
return NULL;
return NULL;
/* for variable size URBs, we may need to queue more if the just-reaped URB was completely filled */
if (pUrbLnx->cbSplitRemaining && (pKUrb->actual_length == pKUrb->buffer_length) && !pUrbLnx->pSplitNext)
bool fUnplugged = false;
bool fSucceeded;
if (!pNew)
Log(("usb-linux: Allocating URB fragment failed. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
return NULL;
if (fUnplugged)
if (!fSucceeded)
return NULL;
if (!pUrbLnx)
if ( pUrb
unsigned i, off;
pUrb->aIsocPkts[i].enmStatus = vusbProxyLinuxStatusToVUsbStatus(pUrbLnx->KUrb.iso_frame_desc[i].status);
return pUrb;
return rc;
sizeof(USBPROXYDEVLNX),