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_raw_test.h"
10 #include "data_fifo.h"
11 #include "device_resource_if.h"
12 #include "hdf_base.h"
13 #include "hdf_device_desc.h"
14 #include "hdf_dlist.h"
15 #include "hdf_log.h"
16 #include "osal_mem.h"
17 #include "osal_time.h"
18 #include "usb_ddk_interface.h"
19 #ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY
20 #include "usb_pnp_notify.h"
21 #endif
22
23 bool g_writeBufFlag = 0;
24 struct UsbSession *g_session = NULL;
25 struct AcmRawDevice g_deviceService;
26 struct AcmRawDevice *g_acm = &g_deviceService;
27 UsbRawHandle *g_devHandle = NULL;
28 UsbRawDevice *g_dev = NULL;
29 int32_t g_activeConfig;
30 bool g_initFlag;
31 bool g_stopIoThreadFlag = false;
32
UsbGetIoAcm(void)33 struct AcmRawDevice *UsbGetIoAcm(void)
34 {
35 return g_acm;
36 }
37
UsbIoThread(void * data)38 int32_t UsbIoThread(void *data)
39 {
40 int32_t ret;
41 struct AcmRawDevice *acm = (struct AcmRawDevice *)data;
42
43 while (true) {
44 printf("%s:%d\n", __func__, __LINE__);
45 if (acm == NULL) {
46 printf("%s:%d acm is NULL\n", __func__, __LINE__);
47 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
48 continue;
49 }
50
51 if (acm->devHandle == NULL) {
52 printf("%s:%d acm->devHandle is NULL!\n", __func__, __LINE__);
53 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
54 continue;
55 }
56
57 printf("%s:%d\n", __func__, __LINE__);
58 ret = UsbRawHandleRequests(acm->devHandle);
59 printf("%s:%d, ret=%d\n", __func__, __LINE__, ret);
60 if (ret < 0) {
61 printf("%s:%d UsbRawHandleRequests faile, ret=%d \n", __func__, __LINE__, ret);
62 if (ret == HDF_DEV_ERR_NO_DEVICE) {
63 printf("%s:%d, ret=%d\n", __func__, __LINE__, ret);
64 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
65 }
66 }
67
68 if (g_stopIoThreadFlag == true) {
69 printf("%s:%d\n", __func__, __LINE__);
70 break;
71 }
72 }
73
74 printf("%s:%d exit\n", __func__, __LINE__);
75
76 return HDF_SUCCESS;
77 }
78
79
UsbStartIo(void)80 int32_t UsbStartIo(void)
81 {
82 struct OsalThreadParam threadCfg;
83 int32_t ret;
84
85 printf("%s start\n", __func__);
86 g_stopIoThreadFlag = false;
87
88 /* creat Io thread */
89 (void)memset_s(&threadCfg, sizeof(threadCfg), 0, sizeof(threadCfg));
90 threadCfg.name = (char *)("usb io thread");
91 threadCfg.priority = OSAL_THREAD_PRI_LOW;
92 threadCfg.stackSize = USB_IO_THREAD_STACK_SIZE;
93
94 ret = OsalThreadCreate(&g_acm->ioThread, \
95 (OsalThreadEntry)UsbIoThread, (void *)g_acm);
96 if (ret != HDF_SUCCESS) {
97 printf("%s:%d OsalThreadCreate faile, ret=%d \n", __func__, __LINE__, ret);
98 return ret;
99 }
100
101 ret = OsalThreadStart(&g_acm->ioThread, &threadCfg);
102 if (ret != HDF_SUCCESS) {
103 printf("%s:%d OsalThreadStart faile, ret=%d \n", __func__, __LINE__, ret);
104 return ret;
105 }
106
107 return HDF_SUCCESS;
108 }
109
UsbStopIo(void)110 int32_t UsbStopIo(void)
111 {
112 int32_t ret;
113 g_stopIoThreadFlag = true;
114 HDF_LOGD("%s:%d", __func__, __LINE__);
115 ret = OsalThreadDestroy(&g_acm->ioThread);
116 if (ret != HDF_SUCCESS) {
117 HDF_LOGE("%s:%d OsalThreadDestroy faile, ret=%d ", __func__, __LINE__, ret);
118 return ret;
119 }
120 return HDF_SUCCESS;
121 }
122
AcmWriteBulkCallback(const void * requestArg)123 void AcmWriteBulkCallback(const void *requestArg)
124 {
125 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
126
127 printf("%s:%d entry!", __func__, __LINE__);
128
129 if (req == NULL) {
130 printf("%s:%d req is NULL!", __func__, __LINE__);
131 return;
132 }
133 struct RawWb *wb = (struct RawWb *)req->userData;
134 if (wb == NULL) {
135 printf("%s:%d userData(wb) is NULL!", __func__, __LINE__);
136 return;
137 }
138
139 if (req->status != USB_REQUEST_COMPLETED) {
140 printf("%s: write req failed, status=%d", __func__, req->status);
141 }
142
143 wb->use = 0;
144 }
145
AcmWriteIsoCallback(const void * requestArg)146 void AcmWriteIsoCallback(const void *requestArg)
147 {
148 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
149 printf("%s:%d status:%d\n", __func__, __LINE__, req->status);
150 }
151
AcmReadBulkCallback(const void * requestArg)152 void AcmReadBulkCallback(const void *requestArg)
153 {
154 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
155
156 printf("%s:%d entry!", __func__, __LINE__);
157
158 if (req == NULL) {
159 printf("%s:%d req is NULL!", __func__, __LINE__);
160 return;
161 }
162 struct AcmRawDevice *acm = (struct AcmRawDevice *)req->userData;
163 if (acm == NULL) {
164 printf("%s:%d userData(acm) is NULL!", __func__, __LINE__);
165 return;
166 }
167 size_t size = (size_t)req->actualLength;
168
169 switch (req->status) {
170 case USB_REQUEST_COMPLETED:
171 HDF_LOGD("Bulk status: %d+size:%u\n", req->status, size);
172 if (size) {
173 uint8_t *data = req->buffer;
174 printf("rcv:%s\n", (char *)data);
175 }
176 break;
177 case USB_REQUEST_CANCELLED:
178 return;
179 default:
180 printf("%s: the request is failed\n", __func__);
181 break;
182 }
183
184 if (UsbRawSubmitRequest(req)) {
185 printf("%s - UsbRawSubmitRequest failed", __func__);
186 }
187 }
AcmNotifyReqCallback(const void * requestArg)188 void AcmNotifyReqCallback(const void *requestArg)
189 {
190 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
191
192 printf("%s:%d entry!", __func__, __LINE__);
193
194 if (req == NULL) {
195 printf("%s:%d req is NULL!", __func__, __LINE__);
196 return;
197 }
198 struct AcmRawDevice *acm = (struct AcmRawDevice *)req->userData;
199 if (acm == NULL) {
200 printf("%s:%d userData(acm) is NULL!", __func__, __LINE__);
201 return;
202 }
203 struct UsbCdcNotification *dr = (struct UsbCdcNotification *)req->buffer;
204 if (dr == NULL) {
205 printf("%s:%d req->buffer(dr) is NULL!", __func__, __LINE__);
206 return;
207 }
208 unsigned int currentSize = req->actualLength;
209
210 printf("Irqstatus:%d,actualLength:%u\n", req->status, currentSize);
211 }
212
AcmWriteBufAllocHandle(const struct AcmRawDevice * acm)213 static int32_t AcmWriteBufAllocHandle(const struct AcmRawDevice *acm)
214 {
215 int32_t i;
216 struct RawWb *wb;
217 for (wb = (struct RawWb *)&acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
218 wb->buf = OsalMemCalloc(acm->dataOutEp.maxPacketSize);
219 if (!wb->buf) {
220 while (i > 0) {
221 --i;
222 --wb;
223 OsalMemFree(wb->buf);
224 wb->buf = NULL;
225 }
226 return -HDF_ERR_MALLOC_FAIL;
227 }
228 g_writeBufFlag = true;
229 }
230
231 return HDF_SUCCESS;
232 }
233
AcmWriteBufAlloc(struct AcmRawDevice * acm)234 int32_t AcmWriteBufAlloc(struct AcmRawDevice *acm)
235 {
236 int32_t ret = HDF_SUCCESS;
237
238 if (!g_writeBufFlag) {
239 ret = AcmWriteBufAllocHandle(acm);
240 }
241
242 return ret;
243 }
244
AcmWriteBufFree(struct AcmRawDevice * acm)245 void AcmWriteBufFree(struct AcmRawDevice *acm)
246 {
247 int32_t i;
248 struct RawWb *wb;
249 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
250 if (wb->buf) {
251 OsalMemFree(wb->buf);
252 wb->buf = NULL;
253 }
254 }
255 g_writeBufFlag = false;
256 return;
257 }
258
AcmCtrlReqCallback(const void * requestArg)259 void AcmCtrlReqCallback(const void *requestArg)
260 {
261 printf("%s:%d entry!", __func__, __LINE__);
262 }
263
AcmParaseInterfaceClass(struct AcmRawDevice * const acm,const struct UsbRawInterface * interface,uint8_t number)264 static void AcmParaseInterfaceClass(
265 struct AcmRawDevice * const acm, const struct UsbRawInterface *interface, uint8_t number)
266 {
267 uint8_t ifaceClass;
268 uint8_t numEndpoints;
269
270 ifaceClass = interface->altsetting->interfaceDescriptor.bInterfaceClass;
271 numEndpoints = interface->altsetting->interfaceDescriptor.bNumEndpoints;
272
273 switch (ifaceClass) {
274 case USB_DDK_CLASS_COMM:
275 acm->ctrlIface = number;
276 /* get the first endpoint by default */
277 acm->notifyEp.addr = interface->altsetting->endPoint[0].endpointDescriptor.bEndpointAddress;
278 acm->notifyEp.interval = interface->altsetting->endPoint[0].endpointDescriptor.bInterval;
279 acm->notifyEp.maxPacketSize = interface->altsetting->endPoint[0].endpointDescriptor.wMaxPacketSize;
280 break;
281 case USB_DDK_CLASS_CDC_DATA:
282 acm->dataIface = number;
283 for (uint8_t j = 0; j < numEndpoints; j++) {
284 const struct UsbRawEndpointDescriptor *endPoint = &interface->altsetting->endPoint[j];
285
286 /* get bulk in endpoint */
287 if ((endPoint->endpointDescriptor.bEndpointAddress
288 & USB_DDK_ENDPOINT_DIR_MASK) == USB_DDK_DIR_IN) {
289 acm->dataInEp.addr = endPoint->endpointDescriptor.bEndpointAddress;
290 acm->dataInEp.interval = endPoint->endpointDescriptor.bInterval;
291 acm->dataInEp.maxPacketSize = endPoint->endpointDescriptor.wMaxPacketSize;
292 } else { /* get bulk out endpoint */
293 acm->dataOutEp.addr = endPoint->endpointDescriptor.bEndpointAddress;
294 acm->dataOutEp.interval = endPoint->endpointDescriptor.bInterval;
295 acm->dataOutEp.maxPacketSize = endPoint->endpointDescriptor.wMaxPacketSize;
296 }
297 }
298 break;
299 default:
300 printf("%s:%d wrong descriptor type\n", __func__, __LINE__);
301 break;
302 }
303 }
304
UsbParseConfigDescriptor(struct AcmRawDevice * acm,struct UsbRawConfigDescriptor * config)305 int32_t UsbParseConfigDescriptor(struct AcmRawDevice *acm, struct UsbRawConfigDescriptor *config)
306 {
307 uint8_t numInterfaces;
308 uint8_t i;
309 int32_t ret;
310 const struct UsbRawInterface *interface = NULL;
311
312 numInterfaces = config->configDescriptor.bNumInterfaces;
313 printf("------numInterfaces = [%d]------\n", numInterfaces);
314 for (i = 0; i < numInterfaces; i++) {
315 interface = config->interface[i];
316
317 printf("------UsbRawClaimInterface start------\n");
318 ret = UsbRawClaimInterface(acm->devHandle, i);
319 if (ret) {
320 printf("%s:%d claim interface %u failed\n", __func__, __LINE__, i);
321 continue;
322 }
323 printf("------UsbRawClaimInterface end------\n");
324 AcmParaseInterfaceClass(acm, interface, i);
325 }
326
327 return HDF_SUCCESS;
328 }
329
330
331 struct UsbRawTestFunc g_usbRawFunc[] = {
332 { USB_RAW_SDK_IF_START_IO, UsbStartIo},
333 { USB_RAW_SDK_IF_INIT_001_TEST, CheckRawSdkIfInit001},
334 { USB_RAW_SDK_IF_EXIT_001_TEST, CheckRawSdkIfExit001},
335 { USB_RAW_SDK_IF_INIT_002_TEST, CheckRawSdkIfInit002},
336 { USB_RAW_SDK_IF_EXIT_002_TEST, CheckRawSdkIfExit002},
337 { USB_RAW_SDK_IF_INIT_003_TEST, CheckRawSdkIfInit003},
338 { USB_RAW_SDK_IF_INIT_004_TEST, CheckRawSdkIfInit004},
339 { USB_RAW_SDK_IF_INIT_005_TEST, CheckRawSdkIfInit005},
340 { USB_RAW_SDK_IF_OPEN_DEVICE_001_TEST, CheckRawSdkIfOpenDevice001},
341 { USB_RAW_SDK_IF_OPEN_DEVICE_002_TEST, CheckRawSdkIfOpenDevice002},
342 { USB_RAW_SDK_IF_OPEN_DEVICE_003_TEST, CheckRawSdkIfOpenDevice003},
343 { USB_RAW_SDK_IF_OPEN_DEVICE_004_TEST, CheckRawSdkIfOpenDevice004},
344 { USB_RAW_SDK_IF_OPEN_DEVICE_005_TEST, CheckRawSdkIfOpenDevice005},
345 { USB_RAW_SDK_IF_OPEN_DEVICE_006_TEST, CheckRawSdkIfOpenDevice006},
346 { USB_RAW_SDK_IF_RESET_DEVICE_001_TEST, CheckRawSdkIfResetDevice001},
347 { USB_RAW_SDK_IF_RESET_DEVICE_002_TEST, CheckRawSdkIfResetDevice002},
348 { USB_RAW_SDK_IF_CLOSE_DEVICE_001_TEST, CheckRawSdkIfCloseDevice001},
349 { USB_RAW_SDK_IF_CLOSE_DEVICE_002_TEST, CheckRawSdkIfCloseDevice002},
350 { USB_RAW_SDK_IF_OPEN_DEVICE_007_TEST, CheckRawSdkIfOpenDevice007},
351 { USB_RAW_SDK_IF_GET_CONFIGURATION_001_TEST, CheckRawSdkIfGetConfiguration001},
352 { USB_RAW_SDK_IF_GET_CONFIGURATION_002_TEST, CheckRawSdkIfGetConfiguration002},
353 { USB_RAW_SDK_IF_GET_CONFIGURATION_003_TEST, CheckRawSdkIfGetConfiguration003},
354 { USB_RAW_SDK_IF_GET_CONFIGURATION_004_TEST, CheckRawSdkIfGetConfiguration004},
355 { USB_RAW_SDK_IF_GET_DEVICE_001_TEST, CheckRawSdkIfGetDevice001},
356 { USB_RAW_SDK_IF_GET_DEVICE_002_TEST, CheckRawSdkIfGetDevice002},
357 { USB_RAW_SDK_IF_GET_CONFIG_DESC_001_TEST, CheckRawSdkIfGetConfigDescriptor001},
358 { USB_RAW_SDK_IF_GET_CONFIG_DESC_002_TEST, CheckRawSdkIfGetConfigDescriptor002},
359 { USB_RAW_SDK_IF_GET_CONFIG_DESC_003_TEST, CheckRawSdkIfGetConfigDescriptor003},
360 { USB_RAW_SDK_IF_GET_CONFIG_DESC_004_TEST, CheckRawSdkIfGetConfigDescriptor004},
361 { USB_RAW_SDK_IF_SET_CONFIGURATION_001_TEST, CheckRawSdkIfSetConfiguration001},
362 { USB_RAW_SDK_IF_SET_CONFIGURATION_002_TEST, CheckRawSdkIfSetConfiguration002},
363 { USB_RAW_SDK_IF_SET_CONFIGURATION_003_TEST, CheckRawSdkIfSetConfiguration003},
364 { USB_RAW_SDK_IF_SET_CONFIGURATION_004_TEST, CheckRawSdkIfSetConfiguration004},
365 { USB_RAW_SDK_IF_SET_CONFIGURATION_005_TEST, CheckRawSdkIfSetConfiguration005},
366 { USB_RAW_SDK_IF_SET_CONFIGURATION_006_TEST, CheckRawSdkIfSetConfiguration006},
367 { USB_RAW_SDK_IF_SET_CONFIGURATION_007_TEST, CheckRawSdkIfSetConfiguration007},
368 { USB_RAW_SDK_IF_SET_CONFIGURATION_008_TEST, CheckRawSdkIfSetConfiguration008},
369 { USB_RAW_SDK_IF_GET_DEVICE_DESC_001_TEST, CheckRawSdkIfGetDeviceDescriptor001},
370 { USB_RAW_SDK_IF_GET_DEVICE_DESC_002_TEST, CheckRawSdkIfGetDeviceDescriptor002},
371 { USB_RAW_SDK_IF_GET_DEVICE_DESC_003_TEST, CheckRawSdkIfGetDeviceDescriptor003},
372 { USB_RAW_SDK_IF_GET_DEVICE_DESC_004_TEST, CheckRawSdkIfGetDeviceDescriptor004},
373 { USB_RAW_SDK_IF_GET_CONFIG_DESC_005_TEST, CheckRawSdkIfGetConfigDescriptor005},
374 { USB_RAW_SDK_IF_GET_DEVICE_DESC_005_TEST, CheckRawSdkIfGetDeviceDescriptor005},
375 { USB_RAW_SDK_IF_CLAMIN_INTERFACE_001_TEST, CheckRawSdkIfClaimInterface001},
376 { USB_RAW_SDK_IF_CLAMIN_INTERFACE_002_TEST, CheckRawSdkIfClaimInterface002},
377 { USB_RAW_SDK_IF_CLAMIN_INTERFACE_003_TEST, CheckRawSdkIfClaimInterface003},
378 { USB_RAW_SDK_IF_CLAMIN_INTERFACE_004_TEST, CheckRawSdkIfClaimInterface004},
379 { USB_RAW_SDK_IF_CLAMIN_INTERFACE_005_TEST, CheckRawSdkIfClaimInterface005},
380 { USB_RAW_SDK_IF_RELEASE_INTERFACE_001_TEST, CheckRawSdkIfReleaseInterface001},
381 { USB_RAW_SDK_IF_RELEASE_INTERFACE_002_TEST, CheckRawSdkIfReleaseInterface002},
382 { USB_RAW_SDK_IF_RELEASE_INTERFACE_003_TEST, CheckRawSdkIfReleaseInterface003},
383 { USB_RAW_SDK_IF_RELEASE_INTERFACE_004_TEST, CheckRawSdkIfReleaseInterface004},
384 { USB_RAW_SDK_IF_CLAMIN_INTERFACE_006_TEST, CheckRawSdkIfClaimInterface006},
385 { USB_RAW_SDK_IF_ALLOC_REQUEST_001_TEST, CheckRawSdkIfAllocRequest001},
386 { USB_RAW_SDK_IF_ALLOC_REQUEST_002_TEST, CheckRawSdkIfAllocRequest002},
387 { USB_RAW_SDK_IF_ALLOC_REQUEST_003_TEST, CheckRawSdkIfAllocRequest003},
388 { USB_RAW_SDK_IF_ALLOC_REQUEST_004_TEST, CheckRawSdkIfAllocRequest004},
389 { USB_RAW_SDK_IF_ALLOC_REQUEST_005_TEST, CheckRawSdkIfAllocRequest005},
390 { USB_RAW_SDK_IF_ALLOC_REQUEST_006_TEST, CheckRawSdkIfAllocRequest006},
391 { USB_RAW_SDK_IF_ALLOC_REQUEST_007_TEST, CheckRawSdkIfAllocRequest007},
392 { USB_RAW_SDK_IF_ALLOC_REQUEST_008_TEST, CheckRawSdkIfAllocRequest008},
393 { USB_RAW_SDK_IF_ALLOC_REQUEST_010_TEST, CheckRawSdkIfAllocRequest010},
394 { USB_RAW_SDK_IF_ALLOC_REQUEST_011_TEST, CheckRawSdkIfAllocRequest011},
395 { USB_RAW_SDK_IF_FREE_REQUEST_006_TEST, CheckRawSdkIfFreeRequest006},
396 { USB_RAW_SDK_IF_FILL_ISO_REQUEST_001_TEST, CheckRawSdkIfFillIsoRequest001},
397 { USB_RAW_SDK_IF_FILL_ISO_REQUEST_002_TEST, CheckRawSdkIfFillIsoRequest002},
398 { USB_RAW_SDK_IF_FILL_ISO_REQUEST_003_TEST, CheckRawSdkIfFillIsoRequest003},
399 { USB_RAW_SDK_IF_FILL_ISO_REQUEST_004_TEST, CheckRawSdkIfFillIsoRequest004},
400 { USB_RAW_SDK_IF_FILL_ISO_REQUEST_005_TEST, CheckRawSdkIfFillIsoRequest005},
401 { USB_RAW_SDK_IF_FILL_ISO_REQUEST_006_TEST, CheckRawSdkIfFillIsoRequest006},
402 { USB_RAW_SDK_IF_FREE_REQUEST_001_TEST, CheckRawSdkIfFreeRequest001},
403 { USB_RAW_SDK_IF_FREE_REQUEST_002_TEST, CheckRawSdkIfFreeRequest002},
404 { USB_RAW_SDK_IF_FREE_REQUEST_003_TEST, CheckRawSdkIfFreeRequest003},
405 { USB_RAW_SDK_IF_FREE_REQUEST_004_TEST, CheckRawSdkIfFreeRequest004},
406 { USB_RAW_SDK_IF_FREE_REQUEST_005_TEST, CheckRawSdkIfFreeRequest005},
407 { USB_RAW_SDK_IF_ALLOC_REQUEST_009_TEST, CheckRawSdkIfAllocRequest009},
408 { USB_RAW_SDK_IF_GET_DESCRIPTION_001_TEST, CheckRawSdkIfGetDescriptor001},
409 { USB_RAW_SDK_IF_GET_DESCRIPTION_002_TEST, CheckRawSdkIfGetDescriptor002},
410 { USB_RAW_SDK_IF_GET_DESCRIPTION_003_TEST, CheckRawSdkIfGetDescriptor003},
411 { USB_RAW_SDK_IF_GET_DESCRIPTION_004_TEST, CheckRawSdkIfGetDescriptor004},
412 { USB_RAW_SDK_IF_GET_DESCRIPTION_005_TEST, CheckRawSdkIfGetDescriptor005},
413 { USB_RAW_SDK_IF_GET_DESCRIPTION_006_TEST, CheckRawSdkIfGetDescriptor006},
414 { USB_RAW_SDK_IF_GET_DESCRIPTION_007_TEST, CheckRawSdkIfGetDescriptor007},
415 { USB_RAW_SDK_IF_GET_DESCRIPTION_008_TEST, CheckRawSdkIfGetDescriptor008},
416 { USB_RAW_SDK_IF_GET_DESCRIPTION_009_TEST, CheckRawSdkIfGetDescriptor009},
417 { USB_RAW_SDK_IF_GET_DESCRIPTION_010_TEST, CheckRawSdkIfGetDescriptor010},
418 { USB_RAW_SDK_IF_GET_DESCRIPTION_011_TEST, CheckRawSdkIfGetDescriptor011},
419 { USB_RAW_SDK_IF_GET_DESCRIPTION_012_TEST, CheckRawSdkIfGetDescriptor012},
420 { USB_RAW_SDK_IF_GET_DESCRIPTION_013_TEST, CheckRawSdkIfGetDescriptor013},
421 { USB_RAW_SDK_IF_GET_DESCRIPTION_014_TEST, CheckRawSdkIfGetDescriptor014},
422 { USB_RAW_SDK_IF_GET_DESCRIPTION_015_TEST, CheckRawSdkIfGetDescriptor015},
423 { USB_RAW_SDK_IF_GET_DESCRIPTION_016_TEST, CheckRawSdkIfGetDescriptor016},
424 { USB_RAW_SDK_IF_FILL_BULK_REQUEST_001_TEST, CheckRawSdkIfFillBulkRequest001},
425 { USB_RAW_SDK_IF_FILL_BULK_REQUEST_002_TEST, CheckRawSdkIfFillBulkRequest002},
426 { USB_RAW_SDK_IF_FILL_INT_REQUEST_001_TEST, CheckRawSdkIfFillInterruptRequest001},
427 { USB_RAW_SDK_IF_FILL_INT_REQUEST_002_TEST, CheckRawSdkIfFillInterruptRequest002},
428 { USB_RAW_SDK_IF_FILL_INT_REQUEST_003_TEST, CheckRawSdkIfFillInterruptRequest003},
429 { USB_RAW_SDK_IF_FILL_INT_REQUEST_004_TEST, CheckRawSdkIfFillInterruptRequest004},
430 { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_001_TEST, CheckRawSdkIfFillControlRequest001},
431 { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_002_TEST, CheckRawSdkIfFillControlRequest002},
432 { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_003_TEST, CheckRawSdkIfFillControlRequest003},
433 { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_004_TEST, CheckRawSdkIfFillControlRequest004},
434 { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_005_TEST, CheckRawSdkIfFillControlRequest005},
435 { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_006_TEST, CheckRawSdkIfFillControlRequest006},
436 { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_007_TEST, CheckRawSdkIfFillControlRequest007},
437 { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_008_TEST, CheckRawSdkIfFillControlRequest008},
438 { USB_RAW_SDK_IF_FILL_CONTROL_SETUP_001_TEST, CheckRawSdkIfFillControlSetup001},
439 { USB_RAW_SDK_IF_FILL_CONTROL_SETUP_002_TEST, CheckRawSdkIfFillControlSetup002},
440 { USB_RAW_SDK_IF_FILL_CONTROL_SETUP_003_TEST, CheckRawSdkIfFillControlSetup003},
441 { USB_RAW_SDK_IF_FILL_CONTROL_SETUP_004_TEST, CheckRawSdkIfFillControlSetup004},
442 { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_001_TEST, CheckRawSdkIfSendControlRequest001},
443 { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_002_TEST, CheckRawSdkIfSendControlRequest002},
444 { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_003_TEST, CheckRawSdkIfSendControlRequest003},
445 { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_004_TEST, CheckRawSdkIfSendControlRequest004},
446 { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_005_TEST, CheckRawSdkIfSendControlRequest005},
447 { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_006_TEST, CheckRawSdkIfSendControlRequest006},
448 { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_007_TEST, CheckRawSdkIfSendControlRequest007},
449 { USB_RAW_SDK_IF_SEND_BULK_REQUEST_001_TEST, CheckRawSdkIfSendBulkRequest001},
450 { USB_RAW_SDK_IF_SEND_BULK_REQUEST_002_TEST, CheckRawSdkIfSendBulkRequest002},
451 { USB_RAW_SDK_IF_SEND_BULK_REQUEST_003_TEST, CheckRawSdkIfSendBulkRequest003},
452 { USB_RAW_SDK_IF_SEND_BULK_REQUEST_004_TEST, CheckRawSdkIfSendBulkRequest004},
453 { USB_RAW_SDK_IF_SEND_BULK_REQUEST_005_TEST, CheckRawSdkIfSendBulkRequest005},
454 { USB_RAW_SDK_IF_SEND_INT_REQUEST_001_TEST, CheckRawSdkIfSendInterruptRequest001},
455 { USB_RAW_SDK_IF_SEND_INT_REQUEST_002_TEST, CheckRawSdkIfSendInterruptRequest002},
456 { USB_RAW_SDK_IF_SEND_INT_REQUEST_003_TEST, CheckRawSdkIfSendInterruptRequest003},
457 { USB_RAW_SDK_IF_SEND_INT_REQUEST_004_TEST, CheckRawSdkIfSendInterruptRequest004},
458 { USB_RAW_SDK_IF_FILL_BULK_REQUEST_003_TEST, CheckRawSdkIfFillBulkRequest003},
459 { USB_RAW_SDK_IF_FILL_BULK_REQUEST_004_TEST, CheckRawSdkIfFillBulkRequest004},
460 { USB_RAW_SDK_IF_FILL_INT_REQUEST_005_TEST, CheckRawSdkIfFillInterruptRequest005},
461 { USB_RAW_SDK_IF_SUBMIT_REQUEST_001_TEST, CheckRawSdkIfSubmitRequest001},
462 { USB_RAW_SDK_IF_SUBMIT_REQUEST_002_TEST, CheckRawSdkIfSubmitRequest002},
463 { USB_RAW_SDK_IF_SUBMIT_REQUEST_003_TEST, CheckRawSdkIfSubmitRequest003},
464 { USB_RAW_SDK_IF_SUBMIT_REQUEST_004_TEST, CheckRawSdkIfSubmitRequest004},
465 { USB_RAW_SDK_IF_CANCEL_REQUEST_001_TEST, CheckRawSdkIfCancelRequest001},
466 { USB_RAW_SDK_IF_CANCEL_REQUEST_002_TEST, CheckRawSdkIfCancelRequest002},
467 { USB_RAW_SDK_IF_CANCEL_REQUEST_003_TEST, CheckRawSdkIfCancelRequest003},
468 { USB_RAW_SDK_IF_CANCEL_REQUEST_004_TEST, CheckRawSdkIfCancelRequest004},
469 { USB_RAW_SDK_IF_STOP_IO, UsbStopIo},
470
471 };
472
UsbRawTestEntry(int32_t cmd)473 int32_t UsbRawTestEntry(int32_t cmd)
474 {
475 int32_t i;
476 int32_t ret = HDF_ERR_NOT_SUPPORT;
477
478 if (g_initFlag == false) {
479 #ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY
480 struct UsbGetDevicePara paraData;
481 struct usb_device *usbPnpDevice = NULL;
482 paraData.type = USB_PNP_DEVICE_VENDOR_PRODUCT_TYPE;
483 paraData.vendorId = USB_DEVICE_VENDOR_ID;
484 paraData.productId = USB_DEVICE_PRODUCT_ID;
485 usbPnpDevice = UsbPnpNotifyGetUsbDevice(paraData);
486 if (usbPnpDevice == NULL) {
487 HDF_LOGE("%s:%d UsbPnpNotifyGetUsbDevice is NULL!", __func__, __LINE__);
488 return HDF_ERR_INVALID_PARAM;
489 }
490 g_acm->busNum = usbPnpDevice->address;
491 g_acm->devAddr = usbPnpDevice->port_no;
492 HDF_LOGE("%s: busNum %d++devAddr %d", __func__, g_acm->busNum, g_acm->devAddr);
493 g_initFlag = true;
494 #else
495 HDF_LOGE("%s:%d pnp notify module is not support!", __func__, __LINE__);
496 return HDF_ERR_NOT_SUPPORT;
497 #endif
498 }
499 for (i = 0; i < sizeof(g_usbRawFunc) / sizeof(g_usbRawFunc[0]); i++) {
500 if (cmd == g_usbRawFunc[i].type && g_usbRawFunc[i].Func != NULL) {
501 ret = g_usbRawFunc[i].Func();
502 HDF_LOGE("%s: cmd %d ret %d", __func__, cmd, ret);
503 break;
504 }
505 }
506 return ret;
507 }
508
CheckRawSdkIfInit001(void)509 int32_t CheckRawSdkIfInit001(void)
510 {
511 int32_t ret;
512
513 ret = UsbRawInit(&g_session);
514 if (ret) {
515 HDF_LOGE("%s: error", __func__);
516 return HDF_FAILURE;
517 }
518 g_acm->session = g_session;
519 HDF_LOGE("%s: success", __func__);
520 return HDF_SUCCESS;
521 }
522
CheckRawSdkIfExit001(void)523 int32_t CheckRawSdkIfExit001(void)
524 {
525 int32_t ret;
526
527 ret = UsbRawExit(g_acm->session);
528 if (ret) {
529 HDF_LOGE("%s: error", __func__);
530 return HDF_FAILURE;
531 }
532 g_session = NULL;
533 g_acm->session = g_session;
534 HDF_LOGE("%s: success", __func__);
535 return HDF_SUCCESS;
536 }
537
CheckRawSdkIfInit002(void)538 int32_t CheckRawSdkIfInit002(void)
539 {
540 int32_t ret;
541
542 ret = UsbRawInit(NULL);
543 if (ret) {
544 HDF_LOGE("%s: error", __func__);
545 return HDF_FAILURE;
546 }
547 HDF_LOGE("%s: success", __func__);
548 return HDF_SUCCESS;
549 }
550
CheckRawSdkIfExit002(void)551 int32_t CheckRawSdkIfExit002(void)
552 {
553 int32_t ret;
554
555 ret = UsbRawExit(NULL);
556 if (ret) {
557 HDF_LOGE("%s: error", __func__);
558 return HDF_FAILURE;
559 }
560 HDF_LOGE("%s: success", __func__);
561 return HDF_SUCCESS;
562 }
563
CheckRawSdkIfInit003(void)564 int32_t CheckRawSdkIfInit003(void)
565 {
566 int32_t ret;
567 int32_t i;
568
569 for (i = 0; i < USB_LOOP_NUM; i++) {
570 ret = UsbRawInit(&g_session);
571 if (ret) {
572 HDF_LOGE("%s: error", __func__);
573 return HDF_FAILURE;
574 }
575 g_acm->session = g_session;
576 ret = UsbRawExit(g_acm->session);
577 if (ret) {
578 HDF_LOGE("%s: error", __func__);
579 return HDF_FAILURE;
580 }
581 g_session = NULL;
582 g_acm->session = g_session;
583 }
584 HDF_LOGE("%s: success", __func__);
585 return HDF_SUCCESS;
586 }
587
CheckRawSdkIfInit004(void)588 int32_t CheckRawSdkIfInit004(void)
589 {
590 int32_t ret;
591 int32_t i;
592
593 for (i = 0; i < USB_LOOP_NUM; i++) {
594 ret = UsbRawInit(NULL);
595 if (ret) {
596 HDF_LOGE("%s: error", __func__);
597 return HDF_FAILURE;
598 }
599 ret = UsbRawExit(NULL);
600 if (ret) {
601 HDF_LOGE("%s: error", __func__);
602 return HDF_FAILURE;
603 }
604 }
605 HDF_LOGE("%s: success", __func__);
606 return HDF_SUCCESS;
607 }
608
CheckRawSdkIfInit005(void)609 int32_t CheckRawSdkIfInit005(void)
610 {
611 int32_t ret;
612
613 ret = UsbRawInit(&g_session);
614 if (ret) {
615 HDF_LOGE("%s: error", __func__);
616 return HDF_FAILURE;
617 }
618 g_acm->session = g_session;
619 HDF_LOGE("%s: success", __func__);
620 return HDF_SUCCESS;
621 }
622
CheckRawSdkIfOpenDevice001(void)623 int32_t CheckRawSdkIfOpenDevice001(void)
624 {
625 g_devHandle = UsbRawOpenDevice(NULL, g_acm->busNum, g_acm->devAddr);
626 if (g_devHandle) {
627 HDF_LOGE("%s: error", __func__);
628 return HDF_FAILURE;
629 }
630 g_acm->devHandle = g_devHandle;
631 HDF_LOGE("%s: success", __func__);
632 return HDF_SUCCESS;
633 }
634
CheckRawSdkIfOpenDevice002(void)635 int32_t CheckRawSdkIfOpenDevice002(void)
636 {
637 uint8_t busNum = 1U;
638 uint8_t devAddr = 100U;
639 g_devHandle = UsbRawOpenDevice(g_acm->session, busNum, devAddr);
640 if (g_devHandle) {
641 HDF_LOGE("%s: error", __func__);
642 return HDF_FAILURE;
643 }
644 g_acm->devHandle = g_devHandle;
645 HDF_LOGE("%s: success", __func__);
646 return HDF_SUCCESS;
647 }
648
CheckRawSdkIfOpenDevice003(void)649 int32_t CheckRawSdkIfOpenDevice003(void)
650 {
651 uint8_t busNum = 1U;
652 uint8_t devAddr = 255U;
653 g_devHandle = UsbRawOpenDevice(g_acm->session, busNum, devAddr);
654 if (g_devHandle) {
655 HDF_LOGE("%s: error", __func__);
656 return HDF_FAILURE;
657 }
658 g_acm->devHandle = g_devHandle;
659 HDF_LOGE("%s: success", __func__);
660 return HDF_SUCCESS;
661 }
662
CheckRawSdkIfOpenDevice004(void)663 int32_t CheckRawSdkIfOpenDevice004(void)
664 {
665 uint8_t busNum = 100U;
666 uint8_t devAddr = 2U;
667 g_devHandle = UsbRawOpenDevice(g_acm->session, busNum, devAddr);
668 if (g_devHandle) {
669 HDF_LOGE("%s: error", __func__);
670 return HDF_FAILURE;
671 }
672 g_acm->devHandle = g_devHandle;
673 HDF_LOGE("%s: success", __func__);
674 return HDF_SUCCESS;
675 }
676
CheckRawSdkIfOpenDevice005(void)677 int32_t CheckRawSdkIfOpenDevice005(void)
678 {
679 uint8_t busNum = 255U;
680 uint8_t devAddr = 2U;
681 g_devHandle = UsbRawOpenDevice(g_acm->session, busNum, devAddr);
682 if (g_devHandle) {
683 HDF_LOGE("%s: error", __func__);
684 return HDF_FAILURE;
685 }
686 g_acm->devHandle = g_devHandle;
687 HDF_LOGE("%s: success", __func__);
688 return HDF_SUCCESS;
689 }
690
CheckRawSdkIfOpenDevice006(void)691 int32_t CheckRawSdkIfOpenDevice006(void)
692 {
693 g_devHandle = UsbRawOpenDevice(g_acm->session, g_acm->busNum, g_acm->devAddr);
694 if (g_devHandle == NULL) {
695 HDF_LOGE("%s: error", __func__);
696 return HDF_FAILURE;
697 }
698 g_acm->devHandle = g_devHandle;
699 HDF_LOGE("%s: success", __func__);
700 return HDF_SUCCESS;
701 }
702
CheckRawSdkIfResetDevice001(void)703 int32_t CheckRawSdkIfResetDevice001(void)
704 {
705 int32_t ret;
706
707 ret = UsbRawResetDevice(NULL);
708 if (ret != HDF_ERR_INVALID_PARAM) {
709 HDF_LOGE("%s: error", __func__);
710 return HDF_FAILURE;
711 }
712 HDF_LOGE("%s: success", __func__);
713 return HDF_SUCCESS;
714 }
715
CheckRawSdkIfResetDevice002(void)716 int32_t CheckRawSdkIfResetDevice002(void)
717 {
718 int32_t ret;
719
720 ret = UsbRawResetDevice(g_acm->devHandle);
721 if (ret) {
722 HDF_LOGE("%s: error", __func__);
723 return HDF_FAILURE;
724 }
725 HDF_LOGE("%s: success", __func__);
726 return HDF_SUCCESS;
727 }
728
CheckRawSdkIfCloseDevice001(void)729 int32_t CheckRawSdkIfCloseDevice001(void)
730 {
731 int32_t ret;
732
733 ret = UsbRawCloseDevice(NULL);
734 if (ret != HDF_ERR_INVALID_PARAM) {
735 HDF_LOGE("%s: error", __func__);
736 return HDF_FAILURE;
737 }
738 HDF_LOGE("%s: success", __func__);
739 return HDF_SUCCESS;
740 }
741
CheckRawSdkIfCloseDevice002(void)742 int32_t CheckRawSdkIfCloseDevice002(void)
743 {
744 int32_t ret;
745
746 ret = UsbRawCloseDevice(g_acm->devHandle);
747 if (ret) {
748 HDF_LOGE("%s: error", __func__);
749 return HDF_FAILURE;
750 }
751 g_acm->devHandle = NULL;
752 g_devHandle = g_acm->devHandle;
753 HDF_LOGE("%s: success", __func__);
754 return HDF_SUCCESS;
755 }
756
CheckRawSdkIfOpenDevice007(void)757 int32_t CheckRawSdkIfOpenDevice007(void)
758 {
759 g_devHandle = UsbRawOpenDevice(g_session, g_acm->busNum, g_acm->devAddr);
760 if (g_devHandle == NULL) {
761 HDF_LOGE("%s: error", __func__);
762 return HDF_FAILURE;
763 }
764 g_acm->devHandle = g_devHandle;
765 HDF_LOGE("%s: success", __func__);
766 return HDF_SUCCESS;
767 }
768
CheckRawSdkIfGetConfiguration001(void)769 int32_t CheckRawSdkIfGetConfiguration001(void)
770 {
771 int32_t ret;
772
773 ret = UsbRawGetConfiguration(NULL, &g_activeConfig);
774 if (ret != HDF_ERR_INVALID_PARAM) {
775 HDF_LOGE("%s: error", __func__);
776 return HDF_FAILURE;
777 }
778 HDF_LOGE("%s: success", __func__);
779 return HDF_SUCCESS;
780 }
781
CheckRawSdkIfGetConfiguration002(void)782 int32_t CheckRawSdkIfGetConfiguration002(void)
783 {
784 int32_t ret;
785
786 ret = UsbRawGetConfiguration(g_acm->devHandle, NULL);
787 if (ret != HDF_ERR_INVALID_PARAM) {
788 HDF_LOGE("%s: error", __func__);
789 return HDF_FAILURE;
790 }
791 HDF_LOGE("%s: success", __func__);
792 return HDF_SUCCESS;
793 }
794
CheckRawSdkIfGetConfiguration003(void)795 int32_t CheckRawSdkIfGetConfiguration003(void)
796 {
797 int32_t ret;
798
799 ret = UsbRawGetConfiguration(NULL, NULL);
800 if (ret != HDF_ERR_INVALID_PARAM) {
801 HDF_LOGE("%s: error", __func__);
802 return HDF_FAILURE;
803 }
804 HDF_LOGE("%s: success", __func__);
805 return HDF_SUCCESS;
806 }
807
CheckRawSdkIfGetConfiguration004(void)808 int32_t CheckRawSdkIfGetConfiguration004(void)
809 {
810 int32_t ret;
811
812 ret = UsbRawGetConfiguration(g_acm->devHandle, &g_activeConfig);
813 printf("------g_activeConfig = [%d]------\n", g_activeConfig);
814 if (ret) {
815 HDF_LOGE("%s: error", __func__);
816 return HDF_FAILURE;
817 }
818 HDF_LOGE("%s: success", __func__);
819 return HDF_SUCCESS;
820 }
821
CheckRawSdkIfGetDevice001(void)822 int32_t CheckRawSdkIfGetDevice001(void)
823 {
824 g_dev = UsbRawGetDevice(NULL);
825 if (g_dev) {
826 HDF_LOGE("%s: error", __func__);
827 return HDF_FAILURE;
828 }
829 HDF_LOGE("%s: success", __func__);
830 return HDF_SUCCESS;
831 }
832
CheckRawSdkIfGetDevice002(void)833 int32_t CheckRawSdkIfGetDevice002(void)
834 {
835 g_dev = UsbRawGetDevice(g_acm->devHandle);
836 if (g_dev == NULL) {
837 HDF_LOGE("%s: error", __func__);
838 return HDF_FAILURE;
839 }
840 HDF_LOGE("%s: success", __func__);
841 return HDF_SUCCESS;
842 }
843
844
CheckRawSdkIfClaimInterface002(void)845 int32_t CheckRawSdkIfClaimInterface002(void)
846 {
847 int32_t ret;
848 int32_t interfaceNumber = 1;
849
850 ret = UsbRawClaimInterface(g_devHandle, interfaceNumber);
851 if (ret) {
852 HDF_LOGE("%s: error", __func__);
853 return HDF_FAILURE;
854 }
855 HDF_LOGE("%s: success", __func__);
856 return HDF_SUCCESS;
857 }
858
CheckRawSdkIfClaimInterface003(void)859 int32_t CheckRawSdkIfClaimInterface003(void)
860 {
861 int32_t ret;
862 int32_t interfaceNumber = 0;
863
864 ret = UsbRawClaimInterface(g_devHandle, interfaceNumber);
865 if (ret) {
866 HDF_LOGE("%s: error", __func__);
867 return HDF_FAILURE;
868 }
869 HDF_LOGE("%s: success", __func__);
870 return HDF_SUCCESS;
871 }
872
CheckRawSdkIfClaimInterface004(void)873 int32_t CheckRawSdkIfClaimInterface004(void)
874 {
875 int32_t ret;
876 int32_t interfaceNumber = USB_MAX_BYTE;
877
878 ret = UsbRawClaimInterface(g_devHandle, interfaceNumber);
879 if (ret != HDF_ERR_INVALID_PARAM) {
880 HDF_LOGE("%s: error", __func__);
881 return HDF_FAILURE;
882 }
883 HDF_LOGE("%s: success", __func__);
884 return HDF_SUCCESS;
885 }
886
CheckRawSdkIfGetDeviceDescriptor002(void)887 int32_t CheckRawSdkIfGetDeviceDescriptor002(void)
888 {
889 int32_t ret;
890
891 ret = UsbRawGetDeviceDescriptor(g_dev, NULL);
892 if (ret != HDF_ERR_INVALID_PARAM) {
893 HDF_LOGE("%s: error", __func__);
894 return HDF_FAILURE;
895 }
896 HDF_LOGE("%s: success", __func__);
897 return HDF_SUCCESS;
898 }
899
CheckRawSdkIfGetDeviceDescriptor003(void)900 int32_t CheckRawSdkIfGetDeviceDescriptor003(void)
901 {
902 int32_t ret;
903
904 ret = UsbRawGetDeviceDescriptor(NULL, NULL);
905 if (ret != HDF_ERR_INVALID_PARAM) {
906 HDF_LOGE("%s: error", __func__);
907 return HDF_FAILURE;
908 }
909 HDF_LOGE("%s: success", __func__);
910 return HDF_SUCCESS;
911 }
912
CheckRawSdkIfGetDeviceDescriptor004(void)913 int32_t CheckRawSdkIfGetDeviceDescriptor004(void)
914 {
915 struct UsbDeviceDescriptor desc;
916 int32_t ret;
917
918 ret = UsbRawGetDeviceDescriptor(g_dev, &desc);
919 if (ret) {
920 HDF_LOGE("%s: error", __func__);
921 return HDF_FAILURE;
922 }
923 HDF_LOGE("%s: success", __func__);
924 return HDF_SUCCESS;
925 }
926
CheckRawSdkIfGetConfigDescriptor005(void)927 int32_t CheckRawSdkIfGetConfigDescriptor005(void)
928 {
929 int32_t ret;
930
931 printf("------g_activeConfig = [%d]------\n", g_activeConfig);
932 ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, &g_acm->config);
933 if (ret) {
934 HDF_LOGE("%s: error", __func__);
935 return HDF_FAILURE;
936 }
937 HDF_LOGE("%s: success", __func__);
938 return HDF_SUCCESS;
939 }
940
CheckRawSdkIfGetDeviceDescriptor005(void)941 int32_t CheckRawSdkIfGetDeviceDescriptor005(void)
942 {
943 struct UsbDeviceDescriptor desc;
944 int32_t ret;
945
946 ret = UsbRawGetDeviceDescriptor(g_dev, &desc);
947 if (ret) {
948 HDF_LOGE("%s: error", __func__);
949 return HDF_FAILURE;
950 }
951 HDF_LOGE("%s: success", __func__);
952 return HDF_SUCCESS;
953 }
954
CheckRawSdkIfGetConfigDescriptor001(void)955 int32_t CheckRawSdkIfGetConfigDescriptor001(void)
956 {
957 int32_t ret;
958
959 ret = UsbRawGetConfigDescriptor(NULL, g_activeConfig, &g_acm->config);
960 if (ret != HDF_ERR_INVALID_PARAM) {
961 HDF_LOGE("%s: error", __func__);
962 return HDF_FAILURE;
963 }
964 HDF_LOGE("%s: success", __func__);
965 return HDF_SUCCESS;
966 }
967
CheckRawSdkIfGetConfigDescriptor002(void)968 int32_t CheckRawSdkIfGetConfigDescriptor002(void)
969 {
970 int32_t ret;
971
972 ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, NULL);
973 if (ret != HDF_ERR_INVALID_PARAM) {
974 HDF_LOGE("%s: error", __func__);
975 return HDF_FAILURE;
976 }
977 HDF_LOGE("%s: success", __func__);
978 return HDF_SUCCESS;
979 }
980
CheckRawSdkIfGetConfigDescriptor003(void)981 int32_t CheckRawSdkIfGetConfigDescriptor003(void)
982 {
983 int32_t ret;
984
985 ret = UsbRawGetConfigDescriptor(NULL, g_activeConfig, NULL);
986 if (ret != HDF_ERR_INVALID_PARAM) {
987 HDF_LOGE("%s: error", __func__);
988 return HDF_FAILURE;
989 }
990 HDF_LOGE("%s: success", __func__);
991 return HDF_SUCCESS;
992 }
993
CheckRawSdkIfGetConfigDescriptor004(void)994 int32_t CheckRawSdkIfGetConfigDescriptor004(void)
995 {
996 int32_t ret;
997
998 printf("------g_activeConfig = [%d]------\n", g_activeConfig);
999 ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, &g_acm->config);
1000 if (ret) {
1001 HDF_LOGE("%s: error", __func__);
1002 return HDF_FAILURE;
1003 }
1004 HDF_LOGE("%s: success", __func__);
1005 return HDF_SUCCESS;
1006 }
1007
CheckRawSdkIfSetConfiguration001(void)1008 int32_t CheckRawSdkIfSetConfiguration001(void)
1009 {
1010 int32_t ret;
1011 int32_t config = 0;
1012
1013 ret = UsbRawSetConfiguration(NULL, config);
1014 if (ret != HDF_ERR_INVALID_PARAM) {
1015 HDF_LOGE("%s: error", __func__);
1016 return HDF_FAILURE;
1017 }
1018 HDF_LOGE("%s: success", __func__);
1019 return HDF_SUCCESS;
1020 }
1021
CheckRawSdkIfSetConfiguration002(void)1022 int32_t CheckRawSdkIfSetConfiguration002(void)
1023 {
1024 int32_t ret;
1025 int32_t config = 0;
1026
1027 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
1028 if (ret) {
1029 HDF_LOGE("%s: error", __func__);
1030 return HDF_FAILURE;
1031 }
1032 HDF_LOGE("%s: success", __func__);
1033 return HDF_SUCCESS;
1034 }
1035
CheckRawSdkIfSetConfiguration003(void)1036 int32_t CheckRawSdkIfSetConfiguration003(void)
1037 {
1038 int32_t ret;
1039 int32_t config = 1;
1040
1041 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
1042 if (ret) {
1043 HDF_LOGE("%s: error", __func__);
1044 return HDF_FAILURE;
1045 }
1046 HDF_LOGE("%s: success", __func__);
1047 return HDF_SUCCESS;
1048 }
1049
CheckRawSdkIfSetConfiguration004(void)1050 int32_t CheckRawSdkIfSetConfiguration004(void)
1051 {
1052 int32_t ret;
1053 int32_t config = 10;
1054
1055 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
1056 if (ret != HDF_SUCCESS) {
1057 HDF_LOGE("%s: error", __func__);
1058 return HDF_SUCCESS;
1059 }
1060 HDF_LOGE("%s: success", __func__);
1061 return HDF_FAILURE;
1062 }
1063
CheckRawSdkIfSetConfiguration005(void)1064 int32_t CheckRawSdkIfSetConfiguration005(void)
1065 {
1066 int32_t ret;
1067 int32_t config = 100;
1068
1069 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
1070 if (ret != HDF_SUCCESS) {
1071 HDF_LOGE("%s: error", __func__);
1072 return HDF_SUCCESS;
1073 }
1074 HDF_LOGE("%s: success", __func__);
1075 return HDF_FAILURE;
1076 }
1077
CheckRawSdkIfSetConfiguration006(void)1078 int32_t CheckRawSdkIfSetConfiguration006(void)
1079 {
1080 int32_t ret;
1081 int32_t config = 200;
1082
1083 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
1084 if (ret != HDF_SUCCESS) {
1085 HDF_LOGE("%s: error", __func__);
1086 return HDF_SUCCESS;
1087 }
1088 HDF_LOGE("%s: success", __func__);
1089 return HDF_FAILURE;
1090 }
1091
CheckRawSdkIfSetConfiguration007(void)1092 int32_t CheckRawSdkIfSetConfiguration007(void)
1093 {
1094 int32_t ret;
1095 int32_t config = USB_MAX_BYTE;
1096
1097 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
1098 if (ret != HDF_SUCCESS) {
1099 HDF_LOGE("%s: error", __func__);
1100 return HDF_SUCCESS;
1101 }
1102 HDF_LOGE("%s: success", __func__);
1103 return HDF_FAILURE;
1104 }
1105
CheckRawSdkIfSetConfiguration008(void)1106 int32_t CheckRawSdkIfSetConfiguration008(void)
1107 {
1108 int32_t ret;
1109 int32_t config = 0;
1110
1111 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
1112 if (ret) {
1113 HDF_LOGE("%s: error", __func__);
1114 return HDF_FAILURE;
1115 }
1116 HDF_LOGE("%s: success", __func__);
1117 return HDF_SUCCESS;
1118 }
1119