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 "../iio.h"
19 #include "../sysfs.h"
20 #include "../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
adt7310_spi_read_word(struct adt7310_chip_info * chip,u8 reg,u16 * data)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
adt7310_spi_write_word(struct adt7310_chip_info * chip,u8 reg,u16 data)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
adt7310_spi_read_byte(struct adt7310_chip_info * chip,u8 reg,u8 * data)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
adt7310_spi_write_byte(struct adt7310_chip_info * chip,u8 reg,u8 data)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
adt7310_show_mode(struct device * dev,struct device_attribute * attr,char * buf)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_get_drvdata(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
adt7310_store_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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_get_drvdata(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
adt7310_show_available_modes(struct device * dev,struct device_attribute * attr,char * buf)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
adt7310_show_resolution(struct device * dev,struct device_attribute * attr,char * buf)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_get_drvdata(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
adt7310_store_resolution(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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_get_drvdata(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
adt7310_show_id(struct device * dev,struct device_attribute * attr,char * buf)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_get_drvdata(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
adt7310_convert_temperature(struct adt7310_chip_info * chip,u16 data,char * buf)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
adt7310_show_value(struct device * dev,struct device_attribute * attr,char * buf)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_get_drvdata(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
adt7310_event_handler(int irq,void * private)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 return ret;
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 return IRQ_HANDLED;
421 }
422
adt7310_show_event_mode(struct device * dev,struct device_attribute * attr,char * buf)423 static ssize_t adt7310_show_event_mode(struct device *dev,
424 struct device_attribute *attr,
425 char *buf)
426 {
427 struct iio_dev *dev_info = dev_get_drvdata(dev);
428 struct adt7310_chip_info *chip = iio_priv(dev_info);
429 int ret;
430
431 ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
432 if (ret)
433 return -EIO;
434
435 if (chip->config & ADT7310_EVENT_MODE)
436 return sprintf(buf, "interrupt\n");
437 else
438 return sprintf(buf, "comparator\n");
439 }
440
adt7310_set_event_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)441 static ssize_t adt7310_set_event_mode(struct device *dev,
442 struct device_attribute *attr,
443 const char *buf,
444 size_t len)
445 {
446 struct iio_dev *dev_info = dev_get_drvdata(dev);
447 struct adt7310_chip_info *chip = iio_priv(dev_info);
448 u16 config;
449 int ret;
450
451 ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
452 if (ret)
453 return -EIO;
454
455 config = chip->config &= ~ADT7310_EVENT_MODE;
456 if (strcmp(buf, "comparator") != 0)
457 config |= ADT7310_EVENT_MODE;
458
459 ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, config);
460 if (ret)
461 return -EIO;
462
463 chip->config = config;
464
465 return len;
466 }
467
adt7310_show_available_event_modes(struct device * dev,struct device_attribute * attr,char * buf)468 static ssize_t adt7310_show_available_event_modes(struct device *dev,
469 struct device_attribute *attr,
470 char *buf)
471 {
472 return sprintf(buf, "comparator\ninterrupt\n");
473 }
474
adt7310_show_fault_queue(struct device * dev,struct device_attribute * attr,char * buf)475 static ssize_t adt7310_show_fault_queue(struct device *dev,
476 struct device_attribute *attr,
477 char *buf)
478 {
479 struct iio_dev *dev_info = dev_get_drvdata(dev);
480 struct adt7310_chip_info *chip = iio_priv(dev_info);
481 int ret;
482
483 ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
484 if (ret)
485 return -EIO;
486
487 return sprintf(buf, "%d\n", chip->config & ADT7310_FAULT_QUEUE_MASK);
488 }
489
adt7310_set_fault_queue(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)490 static ssize_t adt7310_set_fault_queue(struct device *dev,
491 struct device_attribute *attr,
492 const char *buf,
493 size_t len)
494 {
495 struct iio_dev *dev_info = dev_get_drvdata(dev);
496 struct adt7310_chip_info *chip = iio_priv(dev_info);
497 unsigned long data;
498 int ret;
499 u8 config;
500
501 ret = strict_strtoul(buf, 10, &data);
502 if (ret || data > 3)
503 return -EINVAL;
504
505 ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
506 if (ret)
507 return -EIO;
508
509 config = chip->config & ~ADT7310_FAULT_QUEUE_MASK;
510 config |= data;
511 ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, config);
512 if (ret)
513 return -EIO;
514
515 chip->config = config;
516
517 return len;
518 }
519
adt7310_show_t_bound(struct device * dev,struct device_attribute * attr,u8 bound_reg,char * buf)520 static inline ssize_t adt7310_show_t_bound(struct device *dev,
521 struct device_attribute *attr,
522 u8 bound_reg,
523 char *buf)
524 {
525 struct iio_dev *dev_info = dev_get_drvdata(dev);
526 struct adt7310_chip_info *chip = iio_priv(dev_info);
527 u16 data;
528 int ret;
529
530 ret = adt7310_spi_read_word(chip, bound_reg, &data);
531 if (ret)
532 return -EIO;
533
534 return adt7310_convert_temperature(chip, data, buf);
535 }
536
adt7310_set_t_bound(struct device * dev,struct device_attribute * attr,u8 bound_reg,const char * buf,size_t len)537 static inline ssize_t adt7310_set_t_bound(struct device *dev,
538 struct device_attribute *attr,
539 u8 bound_reg,
540 const char *buf,
541 size_t len)
542 {
543 struct iio_dev *dev_info = dev_get_drvdata(dev);
544 struct adt7310_chip_info *chip = iio_priv(dev_info);
545 long tmp1, tmp2;
546 u16 data;
547 char *pos;
548 int ret;
549
550 pos = strchr(buf, '.');
551
552 ret = strict_strtol(buf, 10, &tmp1);
553
554 if (ret || tmp1 > 127 || tmp1 < -128)
555 return -EINVAL;
556
557 if (pos) {
558 len = strlen(pos);
559
560 if (chip->config & ADT7310_RESOLUTION) {
561 if (len > ADT7310_T16_VALUE_FLOAT_OFFSET)
562 len = ADT7310_T16_VALUE_FLOAT_OFFSET;
563 pos[len] = 0;
564 ret = strict_strtol(pos, 10, &tmp2);
565
566 if (!ret)
567 tmp2 = (tmp2 / 78125) * 78125;
568 } else {
569 if (len > ADT7310_T13_VALUE_FLOAT_OFFSET)
570 len = ADT7310_T13_VALUE_FLOAT_OFFSET;
571 pos[len] = 0;
572 ret = strict_strtol(pos, 10, &tmp2);
573
574 if (!ret)
575 tmp2 = (tmp2 / 625) * 625;
576 }
577 }
578
579 if (tmp1 < 0)
580 data = (u16)(-tmp1);
581 else
582 data = (u16)tmp1;
583
584 if (chip->config & ADT7310_RESOLUTION) {
585 data = (data << ADT7310_T16_VALUE_FLOAT_OFFSET) |
586 (tmp2 & ADT7310_T16_VALUE_FLOAT_MASK);
587
588 if (tmp1 < 0)
589 /* convert positive value to supplyment */
590 data = (u16)((ADT7310_T16_VALUE_SIGN << 1) - (u32)data);
591 } else {
592 data = (data << ADT7310_T13_VALUE_FLOAT_OFFSET) |
593 (tmp2 & ADT7310_T13_VALUE_FLOAT_MASK);
594
595 if (tmp1 < 0)
596 /* convert positive value to supplyment */
597 data = (ADT7310_T13_VALUE_SIGN << 1) - data;
598 data <<= ADT7310_T13_VALUE_OFFSET;
599 }
600
601 ret = adt7310_spi_write_word(chip, bound_reg, data);
602 if (ret)
603 return -EIO;
604
605 return len;
606 }
607
adt7310_show_t_alarm_high(struct device * dev,struct device_attribute * attr,char * buf)608 static ssize_t adt7310_show_t_alarm_high(struct device *dev,
609 struct device_attribute *attr,
610 char *buf)
611 {
612 return adt7310_show_t_bound(dev, attr,
613 ADT7310_T_ALARM_HIGH, buf);
614 }
615
adt7310_set_t_alarm_high(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)616 static inline ssize_t adt7310_set_t_alarm_high(struct device *dev,
617 struct device_attribute *attr,
618 const char *buf,
619 size_t len)
620 {
621 return adt7310_set_t_bound(dev, attr,
622 ADT7310_T_ALARM_HIGH, buf, len);
623 }
624
adt7310_show_t_alarm_low(struct device * dev,struct device_attribute * attr,char * buf)625 static ssize_t adt7310_show_t_alarm_low(struct device *dev,
626 struct device_attribute *attr,
627 char *buf)
628 {
629 return adt7310_show_t_bound(dev, attr,
630 ADT7310_T_ALARM_LOW, buf);
631 }
632
adt7310_set_t_alarm_low(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)633 static inline ssize_t adt7310_set_t_alarm_low(struct device *dev,
634 struct device_attribute *attr,
635 const char *buf,
636 size_t len)
637 {
638 return adt7310_set_t_bound(dev, attr,
639 ADT7310_T_ALARM_LOW, buf, len);
640 }
641
adt7310_show_t_crit(struct device * dev,struct device_attribute * attr,char * buf)642 static ssize_t adt7310_show_t_crit(struct device *dev,
643 struct device_attribute *attr,
644 char *buf)
645 {
646 return adt7310_show_t_bound(dev, attr,
647 ADT7310_T_CRIT, buf);
648 }
649
adt7310_set_t_crit(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)650 static inline ssize_t adt7310_set_t_crit(struct device *dev,
651 struct device_attribute *attr,
652 const char *buf,
653 size_t len)
654 {
655 return adt7310_set_t_bound(dev, attr,
656 ADT7310_T_CRIT, buf, len);
657 }
658
adt7310_show_t_hyst(struct device * dev,struct device_attribute * attr,char * buf)659 static ssize_t adt7310_show_t_hyst(struct device *dev,
660 struct device_attribute *attr,
661 char *buf)
662 {
663 struct iio_dev *dev_info = dev_get_drvdata(dev);
664 struct adt7310_chip_info *chip = iio_priv(dev_info);
665 int ret;
666 u8 t_hyst;
667
668 ret = adt7310_spi_read_byte(chip, ADT7310_T_HYST, &t_hyst);
669 if (ret)
670 return -EIO;
671
672 return sprintf(buf, "%d\n", t_hyst & ADT7310_T_HYST_MASK);
673 }
674
adt7310_set_t_hyst(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)675 static inline ssize_t adt7310_set_t_hyst(struct device *dev,
676 struct device_attribute *attr,
677 const char *buf,
678 size_t len)
679 {
680 struct iio_dev *dev_info = dev_get_drvdata(dev);
681 struct adt7310_chip_info *chip = iio_priv(dev_info);
682 int ret;
683 unsigned long data;
684 u8 t_hyst;
685
686 ret = strict_strtol(buf, 10, &data);
687
688 if (ret || data > ADT7310_T_HYST_MASK)
689 return -EINVAL;
690
691 t_hyst = (u8)data;
692
693 ret = adt7310_spi_write_byte(chip, ADT7310_T_HYST, t_hyst);
694 if (ret)
695 return -EIO;
696
697 return len;
698 }
699
700 static IIO_DEVICE_ATTR(event_mode,
701 S_IRUGO | S_IWUSR,
702 adt7310_show_event_mode, adt7310_set_event_mode, 0);
703 static IIO_DEVICE_ATTR(available_event_modes,
704 S_IRUGO | S_IWUSR,
705 adt7310_show_available_event_modes, NULL, 0);
706 static IIO_DEVICE_ATTR(fault_queue,
707 S_IRUGO | S_IWUSR,
708 adt7310_show_fault_queue, adt7310_set_fault_queue, 0);
709 static IIO_DEVICE_ATTR(t_alarm_high,
710 S_IRUGO | S_IWUSR,
711 adt7310_show_t_alarm_high, adt7310_set_t_alarm_high, 0);
712 static IIO_DEVICE_ATTR(t_alarm_low,
713 S_IRUGO | S_IWUSR,
714 adt7310_show_t_alarm_low, adt7310_set_t_alarm_low, 0);
715 static IIO_DEVICE_ATTR(t_crit,
716 S_IRUGO | S_IWUSR,
717 adt7310_show_t_crit, adt7310_set_t_crit, 0);
718 static IIO_DEVICE_ATTR(t_hyst,
719 S_IRUGO | S_IWUSR,
720 adt7310_show_t_hyst, adt7310_set_t_hyst, 0);
721
722 static struct attribute *adt7310_event_int_attributes[] = {
723 &iio_dev_attr_event_mode.dev_attr.attr,
724 &iio_dev_attr_available_event_modes.dev_attr.attr,
725 &iio_dev_attr_fault_queue.dev_attr.attr,
726 &iio_dev_attr_t_alarm_high.dev_attr.attr,
727 &iio_dev_attr_t_alarm_low.dev_attr.attr,
728 &iio_dev_attr_t_hyst.dev_attr.attr,
729 NULL,
730 };
731
732 static struct attribute *adt7310_event_ct_attributes[] = {
733 &iio_dev_attr_event_mode.dev_attr.attr,
734 &iio_dev_attr_available_event_modes.dev_attr.attr,
735 &iio_dev_attr_fault_queue.dev_attr.attr,
736 &iio_dev_attr_t_crit.dev_attr.attr,
737 &iio_dev_attr_t_hyst.dev_attr.attr,
738 NULL,
739 };
740
741 static struct attribute_group adt7310_event_attribute_group[ADT7310_IRQS] = {
742 {
743 .attrs = adt7310_event_int_attributes,
744 .name = "events",
745 }, {
746 .attrs = adt7310_event_ct_attributes,
747 .name = "events",
748 }
749 };
750
751 static const struct iio_info adt7310_info = {
752 .attrs = &adt7310_attribute_group,
753 .event_attrs = adt7310_event_attribute_group,
754 .driver_module = THIS_MODULE,
755 };
756
757 /*
758 * device probe and remove
759 */
760
adt7310_probe(struct spi_device * spi_dev)761 static int __devinit adt7310_probe(struct spi_device *spi_dev)
762 {
763 struct adt7310_chip_info *chip;
764 struct iio_dev *indio_dev;
765 int ret = 0;
766 unsigned long *adt7310_platform_data = spi_dev->dev.platform_data;
767 unsigned long irq_flags;
768
769 indio_dev = iio_allocate_device(sizeof(*chip));
770 if (indio_dev == NULL) {
771 ret = -ENOMEM;
772 goto error_ret;
773 }
774 chip = iio_priv(indio_dev);
775 /* this is only used for device removal purposes */
776 dev_set_drvdata(&spi_dev->dev, indio_dev);
777
778 chip->spi_dev = spi_dev;
779
780 indio_dev->dev.parent = &spi_dev->dev;
781 indio_dev->name = spi_get_device_id(spi_dev)->name;
782 indio_dev->info = &adt7310_info;
783 indio_dev->modes = INDIO_DIRECT_MODE;
784
785 /* CT critcal temperature event. line 0 */
786 if (spi_dev->irq) {
787 if (adt7310_platform_data[2])
788 irq_flags = adt7310_platform_data[2];
789 else
790 irq_flags = IRQF_TRIGGER_LOW;
791 ret = request_threaded_irq(spi_dev->irq,
792 NULL,
793 &adt7310_event_handler,
794 irq_flags,
795 indio_dev->name,
796 indio_dev);
797 if (ret)
798 goto error_free_dev;
799 }
800
801 /* INT bound temperature alarm event. line 1 */
802 if (adt7310_platform_data[0]) {
803 ret = request_threaded_irq(adt7310_platform_data[0],
804 NULL,
805 &adt7310_event_handler,
806 adt7310_platform_data[1],
807 indio_dev->name,
808 indio_dev);
809 if (ret)
810 goto error_unreg_ct_irq;
811 }
812
813 if (spi_dev->irq && adt7310_platform_data[0]) {
814 ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
815 if (ret) {
816 ret = -EIO;
817 goto error_unreg_int_irq;
818 }
819
820 /* set irq polarity low level */
821 chip->config &= ~ADT7310_CT_POLARITY;
822
823 if (adt7310_platform_data[1] & IRQF_TRIGGER_HIGH)
824 chip->config |= ADT7310_INT_POLARITY;
825 else
826 chip->config &= ~ADT7310_INT_POLARITY;
827
828 ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, chip->config);
829 if (ret) {
830 ret = -EIO;
831 goto error_unreg_int_irq;
832 }
833 }
834
835 ret = iio_device_register(indio_dev);
836 if (ret)
837 goto error_unreg_int_irq;
838
839 dev_info(&spi_dev->dev, "%s temperature sensor registered.\n",
840 indio_dev->name);
841
842 return 0;
843
844 error_unreg_int_irq:
845 free_irq(adt7310_platform_data[0], indio_dev);
846 error_unreg_ct_irq:
847 free_irq(spi_dev->irq, indio_dev);
848 error_free_dev:
849 iio_free_device(indio_dev);
850 error_ret:
851 return ret;
852 }
853
adt7310_remove(struct spi_device * spi_dev)854 static int __devexit adt7310_remove(struct spi_device *spi_dev)
855 {
856 struct iio_dev *indio_dev = dev_get_drvdata(&spi_dev->dev);
857 unsigned long *adt7310_platform_data = spi_dev->dev.platform_data;
858
859 iio_device_unregister(indio_dev);
860 dev_set_drvdata(&spi_dev->dev, NULL);
861 if (adt7310_platform_data[0])
862 free_irq(adt7310_platform_data[0], indio_dev);
863 if (spi_dev->irq)
864 free_irq(spi_dev->irq, indio_dev);
865 iio_free_device(indio_dev);
866
867 return 0;
868 }
869
870 static const struct spi_device_id adt7310_id[] = {
871 { "adt7310", 0 },
872 {}
873 };
874
875 MODULE_DEVICE_TABLE(spi, adt7310_id);
876
877 static struct spi_driver adt7310_driver = {
878 .driver = {
879 .name = "adt7310",
880 .owner = THIS_MODULE,
881 },
882 .probe = adt7310_probe,
883 .remove = __devexit_p(adt7310_remove),
884 .id_table = adt7310_id,
885 };
886 module_spi_driver(adt7310_driver);
887
888 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
889 MODULE_DESCRIPTION("Analog Devices ADT7310 digital"
890 " temperature sensor driver");
891 MODULE_LICENSE("GPL v2");
892