1 /*
2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include <securec.h>
10 #include "hdf_base.h"
11 #include "hdf_device_desc.h"
12 #include "hdf_sensor_test.h"
13 #include "osal_math.h"
14 #include "osal_time.h"
15 #include "sensor_platform_if.h"
16 #include "sensor_device_manager.h"
17 #include "sensor_device_type.h"
18
19 #define HDF_LOG_TAG hdf_sensor_test_c
20
21 #define HDF_SENSOR_TEST_VALUE 1024000000 // 1g = 9.8m/s^2
22 #define SENSOR_TEST_MAX_RANGE 8
23 #define SENSOR_TEST_MAX_POWER 230
24 #define HDF_SENSOR_TEST_WORK_QUEUE_NAME "hdf_sensor_test_work_queue"
25
GetSensorTestDrvData(void)26 static struct SensorTestDrvData *GetSensorTestDrvData(void)
27 {
28 static struct SensorTestDrvData sensorTestDrvData = {
29 .enable = false,
30 .initStatus = false,
31 .interval = SENSOR_TEST_SAMPLING_200_MS,
32 };
33
34 return &sensorTestDrvData;
35 }
SensorTestDataWorkEntry(void * arg)36 static void SensorTestDataWorkEntry(void *arg)
37 {
38 int32_t value = HDF_SENSOR_TEST_VALUE;
39 struct SensorReportEvent event;
40 OsalTimespec time;
41
42 (void)memset_s(&event, sizeof(event), 0, sizeof(event));
43 (void)memset_s(&time, sizeof(time), 0, sizeof(time));
44 (void)OsalGetTime(&time);
45
46 event.timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; // nanosecond
47 event.sensorId = SENSOR_TAG_NONE;
48 event.option = 0;
49 event.mode = SENSOR_WORK_MODE_REALTIME;
50 event.dataLen = sizeof(value);
51 event.data = (uint8_t *)&value;
52 ReportSensorEvent(&event);
53 }
54
SensorTestTimerEntry(uintptr_t arg)55 static void SensorTestTimerEntry(uintptr_t arg)
56 {
57 int64_t interval;
58 struct SensorTestDrvData *drvData = (struct SensorTestDrvData *)arg;
59 CHECK_NULL_PTR_RETURN(drvData);
60
61 if (!HdfAddWork(&drvData->workQueue, &drvData->work)) {
62 HDF_LOGE("%s: sensor test add work queue failed", __func__);
63 }
64
65 interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT));
66 interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval;
67
68 if (OsalTimerSetTimeout(&drvData->timer, interval) != HDF_SUCCESS) {
69 HDF_LOGE("%s: sensor test modify time failed", __func__);
70 }
71 }
72
SensorInitTestConfig(void)73 static int32_t SensorInitTestConfig(void)
74 {
75 struct SensorTestDrvData *drvData = GetSensorTestDrvData();
76
77 if (HdfWorkQueueInit(&drvData->workQueue, HDF_SENSOR_TEST_WORK_QUEUE_NAME) != HDF_SUCCESS) {
78 HDF_LOGE("%s: sensor test init work queue failed", __func__);
79 return HDF_FAILURE;
80 }
81
82 if (HdfWorkInit(&drvData->work, SensorTestDataWorkEntry, drvData) != HDF_SUCCESS) {
83 HDF_LOGE("%s: sensor test create thread failed", __func__);
84 return HDF_FAILURE;
85 }
86
87 drvData->enable = false;
88 drvData->initStatus = true;
89
90 return HDF_SUCCESS;
91 }
92
SensorEnableTest(void)93 static int32_t SensorEnableTest(void)
94 {
95 int32_t ret;
96 struct SensorTestDrvData *drvData = GetSensorTestDrvData();
97
98 if (drvData->enable) {
99 HDF_LOGE("%s: sensor test had enable", __func__);
100 return HDF_SUCCESS;
101 }
102
103 ret = OsalTimerCreate(&drvData->timer, SENSOR_TIMER_MIN_TIME, SensorTestTimerEntry, (uintptr_t)drvData);
104 if (ret != HDF_SUCCESS) {
105 HDF_LOGE("%s: sensor test create timer failed[%d]", __func__, ret);
106 return ret;
107 }
108
109 ret = OsalTimerStartLoop(&drvData->timer);
110 if (ret != HDF_SUCCESS) {
111 HDF_LOGE("%s: sensor test start timer failed[%d]", __func__, ret);
112 return ret;
113 }
114 drvData->enable = true;
115
116 return HDF_SUCCESS;
117 }
118
SensorDisableTest(void)119 static int32_t SensorDisableTest(void)
120 {
121 int32_t ret;
122 struct SensorTestDrvData *drvData = GetSensorTestDrvData();
123
124 if (!drvData->enable) {
125 HDF_LOGE("%s: sensor test had disable", __func__);
126 return HDF_SUCCESS;
127 }
128
129 if (drvData->timer.realTimer != NULL) {
130 ret = OsalTimerDelete(&drvData->timer);
131 if (ret != HDF_SUCCESS) {
132 HDF_LOGE("%s: sensor test delete timer failed", __func__);
133 return ret;
134 }
135 }
136
137 drvData->enable = false;
138
139 return HDF_SUCCESS;
140 }
141
SensorSetBatchTest(int64_t samplingInterval,int64_t interval)142 static int32_t SensorSetBatchTest(int64_t samplingInterval, int64_t interval)
143 {
144 struct SensorTestDrvData *drvData = NULL;
145 (void)interval;
146
147 drvData = GetSensorTestDrvData();
148
149 drvData->interval = samplingInterval;
150 return HDF_SUCCESS;
151 }
152
SensorSetModeTest(int32_t mode)153 static int32_t SensorSetModeTest(int32_t mode)
154 {
155 return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE;
156 }
157
SensorSetOptionTest(uint32_t option)158 static int32_t SensorSetOptionTest(uint32_t option)
159 {
160 (void)option;
161 return HDF_SUCCESS;
162 }
163
SensorTestDispatch(struct HdfDeviceIoClient * client,int cmd,struct HdfSBuf * data,struct HdfSBuf * reply)164 static int32_t SensorTestDispatch(struct HdfDeviceIoClient *client,
165 int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
166 {
167 (void)client;
168 (void)cmd;
169 (void)data;
170 (void)reply;
171
172 return HDF_SUCCESS;
173 }
174
BindSensorDriverTest(struct HdfDeviceObject * device)175 int32_t BindSensorDriverTest(struct HdfDeviceObject *device)
176 {
177 static struct IDeviceIoService service = {
178 .object = {0},
179 .Dispatch = SensorTestDispatch,
180 };
181
182 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
183
184 device->service = &service;
185 return HDF_SUCCESS;
186 }
187
InitSensorDriverTest(struct HdfDeviceObject * device)188 int32_t InitSensorDriverTest(struct HdfDeviceObject *device)
189 {
190 int32_t ret;
191 struct SensorDeviceInfo deviceInfo = {
192 .sensorInfo = {
193 .sensorName = "sensor_test",
194 .vendorName = "default",
195 .firmwareVersion = "1.0",
196 .hardwareVersion = "1.0",
197 .sensorTypeId = SENSOR_TAG_NONE,
198 .sensorId = SENSOR_TAG_NONE,
199 .maxRange = SENSOR_TEST_MAX_RANGE,
200 .accuracy = 1,
201 .power = SENSOR_TEST_MAX_POWER,
202 },
203 .ops = {
204 .Enable = SensorEnableTest,
205 .Disable = SensorDisableTest,
206 .SetBatch = SensorSetBatchTest,
207 .SetMode = SensorSetModeTest,
208 .SetOption = SensorSetOptionTest,
209 },
210 };
211
212 (void)device;
213
214 ret = SensorInitTestConfig();
215 if (ret != HDF_SUCCESS) {
216 HDF_LOGE("%s: sensor test config failed", __func__);
217 return ret;
218 }
219
220 ret = AddSensorDevice(&deviceInfo);
221 if (ret != HDF_SUCCESS) {
222 HDF_LOGE("%s: sensor test register failed", __func__);
223 return ret;
224 }
225
226 HDF_LOGI("%s: init sensor test driver success", __func__);
227 return HDF_SUCCESS;
228 }
229
ReleaseSensorDriverTest(struct HdfDeviceObject * device)230 void ReleaseSensorDriverTest(struct HdfDeviceObject *device)
231 {
232 int32_t ret;
233 struct SensorTestDrvData *drvData = NULL;
234 struct SensorDeviceInfo deviceInfo = {
235 .sensorInfo = {
236 .sensorName = "sensor_test",
237 .vendorName = "default",
238 .firmwareVersion = "1.0",
239 .hardwareVersion = "1.0",
240 .sensorTypeId = SENSOR_TAG_NONE,
241 .sensorId = SENSOR_TAG_NONE,
242 .maxRange = SENSOR_TEST_MAX_RANGE,
243 .accuracy = 1,
244 .power = SENSOR_TEST_MAX_POWER,
245 }
246 };
247 drvData = GetSensorTestDrvData();
248 (void)device;
249 (void)DeleteSensorDevice(&deviceInfo.sensorInfo);
250
251 if (drvData->timer.realTimer != NULL) {
252 ret = OsalTimerDelete(&drvData->timer);
253 if (ret != HDF_SUCCESS) {
254 HDF_LOGE("%s: sensor test delete timer failed", __func__);
255 }
256 }
257 }
258
259 struct HdfDriverEntry g_sensorTestDevEntry = {
260 .moduleVersion = 1,
261 .moduleName = "HDF_SENSOR_TEST_DRIVER",
262 .Bind = BindSensorDriverTest,
263 .Init = InitSensorDriverTest,
264 .Release = ReleaseSensorDriverTest,
265 };
266
267 HDF_INIT(g_sensorTestDevEntry);
268