Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
adis16209_core.c
Go to the documentation of this file.
1 /*
2  * ADIS16209 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/list.h>
17 #include <linux/module.h>
18 
19 #include <linux/iio/iio.h>
20 #include <linux/iio/sysfs.h>
21 #include <linux/iio/buffer.h>
22 
23 #include "adis16209.h"
24 
25 #define DRIVER_NAME "adis16209"
26 
33 static int adis16209_spi_write_reg_8(struct iio_dev *indio_dev,
34  u8 reg_address,
35  u8 val)
36 {
37  int ret;
38  struct adis16209_state *st = iio_priv(indio_dev);
39 
40  mutex_lock(&st->buf_lock);
41  st->tx[0] = ADIS16209_WRITE_REG(reg_address);
42  st->tx[1] = val;
43 
44  ret = spi_write(st->us, st->tx, 2);
45  mutex_unlock(&st->buf_lock);
46 
47  return ret;
48 }
49 
57 static int adis16209_spi_write_reg_16(struct iio_dev *indio_dev,
58  u8 lower_reg_address,
59  u16 value)
60 {
61  int ret;
62  struct spi_message msg;
63  struct adis16209_state *st = iio_priv(indio_dev);
64  struct spi_transfer xfers[] = {
65  {
66  .tx_buf = st->tx,
67  .bits_per_word = 8,
68  .len = 2,
69  .cs_change = 1,
70  .delay_usecs = 30,
71  }, {
72  .tx_buf = st->tx + 2,
73  .bits_per_word = 8,
74  .len = 2,
75  .delay_usecs = 30,
76  },
77  };
78 
79  mutex_lock(&st->buf_lock);
80  st->tx[0] = ADIS16209_WRITE_REG(lower_reg_address);
81  st->tx[1] = value & 0xFF;
82  st->tx[2] = ADIS16209_WRITE_REG(lower_reg_address + 1);
83  st->tx[3] = (value >> 8) & 0xFF;
84 
85  spi_message_init(&msg);
86  spi_message_add_tail(&xfers[0], &msg);
87  spi_message_add_tail(&xfers[1], &msg);
88  ret = spi_sync(st->us, &msg);
89  mutex_unlock(&st->buf_lock);
90 
91  return ret;
92 }
93 
101 static int adis16209_spi_read_reg_16(struct iio_dev *indio_dev,
102  u8 lower_reg_address,
103  u16 *val)
104 {
105  struct spi_message msg;
106  struct adis16209_state *st = iio_priv(indio_dev);
107  int ret;
108  struct spi_transfer xfers[] = {
109  {
110  .tx_buf = st->tx,
111  .bits_per_word = 8,
112  .len = 2,
113  .cs_change = 1,
114  .delay_usecs = 30,
115  }, {
116  .rx_buf = st->rx,
117  .bits_per_word = 8,
118  .len = 2,
119  .delay_usecs = 30,
120  },
121  };
122 
123  mutex_lock(&st->buf_lock);
124  st->tx[0] = ADIS16209_READ_REG(lower_reg_address);
125  st->tx[1] = 0;
126 
127  spi_message_init(&msg);
128  spi_message_add_tail(&xfers[0], &msg);
129  spi_message_add_tail(&xfers[1], &msg);
130  ret = spi_sync(st->us, &msg);
131  if (ret) {
132  dev_err(&st->us->dev,
133  "problem when reading 16 bit register 0x%02X",
134  lower_reg_address);
135  goto error_ret;
136  }
137  *val = (st->rx[0] << 8) | st->rx[1];
138 
139 error_ret:
140  mutex_unlock(&st->buf_lock);
141  return ret;
142 }
143 
144 static int adis16209_reset(struct iio_dev *indio_dev)
145 {
146  int ret;
147  ret = adis16209_spi_write_reg_8(indio_dev,
148  ADIS16209_GLOB_CMD,
149  ADIS16209_GLOB_CMD_SW_RESET);
150  if (ret)
151  dev_err(&indio_dev->dev, "problem resetting device");
152 
153  return ret;
154 }
155 
156 int adis16209_set_irq(struct iio_dev *indio_dev, bool enable)
157 {
158  int ret = 0;
159  u16 msc;
160 
161  ret = adis16209_spi_read_reg_16(indio_dev, ADIS16209_MSC_CTRL, &msc);
162  if (ret)
163  goto error_ret;
164 
165  msc |= ADIS16209_MSC_CTRL_ACTIVE_HIGH;
166  msc &= ~ADIS16209_MSC_CTRL_DATA_RDY_DIO2;
167  if (enable)
168  msc |= ADIS16209_MSC_CTRL_DATA_RDY_EN;
169  else
170  msc &= ~ADIS16209_MSC_CTRL_DATA_RDY_EN;
171 
172  ret = adis16209_spi_write_reg_16(indio_dev, ADIS16209_MSC_CTRL, msc);
173 
174 error_ret:
175  return ret;
176 }
177 
178 static int adis16209_check_status(struct iio_dev *indio_dev)
179 {
180  u16 status;
181  int ret;
182 
183  ret = adis16209_spi_read_reg_16(indio_dev,
184  ADIS16209_DIAG_STAT, &status);
185  if (ret < 0) {
186  dev_err(&indio_dev->dev, "Reading status failed\n");
187  goto error_ret;
188  }
189  ret = status & 0x1F;
190 
191  if (status & ADIS16209_DIAG_STAT_SELFTEST_FAIL)
192  dev_err(&indio_dev->dev, "Self test failure\n");
193  if (status & ADIS16209_DIAG_STAT_SPI_FAIL)
194  dev_err(&indio_dev->dev, "SPI failure\n");
195  if (status & ADIS16209_DIAG_STAT_FLASH_UPT)
196  dev_err(&indio_dev->dev, "Flash update failed\n");
197  if (status & ADIS16209_DIAG_STAT_POWER_HIGH)
198  dev_err(&indio_dev->dev, "Power supply above 3.625V\n");
199  if (status & ADIS16209_DIAG_STAT_POWER_LOW)
200  dev_err(&indio_dev->dev, "Power supply below 3.15V\n");
201 
202 error_ret:
203  return ret;
204 }
205 
206 static int adis16209_self_test(struct iio_dev *indio_dev)
207 {
208  int ret;
209  ret = adis16209_spi_write_reg_16(indio_dev,
210  ADIS16209_MSC_CTRL,
211  ADIS16209_MSC_CTRL_SELF_TEST_EN);
212  if (ret) {
213  dev_err(&indio_dev->dev, "problem starting self test");
214  goto err_ret;
215  }
216 
217  adis16209_check_status(indio_dev);
218 
219 err_ret:
220  return ret;
221 }
222 
223 static int adis16209_initial_setup(struct iio_dev *indio_dev)
224 {
225  int ret;
226 
227  /* Disable IRQ */
228  ret = adis16209_set_irq(indio_dev, false);
229  if (ret) {
230  dev_err(&indio_dev->dev, "disable irq failed");
231  goto err_ret;
232  }
233 
234  /* Do self test */
235  ret = adis16209_self_test(indio_dev);
236  if (ret) {
237  dev_err(&indio_dev->dev, "self test failure");
238  goto err_ret;
239  }
240 
241  /* Read status register to check the result */
242  ret = adis16209_check_status(indio_dev);
243  if (ret) {
244  adis16209_reset(indio_dev);
245  dev_err(&indio_dev->dev, "device not playing ball -> reset");
246  msleep(ADIS16209_STARTUP_DELAY);
247  ret = adis16209_check_status(indio_dev);
248  if (ret) {
249  dev_err(&indio_dev->dev, "giving up");
250  goto err_ret;
251  }
252  }
253 
254 err_ret:
255  return ret;
256 }
257 
258 enum adis16209_chan {
259  in_supply,
260  temp,
261  accel_x,
262  accel_y,
263  incli_x,
264  incli_y,
265  in_aux,
266  rot,
267 };
268 
269 static const u8 adis16209_addresses[8][2] = {
270  [in_supply] = { ADIS16209_SUPPLY_OUT },
271  [in_aux] = { ADIS16209_AUX_ADC },
272  [accel_x] = { ADIS16209_XACCL_OUT, ADIS16209_XACCL_NULL },
273  [accel_y] = { ADIS16209_YACCL_OUT, ADIS16209_YACCL_NULL },
274  [incli_x] = { ADIS16209_XINCL_OUT, ADIS16209_XINCL_NULL },
275  [incli_y] = { ADIS16209_YINCL_OUT, ADIS16209_YINCL_NULL },
276  [rot] = { ADIS16209_ROT_OUT },
277  [temp] = { ADIS16209_TEMP_OUT },
278 };
279 
280 static int adis16209_write_raw(struct iio_dev *indio_dev,
281  struct iio_chan_spec const *chan,
282  int val,
283  int val2,
284  long mask)
285 {
286  int bits;
287  s16 val16;
288  u8 addr;
289  switch (mask) {
290  case IIO_CHAN_INFO_CALIBBIAS:
291  switch (chan->type) {
292  case IIO_ACCEL:
293  case IIO_INCLI:
294  bits = 14;
295  break;
296  default:
297  return -EINVAL;
298  };
299  val16 = val & ((1 << bits) - 1);
300  addr = adis16209_addresses[chan->address][1];
301  return adis16209_spi_write_reg_16(indio_dev, addr, val16);
302  }
303  return -EINVAL;
304 }
305 
306 static int adis16209_read_raw(struct iio_dev *indio_dev,
307  struct iio_chan_spec const *chan,
308  int *val, int *val2,
309  long mask)
310 {
311  int ret;
312  int bits;
313  u8 addr;
314  s16 val16;
315 
316  switch (mask) {
317  case IIO_CHAN_INFO_RAW:
318  mutex_lock(&indio_dev->mlock);
319  addr = adis16209_addresses[chan->address][0];
320  ret = adis16209_spi_read_reg_16(indio_dev, addr, &val16);
321  if (ret) {
322  mutex_unlock(&indio_dev->mlock);
323  return ret;
324  }
325 
326  if (val16 & ADIS16209_ERROR_ACTIVE) {
327  ret = adis16209_check_status(indio_dev);
328  if (ret) {
329  mutex_unlock(&indio_dev->mlock);
330  return ret;
331  }
332  }
333  val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
334  if (chan->scan_type.sign == 's')
335  val16 = (s16)(val16 <<
336  (16 - chan->scan_type.realbits)) >>
337  (16 - chan->scan_type.realbits);
338  *val = val16;
339  mutex_unlock(&indio_dev->mlock);
340  return IIO_VAL_INT;
341  case IIO_CHAN_INFO_SCALE:
342  switch (chan->type) {
343  case IIO_VOLTAGE:
344  *val = 0;
345  if (chan->channel == 0)
346  *val2 = 305180; /* 0.30518 mV */
347  else
348  *val2 = 610500; /* 0.6105 mV */
349  return IIO_VAL_INT_PLUS_MICRO;
350  case IIO_TEMP:
351  *val = -470; /* -0.47 C */
352  *val2 = 0;
353  return IIO_VAL_INT_PLUS_MICRO;
354  case IIO_ACCEL:
355  *val = 0;
356  *val2 = IIO_G_TO_M_S_2(244140); /* 0.244140 mg */
357  return IIO_VAL_INT_PLUS_NANO;
358  case IIO_INCLI:
359  case IIO_ROT:
360  *val = 0;
361  *val2 = 25000; /* 0.025 degree */
362  return IIO_VAL_INT_PLUS_MICRO;
363  default:
364  return -EINVAL;
365  }
366  break;
367  case IIO_CHAN_INFO_OFFSET:
368  *val = 25000 / -470 - 0x4FE; /* 25 C = 0x4FE */
369  return IIO_VAL_INT;
370  case IIO_CHAN_INFO_CALIBBIAS:
371  switch (chan->type) {
372  case IIO_ACCEL:
373  bits = 14;
374  break;
375  default:
376  return -EINVAL;
377  };
378  mutex_lock(&indio_dev->mlock);
379  addr = adis16209_addresses[chan->address][1];
380  ret = adis16209_spi_read_reg_16(indio_dev, addr, &val16);
381  if (ret) {
382  mutex_unlock(&indio_dev->mlock);
383  return ret;
384  }
385  val16 &= (1 << bits) - 1;
386  val16 = (s16)(val16 << (16 - bits)) >> (16 - bits);
387  *val = val16;
388  mutex_unlock(&indio_dev->mlock);
389  return IIO_VAL_INT;
390  }
391  return -EINVAL;
392 }
393 
394 static const struct iio_chan_spec adis16209_channels[] = {
395  {
396  .type = IIO_VOLTAGE,
397  .indexed = 1,
398  .channel = 0,
399  .extend_name = "supply",
400  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
401  IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
402  .address = in_supply,
403  .scan_index = ADIS16209_SCAN_SUPPLY,
404  .scan_type = {
405  .sign = 'u',
406  .realbits = 14,
407  .storagebits = 16,
408  },
409  }, {
410  .type = IIO_TEMP,
411  .indexed = 0,
412  .channel = 0,
413  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
414  IIO_CHAN_INFO_SCALE_SEPARATE_BIT |
415  IIO_CHAN_INFO_OFFSET_SEPARATE_BIT,
416  .address = temp,
417  .scan_index = ADIS16209_SCAN_TEMP,
418  .scan_type = {
419  .sign = 'u',
420  .realbits = 12,
421  .storagebits = 16,
422  },
423  }, {
424  .type = IIO_ACCEL,
425  .modified = 1,
426  .channel2 = IIO_MOD_X,
427  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
428  IIO_CHAN_INFO_SCALE_SHARED_BIT |
429  IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
430  .address = accel_x,
431  .scan_index = ADIS16209_SCAN_ACC_X,
432  .scan_type = {
433  .sign = 's',
434  .realbits = 14,
435  .storagebits = 16,
436  },
437  }, {
438  .type = IIO_ACCEL,
439  .modified = 1,
440  .channel2 = IIO_MOD_Y,
441  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
442  IIO_CHAN_INFO_SCALE_SHARED_BIT |
443  IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
444  .address = accel_y,
445  .scan_index = ADIS16209_SCAN_ACC_Y,
446  .scan_type = {
447  .sign = 's',
448  .realbits = 14,
449  .storagebits = 16,
450  },
451  }, {
452  .type = IIO_VOLTAGE,
453  .indexed = 1,
454  .channel = 1,
455  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
456  IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
457  .address = in_aux,
458  .scan_index = ADIS16209_SCAN_AUX_ADC,
459  .scan_type = {
460  .sign = 'u',
461  .realbits = 12,
462  .storagebits = 16,
463  },
464  }, {
465  .type = IIO_INCLI,
466  .modified = 1,
467  .channel2 = IIO_MOD_X,
468  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
469  IIO_CHAN_INFO_SCALE_SHARED_BIT,
470  .address = incli_x,
471  .scan_index = ADIS16209_SCAN_INCLI_X,
472  .scan_type = {
473  .sign = 's',
474  .realbits = 14,
475  .storagebits = 16,
476  },
477  }, {
478  .type = IIO_INCLI,
479  .modified = 1,
480  .channel2 = IIO_MOD_Y,
481  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
482  IIO_CHAN_INFO_SCALE_SHARED_BIT,
483  .address = incli_y,
484  .scan_index = ADIS16209_SCAN_INCLI_Y,
485  .scan_type = {
486  .sign = 's',
487  .realbits = 14,
488  .storagebits = 16,
489  },
490  }, {
491  .type = IIO_ROT,
492  .modified = 1,
493  .channel2 = IIO_MOD_X,
494  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
495  IIO_CHAN_INFO_SCALE_SHARED_BIT,
496  .address = rot,
497  .scan_index = ADIS16209_SCAN_ROT,
498  .scan_type = {
499  .sign = 's',
500  .realbits = 14,
501  .storagebits = 16,
502  },
503  },
504  IIO_CHAN_SOFT_TIMESTAMP(8)
505 };
506 
507 static const struct iio_info adis16209_info = {
508  .read_raw = &adis16209_read_raw,
509  .write_raw = &adis16209_write_raw,
510  .driver_module = THIS_MODULE,
511 };
512 
513 static int __devinit adis16209_probe(struct spi_device *spi)
514 {
515  int ret;
516  struct adis16209_state *st;
517  struct iio_dev *indio_dev;
518 
519  /* setup the industrialio driver allocated elements */
520  indio_dev = iio_device_alloc(sizeof(*st));
521  if (indio_dev == NULL) {
522  ret = -ENOMEM;
523  goto error_ret;
524  }
525  st = iio_priv(indio_dev);
526  /* this is only used for removal purposes */
527  spi_set_drvdata(spi, indio_dev);
528  st->us = spi;
529  mutex_init(&st->buf_lock);
530 
531  indio_dev->name = spi->dev.driver->name;
532  indio_dev->dev.parent = &spi->dev;
533  indio_dev->info = &adis16209_info;
534  indio_dev->channels = adis16209_channels;
535  indio_dev->num_channels = ARRAY_SIZE(adis16209_channels);
536  indio_dev->modes = INDIO_DIRECT_MODE;
537 
538  ret = adis16209_configure_ring(indio_dev);
539  if (ret)
540  goto error_free_dev;
541 
542  ret = iio_buffer_register(indio_dev,
543  adis16209_channels,
544  ARRAY_SIZE(adis16209_channels));
545  if (ret) {
546  printk(KERN_ERR "failed to initialize the ring\n");
547  goto error_unreg_ring_funcs;
548  }
549 
550  if (spi->irq) {
551  ret = adis16209_probe_trigger(indio_dev);
552  if (ret)
553  goto error_uninitialize_ring;
554  }
555 
556  /* Get the device into a sane initial state */
557  ret = adis16209_initial_setup(indio_dev);
558  if (ret)
559  goto error_remove_trigger;
560  ret = iio_device_register(indio_dev);
561  if (ret)
562  goto error_remove_trigger;
563 
564  return 0;
565 
566 error_remove_trigger:
567  adis16209_remove_trigger(indio_dev);
568 error_uninitialize_ring:
569  iio_buffer_unregister(indio_dev);
570 error_unreg_ring_funcs:
571  adis16209_unconfigure_ring(indio_dev);
572 error_free_dev:
573  iio_device_free(indio_dev);
574 error_ret:
575  return ret;
576 }
577 
578 static int __devexit adis16209_remove(struct spi_device *spi)
579 {
580  struct iio_dev *indio_dev = spi_get_drvdata(spi);
581 
582  iio_device_unregister(indio_dev);
583  adis16209_remove_trigger(indio_dev);
584  iio_buffer_unregister(indio_dev);
585  adis16209_unconfigure_ring(indio_dev);
586  iio_device_free(indio_dev);
587 
588  return 0;
589 }
590 
591 static struct spi_driver adis16209_driver = {
592  .driver = {
593  .name = "adis16209",
594  .owner = THIS_MODULE,
595  },
596  .probe = adis16209_probe,
597  .remove = __devexit_p(adis16209_remove),
598 };
599 module_spi_driver(adis16209_driver);
600 
601 MODULE_AUTHOR("Barry Song <[email protected]>");
602 MODULE_DESCRIPTION("Analog Devices ADIS16209 Digital Vibration Sensor driver");
603 MODULE_LICENSE("GPL v2");
604 MODULE_ALIAS("spi:adis16209");
Generated on Thu Jan 10 2013 14:28:32 for Linux Kernel by   doxygen 1.8.2