2 * KXCJK-1013 3-axis accelerometer 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/bitops.h>
20 #include <linux/slab.h>
21 #include <linux/string.h>
22 #include <linux/acpi.h>
23 #include <linux/gpio/consumer.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/iio/iio.h>
27 #include <linux/iio/sysfs.h>
28 #include <linux/iio/buffer.h>
29 #include <linux/iio/trigger.h>
30 #include <linux/iio/events.h>
31 #include <linux/iio/trigger_consumer.h>
32 #include <linux/iio/triggered_buffer.h>
33 #include <linux/iio/accel/kxcjk_1013.h>
35 #define KXCJK1013_DRV_NAME "kxcjk1013"
36 #define KXCJK1013_IRQ_NAME "kxcjk1013_event"
38 #define KXCJK1013_REG_XOUT_L 0x06
40 * From low byte X axis register, all the other addresses of Y and Z can be
41 * obtained by just applying axis offset. The following axis defines are just
42 * provide clarity, but not used.
44 #define KXCJK1013_REG_XOUT_H 0x07
45 #define KXCJK1013_REG_YOUT_L 0x08
46 #define KXCJK1013_REG_YOUT_H 0x09
47 #define KXCJK1013_REG_ZOUT_L 0x0A
48 #define KXCJK1013_REG_ZOUT_H 0x0B
50 #define KXCJK1013_REG_DCST_RESP 0x0C
51 #define KXCJK1013_REG_WHO_AM_I 0x0F
52 #define KXCJK1013_REG_INT_SRC1 0x16
53 #define KXCJK1013_REG_INT_SRC2 0x17
54 #define KXCJK1013_REG_STATUS_REG 0x18
55 #define KXCJK1013_REG_INT_REL 0x1A
56 #define KXCJK1013_REG_CTRL1 0x1B
57 #define KXCJK1013_REG_CTRL2 0x1D
58 #define KXCJK1013_REG_INT_CTRL1 0x1E
59 #define KXCJK1013_REG_INT_CTRL2 0x1F
60 #define KXCJK1013_REG_DATA_CTRL 0x21
61 #define KXCJK1013_REG_WAKE_TIMER 0x29
62 #define KXCJK1013_REG_SELF_TEST 0x3A
63 #define KXCJK1013_REG_WAKE_THRES 0x6A
65 #define KXCJK1013_REG_CTRL1_BIT_PC1 BIT(7)
66 #define KXCJK1013_REG_CTRL1_BIT_RES BIT(6)
67 #define KXCJK1013_REG_CTRL1_BIT_DRDY BIT(5)
68 #define KXCJK1013_REG_CTRL1_BIT_GSEL1 BIT(4)
69 #define KXCJK1013_REG_CTRL1_BIT_GSEL0 BIT(3)
70 #define KXCJK1013_REG_CTRL1_BIT_WUFE BIT(1)
71 #define KXCJK1013_REG_INT_REG1_BIT_IEA BIT(4)
72 #define KXCJK1013_REG_INT_REG1_BIT_IEN BIT(5)
74 #define KXCJK1013_DATA_MASK_12_BIT 0x0FFF
75 #define KXCJK1013_MAX_STARTUP_TIME_US 100000
77 #define KXCJK1013_SLEEP_DELAY_MS 2000
79 #define KXCJK1013_REG_INT_SRC2_BIT_ZP BIT(0)
80 #define KXCJK1013_REG_INT_SRC2_BIT_ZN BIT(1)
81 #define KXCJK1013_REG_INT_SRC2_BIT_YP BIT(2)
82 #define KXCJK1013_REG_INT_SRC2_BIT_YN BIT(3)
83 #define KXCJK1013_REG_INT_SRC2_BIT_XP BIT(4)
84 #define KXCJK1013_REG_INT_SRC2_BIT_XN BIT(5)
86 #define KXCJK1013_DEFAULT_WAKE_THRES 1
92 KX_MAX_CHIPS
/* this must be last */
95 struct kxcjk1013_data
{
96 struct i2c_client
*client
;
97 struct iio_trigger
*dready_trig
;
98 struct iio_trigger
*motion_trig
;
105 bool active_high_intr
;
106 bool dready_trigger_on
;
108 bool motion_trigger_on
;
110 enum kx_chipset chipset
;
113 enum kxcjk1013_axis
{
119 enum kxcjk1013_mode
{
124 enum kxcjk1013_range
{
130 static const struct {
134 } samp_freq_table
[] = { {0, 781000, 0x08}, {1, 563000, 0x09},
135 {3, 125000, 0x0A}, {6, 250000, 0x0B}, {12, 500000, 0},
136 {25, 0, 0x01}, {50, 0, 0x02}, {100, 0, 0x03},
137 {200, 0, 0x04}, {400, 0, 0x05}, {800, 0, 0x06},
140 /* Refer to section 4 of the specification */
141 static const struct {
144 } odr_start_up_times
[KX_MAX_CHIPS
][12] = {
192 static const struct {
196 } KXCJK1013_scale_table
[] = { {9582, 0, 0},
200 static const struct {
204 } wake_odr_data_rate_table
[] = { {0, 781000, 0x00},
217 static int kxcjk1013_set_mode(struct kxcjk1013_data
*data
,
218 enum kxcjk1013_mode mode
)
222 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_CTRL1
);
224 dev_err(&data
->client
->dev
, "Error reading reg_ctrl1\n");
229 ret
&= ~KXCJK1013_REG_CTRL1_BIT_PC1
;
231 ret
|= KXCJK1013_REG_CTRL1_BIT_PC1
;
233 ret
= i2c_smbus_write_byte_data(data
->client
,
234 KXCJK1013_REG_CTRL1
, ret
);
236 dev_err(&data
->client
->dev
, "Error writing reg_ctrl1\n");
243 static int kxcjk1013_get_mode(struct kxcjk1013_data
*data
,
244 enum kxcjk1013_mode
*mode
)
248 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_CTRL1
);
250 dev_err(&data
->client
->dev
, "Error reading reg_ctrl1\n");
254 if (ret
& KXCJK1013_REG_CTRL1_BIT_PC1
)
262 static int kxcjk1013_set_range(struct kxcjk1013_data
*data
, int range_index
)
266 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_CTRL1
);
268 dev_err(&data
->client
->dev
, "Error reading reg_ctrl1\n");
272 ret
|= (KXCJK1013_scale_table
[range_index
].gsel_0
<< 3);
273 ret
|= (KXCJK1013_scale_table
[range_index
].gsel_1
<< 4);
275 ret
= i2c_smbus_write_byte_data(data
->client
,
279 dev_err(&data
->client
->dev
, "Error writing reg_ctrl1\n");
283 data
->range
= range_index
;
288 static int kxcjk1013_chip_init(struct kxcjk1013_data
*data
)
292 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_WHO_AM_I
);
294 dev_err(&data
->client
->dev
, "Error reading who_am_i\n");
298 dev_dbg(&data
->client
->dev
, "KXCJK1013 Chip Id %x\n", ret
);
300 ret
= kxcjk1013_set_mode(data
, STANDBY
);
304 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_CTRL1
);
306 dev_err(&data
->client
->dev
, "Error reading reg_ctrl1\n");
310 /* Set 12 bit mode */
311 ret
|= KXCJK1013_REG_CTRL1_BIT_RES
;
313 ret
= i2c_smbus_write_byte_data(data
->client
, KXCJK1013_REG_CTRL1
,
316 dev_err(&data
->client
->dev
, "Error reading reg_ctrl\n");
320 /* Setting range to 4G */
321 ret
= kxcjk1013_set_range(data
, KXCJK1013_RANGE_4G
);
325 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_DATA_CTRL
);
327 dev_err(&data
->client
->dev
, "Error reading reg_data_ctrl\n");
331 data
->odr_bits
= ret
;
333 /* Set up INT polarity */
334 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_INT_CTRL1
);
336 dev_err(&data
->client
->dev
, "Error reading reg_int_ctrl1\n");
340 if (data
->active_high_intr
)
341 ret
|= KXCJK1013_REG_INT_REG1_BIT_IEA
;
343 ret
&= ~KXCJK1013_REG_INT_REG1_BIT_IEA
;
345 ret
= i2c_smbus_write_byte_data(data
->client
, KXCJK1013_REG_INT_CTRL1
,
348 dev_err(&data
->client
->dev
, "Error writing reg_int_ctrl1\n");
352 ret
= kxcjk1013_set_mode(data
, OPERATION
);
356 data
->wake_thres
= KXCJK1013_DEFAULT_WAKE_THRES
;
361 #ifdef CONFIG_PM_RUNTIME
362 static int kxcjk1013_get_startup_times(struct kxcjk1013_data
*data
)
365 int idx
= data
->chipset
;
367 for (i
= 0; i
< ARRAY_SIZE(odr_start_up_times
[idx
]); ++i
) {
368 if (odr_start_up_times
[idx
][i
].odr_bits
== data
->odr_bits
)
369 return odr_start_up_times
[idx
][i
].usec
;
372 return KXCJK1013_MAX_STARTUP_TIME_US
;
376 static int kxcjk1013_set_power_state(struct kxcjk1013_data
*data
, bool on
)
381 ret
= pm_runtime_get_sync(&data
->client
->dev
);
383 pm_runtime_mark_last_busy(&data
->client
->dev
);
384 ret
= pm_runtime_put_autosuspend(&data
->client
->dev
);
387 dev_err(&data
->client
->dev
,
388 "Failed: kxcjk1013_set_power_state for %d\n", on
);
395 static int kxcjk1013_chip_update_thresholds(struct kxcjk1013_data
*data
)
399 ret
= i2c_smbus_write_byte_data(data
->client
,
400 KXCJK1013_REG_WAKE_TIMER
,
403 dev_err(&data
->client
->dev
,
404 "Error writing reg_wake_timer\n");
408 ret
= i2c_smbus_write_byte_data(data
->client
,
409 KXCJK1013_REG_WAKE_THRES
,
412 dev_err(&data
->client
->dev
, "Error writing reg_wake_thres\n");
419 static int kxcjk1013_setup_any_motion_interrupt(struct kxcjk1013_data
*data
,
423 enum kxcjk1013_mode store_mode
;
425 ret
= kxcjk1013_get_mode(data
, &store_mode
);
429 /* This is requirement by spec to change state to STANDBY */
430 ret
= kxcjk1013_set_mode(data
, STANDBY
);
434 ret
= kxcjk1013_chip_update_thresholds(data
);
438 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_INT_CTRL1
);
440 dev_err(&data
->client
->dev
, "Error reading reg_int_ctrl1\n");
445 ret
|= KXCJK1013_REG_INT_REG1_BIT_IEN
;
447 ret
&= ~KXCJK1013_REG_INT_REG1_BIT_IEN
;
449 ret
= i2c_smbus_write_byte_data(data
->client
, KXCJK1013_REG_INT_CTRL1
,
452 dev_err(&data
->client
->dev
, "Error writing reg_int_ctrl1\n");
456 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_CTRL1
);
458 dev_err(&data
->client
->dev
, "Error reading reg_ctrl1\n");
463 ret
|= KXCJK1013_REG_CTRL1_BIT_WUFE
;
465 ret
&= ~KXCJK1013_REG_CTRL1_BIT_WUFE
;
467 ret
= i2c_smbus_write_byte_data(data
->client
,
468 KXCJK1013_REG_CTRL1
, ret
);
470 dev_err(&data
->client
->dev
, "Error writing reg_ctrl1\n");
474 if (store_mode
== OPERATION
) {
475 ret
= kxcjk1013_set_mode(data
, OPERATION
);
483 static int kxcjk1013_setup_new_data_interrupt(struct kxcjk1013_data
*data
,
487 enum kxcjk1013_mode store_mode
;
489 ret
= kxcjk1013_get_mode(data
, &store_mode
);
493 /* This is requirement by spec to change state to STANDBY */
494 ret
= kxcjk1013_set_mode(data
, STANDBY
);
498 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_INT_CTRL1
);
500 dev_err(&data
->client
->dev
, "Error reading reg_int_ctrl1\n");
505 ret
|= KXCJK1013_REG_INT_REG1_BIT_IEN
;
507 ret
&= ~KXCJK1013_REG_INT_REG1_BIT_IEN
;
509 ret
= i2c_smbus_write_byte_data(data
->client
, KXCJK1013_REG_INT_CTRL1
,
512 dev_err(&data
->client
->dev
, "Error writing reg_int_ctrl1\n");
516 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_CTRL1
);
518 dev_err(&data
->client
->dev
, "Error reading reg_ctrl1\n");
523 ret
|= KXCJK1013_REG_CTRL1_BIT_DRDY
;
525 ret
&= ~KXCJK1013_REG_CTRL1_BIT_DRDY
;
527 ret
= i2c_smbus_write_byte_data(data
->client
,
528 KXCJK1013_REG_CTRL1
, ret
);
530 dev_err(&data
->client
->dev
, "Error writing reg_ctrl1\n");
534 if (store_mode
== OPERATION
) {
535 ret
= kxcjk1013_set_mode(data
, OPERATION
);
543 static int kxcjk1013_convert_freq_to_bit(int val
, int val2
)
547 for (i
= 0; i
< ARRAY_SIZE(samp_freq_table
); ++i
) {
548 if (samp_freq_table
[i
].val
== val
&&
549 samp_freq_table
[i
].val2
== val2
) {
550 return samp_freq_table
[i
].odr_bits
;
557 static int kxcjk1013_convert_wake_odr_to_bit(int val
, int val2
)
561 for (i
= 0; i
< ARRAY_SIZE(wake_odr_data_rate_table
); ++i
) {
562 if (wake_odr_data_rate_table
[i
].val
== val
&&
563 wake_odr_data_rate_table
[i
].val2
== val2
) {
564 return wake_odr_data_rate_table
[i
].odr_bits
;
571 static int kxcjk1013_set_odr(struct kxcjk1013_data
*data
, int val
, int val2
)
575 enum kxcjk1013_mode store_mode
;
577 ret
= kxcjk1013_get_mode(data
, &store_mode
);
581 odr_bits
= kxcjk1013_convert_freq_to_bit(val
, val2
);
585 /* To change ODR, the chip must be set to STANDBY as per spec */
586 ret
= kxcjk1013_set_mode(data
, STANDBY
);
590 ret
= i2c_smbus_write_byte_data(data
->client
, KXCJK1013_REG_DATA_CTRL
,
593 dev_err(&data
->client
->dev
, "Error writing data_ctrl\n");
597 data
->odr_bits
= odr_bits
;
599 odr_bits
= kxcjk1013_convert_wake_odr_to_bit(val
, val2
);
603 ret
= i2c_smbus_write_byte_data(data
->client
, KXCJK1013_REG_CTRL2
,
606 dev_err(&data
->client
->dev
, "Error writing reg_ctrl2\n");
610 if (store_mode
== OPERATION
) {
611 ret
= kxcjk1013_set_mode(data
, OPERATION
);
619 static int kxcjk1013_get_odr(struct kxcjk1013_data
*data
, int *val
, int *val2
)
623 for (i
= 0; i
< ARRAY_SIZE(samp_freq_table
); ++i
) {
624 if (samp_freq_table
[i
].odr_bits
== data
->odr_bits
) {
625 *val
= samp_freq_table
[i
].val
;
626 *val2
= samp_freq_table
[i
].val2
;
627 return IIO_VAL_INT_PLUS_MICRO
;
634 static int kxcjk1013_get_acc_reg(struct kxcjk1013_data
*data
, int axis
)
636 u8 reg
= KXCJK1013_REG_XOUT_L
+ axis
* 2;
639 ret
= i2c_smbus_read_word_data(data
->client
, reg
);
641 dev_err(&data
->client
->dev
,
642 "failed to read accel_%c registers\n", 'x' + axis
);
649 static int kxcjk1013_set_scale(struct kxcjk1013_data
*data
, int val
)
652 enum kxcjk1013_mode store_mode
;
655 for (i
= 0; i
< ARRAY_SIZE(KXCJK1013_scale_table
); ++i
) {
656 if (KXCJK1013_scale_table
[i
].scale
== val
) {
658 ret
= kxcjk1013_get_mode(data
, &store_mode
);
662 ret
= kxcjk1013_set_mode(data
, STANDBY
);
666 ret
= kxcjk1013_set_range(data
, i
);
670 if (store_mode
== OPERATION
) {
671 ret
= kxcjk1013_set_mode(data
, OPERATION
);
683 static int kxcjk1013_read_raw(struct iio_dev
*indio_dev
,
684 struct iio_chan_spec
const *chan
, int *val
,
685 int *val2
, long mask
)
687 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
691 case IIO_CHAN_INFO_RAW
:
692 mutex_lock(&data
->mutex
);
693 if (iio_buffer_enabled(indio_dev
))
696 ret
= kxcjk1013_set_power_state(data
, true);
698 mutex_unlock(&data
->mutex
);
701 ret
= kxcjk1013_get_acc_reg(data
, chan
->scan_index
);
703 kxcjk1013_set_power_state(data
, false);
704 mutex_unlock(&data
->mutex
);
707 *val
= sign_extend32(ret
>> 4, 11);
708 ret
= kxcjk1013_set_power_state(data
, false);
710 mutex_unlock(&data
->mutex
);
717 case IIO_CHAN_INFO_SCALE
:
719 *val2
= KXCJK1013_scale_table
[data
->range
].scale
;
720 return IIO_VAL_INT_PLUS_MICRO
;
722 case IIO_CHAN_INFO_SAMP_FREQ
:
723 mutex_lock(&data
->mutex
);
724 ret
= kxcjk1013_get_odr(data
, val
, val2
);
725 mutex_unlock(&data
->mutex
);
733 static int kxcjk1013_write_raw(struct iio_dev
*indio_dev
,
734 struct iio_chan_spec
const *chan
, int val
,
737 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
741 case IIO_CHAN_INFO_SAMP_FREQ
:
742 mutex_lock(&data
->mutex
);
743 ret
= kxcjk1013_set_odr(data
, val
, val2
);
744 mutex_unlock(&data
->mutex
);
746 case IIO_CHAN_INFO_SCALE
:
750 mutex_lock(&data
->mutex
);
751 ret
= kxcjk1013_set_scale(data
, val2
);
752 mutex_unlock(&data
->mutex
);
761 static int kxcjk1013_read_event(struct iio_dev
*indio_dev
,
762 const struct iio_chan_spec
*chan
,
763 enum iio_event_type type
,
764 enum iio_event_direction dir
,
765 enum iio_event_info info
,
768 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
772 case IIO_EV_INFO_VALUE
:
773 *val
= data
->wake_thres
;
775 case IIO_EV_INFO_PERIOD
:
776 *val
= data
->wake_dur
;
785 static int kxcjk1013_write_event(struct iio_dev
*indio_dev
,
786 const struct iio_chan_spec
*chan
,
787 enum iio_event_type type
,
788 enum iio_event_direction dir
,
789 enum iio_event_info info
,
792 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
794 if (data
->ev_enable_state
)
798 case IIO_EV_INFO_VALUE
:
799 data
->wake_thres
= val
;
801 case IIO_EV_INFO_PERIOD
:
802 data
->wake_dur
= val
;
811 static int kxcjk1013_read_event_config(struct iio_dev
*indio_dev
,
812 const struct iio_chan_spec
*chan
,
813 enum iio_event_type type
,
814 enum iio_event_direction dir
)
817 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
819 return data
->ev_enable_state
;
822 static int kxcjk1013_write_event_config(struct iio_dev
*indio_dev
,
823 const struct iio_chan_spec
*chan
,
824 enum iio_event_type type
,
825 enum iio_event_direction dir
,
828 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
831 if (state
&& data
->ev_enable_state
)
834 mutex_lock(&data
->mutex
);
836 if (!state
&& data
->motion_trigger_on
) {
837 data
->ev_enable_state
= 0;
838 mutex_unlock(&data
->mutex
);
843 * We will expect the enable and disable to do operation in
844 * in reverse order. This will happen here anyway as our
845 * resume operation uses sync mode runtime pm calls, the
846 * suspend operation will be delayed by autosuspend delay
847 * So the disable operation will still happen in reverse of
848 * enable operation. When runtime pm is disabled the mode
849 * is always on so sequence doesn't matter
851 ret
= kxcjk1013_set_power_state(data
, state
);
853 mutex_unlock(&data
->mutex
);
857 ret
= kxcjk1013_setup_any_motion_interrupt(data
, state
);
859 mutex_unlock(&data
->mutex
);
863 data
->ev_enable_state
= state
;
864 mutex_unlock(&data
->mutex
);
869 static int kxcjk1013_validate_trigger(struct iio_dev
*indio_dev
,
870 struct iio_trigger
*trig
)
872 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
874 if (data
->dready_trig
!= trig
&& data
->motion_trig
!= trig
)
880 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
881 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800 1600");
883 static IIO_CONST_ATTR(in_accel_scale_available
, "0.009582 0.019163 0.038326");
885 static struct attribute
*kxcjk1013_attributes
[] = {
886 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
887 &iio_const_attr_in_accel_scale_available
.dev_attr
.attr
,
891 static const struct attribute_group kxcjk1013_attrs_group
= {
892 .attrs
= kxcjk1013_attributes
,
895 static const struct iio_event_spec kxcjk1013_event
= {
896 .type
= IIO_EV_TYPE_THRESH
,
897 .dir
= IIO_EV_DIR_RISING
| IIO_EV_DIR_FALLING
,
898 .mask_separate
= BIT(IIO_EV_INFO_VALUE
) |
899 BIT(IIO_EV_INFO_ENABLE
) |
900 BIT(IIO_EV_INFO_PERIOD
)
903 #define KXCJK1013_CHANNEL(_axis) { \
906 .channel2 = IIO_MOD_##_axis, \
907 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
908 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
909 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
910 .scan_index = AXIS_##_axis, \
916 .endianness = IIO_CPU, \
918 .event_spec = &kxcjk1013_event, \
919 .num_event_specs = 1 \
922 static const struct iio_chan_spec kxcjk1013_channels
[] = {
923 KXCJK1013_CHANNEL(X
),
924 KXCJK1013_CHANNEL(Y
),
925 KXCJK1013_CHANNEL(Z
),
926 IIO_CHAN_SOFT_TIMESTAMP(3),
929 static const struct iio_info kxcjk1013_info
= {
930 .attrs
= &kxcjk1013_attrs_group
,
931 .read_raw
= kxcjk1013_read_raw
,
932 .write_raw
= kxcjk1013_write_raw
,
933 .read_event_value
= kxcjk1013_read_event
,
934 .write_event_value
= kxcjk1013_write_event
,
935 .write_event_config
= kxcjk1013_write_event_config
,
936 .read_event_config
= kxcjk1013_read_event_config
,
937 .validate_trigger
= kxcjk1013_validate_trigger
,
938 .driver_module
= THIS_MODULE
,
941 static irqreturn_t
kxcjk1013_trigger_handler(int irq
, void *p
)
943 struct iio_poll_func
*pf
= p
;
944 struct iio_dev
*indio_dev
= pf
->indio_dev
;
945 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
948 mutex_lock(&data
->mutex
);
950 for_each_set_bit(bit
, indio_dev
->buffer
->scan_mask
,
951 indio_dev
->masklength
) {
952 ret
= kxcjk1013_get_acc_reg(data
, bit
);
954 mutex_unlock(&data
->mutex
);
957 data
->buffer
[i
++] = ret
;
959 mutex_unlock(&data
->mutex
);
961 iio_push_to_buffers_with_timestamp(indio_dev
, data
->buffer
,
964 iio_trigger_notify_done(indio_dev
->trig
);
969 static int kxcjk1013_trig_try_reen(struct iio_trigger
*trig
)
971 struct iio_dev
*indio_dev
= iio_trigger_get_drvdata(trig
);
972 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
975 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_INT_REL
);
977 dev_err(&data
->client
->dev
, "Error reading reg_int_rel\n");
984 static int kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger
*trig
,
987 struct iio_dev
*indio_dev
= iio_trigger_get_drvdata(trig
);
988 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
991 mutex_lock(&data
->mutex
);
993 if (!state
&& data
->ev_enable_state
&& data
->motion_trigger_on
) {
994 data
->motion_trigger_on
= false;
995 mutex_unlock(&data
->mutex
);
999 ret
= kxcjk1013_set_power_state(data
, state
);
1001 mutex_unlock(&data
->mutex
);
1004 if (data
->motion_trig
== trig
)
1005 ret
= kxcjk1013_setup_any_motion_interrupt(data
, state
);
1007 ret
= kxcjk1013_setup_new_data_interrupt(data
, state
);
1009 mutex_unlock(&data
->mutex
);
1012 if (data
->motion_trig
== trig
)
1013 data
->motion_trigger_on
= state
;
1015 data
->dready_trigger_on
= state
;
1017 mutex_unlock(&data
->mutex
);
1022 static const struct iio_trigger_ops kxcjk1013_trigger_ops
= {
1023 .set_trigger_state
= kxcjk1013_data_rdy_trigger_set_state
,
1024 .try_reenable
= kxcjk1013_trig_try_reen
,
1025 .owner
= THIS_MODULE
,
1028 static irqreturn_t
kxcjk1013_event_handler(int irq
, void *private)
1030 struct iio_dev
*indio_dev
= private;
1031 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
1034 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_INT_SRC1
);
1036 dev_err(&data
->client
->dev
, "Error reading reg_int_src1\n");
1041 ret
= i2c_smbus_read_byte_data(data
->client
,
1042 KXCJK1013_REG_INT_SRC2
);
1044 dev_err(&data
->client
->dev
,
1045 "Error reading reg_int_src2\n");
1049 if (ret
& KXCJK1013_REG_INT_SRC2_BIT_XN
)
1050 iio_push_event(indio_dev
,
1051 IIO_MOD_EVENT_CODE(IIO_ACCEL
,
1055 IIO_EV_DIR_FALLING
),
1057 if (ret
& KXCJK1013_REG_INT_SRC2_BIT_XP
)
1058 iio_push_event(indio_dev
,
1059 IIO_MOD_EVENT_CODE(IIO_ACCEL
,
1067 if (ret
& KXCJK1013_REG_INT_SRC2_BIT_YN
)
1068 iio_push_event(indio_dev
,
1069 IIO_MOD_EVENT_CODE(IIO_ACCEL
,
1073 IIO_EV_DIR_FALLING
),
1075 if (ret
& KXCJK1013_REG_INT_SRC2_BIT_YP
)
1076 iio_push_event(indio_dev
,
1077 IIO_MOD_EVENT_CODE(IIO_ACCEL
,
1084 if (ret
& KXCJK1013_REG_INT_SRC2_BIT_ZN
)
1085 iio_push_event(indio_dev
,
1086 IIO_MOD_EVENT_CODE(IIO_ACCEL
,
1090 IIO_EV_DIR_FALLING
),
1092 if (ret
& KXCJK1013_REG_INT_SRC2_BIT_ZP
)
1093 iio_push_event(indio_dev
,
1094 IIO_MOD_EVENT_CODE(IIO_ACCEL
,
1103 if (data
->dready_trigger_on
)
1106 ret
= i2c_smbus_read_byte_data(data
->client
, KXCJK1013_REG_INT_REL
);
1108 dev_err(&data
->client
->dev
, "Error reading reg_int_rel\n");
1113 static irqreturn_t
kxcjk1013_data_rdy_trig_poll(int irq
, void *private)
1115 struct iio_dev
*indio_dev
= private;
1116 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
1118 data
->timestamp
= iio_get_time_ns();
1120 if (data
->dready_trigger_on
)
1121 iio_trigger_poll(data
->dready_trig
);
1122 else if (data
->motion_trigger_on
)
1123 iio_trigger_poll(data
->motion_trig
);
1125 if (data
->ev_enable_state
)
1126 return IRQ_WAKE_THREAD
;
1131 static const char *kxcjk1013_match_acpi_device(struct device
*dev
,
1132 enum kx_chipset
*chipset
)
1134 const struct acpi_device_id
*id
;
1135 id
= acpi_match_device(dev
->driver
->acpi_match_table
, dev
);
1138 *chipset
= (enum kx_chipset
)id
->driver_data
;
1140 return dev_name(dev
);
1143 static int kxcjk1013_gpio_probe(struct i2c_client
*client
,
1144 struct kxcjk1013_data
*data
)
1147 struct gpio_desc
*gpio
;
1155 /* data ready gpio interrupt pin */
1156 gpio
= devm_gpiod_get_index(dev
, "kxcjk1013_int", 0);
1158 dev_err(dev
, "acpi gpio get index failed\n");
1159 return PTR_ERR(gpio
);
1162 ret
= gpiod_direction_input(gpio
);
1166 ret
= gpiod_to_irq(gpio
);
1168 dev_dbg(dev
, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio
), ret
);
1173 static int kxcjk1013_probe(struct i2c_client
*client
,
1174 const struct i2c_device_id
*id
)
1176 struct kxcjk1013_data
*data
;
1177 struct iio_dev
*indio_dev
;
1178 struct kxcjk_1013_platform_data
*pdata
;
1182 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
1186 data
= iio_priv(indio_dev
);
1187 i2c_set_clientdata(client
, indio_dev
);
1188 data
->client
= client
;
1190 pdata
= dev_get_platdata(&client
->dev
);
1192 data
->active_high_intr
= pdata
->active_high_intr
;
1194 data
->active_high_intr
= true; /* default polarity */
1197 data
->chipset
= (enum kx_chipset
)(id
->driver_data
);
1199 } else if (ACPI_HANDLE(&client
->dev
)) {
1200 name
= kxcjk1013_match_acpi_device(&client
->dev
,
1205 ret
= kxcjk1013_chip_init(data
);
1209 mutex_init(&data
->mutex
);
1211 indio_dev
->dev
.parent
= &client
->dev
;
1212 indio_dev
->channels
= kxcjk1013_channels
;
1213 indio_dev
->num_channels
= ARRAY_SIZE(kxcjk1013_channels
);
1214 indio_dev
->name
= name
;
1215 indio_dev
->modes
= INDIO_DIRECT_MODE
;
1216 indio_dev
->info
= &kxcjk1013_info
;
1218 if (client
->irq
< 0)
1219 client
->irq
= kxcjk1013_gpio_probe(client
, data
);
1221 if (client
->irq
>= 0) {
1222 ret
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
1223 kxcjk1013_data_rdy_trig_poll
,
1224 kxcjk1013_event_handler
,
1225 IRQF_TRIGGER_RISING
,
1231 data
->dready_trig
= devm_iio_trigger_alloc(&client
->dev
,
1235 if (!data
->dready_trig
)
1238 data
->motion_trig
= devm_iio_trigger_alloc(&client
->dev
,
1239 "%s-any-motion-dev%d",
1242 if (!data
->motion_trig
)
1245 data
->dready_trig
->dev
.parent
= &client
->dev
;
1246 data
->dready_trig
->ops
= &kxcjk1013_trigger_ops
;
1247 iio_trigger_set_drvdata(data
->dready_trig
, indio_dev
);
1248 indio_dev
->trig
= data
->dready_trig
;
1249 iio_trigger_get(indio_dev
->trig
);
1250 ret
= iio_trigger_register(data
->dready_trig
);
1254 data
->motion_trig
->dev
.parent
= &client
->dev
;
1255 data
->motion_trig
->ops
= &kxcjk1013_trigger_ops
;
1256 iio_trigger_set_drvdata(data
->motion_trig
, indio_dev
);
1257 ret
= iio_trigger_register(data
->motion_trig
);
1259 data
->motion_trig
= NULL
;
1260 goto err_trigger_unregister
;
1263 ret
= iio_triggered_buffer_setup(indio_dev
,
1264 &iio_pollfunc_store_time
,
1265 kxcjk1013_trigger_handler
,
1268 dev_err(&client
->dev
,
1269 "iio triggered buffer setup failed\n");
1270 goto err_trigger_unregister
;
1274 ret
= iio_device_register(indio_dev
);
1276 dev_err(&client
->dev
, "unable to register iio device\n");
1277 goto err_buffer_cleanup
;
1280 ret
= pm_runtime_set_active(&client
->dev
);
1282 goto err_iio_unregister
;
1284 pm_runtime_enable(&client
->dev
);
1285 pm_runtime_set_autosuspend_delay(&client
->dev
,
1286 KXCJK1013_SLEEP_DELAY_MS
);
1287 pm_runtime_use_autosuspend(&client
->dev
);
1292 iio_device_unregister(indio_dev
);
1294 if (data
->dready_trig
)
1295 iio_triggered_buffer_cleanup(indio_dev
);
1296 err_trigger_unregister
:
1297 if (data
->dready_trig
)
1298 iio_trigger_unregister(data
->dready_trig
);
1299 if (data
->motion_trig
)
1300 iio_trigger_unregister(data
->motion_trig
);
1305 static int kxcjk1013_remove(struct i2c_client
*client
)
1307 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
1308 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
1310 pm_runtime_disable(&client
->dev
);
1311 pm_runtime_set_suspended(&client
->dev
);
1312 pm_runtime_put_noidle(&client
->dev
);
1314 iio_device_unregister(indio_dev
);
1316 if (data
->dready_trig
) {
1317 iio_triggered_buffer_cleanup(indio_dev
);
1318 iio_trigger_unregister(data
->dready_trig
);
1319 iio_trigger_unregister(data
->motion_trig
);
1322 mutex_lock(&data
->mutex
);
1323 kxcjk1013_set_mode(data
, STANDBY
);
1324 mutex_unlock(&data
->mutex
);
1329 #ifdef CONFIG_PM_SLEEP
1330 static int kxcjk1013_suspend(struct device
*dev
)
1332 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1333 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
1336 mutex_lock(&data
->mutex
);
1337 ret
= kxcjk1013_set_mode(data
, STANDBY
);
1338 mutex_unlock(&data
->mutex
);
1343 static int kxcjk1013_resume(struct device
*dev
)
1345 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1346 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
1349 mutex_lock(&data
->mutex
);
1350 /* Check, if the suspend occured while active */
1351 if (data
->dready_trigger_on
|| data
->motion_trigger_on
||
1352 data
->ev_enable_state
)
1353 ret
= kxcjk1013_set_mode(data
, OPERATION
);
1354 mutex_unlock(&data
->mutex
);
1360 #ifdef CONFIG_PM_RUNTIME
1361 static int kxcjk1013_runtime_suspend(struct device
*dev
)
1363 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1364 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
1366 return kxcjk1013_set_mode(data
, STANDBY
);
1369 static int kxcjk1013_runtime_resume(struct device
*dev
)
1371 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
1372 struct kxcjk1013_data
*data
= iio_priv(indio_dev
);
1376 ret
= kxcjk1013_set_mode(data
, OPERATION
);
1380 sleep_val
= kxcjk1013_get_startup_times(data
);
1381 if (sleep_val
< 20000)
1382 usleep_range(sleep_val
, 20000);
1384 msleep_interruptible(sleep_val
/1000);
1390 static const struct dev_pm_ops kxcjk1013_pm_ops
= {
1391 SET_SYSTEM_SLEEP_PM_OPS(kxcjk1013_suspend
, kxcjk1013_resume
)
1392 SET_RUNTIME_PM_OPS(kxcjk1013_runtime_suspend
,
1393 kxcjk1013_runtime_resume
, NULL
)
1396 static const struct acpi_device_id kx_acpi_match
[] = {
1397 {"KXCJ1013", KXCJK1013
},
1398 {"KXCJ1008", KXCJ91008
},
1399 {"KXTJ1009", KXTJ21009
},
1402 MODULE_DEVICE_TABLE(acpi
, kx_acpi_match
);
1404 static const struct i2c_device_id kxcjk1013_id
[] = {
1405 {"kxcjk1013", KXCJK1013
},
1406 {"kxcj91008", KXCJ91008
},
1407 {"kxtj21009", KXTJ21009
},
1411 MODULE_DEVICE_TABLE(i2c
, kxcjk1013_id
);
1413 static struct i2c_driver kxcjk1013_driver
= {
1415 .name
= KXCJK1013_DRV_NAME
,
1416 .acpi_match_table
= ACPI_PTR(kx_acpi_match
),
1417 .pm
= &kxcjk1013_pm_ops
,
1419 .probe
= kxcjk1013_probe
,
1420 .remove
= kxcjk1013_remove
,
1421 .id_table
= kxcjk1013_id
,
1423 module_i2c_driver(kxcjk1013_driver
);
1425 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1426 MODULE_LICENSE("GPL v2");
1427 MODULE_DESCRIPTION("KXCJK1013 accelerometer driver");