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 #define HDF_LOG_TAG usb_raw_test_c
24
CheckRawSdkIfGetDeviceDescriptor001(void)25 int32_t CheckRawSdkIfGetDeviceDescriptor001(void)
26 {
27 struct UsbDeviceDescriptor desc;
28 int32_t ret;
29 ret = UsbRawGetDeviceDescriptor(NULL, &desc);
30 if (ret != HDF_ERR_INVALID_PARAM) {
31 HDF_LOGE("%s: error", __func__);
32 return HDF_FAILURE;
33 }
34 HDF_LOGE("%s: success", __func__);
35 return HDF_SUCCESS;
36 }
37
CheckRawSdkIfClaimInterface001(void)38 int32_t CheckRawSdkIfClaimInterface001(void)
39 {
40 int32_t ret;
41 int32_t interfaceNumber = 1;
42
43 ret = UsbRawClaimInterface(NULL, interfaceNumber);
44 if (ret != HDF_ERR_INVALID_PARAM) {
45 HDF_LOGE("%s: error", __func__);
46 return HDF_FAILURE;
47 }
48 HDF_LOGE("%s: success", __func__);
49 return HDF_SUCCESS;
50 }
51
CheckRawSdkIfClaimInterface005(void)52 int32_t CheckRawSdkIfClaimInterface005(void)
53 {
54 int32_t ret;
55 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
56
57 ret = UsbParseConfigDescriptor(rawAcm, rawAcm->config);
58 if (ret) {
59 HDF_LOGE("%s: error", __func__);
60 return HDF_FAILURE;
61 }
62 HDF_LOGE("%s: success", __func__);
63 return HDF_SUCCESS;
64 }
65
CheckRawSdkIfReleaseInterface001(void)66 int32_t CheckRawSdkIfReleaseInterface001(void)
67 {
68 int32_t ret;
69 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
70
71 ret = UsbRawReleaseInterface(NULL, rawAcm->ctrlIface);
72 if (ret != HDF_ERR_INVALID_PARAM) {
73 HDF_LOGE("%s: error", __func__);
74 return HDF_FAILURE;
75 }
76 HDF_LOGE("%s: success", __func__);
77 return HDF_SUCCESS;
78 }
79
CheckRawSdkIfReleaseInterface002(void)80 int32_t CheckRawSdkIfReleaseInterface002(void)
81 {
82 int32_t ret;
83 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
84
85 ret = UsbRawReleaseInterface(rawAcm->devHandle, rawAcm->ctrlIface);
86 if (ret) {
87 HDF_LOGE("%s: error", __func__);
88 return HDF_FAILURE;
89 }
90 HDF_LOGE("%s: success", __func__);
91 return HDF_SUCCESS;
92 }
93
CheckRawSdkIfReleaseInterface003(void)94 int32_t CheckRawSdkIfReleaseInterface003(void)
95 {
96 int32_t ret;
97 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
98
99 ret = UsbRawReleaseInterface(NULL, rawAcm->dataIface);
100 if (ret != HDF_ERR_INVALID_PARAM) {
101 HDF_LOGE("%s: error", __func__);
102 return HDF_FAILURE;
103 }
104 HDF_LOGE("%s: success", __func__);
105 return HDF_SUCCESS;
106 }
107
CheckRawSdkIfReleaseInterface004(void)108 int32_t CheckRawSdkIfReleaseInterface004(void)
109 {
110 int32_t ret;
111 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
112
113 ret = UsbRawReleaseInterface(rawAcm->devHandle, rawAcm->dataIface);
114 if (ret) {
115 HDF_LOGE("%s: error", __func__);
116 return HDF_FAILURE;
117 }
118 HDF_LOGE("%s: success", __func__);
119 return HDF_SUCCESS;
120 }
121
CheckRawSdkIfClaimInterface006(void)122 int32_t CheckRawSdkIfClaimInterface006(void)
123 {
124 int32_t ret;
125 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
126
127 ret = UsbParseConfigDescriptor(rawAcm, rawAcm->config);
128 if (ret) {
129 HDF_LOGE("%s: error", __func__);
130 return HDF_FAILURE;
131 }
132 HDF_LOGE("%s: success", __func__);
133 return HDF_SUCCESS;
134 }
135
CheckRawSdkIfAllocRequest001(void)136 int32_t CheckRawSdkIfAllocRequest001(void)
137 {
138 int32_t i;
139 int32_t ret;
140 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
141
142 ret = AcmWriteBufAlloc(rawAcm);
143 if (ret) {
144 HDF_LOGE("%s: error", __func__);
145 return HDF_FAILURE;
146 }
147
148 for (i = 0; i < ACM_NW; i++) {
149 rawAcm->wb[i].request = UsbRawAllocRequest(NULL, 0, rawAcm->dataOutEp.maxPacketSize);
150 rawAcm->wb[i].instance = rawAcm;
151 if (rawAcm->wb[i].request) {
152 HDF_LOGE("%s: error", __func__);
153 return HDF_FAILURE;
154 }
155 }
156 HDF_LOGE("%s: success", __func__);
157 return HDF_SUCCESS;
158 }
159
CheckRawSdkIfAllocRequest002(void)160 int32_t CheckRawSdkIfAllocRequest002(void)
161 {
162 int32_t i;
163 int32_t ret;
164 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
165
166 ret = AcmWriteBufAlloc(rawAcm);
167 if (ret) {
168 HDF_LOGE("%s: error", __func__);
169 return HDF_FAILURE;
170 }
171
172 for (i = 0; i < ACM_NW; i++) {
173 rawAcm->wb[i].request = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataOutEp.maxPacketSize);
174 rawAcm->wb[i].instance = rawAcm;
175 if (rawAcm->wb[i].request == NULL) {
176 HDF_LOGE("%s: error", __func__);
177 return HDF_FAILURE;
178 }
179 ((struct UsbHostRequest *)(rawAcm->wb[i].request))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
180 }
181 HDF_LOGE("%s: success", __func__);
182 return HDF_SUCCESS;
183 }
184
CheckRawSdkIfAllocRequest003(void)185 int32_t CheckRawSdkIfAllocRequest003(void)
186 {
187 int32_t i;
188 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
189
190 for (i = 0; i < ACM_NR; i++) {
191 rawAcm->readReq[i] = UsbRawAllocRequest(NULL, 0, rawAcm->dataInEp.maxPacketSize);
192 if (rawAcm->readReq[i]) {
193 HDF_LOGE("%s: error", __func__);
194 return HDF_FAILURE;
195 }
196 }
197 HDF_LOGE("%s: success", __func__);
198 return HDF_SUCCESS;
199 }
200
CheckRawSdkIfAllocRequest004(void)201 int32_t CheckRawSdkIfAllocRequest004(void)
202 {
203 int32_t i;
204 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
205
206 for (i = 0; i < ACM_NR; i++) {
207 rawAcm->readReq[i] = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataInEp.maxPacketSize);
208 if (rawAcm->readReq[i] == NULL) {
209 HDF_LOGE("%s: error", __func__);
210 return HDF_FAILURE;
211 }
212 ((struct UsbHostRequest *)(rawAcm->readReq[i]))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
213 }
214 HDF_LOGE("%s: success", __func__);
215 return HDF_SUCCESS;
216 }
217
CheckRawSdkIfAllocRequest005(void)218 int32_t CheckRawSdkIfAllocRequest005(void)
219 {
220 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
221 rawAcm->ctrlReq = UsbRawAllocRequest(NULL, 0, USB_CTRL_REQ_SIZE);
222 if (rawAcm->ctrlReq) {
223 HDF_LOGE("%s: error", __func__);
224 return HDF_FAILURE;
225 }
226 HDF_LOGE("%s: success", __func__);
227 return HDF_SUCCESS;
228 }
229
CheckRawSdkIfAllocRequest006(void)230 int32_t CheckRawSdkIfAllocRequest006(void)
231 {
232 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
233 rawAcm->ctrlReq = UsbRawAllocRequest(rawAcm->devHandle, 0, USB_CTRL_REQ_SIZE);
234 if (rawAcm->ctrlReq == NULL) {
235 HDF_LOGE("%s: error", __func__);
236 return HDF_FAILURE;
237 }
238 ((struct UsbHostRequest *)(rawAcm->ctrlReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
239 HDF_LOGE("%s: success", __func__);
240 return HDF_SUCCESS;
241 }
242
CheckRawSdkIfAllocRequest007(void)243 int32_t CheckRawSdkIfAllocRequest007(void)
244 {
245 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
246 rawAcm->notifyReq = UsbRawAllocRequest(NULL, 0, rawAcm->notifyEp.maxPacketSize);
247 if (rawAcm->notifyReq) {
248 HDF_LOGE("%s: error", __func__);
249 return HDF_FAILURE;
250 }
251 HDF_LOGE("%s: success", __func__);
252 return HDF_SUCCESS;
253 }
254
CheckRawSdkIfAllocRequest008(void)255 int32_t CheckRawSdkIfAllocRequest008(void)
256 {
257 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
258 rawAcm->notifyReq = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->notifyEp.maxPacketSize);
259 if (rawAcm->notifyReq == NULL) {
260 HDF_LOGE("%s: error", __func__);
261 return HDF_FAILURE;
262 }
263 ((struct UsbHostRequest *)(rawAcm->notifyReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
264 HDF_LOGE("%s: success", __func__);
265 return HDF_SUCCESS;
266 }
CheckRawSdkIfAllocRequest010(void)267 int32_t CheckRawSdkIfAllocRequest010(void)
268 {
269 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
270 rawAcm->isoReq = UsbRawAllocRequest(NULL, USB_ISO_PACKAT_CNT, rawAcm->isoEp.maxPacketSize);
271 if (rawAcm->isoReq == NULL) {
272 HDF_LOGE("%s: error", __func__);
273 return HDF_FAILURE;
274 }
275 ((struct UsbHostRequest *)(rawAcm->isoReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
276 HDF_LOGE("%s: success", __func__);
277 return HDF_SUCCESS;
278 }
CheckRawSdkIfAllocRequest011(void)279 int32_t CheckRawSdkIfAllocRequest011(void)
280 {
281 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
282 rawAcm->isoReq = UsbRawAllocRequest(rawAcm->devHandle, USB_ISO_PACKAT_CNT, rawAcm->isoEp.maxPacketSize);
283 if (rawAcm->isoReq == NULL) {
284 HDF_LOGE("%s: error", __func__);
285 return HDF_FAILURE;
286 }
287 ((struct UsbHostRequest *)(rawAcm->isoReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle;
288 HDF_LOGE("%s: success", __func__);
289 return HDF_SUCCESS;
290 }
291
CheckRawSdkIfFreeRequest006(void)292 int32_t CheckRawSdkIfFreeRequest006(void)
293 {
294 int32_t ret;
295 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
296
297 ret = UsbRawFreeRequest(rawAcm->isoReq);
298 if (ret != HDF_ERR_INVALID_PARAM) {
299 HDF_LOGE("%s: error", __func__);
300 return HDF_FAILURE;
301 }
302 rawAcm->isoReq = NULL;
303 HDF_LOGE("%s: success", __func__);
304 return HDF_SUCCESS;
305 }
306
CheckRawSdkIfFillIsoRequest001(void)307 int32_t CheckRawSdkIfFillIsoRequest001(void)
308 {
309 struct UsbRawFillRequestData reqData;
310 int32_t ret;
311 int32_t i;
312 uint32_t size;
313 char sendData[] = {"abcde\0"};
314 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
315 size = strlen(sendData) + 1;
316 printf("---size:%u\n", size);
317 size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
318 for (i = 0; i < 1; i++) {
319 reqData.endPoint = rawAcm->isoEp.addr;
320 reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
321 reqData.callback = AcmWriteIsoCallback;
322 reqData.timeout = USB_CTRL_SET_TIMEOUT;
323 reqData.buffer = (unsigned char*)sendData;
324 reqData.length = size;
325 ret = UsbRawFillIsoRequest(rawAcm->isoReq, rawAcm->devHandle, &reqData);
326 if (ret) {
327 printf("%s: error++ret=%d\n", __func__, ret);
328 return HDF_FAILURE;
329 }
330 }
331 HDF_LOGE("%s: success", __func__);
332 return HDF_SUCCESS;
333 }
334
CheckRawSdkIfFillIsoRequest002(void)335 int32_t CheckRawSdkIfFillIsoRequest002(void)
336 {
337 struct UsbRawFillRequestData reqData;
338 int32_t ret;
339 int32_t i;
340 uint32_t size;
341 char sendData[] = {"abcde\0"};
342 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
343 size = strlen(sendData) + 1;
344 printf("---size:%u\n", size);
345 size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
346 for (i = 0; i < 1; i++) {
347 reqData.endPoint = rawAcm->isoEp.addr;
348 reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
349 reqData.callback = AcmWriteIsoCallback;
350 reqData.timeout = USB_CTRL_SET_TIMEOUT;
351 reqData.buffer = (unsigned char*)sendData;
352 reqData.length = size;
353 ret = UsbRawFillIsoRequest(NULL, rawAcm->devHandle, &reqData);
354 if (ret) {
355 printf("%s: error++ret=%d\n", __func__, ret);
356 return HDF_FAILURE;
357 }
358 }
359 HDF_LOGE("%s: success", __func__);
360 return HDF_SUCCESS;
361 }
362
CheckRawSdkIfFillIsoRequest003(void)363 int32_t CheckRawSdkIfFillIsoRequest003(void)
364 {
365 struct UsbRawFillRequestData reqData;
366 int32_t ret;
367 int32_t i;
368 uint32_t size;
369 char sendData[] = {"abcde\0"};
370 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
371 size = strlen(sendData) + 1;
372 printf("---size:%u\n", size);
373 size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
374 for (i = 0; i < 1; i++) {
375 reqData.endPoint = rawAcm->isoEp.addr;
376 reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
377 reqData.callback = AcmWriteIsoCallback;
378 reqData.timeout = USB_CTRL_SET_TIMEOUT;
379 reqData.buffer = (unsigned char*)sendData;
380 reqData.length = size;
381 ret = UsbRawFillIsoRequest(rawAcm->isoReq, rawAcm->devHandle, NULL);
382 if (ret) {
383 printf("%s: error++ret=%d\n", __func__, ret);
384 return HDF_FAILURE;
385 }
386 }
387 HDF_LOGE("%s: success", __func__);
388 return HDF_SUCCESS;
389 }
390
CheckRawSdkIfFillIsoRequest004(void)391 int32_t CheckRawSdkIfFillIsoRequest004(void)
392 {
393 struct UsbRawFillRequestData reqData;
394 int32_t ret;
395 int32_t i;
396 uint32_t size;
397 char sendData[] = {"abcde\0"};
398 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
399 size = strlen(sendData) + 1;
400 printf("---size:%u\n", size);
401 size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
402 for (i = 0; i < 1; i++) {
403 reqData.endPoint = rawAcm->isoEp.addr;
404 reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
405 reqData.callback = AcmWriteIsoCallback;
406 reqData.timeout = USB_CTRL_SET_TIMEOUT;
407 reqData.buffer = (unsigned char*)sendData;
408 reqData.length = size;
409 ret = UsbRawFillIsoRequest(rawAcm->isoReq, NULL, &reqData);
410 if (ret) {
411 printf("%s: error++ret=%d\n", __func__, ret);
412 return HDF_FAILURE;
413 }
414 }
415 HDF_LOGE("%s: success", __func__);
416 return HDF_SUCCESS;
417 }
418
CheckRawSdkIfFillIsoRequest005(void)419 int32_t CheckRawSdkIfFillIsoRequest005(void)
420 {
421 struct UsbRawFillRequestData reqData;
422 int32_t ret;
423 int32_t i;
424 uint32_t size;
425 char sendData[] = {"abcde\0"};
426 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
427 size = strlen(sendData) + 1;
428 printf("---size:%u\n", size);
429 size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
430 for (i = 0; i < 1; i++) {
431 reqData.endPoint = rawAcm->isoEp.addr;
432 reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
433 reqData.callback = AcmWriteIsoCallback;
434 reqData.timeout = USB_CTRL_SET_TIMEOUT;
435 reqData.buffer = (unsigned char*)sendData;
436 reqData.length = size;
437 ret = UsbRawFillIsoRequest(NULL, NULL, &reqData);
438 if (ret) {
439 printf("%s: error++ret=%d\n", __func__, ret);
440 return HDF_FAILURE;
441 }
442 }
443 HDF_LOGE("%s: success", __func__);
444 return HDF_SUCCESS;
445 }
446
CheckRawSdkIfFillIsoRequest006(void)447 int32_t CheckRawSdkIfFillIsoRequest006(void)
448 {
449 struct UsbRawFillRequestData reqData;
450 int32_t ret;
451 int32_t i;
452 uint32_t size;
453 char sendData[] = {"abcde\0"};
454 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
455 size = strlen(sendData) + 1;
456 printf("---size:%u\n", size);
457 size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size;
458 for (i = 0; i < 1; i++) {
459 reqData.endPoint = rawAcm->isoEp.addr;
460 reqData.numIsoPackets = USB_ISO_PACKAT_CNT;
461 reqData.callback = AcmWriteIsoCallback;
462 reqData.timeout = USB_CTRL_SET_TIMEOUT;
463 reqData.buffer = (unsigned char*)sendData;
464 reqData.length = size;
465 ret = UsbRawFillIsoRequest(NULL, NULL, NULL);
466 if (ret) {
467 printf("%s: error++ret=%d\n", __func__, ret);
468 return HDF_FAILURE;
469 }
470 }
471 HDF_LOGE("%s: success", __func__);
472 return HDF_SUCCESS;
473 }
CheckRawSdkIfFreeRequest001(void)474 int32_t CheckRawSdkIfFreeRequest001(void)
475 {
476 int32_t ret;
477 int32_t i;
478 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
479
480 for (i = 0; i < ACM_NW; i++) {
481 ret = UsbRawFreeRequest(rawAcm->wb[i].request);
482 if (ret) {
483 HDF_LOGE("%s: error", __func__);
484 return HDF_FAILURE;
485 }
486 rawAcm->wb[i].request = NULL;
487 }
488 AcmWriteBufFree(rawAcm);
489 HDF_LOGE("%s: success", __func__);
490 return HDF_SUCCESS;
491 }
492
CheckRawSdkIfFreeRequest002(void)493 int32_t CheckRawSdkIfFreeRequest002(void)
494 {
495 int32_t ret;
496 int32_t i;
497 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
498
499 for (i = 0; i < ACM_NW; i++) {
500 ret = UsbRawFreeRequest(rawAcm->readReq[i]);
501 if (ret) {
502 HDF_LOGE("%s: error", __func__);
503 return HDF_FAILURE;
504 }
505 rawAcm->readReq[i] = NULL;
506 }
507 HDF_LOGE("%s: success", __func__);
508 return HDF_SUCCESS;
509 }
510
CheckRawSdkIfFreeRequest003(void)511 int32_t CheckRawSdkIfFreeRequest003(void)
512 {
513 int32_t ret;
514 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
515
516 ret = UsbRawFreeRequest(rawAcm->ctrlReq);
517 if (ret) {
518 HDF_LOGE("%s: error", __func__);
519 return HDF_FAILURE;
520 }
521 rawAcm->ctrlReq = NULL;
522 HDF_LOGE("%s: success", __func__);
523 return HDF_SUCCESS;
524 }
525
CheckRawSdkIfFreeRequest004(void)526 int32_t CheckRawSdkIfFreeRequest004(void)
527 {
528 int32_t ret;
529 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
530
531 ret = UsbRawFreeRequest(rawAcm->notifyReq);
532 if (ret) {
533 HDF_LOGE("%s: error", __func__);
534 return HDF_FAILURE;
535 }
536 rawAcm->notifyReq = NULL;
537 HDF_LOGE("%s: success", __func__);
538 return HDF_SUCCESS;
539 }
540
CheckRawSdkIfFreeRequest005(void)541 int32_t CheckRawSdkIfFreeRequest005(void)
542 {
543 int32_t ret;
544
545 ret = UsbRawFreeRequest(NULL);
546 if (ret != HDF_ERR_INVALID_PARAM) {
547 HDF_LOGE("%s: error", __func__);
548 return HDF_FAILURE;
549 }
550 HDF_LOGE("%s: success", __func__);
551 return HDF_SUCCESS;
552 }
553
CheckRawSdkIfAllocRequest009(void)554 int32_t CheckRawSdkIfAllocRequest009(void)
555 {
556 int32_t i;
557 int32_t ret;
558 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
559
560 ret = AcmWriteBufAlloc(rawAcm);
561 if (ret) {
562 HDF_LOGE("%s: error", __func__);
563 return HDF_FAILURE;
564 }
565
566 for (i = 0; i < ACM_NW; i++) {
567 rawAcm->wb[i].request = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataOutEp.maxPacketSize);
568 rawAcm->wb[i].instance = rawAcm;
569 if (rawAcm->wb[i].request == NULL) {
570 HDF_LOGE("%s: error", __func__);
571 return HDF_FAILURE;
572 }
573 }
574
575 for (i = 0; i < ACM_NR; i++) {
576 rawAcm->readReq[i] = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataInEp.maxPacketSize);
577 if (rawAcm->readReq[i] == NULL) {
578 HDF_LOGE("%s: error", __func__);
579 return HDF_FAILURE;
580 }
581 }
582
583 rawAcm->ctrlReq = UsbRawAllocRequest(rawAcm->devHandle, 0, USB_CTRL_REQ_SIZE);
584 if (rawAcm->ctrlReq == NULL) {
585 HDF_LOGE("%s: error", __func__);
586 return HDF_FAILURE;
587 }
588
589 rawAcm->notifyReq = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->notifyEp.maxPacketSize);
590 if (rawAcm->notifyReq == NULL) {
591 HDF_LOGE("%s: error", __func__);
592 return HDF_FAILURE;
593 }
594 HDF_LOGE("%s: success", __func__);
595 return HDF_SUCCESS;
596 }
597
CheckRawSdkIfGetDescriptor001(void)598 int32_t CheckRawSdkIfGetDescriptor001(void)
599 {
600 struct UsbRawDescriptorParam param;
601 unsigned char *data = NULL;
602 int32_t ret;
603 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
604
605 data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
606 if (data == NULL) {
607 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
608 return HDF_ERR_MALLOC_FAIL;
609 }
610
611 ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, ¶m, data);
612 if (ret != HDF_ERR_INVALID_PARAM) {
613 HDF_LOGE("%s: error", __func__);
614 ret = HDF_FAILURE;
615 goto ERROR;
616 }
617 HDF_LOGE("%s: success", __func__);
618 ret = HDF_SUCCESS;
619 ERROR:
620 OsalMemFree(data);
621 data = NULL;
622
623 return ret;
624 }
625
CheckRawSdkIfGetDescriptor002(void)626 int32_t CheckRawSdkIfGetDescriptor002(void)
627 {
628 struct UsbRawDescriptorParam param;
629 unsigned char *data = NULL;
630 int32_t ret;
631 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
632
633 data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
634 if (data == NULL) {
635 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
636 return HDF_ERR_MALLOC_FAIL;
637 }
638
639 ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, ¶m, data);
640 if (ret != HDF_ERR_INVALID_PARAM) {
641 HDF_LOGE("%s: error", __func__);
642 ret = HDF_FAILURE;
643 goto ERROR;
644 }
645 HDF_LOGE("%s: success", __func__);
646 ret = HDF_SUCCESS;
647 ERROR:
648 OsalMemFree(data);
649 data = NULL;
650
651 return ret;
652 }
653
CheckRawSdkIfGetDescriptor003(void)654 int32_t CheckRawSdkIfGetDescriptor003(void)
655 {
656 struct UsbRawDescriptorParam param;
657 unsigned char *data = NULL;
658 int32_t ret;
659
660 data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
661 if (data == NULL) {
662 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
663 return HDF_ERR_MALLOC_FAIL;
664 }
665
666 ret = UsbRawGetDescriptor(NULL, NULL, ¶m, data);
667 if (ret != HDF_ERR_INVALID_PARAM) {
668 HDF_LOGE("%s: error", __func__);
669 ret = HDF_FAILURE;
670 goto ERROR;
671 }
672 HDF_LOGE("%s: success", __func__);
673 ret = HDF_SUCCESS;
674 ERROR:
675 OsalMemFree(data);
676 data = NULL;
677
678 return ret;
679 }
680
CheckRawSdkIfGetDescriptor004(void)681 int32_t CheckRawSdkIfGetDescriptor004(void)
682 {
683 unsigned char *data = NULL;
684 int32_t ret;
685 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
686
687 data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
688 if (data == NULL) {
689 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
690 return HDF_ERR_MALLOC_FAIL;
691 }
692
693 ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, NULL, data);
694 if (ret != HDF_ERR_INVALID_PARAM) {
695 HDF_LOGE("%s: error", __func__);
696 ret = HDF_FAILURE;
697 goto ERROR;
698 }
699 HDF_LOGE("%s: success", __func__);
700 ret = HDF_SUCCESS;
701 ERROR:
702 OsalMemFree(data);
703 data = NULL;
704
705 return ret;
706 }
707
CheckRawSdkIfGetDescriptor005(void)708 int32_t CheckRawSdkIfGetDescriptor005(void)
709 {
710 struct UsbRawDescriptorParam param;
711 int32_t ret;
712 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
713
714 ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, ¶m, NULL);
715 if (ret != HDF_ERR_INVALID_PARAM) {
716 HDF_LOGE("%s: error", __func__);
717 return HDF_FAILURE;
718 }
719 HDF_LOGE("%s: success", __func__);
720 return HDF_SUCCESS;
721 }
722
CheckRawSdkIfGetDescriptor006(void)723 int32_t CheckRawSdkIfGetDescriptor006(void)
724 {
725 struct UsbRawDescriptorParam param;
726 unsigned char *data = NULL;
727 int32_t ret;
728 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
729
730 data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
731 if (data == NULL) {
732 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
733 return HDF_ERR_MALLOC_FAIL;
734 }
735
736 param.descType = USB_DESC_TYPE;
737 param.descIndex = 0;
738 param.length = USB_BUFFER_MAX_SIZE;
739
740 ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, ¶m, data);
741 if (ret < 0) {
742 HDF_LOGE("%s: error", __func__);
743 ret = HDF_FAILURE;
744 goto ERROR;
745 }
746 HDF_LOGE("%s: success", __func__);
747 ret = HDF_SUCCESS;
748 ERROR:
749 OsalMemFree(data);
750 data = NULL;
751
752 return ret;
753 }
754
CheckRawSdkIfGetDescriptor007(void)755 int32_t CheckRawSdkIfGetDescriptor007(void)
756 {
757 unsigned char *data = NULL;
758 int32_t ret;
759 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
760
761 data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
762 if (data == NULL) {
763 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
764 return HDF_ERR_MALLOC_FAIL;
765 }
766
767 ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, NULL, data);
768 if (ret != HDF_ERR_INVALID_PARAM) {
769 HDF_LOGE("%s: error", __func__);
770 ret = HDF_FAILURE;
771 goto ERROR;
772 }
773 HDF_LOGE("%s: success", __func__);
774 ret = HDF_SUCCESS;
775 ERROR:
776 OsalMemFree(data);
777 data = NULL;
778
779 return ret;
780 }
781
CheckRawSdkIfGetDescriptor008(void)782 int32_t CheckRawSdkIfGetDescriptor008(void)
783 {
784 int32_t ret;
785 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
786
787 ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, NULL, NULL);
788 if (ret != HDF_ERR_INVALID_PARAM) {
789 HDF_LOGE("%s: error", __func__);
790 return HDF_FAILURE;
791 }
792 HDF_LOGE("%s: success", __func__);
793 return HDF_SUCCESS;
794 }
795
CheckRawSdkIfGetDescriptor009(void)796 int32_t CheckRawSdkIfGetDescriptor009(void)
797 {
798 unsigned char *data = NULL;
799 int32_t ret;
800 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
801
802 data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
803 if (data == NULL) {
804 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
805 return HDF_ERR_MALLOC_FAIL;
806 }
807
808 ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, NULL, data);
809 if (ret != HDF_ERR_INVALID_PARAM) {
810 HDF_LOGE("%s: error", __func__);
811 ret = HDF_FAILURE;
812 goto ERROR;
813 }
814 HDF_LOGE("%s: success", __func__);
815 ret = HDF_SUCCESS;
816 ERROR:
817 OsalMemFree(data);
818 data = NULL;
819
820 return ret;
821 }
822
CheckRawSdkIfGetDescriptor010(void)823 int32_t CheckRawSdkIfGetDescriptor010(void)
824 {
825 struct UsbRawDescriptorParam param;
826 unsigned char data[100];
827 int32_t ret;
828 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
829
830 param.descType = 0;
831 param.descIndex = 0;
832 param.length = sizeof(data);
833
834 ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, ¶m, NULL);
835 if (ret != HDF_ERR_INVALID_PARAM) {
836 HDF_LOGE("%s: error", __func__);
837 return HDF_FAILURE;
838 }
839 HDF_LOGE("%s: success", __func__);
840 return HDF_SUCCESS;
841 }
842
CheckRawSdkIfGetDescriptor011(void)843 int32_t CheckRawSdkIfGetDescriptor011(void)
844 {
845 struct UsbRawDescriptorParam param;
846 unsigned char data[100];
847 int32_t ret;
848 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
849
850 param.descType = 0;
851 param.descIndex = 0;
852 param.length = sizeof(data);
853
854 ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, ¶m, NULL);
855 if (ret != HDF_ERR_INVALID_PARAM) {
856 HDF_LOGE("%s: error", __func__);
857 return HDF_FAILURE;
858 }
859 HDF_LOGE("%s: success", __func__);
860 return HDF_SUCCESS;
861 }
862
CheckRawSdkIfGetDescriptor012(void)863 int32_t CheckRawSdkIfGetDescriptor012(void)
864 {
865 unsigned char *data = NULL;
866 int32_t ret;
867
868 data = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
869 if (data == NULL) {
870 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
871 return HDF_ERR_MALLOC_FAIL;
872 }
873
874 ret = UsbRawGetDescriptor(NULL, NULL, NULL, data);
875 if (ret != HDF_ERR_INVALID_PARAM) {
876 HDF_LOGE("%s: error", __func__);
877 ret = HDF_FAILURE;
878 goto ERROR;
879 }
880 HDF_LOGE("%s: success", __func__);
881 ret = HDF_SUCCESS;
882 ERROR:
883 OsalMemFree(data);
884 data = NULL;
885
886 return ret;
887 }
888
CheckRawSdkIfGetDescriptor013(void)889 int32_t CheckRawSdkIfGetDescriptor013(void)
890 {
891 struct UsbRawDescriptorParam param;
892 unsigned char data[100];
893 int32_t ret;
894
895 param.descType = 0;
896 param.descIndex = 0;
897 param.length = sizeof(data);
898
899 ret = UsbRawGetDescriptor(NULL, NULL, ¶m, NULL);
900 if (ret != HDF_ERR_INVALID_PARAM) {
901 HDF_LOGE("%s: error", __func__);
902 return HDF_FAILURE;
903 }
904 HDF_LOGE("%s: success", __func__);
905 return HDF_SUCCESS;
906 }
907
CheckRawSdkIfGetDescriptor014(void)908 int32_t CheckRawSdkIfGetDescriptor014(void)
909 {
910 int32_t ret;
911 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
912
913 ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, NULL, NULL);
914 if (ret != HDF_ERR_INVALID_PARAM) {
915 HDF_LOGE("%s: error", __func__);
916 return HDF_FAILURE;
917 }
918 HDF_LOGE("%s: success", __func__);
919 return HDF_SUCCESS;
920 }
921
CheckRawSdkIfGetDescriptor015(void)922 int32_t CheckRawSdkIfGetDescriptor015(void)
923 {
924 int32_t ret;
925 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
926
927 ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, NULL, NULL);
928 if (ret != HDF_ERR_INVALID_PARAM) {
929 HDF_LOGE("%s: error", __func__);
930 return HDF_FAILURE;
931 }
932 HDF_LOGE("%s: success", __func__);
933 return HDF_SUCCESS;
934 }
935
CheckRawSdkIfGetDescriptor016(void)936 int32_t CheckRawSdkIfGetDescriptor016(void)
937 {
938 int32_t ret;
939
940 ret = UsbRawGetDescriptor(NULL, NULL, NULL, NULL);
941 if (ret != HDF_ERR_INVALID_PARAM) {
942 HDF_LOGE("%s: error", __func__);
943 return HDF_FAILURE;
944 }
945 HDF_LOGE("%s: success", __func__);
946 return HDF_SUCCESS;
947 }
948
CheckRawSdkIfFillBulkRequest001(void)949 int32_t CheckRawSdkIfFillBulkRequest001(void)
950 {
951 struct UsbRawFillRequestData reqData;
952 int32_t ret;
953 int32_t i;
954 uint32_t size;
955 char sendData[] = {"abcde\0"};
956 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
957
958 size = strlen(sendData) + 1;
959 printf("---size:%u\n", size);
960
961 size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size;
962 for (i = 0; i < 1; i++) {
963 struct RawWb *snd = &rawAcm->wb[i];
964 snd->len = (int)size;
965 ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size);
966 if (ret) {
967 HDF_LOGE("%s: memcpy_s fail", __func__);
968 return HDF_FAILURE;
969 }
970 rawAcm->transmitting++;
971
972 reqData.endPoint = rawAcm->dataOutEp.addr;
973 reqData.numIsoPackets = 0;
974 reqData.callback = AcmWriteBulkCallback;
975 reqData.userData = (void *)snd;
976 reqData.timeout = USB_CTRL_SET_TIMEOUT;
977 reqData.buffer = snd->buf;
978 reqData.length = snd->len;
979 printf("maxPacketSize:%d\n", rawAcm->dataOutEp.maxPacketSize);
980 ret = UsbRawFillBulkRequest(snd->request, rawAcm->devHandle, &reqData);
981 if (ret) {
982 printf("%s: error++ret=%d\n", __func__, ret);
983 return HDF_FAILURE;
984 }
985 }
986 HDF_LOGE("%s: success", __func__);
987 return HDF_SUCCESS;
988 }
989
CheckRawSdkIfFillBulkRequest002(void)990 int32_t CheckRawSdkIfFillBulkRequest002(void)
991 {
992 struct UsbRawFillRequestData reqData;
993 int32_t ret;
994 int32_t i;
995 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
996 uint32_t size = rawAcm->dataInEp.maxPacketSize;
997
998 for (i = 0; i < 1; i++) {
999 reqData.endPoint = rawAcm->dataInEp.addr;
1000 reqData.numIsoPackets = 0;
1001 reqData.callback = AcmReadBulkCallback;
1002 reqData.userData = (void *)rawAcm;
1003 reqData.timeout = USB_CTRL_SET_TIMEOUT;
1004 reqData.length = size;
1005
1006 ret = UsbRawFillBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData);
1007 if (ret) {
1008 HDF_LOGE("%s: error", __func__);
1009 return HDF_FAILURE;
1010 }
1011 }
1012 HDF_LOGE("%s: success", __func__);
1013 return HDF_SUCCESS;
1014 }
1015
CheckRawSdkIfFillInterruptRequest001(void)1016 int32_t CheckRawSdkIfFillInterruptRequest001(void)
1017 {
1018 struct UsbRawFillRequestData fillRequestData;
1019 int32_t ret;
1020 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1021 uint32_t size = rawAcm->notifyEp.maxPacketSize;
1022
1023 fillRequestData.endPoint = rawAcm->notifyEp.addr;
1024 fillRequestData.length = size;
1025 fillRequestData.numIsoPackets = 0;
1026 fillRequestData.callback = AcmNotifyReqCallback;
1027 fillRequestData.userData = (void *)rawAcm;
1028 fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1029
1030 ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &fillRequestData);
1031 if (ret) {
1032 HDF_LOGE("%s: error", __func__);
1033 return HDF_FAILURE;
1034 }
1035 HDF_LOGE("%s: success", __func__);
1036 return HDF_SUCCESS;
1037 }
1038
CheckRawSdkIfFillInterruptRequest002(void)1039 int32_t CheckRawSdkIfFillInterruptRequest002(void)
1040 {
1041 struct UsbRawFillRequestData fillRequestData;
1042 int32_t ret;
1043 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1044 uint32_t size = rawAcm->notifyEp.maxPacketSize;
1045
1046 fillRequestData.endPoint = rawAcm->notifyEp.addr;
1047 fillRequestData.length = size;
1048 fillRequestData.numIsoPackets = 0;
1049 fillRequestData.callback = AcmNotifyReqCallback;
1050 fillRequestData.userData = (void *)rawAcm;
1051 fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1052
1053 ret = UsbRawFillInterruptRequest(NULL, rawAcm->devHandle, &fillRequestData);
1054 if (ret != HDF_ERR_INVALID_PARAM) {
1055 HDF_LOGE("%s: error", __func__);
1056 return HDF_FAILURE;
1057 }
1058 HDF_LOGE("%s: success", __func__);
1059 return HDF_SUCCESS;
1060 }
1061
CheckRawSdkIfFillInterruptRequest003(void)1062 int32_t CheckRawSdkIfFillInterruptRequest003(void)
1063 {
1064 struct UsbRawFillRequestData fillRequestData;
1065 int32_t ret;
1066 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1067 uint32_t size = rawAcm->notifyEp.maxPacketSize;
1068
1069 fillRequestData.endPoint = rawAcm->notifyEp.addr;
1070 fillRequestData.length = size;
1071 fillRequestData.numIsoPackets = 0;
1072 fillRequestData.callback = AcmNotifyReqCallback;
1073 fillRequestData.userData = (void *)rawAcm;
1074 fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1075
1076 ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, NULL, &fillRequestData);
1077 if (ret != HDF_ERR_INVALID_PARAM) {
1078 HDF_LOGE("%s: error", __func__);
1079 return HDF_FAILURE;
1080 }
1081 HDF_LOGE("%s: success", __func__);
1082 return HDF_SUCCESS;
1083 }
1084
CheckRawSdkIfFillInterruptRequest004(void)1085 int32_t CheckRawSdkIfFillInterruptRequest004(void)
1086 {
1087 struct UsbRawFillRequestData fillRequestData;
1088 int32_t ret;
1089 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1090 uint32_t size = rawAcm->notifyEp.maxPacketSize;
1091
1092 fillRequestData.endPoint = rawAcm->notifyEp.addr;
1093 fillRequestData.length = size;
1094 fillRequestData.numIsoPackets = 0;
1095 fillRequestData.callback = AcmNotifyReqCallback;
1096 fillRequestData.userData = (void *)rawAcm;
1097 fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1098
1099 ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, NULL);
1100 if (ret != HDF_ERR_INVALID_PARAM) {
1101 HDF_LOGE("%s: error", __func__);
1102 return HDF_FAILURE;
1103 }
1104 HDF_LOGE("%s: success", __func__);
1105 return HDF_SUCCESS;
1106 }
1107
CheckRawSdkIfFillControlRequest001(void)1108 int32_t CheckRawSdkIfFillControlRequest001(void)
1109 {
1110 struct UsbRawFillRequestData fillRequestData;
1111 int32_t ret;
1112 int32_t completed = 0;
1113 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1114
1115 fillRequestData.callback = AcmCtrlReqCallback;
1116 fillRequestData.userData = &completed;
1117 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1118
1119 ret = UsbRawFillControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, &fillRequestData);
1120 if (ret) {
1121 HDF_LOGE("%s: error", __func__);
1122 return HDF_FAILURE;
1123 }
1124 HDF_LOGE("%s: success", __func__);
1125 return HDF_SUCCESS;
1126 }
1127
CheckRawSdkIfFillControlRequest002(void)1128 int32_t CheckRawSdkIfFillControlRequest002(void)
1129 {
1130 struct UsbRawFillRequestData fillRequestData;
1131 int32_t ret;
1132 int32_t completed = 0;
1133 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1134
1135 fillRequestData.callback = AcmCtrlReqCallback;
1136 fillRequestData.userData = &completed;
1137 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1138
1139 ret = UsbRawFillControlRequest(NULL, rawAcm->devHandle, &fillRequestData);
1140 if (ret != HDF_ERR_INVALID_PARAM) {
1141 HDF_LOGE("%s: error", __func__);
1142 return HDF_FAILURE;
1143 }
1144 HDF_LOGE("%s: success", __func__);
1145 return HDF_SUCCESS;
1146 }
1147
CheckRawSdkIfFillControlRequest003(void)1148 int32_t CheckRawSdkIfFillControlRequest003(void)
1149 {
1150 struct UsbRawFillRequestData fillRequestData;
1151 int32_t ret;
1152 int32_t completed = 0;
1153 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1154
1155 fillRequestData.callback = AcmCtrlReqCallback;
1156 fillRequestData.userData = &completed;
1157 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1158
1159 ret = UsbRawFillControlRequest(rawAcm->ctrlReq, NULL, &fillRequestData);
1160 if (ret != HDF_ERR_INVALID_PARAM) {
1161 HDF_LOGE("%s: error", __func__);
1162 return HDF_FAILURE;
1163 }
1164 HDF_LOGE("%s: success", __func__);
1165 return HDF_SUCCESS;
1166 }
1167
CheckRawSdkIfFillControlRequest004(void)1168 int32_t CheckRawSdkIfFillControlRequest004(void)
1169 {
1170 struct UsbRawFillRequestData fillRequestData;
1171 int32_t ret;
1172 int32_t completed = 0;
1173 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1174
1175 fillRequestData.callback = AcmCtrlReqCallback;
1176 fillRequestData.userData = &completed;
1177 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1178
1179 ret = UsbRawFillControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, NULL);
1180 if (ret != HDF_ERR_INVALID_PARAM) {
1181 HDF_LOGE("%s: error", __func__);
1182 return HDF_FAILURE;
1183 }
1184 HDF_LOGE("%s: success", __func__);
1185 return HDF_SUCCESS;
1186 }
1187
CheckRawSdkIfFillControlRequest005(void)1188 int32_t CheckRawSdkIfFillControlRequest005(void)
1189 {
1190 struct UsbRawFillRequestData fillRequestData;
1191 int32_t ret;
1192 int32_t completed = 0;
1193 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1194
1195 fillRequestData.callback = AcmCtrlReqCallback;
1196 fillRequestData.userData = &completed;
1197 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1198
1199 ret = UsbRawFillControlRequest(NULL, rawAcm->devHandle, NULL);
1200 if (ret != HDF_ERR_INVALID_PARAM) {
1201 HDF_LOGE("%s: error", __func__);
1202 return HDF_FAILURE;
1203 }
1204 HDF_LOGE("%s: success", __func__);
1205 return HDF_SUCCESS;
1206 }
1207
CheckRawSdkIfFillControlRequest006(void)1208 int32_t CheckRawSdkIfFillControlRequest006(void)
1209 {
1210 struct UsbRawFillRequestData fillRequestData;
1211 int32_t ret;
1212 int32_t completed = 0;
1213 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1214
1215 fillRequestData.callback = AcmCtrlReqCallback;
1216 fillRequestData.userData = &completed;
1217 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1218
1219 ret = UsbRawFillControlRequest(rawAcm->ctrlReq, NULL, NULL);
1220 if (ret != HDF_ERR_INVALID_PARAM) {
1221 HDF_LOGE("%s: error", __func__);
1222 return HDF_FAILURE;
1223 }
1224 HDF_LOGE("%s: success", __func__);
1225 return HDF_SUCCESS;
1226 }
1227
CheckRawSdkIfFillControlRequest007(void)1228 int32_t CheckRawSdkIfFillControlRequest007(void)
1229 {
1230 struct UsbRawFillRequestData fillRequestData;
1231 int32_t ret;
1232 int32_t completed = 0;
1233
1234 fillRequestData.callback = AcmCtrlReqCallback;
1235 fillRequestData.userData = &completed;
1236 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1237
1238 ret = UsbRawFillControlRequest(NULL, NULL, NULL);
1239 if (ret != HDF_ERR_INVALID_PARAM) {
1240 HDF_LOGE("%s: error", __func__);
1241 return HDF_FAILURE;
1242 }
1243 HDF_LOGE("%s: success", __func__);
1244 return HDF_SUCCESS;
1245 }
1246
CheckRawSdkIfFillControlRequest008(void)1247 int32_t CheckRawSdkIfFillControlRequest008(void)
1248 {
1249 struct UsbRawFillRequestData fillRequestData;
1250 int32_t ret;
1251 int32_t completed = 0;
1252
1253 fillRequestData.callback = AcmCtrlReqCallback;
1254 fillRequestData.userData = &completed;
1255 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1256
1257 ret = UsbRawFillControlRequest(NULL, NULL, &fillRequestData);
1258 if (ret != HDF_ERR_INVALID_PARAM) {
1259 HDF_LOGE("%s: error", __func__);
1260 return HDF_FAILURE;
1261 }
1262 HDF_LOGE("%s: success", __func__);
1263 return HDF_SUCCESS;
1264 }
1265
CheckRawSdkIfFillControlSetup001(void)1266 int32_t CheckRawSdkIfFillControlSetup001(void)
1267 {
1268 struct UsbControlRequestData ctrlReq;
1269 int32_t ret;
1270 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1271
1272 rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
1273 rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
1274 rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
1275 rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH;
1276
1277 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
1278 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
1279 ctrlReq.value = CpuToLe16(0);
1280 ctrlReq.index = 0;
1281 ctrlReq.data = (unsigned char *)&rawAcm->lineCoding;
1282 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
1283 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
1284
1285 ret = UsbRawFillControlSetup(NULL, &ctrlReq);
1286 if (ret != HDF_ERR_INVALID_PARAM) {
1287 HDF_LOGE("%s: error", __func__);
1288 return HDF_FAILURE;
1289 }
1290 HDF_LOGE("%s: success", __func__);
1291 return HDF_SUCCESS;
1292 }
1293
CheckRawSdkIfFillControlSetup002(void)1294 int32_t CheckRawSdkIfFillControlSetup002(void)
1295 {
1296 unsigned char *setup = NULL;
1297 int32_t ret;
1298
1299 setup = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
1300 if (setup == NULL) {
1301 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
1302 return HDF_ERR_MALLOC_FAIL;
1303 }
1304
1305 ret = UsbRawFillControlSetup(setup, NULL);
1306 if (ret != HDF_ERR_INVALID_PARAM) {
1307 HDF_LOGE("%s: error", __func__);
1308 ret = HDF_FAILURE;
1309 goto ERROR;
1310 }
1311 HDF_LOGE("%s: success", __func__);
1312 ret = HDF_SUCCESS;
1313 ERROR:
1314 OsalMemFree(setup);
1315 setup = NULL;
1316
1317 return ret;
1318 }
1319
CheckRawSdkIfFillControlSetup003(void)1320 int32_t CheckRawSdkIfFillControlSetup003(void)
1321 {
1322 int32_t ret;
1323
1324 ret = UsbRawFillControlSetup(NULL, NULL);
1325 if (ret != HDF_ERR_INVALID_PARAM) {
1326 HDF_LOGE("%s: error", __func__);
1327 return HDF_FAILURE;
1328 }
1329 HDF_LOGE("%s: success", __func__);
1330 return HDF_SUCCESS;
1331 }
1332
CheckRawSdkIfFillControlSetup004(void)1333 int32_t CheckRawSdkIfFillControlSetup004(void)
1334 {
1335 struct UsbControlRequestData ctrlReq;
1336 unsigned char *setup = NULL;
1337 int32_t ret;
1338 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1339
1340 rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
1341 rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
1342 rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
1343 rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH;
1344
1345 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
1346 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
1347 ctrlReq.value = CpuToLe16(0);
1348 ctrlReq.index = 0;
1349 ctrlReq.data = (unsigned char *)&rawAcm->lineCoding;
1350 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
1351 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
1352
1353 setup = OsalMemCalloc(USB_BUFFER_MAX_SIZE);
1354 if (setup == NULL) {
1355 HDF_LOGE("%s:%d OsalMemCalloc error", __func__, __LINE__);
1356 return HDF_ERR_MALLOC_FAIL;
1357 }
1358
1359 ret = UsbRawFillControlSetup(setup, &ctrlReq);
1360 if (ret) {
1361 HDF_LOGE("%s: error", __func__);
1362 ret = HDF_FAILURE;
1363 goto ERROR;
1364 }
1365 HDF_LOGE("%s: success", __func__);
1366
1367 ERROR:
1368 OsalMemFree(setup);
1369 setup = NULL;
1370
1371 return ret;
1372 }
1373
CheckRawSdkIfSendControlRequest001(void)1374 int32_t CheckRawSdkIfSendControlRequest001(void)
1375 {
1376 struct UsbControlRequestData ctrlReq;
1377 int32_t ret;
1378 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1379
1380 rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
1381 rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
1382 rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
1383 rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH;
1384 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
1385 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
1386 ctrlReq.value = CpuToLe16(0);
1387 ctrlReq.index = 0;
1388 ctrlReq.data = (unsigned char *)&rawAcm->lineCoding;
1389 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
1390 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
1391
1392 ret = UsbRawSendControlRequest(NULL, rawAcm->devHandle, &ctrlReq);
1393 if (ret != HDF_ERR_INVALID_PARAM) {
1394 HDF_LOGE("%s: error", __func__);
1395 return HDF_FAILURE;
1396 }
1397 HDF_LOGE("%s: success", __func__);
1398 return HDF_SUCCESS;
1399 }
1400
CheckRawSdkIfSendControlRequest002(void)1401 int32_t CheckRawSdkIfSendControlRequest002(void)
1402 {
1403 struct UsbControlRequestData ctrlReq;
1404 int32_t ret;
1405 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1406
1407 rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
1408 rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
1409 rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
1410 rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH;
1411 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
1412 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
1413 ctrlReq.value = CpuToLe16(0);
1414 ctrlReq.index = 0;
1415 ctrlReq.data = (unsigned char *)&rawAcm->lineCoding;
1416 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
1417 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
1418
1419 ret = UsbRawSendControlRequest(rawAcm->ctrlReq, NULL, &ctrlReq);
1420 if (ret != HDF_ERR_INVALID_PARAM) {
1421 HDF_LOGE("%s: error", __func__);
1422 return HDF_FAILURE;
1423 }
1424 HDF_LOGE("%s: success", __func__);
1425 return HDF_SUCCESS;
1426 }
1427
CheckRawSdkIfSendControlRequest003(void)1428 int32_t CheckRawSdkIfSendControlRequest003(void)
1429 {
1430 int32_t ret;
1431 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1432 ret = UsbRawSendControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, NULL);
1433 if (ret != HDF_ERR_INVALID_PARAM) {
1434 HDF_LOGE("%s: error", __func__);
1435 return HDF_FAILURE;
1436 }
1437 HDF_LOGE("%s: success", __func__);
1438 return HDF_SUCCESS;
1439 }
1440
CheckRawSdkIfSendControlRequest004(void)1441 int32_t CheckRawSdkIfSendControlRequest004(void)
1442 {
1443 struct UsbControlRequestData ctrlReq;
1444 int32_t ret;
1445 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1446
1447 rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
1448 rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
1449 rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
1450 rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH;
1451 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
1452 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
1453 ctrlReq.value = CpuToLe16(0);
1454 ctrlReq.index = 2;
1455 ctrlReq.data = (unsigned char *)&rawAcm->lineCoding;
1456 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
1457 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
1458
1459 ret = UsbRawSendControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, &ctrlReq);
1460 if (ret < 0) {
1461 HDF_LOGE("%s: error", __func__);
1462 return HDF_FAILURE;
1463 }
1464 HDF_LOGE("%s: success", __func__);
1465 return HDF_SUCCESS;
1466 }
1467
CheckRawSdkIfSendControlRequest005(void)1468 int32_t CheckRawSdkIfSendControlRequest005(void)
1469 {
1470 struct UsbControlRequestData ctrlReq;
1471 int32_t ret;
1472 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1473
1474 rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
1475 rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
1476 rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY;
1477 rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH;
1478 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
1479 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
1480 ctrlReq.value = CpuToLe16(0);
1481 ctrlReq.index = 0;
1482 ctrlReq.data = (unsigned char *)&rawAcm->lineCoding;
1483 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
1484 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
1485
1486 ret = UsbRawSendControlRequest(NULL, NULL, &ctrlReq);
1487 if (ret != HDF_ERR_INVALID_PARAM) {
1488 HDF_LOGE("%s: error", __func__);
1489 return HDF_FAILURE;
1490 }
1491 HDF_LOGE("%s: success", __func__);
1492 return HDF_SUCCESS;
1493 }
1494
CheckRawSdkIfSendControlRequest006(void)1495 int32_t CheckRawSdkIfSendControlRequest006(void)
1496 {
1497 int32_t ret;
1498 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1499
1500 ret = UsbRawSendControlRequest(NULL, rawAcm->devHandle, NULL);
1501 if (ret != HDF_ERR_INVALID_PARAM) {
1502 HDF_LOGE("%s: error", __func__);
1503 return HDF_FAILURE;
1504 }
1505 HDF_LOGE("%s: success", __func__);
1506 return HDF_SUCCESS;
1507 }
1508
CheckRawSdkIfSendControlRequest007(void)1509 int32_t CheckRawSdkIfSendControlRequest007(void)
1510 {
1511 int32_t ret;
1512 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1513
1514 ret = UsbRawSendControlRequest(rawAcm->ctrlReq, NULL, NULL);
1515 if (ret != HDF_ERR_INVALID_PARAM) {
1516 HDF_LOGE("%s: error", __func__);
1517 return HDF_FAILURE;
1518 }
1519 HDF_LOGE("%s: success", __func__);
1520 return HDF_SUCCESS;
1521 }
1522
CheckRawSdkIfSendBulkRequest001(void)1523 int32_t CheckRawSdkIfSendBulkRequest001(void)
1524 {
1525 struct UsbRequestData reqData;
1526 int32_t ret;
1527 int32_t i;
1528 uint32_t size;
1529 char sendData[] = {"abcd\0"};
1530 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1531
1532 size = strlen(sendData) + 1;
1533 size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size;
1534
1535 for (i = 0; i < 1; i++) {
1536 struct RawWb *snd = &rawAcm->wb[i];
1537 snd->len = (int)size;
1538 ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size);
1539 if (ret) {
1540 HDF_LOGE("%s: memcpy_s fail", __func__);
1541 return HDF_FAILURE;
1542 }
1543 rawAcm->transmitting++;
1544
1545 reqData.endPoint = rawAcm->dataOutEp.addr;
1546 reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1547 reqData.data = snd->buf;
1548 reqData.length = snd->len;
1549 reqData.requested = (int32_t *)&size;
1550 }
1551
1552 for (i = 0; i < 1; i++) {
1553 struct RawWb *snd = &rawAcm->wb[i];
1554 printf("UsbRawSendBulkRequest i = [%d]\n", i);
1555 ret = UsbRawSendBulkRequest(snd->request, rawAcm->devHandle, &reqData);
1556 if (ret) {
1557 printf("%s: error+ret:%d", __func__, ret);
1558 return HDF_FAILURE;
1559 }
1560 }
1561 HDF_LOGE("%s: success", __func__);
1562 return HDF_SUCCESS;
1563 }
1564
CheckRawSdkIfSendBulkRequest002(void)1565 int32_t CheckRawSdkIfSendBulkRequest002(void)
1566 {
1567 struct UsbRequestData reqData;
1568 int32_t ret;
1569 int32_t i;
1570 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1571 uint32_t size = rawAcm->dataInEp.maxPacketSize;
1572
1573 for (i = 0; i < 1; i++) {
1574 reqData.endPoint = rawAcm->dataInEp.addr;
1575 reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1576 reqData.length = size;
1577 reqData.data = ((struct UsbRawRequest *)rawAcm->readReq[i])->buffer;
1578 reqData.requested = (int32_t *)&size;
1579 }
1580
1581 for (i = 0; i < 1; i++) {
1582 printf("UsbRawSendBulkRequest i = [%d]\n", i);
1583 ret = UsbRawSendBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData);
1584 if (ret) {
1585 HDF_LOGE("%s: error", __func__);
1586 return HDF_FAILURE;
1587 }
1588 }
1589 HDF_LOGE("%s: success", __func__);
1590 return HDF_SUCCESS;
1591 }
1592
CheckRawSdkIfSendBulkRequest003(void)1593 int32_t CheckRawSdkIfSendBulkRequest003(void)
1594 {
1595 struct UsbRequestData reqData;
1596 int32_t ret;
1597 int32_t i;
1598 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1599 uint32_t size = rawAcm->dataInEp.maxPacketSize;
1600
1601 for (i = 0; i < 1; i++) {
1602 reqData.endPoint = rawAcm->dataInEp.addr;
1603 reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1604 reqData.length = size;
1605 reqData.data = ((struct UsbRawRequest *)rawAcm->readReq[i])->buffer;
1606 reqData.requested = (int32_t *)&size;
1607 }
1608
1609 for (i = 0; i < 1; i++) {
1610 printf("UsbRawSendBulkRequest i = [%d]\n", i);
1611 ret = UsbRawSendBulkRequest(NULL, rawAcm->devHandle, &reqData);
1612 if (ret != HDF_ERR_INVALID_PARAM) {
1613 HDF_LOGE("%s: error", __func__);
1614 return HDF_FAILURE;
1615 }
1616 }
1617 HDF_LOGE("%s: success", __func__);
1618 return HDF_SUCCESS;
1619 }
1620
CheckRawSdkIfSendBulkRequest004(void)1621 int32_t CheckRawSdkIfSendBulkRequest004(void)
1622 {
1623 struct UsbRequestData reqData;
1624 int32_t ret;
1625 int32_t i;
1626 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1627 uint32_t size = rawAcm->dataInEp.maxPacketSize;
1628
1629 for (i = 0; i < 1; i++) {
1630 reqData.endPoint = rawAcm->dataInEp.addr;
1631 reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1632 reqData.length = size;
1633 reqData.data = ((struct UsbRawRequest *)rawAcm->readReq[i])->buffer;
1634 reqData.requested = (int32_t *)&size;
1635 }
1636 for (i = 0; i < 1; i++) {
1637 printf("UsbRawSendBulkRequest i = [%d]\n", i);
1638 ret = UsbRawSendBulkRequest(rawAcm->readReq[i], NULL, &reqData);
1639 if (ret != HDF_ERR_INVALID_PARAM) {
1640 HDF_LOGE("%s: error", __func__);
1641 return HDF_FAILURE;
1642 }
1643 }
1644 HDF_LOGE("%s: success", __func__);
1645 return HDF_SUCCESS;
1646 }
1647
CheckRawSdkIfSendBulkRequest005(void)1648 int32_t CheckRawSdkIfSendBulkRequest005(void)
1649 {
1650 int32_t ret;
1651 int32_t i;
1652 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1653
1654 for (i = 0; i < 1; i++) {
1655 printf("UsbRawSendBulkRequest i = [%d]\n", i);
1656 ret = UsbRawSendBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, NULL);
1657 if (ret != HDF_ERR_INVALID_PARAM) {
1658 HDF_LOGE("%s: error", __func__);
1659 return HDF_FAILURE;
1660 }
1661 }
1662 HDF_LOGE("%s: success", __func__);
1663 return HDF_SUCCESS;
1664 }
1665
CheckRawSdkIfSendInterruptRequest001(void)1666 int32_t CheckRawSdkIfSendInterruptRequest001(void)
1667 {
1668 struct UsbRequestData reqData;
1669 int32_t ret;
1670 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1671 uint32_t size = rawAcm->notifyEp.maxPacketSize;
1672
1673 reqData.endPoint = rawAcm->notifyEp.addr;
1674 reqData.length = size;
1675 reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1676 reqData.data = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer;
1677 reqData.requested = (int32_t *)&size;
1678 ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &reqData);
1679 if (ret) {
1680 HDF_LOGE("%s: error", __func__);
1681 return HDF_FAILURE;
1682 }
1683 HDF_LOGE("%s: success", __func__);
1684 return HDF_SUCCESS;
1685 }
1686
CheckRawSdkIfSendInterruptRequest002(void)1687 int32_t CheckRawSdkIfSendInterruptRequest002(void)
1688 {
1689 struct UsbRequestData reqData;
1690 int32_t ret;
1691 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1692 uint32_t size = rawAcm->notifyEp.maxPacketSize;
1693
1694 reqData.endPoint = rawAcm->notifyEp.addr;
1695 reqData.length = size;
1696 reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1697 reqData.data = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer;
1698 reqData.requested = (int32_t *)&size;
1699
1700 ret = UsbRawSendInterruptRequest(NULL, rawAcm->devHandle, &reqData);
1701 if (ret != HDF_ERR_INVALID_PARAM) {
1702 HDF_LOGE("%s: error", __func__);
1703 return HDF_FAILURE;
1704 }
1705 HDF_LOGE("%s: success", __func__);
1706 return HDF_SUCCESS;
1707 }
1708
CheckRawSdkIfSendInterruptRequest003(void)1709 int32_t CheckRawSdkIfSendInterruptRequest003(void)
1710 {
1711 struct UsbRequestData reqData;
1712 int32_t ret;
1713 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1714 uint32_t size = rawAcm->notifyEp.maxPacketSize;
1715
1716 reqData.endPoint = rawAcm->notifyEp.addr;
1717 reqData.length = size;
1718 reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1719 reqData.data = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer;
1720 reqData.requested = (int32_t *)&size;
1721
1722 ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, NULL, &reqData);
1723 if (ret != HDF_ERR_INVALID_PARAM) {
1724 HDF_LOGE("%s: error", __func__);
1725 return HDF_FAILURE;
1726 }
1727 HDF_LOGE("%s: success", __func__);
1728 return HDF_SUCCESS;
1729 }
1730
CheckRawSdkIfSendInterruptRequest004(void)1731 int32_t CheckRawSdkIfSendInterruptRequest004(void)
1732 {
1733 int32_t ret;
1734 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1735
1736 ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, NULL);
1737 if (ret != HDF_ERR_INVALID_PARAM) {
1738 HDF_LOGE("%s: error", __func__);
1739 return HDF_FAILURE;
1740 }
1741 HDF_LOGE("%s: success", __func__);
1742 return HDF_SUCCESS;
1743 }
1744
CheckRawSdkIfFillBulkRequest003(void)1745 int32_t CheckRawSdkIfFillBulkRequest003(void)
1746 {
1747 struct UsbRawFillRequestData reqData;
1748 int32_t ret;
1749 int32_t i;
1750 uint32_t size;
1751 char sendData[] = {"abcde\0"};
1752 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1753 size = strlen(sendData) + 1;
1754 size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size;
1755
1756 for (i = 0; i < ACM_NW; i++) {
1757 struct RawWb *snd = &rawAcm->wb[i];
1758 snd->len = (int)size;
1759 ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size);
1760 if (ret) {
1761 HDF_LOGE("%s: memcpy_s fail", __func__);
1762 return HDF_FAILURE;
1763 }
1764 rawAcm->transmitting++;
1765
1766 reqData.endPoint = rawAcm->dataOutEp.addr;
1767 reqData.numIsoPackets = 0;
1768 reqData.callback = AcmWriteBulkCallback;
1769 reqData.userData = (void *)snd;
1770 reqData.timeout = USB_CTRL_SET_TIMEOUT;
1771 reqData.buffer = snd->buf;
1772 reqData.length = snd->len;
1773
1774 ret = UsbRawFillBulkRequest(snd->request, rawAcm->devHandle, &reqData);
1775 if (ret) {
1776 HDF_LOGE("%s: error", __func__);
1777 return HDF_FAILURE;
1778 }
1779 }
1780 HDF_LOGE("%s: success", __func__);
1781 return HDF_SUCCESS;
1782 }
1783
CheckRawSdkIfFillBulkRequest004(void)1784 int32_t CheckRawSdkIfFillBulkRequest004(void)
1785 {
1786 struct UsbRawFillRequestData reqData;
1787 int32_t ret;
1788 int32_t i;
1789 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1790 uint32_t size = rawAcm->dataInEp.maxPacketSize;
1791
1792 for (i = 0; i < ACM_NW; i++) {
1793 reqData.endPoint = rawAcm->dataInEp.addr;
1794 reqData.numIsoPackets = 0;
1795 reqData.callback = AcmReadBulkCallback;
1796 reqData.userData = (void *)rawAcm;
1797 reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS;
1798 reqData.length = size;
1799 ret = UsbRawFillBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData);
1800 if (ret) {
1801 HDF_LOGE("%s: error", __func__);
1802 return HDF_FAILURE;
1803 }
1804 }
1805 HDF_LOGE("%s: success", __func__);
1806 return HDF_SUCCESS;
1807 }
1808
CheckRawSdkIfFillInterruptRequest005(void)1809 int32_t CheckRawSdkIfFillInterruptRequest005(void)
1810 {
1811 struct UsbRawFillRequestData fillRequestData;
1812 int32_t ret;
1813 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1814 uint32_t size = rawAcm->notifyEp.maxPacketSize;
1815 fillRequestData.endPoint = rawAcm->notifyEp.addr;
1816 fillRequestData.length = size;
1817 fillRequestData.numIsoPackets = 0;
1818 fillRequestData.callback = AcmNotifyReqCallback;
1819 fillRequestData.userData = (void *)rawAcm;
1820 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1821 ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &fillRequestData);
1822 if (ret) {
1823 HDF_LOGE("%s: error", __func__);
1824 return HDF_FAILURE;
1825 }
1826 HDF_LOGE("%s: success", __func__);
1827 return HDF_SUCCESS;
1828 }
1829
CheckRawSdkIfSubmitRequest001(void)1830 int32_t CheckRawSdkIfSubmitRequest001(void)
1831 {
1832 int32_t ret;
1833 int32_t i;
1834 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1835
1836 for (i = 0; i < ACM_NW; i++) {
1837 struct RawWb *snd = &rawAcm->wb[i];
1838 printf("UsbRawSubmitRequest i = [%d]\n", i);
1839 ret = UsbRawSubmitRequest(snd->request);
1840 if (ret) {
1841 HDF_LOGE("%s: error", __func__);
1842 return HDF_FAILURE;
1843 }
1844 }
1845 HDF_LOGE("%s: success", __func__);
1846 return HDF_SUCCESS;
1847 }
1848
CheckRawSdkIfSubmitRequest002(void)1849 int32_t CheckRawSdkIfSubmitRequest002(void)
1850 {
1851 int32_t ret;
1852 int32_t i;
1853 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1854
1855 for (i = 0; i < ACM_NW; i++) {
1856 printf("UsbRawSubmitRequest i = [%d]\n", i);
1857 ret = UsbRawSubmitRequest(rawAcm->readReq[i]);
1858 if (ret) {
1859 HDF_LOGE("%s: error", __func__);
1860 return HDF_FAILURE;
1861 }
1862 }
1863 HDF_LOGE("%s: success", __func__);
1864 return HDF_SUCCESS;
1865 }
1866
CheckRawSdkIfSubmitRequest003(void)1867 int32_t CheckRawSdkIfSubmitRequest003(void)
1868 {
1869 int32_t ret;
1870 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1871
1872 ret = UsbRawSubmitRequest(rawAcm->notifyReq);
1873 if (ret) {
1874 HDF_LOGE("%s: error", __func__);
1875 return HDF_FAILURE;
1876 }
1877 HDF_LOGE("%s: success", __func__);
1878 return HDF_SUCCESS;
1879 }
1880
CheckRawSdkIfSubmitRequest004(void)1881 int32_t CheckRawSdkIfSubmitRequest004(void)
1882 {
1883 int32_t ret;
1884
1885 ret = UsbRawSubmitRequest(NULL);
1886 if (ret != HDF_ERR_INVALID_PARAM) {
1887 HDF_LOGE("%s: error", __func__);
1888 return HDF_FAILURE;
1889 }
1890 HDF_LOGE("%s: success", __func__);
1891 return HDF_SUCCESS;
1892 }
1893
CheckRawSdkIfCancelRequest001(void)1894 int32_t CheckRawSdkIfCancelRequest001(void)
1895 {
1896 int32_t ret;
1897 int32_t i;
1898 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1899
1900 for (i = 0; i < ACM_NW; i++) {
1901 struct RawWb *snd = &rawAcm->wb[i];
1902 ret = UsbRawCancelRequest(snd->request);
1903 if (ret) {
1904 HDF_LOGE("%s: error", __func__);
1905 return HDF_FAILURE;
1906 }
1907 }
1908 HDF_LOGE("%s: success", __func__);
1909 return HDF_SUCCESS;
1910 }
1911
CheckRawSdkIfCancelRequest002(void)1912 int32_t CheckRawSdkIfCancelRequest002(void)
1913 {
1914 int32_t ret;
1915 int32_t i;
1916 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1917
1918 for (i = 0; i < ACM_NR; i++) {
1919 ret = UsbRawCancelRequest(rawAcm->readReq[i]);
1920 printf("%s+%d+ret:%d\n", __func__, __LINE__, ret);
1921 if (ret) {
1922 HDF_LOGE("%s: error", __func__);
1923 return HDF_FAILURE;
1924 }
1925 }
1926 HDF_LOGE("%s: success", __func__);
1927 return HDF_SUCCESS;
1928 }
1929
CheckRawSdkIfCancelRequest003(void)1930 int32_t CheckRawSdkIfCancelRequest003(void)
1931 {
1932 int32_t ret;
1933 struct AcmRawDevice *rawAcm = UsbGetIoAcm();
1934
1935 ret = UsbRawCancelRequest(rawAcm->notifyReq);
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
CheckRawSdkIfCancelRequest004(void)1944 int32_t CheckRawSdkIfCancelRequest004(void)
1945 {
1946 int32_t ret;
1947
1948 ret = UsbRawCancelRequest(NULL);
1949 if (ret != HDF_ERR_INVALID_PARAM) {
1950 HDF_LOGE("%s: error", __func__);
1951 return HDF_FAILURE;
1952 }
1953 HDF_LOGE("%s: success", __func__);
1954 return HDF_SUCCESS;
1955 }
1956