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