1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * ADT7316 digital temperature sensor driver supporting ADT7316/7/8 ADT7516/7/9
4 *
5 * Copyright 2010 Analog Devices Inc.
6 */
7
8 #include <linux/interrupt.h>
9 #include <linux/gpio/consumer.h>
10 #include <linux/irq.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/i2c.h>
18 #include <linux/rtc.h>
19 #include <linux/module.h>
20
21 #include <linux/iio/iio.h>
22 #include <linux/iio/events.h>
23 #include <linux/iio/sysfs.h>
24 #include "adt7316.h"
25
26 /*
27 * ADT7316 registers definition
28 */
29 #define ADT7316_INT_STAT1 0x0
30 #define ADT7316_INT_STAT2 0x1
31 #define ADT7316_LSB_IN_TEMP_VDD 0x3
32 #define ADT7316_LSB_IN_TEMP_MASK 0x3
33 #define ADT7316_LSB_VDD_MASK 0xC
34 #define ADT7316_LSB_VDD_OFFSET 2
35 #define ADT7316_LSB_EX_TEMP_AIN 0x4
36 #define ADT7316_LSB_EX_TEMP_MASK 0x3
37 #define ADT7516_LSB_AIN_SHIFT 2
38 #define ADT7316_AD_MSB_DATA_BASE 0x6
39 #define ADT7316_AD_MSB_DATA_REGS 3
40 #define ADT7516_AD_MSB_DATA_REGS 6
41 #define ADT7316_MSB_VDD 0x6
42 #define ADT7316_MSB_IN_TEMP 0x7
43 #define ADT7316_MSB_EX_TEMP 0x8
44 #define ADT7516_MSB_AIN1 0x8
45 #define ADT7516_MSB_AIN2 0x9
46 #define ADT7516_MSB_AIN3 0xA
47 #define ADT7516_MSB_AIN4 0xB
48 #define ADT7316_DA_DATA_BASE 0x10
49 #define ADT7316_DA_10_BIT_LSB_SHIFT 6
50 #define ADT7316_DA_12_BIT_LSB_SHIFT 4
51 #define ADT7316_DA_MSB_DATA_REGS 4
52 #define ADT7316_LSB_DAC_A 0x10
53 #define ADT7316_MSB_DAC_A 0x11
54 #define ADT7316_LSB_DAC_B 0x12
55 #define ADT7316_MSB_DAC_B 0x13
56 #define ADT7316_LSB_DAC_C 0x14
57 #define ADT7316_MSB_DAC_C 0x15
58 #define ADT7316_LSB_DAC_D 0x16
59 #define ADT7316_MSB_DAC_D 0x17
60 #define ADT7316_CONFIG1 0x18
61 #define ADT7316_CONFIG2 0x19
62 #define ADT7316_CONFIG3 0x1A
63 #define ADT7316_DAC_CONFIG 0x1B
64 #define ADT7316_LDAC_CONFIG 0x1C
65 #define ADT7316_INT_MASK1 0x1D
66 #define ADT7316_INT_MASK2 0x1E
67 #define ADT7316_IN_TEMP_OFFSET 0x1F
68 #define ADT7316_EX_TEMP_OFFSET 0x20
69 #define ADT7316_IN_ANALOG_TEMP_OFFSET 0x21
70 #define ADT7316_EX_ANALOG_TEMP_OFFSET 0x22
71 #define ADT7316_VDD_HIGH 0x23
72 #define ADT7316_VDD_LOW 0x24
73 #define ADT7316_IN_TEMP_HIGH 0x25
74 #define ADT7316_IN_TEMP_LOW 0x26
75 #define ADT7316_EX_TEMP_HIGH 0x27
76 #define ADT7316_EX_TEMP_LOW 0x28
77 #define ADT7516_AIN2_HIGH 0x2B
78 #define ADT7516_AIN2_LOW 0x2C
79 #define ADT7516_AIN3_HIGH 0x2D
80 #define ADT7516_AIN3_LOW 0x2E
81 #define ADT7516_AIN4_HIGH 0x2F
82 #define ADT7516_AIN4_LOW 0x30
83 #define ADT7316_DEVICE_ID 0x4D
84 #define ADT7316_MANUFACTURE_ID 0x4E
85 #define ADT7316_DEVICE_REV 0x4F
86 #define ADT7316_SPI_LOCK_STAT 0x7F
87
88 /*
89 * ADT7316 config1
90 */
91 #define ADT7316_EN 0x1
92 #define ADT7516_SEL_EX_TEMP 0x4
93 #define ADT7516_SEL_AIN1_2_EX_TEMP_MASK 0x6
94 #define ADT7516_SEL_AIN3 0x8
95 #define ADT7316_INT_EN 0x20
96 #define ADT7316_INT_POLARITY 0x40
97 #define ADT7316_PD 0x80
98
99 /*
100 * ADT7316 config2
101 */
102 #define ADT7316_AD_SINGLE_CH_MASK 0x3
103 #define ADT7516_AD_SINGLE_CH_MASK 0x7
104 #define ADT7316_AD_SINGLE_CH_VDD 0
105 #define ADT7316_AD_SINGLE_CH_IN 1
106 #define ADT7316_AD_SINGLE_CH_EX 2
107 #define ADT7516_AD_SINGLE_CH_AIN1 2
108 #define ADT7516_AD_SINGLE_CH_AIN2 3
109 #define ADT7516_AD_SINGLE_CH_AIN3 4
110 #define ADT7516_AD_SINGLE_CH_AIN4 5
111 #define ADT7316_AD_SINGLE_CH_MODE 0x10
112 #define ADT7316_DISABLE_AVERAGING 0x20
113 #define ADT7316_EN_SMBUS_TIMEOUT 0x40
114 #define ADT7316_RESET 0x80
115
116 /*
117 * ADT7316 config3
118 */
119 #define ADT7316_ADCLK_22_5 0x1
120 #define ADT7316_DA_HIGH_RESOLUTION 0x2
121 #define ADT7316_DA_EN_VIA_DAC_LDAC 0x8
122 #define ADT7516_AIN_IN_VREF 0x10
123 #define ADT7316_EN_IN_TEMP_PROP_DACA 0x20
124 #define ADT7316_EN_EX_TEMP_PROP_DACB 0x40
125
126 /*
127 * ADT7316 DAC config
128 */
129 #define ADT7316_DA_2VREF_CH_MASK 0xF
130 #define ADT7316_DA_EN_MODE_MASK 0x30
131 #define ADT7316_DA_EN_MODE_SHIFT 4
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
138
139 /*
140 * ADT7316 LDAC config
141 */
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
148
149 /*
150 * ADT7316 INT_MASK2
151 */
152 #define ADT7316_INT_MASK2_VDD 0x10
153
154 /*
155 * ADT7316 value masks
156 */
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
161
162 /*
163 * Chip ID
164 */
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
171
172 #define ID_FAMILY_MASK 0xF0
173 #define ID_ADT73XX 0x0
174 #define ID_ADT75XX 0x10
175
176 /*
177 * struct adt7316_chip_info - chip specific information
178 */
179
180 struct adt7316_chip_info {
181 struct adt7316_bus bus;
182 struct gpio_desc *ldac_pin;
183 u16 int_mask; /* 0x2f */
184 u8 config1;
185 u8 config2;
186 u8 config3;
187 u8 dac_config; /* DAC config */
188 u8 ldac_config; /* LDAC config */
189 u8 dac_bits; /* 8, 10, 12 */
190 u8 id; /* chip id */
191 };
192
193 /*
194 * Logic interrupt mask for user application to enable
195 * interrupts.
196 */
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)
211
adt7316_show_enabled(struct device * dev,struct device_attribute * attr,char * buf)212 static ssize_t adt7316_show_enabled(struct device *dev,
213 struct device_attribute *attr,
214 char *buf)
215 {
216 struct iio_dev *dev_info = dev_to_iio_dev(dev);
217 struct adt7316_chip_info *chip = iio_priv(dev_info);
218
219 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_EN));
220 }
221
_adt7316_store_enabled(struct adt7316_chip_info * chip,int enable)222 static ssize_t _adt7316_store_enabled(struct adt7316_chip_info *chip,
223 int enable)
224 {
225 u8 config1;
226 int ret;
227
228 if (enable)
229 config1 = chip->config1 | ADT7316_EN;
230 else
231 config1 = chip->config1 & ~ADT7316_EN;
232
233 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
234 if (ret)
235 return -EIO;
236
237 chip->config1 = config1;
238
239 return ret;
240 }
241
adt7316_store_enabled(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)242 static ssize_t adt7316_store_enabled(struct device *dev,
243 struct device_attribute *attr,
244 const char *buf,
245 size_t len)
246 {
247 struct iio_dev *dev_info = dev_to_iio_dev(dev);
248 struct adt7316_chip_info *chip = iio_priv(dev_info);
249 int enable;
250
251 if (buf[0] == '1')
252 enable = 1;
253 else
254 enable = 0;
255
256 if (_adt7316_store_enabled(chip, enable) < 0)
257 return -EIO;
258
259 return len;
260 }
261
262 static IIO_DEVICE_ATTR(enabled, 0644,
263 adt7316_show_enabled,
264 adt7316_store_enabled,
265 0);
266
adt7316_show_select_ex_temp(struct device * dev,struct device_attribute * attr,char * buf)267 static ssize_t adt7316_show_select_ex_temp(struct device *dev,
268 struct device_attribute *attr,
269 char *buf)
270 {
271 struct iio_dev *dev_info = dev_to_iio_dev(dev);
272 struct adt7316_chip_info *chip = iio_priv(dev_info);
273
274 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
275 return -EPERM;
276
277 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7516_SEL_EX_TEMP));
278 }
279
adt7316_store_select_ex_temp(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)280 static ssize_t adt7316_store_select_ex_temp(struct device *dev,
281 struct device_attribute *attr,
282 const char *buf,
283 size_t len)
284 {
285 struct iio_dev *dev_info = dev_to_iio_dev(dev);
286 struct adt7316_chip_info *chip = iio_priv(dev_info);
287 u8 config1;
288 int ret;
289
290 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
291 return -EPERM;
292
293 config1 = chip->config1 & (~ADT7516_SEL_EX_TEMP);
294 if (buf[0] == '1')
295 config1 |= ADT7516_SEL_EX_TEMP;
296
297 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
298 if (ret)
299 return -EIO;
300
301 chip->config1 = config1;
302
303 return len;
304 }
305
306 static IIO_DEVICE_ATTR(select_ex_temp, 0644,
307 adt7316_show_select_ex_temp,
308 adt7316_store_select_ex_temp,
309 0);
310
adt7316_show_mode(struct device * dev,struct device_attribute * attr,char * buf)311 static ssize_t adt7316_show_mode(struct device *dev,
312 struct device_attribute *attr,
313 char *buf)
314 {
315 struct iio_dev *dev_info = dev_to_iio_dev(dev);
316 struct adt7316_chip_info *chip = iio_priv(dev_info);
317
318 if (chip->config2 & ADT7316_AD_SINGLE_CH_MODE)
319 return sprintf(buf, "single_channel\n");
320
321 return sprintf(buf, "round_robin\n");
322 }
323
adt7316_store_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)324 static ssize_t adt7316_store_mode(struct device *dev,
325 struct device_attribute *attr,
326 const char *buf,
327 size_t len)
328 {
329 struct iio_dev *dev_info = dev_to_iio_dev(dev);
330 struct adt7316_chip_info *chip = iio_priv(dev_info);
331 u8 config2;
332 int ret;
333
334 config2 = chip->config2 & (~ADT7316_AD_SINGLE_CH_MODE);
335 if (!memcmp(buf, "single_channel", 14))
336 config2 |= ADT7316_AD_SINGLE_CH_MODE;
337
338 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
339 if (ret)
340 return -EIO;
341
342 chip->config2 = config2;
343
344 return len;
345 }
346
347 static IIO_DEVICE_ATTR(mode, 0644,
348 adt7316_show_mode,
349 adt7316_store_mode,
350 0);
351
adt7316_show_all_modes(struct device * dev,struct device_attribute * attr,char * buf)352 static ssize_t adt7316_show_all_modes(struct device *dev,
353 struct device_attribute *attr,
354 char *buf)
355 {
356 return sprintf(buf, "single_channel\nround_robin\n");
357 }
358
359 static IIO_DEVICE_ATTR(all_modes, 0444, adt7316_show_all_modes, NULL, 0);
360
adt7316_show_ad_channel(struct device * dev,struct device_attribute * attr,char * buf)361 static ssize_t adt7316_show_ad_channel(struct device *dev,
362 struct device_attribute *attr,
363 char *buf)
364 {
365 struct iio_dev *dev_info = dev_to_iio_dev(dev);
366 struct adt7316_chip_info *chip = iio_priv(dev_info);
367
368 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
369 return -EPERM;
370
371 switch (chip->config2 & ADT7516_AD_SINGLE_CH_MASK) {
372 case ADT7316_AD_SINGLE_CH_VDD:
373 return sprintf(buf, "0 - VDD\n");
374 case ADT7316_AD_SINGLE_CH_IN:
375 return sprintf(buf, "1 - Internal Temperature\n");
376 case ADT7316_AD_SINGLE_CH_EX:
377 if (((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) &&
378 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)
379 return sprintf(buf, "2 - AIN1\n");
380
381 return sprintf(buf, "2 - External Temperature\n");
382 case ADT7516_AD_SINGLE_CH_AIN2:
383 if ((chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)
384 return sprintf(buf, "3 - AIN2\n");
385
386 return sprintf(buf, "N/A\n");
387 case ADT7516_AD_SINGLE_CH_AIN3:
388 if (chip->config1 & ADT7516_SEL_AIN3)
389 return sprintf(buf, "4 - AIN3\n");
390
391 return sprintf(buf, "N/A\n");
392 case ADT7516_AD_SINGLE_CH_AIN4:
393 return sprintf(buf, "5 - AIN4\n");
394 default:
395 return sprintf(buf, "N/A\n");
396 }
397 }
398
adt7316_store_ad_channel(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)399 static ssize_t adt7316_store_ad_channel(struct device *dev,
400 struct device_attribute *attr,
401 const char *buf,
402 size_t len)
403 {
404 struct iio_dev *dev_info = dev_to_iio_dev(dev);
405 struct adt7316_chip_info *chip = iio_priv(dev_info);
406 u8 config2;
407 u8 data;
408 int ret;
409
410 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
411 return -EPERM;
412
413 ret = kstrtou8(buf, 10, &data);
414 if (ret)
415 return -EINVAL;
416
417 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) {
418 if (data > 5)
419 return -EINVAL;
420
421 config2 = chip->config2 & (~ADT7516_AD_SINGLE_CH_MASK);
422 } else {
423 if (data > 2)
424 return -EINVAL;
425
426 config2 = chip->config2 & (~ADT7316_AD_SINGLE_CH_MASK);
427 }
428
429 config2 |= data;
430
431 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
432 if (ret)
433 return -EIO;
434
435 chip->config2 = config2;
436
437 return len;
438 }
439
440 static IIO_DEVICE_ATTR(ad_channel, 0644,
441 adt7316_show_ad_channel,
442 adt7316_store_ad_channel,
443 0);
444
adt7316_show_all_ad_channels(struct device * dev,struct device_attribute * attr,char * buf)445 static ssize_t adt7316_show_all_ad_channels(struct device *dev,
446 struct device_attribute *attr,
447 char *buf)
448 {
449 struct iio_dev *dev_info = dev_to_iio_dev(dev);
450 struct adt7316_chip_info *chip = iio_priv(dev_info);
451
452 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
453 return -EPERM;
454
455 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
456 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
457 "2 - External Temperature or AIN1\n"
458 "3 - AIN2\n4 - AIN3\n5 - AIN4\n");
459 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
460 "2 - External Temperature\n");
461 }
462
463 static IIO_DEVICE_ATTR(all_ad_channels, 0444,
464 adt7316_show_all_ad_channels, NULL, 0);
465
adt7316_show_disable_averaging(struct device * dev,struct device_attribute * attr,char * buf)466 static ssize_t adt7316_show_disable_averaging(struct device *dev,
467 struct device_attribute *attr,
468 char *buf)
469 {
470 struct iio_dev *dev_info = dev_to_iio_dev(dev);
471 struct adt7316_chip_info *chip = iio_priv(dev_info);
472
473 return sprintf(buf, "%d\n",
474 !!(chip->config2 & ADT7316_DISABLE_AVERAGING));
475 }
476
adt7316_store_disable_averaging(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)477 static ssize_t adt7316_store_disable_averaging(struct device *dev,
478 struct device_attribute *attr,
479 const char *buf,
480 size_t len)
481 {
482 struct iio_dev *dev_info = dev_to_iio_dev(dev);
483 struct adt7316_chip_info *chip = iio_priv(dev_info);
484 u8 config2;
485 int ret;
486
487 config2 = chip->config2 & (~ADT7316_DISABLE_AVERAGING);
488 if (buf[0] == '1')
489 config2 |= ADT7316_DISABLE_AVERAGING;
490
491 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
492 if (ret)
493 return -EIO;
494
495 chip->config2 = config2;
496
497 return len;
498 }
499
500 static IIO_DEVICE_ATTR(disable_averaging, 0644,
501 adt7316_show_disable_averaging,
502 adt7316_store_disable_averaging,
503 0);
504
adt7316_show_enable_smbus_timeout(struct device * dev,struct device_attribute * attr,char * buf)505 static ssize_t adt7316_show_enable_smbus_timeout(struct device *dev,
506 struct device_attribute *attr,
507 char *buf)
508 {
509 struct iio_dev *dev_info = dev_to_iio_dev(dev);
510 struct adt7316_chip_info *chip = iio_priv(dev_info);
511
512 return sprintf(buf, "%d\n",
513 !!(chip->config2 & ADT7316_EN_SMBUS_TIMEOUT));
514 }
515
adt7316_store_enable_smbus_timeout(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)516 static ssize_t adt7316_store_enable_smbus_timeout(struct device *dev,
517 struct device_attribute *attr,
518 const char *buf,
519 size_t len)
520 {
521 struct iio_dev *dev_info = dev_to_iio_dev(dev);
522 struct adt7316_chip_info *chip = iio_priv(dev_info);
523 u8 config2;
524 int ret;
525
526 config2 = chip->config2 & (~ADT7316_EN_SMBUS_TIMEOUT);
527 if (buf[0] == '1')
528 config2 |= ADT7316_EN_SMBUS_TIMEOUT;
529
530 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
531 if (ret)
532 return -EIO;
533
534 chip->config2 = config2;
535
536 return len;
537 }
538
539 static IIO_DEVICE_ATTR(enable_smbus_timeout, 0644,
540 adt7316_show_enable_smbus_timeout,
541 adt7316_store_enable_smbus_timeout,
542 0);
543
adt7316_show_powerdown(struct device * dev,struct device_attribute * attr,char * buf)544 static ssize_t adt7316_show_powerdown(struct device *dev,
545 struct device_attribute *attr,
546 char *buf)
547 {
548 struct iio_dev *dev_info = dev_to_iio_dev(dev);
549 struct adt7316_chip_info *chip = iio_priv(dev_info);
550
551 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_PD));
552 }
553
adt7316_store_powerdown(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)554 static ssize_t adt7316_store_powerdown(struct device *dev,
555 struct device_attribute *attr,
556 const char *buf,
557 size_t len)
558 {
559 struct iio_dev *dev_info = dev_to_iio_dev(dev);
560 struct adt7316_chip_info *chip = iio_priv(dev_info);
561 u8 config1;
562 int ret;
563
564 config1 = chip->config1 & (~ADT7316_PD);
565 if (buf[0] == '1')
566 config1 |= ADT7316_PD;
567
568 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
569 if (ret)
570 return -EIO;
571
572 chip->config1 = config1;
573
574 return len;
575 }
576
577 static IIO_DEVICE_ATTR(powerdown, 0644,
578 adt7316_show_powerdown,
579 adt7316_store_powerdown,
580 0);
581
adt7316_show_fast_ad_clock(struct device * dev,struct device_attribute * attr,char * buf)582 static ssize_t adt7316_show_fast_ad_clock(struct device *dev,
583 struct device_attribute *attr,
584 char *buf)
585 {
586 struct iio_dev *dev_info = dev_to_iio_dev(dev);
587 struct adt7316_chip_info *chip = iio_priv(dev_info);
588
589 return sprintf(buf, "%d\n", !!(chip->config3 & ADT7316_ADCLK_22_5));
590 }
591
adt7316_store_fast_ad_clock(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)592 static ssize_t adt7316_store_fast_ad_clock(struct device *dev,
593 struct device_attribute *attr,
594 const char *buf,
595 size_t len)
596 {
597 struct iio_dev *dev_info = dev_to_iio_dev(dev);
598 struct adt7316_chip_info *chip = iio_priv(dev_info);
599 u8 config3;
600 int ret;
601
602 config3 = chip->config3 & (~ADT7316_ADCLK_22_5);
603 if (buf[0] == '1')
604 config3 |= ADT7316_ADCLK_22_5;
605
606 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
607 if (ret)
608 return -EIO;
609
610 chip->config3 = config3;
611
612 return len;
613 }
614
615 static IIO_DEVICE_ATTR(fast_ad_clock, 0644,
616 adt7316_show_fast_ad_clock,
617 adt7316_store_fast_ad_clock,
618 0);
619
adt7316_show_da_high_resolution(struct device * dev,struct device_attribute * attr,char * buf)620 static ssize_t adt7316_show_da_high_resolution(struct device *dev,
621 struct device_attribute *attr,
622 char *buf)
623 {
624 struct iio_dev *dev_info = dev_to_iio_dev(dev);
625 struct adt7316_chip_info *chip = iio_priv(dev_info);
626
627 if (chip->config3 & ADT7316_DA_HIGH_RESOLUTION) {
628 if (chip->id != ID_ADT7318 && chip->id != ID_ADT7519)
629 return sprintf(buf, "1 (10 bits)\n");
630 }
631
632 return sprintf(buf, "0 (8 bits)\n");
633 }
634
adt7316_store_da_high_resolution(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)635 static ssize_t adt7316_store_da_high_resolution(struct device *dev,
636 struct device_attribute *attr,
637 const char *buf,
638 size_t len)
639 {
640 struct iio_dev *dev_info = dev_to_iio_dev(dev);
641 struct adt7316_chip_info *chip = iio_priv(dev_info);
642 u8 config3;
643 int ret;
644
645 if (chip->id == ID_ADT7318 || chip->id == ID_ADT7519)
646 return -EPERM;
647
648 config3 = chip->config3 & (~ADT7316_DA_HIGH_RESOLUTION);
649 if (buf[0] == '1')
650 config3 |= ADT7316_DA_HIGH_RESOLUTION;
651
652 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
653 if (ret)
654 return -EIO;
655
656 chip->config3 = config3;
657
658 return len;
659 }
660
661 static IIO_DEVICE_ATTR(da_high_resolution, 0644,
662 adt7316_show_da_high_resolution,
663 adt7316_store_da_high_resolution,
664 0);
665
adt7316_show_AIN_internal_Vref(struct device * dev,struct device_attribute * attr,char * buf)666 static ssize_t adt7316_show_AIN_internal_Vref(struct device *dev,
667 struct device_attribute *attr,
668 char *buf)
669 {
670 struct iio_dev *dev_info = dev_to_iio_dev(dev);
671 struct adt7316_chip_info *chip = iio_priv(dev_info);
672
673 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
674 return -EPERM;
675
676 return sprintf(buf, "%d\n",
677 !!(chip->config3 & ADT7516_AIN_IN_VREF));
678 }
679
adt7316_store_AIN_internal_Vref(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)680 static ssize_t adt7316_store_AIN_internal_Vref(struct device *dev,
681 struct device_attribute *attr,
682 const char *buf,
683 size_t len)
684 {
685 struct iio_dev *dev_info = dev_to_iio_dev(dev);
686 struct adt7316_chip_info *chip = iio_priv(dev_info);
687 u8 config3;
688 int ret;
689
690 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
691 return -EPERM;
692
693 if (buf[0] != '1')
694 config3 = chip->config3 & (~ADT7516_AIN_IN_VREF);
695 else
696 config3 = chip->config3 | ADT7516_AIN_IN_VREF;
697
698 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
699 if (ret)
700 return -EIO;
701
702 chip->config3 = config3;
703
704 return len;
705 }
706
707 static IIO_DEVICE_ATTR(AIN_internal_Vref, 0644,
708 adt7316_show_AIN_internal_Vref,
709 adt7316_store_AIN_internal_Vref,
710 0);
711
adt7316_show_enable_prop_DACA(struct device * dev,struct device_attribute * attr,char * buf)712 static ssize_t adt7316_show_enable_prop_DACA(struct device *dev,
713 struct device_attribute *attr,
714 char *buf)
715 {
716 struct iio_dev *dev_info = dev_to_iio_dev(dev);
717 struct adt7316_chip_info *chip = iio_priv(dev_info);
718
719 return sprintf(buf, "%d\n",
720 !!(chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA));
721 }
722
adt7316_store_enable_prop_DACA(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)723 static ssize_t adt7316_store_enable_prop_DACA(struct device *dev,
724 struct device_attribute *attr,
725 const char *buf,
726 size_t len)
727 {
728 struct iio_dev *dev_info = dev_to_iio_dev(dev);
729 struct adt7316_chip_info *chip = iio_priv(dev_info);
730 u8 config3;
731 int ret;
732
733 config3 = chip->config3 & (~ADT7316_EN_IN_TEMP_PROP_DACA);
734 if (buf[0] == '1')
735 config3 |= ADT7316_EN_IN_TEMP_PROP_DACA;
736
737 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
738 if (ret)
739 return -EIO;
740
741 chip->config3 = config3;
742
743 return len;
744 }
745
746 static IIO_DEVICE_ATTR(enable_proportion_DACA, 0644,
747 adt7316_show_enable_prop_DACA,
748 adt7316_store_enable_prop_DACA,
749 0);
750
adt7316_show_enable_prop_DACB(struct device * dev,struct device_attribute * attr,char * buf)751 static ssize_t adt7316_show_enable_prop_DACB(struct device *dev,
752 struct device_attribute *attr,
753 char *buf)
754 {
755 struct iio_dev *dev_info = dev_to_iio_dev(dev);
756 struct adt7316_chip_info *chip = iio_priv(dev_info);
757
758 return sprintf(buf, "%d\n",
759 !!(chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB));
760 }
761
adt7316_store_enable_prop_DACB(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)762 static ssize_t adt7316_store_enable_prop_DACB(struct device *dev,
763 struct device_attribute *attr,
764 const char *buf,
765 size_t len)
766 {
767 struct iio_dev *dev_info = dev_to_iio_dev(dev);
768 struct adt7316_chip_info *chip = iio_priv(dev_info);
769 u8 config3;
770 int ret;
771
772 config3 = chip->config3 & (~ADT7316_EN_EX_TEMP_PROP_DACB);
773 if (buf[0] == '1')
774 config3 |= ADT7316_EN_EX_TEMP_PROP_DACB;
775
776 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
777 if (ret)
778 return -EIO;
779
780 chip->config3 = config3;
781
782 return len;
783 }
784
785 static IIO_DEVICE_ATTR(enable_proportion_DACB, 0644,
786 adt7316_show_enable_prop_DACB,
787 adt7316_store_enable_prop_DACB,
788 0);
789
adt7316_show_DAC_2Vref_ch_mask(struct device * dev,struct device_attribute * attr,char * buf)790 static ssize_t adt7316_show_DAC_2Vref_ch_mask(struct device *dev,
791 struct device_attribute *attr,
792 char *buf)
793 {
794 struct iio_dev *dev_info = dev_to_iio_dev(dev);
795 struct adt7316_chip_info *chip = iio_priv(dev_info);
796
797 return sprintf(buf, "0x%x\n",
798 chip->dac_config & ADT7316_DA_2VREF_CH_MASK);
799 }
800
adt7316_store_DAC_2Vref_ch_mask(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)801 static ssize_t adt7316_store_DAC_2Vref_ch_mask(struct device *dev,
802 struct device_attribute *attr,
803 const char *buf,
804 size_t len)
805 {
806 struct iio_dev *dev_info = dev_to_iio_dev(dev);
807 struct adt7316_chip_info *chip = iio_priv(dev_info);
808 u8 dac_config;
809 u8 data;
810 int ret;
811
812 ret = kstrtou8(buf, 16, &data);
813 if (ret || data > ADT7316_DA_2VREF_CH_MASK)
814 return -EINVAL;
815
816 dac_config = chip->dac_config & (~ADT7316_DA_2VREF_CH_MASK);
817 dac_config |= data;
818
819 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
820 if (ret)
821 return -EIO;
822
823 chip->dac_config = dac_config;
824
825 return len;
826 }
827
828 static IIO_DEVICE_ATTR(DAC_2Vref_channels_mask, 0644,
829 adt7316_show_DAC_2Vref_ch_mask,
830 adt7316_store_DAC_2Vref_ch_mask,
831 0);
832
adt7316_show_DAC_update_mode(struct device * dev,struct device_attribute * attr,char * buf)833 static ssize_t adt7316_show_DAC_update_mode(struct device *dev,
834 struct device_attribute *attr,
835 char *buf)
836 {
837 struct iio_dev *dev_info = dev_to_iio_dev(dev);
838 struct adt7316_chip_info *chip = iio_priv(dev_info);
839
840 if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDAC))
841 return sprintf(buf, "manual\n");
842
843 switch (chip->dac_config & ADT7316_DA_EN_MODE_MASK) {
844 case ADT7316_DA_EN_MODE_SINGLE:
845 return sprintf(buf,
846 "0 - auto at any MSB DAC writing\n");
847 case ADT7316_DA_EN_MODE_AB_CD:
848 return sprintf(buf,
849 "1 - auto at MSB DAC AB and CD writing\n");
850 case ADT7316_DA_EN_MODE_ABCD:
851 return sprintf(buf,
852 "2 - auto at MSB DAC ABCD writing\n");
853 default: /* ADT7316_DA_EN_MODE_LDAC */
854 return sprintf(buf, "3 - manual\n");
855 }
856 }
857
adt7316_store_DAC_update_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)858 static ssize_t adt7316_store_DAC_update_mode(struct device *dev,
859 struct device_attribute *attr,
860 const char *buf,
861 size_t len)
862 {
863 struct iio_dev *dev_info = dev_to_iio_dev(dev);
864 struct adt7316_chip_info *chip = iio_priv(dev_info);
865 u8 dac_config;
866 u8 data;
867 int ret;
868
869 if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDAC))
870 return -EPERM;
871
872 ret = kstrtou8(buf, 10, &data);
873 if (ret || data > (ADT7316_DA_EN_MODE_MASK >> ADT7316_DA_EN_MODE_SHIFT))
874 return -EINVAL;
875
876 dac_config = chip->dac_config & (~ADT7316_DA_EN_MODE_MASK);
877 dac_config |= data << ADT7316_DA_EN_MODE_SHIFT;
878
879 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
880 if (ret)
881 return -EIO;
882
883 chip->dac_config = dac_config;
884
885 return len;
886 }
887
888 static IIO_DEVICE_ATTR(DAC_update_mode, 0644,
889 adt7316_show_DAC_update_mode,
890 adt7316_store_DAC_update_mode,
891 0);
892
adt7316_show_all_DAC_update_modes(struct device * dev,struct device_attribute * attr,char * buf)893 static ssize_t adt7316_show_all_DAC_update_modes(struct device *dev,
894 struct device_attribute *attr,
895 char *buf)
896 {
897 struct iio_dev *dev_info = dev_to_iio_dev(dev);
898 struct adt7316_chip_info *chip = iio_priv(dev_info);
899
900 if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDAC)
901 return sprintf(buf, "0 - auto at any MSB DAC writing\n"
902 "1 - auto at MSB DAC AB and CD writing\n"
903 "2 - auto at MSB DAC ABCD writing\n"
904 "3 - manual\n");
905 return sprintf(buf, "manual\n");
906 }
907
908 static IIO_DEVICE_ATTR(all_DAC_update_modes, 0444,
909 adt7316_show_all_DAC_update_modes, NULL, 0);
910
adt7316_store_update_DAC(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)911 static ssize_t adt7316_store_update_DAC(struct device *dev,
912 struct device_attribute *attr,
913 const char *buf,
914 size_t len)
915 {
916 struct iio_dev *dev_info = dev_to_iio_dev(dev);
917 struct adt7316_chip_info *chip = iio_priv(dev_info);
918 u8 ldac_config;
919 u8 data;
920 int ret;
921
922 if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDAC) {
923 if ((chip->dac_config & ADT7316_DA_EN_MODE_MASK) !=
924 ADT7316_DA_EN_MODE_LDAC)
925 return -EPERM;
926
927 ret = kstrtou8(buf, 16, &data);
928 if (ret || data > ADT7316_LDAC_EN_DA_MASK)
929 return -EINVAL;
930
931 ldac_config = chip->ldac_config & (~ADT7316_LDAC_EN_DA_MASK);
932 ldac_config |= data;
933
934 ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG,
935 ldac_config);
936 if (ret)
937 return -EIO;
938 } else {
939 gpiod_set_value(chip->ldac_pin, 0);
940 gpiod_set_value(chip->ldac_pin, 1);
941 }
942
943 return len;
944 }
945
946 static IIO_DEVICE_ATTR(update_DAC, 0644,
947 NULL,
948 adt7316_store_update_DAC,
949 0);
950
adt7316_show_DA_AB_Vref_bypass(struct device * dev,struct device_attribute * attr,char * buf)951 static ssize_t adt7316_show_DA_AB_Vref_bypass(struct device *dev,
952 struct device_attribute *attr,
953 char *buf)
954 {
955 struct iio_dev *dev_info = dev_to_iio_dev(dev);
956 struct adt7316_chip_info *chip = iio_priv(dev_info);
957
958 return sprintf(buf, "%d\n",
959 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_AB));
960 }
961
adt7316_store_DA_AB_Vref_bypass(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)962 static ssize_t adt7316_store_DA_AB_Vref_bypass(struct device *dev,
963 struct device_attribute *attr,
964 const char *buf,
965 size_t len)
966 {
967 struct iio_dev *dev_info = dev_to_iio_dev(dev);
968 struct adt7316_chip_info *chip = iio_priv(dev_info);
969 u8 dac_config;
970 int ret;
971
972 dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_AB);
973 if (buf[0] == '1')
974 dac_config |= ADT7316_VREF_BYPASS_DAC_AB;
975
976 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
977 if (ret)
978 return -EIO;
979
980 chip->dac_config = dac_config;
981
982 return len;
983 }
984
985 static IIO_DEVICE_ATTR(DA_AB_Vref_bypass, 0644,
986 adt7316_show_DA_AB_Vref_bypass,
987 adt7316_store_DA_AB_Vref_bypass,
988 0);
989
adt7316_show_DA_CD_Vref_bypass(struct device * dev,struct device_attribute * attr,char * buf)990 static ssize_t adt7316_show_DA_CD_Vref_bypass(struct device *dev,
991 struct device_attribute *attr,
992 char *buf)
993 {
994 struct iio_dev *dev_info = dev_to_iio_dev(dev);
995 struct adt7316_chip_info *chip = iio_priv(dev_info);
996
997 return sprintf(buf, "%d\n",
998 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_CD));
999 }
1000
adt7316_store_DA_CD_Vref_bypass(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1001 static ssize_t adt7316_store_DA_CD_Vref_bypass(struct device *dev,
1002 struct device_attribute *attr,
1003 const char *buf,
1004 size_t len)
1005 {
1006 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1007 struct adt7316_chip_info *chip = iio_priv(dev_info);
1008 u8 dac_config;
1009 int ret;
1010
1011 dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_CD);
1012 if (buf[0] == '1')
1013 dac_config |= ADT7316_VREF_BYPASS_DAC_CD;
1014
1015 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
1016 if (ret)
1017 return -EIO;
1018
1019 chip->dac_config = dac_config;
1020
1021 return len;
1022 }
1023
1024 static IIO_DEVICE_ATTR(DA_CD_Vref_bypass, 0644,
1025 adt7316_show_DA_CD_Vref_bypass,
1026 adt7316_store_DA_CD_Vref_bypass,
1027 0);
1028
adt7316_show_DAC_internal_Vref(struct device * dev,struct device_attribute * attr,char * buf)1029 static ssize_t adt7316_show_DAC_internal_Vref(struct device *dev,
1030 struct device_attribute *attr,
1031 char *buf)
1032 {
1033 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1034 struct adt7316_chip_info *chip = iio_priv(dev_info);
1035
1036 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1037 return sprintf(buf, "0x%x\n",
1038 (chip->ldac_config & ADT7516_DAC_IN_VREF_MASK) >>
1039 ADT7516_DAC_IN_VREF_OFFSET);
1040 return sprintf(buf, "%d\n",
1041 !!(chip->ldac_config & ADT7316_DAC_IN_VREF));
1042 }
1043
adt7316_store_DAC_internal_Vref(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1044 static ssize_t adt7316_store_DAC_internal_Vref(struct device *dev,
1045 struct device_attribute *attr,
1046 const char *buf,
1047 size_t len)
1048 {
1049 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1050 struct adt7316_chip_info *chip = iio_priv(dev_info);
1051 u8 ldac_config;
1052 u8 data;
1053 int ret;
1054
1055 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) {
1056 ret = kstrtou8(buf, 16, &data);
1057 if (ret || data > 3)
1058 return -EINVAL;
1059
1060 ldac_config = chip->ldac_config & (~ADT7516_DAC_IN_VREF_MASK);
1061 if (data & 0x1)
1062 ldac_config |= ADT7516_DAC_AB_IN_VREF;
1063 if (data & 0x2)
1064 ldac_config |= ADT7516_DAC_CD_IN_VREF;
1065 } else {
1066 ret = kstrtou8(buf, 16, &data);
1067 if (ret)
1068 return -EINVAL;
1069
1070 ldac_config = chip->ldac_config & (~ADT7316_DAC_IN_VREF);
1071 if (data)
1072 ldac_config = chip->ldac_config | ADT7316_DAC_IN_VREF;
1073 }
1074
1075 ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG,
1076 ldac_config);
1077 if (ret)
1078 return -EIO;
1079
1080 chip->ldac_config = ldac_config;
1081
1082 return len;
1083 }
1084
1085 static IIO_DEVICE_ATTR(DAC_internal_Vref, 0644,
1086 adt7316_show_DAC_internal_Vref,
1087 adt7316_store_DAC_internal_Vref,
1088 0);
1089
adt7316_show_ad(struct adt7316_chip_info * chip,int channel,char * buf)1090 static ssize_t adt7316_show_ad(struct adt7316_chip_info *chip,
1091 int channel, char *buf)
1092 {
1093 u16 data;
1094 u8 msb, lsb;
1095 char sign = ' ';
1096 int ret;
1097
1098 if ((chip->config2 & ADT7316_AD_SINGLE_CH_MODE) &&
1099 channel != (chip->config2 & ADT7516_AD_SINGLE_CH_MASK))
1100 return -EPERM;
1101
1102 switch (channel) {
1103 case ADT7316_AD_SINGLE_CH_IN:
1104 ret = chip->bus.read(chip->bus.client,
1105 ADT7316_LSB_IN_TEMP_VDD, &lsb);
1106 if (ret)
1107 return -EIO;
1108
1109 ret = chip->bus.read(chip->bus.client,
1110 ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1111 if (ret)
1112 return -EIO;
1113
1114 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1115 data |= lsb & ADT7316_LSB_IN_TEMP_MASK;
1116 break;
1117 case ADT7316_AD_SINGLE_CH_VDD:
1118 ret = chip->bus.read(chip->bus.client,
1119 ADT7316_LSB_IN_TEMP_VDD, &lsb);
1120 if (ret)
1121 return -EIO;
1122
1123 ret = chip->bus.read(chip->bus.client,
1124
1125 ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1126 if (ret)
1127 return -EIO;
1128
1129 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1130 data |= (lsb & ADT7316_LSB_VDD_MASK) >> ADT7316_LSB_VDD_OFFSET;
1131 return sprintf(buf, "%d\n", data);
1132 default: /* ex_temp and ain */
1133 ret = chip->bus.read(chip->bus.client,
1134 ADT7316_LSB_EX_TEMP_AIN, &lsb);
1135 if (ret)
1136 return -EIO;
1137
1138 ret = chip->bus.read(chip->bus.client,
1139 ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1140 if (ret)
1141 return -EIO;
1142
1143 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1144 data |= lsb & (ADT7316_LSB_EX_TEMP_MASK <<
1145 (ADT7516_LSB_AIN_SHIFT * (channel -
1146 (ADT7316_MSB_EX_TEMP - ADT7316_AD_MSB_DATA_BASE))));
1147
1148 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1149 return sprintf(buf, "%d\n", data);
1150
1151 break;
1152 }
1153
1154 if (data & ADT7316_T_VALUE_SIGN) {
1155 /* convert supplement to positive value */
1156 data = (ADT7316_T_VALUE_SIGN << 1) - data;
1157 sign = '-';
1158 }
1159
1160 return sprintf(buf, "%c%d.%.2d\n", sign,
1161 (data >> ADT7316_T_VALUE_FLOAT_OFFSET),
1162 (data & ADT7316_T_VALUE_FLOAT_MASK) * 25);
1163 }
1164
adt7316_show_VDD(struct device * dev,struct device_attribute * attr,char * buf)1165 static ssize_t adt7316_show_VDD(struct device *dev,
1166 struct device_attribute *attr,
1167 char *buf)
1168 {
1169 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1170 struct adt7316_chip_info *chip = iio_priv(dev_info);
1171
1172 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_VDD, buf);
1173 }
1174 static IIO_DEVICE_ATTR(VDD, 0444, adt7316_show_VDD, NULL, 0);
1175
adt7316_show_in_temp(struct device * dev,struct device_attribute * attr,char * buf)1176 static ssize_t adt7316_show_in_temp(struct device *dev,
1177 struct device_attribute *attr,
1178 char *buf)
1179 {
1180 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1181 struct adt7316_chip_info *chip = iio_priv(dev_info);
1182
1183 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_IN, buf);
1184 }
1185
1186 static IIO_DEVICE_ATTR(in_temp, 0444, adt7316_show_in_temp, NULL, 0);
1187
adt7316_show_ex_temp_AIN1(struct device * dev,struct device_attribute * attr,char * buf)1188 static ssize_t adt7316_show_ex_temp_AIN1(struct device *dev,
1189 struct device_attribute *attr,
1190 char *buf)
1191 {
1192 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1193 struct adt7316_chip_info *chip = iio_priv(dev_info);
1194
1195 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_EX, buf);
1196 }
1197
1198 static IIO_DEVICE_ATTR(ex_temp_AIN1, 0444, adt7316_show_ex_temp_AIN1,
1199 NULL, 0);
1200 static IIO_DEVICE_ATTR(ex_temp, 0444, adt7316_show_ex_temp_AIN1, NULL, 0);
1201
adt7316_show_AIN2(struct device * dev,struct device_attribute * attr,char * buf)1202 static ssize_t adt7316_show_AIN2(struct device *dev,
1203 struct device_attribute *attr,
1204 char *buf)
1205 {
1206 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1207 struct adt7316_chip_info *chip = iio_priv(dev_info);
1208
1209 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN2, buf);
1210 }
1211 static IIO_DEVICE_ATTR(AIN2, 0444, adt7316_show_AIN2, NULL, 0);
1212
adt7316_show_AIN3(struct device * dev,struct device_attribute * attr,char * buf)1213 static ssize_t adt7316_show_AIN3(struct device *dev,
1214 struct device_attribute *attr,
1215 char *buf)
1216 {
1217 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1218 struct adt7316_chip_info *chip = iio_priv(dev_info);
1219
1220 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN3, buf);
1221 }
1222 static IIO_DEVICE_ATTR(AIN3, 0444, adt7316_show_AIN3, NULL, 0);
1223
adt7316_show_AIN4(struct device * dev,struct device_attribute * attr,char * buf)1224 static ssize_t adt7316_show_AIN4(struct device *dev,
1225 struct device_attribute *attr,
1226 char *buf)
1227 {
1228 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1229 struct adt7316_chip_info *chip = iio_priv(dev_info);
1230
1231 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN4, buf);
1232 }
1233 static IIO_DEVICE_ATTR(AIN4, 0444, adt7316_show_AIN4, NULL, 0);
1234
adt7316_show_temp_offset(struct adt7316_chip_info * chip,int offset_addr,char * buf)1235 static ssize_t adt7316_show_temp_offset(struct adt7316_chip_info *chip,
1236 int offset_addr, char *buf)
1237 {
1238 int data;
1239 u8 val;
1240 int ret;
1241
1242 ret = chip->bus.read(chip->bus.client, offset_addr, &val);
1243 if (ret)
1244 return -EIO;
1245
1246 data = (int)val;
1247 if (val & 0x80)
1248 data -= 256;
1249
1250 return sprintf(buf, "%d\n", data);
1251 }
1252
adt7316_store_temp_offset(struct adt7316_chip_info * chip,int offset_addr,const char * buf,size_t len)1253 static ssize_t adt7316_store_temp_offset(struct adt7316_chip_info *chip,
1254 int offset_addr,
1255 const char *buf,
1256 size_t len)
1257 {
1258 int data;
1259 u8 val;
1260 int ret;
1261
1262 ret = kstrtoint(buf, 10, &data);
1263 if (ret || data > 127 || data < -128)
1264 return -EINVAL;
1265
1266 if (data < 0)
1267 data += 256;
1268
1269 val = (u8)data;
1270
1271 ret = chip->bus.write(chip->bus.client, offset_addr, val);
1272 if (ret)
1273 return -EIO;
1274
1275 return len;
1276 }
1277
adt7316_show_in_temp_offset(struct device * dev,struct device_attribute * attr,char * buf)1278 static ssize_t adt7316_show_in_temp_offset(struct device *dev,
1279 struct device_attribute *attr,
1280 char *buf)
1281 {
1282 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1283 struct adt7316_chip_info *chip = iio_priv(dev_info);
1284
1285 return adt7316_show_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf);
1286 }
1287
adt7316_store_in_temp_offset(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1288 static ssize_t adt7316_store_in_temp_offset(struct device *dev,
1289 struct device_attribute *attr,
1290 const char *buf,
1291 size_t len)
1292 {
1293 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1294 struct adt7316_chip_info *chip = iio_priv(dev_info);
1295
1296 return adt7316_store_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf,
1297 len);
1298 }
1299
1300 static IIO_DEVICE_ATTR(in_temp_offset, 0644,
1301 adt7316_show_in_temp_offset,
1302 adt7316_store_in_temp_offset, 0);
1303
adt7316_show_ex_temp_offset(struct device * dev,struct device_attribute * attr,char * buf)1304 static ssize_t adt7316_show_ex_temp_offset(struct device *dev,
1305 struct device_attribute *attr,
1306 char *buf)
1307 {
1308 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1309 struct adt7316_chip_info *chip = iio_priv(dev_info);
1310
1311 return adt7316_show_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf);
1312 }
1313
adt7316_store_ex_temp_offset(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1314 static ssize_t adt7316_store_ex_temp_offset(struct device *dev,
1315 struct device_attribute *attr,
1316 const char *buf,
1317 size_t len)
1318 {
1319 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1320 struct adt7316_chip_info *chip = iio_priv(dev_info);
1321
1322 return adt7316_store_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf,
1323 len);
1324 }
1325
1326 static IIO_DEVICE_ATTR(ex_temp_offset, 0644,
1327 adt7316_show_ex_temp_offset,
1328 adt7316_store_ex_temp_offset, 0);
1329
adt7316_show_in_analog_temp_offset(struct device * dev,struct device_attribute * attr,char * buf)1330 static ssize_t adt7316_show_in_analog_temp_offset(struct device *dev,
1331 struct device_attribute *attr,
1332 char *buf)
1333 {
1334 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1335 struct adt7316_chip_info *chip = iio_priv(dev_info);
1336
1337 return adt7316_show_temp_offset(chip,
1338 ADT7316_IN_ANALOG_TEMP_OFFSET, buf);
1339 }
1340
adt7316_store_in_analog_temp_offset(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1341 static ssize_t adt7316_store_in_analog_temp_offset(struct device *dev,
1342 struct device_attribute *attr,
1343 const char *buf,
1344 size_t len)
1345 {
1346 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1347 struct adt7316_chip_info *chip = iio_priv(dev_info);
1348
1349 return adt7316_store_temp_offset(chip,
1350 ADT7316_IN_ANALOG_TEMP_OFFSET, buf, len);
1351 }
1352
1353 static IIO_DEVICE_ATTR(in_analog_temp_offset, 0644,
1354 adt7316_show_in_analog_temp_offset,
1355 adt7316_store_in_analog_temp_offset, 0);
1356
adt7316_show_ex_analog_temp_offset(struct device * dev,struct device_attribute * attr,char * buf)1357 static ssize_t adt7316_show_ex_analog_temp_offset(struct device *dev,
1358 struct device_attribute *attr,
1359 char *buf)
1360 {
1361 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1362 struct adt7316_chip_info *chip = iio_priv(dev_info);
1363
1364 return adt7316_show_temp_offset(chip,
1365 ADT7316_EX_ANALOG_TEMP_OFFSET, buf);
1366 }
1367
adt7316_store_ex_analog_temp_offset(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1368 static ssize_t adt7316_store_ex_analog_temp_offset(struct device *dev,
1369 struct device_attribute *attr,
1370 const char *buf,
1371 size_t len)
1372 {
1373 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1374 struct adt7316_chip_info *chip = iio_priv(dev_info);
1375
1376 return adt7316_store_temp_offset(chip,
1377 ADT7316_EX_ANALOG_TEMP_OFFSET, buf, len);
1378 }
1379
1380 static IIO_DEVICE_ATTR(ex_analog_temp_offset, 0644,
1381 adt7316_show_ex_analog_temp_offset,
1382 adt7316_store_ex_analog_temp_offset, 0);
1383
adt7316_show_DAC(struct adt7316_chip_info * chip,int channel,char * buf)1384 static ssize_t adt7316_show_DAC(struct adt7316_chip_info *chip,
1385 int channel, char *buf)
1386 {
1387 u16 data = 0;
1388 u8 msb, lsb, offset;
1389 int ret;
1390
1391 if (channel >= ADT7316_DA_MSB_DATA_REGS ||
1392 (channel == 0 &&
1393 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) ||
1394 (channel == 1 &&
1395 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)))
1396 return -EPERM;
1397
1398 offset = chip->dac_bits - 8;
1399
1400 if (chip->dac_bits > 8) {
1401 ret = chip->bus.read(chip->bus.client,
1402 ADT7316_DA_DATA_BASE + channel * 2, &lsb);
1403 if (ret)
1404 return -EIO;
1405 }
1406
1407 ret = chip->bus.read(chip->bus.client,
1408 ADT7316_DA_DATA_BASE + 1 + channel * 2, &msb);
1409 if (ret)
1410 return -EIO;
1411
1412 if (chip->dac_bits == 12)
1413 data = lsb >> ADT7316_DA_12_BIT_LSB_SHIFT;
1414 else if (chip->dac_bits == 10)
1415 data = lsb >> ADT7316_DA_10_BIT_LSB_SHIFT;
1416 data |= msb << offset;
1417
1418 return sprintf(buf, "%d\n", data);
1419 }
1420
adt7316_store_DAC(struct adt7316_chip_info * chip,int channel,const char * buf,size_t len)1421 static ssize_t adt7316_store_DAC(struct adt7316_chip_info *chip,
1422 int channel, const char *buf, size_t len)
1423 {
1424 u8 msb, lsb, lsb_reg, offset;
1425 u16 data;
1426 int ret;
1427
1428 if (channel >= ADT7316_DA_MSB_DATA_REGS ||
1429 (channel == 0 &&
1430 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) ||
1431 (channel == 1 &&
1432 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)))
1433 return -EPERM;
1434
1435 offset = chip->dac_bits - 8;
1436
1437 ret = kstrtou16(buf, 10, &data);
1438 if (ret || data >= (1 << chip->dac_bits))
1439 return -EINVAL;
1440
1441 if (chip->dac_bits > 8) {
1442 lsb = data & ((1 << offset) - 1);
1443 if (chip->dac_bits == 12)
1444 lsb_reg = lsb << ADT7316_DA_12_BIT_LSB_SHIFT;
1445 else
1446 lsb_reg = lsb << ADT7316_DA_10_BIT_LSB_SHIFT;
1447 ret = chip->bus.write(chip->bus.client,
1448 ADT7316_DA_DATA_BASE + channel * 2, lsb_reg);
1449 if (ret)
1450 return -EIO;
1451 }
1452
1453 msb = data >> offset;
1454 ret = chip->bus.write(chip->bus.client,
1455 ADT7316_DA_DATA_BASE + 1 + channel * 2, msb);
1456 if (ret)
1457 return -EIO;
1458
1459 return len;
1460 }
1461
adt7316_show_DAC_A(struct device * dev,struct device_attribute * attr,char * buf)1462 static ssize_t adt7316_show_DAC_A(struct device *dev,
1463 struct device_attribute *attr,
1464 char *buf)
1465 {
1466 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1467 struct adt7316_chip_info *chip = iio_priv(dev_info);
1468
1469 return adt7316_show_DAC(chip, 0, buf);
1470 }
1471
adt7316_store_DAC_A(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1472 static ssize_t adt7316_store_DAC_A(struct device *dev,
1473 struct device_attribute *attr,
1474 const char *buf,
1475 size_t len)
1476 {
1477 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1478 struct adt7316_chip_info *chip = iio_priv(dev_info);
1479
1480 return adt7316_store_DAC(chip, 0, buf, len);
1481 }
1482
1483 static IIO_DEVICE_ATTR(DAC_A, 0644, adt7316_show_DAC_A,
1484 adt7316_store_DAC_A, 0);
1485
adt7316_show_DAC_B(struct device * dev,struct device_attribute * attr,char * buf)1486 static ssize_t adt7316_show_DAC_B(struct device *dev,
1487 struct device_attribute *attr,
1488 char *buf)
1489 {
1490 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1491 struct adt7316_chip_info *chip = iio_priv(dev_info);
1492
1493 return adt7316_show_DAC(chip, 1, buf);
1494 }
1495
adt7316_store_DAC_B(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1496 static ssize_t adt7316_store_DAC_B(struct device *dev,
1497 struct device_attribute *attr,
1498 const char *buf,
1499 size_t len)
1500 {
1501 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1502 struct adt7316_chip_info *chip = iio_priv(dev_info);
1503
1504 return adt7316_store_DAC(chip, 1, buf, len);
1505 }
1506
1507 static IIO_DEVICE_ATTR(DAC_B, 0644, adt7316_show_DAC_B,
1508 adt7316_store_DAC_B, 0);
1509
adt7316_show_DAC_C(struct device * dev,struct device_attribute * attr,char * buf)1510 static ssize_t adt7316_show_DAC_C(struct device *dev,
1511 struct device_attribute *attr,
1512 char *buf)
1513 {
1514 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1515 struct adt7316_chip_info *chip = iio_priv(dev_info);
1516
1517 return adt7316_show_DAC(chip, 2, buf);
1518 }
1519
adt7316_store_DAC_C(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1520 static ssize_t adt7316_store_DAC_C(struct device *dev,
1521 struct device_attribute *attr,
1522 const char *buf,
1523 size_t len)
1524 {
1525 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1526 struct adt7316_chip_info *chip = iio_priv(dev_info);
1527
1528 return adt7316_store_DAC(chip, 2, buf, len);
1529 }
1530
1531 static IIO_DEVICE_ATTR(DAC_C, 0644, adt7316_show_DAC_C,
1532 adt7316_store_DAC_C, 0);
1533
adt7316_show_DAC_D(struct device * dev,struct device_attribute * attr,char * buf)1534 static ssize_t adt7316_show_DAC_D(struct device *dev,
1535 struct device_attribute *attr,
1536 char *buf)
1537 {
1538 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1539 struct adt7316_chip_info *chip = iio_priv(dev_info);
1540
1541 return adt7316_show_DAC(chip, 3, buf);
1542 }
1543
adt7316_store_DAC_D(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1544 static ssize_t adt7316_store_DAC_D(struct device *dev,
1545 struct device_attribute *attr,
1546 const char *buf,
1547 size_t len)
1548 {
1549 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1550 struct adt7316_chip_info *chip = iio_priv(dev_info);
1551
1552 return adt7316_store_DAC(chip, 3, buf, len);
1553 }
1554
1555 static IIO_DEVICE_ATTR(DAC_D, 0644, adt7316_show_DAC_D,
1556 adt7316_store_DAC_D, 0);
1557
adt7316_show_device_id(struct device * dev,struct device_attribute * attr,char * buf)1558 static ssize_t adt7316_show_device_id(struct device *dev,
1559 struct device_attribute *attr,
1560 char *buf)
1561 {
1562 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1563 struct adt7316_chip_info *chip = iio_priv(dev_info);
1564 u8 id;
1565 int ret;
1566
1567 ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_ID, &id);
1568 if (ret)
1569 return -EIO;
1570
1571 return sprintf(buf, "%d\n", id);
1572 }
1573
1574 static IIO_DEVICE_ATTR(device_id, 0444, adt7316_show_device_id, NULL, 0);
1575
adt7316_show_manufactorer_id(struct device * dev,struct device_attribute * attr,char * buf)1576 static ssize_t adt7316_show_manufactorer_id(struct device *dev,
1577 struct device_attribute *attr,
1578 char *buf)
1579 {
1580 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1581 struct adt7316_chip_info *chip = iio_priv(dev_info);
1582 u8 id;
1583 int ret;
1584
1585 ret = chip->bus.read(chip->bus.client, ADT7316_MANUFACTURE_ID, &id);
1586 if (ret)
1587 return -EIO;
1588
1589 return sprintf(buf, "%d\n", id);
1590 }
1591
1592 static IIO_DEVICE_ATTR(manufactorer_id, 0444,
1593 adt7316_show_manufactorer_id, NULL, 0);
1594
adt7316_show_device_rev(struct device * dev,struct device_attribute * attr,char * buf)1595 static ssize_t adt7316_show_device_rev(struct device *dev,
1596 struct device_attribute *attr,
1597 char *buf)
1598 {
1599 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1600 struct adt7316_chip_info *chip = iio_priv(dev_info);
1601 u8 rev;
1602 int ret;
1603
1604 ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_REV, &rev);
1605 if (ret)
1606 return -EIO;
1607
1608 return sprintf(buf, "%d\n", rev);
1609 }
1610
1611 static IIO_DEVICE_ATTR(device_rev, 0444, adt7316_show_device_rev, NULL, 0);
1612
adt7316_show_bus_type(struct device * dev,struct device_attribute * attr,char * buf)1613 static ssize_t adt7316_show_bus_type(struct device *dev,
1614 struct device_attribute *attr,
1615 char *buf)
1616 {
1617 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1618 struct adt7316_chip_info *chip = iio_priv(dev_info);
1619 u8 stat;
1620 int ret;
1621
1622 ret = chip->bus.read(chip->bus.client, ADT7316_SPI_LOCK_STAT, &stat);
1623 if (ret)
1624 return -EIO;
1625
1626 if (stat)
1627 return sprintf(buf, "spi\n");
1628
1629 return sprintf(buf, "i2c\n");
1630 }
1631
1632 static IIO_DEVICE_ATTR(bus_type, 0444, adt7316_show_bus_type, NULL, 0);
1633
1634 static struct attribute *adt7316_attributes[] = {
1635 &iio_dev_attr_all_modes.dev_attr.attr,
1636 &iio_dev_attr_mode.dev_attr.attr,
1637 &iio_dev_attr_enabled.dev_attr.attr,
1638 &iio_dev_attr_ad_channel.dev_attr.attr,
1639 &iio_dev_attr_all_ad_channels.dev_attr.attr,
1640 &iio_dev_attr_disable_averaging.dev_attr.attr,
1641 &iio_dev_attr_enable_smbus_timeout.dev_attr.attr,
1642 &iio_dev_attr_powerdown.dev_attr.attr,
1643 &iio_dev_attr_fast_ad_clock.dev_attr.attr,
1644 &iio_dev_attr_da_high_resolution.dev_attr.attr,
1645 &iio_dev_attr_enable_proportion_DACA.dev_attr.attr,
1646 &iio_dev_attr_enable_proportion_DACB.dev_attr.attr,
1647 &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr,
1648 &iio_dev_attr_DAC_update_mode.dev_attr.attr,
1649 &iio_dev_attr_all_DAC_update_modes.dev_attr.attr,
1650 &iio_dev_attr_update_DAC.dev_attr.attr,
1651 &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr,
1652 &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr,
1653 &iio_dev_attr_DAC_internal_Vref.dev_attr.attr,
1654 &iio_dev_attr_VDD.dev_attr.attr,
1655 &iio_dev_attr_in_temp.dev_attr.attr,
1656 &iio_dev_attr_ex_temp.dev_attr.attr,
1657 &iio_dev_attr_in_temp_offset.dev_attr.attr,
1658 &iio_dev_attr_ex_temp_offset.dev_attr.attr,
1659 &iio_dev_attr_in_analog_temp_offset.dev_attr.attr,
1660 &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr,
1661 &iio_dev_attr_DAC_A.dev_attr.attr,
1662 &iio_dev_attr_DAC_B.dev_attr.attr,
1663 &iio_dev_attr_DAC_C.dev_attr.attr,
1664 &iio_dev_attr_DAC_D.dev_attr.attr,
1665 &iio_dev_attr_device_id.dev_attr.attr,
1666 &iio_dev_attr_manufactorer_id.dev_attr.attr,
1667 &iio_dev_attr_device_rev.dev_attr.attr,
1668 &iio_dev_attr_bus_type.dev_attr.attr,
1669 NULL,
1670 };
1671
1672 static const struct attribute_group adt7316_attribute_group = {
1673 .attrs = adt7316_attributes,
1674 };
1675
1676 static struct attribute *adt7516_attributes[] = {
1677 &iio_dev_attr_all_modes.dev_attr.attr,
1678 &iio_dev_attr_mode.dev_attr.attr,
1679 &iio_dev_attr_select_ex_temp.dev_attr.attr,
1680 &iio_dev_attr_enabled.dev_attr.attr,
1681 &iio_dev_attr_ad_channel.dev_attr.attr,
1682 &iio_dev_attr_all_ad_channels.dev_attr.attr,
1683 &iio_dev_attr_disable_averaging.dev_attr.attr,
1684 &iio_dev_attr_enable_smbus_timeout.dev_attr.attr,
1685 &iio_dev_attr_powerdown.dev_attr.attr,
1686 &iio_dev_attr_fast_ad_clock.dev_attr.attr,
1687 &iio_dev_attr_AIN_internal_Vref.dev_attr.attr,
1688 &iio_dev_attr_da_high_resolution.dev_attr.attr,
1689 &iio_dev_attr_enable_proportion_DACA.dev_attr.attr,
1690 &iio_dev_attr_enable_proportion_DACB.dev_attr.attr,
1691 &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr,
1692 &iio_dev_attr_DAC_update_mode.dev_attr.attr,
1693 &iio_dev_attr_all_DAC_update_modes.dev_attr.attr,
1694 &iio_dev_attr_update_DAC.dev_attr.attr,
1695 &iio_dev_attr_DAC_internal_Vref.dev_attr.attr,
1696 &iio_dev_attr_VDD.dev_attr.attr,
1697 &iio_dev_attr_in_temp.dev_attr.attr,
1698 &iio_dev_attr_ex_temp_AIN1.dev_attr.attr,
1699 &iio_dev_attr_AIN2.dev_attr.attr,
1700 &iio_dev_attr_AIN3.dev_attr.attr,
1701 &iio_dev_attr_AIN4.dev_attr.attr,
1702 &iio_dev_attr_in_temp_offset.dev_attr.attr,
1703 &iio_dev_attr_ex_temp_offset.dev_attr.attr,
1704 &iio_dev_attr_in_analog_temp_offset.dev_attr.attr,
1705 &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr,
1706 &iio_dev_attr_DAC_A.dev_attr.attr,
1707 &iio_dev_attr_DAC_B.dev_attr.attr,
1708 &iio_dev_attr_DAC_C.dev_attr.attr,
1709 &iio_dev_attr_DAC_D.dev_attr.attr,
1710 &iio_dev_attr_device_id.dev_attr.attr,
1711 &iio_dev_attr_manufactorer_id.dev_attr.attr,
1712 &iio_dev_attr_device_rev.dev_attr.attr,
1713 &iio_dev_attr_bus_type.dev_attr.attr,
1714 NULL,
1715 };
1716
1717 static const struct attribute_group adt7516_attribute_group = {
1718 .attrs = adt7516_attributes,
1719 };
1720
adt7316_event_handler(int irq,void * private)1721 static irqreturn_t adt7316_event_handler(int irq, void *private)
1722 {
1723 struct iio_dev *indio_dev = private;
1724 struct adt7316_chip_info *chip = iio_priv(indio_dev);
1725 u8 stat1, stat2;
1726 int ret;
1727 s64 time;
1728
1729 ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT1, &stat1);
1730 if (!ret) {
1731 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
1732 stat1 &= 0x1F;
1733
1734 time = iio_get_time_ns(indio_dev);
1735 if (stat1 & BIT(0))
1736 iio_push_event(indio_dev,
1737 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
1738 IIO_EV_TYPE_THRESH,
1739 IIO_EV_DIR_RISING),
1740 time);
1741 if (stat1 & BIT(1))
1742 iio_push_event(indio_dev,
1743 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
1744 IIO_EV_TYPE_THRESH,
1745 IIO_EV_DIR_FALLING),
1746 time);
1747 if (stat1 & BIT(2))
1748 iio_push_event(indio_dev,
1749 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
1750 IIO_EV_TYPE_THRESH,
1751 IIO_EV_DIR_RISING),
1752 time);
1753 if (stat1 & BIT(3))
1754 iio_push_event(indio_dev,
1755 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
1756 IIO_EV_TYPE_THRESH,
1757 IIO_EV_DIR_FALLING),
1758 time);
1759 if (stat1 & BIT(5))
1760 iio_push_event(indio_dev,
1761 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1,
1762 IIO_EV_TYPE_THRESH,
1763 IIO_EV_DIR_EITHER),
1764 time);
1765 if (stat1 & BIT(6))
1766 iio_push_event(indio_dev,
1767 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 2,
1768 IIO_EV_TYPE_THRESH,
1769 IIO_EV_DIR_EITHER),
1770 time);
1771 if (stat1 & BIT(7))
1772 iio_push_event(indio_dev,
1773 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 3,
1774 IIO_EV_TYPE_THRESH,
1775 IIO_EV_DIR_EITHER),
1776 time);
1777 }
1778 ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT2, &stat2);
1779 if (!ret) {
1780 if (stat2 & ADT7316_INT_MASK2_VDD)
1781 iio_push_event(indio_dev,
1782 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
1783 0,
1784 IIO_EV_TYPE_THRESH,
1785 IIO_EV_DIR_RISING),
1786 iio_get_time_ns(indio_dev));
1787 }
1788
1789 return IRQ_HANDLED;
1790 }
1791
adt7316_setup_irq(struct iio_dev * indio_dev)1792 static int adt7316_setup_irq(struct iio_dev *indio_dev)
1793 {
1794 struct adt7316_chip_info *chip = iio_priv(indio_dev);
1795 int irq_type, ret;
1796
1797 irq_type = irqd_get_trigger_type(irq_get_irq_data(chip->bus.irq));
1798
1799 switch (irq_type) {
1800 case IRQF_TRIGGER_HIGH:
1801 case IRQF_TRIGGER_RISING:
1802 break;
1803 case IRQF_TRIGGER_LOW:
1804 case IRQF_TRIGGER_FALLING:
1805 break;
1806 default:
1807 dev_info(&indio_dev->dev, "mode %d unsupported, using IRQF_TRIGGER_LOW\n",
1808 irq_type);
1809 irq_type = IRQF_TRIGGER_LOW;
1810 break;
1811 }
1812
1813 ret = devm_request_threaded_irq(&indio_dev->dev, chip->bus.irq,
1814 NULL, adt7316_event_handler,
1815 irq_type | IRQF_ONESHOT,
1816 indio_dev->name, indio_dev);
1817 if (ret) {
1818 dev_err(&indio_dev->dev, "failed to request irq %d\n",
1819 chip->bus.irq);
1820 return ret;
1821 }
1822
1823 if (irq_type & IRQF_TRIGGER_HIGH)
1824 chip->config1 |= ADT7316_INT_POLARITY;
1825
1826 return 0;
1827 }
1828
1829 /*
1830 * Show mask of enabled interrupts in Hex.
1831 */
adt7316_show_int_mask(struct device * dev,struct device_attribute * attr,char * buf)1832 static ssize_t adt7316_show_int_mask(struct device *dev,
1833 struct device_attribute *attr,
1834 char *buf)
1835 {
1836 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1837 struct adt7316_chip_info *chip = iio_priv(dev_info);
1838
1839 return sprintf(buf, "0x%x\n", chip->int_mask);
1840 }
1841
1842 /*
1843 * Set 1 to the mask in Hex to enabled interrupts.
1844 */
adt7316_set_int_mask(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1845 static ssize_t adt7316_set_int_mask(struct device *dev,
1846 struct device_attribute *attr,
1847 const char *buf,
1848 size_t len)
1849 {
1850 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1851 struct adt7316_chip_info *chip = iio_priv(dev_info);
1852 u16 data;
1853 int ret;
1854 u8 mask;
1855
1856 ret = kstrtou16(buf, 16, &data);
1857 if (ret || data >= ADT7316_VDD_INT_MASK + 1)
1858 return -EINVAL;
1859
1860 if (data & ADT7316_VDD_INT_MASK)
1861 mask = 0; /* enable vdd int */
1862 else
1863 mask = ADT7316_INT_MASK2_VDD; /* disable vdd int */
1864
1865 ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK2, mask);
1866 if (!ret) {
1867 chip->int_mask &= ~ADT7316_VDD_INT_MASK;
1868 chip->int_mask |= data & ADT7316_VDD_INT_MASK;
1869 }
1870
1871 if (data & ADT7316_TEMP_AIN_INT_MASK) {
1872 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX)
1873 /* mask in reg is opposite, set 1 to disable */
1874 mask = (~data) & ADT7316_TEMP_INT_MASK;
1875 else
1876 /* mask in reg is opposite, set 1 to disable */
1877 mask = (~data) & ADT7316_TEMP_AIN_INT_MASK;
1878 }
1879 ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK1, mask);
1880
1881 chip->int_mask = mask;
1882
1883 return len;
1884 }
1885
adt7316_show_ad_bound(struct device * dev,struct device_attribute * attr,char * buf)1886 static inline ssize_t adt7316_show_ad_bound(struct device *dev,
1887 struct device_attribute *attr,
1888 char *buf)
1889 {
1890 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1891 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1892 struct adt7316_chip_info *chip = iio_priv(dev_info);
1893 u8 val;
1894 int data;
1895 int ret;
1896
1897 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1898 this_attr->address > ADT7316_EX_TEMP_LOW)
1899 return -EPERM;
1900
1901 ret = chip->bus.read(chip->bus.client, this_attr->address, &val);
1902 if (ret)
1903 return -EIO;
1904
1905 data = (int)val;
1906
1907 if (!((chip->id & ID_FAMILY_MASK) == ID_ADT75XX &&
1908 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)) {
1909 if (data & 0x80)
1910 data -= 256;
1911 }
1912
1913 return sprintf(buf, "%d\n", data);
1914 }
1915
adt7316_set_ad_bound(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1916 static inline ssize_t adt7316_set_ad_bound(struct device *dev,
1917 struct device_attribute *attr,
1918 const char *buf,
1919 size_t len)
1920 {
1921 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1922 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1923 struct adt7316_chip_info *chip = iio_priv(dev_info);
1924 int data;
1925 u8 val;
1926 int ret;
1927
1928 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1929 this_attr->address > ADT7316_EX_TEMP_LOW)
1930 return -EPERM;
1931
1932 ret = kstrtoint(buf, 10, &data);
1933 if (ret)
1934 return -EINVAL;
1935
1936 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX &&
1937 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0) {
1938 if (data > 255 || data < 0)
1939 return -EINVAL;
1940 } else {
1941 if (data > 127 || data < -128)
1942 return -EINVAL;
1943
1944 if (data < 0)
1945 data += 256;
1946 }
1947
1948 val = (u8)data;
1949
1950 ret = chip->bus.write(chip->bus.client, this_attr->address, val);
1951 if (ret)
1952 return -EIO;
1953
1954 return len;
1955 }
1956
adt7316_show_int_enabled(struct device * dev,struct device_attribute * attr,char * buf)1957 static ssize_t adt7316_show_int_enabled(struct device *dev,
1958 struct device_attribute *attr,
1959 char *buf)
1960 {
1961 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1962 struct adt7316_chip_info *chip = iio_priv(dev_info);
1963
1964 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_INT_EN));
1965 }
1966
adt7316_set_int_enabled(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1967 static ssize_t adt7316_set_int_enabled(struct device *dev,
1968 struct device_attribute *attr,
1969 const char *buf,
1970 size_t len)
1971 {
1972 struct iio_dev *dev_info = dev_to_iio_dev(dev);
1973 struct adt7316_chip_info *chip = iio_priv(dev_info);
1974 u8 config1;
1975 int ret;
1976
1977 config1 = chip->config1 & (~ADT7316_INT_EN);
1978 if (buf[0] == '1')
1979 config1 |= ADT7316_INT_EN;
1980
1981 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
1982 if (ret)
1983 return -EIO;
1984
1985 chip->config1 = config1;
1986
1987 return len;
1988 }
1989
1990 static IIO_DEVICE_ATTR(int_mask,
1991 0644,
1992 adt7316_show_int_mask, adt7316_set_int_mask,
1993 0);
1994 static IIO_DEVICE_ATTR(in_temp_high_value,
1995 0644,
1996 adt7316_show_ad_bound, adt7316_set_ad_bound,
1997 ADT7316_IN_TEMP_HIGH);
1998 static IIO_DEVICE_ATTR(in_temp_low_value,
1999 0644,
2000 adt7316_show_ad_bound, adt7316_set_ad_bound,
2001 ADT7316_IN_TEMP_LOW);
2002 static IIO_DEVICE_ATTR(ex_temp_high_value,
2003 0644,
2004 adt7316_show_ad_bound, adt7316_set_ad_bound,
2005 ADT7316_EX_TEMP_HIGH);
2006 static IIO_DEVICE_ATTR(ex_temp_low_value,
2007 0644,
2008 adt7316_show_ad_bound, adt7316_set_ad_bound,
2009 ADT7316_EX_TEMP_LOW);
2010
2011 /* NASTY duplication to be fixed */
2012 static IIO_DEVICE_ATTR(ex_temp_ain1_high_value,
2013 0644,
2014 adt7316_show_ad_bound, adt7316_set_ad_bound,
2015 ADT7316_EX_TEMP_HIGH);
2016 static IIO_DEVICE_ATTR(ex_temp_ain1_low_value,
2017 0644,
2018 adt7316_show_ad_bound, adt7316_set_ad_bound,
2019 ADT7316_EX_TEMP_LOW);
2020 static IIO_DEVICE_ATTR(ain2_high_value,
2021 0644,
2022 adt7316_show_ad_bound, adt7316_set_ad_bound,
2023 ADT7516_AIN2_HIGH);
2024 static IIO_DEVICE_ATTR(ain2_low_value,
2025 0644,
2026 adt7316_show_ad_bound, adt7316_set_ad_bound,
2027 ADT7516_AIN2_LOW);
2028 static IIO_DEVICE_ATTR(ain3_high_value,
2029 0644,
2030 adt7316_show_ad_bound, adt7316_set_ad_bound,
2031 ADT7516_AIN3_HIGH);
2032 static IIO_DEVICE_ATTR(ain3_low_value,
2033 0644,
2034 adt7316_show_ad_bound, adt7316_set_ad_bound,
2035 ADT7516_AIN3_LOW);
2036 static IIO_DEVICE_ATTR(ain4_high_value,
2037 0644,
2038 adt7316_show_ad_bound, adt7316_set_ad_bound,
2039 ADT7516_AIN4_HIGH);
2040 static IIO_DEVICE_ATTR(ain4_low_value,
2041 0644,
2042 adt7316_show_ad_bound, adt7316_set_ad_bound,
2043 ADT7516_AIN4_LOW);
2044 static IIO_DEVICE_ATTR(int_enabled,
2045 0644,
2046 adt7316_show_int_enabled,
2047 adt7316_set_int_enabled, 0);
2048
2049 static struct attribute *adt7316_event_attributes[] = {
2050 &iio_dev_attr_int_mask.dev_attr.attr,
2051 &iio_dev_attr_in_temp_high_value.dev_attr.attr,
2052 &iio_dev_attr_in_temp_low_value.dev_attr.attr,
2053 &iio_dev_attr_ex_temp_high_value.dev_attr.attr,
2054 &iio_dev_attr_ex_temp_low_value.dev_attr.attr,
2055 &iio_dev_attr_int_enabled.dev_attr.attr,
2056 NULL,
2057 };
2058
2059 static const struct attribute_group adt7316_event_attribute_group = {
2060 .attrs = adt7316_event_attributes,
2061 .name = "events",
2062 };
2063
2064 static struct attribute *adt7516_event_attributes[] = {
2065 &iio_dev_attr_int_mask.dev_attr.attr,
2066 &iio_dev_attr_in_temp_high_value.dev_attr.attr,
2067 &iio_dev_attr_in_temp_low_value.dev_attr.attr,
2068 &iio_dev_attr_ex_temp_ain1_high_value.dev_attr.attr,
2069 &iio_dev_attr_ex_temp_ain1_low_value.dev_attr.attr,
2070 &iio_dev_attr_ain2_high_value.dev_attr.attr,
2071 &iio_dev_attr_ain2_low_value.dev_attr.attr,
2072 &iio_dev_attr_ain3_high_value.dev_attr.attr,
2073 &iio_dev_attr_ain3_low_value.dev_attr.attr,
2074 &iio_dev_attr_ain4_high_value.dev_attr.attr,
2075 &iio_dev_attr_ain4_low_value.dev_attr.attr,
2076 &iio_dev_attr_int_enabled.dev_attr.attr,
2077 NULL,
2078 };
2079
2080 static const struct attribute_group adt7516_event_attribute_group = {
2081 .attrs = adt7516_event_attributes,
2082 .name = "events",
2083 };
2084
2085 #ifdef CONFIG_PM_SLEEP
adt7316_disable(struct device * dev)2086 static int adt7316_disable(struct device *dev)
2087 {
2088 struct iio_dev *dev_info = dev_get_drvdata(dev);
2089 struct adt7316_chip_info *chip = iio_priv(dev_info);
2090
2091 return _adt7316_store_enabled(chip, 0);
2092 }
2093
adt7316_enable(struct device * dev)2094 static int adt7316_enable(struct device *dev)
2095 {
2096 struct iio_dev *dev_info = dev_get_drvdata(dev);
2097 struct adt7316_chip_info *chip = iio_priv(dev_info);
2098
2099 return _adt7316_store_enabled(chip, 1);
2100 }
2101 EXPORT_SYMBOL_GPL(adt7316_pm_ops);
2102 SIMPLE_DEV_PM_OPS(adt7316_pm_ops, adt7316_disable, adt7316_enable);
2103 #endif
2104
2105 static const struct iio_info adt7316_info = {
2106 .attrs = &adt7316_attribute_group,
2107 .event_attrs = &adt7316_event_attribute_group,
2108 };
2109
2110 static const struct iio_info adt7516_info = {
2111 .attrs = &adt7516_attribute_group,
2112 .event_attrs = &adt7516_event_attribute_group,
2113 };
2114
2115 /*
2116 * device probe and remove
2117 */
adt7316_probe(struct device * dev,struct adt7316_bus * bus,const char * name)2118 int adt7316_probe(struct device *dev, struct adt7316_bus *bus,
2119 const char *name)
2120 {
2121 struct adt7316_chip_info *chip;
2122 struct iio_dev *indio_dev;
2123 int ret;
2124
2125 indio_dev = devm_iio_device_alloc(dev, sizeof(*chip));
2126 if (!indio_dev)
2127 return -ENOMEM;
2128 chip = iio_priv(indio_dev);
2129 /* this is only used for device removal purposes */
2130 dev_set_drvdata(dev, indio_dev);
2131
2132 chip->bus = *bus;
2133
2134 if (name[4] == '3')
2135 chip->id = ID_ADT7316 + (name[6] - '6');
2136 else if (name[4] == '5')
2137 chip->id = ID_ADT7516 + (name[6] - '6');
2138 else
2139 return -ENODEV;
2140
2141 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516)
2142 chip->dac_bits = 12;
2143 else if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517)
2144 chip->dac_bits = 10;
2145 else
2146 chip->dac_bits = 8;
2147
2148 chip->ldac_pin = devm_gpiod_get_optional(dev, "adi,ldac",
2149 GPIOD_OUT_LOW);
2150 if (IS_ERR(chip->ldac_pin)) {
2151 ret = PTR_ERR(chip->ldac_pin);
2152 dev_err(dev, "Failed to request ldac GPIO: %d\n", ret);
2153 return ret;
2154 }
2155
2156 if (!chip->ldac_pin) {
2157 chip->config3 |= ADT7316_DA_EN_VIA_DAC_LDAC;
2158 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2159 chip->config1 |= ADT7516_SEL_AIN3;
2160 }
2161 chip->int_mask = ADT7316_TEMP_INT_MASK | ADT7316_VDD_INT_MASK;
2162 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2163 chip->int_mask |= ADT7516_AIN_INT_MASK;
2164
2165 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2166 indio_dev->info = &adt7516_info;
2167 else
2168 indio_dev->info = &adt7316_info;
2169 indio_dev->name = name;
2170 indio_dev->modes = INDIO_DIRECT_MODE;
2171
2172 if (chip->bus.irq > 0) {
2173 ret = adt7316_setup_irq(indio_dev);
2174 if (ret)
2175 return ret;
2176 }
2177
2178 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, chip->config1);
2179 if (ret)
2180 return -EIO;
2181
2182 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, chip->config3);
2183 if (ret)
2184 return -EIO;
2185
2186 ret = devm_iio_device_register(dev, indio_dev);
2187 if (ret)
2188 return ret;
2189
2190 dev_info(dev, "%s temperature sensor, ADC and DAC registered.\n",
2191 indio_dev->name);
2192
2193 return 0;
2194 }
2195 EXPORT_SYMBOL(adt7316_probe);
2196
2197 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
2198 MODULE_DESCRIPTION("Analog Devices ADT7316/7/8 and ADT7516/7/9 digital temperature sensor, ADC and DAC driver");
2199 MODULE_LICENSE("GPL v2");
2200