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