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 "usbhost_ddk_test.h"
17 #include <securec.h>
18 #include <signal.h>
19 #include <inttypes.h>
20
21 #define HDF_LOG_TAG USB_HOST_DDK_TEST
22
23 #ifdef __LITEOS_USB_HOST_DDK_TEST__
24 typedef enum {
25 CMD_OPEN_PARM = 0,
26 CMD_CLOSE_PARM,
27 CMD_WRITE_PARM,
28 CMD_READ_PARM,
29 CMD_GET_BAUDRATE,
30 CMD_SET_BAUDRATE,
31 CMD_WRITE_DATA_SYNC,
32 CMD_READ_DATA_SYNC,
33 CMD_CLASS_CTRL_SYNC,
34 CMD_STD_CTRL_GET_DESCRIPTOR_CMD,
35 CMD_STD_CTRL_GET_STATUS_CMD,
36 CMD_STD_CTRL_GET_CONFIGURATION,
37 CMD_STD_CTRL_GET_INTERFACE,
38 CMD_STD_CTRL_GET_DESCRIPTOR_ASYNC,
39 CMD_ADD_INTERFACE,
40 CMD_REMOVE_INTERFACE,
41 } SerialOPCmd;
42 #endif
43
44 struct TestUsbDeviceDescriptor {
45 uint16_t idVendor;
46 uint16_t idProduct;
47 uint8_t bDeviceClass;
48 uint8_t bDeviceSubClass;
49 uint8_t bDeviceProtocol;
50 };
51
52 #define BUFFER_MAX_LEN 1024
53 #define SPEED_SLEEP_TIME 300
54
55 const char *g_acmServiceName = "usbhost_acm_pnp_service";
56 const char *g_acmRawServiceName = "usbhost_acm_rawapi_service";
57 const char *g_ecmServiceName = "usbhost_ecm_pnp_service";
58
59 struct HdfSBuf *g_data = NULL;
60 struct HdfSBuf *g_reply = NULL;
61 #ifdef __LITEOS_USB_HOST_DDK_TEST__
62 static struct HdfIoService *g_acmService = NULL;
63 #else
64 struct HdfRemoteService *g_acmService = NULL;
65 #endif
66 static bool g_exitFlag = false;
67
UsbObtainSbuf()68 int32_t UsbObtainSbuf()
69 {
70 if (g_acmService == NULL) {
71 HDF_LOGE("%s:%d GetService err", __func__, __LINE__);
72 return HDF_FAILURE;
73 }
74
75 #ifdef __LITEOS_USB_HOST_DDK_TEST__
76 g_data = HdfSbufObtainDefaultSize();
77 g_reply = HdfSbufObtainDefaultSize();
78 #else
79 g_data = HdfSbufTypedObtain(SBUF_IPC);
80 g_reply = HdfSbufTypedObtain(SBUF_IPC);
81 #endif
82 if (g_data == NULL || g_reply == NULL) {
83 HDF_LOGE("%s:%d HdfSbufTypedObtain err", __func__, __LINE__);
84 return HDF_FAILURE;
85 }
86 return HDF_SUCCESS;
87 }
88
UsbHostDdkTestInit(const char * apiType)89 int32_t UsbHostDdkTestInit(const char *apiType)
90 {
91 #ifndef __LITEOS_USB_HOST_DDK_TEST__
92 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
93 if (servmgr == NULL) {
94 HDF_LOGE("%s:%d HDIServiceManagerGet err", __func__, __LINE__);
95 return HDF_FAILURE;
96 }
97 #endif
98 if (apiType == NULL) {
99 return HDF_FAILURE;
100 }
101 if (!strcmp(apiType, "-SDK")) {
102 printf("%s:%d test SDK API, service=%s\n", __func__, __LINE__, g_acmServiceName);
103 HDF_LOGI("%s:%d test SDK API, service=%s", __func__, __LINE__, g_acmServiceName);
104 #ifdef __LITEOS_USB_HOST_DDK_TEST__
105 g_acmService = HdfIoServiceBind(g_acmServiceName);
106 #else
107 g_acmService = servmgr->GetService(servmgr, g_acmServiceName);
108 #endif
109 } else if (!strcmp(apiType, "-RAW")) {
110 printf("%s:%d test RAW API, service=%s\n", __func__, __LINE__, g_acmRawServiceName);
111 HDF_LOGI("%s:%d test RAW API, service=%s", __func__, __LINE__, g_acmRawServiceName);
112 #ifdef __LITEOS_USB_HOST_DDK_TEST__
113 g_acmService = HdfIoServiceBind(g_acmRawServiceName);
114 #else
115 g_acmService = servmgr->GetService(servmgr, g_acmRawServiceName);
116 #endif
117 } else if (!strcmp(apiType, "-ECM")) {
118 printf("%s:%d test ECM API, service=%s\n", __func__, __LINE__, g_ecmServiceName);
119 HDF_LOGI("%s:%d test ECM API, service=%s", __func__, __LINE__, g_ecmServiceName);
120 #ifdef __LITEOS_USB_HOST_DDK_TEST__
121 g_acmService = HdfIoServiceBind(g_ecmServiceName);
122 #else
123 g_acmService = servmgr->GetService(servmgr, g_ecmServiceName);
124 #endif
125 } else {
126 printf("%s:%d apiType=%s is not define\n", __func__, __LINE__, apiType);
127 HDF_LOGE("%s:%d apiType=%s is not define", __func__, __LINE__, apiType);
128 return HDF_FAILURE;
129 }
130 #ifndef __LITEOS_USB_HOST_DDK_TEST__
131 HDIServiceManagerRelease(servmgr);
132 #endif
133 if (UsbObtainSbuf() != HDF_SUCCESS) {
134 return HDF_FAILURE;
135 }
136 return HDF_SUCCESS;
137 }
138
TestModuleWriteLog(int32_t cmdType,const char * string,struct TestUsbDeviceDescriptor * data)139 static void TestModuleWriteLog(int32_t cmdType, const char *string, struct TestUsbDeviceDescriptor *data)
140 {
141 #ifdef __LITEOS_USB_HOST_DDK_TEST__
142 bool runFlag = false;
143 #else
144 bool runFlag = true;
145 #endif
146 if (runFlag) {
147 int32_t ret;
148 char buffer[BUFFER_MAX_LEN];
149 FILE *fp = NULL;
150 struct timeval time;
151
152 gettimeofday(&time, NULL);
153
154 switch (cmdType) {
155 case HOST_ACM_SYNC_READ:
156 fp = fopen("/data/acm_read_xts", "a+");
157 ret = snprintf_s(buffer, BUFFER_MAX_LEN, BUFFER_MAX_LEN - 1,
158 "[XTSCHECK] %d.%06d, recv data[%s] from device\n", time.tv_sec, time.tv_usec, string);
159 break;
160 case HOST_ACM_SYNC_WRITE:
161 fp = fopen("/data/acm_write_xts", "a+");
162 ret = snprintf_s(buffer, BUFFER_MAX_LEN, BUFFER_MAX_LEN - 1,
163 "[XTSCHECK] %d.%06d, send data[%s] to device\n", time.tv_sec, time.tv_usec, string);
164 break;
165 case HOST_ACM_ASYNC_READ:
166 fp = fopen("/data/acm_read_xts", "a+");
167 ret = snprintf_s(buffer, BUFFER_MAX_LEN, BUFFER_MAX_LEN - 1,
168 "[XTSCHECK] %d.%06d, recv data[%s] from device\n", time.tv_sec, time.tv_usec, string);
169 break;
170 case HOST_ACM_ASYNC_WRITE:
171 fp = fopen("/data/acm_write_xts", "a+");
172 ret = snprintf_s(buffer, BUFFER_MAX_LEN, BUFFER_MAX_LEN - 1,
173 "[XTSCHECK] %d.%06d, send data[%s] to device\n", time.tv_sec, time.tv_usec, string);
174 break;
175 case HOST_ACM_CTRL_READ:
176 fp = fopen("/data/acm_read_xts", "a+");
177 ret = snprintf_s(buffer, BUFFER_MAX_LEN, BUFFER_MAX_LEN - 1,
178 "[XTSCHECK] %d.%06d, %s\n", time.tv_sec, time.tv_usec, string);
179 break;
180 case HOST_ACM_CTRL_WRITE:
181 fp = fopen("/data/acm_write_xts", "a+");
182 ret = snprintf_s(buffer, BUFFER_MAX_LEN, BUFFER_MAX_LEN - 1,
183 "[XTSCHECK] %d.%06d, usb serial control command[%s] done\n", time.tv_sec, time.tv_usec, string);
184 break;
185 case HOST_ACM_SPEED_TEST:
186 ret = HDF_SUCCESS;
187 break;
188 default:
189 ret = HDF_SUCCESS;
190 break;
191 }
192
193 if (ret < HDF_SUCCESS) {
194 printf("%s:%d cmdType=%d snprintf_s failed ret=%d\n", __func__, __LINE__, cmdType, ret);
195 HDF_LOGE("%s:%d cmdType=%d snprintf_s failed", __func__, __LINE__, cmdType);
196 goto OUT;
197 }
198
199 (void)fwrite(buffer, strlen(buffer), 1, fp);
200
201 OUT:
202 (void)fclose(fp);
203 }
204 }
205
UsbHostDdkTestAsyncRead(char * readSbuf)206 int32_t UsbHostDdkTestAsyncRead(char *readSbuf)
207 {
208 HdfSbufFlush(g_reply);
209 #ifdef __LITEOS_USB_HOST_DDK_TEST__
210 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_READ_PARM, g_data, g_reply);
211 #else
212 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_READ_PARM, g_data, g_reply);
213 #endif
214 if (status < 0) {
215 g_exitFlag = true;
216 printf("%s:%d Dispatch USB_SERIAL_READ failed status = %d\n", __func__, __LINE__, status);
217 HDF_LOGE("%s:%d Dispatch USB_SERIAL_READ failed status = %d",
218 __func__, __LINE__, status);
219 return status;
220 }
221
222 const char *tmp = HdfSbufReadString(g_reply);
223 if (tmp && strlen(tmp) > 0) {
224 if (readSbuf != NULL) {
225 errno_t err = memcpy_s(readSbuf, DATA_MAX_LEN, tmp, strlen(tmp));
226 if (err != EOK) {
227 HDF_LOGE("%s:%d err=%d", __func__, __LINE__, err);
228 }
229 }
230 printf("%s:%d %s-%zu!\n", __func__, __LINE__, tmp, strlen(tmp));
231 HDF_LOGD("%s:%d %s-%zu!", __func__, __LINE__, tmp, strlen(tmp));
232 TestModuleWriteLog(HOST_ACM_ASYNC_READ, tmp, NULL);
233 }
234
235 return HDF_SUCCESS;
236 }
237
UsbHostDdkTestAsyncWrite(const char * buf)238 void UsbHostDdkTestAsyncWrite(const char *buf)
239 {
240 if (buf == NULL) {
241 return;
242 }
243 HdfSbufFlush(g_data);
244
245 if (!HdfSbufWriteString(g_data, buf)) {
246 printf("%s:%d HdfSbufWriteString error\n", __func__, __LINE__);
247 HDF_LOGE("%s:%d HdfSbufWriteString error", __func__, __LINE__);
248 return;
249 }
250
251 #ifdef __LITEOS_USB_HOST_DDK_TEST__
252 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_WRITE_PARM, g_data, g_reply);
253 #else
254 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_WRITE_PARM, g_data, g_reply);
255 #endif
256 if (status <= HDF_SUCCESS) {
257 g_exitFlag = true;
258 printf("%s:%d Dispatch USB_SERIAL_WRITE failed status = %d\n", __func__, __LINE__, status);
259 HDF_LOGE("%s:%d Dispatch USB_SERIAL_WRITE failed status = %d",
260 __func__, __LINE__, status);
261 return;
262 }
263
264 printf("%s:%d %s-%zu!\n", __func__, __LINE__, buf, strlen(buf));
265 HDF_LOGI("%s:%d %s-%zu!\n", __func__, __LINE__, buf, strlen(buf));
266 TestModuleWriteLog(HOST_ACM_ASYNC_WRITE, buf, NULL);
267 }
268
UsbHostDdkTestSyncRead(char * readSbuf)269 void UsbHostDdkTestSyncRead(char *readSbuf)
270 {
271 HdfSbufFlush(g_reply);
272
273 #ifdef __LITEOS_USB_HOST_DDK_TEST__
274 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_READ_DATA_SYNC, g_data, g_reply);
275 #else
276 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_READ_DATA_SYNC, g_data, g_reply);
277 #endif
278 if (status) {
279 g_exitFlag = true;
280 printf("%s:%d Dispatch CMD_READ_DATA_SYNC failed status = %d\n", __func__, __LINE__, status);
281 HDF_LOGE("%s:%d Dispatch CMD_READ_DATA_SYNC failed status = %d",
282 __func__, __LINE__, status);
283 return;
284 }
285
286 const char *tmp = HdfSbufReadString(g_reply);
287 if (tmp && strlen(tmp) > 0) {
288 if (readSbuf != NULL) {
289 errno_t err = memcpy_s(readSbuf, DATA_MAX_LEN, tmp, strlen(tmp));
290 if (err != EOK) {
291 HDF_LOGE("%s:%d err=%d", __func__, __LINE__, err);
292 }
293 }
294 printf("%s:%d %s-%zu!\n", __func__, __LINE__, tmp, strlen(tmp));
295 HDF_LOGD("%s:%d %s-%zu !", __func__, __LINE__, tmp, strlen(tmp));
296 TestModuleWriteLog(HOST_ACM_SYNC_READ, tmp, NULL);
297 }
298 }
299
UsbHostDdkTestSyncWrite(const char * buf)300 void UsbHostDdkTestSyncWrite(const char *buf)
301 {
302 HdfSbufFlush(g_data);
303
304 if (!HdfSbufWriteString(g_data, buf)) {
305 printf("%s:%d HdfSbufWriteString error\n", __func__, __LINE__);
306 HDF_LOGE("%s:%d HdfSbufWriteString error", __func__, __LINE__);
307 return;
308 }
309
310 #ifdef __LITEOS_USB_HOST_DDK_TEST__
311 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_WRITE_DATA_SYNC, g_data, g_reply);
312 #else
313 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_WRITE_DATA_SYNC, g_data, g_reply);
314 #endif
315 if (status < HDF_SUCCESS) {
316 g_exitFlag = true;
317 printf("%s:%d Dispatch CMD_WRITE_DATA_SYNC failed status = %d\n", __func__, __LINE__, status);
318 HDF_LOGE("%s:%d Dispatch CMD_WRITE_DATA_SYNC failed status = %d",
319 __func__, __LINE__, status);
320 return;
321 }
322
323 printf("%s:%d %s-%zu!\n", __func__, __LINE__, buf, strlen(buf));
324 HDF_LOGD("%s:%d %s-%zu!", __func__, __LINE__, buf, strlen(buf));
325 TestModuleWriteLog(HOST_ACM_SYNC_WRITE, buf, NULL);
326 }
327
UsbHostDdkTestCtrlClass(char * readSbuf)328 void UsbHostDdkTestCtrlClass(char *readSbuf)
329 {
330 HdfSbufFlush(g_reply);
331
332 #ifdef __LITEOS_USB_HOST_DDK_TEST__
333 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_CLASS_CTRL_SYNC, g_data, g_reply);
334 #else
335 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_CLASS_CTRL_SYNC, g_data, g_reply);
336 #endif
337 if (status < 0) {
338 g_exitFlag = true;
339 printf("%s:%d Dispatch CMD_CLASS_CTRL_SYNC failed status = %d\n", __func__, __LINE__, status);
340 HDF_LOGE("%s:%d Dispatch CMD_CLASS_CTRL_SYNC failed status = %d",
341 __func__, __LINE__, status);
342 } else {
343 if (readSbuf != NULL) {
344 const char tmp[] = "CMD_CLASS_CTRL";
345 errno_t err = memcpy_s(readSbuf, DATA_MAX_LEN, tmp, strlen(tmp));
346 if (err != EOK) {
347 HDF_LOGE("%s:%d err=%d", __func__, __LINE__, err);
348 }
349 }
350 printf("%s:%d usb serial control CMD_CLASS_CTRL command done\n", __func__, __LINE__);
351 TestModuleWriteLog(HOST_ACM_CTRL_WRITE, "CMD_CLASS_CTRL", NULL);
352 }
353 }
354
UsbHostDdkTestStdGetDes(char * readSbuf)355 void UsbHostDdkTestStdGetDes(char *readSbuf)
356 {
357 HdfSbufFlush(g_reply);
358 #ifdef __LITEOS_USB_HOST_DDK_TEST__
359 int32_t status = g_acmService->dispatcher->Dispatch(
360 &g_acmService->object, CMD_STD_CTRL_GET_DESCRIPTOR_CMD, g_data, g_reply);
361 #else
362 int32_t status = g_acmService->dispatcher->Dispatch(
363 g_acmService, CMD_STD_CTRL_GET_DESCRIPTOR_CMD, g_data, g_reply);
364 #endif
365 if (status < 0) {
366 g_exitFlag = true;
367 printf("%s:%d Dispatch UsbHostDdkTestStdGetDes failed status = %d\n", __func__, __LINE__, status);
368 HDF_LOGE("%s:%d Dispatch UsbHostDdkTestStdGetDes failed status = %d",
369 __func__, __LINE__, status);
370 }
371
372 printf("%s:%d usb serial control CMD_STD_CTRL_GET_DESCRIPTOR command done\n", __func__, __LINE__);
373 TestModuleWriteLog(HOST_ACM_CTRL_WRITE, "CMD_STD_CTRL_GET_DESCRIPTOR", NULL);
374 const char *tmp = HdfSbufReadString(g_reply);
375 if (tmp && strlen(tmp) > 0) {
376 if (readSbuf != NULL) {
377 errno_t err = memcpy_s(readSbuf, DATA_MAX_LEN, tmp, strlen(tmp));
378 if (err != EOK) {
379 HDF_LOGE("%s:%d err=%d", __func__, __LINE__, err);
380 }
381 }
382 printf("%s:%d %s!\n", __func__, __LINE__, tmp);
383 TestModuleWriteLog(HOST_ACM_CTRL_READ, tmp, NULL);
384 } else {
385 printf("%s:%d HdfSbufReadBuffer faile\n", __func__, __LINE__);
386 HDF_LOGE("%s:%d HdfSbufReadBuffer faile", __func__, __LINE__);
387 }
388 }
389
UsbHostDdkTestStdGetDesAsync(char * readSbuf)390 void UsbHostDdkTestStdGetDesAsync(char *readSbuf)
391 {
392 HdfSbufFlush(g_reply);
393 #ifdef __LITEOS_USB_HOST_DDK_TEST__
394 int32_t status = g_acmService->dispatcher->Dispatch(
395 &g_acmService->object, CMD_STD_CTRL_GET_DESCRIPTOR_ASYNC, g_data, g_reply);
396 #else
397 int32_t status = g_acmService->dispatcher->Dispatch(
398 g_acmService, CMD_STD_CTRL_GET_DESCRIPTOR_ASYNC, g_data, g_reply);
399 #endif
400 if (status < 0) {
401 g_exitFlag = true;
402 printf("%s:%d Dispatch CMD_STD_CTRL_GET_DESCRIPTOR_ASYNC failed status = %d\n", __func__, __LINE__, status);
403 HDF_LOGE("%s:%d Dispatch CMD_STD_CTRL_GET_DESCRIPTOR_ASYNC failed status = %d",
404 __func__, __LINE__, status);
405 return;
406 }
407
408 printf("%s:%d usb serial control CMD_STD_CTRL_GET_DESCRIPTOR_ASYNC command done\n", __func__, __LINE__);
409 TestModuleWriteLog(HOST_ACM_CTRL_WRITE, "CMD_STD_CTRL_GET_DESCRIPTOR_ASYNC", NULL);
410 const char *tmp = HdfSbufReadString(g_reply);
411 if (tmp && strlen(tmp) > 0) {
412 if (readSbuf != NULL) {
413 errno_t err = memcpy_s(readSbuf, DATA_MAX_LEN, tmp, strlen(tmp));
414 if (err != EOK) {
415 HDF_LOGE("%s:%d err=%d", __func__, __LINE__, err);
416 }
417 }
418 printf("%s:%d %s!\n", __func__, __LINE__, tmp);
419 TestModuleWriteLog(HOST_ACM_CTRL_READ, tmp, NULL);
420 } else {
421 printf("%s:%d HdfSbufReadBuffer faile\n", __func__, __LINE__);
422 HDF_LOGE("%s:%d HdfSbufReadBuffer faile", __func__, __LINE__);
423 }
424 }
425
UsbHostDdkTestStdGetStatus(char * readSbuf)426 void UsbHostDdkTestStdGetStatus(char *readSbuf)
427 {
428 uint16_t data = 0;
429
430 HdfSbufFlush(g_reply);
431 #ifdef __LITEOS_USB_HOST_DDK_TEST__
432 int32_t status = g_acmService->dispatcher->Dispatch(
433 &g_acmService->object, CMD_STD_CTRL_GET_STATUS_CMD, g_data, g_reply);
434 #else
435 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_STD_CTRL_GET_STATUS_CMD, g_data, g_reply);
436 #endif
437 if (status < 0) {
438 g_exitFlag = true;
439 printf("%s:%d Dispatch CMD_STD_CTRL_GET_STATUS_CMD failed status = %d\n", __func__, __LINE__, status);
440 HDF_LOGE("%s:%d Dispatch CMD_STD_CTRL_GET_STATUS_CMD failed status = %d",
441 __func__, __LINE__, status);
442 }
443
444 status = HdfSbufReadUint16(g_reply, &data);
445 if (status == false) {
446 printf("%s:%d HdfSbufReadBuffer status = %d\n", __func__, __LINE__, status);
447 HDF_LOGE("%s:%d HdfSbufReadBuffer status=%d",
448 __func__, __LINE__, status);
449 } else {
450 if (readSbuf != NULL) {
451 const char tmp[DATA_MAX_LEN] = "CMD_STD_CTRL_GET_STATUS";
452 errno_t err = memcpy_s(readSbuf, DATA_MAX_LEN, tmp, strlen(tmp));
453 if (err != EOK) {
454 HDF_LOGE("%s:%d err=%d", __func__, __LINE__, err);
455 }
456 }
457 printf("%s:%d usb serial control CMD_STD_CTRL_GET_STATUS command done,data=%d\n", __func__, __LINE__, data);
458 TestModuleWriteLog(HOST_ACM_CTRL_WRITE, "CMD_STD_CTRL_GET_STATUS", NULL);
459 }
460 }
461
TestStdGetConf(void)462 void TestStdGetConf(void)
463 {
464 uint8_t data;
465
466 HdfSbufFlush(g_reply);
467
468 #ifdef __LITEOS_USB_HOST_DDK_TEST__
469 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_STD_CTRL_GET_CONFIGURATION,
470 g_data, g_reply);
471 #else
472 int32_t status = g_acmService->dispatcher->Dispatch(
473 g_acmService, CMD_STD_CTRL_GET_CONFIGURATION, g_data, g_reply);
474 #endif
475 if (status < 0) {
476 g_exitFlag = true;
477 printf("%s:%d Dispatch CMD_STD_CTRL_GET_CONFIGURATION failed status = %d\n", __func__, __LINE__, status);
478 HDF_LOGE("%s:%d Dispatch CMD_STD_CTRL_GET_CONFIGURATION failed status = %d",
479 __func__, __LINE__, status);
480 }
481
482 printf("%s:%d usb serial control CMD_STD_CTRL_GET_CONFIGURATION command done\n", __func__, __LINE__);
483 TestModuleWriteLog(HOST_ACM_CTRL_WRITE, "CMD_STD_CTRL_GET_CONFIGURATION", NULL);
484 status = HdfSbufReadUint8(g_reply, &data);
485 if (status < 0) {
486 printf("%s:%d HdfSbufReadBuffer status = %d\n", __func__, __LINE__, status);
487 HDF_LOGE("%s:%d HdfSbufReadBuffer status = %d", __func__, __LINE__, status);
488 }
489 }
490
TestStdGetInterface(void)491 void TestStdGetInterface(void)
492 {
493 uint8_t data;
494
495 HdfSbufFlush(g_reply);
496 #ifdef __LITEOS_USB_HOST_DDK_TEST__
497 int32_t status = g_acmService->dispatcher->Dispatch(
498 &g_acmService->object, CMD_STD_CTRL_GET_INTERFACE, g_data, g_reply);
499 #else
500 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_STD_CTRL_GET_INTERFACE, g_data, g_reply);
501 #endif
502 if (status < 0) {
503 g_exitFlag = true;
504 printf("%s:%d Dispatch CMD_STD_CTRL_GET_INTERFACE failed status = %d\n", __func__, __LINE__, status);
505 HDF_LOGE("%s:%d Dispatch CMD_STD_CTRL_GET_INTERFACE failed status = %d",
506 __func__, __LINE__, status);
507 }
508
509 printf("%s:%d usb serial control CMD_STD_CTRL_GET_INTERFACE command done\n", __func__, __LINE__);
510 TestModuleWriteLog(HOST_ACM_CTRL_WRITE, "CMD_STD_CTRL_GET_INTERFACE", NULL);
511 status = HdfSbufReadUint8(g_reply, &data);
512 if (status < 0) {
513 printf("%s:%d HdfSbufReadBuffer status = %d\n", __func__, __LINE__, status);
514 HDF_LOGE("%s:%d HdfSbufReadBuffer status = %d", __func__, __LINE__, status);
515 }
516 }
517
UsbHostDdkTestSetBaudrate(uint32_t value)518 void UsbHostDdkTestSetBaudrate(uint32_t value)
519 {
520 HdfSbufFlush(g_data);
521
522 if (!HdfSbufWriteUint32(g_data, value)) {
523 printf("%s:%d HdfSbufWriteString error\n", __func__, __LINE__);
524 HDF_LOGE("%s:%d HdfSbufWriteString error", __func__, __LINE__);
525 return;
526 }
527
528 #ifdef __LITEOS_USB_HOST_DDK_TEST__
529 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_SET_BAUDRATE, g_data, g_reply);
530 #else
531 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_SET_BAUDRATE, g_data, g_reply);
532 #endif
533 if (status != HDF_SUCCESS) {
534 g_exitFlag = true;
535 printf("%s:%d Dispatch CMD_SET_BAUDRATE failed status = %d\n", __func__, __LINE__, status);
536 HDF_LOGE("%s:%d Dispatch CMD_SET_BAUDRATE failed status = %d",
537 __func__, __LINE__, status);
538 return;
539 }
540
541 printf("%s:%d CMD_SET_BAUDRATE success\n", __func__, __LINE__);
542 HDF_LOGI("%s:%d CMD_SET_BAUDRATE success", __func__, __LINE__);
543 TestModuleWriteLog(HOST_ACM_CTRL_WRITE, "CMD_SET_BAUDRATE", NULL);
544 }
545
UsbHostDdkTestGetBaudrate(char * readSbuf)546 void UsbHostDdkTestGetBaudrate(char *readSbuf)
547 {
548 uint32_t value = 0;
549
550 HdfSbufFlush(g_reply);
551 #ifdef __LITEOS_USB_HOST_DDK_TEST__
552 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_GET_BAUDRATE, g_data, g_reply);
553 #else
554 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_GET_BAUDRATE, g_data, g_reply);
555 #endif
556 if (status < 0) {
557 g_exitFlag = true;
558 printf("%s:%d Dispatch CMD_GET_BAUDRATE failed status = %d\n", __func__, __LINE__, status);
559 HDF_LOGE("%s:%d Dispatch CMD_GET_BAUDRATE failed status = %d",
560 __func__, __LINE__, status);
561 return;
562 }
563
564 if (HdfSbufReadUint32(g_reply, &value)) {
565 if (readSbuf != NULL) {
566 const char tmp[] = "CMD_GET_BAUDRATE";
567 errno_t err = memcpy_s(readSbuf, DATA_MAX_LEN, tmp, strlen(tmp));
568 if (err != EOK) {
569 HDF_LOGE("%s:%d err=%d", __func__, __LINE__, err);
570 }
571 }
572 printf("%s:%d baudrate=%u usb serial control CMD_GET_BAUDRATE command done\n", __func__, __LINE__, value);
573 TestModuleWriteLog(HOST_ACM_CTRL_WRITE, "CMD_GET_BAUDRATE", NULL);
574 } else {
575 printf("%s:%d HdfSbufReadUint32 failed!\n", __func__, __LINE__);
576 HDF_LOGD("%s:%d HdfSbufReadUint32 failed!",
577 __func__, __LINE__);
578 }
579 }
580
UsbHostDdkTestAddInterface(uint32_t value)581 void UsbHostDdkTestAddInterface(uint32_t value)
582 {
583 HdfSbufFlush(g_data);
584
585 if (!HdfSbufWriteUint32(g_data, value)) {
586 HDF_LOGE("%s:%d HdfSbufWriteString error", __func__, __LINE__);
587 return;
588 }
589
590 #ifdef __LITEOS_USB_HOST_DDK_TEST__
591 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_ADD_INTERFACE, g_data, g_reply);
592 #else
593 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_ADD_INTERFACE, g_data, g_reply);
594 #endif
595 if (status != HDF_SUCCESS) {
596 g_exitFlag = true;
597 HDF_LOGE("%s:%d Dispatch CMD_ADD_INTERFACE failed status = %d",
598 __func__, __LINE__, status);
599 return;
600 }
601
602 printf("%s:%d CMD_ADD_INTERFACE success!\n", __func__, __LINE__);
603 HDF_LOGD("%s:%d CMD_ADD_INTERFACE success!", __func__, __LINE__);
604 }
605
UsbHostDdkTestRemoveInterface(uint32_t value)606 void UsbHostDdkTestRemoveInterface(uint32_t value)
607 {
608 HdfSbufFlush(g_data);
609
610 if (!HdfSbufWriteUint32(g_data, value)) {
611 HDF_LOGE("%s:%d HdfSbufWriteString error", __func__, __LINE__);
612 return;
613 }
614
615 #ifdef __LITEOS_USB_HOST_DDK_TEST__
616 int32_t status = g_acmService->dispatcher->Dispatch(
617 &g_acmService->object, CMD_REMOVE_INTERFACE, g_data, g_reply);
618 #else
619 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_REMOVE_INTERFACE, g_data, g_reply);
620 #endif
621 if (status != HDF_SUCCESS) {
622 g_exitFlag = true;
623 HDF_LOGE("%s:%d Dispatch CMD_REMOVE_INTERFACE failed status = %d",
624 __func__, __LINE__, status);
625 return;
626 }
627
628 printf("%s:%d CMD_REMOVE_INTERFACE success!\n", __func__, __LINE__);
629 HDF_LOGD("%s:%d CMD_REMOVE_INTERFACE success!", __func__, __LINE__);
630 }
631
UsbHostDdkTestOpen(int32_t cmdType)632 int32_t UsbHostDdkTestOpen(int32_t cmdType)
633 {
634 if (g_exitFlag == true) {
635 HDF_LOGD("%s:%d g_exitFlag is true!", __func__, __LINE__);
636 return HDF_FAILURE;
637 }
638
639 HdfSbufFlush(g_data);
640 if (!HdfSbufWriteInt32(g_data, cmdType)) {
641 HDF_LOGE("%s:%d HdfSbufWriteString error", __func__, __LINE__);
642 return HDF_FAILURE;
643 }
644
645 #ifdef __LITEOS_USB_HOST_DDK_TEST__
646 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_OPEN_PARM, g_data, g_reply);
647 #else
648 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_OPEN_PARM, g_data, g_reply);
649 #endif
650 if (status) {
651 g_exitFlag = true;
652 HDF_LOGE("%s:%d Dispatch CMD_OPEN_PARM status=%d err",
653 __func__, __LINE__, status);
654 }
655
656 return status;
657 }
658
UsbHostDdkTestClose(int32_t cmdType)659 int32_t UsbHostDdkTestClose(int32_t cmdType)
660 {
661 if (g_exitFlag == true) {
662 HDF_LOGD("%s:%d g_exitFlag is true!", __func__, __LINE__);
663 return HDF_FAILURE;
664 }
665
666 HdfSbufFlush(g_data);
667 if (!HdfSbufWriteInt32(g_data, cmdType)) {
668 HDF_LOGE("%s:%d HdfSbufWriteString error", __func__, __LINE__);
669 return HDF_FAILURE;
670 }
671
672 #ifdef __LITEOS_USB_HOST_DDK_TEST__
673 int32_t status = g_acmService->dispatcher->Dispatch(&g_acmService->object, CMD_CLOSE_PARM, g_data, g_reply);
674 #else
675 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService, CMD_CLOSE_PARM, g_data, g_reply);
676 #endif
677 if (status) {
678 g_exitFlag = true;
679 HDF_LOGE("%s:%d Dispatch CMD_CLOSE_PARM status=%d err",
680 __func__, __LINE__, status);
681 }
682
683 return status;
684 }
685
TestExit(void)686 void TestExit(void)
687 {
688 #ifdef __LITEOS_USB_HOST_DDK_TEST__
689 HdfIoServiceRecycle(g_acmService);
690 #else
691 HdfRemoteServiceRecycle(g_acmService);
692 #endif
693 HdfSbufRecycle(g_data);
694 HdfSbufRecycle(g_reply);
695 }
696
TestGetExitFlag(void)697 bool TestGetExitFlag(void)
698 {
699 return g_exitFlag;
700 }
701