← 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/adis16209_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/adis16209_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>
23
20
#include "../ring_generic.h"
24
21
#include "accel.h"
25
22
#include "inclinometer.h"
26
 
#include "../gyro/gyro.h"
27
23
#include "../adc/adc.h"
28
24
 
29
25
#include "adis16209.h"
30
26
 
31
27
#define DRIVER_NAME             "adis16209"
32
28
 
33
 
static int adis16209_check_status(struct device *dev);
34
 
 
35
29
/**
36
30
 * adis16209_spi_write_reg_8() - write single byte to a register
37
 
 * @dev: device associated with child of actual device (iio_dev or iio_trig)
 
31
 * @indio_dev: iio device associated with actual device
38
32
 * @reg_address: the address of the register to be written
39
33
 * @val: the value to write
40
34
 **/
41
 
static int adis16209_spi_write_reg_8(struct device *dev,
42
 
                u8 reg_address,
43
 
                u8 val)
 
35
static int adis16209_spi_write_reg_8(struct iio_dev *indio_dev,
 
36
                                     u8 reg_address,
 
37
                                     u8 val)
44
38
{
45
39
        int ret;
46
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
47
40
        struct adis16209_state *st = iio_dev_get_devdata(indio_dev);
48
41
 
49
42
        mutex_lock(&st->buf_lock);
58
51
 
59
52
/**
60
53
 * adis16209_spi_write_reg_16() - write 2 bytes to a pair of registers
61
 
 * @dev: device associated with child of actual device (iio_dev or iio_trig)
 
54
 * @indio_dev: iio device associated actual device
62
55
 * @reg_address: the address of the lower of the two registers. Second register
63
56
 *               is assumed to have address one greater.
64
57
 * @val: value to be written
65
58
 **/
66
 
static int adis16209_spi_write_reg_16(struct device *dev,
67
 
                u8 lower_reg_address,
68
 
                u16 value)
 
59
static int adis16209_spi_write_reg_16(struct iio_dev *indio_dev,
 
60
                                      u8 lower_reg_address,
 
61
                                      u16 value)
69
62
{
70
63
        int ret;
71
64
        struct spi_message msg;
72
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
73
65
        struct adis16209_state *st = iio_dev_get_devdata(indio_dev);
74
66
        struct spi_transfer xfers[] = {
75
67
                {
82
74
                        .tx_buf = st->tx + 2,
83
75
                        .bits_per_word = 8,
84
76
                        .len = 2,
85
 
                        .cs_change = 1,
86
77
                        .delay_usecs = 30,
87
78
                },
88
79
        };
104
95
 
105
96
/**
106
97
 * adis16209_spi_read_reg_16() - read 2 bytes from a 16-bit register
107
 
 * @dev: device associated with child of actual device (iio_dev or iio_trig)
 
98
 * @indio_dev: iio device associated with device
108
99
 * @reg_address: the address of the lower of the two registers. Second register
109
100
 *               is assumed to have address one greater.
110
101
 * @val: somewhere to pass back the value read
111
102
 **/
112
 
static int adis16209_spi_read_reg_16(struct device *dev,
113
 
                u8 lower_reg_address,
114
 
                u16 *val)
 
103
static int adis16209_spi_read_reg_16(struct iio_dev *indio_dev,
 
104
                                     u8 lower_reg_address,
 
105
                                     u16 *val)
115
106
{
116
107
        struct spi_message msg;
117
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
118
108
        struct adis16209_state *st = iio_dev_get_devdata(indio_dev);
119
109
        int ret;
120
110
        struct spi_transfer xfers[] = {
128
118
                        .rx_buf = st->rx,
129
119
                        .bits_per_word = 8,
130
120
                        .len = 2,
131
 
                        .cs_change = 1,
132
121
                        .delay_usecs = 30,
133
122
                },
134
123
        };
154
143
        return ret;
155
144
}
156
145
 
157
 
static ssize_t adis16209_read_12bit_unsigned(struct device *dev,
158
 
                struct device_attribute *attr,
159
 
                char *buf)
160
 
{
161
 
        int ret;
162
 
        u16 val = 0;
163
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
164
 
 
165
 
        ret = adis16209_spi_read_reg_16(dev, this_attr->address, &val);
166
 
        if (ret)
167
 
                return ret;
168
 
 
169
 
        if (val & ADIS16209_ERROR_ACTIVE)
170
 
                adis16209_check_status(dev);
171
 
 
172
 
        return sprintf(buf, "%u\n", val & 0x0FFF);
173
 
}
174
 
 
175
 
static ssize_t adis16209_read_14bit_unsigned(struct device *dev,
176
 
                struct device_attribute *attr,
177
 
                char *buf)
178
 
{
179
 
        int ret;
180
 
        u16 val = 0;
181
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
182
 
 
183
 
        ret = adis16209_spi_read_reg_16(dev, this_attr->address, &val);
184
 
        if (ret)
185
 
                return ret;
186
 
 
187
 
        if (val & ADIS16209_ERROR_ACTIVE)
188
 
                adis16209_check_status(dev);
189
 
 
190
 
        return sprintf(buf, "%u\n", val & 0x3FFF);
191
 
}
192
 
 
193
 
static ssize_t adis16209_read_temp(struct device *dev,
194
 
                struct device_attribute *attr,
195
 
                char *buf)
196
 
{
197
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
198
 
        ssize_t ret;
199
 
        u16 val;
200
 
 
201
 
        /* Take the iio_dev status lock */
202
 
        mutex_lock(&indio_dev->mlock);
203
 
 
204
 
        ret = adis16209_spi_read_reg_16(dev, ADIS16209_TEMP_OUT, (u16 *)&val);
205
 
        if (ret)
206
 
                goto error_ret;
207
 
 
208
 
        if (val & ADIS16209_ERROR_ACTIVE)
209
 
                adis16209_check_status(dev);
210
 
 
211
 
        val &= 0xFFF;
212
 
        ret = sprintf(buf, "%d\n", val);
213
 
 
214
 
error_ret:
215
 
        mutex_unlock(&indio_dev->mlock);
216
 
        return ret;
217
 
}
218
 
 
219
 
static ssize_t adis16209_read_14bit_signed(struct device *dev,
220
 
                struct device_attribute *attr,
221
 
                char *buf)
222
 
{
223
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
224
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
225
 
        s16 val = 0;
226
 
        ssize_t ret;
227
 
 
228
 
        mutex_lock(&indio_dev->mlock);
229
 
 
230
 
        ret = adis16209_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);
231
 
        if (!ret) {
232
 
                if (val & ADIS16209_ERROR_ACTIVE)
233
 
                        adis16209_check_status(dev);
234
 
 
235
 
                val = ((s16)(val << 2) >> 2);
236
 
                ret = sprintf(buf, "%d\n", val);
237
 
        }
238
 
 
239
 
        mutex_unlock(&indio_dev->mlock);
240
 
 
241
 
        return ret;
242
 
}
243
 
 
244
 
static ssize_t adis16209_write_16bit(struct device *dev,
245
 
                struct device_attribute *attr,
246
 
                const char *buf,
247
 
                size_t len)
248
 
{
249
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
250
 
        int ret;
251
 
        long val;
252
 
 
253
 
        ret = strict_strtol(buf, 10, &val);
254
 
        if (ret)
255
 
                goto error_ret;
256
 
        ret = adis16209_spi_write_reg_16(dev, this_attr->address, val);
257
 
 
258
 
error_ret:
259
 
        return ret ? ret : len;
260
 
}
261
 
 
262
 
static int adis16209_reset(struct device *dev)
263
 
{
264
 
        int ret;
265
 
        ret = adis16209_spi_write_reg_8(dev,
 
146
static int adis16209_reset(struct iio_dev *indio_dev)
 
147
{
 
148
        int ret;
 
149
        ret = adis16209_spi_write_reg_8(indio_dev,
266
150
                        ADIS16209_GLOB_CMD,
267
151
                        ADIS16209_GLOB_CMD_SW_RESET);
268
152
        if (ret)
269
 
                dev_err(dev, "problem resetting device");
 
153
                dev_err(&indio_dev->dev, "problem resetting device");
270
154
 
271
155
        return ret;
272
156
}
275
159
                struct device_attribute *attr,
276
160
                const char *buf, size_t len)
277
161
{
 
162
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
163
 
278
164
        if (len < 1)
279
165
                return -EINVAL;
280
166
        switch (buf[0]) {
281
167
        case '1':
282
168
        case 'y':
283
169
        case 'Y':
284
 
                return adis16209_reset(dev);
 
170
                return adis16209_reset(indio_dev);
285
171
        }
286
172
        return -EINVAL;
287
173
}
288
174
 
289
 
int adis16209_set_irq(struct device *dev, bool enable)
 
175
int adis16209_set_irq(struct iio_dev *indio_dev, bool enable)
290
176
{
291
177
        int ret = 0;
292
178
        u16 msc;
293
179
 
294
 
        ret = adis16209_spi_read_reg_16(dev, ADIS16209_MSC_CTRL, &msc);
 
180
        ret = adis16209_spi_read_reg_16(indio_dev, ADIS16209_MSC_CTRL, &msc);
295
181
        if (ret)
296
182
                goto error_ret;
297
183
 
302
188
        else
303
189
                msc &= ~ADIS16209_MSC_CTRL_DATA_RDY_EN;
304
190
 
305
 
        ret = adis16209_spi_write_reg_16(dev, ADIS16209_MSC_CTRL, msc);
 
191
        ret = adis16209_spi_write_reg_16(indio_dev, ADIS16209_MSC_CTRL, msc);
306
192
 
307
193
error_ret:
308
194
        return ret;
309
195
}
310
196
 
311
 
static int adis16209_check_status(struct device *dev)
 
197
static int adis16209_check_status(struct iio_dev *indio_dev)
312
198
{
313
199
        u16 status;
314
200
        int ret;
315
201
 
316
 
        ret = adis16209_spi_read_reg_16(dev, ADIS16209_DIAG_STAT, &status);
 
202
        ret = adis16209_spi_read_reg_16(indio_dev,
 
203
                                        ADIS16209_DIAG_STAT, &status);
317
204
        if (ret < 0) {
318
 
                dev_err(dev, "Reading status failed\n");
 
205
                dev_err(&indio_dev->dev, "Reading status failed\n");
319
206
                goto error_ret;
320
207
        }
321
208
        ret = status & 0x1F;
322
209
 
323
210
        if (status & ADIS16209_DIAG_STAT_SELFTEST_FAIL)
324
 
                dev_err(dev, "Self test failure\n");
 
211
                dev_err(&indio_dev->dev, "Self test failure\n");
325
212
        if (status & ADIS16209_DIAG_STAT_SPI_FAIL)
326
 
                dev_err(dev, "SPI failure\n");
 
213
                dev_err(&indio_dev->dev, "SPI failure\n");
327
214
        if (status & ADIS16209_DIAG_STAT_FLASH_UPT)
328
 
                dev_err(dev, "Flash update failed\n");
 
215
                dev_err(&indio_dev->dev, "Flash update failed\n");
329
216
        if (status & ADIS16209_DIAG_STAT_POWER_HIGH)
330
 
                dev_err(dev, "Power supply above 3.625V\n");
 
217
                dev_err(&indio_dev->dev, "Power supply above 3.625V\n");
331
218
        if (status & ADIS16209_DIAG_STAT_POWER_LOW)
332
 
                dev_err(dev, "Power supply below 3.15V\n");
 
219
                dev_err(&indio_dev->dev, "Power supply below 3.15V\n");
333
220
 
334
221
error_ret:
335
222
        return ret;
336
223
}
337
224
 
338
 
static int adis16209_self_test(struct device *dev)
 
225
static int adis16209_self_test(struct iio_dev *indio_dev)
339
226
{
340
227
        int ret;
341
 
        ret = adis16209_spi_write_reg_16(dev,
 
228
        ret = adis16209_spi_write_reg_16(indio_dev,
342
229
                        ADIS16209_MSC_CTRL,
343
230
                        ADIS16209_MSC_CTRL_SELF_TEST_EN);
344
231
        if (ret) {
345
 
                dev_err(dev, "problem starting self test");
 
232
                dev_err(&indio_dev->dev, "problem starting self test");
346
233
                goto err_ret;
347
234
        }
348
235
 
349
 
        adis16209_check_status(dev);
 
236
        adis16209_check_status(indio_dev);
350
237
 
351
238
err_ret:
352
239
        return ret;
353
240
}
354
241
 
355
 
static int adis16209_initial_setup(struct adis16209_state *st)
 
242
static int adis16209_initial_setup(struct iio_dev *indio_dev)
356
243
{
357
244
        int ret;
358
 
        struct device *dev = &st->indio_dev->dev;
359
245
 
360
246
        /* Disable IRQ */
361
 
        ret = adis16209_set_irq(dev, false);
 
247
        ret = adis16209_set_irq(indio_dev, false);
362
248
        if (ret) {
363
 
                dev_err(dev, "disable irq failed");
 
249
                dev_err(&indio_dev->dev, "disable irq failed");
364
250
                goto err_ret;
365
251
        }
366
252
 
367
253
        /* Do self test */
368
 
        ret = adis16209_self_test(dev);
 
254
        ret = adis16209_self_test(indio_dev);
369
255
        if (ret) {
370
 
                dev_err(dev, "self test failure");
 
256
                dev_err(&indio_dev->dev, "self test failure");
371
257
                goto err_ret;
372
258
        }
373
259
 
374
260
        /* Read status register to check the result */
375
 
        ret = adis16209_check_status(dev);
 
261
        ret = adis16209_check_status(indio_dev);
376
262
        if (ret) {
377
 
                adis16209_reset(dev);
378
 
                dev_err(dev, "device not playing ball -> reset");
 
263
                adis16209_reset(indio_dev);
 
264
                dev_err(&indio_dev->dev, "device not playing ball -> reset");
379
265
                msleep(ADIS16209_STARTUP_DELAY);
380
 
                ret = adis16209_check_status(dev);
 
266
                ret = adis16209_check_status(indio_dev);
381
267
                if (ret) {
382
 
                        dev_err(dev, "giving up");
 
268
                        dev_err(&indio_dev->dev, "giving up");
383
269
                        goto err_ret;
384
270
                }
385
271
        }
386
272
 
387
 
        printk(KERN_INFO DRIVER_NAME ": at CS%d (irq %d)\n",
388
 
                        st->us->chip_select, st->us->irq);
389
 
 
390
273
err_ret:
391
274
        return ret;
392
275
}
393
276
 
394
 
static IIO_DEV_ATTR_IN_NAMED_RAW(0, supply, adis16209_read_14bit_unsigned,
395
 
                ADIS16209_SUPPLY_OUT);
396
 
static IIO_CONST_ATTR_IN_NAMED_SCALE(0, supply, "0.30518");
397
 
static IIO_DEV_ATTR_IN_RAW(1, adis16209_read_12bit_unsigned,
398
 
                ADIS16209_AUX_ADC);
399
 
static IIO_CONST_ATTR(in1_scale, "0.6105");
400
 
 
401
 
static IIO_DEV_ATTR_ACCEL_X(adis16209_read_14bit_signed,
402
 
                ADIS16209_XACCL_OUT);
403
 
static IIO_DEV_ATTR_ACCEL_Y(adis16209_read_14bit_signed,
404
 
                ADIS16209_YACCL_OUT);
405
 
static IIO_DEV_ATTR_ACCEL_X_CALIBBIAS(S_IWUSR | S_IRUGO,
406
 
                adis16209_read_14bit_signed,
407
 
                adis16209_write_16bit,
408
 
                ADIS16209_XACCL_NULL);
409
 
static IIO_DEV_ATTR_ACCEL_Y_CALIBBIAS(S_IWUSR | S_IRUGO,
410
 
                adis16209_read_14bit_signed,
411
 
                adis16209_write_16bit,
412
 
                ADIS16209_YACCL_NULL);
413
 
static IIO_CONST_ATTR_ACCEL_SCALE("0.002394195531");
414
 
 
415
 
static IIO_DEV_ATTR_INCLI_X(adis16209_read_14bit_signed,
416
 
                ADIS16209_XINCL_OUT);
417
 
static IIO_DEV_ATTR_INCLI_Y(adis16209_read_14bit_signed,
418
 
                ADIS16209_YINCL_OUT);
419
 
static IIO_CONST_ATTR(incli_scale, "0.00043633231");
420
 
 
421
 
static IIO_DEVICE_ATTR(rot_raw, S_IRUGO, adis16209_read_14bit_signed,
422
 
                       NULL, ADIS16209_ROT_OUT);
423
 
 
424
 
static IIO_DEV_ATTR_TEMP_RAW(adis16209_read_temp);
425
 
static IIO_CONST_ATTR_TEMP_OFFSET("25");
426
 
static IIO_CONST_ATTR_TEMP_SCALE("-0.47");
 
277
enum adis16209_chan {
 
278
        in_supply,
 
279
        temp,
 
280
        accel_x,
 
281
        accel_y,
 
282
        incli_x,
 
283
        incli_y,
 
284
        in_aux,
 
285
        rot,
 
286
};
 
287
 
 
288
static const u8 adis16209_addresses[8][2] = {
 
289
        [in_supply] = { ADIS16209_SUPPLY_OUT },
 
290
        [in_aux] = { ADIS16209_AUX_ADC },
 
291
        [accel_x] = { ADIS16209_XACCL_OUT, ADIS16209_XACCL_NULL },
 
292
        [accel_y] = { ADIS16209_YACCL_OUT, ADIS16209_YACCL_NULL },
 
293
        [incli_x] = { ADIS16209_XINCL_OUT, ADIS16209_XINCL_NULL },
 
294
        [incli_y] = { ADIS16209_YINCL_OUT, ADIS16209_YINCL_NULL },
 
295
        [rot] = { ADIS16209_ROT_OUT },
 
296
        [temp] = { ADIS16209_TEMP_OUT },
 
297
};
 
298
 
 
299
static int adis16209_write_raw(struct iio_dev *indio_dev,
 
300
                               struct iio_chan_spec const *chan,
 
301
                               int val,
 
302
                               int val2,
 
303
                               long mask)
 
304
{
 
305
        int bits;
 
306
        s16 val16;
 
307
        u8 addr;
 
308
        switch (mask) {
 
309
        case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
 
310
                switch (chan->type) {
 
311
                case IIO_ACCEL:
 
312
                case IIO_INCLI:
 
313
                        bits = 14;
 
314
                        break;
 
315
                default:
 
316
                        return -EINVAL;
 
317
                };
 
318
                val16 = val & ((1 << bits) - 1);
 
319
                addr = adis16209_addresses[chan->address][1];
 
320
                return adis16209_spi_write_reg_16(indio_dev, addr, val16);
 
321
        }
 
322
        return -EINVAL;
 
323
}
 
324
 
 
325
static int adis16209_read_raw(struct iio_dev *indio_dev,
 
326
                              struct iio_chan_spec const *chan,
 
327
                              int *val, int *val2,
 
328
                              long mask)
 
329
{
 
330
        int ret;
 
331
        int bits;
 
332
        u8 addr;
 
333
        s16 val16;
 
334
 
 
335
        switch (mask) {
 
336
        case 0:
 
337
                mutex_lock(&indio_dev->mlock);
 
338
                addr = adis16209_addresses[chan->address][0];
 
339
                ret = adis16209_spi_read_reg_16(indio_dev, addr, &val16);
 
340
                if (ret)
 
341
                        return ret;
 
342
 
 
343
                if (val16 & ADIS16209_ERROR_ACTIVE) {
 
344
                        ret = adis16209_check_status(indio_dev);
 
345
                        if (ret)
 
346
                                return ret;
 
347
                }
 
348
                val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
 
349
                if (chan->scan_type.sign == 's')
 
350
                        val16 = (s16)(val16 <<
 
351
                                      (16 - chan->scan_type.realbits)) >>
 
352
                                (16 - chan->scan_type.realbits);
 
353
                *val = val16;
 
354
                mutex_unlock(&indio_dev->mlock);
 
355
                return IIO_VAL_INT;
 
356
        case (1 << IIO_CHAN_INFO_SCALE_SEPARATE):
 
357
        case (1 << IIO_CHAN_INFO_SCALE_SHARED):
 
358
                switch (chan->type) {
 
359
                case IIO_IN:
 
360
                        *val = 0;
 
361
                        if (chan->channel == 0)
 
362
                                *val2 = 305180;
 
363
                        else
 
364
                                *val2 = 610500;
 
365
                        return IIO_VAL_INT_PLUS_MICRO;
 
366
                case IIO_TEMP:
 
367
                        *val = 0;
 
368
                        *val2 = -470000;
 
369
                        return IIO_VAL_INT_PLUS_MICRO;
 
370
                case IIO_ACCEL:
 
371
                        *val = 0;
 
372
                        *val2 = 2394;
 
373
                        return IIO_VAL_INT_PLUS_MICRO;
 
374
                case IIO_INCLI:
 
375
                        *val = 0;
 
376
                        *val2 = 436;
 
377
                        return IIO_VAL_INT_PLUS_MICRO;
 
378
                default:
 
379
                        return -EINVAL;
 
380
                }
 
381
                break;
 
382
        case (1 << IIO_CHAN_INFO_OFFSET_SEPARATE):
 
383
                *val = 25;
 
384
                return IIO_VAL_INT;
 
385
        case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
 
386
                switch (chan->type) {
 
387
                case IIO_ACCEL:
 
388
                        bits = 14;
 
389
                        break;
 
390
                default:
 
391
                        return -EINVAL;
 
392
                };
 
393
                mutex_lock(&indio_dev->mlock);
 
394
                addr = adis16209_addresses[chan->address][1];
 
395
                ret = adis16209_spi_read_reg_16(indio_dev, addr, &val16);
 
396
                if (ret) {
 
397
                        mutex_unlock(&indio_dev->mlock);
 
398
                        return ret;
 
399
                }
 
400
                val16 &= (1 << bits) - 1;
 
401
                val16 = (s16)(val16 << (16 - bits)) >> (16 - bits);
 
402
                *val = val16;
 
403
                mutex_unlock(&indio_dev->mlock);
 
404
                return IIO_VAL_INT;
 
405
        }
 
406
        return -EINVAL;
 
407
}
 
408
 
 
409
static struct iio_chan_spec adis16209_channels[] = {
 
410
        IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 
411
                 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 
412
                 in_supply, ADIS16209_SCAN_SUPPLY,
 
413
                 IIO_ST('u', 14, 16, 0), 0),
 
414
        IIO_CHAN(IIO_TEMP, 0, 1, 0, NULL, 0, 0,
 
415
                 (1 << IIO_CHAN_INFO_SCALE_SEPARATE) |
 
416
                 (1 << IIO_CHAN_INFO_OFFSET_SEPARATE),
 
417
                 temp, ADIS16209_SCAN_TEMP,
 
418
                 IIO_ST('u', 12, 16, 0), 0),
 
419
        IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X,
 
420
                 (1 << IIO_CHAN_INFO_SCALE_SHARED) |
 
421
                 (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE),
 
422
                 accel_x, ADIS16209_SCAN_ACC_X,
 
423
                 IIO_ST('s', 14, 16, 0), 0),
 
424
        IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y,
 
425
                 (1 << IIO_CHAN_INFO_SCALE_SHARED) |
 
426
                 (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE),
 
427
                 accel_y, ADIS16209_SCAN_ACC_Y,
 
428
                 IIO_ST('s', 14, 16, 0), 0),
 
429
        IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 
430
                 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 
431
                 in_aux, ADIS16209_SCAN_AUX_ADC,
 
432
                 IIO_ST('u', 12, 16, 0), 0),
 
433
        IIO_CHAN(IIO_INCLI, 0, 1, 0, NULL, 0, IIO_MOD_X,
 
434
                 (1 << IIO_CHAN_INFO_SCALE_SHARED),
 
435
                 incli_x, ADIS16209_SCAN_INCLI_X,
 
436
                 IIO_ST('s', 14, 16, 0), 0),
 
437
        IIO_CHAN(IIO_INCLI, 0, 1, 0, NULL, 0, IIO_MOD_Y,
 
438
                 (1 << IIO_CHAN_INFO_SCALE_SHARED),
 
439
                 incli_y, ADIS16209_SCAN_INCLI_Y,
 
440
                 IIO_ST('s', 14, 16, 0), 0),
 
441
        IIO_CHAN(IIO_ROT, 0, 1, 0, NULL, 0, IIO_MOD_X,
 
442
                    0,
 
443
                    rot, ADIS16209_SCAN_ROT,
 
444
                    IIO_ST('s', 14, 16, 0), 0),
 
445
        IIO_CHAN_SOFT_TIMESTAMP(8)
 
446
};
427
447
 
428
448
static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16209_write_reset, 0);
429
449
 
430
 
static IIO_CONST_ATTR_NAME("adis16209");
431
 
 
432
 
static struct attribute *adis16209_event_attributes[] = {
433
 
        NULL
434
 
};
435
 
 
436
 
static struct attribute_group adis16209_event_attribute_group = {
437
 
        .attrs = adis16209_event_attributes,
438
 
};
439
 
 
440
450
static struct attribute *adis16209_attributes[] = {
441
 
        &iio_dev_attr_in0_supply_raw.dev_attr.attr,
442
 
        &iio_const_attr_in0_supply_scale.dev_attr.attr,
443
 
        &iio_dev_attr_temp_raw.dev_attr.attr,
444
 
        &iio_const_attr_temp_offset.dev_attr.attr,
445
 
        &iio_const_attr_temp_scale.dev_attr.attr,
446
451
        &iio_dev_attr_reset.dev_attr.attr,
447
 
        &iio_const_attr_name.dev_attr.attr,
448
 
        &iio_dev_attr_in1_raw.dev_attr.attr,
449
 
        &iio_const_attr_in1_scale.dev_attr.attr,
450
 
        &iio_dev_attr_accel_x_raw.dev_attr.attr,
451
 
        &iio_dev_attr_accel_y_raw.dev_attr.attr,
452
 
        &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
453
 
        &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
454
 
        &iio_const_attr_accel_scale.dev_attr.attr,
455
 
        &iio_dev_attr_incli_x_raw.dev_attr.attr,
456
 
        &iio_dev_attr_incli_y_raw.dev_attr.attr,
457
 
        &iio_const_attr_incli_scale.dev_attr.attr,
458
 
        &iio_dev_attr_rot_raw.dev_attr.attr,
459
452
        NULL
460
453
};
461
454
 
463
456
        .attrs = adis16209_attributes,
464
457
};
465
458
 
 
459
static const struct iio_info adis16209_info = {
 
460
        .attrs = &adis16209_attribute_group,
 
461
        .read_raw = &adis16209_read_raw,
 
462
        .write_raw = &adis16209_write_raw,
 
463
        .driver_module = THIS_MODULE,
 
464
};
 
465
 
466
466
static int __devinit adis16209_probe(struct spi_device *spi)
467
467
{
468
468
        int ret, regdone = 0;
488
488
        st->us = spi;
489
489
        mutex_init(&st->buf_lock);
490
490
        /* setup the industrialio driver allocated elements */
491
 
        st->indio_dev = iio_allocate_device();
 
491
        st->indio_dev = iio_allocate_device(0);
492
492
        if (st->indio_dev == NULL) {
493
493
                ret = -ENOMEM;
494
494
                goto error_free_tx;
495
495
        }
496
496
 
 
497
        st->indio_dev->name = spi->dev.driver->name;
497
498
        st->indio_dev->dev.parent = &spi->dev;
498
 
        st->indio_dev->num_interrupt_lines = 1;
499
 
        st->indio_dev->event_attrs = &adis16209_event_attribute_group;
500
 
        st->indio_dev->attrs = &adis16209_attribute_group;
 
499
        st->indio_dev->info = &adis16209_info;
 
500
        st->indio_dev->channels = adis16209_channels;
 
501
        st->indio_dev->num_channels = ARRAY_SIZE(adis16209_channels);
501
502
        st->indio_dev->dev_data = (void *)(st);
502
 
        st->indio_dev->driver_module = THIS_MODULE;
503
503
        st->indio_dev->modes = INDIO_DIRECT_MODE;
504
504
 
505
505
        ret = adis16209_configure_ring(st->indio_dev);
511
511
                goto error_unreg_ring_funcs;
512
512
        regdone = 1;
513
513
 
514
 
        ret = iio_ring_buffer_register(st->indio_dev->ring, 0);
 
514
        ret = iio_ring_buffer_register_ex(st->indio_dev->ring, 0,
 
515
                                          adis16209_channels,
 
516
                                          ARRAY_SIZE(adis16209_channels));
515
517
        if (ret) {
516
518
                printk(KERN_ERR "failed to initialize the ring\n");
517
519
                goto error_unreg_ring_funcs;
518
520
        }
519
521
 
520
522
        if (spi->irq) {
521
 
                ret = iio_register_interrupt_line(spi->irq,
522
 
                                st->indio_dev,
523
 
                                0,
524
 
                                IRQF_TRIGGER_RISING,
525
 
                                "adis16209");
 
523
                ret = adis16209_probe_trigger(st->indio_dev);
526
524
                if (ret)
527
525
                        goto error_uninitialize_ring;
528
 
 
529
 
                ret = adis16209_probe_trigger(st->indio_dev);
530
 
                if (ret)
531
 
                        goto error_unregister_line;
532
526
        }
533
527
 
534
528
        /* Get the device into a sane initial state */
535
 
        ret = adis16209_initial_setup(st);
 
529
        ret = adis16209_initial_setup(st->indio_dev);
536
530
        if (ret)
537
531
                goto error_remove_trigger;
538
532
        return 0;
539
533
 
540
534
error_remove_trigger:
541
535
        adis16209_remove_trigger(st->indio_dev);
542
 
error_unregister_line:
543
 
        if (spi->irq)
544
 
                iio_unregister_interrupt_line(st->indio_dev, 0);
545
536
error_uninitialize_ring:
546
537
        iio_ring_buffer_unregister(st->indio_dev->ring);
547
538
error_unreg_ring_funcs:
569
560
        flush_scheduled_work();
570
561
 
571
562
        adis16209_remove_trigger(indio_dev);
572
 
        if (spi->irq)
573
 
                iio_unregister_interrupt_line(indio_dev, 0);
574
 
 
575
563
        iio_ring_buffer_unregister(indio_dev->ring);
576
564
        iio_device_unregister(indio_dev);
577
565
        adis16209_unconfigure_ring(indio_dev);