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