← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to drivers/staging/iio/accel/adis16201_core.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/iio/accel/adis16201_core.c
6
6
 * Licensed under the GPL-2 or later.
7
7
 */
8
8
 
9
 
#include <linux/interrupt.h>
10
 
#include <linux/irq.h>
11
 
#include <linux/gpio.h>
12
9
#include <linux/delay.h>
13
10
#include <linux/mutex.h>
14
11
#include <linux/device.h>
16
13
#include <linux/spi/spi.h>
17
14
#include <linux/slab.h>
18
15
#include <linux/sysfs.h>
19
 
#include <linux/list.h>
20
16
 
21
17
#include "../iio.h"
22
18
#include "../sysfs.h"
 
19
#include "../ring_generic.h"
 
20
 
23
21
#include "accel.h"
24
22
#include "inclinometer.h"
25
 
#include "../gyro/gyro.h"
26
23
#include "../adc/adc.h"
27
24
 
28
25
#include "adis16201.h"
29
26
 
30
27
#define DRIVER_NAME             "adis16201"
31
28
 
32
 
static int adis16201_check_status(struct device *dev);
 
29
enum adis16201_chan {
 
30
        in_supply,
 
31
        temp,
 
32
        accel_x,
 
33
        accel_y,
 
34
        incli_x,
 
35
        incli_y,
 
36
        in_aux,
 
37
};
33
38
 
34
39
/**
35
40
 * adis16201_spi_write_reg_8() - write single byte to a register
57
62
 
58
63
/**
59
64
 * adis16201_spi_write_reg_16() - write 2 bytes to a pair of registers
60
 
 * @dev: device associated with child of actual device (iio_dev or iio_trig)
 
65
 * @indio_dev: iio device associated with child of actual device
61
66
 * @reg_address: the address of the lower of the two registers. Second register
62
67
 *               is assumed to have address one greater.
63
68
 * @val: value to be written
64
69
 **/
65
 
static int adis16201_spi_write_reg_16(struct device *dev,
66
 
                u8 lower_reg_address,
67
 
                u16 value)
 
70
static int adis16201_spi_write_reg_16(struct iio_dev *indio_dev,
 
71
                                      u8 lower_reg_address,
 
72
                                      u16 value)
68
73
{
69
74
        int ret;
70
75
        struct spi_message msg;
71
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
72
76
        struct adis16201_state *st = iio_dev_get_devdata(indio_dev);
73
77
        struct spi_transfer xfers[] = {
74
78
                {
80
84
                        .tx_buf = st->tx + 2,
81
85
                        .bits_per_word = 8,
82
86
                        .len = 2,
83
 
                        .cs_change = 1,
84
87
                },
85
88
        };
86
89
 
101
104
 
102
105
/**
103
106
 * adis16201_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)
 
107
 * @indio_dev: iio device associated with child of actual device
105
108
 * @reg_address: the address of the lower of the two registers. Second register
106
109
 *               is assumed to have address one greater.
107
110
 * @val: somewhere to pass back the value read
108
111
 **/
109
 
static int adis16201_spi_read_reg_16(struct device *dev,
 
112
static int adis16201_spi_read_reg_16(struct iio_dev *indio_dev,
110
113
                u8 lower_reg_address,
111
114
                u16 *val)
112
115
{
113
116
        struct spi_message msg;
114
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
115
117
        struct adis16201_state *st = iio_dev_get_devdata(indio_dev);
116
118
        int ret;
117
119
        struct spi_transfer xfers[] = {
125
127
                        .rx_buf = st->rx,
126
128
                        .bits_per_word = 8,
127
129
                        .len = 2,
128
 
                        .cs_change = 1,
129
130
                        .delay_usecs = 20,
130
131
                },
131
132
        };
150
151
        return ret;
151
152
}
152
153
 
153
 
static ssize_t adis16201_read_12bit_unsigned(struct device *dev,
154
 
                struct device_attribute *attr,
155
 
                char *buf)
156
 
{
157
 
        int ret;
158
 
        u16 val = 0;
159
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
160
 
 
161
 
        ret = adis16201_spi_read_reg_16(dev, this_attr->address, &val);
162
 
        if (ret)
163
 
                return ret;
164
 
 
165
 
        if (val & ADIS16201_ERROR_ACTIVE) {
166
 
                ret = adis16201_check_status(dev);
167
 
                if (ret)
168
 
                        return ret;
169
 
        }
170
 
 
171
 
        return sprintf(buf, "%u\n", val & 0x0FFF);
172
 
}
173
 
 
174
 
static ssize_t adis16201_read_temp(struct device *dev,
175
 
                struct device_attribute *attr,
176
 
                char *buf)
177
 
{
178
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
179
 
        ssize_t ret;
180
 
        u16 val;
181
 
 
182
 
        /* Take the iio_dev status lock */
183
 
        mutex_lock(&indio_dev->mlock);
184
 
 
185
 
        ret = adis16201_spi_read_reg_16(dev, ADIS16201_TEMP_OUT, (u16 *)&val);
186
 
        if (ret)
187
 
                goto error_ret;
188
 
 
189
 
        if (val & ADIS16201_ERROR_ACTIVE) {
190
 
                ret = adis16201_check_status(dev);
191
 
                if (ret)
192
 
                        goto error_ret;
193
 
        }
194
 
 
195
 
        val &= 0xFFF;
196
 
        ret = sprintf(buf, "%d\n", val);
197
 
 
198
 
error_ret:
199
 
        mutex_unlock(&indio_dev->mlock);
200
 
        return ret;
201
 
}
202
 
 
203
 
static ssize_t adis16201_read_9bit_signed(struct device *dev,
204
 
                struct device_attribute *attr,
205
 
                char *buf)
206
 
{
207
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
208
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
209
 
        s16 val = 0;
210
 
        ssize_t ret;
211
 
 
212
 
        mutex_lock(&indio_dev->mlock);
213
 
 
214
 
        ret = adis16201_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
215
 
        if (!ret) {
216
 
                if (val & ADIS16201_ERROR_ACTIVE) {
217
 
                        ret = adis16201_check_status(dev);
218
 
                        if (ret)
219
 
                                goto error_ret;
220
 
                }
221
 
                val = ((s16)(val << 7) >> 7);
222
 
                ret = sprintf(buf, "%d\n", val);
223
 
        }
224
 
 
225
 
error_ret:
226
 
        mutex_unlock(&indio_dev->mlock);
227
 
 
228
 
        return ret;
229
 
}
230
 
 
231
 
static ssize_t adis16201_read_12bit_signed(struct device *dev,
232
 
                struct device_attribute *attr,
233
 
                char *buf)
234
 
{
235
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
236
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
237
 
        s16 val = 0;
238
 
        ssize_t ret;
239
 
 
240
 
        mutex_lock(&indio_dev->mlock);
241
 
 
242
 
        ret = adis16201_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
243
 
        if (!ret) {
244
 
                if (val & ADIS16201_ERROR_ACTIVE) {
245
 
                        ret = adis16201_check_status(dev);
246
 
                        if (ret)
247
 
                                goto error_ret;
248
 
                }
249
 
 
250
 
                val = ((s16)(val << 4) >> 4);
251
 
                ret = sprintf(buf, "%d\n", val);
252
 
        }
253
 
 
254
 
error_ret:
255
 
        mutex_unlock(&indio_dev->mlock);
256
 
 
257
 
        return ret;
258
 
}
259
 
 
260
 
static ssize_t adis16201_read_14bit_signed(struct device *dev,
261
 
                struct device_attribute *attr,
262
 
                char *buf)
263
 
{
264
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
265
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
266
 
        s16 val = 0;
267
 
        ssize_t ret;
268
 
 
269
 
        mutex_lock(&indio_dev->mlock);
270
 
 
271
 
        ret = adis16201_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
272
 
        if (!ret) {
273
 
                if (val & ADIS16201_ERROR_ACTIVE) {
274
 
                        ret = adis16201_check_status(dev);
275
 
                        if (ret)
276
 
                                goto error_ret;
277
 
                }
278
 
 
279
 
                val = ((s16)(val << 2) >> 2);
280
 
                ret = sprintf(buf, "%d\n", val);
281
 
        }
282
 
 
283
 
error_ret:
284
 
        mutex_unlock(&indio_dev->mlock);
285
 
 
286
 
        return ret;
287
 
}
288
 
 
289
 
static ssize_t adis16201_write_16bit(struct device *dev,
290
 
                struct device_attribute *attr,
291
 
                const char *buf,
292
 
                size_t len)
293
 
{
294
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
295
 
        int ret;
296
 
        long val;
297
 
 
298
 
        ret = strict_strtol(buf, 10, &val);
299
 
        if (ret)
300
 
                goto error_ret;
301
 
        ret = adis16201_spi_write_reg_16(dev, this_attr->address, val);
302
 
 
303
 
error_ret:
304
 
        return ret ? ret : len;
305
 
}
306
 
 
307
154
static int adis16201_reset(struct device *dev)
308
155
{
309
156
        int ret;
331
178
        return -EINVAL;
332
179
}
333
180
 
334
 
int adis16201_set_irq(struct device *dev, bool enable)
 
181
int adis16201_set_irq(struct iio_dev *indio_dev, bool enable)
335
182
{
336
183
        int ret = 0;
337
184
        u16 msc;
338
185
 
339
 
        ret = adis16201_spi_read_reg_16(dev, ADIS16201_MSC_CTRL, &msc);
 
186
        ret = adis16201_spi_read_reg_16(indio_dev, ADIS16201_MSC_CTRL, &msc);
340
187
        if (ret)
341
188
                goto error_ret;
342
189
 
347
194
        else
348
195
                msc &= ~ADIS16201_MSC_CTRL_DATA_RDY_EN;
349
196
 
350
 
        ret = adis16201_spi_write_reg_16(dev, ADIS16201_MSC_CTRL, msc);
 
197
        ret = adis16201_spi_write_reg_16(indio_dev, ADIS16201_MSC_CTRL, msc);
351
198
 
352
199
error_ret:
353
200
        return ret;
354
201
}
355
202
 
356
 
static int adis16201_check_status(struct device *dev)
 
203
static int adis16201_check_status(struct iio_dev *indio_dev)
357
204
{
358
205
        u16 status;
359
206
        int ret;
360
207
 
361
 
        ret = adis16201_spi_read_reg_16(dev, ADIS16201_DIAG_STAT, &status);
 
208
        ret = adis16201_spi_read_reg_16(indio_dev,
 
209
                                        ADIS16201_DIAG_STAT, &status);
362
210
        if (ret < 0) {
363
 
                dev_err(dev, "Reading status failed\n");
 
211
                dev_err(&indio_dev->dev, "Reading status failed\n");
364
212
                goto error_ret;
365
213
        }
366
214
        ret = status & 0xF;
368
216
                ret = -EFAULT;
369
217
 
370
218
        if (status & ADIS16201_DIAG_STAT_SPI_FAIL)
371
 
                dev_err(dev, "SPI failure\n");
 
219
                dev_err(&indio_dev->dev, "SPI failure\n");
372
220
        if (status & ADIS16201_DIAG_STAT_FLASH_UPT)
373
 
                dev_err(dev, "Flash update failed\n");
 
221
                dev_err(&indio_dev->dev, "Flash update failed\n");
374
222
        if (status & ADIS16201_DIAG_STAT_POWER_HIGH)
375
 
                dev_err(dev, "Power supply above 3.625V\n");
 
223
                dev_err(&indio_dev->dev, "Power supply above 3.625V\n");
376
224
        if (status & ADIS16201_DIAG_STAT_POWER_LOW)
377
 
                dev_err(dev, "Power supply below 3.15V\n");
 
225
                dev_err(&indio_dev->dev, "Power supply below 3.15V\n");
378
226
 
379
227
error_ret:
380
228
        return ret;
381
229
}
382
230
 
383
 
static int adis16201_self_test(struct device *dev)
 
231
static int adis16201_self_test(struct iio_dev *indio_dev)
384
232
{
385
233
        int ret;
386
 
        ret = adis16201_spi_write_reg_16(dev,
 
234
        ret = adis16201_spi_write_reg_16(indio_dev,
387
235
                        ADIS16201_MSC_CTRL,
388
236
                        ADIS16201_MSC_CTRL_SELF_TEST_EN);
389
237
        if (ret) {
390
 
                dev_err(dev, "problem starting self test");
 
238
                dev_err(&indio_dev->dev, "problem starting self test");
391
239
                goto err_ret;
392
240
        }
393
241
 
394
 
        ret = adis16201_check_status(dev);
 
242
        ret = adis16201_check_status(indio_dev);
395
243
 
396
244
err_ret:
397
245
        return ret;
403
251
        struct device *dev = &st->indio_dev->dev;
404
252
 
405
253
        /* Disable IRQ */
406
 
        ret = adis16201_set_irq(dev, false);
 
254
        ret = adis16201_set_irq(st->indio_dev, false);
407
255
        if (ret) {
408
256
                dev_err(dev, "disable irq failed");
409
257
                goto err_ret;
410
258
        }
411
259
 
412
260
        /* Do self test */
413
 
        ret = adis16201_self_test(dev);
 
261
        ret = adis16201_self_test(st->indio_dev);
414
262
        if (ret) {
415
263
                dev_err(dev, "self test failure");
416
264
                goto err_ret;
417
265
        }
418
266
 
419
267
        /* Read status register to check the result */
420
 
        ret = adis16201_check_status(dev);
 
268
        ret = adis16201_check_status(st->indio_dev);
421
269
        if (ret) {
422
270
                adis16201_reset(dev);
423
271
                dev_err(dev, "device not playing ball -> reset");
424
272
                msleep(ADIS16201_STARTUP_DELAY);
425
 
                ret = adis16201_check_status(dev);
 
273
                ret = adis16201_check_status(st->indio_dev);
426
274
                if (ret) {
427
275
                        dev_err(dev, "giving up");
428
276
                        goto err_ret;
436
284
        return ret;
437
285
}
438
286
 
439
 
static IIO_DEV_ATTR_IN_NAMED_RAW(0, supply, adis16201_read_12bit_unsigned,
440
 
                ADIS16201_SUPPLY_OUT);
441
 
static IIO_CONST_ATTR(in0_supply_scale, "0.00122");
442
 
static IIO_DEV_ATTR_IN_RAW(1, adis16201_read_12bit_unsigned,
443
 
                ADIS16201_AUX_ADC);
444
 
static IIO_CONST_ATTR(in1_scale, "0.00061");
445
 
 
446
 
static IIO_DEV_ATTR_ACCEL_X(adis16201_read_14bit_signed,
447
 
                ADIS16201_XACCL_OUT);
448
 
static IIO_DEV_ATTR_ACCEL_Y(adis16201_read_14bit_signed,
449
 
                ADIS16201_YACCL_OUT);
450
 
static IIO_DEV_ATTR_ACCEL_X_OFFSET(S_IWUSR | S_IRUGO,
451
 
                adis16201_read_12bit_signed,
452
 
                adis16201_write_16bit,
453
 
                ADIS16201_XACCL_OFFS);
454
 
static IIO_DEV_ATTR_ACCEL_Y_OFFSET(S_IWUSR | S_IRUGO,
455
 
                adis16201_read_12bit_signed,
456
 
                adis16201_write_16bit,
457
 
                ADIS16201_YACCL_OFFS);
458
 
static IIO_CONST_ATTR(accel_scale, "0.4625");
459
 
 
460
 
static IIO_DEV_ATTR_INCLI_X(adis16201_read_14bit_signed,
461
 
                ADIS16201_XINCL_OUT);
462
 
static IIO_DEV_ATTR_INCLI_Y(adis16201_read_14bit_signed,
463
 
                ADIS16201_YINCL_OUT);
464
 
static IIO_DEV_ATTR_INCLI_X_OFFSET(S_IWUSR | S_IRUGO,
465
 
                adis16201_read_9bit_signed,
466
 
                adis16201_write_16bit,
467
 
                ADIS16201_XACCL_OFFS);
468
 
static IIO_DEV_ATTR_INCLI_Y_OFFSET(S_IWUSR | S_IRUGO,
469
 
                adis16201_read_9bit_signed,
470
 
                adis16201_write_16bit,
471
 
                ADIS16201_YACCL_OFFS);
472
 
static IIO_CONST_ATTR(incli_scale, "0.1");
473
 
 
474
 
static IIO_DEV_ATTR_TEMP_RAW(adis16201_read_temp);
475
 
static IIO_CONST_ATTR(temp_offset, "25");
476
 
static IIO_CONST_ATTR(temp_scale, "-0.47");
 
287
static u8 adis16201_addresses[7][2] = {
 
288
        [in_supply] = { ADIS16201_SUPPLY_OUT, },
 
289
        [temp] = { ADIS16201_TEMP_OUT },
 
290
        [accel_x] = { ADIS16201_XACCL_OUT, ADIS16201_XACCL_OFFS },
 
291
        [accel_y] = { ADIS16201_YACCL_OUT, ADIS16201_YACCL_OFFS },
 
292
        [in_aux] = { ADIS16201_AUX_ADC },
 
293
        [incli_x] = { ADIS16201_XINCL_OUT },
 
294
        [incli_y] = { ADIS16201_YINCL_OUT },
 
295
};
 
296
 
 
297
static int adis16201_read_raw(struct iio_dev *indio_dev,
 
298
                              struct iio_chan_spec const *chan,
 
299
                              int *val, int *val2,
 
300
                              long mask)
 
301
{
 
302
        int ret;
 
303
        int bits;
 
304
        u8 addr;
 
305
        s16 val16;
 
306
 
 
307
        switch (mask) {
 
308
        case 0:
 
309
                mutex_lock(&indio_dev->mlock);
 
310
                addr = adis16201_addresses[chan->address][0];
 
311
                ret = adis16201_spi_read_reg_16(indio_dev, addr, &val16);
 
312
                if (ret)
 
313
                        return ret;
 
314
 
 
315
                if (val16 & ADIS16201_ERROR_ACTIVE) {
 
316
                        ret = adis16201_check_status(indio_dev);
 
317
                        if (ret)
 
318
                                return ret;
 
319
                }
 
320
                val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
 
321
                if (chan->scan_type.sign == 's')
 
322
                        val16 = (s16)(val16 <<
 
323
                                      (16 - chan->scan_type.realbits)) >>
 
324
                                (16 - chan->scan_type.realbits);
 
325
                *val = val16;
 
326
                mutex_unlock(&indio_dev->mlock);
 
327
                return IIO_VAL_INT;
 
328
        case (1 << IIO_CHAN_INFO_SCALE_SEPARATE):
 
329
        case (1 << IIO_CHAN_INFO_SCALE_SHARED):
 
330
                switch (chan->type) {
 
331
                case IIO_IN:
 
332
                        *val = 0;
 
333
                        if (chan->channel == 0)
 
334
                                *val2 = 1220;
 
335
                        else
 
336
                                *val2 = 610;
 
337
                        return IIO_VAL_INT_PLUS_MICRO;
 
338
                case IIO_TEMP:
 
339
                        *val = 0;
 
340
                        *val2 = -470000;
 
341
                        return IIO_VAL_INT_PLUS_MICRO;
 
342
                case IIO_ACCEL:
 
343
                        *val = 0;
 
344
                        *val2 = 462500;
 
345
                        return IIO_VAL_INT_PLUS_MICRO;
 
346
                case IIO_INCLI:
 
347
                        *val = 0;
 
348
                        *val2 = 100000;
 
349
                        return IIO_VAL_INT_PLUS_MICRO;
 
350
                default:
 
351
                        return -EINVAL;
 
352
                }
 
353
                break;
 
354
        case (1 << IIO_CHAN_INFO_OFFSET_SEPARATE):
 
355
                *val = 25;
 
356
                return IIO_VAL_INT;
 
357
        case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
 
358
                switch (chan->type) {
 
359
                case IIO_ACCEL:
 
360
                        bits = 12;
 
361
                        break;
 
362
                case IIO_INCLI:
 
363
                        bits = 9;
 
364
                        break;
 
365
                default:
 
366
                        return -EINVAL;
 
367
                };
 
368
                mutex_lock(&indio_dev->mlock);
 
369
                addr = adis16201_addresses[chan->address][1];
 
370
                ret = adis16201_spi_read_reg_16(indio_dev, addr, &val16);
 
371
                if (ret) {
 
372
                        mutex_unlock(&indio_dev->mlock);
 
373
                        return ret;
 
374
                }
 
375
                val16 &= (1 << bits) - 1;
 
376
                val16 = (s16)(val16 << (16 - bits)) >> (16 - bits);
 
377
                *val = val16;
 
378
                mutex_unlock(&indio_dev->mlock);
 
379
                return IIO_VAL_INT;
 
380
        }
 
381
        return -EINVAL;
 
382
}
 
383
 
 
384
static int adis16201_write_raw(struct iio_dev *indio_dev,
 
385
                               struct iio_chan_spec const *chan,
 
386
                               int val,
 
387
                               int val2,
 
388
                               long mask)
 
389
{
 
390
        int bits;
 
391
        s16 val16;
 
392
        u8 addr;
 
393
        switch (mask) {
 
394
        case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
 
395
                switch (chan->type) {
 
396
                case IIO_ACCEL:
 
397
                        bits = 12;
 
398
                        break;
 
399
                case IIO_INCLI:
 
400
                        bits = 9;
 
401
                        break;
 
402
                default:
 
403
                        return -EINVAL;
 
404
                };
 
405
                val16 = val & ((1 << bits) - 1);
 
406
                addr = adis16201_addresses[chan->address][1];
 
407
                return adis16201_spi_write_reg_16(indio_dev, addr, val16);
 
408
        }
 
409
        return -EINVAL;
 
410
}
 
411
 
 
412
static struct iio_chan_spec adis16201_channels[] = {
 
413
        IIO_CHAN(IIO_IN, 0, 1, 0, "supply", 0, 0,
 
414
                 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 
415
                 in_supply, ADIS16201_SCAN_SUPPLY,
 
416
                 IIO_ST('u', 12, 16, 0), 0),
 
417
        IIO_CHAN(IIO_TEMP, 0, 1, 0, NULL, 0, 0,
 
418
                 (1 << IIO_CHAN_INFO_SCALE_SEPARATE) |
 
419
                 (1 << IIO_CHAN_INFO_OFFSET_SEPARATE),
 
420
                 temp, ADIS16201_SCAN_TEMP,
 
421
                 IIO_ST('u', 12, 16, 0), 0),
 
422
        IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X,
 
423
                 (1 << IIO_CHAN_INFO_SCALE_SHARED) |
 
424
                 (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE),
 
425
                 accel_x, ADIS16201_SCAN_ACC_X,
 
426
                 IIO_ST('s', 14, 16, 0), 0),
 
427
        IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 
428
                 (1 << IIO_CHAN_INFO_SCALE_SHARED) |
 
429
                 (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE),
 
430
                 accel_y, ADIS16201_SCAN_ACC_Y,
 
431
                 IIO_ST('s', 14, 16, 0), 0),
 
432
        IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 
433
                 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 
434
                 in_aux, ADIS16201_SCAN_AUX_ADC,
 
435
                 IIO_ST('u', 12, 16, 0), 0),
 
436
        IIO_CHAN(IIO_INCLI, 1, 0, 0, NULL, 0, IIO_MOD_X,
 
437
                 (1 << IIO_CHAN_INFO_SCALE_SHARED) |
 
438
                 (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE),
 
439
                 incli_x, ADIS16201_SCAN_INCLI_X,
 
440
                 IIO_ST('s', 14, 16, 0), 0),
 
441
        IIO_CHAN(IIO_INCLI, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 
442
                 (1 << IIO_CHAN_INFO_SCALE_SHARED) |
 
443
                 (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE),
 
444
                 incli_y, ADIS16201_SCAN_INCLI_Y,
 
445
                 IIO_ST('s', 14, 16, 0), 0),
 
446
        IIO_CHAN_SOFT_TIMESTAMP(7)
 
447
};
477
448
 
478
449
static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16201_write_reset, 0);
479
450
 
480
 
static IIO_CONST_ATTR(name, "adis16201");
481
 
 
482
 
static struct attribute *adis16201_event_attributes[] = {
483
 
        NULL
484
 
};
485
 
 
486
 
static struct attribute_group adis16201_event_attribute_group = {
487
 
        .attrs = adis16201_event_attributes,
488
 
};
489
 
 
490
451
static struct attribute *adis16201_attributes[] = {
491
 
        &iio_dev_attr_in0_supply_raw.dev_attr.attr,
492
 
        &iio_const_attr_in0_supply_scale.dev_attr.attr,
493
 
        &iio_dev_attr_temp_raw.dev_attr.attr,
494
 
        &iio_const_attr_temp_offset.dev_attr.attr,
495
 
        &iio_const_attr_temp_scale.dev_attr.attr,
496
452
        &iio_dev_attr_reset.dev_attr.attr,
497
 
        &iio_const_attr_name.dev_attr.attr,
498
 
        &iio_dev_attr_in1_raw.dev_attr.attr,
499
 
        &iio_const_attr_in1_scale.dev_attr.attr,
500
 
        &iio_dev_attr_accel_x_raw.dev_attr.attr,
501
 
        &iio_dev_attr_accel_y_raw.dev_attr.attr,
502
 
        &iio_dev_attr_accel_x_offset.dev_attr.attr,
503
 
        &iio_dev_attr_accel_y_offset.dev_attr.attr,
504
 
        &iio_const_attr_accel_scale.dev_attr.attr,
505
 
        &iio_dev_attr_incli_x_raw.dev_attr.attr,
506
 
        &iio_dev_attr_incli_y_raw.dev_attr.attr,
507
 
        &iio_dev_attr_incli_x_offset.dev_attr.attr,
508
 
        &iio_dev_attr_incli_y_offset.dev_attr.attr,
509
 
        &iio_const_attr_incli_scale.dev_attr.attr,
510
453
        NULL
511
454
};
512
455
 
514
457
        .attrs = adis16201_attributes,
515
458
};
516
459
 
 
460
static const struct iio_info adis16201_info = {
 
461
        .attrs = &adis16201_attribute_group,
 
462
        .read_raw = &adis16201_read_raw,
 
463
        .write_raw = &adis16201_write_raw,
 
464
        .driver_module = THIS_MODULE,
 
465
};
 
466
 
517
467
static int __devinit adis16201_probe(struct spi_device *spi)
518
468
{
519
469
        int ret, regdone = 0;
539
489
        st->us = spi;
540
490
        mutex_init(&st->buf_lock);
541
491
        /* setup the industrialio driver allocated elements */
542
 
        st->indio_dev = iio_allocate_device();
 
492
        st->indio_dev = iio_allocate_device(0);
543
493
        if (st->indio_dev == NULL) {
544
494
                ret = -ENOMEM;
545
495
                goto error_free_tx;
546
496
        }
547
497
 
 
498
        st->indio_dev->name = spi->dev.driver->name;
548
499
        st->indio_dev->dev.parent = &spi->dev;
549
 
        st->indio_dev->num_interrupt_lines = 1;
550
 
        st->indio_dev->event_attrs = &adis16201_event_attribute_group;
551
 
        st->indio_dev->attrs = &adis16201_attribute_group;
 
500
        st->indio_dev->info = &adis16201_info;
 
501
 
 
502
        st->indio_dev->channels = adis16201_channels;
 
503
        st->indio_dev->num_channels = ARRAY_SIZE(adis16201_channels);
552
504
        st->indio_dev->dev_data = (void *)(st);
553
 
        st->indio_dev->driver_module = THIS_MODULE;
554
505
        st->indio_dev->modes = INDIO_DIRECT_MODE;
555
506
 
556
507
        ret = adis16201_configure_ring(st->indio_dev);
562
513
                goto error_unreg_ring_funcs;
563
514
        regdone = 1;
564
515
 
565
 
        ret = adis16201_initialize_ring(st->indio_dev->ring);
 
516
        ret = iio_ring_buffer_register_ex(st->indio_dev->ring, 0,
 
517
                                          adis16201_channels,
 
518
                                          ARRAY_SIZE(adis16201_channels));
566
519
        if (ret) {
567
520
                printk(KERN_ERR "failed to initialize the ring\n");
568
521
                goto error_unreg_ring_funcs;
569
522
        }
570
523
 
571
524
        if (spi->irq) {
572
 
                ret = iio_register_interrupt_line(spi->irq,
573
 
                                st->indio_dev,
574
 
                                0,
575
 
                                IRQF_TRIGGER_RISING,
576
 
                                "adis16201");
 
525
                ret = adis16201_probe_trigger(st->indio_dev);
577
526
                if (ret)
578
527
                        goto error_uninitialize_ring;
579
 
 
580
 
                ret = adis16201_probe_trigger(st->indio_dev);
581
 
                if (ret)
582
 
                        goto error_unregister_line;
583
528
        }
584
529
 
585
530
        /* Get the device into a sane initial state */
590
535
 
591
536
error_remove_trigger:
592
537
        adis16201_remove_trigger(st->indio_dev);
593
 
error_unregister_line:
594
 
        if (spi->irq)
595
 
                iio_unregister_interrupt_line(st->indio_dev, 0);
596
538
error_uninitialize_ring:
597
 
        adis16201_uninitialize_ring(st->indio_dev->ring);
 
539
        iio_ring_buffer_unregister(st->indio_dev->ring);
598
540
error_unreg_ring_funcs:
599
541
        adis16201_unconfigure_ring(st->indio_dev);
600
542
error_free_dev:
617
559
        struct adis16201_state *st = spi_get_drvdata(spi);
618
560
        struct iio_dev *indio_dev = st->indio_dev;
619
561
 
620
 
        flush_scheduled_work();
621
 
 
622
562
        adis16201_remove_trigger(indio_dev);
623
 
        if (spi->irq)
624
 
                iio_unregister_interrupt_line(indio_dev, 0);
625
 
 
626
 
        adis16201_uninitialize_ring(indio_dev->ring);
 
563
        iio_ring_buffer_unregister(indio_dev->ring);
627
564
        iio_device_unregister(indio_dev);
628
565
        adis16201_unconfigure_ring(indio_dev);
629
566
        kfree(st->tx);