Lines Matching refs:pState
259 struct vboxusb_state_t *pState; /* Pointer to the device instance */
304 LOCAL int vboxUSBSolarisInitEndPoint(vboxusb_state_t *pState, usb_ep_data_t *pEpData, uchar_t uCfgValue,
306 LOCAL int vboxUSBSolarisInitAllEndPoints(vboxusb_state_t *pState);
307 LOCAL int vboxUSBSolarisInitEndPointsForConfig(vboxusb_state_t *pState, uint8_t uCfgIndex);
308 LOCAL int vboxUSBSolarisInitEndPointsForInterfaceAlt(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt);
309 LOCAL void vboxUSBSolarisDestroyAllEndPoints(vboxusb_state_t *pState);
310 LOCAL void vboxUSBSolarisDestroyEndPoint(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
311 LOCAL void vboxUSBSolarisCloseAllPipes(vboxusb_state_t *pState, bool fControlPipe);
312 LOCAL int vboxUSBSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
313 LOCAL void vboxUSBSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp);
314 LOCAL int vboxUSBSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
316 LOCAL int vboxUSBSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *purb);
318 LOCAL int vboxUSBSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
320 LOCAL int vboxUSBSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb);
324 LOCAL vboxusb_urb_t *vboxUSBSolarisGetIsocInURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq);
325 LOCAL vboxusb_urb_t *vboxUSBSolarisQueueURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg);
329 LOCAL inline void vboxUSBSolarisNotifyComplete(vboxusb_state_t *pState);
335 LOCAL int vboxUSBSolarisSendURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode);
336 LOCAL int vboxUSBSolarisReapURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode);
337 LOCAL int vboxUSBSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint);
338 LOCAL int vboxUSBSolarisSetConfig(vboxusb_state_t *pState, uint8_t bCfgValue);
339 LOCAL int vboxUSBSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pCfgValue);
340 LOCAL int vboxUSBSolarisSetInterface(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt);
341 LOCAL int vboxUSBSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset);
342 LOCAL int vboxUSBSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint);
343 LOCAL int vboxUSBSolarisGetConfigIndex(vboxusb_state_t *pState, uint_t uCfgValue);
346 LOCAL inline void vboxUSBSolarisNotifyHotplug(vboxusb_state_t *pState);
350 LOCAL int vboxUSBSolarisInitPower(vboxusb_state_t *pState);
351 LOCAL void vboxUSBSolarisDestroyPower(vboxusb_state_t *pState);
352 LOCAL int vboxUSBSolarisDeviceSuspend(vboxusb_state_t *pState);
353 LOCAL void vboxUSBSolarisDeviceResume(vboxusb_state_t *pState);
354 LOCAL void vboxUSBSolarisDeviceRestore(vboxusb_state_t *pState);
355 LOCAL void vboxUSBSolarisPowerBusy(vboxusb_state_t *pState);
356 LOCAL void vboxUSBSolarisPowerIdle(vboxusb_state_t *pState);
467 vboxusb_state_t *pState = NULL;
476 pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
477 if (RT_LIKELY(pState))
479 pState->pDip = pDip;
480 pState->pDevDesc = NULL;
481 pState->fClosed = false;
482 pState->fRestoreCfg = false;
483 pState->fGetCfgReqDone = false;
484 bzero(pState->aEps, sizeof(pState->aEps));
485 list_create(&pState->hUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink));
486 list_create(&pState->hLandedUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink));
487 pState->cInflightUrbs = 0;
488 pState->fPoll = VBOXUSB_POLL_OFF;
489 pState->Process = NIL_RTPROCESS;
490 pState->pPower = NULL;
496 if (vboxUSBSolarisIsUSBDevice(pState->pDip))
501 rc = usb_client_attach(pState->pDip, USBDRV_VERSION, 0);
507 rc = usb_get_dev_data(pState->pDip, &pState->pDevDesc, USB_PARSE_LVL_ALL, 0 /* Unused */);
511 usb_print_descr_tree(pState->pDip, pState->pDevDesc);
517 mutex_init(&pState->Mtx, NULL, MUTEX_DRIVER, pState->pDevDesc->dev_iblock_cookie);
518 pState->StateMulti = usb_init_serialization(pState->pDip, USB_INIT_SER_CHECK_SAME_THREAD);
523 rc = usb_pipe_get_max_bulk_transfer_size(pState->pDip, &pState->cbMaxBulkXfer);
526 Log((DEVICE_NAME ":VBoxUSBSolarisAttach cbMaxBulkXfer=%d\n", pState->cbMaxBulkXfer));
531 rc = vboxUSBSolarisInitAllEndPoints(pState);
537 pState->DevState = USB_DEV_ONLINE;
542 rc = vboxUSBSolarisInitPower(pState);
548 vboxUSBSolarisInitEndPointsForConfig(pState, usb_get_current_cfgidx(pState->pDip));
560 rc = usb_register_event_cbs(pState->pDip, &g_VBoxUSBSolarisEvents, 0 /* flags */);
566 bzero(&pState->ClientInfo, sizeof(pState->ClientInfo));
568 ddi_pathname(pState->pDip, szDevicePath);
569 RTStrPrintf(pState->ClientInfo.szClientPath,
570 sizeof(pState->ClientInfo.szClientPath),
573 RTStrPrintf(pState->ClientInfo.szDeviceIdent,
574 sizeof(pState->ClientInfo.szDeviceIdent),
576 pState->pDevDesc->dev_descr->idVendor,
577 pState->pDevDesc->dev_descr->idProduct,
578 pState->pDevDesc->dev_descr->bcdDevice, szDevicePath);
579 pState->ClientInfo.Instance = instance;
580 pState->ClientInfo.pfnSetConsumerCredentials = &vboxUSBSolarisSetConsumerCredentials;
581 rc = VBoxUSBMonSolarisRegisterClient(pState->pDip, &pState->ClientInfo);
585 pState->pDevDesc->dev_product ? pState->pDevDesc->dev_product
587 pState->pDevDesc->dev_descr->idVendor,
588 pState->pDevDesc->dev_descr->idProduct,
589 pState->pDevDesc->dev_descr->bcdDevice,
590 pState->ClientInfo.szClientPath));
597 "path=%s instance=%d\n", rc, pState->ClientInfo.szClientPath,
601 usb_unregister_event_cbs(pState->pDip, &g_VBoxUSBSolarisEvents);
607 ddi_remove_minor_node(pState->pDip, NULL);
633 usb_fini_serialization(pState->StateMulti);
634 mutex_destroy(&pState->Mtx);
635 usb_free_dev_data(pState->pDip, pState->pDevDesc);
640 usb_client_detach(pState->pDip, NULL);
652 LogRel((DEVICE_NAME ":VBoxUSBSolarisAttach failed to get soft state\n", sizeof(*pState)));
664 pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
665 if (RT_UNLIKELY(!pState))
671 vboxUSBSolarisDeviceResume(pState);
694 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
695 if (RT_UNLIKELY(!pState))
714 vboxUSBSolarisNotifyHotplug(pState);
726 usb_serialize_access(pState->StateMulti, USB_WAIT, 0);
727 usb_release_access(pState->StateMulti);
728 mutex_enter(&pState->Mtx);
733 vboxUSBSolarisCloseAllPipes(pState, true /* ControlPipe */);
734 pState->fClosed = true;
739 vboxUSBSolarisDestroyPower(pState);
740 vboxUSBSolarisDestroyAllEndPoints(pState);
746 while ((pUrb = list_remove_head(&pState->hUrbs)) != NULL)
753 while ((pUrb = list_remove_head(&pState->hLandedUrbs)) != NULL)
759 pState->cInflightUrbs = 0;
760 list_destroy(&pState->hUrbs);
761 list_destroy(&pState->hLandedUrbs);
766 mutex_exit(&pState->Mtx);
767 usb_fini_serialization(pState->StateMulti);
768 mutex_destroy(&pState->Mtx);
770 usb_free_dev_data(pState->pDip, pState->pDevDesc);
771 usb_client_detach(pState->pDip, NULL);
776 VBoxUSBMonSolarisUnregisterClient(pState->pDip);
778 ddi_remove_minor_node(pState->pDip, NULL);
781 pState->pDevDesc->dev_product ? pState->pDevDesc->dev_product : "<Unnamed USB device>",
782 pState->ClientInfo.szDeviceIdent));
785 pState = NULL;
792 int rc = vboxUSBSolarisDeviceSuspend(pState);
819 vboxusb_state_t *pState = NULL;
829 pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
830 if (pState)
832 *ppvResult = (void *)pState->pDip;
867 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, Instance);
868 if (!pState)
875 mutex_enter(&pState->Mtx);
877 if (pState->Process == NIL_RTPROCESS)
878 pState->Process = Process;
882 pState->Process));
886 mutex_exit(&pState->Mtx);
906 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
907 if (!pState)
913 mutex_enter(&pState->Mtx);
918 if (pState->Process != RTProcSelf())
920 if (pState->Process == NIL_RTPROCESS)
923 LogRel((DEVICE_NAME ":VBoxUSBSolarisOpen Process %u is already using this device instance.\n", pState->Process));
925 mutex_exit(&pState->Mtx);
929 pState->fPoll = VBOXUSB_POLL_ON;
931 mutex_exit(&pState->Mtx);
945 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
946 if (RT_UNLIKELY(!pState))
952 mutex_enter(&pState->Mtx);
953 pState->fPoll = VBOXUSB_POLL_OFF;
954 pState->Process = NIL_RTPROCESS;
955 mutex_exit(&pState->Mtx);
983 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
984 if (RT_UNLIKELY(!pState))
990 mutex_enter(&pState->Mtx);
997 if (pState->fPoll & VBOXUSB_POLL_DEV_UNPLUGGED)
1000 pState->fPoll &= ~VBOXUSB_POLL_DEV_UNPLUGGED;
1003 if (pState->fPoll & VBOXUSB_POLL_REAP_PENDING)
1006 pState->fPoll &= ~VBOXUSB_POLL_REAP_PENDING;
1012 *ppPollHead = &pState->PollHead;
1017 mutex_exit(&pState->Mtx);
1028 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
1029 if (RT_UNLIKELY(!pState))
1035 if (!pState->pPower)
1038 usb_serialize_access(pState->StateMulti, USB_WAIT, 0);
1039 mutex_enter(&pState->Mtx);
1042 if (pState->DevState == USB_DEV_ONLINE)
1047 if (!USB_DEV_PWRSTATE_OK(pState->pPower->PowerStates, Level))
1053 if (pState->pPower->PowerBusy)
1059 pState->pPower->PowerLevel = USB_DEV_OS_PWR_OFF;
1060 mutex_exit(&pState->Mtx);
1062 mutex_enter(&pState->Mtx);
1071 pState->pPower->PowerLevel = USB_DEV_OS_FULL_PWR;
1072 mutex_exit(&pState->Mtx);
1074 mutex_enter(&pState->Mtx);
1088 mutex_exit(&pState->Mtx);
1089 usb_release_access(pState->StateMulti);
1110 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
1111 if (RT_UNLIKELY(!pState))
1176 rc = vboxUSBSolarisProcessIOCtl(Cmd, pState, Mode, &ReqWrap, pvBuf, &cbDataOut);
1239 vboxusb_state_t *pState = (vboxusb_state_t *)pvState;
1265 rc = vboxUSBSolarisSendURB(pState, pUrbReq, Mode);
1276 rc = vboxUSBSolarisReapURB(pState, pUrbReq, Mode);
1287 rc = vboxUSBSolarisClearEndPoint(pState, pClearEpReq->bEndpoint);
1298 rc = vboxUSBSolarisSetConfig(pState, pSetCfgReq->bConfigValue);
1309 rc = vboxUSBSolarisSetInterface(pState, pSetInterfaceReq->bInterface, pSetInterfaceReq->bAlternate);
1320 rc = vboxUSBSolarisCloseDevice(pState, pCloseDeviceReq->ResetLevel);
1331 rc = vboxUSBSolarisAbortPipe(pState, pAbortPipeReq->bEndpoint);
1342 rc = vboxUSBSolarisGetConfig(pState, &pGetCfgReq->bConfigValue);
1378 * @param pState The USB device instance.
1382 LOCAL int vboxUSBSolarisInitPower(vboxusb_state_t *pState)
1384 LogFunc((DEVICE_NAME ":vboxUSBSolarisInitPower pState=%p\n", pState));
1386 int rc = usb_handle_remote_wakeup(pState->pDip, USB_REMOTE_WAKEUP_ENABLE);
1392 mutex_enter(&pState->Mtx);
1393 pState->pPower = pPower;
1394 pState->pPower->fPowerWakeup = false;
1395 mutex_exit(&pState->Mtx);
1398 rc = usb_create_pm_components(pState->pDip, &PowerStates);
1401 pState->pPower->fPowerWakeup = true;
1402 pState->pPower->PowerLevel = USB_DEV_OS_FULL_PWR;
1403 pState->pPower->PowerStates = PowerStates;
1405 rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR);
1410 pState->pDevDesc->dev_descr->idVendor, pState->pDevDesc->dev_descr->idProduct));
1434 * @param pState The USB device instance.
1439 LOCAL void vboxUSBSolarisDestroyPower(vboxusb_state_t *pState)
1441 LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyPower pState=%p\n", pState));
1443 if (pState->pPower)
1445 mutex_exit(&pState->Mtx);
1446 vboxUSBSolarisPowerBusy(pState);
1447 mutex_enter(&pState->Mtx);
1450 if ( pState->pPower->fPowerWakeup
1451 && pState->DevState != USB_DEV_DISCONNECTED)
1453 mutex_exit(&pState->Mtx);
1454 rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR);
1458 rc = usb_handle_remote_wakeup(pState->pDip, USB_REMOTE_WAKEUP_DISABLE);
1463 mutex_exit(&pState->Mtx);
1465 rc = pm_lower_power(pState->pDip, 0 /* component */, USB_DEV_OS_PWR_OFF);
1469 vboxUSBSolarisPowerIdle(pState);
1470 mutex_enter(&pState->Mtx);
1471 RTMemFree(pState->pPower);
1472 pState->pPower = NULL;
1648 * @param pState The USB device instance.
1654 LOCAL int vboxUSBSolarisSendURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode)
1657 vboxusb_ep_t *pEp = &pState->aEps[EndPtIndex];
1660 /* LogFunc((DEVICE_NAME ":vboxUSBSolarisSendUrb pState=%p pUrbReq=%p bEndpoint=%#x[%d] enmDir=%#x enmType=%#x cbData=%d pvData=%p\n",
1661 pState, pUrbReq, pUrbReq->bEndpoint, EndPtIndex, pUrbReq->enmDir, pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData)); */
1696 mutex_enter(&pState->Mtx);
1697 rc = vboxUSBSolarisDeviceState(pState->DevState);
1699 if (pState->fClosed) /* Required for Isoc. IN Xfers which don't Xfer through the pipe after polling starts */
1707 rc = vboxUSBSolarisOpenPipe(pState, pEp);
1710 mutex_exit(&pState->Mtx);
1712 LogRel((DEVICE_NAME ":vboxUSBSolarisSendUrb OpenPipe failed. pState=%p pUrbReq=%p bEndpoint=%#x enmDir=%#x "
1713 "enmType=%#x cbData=%d pvData=%p rc=%d\n", pState, pUrbReq, pUrbReq->bEndpoint, pUrbReq->enmDir,
1718 mutex_exit(&pState->Mtx);
1723 pUrb = vboxUSBSolarisGetIsocInURB(pState, pUrbReq);
1725 pUrb = vboxUSBSolarisQueueURB(pState, pUrbReq, pMsg);
1733 rc = vboxUSBSolarisCtrlXfer(pState, pEp, pUrb);
1739 rc = vboxUSBSolarisBulkXfer(pState, pEp, pUrb);
1745 rc = vboxUSBSolarisIntrXfer(pState, pEp, pUrb);
1751 rc = vboxUSBSolarisIsocXfer(pState, pEp, pUrb);
1768 mutex_enter(&pState->Mtx);
1786 mutex_exit(&pState->Mtx);
1801 mutex_enter(&pState->Mtx);
1802 pState->cInflightUrbs--;
1803 mutex_exit(&pState->Mtx);
1809 mutex_exit(&pState->Mtx);
1820 * @param pState The USB device instance.
1826 LOCAL int vboxUSBSolarisReapURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode)
1828 // LogFunc((DEVICE_NAME ":vboxUSBSolarisReapUrb pState=%p pUrbReq=%p\n", pState, pUrbReq));
1833 mutex_enter(&pState->Mtx);
1834 rc = vboxUSBSolarisDeviceState(pState->DevState);
1835 if (pState->fClosed)
1839 vboxusb_urb_t *pUrb = list_remove_head(&pState->hLandedUrbs);
1845 mutex_exit(&pState->Mtx);
1971 mutex_enter(&pState->Mtx);
1972 list_insert_head(&pState->hUrbs, pUrb);
1973 mutex_exit(&pState->Mtx);
1980 mutex_exit(&pState->Mtx);
1989 * @param pState The USB device instance.
1994 LOCAL int vboxUSBSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint)
1996 LogFunc((DEVICE_NAME ":vboxUSBSolarisClearEndPoint pState=%p bEndpoint=%#x\n", pState, bEndpoint));
2001 mutex_enter(&pState->Mtx);
2002 int rc = vboxUSBSolarisDeviceState(pState->DevState);
2006 vboxusb_ep_t *pEp = &pState->aEps[EndPtIndex];
2014 mutex_exit(&pState->Mtx);
2019 rc = usb_clr_feature(pState->pDip, USB_DEV_REQ_RCPT_EP, USB_EP_HALT, bEndpoint,
2027 usb_pipe_reset(pState->pDip, pEp->pPipe,
2032 mutex_enter(&pState->Mtx);
2053 Log((DEVICE_NAME ":vboxUSBSolarisClearEndPoint device state=%d not online.\n", pState->DevState));
2055 mutex_exit(&pState->Mtx);
2063 * @param pState The USB device instance.
2068 LOCAL int vboxUSBSolarisSetConfig(vboxusb_state_t *pState, uint8_t bCfgValue)
2070 LogFunc((DEVICE_NAME ":vboxUSBSolarisSetConfig pState=%p bCfgValue=%#x\n", pState, bCfgValue));
2075 mutex_enter(&pState->Mtx);
2076 int rc = vboxUSBSolarisDeviceState(pState->DevState);
2079 vboxUSBSolarisCloseAllPipes(pState, false /* ControlPipe */);
2080 int iCfgIndex = vboxUSBSolarisGetConfigIndex(pState, bCfgValue);
2087 mutex_exit(&pState->Mtx);
2088 rc = usb_set_cfg(pState->pDip, (uint_t)iCfgIndex, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback data */);
2089 mutex_enter(&pState->Mtx);
2093 pState->fRestoreCfg = true;
2094 vboxUSBSolarisInitEndPointsForConfig(pState, iCfgIndex);
2111 mutex_exit(&pState->Mtx);
2120 * @param pState The USB device instance.
2125 LOCAL int vboxUSBSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pCfgValue)
2127 LogFunc((DEVICE_NAME ":vboxUSBSolarisGetConfig pState=%p pCfgValue=%p\n", pState, pCfgValue));
2134 if (!pState->fGetCfgReqDone)
2136 pState->fGetCfgReqDone = true;
2137 AssertPtrReturn(pState->pDevDesc, VERR_GENERAL_FAILURE);
2138 usb_cfg_data_t *pCurrCfg = pState->pDevDesc->dev_curr_cfg;
2151 int rc = usb_get_cfg(pState->pDip, &bCfgValue, USB_FLAGS_SLEEP);
2171 * @param pState The USB device instance.
2177 LOCAL int vboxUSBSolarisSetInterface(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt)
2179 LogFunc((DEVICE_NAME ":vboxUSBSolarisSetInterface pState=%p uInterface=%#x uAlt=%#x\n", pState, uInterface, uAlt));
2184 mutex_enter(&pState->Mtx);
2185 int rc = vboxUSBSolarisDeviceState(pState->DevState);
2188 vboxUSBSolarisCloseAllPipes(pState, false /* ControlPipe */);
2193 mutex_exit(&pState->Mtx);
2194 rc = usb_set_alt_if(pState->pDip, uInterface, uAlt, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback data */);
2195 mutex_enter(&pState->Mtx);
2199 vboxUSBSolarisInitEndPointsForInterfaceAlt(pState, uInterface, uAlt);
2210 mutex_exit(&pState->Mtx);
2219 * @param pState The USB device instance.
2224 LOCAL int vboxUSBSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset)
2226 Log((DEVICE_NAME ":vboxUSBSolarisCloseDevice pState=%p enmReset=%d\n", pState, enmReset));
2231 mutex_enter(&pState->Mtx);
2232 int rc = vboxUSBSolarisDeviceState(pState->DevState);
2236 vboxUSBSolarisCloseAllPipes(pState, true /* ControlPipe */);
2237 pState->fClosed = true;
2240 vboxUSBSolarisCloseAllPipes(pState, false /* ControlPipe */);
2243 mutex_exit(&pState->Mtx);
2250 rc = usb_reset_device(pState->pDip, USB_RESET_LVL_REATTACH);
2254 rc = usb_reset_device(pState->pDip, USB_RESET_LVL_DEFAULT);
2273 * @param pState The USB device instance.
2278 LOCAL int vboxUSBSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint)
2280 LogFunc((DEVICE_NAME ":vboxUSBSolarisAbortPipe pState=%p bEndpoint=%#x\n", pState, bEndpoint));
2285 mutex_enter(&pState->Mtx);
2286 int rc = vboxUSBSolarisDeviceState(pState->DevState);
2290 vboxusb_ep_t *pEp = &pState->aEps[EndPtIndex];
2300 mutex_exit(&pState->Mtx);
2308 mutex_exit(&pState->Mtx);
2309 usb_pipe_reset(pState->pDip, pEp->pPipe,
2317 rc = usb_pipe_drain_reqs(pState->pDip, pEp->pPipe,
2323 mutex_enter(&pState->Mtx);
2341 mutex_exit(&pState->Mtx);
2351 * @param pState The USB device instance.
2360 LOCAL int vboxUSBSolarisInitEndPoint(vboxusb_state_t *pState, usb_ep_data_t *pEpData, uchar_t uCfgValue,
2363 LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPoint pState=%p pEpData=%p CfgVal=%d Iface=%d Alt=%d", pState,
2383 pEp = &pState->aEps[EpIndex];
2416 * @param pState The USB device instance.
2420 LOCAL int vboxUSBSolarisInitAllEndPoints(vboxusb_state_t *pState)
2422 LogFunc((DEVICE_NAME ":vboxUSBSolarisInitAllEndPoints pState=%p\n", pState));
2427 int rc = vboxUSBSolarisInitEndPoint(pState, NULL /* pEp */, 0 /* uCfgValue */, 0 /* uInterface */, 0 /* uAlt */);
2434 for (uchar_t uCfgIndex = 0; uCfgIndex < pState->pDevDesc->dev_n_cfg; uCfgIndex++)
2436 rc = vboxUSBSolarisInitEndPointsForConfig(pState, uCfgIndex);
2455 * @param pState The USB device instance.
2460 LOCAL int vboxUSBSolarisInitEndPointsForConfig(vboxusb_state_t *pState, uint8_t uCfgIndex)
2462 LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForConfig pState=%p uCfgIndex=%d\n", pState, uCfgIndex));
2463 usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[uCfgIndex];
2478 int rc = vboxUSBSolarisInitEndPoint(pState, pEpData, uCfgValue, uInterface, uAlt);
2495 * @param pState The USB device instance.
2501 LOCAL int vboxUSBSolarisInitEndPointsForInterfaceAlt(vboxusb_state_t *pState, uint8_t uInterface, uint8_t uAlt)
2503 LogFunc((DEVICE_NAME ":vboxUSBSolarisInitEndPointsForInterfaceAlt pState=%p uInterface=%d uAlt=%d\n", pState, uInterface,
2507 uint_t uCfgIndex = usb_get_current_cfgidx(pState->pDip);
2508 if (RT_UNLIKELY(uCfgIndex >= pState->pDevDesc->dev_n_cfg))
2514 usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[uCfgIndex];
2527 rc = vboxUSBSolarisInitEndPoint(pState, pEpData, uCfgValue, uInterface, uAlt);
2556 * @param pState The USB device instance.
2560 LOCAL void vboxUSBSolarisDestroyAllEndPoints(vboxusb_state_t *pState)
2562 LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyAllEndPoints pState=%p\n", pState));
2564 Assert(mutex_owned(&pState->Mtx));
2567 vboxusb_ep_t *pEp = &pState->aEps[i];
2570 vboxUSBSolarisDestroyEndPoint(pState, pEp);
2580 * @param pState The USB device instance.
2584 LOCAL void vboxUSBSolarisDestroyEndPoint(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
2586 LogFunc((DEVICE_NAME ":vboxUSBSolarisDestroyEndPoint pState=%p pEp=%p\n", pState, pEp));
2588 Assert(mutex_owned(&pState->Mtx));
2619 * @param pState The USB device instance.
2624 LOCAL void vboxUSBSolarisCloseAllPipes(vboxusb_state_t *pState, bool fDefault)
2626 LogFunc((DEVICE_NAME ":vboxUSBSolarisCloseAllPipes pState=%p\n", pState));
2630 vboxusb_ep_t *pEp = &pState->aEps[i];
2635 vboxUSBSolarisClosePipe(pState, pEp);
2641 vboxusb_ep_t *pEp = &pState->aEps[0];
2645 vboxUSBSolarisClosePipe(pState, pEp);
2655 * @param pState The USB device instance.
2661 LOCAL int vboxUSBSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
2663 Assert(mutex_owned(&pState->Mtx));
2677 pEp->pPipe = pState->pDevDesc->dev_default_ph;
2686 mutex_exit(&pState->Mtx);
2687 int rc = usb_pipe_open(pState->pDip, &pEp->EpDesc, &pEp->PipePolicy, USB_FLAGS_NOSLEEP, &pEp->pPipe);
2688 mutex_enter(&pState->Mtx);
2691 LogFunc((DEVICE_NAME ":vboxUSBSolarisOpenPipe: Opened pipe. pState=%p pEp=%p\n", pState, pEp));
2724 LogRel((DEVICE_NAME ":vboxUSBSolarisOpenPipe failed! rc=%d pState=%p pEp=%p\n", rc, pState, pEp));
2735 * @param pState The USB device instance.
2740 LOCAL void vboxUSBSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp)
2742 LogFunc((DEVICE_NAME ":vboxUSBSolarisClosePipe pState=%p pEp=%p\n", pState, pEp));
2752 if (pEp->pPipe == pState->pDevDesc->dev_default_ph)
2754 mutex_exit(&pState->Mtx);
2755 usb_pipe_drain_reqs(pState->pDip, pEp->pPipe, 0, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback arg. */);
2756 mutex_enter(&pState->Mtx);
2767 mutex_exit(&pState->Mtx);
2769 mutex_enter(&pState->Mtx);
2777 mutex_exit(&pState->Mtx);
2778 usb_pipe_close(pState->pDip, pEp->pPipe, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback arg. */);
2779 mutex_enter(&pState->Mtx);
2797 * @param pState The USB device instance.
2802 LOCAL int vboxUSBSolarisGetConfigIndex(vboxusb_state_t *pState, uint_t uCfgValue)
2804 for (int CfgIndex = 0; CfgIndex < pState->pDevDesc->dev_n_cfg; CfgIndex++)
2806 usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[CfgIndex];
2818 * @param pState The USB device instance.
2825 LOCAL vboxusb_urb_t *vboxUSBSolarisGetIsocInURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq)
2835 pUrb->pState = pState;
2863 * @param pState The USB device instance.
2869 LOCAL vboxusb_urb_t *vboxUSBSolarisQueueURB(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg)
2871 LogFunc((DEVICE_NAME ":vboxUSBSolarisQueueURB pState=%p pUrbReq=%p\n", pState, pUrbReq));
2873 mutex_enter(&pState->Mtx);
2878 if (pState->cInflightUrbs >= VBOXUSB_URB_QUEUE_SIZE)
2880 vboxusb_urb_t *pUrb = list_head(&pState->hUrbs);
2892 vboxusb_urb_t *pUrb = list_head(&pState->hUrbs);
2897 mutex_exit(&pState->Mtx);
2904 mutex_enter(&pState->Mtx);
2913 list_remove_head(&pState->hUrbs);
2916 list_insert_tail(&pState->hUrbs, pUrb);
2917 ++pState->cInflightUrbs;
2922 pUrb->pState = pState;
2923 Log((DEVICE_NAME ":vboxUSBSolarisQueueURB cInflightUrbs=%d\n", pState->cInflightUrbs));
2946 mutex_exit(&pState->Mtx);
2967 vboxusb_state_t *pState = pUrb->pState;
2968 if (RT_LIKELY(pState))
2970 mutex_enter(&pState->Mtx);
2976 list_remove(&pState->hUrbs, pUrb);
2977 --pState->cInflightUrbs;
2978 list_insert_tail(&pState->hLandedUrbs, pUrb);
2980 vboxUSBSolarisNotifyComplete(pUrb->pState);
2981 mutex_exit(&pState->Mtx);
3019 * @param pState The USB device instance.
3022 LOCAL inline void vboxUSBSolarisNotifyComplete(vboxusb_state_t *pState)
3024 if (pState->fPoll & VBOXUSB_POLL_ON)
3026 pollhead_t *pPollHead = &pState->PollHead;
3027 pState->fPoll |= VBOXUSB_POLL_REAP_PENDING;
3028 mutex_exit(&pState->Mtx);
3030 mutex_enter(&pState->Mtx);
3038 * @param pState The USB device instance.
3041 LOCAL inline void vboxUSBSolarisNotifyHotplug(vboxusb_state_t *pState)
3043 if (pState->fPoll & VBOXUSB_POLL_ON)
3045 pollhead_t *pPollHead = &pState->PollHead;
3046 pState->fPoll |= VBOXUSB_POLL_DEV_UNPLUGGED;
3047 mutex_exit(&pState->Mtx);
3049 mutex_enter(&pState->Mtx);
3057 * @param pState The USB device instance.
3064 LOCAL int vboxUSBSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
3066 LogFunc((DEVICE_NAME ":vboxUSBSolarisCtrlXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
3077 usb_ctrl_req_t *pReq = usb_alloc_ctrl_req(pState->pDip, cbData, USB_FLAGS_NOSLEEP);
3215 * @param pState The USB device instance.
3222 LOCAL int vboxUSBSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
3224 LogFunc((DEVICE_NAME ":vboxUSBSolarisBulkXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
3231 usb_bulk_req_t *pReq = usb_alloc_bulk_req(pState->pDip, pUrb->enmDir == VUSBDIRECTION_IN ? pUrb->cbDataR3 : 0,
3255 if (RT_UNLIKELY(pUrb->cbDataR3 > pState->cbMaxBulkXfer))
3258 pUrb->cbDataR3, pState->cbMaxBulkXfer));
3342 * @param pState The USB device instance.
3349 LOCAL int vboxUSBSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
3351 LogFunc((DEVICE_NAME ":vboxUSBSolarisIntrXfer pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb,
3355 usb_intr_req_t *pReq = usb_alloc_intr_req(pState->pDip, 0 /* length */, USB_FLAGS_NOSLEEP);
3455 * @param pState The USB device instance.
3462 LOCAL int vboxUSBSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb)
3464 // LogFunc((DEVICE_NAME ":vboxUSBSolarisIsocXfer pState=%p pEp=%p pUrb=%p\n", pState, pEp, pUrb));
3475 mutex_enter(&pState->Mtx);
3483 mutex_exit(&pState->Mtx);
3491 mutex_exit(&pState->Mtx);
3494 mutex_exit(&pState->Mtx);
3498 usb_isoc_req_t *pReq = usb_alloc_isoc_req(pState->pDip, pUrb->cIsocPkts, cbData, USB_FLAGS_NOSLEEP);
3522 pReq->isoc_client_private = (usb_opaque_t)pState;
3538 mutex_enter(&pState->Mtx);
3542 mutex_exit(&pState->Mtx);
3554 mutex_enter(&pState->Mtx);
3562 mutex_exit(&pState->Mtx);
3593 vboxusb_state_t *pState = (vboxusb_state_t *)pReq->isoc_client_private;
3594 if (RT_LIKELY(pState))
3607 mutex_exit(&pState->Mtx);
3609 mutex_enter(&pState->Mtx);
3621 mutex_enter(&pState->Mtx);
3633 mutex_exit(&pState->Mtx);
3647 mutex_enter(&pState->Mtx);
3648 list_insert_tail(&pState->hLandedUrbs, pUrb);
3649 vboxUSBSolarisNotifyComplete(pState);
3659 mutex_exit(&pState->Mtx);
3678 mutex_exit(&pState->Mtx);
3700 mutex_enter(&pState->Mtx);
3703 mutex_exit(&pState->Mtx);
3714 mutex_enter(&pState->Mtx);
3730 mutex_exit(&pState->Mtx);
3748 mutex_enter(&pState->Mtx);
3749 list_insert_tail(&pState->hLandedUrbs, pUrb);
3750 vboxUSBSolarisNotifyComplete(pState);
3754 mutex_exit(&pState->Mtx);
3782 vboxusb_state_t *pState = (vboxusb_state_t *)pReq->isoc_client_private;
3783 if (RT_UNLIKELY(!pState))
3790 mutex_enter(&pState->Mtx);
3795 mutex_exit(&pState->Mtx);
3808 mutex_exit(&pState->Mtx);
3830 mutex_exit(&pState->Mtx);
3833 mutex_enter(&pState->Mtx);
3848 vboxUSBSolarisNotifyComplete(pState);
3851 mutex_exit(&pState->Mtx);
3925 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
3927 if (RT_LIKELY(pState))
3932 usb_serialize_access(pState->StateMulti, USB_WAIT, 0);
3933 mutex_enter(&pState->Mtx);
3935 pState->DevState = USB_DEV_DISCONNECTED;
3937 vboxUSBSolarisCloseAllPipes(pState, true /* ControlPipe */);
3938 vboxUSBSolarisNotifyHotplug(pState);
3940 mutex_exit(&pState->Mtx);
3941 usb_release_access(pState->StateMulti);
3963 vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance);
3965 if (RT_LIKELY(pState))
3967 vboxUSBSolarisDeviceRestore(pState);
3979 * @param pState The USB device instance.
3981 LOCAL void vboxUSBSolarisDeviceRestore(vboxusb_state_t *pState)
3983 LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceRestore pState=%p\n", pState));
3984 AssertPtrReturnVoid(pState);
3989 vboxUSBSolarisPowerBusy(pState);
3990 int rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR);
3995 rc = usb_check_same_device(pState->pDip,
4004 mutex_enter(&pState->Mtx);
4005 pState->DevState = USB_DEV_DISCONNECTED;
4006 mutex_exit(&pState->Mtx);
4009 vboxUSBSolarisPowerIdle(pState);
4017 usb_serialize_access(pState->StateMulti, USB_WAIT, 0);
4019 mutex_enter(&pState->Mtx);
4020 if (pState->DevState == USB_DEV_DISCONNECTED)
4021 pState->DevState = USB_DEV_ONLINE;
4022 else if (pState->DevState == USB_DEV_SUSPENDED)
4023 pState->DevState = USB_DEV_ONLINE;
4025 mutex_exit(&pState->Mtx);
4026 usb_release_access(pState->StateMulti);
4028 vboxUSBSolarisPowerIdle(pState);
4035 * @param pState The USB device instance.
4039 LOCAL int vboxUSBSolarisDeviceSuspend(vboxusb_state_t *pState)
4041 LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend pState=%p\n", pState));
4044 mutex_enter(&pState->Mtx);
4046 switch (pState->DevState)
4050 LogRel((DEVICE_NAME ":vboxUSBSolarisDeviceSuspend: Invalid device state %d\n", pState->DevState));
4058 int PreviousState = pState->DevState;
4059 pState->DevState = USB_DEV_DISCONNECTED;
4066 if (pState->cInflightUrbs < 1)
4069 mutex_exit(&pState->Mtx);
4071 mutex_enter(&pState->Mtx);
4077 if (pState->cInflightUrbs > 0)
4079 pState->DevState = PreviousState;
4080 LogRel((DEVICE_NAME ":Cannot suspend, still have %d inflight URBs.\n", pState->cInflightUrbs));
4082 mutex_exit(&pState->Mtx);
4086 pState->cInflightUrbs = 0;
4092 mutex_exit(&pState->Mtx);
4093 usb_serialize_access(pState->StateMulti, USB_WAIT, 0);
4094 mutex_enter(&pState->Mtx);
4096 vboxUSBSolarisCloseAllPipes(pState, true /* default pipe */);
4097 vboxUSBSolarisNotifyHotplug(pState);
4099 mutex_exit(&pState->Mtx);
4100 usb_release_access(pState->StateMulti);
4105 mutex_exit(&pState->Mtx);
4114 * @param pState The USB device instance.
4116 LOCAL void vboxUSBSolarisDeviceResume(vboxusb_state_t *pState)
4118 LogFunc((DEVICE_NAME ":vboxUSBSolarisDeviceResume pState=%p\n", pState));
4119 return vboxUSBSolarisDeviceRestore(pState);
4126 * @param pState The USB device instance.
4128 LOCAL void vboxUSBSolarisPowerBusy(vboxusb_state_t *pState)
4130 LogFunc((DEVICE_NAME ":vboxUSBSolarisPowerBusy pState=%p\n", pState));
4131 AssertPtrReturnVoid(pState);
4133 mutex_enter(&pState->Mtx);
4134 if (pState->pPower)
4136 pState->pPower->PowerBusy++;
4137 mutex_exit(&pState->Mtx);
4139 int rc = pm_busy_component(pState->pDip, 0 /* component */);
4143 mutex_enter(&pState->Mtx);
4144 pState->pPower->PowerBusy--;
4145 mutex_exit(&pState->Mtx);
4149 mutex_exit(&pState->Mtx);
4156 * @param pState The USB device instance.
4158 LOCAL void vboxUSBSolarisPowerIdle(vboxusb_state_t *pState)
4160 LogFunc((DEVICE_NAME ":vboxUSBSolarisPowerIdle pState=%p\n", pState));
4161 AssertPtrReturnVoid(pState);
4163 if (pState->pPower)
4165 int rc = pm_idle_component(pState->pDip, 0 /* component */);
4168 mutex_enter(&pState->Mtx);
4169 Assert(pState->pPower->PowerBusy > 0);
4170 pState->pPower->PowerBusy--;
4171 mutex_exit(&pState->Mtx);