1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "usbd_dispatcher.h"
17 #include <errno.h>
18 #include <sys/mman.h>
19 #include <sys/types.h>
20 #include <unistd.h>
21 #include "hdf_log.h"
22 #include "hdf_device_object.h"
23 #include "osal_mem.h"
24 #include "osal_time.h"
25 #include "securec.h"
26 #include "usb_interface_pool.h"
27 #include "usbd.h"
28 #include "usbd_function.h"
29 #include "usbd_port.h"
30 #include "usbd_publisher.h"
31
32 #define HDF_LOG_TAG Usbd
33
34 #define MAX_BUFF_SIZE 16384
35 #define MAX_CONTROL_BUFF_SIZE 1024
36 #define READ_BUF_SIZE 8192
37
38 #define USB_CTRL_SET_TIMEOUT 5000
39 #define GET_STRING_SET_TIMEOUT 50
40 #define USB_PIPE_DIR_OFFSET 7
41 #define CHARFORMAT 8
42 #define USB_REUQEST_SLEEP_TIME 100
43 #define USB_MAX_DESCRIPTOR_SIZE 256
44 #define USB_BULK_CALLBACK_SLEEP_TIME 500
45 #define USB_BULK_CANCEL_SLEEP_TIME 1000
46
47 #define OPEN_SLEPP_TIME 1
48 #define SUBMIT_SLEEP_TIME 1
49 #define USBD_ASYNC_GETENODE_TIME 1
50 #define USBD_ASYNC_GETENODE_TRY 3
51
52 #define POS_STEP 3
53
54 #define MULTIPLE 3
55 #define ADD_NUM_50 100
56 #define ERROR_0 0
57
58 #define USB_RECIP_MASK 0x1F
59 #define ENDPOINT_DIRECTION_MASK 0x1
60 #define CMD_TYPE_MASK 0x3
61
62 #define MAX_REQUESTASYNC_NUM 20
63
64 static const int32_t CMD_OFFSET_5 = 5;
65 static const int32_t DIRECTION_OFFSET_7 = 7;
66 static const int32_t TYPE_OFFSET_8 = 8;
67 static const char* USB_TOKEN_VALUE = "UsbdBulkCallback.V1_0";
68
69 enum UsbdReqNodeStatus {
70 USBD_REQNODE_INIT,
71 USBD_REQNODE_NOUSE,
72 USBD_REQNODE_USE,
73 USBD_REQNODE_OTHER,
74 };
75
76 int32_t UsbdRealseDevices(struct UsbdService *service);
77 int32_t UsbdDeviceCreateAndAttach(struct UsbdService *service, uint8_t busNum, uint8_t devAddr);
78 int32_t UsbdDeviceDettach(struct UsbdService *service, uint8_t busNum, uint8_t devAddr);
79 int32_t UsbdRemoveBusDev(struct UsbdService *service, uint8_t busNum);
80
UsbdHdfWriteBuf(struct HdfSBuf * data,uint8_t * buffer,uint32_t length)81 static bool UsbdHdfWriteBuf(struct HdfSBuf *data, uint8_t *buffer, uint32_t length)
82 {
83 if ((!data) || ((length > 0) && (!buffer))) {
84 HDF_LOGE("%{public}s:%{public}d hdfwritebuf failed", __func__, __LINE__);
85 return false;
86 }
87 if (length == 0) {
88 return HdfSbufWriteUint32(data, length);
89 }
90 return HdfSbufWriteBuffer(data, (const void *)buffer, length);
91 }
92
ParseDeviceBuf(struct HdfSBuf * data,uint8_t * busNum,uint8_t * devAddr)93 static int32_t ParseDeviceBuf(struct HdfSBuf *data, uint8_t *busNum, uint8_t *devAddr)
94 {
95 if (data == NULL || busNum == NULL || devAddr == NULL) {
96 HDF_LOGE("%{public}s:%{public}d devicebuf failed", __func__, __LINE__);
97 return HDF_ERR_INVALID_PARAM;
98 }
99 HdfSbufReadUint8(data, busNum);
100 HdfSbufReadUint8(data, devAddr);
101 return HDF_SUCCESS;
102 }
103
UsbdAllocFifo(struct DataFifo * fifo,uint32_t size)104 static int32_t UsbdAllocFifo(struct DataFifo *fifo, uint32_t size)
105 {
106 if (!DataFifoIsInitialized(fifo)) {
107 void *data = OsalMemAlloc(size);
108 if (data == NULL) {
109 HDF_LOGE("%{public}s:%{public}d allocate failed", __func__, __LINE__);
110 return HDF_ERR_MALLOC_FAIL;
111 }
112 DataFifoInit(fifo, size, data);
113 }
114 return HDF_SUCCESS;
115 }
116
UsbdFreeFifo(struct DataFifo * fifo)117 static void UsbdFreeFifo(struct DataFifo *fifo)
118 {
119 if (fifo == NULL) {
120 HDF_LOGE("%{public}s:%{public}d fifo is NULL", __func__, __LINE__);
121 return;
122 }
123
124 OsalMemFree(fifo->data);
125 fifo->data = NULL;
126
127 DataFifoInit(fifo, 0, NULL);
128 }
129
UsbdReadCallback(struct UsbRequest * req)130 static void UsbdReadCallback(struct UsbRequest *req)
131 {
132 struct UsbIfRequest *reqObj = (struct UsbIfRequest *)req;
133 if (req == NULL) {
134 HDF_LOGE("%{public}s:%{pulib}d req is NULL!", __func__, __LINE__);
135 return;
136 }
137 struct UsbdRequestASync *dev = (struct UsbdRequestASync *)req->compInfo.userData;
138 if (dev == NULL) {
139 HDF_LOGE("%{public}s:%{pulib}d dev is NULL!", __func__, __LINE__);
140 OsalSemPost(&reqObj->hostRequest->sem);
141 return;
142 }
143 }
144
UsbdWriteCallback(struct UsbRequest * req)145 static void UsbdWriteCallback(struct UsbRequest *req)
146 {
147 if (req == NULL) {
148 HDF_LOGE("%{public}s:%{pulib}d req is NULL!", __func__, __LINE__);
149 return;
150 }
151 int32_t status = req->compInfo.status;
152 HDF_LOGI("%{public}s:%{pulib}d statue is %d!", __func__, __LINE__, status);
153 return;
154 }
155
InterfaceIdToHandle(const struct HostDevice * dev,uint8_t id)156 static UsbInterfaceHandle *InterfaceIdToHandle(const struct HostDevice *dev, uint8_t id)
157 {
158 UsbInterfaceHandle *devHandle = NULL;
159
160 if (id == 0xFF) {
161 devHandle = dev->ctrDevHandle;
162 } else if (id < USB_MAX_INTERFACES) {
163 return dev->devHandle[id];
164 }
165 return devHandle;
166 }
167
UsbControlSetUp(struct UsbControlParams * controlParams,struct UsbControlRequest * controlReq)168 static int32_t UsbControlSetUp(struct UsbControlParams *controlParams, struct UsbControlRequest *controlReq)
169 {
170 if (controlParams == NULL || controlReq == NULL) {
171 HDF_LOGE("%{public}s:%{public}d param is null", __func__, __LINE__);
172 return HDF_ERR_INVALID_PARAM;
173 }
174
175 controlReq->target = controlParams->target;
176 controlReq->reqType = controlParams->reqType;
177 controlReq->directon = controlParams->directon;
178 controlReq->request = controlParams->request;
179 controlReq->value = CpuToLe16(controlParams->value);
180 controlReq->index = CpuToLe16(controlParams->index);
181 controlReq->buffer = controlParams->data;
182 controlReq->length = CpuToLe16(controlParams->size);
183 return HDF_SUCCESS;
184 }
185
GetUsbInterfaceById(const struct HostDevice * dev,uint8_t interfaceIndex)186 static struct UsbInterface *GetUsbInterfaceById(const struct HostDevice *dev, uint8_t interfaceIndex)
187 {
188 if (!dev || (dev->service == NULL)) {
189 HDF_LOGE("%{public}s:%{public}d idx:%{public}d service is null", __func__, __LINE__, interfaceIndex);
190 return NULL;
191 }
192 struct UsbInterface *tmpIf = UsbClaimInterface(dev->service->session, dev->busNum, dev->devAddr, interfaceIndex);
193 return tmpIf;
194 }
195
GetInterfacePipe(const struct HostDevice * dev,struct UsbInterface * interface,uint8_t pipeAddr,struct UsbPipeInfo * pipe)196 static int32_t GetInterfacePipe(const struct HostDevice *dev, struct UsbInterface *interface, uint8_t pipeAddr,
197 struct UsbPipeInfo *pipe)
198 {
199 int32_t ret = HDF_FAILURE;
200 struct UsbInterfaceInfo *info = NULL;
201 UsbInterfaceHandle *interfaceHandle = NULL;
202 struct UsbPipeInfo pipeTmp;
203 if (memset_s(&pipeTmp, sizeof(pipeTmp), 0, sizeof(pipeTmp)) != EOK) {
204 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
205 return HDF_FAILURE;
206 }
207 if (dev == NULL || interface == NULL || pipe == NULL) {
208 HDF_LOGE("%{public}s:%{public}d invalid parmas", __func__, __LINE__);
209 return HDF_ERR_INVALID_PARAM;
210 }
211 info = &interface->info;
212 if (info == NULL) {
213 HDF_LOGE("%{public}s:%{public}d invalid interface", __func__, __LINE__);
214 return HDF_FAILURE;
215 }
216
217 interfaceHandle = InterfaceIdToHandle(dev, info->interfaceIndex);
218 if (interfaceHandle == NULL) {
219 HDF_LOGE("%{public}s:%{public}d invalid interface handle", __func__, __LINE__);
220 return HDF_FAILURE;
221 }
222
223 for (uint8_t i = 1; i <= info->pipeNum; ++i) {
224 ret = UsbGetPipeInfo(interfaceHandle, info->curAltSetting, i, &pipeTmp);
225 if ((ret == HDF_SUCCESS) && ((pipeTmp.pipeAddress | (uint8_t)pipeTmp.pipeDirection) == pipeAddr)) {
226 if (pipe) {
227 *pipe = pipeTmp;
228 }
229 return HDF_SUCCESS;
230 }
231 }
232 return HDF_FAILURE;
233 }
234
GetPipe(const struct HostDevice * dev,uint8_t interfaceId,uint8_t pipeId,struct UsbPipeInfo * pipe)235 static int32_t GetPipe(const struct HostDevice *dev, uint8_t interfaceId, uint8_t pipeId, struct UsbPipeInfo *pipe)
236 {
237 if (dev == NULL) {
238 HDF_LOGE("%{public}s:%{public}d invalid params ifId:%{public}d epId:%{public}d", __func__, __LINE__,
239 interfaceId, pipeId);
240 return HDF_ERR_INVALID_PARAM;
241 }
242 if (interfaceId > USB_MAX_INTERFACES) {
243 HDF_LOGE("%{public}s:%{public}d invalid params ifId:%{public}d epId:%{public}d", __func__, __LINE__,
244 interfaceId, pipeId);
245 return HDF_ERR_INVALID_PARAM;
246 }
247 struct UsbInterface *interface = dev->iface[interfaceId];
248 if (interface == NULL) {
249 HDF_LOGE(
250 "%{public}s:%{public}d invalid interface ifId:%{public}d "
251 "epId:%{public}d",
252 __func__, __LINE__, interfaceId, pipeId);
253 return HDF_FAILURE;
254 }
255
256 int32_t ret = GetInterfacePipe(dev, interface, pipeId, pipe);
257 return ret;
258 }
259
UsbdFreeCtrlPipe(struct HostDevice * dev)260 static void UsbdFreeCtrlPipe(struct HostDevice *dev)
261 {
262 if (dev == NULL) {
263 HDF_LOGW("%{public}s:%{public}d params dev is null", __func__, __LINE__);
264 return;
265 }
266 OsalMemFree(dev->ctrPipe);
267 dev->ctrPipe = NULL;
268 }
269
UsbdGetCtrlPipe(struct HostDevice * dev)270 static int32_t UsbdGetCtrlPipe(struct HostDevice *dev)
271 {
272 struct UsbPipeInfo *pipe = (struct UsbPipeInfo *)OsalMemAlloc(sizeof(struct UsbPipeInfo));
273 if (pipe == NULL) {
274 HDF_LOGE("%{public}s:%{public}d OsalMemAlloc failed", __func__, __LINE__);
275 return HDF_ERR_MALLOC_FAIL;
276 }
277
278 if (memset_s(pipe, sizeof(struct UsbPipeInfo), 0, sizeof(struct UsbPipeInfo)) != EOK) {
279 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
280 OsalMemFree(pipe);
281 return HDF_FAILURE;
282 }
283 int32_t ret = UsbGetPipeInfo(dev->ctrDevHandle, dev->ctrIface->info.curAltSetting, 0, pipe);
284 if (ret != HDF_SUCCESS) {
285 HDF_LOGE("%{public}s:%{public}d get pipe failed ret = %{public}d", __func__, __LINE__, ret);
286 OsalMemFree(pipe);
287 pipe = NULL;
288 return HDF_FAILURE;
289 }
290 dev->ctrPipe = pipe;
291
292 return HDF_SUCCESS;
293 }
294
UsbdBulkReadSyncGetParams(struct HdfSBuf * data,uint8_t * ifId,uint8_t * pipeId,int32_t * timeout)295 static int32_t UsbdBulkReadSyncGetParams(struct HdfSBuf *data, uint8_t *ifId, uint8_t *pipeId, int32_t *timeout)
296 {
297 if ((ifId == NULL) || (data == NULL) || (pipeId == NULL) || (timeout == NULL)) {
298 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
299 return HDF_ERR_INVALID_PARAM;
300 }
301
302 if (!HdfSbufReadUint8(data, ifId)) {
303 HDF_LOGE("%{public}s:%{public}d read interfaceId error", __func__, __LINE__);
304 return HDF_ERR_IO;
305 }
306 if (!HdfSbufReadUint8(data, pipeId)) {
307 HDF_LOGE("%{public}s:%{public}d read pipeId error", __func__, __LINE__);
308 return HDF_ERR_IO;
309 }
310 if (!HdfSbufReadInt32(data, timeout)) {
311 HDF_LOGE("%{public}s:%{public}d read timeout error", __func__, __LINE__);
312 return HDF_ERR_IO;
313 }
314
315 return HDF_SUCCESS;
316 }
317
UsbdBulkReadSyncBase(int32_t timeout,uint8_t * buffer,uint32_t size,uint32_t * actlength,struct UsbdRequestSync * requestSync)318 static int32_t UsbdBulkReadSyncBase(int32_t timeout, uint8_t *buffer, uint32_t size, uint32_t *actlength,
319 struct UsbdRequestSync *requestSync)
320 {
321 int32_t ret = HDF_FAILURE;
322 if ((!requestSync) || (!buffer) || (!actlength) || (size < 1) || (!requestSync->request)) {
323 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
324 return HDF_ERR_INVALID_PARAM;
325 }
326 uint64_t intTimeout = timeout < 0 ? 0 : timeout;
327 int32_t timeonce = 500;
328 uint64_t stime = OsalGetSysTimeMs();
329 uint64_t ntime = 0;
330 uint32_t tcur = 0;
331 uint32_t msize = 0;
332 OsalMutexLock(&requestSync->lock);
333 requestSync->params.timeout = timeonce;
334 msize = requestSync->pipe.maxPacketSize;
335 while (tcur + msize < size) {
336 ret = UsbFillRequest(requestSync->request, requestSync->ifHandle, &requestSync->params);
337 if (HDF_SUCCESS != ret) {
338 HDF_LOGE("%{public}s: UsbFillRequest faile, ret=%{public}d \n", __func__, ret);
339 break;
340 }
341 ret = UsbSubmitRequestSync(requestSync->request);
342 if (HDF_SUCCESS == ret) {
343 memcpy_s(buffer + tcur, size - tcur, requestSync->request->compInfo.buffer,
344 requestSync->request->compInfo.actualLength);
345 tcur += requestSync->request->compInfo.actualLength;
346 } else if (HDF_ERR_TIMEOUT == ret) {
347 if (tcur > 0) {
348 ret = HDF_SUCCESS;
349 break;
350 }
351 ntime = OsalGetSysTimeMs();
352 if ((intTimeout == 0) || (ntime < stime + intTimeout)) {
353 continue;
354 } else {
355 HDF_LOGE("%{public}s:%{public}d tcur:%{public}d ret:%{public}d", __func__, __LINE__, tcur, ret);
356 break;
357 }
358 } else {
359 HDF_LOGE("%{public}s:%{public}d tcur:%{public}d ret:%{public}d", __func__, __LINE__, tcur, ret);
360 break;
361 }
362 }
363 OsalMutexUnlock(&requestSync->lock);
364 *actlength = tcur;
365 return ret;
366 }
367
UsbdFindRequestSync(struct HostDevice * port,uint8_t interfaceId,uint8_t pipeAddr)368 static struct UsbdRequestSync *UsbdFindRequestSync(struct HostDevice *port, uint8_t interfaceId, uint8_t pipeAddr)
369 {
370 struct UsbdRequestSync *req = NULL;
371 struct HdfSListIterator it;
372 bool flag = false;
373 if (!port) {
374 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
375 return NULL;
376 }
377 OsalMutexLock(&port->reqSyncLock);
378 HdfSListIteratorInit(&it, &port->reqSyncList);
379 while (HdfSListIteratorHasNext(&it)) {
380 req = (struct UsbdRequestSync *)HdfSListIteratorNext(&it);
381 if (!req) {
382 continue;
383 }
384 if ((req->pipe.interfaceId == interfaceId) && ((req->pipe.pipeAddress | req->pipe.pipeDirection) == pipeAddr)) {
385 flag = true;
386 break;
387 }
388 }
389 OsalMutexUnlock(&port->reqSyncLock);
390
391 if (flag) {
392 return req;
393 }
394 HDF_LOGE("%{public}s:%{public}d req null", __func__, __LINE__);
395 return NULL;
396 }
397
UsbdRequestSyncAlloc(void)398 static struct UsbdRequestSync *UsbdRequestSyncAlloc(void)
399 {
400 struct UsbdRequestSync *req = NULL;
401 req = (struct UsbdRequestSync *)OsalMemAlloc(sizeof(struct UsbdRequestSync));
402 if (req) {
403 if (memset_s(req, sizeof(struct UsbdRequestSync), 0, sizeof(struct UsbdRequestSync)) != EOK) {
404 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
405 OsalMemFree(req);
406 return NULL;
407 }
408 req->request = NULL;
409 req->endPointAddr = 0;
410 req->ifHandle = NULL;
411 OsalMutexInit(&req->lock);
412 }
413 return req;
414 }
415
UsbRequestParamsWSyncInit(struct UsbRequestParams * parmas,int32_t timeout,const struct UsbPipeInfo * pipe)416 static void UsbRequestParamsWSyncInit(struct UsbRequestParams *parmas, int32_t timeout, const struct UsbPipeInfo *pipe)
417 {
418 if (parmas == NULL || pipe == NULL) {
419 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
420 return;
421 }
422 parmas->interfaceId = pipe->interfaceId;
423 parmas->pipeAddress = pipe->pipeDirection | pipe->pipeAddress;
424 parmas->pipeId = pipe->pipeId;
425 parmas->requestType = USB_REQUEST_PARAMS_DATA_TYPE;
426 parmas->timeout = timeout;
427 parmas->dataReq.numIsoPackets = 0;
428
429 parmas->dataReq.directon = (pipe->pipeDirection >> USB_DIR_OFFSET) & 0x1;
430 parmas->dataReq.length = pipe->maxPacketSize;
431 return;
432 }
433
UsbdRequestSyncInit(struct HostDevice * port,UsbInterfaceHandle * ifHandle,struct UsbPipeInfo * pipe,struct UsbdRequestSync * requestSync)434 static int32_t UsbdRequestSyncInit(struct HostDevice *port, UsbInterfaceHandle *ifHandle,
435 struct UsbPipeInfo *pipe, struct UsbdRequestSync *requestSync)
436 {
437 int32_t ret = HDF_SUCCESS;
438 if ((port == NULL) || (requestSync == NULL) || (ifHandle == NULL) || (pipe == NULL)) {
439 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
440 return HDF_ERR_INVALID_PARAM;
441 }
442 memcpy_s(&requestSync->pipe, sizeof(struct UsbPipeInfo), pipe, sizeof(struct UsbPipeInfo));
443 requestSync->ifHandle = ifHandle;
444 requestSync->request = UsbAllocRequest(requestSync->ifHandle, 0, requestSync->pipe.maxPacketSize);
445 if (!requestSync->request) {
446 HDF_LOGE("%{public}s:%{public}d alloc request faild\n", __func__, __LINE__);
447 return HDF_ERR_MALLOC_FAIL;
448 }
449 UsbRequestParamsWSyncInit(&requestSync->params, USB_CTRL_SET_TIMEOUT, &requestSync->pipe);
450 requestSync->params.userData = port;
451 OsalMutexLock(&port->reqSyncLock);
452 HdfSListAdd(&port->reqSyncList, &requestSync->node);
453 OsalMutexUnlock(&port->reqSyncLock);
454 return ret;
455 }
456
UsbdRequestSyncRelease(struct UsbdRequestSync * requestSync)457 static int32_t UsbdRequestSyncRelease(struct UsbdRequestSync *requestSync)
458 {
459 int32_t ret = HDF_SUCCESS;
460 if (requestSync) {
461 OsalMutexLock(&requestSync->lock);
462 if (requestSync->request) {
463 ret = UsbFreeRequest(requestSync->request);
464 if (HDF_SUCCESS != ret) {
465 HDF_LOGW("%{public}s:%{public}d UsbFreeRequest fail", __func__, __LINE__);
466 }
467 requestSync->request = NULL;
468 }
469 OsalMutexUnlock(&requestSync->lock);
470 OsalMemFree(requestSync);
471 }
472 return ret;
473 }
474
UsbdFindRequestSyncAndCreat(struct HostDevice * port,uint8_t interfaceId,uint8_t pipeAddr,struct UsbdRequestSync ** request)475 static int32_t UsbdFindRequestSyncAndCreat(struct HostDevice *port, uint8_t interfaceId,
476 uint8_t pipeAddr, struct UsbdRequestSync **request)
477 {
478 int32_t ret = HDF_SUCCESS;
479 if ((!port) || (!request)) {
480 HDF_LOGE("%{public}s:%{public}d ifId:%{public}d epId:%{public}d", __func__, __LINE__, interfaceId, pipeAddr);
481 return HDF_ERR_INVALID_PARAM;
482 }
483 *request = NULL;
484 struct UsbdRequestSync *requestSync = UsbdFindRequestSync(port, interfaceId, pipeAddr);
485 if (!requestSync) {
486 UsbInterfaceHandle *ifHandle = NULL;
487 struct UsbPipeInfo pipe;
488 if (memset_s(&pipe, sizeof(struct UsbPipeInfo), 0, sizeof(struct UsbPipeInfo)) != EOK) {
489 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
490 return HDF_FAILURE;
491 }
492 ret = GetPipe(port, interfaceId, pipeAddr, &pipe);
493 if (ret != HDF_SUCCESS) {
494 HDF_LOGE("%{public}s: get pipe failed ifId:%{public}d, epId:%{public}d", __func__, interfaceId, pipeAddr);
495 return HDF_FAILURE;
496 }
497 ifHandle = InterfaceIdToHandle(port, interfaceId);
498 if (ifHandle == NULL) {
499 HDF_LOGE("%{public}s:%{public}d get interface handle faild \n", __func__, __LINE__);
500 return HDF_ERR_INVALID_PARAM;
501 }
502 requestSync = UsbdRequestSyncAlloc();
503 if (!requestSync) {
504 HDF_LOGE("%{public}s:%{public}d fail ifId:%{public}d pipeId:%{public}d", __func__, __LINE__, interfaceId,
505 pipeAddr);
506 return HDF_ERR_MALLOC_FAIL;
507 }
508 ret = UsbdRequestSyncInit(port, ifHandle, &pipe, requestSync);
509 if (HDF_SUCCESS != ret) {
510 HDF_LOGE("%{public}s:%{public}d UsbdRequestSyncInit fail ret:%{public}d", __func__, __LINE__, ret);
511 int32_t tRet = UsbdRequestSyncRelease(requestSync);
512 requestSync = NULL;
513 if (HDF_SUCCESS != tRet) {
514 HDF_LOGE("%{public}s:%{public}d Release fail ifId:%{public}d pipeId:%{public}d", __func__, __LINE__,
515 interfaceId, pipeAddr);
516 }
517 return ret;
518 }
519 }
520 *request = requestSync;
521 return ret;
522 }
523
FunBulkReadSync(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)524 static int32_t FunBulkReadSync(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
525 {
526 uint8_t interfaceId = 0, pipeId = 0;
527 int32_t timeout = 0;
528 uint8_t tbuf[READ_BUF_SIZE] = {0};
529 uint32_t tsize = READ_BUF_SIZE;
530 uint32_t actlength = 0;
531 struct UsbdRequestSync *requestSync = NULL;
532
533 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
534 HDF_LOGE("%{public}s:%{public}d mangf invalid parma", __func__, __LINE__);
535 return HDF_ERR_INVALID_PARAM;
536 }
537 int32_t ret = UsbdBulkReadSyncGetParams(data, &interfaceId, &pipeId, &timeout);
538 if (HDF_SUCCESS != ret) {
539 HDF_LOGE("%{public}s:%{public}d UsbdBulkReadSyncGetParams error:%{public}d", __func__, __LINE__, ret);
540 return ret;
541 }
542 ret = UsbdFindRequestSyncAndCreat(port, interfaceId, pipeId, &requestSync);
543 if ((HDF_SUCCESS != ret) || (!requestSync)) {
544 HDF_LOGE("%{public}s:%{public}d read timeout error", __func__, __LINE__);
545 return ret;
546 }
547 if ((requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN) ||
548 (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK)) {
549 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
550 return HDF_ERR_INVALID_PARAM;
551 }
552 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync);
553 if (HDF_SUCCESS != ret) {
554 HDF_LOGW(
555 "%{public}s:%{public}d UsbdBulkReadSyncBase ret:%{public}d "
556 "len:%{public}d",
557 __func__, __LINE__, ret, actlength);
558 }
559 if (actlength > 0) {
560 if (!UsbdHdfWriteBuf(reply, tbuf, actlength)) {
561 HDF_LOGE("%{public}s:%{public}d sbuf write buffer failed:%{public}d", __func__, __LINE__, actlength);
562 ret = HDF_ERR_IO;
563 } else {
564 ret = HDF_SUCCESS;
565 }
566 }
567 return ret;
568 }
569
FunBulkWriteSyncGetParam(struct HdfSBuf * data,uint8_t * interfaceId,uint8_t * pipeId,int32_t * timeout)570 static int32_t FunBulkWriteSyncGetParam(struct HdfSBuf *data, uint8_t *interfaceId, uint8_t *pipeId, int32_t *timeout)
571 {
572 if (!HdfSbufReadUint8(data, interfaceId)) {
573 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
574 return HDF_ERR_IO;
575 }
576 if (!HdfSbufReadUint8(data, pipeId)) {
577 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
578 return HDF_ERR_IO;
579 }
580 if (!HdfSbufReadInt32(data, timeout)) {
581 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
582 return HDF_ERR_IO;
583 }
584 return HDF_SUCCESS;
585 }
586
UsbdRequestSyncReleaseList(struct HostDevice * port)587 static int32_t UsbdRequestSyncReleaseList(struct HostDevice *port)
588 {
589 int32_t ret = HDF_SUCCESS;
590 struct UsbdRequestSync *req = NULL;
591 struct HdfSListIterator it;
592 if (!port) {
593 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
594 return HDF_ERR_INVALID_PARAM;
595 }
596 OsalMutexLock(&port->reqSyncLock);
597 HdfSListIteratorInit(&it, &port->reqSyncList);
598 while (HdfSListIteratorHasNext(&it)) {
599 req = (struct UsbdRequestSync *)HdfSListIteratorNext(&it);
600 if (!req) {
601 continue;
602 }
603 HdfSListIteratorRemove(&it);
604 ret = UsbdRequestSyncRelease(req);
605 req = NULL;
606 if (HDF_SUCCESS != ret) {
607 HDF_LOGE("%{public}s:%{public}d UsbdRequestSyncRelease faild\n", __func__, __LINE__);
608 }
609 }
610 OsalMutexUnlock(&port->reqSyncLock);
611
612 return HDF_SUCCESS;
613 }
614
UsbdBulkWriteSyncBase(struct HostDevice * port,struct UsbdRequestSync * requestSync,const uint8_t * buffer,uint32_t length,int32_t timeout)615 static int32_t UsbdBulkWriteSyncBase(struct HostDevice *port, struct UsbdRequestSync *requestSync,
616 const uint8_t *buffer, uint32_t length, int32_t timeout)
617 {
618 int32_t ret = HDF_FAILURE;
619 if ((!port) || (!requestSync) || (!buffer) || (length < 1)) {
620 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
621 return HDF_ERR_INVALID_PARAM;
622 }
623
624 OsalMutexLock(&requestSync->lock);
625 int32_t initTimeout = timeout < 0 ? 0 : timeout;
626 requestSync->params.timeout = initTimeout;
627 requestSync->params.userData = port;
628 uint16_t tsize = requestSync->pipe.maxPacketSize;
629 uint16_t tcur = 0;
630 uint16_t msize = requestSync->pipe.maxPacketSize;
631 while (tcur < length) {
632 tsize = (length - tcur) < msize ? (length - tcur) : msize;
633 requestSync->params.dataReq.buffer = (unsigned char *)(buffer + tcur);
634 requestSync->params.dataReq.length = tsize;
635 tcur += tsize;
636 ret = UsbFillRequest(requestSync->request, requestSync->ifHandle, &requestSync->params);
637 if (HDF_SUCCESS != ret) {
638 HDF_LOGE(
639 "%{public}s:%{public}d UsbFillRequest faile, ret=%{public}d "
640 "handle:%{public}p tcur:%{public}d "
641 "length:%{public}d\n",
642 __func__, __LINE__, ret, requestSync->ifHandle, tcur, length);
643 break;
644 }
645 ret = UsbSubmitRequestSync(requestSync->request);
646 if (HDF_SUCCESS != ret) {
647 HDF_LOGE(
648 "%{public}s:%{public}d UsbSubmitRequestSync faile, "
649 "ret=%{public}d tcur:%{public}d length:%{public}d\n",
650 __func__, __LINE__, ret, tcur, length);
651 break;
652 }
653 }
654 OsalMutexUnlock(&requestSync->lock);
655 return ret;
656 }
657
FunBulkWriteSync(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)658 static int32_t FunBulkWriteSync(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
659 {
660 uint8_t *buffer = NULL;
661 uint8_t interfaceId = 0;
662 uint8_t pipeId = 0;
663 int32_t timeout = 0;
664 uint32_t length = 0;
665 struct UsbdRequestSync *requestSync = NULL;
666 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
667 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
668 return HDF_ERR_INVALID_PARAM;
669 }
670 int32_t ret = FunBulkWriteSyncGetParam(data, &interfaceId, &pipeId, &timeout);
671 if (ret != HDF_SUCCESS) {
672 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
673 return HDF_ERR_IO;
674 }
675 if (!HdfSbufReadBuffer(data, (const void **)&buffer, &length)) {
676 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
677 return HDF_ERR_IO;
678 }
679 ret = UsbdFindRequestSyncAndCreat(port, interfaceId, pipeId, &requestSync);
680 if ((HDF_SUCCESS != ret) || (!requestSync)) {
681 HDF_LOGE("%{public}s:%{public}d read timeout error", __func__, __LINE__);
682 return ret;
683 }
684 if ((requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT) ||
685 (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK)) {
686 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
687 return HDF_ERR_INVALID_PARAM;
688 }
689 ret = UsbdBulkWriteSyncBase(port, requestSync, buffer, length, timeout);
690 return ret;
691 }
692
UsbRequestParamsInit(struct UsbRequestParams * parmas,int32_t timeout)693 static void UsbRequestParamsInit(struct UsbRequestParams *parmas, int32_t timeout)
694 {
695 if (parmas == NULL) {
696 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
697 return;
698 }
699 parmas->interfaceId = USB_CTRL_INTERFACE_ID;
700 parmas->pipeAddress = 0;
701 parmas->pipeId = 0;
702 parmas->requestType = USB_REQUEST_PARAMS_CTRL_TYPE;
703 parmas->timeout = timeout;
704 return;
705 }
706
UsbControlTransferEx(struct HostDevice * dev,struct UsbControlParams * ctrParams,int32_t timeout)707 static int32_t UsbControlTransferEx(struct HostDevice *dev, struct UsbControlParams *ctrParams, int32_t timeout)
708 {
709 struct UsbRequest *request = NULL;
710 struct UsbRequestParams parmas = {};
711
712 if (memset_s(&parmas, sizeof(parmas), 0, sizeof(parmas)) != EOK) {
713 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
714 return HDF_FAILURE;
715 }
716
717 if ((dev == NULL) || (dev->ctrDevHandle == NULL) || (ctrParams == NULL) || (ctrParams->data == NULL)) {
718 HDF_LOGE("%{public}s:%{public}d null pointer faild", __func__, __LINE__);
719 return HDF_ERR_INVALID_PARAM;
720 }
721
722 if (!dev->ctrlReq) {
723 request = UsbAllocRequest(dev->ctrDevHandle, 0, MAX_CONTROL_BUFF_SIZE);
724 if (!request) {
725 HDF_LOGE("%{public}s:%{public}d UsbAllocRequest alloc request faild\n", __func__, __LINE__);
726 return HDF_ERR_MALLOC_FAIL;
727 }
728 dev->ctrlReq = request;
729 } else {
730 request = dev->ctrlReq;
731 }
732
733 UsbRequestParamsInit(&parmas, timeout);
734
735 int32_t ret = UsbControlSetUp(ctrParams, &parmas.ctrlReq);
736 if (ret != HDF_SUCCESS) {
737 HDF_LOGE("%{public}s:%{public}d UsbControlSetUp faile, ret=%{public}d ", __func__, __LINE__, ret);
738 return ret;
739 }
740 OsalMutexLock(&dev->lock);
741 do {
742 ret = UsbFillRequest(request, dev->ctrDevHandle, &parmas);
743 if (HDF_SUCCESS != ret) {
744 HDF_LOGE("%{public}s:%{public}d UsbFillRequest faile, ret=%{public}d ", __func__, __LINE__, ret);
745 break;
746 }
747
748 ret = UsbSubmitRequestSync(request);
749 if (HDF_SUCCESS != ret) {
750 HDF_LOGE("%{public}s:%{public}d UsbSubmitRequestSync faile, ret=%{public}d ", __func__, __LINE__, ret);
751 OsalMSleep(SUBMIT_SLEEP_TIME);
752 break;
753 }
754
755 if (USB_REQUEST_DIR_FROM_DEVICE == ctrParams->directon) {
756 memcpy_s(ctrParams->data, ctrParams->size, request->compInfo.buffer, request->compInfo.actualLength);
757 ctrParams->size =
758 ctrParams->size < request->compInfo.actualLength ? ctrParams->size : request->compInfo.actualLength;
759 }
760 } while (0);
761
762 OsalMutexUnlock(&dev->lock);
763 return ret;
764 }
765
CtrlTranParamGetReqType(struct HdfSBuf * data,struct UsbControlParams * pCtrParams,int32_t requestType)766 static int32_t CtrlTranParamGetReqType(struct HdfSBuf *data, struct UsbControlParams *pCtrParams, int32_t requestType)
767 {
768 if (data == NULL || pCtrParams == NULL) {
769 HDF_LOGE("%{public}s:%{public}d param failed", __func__, __LINE__);
770 return HDF_ERR_INVALID_PARAM;
771 }
772 uint8_t *buffer = NULL;
773 uint32_t length = 0;
774
775 int32_t target = requestType & USB_RECIP_MASK;
776 int32_t direction = (requestType >> DIRECTION_OFFSET_7) & ENDPOINT_DIRECTION_MASK;
777 int32_t cmdType = (requestType >> CMD_OFFSET_5) & CMD_TYPE_MASK;
778 if (direction == USB_REQUEST_DIR_TO_DEVICE) {
779 if (!HdfSbufReadBuffer(data, (const void **)&buffer, &length)) {
780 HDF_LOGE("%{public}s:%{public}d hdf sbuf Read failed", __func__, __LINE__);
781 return HDF_FAILURE;
782 }
783 } else {
784 length = MAX_CONTROL_BUFF_SIZE;
785 buffer = (uint8_t *)OsalMemAlloc(length);
786 if (buffer == NULL) {
787 HDF_LOGE("%{public}s:%{public}d OsalMemAlloc faild length = %{public}d", __func__, __LINE__, length);
788 return HDF_ERR_MALLOC_FAIL;
789 }
790 if (memset_s(buffer, length, 0, length) != EOK) {
791 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
792 OsalMemFree(buffer);
793 return HDF_FAILURE;
794 }
795 }
796 pCtrParams->target = target;
797 pCtrParams->directon = direction;
798 pCtrParams->reqType = cmdType;
799 pCtrParams->size = length;
800 pCtrParams->data = buffer;
801
802 return HDF_SUCCESS;
803 }
804
CtrlTransferParamInit(struct HdfSBuf * data,struct UsbControlParams * pCtrParams,int32_t * timeout)805 static int32_t CtrlTransferParamInit(struct HdfSBuf *data, struct UsbControlParams *pCtrParams, int32_t *timeout)
806 {
807 if (data == NULL || pCtrParams == NULL) {
808 HDF_LOGE("%{public}s:%{public}d param failed", __func__, __LINE__);
809 return HDF_ERR_INVALID_PARAM;
810 }
811 int32_t requestCmd = 0;
812 int32_t requestType = 0;
813 int32_t value = 0;
814 int32_t index = 0;
815
816 if (!HdfSbufReadInt32(data, &requestType)) {
817 HDF_LOGE("%{public}s:%{public}d read param fail", __func__, __LINE__);
818 return HDF_ERR_IO;
819 }
820 if (!HdfSbufReadInt32(data, &requestCmd)) {
821 HDF_LOGE("%{public}s:%{public}d read param fail", __func__, __LINE__);
822 return HDF_ERR_IO;
823 }
824 if (!HdfSbufReadInt32(data, &value)) {
825 HDF_LOGE("%{public}s:%{public}d read param fail", __func__, __LINE__);
826 return HDF_ERR_IO;
827 }
828 if (!HdfSbufReadInt32(data, &index)) {
829 HDF_LOGE("%{public}s:%{public}d read param fail", __func__, __LINE__);
830 return HDF_ERR_IO;
831 }
832 if (!HdfSbufReadInt32(data, timeout)) {
833 HDF_LOGE("%{public}s:%{public}d read param fail", __func__, __LINE__);
834 return HDF_ERR_IO;
835 }
836
837 pCtrParams->request = (uint8_t)requestCmd;
838 pCtrParams->value = value;
839 pCtrParams->index = index;
840
841 int32_t ret = CtrlTranParamGetReqType(data, pCtrParams, requestType);
842 if (HDF_SUCCESS != ret) {
843 HDF_LOGE("%{public}s:%{public}d CtrlTransferParamInit failed:%{public}d", __func__, __LINE__, ret);
844 OsalMemFree(pCtrParams->data);
845 pCtrParams->data = NULL;
846 }
847 return ret;
848 }
849
FunControlTransfer(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)850 static int32_t FunControlTransfer(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
851 {
852 int32_t timeout = 0;
853 int32_t ret = HDF_SUCCESS;
854
855 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
856 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
857 return HDF_ERR_INVALID_PARAM;
858 }
859
860 if (port->ctrDevHandle == NULL) {
861 HDF_LOGE("%{public}s:%{public}d interface handle is null \n", __func__, __LINE__);
862 return HDF_ERR_INVALID_PARAM;
863 }
864
865 struct UsbControlParams controlParams = {};
866 if (memset_s(&controlParams, sizeof(controlParams), 0, sizeof(controlParams)) != EOK) {
867 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
868 return HDF_FAILURE;
869 }
870 ret = CtrlTransferParamInit(data, &controlParams, &timeout);
871 if (HDF_SUCCESS != ret) {
872 HDF_LOGE("%{public}s:%{public}d CtrlTransferParamInit failed:%{public}d", __func__, __LINE__, ret);
873 OsalMemFree(controlParams.data);
874 controlParams.data = NULL;
875 return ret;
876 }
877
878 ret = UsbControlTransferEx(port, &controlParams, timeout);
879 if (ret != HDF_SUCCESS) {
880 HDF_LOGE("%{public}s:%{public}d UsbControlTransfer faild ret:%{public}d\n", __func__, __LINE__, ret);
881 }
882 if (controlParams.directon == USB_REQUEST_DIR_FROM_DEVICE) {
883 if ((HDF_SUCCESS == ret) && (!UsbdHdfWriteBuf(reply, (uint8_t *)controlParams.data, controlParams.size))) {
884 HDF_LOGE("%{public}s:%{public}d sbuf write buffer failed", __func__, __LINE__);
885 }
886 OsalMemFree(controlParams.data);
887 controlParams.data = NULL;
888 }
889 return ret;
890 }
891
UsbdReleaseInterfaces(struct HostDevice * dev)892 static void UsbdReleaseInterfaces(struct HostDevice *dev)
893 {
894 if (dev == NULL) {
895 HDF_LOGE("%{public}s:%{public}d: invalid parma", __func__, __LINE__);
896 return;
897 }
898
899 for (int32_t i = 0; i < USB_MAX_INTERFACES; ++i) {
900 if (dev->iface[i]) {
901 UsbReleaseInterface(dev->iface[i]);
902 dev->iface[i] = NULL;
903 }
904 }
905 if (dev->ctrIface) {
906 UsbReleaseInterface(dev->ctrIface);
907 dev->ctrIface = NULL;
908 }
909 }
910
UsbdCloseInterfaces(struct HostDevice * dev)911 static void UsbdCloseInterfaces(struct HostDevice *dev)
912 {
913 if (dev == NULL) {
914 HDF_LOGE("%{public}s:%{public}d: invalid parma", __func__, __LINE__);
915 return;
916 }
917
918 for (int32_t i = 0; i < USB_MAX_INTERFACES; ++i) {
919 if (dev->devHandle[i]) {
920 UsbCloseInterface(dev->devHandle[i]);
921 dev->devHandle[i] = NULL;
922 }
923 }
924 if (dev->ctrDevHandle) {
925 UsbCloseInterface(dev->ctrDevHandle);
926 dev->ctrDevHandle = NULL;
927 }
928 }
929
FunClaimInterface(struct HostDevice * port,struct HdfSBuf * data)930 static int32_t FunClaimInterface(struct HostDevice *port, struct HdfSBuf *data)
931 {
932 if ((port == NULL) || (data == NULL)) {
933 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
934 return HDF_ERR_INVALID_PARAM;
935 }
936
937 uint8_t interfaceId;
938 uint8_t force = 1;
939 if (!HdfSbufReadUint8(data, &interfaceId)) {
940 HDF_LOGE("%{public}s:%{public}d sbuf read interfaceNum failed", __func__, __LINE__);
941 return HDF_ERR_INVALID_PARAM;
942 }
943 if (!HdfSbufReadUint8(data, &force)) {
944 HDF_LOGE("%{public}s:%{public}d sbuf read interfaceNum failed", __func__, __LINE__);
945 return HDF_ERR_INVALID_PARAM;
946 }
947 if (interfaceId >= USB_MAX_INTERFACES) {
948 HDF_LOGE("%{public}s:%{public}d interfaceId larger then max num", __func__, __LINE__);
949 return HDF_ERR_INVALID_PARAM;
950 }
951 if (port->iface[interfaceId] == NULL) {
952 if (force) {
953 port->iface[interfaceId] = UsbClaimInterface(
954 port->service->session, port->busNum, port->devAddr, interfaceId);
955 } else {
956 port->iface[interfaceId] = (struct UsbInterface *)UsbClaimInterfaceUnforce(
957 port->service->session, port->busNum, port->devAddr, interfaceId);
958 }
959 if (port->iface[interfaceId] == NULL) {
960 HDF_LOGE(
961 "%{public}s:%{public}d UsbClaimInterface failed id = "
962 "%{public}d, busNum=%{public}d, devAddr=%{public}d",
963 __func__, __LINE__, interfaceId, (int32_t)port->busNum, (int32_t)port->devAddr);
964 return HDF_FAILURE;
965 }
966 }
967 if (port->devHandle[interfaceId] == NULL) {
968 port->devHandle[interfaceId] = UsbOpenInterface(port->iface[interfaceId]);
969 if (port->devHandle[interfaceId] == NULL) {
970 HDF_LOGE("%{public}s:%{public}d UsbOpenInterface failed id = %{public}d", __func__, __LINE__, interfaceId);
971 return HDF_FAILURE;
972 }
973 }
974 return HDF_SUCCESS;
975 }
976
FunReleaseInterface(struct HostDevice * port,struct HdfSBuf * data)977 static int32_t FunReleaseInterface(struct HostDevice *port, struct HdfSBuf *data)
978 {
979 int32_t ret = HDF_SUCCESS;
980 uint8_t interfaceId = 0;
981 if ((port == NULL) || (data == NULL)) {
982 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
983 return HDF_ERR_INVALID_PARAM;
984 }
985
986 if (!HdfSbufReadUint8(data, &interfaceId)) {
987 HDF_LOGE("%{public}s:%{public}d sbuf read interfaceNum failed", __func__, __LINE__);
988 return HDF_ERR_INVALID_PARAM;
989 }
990 if (interfaceId >= USB_MAX_INTERFACES) {
991 HDF_LOGE("%{public}s:%{public}d interfaceId:%{public}d fail", __func__, __LINE__, interfaceId);
992 return HDF_ERR_INVALID_PARAM;
993 }
994 return ret;
995 }
996
UsbdOpenInterfaces(struct HostDevice * dev)997 static int32_t UsbdOpenInterfaces(struct HostDevice *dev)
998 {
999 if (dev == NULL) {
1000 HDF_LOGE("%{public}s:%{public}d: invalid parma", __func__, __LINE__);
1001 return HDF_ERR_INVALID_PARAM;
1002 }
1003
1004 if (memset_s(dev->devHandle, sizeof(uint8_t) * USB_MAX_INTERFACES, 0, sizeof(uint8_t) * USB_MAX_INTERFACES) !=
1005 EOK) {
1006 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
1007 return HDF_FAILURE;
1008 }
1009 dev->ctrDevHandle = UsbOpenInterface(dev->ctrIface);
1010 if (dev->ctrDevHandle == NULL) {
1011 HDF_LOGE("%{public}s:%{public}d ctrDevHandle UsbOpenInterface null", __func__, __LINE__);
1012 UsbdCloseInterfaces(dev);
1013 return HDF_FAILURE;
1014 }
1015 return HDF_SUCCESS;
1016 }
1017
MakeUsbControlParams(struct UsbControlParams * controlParams,uint8_t * buffer,uint32_t * length,uint16_t value,uint16_t index)1018 void MakeUsbControlParams(struct UsbControlParams *controlParams, uint8_t *buffer, uint32_t *length,
1019 uint16_t value, uint16_t index)
1020 {
1021 controlParams->request = USB_DDK_REQ_GET_DESCRIPTOR;
1022 controlParams->target = USB_REQUEST_TARGET_DEVICE;
1023 controlParams->reqType = USB_REQUEST_TYPE_STANDARD;
1024 controlParams->directon = USB_REQUEST_DIR_FROM_DEVICE;
1025 controlParams->value = value;
1026 controlParams->index = index;
1027 controlParams->data = buffer;
1028 controlParams->size = *length;
1029 }
1030
FunGetDeviceDescriptor(struct HostDevice * port,struct HdfSBuf * reply)1031 static int32_t FunGetDeviceDescriptor(struct HostDevice *port, struct HdfSBuf *reply)
1032 {
1033 if ((port == NULL) || (reply == NULL)) {
1034 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1035 return HDF_ERR_INVALID_PARAM;
1036 }
1037
1038 uint32_t length = MAX_CONTROL_BUFF_SIZE;
1039 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0};
1040 struct UsbControlParams controlParams = {};
1041 MakeUsbControlParams(&controlParams, buffer, &length, (int32_t)USB_DDK_DT_DEVICE << TYPE_OFFSET_8, 0);
1042 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1043 if (HDF_SUCCESS != ret) {
1044 HDF_LOGE("%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
1045 return ret;
1046 }
1047 if (!UsbdHdfWriteBuf(reply, buffer, controlParams.size)) {
1048 HDF_LOGE("%{public}s:%{public}d WriteBuffer fail ", __func__, __LINE__);
1049 return HDF_ERR_IO;
1050 }
1051
1052 return ret;
1053 }
1054
FunGetConfigDescriptor(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1055 static int32_t FunGetConfigDescriptor(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1056 {
1057 uint8_t configId = 0;
1058
1059 if ((port == NULL) || (reply == NULL) || (data == NULL)) {
1060 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1061 return HDF_ERR_INVALID_PARAM;
1062 }
1063
1064 if (!HdfSbufReadUint8(data, &configId)) {
1065 HDF_LOGE("%{public}s:%{public}d failed", __func__, __LINE__);
1066 return HDF_ERR_INVALID_PARAM;
1067 }
1068
1069 uint32_t length = MAX_CONTROL_BUFF_SIZE;
1070 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0};
1071 struct UsbControlParams controlParams = {};
1072 MakeUsbControlParams(&controlParams, buffer, &length, ((int32_t)USB_DDK_DT_CONFIG << TYPE_OFFSET_8) + configId, 0);
1073 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1074 if (HDF_SUCCESS != ret) {
1075 HDF_LOGE("%{public}s:%{public}d failed", __func__, __LINE__);
1076
1077 return ret;
1078 }
1079 if (!UsbdHdfWriteBuf(reply, buffer, controlParams.size)) {
1080 HDF_LOGE("%{public}s:%{public}d WriteBuffer fail ", __func__, __LINE__);
1081 return HDF_ERR_IO;
1082 }
1083
1084 return ret;
1085 }
1086
FunGetStringDescriptor(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1087 static int32_t FunGetStringDescriptor(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1088 {
1089 uint8_t stringId = 0;
1090
1091 if ((port == NULL) || (reply == NULL)) {
1092 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1093 return HDF_ERR_INVALID_PARAM;
1094 }
1095
1096 if (!HdfSbufReadUint8(data, &stringId)) {
1097 HDF_LOGE("%{public}s:%{public}d failed", __func__, __LINE__);
1098 return HDF_ERR_INVALID_PARAM;
1099 }
1100
1101 uint32_t length = MAX_CONTROL_BUFF_SIZE;
1102 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0};
1103 struct UsbControlParams controlParams = {};
1104 MakeUsbControlParams(&controlParams, buffer, &length, ((int32_t)USB_DDK_DT_STRING << TYPE_OFFSET_8) + stringId, 0);
1105 int32_t ret = UsbControlTransferEx(port, &controlParams, GET_STRING_SET_TIMEOUT);
1106 if (HDF_SUCCESS != ret) {
1107 HDF_LOGE("%{public}s:%{public}d failed ret=%{public}d", __func__, __LINE__, ret);
1108 return ret;
1109 }
1110 if (!UsbdHdfWriteBuf(reply, buffer, controlParams.size)) {
1111 HDF_LOGE("%{public}s:%{public}d WriteBuffer fail ", __func__, __LINE__);
1112 return HDF_ERR_IO;
1113 }
1114 return ret;
1115 }
1116
MakeGetActiveUsbControlParams(struct UsbControlParams * controlParams,uint8_t * buffer,uint32_t * length,uint16_t value,uint16_t index)1117 void MakeGetActiveUsbControlParams(struct UsbControlParams *controlParams, uint8_t *buffer,
1118 uint32_t *length, uint16_t value, uint16_t index)
1119 {
1120 controlParams->request = USB_DDK_REQ_GET_CONFIGURATION;
1121 controlParams->target = USB_REQUEST_TARGET_DEVICE;
1122 controlParams->reqType = USB_REQUEST_TYPE_STANDARD;
1123 controlParams->directon = USB_REQUEST_DIR_FROM_DEVICE;
1124 controlParams->value = value;
1125 controlParams->index = index;
1126 controlParams->data = buffer;
1127 controlParams->size = *length;
1128 }
1129
FunGetActiveConfig(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1130 static int32_t FunGetActiveConfig(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1131 {
1132 uint8_t configId = 0;
1133 uint32_t length = 1;
1134
1135 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
1136 HDF_LOGE("%{public}s: invalid parma", __func__);
1137 return HDF_ERR_INVALID_PARAM;
1138 }
1139
1140 struct UsbControlParams controlParams = {};
1141 MakeGetActiveUsbControlParams(&controlParams, &configId, &length, 0, 0);
1142 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1143 if (HDF_SUCCESS != ret) {
1144 HDF_LOGE("%{public}s:%{public}d failed", __func__, __LINE__);
1145 return HDF_ERR_IO;
1146 }
1147 if (!HdfSbufWriteUint8(reply, configId)) {
1148 HDF_LOGE("%{public}s:%{public}d WriteBuffer fail ", __func__, __LINE__);
1149 return HDF_ERR_IO;
1150 }
1151 return ret;
1152 }
1153
RemoveDevFromService(struct UsbdService * service,struct HostDevice * port)1154 static void RemoveDevFromService(struct UsbdService *service, struct HostDevice *port)
1155 {
1156 struct HdfSListIterator it;
1157 struct HostDevice *tempPort = NULL;
1158 if (!service || !port) {
1159 return;
1160 }
1161
1162 OsalMutexLock(&service->lock);
1163 HdfSListIteratorInit(&it, &service->devList);
1164 while (HdfSListIteratorHasNext(&it)) {
1165 tempPort = (struct HostDevice *)HdfSListIteratorNext(&it);
1166 if (!tempPort) {
1167 continue;
1168 }
1169 if ((tempPort->busNum == port->busNum) && (tempPort->devAddr == port->devAddr)) {
1170 HdfSListIteratorRemove(&it);
1171 break;
1172 }
1173 }
1174 OsalMutexUnlock(&service->lock);
1175
1176 return;
1177 }
1178
UsbdClaimInterfaces(struct HostDevice * dev)1179 static int32_t UsbdClaimInterfaces(struct HostDevice *dev)
1180 {
1181 if (dev == NULL) {
1182 HDF_LOGE("%{public}s:%{public}d: invalid parma", __func__, __LINE__);
1183 return HDF_ERR_INVALID_PARAM;
1184 }
1185
1186 if (memset_s(dev->iface, sizeof(uint8_t) * USB_MAX_INTERFACES, 0, sizeof(uint8_t) * USB_MAX_INTERFACES) != EOK) {
1187 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
1188 return HDF_FAILURE;
1189 }
1190 dev->ctrIface = GetUsbInterfaceById((const struct HostDevice *)dev, USB_CTRL_INTERFACE_ID);
1191 if (dev->ctrIface == NULL) {
1192 HDF_LOGE("%{public}s:%{public}d GetUsbInterfaceById null", __func__, __LINE__);
1193 UsbdReleaseInterfaces(dev);
1194 return HDF_FAILURE;
1195 }
1196
1197 return HDF_SUCCESS;
1198 }
1199
ReturnGetPipes(int32_t ret,struct HostDevice * dev)1200 static int32_t ReturnGetPipes(int32_t ret, struct HostDevice *dev)
1201 {
1202 UsbdCloseInterfaces(dev);
1203 UsbdReleaseInterfaces(dev);
1204 UsbExitHostSdk(dev->service->session);
1205 dev->service->session = NULL;
1206 return ret;
1207 }
1208
ReturnOpenInterfaces(int32_t ret,struct HostDevice * dev)1209 static int32_t ReturnOpenInterfaces(int32_t ret, struct HostDevice *dev)
1210 {
1211 UsbdReleaseInterfaces(dev);
1212 UsbExitHostSdk(dev->service->session);
1213 dev->service->session = NULL;
1214 return ret;
1215 }
1216
ReturnClainInterfaces(int32_t ret,struct HostDevice * dev)1217 static int32_t ReturnClainInterfaces(int32_t ret, struct HostDevice *dev)
1218 {
1219 UsbExitHostSdk(dev->service->session);
1220 dev->service->session = NULL;
1221 return ret;
1222 }
1223
UsbdInit(struct HostDevice * dev)1224 static int32_t UsbdInit(struct HostDevice *dev)
1225 {
1226 struct UsbSession *session = NULL;
1227 if (dev == NULL) {
1228 HDF_LOGE("%{public}s:%{public}d: invalid parma", __func__, __LINE__);
1229 return HDF_ERR_INVALID_PARAM;
1230 }
1231 if (dev->initFlag == true) {
1232 HDF_LOGE("%{public}s:%{public}d: initFlag is true", __func__, __LINE__);
1233 return HDF_SUCCESS;
1234 }
1235 int32_t ret = UsbInitHostSdk(NULL);
1236 if (ret != HDF_SUCCESS) {
1237 HDF_LOGE("%{public}s:%{public}d UsbInitHostSdk faild", __func__, __LINE__);
1238 return HDF_ERR_IO;
1239 }
1240 if (dev->service) {
1241 dev->service->session = session;
1242 }
1243
1244 ret = UsbdClaimInterfaces(dev);
1245 if (ret != HDF_SUCCESS) {
1246 HDF_LOGE("%{public}s:%{public}d UsbdClaimInterfaces faild ret:%{public}d", __func__, __LINE__, ret);
1247 return ReturnClainInterfaces(ret, dev);
1248 }
1249 ret = UsbdOpenInterfaces(dev);
1250 if (ret != HDF_SUCCESS) {
1251 HDF_LOGE("%{public}s:%{public}d UsbdOpenInterfaces faild ret:%{public}d", __func__, __LINE__, ret);
1252 return ReturnOpenInterfaces(ret, dev);
1253 }
1254 ret = UsbdGetCtrlPipe(dev);
1255 if (ret != HDF_SUCCESS) {
1256 HDF_LOGE("%{public}s:%{public}d UsbdGetPipes failed ret:%{public}d", __func__, __LINE__, ret);
1257 return ReturnGetPipes(ret, dev);
1258 }
1259
1260 return HDF_SUCCESS;
1261 }
1262
UsbdRequestASyncReleaseData(struct UsbdRequestASync * request)1263 static int32_t UsbdRequestASyncReleaseData(struct UsbdRequestASync *request)
1264 {
1265 if (request) {
1266 if (request->reqMsg.buffer) {
1267 HDF_LOGI("%{public}s:%{public}d free buffer\n", __func__, __LINE__);
1268 OsalMemFree(request->reqMsg.buffer);
1269 request->reqMsg.buffer = NULL;
1270 }
1271 request->reqMsg.length = 0;
1272 if (request->reqMsg.clientData) {
1273 HDF_LOGI("%{public}s:%{public}d free clientData\n", __func__, __LINE__);
1274 OsalMemFree(request->reqMsg.clientData);
1275 request->reqMsg.clientData = NULL;
1276 }
1277 request->reqMsg.clientLength = 0;
1278 request->status = 0;
1279 }
1280 return HDF_SUCCESS;
1281 }
1282
UsbdRequestASyncRelease(struct UsbdRequestASync * request)1283 static int32_t UsbdRequestASyncRelease(struct UsbdRequestASync *request)
1284 {
1285 int32_t ret = HDF_SUCCESS;
1286 if (request) {
1287 OsalMutexLock(&request->lock);
1288 UsbdRequestASyncReleaseData(request);
1289 if (request->reqMsg.request) {
1290 ret = UsbFreeRequest(request->reqMsg.request);
1291 request->reqMsg.request = NULL;
1292 if (HDF_SUCCESS != ret) {
1293 HDF_LOGE("%{public}s:%{public}d UsbFreeRequest fail", __func__, __LINE__);
1294 }
1295 }
1296 OsalMutexUnlock(&request->lock);
1297 OsalMemFree(request);
1298 }
1299 return ret;
1300 }
1301
UsbdRequestASyncReleaseList(struct HostDevice * port)1302 static int32_t UsbdRequestASyncReleaseList(struct HostDevice *port)
1303 {
1304 int32_t ret = HDF_SUCCESS;
1305 struct UsbdRequestASync *req = NULL;
1306 struct HdfSListIterator it;
1307 if (!port) {
1308 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1309 return HDF_ERR_INVALID_PARAM;
1310 }
1311 OsalMutexLock(&port->reqASyncLock);
1312 HdfSListIteratorInit(&it, &port->reqASyncList);
1313 while (HdfSListIteratorHasNext(&it)) {
1314 req = (struct UsbdRequestASync *)HdfSListIteratorNext(&it);
1315 if (!req) {
1316 continue;
1317 }
1318 HdfSListIteratorRemove(&it);
1319 ret = UsbdRequestASyncRelease(req);
1320 req = NULL;
1321 if (HDF_SUCCESS != ret) {
1322 HDF_LOGW("%{public}s:%{public}d UsbdRequestASyncRelease faild\n", __func__, __LINE__);
1323 }
1324 }
1325 OsalMutexUnlock(&port->reqASyncLock);
1326
1327 return HDF_SUCCESS;
1328 }
1329
UsbdBulkASyncReqRelease(struct UsbdBulkASyncReqList * list)1330 static int32_t UsbdBulkASyncReqRelease(struct UsbdBulkASyncReqList *list)
1331 {
1332 for (int32_t i = 0; i < USBD_BULKASYNCREQ_NUM_MAX; ++i) {
1333 UsbFreeRequest(list->node[i].request);
1334 list->node[i].request = NULL;
1335 }
1336 DListHeadInit(&list->eList);
1337 DListHeadInit(&list->uList);
1338 OsalMutexDestroy(&list->elock);
1339 OsalMutexDestroy(&list->ulock);
1340
1341 return HDF_SUCCESS;
1342 }
1343
UsbdBulkASyncListRelease(struct UsbdBulkASyncList * list)1344 static int32_t UsbdBulkASyncListRelease(struct UsbdBulkASyncList *list)
1345 {
1346 UsbdBulkASyncReqRelease(&list->rList);
1347 OsalMutexDestroy(&list->asmHandle.lock);
1348 OsalMemFree(list);
1349
1350 return HDF_SUCCESS;
1351 }
1352
UsbdBulkASyncListReleasePort(struct HostDevice * port)1353 static int32_t UsbdBulkASyncListReleasePort(struct HostDevice *port)
1354 {
1355 if ((!port) || (!port->bulkASyncList)) {
1356 return HDF_SUCCESS;
1357 }
1358 struct UsbdBulkASyncList *list = port->bulkASyncList;
1359 while (port->bulkASyncList) {
1360 list = port->bulkASyncList;
1361 port->bulkASyncList = list->next;
1362 UsbdBulkASyncListRelease(list);
1363 list = NULL;
1364 }
1365 return HDF_SUCCESS;
1366 }
1367
UsbdRelease(struct HostDevice * dev)1368 static void UsbdRelease(struct HostDevice *dev)
1369 {
1370 if (dev == NULL) {
1371 HDF_LOGE("%{public}s:%{public}d: invalid parma", __func__, __LINE__);
1372 return;
1373 }
1374
1375 UsbdCloseInterfaces(dev);
1376 UsbdReleaseInterfaces(dev);
1377 UsbdFreeCtrlPipe(dev);
1378 UsbdRequestSyncReleaseList(dev);
1379 UsbdRequestASyncReleaseList(dev);
1380 UsbdBulkASyncListReleasePort(dev);
1381
1382 if (dev->ctrlReq) {
1383 UsbFreeRequest(dev->ctrlReq);
1384 dev->ctrlReq = NULL;
1385 }
1386 UsbExitHostSdk(dev->service->session);
1387 dev->service->session = NULL;
1388 OsalMutexDestroy(&dev->writeLock);
1389 OsalMutexDestroy(&dev->readLock);
1390 OsalMutexDestroy(&dev->lock);
1391 OsalMutexDestroy(&dev->requestLock);
1392 OsalMutexDestroy(&dev->reqSyncLock);
1393 OsalMutexDestroy(&dev->reqASyncLock);
1394 dev->busNum = 0;
1395 dev->devAddr = 0;
1396 dev->initFlag = false;
1397 }
1398
ReOpenDevice(struct HostDevice * port)1399 static int32_t ReOpenDevice(struct HostDevice *port)
1400 {
1401 if (!port) {
1402 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1403 return HDF_FAILURE;
1404 }
1405 uint8_t busNum = port->busNum;
1406 uint8_t devAddr = port->devAddr;
1407 UsbdRelease(port);
1408 port->busNum = busNum;
1409 port->devAddr = devAddr;
1410 OsalMutexInit(&port->writeLock);
1411 OsalMutexInit(&port->readLock);
1412 OsalMutexInit(&port->lock);
1413 OsalMutexInit(&port->requestLock);
1414 OsalMutexInit(&port->reqSyncLock);
1415 OsalMutexInit(&port->reqASyncLock);
1416
1417 HdfSListInit(&port->requestQueue);
1418 HdfSListInit(&port->reqSyncList);
1419 HdfSListInit(&port->reqASyncList);
1420 int32_t ret = UsbdInit(port);
1421 if (ret != HDF_SUCCESS) {
1422 HDF_LOGE("%{public}s:%{public}d UsbInit failed ret:%{public}d", __func__, __LINE__, ret);
1423 UsbdRelease(port);
1424 RemoveDevFromService(port->service, port);
1425 OsalMemFree(port);
1426 return ret;
1427 }
1428 DataFifoReset(&port->readFifo);
1429 port->initFlag = true;
1430 return HDF_SUCCESS;
1431 }
1432
MakeSetActiveUsbControlParams(struct UsbControlParams * controlParams,uint8_t * buffer,uint32_t * length,uint16_t value,uint16_t index)1433 void MakeSetActiveUsbControlParams(struct UsbControlParams *controlParams, uint8_t *buffer,
1434 uint32_t *length, uint16_t value, uint16_t index)
1435 {
1436 controlParams->request = USB_DDK_REQ_SET_CONFIGURATION;
1437 controlParams->target = USB_REQUEST_TARGET_DEVICE;
1438 controlParams->reqType = USB_REQUEST_TYPE_STANDARD;
1439 controlParams->directon = USB_REQUEST_DIR_FROM_DEVICE;
1440 controlParams->value = value;
1441 controlParams->index = index;
1442 controlParams->data = buffer;
1443 controlParams->size = *length;
1444 }
1445
FunSetActiveConfig(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1446 static int32_t FunSetActiveConfig(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1447 {
1448 uint8_t configId = 0;
1449 uint8_t configIdOld = 0;
1450 uint8_t configIdNew = 0;
1451 uint32_t length = 1;
1452 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
1453 HDF_LOGE("%{public}s: invalid parma", __func__);
1454 return HDF_ERR_INVALID_PARAM;
1455 }
1456 if (!HdfSbufReadUint8(data, &configId)) {
1457 HDF_LOGE("%{public}s:%{public}d failed", __func__, __LINE__);
1458 return HDF_ERR_INVALID_PARAM;
1459 }
1460 struct UsbControlParams controlParams = {};
1461 MakeGetActiveUsbControlParams(&controlParams, &configIdOld, &length, 0, 0);
1462 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1463 if (HDF_SUCCESS != ret) {
1464 HDF_LOGE("%{public}s:%{public}d getConfiguration failed ret:%{public}d", __func__, __LINE__, ret);
1465 return HDF_ERR_INVALID_PARAM;
1466 }
1467 if (configId == configIdOld) {
1468 HDF_LOGE(
1469 "%{public}s:%{public}d setConfiguration success "
1470 "configId:%{public}d old:%{public}d",
1471 __func__, __LINE__, configId, configIdOld);
1472 return HDF_SUCCESS;
1473 }
1474 length = 0;
1475 MakeSetActiveUsbControlParams(&controlParams, &configId, &length, (int32_t)0 + configId, 0);
1476 ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1477 if (HDF_SUCCESS != ret) {
1478 HDF_LOGE("%{public}s:%{public}d setConfiguration failed ret:%{public}d", __func__, __LINE__, ret);
1479 return HDF_ERR_IO;
1480 }
1481 length = 1;
1482 MakeGetActiveUsbControlParams(&controlParams, &configIdNew, &length, 0, 0);
1483 ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1484 if ((HDF_SUCCESS != ret) || (configId != configIdNew)) {
1485 HDF_LOGE("%{public}s:%{public}d getConfiguration failed ret:%{public}d", __func__, __LINE__, ret);
1486 return HDF_ERR_IO;
1487 }
1488 if (configId != 0) {
1489 ret = ReOpenDevice(port);
1490 if (ret != HDF_SUCCESS) {
1491 HDF_LOGE("%{public}s:%{public}d ReOpenDevice failed ret:%{public}d", __func__, __LINE__, ret);
1492 return ret;
1493 }
1494 }
1495 return ret;
1496 }
1497
FunSetInterface(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1498 static int32_t FunSetInterface(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1499 {
1500 uint8_t interfaceId = 0;
1501 uint8_t altIndex = 0;
1502 UsbInterfaceHandle *interfaceHandle = NULL;
1503
1504 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
1505 HDF_LOGE("%{public}s: invalid parma", __func__);
1506 return HDF_ERR_INVALID_PARAM;
1507 }
1508
1509 if (!HdfSbufReadUint8(data, &interfaceId)) {
1510 HDF_LOGE("%{public}s:%{public}d failed", __func__, __LINE__);
1511 return HDF_ERR_INVALID_PARAM;
1512 }
1513 if (!HdfSbufReadUint8(data, &altIndex)) {
1514 HDF_LOGE("%{public}s:%{public}d failed", __func__, __LINE__);
1515 return HDF_ERR_INVALID_PARAM;
1516 }
1517
1518 interfaceHandle = InterfaceIdToHandle(port, interfaceId);
1519 if (interfaceHandle == NULL) {
1520 HDF_LOGE(
1521 "%{public}s:%{public}d InterfaceIdToHandle failed bus:%{public}d "
1522 "devAddr:%{public}d interfaceId:%{public}d",
1523 __func__, __LINE__, port->busNum, port->devAddr, interfaceId);
1524 return HDF_FAILURE;
1525 }
1526 if (port->iface[interfaceId] && (port->iface[interfaceId]->info.curAltSetting == altIndex)) {
1527 HDF_LOGE(
1528 "%{public}s:%{public}d bus:%{public}d devAddr:%{public}d "
1529 "interfaceId:%{public}d cur:%{public}d",
1530 __func__, __LINE__, port->busNum, port->devAddr, interfaceId, altIndex);
1531 return HDF_SUCCESS;
1532 }
1533
1534 int32_t ret = UsbSelectInterfaceSetting(interfaceHandle, altIndex, &port->iface[interfaceId]);
1535 if (HDF_SUCCESS == ret) {
1536 UsbdRequestSyncReleaseList(port);
1537 UsbdRequestASyncReleaseList(port);
1538 UsbdBulkASyncListReleasePort(port);
1539 }
1540 return ret;
1541 }
1542
UsbdHdfReadBufAndMalloc(struct HdfSBuf * data,uint8_t ** ptr,uint32_t * length)1543 static bool UsbdHdfReadBufAndMalloc(struct HdfSBuf *data, uint8_t **ptr, uint32_t *length)
1544 {
1545 if ((!data) && (!length) && (!ptr)) {
1546 HDF_LOGE("%{public}s:%{public}d param failed", __func__, __LINE__);
1547 return false;
1548 }
1549 if (!HdfSbufReadUint32(data, length)) {
1550 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1551 return false;
1552 }
1553 if (*length > 0) {
1554 const uint8_t *tclientData = HdfSbufReadUnpadBuffer(data, *length);
1555 if (tclientData == NULL) {
1556 HDF_LOGE("%{public}s:%{public}d read failed length:%{public}d", __func__, __LINE__, *length);
1557 return false;
1558 }
1559 *ptr = (uint8_t *)OsalMemAlloc(*length);
1560 if (!(*ptr)) {
1561 HDF_LOGE("%{public}s:%{public}d OsalMemAlloc fail size:%{public}d", __func__, __LINE__, *length);
1562 return false;
1563 }
1564 int32_t err = memcpy_s(*ptr, *length, tclientData, *length);
1565 if (err != EOK) {
1566 HDF_LOGE("%{public}s:%{public}d memcpy_s fail size:%{public}d", __func__, __LINE__, *length);
1567 OsalMemFree(*ptr);
1568 *ptr = NULL;
1569 return false;
1570 }
1571 } else {
1572 *ptr = NULL;
1573 }
1574 return true;
1575 }
1576
FillReqAyncParams(struct UsbdRequestASync * userData,struct UsbPipeInfo * pipe,struct UsbRequestParams * parmas,uint8_t * buffer,int32_t length)1577 static int32_t FillReqAyncParams(struct UsbdRequestASync *userData, struct UsbPipeInfo *pipe,
1578 struct UsbRequestParams *parmas, uint8_t *buffer, int32_t length)
1579 {
1580 bool bWrite = false;
1581 if ((!userData) || (!pipe) || (!parmas)) {
1582 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1583 return HDF_ERR_INVALID_PARAM;
1584 }
1585 bWrite = (pipe->pipeDirection == USB_PIPE_DIRECTION_OUT);
1586 parmas->interfaceId = pipe->interfaceId;
1587 parmas->pipeAddress = pipe->pipeDirection | pipe->pipeAddress;
1588 parmas->pipeId = pipe->pipeId;
1589 parmas->requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1590 parmas->timeout = USB_CTRL_SET_TIMEOUT;
1591 parmas->dataReq.numIsoPackets = 0;
1592 parmas->userData = (void *)userData;
1593 parmas->dataReq.length = length;
1594 parmas->dataReq.directon = (pipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & 0x1;
1595 if (bWrite) {
1596 parmas->callback = UsbdWriteCallback;
1597 parmas->dataReq.buffer = buffer;
1598 } else {
1599 parmas->callback = UsbdReadCallback;
1600 parmas->dataReq.length = length;
1601 }
1602 return HDF_SUCCESS;
1603 }
1604
UsbdRequestASyncAlloc(void)1605 static struct UsbdRequestASync *UsbdRequestASyncAlloc(void)
1606 {
1607 struct UsbdRequestASync *req = (struct UsbdRequestASync *)OsalMemAlloc(sizeof(struct UsbdRequestASync));
1608 if (req) {
1609 if (memset_s(req, sizeof(struct UsbdRequestASync), 0, sizeof(struct UsbdRequestASync)) != EOK) {
1610 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
1611 OsalMemFree(req);
1612 return NULL;
1613 }
1614 req->reqMsg.request = NULL;
1615 req->endPointAddr = 0;
1616 req->ifHandle = NULL;
1617 req->status = 0;
1618 OsalMutexInit(&req->lock);
1619 }
1620 return req;
1621 }
1622
UsbdRequestASyncInit(struct HostDevice * port,UsbInterfaceHandle * ifHandle,struct UsbPipeInfo * pipe,struct UsbdRequestASync * request)1623 static int32_t UsbdRequestASyncInit(struct HostDevice *port, UsbInterfaceHandle *ifHandle,
1624 struct UsbPipeInfo *pipe, struct UsbdRequestASync *request)
1625 {
1626 int32_t ret = HDF_SUCCESS;
1627 if ((port == NULL) || (request == NULL) || (ifHandle == NULL) || (pipe == NULL)) {
1628 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1629 return HDF_ERR_INVALID_PARAM;
1630 }
1631 memcpy_s(&request->pipe, sizeof(struct UsbPipeInfo), pipe, sizeof(struct UsbPipeInfo));
1632 request->ifHandle = ifHandle;
1633 request->reqMsg.request = UsbAllocRequest(request->ifHandle, 0, request->pipe.maxPacketSize);
1634 if (request->reqMsg.request == NULL) {
1635 HDF_LOGE("%{public}s:%{public}d alloc request faild\n", __func__, __LINE__);
1636 return HDF_ERR_MALLOC_FAIL;
1637 }
1638 FillReqAyncParams(request, &request->pipe, &request->params, NULL, 0);
1639 OsalMutexLock(&port->reqASyncLock);
1640 HdfSListAddTail(&port->reqASyncList, &request->node);
1641 OsalMutexUnlock(&port->reqASyncLock);
1642 return ret;
1643 }
1644
UsbdRequestASyncCreatAndInsert(struct HostDevice * port,uint8_t interfaceId,uint8_t pipeAddr)1645 static struct UsbdRequestASync *UsbdRequestASyncCreatAndInsert(struct HostDevice *port, uint8_t interfaceId,
1646 uint8_t pipeAddr)
1647 {
1648 int32_t ret = HDF_SUCCESS;
1649 struct UsbdRequestASync *req = NULL;
1650 UsbInterfaceHandle *ifHandle = NULL;
1651 struct UsbPipeInfo pipe;
1652 if (memset_s(&pipe, sizeof(struct UsbPipeInfo), 0, sizeof(struct UsbPipeInfo)) != EOK) {
1653 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
1654 return NULL;
1655 }
1656 ret = GetPipe(port, interfaceId, pipeAddr, &pipe);
1657 if (ret != HDF_SUCCESS) {
1658 HDF_LOGE(
1659 "%{public}s: get pipe info failed interfaceId=%{public}d, "
1660 "pipeAddr=%{public}d",
1661 __func__, interfaceId, pipeAddr);
1662 return NULL;
1663 }
1664 ifHandle = InterfaceIdToHandle(port, interfaceId);
1665 if (ifHandle == NULL) {
1666 HDF_LOGE("%{public}s:%{public}d get interface handle faild \n", __func__, __LINE__);
1667 return NULL;
1668 }
1669 req = UsbdRequestASyncAlloc();
1670 if (req) {
1671 ret = UsbdRequestASyncInit(port, ifHandle, &pipe, req);
1672 if (HDF_SUCCESS != ret) {
1673 HDF_LOGE("%{public}s:%{public}d UsbdRequestASyncInit faild:%{public}d\n", __func__, __LINE__, ret);
1674 UsbdRequestASyncRelease(req);
1675 req = NULL;
1676 return NULL;
1677 }
1678 }
1679 return req;
1680 }
1681
UsbdFindRequestASync(struct HostDevice * port,uint8_t interfaceId,uint8_t pipeAddr)1682 static struct UsbdRequestASync *UsbdFindRequestASync(struct HostDevice *port, uint8_t interfaceId, uint8_t pipeAddr)
1683 {
1684 struct UsbdRequestASync *req = NULL;
1685 struct HdfSListIterator it;
1686 uint8_t reqnum = 0;
1687 uint8_t usenum = 0;
1688 bool flag = false;
1689 if (!port) {
1690 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1691 return NULL;
1692 }
1693 OsalMutexLock(&port->reqASyncLock);
1694 HdfSListIteratorInit(&it, &port->reqASyncList);
1695 while (HdfSListIteratorHasNext(&it)) {
1696 req = (struct UsbdRequestASync *)HdfSListIteratorNext(&it);
1697 if (!req) {
1698 continue;
1699 }
1700 if ((req->pipe.interfaceId == interfaceId) && ((req->pipe.pipeAddress | req->pipe.pipeDirection) == pipeAddr)) {
1701 reqnum++;
1702 if (req->status) {
1703 usenum++;
1704 } else {
1705 flag = true;
1706 break;
1707 }
1708 }
1709 }
1710 OsalMutexUnlock(&port->reqASyncLock);
1711
1712 if (flag) {
1713 if (req) {
1714 OsalMutexLock(&req->lock);
1715 req->status = 1;
1716 OsalMutexUnlock(&req->lock);
1717 }
1718 return req;
1719 } else {
1720 if (reqnum < MAX_REQUESTASYNC_NUM) {
1721 req = UsbdRequestASyncCreatAndInsert(port, interfaceId, pipeAddr);
1722 if (req) {
1723 OsalMutexLock(&req->lock);
1724 req->status = 1;
1725 OsalMutexUnlock(&req->lock);
1726 }
1727 return req;
1728 }
1729 }
1730 return NULL;
1731 }
1732
UsbReqQueueParamInfo(struct HdfSBuf * data,uint8_t * interfaceId,uint8_t * pipeAddr)1733 static int32_t UsbReqQueueParamInfo(struct HdfSBuf *data, uint8_t *interfaceId, uint8_t *pipeAddr)
1734 {
1735 if ((!data) || (!interfaceId) || (!pipeAddr)) {
1736 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1737 return HDF_ERR_INVALID_PARAM;
1738 }
1739 if (!HdfSbufReadUint8(data, interfaceId)) {
1740 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1741 return HDF_ERR_INVALID_PARAM;
1742 }
1743 if (!HdfSbufReadUint8(data, pipeAddr)) {
1744 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1745 return HDF_ERR_INVALID_PARAM;
1746 }
1747 return HDF_SUCCESS;
1748 }
1749
FunRequestQueueFillAndSubmit(struct HostDevice * port,struct UsbdRequestASync * reqAsync,uint8_t * buffer,uint32_t length)1750 static int32_t FunRequestQueueFillAndSubmit(struct HostDevice *port, struct UsbdRequestASync *reqAsync, uint8_t *buffer,
1751 uint32_t length)
1752 {
1753 if ((port == NULL) || (reqAsync == NULL)) {
1754 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1755 return HDF_ERR_INVALID_PARAM;
1756 }
1757
1758 FillReqAyncParams(reqAsync, &reqAsync->pipe, &reqAsync->params, buffer, length);
1759 int32_t ret = UsbFillRequest(reqAsync->reqMsg.request, reqAsync->ifHandle, &reqAsync->params);
1760 if (HDF_SUCCESS != ret) {
1761 HDF_LOGE("%{public}s:%{public}d UsbFillRequest faile, ret=%{public}d \n", __func__, __LINE__, ret);
1762 OsalMutexLock(&reqAsync->lock);
1763 reqAsync->reqMsg.clientData = NULL;
1764 reqAsync->reqMsg.clientLength = 0;
1765 reqAsync->params.dataReq.buffer = NULL;
1766 reqAsync->params.dataReq.length = 0;
1767 reqAsync->status = 0;
1768 OsalMutexUnlock(&reqAsync->lock);
1769 return ret;
1770 }
1771
1772 OsalSemInit(&((struct UsbIfRequest *)reqAsync->reqMsg.request)->hostRequest->sem, 0);
1773 ret = UsbSubmitRequestAsync(reqAsync->reqMsg.request);
1774 if (HDF_SUCCESS == ret) {
1775 OsalMutexLock(&port->requestLock);
1776 HdfSListAddTail(&port->requestQueue, &reqAsync->qNode);
1777 OsalMutexUnlock(&port->requestLock);
1778 } else {
1779 HDF_LOGE("%{public}s:%{public}d UsbSubmitRequestAsync faile, ret=%{public}d", __func__, __LINE__, ret);
1780 OsalMutexLock(&reqAsync->lock);
1781 reqAsync->status = 0;
1782 reqAsync->reqMsg.clientData = NULL;
1783 reqAsync->reqMsg.clientLength = 0;
1784 reqAsync->params.dataReq.buffer = NULL;
1785 reqAsync->params.dataReq.length = 0;
1786 OsalMutexUnlock(&reqAsync->lock);
1787 }
1788
1789 return ret;
1790 }
1791
FunRequestQueue(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1792 static int32_t FunRequestQueue(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1793 {
1794 uint8_t *clientData = NULL;
1795 uint8_t *buffer = NULL;
1796 uint32_t clientLength = 0;
1797 uint32_t length = 0;
1798 struct UsbdRequestASync *reqAsync = NULL;
1799 uint8_t interfaceId = 0;
1800 uint8_t pipeAddr = 0;
1801 if ((port == NULL) || (reply == NULL) || (data == NULL)) {
1802 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1803 return HDF_ERR_INVALID_PARAM;
1804 }
1805 int32_t ret = UsbReqQueueParamInfo(data, &interfaceId, &pipeAddr);
1806 if (HDF_SUCCESS != ret) {
1807 HDF_LOGE("%{public}s:%{public}d UsbReqQueueParamInfo fail", __func__, __LINE__);
1808 return ret;
1809 }
1810 if (!UsbdHdfReadBufAndMalloc(data, &clientData, &clientLength) ||
1811 !UsbdHdfReadBufAndMalloc(data, &buffer, &length)) {
1812 HDF_LOGE("%{public}s:%{public}d UsbdHdfReadBufAndMalloc fail", __func__, __LINE__);
1813 OsalMemFree(buffer);
1814 buffer = NULL;
1815 OsalMemFree(clientData);
1816 clientData = NULL;
1817 return HDF_ERR_INVALID_PARAM;
1818 }
1819 reqAsync = UsbdFindRequestASync(port, interfaceId, pipeAddr);
1820 if (!reqAsync) {
1821 HDF_LOGE("%{public}s:%{public}d UsbdFindRequestASync fail", __func__, __LINE__);
1822 OsalMemFree(buffer);
1823 buffer = NULL;
1824 OsalMemFree(clientData);
1825 clientData = NULL;
1826 return HDF_ERR_DEVICE_BUSY;
1827 }
1828
1829 reqAsync->reqMsg.clientData = (void *)clientData;
1830 reqAsync->reqMsg.clientLength = clientLength;
1831 ret = FunRequestQueueFillAndSubmit(port, reqAsync, buffer, length);
1832 if (HDF_SUCCESS != ret) {
1833 HDF_LOGE("%{public}s:%{public}d FunRequestQueueFillAndSubmit fail:%{public}d", __func__, __LINE__, ret);
1834 OsalMemFree(clientData);
1835 clientData = NULL;
1836 }
1837 OsalMemFree(buffer);
1838 buffer = NULL;
1839 return ret;
1840 }
1841
GetRequestMsgFromQueue(struct HostDevice * port,struct UsbdRequestASync ** reqMsg)1842 static int32_t GetRequestMsgFromQueue(struct HostDevice *port, struct UsbdRequestASync **reqMsg)
1843 {
1844 struct HdfSListNode *requestNode = NULL;
1845 int32_t requestCount = 0;
1846 if (port == NULL) {
1847 HDF_LOGE("%{public}s: invalid parma", __func__);
1848 return HDF_ERR_INVALID_PARAM;
1849 }
1850 OsalMutexLock(&port->requestLock);
1851 if (!HdfSListIsEmpty(&port->requestQueue)) {
1852 requestNode = HdfSListPop(&port->requestQueue);
1853 requestCount = HdfSListCount(&port->requestQueue);
1854 }
1855 OsalMutexUnlock(&port->requestLock);
1856 if (requestNode == NULL) {
1857 HDF_LOGE("%{public}s:%{public}d request node is null", __func__, __LINE__);
1858 return HDF_FAILURE;
1859 }
1860 *reqMsg = HDF_SLIST_CONTAINER_OF(struct HdfSListNode, requestNode, struct UsbdRequestASync, qNode);
1861 if (*reqMsg == NULL) {
1862 HDF_LOGE("%{public}s:%{public}d request msg is null", __func__, __LINE__);
1863 return HDF_FAILURE;
1864 }
1865 return HDF_SUCCESS;
1866 }
1867
GetRequestMsgData(struct HostDevice * port,struct UsbdRequestASync * reqMsg,int32_t timeout,uint8_t ** buffer,uint32_t * length)1868 static int32_t GetRequestMsgData(struct HostDevice *port, struct UsbdRequestASync *reqMsg, int32_t timeout,
1869 uint8_t **buffer, uint32_t *length)
1870 {
1871 int32_t ret = HDF_SUCCESS;
1872 if ((reqMsg == NULL) || (reqMsg->reqMsg.request == NULL)) {
1873 HDF_LOGE("%{public}s: invalid parma request %{public}p", __func__, reqMsg);
1874 return HDF_ERR_INVALID_PARAM;
1875 }
1876 if ((int32_t)(reqMsg->reqMsg.request->compInfo.status) == -1) {
1877 ret = OsalSemWait(&((struct UsbIfRequest *)reqMsg->reqMsg.request)->hostRequest->sem, timeout);
1878 if (HDF_SUCCESS != ret) {
1879 HDF_LOGE("%{public}s:%{public}d OsalSemWait failed, ret=%{public}d", __func__, __LINE__, ret);
1880 OsalMutexLock(&port->requestLock);
1881 HdfSListAdd(&port->requestQueue, &reqMsg->qNode);
1882 OsalMutexUnlock(&port->requestLock);
1883 return ret;
1884 }
1885 }
1886
1887 OsalMutexLock(&reqMsg->lock);
1888 *length = reqMsg->reqMsg.length;
1889 *buffer = reqMsg->reqMsg.buffer;
1890 reqMsg->reqMsg.buffer = NULL;
1891 reqMsg->reqMsg.length = 0;
1892 reqMsg->status = 0;
1893 OsalMutexUnlock(&reqMsg->lock);
1894 return ret;
1895 }
1896
FunRequestWait(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1897 static int32_t FunRequestWait(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1898 {
1899 struct UsbdRequestASync *reqMsg = NULL;
1900 uint8_t *buffer = NULL;
1901 uint32_t length = 0;
1902 int32_t timeout = 0;
1903 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
1904 HDF_LOGE("%{public}s: invalid parma", __func__);
1905 return HDF_ERR_INVALID_PARAM;
1906 }
1907 if (!HdfSbufReadInt32(data, &timeout)) {
1908 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1909 return HDF_ERR_INVALID_PARAM;
1910 }
1911 int32_t ret = GetRequestMsgFromQueue(port, &reqMsg);
1912 if ((HDF_SUCCESS != ret) || (!reqMsg) || (!reqMsg->reqMsg.request)) {
1913 HDF_LOGE("%{public}s:%{public}d GetRequestMsgFromQueue error:%{public}d", __func__, __LINE__, ret);
1914 return ret;
1915 }
1916
1917 if ((int32_t)(reqMsg->reqMsg.request->compInfo.status) == -1) {
1918 ret = OsalSemWait(&((struct UsbIfRequest *)reqMsg->reqMsg.request)->hostRequest->sem, timeout);
1919 if (HDF_SUCCESS != ret) {
1920 HDF_LOGE("%{public}s:%{public}d OsalSemWait failed, ret=%{public}d", __func__, __LINE__, ret);
1921 OsalMutexLock(&port->requestLock);
1922 HdfSListAdd(&port->requestQueue, &reqMsg->qNode);
1923 OsalMutexUnlock(&port->requestLock);
1924 return ret;
1925 }
1926 }
1927
1928 ret = GetRequestMsgData(port, reqMsg, timeout, &buffer, &length);
1929 if (HDF_SUCCESS != ret) {
1930 HDF_LOGE("%{public}s:%{public}d GetRequestMsgData error:%{public}d", __func__, __LINE__, ret);
1931 return ret;
1932 }
1933 if (!UsbdHdfWriteBuf(reply, reqMsg->reqMsg.clientData, reqMsg->reqMsg.clientLength)) {
1934 ret = HDF_ERR_IO;
1935 HDF_LOGE("%{public}s:%{public}d HdfSbufWriteBuffer failed", __func__, __LINE__);
1936 }
1937 if (!UsbdHdfWriteBuf(reply, reqMsg->reqMsg.request->compInfo.buffer, reqMsg->reqMsg.request->compInfo.length)) {
1938 ret = HDF_ERR_IO;
1939 HDF_LOGE("%{public}s:%{public}d HdfSbufWriteBuffer failed", __func__, __LINE__);
1940 }
1941 UsbdRequestASyncReleaseData(reqMsg);
1942 return ret;
1943 }
1944
FunRequestCancel(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1945 static int32_t FunRequestCancel(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1946 {
1947 struct UsbdRequestASync *reqMsg = NULL;
1948 uint8_t interfaceId = 0;
1949 uint8_t endpointId = 0;
1950 int32_t ret = HDF_FAILURE;
1951
1952 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
1953 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1954 return HDF_ERR_INVALID_PARAM;
1955 }
1956
1957 if (!HdfSbufReadUint8(data, &interfaceId)) {
1958 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1959 return HDF_ERR_INVALID_PARAM;
1960 }
1961 if (!HdfSbufReadUint8(data, &endpointId)) {
1962 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1963 return HDF_ERR_INVALID_PARAM;
1964 }
1965
1966 while (HDF_SUCCESS == GetRequestMsgFromQueue(port, &reqMsg)) {
1967 if (reqMsg) {
1968 ret = UsbCancelRequest(reqMsg->reqMsg.request);
1969 if (ret != HDF_SUCCESS) {
1970 HDF_LOGW("%{public}s:%{public}d request cancel failed = %{public}d", __func__, __LINE__, ret);
1971 }
1972 OsalMutexLock(&reqMsg->lock);
1973 UsbdRequestASyncReleaseData(reqMsg);
1974 reqMsg->status = 0;
1975 OsalMutexUnlock(&reqMsg->lock);
1976 }
1977 reqMsg = NULL;
1978 }
1979 return HDF_SUCCESS;
1980 }
1981
FunOpenDevice(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)1982 static int32_t FunOpenDevice(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
1983 {
1984 if ((port == NULL) || (data == NULL) || (reply == NULL)) {
1985 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1986 return HDF_ERR_INVALID_PARAM;
1987 }
1988 port->initFlag = true;
1989 return HDF_SUCCESS;
1990 }
1991
FunCloseDevice(struct HostDevice * port,struct HdfSBuf * data)1992 static int32_t FunCloseDevice(struct HostDevice *port, struct HdfSBuf *data)
1993 {
1994 if (port == NULL) {
1995 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
1996 return HDF_ERR_INVALID_PARAM;
1997 }
1998 port->initFlag = false;
1999 return HDF_SUCCESS;
2000 }
2001
FunSetRole(struct HdfSBuf * data,struct HdfSBuf * reply,struct UsbdService * service)2002 static int32_t FunSetRole(struct HdfSBuf *data, struct HdfSBuf *reply, struct UsbdService *service)
2003 {
2004 int32_t portId = 0;
2005 int32_t powerRole = 0;
2006 int32_t dataRole = 0;
2007 if (!HdfSbufReadInt32(data, &portId)) {
2008 HDF_LOGE("%{public}s:%{public}d Read data faild", __func__, __LINE__);
2009 return HDF_ERR_IO;
2010 }
2011 if (!HdfSbufReadInt32(data, &powerRole)) {
2012 HDF_LOGE("%{public}s:%{public}d Read data faild", __func__, __LINE__);
2013 return HDF_ERR_IO;
2014 }
2015 if (!HdfSbufReadInt32(data, &dataRole)) {
2016 HDF_LOGE("%{public}s:%{public}d Read data faild", __func__, __LINE__);
2017 return HDF_ERR_IO;
2018 }
2019
2020 int32_t ret = SetPort(portId, powerRole, dataRole, service);
2021 if (ret != HDF_SUCCESS) {
2022 HDF_LOGE("%{public}s:%{public}d FunSetRole faild, ret=%{public}d", __func__, __LINE__, ret);
2023 return ret;
2024 }
2025 if (reply) {
2026 HdfSbufWriteInt32(reply, ret);
2027 }
2028
2029 return HDF_SUCCESS;
2030 }
2031
FunQueryPort(struct HdfSBuf * data,struct HdfSBuf * reply,struct UsbdService * service)2032 static int32_t FunQueryPort(struct HdfSBuf *data, struct HdfSBuf *reply, struct UsbdService *service)
2033 {
2034 int32_t portId = 0;
2035 int32_t powerRole = 0;
2036 int32_t dataRole = 0;
2037 int32_t mode = 0;
2038 int32_t ret = QueryPort(&portId, &powerRole, &dataRole, &mode, service);
2039 if (ret != HDF_SUCCESS) {
2040 HDF_LOGE("%{public}s:%{public}d QueryPort faild, ret=%{public}d", __func__, __LINE__, ret);
2041 return ret;
2042 }
2043 if (reply) {
2044 HdfSbufWriteInt32(reply, portId);
2045 HdfSbufWriteInt32(reply, powerRole);
2046 HdfSbufWriteInt32(reply, dataRole);
2047 HdfSbufWriteInt32(reply, mode);
2048 }
2049 return HDF_SUCCESS;
2050 }
2051
FunGetCurrentFunctions(struct HdfSBuf * data,struct HdfSBuf * reply)2052 static int32_t FunGetCurrentFunctions(struct HdfSBuf *data, struct HdfSBuf *reply)
2053 {
2054 int32_t funcs = UsbdGetFunction();
2055 if (reply) {
2056 HdfSbufWriteInt32(reply, funcs);
2057 }
2058
2059 return HDF_SUCCESS;
2060 }
2061
FunSetCurrentFunctions(struct HdfSBuf * data,struct HdfSBuf * reply)2062 static int32_t FunSetCurrentFunctions(struct HdfSBuf *data, struct HdfSBuf *reply)
2063 {
2064 int32_t funcs = 0;
2065 HdfSbufReadInt32(data, &funcs);
2066 int32_t ret = UsbdSetFunction(funcs);
2067 if (ret != HDF_SUCCESS) {
2068 HDF_LOGE("%{public}s:%{public}d FunSetCurrentFunctions faild, ret=%{public}d", __func__, __LINE__, ret);
2069 return ret;
2070 }
2071 return HDF_SUCCESS;
2072 }
2073
DispatchBindUsbSubscriber(struct UsbdService * service,struct HdfSBuf * data)2074 static int32_t DispatchBindUsbSubscriber(struct UsbdService *service, struct HdfSBuf *data)
2075 {
2076 struct UsbdSubscriber *subscriber = NULL;
2077 if (service == NULL || data == NULL) {
2078 HDF_LOGE("%{public}s:%{public}d param is NULL", __func__, __LINE__);
2079 return HDF_ERR_INVALID_PARAM;
2080 }
2081 struct HdfRemoteService *remoteService = HdfSbufReadRemoteService(data);
2082 if (remoteService == NULL) {
2083 HDF_LOGE("%{public}s: remoteService is NULL", __func__);
2084 return HDF_ERR_INVALID_PARAM;
2085 }
2086
2087 subscriber = (struct UsbdSubscriber *)OsalMemCalloc(sizeof(struct UsbdSubscriber));
2088 if (subscriber == NULL) {
2089 HDF_LOGE("%{public}s: calloc subscriber error", __func__);
2090 return HDF_ERR_MALLOC_FAIL;
2091 }
2092 if (memset_s(subscriber, sizeof(struct UsbdSubscriber), 0, sizeof(struct UsbdSubscriber)) != EOK) {
2093 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
2094 OsalMemFree(subscriber);
2095 return HDF_FAILURE;
2096 }
2097 subscriber->remoteService = remoteService;
2098 return BindUsbSubscriber(service, subscriber);
2099 }
2100
DispatchUnbindUsbSubscriber(struct UsbdService * service)2101 static int32_t DispatchUnbindUsbSubscriber(struct UsbdService *service)
2102 {
2103 if (service == NULL) {
2104 HDF_LOGE("%{public}s:%{public}d param is NULL", __func__, __LINE__);
2105 return HDF_ERR_INVALID_PARAM;
2106 }
2107 return UnbindUsbSubscriber(service);
2108 }
2109
FunGetRawDeviceDescriptor(struct HostDevice * port,struct HdfSBuf * reply)2110 static int32_t FunGetRawDeviceDescriptor(struct HostDevice *port, struct HdfSBuf *reply)
2111 {
2112 int32_t ret = HDF_SUCCESS;
2113
2114 if ((port == NULL) || (reply == NULL)) {
2115 HDF_LOGE("%{public}s:%{public}d mangf invalid parma", __func__, __LINE__);
2116 return HDF_ERR_INVALID_PARAM;
2117 }
2118
2119 if (port->ctrDevHandle == NULL) {
2120 HDF_LOGE("%{public}s:%{public}d devHandle fail ", __func__, __LINE__);
2121 return HDF_ERR_INVALID_OBJECT;
2122 }
2123 struct UsbInterfaceHandleEntity *handle = (struct UsbInterfaceHandleEntity *)port->ctrDevHandle;
2124 OsalMutexLock(&handle->devHandle->lock);
2125 uint8_t *ptr = handle->devHandle->dev->descriptors;
2126 uint32_t length = handle->devHandle->dev->descriptorsLength;
2127 if (!UsbdHdfWriteBuf(reply, ptr, length)) {
2128 HDF_LOGE("%{public}s:%{public}d WriteBuffer fail ", __func__, __LINE__);
2129 ret = HDF_ERR_IO;
2130 }
2131 OsalMutexUnlock(&handle->devHandle->lock);
2132
2133 return ret;
2134 }
2135
FunGetFileDescriptor(struct HostDevice * port,struct HdfSBuf * reply)2136 static int32_t FunGetFileDescriptor(struct HostDevice *port, struct HdfSBuf *reply)
2137 {
2138 if ((port == NULL) || (reply == NULL)) {
2139 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2140 return HDF_ERR_INVALID_PARAM;
2141 }
2142 if (port->ctrDevHandle == NULL) {
2143 HDF_LOGE("%{public}s:%{public}d devHandle fail ", __func__, __LINE__);
2144 return HDF_ERR_INVALID_OBJECT;
2145 }
2146 struct UsbInterfaceHandleEntity *handle = (struct UsbInterfaceHandleEntity *)port->ctrDevHandle;
2147 OsalMutexLock(&handle->devHandle->lock);
2148 int32_t fd = handle->devHandle->fd;
2149 OsalMutexUnlock(&handle->devHandle->lock);
2150 if (!HdfSbufWriteInt32(reply, fd)) {
2151 HDF_LOGE("%{public}s:%{public}d writeint32 fail fd:%{public}d", __func__, __LINE__, fd);
2152 return HDF_ERR_IO;
2153 }
2154 return HDF_SUCCESS;
2155 }
2156
FindDevFromService(struct UsbdService * service,uint8_t busNum,uint8_t devAddr)2157 static struct HostDevice *FindDevFromService(struct UsbdService *service, uint8_t busNum, uint8_t devAddr)
2158 {
2159 struct HdfSListIterator it;
2160 struct HostDevice *port = NULL;
2161 bool flag = false;
2162 if (!service) {
2163 return NULL;
2164 }
2165
2166 OsalMutexLock(&service->lock);
2167 HdfSListIteratorInit(&it, &service->devList);
2168 while (HdfSListIteratorHasNext(&it)) {
2169 port = (struct HostDevice *)HdfSListIteratorNext(&it);
2170 if (!port) {
2171 continue;
2172 }
2173 if ((port->busNum == busNum) && (port->devAddr == devAddr)) {
2174 flag = true;
2175 break;
2176 }
2177 }
2178 OsalMutexUnlock(&service->lock);
2179 if (!flag) {
2180 return NULL;
2181 }
2182 return port;
2183 }
2184
HostDeviceInit(struct HostDevice * port)2185 static int32_t HostDeviceInit(struct HostDevice *port)
2186 {
2187 if (!port) {
2188 HDF_LOGE("%{public}s:%{public}d param failed", __func__, __LINE__);
2189 return HDF_ERR_INVALID_OBJECT;
2190 }
2191 port->busNum = 0;
2192 port->devAddr = 0;
2193 port->initFlag = false;
2194 port->interfaceCnt = 0;
2195
2196 if (OsalMutexInit(&port->lock) != HDF_SUCCESS) {
2197 HDF_LOGE("%{public}s:%{public}d init lock fail!", __func__, __LINE__);
2198 return HDF_FAILURE;
2199 }
2200 if (OsalMutexInit(&port->requestLock) != HDF_SUCCESS) {
2201 HDF_LOGE("%{public}s:%{public}d init lock fail!", __func__, __LINE__);
2202 return HDF_FAILURE;
2203 }
2204 if (OsalMutexInit(&port->writeLock) != HDF_SUCCESS) {
2205 HDF_LOGE("%{public}s:%{public}d init lock fail!", __func__, __LINE__);
2206 return HDF_FAILURE;
2207 }
2208 if (OsalMutexInit(&port->readLock) != HDF_SUCCESS) {
2209 HDF_LOGE("%{public}s:%{public}d init lock fail!", __func__, __LINE__);
2210 return HDF_FAILURE;
2211 }
2212 if (OsalMutexInit(&port->reqSyncLock) != HDF_SUCCESS) {
2213 HDF_LOGE("%{public}s:%{public}d init lock fail!", __func__, __LINE__);
2214 return HDF_FAILURE;
2215 }
2216 if (OsalMutexInit(&port->reqASyncLock) != HDF_SUCCESS) {
2217 HDF_LOGE("%{public}s:%{public}d init lock fail!", __func__, __LINE__);
2218 return HDF_FAILURE;
2219 }
2220 HdfSListInit(&port->requestQueue);
2221 HdfSListInit(&port->reqSyncList);
2222 HdfSListInit(&port->reqASyncList);
2223 return HDF_SUCCESS;
2224 }
2225
HostDeviceCreate(struct HostDevice ** port)2226 int32_t HostDeviceCreate(struct HostDevice **port)
2227 {
2228 struct HostDevice *tmp = NULL;
2229 if (!port) {
2230 return HDF_FAILURE;
2231 }
2232 tmp = (struct HostDevice *)OsalMemCalloc(sizeof(struct HostDevice));
2233 if (!tmp) {
2234 HDF_LOGE("%{public}s:%{public}d Alloc usb host device failed", __func__, __LINE__);
2235 return HDF_ERR_MALLOC_FAIL;
2236 }
2237 if (memset_s(tmp, sizeof(struct HostDevice), 0, sizeof(struct HostDevice)) != EOK) {
2238 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
2239 OsalMemFree(tmp);
2240 return HDF_FAILURE;
2241 }
2242
2243 int32_t ret = HostDeviceInit(tmp);
2244 if (ret != HDF_SUCCESS) {
2245 HDF_LOGE("%{public}s:%{public}d HostDeviceInit fail!", __func__, __LINE__);
2246 OsalMemFree(tmp);
2247 return ret;
2248 }
2249
2250 tmp->initFlag = false;
2251 *port = tmp;
2252 return HDF_SUCCESS;
2253 }
2254
UsbdRealseDevices(struct UsbdService * service)2255 int32_t UsbdRealseDevices(struct UsbdService *service)
2256 {
2257 if (!service) {
2258 return HDF_ERR_INVALID_PARAM;
2259 }
2260 OsalMutexLock(&service->lock);
2261 while (!HdfSListIsEmpty(&service->devList)) {
2262 struct HostDevice *port = (struct HostDevice *)HdfSListPop(&service->devList);
2263 if (port) {
2264 UsbdRelease(port);
2265 OsalMemFree(port);
2266 port = NULL;
2267 }
2268 }
2269 OsalMutexUnlock(&service->lock);
2270 return HDF_SUCCESS;
2271 }
2272
FunAttachDevice(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)2273 int32_t FunAttachDevice(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
2274 {
2275 int32_t ret = HDF_SUCCESS;
2276 if (port == NULL) {
2277 HDF_LOGE("%{public}s:%{public}d mangf invalid parma", __func__, __LINE__);
2278 return HDF_ERR_INVALID_PARAM;
2279 }
2280 if (port->initFlag) {
2281 HDF_LOGE(
2282 "%{public}s:%{public}d device is already on flag:%{public}d "
2283 "bus:%{public}d dev:%{public}d",
2284 __func__, __LINE__, port->initFlag, port->busNum, port->devAddr);
2285 return HDF_SUCCESS;
2286 }
2287
2288 do {
2289 ret = UsbdInit(port);
2290 if (ret != HDF_SUCCESS) {
2291 HDF_LOGE("%{public}s:%{public}d mangf UsbInit failed ret:%{public}d", __func__, __LINE__, ret);
2292 UsbdRelease(port);
2293 RemoveDevFromService(port->service, port);
2294 OsalMemFree(port);
2295 return ret;
2296 }
2297 ret = UsbdAllocFifo(&port->readFifo, READ_BUF_SIZE);
2298 if (ret != HDF_SUCCESS) {
2299 HDF_LOGE("%{public}s:%{public}d mangf UsbAllocFifo failed ret:%{public}d", __func__, __LINE__, ret);
2300 ret = HDF_ERR_INVALID_PARAM;
2301 break;
2302 }
2303 if (HDF_SUCCESS == ret) {
2304 port->initFlag = true;
2305 HDF_LOGI("%{public}s:%{public}d UsbOpen success", __func__, __LINE__);
2306 } else {
2307 HDF_LOGE("%{public}s:%{public}d UsbOpen fail:%{public}d", __func__, __LINE__, ret);
2308 }
2309 return ret;
2310 } while (0);
2311
2312 UsbdFreeFifo(&port->readFifo);
2313 UsbdRelease(port);
2314 RemoveDevFromService(port->service, port);
2315 OsalMemFree(port);
2316
2317 return ret;
2318 }
2319
UsbdDeviceCreateAndAttach(struct UsbdService * service,uint8_t busNum,uint8_t devAddr)2320 int32_t UsbdDeviceCreateAndAttach(struct UsbdService *service, uint8_t busNum, uint8_t devAddr)
2321 {
2322 struct HostDevice *port = NULL;
2323 if (!service) {
2324 HDF_LOGE("%{public}s:%{public}d invalid param!", __func__, __LINE__);
2325 return HDF_ERR_INVALID_PARAM;
2326 }
2327
2328 int32_t ret = HostDeviceCreate(&port);
2329 if (ret == HDF_SUCCESS) {
2330 port->busNum = busNum;
2331 port->devAddr = devAddr;
2332 port->service = service;
2333 OsalMutexLock(&service->lock);
2334 HdfSListAdd(&service->devList, &port->node);
2335 OsalMutexUnlock(&service->lock);
2336 ret = FunAttachDevice(port, NULL, NULL);
2337 port = NULL;
2338 } else {
2339 HDF_LOGE("%{public}s:%{public}d createdevice error ret:%{public}d", __func__, __LINE__, ret);
2340 }
2341
2342 return ret;
2343 }
2344
FunDetachDevice(struct HostDevice * port,struct HdfSBuf * data)2345 int32_t FunDetachDevice(struct HostDevice *port, struct HdfSBuf *data)
2346 {
2347 if (port == NULL) {
2348 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2349 return HDF_ERR_INVALID_PARAM;
2350 }
2351
2352 RemoveDevFromService(port->service, port);
2353 UsbdRelease(port);
2354 UsbdFreeFifo(&port->readFifo);
2355 OsalMemFree(port);
2356
2357 return HDF_SUCCESS;
2358 }
2359
UsbdDeviceDettach(struct UsbdService * service,uint8_t busNum,uint8_t devAddr)2360 int32_t UsbdDeviceDettach(struct UsbdService *service, uint8_t busNum, uint8_t devAddr)
2361 {
2362 if (!service) {
2363 HDF_LOGE("%{public}s:%{public}d invalid param!", __func__, __LINE__);
2364 return HDF_ERR_INVALID_PARAM;
2365 }
2366 struct HostDevice *port = FindDevFromService(service, busNum, devAddr);
2367 int32_t ret = FunDetachDevice(port, NULL);
2368 port = NULL;
2369 return ret;
2370 }
2371
UsbdFindDevForBusNum(struct UsbdService * service,uint8_t busNum)2372 struct HostDevice *UsbdFindDevForBusNum(struct UsbdService *service, uint8_t busNum)
2373 {
2374 struct HdfSListIterator it;
2375 uint8_t flg = false;
2376 struct HostDevice *tempPort = NULL;
2377 if (!service) {
2378 return NULL;
2379 }
2380 OsalMutexLock(&service->lock);
2381 HdfSListIteratorInit(&it, &service->devList);
2382 while (HdfSListIteratorHasNext(&it)) {
2383 tempPort = (struct HostDevice *)HdfSListIteratorNext(&it);
2384 if (!tempPort) {
2385 continue;
2386 }
2387 if (tempPort->busNum == busNum) {
2388 HdfSListIteratorRemove(&it);
2389 flg = true;
2390 break;
2391 }
2392 }
2393 OsalMutexUnlock(&service->lock);
2394 if (flg) {
2395 return tempPort;
2396 }
2397 return NULL;
2398 }
2399
UsbdRemoveBusDev(struct UsbdService * service,uint8_t busNum)2400 int32_t UsbdRemoveBusDev(struct UsbdService *service, uint8_t busNum)
2401 {
2402 struct HostDevice *tempPort = NULL;
2403 while (1) {
2404 tempPort = UsbdFindDevForBusNum(service, busNum);
2405 if (!tempPort) {
2406 break;
2407 }
2408 NotifySubscriberDevice(service->subscriber, ACT_DEVDOWN, tempPort->busNum, tempPort->devAddr);
2409
2410 UsbdRelease(tempPort);
2411
2412 UsbdFreeFifo(&tempPort->readFifo);
2413
2414 OsalMemFree(tempPort);
2415 tempPort = NULL;
2416 }
2417 return HDF_SUCCESS;
2418 }
2419
UsbdBulkASyncReqInit(struct UsbdBulkASyncReqList * list,struct UsbdBulkASyncList * pList)2420 static int32_t UsbdBulkASyncReqInit(struct UsbdBulkASyncReqList *list, struct UsbdBulkASyncList *pList)
2421 {
2422 int32_t ret = HDF_SUCCESS;
2423 int32_t i = 0;
2424 DListHeadInit(&list->eList);
2425 DListHeadInit(&list->uList);
2426 OsalMutexInit(&list->elock);
2427 OsalMutexInit(&list->ulock);
2428 for (i = 0; i < USBD_BULKASYNCREQ_NUM_MAX; ++i) {
2429 list->node[i].request = UsbAllocRequest(pList->ifHandle, 0, pList->pipe.maxPacketSize);
2430 if (!list->node[i].request) {
2431 HDF_LOGE("%{public}s:%{public}d alloc request faild i:%{public}d", __func__, __LINE__, i);
2432 ret = HDF_ERR_MALLOC_FAIL;
2433 break;
2434 }
2435 list->node[i].list = list;
2436 list->node[i].id = i;
2437 DListInsertTail(&list->node[i].node, &list->eList);
2438 pList->params.userData = (void *)&list->node[i];
2439 }
2440
2441 if (i != USBD_BULKASYNCREQ_NUM_MAX) {
2442 for (; i >= 0; --i) {
2443 UsbFreeRequest(list->node[i].request);
2444 list->node[i].request = NULL;
2445 }
2446 DListHeadInit(&list->eList);
2447 DListHeadInit(&list->uList);
2448 OsalMutexDestroy(&list->elock);
2449 OsalMutexDestroy(&list->ulock);
2450 }
2451 list->pList = pList;
2452 return ret;
2453 }
2454
2455 static int32_t UsbdBulkASyncReqFillParams(struct UsbPipeInfo *pipe, struct UsbRequestParams *params, uint8_t *buffer);
2456
UsbdBulkASyncListAlloc(struct HostDevice * port,uint8_t ifId,uint8_t epId)2457 static struct UsbdBulkASyncList *UsbdBulkASyncListAlloc(struct HostDevice *port, uint8_t ifId, uint8_t epId)
2458 {
2459 int32_t ret = HDF_SUCCESS;
2460 UsbInterfaceHandle *ifHandle = NULL;
2461 struct UsbPipeInfo pipe;
2462 struct UsbdBulkASyncList *bulkAsyncList = NULL;
2463
2464 if (memset_s(&pipe, sizeof(struct UsbPipeInfo), 0, sizeof(struct UsbPipeInfo)) != EOK) {
2465 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
2466 return NULL;
2467 }
2468 ret = GetPipe(port, ifId, epId, &pipe);
2469 if (ret != HDF_SUCCESS) {
2470 HDF_LOGE(
2471 "%{public}s:%{public}d GetPipe ret:%{public}d ifId:%{public}d "
2472 "epId:%{public}d",
2473 __func__, __LINE__, ret, ifId, epId);
2474 return NULL;
2475 }
2476 ifHandle = InterfaceIdToHandle(port, ifId);
2477 if (ifHandle == NULL) {
2478 HDF_LOGE("%{public}s:%{public}d get interface handle faild", __func__, __LINE__);
2479 return NULL;
2480 }
2481
2482 bulkAsyncList = OsalMemAlloc(sizeof(struct UsbdBulkASyncList));
2483 if (!bulkAsyncList) {
2484 HDF_LOGE("%{public}s:%{public}d malloc fail!", __func__, __LINE__);
2485 return NULL;
2486 }
2487 if (memset_s(bulkAsyncList, sizeof(struct UsbdBulkASyncList), 0, sizeof(struct UsbdBulkASyncList)) != EOK) {
2488 HDF_LOGE("%{public}s:%{public}d memset_s faild ", __func__, __LINE__);
2489 OsalMemFree(bulkAsyncList);
2490 return NULL;
2491 }
2492 bulkAsyncList->ifId = ifId;
2493 bulkAsyncList->epId = epId;
2494 bulkAsyncList->instance = port;
2495 OsalMutexInit(&bulkAsyncList->asmHandle.lock);
2496 bulkAsyncList->pipe = pipe;
2497 bulkAsyncList->ifHandle = ifHandle;
2498
2499 UsbdBulkASyncReqFillParams(&bulkAsyncList->pipe, &bulkAsyncList->params, NULL);
2500
2501 ret = UsbdBulkASyncReqInit(&bulkAsyncList->rList, bulkAsyncList);
2502 if (HDF_SUCCESS != ret) {
2503 HDF_LOGE("%{public}s:%{public}d UsbdBulkASyncReqInit ret:%{public}d", __func__, __LINE__, ret);
2504 UsbdBulkASyncListRelease(bulkAsyncList);
2505 bulkAsyncList = NULL;
2506 return NULL;
2507 }
2508
2509 return bulkAsyncList;
2510 }
2511
UsbdBulkASyncListFind(struct HostDevice * port,uint8_t ifId,uint8_t epId)2512 static struct UsbdBulkASyncList *UsbdBulkASyncListFind(struct HostDevice *port, uint8_t ifId, uint8_t epId)
2513 {
2514 struct UsbdBulkASyncList *list = NULL;
2515 if (!port) {
2516 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2517 return NULL;
2518 }
2519 list = port->bulkASyncList;
2520 while (list) {
2521 if ((list->epId == epId) && (list->ifId == ifId)) {
2522 return list;
2523 }
2524 list = list->next;
2525 }
2526 return NULL;
2527 }
2528
UsbdBulkASyncListInit(struct HostDevice * port,uint8_t ifId,uint8_t epId)2529 static struct UsbdBulkASyncList *UsbdBulkASyncListInit(struct HostDevice *port, uint8_t ifId, uint8_t epId)
2530 {
2531 struct UsbdBulkASyncList *list = UsbdBulkASyncListFind(port, ifId, epId);
2532 if (!list) {
2533 list = UsbdBulkASyncListAlloc(port, ifId, epId);
2534 if (list) {
2535 list->next = port->bulkASyncList;
2536 port->bulkASyncList = list;
2537 }
2538 }
2539 return list;
2540 }
2541
UsbdBulkASyncReqNodeSetNoUse(struct UsbdBulkASyncReqNode * db)2542 static int32_t UsbdBulkASyncReqNodeSetNoUse(struct UsbdBulkASyncReqNode *db)
2543 {
2544 OsalMutexLock(&db->list->elock);
2545 db->use = USBD_REQNODE_NOUSE;
2546 DListInsertTail(&db->node, &db->list->eList);
2547 OsalMutexUnlock(&db->list->elock);
2548 return HDF_SUCCESS;
2549 }
2550
UsbdBulkASyncReqGetENode(struct UsbdBulkASyncReqList * list)2551 static struct UsbdBulkASyncReqNode *UsbdBulkASyncReqGetENode(struct UsbdBulkASyncReqList *list)
2552 {
2553 OsalMutexLock(&list->elock);
2554 if (DListIsEmpty(&list->eList)) {
2555 OsalMutexUnlock(&list->elock);
2556 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2557 return NULL;
2558 }
2559 struct UsbdBulkASyncReqNode *ptr = DLIST_FIRST_ENTRY(&list->eList, struct UsbdBulkASyncReqNode, node);
2560 if (ptr) {
2561 ptr->use = USBD_REQNODE_OTHER;
2562 DListRemove(&ptr->node);
2563 }
2564 OsalMutexUnlock(&list->elock);
2565 return ptr;
2566 }
2567
UsbdBulkReadRemoteCallback(struct HdfRemoteService * service,int32_t status,struct UsbdBufferHandle * handle)2568 static int32_t UsbdBulkReadRemoteCallback(struct HdfRemoteService *service, int32_t status,
2569 struct UsbdBufferHandle *handle)
2570 {
2571 int32_t ret = HDF_SUCCESS;
2572 int32_t actLength = 0;
2573 uint8_t flg = 0;
2574 if ((service == NULL) || (handle == NULL)) {
2575 HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
2576 return HDF_ERR_INVALID_PARAM;
2577 }
2578 OsalMutexLock(&handle->lock);
2579 flg = handle->cbflg;
2580 handle->cbflg = 1;
2581 actLength = handle->rcur;
2582 OsalMutexUnlock(&handle->lock);
2583 if (flg) {
2584 return HDF_SUCCESS;
2585 }
2586 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
2587 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
2588 do {
2589 if (data == NULL || reply == NULL) {
2590 HDF_LOGE("%{public}s:%{public}d failed to obtain hdf sbuf", __func__, __LINE__);
2591 ret = HDF_ERR_IO;
2592 break;
2593 }
2594 if (!HdfRemoteServiceWriteInterfaceToken(service, data)) {
2595 HDF_LOGE("%{public}s:%{public}d write interface token failed", __func__, __LINE__);
2596 ret = HDF_ERR_IO;
2597 break;
2598 }
2599 if (!HdfSbufWriteInt32(data, status)) {
2600 HDF_LOGE("%{public}s:%{public}d write status error status:%{public}d", __func__, __LINE__, status);
2601 ret = HDF_ERR_IO;
2602 break;
2603 }
2604 if (!HdfSbufWriteInt32(data, actLength)) {
2605 HDF_LOGE("%{public}s:%{public}d write actLength error length:%{public}d", __func__, __LINE__, actLength);
2606 ret = HDF_ERR_IO;
2607 break;
2608 }
2609 ret = service->dispatcher->Dispatch(service, CMD_USBD_BULK_CALLBACK_READ, data, reply);
2610 } while (0);
2611
2612 HdfSbufRecycle(data);
2613 HdfSbufRecycle(reply);
2614 return ret;
2615 }
2616
UsbdBulkWriteRemoteCallback(struct HdfRemoteService * service,int32_t status,struct UsbdBufferHandle * handle)2617 static int32_t UsbdBulkWriteRemoteCallback(struct HdfRemoteService *service, int32_t status,
2618 struct UsbdBufferHandle *handle)
2619 {
2620 int32_t ret = HDF_SUCCESS;
2621 int32_t actLength = 0;
2622 uint8_t flg = 0;
2623 if ((service == NULL) || (handle == NULL)) {
2624 HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__);
2625 return HDF_ERR_INVALID_PARAM;
2626 }
2627 OsalMutexLock(&handle->lock);
2628 flg = handle->cbflg;
2629 handle->cbflg = 1;
2630 actLength = handle->cur;
2631 OsalMutexUnlock(&handle->lock);
2632 if (flg) {
2633 return HDF_SUCCESS;
2634 }
2635 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
2636 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
2637 do {
2638 if (data == NULL || reply == NULL) {
2639 HDF_LOGE("%{public}s:%{public}d failed to obtain hdf sbuf", __func__, __LINE__);
2640 ret = HDF_ERR_IO;
2641 break;
2642 }
2643 if (!HdfRemoteServiceWriteInterfaceToken(service, data)) {
2644 HDF_LOGE("%{public}s:%{public}d write interface token failed", __func__, __LINE__);
2645 ret = HDF_ERR_IO;
2646 break;
2647 }
2648 if (!HdfSbufWriteInt32(data, status)) {
2649 HDF_LOGE("%{public}s:%{public}d write status error status:%{public}d", __func__, __LINE__, status);
2650 ret = HDF_ERR_IO;
2651 break;
2652 }
2653 if (!HdfSbufWriteInt32(data, actLength)) {
2654 HDF_LOGE("%{public}s:%{public}d write actLength error length:%{public}d", __func__, __LINE__, actLength);
2655 ret = HDF_ERR_IO;
2656 break;
2657 }
2658 ret = service->dispatcher->Dispatch(service, CMD_USBD_BULK_CALLBACK_WRITE, data, reply);
2659 } while (0);
2660
2661 HdfSbufRecycle(data);
2662 HdfSbufRecycle(reply);
2663 return ret;
2664 }
2665
UsbdBulkASyncPutAsmData(struct UsbdBufferHandle * handle,uint8_t * buffer,uint32_t len)2666 static int32_t UsbdBulkASyncPutAsmData(struct UsbdBufferHandle *handle, uint8_t *buffer, uint32_t len)
2667 {
2668 int32_t tlen = len;
2669 int32_t ret = HDF_SUCCESS;
2670 if ((handle == NULL) || (buffer == NULL) || (len < 1)) {
2671 HDF_LOGE("%{public}s:%{public}d invalid param len:%{public}d", __func__, __LINE__, len);
2672 return HDF_ERR_INVALID_PARAM;
2673 }
2674 OsalMutexLock(&handle->lock);
2675 do {
2676 if (handle->fd < 1) {
2677 HDF_LOGE("%{public}s:%{public}d fd:%{public}d", __func__, __LINE__, handle->fd);
2678 ret = HDF_ERR_BAD_FD;
2679 break;
2680 }
2681 tlen = (handle->size > handle->rcur) ? (handle->size - handle->rcur) : 0;
2682 tlen = tlen < len ? tlen : len;
2683 if (tlen > 0) {
2684 memcpy_s(handle->starAddr + handle->rcur, tlen, buffer, len);
2685 handle->rcur += tlen;
2686 }
2687 } while (0);
2688 OsalMutexUnlock(&handle->lock);
2689 return ret;
2690 }
2691
UsbdBulkAsyncGetAsmData(struct UsbdBufferHandle * handle,struct UsbRequestParams * params,uint16_t maxPacketSize)2692 static int32_t UsbdBulkAsyncGetAsmData(struct UsbdBufferHandle *handle, struct UsbRequestParams *params,
2693 uint16_t maxPacketSize)
2694 {
2695 int32_t ret = HDF_ERR_INVALID_PARAM;
2696 if ((handle == NULL) || (params == NULL) || (handle->size < 1) || (maxPacketSize < 1)) {
2697 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2698 return HDF_ERR_IO;
2699 }
2700 OsalMutexLock(&handle->lock);
2701 if (handle->cur < handle->size) {
2702 params->dataReq.length =
2703 (handle->size - handle->cur) < maxPacketSize ? (handle->size - handle->cur) : maxPacketSize;
2704 params->dataReq.buffer = handle->starAddr + handle->cur;
2705 handle->cur += params->dataReq.length;
2706 ret = HDF_SUCCESS;
2707 } else {
2708 params->dataReq.length = 0;
2709 params->dataReq.buffer = NULL;
2710 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2711 ret = HDF_DEV_ERR_NODATA;
2712 }
2713 OsalMutexUnlock(&handle->lock);
2714 return ret;
2715 }
2716
UsbdBulkAsyncGetAsmReqLen(struct UsbdBufferHandle * handle,uint32_t * reqLen,uint16_t maxPacketSize)2717 static int32_t UsbdBulkAsyncGetAsmReqLen(struct UsbdBufferHandle *handle, uint32_t *reqLen, uint16_t maxPacketSize)
2718 {
2719 if ((handle == NULL) || (reqLen == NULL) || (handle->size < 1) || (maxPacketSize < 1)) {
2720 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2721 return HDF_ERR_IO;
2722 }
2723 uint32_t tlen = 0;
2724 OsalMutexLock(&handle->lock);
2725 if (handle->cur < handle->size) {
2726 tlen = handle->size - handle->cur;
2727 tlen = tlen < maxPacketSize ? tlen : maxPacketSize;
2728 handle->cur += tlen;
2729 }
2730 OsalMutexUnlock(&handle->lock);
2731 *reqLen = tlen;
2732 return HDF_SUCCESS;
2733 }
2734
UsbdBulkASyncReqWriteAutoSubmit(struct UsbRequest * request)2735 static int32_t UsbdBulkASyncReqWriteAutoSubmit(struct UsbRequest *request)
2736 {
2737 int32_t ret = HDF_SUCCESS;
2738 struct UsbdBulkASyncReqNode *db = (struct UsbdBulkASyncReqNode *)request->compInfo.userData;
2739 struct UsbRequestParams params = {0};
2740 memcpy_s(¶ms, sizeof(params), &db->list->pList->params, sizeof(params));
2741 params.userData = (void *)db;
2742 ret = UsbdBulkAsyncGetAsmData(&db->list->pList->asmHandle, ¶ms, db->list->pList->pipe.maxPacketSize);
2743 if (HDF_SUCCESS != ret) {
2744 UsbdBulkASyncReqNodeSetNoUse(db);
2745 return ret;
2746 }
2747 db->request->compInfo.status = 0;
2748 ret = UsbFillRequest(request, db->list->pList->ifHandle, ¶ms);
2749 if (HDF_SUCCESS != ret) {
2750 UsbdBulkASyncReqNodeSetNoUse(db);
2751 HDF_LOGE("%{public}s:%{public}d UsbFillRequest ret:%{public}d", __func__, __LINE__, ret);
2752 return ret;
2753 }
2754 ret = UsbSubmitRequestAsync(request);
2755 if (HDF_SUCCESS != ret) {
2756 UsbdBulkASyncReqNodeSetNoUse(db);
2757 HDF_LOGE("%{public}s:%{public}d UsbSubmitRequestAsync ret:%{public}d", __func__, __LINE__, ret);
2758 }
2759 return ret;
2760 }
2761
UsbdBulkASyncReqReadAutoSubmit(struct UsbRequest * request)2762 static int32_t UsbdBulkASyncReqReadAutoSubmit(struct UsbRequest *request)
2763 {
2764 uint32_t readLen = 0;
2765 struct UsbdBulkASyncReqNode *db = (struct UsbdBulkASyncReqNode *)request->compInfo.userData;
2766 int32_t ret =
2767 UsbdBulkASyncPutAsmData(&db->list->pList->asmHandle, request->compInfo.buffer, request->compInfo.actualLength);
2768 if (HDF_SUCCESS != ret) {
2769 HDF_LOGE(
2770 "%{public}s:%{public}d UsbdBulkASyncPutAsmData error "
2771 "size:%{public}d ret:%{public}d ",
2772 __func__, __LINE__, request->compInfo.actualLength, ret);
2773 UsbdBulkASyncReqNodeSetNoUse(db);
2774 return ret;
2775 }
2776 ret = UsbdBulkAsyncGetAsmReqLen(&db->list->pList->asmHandle, &readLen, db->list->pList->pipe.maxPacketSize);
2777 if (readLen < 1) {
2778 UsbdBulkASyncReqNodeSetNoUse(db);
2779 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2780 return HDF_DEV_ERR_NODATA;
2781 }
2782 db->request->compInfo.status = 0;
2783 struct UsbHostRequest *hostRequest = NULL;
2784 hostRequest = ((struct UsbIfRequest *)request)->hostRequest;
2785 if (readLen != (uint32_t)hostRequest->length) {
2786 struct UsbRequestParams params;
2787 memcpy_s(¶ms, sizeof(params), &db->list->pList->params, sizeof(params));
2788 params.dataReq.length = readLen;
2789 params.userData = (void *)db;
2790 ret = UsbFillRequest(request, db->list->pList->ifHandle, ¶ms);
2791 if (HDF_SUCCESS != ret) {
2792 UsbdBulkASyncReqNodeSetNoUse(db);
2793 HDF_LOGE("%{public}s:%{public}d UsbFillRequest ret:%{public}d ", __func__, __LINE__, ret);
2794 return ret;
2795 }
2796 }
2797 ret = UsbSubmitRequestAsync(request);
2798 if (HDF_SUCCESS != ret) {
2799 UsbdBulkASyncReqNodeSetNoUse(db);
2800 HDF_LOGE("%{public}s:%{public}d UsbSubmitRequestAsync ret:%{public}d ", __func__, __LINE__, ret);
2801 }
2802 return ret;
2803 }
2804
UsbdBulkASyncWriteCallbackAutoSubmit(struct UsbRequest * request)2805 static void UsbdBulkASyncWriteCallbackAutoSubmit(struct UsbRequest *request)
2806 {
2807 if (!request) {
2808 return;
2809 }
2810 int32_t ret = HDF_SUCCESS;
2811 struct UsbdBulkASyncReqNode *node = (struct UsbdBulkASyncReqNode *)request->compInfo.userData;
2812 int32_t status = request->compInfo.status;
2813 if (status == 0) {
2814 ret = UsbdBulkASyncReqWriteAutoSubmit(request);
2815 if (HDF_DEV_ERR_NODATA == ret) {
2816 int32_t count = DlistGetCount(&node->list->eList);
2817 if (count >= USBD_BULKASYNCREQ_NUM_MAX) {
2818 ret = UsbdBulkWriteRemoteCallback(node->list->pList->cb, HDF_SUCCESS, &node->list->pList->asmHandle);
2819 }
2820 } else if (HDF_SUCCESS != ret) {
2821 ret = UsbdBulkWriteRemoteCallback(node->list->pList->cb, ret, &node->list->pList->asmHandle);
2822 HDF_LOGE(
2823 "%{public}s:%{public}d UsbdBulkWriteRemoteCallback "
2824 "ret:%{public}d req:%{public}p id:%{public}d",
2825 __func__, __LINE__, ret, request, node->id);
2826 }
2827 } else {
2828 UsbdBulkASyncReqNodeSetNoUse(node);
2829 ret = UsbdBulkWriteRemoteCallback(node->list->pList->cb, status, &node->list->pList->asmHandle);
2830 HDF_LOGE(
2831 "%{public}s:%{public}d UsbdBulkWriteRemoteCallback ret:%{public}d "
2832 "req:%{public}p id:%{public}d status:%{public}d",
2833 __func__, __LINE__, ret, request, node->id, status);
2834 }
2835 }
2836
UsbdBulkASyncReadCallbackAutoSubmit(struct UsbRequest * request)2837 static void UsbdBulkASyncReadCallbackAutoSubmit(struct UsbRequest *request)
2838 {
2839 if (!request) {
2840 return;
2841 }
2842 int32_t ret = HDF_SUCCESS;
2843 struct UsbdBulkASyncReqNode *node = (struct UsbdBulkASyncReqNode *)request->compInfo.userData;
2844 int32_t status = request->compInfo.status;
2845 if (status == 0) {
2846 ret = UsbdBulkASyncReqReadAutoSubmit(request);
2847 if (HDF_DEV_ERR_NODATA == ret) {
2848 int32_t count = DlistGetCount(&node->list->eList);
2849 if (count >= USBD_BULKASYNCREQ_NUM_MAX) {
2850 ret = UsbdBulkReadRemoteCallback(node->list->pList->cb, HDF_SUCCESS, &node->list->pList->asmHandle);
2851 }
2852 } else if (HDF_SUCCESS != ret) {
2853 ret = UsbdBulkReadRemoteCallback(node->list->pList->cb, ret, &node->list->pList->asmHandle);
2854 HDF_LOGE(
2855 "%{public}s:%{public}d UsbdBulkReadRemoteCallback "
2856 "ret:%{public}d req:%{public}p id:%{public}d",
2857 __func__, __LINE__, ret, request, node->id);
2858 }
2859 } else {
2860 UsbdBulkASyncReqNodeSetNoUse(node);
2861 ret = UsbdBulkReadRemoteCallback(node->list->pList->cb, status, &node->list->pList->asmHandle);
2862 HDF_LOGE(
2863 "%{public}s:%{public}d UsbdBulkReadRemoteCallback ret:%{public}d "
2864 "req:%{public}p id:%{public}d status:%{public}d",
2865 __func__, __LINE__, ret, request, node->id, status);
2866 }
2867 }
2868
UsbdBulkASyncReqFillParams(struct UsbPipeInfo * pipe,struct UsbRequestParams * params,uint8_t * buffer)2869 static int32_t UsbdBulkASyncReqFillParams(struct UsbPipeInfo *pipe, struct UsbRequestParams *params, uint8_t *buffer)
2870 {
2871 params->interfaceId = pipe->interfaceId;
2872 params->pipeAddress = pipe->pipeDirection | pipe->pipeAddress;
2873 params->pipeId = pipe->pipeId;
2874 params->requestType = USB_REQUEST_PARAMS_DATA_TYPE;
2875 params->timeout = USB_CTRL_SET_TIMEOUT;
2876 params->dataReq.numIsoPackets = 0;
2877 params->dataReq.directon = (pipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & 0x1;
2878 params->dataReq.length = pipe->maxPacketSize;
2879
2880 if (pipe->pipeDirection == USB_PIPE_DIRECTION_OUT) {
2881 params->callback = UsbdBulkASyncWriteCallbackAutoSubmit;
2882 params->dataReq.buffer = buffer;
2883 } else {
2884 params->callback = UsbdBulkASyncReadCallbackAutoSubmit;
2885 }
2886 return HDF_SUCCESS;
2887 }
2888
UsbdBulkASyncReqWriteSubmit(struct UsbdBulkASyncReqNode * req)2889 static int32_t UsbdBulkASyncReqWriteSubmit(struct UsbdBulkASyncReqNode *req)
2890 {
2891 int32_t ret = HDF_SUCCESS;
2892 struct UsbRequestParams params = {0};
2893 memcpy_s(¶ms, sizeof(params), &req->list->pList->params, sizeof(params));
2894 params.userData = (void *)req;
2895 ret = UsbdBulkAsyncGetAsmData(&req->list->pList->asmHandle, ¶ms, req->list->pList->pipe.maxPacketSize);
2896 if (HDF_SUCCESS != ret) {
2897 UsbdBulkASyncReqNodeSetNoUse(req);
2898 HDF_LOGE("%{public}s:%{public}d UsbdBulkAsyncGetAsmData ret:%{public}d", __func__, __LINE__, ret);
2899 return ret;
2900 }
2901 req->request->compInfo.status = 0;
2902 ret = UsbFillRequest(req->request, req->list->pList->ifHandle, ¶ms);
2903 if (HDF_SUCCESS != ret) {
2904 UsbdBulkASyncReqNodeSetNoUse(req);
2905 HDF_LOGE("%{public}s:%{public}d UsbFillRequest ret:%{public}d", __func__, __LINE__, ret);
2906 return ret;
2907 }
2908 ret = UsbSubmitRequestAsync(req->request);
2909 if (HDF_SUCCESS != ret) {
2910 UsbdBulkASyncReqNodeSetNoUse(req);
2911 HDF_LOGE("%{public}s:%{public}d UsbSubmitRequestAsync ret:%{public}d", __func__, __LINE__, ret);
2912 }
2913 return ret;
2914 }
2915
UsbdBulkASyncWriteSubmitStart(struct UsbdBulkASyncList * list)2916 static int32_t UsbdBulkASyncWriteSubmitStart(struct UsbdBulkASyncList *list)
2917 {
2918 int32_t ret = HDF_SUCCESS;
2919 struct UsbdBulkASyncReqNode *req = NULL;
2920 uint32_t i = 0;
2921 if (list == NULL) {
2922 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2923 return HDF_ERR_INVALID_PARAM;
2924 }
2925 do {
2926 req = UsbdBulkASyncReqGetENode(&list->rList);
2927 if (!req) {
2928 ret = HDF_ERR_DEVICE_BUSY;
2929 break;
2930 } else {
2931 ret = UsbdBulkASyncReqWriteSubmit(req);
2932 if (HDF_SUCCESS != ret) {
2933 break;
2934 }
2935 }
2936 if (++i > USBD_BULKASYNCREQ_NUM_MAX) {
2937 break;
2938 }
2939 } while (!DListIsEmpty(&list->rList.eList));
2940 return ret;
2941 }
2942
UsbdBulkASyncReqReadSubmit(struct UsbdBulkASyncReqNode * db)2943 static int32_t UsbdBulkASyncReqReadSubmit(struct UsbdBulkASyncReqNode *db)
2944 {
2945 int32_t ret = HDF_SUCCESS;
2946 uint32_t readLen = 0;
2947 ret = UsbdBulkAsyncGetAsmReqLen(&db->list->pList->asmHandle, &readLen, db->list->pList->pipe.maxPacketSize);
2948 if (readLen == 0) {
2949 UsbdBulkASyncReqNodeSetNoUse(db);
2950 HDF_LOGE("%{public}s:%{public}d readLen:%{public}d", __func__, __LINE__, readLen);
2951 return HDF_DEV_ERR_NODATA;
2952 }
2953
2954 db->request->compInfo.status = 0;
2955 struct UsbRequestParams params;
2956 memcpy_s(¶ms, sizeof(params), &db->list->pList->params, sizeof(params));
2957 params.dataReq.length = readLen;
2958 params.userData = (void *)db;
2959 ret = UsbFillRequest(db->request, db->list->pList->ifHandle, ¶ms);
2960 if (HDF_SUCCESS != ret) {
2961 HDF_LOGE("%{public}s:%{public}d readLen:%{public}d", __func__, __LINE__, readLen);
2962 UsbdBulkASyncReqNodeSetNoUse(db);
2963 return ret;
2964 }
2965
2966 ret = UsbSubmitRequestAsync(db->request);
2967 if (HDF_SUCCESS != ret) {
2968 HDF_LOGE("%{public}s:%{public}d readLen:%{public}d", __func__, __LINE__, readLen);
2969 UsbdBulkASyncReqNodeSetNoUse(db);
2970 }
2971 return ret;
2972 }
2973
UsbdBulkReadASyncSubmitStart(struct UsbdBulkASyncList * list)2974 static int32_t UsbdBulkReadASyncSubmitStart(struct UsbdBulkASyncList *list)
2975 {
2976 int32_t ret = HDF_SUCCESS;
2977 struct UsbdBulkASyncReqNode *req = NULL;
2978 uint32_t i = 0;
2979 if (list == NULL) {
2980 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2981 return HDF_ERR_INVALID_PARAM;
2982 }
2983 do {
2984 req = UsbdBulkASyncReqGetENode(&list->rList);
2985 if (!req) {
2986 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2987 ret = HDF_ERR_DEVICE_BUSY;
2988 break;
2989 } else {
2990 ret = UsbdBulkASyncReqReadSubmit(req);
2991 if (HDF_SUCCESS != ret) {
2992 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
2993 break;
2994 }
2995 }
2996 if (++i > USBD_BULKASYNCREQ_NUM_MAX) {
2997 break;
2998 }
2999 } while (!DListIsEmpty(&list->rList.eList));
3000 return ret;
3001 }
3002
FunRegBulkCallback(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)3003 static int32_t FunRegBulkCallback(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
3004 {
3005 uint8_t interfaceId = 0;
3006 uint8_t pipeId = 0;
3007 if ((port == NULL) || (data == NULL)) {
3008 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3009 return HDF_ERR_INVALID_PARAM;
3010 }
3011 if (!HdfSbufReadUint8(data, &interfaceId)) {
3012 HDF_LOGE("%{public}s:%{public}d get interfaceId error", __func__, __LINE__);
3013 return HDF_ERR_IO;
3014 }
3015 if (!HdfSbufReadUint8(data, &pipeId)) {
3016 HDF_LOGE("%{public}s:%{public}d get pipeId error", __func__, __LINE__);
3017 return HDF_ERR_IO;
3018 }
3019 struct UsbdBulkASyncList *list = UsbdBulkASyncListInit(port, interfaceId, pipeId);
3020 if (!list) {
3021 HDF_LOGE("%{public}s:%{public}d fail ifId:%{public}d epId:%{public}d", __func__, __LINE__, interfaceId, pipeId);
3022 return HDF_DEV_ERR_DEV_INIT_FAIL;
3023 }
3024 list->cb = HdfSbufReadRemoteService(data);
3025 if (!list->cb) {
3026 HDF_LOGE("%{public}s:%{public}d get callback error", __func__, __LINE__);
3027 return HDF_ERR_IO;
3028 }
3029 if (!HdfRemoteServiceSetInterfaceDesc(list->cb, USB_TOKEN_VALUE)) {
3030 HDF_LOGE("%{public}s: failed to init interface desc", __func__);
3031 HdfRemoteServiceRecycle(list->cb);
3032 return HDF_ERR_IO;
3033 }
3034 return HDF_SUCCESS;
3035 }
3036
FunUnRegBulkCallback(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)3037 static int32_t FunUnRegBulkCallback(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
3038 {
3039 uint8_t interfaceId = 0;
3040 uint8_t pipeId = 0;
3041 if ((port == NULL) || (data == NULL)) {
3042 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3043 return HDF_ERR_INVALID_PARAM;
3044 }
3045 if (!HdfSbufReadUint8(data, &interfaceId)) {
3046 HDF_LOGE("%{public}s:%{public}d get interfaceId error", __func__, __LINE__);
3047 return HDF_ERR_IO;
3048 }
3049 if (!HdfSbufReadUint8(data, &pipeId)) {
3050 HDF_LOGE("%{public}s:%{public}d get pipeId error", __func__, __LINE__);
3051 return HDF_ERR_IO;
3052 }
3053 struct UsbdBulkASyncList *list = UsbdBulkASyncListFind(port, interfaceId, pipeId);
3054 if (!list) {
3055 HDF_LOGW("%{public}s:%{public}d fail ifId:%{public}d epId:%{public}d", __func__, __LINE__, interfaceId, pipeId);
3056 return HDF_SUCCESS;
3057 }
3058 list->cb = NULL;
3059 return HDF_SUCCESS;
3060 }
3061
ReleaseAsmBufferHandle(struct UsbdBufferHandle * handle)3062 static void ReleaseAsmBufferHandle(struct UsbdBufferHandle *handle)
3063 {
3064 if (!handle) {
3065 return;
3066 }
3067 int32_t tsize = handle->size;
3068 if (handle->size > 0) {
3069 OsalMutexLock(&handle->lock);
3070 handle->size = 0;
3071 handle->cur = 0;
3072 handle->rcur = 0;
3073 handle->fd = -1;
3074 handle->cbflg = 0;
3075 OsalMutexUnlock(&handle->lock);
3076 }
3077
3078 handle->fd = -1;
3079 handle->cur = 0;
3080 handle->rcur = 0;
3081 handle->size = 0;
3082 handle->cbflg = 0;
3083 if (tsize > 0) {
3084 OsalMutexLock(&handle->lock);
3085 munmap(handle->starAddr, tsize);
3086 OsalMutexUnlock(&handle->lock);
3087 }
3088 handle->starAddr = NULL;
3089 }
3090
BulkRequestCancel(struct UsbdBulkASyncList * list)3091 static int32_t BulkRequestCancel(struct UsbdBulkASyncList *list)
3092 {
3093 int32_t ret = HDF_SUCCESS;
3094 if (!list) {
3095 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3096 return HDF_ERR_INVALID_PARAM;
3097 }
3098
3099 for (int32_t i = 0; i < USBD_BULKASYNCREQ_NUM_MAX; ++i) {
3100 if ((list->rList.node[i].use == USBD_REQNODE_USE) || (list->rList.node[i].use == USBD_REQNODE_OTHER)) {
3101 ret = UsbCancelRequest(list->rList.node[i].request);
3102 }
3103 }
3104 OsalMSleep(USB_BULK_CANCEL_SLEEP_TIME);
3105
3106 for (int32_t i = 0; i < USBD_BULKASYNCREQ_NUM_MAX; ++i) {
3107 list->rList.node[i].request->compInfo.status = 0;
3108 if ((list->rList.node[i].use == USBD_REQNODE_USE) || (list->rList.node[i].use == USBD_REQNODE_OTHER)) {
3109 list->rList.node[i].request->compInfo.status = 0;
3110 UsbdBulkASyncReqNodeSetNoUse(&list->rList.node[i]);
3111 }
3112 }
3113 return HDF_SUCCESS;
3114 }
3115
FunBulkCancel(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)3116 static int32_t FunBulkCancel(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
3117 {
3118 uint8_t interfaceId = 0;
3119 uint8_t pipeId = 0;
3120 struct HdfRemoteService *tcb = NULL;
3121 if ((port == NULL) || (data == NULL)) {
3122 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3123 return HDF_ERR_INVALID_PARAM;
3124 }
3125 if (!HdfSbufReadUint8(data, &interfaceId)) {
3126 HDF_LOGE("%{public}s:%{public}d get interfaceId error", __func__, __LINE__);
3127 return HDF_ERR_IO;
3128 }
3129 if (!HdfSbufReadUint8(data, &pipeId)) {
3130 HDF_LOGE("%{public}s:%{public}d get pipeId error", __func__, __LINE__);
3131 return HDF_ERR_IO;
3132 }
3133 struct UsbdBulkASyncList *list = UsbdBulkASyncListFind(port, interfaceId, pipeId);
3134 if (!list) {
3135 HDF_LOGW("%{public}s:%{public}d fail ifId:%{public}d epId:%{public}d", __func__, __LINE__, interfaceId, pipeId);
3136 return HDF_SUCCESS;
3137 }
3138 tcb = list->cb;
3139 list->cb = NULL;
3140 ReleaseAsmBufferHandle(&list->asmHandle);
3141 BulkRequestCancel(list);
3142 list->cb = tcb;
3143 return HDF_SUCCESS;
3144 }
3145
UsbdGetBulkParams(struct HdfSBuf * data,uint8_t * ifId,uint8_t * epId,int32_t * fd,int32_t * size)3146 static int32_t UsbdGetBulkParams(struct HdfSBuf *data, uint8_t *ifId, uint8_t *epId, int32_t *fd, int32_t *size)
3147 {
3148 if ((!data) || (!ifId) || (!epId) || (!fd) || (!size)) {
3149 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3150 return HDF_ERR_INVALID_PARAM;
3151 }
3152 if (!HdfSbufReadUint8(data, ifId)) {
3153 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3154 return HDF_ERR_IO;
3155 }
3156 if (!HdfSbufReadUint8(data, epId)) {
3157 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3158 return HDF_ERR_IO;
3159 }
3160 *fd = HdfSbufReadFileDescriptor(data);
3161 if (*fd < 0) {
3162 HDF_LOGE("%{public}s:%{public}d get fd error:%{public}d", __func__, __LINE__, *fd);
3163 return HDF_ERR_IO;
3164 }
3165 if (!HdfSbufReadInt32(data, size)) {
3166 HDF_LOGE("%{public}s:%{public}d file size error", __func__, __LINE__);
3167 return HDF_ERR_IO;
3168 }
3169 return HDF_SUCCESS;
3170 }
3171
InitAsmBufferHandle(struct UsbdBufferHandle * handle,int32_t fd,int32_t size)3172 static int32_t InitAsmBufferHandle(struct UsbdBufferHandle *handle, int32_t fd, int32_t size)
3173 {
3174 if (handle == NULL) {
3175 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3176 return HDF_ERR_INVALID_PARAM;
3177 }
3178 ReleaseAsmBufferHandle(handle);
3179 if ((fd < 0) || (size < 0)) {
3180 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3181 return HDF_ERR_INVALID_PARAM;
3182 }
3183 handle->fd = fd;
3184 handle->size = size;
3185 handle->cur = 0;
3186 handle->rcur = 0;
3187 handle->cbflg = 0;
3188 lseek(fd, 0, SEEK_SET);
3189 handle->starAddr = (uint8_t *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
3190 close(fd);
3191 if (handle->starAddr == NULL) {
3192 handle->fd = -1;
3193 handle->size = 0;
3194 HDF_LOGE("%{public}s:%{public}d mmap error:%s", __func__, __LINE__, strerror(errno));
3195 return HDF_ERR_MALLOC_FAIL;
3196 }
3197 return HDF_SUCCESS;
3198 }
3199
FunBulkRead(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)3200 static int32_t FunBulkRead(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
3201 {
3202 int32_t fd = -1;
3203 int32_t size = 0;
3204 uint8_t ifId = 0;
3205 uint8_t epId = 0;
3206 struct UsbdBulkASyncList *list = NULL;
3207 if ((port == NULL) || (data == NULL)) {
3208 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3209 return HDF_ERR_INVALID_PARAM;
3210 }
3211 int32_t ret = UsbdGetBulkParams(data, &ifId, &epId, &fd, &size);
3212 if (HDF_SUCCESS != ret) {
3213 HDF_LOGE("%{public}s:%{public}d UsbdReadAshmemFromHdfSBuf error ret:%{public}d ", __func__, __LINE__, ret);
3214 return ret;
3215 }
3216 list = UsbdBulkASyncListInit(port, ifId, epId);
3217 if (!list) {
3218 HDF_LOGE("%{public}s:%{public}d fail ifId:%{public}d epId:%{public}d", __func__, __LINE__, ifId, epId);
3219 return HDF_ERR_MALLOC_FAIL;
3220 }
3221 ret = InitAsmBufferHandle(&list->asmHandle, fd, size);
3222 if (HDF_SUCCESS != ret) {
3223 HDF_LOGE(
3224 "%{public}s:%{public}d InitAsmBufferHandle error ret:%{public}d "
3225 "ashmem fd:%{public}d size:%{public}d",
3226 __func__, __LINE__, ret, fd, size);
3227 return ret;
3228 }
3229 ret = UsbdBulkReadASyncSubmitStart(list);
3230 if ((HDF_DEV_ERR_NODATA == ret) || (HDF_DEV_ERR_NO_MEMORY == ret) || (HDF_ERR_DEVICE_BUSY == ret)) {
3231 ret = HDF_SUCCESS;
3232 }
3233 if (HDF_SUCCESS != ret) {
3234 HDF_LOGE(
3235 "%{public}s:%{public}d UsbdBulkReadASyncSubmitStart error "
3236 "ret:%{public}d ",
3237 __func__, __LINE__, ret);
3238 return ret;
3239 }
3240 return ret;
3241 }
3242
FunBulkWrite(struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)3243 static int32_t FunBulkWrite(struct HostDevice *port, struct HdfSBuf *data, struct HdfSBuf *reply)
3244 {
3245 int32_t fd = -1;
3246 int32_t size = 0;
3247 uint8_t ifId = 0;
3248 uint8_t epId = 0;
3249 struct UsbdBulkASyncList *list = NULL;
3250 if ((port == NULL) || (data == NULL)) {
3251 HDF_LOGE("%{public}s:%{public}d invalid parma", __func__, __LINE__);
3252 return HDF_ERR_INVALID_PARAM;
3253 }
3254 int32_t ret = UsbdGetBulkParams(data, &ifId, &epId, &fd, &size);
3255 if (HDF_SUCCESS != ret) {
3256 HDF_LOGE("%{public}s:%{public}d UsbdReadAshmemFromHdfSBuf error ret:%{public}d ", __func__, __LINE__, ret);
3257 return ret;
3258 }
3259 list = UsbdBulkASyncListInit(port, ifId, epId);
3260 if (!list) {
3261 HDF_LOGE("%{public}s:%{public}d fail ifId:%{public}d epId:%{public}d", __func__, __LINE__, ifId, epId);
3262 return HDF_ERR_MALLOC_FAIL;
3263 }
3264 ret = InitAsmBufferHandle(&list->asmHandle, fd, size);
3265 if (HDF_SUCCESS != ret) {
3266 HDF_LOGE(
3267 "%{public}s:%{public}d InitAsmBufferHandle error ret:%{public}d "
3268 "ashmem fd:%{public}d size:%{public}d",
3269 __func__, __LINE__, ret, fd, size);
3270 return ret;
3271 }
3272 ret = UsbdBulkASyncWriteSubmitStart(list);
3273 if ((HDF_DEV_ERR_NODATA == ret) || (HDF_DEV_ERR_NO_MEMORY == ret) || (HDF_ERR_DEVICE_BUSY == ret)) {
3274 ret = HDF_SUCCESS;
3275 }
3276 if (HDF_SUCCESS != ret) {
3277 HDF_LOGE(
3278 "%{public}s:%{public}d UsbdBulkASyncWriteSubmitStart error "
3279 "ret:%{public}d ",
3280 __func__, __LINE__, ret);
3281 return ret;
3282 }
3283 return ret;
3284 }
3285
DispatchCheckParam(struct HdfDeviceIoClient * client)3286 static int32_t DispatchCheckParam(struct HdfDeviceIoClient *client)
3287 {
3288 if (client == NULL) {
3289 HDF_LOGE("%{public}s:%{public}d client is NULL", __func__, __LINE__);
3290 return HDF_ERR_INVALID_OBJECT;
3291 }
3292 if (client->device == NULL) {
3293 HDF_LOGE("%{public}s:%{public}d client->device is NULL", __func__, __LINE__);
3294 return HDF_ERR_INVALID_OBJECT;
3295 }
3296 if (client->device->service == NULL) {
3297 HDF_LOGE("%{public}s:%{public}d client->device->service is NULL", __func__, __LINE__);
3298 return HDF_ERR_INVALID_OBJECT;
3299 }
3300 return HDF_SUCCESS;
3301 }
3302
FilterCmd(int32_t cmd)3303 static bool FilterCmd(int32_t cmd)
3304 {
3305 if (cmd != CMD_FUN_GET_CURRENT_FUNCTIONS && cmd != CMD_FUN_SET_CURRENT_FUNCTIONS && cmd != CMD_SET_ROLE &&
3306 cmd != CMD_QUERY_PORT && CMD_BIND_USB_SUBSCRIBER != cmd && CMD_UNBIND_USB_SUBSCRIBER != cmd) {
3307 return true;
3308 }
3309 return false;
3310 }
3311
DispatchSwitchHost(int32_t cmd,struct UsbdService * service,struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)3312 int32_t DispatchSwitchHost(int32_t cmd, struct UsbdService *service, struct HostDevice *port, struct HdfSBuf *data,
3313 struct HdfSBuf *reply)
3314 {
3315 switch (cmd) {
3316 case CMD_FUN_OPEN_DEVICE:
3317 return FunOpenDevice(port, data, reply);
3318 case CMD_FUN_CLOSE_DEVICE:
3319 return FunCloseDevice(port, data);
3320 case CMD_FUN_SEND_BULK_READ_ASYNC:
3321 return FunBulkRead(port, data, reply);
3322 case CMD_FUN_SEND_BULK_WRITE_ASYNC:
3323 return FunBulkWrite(port, data, reply);
3324 case CMD_FUN_SEND_BULK_READ_SYNC:
3325 case CMD_FUN_SEND_INTERRUPT_READ_SYNC:
3326 case CMD_FUN_SEND_ISO_READ_SYNC:
3327 return FunBulkReadSync(port, data, reply);
3328 case CMD_FUN_SEND_BULK_WRITE_SYNC:
3329 case CMD_FUN_SEND_INTERRUPT_WRITE_SYNC:
3330 case CMD_FUN_SEND_ISO_WRITE_SYNC:
3331 return FunBulkWriteSync(port, data, reply);
3332 case CMD_FUN_GET_DESCRIPTOR:
3333 return FunGetRawDeviceDescriptor(port, reply);
3334 case CMD_FUN_GET_FILEDESCRIPTOR:
3335 return FunGetFileDescriptor(port, reply);
3336 case CMD_FUN_REG_BULK_CALLBACK:
3337 return FunRegBulkCallback(port, data, reply);
3338 case CMD_FUN_UNREG_BULK_CALLBACK:
3339 return FunUnRegBulkCallback(port, data, reply);
3340 case CMD_FUN_BULK_CANCEL:
3341 return FunBulkCancel(port, data, reply);
3342 default:
3343 return HDF_ERR_NOT_SUPPORT;
3344 }
3345 return HDF_SUCCESS;
3346 }
3347
DispatchSwitchDevice(int32_t cmd,struct UsbdService * service,struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)3348 int32_t DispatchSwitchDevice(int32_t cmd, struct UsbdService *service, struct HostDevice *port, struct HdfSBuf *data,
3349 struct HdfSBuf *reply)
3350 {
3351 switch (cmd) {
3352 case CMD_SET_ROLE:
3353 return FunSetRole(data, reply, service);
3354 case CMD_QUERY_PORT:
3355 return FunQueryPort(data, reply, service);
3356 case CMD_FUN_GET_CURRENT_FUNCTIONS:
3357 return FunGetCurrentFunctions(data, reply);
3358 case CMD_FUN_SET_CURRENT_FUNCTIONS:
3359 return FunSetCurrentFunctions(data, reply);
3360 default:
3361 return HDF_ERR_NOT_SUPPORT;
3362 }
3363 return HDF_SUCCESS;
3364 }
3365
DispatchSwitch(int32_t cmd,struct UsbdService * service,struct HostDevice * port,struct HdfSBuf * data,struct HdfSBuf * reply)3366 int32_t DispatchSwitch(int32_t cmd, struct UsbdService *service, struct HostDevice *port, struct HdfSBuf *data,
3367 struct HdfSBuf *reply)
3368 {
3369 if (cmd == CMD_FUN_OPEN_DEVICE || cmd == CMD_FUN_CLOSE_DEVICE || cmd == CMD_FUN_SEND_BULK_READ_ASYNC ||
3370 cmd == CMD_FUN_SEND_BULK_WRITE_ASYNC || cmd == CMD_FUN_SEND_BULK_READ_SYNC ||
3371 cmd == CMD_FUN_SEND_INTERRUPT_READ_SYNC || cmd == CMD_FUN_SEND_ISO_READ_SYNC ||
3372 cmd == CMD_FUN_SEND_BULK_WRITE_SYNC || cmd == CMD_FUN_SEND_INTERRUPT_WRITE_SYNC ||
3373 cmd == CMD_FUN_SEND_ISO_WRITE_SYNC || cmd == CMD_FUN_GET_DESCRIPTOR || cmd == CMD_FUN_REG_BULK_CALLBACK ||
3374 cmd == CMD_FUN_UNREG_BULK_CALLBACK || cmd == CMD_FUN_BULK_CANCEL || cmd == CMD_FUN_GET_FILEDESCRIPTOR) {
3375 return DispatchSwitchHost(cmd, service, port, data, reply);
3376 }
3377 if (cmd == CMD_SET_ROLE || cmd == CMD_QUERY_PORT || cmd == CMD_FUN_GET_CURRENT_FUNCTIONS ||
3378 cmd == CMD_FUN_SET_CURRENT_FUNCTIONS) {
3379 return DispatchSwitchDevice(cmd, service, port, data, reply);
3380 }
3381
3382 switch (cmd) {
3383 case CMD_BIND_USB_SUBSCRIBER:
3384 return DispatchBindUsbSubscriber(service, data);
3385 case CMD_UNBIND_USB_SUBSCRIBER:
3386 return DispatchUnbindUsbSubscriber(service);
3387 case CMD_FUN_SEND_CTRL_REQUEST_SYNC:
3388 return FunControlTransfer(port, data, reply);
3389 case CMD_FUN_GET_DEVICE_DESCRIPTOR:
3390 return FunGetDeviceDescriptor(port, reply);
3391 case CMD_FUN_GET_CONFIG_DESCRIPTOR:
3392 return FunGetConfigDescriptor(port, data, reply);
3393 case CMD_FUN_GET_STRING_DESCRIPTOR:
3394 return FunGetStringDescriptor(port, data, reply);
3395 case CMD_FUN_REQUEST_QUEUE:
3396 return FunRequestQueue(port, data, reply);
3397 case CMD_FUN_REQUEST_WAIT:
3398 return FunRequestWait(port, data, reply);
3399 case CMD_FUN_REQUEST_CANCEL:
3400 return FunRequestCancel(port, data, reply);
3401 case CMD_FUN_CLAIM_INTERFACE:
3402 return FunClaimInterface(port, data);
3403 case CMD_FUN_RELEASE_INTERFACE:
3404 return FunReleaseInterface(port, data);
3405 case CMD_FUN_SET_CONFIG:
3406 return FunSetActiveConfig(port, data, reply);
3407 case CMD_FUN_GET_CONFIG:
3408 return FunGetActiveConfig(port, data, reply);
3409 case CMD_FUN_SET_INTERFACE:
3410 return FunSetInterface(port, data, reply);
3411 default:
3412 return HDF_ERR_NOT_SUPPORT;
3413 }
3414 return HDF_SUCCESS;
3415 }
3416
UsbdServiceDispatch(struct HdfDeviceIoClient * client,int32_t cmd,struct HdfSBuf * data,struct HdfSBuf * reply)3417 int32_t UsbdServiceDispatch(struct HdfDeviceIoClient *client, int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
3418 {
3419 struct UsbdService *service = NULL;
3420 struct HostDevice *port = NULL;
3421 if (DispatchCheckParam(client) != HDF_SUCCESS) {
3422 return HDF_ERR_INVALID_OBJECT;
3423 }
3424
3425 if (HdfDeviceObjectCheckInterfaceDesc(client->device, data) == false) {
3426 HDF_LOGE("%{public}s:%{public}d check interface desc fail", __func__, __LINE__);
3427 return HDF_ERR_INVALID_PARAM;
3428 }
3429
3430 service = (struct UsbdService *)client->device->service;
3431 if (FilterCmd(cmd)) {
3432 uint8_t busNum = 0;
3433 uint8_t devAddr = 0;
3434 int32_t ret = ParseDeviceBuf(data, &busNum, &devAddr);
3435 if (ret != HDF_SUCCESS) {
3436 HDF_LOGE("%{public}s:%{public}d cmd = %{public}d parse error:%{public}d", __func__, __LINE__, cmd, ret);
3437 return ret;
3438 }
3439 port = FindDevFromService(service, busNum, devAddr);
3440 switch (cmd) {
3441 case CMD_FUN_OPEN_DEVICE:
3442 case CMD_FUN_CLOSE_DEVICE:
3443 if (port == NULL) {
3444 HDF_LOGE(
3445 "%{public}s:%{public}d cmd = %{public}d busNum:%{public}d "
3446 "devAddr:%{public}d no device",
3447 __func__, __LINE__, cmd, busNum, devAddr);
3448 return HDF_DEV_ERR_NO_DEVICE;
3449 }
3450 break;
3451 default:
3452 if ((port == NULL) || (!port->initFlag)) {
3453 HDF_LOGE(
3454 "%{public}s:%{public}d cmd = %{public}d busNum:%{public}d "
3455 "devAddr:%{public}d no device",
3456 __func__, __LINE__, cmd, busNum, devAddr);
3457 return HDF_DEV_ERR_NO_DEVICE;
3458 }
3459 break;
3460 }
3461 }
3462 return DispatchSwitch(cmd, service, port, data, reply);
3463 }