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