aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/staging/iio/gyro/Makefile1
-rw-r--r--drivers/staging/iio/gyro/adis16260.h84
-rw-r--r--drivers/staging/iio/gyro/adis16260_core.c483
-rw-r--r--drivers/staging/iio/gyro/adis16260_ring.c136
-rw-r--r--drivers/staging/iio/gyro/adis16260_trigger.c75
5 files changed, 94 insertions, 685 deletions
diff --git a/drivers/staging/iio/gyro/Makefile b/drivers/staging/iio/gyro/Makefile
index 9ba5ec15170..1303569e5c8 100644
--- a/drivers/staging/iio/gyro/Makefile
+++ b/drivers/staging/iio/gyro/Makefile
@@ -12,7 +12,6 @@ adis16130-y := adis16130_core.o
12obj-$(CONFIG_ADIS16130) += adis16130.o 12obj-$(CONFIG_ADIS16130) += adis16130.o
13 13
14adis16260-y := adis16260_core.o 14adis16260-y := adis16260_core.o
15adis16260-$(CONFIG_IIO_BUFFER) += adis16260_ring.o adis16260_trigger.o
16obj-$(CONFIG_ADIS16260) += adis16260.o 15obj-$(CONFIG_ADIS16260) += adis16260.o
17 16
18adis16251-y := adis16251_core.o 17adis16251-y := adis16251_core.o
diff --git a/drivers/staging/iio/gyro/adis16260.h b/drivers/staging/iio/gyro/adis16260.h
index 4c4b25129c6..ea5eba205bb 100644
--- a/drivers/staging/iio/gyro/adis16260.h
+++ b/drivers/staging/iio/gyro/adis16260.h
@@ -1,12 +1,11 @@
1#ifndef SPI_ADIS16260_H_ 1#ifndef SPI_ADIS16260_H_
2#define SPI_ADIS16260_H_ 2#define SPI_ADIS16260_H_
3
3#include "adis16260_platform_data.h" 4#include "adis16260_platform_data.h"
5#include "../imu/adis.h"
4 6
5#define ADIS16260_STARTUP_DELAY 220 /* ms */ 7#define ADIS16260_STARTUP_DELAY 220 /* ms */
6 8
7#define ADIS16260_READ_REG(a) a
8#define ADIS16260_WRITE_REG(a) ((a) | 0x80)
9
10#define ADIS16260_FLASH_CNT 0x00 /* Flash memory write count */ 9#define ADIS16260_FLASH_CNT 0x00 /* Flash memory write count */
11#define ADIS16260_SUPPLY_OUT 0x02 /* Power supply measurement */ 10#define ADIS16260_SUPPLY_OUT 0x02 /* Power supply measurement */
12#define ADIS16260_GYRO_OUT 0x04 /* X-axis gyroscope output */ 11#define ADIS16260_GYRO_OUT 0x04 /* X-axis gyroscope output */
@@ -34,8 +33,6 @@
34 * convert to decimal = 16,265/16,260 */ 33 * convert to decimal = 16,265/16,260 */
35#define ADIS16260_SERIAL_NUM 0x58 /* Serial number */ 34#define ADIS16260_SERIAL_NUM 0x58 /* Serial number */
36 35
37#define ADIS16260_OUTPUTS 5
38
39#define ADIS16260_ERROR_ACTIVE (1<<14) 36#define ADIS16260_ERROR_ACTIVE (1<<14)
40#define ADIS16260_NEW_DATA (1<<15) 37#define ADIS16260_NEW_DATA (1<<15)
41 38
@@ -60,13 +57,13 @@
60/* DIAG_STAT */ 57/* DIAG_STAT */
61#define ADIS16260_DIAG_STAT_ALARM2 (1<<9) 58#define ADIS16260_DIAG_STAT_ALARM2 (1<<9)
62#define ADIS16260_DIAG_STAT_ALARM1 (1<<8) 59#define ADIS16260_DIAG_STAT_ALARM1 (1<<8)
63#define ADIS16260_DIAG_STAT_FLASH_CHK (1<<6) 60#define ADIS16260_DIAG_STAT_FLASH_CHK_BIT 6
64#define ADIS16260_DIAG_STAT_SELF_TEST (1<<5) 61#define ADIS16260_DIAG_STAT_SELF_TEST_BIT 5
65#define ADIS16260_DIAG_STAT_OVERFLOW (1<<4) 62#define ADIS16260_DIAG_STAT_OVERFLOW_BIT 4
66#define ADIS16260_DIAG_STAT_SPI_FAIL (1<<3) 63#define ADIS16260_DIAG_STAT_SPI_FAIL_BIT 3
67#define ADIS16260_DIAG_STAT_FLASH_UPT (1<<2) 64#define ADIS16260_DIAG_STAT_FLASH_UPT_BIT 2
68#define ADIS16260_DIAG_STAT_POWER_HIGH (1<<1) 65#define ADIS16260_DIAG_STAT_POWER_HIGH_BIT 1
69#define ADIS16260_DIAG_STAT_POWER_LOW (1<<0) 66#define ADIS16260_DIAG_STAT_POWER_LOW_BIT 0
70 67
71/* GLOB_CMD */ 68/* GLOB_CMD */
72#define ADIS16260_GLOB_CMD_SW_RESET (1<<7) 69#define ADIS16260_GLOB_CMD_SW_RESET (1<<7)
@@ -75,82 +72,27 @@
75#define ADIS16260_GLOB_CMD_FAC_CALIB (1<<1) 72#define ADIS16260_GLOB_CMD_FAC_CALIB (1<<1)
76#define ADIS16260_GLOB_CMD_AUTO_NULL (1<<0) 73#define ADIS16260_GLOB_CMD_AUTO_NULL (1<<0)
77 74
78#define ADIS16260_MAX_TX 24
79#define ADIS16260_MAX_RX 24
80
81#define ADIS16260_SPI_SLOW (u32)(300 * 1000) 75#define ADIS16260_SPI_SLOW (u32)(300 * 1000)
82#define ADIS16260_SPI_BURST (u32)(1000 * 1000) 76#define ADIS16260_SPI_BURST (u32)(1000 * 1000)
83#define ADIS16260_SPI_FAST (u32)(2000 * 1000) 77#define ADIS16260_SPI_FAST (u32)(2000 * 1000)
84 78
85/** 79/**
86 * struct adis16260_state - device instance specific data 80 * struct adis16260_state - device instance specific data
87 * @us: actual spi_device
88 * @trig: data ready trigger registered with iio
89 * @buf_lock: mutex to protect tx and rx
90 * @negate: negate the scale parameter 81 * @negate: negate the scale parameter
91 * @tx: transmit buffer
92 * @rx: receive buffer
93 **/ 82 **/
94struct adis16260_state { 83struct adis16260_state {
95 struct spi_device *us; 84 unsigned negate:1;
96 struct iio_trigger *trig; 85 struct adis adis;
97 struct mutex buf_lock;
98 unsigned negate:1;
99 u8 tx[ADIS16260_MAX_TX] ____cacheline_aligned;
100 u8 rx[ADIS16260_MAX_RX];
101}; 86};
102 87
103int adis16260_set_irq(struct iio_dev *indio_dev, bool enable);
104
105/* At the moment triggers are only used for ring buffer 88/* At the moment triggers are only used for ring buffer
106 * filling. This may change! 89 * filling. This may change!
107 */ 90 */
108 91
109#define ADIS16260_SCAN_SUPPLY 0 92#define ADIS16260_SCAN_GYRO 0
110#define ADIS16260_SCAN_GYRO 1 93#define ADIS16260_SCAN_SUPPLY 1
111#define ADIS16260_SCAN_AUX_ADC 2 94#define ADIS16260_SCAN_AUX_ADC 2
112#define ADIS16260_SCAN_TEMP 3 95#define ADIS16260_SCAN_TEMP 3
113#define ADIS16260_SCAN_ANGL 4 96#define ADIS16260_SCAN_ANGL 4
114 97
115#ifdef CONFIG_IIO_BUFFER
116void adis16260_remove_trigger(struct iio_dev *indio_dev);
117int adis16260_probe_trigger(struct iio_dev *indio_dev);
118
119ssize_t adis16260_read_data_from_ring(struct device *dev,
120 struct device_attribute *attr,
121 char *buf);
122
123
124int adis16260_configure_ring(struct iio_dev *indio_dev);
125void adis16260_unconfigure_ring(struct iio_dev *indio_dev);
126
127#else /* CONFIG_IIO_BUFFER */
128
129static inline void adis16260_remove_trigger(struct iio_dev *indio_dev)
130{
131}
132
133static inline int adis16260_probe_trigger(struct iio_dev *indio_dev)
134{
135 return 0;
136}
137
138static inline ssize_t
139adis16260_read_data_from_ring(struct device *dev,
140 struct device_attribute *attr,
141 char *buf)
142{
143 return 0;
144}
145
146static int adis16260_configure_ring(struct iio_dev *indio_dev)
147{
148 return 0;
149}
150
151static inline void adis16260_unconfigure_ring(struct iio_dev *indio_dev)
152{
153}
154
155#endif /* CONFIG_IIO_BUFFER */
156#endif /* SPI_ADIS16260_H_ */ 98#endif /* SPI_ADIS16260_H_ */
diff --git a/drivers/staging/iio/gyro/adis16260_core.c b/drivers/staging/iio/gyro/adis16260_core.c
index e822460502b..820547baae3 100644
--- a/drivers/staging/iio/gyro/adis16260_core.c
+++ b/drivers/staging/iio/gyro/adis16260_core.c
@@ -24,132 +24,13 @@
24 24
25#include "adis16260.h" 25#include "adis16260.h"
26 26
27static int adis16260_check_status(struct iio_dev *indio_dev);
28
29/**
30 * adis16260_spi_write_reg_8() - write single byte to a register
31 * @indio_dev: iio_dev for the device
32 * @reg_address: the address of the register to be written
33 * @val: the value to write
34 **/
35static int adis16260_spi_write_reg_8(struct iio_dev *indio_dev,
36 u8 reg_address,
37 u8 val)
38{
39 int ret;
40 struct adis16260_state *st = iio_priv(indio_dev);
41
42 mutex_lock(&st->buf_lock);
43 st->tx[0] = ADIS16260_WRITE_REG(reg_address);
44 st->tx[1] = val;
45
46 ret = spi_write(st->us, st->tx, 2);
47 mutex_unlock(&st->buf_lock);
48
49 return ret;
50}
51
52/**
53 * adis16260_spi_write_reg_16() - write 2 bytes to a pair of registers
54 * @indio_dev: iio_dev for the device
55 * @reg_address: the address of the lower of the two registers. Second register
56 * is assumed to have address one greater.
57 * @val: value to be written
58 **/
59static int adis16260_spi_write_reg_16(struct iio_dev *indio_dev,
60 u8 lower_reg_address,
61 u16 value)
62{
63 int ret;
64 struct spi_message msg;
65 struct adis16260_state *st = iio_priv(indio_dev);
66 struct spi_transfer xfers[] = {
67 {
68 .tx_buf = st->tx,
69 .bits_per_word = 8,
70 .len = 2,
71 .cs_change = 1,
72 .delay_usecs = 20,
73 }, {
74 .tx_buf = st->tx + 2,
75 .bits_per_word = 8,
76 .len = 2,
77 .delay_usecs = 20,
78 },
79 };
80
81 mutex_lock(&st->buf_lock);
82 st->tx[0] = ADIS16260_WRITE_REG(lower_reg_address);
83 st->tx[1] = value & 0xFF;
84 st->tx[2] = ADIS16260_WRITE_REG(lower_reg_address + 1);
85 st->tx[3] = (value >> 8) & 0xFF;
86
87 spi_message_init(&msg);
88 spi_message_add_tail(&xfers[0], &msg);
89 spi_message_add_tail(&xfers[1], &msg);
90 ret = spi_sync(st->us, &msg);
91 mutex_unlock(&st->buf_lock);
92
93 return ret;
94}
95
96/**
97 * adis16260_spi_read_reg_16() - read 2 bytes from a 16-bit register
98 * @indio_dev: iio_dev for the device
99 * @reg_address: the address of the lower of the two registers. Second register
100 * is assumed to have address one greater.
101 * @val: somewhere to pass back the value read
102 **/
103static int adis16260_spi_read_reg_16(struct iio_dev *indio_dev,
104 u8 lower_reg_address,
105 u16 *val)
106{
107 struct spi_message msg;
108 struct adis16260_state *st = iio_priv(indio_dev);
109 int ret;
110 struct spi_transfer xfers[] = {
111 {
112 .tx_buf = st->tx,
113 .bits_per_word = 8,
114 .len = 2,
115 .cs_change = 1,
116 .delay_usecs = 30,
117 }, {
118 .rx_buf = st->rx,
119 .bits_per_word = 8,
120 .len = 2,
121 .delay_usecs = 30,
122 },
123 };
124
125 mutex_lock(&st->buf_lock);
126 st->tx[0] = ADIS16260_READ_REG(lower_reg_address);
127 st->tx[1] = 0;
128
129 spi_message_init(&msg);
130 spi_message_add_tail(&xfers[0], &msg);
131 spi_message_add_tail(&xfers[1], &msg);
132 ret = spi_sync(st->us, &msg);
133 if (ret) {
134 dev_err(&st->us->dev,
135 "problem when reading 16 bit register 0x%02X",
136 lower_reg_address);
137 goto error_ret;
138 }
139 *val = (st->rx[0] << 8) | st->rx[1];
140
141error_ret:
142 mutex_unlock(&st->buf_lock);
143 return ret;
144}
145
146static ssize_t adis16260_read_frequency_available(struct device *dev, 27static ssize_t adis16260_read_frequency_available(struct device *dev,
147 struct device_attribute *attr, 28 struct device_attribute *attr,
148 char *buf) 29 char *buf)
149{ 30{
150 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 31 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
151 struct adis16260_state *st = iio_priv(indio_dev); 32 struct adis16260_state *st = iio_priv(indio_dev);
152 if (spi_get_device_id(st->us)->driver_data) 33 if (spi_get_device_id(st->adis.spi)->driver_data)
153 return sprintf(buf, "%s\n", "0.129 ~ 256"); 34 return sprintf(buf, "%s\n", "0.129 ~ 256");
154 else 35 else
155 return sprintf(buf, "%s\n", "256 2048"); 36 return sprintf(buf, "%s\n", "256 2048");
@@ -164,13 +45,11 @@ static ssize_t adis16260_read_frequency(struct device *dev,
164 int ret, len = 0; 45 int ret, len = 0;
165 u16 t; 46 u16 t;
166 int sps; 47 int sps;
167 ret = adis16260_spi_read_reg_16(indio_dev, 48 ret = adis_read_reg_16(&st->adis, ADIS16260_SMPL_PRD, &t);
168 ADIS16260_SMPL_PRD,
169 &t);
170 if (ret) 49 if (ret)
171 return ret; 50 return ret;
172 51
173 if (spi_get_device_id(st->us)->driver_data) /* If an adis16251 */ 52 if (spi_get_device_id(st->adis.spi)->driver_data) /* If an adis16251 */
174 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 8 : 256; 53 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 8 : 256;
175 else 54 else
176 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 66 : 2048; 55 sps = (t & ADIS16260_SMPL_PRD_TIME_BASE) ? 66 : 2048;
@@ -197,7 +76,7 @@ static ssize_t adis16260_write_frequency(struct device *dev,
197 return -EINVAL; 76 return -EINVAL;
198 77
199 mutex_lock(&indio_dev->mlock); 78 mutex_lock(&indio_dev->mlock);
200 if (spi_get_device_id(st->us)) { 79 if (spi_get_device_id(st->adis.spi)->driver_data) {
201 t = (256 / val); 80 t = (256 / val);
202 if (t > 0) 81 if (t > 0)
203 t--; 82 t--;
@@ -209,10 +88,10 @@ static ssize_t adis16260_write_frequency(struct device *dev,
209 t &= ADIS16260_SMPL_PRD_DIV_MASK; 88 t &= ADIS16260_SMPL_PRD_DIV_MASK;
210 } 89 }
211 if ((t & ADIS16260_SMPL_PRD_DIV_MASK) >= 0x0A) 90 if ((t & ADIS16260_SMPL_PRD_DIV_MASK) >= 0x0A)
212 st->us->max_speed_hz = ADIS16260_SPI_SLOW; 91 st->adis.spi->max_speed_hz = ADIS16260_SPI_SLOW;
213 else 92 else
214 st->us->max_speed_hz = ADIS16260_SPI_FAST; 93 st->adis.spi->max_speed_hz = ADIS16260_SPI_FAST;
215 ret = adis16260_spi_write_reg_8(indio_dev, 94 ret = adis_write_reg_8(&st->adis,
216 ADIS16260_SMPL_PRD, 95 ADIS16260_SMPL_PRD,
217 t); 96 t);
218 97
@@ -221,140 +100,20 @@ static ssize_t adis16260_write_frequency(struct device *dev,
221 return ret ? ret : len; 100 return ret ? ret : len;
222} 101}
223 102
224static int adis16260_reset(struct iio_dev *indio_dev)
225{
226 int ret;
227 ret = adis16260_spi_write_reg_8(indio_dev,
228 ADIS16260_GLOB_CMD,
229 ADIS16260_GLOB_CMD_SW_RESET);
230 if (ret)
231 dev_err(&indio_dev->dev, "problem resetting device");
232
233 return ret;
234}
235
236int adis16260_set_irq(struct iio_dev *indio_dev, bool enable)
237{
238 int ret;
239 u16 msc;
240 ret = adis16260_spi_read_reg_16(indio_dev, ADIS16260_MSC_CTRL, &msc);
241 if (ret)
242 goto error_ret;
243
244 msc |= ADIS16260_MSC_CTRL_DATA_RDY_POL_HIGH;
245 if (enable)
246 msc |= ADIS16260_MSC_CTRL_DATA_RDY_EN;
247 else
248 msc &= ~ADIS16260_MSC_CTRL_DATA_RDY_EN;
249
250 ret = adis16260_spi_write_reg_16(indio_dev, ADIS16260_MSC_CTRL, msc);
251 if (ret)
252 goto error_ret;
253
254error_ret:
255 return ret;
256}
257
258/* Power down the device */ 103/* Power down the device */
259static int adis16260_stop_device(struct iio_dev *indio_dev) 104static int adis16260_stop_device(struct iio_dev *indio_dev)
260{ 105{
106 struct adis16260_state *st = iio_priv(indio_dev);
261 int ret; 107 int ret;
262 u16 val = ADIS16260_SLP_CNT_POWER_OFF; 108 u16 val = ADIS16260_SLP_CNT_POWER_OFF;
263 109
264 ret = adis16260_spi_write_reg_16(indio_dev, ADIS16260_SLP_CNT, val); 110 ret = adis_write_reg_16(&st->adis, ADIS16260_SLP_CNT, val);
265 if (ret) 111 if (ret)
266 dev_err(&indio_dev->dev, "problem with turning device off: SLP_CNT"); 112 dev_err(&indio_dev->dev, "problem with turning device off: SLP_CNT");
267 113
268 return ret; 114 return ret;
269} 115}
270 116
271static int adis16260_self_test(struct iio_dev *indio_dev)
272{
273 int ret;
274 ret = adis16260_spi_write_reg_16(indio_dev,
275 ADIS16260_MSC_CTRL,
276 ADIS16260_MSC_CTRL_MEM_TEST);
277 if (ret) {
278 dev_err(&indio_dev->dev, "problem starting self test");
279 goto err_ret;
280 }
281
282 adis16260_check_status(indio_dev);
283
284err_ret:
285 return ret;
286}
287
288static int adis16260_check_status(struct iio_dev *indio_dev)
289{
290 u16 status;
291 int ret;
292 struct device *dev = &indio_dev->dev;
293
294 ret = adis16260_spi_read_reg_16(indio_dev,
295 ADIS16260_DIAG_STAT,
296 &status);
297
298 if (ret < 0) {
299 dev_err(dev, "Reading status failed\n");
300 goto error_ret;
301 }
302 ret = status & 0x7F;
303 if (status & ADIS16260_DIAG_STAT_FLASH_CHK)
304 dev_err(dev, "Flash checksum error\n");
305 if (status & ADIS16260_DIAG_STAT_SELF_TEST)
306 dev_err(dev, "Self test error\n");
307 if (status & ADIS16260_DIAG_STAT_OVERFLOW)
308 dev_err(dev, "Sensor overrange\n");
309 if (status & ADIS16260_DIAG_STAT_SPI_FAIL)
310 dev_err(dev, "SPI failure\n");
311 if (status & ADIS16260_DIAG_STAT_FLASH_UPT)
312 dev_err(dev, "Flash update failed\n");
313 if (status & ADIS16260_DIAG_STAT_POWER_HIGH)
314 dev_err(dev, "Power supply above 5.25V\n");
315 if (status & ADIS16260_DIAG_STAT_POWER_LOW)
316 dev_err(dev, "Power supply below 4.75V\n");
317
318error_ret:
319 return ret;
320}
321
322static int adis16260_initial_setup(struct iio_dev *indio_dev)
323{
324 int ret;
325 struct device *dev = &indio_dev->dev;
326
327 /* Disable IRQ */
328 ret = adis16260_set_irq(indio_dev, false);
329 if (ret) {
330 dev_err(dev, "disable irq failed");
331 goto err_ret;
332 }
333
334 /* Do self test */
335 ret = adis16260_self_test(indio_dev);
336 if (ret) {
337 dev_err(dev, "self test failure");
338 goto err_ret;
339 }
340
341 /* Read status register to check the result */
342 ret = adis16260_check_status(indio_dev);
343 if (ret) {
344 adis16260_reset(indio_dev);
345 dev_err(dev, "device not playing ball -> reset");
346 msleep(ADIS16260_STARTUP_DELAY);
347 ret = adis16260_check_status(indio_dev);
348 if (ret) {
349 dev_err(dev, "giving up");
350 goto err_ret;
351 }
352 }
353
354err_ret:
355 return ret;
356}
357
358static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO, 117static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
359 adis16260_read_frequency, 118 adis16260_read_frequency,
360 adis16260_write_frequency); 119 adis16260_write_frequency);
@@ -362,100 +121,26 @@ static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
362static IIO_DEVICE_ATTR(sampling_frequency_available, 121static IIO_DEVICE_ATTR(sampling_frequency_available,
363 S_IRUGO, adis16260_read_frequency_available, NULL, 0); 122 S_IRUGO, adis16260_read_frequency_available, NULL, 0);
364 123
365enum adis16260_channel {
366 gyro,
367 temp,
368 in_supply,
369 in_aux,
370 angle,
371};
372#define ADIS16260_GYRO_CHANNEL_SET(axis, mod) \ 124#define ADIS16260_GYRO_CHANNEL_SET(axis, mod) \
373 struct iio_chan_spec adis16260_channels_##axis[] = { \ 125struct iio_chan_spec adis16260_channels_##axis[] = { \
374 { \ 126 ADIS_GYRO_CHAN(mod, ADIS16260_GYRO_OUT, ADIS16260_SCAN_GYRO, \
375 .type = IIO_ANGL_VEL, \ 127 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT | \
376 .modified = 1, \ 128 IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT, 14), \
377 .channel2 = mod, \ 129 ADIS_INCLI_CHAN(mod, ADIS16260_ANGL_OUT, ADIS16260_SCAN_ANGL, 0, 14), \
378 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \ 130 ADIS_TEMP_CHAN(ADIS16260_TEMP_OUT, ADIS16260_SCAN_TEMP, 12), \
379 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT | \ 131 ADIS_SUPPLY_CHAN(ADIS16260_SUPPLY_OUT, ADIS16260_SCAN_SUPPLY, 12), \
380 IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT | \ 132 ADIS_AUX_ADC_CHAN(ADIS16260_AUX_ADC, ADIS16260_SCAN_AUX_ADC, 12), \
381 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \ 133 IIO_CHAN_SOFT_TIMESTAMP(5), \
382 .address = gyro, \ 134}
383 .scan_index = ADIS16260_SCAN_GYRO, \
384 .scan_type = { \
385 .sign = 's', \
386 .realbits = 14, \
387 .storagebits = 16, \
388 }, \
389 }, { \
390 .type = IIO_ANGL, \
391 .modified = 1, \
392 .channel2 = mod, \
393 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT, \
394 .address = angle, \
395 .scan_index = ADIS16260_SCAN_ANGL, \
396 .scan_type = { \
397 .sign = 'u', \
398 .realbits = 14, \
399 .storagebits = 16, \
400 }, \
401 }, { \
402 .type = IIO_TEMP, \
403 .indexed = 1, \
404 .channel = 0, \
405 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
406 IIO_CHAN_INFO_OFFSET_SEPARATE_BIT | \
407 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
408 .address = temp, \
409 .scan_index = ADIS16260_SCAN_TEMP, \
410 .scan_type = { \
411 .sign = 'u', \
412 .realbits = 12, \
413 .storagebits = 16, \
414 }, \
415 }, { \
416 .type = IIO_VOLTAGE, \
417 .indexed = 1, \
418 .channel = 0, \
419 .extend_name = "supply", \
420 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
421 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
422 .address = in_supply, \
423 .scan_index = ADIS16260_SCAN_SUPPLY, \
424 .scan_type = { \
425 .sign = 'u', \
426 .realbits = 12, \
427 .storagebits = 16, \
428 }, \
429 }, { \
430 .type = IIO_VOLTAGE, \
431 .indexed = 1, \
432 .channel = 1, \
433 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
434 IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
435 .address = in_aux, \
436 .scan_index = ADIS16260_SCAN_AUX_ADC, \
437 .scan_type = { \
438 .sign = 'u', \
439 .realbits = 12, \
440 .storagebits = 16, \
441 }, \
442 }, \
443 IIO_CHAN_SOFT_TIMESTAMP(5), \
444 }
445 135
446static const ADIS16260_GYRO_CHANNEL_SET(x, IIO_MOD_X); 136static const ADIS16260_GYRO_CHANNEL_SET(x, X);
447static const ADIS16260_GYRO_CHANNEL_SET(y, IIO_MOD_Y); 137static const ADIS16260_GYRO_CHANNEL_SET(y, Y);
448static const ADIS16260_GYRO_CHANNEL_SET(z, IIO_MOD_Z); 138static const ADIS16260_GYRO_CHANNEL_SET(z, Z);
449 139
450static const u8 adis16260_addresses[5][3] = { 140static const u8 adis16260_addresses[][2] = {
451 [gyro] = { ADIS16260_GYRO_OUT, 141 [ADIS16260_SCAN_GYRO] = { ADIS16260_GYRO_OFF, ADIS16260_GYRO_SCALE },
452 ADIS16260_GYRO_OFF,
453 ADIS16260_GYRO_SCALE },
454 [angle] = { ADIS16260_ANGL_OUT },
455 [in_supply] = { ADIS16260_SUPPLY_OUT },
456 [in_aux] = { ADIS16260_AUX_ADC },
457 [temp] = { ADIS16260_TEMP_OUT },
458}; 142};
143
459static int adis16260_read_raw(struct iio_dev *indio_dev, 144static int adis16260_read_raw(struct iio_dev *indio_dev,
460 struct iio_chan_spec const *chan, 145 struct iio_chan_spec const *chan,
461 int *val, int *val2, 146 int *val, int *val2,
@@ -469,34 +154,13 @@ static int adis16260_read_raw(struct iio_dev *indio_dev,
469 154
470 switch (mask) { 155 switch (mask) {
471 case IIO_CHAN_INFO_RAW: 156 case IIO_CHAN_INFO_RAW:
472 mutex_lock(&indio_dev->mlock); 157 return adis_single_conversion(indio_dev, chan,
473 addr = adis16260_addresses[chan->address][0]; 158 ADIS16260_ERROR_ACTIVE, val);
474 ret = adis16260_spi_read_reg_16(indio_dev, addr, &val16);
475 if (ret) {
476 mutex_unlock(&indio_dev->mlock);
477 return ret;
478 }
479
480 if (val16 & ADIS16260_ERROR_ACTIVE) {
481 ret = adis16260_check_status(indio_dev);
482 if (ret) {
483 mutex_unlock(&indio_dev->mlock);
484 return ret;
485 }
486 }
487 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
488 if (chan->scan_type.sign == 's')
489 val16 = (s16)(val16 <<
490 (16 - chan->scan_type.realbits)) >>
491 (16 - chan->scan_type.realbits);
492 *val = val16;
493 mutex_unlock(&indio_dev->mlock);
494 return IIO_VAL_INT;
495 case IIO_CHAN_INFO_SCALE: 159 case IIO_CHAN_INFO_SCALE:
496 switch (chan->type) { 160 switch (chan->type) {
497 case IIO_ANGL_VEL: 161 case IIO_ANGL_VEL:
498 *val = 0; 162 *val = 0;
499 if (spi_get_device_id(st->us)->driver_data) { 163 if (spi_get_device_id(st->adis.spi)->driver_data) {
500 /* 0.01832 degree / sec */ 164 /* 0.01832 degree / sec */
501 *val2 = IIO_DEGREE_TO_RAD(18320); 165 *val2 = IIO_DEGREE_TO_RAD(18320);
502 } else { 166 } else {
@@ -533,8 +197,8 @@ static int adis16260_read_raw(struct iio_dev *indio_dev,
533 return -EINVAL; 197 return -EINVAL;
534 } 198 }
535 mutex_lock(&indio_dev->mlock); 199 mutex_lock(&indio_dev->mlock);
536 addr = adis16260_addresses[chan->address][1]; 200 addr = adis16260_addresses[chan->scan_index][0];
537 ret = adis16260_spi_read_reg_16(indio_dev, addr, &val16); 201 ret = adis_read_reg_16(&st->adis, addr, &val16);
538 if (ret) { 202 if (ret) {
539 mutex_unlock(&indio_dev->mlock); 203 mutex_unlock(&indio_dev->mlock);
540 return ret; 204 return ret;
@@ -553,8 +217,8 @@ static int adis16260_read_raw(struct iio_dev *indio_dev,
553 return -EINVAL; 217 return -EINVAL;
554 } 218 }
555 mutex_lock(&indio_dev->mlock); 219 mutex_lock(&indio_dev->mlock);
556 addr = adis16260_addresses[chan->address][2]; 220 addr = adis16260_addresses[chan->scan_index][1];
557 ret = adis16260_spi_read_reg_16(indio_dev, addr, &val16); 221 ret = adis_read_reg_16(&st->adis, addr, &val16);
558 if (ret) { 222 if (ret) {
559 mutex_unlock(&indio_dev->mlock); 223 mutex_unlock(&indio_dev->mlock);
560 return ret; 224 return ret;
@@ -572,18 +236,19 @@ static int adis16260_write_raw(struct iio_dev *indio_dev,
572 int val2, 236 int val2,
573 long mask) 237 long mask)
574{ 238{
239 struct adis16260_state *st = iio_priv(indio_dev);
575 int bits = 12; 240 int bits = 12;
576 s16 val16; 241 s16 val16;
577 u8 addr; 242 u8 addr;
578 switch (mask) { 243 switch (mask) {
579 case IIO_CHAN_INFO_CALIBBIAS: 244 case IIO_CHAN_INFO_CALIBBIAS:
580 val16 = val & ((1 << bits) - 1); 245 val16 = val & ((1 << bits) - 1);
581 addr = adis16260_addresses[chan->address][1]; 246 addr = adis16260_addresses[chan->scan_index][0];
582 return adis16260_spi_write_reg_16(indio_dev, addr, val16); 247 return adis_write_reg_16(&st->adis, addr, val16);
583 case IIO_CHAN_INFO_CALIBSCALE: 248 case IIO_CHAN_INFO_CALIBSCALE:
584 val16 = val & ((1 << bits) - 1); 249 val16 = val & ((1 << bits) - 1);
585 addr = adis16260_addresses[chan->address][2]; 250 addr = adis16260_addresses[chan->scan_index][1];
586 return adis16260_spi_write_reg_16(indio_dev, addr, val16); 251 return adis_write_reg_16(&st->adis, addr, val16);
587 } 252 }
588 return -EINVAL; 253 return -EINVAL;
589} 254}
@@ -605,6 +270,36 @@ static const struct iio_info adis16260_info = {
605 .driver_module = THIS_MODULE, 270 .driver_module = THIS_MODULE,
606}; 271};
607 272
273static const char * const adis1620_status_error_msgs[] = {
274 [ADIS16260_DIAG_STAT_FLASH_CHK_BIT] = "Flash checksum error",
275 [ADIS16260_DIAG_STAT_SELF_TEST_BIT] = "Self test error",
276 [ADIS16260_DIAG_STAT_OVERFLOW_BIT] = "Sensor overrange",
277 [ADIS16260_DIAG_STAT_SPI_FAIL_BIT] = "SPI failure",
278 [ADIS16260_DIAG_STAT_FLASH_UPT_BIT] = "Flash update failed",
279 [ADIS16260_DIAG_STAT_POWER_HIGH_BIT] = "Power supply above 5.25",
280 [ADIS16260_DIAG_STAT_POWER_LOW_BIT] = "Power supply below 4.75",
281};
282
283static const struct adis_data adis16260_data = {
284 .write_delay = 30,
285 .read_delay = 30,
286 .msc_ctrl_reg = ADIS16260_MSC_CTRL,
287 .glob_cmd_reg = ADIS16260_GLOB_CMD,
288 .diag_stat_reg = ADIS16260_DIAG_STAT,
289
290 .self_test_mask = ADIS16260_MSC_CTRL_MEM_TEST,
291 .startup_delay = ADIS16260_STARTUP_DELAY,
292
293 .status_error_msgs = adis1620_status_error_msgs,
294 .status_error_mask = BIT(ADIS16260_DIAG_STAT_FLASH_CHK_BIT) |
295 BIT(ADIS16260_DIAG_STAT_SELF_TEST_BIT) |
296 BIT(ADIS16260_DIAG_STAT_OVERFLOW_BIT) |
297 BIT(ADIS16260_DIAG_STAT_SPI_FAIL_BIT) |
298 BIT(ADIS16260_DIAG_STAT_FLASH_UPT_BIT) |
299 BIT(ADIS16260_DIAG_STAT_POWER_HIGH_BIT) |
300 BIT(ADIS16260_DIAG_STAT_POWER_LOW_BIT),
301};
302
608static int __devinit adis16260_probe(struct spi_device *spi) 303static int __devinit adis16260_probe(struct spi_device *spi)
609{ 304{
610 int ret; 305 int ret;
@@ -624,10 +319,7 @@ static int __devinit adis16260_probe(struct spi_device *spi)
624 /* this is only used for removal purposes */ 319 /* this is only used for removal purposes */
625 spi_set_drvdata(spi, indio_dev); 320 spi_set_drvdata(spi, indio_dev);
626 321
627 st->us = spi; 322 indio_dev->name = spi_get_device_id(spi)->name;
628 mutex_init(&st->buf_lock);
629
630 indio_dev->name = spi_get_device_id(st->us)->name;
631 indio_dev->dev.parent = &spi->dev; 323 indio_dev->dev.parent = &spi->dev;
632 indio_dev->info = &adis16260_info; 324 indio_dev->info = &adis16260_info;
633 indio_dev->num_channels 325 indio_dev->num_channels
@@ -651,17 +343,14 @@ static int __devinit adis16260_probe(struct spi_device *spi)
651 indio_dev->num_channels = ARRAY_SIZE(adis16260_channels_x); 343 indio_dev->num_channels = ARRAY_SIZE(adis16260_channels_x);
652 indio_dev->modes = INDIO_DIRECT_MODE; 344 indio_dev->modes = INDIO_DIRECT_MODE;
653 345
654 ret = adis16260_configure_ring(indio_dev); 346 ret = adis_init(&st->adis, indio_dev, spi, &adis16260_data);
347 if (ret)
348 goto error_free_dev;
349
350 ret = adis_setup_buffer_and_trigger(&st->adis, indio_dev, NULL);
655 if (ret) 351 if (ret)
656 goto error_free_dev; 352 goto error_free_dev;
657 353
658 ret = iio_buffer_register(indio_dev,
659 indio_dev->channels,
660 ARRAY_SIZE(adis16260_channels_x));
661 if (ret) {
662 printk(KERN_ERR "failed to initialize the ring\n");
663 goto error_unreg_ring_funcs;
664 }
665 if (indio_dev->buffer) { 354 if (indio_dev->buffer) {
666 /* Set default scan mode */ 355 /* Set default scan mode */
667 iio_scan_mask_set(indio_dev, indio_dev->buffer, 356 iio_scan_mask_set(indio_dev, indio_dev->buffer,
@@ -675,28 +364,19 @@ static int __devinit adis16260_probe(struct spi_device *spi)
675 iio_scan_mask_set(indio_dev, indio_dev->buffer, 364 iio_scan_mask_set(indio_dev, indio_dev->buffer,
676 ADIS16260_SCAN_ANGL); 365 ADIS16260_SCAN_ANGL);
677 } 366 }
678 if (spi->irq) {
679 ret = adis16260_probe_trigger(indio_dev);
680 if (ret)
681 goto error_uninitialize_ring;
682 }
683 367
684 /* Get the device into a sane initial state */ 368 /* Get the device into a sane initial state */
685 ret = adis16260_initial_setup(indio_dev); 369 ret = adis_initial_startup(&st->adis);
686 if (ret) 370 if (ret)
687 goto error_remove_trigger; 371 goto error_cleanup_buffer_trigger;
688 ret = iio_device_register(indio_dev); 372 ret = iio_device_register(indio_dev);
689 if (ret) 373 if (ret)
690 goto error_remove_trigger; 374 goto error_cleanup_buffer_trigger;
691 375
692 return 0; 376 return 0;
693 377
694error_remove_trigger: 378error_cleanup_buffer_trigger:
695 adis16260_remove_trigger(indio_dev); 379 adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);
696error_uninitialize_ring:
697 iio_buffer_unregister(indio_dev);
698error_unreg_ring_funcs:
699 adis16260_unconfigure_ring(indio_dev);
700error_free_dev: 380error_free_dev:
701 iio_device_free(indio_dev); 381 iio_device_free(indio_dev);
702error_ret: 382error_ret:
@@ -706,12 +386,11 @@ error_ret:
706static int __devexit adis16260_remove(struct spi_device *spi) 386static int __devexit adis16260_remove(struct spi_device *spi)
707{ 387{
708 struct iio_dev *indio_dev = spi_get_drvdata(spi); 388 struct iio_dev *indio_dev = spi_get_drvdata(spi);
389 struct adis16260_state *st = iio_priv(indio_dev);
709 390
710 iio_device_unregister(indio_dev); 391 iio_device_unregister(indio_dev);
711 adis16260_stop_device(indio_dev); 392 adis16260_stop_device(indio_dev);
712 adis16260_remove_trigger(indio_dev); 393 adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);
713 iio_buffer_unregister(indio_dev);
714 adis16260_unconfigure_ring(indio_dev);
715 iio_device_free(indio_dev); 394 iio_device_free(indio_dev);
716 395
717 return 0; 396 return 0;
diff --git a/drivers/staging/iio/gyro/adis16260_ring.c b/drivers/staging/iio/gyro/adis16260_ring.c
deleted file mode 100644
index d6c48f850a9..00000000000
--- a/drivers/staging/iio/gyro/adis16260_ring.c
+++ /dev/null
@@ -1,136 +0,0 @@
1#include <linux/export.h>
2#include <linux/interrupt.h>
3#include <linux/mutex.h>
4#include <linux/kernel.h>
5#include <linux/spi/spi.h>
6#include <linux/slab.h>
7
8#include <linux/iio/iio.h>
9#include "../ring_sw.h"
10#include <linux/iio/trigger_consumer.h>
11#include "adis16260.h"
12
13/**
14 * adis16260_read_ring_data() read data registers which will be placed into ring
15 * @indio_dev: the IIO device
16 * @rx: somewhere to pass back the value read
17 **/
18static int adis16260_read_ring_data(struct iio_dev *indio_dev, u8 *rx)
19{
20 struct spi_message msg;
21 struct adis16260_state *st = iio_priv(indio_dev);
22 struct spi_transfer xfers[ADIS16260_OUTPUTS + 1];
23 int ret;
24 int i;
25
26 mutex_lock(&st->buf_lock);
27
28 spi_message_init(&msg);
29
30 memset(xfers, 0, sizeof(xfers));
31 for (i = 0; i <= ADIS16260_OUTPUTS; i++) {
32 xfers[i].bits_per_word = 8;
33 xfers[i].cs_change = 1;
34 xfers[i].len = 2;
35 xfers[i].delay_usecs = 30;
36 xfers[i].tx_buf = st->tx + 2 * i;
37 if (i < 2) /* SUPPLY_OUT:0x02 GYRO_OUT:0x04 */
38 st->tx[2 * i]
39 = ADIS16260_READ_REG(ADIS16260_SUPPLY_OUT
40 + 2 * i);
41 else /* 0x06 to 0x09 is reserved */
42 st->tx[2 * i]
43 = ADIS16260_READ_REG(ADIS16260_SUPPLY_OUT
44 + 2 * i + 4);
45 st->tx[2 * i + 1] = 0;
46 if (i >= 1)
47 xfers[i].rx_buf = rx + 2 * (i - 1);
48 spi_message_add_tail(&xfers[i], &msg);
49 }
50
51 ret = spi_sync(st->us, &msg);
52 if (ret)
53 dev_err(&st->us->dev, "problem when burst reading");
54
55 mutex_unlock(&st->buf_lock);
56
57 return ret;
58}
59
60static irqreturn_t adis16260_trigger_handler(int irq, void *p)
61{
62 struct iio_poll_func *pf = p;
63 struct iio_dev *indio_dev = pf->indio_dev;
64 struct adis16260_state *st = iio_priv(indio_dev);
65 int i = 0;
66 s16 *data;
67
68 data = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
69 if (data == NULL) {
70 dev_err(&st->us->dev, "memory alloc failed in ring bh");
71 goto done;
72 }
73
74 if (!bitmap_empty(indio_dev->active_scan_mask, indio_dev->masklength) &&
75 adis16260_read_ring_data(indio_dev, st->rx) >= 0)
76 for (; i < bitmap_weight(indio_dev->active_scan_mask,
77 indio_dev->masklength); i++)
78 data[i] = be16_to_cpup((__be16 *)&(st->rx[i*2]));
79
80 /* Guaranteed to be aligned with 8 byte boundary */
81 if (indio_dev->scan_timestamp)
82 *((s64 *)(data + ((i + 3)/4)*4)) = pf->timestamp;
83
84 iio_push_to_buffers(indio_dev, (u8 *)data);
85
86 kfree(data);
87done:
88 iio_trigger_notify_done(indio_dev->trig);
89
90 return IRQ_HANDLED;
91}
92
93void adis16260_unconfigure_ring(struct iio_dev *indio_dev)
94{
95 iio_dealloc_pollfunc(indio_dev->pollfunc);
96 iio_sw_rb_free(indio_dev->buffer);
97}
98
99static const struct iio_buffer_setup_ops adis16260_ring_setup_ops = {
100 .preenable = &iio_sw_buffer_preenable,
101 .postenable = &iio_triggered_buffer_postenable,
102 .predisable = &iio_triggered_buffer_predisable,
103};
104
105int adis16260_configure_ring(struct iio_dev *indio_dev)
106{
107 int ret = 0;
108 struct iio_buffer *ring;
109
110 ring = iio_sw_rb_allocate(indio_dev);
111 if (!ring) {
112 ret = -ENOMEM;
113 return ret;
114 }
115 indio_dev->buffer = ring;
116 ring->scan_timestamp = true;
117 indio_dev->setup_ops = &adis16260_ring_setup_ops;
118
119 indio_dev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
120 &adis16260_trigger_handler,
121 IRQF_ONESHOT,
122 indio_dev,
123 "adis16260_consumer%d",
124 indio_dev->id);
125 if (indio_dev->pollfunc == NULL) {
126 ret = -ENOMEM;
127 goto error_iio_sw_rb_free;
128 }
129
130 indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
131 return 0;
132
133error_iio_sw_rb_free:
134 iio_sw_rb_free(indio_dev->buffer);
135 return ret;
136}
diff --git a/drivers/staging/iio/gyro/adis16260_trigger.c b/drivers/staging/iio/gyro/adis16260_trigger.c
deleted file mode 100644
index 034559e4d5b..00000000000
--- a/drivers/staging/iio/gyro/adis16260_trigger.c
+++ /dev/null
@@ -1,75 +0,0 @@
1#include <linux/interrupt.h>
2#include <linux/kernel.h>
3#include <linux/spi/spi.h>
4#include <linux/export.h>
5
6#include <linux/iio/iio.h>
7#include <linux/iio/trigger.h>
8#include "adis16260.h"
9
10/**
11 * adis16260_data_rdy_trigger_set_state() set datardy interrupt state
12 **/
13static int adis16260_data_rdy_trigger_set_state(struct iio_trigger *trig,
14 bool state)
15{
16 struct iio_dev *indio_dev = trig->private_data;
17
18 dev_dbg(&indio_dev->dev, "%s (%d)\n", __func__, state);
19 return adis16260_set_irq(indio_dev, state);
20}
21
22static const struct iio_trigger_ops adis16260_trigger_ops = {
23 .owner = THIS_MODULE,
24 .set_trigger_state = &adis16260_data_rdy_trigger_set_state,
25};
26
27int adis16260_probe_trigger(struct iio_dev *indio_dev)
28{
29 int ret;
30 struct adis16260_state *st = iio_priv(indio_dev);
31
32 st->trig = iio_trigger_alloc("%s-dev%d",
33 spi_get_device_id(st->us)->name,
34 indio_dev->id);
35 if (st->trig == NULL) {
36 ret = -ENOMEM;
37 goto error_ret;
38 }
39
40 ret = request_irq(st->us->irq,
41 &iio_trigger_generic_data_rdy_poll,
42 IRQF_TRIGGER_RISING,
43 "adis16260",
44 st->trig);
45 if (ret)
46 goto error_free_trig;
47
48 st->trig->dev.parent = &st->us->dev;
49 st->trig->ops = &adis16260_trigger_ops;
50 st->trig->private_data = indio_dev;
51 ret = iio_trigger_register(st->trig);
52
53 /* select default trigger */
54 indio_dev->trig = st->trig;
55 if (ret)
56 goto error_free_irq;
57
58 return 0;
59
60error_free_irq:
61 free_irq(st->us->irq, st->trig);
62error_free_trig:
63 iio_trigger_free(st->trig);
64error_ret:
65 return ret;
66}
67
68void adis16260_remove_trigger(struct iio_dev *indio_dev)
69{
70 struct adis16260_state *st = iio_priv(indio_dev);
71
72 iio_trigger_unregister(st->trig);
73 free_irq(st->us->irq, st->trig);
74 iio_trigger_free(st->trig);
75}
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-22 13:33:37 -0400