Lines Matching refs:pDev
47 PVUSBDEV pDev;
93 static PCVUSBDESCCONFIGEX vusbDevFindCfgDesc(PVUSBDEV pDev, int iCfg)
98 for (unsigned i = 0; i < pDev->pDescCache->pDevice->bNumConfigurations; i++)
99 if (pDev->pDescCache->paConfigs[i].Core.bConfigurationValue == iCfg)
100 return &pDev->pDescCache->paConfigs[i];
104 static PVUSBINTERFACESTATE vusbDevFindIfState(PVUSBDEV pDev, int iIf)
106 for (unsigned i = 0; i < pDev->pCurCfgDesc->Core.bNumInterfaces; i++)
107 if (pDev->paIfStates[i].pIf->paSettings[0].Core.bInterfaceNumber == iIf)
108 return &pDev->paIfStates[i];
112 static PCVUSBDESCINTERFACEEX vusbDevFindAltIfDesc(PVUSBDEV pDev, PCVUSBINTERFACESTATE pIfState, int iAlt)
120 void vusbDevMapEndpoint(PVUSBDEV pDev, PCVUSBDESCENDPOINTEX pEndPtDesc)
123 PVUSBPIPE pPipe = &pDev->aPipes[i8Addr];
124 LogFlow(("vusbDevMapEndpoint: pDev=%p[%s] pEndPtDesc=%p{.bEndpointAddress=%#x, .bmAttributes=%#x} p=%p stage %s->SETUP\n",
125 pDev, pDev->pUsbIns->pszName, pEndPtDesc, pEndPtDesc->Core.bEndpointAddress, pEndPtDesc->Core.bmAttributes,
144 pPipe->hReadAhead = vusbReadAheadStart(pDev, pPipe);
160 static void unmap_endpoint(PVUSBDEV pDev, PCVUSBDESCENDPOINTEX pEndPtDesc)
163 PVUSBPIPE pPipe = &pDev->aPipes[EndPt];
164 LogFlow(("unmap_endpoint: pDev=%p[%s] pEndPtDesc=%p{.bEndpointAddress=%#x, .bmAttributes=%#x} p=%p stage %s->SETUP\n",
165 pDev, pDev->pUsbIns->pszName, pEndPtDesc, pEndPtDesc->Core.bEndpointAddress, pEndPtDesc->Core.bmAttributes,
200 static void map_interface(PVUSBDEV pDev, PCVUSBDESCINTERFACEEX pIfDesc)
202 LogFlow(("map_interface: pDev=%p[%s] pIfDesc=%p:{.iInterface=%d, .bAlternateSetting=%d}\n",
203 pDev, pDev->pUsbIns->pszName, pIfDesc, pIfDesc->Core.iInterface, pIfDesc->Core.bAlternateSetting));
211 vusbDevMapEndpoint(pDev, &pIfDesc->paEndpoints[i]);
240 bool vusbDevDoSelectConfig(PVUSBDEV pDev, PCVUSBDESCCONFIGEX pCfgDesc)
242 LogFlow(("vusbDevDoSelectConfig: pDev=%p[%s] pCfgDesc=%p:{.iConfiguration=%d}\n",
243 pDev, pDev->pUsbIns->pszName, pCfgDesc, pCfgDesc->Core.iConfiguration));
251 vusbDevResetPipeData(&pDev->aPipes[i]);
252 memset(pDev->paIfStates, 0, pCfgDesc->Core.bNumInterfaces * sizeof(pDev->paIfStates[0]));
263 pIfState = &pDev->paIfStates[i];
280 map_interface(pDev, pIfState->pCurIfDesc);
283 pDev->pCurCfgDesc = pCfgDesc;
286 pDev->u16Status |= (1 << VUSB_DEV_SELF_POWERED);
288 pDev->u16Status &= ~(1 << VUSB_DEV_SELF_POWERED);
297 static bool vusbDevStdReqSetConfig(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
303 Log(("vusb: error: %s: SET_CONFIGURATION - invalid request (dir) !!!\n", pDev->pUsbIns->pszName, iCfg));
311 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
314 LogFlow(("vusbDevStdReqSetConfig: %s: default dev state !!?\n", pDev->pUsbIns->pszName));
318 PCVUSBDESCCONFIGEX pNewCfgDesc = vusbDevFindCfgDesc(pDev, iCfg);
321 Log(("vusb: error: %s: config %i not found !!!\n", pDev->pUsbIns->pszName, iCfg));
326 vusbDevSetState(pDev, VUSB_DEVICE_STATE_ADDRESS);
328 vusbDevSetState(pDev, VUSB_DEVICE_STATE_CONFIGURED);
329 if (pDev->pUsbIns->pReg->pfnUsbSetConfiguration)
331 int rc = vusbDevIoThreadExecSync(pDev, (PFNRT)pDev->pUsbIns->pReg->pfnUsbSetConfiguration, 5,
332 pDev->pUsbIns, pNewCfgDesc->Core.bConfigurationValue,
333 pDev->pCurCfgDesc, pDev->paIfStates, pNewCfgDesc);
336 Log(("vusb: error: %s: failed to set config %i (%Rrc) !!!\n", pDev->pUsbIns->pszName, iCfg, rc));
340 Log(("vusb: %p[%s]: SET_CONFIGURATION: Selected config %u\n", pDev, pDev->pUsbIns->pszName, iCfg));
341 return vusbDevDoSelectConfig(pDev, pNewCfgDesc);
349 static bool vusbDevStdReqGetConfig(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
353 Log(("vusb: error: %s: GET_CONFIGURATION - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
361 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
365 LogFlow(("vusbDevStdReqGetConfig: error: %s: invalid device state %d!!!\n", pDev->pUsbIns->pszName, enmState));
371 LogFlow(("vusbDevStdReqGetConfig: %s: no space for data!\n", pDev->pUsbIns->pszName));
379 iCfg = pDev->pCurCfgDesc->Core.bConfigurationValue;
383 LogFlow(("vusbDevStdReqGetConfig: %s: returns iCfg=%d\n", pDev->pUsbIns->pszName, iCfg));
391 static bool vusbDevStdReqGetInterface(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
395 Log(("vusb: error: %s: GET_INTERFACE - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
403 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
406 LogFlow(("vusbDevStdReqGetInterface: error: %s: invalid device state %d!!!\n", pDev->pUsbIns->pszName, enmState));
412 LogFlow(("vusbDevStdReqGetInterface: %s: no space for data!\n", pDev->pUsbIns->pszName));
416 for (unsigned i = 0; i < pDev->pCurCfgDesc->Core.bNumInterfaces; i++)
418 PCVUSBDESCINTERFACEEX pIfDesc = pDev->paIfStates[i].pCurIfDesc;
424 Log(("vusb: %s: GET_INTERFACE: %u.%u\n", pDev->pUsbIns->pszName, pIfDesc->Core.bInterfaceNumber, *pbBuf));
429 Log(("vusb: error: %s: GET_INTERFACE - unknown iface %u !!!\n", pDev->pUsbIns->pszName, pSetup->wIndex));
437 static bool vusbDevStdReqSetInterface(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
441 Log(("vusb: error: %s: SET_INTERFACE - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
449 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
452 LogFlow(("vusbDevStdReqSetInterface: error: %s: invalid device state %d !!!\n", pDev->pUsbIns->pszName, enmState));
460 PVUSBINTERFACESTATE pIfState = vusbDevFindIfState(pDev, iIf);
463 LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find interface %u !!!\n", pDev->pUsbIns->pszName, iIf));
467 PCVUSBDESCINTERFACEEX pIfDesc = vusbDevFindAltIfDesc(pDev, pIfState, iAlt);
470 LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find alt interface %u.%u !!!\n", pDev->pUsbIns->pszName, iIf, iAlt));
474 if (pDev->pUsbIns->pReg->pfnUsbSetInterface)
476 int rc = vusbDevIoThreadExecSync(pDev, (PFNRT)pDev->pUsbIns->pReg->pfnUsbSetInterface, 3, pDev->pUsbIns, iIf, iAlt);
479 LogFlow(("vusbDevStdReqSetInterface: error: %s: couldn't find alt interface %u.%u (%Rrc)\n", pDev->pUsbIns->pszName, iIf, iAlt, rc));
485 unmap_endpoint(pDev, &pIfState->pCurIfDesc->paEndpoints[i]);
489 map_interface(pDev, pIfDesc);
499 static bool vusbDevStdReqSetAddress(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
503 Log(("vusb: error: %s: SET_ADDRESS - invalid request (dir) !!!\n", pDev->pUsbIns->pszName));
511 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
515 LogFlow(("vusbDevStdReqSetAddress: error: %s: invalid device state %d !!!\n", pDev->pUsbIns->pszName, enmState));
519 pDev->u8NewAddress = pSetup->wValue;
530 static bool vusbDevStdReqClearFeature(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
544 && pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint)
546 int rc = vusbDevIoThreadExecSync(pDev, (PFNRT)pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint,
547 2, pDev->pUsbIns, pSetup->wIndex);
564 static bool vusbDevStdReqSetFeature(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
588 static bool vusbDevStdReqGetStatus(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
592 LogFlow(("vusbDevStdReqGetStatus: %s: buffer is too small! (%d)\n", pDev->pUsbIns->pszName, *pcbBuf));
600 u16Status = pDev->u16Status;
601 LogFlow(("vusbDevStdReqGetStatus: %s: device status %#x (%d)\n", pDev->pUsbIns->pszName, u16Status, u16Status));
605 LogFlow(("vusbDevStdReqGetStatus: %s: bogus interface status request!!\n", pDev->pUsbIns->pszName));
609 LogFlow(("vusbDevStdReqGetStatus: %s: bogus endpoint status request!!\n", pDev->pUsbIns->pszName));
820 static bool vusbDevStdReqGetDescriptor(PVUSBDEV pDev, int EndPt, PVUSBSETUP pSetup, uint8_t *pbBuf, uint32_t *pcbBuf)
827 ReadCachedDeviceDesc(pDev->pDescCache->pDevice, pbBuf, pcbBuf);
828 LogFlow(("vusbDevStdReqGetDescriptor: %s: %u bytes of device descriptors\n", pDev->pUsbIns->pszName, *pcbBuf));
834 if (iIndex >= pDev->pDescCache->pDevice->bNumConfigurations)
837 pDev->pUsbIns->pszName, iIndex, pDev->pDescCache->pDevice->bNumConfigurations));
840 ReadCachedConfigDesc(&pDev->pDescCache->paConfigs[iIndex], pbBuf, pcbBuf);
841 LogFlow(("vusbDevStdReqGetDescriptor: %s: %u bytes of config descriptors\n", pDev->pUsbIns->pszName, *pcbBuf));
849 ReadCachedLangIdDesc(pDev->pDescCache->paLanguages, pDev->pDescCache->cLanguages, pbBuf, pcbBuf);
850 LogFlow(("vusbDevStdReqGetDescriptor: %s: %u bytes of language ID (string) descriptors\n", pDev->pUsbIns->pszName, *pcbBuf));
854 pString = FindCachedString(pDev->pDescCache->paLanguages, pDev->pDescCache->cLanguages,
860 pDev->pUsbIns->pszName, *pcbBuf, pString->psz));
871 pDev->pUsbIns->pszName, pSetup->wValue >> 8, pSetup->wValue & 0xff, pSetup->wIndex, pSetup->wLength));
882 * @param pDev The device.
888 bool vusbDevStandardRequest(PVUSBDEV pDev, int EndPoint, PVUSBSETUP pSetup, void *pvBuf, uint32_t *pcbBuf)
910 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
913 LogRel(("VUSB: %s: standard control message ignored, the device is resetting\n", pDev->pUsbIns->pszName));
928 return s_apfnStdReq[pSetup->bRequest](pDev, EndPoint, pSetup, (uint8_t *)pvBuf, pcbBuf);
935 static void vusbDevAddressHash(PVUSBDEV pDev)
937 if (pDev->u8Address == VUSB_INVALID_ADDRESS)
939 uint8_t u8Hash = vusbHashAddress(pDev->u8Address);
940 pDev->pNextHash = pDev->pHub->pRootHub->apAddrHash[u8Hash];
941 pDev->pHub->pRootHub->apAddrHash[u8Hash] = pDev;
947 static void vusbDevAddressUnHash(PVUSBDEV pDev)
949 if (pDev->u8Address == VUSB_INVALID_ADDRESS)
952 uint8_t u8Hash = vusbHashAddress(pDev->u8Address);
953 pDev->u8Address = VUSB_INVALID_ADDRESS;
954 pDev->u8NewAddress = VUSB_INVALID_ADDRESS;
956 PVUSBDEV pCur = pDev->pHub->pRootHub->apAddrHash[u8Hash];
957 if (pCur == pDev)
960 pDev->pHub->pRootHub->apAddrHash[u8Hash] = pDev->pNextHash;
961 pDev->pNextHash = NULL;
971 if (pCur == pDev)
974 pDev->pNextHash = NULL;
986 void vusbDevSetAddress(PVUSBDEV pDev, uint8_t u8Address)
988 LogFlow(("vusbDevSetAddress: pDev=%p[%s]/%i u8Address=%#x\n",
989 pDev, pDev->pUsbIns->pszName, pDev->i16Port, u8Address));
994 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
999 LogFlow(("vusbDevSetAddress: %s: fails because %d < POWERED\n", pDev->pUsbIns->pszName, pDev->enmState));
1004 LogRel(("VUSB: %s: set address ignored, the device is resetting\n", pDev->pUsbIns->pszName));
1011 if (pDev->u8Address == u8Address)
1014 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
1016 if (pDev->u8Address == VUSB_DEFAULT_ADDRESS)
1019 vusbDevAddressUnHash(pDev);
1030 pRh->pDefaultAddress = pDev;
1031 vusbDevSetState(pDev, VUSB_DEVICE_STATE_DEFAULT);
1034 vusbDevSetState(pDev, VUSB_DEVICE_STATE_ADDRESS);
1036 pDev->u8Address = u8Address;
1037 vusbDevAddressHash(pDev);
1040 pDev, pDev->pUsbIns->pszName, pDev->i16Port, u8Address));
1044 static DECLCALLBACK(int) vusbDevCancelAllUrbsWorker(PVUSBDEV pDev, bool fDetaching)
1049 RTCritSectEnter(&pDev->CritSectAsyncUrbs);
1050 PVUSBURB pUrb = pDev->pAsyncUrbHead;
1055 Assert(pUrb->VUsb.pDev == pDev);
1070 pUrb = pDev->pAsyncUrbHead;
1074 Assert(pUrb->VUsb.pDev == pDev);
1082 pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, fDetaching ? 1500 : 0 /*ms*/);
1084 pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, fDetaching ? 10 : 0 /*ms*/);
1105 pUrb = pDev->pAsyncUrbHead;
1109 Assert(pUrb->VUsb.pDev == pDev);
1111 AssertMsgFailed(("%s: Leaking left over URB! state=%d pDev=%p[%s]\n",
1112 pUrb->pszDesc, pUrb->enmState, pDev, pDev->pUsbIns->pszName));
1122 RTCritSectLeave(&pDev->CritSectAsyncUrbs);
1134 static void vusbDevCancelAllUrbs(PVUSBDEV pDev, bool fDetaching)
1136 int rc = vusbDevIoThreadExecSync(pDev, (PFNRT)vusbDevCancelAllUrbsWorker, 2, pDev, fDetaching);
1143 PVUSBDEV pDev = (PVUSBDEV)pvUser;
1150 while (!ASMAtomicReadBool(&pDev->fTerminate))
1152 if (vusbDevGetState(pDev) != VUSB_DEVICE_STATE_RESET)
1153 vusbUrbDoReapAsyncDev(pDev, RT_INDEFINITE_WAIT);
1156 int rc = RTReqQueueProcess(pDev->hReqQueueSync, 0); /* Don't wait if there is nothing to do. */
1163 int vusbDevUrbIoThreadWakeup(PVUSBDEV pDev)
1165 ASMAtomicXchgBool(&pDev->fWokenUp, true);
1166 return pDev->pUsbIns->pReg->pfnWakeup(pDev->pUsbIns);
1173 * @param pDev The VUSB device.
1175 int vusbDevUrbIoThreadCreate(PVUSBDEV pDev)
1179 ASMAtomicXchgBool(&pDev->fTerminate, false);
1180 rc = RTThreadCreateF(&pDev->hUrbIoThread, vusbDevUrbIoThread, pDev, 0, RTTHREADTYPE_IO,
1181 RTTHREADFLAGS_WAITABLE, "USBDevIo-%d", pDev->i16Port);
1185 rc = RTThreadUserWait(pDev->hUrbIoThread, RT_INDEFINITE_WAIT);
1195 * @param pDev The VUSB device.
1197 int vusbDevUrbIoThreadDestroy(PVUSBDEV pDev)
1202 ASMAtomicXchgBool(&pDev->fTerminate, true);
1203 vusbDevUrbIoThreadWakeup(pDev);
1205 rc = RTThreadWait(pDev->hUrbIoThread, RT_INDEFINITE_WAIT, &rcThread);
1209 pDev->hUrbIoThread = NIL_RTTHREAD;
1219 * @param pDev The device to detach.
1223 int vusbDevDetach(PVUSBDEV pDev)
1225 LogFlow(("vusbDevDetach: pDev=%p[%s] enmState=%#x\n", pDev, pDev->pUsbIns->pszName, pDev->enmState));
1226 VUSBDEV_ASSERT_VALID_STATE(pDev->enmState);
1227 Assert(pDev->enmState != VUSB_DEVICE_STATE_RESET);
1229 vusbDevCancelAllUrbs(pDev, true);
1230 vusbDevAddressUnHash(pDev);
1232 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
1235 if (pRh->pDefaultAddress == pDev)
1238 pDev->pHub->pOps->pfnDetach(pDev->pHub, pDev);
1239 pDev->i16Port = -1;
1240 vusbDevSetState(pDev, VUSB_DEVICE_STATE_DETACHED);
1241 pDev->pHub = NULL;
1244 pDev->pCurCfgDesc = NULL;
1245 for (unsigned i = 0; i < RT_ELEMENTS(pDev->aPipes); i++)
1246 vusbDevResetPipeData(&pDev->aPipes[i]);
1254 * @param pDev The device.
1257 void vusbDevDestroy(PVUSBDEV pDev)
1259 LogFlow(("vusbDevDestroy: pDev=%p[%s] enmState=%d\n", pDev, pDev->pUsbIns->pszName, pDev->enmState));
1265 vusbDevSetStateCmp(pDev, VUSB_DEVICE_STATE_DEFAULT, VUSB_DEVICE_STATE_RESET);
1270 if (pDev->pHub)
1271 vusbDevDetach(pDev);
1272 RTMemFree(pDev->paIfStates);
1273 TMR3TimerDestroy(pDev->pResetTimer);
1274 pDev->pResetTimer = NULL;
1275 for (unsigned i = 0; i < RT_ELEMENTS(pDev->aPipes); i++)
1277 Assert(pDev->aPipes[i].pCtrl == NULL);
1278 RTCritSectDelete(&pDev->aPipes[i].CritSectCtrl);
1285 vusbDevUrbIoThreadDestroy(pDev);
1287 int rc = RTReqQueueDestroy(pDev->hReqQueueSync);
1290 if (pDev->hSniffer != VUSBSNIFFER_NIL)
1291 VUSBSnifferDestroy(pDev->hSniffer);
1293 RTCritSectDelete(&pDev->CritSectAsyncUrbs);
1295 pDev->enmState = VUSB_DEVICE_STATE_DESTROYED;
1313 * @param pDev The device that is being reset.
1318 static void vusbDevResetDone(PVUSBDEV pDev, int rc, PFNVUSBRESETDONE pfnDone, void *pvUser)
1320 VUSBDEV_ASSERT_VALID_STATE(pDev->enmState);
1321 Assert(pDev->enmState == VUSB_DEVICE_STATE_RESET);
1327 if (pDev->aPipes[i].pCtrl)
1328 vusbMsgResetExtraData(pDev->aPipes[i].pCtrl);
1333 vusbDevSetState(pDev, VUSB_DEVICE_STATE_DEFAULT);
1334 pDev->u16Status = 0;
1335 vusbDevDoSelectConfig(pDev, &g_Config0);
1336 if (!vusbDevIsRh(pDev))
1337 vusbDevSetAddress(pDev, VUSB_DEFAULT_ADDRESS);
1339 pfnDone(&pDev->IDevice, rc, pvUser);
1353 PVUSBDEV pDev = (PVUSBDEV)pvUser;
1354 PVUSBRESETARGS pArgs = (PVUSBRESETARGS)pDev->pvArgs;
1355 Assert(pDev->pUsbIns == pUsbIns);
1360 vusbDevResetDone(pDev, pArgs->rc, pArgs->pfnDone, pArgs->pvUser);
1361 pDev->pvArgs = NULL;
1371 static int vusbDevResetWorker(PVUSBDEV pDev, bool fResetOnLinux, bool fUseTimer, PVUSBRESETARGS pArgs)
1374 uint64_t u64EndTS = TMTimerGet(pDev->pResetTimer) + TMTimerFromMilli(pDev->pResetTimer, 10);
1376 if (pDev->pUsbIns->pReg->pfnUsbReset)
1377 rc = pDev->pUsbIns->pReg->pfnUsbReset(pDev->pUsbIns, fResetOnLinux);
1386 int rc2 = TMTimerSet(pDev->pResetTimer, u64EndTS);
1396 LogFlow(("vusbDevResetWorker: %s: returns %Rrc\n", pDev->pUsbIns->pszName, rc));
1417 * @param pDev Pointer to the VUSB device interface.
1428 PVUSBDEV pDev = (PVUSBDEV)pDevice;
1430 LogFlow(("vusb: reset: [%s]/%i\n", pDev->pUsbIns->pszName, pDev->i16Port));
1435 const VUSBDEVICESTATE enmStateOld = vusbDevSetState(pDev, VUSB_DEVICE_STATE_RESET);
1438 LogRel(("VUSB: %s: reset request is ignored, the device is already resetting!\n", pDev->pUsbIns->pszName));
1445 vusbDevCancelAllUrbs(pDev, false);
1456 pArgs->pDev = pDev;
1460 pDev->pvArgs = pArgs;
1461 int rc = vusbDevIoThreadExec(pDev, 0 /* fFlags */, (PFNRT)vusbDevResetWorker, 4, pDev, fResetOnLinux, true, pArgs);
1473 int rc = vusbDevResetWorker(pDev, fResetOnLinux, false, NULL);
1474 vusbDevResetDone(pDev, rc, pfnDone, pvUser);
1487 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1488 LogFlow(("vusbDevPowerOn: pDev=%p[%s]\n", pDev, pDev->pUsbIns->pszName));
1493 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
1496 Log(("vusb: warning: attempt to power on detached device %p[%s]\n", pDev, pDev->pUsbIns->pszName));
1501 LogRel(("VUSB: %s: power on ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1509 vusbDevSetState(pDev, VUSB_DEVICE_STATE_POWERED);
1523 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1524 LogFlow(("vusbDevPowerOff: pDev=%p[%s]\n", pDev, pDev->pUsbIns->pszName));
1529 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
1532 Log(("vusb: warning: attempt to power off detached device %p[%s]\n", pDev, pDev->pUsbIns->pszName));
1537 LogRel(("VUSB: %s: power off ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1544 if (vusbDevIsRh(pDev))
1546 PVUSBROOTHUB pRh = (PVUSBROOTHUB)pDev;
1551 vusbDevSetState(pDev, VUSB_DEVICE_STATE_ATTACHED);
1573 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1574 bool fEmulated = !!(pDev->pUsbIns->pReg->fFlags & PDM_USBREG_EMULATED_DEVICE);
1588 PVUSBDEV pDev = (PVUSBDEV)pInterface;
1589 VUSBSPEED enmSpeed = pDev->pUsbIns->enmSpeed;
1600 * @param pDev The device.
1602 size_t vusbDevMaxInterfaces(PVUSBDEV pDev)
1605 unsigned i = pDev->pDescCache->pDevice->bNumConfigurations;
1608 if (pDev->pDescCache->paConfigs[i].Core.bNumInterfaces > cMax)
1609 cMax = pDev->pDescCache->paConfigs[i].Core.bNumInterfaces;
1620 * @param pDev The USB device instance data.
1628 DECLHIDDEN(int) vusbDevIoThreadExecV(PVUSBDEV pDev, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, va_list Args)
1633 Assert(pDev->hUrbIoThread != NIL_RTTHREAD);
1634 if (RT_LIKELY(pDev->hUrbIoThread != NIL_RTTHREAD))
1641 rc = RTReqQueueCallV(pDev->hReqQueueSync, &hReq, 0 /* cMillies */, fReqFlags, pfnFunction, cArgs, Args);
1644 vusbDevUrbIoThreadWakeup(pDev);
1664 * @param pDev The USB device instance data.
1672 DECLHIDDEN(int) vusbDevIoThreadExec(PVUSBDEV pDev, uint32_t fFlags, PFNRT pfnFunction, unsigned cArgs, ...)
1678 rc = vusbDevIoThreadExecV(pDev, fFlags, pfnFunction, cArgs, va);
1688 * @param pDev The USB device instance data
1695 DECLHIDDEN(int) vusbDevIoThreadExecSync(PVUSBDEV pDev, PFNRT pfnFunction, unsigned cArgs, ...)
1701 rc = vusbDevIoThreadExecV(pDev, VUSB_DEV_IO_THREAD_EXEC_FLAGS_SYNC, pfnFunction, cArgs, va);
1717 * @param pDev The VUSB device to initialize.
1720 int vusbDevInit(PVUSBDEV pDev, PPDMUSBINS pUsbIns, const char *pszCaptureFilename)
1726 Assert(!pDev->IDevice.pfnReset);
1727 Assert(!pDev->IDevice.pfnPowerOn);
1728 Assert(!pDev->IDevice.pfnPowerOff);
1729 Assert(!pDev->IDevice.pfnGetState);
1730 Assert(!pDev->IDevice.pfnIsEmulated);
1732 pDev->IDevice.pfnReset = vusbIDeviceReset;
1733 pDev->IDevice.pfnPowerOn = vusbIDevicePowerOn;
1734 pDev->IDevice.pfnPowerOff = vusbIDevicePowerOff;
1735 pDev->IDevice.pfnGetState = vusbIDeviceGetState;
1736 pDev->IDevice.pfnIsEmulated = vusbIDeviceIsEmulated;
1737 pDev->IDevice.pfnGetSpeed = vusbIDeviceGetSpeed;
1738 pDev->pUsbIns = pUsbIns;
1739 pDev->pNext = NULL;
1740 pDev->pNextHash = NULL;
1741 pDev->pHub = NULL;
1742 pDev->enmState = VUSB_DEVICE_STATE_DETACHED;
1743 pDev->u8Address = VUSB_INVALID_ADDRESS;
1744 pDev->u8NewAddress = VUSB_INVALID_ADDRESS;
1745 pDev->i16Port = -1;
1746 pDev->u16Status = 0;
1747 pDev->pDescCache = NULL;
1748 pDev->pCurCfgDesc = NULL;
1749 pDev->paIfStates = NULL;
1750 memset(&pDev->aPipes[0], 0, sizeof(pDev->aPipes));
1751 for (unsigned i = 0; i < RT_ELEMENTS(pDev->aPipes); i++)
1753 int rc = RTCritSectInit(&pDev->aPipes[i].CritSectCtrl);
1756 pDev->pResetTimer = NULL;
1757 pDev->hSniffer = VUSBSNIFFER_NIL;
1759 int rc = RTCritSectInit(&pDev->CritSectAsyncUrbs);
1763 rc = RTReqQueueCreate(&pDev->hReqQueueSync);
1767 rc = vusbDevUrbIoThreadCreate(pDev);
1773 rc = PDMUsbHlpTMTimerCreate(pDev->pUsbIns, TMCLOCK_VIRTUAL, vusbDevResetDoneTimer, pDev, 0 /*fFlags*/,
1774 "USB Device Reset Timer", &pDev->pResetTimer);
1779 rc = VUSBSnifferCreate(&pDev->hSniffer, 0, pszCaptureFilename, NULL);
1786 rc = vusbDevIoThreadExecSync(pDev, (PFNRT)vusbDevGetDescriptorCacheWorker, 2, pUsbIns, &pDev->pDescCache);
1788 AssertPtr(pDev->pDescCache);
1790 if (pDev->pDescCache->fUseCachedStringsDescriptors)
1793 for (unsigned iLang = 0; iLang < pDev->pDescCache->cLanguages; iLang++)
1795 Assert((int32_t)pDev->pDescCache->paLanguages[iLang].idLang > iPrevId);
1796 iPrevId = pDev->pDescCache->paLanguages[iLang].idLang;
1799 PCPDMUSBDESCCACHESTRING paStrings = pDev->pDescCache->paLanguages[iLang].paStrings;
1800 unsigned cStrings = pDev->pDescCache->paLanguages[iLang].cStrings;
1815 size_t cbIface = vusbDevMaxInterfaces(pDev) * sizeof(*pDev->paIfStates);
1816 pDev->paIfStates = (PVUSBINTERFACESTATE)RTMemAllocZ(cbIface);
1817 AssertMsgReturn(pDev->paIfStates, ("RTMemAllocZ(%d) failed\n", cbIface), VERR_NO_MEMORY);