2 * Sensortek STK8312 3-Axis Accelerometer
4 * Copyright (c) 2015, 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 STK8312; 7-bit I2C address: 0x3D.
13 #include <linux/acpi.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/i2c.h>
16 #include <linux/interrupt.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/delay.h>
20 #include <linux/iio/buffer.h>
21 #include <linux/iio/iio.h>
22 #include <linux/iio/sysfs.h>
23 #include <linux/iio/trigger.h>
24 #include <linux/iio/triggered_buffer.h>
25 #include <linux/iio/trigger_consumer.h>
27 #define STK8312_REG_XOUT 0x00
28 #define STK8312_REG_YOUT 0x01
29 #define STK8312_REG_ZOUT 0x02
30 #define STK8312_REG_INTSU 0x06
31 #define STK8312_REG_MODE 0x07
32 #define STK8312_REG_SR 0x08
33 #define STK8312_REG_STH 0x13
34 #define STK8312_REG_RESET 0x20
35 #define STK8312_REG_AFECTRL 0x24
36 #define STK8312_REG_OTPADDR 0x3D
37 #define STK8312_REG_OTPDATA 0x3E
38 #define STK8312_REG_OTPCTRL 0x3F
40 #define STK8312_MODE_ACTIVE BIT(0)
41 #define STK8312_MODE_STANDBY 0x00
42 #define STK8312_MODE_INT_AH_PP 0xC0 /* active-high, push-pull */
43 #define STK8312_DREADY_BIT BIT(4)
44 #define STK8312_RNG_6G 1
45 #define STK8312_RNG_SHIFT 6
46 #define STK8312_RNG_MASK GENMASK(7, 6)
47 #define STK8312_SR_MASK GENMASK(2, 0)
48 #define STK8312_SR_400HZ_IDX 0
49 #define STK8312_ALL_CHANNEL_MASK GENMASK(2, 0)
50 #define STK8312_ALL_CHANNEL_SIZE 3
52 #define STK8312_DRIVER_NAME "stk8312"
53 #define STK8312_GPIO "stk8312_gpio"
54 #define STK8312_IRQ_NAME "stk8312_event"
57 * The accelerometer has two measurement ranges:
59 * -6g - +6g (8-bit, signed)
60 * -16g - +16g (8-bit, signed)
62 * scale1 = (6 + 6) * 9.81 / (2^8 - 1) = 0.4616
63 * scale2 = (16 + 16) * 9.81 / (2^8 - 1) = 1.2311
65 #define STK8312_SCALE_AVAIL "0.4616 1.2311"
67 static const int stk8312_scale_table
[][2] = {
68 {0, 461600}, {1, 231100}
74 } stk8312_samp_freq_table
[] = {
75 {400, 0}, {200, 0}, {100, 0}, {50, 0}, {25, 0},
76 {12, 500000}, {6, 250000}, {3, 125000}
79 #define STK8312_ACCEL_CHANNEL(index, reg, axis) { \
83 .channel2 = IIO_MOD_##axis, \
84 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
85 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
86 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
87 .scan_index = index, \
92 .endianness = IIO_CPU, \
96 static const struct iio_chan_spec stk8312_channels
[] = {
97 STK8312_ACCEL_CHANNEL(0, STK8312_REG_XOUT
, X
),
98 STK8312_ACCEL_CHANNEL(1, STK8312_REG_YOUT
, Y
),
99 STK8312_ACCEL_CHANNEL(2, STK8312_REG_ZOUT
, Z
),
100 IIO_CHAN_SOFT_TIMESTAMP(3),
103 struct stk8312_data
{
104 struct i2c_client
*client
;
109 struct iio_trigger
*dready_trig
;
110 bool dready_trigger_on
;
111 s8 buffer
[16]; /* 3x8-bit channels + 5x8 padding + 64-bit timestamp */
114 static IIO_CONST_ATTR(in_accel_scale_available
, STK8312_SCALE_AVAIL
);
116 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("3.125 6.25 12.5 25 50 100 200 400");
118 static struct attribute
*stk8312_attributes
[] = {
119 &iio_const_attr_in_accel_scale_available
.dev_attr
.attr
,
120 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
124 static const struct attribute_group stk8312_attribute_group
= {
125 .attrs
= stk8312_attributes
128 static int stk8312_otp_init(struct stk8312_data
*data
)
132 struct i2c_client
*client
= data
->client
;
134 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_OTPADDR
, 0x70);
137 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_OTPCTRL
, 0x02);
142 usleep_range(1000, 5000);
143 ret
= i2c_smbus_read_byte_data(client
, STK8312_REG_OTPCTRL
);
147 } while (!(ret
& BIT(7)) && count
> 0);
154 ret
= i2c_smbus_read_byte_data(client
, STK8312_REG_OTPDATA
);
160 ret
= i2c_smbus_write_byte_data(data
->client
, STK8312_REG_AFECTRL
, ret
);
168 dev_err(&client
->dev
, "failed to initialize sensor\n");
172 static int stk8312_set_mode(struct stk8312_data
*data
, u8 mode
)
175 struct i2c_client
*client
= data
->client
;
177 if (mode
== data
->mode
)
180 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_MODE
, mode
);
182 dev_err(&client
->dev
, "failed to change sensor mode\n");
187 if (mode
& STK8312_MODE_ACTIVE
) {
188 /* Need to run OTP sequence before entering active mode */
189 usleep_range(1000, 5000);
190 ret
= stk8312_otp_init(data
);
196 static int stk8312_set_interrupts(struct stk8312_data
*data
, u8 int_mask
)
200 struct i2c_client
*client
= data
->client
;
203 /* We need to go in standby mode to modify registers */
204 ret
= stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
208 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_INTSU
, int_mask
);
210 dev_err(&client
->dev
, "failed to set interrupts\n");
211 stk8312_set_mode(data
, mode
);
215 return stk8312_set_mode(data
, mode
);
218 static int stk8312_data_rdy_trigger_set_state(struct iio_trigger
*trig
,
221 struct iio_dev
*indio_dev
= iio_trigger_get_drvdata(trig
);
222 struct stk8312_data
*data
= iio_priv(indio_dev
);
226 ret
= stk8312_set_interrupts(data
, STK8312_DREADY_BIT
);
228 ret
= stk8312_set_interrupts(data
, 0x00);
231 dev_err(&data
->client
->dev
, "failed to set trigger state\n");
235 data
->dready_trigger_on
= state
;
240 static const struct iio_trigger_ops stk8312_trigger_ops
= {
241 .set_trigger_state
= stk8312_data_rdy_trigger_set_state
,
242 .owner
= THIS_MODULE
,
245 static int stk8312_set_sample_rate(struct stk8312_data
*data
, u8 rate
)
250 struct i2c_client
*client
= data
->client
;
252 if (rate
== data
->sample_rate_idx
)
256 /* We need to go in standby mode to modify registers */
257 ret
= stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
261 ret
= i2c_smbus_read_byte_data(client
, STK8312_REG_SR
);
265 masked_reg
= (ret
& (~STK8312_SR_MASK
)) | rate
;
267 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_SR
, masked_reg
);
271 data
->sample_rate_idx
= rate
;
273 return stk8312_set_mode(data
, mode
);
276 dev_err(&client
->dev
, "failed to set sampling rate\n");
277 stk8312_set_mode(data
, mode
);
282 static int stk8312_set_range(struct stk8312_data
*data
, u8 range
)
287 struct i2c_client
*client
= data
->client
;
289 if (range
!= 1 && range
!= 2)
291 else if (range
== data
->range
)
295 /* We need to go in standby mode to modify registers */
296 ret
= stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
300 ret
= i2c_smbus_read_byte_data(client
, STK8312_REG_STH
);
304 masked_reg
= ret
& (~STK8312_RNG_MASK
);
305 masked_reg
|= range
<< STK8312_RNG_SHIFT
;
307 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_STH
, masked_reg
);
313 return stk8312_set_mode(data
, mode
);
316 dev_err(&client
->dev
, "failed to change sensor range\n");
317 stk8312_set_mode(data
, mode
);
322 static int stk8312_read_accel(struct stk8312_data
*data
, u8 address
)
325 struct i2c_client
*client
= data
->client
;
330 ret
= i2c_smbus_read_byte_data(client
, address
);
332 dev_err(&client
->dev
, "register read failed\n");
337 static int stk8312_read_raw(struct iio_dev
*indio_dev
,
338 struct iio_chan_spec
const *chan
,
339 int *val
, int *val2
, long mask
)
341 struct stk8312_data
*data
= iio_priv(indio_dev
);
345 case IIO_CHAN_INFO_RAW
:
346 if (iio_buffer_enabled(indio_dev
))
348 mutex_lock(&data
->lock
);
349 ret
= stk8312_set_mode(data
, data
->mode
| STK8312_MODE_ACTIVE
);
351 mutex_unlock(&data
->lock
);
354 ret
= stk8312_read_accel(data
, chan
->address
);
356 stk8312_set_mode(data
,
357 data
->mode
& (~STK8312_MODE_ACTIVE
));
358 mutex_unlock(&data
->lock
);
361 *val
= sign_extend32(ret
, 7);
362 ret
= stk8312_set_mode(data
,
363 data
->mode
& (~STK8312_MODE_ACTIVE
));
364 mutex_unlock(&data
->lock
);
368 case IIO_CHAN_INFO_SCALE
:
369 *val
= stk8312_scale_table
[data
->range
- 1][0];
370 *val2
= stk8312_scale_table
[data
->range
- 1][1];
371 return IIO_VAL_INT_PLUS_MICRO
;
372 case IIO_CHAN_INFO_SAMP_FREQ
:
373 *val
= stk8312_samp_freq_table
[data
->sample_rate_idx
].val
;
374 *val2
= stk8312_samp_freq_table
[data
->sample_rate_idx
].val2
;
375 return IIO_VAL_INT_PLUS_MICRO
;
381 static int stk8312_write_raw(struct iio_dev
*indio_dev
,
382 struct iio_chan_spec
const *chan
,
383 int val
, int val2
, long mask
)
388 struct stk8312_data
*data
= iio_priv(indio_dev
);
391 case IIO_CHAN_INFO_SCALE
:
392 for (i
= 0; i
< ARRAY_SIZE(stk8312_scale_table
); i
++)
393 if (val
== stk8312_scale_table
[i
][0] &&
394 val2
== stk8312_scale_table
[i
][1]) {
401 mutex_lock(&data
->lock
);
402 ret
= stk8312_set_range(data
, index
);
403 mutex_unlock(&data
->lock
);
406 case IIO_CHAN_INFO_SAMP_FREQ
:
407 for (i
= 0; i
< ARRAY_SIZE(stk8312_samp_freq_table
); i
++)
408 if (val
== stk8312_samp_freq_table
[i
].val
&&
409 val2
== stk8312_samp_freq_table
[i
].val2
) {
415 mutex_lock(&data
->lock
);
416 ret
= stk8312_set_sample_rate(data
, index
);
417 mutex_unlock(&data
->lock
);
425 static const struct iio_info stk8312_info
= {
426 .driver_module
= THIS_MODULE
,
427 .read_raw
= stk8312_read_raw
,
428 .write_raw
= stk8312_write_raw
,
429 .attrs
= &stk8312_attribute_group
,
432 static irqreturn_t
stk8312_trigger_handler(int irq
, void *p
)
434 struct iio_poll_func
*pf
= p
;
435 struct iio_dev
*indio_dev
= pf
->indio_dev
;
436 struct stk8312_data
*data
= iio_priv(indio_dev
);
439 mutex_lock(&data
->lock
);
441 * Do a bulk read if all channels are requested,
442 * from 0x00 (XOUT) to 0x02 (ZOUT)
444 if (*(indio_dev
->active_scan_mask
) == STK8312_ALL_CHANNEL_MASK
) {
445 ret
= i2c_smbus_read_i2c_block_data(data
->client
,
447 STK8312_ALL_CHANNEL_SIZE
,
449 if (ret
< STK8312_ALL_CHANNEL_SIZE
) {
450 dev_err(&data
->client
->dev
, "register read failed\n");
451 mutex_unlock(&data
->lock
);
455 for_each_set_bit(bit
, indio_dev
->active_scan_mask
,
456 indio_dev
->masklength
) {
457 ret
= stk8312_read_accel(data
, bit
);
459 mutex_unlock(&data
->lock
);
462 data
->buffer
[i
++] = ret
;
465 mutex_unlock(&data
->lock
);
467 iio_push_to_buffers_with_timestamp(indio_dev
, data
->buffer
,
470 iio_trigger_notify_done(indio_dev
->trig
);
475 static irqreturn_t
stk8312_data_rdy_trig_poll(int irq
, void *private)
477 struct iio_dev
*indio_dev
= private;
478 struct stk8312_data
*data
= iio_priv(indio_dev
);
480 if (data
->dready_trigger_on
)
481 iio_trigger_poll(data
->dready_trig
);
486 static int stk8312_buffer_preenable(struct iio_dev
*indio_dev
)
488 struct stk8312_data
*data
= iio_priv(indio_dev
);
490 return stk8312_set_mode(data
, data
->mode
| STK8312_MODE_ACTIVE
);
493 static int stk8312_buffer_postdisable(struct iio_dev
*indio_dev
)
495 struct stk8312_data
*data
= iio_priv(indio_dev
);
497 return stk8312_set_mode(data
, data
->mode
& (~STK8312_MODE_ACTIVE
));
500 static const struct iio_buffer_setup_ops stk8312_buffer_setup_ops
= {
501 .preenable
= stk8312_buffer_preenable
,
502 .postenable
= iio_triggered_buffer_postenable
,
503 .predisable
= iio_triggered_buffer_predisable
,
504 .postdisable
= stk8312_buffer_postdisable
,
507 static int stk8312_gpio_probe(struct i2c_client
*client
)
510 struct gpio_desc
*gpio
;
518 /* data ready gpio interrupt pin */
519 gpio
= devm_gpiod_get_index(dev
, STK8312_GPIO
, 0, GPIOD_IN
);
521 dev_err(dev
, "acpi gpio get index failed\n");
522 return PTR_ERR(gpio
);
525 ret
= gpiod_to_irq(gpio
);
526 dev_dbg(dev
, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio
), ret
);
531 static int stk8312_probe(struct i2c_client
*client
,
532 const struct i2c_device_id
*id
)
535 struct iio_dev
*indio_dev
;
536 struct stk8312_data
*data
;
538 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
540 dev_err(&client
->dev
, "iio allocation failed!\n");
544 data
= iio_priv(indio_dev
);
545 data
->client
= client
;
546 i2c_set_clientdata(client
, indio_dev
);
547 mutex_init(&data
->lock
);
549 indio_dev
->dev
.parent
= &client
->dev
;
550 indio_dev
->info
= &stk8312_info
;
551 indio_dev
->name
= STK8312_DRIVER_NAME
;
552 indio_dev
->modes
= INDIO_DIRECT_MODE
;
553 indio_dev
->channels
= stk8312_channels
;
554 indio_dev
->num_channels
= ARRAY_SIZE(stk8312_channels
);
556 /* A software reset is recommended at power-on */
557 ret
= i2c_smbus_write_byte_data(data
->client
, STK8312_REG_RESET
, 0x00);
559 dev_err(&client
->dev
, "failed to reset sensor\n");
562 data
->sample_rate_idx
= STK8312_SR_400HZ_IDX
;
563 ret
= stk8312_set_range(data
, STK8312_RNG_6G
);
567 ret
= stk8312_set_mode(data
,
568 STK8312_MODE_INT_AH_PP
| STK8312_MODE_ACTIVE
);
573 client
->irq
= stk8312_gpio_probe(client
);
575 if (client
->irq
> 0) {
576 ret
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
577 stk8312_data_rdy_trig_poll
,
579 IRQF_TRIGGER_RISING
|
584 dev_err(&client
->dev
, "request irq %d failed\n",
589 data
->dready_trig
= devm_iio_trigger_alloc(&client
->dev
,
593 if (!data
->dready_trig
) {
598 data
->dready_trig
->dev
.parent
= &client
->dev
;
599 data
->dready_trig
->ops
= &stk8312_trigger_ops
;
600 iio_trigger_set_drvdata(data
->dready_trig
, indio_dev
);
601 ret
= iio_trigger_register(data
->dready_trig
);
603 dev_err(&client
->dev
, "iio trigger register failed\n");
608 ret
= iio_triggered_buffer_setup(indio_dev
,
609 iio_pollfunc_store_time
,
610 stk8312_trigger_handler
,
611 &stk8312_buffer_setup_ops
);
613 dev_err(&client
->dev
, "iio triggered buffer setup failed\n");
614 goto err_trigger_unregister
;
617 ret
= iio_device_register(indio_dev
);
619 dev_err(&client
->dev
, "device_register failed\n");
620 goto err_buffer_cleanup
;
626 iio_triggered_buffer_cleanup(indio_dev
);
627 err_trigger_unregister
:
628 if (data
->dready_trig
)
629 iio_trigger_unregister(data
->dready_trig
);
631 stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
635 static int stk8312_remove(struct i2c_client
*client
)
637 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
638 struct stk8312_data
*data
= iio_priv(indio_dev
);
640 iio_device_unregister(indio_dev
);
641 iio_triggered_buffer_cleanup(indio_dev
);
643 if (data
->dready_trig
)
644 iio_trigger_unregister(data
->dready_trig
);
646 return stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
649 #ifdef CONFIG_PM_SLEEP
650 static int stk8312_suspend(struct device
*dev
)
652 struct stk8312_data
*data
;
654 data
= iio_priv(i2c_get_clientdata(to_i2c_client(dev
)));
656 return stk8312_set_mode(data
, data
->mode
& (~STK8312_MODE_ACTIVE
));
659 static int stk8312_resume(struct device
*dev
)
661 struct stk8312_data
*data
;
663 data
= iio_priv(i2c_get_clientdata(to_i2c_client(dev
)));
665 return stk8312_set_mode(data
, data
->mode
| STK8312_MODE_ACTIVE
);
668 static SIMPLE_DEV_PM_OPS(stk8312_pm_ops
, stk8312_suspend
, stk8312_resume
);
670 #define STK8312_PM_OPS (&stk8312_pm_ops)
672 #define STK8312_PM_OPS NULL
675 static const struct i2c_device_id stk8312_i2c_id
[] = {
679 MODULE_DEVICE_TABLE(i2c
, stk8312_i2c_id
);
681 static const struct acpi_device_id stk8312_acpi_id
[] = {
686 MODULE_DEVICE_TABLE(acpi
, stk8312_acpi_id
);
688 static struct i2c_driver stk8312_driver
= {
690 .name
= STK8312_DRIVER_NAME
,
691 .pm
= STK8312_PM_OPS
,
692 .acpi_match_table
= ACPI_PTR(stk8312_acpi_id
),
694 .probe
= stk8312_probe
,
695 .remove
= stk8312_remove
,
696 .id_table
= stk8312_i2c_id
,
699 module_i2c_driver(stk8312_driver
);
701 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
702 MODULE_DESCRIPTION("STK8312 3-Axis Accelerometer driver");
703 MODULE_LICENSE("GPL v2");