2 * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
4 * Copyright (c) 2014, Intel Corporation.
6 * This file is subject to the terms and conditions of version 2 of
7 * the GNU General Public License. See the file COPYING in the main
8 * directory of this archive for more details.
10 * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
14 #include <linux/module.h>
15 #include <linux/i2c.h>
16 #include <linux/acpi.h>
17 #include <linux/gpio/consumer.h>
18 #include <linux/interrupt.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/iio/iio.h>
22 #include <linux/iio/sysfs.h>
23 #include <linux/iio/events.h>
24 #include <linux/iio/trigger.h>
25 #include <linux/iio/buffer.h>
26 #include <linux/iio/triggered_buffer.h>
27 #include <linux/iio/trigger_consumer.h>
29 #define KMX61_DRV_NAME "kmx61"
30 #define KMX61_GPIO_NAME "kmx61_int"
31 #define KMX61_IRQ_NAME "kmx61_event"
33 #define KMX61_REG_WHO_AM_I 0x00
34 #define KMX61_REG_INS1 0x01
35 #define KMX61_REG_INS2 0x02
38 * three 16-bit accelerometer output registers for X/Y/Z axis
39 * we use only XOUT_L as a base register, all other addresses
40 * can be obtained by applying an offset and are provided here
43 #define KMX61_ACC_XOUT_L 0x0A
44 #define KMX61_ACC_XOUT_H 0x0B
45 #define KMX61_ACC_YOUT_L 0x0C
46 #define KMX61_ACC_YOUT_H 0x0D
47 #define KMX61_ACC_ZOUT_L 0x0E
48 #define KMX61_ACC_ZOUT_H 0x0F
51 * one 16-bit temperature output register
53 #define KMX61_TEMP_L 0x10
54 #define KMX61_TEMP_H 0x11
57 * three 16-bit magnetometer output registers for X/Y/Z axis
59 #define KMX61_MAG_XOUT_L 0x12
60 #define KMX61_MAG_XOUT_H 0x13
61 #define KMX61_MAG_YOUT_L 0x14
62 #define KMX61_MAG_YOUT_H 0x15
63 #define KMX61_MAG_ZOUT_L 0x16
64 #define KMX61_MAG_ZOUT_H 0x17
66 #define KMX61_REG_INL 0x28
67 #define KMX61_REG_STBY 0x29
68 #define KMX61_REG_CTRL1 0x2A
69 #define KMX61_REG_CTRL2 0x2B
70 #define KMX61_REG_ODCNTL 0x2C
71 #define KMX61_REG_INC1 0x2D
73 #define KMX61_REG_WUF_THRESH 0x3D
74 #define KMX61_REG_WUF_TIMER 0x3E
76 #define KMX61_ACC_STBY_BIT BIT(0)
77 #define KMX61_MAG_STBY_BIT BIT(1)
78 #define KMX61_ACT_STBY_BIT BIT(7)
80 #define KMX61_ALL_STBY (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
82 #define KMX61_REG_INS1_BIT_WUFS BIT(1)
84 #define KMX61_REG_INS2_BIT_ZP BIT(0)
85 #define KMX61_REG_INS2_BIT_ZN BIT(1)
86 #define KMX61_REG_INS2_BIT_YP BIT(2)
87 #define KMX61_REG_INS2_BIT_YN BIT(3)
88 #define KMX61_REG_INS2_BIT_XP BIT(4)
89 #define KMX61_REG_INS2_BIT_XN BIT(5)
91 #define KMX61_REG_CTRL1_GSEL_MASK 0x03
93 #define KMX61_REG_CTRL1_BIT_RES BIT(4)
94 #define KMX61_REG_CTRL1_BIT_DRDYE BIT(5)
95 #define KMX61_REG_CTRL1_BIT_WUFE BIT(6)
96 #define KMX61_REG_CTRL1_BIT_BTSE BIT(7)
98 #define KMX61_REG_INC1_BIT_WUFS BIT(0)
99 #define KMX61_REG_INC1_BIT_DRDYM BIT(1)
100 #define KMX61_REG_INC1_BIT_DRDYA BIT(2)
101 #define KMX61_REG_INC1_BIT_IEN BIT(5)
103 #define KMX61_ACC_ODR_SHIFT 0
104 #define KMX61_MAG_ODR_SHIFT 4
105 #define KMX61_ACC_ODR_MASK 0x0F
106 #define KMX61_MAG_ODR_MASK 0xF0
108 #define KMX61_OWUF_MASK 0x7
110 #define KMX61_DEFAULT_WAKE_THRESH 1
111 #define KMX61_DEFAULT_WAKE_DURATION 1
113 #define KMX61_SLEEP_DELAY_MS 2000
115 #define KMX61_CHIP_ID 0x12
118 #define KMX61_ACC 0x01
119 #define KMX61_MAG 0x02
122 struct i2c_client *client;
124 /* serialize access to non-atomic ops, e.g set_mode */
141 /* accelerometer specific data */
142 struct iio_dev *acc_indio_dev;
143 struct iio_trigger *acc_dready_trig;
144 struct iio_trigger *motion_trig;
145 bool acc_dready_trig_on;
147 bool ev_enable_state;
149 /* magnetometer specific data */
150 struct iio_dev *mag_indio_dev;
151 struct iio_trigger *mag_dready_trig;
152 bool mag_dready_trig_on;
167 static const u16 kmx61_uscale_table[] = {9582, 19163, 38326};
169 static const struct {
172 } kmx61_samp_freq_table[] = { {12, 500000},
185 static const struct {
189 } kmx61_wake_up_odr_table[] = { {0, 781000, 0x00},
202 static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
203 static IIO_CONST_ATTR(magn_scale_available, "0.001465");
204 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
205 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
207 static struct attribute *kmx61_acc_attributes[] = {
208 &iio_const_attr_accel_scale_available.dev_attr.attr,
209 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
213 static struct attribute *kmx61_mag_attributes[] = {
214 &iio_const_attr_magn_scale_available.dev_attr.attr,
215 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
219 static const struct attribute_group kmx61_acc_attribute_group = {
220 .attrs = kmx61_acc_attributes,
223 static const struct attribute_group kmx61_mag_attribute_group = {
224 .attrs = kmx61_mag_attributes,
227 static const struct iio_event_spec kmx61_event = {
228 .type = IIO_EV_TYPE_THRESH,
229 .dir = IIO_EV_DIR_EITHER,
230 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
231 BIT(IIO_EV_INFO_ENABLE) |
232 BIT(IIO_EV_INFO_PERIOD),
235 #define KMX61_ACC_CHAN(_axis) { \
238 .channel2 = IIO_MOD_ ## _axis, \
239 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
240 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
241 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
242 .address = KMX61_ACC, \
243 .scan_index = KMX61_AXIS_ ## _axis, \
249 .endianness = IIO_LE, \
251 .event_spec = &kmx61_event, \
252 .num_event_specs = 1 \
255 #define KMX61_MAG_CHAN(_axis) { \
258 .channel2 = IIO_MOD_ ## _axis, \
259 .address = KMX61_MAG, \
260 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
261 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
262 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
263 .scan_index = KMX61_AXIS_ ## _axis, \
269 .endianness = IIO_LE, \
273 static const struct iio_chan_spec kmx61_acc_channels[] = {
279 static const struct iio_chan_spec kmx61_mag_channels[] = {
285 static void kmx61_set_data(struct iio_dev *indio_dev, struct kmx61_data *data)
287 struct kmx61_data **priv = iio_priv(indio_dev);
292 static struct kmx61_data *kmx61_get_data(struct iio_dev *indio_dev)
294 return *(struct kmx61_data **)iio_priv(indio_dev);
297 static int kmx61_convert_freq_to_bit(int val, int val2)
301 for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
302 if (val == kmx61_samp_freq_table[i].val &&
303 val2 == kmx61_samp_freq_table[i].val2)
308 static int kmx61_convert_wake_up_odr_to_bit(int val, int val2)
312 for (i = 0; i < ARRAY_SIZE(kmx61_wake_up_odr_table); ++i)
313 if (kmx61_wake_up_odr_table[i].val == val &&
314 kmx61_wake_up_odr_table[i].val2 == val2)
315 return kmx61_wake_up_odr_table[i].odr_bits;
320 * kmx61_set_mode() - set KMX61 device operating mode
321 * @data - kmx61 device private data pointer
322 * @mode - bitmask, indicating operating mode for @device
323 * @device - bitmask, indicating device for which @mode needs to be set
324 * @update - update stby bits stored in device's private @data
326 * For each sensor (accelerometer/magnetometer) there are two operating modes
327 * STANDBY and OPERATION. Neither accel nor magn can be disabled independently
328 * if they are both enabled. Internal sensors state is saved in acc_stby and
329 * mag_stby members of driver's private @data.
331 static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device,
335 int acc_stby = -1, mag_stby = -1;
337 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
339 dev_err(&data->client->dev, "Error reading reg_stby\n");
342 if (device & KMX61_ACC) {
343 if (mode & KMX61_ACC_STBY_BIT) {
344 ret |= KMX61_ACC_STBY_BIT;
347 ret &= ~KMX61_ACC_STBY_BIT;
352 if (device & KMX61_MAG) {
353 if (mode & KMX61_MAG_STBY_BIT) {
354 ret |= KMX61_MAG_STBY_BIT;
357 ret &= ~KMX61_MAG_STBY_BIT;
362 if (mode & KMX61_ACT_STBY_BIT)
363 ret |= KMX61_ACT_STBY_BIT;
365 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
367 dev_err(&data->client->dev, "Error writing reg_stby\n");
371 if (acc_stby != -1 && update)
372 data->acc_stby = acc_stby;
373 if (mag_stby != -1 && update)
374 data->mag_stby = mag_stby;
379 static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
383 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
385 dev_err(&data->client->dev, "Error reading reg_stby\n");
390 if (device & KMX61_ACC) {
391 if (ret & KMX61_ACC_STBY_BIT)
392 *mode |= KMX61_ACC_STBY_BIT;
394 *mode &= ~KMX61_ACC_STBY_BIT;
397 if (device & KMX61_MAG) {
398 if (ret & KMX61_MAG_STBY_BIT)
399 *mode |= KMX61_MAG_STBY_BIT;
401 *mode &= ~KMX61_MAG_STBY_BIT;
407 static int kmx61_set_wake_up_odr(struct kmx61_data *data, int val, int val2)
411 odr_bits = kmx61_convert_wake_up_odr_to_bit(val, val2);
415 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL2,
418 dev_err(&data->client->dev, "Error writing reg_ctrl2\n");
422 static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
426 int lodr_bits, odr_bits;
428 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
432 lodr_bits = kmx61_convert_freq_to_bit(val, val2);
436 /* To change ODR, accel and magn must be in STDBY */
437 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
443 if (device & KMX61_ACC)
444 odr_bits |= lodr_bits << KMX61_ACC_ODR_SHIFT;
445 if (device & KMX61_MAG)
446 odr_bits |= lodr_bits << KMX61_MAG_ODR_SHIFT;
448 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
453 data->odr_bits = odr_bits;
455 if (device & KMX61_ACC) {
456 ret = kmx61_set_wake_up_odr(data, val, val2);
461 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
464 static int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2,
469 if (device & KMX61_ACC)
470 lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
472 else if (device & KMX61_MAG)
473 lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
478 if (lodr_bits >= ARRAY_SIZE(kmx61_samp_freq_table))
481 *val = kmx61_samp_freq_table[lodr_bits].val;
482 *val2 = kmx61_samp_freq_table[lodr_bits].val2;
487 static int kmx61_set_range(struct kmx61_data *data, u8 range)
491 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
493 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
497 ret &= ~KMX61_REG_CTRL1_GSEL_MASK;
498 ret |= range & KMX61_REG_CTRL1_GSEL_MASK;
500 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
502 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
511 static int kmx61_set_scale(struct kmx61_data *data, u16 uscale)
516 for (i = 0; i < ARRAY_SIZE(kmx61_uscale_table); i++) {
517 if (kmx61_uscale_table[i] == uscale) {
518 ret = kmx61_get_mode(data, &mode,
519 KMX61_ACC | KMX61_MAG);
523 ret = kmx61_set_mode(data, KMX61_ALL_STBY,
524 KMX61_ACC | KMX61_MAG, true);
528 ret = kmx61_set_range(data, i);
532 return kmx61_set_mode(data, mode,
533 KMX61_ACC | KMX61_MAG, true);
539 static int kmx61_chip_init(struct kmx61_data *data)
543 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
545 dev_err(&data->client->dev, "Error reading who_am_i\n");
549 if (ret != KMX61_CHIP_ID) {
550 dev_err(&data->client->dev,
551 "Wrong chip id, got %x expected %x\n",
556 /* set accel 12bit, 4g range */
557 ret = kmx61_set_range(data, KMX61_RANGE_4G);
561 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_ODCNTL);
563 dev_err(&data->client->dev, "Error reading reg_odcntl\n");
566 data->odr_bits = ret;
569 * set output data rate for wake up (motion detection) function
570 * to match data rate for accelerometer sampling
572 ret = kmx61_get_odr(data, &val, &val2, KMX61_ACC);
576 ret = kmx61_set_wake_up_odr(data, val, val2);
580 /* set acc/magn to OPERATION mode */
581 ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG, true);
585 data->wake_thresh = KMX61_DEFAULT_WAKE_THRESH;
586 data->wake_duration = KMX61_DEFAULT_WAKE_DURATION;
591 static int kmx61_setup_new_data_interrupt(struct kmx61_data *data,
592 bool status, u8 device)
597 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
601 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
605 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1);
607 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
612 ret |= KMX61_REG_INC1_BIT_IEN;
613 if (device & KMX61_ACC)
614 ret |= KMX61_REG_INC1_BIT_DRDYA;
615 if (device & KMX61_MAG)
616 ret |= KMX61_REG_INC1_BIT_DRDYM;
618 ret &= ~KMX61_REG_INC1_BIT_IEN;
619 if (device & KMX61_ACC)
620 ret &= ~KMX61_REG_INC1_BIT_DRDYA;
621 if (device & KMX61_MAG)
622 ret &= ~KMX61_REG_INC1_BIT_DRDYM;
624 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret);
626 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
630 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
632 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
637 ret |= KMX61_REG_CTRL1_BIT_DRDYE;
639 ret &= ~KMX61_REG_CTRL1_BIT_DRDYE;
641 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
643 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
647 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
650 static int kmx61_chip_update_thresholds(struct kmx61_data *data)
654 ret = i2c_smbus_write_byte_data(data->client,
656 data->wake_duration);
658 dev_err(&data->client->dev, "Errow writing reg_wuf_timer\n");
662 ret = i2c_smbus_write_byte_data(data->client,
663 KMX61_REG_WUF_THRESH,
666 dev_err(&data->client->dev, "Error writing reg_wuf_thresh\n");
671 static int kmx61_setup_any_motion_interrupt(struct kmx61_data *data,
677 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
681 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
685 ret = kmx61_chip_update_thresholds(data);
689 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1);
691 dev_err(&data->client->dev, "Error reading reg_inc1\n");
695 ret |= (KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS);
697 ret &= ~(KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS);
699 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret);
701 dev_err(&data->client->dev, "Error writing reg_inc1\n");
705 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
707 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
712 ret |= KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE;
714 ret &= ~(KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE);
716 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
718 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
721 mode |= KMX61_ACT_STBY_BIT;
722 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
726 * kmx61_set_power_state() - set power state for kmx61 @device
727 * @data - kmx61 device private pointer
728 * @on - power state to be set for @device
729 * @device - bitmask indicating device for which @on state needs to be set
731 * Notice that when ACC power state needs to be set to ON and MAG is in
732 * OPERATION then we know that kmx61_runtime_resume was already called
733 * so we must set ACC OPERATION mode here. The same happens when MAG power
734 * state needs to be set to ON and ACC is in OPERATION.
736 static int kmx61_set_power_state(struct kmx61_data *data, bool on, u8 device)
741 if (device & KMX61_ACC) {
742 if (on && !data->acc_ps && !data->mag_stby) {
743 ret = kmx61_set_mode(data, 0, KMX61_ACC, true);
749 if (device & KMX61_MAG) {
750 if (on && !data->mag_ps && !data->acc_stby) {
751 ret = kmx61_set_mode(data, 0, KMX61_MAG, true);
759 ret = pm_runtime_get_sync(&data->client->dev);
761 pm_runtime_mark_last_busy(&data->client->dev);
762 ret = pm_runtime_put_autosuspend(&data->client->dev);
765 dev_err(&data->client->dev,
766 "Failed: kmx61_set_power_state for %d, ret %d\n",
769 pm_runtime_put_noidle(&data->client->dev);
777 static int kmx61_read_measurement(struct kmx61_data *data, u8 base, u8 offset)
780 u8 reg = base + offset * 2;
782 ret = i2c_smbus_read_word_data(data->client, reg);
784 dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
789 static int kmx61_read_raw(struct iio_dev *indio_dev,
790 struct iio_chan_spec const *chan, int *val,
791 int *val2, long mask)
795 struct kmx61_data *data = kmx61_get_data(indio_dev);
798 case IIO_CHAN_INFO_RAW:
799 switch (chan->type) {
801 base_reg = KMX61_ACC_XOUT_L;
804 base_reg = KMX61_MAG_XOUT_L;
809 mutex_lock(&data->lock);
811 ret = kmx61_set_power_state(data, true, chan->address);
813 mutex_unlock(&data->lock);
817 ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
819 kmx61_set_power_state(data, false, chan->address);
820 mutex_unlock(&data->lock);
823 *val = sign_extend32(ret >> chan->scan_type.shift,
824 chan->scan_type.realbits - 1);
825 ret = kmx61_set_power_state(data, false, chan->address);
827 mutex_unlock(&data->lock);
831 case IIO_CHAN_INFO_SCALE:
832 switch (chan->type) {
835 *val2 = kmx61_uscale_table[data->range];
836 return IIO_VAL_INT_PLUS_MICRO;
838 /* 14 bits res, 1465 microGauss per magn count */
841 return IIO_VAL_INT_PLUS_MICRO;
845 case IIO_CHAN_INFO_SAMP_FREQ:
846 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
849 mutex_lock(&data->lock);
850 ret = kmx61_get_odr(data, val, val2, chan->address);
851 mutex_unlock(&data->lock);
854 return IIO_VAL_INT_PLUS_MICRO;
859 static int kmx61_write_raw(struct iio_dev *indio_dev,
860 struct iio_chan_spec const *chan, int val,
864 struct kmx61_data *data = kmx61_get_data(indio_dev);
867 case IIO_CHAN_INFO_SAMP_FREQ:
868 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
871 mutex_lock(&data->lock);
872 ret = kmx61_set_odr(data, val, val2, chan->address);
873 mutex_unlock(&data->lock);
875 case IIO_CHAN_INFO_SCALE:
876 switch (chan->type) {
880 mutex_lock(&data->lock);
881 ret = kmx61_set_scale(data, val2);
882 mutex_unlock(&data->lock);
892 static int kmx61_read_event(struct iio_dev *indio_dev,
893 const struct iio_chan_spec *chan,
894 enum iio_event_type type,
895 enum iio_event_direction dir,
896 enum iio_event_info info,
899 struct kmx61_data *data = kmx61_get_data(indio_dev);
903 case IIO_EV_INFO_VALUE:
904 *val = data->wake_thresh;
906 case IIO_EV_INFO_PERIOD:
907 *val = data->wake_duration;
914 static int kmx61_write_event(struct iio_dev *indio_dev,
915 const struct iio_chan_spec *chan,
916 enum iio_event_type type,
917 enum iio_event_direction dir,
918 enum iio_event_info info,
921 struct kmx61_data *data = kmx61_get_data(indio_dev);
923 if (data->ev_enable_state)
927 case IIO_EV_INFO_VALUE:
928 data->wake_thresh = val;
930 case IIO_EV_INFO_PERIOD:
931 data->wake_duration = val;
938 static int kmx61_read_event_config(struct iio_dev *indio_dev,
939 const struct iio_chan_spec *chan,
940 enum iio_event_type type,
941 enum iio_event_direction dir)
943 struct kmx61_data *data = kmx61_get_data(indio_dev);
945 return data->ev_enable_state;
948 static int kmx61_write_event_config(struct iio_dev *indio_dev,
949 const struct iio_chan_spec *chan,
950 enum iio_event_type type,
951 enum iio_event_direction dir,
954 struct kmx61_data *data = kmx61_get_data(indio_dev);
957 if (state && data->ev_enable_state)
960 mutex_lock(&data->lock);
962 if (!state && data->motion_trig_on) {
963 data->ev_enable_state = false;
967 ret = kmx61_set_power_state(data, state, KMX61_ACC);
971 ret = kmx61_setup_any_motion_interrupt(data, state);
973 kmx61_set_power_state(data, false, KMX61_ACC);
977 data->ev_enable_state = state;
980 mutex_unlock(&data->lock);
985 static int kmx61_acc_validate_trigger(struct iio_dev *indio_dev,
986 struct iio_trigger *trig)
988 struct kmx61_data *data = kmx61_get_data(indio_dev);
990 if (data->acc_dready_trig != trig && data->motion_trig != trig)
996 static int kmx61_mag_validate_trigger(struct iio_dev *indio_dev,
997 struct iio_trigger *trig)
999 struct kmx61_data *data = kmx61_get_data(indio_dev);
1001 if (data->mag_dready_trig != trig)
1007 static const struct iio_info kmx61_acc_info = {
1008 .driver_module = THIS_MODULE,
1009 .read_raw = kmx61_read_raw,
1010 .write_raw = kmx61_write_raw,
1011 .attrs = &kmx61_acc_attribute_group,
1012 .read_event_value = kmx61_read_event,
1013 .write_event_value = kmx61_write_event,
1014 .read_event_config = kmx61_read_event_config,
1015 .write_event_config = kmx61_write_event_config,
1016 .validate_trigger = kmx61_acc_validate_trigger,
1019 static const struct iio_info kmx61_mag_info = {
1020 .driver_module = THIS_MODULE,
1021 .read_raw = kmx61_read_raw,
1022 .write_raw = kmx61_write_raw,
1023 .attrs = &kmx61_mag_attribute_group,
1024 .validate_trigger = kmx61_mag_validate_trigger,
1028 static int kmx61_data_rdy_trigger_set_state(struct iio_trigger *trig,
1034 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1035 struct kmx61_data *data = kmx61_get_data(indio_dev);
1037 mutex_lock(&data->lock);
1039 if (!state && data->ev_enable_state && data->motion_trig_on) {
1040 data->motion_trig_on = false;
1044 if (data->acc_dready_trig == trig || data->motion_trig == trig)
1049 ret = kmx61_set_power_state(data, state, device);
1053 if (data->acc_dready_trig == trig || data->mag_dready_trig == trig)
1054 ret = kmx61_setup_new_data_interrupt(data, state, device);
1056 ret = kmx61_setup_any_motion_interrupt(data, state);
1058 kmx61_set_power_state(data, false, device);
1062 if (data->acc_dready_trig == trig)
1063 data->acc_dready_trig_on = state;
1064 else if (data->mag_dready_trig == trig)
1065 data->mag_dready_trig_on = state;
1067 data->motion_trig_on = state;
1069 mutex_unlock(&data->lock);
1074 static int kmx61_trig_try_reenable(struct iio_trigger *trig)
1076 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1077 struct kmx61_data *data = kmx61_get_data(indio_dev);
1080 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1082 dev_err(&data->client->dev, "Error reading reg_inl\n");
1089 static const struct iio_trigger_ops kmx61_trigger_ops = {
1090 .set_trigger_state = kmx61_data_rdy_trigger_set_state,
1091 .try_reenable = kmx61_trig_try_reenable,
1092 .owner = THIS_MODULE,
1095 static irqreturn_t kmx61_event_handler(int irq, void *private)
1097 struct kmx61_data *data = private;
1098 struct iio_dev *indio_dev = data->acc_indio_dev;
1101 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS1);
1103 dev_err(&data->client->dev, "Error reading reg_ins1\n");
1107 if (ret & KMX61_REG_INS1_BIT_WUFS) {
1108 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS2);
1110 dev_err(&data->client->dev, "Error reading reg_ins2\n");
1114 if (ret & KMX61_REG_INS2_BIT_XN)
1115 iio_push_event(indio_dev,
1116 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1120 IIO_EV_DIR_FALLING),
1123 if (ret & KMX61_REG_INS2_BIT_XP)
1124 iio_push_event(indio_dev,
1125 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1132 if (ret & KMX61_REG_INS2_BIT_YN)
1133 iio_push_event(indio_dev,
1134 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1138 IIO_EV_DIR_FALLING),
1141 if (ret & KMX61_REG_INS2_BIT_YP)
1142 iio_push_event(indio_dev,
1143 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1150 if (ret & KMX61_REG_INS2_BIT_ZN)
1151 iio_push_event(indio_dev,
1152 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1156 IIO_EV_DIR_FALLING),
1159 if (ret & KMX61_REG_INS2_BIT_ZP)
1160 iio_push_event(indio_dev,
1161 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1170 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
1172 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
1174 ret |= KMX61_REG_CTRL1_BIT_RES;
1175 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
1177 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
1179 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1181 dev_err(&data->client->dev, "Error reading reg_inl\n");
1186 static irqreturn_t kmx61_data_rdy_trig_poll(int irq, void *private)
1188 struct kmx61_data *data = private;
1190 if (data->acc_dready_trig_on)
1191 iio_trigger_poll(data->acc_dready_trig);
1192 if (data->mag_dready_trig_on)
1193 iio_trigger_poll(data->mag_dready_trig);
1195 if (data->motion_trig_on)
1196 iio_trigger_poll(data->motion_trig);
1198 if (data->ev_enable_state)
1199 return IRQ_WAKE_THREAD;
1203 static irqreturn_t kmx61_trigger_handler(int irq, void *p)
1205 struct iio_poll_func *pf = p;
1206 struct iio_dev *indio_dev = pf->indio_dev;
1207 struct kmx61_data *data = kmx61_get_data(indio_dev);
1208 int bit, ret, i = 0;
1212 if (indio_dev == data->acc_indio_dev)
1213 base = KMX61_ACC_XOUT_L;
1215 base = KMX61_MAG_XOUT_L;
1217 mutex_lock(&data->lock);
1218 for_each_set_bit(bit, indio_dev->active_scan_mask,
1219 indio_dev->masklength) {
1220 ret = kmx61_read_measurement(data, base, bit);
1222 mutex_unlock(&data->lock);
1227 mutex_unlock(&data->lock);
1229 iio_push_to_buffers(indio_dev, buffer);
1231 iio_trigger_notify_done(indio_dev->trig);
1236 static const char *kmx61_match_acpi_device(struct device *dev)
1238 const struct acpi_device_id *id;
1240 id = acpi_match_device(dev->driver->acpi_match_table, dev);
1243 return dev_name(dev);
1246 static int kmx61_gpio_probe(struct i2c_client *client, struct kmx61_data *data)
1249 struct gpio_desc *gpio;
1257 /* data ready gpio interrupt pin */
1258 gpio = devm_gpiod_get_index(dev, KMX61_GPIO_NAME, 0, GPIOD_IN);
1260 dev_err(dev, "acpi gpio get index failed\n");
1261 return PTR_ERR(gpio);
1264 ret = gpiod_to_irq(gpio);
1266 dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
1270 static struct iio_dev *kmx61_indiodev_setup(struct kmx61_data *data,
1271 const struct iio_info *info,
1272 const struct iio_chan_spec *chan,
1276 struct iio_dev *indio_dev;
1278 indio_dev = devm_iio_device_alloc(&data->client->dev, sizeof(data));
1280 return ERR_PTR(-ENOMEM);
1282 kmx61_set_data(indio_dev, data);
1284 indio_dev->dev.parent = &data->client->dev;
1285 indio_dev->channels = chan;
1286 indio_dev->num_channels = num_channels;
1287 indio_dev->name = name;
1288 indio_dev->modes = INDIO_DIRECT_MODE;
1289 indio_dev->info = info;
1294 static struct iio_trigger *kmx61_trigger_setup(struct kmx61_data *data,
1295 struct iio_dev *indio_dev,
1298 struct iio_trigger *trig;
1301 trig = devm_iio_trigger_alloc(&data->client->dev,
1307 return ERR_PTR(-ENOMEM);
1309 trig->dev.parent = &data->client->dev;
1310 trig->ops = &kmx61_trigger_ops;
1311 iio_trigger_set_drvdata(trig, indio_dev);
1313 ret = iio_trigger_register(trig);
1315 return ERR_PTR(ret);
1320 static int kmx61_probe(struct i2c_client *client,
1321 const struct i2c_device_id *id)
1324 struct kmx61_data *data;
1325 const char *name = NULL;
1327 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1331 i2c_set_clientdata(client, data);
1332 data->client = client;
1334 mutex_init(&data->lock);
1338 else if (ACPI_HANDLE(&client->dev))
1339 name = kmx61_match_acpi_device(&client->dev);
1343 data->acc_indio_dev =
1344 kmx61_indiodev_setup(data, &kmx61_acc_info,
1346 ARRAY_SIZE(kmx61_acc_channels),
1348 if (IS_ERR(data->acc_indio_dev))
1349 return PTR_ERR(data->acc_indio_dev);
1351 data->mag_indio_dev =
1352 kmx61_indiodev_setup(data, &kmx61_mag_info,
1354 ARRAY_SIZE(kmx61_mag_channels),
1356 if (IS_ERR(data->mag_indio_dev))
1357 return PTR_ERR(data->mag_indio_dev);
1359 ret = kmx61_chip_init(data);
1363 if (client->irq < 0)
1364 client->irq = kmx61_gpio_probe(client, data);
1366 if (client->irq > 0) {
1367 ret = devm_request_threaded_irq(&client->dev, client->irq,
1368 kmx61_data_rdy_trig_poll,
1369 kmx61_event_handler,
1370 IRQF_TRIGGER_RISING,
1374 goto err_chip_uninit;
1376 data->acc_dready_trig =
1377 kmx61_trigger_setup(data, data->acc_indio_dev,
1379 if (IS_ERR(data->acc_dready_trig)) {
1380 ret = PTR_ERR(data->acc_dready_trig);
1381 goto err_chip_uninit;
1384 data->mag_dready_trig =
1385 kmx61_trigger_setup(data, data->mag_indio_dev,
1387 if (IS_ERR(data->mag_dready_trig)) {
1388 ret = PTR_ERR(data->mag_dready_trig);
1389 goto err_trigger_unregister_acc_dready;
1393 kmx61_trigger_setup(data, data->acc_indio_dev,
1395 if (IS_ERR(data->motion_trig)) {
1396 ret = PTR_ERR(data->motion_trig);
1397 goto err_trigger_unregister_mag_dready;
1400 ret = iio_triggered_buffer_setup(data->acc_indio_dev,
1401 &iio_pollfunc_store_time,
1402 kmx61_trigger_handler,
1405 dev_err(&data->client->dev,
1406 "Failed to setup acc triggered buffer\n");
1407 goto err_trigger_unregister_motion;
1410 ret = iio_triggered_buffer_setup(data->mag_indio_dev,
1411 &iio_pollfunc_store_time,
1412 kmx61_trigger_handler,
1415 dev_err(&data->client->dev,
1416 "Failed to setup mag triggered buffer\n");
1417 goto err_buffer_cleanup_acc;
1421 ret = iio_device_register(data->acc_indio_dev);
1423 dev_err(&client->dev, "Failed to register acc iio device\n");
1424 goto err_buffer_cleanup_mag;
1427 ret = iio_device_register(data->mag_indio_dev);
1429 dev_err(&client->dev, "Failed to register mag iio device\n");
1430 goto err_iio_unregister_acc;
1433 ret = pm_runtime_set_active(&client->dev);
1435 goto err_iio_unregister_mag;
1437 pm_runtime_enable(&client->dev);
1438 pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS);
1439 pm_runtime_use_autosuspend(&client->dev);
1443 err_iio_unregister_mag:
1444 iio_device_unregister(data->mag_indio_dev);
1445 err_iio_unregister_acc:
1446 iio_device_unregister(data->acc_indio_dev);
1447 err_buffer_cleanup_mag:
1448 if (client->irq > 0)
1449 iio_triggered_buffer_cleanup(data->mag_indio_dev);
1450 err_buffer_cleanup_acc:
1451 if (client->irq > 0)
1452 iio_triggered_buffer_cleanup(data->acc_indio_dev);
1453 err_trigger_unregister_motion:
1454 iio_trigger_unregister(data->motion_trig);
1455 err_trigger_unregister_mag_dready:
1456 iio_trigger_unregister(data->mag_dready_trig);
1457 err_trigger_unregister_acc_dready:
1458 iio_trigger_unregister(data->acc_dready_trig);
1460 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1464 static int kmx61_remove(struct i2c_client *client)
1466 struct kmx61_data *data = i2c_get_clientdata(client);
1468 pm_runtime_disable(&client->dev);
1469 pm_runtime_set_suspended(&client->dev);
1470 pm_runtime_put_noidle(&client->dev);
1472 iio_device_unregister(data->acc_indio_dev);
1473 iio_device_unregister(data->mag_indio_dev);
1475 if (client->irq > 0) {
1476 iio_triggered_buffer_cleanup(data->acc_indio_dev);
1477 iio_triggered_buffer_cleanup(data->mag_indio_dev);
1478 iio_trigger_unregister(data->acc_dready_trig);
1479 iio_trigger_unregister(data->mag_dready_trig);
1480 iio_trigger_unregister(data->motion_trig);
1483 mutex_lock(&data->lock);
1484 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1485 mutex_unlock(&data->lock);
1490 #ifdef CONFIG_PM_SLEEP
1491 static int kmx61_suspend(struct device *dev)
1494 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1496 mutex_lock(&data->lock);
1497 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
1499 mutex_unlock(&data->lock);
1504 static int kmx61_resume(struct device *dev)
1507 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1510 stby |= KMX61_ACC_STBY_BIT;
1512 stby |= KMX61_MAG_STBY_BIT;
1514 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1519 static int kmx61_runtime_suspend(struct device *dev)
1521 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1524 mutex_lock(&data->lock);
1525 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1526 mutex_unlock(&data->lock);
1531 static int kmx61_runtime_resume(struct device *dev)
1533 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1537 stby |= KMX61_ACC_STBY_BIT;
1539 stby |= KMX61_MAG_STBY_BIT;
1541 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1545 static const struct dev_pm_ops kmx61_pm_ops = {
1546 SET_SYSTEM_SLEEP_PM_OPS(kmx61_suspend, kmx61_resume)
1547 SET_RUNTIME_PM_OPS(kmx61_runtime_suspend, kmx61_runtime_resume, NULL)
1550 static const struct acpi_device_id kmx61_acpi_match[] = {
1555 MODULE_DEVICE_TABLE(acpi, kmx61_acpi_match);
1557 static const struct i2c_device_id kmx61_id[] = {
1562 MODULE_DEVICE_TABLE(i2c, kmx61_id);
1564 static struct i2c_driver kmx61_driver = {
1566 .name = KMX61_DRV_NAME,
1567 .acpi_match_table = ACPI_PTR(kmx61_acpi_match),
1568 .pm = &kmx61_pm_ops,
1570 .probe = kmx61_probe,
1571 .remove = kmx61_remove,
1572 .id_table = kmx61_id,
1575 module_i2c_driver(kmx61_driver);
1577 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
1578 MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
1579 MODULE_LICENSE("GPL v2");