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