blob: b5a5517e3ce1a141c3af94c64d506ca00b305172 [file] [log] [blame]
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001/*
2 * BMG160 Gyro Sensor driver
3 * Copyright (c) 2014, Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/module.h>
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010016#include <linux/interrupt.h>
17#include <linux/delay.h>
18#include <linux/slab.h>
19#include <linux/acpi.h>
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010020#include <linux/pm.h>
21#include <linux/pm_runtime.h>
22#include <linux/iio/iio.h>
23#include <linux/iio/sysfs.h>
24#include <linux/iio/buffer.h>
25#include <linux/iio/trigger.h>
26#include <linux/iio/events.h>
27#include <linux/iio/trigger_consumer.h>
28#include <linux/iio/triggered_buffer.h>
Markus Pargmannc6c9e992015-08-12 16:50:04 +020029#include <linux/regmap.h>
Quentin Schulz71b44ef2017-03-21 16:52:14 +010030#include <linux/delay.h>
Markus Pargmann13426452015-08-19 14:12:45 +020031#include "bmg160.h"
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010032
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010033#define BMG160_IRQ_NAME "bmg160_event"
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010034
35#define BMG160_REG_CHIP_ID 0x00
36#define BMG160_CHIP_ID_VAL 0x0F
37
38#define BMG160_REG_PMU_LPW 0x11
39#define BMG160_MODE_NORMAL 0x00
40#define BMG160_MODE_DEEP_SUSPEND 0x20
41#define BMG160_MODE_SUSPEND 0x80
42
43#define BMG160_REG_RANGE 0x0F
44
45#define BMG160_RANGE_2000DPS 0
46#define BMG160_RANGE_1000DPS 1
47#define BMG160_RANGE_500DPS 2
48#define BMG160_RANGE_250DPS 3
49#define BMG160_RANGE_125DPS 4
50
51#define BMG160_REG_PMU_BW 0x10
52#define BMG160_NO_FILTER 0
53#define BMG160_DEF_BW 100
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +020054#define BMG160_REG_PMU_BW_RES BIT(7)
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010055
Quentin Schulz71b44ef2017-03-21 16:52:14 +010056#define BMG160_GYRO_REG_RESET 0x14
57#define BMG160_GYRO_RESET_VAL 0xb6
58
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010059#define BMG160_REG_INT_MAP_0 0x17
60#define BMG160_INT_MAP_0_BIT_ANY BIT(1)
61
62#define BMG160_REG_INT_MAP_1 0x18
63#define BMG160_INT_MAP_1_BIT_NEW_DATA BIT(0)
64
65#define BMG160_REG_INT_RST_LATCH 0x21
66#define BMG160_INT_MODE_LATCH_RESET 0x80
67#define BMG160_INT_MODE_LATCH_INT 0x0F
68#define BMG160_INT_MODE_NON_LATCH_INT 0x00
69
70#define BMG160_REG_INT_EN_0 0x15
71#define BMG160_DATA_ENABLE_INT BIT(7)
72
Srinivas Pandruvada5af6b302014-10-10 20:33:26 -070073#define BMG160_REG_INT_EN_1 0x16
74#define BMG160_INT1_BIT_OD BIT(1)
75
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010076#define BMG160_REG_XOUT_L 0x02
77#define BMG160_AXIS_TO_REG(axis) (BMG160_REG_XOUT_L + (axis * 2))
78
79#define BMG160_REG_SLOPE_THRES 0x1B
80#define BMG160_SLOPE_THRES_MASK 0x0F
81
82#define BMG160_REG_MOTION_INTR 0x1C
83#define BMG160_INT_MOTION_X BIT(0)
84#define BMG160_INT_MOTION_Y BIT(1)
85#define BMG160_INT_MOTION_Z BIT(2)
86#define BMG160_ANY_DUR_MASK 0x30
87#define BMG160_ANY_DUR_SHIFT 4
88
89#define BMG160_REG_INT_STATUS_2 0x0B
90#define BMG160_ANY_MOTION_MASK 0x07
Srinivas Pandruvadacb80f6a2014-10-10 20:33:27 -070091#define BMG160_ANY_MOTION_BIT_X BIT(0)
92#define BMG160_ANY_MOTION_BIT_Y BIT(1)
93#define BMG160_ANY_MOTION_BIT_Z BIT(2)
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +010094
95#define BMG160_REG_TEMP 0x08
96#define BMG160_TEMP_CENTER_VAL 23
97
98#define BMG160_MAX_STARTUP_TIME_MS 80
99
100#define BMG160_AUTO_SUSPEND_DELAY_MS 2000
101
102struct bmg160_data {
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200103 struct regmap *regmap;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100104 struct iio_trigger *dready_trig;
105 struct iio_trigger *motion_trig;
106 struct mutex mutex;
107 s16 buffer[8];
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100108 u32 dps_range;
109 int ev_enable_state;
110 int slope_thres;
111 bool dready_trigger_on;
112 bool motion_trigger_on;
Markus Pargmann5d889ab2015-08-12 16:50:07 +0200113 int irq;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100114};
115
116enum bmg160_axis {
117 AXIS_X,
118 AXIS_Y,
119 AXIS_Z,
Irina Tirdeaee8c5412016-03-24 11:29:28 +0200120 AXIS_MAX,
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100121};
122
123static const struct {
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200124 int odr;
125 int filter;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100126 int bw_bits;
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200127} bmg160_samp_freq_table[] = { {100, 32, 0x07},
128 {200, 64, 0x06},
129 {100, 12, 0x05},
130 {200, 23, 0x04},
131 {400, 47, 0x03},
132 {1000, 116, 0x02},
133 {2000, 230, 0x01} };
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100134
135static const struct {
136 int scale;
137 int dps_range;
138} bmg160_scale_table[] = { { 1065, BMG160_RANGE_2000DPS},
139 { 532, BMG160_RANGE_1000DPS},
140 { 266, BMG160_RANGE_500DPS},
141 { 133, BMG160_RANGE_250DPS},
142 { 66, BMG160_RANGE_125DPS} };
143
144static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
145{
Alison Schofielddc2c5712016-04-10 12:08:14 -0700146 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100147 int ret;
148
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200149 ret = regmap_write(data->regmap, BMG160_REG_PMU_LPW, mode);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100150 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700151 dev_err(dev, "Error writing reg_pmu_lpw\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100152 return ret;
153 }
154
155 return 0;
156}
157
158static int bmg160_convert_freq_to_bit(int val)
159{
160 int i;
161
162 for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200163 if (bmg160_samp_freq_table[i].odr == val)
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100164 return bmg160_samp_freq_table[i].bw_bits;
165 }
166
167 return -EINVAL;
168}
169
170static int bmg160_set_bw(struct bmg160_data *data, int val)
171{
Alison Schofielddc2c5712016-04-10 12:08:14 -0700172 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100173 int ret;
174 int bw_bits;
175
176 bw_bits = bmg160_convert_freq_to_bit(val);
177 if (bw_bits < 0)
178 return bw_bits;
179
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200180 ret = regmap_write(data->regmap, BMG160_REG_PMU_BW, bw_bits);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100181 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700182 dev_err(dev, "Error writing reg_pmu_bw\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100183 return ret;
184 }
185
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200186 return 0;
187}
188
189static int bmg160_get_filter(struct bmg160_data *data, int *val)
190{
191 struct device *dev = regmap_get_device(data->regmap);
192 int ret;
193 int i;
194 unsigned int bw_bits;
195
196 ret = regmap_read(data->regmap, BMG160_REG_PMU_BW, &bw_bits);
197 if (ret < 0) {
198 dev_err(dev, "Error reading reg_pmu_bw\n");
199 return ret;
200 }
201
202 /* Ignore the readonly reserved bit. */
203 bw_bits &= ~BMG160_REG_PMU_BW_RES;
204
205 for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
206 if (bmg160_samp_freq_table[i].bw_bits == bw_bits)
207 break;
208 }
209
210 *val = bmg160_samp_freq_table[i].filter;
211
212 return ret ? ret : IIO_VAL_INT;
213}
214
215
216static int bmg160_set_filter(struct bmg160_data *data, int val)
217{
218 struct device *dev = regmap_get_device(data->regmap);
219 int ret;
220 int i;
221
222 for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
223 if (bmg160_samp_freq_table[i].filter == val)
224 break;
225 }
226
227 ret = regmap_write(data->regmap, BMG160_REG_PMU_BW,
228 bmg160_samp_freq_table[i].bw_bits);
229 if (ret < 0) {
230 dev_err(dev, "Error writing reg_pmu_bw\n");
231 return ret;
232 }
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100233
234 return 0;
235}
236
237static int bmg160_chip_init(struct bmg160_data *data)
238{
Alison Schofielddc2c5712016-04-10 12:08:14 -0700239 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100240 int ret;
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200241 unsigned int val;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100242
Quentin Schulz71b44ef2017-03-21 16:52:14 +0100243 /*
244 * Reset chip to get it in a known good state. A delay of 30ms after
245 * reset is required according to the datasheet.
246 */
247 regmap_write(data->regmap, BMG160_GYRO_REG_RESET,
248 BMG160_GYRO_RESET_VAL);
249 usleep_range(30000, 30700);
250
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200251 ret = regmap_read(data->regmap, BMG160_REG_CHIP_ID, &val);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100252 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700253 dev_err(dev, "Error reading reg_chip_id\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100254 return ret;
255 }
256
Alison Schofielddc2c5712016-04-10 12:08:14 -0700257 dev_dbg(dev, "Chip Id %x\n", val);
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200258 if (val != BMG160_CHIP_ID_VAL) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700259 dev_err(dev, "invalid chip %x\n", val);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100260 return -ENODEV;
261 }
262
263 ret = bmg160_set_mode(data, BMG160_MODE_NORMAL);
264 if (ret < 0)
265 return ret;
266
267 /* Wait upto 500 ms to be ready after changing mode */
268 usleep_range(500, 1000);
269
270 /* Set Bandwidth */
271 ret = bmg160_set_bw(data, BMG160_DEF_BW);
272 if (ret < 0)
273 return ret;
274
275 /* Set Default Range */
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200276 ret = regmap_write(data->regmap, BMG160_REG_RANGE, BMG160_RANGE_500DPS);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100277 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700278 dev_err(dev, "Error writing reg_range\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100279 return ret;
280 }
281 data->dps_range = BMG160_RANGE_500DPS;
282
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200283 ret = regmap_read(data->regmap, BMG160_REG_SLOPE_THRES, &val);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100284 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700285 dev_err(dev, "Error reading reg_slope_thres\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100286 return ret;
287 }
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200288 data->slope_thres = val;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100289
290 /* Set default interrupt mode */
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200291 ret = regmap_update_bits(data->regmap, BMG160_REG_INT_EN_1,
292 BMG160_INT1_BIT_OD, 0);
Srinivas Pandruvada5af6b302014-10-10 20:33:26 -0700293 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700294 dev_err(dev, "Error updating bits in reg_int_en_1\n");
Srinivas Pandruvada5af6b302014-10-10 20:33:26 -0700295 return ret;
296 }
297
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200298 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
299 BMG160_INT_MODE_LATCH_INT |
300 BMG160_INT_MODE_LATCH_RESET);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100301 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700302 dev_err(dev,
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100303 "Error writing reg_motion_intr\n");
304 return ret;
305 }
306
307 return 0;
308}
309
310static int bmg160_set_power_state(struct bmg160_data *data, bool on)
311{
Rafael J. Wysocki6f0a13f2014-12-04 01:08:13 +0100312#ifdef CONFIG_PM
Alison Schofielddc2c5712016-04-10 12:08:14 -0700313 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100314 int ret;
315
316 if (on)
Alison Schofielddc2c5712016-04-10 12:08:14 -0700317 ret = pm_runtime_get_sync(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100318 else {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700319 pm_runtime_mark_last_busy(dev);
320 ret = pm_runtime_put_autosuspend(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100321 }
322
323 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700324 dev_err(dev, "Failed: bmg160_set_power_state for %d\n", on);
325
Srinivas Pandruvada10bef282014-10-10 20:33:25 -0700326 if (on)
Alison Schofielddc2c5712016-04-10 12:08:14 -0700327 pm_runtime_put_noidle(dev);
Srinivas Pandruvada10bef282014-10-10 20:33:25 -0700328
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100329 return ret;
330 }
Irina Tirdeaef1c6b22014-08-09 15:05:00 +0100331#endif
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100332
333 return 0;
334}
335
336static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
337 bool status)
338{
Alison Schofielddc2c5712016-04-10 12:08:14 -0700339 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100340 int ret;
341
342 /* Enable/Disable INT_MAP0 mapping */
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200343 ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_0,
344 BMG160_INT_MAP_0_BIT_ANY,
345 (status ? BMG160_INT_MAP_0_BIT_ANY : 0));
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100346 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700347 dev_err(dev, "Error updating bits reg_int_map0\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100348 return ret;
349 }
350
351 /* Enable/Disable slope interrupts */
352 if (status) {
353 /* Update slope thres */
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200354 ret = regmap_write(data->regmap, BMG160_REG_SLOPE_THRES,
355 data->slope_thres);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100356 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700357 dev_err(dev, "Error writing reg_slope_thres\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100358 return ret;
359 }
360
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200361 ret = regmap_write(data->regmap, BMG160_REG_MOTION_INTR,
362 BMG160_INT_MOTION_X | BMG160_INT_MOTION_Y |
363 BMG160_INT_MOTION_Z);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100364 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700365 dev_err(dev, "Error writing reg_motion_intr\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100366 return ret;
367 }
368
369 /*
370 * New data interrupt is always non-latched,
371 * which will have higher priority, so no need
372 * to set latched mode, we will be flooded anyway with INTR
373 */
374 if (!data->dready_trigger_on) {
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200375 ret = regmap_write(data->regmap,
376 BMG160_REG_INT_RST_LATCH,
377 BMG160_INT_MODE_LATCH_INT |
378 BMG160_INT_MODE_LATCH_RESET);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100379 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700380 dev_err(dev, "Error writing reg_rst_latch\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100381 return ret;
382 }
383 }
384
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200385 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
386 BMG160_DATA_ENABLE_INT);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100387
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200388 } else {
389 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
390 }
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100391
392 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700393 dev_err(dev, "Error writing reg_int_en0\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100394 return ret;
395 }
396
397 return 0;
398}
399
400static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
401 bool status)
402{
Alison Schofielddc2c5712016-04-10 12:08:14 -0700403 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100404 int ret;
405
406 /* Enable/Disable INT_MAP1 mapping */
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200407 ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_1,
408 BMG160_INT_MAP_1_BIT_NEW_DATA,
409 (status ? BMG160_INT_MAP_1_BIT_NEW_DATA : 0));
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100410 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700411 dev_err(dev, "Error updating bits in reg_int_map1\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100412 return ret;
413 }
414
415 if (status) {
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200416 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
417 BMG160_INT_MODE_NON_LATCH_INT |
418 BMG160_INT_MODE_LATCH_RESET);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100419 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700420 dev_err(dev, "Error writing reg_rst_latch\n");
421 return ret;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100422 }
423
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200424 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
425 BMG160_DATA_ENABLE_INT);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100426
427 } else {
428 /* Restore interrupt mode */
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200429 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
430 BMG160_INT_MODE_LATCH_INT |
431 BMG160_INT_MODE_LATCH_RESET);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100432 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700433 dev_err(dev, "Error writing reg_rst_latch\n");
434 return ret;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100435 }
436
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200437 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100438 }
439
440 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700441 dev_err(dev, "Error writing reg_int_en0\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100442 return ret;
443 }
444
445 return 0;
446}
447
448static int bmg160_get_bw(struct bmg160_data *data, int *val)
449{
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200450 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100451 int i;
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200452 unsigned int bw_bits;
453 int ret;
454
455 ret = regmap_read(data->regmap, BMG160_REG_PMU_BW, &bw_bits);
456 if (ret < 0) {
457 dev_err(dev, "Error reading reg_pmu_bw\n");
458 return ret;
459 }
460
461 /* Ignore the readonly reserved bit. */
462 bw_bits &= ~BMG160_REG_PMU_BW_RES;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100463
464 for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200465 if (bmg160_samp_freq_table[i].bw_bits == bw_bits) {
466 *val = bmg160_samp_freq_table[i].odr;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100467 return IIO_VAL_INT;
468 }
469 }
470
471 return -EINVAL;
472}
473
474static int bmg160_set_scale(struct bmg160_data *data, int val)
475{
Alison Schofielddc2c5712016-04-10 12:08:14 -0700476 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100477 int ret, i;
478
479 for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
480 if (bmg160_scale_table[i].scale == val) {
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200481 ret = regmap_write(data->regmap, BMG160_REG_RANGE,
482 bmg160_scale_table[i].dps_range);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100483 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700484 dev_err(dev, "Error writing reg_range\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100485 return ret;
486 }
487 data->dps_range = bmg160_scale_table[i].dps_range;
488 return 0;
489 }
490 }
491
492 return -EINVAL;
493}
494
495static int bmg160_get_temp(struct bmg160_data *data, int *val)
496{
Alison Schofielddc2c5712016-04-10 12:08:14 -0700497 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100498 int ret;
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200499 unsigned int raw_val;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100500
501 mutex_lock(&data->mutex);
502 ret = bmg160_set_power_state(data, true);
503 if (ret < 0) {
504 mutex_unlock(&data->mutex);
505 return ret;
506 }
507
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200508 ret = regmap_read(data->regmap, BMG160_REG_TEMP, &raw_val);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100509 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700510 dev_err(dev, "Error reading reg_temp\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100511 bmg160_set_power_state(data, false);
512 mutex_unlock(&data->mutex);
513 return ret;
514 }
515
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200516 *val = sign_extend32(raw_val, 7);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100517 ret = bmg160_set_power_state(data, false);
518 mutex_unlock(&data->mutex);
519 if (ret < 0)
520 return ret;
521
522 return IIO_VAL_INT;
523}
524
525static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
526{
Alison Schofielddc2c5712016-04-10 12:08:14 -0700527 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100528 int ret;
Irina Tirdea95e7ff02016-03-29 15:37:30 +0300529 __le16 raw_val;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100530
531 mutex_lock(&data->mutex);
532 ret = bmg160_set_power_state(data, true);
533 if (ret < 0) {
534 mutex_unlock(&data->mutex);
535 return ret;
536 }
537
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200538 ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(axis), &raw_val,
Irina Tirdea95e7ff02016-03-29 15:37:30 +0300539 sizeof(raw_val));
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100540 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700541 dev_err(dev, "Error reading axis %d\n", axis);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100542 bmg160_set_power_state(data, false);
543 mutex_unlock(&data->mutex);
544 return ret;
545 }
546
Irina Tirdea95e7ff02016-03-29 15:37:30 +0300547 *val = sign_extend32(le16_to_cpu(raw_val), 15);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100548 ret = bmg160_set_power_state(data, false);
549 mutex_unlock(&data->mutex);
550 if (ret < 0)
551 return ret;
552
553 return IIO_VAL_INT;
554}
555
556static int bmg160_read_raw(struct iio_dev *indio_dev,
557 struct iio_chan_spec const *chan,
558 int *val, int *val2, long mask)
559{
560 struct bmg160_data *data = iio_priv(indio_dev);
561 int ret;
562
563 switch (mask) {
564 case IIO_CHAN_INFO_RAW:
565 switch (chan->type) {
566 case IIO_TEMP:
567 return bmg160_get_temp(data, val);
568 case IIO_ANGL_VEL:
569 if (iio_buffer_enabled(indio_dev))
570 return -EBUSY;
571 else
572 return bmg160_get_axis(data, chan->scan_index,
573 val);
574 default:
575 return -EINVAL;
576 }
577 case IIO_CHAN_INFO_OFFSET:
578 if (chan->type == IIO_TEMP) {
579 *val = BMG160_TEMP_CENTER_VAL;
580 return IIO_VAL_INT;
581 } else
582 return -EINVAL;
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200583 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
584 return bmg160_get_filter(data, val);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100585 case IIO_CHAN_INFO_SCALE:
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100586 switch (chan->type) {
587 case IIO_TEMP:
Mike Looijmansdb0609c2019-02-13 08:41:47 +0100588 *val = 500;
589 return IIO_VAL_INT;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100590 case IIO_ANGL_VEL:
591 {
592 int i;
593
594 for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
595 if (bmg160_scale_table[i].dps_range ==
596 data->dps_range) {
Mike Looijmansdb0609c2019-02-13 08:41:47 +0100597 *val = 0;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100598 *val2 = bmg160_scale_table[i].scale;
599 return IIO_VAL_INT_PLUS_MICRO;
600 }
601 }
602 return -EINVAL;
603 }
604 default:
605 return -EINVAL;
606 }
607 case IIO_CHAN_INFO_SAMP_FREQ:
608 *val2 = 0;
609 mutex_lock(&data->mutex);
610 ret = bmg160_get_bw(data, val);
611 mutex_unlock(&data->mutex);
612 return ret;
613 default:
614 return -EINVAL;
615 }
616}
617
618static int bmg160_write_raw(struct iio_dev *indio_dev,
619 struct iio_chan_spec const *chan,
620 int val, int val2, long mask)
621{
622 struct bmg160_data *data = iio_priv(indio_dev);
623 int ret;
624
625 switch (mask) {
626 case IIO_CHAN_INFO_SAMP_FREQ:
627 mutex_lock(&data->mutex);
628 /*
629 * Section 4.2 of spec
630 * In suspend mode, the only supported operations are reading
631 * registers as well as writing to the (0x14) softreset
632 * register. Since we will be in suspend mode by default, change
633 * mode to power on for other writes.
634 */
635 ret = bmg160_set_power_state(data, true);
636 if (ret < 0) {
637 mutex_unlock(&data->mutex);
638 return ret;
639 }
640 ret = bmg160_set_bw(data, val);
641 if (ret < 0) {
642 bmg160_set_power_state(data, false);
643 mutex_unlock(&data->mutex);
644 return ret;
645 }
646 ret = bmg160_set_power_state(data, false);
647 mutex_unlock(&data->mutex);
648 return ret;
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200649 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
650 if (val2)
651 return -EINVAL;
652
653 mutex_lock(&data->mutex);
654 ret = bmg160_set_power_state(data, true);
655 if (ret < 0) {
656 bmg160_set_power_state(data, false);
657 mutex_unlock(&data->mutex);
658 return ret;
659 }
660 ret = bmg160_set_filter(data, val);
661 if (ret < 0) {
662 bmg160_set_power_state(data, false);
663 mutex_unlock(&data->mutex);
664 return ret;
665 }
666 ret = bmg160_set_power_state(data, false);
667 mutex_unlock(&data->mutex);
668 return ret;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100669 case IIO_CHAN_INFO_SCALE:
670 if (val)
671 return -EINVAL;
672
673 mutex_lock(&data->mutex);
674 /* Refer to comments above for the suspend mode ops */
675 ret = bmg160_set_power_state(data, true);
676 if (ret < 0) {
677 mutex_unlock(&data->mutex);
678 return ret;
679 }
680 ret = bmg160_set_scale(data, val2);
681 if (ret < 0) {
682 bmg160_set_power_state(data, false);
683 mutex_unlock(&data->mutex);
684 return ret;
685 }
686 ret = bmg160_set_power_state(data, false);
687 mutex_unlock(&data->mutex);
688 return ret;
689 default:
690 return -EINVAL;
691 }
692
693 return -EINVAL;
694}
695
696static int bmg160_read_event(struct iio_dev *indio_dev,
697 const struct iio_chan_spec *chan,
698 enum iio_event_type type,
699 enum iio_event_direction dir,
700 enum iio_event_info info,
701 int *val, int *val2)
702{
703 struct bmg160_data *data = iio_priv(indio_dev);
704
705 *val2 = 0;
706 switch (info) {
707 case IIO_EV_INFO_VALUE:
708 *val = data->slope_thres & BMG160_SLOPE_THRES_MASK;
709 break;
710 default:
711 return -EINVAL;
712 }
713
714 return IIO_VAL_INT;
715}
716
717static int bmg160_write_event(struct iio_dev *indio_dev,
718 const struct iio_chan_spec *chan,
719 enum iio_event_type type,
720 enum iio_event_direction dir,
721 enum iio_event_info info,
722 int val, int val2)
723{
724 struct bmg160_data *data = iio_priv(indio_dev);
725
726 switch (info) {
727 case IIO_EV_INFO_VALUE:
728 if (data->ev_enable_state)
729 return -EBUSY;
730 data->slope_thres &= ~BMG160_SLOPE_THRES_MASK;
731 data->slope_thres |= (val & BMG160_SLOPE_THRES_MASK);
732 break;
733 default:
734 return -EINVAL;
735 }
736
737 return 0;
738}
739
740static int bmg160_read_event_config(struct iio_dev *indio_dev,
741 const struct iio_chan_spec *chan,
742 enum iio_event_type type,
743 enum iio_event_direction dir)
744{
745
746 struct bmg160_data *data = iio_priv(indio_dev);
747
748 return data->ev_enable_state;
749}
750
751static int bmg160_write_event_config(struct iio_dev *indio_dev,
752 const struct iio_chan_spec *chan,
753 enum iio_event_type type,
754 enum iio_event_direction dir,
755 int state)
756{
757 struct bmg160_data *data = iio_priv(indio_dev);
758 int ret;
759
760 if (state && data->ev_enable_state)
761 return 0;
762
763 mutex_lock(&data->mutex);
764
765 if (!state && data->motion_trigger_on) {
766 data->ev_enable_state = 0;
767 mutex_unlock(&data->mutex);
768 return 0;
769 }
770 /*
771 * We will expect the enable and disable to do operation in
772 * in reverse order. This will happen here anyway as our
773 * resume operation uses sync mode runtime pm calls, the
774 * suspend operation will be delayed by autosuspend delay
775 * So the disable operation will still happen in reverse of
776 * enable operation. When runtime pm is disabled the mode
777 * is always on so sequence doesn't matter
778 */
779 ret = bmg160_set_power_state(data, state);
780 if (ret < 0) {
781 mutex_unlock(&data->mutex);
782 return ret;
783 }
784
785 ret = bmg160_setup_any_motion_interrupt(data, state);
786 if (ret < 0) {
Srinivas Pandruvada10bef282014-10-10 20:33:25 -0700787 bmg160_set_power_state(data, false);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100788 mutex_unlock(&data->mutex);
789 return ret;
790 }
791
792 data->ev_enable_state = state;
793 mutex_unlock(&data->mutex);
794
795 return 0;
796}
797
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100798static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("100 200 400 1000 2000");
799
800static IIO_CONST_ATTR(in_anglvel_scale_available,
801 "0.001065 0.000532 0.000266 0.000133 0.000066");
802
803static struct attribute *bmg160_attributes[] = {
804 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
805 &iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
806 NULL,
807};
808
809static const struct attribute_group bmg160_attrs_group = {
810 .attrs = bmg160_attributes,
811};
812
813static const struct iio_event_spec bmg160_event = {
814 .type = IIO_EV_TYPE_ROC,
Srinivas Pandruvada6896ab32014-10-10 20:33:28 -0700815 .dir = IIO_EV_DIR_EITHER,
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100816 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) |
817 BIT(IIO_EV_INFO_ENABLE)
818};
819
820#define BMG160_CHANNEL(_axis) { \
821 .type = IIO_ANGL_VEL, \
822 .modified = 1, \
823 .channel2 = IIO_MOD_##_axis, \
824 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
825 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
Steffen Trumtrarbf61f5d2016-04-21 12:49:00 +0200826 BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
827 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100828 .scan_index = AXIS_##_axis, \
829 .scan_type = { \
830 .sign = 's', \
831 .realbits = 16, \
832 .storagebits = 16, \
Irina Tirdea7e3d1eb2016-03-24 11:29:29 +0200833 .endianness = IIO_LE, \
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100834 }, \
835 .event_spec = &bmg160_event, \
836 .num_event_specs = 1 \
837}
838
839static const struct iio_chan_spec bmg160_channels[] = {
840 {
841 .type = IIO_TEMP,
842 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
843 BIT(IIO_CHAN_INFO_SCALE) |
844 BIT(IIO_CHAN_INFO_OFFSET),
845 .scan_index = -1,
846 },
847 BMG160_CHANNEL(X),
848 BMG160_CHANNEL(Y),
849 BMG160_CHANNEL(Z),
850 IIO_CHAN_SOFT_TIMESTAMP(3),
851};
852
853static const struct iio_info bmg160_info = {
854 .attrs = &bmg160_attrs_group,
855 .read_raw = bmg160_read_raw,
856 .write_raw = bmg160_write_raw,
857 .read_event_value = bmg160_read_event,
858 .write_event_value = bmg160_write_event,
859 .write_event_config = bmg160_write_event_config,
860 .read_event_config = bmg160_read_event_config,
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100861 .driver_module = THIS_MODULE,
862};
863
Irina Tirdeaee8c5412016-03-24 11:29:28 +0200864static const unsigned long bmg160_accel_scan_masks[] = {
865 BIT(AXIS_X) | BIT(AXIS_Y) | BIT(AXIS_Z),
866 0};
867
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100868static irqreturn_t bmg160_trigger_handler(int irq, void *p)
869{
870 struct iio_poll_func *pf = p;
871 struct iio_dev *indio_dev = pf->indio_dev;
872 struct bmg160_data *data = iio_priv(indio_dev);
Irina Tirdea7e3d1eb2016-03-24 11:29:29 +0200873 int ret;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100874
875 mutex_lock(&data->mutex);
Irina Tirdea7e3d1eb2016-03-24 11:29:29 +0200876 ret = regmap_bulk_read(data->regmap, BMG160_REG_XOUT_L,
877 data->buffer, AXIS_MAX * 2);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100878 mutex_unlock(&data->mutex);
Irina Tirdea7e3d1eb2016-03-24 11:29:29 +0200879 if (ret < 0)
880 goto err;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100881
882 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
Vlad Dogarueb219102015-05-13 16:30:08 +0300883 pf->timestamp);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100884err:
885 iio_trigger_notify_done(indio_dev->trig);
886
887 return IRQ_HANDLED;
888}
889
890static int bmg160_trig_try_reen(struct iio_trigger *trig)
891{
892 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
893 struct bmg160_data *data = iio_priv(indio_dev);
Alison Schofielddc2c5712016-04-10 12:08:14 -0700894 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100895 int ret;
896
897 /* new data interrupts don't need ack */
898 if (data->dready_trigger_on)
899 return 0;
900
901 /* Set latched mode interrupt and clear any latched interrupt */
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200902 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
903 BMG160_INT_MODE_LATCH_INT |
904 BMG160_INT_MODE_LATCH_RESET);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100905 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700906 dev_err(dev, "Error writing reg_rst_latch\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100907 return ret;
908 }
909
910 return 0;
911}
912
913static int bmg160_data_rdy_trigger_set_state(struct iio_trigger *trig,
914 bool state)
915{
916 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
917 struct bmg160_data *data = iio_priv(indio_dev);
918 int ret;
919
920 mutex_lock(&data->mutex);
921
922 if (!state && data->ev_enable_state && data->motion_trigger_on) {
923 data->motion_trigger_on = false;
924 mutex_unlock(&data->mutex);
925 return 0;
926 }
927
928 /*
929 * Refer to comment in bmg160_write_event_config for
930 * enable/disable operation order
931 */
932 ret = bmg160_set_power_state(data, state);
933 if (ret < 0) {
934 mutex_unlock(&data->mutex);
935 return ret;
936 }
937 if (data->motion_trig == trig)
938 ret = bmg160_setup_any_motion_interrupt(data, state);
939 else
940 ret = bmg160_setup_new_data_interrupt(data, state);
941 if (ret < 0) {
Srinivas Pandruvada10bef282014-10-10 20:33:25 -0700942 bmg160_set_power_state(data, false);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100943 mutex_unlock(&data->mutex);
944 return ret;
945 }
946 if (data->motion_trig == trig)
947 data->motion_trigger_on = state;
948 else
949 data->dready_trigger_on = state;
950
951 mutex_unlock(&data->mutex);
952
953 return 0;
954}
955
956static const struct iio_trigger_ops bmg160_trigger_ops = {
957 .set_trigger_state = bmg160_data_rdy_trigger_set_state,
958 .try_reenable = bmg160_trig_try_reen,
959 .owner = THIS_MODULE,
960};
961
962static irqreturn_t bmg160_event_handler(int irq, void *private)
963{
964 struct iio_dev *indio_dev = private;
965 struct bmg160_data *data = iio_priv(indio_dev);
Alison Schofielddc2c5712016-04-10 12:08:14 -0700966 struct device *dev = regmap_get_device(data->regmap);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100967 int ret;
968 int dir;
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200969 unsigned int val;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100970
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200971 ret = regmap_read(data->regmap, BMG160_REG_INT_STATUS_2, &val);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100972 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -0700973 dev_err(dev, "Error reading reg_int_status2\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100974 goto ack_intr_status;
975 }
976
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200977 if (val & 0x08)
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100978 dir = IIO_EV_DIR_RISING;
979 else
980 dir = IIO_EV_DIR_FALLING;
981
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200982 if (val & BMG160_ANY_MOTION_BIT_X)
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +0100983 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
Gregor Boiriebc2b7da2016-03-09 19:05:49 +0100984 0,
985 IIO_MOD_X,
986 IIO_EV_TYPE_ROC,
987 dir),
988 iio_get_time_ns(indio_dev));
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200989 if (val & BMG160_ANY_MOTION_BIT_Y)
Srinivas Pandruvadacb80f6a2014-10-10 20:33:27 -0700990 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
Gregor Boiriebc2b7da2016-03-09 19:05:49 +0100991 0,
992 IIO_MOD_Y,
993 IIO_EV_TYPE_ROC,
994 dir),
995 iio_get_time_ns(indio_dev));
Markus Pargmannc6c9e992015-08-12 16:50:04 +0200996 if (val & BMG160_ANY_MOTION_BIT_Z)
Srinivas Pandruvadacb80f6a2014-10-10 20:33:27 -0700997 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
Gregor Boiriebc2b7da2016-03-09 19:05:49 +0100998 0,
999 IIO_MOD_Z,
1000 IIO_EV_TYPE_ROC,
1001 dir),
1002 iio_get_time_ns(indio_dev));
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001003
1004ack_intr_status:
1005 if (!data->dready_trigger_on) {
Markus Pargmannc6c9e992015-08-12 16:50:04 +02001006 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
1007 BMG160_INT_MODE_LATCH_INT |
1008 BMG160_INT_MODE_LATCH_RESET);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001009 if (ret < 0)
Alison Schofielddc2c5712016-04-10 12:08:14 -07001010 dev_err(dev, "Error writing reg_rst_latch\n");
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001011 }
1012
1013 return IRQ_HANDLED;
1014}
1015
1016static irqreturn_t bmg160_data_rdy_trig_poll(int irq, void *private)
1017{
1018 struct iio_dev *indio_dev = private;
1019 struct bmg160_data *data = iio_priv(indio_dev);
1020
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001021 if (data->dready_trigger_on)
1022 iio_trigger_poll(data->dready_trig);
1023 else if (data->motion_trigger_on)
1024 iio_trigger_poll(data->motion_trig);
1025
1026 if (data->ev_enable_state)
1027 return IRQ_WAKE_THREAD;
1028 else
1029 return IRQ_HANDLED;
1030
1031}
1032
Vlad Dogaru00e0c8e2015-05-13 16:30:09 +03001033static int bmg160_buffer_preenable(struct iio_dev *indio_dev)
1034{
1035 struct bmg160_data *data = iio_priv(indio_dev);
1036
1037 return bmg160_set_power_state(data, true);
1038}
1039
1040static int bmg160_buffer_postdisable(struct iio_dev *indio_dev)
1041{
1042 struct bmg160_data *data = iio_priv(indio_dev);
1043
1044 return bmg160_set_power_state(data, false);
1045}
1046
1047static const struct iio_buffer_setup_ops bmg160_buffer_setup_ops = {
1048 .preenable = bmg160_buffer_preenable,
1049 .postenable = iio_triggered_buffer_postenable,
1050 .predisable = iio_triggered_buffer_predisable,
1051 .postdisable = bmg160_buffer_postdisable,
1052};
1053
Irina Tirdea3a0888e2014-02-09 11:59:00 +00001054static const char *bmg160_match_acpi_device(struct device *dev)
1055{
1056 const struct acpi_device_id *id;
1057
1058 id = acpi_match_device(dev->driver->acpi_match_table, dev);
1059 if (!id)
1060 return NULL;
1061
1062 return dev_name(dev);
1063}
1064
Markus Pargmann13426452015-08-19 14:12:45 +02001065int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
1066 const char *name)
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001067{
1068 struct bmg160_data *data;
1069 struct iio_dev *indio_dev;
1070 int ret;
Markus Pargmannc6c9e992015-08-12 16:50:04 +02001071
Markus Pargmann13426452015-08-19 14:12:45 +02001072 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001073 if (!indio_dev)
1074 return -ENOMEM;
1075
1076 data = iio_priv(indio_dev);
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001077 dev_set_drvdata(dev, indio_dev);
Markus Pargmann13426452015-08-19 14:12:45 +02001078 data->irq = irq;
1079 data->regmap = regmap;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001080
1081 ret = bmg160_chip_init(data);
1082 if (ret < 0)
1083 return ret;
1084
1085 mutex_init(&data->mutex);
1086
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001087 if (ACPI_HANDLE(dev))
1088 name = bmg160_match_acpi_device(dev);
Irina Tirdea3a0888e2014-02-09 11:59:00 +00001089
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001090 indio_dev->dev.parent = dev;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001091 indio_dev->channels = bmg160_channels;
1092 indio_dev->num_channels = ARRAY_SIZE(bmg160_channels);
Irina Tirdea3a0888e2014-02-09 11:59:00 +00001093 indio_dev->name = name;
Irina Tirdeaee8c5412016-03-24 11:29:28 +02001094 indio_dev->available_scan_masks = bmg160_accel_scan_masks;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001095 indio_dev->modes = INDIO_DIRECT_MODE;
1096 indio_dev->info = &bmg160_info;
1097
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001098 if (data->irq > 0) {
1099 ret = devm_request_threaded_irq(dev,
1100 data->irq,
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001101 bmg160_data_rdy_trig_poll,
1102 bmg160_event_handler,
1103 IRQF_TRIGGER_RISING,
1104 BMG160_IRQ_NAME,
1105 indio_dev);
1106 if (ret)
1107 return ret;
1108
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001109 data->dready_trig = devm_iio_trigger_alloc(dev,
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001110 "%s-dev%d",
1111 indio_dev->name,
1112 indio_dev->id);
1113 if (!data->dready_trig)
1114 return -ENOMEM;
1115
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001116 data->motion_trig = devm_iio_trigger_alloc(dev,
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001117 "%s-any-motion-dev%d",
1118 indio_dev->name,
1119 indio_dev->id);
1120 if (!data->motion_trig)
1121 return -ENOMEM;
1122
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001123 data->dready_trig->dev.parent = dev;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001124 data->dready_trig->ops = &bmg160_trigger_ops;
1125 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
1126 ret = iio_trigger_register(data->dready_trig);
1127 if (ret)
1128 return ret;
1129
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001130 data->motion_trig->dev.parent = dev;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001131 data->motion_trig->ops = &bmg160_trigger_ops;
1132 iio_trigger_set_drvdata(data->motion_trig, indio_dev);
1133 ret = iio_trigger_register(data->motion_trig);
1134 if (ret) {
1135 data->motion_trig = NULL;
1136 goto err_trigger_unregister;
1137 }
Vlad Dogaru00e0c8e2015-05-13 16:30:09 +03001138 }
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001139
Vlad Dogaru00e0c8e2015-05-13 16:30:09 +03001140 ret = iio_triggered_buffer_setup(indio_dev,
1141 iio_pollfunc_store_time,
1142 bmg160_trigger_handler,
1143 &bmg160_buffer_setup_ops);
1144 if (ret < 0) {
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001145 dev_err(dev,
Vlad Dogaru00e0c8e2015-05-13 16:30:09 +03001146 "iio triggered buffer setup failed\n");
1147 goto err_trigger_unregister;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001148 }
1149
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001150 ret = pm_runtime_set_active(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001151 if (ret)
Adriana Reus7d0ead52015-11-05 16:25:29 +02001152 goto err_buffer_cleanup;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001153
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001154 pm_runtime_enable(dev);
1155 pm_runtime_set_autosuspend_delay(dev,
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001156 BMG160_AUTO_SUSPEND_DELAY_MS);
Markus Pargmann5d889ab2015-08-12 16:50:07 +02001157 pm_runtime_use_autosuspend(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001158
Adriana Reus7d0ead52015-11-05 16:25:29 +02001159 ret = iio_device_register(indio_dev);
1160 if (ret < 0) {
1161 dev_err(dev, "unable to register iio device\n");
1162 goto err_buffer_cleanup;
1163 }
1164
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001165 return 0;
1166
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001167err_buffer_cleanup:
Vlad Dogaru00e0c8e2015-05-13 16:30:09 +03001168 iio_triggered_buffer_cleanup(indio_dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001169err_trigger_unregister:
1170 if (data->dready_trig)
1171 iio_trigger_unregister(data->dready_trig);
1172 if (data->motion_trig)
1173 iio_trigger_unregister(data->motion_trig);
1174
1175 return ret;
1176}
Markus Pargmann13426452015-08-19 14:12:45 +02001177EXPORT_SYMBOL_GPL(bmg160_core_probe);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001178
Markus Pargmann13426452015-08-19 14:12:45 +02001179void bmg160_core_remove(struct device *dev)
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001180{
Markus Pargmann13426452015-08-19 14:12:45 +02001181 struct iio_dev *indio_dev = dev_get_drvdata(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001182 struct bmg160_data *data = iio_priv(indio_dev);
1183
Adriana Reus7d0ead52015-11-05 16:25:29 +02001184 iio_device_unregister(indio_dev);
1185
Markus Pargmann13426452015-08-19 14:12:45 +02001186 pm_runtime_disable(dev);
1187 pm_runtime_set_suspended(dev);
1188 pm_runtime_put_noidle(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001189
Vlad Dogaru00e0c8e2015-05-13 16:30:09 +03001190 iio_triggered_buffer_cleanup(indio_dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001191
1192 if (data->dready_trig) {
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001193 iio_trigger_unregister(data->dready_trig);
1194 iio_trigger_unregister(data->motion_trig);
1195 }
1196
1197 mutex_lock(&data->mutex);
1198 bmg160_set_mode(data, BMG160_MODE_DEEP_SUSPEND);
1199 mutex_unlock(&data->mutex);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001200}
Markus Pargmann13426452015-08-19 14:12:45 +02001201EXPORT_SYMBOL_GPL(bmg160_core_remove);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001202
1203#ifdef CONFIG_PM_SLEEP
1204static int bmg160_suspend(struct device *dev)
1205{
Markus Pargmannebc6eb52015-08-12 16:50:06 +02001206 struct iio_dev *indio_dev = dev_get_drvdata(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001207 struct bmg160_data *data = iio_priv(indio_dev);
1208
1209 mutex_lock(&data->mutex);
1210 bmg160_set_mode(data, BMG160_MODE_SUSPEND);
1211 mutex_unlock(&data->mutex);
1212
1213 return 0;
1214}
1215
1216static int bmg160_resume(struct device *dev)
1217{
Markus Pargmannebc6eb52015-08-12 16:50:06 +02001218 struct iio_dev *indio_dev = dev_get_drvdata(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001219 struct bmg160_data *data = iio_priv(indio_dev);
1220
1221 mutex_lock(&data->mutex);
1222 if (data->dready_trigger_on || data->motion_trigger_on ||
1223 data->ev_enable_state)
1224 bmg160_set_mode(data, BMG160_MODE_NORMAL);
1225 mutex_unlock(&data->mutex);
1226
1227 return 0;
1228}
1229#endif
1230
Rafael J. Wysocki6f0a13f2014-12-04 01:08:13 +01001231#ifdef CONFIG_PM
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001232static int bmg160_runtime_suspend(struct device *dev)
1233{
Markus Pargmannebc6eb52015-08-12 16:50:06 +02001234 struct iio_dev *indio_dev = dev_get_drvdata(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001235 struct bmg160_data *data = iio_priv(indio_dev);
Srinivas Pandruvada10bef282014-10-10 20:33:25 -07001236 int ret;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001237
Srinivas Pandruvada10bef282014-10-10 20:33:25 -07001238 ret = bmg160_set_mode(data, BMG160_MODE_SUSPEND);
1239 if (ret < 0) {
Alison Schofielddc2c5712016-04-10 12:08:14 -07001240 dev_err(dev, "set mode failed\n");
Srinivas Pandruvada10bef282014-10-10 20:33:25 -07001241 return -EAGAIN;
1242 }
1243
1244 return 0;
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001245}
1246
1247static int bmg160_runtime_resume(struct device *dev)
1248{
Markus Pargmannebc6eb52015-08-12 16:50:06 +02001249 struct iio_dev *indio_dev = dev_get_drvdata(dev);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001250 struct bmg160_data *data = iio_priv(indio_dev);
1251 int ret;
1252
1253 ret = bmg160_set_mode(data, BMG160_MODE_NORMAL);
1254 if (ret < 0)
1255 return ret;
1256
1257 msleep_interruptible(BMG160_MAX_STARTUP_TIME_MS);
1258
1259 return 0;
1260}
1261#endif
1262
Markus Pargmann13426452015-08-19 14:12:45 +02001263const struct dev_pm_ops bmg160_pm_ops = {
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001264 SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend, bmg160_resume)
1265 SET_RUNTIME_PM_OPS(bmg160_runtime_suspend,
1266 bmg160_runtime_resume, NULL)
1267};
Markus Pargmann13426452015-08-19 14:12:45 +02001268EXPORT_SYMBOL_GPL(bmg160_pm_ops);
Srinivas Pandruvada22b46c42014-05-08 22:57:00 +01001269
1270MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1271MODULE_LICENSE("GPL v2");
1272MODULE_DESCRIPTION("BMG160 Gyro driver");