1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdio>
17 #include <cstring>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20 extern "C" {
21 #include "usb_raw_sdk_if_test.h"
22 #include "hdf_base.h"
23 #include "hdf_log.h"
24 #include "osal_mem.h"
25 #include "osal_time.h"
26 #include "securec.h"
27 #include "hdf_usb_pnp_manage.h"
28 }
29
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace acmraw {
34 class UsbRawSdkIfTestIo : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 };
39
40 #define USB_RAW_IO_SLEEP_MS_TIME 500
41 #define USB_IO_THREAD_STACK_SIZE 8192
42
43 static struct AcmDevice *g_acm = NULL;
44 static struct AcmDevice g_deviceService;
45 static UsbRawHandle *g_devHandle = NULL;
46 static UsbRawDevice *g_dev = NULL;
47 static int32_t g_activeConfig;
48 static bool g_stopIoThreadFlag = false;
49
UsbIoThread(void * data)50 static int32_t UsbIoThread(void *data)
51 {
52 int32_t ret;
53 struct AcmDevice *acm = (struct AcmDevice *)data;
54
55 for (;;) {
56 if (acm == NULL) {
57 printf("%s:%d acm is NULL\n", __func__, __LINE__);
58 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
59 continue;
60 }
61
62 if (acm->devHandle == NULL) {
63 printf("%s:%d acm->devHandle is NULL!\n", __func__, __LINE__);
64 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
65 continue;
66 }
67 ret = UsbRawHandleRequests(acm->devHandle);
68 if (ret < 0) {
69 printf("%s:%d UsbRawHandleRequests faile, ret=%d \n", __func__, __LINE__, ret);
70 if (ret == HDF_DEV_ERR_NO_DEVICE) {
71 printf("%s:%d, ret=%d\n", __func__, __LINE__, ret);
72 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
73 }
74 }
75
76 if (g_stopIoThreadFlag == true) {
77 printf("%s:%d\n", __func__, __LINE__);
78 g_stopIoThreadFlag = false;
79 break;
80 }
81 }
82
83 return HDF_SUCCESS;
84 }
85
86
UsbStartIo(struct AcmDevice * acm)87 static int32_t UsbStartIo(struct AcmDevice *acm)
88 {
89 struct OsalThreadParam threadCfg;
90 int32_t ret;
91
92 printf("%s start\n", __func__);
93
94 /* creat Io thread */
95 (void)memset_s(&threadCfg, sizeof(threadCfg), 0, sizeof(threadCfg));
96 threadCfg.name = (char *)("usb io thread");
97 threadCfg.priority = OSAL_THREAD_PRI_LOW;
98 threadCfg.stackSize = USB_IO_THREAD_STACK_SIZE;
99
100 ret = OsalThreadCreate(&acm->ioThread, \
101 (OsalThreadEntry)UsbIoThread, (void *)acm);
102 if (ret != HDF_SUCCESS) {
103 printf("%s:%d OsalThreadCreate faile, ret=%d \n", __func__, __LINE__, ret);
104 return ret;
105 }
106
107 ret = OsalThreadStart(&acm->ioThread, &threadCfg);
108 if (ret != HDF_SUCCESS) {
109 printf("%s:%d OsalThreadStart faile, ret=%d \n", __func__, __LINE__, ret);
110 return ret;
111 }
112
113 return HDF_SUCCESS;
114 }
115
UsbStopIo(struct AcmDevice * acm)116 static int32_t UsbStopIo(struct AcmDevice *acm)
117 {
118 int32_t ret;
119
120 HDF_LOGD("%{public}s:%{public}d", __func__, __LINE__);
121 if (g_stopIoThreadFlag == false) {
122 HDF_LOGD("%{public}s:%{public}d", __func__, __LINE__);
123 g_stopIoThreadFlag = true;
124 }
125 ret = OsalThreadDestroy(&acm->ioThread);
126 if (ret != HDF_SUCCESS) {
127 HDF_LOGE("%{public}s:%{public}d OsalThreadDestroy faile, ret=%{public}d ", __func__, __LINE__, ret);
128 return ret;
129 }
130
131 return HDF_SUCCESS;
132 }
133
TearDownTestCase()134 void UsbRawSdkIfTestIo::TearDownTestCase()
135 {
136 g_acm = &g_deviceService;
137 if (UsbStopIo(g_acm) != HDF_SUCCESS) {
138 HDF_LOGW("%s:%d UsbStopIo error!", __func__, __LINE__);
139 }
140 }
141
142 extern "C" {
AcmWriteBulkCallback(const void * requestArg)143 static void AcmWriteBulkCallback(const void *requestArg)
144 {
145 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
146
147 printf("%s:%d entry!", __func__, __LINE__);
148
149 if (req == NULL) {
150 printf("%s:%d req is NULL!", __func__, __LINE__);
151 return;
152 }
153 struct AcmWb *wb = (struct AcmWb *)req->userData;
154 if (wb == NULL) {
155 printf("%s:%d userData(wb) is NULL!", __func__, __LINE__);
156 return;
157 }
158
159 if (req->status != USB_REQUEST_COMPLETED) {
160 printf("%s: write req failed, status=%d", __func__, req->status);
161 }
162
163 wb->use = 0;
164 }
165
AcmReadBulkCallback(const void * requestArg)166 static void AcmReadBulkCallback(const void *requestArg)
167 {
168 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
169 printf("%s:%d entry!", __func__, __LINE__);
170
171 if (req == NULL) {
172 printf("%s:%d req is NULL!", __func__, __LINE__);
173 return;
174 }
175 struct AcmDevice *acm = (struct AcmDevice *)req->userData;
176 if (acm == NULL) {
177 printf("%s:%d userData(acm) is NULL!", __func__, __LINE__);
178 return;
179 }
180 size_t size = req->actualLength;
181
182 switch (req->status) {
183 case USB_REQUEST_COMPLETED:
184 HDF_LOGD("Bulk status: %{public}d+size:%{public}zu\n", req->status, size);
185 if (size) {
186 uint8_t *data = req->buffer;
187 uint32_t count;
188
189 OsalMutexLock(&acm->readLock);
190 if (DataFifoIsFull(&acm->port->readFifo)) {
191 DataFifoSkip(&acm->port->readFifo, size);
192 }
193 count = DataFifoWrite(&acm->port->readFifo, data, size);
194 if (count != size) {
195 printf("%s: write %u less than expected %zu", __func__, count, size);
196 }
197 OsalMutexUnlock(&acm->readLock);
198 }
199 break;
200 case USB_REQUEST_CANCELLED:
201 printf("%s: the request is cancelled", __func__);
202 break;
203 default:
204 printf("%s: the request is failed", __func__);
205 break;
206 }
207 }
208
AcmNotifyReqCallback(const void * requestArg)209 static void AcmNotifyReqCallback(const void *requestArg)
210 {
211 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
212
213 printf("%s:%d entry!", __func__, __LINE__);
214 if (req == NULL) {
215 printf("%s:%d req is NULL!", __func__, __LINE__);
216 return;
217 }
218 struct AcmDevice *acm = (struct AcmDevice *)req->userData;
219 if (acm == NULL) {
220 printf("%s:%d userData(acm) is NULL!", __func__, __LINE__);
221 return;
222 }
223 struct UsbCdcNotification *dr = (struct UsbCdcNotification *)req->buffer;
224 if (dr == NULL) {
225 printf("%s:%d req->buffer(dr) is NULL!", __func__, __LINE__);
226 return;
227 }
228 unsigned int currentSize = req->actualLength;
229 printf("Irqstatus:%d,actualLength:%u\n", req->status, currentSize);
230 }
231 }
AcmWriteBufAlloc(struct AcmDevice * acm)232 static int32_t AcmWriteBufAlloc(struct AcmDevice *acm)
233 {
234 struct AcmWb *wb = &acm->wb[0];
235 int32_t i;
236
237 for (i = 0; i < ACM_NW; i++, wb++) {
238 wb->buf = (uint8_t *)OsalMemCalloc(acm->dataOutEp->maxPacketSize);
239 if (!wb->buf) {
240 while (i != 0) {
241 --i;
242 --wb;
243 OsalMemFree(wb->buf);
244 wb->buf = NULL;
245 }
246 return -HDF_ERR_MALLOC_FAIL;
247 }
248 }
249 return HDF_SUCCESS;
250 }
251
UsbParseConfigDescriptor(struct AcmDevice * acm,struct UsbRawConfigDescriptor * config)252 static int32_t UsbParseConfigDescriptor(struct AcmDevice *acm, struct UsbRawConfigDescriptor *config)
253 {
254 uint8_t i;
255 uint8_t j;
256 int32_t ret;
257
258 if ((acm == NULL) || (config == NULL)) {
259 HDF_LOGE("%{public}s:%{public}d acm or config is NULL",
260 __func__, __LINE__);
261 return HDF_ERR_INVALID_PARAM;
262 }
263 acm->interfaceCnt = 2;
264 acm->interfaceIndex[0] = 2;
265 acm->interfaceIndex[1] = 3;
266
267 for (i = 0; i < acm->interfaceCnt; i++) {
268 uint8_t interfaceIndex = acm->interfaceIndex[i];
269 const struct UsbRawInterface *interface = config->interface[interfaceIndex];
270 uint8_t ifaceClass = interface->altsetting->interfaceDescriptor.bInterfaceClass;
271 uint8_t numEndpoints = interface->altsetting->interfaceDescriptor.bNumEndpoints;
272
273 ret = UsbRawClaimInterface(acm->devHandle, interfaceIndex);
274 if (ret) {
275 HDF_LOGE("%{public}s:%{public}d claim interface %{public}u failed",
276 __func__, __LINE__, i);
277 return ret;
278 }
279
280 switch (ifaceClass) {
281 case USB_DDK_CLASS_COMM:
282 acm->ctrlIface = interfaceIndex;
283 acm->notifyEp = (struct UsbEndpoint *)OsalMemAlloc(sizeof(struct UsbEndpoint));
284 if (acm->notifyEp == NULL) {
285 HDF_LOGE("%{public}s:%{public}d allocate endpoint failed",
286 __func__, __LINE__);
287 break;
288 }
289 /* get the first endpoint by default */
290 acm->notifyEp->addr = interface->altsetting->endPoint[0].endpointDescriptor.bEndpointAddress;
291 acm->notifyEp->interval = interface->altsetting->endPoint[0].endpointDescriptor.bInterval;
292 acm->notifyEp->maxPacketSize = interface->altsetting->endPoint[0].endpointDescriptor.wMaxPacketSize;
293 break;
294 case USB_DDK_CLASS_CDC_DATA:
295 acm->dataIface = interfaceIndex;
296 for (j = 0; j < numEndpoints; j++) {
297 const struct UsbRawEndpointDescriptor *endPoint = &interface->altsetting->endPoint[j];
298
299 /* get bulk in endpoint */
300 if ((endPoint->endpointDescriptor.bEndpointAddress \
301 & USB_DDK_ENDPOINT_DIR_MASK) == USB_DDK_DIR_IN) {
302 acm->dataInEp = (struct UsbEndpoint *)OsalMemAlloc(sizeof(struct UsbEndpoint));
303 if (acm->dataInEp == NULL) {
304 HDF_LOGE("%{public}s:%{public}d allocate dataInEp failed",
305 __func__, __LINE__);
306 break;
307 }
308 acm->dataInEp->addr = endPoint->endpointDescriptor.bEndpointAddress;
309 acm->dataInEp->interval = endPoint->endpointDescriptor.bInterval;
310 acm->dataInEp->maxPacketSize = endPoint->endpointDescriptor.wMaxPacketSize;
311 } else { /* get bulk out endpoint */
312 acm->dataOutEp = (struct UsbEndpoint *)OsalMemAlloc(sizeof(struct UsbEndpoint));
313 if (acm->dataOutEp == NULL) {
314 HDF_LOGE("%{public}s:%{public}d allocate dataOutEp failed",
315 __func__, __LINE__);
316 break;
317 }
318 acm->dataOutEp->addr = endPoint->endpointDescriptor.bEndpointAddress;
319 acm->dataOutEp->interval = endPoint->endpointDescriptor.bInterval;
320 acm->dataOutEp->maxPacketSize = endPoint->endpointDescriptor.wMaxPacketSize;
321 }
322 }
323 break;
324 default:
325 HDF_LOGE("%{public}s:%{public}d wrong descriptor type", __func__, __LINE__);
326 break;
327 }
328 }
329
330 return HDF_SUCCESS;
331 }
332
AcmRawAllocRequest()333 static void AcmRawAllocRequest()
334 {
335 int32_t i;
336
337 for (i = 0; i < ACM_NW; i++) {
338 g_acm->wb[i].request = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataOutEp->maxPacketSize);
339 g_acm->wb[i].instance = g_acm;
340 EXPECT_NE(nullptr, g_acm->wb[i].request);
341 }
342 for (i = 0; i < ACM_NR; i++) {
343 g_acm->readReq[i] = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataInEp->maxPacketSize);
344 EXPECT_NE(nullptr, g_acm->readReq[i]);
345 }
346
347 g_acm->ctrlReq = UsbRawAllocRequest(g_acm->devHandle, 0, USB_CTRL_REQ_SIZE);
348 EXPECT_NE(nullptr, g_acm->ctrlReq);
349
350 g_acm->notifyReq = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->notifyEp->maxPacketSize);
351 EXPECT_NE(nullptr, g_acm->notifyReq);
352 }
353
AcmRawFillWriteReq()354 static void AcmRawFillWriteReq()
355 {
356 struct UsbRawFillRequestData reqData;
357 int32_t ret;
358 int32_t i;
359 uint32_t size;
360 char sendData[] = {"abcde\0"};
361
362 size = strlen(sendData) + 1;
363
364 size = (size > g_acm->dataOutEp->maxPacketSize) ? g_acm->dataOutEp->maxPacketSize : size;
365
366 for (i = 0; i < 1; i++) {
367 AcmWb *snd = &g_acm->wb[i];
368 snd->len = size;
369 if ((snd->buf == NULL) || (g_acm->dataOutEp->maxPacketSize == 0)) {
370 break;
371 }
372 ret = memcpy_s(snd->buf, g_acm->dataOutEp->maxPacketSize, sendData, size);
373 if (ret != EOK) {
374 printf("memcpy_s fial");
375 break;
376 }
377
378 reqData.endPoint = g_acm->dataOutEp->addr;
379 reqData.numIsoPackets = 0;
380 reqData.callback = AcmWriteBulkCallback;
381 reqData.userData = (void *)snd;
382 reqData.timeout = USB_CTRL_SET_TIMEOUT;
383 reqData.buffer = snd->buf;
384 reqData.length = snd->len;
385
386 ret = UsbRawFillBulkRequest(snd->request, g_acm->devHandle, &reqData);
387 EXPECT_EQ(HDF_SUCCESS, ret);
388 }
389 }
390
AcmRawFillReadReq()391 static void AcmRawFillReadReq()
392 {
393 struct UsbRawFillRequestData reqData;
394 int32_t ret;
395 int32_t i;
396 uint32_t size = g_acm->dataInEp->maxPacketSize;
397
398 for (i = 0; i < 1; i++) {
399 reqData.endPoint = g_acm->dataInEp->addr;
400 reqData.numIsoPackets = 0;
401 reqData.callback = AcmReadBulkCallback;
402 reqData.userData = (void *)g_acm;
403 reqData.timeout = USB_CTRL_SET_TIMEOUT;
404 reqData.length = size;
405
406 ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData);
407 EXPECT_EQ(HDF_SUCCESS, ret);
408 }
409 }
410
411
AcmRawFillIntReq()412 static void AcmRawFillIntReq()
413 {
414 struct UsbRawFillRequestData fillRequestData;
415 int32_t ret;
416 uint32_t size = g_acm->notifyEp->maxPacketSize;
417
418 fillRequestData.endPoint = g_acm->notifyEp->addr;
419 fillRequestData.length = size;
420 fillRequestData.numIsoPackets = 0;
421 fillRequestData.callback = AcmNotifyReqCallback;
422 fillRequestData.userData = (void *)g_acm;
423 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
424
425 ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData);
426 EXPECT_EQ(HDF_SUCCESS, ret);
427 }
428
429
AcmRawFillCtrlReq()430 static void AcmRawFillCtrlReq()
431 {
432 struct UsbControlRequestData ctrlReq;
433 unsigned char setup[100] = {0};
434 int32_t ret;
435
436 g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
437 g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
438 g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
439 g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
440
441 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
442 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
443 ctrlReq.value = CpuToLe16(0);
444 ctrlReq.index = 2;
445 ctrlReq.data = (unsigned char *)&g_acm->lineCoding;
446 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
447 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
448
449 ret = UsbRawFillControlSetup(setup, &ctrlReq);
450 EXPECT_EQ(HDF_SUCCESS, ret);
451 }
452
AcmRawInit()453 static void AcmRawInit()
454 {
455 int32_t ret;
456 struct UsbDeviceDescriptor desc;
457 g_acm->busNum = 1U;
458 g_acm->devAddr = 2U;
459
460 ret = UsbRawInit(NULL);
461 EXPECT_EQ(HDF_SUCCESS, ret);
462
463 g_devHandle = UsbRawOpenDevice(NULL, g_acm->busNum, g_acm->devAddr);
464 EXPECT_NE(nullptr, g_devHandle);
465 g_acm->devHandle = g_devHandle;
466
467 ret = UsbRawGetConfiguration(g_acm->devHandle, &g_activeConfig);
468 EXPECT_EQ(HDF_SUCCESS, ret);
469 g_dev = UsbRawGetDevice(g_acm->devHandle);
470 EXPECT_NE(nullptr, g_dev);
471 ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, &g_acm->config);
472 EXPECT_EQ(HDF_SUCCESS, ret);
473 ret = UsbRawGetDeviceDescriptor(g_dev, &desc);
474 EXPECT_EQ(HDF_SUCCESS, ret);
475 ret = UsbParseConfigDescriptor(g_acm, g_acm->config);
476 EXPECT_EQ(HDF_SUCCESS, ret);
477
478 AcmRawAllocRequest();
479 ret = AcmWriteBufAlloc(g_acm);
480 EXPECT_EQ(HDF_SUCCESS, ret);
481 AcmRawFillWriteReq();
482 AcmRawFillReadReq();
483 AcmRawFillIntReq();
484 AcmRawFillCtrlReq();
485 }
486
SetUpTestCase()487 void UsbRawSdkIfTestIo::SetUpTestCase()
488 {
489 g_acm = &g_deviceService;
490 AcmRawInit();
491 UsbStartIo(g_acm);
492 }
493
494 /**
495 * @tc.number : CheckRawSdkIfSendControlRequest001
496 * @tc.name :
497 * @tc.type : PERFs
498 * @tc.level : Level 1
499 */
500 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendControlRequest001, TestSize.Level1)
501 {
502 struct UsbControlRequestData ctrlReq;
503 int32_t ret;
504
505 g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
506 g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
507 g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
508 g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
509
510 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
511 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
512 ctrlReq.value = CpuToLe16(0);
513 ctrlReq.index = 0;
514 ctrlReq.data = (unsigned char *)&g_acm->lineCoding;
515 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
516 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
517
518 ret = UsbRawSendControlRequest(NULL, g_acm->devHandle, &ctrlReq);
519 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
520 }
521
522 /**
523 * @tc.number : CheckRawSdkIfSendControlRequest002
524 * @tc.name :
525 * @tc.type : PERFs
526 * @tc.level : Level 1
527 */
528 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendControlRequest002, TestSize.Level1)
529 {
530 struct UsbControlRequestData ctrlReq;
531 int32_t ret;
532
533 g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
534 g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
535 g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
536 g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
537
538 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
539 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
540 ctrlReq.value = CpuToLe16(0);
541 ctrlReq.index = 0;
542 ctrlReq.data = (unsigned char *)&g_acm->lineCoding;
543 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
544 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
545
546 ret = UsbRawSendControlRequest(g_acm->ctrlReq, NULL, &ctrlReq);
547 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
548 }
549
550 /**
551 * @tc.number : CheckRawSdkIfSendControlRequest003
552 * @tc.name :
553 * @tc.type : PERFs
554 * @tc.level : Level 1
555 */
556 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendControlRequest003, TestSize.Level1)
557 {
558 int32_t ret;
559
560 ret = UsbRawSendControlRequest(g_acm->ctrlReq, g_acm->devHandle, NULL);
561 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
562 }
563
564 /**
565 * @tc.number : CheckRawSdkIfSendControlRequest004
566 * @tc.name :
567 * @tc.type : PERFs
568 * @tc.level : Level 1
569 */
570 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendControlRequest004, TestSize.Level1)
571 {
572 struct UsbControlRequestData ctrlReq;
573 int32_t ret;
574
575 g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
576 g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
577 g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
578 g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
579
580 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
581 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
582 ctrlReq.value = CpuToLe16(0);
583 ctrlReq.index = 2;
584 ctrlReq.data = (unsigned char *)&g_acm->lineCoding;
585 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
586 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
587
588 ret = UsbRawSendControlRequest(g_acm->ctrlReq, g_acm->devHandle, &ctrlReq);
589 EXPECT_NE(HDF_ERR_IO, ret);
590 }
591
592 /**
593 * @tc.number : CheckRawSdkIfSendControlRequest005
594 * @tc.name :
595 * @tc.type : PERFs
596 * @tc.level : Level 1
597 */
598 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendControlRequest005, TestSize.Level1)
599 {
600 struct UsbControlRequestData ctrlReq;
601 int32_t ret;
602
603 g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
604 g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
605 g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
606 g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
607
608 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
609 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
610 ctrlReq.value = CpuToLe16(0);
611 ctrlReq.index = 0;
612 ctrlReq.data = (unsigned char *)&g_acm->lineCoding;
613 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
614 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
615
616 ret = UsbRawSendControlRequest(NULL, NULL, &ctrlReq);
617 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
618 }
619
620 /**
621 * @tc.number : CheckRawSdkIfSendControlRequest006
622 * @tc.name :
623 * @tc.type : PERFs
624 * @tc.level : Level 1
625 */
626 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendControlRequest006, TestSize.Level1)
627 {
628 int32_t ret;
629
630 ret = UsbRawSendControlRequest(NULL, g_acm->devHandle, NULL);
631 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
632 }
633
634 /**
635 * @tc.number : CheckRawSdkIfSendControlRequest007
636 * @tc.name :
637 * @tc.type : PERFs
638 * @tc.level : Level 1
639 */
640 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendControlRequest007, TestSize.Level1)
641 {
642 int32_t ret;
643
644 ret = UsbRawSendControlRequest(g_acm->ctrlReq, NULL, NULL);
645 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
646 }
647
648 /**
649 * @tc.number : CheckRawSdkIfSendBulkRequest001
650 * @tc.name :
651 * @tc.type : PERFs
652 * @tc.level : Level 1
653 */
654 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendBulkRequest001, TestSize.Level1)
655 {
656 struct UsbRequestData reqData;
657 int32_t ret;
658 int32_t i;
659 uint32_t size;
660 char sendData[] = {"abcd\0"};
661
662 size = strlen(sendData) + 1;
663 size = (size > g_acm->dataOutEp->maxPacketSize) ? g_acm->dataOutEp->maxPacketSize : size;
664
665 for (i = 0; i < 1; i++) {
666 AcmWb *snd = &g_acm->wb[i];
667 snd->len = size;
668 ret = memcpy_s(snd->buf, g_acm->dataOutEp->maxPacketSize, sendData, size);
669 if (ret) {
670 printf("memcpy_s fial");
671 }
672
673 reqData.endPoint = g_acm->dataOutEp->addr;
674 reqData.timeout = USB_CTRL_SET_TIMEOUT;
675 reqData.data = snd->buf;
676 reqData.length = snd->len;
677 reqData.requested = (int32_t *)&size;
678 }
679
680 for (i = 0; i < 1; i++) {
681 AcmWb *snd = &g_acm->wb[i];
682 printf("UsbRawSendBulkRequest i = [%d]\n", i);
683 ret = UsbRawSendBulkRequest(snd->request, g_acm->devHandle, &reqData);
684 EXPECT_EQ(HDF_SUCCESS, ret);
685 }
686 }
687
688 /**
689 * @tc.number : CheckRawSdkIfSendBulkRequest002
690 * @tc.name :
691 * @tc.type : PERFs
692 * @tc.level : Level 1
693 */
694 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendBulkRequest002, TestSize.Level1)
695 {
696 struct UsbRequestData reqData;
697 int32_t ret;
698 int32_t i;
699 uint32_t size = g_acm->dataInEp->maxPacketSize;
700
701 for (i = 0; i < 1; i++) {
702 reqData.endPoint = g_acm->dataInEp->addr;
703 reqData.timeout = USB_CTRL_SET_TIMEOUT;
704 reqData.length = size;
705 reqData.data = ((UsbRawRequest *)g_acm->readReq[i])->buffer;
706 reqData.requested = (int32_t *)&size;
707 }
708
709 for (i = 0; i < 1; i++) {
710 printf("UsbRawSendBulkRequest i = [%d]\n", i);
711 ret = UsbRawSendBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData);
712 EXPECT_EQ(HDF_SUCCESS, ret);
713 }
714 }
715
716 /**
717 * @tc.number : CheckRawSdkIfSendBulkRequest003
718 * @tc.name :
719 * @tc.type : PERFs
720 * @tc.level : Level 1
721 */
722 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendBulkRequest003, TestSize.Level1)
723 {
724 struct UsbRequestData reqData;
725 int32_t ret;
726 int32_t i;
727 uint32_t size = g_acm->dataInEp->maxPacketSize;
728
729 for (i = 0; i < 1; i++) {
730 reqData.endPoint = g_acm->dataInEp->addr;
731 reqData.timeout = USB_CTRL_SET_TIMEOUT;
732 reqData.length = size;
733 reqData.data = ((UsbRawRequest *)g_acm->readReq[i])->buffer;
734 reqData.requested = (int32_t *)&size;
735 }
736
737 for (i = 0; i < 1; i++) {
738 printf("UsbRawSendBulkRequest i = [%d]\n", i);
739 ret = UsbRawSendBulkRequest(NULL, g_acm->devHandle, &reqData);
740 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
741 }
742 }
743
744 /**
745 * @tc.number : CheckRawSdkIfSendBulkRequest004
746 * @tc.name :
747 * @tc.type : PERFs
748 * @tc.level : Level 1
749 */
750 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendBulkRequest004, TestSize.Level1)
751 {
752 struct UsbRequestData reqData;
753 int32_t ret;
754 int32_t i;
755 uint32_t size = g_acm->dataInEp->maxPacketSize;
756
757 for (i = 0; i < 1; i++) {
758 reqData.endPoint = g_acm->dataInEp->addr;
759 reqData.timeout = USB_CTRL_SET_TIMEOUT;
760 reqData.length = size;
761 reqData.data = ((UsbRawRequest *)g_acm->readReq[i])->buffer;
762 reqData.requested = (int32_t *)&size;
763 }
764
765 for (i = 0; i < 1; i++) {
766 printf("UsbRawSendBulkRequest i = [%d]\n", i);
767 ret = UsbRawSendBulkRequest(g_acm->readReq[i], NULL, &reqData);
768 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
769 }
770 }
771
772 /**
773 * @tc.number : CheckRawSdkIfSendBulkRequest005
774 * @tc.name :
775 * @tc.type : PERFs
776 * @tc.level : Level 1
777 */
778 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendBulkRequest005, TestSize.Level1)
779 {
780 int32_t ret;
781 int32_t i;
782
783 for (i = 0; i < 1; i++) {
784 printf("UsbRawSendBulkRequest i = [%d]\n", i);
785 ret = UsbRawSendBulkRequest(g_acm->readReq[i], g_acm->devHandle, NULL);
786 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
787 }
788 }
789
790 /**
791 * @tc.number : CheckRawSdkIfSendInterruptRequest001
792 * @tc.name :
793 * @tc.type : PERFs
794 * @tc.level : Level 1
795 */
796 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendInterruptRequest001, TestSize.Level1)
797 {
798 struct UsbRequestData reqData;
799 int32_t ret;
800 uint32_t size = g_acm->notifyEp->maxPacketSize;
801
802 reqData.endPoint = g_acm->notifyEp->addr;
803 reqData.length = size;
804 reqData.timeout = USB_CTRL_SET_TIMEOUT;
805 reqData.data = ((UsbRawRequest *)g_acm->notifyReq)->buffer;
806 reqData.requested = (int32_t *)&size;
807
808 ret = UsbRawSendInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &reqData);
809 EXPECT_EQ(HDF_SUCCESS, ret);
810 }
811
812 /**
813 * @tc.number : CheckRawSdkIfSendInterruptRequest002
814 * @tc.name :
815 * @tc.type : PERFs
816 * @tc.level : Level 1
817 */
818 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendInterruptRequest002, TestSize.Level1)
819 {
820 struct UsbRequestData reqData;
821 int32_t ret;
822 uint32_t size = g_acm->notifyEp->maxPacketSize;
823
824 reqData.endPoint = g_acm->notifyEp->addr;
825 reqData.length = size;
826 reqData.timeout = USB_CTRL_SET_TIMEOUT;
827 reqData.data = ((UsbRawRequest *)g_acm->notifyReq)->buffer;
828 reqData.requested = (int32_t *)&size;
829
830 ret = UsbRawSendInterruptRequest(NULL, g_acm->devHandle, &reqData);
831 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
832 }
833
834 /**
835 * @tc.number : CheckRawSdkIfSendInterruptRequest003
836 * @tc.name :
837 * @tc.type : PERFs
838 * @tc.level : Level 1
839 */
840 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendInterruptRequest003, TestSize.Level1)
841 {
842 struct UsbRequestData reqData;
843 int32_t ret;
844 uint32_t size = g_acm->notifyEp->maxPacketSize;
845
846 reqData.endPoint = g_acm->notifyEp->addr;
847 reqData.length = size;
848 reqData.timeout = USB_CTRL_SET_TIMEOUT;
849 reqData.data = ((UsbRawRequest *)g_acm->notifyReq)->buffer;
850 reqData.requested = (int32_t *)&size;
851
852 ret = UsbRawSendInterruptRequest(g_acm->notifyReq, NULL, &reqData);
853 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
854 }
855
856 /**
857 * @tc.number : CheckRawSdkIfSendInterruptRequest004
858 * @tc.name :
859 * @tc.type : PERFs
860 * @tc.level : Level 1
861 */
862 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSendInterruptRequest004, TestSize.Level1)
863 {
864 int32_t ret;
865
866 ret = UsbRawSendInterruptRequest(g_acm->notifyReq, g_acm->devHandle, NULL);
867 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
868 }
869
870 /**
871 * @tc.number : CheckRawSdkIfFillBulkRequest003
872 * @tc.name :
873 * @tc.type : PERFs
874 * @tc.level : Level 1
875 */
876 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfFillBulkRequest003, TestSize.Level1)
877 {
878 struct UsbRawFillRequestData reqData;
879 int32_t ret;
880 int32_t i;
881 uint32_t size;
882 char sendData[] = {"abcde\0"};
883
884 size = strlen(sendData) + 1;
885
886 size = (size > g_acm->dataOutEp->maxPacketSize) ? g_acm->dataOutEp->maxPacketSize : size;
887
888 for (i = 0; i < ACM_NW; i++) {
889 AcmWb *snd = &g_acm->wb[i];
890 snd->len = size;
891 ret = memcpy_s(snd->buf, g_acm->dataOutEp->maxPacketSize, sendData, size);
892 if (ret) {
893 printf("memcpy_s fial");
894 }
895 g_acm->transmitting++;
896
897 reqData.endPoint = g_acm->dataOutEp->addr;
898 reqData.numIsoPackets = 0;
899 reqData.callback = AcmWriteBulkCallback;
900 reqData.userData = (void *)snd;
901 reqData.timeout = USB_CTRL_SET_TIMEOUT;
902 reqData.buffer = snd->buf;
903 reqData.length = snd->len;
904
905 ret = UsbRawFillBulkRequest(snd->request, g_acm->devHandle, &reqData);
906 EXPECT_EQ(HDF_SUCCESS, ret);
907 }
908 }
909
910 /**
911 * @tc.number : CheckRawSdkIfFillBulkRequest004
912 * @tc.name :
913 * @tc.type : PERFs
914 * @tc.level : Level 1
915 */
916 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfFillBulkRequest004, TestSize.Level1)
917 {
918 struct UsbRawFillRequestData reqData;
919 int32_t ret;
920 int32_t i;
921 uint32_t size = g_acm->dataInEp->maxPacketSize;
922
923 for (i = 0; i < ACM_NR; i++) {
924 reqData.endPoint = g_acm->dataInEp->addr;
925 reqData.numIsoPackets = 0;
926 reqData.callback = AcmReadBulkCallback;
927 reqData.userData = (void *)g_acm;
928 reqData.timeout = USB_CTRL_SET_TIMEOUT;
929 reqData.length = size;
930
931 ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData);
932 EXPECT_EQ(HDF_SUCCESS, ret);
933 }
934 }
935
936 /**
937 * @tc.number : CheckRawSdkIfFillInterruptRequest005
938 * @tc.name :
939 * @tc.type : PERFs
940 * @tc.level : Level 1
941 */
942 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfFillInterruptRequest005, TestSize.Level1)
943 {
944 struct UsbRawFillRequestData fillRequestData;
945 int32_t ret;
946 uint32_t size = g_acm->notifyEp->maxPacketSize;
947
948 fillRequestData.endPoint = g_acm->notifyEp->addr;
949 fillRequestData.length = size;
950 fillRequestData.numIsoPackets = 0;
951 fillRequestData.callback = AcmNotifyReqCallback;
952 fillRequestData.userData = (void *)g_acm;
953 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
954
955 ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData);
956 EXPECT_EQ(HDF_SUCCESS, ret);
957 }
958
959
960 /**
961 * @tc.number : CheckRawSdkIfSubmitRequest001
962 * @tc.name :
963 * @tc.type : PERFs
964 * @tc.level : Level 1
965 */
966 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSubmitRequest001, TestSize.Level1)
967 {
968 int32_t ret;
969 int32_t i;
970
971 for (i = 0; i < 1; i++) {
972 AcmWb *snd = &g_acm->wb[i];
973 printf("UsbRawSubmitRequest i = [%d]\n", i);
974 ret = UsbRawSubmitRequest(snd->request);
975 EXPECT_EQ(HDF_SUCCESS, ret);
976 }
977 }
978
979 /**
980 * @tc.number : CheckRawSdkIfSubmitRequest002
981 * @tc.name :
982 * @tc.type : PERFs
983 * @tc.level : Level 1
984 */
985 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSubmitRequest002, TestSize.Level1)
986 {
987 int32_t ret;
988 int32_t i;
989
990 for (i = 0; i < 1; i++) {
991 printf("UsbRawSubmitRequest i = [%d]\n", i);
992 ret = UsbRawSubmitRequest(g_acm->readReq[i]);
993 EXPECT_EQ(HDF_SUCCESS, ret);
994 }
995 }
996
997 /**
998 * @tc.number : CheckRawSdkIfSubmitRequest003
999 * @tc.name :
1000 * @tc.type : PERFs
1001 * @tc.level : Level 1
1002 */
1003 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSubmitRequest003, TestSize.Level1)
1004 {
1005 int32_t ret;
1006
1007 ret = UsbRawSubmitRequest(g_acm->notifyReq);
1008 EXPECT_EQ(HDF_SUCCESS, ret);
1009 }
1010
1011 /**
1012 * @tc.number : CheckRawSdkIfSubmitRequest004
1013 * @tc.name :
1014 * @tc.type : PERFs
1015 * @tc.level : Level 1
1016 */
1017 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfSubmitRequest004, TestSize.Level1)
1018 {
1019 int32_t ret;
1020
1021 ret = UsbRawSubmitRequest(NULL);
1022 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1023 }
1024
1025 /**
1026 * @tc.number : CheckRawSdkIfCancelRequest001
1027 * @tc.name :
1028 * @tc.type : PERFs
1029 * @tc.level : Level 1
1030 */
1031 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfCancelRequest001, TestSize.Level1)
1032 {
1033 int32_t ret;
1034 int32_t i;
1035
1036 for (i = 0; i < ACM_NW; i++) {
1037 AcmWb *snd = &g_acm->wb[i];
1038 ret = UsbRawCancelRequest(snd->request);
1039 EXPECT_EQ(HDF_SUCCESS, ret);
1040 }
1041 }
1042
1043 /**
1044 * @tc.number : CheckRawSdkIfCancelRequest002
1045 * @tc.name :
1046 * @tc.type : PERFs
1047 * @tc.level : Level 1
1048 */
1049 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfCancelRequest002, TestSize.Level1)
1050 {
1051 int32_t ret;
1052 int32_t i;
1053
1054 for (i = 0; i < 1; i++) {
1055 ret = UsbRawCancelRequest(g_acm->readReq[i]);
1056 EXPECT_EQ(HDF_SUCCESS, ret);
1057 }
1058 }
1059
1060 /**
1061 * @tc.number : CheckRawSdkIfCancelRequest003
1062 * @tc.name :
1063 * @tc.type : PERFs
1064 * @tc.level : Level 1
1065 */
1066 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfCancelRequest003, TestSize.Level1)
1067 {
1068 int32_t ret;
1069
1070 ret = UsbRawCancelRequest(g_acm->notifyReq);
1071 EXPECT_EQ(HDF_SUCCESS, ret);
1072 }
1073
1074 /**
1075 * @tc.number : CheckRawSdkIfCancelRequest004
1076 * @tc.name :
1077 * @tc.type : PERFs
1078 * @tc.level : Level 1
1079 */
1080 HWTEST_F(UsbRawSdkIfTestIo, CheckRawSdkIfCancelRequest004, TestSize.Level1)
1081 {
1082 int32_t ret;
1083
1084 ret = UsbRawCancelRequest(NULL);
1085 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1086 }
1087
1088 }
1089