1 /*
2 * Copyright (c) 2021-2022 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 "barometer_bmp180.h"
10 #include <securec.h>
11 #include "osal_mem.h"
12 #include "osal_time.h"
13 #include "sensor_barometer_driver.h"
14 #include "sensor_config_controller.h"
15 #include "sensor_device_manager.h"
16 #include "sensor_platform_if.h"
17
18 #define HDF_LOG_TAG hdf_sensor_barometer
19
20 static struct Bmp180DrvData *g_bmp180DrvData = NULL;
21
Bmp180GetDrvData(void)22 static struct Bmp180DrvData *Bmp180GetDrvData(void)
23 {
24 return g_bmp180DrvData;
25 }
26
27 /* IO config for int-pin and I2C-pin */
28 #define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c
29 #define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048
30 #define SENSOR_I2C_REG_CFG 0x403
31
32 static struct BarometerEepromData g_calibraData = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
33
ReadEepromRawData(struct SensorCfgData * data,uint8_t rfg[BAROMETER_EEPROM_SUM])34 static int32_t ReadEepromRawData(struct SensorCfgData *data, uint8_t rfg[BAROMETER_EEPROM_SUM])
35 {
36 int32_t ret;
37
38 ret = ReadSensor(&data->busCfg, BMP180_AC1_MSB_ADDR, &rfg[BAROMETER_AC1_MSB], sizeof(uint8_t));
39 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
40
41 ret = ReadSensor(&data->busCfg, BMP180_AC1_LSB_ADDR, &rfg[BAROMETER_AC1_LSB], sizeof(uint8_t));
42 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
43
44 ret = ReadSensor(&data->busCfg, BMP180_AC2_MSB_ADDR, &rfg[BAROMETER_AC2_MSB], sizeof(uint8_t));
45 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
46
47 ret = ReadSensor(&data->busCfg, BMP180_AC2_LSB_ADDR, &rfg[BAROMETER_AC2_LSB], sizeof(uint8_t));
48 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
49
50 ret = ReadSensor(&data->busCfg, BMP180_AC3_MSB_ADDR, &rfg[BAROMETER_AC3_MSB], sizeof(uint8_t));
51 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
52
53 ret = ReadSensor(&data->busCfg, BMP180_AC3_LSB_ADDR, &rfg[BAROMETER_AC3_LSB], sizeof(uint8_t));
54 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
55
56 ret = ReadSensor(&data->busCfg, BMP180_AC4_MSB_ADDR, &rfg[BAROMETER_AC4_MSB], sizeof(uint8_t));
57 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
58
59 ret = ReadSensor(&data->busCfg, BMP180_AC4_LSB_ADDR, &rfg[BAROMETER_AC4_LSB], sizeof(uint8_t));
60 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
61
62 ret = ReadSensor(&data->busCfg, BMP180_AC5_MSB_ADDR, &rfg[BAROMETER_AC5_MSB], sizeof(uint8_t));
63 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
64
65 ret = ReadSensor(&data->busCfg, BMP180_AC5_LSB_ADDR, &rfg[BAROMETER_AC5_LSB], sizeof(uint8_t));
66 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
67
68 ret = ReadSensor(&data->busCfg, BMP180_AC6_MSB_ADDR, &rfg[BAROMETER_AC6_MSB], sizeof(uint8_t));
69 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
70 ret = ReadSensor(&data->busCfg, BMP180_AC6_LSB_ADDR, &rfg[BAROMETER_AC6_LSB], sizeof(uint8_t));
71 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
72
73 ret = ReadSensor(&data->busCfg, BMP180_B1_MSB_ADDR, &rfg[BAROMETER_B1_MSB], sizeof(uint8_t));
74 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
75
76 ret = ReadSensor(&data->busCfg, BMP180_B1_LSB_ADDR, &rfg[BAROMETER_B1_LSB], sizeof(uint8_t));
77 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
78
79 ret = ReadSensor(&data->busCfg, BMP180_B2_MSB_ADDR, &rfg[BAROMETER_B2_MSB], sizeof(uint8_t));
80 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
81
82 ret = ReadSensor(&data->busCfg, BMP180_B2_LSB_ADDR, &rfg[BAROMETER_B2_LSB], sizeof(uint8_t));
83 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
84
85 ret = ReadSensor(&data->busCfg, BMP180_MB_MSB_ADDR, &rfg[BAROMETER_MB_MSB], sizeof(uint8_t));
86 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
87
88 ret = ReadSensor(&data->busCfg, BMP180_MB_LSB_ADDR, &rfg[BAROMETER_MB_LSB], sizeof(uint8_t));
89 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
90
91 ret = ReadSensor(&data->busCfg, BMP180_MC_MSB_ADDR, &rfg[BAROMETER_MC_MSB], sizeof(uint8_t));
92 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
93
94 ret = ReadSensor(&data->busCfg, BMP180_MC_LSB_ADDR, &rfg[BAROMETER_MC_LSB], sizeof(uint8_t));
95 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
96
97 ret = ReadSensor(&data->busCfg, BMP180_MD_MSB_ADDR, &rfg[BAROMETER_MD_MSB], sizeof(uint8_t));
98 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
99
100 ret = ReadSensor(&data->busCfg, BMP180_MD_LSB_ADDR, &rfg[BAROMETER_MD_LSB], sizeof(uint8_t));
101 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
102
103 return ret;
104 }
105
ReadEepromData(struct SensorCfgData * data,struct BarometerEepromData * g_calibraData)106 static int32_t ReadEepromData(struct SensorCfgData *data, struct BarometerEepromData *g_calibraData)
107 {
108 int32_t ret;
109 uint8_t reg[BAROMETER_EEPROM_SUM];
110
111 (void)memset_s(reg, sizeof(reg), 0, sizeof(reg));
112
113 CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
114
115 ret = ReadEepromRawData(data, reg);
116 if (ret != HDF_SUCCESS) {
117 return HDF_FAILURE;
118 }
119
120 g_calibraData->ac1 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC1_MSB], SENSOR_DATA_WIDTH_8_BIT) |
121 reg[BAROMETER_AC1_LSB]);
122 g_calibraData->ac2 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC2_MSB], SENSOR_DATA_WIDTH_8_BIT) |
123 reg[BAROMETER_AC2_LSB]);
124 g_calibraData->ac3 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC3_MSB], SENSOR_DATA_WIDTH_8_BIT) |
125 reg[BAROMETER_AC3_LSB]);
126 g_calibraData->ac4 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC4_MSB], SENSOR_DATA_WIDTH_8_BIT) |
127 reg[BAROMETER_AC4_LSB]);
128 g_calibraData->ac5 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC5_MSB], SENSOR_DATA_WIDTH_8_BIT) |
129 reg[BAROMETER_AC5_LSB]);
130 g_calibraData->ac6 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC6_MSB], SENSOR_DATA_WIDTH_8_BIT) |
131 reg[BAROMETER_AC6_LSB]);
132 g_calibraData->b1 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_B1_MSB], SENSOR_DATA_WIDTH_8_BIT) |
133 reg[BAROMETER_B1_LSB]);
134 g_calibraData->b2 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_B2_MSB], SENSOR_DATA_WIDTH_8_BIT) |
135 reg[BAROMETER_B2_LSB]);
136 g_calibraData->mb = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MB_MSB], SENSOR_DATA_WIDTH_8_BIT) |
137 reg[BAROMETER_MB_LSB]);
138 g_calibraData->mc = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MC_MSB], SENSOR_DATA_WIDTH_8_BIT) |
139 reg[BAROMETER_MC_LSB]);
140 g_calibraData->md = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MD_MSB], SENSOR_DATA_WIDTH_8_BIT) |
141 reg[BAROMETER_MD_LSB]);
142
143 return ret;
144 }
145
ReadTempData(struct SensorCfgData * data,struct BarometerData * Temp)146 static int32_t ReadTempData(struct SensorCfgData *data, struct BarometerData *Temp)
147 {
148 int32_t ret;
149 uint8_t status = 0;
150 uint8_t reg[BAROMETER_TEM_SUM];
151 uint8_t value[SENSOR_VALUE_BUTT];
152 value[SENSOR_ADDR_INDEX] = BMP180_CONTROL_REG_ADDR;
153 value[SENSOR_VALUE_INDEX] = BMP180_COVERT_TEMP;
154
155 (void)memset_s(reg, sizeof(reg), 0, sizeof(reg));
156
157 CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
158
159 ret = ReadSensor(&data->busCfg, BMP180_COVERT_PRES_3, &status, sizeof(uint8_t));
160 if ((status & BMP180_STATUS_ADDR) == BMP180_STATUS_JUDGE) {
161 WriteSensor(&data->busCfg, value, sizeof(value));
162 OsalMDelay(DELAY_0);
163 ret = ReadSensor(&data->busCfg, BMP180_OUT_MSB_ADDR, ®[BAROMETER_TEM_MSB], sizeof(uint8_t));
164 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
165
166 ret = ReadSensor(&data->busCfg, BMP180_OUT_LSB_ADDR, ®[BAROMETER_TEM_LSB], sizeof(uint8_t));
167 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
168
169 Temp->unpensateTemp = (int32_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_TEM_MSB], SENSOR_DATA_WIDTH_8_BIT) |
170 reg[BAROMETER_TEM_LSB]);
171 }
172 return ret;
173 }
174
ReadBarometerData(struct SensorCfgData * data,struct BarometerData * Barom)175 static int32_t ReadBarometerData(struct SensorCfgData *data, struct BarometerData *Barom)
176 {
177 int32_t ret;
178 uint8_t status = 0;
179 uint8_t reg[BAROMETER_BAR_SUM];
180 uint8_t value[SENSOR_VALUE_BUTT];
181 value[SENSOR_ADDR_INDEX] = BMP180_CONTROL_REG_ADDR;
182 value[SENSOR_VALUE_INDEX] = BMP180_COVERT_PRES_1;
183
184 (void)memset_s(reg, sizeof(reg), 0, sizeof(reg));
185
186 CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
187
188 ret = ReadSensor(&data->busCfg, BMP180_COVERT_PRES_3, &status, sizeof(uint8_t));
189 if ((status & BMP180_STATUS_ADDR) == BMP180_STATUS_JUDGE) {
190 WriteSensor(&data->busCfg, value, sizeof(value));
191 OsalMDelay(DELAY_1);
192 ret = ReadSensor(&data->busCfg, BMP180_OUT_MSB_ADDR, ®[BAROMETER_BAR_MSB], sizeof(uint8_t));
193 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
194
195 ret = ReadSensor(&data->busCfg, BMP180_OUT_LSB_ADDR, ®[BAROMETER_BAR_LSB], sizeof(uint8_t));
196 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
197
198 ret = ReadSensor(&data->busCfg, BMP180_OUT_XLSB_ADDR, ®[BAROMETER_BAR_XLSB], sizeof(uint8_t));
199 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
200
201 Barom->unpensatePre = (int32_t)(SENSOR_DATA_SHIFT_RIGHT(
202 (SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_BAR_MSB], SENSOR_DATA_WIDTH_16_BIT) |
203 SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_BAR_LSB], SENSOR_DATA_WIDTH_8_BIT) | reg[BAROMETER_BAR_XLSB]),
204 (BMP180_CONSTANT_4 - OSSETTING)));
205 }
206 return ret;
207 }
208
CalcBarometerData(struct BarometerData * barometerData,int32_t tnp[BAROMETER_SUM])209 static int32_t CalcBarometerData(struct BarometerData *barometerData, int32_t tnp[BAROMETER_SUM])
210 {
211 struct Coefficient coefficientData = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
212
213 // Calculated temperature
214
215 coefficientData.x1 = ((barometerData->unpensateTemp - g_calibraData.ac6) * (g_calibraData.ac5))
216 >> BMP180_CONSTANT_8;
217 coefficientData.x2 = (g_calibraData.mc << BMP180_CONSTANT_5) / (coefficientData.x1 + g_calibraData.md);
218 coefficientData.b5 = coefficientData.x1 + coefficientData.x2;
219 tnp[BAROMETER_TEMPERATURE] = (coefficientData.b5 + BMP180_CONSTANT_4) >> BMP180_CONSTANT_3;
220
221 // Calculated pressure
222
223 coefficientData.b6 = coefficientData.b5 - BMP180_CONSTANT_12;
224 coefficientData.x1 = (g_calibraData.b2 * ((coefficientData.b6 * coefficientData.b6) >> BMP180_CONSTANT_6))
225 >> BMP180_CONSTANT_5;
226 coefficientData.x2 = (g_calibraData.ac2 * coefficientData.b6) >> BMP180_CONSTANT_5;
227 coefficientData.x3 = coefficientData.x1 + coefficientData.x2;
228 coefficientData.b3 = (((((int32_t)g_calibraData.ac1) * BMP180_CONSTANT_3 + coefficientData.x3) << OSSETTING)
229 + BMP180_CONSTANT_2) >> BMP180_CONSTANT_2;
230 coefficientData.x1 = (g_calibraData.ac3 * coefficientData.b6) >> BMP180_CONSTANT_7;
231 coefficientData.x2 = (g_calibraData.b1 * ((coefficientData.b6 * coefficientData.b6) >> BMP180_CONSTANT_6))
232 >> BMP180_CONSTANT_9;
233 coefficientData.x3 = ((coefficientData.x1 + coefficientData.x2) + BMP180_CONSTANT_2) >> BMP180_CONSTANT_2;
234 coefficientData.b4 = (g_calibraData.ac4 * (uint32_t)(coefficientData.x3 + BMP180_CONSTANT_13))
235 >> BMP180_CONSTANT_8;
236 coefficientData.b7 = ((uint32_t)(barometerData->unpensatePre) - (uint32_t)coefficientData.b3)
237 * (BMP180_CONSTANT_14 >> OSSETTING);
238 if (coefficientData.b7 < BMP180_CONSTANT_15) {
239 coefficientData.p = (coefficientData.b7 << BMP180_CONSTANT_1) / coefficientData.b4;
240 } else {
241 coefficientData.p = (coefficientData.b7 / coefficientData.b4) << BMP180_CONSTANT_1;
242 }
243 coefficientData.x1 = (coefficientData.p >> BMP180_CONSTANT_4) * (coefficientData.p >> BMP180_CONSTANT_4);
244 coefficientData.x1 = (coefficientData.x1 * BMP180_CONSTANT_10) >> BMP180_CONSTANT_9;
245 coefficientData.x2 = (BMP180_CONSTANT_0 * coefficientData.p) >> BMP180_CONSTANT_9;
246 tnp[BAROMETER_BAROMETER] = coefficientData.p + ((coefficientData.x1 + coefficientData.x2
247 + BMP180_CONSTANT_11) >> BMP180_CONSTANT_3);
248
249 return HDF_SUCCESS;
250 }
251
ReadBmp180Data(struct SensorCfgData * data)252 int32_t ReadBmp180Data(struct SensorCfgData *data)
253 {
254 int32_t ret;
255 int32_t tmp[BAROMETER_SUM];
256 struct BarometerData barometerData = {0, 0};
257 OsalTimespec time;
258 struct SensorReportEvent event;
259
260 (void)memset_s(&time, sizeof(time), 0, sizeof(time));
261 (void)memset_s(&event, sizeof(event), 0, sizeof(event));
262
263 if (OsalGetTime(&time) != HDF_SUCCESS) {
264 HDF_LOGE("%s: Get time failed", __func__);
265 return HDF_FAILURE;
266 }
267 event.timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT;
268
269 ret = ReadTempData(data, &barometerData);
270 if (ret != HDF_SUCCESS) {
271 return HDF_FAILURE;
272 }
273
274 ret = ReadBarometerData(data, &barometerData);
275 if (ret != HDF_SUCCESS) {
276 return HDF_FAILURE;
277 }
278
279 ret = CalcBarometerData(&barometerData, tmp);
280 if (ret != HDF_SUCCESS) {
281 return HDF_FAILURE;
282 }
283
284 event.sensorId = SENSOR_TAG_BAROMETER;
285 event.option = 0;
286 event.mode = SENSOR_WORK_MODE_REALTIME;
287 event.dataLen = sizeof(tmp);
288 event.data = (uint8_t *)&tmp;
289 ret = ReportSensorEvent(&event);
290 return ret;
291 }
292
InitBmp180(struct SensorCfgData * data)293 static int32_t InitBmp180(struct SensorCfgData *data)
294 {
295 int32_t ret;
296 CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
297 struct SensorReportEvent event;
298
299 (void)memset_s(&event, sizeof(event), 0, sizeof(event));
300
301 ret = ReadEepromData(data, &g_calibraData);
302 if (ret != HDF_SUCCESS) {
303 return HDF_FAILURE;
304 }
305 ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]);
306 if (ret != HDF_SUCCESS) {
307 HDF_LOGE("%s: BMP180 sensor init config failed", __func__);
308 return HDF_FAILURE;
309 }
310 return HDF_SUCCESS;
311 }
312
InitBarometerPreConfig(void)313 static int32_t InitBarometerPreConfig(void)
314 {
315 if (SetSensorPinMux(SENSOR_I2C6_DATA_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) {
316 HDF_LOGE("%s: Data write mux pin failed", __func__);
317 return HDF_FAILURE;
318 }
319 if (SetSensorPinMux(SENSOR_I2C6_CLK_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) {
320 HDF_LOGE("%s: Clk write mux pin failed", __func__);
321 return HDF_FAILURE;
322 }
323
324 return HDF_SUCCESS;
325 }
326
DispatchBMP180(struct HdfDeviceIoClient * client,int cmd,struct HdfSBuf * data,struct HdfSBuf * reply)327 static int32_t DispatchBMP180(struct HdfDeviceIoClient *client,
328 int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
329 {
330 (void)client;
331 (void)cmd;
332 (void)data;
333 (void)reply;
334
335 return HDF_SUCCESS;
336 }
337
Bmp180BindDriver(struct HdfDeviceObject * device)338 int32_t Bmp180BindDriver(struct HdfDeviceObject *device)
339 {
340 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
341
342 struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)OsalMemCalloc(sizeof(*drvData));
343 if (drvData == NULL) {
344 HDF_LOGE("%s: Malloc Bmi160 drv data fail", __func__);
345 return HDF_ERR_MALLOC_FAIL;
346 }
347
348 drvData->ioService.Dispatch = DispatchBMP180;
349 drvData->device = device;
350 device->service = &drvData->ioService;
351 g_bmp180DrvData = drvData;
352
353 return HDF_SUCCESS;
354 }
355
Bmp180InitDriver(struct HdfDeviceObject * device)356 int32_t Bmp180InitDriver(struct HdfDeviceObject *device)
357 {
358 int32_t ret;
359 struct BarometerOpsCall ops;
360
361 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
362 struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)device->service;
363 CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
364
365 ret = InitBarometerPreConfig();
366 if (ret != HDF_SUCCESS) {
367 HDF_LOGE("%s: Init BMp180 bus mux config", __func__);
368 return HDF_FAILURE;
369 }
370
371 drvData->sensorCfg = BarometerCreateCfgData(device->property);
372 if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) {
373 HDF_LOGD("%s: Creating barometercfg failed because detection failed", __func__);
374 return HDF_ERR_NOT_SUPPORT;
375 }
376
377 ops.Init = NULL;
378 ops.ReadData = ReadBmp180Data;
379 ret = BarometerRegisterChipOps(&ops);
380 if (ret != HDF_SUCCESS) {
381 HDF_LOGE("%s: Register BMp180 barometer failed", __func__);
382 return HDF_FAILURE;
383 }
384
385 ret = InitBmp180(drvData->sensorCfg);
386 if (ret != HDF_SUCCESS) {
387 HDF_LOGE("%s: Init BMP180 barometer failed", __func__);
388 return HDF_FAILURE;
389 }
390
391 return HDF_SUCCESS;
392 }
393
Bmp180ReleaseDriver(struct HdfDeviceObject * device)394 void Bmp180ReleaseDriver(struct HdfDeviceObject *device)
395 {
396 CHECK_NULL_PTR_RETURN(device);
397
398 struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)device->service;
399 CHECK_NULL_PTR_RETURN(drvData);
400
401 if (drvData->sensorCfg != NULL) {
402 BarometerReleaseCfgData(drvData->sensorCfg);
403 drvData->sensorCfg = NULL;
404 }
405 OsalMemFree(drvData);
406 }
407
408 struct HdfDriverEntry g_barometerBmp180DevEntry = {
409 .moduleVersion = 1,
410 .moduleName = "HDF_SENSOR_BAROMETER_BMP180",
411 .Bind = Bmp180BindDriver,
412 .Init = Bmp180InitDriver,
413 .Release = Bmp180ReleaseDriver,
414 };
415
416 HDF_INIT(g_barometerBmp180DevEntry);