1 /*
2  * Copyright (c) 2021-2023 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 "usbfn_dev_mgr.h"
17 #include "hdf_base.h"
18 #include "hdf_log.h"
19 #include "osal_thread.h"
20 #include "osal_time.h"
21 #include "securec.h"
22 #include "usbfn_cfg_mgr.h"
23 #include "usbfn_io_mgr.h"
24 #include "usbd_wrapper.h"
25 
26 #define HDF_LOG_TAG    usbfn_dev_mgr
27 #define SLEEP_TIME_OUT 100
28 #define SLEEP_TIMES    20
29 
30 static struct DListHead g_devEntry = {0};
31 static uint32_t g_intfCnt = 0;
32 static uint32_t g_epCnt = 1;
33 static uint32_t g_fnCntOld = 0;
GetInterfaceInfo(const struct UsbInterfaceDescriptor * intf,struct UsbFnDeviceMgr * devMgr,uint32_t fnCnt,const struct UsbFnConfiguration * config)34 static void GetInterfaceInfo(const struct UsbInterfaceDescriptor *intf, struct UsbFnDeviceMgr *devMgr, uint32_t fnCnt,
35     const struct UsbFnConfiguration *config)
36 {
37     if (g_fnCntOld != fnCnt) {
38         g_fnCntOld = fnCnt;
39         g_epCnt = 1;
40     }
41     struct UsbFnInterfaceInfo *info = NULL;
42     if (intf->bDescriptorType == USB_DDK_DT_INTERFACE && intf->bNumEndpoints > 0) {
43         if (g_intfCnt >= devMgr->fnDev.numInterfaces) {
44             HDF_LOGE("%{public}s: GetInterfaceInfo failed", __func__);
45             return;
46         }
47         info = &devMgr->interfaceMgr[g_intfCnt].interface.info;
48         info->index = intf->bInterfaceNumber;
49         info->interfaceClass = intf->bInterfaceClass;
50         info->subclass = intf->bInterfaceSubClass;
51         info->protocol = intf->bInterfaceProtocol;
52         info->numPipes = intf->bNumEndpoints;
53         info->configIndex = config->configurationValue;
54 
55         devMgr->interfaceMgr[g_intfCnt].interface.object = &devMgr->fnDev.object;
56         devMgr->interfaceMgr[g_intfCnt].funcMgr = &devMgr->funcMgr[fnCnt];
57         devMgr->interfaceMgr[g_intfCnt].startEpId = (uint8_t)g_epCnt;
58         g_epCnt += intf->bNumEndpoints;
59         g_intfCnt++;
60     }
61 }
62 
CreateInterface(struct UsbFnDeviceDesc * des,struct UsbFnDeviceMgr * devMgr)63 static void CreateInterface(struct UsbFnDeviceDesc *des, struct UsbFnDeviceMgr *devMgr)
64 {
65     uint32_t fnCnt = 0;
66     struct UsbInterfaceDescriptor *intf = NULL;
67     g_intfCnt = 0;
68     g_epCnt = 1;
69     g_fnCntOld = 0;
70 
71     for (uint32_t i = 0; des->configs[i] != NULL; i++) {
72         for (uint32_t j = 0; des->configs[i]->functions[j] != NULL; j++) {
73             if (strncmp(des->configs[i]->functions[j]->funcName, FUNCTION_GENERIC, strlen(FUNCTION_GENERIC))) {
74                 continue;
75             }
76             if (des->configs[i]->functions[j]->enable == false) {
77                 continue;
78             }
79             DListHeadInit(&devMgr->funcMgr[fnCnt].reqEntry);
80             devMgr->funcMgr[fnCnt].object = &devMgr->fnDev.object;
81             int32_t ret = snprintf_s(devMgr->funcMgr[fnCnt].name, MAX_NAMELEN, MAX_NAMELEN - 1, "%s",
82                 des->configs[i]->functions[j]->funcName);
83             if (ret < 0) {
84                 HDF_LOGE("%{public}s: snprintf_s failed", __func__);
85                 return;
86             }
87 
88             for (uint32_t k = 0; des->configs[i]->functions[j]->fsDescriptors[k] != NULL; k++) {
89                 intf = (struct UsbInterfaceDescriptor *)des->configs[i]->functions[j]->fsDescriptors[k];
90                 GetInterfaceInfo(intf, devMgr, fnCnt, des->configs[i]);
91             }
92             fnCnt++;
93         }
94     }
95 }
96 
97 #define MAX_LIST 32
FindEmptyId(void)98 static int32_t FindEmptyId(void)
99 {
100     int32_t devCnt = 1;
101     struct UsbObject *obj = NULL;
102     struct UsbObject *temp = NULL;
103     if (g_devEntry.next != 0 && !DListIsEmpty(&g_devEntry)) {
104         int32_t i;
105         for (i = 1; i < MAX_LIST; i++) {
106             int32_t isUse = 0;
107             DLIST_FOR_EACH_ENTRY_SAFE(obj, temp, &g_devEntry, struct UsbObject, entry) {
108                 if (obj->objectId == i) {
109                     isUse = 1;
110                     break;
111                 }
112             }
113             if (isUse == 0) {
114                 break;
115             }
116         }
117         if (i == MAX_LIST) {
118             HDF_LOGE("%{public}s:%{public}d too much device created", __func__, __LINE__);
119             return -1;
120         }
121         devCnt = i;
122     }
123     return devCnt;
124 }
125 
CreatDev(const char * udcName,struct UsbFnDeviceDesc * des,struct UsbFnDeviceMgr * fnDevMgr)126 static int32_t CreatDev(const char *udcName, struct UsbFnDeviceDesc *des, struct UsbFnDeviceMgr *fnDevMgr)
127 {
128     int32_t ret, devCnt;
129     struct UsbFnAdapterOps *fnOps = UsbFnAdapterGetOps();
130     devCnt = FindEmptyId();
131     if (devCnt < 0) {
132         return HDF_ERR_IO;
133     }
134 
135     fnDevMgr->fnDev.object.objectId = devCnt;
136     ret = sprintf_s(fnDevMgr->name, MAX_NAMELEN, "g%d", devCnt);
137     if (ret < 0) {
138         return HDF_ERR_IO;
139     }
140     ret = strcpy_s(fnDevMgr->udcName, MAX_NAMELEN, udcName);
141     if (ret != EOK) {
142         return HDF_ERR_IO;
143     }
144     ret = fnOps->createDevice(udcName, fnDevMgr->name, des);
145     if (ret) {
146         return HDF_ERR_IO;
147     }
148     return 0;
149 }
150 
GetInterfaceNum(struct UsbDescriptorHeader ** intf)151 static uint32_t GetInterfaceNum(struct UsbDescriptorHeader **intf)
152 {
153     uint32_t i;
154     uint32_t num = 0;
155     struct UsbInterfaceDescriptor *interface = NULL;
156     for (i = 0; intf[i] != NULL; i++) {
157         if (intf[i]->bDescriptorType == USB_DDK_DT_INTERFACE) {
158             interface = (struct UsbInterfaceDescriptor *)intf[i];
159             if (interface->bNumEndpoints > 0) {
160                 num++;
161             }
162         }
163     }
164     return num;
165 }
166 
AllocInterfaceAndFuncMgr(struct UsbFnDeviceMgr * fnDevMgr,struct UsbFnDeviceDesc * des)167 static int32_t AllocInterfaceAndFuncMgr(struct UsbFnDeviceMgr *fnDevMgr, struct UsbFnDeviceDesc *des)
168 {
169     uint32_t i, j;
170     for (i = 0; des->configs[i] != NULL; i++) {
171         for (j = 0; des->configs[i]->functions[j] != NULL; j++) {
172             if (strncmp(des->configs[i]->functions[j]->funcName, FUNCTION_GENERIC, strlen(FUNCTION_GENERIC))) {
173                 continue;
174             }
175             if (des->configs[i]->functions[j]->enable == false) {
176                 continue;
177             }
178             fnDevMgr->numFunc++;
179             fnDevMgr->fnDev.numInterfaces += GetInterfaceNum(des->configs[i]->functions[j]->fsDescriptors);
180         }
181     }
182     if (fnDevMgr->fnDev.numInterfaces == 0) {
183         HDF_LOGE("%{public}s functions is null", __func__);
184         return HDF_DEV_ERR_NO_DEVICE;
185     }
186 
187     fnDevMgr->interfaceMgr = UsbFnMemCalloc(fnDevMgr->fnDev.numInterfaces * sizeof(struct UsbFnInterfaceMgr));
188     if (fnDevMgr->interfaceMgr == NULL) {
189         HDF_LOGE("%{public}s UsbFnMemCalloc failed", __func__);
190         return HDF_ERR_IO;
191     }
192 
193     fnDevMgr->funcMgr = UsbFnMemCalloc(fnDevMgr->numFunc * sizeof(struct UsbFnFuncMgr));
194     if (fnDevMgr->funcMgr == NULL) {
195         HDF_LOGE("%{public}s UsbFnMemCalloc failed", __func__);
196         UsbFnMemFree(fnDevMgr->interfaceMgr);
197         return HDF_ERR_IO;
198     }
199     return 0;
200 }
201 
202 static int32_t StartThreadIo(struct UsbFnDeviceMgr *fnDevMgr);
UsbFnMgrDeviceCreate(const char * udcName,struct UsbFnDeviceDesc * des,const struct DeviceResourceNode * node)203 const struct UsbFnDeviceMgr *UsbFnMgrDeviceCreate(
204     const char *udcName, struct UsbFnDeviceDesc *des, const struct DeviceResourceNode *node)
205 {
206     int32_t ret;
207 
208     struct UsbFnDeviceMgr *fnDevMgr = NULL;
209     if (udcName == NULL || des == NULL) {
210         HDF_LOGE("%{public}s invalid param.", __func__);
211         return NULL;
212     }
213 
214     fnDevMgr = UsbFnMemCalloc(sizeof(struct UsbFnDeviceMgr));
215     if (fnDevMgr == NULL) {
216         HDF_LOGE("%{public}s UsbFnMemCalloc failed", __func__);
217         return NULL;
218     }
219 
220     ret = CreatDev(udcName, des, fnDevMgr);
221     if (ret) {
222         HDF_LOGE("%{public}s CreatDev failed", __func__);
223         goto FREE_DEVMGR;
224     }
225     if (g_devEntry.next == 0) {
226         DListHeadInit(&g_devEntry);
227     }
228     DListInsertTail(&fnDevMgr->fnDev.object.entry, &g_devEntry);
229     fnDevMgr->node = node;
230     fnDevMgr->des = des;
231 
232     ret = AllocInterfaceAndFuncMgr(fnDevMgr, des);
233     if (ret == HDF_DEV_ERR_NO_DEVICE) {
234         return fnDevMgr;
235     } else if (ret != 0) {
236         HDF_LOGE("%{public}s AllocInterfaceAndFuncMgr failed", __func__);
237         goto FREE_DEVMGR;
238     }
239 
240     CreateInterface(des, fnDevMgr);
241     fnDevMgr->running = true;
242     ret = StartThreadIo(fnDevMgr);
243     if (ret) {
244         HDF_LOGE("%{public}s: StartThreadIo failed", __func__);
245         goto FREE_INTF_FUNC_MGR;
246     }
247     return fnDevMgr;
248 
249 FREE_INTF_FUNC_MGR:
250     UsbFnMemFree(fnDevMgr->interfaceMgr);
251     UsbFnMemFree(fnDevMgr->funcMgr);
252 FREE_DEVMGR:
253     UsbFnMemFree(fnDevMgr);
254     return NULL;
255 }
256 
UsbFnMgrDeviceRemove(struct UsbFnDevice * fnDevice)257 int32_t UsbFnMgrDeviceRemove(struct UsbFnDevice *fnDevice)
258 {
259     int32_t ret;
260     int32_t i = 0;
261     if (fnDevice == NULL) {
262         return HDF_ERR_INVALID_PARAM;
263     }
264     struct UsbFnDeviceMgr *fnDevMgr = (struct UsbFnDeviceMgr *)fnDevice;
265     struct UsbFnAdapterOps *fnOps = UsbFnAdapterGetOps();
266 
267     fnDevMgr->running = false;
268     while (!fnDevMgr->running) {
269         i++;
270         OsalMSleep(SLEEP_TIME_OUT);
271         if (i > SLEEP_TIMES) {
272             HDF_LOGE("%{public}s: wait thread exit timeout", __func__);
273             break;
274         }
275     }
276 
277     ret = OsalThreadDestroy(&fnDevMgr->thread);
278     if (ret != HDF_SUCCESS) {
279         HDF_LOGE("%{public}s:%{public}d OsalThreadDestroy failed, ret = %{public}d", __func__, __LINE__, ret);
280         return ret;
281     }
282     ret = fnOps->delDevice(fnDevMgr->name, fnDevMgr->udcName, fnDevMgr->des);
283     if (ret) {
284         HDF_LOGE("%{public}s:%{public}d UsbFnMgrDeviceRemove failed", __func__, __LINE__);
285         return ret;
286     }
287     DListRemove(&fnDevice->object.entry);
288     UsbFnCfgMgrUnRegisterAllProp();
289 
290     if (fnDevMgr->funcMgr != NULL) {
291         UsbFnMemFree(fnDevMgr->funcMgr);
292         fnDevMgr->funcMgr = NULL;
293     }
294     if (fnDevMgr->interfaceMgr != NULL) {
295         UsbFnMemFree(fnDevMgr->interfaceMgr);
296         fnDevMgr->interfaceMgr = NULL;
297     }
298     if (fnDevMgr->node) {
299         UsbFnCfgMgrFreeUsbFnDeviceDesc(fnDevMgr->des);
300         fnDevMgr->des = NULL;
301     }
302     UsbFnMemFree(fnDevMgr);
303     fnDevMgr = NULL;
304     return 0;
305 }
306 
UsbFnMgrDeviceGet(const char * udcName)307 const struct UsbFnDeviceMgr *UsbFnMgrDeviceGet(const char *udcName)
308 {
309     if (udcName == NULL) {
310         HDF_LOGE("%{public}s invalid param.", __func__);
311         return NULL;
312     }
313     if (g_devEntry.next == 0 || DListIsEmpty(&g_devEntry)) {
314         HDF_LOGE("%{public}s no device created", __func__);
315         return NULL;
316     }
317 
318     struct UsbObject *obj = NULL;
319     struct UsbObject *temp = NULL;
320     DLIST_FOR_EACH_ENTRY_SAFE(obj, temp, &g_devEntry, struct UsbObject, entry) {
321         struct UsbFnDeviceMgr *fnDevMgr = (struct UsbFnDeviceMgr *)obj;
322         if (strcmp(udcName, fnDevMgr->udcName) == 0) {
323             return fnDevMgr;
324         }
325     }
326     return NULL;
327 }
328 
UsbFnMgrDeviceGetState(struct UsbFnDevice * fnDevice,UsbFnDeviceState * devState)329 int32_t UsbFnMgrDeviceGetState(struct UsbFnDevice *fnDevice, UsbFnDeviceState *devState)
330 {
331     if (fnDevice == NULL || devState == NULL) {
332         HDF_LOGE("%{public}s:%{public}d invalid param.", __func__, __LINE__);
333         return HDF_ERR_INVALID_PARAM;
334     }
335     struct UsbFnDeviceMgr *fnDevMgr = (struct UsbFnDeviceMgr *)fnDevice;
336     *devState = fnDevMgr->devState;
337     return 0;
338 }
339 
UsbFnMgrDeviceGetInterface(struct UsbFnDevice * fnDevice,uint8_t interfaceIndex)340 const struct UsbFnInterfaceMgr *UsbFnMgrDeviceGetInterface(struct UsbFnDevice *fnDevice, uint8_t interfaceIndex)
341 {
342     if (fnDevice == NULL) {
343         HDF_LOGE("%{public}s:%{public}d fnDevice is null", __func__, __LINE__);
344         return NULL;
345     }
346     struct UsbFnDeviceMgr *fnDevMgr = (struct UsbFnDeviceMgr *)fnDevice;
347     if (interfaceIndex >= fnDevMgr->fnDev.numInterfaces) {
348         HDF_LOGE("%{public}s:%{public}d invalid param.", __func__, __LINE__);
349         return NULL;
350     }
351     return &(fnDevMgr->interfaceMgr[interfaceIndex]);
352 }
353 
CollectEventHandle(struct UsbFnEventAll * event,struct UsbFnDeviceMgr * devMgr)354 static void CollectEventHandle(struct UsbFnEventAll *event, struct UsbFnDeviceMgr *devMgr)
355 {
356     uint8_t i, j;
357     struct UsbFnFuncMgr *funcMgr = NULL;
358     struct UsbFnInterfaceMgr *intfMgr = NULL;
359     struct UsbHandleMgr *handle = NULL;
360     event->ep0Num = 0;
361     event->epNum = 0;
362     for (i = 0; i < devMgr->numFunc; i++) {
363         funcMgr = devMgr->funcMgr + i;
364 
365         if (funcMgr->fd > 0 && funcMgr->callback != NULL) {
366             event->ep0[event->ep0Num] = funcMgr->fd;
367             event->ep0Event[event->ep0Num].type = USB_EP0_INVALID;
368             event->ep0Num++;
369         }
370     }
371     for (i = 0; i < devMgr->fnDev.numInterfaces; i++) {
372         intfMgr = devMgr->interfaceMgr + i;
373         if (intfMgr == NULL || intfMgr->isOpen == false || intfMgr->handle == NULL) {
374             continue;
375         }
376         handle = intfMgr->handle;
377         for (j = 0; j < handle->numFd; j++) {
378             if (handle->fds[j] <= 0) {
379                 continue;
380             }
381             event->epx[event->epNum] = handle->fds[j];
382             event->reqEvent[event->epNum] = handle->reqEvent[j];
383             event->numEvent[event->epNum] = 0;
384             event->epNum++;
385         }
386     }
387 }
388 
HandleEp0IoEvent(const struct UsbFnFuncMgr * funcMgr,const struct UsbFnReqEvent * reqEvent)389 static void HandleEp0IoEvent(const struct UsbFnFuncMgr *funcMgr, const struct UsbFnReqEvent *reqEvent)
390 {
391     struct ReqList *reqList = NULL;
392     struct ReqList *temp = NULL;
393 
394     DLIST_FOR_EACH_ENTRY_SAFE(reqList, temp, &funcMgr->reqEntry, struct ReqList, entry) {
395         if (reqList->buf == reqEvent->buf) {
396             HDF_LOGD("%{public}s: req.actual = %{public}d", __func__, reqList->req.actual);
397             reqList->req.actual = reqEvent->actual;
398             reqList->req.status = -reqEvent->status;
399             if (reqList->req.complete) {
400                 reqList->req.complete(reqList->pipe, &reqList->req);
401             } else {
402                 HDF_LOGE("no complete callback find");
403             }
404             break;
405         }
406     }
407 }
408 
HandleEp0CtrlEvent(const struct UsbFnFuncMgr * funcMgr,struct UsbFnCtrlEvent * ctrlEvent)409 static void HandleEp0CtrlEvent(const struct UsbFnFuncMgr *funcMgr, struct UsbFnCtrlEvent *ctrlEvent)
410 {
411     struct UsbFnDeviceMgr *devMgr = (struct UsbFnDeviceMgr *)funcMgr->object;
412     struct UsbFnEvent fnEvnet;
413     if (((funcMgr->eventMask) & (1 << ctrlEvent->type)) == 0) {
414         return;
415     }
416     fnEvnet.setup = &ctrlEvent->u.setup;
417     fnEvnet.type = ctrlEvent->type;
418     fnEvnet.context = funcMgr->context;
419     devMgr->devState = ctrlEvent->type;
420     if (funcMgr->callback) {
421         funcMgr->callback(&fnEvnet);
422     } else {
423         HDF_LOGE("%{public}s: no callback find event=%{public}d", __func__, fnEvnet.type);
424     }
425 }
426 
HandleEpsIoEvent(const struct UsbFnReqEvent * reqEvent,const struct UsbHandleMgr * handle)427 static void HandleEpsIoEvent(const struct UsbFnReqEvent *reqEvent, const struct UsbHandleMgr *handle)
428 {
429     struct ReqList *reqList = NULL;
430     struct ReqList *temp = NULL;
431     DLIST_FOR_EACH_ENTRY_SAFE(reqList, temp, &handle->reqEntry, struct ReqList, entry) {
432         if (reqList->buf == reqEvent->buf) {
433             reqList->req.actual = reqEvent->actual;
434             reqList->req.status = -reqEvent->status;
435             if (reqList->req.complete) {
436                 reqList->req.complete(reqList->pipe, &reqList->req);
437             } else {
438                 HDF_LOGE("no complete callback find");
439             }
440             break;
441         }
442     }
443 }
444 
GetFuncMgr(const struct UsbFnDeviceMgr * devMgr,int32_t ep0)445 static struct UsbFnFuncMgr *GetFuncMgr(const struct UsbFnDeviceMgr *devMgr, int32_t ep0)
446 {
447     uint8_t i;
448 
449     if (devMgr == NULL) {
450         HDF_LOGE("%{public}s:%{public}d devMgr is null.", __func__, __LINE__);
451         return NULL;
452     }
453     struct UsbFnFuncMgr *funcMgr = NULL;
454     for (i = 0; i < devMgr->numFunc; i++) {
455         funcMgr = devMgr->funcMgr + i;
456         if (funcMgr->fd == ep0) {
457             break;
458         }
459     }
460     return funcMgr;
461 }
462 
GetHandleMgr(const struct UsbFnDeviceMgr * devMgr,int32_t epx)463 static struct UsbHandleMgr *GetHandleMgr(const struct UsbFnDeviceMgr *devMgr, int32_t epx)
464 {
465     uint8_t i, j;
466     struct UsbHandleMgr *handle = NULL;
467     struct UsbFnInterfaceMgr *intfMgr = NULL;
468 
469     if (devMgr == NULL) {
470         HDF_LOGE("%{public}s:%{public}d devMgr is null.", __func__, __LINE__);
471         return NULL;
472     }
473     for (i = 0; i < devMgr->fnDev.numInterfaces; i++) {
474         intfMgr = devMgr->interfaceMgr + i;
475         if (!intfMgr->isOpen) {
476             continue;
477         }
478         handle = intfMgr->handle;
479         for (j = 0; j < handle->numFd; j++) {
480             if (epx == handle->fds[j]) {
481                 return handle;
482             }
483         }
484     }
485     return handle;
486 }
487 
HandleEp0Event(const struct UsbFnDeviceMgr * devMgr,struct UsbFnEventAll event)488 static void HandleEp0Event(const struct UsbFnDeviceMgr *devMgr, struct UsbFnEventAll event)
489 {
490     uint8_t i;
491     struct UsbFnFuncMgr *funcMgr = NULL;
492     for (i = 0; i < event.ep0Num; i++) {
493         funcMgr = GetFuncMgr(devMgr, event.ep0[i]);
494         if (funcMgr == NULL) {
495             HDF_LOGE("%{public}s:%{public}d GetFuncMgr failed.", __func__, __LINE__);
496             return;
497         }
498         if (event.ep0Event[i].type == USB_EP0_CTRL_EVENT) {
499             HandleEp0CtrlEvent(funcMgr, &event.ep0Event[i].ctrlEvent);
500         } else if (event.ep0Event[i].type == USB_EP0_IO_COMPLETED) {
501             HandleEp0IoEvent(funcMgr, &event.ep0Event[i].reqEvent);
502         }
503     }
504 }
505 
UsbFnEventProcess(void * arg)506 static int32_t UsbFnEventProcess(void *arg)
507 {
508     struct UsbFnDeviceMgr *devMgr = (struct UsbFnDeviceMgr *)arg;
509     struct UsbFnAdapterOps *fnOps = UsbFnAdapterGetOps();
510     struct UsbFnEventAll event;
511     struct UsbHandleMgr *handle = NULL;
512     int32_t timeout = SLEEP_TIME_OUT;
513 
514     while (true) {
515         if (devMgr == NULL || !devMgr->running) {
516             break;
517         }
518         if (memset_s(&event, sizeof(event), 0, sizeof(event)) != EOK) {
519             HDF_LOGE("%{public}s:%{public}d memset_s failed", __func__, __LINE__);
520             return HDF_FAILURE;
521         }
522 
523         CollectEventHandle(&event, devMgr);
524         if (event.ep0Num + event.epNum == 0) {
525             continue;
526         }
527         int32_t ret = fnOps->pollEvent(&event, timeout);
528         if (ret != 0) {
529             if (devMgr == NULL || !devMgr->running) {
530                 break;
531             }
532             OsalMSleep(1);
533             continue;
534         }
535         HandleEp0Event(devMgr, event);
536         for (uint8_t i = 0; i < event.epNum; i++) {
537             handle = GetHandleMgr(devMgr, event.epx[i]);
538             if (handle == NULL) {
539                 continue;
540             }
541             for (uint8_t j = 0; j < event.numEvent[i]; j++) {
542                 HandleEpsIoEvent(&event.reqEvent[i][j], handle);
543             }
544         }
545     }
546     if (devMgr) {
547         devMgr->running = true;
548     }
549     HDF_LOGI("%{public}s, exit", __func__);
550     return 0;
551 }
552 
StartThreadIo(struct UsbFnDeviceMgr * fnDevMgr)553 static int32_t StartThreadIo(struct UsbFnDeviceMgr *fnDevMgr)
554 {
555     int32_t ret;
556     struct OsalThreadParam threadCfg;
557     ret = memset_s(&threadCfg, sizeof(threadCfg), 0, sizeof(threadCfg));
558     if (ret != EOK) {
559         HDF_LOGE("%{public}s:%{public}d memset_s failed", __func__, __LINE__);
560         return ret;
561     }
562     threadCfg.name = "usbfn process";
563     threadCfg.priority = OSAL_THREAD_PRI_LOW;
564     threadCfg.stackSize = HDF_PROCESS_STACK_SIZE;
565 
566     ret = OsalThreadCreate(&fnDevMgr->thread, (OsalThreadEntry)UsbFnEventProcess, (void *)fnDevMgr);
567     if (ret != HDF_SUCCESS) {
568         HDF_LOGE("%{public}s:%{public}d OsalThreadCreate failed, ret = %{public}d ", __func__, __LINE__, ret);
569         return HDF_ERR_DEVICE_BUSY;
570     }
571     HDF_LOGD("%{public}s: Usb device OsalThreadCreate", __func__);
572     ret = OsalThreadStart(&fnDevMgr->thread, &threadCfg);
573     if (ret != HDF_SUCCESS) {
574         HDF_LOGE("%{public}s:%{public}d OsalThreadStart failed, ret = %{public}d ", __func__, __LINE__, ret);
575         return HDF_ERR_DEVICE_BUSY;
576     }
577     return 0;
578 }
579 
UsbFnMgrStartRecvEvent(struct UsbFnInterface * interface,uint32_t eventMask,UsbFnEventCallback callback,void * context)580 int32_t UsbFnMgrStartRecvEvent(
581     struct UsbFnInterface *interface, uint32_t eventMask, UsbFnEventCallback callback, void *context)
582 {
583     struct UsbFnInterfaceMgr *interfaceMgr = (struct UsbFnInterfaceMgr *)interface;
584     struct UsbFnFuncMgr *funcMgr = interfaceMgr->funcMgr;
585     if (funcMgr->callback != NULL) {
586         HDF_LOGE("%{public}s: callback has Register", __func__);
587         return HDF_ERR_INVALID_PARAM;
588     }
589     funcMgr->context = context;
590     funcMgr->eventMask = eventMask;
591     funcMgr->callback = callback;
592     if (funcMgr->fd <= 0) {
593         int32_t ret = OpenEp0AndMapAddr(funcMgr);
594         if (ret != HDF_SUCCESS) {
595             HDF_LOGE("%{public}s: OpenEp0AndMapAddr failed, ret = %{public}d ", __func__, ret);
596             return HDF_ERR_IO;
597         }
598     }
599     return 0;
600 }
601 
UsbFnStopRecvEvent(struct UsbFnInterface * interface)602 int32_t UsbFnStopRecvEvent(struct UsbFnInterface *interface)
603 {
604     int32_t ret;
605     struct UsbFnAdapterOps *fnOps = UsbFnAdapterGetOps();
606     struct UsbFnInterfaceMgr *interfaceMgr = (struct UsbFnInterfaceMgr *)interface;
607     struct UsbFnFuncMgr *funcMgr = interfaceMgr->funcMgr;
608     ret = fnOps->queueDel(funcMgr->fd);
609     if (ret) {
610         HDF_LOGE("%{public}s:%{public}d queueDel failed, ret = %{public}d ", __func__, __LINE__, ret);
611         return HDF_ERR_DEVICE_BUSY;
612     }
613     ret = fnOps->closePipe(funcMgr->fd);
614     if (ret) {
615         HDF_LOGE("%{public}s:%{public}d closePipe failed, ret = %{public}d ", __func__, __LINE__, ret);
616         return HDF_ERR_DEVICE_BUSY;
617     }
618     funcMgr->fd = -1;
619     funcMgr->callback = NULL;
620     return 0;
621 }
622