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