Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
adt7310.c
Go to the documentation of this file.
1 /*
2  * ADT7310 digital temperature sensor driver supporting ADT7310
3  *
4  * Copyright 2010 Analog Devices Inc.
5  *
6  * Licensed under the GPL-2 or later.
7  */
8 
9 #include <linux/interrupt.h>
10 #include <linux/device.h>
11 #include <linux/kernel.h>
12 #include <linux/slab.h>
13 #include <linux/sysfs.h>
14 #include <linux/list.h>
15 #include <linux/spi/spi.h>
16 #include <linux/module.h>
17 
18 #include <linux/iio/iio.h>
19 #include <linux/iio/sysfs.h>
20 #include <linux/iio/events.h>
21 /*
22  * ADT7310 registers definition
23  */
24 
25 #define ADT7310_STATUS 0
26 #define ADT7310_CONFIG 1
27 #define ADT7310_TEMPERATURE 2
28 #define ADT7310_ID 3
29 #define ADT7310_T_CRIT 4
30 #define ADT7310_T_HYST 5
31 #define ADT7310_T_ALARM_HIGH 6
32 #define ADT7310_T_ALARM_LOW 7
33 
34 /*
35  * ADT7310 status
36  */
37 #define ADT7310_STAT_T_LOW 0x10
38 #define ADT7310_STAT_T_HIGH 0x20
39 #define ADT7310_STAT_T_CRIT 0x40
40 #define ADT7310_STAT_NOT_RDY 0x80
41 
42 /*
43  * ADT7310 config
44  */
45 #define ADT7310_FAULT_QUEUE_MASK 0x3
46 #define ADT7310_CT_POLARITY 0x4
47 #define ADT7310_INT_POLARITY 0x8
48 #define ADT7310_EVENT_MODE 0x10
49 #define ADT7310_MODE_MASK 0x60
50 #define ADT7310_ONESHOT 0x20
51 #define ADT7310_SPS 0x40
52 #define ADT7310_PD 0x60
53 #define ADT7310_RESOLUTION 0x80
54 
55 /*
56  * ADT7310 masks
57  */
58 #define ADT7310_T16_VALUE_SIGN 0x8000
59 #define ADT7310_T16_VALUE_FLOAT_OFFSET 7
60 #define ADT7310_T16_VALUE_FLOAT_MASK 0x7F
61 #define ADT7310_T13_VALUE_SIGN 0x1000
62 #define ADT7310_T13_VALUE_OFFSET 3
63 #define ADT7310_T13_VALUE_FLOAT_OFFSET 4
64 #define ADT7310_T13_VALUE_FLOAT_MASK 0xF
65 #define ADT7310_T_HYST_MASK 0xF
66 #define ADT7310_DEVICE_ID_MASK 0x7
67 #define ADT7310_MANUFACTORY_ID_MASK 0xF8
68 #define ADT7310_MANUFACTORY_ID_OFFSET 3
69 
70 
71 #define ADT7310_CMD_REG_MASK 0x28
72 #define ADT7310_CMD_REG_OFFSET 3
73 #define ADT7310_CMD_READ 0x40
74 #define ADT7310_CMD_CON_READ 0x4
75 
76 #define ADT7310_IRQS 2
77 
78 /*
79  * struct adt7310_chip_info - chip specifc information
80  */
81 
82 struct adt7310_chip_info {
83  struct spi_device *spi_dev;
84  u8 config;
85 };
86 
87 /*
88  * adt7310 register access by SPI
89  */
90 
91 static int adt7310_spi_read_word(struct adt7310_chip_info *chip, u8 reg, u16 *data)
92 {
93  struct spi_device *spi_dev = chip->spi_dev;
94  u8 command = (reg << ADT7310_CMD_REG_OFFSET) & ADT7310_CMD_REG_MASK;
95  int ret = 0;
96 
97  command |= ADT7310_CMD_READ;
98  ret = spi_write(spi_dev, &command, sizeof(command));
99  if (ret < 0) {
100  dev_err(&spi_dev->dev, "SPI write command error\n");
101  return ret;
102  }
103 
104  ret = spi_read(spi_dev, (u8 *)data, sizeof(*data));
105  if (ret < 0) {
106  dev_err(&spi_dev->dev, "SPI read word error\n");
107  return ret;
108  }
109 
110  *data = be16_to_cpu(*data);
111 
112  return 0;
113 }
114 
115 static int adt7310_spi_write_word(struct adt7310_chip_info *chip, u8 reg, u16 data)
116 {
117  struct spi_device *spi_dev = chip->spi_dev;
118  u8 buf[3];
119  int ret = 0;
120 
121  buf[0] = (reg << ADT7310_CMD_REG_OFFSET) & ADT7310_CMD_REG_MASK;
122  buf[1] = (u8)(data >> 8);
123  buf[2] = (u8)(data & 0xFF);
124 
125  ret = spi_write(spi_dev, buf, 3);
126  if (ret < 0) {
127  dev_err(&spi_dev->dev, "SPI write word error\n");
128  return ret;
129  }
130 
131  return ret;
132 }
133 
134 static int adt7310_spi_read_byte(struct adt7310_chip_info *chip, u8 reg, u8 *data)
135 {
136  struct spi_device *spi_dev = chip->spi_dev;
137  u8 command = (reg << ADT7310_CMD_REG_OFFSET) & ADT7310_CMD_REG_MASK;
138  int ret = 0;
139 
140  command |= ADT7310_CMD_READ;
141  ret = spi_write(spi_dev, &command, sizeof(command));
142  if (ret < 0) {
143  dev_err(&spi_dev->dev, "SPI write command error\n");
144  return ret;
145  }
146 
147  ret = spi_read(spi_dev, data, sizeof(*data));
148  if (ret < 0) {
149  dev_err(&spi_dev->dev, "SPI read byte error\n");
150  return ret;
151  }
152 
153  return 0;
154 }
155 
156 static int adt7310_spi_write_byte(struct adt7310_chip_info *chip, u8 reg, u8 data)
157 {
158  struct spi_device *spi_dev = chip->spi_dev;
159  u8 buf[2];
160  int ret = 0;
161 
162  buf[0] = (reg << ADT7310_CMD_REG_OFFSET) & ADT7310_CMD_REG_MASK;
163  buf[1] = data;
164 
165  ret = spi_write(spi_dev, buf, 2);
166  if (ret < 0) {
167  dev_err(&spi_dev->dev, "SPI write byte error\n");
168  return ret;
169  }
170 
171  return ret;
172 }
173 
174 static ssize_t adt7310_show_mode(struct device *dev,
175  struct device_attribute *attr,
176  char *buf)
177 {
178  struct iio_dev *dev_info = dev_to_iio_dev(dev);
179  struct adt7310_chip_info *chip = iio_priv(dev_info);
180  u8 config;
181 
182  config = chip->config & ADT7310_MODE_MASK;
183 
184  switch (config) {
185  case ADT7310_PD:
186  return sprintf(buf, "power-down\n");
187  case ADT7310_ONESHOT:
188  return sprintf(buf, "one-shot\n");
189  case ADT7310_SPS:
190  return sprintf(buf, "sps\n");
191  default:
192  return sprintf(buf, "full\n");
193  }
194 }
195 
196 static ssize_t adt7310_store_mode(struct device *dev,
197  struct device_attribute *attr,
198  const char *buf,
199  size_t len)
200 {
201  struct iio_dev *dev_info = dev_to_iio_dev(dev);
202  struct adt7310_chip_info *chip = iio_priv(dev_info);
203  u16 config;
204  int ret;
205 
206  ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
207  if (ret)
208  return -EIO;
209 
210  config = chip->config & (~ADT7310_MODE_MASK);
211  if (strcmp(buf, "power-down"))
212  config |= ADT7310_PD;
213  else if (strcmp(buf, "one-shot"))
214  config |= ADT7310_ONESHOT;
215  else if (strcmp(buf, "sps"))
216  config |= ADT7310_SPS;
217 
218  ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, config);
219  if (ret)
220  return -EIO;
221 
222  chip->config = config;
223 
224  return len;
225 }
226 
227 static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
228  adt7310_show_mode,
229  adt7310_store_mode,
230  0);
231 
232 static ssize_t adt7310_show_available_modes(struct device *dev,
233  struct device_attribute *attr,
234  char *buf)
235 {
236  return sprintf(buf, "full\none-shot\nsps\npower-down\n");
237 }
238 
239 static IIO_DEVICE_ATTR(available_modes, S_IRUGO, adt7310_show_available_modes, NULL, 0);
240 
241 static ssize_t adt7310_show_resolution(struct device *dev,
242  struct device_attribute *attr,
243  char *buf)
244 {
245  struct iio_dev *dev_info = dev_to_iio_dev(dev);
246  struct adt7310_chip_info *chip = iio_priv(dev_info);
247  int ret;
248  int bits;
249 
250  ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
251  if (ret)
252  return -EIO;
253 
254  if (chip->config & ADT7310_RESOLUTION)
255  bits = 16;
256  else
257  bits = 13;
258 
259  return sprintf(buf, "%d bits\n", bits);
260 }
261 
262 static ssize_t adt7310_store_resolution(struct device *dev,
263  struct device_attribute *attr,
264  const char *buf,
265  size_t len)
266 {
267  struct iio_dev *dev_info = dev_to_iio_dev(dev);
268  struct adt7310_chip_info *chip = iio_priv(dev_info);
269  unsigned long data;
270  u16 config;
271  int ret;
272 
273  ret = strict_strtoul(buf, 10, &data);
274  if (ret)
275  return -EINVAL;
276 
277  ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
278  if (ret)
279  return -EIO;
280 
281  config = chip->config & (~ADT7310_RESOLUTION);
282  if (data)
283  config |= ADT7310_RESOLUTION;
284 
285  ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, config);
286  if (ret)
287  return -EIO;
288 
289  chip->config = config;
290 
291  return len;
292 }
293 
294 static IIO_DEVICE_ATTR(resolution, S_IRUGO | S_IWUSR,
295  adt7310_show_resolution,
296  adt7310_store_resolution,
297  0);
298 
299 static ssize_t adt7310_show_id(struct device *dev,
300  struct device_attribute *attr,
301  char *buf)
302 {
303  struct iio_dev *dev_info = dev_to_iio_dev(dev);
304  struct adt7310_chip_info *chip = iio_priv(dev_info);
305  u8 id;
306  int ret;
307 
308  ret = adt7310_spi_read_byte(chip, ADT7310_ID, &id);
309  if (ret)
310  return -EIO;
311 
312  return sprintf(buf, "device id: 0x%x\nmanufactory id: 0x%x\n",
313  id & ADT7310_DEVICE_ID_MASK,
314  (id & ADT7310_MANUFACTORY_ID_MASK) >> ADT7310_MANUFACTORY_ID_OFFSET);
315 }
316 
317 static IIO_DEVICE_ATTR(id, S_IRUGO | S_IWUSR,
318  adt7310_show_id,
319  NULL,
320  0);
321 
322 static ssize_t adt7310_convert_temperature(struct adt7310_chip_info *chip,
323  u16 data, char *buf)
324 {
325  char sign = ' ';
326 
327  if (chip->config & ADT7310_RESOLUTION) {
328  if (data & ADT7310_T16_VALUE_SIGN) {
329  /* convert supplement to positive value */
330  data = (u16)((ADT7310_T16_VALUE_SIGN << 1) - (u32)data);
331  sign = '-';
332  }
333  return sprintf(buf, "%c%d.%.7d\n", sign,
334  (data >> ADT7310_T16_VALUE_FLOAT_OFFSET),
335  (data & ADT7310_T16_VALUE_FLOAT_MASK) * 78125);
336  } else {
337  if (data & ADT7310_T13_VALUE_SIGN) {
338  /* convert supplement to positive value */
339  data >>= ADT7310_T13_VALUE_OFFSET;
340  data = (ADT7310_T13_VALUE_SIGN << 1) - data;
341  sign = '-';
342  }
343  return sprintf(buf, "%c%d.%.4d\n", sign,
344  (data >> ADT7310_T13_VALUE_FLOAT_OFFSET),
345  (data & ADT7310_T13_VALUE_FLOAT_MASK) * 625);
346  }
347 }
348 
349 static ssize_t adt7310_show_value(struct device *dev,
350  struct device_attribute *attr,
351  char *buf)
352 {
353  struct iio_dev *dev_info = dev_to_iio_dev(dev);
354  struct adt7310_chip_info *chip = iio_priv(dev_info);
355  u8 status;
356  u16 data;
357  int ret, i = 0;
358 
359  do {
360  ret = adt7310_spi_read_byte(chip, ADT7310_STATUS, &status);
361  if (ret)
362  return -EIO;
363  i++;
364  if (i == 10000)
365  return -EIO;
366  } while (status & ADT7310_STAT_NOT_RDY);
367 
368  ret = adt7310_spi_read_word(chip, ADT7310_TEMPERATURE, &data);
369  if (ret)
370  return -EIO;
371 
372  return adt7310_convert_temperature(chip, data, buf);
373 }
374 
375 static IIO_DEVICE_ATTR(value, S_IRUGO, adt7310_show_value, NULL, 0);
376 
377 static struct attribute *adt7310_attributes[] = {
378  &iio_dev_attr_available_modes.dev_attr.attr,
379  &iio_dev_attr_mode.dev_attr.attr,
380  &iio_dev_attr_resolution.dev_attr.attr,
381  &iio_dev_attr_id.dev_attr.attr,
382  &iio_dev_attr_value.dev_attr.attr,
383  NULL,
384 };
385 
386 static const struct attribute_group adt7310_attribute_group = {
387  .attrs = adt7310_attributes,
388 };
389 
390 static irqreturn_t adt7310_event_handler(int irq, void *private)
391 {
392  struct iio_dev *indio_dev = private;
393  struct adt7310_chip_info *chip = iio_priv(indio_dev);
394  s64 timestamp = iio_get_time_ns();
395  u8 status;
396  int ret;
397 
398  ret = adt7310_spi_read_byte(chip, ADT7310_STATUS, &status);
399  if (ret)
400  goto done;
401 
402  if (status & ADT7310_STAT_T_HIGH)
403  iio_push_event(indio_dev,
404  IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
405  IIO_EV_TYPE_THRESH,
406  IIO_EV_DIR_RISING),
407  timestamp);
408  if (status & ADT7310_STAT_T_LOW)
409  iio_push_event(indio_dev,
410  IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
411  IIO_EV_TYPE_THRESH,
412  IIO_EV_DIR_FALLING),
413  timestamp);
414  if (status & ADT7310_STAT_T_CRIT)
415  iio_push_event(indio_dev,
416  IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
417  IIO_EV_TYPE_THRESH,
418  IIO_EV_DIR_RISING),
419  timestamp);
420 
421 done:
422  return IRQ_HANDLED;
423 }
424 
425 static ssize_t adt7310_show_event_mode(struct device *dev,
426  struct device_attribute *attr,
427  char *buf)
428 {
429  struct iio_dev *dev_info = dev_to_iio_dev(dev);
430  struct adt7310_chip_info *chip = iio_priv(dev_info);
431  int ret;
432 
433  ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
434  if (ret)
435  return -EIO;
436 
437  if (chip->config & ADT7310_EVENT_MODE)
438  return sprintf(buf, "interrupt\n");
439  else
440  return sprintf(buf, "comparator\n");
441 }
442 
443 static ssize_t adt7310_set_event_mode(struct device *dev,
444  struct device_attribute *attr,
445  const char *buf,
446  size_t len)
447 {
448  struct iio_dev *dev_info = dev_to_iio_dev(dev);
449  struct adt7310_chip_info *chip = iio_priv(dev_info);
450  u16 config;
451  int ret;
452 
453  ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
454  if (ret)
455  return -EIO;
456 
457  config = chip->config &= ~ADT7310_EVENT_MODE;
458  if (strcmp(buf, "comparator") != 0)
459  config |= ADT7310_EVENT_MODE;
460 
461  ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, config);
462  if (ret)
463  return -EIO;
464 
465  chip->config = config;
466 
467  return len;
468 }
469 
470 static ssize_t adt7310_show_available_event_modes(struct device *dev,
471  struct device_attribute *attr,
472  char *buf)
473 {
474  return sprintf(buf, "comparator\ninterrupt\n");
475 }
476 
477 static ssize_t adt7310_show_fault_queue(struct device *dev,
478  struct device_attribute *attr,
479  char *buf)
480 {
481  struct iio_dev *dev_info = dev_to_iio_dev(dev);
482  struct adt7310_chip_info *chip = iio_priv(dev_info);
483  int ret;
484 
485  ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
486  if (ret)
487  return -EIO;
488 
489  return sprintf(buf, "%d\n", chip->config & ADT7310_FAULT_QUEUE_MASK);
490 }
491 
492 static ssize_t adt7310_set_fault_queue(struct device *dev,
493  struct device_attribute *attr,
494  const char *buf,
495  size_t len)
496 {
497  struct iio_dev *dev_info = dev_to_iio_dev(dev);
498  struct adt7310_chip_info *chip = iio_priv(dev_info);
499  unsigned long data;
500  int ret;
501  u8 config;
502 
503  ret = strict_strtoul(buf, 10, &data);
504  if (ret || data > 3)
505  return -EINVAL;
506 
507  ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
508  if (ret)
509  return -EIO;
510 
511  config = chip->config & ~ADT7310_FAULT_QUEUE_MASK;
512  config |= data;
513  ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, config);
514  if (ret)
515  return -EIO;
516 
517  chip->config = config;
518 
519  return len;
520 }
521 
522 static inline ssize_t adt7310_show_t_bound(struct device *dev,
523  struct device_attribute *attr,
524  u8 bound_reg,
525  char *buf)
526 {
527  struct iio_dev *dev_info = dev_to_iio_dev(dev);
528  struct adt7310_chip_info *chip = iio_priv(dev_info);
529  u16 data;
530  int ret;
531 
532  ret = adt7310_spi_read_word(chip, bound_reg, &data);
533  if (ret)
534  return -EIO;
535 
536  return adt7310_convert_temperature(chip, data, buf);
537 }
538 
539 static inline ssize_t adt7310_set_t_bound(struct device *dev,
540  struct device_attribute *attr,
541  u8 bound_reg,
542  const char *buf,
543  size_t len)
544 {
545  struct iio_dev *dev_info = dev_to_iio_dev(dev);
546  struct adt7310_chip_info *chip = iio_priv(dev_info);
547  long tmp1, tmp2;
548  u16 data;
549  char *pos;
550  int ret;
551 
552  pos = strchr(buf, '.');
553 
554  ret = strict_strtol(buf, 10, &tmp1);
555 
556  if (ret || tmp1 > 127 || tmp1 < -128)
557  return -EINVAL;
558 
559  if (pos) {
560  len = strlen(pos);
561 
562  if (chip->config & ADT7310_RESOLUTION) {
563  if (len > ADT7310_T16_VALUE_FLOAT_OFFSET)
564  len = ADT7310_T16_VALUE_FLOAT_OFFSET;
565  pos[len] = 0;
566  ret = strict_strtol(pos, 10, &tmp2);
567 
568  if (!ret)
569  tmp2 = (tmp2 / 78125) * 78125;
570  } else {
571  if (len > ADT7310_T13_VALUE_FLOAT_OFFSET)
572  len = ADT7310_T13_VALUE_FLOAT_OFFSET;
573  pos[len] = 0;
574  ret = strict_strtol(pos, 10, &tmp2);
575 
576  if (!ret)
577  tmp2 = (tmp2 / 625) * 625;
578  }
579  }
580 
581  if (tmp1 < 0)
582  data = (u16)(-tmp1);
583  else
584  data = (u16)tmp1;
585 
586  if (chip->config & ADT7310_RESOLUTION) {
587  data = (data << ADT7310_T16_VALUE_FLOAT_OFFSET) |
588  (tmp2 & ADT7310_T16_VALUE_FLOAT_MASK);
589 
590  if (tmp1 < 0)
591  /* convert positive value to supplyment */
592  data = (u16)((ADT7310_T16_VALUE_SIGN << 1) - (u32)data);
593  } else {
594  data = (data << ADT7310_T13_VALUE_FLOAT_OFFSET) |
595  (tmp2 & ADT7310_T13_VALUE_FLOAT_MASK);
596 
597  if (tmp1 < 0)
598  /* convert positive value to supplyment */
599  data = (ADT7310_T13_VALUE_SIGN << 1) - data;
600  data <<= ADT7310_T13_VALUE_OFFSET;
601  }
602 
603  ret = adt7310_spi_write_word(chip, bound_reg, data);
604  if (ret)
605  return -EIO;
606 
607  return len;
608 }
609 
610 static ssize_t adt7310_show_t_alarm_high(struct device *dev,
611  struct device_attribute *attr,
612  char *buf)
613 {
614  return adt7310_show_t_bound(dev, attr,
615  ADT7310_T_ALARM_HIGH, buf);
616 }
617 
618 static inline ssize_t adt7310_set_t_alarm_high(struct device *dev,
619  struct device_attribute *attr,
620  const char *buf,
621  size_t len)
622 {
623  return adt7310_set_t_bound(dev, attr,
624  ADT7310_T_ALARM_HIGH, buf, len);
625 }
626 
627 static ssize_t adt7310_show_t_alarm_low(struct device *dev,
628  struct device_attribute *attr,
629  char *buf)
630 {
631  return adt7310_show_t_bound(dev, attr,
632  ADT7310_T_ALARM_LOW, buf);
633 }
634 
635 static inline ssize_t adt7310_set_t_alarm_low(struct device *dev,
636  struct device_attribute *attr,
637  const char *buf,
638  size_t len)
639 {
640  return adt7310_set_t_bound(dev, attr,
641  ADT7310_T_ALARM_LOW, buf, len);
642 }
643 
644 static ssize_t adt7310_show_t_crit(struct device *dev,
645  struct device_attribute *attr,
646  char *buf)
647 {
648  return adt7310_show_t_bound(dev, attr,
649  ADT7310_T_CRIT, buf);
650 }
651 
652 static inline ssize_t adt7310_set_t_crit(struct device *dev,
653  struct device_attribute *attr,
654  const char *buf,
655  size_t len)
656 {
657  return adt7310_set_t_bound(dev, attr,
658  ADT7310_T_CRIT, buf, len);
659 }
660 
661 static ssize_t adt7310_show_t_hyst(struct device *dev,
662  struct device_attribute *attr,
663  char *buf)
664 {
665  struct iio_dev *dev_info = dev_to_iio_dev(dev);
666  struct adt7310_chip_info *chip = iio_priv(dev_info);
667  int ret;
668  u8 t_hyst;
669 
670  ret = adt7310_spi_read_byte(chip, ADT7310_T_HYST, &t_hyst);
671  if (ret)
672  return -EIO;
673 
674  return sprintf(buf, "%d\n", t_hyst & ADT7310_T_HYST_MASK);
675 }
676 
677 static inline ssize_t adt7310_set_t_hyst(struct device *dev,
678  struct device_attribute *attr,
679  const char *buf,
680  size_t len)
681 {
682  struct iio_dev *dev_info = dev_to_iio_dev(dev);
683  struct adt7310_chip_info *chip = iio_priv(dev_info);
684  int ret;
685  unsigned long data;
686  u8 t_hyst;
687 
688  ret = strict_strtol(buf, 10, &data);
689 
690  if (ret || data > ADT7310_T_HYST_MASK)
691  return -EINVAL;
692 
693  t_hyst = (u8)data;
694 
695  ret = adt7310_spi_write_byte(chip, ADT7310_T_HYST, t_hyst);
696  if (ret)
697  return -EIO;
698 
699  return len;
700 }
701 
702 static IIO_DEVICE_ATTR(event_mode,
703  S_IRUGO | S_IWUSR,
704  adt7310_show_event_mode, adt7310_set_event_mode, 0);
705 static IIO_DEVICE_ATTR(available_event_modes,
706  S_IRUGO | S_IWUSR,
707  adt7310_show_available_event_modes, NULL, 0);
708 static IIO_DEVICE_ATTR(fault_queue,
709  S_IRUGO | S_IWUSR,
710  adt7310_show_fault_queue, adt7310_set_fault_queue, 0);
711 static IIO_DEVICE_ATTR(t_alarm_high,
712  S_IRUGO | S_IWUSR,
713  adt7310_show_t_alarm_high, adt7310_set_t_alarm_high, 0);
714 static IIO_DEVICE_ATTR(t_alarm_low,
715  S_IRUGO | S_IWUSR,
716  adt7310_show_t_alarm_low, adt7310_set_t_alarm_low, 0);
717 static IIO_DEVICE_ATTR(t_crit,
718  S_IRUGO | S_IWUSR,
719  adt7310_show_t_crit, adt7310_set_t_crit, 0);
720 static IIO_DEVICE_ATTR(t_hyst,
721  S_IRUGO | S_IWUSR,
722  adt7310_show_t_hyst, adt7310_set_t_hyst, 0);
723 
724 static struct attribute *adt7310_event_int_attributes[] = {
725  &iio_dev_attr_event_mode.dev_attr.attr,
726  &iio_dev_attr_available_event_modes.dev_attr.attr,
727  &iio_dev_attr_fault_queue.dev_attr.attr,
728  &iio_dev_attr_t_alarm_high.dev_attr.attr,
729  &iio_dev_attr_t_alarm_low.dev_attr.attr,
730  &iio_dev_attr_t_crit.dev_attr.attr,
731  &iio_dev_attr_t_hyst.dev_attr.attr,
732  NULL,
733 };
734 
735 static struct attribute_group adt7310_event_attribute_group = {
736  .attrs = adt7310_event_int_attributes,
737  .name = "events",
738 };
739 
740 static const struct iio_info adt7310_info = {
741  .attrs = &adt7310_attribute_group,
742  .event_attrs = &adt7310_event_attribute_group,
743  .driver_module = THIS_MODULE,
744 };
745 
746 /*
747  * device probe and remove
748  */
749 
750 static int __devinit adt7310_probe(struct spi_device *spi_dev)
751 {
752  struct adt7310_chip_info *chip;
753  struct iio_dev *indio_dev;
754  int ret = 0;
755  unsigned long *adt7310_platform_data = spi_dev->dev.platform_data;
756  unsigned long irq_flags;
757 
758  indio_dev = iio_device_alloc(sizeof(*chip));
759  if (indio_dev == NULL) {
760  ret = -ENOMEM;
761  goto error_ret;
762  }
763  chip = iio_priv(indio_dev);
764  /* this is only used for device removal purposes */
765  dev_set_drvdata(&spi_dev->dev, indio_dev);
766 
767  chip->spi_dev = spi_dev;
768 
769  indio_dev->dev.parent = &spi_dev->dev;
770  indio_dev->name = spi_get_device_id(spi_dev)->name;
771  indio_dev->info = &adt7310_info;
772  indio_dev->modes = INDIO_DIRECT_MODE;
773 
774  /* CT critcal temperature event. line 0 */
775  if (spi_dev->irq) {
776  if (adt7310_platform_data[2])
777  irq_flags = adt7310_platform_data[2];
778  else
779  irq_flags = IRQF_TRIGGER_LOW;
780  ret = request_threaded_irq(spi_dev->irq,
781  NULL,
782  &adt7310_event_handler,
783  irq_flags | IRQF_ONESHOT,
784  indio_dev->name,
785  indio_dev);
786  if (ret)
787  goto error_free_dev;
788  }
789 
790  /* INT bound temperature alarm event. line 1 */
791  if (adt7310_platform_data[0]) {
792  ret = request_threaded_irq(adt7310_platform_data[0],
793  NULL,
794  &adt7310_event_handler,
795  adt7310_platform_data[1] |
796  IRQF_ONESHOT,
797  indio_dev->name,
798  indio_dev);
799  if (ret)
800  goto error_unreg_ct_irq;
801  }
802 
803  if (spi_dev->irq && adt7310_platform_data[0]) {
804  ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
805  if (ret) {
806  ret = -EIO;
807  goto error_unreg_int_irq;
808  }
809 
810  /* set irq polarity low level */
811  chip->config &= ~ADT7310_CT_POLARITY;
812 
813  if (adt7310_platform_data[1] & IRQF_TRIGGER_HIGH)
814  chip->config |= ADT7310_INT_POLARITY;
815  else
816  chip->config &= ~ADT7310_INT_POLARITY;
817 
818  ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, chip->config);
819  if (ret) {
820  ret = -EIO;
821  goto error_unreg_int_irq;
822  }
823  }
824 
825  ret = iio_device_register(indio_dev);
826  if (ret)
827  goto error_unreg_int_irq;
828 
829  dev_info(&spi_dev->dev, "%s temperature sensor registered.\n",
830  indio_dev->name);
831 
832  return 0;
833 
834 error_unreg_int_irq:
835  free_irq(adt7310_platform_data[0], indio_dev);
836 error_unreg_ct_irq:
837  free_irq(spi_dev->irq, indio_dev);
838 error_free_dev:
839  iio_device_free(indio_dev);
840 error_ret:
841  return ret;
842 }
843 
844 static int __devexit adt7310_remove(struct spi_device *spi_dev)
845 {
846  struct iio_dev *indio_dev = dev_get_drvdata(&spi_dev->dev);
847  unsigned long *adt7310_platform_data = spi_dev->dev.platform_data;
848 
849  iio_device_unregister(indio_dev);
850  dev_set_drvdata(&spi_dev->dev, NULL);
851  if (adt7310_platform_data[0])
852  free_irq(adt7310_platform_data[0], indio_dev);
853  if (spi_dev->irq)
854  free_irq(spi_dev->irq, indio_dev);
855  iio_device_free(indio_dev);
856 
857  return 0;
858 }
859 
860 static const struct spi_device_id adt7310_id[] = {
861  { "adt7310", 0 },
862  {}
863 };
864 
865 MODULE_DEVICE_TABLE(spi, adt7310_id);
866 
867 static struct spi_driver adt7310_driver = {
868  .driver = {
869  .name = "adt7310",
870  .owner = THIS_MODULE,
871  },
872  .probe = adt7310_probe,
873  .remove = __devexit_p(adt7310_remove),
874  .id_table = adt7310_id,
875 };
876 module_spi_driver(adt7310_driver);
877 
878 MODULE_AUTHOR("Sonic Zhang <[email protected]>");
879 MODULE_DESCRIPTION("Analog Devices ADT7310 digital"
880  " temperature sensor driver");
881 MODULE_LICENSE("GPL v2");
Generated on Thu Jan 10 2013 14:28:37 for Linux Kernel by   doxygen 1.8.2