aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/staging/iio
diff options
context:
space:
mode:
authorLars-Peter Clausen <lars@metafoo.de>2012-11-13 08:28:00 -0500
committerJonathan Cameron <jic23@kernel.org>2012-11-19 17:22:09 -0500
commit9d5e9fdf0f8846e014125f8e57fe5f3e03c8839f (patch)
treefc6c4483625d3f1624c73e55d290facd8bf050c6 /drivers/staging/iio
parent5cb7cb1191fc8fc0fcf9a1cc43b9ed7168c5c44a (diff)
staging:iio:adis16260: Use adis library
Use the new adis library for the adis16260 driver. This allows us to completely scrap the adis16260 buffer and trigger code and about half of the core driver code. Signed-off-by: Lars-Peter Clausen <lars@metafoo.de> Signed-off-by: Jonathan Cameron <jic23@kernel.org>
Diffstat (limited to 'drivers/staging/iio')
-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 11:24:15 -0400