• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3  *
4  * HDF is dual licensed: you can use it either under the terms of
5  * the GPL, or the BSD license, at your option.
6  * See the LICENSE file in the root of this repository for complete details.
7  */
8 
9 #include "usb_test.h"
10 #include "device_resource_if.h"
11 #include "hdf_base.h"
12 #include "hdf_device_desc.h"
13 #include "hdf_log.h"
14 #include "osal_mem.h"
15 #include "osal_time.h"
16 #include "usb_ddk_interface.h"
17 #ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY
18 #include "usb_pnp_notify.h"
19 #endif
20 
21 #define HDF_LOG_TAG USB_TEST_C
22 
23 static struct UsbSession *g_session = NULL;
24 static struct AcmDevice g_deviceService = {0};
25 static struct AcmDevice *g_acm = &g_deviceService;
26 static struct UsbInterface *g_ecmDataIface = NULL;
27 static struct UsbInterface *g_ecmIntIface = NULL;
28 static UsbInterfaceHandle *g_ecmDataDevHandle = NULL;
29 static UsbInterfaceHandle *g_ecmIntDevHandle = NULL;
30 static bool g_initFlag;
31 static bool g_writeBufFlag = 0;
32 static UsbInterfaceHandle *g_acmDataDevHandle[USB_LOOP_NUM];
33 
AcmReadBulk(struct UsbRequest * req)34 static void AcmReadBulk(struct UsbRequest *req)
35 {
36     uint32_t size;
37     int32_t status = req->compInfo.status;
38     size = req->compInfo.actualLength;
39     printf("Bulk status:%d,actualLength:%u\n", status, size);
40     switch (status) {
41         case 0:
42             break;
43         case -ECONNRESET:
44         case -ENOENT:
45         case -ESHUTDOWN:
46             return;
47         default:
48             goto EXIT;
49     }
50 EXIT:
51     return;
52 }
53 
AcmWriteBulk(struct UsbRequest * req)54 static void AcmWriteBulk(struct UsbRequest *req)
55 {
56     int32_t status;
57 
58     if (req == NULL) {
59         printf("%s:%d req is NULL!", __func__, __LINE__);
60         return;
61     }
62 
63     status = req->compInfo.status;
64     printf("Bulk Write status:%d\n", status);
65     struct AcmWb *wb  = (struct AcmWb *)req->compInfo.userData;
66     switch (status) {
67         case 0:
68             wb->use = 0;
69             break;
70         case -ECONNRESET:
71         case -ENOENT:
72         case -ESHUTDOWN:
73             return;
74         default:
75             return;
76     }
77 
78     return;
79 }
80 
AcmWriteIsoCallback(struct UsbRequest * requestArg)81 static void AcmWriteIsoCallback(struct UsbRequest *requestArg)
82 {
83     struct UsbRequest *req = requestArg;
84     printf("%s:%d status:%d\n", __func__, __LINE__, req->compInfo.status);
85 }
86 
AcmWriteBufAllocHandle(const struct AcmDevice * acm)87 static int32_t AcmWriteBufAllocHandle(const struct AcmDevice *acm)
88 {
89     int32_t i;
90     struct AcmWb *wb;
91     for (wb = (struct AcmWb *)&acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
92         wb->buf = (uint8_t *)OsalMemCalloc(acm->writeSize);
93         if (!wb->buf) {
94             while (i > 0) {
95                 --i;
96                 --wb;
97                 OsalMemFree(wb->buf);
98                 wb->buf = NULL;
99             }
100             return -HDF_ERR_MALLOC_FAIL;
101         }
102         g_writeBufFlag = true;
103     }
104 
105     return HDF_SUCCESS;
106 }
107 
AcmWriteBufAlloc(struct AcmDevice * acm)108 static int32_t AcmWriteBufAlloc(struct AcmDevice *acm)
109 {
110     int32_t ret = HDF_SUCCESS;
111 
112     if (!g_writeBufFlag) {
113         ret = AcmWriteBufAllocHandle(acm);
114     }
115 
116     return ret;
117 }
118 
AcmWriteBufFree(struct AcmDevice * acm)119 static void AcmWriteBufFree(struct AcmDevice *acm)
120 {
121     int32_t i;
122     struct AcmWb *wb;
123     for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
124         if (wb->buf) {
125             OsalMemFree(wb->buf);
126             wb->buf = NULL;
127         }
128     }
129     g_writeBufFlag = false;
130     return;
131 }
132 
AcmCtrlIrq(struct UsbRequest * req)133 static void AcmCtrlIrq(struct UsbRequest *req)
134 {
135     if (req == NULL) {
136         printf("%s:%d req is NULL!", __func__, __LINE__);
137         return;
138     }
139     int32_t status = req->compInfo.status;
140     unsigned int currentSize = req->compInfo.actualLength;
141     printf("Irqstatus:%d,actualLength:%u\n", status, currentSize);
142 }
143 
UsbControlMsg(struct TestControlMsgData msgData)144 static struct UsbControlRequest UsbControlMsg(struct TestControlMsgData msgData)
145 {
146     struct UsbControlRequest dr;
147     dr.target = (UsbRequestTargetType)(msgData.requestType & TARGET_MASK);
148     dr.reqType = (UsbControlRequestType)((msgData.requestType >> USB_TYPE_OFFSET) & REQUEST_TYPE_MASK);
149     dr.directon = (UsbRequestDirection)((msgData.requestType >> USB_DIR_OFFSET) & DIRECTION_MASK);
150     dr.request = msgData.request;
151     dr.value = CpuToLe16(msgData.value);
152     dr.index = CpuToLe16(msgData.index);
153     dr.buffer = msgData.data;
154     dr.length = CpuToLe16(msgData.size);
155     return dr;
156 }
157 
CheckHostSdkIfInit001(void)158 static int32_t CheckHostSdkIfInit001(void)
159 {
160     int32_t ret;
161     ret = UsbInitHostSdk(&g_session);
162     if (ret) {
163         HDF_LOGE("%s: error", __func__);
164         return HDF_FAILURE;
165     }
166     g_acm->session = g_session;
167     HDF_LOGE("%s: success", __func__);
168     return HDF_SUCCESS;
169 }
170 
CheckHostSdkIfExit001(void)171 static int32_t CheckHostSdkIfExit001(void)
172 {
173     int32_t ret;
174 
175     ret = UsbExitHostSdk(g_acm->session);
176     if (ret) {
177         HDF_LOGE("%s: error", __func__);
178         return HDF_FAILURE;
179     }
180     g_acm->session = NULL;
181     g_session = g_acm->session;
182     HDF_LOGE("%s: success", __func__);
183     return HDF_SUCCESS;
184 }
185 
CheckHostSdkIfInit002(void)186 static int32_t CheckHostSdkIfInit002(void)
187 {
188     int32_t ret;
189 
190     ret = UsbInitHostSdk(NULL);
191     if (ret) {
192         HDF_LOGE("%s: error", __func__);
193         return HDF_FAILURE;
194     }
195     HDF_LOGE("%s: success", __func__);
196     return HDF_SUCCESS;
197 }
198 
CheckHostSdkIfExit002(void)199 static int32_t CheckHostSdkIfExit002(void)
200 {
201     int32_t ret;
202 
203     ret = UsbExitHostSdk(NULL);
204     if (ret) {
205         HDF_LOGE("%s: error", __func__);
206         return HDF_FAILURE;
207     }
208     HDF_LOGE("%s: success", __func__);
209     return HDF_SUCCESS;
210 }
211 
CheckHostSdkIfInit003(void)212 static int32_t CheckHostSdkIfInit003(void)
213 {
214     int32_t ret;
215     int32_t i;
216 
217     for (i = 0; i < USB_LOOP_NUM; i++) {
218         ret = UsbInitHostSdk(&g_session);
219         if (ret) {
220             HDF_LOGE("%s: error", __func__);
221             return HDF_FAILURE;
222         }
223         g_acm->session = g_session;
224         ret = UsbExitHostSdk(g_acm->session);
225         if (ret) {
226             HDF_LOGE("%s: error", __func__);
227             return HDF_FAILURE;
228         }
229         g_acm->session = NULL;
230         g_session = g_acm->session;
231     }
232     HDF_LOGE("%s: success", __func__);
233     return HDF_SUCCESS;
234 }
235 
CheckHostSdkIfInit004(void)236 static int32_t CheckHostSdkIfInit004(void)
237 {
238     int32_t ret;
239     int32_t i;
240 
241     for (i = 0; i < USB_LOOP_NUM; i++) {
242         ret = UsbInitHostSdk(NULL);
243         if (ret) {
244             HDF_LOGE("%s: error", __func__);
245             return HDF_FAILURE;
246         }
247         ret = UsbExitHostSdk(NULL);
248         if (ret) {
249             HDF_LOGE("%s: error", __func__);
250             return HDF_FAILURE;
251         }
252     }
253     HDF_LOGE("%s: success", __func__);
254     return HDF_SUCCESS;
255 }
256 
CheckHostSdkIfInit005(void)257 static int32_t CheckHostSdkIfInit005(void)
258 {
259     int32_t ret;
260 
261     ret = UsbInitHostSdk(&g_session);
262     if (ret) {
263         HDF_LOGE("%s: error", __func__);
264         return HDF_FAILURE;
265     }
266     g_acm->session = g_session;
267     HDF_LOGE("%s: success", __func__);
268     return HDF_SUCCESS;
269 }
270 
CheckHostSdkIfClaimInterface001(void)271 static int32_t CheckHostSdkIfClaimInterface001(void)
272 {
273     g_acm->interfaceIndex = 1U;
274 
275     g_acm->dataIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
276         g_acm->devAddr, g_acm->interfaceIndex);
277     if (g_acm->dataIface == NULL) {
278         HDF_LOGE("%s: error", __func__);
279         return HDF_FAILURE;
280     }
281     HDF_LOGE("%s: success", __func__);
282     return HDF_SUCCESS;
283 }
284 
CheckHostSdkIfReleaseInterface001(void)285 static int32_t CheckHostSdkIfReleaseInterface001(void)
286 {
287     int32_t ret;
288 
289     ret = UsbReleaseInterface(g_acm->dataIface);
290     if (ret) {
291         HDF_LOGE("%s: error", __func__);
292         return HDF_FAILURE;
293     }
294     HDF_LOGE("%s: success", __func__);
295     return HDF_SUCCESS;
296 }
297 
CheckHostSdkIfClaimInterface002(void)298 static int32_t CheckHostSdkIfClaimInterface002(void)
299 {
300     g_acm->interfaceIndex = 0U;
301 
302     g_acm->intIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
303         g_acm->devAddr, g_acm->interfaceIndex);
304     if (g_acm->intIface == NULL) {
305         HDF_LOGE("%s: error", __func__);
306         return HDF_FAILURE;
307     }
308     HDF_LOGE("%s: success", __func__);
309     return HDF_SUCCESS;
310 }
311 
CheckHostSdkIfReleaseInterface002(void)312 static int32_t CheckHostSdkIfReleaseInterface002(void)
313 {
314     int32_t ret;
315 
316     ret = UsbReleaseInterface(g_acm->intIface);
317     if (ret) {
318         HDF_LOGE("%s: error", __func__);
319         return HDF_FAILURE;
320     }
321     HDF_LOGE("%s: success", __func__);
322     return HDF_SUCCESS;
323 }
324 
CheckHostSdkIfClaimInterface003(void)325 static int32_t CheckHostSdkIfClaimInterface003(void)
326 {
327     g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID;
328 
329     g_acm->ctrIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
330         g_acm->devAddr, g_acm->interfaceIndex);
331     if (g_acm->ctrIface == NULL) {
332         HDF_LOGE("%s: error", __func__);
333         return HDF_FAILURE;
334     }
335     HDF_LOGE("%s: success", __func__);
336     return HDF_SUCCESS;
337 }
338 
CheckHostSdkIfReleaseInterface003(void)339 static int32_t CheckHostSdkIfReleaseInterface003(void)
340 {
341     int32_t ret;
342 
343     ret = UsbReleaseInterface(g_acm->ctrIface);
344     if (ret) {
345         HDF_LOGE("%s: error", __func__);
346         return HDF_FAILURE;
347     }
348     HDF_LOGE("%s: success", __func__);
349     return HDF_SUCCESS;
350 }
351 
CheckHostSdkIfClaimInterface004(void)352 static int32_t CheckHostSdkIfClaimInterface004(void)
353 {
354     g_acm->interfaceIndex = 2U;
355 
356     g_acm->dataIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
357         g_acm->devAddr, g_acm->interfaceIndex);
358     if (g_acm->dataIface == NULL) {
359         HDF_LOGE("%s: error", __func__);
360         return HDF_FAILURE;
361     }
362     HDF_LOGE("%s: success", __func__);
363     return HDF_SUCCESS;
364 }
365 
CheckHostSdkIfClaimInterface005(void)366 static int32_t CheckHostSdkIfClaimInterface005(void)
367 {
368     g_acm->interfaceIndex = 3U;
369 
370     g_acm->dataIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
371         g_acm->devAddr, g_acm->interfaceIndex);
372     if (g_acm->dataIface == NULL) {
373         HDF_LOGE("%s: error", __func__);
374         return HDF_FAILURE;
375     }
376     HDF_LOGE("%s: success", __func__);
377     return HDF_SUCCESS;
378 }
379 
CheckHostSdkIfClaimInterface006(void)380 static int32_t CheckHostSdkIfClaimInterface006(void)
381 {
382     g_acm = &g_deviceService;
383     g_acm->interfaceIndex = 3U;
384     g_acm->dataIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
385         g_acm->devAddr, g_acm->interfaceIndex);
386     if (g_acm->dataIface == NULL) {
387         HDF_LOGE("%s: error", __func__);
388         return HDF_FAILURE;
389     }
390 
391     g_acm->interfaceIndex = 2U;
392     g_acm->intIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
393         g_acm->devAddr, g_acm->interfaceIndex);
394     if (g_acm->intIface == NULL) {
395         HDF_LOGE("%s: error", __func__);
396         return HDF_FAILURE;
397     }
398 
399     g_acm->interfaceIndex = 0U;
400     g_ecmIntIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
401         g_acm->devAddr, g_acm->interfaceIndex);
402     if (g_ecmIntIface == NULL) {
403         HDF_LOGE("%s: error", __func__);
404         return HDF_FAILURE;
405     }
406 
407     g_acm->interfaceIndex = 1U;
408     g_ecmDataIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
409         g_acm->devAddr, g_acm->interfaceIndex);
410     if (g_ecmDataIface == NULL) {
411         HDF_LOGE("%s: error", __func__);
412         return HDF_FAILURE;
413     }
414 
415     g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID;
416     g_acm->ctrIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
417         g_acm->devAddr, g_acm->interfaceIndex);
418     if (g_acm->ctrIface == NULL) {
419         HDF_LOGE("%s: error", __func__);
420         return HDF_FAILURE;
421     }
422     HDF_LOGE("%s: success", __func__);
423     return HDF_SUCCESS;
424 }
425 
CheckHostSdkIfOpenInterface001(void)426 static int32_t CheckHostSdkIfOpenInterface001(void)
427 {
428     g_acm->data_devHandle = UsbOpenInterface(g_acm->dataIface);
429     if (g_acm->data_devHandle == NULL) {
430         HDF_LOGE("%s: error", __func__);
431         return HDF_FAILURE;
432     }
433     HDF_LOGE("%s: success", __func__);
434     return HDF_SUCCESS;
435 }
436 
CheckHostSdkIfCloseInterface001(void)437 static int32_t CheckHostSdkIfCloseInterface001(void)
438 {
439     int32_t ret;
440 
441     ret = UsbCloseInterface(g_acm->data_devHandle);
442     if (ret) {
443         HDF_LOGE("%s: error", __func__);
444         return HDF_FAILURE;
445     }
446     HDF_LOGE("%s: success", __func__);
447     return HDF_SUCCESS;
448 }
449 
CheckHostSdkIfOpenInterface002(void)450 static int32_t CheckHostSdkIfOpenInterface002(void)
451 {
452     g_acm->int_devHandle = UsbOpenInterface(g_acm->intIface);
453     if (g_acm->int_devHandle == NULL) {
454         HDF_LOGE("%s: error", __func__);
455         return HDF_FAILURE;
456     }
457     HDF_LOGE("%s: success", __func__);
458     return HDF_SUCCESS;
459 }
460 
CheckHostSdkIfCloseInterface002(void)461 static int32_t CheckHostSdkIfCloseInterface002(void)
462 {
463     int32_t ret;
464 
465     ret = UsbCloseInterface(g_acm->int_devHandle);
466     if (ret) {
467         HDF_LOGE("%s: error", __func__);
468         return HDF_FAILURE;
469     }
470     HDF_LOGE("%s: success", __func__);
471     return HDF_SUCCESS;
472 }
473 
CheckHostSdkIfOpenInterface003(void)474 static int32_t CheckHostSdkIfOpenInterface003(void)
475 {
476     g_acm->ctrl_devHandle = UsbOpenInterface(g_acm->ctrIface);
477     if (g_acm->ctrl_devHandle == NULL) {
478         HDF_LOGE("%s: error", __func__);
479         return HDF_FAILURE;
480     }
481     HDF_LOGE("%s: success", __func__);
482     return HDF_SUCCESS;
483 }
484 
CheckHostSdkIfCloseInterface003(void)485 static int32_t CheckHostSdkIfCloseInterface003(void)
486 {
487     int32_t ret;
488     ret = UsbCloseInterface(g_acm->ctrl_devHandle);
489     if (ret) {
490         HDF_LOGE("%s: error", __func__);
491         return HDF_FAILURE;
492     }
493     HDF_LOGE("%s: success", __func__);
494     return HDF_SUCCESS;
495 }
496 
CheckHostSdkIfOpenInterface004(void)497 static int32_t CheckHostSdkIfOpenInterface004(void)
498 {
499     g_acm->data_devHandle = UsbOpenInterface(NULL);
500     if (g_acm->data_devHandle == NULL) {
501         HDF_LOGE("%s: error", __func__);
502         return HDF_SUCCESS;
503     }
504     HDF_LOGE("%s: success", __func__);
505     return HDF_FAILURE;
506 }
507 
CheckHostSdkIfOpenInterface005(void)508 static int32_t CheckHostSdkIfOpenInterface005(void)
509 {
510     int32_t i;
511     for (i = 0; i < USB_LOOP_NUM; i++) {
512         g_acmDataDevHandle[i] = UsbOpenInterface(g_acm->dataIface);
513         if (g_acmDataDevHandle[i] == NULL) {
514             HDF_LOGE("%s:%d i=%d error", __func__, __LINE__, i);
515             return HDF_FAILURE;
516         }
517     }
518     HDF_LOGE("%s: success", __func__);
519     return HDF_SUCCESS;
520 }
521 
CheckHostSdkIfCloseInterface005(void)522 static int32_t CheckHostSdkIfCloseInterface005(void)
523 {
524     int32_t i;
525     int32_t ret;
526     for (i = 0; i < USB_LOOP_NUM; i++) {
527         ret = UsbCloseInterface(g_acmDataDevHandle[i]);
528         if (ret) {
529             HDF_LOGE("%s: error", __func__);
530             return HDF_FAILURE;
531         }
532     }
533     HDF_LOGE("%s: success", __func__);
534     return HDF_SUCCESS;
535 }
536 
CheckHostSdkIfOpenInterface006(void)537 static int32_t CheckHostSdkIfOpenInterface006(void)
538 {
539     g_acm->data_devHandle = UsbOpenInterface(g_acm->dataIface);
540     if (g_acm->data_devHandle == NULL) {
541         HDF_LOGE("%s: error", __func__);
542         return HDF_FAILURE;
543     }
544     g_acm->int_devHandle = UsbOpenInterface(g_acm->intIface);
545     if (g_acm->int_devHandle == NULL) {
546         HDF_LOGE("%s: error", __func__);
547         return HDF_FAILURE;
548     }
549     g_acm->ctrl_devHandle = UsbOpenInterface(g_acm->ctrIface);
550     if (g_acm->ctrl_devHandle == NULL) {
551         HDF_LOGE("%s: error", __func__);
552         return HDF_FAILURE;
553     }
554     g_ecmDataDevHandle = UsbOpenInterface(g_ecmDataIface);
555     if (g_ecmDataDevHandle == NULL) {
556         HDF_LOGE("%s: error", __func__);
557         return HDF_FAILURE;
558     }
559     g_ecmIntDevHandle = UsbOpenInterface(g_ecmIntIface);
560     if (g_ecmIntDevHandle == NULL) {
561         HDF_LOGE("%s: error", __func__);
562         return HDF_FAILURE;
563     }
564     HDF_LOGE("%s: success", __func__);
565     return HDF_SUCCESS;
566 }
567 
CheckHostSdkIfSelectInterfaceSetting001(void)568 static int32_t CheckHostSdkIfSelectInterfaceSetting001(void)
569 {
570     int32_t ret;
571     int32_t settingIndex = 0;
572     ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface);
573     if (ret) {
574         HDF_LOGE("%s: error", __func__);
575         return HDF_FAILURE;
576     }
577     HDF_LOGE("%s: success", __func__);
578     return HDF_SUCCESS;
579 }
580 
CheckHostSdkIfSelectInterfaceSetting002(void)581 static int32_t CheckHostSdkIfSelectInterfaceSetting002(void)
582 {
583     int32_t ret;
584     int32_t settingIndex = 10;
585     ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface);
586     if (ret != HDF_FAILURE) {
587         HDF_LOGE("%s: error", __func__);
588         return HDF_FAILURE;
589     }
590     HDF_LOGE("%s: success", __func__);
591     return HDF_SUCCESS;
592 }
593 
CheckHostSdkIfSelectInterfaceSetting003(void)594 static int32_t CheckHostSdkIfSelectInterfaceSetting003(void)
595 {
596     int32_t ret;
597     int32_t settingIndex = 100;
598     ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface);
599     if (ret != HDF_FAILURE) {
600         HDF_LOGE("%s: error", __func__);
601         return HDF_FAILURE;
602     }
603     HDF_LOGE("%s: success", __func__);
604     return HDF_SUCCESS;
605 }
606 
CheckHostSdkIfSelectInterfaceSetting004(void)607 static int32_t CheckHostSdkIfSelectInterfaceSetting004(void)
608 {
609     int32_t ret;
610     int32_t settingIndex = 200;
611     ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface);
612     if (ret != HDF_FAILURE) {
613         HDF_LOGE("%s: error", __func__);
614         return HDF_FAILURE;
615     }
616     HDF_LOGE("%s: success", __func__);
617     return HDF_SUCCESS;
618 }
619 
CheckHostSdkIfSelectInterfaceSetting005(void)620 static int32_t CheckHostSdkIfSelectInterfaceSetting005(void)
621 {
622     int32_t ret;
623     int32_t settingIndex = USB_MAX_BYTE;
624     ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface);
625     if (ret != HDF_FAILURE) {
626         HDF_LOGE("%s: error", __func__);
627         return HDF_FAILURE;
628     }
629     HDF_LOGE("%s: success", __func__);
630     return HDF_SUCCESS;
631 }
632 
CheckHostSdkIfSelectInterfaceSetting006(void)633 static int32_t CheckHostSdkIfSelectInterfaceSetting006(void)
634 {
635     int32_t ret;
636     int32_t settingIndex = 1;
637     ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface);
638     if (ret) {
639         HDF_LOGE("%s: error", __func__);
640         return HDF_FAILURE;
641     }
642     HDF_LOGE("%s: success", __func__);
643     return HDF_SUCCESS;
644 }
645 
CheckHostSdkIfClaimInterface007(void)646 static int32_t CheckHostSdkIfClaimInterface007(void)
647 {
648     g_acm->interfaceIndex = 0U;
649 
650     g_ecmIntIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
651         g_acm->devAddr, g_acm->interfaceIndex);
652     if (g_ecmIntIface == NULL) {
653         HDF_LOGE("%s: error", __func__);
654         return HDF_FAILURE;
655     }
656     HDF_LOGE("%s: success", __func__);
657     return HDF_SUCCESS;
658 }
659 
CheckHostSdkIfClaimInterface008(void)660 static int32_t CheckHostSdkIfClaimInterface008(void)
661 {
662     g_acm->interfaceIndex = 1U;
663     g_ecmDataIface =  (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum,
664         g_acm->devAddr, g_acm->interfaceIndex);
665     if (g_ecmDataIface == NULL) {
666         HDF_LOGE("%s: error", __func__);
667         return HDF_FAILURE;
668     }
669     HDF_LOGE("%s: success", __func__);
670     return HDF_SUCCESS;
671 }
672 
CheckHostSdkIfGetPipe001(void)673 static int32_t CheckHostSdkIfGetPipe001(void)
674 {
675     int32_t ret;
676     struct UsbPipeInfo p;
677     uint8_t i;
678     for (i = 0;  i <= g_acm->dataIface->info.pipeNum; i++) {
679         ret = UsbGetPipeInfo(NULL, g_acm->dataIface->info.curAltSetting, i, &p);
680         if (ret < 0) {
681             continue;
682         }
683         if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_BULK)) {
684             struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(struct UsbPipeInfo));
685             if (pi == NULL) {
686                 HDF_LOGE("%s: error", __func__);
687                 return HDF_FAILURE;
688             }
689             p.interfaceId = g_acm->dataIface->info.interfaceIndex;
690             *pi = p;
691             g_acm->dataInPipe = pi;
692             break;
693         }
694     }
695     if (i > g_acm->dataIface->info.pipeNum) {
696         return HDF_FAILURE;
697     }
698     if (g_acm->dataInPipe == NULL) {
699         HDF_LOGE("%s: error", __func__);
700         return HDF_FAILURE;
701     }
702     HDF_LOGE("%s: success", __func__);
703     return HDF_SUCCESS;
704 }
705 
CheckHostSdkIfGetPipe002(void)706 static int32_t CheckHostSdkIfGetPipe002(void)
707 {
708     int32_t ret;
709     struct UsbPipeInfo p;
710     uint8_t i;
711     for (i = 0;  i <= g_acm->dataIface->info.pipeNum; i++) {
712         ret = UsbGetPipeInfo(g_acm->data_devHandle, g_acm->dataIface->info.curAltSetting, i, &p);
713         if (ret < 0) {
714             continue;
715         }
716         if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_BULK)) {
717             struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(struct UsbPipeInfo));
718             if (pi == NULL) {
719                 return HDF_FAILURE;
720             }
721             p.interfaceId = g_acm->dataIface->info.interfaceIndex;
722             *pi = p;
723             g_acm->dataInPipe = pi;
724             break;
725         }
726     }
727     if (g_acm->dataInPipe == NULL) {
728         HDF_LOGE("%s: error", __func__);
729         return HDF_FAILURE;
730     }
731     HDF_LOGE("%s: success", __func__);
732     return HDF_SUCCESS;
733 }
734 
CheckHostSdkIfGetPipe003(void)735 static int32_t CheckHostSdkIfGetPipe003(void)
736 {
737     int32_t ret;
738     struct UsbPipeInfo p;
739     uint8_t i;
740     for (i = 0;  i <= g_acm->dataIface->info.pipeNum; i++) {
741         ret = UsbGetPipeInfo(NULL, g_acm->dataIface->info.curAltSetting, i, &p);
742         if (ret < 0) {
743             continue;
744         }
745         if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_BULK)) {
746             struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(struct UsbPipeInfo));
747             if (pi == NULL) {
748                 HDF_LOGE("%s: error", __func__);
749                 return HDF_FAILURE;
750             }
751             p.interfaceId = g_acm->dataIface->info.interfaceIndex;
752             *pi = p;
753             g_acm->dataOutPipe = pi;
754             break;
755         }
756     }
757     if (i > g_acm->dataIface->info.pipeNum) {
758         return HDF_FAILURE;
759     }
760     if (g_acm->dataOutPipe == NULL) {
761         HDF_LOGE("%s: error", __func__);
762         return HDF_FAILURE;
763     }
764     HDF_LOGE("%s: success", __func__);
765     return HDF_SUCCESS;
766 }
767 
CheckHostSdkIfGetPipe004(void)768 static int32_t CheckHostSdkIfGetPipe004(void)
769 {
770     int32_t ret;
771     struct UsbPipeInfo p;
772     uint8_t i;
773     for (i = 0;  i <= g_acm->dataIface->info.pipeNum; i++) {
774         ret = UsbGetPipeInfo(g_acm->data_devHandle, g_acm->dataIface->info.curAltSetting, i, &p);
775         if (ret < 0) {
776             continue;
777         }
778         if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_BULK)) {
779             struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(struct UsbPipeInfo));
780             if (pi == NULL) {
781                 return HDF_FAILURE;
782             }
783             p.interfaceId = g_acm->dataIface->info.interfaceIndex;
784             *pi = p;
785             g_acm->dataOutPipe = pi;
786             break;
787         }
788     }
789     if (g_acm->dataOutPipe == NULL) {
790         HDF_LOGE("%s: error", __func__);
791         return HDF_FAILURE;
792     }
793     HDF_LOGE("%s: success", __func__);
794     return HDF_SUCCESS;
795 }
796 
CheckHostSdkIfGetPipe005(void)797 static int32_t CheckHostSdkIfGetPipe005(void)
798 {
799     int32_t ret;
800     struct UsbPipeInfo p;
801     uint8_t i;
802     for (i = 0;  i <= g_acm->intIface->info.pipeNum; i++) {
803         ret = UsbGetPipeInfo(NULL, g_acm->intIface->info.curAltSetting, i, &p);
804         if (ret < 0) {
805             continue;
806         }
807         if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_INTERRUPT)) {
808             struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(struct UsbPipeInfo));
809             if (pi == NULL) {
810                 return HDF_FAILURE;
811             }
812             p.interfaceId = g_acm->intIface->info.interfaceIndex;
813             *pi = p;
814             g_acm->intPipe = pi;
815             break;
816         }
817     }
818     if (i > g_acm->intIface->info.pipeNum) {
819         return HDF_FAILURE;
820     }
821     if (g_acm->intPipe == NULL) {
822         HDF_LOGE("%s: error", __func__);
823         return HDF_FAILURE;
824     }
825     HDF_LOGE("%s: success", __func__);
826     return HDF_SUCCESS;
827 }
828 
CheckHostSdkIfGetPipe006(void)829 static int32_t CheckHostSdkIfGetPipe006(void)
830 {
831     int32_t ret;
832     struct UsbPipeInfo p;
833     uint8_t i;
834     for (i = 0;  i <= g_acm->intIface->info.pipeNum; i++) {
835         ret = UsbGetPipeInfo(g_acm->int_devHandle, g_acm->intIface->info.curAltSetting, i, &p);
836         if (ret < 0) {
837             continue;
838         }
839         if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_INTERRUPT)) {
840             struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(struct UsbPipeInfo));
841             if (pi == NULL) {
842                 return HDF_FAILURE;
843             }
844             p.interfaceId = g_acm->intIface->info.interfaceIndex;
845             *pi = p;
846             g_acm->intPipe = pi;
847             break;
848         }
849     }
850     if (g_acm->intPipe == NULL) {
851         HDF_LOGE("%s: error", __func__);
852         return HDF_FAILURE;
853     }
854     HDF_LOGE("%s: success", __func__);
855     return HDF_SUCCESS;
856 }
857 
CheckHostSdkIfGetPipe007(void)858 static int32_t CheckHostSdkIfGetPipe007(void)
859 {
860     int32_t ret;
861     struct UsbPipeInfo p;
862     uint8_t i;
863     g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID;
864     for (i = 0;  i <= g_acm->ctrIface->info.pipeNum; i++) {
865         ret = UsbGetPipeInfo(NULL, g_acm->ctrIface->info.curAltSetting, i, &p);
866         if (ret < 0) {
867             continue;
868         }
869         if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_CONTROL)) {
870             struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(struct UsbPipeInfo));
871             if (pi == NULL) {
872                 return HDF_FAILURE;
873             }
874             p.interfaceId = g_acm->interfaceIndex;
875             *pi = p;
876             g_acm->ctrPipe = pi;
877             break;
878         }
879     }
880     if (i > g_acm->ctrIface->info.pipeNum) {
881         return HDF_FAILURE;
882     }
883     if (g_acm->ctrPipe == NULL) {
884         HDF_LOGE("%s: error", __func__);
885         return HDF_FAILURE;
886     }
887     HDF_LOGE("%s: success", __func__);
888     return HDF_SUCCESS;
889 }
890 
CheckHostSdkIfGetPipe008(void)891 static int32_t CheckHostSdkIfGetPipe008(void)
892 {
893     int32_t ret;
894     struct UsbPipeInfo p;
895     uint8_t i;
896     g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID;
897     for (i = 0;  i <= g_acm->ctrIface->info.pipeNum; i++) {
898         ret = UsbGetPipeInfo(g_acm->ctrl_devHandle, g_acm->ctrIface->info.curAltSetting, i, &p);
899         if (ret < 0) {
900             continue;
901         }
902         if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_CONTROL)) {
903             struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(struct UsbPipeInfo));
904             if (pi == NULL) {
905                 return HDF_FAILURE;
906             }
907             p.interfaceId = g_acm->interfaceIndex;
908             *pi = p;
909             g_acm->ctrPipe = pi;
910             break;
911         }
912     }
913     if (g_acm->ctrPipe == NULL) {
914         HDF_LOGE("%s: error", __func__);
915         return HDF_FAILURE;
916     }
917     HDF_LOGE("%s: success", __func__);
918     return HDF_SUCCESS;
919 }
920 
CheckHostSdkIfAllocRequest001(void)921 static int32_t CheckHostSdkIfAllocRequest001(void)
922 {
923     int32_t i;
924     g_acm->readSize = g_acm->dataInPipe->maxPacketSize;
925     printf("------readSize = [%d]------\n", g_acm->readSize);
926     for (i = 0; i < ACM_NR; i++) {
927         g_acm->readReq[i] = UsbAllocRequest(NULL, 0, g_acm->readSize);
928         if (g_acm->readReq[i] == NULL) {
929             HDF_LOGE("%s: error", __func__);
930             return HDF_SUCCESS;
931         }
932     }
933     HDF_LOGE("%s: success", __func__);
934     return HDF_FAILURE;
935 }
936 
CheckHostSdkIfAllocRequest002(void)937 static int32_t CheckHostSdkIfAllocRequest002(void)
938 {
939     int32_t i;
940     g_acm->readSize = g_acm->dataInPipe->maxPacketSize;
941     printf("------readSize = [%d]------\n", g_acm->readSize);
942     for (i = 0; i < ACM_NR; i++) {
943         g_acm->readReq[i] = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->readSize);
944         if (g_acm->readReq[i] == NULL) {
945             HDF_LOGE("%s: error", __func__);
946             return HDF_FAILURE;
947         }
948     }
949     HDF_LOGE("%s: success", __func__);
950     return HDF_SUCCESS;
951 }
952 
CheckHostSdkIfFreeRequest001(void)953 static int32_t CheckHostSdkIfFreeRequest001(void)
954 {
955     int32_t ret;
956     int32_t i;
957     for (i = 0; i < ACM_NR; i++) {
958         ret = UsbFreeRequest(g_acm->readReq[i]);
959         if (ret) {
960             HDF_LOGE("%s: error", __func__);
961             return HDF_FAILURE;
962         }
963         g_acm->readReq[i] = NULL;
964     }
965     HDF_LOGE("%s: success", __func__);
966     return HDF_SUCCESS;
967 }
968 
CheckHostSdkIfAllocRequest003(void)969 static int32_t CheckHostSdkIfAllocRequest003(void)
970 {
971     int32_t i;
972     int32_t ret;
973     g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize;
974     ret = AcmWriteBufAlloc(g_acm);
975     if (ret) {
976         HDF_LOGE("%s: error", __func__);
977         return HDF_FAILURE;
978     }
979     for (i = 0; i < ACM_NW; i++) {
980         g_acm->wb[i].request = UsbAllocRequest(NULL, 0, g_acm->writeSize);
981         g_acm->wb[i].instance = g_acm;
982         if (g_acm->wb[i].request == NULL) {
983             HDF_LOGE("%s: error", __func__);
984             return HDF_SUCCESS;
985         }
986     }
987     HDF_LOGE("%s: success", __func__);
988     return HDF_FAILURE;
989 }
990 
CheckHostSdkIfAllocRequest004(void)991 static int32_t CheckHostSdkIfAllocRequest004(void)
992 {
993     int32_t i;
994     int32_t ret;
995     g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize;
996     ret = AcmWriteBufAlloc(g_acm);
997     if (ret) {
998         HDF_LOGE("%s: error", __func__);
999         return HDF_FAILURE;
1000     }
1001 
1002     for (i = 0; i < ACM_NW; i++) {
1003         g_acm->wb[i].request = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->writeSize);
1004         g_acm->wb[i].instance = g_acm;
1005         if (g_acm->wb[i].request == NULL) {
1006             HDF_LOGE("%s: error", __func__);
1007             return HDF_FAILURE;
1008         }
1009     }
1010     HDF_LOGE("%s: success", __func__);
1011     return HDF_SUCCESS;
1012 }
1013 
CheckHostSdkIfFreeRequest002(void)1014 static int32_t CheckHostSdkIfFreeRequest002(void)
1015 {
1016     int32_t ret;
1017     int32_t i;
1018     for (i = 0; i < ACM_NR; i++) {
1019         ret = UsbFreeRequest(g_acm->wb[i].request);
1020         if (ret) {
1021             HDF_LOGE("%s: error", __func__);
1022             return HDF_FAILURE;
1023         }
1024         g_acm->wb[i].request = NULL;
1025     }
1026     AcmWriteBufFree(g_acm);
1027     HDF_LOGE("%s: success", __func__);
1028     return HDF_SUCCESS;
1029 }
1030 
CheckHostSdkIfAllocRequest005(void)1031 static int32_t CheckHostSdkIfAllocRequest005(void)
1032 {
1033     g_acm->intSize = g_acm->intPipe->maxPacketSize;
1034     g_acm->notifyReq = UsbAllocRequest(NULL, 0, g_acm->intSize);
1035     if (g_acm->notifyReq == NULL) {
1036         HDF_LOGE("%s: error", __func__);
1037         return HDF_SUCCESS;
1038     }
1039     HDF_LOGE("%s: success", __func__);
1040     return HDF_FAILURE;
1041 }
1042 
CheckHostSdkIfAllocRequest006(void)1043 static int32_t CheckHostSdkIfAllocRequest006(void)
1044 {
1045     g_acm->intSize = g_acm->intPipe->maxPacketSize;
1046     g_acm->notifyReq = UsbAllocRequest(g_acm->int_devHandle, 0, g_acm->intSize);
1047     if (g_acm->notifyReq == NULL) {
1048         HDF_LOGE("%s: error", __func__);
1049         return HDF_FAILURE;
1050     }
1051     HDF_LOGE("%s: success", __func__);
1052     return HDF_SUCCESS;
1053 }
1054 
CheckHostSdkIfFreeRequest003(void)1055 static int32_t CheckHostSdkIfFreeRequest003(void)
1056 {
1057     int32_t ret;
1058 
1059     ret = UsbFreeRequest(g_acm->notifyReq);
1060     if (ret) {
1061         HDF_LOGE("%s: error", __func__);
1062         return HDF_FAILURE;
1063     }
1064     g_acm->notifyReq = NULL;
1065     HDF_LOGE("%s: success", __func__);
1066     return HDF_SUCCESS;
1067 }
1068 
CheckHostSdkIfAllocRequest007(void)1069 static int32_t CheckHostSdkIfAllocRequest007(void)
1070 {
1071     g_acm->ctrlSize = sizeof (struct UsbCdcLineCoding);
1072     g_acm->ctrlReq = UsbAllocRequest(NULL, 0, g_acm->ctrlSize);
1073     if (g_acm->ctrlReq == NULL) {
1074         HDF_LOGE("%s: error", __func__);
1075         return HDF_SUCCESS;
1076     }
1077     HDF_LOGE("%s: success", __func__);
1078     return HDF_FAILURE;
1079 }
1080 
CheckHostSdkIfAllocRequest008(void)1081 static int32_t CheckHostSdkIfAllocRequest008(void)
1082 {
1083     g_acm->ctrlSize = sizeof (struct UsbCdcLineCoding);
1084     g_acm->ctrlReq = UsbAllocRequest(g_acm->ctrl_devHandle, 0, g_acm->ctrlSize);
1085     if (g_acm->ctrlReq == NULL) {
1086         HDF_LOGE("%s: error", __func__);
1087         return HDF_FAILURE;
1088     }
1089     HDF_LOGE("%s: success", __func__);
1090     return HDF_SUCCESS;
1091 }
1092 
CheckHostSdkIfAllocRequest010(void)1093 static int32_t CheckHostSdkIfAllocRequest010(void)
1094 {
1095     size_t size = g_acm->dataOutPipe->maxPacketSize;
1096     g_acm->isoReq = UsbAllocRequest(NULL, USB_ISO_PACKAT_CNT, size);
1097     if (g_acm->isoReq == NULL) {
1098         HDF_LOGE("%s: error", __func__);
1099         return HDF_FAILURE;
1100     }
1101     HDF_LOGE("%s: success", __func__);
1102     return HDF_SUCCESS;
1103 }
CheckHostSdkIfAllocRequest011(void)1104 static int32_t CheckHostSdkIfAllocRequest011(void)
1105 {
1106     size_t size = g_acm->dataOutPipe->maxPacketSize;
1107     g_acm->isoReq = UsbAllocRequest(g_acm->iso_devHandle, USB_ISO_PACKAT_CNT, size);
1108     if (g_acm->isoReq == NULL) {
1109         HDF_LOGE("%s: error", __func__);
1110         return HDF_FAILURE;
1111     }
1112     HDF_LOGE("%s: success", __func__);
1113     return HDF_SUCCESS;
1114 }
1115 
CheckHostSdkIfFreeRequest006(void)1116 static int32_t CheckHostSdkIfFreeRequest006(void)
1117 {
1118     int32_t ret;
1119 
1120     if (g_acm->isoReq == NULL) {
1121         HDF_LOGE("%s: isoReq is NULL", __func__);
1122         return HDF_FAILURE;
1123     }
1124     ret = UsbFreeRequest(g_acm->isoReq);
1125     if (ret) {
1126         HDF_LOGE("%s: error", __func__);
1127         return HDF_FAILURE;
1128     }
1129     g_acm->isoReq = NULL;
1130     HDF_LOGE("%s: success", __func__);
1131     return HDF_SUCCESS;
1132 }
1133 
CheckHostSdkIfFillIsoRequest001(void)1134 static int32_t CheckHostSdkIfFillIsoRequest001(void)
1135 {
1136     int32_t ret;
1137     struct UsbRequestParams parmas = {0};
1138     int32_t i;
1139     char sendData[] = {"abcde\0"};
1140     uint32_t size = strlen(sendData) + 1;
1141     if (g_acm->isoPipe == NULL) {
1142         return HDF_FAILURE;
1143     }
1144     for (i = 0; i < 1; i++) {
1145         parmas.interfaceId = g_acm->isoPipe->interfaceId;
1146         parmas.pipeAddress = g_acm->isoPipe->pipeAddress;
1147         parmas.pipeId = g_acm->isoPipe->pipeId;
1148         parmas.callback = AcmWriteIsoCallback;
1149         parmas.userData = NULL;
1150         parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1151         parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1152         parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT;
1153         parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE;
1154         parmas.dataReq.length = (int)size;
1155         parmas.dataReq.buffer = (unsigned char *)sendData;
1156         ret = UsbFillRequest(g_acm->isoReq, g_acm->iso_devHandle, &parmas);
1157         if (ret) {
1158             HDF_LOGE("%s: error", __func__);
1159             return HDF_FAILURE;
1160         }
1161     }
1162     HDF_LOGE("%s: success", __func__);
1163     return HDF_SUCCESS;
1164 }
1165 
CheckHostSdkIfFillIsoRequest002(void)1166 static int32_t CheckHostSdkIfFillIsoRequest002(void)
1167 {
1168     int32_t ret;
1169     struct UsbRequestParams parmas;
1170     int32_t i;
1171     char sendData[] = {"abcde\0"};
1172     uint32_t size = strlen(sendData) + 1;
1173     if (g_acm->isoPipe == NULL) {
1174         return HDF_FAILURE;
1175     }
1176     for (i = 0; i < 1; i++) {
1177         parmas.interfaceId = g_acm->isoPipe->interfaceId;
1178         parmas.pipeAddress = g_acm->isoPipe->pipeAddress;
1179         parmas.pipeId = g_acm->isoPipe->pipeId;
1180         parmas.callback = AcmWriteIsoCallback;
1181         parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1182         parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1183         parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT;
1184         parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE;
1185         parmas.dataReq.length = (int)size;
1186         parmas.dataReq.buffer = (unsigned char *)sendData;
1187         ret = UsbFillRequest(NULL, g_acm->iso_devHandle, &parmas);
1188         if (ret) {
1189             HDF_LOGE("%s: error", __func__);
1190             return HDF_FAILURE;
1191         }
1192     }
1193     HDF_LOGE("%s: success", __func__);
1194     return HDF_SUCCESS;
1195 }
1196 
CheckHostSdkIfFillIsoRequest003(void)1197 static int32_t CheckHostSdkIfFillIsoRequest003(void)
1198 {
1199     int32_t ret;
1200     struct UsbRequestParams parmas;
1201     int32_t i;
1202     char sendData[] = {"abcde\0"};
1203     uint32_t size = strlen(sendData) + 1;
1204     if (g_acm->isoPipe == NULL) {
1205         return HDF_FAILURE;
1206     }
1207     for (i = 0; i < 1; i++) {
1208         parmas.interfaceId = g_acm->isoPipe->interfaceId;
1209         parmas.pipeAddress = g_acm->isoPipe->pipeAddress;
1210         parmas.pipeId = g_acm->isoPipe->pipeId;
1211         parmas.callback = AcmWriteIsoCallback;
1212         parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1213         parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1214         parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT;
1215         parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE;
1216         parmas.dataReq.length = (int)size;
1217         parmas.dataReq.buffer = (unsigned char *)sendData;
1218         ret = UsbFillRequest(g_acm->isoReq, NULL, &parmas);
1219         if (ret) {
1220             HDF_LOGE("%s: error", __func__);
1221             return HDF_FAILURE;
1222         }
1223     }
1224     HDF_LOGE("%s: success", __func__);
1225     return HDF_SUCCESS;
1226 }
1227 
CheckHostSdkIfFillIsoRequest004(void)1228 static int32_t CheckHostSdkIfFillIsoRequest004(void)
1229 {
1230     int32_t ret;
1231     struct UsbRequestParams parmas;
1232     int32_t i;
1233     char sendData[] = {"abcde\0"};
1234     uint32_t size = strlen(sendData) + 1;
1235     if (g_acm->isoPipe == NULL) {
1236         return HDF_FAILURE;
1237     }
1238     for (i = 0; i < 1; i++) {
1239         parmas.interfaceId = g_acm->isoPipe->interfaceId;
1240         parmas.pipeAddress = g_acm->isoPipe->pipeAddress;
1241         parmas.pipeId = g_acm->isoPipe->pipeId;
1242         parmas.callback = AcmWriteIsoCallback;
1243         parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1244         parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1245         parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT;
1246         parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE;
1247         parmas.dataReq.length = (int)size;
1248         parmas.dataReq.buffer = (unsigned char *)sendData;
1249         ret = UsbFillRequest(g_acm->isoReq, g_acm->iso_devHandle, NULL);
1250         if (ret) {
1251             HDF_LOGE("%s: error", __func__);
1252             return HDF_FAILURE;
1253         }
1254     }
1255     HDF_LOGE("%s: success", __func__);
1256     return HDF_SUCCESS;
1257 }
1258 
CheckHostSdkIfFillIsoRequest005(void)1259 static int32_t CheckHostSdkIfFillIsoRequest005(void)
1260 {
1261     int32_t ret;
1262     struct UsbRequestParams parmas;
1263     int32_t i;
1264     char sendData[] = {"abcde\0"};
1265     uint32_t size = strlen(sendData) + 1;
1266     if (g_acm->isoPipe == NULL) {
1267         return HDF_FAILURE;
1268     }
1269     for (i = 0; i < 1; i++) {
1270         parmas.interfaceId = g_acm->isoPipe->interfaceId;
1271         parmas.pipeAddress = g_acm->isoPipe->pipeAddress;
1272         parmas.pipeId = g_acm->isoPipe->pipeId;
1273         parmas.callback = AcmWriteIsoCallback;
1274         parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1275         parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1276         parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT;
1277         parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE;
1278         parmas.dataReq.length = (int)size;
1279         parmas.dataReq.buffer = (unsigned char *)sendData;
1280         ret = UsbFillRequest(NULL, NULL, &parmas);
1281         if (ret) {
1282             HDF_LOGE("%s: error", __func__);
1283             return HDF_FAILURE;
1284         }
1285     }
1286     HDF_LOGE("%s: success", __func__);
1287     return HDF_SUCCESS;
1288 }
1289 
CheckHostSdkIfFillIsoRequest006(void)1290 static int32_t CheckHostSdkIfFillIsoRequest006(void)
1291 {
1292     int32_t ret;
1293     struct UsbRequestParams parmas;
1294     int32_t i;
1295     char sendData[] = {"abcde\0"};
1296     uint32_t size = strlen(sendData) + 1;
1297     if (g_acm->isoPipe == NULL) {
1298         return HDF_FAILURE;
1299     }
1300     for (i = 0; i < 1; i++) {
1301         parmas.interfaceId = g_acm->isoPipe->interfaceId;
1302         parmas.pipeAddress = g_acm->isoPipe->pipeAddress;
1303         parmas.pipeId = g_acm->isoPipe->pipeId;
1304         parmas.callback = AcmWriteIsoCallback;
1305         parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1306         parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1307         parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT;
1308         parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE;
1309         parmas.dataReq.length = (int)size;
1310         parmas.dataReq.buffer = (unsigned char *)sendData;
1311         ret = UsbFillRequest(g_acm->isoReq, NULL, NULL);
1312         if (ret) {
1313             HDF_LOGE("%s: error", __func__);
1314             return HDF_FAILURE;
1315         }
1316     }
1317     HDF_LOGE("%s: success", __func__);
1318     return HDF_SUCCESS;
1319 }
1320 
CheckHostSdkIfFreeRequest004(void)1321 static int32_t CheckHostSdkIfFreeRequest004(void)
1322 {
1323     int32_t ret;
1324     ret = UsbFreeRequest(g_acm->ctrlReq);
1325     if (ret) {
1326         HDF_LOGE("%s: error", __func__);
1327         return HDF_FAILURE;
1328     }
1329     g_acm->ctrlReq = NULL;
1330     HDF_LOGE("%s: success", __func__);
1331     return HDF_SUCCESS;
1332 }
1333 
CheckHostSdkIfAllocRequest009(void)1334 static int32_t CheckHostSdkIfAllocRequest009(void)
1335 {
1336     int32_t i;
1337     int32_t ret;
1338     g_acm->readSize = g_acm->dataInPipe->maxPacketSize;
1339     for (i = 0; i < ACM_NR; i++) {
1340         g_acm->readReq[i] = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->readSize);
1341         if (g_acm->readReq[i] == NULL) {
1342             HDF_LOGE("%s: error", __func__);
1343             return HDF_FAILURE;
1344         }
1345     }
1346 
1347     g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize;
1348     ret = AcmWriteBufAlloc(g_acm);
1349     if (ret) {
1350         HDF_LOGE("%s: error", __func__);
1351         return HDF_FAILURE;
1352     }
1353     for (int32_t i = 0; i < ACM_NW; i++) {
1354         g_acm->wb[i].request = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->writeSize);
1355         g_acm->wb[i].instance = g_acm;
1356         if (g_acm->wb[i].request == NULL) {
1357             HDF_LOGE("%s: error", __func__);
1358             return HDF_FAILURE;
1359         }
1360     }
1361     g_acm->intSize = g_acm->intPipe->maxPacketSize;
1362     g_acm->notifyReq = UsbAllocRequest(g_acm->int_devHandle, 0, g_acm->intSize);
1363     if (g_acm->notifyReq == NULL) {
1364         HDF_LOGE("%s: error", __func__);
1365         return HDF_FAILURE;
1366     }
1367     g_acm->ctrlSize = sizeof (struct UsbCdcLineCoding);
1368     g_acm->ctrlReq = UsbAllocRequest(g_acm->ctrl_devHandle, 0, g_acm->ctrlSize);
1369     if (g_acm->ctrlReq == NULL) {
1370         HDF_LOGE("%s: error", __func__);
1371         return HDF_FAILURE;
1372     }
1373     HDF_LOGE("%s: success", __func__);
1374     return HDF_SUCCESS;
1375 }
1376 
CheckHostSdkIfFillRequest001(void)1377 static int32_t CheckHostSdkIfFillRequest001(void)
1378 {
1379     int32_t ret;
1380     struct UsbRequestParams readParmas;
1381     int32_t i;
1382     for (i = 0; i < 1; i++) {
1383         readParmas.userData = (void *)g_acm;
1384         readParmas.pipeAddress = g_acm->dataInPipe->pipeAddress;
1385         readParmas.pipeId = g_acm->dataInPipe->pipeId;
1386         readParmas.interfaceId = g_acm->dataInPipe->interfaceId;
1387         readParmas.callback = AcmReadBulk;
1388         readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1389         readParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1390         readParmas.dataReq.numIsoPackets = 0;
1391         readParmas.dataReq.directon =
1392             (UsbRequestDirection)(((uint32_t)g_acm->dataInPipe->pipeDirection >> USB_DIR_OFFSET) & DIRECTION_MASK);
1393         readParmas.dataReq.length = (int)g_acm->readSize;
1394         ret = UsbFillRequest(g_acm->readReq[i], g_acm->data_devHandle, &readParmas);
1395         if (ret) {
1396             HDF_LOGE("%s: error", __func__);
1397             return HDF_FAILURE;
1398         }
1399     }
1400     HDF_LOGE("%s: success", __func__);
1401     return HDF_SUCCESS;
1402 }
1403 
CheckHostSdkIfFillRequest002(void)1404 static int32_t CheckHostSdkIfFillRequest002(void)
1405 {
1406     int32_t ret;
1407     struct UsbRequestParams parmas;
1408     int32_t i;
1409     char sendData[] = {"abcde\0"};
1410     uint32_t size = strlen(sendData) + 1;
1411     g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize;
1412     size = (size > g_acm->writeSize) ? g_acm->writeSize : size;
1413 
1414     for (i = 0; i < 1; i++) {
1415         g_acm->wb[i].len = (int)size;
1416         ret = memcpy_s(g_acm->wb[i].buf, g_acm->writeSize, sendData, size);
1417         if (ret) {
1418             HDF_LOGE("%s: memcpy_s failed", __func__);
1419             return HDF_FAILURE;
1420         }
1421         parmas.interfaceId = g_acm->dataOutPipe->interfaceId;
1422         parmas.pipeAddress = g_acm->dataOutPipe->pipeAddress;
1423         parmas.pipeId = g_acm->dataOutPipe->pipeId;
1424         parmas.callback = AcmWriteBulk;
1425         parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1426         parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1427         parmas.dataReq.numIsoPackets = 0;
1428         parmas.userData = (void *)&g_acm->wb[i];
1429         parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE;
1430         parmas.dataReq.length = g_acm->wb[i].len;
1431         parmas.dataReq.buffer = g_acm->wb[i].buf;
1432         ret = UsbFillRequest(g_acm->wb[i].request, g_acm->data_devHandle, &parmas);
1433         if (ret) {
1434             HDF_LOGE("%s: error", __func__);
1435             return HDF_FAILURE;
1436         }
1437     }
1438     HDF_LOGE("%s: success", __func__);
1439     return HDF_SUCCESS;
1440 }
1441 
CheckHostSdkIfFillRequest003(void)1442 static int32_t CheckHostSdkIfFillRequest003(void)
1443 {
1444     int32_t ret;
1445     struct UsbRequestParams intParmas;
1446     intParmas.userData = (void *)g_acm;
1447     intParmas.pipeAddress = g_acm->intPipe->pipeAddress;
1448     intParmas.pipeId = g_acm->intPipe->pipeId;
1449     intParmas.interfaceId = g_acm->intPipe->interfaceId;
1450     intParmas.callback = AcmCtrlIrq;
1451     intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1452     intParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1453     intParmas.dataReq.numIsoPackets = 0;
1454     intParmas.dataReq.directon = (UsbRequestDirection)(((uint32_t)g_acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET)
1455         & DIRECTION_MASK);
1456     intParmas.dataReq.length = (int)g_acm->intSize;
1457     intParmas.dataReq.buffer = NULL;
1458     ret = UsbFillRequest(g_acm->notifyReq, g_acm->int_devHandle, &intParmas);
1459     if (ret) {
1460         HDF_LOGE("%s: error", __func__);
1461         return HDF_FAILURE;
1462     }
1463     HDF_LOGE("%s: success", __func__);
1464     return HDF_SUCCESS;
1465 }
1466 
CheckHostSdkIfFillRequest004(void)1467 static int32_t CheckHostSdkIfFillRequest004(void)
1468 {
1469     int32_t ret;
1470     struct UsbRequestParams parmas;
1471     uint16_t index = 2;
1472     uint16_t value = 0;
1473     struct TestControlMsgData msgData;
1474     parmas.interfaceId = USB_CTRL_INTERFACE_ID;
1475     parmas.pipeAddress = 0;
1476     parmas.pipeId = 0;
1477     parmas.callback = AcmCtrlIrq;
1478     parmas.requestType = USB_REQUEST_PARAMS_CTRL_TYPE;
1479     parmas.timeout = USB_CTRL_SET_TIMEOUT;
1480     g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
1481     g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
1482     g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
1483     g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
1484     msgData.request = USB_DDK_CDC_REQ_SET_LINE_CODING;
1485     msgData.requestType = USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
1486     msgData.value = value;
1487     msgData.index = index;
1488     msgData.data = &g_acm->lineCoding;
1489     msgData.size = sizeof(struct UsbCdcLineCoding);
1490     parmas.ctrlReq = UsbControlMsg(msgData);
1491     parmas.userData = NULL;
1492     ret = UsbFillRequest(g_acm->ctrlReq, g_acm->ctrl_devHandle, &parmas);
1493     if (ret) {
1494         HDF_LOGE("%s: error", __func__);
1495         return HDF_FAILURE;
1496     }
1497     HDF_LOGE("%s: success", __func__);
1498     return HDF_SUCCESS;
1499 }
1500 
CheckHostSdkIfSubmitRequestSync001(void)1501 static int32_t CheckHostSdkIfSubmitRequestSync001(void)
1502 {
1503     int32_t ret;
1504     int32_t i;
1505     for (i = 0; i < 1; i++) {
1506         printf("------UsbSubmitRequestSync i = [%d]------\n", i);
1507         ret = UsbSubmitRequestSync(g_acm->readReq[i]);
1508         if (ret) {
1509             HDF_LOGE("%s: error", __func__);
1510             return HDF_FAILURE;
1511         }
1512     }
1513     HDF_LOGE("%s: success", __func__);
1514     return HDF_SUCCESS;
1515 }
1516 
CheckHostSdkIfSubmitRequestSync002(void)1517 static int32_t CheckHostSdkIfSubmitRequestSync002(void)
1518 {
1519     int32_t ret;
1520     int32_t i;
1521     for (i = 0; i < 1; i++) {
1522         printf("------UsbSubmitRequestSync i = [%d]------\n", i);
1523         ret = UsbSubmitRequestSync(g_acm->wb[i].request);
1524         if (ret) {
1525             HDF_LOGE("%s: error", __func__);
1526             return HDF_FAILURE;
1527         }
1528     }
1529     HDF_LOGE("%s: success", __func__);
1530     return HDF_SUCCESS;
1531 }
1532 
CheckHostSdkIfSubmitRequestSync003(void)1533 static int32_t CheckHostSdkIfSubmitRequestSync003(void)
1534 {
1535     int32_t ret;
1536 
1537     ret = UsbSubmitRequestSync(g_acm->ctrlReq);
1538     if (ret) {
1539         HDF_LOGE("%s: error", __func__);
1540         return HDF_FAILURE;
1541     }
1542     HDF_LOGE("%s: success", __func__);
1543     return HDF_SUCCESS;
1544 }
1545 
CheckHostSdkIfSubmitRequestSync004(void)1546 static int32_t CheckHostSdkIfSubmitRequestSync004(void)
1547 {
1548     int32_t ret;
1549     ret = UsbSubmitRequestSync(g_acm->notifyReq);
1550     if (ret) {
1551         HDF_LOGE("%s: error", __func__);
1552         return HDF_FAILURE;
1553     }
1554     HDF_LOGE("%s: success", __func__);
1555     return HDF_SUCCESS;
1556 }
1557 
CheckHostSdkIfFillRequest005(void)1558 static int32_t CheckHostSdkIfFillRequest005(void)
1559 {
1560     int32_t ret;
1561     struct UsbRequestParams readParmas;
1562     int32_t i;
1563     for (i = 0; i < ACM_NR; i++) {
1564         readParmas.userData = (void *)g_acm;
1565         readParmas.pipeAddress = g_acm->dataInPipe->pipeAddress;
1566         readParmas.pipeId = g_acm->dataInPipe->pipeId;
1567         readParmas.interfaceId = g_acm->dataInPipe->interfaceId;
1568         readParmas.callback = AcmReadBulk;
1569         readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1570         readParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1571         readParmas.dataReq.numIsoPackets = 0;
1572         readParmas.dataReq.directon =
1573             (UsbRequestDirection)(((uint32_t)g_acm->dataInPipe->pipeDirection >> USB_DIR_OFFSET) & DIRECTION_MASK);
1574         readParmas.dataReq.length = (int)g_acm->readSize;
1575         ret = UsbFillRequest(g_acm->readReq[i], g_acm->data_devHandle, &readParmas);
1576         if (ret) {
1577             HDF_LOGE("%s: error", __func__);
1578             return HDF_FAILURE;
1579         }
1580     }
1581     HDF_LOGE("%s: success", __func__);
1582     return HDF_SUCCESS;
1583 }
1584 
CheckHostSdkIfFillRequest006(void)1585 static int32_t CheckHostSdkIfFillRequest006(void)
1586 {
1587     int32_t ret;
1588     struct UsbRequestParams parmas;
1589     int32_t i;
1590     char sendData[] = {"abcde\0"};
1591     uint32_t size = strlen(sendData) + 1;
1592     g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize;
1593     size = (size > g_acm->writeSize) ? g_acm->writeSize : size;
1594     for (i = 0; i < ACM_NR; i++) {
1595         g_acm->wb[i].len = (int)size;
1596         ret = memcpy_s(g_acm->wb[i].buf, g_acm->writeSize, sendData, size);
1597         if (ret) {
1598             HDF_LOGE("%s: memcpy_s failed", __func__);
1599             return HDF_FAILURE;
1600         }
1601         parmas.interfaceId = g_acm->dataOutPipe->interfaceId;
1602         parmas.pipeAddress = g_acm->dataOutPipe->pipeAddress;
1603         parmas.pipeId = g_acm->dataOutPipe->pipeId;
1604         parmas.callback = AcmWriteBulk;
1605         parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1606         parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1607         parmas.dataReq.numIsoPackets = 0;
1608         parmas.userData = (void *)&g_acm->wb[i];
1609         parmas.dataReq.length = g_acm->wb[i].len;
1610         parmas.dataReq.buffer = g_acm->wb[i].buf;
1611         ret = UsbFillRequest(g_acm->wb[i].request, g_acm->data_devHandle, &parmas);
1612         if (ret) {
1613             HDF_LOGE("%s: error", __func__);
1614             return HDF_FAILURE;
1615         }
1616     }
1617     HDF_LOGE("%s: success", __func__);
1618     return HDF_SUCCESS;
1619 }
1620 
CheckHostSdkIfFillRequest007(void)1621 static int32_t CheckHostSdkIfFillRequest007(void)
1622 {
1623     int32_t ret;
1624     struct UsbRequestParams intParmas;
1625     intParmas.userData = (void *)g_acm;
1626     intParmas.pipeAddress = g_acm->intPipe->pipeAddress;
1627     intParmas.pipeId = g_acm->intPipe->pipeId;
1628     intParmas.interfaceId = g_acm->intPipe->interfaceId;
1629     intParmas.callback = AcmCtrlIrq;
1630     intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
1631     intParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1632     intParmas.dataReq.buffer = NULL;
1633     intParmas.dataReq.numIsoPackets = 0;
1634     intParmas.dataReq.directon = (UsbRequestDirection)(((uint32_t)g_acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET)
1635         & DIRECTION_MASK);
1636     intParmas.dataReq.length = (int)g_acm->intSize;
1637     ret = UsbFillRequest(g_acm->notifyReq, g_acm->int_devHandle, &intParmas);
1638     if (ret) {
1639         HDF_LOGE("%s: error", __func__);
1640         return HDF_FAILURE;
1641     }
1642     HDF_LOGE("%s: success", __func__);
1643     return HDF_SUCCESS;
1644 }
1645 
CheckHostSdkIfFillRequest008(void)1646 static int32_t CheckHostSdkIfFillRequest008(void)
1647 {
1648     int32_t ret;
1649     struct UsbRequestParams parmas;
1650     uint16_t index = 2;
1651     uint16_t value = 0;
1652     struct TestControlMsgData msgData;
1653 
1654     parmas.interfaceId = USB_CTRL_INTERFACE_ID;
1655     parmas.pipeAddress = 0;
1656     parmas.pipeId = 0;
1657     parmas.callback = AcmCtrlIrq;
1658     parmas.requestType = USB_REQUEST_PARAMS_CTRL_TYPE;
1659     parmas.timeout = USB_CTRL_SET_TIMEOUT;
1660     g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
1661     g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
1662     g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
1663     g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
1664     msgData.request = USB_DDK_CDC_REQ_SET_LINE_CODING;
1665     msgData.requestType = USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
1666     msgData.value = value;
1667     msgData.index = index;
1668     msgData.data = &g_acm->lineCoding;
1669     msgData.size = sizeof(struct UsbCdcLineCoding);
1670     parmas.ctrlReq = UsbControlMsg(msgData);
1671     parmas.userData = NULL;
1672     ret = UsbFillRequest(g_acm->ctrlReq, g_acm->ctrl_devHandle, &parmas);
1673     if (ret) {
1674         HDF_LOGE("%s: error", __func__);
1675         return HDF_FAILURE;
1676     }
1677     HDF_LOGE("%s: success", __func__);
1678     return HDF_SUCCESS;
1679 }
1680 
CheckHostSdkIfSubmitRequestAsync001(void)1681 static int32_t CheckHostSdkIfSubmitRequestAsync001(void)
1682 {
1683     int32_t ret;
1684     int32_t i;
1685     for (i = 0; i < 1; i++) {
1686         ret = UsbSubmitRequestAsync(g_acm->readReq[i]);
1687         if (ret) {
1688             HDF_LOGE("%s: error", __func__);
1689             return HDF_FAILURE;
1690         }
1691     }
1692     HDF_LOGE("%s: success", __func__);
1693     return HDF_SUCCESS;
1694 }
1695 
CheckHostSdkIfCancelRequest001(void)1696 static int32_t CheckHostSdkIfCancelRequest001(void)
1697 {
1698     int32_t ret;
1699     int32_t i = 0;
1700     ret = UsbCancelRequest(g_acm->readReq[i]);
1701     if (ret) {
1702         HDF_LOGE("%s: error", __func__);
1703         return HDF_FAILURE;
1704     }
1705     HDF_LOGE("%s: success", __func__);
1706     return HDF_SUCCESS;
1707 }
1708 
CheckHostSdkIfSubmitRequestAsync002(void)1709 static int32_t CheckHostSdkIfSubmitRequestAsync002(void)
1710 {
1711     int32_t ret;
1712     int32_t i;
1713     for (i = 0; i < 1; i++) {
1714         ret = UsbSubmitRequestAsync(g_acm->wb[i].request);
1715         if (ret) {
1716             HDF_LOGE("%s: error", __func__);
1717             return HDF_FAILURE;
1718         }
1719     }
1720     HDF_LOGE("%s: success", __func__);
1721     return HDF_SUCCESS;
1722 }
1723 
CheckHostSdkIfCancelRequest002(void)1724 static int32_t CheckHostSdkIfCancelRequest002(void)
1725 {
1726     int32_t ret;
1727     int32_t i = 0;
1728     ret = UsbCancelRequest(g_acm->wb[i].request);
1729     if (ret) {
1730         HDF_LOGE("%s: error", __func__);
1731         return HDF_FAILURE;
1732     }
1733     HDF_LOGE("%s: success", __func__);
1734     return HDF_SUCCESS;
1735 }
1736 
CheckHostSdkIfSubmitRequestAsync003(void)1737 static int32_t CheckHostSdkIfSubmitRequestAsync003(void)
1738 {
1739     int32_t ret;
1740     ret = UsbSubmitRequestAsync(g_acm->notifyReq);
1741     if (ret) {
1742         HDF_LOGE("%s: error", __func__);
1743         return HDF_FAILURE;
1744     }
1745     HDF_LOGE("%s: success", __func__);
1746     return HDF_SUCCESS;
1747 }
1748 
CheckHostSdkIfCancelRequest003(void)1749 static int32_t CheckHostSdkIfCancelRequest003(void)
1750 {
1751     int32_t ret;
1752     ret = UsbCancelRequest(g_acm->notifyReq);
1753     if (ret) {
1754         HDF_LOGE("%s: error", __func__);
1755         return HDF_FAILURE;
1756     }
1757     HDF_LOGE("%s: success", __func__);
1758     return HDF_SUCCESS;
1759 }
1760 
CheckHostSdkIfSubmitRequestAsync004(void)1761 static int32_t CheckHostSdkIfSubmitRequestAsync004(void)
1762 {
1763     int32_t ret;
1764     ret = UsbSubmitRequestAsync(g_acm->ctrlReq);
1765     if (ret) {
1766         HDF_LOGE("%s: error", __func__);
1767         return HDF_FAILURE;
1768     }
1769     HDF_LOGE("%s: success", __func__);
1770     return HDF_SUCCESS;
1771 }
1772 
CheckHostSdkIfCancelRequest004(void)1773 static int32_t CheckHostSdkIfCancelRequest004(void)
1774 {
1775     int32_t ret;
1776     ret = UsbCancelRequest(g_acm->ctrlReq);
1777     if (ret) {
1778         HDF_LOGE("%s: error", __func__);
1779         return HDF_FAILURE;
1780     }
1781     HDF_LOGE("%s: success", __func__);
1782     return HDF_SUCCESS;
1783 }
1784 
CheckHostSdkIfClearInterfaceHalt002(void)1785 static int32_t CheckHostSdkIfClearInterfaceHalt002(void)
1786 {
1787     int32_t ret;
1788     ret = UsbClearInterfaceHalt(g_acm->data_devHandle, g_acm->dataOutPipe->pipeAddress);
1789     if (ret < 0) {
1790         HDF_LOGE("%s: error", __func__);
1791         return HDF_FAILURE;
1792     }
1793     HDF_LOGE("%s: success", __func__);
1794     return HDF_SUCCESS;
1795 }
1796 
CheckHostSdkIfClearInterfaceHalt003(void)1797 static int32_t CheckHostSdkIfClearInterfaceHalt003(void)
1798 {
1799     int32_t ret;
1800     ret = UsbClearInterfaceHalt(g_acm->int_devHandle, g_acm->intPipe->pipeAddress);
1801     if (ret) {
1802         HDF_LOGE("%s: error", __func__);
1803         return HDF_SUCCESS;
1804     }
1805     HDF_LOGE("%s: success", __func__);
1806     return HDF_FAILURE;
1807 }
1808 
CheckHostSdkIfClearInterfaceHalt004(void)1809 static int32_t CheckHostSdkIfClearInterfaceHalt004(void)
1810 {
1811     int32_t ret;
1812     ret = UsbClearInterfaceHalt(g_acm->ctrl_devHandle, g_acm->ctrPipe->pipeAddress);
1813     if (ret) {
1814         HDF_LOGE("%s: error", __func__);
1815         return HDF_SUCCESS;
1816     }
1817     HDF_LOGE("%s: success", __func__);
1818     return HDF_FAILURE;
1819 }
1820 
CheckHostSdkIfRemoveInterface001(void)1821 static int32_t CheckHostSdkIfRemoveInterface001(void)
1822 {
1823     int32_t ret;
1824     UsbInterfaceStatus status = USB_INTERFACE_STATUS_REMOVE;
1825     ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr,
1826         g_acm->dataIface->info.interfaceIndex, status);
1827     if (ret) {
1828         HDF_LOGE("%s: error", __func__);
1829         return HDF_FAILURE;
1830     }
1831     HDF_LOGE("%s: success", __func__);
1832     return HDF_SUCCESS;
1833 }
1834 
CheckHostSdkIfAddInterface001(void)1835 static int32_t CheckHostSdkIfAddInterface001(void)
1836 {
1837     int32_t ret;
1838     UsbInterfaceStatus status = USB_INTERFACE_STATUS_ADD;
1839     OsalSleep(1);
1840     ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr,
1841         g_acm->dataIface->info.interfaceIndex, status);
1842     if (ret) {
1843         HDF_LOGE("%s: error", __func__);
1844         return HDF_FAILURE;
1845     }
1846     HDF_LOGE("%s: success", __func__);
1847     return HDF_SUCCESS;
1848 }
1849 
CheckHostSdkIfRemoveInterface002(void)1850 static int32_t CheckHostSdkIfRemoveInterface002(void)
1851 {
1852     int32_t ret;
1853     UsbInterfaceStatus status = USB_INTERFACE_STATUS_REMOVE;
1854     OsalSleep(1);
1855     ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr,
1856         g_acm->intIface->info.interfaceIndex, status);
1857     if (ret) {
1858         HDF_LOGE("%s: error", __func__);
1859         return HDF_FAILURE;
1860     }
1861     HDF_LOGE("%s: success", __func__);
1862     return HDF_SUCCESS;
1863 }
1864 
CheckHostSdkIfAddInterface002(void)1865 static int32_t CheckHostSdkIfAddInterface002(void)
1866 {
1867     int32_t ret;
1868     UsbInterfaceStatus status = USB_INTERFACE_STATUS_ADD;
1869 
1870     OsalSleep(1);
1871 
1872     ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr,
1873         g_acm->intIface->info.interfaceIndex, status);
1874     if (ret) {
1875         HDF_LOGE("%s: error", __func__);
1876         return HDF_FAILURE;
1877     }
1878     HDF_LOGE("%s: success", __func__);
1879     return HDF_SUCCESS;
1880 }
1881 
CheckHostSdkIfRemoveInterface003(void)1882 static int32_t CheckHostSdkIfRemoveInterface003(void)
1883 {
1884     int32_t ret;
1885     UsbInterfaceStatus status = USB_INTERFACE_STATUS_REMOVE;
1886 
1887     ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr,
1888         g_acm->ctrIface->info.interfaceIndex, status);
1889     if (ret) {
1890         HDF_LOGE("%s: error", __func__);
1891         return HDF_FAILURE;
1892     }
1893     HDF_LOGE("%s: success", __func__);
1894     return HDF_SUCCESS;
1895 }
1896 
CheckHostSdkIfAddInterface003(void)1897 static int32_t CheckHostSdkIfAddInterface003(void)
1898 {
1899     int32_t ret;
1900     UsbInterfaceStatus status = USB_INTERFACE_STATUS_ADD;
1901 
1902     ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr,
1903         g_acm->ctrIface->info.interfaceIndex, status);
1904     if (ret) {
1905         HDF_LOGE("%s: error", __func__);
1906         return HDF_FAILURE;
1907     }
1908     HDF_LOGE("%s: success", __func__);
1909     return HDF_SUCCESS;
1910 }
1911 
CheckHostSdkIfCloseInterface006(void)1912 static int32_t CheckHostSdkIfCloseInterface006(void)
1913 {
1914     int32_t ret;
1915     ret = UsbCloseInterface(g_ecmIntDevHandle);
1916     if (ret) {
1917         HDF_LOGE("%s: error", __func__);
1918         return HDF_FAILURE;
1919     }
1920     ret = UsbCloseInterface(g_ecmDataDevHandle);
1921     if (ret) {
1922         HDF_LOGE("%s: error", __func__);
1923         return HDF_FAILURE;
1924     }
1925     ret = UsbCloseInterface(g_acm->ctrl_devHandle);
1926     if (ret) {
1927         HDF_LOGE("%s: error", __func__);
1928         return HDF_FAILURE;
1929     }
1930     ret = UsbCloseInterface(g_acm->int_devHandle);
1931     if (ret) {
1932         HDF_LOGE("%s: error", __func__);
1933         return HDF_FAILURE;
1934     }
1935     ret = UsbCloseInterface(g_acm->data_devHandle);
1936     if (ret) {
1937         HDF_LOGE("%s: error", __func__);
1938         return HDF_FAILURE;
1939     }
1940     HDF_LOGE("%s: success", __func__);
1941     return HDF_SUCCESS;
1942 }
1943 
1944 struct UsbTestFunc g_usbTestFunc[] = {
1945     { USB_HOSTSDK_INIT_001_TEST, CheckHostSdkIfInit001},
1946     { Usb_HOSTSDK_EXIT_001_TEST, CheckHostSdkIfExit001},
1947     { USB_HOSTSDK_INIT_002_TEST, CheckHostSdkIfInit002},
1948     { USB_HOSTSDK_EXIT_002_TEST, CheckHostSdkIfExit002},
1949     { USB_HOSTSDK_INIT_003_TEST, CheckHostSdkIfInit003},
1950     { USB_HOSTSDK_INIT_004_TEST, CheckHostSdkIfInit004},
1951     { USB_HOSTSDK_INIT_005_TEST, CheckHostSdkIfInit005},
1952     { USB_HOSTSDK_CLAIM_INTERFACE_001_TEST, CheckHostSdkIfClaimInterface001},
1953     { USB_HOSTSDK_RELEASE_INTERFACE_001_TEST, CheckHostSdkIfReleaseInterface001},
1954     { USB_HOSTSDK_CLAIM_INTERFACE_002_TEST, CheckHostSdkIfClaimInterface002},
1955     { USB_HOSTSDK_RELEASE_INTERFACE_002_TEST, CheckHostSdkIfReleaseInterface002},
1956     { USB_HOSTSDK_CLAIM_INTERFACE_003_TEST, CheckHostSdkIfClaimInterface003},
1957     { USB_HOSTSDK_RELEASE_INTERFACE_003_TEST, CheckHostSdkIfReleaseInterface003},
1958     { USB_HOSTSDK_CLAIM_INTERFACE_004_TEST, CheckHostSdkIfClaimInterface004},
1959     { USB_HOSTSDK_CLAIM_INTERFACE_005_TEST, CheckHostSdkIfClaimInterface005},
1960     { USB_HOSTSDK_CLAIM_INTERFACE_006_TEST, CheckHostSdkIfClaimInterface006},
1961     { USB_HOSTSDK_OPEN_INTERFACE_001_TEST, CheckHostSdkIfOpenInterface001},
1962     { USB_HOSTSDK_CLOSE_INTERFACE_001_TEST, CheckHostSdkIfCloseInterface001},
1963     { USB_HOSTSDK_OPEN_INTERFACE_002_TEST, CheckHostSdkIfOpenInterface002},
1964     { USB_HOSTSDK_CLOSE_INTERFACE_002_TEST, CheckHostSdkIfCloseInterface002},
1965     { USB_HOSTSDK_OPEN_INTERFACE_003_TEST, CheckHostSdkIfOpenInterface003},
1966     { USB_HOSTSDK_CLOSE_INTERFACE_003_TEST, CheckHostSdkIfCloseInterface003},
1967     { USB_HOSTSDK_OPEN_INTERFACE_004_TEST, CheckHostSdkIfOpenInterface004},
1968     { USB_HOSTSDK_OPEN_INTERFACE_005_TEST, CheckHostSdkIfOpenInterface005},
1969     { USB_HOSTSDK_CLOSE_INTERFACE_005_TEST, CheckHostSdkIfCloseInterface005},
1970     { USB_HOSTSDK_OPEN_INTERFACE_006_TEST, CheckHostSdkIfOpenInterface006},
1971     { USB_HOSTSDK_SELECT_INTERFACE_001_TEST, CheckHostSdkIfSelectInterfaceSetting001},
1972     { USB_HOSTSDK_SELECT_INTERFACE_002_TEST, CheckHostSdkIfSelectInterfaceSetting002},
1973     { USB_HOSTSDK_SELECT_INTERFACE_003_TEST, CheckHostSdkIfSelectInterfaceSetting003},
1974     { USB_HOSTSDK_SELECT_INTERFACE_004_TEST, CheckHostSdkIfSelectInterfaceSetting004},
1975     { USB_HOSTSDK_SELECT_INTERFACE_005_TEST, CheckHostSdkIfSelectInterfaceSetting005},
1976     { USB_HOSTSDK_SELECT_INTERFACE_006_TEST, CheckHostSdkIfSelectInterfaceSetting006},
1977     { USB_HOSTSDK_CLAIM_INTERFACE_007_TEST, CheckHostSdkIfClaimInterface007},
1978     { USB_HOSTSDK_CLAIM_INTERFACE_008_TEST, CheckHostSdkIfClaimInterface008},
1979     { USB_HOSTSDK_GET_PIPE_001_TEST, CheckHostSdkIfGetPipe001},
1980     { USB_HOSTSDK_GET_PIPE_002_TEST, CheckHostSdkIfGetPipe002},
1981     { USB_HOSTSDK_GET_PIPE_003_TEST, CheckHostSdkIfGetPipe003},
1982     { USB_HOSTSDK_GET_PIPE_004_TEST, CheckHostSdkIfGetPipe004},
1983     { USB_HOSTSDK_GET_PIPE_005_TEST, CheckHostSdkIfGetPipe005},
1984     { USB_HOSTSDK_GET_PIPE_006_TEST, CheckHostSdkIfGetPipe006},
1985     { USB_HOSTSDK_GET_PIPE_007_TEST, CheckHostSdkIfGetPipe007},
1986     { USB_HOSTSDK_GET_PIPE_008_TEST, CheckHostSdkIfGetPipe008},
1987     { USB_HOSTSDK_ALLOC_REQUEST_001_TEST, CheckHostSdkIfAllocRequest001},
1988     { USB_HOSTSDK_ALLOC_REQUEST_002_TEST, CheckHostSdkIfAllocRequest002},
1989     { USB_HOSTSDK_FREE_REQUEST_001_TEST, CheckHostSdkIfFreeRequest001},
1990     { USB_HOSTSDK_ALLOC_REQUEST_003_TEST, CheckHostSdkIfAllocRequest003},
1991     { USB_HOSTSDK_ALLOC_REQUEST_004_TEST, CheckHostSdkIfAllocRequest004},
1992     { USB_HOSTSDK_FREE_REQUEST_002_TEST, CheckHostSdkIfFreeRequest002},
1993     { USB_HOSTSDK_ALLOC_REQUEST_005_TEST, CheckHostSdkIfAllocRequest005},
1994     { USB_HOSTSDK_ALLOC_REQUEST_006_TEST, CheckHostSdkIfAllocRequest006},
1995     { USB_HOSTSDK_FREE_REQUEST_003_TEST, CheckHostSdkIfFreeRequest003},
1996     { USB_HOSTSDK_ALLOC_REQUEST_007_TEST, CheckHostSdkIfAllocRequest007},
1997     { USB_HOSTSDK_ALLOC_REQUEST_008_TEST, CheckHostSdkIfAllocRequest008},
1998     { USB_HOSTSDK_ALLOC_REQUEST_010_TEST, CheckHostSdkIfAllocRequest010},
1999     { USB_HOSTSDK_ALLOC_REQUEST_011_TEST, CheckHostSdkIfAllocRequest011},
2000     { USB_HOSTSDK_FREE_REQUEST_006_TEST, CheckHostSdkIfFreeRequest006},
2001     { USB_HOSTSDK_FILL_ISO_REQUEST_001_TEST, CheckHostSdkIfFillIsoRequest001},
2002     { USB_HOSTSDK_FILL_ISO_REQUEST_002_TEST, CheckHostSdkIfFillIsoRequest002},
2003     { USB_HOSTSDK_FILL_ISO_REQUEST_003_TEST, CheckHostSdkIfFillIsoRequest003},
2004     { USB_HOSTSDK_FILL_ISO_REQUEST_004_TEST, CheckHostSdkIfFillIsoRequest004},
2005     { USB_HOSTSDK_FILL_ISO_REQUEST_005_TEST, CheckHostSdkIfFillIsoRequest005},
2006     { USB_HOSTSDK_FILL_ISO_REQUEST_006_TEST, CheckHostSdkIfFillIsoRequest006},
2007     { USB_HOSTSDK_FREE_REQUEST_004_TEST, CheckHostSdkIfFreeRequest004},
2008     { USB_HOSTSDK_ALLOC_REQUEST_009_TEST, CheckHostSdkIfAllocRequest009},
2009     { USB_HOSTSDK_FILL_REQUEST_001_TEST, CheckHostSdkIfFillRequest001},
2010     { USB_HOSTSDK_FILL_REQUEST_002_TEST, CheckHostSdkIfFillRequest002},
2011     { USB_HOSTSDK_FILL_REQUEST_003_TEST, CheckHostSdkIfFillRequest003},
2012     { USB_HOSTSDK_FILL_REQUEST_004_TEST, CheckHostSdkIfFillRequest004},
2013     { USB_HOSTSDK_SUBMIT_REQUEST_SYNC_001_TEST, CheckHostSdkIfSubmitRequestSync001},
2014     { USB_HOSTSDK_SUBMIT_REQUEST_SYNC_002_TEST, CheckHostSdkIfSubmitRequestSync002},
2015     { USB_HOSTSDK_SUBMIT_REQUEST_SYNC_003_TEST, CheckHostSdkIfSubmitRequestSync003},
2016     { USB_HOSTSDK_SUBMIT_REQUEST_SYNC_004_TEST, CheckHostSdkIfSubmitRequestSync004},
2017     { USB_HOSTSDK_FILL_REQUEST_005_TEST, CheckHostSdkIfFillRequest005},
2018     { USB_HOSTSDK_FILL_REQUEST_006_TEST, CheckHostSdkIfFillRequest006},
2019     { USB_HOSTSDK_FILL_REQUEST_007_TEST, CheckHostSdkIfFillRequest007},
2020     { USB_HOSTSDK_FILL_REQUEST_008_TEST, CheckHostSdkIfFillRequest008},
2021     { USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_001_TEST, CheckHostSdkIfSubmitRequestAsync001},
2022     { USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_001_TEST, CheckHostSdkIfCancelRequest001},
2023     { USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_002_TEST, CheckHostSdkIfSubmitRequestAsync002},
2024     { USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_002_TEST, CheckHostSdkIfCancelRequest002},
2025     { USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_003_TEST, CheckHostSdkIfSubmitRequestAsync003},
2026     { USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_003_TEST, CheckHostSdkIfCancelRequest003},
2027     { USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_004_TEST, CheckHostSdkIfSubmitRequestAsync004},
2028     { USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_004_TEST, CheckHostSdkIfCancelRequest004},
2029     { USB_HOSTSDK_CLEAR_INTERFACE_HALT_002_TEST, CheckHostSdkIfClearInterfaceHalt002},
2030     { USB_HOSTSDK_CLEAR_INTERFACE_HALT_003_TEST, CheckHostSdkIfClearInterfaceHalt003},
2031     { USB_HOSTSDK_CLEAR_INTERFACE_HALT_004_TEST, CheckHostSdkIfClearInterfaceHalt004},
2032     { USB_HOSTSDK_REMOVE_INTERFACE_001_TEST, CheckHostSdkIfRemoveInterface001},
2033     { USB_HOSTSDK_ADD_INTERFACE_001_TEST, CheckHostSdkIfAddInterface001},
2034     { USB_HOSTSDK_REMOVE_INTERFACE_002_TEST, CheckHostSdkIfRemoveInterface002},
2035     { USB_HOSTSDK_ADD_INTERFACE_002_TEST, CheckHostSdkIfAddInterface002},
2036     { USB_HOSTSDK_REMOVE_INTERFACE_003_TEST, CheckHostSdkIfRemoveInterface003},
2037     { USB_HOSTSDK_ADD_INTERFACE_003_TEST, CheckHostSdkIfAddInterface003},
2038     { USB_HOSTSDK_CLOSE_INTERFACE_006_TEST, CheckHostSdkIfCloseInterface006},
2039 };
2040 
UsbTestEntry(int32_t cmd)2041 int32_t UsbTestEntry(int32_t cmd)
2042 {
2043     int32_t i;
2044     int32_t ret = HDF_ERR_NOT_SUPPORT;
2045 
2046     if (g_initFlag == false) {
2047 #ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY
2048         struct UsbGetDevicePara paraData;
2049         struct usb_device *usbPnpDevice = NULL;
2050         paraData.type = USB_PNP_DEVICE_VENDOR_PRODUCT_TYPE;
2051         paraData.vendorId = USB_DEVICE_VENDOR_ID;
2052         paraData.productId = USB_DEVICE_PRODUCT_ID;
2053         usbPnpDevice = UsbPnpNotifyGetUsbDevice(paraData);
2054         if (usbPnpDevice == NULL) {
2055             HDF_LOGE("%s:%d UsbPnpNotifyGetUsbDevice is NULL!", __func__, __LINE__);
2056             return HDF_ERR_INVALID_PARAM;
2057         }
2058         g_acm->busNum = usbPnpDevice->address;
2059         g_acm->devAddr = usbPnpDevice->port_no;
2060         HDF_LOGE("%s: busNum %d++devAddr %d", __func__, g_acm->busNum, g_acm->devAddr);
2061         g_initFlag = true;
2062 #else
2063         HDF_LOGE("%s:%d pnp notify module is not support!", __func__, __LINE__);
2064         return HDF_ERR_NOT_SUPPORT;
2065 #endif
2066     }
2067     for (i = 0; i < sizeof(g_usbTestFunc) / sizeof(g_usbTestFunc[0]); i++) {
2068         if (cmd == g_usbTestFunc[i].type && g_usbTestFunc[i].Func != NULL) {
2069             ret = g_usbTestFunc[i].Func();
2070             HDF_LOGE("%s: cmd %d ret %d", __func__, cmd, ret);
2071             break;
2072         }
2073     }
2074     return ret;
2075 }
2076