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_host_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 "usb_ddk_interface.h"
28 }
29
30 #define USB_PIPE_DIR_OFFSET 7
31
32 using namespace std;
33 using namespace testing::ext;
34
35 namespace {
36 class UsbHostSdkIfTestIo : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42 };
43
44 static struct AcmDevice g_deviceService;
45 static struct AcmDevice *g_acm = &g_deviceService;
46
SetUpTestCase()47 void UsbHostSdkIfTestIo::SetUpTestCase()
48 {
49 }
50
TearDownTestCase()51 void UsbHostSdkIfTestIo::TearDownTestCase()
52 {
53 }
54
SetUp()55 void UsbHostSdkIfTestIo::SetUp()
56 {
57 }
58
TearDown()59 void UsbHostSdkIfTestIo::TearDown()
60 {
61 }
62
AcmReadBulk(struct UsbRequest * req)63 static void AcmReadBulk(struct UsbRequest *req)
64 {
65 uint32_t size;
66 int32_t status = req->compInfo.status;
67 size = req->compInfo.actualLength;
68 printf("Bulk status:%d,actualLength:%d\n", status, size);
69 return;
70 }
71
AcmWriteBulk(struct UsbRequest * req)72 static void AcmWriteBulk(struct UsbRequest *req)
73 {
74 int32_t status;
75
76 if (req == NULL) {
77 printf("%s:%d req is NULL!", __func__, __LINE__);
78 return;
79 }
80
81 status = req->compInfo.status;
82 printf("Bulk Write status:%d\n", status);
83 struct AcmWb *wb = (struct AcmWb *)req->compInfo.userData;
84 switch (status) {
85 case 0:
86 wb->use = 0;
87 break;
88 case -ECONNRESET:
89 case -ENOENT:
90 case -ESHUTDOWN:
91 return;
92 default:
93 return;
94 }
95 return;
96 }
97
AcmWriteBufAlloc(struct AcmDevice * acm)98 static int32_t AcmWriteBufAlloc(struct AcmDevice *acm)
99 {
100 int32_t i;
101 struct AcmWb *wb;
102 for (wb = &acm->wb[0],i = 0; i < ACM_NW; i++,wb++) {
103 wb->buf = (uint8_t *)OsalMemCalloc(acm->writeSize);
104 if (!wb->buf) {
105 while (i != 0) {
106 --i;
107 --wb;
108 OsalMemFree(wb->buf);
109 wb->buf = NULL;
110 }
111 return -HDF_ERR_MALLOC_FAIL;
112 }
113 }
114 return 0;
115 }
116
AcmCtrlIrq(struct UsbRequest * req)117 static void AcmCtrlIrq(struct UsbRequest *req)
118 {
119 if (req == NULL) {
120 printf("%s:%d req is NULL!", __func__, __LINE__);
121 return;
122 }
123 int32_t status = req->compInfo.status;
124 unsigned int currentSize = req->compInfo.actualLength;
125 printf("Irqstatus:%d,actualLength:%u\n", status, currentSize);
126 switch (status) {
127 case 0:
128 break;
129 default:
130 return;
131 }
132
133 printf("%s:%d exit", __func__, __LINE__);
134 }
135
UsbControlMsg(struct TestControlMsgData msgData)136 static struct UsbControlRequest UsbControlMsg(struct TestControlMsgData msgData)
137 {
138 struct UsbControlRequest dr;
139 dr.target = (UsbRequestTargetType)(msgData.requestType & TARGET_MASK);
140 dr.reqType = (UsbControlRequestType)((msgData.requestType >> USB_TYPE_OFFSET) & REQUEST_TYPE_MASK);
141 dr.directon = (UsbRequestDirection)((msgData.requestType >> USB_DIR_OFFSET) & DIRECTION_MASK);
142 dr.request = msgData.request;
143 dr.value = CpuToLe16(msgData.value);
144 dr.index = CpuToLe16(msgData.index);
145 dr.buffer = msgData.data;
146 dr.length = CpuToLe16(msgData.size);
147 return dr;
148 }
AcmGetPipe()149 static void AcmGetPipe()
150 {
151 int32_t ret;
152 struct UsbPipeInfo p;
153 int32_t i;
154
155 for (i = 0; i <= g_acm->dataIface->info.pipeNum; i++) {
156 ret = UsbGetPipeInfo(g_acm->data_devHandle, g_acm->dataIface->info.curAltSetting, i, &p);
157 if (ret < 0) {
158 continue;
159 }
160 if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_BULK)) {
161 struct UsbPipeInfo *pi = (UsbPipeInfo *)OsalMemCalloc(sizeof(*pi));
162 EXPECT_NE(nullptr, pi);
163 p.interfaceId = g_acm->dataIface->info.interfaceIndex;
164 *pi = p;
165 g_acm->dataInPipe = pi;
166 }
167
168 if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_BULK)) {
169 struct UsbPipeInfo *pi = (UsbPipeInfo *)OsalMemCalloc(sizeof(*pi));
170 EXPECT_NE(nullptr, pi);
171 p.interfaceId = g_acm->dataIface->info.interfaceIndex;
172 *pi = p;
173 g_acm->dataOutPipe = pi;
174 }
175 }
176
177 for (i = 0; i <= g_acm->intIface->info.pipeNum; i++) {
178 ret = UsbGetPipeInfo(g_acm->int_devHandle, g_acm->intIface->info.curAltSetting, i, &p);
179 if (ret < 0) {
180 continue;
181 }
182 if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_INTERRUPT)) {
183 struct UsbPipeInfo *pi = (UsbPipeInfo *)OsalMemCalloc(sizeof(*pi));
184 p.interfaceId = g_acm->intIface->info.interfaceIndex;
185 *pi = p;
186 g_acm->intPipe = pi;
187 break;
188 }
189 }
190
191 g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID;
192 for (i = 0; i <= g_acm->ctrIface->info.pipeNum; i++) {
193 ret = UsbGetPipeInfo(g_acm->ctrl_devHandle, g_acm->ctrIface->info.curAltSetting, i, &p);
194 if (ret < 0) {
195 continue;
196 }
197 if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_CONTROL)) {
198 struct UsbPipeInfo *pi = (UsbPipeInfo *)OsalMemCalloc(sizeof(*pi));
199 p.interfaceId = g_acm->interfaceIndex;
200 *pi = p;
201 g_acm->ctrPipe = pi;
202 break;
203 }
204 }
205 }
206
AcmGetRequest()207 static void AcmGetRequest()
208 {
209 int32_t ret;
210 int32_t i;
211 g_acm->readSize = g_acm->dataInPipe->maxPacketSize;
212 for (i = 0; i < ACM_NR; i++) {
213 g_acm->readReq[i] = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->readSize);
214 EXPECT_NE(nullptr, g_acm->readReq[i]);
215 }
216
217 g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize;
218 ret = AcmWriteBufAlloc(g_acm);
219 EXPECT_EQ(HDF_SUCCESS, ret);
220
221 for (i = 0; i < ACM_NW; i++) {
222 g_acm->wb[i].request = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->writeSize);
223 g_acm->wb[i].instance = g_acm;
224 EXPECT_NE(nullptr, g_acm->wb[i].request);
225 }
226
227 g_acm->intSize = g_acm->intPipe->maxPacketSize;
228 g_acm->notifyReq = UsbAllocRequest(g_acm->int_devHandle, 0, g_acm->intSize);
229 EXPECT_NE(nullptr, g_acm->notifyReq);
230
231 g_acm->ctrlSize = sizeof (struct UsbCdcLineCoding);
232 g_acm->ctrlReq = UsbAllocRequest(g_acm->ctrl_devHandle, 0, g_acm->ctrlSize);
233 EXPECT_NE(nullptr, g_acm->ctrlReq);
234 }
235
AcmFillReadRequest()236 static void AcmFillReadRequest()
237 {
238 int32_t i;
239 struct UsbRequestParams readParmas;
240 int32_t ret;
241 for (i = 0; i < ACM_NR; i++) {
242 readParmas.userData = (void *)g_acm;
243 readParmas.pipeAddress = g_acm->dataInPipe->pipeAddress;
244 readParmas.pipeId = g_acm->dataInPipe->pipeId;
245 readParmas.interfaceId = g_acm->dataInPipe->interfaceId;
246 readParmas.callback = AcmReadBulk;
247 readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
248 readParmas.timeout = USB_CTRL_SET_TIMEOUT;
249 readParmas.dataReq.numIsoPackets = 0;
250 readParmas.dataReq.directon = (UsbRequestDirection)((g_acm->dataInPipe->pipeDirection >> USB_DIR_OFFSET) \
251 & 0x1);
252 readParmas.dataReq.length = g_acm->readSize;
253 ret = UsbFillRequest(g_acm->readReq[i], g_acm->data_devHandle, &readParmas);
254 EXPECT_EQ(HDF_SUCCESS, ret);
255 }
256 }
257
AcmFillWriteRequest()258 static void AcmFillWriteRequest()
259 {
260 struct UsbRequestParams parmas;
261 char sendData[] = {"abcde\0"};
262 uint32_t size = strlen(sendData) + 1;
263 int32_t i;
264 int32_t ret;
265
266 g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize;
267 size = (size > g_acm->writeSize) ? g_acm->writeSize : size;
268
269 for (i = 0; i < ACM_NW; i++) {
270 g_acm->wb[i].len = size;
271 if ((g_acm->wb[i].buf == NULL) || (g_acm->writeSize == 0)) {
272 break;
273 }
274 ret = memcpy_s(g_acm->wb[i].buf, g_acm->writeSize, sendData, size);
275 if (ret != EOK) {
276 printf("memcpy_s fial");
277 break;
278 }
279
280 parmas.interfaceId = g_acm->dataOutPipe->interfaceId;
281 parmas.pipeAddress = g_acm->dataOutPipe->pipeAddress;
282 parmas.pipeId = g_acm->dataOutPipe->pipeId;
283 parmas.callback = AcmWriteBulk;
284 parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
285 parmas.timeout = USB_CTRL_SET_TIMEOUT;
286 parmas.dataReq.numIsoPackets = 0;
287 parmas.userData = (void *)&g_acm->wb[i];
288 parmas.dataReq.length = g_acm->wb[i].len;
289 parmas.dataReq.buffer = g_acm->wb[i].buf;
290 ret = UsbFillRequest(g_acm->wb[i].request, g_acm->data_devHandle, &parmas);
291 EXPECT_EQ(HDF_SUCCESS, ret);
292 }
293 }
294
AcmFillIntRequest()295 static void AcmFillIntRequest()
296 {
297 int32_t ret;
298 struct UsbRequestParams intParmas;
299
300 intParmas.userData = (void *)g_acm;
301 intParmas.pipeAddress = g_acm->intPipe->pipeAddress;
302 intParmas.pipeId = g_acm->intPipe->pipeId;
303 intParmas.interfaceId = g_acm->intPipe->interfaceId;
304 intParmas.callback = AcmCtrlIrq;
305 intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
306 intParmas.timeout = USB_CTRL_SET_TIMEOUT;
307 intParmas.dataReq.numIsoPackets = 0;
308 intParmas.dataReq.directon = (UsbRequestDirection)((g_acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) \
309 & DIRECTION_MASK);
310 intParmas.dataReq.length = g_acm->intSize;
311 ret = UsbFillRequest(g_acm->notifyReq, g_acm->int_devHandle, &intParmas);
312 EXPECT_EQ(HDF_SUCCESS, ret);
313 }
314
AcmFillCtrlRequest()315 static void AcmFillCtrlRequest()
316 {
317 int32_t ret;
318 struct UsbRequestParams parmas;
319 uint16_t index = 2;
320 uint16_t value = 0;
321 struct TestControlMsgData msgData = {0};
322
323 parmas.interfaceId = USB_CTRL_INTERFACE_ID;
324 parmas.pipeAddress = 0;
325 parmas.pipeId = 0;
326 parmas.callback = AcmCtrlIrq;
327 parmas.requestType = USB_REQUEST_PARAMS_CTRL_TYPE;
328 parmas.timeout = USB_CTRL_SET_TIMEOUT;
329
330 g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
331 g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
332 g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
333 g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
334
335 msgData.request = USB_DDK_CDC_REQ_SET_LINE_CODING;
336 msgData.requestType = USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
337 msgData.value = value;
338 msgData.index = index;
339 msgData.data = &g_acm->lineCoding;
340 msgData.size = sizeof(struct UsbCdcLineCoding);
341 parmas.ctrlReq = UsbControlMsg(msgData);
342 ret = UsbFillRequest(g_acm->ctrlReq, g_acm->ctrl_devHandle, &parmas);
343 EXPECT_EQ(HDF_SUCCESS, ret);
344 }
345
AcmInit()346 static void AcmInit()
347 {
348 int32_t ret;
349 struct UsbSession *session = NULL;
350
351 ret = UsbInitHostSdk(&session);
352 EXPECT_EQ(HDF_SUCCESS, ret);
353 g_acm->session = session;
354
355 g_acm->busNum = 1U;
356 g_acm->devAddr = 2U;
357 g_acm->interfaceIndex = 3U;
358 g_acm->dataIface = UsbClaimInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, g_acm->interfaceIndex);
359 EXPECT_NE(nullptr, g_acm->dataIface);
360
361 g_acm->interfaceIndex = 2U;
362 g_acm->intIface = UsbClaimInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, g_acm->interfaceIndex);
363 EXPECT_NE(nullptr, g_acm->intIface);
364
365 g_acm->interfaceIndex = 255U;
366 g_acm->ctrIface = UsbClaimInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, g_acm->interfaceIndex);
367 EXPECT_NE(nullptr, g_acm->ctrIface);
368
369 g_acm->data_devHandle = UsbOpenInterface(g_acm->dataIface);
370 EXPECT_NE(nullptr, g_acm->data_devHandle);
371 g_acm->int_devHandle = UsbOpenInterface(g_acm->intIface);
372 EXPECT_NE(nullptr, g_acm->int_devHandle);
373 g_acm->ctrl_devHandle = UsbOpenInterface(g_acm->ctrIface);
374 EXPECT_NE(nullptr, g_acm->ctrl_devHandle);
375
376 AcmGetPipe();
377 AcmGetRequest();
378 AcmFillReadRequest();
379 AcmFillWriteRequest();
380 AcmFillIntRequest();
381 AcmFillCtrlRequest();
382 }
383
384 /**
385 * @tc.number : CheckHostSdkIfSubmitRequestSync001
386 * @tc.name :
387 * @tc.type : PERF
388 * @tc.level : Level 1
389 */
390 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfSubmitRequestSync001, TestSize.Level1)
391 {
392 int32_t ret;
393 int32_t i;
394 AcmInit();
395
396 for (i = 0; i < 1; i++) {
397 printf("------UsbSubmitRequestSync i = [%d]------\n", i);
398 ret = UsbSubmitRequestSync(g_acm->readReq[i]);
399 EXPECT_EQ(HDF_SUCCESS, ret);
400 }
401 }
402
403 /**
404 * @tc.number : CheckHostSdkIfSubmitRequestSync002
405 * @tc.name :
406 * @tc.type : PERF
407 * @tc.level : Level 1
408 */
409 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfSubmitRequestSync002, TestSize.Level1)
410 {
411 int32_t ret;
412 int32_t i;
413
414 for (i = 0; i < 1; i++) {
415 printf("------UsbSubmitRequestSync i = [%d]------\n", i);
416 ret = UsbSubmitRequestSync(g_acm->wb[i].request);
417 EXPECT_EQ(HDF_SUCCESS, ret);
418 }
419 }
420
421 /**
422 * @tc.number : CheckHostSdkIfSubmitRequestSync003
423 * @tc.name :
424 * @tc.type : PERF
425 * @tc.level : Level 1
426 */
427 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfSubmitRequestSync003, TestSize.Level1)
428 {
429 int32_t ret;
430
431 ret = UsbSubmitRequestSync(g_acm->notifyReq);
432 EXPECT_EQ(HDF_SUCCESS, ret);
433 }
434
435 /**
436 * @tc.number : CheckHostSdkIfSubmitRequestSync004
437 * @tc.name :
438 * @tc.type : PERF
439 * @tc.level : Level 1
440 */
441 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfSubmitRequestSync004, TestSize.Level1)
442 {
443 int32_t ret;
444
445 ret = UsbSubmitRequestSync(g_acm->notifyReq);
446 EXPECT_EQ(HDF_SUCCESS, ret);
447 }
448
449 /**
450 * @tc.number : CheckHostSdkIfSubmitRequestAsync001
451 * @tc.name :
452 * @tc.type : PERF
453 * @tc.level : Level 1
454 */
455 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfSubmitRequestAsync001, TestSize.Level1)
456 {
457 int32_t ret;
458 int32_t i;
459
460 for (i = 0; i < ACM_NR; i++) {
461 ret = UsbSubmitRequestAsync(g_acm->readReq[i]);
462 EXPECT_EQ(HDF_SUCCESS, ret);
463 }
464 }
465
466 /**
467 * @tc.number : CheckHostSdkIfCancelRequest001
468 * @tc.name :
469 * @tc.type : PERF
470 * @tc.level : Level 1
471 */
472 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfCancelRequest001, TestSize.Level1)
473 {
474 int32_t ret;
475 int32_t i = 0;
476
477 ret = UsbCancelRequest(g_acm->readReq[i]);
478 EXPECT_EQ(HDF_SUCCESS, ret);
479 }
480
481 /**
482 * @tc.number : CheckHostSdkIfSubmitRequestAsync002
483 * @tc.name :
484 * @tc.type : PERF
485 * @tc.level : Level 1
486 */
487 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfSubmitRequestAsync002, TestSize.Level1)
488 {
489 int32_t ret;
490 int32_t i;
491
492 for (i = 0; i < ACM_NR; i++) {
493 ret = UsbSubmitRequestAsync(g_acm->wb[i].request);
494 EXPECT_EQ(HDF_SUCCESS, ret);
495 }
496 }
497
498 /**
499 * @tc.number : CheckHostSdkIfCancelRequest002
500 * @tc.name :
501 * @tc.type : PERF
502 * @tc.level : Level 1
503 */
504 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfCancelRequest002, TestSize.Level1)
505 {
506 int32_t ret;
507 int32_t i = 0;
508
509 i = ACM_NR-1;
510 ret = UsbCancelRequest(g_acm->wb[i].request);
511 EXPECT_EQ(HDF_SUCCESS, ret);
512 }
513
514 /**
515 * @tc.number : CheckHostSdkIfSubmitRequestAsync003
516 * @tc.name :
517 * @tc.type : PERF
518 * @tc.level : Level 1
519 */
520 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfSubmitRequestAsync003, TestSize.Level1)
521 {
522 int32_t ret;
523
524 ret = UsbSubmitRequestAsync(g_acm->notifyReq);
525 EXPECT_EQ(HDF_SUCCESS, ret);
526 }
527
528 /**
529 * @tc.number : CheckHostSdkIfCancelRequest003
530 * @tc.name :
531 * @tc.type : PERF
532 * @tc.level : Level 1
533 */
534 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfCancelRequest003, TestSize.Level1)
535 {
536 int32_t ret;
537
538 ret = UsbCancelRequest(g_acm->notifyReq);
539 EXPECT_EQ(HDF_SUCCESS, ret);
540 }
541
542 /**
543 * @tc.number : CheckHostSdkIfSubmitRequestAsync004
544 * @tc.name :
545 * @tc.type : PERF
546 * @tc.level : Level 1
547 */
548 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfSubmitRequestAsync004, TestSize.Level1)
549 {
550 int32_t ret;
551
552 ret = UsbSubmitRequestAsync(g_acm->readReq[0]);
553
554 EXPECT_EQ(HDF_SUCCESS, ret);
555 }
556
557 /**
558 * @tc.number : CheckHostSdkIfCancelRequest004
559 * @tc.name :
560 * @tc.type : PERF
561 * @tc.level : Level 1
562 */
563 HWTEST_F(UsbHostSdkIfTestIo, CheckHostSdkIfCancelRequest004, TestSize.Level1)
564 {
565 int32_t ret;
566
567 ret = UsbSubmitRequestAsync(g_acm->readReq[0]);
568 EXPECT_EQ(HDF_SUCCESS, ret);
569 }
570
571 }
572