1 /*
2 * Copyright (c) 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 "pedometer_bmi160.h"
10 #include <securec.h>
11 #include "osal_mem.h"
12 #include "osal_time.h"
13 #include "sensor_config_controller.h"
14 #include "sensor_device_manager.h"
15 #include "sensor_pedometer_driver.h"
16
17 #define HDF_LOG_TAG hdf_sensor_pedometer
18
19 static struct Bmi160DrvData *g_bmi160DrvData = NULL;
20
PedometerBmi160GetDrvData(void)21 static struct Bmi160DrvData *PedometerBmi160GetDrvData(void)
22 {
23 return g_bmi160DrvData;
24 }
25
26 /* IO config for int-pin and I2C-pin */
27 #define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c
28 #define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048
29 #define SENSOR_I2C_REG_CFG 0x403
30
ReadBmi160PedometerRawData(struct SensorCfgData * data,struct PedometerData * rawData,uint64_t * timestamp)31 static int32_t ReadBmi160PedometerRawData(struct SensorCfgData *data, struct PedometerData *rawData,
32 uint64_t *timestamp)
33 {
34 uint8_t reg[PEDOMETER_BUTT];
35 OsalTimespec time;
36
37 (void)memset_s(&time, sizeof(time), 0, sizeof(time));
38 (void)memset_s(reg, sizeof(reg), 0, sizeof(reg));
39
40 CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
41
42 if (OsalGetTime(&time) != HDF_SUCCESS) {
43 HDF_LOGE("%s: Get time failed", __func__);
44 return HDF_FAILURE;
45 }
46 *timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT;
47
48 int32_t ret = ReadSensor(&data->busCfg, BMI160_PEDOMETER_LSB_ADDR, ®[PEDOMETER_NU_LSB], sizeof(uint8_t));
49 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
50
51 ret = ReadSensor(&data->busCfg, BMI160_PEDOMETER_MSB_ADDR, ®[PEDOMETER_NU_MSB], sizeof(uint8_t));
52 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data");
53
54 rawData->pedometer = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[PEDOMETER_NU_MSB], SENSOR_DATA_WIDTH_8_BIT) |
55 reg[PEDOMETER_NU_LSB]);
56
57 return HDF_SUCCESS;
58 }
59
ReadBmi160PedometerData(struct SensorCfgData * data)60 int32_t ReadBmi160PedometerData(struct SensorCfgData *data)
61 {
62 int32_t ret;
63 struct PedometerData rawData = { 0 };
64 static int32_t tmp;
65 struct SensorReportEvent event;
66
67 ret = memset_s(&event, sizeof(event), 0, sizeof(event));
68 CHECK_PARSER_RESULT_RETURN_VALUE(ret, "memset_s");
69
70 CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
71
72 ret = ReadBmi160PedometerRawData(data, &rawData, &event.timestamp);
73 if (ret != HDF_SUCCESS) {
74 HDF_LOGE("%s: BMI160 read raw data failed", __func__);
75 return HDF_FAILURE;
76 }
77
78 event.sensorId = SENSOR_TAG_PEDOMETER;
79 event.option = 0;
80 event.mode = SENSOR_WORK_MODE_REALTIME;
81
82 tmp = rawData.pedometer;
83
84 event.dataLen = sizeof(tmp);
85 event.data = (uint8_t *)&tmp;
86 ret = ReportSensorEvent(&event);
87 if (ret != HDF_SUCCESS) {
88 HDF_LOGE("%s: BMI160 report data failed", __func__);
89 }
90
91 return ret;
92 }
93
InitBmi160(struct SensorCfgData * data)94 static int32_t InitBmi160(struct SensorCfgData *data)
95 {
96 int32_t ret;
97
98 CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
99 ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]);
100 if (ret != HDF_SUCCESS) {
101 HDF_LOGE("%s: BMI160 sensor init config failed", __func__);
102 return HDF_FAILURE;
103 }
104 return HDF_SUCCESS;
105 }
106
InitPedometerPreConfig(void)107 static int32_t InitPedometerPreConfig(void)
108 {
109 if (SetSensorPinMux(SENSOR_I2C6_DATA_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) {
110 HDF_LOGE("%s: Data write mux pin failed", __func__);
111 return HDF_FAILURE;
112 }
113 if (SetSensorPinMux(SENSOR_I2C6_CLK_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) {
114 HDF_LOGE("%s: Clk write mux pin failed", __func__);
115 return HDF_FAILURE;
116 }
117
118 return HDF_SUCCESS;
119 }
120
DispatchBMI160(struct HdfDeviceIoClient * client,int cmd,struct HdfSBuf * data,struct HdfSBuf * reply)121 static int32_t DispatchBMI160(struct HdfDeviceIoClient *client,
122 int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
123 {
124 (void)client;
125 (void)cmd;
126 (void)data;
127 (void)reply;
128
129 return HDF_SUCCESS;
130 }
131
PedometerBmi160BindDriver(struct HdfDeviceObject * device)132 int32_t PedometerBmi160BindDriver(struct HdfDeviceObject *device)
133 {
134 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
135
136 struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)OsalMemCalloc(sizeof(*drvData));
137 if (drvData == NULL) {
138 HDF_LOGE("%s: Malloc Bmi160 drv data fail", __func__);
139 return HDF_ERR_MALLOC_FAIL;
140 }
141
142 drvData->ioService.Dispatch = DispatchBMI160;
143 drvData->device = device;
144 device->service = &drvData->ioService;
145 g_bmi160DrvData = drvData;
146
147 return HDF_SUCCESS;
148 }
149
PedometerBmi160InitDriver(struct HdfDeviceObject * device)150 int32_t PedometerBmi160InitDriver(struct HdfDeviceObject *device)
151 {
152 int32_t ret;
153 struct PedometerOpsCall ops;
154
155 CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
156 struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)device->service;
157 CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
158
159 ret = InitPedometerPreConfig();
160 if (ret != HDF_SUCCESS) {
161 HDF_LOGE("%s: Init BMI160 bus mux config", __func__);
162 return HDF_FAILURE;
163 }
164
165 drvData->sensorCfg = PedometerCreateCfgData(device->property);
166 if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) {
167 HDF_LOGD("%s: Creating pedometercfg failed because detection failed", __func__);
168 return HDF_ERR_NOT_SUPPORT;
169 }
170
171 ops.Init = NULL;
172 ops.ReadData = ReadBmi160PedometerData;
173 ret = PedometerRegisterChipOps(&ops);
174 if (ret != HDF_SUCCESS) {
175 HDF_LOGE("%s: Register BMI160 pedometer failed", __func__);
176 return HDF_FAILURE;
177 }
178
179 ret = InitBmi160(drvData->sensorCfg);
180 if (ret != HDF_SUCCESS) {
181 HDF_LOGE("%s: Init BMI160 pedometer failed", __func__);
182 return HDF_FAILURE;
183 }
184
185 return HDF_SUCCESS;
186 }
187
PedometerBmi160ReleaseDriver(struct HdfDeviceObject * device)188 void PedometerBmi160ReleaseDriver(struct HdfDeviceObject *device)
189 {
190 CHECK_NULL_PTR_RETURN(device);
191
192 struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)device->service;
193 CHECK_NULL_PTR_RETURN(drvData);
194
195 if (drvData->sensorCfg != NULL) {
196 PedometerReleaseCfgData(drvData->sensorCfg);
197 drvData->sensorCfg = NULL;
198 }
199 OsalMemFree(drvData);
200 }
201
202 struct HdfDriverEntry g_pedometerBmi160DevEntry = {
203 .moduleVersion = 1,
204 .moduleName = "HDF_SENSOR_PEDOMETER_BMI160",
205 .Bind = PedometerBmi160BindDriver,
206 .Init = PedometerBmi160InitDriver,
207 .Release = PedometerBmi160ReleaseDriver,
208 };
209
210 HDF_INIT(g_pedometerBmi160DevEntry);
211