1 /*
2  * Copyright (c) 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 "sensor_barometer_driver.h"
10 #include <securec.h>
11 #include "hdf_base.h"
12 #include "hdf_device_desc.h"
13 #include "osal_math.h"
14 #include "osal_mem.h"
15 #include "sensor_config_controller.h"
16 #include "sensor_device_manager.h"
17 #include "sensor_platform_if.h"
18 
19 #define HDF_LOG_TAG    khdf_sensor_barometer_driver
20 
21 #define HDF_BAROMETER_WORK_QUEUE_NAME    "hdf_barometer_work_queue"
22 
23 static struct BarometerDrvData *g_barometerDrvData = NULL;
24 
BarometerGetDrvData(void)25 static struct BarometerDrvData *BarometerGetDrvData(void)
26 {
27     return g_barometerDrvData;
28 }
29 
30 static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL };
31 
BarometerRegisterChipOps(const struct BarometerOpsCall * ops)32 int32_t BarometerRegisterChipOps(const struct BarometerOpsCall *ops)
33 {
34     struct BarometerDrvData *drvData = BarometerGetDrvData();
35 
36     CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
37     CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM);
38 
39     drvData->ops.Init = ops->Init;
40     drvData->ops.ReadData = ops->ReadData;
41     return HDF_SUCCESS;
42 }
43 
BarometerDataWorkEntry(void * arg)44 static void BarometerDataWorkEntry(void *arg)
45 {
46     struct BarometerDrvData *drvData = NULL;
47 
48     drvData = (struct BarometerDrvData *)arg;
49     CHECK_NULL_PTR_RETURN(drvData);
50 
51     if (drvData->ops.ReadData == NULL) {
52         HDF_LOGI("%s: Barometer ReadData function NULl", __func__);
53         return;
54     }
55     if (drvData->ops.ReadData(drvData->barometerCfg) != HDF_SUCCESS) {
56         HDF_LOGE("%s: Barometer read data failed", __func__);
57     }
58 }
59 
BarometerTimerEntry(uintptr_t arg)60 static void BarometerTimerEntry(uintptr_t arg)
61 {
62     int64_t interval;
63     int32_t ret;
64     struct BarometerDrvData *drvData = (struct BarometerDrvData *)arg;
65     CHECK_NULL_PTR_RETURN(drvData);
66 
67     if (!HdfAddWork(&drvData->barometerWorkQueue, &drvData->barometerWork)) {
68         HDF_LOGE("%s: barometer add work queue failed", __func__);
69     }
70 
71     interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT));
72     interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval;
73     ret = OsalTimerSetTimeout(&drvData->barometerTimer, interval);
74     if (ret != HDF_SUCCESS) {
75         HDF_LOGE("%s: barometer modify time failed", __func__);
76     }
77 }
78 
InitBarometerData(struct BarometerDrvData * drvData)79 static int32_t InitBarometerData(struct BarometerDrvData *drvData)
80 {
81     if (HdfWorkQueueInit(&drvData->barometerWorkQueue, HDF_BAROMETER_WORK_QUEUE_NAME) != HDF_SUCCESS) {
82         HDF_LOGE("%s: barometer init work queue failed", __func__);
83         return HDF_FAILURE;
84     }
85 
86     if (HdfWorkInit(&drvData->barometerWork, BarometerDataWorkEntry, drvData) != HDF_SUCCESS) {
87         HDF_LOGE("%s: barometer create thread failed", __func__);
88         return HDF_FAILURE;
89     }
90 
91     drvData->interval = SENSOR_TIMER_MIN_TIME;
92     drvData->enable = false;
93     drvData->detectFlag = false;
94 
95     return HDF_SUCCESS;
96 }
97 
SetBarometerEnable(void)98 static int32_t SetBarometerEnable(void)
99 {
100     int32_t ret;
101     struct BarometerDrvData *drvData = BarometerGetDrvData();
102 
103     CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
104     CHECK_NULL_PTR_RETURN_VALUE(drvData->barometerCfg, HDF_ERR_INVALID_PARAM);
105 
106     if (drvData->enable) {
107         HDF_LOGE("%s: barometer sensor is enabled", __func__);
108         return HDF_SUCCESS;
109     }
110 
111     ret = SetSensorRegCfgArray(&drvData->barometerCfg->busCfg, drvData->barometerCfg->regCfgGroup[SENSOR_ENABLE_GROUP]);
112     if (ret != HDF_SUCCESS) {
113         HDF_LOGE("%s: barometer sensor enable config failed", __func__);
114         return ret;
115     }
116 
117     ret = OsalTimerCreate(&drvData->barometerTimer, SENSOR_TIMER_MIN_TIME, BarometerTimerEntry, (uintptr_t)drvData);
118     if (ret != HDF_SUCCESS) {
119         HDF_LOGE("%s: barometer create timer failed[%d]", __func__, ret);
120         return ret;
121     }
122 
123     ret = OsalTimerStartLoop(&drvData->barometerTimer);
124     if (ret != HDF_SUCCESS) {
125         HDF_LOGE("%s: barometer start timer failed[%d]", __func__, ret);
126         return ret;
127     }
128     drvData->enable = true;
129 
130     return HDF_SUCCESS;
131 }
132 
SetBarometerDisable(void)133 static int32_t SetBarometerDisable(void)
134 {
135     int32_t ret;
136     struct BarometerDrvData *drvData = BarometerGetDrvData();
137 
138     CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
139     CHECK_NULL_PTR_RETURN_VALUE(drvData->barometerCfg, HDF_ERR_INVALID_PARAM);
140 
141     if (!drvData->enable) {
142         HDF_LOGE("%s: barometer sensor had disable", __func__);
143         return HDF_SUCCESS;
144     }
145 
146     ret = SetSensorRegCfgArray(&drvData->barometerCfg->busCfg,
147         drvData->barometerCfg->regCfgGroup[SENSOR_DISABLE_GROUP]);
148     if (ret != HDF_SUCCESS) {
149         HDF_LOGE("%s: barometer sensor disable config failed", __func__);
150         return ret;
151     }
152 
153     ret = OsalTimerDelete(&drvData->barometerTimer);
154     if (ret != HDF_SUCCESS) {
155         HDF_LOGE("%s: barometer delete timer failed", __func__);
156         return ret;
157     }
158     drvData->enable = false;
159     return HDF_SUCCESS;
160 }
161 
SetBarometerBatch(int64_t samplingInterval,int64_t interval)162 static int32_t SetBarometerBatch(int64_t samplingInterval, int64_t interval)
163 {
164     (void)interval;
165 
166     struct BarometerDrvData *drvData = NULL;
167 
168     drvData = BarometerGetDrvData();
169     CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
170 
171     drvData->interval = samplingInterval;
172 
173     return HDF_SUCCESS;
174 }
175 
SetBarometerMode(int32_t mode)176 static int32_t SetBarometerMode(int32_t mode)
177 {
178     if (mode <= SENSOR_WORK_MODE_DEFAULT || mode >= SENSOR_WORK_MODE_MAX) {
179         HDF_LOGE("%s: The current mode is not supported", __func__);
180         return HDF_FAILURE;
181     }
182 
183     return HDF_SUCCESS;
184 }
185 
SetBarometerOption(uint32_t option)186 static int32_t SetBarometerOption(uint32_t option)
187 {
188     (void)option;
189     return HDF_SUCCESS;
190 }
191 
DispatchBarometer(struct HdfDeviceIoClient * client,int cmd,struct HdfSBuf * data,struct HdfSBuf * reply)192 static int32_t DispatchBarometer(struct HdfDeviceIoClient *client,
193     int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
194 {
195     (void)client;
196     (void)cmd;
197     (void)data;
198     (void)reply;
199 
200     return HDF_SUCCESS;
201 }
202 
BarometerBindDriver(struct HdfDeviceObject * device)203 int32_t BarometerBindDriver(struct HdfDeviceObject *device)
204 {
205     CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
206 
207     struct BarometerDrvData *drvData = (struct BarometerDrvData *)OsalMemCalloc(sizeof(*drvData));
208     if (drvData == NULL) {
209         HDF_LOGE("%s: malloc barometer drv data fail!", __func__);
210         return HDF_ERR_MALLOC_FAIL;
211     }
212 
213     drvData->ioService.Dispatch = DispatchBarometer;
214     drvData->device = device;
215     device->service = &drvData->ioService;
216     g_barometerDrvData = drvData;
217     return HDF_SUCCESS;
218 }
219 
InitBarometerOps(struct SensorCfgData * config,struct SensorDeviceInfo * deviceInfo)220 static int32_t InitBarometerOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo)
221 {
222     CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM);
223 
224     deviceInfo->ops.Enable = SetBarometerEnable;
225     deviceInfo->ops.Disable = SetBarometerDisable;
226     deviceInfo->ops.SetBatch = SetBarometerBatch;
227     deviceInfo->ops.SetMode = SetBarometerMode;
228     deviceInfo->ops.SetOption = SetBarometerOption;
229 
230     if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo),
231         &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) {
232         HDF_LOGE("%s: copy sensor info failed", __func__);
233         return HDF_FAILURE;
234     }
235 
236     return HDF_SUCCESS;
237 }
238 
InitBarometerAfterDetected(struct SensorCfgData * config)239 static int32_t InitBarometerAfterDetected(struct SensorCfgData *config)
240 {
241     struct SensorDeviceInfo deviceInfo;
242     CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM);
243 
244     if (InitBarometerOps(config, &deviceInfo) != HDF_SUCCESS) {
245         HDF_LOGE("%s: Init barometer ops failed", __func__);
246         return HDF_FAILURE;
247     }
248 
249     if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) {
250         HDF_LOGE("%s: Add barometer device failed", __func__);
251         return HDF_FAILURE;
252     }
253 
254     if (ParseSensorRegConfig(config) != HDF_SUCCESS) {
255         HDF_LOGE("%s: Parse sensor register failed", __func__);
256         (void)DeleteSensorDevice(&config->sensorInfo);
257         ReleaseSensorAllRegConfig(config);
258         return HDF_FAILURE;
259     }
260     return HDF_SUCCESS;
261 }
262 
BarometerCreateCfgData(const struct DeviceResourceNode * node)263 struct SensorCfgData *BarometerCreateCfgData(const struct DeviceResourceNode *node)
264 {
265     struct BarometerDrvData *drvData = BarometerGetDrvData();
266 
267     if (drvData == NULL || node == NULL) {
268         HDF_LOGE("%s: Barometer node pointer NULL", __func__);
269         return NULL;
270     }
271 
272     if (drvData->detectFlag) {
273         HDF_LOGE("%s: Barometer sensor have detected", __func__);
274         return NULL;
275     }
276 
277     if (drvData->barometerCfg == NULL) {
278         HDF_LOGE("%s: Barometer barometerCfg pointer NULL", __func__);
279         return NULL;
280     }
281 
282     if (GetSensorBaseConfigData(node, drvData->barometerCfg) != HDF_SUCCESS) {
283         HDF_LOGE("%s: Get sensor base config failed", __func__);
284         goto BASE_CONFIG_EXIT;
285     }
286 
287     if (DetectSensorDevice(drvData->barometerCfg) != HDF_SUCCESS) {
288         HDF_LOGI("%s: Barometer sensor detect device no exist", __func__);
289         drvData->detectFlag = false;
290         goto BASE_CONFIG_EXIT;
291     }
292 
293     drvData->detectFlag = true;
294     if (InitBarometerAfterDetected(drvData->barometerCfg) != HDF_SUCCESS) {
295         HDF_LOGE("%s: Barometer sensor detect device no exist", __func__);
296         goto INIT_EXIT;
297     }
298     return drvData->barometerCfg;
299 
300 INIT_EXIT:
301     (void)ReleaseSensorBusHandle(&drvData->barometerCfg->busCfg);
302 BASE_CONFIG_EXIT:
303     drvData->barometerCfg->root = NULL;
304     (void)memset_s(&drvData->barometerCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0,
305         sizeof(struct SensorBasicInfo));
306     (void)memset_s(&drvData->barometerCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg));
307     (void)memset_s(&drvData->barometerCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr));
308     return drvData->barometerCfg;
309 }
310 
BarometerReleaseCfgData(struct SensorCfgData * barometerCfg)311 void BarometerReleaseCfgData(struct SensorCfgData *barometerCfg)
312 {
313     CHECK_NULL_PTR_RETURN(barometerCfg);
314 
315     (void)DeleteSensorDevice(&barometerCfg->sensorInfo);
316     ReleaseSensorAllRegConfig(barometerCfg);
317     (void)ReleaseSensorBusHandle(&barometerCfg->busCfg);
318 
319     barometerCfg->root = NULL;
320     (void)memset_s(&barometerCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo));
321     (void)memset_s(&barometerCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg));
322     (void)memset_s(&barometerCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr));
323 }
324 
BarometerInitDriver(struct HdfDeviceObject * device)325 int32_t BarometerInitDriver(struct HdfDeviceObject *device)
326 {
327     CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
328     struct BarometerDrvData *drvData = (struct BarometerDrvData *)device->service;
329     CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
330 
331     if (InitBarometerData(drvData) != HDF_SUCCESS) {
332         HDF_LOGE("%s: Init barometer config failed", __func__);
333         return HDF_FAILURE;
334     }
335 
336     drvData->barometerCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->barometerCfg));
337     if (drvData->barometerCfg == NULL) {
338         HDF_LOGE("%s: Malloc barometer config data failed", __func__);
339         return HDF_FAILURE;
340     }
341 
342     drvData->barometerCfg->regCfgGroup = &g_regCfgGroup[0];
343 
344     HDF_LOGI("%s: Init barometer driver success", __func__);
345     return HDF_SUCCESS;
346 }
347 
BarometerReleaseDriver(struct HdfDeviceObject * device)348 void BarometerReleaseDriver(struct HdfDeviceObject *device)
349 {
350     CHECK_NULL_PTR_RETURN(device);
351 
352     struct BarometerDrvData *drvData = (struct BarometerDrvData *)device->service;
353     CHECK_NULL_PTR_RETURN(drvData);
354 
355     if (drvData->detectFlag && drvData->barometerCfg != NULL) {
356         BarometerReleaseCfgData(drvData->barometerCfg);
357     }
358 
359     OsalMemFree(drvData->barometerCfg);
360     drvData->barometerCfg = NULL;
361 
362     HdfWorkDestroy(&drvData->barometerWork);
363     HdfWorkQueueDestroy(&drvData->barometerWorkQueue);
364     OsalMemFree(drvData);
365 }
366 
367 struct HdfDriverEntry g_sensorBarometerDevEntry = {
368     .moduleVersion = 1,
369     .moduleName = "HDF_SENSOR_BAROMETER",
370     .Bind = BarometerBindDriver,
371     .Init = BarometerInitDriver,
372     .Release = BarometerReleaseDriver,
373 };
374 
375 HDF_INIT(g_sensorBarometerDevEntry);