← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/iio/accel/adis16220_core.c
 
1
/*
 
2
 * ADIS16220 Programmable Digital Vibration Sensor driver
 
3
 *
 
4
 * Copyright 2010 Analog Devices Inc.
 
5
 *
 
6
 * Licensed under the GPL-2 or later.
 
7
 */
 
8
 
 
9
#include <linux/delay.h>
 
10
#include <linux/mutex.h>
 
11
#include <linux/device.h>
 
12
#include <linux/kernel.h>
 
13
#include <linux/spi/spi.h>
 
14
#include <linux/slab.h>
 
15
#include <linux/sysfs.h>
 
16
#include <linux/module.h>
 
17
 
 
18
#include "../iio.h"
 
19
#include "../sysfs.h"
 
20
 
 
21
#include "adis16220.h"
 
22
 
 
23
#define DRIVER_NAME             "adis16220"
 
24
 
 
25
/**
 
26
 * adis16220_spi_write_reg_8() - write single byte to a register
 
27
 * @indio_dev: iio device associated with child of actual device
 
28
 * @reg_address: the address of the register to be written
 
29
 * @val: the value to write
 
30
 **/
 
31
static int adis16220_spi_write_reg_8(struct iio_dev *indio_dev,
 
32
                u8 reg_address,
 
33
                u8 val)
 
34
{
 
35
        int ret;
 
36
        struct adis16220_state *st = iio_priv(indio_dev);
 
37
 
 
38
        mutex_lock(&st->buf_lock);
 
39
        st->tx[0] = ADIS16220_WRITE_REG(reg_address);
 
40
        st->tx[1] = val;
 
41
 
 
42
        ret = spi_write(st->us, st->tx, 2);
 
43
        mutex_unlock(&st->buf_lock);
 
44
 
 
45
        return ret;
 
46
}
 
47
 
 
48
/**
 
49
 * adis16220_spi_write_reg_16() - write 2 bytes to a pair of registers
 
50
 * @indio_dev:  iio device associated with child of actual device
 
51
 * @reg_address: the address of the lower of the two registers. Second register
 
52
 *               is assumed to have address one greater.
 
53
 * @val: value to be written
 
54
 **/
 
55
static int adis16220_spi_write_reg_16(struct iio_dev *indio_dev,
 
56
                u8 lower_reg_address,
 
57
                u16 value)
 
58
{
 
59
        int ret;
 
60
        struct spi_message msg;
 
61
        struct adis16220_state *st = iio_priv(indio_dev);
 
62
        struct spi_transfer xfers[] = {
 
63
                {
 
64
                        .tx_buf = st->tx,
 
65
                        .bits_per_word = 8,
 
66
                        .len = 2,
 
67
                        .cs_change = 1,
 
68
                        .delay_usecs = 35,
 
69
                }, {
 
70
                        .tx_buf = st->tx + 2,
 
71
                        .bits_per_word = 8,
 
72
                        .len = 2,
 
73
                        .delay_usecs = 35,
 
74
                },
 
75
        };
 
76
 
 
77
        mutex_lock(&st->buf_lock);
 
78
        st->tx[0] = ADIS16220_WRITE_REG(lower_reg_address);
 
79
        st->tx[1] = value & 0xFF;
 
80
        st->tx[2] = ADIS16220_WRITE_REG(lower_reg_address + 1);
 
81
        st->tx[3] = (value >> 8) & 0xFF;
 
82
 
 
83
        spi_message_init(&msg);
 
84
        spi_message_add_tail(&xfers[0], &msg);
 
85
        spi_message_add_tail(&xfers[1], &msg);
 
86
        ret = spi_sync(st->us, &msg);
 
87
        mutex_unlock(&st->buf_lock);
 
88
 
 
89
        return ret;
 
90
}
 
91
 
 
92
/**
 
93
 * adis16220_spi_read_reg_16() - read 2 bytes from a 16-bit register
 
94
 * @indio_dev: iio device associated with child of actual device
 
95
 * @reg_address: the address of the lower of the two registers. Second register
 
96
 *               is assumed to have address one greater.
 
97
 * @val: somewhere to pass back the value read
 
98
 **/
 
99
static int adis16220_spi_read_reg_16(struct iio_dev *indio_dev,
 
100
                                     u8 lower_reg_address,
 
101
                                     u16 *val)
 
102
{
 
103
        struct spi_message msg;
 
104
        struct adis16220_state *st = iio_priv(indio_dev);
 
105
        int ret;
 
106
        struct spi_transfer xfers[] = {
 
107
                {
 
108
                        .tx_buf = st->tx,
 
109
                        .bits_per_word = 8,
 
110
                        .len = 2,
 
111
                        .cs_change = 1,
 
112
                        .delay_usecs = 35,
 
113
                }, {
 
114
                        .rx_buf = st->rx,
 
115
                        .bits_per_word = 8,
 
116
                        .len = 2,
 
117
                        .cs_change = 1,
 
118
                        .delay_usecs = 35,
 
119
                },
 
120
        };
 
121
 
 
122
        mutex_lock(&st->buf_lock);
 
123
        st->tx[0] = ADIS16220_READ_REG(lower_reg_address);
 
124
        st->tx[1] = 0;
 
125
 
 
126
        spi_message_init(&msg);
 
127
        spi_message_add_tail(&xfers[0], &msg);
 
128
        spi_message_add_tail(&xfers[1], &msg);
 
129
        ret = spi_sync(st->us, &msg);
 
130
        if (ret) {
 
131
                dev_err(&st->us->dev,
 
132
                        "problem when reading 16 bit register 0x%02X",
 
133
                        lower_reg_address);
 
134
                goto error_ret;
 
135
        }
 
136
        *val = (st->rx[0] << 8) | st->rx[1];
 
137
 
 
138
error_ret:
 
139
        mutex_unlock(&st->buf_lock);
 
140
        return ret;
 
141
}
 
142
 
 
143
static ssize_t adis16220_read_16bit(struct device *dev,
 
144
                struct device_attribute *attr,
 
145
                char *buf)
 
146
{
 
147
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 
148
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
149
        ssize_t ret;
 
150
        s16 val = 0;
 
151
 
 
152
        /* Take the iio_dev status lock */
 
153
        mutex_lock(&indio_dev->mlock);
 
154
        ret = adis16220_spi_read_reg_16(indio_dev, this_attr->address,
 
155
                                        (u16 *)&val);
 
156
        mutex_unlock(&indio_dev->mlock);
 
157
        if (ret)
 
158
                return ret;
 
159
        return sprintf(buf, "%d\n", val);
 
160
}
 
161
 
 
162
static ssize_t adis16220_write_16bit(struct device *dev,
 
163
                struct device_attribute *attr,
 
164
                const char *buf,
 
165
                size_t len)
 
166
{
 
167
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
168
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 
169
        int ret;
 
170
        long val;
 
171
 
 
172
        ret = strict_strtol(buf, 10, &val);
 
173
        if (ret)
 
174
                goto error_ret;
 
175
        ret = adis16220_spi_write_reg_16(indio_dev, this_attr->address, val);
 
176
 
 
177
error_ret:
 
178
        return ret ? ret : len;
 
179
}
 
180
 
 
181
static int adis16220_capture(struct iio_dev *indio_dev)
 
182
{
 
183
        int ret;
 
184
        ret = adis16220_spi_write_reg_16(indio_dev,
 
185
                        ADIS16220_GLOB_CMD,
 
186
                        0xBF08); /* initiates a manual data capture */
 
187
        if (ret)
 
188
                dev_err(&indio_dev->dev, "problem beginning capture");
 
189
 
 
190
        msleep(10); /* delay for capture to finish */
 
191
 
 
192
        return ret;
 
193
}
 
194
 
 
195
static int adis16220_reset(struct iio_dev *indio_dev)
 
196
{
 
197
        int ret;
 
198
        ret = adis16220_spi_write_reg_8(indio_dev,
 
199
                        ADIS16220_GLOB_CMD,
 
200
                        ADIS16220_GLOB_CMD_SW_RESET);
 
201
        if (ret)
 
202
                dev_err(&indio_dev->dev, "problem resetting device");
 
203
 
 
204
        return ret;
 
205
}
 
206
 
 
207
static ssize_t adis16220_write_reset(struct device *dev,
 
208
                struct device_attribute *attr,
 
209
                const char *buf, size_t len)
 
210
{
 
211
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
212
        bool val;
 
213
        int ret;
 
214
 
 
215
        ret = strtobool(buf, &val);
 
216
        if (ret)
 
217
                return ret;
 
218
        if (!val)
 
219
                return -EINVAL;
 
220
 
 
221
        ret = adis16220_reset(indio_dev);
 
222
        if (ret)
 
223
                return ret;
 
224
        return len;
 
225
}
 
226
 
 
227
static ssize_t adis16220_write_capture(struct device *dev,
 
228
                struct device_attribute *attr,
 
229
                const char *buf, size_t len)
 
230
{
 
231
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
232
        bool val;
 
233
        int ret;
 
234
 
 
235
        ret = strtobool(buf, &val);
 
236
        if (ret)
 
237
                return ret;
 
238
        if (!val)
 
239
                return -EINVAL;
 
240
        ret = adis16220_capture(indio_dev);
 
241
        if (ret)
 
242
                return ret;
 
243
 
 
244
        return len;
 
245
}
 
246
 
 
247
static int adis16220_check_status(struct iio_dev *indio_dev)
 
248
{
 
249
        u16 status;
 
250
        int ret;
 
251
 
 
252
        ret = adis16220_spi_read_reg_16(indio_dev, ADIS16220_DIAG_STAT,
 
253
                                        &status);
 
254
 
 
255
        if (ret < 0) {
 
256
                dev_err(&indio_dev->dev, "Reading status failed\n");
 
257
                goto error_ret;
 
258
        }
 
259
        ret = status & 0x7F;
 
260
 
 
261
        if (status & ADIS16220_DIAG_STAT_VIOLATION)
 
262
                dev_err(&indio_dev->dev,
 
263
                        "Capture period violation/interruption\n");
 
264
        if (status & ADIS16220_DIAG_STAT_SPI_FAIL)
 
265
                dev_err(&indio_dev->dev, "SPI failure\n");
 
266
        if (status & ADIS16220_DIAG_STAT_FLASH_UPT)
 
267
                dev_err(&indio_dev->dev, "Flash update failed\n");
 
268
        if (status & ADIS16220_DIAG_STAT_POWER_HIGH)
 
269
                dev_err(&indio_dev->dev, "Power supply above 3.625V\n");
 
270
        if (status & ADIS16220_DIAG_STAT_POWER_LOW)
 
271
                dev_err(&indio_dev->dev, "Power supply below 3.15V\n");
 
272
 
 
273
error_ret:
 
274
        return ret;
 
275
}
 
276
 
 
277
static int adis16220_self_test(struct iio_dev *indio_dev)
 
278
{
 
279
        int ret;
 
280
        ret = adis16220_spi_write_reg_16(indio_dev,
 
281
                        ADIS16220_MSC_CTRL,
 
282
                        ADIS16220_MSC_CTRL_SELF_TEST_EN);
 
283
        if (ret) {
 
284
                dev_err(&indio_dev->dev, "problem starting self test");
 
285
                goto err_ret;
 
286
        }
 
287
 
 
288
        adis16220_check_status(indio_dev);
 
289
 
 
290
err_ret:
 
291
        return ret;
 
292
}
 
293
 
 
294
static int adis16220_initial_setup(struct iio_dev *indio_dev)
 
295
{
 
296
        int ret;
 
297
 
 
298
        /* Do self test */
 
299
        ret = adis16220_self_test(indio_dev);
 
300
        if (ret) {
 
301
                dev_err(&indio_dev->dev, "self test failure");
 
302
                goto err_ret;
 
303
        }
 
304
 
 
305
        /* Read status register to check the result */
 
306
        ret = adis16220_check_status(indio_dev);
 
307
        if (ret) {
 
308
                adis16220_reset(indio_dev);
 
309
                dev_err(&indio_dev->dev, "device not playing ball -> reset");
 
310
                msleep(ADIS16220_STARTUP_DELAY);
 
311
                ret = adis16220_check_status(indio_dev);
 
312
                if (ret) {
 
313
                        dev_err(&indio_dev->dev, "giving up");
 
314
                        goto err_ret;
 
315
                }
 
316
        }
 
317
 
 
318
err_ret:
 
319
        return ret;
 
320
}
 
321
 
 
322
static ssize_t adis16220_capture_buffer_read(struct iio_dev *indio_dev,
 
323
                                        char *buf,
 
324
                                        loff_t off,
 
325
                                        size_t count,
 
326
                                        int addr)
 
327
{
 
328
        struct adis16220_state *st = iio_priv(indio_dev);
 
329
        struct spi_message msg;
 
330
        struct spi_transfer xfers[] = {
 
331
                {
 
332
                        .tx_buf = st->tx,
 
333
                        .bits_per_word = 8,
 
334
                        .len = 2,
 
335
                        .cs_change = 1,
 
336
                        .delay_usecs = 25,
 
337
                }, {
 
338
                        .tx_buf = st->tx,
 
339
                        .rx_buf = st->rx,
 
340
                        .bits_per_word = 8,
 
341
                        .cs_change = 1,
 
342
                        .delay_usecs = 25,
 
343
                },
 
344
        };
 
345
        int ret;
 
346
        int i;
 
347
 
 
348
        if (unlikely(!count))
 
349
                return count;
 
350
 
 
351
        if ((off >= ADIS16220_CAPTURE_SIZE) || (count & 1) || (off & 1))
 
352
                return -EINVAL;
 
353
 
 
354
        if (off + count > ADIS16220_CAPTURE_SIZE)
 
355
                count = ADIS16220_CAPTURE_SIZE - off;
 
356
 
 
357
        /* write the begin position of capture buffer */
 
358
        ret = adis16220_spi_write_reg_16(indio_dev,
 
359
                                        ADIS16220_CAPT_PNTR,
 
360
                                        off > 1);
 
361
        if (ret)
 
362
                return -EIO;
 
363
 
 
364
        /* read count/2 values from capture buffer */
 
365
        mutex_lock(&st->buf_lock);
 
366
 
 
367
        for (i = 0; i < count; i += 2) {
 
368
                st->tx[i] = ADIS16220_READ_REG(addr);
 
369
                st->tx[i + 1] = 0;
 
370
        }
 
371
        xfers[1].len = count;
 
372
 
 
373
        spi_message_init(&msg);
 
374
        spi_message_add_tail(&xfers[0], &msg);
 
375
        spi_message_add_tail(&xfers[1], &msg);
 
376
        ret = spi_sync(st->us, &msg);
 
377
        if (ret) {
 
378
 
 
379
                mutex_unlock(&st->buf_lock);
 
380
                return -EIO;
 
381
        }
 
382
 
 
383
        memcpy(buf, st->rx, count);
 
384
 
 
385
        mutex_unlock(&st->buf_lock);
 
386
        return count;
 
387
}
 
388
 
 
389
static ssize_t adis16220_accel_bin_read(struct file *filp, struct kobject *kobj,
 
390
                                        struct bin_attribute *attr,
 
391
                                        char *buf,
 
392
                                        loff_t off,
 
393
                                        size_t count)
 
394
{
 
395
        struct device *dev = container_of(kobj, struct device, kobj);
 
396
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
397
 
 
398
        return adis16220_capture_buffer_read(indio_dev, buf,
 
399
                                        off, count,
 
400
                                        ADIS16220_CAPT_BUFA);
 
401
}
 
402
 
 
403
static struct bin_attribute accel_bin = {
 
404
        .attr = {
 
405
                .name = "accel_bin",
 
406
                .mode = S_IRUGO,
 
407
        },
 
408
        .read = adis16220_accel_bin_read,
 
409
        .size = ADIS16220_CAPTURE_SIZE,
 
410
};
 
411
 
 
412
static ssize_t adis16220_adc1_bin_read(struct file *filp, struct kobject *kobj,
 
413
                                struct bin_attribute *attr,
 
414
                                char *buf, loff_t off,
 
415
                                size_t count)
 
416
{
 
417
        struct device *dev = container_of(kobj, struct device, kobj);
 
418
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
419
 
 
420
        return adis16220_capture_buffer_read(indio_dev, buf,
 
421
                                        off, count,
 
422
                                        ADIS16220_CAPT_BUF1);
 
423
}
 
424
 
 
425
static struct bin_attribute adc1_bin = {
 
426
        .attr = {
 
427
                .name = "in0_bin",
 
428
                .mode = S_IRUGO,
 
429
        },
 
430
        .read =  adis16220_adc1_bin_read,
 
431
        .size = ADIS16220_CAPTURE_SIZE,
 
432
};
 
433
 
 
434
static ssize_t adis16220_adc2_bin_read(struct file *filp, struct kobject *kobj,
 
435
                                struct bin_attribute *attr,
 
436
                                char *buf, loff_t off,
 
437
                                size_t count)
 
438
{
 
439
        struct device *dev = container_of(kobj, struct device, kobj);
 
440
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
441
 
 
442
        return adis16220_capture_buffer_read(indio_dev, buf,
 
443
                                        off, count,
 
444
                                        ADIS16220_CAPT_BUF2);
 
445
}
 
446
 
 
447
 
 
448
static struct bin_attribute adc2_bin = {
 
449
        .attr = {
 
450
                .name = "in1_bin",
 
451
                .mode = S_IRUGO,
 
452
        },
 
453
        .read =  adis16220_adc2_bin_read,
 
454
        .size = ADIS16220_CAPTURE_SIZE,
 
455
};
 
456
 
 
457
static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL,
 
458
                adis16220_write_reset, 0);
 
459
 
 
460
#define IIO_DEV_ATTR_CAPTURE(_store)                            \
 
461
        IIO_DEVICE_ATTR(capture, S_IWUSR, NULL, _store, 0)
 
462
 
 
463
static IIO_DEV_ATTR_CAPTURE(adis16220_write_capture);
 
464
 
 
465
#define IIO_DEV_ATTR_CAPTURE_COUNT(_mode, _show, _store, _addr)         \
 
466
        IIO_DEVICE_ATTR(capture_count, _mode, _show, _store, _addr)
 
467
 
 
468
static IIO_DEV_ATTR_CAPTURE_COUNT(S_IWUSR | S_IRUGO,
 
469
                adis16220_read_16bit,
 
470
                adis16220_write_16bit,
 
471
                ADIS16220_CAPT_PNTR);
 
472
 
 
473
enum adis16220_channel {
 
474
        in_supply, in_1, in_2, accel, temp
 
475
};
 
476
 
 
477
struct adis16220_address_spec {
 
478
        u8 addr;
 
479
        u8 bits;
 
480
        bool sign;
 
481
};
 
482
 
 
483
/* Address / bits / signed */
 
484
static const struct adis16220_address_spec adis16220_addresses[][3] = {
 
485
        [in_supply] =   { { ADIS16220_CAPT_SUPPLY,      12, 0 }, },
 
486
        [in_1] =        { { ADIS16220_CAPT_BUF1,        16, 1 },
 
487
                          { ADIS16220_AIN1_NULL,        16, 1 },
 
488
                          { ADIS16220_CAPT_PEAK1,       16, 1 }, },
 
489
        [in_2] =        { { ADIS16220_CAPT_BUF2,        16, 1 },
 
490
                          { ADIS16220_AIN2_NULL,        16, 1 },
 
491
                          { ADIS16220_CAPT_PEAK2,       16, 1 }, },
 
492
        [accel] =       { { ADIS16220_CAPT_BUFA,        16, 1 },
 
493
                          { ADIS16220_ACCL_NULL,        16, 1 },
 
494
                          { ADIS16220_CAPT_PEAKA,       16, 1 }, },
 
495
        [temp] =        { { ADIS16220_CAPT_TEMP,        12, 0 }, }
 
496
};
 
497
 
 
498
static int adis16220_read_raw(struct iio_dev *indio_dev,
 
499
                              struct iio_chan_spec const *chan,
 
500
                              int *val, int *val2,
 
501
                              long mask)
 
502
{
 
503
        int ret = -EINVAL;
 
504
        int addrind = 0;
 
505
        u16 uval;
 
506
        s16 sval;
 
507
        u8 bits;
 
508
 
 
509
        switch (mask) {
 
510
        case 0:
 
511
                addrind = 0;
 
512
                break;
 
513
        case (1 << IIO_CHAN_INFO_OFFSET_SEPARATE):
 
514
                if (chan->type == IIO_TEMP) {
 
515
                        *val = 25;
 
516
                        return IIO_VAL_INT;
 
517
                }
 
518
                addrind = 1;
 
519
                break;
 
520
        case (1 << IIO_CHAN_INFO_PEAK_SEPARATE):
 
521
                addrind = 2;
 
522
                break;
 
523
        case (1 << IIO_CHAN_INFO_SCALE_SEPARATE):
 
524
                *val = 0;
 
525
                switch (chan->type) {
 
526
                case IIO_TEMP:
 
527
                        *val2 = -470000;
 
528
                        return IIO_VAL_INT_PLUS_MICRO;
 
529
                case IIO_ACCEL:
 
530
                        *val2 = 1887042;
 
531
                        return IIO_VAL_INT_PLUS_MICRO;
 
532
                case IIO_VOLTAGE:
 
533
                        if (chan->channel == 0)
 
534
                                *val2 = 0012221;
 
535
                        else /* Should really be dependent on VDD */
 
536
                                *val2 = 305;
 
537
                        return IIO_VAL_INT_PLUS_MICRO;
 
538
                default:
 
539
                        return -EINVAL;
 
540
                }
 
541
        default:
 
542
                return -EINVAL;
 
543
        }
 
544
        if (adis16220_addresses[chan->address][addrind].sign) {
 
545
                ret = adis16220_spi_read_reg_16(indio_dev,
 
546
                                                adis16220_addresses[chan
 
547
                                                                    ->address]
 
548
                                                [addrind].addr,
 
549
                                                &sval);
 
550
                if (ret)
 
551
                        return ret;
 
552
                bits = adis16220_addresses[chan->address][addrind].bits;
 
553
                sval &= (1 << bits) - 1;
 
554
                sval = (s16)(sval << (16 - bits)) >> (16 - bits);
 
555
                *val = sval;
 
556
                return IIO_VAL_INT;
 
557
        } else {
 
558
                ret = adis16220_spi_read_reg_16(indio_dev,
 
559
                                                adis16220_addresses[chan
 
560
                                                                    ->address]
 
561
                                                [addrind].addr,
 
562
                                                &uval);
 
563
                if (ret)
 
564
                        return ret;
 
565
                bits = adis16220_addresses[chan->address][addrind].bits;
 
566
                uval &= (1 << bits) - 1;
 
567
                *val = uval;
 
568
                return IIO_VAL_INT;
 
569
        }
 
570
}
 
571
 
 
572
static const struct iio_chan_spec adis16220_channels[] = {
 
573
        {
 
574
                .type = IIO_VOLTAGE,
 
575
                .indexed = 1,
 
576
                .channel = 0,
 
577
                .extend_name = "supply",
 
578
                .info_mask = (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 
579
                .address = in_supply,
 
580
        }, {
 
581
                .type = IIO_ACCEL,
 
582
                .info_mask = (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
 
583
                             (1 << IIO_CHAN_INFO_SCALE_SEPARATE) |
 
584
                             (1 << IIO_CHAN_INFO_PEAK_SEPARATE),
 
585
                .address = accel,
 
586
        }, {
 
587
                .type = IIO_TEMP,
 
588
                .indexed = 1,
 
589
                .channel = 0,
 
590
                .info_mask = (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
 
591
                             (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 
592
                .address = temp,
 
593
        }, {
 
594
                .type = IIO_VOLTAGE,
 
595
                .indexed = 1,
 
596
                .channel = 1,
 
597
                .info_mask = (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
 
598
                             (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 
599
                .address = in_1,
 
600
        }, {
 
601
                .type = IIO_VOLTAGE,
 
602
                .indexed = 1,
 
603
                .channel = 2,
 
604
                .address = in_2,
 
605
        }
 
606
};
 
607
 
 
608
static struct attribute *adis16220_attributes[] = {
 
609
        &iio_dev_attr_reset.dev_attr.attr,
 
610
        &iio_dev_attr_capture.dev_attr.attr,
 
611
        &iio_dev_attr_capture_count.dev_attr.attr,
 
612
        NULL
 
613
};
 
614
 
 
615
static const struct attribute_group adis16220_attribute_group = {
 
616
        .attrs = adis16220_attributes,
 
617
};
 
618
 
 
619
static const struct iio_info adis16220_info = {
 
620
        .attrs = &adis16220_attribute_group,
 
621
        .driver_module = THIS_MODULE,
 
622
        .read_raw = &adis16220_read_raw,
 
623
};
 
624
 
 
625
static int __devinit adis16220_probe(struct spi_device *spi)
 
626
{
 
627
        int ret;
 
628
        struct adis16220_state *st;
 
629
        struct iio_dev *indio_dev;
 
630
 
 
631
        /* setup the industrialio driver allocated elements */
 
632
        indio_dev = iio_allocate_device(sizeof(*st));
 
633
        if (indio_dev == NULL) {
 
634
                ret = -ENOMEM;
 
635
                goto error_ret;
 
636
        }
 
637
 
 
638
        st = iio_priv(indio_dev);
 
639
        /* this is only used for removal purposes */
 
640
        spi_set_drvdata(spi, indio_dev);
 
641
 
 
642
        st->us = spi;
 
643
        mutex_init(&st->buf_lock);
 
644
 
 
645
        indio_dev->name = spi->dev.driver->name;
 
646
        indio_dev->dev.parent = &spi->dev;
 
647
        indio_dev->info = &adis16220_info;
 
648
        indio_dev->modes = INDIO_DIRECT_MODE;
 
649
        indio_dev->channels = adis16220_channels;
 
650
        indio_dev->num_channels = ARRAY_SIZE(adis16220_channels);
 
651
 
 
652
        ret = iio_device_register(indio_dev);
 
653
        if (ret)
 
654
                goto error_free_dev;
 
655
 
 
656
        ret = sysfs_create_bin_file(&indio_dev->dev.kobj, &accel_bin);
 
657
        if (ret)
 
658
                goto error_unregister_dev;
 
659
 
 
660
        ret = sysfs_create_bin_file(&indio_dev->dev.kobj, &adc1_bin);
 
661
        if (ret)
 
662
                goto error_rm_accel_bin;
 
663
 
 
664
        ret = sysfs_create_bin_file(&indio_dev->dev.kobj, &adc2_bin);
 
665
        if (ret)
 
666
                goto error_rm_adc1_bin;
 
667
 
 
668
        /* Get the device into a sane initial state */
 
669
        ret = adis16220_initial_setup(indio_dev);
 
670
        if (ret)
 
671
                goto error_rm_adc2_bin;
 
672
        return 0;
 
673
 
 
674
error_rm_adc2_bin:
 
675
        sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc2_bin);
 
676
error_rm_adc1_bin:
 
677
        sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc1_bin);
 
678
error_rm_accel_bin:
 
679
        sysfs_remove_bin_file(&indio_dev->dev.kobj, &accel_bin);
 
680
error_unregister_dev:
 
681
        iio_device_unregister(indio_dev);
 
682
error_free_dev:
 
683
        iio_free_device(indio_dev);
 
684
error_ret:
 
685
        return ret;
 
686
}
 
687
 
 
688
static int adis16220_remove(struct spi_device *spi)
 
689
{
 
690
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
 
691
 
 
692
        flush_scheduled_work();
 
693
 
 
694
        sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc2_bin);
 
695
        sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc1_bin);
 
696
        sysfs_remove_bin_file(&indio_dev->dev.kobj, &accel_bin);
 
697
        iio_device_unregister(indio_dev);
 
698
        iio_free_device(indio_dev);
 
699
 
 
700
        return 0;
 
701
}
 
702
 
 
703
static struct spi_driver adis16220_driver = {
 
704
        .driver = {
 
705
                .name = "adis16220",
 
706
                .owner = THIS_MODULE,
 
707
        },
 
708
        .probe = adis16220_probe,
 
709
        .remove = __devexit_p(adis16220_remove),
 
710
};
 
711
 
 
712
static __init int adis16220_init(void)
 
713
{
 
714
        return spi_register_driver(&adis16220_driver);
 
715
}
 
716
module_init(adis16220_init);
 
717
 
 
718
static __exit void adis16220_exit(void)
 
719
{
 
720
        spi_unregister_driver(&adis16220_driver);
 
721
}
 
722
module_exit(adis16220_exit);
 
723
 
 
724
MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 
725
MODULE_DESCRIPTION("Analog Devices ADIS16220 Digital Vibration Sensor");
 
726
MODULE_LICENSE("GPL v2");