Lines Matching defs:pReq
127 * mass storage reset operation times out. USBMSD::pReq will be set to NULL
215 PUSBMSDREQ pReq;
749 PUSBMSDREQ pReq = (PUSBMSDREQ)PDMUsbHlpMMHeapAllocZ(pUsbIns, sizeof(*pReq));
750 if (pReq)
752 pReq->enmState = USBMSDREQSTATE_READY;
753 pReq->iScsiReqStatus = -1;
754 pReq->pUsbIns = pUsbIns;
758 return pReq;
765 * @param pReq The request.
767 static void usbMsdReqFree(PUSBMSDREQ pReq)
772 AssertReturnVoid( pReq->enmState > USBMSDREQSTATE_INVALID
773 && pReq->enmState != USBMSDREQSTATE_EXECUTING
774 && pReq->enmState < USBMSDREQSTATE_END);
775 PPDMUSBINS pUsbIns = pReq->pUsbIns;
782 pReq->enmState = USBMSDREQSTATE_INVALID;
783 pReq->cbBuf = 0;
784 pReq->offBuf = 0;
785 pReq->ScsiReq.pbCDB = NULL;
786 pReq->ScsiReq.paScatterGatherHead = NULL;
787 pReq->ScsiReq.pbSenseBuffer = NULL;
788 pReq->ScsiReq.pvUser = NULL;
789 pReq->ScsiReqSeg.cbSeg = 0;
790 pReq->ScsiReqSeg.pvSeg = NULL;
792 if (pReq->pbBuf)
794 PDMUsbHlpMMHeapFree(pUsbIns, pReq->pbBuf);
795 pReq->pbBuf = NULL;
798 PDMUsbHlpMMHeapFree(pUsbIns, pReq);
805 * @param pReq The request.
808 static void usbMsdReqPrepare(PUSBMSDREQ pReq, PCUSBCBW pCbw)
812 memcpy(&pReq->Cbw, pCbw, cbCopy);
813 memset((uint8_t *)&pReq->Cbw + cbCopy, 0, sizeof(pReq->Cbw) - cbCopy);
816 pReq->ScsiReq.uLogicalUnit = pReq->Cbw.bCBWLun;
817 pReq->ScsiReq.uDataDirection = (pReq->Cbw.bmCBWFlags & USBCBW_DIR_MASK) == USBCBW_DIR_OUT
820 pReq->ScsiReq.cbCDB = pReq->Cbw.bCBWCBLength;
822 pReq->ScsiReq.pbCDB = &pReq->Cbw.CBWCB[0];
823 pReq->offBuf = 0;
824 pReq->ScsiReqSeg.pvSeg = pReq->pbBuf;
825 pReq->ScsiReqSeg.cbSeg = pReq->Cbw.dCBWDataTransferLength;
826 pReq->ScsiReq.cbScatterGather = pReq->Cbw.dCBWDataTransferLength;
827 pReq->ScsiReq.cScatterGatherEntries = 1;
828 pReq->ScsiReq.paScatterGatherHead = &pReq->ScsiReqSeg;
829 pReq->ScsiReq.cbSenseBuffer = sizeof(pReq->ScsiReqSense);
830 pReq->ScsiReq.pbSenseBuffer = &pReq->ScsiReqSense[0];
831 pReq->ScsiReq.pvUser = NULL;
832 RT_ZERO(pReq->ScsiReqSense);
833 pReq->iScsiReqStatus = -1;
841 * @param pReq
844 static int usbMsdReqEnsureBuffer(PUSBMSDREQ pReq, uint32_t cbBuf)
846 if (RT_LIKELY(pReq->cbBuf >= cbBuf))
847 RT_BZERO(pReq->pbBuf, cbBuf);
850 PDMUsbHlpMMHeapFree(pReq->pUsbIns, pReq->pbBuf);
851 pReq->cbBuf = 0;
854 pReq->pbBuf = (uint8_t *)PDMUsbHlpMMHeapAllocZ(pReq->pUsbIns, cbBuf);
855 if (!pReq->pbBuf)
858 pReq->cbBuf = cbBuf;
920 PUSBMSDREQ pReq = pThis->pReq;
921 if ( pReq
922 && pReq->enmState == USBMSDREQSTATE_EXECUTING)
953 || pReq->enmState == USBMSDREQSTATE_EXECUTING)
955 Log(("usbMsdResetWorker: Didn't complete, ditching the current request (%p)!\n", pReq));
956 Assert(pReq == pThis->pReq);
957 pReq->enmState = USBMSDREQSTATE_DESTROY_ON_COMPLETION;
958 pThis->pReq = NULL;
959 pReq = NULL;
966 if (pReq)
968 pReq->enmState = USBMSDREQSTATE_READY;
969 pReq->iScsiReqStatus = -1;
1009 PUSBMSDREQ pReq = RT_FROM_MEMBER(pSCSIRequest, USBMSDREQ, ScsiReq);
1011 Log(("usbMsdLun0ScsiRequestCompleted: pReq=%p dCBWTag=%#x iScsiReqStatus=%u \n", pReq, pReq->Cbw.dCBWTag, rcCompletion));
1014 if (pReq->enmState != USBMSDREQSTATE_DESTROY_ON_COMPLETION)
1016 Assert(pReq->enmState == USBMSDREQSTATE_EXECUTING);
1017 Assert(pThis->pReq == pReq);
1018 pReq->iScsiReqStatus = rcCompletion;
1024 if ((pReq->Cbw.bmCBWFlags & USBCBW_DIR_MASK) == USBCBW_DIR_OUT)
1026 pReq->enmState = USBMSDREQSTATE_STATUS;
1031 pReq->enmState = USBMSDREQSTATE_DATA_TO_HOST;
1050 Log(("usbMsdLun0ScsiRequestCompleted: freeing %p\n", pReq));
1051 usbMsdReqFree(pReq);
1113 if ( VALID_PTR(pThis->pReq)
1114 && pThis->pReq->enmState == USBMSDREQSTATE_EXECUTING)
1205 SSMR3PutBool(pSSM, pThis->pReq != NULL);
1207 if (pThis->pReq)
1209 PUSBMSDREQ pReq = pThis->pReq;
1211 SSMR3PutU32(pSSM, pReq->enmState);
1212 SSMR3PutU32(pSSM, pReq->cbBuf);
1213 if (pReq->cbBuf)
1215 AssertPtr(pReq->pbBuf);
1216 SSMR3PutMem(pSSM, pReq->pbBuf, pReq->cbBuf);
1219 SSMR3PutU32(pSSM, pReq->offBuf);
1220 SSMR3PutMem(pSSM, &pReq->Cbw, sizeof(pReq->Cbw));
1221 SSMR3PutU32(pSSM, pReq->ScsiReq.uLogicalUnit);
1222 SSMR3PutU32(pSSM, pReq->ScsiReq.uDataDirection);
1223 SSMR3PutU32(pSSM, pReq->ScsiReq.cbCDB);
1224 SSMR3PutU32(pSSM, pReq->ScsiReq.cbScatterGather);
1225 SSMR3PutMem(pSSM, &pReq->ScsiReqSense[0], sizeof(pReq->ScsiReqSense));
1226 SSMR3PutS32(pSSM, pReq->iScsiReqStatus);
1258 Assert(!pThis->pReq);
1268 PUSBMSDREQ pReq = usbMsdReqAlloc(pUsbIns);
1270 if (pReq)
1274 pThis->pReq = pReq;
1276 SSMR3GetU32(pSSM, (uint32_t *)&pReq->enmState);
1280 if (usbMsdReqEnsureBuffer(pReq, cbBuf))
1282 AssertPtr(pReq->pbBuf);
1283 Assert(cbBuf == pReq->cbBuf);
1284 SSMR3GetMem(pSSM, pReq->pbBuf, pReq->cbBuf);
1292 SSMR3GetU32(pSSM, &pReq->offBuf);
1293 SSMR3GetMem(pSSM, &pReq->Cbw, sizeof(pReq->Cbw));
1294 SSMR3GetU32(pSSM, &pReq->ScsiReq.uLogicalUnit);
1295 SSMR3GetU32(pSSM, (uint32_t *)&pReq->ScsiReq.uDataDirection);
1296 SSMR3GetU32(pSSM, &pReq->ScsiReq.cbCDB);
1297 SSMR3GetU32(pSSM, &pReq->ScsiReq.cbScatterGather);
1298 SSMR3GetMem(pSSM, &pReq->ScsiReqSense[0], sizeof(pReq->ScsiReqSense));
1299 SSMR3GetS32(pSSM, &pReq->iScsiReqStatus);
1302 pReq->ScsiReq.cbCDB = pReq->Cbw.bCBWCBLength;
1303 pReq->ScsiReq.pbCDB = &pReq->Cbw.CBWCB[0];
1304 pReq->ScsiReqSeg.pvSeg = pReq->pbBuf;
1305 pReq->ScsiReqSeg.cbSeg = pReq->ScsiReq.cbScatterGather;
1306 pReq->ScsiReq.cScatterGatherEntries = 1;
1307 pReq->ScsiReq.paScatterGatherHead = &pReq->ScsiReqSeg;
1308 pReq->ScsiReq.cbSenseBuffer = sizeof(pReq->ScsiReqSense);
1309 pReq->ScsiReq.pbSenseBuffer = &pReq->ScsiReqSense[0];
1310 pReq->ScsiReq.pvUser = NULL;
1399 * @param pReq The MSD request.
1404 static int usbMsdScsiIllegalRequest(PUSBMSD pThis, PUSBMSDREQ pReq, uint8_t bAsc, uint8_t bAscq, const char *pszWhy)
1408 RT_ZERO(pReq->ScsiReqSense);
1409 pReq->ScsiReqSense[0] = 0x80 | SCSI_SENSE_RESPONSE_CODE_CURR_FIXED;
1410 pReq->ScsiReqSense[2] = SCSI_SENSE_ILLEGAL_REQUEST;
1411 pReq->ScsiReqSense[7] = 10;
1412 pReq->ScsiReqSense[12] = SCSI_ASC_INVALID_MESSAGE;
1413 pReq->ScsiReqSense[13] = 0; /* Should be ASCQ but it has the same value for success. */
1415 usbMsdLun0ScsiRequestCompleted(&pThis->Lun0.IScsiPort, &pReq->ScsiReq, SCSI_STATUS_CHECK_CONDITION, false, VINF_SUCCESS);
1425 static int usbMsdHandleScsiReqestSense(PUSBMSD pThis, PUSBMSDREQ pReq, PCUSBCBW pCbw)
1427 Log(("usbMsdHandleScsiReqestSense: Entering EXECUTING (dCBWTag=%#x).\n", pReq->Cbw.dCBWTag));
1428 Assert(pReq == pThis->pReq);
1429 pReq->enmState = USBMSDREQSTATE_EXECUTING;
1433 return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INVALID_MESSAGE, 0, "direction");
1435 return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INVALID_MESSAGE, 0, "length");
1437 return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0, "lun");
1439 return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INVALID_MESSAGE, 0, "lun0");
1441 return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0, "out length");
1444 if ( pReq->iScsiReqStatus == SCSI_STATUS_OK
1445 && pReq->ScsiReqSense[0] == 0)
1447 RT_ZERO(pReq->ScsiReqSense);
1449 pReq->ScsiReqSense[0] = 0x80 | SCSI_SENSE_RESPONSE_CODE_CURR_FIXED;
1450 pReq->ScsiReqSense[0] = SCSI_SENSE_RESPONSE_CODE_CURR_FIXED;
1451 pReq->ScsiReqSense[2] = SCSI_SENSE_NONE;
1452 pReq->ScsiReqSense[7] = 10;
1453 pReq->ScsiReqSense[12] = SCSI_ASC_NONE;
1454 pReq->ScsiReqSense[13] = SCSI_ASC_NONE; /* Should be ASCQ but it has the same value for success. */
1459 size_t cbCopy = RT_MIN(pCbw->dCBWDataTransferLength, sizeof(pReq->ScsiReqSense));
1461 pCbw->CBWCB[4], pReq->iScsiReqStatus, pCbw->dCBWDataTransferLength, RT_MAX(1, cbCopy), pReq->ScsiReqSense));
1462 memcpy(pReq->pbBuf, &pReq->ScsiReqSense[0], cbCopy);
1464 usbMsdReqPrepare(pReq, pCbw);
1467 usbMsdLun0ScsiRequestCompleted(&pThis->Lun0.IScsiPort, &pReq->ScsiReq, SCSI_STATUS_OK, false, VINF_SUCCESS);
1478 * @param pReq The MSD request.
1481 static int usbMsdSubmitScsiCommand(PUSBMSD pThis, PUSBMSDREQ pReq, const char *pszCaller)
1483 Log(("%s: Entering EXECUTING (dCBWTag=%#x).\n", pszCaller, pReq->Cbw.dCBWTag));
1484 Assert(pReq == pThis->pReq);
1485 pReq->enmState = USBMSDREQSTATE_EXECUTING;
1487 switch (pReq->ScsiReq.pbCDB[0])
1494 return pThis->Lun0.pIScsiConnector->pfnSCSIRequestSend(pThis->Lun0.pIScsiConnector, &pReq->ScsiReq);
1534 PUSBMSDREQ pReq = pThis->pReq;
1535 USBMSDREQSTATE enmState = pReq ? pReq->enmState : USBMSDREQSTATE_READY;
1540 pReq->enmState = USBMSDREQSTATE_READY;
1601 if (!pReq)
1603 pReq = usbMsdReqAlloc(pThis->pUsbIns);
1604 if (!pReq)
1606 pThis->pReq = pReq;
1608 if (!usbMsdReqEnsureBuffer(pReq, pCbw->dCBWDataTransferLength))
1616 usbMsdHandleScsiReqestSense(pThis, pReq, pCbw);
1622 usbMsdReqPrepare(pReq, pCbw);
1624 if ( pReq->Cbw.dCBWDataTransferLength == 0
1625 || (pReq->Cbw.bmCBWFlags & USBCBW_DIR_MASK) == USBCBW_DIR_IN)
1627 int rc = usbMsdSubmitScsiCommand(pThis, pReq, "usbMsdHandleBulkHostToDev");
1637 pReq->enmState = USBMSDREQSTATE_DATA_FROM_HOST;
1650 uint32_t cbLeft = pReq->Cbw.dCBWDataTransferLength - pReq->offBuf;
1654 cbData, pReq->offBuf, pReq->Cbw.dCBWDataTransferLength, cbLeft));
1657 memcpy(&pReq->pbBuf[pReq->offBuf], &pUrb->abData[0], cbData);
1658 pReq->offBuf += cbData;
1660 if (pReq->offBuf == pReq->Cbw.dCBWDataTransferLength)
1662 int rc = usbMsdSubmitScsiCommand(pThis, pReq, "usbMsdHandleBulkHostToDev");
1697 PUSBMSDREQ pReq = pThis->pReq;
1698 if (RT_UNLIKELY(pEp->fHalted || !pReq))
1704 switch (pReq->enmState)
1712 uint32_t cbCopy = pReq->Cbw.dCBWDataTransferLength - pReq->offBuf;
1718 cbData, pReq->offBuf, pReq->Cbw.dCBWDataTransferLength, cbCopy));
1721 memcpy(&pUrb->abData[0], &pReq->pbBuf[pReq->offBuf], cbCopy);
1722 pReq->offBuf += cbCopy;
1724 if (pReq->offBuf == pReq->Cbw.dCBWDataTransferLength)
1727 pReq->enmState = USBMSDREQSTATE_STATUS;
1746 pCsw->dCSWTag = pReq->Cbw.dCBWTag;
1747 pCsw->bCSWStatus = pReq->iScsiReqStatus == SCSI_STATUS_OK
1749 : pReq->iScsiReqStatus >= 0
1754 if ((pReq->Cbw.bmCBWFlags & USBCBW_DIR_MASK) == USBCBW_DIR_OUT)
1756 ? pReq->Cbw.dCBWDataTransferLength - pReq->ScsiReq.cbScatterGather
1757 : pReq->Cbw.dCBWDataTransferLength;
1761 : pReq->ScsiReq.cbScatterGather;
1766 pReq->enmState = USBMSDREQSTATE_READY;
1786 pReq->ScsiReq.cbScatterGather = pReq->offBuf;
1787 pReq->ScsiReqSeg.cbSeg = pReq->offBuf;
1788 if (!pReq->offBuf)
1791 pReq->enmState = USBMSDREQSTATE_EXECUTING;
1796 usbMsdLun0ScsiRequestCompleted(&pThis->Lun0.IScsiPort, &pReq->ScsiReq, SCSI_STATUS_OK, false, VINF_SUCCESS);
1800 int rc = usbMsdSubmitScsiCommand(pThis, pReq, "usbMsdHandleBulkDevToHost");
1823 Log(("usbMsdHandleBulkDevToHost: enmState=READ (cbData=%#x)\n", pReq->enmState, pUrb->cbData));
1827 Log(("usbMsdHandleBulkDevToHost: enmState=%d cbData=%#x\n", pReq->enmState, pUrb->cbData));
2180 if (pThis->pReq)
2182 usbMsdReqFree(pThis->pReq);
2183 pThis->pReq = NULL;