2 * BMG160 Gyro Sensor driver
3 * Copyright (c) 2014, Intel Corporation.
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.
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
15 #include <linux/module.h>
16 #include <linux/i2c.h>
17 #include <linux/interrupt.h>
18 #include <linux/delay.h>
19 #include <linux/slab.h>
20 #include <linux/acpi.h>
21 #include <linux/gpio/consumer.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/iio/iio.h>
25 #include <linux/iio/sysfs.h>
26 #include <linux/iio/buffer.h>
27 #include <linux/iio/trigger.h>
28 #include <linux/iio/events.h>
29 #include <linux/iio/trigger_consumer.h>
30 #include <linux/iio/triggered_buffer.h>
32 #define BMG160_DRV_NAME "bmg160"
33 #define BMG160_IRQ_NAME "bmg160_event"
34 #define BMG160_GPIO_NAME "gpio_int"
36 #define BMG160_REG_CHIP_ID 0x00
37 #define BMG160_CHIP_ID_VAL 0x0F
39 #define BMG160_REG_PMU_LPW 0x11
40 #define BMG160_MODE_NORMAL 0x00
41 #define BMG160_MODE_DEEP_SUSPEND 0x20
42 #define BMG160_MODE_SUSPEND 0x80
44 #define BMG160_REG_RANGE 0x0F
46 #define BMG160_RANGE_2000DPS 0
47 #define BMG160_RANGE_1000DPS 1
48 #define BMG160_RANGE_500DPS 2
49 #define BMG160_RANGE_250DPS 3
50 #define BMG160_RANGE_125DPS 4
52 #define BMG160_REG_PMU_BW 0x10
53 #define BMG160_NO_FILTER 0
54 #define BMG160_DEF_BW 100
56 #define BMG160_REG_INT_MAP_0 0x17
57 #define BMG160_INT_MAP_0_BIT_ANY BIT(1)
59 #define BMG160_REG_INT_MAP_1 0x18
60 #define BMG160_INT_MAP_1_BIT_NEW_DATA BIT(0)
62 #define BMG160_REG_INT_RST_LATCH 0x21
63 #define BMG160_INT_MODE_LATCH_RESET 0x80
64 #define BMG160_INT_MODE_LATCH_INT 0x0F
65 #define BMG160_INT_MODE_NON_LATCH_INT 0x00
67 #define BMG160_REG_INT_EN_0 0x15
68 #define BMG160_DATA_ENABLE_INT BIT(7)
70 #define BMG160_REG_INT_EN_1 0x16
71 #define BMG160_INT1_BIT_OD BIT(1)
73 #define BMG160_REG_XOUT_L 0x02
74 #define BMG160_AXIS_TO_REG(axis) (BMG160_REG_XOUT_L + (axis * 2))
76 #define BMG160_REG_SLOPE_THRES 0x1B
77 #define BMG160_SLOPE_THRES_MASK 0x0F
79 #define BMG160_REG_MOTION_INTR 0x1C
80 #define BMG160_INT_MOTION_X BIT(0)
81 #define BMG160_INT_MOTION_Y BIT(1)
82 #define BMG160_INT_MOTION_Z BIT(2)
83 #define BMG160_ANY_DUR_MASK 0x30
84 #define BMG160_ANY_DUR_SHIFT 4
86 #define BMG160_REG_INT_STATUS_2 0x0B
87 #define BMG160_ANY_MOTION_MASK 0x07
88 #define BMG160_ANY_MOTION_BIT_X BIT(0)
89 #define BMG160_ANY_MOTION_BIT_Y BIT(1)
90 #define BMG160_ANY_MOTION_BIT_Z BIT(2)
92 #define BMG160_REG_TEMP 0x08
93 #define BMG160_TEMP_CENTER_VAL 23
95 #define BMG160_MAX_STARTUP_TIME_MS 80
97 #define BMG160_AUTO_SUSPEND_DELAY_MS 2000
100 struct i2c_client
*client
;
101 struct iio_trigger
*dready_trig
;
102 struct iio_trigger
*motion_trig
;
109 bool dready_trigger_on
;
110 bool motion_trigger_on
;
119 static const struct {
122 } bmg160_samp_freq_table
[] = { {100, 0x07},
128 static const struct {
131 } bmg160_scale_table
[] = { { 1065, BMG160_RANGE_2000DPS
},
132 { 532, BMG160_RANGE_1000DPS
},
133 { 266, BMG160_RANGE_500DPS
},
134 { 133, BMG160_RANGE_250DPS
},
135 { 66, BMG160_RANGE_125DPS
} };
137 static int bmg160_set_mode(struct bmg160_data
*data
, u8 mode
)
141 ret
= i2c_smbus_write_byte_data(data
->client
,
142 BMG160_REG_PMU_LPW
, mode
);
144 dev_err(&data
->client
->dev
, "Error writing reg_pmu_lpw\n");
151 static int bmg160_convert_freq_to_bit(int val
)
155 for (i
= 0; i
< ARRAY_SIZE(bmg160_samp_freq_table
); ++i
) {
156 if (bmg160_samp_freq_table
[i
].val
== val
)
157 return bmg160_samp_freq_table
[i
].bw_bits
;
163 static int bmg160_set_bw(struct bmg160_data
*data
, int val
)
168 bw_bits
= bmg160_convert_freq_to_bit(val
);
172 ret
= i2c_smbus_write_byte_data(data
->client
, BMG160_REG_PMU_BW
,
175 dev_err(&data
->client
->dev
, "Error writing reg_pmu_bw\n");
179 data
->bw_bits
= bw_bits
;
184 static int bmg160_chip_init(struct bmg160_data
*data
)
188 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_CHIP_ID
);
190 dev_err(&data
->client
->dev
, "Error reading reg_chip_id\n");
194 dev_dbg(&data
->client
->dev
, "Chip Id %x\n", ret
);
195 if (ret
!= BMG160_CHIP_ID_VAL
) {
196 dev_err(&data
->client
->dev
, "invalid chip %x\n", ret
);
200 ret
= bmg160_set_mode(data
, BMG160_MODE_NORMAL
);
204 /* Wait upto 500 ms to be ready after changing mode */
205 usleep_range(500, 1000);
208 ret
= bmg160_set_bw(data
, BMG160_DEF_BW
);
212 /* Set Default Range */
213 ret
= i2c_smbus_write_byte_data(data
->client
,
215 BMG160_RANGE_500DPS
);
217 dev_err(&data
->client
->dev
, "Error writing reg_range\n");
220 data
->dps_range
= BMG160_RANGE_500DPS
;
222 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_SLOPE_THRES
);
224 dev_err(&data
->client
->dev
, "Error reading reg_slope_thres\n");
227 data
->slope_thres
= ret
;
229 /* Set default interrupt mode */
230 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_INT_EN_1
);
232 dev_err(&data
->client
->dev
, "Error reading reg_int_en_1\n");
235 ret
&= ~BMG160_INT1_BIT_OD
;
236 ret
= i2c_smbus_write_byte_data(data
->client
,
237 BMG160_REG_INT_EN_1
, ret
);
239 dev_err(&data
->client
->dev
, "Error writing reg_int_en_1\n");
243 ret
= i2c_smbus_write_byte_data(data
->client
,
244 BMG160_REG_INT_RST_LATCH
,
245 BMG160_INT_MODE_LATCH_INT
|
246 BMG160_INT_MODE_LATCH_RESET
);
248 dev_err(&data
->client
->dev
,
249 "Error writing reg_motion_intr\n");
256 static int bmg160_set_power_state(struct bmg160_data
*data
, bool on
)
262 ret
= pm_runtime_get_sync(&data
->client
->dev
);
264 pm_runtime_mark_last_busy(&data
->client
->dev
);
265 ret
= pm_runtime_put_autosuspend(&data
->client
->dev
);
269 dev_err(&data
->client
->dev
,
270 "Failed: bmg160_set_power_state for %d\n", on
);
272 pm_runtime_put_noidle(&data
->client
->dev
);
281 static int bmg160_setup_any_motion_interrupt(struct bmg160_data
*data
,
286 /* Enable/Disable INT_MAP0 mapping */
287 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_INT_MAP_0
);
289 dev_err(&data
->client
->dev
, "Error reading reg_int_map0\n");
293 ret
|= BMG160_INT_MAP_0_BIT_ANY
;
295 ret
&= ~BMG160_INT_MAP_0_BIT_ANY
;
297 ret
= i2c_smbus_write_byte_data(data
->client
,
298 BMG160_REG_INT_MAP_0
,
301 dev_err(&data
->client
->dev
, "Error writing reg_int_map0\n");
305 /* Enable/Disable slope interrupts */
307 /* Update slope thres */
308 ret
= i2c_smbus_write_byte_data(data
->client
,
309 BMG160_REG_SLOPE_THRES
,
312 dev_err(&data
->client
->dev
,
313 "Error writing reg_slope_thres\n");
317 ret
= i2c_smbus_write_byte_data(data
->client
,
318 BMG160_REG_MOTION_INTR
,
319 BMG160_INT_MOTION_X
|
320 BMG160_INT_MOTION_Y
|
321 BMG160_INT_MOTION_Z
);
323 dev_err(&data
->client
->dev
,
324 "Error writing reg_motion_intr\n");
329 * New data interrupt is always non-latched,
330 * which will have higher priority, so no need
331 * to set latched mode, we will be flooded anyway with INTR
333 if (!data
->dready_trigger_on
) {
334 ret
= i2c_smbus_write_byte_data(data
->client
,
335 BMG160_REG_INT_RST_LATCH
,
336 BMG160_INT_MODE_LATCH_INT
|
337 BMG160_INT_MODE_LATCH_RESET
);
339 dev_err(&data
->client
->dev
,
340 "Error writing reg_rst_latch\n");
345 ret
= i2c_smbus_write_byte_data(data
->client
,
347 BMG160_DATA_ENABLE_INT
);
350 ret
= i2c_smbus_write_byte_data(data
->client
,
355 dev_err(&data
->client
->dev
, "Error writing reg_int_en0\n");
362 static int bmg160_setup_new_data_interrupt(struct bmg160_data
*data
,
367 /* Enable/Disable INT_MAP1 mapping */
368 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_INT_MAP_1
);
370 dev_err(&data
->client
->dev
, "Error reading reg_int_map1\n");
375 ret
|= BMG160_INT_MAP_1_BIT_NEW_DATA
;
377 ret
&= ~BMG160_INT_MAP_1_BIT_NEW_DATA
;
379 ret
= i2c_smbus_write_byte_data(data
->client
,
380 BMG160_REG_INT_MAP_1
,
383 dev_err(&data
->client
->dev
, "Error writing reg_int_map1\n");
388 ret
= i2c_smbus_write_byte_data(data
->client
,
389 BMG160_REG_INT_RST_LATCH
,
390 BMG160_INT_MODE_NON_LATCH_INT
|
391 BMG160_INT_MODE_LATCH_RESET
);
393 dev_err(&data
->client
->dev
,
394 "Error writing reg_rst_latch\n");
398 ret
= i2c_smbus_write_byte_data(data
->client
,
400 BMG160_DATA_ENABLE_INT
);
403 /* Restore interrupt mode */
404 ret
= i2c_smbus_write_byte_data(data
->client
,
405 BMG160_REG_INT_RST_LATCH
,
406 BMG160_INT_MODE_LATCH_INT
|
407 BMG160_INT_MODE_LATCH_RESET
);
409 dev_err(&data
->client
->dev
,
410 "Error writing reg_rst_latch\n");
414 ret
= i2c_smbus_write_byte_data(data
->client
,
420 dev_err(&data
->client
->dev
, "Error writing reg_int_en0\n");
427 static int bmg160_get_bw(struct bmg160_data
*data
, int *val
)
431 for (i
= 0; i
< ARRAY_SIZE(bmg160_samp_freq_table
); ++i
) {
432 if (bmg160_samp_freq_table
[i
].bw_bits
== data
->bw_bits
) {
433 *val
= bmg160_samp_freq_table
[i
].val
;
441 static int bmg160_set_scale(struct bmg160_data
*data
, int val
)
445 for (i
= 0; i
< ARRAY_SIZE(bmg160_scale_table
); ++i
) {
446 if (bmg160_scale_table
[i
].scale
== val
) {
447 ret
= i2c_smbus_write_byte_data(
450 bmg160_scale_table
[i
].dps_range
);
452 dev_err(&data
->client
->dev
,
453 "Error writing reg_range\n");
456 data
->dps_range
= bmg160_scale_table
[i
].dps_range
;
464 static int bmg160_get_temp(struct bmg160_data
*data
, int *val
)
468 mutex_lock(&data
->mutex
);
469 ret
= bmg160_set_power_state(data
, true);
471 mutex_unlock(&data
->mutex
);
475 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_TEMP
);
477 dev_err(&data
->client
->dev
, "Error reading reg_temp\n");
478 bmg160_set_power_state(data
, false);
479 mutex_unlock(&data
->mutex
);
483 *val
= sign_extend32(ret
, 7);
484 ret
= bmg160_set_power_state(data
, false);
485 mutex_unlock(&data
->mutex
);
492 static int bmg160_get_axis(struct bmg160_data
*data
, int axis
, int *val
)
496 mutex_lock(&data
->mutex
);
497 ret
= bmg160_set_power_state(data
, true);
499 mutex_unlock(&data
->mutex
);
503 ret
= i2c_smbus_read_word_data(data
->client
, BMG160_AXIS_TO_REG(axis
));
505 dev_err(&data
->client
->dev
, "Error reading axis %d\n", axis
);
506 bmg160_set_power_state(data
, false);
507 mutex_unlock(&data
->mutex
);
511 *val
= sign_extend32(ret
, 15);
512 ret
= bmg160_set_power_state(data
, false);
513 mutex_unlock(&data
->mutex
);
520 static int bmg160_read_raw(struct iio_dev
*indio_dev
,
521 struct iio_chan_spec
const *chan
,
522 int *val
, int *val2
, long mask
)
524 struct bmg160_data
*data
= iio_priv(indio_dev
);
528 case IIO_CHAN_INFO_RAW
:
529 switch (chan
->type
) {
531 return bmg160_get_temp(data
, val
);
533 if (iio_buffer_enabled(indio_dev
))
536 return bmg160_get_axis(data
, chan
->scan_index
,
541 case IIO_CHAN_INFO_OFFSET
:
542 if (chan
->type
== IIO_TEMP
) {
543 *val
= BMG160_TEMP_CENTER_VAL
;
547 case IIO_CHAN_INFO_SCALE
:
549 switch (chan
->type
) {
552 return IIO_VAL_INT_PLUS_MICRO
;
557 for (i
= 0; i
< ARRAY_SIZE(bmg160_scale_table
); ++i
) {
558 if (bmg160_scale_table
[i
].dps_range
==
560 *val2
= bmg160_scale_table
[i
].scale
;
561 return IIO_VAL_INT_PLUS_MICRO
;
569 case IIO_CHAN_INFO_SAMP_FREQ
:
571 mutex_lock(&data
->mutex
);
572 ret
= bmg160_get_bw(data
, val
);
573 mutex_unlock(&data
->mutex
);
580 static int bmg160_write_raw(struct iio_dev
*indio_dev
,
581 struct iio_chan_spec
const *chan
,
582 int val
, int val2
, long mask
)
584 struct bmg160_data
*data
= iio_priv(indio_dev
);
588 case IIO_CHAN_INFO_SAMP_FREQ
:
589 mutex_lock(&data
->mutex
);
591 * Section 4.2 of spec
592 * In suspend mode, the only supported operations are reading
593 * registers as well as writing to the (0x14) softreset
594 * register. Since we will be in suspend mode by default, change
595 * mode to power on for other writes.
597 ret
= bmg160_set_power_state(data
, true);
599 mutex_unlock(&data
->mutex
);
602 ret
= bmg160_set_bw(data
, val
);
604 bmg160_set_power_state(data
, false);
605 mutex_unlock(&data
->mutex
);
608 ret
= bmg160_set_power_state(data
, false);
609 mutex_unlock(&data
->mutex
);
611 case IIO_CHAN_INFO_SCALE
:
615 mutex_lock(&data
->mutex
);
616 /* Refer to comments above for the suspend mode ops */
617 ret
= bmg160_set_power_state(data
, true);
619 mutex_unlock(&data
->mutex
);
622 ret
= bmg160_set_scale(data
, val2
);
624 bmg160_set_power_state(data
, false);
625 mutex_unlock(&data
->mutex
);
628 ret
= bmg160_set_power_state(data
, false);
629 mutex_unlock(&data
->mutex
);
638 static int bmg160_read_event(struct iio_dev
*indio_dev
,
639 const struct iio_chan_spec
*chan
,
640 enum iio_event_type type
,
641 enum iio_event_direction dir
,
642 enum iio_event_info info
,
645 struct bmg160_data
*data
= iio_priv(indio_dev
);
649 case IIO_EV_INFO_VALUE
:
650 *val
= data
->slope_thres
& BMG160_SLOPE_THRES_MASK
;
659 static int bmg160_write_event(struct iio_dev
*indio_dev
,
660 const struct iio_chan_spec
*chan
,
661 enum iio_event_type type
,
662 enum iio_event_direction dir
,
663 enum iio_event_info info
,
666 struct bmg160_data
*data
= iio_priv(indio_dev
);
669 case IIO_EV_INFO_VALUE
:
670 if (data
->ev_enable_state
)
672 data
->slope_thres
&= ~BMG160_SLOPE_THRES_MASK
;
673 data
->slope_thres
|= (val
& BMG160_SLOPE_THRES_MASK
);
682 static int bmg160_read_event_config(struct iio_dev
*indio_dev
,
683 const struct iio_chan_spec
*chan
,
684 enum iio_event_type type
,
685 enum iio_event_direction dir
)
688 struct bmg160_data
*data
= iio_priv(indio_dev
);
690 return data
->ev_enable_state
;
693 static int bmg160_write_event_config(struct iio_dev
*indio_dev
,
694 const struct iio_chan_spec
*chan
,
695 enum iio_event_type type
,
696 enum iio_event_direction dir
,
699 struct bmg160_data
*data
= iio_priv(indio_dev
);
702 if (state
&& data
->ev_enable_state
)
705 mutex_lock(&data
->mutex
);
707 if (!state
&& data
->motion_trigger_on
) {
708 data
->ev_enable_state
= 0;
709 mutex_unlock(&data
->mutex
);
713 * We will expect the enable and disable to do operation in
714 * in reverse order. This will happen here anyway as our
715 * resume operation uses sync mode runtime pm calls, the
716 * suspend operation will be delayed by autosuspend delay
717 * So the disable operation will still happen in reverse of
718 * enable operation. When runtime pm is disabled the mode
719 * is always on so sequence doesn't matter
721 ret
= bmg160_set_power_state(data
, state
);
723 mutex_unlock(&data
->mutex
);
727 ret
= bmg160_setup_any_motion_interrupt(data
, state
);
729 bmg160_set_power_state(data
, false);
730 mutex_unlock(&data
->mutex
);
734 data
->ev_enable_state
= state
;
735 mutex_unlock(&data
->mutex
);
740 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("100 200 400 1000 2000");
742 static IIO_CONST_ATTR(in_anglvel_scale_available
,
743 "0.001065 0.000532 0.000266 0.000133 0.000066");
745 static struct attribute
*bmg160_attributes
[] = {
746 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
747 &iio_const_attr_in_anglvel_scale_available
.dev_attr
.attr
,
751 static const struct attribute_group bmg160_attrs_group
= {
752 .attrs
= bmg160_attributes
,
755 static const struct iio_event_spec bmg160_event
= {
756 .type
= IIO_EV_TYPE_ROC
,
757 .dir
= IIO_EV_DIR_EITHER
,
758 .mask_shared_by_type
= BIT(IIO_EV_INFO_VALUE
) |
759 BIT(IIO_EV_INFO_ENABLE
)
762 #define BMG160_CHANNEL(_axis) { \
763 .type = IIO_ANGL_VEL, \
765 .channel2 = IIO_MOD_##_axis, \
766 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
767 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
768 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
769 .scan_index = AXIS_##_axis, \
775 .event_spec = &bmg160_event, \
776 .num_event_specs = 1 \
779 static const struct iio_chan_spec bmg160_channels
[] = {
782 .info_mask_separate
= BIT(IIO_CHAN_INFO_RAW
) |
783 BIT(IIO_CHAN_INFO_SCALE
) |
784 BIT(IIO_CHAN_INFO_OFFSET
),
790 IIO_CHAN_SOFT_TIMESTAMP(3),
793 static const struct iio_info bmg160_info
= {
794 .attrs
= &bmg160_attrs_group
,
795 .read_raw
= bmg160_read_raw
,
796 .write_raw
= bmg160_write_raw
,
797 .read_event_value
= bmg160_read_event
,
798 .write_event_value
= bmg160_write_event
,
799 .write_event_config
= bmg160_write_event_config
,
800 .read_event_config
= bmg160_read_event_config
,
801 .driver_module
= THIS_MODULE
,
804 static irqreturn_t
bmg160_trigger_handler(int irq
, void *p
)
806 struct iio_poll_func
*pf
= p
;
807 struct iio_dev
*indio_dev
= pf
->indio_dev
;
808 struct bmg160_data
*data
= iio_priv(indio_dev
);
811 mutex_lock(&data
->mutex
);
812 for_each_set_bit(bit
, indio_dev
->active_scan_mask
,
813 indio_dev
->masklength
) {
814 ret
= i2c_smbus_read_word_data(data
->client
,
815 BMG160_AXIS_TO_REG(bit
));
817 mutex_unlock(&data
->mutex
);
820 data
->buffer
[i
++] = ret
;
822 mutex_unlock(&data
->mutex
);
824 iio_push_to_buffers_with_timestamp(indio_dev
, data
->buffer
,
827 iio_trigger_notify_done(indio_dev
->trig
);
832 static int bmg160_trig_try_reen(struct iio_trigger
*trig
)
834 struct iio_dev
*indio_dev
= iio_trigger_get_drvdata(trig
);
835 struct bmg160_data
*data
= iio_priv(indio_dev
);
838 /* new data interrupts don't need ack */
839 if (data
->dready_trigger_on
)
842 /* Set latched mode interrupt and clear any latched interrupt */
843 ret
= i2c_smbus_write_byte_data(data
->client
,
844 BMG160_REG_INT_RST_LATCH
,
845 BMG160_INT_MODE_LATCH_INT
|
846 BMG160_INT_MODE_LATCH_RESET
);
848 dev_err(&data
->client
->dev
, "Error writing reg_rst_latch\n");
855 static int bmg160_data_rdy_trigger_set_state(struct iio_trigger
*trig
,
858 struct iio_dev
*indio_dev
= iio_trigger_get_drvdata(trig
);
859 struct bmg160_data
*data
= iio_priv(indio_dev
);
862 mutex_lock(&data
->mutex
);
864 if (!state
&& data
->ev_enable_state
&& data
->motion_trigger_on
) {
865 data
->motion_trigger_on
= false;
866 mutex_unlock(&data
->mutex
);
871 * Refer to comment in bmg160_write_event_config for
872 * enable/disable operation order
874 ret
= bmg160_set_power_state(data
, state
);
876 mutex_unlock(&data
->mutex
);
879 if (data
->motion_trig
== trig
)
880 ret
= bmg160_setup_any_motion_interrupt(data
, state
);
882 ret
= bmg160_setup_new_data_interrupt(data
, state
);
884 bmg160_set_power_state(data
, false);
885 mutex_unlock(&data
->mutex
);
888 if (data
->motion_trig
== trig
)
889 data
->motion_trigger_on
= state
;
891 data
->dready_trigger_on
= state
;
893 mutex_unlock(&data
->mutex
);
898 static const struct iio_trigger_ops bmg160_trigger_ops
= {
899 .set_trigger_state
= bmg160_data_rdy_trigger_set_state
,
900 .try_reenable
= bmg160_trig_try_reen
,
901 .owner
= THIS_MODULE
,
904 static irqreturn_t
bmg160_event_handler(int irq
, void *private)
906 struct iio_dev
*indio_dev
= private;
907 struct bmg160_data
*data
= iio_priv(indio_dev
);
911 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_INT_STATUS_2
);
913 dev_err(&data
->client
->dev
, "Error reading reg_int_status2\n");
914 goto ack_intr_status
;
918 dir
= IIO_EV_DIR_RISING
;
920 dir
= IIO_EV_DIR_FALLING
;
922 if (ret
& BMG160_ANY_MOTION_BIT_X
)
923 iio_push_event(indio_dev
, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL
,
929 if (ret
& BMG160_ANY_MOTION_BIT_Y
)
930 iio_push_event(indio_dev
, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL
,
936 if (ret
& BMG160_ANY_MOTION_BIT_Z
)
937 iio_push_event(indio_dev
, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL
,
945 if (!data
->dready_trigger_on
) {
946 ret
= i2c_smbus_write_byte_data(data
->client
,
947 BMG160_REG_INT_RST_LATCH
,
948 BMG160_INT_MODE_LATCH_INT
|
949 BMG160_INT_MODE_LATCH_RESET
);
951 dev_err(&data
->client
->dev
,
952 "Error writing reg_rst_latch\n");
958 static irqreturn_t
bmg160_data_rdy_trig_poll(int irq
, void *private)
960 struct iio_dev
*indio_dev
= private;
961 struct bmg160_data
*data
= iio_priv(indio_dev
);
963 if (data
->dready_trigger_on
)
964 iio_trigger_poll(data
->dready_trig
);
965 else if (data
->motion_trigger_on
)
966 iio_trigger_poll(data
->motion_trig
);
968 if (data
->ev_enable_state
)
969 return IRQ_WAKE_THREAD
;
975 static int bmg160_buffer_preenable(struct iio_dev
*indio_dev
)
977 struct bmg160_data
*data
= iio_priv(indio_dev
);
979 return bmg160_set_power_state(data
, true);
982 static int bmg160_buffer_postdisable(struct iio_dev
*indio_dev
)
984 struct bmg160_data
*data
= iio_priv(indio_dev
);
986 return bmg160_set_power_state(data
, false);
989 static const struct iio_buffer_setup_ops bmg160_buffer_setup_ops
= {
990 .preenable
= bmg160_buffer_preenable
,
991 .postenable
= iio_triggered_buffer_postenable
,
992 .predisable
= iio_triggered_buffer_predisable
,
993 .postdisable
= bmg160_buffer_postdisable
,
996 static int bmg160_gpio_probe(struct i2c_client
*client
,
997 struct bmg160_data
*data
)
1001 struct gpio_desc
*gpio
;
1009 /* data ready gpio interrupt pin */
1010 gpio
= devm_gpiod_get_index(dev
, BMG160_GPIO_NAME
, 0, GPIOD_IN
);
1012 dev_err(dev
, "acpi gpio get index failed\n");
1013 return PTR_ERR(gpio
);
1016 ret
= gpiod_to_irq(gpio
);
1018 dev_dbg(dev
, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio
), ret
);
1023 static const char *bmg160_match_acpi_device(struct device
*dev
)
1025 const struct acpi_device_id
*id
;
1027 id
= acpi_match_device(dev
->driver
->acpi_match_table
, dev
);
1031 return dev_name(dev
);
1034 static int bmg160_probe(struct i2c_client
*client
,
1035 const struct i2c_device_id
*id
)
1037 struct bmg160_data
*data
;
1038 struct iio_dev
*indio_dev
;
1040 const char *name
= NULL
;
1042 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
1046 data
= iio_priv(indio_dev
);
1047 i2c_set_clientdata(client
, indio_dev
);
1048 data
->client
= client
;
1050 ret
= bmg160_chip_init(data
);
1054 mutex_init(&data
->mutex
);
1059 if (ACPI_HANDLE(&client
->dev
))
1060 name
= bmg160_match_acpi_device(&client
->dev
);
1062 indio_dev
->dev
.parent
= &client
->dev
;
1063 indio_dev
->channels
= bmg160_channels
;
1064 indio_dev
->num_channels
= ARRAY_SIZE(bmg160_channels
);
1065 indio_dev
->name
= name
;
1066 indio_dev
->modes
= INDIO_DIRECT_MODE
;
1067 indio_dev
->info
= &bmg160_info
;
1069 if (client
->irq
<= 0)
1070 client
->irq
= bmg160_gpio_probe(client
, data
);
1072 if (client
->irq
> 0) {
1073 ret
= devm_request_threaded_irq(&client
->dev
,
1075 bmg160_data_rdy_trig_poll
,
1076 bmg160_event_handler
,
1077 IRQF_TRIGGER_RISING
,
1083 data
->dready_trig
= devm_iio_trigger_alloc(&client
->dev
,
1087 if (!data
->dready_trig
)
1090 data
->motion_trig
= devm_iio_trigger_alloc(&client
->dev
,
1091 "%s-any-motion-dev%d",
1094 if (!data
->motion_trig
)
1097 data
->dready_trig
->dev
.parent
= &client
->dev
;
1098 data
->dready_trig
->ops
= &bmg160_trigger_ops
;
1099 iio_trigger_set_drvdata(data
->dready_trig
, indio_dev
);
1100 ret
= iio_trigger_register(data
->dready_trig
);
1104 data
->motion_trig
->dev
.parent
= &client
->dev
;
1105 data
->motion_trig
->ops
= &bmg160_trigger_ops
;
1106 iio_trigger_set_drvdata(data
->motion_trig
, indio_dev
);
1107 ret
= iio_trigger_register(data
->motion_trig
);
1109 data
->motion_trig
= NULL
;
1110 goto err_trigger_unregister
;
1114 ret
= iio_triggered_buffer_setup(indio_dev
,
1115 iio_pollfunc_store_time
,
1116 bmg160_trigger_handler
,
1117 &bmg160_buffer_setup_ops
);
1119 dev_err(&client
->dev
,
1120 "iio triggered buffer setup failed\n");
1121 goto err_trigger_unregister
;
1124 ret
= iio_device_register(indio_dev
);
1126 dev_err(&client
->dev
, "unable to register iio device\n");
1127 goto err_buffer_cleanup
;
1130 ret
= pm_runtime_set_active(&client
->dev
);
1132 goto err_iio_unregister
;
1134 pm_runtime_enable(&client
->dev
);
1135 pm_runtime_set_autosuspend_delay(&client
->dev
,
1136 BMG160_AUTO_SUSPEND_DELAY_MS
);
1137 pm_runtime_use_autosuspend(&client
->dev
);
1142 iio_device_unregister(indio_dev
);
1144 iio_triggered_buffer_cleanup(indio_dev
);
1145 err_trigger_unregister
:
1146 if (data
->dready_trig
)
1147 iio_trigger_unregister(data
->dready_trig
);
1148 if (data
->motion_trig
)
1149 iio_trigger_unregister(data
->motion_trig
);
1154 static int bmg160_remove(struct i2c_client
*client
)
1156 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
1157 struct bmg160_data
*data
= iio_priv(indio_dev
);
1159 pm_runtime_disable(&client
->dev
);
1160 pm_runtime_set_suspended(&client
->dev
);
1161 pm_runtime_put_noidle(&client
->dev
);
1163 iio_device_unregister(indio_dev
);
1164 iio_triggered_buffer_cleanup(indio_dev
);
1166 if (data
->dready_trig
) {
1167 iio_trigger_unregister(data
->dready_trig
);
1168 iio_trigger_unregister(data
->motion_trig
);
1171 mutex_lock(&data
->mutex
);
1172 bmg160_set_mode(data
, BMG160_MODE_DEEP_SUSPEND
);
1173 mutex_unlock(&data
->mutex
);
1178 #ifdef CONFIG_PM_SLEEP
1179 static int bmg160_suspend(struct device
*dev
)
1181 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1182 struct bmg160_data
*data
= iio_priv(indio_dev
);
1184 mutex_lock(&data
->mutex
);
1185 bmg160_set_mode(data
, BMG160_MODE_SUSPEND
);
1186 mutex_unlock(&data
->mutex
);
1191 static int bmg160_resume(struct device
*dev
)
1193 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1194 struct bmg160_data
*data
= iio_priv(indio_dev
);
1196 mutex_lock(&data
->mutex
);
1197 if (data
->dready_trigger_on
|| data
->motion_trigger_on
||
1198 data
->ev_enable_state
)
1199 bmg160_set_mode(data
, BMG160_MODE_NORMAL
);
1200 mutex_unlock(&data
->mutex
);
1207 static int bmg160_runtime_suspend(struct device
*dev
)
1209 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1210 struct bmg160_data
*data
= iio_priv(indio_dev
);
1213 ret
= bmg160_set_mode(data
, BMG160_MODE_SUSPEND
);
1215 dev_err(&data
->client
->dev
, "set mode failed\n");
1222 static int bmg160_runtime_resume(struct device
*dev
)
1224 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1225 struct bmg160_data
*data
= iio_priv(indio_dev
);
1228 ret
= bmg160_set_mode(data
, BMG160_MODE_NORMAL
);
1232 msleep_interruptible(BMG160_MAX_STARTUP_TIME_MS
);
1238 static const struct dev_pm_ops bmg160_pm_ops
= {
1239 SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend
, bmg160_resume
)
1240 SET_RUNTIME_PM_OPS(bmg160_runtime_suspend
,
1241 bmg160_runtime_resume
, NULL
)
1244 static const struct acpi_device_id bmg160_acpi_match
[] = {
1250 MODULE_DEVICE_TABLE(acpi
, bmg160_acpi_match
);
1252 static const struct i2c_device_id bmg160_id
[] = {
1258 MODULE_DEVICE_TABLE(i2c
, bmg160_id
);
1260 static struct i2c_driver bmg160_driver
= {
1262 .name
= BMG160_DRV_NAME
,
1263 .acpi_match_table
= ACPI_PTR(bmg160_acpi_match
),
1264 .pm
= &bmg160_pm_ops
,
1266 .probe
= bmg160_probe
,
1267 .remove
= bmg160_remove
,
1268 .id_table
= bmg160_id
,
1270 module_i2c_driver(bmg160_driver
);
1272 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1273 MODULE_LICENSE("GPL v2");
1274 MODULE_DESCRIPTION("BMG160 Gyro driver");