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