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
89 #define BMG160_REG_TEMP 0x08
90 #define BMG160_TEMP_CENTER_VAL 23
92 #define BMG160_MAX_STARTUP_TIME_MS 80
94 #define BMG160_AUTO_SUSPEND_DELAY_MS 2000
97 struct i2c_client
*client
;
98 struct iio_trigger
*dready_trig
;
99 struct iio_trigger
*motion_trig
;
106 bool dready_trigger_on
;
107 bool motion_trigger_on
;
117 static const struct {
120 } bmg160_samp_freq_table
[] = { {100, 0x07},
126 static const struct {
129 } bmg160_scale_table
[] = { { 1065, BMG160_RANGE_2000DPS
},
130 { 532, BMG160_RANGE_1000DPS
},
131 { 266, BMG160_RANGE_500DPS
},
132 { 133, BMG160_RANGE_250DPS
},
133 { 66, BMG160_RANGE_125DPS
} };
135 static int bmg160_set_mode(struct bmg160_data
*data
, u8 mode
)
139 ret
= i2c_smbus_write_byte_data(data
->client
,
140 BMG160_REG_PMU_LPW
, mode
);
142 dev_err(&data
->client
->dev
, "Error writing reg_pmu_lpw\n");
149 static int bmg160_convert_freq_to_bit(int val
)
153 for (i
= 0; i
< ARRAY_SIZE(bmg160_samp_freq_table
); ++i
) {
154 if (bmg160_samp_freq_table
[i
].val
== val
)
155 return bmg160_samp_freq_table
[i
].bw_bits
;
161 static int bmg160_set_bw(struct bmg160_data
*data
, int val
)
166 bw_bits
= bmg160_convert_freq_to_bit(val
);
170 ret
= i2c_smbus_write_byte_data(data
->client
, BMG160_REG_PMU_BW
,
173 dev_err(&data
->client
->dev
, "Error writing reg_pmu_bw\n");
177 data
->bw_bits
= bw_bits
;
182 static int bmg160_chip_init(struct bmg160_data
*data
)
186 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_CHIP_ID
);
188 dev_err(&data
->client
->dev
, "Error reading reg_chip_id\n");
192 dev_dbg(&data
->client
->dev
, "Chip Id %x\n", ret
);
193 if (ret
!= BMG160_CHIP_ID_VAL
) {
194 dev_err(&data
->client
->dev
, "invalid chip %x\n", ret
);
198 ret
= bmg160_set_mode(data
, BMG160_MODE_NORMAL
);
202 /* Wait upto 500 ms to be ready after changing mode */
203 usleep_range(500, 1000);
206 ret
= bmg160_set_bw(data
, BMG160_DEF_BW
);
210 /* Set Default Range */
211 ret
= i2c_smbus_write_byte_data(data
->client
,
213 BMG160_RANGE_500DPS
);
215 dev_err(&data
->client
->dev
, "Error writing reg_range\n");
218 data
->dps_range
= BMG160_RANGE_500DPS
;
220 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_SLOPE_THRES
);
222 dev_err(&data
->client
->dev
, "Error reading reg_slope_thres\n");
225 data
->slope_thres
= ret
;
227 /* Set default interrupt mode */
228 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_INT_EN_1
);
230 dev_err(&data
->client
->dev
, "Error reading reg_int_en_1\n");
233 ret
&= ~BMG160_INT1_BIT_OD
;
234 ret
= i2c_smbus_write_byte_data(data
->client
,
235 BMG160_REG_INT_EN_1
, ret
);
237 dev_err(&data
->client
->dev
, "Error writing reg_int_en_1\n");
241 ret
= i2c_smbus_write_byte_data(data
->client
,
242 BMG160_REG_INT_RST_LATCH
,
243 BMG160_INT_MODE_LATCH_INT
|
244 BMG160_INT_MODE_LATCH_RESET
);
246 dev_err(&data
->client
->dev
,
247 "Error writing reg_motion_intr\n");
254 static int bmg160_set_power_state(struct bmg160_data
*data
, bool on
)
256 #ifdef CONFIG_PM_RUNTIME
260 ret
= pm_runtime_get_sync(&data
->client
->dev
);
262 pm_runtime_mark_last_busy(&data
->client
->dev
);
263 ret
= pm_runtime_put_autosuspend(&data
->client
->dev
);
267 dev_err(&data
->client
->dev
,
268 "Failed: bmg160_set_power_state for %d\n", on
);
270 pm_runtime_put_noidle(&data
->client
->dev
);
279 static int bmg160_setup_any_motion_interrupt(struct bmg160_data
*data
,
284 /* Enable/Disable INT_MAP0 mapping */
285 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_INT_MAP_0
);
287 dev_err(&data
->client
->dev
, "Error reading reg_int_map0\n");
291 ret
|= BMG160_INT_MAP_0_BIT_ANY
;
293 ret
&= ~BMG160_INT_MAP_0_BIT_ANY
;
295 ret
= i2c_smbus_write_byte_data(data
->client
,
296 BMG160_REG_INT_MAP_0
,
299 dev_err(&data
->client
->dev
, "Error writing reg_int_map0\n");
303 /* Enable/Disable slope interrupts */
305 /* Update slope thres */
306 ret
= i2c_smbus_write_byte_data(data
->client
,
307 BMG160_REG_SLOPE_THRES
,
310 dev_err(&data
->client
->dev
,
311 "Error writing reg_slope_thres\n");
315 ret
= i2c_smbus_write_byte_data(data
->client
,
316 BMG160_REG_MOTION_INTR
,
317 BMG160_INT_MOTION_X
|
318 BMG160_INT_MOTION_Y
|
319 BMG160_INT_MOTION_Z
);
321 dev_err(&data
->client
->dev
,
322 "Error writing reg_motion_intr\n");
327 * New data interrupt is always non-latched,
328 * which will have higher priority, so no need
329 * to set latched mode, we will be flooded anyway with INTR
331 if (!data
->dready_trigger_on
) {
332 ret
= i2c_smbus_write_byte_data(data
->client
,
333 BMG160_REG_INT_RST_LATCH
,
334 BMG160_INT_MODE_LATCH_INT
|
335 BMG160_INT_MODE_LATCH_RESET
);
337 dev_err(&data
->client
->dev
,
338 "Error writing reg_rst_latch\n");
343 ret
= i2c_smbus_write_byte_data(data
->client
,
345 BMG160_DATA_ENABLE_INT
);
348 ret
= i2c_smbus_write_byte_data(data
->client
,
353 dev_err(&data
->client
->dev
, "Error writing reg_int_en0\n");
360 static int bmg160_setup_new_data_interrupt(struct bmg160_data
*data
,
365 /* Enable/Disable INT_MAP1 mapping */
366 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_INT_MAP_1
);
368 dev_err(&data
->client
->dev
, "Error reading reg_int_map1\n");
373 ret
|= BMG160_INT_MAP_1_BIT_NEW_DATA
;
375 ret
&= ~BMG160_INT_MAP_1_BIT_NEW_DATA
;
377 ret
= i2c_smbus_write_byte_data(data
->client
,
378 BMG160_REG_INT_MAP_1
,
381 dev_err(&data
->client
->dev
, "Error writing reg_int_map1\n");
386 ret
= i2c_smbus_write_byte_data(data
->client
,
387 BMG160_REG_INT_RST_LATCH
,
388 BMG160_INT_MODE_NON_LATCH_INT
|
389 BMG160_INT_MODE_LATCH_RESET
);
391 dev_err(&data
->client
->dev
,
392 "Error writing reg_rst_latch\n");
396 ret
= i2c_smbus_write_byte_data(data
->client
,
398 BMG160_DATA_ENABLE_INT
);
401 /* Restore interrupt mode */
402 ret
= i2c_smbus_write_byte_data(data
->client
,
403 BMG160_REG_INT_RST_LATCH
,
404 BMG160_INT_MODE_LATCH_INT
|
405 BMG160_INT_MODE_LATCH_RESET
);
407 dev_err(&data
->client
->dev
,
408 "Error writing reg_rst_latch\n");
412 ret
= i2c_smbus_write_byte_data(data
->client
,
418 dev_err(&data
->client
->dev
, "Error writing reg_int_en0\n");
425 static int bmg160_get_bw(struct bmg160_data
*data
, int *val
)
429 for (i
= 0; i
< ARRAY_SIZE(bmg160_samp_freq_table
); ++i
) {
430 if (bmg160_samp_freq_table
[i
].bw_bits
== data
->bw_bits
) {
431 *val
= bmg160_samp_freq_table
[i
].val
;
439 static int bmg160_set_scale(struct bmg160_data
*data
, int val
)
443 for (i
= 0; i
< ARRAY_SIZE(bmg160_scale_table
); ++i
) {
444 if (bmg160_scale_table
[i
].scale
== val
) {
445 ret
= i2c_smbus_write_byte_data(
448 bmg160_scale_table
[i
].dps_range
);
450 dev_err(&data
->client
->dev
,
451 "Error writing reg_range\n");
454 data
->dps_range
= bmg160_scale_table
[i
].dps_range
;
462 static int bmg160_get_temp(struct bmg160_data
*data
, int *val
)
466 mutex_lock(&data
->mutex
);
467 ret
= bmg160_set_power_state(data
, true);
469 mutex_unlock(&data
->mutex
);
473 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_TEMP
);
475 dev_err(&data
->client
->dev
, "Error reading reg_temp\n");
476 bmg160_set_power_state(data
, false);
477 mutex_unlock(&data
->mutex
);
481 *val
= sign_extend32(ret
, 7);
482 ret
= bmg160_set_power_state(data
, false);
483 mutex_unlock(&data
->mutex
);
490 static int bmg160_get_axis(struct bmg160_data
*data
, int axis
, int *val
)
494 mutex_lock(&data
->mutex
);
495 ret
= bmg160_set_power_state(data
, true);
497 mutex_unlock(&data
->mutex
);
501 ret
= i2c_smbus_read_word_data(data
->client
, BMG160_AXIS_TO_REG(axis
));
503 dev_err(&data
->client
->dev
, "Error reading axis %d\n", axis
);
504 bmg160_set_power_state(data
, false);
505 mutex_unlock(&data
->mutex
);
509 *val
= sign_extend32(ret
, 15);
510 ret
= bmg160_set_power_state(data
, false);
511 mutex_unlock(&data
->mutex
);
518 static int bmg160_read_raw(struct iio_dev
*indio_dev
,
519 struct iio_chan_spec
const *chan
,
520 int *val
, int *val2
, long mask
)
522 struct bmg160_data
*data
= iio_priv(indio_dev
);
526 case IIO_CHAN_INFO_RAW
:
527 switch (chan
->type
) {
529 return bmg160_get_temp(data
, val
);
531 if (iio_buffer_enabled(indio_dev
))
534 return bmg160_get_axis(data
, chan
->scan_index
,
539 case IIO_CHAN_INFO_OFFSET
:
540 if (chan
->type
== IIO_TEMP
) {
541 *val
= BMG160_TEMP_CENTER_VAL
;
545 case IIO_CHAN_INFO_SCALE
:
547 switch (chan
->type
) {
550 return IIO_VAL_INT_PLUS_MICRO
;
555 for (i
= 0; i
< ARRAY_SIZE(bmg160_scale_table
); ++i
) {
556 if (bmg160_scale_table
[i
].dps_range
==
558 *val2
= bmg160_scale_table
[i
].scale
;
559 return IIO_VAL_INT_PLUS_MICRO
;
567 case IIO_CHAN_INFO_SAMP_FREQ
:
569 mutex_lock(&data
->mutex
);
570 ret
= bmg160_get_bw(data
, val
);
571 mutex_unlock(&data
->mutex
);
578 static int bmg160_write_raw(struct iio_dev
*indio_dev
,
579 struct iio_chan_spec
const *chan
,
580 int val
, int val2
, long mask
)
582 struct bmg160_data
*data
= iio_priv(indio_dev
);
586 case IIO_CHAN_INFO_SAMP_FREQ
:
587 mutex_lock(&data
->mutex
);
589 * Section 4.2 of spec
590 * In suspend mode, the only supported operations are reading
591 * registers as well as writing to the (0x14) softreset
592 * register. Since we will be in suspend mode by default, change
593 * mode to power on for other writes.
595 ret
= bmg160_set_power_state(data
, true);
597 mutex_unlock(&data
->mutex
);
600 ret
= bmg160_set_bw(data
, val
);
602 bmg160_set_power_state(data
, false);
603 mutex_unlock(&data
->mutex
);
606 ret
= bmg160_set_power_state(data
, false);
607 mutex_unlock(&data
->mutex
);
609 case IIO_CHAN_INFO_SCALE
:
613 mutex_lock(&data
->mutex
);
614 /* Refer to comments above for the suspend mode ops */
615 ret
= bmg160_set_power_state(data
, true);
617 mutex_unlock(&data
->mutex
);
620 ret
= bmg160_set_scale(data
, val2
);
622 bmg160_set_power_state(data
, false);
623 mutex_unlock(&data
->mutex
);
626 ret
= bmg160_set_power_state(data
, false);
627 mutex_unlock(&data
->mutex
);
636 static int bmg160_read_event(struct iio_dev
*indio_dev
,
637 const struct iio_chan_spec
*chan
,
638 enum iio_event_type type
,
639 enum iio_event_direction dir
,
640 enum iio_event_info info
,
643 struct bmg160_data
*data
= iio_priv(indio_dev
);
647 case IIO_EV_INFO_VALUE
:
648 *val
= data
->slope_thres
& BMG160_SLOPE_THRES_MASK
;
657 static int bmg160_write_event(struct iio_dev
*indio_dev
,
658 const struct iio_chan_spec
*chan
,
659 enum iio_event_type type
,
660 enum iio_event_direction dir
,
661 enum iio_event_info info
,
664 struct bmg160_data
*data
= iio_priv(indio_dev
);
667 case IIO_EV_INFO_VALUE
:
668 if (data
->ev_enable_state
)
670 data
->slope_thres
&= ~BMG160_SLOPE_THRES_MASK
;
671 data
->slope_thres
|= (val
& BMG160_SLOPE_THRES_MASK
);
680 static int bmg160_read_event_config(struct iio_dev
*indio_dev
,
681 const struct iio_chan_spec
*chan
,
682 enum iio_event_type type
,
683 enum iio_event_direction dir
)
686 struct bmg160_data
*data
= iio_priv(indio_dev
);
688 return data
->ev_enable_state
;
691 static int bmg160_write_event_config(struct iio_dev
*indio_dev
,
692 const struct iio_chan_spec
*chan
,
693 enum iio_event_type type
,
694 enum iio_event_direction dir
,
697 struct bmg160_data
*data
= iio_priv(indio_dev
);
700 if (state
&& data
->ev_enable_state
)
703 mutex_lock(&data
->mutex
);
705 if (!state
&& data
->motion_trigger_on
) {
706 data
->ev_enable_state
= 0;
707 mutex_unlock(&data
->mutex
);
711 * We will expect the enable and disable to do operation in
712 * in reverse order. This will happen here anyway as our
713 * resume operation uses sync mode runtime pm calls, the
714 * suspend operation will be delayed by autosuspend delay
715 * So the disable operation will still happen in reverse of
716 * enable operation. When runtime pm is disabled the mode
717 * is always on so sequence doesn't matter
719 ret
= bmg160_set_power_state(data
, state
);
721 mutex_unlock(&data
->mutex
);
725 ret
= bmg160_setup_any_motion_interrupt(data
, state
);
727 bmg160_set_power_state(data
, false);
728 mutex_unlock(&data
->mutex
);
732 data
->ev_enable_state
= state
;
733 mutex_unlock(&data
->mutex
);
738 static int bmg160_validate_trigger(struct iio_dev
*indio_dev
,
739 struct iio_trigger
*trig
)
741 struct bmg160_data
*data
= iio_priv(indio_dev
);
743 if (data
->dready_trig
!= trig
&& data
->motion_trig
!= trig
)
749 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("100 200 400 1000 2000");
751 static IIO_CONST_ATTR(in_anglvel_scale_available
,
752 "0.001065 0.000532 0.000266 0.000133 0.000066");
754 static struct attribute
*bmg160_attributes
[] = {
755 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
756 &iio_const_attr_in_anglvel_scale_available
.dev_attr
.attr
,
760 static const struct attribute_group bmg160_attrs_group
= {
761 .attrs
= bmg160_attributes
,
764 static const struct iio_event_spec bmg160_event
= {
765 .type
= IIO_EV_TYPE_ROC
,
766 .dir
= IIO_EV_DIR_RISING
| IIO_EV_DIR_FALLING
,
767 .mask_shared_by_type
= BIT(IIO_EV_INFO_VALUE
) |
768 BIT(IIO_EV_INFO_ENABLE
)
771 #define BMG160_CHANNEL(_axis) { \
772 .type = IIO_ANGL_VEL, \
774 .channel2 = IIO_MOD_##_axis, \
775 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
776 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
777 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
778 .scan_index = AXIS_##_axis, \
784 .event_spec = &bmg160_event, \
785 .num_event_specs = 1 \
788 static const struct iio_chan_spec bmg160_channels
[] = {
791 .info_mask_separate
= BIT(IIO_CHAN_INFO_RAW
) |
792 BIT(IIO_CHAN_INFO_SCALE
) |
793 BIT(IIO_CHAN_INFO_OFFSET
),
799 IIO_CHAN_SOFT_TIMESTAMP(3),
802 static const struct iio_info bmg160_info
= {
803 .attrs
= &bmg160_attrs_group
,
804 .read_raw
= bmg160_read_raw
,
805 .write_raw
= bmg160_write_raw
,
806 .read_event_value
= bmg160_read_event
,
807 .write_event_value
= bmg160_write_event
,
808 .write_event_config
= bmg160_write_event_config
,
809 .read_event_config
= bmg160_read_event_config
,
810 .validate_trigger
= bmg160_validate_trigger
,
811 .driver_module
= THIS_MODULE
,
814 static irqreturn_t
bmg160_trigger_handler(int irq
, void *p
)
816 struct iio_poll_func
*pf
= p
;
817 struct iio_dev
*indio_dev
= pf
->indio_dev
;
818 struct bmg160_data
*data
= iio_priv(indio_dev
);
821 mutex_lock(&data
->mutex
);
822 for_each_set_bit(bit
, indio_dev
->buffer
->scan_mask
,
823 indio_dev
->masklength
) {
824 ret
= i2c_smbus_read_word_data(data
->client
,
825 BMG160_AXIS_TO_REG(bit
));
827 mutex_unlock(&data
->mutex
);
830 data
->buffer
[i
++] = ret
;
832 mutex_unlock(&data
->mutex
);
834 iio_push_to_buffers_with_timestamp(indio_dev
, data
->buffer
,
837 iio_trigger_notify_done(indio_dev
->trig
);
842 static int bmg160_trig_try_reen(struct iio_trigger
*trig
)
844 struct iio_dev
*indio_dev
= iio_trigger_get_drvdata(trig
);
845 struct bmg160_data
*data
= iio_priv(indio_dev
);
848 /* new data interrupts don't need ack */
849 if (data
->dready_trigger_on
)
852 /* Set latched mode interrupt and clear any latched interrupt */
853 ret
= i2c_smbus_write_byte_data(data
->client
,
854 BMG160_REG_INT_RST_LATCH
,
855 BMG160_INT_MODE_LATCH_INT
|
856 BMG160_INT_MODE_LATCH_RESET
);
858 dev_err(&data
->client
->dev
, "Error writing reg_rst_latch\n");
865 static int bmg160_data_rdy_trigger_set_state(struct iio_trigger
*trig
,
868 struct iio_dev
*indio_dev
= iio_trigger_get_drvdata(trig
);
869 struct bmg160_data
*data
= iio_priv(indio_dev
);
872 mutex_lock(&data
->mutex
);
874 if (!state
&& data
->ev_enable_state
&& data
->motion_trigger_on
) {
875 data
->motion_trigger_on
= false;
876 mutex_unlock(&data
->mutex
);
881 * Refer to comment in bmg160_write_event_config for
882 * enable/disable operation order
884 ret
= bmg160_set_power_state(data
, state
);
886 mutex_unlock(&data
->mutex
);
889 if (data
->motion_trig
== trig
)
890 ret
= bmg160_setup_any_motion_interrupt(data
, state
);
892 ret
= bmg160_setup_new_data_interrupt(data
, state
);
894 bmg160_set_power_state(data
, false);
895 mutex_unlock(&data
->mutex
);
898 if (data
->motion_trig
== trig
)
899 data
->motion_trigger_on
= state
;
901 data
->dready_trigger_on
= state
;
903 mutex_unlock(&data
->mutex
);
908 static const struct iio_trigger_ops bmg160_trigger_ops
= {
909 .set_trigger_state
= bmg160_data_rdy_trigger_set_state
,
910 .try_reenable
= bmg160_trig_try_reen
,
911 .owner
= THIS_MODULE
,
914 static irqreturn_t
bmg160_event_handler(int irq
, void *private)
916 struct iio_dev
*indio_dev
= private;
917 struct bmg160_data
*data
= iio_priv(indio_dev
);
921 ret
= i2c_smbus_read_byte_data(data
->client
, BMG160_REG_INT_STATUS_2
);
923 dev_err(&data
->client
->dev
, "Error reading reg_int_status2\n");
924 goto ack_intr_status
;
928 dir
= IIO_EV_DIR_RISING
;
930 dir
= IIO_EV_DIR_FALLING
;
932 if (ret
& BMG160_ANY_MOTION_MASK
)
933 iio_push_event(indio_dev
, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL
,
941 if (!data
->dready_trigger_on
) {
942 ret
= i2c_smbus_write_byte_data(data
->client
,
943 BMG160_REG_INT_RST_LATCH
,
944 BMG160_INT_MODE_LATCH_INT
|
945 BMG160_INT_MODE_LATCH_RESET
);
947 dev_err(&data
->client
->dev
,
948 "Error writing reg_rst_latch\n");
954 static irqreturn_t
bmg160_data_rdy_trig_poll(int irq
, void *private)
956 struct iio_dev
*indio_dev
= private;
957 struct bmg160_data
*data
= iio_priv(indio_dev
);
959 data
->timestamp
= iio_get_time_ns();
961 if (data
->dready_trigger_on
)
962 iio_trigger_poll(data
->dready_trig
);
963 else if (data
->motion_trigger_on
)
964 iio_trigger_poll(data
->motion_trig
);
966 if (data
->ev_enable_state
)
967 return IRQ_WAKE_THREAD
;
973 static int bmg160_gpio_probe(struct i2c_client
*client
,
974 struct bmg160_data
*data
)
978 struct gpio_desc
*gpio
;
986 /* data ready gpio interrupt pin */
987 gpio
= devm_gpiod_get_index(dev
, BMG160_GPIO_NAME
, 0);
989 dev_err(dev
, "acpi gpio get index failed\n");
990 return PTR_ERR(gpio
);
993 ret
= gpiod_direction_input(gpio
);
997 ret
= gpiod_to_irq(gpio
);
999 dev_dbg(dev
, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio
), ret
);
1004 static const char *bmg160_match_acpi_device(struct device
*dev
)
1006 const struct acpi_device_id
*id
;
1008 id
= acpi_match_device(dev
->driver
->acpi_match_table
, dev
);
1012 return dev_name(dev
);
1015 static int bmg160_probe(struct i2c_client
*client
,
1016 const struct i2c_device_id
*id
)
1018 struct bmg160_data
*data
;
1019 struct iio_dev
*indio_dev
;
1021 const char *name
= NULL
;
1023 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
1027 data
= iio_priv(indio_dev
);
1028 i2c_set_clientdata(client
, indio_dev
);
1029 data
->client
= client
;
1031 ret
= bmg160_chip_init(data
);
1035 mutex_init(&data
->mutex
);
1040 if (ACPI_HANDLE(&client
->dev
))
1041 name
= bmg160_match_acpi_device(&client
->dev
);
1043 indio_dev
->dev
.parent
= &client
->dev
;
1044 indio_dev
->channels
= bmg160_channels
;
1045 indio_dev
->num_channels
= ARRAY_SIZE(bmg160_channels
);
1046 indio_dev
->name
= name
;
1047 indio_dev
->modes
= INDIO_DIRECT_MODE
;
1048 indio_dev
->info
= &bmg160_info
;
1050 if (client
->irq
<= 0)
1051 client
->irq
= bmg160_gpio_probe(client
, data
);
1053 if (client
->irq
> 0) {
1054 ret
= devm_request_threaded_irq(&client
->dev
,
1056 bmg160_data_rdy_trig_poll
,
1057 bmg160_event_handler
,
1058 IRQF_TRIGGER_RISING
,
1064 data
->dready_trig
= devm_iio_trigger_alloc(&client
->dev
,
1068 if (!data
->dready_trig
)
1071 data
->motion_trig
= devm_iio_trigger_alloc(&client
->dev
,
1072 "%s-any-motion-dev%d",
1075 if (!data
->motion_trig
)
1078 data
->dready_trig
->dev
.parent
= &client
->dev
;
1079 data
->dready_trig
->ops
= &bmg160_trigger_ops
;
1080 iio_trigger_set_drvdata(data
->dready_trig
, indio_dev
);
1081 ret
= iio_trigger_register(data
->dready_trig
);
1085 data
->motion_trig
->dev
.parent
= &client
->dev
;
1086 data
->motion_trig
->ops
= &bmg160_trigger_ops
;
1087 iio_trigger_set_drvdata(data
->motion_trig
, indio_dev
);
1088 ret
= iio_trigger_register(data
->motion_trig
);
1090 data
->motion_trig
= NULL
;
1091 goto err_trigger_unregister
;
1094 ret
= iio_triggered_buffer_setup(indio_dev
,
1096 bmg160_trigger_handler
,
1099 dev_err(&client
->dev
,
1100 "iio triggered buffer setup failed\n");
1101 goto err_trigger_unregister
;
1105 ret
= iio_device_register(indio_dev
);
1107 dev_err(&client
->dev
, "unable to register iio device\n");
1108 goto err_buffer_cleanup
;
1111 ret
= pm_runtime_set_active(&client
->dev
);
1113 goto err_iio_unregister
;
1115 pm_runtime_enable(&client
->dev
);
1116 pm_runtime_set_autosuspend_delay(&client
->dev
,
1117 BMG160_AUTO_SUSPEND_DELAY_MS
);
1118 pm_runtime_use_autosuspend(&client
->dev
);
1123 iio_device_unregister(indio_dev
);
1125 if (data
->dready_trig
)
1126 iio_triggered_buffer_cleanup(indio_dev
);
1127 err_trigger_unregister
:
1128 if (data
->dready_trig
)
1129 iio_trigger_unregister(data
->dready_trig
);
1130 if (data
->motion_trig
)
1131 iio_trigger_unregister(data
->motion_trig
);
1136 static int bmg160_remove(struct i2c_client
*client
)
1138 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
1139 struct bmg160_data
*data
= iio_priv(indio_dev
);
1141 pm_runtime_disable(&client
->dev
);
1142 pm_runtime_set_suspended(&client
->dev
);
1143 pm_runtime_put_noidle(&client
->dev
);
1145 iio_device_unregister(indio_dev
);
1147 if (data
->dready_trig
) {
1148 iio_triggered_buffer_cleanup(indio_dev
);
1149 iio_trigger_unregister(data
->dready_trig
);
1150 iio_trigger_unregister(data
->motion_trig
);
1153 mutex_lock(&data
->mutex
);
1154 bmg160_set_mode(data
, BMG160_MODE_DEEP_SUSPEND
);
1155 mutex_unlock(&data
->mutex
);
1160 #ifdef CONFIG_PM_SLEEP
1161 static int bmg160_suspend(struct device
*dev
)
1163 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1164 struct bmg160_data
*data
= iio_priv(indio_dev
);
1166 mutex_lock(&data
->mutex
);
1167 bmg160_set_mode(data
, BMG160_MODE_SUSPEND
);
1168 mutex_unlock(&data
->mutex
);
1173 static int bmg160_resume(struct device
*dev
)
1175 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1176 struct bmg160_data
*data
= iio_priv(indio_dev
);
1178 mutex_lock(&data
->mutex
);
1179 if (data
->dready_trigger_on
|| data
->motion_trigger_on
||
1180 data
->ev_enable_state
)
1181 bmg160_set_mode(data
, BMG160_MODE_NORMAL
);
1182 mutex_unlock(&data
->mutex
);
1188 #ifdef CONFIG_PM_RUNTIME
1189 static int bmg160_runtime_suspend(struct device
*dev
)
1191 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1192 struct bmg160_data
*data
= iio_priv(indio_dev
);
1195 ret
= bmg160_set_mode(data
, BMG160_MODE_SUSPEND
);
1197 dev_err(&data
->client
->dev
, "set mode failed\n");
1204 static int bmg160_runtime_resume(struct device
*dev
)
1206 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1207 struct bmg160_data
*data
= iio_priv(indio_dev
);
1210 ret
= bmg160_set_mode(data
, BMG160_MODE_NORMAL
);
1214 msleep_interruptible(BMG160_MAX_STARTUP_TIME_MS
);
1220 static const struct dev_pm_ops bmg160_pm_ops
= {
1221 SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend
, bmg160_resume
)
1222 SET_RUNTIME_PM_OPS(bmg160_runtime_suspend
,
1223 bmg160_runtime_resume
, NULL
)
1226 static const struct acpi_device_id bmg160_acpi_match
[] = {
1232 MODULE_DEVICE_TABLE(acpi
, bmg160_acpi_match
);
1234 static const struct i2c_device_id bmg160_id
[] = {
1240 MODULE_DEVICE_TABLE(i2c
, bmg160_id
);
1242 static struct i2c_driver bmg160_driver
= {
1244 .name
= BMG160_DRV_NAME
,
1245 .acpi_match_table
= ACPI_PTR(bmg160_acpi_match
),
1246 .pm
= &bmg160_pm_ops
,
1248 .probe
= bmg160_probe
,
1249 .remove
= bmg160_remove
,
1250 .id_table
= bmg160_id
,
1252 module_i2c_driver(bmg160_driver
);
1254 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1255 MODULE_LICENSE("GPL v2");
1256 MODULE_DESCRIPTION("BMG160 Gyro driver");