xref: /openbmc/linux/drivers/staging/iio/adc/ad7816.c (revision d3be8324)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * AD7816 digital temperature sensor driver supporting AD7816/7/8
4  *
5  * Copyright 2010 Analog Devices Inc.
6  */
7 
8 #include <linux/interrupt.h>
9 #include <linux/gpio/consumer.h>
10 #include <linux/device.h>
11 #include <linux/kernel.h>
12 #include <linux/slab.h>
13 #include <linux/sysfs.h>
14 #include <linux/list.h>
15 #include <linux/spi/spi.h>
16 #include <linux/module.h>
17 
18 #include <linux/iio/iio.h>
19 #include <linux/iio/sysfs.h>
20 #include <linux/iio/events.h>
21 
22 /*
23  * AD7816 config masks
24  */
25 #define AD7816_FULL			0x1
26 #define AD7816_PD			0x2
27 #define AD7816_CS_MASK			0x7
28 #define AD7816_CS_MAX			0x4
29 
30 /*
31  * AD7816 temperature masks
32  */
33 #define AD7816_VALUE_OFFSET		6
34 #define AD7816_BOUND_VALUE_BASE		0x8
35 #define AD7816_BOUND_VALUE_MIN		-95
36 #define AD7816_BOUND_VALUE_MAX		152
37 #define AD7816_TEMP_FLOAT_OFFSET	2
38 #define AD7816_TEMP_FLOAT_MASK		0x3
39 
40 /*
41  * struct ad7816_chip_info - chip specific information
42  */
43 
44 struct ad7816_chip_info {
45 	kernel_ulong_t id;
46 	struct spi_device *spi_dev;
47 	struct gpio_desc *rdwr_pin;
48 	struct gpio_desc *convert_pin;
49 	struct gpio_desc *busy_pin;
50 	u8  oti_data[AD7816_CS_MAX + 1];
51 	u8  channel_id;	/* 0 always be temperature */
52 	u8  mode;
53 };
54 
55 enum ad7816_type {
56 	ID_AD7816,
57 	ID_AD7817,
58 	ID_AD7818,
59 };
60 
61 /*
62  * ad7816 data access by SPI
63  */
ad7816_spi_read(struct ad7816_chip_info * chip,u16 * data)64 static int ad7816_spi_read(struct ad7816_chip_info *chip, u16 *data)
65 {
66 	struct spi_device *spi_dev = chip->spi_dev;
67 	int ret;
68 	__be16 buf;
69 
70 	gpiod_set_value(chip->rdwr_pin, 1);
71 	gpiod_set_value(chip->rdwr_pin, 0);
72 	ret = spi_write(spi_dev, &chip->channel_id, sizeof(chip->channel_id));
73 	if (ret < 0) {
74 		dev_err(&spi_dev->dev, "SPI channel setting error\n");
75 		return ret;
76 	}
77 	gpiod_set_value(chip->rdwr_pin, 1);
78 
79 	if (chip->mode == AD7816_PD) { /* operating mode 2 */
80 		gpiod_set_value(chip->convert_pin, 1);
81 		gpiod_set_value(chip->convert_pin, 0);
82 	} else { /* operating mode 1 */
83 		gpiod_set_value(chip->convert_pin, 0);
84 		gpiod_set_value(chip->convert_pin, 1);
85 	}
86 
87 	if (chip->id == ID_AD7816 || chip->id == ID_AD7817) {
88 		while (gpiod_get_value(chip->busy_pin))
89 			cpu_relax();
90 	}
91 
92 	gpiod_set_value(chip->rdwr_pin, 0);
93 	gpiod_set_value(chip->rdwr_pin, 1);
94 	ret = spi_read(spi_dev, &buf, sizeof(*data));
95 	if (ret < 0) {
96 		dev_err(&spi_dev->dev, "SPI data read error\n");
97 		return ret;
98 	}
99 
100 	*data = be16_to_cpu(buf);
101 
102 	return ret;
103 }
104 
ad7816_spi_write(struct ad7816_chip_info * chip,u8 data)105 static int ad7816_spi_write(struct ad7816_chip_info *chip, u8 data)
106 {
107 	struct spi_device *spi_dev = chip->spi_dev;
108 	int ret;
109 
110 	gpiod_set_value(chip->rdwr_pin, 1);
111 	gpiod_set_value(chip->rdwr_pin, 0);
112 	ret = spi_write(spi_dev, &data, sizeof(data));
113 	if (ret < 0)
114 		dev_err(&spi_dev->dev, "SPI oti data write error\n");
115 
116 	return ret;
117 }
118 
ad7816_show_mode(struct device * dev,struct device_attribute * attr,char * buf)119 static ssize_t ad7816_show_mode(struct device *dev,
120 				struct device_attribute *attr,
121 				char *buf)
122 {
123 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
124 	struct ad7816_chip_info *chip = iio_priv(indio_dev);
125 
126 	if (chip->mode)
127 		return sprintf(buf, "power-save\n");
128 	return sprintf(buf, "full\n");
129 }
130 
ad7816_store_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)131 static ssize_t ad7816_store_mode(struct device *dev,
132 				 struct device_attribute *attr,
133 				 const char *buf,
134 				 size_t len)
135 {
136 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
137 	struct ad7816_chip_info *chip = iio_priv(indio_dev);
138 
139 	if (strcmp(buf, "full")) {
140 		gpiod_set_value(chip->rdwr_pin, 1);
141 		chip->mode = AD7816_FULL;
142 	} else {
143 		gpiod_set_value(chip->rdwr_pin, 0);
144 		chip->mode = AD7816_PD;
145 	}
146 
147 	return len;
148 }
149 
150 static IIO_DEVICE_ATTR(mode, 0644,
151 		ad7816_show_mode,
152 		ad7816_store_mode,
153 		0);
154 
ad7816_show_available_modes(struct device * dev,struct device_attribute * attr,char * buf)155 static ssize_t ad7816_show_available_modes(struct device *dev,
156 					   struct device_attribute *attr,
157 					   char *buf)
158 {
159 	return sprintf(buf, "full\npower-save\n");
160 }
161 
162 static IIO_DEVICE_ATTR(available_modes, 0444, ad7816_show_available_modes,
163 			NULL, 0);
164 
ad7816_show_channel(struct device * dev,struct device_attribute * attr,char * buf)165 static ssize_t ad7816_show_channel(struct device *dev,
166 				   struct device_attribute *attr,
167 				   char *buf)
168 {
169 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
170 	struct ad7816_chip_info *chip = iio_priv(indio_dev);
171 
172 	return sprintf(buf, "%d\n", chip->channel_id);
173 }
174 
ad7816_store_channel(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)175 static ssize_t ad7816_store_channel(struct device *dev,
176 				    struct device_attribute *attr,
177 				    const char *buf,
178 				    size_t len)
179 {
180 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
181 	struct ad7816_chip_info *chip = iio_priv(indio_dev);
182 	unsigned long data;
183 	int ret;
184 
185 	ret = kstrtoul(buf, 10, &data);
186 	if (ret)
187 		return ret;
188 
189 	if (data > AD7816_CS_MAX && data != AD7816_CS_MASK) {
190 		dev_err(&chip->spi_dev->dev, "Invalid channel id %lu for %s.\n",
191 			data, indio_dev->name);
192 		return -EINVAL;
193 	} else if (strcmp(indio_dev->name, "ad7818") == 0 && data > 1) {
194 		dev_err(&chip->spi_dev->dev,
195 			"Invalid channel id %lu for ad7818.\n", data);
196 		return -EINVAL;
197 	} else if (strcmp(indio_dev->name, "ad7816") == 0 && data > 0) {
198 		dev_err(&chip->spi_dev->dev,
199 			"Invalid channel id %lu for ad7816.\n", data);
200 		return -EINVAL;
201 	}
202 
203 	chip->channel_id = data;
204 
205 	return len;
206 }
207 
208 static IIO_DEVICE_ATTR(channel, 0644,
209 		ad7816_show_channel,
210 		ad7816_store_channel,
211 		0);
212 
ad7816_show_value(struct device * dev,struct device_attribute * attr,char * buf)213 static ssize_t ad7816_show_value(struct device *dev,
214 				 struct device_attribute *attr,
215 				 char *buf)
216 {
217 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
218 	struct ad7816_chip_info *chip = iio_priv(indio_dev);
219 	u16 data;
220 	s8 value;
221 	int ret;
222 
223 	ret = ad7816_spi_read(chip, &data);
224 	if (ret)
225 		return -EIO;
226 
227 	data >>= AD7816_VALUE_OFFSET;
228 
229 	if (chip->channel_id == 0) {
230 		value = (s8)((data >> AD7816_TEMP_FLOAT_OFFSET) - 103);
231 		data &= AD7816_TEMP_FLOAT_MASK;
232 		if (value < 0)
233 			data = BIT(AD7816_TEMP_FLOAT_OFFSET) - data;
234 		return sprintf(buf, "%d.%.2d\n", value, data * 25);
235 	}
236 	return sprintf(buf, "%u\n", data);
237 }
238 
239 static IIO_DEVICE_ATTR(value, 0444, ad7816_show_value, NULL, 0);
240 
241 static struct attribute *ad7816_attributes[] = {
242 	&iio_dev_attr_available_modes.dev_attr.attr,
243 	&iio_dev_attr_mode.dev_attr.attr,
244 	&iio_dev_attr_channel.dev_attr.attr,
245 	&iio_dev_attr_value.dev_attr.attr,
246 	NULL,
247 };
248 
249 static const struct attribute_group ad7816_attribute_group = {
250 	.attrs = ad7816_attributes,
251 };
252 
253 /*
254  * temperature bound events
255  */
256 
257 #define IIO_EVENT_CODE_AD7816_OTI IIO_UNMOD_EVENT_CODE(IIO_TEMP,	\
258 						       0,		\
259 						       IIO_EV_TYPE_THRESH, \
260 						       IIO_EV_DIR_FALLING)
261 
ad7816_event_handler(int irq,void * private)262 static irqreturn_t ad7816_event_handler(int irq, void *private)
263 {
264 	iio_push_event(private, IIO_EVENT_CODE_AD7816_OTI,
265 		       iio_get_time_ns(private));
266 	return IRQ_HANDLED;
267 }
268 
ad7816_show_oti(struct device * dev,struct device_attribute * attr,char * buf)269 static ssize_t ad7816_show_oti(struct device *dev,
270 			       struct device_attribute *attr,
271 			       char *buf)
272 {
273 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
274 	struct ad7816_chip_info *chip = iio_priv(indio_dev);
275 	int value;
276 
277 	if (chip->channel_id > AD7816_CS_MAX) {
278 		dev_err(dev, "Invalid oti channel id %d.\n", chip->channel_id);
279 		return -EINVAL;
280 	} else if (chip->channel_id == 0) {
281 		value = AD7816_BOUND_VALUE_MIN +
282 			(chip->oti_data[chip->channel_id] -
283 			AD7816_BOUND_VALUE_BASE);
284 		return sprintf(buf, "%d\n", value);
285 	}
286 	return sprintf(buf, "%u\n", chip->oti_data[chip->channel_id]);
287 }
288 
ad7816_set_oti(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)289 static inline ssize_t ad7816_set_oti(struct device *dev,
290 				     struct device_attribute *attr,
291 				     const char *buf,
292 				     size_t len)
293 {
294 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
295 	struct ad7816_chip_info *chip = iio_priv(indio_dev);
296 	long value;
297 	u8 data;
298 	int ret;
299 
300 	ret = kstrtol(buf, 10, &value);
301 	if (ret)
302 		return ret;
303 
304 	if (chip->channel_id > AD7816_CS_MAX) {
305 		dev_err(dev, "Invalid oti channel id %d.\n", chip->channel_id);
306 		return -EINVAL;
307 	} else if (chip->channel_id == 0) {
308 		if (value < AD7816_BOUND_VALUE_MIN ||
309 		    value > AD7816_BOUND_VALUE_MAX)
310 			return -EINVAL;
311 
312 		data = (u8)(value - AD7816_BOUND_VALUE_MIN +
313 			AD7816_BOUND_VALUE_BASE);
314 	} else {
315 		if (value < AD7816_BOUND_VALUE_BASE || value > 255)
316 			return -EINVAL;
317 
318 		data = (u8)value;
319 	}
320 
321 	ret = ad7816_spi_write(chip, data);
322 	if (ret)
323 		return -EIO;
324 
325 	chip->oti_data[chip->channel_id] = data;
326 
327 	return len;
328 }
329 
330 static IIO_DEVICE_ATTR(oti, 0644,
331 		       ad7816_show_oti, ad7816_set_oti, 0);
332 
333 static struct attribute *ad7816_event_attributes[] = {
334 	&iio_dev_attr_oti.dev_attr.attr,
335 	NULL,
336 };
337 
338 static const struct attribute_group ad7816_event_attribute_group = {
339 	.attrs = ad7816_event_attributes,
340 	.name = "events",
341 };
342 
343 static const struct iio_info ad7816_info = {
344 	.attrs = &ad7816_attribute_group,
345 	.event_attrs = &ad7816_event_attribute_group,
346 };
347 
348 /*
349  * device probe and remove
350  */
351 
ad7816_probe(struct spi_device * spi_dev)352 static int ad7816_probe(struct spi_device *spi_dev)
353 {
354 	struct ad7816_chip_info *chip;
355 	struct iio_dev *indio_dev;
356 	int i, ret;
357 
358 	indio_dev = devm_iio_device_alloc(&spi_dev->dev, sizeof(*chip));
359 	if (!indio_dev)
360 		return -ENOMEM;
361 	chip = iio_priv(indio_dev);
362 	/* this is only used for device removal purposes */
363 	dev_set_drvdata(&spi_dev->dev, indio_dev);
364 
365 	chip->spi_dev = spi_dev;
366 	for (i = 0; i <= AD7816_CS_MAX; i++)
367 		chip->oti_data[i] = 203;
368 
369 	chip->id = spi_get_device_id(spi_dev)->driver_data;
370 	chip->rdwr_pin = devm_gpiod_get(&spi_dev->dev, "rdwr", GPIOD_OUT_HIGH);
371 	if (IS_ERR(chip->rdwr_pin)) {
372 		ret = PTR_ERR(chip->rdwr_pin);
373 		dev_err(&spi_dev->dev, "Failed to request rdwr GPIO: %d\n",
374 			ret);
375 		return ret;
376 	}
377 	chip->convert_pin = devm_gpiod_get(&spi_dev->dev, "convert",
378 					   GPIOD_OUT_HIGH);
379 	if (IS_ERR(chip->convert_pin)) {
380 		ret = PTR_ERR(chip->convert_pin);
381 		dev_err(&spi_dev->dev, "Failed to request convert GPIO: %d\n",
382 			ret);
383 		return ret;
384 	}
385 	if (chip->id == ID_AD7816 || chip->id == ID_AD7817) {
386 		chip->busy_pin = devm_gpiod_get(&spi_dev->dev, "busy",
387 						GPIOD_IN);
388 		if (IS_ERR(chip->busy_pin)) {
389 			ret = PTR_ERR(chip->busy_pin);
390 			dev_err(&spi_dev->dev, "Failed to request busy GPIO: %d\n",
391 				ret);
392 			return ret;
393 		}
394 	}
395 
396 	indio_dev->name = spi_get_device_id(spi_dev)->name;
397 	indio_dev->info = &ad7816_info;
398 	indio_dev->modes = INDIO_DIRECT_MODE;
399 
400 	if (spi_dev->irq) {
401 		/* Only low trigger is supported in ad7816/7/8 */
402 		ret = devm_request_threaded_irq(&spi_dev->dev, spi_dev->irq,
403 						NULL,
404 						&ad7816_event_handler,
405 						IRQF_TRIGGER_LOW | IRQF_ONESHOT,
406 						indio_dev->name,
407 						indio_dev);
408 		if (ret)
409 			return ret;
410 	}
411 
412 	ret = devm_iio_device_register(&spi_dev->dev, indio_dev);
413 	if (ret)
414 		return ret;
415 
416 	dev_info(&spi_dev->dev, "%s temperature sensor and ADC registered.\n",
417 		 indio_dev->name);
418 
419 	return 0;
420 }
421 
422 static const struct of_device_id ad7816_of_match[] = {
423 	{ .compatible = "adi,ad7816", },
424 	{ .compatible = "adi,ad7817", },
425 	{ .compatible = "adi,ad7818", },
426 	{ }
427 };
428 MODULE_DEVICE_TABLE(of, ad7816_of_match);
429 
430 static const struct spi_device_id ad7816_id[] = {
431 	{ "ad7816", ID_AD7816 },
432 	{ "ad7817", ID_AD7817 },
433 	{ "ad7818", ID_AD7818 },
434 	{}
435 };
436 
437 MODULE_DEVICE_TABLE(spi, ad7816_id);
438 
439 static struct spi_driver ad7816_driver = {
440 	.driver = {
441 		.name = "ad7816",
442 		.of_match_table = ad7816_of_match,
443 	},
444 	.probe = ad7816_probe,
445 	.id_table = ad7816_id,
446 };
447 module_spi_driver(ad7816_driver);
448 
449 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
450 MODULE_DESCRIPTION("Analog Devices AD7816/7/8 digital temperature sensor driver");
451 MODULE_LICENSE("GPL v2");
452