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 <stdio.h>
17 #include <sys/time.h>
18 #include <hdf_log.h>
19 #include <hdf_remote_service.h>
20 #include <hdf_sbuf.h>
21 #include <osal_time.h>
22 #include <servmgr_hdi.h>
23 #include <signal.h>
24 #include <unistd.h>
25 #include "cdcacm.h"
26 #include "usb_dev_test.h"
27
28 #define HDF_LOG_TAG cdc_acm_speed_read
29
30 static struct HdfSBuf *g_data;
31 static struct HdfSBuf *g_reply;
32 static struct HdfRemoteService *g_acmService;
33 static bool g_readRuning = false;
TestSpeed(void)34 static void TestSpeed(void)
35 {
36 HdfSbufFlush(g_reply);
37 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService,
38 USB_SERIAL_READ_SPEED, g_data, g_reply);
39 if (status) {
40 HDF_LOGE("%{public}s: Dispatch USB_SERIAL_WRITE_SPEED failed status = %{public}d",
41 __func__, status);
42 return;
43 }
44 }
45
GetTempSpeed(void)46 static void GetTempSpeed(void)
47 {
48 float speed;
49 HdfSbufFlush(g_reply);
50 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService,
51 USB_SERIAL_READ_GET_TEMP_SPEED, g_data, g_reply);
52 if (status) {
53 HDF_LOGE("%{public}s: Dispatch USB_SERIAL_WRITE_GET_TEMP_SPEED failed status = %{public}d",
54 __func__, status);
55 return;
56 }
57 if (!HdfSbufReadFloat(g_reply, &speed)) {
58 HDF_LOGE("%{public}s: HdfSbufReadFloat failed", __func__);
59 return;
60 }
61 if (speed > 0) {
62 printf("speed : %f MB/s\n", speed);
63 }
64 }
65
ReadSpeedDone(void)66 static void ReadSpeedDone(void)
67 {
68 int32_t status = g_acmService->dispatcher->Dispatch(g_acmService,
69 USB_SERIAL_READ_SPEED_DONE, g_data, g_reply);
70 if (status) {
71 HDF_LOGE("%{public}s: Dispatch USB_SERIAL_WRITE_SPEED_DONE failed status = %{public}d",
72 __func__, status);
73 return;
74 }
75 }
76
StopReadSpeedTest(int32_t signo)77 static void StopReadSpeedTest(int32_t signo)
78 {
79 ReadSpeedDone();
80 g_readRuning = false;
81 printf("AcmSpeedRead exit.\n");
82 }
83
AcmSpeedRead(int32_t argc,const char * argv[])84 int32_t AcmSpeedRead(int32_t argc, const char *argv[])
85 {
86 (void)argc;
87 (void)argv;
88 int32_t status;
89 struct HDIServiceManager *servmgr = HDIServiceManagerGet();
90 if (servmgr == NULL) {
91 HDF_LOGE("%{public}s: HDIServiceManagerGet err", __func__);
92 return HDF_FAILURE;
93 }
94 g_acmService = servmgr->GetService(servmgr, "usbfn_cdcacm");
95 HDIServiceManagerRelease(servmgr);
96 if (g_acmService == NULL) {
97 HDF_LOGE("%{public}s: GetService err", __func__);
98 return HDF_FAILURE;
99 }
100
101 g_data = HdfSbufTypedObtain(SBUF_IPC);
102 g_reply = HdfSbufTypedObtain(SBUF_IPC);
103 if (g_data == NULL || g_reply == NULL) {
104 HDF_LOGE("%{public}s: GetService err", __func__);
105 return HDF_FAILURE;
106 }
107
108 status = g_acmService->dispatcher->Dispatch(g_acmService, USB_SERIAL_OPEN, g_data, g_reply);
109 if (status) {
110 HDF_LOGE("%{public}s: Dispatch USB_SERIAL_OPEN err", __func__);
111 return HDF_FAILURE;
112 }
113
114 (void)signal(SIGINT, StopReadSpeedTest);
115 TestSpeed();
116 g_readRuning = true;
117 while (g_readRuning) {
118 sleep(0x2);
119 if (g_readRuning) {
120 GetTempSpeed();
121 }
122 }
123
124 status = g_acmService->dispatcher->Dispatch(g_acmService, USB_SERIAL_CLOSE, g_data, g_reply);
125 if (status) {
126 HDF_LOGE("%{public}s: Dispatch USB_SERIAL_CLOSE err", __func__);
127 return HDF_FAILURE;
128 }
129
130 HdfSbufRecycle(g_data);
131 HdfSbufRecycle(g_reply);
132
133 return 0;
134 }
135