Pileus Git - ~andy/linux/blob - drivers/staging/iio/gyro/adis16080_core.c

   1 /*
   2  * ADIS16080/100 Yaw Rate Gyroscope with SPI driver
   3  *
   4  * Copyright 2010 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2 or later.
   7  */
   8 #include <linux/gpio.h>
   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
  17 #include "../iio.h"
  18 #include "../sysfs.h"
  19 #include "gyro.h"
  20 #include "../adc/adc.h"
  21
  22 #define ADIS16080_DIN_GYRO   (0 << 10) /* Gyroscope output */
  23 #define ADIS16080_DIN_TEMP   (1 << 10) /* Temperature output */
  24 #define ADIS16080_DIN_AIN1   (2 << 10)
  25 #define ADIS16080_DIN_AIN2   (3 << 10)
  26
  27 /*
  28  * 1: Write contents on DIN to control register.
  29  * 0: No changes to control register.
  30  */
  31
  32 #define ADIS16080_DIN_WRITE  (1 << 15)
  33
  34 /**
  35  * struct adis16080_state - device instance specific data
  36  * @us:                 actual spi_device to write data
  37  * @indio_dev:          industrial I/O device structure
  38  * @buf:                transmit or receive buffer
  39  * @buf_lock:           mutex to protect tx and rx
  40  **/
  41 struct adis16080_state {
  42         struct spi_device               *us;
  43         struct iio_dev                  *indio_dev;
  44         struct mutex                    buf_lock;
  45
  46         u8 buf[2] ____cacheline_aligned;
  47 };
  48
  49 static int adis16080_spi_write(struct device *dev,
  50                 u16 val)
  51 {
  52         int ret;
  53         struct iio_dev *indio_dev = dev_get_drvdata(dev);
  54         struct adis16080_state *st = iio_dev_get_devdata(indio_dev);
  55
  56         mutex_lock(&st->buf_lock);
  57         st->buf[0] = val >> 8;
  58         st->buf[1] = val;
  59
  60         ret = spi_write(st->us, st->buf, 2);
  61         mutex_unlock(&st->buf_lock);
  62
  63         return ret;
  64 }
  65
  66 static int adis16080_spi_read(struct device *dev,
  67                 u16 *val)
  68 {
  69         int ret;
  70         struct iio_dev *indio_dev = dev_get_drvdata(dev);
  71         struct adis16080_state *st = iio_dev_get_devdata(indio_dev);
  72
  73         mutex_lock(&st->buf_lock);
  74
  75         ret = spi_read(st->us, st->buf, 2);
  76
  77         if (ret == 0)
  78                 *val = ((st->buf[0] & 0xF) << 8) | st->buf[1];
  79         mutex_unlock(&st->buf_lock);
  80
  81         return ret;
  82 }
  83
  84 static ssize_t adis16080_read(struct device *dev,
  85                 struct device_attribute *attr,
  86                 char *buf)
  87 {
  88         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
  89         struct iio_dev *indio_dev = dev_get_drvdata(dev);
  90         u16 val = 0;
  91         ssize_t ret;
  92
  93         /* Take the iio_dev status lock */
  94         mutex_lock(&indio_dev->mlock);
  95         ret = adis16080_spi_write(dev,
  96                                   this_attr->address | ADIS16080_DIN_WRITE);
  97         if (ret < 0)
  98                 goto error_ret;
  99         ret =  adis16080_spi_read(dev, &val);
 100 error_ret:
 101         mutex_unlock(&indio_dev->mlock);
 102
 103         if (ret == 0)
 104                 return sprintf(buf, "%d\n", val);
 105         else
 106                 return ret;
 107 }
 108 static IIO_DEV_ATTR_GYRO_Z(adis16080_read, ADIS16080_DIN_GYRO);
 109 static IIO_DEVICE_ATTR(temp_raw, S_IRUGO, adis16080_read, NULL,
 110                        ADIS16080_DIN_TEMP);
 111 static IIO_DEV_ATTR_IN_RAW(0, adis16080_read, ADIS16080_DIN_AIN1);
 112 static IIO_DEV_ATTR_IN_RAW(1, adis16080_read, ADIS16080_DIN_AIN2);
 113
 114 static struct attribute *adis16080_attributes[] = {
 115         &iio_dev_attr_gyro_z_raw.dev_attr.attr,
 116         &iio_dev_attr_temp_raw.dev_attr.attr,
 117         &iio_dev_attr_in0_raw.dev_attr.attr,
 118         &iio_dev_attr_in1_raw.dev_attr.attr,
 119         NULL
 120 };
 121
 122 static const struct attribute_group adis16080_attribute_group = {
 123         .attrs = adis16080_attributes,
 124 };
 125
 126 static const struct iio_info adis16080_info = {
 127         .attrs = &adis16080_attribute_group,
 128         .driver_module = THIS_MODULE,
 129 };
 130
 131 static int __devinit adis16080_probe(struct spi_device *spi)
 132 {
 133         int ret, regdone = 0;
 134         struct adis16080_state *st = kzalloc(sizeof *st, GFP_KERNEL);
 135         if (!st) {
 136                 ret =  -ENOMEM;
 137                 goto error_ret;
 138         }
 139         /* this is only used for removal purposes */
 140         spi_set_drvdata(spi, st);
 141
 142         /* Allocate the comms buffers */
 143         st->us = spi;
 144         mutex_init(&st->buf_lock);
 145         /* setup the industrialio driver allocated elements */
 146         st->indio_dev = iio_allocate_device(0);
 147         if (st->indio_dev == NULL) {
 148                 ret = -ENOMEM;
 149                 goto error_free_st;
 150         }
 151
 152         st->indio_dev->name = spi->dev.driver->name;
 153         st->indio_dev->dev.parent = &spi->dev;
 154         st->indio_dev->info = &adis16080_info;
 155         st->indio_dev->dev_data = (void *)(st);
 156         st->indio_dev->modes = INDIO_DIRECT_MODE;
 157
 158         ret = iio_device_register(st->indio_dev);
 159         if (ret)
 160                 goto error_free_dev;
 161         regdone = 1;
 162
 163         return 0;
 164
 165 error_free_dev:
 166         if (regdone)
 167                 iio_device_unregister(st->indio_dev);
 168         else
 169                 iio_free_device(st->indio_dev);
 170 error_free_st:
 171         kfree(st);
 172 error_ret:
 173         return ret;
 174 }
 175
 176 /* fixme, confirm ordering in this function */
 177 static int adis16080_remove(struct spi_device *spi)
 178 {
 179         struct adis16080_state *st = spi_get_drvdata(spi);
 180         struct iio_dev *indio_dev = st->indio_dev;
 181
 182         iio_device_unregister(indio_dev);
 183         kfree(st);
 184
 185         return 0;
 186 }
 187
 188 static struct spi_driver adis16080_driver = {
 189         .driver = {
 190                 .name = "adis16080",
 191                 .owner = THIS_MODULE,
 192         },
 193         .probe = adis16080_probe,
 194         .remove = __devexit_p(adis16080_remove),
 195 };
 196
 197 static __init int adis16080_init(void)
 198 {
 199         return spi_register_driver(&adis16080_driver);
 200 }
 201 module_init(adis16080_init);
 202
 203 static __exit void adis16080_exit(void)
 204 {
 205         spi_unregister_driver(&adis16080_driver);
 206 }
 207 module_exit(adis16080_exit);
 208
 209 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 210 MODULE_DESCRIPTION("Analog Devices ADIS16080/100 Yaw Rate Gyroscope Driver");
 211 MODULE_LICENSE("GPL v2");