2 * ADIS16220 Programmable Digital Vibration Sensor driver
4 * Copyright 2010 Analog Devices Inc.
6 * Licensed under the GPL-2 or later.
9 #include <linux/interrupt.h>
10 #include <linux/irq.h>
11 #include <linux/gpio.h>
12 #include <linux/delay.h>
13 #include <linux/mutex.h>
14 #include <linux/device.h>
15 #include <linux/kernel.h>
16 #include <linux/spi/spi.h>
18 #include <linux/sysfs.h>
19 #include <linux/list.h>
24 #include "../adc/adc.h"
26 #include "adis16220.h"
28 #define DRIVER_NAME "adis16220"
31 * adis16220_spi_write_reg_8() - write single byte to a register
32 * @dev: device associated with child of actual device (iio_dev or iio_trig)
33 * @reg_address: the address of the register to be written
34 * @val: the value to write
36 static int adis16220_spi_write_reg_8(struct device
*dev
,
41 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
42 struct adis16220_state
*st
= iio_dev_get_devdata(indio_dev
);
44 mutex_lock(&st
->buf_lock
);
45 st
->tx
[0] = ADIS16220_WRITE_REG(reg_address
);
48 ret
= spi_write(st
->us
, st
->tx
, 2);
49 mutex_unlock(&st
->buf_lock
);
55 * adis16220_spi_write_reg_16() - write 2 bytes to a pair of registers
56 * @dev: device associated with child of actual device (iio_dev or iio_trig)
57 * @reg_address: the address of the lower of the two registers. Second register
58 * is assumed to have address one greater.
59 * @val: value to be written
61 static int adis16220_spi_write_reg_16(struct device
*dev
,
66 struct spi_message msg
;
67 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
68 struct adis16220_state
*st
= iio_dev_get_devdata(indio_dev
);
69 struct spi_transfer xfers
[] = {
85 mutex_lock(&st
->buf_lock
);
86 st
->tx
[0] = ADIS16220_WRITE_REG(lower_reg_address
);
87 st
->tx
[1] = value
& 0xFF;
88 st
->tx
[2] = ADIS16220_WRITE_REG(lower_reg_address
+ 1);
89 st
->tx
[3] = (value
>> 8) & 0xFF;
91 spi_message_init(&msg
);
92 spi_message_add_tail(&xfers
[0], &msg
);
93 spi_message_add_tail(&xfers
[1], &msg
);
94 ret
= spi_sync(st
->us
, &msg
);
95 mutex_unlock(&st
->buf_lock
);
101 * adis16220_spi_read_reg_16() - read 2 bytes from a 16-bit register
102 * @dev: device associated with child of actual device (iio_dev or iio_trig)
103 * @reg_address: the address of the lower of the two registers. Second register
104 * is assumed to have address one greater.
105 * @val: somewhere to pass back the value read
107 static int adis16220_spi_read_reg_16(struct device
*dev
,
108 u8 lower_reg_address
,
111 struct spi_message msg
;
112 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
113 struct adis16220_state
*st
= iio_dev_get_devdata(indio_dev
);
115 struct spi_transfer xfers
[] = {
131 mutex_lock(&st
->buf_lock
);
132 st
->tx
[0] = ADIS16220_READ_REG(lower_reg_address
);
135 spi_message_init(&msg
);
136 spi_message_add_tail(&xfers
[0], &msg
);
137 spi_message_add_tail(&xfers
[1], &msg
);
138 ret
= spi_sync(st
->us
, &msg
);
140 dev_err(&st
->us
->dev
,
141 "problem when reading 16 bit register 0x%02X",
145 *val
= (st
->rx
[0] << 8) | st
->rx
[1];
148 mutex_unlock(&st
->buf_lock
);
152 static ssize_t
adis16220_spi_read_signed(struct device
*dev
,
153 struct device_attribute
*attr
,
159 unsigned shift
= 16 - bits
;
160 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
162 ret
= adis16220_spi_read_reg_16(dev
, this_attr
->address
, (u16
*)&val
);
166 val
= ((s16
)(val
<< shift
) >> shift
);
167 return sprintf(buf
, "%d\n", val
);
170 static ssize_t
adis16220_read_12bit_unsigned(struct device
*dev
,
171 struct device_attribute
*attr
,
176 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
178 ret
= adis16220_spi_read_reg_16(dev
, this_attr
->address
, &val
);
182 return sprintf(buf
, "%u\n", val
& 0x0FFF);
185 static ssize_t
adis16220_read_16bit(struct device
*dev
,
186 struct device_attribute
*attr
,
189 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
192 /* Take the iio_dev status lock */
193 mutex_lock(&indio_dev
->mlock
);
194 ret
= adis16220_spi_read_signed(dev
, attr
, buf
, 16);
195 mutex_unlock(&indio_dev
->mlock
);
200 static ssize_t
adis16220_write_16bit(struct device
*dev
,
201 struct device_attribute
*attr
,
205 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
209 ret
= strict_strtol(buf
, 10, &val
);
212 ret
= adis16220_spi_write_reg_16(dev
, this_attr
->address
, val
);
215 return ret
? ret
: len
;
218 static int adis16220_capture(struct device
*dev
)
221 ret
= adis16220_spi_write_reg_16(dev
,
223 0xBF08); /* initiates a manual data capture */
225 dev_err(dev
, "problem beginning capture");
227 msleep(10); /* delay for capture to finish */
232 static int adis16220_reset(struct device
*dev
)
235 ret
= adis16220_spi_write_reg_8(dev
,
237 ADIS16220_GLOB_CMD_SW_RESET
);
239 dev_err(dev
, "problem resetting device");
244 static ssize_t
adis16220_write_reset(struct device
*dev
,
245 struct device_attribute
*attr
,
246 const char *buf
, size_t len
)
254 return adis16220_reset(dev
) == 0 ? len
: -EIO
;
259 static ssize_t
adis16220_write_capture(struct device
*dev
,
260 struct device_attribute
*attr
,
261 const char *buf
, size_t len
)
269 return adis16220_capture(dev
) == 0 ? len
: -EIO
;
274 static int adis16220_check_status(struct device
*dev
)
279 ret
= adis16220_spi_read_reg_16(dev
, ADIS16220_DIAG_STAT
, &status
);
282 dev_err(dev
, "Reading status failed\n");
287 if (status
& ADIS16220_DIAG_STAT_VIOLATION
)
288 dev_err(dev
, "Capture period violation/interruption\n");
289 if (status
& ADIS16220_DIAG_STAT_SPI_FAIL
)
290 dev_err(dev
, "SPI failure\n");
291 if (status
& ADIS16220_DIAG_STAT_FLASH_UPT
)
292 dev_err(dev
, "Flash update failed\n");
293 if (status
& ADIS16220_DIAG_STAT_POWER_HIGH
)
294 dev_err(dev
, "Power supply above 5.25V\n");
295 if (status
& ADIS16220_DIAG_STAT_POWER_LOW
)
296 dev_err(dev
, "Power supply below 4.75V\n");
302 static int adis16220_self_test(struct device
*dev
)
305 ret
= adis16220_spi_write_reg_16(dev
,
307 ADIS16220_MSC_CTRL_SELF_TEST_EN
);
309 dev_err(dev
, "problem starting self test");
313 adis16220_check_status(dev
);
319 static int adis16220_initial_setup(struct adis16220_state
*st
)
322 struct device
*dev
= &st
->indio_dev
->dev
;
325 ret
= adis16220_self_test(dev
);
327 dev_err(dev
, "self test failure");
331 /* Read status register to check the result */
332 ret
= adis16220_check_status(dev
);
334 adis16220_reset(dev
);
335 dev_err(dev
, "device not playing ball -> reset");
336 msleep(ADIS16220_STARTUP_DELAY
);
337 ret
= adis16220_check_status(dev
);
339 dev_err(dev
, "giving up");
344 printk(KERN_INFO DRIVER_NAME
": at CS%d (irq %d)\n",
345 st
->us
->chip_select
, st
->us
->irq
);
351 static ssize_t
adis16220_capture_buffer_read(struct adis16220_state
*st
,
357 struct spi_message msg
;
358 struct spi_transfer xfers
[] = {
376 if (unlikely(!count
))
379 if ((off
>= ADIS16220_CAPTURE_SIZE
) || (count
& 1) || (off
& 1))
382 if (off
+ count
> ADIS16220_CAPTURE_SIZE
)
383 count
= ADIS16220_CAPTURE_SIZE
- off
;
385 /* write the begin position of capture buffer */
386 ret
= adis16220_spi_write_reg_16(&st
->indio_dev
->dev
,
392 /* read count/2 values from capture buffer */
393 mutex_lock(&st
->buf_lock
);
395 for (i
= 0; i
< count
; i
+= 2) {
396 st
->tx
[i
] = ADIS16220_READ_REG(addr
);
399 xfers
[1].len
= count
;
401 spi_message_init(&msg
);
402 spi_message_add_tail(&xfers
[0], &msg
);
403 spi_message_add_tail(&xfers
[1], &msg
);
404 ret
= spi_sync(st
->us
, &msg
);
407 mutex_unlock(&st
->buf_lock
);
411 memcpy(buf
, st
->rx
, count
);
413 mutex_unlock(&st
->buf_lock
);
417 static ssize_t
adis16220_accel_bin_read(struct kobject
*kobj
,
418 struct bin_attribute
*attr
,
423 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
424 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
425 struct adis16220_state
*st
= iio_dev_get_devdata(indio_dev
);
427 return adis16220_capture_buffer_read(st
, buf
,
429 ADIS16220_CAPT_BUFA
);
432 static struct bin_attribute accel_bin
= {
437 .read
= adis16220_accel_bin_read
,
438 .size
= ADIS16220_CAPTURE_SIZE
,
441 static ssize_t
adis16220_adc1_bin_read(struct kobject
*kobj
,
442 struct bin_attribute
*attr
,
443 char *buf
, loff_t off
,
446 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
447 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
448 struct adis16220_state
*st
= iio_dev_get_devdata(indio_dev
);
450 return adis16220_capture_buffer_read(st
, buf
,
452 ADIS16220_CAPT_BUF1
);
455 static struct bin_attribute adc1_bin
= {
460 .read
= adis16220_adc1_bin_read
,
461 .size
= ADIS16220_CAPTURE_SIZE
,
464 static ssize_t
adis16220_adc2_bin_read(struct kobject
*kobj
,
465 struct bin_attribute
*attr
,
466 char *buf
, loff_t off
,
469 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
470 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
471 struct adis16220_state
*st
= iio_dev_get_devdata(indio_dev
);
473 return adis16220_capture_buffer_read(st
, buf
,
475 ADIS16220_CAPT_BUF2
);
479 static struct bin_attribute adc2_bin
= {
484 .read
= adis16220_adc2_bin_read
,
485 .size
= ADIS16220_CAPTURE_SIZE
,
488 static IIO_DEV_ATTR_IN_NAMED_RAW(supply
, adis16220_read_12bit_unsigned
,
489 ADIS16220_CAPT_SUPPLY
);
490 static IIO_CONST_ATTR(in_supply_scale
, "0.0012207");
491 static IIO_DEV_ATTR_ACCEL(adis16220_read_16bit
, ADIS16220_CAPT_BUFA
);
492 static IIO_DEVICE_ATTR(accel_peak_raw
, S_IRUGO
, adis16220_read_16bit
,
493 NULL
, ADIS16220_CAPT_PEAKA
);
494 static IIO_DEV_ATTR_ACCEL_OFFSET(S_IWUSR
| S_IRUGO
,
495 adis16220_read_16bit
,
496 adis16220_write_16bit
,
497 ADIS16220_ACCL_NULL
);
498 static IIO_DEV_ATTR_TEMP_RAW(adis16220_read_12bit_unsigned
);
499 static IIO_CONST_ATTR(temp_offset
, "25");
500 static IIO_CONST_ATTR(temp_scale
, "-0.47");
502 static IIO_DEV_ATTR_IN_RAW(0, adis16220_read_16bit
, ADIS16220_CAPT_BUF1
);
503 static IIO_DEV_ATTR_IN_RAW(1, adis16220_read_16bit
, ADIS16220_CAPT_BUF2
);
505 static IIO_DEVICE_ATTR(reset
, S_IWUSR
, NULL
,
506 adis16220_write_reset
, 0);
508 #define IIO_DEV_ATTR_CAPTURE(_store) \
509 IIO_DEVICE_ATTR(capture, S_IWUGO, NULL, _store, 0)
511 static IIO_DEV_ATTR_CAPTURE(adis16220_write_capture
);
513 #define IIO_DEV_ATTR_CAPTURE_COUNT(_mode, _show, _store, _addr) \
514 IIO_DEVICE_ATTR(capture_count, _mode, _show, _store, _addr)
516 static IIO_DEV_ATTR_CAPTURE_COUNT(S_IWUSR
| S_IRUGO
,
517 adis16220_read_16bit
,
518 adis16220_write_16bit
,
519 ADIS16220_CAPT_PNTR
);
521 static IIO_CONST_ATTR_AVAIL_SAMP_FREQ("100200");
523 static IIO_CONST_ATTR(name
, "adis16220");
525 static struct attribute
*adis16220_attributes
[] = {
526 &iio_dev_attr_in_supply_raw
.dev_attr
.attr
,
527 &iio_const_attr_in_supply_scale
.dev_attr
.attr
,
528 &iio_dev_attr_accel_raw
.dev_attr
.attr
,
529 &iio_dev_attr_accel_offset
.dev_attr
.attr
,
530 &iio_dev_attr_accel_peak_raw
.dev_attr
.attr
,
531 &iio_dev_attr_temp_raw
.dev_attr
.attr
,
532 &iio_dev_attr_in0_raw
.dev_attr
.attr
,
533 &iio_dev_attr_in1_raw
.dev_attr
.attr
,
534 &iio_const_attr_temp_offset
.dev_attr
.attr
,
535 &iio_const_attr_temp_scale
.dev_attr
.attr
,
536 &iio_const_attr_available_sampling_frequency
.dev_attr
.attr
,
537 &iio_dev_attr_reset
.dev_attr
.attr
,
538 &iio_dev_attr_capture
.dev_attr
.attr
,
539 &iio_dev_attr_capture_count
.dev_attr
.attr
,
540 &iio_const_attr_name
.dev_attr
.attr
,
544 static const struct attribute_group adis16220_attribute_group
= {
545 .attrs
= adis16220_attributes
,
548 static int __devinit
adis16220_probe(struct spi_device
*spi
)
550 int ret
, regdone
= 0;
551 struct adis16220_state
*st
= kzalloc(sizeof *st
, GFP_KERNEL
);
556 /* this is only used for removal purposes */
557 spi_set_drvdata(spi
, st
);
559 /* Allocate the comms buffers */
560 st
->rx
= kzalloc(sizeof(*st
->rx
)*ADIS16220_MAX_RX
, GFP_KERNEL
);
561 if (st
->rx
== NULL
) {
565 st
->tx
= kzalloc(sizeof(*st
->tx
)*ADIS16220_MAX_TX
, GFP_KERNEL
);
566 if (st
->tx
== NULL
) {
571 mutex_init(&st
->buf_lock
);
572 /* setup the industrialio driver allocated elements */
573 st
->indio_dev
= iio_allocate_device();
574 if (st
->indio_dev
== NULL
) {
579 st
->indio_dev
->dev
.parent
= &spi
->dev
;
580 st
->indio_dev
->attrs
= &adis16220_attribute_group
;
581 st
->indio_dev
->dev_data
= (void *)(st
);
582 st
->indio_dev
->driver_module
= THIS_MODULE
;
583 st
->indio_dev
->modes
= INDIO_DIRECT_MODE
;
585 ret
= iio_device_register(st
->indio_dev
);
590 ret
= sysfs_create_bin_file(&st
->indio_dev
->dev
.kobj
, &accel_bin
);
594 ret
= sysfs_create_bin_file(&st
->indio_dev
->dev
.kobj
, &adc1_bin
);
596 goto error_rm_accel_bin
;
598 ret
= sysfs_create_bin_file(&st
->indio_dev
->dev
.kobj
, &adc2_bin
);
600 goto error_rm_adc1_bin
;
602 /* Get the device into a sane initial state */
603 ret
= adis16220_initial_setup(st
);
605 goto error_rm_adc2_bin
;
609 sysfs_remove_bin_file(&st
->indio_dev
->dev
.kobj
, &adc2_bin
);
611 sysfs_remove_bin_file(&st
->indio_dev
->dev
.kobj
, &adc1_bin
);
613 sysfs_remove_bin_file(&st
->indio_dev
->dev
.kobj
, &accel_bin
);
616 iio_device_unregister(st
->indio_dev
);
618 iio_free_device(st
->indio_dev
);
629 static int adis16220_remove(struct spi_device
*spi
)
631 struct adis16220_state
*st
= spi_get_drvdata(spi
);
632 struct iio_dev
*indio_dev
= st
->indio_dev
;
634 flush_scheduled_work();
636 sysfs_remove_bin_file(&st
->indio_dev
->dev
.kobj
, &adc2_bin
);
637 sysfs_remove_bin_file(&st
->indio_dev
->dev
.kobj
, &adc1_bin
);
638 sysfs_remove_bin_file(&st
->indio_dev
->dev
.kobj
, &accel_bin
);
639 iio_device_unregister(indio_dev
);
647 static struct spi_driver adis16220_driver
= {
650 .owner
= THIS_MODULE
,
652 .probe
= adis16220_probe
,
653 .remove
= __devexit_p(adis16220_remove
),
656 static __init
int adis16220_init(void)
658 return spi_register_driver(&adis16220_driver
);
660 module_init(adis16220_init
);
662 static __exit
void adis16220_exit(void)
664 spi_unregister_driver(&adis16220_driver
);
666 module_exit(adis16220_exit
);
668 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
669 MODULE_DESCRIPTION("Analog Devices ADIS16220 Digital Vibration Sensor");
670 MODULE_LICENSE("GPL v2");