2 * ADIS16260 Programmable Digital Gyroscope 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>
23 #include "../adc/adc.h"
26 #include "adis16260.h"
28 #define DRIVER_NAME "adis16260"
30 static int adis16260_check_status(struct device *dev);
33 * adis16260_spi_write_reg_8() - write single byte to a register
34 * @dev: device associated with child of actual device (iio_dev or iio_trig)
35 * @reg_address: the address of the register to be written
36 * @val: the value to write
38 static int adis16260_spi_write_reg_8(struct device *dev,
43 struct iio_dev *indio_dev = dev_get_drvdata(dev);
44 struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
46 mutex_lock(&st->buf_lock);
47 st->tx[0] = ADIS16260_WRITE_REG(reg_address);
50 ret = spi_write(st->us, st->tx, 2);
51 mutex_unlock(&st->buf_lock);
57 * adis16260_spi_write_reg_16() - write 2 bytes to a pair of registers
58 * @dev: device associated with child of actual device (iio_dev or iio_trig)
59 * @reg_address: the address of the lower of the two registers. Second register
60 * is assumed to have address one greater.
61 * @val: value to be written
63 static int adis16260_spi_write_reg_16(struct device *dev,
68 struct spi_message msg;
69 struct iio_dev *indio_dev = dev_get_drvdata(dev);
70 struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
71 struct spi_transfer xfers[] = {
87 mutex_lock(&st->buf_lock);
88 st->tx[0] = ADIS16260_WRITE_REG(lower_reg_address);
89 st->tx[1] = value & 0xFF;
90 st->tx[2] = ADIS16260_WRITE_REG(lower_reg_address + 1);
91 st->tx[3] = (value >> 8) & 0xFF;
93 spi_message_init(&msg);
94 spi_message_add_tail(&xfers[0], &msg);
95 spi_message_add_tail(&xfers[1], &msg);
96 ret = spi_sync(st->us, &msg);
97 mutex_unlock(&st->buf_lock);
103 * adis16260_spi_read_reg_16() - read 2 bytes from a 16-bit register
104 * @dev: device associated with child of actual device (iio_dev or iio_trig)
105 * @reg_address: the address of the lower of the two registers. Second register
106 * is assumed to have address one greater.
107 * @val: somewhere to pass back the value read
109 static int adis16260_spi_read_reg_16(struct device *dev,
110 u8 lower_reg_address,
113 struct spi_message msg;
114 struct iio_dev *indio_dev = dev_get_drvdata(dev);
115 struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
117 struct spi_transfer xfers[] = {
133 mutex_lock(&st->buf_lock);
134 st->tx[0] = ADIS16260_READ_REG(lower_reg_address);
139 spi_message_init(&msg);
140 spi_message_add_tail(&xfers[0], &msg);
141 spi_message_add_tail(&xfers[1], &msg);
142 ret = spi_sync(st->us, &msg);
144 dev_err(&st->us->dev,
145 "problem when reading 16 bit register 0x%02X",
149 *val = (st->rx[0] << 8) | st->rx[1];
152 mutex_unlock(&st->buf_lock);
156 static ssize_t adis16260_spi_read_signed(struct device *dev,
157 struct device_attribute *attr,
163 unsigned shift = 16 - bits;
164 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
166 ret = adis16260_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
170 if (val & ADIS16260_ERROR_ACTIVE)
171 adis16260_check_status(dev);
172 val = ((s16)(val << shift) >> shift);
173 return sprintf(buf, "%d\n", val);
176 static ssize_t adis16260_read_12bit_unsigned(struct device *dev,
177 struct device_attribute *attr,
182 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
184 ret = adis16260_spi_read_reg_16(dev, this_attr->address, &val);
188 if (val & ADIS16260_ERROR_ACTIVE)
189 adis16260_check_status(dev);
191 return sprintf(buf, "%u\n", val & 0x0FFF);
194 static ssize_t adis16260_read_12bit_signed(struct device *dev,
195 struct device_attribute *attr,
198 struct iio_dev *indio_dev = dev_get_drvdata(dev);
201 /* Take the iio_dev status lock */
202 mutex_lock(&indio_dev->mlock);
203 ret = adis16260_spi_read_signed(dev, attr, buf, 12);
204 mutex_unlock(&indio_dev->mlock);
209 static ssize_t adis16260_read_14bit_signed(struct device *dev,
210 struct device_attribute *attr,
213 struct iio_dev *indio_dev = dev_get_drvdata(dev);
216 /* Take the iio_dev status lock */
217 mutex_lock(&indio_dev->mlock);
218 ret = adis16260_spi_read_signed(dev, attr, buf, 14);
219 mutex_unlock(&indio_dev->mlock);
224 static ssize_t adis16260_write_16bit(struct device *dev,
225 struct device_attribute *attr,
229 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
233 ret = strict_strtol(buf, 10, &val);
236 ret = adis16260_spi_write_reg_16(dev, this_attr->address, val);
239 return ret ? ret : len;
242 static ssize_t adis16260_read_frequency(struct device *dev,
243 struct device_attribute *attr,
249 ret = adis16260_spi_read_reg_16(dev,
254 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 66 : 2048;
255 sps /= (t & ADIS16260_SMPL_PRD_DIV_MASK) + 1;
256 len = sprintf(buf, "%d SPS\n", sps);
260 static ssize_t adis16260_write_frequency(struct device *dev,
261 struct device_attribute *attr,
265 struct iio_dev *indio_dev = dev_get_drvdata(dev);
266 struct adis16260_state *st = iio_dev_get_devdata(indio_dev);
271 ret = strict_strtol(buf, 10, &val);
275 mutex_lock(&indio_dev->mlock);
280 t &= ADIS16260_SMPL_PRD_DIV_MASK;
281 if ((t & ADIS16260_SMPL_PRD_DIV_MASK) >= 0x0A)
282 st->us->max_speed_hz = ADIS16260_SPI_SLOW;
284 st->us->max_speed_hz = ADIS16260_SPI_FAST;
286 ret = adis16260_spi_write_reg_8(dev,
290 mutex_unlock(&indio_dev->mlock);
292 return ret ? ret : len;
295 static int adis16260_reset(struct device *dev)
298 ret = adis16260_spi_write_reg_8(dev,
300 ADIS16260_GLOB_CMD_SW_RESET);
302 dev_err(dev, "problem resetting device");
307 static ssize_t adis16260_write_reset(struct device *dev,
308 struct device_attribute *attr,
309 const char *buf, size_t len)
317 return adis16260_reset(dev);
322 int adis16260_set_irq(struct device *dev, bool enable)
326 ret = adis16260_spi_read_reg_16(dev, ADIS16260_MSC_CTRL, &msc);
330 msc |= ADIS16260_MSC_CTRL_DATA_RDY_POL_HIGH;
332 msc |= ADIS16260_MSC_CTRL_DATA_RDY_EN;
334 msc &= ~ADIS16260_MSC_CTRL_DATA_RDY_EN;
336 ret = adis16260_spi_write_reg_16(dev, ADIS16260_MSC_CTRL, msc);
344 /* Power down the device */
345 static int adis16260_stop_device(struct device *dev)
348 u16 val = ADIS16260_SLP_CNT_POWER_OFF;
350 ret = adis16260_spi_write_reg_16(dev, ADIS16260_SLP_CNT, val);
352 dev_err(dev, "problem with turning device off: SLP_CNT");
357 static int adis16260_self_test(struct device *dev)
360 ret = adis16260_spi_write_reg_16(dev,
362 ADIS16260_MSC_CTRL_MEM_TEST);
364 dev_err(dev, "problem starting self test");
368 adis16260_check_status(dev);
374 static int adis16260_check_status(struct device *dev)
379 ret = adis16260_spi_read_reg_16(dev, ADIS16260_DIAG_STAT, &status);
382 dev_err(dev, "Reading status failed\n");
386 if (status & ADIS16260_DIAG_STAT_FLASH_CHK)
387 dev_err(dev, "Flash checksum error\n");
388 if (status & ADIS16260_DIAG_STAT_SELF_TEST)
389 dev_err(dev, "Self test error\n");
390 if (status & ADIS16260_DIAG_STAT_OVERFLOW)
391 dev_err(dev, "Sensor overrange\n");
392 if (status & ADIS16260_DIAG_STAT_SPI_FAIL)
393 dev_err(dev, "SPI failure\n");
394 if (status & ADIS16260_DIAG_STAT_FLASH_UPT)
395 dev_err(dev, "Flash update failed\n");
396 if (status & ADIS16260_DIAG_STAT_POWER_HIGH)
397 dev_err(dev, "Power supply above 5.25V\n");
398 if (status & ADIS16260_DIAG_STAT_POWER_LOW)
399 dev_err(dev, "Power supply below 4.75V\n");
405 static int adis16260_initial_setup(struct adis16260_state *st)
408 struct device *dev = &st->indio_dev->dev;
411 ret = adis16260_set_irq(dev, false);
413 dev_err(dev, "disable irq failed");
418 ret = adis16260_self_test(dev);
420 dev_err(dev, "self test failure");
424 /* Read status register to check the result */
425 ret = adis16260_check_status(dev);
427 adis16260_reset(dev);
428 dev_err(dev, "device not playing ball -> reset");
429 msleep(ADIS16260_STARTUP_DELAY);
430 ret = adis16260_check_status(dev);
432 dev_err(dev, "giving up");
437 printk(KERN_INFO DRIVER_NAME ": at CS%d (irq %d)\n",
438 st->us->chip_select, st->us->irq);
444 static IIO_DEV_ATTR_IN_NAMED_RAW(supply,
445 adis16260_read_12bit_unsigned,
446 ADIS16260_SUPPLY_OUT);
447 static IIO_CONST_ATTR(in_supply_scale, "0.0018315");
449 static IIO_DEV_ATTR_GYRO(adis16260_read_14bit_signed,
451 static IIO_DEV_ATTR_GYRO_SCALE(S_IWUSR | S_IRUGO,
452 adis16260_read_14bit_signed,
453 adis16260_write_16bit,
454 ADIS16260_GYRO_SCALE);
455 static IIO_DEV_ATTR_GYRO_OFFSET(S_IWUSR | S_IRUGO,
456 adis16260_read_12bit_signed,
457 adis16260_write_16bit,
460 static IIO_DEV_ATTR_TEMP_RAW(adis16260_read_12bit_unsigned);
461 static IIO_CONST_ATTR(temp_offset, "25");
462 static IIO_CONST_ATTR(temp_scale, "0.1453");
464 static IIO_DEV_ATTR_IN_RAW(0, adis16260_read_12bit_unsigned,
466 static IIO_CONST_ATTR(in0_scale, "0.0006105");
468 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
469 adis16260_read_frequency,
470 adis16260_write_frequency);
471 static IIO_DEV_ATTR_ANGL(adis16260_read_14bit_signed,
474 static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16260_write_reset, 0);
476 static IIO_CONST_ATTR_AVAIL_SAMP_FREQ("256 2048");
478 static IIO_CONST_ATTR(name, "adis16260");
480 static struct attribute *adis16260_event_attributes[] = {
484 static struct attribute_group adis16260_event_attribute_group = {
485 .attrs = adis16260_event_attributes,
488 static struct attribute *adis16260_attributes[] = {
489 &iio_dev_attr_in_supply_raw.dev_attr.attr,
490 &iio_const_attr_in_supply_scale.dev_attr.attr,
491 &iio_dev_attr_gyro_raw.dev_attr.attr,
492 &iio_dev_attr_gyro_scale.dev_attr.attr,
493 &iio_dev_attr_gyro_offset.dev_attr.attr,
494 &iio_dev_attr_angl_raw.dev_attr.attr,
495 &iio_dev_attr_temp_raw.dev_attr.attr,
496 &iio_const_attr_temp_offset.dev_attr.attr,
497 &iio_const_attr_temp_scale.dev_attr.attr,
498 &iio_dev_attr_in0_raw.dev_attr.attr,
499 &iio_const_attr_in0_scale.dev_attr.attr,
500 &iio_dev_attr_sampling_frequency.dev_attr.attr,
501 &iio_const_attr_available_sampling_frequency.dev_attr.attr,
502 &iio_dev_attr_reset.dev_attr.attr,
503 &iio_const_attr_name.dev_attr.attr,
507 static const struct attribute_group adis16260_attribute_group = {
508 .attrs = adis16260_attributes,
511 static int __devinit adis16260_probe(struct spi_device *spi)
513 int ret, regdone = 0;
514 struct adis16260_state *st = kzalloc(sizeof *st, GFP_KERNEL);
519 /* this is only used for removal purposes */
520 spi_set_drvdata(spi, st);
522 /* Allocate the comms buffers */
523 st->rx = kzalloc(sizeof(*st->rx)*ADIS16260_MAX_RX, GFP_KERNEL);
524 if (st->rx == NULL) {
528 st->tx = kzalloc(sizeof(*st->tx)*ADIS16260_MAX_TX, GFP_KERNEL);
529 if (st->tx == NULL) {
534 mutex_init(&st->buf_lock);
535 /* setup the industrialio driver allocated elements */
536 st->indio_dev = iio_allocate_device();
537 if (st->indio_dev == NULL) {
542 st->indio_dev->dev.parent = &spi->dev;
543 st->indio_dev->num_interrupt_lines = 1;
544 st->indio_dev->event_attrs = &adis16260_event_attribute_group;
545 st->indio_dev->attrs = &adis16260_attribute_group;
546 st->indio_dev->dev_data = (void *)(st);
547 st->indio_dev->driver_module = THIS_MODULE;
548 st->indio_dev->modes = INDIO_DIRECT_MODE;
550 ret = adis16260_configure_ring(st->indio_dev);
554 ret = iio_device_register(st->indio_dev);
556 goto error_unreg_ring_funcs;
559 ret = adis16260_initialize_ring(st->indio_dev->ring);
561 printk(KERN_ERR "failed to initialize the ring\n");
562 goto error_unreg_ring_funcs;
566 ret = iio_register_interrupt_line(spi->irq,
572 goto error_uninitialize_ring;
574 ret = adis16260_probe_trigger(st->indio_dev);
576 goto error_unregister_line;
579 /* Get the device into a sane initial state */
580 ret = adis16260_initial_setup(st);
582 goto error_remove_trigger;
585 error_remove_trigger:
586 adis16260_remove_trigger(st->indio_dev);
587 error_unregister_line:
589 iio_unregister_interrupt_line(st->indio_dev, 0);
590 error_uninitialize_ring:
591 adis16260_uninitialize_ring(st->indio_dev->ring);
592 error_unreg_ring_funcs:
593 adis16260_unconfigure_ring(st->indio_dev);
596 iio_device_unregister(st->indio_dev);
598 iio_free_device(st->indio_dev);
609 static int adis16260_remove(struct spi_device *spi)
612 struct adis16260_state *st = spi_get_drvdata(spi);
613 struct iio_dev *indio_dev = st->indio_dev;
615 ret = adis16260_stop_device(&(indio_dev->dev));
619 flush_scheduled_work();
621 adis16260_remove_trigger(indio_dev);
623 iio_unregister_interrupt_line(indio_dev, 0);
625 adis16260_uninitialize_ring(indio_dev->ring);
626 iio_device_unregister(indio_dev);
627 adis16260_unconfigure_ring(indio_dev);
638 static struct spi_driver adis16260_driver = {
641 .owner = THIS_MODULE,
643 .probe = adis16260_probe,
644 .remove = __devexit_p(adis16260_remove),
647 static __init int adis16260_init(void)
649 return spi_register_driver(&adis16260_driver);
651 module_init(adis16260_init);
653 static __exit void adis16260_exit(void)
655 spi_unregister_driver(&adis16260_driver);
657 module_exit(adis16260_exit);
659 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
660 MODULE_DESCRIPTION("Analog Devices ADIS16260/5 Digital Gyroscope Sensor");
661 MODULE_LICENSE("GPL v2");