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