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 (void)arg;
39 int32_t value = HDF_SENSOR_TEST_VALUE;
40 struct SensorReportEvent event;
41 OsalTimespec time;
42
43 (void)memset_s(&event, sizeof(event), 0, sizeof(event));
44 (void)memset_s(&time, sizeof(time), 0, sizeof(time));
45 (void)OsalGetTime(&time);
46
47 event.timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; // nanosecond
48 event.sensorId = SENSOR_TAG_NONE;
49 event.option = 0;
50 event.mode = SENSOR_WORK_MODE_REALTIME;
51 event.dataLen = sizeof(value);
52 event.data = (uint8_t *)&value;
53 ReportSensorEvent(&event);
54 }
55
SensorTestTimerEntry(uintptr_t arg)56 static void SensorTestTimerEntry(uintptr_t arg)
57 {
58 int64_t interval;
59 struct SensorTestDrvData *drvData = (struct SensorTestDrvData *)arg;
60 CHECK_NULL_PTR_RETURN(drvData);
61
62 if (!HdfAddWork(&drvData->workQueue, &drvData->work)) {
63 HDF_LOGE("%s: sensor test add work queue failed", __func__);
64 }
65
66 interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT));
67 interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval;
68
69 if (OsalTimerSetTimeout(&drvData->timer, interval) != HDF_SUCCESS) {
70 HDF_LOGE("%s: sensor test modify time failed", __func__);
71 }
72 }
73
SensorInitTestConfig(void)74 static int32_t SensorInitTestConfig(void)
75 {
76 struct SensorTestDrvData *drvData = GetSensorTestDrvData();
77
78 if (HdfWorkQueueInit(&drvData->workQueue, HDF_SENSOR_TEST_WORK_QUEUE_NAME) != HDF_SUCCESS) {
79 HDF_LOGE("%s: sensor test init work queue failed", __func__);
80 return HDF_FAILURE;
81 }
82
83 if (HdfWorkInit(&drvData->work, SensorTestDataWorkEntry, drvData) != HDF_SUCCESS) {
84 HDF_LOGE("%s: sensor test create thread failed", __func__);
85 return HDF_FAILURE;
86 }
87
88 drvData->enable = false;
89 drvData->initStatus = true;
90
91 return HDF_SUCCESS;
92 }
93
SensorEnableTest(void)94 static int32_t SensorEnableTest(void)
95 {
96 int32_t ret;
97 struct SensorTestDrvData *drvData = GetSensorTestDrvData();
98
99 if (drvData->enable) {
100 HDF_LOGE("%s: sensor test had enable", __func__);
101 return HDF_SUCCESS;
102 }
103
104 ret = OsalTimerCreate(&drvData->timer, SENSOR_TIMER_MIN_TIME, SensorTestTimerEntry, (uintptr_t)drvData);
105 if (ret != HDF_SUCCESS) {
106 HDF_LOGE("%s: sensor test create timer failed[%d]", __func__, ret);
107 return ret;
108 }
109
110 ret = OsalTimerStartLoop(&drvData->timer);
111 if (ret != HDF_SUCCESS) {
112 HDF_LOGE("%s: sensor test start timer failed[%d]", __func__, ret);
113 return ret;
114 }
115 drvData->enable = true;
116
117 return HDF_SUCCESS;
118 }
119
SensorDisableTest(void)120 static int32_t SensorDisableTest(void)
121 {
122 int32_t ret;
123 struct SensorTestDrvData *drvData = GetSensorTestDrvData();
124
125 if (!drvData->enable) {
126 HDF_LOGE("%s: sensor test had disable", __func__);
127 return HDF_SUCCESS;
128 }
129
130 if (drvData->timer.realTimer != NULL) {
131 ret = OsalTimerDelete(&drvData->timer);
132 if (ret != HDF_SUCCESS) {
133 HDF_LOGE("%s: sensor test delete timer failed", __func__);
134 return ret;
135 }
136 }
137
138 drvData->enable = false;
139
140 return HDF_SUCCESS;
141 }
142
SensorSetBatchTest(int64_t samplingInterval,int64_t interval)143 static int32_t SensorSetBatchTest(int64_t samplingInterval, int64_t interval)
144 {
145 struct SensorTestDrvData *drvData = NULL;
146 (void)interval;
147
148 drvData = GetSensorTestDrvData();
149
150 drvData->interval = samplingInterval;
151 return HDF_SUCCESS;
152 }
153
SensorSetModeTest(int32_t mode)154 static int32_t SensorSetModeTest(int32_t mode)
155 {
156 return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE;
157 }
158
SensorSetOptionTest(uint32_t option)159 static int32_t SensorSetOptionTest(uint32_t option)
160 {
161 (void)option;
162 return HDF_SUCCESS;
163 }
164
SensorTestDispatch(struct HdfDeviceIoClient * client,int cmd,struct HdfSBuf * data,struct HdfSBuf * reply)165 static int32_t SensorTestDispatch(struct HdfDeviceIoClient *client,
166 int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
167 {
168 (void)client;
169 (void)cmd;
170 (void)data;
171 (void)reply;
172
173 return HDF_SUCCESS;
174 }
175
BindSensorDriverTest(struct HdfDeviceObject * device)176 int32_t BindSensorDriverTest(struct HdfDeviceObject *device)
177 {
178 static struct IDeviceIoService service = {
179 .object = {0},
180 .Dispatch = SensorTestDispatch,
181 };
182
183 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
184
185 device->service = &service;
186 return HDF_SUCCESS;
187 }
188
InitSensorDriverTest(struct HdfDeviceObject * device)189 int32_t InitSensorDriverTest(struct HdfDeviceObject *device)
190 {
191 int32_t ret;
192 struct SensorDeviceInfo deviceInfo = {
193 .sensorInfo = {
194 .sensorName = "sensor_test",
195 .vendorName = "default",
196 .firmwareVersion = "1.0",
197 .hardwareVersion = "1.0",
198 .sensorTypeId = SENSOR_TAG_NONE,
199 .sensorId = SENSOR_TAG_NONE,
200 .maxRange = SENSOR_TEST_MAX_RANGE,
201 .accuracy = 1,
202 .power = SENSOR_TEST_MAX_POWER,
203 },
204 .ops = {
205 .Enable = SensorEnableTest,
206 .Disable = SensorDisableTest,
207 .SetBatch = SensorSetBatchTest,
208 .SetMode = SensorSetModeTest,
209 .SetOption = SensorSetOptionTest,
210 },
211 };
212
213 (void)device;
214
215 ret = SensorInitTestConfig();
216 if (ret != HDF_SUCCESS) {
217 HDF_LOGE("%s: sensor test config failed", __func__);
218 return ret;
219 }
220
221 ret = AddSensorDevice(&deviceInfo);
222 if (ret != HDF_SUCCESS) {
223 HDF_LOGE("%s: sensor test register failed", __func__);
224 return ret;
225 }
226
227 HDF_LOGI("%s: init sensor test driver success", __func__);
228 return HDF_SUCCESS;
229 }
230
ReleaseSensorDriverTest(struct HdfDeviceObject * device)231 void ReleaseSensorDriverTest(struct HdfDeviceObject *device)
232 {
233 int32_t ret;
234 struct SensorTestDrvData *drvData = NULL;
235 struct SensorDeviceInfo deviceInfo = {
236 .sensorInfo = {
237 .sensorName = "sensor_test",
238 .vendorName = "default",
239 .firmwareVersion = "1.0",
240 .hardwareVersion = "1.0",
241 .sensorTypeId = SENSOR_TAG_NONE,
242 .sensorId = SENSOR_TAG_NONE,
243 .maxRange = SENSOR_TEST_MAX_RANGE,
244 .accuracy = 1,
245 .power = SENSOR_TEST_MAX_POWER,
246 }
247 };
248 drvData = GetSensorTestDrvData();
249 (void)device;
250 (void)DeleteSensorDevice(&deviceInfo.sensorInfo);
251
252 if (drvData->timer.realTimer != NULL) {
253 ret = OsalTimerDelete(&drvData->timer);
254 if (ret != HDF_SUCCESS) {
255 HDF_LOGE("%s: sensor test delete timer failed", __func__);
256 }
257 }
258 }
259
260 struct HdfDriverEntry g_sensorTestDevEntry = {
261 .moduleVersion = 1,
262 .moduleName = "HDF_SENSOR_TEST_DRIVER",
263 .Bind = BindSensorDriverTest,
264 .Init = InitSensorDriverTest,
265 .Release = ReleaseSensorDriverTest,
266 };
267
268 HDF_INIT(g_sensorTestDevEntry);
269