2 * ADIS16220 Programmable Digital Vibration Sensor driver
4 * Copyright 2010 Analog Devices Inc.
6 * Licensed under the GPL-2 or later.
9 #include <linux/delay.h>
10 #include <linux/mutex.h>
11 #include <linux/device.h>
12 #include <linux/kernel.h>
13 #include <linux/spi/spi.h>
14 #include <linux/slab.h>
15 #include <linux/sysfs.h>
16 #include <linux/module.h>
18 #include <linux/iio/iio.h>
19 #include <linux/iio/sysfs.h>
21 #include "adis16220.h"
23 #define DRIVER_NAME "adis16220"
26 * adis16220_spi_write_reg_8() - write single byte to a register
27 * @indio_dev: iio device associated with child of actual device
28 * @reg_address: the address of the register to be written
29 * @val: the value to write
31 static int adis16220_spi_write_reg_8(struct iio_dev *indio_dev,
36 struct adis16220_state *st = iio_priv(indio_dev);
38 mutex_lock(&st->buf_lock);
39 st->tx[0] = ADIS16220_WRITE_REG(reg_address);
42 ret = spi_write(st->us, st->tx, 2);
43 mutex_unlock(&st->buf_lock);
49 * adis16220_spi_write_reg_16() - write 2 bytes to a pair of registers
50 * @indio_dev: iio device associated with child of actual device
51 * @reg_address: the address of the lower of the two registers. Second register
52 * is assumed to have address one greater.
53 * @val: value to be written
55 static int adis16220_spi_write_reg_16(struct iio_dev *indio_dev,
60 struct spi_message msg;
61 struct adis16220_state *st = iio_priv(indio_dev);
62 struct spi_transfer xfers[] = {
77 mutex_lock(&st->buf_lock);
78 st->tx[0] = ADIS16220_WRITE_REG(lower_reg_address);
79 st->tx[1] = value & 0xFF;
80 st->tx[2] = ADIS16220_WRITE_REG(lower_reg_address + 1);
81 st->tx[3] = (value >> 8) & 0xFF;
83 spi_message_init(&msg);
84 spi_message_add_tail(&xfers[0], &msg);
85 spi_message_add_tail(&xfers[1], &msg);
86 ret = spi_sync(st->us, &msg);
87 mutex_unlock(&st->buf_lock);
93 * adis16220_spi_read_reg_16() - read 2 bytes from a 16-bit register
94 * @indio_dev: iio device associated with child of actual device
95 * @reg_address: the address of the lower of the two registers. Second register
96 * is assumed to have address one greater.
97 * @val: somewhere to pass back the value read
99 static int adis16220_spi_read_reg_16(struct iio_dev *indio_dev,
100 u8 lower_reg_address,
103 struct spi_message msg;
104 struct adis16220_state *st = iio_priv(indio_dev);
106 struct spi_transfer xfers[] = {
122 mutex_lock(&st->buf_lock);
123 st->tx[0] = ADIS16220_READ_REG(lower_reg_address);
126 spi_message_init(&msg);
127 spi_message_add_tail(&xfers[0], &msg);
128 spi_message_add_tail(&xfers[1], &msg);
129 ret = spi_sync(st->us, &msg);
131 dev_err(&st->us->dev,
132 "problem when reading 16 bit register 0x%02X",
136 *val = (st->rx[0] << 8) | st->rx[1];
139 mutex_unlock(&st->buf_lock);
143 static ssize_t adis16220_read_16bit(struct device *dev,
144 struct device_attribute *attr,
147 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
148 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
152 /* Take the iio_dev status lock */
153 mutex_lock(&indio_dev->mlock);
154 ret = adis16220_spi_read_reg_16(indio_dev, this_attr->address,
156 mutex_unlock(&indio_dev->mlock);
159 return sprintf(buf, "%d\n", val);
162 static ssize_t adis16220_write_16bit(struct device *dev,
163 struct device_attribute *attr,
167 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
168 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
172 ret = kstrtou16(buf, 10, &val);
175 ret = adis16220_spi_write_reg_16(indio_dev, this_attr->address, val);
178 return ret ? ret : len;
181 static int adis16220_capture(struct iio_dev *indio_dev)
184 ret = adis16220_spi_write_reg_16(indio_dev,
186 0xBF08); /* initiates a manual data capture */
188 dev_err(&indio_dev->dev, "problem beginning capture");
190 msleep(10); /* delay for capture to finish */
195 static int adis16220_reset(struct iio_dev *indio_dev)
198 ret = adis16220_spi_write_reg_8(indio_dev,
200 ADIS16220_GLOB_CMD_SW_RESET);
202 dev_err(&indio_dev->dev, "problem resetting device");
207 static ssize_t adis16220_write_capture(struct device *dev,
208 struct device_attribute *attr,
209 const char *buf, size_t len)
211 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
215 ret = strtobool(buf, &val);
220 ret = adis16220_capture(indio_dev);
227 static int adis16220_check_status(struct iio_dev *indio_dev)
232 ret = adis16220_spi_read_reg_16(indio_dev, ADIS16220_DIAG_STAT,
236 dev_err(&indio_dev->dev, "Reading status failed\n");
241 if (status & ADIS16220_DIAG_STAT_VIOLATION)
242 dev_err(&indio_dev->dev,
243 "Capture period violation/interruption\n");
244 if (status & ADIS16220_DIAG_STAT_SPI_FAIL)
245 dev_err(&indio_dev->dev, "SPI failure\n");
246 if (status & ADIS16220_DIAG_STAT_FLASH_UPT)
247 dev_err(&indio_dev->dev, "Flash update failed\n");
248 if (status & ADIS16220_DIAG_STAT_POWER_HIGH)
249 dev_err(&indio_dev->dev, "Power supply above 3.625V\n");
250 if (status & ADIS16220_DIAG_STAT_POWER_LOW)
251 dev_err(&indio_dev->dev, "Power supply below 3.15V\n");
257 static int adis16220_self_test(struct iio_dev *indio_dev)
260 ret = adis16220_spi_write_reg_16(indio_dev,
262 ADIS16220_MSC_CTRL_SELF_TEST_EN);
264 dev_err(&indio_dev->dev, "problem starting self test");
268 adis16220_check_status(indio_dev);
274 static int adis16220_initial_setup(struct iio_dev *indio_dev)
279 ret = adis16220_self_test(indio_dev);
281 dev_err(&indio_dev->dev, "self test failure");
285 /* Read status register to check the result */
286 ret = adis16220_check_status(indio_dev);
288 adis16220_reset(indio_dev);
289 dev_err(&indio_dev->dev, "device not playing ball -> reset");
290 msleep(ADIS16220_STARTUP_DELAY);
291 ret = adis16220_check_status(indio_dev);
293 dev_err(&indio_dev->dev, "giving up");
302 static ssize_t adis16220_capture_buffer_read(struct iio_dev *indio_dev,
308 struct adis16220_state *st = iio_priv(indio_dev);
309 struct spi_message msg;
310 struct spi_transfer xfers[] = {
328 if (unlikely(!count))
331 if ((off >= ADIS16220_CAPTURE_SIZE) || (count & 1) || (off & 1))
334 if (off + count > ADIS16220_CAPTURE_SIZE)
335 count = ADIS16220_CAPTURE_SIZE - off;
337 /* write the begin position of capture buffer */
338 ret = adis16220_spi_write_reg_16(indio_dev,
344 /* read count/2 values from capture buffer */
345 mutex_lock(&st->buf_lock);
347 for (i = 0; i < count; i += 2) {
348 st->tx[i] = ADIS16220_READ_REG(addr);
351 xfers[1].len = count;
353 spi_message_init(&msg);
354 spi_message_add_tail(&xfers[0], &msg);
355 spi_message_add_tail(&xfers[1], &msg);
356 ret = spi_sync(st->us, &msg);
359 mutex_unlock(&st->buf_lock);
363 memcpy(buf, st->rx, count);
365 mutex_unlock(&st->buf_lock);
369 static ssize_t adis16220_accel_bin_read(struct file *filp, struct kobject *kobj,
370 struct bin_attribute *attr,
375 struct iio_dev *indio_dev = dev_to_iio_dev(kobj_to_dev(kobj));
377 return adis16220_capture_buffer_read(indio_dev, buf,
379 ADIS16220_CAPT_BUFA);
382 static struct bin_attribute accel_bin = {
387 .read = adis16220_accel_bin_read,
388 .size = ADIS16220_CAPTURE_SIZE,
391 static ssize_t adis16220_adc1_bin_read(struct file *filp, struct kobject *kobj,
392 struct bin_attribute *attr,
393 char *buf, loff_t off,
396 struct iio_dev *indio_dev = dev_to_iio_dev(kobj_to_dev(kobj));
398 return adis16220_capture_buffer_read(indio_dev, buf,
400 ADIS16220_CAPT_BUF1);
403 static struct bin_attribute adc1_bin = {
408 .read = adis16220_adc1_bin_read,
409 .size = ADIS16220_CAPTURE_SIZE,
412 static ssize_t adis16220_adc2_bin_read(struct file *filp, struct kobject *kobj,
413 struct bin_attribute *attr,
414 char *buf, loff_t off,
417 struct iio_dev *indio_dev = dev_to_iio_dev(kobj_to_dev(kobj));
419 return adis16220_capture_buffer_read(indio_dev, buf,
421 ADIS16220_CAPT_BUF2);
425 static struct bin_attribute adc2_bin = {
430 .read = adis16220_adc2_bin_read,
431 .size = ADIS16220_CAPTURE_SIZE,
434 #define IIO_DEV_ATTR_CAPTURE(_store) \
435 IIO_DEVICE_ATTR(capture, S_IWUSR, NULL, _store, 0)
437 static IIO_DEV_ATTR_CAPTURE(adis16220_write_capture);
439 #define IIO_DEV_ATTR_CAPTURE_COUNT(_mode, _show, _store, _addr) \
440 IIO_DEVICE_ATTR(capture_count, _mode, _show, _store, _addr)
442 static IIO_DEV_ATTR_CAPTURE_COUNT(S_IWUSR | S_IRUGO,
443 adis16220_read_16bit,
444 adis16220_write_16bit,
445 ADIS16220_CAPT_PNTR);
447 enum adis16220_channel {
448 in_supply, in_1, in_2, accel, temp
451 struct adis16220_address_spec {
457 /* Address / bits / signed */
458 static const struct adis16220_address_spec adis16220_addresses[][3] = {
459 [in_supply] = { { ADIS16220_CAPT_SUPPLY, 12, 0 }, },
460 [in_1] = { { ADIS16220_CAPT_BUF1, 16, 1 },
461 { ADIS16220_AIN1_NULL, 16, 1 },
462 { ADIS16220_CAPT_PEAK1, 16, 1 }, },
463 [in_2] = { { ADIS16220_CAPT_BUF2, 16, 1 },
464 { ADIS16220_AIN2_NULL, 16, 1 },
465 { ADIS16220_CAPT_PEAK2, 16, 1 }, },
466 [accel] = { { ADIS16220_CAPT_BUFA, 16, 1 },
467 { ADIS16220_ACCL_NULL, 16, 1 },
468 { ADIS16220_CAPT_PEAKA, 16, 1 }, },
469 [temp] = { { ADIS16220_CAPT_TEMP, 12, 0 }, }
472 static int adis16220_read_raw(struct iio_dev *indio_dev,
473 struct iio_chan_spec const *chan,
484 case IIO_CHAN_INFO_RAW:
487 case IIO_CHAN_INFO_OFFSET:
488 if (chan->type == IIO_TEMP) {
494 case IIO_CHAN_INFO_PEAK:
497 case IIO_CHAN_INFO_SCALE:
499 switch (chan->type) {
502 return IIO_VAL_INT_PLUS_MICRO;
505 return IIO_VAL_INT_PLUS_MICRO;
507 if (chan->channel == 0)
509 else /* Should really be dependent on VDD */
511 return IIO_VAL_INT_PLUS_MICRO;
518 if (adis16220_addresses[chan->address][addrind].sign) {
519 ret = adis16220_spi_read_reg_16(indio_dev,
520 adis16220_addresses[chan
526 bits = adis16220_addresses[chan->address][addrind].bits;
527 sval &= (1 << bits) - 1;
528 sval = (s16)(sval << (16 - bits)) >> (16 - bits);
532 ret = adis16220_spi_read_reg_16(indio_dev,
533 adis16220_addresses[chan
539 bits = adis16220_addresses[chan->address][addrind].bits;
540 uval &= (1 << bits) - 1;
546 static const struct iio_chan_spec adis16220_channels[] = {
551 .extend_name = "supply",
552 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
553 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
554 .address = in_supply,
557 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
558 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
559 IIO_CHAN_INFO_SCALE_SEPARATE_BIT |
560 IIO_CHAN_INFO_PEAK_SEPARATE_BIT,
566 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
567 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
568 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
574 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
575 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
576 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
582 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
587 static struct attribute *adis16220_attributes[] = {
588 &iio_dev_attr_capture.dev_attr.attr,
589 &iio_dev_attr_capture_count.dev_attr.attr,
593 static const struct attribute_group adis16220_attribute_group = {
594 .attrs = adis16220_attributes,
597 static const struct iio_info adis16220_info = {
598 .attrs = &adis16220_attribute_group,
599 .driver_module = THIS_MODULE,
600 .read_raw = &adis16220_read_raw,
603 static int __devinit adis16220_probe(struct spi_device *spi)
606 struct adis16220_state *st;
607 struct iio_dev *indio_dev;
609 /* setup the industrialio driver allocated elements */
610 indio_dev = iio_device_alloc(sizeof(*st));
611 if (indio_dev == NULL) {
616 st = iio_priv(indio_dev);
617 /* this is only used for removal purposes */
618 spi_set_drvdata(spi, indio_dev);
621 mutex_init(&st->buf_lock);
623 indio_dev->name = spi->dev.driver->name;
624 indio_dev->dev.parent = &spi->dev;
625 indio_dev->info = &adis16220_info;
626 indio_dev->modes = INDIO_DIRECT_MODE;
627 indio_dev->channels = adis16220_channels;
628 indio_dev->num_channels = ARRAY_SIZE(adis16220_channels);
630 ret = iio_device_register(indio_dev);
634 ret = sysfs_create_bin_file(&indio_dev->dev.kobj, &accel_bin);
636 goto error_unregister_dev;
638 ret = sysfs_create_bin_file(&indio_dev->dev.kobj, &adc1_bin);
640 goto error_rm_accel_bin;
642 ret = sysfs_create_bin_file(&indio_dev->dev.kobj, &adc2_bin);
644 goto error_rm_adc1_bin;
646 /* Get the device into a sane initial state */
647 ret = adis16220_initial_setup(indio_dev);
649 goto error_rm_adc2_bin;
653 sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc2_bin);
655 sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc1_bin);
657 sysfs_remove_bin_file(&indio_dev->dev.kobj, &accel_bin);
658 error_unregister_dev:
659 iio_device_unregister(indio_dev);
661 iio_device_free(indio_dev);
666 static int __devexit adis16220_remove(struct spi_device *spi)
668 struct iio_dev *indio_dev = spi_get_drvdata(spi);
670 sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc2_bin);
671 sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc1_bin);
672 sysfs_remove_bin_file(&indio_dev->dev.kobj, &accel_bin);
673 iio_device_unregister(indio_dev);
674 iio_device_free(indio_dev);
679 static struct spi_driver adis16220_driver = {
682 .owner = THIS_MODULE,
684 .probe = adis16220_probe,
685 .remove = __devexit_p(adis16220_remove),
687 module_spi_driver(adis16220_driver);
689 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
690 MODULE_DESCRIPTION("Analog Devices ADIS16220 Digital Vibration Sensor");
691 MODULE_LICENSE("GPL v2");
692 MODULE_ALIAS("spi:adis16220");