Lines Matching defs:reqMsg

602     int32_t ret = UsbFillRequest(reqAsync->reqMsg.request, reqAsync->ifHandle, &reqAsync->params);

606         reqAsync->reqMsg.clientData = nullptr;

607         reqAsync->reqMsg.clientLength = 0;

615     UsbIfRequest *requestConvertVal = reinterpret_cast<UsbIfRequest *>(reqAsync->reqMsg.request);

617     ret = UsbSubmitRequestAsync(reqAsync->reqMsg.request);

626         reqAsync->reqMsg.clientData = nullptr;

627         reqAsync->reqMsg.clientLength = 0;

635 int32_t UsbImpl::GetRequestMsgFromQueue(HostDevice *port, UsbdRequestASync **reqMsg)

637     if (port == nullptr || reqMsg == nullptr) {

638         HDF_LOGE("%{public}s: port or reqMsg is nullptr", __func__);

652     *reqMsg = HDF_SLIST_CONTAINER_OF(HdfSListNode, requestNode, UsbdRequestASync, qNode);

653     if (*reqMsg == nullptr) {

661     HostDevice *port, UsbdRequestASync *reqMsg, int32_t timeout, uint8_t **buffer, uint32_t *length)

663     if (port == nullptr || reqMsg == nullptr || reqMsg->reqMsg.request == nullptr) {

669     UsbIfRequest *reqValue = reinterpret_cast<UsbIfRequest *>(reqMsg->reqMsg.request);

670     if (static_cast<int32_t>(reqMsg->reqMsg.request->compInfo.status) == -1) {

675             HdfSListAdd(&port->requestQueue, &reqMsg->qNode);

681     OsalMutexLock(&reqMsg->lock);

682     *length = reqMsg->reqMsg.length;

683     *buffer = static_cast<uint8_t *>(reqMsg->reqMsg.buffer);

684     reqMsg->reqMsg.buffer = nullptr;

685     reqMsg->reqMsg.length = 0;

686     reqMsg->status = 0;

687     OsalMutexUnlock(&reqMsg->lock);

698     if (request->reqMsg.buffer != nullptr) {

700         OsalMemFree(request->reqMsg.buffer);

701         request->reqMsg.buffer = nullptr;

703     request->reqMsg.length = 0;

704     if (request->reqMsg.clientData) {

706         OsalMemFree(request->reqMsg.clientData);

707         request->reqMsg.clientData = nullptr;

709     request->reqMsg.clientLength = 0;

1845     reqAsync->reqMsg.clientData = static_cast<void *>(clientDataAddr);

1846     reqAsync->reqMsg.clientLength = sizeof(uint8_t) * clientData.size();

1868     UsbdRequestASync *reqMsg = nullptr;

1869     int32_t ret = GetRequestMsgFromQueue(port, &reqMsg);

1870     if (ret != HDF_SUCCESS || reqMsg == nullptr || reqMsg->reqMsg.request == nullptr) {

1875     UsbIfRequest *reqValue = reinterpret_cast<UsbIfRequest *>(reqMsg->reqMsg.request);

1876     if (static_cast<int32_t>(reqMsg->reqMsg.request->compInfo.status) == -1) {

1881             HdfSListAdd(&port->requestQueue, &reqMsg->qNode);

1889     ret = GetRequestMsgData(port, reqMsg, timeout, &buf, &length);

1895     uint8_t *clientDataAddr = static_cast<uint8_t *>(reqMsg->reqMsg.clientData);

1896     uint8_t *bufferAddr = static_cast<uint8_t *>(reqMsg->reqMsg.request->compInfo.buffer);

1897     clientData.assign(clientDataAddr, clientDataAddr + reqMsg->reqMsg.clientLength);

1898     buffer.assign(bufferAddr, bufferAddr + reqMsg->reqMsg.request->compInfo.length);

1899     UsbdRequestASyncReleaseData(reqMsg);

1911     UsbdRequestASync *reqMsg = nullptr;

1912     while (GetRequestMsgFromQueue(port, &reqMsg) == HDF_SUCCESS) {

1913         if (reqMsg) {

1914             int32_t ret = UsbCancelRequest(reqMsg->reqMsg.request);

1918             OsalMutexLock(&reqMsg->lock);

1919             UsbdRequestASyncReleaseData(reqMsg);

1920             reqMsg->status = 0;

1921             OsalMutexUnlock(&reqMsg->lock);