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