mmc: rtsx_pci: Enable MMC_CAP_ERASE to allow erase/discard/trim requests
[linux/fpc-iii.git] / drivers / iio / gyro / adis16080.c
blobad31a1372a04ce87c4d2218d07a45bff9e51901d
1 /*
2 * ADIS16080/100 Yaw Rate Gyroscope with SPI driver
4 * Copyright 2010 Analog Devices Inc.
6 * Licensed under the GPL-2 or later.
7 */
8 #include <linux/delay.h>
9 #include <linux/mutex.h>
10 #include <linux/device.h>
11 #include <linux/kernel.h>
12 #include <linux/spi/spi.h>
13 #include <linux/slab.h>
14 #include <linux/sysfs.h>
15 #include <linux/module.h>
17 #include <linux/iio/iio.h>
18 #include <linux/iio/sysfs.h>
20 #define ADIS16080_DIN_GYRO (0 << 10) /* Gyroscope output */
21 #define ADIS16080_DIN_TEMP (1 << 10) /* Temperature output */
22 #define ADIS16080_DIN_AIN1 (2 << 10)
23 #define ADIS16080_DIN_AIN2 (3 << 10)
26 * 1: Write contents on DIN to control register.
27 * 0: No changes to control register.
30 #define ADIS16080_DIN_WRITE (1 << 15)
32 struct adis16080_chip_info {
33 int scale_val;
34 int scale_val2;
37 /**
38 * struct adis16080_state - device instance specific data
39 * @us: actual spi_device to write data
40 * @info: chip specific parameters
41 * @buf: transmit or receive buffer
42 **/
43 struct adis16080_state {
44 struct spi_device *us;
45 const struct adis16080_chip_info *info;
47 __be16 buf ____cacheline_aligned;
50 static int adis16080_read_sample(struct iio_dev *indio_dev,
51 u16 addr, int *val)
53 struct adis16080_state *st = iio_priv(indio_dev);
54 int ret;
55 struct spi_transfer t[] = {
57 .tx_buf = &st->buf,
58 .len = 2,
59 .cs_change = 1,
60 }, {
61 .rx_buf = &st->buf,
62 .len = 2,
66 st->buf = cpu_to_be16(addr | ADIS16080_DIN_WRITE);
68 ret = spi_sync_transfer(st->us, t, ARRAY_SIZE(t));
69 if (ret == 0)
70 *val = sign_extend32(be16_to_cpu(st->buf), 11);
72 return ret;
75 static int adis16080_read_raw(struct iio_dev *indio_dev,
76 struct iio_chan_spec const *chan,
77 int *val,
78 int *val2,
79 long mask)
81 struct adis16080_state *st = iio_priv(indio_dev);
82 int ret;
84 switch (mask) {
85 case IIO_CHAN_INFO_RAW:
86 mutex_lock(&indio_dev->mlock);
87 ret = adis16080_read_sample(indio_dev, chan->address, val);
88 mutex_unlock(&indio_dev->mlock);
89 return ret ? ret : IIO_VAL_INT;
90 case IIO_CHAN_INFO_SCALE:
91 switch (chan->type) {
92 case IIO_ANGL_VEL:
93 *val = st->info->scale_val;
94 *val2 = st->info->scale_val2;
95 return IIO_VAL_FRACTIONAL;
96 case IIO_VOLTAGE:
97 /* VREF = 5V, 12 bits */
98 *val = 5000;
99 *val2 = 12;
100 return IIO_VAL_FRACTIONAL_LOG2;
101 case IIO_TEMP:
102 /* 85 C = 585, 25 C = 0 */
103 *val = 85000 - 25000;
104 *val2 = 585;
105 return IIO_VAL_FRACTIONAL;
106 default:
107 return -EINVAL;
109 case IIO_CHAN_INFO_OFFSET:
110 switch (chan->type) {
111 case IIO_VOLTAGE:
112 /* 2.5 V = 0 */
113 *val = 2048;
114 return IIO_VAL_INT;
115 case IIO_TEMP:
116 /* 85 C = 585, 25 C = 0 */
117 *val = DIV_ROUND_CLOSEST(25 * 585, 85 - 25);
118 return IIO_VAL_INT;
119 default:
120 return -EINVAL;
122 default:
123 break;
126 return -EINVAL;
129 static const struct iio_chan_spec adis16080_channels[] = {
131 .type = IIO_ANGL_VEL,
132 .modified = 1,
133 .channel2 = IIO_MOD_Z,
134 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
135 BIT(IIO_CHAN_INFO_SCALE),
136 .address = ADIS16080_DIN_GYRO,
137 }, {
138 .type = IIO_VOLTAGE,
139 .indexed = 1,
140 .channel = 0,
141 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
142 BIT(IIO_CHAN_INFO_SCALE) |
143 BIT(IIO_CHAN_INFO_OFFSET),
144 .address = ADIS16080_DIN_AIN1,
145 }, {
146 .type = IIO_VOLTAGE,
147 .indexed = 1,
148 .channel = 1,
149 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
150 BIT(IIO_CHAN_INFO_SCALE) |
151 BIT(IIO_CHAN_INFO_OFFSET),
152 .address = ADIS16080_DIN_AIN2,
153 }, {
154 .type = IIO_TEMP,
155 .indexed = 1,
156 .channel = 0,
157 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
158 BIT(IIO_CHAN_INFO_SCALE) |
159 BIT(IIO_CHAN_INFO_OFFSET),
160 .address = ADIS16080_DIN_TEMP,
164 static const struct iio_info adis16080_info = {
165 .read_raw = &adis16080_read_raw,
166 .driver_module = THIS_MODULE,
169 enum {
170 ID_ADIS16080,
171 ID_ADIS16100,
174 static const struct adis16080_chip_info adis16080_chip_info[] = {
175 [ID_ADIS16080] = {
176 /* 80 degree = 819, 819 rad = 46925 degree */
177 .scale_val = 80,
178 .scale_val2 = 46925,
180 [ID_ADIS16100] = {
181 /* 300 degree = 1230, 1230 rad = 70474 degree */
182 .scale_val = 300,
183 .scale_val2 = 70474,
187 static int adis16080_probe(struct spi_device *spi)
189 const struct spi_device_id *id = spi_get_device_id(spi);
190 struct adis16080_state *st;
191 struct iio_dev *indio_dev;
193 /* setup the industrialio driver allocated elements */
194 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
195 if (!indio_dev)
196 return -ENOMEM;
197 st = iio_priv(indio_dev);
198 /* this is only used for removal purposes */
199 spi_set_drvdata(spi, indio_dev);
201 /* Allocate the comms buffers */
202 st->us = spi;
203 st->info = &adis16080_chip_info[id->driver_data];
205 indio_dev->name = spi->dev.driver->name;
206 indio_dev->channels = adis16080_channels;
207 indio_dev->num_channels = ARRAY_SIZE(adis16080_channels);
208 indio_dev->dev.parent = &spi->dev;
209 indio_dev->info = &adis16080_info;
210 indio_dev->modes = INDIO_DIRECT_MODE;
212 return iio_device_register(indio_dev);
215 static int adis16080_remove(struct spi_device *spi)
217 iio_device_unregister(spi_get_drvdata(spi));
218 return 0;
221 static const struct spi_device_id adis16080_ids[] = {
222 { "adis16080", ID_ADIS16080 },
223 { "adis16100", ID_ADIS16100 },
226 MODULE_DEVICE_TABLE(spi, adis16080_ids);
228 static struct spi_driver adis16080_driver = {
229 .driver = {
230 .name = "adis16080",
232 .probe = adis16080_probe,
233 .remove = adis16080_remove,
234 .id_table = adis16080_ids,
236 module_spi_driver(adis16080_driver);
238 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
239 MODULE_DESCRIPTION("Analog Devices ADIS16080/100 Yaw Rate Gyroscope Driver");
240 MODULE_LICENSE("GPL v2");