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 0x01
41 #define STK8312_MODE_STANDBY 0x00
42 #define STK8312_DREADY_BIT 0x10
43 #define STK8312_INT_MODE 0xC0
44 #define STK8312_RNG_MASK 0xC0
45 #define STK8312_SR_MASK 0x07
46 #define STK8312_SR_400HZ_IDX 0
47 #define STK8312_RNG_SHIFT 6
48 #define STK8312_READ_RETRIES 16
49 #define STK8312_ALL_CHANNEL_MASK 7
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
& 0x80) && count
> 0);
152 ret
= i2c_smbus_read_byte_data(client
, STK8312_REG_OTPDATA
);
156 ret
= i2c_smbus_write_byte_data(data
->client
,
157 STK8312_REG_AFECTRL
, ret
);
165 dev_err(&client
->dev
, "failed to initialize sensor\n");
169 static int stk8312_set_mode(struct stk8312_data
*data
, u8 mode
)
172 struct i2c_client
*client
= data
->client
;
174 if (mode
== data
->mode
)
177 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_MODE
, mode
);
179 dev_err(&client
->dev
, "failed to change sensor mode\n");
184 if (mode
& STK8312_MODE_ACTIVE
) {
185 /* Need to run OTP sequence before entering active mode */
186 usleep_range(1000, 5000);
187 ret
= stk8312_otp_init(data
);
193 static int stk8312_set_interrupts(struct stk8312_data
*data
, u8 int_mask
)
197 struct i2c_client
*client
= data
->client
;
200 /* We need to go in standby mode to modify registers */
201 ret
= stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
205 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_INTSU
, int_mask
);
207 dev_err(&client
->dev
, "failed to set interrupts\n");
209 return stk8312_set_mode(data
, mode
);
212 static int stk8312_data_rdy_trigger_set_state(struct iio_trigger
*trig
,
215 struct iio_dev
*indio_dev
= iio_trigger_get_drvdata(trig
);
216 struct stk8312_data
*data
= iio_priv(indio_dev
);
220 ret
= stk8312_set_interrupts(data
, STK8312_DREADY_BIT
);
222 ret
= stk8312_set_interrupts(data
, 0x00);
225 dev_err(&data
->client
->dev
, "failed to set trigger state\n");
229 data
->dready_trigger_on
= state
;
234 static const struct iio_trigger_ops stk8312_trigger_ops
= {
235 .set_trigger_state
= stk8312_data_rdy_trigger_set_state
,
236 .owner
= THIS_MODULE
,
239 static int stk8312_set_sample_rate(struct stk8312_data
*data
, int rate
)
244 struct i2c_client
*client
= data
->client
;
246 if (rate
== data
->sample_rate_idx
)
250 /* We need to go in standby mode to modify registers */
251 ret
= stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
255 ret
= i2c_smbus_read_byte_data(client
, STK8312_REG_SR
);
257 dev_err(&client
->dev
, "failed to set sampling rate\n");
261 masked_reg
= (ret
& (~STK8312_SR_MASK
)) | rate
;
263 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_SR
, masked_reg
);
265 dev_err(&client
->dev
, "failed to set sampling rate\n");
267 data
->sample_rate_idx
= rate
;
269 return stk8312_set_mode(data
, mode
);
272 static int stk8312_set_range(struct stk8312_data
*data
, u8 range
)
277 struct i2c_client
*client
= data
->client
;
279 if (range
!= 1 && range
!= 2)
281 else if (range
== data
->range
)
285 /* We need to go in standby mode to modify registers */
286 ret
= stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
290 ret
= i2c_smbus_read_byte_data(client
, STK8312_REG_STH
);
292 dev_err(&client
->dev
, "failed to change sensor range\n");
296 masked_reg
= ret
& (~STK8312_RNG_MASK
);
297 masked_reg
|= range
<< STK8312_RNG_SHIFT
;
299 ret
= i2c_smbus_write_byte_data(client
, STK8312_REG_STH
, masked_reg
);
301 dev_err(&client
->dev
, "failed to change sensor range\n");
305 return stk8312_set_mode(data
, mode
);
308 static int stk8312_read_accel(struct stk8312_data
*data
, u8 address
)
311 struct i2c_client
*client
= data
->client
;
316 ret
= i2c_smbus_read_byte_data(client
, address
);
318 dev_err(&client
->dev
, "register read failed\n");
323 static int stk8312_read_raw(struct iio_dev
*indio_dev
,
324 struct iio_chan_spec
const *chan
,
325 int *val
, int *val2
, long mask
)
327 struct stk8312_data
*data
= iio_priv(indio_dev
);
331 case IIO_CHAN_INFO_RAW
:
332 if (iio_buffer_enabled(indio_dev
))
334 mutex_lock(&data
->lock
);
335 ret
= stk8312_set_mode(data
, data
->mode
| STK8312_MODE_ACTIVE
);
337 mutex_unlock(&data
->lock
);
340 ret
= stk8312_read_accel(data
, chan
->address
);
342 stk8312_set_mode(data
,
343 data
->mode
& (~STK8312_MODE_ACTIVE
));
344 mutex_unlock(&data
->lock
);
347 *val
= sign_extend32(ret
, 7);
348 stk8312_set_mode(data
, data
->mode
& (~STK8312_MODE_ACTIVE
));
349 mutex_unlock(&data
->lock
);
351 case IIO_CHAN_INFO_SCALE
:
352 *val
= stk8312_scale_table
[data
->range
- 1][0];
353 *val2
= stk8312_scale_table
[data
->range
- 1][1];
354 return IIO_VAL_INT_PLUS_MICRO
;
355 case IIO_CHAN_INFO_SAMP_FREQ
:
356 *val
= stk8312_samp_freq_table
[data
->sample_rate_idx
].val
;
357 *val2
= stk8312_samp_freq_table
[data
->sample_rate_idx
].val2
;
358 return IIO_VAL_INT_PLUS_MICRO
;
364 static int stk8312_write_raw(struct iio_dev
*indio_dev
,
365 struct iio_chan_spec
const *chan
,
366 int val
, int val2
, long mask
)
371 struct stk8312_data
*data
= iio_priv(indio_dev
);
374 case IIO_CHAN_INFO_SCALE
:
375 for (i
= 0; i
< ARRAY_SIZE(stk8312_scale_table
); i
++)
376 if (val
== stk8312_scale_table
[i
][0] &&
377 val2
== stk8312_scale_table
[i
][1]) {
384 mutex_lock(&data
->lock
);
385 ret
= stk8312_set_range(data
, index
);
386 mutex_unlock(&data
->lock
);
389 case IIO_CHAN_INFO_SAMP_FREQ
:
390 for (i
= 0; i
< ARRAY_SIZE(stk8312_samp_freq_table
); i
++)
391 if (val
== stk8312_samp_freq_table
[i
].val
&&
392 val2
== stk8312_samp_freq_table
[i
].val2
) {
398 mutex_lock(&data
->lock
);
399 ret
= stk8312_set_sample_rate(data
, index
);
400 mutex_unlock(&data
->lock
);
408 static const struct iio_info stk8312_info
= {
409 .driver_module
= THIS_MODULE
,
410 .read_raw
= stk8312_read_raw
,
411 .write_raw
= stk8312_write_raw
,
412 .attrs
= &stk8312_attribute_group
,
415 static irqreturn_t
stk8312_trigger_handler(int irq
, void *p
)
417 struct iio_poll_func
*pf
= p
;
418 struct iio_dev
*indio_dev
= pf
->indio_dev
;
419 struct stk8312_data
*data
= iio_priv(indio_dev
);
421 u8 buffer
[STK8312_ALL_CHANNEL_SIZE
];
423 mutex_lock(&data
->lock
);
425 * Do a bulk read if all channels are requested,
426 * from 0x00 (XOUT) to 0x02 (ZOUT)
428 if (*(indio_dev
->active_scan_mask
) == STK8312_ALL_CHANNEL_MASK
) {
429 ret
= i2c_smbus_read_i2c_block_data(data
->client
,
431 STK8312_ALL_CHANNEL_SIZE
,
433 if (ret
< STK8312_ALL_CHANNEL_SIZE
) {
434 dev_err(&data
->client
->dev
, "register read failed\n");
435 mutex_unlock(&data
->lock
);
438 data
->buffer
[0] = buffer
[0];
439 data
->buffer
[1] = buffer
[1];
440 data
->buffer
[2] = buffer
[2];
442 for_each_set_bit(bit
, indio_dev
->active_scan_mask
,
443 indio_dev
->masklength
) {
444 ret
= stk8312_read_accel(data
, bit
);
446 mutex_unlock(&data
->lock
);
449 data
->buffer
[i
++] = ret
;
452 mutex_unlock(&data
->lock
);
454 iio_push_to_buffers_with_timestamp(indio_dev
, data
->buffer
,
457 iio_trigger_notify_done(indio_dev
->trig
);
462 static irqreturn_t
stk8312_data_rdy_trig_poll(int irq
, void *private)
464 struct iio_dev
*indio_dev
= private;
465 struct stk8312_data
*data
= iio_priv(indio_dev
);
467 if (data
->dready_trigger_on
)
468 iio_trigger_poll(data
->dready_trig
);
473 static int stk8312_buffer_preenable(struct iio_dev
*indio_dev
)
475 struct stk8312_data
*data
= iio_priv(indio_dev
);
477 return stk8312_set_mode(data
, data
->mode
| STK8312_MODE_ACTIVE
);
480 static int stk8312_buffer_postdisable(struct iio_dev
*indio_dev
)
482 struct stk8312_data
*data
= iio_priv(indio_dev
);
484 return stk8312_set_mode(data
, data
->mode
& (~STK8312_MODE_ACTIVE
));
487 static const struct iio_buffer_setup_ops stk8312_buffer_setup_ops
= {
488 .preenable
= stk8312_buffer_preenable
,
489 .postenable
= iio_triggered_buffer_postenable
,
490 .predisable
= iio_triggered_buffer_predisable
,
491 .postdisable
= stk8312_buffer_postdisable
,
494 static int stk8312_gpio_probe(struct i2c_client
*client
)
497 struct gpio_desc
*gpio
;
505 /* data ready gpio interrupt pin */
506 gpio
= devm_gpiod_get_index(dev
, STK8312_GPIO
, 0, GPIOD_IN
);
508 dev_err(dev
, "acpi gpio get index failed\n");
509 return PTR_ERR(gpio
);
512 ret
= gpiod_to_irq(gpio
);
513 dev_dbg(dev
, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio
), ret
);
518 static int stk8312_probe(struct i2c_client
*client
,
519 const struct i2c_device_id
*id
)
522 struct iio_dev
*indio_dev
;
523 struct stk8312_data
*data
;
525 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
527 dev_err(&client
->dev
, "iio allocation failed!\n");
531 data
= iio_priv(indio_dev
);
532 data
->client
= client
;
533 i2c_set_clientdata(client
, indio_dev
);
534 mutex_init(&data
->lock
);
536 indio_dev
->dev
.parent
= &client
->dev
;
537 indio_dev
->info
= &stk8312_info
;
538 indio_dev
->name
= STK8312_DRIVER_NAME
;
539 indio_dev
->modes
= INDIO_DIRECT_MODE
;
540 indio_dev
->channels
= stk8312_channels
;
541 indio_dev
->num_channels
= ARRAY_SIZE(stk8312_channels
);
543 /* A software reset is recommended at power-on */
544 ret
= i2c_smbus_write_byte_data(data
->client
, STK8312_REG_RESET
, 0x00);
546 dev_err(&client
->dev
, "failed to reset sensor\n");
549 data
->sample_rate_idx
= STK8312_SR_400HZ_IDX
;
550 ret
= stk8312_set_range(data
, 1);
554 ret
= stk8312_set_mode(data
, STK8312_INT_MODE
| STK8312_MODE_ACTIVE
);
559 client
->irq
= stk8312_gpio_probe(client
);
561 if (client
->irq
>= 0) {
562 ret
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
563 stk8312_data_rdy_trig_poll
,
565 IRQF_TRIGGER_RISING
|
570 dev_err(&client
->dev
, "request irq %d failed\n",
575 data
->dready_trig
= devm_iio_trigger_alloc(&client
->dev
,
579 if (!data
->dready_trig
) {
584 data
->dready_trig
->dev
.parent
= &client
->dev
;
585 data
->dready_trig
->ops
= &stk8312_trigger_ops
;
586 iio_trigger_set_drvdata(data
->dready_trig
, indio_dev
);
587 ret
= iio_trigger_register(data
->dready_trig
);
589 dev_err(&client
->dev
, "iio trigger register failed\n");
594 ret
= iio_triggered_buffer_setup(indio_dev
,
595 iio_pollfunc_store_time
,
596 stk8312_trigger_handler
,
597 &stk8312_buffer_setup_ops
);
599 dev_err(&client
->dev
, "iio triggered buffer setup failed\n");
600 goto err_trigger_unregister
;
603 ret
= iio_device_register(indio_dev
);
605 dev_err(&client
->dev
, "device_register failed\n");
606 goto err_buffer_cleanup
;
612 iio_triggered_buffer_cleanup(indio_dev
);
613 err_trigger_unregister
:
614 if (data
->dready_trig
)
615 iio_trigger_unregister(data
->dready_trig
);
617 stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
621 static int stk8312_remove(struct i2c_client
*client
)
623 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
624 struct stk8312_data
*data
= iio_priv(indio_dev
);
626 iio_device_unregister(indio_dev
);
627 iio_triggered_buffer_cleanup(indio_dev
);
629 if (data
->dready_trig
)
630 iio_trigger_unregister(data
->dready_trig
);
632 return stk8312_set_mode(data
, STK8312_MODE_STANDBY
);
635 #ifdef CONFIG_PM_SLEEP
636 static int stk8312_suspend(struct device
*dev
)
638 struct stk8312_data
*data
;
640 data
= iio_priv(i2c_get_clientdata(to_i2c_client(dev
)));
642 return stk8312_set_mode(data
, data
->mode
& (~STK8312_MODE_ACTIVE
));
645 static int stk8312_resume(struct device
*dev
)
647 struct stk8312_data
*data
;
649 data
= iio_priv(i2c_get_clientdata(to_i2c_client(dev
)));
651 return stk8312_set_mode(data
, data
->mode
| STK8312_MODE_ACTIVE
);
654 static SIMPLE_DEV_PM_OPS(stk8312_pm_ops
, stk8312_suspend
, stk8312_resume
);
656 #define STK8312_PM_OPS (&stk8312_pm_ops)
658 #define STK8312_PM_OPS NULL
661 static const struct i2c_device_id stk8312_i2c_id
[] = {
665 MODULE_DEVICE_TABLE(i2c
, stk8312_i2c_id
);
667 static const struct acpi_device_id stk8312_acpi_id
[] = {
672 MODULE_DEVICE_TABLE(acpi
, stk8312_acpi_id
);
674 static struct i2c_driver stk8312_driver
= {
677 .pm
= STK8312_PM_OPS
,
678 .acpi_match_table
= ACPI_PTR(stk8312_acpi_id
),
680 .probe
= stk8312_probe
,
681 .remove
= stk8312_remove
,
682 .id_table
= stk8312_i2c_id
,
685 module_i2c_driver(stk8312_driver
);
687 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
688 MODULE_DESCRIPTION("STK8312 3-Axis Accelerometer driver");
689 MODULE_LICENSE("GPL v2");