2 * ADT7316 digital temperature sensor driver supporting ADT7316/7/8 ADT7516/7/9
5 * Copyright 2010 Analog Devices Inc.
7 * Licensed under the GPL-2 or later.
10 #include <linux/interrupt.h>
11 #include <linux/gpio.h>
12 #include <linux/workqueue.h>
13 #include <linux/device.h>
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/sysfs.h>
17 #include <linux/list.h>
18 #include <linux/i2c.h>
19 #include <linux/rtc.h>
20 #include <linux/module.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/events.h>
24 #include <linux/iio/sysfs.h>
28 * ADT7316 registers definition
30 #define ADT7316_INT_STAT1 0x0
31 #define ADT7316_INT_STAT2 0x1
32 #define ADT7316_LSB_IN_TEMP_VDD 0x3
33 #define ADT7316_LSB_IN_TEMP_MASK 0x3
34 #define ADT7316_LSB_VDD_MASK 0xC
35 #define ADT7316_LSB_VDD_OFFSET 2
36 #define ADT7316_LSB_EX_TEMP_AIN 0x4
37 #define ADT7316_LSB_EX_TEMP_MASK 0x3
38 #define ADT7516_LSB_AIN_SHIFT 2
39 #define ADT7316_AD_MSB_DATA_BASE 0x6
40 #define ADT7316_AD_MSB_DATA_REGS 3
41 #define ADT7516_AD_MSB_DATA_REGS 6
42 #define ADT7316_MSB_VDD 0x6
43 #define ADT7316_MSB_IN_TEMP 0x7
44 #define ADT7316_MSB_EX_TEMP 0x8
45 #define ADT7516_MSB_AIN1 0x8
46 #define ADT7516_MSB_AIN2 0x9
47 #define ADT7516_MSB_AIN3 0xA
48 #define ADT7516_MSB_AIN4 0xB
49 #define ADT7316_DA_DATA_BASE 0x10
50 #define ADT7316_DA_10_BIT_LSB_SHIFT 6
51 #define ADT7316_DA_12_BIT_LSB_SHIFT 4
52 #define ADT7316_DA_MSB_DATA_REGS 4
53 #define ADT7316_LSB_DAC_A 0x10
54 #define ADT7316_MSB_DAC_A 0x11
55 #define ADT7316_LSB_DAC_B 0x12
56 #define ADT7316_MSB_DAC_B 0x13
57 #define ADT7316_LSB_DAC_C 0x14
58 #define ADT7316_MSB_DAC_C 0x15
59 #define ADT7316_LSB_DAC_D 0x16
60 #define ADT7316_MSB_DAC_D 0x17
61 #define ADT7316_CONFIG1 0x18
62 #define ADT7316_CONFIG2 0x19
63 #define ADT7316_CONFIG3 0x1A
64 #define ADT7316_LDAC_CONFIG 0x1B
65 #define ADT7316_DAC_CONFIG 0x1C
66 #define ADT7316_INT_MASK1 0x1D
67 #define ADT7316_INT_MASK2 0x1E
68 #define ADT7316_IN_TEMP_OFFSET 0x1F
69 #define ADT7316_EX_TEMP_OFFSET 0x20
70 #define ADT7316_IN_ANALOG_TEMP_OFFSET 0x21
71 #define ADT7316_EX_ANALOG_TEMP_OFFSET 0x22
72 #define ADT7316_VDD_HIGH 0x23
73 #define ADT7316_VDD_LOW 0x24
74 #define ADT7316_IN_TEMP_HIGH 0x25
75 #define ADT7316_IN_TEMP_LOW 0x26
76 #define ADT7316_EX_TEMP_HIGH 0x27
77 #define ADT7316_EX_TEMP_LOW 0x28
78 #define ADT7516_AIN2_HIGH 0x2B
79 #define ADT7516_AIN2_LOW 0x2C
80 #define ADT7516_AIN3_HIGH 0x2D
81 #define ADT7516_AIN3_LOW 0x2E
82 #define ADT7516_AIN4_HIGH 0x2F
83 #define ADT7516_AIN4_LOW 0x30
84 #define ADT7316_DEVICE_ID 0x4D
85 #define ADT7316_MANUFACTURE_ID 0x4E
86 #define ADT7316_DEVICE_REV 0x4F
87 #define ADT7316_SPI_LOCK_STAT 0x7F
92 #define ADT7316_EN 0x1
93 #define ADT7516_SEL_EX_TEMP 0x4
94 #define ADT7516_SEL_AIN1_2_EX_TEMP_MASK 0x6
95 #define ADT7516_SEL_AIN3 0x8
96 #define ADT7316_INT_EN 0x20
97 #define ADT7316_INT_POLARITY 0x40
98 #define ADT7316_PD 0x80
103 #define ADT7316_AD_SINGLE_CH_MASK 0x3
104 #define ADT7516_AD_SINGLE_CH_MASK 0x7
105 #define ADT7316_AD_SINGLE_CH_VDD 0
106 #define ADT7316_AD_SINGLE_CH_IN 1
107 #define ADT7316_AD_SINGLE_CH_EX 2
108 #define ADT7516_AD_SINGLE_CH_AIN1 2
109 #define ADT7516_AD_SINGLE_CH_AIN2 3
110 #define ADT7516_AD_SINGLE_CH_AIN3 4
111 #define ADT7516_AD_SINGLE_CH_AIN4 5
112 #define ADT7316_AD_SINGLE_CH_MODE 0x10
113 #define ADT7316_DISABLE_AVERAGING 0x20
114 #define ADT7316_EN_SMBUS_TIMEOUT 0x40
115 #define ADT7316_RESET 0x80
120 #define ADT7316_ADCLK_22_5 0x1
121 #define ADT7316_DA_HIGH_RESOLUTION 0x2
122 #define ADT7316_DA_EN_VIA_DAC_LDCA 0x4
123 #define ADT7516_AIN_IN_VREF 0x10
124 #define ADT7316_EN_IN_TEMP_PROP_DACA 0x20
125 #define ADT7316_EN_EX_TEMP_PROP_DACB 0x40
130 #define ADT7316_DA_2VREF_CH_MASK 0xF
131 #define ADT7316_DA_EN_MODE_MASK 0x30
132 #define ADT7316_DA_EN_MODE_SINGLE 0x00
133 #define ADT7316_DA_EN_MODE_AB_CD 0x10
134 #define ADT7316_DA_EN_MODE_ABCD 0x20
135 #define ADT7316_DA_EN_MODE_LDAC 0x30
136 #define ADT7316_VREF_BYPASS_DAC_AB 0x40
137 #define ADT7316_VREF_BYPASS_DAC_CD 0x80
140 * ADT7316 LDAC config
142 #define ADT7316_LDAC_EN_DA_MASK 0xF
143 #define ADT7316_DAC_IN_VREF 0x10
144 #define ADT7516_DAC_AB_IN_VREF 0x10
145 #define ADT7516_DAC_CD_IN_VREF 0x20
146 #define ADT7516_DAC_IN_VREF_OFFSET 4
147 #define ADT7516_DAC_IN_VREF_MASK 0x30
152 #define ADT7316_INT_MASK2_VDD 0x10
155 * ADT7316 value masks
157 #define ADT7316_VALUE_MASK 0xfff
158 #define ADT7316_T_VALUE_SIGN 0x400
159 #define ADT7316_T_VALUE_FLOAT_OFFSET 2
160 #define ADT7316_T_VALUE_FLOAT_MASK 0x2
165 #define ID_ADT7316 0x1
166 #define ID_ADT7317 0x2
167 #define ID_ADT7318 0x3
168 #define ID_ADT7516 0x11
169 #define ID_ADT7517 0x12
170 #define ID_ADT7519 0x14
172 #define ID_FAMILY_MASK 0xF0
173 #define ID_ADT73XX 0x0
174 #define ID_ADT75XX 0x10
177 * struct adt7316_chip_info - chip specific information
180 struct adt7316_chip_info {
181 struct adt7316_bus bus;
183 u16 int_mask; /* 0x2f */
187 u8 dac_config; /* DAC config */
188 u8 ldac_config; /* LDAC config */
189 u8 dac_bits; /* 8, 10, 12 */
194 * Logic interrupt mask for user application to enable
197 #define ADT7316_IN_TEMP_HIGH_INT_MASK 0x1
198 #define ADT7316_IN_TEMP_LOW_INT_MASK 0x2
199 #define ADT7316_EX_TEMP_HIGH_INT_MASK 0x4
200 #define ADT7316_EX_TEMP_LOW_INT_MASK 0x8
201 #define ADT7316_EX_TEMP_FAULT_INT_MASK 0x10
202 #define ADT7516_AIN1_INT_MASK 0x4
203 #define ADT7516_AIN2_INT_MASK 0x20
204 #define ADT7516_AIN3_INT_MASK 0x40
205 #define ADT7516_AIN4_INT_MASK 0x80
206 #define ADT7316_VDD_INT_MASK 0x100
207 #define ADT7316_TEMP_INT_MASK 0x1F
208 #define ADT7516_AIN_INT_MASK 0xE0
209 #define ADT7316_TEMP_AIN_INT_MASK \
210 (ADT7316_TEMP_INT_MASK)
213 * struct adt7316_chip_info - chip specific information
216 struct adt7316_limit_regs {
221 static ssize_t adt7316_show_enabled(struct device *dev,
222 struct device_attribute *attr,
225 struct iio_dev *dev_info = dev_to_iio_dev(dev);
226 struct adt7316_chip_info *chip = iio_priv(dev_info);
228 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_EN));
231 static ssize_t _adt7316_store_enabled(struct adt7316_chip_info *chip,
238 config1 = chip->config1 | ADT7316_EN;
240 config1 = chip->config1 & ~ADT7316_EN;
242 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
246 chip->config1 = config1;
252 static ssize_t adt7316_store_enabled(struct device *dev,
253 struct device_attribute *attr,
257 struct iio_dev *dev_info = dev_to_iio_dev(dev);
258 struct adt7316_chip_info *chip = iio_priv(dev_info);
266 if (_adt7316_store_enabled(chip, enable) < 0)
272 static IIO_DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR,
273 adt7316_show_enabled,
274 adt7316_store_enabled,
277 static ssize_t adt7316_show_select_ex_temp(struct device *dev,
278 struct device_attribute *attr,
281 struct iio_dev *dev_info = dev_to_iio_dev(dev);
282 struct adt7316_chip_info *chip = iio_priv(dev_info);
284 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
287 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7516_SEL_EX_TEMP));
290 static ssize_t adt7316_store_select_ex_temp(struct device *dev,
291 struct device_attribute *attr,
295 struct iio_dev *dev_info = dev_to_iio_dev(dev);
296 struct adt7316_chip_info *chip = iio_priv(dev_info);
300 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
303 config1 = chip->config1 & (~ADT7516_SEL_EX_TEMP);
305 config1 |= ADT7516_SEL_EX_TEMP;
307 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
311 chip->config1 = config1;
316 static IIO_DEVICE_ATTR(select_ex_temp, S_IRUGO | S_IWUSR,
317 adt7316_show_select_ex_temp,
318 adt7316_store_select_ex_temp,
321 static ssize_t adt7316_show_mode(struct device *dev,
322 struct device_attribute *attr,
325 struct iio_dev *dev_info = dev_to_iio_dev(dev);
326 struct adt7316_chip_info *chip = iio_priv(dev_info);
328 if (chip->config2 & ADT7316_AD_SINGLE_CH_MODE)
329 return sprintf(buf, "single_channel\n");
331 return sprintf(buf, "round_robin\n");
334 static ssize_t adt7316_store_mode(struct device *dev,
335 struct device_attribute *attr,
339 struct iio_dev *dev_info = dev_to_iio_dev(dev);
340 struct adt7316_chip_info *chip = iio_priv(dev_info);
344 config2 = chip->config2 & (~ADT7316_AD_SINGLE_CH_MODE);
345 if (!memcmp(buf, "single_channel", 14))
346 config2 |= ADT7316_AD_SINGLE_CH_MODE;
348 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
352 chip->config2 = config2;
357 static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
362 static ssize_t adt7316_show_all_modes(struct device *dev,
363 struct device_attribute *attr,
366 return sprintf(buf, "single_channel\nround_robin\n");
369 static IIO_DEVICE_ATTR(all_modes, S_IRUGO, adt7316_show_all_modes, NULL, 0);
371 static ssize_t adt7316_show_ad_channel(struct device *dev,
372 struct device_attribute *attr,
375 struct iio_dev *dev_info = dev_to_iio_dev(dev);
376 struct adt7316_chip_info *chip = iio_priv(dev_info);
378 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
381 switch (chip->config2 & ADT7516_AD_SINGLE_CH_MASK) {
382 case ADT7316_AD_SINGLE_CH_VDD:
383 return sprintf(buf, "0 - VDD\n");
384 case ADT7316_AD_SINGLE_CH_IN:
385 return sprintf(buf, "1 - Internal Temperature\n");
386 case ADT7316_AD_SINGLE_CH_EX:
387 if (((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) &&
388 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)
389 return sprintf(buf, "2 - AIN1\n");
391 return sprintf(buf, "2 - External Temperature\n");
392 case ADT7516_AD_SINGLE_CH_AIN2:
393 if ((chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)
394 return sprintf(buf, "3 - AIN2\n");
396 return sprintf(buf, "N/A\n");
397 case ADT7516_AD_SINGLE_CH_AIN3:
398 if (chip->config1 & ADT7516_SEL_AIN3)
399 return sprintf(buf, "4 - AIN3\n");
401 return sprintf(buf, "N/A\n");
402 case ADT7516_AD_SINGLE_CH_AIN4:
403 return sprintf(buf, "5 - AIN4\n");
405 return sprintf(buf, "N/A\n");
409 static ssize_t adt7316_store_ad_channel(struct device *dev,
410 struct device_attribute *attr,
414 struct iio_dev *dev_info = dev_to_iio_dev(dev);
415 struct adt7316_chip_info *chip = iio_priv(dev_info);
420 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
423 ret = kstrtou8(buf, 10, &data);
427 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) {
431 config2 = chip->config2 & (~ADT7516_AD_SINGLE_CH_MASK);
436 config2 = chip->config2 & (~ADT7316_AD_SINGLE_CH_MASK);
442 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
446 chip->config2 = config2;
451 static IIO_DEVICE_ATTR(ad_channel, S_IRUGO | S_IWUSR,
452 adt7316_show_ad_channel,
453 adt7316_store_ad_channel,
456 static ssize_t adt7316_show_all_ad_channels(struct device *dev,
457 struct device_attribute *attr,
460 struct iio_dev *dev_info = dev_to_iio_dev(dev);
461 struct adt7316_chip_info *chip = iio_priv(dev_info);
463 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
466 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
467 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
468 "2 - External Temperature or AIN1\n"
469 "3 - AIN2\n4 - AIN3\n5 - AIN4\n");
471 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
472 "2 - External Temperature\n");
475 static IIO_DEVICE_ATTR(all_ad_channels, S_IRUGO,
476 adt7316_show_all_ad_channels, NULL, 0);
478 static ssize_t adt7316_show_disable_averaging(struct device *dev,
479 struct device_attribute *attr,
482 struct iio_dev *dev_info = dev_to_iio_dev(dev);
483 struct adt7316_chip_info *chip = iio_priv(dev_info);
485 return sprintf(buf, "%d\n",
486 !!(chip->config2 & ADT7316_DISABLE_AVERAGING));
489 static ssize_t adt7316_store_disable_averaging(struct device *dev,
490 struct device_attribute *attr,
494 struct iio_dev *dev_info = dev_to_iio_dev(dev);
495 struct adt7316_chip_info *chip = iio_priv(dev_info);
499 config2 = chip->config2 & (~ADT7316_DISABLE_AVERAGING);
501 config2 |= ADT7316_DISABLE_AVERAGING;
503 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
507 chip->config2 = config2;
512 static IIO_DEVICE_ATTR(disable_averaging, S_IRUGO | S_IWUSR,
513 adt7316_show_disable_averaging,
514 adt7316_store_disable_averaging,
517 static ssize_t adt7316_show_enable_smbus_timeout(struct device *dev,
518 struct device_attribute *attr,
521 struct iio_dev *dev_info = dev_to_iio_dev(dev);
522 struct adt7316_chip_info *chip = iio_priv(dev_info);
524 return sprintf(buf, "%d\n",
525 !!(chip->config2 & ADT7316_EN_SMBUS_TIMEOUT));
528 static ssize_t adt7316_store_enable_smbus_timeout(struct device *dev,
529 struct device_attribute *attr,
533 struct iio_dev *dev_info = dev_to_iio_dev(dev);
534 struct adt7316_chip_info *chip = iio_priv(dev_info);
538 config2 = chip->config2 & (~ADT7316_EN_SMBUS_TIMEOUT);
540 config2 |= ADT7316_EN_SMBUS_TIMEOUT;
542 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
546 chip->config2 = config2;
551 static IIO_DEVICE_ATTR(enable_smbus_timeout, S_IRUGO | S_IWUSR,
552 adt7316_show_enable_smbus_timeout,
553 adt7316_store_enable_smbus_timeout,
556 static ssize_t adt7316_show_powerdown(struct device *dev,
557 struct device_attribute *attr,
560 struct iio_dev *dev_info = dev_to_iio_dev(dev);
561 struct adt7316_chip_info *chip = iio_priv(dev_info);
563 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_PD));
566 static ssize_t adt7316_store_powerdown(struct device *dev,
567 struct device_attribute *attr,
571 struct iio_dev *dev_info = dev_to_iio_dev(dev);
572 struct adt7316_chip_info *chip = iio_priv(dev_info);
576 config1 = chip->config1 & (~ADT7316_PD);
578 config1 |= ADT7316_PD;
580 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
584 chip->config1 = config1;
589 static IIO_DEVICE_ATTR(powerdown, S_IRUGO | S_IWUSR,
590 adt7316_show_powerdown,
591 adt7316_store_powerdown,
594 static ssize_t adt7316_show_fast_ad_clock(struct device *dev,
595 struct device_attribute *attr,
598 struct iio_dev *dev_info = dev_to_iio_dev(dev);
599 struct adt7316_chip_info *chip = iio_priv(dev_info);
601 return sprintf(buf, "%d\n", !!(chip->config3 & ADT7316_ADCLK_22_5));
604 static ssize_t adt7316_store_fast_ad_clock(struct device *dev,
605 struct device_attribute *attr,
609 struct iio_dev *dev_info = dev_to_iio_dev(dev);
610 struct adt7316_chip_info *chip = iio_priv(dev_info);
614 config3 = chip->config3 & (~ADT7316_ADCLK_22_5);
616 config3 |= ADT7316_ADCLK_22_5;
618 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
622 chip->config3 = config3;
627 static IIO_DEVICE_ATTR(fast_ad_clock, S_IRUGO | S_IWUSR,
628 adt7316_show_fast_ad_clock,
629 adt7316_store_fast_ad_clock,
632 static ssize_t adt7316_show_da_high_resolution(struct device *dev,
633 struct device_attribute *attr,
636 struct iio_dev *dev_info = dev_to_iio_dev(dev);
637 struct adt7316_chip_info *chip = iio_priv(dev_info);
639 if (chip->config3 & ADT7316_DA_HIGH_RESOLUTION) {
640 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516)
641 return sprintf(buf, "1 (12 bits)\n");
642 else if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517)
643 return sprintf(buf, "1 (10 bits)\n");
646 return sprintf(buf, "0 (8 bits)\n");
649 static ssize_t adt7316_store_da_high_resolution(struct device *dev,
650 struct device_attribute *attr,
654 struct iio_dev *dev_info = dev_to_iio_dev(dev);
655 struct adt7316_chip_info *chip = iio_priv(dev_info);
662 config3 = chip->config3 | ADT7316_DA_HIGH_RESOLUTION;
663 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516)
665 else if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517)
668 config3 = chip->config3 & (~ADT7316_DA_HIGH_RESOLUTION);
670 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
674 chip->config3 = config3;
679 static IIO_DEVICE_ATTR(da_high_resolution, S_IRUGO | S_IWUSR,
680 adt7316_show_da_high_resolution,
681 adt7316_store_da_high_resolution,
684 static ssize_t adt7316_show_AIN_internal_Vref(struct device *dev,
685 struct device_attribute *attr,
688 struct iio_dev *dev_info = dev_to_iio_dev(dev);
689 struct adt7316_chip_info *chip = iio_priv(dev_info);
691 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
694 return sprintf(buf, "%d\n",
695 !!(chip->config3 & ADT7516_AIN_IN_VREF));
698 static ssize_t adt7316_store_AIN_internal_Vref(struct device *dev,
699 struct device_attribute *attr,
703 struct iio_dev *dev_info = dev_to_iio_dev(dev);
704 struct adt7316_chip_info *chip = iio_priv(dev_info);
708 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
712 config3 = chip->config3 & (~ADT7516_AIN_IN_VREF);
714 config3 = chip->config3 | ADT7516_AIN_IN_VREF;
716 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
720 chip->config3 = config3;
725 static IIO_DEVICE_ATTR(AIN_internal_Vref, S_IRUGO | S_IWUSR,
726 adt7316_show_AIN_internal_Vref,
727 adt7316_store_AIN_internal_Vref,
731 static ssize_t adt7316_show_enable_prop_DACA(struct device *dev,
732 struct device_attribute *attr,
735 struct iio_dev *dev_info = dev_to_iio_dev(dev);
736 struct adt7316_chip_info *chip = iio_priv(dev_info);
738 return sprintf(buf, "%d\n",
739 !!(chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA));
742 static ssize_t adt7316_store_enable_prop_DACA(struct device *dev,
743 struct device_attribute *attr,
747 struct iio_dev *dev_info = dev_to_iio_dev(dev);
748 struct adt7316_chip_info *chip = iio_priv(dev_info);
752 config3 = chip->config3 & (~ADT7316_EN_IN_TEMP_PROP_DACA);
754 config3 |= ADT7316_EN_IN_TEMP_PROP_DACA;
756 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
760 chip->config3 = config3;
765 static IIO_DEVICE_ATTR(enable_proportion_DACA, S_IRUGO | S_IWUSR,
766 adt7316_show_enable_prop_DACA,
767 adt7316_store_enable_prop_DACA,
770 static ssize_t adt7316_show_enable_prop_DACB(struct device *dev,
771 struct device_attribute *attr,
774 struct iio_dev *dev_info = dev_to_iio_dev(dev);
775 struct adt7316_chip_info *chip = iio_priv(dev_info);
777 return sprintf(buf, "%d\n",
778 !!(chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB));
781 static ssize_t adt7316_store_enable_prop_DACB(struct device *dev,
782 struct device_attribute *attr,
786 struct iio_dev *dev_info = dev_to_iio_dev(dev);
787 struct adt7316_chip_info *chip = iio_priv(dev_info);
791 config3 = chip->config3 & (~ADT7316_EN_EX_TEMP_PROP_DACB);
793 config3 |= ADT7316_EN_EX_TEMP_PROP_DACB;
795 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
799 chip->config3 = config3;
804 static IIO_DEVICE_ATTR(enable_proportion_DACB, S_IRUGO | S_IWUSR,
805 adt7316_show_enable_prop_DACB,
806 adt7316_store_enable_prop_DACB,
809 static ssize_t adt7316_show_DAC_2Vref_ch_mask(struct device *dev,
810 struct device_attribute *attr,
813 struct iio_dev *dev_info = dev_to_iio_dev(dev);
814 struct adt7316_chip_info *chip = iio_priv(dev_info);
816 return sprintf(buf, "0x%x\n",
817 chip->dac_config & ADT7316_DA_2VREF_CH_MASK);
820 static ssize_t adt7316_store_DAC_2Vref_ch_mask(struct device *dev,
821 struct device_attribute *attr,
825 struct iio_dev *dev_info = dev_to_iio_dev(dev);
826 struct adt7316_chip_info *chip = iio_priv(dev_info);
831 ret = kstrtou8(buf, 16, &data);
832 if (ret || data > ADT7316_DA_2VREF_CH_MASK)
835 dac_config = chip->dac_config & (~ADT7316_DA_2VREF_CH_MASK);
838 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
842 chip->dac_config = dac_config;
847 static IIO_DEVICE_ATTR(DAC_2Vref_channels_mask, S_IRUGO | S_IWUSR,
848 adt7316_show_DAC_2Vref_ch_mask,
849 adt7316_store_DAC_2Vref_ch_mask,
852 static ssize_t adt7316_show_DAC_update_mode(struct device *dev,
853 struct device_attribute *attr,
856 struct iio_dev *dev_info = dev_to_iio_dev(dev);
857 struct adt7316_chip_info *chip = iio_priv(dev_info);
859 if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA))
860 return sprintf(buf, "manual\n");
862 switch (chip->dac_config & ADT7316_DA_EN_MODE_MASK) {
863 case ADT7316_DA_EN_MODE_SINGLE:
865 "0 - auto at any MSB DAC writing\n");
866 case ADT7316_DA_EN_MODE_AB_CD:
868 "1 - auto at MSB DAC AB and CD writing\n");
869 case ADT7316_DA_EN_MODE_ABCD:
871 "2 - auto at MSB DAC ABCD writing\n");
872 default: /* ADT7316_DA_EN_MODE_LDAC */
873 return sprintf(buf, "3 - manual\n");
877 static ssize_t adt7316_store_DAC_update_mode(struct device *dev,
878 struct device_attribute *attr,
882 struct iio_dev *dev_info = dev_to_iio_dev(dev);
883 struct adt7316_chip_info *chip = iio_priv(dev_info);
888 if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA))
891 ret = kstrtou8(buf, 10, &data);
892 if (ret || data > ADT7316_DA_EN_MODE_MASK)
895 dac_config = chip->dac_config & (~ADT7316_DA_EN_MODE_MASK);
898 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
902 chip->dac_config = dac_config;
907 static IIO_DEVICE_ATTR(DAC_update_mode, S_IRUGO | S_IWUSR,
908 adt7316_show_DAC_update_mode,
909 adt7316_store_DAC_update_mode,
912 static ssize_t adt7316_show_all_DAC_update_modes(struct device *dev,
913 struct device_attribute *attr,
916 struct iio_dev *dev_info = dev_to_iio_dev(dev);
917 struct adt7316_chip_info *chip = iio_priv(dev_info);
919 if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA)
920 return sprintf(buf, "0 - auto at any MSB DAC writing\n"
921 "1 - auto at MSB DAC AB and CD writing\n"
922 "2 - auto at MSB DAC ABCD writing\n"
925 return sprintf(buf, "manual\n");
928 static IIO_DEVICE_ATTR(all_DAC_update_modes, S_IRUGO,
929 adt7316_show_all_DAC_update_modes, NULL, 0);
932 static ssize_t adt7316_store_update_DAC(struct device *dev,
933 struct device_attribute *attr,
937 struct iio_dev *dev_info = dev_to_iio_dev(dev);
938 struct adt7316_chip_info *chip = iio_priv(dev_info);
943 if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA) {
944 if ((chip->dac_config & ADT7316_DA_EN_MODE_MASK) !=
945 ADT7316_DA_EN_MODE_LDAC)
948 ret = kstrtou8(buf, 16, &data);
949 if (ret || data > ADT7316_LDAC_EN_DA_MASK)
952 ldac_config = chip->ldac_config & (~ADT7316_LDAC_EN_DA_MASK);
955 ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG,
960 gpio_set_value(chip->ldac_pin, 0);
961 gpio_set_value(chip->ldac_pin, 1);
967 static IIO_DEVICE_ATTR(update_DAC, S_IRUGO | S_IWUSR,
969 adt7316_store_update_DAC,
972 static ssize_t adt7316_show_DA_AB_Vref_bypass(struct device *dev,
973 struct device_attribute *attr,
976 struct iio_dev *dev_info = dev_to_iio_dev(dev);
977 struct adt7316_chip_info *chip = iio_priv(dev_info);
979 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
982 return sprintf(buf, "%d\n",
983 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_AB));
986 static ssize_t adt7316_store_DA_AB_Vref_bypass(struct device *dev,
987 struct device_attribute *attr,
991 struct iio_dev *dev_info = dev_to_iio_dev(dev);
992 struct adt7316_chip_info *chip = iio_priv(dev_info);
996 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
999 dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_AB);
1001 dac_config |= ADT7316_VREF_BYPASS_DAC_AB;
1003 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
1007 chip->dac_config = dac_config;
1012 static IIO_DEVICE_ATTR(DA_AB_Vref_bypass, S_IRUGO | S_IWUSR,
1013 adt7316_show_DA_AB_Vref_bypass,
1014 adt7316_store_DA_AB_Vref_bypass,
1017 static ssize_t adt7316_show_DA_CD_Vref_bypass(struct device *dev,
1018 struct device_attribute *attr,
1021 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1022 struct adt7316_chip_info *chip = iio_priv(dev_info);
1024 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1027 return sprintf(buf, "%d\n",
1028 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_CD));
1031 static ssize_t adt7316_store_DA_CD_Vref_bypass(struct device *dev,
1032 struct device_attribute *attr,
1036 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1037 struct adt7316_chip_info *chip = iio_priv(dev_info);
1041 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1044 dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_CD);
1046 dac_config |= ADT7316_VREF_BYPASS_DAC_CD;
1048 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
1052 chip->dac_config = dac_config;
1057 static IIO_DEVICE_ATTR(DA_CD_Vref_bypass, S_IRUGO | S_IWUSR,
1058 adt7316_show_DA_CD_Vref_bypass,
1059 adt7316_store_DA_CD_Vref_bypass,
1062 static ssize_t adt7316_show_DAC_internal_Vref(struct device *dev,
1063 struct device_attribute *attr,
1066 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1067 struct adt7316_chip_info *chip = iio_priv(dev_info);
1069 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1070 return sprintf(buf, "0x%x\n",
1071 (chip->dac_config & ADT7516_DAC_IN_VREF_MASK) >>
1072 ADT7516_DAC_IN_VREF_OFFSET);
1074 return sprintf(buf, "%d\n",
1075 !!(chip->dac_config & ADT7316_DAC_IN_VREF));
1078 static ssize_t adt7316_store_DAC_internal_Vref(struct device *dev,
1079 struct device_attribute *attr,
1083 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1084 struct adt7316_chip_info *chip = iio_priv(dev_info);
1089 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) {
1090 ret = kstrtou8(buf, 16, &data);
1091 if (ret || data > 3)
1094 ldac_config = chip->ldac_config & (~ADT7516_DAC_IN_VREF_MASK);
1096 ldac_config |= ADT7516_DAC_AB_IN_VREF;
1098 ldac_config |= ADT7516_DAC_CD_IN_VREF;
1100 ret = kstrtou8(buf, 16, &data);
1104 ldac_config = chip->ldac_config & (~ADT7316_DAC_IN_VREF);
1106 ldac_config = chip->ldac_config | ADT7316_DAC_IN_VREF;
1109 ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG,
1114 chip->ldac_config = ldac_config;
1119 static IIO_DEVICE_ATTR(DAC_internal_Vref, S_IRUGO | S_IWUSR,
1120 adt7316_show_DAC_internal_Vref,
1121 adt7316_store_DAC_internal_Vref,
1124 static ssize_t adt7316_show_ad(struct adt7316_chip_info *chip,
1125 int channel, char *buf)
1132 if ((chip->config2 & ADT7316_AD_SINGLE_CH_MODE) &&
1133 channel != (chip->config2 & ADT7516_AD_SINGLE_CH_MASK))
1137 case ADT7316_AD_SINGLE_CH_IN:
1138 ret = chip->bus.read(chip->bus.client,
1139 ADT7316_LSB_IN_TEMP_VDD, &lsb);
1143 ret = chip->bus.read(chip->bus.client,
1144 ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1148 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1149 data |= lsb & ADT7316_LSB_IN_TEMP_MASK;
1151 case ADT7316_AD_SINGLE_CH_VDD:
1152 ret = chip->bus.read(chip->bus.client,
1153 ADT7316_LSB_IN_TEMP_VDD, &lsb);
1157 ret = chip->bus.read(chip->bus.client,
1159 ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1163 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1164 data |= (lsb & ADT7316_LSB_VDD_MASK) >> ADT7316_LSB_VDD_OFFSET;
1165 return sprintf(buf, "%d\n", data);
1166 default: /* ex_temp and ain */
1167 ret = chip->bus.read(chip->bus.client,
1168 ADT7316_LSB_EX_TEMP_AIN, &lsb);
1172 ret = chip->bus.read(chip->bus.client,
1173 ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1177 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1178 data |= lsb & (ADT7316_LSB_EX_TEMP_MASK <<
1179 (ADT7516_LSB_AIN_SHIFT * (channel -
1180 (ADT7316_MSB_EX_TEMP - ADT7316_AD_MSB_DATA_BASE))));
1182 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1183 return sprintf(buf, "%d\n", data);
1188 if (data & ADT7316_T_VALUE_SIGN) {
1189 /* convert supplement to positive value */
1190 data = (ADT7316_T_VALUE_SIGN << 1) - data;
1194 return sprintf(buf, "%c%d.%.2d\n", sign,
1195 (data >> ADT7316_T_VALUE_FLOAT_OFFSET),
1196 (data & ADT7316_T_VALUE_FLOAT_MASK) * 25);
1199 static ssize_t adt7316_show_VDD(struct device *dev,
1200 struct device_attribute *attr,
1203 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1204 struct adt7316_chip_info *chip = iio_priv(dev_info);
1206 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_VDD, buf);
1208 static IIO_DEVICE_ATTR(VDD, S_IRUGO, adt7316_show_VDD, NULL, 0);
1210 static ssize_t adt7316_show_in_temp(struct device *dev,
1211 struct device_attribute *attr,
1214 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1215 struct adt7316_chip_info *chip = iio_priv(dev_info);
1217 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_IN, buf);
1220 static IIO_DEVICE_ATTR(in_temp, S_IRUGO, adt7316_show_in_temp, NULL, 0);
1222 static ssize_t adt7316_show_ex_temp_AIN1(struct device *dev,
1223 struct device_attribute *attr,
1226 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1227 struct adt7316_chip_info *chip = iio_priv(dev_info);
1229 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_EX, buf);
1232 static IIO_DEVICE_ATTR(ex_temp_AIN1, S_IRUGO, adt7316_show_ex_temp_AIN1,
1234 static IIO_DEVICE_ATTR(ex_temp, S_IRUGO, adt7316_show_ex_temp_AIN1, NULL, 0);
1236 static ssize_t adt7316_show_AIN2(struct device *dev,
1237 struct device_attribute *attr,
1240 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1241 struct adt7316_chip_info *chip = iio_priv(dev_info);
1243 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN2, buf);
1245 static IIO_DEVICE_ATTR(AIN2, S_IRUGO, adt7316_show_AIN2, NULL, 0);
1247 static ssize_t adt7316_show_AIN3(struct device *dev,
1248 struct device_attribute *attr,
1251 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1252 struct adt7316_chip_info *chip = iio_priv(dev_info);
1254 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN3, buf);
1256 static IIO_DEVICE_ATTR(AIN3, S_IRUGO, adt7316_show_AIN3, NULL, 0);
1258 static ssize_t adt7316_show_AIN4(struct device *dev,
1259 struct device_attribute *attr,
1262 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1263 struct adt7316_chip_info *chip = iio_priv(dev_info);
1265 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN4, buf);
1267 static IIO_DEVICE_ATTR(AIN4, S_IRUGO, adt7316_show_AIN4, NULL, 0);
1269 static ssize_t adt7316_show_temp_offset(struct adt7316_chip_info *chip,
1270 int offset_addr, char *buf)
1276 ret = chip->bus.read(chip->bus.client, offset_addr, &val);
1284 return sprintf(buf, "%d\n", data);
1287 static ssize_t adt7316_store_temp_offset(struct adt7316_chip_info *chip,
1288 int offset_addr, const char *buf, size_t len)
1294 ret = kstrtoint(buf, 10, &data);
1295 if (ret || data > 127 || data < -128)
1303 ret = chip->bus.write(chip->bus.client, offset_addr, val);
1310 static ssize_t adt7316_show_in_temp_offset(struct device *dev,
1311 struct device_attribute *attr,
1314 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1315 struct adt7316_chip_info *chip = iio_priv(dev_info);
1317 return adt7316_show_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf);
1320 static ssize_t adt7316_store_in_temp_offset(struct device *dev,
1321 struct device_attribute *attr,
1325 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1326 struct adt7316_chip_info *chip = iio_priv(dev_info);
1328 return adt7316_store_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf,
1332 static IIO_DEVICE_ATTR(in_temp_offset, S_IRUGO | S_IWUSR,
1333 adt7316_show_in_temp_offset,
1334 adt7316_store_in_temp_offset, 0);
1336 static ssize_t adt7316_show_ex_temp_offset(struct device *dev,
1337 struct device_attribute *attr,
1340 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1341 struct adt7316_chip_info *chip = iio_priv(dev_info);
1343 return adt7316_show_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf);
1346 static ssize_t adt7316_store_ex_temp_offset(struct device *dev,
1347 struct device_attribute *attr,
1351 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1352 struct adt7316_chip_info *chip = iio_priv(dev_info);
1354 return adt7316_store_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf,
1358 static IIO_DEVICE_ATTR(ex_temp_offset, S_IRUGO | S_IWUSR,
1359 adt7316_show_ex_temp_offset,
1360 adt7316_store_ex_temp_offset, 0);
1362 static ssize_t adt7316_show_in_analog_temp_offset(struct device *dev,
1363 struct device_attribute *attr,
1366 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1367 struct adt7316_chip_info *chip = iio_priv(dev_info);
1369 return adt7316_show_temp_offset(chip,
1370 ADT7316_IN_ANALOG_TEMP_OFFSET, buf);
1373 static ssize_t adt7316_store_in_analog_temp_offset(struct device *dev,
1374 struct device_attribute *attr,
1378 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1379 struct adt7316_chip_info *chip = iio_priv(dev_info);
1381 return adt7316_store_temp_offset(chip,
1382 ADT7316_IN_ANALOG_TEMP_OFFSET, buf, len);
1385 static IIO_DEVICE_ATTR(in_analog_temp_offset, S_IRUGO | S_IWUSR,
1386 adt7316_show_in_analog_temp_offset,
1387 adt7316_store_in_analog_temp_offset, 0);
1389 static ssize_t adt7316_show_ex_analog_temp_offset(struct device *dev,
1390 struct device_attribute *attr,
1393 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1394 struct adt7316_chip_info *chip = iio_priv(dev_info);
1396 return adt7316_show_temp_offset(chip,
1397 ADT7316_EX_ANALOG_TEMP_OFFSET, buf);
1400 static ssize_t adt7316_store_ex_analog_temp_offset(struct device *dev,
1401 struct device_attribute *attr,
1405 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1406 struct adt7316_chip_info *chip = iio_priv(dev_info);
1408 return adt7316_store_temp_offset(chip,
1409 ADT7316_EX_ANALOG_TEMP_OFFSET, buf, len);
1412 static IIO_DEVICE_ATTR(ex_analog_temp_offset, S_IRUGO | S_IWUSR,
1413 adt7316_show_ex_analog_temp_offset,
1414 adt7316_store_ex_analog_temp_offset, 0);
1416 static ssize_t adt7316_show_DAC(struct adt7316_chip_info *chip,
1417 int channel, char *buf)
1420 u8 msb, lsb, offset;
1423 if (channel >= ADT7316_DA_MSB_DATA_REGS ||
1425 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) ||
1427 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)))
1430 offset = chip->dac_bits - 8;
1432 if (chip->dac_bits > 8) {
1433 ret = chip->bus.read(chip->bus.client,
1434 ADT7316_DA_DATA_BASE + channel * 2, &lsb);
1439 ret = chip->bus.read(chip->bus.client,
1440 ADT7316_DA_DATA_BASE + 1 + channel * 2, &msb);
1444 if (chip->dac_bits == 12)
1445 data = lsb >> ADT7316_DA_12_BIT_LSB_SHIFT;
1446 else if (chip->dac_bits == 10)
1447 data = lsb >> ADT7316_DA_10_BIT_LSB_SHIFT;
1448 data |= msb << offset;
1450 return sprintf(buf, "%d\n", data);
1453 static ssize_t adt7316_store_DAC(struct adt7316_chip_info *chip,
1454 int channel, const char *buf, size_t len)
1456 u8 msb, lsb, lsb_reg, offset;
1460 if (channel >= ADT7316_DA_MSB_DATA_REGS ||
1462 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) ||
1464 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)))
1467 offset = chip->dac_bits - 8;
1469 ret = kstrtou16(buf, 10, &data);
1470 if (ret || data >= (1 << chip->dac_bits))
1473 if (chip->dac_bits > 8) {
1474 lsb = data & ((1 << offset) - 1);
1475 if (chip->dac_bits == 12)
1476 lsb_reg = lsb << ADT7316_DA_12_BIT_LSB_SHIFT;
1478 lsb_reg = lsb << ADT7316_DA_10_BIT_LSB_SHIFT;
1479 ret = chip->bus.write(chip->bus.client,
1480 ADT7316_DA_DATA_BASE + channel * 2, lsb_reg);
1485 msb = data >> offset;
1486 ret = chip->bus.write(chip->bus.client,
1487 ADT7316_DA_DATA_BASE + 1 + channel * 2, msb);
1494 static ssize_t adt7316_show_DAC_A(struct device *dev,
1495 struct device_attribute *attr,
1498 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1499 struct adt7316_chip_info *chip = iio_priv(dev_info);
1501 return adt7316_show_DAC(chip, 0, buf);
1504 static ssize_t adt7316_store_DAC_A(struct device *dev,
1505 struct device_attribute *attr,
1509 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1510 struct adt7316_chip_info *chip = iio_priv(dev_info);
1512 return adt7316_store_DAC(chip, 0, buf, len);
1515 static IIO_DEVICE_ATTR(DAC_A, S_IRUGO | S_IWUSR, adt7316_show_DAC_A,
1516 adt7316_store_DAC_A, 0);
1518 static ssize_t adt7316_show_DAC_B(struct device *dev,
1519 struct device_attribute *attr,
1522 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1523 struct adt7316_chip_info *chip = iio_priv(dev_info);
1525 return adt7316_show_DAC(chip, 1, buf);
1528 static ssize_t adt7316_store_DAC_B(struct device *dev,
1529 struct device_attribute *attr,
1533 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1534 struct adt7316_chip_info *chip = iio_priv(dev_info);
1536 return adt7316_store_DAC(chip, 1, buf, len);
1539 static IIO_DEVICE_ATTR(DAC_B, S_IRUGO | S_IWUSR, adt7316_show_DAC_B,
1540 adt7316_store_DAC_B, 0);
1542 static ssize_t adt7316_show_DAC_C(struct device *dev,
1543 struct device_attribute *attr,
1546 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1547 struct adt7316_chip_info *chip = iio_priv(dev_info);
1549 return adt7316_show_DAC(chip, 2, buf);
1552 static ssize_t adt7316_store_DAC_C(struct device *dev,
1553 struct device_attribute *attr,
1557 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1558 struct adt7316_chip_info *chip = iio_priv(dev_info);
1560 return adt7316_store_DAC(chip, 2, buf, len);
1563 static IIO_DEVICE_ATTR(DAC_C, S_IRUGO | S_IWUSR, adt7316_show_DAC_C,
1564 adt7316_store_DAC_C, 0);
1566 static ssize_t adt7316_show_DAC_D(struct device *dev,
1567 struct device_attribute *attr,
1570 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1571 struct adt7316_chip_info *chip = iio_priv(dev_info);
1573 return adt7316_show_DAC(chip, 3, buf);
1576 static ssize_t adt7316_store_DAC_D(struct device *dev,
1577 struct device_attribute *attr,
1581 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1582 struct adt7316_chip_info *chip = iio_priv(dev_info);
1584 return adt7316_store_DAC(chip, 3, buf, len);
1587 static IIO_DEVICE_ATTR(DAC_D, S_IRUGO | S_IWUSR, adt7316_show_DAC_D,
1588 adt7316_store_DAC_D, 0);
1590 static ssize_t adt7316_show_device_id(struct device *dev,
1591 struct device_attribute *attr,
1594 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1595 struct adt7316_chip_info *chip = iio_priv(dev_info);
1599 ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_ID, &id);
1603 return sprintf(buf, "%d\n", id);
1606 static IIO_DEVICE_ATTR(device_id, S_IRUGO, adt7316_show_device_id, NULL, 0);
1608 static ssize_t adt7316_show_manufactorer_id(struct device *dev,
1609 struct device_attribute *attr,
1612 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1613 struct adt7316_chip_info *chip = iio_priv(dev_info);
1617 ret = chip->bus.read(chip->bus.client, ADT7316_MANUFACTURE_ID, &id);
1621 return sprintf(buf, "%d\n", id);
1624 static IIO_DEVICE_ATTR(manufactorer_id, S_IRUGO,
1625 adt7316_show_manufactorer_id, NULL, 0);
1627 static ssize_t adt7316_show_device_rev(struct device *dev,
1628 struct device_attribute *attr,
1631 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1632 struct adt7316_chip_info *chip = iio_priv(dev_info);
1636 ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_REV, &rev);
1640 return sprintf(buf, "%d\n", rev);
1643 static IIO_DEVICE_ATTR(device_rev, S_IRUGO, adt7316_show_device_rev, NULL, 0);
1645 static ssize_t adt7316_show_bus_type(struct device *dev,
1646 struct device_attribute *attr,
1649 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1650 struct adt7316_chip_info *chip = iio_priv(dev_info);
1654 ret = chip->bus.read(chip->bus.client, ADT7316_SPI_LOCK_STAT, &stat);
1659 return sprintf(buf, "spi\n");
1661 return sprintf(buf, "i2c\n");
1664 static IIO_DEVICE_ATTR(bus_type, S_IRUGO, adt7316_show_bus_type, NULL, 0);
1666 static struct attribute *adt7316_attributes[] = {
1667 &iio_dev_attr_all_modes.dev_attr.attr,
1668 &iio_dev_attr_mode.dev_attr.attr,
1669 &iio_dev_attr_enabled.dev_attr.attr,
1670 &iio_dev_attr_ad_channel.dev_attr.attr,
1671 &iio_dev_attr_all_ad_channels.dev_attr.attr,
1672 &iio_dev_attr_disable_averaging.dev_attr.attr,
1673 &iio_dev_attr_enable_smbus_timeout.dev_attr.attr,
1674 &iio_dev_attr_powerdown.dev_attr.attr,
1675 &iio_dev_attr_fast_ad_clock.dev_attr.attr,
1676 &iio_dev_attr_da_high_resolution.dev_attr.attr,
1677 &iio_dev_attr_enable_proportion_DACA.dev_attr.attr,
1678 &iio_dev_attr_enable_proportion_DACB.dev_attr.attr,
1679 &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr,
1680 &iio_dev_attr_DAC_update_mode.dev_attr.attr,
1681 &iio_dev_attr_all_DAC_update_modes.dev_attr.attr,
1682 &iio_dev_attr_update_DAC.dev_attr.attr,
1683 &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr,
1684 &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr,
1685 &iio_dev_attr_DAC_internal_Vref.dev_attr.attr,
1686 &iio_dev_attr_VDD.dev_attr.attr,
1687 &iio_dev_attr_in_temp.dev_attr.attr,
1688 &iio_dev_attr_ex_temp.dev_attr.attr,
1689 &iio_dev_attr_in_temp_offset.dev_attr.attr,
1690 &iio_dev_attr_ex_temp_offset.dev_attr.attr,
1691 &iio_dev_attr_in_analog_temp_offset.dev_attr.attr,
1692 &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr,
1693 &iio_dev_attr_DAC_A.dev_attr.attr,
1694 &iio_dev_attr_DAC_B.dev_attr.attr,
1695 &iio_dev_attr_DAC_C.dev_attr.attr,
1696 &iio_dev_attr_DAC_D.dev_attr.attr,
1697 &iio_dev_attr_device_id.dev_attr.attr,
1698 &iio_dev_attr_manufactorer_id.dev_attr.attr,
1699 &iio_dev_attr_device_rev.dev_attr.attr,
1700 &iio_dev_attr_bus_type.dev_attr.attr,
1704 static const struct attribute_group adt7316_attribute_group = {
1705 .attrs = adt7316_attributes,
1708 static struct attribute *adt7516_attributes[] = {
1709 &iio_dev_attr_all_modes.dev_attr.attr,
1710 &iio_dev_attr_mode.dev_attr.attr,
1711 &iio_dev_attr_select_ex_temp.dev_attr.attr,
1712 &iio_dev_attr_enabled.dev_attr.attr,
1713 &iio_dev_attr_ad_channel.dev_attr.attr,
1714 &iio_dev_attr_all_ad_channels.dev_attr.attr,
1715 &iio_dev_attr_disable_averaging.dev_attr.attr,
1716 &iio_dev_attr_enable_smbus_timeout.dev_attr.attr,
1717 &iio_dev_attr_powerdown.dev_attr.attr,
1718 &iio_dev_attr_fast_ad_clock.dev_attr.attr,
1719 &iio_dev_attr_AIN_internal_Vref.dev_attr.attr,
1720 &iio_dev_attr_da_high_resolution.dev_attr.attr,
1721 &iio_dev_attr_enable_proportion_DACA.dev_attr.attr,
1722 &iio_dev_attr_enable_proportion_DACB.dev_attr.attr,
1723 &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr,
1724 &iio_dev_attr_DAC_update_mode.dev_attr.attr,
1725 &iio_dev_attr_all_DAC_update_modes.dev_attr.attr,
1726 &iio_dev_attr_update_DAC.dev_attr.attr,
1727 &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr,
1728 &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr,
1729 &iio_dev_attr_DAC_internal_Vref.dev_attr.attr,
1730 &iio_dev_attr_VDD.dev_attr.attr,
1731 &iio_dev_attr_in_temp.dev_attr.attr,
1732 &iio_dev_attr_ex_temp_AIN1.dev_attr.attr,
1733 &iio_dev_attr_AIN2.dev_attr.attr,
1734 &iio_dev_attr_AIN3.dev_attr.attr,
1735 &iio_dev_attr_AIN4.dev_attr.attr,
1736 &iio_dev_attr_in_temp_offset.dev_attr.attr,
1737 &iio_dev_attr_ex_temp_offset.dev_attr.attr,
1738 &iio_dev_attr_in_analog_temp_offset.dev_attr.attr,
1739 &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr,
1740 &iio_dev_attr_DAC_A.dev_attr.attr,
1741 &iio_dev_attr_DAC_B.dev_attr.attr,
1742 &iio_dev_attr_DAC_C.dev_attr.attr,
1743 &iio_dev_attr_DAC_D.dev_attr.attr,
1744 &iio_dev_attr_device_id.dev_attr.attr,
1745 &iio_dev_attr_manufactorer_id.dev_attr.attr,
1746 &iio_dev_attr_device_rev.dev_attr.attr,
1747 &iio_dev_attr_bus_type.dev_attr.attr,
1751 static const struct attribute_group adt7516_attribute_group = {
1752 .attrs = adt7516_attributes,
1755 static irqreturn_t adt7316_event_handler(int irq, void *private)
1757 struct iio_dev *indio_dev = private;
1758 struct adt7316_chip_info *chip = iio_priv(indio_dev);
1763 ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT1, &stat1);
1765 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
1768 time = iio_get_time_ns();
1770 iio_push_event(indio_dev,
1771 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
1776 iio_push_event(indio_dev,
1777 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
1779 IIO_EV_DIR_FALLING),
1782 iio_push_event(indio_dev,
1783 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
1788 iio_push_event(indio_dev,
1789 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
1791 IIO_EV_DIR_FALLING),
1794 iio_push_event(indio_dev,
1795 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1,
1800 iio_push_event(indio_dev,
1801 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 2,
1806 iio_push_event(indio_dev,
1807 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 3,
1812 ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT2, &stat2);
1814 if (stat2 & ADT7316_INT_MASK2_VDD)
1815 iio_push_event(indio_dev,
1816 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
1827 * Show mask of enabled interrupts in Hex.
1829 static ssize_t adt7316_show_int_mask(struct device *dev,
1830 struct device_attribute *attr,
1833 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1834 struct adt7316_chip_info *chip = iio_priv(dev_info);
1836 return sprintf(buf, "0x%x\n", chip->int_mask);
1840 * Set 1 to the mask in Hex to enabled interrupts.
1842 static ssize_t adt7316_set_int_mask(struct device *dev,
1843 struct device_attribute *attr,
1847 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1848 struct adt7316_chip_info *chip = iio_priv(dev_info);
1853 ret = kstrtou16(buf, 16, &data);
1854 if (ret || data >= ADT7316_VDD_INT_MASK + 1)
1857 if (data & ADT7316_VDD_INT_MASK)
1858 mask = 0; /* enable vdd int */
1860 mask = ADT7316_INT_MASK2_VDD; /* disable vdd int */
1862 ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK2, mask);
1864 chip->int_mask &= ~ADT7316_VDD_INT_MASK;
1865 chip->int_mask |= data & ADT7316_VDD_INT_MASK;
1868 if (data & ADT7316_TEMP_AIN_INT_MASK) {
1869 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX)
1870 /* mask in reg is opposite, set 1 to disable */
1871 mask = (~data) & ADT7316_TEMP_INT_MASK;
1873 /* mask in reg is opposite, set 1 to disable */
1874 mask = (~data) & ADT7316_TEMP_AIN_INT_MASK;
1876 ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK1, mask);
1878 chip->int_mask = mask;
1882 static inline ssize_t adt7316_show_ad_bound(struct device *dev,
1883 struct device_attribute *attr,
1886 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1887 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1888 struct adt7316_chip_info *chip = iio_priv(dev_info);
1893 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1894 this_attr->address > ADT7316_EX_TEMP_LOW)
1897 ret = chip->bus.read(chip->bus.client, this_attr->address, &val);
1903 if (!((chip->id & ID_FAMILY_MASK) == ID_ADT75XX &&
1904 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)) {
1909 return sprintf(buf, "%d\n", data);
1912 static inline ssize_t adt7316_set_ad_bound(struct device *dev,
1913 struct device_attribute *attr,
1917 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1918 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1919 struct adt7316_chip_info *chip = iio_priv(dev_info);
1924 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1925 this_attr->address > ADT7316_EX_TEMP_LOW)
1928 ret = kstrtoint(buf, 10, &data);
1932 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX &&
1933 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0) {
1934 if (data > 255 || data < 0)
1937 if (data > 127 || data < -128)
1946 ret = chip->bus.write(chip->bus.client, this_attr->address, val);
1953 static ssize_t adt7316_show_int_enabled(struct device *dev,
1954 struct device_attribute *attr,
1957 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1958 struct adt7316_chip_info *chip = iio_priv(dev_info);
1960 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_INT_EN));
1963 static ssize_t adt7316_set_int_enabled(struct device *dev,
1964 struct device_attribute *attr,
1968 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1969 struct adt7316_chip_info *chip = iio_priv(dev_info);
1973 config1 = chip->config1 & (~ADT7316_INT_EN);
1975 config1 |= ADT7316_INT_EN;
1977 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
1981 chip->config1 = config1;
1986 static IIO_DEVICE_ATTR(int_mask,
1988 adt7316_show_int_mask, adt7316_set_int_mask,
1990 static IIO_DEVICE_ATTR(in_temp_high_value,
1992 adt7316_show_ad_bound, adt7316_set_ad_bound,
1993 ADT7316_IN_TEMP_HIGH);
1994 static IIO_DEVICE_ATTR(in_temp_low_value,
1996 adt7316_show_ad_bound, adt7316_set_ad_bound,
1997 ADT7316_IN_TEMP_LOW);
1998 static IIO_DEVICE_ATTR(ex_temp_high_value,
2000 adt7316_show_ad_bound, adt7316_set_ad_bound,
2001 ADT7316_EX_TEMP_HIGH);
2002 static IIO_DEVICE_ATTR(ex_temp_low_value,
2004 adt7316_show_ad_bound, adt7316_set_ad_bound,
2005 ADT7316_EX_TEMP_LOW);
2007 /* NASTY duplication to be fixed */
2008 static IIO_DEVICE_ATTR(ex_temp_ain1_high_value,
2010 adt7316_show_ad_bound, adt7316_set_ad_bound,
2011 ADT7316_EX_TEMP_HIGH);
2012 static IIO_DEVICE_ATTR(ex_temp_ain1_low_value,
2014 adt7316_show_ad_bound, adt7316_set_ad_bound,
2015 ADT7316_EX_TEMP_LOW);
2016 static IIO_DEVICE_ATTR(ain2_high_value,
2018 adt7316_show_ad_bound, adt7316_set_ad_bound,
2020 static IIO_DEVICE_ATTR(ain2_low_value,
2022 adt7316_show_ad_bound, adt7316_set_ad_bound,
2024 static IIO_DEVICE_ATTR(ain3_high_value,
2026 adt7316_show_ad_bound, adt7316_set_ad_bound,
2028 static IIO_DEVICE_ATTR(ain3_low_value,
2030 adt7316_show_ad_bound, adt7316_set_ad_bound,
2032 static IIO_DEVICE_ATTR(ain4_high_value,
2034 adt7316_show_ad_bound, adt7316_set_ad_bound,
2036 static IIO_DEVICE_ATTR(ain4_low_value,
2038 adt7316_show_ad_bound, adt7316_set_ad_bound,
2040 static IIO_DEVICE_ATTR(int_enabled,
2042 adt7316_show_int_enabled,
2043 adt7316_set_int_enabled, 0);
2045 static struct attribute *adt7316_event_attributes[] = {
2046 &iio_dev_attr_int_mask.dev_attr.attr,
2047 &iio_dev_attr_in_temp_high_value.dev_attr.attr,
2048 &iio_dev_attr_in_temp_low_value.dev_attr.attr,
2049 &iio_dev_attr_ex_temp_high_value.dev_attr.attr,
2050 &iio_dev_attr_ex_temp_low_value.dev_attr.attr,
2051 &iio_dev_attr_int_enabled.dev_attr.attr,
2055 static struct attribute_group adt7316_event_attribute_group = {
2056 .attrs = adt7316_event_attributes,
2060 static struct attribute *adt7516_event_attributes[] = {
2061 &iio_dev_attr_int_mask.dev_attr.attr,
2062 &iio_dev_attr_in_temp_high_value.dev_attr.attr,
2063 &iio_dev_attr_in_temp_low_value.dev_attr.attr,
2064 &iio_dev_attr_ex_temp_ain1_high_value.dev_attr.attr,
2065 &iio_dev_attr_ex_temp_ain1_low_value.dev_attr.attr,
2066 &iio_dev_attr_ain2_high_value.dev_attr.attr,
2067 &iio_dev_attr_ain2_low_value.dev_attr.attr,
2068 &iio_dev_attr_ain3_high_value.dev_attr.attr,
2069 &iio_dev_attr_ain3_low_value.dev_attr.attr,
2070 &iio_dev_attr_ain4_high_value.dev_attr.attr,
2071 &iio_dev_attr_ain4_low_value.dev_attr.attr,
2072 &iio_dev_attr_int_enabled.dev_attr.attr,
2076 static struct attribute_group adt7516_event_attribute_group = {
2077 .attrs = adt7516_event_attributes,
2081 #ifdef CONFIG_PM_SLEEP
2082 static int adt7316_disable(struct device *dev)
2084 struct iio_dev *dev_info = dev_get_drvdata(dev);
2085 struct adt7316_chip_info *chip = iio_priv(dev_info);
2087 return _adt7316_store_enabled(chip, 0);
2090 static int adt7316_enable(struct device *dev)
2092 struct iio_dev *dev_info = dev_get_drvdata(dev);
2093 struct adt7316_chip_info *chip = iio_priv(dev_info);
2095 return _adt7316_store_enabled(chip, 1);
2098 SIMPLE_DEV_PM_OPS(adt7316_pm_ops, adt7316_disable, adt7316_enable);
2099 EXPORT_SYMBOL_GPL(adt7316_pm_ops);
2102 static const struct iio_info adt7316_info = {
2103 .attrs = &adt7316_attribute_group,
2104 .event_attrs = &adt7316_event_attribute_group,
2105 .driver_module = THIS_MODULE,
2108 static const struct iio_info adt7516_info = {
2109 .attrs = &adt7516_attribute_group,
2110 .event_attrs = &adt7516_event_attribute_group,
2111 .driver_module = THIS_MODULE,
2115 * device probe and remove
2117 int adt7316_probe(struct device *dev, struct adt7316_bus *bus,
2120 struct adt7316_chip_info *chip;
2121 struct iio_dev *indio_dev;
2122 unsigned short *adt7316_platform_data = dev->platform_data;
2125 indio_dev = devm_iio_device_alloc(dev, sizeof(*chip));
2128 chip = iio_priv(indio_dev);
2129 /* this is only used for device removal purposes */
2130 dev_set_drvdata(dev, indio_dev);
2135 chip->id = ID_ADT7316 + (name[6] - '6');
2136 else if (name[4] == '5')
2137 chip->id = ID_ADT7516 + (name[6] - '6');
2141 chip->ldac_pin = adt7316_platform_data[1];
2142 if (chip->ldac_pin) {
2143 chip->config3 |= ADT7316_DA_EN_VIA_DAC_LDCA;
2144 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2145 chip->config1 |= ADT7516_SEL_AIN3;
2147 chip->int_mask = ADT7316_TEMP_INT_MASK | ADT7316_VDD_INT_MASK;
2148 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2149 chip->int_mask |= ADT7516_AIN_INT_MASK;
2151 indio_dev->dev.parent = dev;
2152 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2153 indio_dev->info = &adt7516_info;
2155 indio_dev->info = &adt7316_info;
2156 indio_dev->name = name;
2157 indio_dev->modes = INDIO_DIRECT_MODE;
2159 if (chip->bus.irq > 0) {
2160 if (adt7316_platform_data[0])
2161 chip->bus.irq_flags = adt7316_platform_data[0];
2163 ret = devm_request_threaded_irq(dev, chip->bus.irq,
2165 adt7316_event_handler,
2166 chip->bus.irq_flags |
2173 if (chip->bus.irq_flags & IRQF_TRIGGER_HIGH)
2174 chip->config1 |= ADT7316_INT_POLARITY;
2177 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, chip->config1);
2181 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, chip->config3);
2185 ret = devm_iio_device_register(dev, indio_dev);
2189 dev_info(dev, "%s temperature sensor, ADC and DAC registered.\n",
2194 EXPORT_SYMBOL(adt7316_probe);
2196 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
2197 MODULE_DESCRIPTION("Analog Devices ADT7316/7/8 and ADT7516/7/9 digital temperature sensor, ADC and DAC driver");
2198 MODULE_LICENSE("GPL v2");