Lines Matching refs:pipe

113     const HostDevice *dev, UsbInterface *interface, uint8_t pipeAddr, UsbPipeInfo *pipe)

121     if (dev == nullptr || interface == nullptr || pipe == nullptr) {

140         if (pipe) {

141             *pipe = pipeTmp;

148 int32_t UsbdDispatcher::GetPipe(const HostDevice *dev, uint8_t interfaceId, uint8_t pipeId, UsbPipeInfo *pipe)

150     if (dev == nullptr || pipe == nullptr) {

151         HDF_LOGE("%{public}s:dev or pipe is nullptr, ifId:%{public}u epId:%{public}u", __func__, interfaceId, pipeId);

166     int32_t ret = GetInterfacePipe(dev, interface, pipeId, pipe);

183     UsbPipeInfo *pipe = static_cast<UsbPipeInfo *>(OsalMemCalloc(sizeof(UsbPipeInfo)));

184     if (pipe == nullptr) {

189     int32_t ret = UsbGetPipeInfo(dev->ctrDevHandle, dev->ctrIface->info.curAltSetting, 0, pipe);

191         HDF_LOGE("%{public}s:get pipe failed ret:%{public}d", __func__, ret);

192         OsalMemFree(pipe);

193         pipe = nullptr;

197     dev->ctrPipe = pipe;

218         if (req->pipe.interfaceId == interfaceId && ((req->pipe.pipeAddress | req->pipe.pipeDirection) == pipeAddr)) {

246 void UsbdDispatcher::UsbRequestParamsWSyncInit(UsbRequestParams *params, int32_t timeout, const UsbPipeInfo *pipe)

248     if (params == nullptr || pipe == nullptr) {

249         HDF_LOGE("%{public}s: params or pipe is nullptr", __func__);

253     params->interfaceId = pipe->interfaceId;

254     params->pipeAddress = pipe->pipeDirection | pipe->pipeAddress;

255     params->pipeId = pipe->pipeId;

259     params->dataReq.directon = static_cast<UsbRequestDirection>((pipe->pipeDirection >> USB_DIR_OFFSET) & 0x1);

260     params->dataReq.length = pipe->maxPacketSize;

264     HostDevice *port, UsbInterfaceHandle *ifHandle, UsbPipeInfo *pipe, UsbdRequestSync *requestSync)

266     if (port == nullptr || requestSync == nullptr || ifHandle == nullptr || pipe == nullptr) {

271     int32_t ret = memcpy_s(&requestSync->pipe, sizeof(UsbPipeInfo), pipe, sizeof(UsbPipeInfo));

278     requestSync->request = UsbAllocRequest(requestSync->ifHandle, 0, requestSync->pipe.maxPacketSize);

283     UsbRequestParamsWSyncInit(&requestSync->params, USB_CTRL_SET_TIMEOUT, &requestSync->pipe);

292     UsbPipeInfo *pipe, int32_t length, UsbdRequestSync *requestSync)

294     if (port == nullptr || requestSync == nullptr || ifHandle == nullptr || pipe == nullptr) {

299     int32_t ret = memcpy_s(&requestSync->pipe, sizeof(UsbPipeInfo), pipe, sizeof(UsbPipeInfo));

311     UsbRequestParamsWSyncInit(&requestSync->params, USB_CTRL_SET_TIMEOUT, &requestSync->pipe);

704     UsbdRequestASync *userData, UsbPipeInfo *pipe, UsbRequestParams *params, const uint8_t *buffer, uint32_t length)

706     if (userData == nullptr || pipe == nullptr || params == nullptr) {

711     bool bWrite = (pipe->pipeDirection == USB_PIPE_DIRECTION_OUT);

712     params->interfaceId = pipe->interfaceId;

713     params->pipeAddress = pipe->pipeDirection | pipe->pipeAddress;

714     params->pipeId = pipe->pipeId;

720     params->dataReq.directon = static_cast<UsbRequestDirection>((pipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & 0x1);

748     HostDevice *port, UsbInterfaceHandle *ifHandle, UsbPipeInfo *pipe, UsbdRequestASync *request)

750     if (port == nullptr || request == nullptr || ifHandle == nullptr || pipe == nullptr) {

755     int32_t ret = memcpy_s(&request->pipe, sizeof(UsbPipeInfo), pipe, sizeof(UsbPipeInfo));

762     request->reqMsg.request = UsbAllocRequest(request->ifHandle, 0, request->pipe.maxPacketSize);

767     FillReqAyncParams(request, &request->pipe, &request->params, nullptr, 0);

777     UsbPipeInfo pipe;

778     if (memset_s(&pipe, sizeof(UsbPipeInfo), 0, sizeof(UsbPipeInfo)) != EOK) {

783     int32_t ret = GetPipe(port, interfaceId, pipeAddr, &pipe);

785         HDF_LOGE("%{public}s: get pipe info failed interfaceId=%{public}d, pipeAddr=%{public}d", __func__, interfaceId,

801     ret = UsbdRequestASyncInit(port, ifHandle, &pipe, req);

1053         list->node[i].request = UsbAllocRequest(pList->ifHandle, 0, pList->pipe.maxPacketSize);

1081     UsbPipeInfo pipe;

1082     if (memset_s(&pipe, sizeof(UsbPipeInfo), 0, sizeof(UsbPipeInfo)) != EOK) {

1087     int32_t ret = GetPipe(port, ifId, epId, &pipe);

1108     bulkAsyncList->pipe = pipe;

1110     UsbdBulkASyncReqFillParams(&bulkAsyncList->pipe, &bulkAsyncList->params, nullptr);

1283     ret = UsbdBulkAsyncGetAsmData(&db->list->pList->asmHandle, &params, db->list->pList->pipe.maxPacketSize);

1316     ret = UsbdBulkAsyncGetAsmReqLen(&db->list->pList->asmHandle, &readLen, db->list->pList->pipe.maxPacketSize);

1431 int32_t UsbdDispatcher::UsbdBulkASyncReqFillParams(UsbPipeInfo *pipe, UsbRequestParams *params, uint8_t *buffer)

1433     params->interfaceId = pipe->interfaceId;

1434     params->pipeAddress = pipe->pipeDirection | pipe->pipeAddress;

1435     params->pipeId = pipe->pipeId;

1439     params->dataReq.directon = static_cast<UsbRequestDirection>((pipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & 0x1);

1440     params->dataReq.length = pipe->maxPacketSize;

1442     if (pipe->pipeDirection == USB_PIPE_DIRECTION_OUT) {

1461     ret = UsbdBulkAsyncGetAsmData(&req->list->pList->asmHandle, &params, req->list->pList->pipe.maxPacketSize);

1485     int32_t ret = UsbdBulkAsyncGetAsmReqLen(&db->list->pList->asmHandle, &readLen, db->list->pList->pipe.maxPacketSize);