projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging:iio:resolver:ad2s90 chan spec conversion
[deliverable/linux.git] / drivers / staging / iio / imu / adis16400_core.c
CommitLineData
a9d26f00
BS		 1/*
2 * adis16400.c support Analog Devices ADIS16400/5
3 * 3d 2g Linear Accelerometers,
4 * 3d Gyroscopes,
5 * 3d Magnetometers via SPI
6 *
7 * Copyright (c) 2009 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
8 * Copyright (c) 2007 Jonathan Cameron <jic23@cam.ac.uk>
6a6ec623 9 * Copyright (c) 2011 Analog Devices Inc.
a9d26f00
BS		 10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 *
15 */
16
17#include <linux/interrupt.h>
18#include <linux/irq.h>
a9d26f00
BS		 19#include <linux/delay.h>
20#include <linux/mutex.h>
21#include <linux/device.h>
22#include <linux/kernel.h>
23#include <linux/spi/spi.h>
1cb6c1f5 24#include <linux/slab.h>
a9d26f00
BS		 25#include <linux/sysfs.h>
26#include <linux/list.h>
99c97852 27#include <linux/module.h>
a9d26f00
BS		 28
29#include "../iio.h"
30#include "../sysfs.h"
3811cd62 31#include "../buffer_generic.h"
a9d26f00
BS		 32#include "adis16400.h"
33
2a29a90b 34enum adis16400_chip_variant {
8e886e65 35 ADIS16300,
85da5059 36 ADIS16334,
2a29a90b
JC		 37 ADIS16350,
38 ADIS16360,
39 ADIS16362,
40 ADIS16364,
41 ADIS16365,
42 ADIS16400,
43};
44
a9d26f00
BS		 45/**
46 * adis16400_spi_write_reg_8() - write single byte to a register
47 * @dev: device associated with child of actual device (iio_dev or iio_trig)
48 * @reg_address: the address of the register to be written
49 * @val: the value to write
521de518 50 */
e7854845
JC		 51static int adis16400_spi_write_reg_8(struct iio_dev *indio_dev,
52 u8 reg_address,
53 u8 val)
a9d26f00
BS		 54{
55 int ret;
38d15f06 56 struct adis16400_state *st = iio_priv(indio_dev);
a9d26f00
BS		 57
58 mutex_lock(&st->buf_lock);
59 st->tx[0] = ADIS16400_WRITE_REG(reg_address);
60 st->tx[1] = val;
61
62 ret = spi_write(st->us, st->tx, 2);
63 mutex_unlock(&st->buf_lock);
64
65 return ret;
66}
67
68/**
69 * adis16400_spi_write_reg_16() - write 2 bytes to a pair of registers
70 * @dev: device associated with child of actual device (iio_dev or iio_trig)
71 * @reg_address: the address of the lower of the two registers. Second register
72 * is assumed to have address one greater.
73 * @val: value to be written
521de518
JC		 74 *
75 * At the moment the spi framework doesn't allow global setting of cs_change.
76 * This means that use cannot be made of spi_write.
77 */
e7854845 78static int adis16400_spi_write_reg_16(struct iio_dev *indio_dev,
a9d26f00
BS		 79 u8 lower_reg_address,
80 u16 value)
81{
82 int ret;
83 struct spi_message msg;
38d15f06 84 struct adis16400_state *st = iio_priv(indio_dev);
a9d26f00
BS		 85 struct spi_transfer xfers[] = {
86 {
87 .tx_buf = st->tx,
88 .bits_per_word = 8,
89 .len = 2,
90 .cs_change = 1,
91 }, {
92 .tx_buf = st->tx + 2,
93 .bits_per_word = 8,
94 .len = 2,
a9d26f00
BS		 95 },
96 };
97
98 mutex_lock(&st->buf_lock);
99 st->tx[0] = ADIS16400_WRITE_REG(lower_reg_address);
100 st->tx[1] = value & 0xFF;
101 st->tx[2] = ADIS16400_WRITE_REG(lower_reg_address + 1);
102 st->tx[3] = (value >> 8) & 0xFF;
103
104 spi_message_init(&msg);
105 spi_message_add_tail(&xfers[0], &msg);
106 spi_message_add_tail(&xfers[1], &msg);
107 ret = spi_sync(st->us, &msg);
108 mutex_unlock(&st->buf_lock);
109
110 return ret;
111}
112
113/**
114 * adis16400_spi_read_reg_16() - read 2 bytes from a 16-bit register
e7854845 115 * @indio_dev: iio device
a9d26f00
BS		 116 * @reg_address: the address of the lower of the two registers. Second register
117 * is assumed to have address one greater.
118 * @val: somewhere to pass back the value read
521de518
JC		 119 *
120 * At the moment the spi framework doesn't allow global setting of cs_change.
121 * This means that use cannot be made of spi_read.
a9d26f00 122 **/
e7854845 123static int adis16400_spi_read_reg_16(struct iio_dev *indio_dev,
a9d26f00
BS		 124 u8 lower_reg_address,
125 u16 *val)
126{
127 struct spi_message msg;
38d15f06 128 struct adis16400_state *st = iio_priv(indio_dev);
a9d26f00
BS		 129 int ret;
130 struct spi_transfer xfers[] = {
131 {
132 .tx_buf = st->tx,
133 .bits_per_word = 8,
134 .len = 2,
135 .cs_change = 1,
136 }, {
137 .rx_buf = st->rx,
138 .bits_per_word = 8,
139 .len = 2,
a9d26f00
BS		 140 },
141 };
142
143 mutex_lock(&st->buf_lock);
144 st->tx[0] = ADIS16400_READ_REG(lower_reg_address);
145 st->tx[1] = 0;
a9d26f00
BS		 146
147 spi_message_init(&msg);
148 spi_message_add_tail(&xfers[0], &msg);
149 spi_message_add_tail(&xfers[1], &msg);
150 ret = spi_sync(st->us, &msg);
151 if (ret) {
152 dev_err(&st->us->dev,
153 "problem when reading 16 bit register 0x%02X",
154 lower_reg_address);
155 goto error_ret;
156 }
157 *val = (st->rx[0] << 8) | st->rx[1];
158
159error_ret:
160 mutex_unlock(&st->buf_lock);
161 return ret;
162}
163
a9d26f00
BS		 164static ssize_t adis16400_read_frequency(struct device *dev,
165 struct device_attribute *attr,
166 char *buf)
167{
e7854845 168 struct iio_dev *indio_dev = dev_get_drvdata(dev);
a9d26f00
BS		 169 int ret, len = 0;
170 u16 t;
171 int sps;
e7854845 172 ret = adis16400_spi_read_reg_16(indio_dev,
a9d26f00
BS		 173 ADIS16400_SMPL_PRD,
174 &t);
175 if (ret)
176 return ret;
177 sps = (t & ADIS16400_SMPL_PRD_TIME_BASE) ? 53 : 1638;
178 sps /= (t & ADIS16400_SMPL_PRD_DIV_MASK) + 1;
179 len = sprintf(buf, "%d SPS\n", sps);
180 return len;
181}
182
183static ssize_t adis16400_write_frequency(struct device *dev,
184 struct device_attribute *attr,
185 const char *buf,
186 size_t len)
187{
188 struct iio_dev *indio_dev = dev_get_drvdata(dev);
38d15f06 189 struct adis16400_state *st = iio_priv(indio_dev);
a9d26f00
BS		 190 long val;
191 int ret;
192 u8 t;
193
194 ret = strict_strtol(buf, 10, &val);
195 if (ret)
196 return ret;
197
198 mutex_lock(&indio_dev->mlock);
199
200 t = (1638 / val);
201 if (t > 0)
202 t--;
203 t &= ADIS16400_SMPL_PRD_DIV_MASK;
204 if ((t & ADIS16400_SMPL_PRD_DIV_MASK) >= 0x0A)
205 st->us->max_speed_hz = ADIS16400_SPI_SLOW;
206 else
207 st->us->max_speed_hz = ADIS16400_SPI_FAST;
208
e7854845 209 ret = adis16400_spi_write_reg_8(indio_dev,
a9d26f00
BS		 210 ADIS16400_SMPL_PRD,
211 t);
212
213 mutex_unlock(&indio_dev->mlock);
214
215 return ret ? ret : len;
216}
217
e7854845 218static int adis16400_reset(struct iio_dev *indio_dev)
3fd66da1
BS		 219{
220 int ret;
e7854845 221 ret = adis16400_spi_write_reg_8(indio_dev,
3fd66da1
BS		 222 ADIS16400_GLOB_CMD,
223 ADIS16400_GLOB_CMD_SW_RESET);
224 if (ret)
e7854845 225 dev_err(&indio_dev->dev, "problem resetting device");
3fd66da1
BS		 226
227 return ret;
228}
229
a9d26f00
BS		 230static ssize_t adis16400_write_reset(struct device *dev,
231 struct device_attribute *attr,
232 const char *buf, size_t len)
233{
7a6ff010
JC		 234 bool val;
235 int ret;
e7854845 236
7a6ff010
JC		 237 ret = strtobool(buf, &val);
238 if (ret < 0)
239 return ret;
521de518 240 if (val) {
7a6ff010 241 ret = adis16400_reset(dev_get_drvdata(dev));
521de518
JC		 242 if (ret < 0)
243 return ret;
244 }
7a6ff010
JC		 245
246 return len;
a9d26f00
BS		 247}
248
e7854845 249int adis16400_set_irq(struct iio_dev *indio_dev, bool enable)
a9d26f00
BS		 250{
251 int ret;
252 u16 msc;
521de518 253
e7854845 254 ret = adis16400_spi_read_reg_16(indio_dev, ADIS16400_MSC_CTRL, &msc);
a9d26f00
BS		 255 if (ret)
256 goto error_ret;
257
258 msc |= ADIS16400_MSC_CTRL_DATA_RDY_POL_HIGH;
259 if (enable)
260 msc |= ADIS16400_MSC_CTRL_DATA_RDY_EN;
261 else
262 msc &= ~ADIS16400_MSC_CTRL_DATA_RDY_EN;
263
e7854845 264 ret = adis16400_spi_write_reg_16(indio_dev, ADIS16400_MSC_CTRL, msc);
a9d26f00
BS		 265 if (ret)
266 goto error_ret;
267
268error_ret:
269 return ret;
270}
271
a9d26f00 272/* Power down the device */
e7854845 273static int adis16400_stop_device(struct iio_dev *indio_dev)
a9d26f00
BS		 274{
275 int ret;
276 u16 val = ADIS16400_SLP_CNT_POWER_OFF;
277
e7854845 278 ret = adis16400_spi_write_reg_16(indio_dev, ADIS16400_SLP_CNT, val);
a9d26f00 279 if (ret)
e7854845
JC		 280 dev_err(&indio_dev->dev,
281 "problem with turning device off: SLP_CNT");
a9d26f00
BS		 282
283 return ret;
284}
285
e7854845 286static int adis16400_check_status(struct iio_dev *indio_dev)
a9d26f00
BS		 287{
288 u16 status;
289 int ret;
e7854845 290 struct device *dev = &indio_dev->dev;
a9d26f00 291
e7854845
JC		 292 ret = adis16400_spi_read_reg_16(indio_dev,
293 ADIS16400_DIAG_STAT, &status);
a9d26f00
BS		 294
295 if (ret < 0) {
296 dev_err(dev, "Reading status failed\n");
297 goto error_ret;
298 }
299 ret = status;
300 if (status & ADIS16400_DIAG_STAT_ZACCL_FAIL)
301 dev_err(dev, "Z-axis accelerometer self-test failure\n");
302 if (status & ADIS16400_DIAG_STAT_YACCL_FAIL)
303 dev_err(dev, "Y-axis accelerometer self-test failure\n");
304 if (status & ADIS16400_DIAG_STAT_XACCL_FAIL)
305 dev_err(dev, "X-axis accelerometer self-test failure\n");
306 if (status & ADIS16400_DIAG_STAT_XGYRO_FAIL)
307 dev_err(dev, "X-axis gyroscope self-test failure\n");
308 if (status & ADIS16400_DIAG_STAT_YGYRO_FAIL)
309 dev_err(dev, "Y-axis gyroscope self-test failure\n");
310 if (status & ADIS16400_DIAG_STAT_ZGYRO_FAIL)
311 dev_err(dev, "Z-axis gyroscope self-test failure\n");
312 if (status & ADIS16400_DIAG_STAT_ALARM2)
313 dev_err(dev, "Alarm 2 active\n");
314 if (status & ADIS16400_DIAG_STAT_ALARM1)
315 dev_err(dev, "Alarm 1 active\n");
316 if (status & ADIS16400_DIAG_STAT_FLASH_CHK)
317 dev_err(dev, "Flash checksum error\n");
318 if (status & ADIS16400_DIAG_STAT_SELF_TEST)
319 dev_err(dev, "Self test error\n");
320 if (status & ADIS16400_DIAG_STAT_OVERFLOW)
321 dev_err(dev, "Sensor overrange\n");
322 if (status & ADIS16400_DIAG_STAT_SPI_FAIL)
323 dev_err(dev, "SPI failure\n");
324 if (status & ADIS16400_DIAG_STAT_FLASH_UPT)
325 dev_err(dev, "Flash update failed\n");
326 if (status & ADIS16400_DIAG_STAT_POWER_HIGH)
327 dev_err(dev, "Power supply above 5.25V\n");
328 if (status & ADIS16400_DIAG_STAT_POWER_LOW)
329 dev_err(dev, "Power supply below 4.75V\n");
330
331error_ret:
332 return ret;
333}
334
521de518
JC		 335static int adis16400_self_test(struct iio_dev *indio_dev)
336{
337 int ret;
338 ret = adis16400_spi_write_reg_16(indio_dev,
339 ADIS16400_MSC_CTRL,
340 ADIS16400_MSC_CTRL_MEM_TEST);
341 if (ret) {
342 dev_err(&indio_dev->dev, "problem starting self test");
343 goto err_ret;
344 }
345
346 msleep(ADIS16400_MTEST_DELAY);
347 adis16400_check_status(indio_dev);
348
349err_ret:
350 return ret;
351}
352
38d15f06 353static int adis16400_initial_setup(struct iio_dev *indio_dev)
a9d26f00
BS		 354{
355 int ret;
356 u16 prod_id, smp_prd;
38d15f06 357 struct adis16400_state *st = iio_priv(indio_dev);
a9d26f00
BS		 358
359 /* use low spi speed for init */
360 st->us->max_speed_hz = ADIS16400_SPI_SLOW;
361 st->us->mode = SPI_MODE_3;
362 spi_setup(st->us);
363
38d15f06 364 ret = adis16400_set_irq(indio_dev, false);
a9d26f00 365 if (ret) {
521de518 366 dev_err(&indio_dev->dev, "disable irq failed");
a9d26f00
BS		 367 goto err_ret;
368 }
369
38d15f06 370 ret = adis16400_self_test(indio_dev);
3fd66da1 371 if (ret) {
521de518 372 dev_err(&indio_dev->dev, "self test failure");
3fd66da1
BS		 373 goto err_ret;
374 }
a9d26f00 375
38d15f06 376 ret = adis16400_check_status(indio_dev);
a9d26f00 377 if (ret) {
38d15f06 378 adis16400_reset(indio_dev);
521de518 379 dev_err(&indio_dev->dev, "device not playing ball -> reset");
a9d26f00 380 msleep(ADIS16400_STARTUP_DELAY);
38d15f06 381 ret = adis16400_check_status(indio_dev);
a9d26f00 382 if (ret) {
521de518 383 dev_err(&indio_dev->dev, "giving up");
a9d26f00
BS		 384 goto err_ret;
385 }
386 }
2a29a90b 387 if (st->variant->flags & ADIS16400_HAS_PROD_ID) {
38d15f06 388 ret = adis16400_spi_read_reg_16(indio_dev,
2a29a90b
JC		 389 ADIS16400_PRODUCT_ID, &prod_id);
390 if (ret)
391 goto err_ret;
a9d26f00 392
2a29a90b 393 if ((prod_id & 0xF000) != st->variant->product_id)
521de518 394 dev_warn(&indio_dev->dev, "incorrect id");
a9d26f00 395
69d80bae 396 dev_info(&indio_dev->dev, "%s: prod_id 0x%04x at CS%d (irq %d)\n",
521de518
JC		 397 indio_dev->name, prod_id,
398 st->us->chip_select, st->us->irq);
2a29a90b 399 }
a9d26f00 400 /* use high spi speed if possible */
38d15f06 401 ret = adis16400_spi_read_reg_16(indio_dev,
e7854845 402 ADIS16400_SMPL_PRD, &smp_prd);
a9d26f00
BS		 403 if (!ret && (smp_prd & ADIS16400_SMPL_PRD_DIV_MASK) < 0x0A) {
404 st->us->max_speed_hz = ADIS16400_SPI_SLOW;
405 spi_setup(st->us);
406 }
407
a9d26f00 408err_ret:
a9d26f00
BS		 409 return ret;
410}
411
a9d26f00 412static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
521de518
JC		 413 adis16400_read_frequency,
414 adis16400_write_frequency);
a9d26f00
BS		 415
416static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16400_write_reset, 0);
417
51a0a5b0 418static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("409 546 819 1638");
a9d26f00 419
e7854845
JC		 420enum adis16400_chan {
421 in_supply,
422 gyro_x,
423 gyro_y,
424 gyro_z,
425 accel_x,
426 accel_y,
427 accel_z,
428 magn_x,
429 magn_y,
430 magn_z,
431 temp,
2a29a90b 432 temp0, temp1, temp2,
91ab3fc9
JC		 433 in1,
434 incli_x,
435 incli_y,
e7854845
JC		 436};
437
91ab3fc9 438static u8 adis16400_addresses[17][2] = {
521de518 439 [in_supply] = { ADIS16400_SUPPLY_OUT },
e7854845
JC		 440 [gyro_x] = { ADIS16400_XGYRO_OUT, ADIS16400_XGYRO_OFF },
441 [gyro_y] = { ADIS16400_YGYRO_OUT, ADIS16400_YGYRO_OFF },
442 [gyro_z] = { ADIS16400_ZGYRO_OUT, ADIS16400_ZGYRO_OFF },
443 [accel_x] = { ADIS16400_XACCL_OUT, ADIS16400_XACCL_OFF },
444 [accel_y] = { ADIS16400_YACCL_OUT, ADIS16400_YACCL_OFF },
445 [accel_z] = { ADIS16400_ZACCL_OUT, ADIS16400_ZACCL_OFF },
521de518
JC		 446 [magn_x] = { ADIS16400_XMAGN_OUT },
447 [magn_y] = { ADIS16400_YMAGN_OUT },
448 [magn_z] = { ADIS16400_ZMAGN_OUT },
449 [temp] = { ADIS16400_TEMP_OUT },
2a29a90b
JC		 450 [temp0] = { ADIS16350_XTEMP_OUT },
451 [temp1] = { ADIS16350_YTEMP_OUT },
452 [temp2] = { ADIS16350_ZTEMP_OUT },
521de518
JC		 453 [in1] = { ADIS16400_AUX_ADC },
454 [incli_x] = { ADIS16300_PITCH_OUT },
455 [incli_y] = { ADIS16300_ROLL_OUT }
e7854845
JC		 456};
457
458static int adis16400_write_raw(struct iio_dev *indio_dev,
459 struct iio_chan_spec const *chan,
460 int val,
461 int val2,
462 long mask)
463{
464 int ret;
521de518 465
e7854845
JC		 466 switch (mask) {
467 case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
468 mutex_lock(&indio_dev->mlock);
469 ret = adis16400_spi_write_reg_16(indio_dev,
470 adis16400_addresses[chan->address][1],
471 val);
472 mutex_unlock(&indio_dev->mlock);
473 return ret;
474 default:
475 return -EINVAL;
476 }
477}
478
479static int adis16400_read_raw(struct iio_dev *indio_dev,
480 struct iio_chan_spec const *chan,
481 int *val,
482 int *val2,
483 long mask)
484{
38d15f06 485 struct adis16400_state *st = iio_priv(indio_dev);
521de518 486 int ret, shift;
e7854845 487 s16 val16;
e7854845
JC		 488
489 switch (mask) {
490 case 0:
491 mutex_lock(&indio_dev->mlock);
492 ret = adis16400_spi_read_reg_16(indio_dev,
493 adis16400_addresses[chan->address][0],
494 &val16);
495 if (ret) {
496 mutex_unlock(&indio_dev->mlock);
497 return ret;
498 }
499 val16 &= (1 << chan->scan_type.realbits) - 1;
500 if (chan->scan_type.sign == 's') {
501 shift = 16 - chan->scan_type.realbits;
502 val16 = (s16)(val16 << shift) >> shift;
503 }
504 *val = val16;
505 mutex_unlock(&indio_dev->mlock);
506 return IIO_VAL_INT;
507 case (1 << IIO_CHAN_INFO_SCALE_SHARED):
508 case (1 << IIO_CHAN_INFO_SCALE_SEPARATE):
509 switch (chan->type) {
510 case IIO_GYRO:
511 *val = 0;
2a29a90b 512 *val2 = st->variant->gyro_scale_micro;
e7854845 513 return IIO_VAL_INT_PLUS_MICRO;
6835cb6b 514 case IIO_VOLTAGE:
e7854845
JC		 515 *val = 0;
516 if (chan->channel == 0)
517 *val2 = 2418;
518 else
519 *val2 = 806;
520 return IIO_VAL_INT_PLUS_MICRO;
521 case IIO_ACCEL:
522 *val = 0;
2a29a90b 523 *val2 = st->variant->accel_scale_micro;
e7854845
JC		 524 return IIO_VAL_INT_PLUS_MICRO;
525 case IIO_MAGN:
526 *val = 0;
527 *val2 = 500;
528 return IIO_VAL_INT_PLUS_MICRO;
529 case IIO_TEMP:
530 *val = 0;
531 *val2 = 140000;
532 return IIO_VAL_INT_PLUS_MICRO;
533 default:
534 return -EINVAL;
535 }
536 case (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE):
537 mutex_lock(&indio_dev->mlock);
538 ret = adis16400_spi_read_reg_16(indio_dev,
539 adis16400_addresses[chan->address][1],
540 &val16);
2a29a90b
JC		 541 mutex_unlock(&indio_dev->mlock);
542 if (ret)
e7854845 543 return ret;
e7854845
JC		 544 val16 = ((val16 & 0xFFF) << 4) >> 4;
545 *val = val16;
546 return IIO_VAL_INT;
547 case (1 << IIO_CHAN_INFO_OFFSET_SEPARATE):
548 /* currently only temperature */
549 *val = 198;
550 *val2 = 160000;
551 return IIO_VAL_INT_PLUS_MICRO;
552 default:
553 return -EINVAL;
554 }
555}
556
557static struct iio_chan_spec adis16400_channels[] = {
521de518
JC		 558 {
559 .type = IIO_VOLTAGE,
560 .indexed = 1,
561 .channel = 0,
562 .extend_name = "supply",
563 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
564 .address = in_supply,
565 .scan_index = ADIS16400_SCAN_SUPPLY,
566 .scan_type = IIO_ST('u', 14, 16, 0)
567 }, {
568 .type = IIO_GYRO,
569 .modified = 1,
570 .channel2 = IIO_MOD_X,
571 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
572 (1 << IIO_CHAN_INFO_SCALE_SHARED),
573 .address = gyro_x,
574 .scan_index = ADIS16400_SCAN_GYRO_X,
575 .scan_type = IIO_ST('s', 14, 16, 0)
576 }, {
577 .type = IIO_GYRO,
578 .modified = 1,
579 .channel2 = IIO_MOD_Y,
580 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
581 (1 << IIO_CHAN_INFO_SCALE_SHARED),
582 .address = gyro_y,
583 .scan_index = ADIS16400_SCAN_GYRO_Y,
584 .scan_type = IIO_ST('s', 14, 16, 0),
585 }, {
586 .type = IIO_GYRO,
587 .modified = 1,
588 .channel2 = IIO_MOD_Z,
589 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
590 (1 << IIO_CHAN_INFO_SCALE_SHARED),
591 .address = gyro_z,
592 .scan_index = ADIS16400_SCAN_GYRO_Z,
593 .scan_type = IIO_ST('s', 14, 16, 0),
594 }, {
595 .type = IIO_ACCEL,
596 .modified = 1,
597 .channel2 = IIO_MOD_X,
598 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
599 (1 << IIO_CHAN_INFO_SCALE_SHARED),
600 .address = accel_x,
601 .scan_index = ADIS16400_SCAN_ACC_X,
602 .scan_type = IIO_ST('s', 14, 16, 0),
603 }, {
604 .type = IIO_ACCEL,
605 .modified = 1,
606 .channel2 = IIO_MOD_Y,
607 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
608 (1 << IIO_CHAN_INFO_SCALE_SHARED),
609 .address = accel_y,
610 .scan_index = ADIS16400_SCAN_ACC_Y,
611 .scan_type = IIO_ST('s', 14, 16, 0),
612 }, {
613 .type = IIO_ACCEL,
614 .modified = 1,
615 .channel2 = IIO_MOD_Z,
616 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
617 (1 << IIO_CHAN_INFO_SCALE_SHARED),
618 .address = accel_z,
619 .scan_index = ADIS16400_SCAN_ACC_Z,
620 .scan_type = IIO_ST('s', 14, 16, 0),
621 }, {
622 .type = IIO_MAGN,
623 .modified = 1,
624 .channel2 = IIO_MOD_X,
625 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SHARED),
626 .address = magn_x,
627 .scan_index = ADIS16400_SCAN_MAGN_X,
628 .scan_type = IIO_ST('s', 14, 16, 0),
629 }, {
630 .type = IIO_MAGN,
631 .modified = 1,
632 .channel2 = IIO_MOD_Y,
633 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SHARED),
634 .address = magn_y,
635 .scan_index = ADIS16400_SCAN_MAGN_Y,
636 .scan_type = IIO_ST('s', 14, 16, 0),
637 }, {
638 .type = IIO_MAGN,
639 .modified = 1,
640 .channel2 = IIO_MOD_Z,
641 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SHARED),
642 .address = magn_z,
643 .scan_index = ADIS16400_SCAN_MAGN_Z,
644 .scan_type = IIO_ST('s', 14, 16, 0),
645 }, {
646 .type = IIO_TEMP,
647 .indexed = 1,
648 .channel = 0,
649 .info_mask = (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
650 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
651 .address = temp,
652 .scan_index = ADIS16400_SCAN_TEMP,
653 .scan_type = IIO_ST('s', 12, 16, 0),
654 }, {
6835cb6b 655 .type = IIO_VOLTAGE,
521de518
JC		 656 .indexed = 1,
657 .channel = 1,
658 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
659 .address = in1,
660 .scan_index = ADIS16400_SCAN_ADC_0,
661 .scan_type = IIO_ST('s', 12, 16, 0),
662 },
e7854845
JC		 663 IIO_CHAN_SOFT_TIMESTAMP(12)
664};
665
2a29a90b 666static struct iio_chan_spec adis16350_channels[] = {
521de518
JC		 667 {
668 .type = IIO_VOLTAGE,
669 .indexed = 1,
670 .channel = 0,
671 .extend_name = "supply",
672 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
673 .address = in_supply,
674 .scan_index = ADIS16400_SCAN_SUPPLY,
675 .scan_type = IIO_ST('u', 12, 16, 0)
676 }, {
677 .type = IIO_GYRO,
678 .modified = 1,
679 .channel2 = IIO_MOD_X,
680 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
681 (1 << IIO_CHAN_INFO_SCALE_SHARED),
682 .address = gyro_x,
683 .scan_index = ADIS16400_SCAN_GYRO_X,
684 .scan_type = IIO_ST('s', 14, 16, 0)
685 }, {
686 .type = IIO_GYRO,
687 .modified = 1,
688 .channel2 = IIO_MOD_Y,
689 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
690 (1 << IIO_CHAN_INFO_SCALE_SHARED),
691 .address = gyro_y,
692 .scan_index = ADIS16400_SCAN_GYRO_Y,
693 .scan_type = IIO_ST('s', 14, 16, 0),
694 }, {
695 .type = IIO_GYRO,
696 .modified = 1,
697 .channel2 = IIO_MOD_Z,
698 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
699 (1 << IIO_CHAN_INFO_SCALE_SHARED),
700 .address = gyro_z,
701 .scan_index = ADIS16400_SCAN_GYRO_Z,
702 .scan_type = IIO_ST('s', 14, 16, 0),
703 }, {
704 .type = IIO_ACCEL,
705 .modified = 1,
706 .channel2 = IIO_MOD_X,
707 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
708 (1 << IIO_CHAN_INFO_SCALE_SHARED),
709 .address = accel_x,
710 .scan_index = ADIS16400_SCAN_ACC_X,
711 .scan_type = IIO_ST('s', 14, 16, 0),
712 }, {
713 .type = IIO_ACCEL,
714 .modified = 1,
715 .channel2 = IIO_MOD_Y,
716 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
717 (1 << IIO_CHAN_INFO_SCALE_SHARED),
718 .address = accel_y,
719 .scan_index = ADIS16400_SCAN_ACC_Y,
720 .scan_type = IIO_ST('s', 14, 16, 0),
721 }, {
722 .type = IIO_ACCEL,
723 .modified = 1,
724 .channel2 = IIO_MOD_Z,
725 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
726 (1 << IIO_CHAN_INFO_SCALE_SHARED),
727 .address = accel_z,
728 .scan_index = ADIS16400_SCAN_ACC_Z,
729 .scan_type = IIO_ST('s', 14, 16, 0),
730 }, {
731 .type = IIO_TEMP,
732 .indexed = 1,
733 .channel = 0,
734 .extend_name = "x",
735 .info_mask = (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
736 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
737 .address = temp0,
738 .scan_index = ADIS16350_SCAN_TEMP_X,
739 .scan_type = IIO_ST('s', 12, 16, 0),
740 }, {
741 .type = IIO_TEMP,
742 .indexed = 1,
743 .channel = 1,
744 .extend_name = "y",
745 .info_mask = (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
746 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
747 .address = temp1,
748 .scan_index = ADIS16350_SCAN_TEMP_Y,
749 .scan_type = IIO_ST('s', 12, 16, 0),
750 }, {
751 .type = IIO_TEMP,
752 .indexed = 1,
753 .channel = 2,
754 .extend_name = "z",
755 .info_mask = (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
756 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
757 .address = temp2,
758 .scan_index = ADIS16350_SCAN_TEMP_Z,
759 .scan_type = IIO_ST('s', 12, 16, 0),
760 }, {
6835cb6b 761 .type = IIO_VOLTAGE,
521de518
JC		 762 .indexed = 1,
763 .channel = 1,
764 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
765 .address = in1,
766 .scan_index = ADIS16350_SCAN_ADC_0,
767 .scan_type = IIO_ST('s', 12, 16, 0),
768 },
2a29a90b
JC		 769 IIO_CHAN_SOFT_TIMESTAMP(11)
770};
771
8e886e65 772static struct iio_chan_spec adis16300_channels[] = {
521de518
JC		 773 {
774 .type = IIO_VOLTAGE,
775 .indexed = 1,
776 .channel = 0,
777 .extend_name = "supply",
778 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
779 .address = in_supply,
780 .scan_index = ADIS16400_SCAN_SUPPLY,
781 .scan_type = IIO_ST('u', 12, 16, 0)
782 }, {
783 .type = IIO_GYRO,
784 .modified = 1,
785 .channel2 = IIO_MOD_X,
786 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
787 (1 << IIO_CHAN_INFO_SCALE_SHARED),
788 .address = gyro_x,
789 .scan_index = ADIS16400_SCAN_GYRO_X,
790 .scan_type = IIO_ST('s', 14, 16, 0),
791 }, {
792 .type = IIO_ACCEL,
793 .modified = 1,
794 .channel2 = IIO_MOD_X,
795 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
796 (1 << IIO_CHAN_INFO_SCALE_SHARED),
797 .address = accel_x,
798 .scan_index = ADIS16400_SCAN_ACC_X,
799 .scan_type = IIO_ST('s', 14, 16, 0),
800 }, {
801 .type = IIO_ACCEL,
802 .modified = 1,
803 .channel2 = IIO_MOD_Y,
804 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
805 (1 << IIO_CHAN_INFO_SCALE_SHARED),
806 .address = accel_y,
807 .scan_index = ADIS16400_SCAN_ACC_Y,
808 .scan_type = IIO_ST('s', 14, 16, 0),
809 }, {
810 .type = IIO_ACCEL,
811 .modified = 1,
812 .channel2 = IIO_MOD_Z,
813 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
814 (1 << IIO_CHAN_INFO_SCALE_SHARED),
815 .address = accel_z,
816 .scan_index = ADIS16400_SCAN_ACC_Z,
817 .scan_type = IIO_ST('s', 14, 16, 0),
818 }, {
819 .type = IIO_TEMP,
820 .indexed = 1,
821 .channel = 0,
822 .info_mask = (1 << IIO_CHAN_INFO_OFFSET_SEPARATE) |
823 (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
824 .address = temp,
825 .scan_index = ADIS16400_SCAN_TEMP,
826 .scan_type = IIO_ST('s', 12, 16, 0),
827 }, {
6835cb6b 828 .type = IIO_VOLTAGE,
521de518
JC		 829 .indexed = 1,
830 .channel = 1,
831 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
832 .address = in1,
833 .scan_index = ADIS16350_SCAN_ADC_0,
834 .scan_type = IIO_ST('s', 12, 16, 0),
835 }, {
836 .type = IIO_INCLI,
837 .modified = 1,
838 .channel2 = IIO_MOD_X,
839 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SHARED),
840 .address = incli_x,
841 .scan_index = ADIS16300_SCAN_INCLI_X,
842 .scan_type = IIO_ST('s', 13, 16, 0),
843 }, {
844 .type = IIO_INCLI,
845 .modified = 1,
846 .channel2 = IIO_MOD_Y,
847 .info_mask = (1 << IIO_CHAN_INFO_SCALE_SHARED),
848 .address = incli_y,
849 .scan_index = ADIS16300_SCAN_INCLI_Y,
850 .scan_type = IIO_ST('s', 13, 16, 0),
851 },
8e886e65
JC		 852 IIO_CHAN_SOFT_TIMESTAMP(14)
853};
854
85da5059 855static const struct iio_chan_spec adis16334_channels[] = {
521de518
JC		 856 {
857 .type = IIO_GYRO,
858 .modified = 1,
859 .channel2 = IIO_MOD_X,
860 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
861 (1 << IIO_CHAN_INFO_SCALE_SHARED),
862 .address = gyro_x,
863 .scan_index = ADIS16400_SCAN_GYRO_X,
864 .scan_type = IIO_ST('s', 14, 16, 0),
865 }, {
866 .type = IIO_GYRO,
867 .modified = 1,
868 .channel2 = IIO_MOD_Y,
869 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
870 (1 << IIO_CHAN_INFO_SCALE_SHARED),
871 .address = gyro_y,
872 .scan_index = ADIS16400_SCAN_GYRO_Y,
873 .scan_type = IIO_ST('s', 14, 16, 0),
874 }, {
875 .type = IIO_GYRO,
876 .modified = 1,
877 .channel2 = IIO_MOD_Z,
878 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
879 (1 << IIO_CHAN_INFO_SCALE_SHARED),
880 .address = gyro_z,
881 .scan_index = ADIS16400_SCAN_GYRO_Z,
882 .scan_type = IIO_ST('s', 14, 16, 0),
883 }, {
884 .type = IIO_ACCEL,
885 .modified = 1,
886 .channel2 = IIO_MOD_X,
887 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
888 (1 << IIO_CHAN_INFO_SCALE_SHARED),
889 .address = accel_x,
890 .scan_index = ADIS16400_SCAN_ACC_X,
891 .scan_type = IIO_ST('s', 14, 16, 0),
892 }, {
893 .type = IIO_ACCEL,
894 .modified = 1,
895 .channel2 = IIO_MOD_Y,
896 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
897 (1 << IIO_CHAN_INFO_SCALE_SHARED),
898 .address = accel_y,
899 .scan_index = ADIS16400_SCAN_ACC_Y,
900 .scan_type = IIO_ST('s', 14, 16, 0),
901 }, {
902 .type = IIO_ACCEL,
903 .modified = 1,
904 .channel2 = IIO_MOD_Z,
905 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
906 (1 << IIO_CHAN_INFO_SCALE_SHARED),
907 .address = accel_z,
908 .scan_index = ADIS16400_SCAN_ACC_Z,
909 .scan_type = IIO_ST('s', 14, 16, 0),
910 }, {
911 .type = IIO_TEMP,
912 .indexed = 1,
913 .channel = 0,
914 .info_mask = (1 << IIO_CHAN_INFO_CALIBBIAS_SEPARATE) |
915 (1 << IIO_CHAN_INFO_SCALE_SHARED),
916 .address = accel_z,
917 .scan_index = ADIS16400_SCAN_ACC_Z,
918 .scan_type = IIO_ST('s', 14, 16, 0),
919 },
88b42f3a
JC		 920 IIO_CHAN_SOFT_TIMESTAMP(12)
921};
922
a9d26f00 923static struct attribute *adis16400_attributes[] = {
a9d26f00 924 &iio_dev_attr_sampling_frequency.dev_attr.attr,
51a0a5b0 925 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
a9d26f00 926 &iio_dev_attr_reset.dev_attr.attr,
a9d26f00
BS		 927 NULL
928};
929
930static const struct attribute_group adis16400_attribute_group = {
931 .attrs = adis16400_attributes,
932};
933
2a29a90b 934static struct adis16400_chip_info adis16400_chips[] = {
8e886e65
JC		 935 [ADIS16300] = {
936 .channels = adis16300_channels,
937 .num_channels = ARRAY_SIZE(adis16300_channels),
938 .gyro_scale_micro = 873,
939 .accel_scale_micro = 5884,
940 .default_scan_mask = (1 << ADIS16400_SCAN_SUPPLY) |
941 (1 << ADIS16400_SCAN_GYRO_X) | (1 << ADIS16400_SCAN_ACC_X) |
942 (1 << ADIS16400_SCAN_ACC_Y) | (1 << ADIS16400_SCAN_ACC_Z) |
943 (1 << ADIS16400_SCAN_TEMP) | (1 << ADIS16400_SCAN_ADC_0) |
944 (1 << ADIS16300_SCAN_INCLI_X) | (1 << ADIS16300_SCAN_INCLI_Y) |
945 (1 << 14),
946 },
85da5059
JC		 947 [ADIS16334] = {
948 .channels = adis16334_channels,
949 .num_channels = ARRAY_SIZE(adis16334_channels),
88b42f3a
JC		 950 .gyro_scale_micro = 873,
951 .accel_scale_micro = 981,
952 .default_scan_mask = (1 << ADIS16400_SCAN_GYRO_X) |
953 (1 << ADIS16400_SCAN_GYRO_Y) | (1 << ADIS16400_SCAN_GYRO_Z) |
954 (1 << ADIS16400_SCAN_ACC_X) | (1 << ADIS16400_SCAN_ACC_Y) |
955 (1 << ADIS16400_SCAN_ACC_Z),
956 },
2a29a90b
JC		 957 [ADIS16350] = {
958 .channels = adis16350_channels,
959 .num_channels = ARRAY_SIZE(adis16350_channels),
960 .gyro_scale_micro = 872664,
961 .accel_scale_micro = 24732,
962 .default_scan_mask = 0x7FF,
963 .flags = ADIS16400_NO_BURST,
964 },
965 [ADIS16360] = {
966 .channels = adis16350_channels,
967 .num_channels = ARRAY_SIZE(adis16350_channels),
968 .flags = ADIS16400_HAS_PROD_ID,
969 .product_id = 0x3FE8,
970 .gyro_scale_micro = 1279,
971 .accel_scale_micro = 24732,
972 .default_scan_mask = 0x7FF,
973 },
974 [ADIS16362] = {
975 .channels = adis16350_channels,
976 .num_channels = ARRAY_SIZE(adis16350_channels),
977 .flags = ADIS16400_HAS_PROD_ID,
978 .product_id = 0x3FEA,
979 .gyro_scale_micro = 1279,
980 .accel_scale_micro = 24732,
981 .default_scan_mask = 0x7FF,
982 },
983 [ADIS16364] = {
984 .channels = adis16350_channels,
985 .num_channels = ARRAY_SIZE(adis16350_channels),
986 .flags = ADIS16400_HAS_PROD_ID,
987 .product_id = 0x3FEC,
988 .gyro_scale_micro = 1279,
989 .accel_scale_micro = 24732,
990 .default_scan_mask = 0x7FF,
991 },
992 [ADIS16365] = {
993 .channels = adis16350_channels,
994 .num_channels = ARRAY_SIZE(adis16350_channels),
995 .flags = ADIS16400_HAS_PROD_ID,
996 .product_id = 0x3FED,
997 .gyro_scale_micro = 1279,
998 .accel_scale_micro = 24732,
999 .default_scan_mask = 0x7FF,
1000 },
1001 [ADIS16400] = {
1002 .channels = adis16400_channels,
1003 .num_channels = ARRAY_SIZE(adis16400_channels),
1004 .flags = ADIS16400_HAS_PROD_ID,
1005 .product_id = 0x4015,
1006 .gyro_scale_micro = 873,
1007 .accel_scale_micro = 32656,
1008 .default_scan_mask = 0xFFF,
1009 }
1010};
1011
6fe8135f
JC		 1012static const struct iio_info adis16400_info = {
1013 .driver_module = THIS_MODULE,
1014 .read_raw = &adis16400_read_raw,
1015 .write_raw = &adis16400_write_raw,
1016 .attrs = &adis16400_attribute_group,
1017};
2a29a90b 1018
a9d26f00
BS		 1019static int __devinit adis16400_probe(struct spi_device *spi)
1020{
26d25ae3 1021 int ret;
38d15f06
JC		 1022 struct adis16400_state *st;
1023 struct iio_dev *indio_dev = iio_allocate_device(sizeof(*st));
1024 if (indio_dev == NULL) {
a9d26f00
BS		 1025 ret = -ENOMEM;
1026 goto error_ret;
1027 }
38d15f06 1028 st = iio_priv(indio_dev);
a9d26f00 1029 /* this is only used for removal purposes */
38d15f06 1030 spi_set_drvdata(spi, indio_dev);
a9d26f00 1031
a9d26f00
BS		 1032 st->us = spi;
1033 mutex_init(&st->buf_lock);
38d15f06 1034
a9d26f00 1035 /* setup the industrialio driver allocated elements */
2a29a90b 1036 st->variant = &adis16400_chips[spi_get_device_id(spi)->driver_data];
38d15f06
JC		 1037 indio_dev->dev.parent = &spi->dev;
1038 indio_dev->name = spi_get_device_id(spi)->name;
38d15f06
JC		 1039 indio_dev->channels = st->variant->channels;
1040 indio_dev->num_channels = st->variant->num_channels;
6fe8135f 1041 indio_dev->info = &adis16400_info;
38d15f06
JC		 1042 indio_dev->modes = INDIO_DIRECT_MODE;
1043
1044 ret = adis16400_configure_ring(indio_dev);
a9d26f00
BS		 1045 if (ret)
1046 goto error_free_dev;
1047
14555b14
JC		 1048 ret = iio_buffer_register(indio_dev,
1049 st->variant->channels,
1050 st->variant->num_channels);
a9d26f00 1051 if (ret) {
6a6ec623 1052 dev_err(&spi->dev, "failed to initialize the ring\n");
a9d26f00
BS		 1053 goto error_unreg_ring_funcs;
1054 }
1055
521de518 1056 if (spi->irq) {
38d15f06 1057 ret = adis16400_probe_trigger(indio_dev);
a9d26f00 1058 if (ret)
b333a240 1059 goto error_uninitialize_ring;
a9d26f00
BS		 1060 }
1061
1062 /* Get the device into a sane initial state */
38d15f06 1063 ret = adis16400_initial_setup(indio_dev);
a9d26f00
BS		 1064 if (ret)
1065 goto error_remove_trigger;
26d25ae3
JC		 1066 ret = iio_device_register(indio_dev);
1067 if (ret)
1068 goto error_remove_trigger;
1069
a9d26f00
BS		 1070 return 0;
1071
1072error_remove_trigger:
ec3afa40 1073 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
38d15f06 1074 adis16400_remove_trigger(indio_dev);
a9d26f00 1075error_uninitialize_ring:
14555b14 1076 iio_buffer_unregister(indio_dev);
a9d26f00 1077error_unreg_ring_funcs:
38d15f06 1078 adis16400_unconfigure_ring(indio_dev);
a9d26f00 1079error_free_dev:
26d25ae3 1080 iio_free_device(indio_dev);
a9d26f00
BS		 1081error_ret:
1082 return ret;
1083}
1084
1085/* fixme, confirm ordering in this function */
1086static int adis16400_remove(struct spi_device *spi)
1087{
1088 int ret;
38d15f06 1089 struct iio_dev *indio_dev = spi_get_drvdata(spi);
a9d26f00 1090
e7854845 1091 ret = adis16400_stop_device(indio_dev);
a9d26f00
BS		 1092 if (ret)
1093 goto err_ret;
1094
a9d26f00 1095 adis16400_remove_trigger(indio_dev);
14555b14 1096 iio_buffer_unregister(indio_dev);
a9d26f00
BS		 1097 adis16400_unconfigure_ring(indio_dev);
1098 iio_device_unregister(indio_dev);
2a29a90b 1099
a9d26f00
BS		 1100 return 0;
1101
1102err_ret:
1103 return ret;
1104}
1105
2a29a90b 1106static const struct spi_device_id adis16400_id[] = {
8e886e65 1107 {"adis16300", ADIS16300},
85da5059 1108 {"adis16334", ADIS16334},
2a29a90b
JC		 1109 {"adis16350", ADIS16350},
1110 {"adis16354", ADIS16350},
1111 {"adis16355", ADIS16350},
1112 {"adis16360", ADIS16360},
1113 {"adis16362", ADIS16362},
1114 {"adis16364", ADIS16364},
1115 {"adis16365", ADIS16365},
1116 {"adis16400", ADIS16400},
1117 {"adis16405", ADIS16400},
1118 {}
1119};
1120
a9d26f00
BS		 1121static struct spi_driver adis16400_driver = {
1122 .driver = {
1123 .name = "adis16400",
1124 .owner = THIS_MODULE,
1125 },
2a29a90b 1126 .id_table = adis16400_id,
a9d26f00
BS		 1127 .probe = adis16400_probe,
1128 .remove = __devexit_p(adis16400_remove),
1129};
1130
1131static __init int adis16400_init(void)
1132{
1133 return spi_register_driver(&adis16400_driver);
1134}
1135module_init(adis16400_init);
1136
1137static __exit void adis16400_exit(void)
1138{
1139 spi_unregister_driver(&adis16400_driver);
1140}
1141module_exit(adis16400_exit);
1142
1143MODULE_AUTHOR("Manuel Stahl <manuel.stahl@iis.fraunhofer.de>");
1144MODULE_DESCRIPTION("Analog Devices ADIS16400/5 IMU SPI driver");
1145MODULE_LICENSE("GPL v2");
Linux kernel - Deliverables
This page took 0.276309 seconds and 5 git commands to generate.