Lines Matching refs:request

128     controlParams->request = USB_DDK_REQ_GET_DESCRIPTOR;

146     controlParams->request = USB_DDK_REQ_GET_CONFIGURATION;

169     UsbRequest *request = nullptr;

171         request = UsbAllocRequest(dev->ctrDevHandle, 0, MAX_CONTROL_BUFF_SIZE);

172         if (request == nullptr) {

175         dev->ctrlReq = request;

177         request = dev->ctrlReq;

187         ret = UsbFillRequest(request, dev->ctrDevHandle, &params);

193         ret = UsbSubmitRequestSync(request);

200             ret = memcpy_s(ctrParams->data, ctrParams->size, request->compInfo.buffer, request->compInfo.actualLength);

206                 ctrParams->size < request->compInfo.actualLength ? ctrParams->size : request->compInfo.actualLength;

222     controlParams->request = USB_DDK_REQ_SET_CONFIGURATION;

352     HostDevice *port, uint8_t interfaceId, uint8_t pipeAddr, UsbdRequestSync **request)

354     if (port == nullptr || request == nullptr) {

359     *request = nullptr;

362         *request = requestSync;

400     *request = requestSync;

405     uint8_t pipeAddr, int32_t length, UsbdRequestSync **request)

407     if (port == nullptr || request == nullptr) {

412     *request = nullptr;

415         struct UsbIfRequest *requestObj = (struct UsbIfRequest *)requestSync->request;

417             *request = requestSync;

457     *request = requestSync;

464     if (requestSync == nullptr || requestSync->request == nullptr || buffer == nullptr || actlength == nullptr ||

475     ret = UsbFillRequest(requestSync->request, requestSync->ifHandle, &requestSync->params);

482     struct UsbIfRequest* requestObj = (struct UsbIfRequest *)requestSync->request;

486     ret = UsbSubmitRequestSync(requestSync->request);

488         ret = memcpy_s(buffer + tcur, size - tcur, requestSync->request->compInfo.buffer,

489             requestSync->request->compInfo.actualLength);

495         tcur += requestSync->request->compInfo.actualLength;

524         ret = UsbFillRequest(requestSync->request, requestSync->ifHandle, &requestSync->params);

530         ret = UsbSubmitRequestSync(requestSync->request);

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

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

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

654         HDF_LOGE("%{public}s:request msg is nullptr", __func__);

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) {

691 int32_t UsbImpl::UsbdRequestASyncReleaseData(UsbdRequestASync *request)

693     if (request == nullptr) {

694         HDF_LOGE("%{public}s: invalid param request is nullptr", __func__);

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;

710     request->status = 0;

865             int32_t ret = UsbCancelRequest(list->rList.node[i].request);

875         list->rList.node[i].request->compInfo.status = UsbRequestStatus::USB_REQUEST_COMPLETED;

877             list->rList.node[i].request->compInfo.status = UsbRequestStatus::USB_REQUEST_COMPLETED;

1595     controlParams.request = static_cast<uint8_t>(ctrl.requestCmd);

1637     controlParams.request = static_cast<uint8_t>(ctrl.requestCmd);

1672     controlParams.request = static_cast<uint8_t>(ctrlParams.requestCmd);

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) {

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

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

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

1916                 HDF_LOGW("%{public}s:request cancel failed = %{public}d", __func__, ret);