2 * sca3000_core.c -- support VTI sca3000 series accelerometers via SPI
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 as published by
6 * the Free Software Foundation.
8 * Copyright (c) 2009 Jonathan Cameron <jic23@cam.ac.uk>
10 * See industrialio/accels/sca3000.h for comments.
13 #include <linux/interrupt.h>
14 #include <linux/gpio.h>
16 #include <linux/device.h>
17 #include <linux/slab.h>
18 #include <linux/kernel.h>
19 #include <linux/spi/spi.h>
20 #include <linux/sysfs.h>
23 #include "../ring_generic.h"
28 enum sca3000_variant
{
35 /* Note where option modes are not defined, the chip simply does not
37 * Other chips in the sca3000 series use i2c and are not included here.
39 * Some of these devices are only listed in the family data sheet and
40 * do not actually appear to be available.
42 static const struct sca3000_chip_info sca3000_spi_chip_info_tbl
[] = {
44 .name
= "sca3000-d01",
45 .scale
= " 0.0073575",
47 .measurement_mode_freq
= 250,
48 .option_mode_1
= SCA3000_OP_MODE_BYPASS
,
49 .option_mode_1_freq
= 250,
51 .name
= "sca3000-e02",
53 .measurement_mode_freq
= 125,
54 .option_mode_1
= SCA3000_OP_MODE_NARROW
,
55 .option_mode_1_freq
= 63,
57 .name
= "sca3000-e04",
59 .measurement_mode_freq
= 100,
60 .option_mode_1
= SCA3000_OP_MODE_NARROW
,
61 .option_mode_1_freq
= 50,
62 .option_mode_2
= SCA3000_OP_MODE_WIDE
,
63 .option_mode_2_freq
= 400,
65 .name
= "sca3000-e05",
67 .measurement_mode_freq
= 200,
68 .option_mode_1
= SCA3000_OP_MODE_NARROW
,
69 .option_mode_1_freq
= 50,
70 .option_mode_2
= SCA3000_OP_MODE_WIDE
,
71 .option_mode_2_freq
= 400,
76 int sca3000_write_reg(struct sca3000_state
*st
, u8 address
, u8 val
)
78 struct spi_transfer xfer
= {
84 struct spi_message msg
;
86 st
->tx
[0] = SCA3000_WRITE_REG(address
);
88 spi_message_init(&msg
);
89 spi_message_add_tail(&xfer
, &msg
);
91 return spi_sync(st
->us
, &msg
);
94 int sca3000_read_data(struct sca3000_state
*st
,
95 uint8_t reg_address_high
,
100 struct spi_message msg
;
101 struct spi_transfer xfer
= {
108 *rx_p
= kmalloc(len
+ 1, GFP_KERNEL
);
114 st
->tx
[0] = SCA3000_READ_REG(reg_address_high
);
115 spi_message_init(&msg
);
116 spi_message_add_tail(&xfer
, &msg
);
118 ret
= spi_sync(st
->us
, &msg
);
121 dev_err(get_device(&st
->us
->dev
), "problem reading register");
133 * sca3000_reg_lock_on() test if the ctrl register lock is on
137 static int sca3000_reg_lock_on(struct sca3000_state
*st
)
142 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_STATUS
, &rx
, 1);
146 ret
= !(rx
[1] & SCA3000_LOCKED
);
153 * __sca3000_unlock_reg_lock() unlock the control registers
155 * Note the device does not appear to support doing this in a single transfer.
156 * This should only ever be used as part of ctrl reg read.
157 * Lock must be held before calling this
159 static int __sca3000_unlock_reg_lock(struct sca3000_state
*st
)
161 struct spi_message msg
;
162 struct spi_transfer xfer
[3] = {
172 .tx_buf
= st
->tx
+ 2,
177 .tx_buf
= st
->tx
+ 4,
180 st
->tx
[0] = SCA3000_WRITE_REG(SCA3000_REG_ADDR_UNLOCK
);
182 st
->tx
[2] = SCA3000_WRITE_REG(SCA3000_REG_ADDR_UNLOCK
);
184 st
->tx
[4] = SCA3000_WRITE_REG(SCA3000_REG_ADDR_UNLOCK
);
186 spi_message_init(&msg
);
187 spi_message_add_tail(&xfer
[0], &msg
);
188 spi_message_add_tail(&xfer
[1], &msg
);
189 spi_message_add_tail(&xfer
[2], &msg
);
191 return spi_sync(st
->us
, &msg
);
195 * sca3000_write_ctrl_reg() write to a lock protect ctrl register
196 * @sel: selects which registers we wish to write to
197 * @val: the value to be written
199 * Certain control registers are protected against overwriting by the lock
200 * register and use a shared write address. This function allows writing of
204 static int sca3000_write_ctrl_reg(struct sca3000_state
*st
,
211 ret
= sca3000_reg_lock_on(st
);
215 ret
= __sca3000_unlock_reg_lock(st
);
220 /* Set the control select register */
221 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_CTRL_SEL
, sel
);
225 /* Write the actual value into the register */
226 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_CTRL_DATA
, val
);
232 /* Crucial that lock is called before calling this */
234 * sca3000_read_ctrl_reg() read from lock protected control register.
238 static int sca3000_read_ctrl_reg(struct sca3000_state
*st
,
244 ret
= sca3000_reg_lock_on(st
);
248 ret
= __sca3000_unlock_reg_lock(st
);
252 /* Set the control select register */
253 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_CTRL_SEL
, ctrl_reg
);
256 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_CTRL_DATA
, rx_p
, 1);
264 * sca3000_check_status() check the status register
266 * Only used for debugging purposes
268 static int sca3000_check_status(struct device
*dev
)
272 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
273 struct sca3000_state
*st
= indio_dev
->dev_data
;
275 mutex_lock(&st
->lock
);
276 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_STATUS
, &rx
, 1);
279 if (rx
[1] & SCA3000_EEPROM_CS_ERROR
)
280 dev_err(dev
, "eeprom error\n");
281 if (rx
[1] & SCA3000_SPI_FRAME_ERROR
)
282 dev_err(dev
, "Previous SPI Frame was corrupt\n");
286 mutex_unlock(&st
->lock
);
289 #endif /* SCA3000_DEBUG */
292 * sca3000_read_13bit_signed() sysfs interface to read 13 bit signed registers
294 * These are described as signed 12 bit on the data sheet, which appears
295 * to be a conventional 2's complement 13 bit.
297 static ssize_t
sca3000_read_13bit_signed(struct device
*dev
,
298 struct device_attribute
*attr
,
303 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
305 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
306 struct sca3000_state
*st
= indio_dev
->dev_data
;
308 mutex_lock(&st
->lock
);
309 ret
= sca3000_read_data(st
, this_attr
->address
, &rx
, 2);
312 val
= sca3000_13bit_convert(rx
[1], rx
[2]);
313 len
+= sprintf(buf
+ len
, "%d\n", val
);
316 mutex_unlock(&st
->lock
);
318 return ret
? ret
: len
;
321 static ssize_t
sca3000_show_scale(struct device
*dev
,
322 struct device_attribute
*attr
,
325 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
326 struct sca3000_state
*st
= dev_info
->dev_data
;
327 return sprintf(buf
, "%s\n", st
->info
->scale
);
330 static ssize_t
sca3000_show_name(struct device
*dev
,
331 struct device_attribute
*attr
,
334 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
335 struct sca3000_state
*st
= dev_info
->dev_data
;
336 return sprintf(buf
, "%s\n", st
->info
->name
);
339 * sca3000_show_reg() - sysfs interface to read the chip revision number
341 static ssize_t
sca3000_show_rev(struct device
*dev
,
342 struct device_attribute
*attr
,
346 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
347 struct sca3000_state
*st
= dev_info
->dev_data
;
351 mutex_lock(&st
->lock
);
352 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_REVID
, &rx
, 1);
355 len
+= sprintf(buf
+ len
,
356 "major=%d, minor=%d\n",
357 rx
[1] & SCA3000_REVID_MAJOR_MASK
,
358 rx
[1] & SCA3000_REVID_MINOR_MASK
);
362 mutex_unlock(&st
->lock
);
364 return ret
? ret
: len
;
368 * sca3000_show_available_measurement_modes() display available modes
370 * This is all read from chip specific data in the driver. Not all
371 * of the sca3000 series support modes other than normal.
374 sca3000_show_available_measurement_modes(struct device
*dev
,
375 struct device_attribute
*attr
,
378 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
379 struct sca3000_state
*st
= dev_info
->dev_data
;
382 len
+= sprintf(buf
+ len
, "0 - normal mode");
383 switch (st
->info
->option_mode_1
) {
384 case SCA3000_OP_MODE_NARROW
:
385 len
+= sprintf(buf
+ len
, ", 1 - narrow mode");
387 case SCA3000_OP_MODE_BYPASS
:
388 len
+= sprintf(buf
+ len
, ", 1 - bypass mode");
391 switch (st
->info
->option_mode_2
) {
392 case SCA3000_OP_MODE_WIDE
:
393 len
+= sprintf(buf
+ len
, ", 2 - wide mode");
396 /* always supported */
397 len
+= sprintf(buf
+ len
, " 3 - motion detection\n");
403 * sca3000_show_measurmenet_mode() sysfs read of current mode
406 sca3000_show_measurement_mode(struct device
*dev
,
407 struct device_attribute
*attr
,
410 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
411 struct sca3000_state
*st
= dev_info
->dev_data
;
415 mutex_lock(&st
->lock
);
416 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_MODE
, &rx
, 1);
419 /* mask bottom 2 bits - only ones that are relevant */
422 case SCA3000_MEAS_MODE_NORMAL
:
423 len
+= sprintf(buf
+ len
, "0 - normal mode\n");
425 case SCA3000_MEAS_MODE_MOT_DET
:
426 len
+= sprintf(buf
+ len
, "3 - motion detection\n");
428 case SCA3000_MEAS_MODE_OP_1
:
429 switch (st
->info
->option_mode_1
) {
430 case SCA3000_OP_MODE_NARROW
:
431 len
+= sprintf(buf
+ len
, "1 - narrow mode\n");
433 case SCA3000_OP_MODE_BYPASS
:
434 len
+= sprintf(buf
+ len
, "1 - bypass mode\n");
438 case SCA3000_MEAS_MODE_OP_2
:
439 switch (st
->info
->option_mode_2
) {
440 case SCA3000_OP_MODE_WIDE
:
441 len
+= sprintf(buf
+ len
, "2 - wide mode\n");
448 mutex_unlock(&st
->lock
);
450 return ret
? ret
: len
;
454 * sca3000_store_measurement_mode() set the current mode
457 sca3000_store_measurement_mode(struct device
*dev
,
458 struct device_attribute
*attr
,
462 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
463 struct sca3000_state
*st
= dev_info
->dev_data
;
469 mutex_lock(&st
->lock
);
470 ret
= strict_strtol(buf
, 10, &val
);
473 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_MODE
, &rx
, 1);
477 rx
[1] |= (val
& mask
);
478 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_MODE
, rx
[1]);
481 mutex_unlock(&st
->lock
);
488 mutex_unlock(&st
->lock
);
494 /* Not even vaguely standard attributes so defined here rather than
495 * in the relevant IIO core headers
497 static IIO_DEVICE_ATTR(measurement_mode_available
, S_IRUGO
,
498 sca3000_show_available_measurement_modes
,
501 static IIO_DEVICE_ATTR(measurement_mode
, S_IRUGO
| S_IWUSR
,
502 sca3000_show_measurement_mode
,
503 sca3000_store_measurement_mode
,
506 /* More standard attributes */
508 static IIO_DEV_ATTR_NAME(sca3000_show_name
);
509 static IIO_DEV_ATTR_REV(sca3000_show_rev
);
510 static IIO_DEVICE_ATTR(accel_scale
, S_IRUGO
, sca3000_show_scale
,
513 static IIO_DEV_ATTR_ACCEL_X(sca3000_read_13bit_signed
,
514 SCA3000_REG_ADDR_X_MSB
);
515 static IIO_DEV_ATTR_ACCEL_Y(sca3000_read_13bit_signed
,
516 SCA3000_REG_ADDR_Y_MSB
);
517 static IIO_DEV_ATTR_ACCEL_Z(sca3000_read_13bit_signed
,
518 SCA3000_REG_ADDR_Z_MSB
);
522 * sca3000_read_av_freq() sysfs function to get available frequencies
524 * The later modes are only relevant to the ring buffer - and depend on current
525 * mode. Note that data sheet gives rather wide tolerances for these so integer
526 * division will give good enough answer and not all chips have them specified
529 static ssize_t
sca3000_read_av_freq(struct device
*dev
,
530 struct device_attribute
*attr
,
533 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
534 struct sca3000_state
*st
= indio_dev
->dev_data
;
537 mutex_lock(&st
->lock
);
538 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_MODE
, &rx
, 1);
539 mutex_unlock(&st
->lock
);
544 case SCA3000_MEAS_MODE_NORMAL
:
545 len
+= sprintf(buf
+ len
, "%d %d %d\n",
546 st
->info
->measurement_mode_freq
,
547 st
->info
->measurement_mode_freq
/2,
548 st
->info
->measurement_mode_freq
/4);
550 case SCA3000_MEAS_MODE_OP_1
:
551 len
+= sprintf(buf
+ len
, "%d %d %d\n",
552 st
->info
->option_mode_1_freq
,
553 st
->info
->option_mode_1_freq
/2,
554 st
->info
->option_mode_1_freq
/4);
556 case SCA3000_MEAS_MODE_OP_2
:
557 len
+= sprintf(buf
+ len
, "%d %d %d\n",
558 st
->info
->option_mode_2_freq
,
559 st
->info
->option_mode_2_freq
/2,
560 st
->info
->option_mode_2_freq
/4);
569 * __sca3000_get_base_frequency() obtain mode specific base frequency
573 static inline int __sca3000_get_base_freq(struct sca3000_state
*st
,
574 const struct sca3000_chip_info
*info
,
580 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_MODE
, &rx
, 1);
583 switch (0x03 & rx
[1]) {
584 case SCA3000_MEAS_MODE_NORMAL
:
585 *base_freq
= info
->measurement_mode_freq
;
587 case SCA3000_MEAS_MODE_OP_1
:
588 *base_freq
= info
->option_mode_1_freq
;
590 case SCA3000_MEAS_MODE_OP_2
:
591 *base_freq
= info
->option_mode_2_freq
;
600 * sca3000_read_frequency() sysfs interface to get the current frequency
602 static ssize_t
sca3000_read_frequency(struct device
*dev
,
603 struct device_attribute
*attr
,
606 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
607 struct sca3000_state
*st
= indio_dev
->dev_data
;
608 int ret
, len
= 0, base_freq
= 0;
610 mutex_lock(&st
->lock
);
611 ret
= __sca3000_get_base_freq(st
, st
->info
, &base_freq
);
614 ret
= sca3000_read_ctrl_reg(st
, SCA3000_REG_CTRL_SEL_OUT_CTRL
, &rx
);
615 mutex_unlock(&st
->lock
);
619 switch (rx
[1]&0x03) {
622 len
= sprintf(buf
, "%d\n", base_freq
);
625 len
= sprintf(buf
, "%d\n", base_freq
/2);
628 len
= sprintf(buf
, "%d\n", base_freq
/4);
634 mutex_unlock(&st
->lock
);
640 * sca3000_set_frequency() sysfs interface to set the current frequency
642 static ssize_t
sca3000_set_frequency(struct device
*dev
,
643 struct device_attribute
*attr
,
647 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
648 struct sca3000_state
*st
= indio_dev
->dev_data
;
649 int ret
, base_freq
= 0;
653 ret
= strict_strtol(buf
, 10, &val
);
657 mutex_lock(&st
->lock
);
658 /* What mode are we in? */
659 ret
= __sca3000_get_base_freq(st
, st
->info
, &base_freq
);
661 goto error_free_lock
;
663 ret
= sca3000_read_ctrl_reg(st
, SCA3000_REG_CTRL_SEL_OUT_CTRL
, &rx
);
665 goto error_free_lock
;
669 if (val
== base_freq
/2) {
670 rx
[1] |= SCA3000_OUT_CTRL_BUF_DIV_2
;
671 } else if (val
== base_freq
/4) {
672 rx
[1] |= SCA3000_OUT_CTRL_BUF_DIV_4
;
673 } else if (val
!= base_freq
) {
675 goto error_free_lock
;
677 ret
= sca3000_write_ctrl_reg(st
, SCA3000_REG_CTRL_SEL_OUT_CTRL
, rx
[1]);
679 mutex_unlock(&st
->lock
);
681 return ret
? ret
: len
;
684 /* Should only really be registered if ring buffer support is compiled in.
685 * Does no harm however and doing it right would add a fair bit of complexity
687 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sca3000_read_av_freq
);
689 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR
| S_IRUGO
,
690 sca3000_read_frequency
,
691 sca3000_set_frequency
);
695 * sca3000_read_temp() sysfs interface to get the temperature when available
697 * The alignment of data in here is downright odd. See data sheet.
698 * Converting this into a meaningful value is left to inline functions in
699 * userspace part of header.
701 static ssize_t
sca3000_read_temp(struct device
*dev
,
702 struct device_attribute
*attr
,
705 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
706 struct sca3000_state
*st
= indio_dev
->dev_data
;
710 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_TEMP_MSB
, &rx
, 2);
713 val
= ((rx
[1]&0x3F) << 3) | ((rx
[2] & 0xE0) >> 5);
714 len
+= sprintf(buf
+ len
, "%d\n", val
);
722 static IIO_DEV_ATTR_TEMP_RAW(sca3000_read_temp
);
724 static IIO_CONST_ATTR_TEMP_SCALE("0.555556");
725 static IIO_CONST_ATTR_TEMP_OFFSET("-214.6");
728 * sca3000_show_thresh() sysfs query of a threshold
730 static ssize_t
sca3000_show_thresh(struct device
*dev
,
731 struct device_attribute
*attr
,
734 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
735 struct sca3000_state
*st
= indio_dev
->dev_data
;
736 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
740 mutex_lock(&st
->lock
);
741 ret
= sca3000_read_ctrl_reg(st
,
744 mutex_unlock(&st
->lock
);
747 len
+= sprintf(buf
+ len
, "%d\n", rx
[1]);
754 * sca3000_write_thresh() sysfs control of threshold
756 static ssize_t
sca3000_write_thresh(struct device
*dev
,
757 struct device_attribute
*attr
,
761 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
762 struct sca3000_state
*st
= indio_dev
->dev_data
;
763 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
767 ret
= strict_strtol(buf
, 10, &val
);
770 mutex_lock(&st
->lock
);
771 ret
= sca3000_write_ctrl_reg(st
, this_attr
->address
, val
);
772 mutex_unlock(&st
->lock
);
774 return ret
? ret
: len
;
777 static IIO_DEVICE_ATTR(accel_x_raw_mag_rising_value
,
780 sca3000_write_thresh
,
781 SCA3000_REG_CTRL_SEL_MD_X_TH
);
783 static IIO_DEVICE_ATTR(accel_y_raw_mag_rising_value
,
786 sca3000_write_thresh
,
787 SCA3000_REG_CTRL_SEL_MD_Y_TH
);
789 static IIO_DEVICE_ATTR(accel_z_raw_mag_rising_value
,
792 sca3000_write_thresh
,
793 SCA3000_REG_CTRL_SEL_MD_Z_TH
);
795 static struct attribute
*sca3000_attributes
[] = {
796 &iio_dev_attr_name
.dev_attr
.attr
,
797 &iio_dev_attr_revision
.dev_attr
.attr
,
798 &iio_dev_attr_accel_scale
.dev_attr
.attr
,
799 &iio_dev_attr_accel_x_raw
.dev_attr
.attr
,
800 &iio_dev_attr_accel_y_raw
.dev_attr
.attr
,
801 &iio_dev_attr_accel_z_raw
.dev_attr
.attr
,
802 &iio_dev_attr_measurement_mode_available
.dev_attr
.attr
,
803 &iio_dev_attr_measurement_mode
.dev_attr
.attr
,
804 &iio_dev_attr_sampling_frequency_available
.dev_attr
.attr
,
805 &iio_dev_attr_sampling_frequency
.dev_attr
.attr
,
809 static struct attribute
*sca3000_attributes_with_temp
[] = {
810 &iio_dev_attr_name
.dev_attr
.attr
,
811 &iio_dev_attr_revision
.dev_attr
.attr
,
812 &iio_dev_attr_accel_scale
.dev_attr
.attr
,
813 &iio_dev_attr_accel_x_raw
.dev_attr
.attr
,
814 &iio_dev_attr_accel_y_raw
.dev_attr
.attr
,
815 &iio_dev_attr_accel_z_raw
.dev_attr
.attr
,
816 &iio_dev_attr_measurement_mode_available
.dev_attr
.attr
,
817 &iio_dev_attr_measurement_mode
.dev_attr
.attr
,
818 &iio_dev_attr_sampling_frequency_available
.dev_attr
.attr
,
819 &iio_dev_attr_sampling_frequency
.dev_attr
.attr
,
820 /* Only present if temp sensor is */
821 &iio_dev_attr_temp_raw
.dev_attr
.attr
,
822 &iio_const_attr_temp_offset
.dev_attr
.attr
,
823 &iio_const_attr_temp_scale
.dev_attr
.attr
,
827 static const struct attribute_group sca3000_attribute_group
= {
828 .attrs
= sca3000_attributes
,
831 static const struct attribute_group sca3000_attribute_group_with_temp
= {
832 .attrs
= sca3000_attributes_with_temp
,
835 /* RING RELATED interrupt handler */
836 /* depending on event, push to the ring buffer event chrdev or the event one */
839 * sca3000_interrupt_handler_bh() - handling ring and non ring events
841 * This function is complicated by the fact that the devices can signify ring
842 * and non ring events via the same interrupt line and they can only
843 * be distinguished via a read of the relevant status register.
845 static void sca3000_interrupt_handler_bh(struct work_struct
*work_s
)
847 struct sca3000_state
*st
848 = container_of(work_s
, struct sca3000_state
,
849 interrupt_handler_ws
);
853 /* Could lead if badly timed to an extra read of status reg,
854 * but ensures no interrupt is missed.
856 enable_irq(st
->us
->irq
);
857 mutex_lock(&st
->lock
);
858 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_INT_STATUS
,
860 mutex_unlock(&st
->lock
);
864 sca3000_ring_int_process(rx
[1], st
->indio_dev
->ring
);
866 if (rx
[1] & SCA3000_INT_STATUS_FREE_FALL
)
867 iio_push_event(st
->indio_dev
, 0,
868 IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL
,
870 IIO_EV_MOD_X_AND_Y_AND_Z
,
875 if (rx
[1] & SCA3000_INT_STATUS_Y_TRIGGER
)
876 iio_push_event(st
->indio_dev
, 0,
877 IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL
,
884 if (rx
[1] & SCA3000_INT_STATUS_X_TRIGGER
)
885 iio_push_event(st
->indio_dev
, 0,
886 IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL
,
893 if (rx
[1] & SCA3000_INT_STATUS_Z_TRIGGER
)
894 iio_push_event(st
->indio_dev
, 0,
895 IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL
,
908 * sca3000_handler_th() handles all interrupt events from device
910 * These devices deploy unified interrupt status registers meaning
911 * all interrupts must be handled together
913 static int sca3000_handler_th(struct iio_dev
*dev_info
,
918 struct sca3000_state
*st
= dev_info
->dev_data
;
920 st
->last_timestamp
= timestamp
;
921 schedule_work(&st
->interrupt_handler_ws
);
927 * sca3000_query_mo_det() is motion detection enabled for this axis
929 * First queries if motion detection is enabled and then if this axis is
932 static ssize_t
sca3000_query_mo_det(struct device
*dev
,
933 struct device_attribute
*attr
,
936 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
->parent
);
937 struct sca3000_state
*st
= indio_dev
->dev_data
;
938 struct iio_event_attr
*this_attr
= to_iio_event_attr(attr
);
941 u8 protect_mask
= 0x03;
943 /* read current value of mode register */
944 mutex_lock(&st
->lock
);
945 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_MODE
, &rx
, 1);
949 if ((rx
[1]&protect_mask
) != SCA3000_MEAS_MODE_MOT_DET
)
950 len
+= sprintf(buf
+ len
, "0\n");
953 ret
= sca3000_read_ctrl_reg(st
,
954 SCA3000_REG_CTRL_SEL_MD_CTRL
,
958 /* only supporting logical or's for now */
959 len
+= sprintf(buf
+ len
, "%d\n",
960 (rx
[1] & this_attr
->mask
) ? 1 : 0);
964 mutex_unlock(&st
->lock
);
966 return ret
? ret
: len
;
969 * sca3000_query_free_fall_mode() is free fall mode enabled
971 static ssize_t
sca3000_query_free_fall_mode(struct device
*dev
,
972 struct device_attribute
*attr
,
977 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
978 struct sca3000_state
*st
= indio_dev
->dev_data
;
980 mutex_lock(&st
->lock
);
981 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_MODE
, &rx
, 1);
982 mutex_unlock(&st
->lock
);
985 len
= sprintf(buf
, "%d\n",
986 !!(rx
[1] & SCA3000_FREE_FALL_DETECT
));
992 * sca3000_query_ring_int() is the hardware ring status interrupt enabled
994 static ssize_t
sca3000_query_ring_int(struct device
*dev
,
995 struct device_attribute
*attr
,
998 struct iio_event_attr
*this_attr
= to_iio_event_attr(attr
);
1001 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
->parent
);
1002 struct sca3000_state
*st
= indio_dev
->dev_data
;
1003 mutex_lock(&st
->lock
);
1004 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_INT_MASK
, &rx
, 1);
1005 mutex_unlock(&st
->lock
);
1008 len
= sprintf(buf
, "%d\n", (rx
[1] & this_attr
->mask
) ? 1 : 0);
1014 * sca3000_set_ring_int() set state of ring status interrupt
1016 static ssize_t
sca3000_set_ring_int(struct device
*dev
,
1017 struct device_attribute
*attr
,
1021 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
->parent
);
1022 struct sca3000_state
*st
= indio_dev
->dev_data
;
1023 struct iio_event_attr
*this_attr
= to_iio_event_attr(attr
);
1029 mutex_lock(&st
->lock
);
1030 ret
= strict_strtol(buf
, 10, &val
);
1033 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_INT_MASK
, &rx
, 1);
1037 ret
= sca3000_write_reg(st
,
1038 SCA3000_REG_ADDR_INT_MASK
,
1039 rx
[1] | this_attr
->mask
);
1041 ret
= sca3000_write_reg(st
,
1042 SCA3000_REG_ADDR_INT_MASK
,
1043 rx
[1] & ~this_attr
->mask
);
1046 mutex_unlock(&st
->lock
);
1048 return ret
? ret
: len
;
1052 * sca3000_set_free_fall_mode() simple on off control for free fall int
1054 * In these chips the free fall detector should send an interrupt if
1055 * the device falls more than 25cm. This has not been tested due
1056 * to fragile wiring.
1059 static ssize_t
sca3000_set_free_fall_mode(struct device
*dev
,
1060 struct device_attribute
*attr
,
1064 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
1065 struct sca3000_state
*st
= indio_dev
->dev_data
;
1069 u8 protect_mask
= SCA3000_FREE_FALL_DETECT
;
1071 mutex_lock(&st
->lock
);
1072 ret
= strict_strtol(buf
, 10, &val
);
1076 /* read current value of mode register */
1077 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_MODE
, &rx
, 1);
1081 /*if off and should be on*/
1082 if (val
&& !(rx
[1] & protect_mask
))
1083 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_MODE
,
1084 (rx
[1] | SCA3000_FREE_FALL_DETECT
));
1085 /* if on and should be off */
1086 else if (!val
&& (rx
[1]&protect_mask
))
1087 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_MODE
,
1088 (rx
[1] & ~protect_mask
));
1092 mutex_unlock(&st
->lock
);
1094 return ret
? ret
: len
;
1098 * sca3000_set_mo_det() simple on off control for motion detector
1100 * This is a per axis control, but enabling any will result in the
1101 * motion detector unit being enabled.
1102 * N.B. enabling motion detector stops normal data acquisition.
1103 * There is a complexity in knowing which mode to return to when
1104 * this mode is disabled. Currently normal mode is assumed.
1106 static ssize_t
sca3000_set_mo_det(struct device
*dev
,
1107 struct device_attribute
*attr
,
1111 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
->parent
);
1112 struct sca3000_state
*st
= indio_dev
->dev_data
;
1113 struct iio_event_attr
*this_attr
= to_iio_event_attr(attr
);
1117 u8 protect_mask
= 0x03;
1118 ret
= strict_strtol(buf
, 10, &val
);
1122 mutex_lock(&st
->lock
);
1123 /* First read the motion detector config to find out if
1125 ret
= sca3000_read_ctrl_reg(st
,
1126 SCA3000_REG_CTRL_SEL_MD_CTRL
,
1130 /* Off and should be on */
1131 if (val
&& !(rx
[1] & this_attr
->mask
)) {
1132 ret
= sca3000_write_ctrl_reg(st
,
1133 SCA3000_REG_CTRL_SEL_MD_CTRL
,
1134 rx
[1] | this_attr
->mask
);
1136 goto exit_point_free_rx
;
1137 st
->mo_det_use_count
++;
1138 } else if (!val
&& (rx
[1]&this_attr
->mask
)) {
1139 ret
= sca3000_write_ctrl_reg(st
,
1140 SCA3000_REG_CTRL_SEL_MD_CTRL
,
1141 rx
[1] & ~(this_attr
->mask
));
1143 goto exit_point_free_rx
;
1144 st
->mo_det_use_count
--;
1145 } else /* relies on clean state for device on boot */
1146 goto exit_point_free_rx
;
1148 /* read current value of mode register */
1149 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_MODE
, &rx
, 1);
1152 /*if off and should be on*/
1153 if ((st
->mo_det_use_count
)
1154 && ((rx
[1]&protect_mask
) != SCA3000_MEAS_MODE_MOT_DET
))
1155 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_MODE
,
1156 (rx
[1] & ~protect_mask
)
1157 | SCA3000_MEAS_MODE_MOT_DET
);
1158 /* if on and should be off */
1159 else if (!(st
->mo_det_use_count
)
1160 && ((rx
[1]&protect_mask
) == SCA3000_MEAS_MODE_MOT_DET
))
1161 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_MODE
,
1162 (rx
[1] & ~protect_mask
));
1166 mutex_unlock(&st
->lock
);
1168 return ret
? ret
: len
;
1171 /* Shared event handler for all events as single event status register */
1172 IIO_EVENT_SH(all
, &sca3000_handler_th
);
1174 /* Free fall detector related event attribute */
1175 IIO_EVENT_ATTR_NAMED_SH(accel_xayaz_mag_falling_en
,
1176 accel_x
&y
&z_mag_falling_en
,
1178 sca3000_query_free_fall_mode
,
1179 sca3000_set_free_fall_mode
,
1182 IIO_CONST_ATTR_NAMED(accel_xayaz_mag_falling_period
,
1183 accel_x
&y
&z_mag_falling_period
,
1186 /* Motion detector related event attributes */
1187 IIO_EVENT_ATTR_SH(accel_x_mag_rising_en
,
1189 sca3000_query_mo_det
,
1191 SCA3000_MD_CTRL_OR_X
);
1193 IIO_EVENT_ATTR_SH(accel_y_mag_rising_en
,
1195 sca3000_query_mo_det
,
1197 SCA3000_MD_CTRL_OR_Y
);
1199 IIO_EVENT_ATTR_SH(accel_z_mag_rising_en
,
1201 sca3000_query_mo_det
,
1203 SCA3000_MD_CTRL_OR_Z
);
1205 /* Hardware ring buffer related event attributes */
1206 IIO_EVENT_ATTR_RING_50_FULL_SH(iio_event_all
,
1207 sca3000_query_ring_int
,
1208 sca3000_set_ring_int
,
1209 SCA3000_INT_MASK_RING_HALF
);
1211 IIO_EVENT_ATTR_RING_75_FULL_SH(iio_event_all
,
1212 sca3000_query_ring_int
,
1213 sca3000_set_ring_int
,
1214 SCA3000_INT_MASK_RING_THREE_QUARTER
);
1216 static struct attribute
*sca3000_event_attributes
[] = {
1217 &iio_event_attr_accel_xayaz_mag_falling_en
.dev_attr
.attr
,
1218 &iio_const_attr_accel_xayaz_mag_falling_period
.dev_attr
.attr
,
1219 &iio_event_attr_accel_x_mag_rising_en
.dev_attr
.attr
,
1220 &iio_dev_attr_accel_x_raw_mag_rising_value
.dev_attr
.attr
,
1221 &iio_event_attr_accel_y_mag_rising_en
.dev_attr
.attr
,
1222 &iio_dev_attr_accel_y_raw_mag_rising_value
.dev_attr
.attr
,
1223 &iio_event_attr_accel_z_mag_rising_en
.dev_attr
.attr
,
1224 &iio_dev_attr_accel_z_raw_mag_rising_value
.dev_attr
.attr
,
1225 &iio_event_attr_ring_50_full
.dev_attr
.attr
,
1226 &iio_event_attr_ring_75_full
.dev_attr
.attr
,
1230 static struct attribute_group sca3000_event_attribute_group
= {
1231 .attrs
= sca3000_event_attributes
,
1235 * sca3000_clean_setup() get the device into a predictable state
1237 * Devices use flash memory to store many of the register values
1238 * and hence can come up in somewhat unpredictable states.
1239 * Hence reset everything on driver load.
1241 static int sca3000_clean_setup(struct sca3000_state
*st
)
1246 mutex_lock(&st
->lock
);
1247 /* Ensure all interrupts have been acknowledged */
1248 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_INT_STATUS
, &rx
, 1);
1253 /* Turn off all motion detection channels */
1254 ret
= sca3000_read_ctrl_reg(st
,
1255 SCA3000_REG_CTRL_SEL_MD_CTRL
,
1259 ret
= sca3000_write_ctrl_reg(st
,
1260 SCA3000_REG_CTRL_SEL_MD_CTRL
,
1261 rx
[1] & SCA3000_MD_CTRL_PROT_MASK
);
1266 /* Disable ring buffer */
1267 sca3000_read_ctrl_reg(st
,
1268 SCA3000_REG_CTRL_SEL_OUT_CTRL
,
1270 /* Frequency of ring buffer sampling deliberately restricted to make
1271 * debugging easier - add control of this later */
1272 ret
= sca3000_write_ctrl_reg(st
,
1273 SCA3000_REG_CTRL_SEL_OUT_CTRL
,
1274 (rx
[1] & SCA3000_OUT_CTRL_PROT_MASK
)
1275 | SCA3000_OUT_CTRL_BUF_X_EN
1276 | SCA3000_OUT_CTRL_BUF_Y_EN
1277 | SCA3000_OUT_CTRL_BUF_Z_EN
1278 | SCA3000_OUT_CTRL_BUF_DIV_4
);
1283 /* Enable interrupts, relevant to mode and set up as active low */
1284 ret
= sca3000_read_data(st
,
1285 SCA3000_REG_ADDR_INT_MASK
,
1289 ret
= sca3000_write_reg(st
,
1290 SCA3000_REG_ADDR_INT_MASK
,
1291 (rx
[1] & SCA3000_INT_MASK_PROT_MASK
)
1292 | SCA3000_INT_MASK_ACTIVE_LOW
);
1296 /* Select normal measurement mode, free fall off, ring off */
1297 /* Ring in 12 bit mode - it is fine to overwrite reserved bits 3,5
1298 * as that occurs in one of the example on the datasheet */
1299 ret
= sca3000_read_data(st
,
1300 SCA3000_REG_ADDR_MODE
,
1304 ret
= sca3000_write_reg(st
,
1305 SCA3000_REG_ADDR_MODE
,
1306 (rx
[1] & SCA3000_MODE_PROT_MASK
));
1311 mutex_unlock(&st
->lock
);
1315 static int __devinit
__sca3000_probe(struct spi_device
*spi
,
1316 enum sca3000_variant variant
)
1318 int ret
, regdone
= 0;
1319 struct sca3000_state
*st
;
1321 st
= kzalloc(sizeof(struct sca3000_state
), GFP_KERNEL
);
1326 spi_set_drvdata(spi
, st
);
1328 st
->tx
= kmalloc(sizeof(*st
->tx
)*6, GFP_KERNEL
);
1329 if (st
->tx
== NULL
) {
1331 goto error_clear_st
;
1333 st
->rx
= kmalloc(sizeof(*st
->rx
)*3, GFP_KERNEL
);
1334 if (st
->rx
== NULL
) {
1339 mutex_init(&st
->lock
);
1340 st
->info
= &sca3000_spi_chip_info_tbl
[variant
];
1342 st
->indio_dev
= iio_allocate_device();
1343 if (st
->indio_dev
== NULL
) {
1348 st
->indio_dev
->dev
.parent
= &spi
->dev
;
1349 st
->indio_dev
->num_interrupt_lines
= 1;
1350 st
->indio_dev
->event_attrs
= &sca3000_event_attribute_group
;
1351 if (st
->info
->temp_output
)
1352 st
->indio_dev
->attrs
= &sca3000_attribute_group_with_temp
;
1354 st
->indio_dev
->attrs
= &sca3000_attribute_group
;
1355 st
->indio_dev
->dev_data
= (void *)(st
);
1356 st
->indio_dev
->modes
= INDIO_DIRECT_MODE
;
1358 sca3000_configure_ring(st
->indio_dev
);
1360 ret
= iio_device_register(st
->indio_dev
);
1362 goto error_free_dev
;
1364 ret
= iio_ring_buffer_register(st
->indio_dev
->ring
, 0);
1366 goto error_unregister_dev
;
1367 if (spi
->irq
&& gpio_is_valid(irq_to_gpio(spi
->irq
)) > 0) {
1368 INIT_WORK(&st
->interrupt_handler_ws
,
1369 sca3000_interrupt_handler_bh
);
1370 ret
= iio_register_interrupt_line(spi
->irq
,
1373 IRQF_TRIGGER_FALLING
,
1376 goto error_unregister_ring
;
1378 * Probably a common situation. All interrupts need an ack
1379 * and there is only one handler so the complicated list system
1380 * is overkill. At very least a simpler registration method
1381 * might be worthwhile.
1383 iio_add_event_to_list(
1384 iio_event_attr_accel_z_mag_rising_en
.listel
,
1386 ->interrupts
[0]->ev_list
);
1388 sca3000_register_ring_funcs(st
->indio_dev
);
1389 ret
= sca3000_clean_setup(st
);
1391 goto error_unregister_interrupt_line
;
1394 error_unregister_interrupt_line
:
1395 if (spi
->irq
&& gpio_is_valid(irq_to_gpio(spi
->irq
)) > 0)
1396 iio_unregister_interrupt_line(st
->indio_dev
, 0);
1397 error_unregister_ring
:
1398 iio_ring_buffer_unregister(st
->indio_dev
->ring
);
1399 error_unregister_dev
:
1402 iio_device_unregister(st
->indio_dev
);
1404 iio_free_device(st
->indio_dev
);
1415 static int sca3000_stop_all_interrupts(struct sca3000_state
*st
)
1420 mutex_lock(&st
->lock
);
1421 ret
= sca3000_read_data(st
, SCA3000_REG_ADDR_INT_MASK
, &rx
, 1);
1424 ret
= sca3000_write_reg(st
, SCA3000_REG_ADDR_INT_MASK
,
1425 (rx
[1] & ~(SCA3000_INT_MASK_RING_THREE_QUARTER
1426 | SCA3000_INT_MASK_RING_HALF
1427 | SCA3000_INT_MASK_ALL_INTS
)));
1434 static int sca3000_remove(struct spi_device
*spi
)
1436 struct sca3000_state
*st
= spi_get_drvdata(spi
);
1437 struct iio_dev
*indio_dev
= st
->indio_dev
;
1439 /* Must ensure no interrupts can be generated after this!*/
1440 ret
= sca3000_stop_all_interrupts(st
);
1443 if (spi
->irq
&& gpio_is_valid(irq_to_gpio(spi
->irq
)) > 0)
1444 iio_unregister_interrupt_line(indio_dev
, 0);
1445 iio_ring_buffer_unregister(indio_dev
->ring
);
1446 sca3000_unconfigure_ring(indio_dev
);
1447 iio_device_unregister(indio_dev
);
1456 /* These macros save on an awful lot of repeated code */
1457 #define SCA3000_VARIANT_PROBE(_name) \
1458 static int __devinit \
1459 sca3000_##_name##_probe(struct spi_device *spi) \
1461 return __sca3000_probe(spi, _name); \
1464 #define SCA3000_VARIANT_SPI_DRIVER(_name) \
1465 struct spi_driver sca3000_##_name##_driver = { \
1467 .name = "sca3000_" #_name, \
1468 .owner = THIS_MODULE, \
1470 .probe = sca3000_##_name##_probe, \
1471 .remove = __devexit_p(sca3000_remove), \
1474 SCA3000_VARIANT_PROBE(d01
);
1475 static SCA3000_VARIANT_SPI_DRIVER(d01
);
1477 SCA3000_VARIANT_PROBE(e02
);
1478 static SCA3000_VARIANT_SPI_DRIVER(e02
);
1480 SCA3000_VARIANT_PROBE(e04
);
1481 static SCA3000_VARIANT_SPI_DRIVER(e04
);
1483 SCA3000_VARIANT_PROBE(e05
);
1484 static SCA3000_VARIANT_SPI_DRIVER(e05
);
1486 static __init
int sca3000_init(void)
1490 ret
= spi_register_driver(&sca3000_d01_driver
);
1493 ret
= spi_register_driver(&sca3000_e02_driver
);
1495 goto error_unreg_d01
;
1496 ret
= spi_register_driver(&sca3000_e04_driver
);
1498 goto error_unreg_e02
;
1499 ret
= spi_register_driver(&sca3000_e05_driver
);
1501 goto error_unreg_e04
;
1506 spi_unregister_driver(&sca3000_e04_driver
);
1508 spi_unregister_driver(&sca3000_e02_driver
);
1510 spi_unregister_driver(&sca3000_d01_driver
);
1516 static __exit
void sca3000_exit(void)
1518 spi_unregister_driver(&sca3000_e05_driver
);
1519 spi_unregister_driver(&sca3000_e04_driver
);
1520 spi_unregister_driver(&sca3000_e02_driver
);
1521 spi_unregister_driver(&sca3000_d01_driver
);
1524 module_init(sca3000_init
);
1525 module_exit(sca3000_exit
);
1527 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
1528 MODULE_DESCRIPTION("VTI SCA3000 Series Accelerometers SPI driver");
1529 MODULE_LICENSE("GPL v2");