2 * AD7816 digital temperature sensor driver supporting AD7816/7/8
4 * Copyright 2010 Analog Devices Inc.
6 * Licensed under the GPL-2 or later.
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>
19 #include <linux/iio/iio.h>
20 #include <linux/iio/sysfs.h>
21 #include <linux/iio/events.h>
26 #define AD7816_FULL 0x1
28 #define AD7816_CS_MASK 0x7
29 #define AD7816_CS_MAX 0x4
32 * AD7816 temperature masks
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
42 * struct ad7816_chip_info - chip specific information
45 struct ad7816_chip_info
{
46 struct spi_device
*spi_dev
;
50 u8 oti_data
[AD7816_CS_MAX
+ 1];
51 u8 channel_id
; /* 0 always be temperature */
56 * ad7816 data access by SPI
58 static int ad7816_spi_read(struct ad7816_chip_info
*chip
, u16
*data
)
60 struct spi_device
*spi_dev
= chip
->spi_dev
;
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
));
68 dev_err(&spi_dev
->dev
, "SPI channel setting error\n");
71 gpio_set_value(chip
->rdwr_pin
, 1);
73 if (chip
->mode
== AD7816_PD
) { /* operating mode 2 */
74 gpio_set_value(chip
->convert_pin
, 1);
75 gpio_set_value(chip
->convert_pin
, 0);
76 } else { /* operating mode 1 */
77 gpio_set_value(chip
->convert_pin
, 0);
78 gpio_set_value(chip
->convert_pin
, 1);
81 while (gpio_get_value(chip
->busy_pin
))
84 gpio_set_value(chip
->rdwr_pin
, 0);
85 gpio_set_value(chip
->rdwr_pin
, 1);
86 ret
= spi_read(spi_dev
, &buf
, sizeof(*data
));
88 dev_err(&spi_dev
->dev
, "SPI data read error\n");
92 *data
= be16_to_cpu(buf
);
97 static int ad7816_spi_write(struct ad7816_chip_info
*chip
, u8 data
)
99 struct spi_device
*spi_dev
= chip
->spi_dev
;
102 gpio_set_value(chip
->rdwr_pin
, 1);
103 gpio_set_value(chip
->rdwr_pin
, 0);
104 ret
= spi_write(spi_dev
, &data
, sizeof(data
));
106 dev_err(&spi_dev
->dev
, "SPI oti data write error\n");
111 static ssize_t
ad7816_show_mode(struct device
*dev
,
112 struct device_attribute
*attr
,
115 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
116 struct ad7816_chip_info
*chip
= iio_priv(indio_dev
);
119 return sprintf(buf
, "power-save\n");
120 return sprintf(buf
, "full\n");
123 static ssize_t
ad7816_store_mode(struct device
*dev
,
124 struct device_attribute
*attr
,
128 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
129 struct ad7816_chip_info
*chip
= iio_priv(indio_dev
);
131 if (strcmp(buf
, "full")) {
132 gpio_set_value(chip
->rdwr_pin
, 1);
133 chip
->mode
= AD7816_FULL
;
135 gpio_set_value(chip
->rdwr_pin
, 0);
136 chip
->mode
= AD7816_PD
;
142 static IIO_DEVICE_ATTR(mode
, S_IRUGO
| S_IWUSR
,
147 static ssize_t
ad7816_show_available_modes(struct device
*dev
,
148 struct device_attribute
*attr
,
151 return sprintf(buf
, "full\npower-save\n");
154 static IIO_DEVICE_ATTR(available_modes
, S_IRUGO
, ad7816_show_available_modes
,
157 static ssize_t
ad7816_show_channel(struct device
*dev
,
158 struct device_attribute
*attr
,
161 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
162 struct ad7816_chip_info
*chip
= iio_priv(indio_dev
);
164 return sprintf(buf
, "%d\n", chip
->channel_id
);
167 static ssize_t
ad7816_store_channel(struct device
*dev
,
168 struct device_attribute
*attr
,
172 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
173 struct ad7816_chip_info
*chip
= iio_priv(indio_dev
);
177 ret
= kstrtoul(buf
, 10, &data
);
181 if (data
> AD7816_CS_MAX
&& data
!= AD7816_CS_MASK
) {
182 dev_err(&chip
->spi_dev
->dev
, "Invalid channel id %lu for %s.\n",
183 data
, indio_dev
->name
);
185 } else if (strcmp(indio_dev
->name
, "ad7818") == 0 && data
> 1) {
186 dev_err(&chip
->spi_dev
->dev
,
187 "Invalid channel id %lu for ad7818.\n", data
);
189 } else if (strcmp(indio_dev
->name
, "ad7816") == 0 && data
> 0) {
190 dev_err(&chip
->spi_dev
->dev
,
191 "Invalid channel id %lu for ad7816.\n", data
);
195 chip
->channel_id
= data
;
200 static IIO_DEVICE_ATTR(channel
, S_IRUGO
| S_IWUSR
,
202 ad7816_store_channel
,
205 static ssize_t
ad7816_show_value(struct device
*dev
,
206 struct device_attribute
*attr
,
209 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
210 struct ad7816_chip_info
*chip
= iio_priv(indio_dev
);
215 ret
= ad7816_spi_read(chip
, &data
);
219 data
>>= AD7816_VALUE_OFFSET
;
221 if (chip
->channel_id
== 0) {
222 value
= (s8
)((data
>> AD7816_TEMP_FLOAT_OFFSET
) - 103);
223 data
&= AD7816_TEMP_FLOAT_MASK
;
225 data
= (1 << AD7816_TEMP_FLOAT_OFFSET
) - data
;
226 return sprintf(buf
, "%d.%.2d\n", value
, data
* 25);
228 return sprintf(buf
, "%u\n", data
);
231 static IIO_DEVICE_ATTR(value
, S_IRUGO
, ad7816_show_value
, NULL
, 0);
233 static struct attribute
*ad7816_attributes
[] = {
234 &iio_dev_attr_available_modes
.dev_attr
.attr
,
235 &iio_dev_attr_mode
.dev_attr
.attr
,
236 &iio_dev_attr_channel
.dev_attr
.attr
,
237 &iio_dev_attr_value
.dev_attr
.attr
,
241 static const struct attribute_group ad7816_attribute_group
= {
242 .attrs
= ad7816_attributes
,
246 * temperature bound events
249 #define IIO_EVENT_CODE_AD7816_OTI IIO_UNMOD_EVENT_CODE(IIO_TEMP, \
251 IIO_EV_TYPE_THRESH, \
254 static irqreturn_t
ad7816_event_handler(int irq
, void *private)
256 iio_push_event(private, IIO_EVENT_CODE_AD7816_OTI
, iio_get_time_ns());
260 static ssize_t
ad7816_show_oti(struct device
*dev
,
261 struct device_attribute
*attr
,
264 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
265 struct ad7816_chip_info
*chip
= iio_priv(indio_dev
);
268 if (chip
->channel_id
> AD7816_CS_MAX
) {
269 dev_err(dev
, "Invalid oti channel id %d.\n", chip
->channel_id
);
271 } else if (chip
->channel_id
== 0) {
272 value
= AD7816_BOUND_VALUE_MIN
+
273 (chip
->oti_data
[chip
->channel_id
] -
274 AD7816_BOUND_VALUE_BASE
);
275 return sprintf(buf
, "%d\n", value
);
277 return sprintf(buf
, "%u\n", chip
->oti_data
[chip
->channel_id
]);
280 static inline ssize_t
ad7816_set_oti(struct device
*dev
,
281 struct device_attribute
*attr
,
285 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
286 struct ad7816_chip_info
*chip
= iio_priv(indio_dev
);
291 ret
= kstrtol(buf
, 10, &value
);
295 if (chip
->channel_id
> AD7816_CS_MAX
) {
296 dev_err(dev
, "Invalid oti channel id %d.\n", chip
->channel_id
);
298 } else if (chip
->channel_id
== 0) {
299 if (ret
|| value
< AD7816_BOUND_VALUE_MIN
||
300 value
> AD7816_BOUND_VALUE_MAX
)
303 data
= (u8
)(value
- AD7816_BOUND_VALUE_MIN
+
304 AD7816_BOUND_VALUE_BASE
);
306 if (ret
|| value
< AD7816_BOUND_VALUE_BASE
|| value
> 255)
312 ret
= ad7816_spi_write(chip
, data
);
316 chip
->oti_data
[chip
->channel_id
] = data
;
321 static IIO_DEVICE_ATTR(oti
, S_IRUGO
| S_IWUSR
,
322 ad7816_show_oti
, ad7816_set_oti
, 0);
324 static struct attribute
*ad7816_event_attributes
[] = {
325 &iio_dev_attr_oti
.dev_attr
.attr
,
329 static struct attribute_group ad7816_event_attribute_group
= {
330 .attrs
= ad7816_event_attributes
,
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
,
341 * device probe and remove
344 static int ad7816_probe(struct spi_device
*spi_dev
)
346 struct ad7816_chip_info
*chip
;
347 struct iio_dev
*indio_dev
;
348 unsigned short *pins
= spi_dev
->dev
.platform_data
;
353 dev_err(&spi_dev
->dev
, "No necessary GPIO platform data.\n");
357 indio_dev
= devm_iio_device_alloc(&spi_dev
->dev
, sizeof(*chip
));
360 chip
= iio_priv(indio_dev
);
361 /* this is only used for device removal purposes */
362 dev_set_drvdata(&spi_dev
->dev
, indio_dev
);
364 chip
->spi_dev
= spi_dev
;
365 for (i
= 0; i
<= AD7816_CS_MAX
; i
++)
366 chip
->oti_data
[i
] = 203;
367 chip
->rdwr_pin
= pins
[0];
368 chip
->convert_pin
= pins
[1];
369 chip
->busy_pin
= pins
[2];
371 ret
= devm_gpio_request(&spi_dev
->dev
, chip
->rdwr_pin
,
372 spi_get_device_id(spi_dev
)->name
);
374 dev_err(&spi_dev
->dev
, "Fail to request rdwr gpio PIN %d.\n",
378 gpio_direction_input(chip
->rdwr_pin
);
379 ret
= devm_gpio_request(&spi_dev
->dev
, chip
->convert_pin
,
380 spi_get_device_id(spi_dev
)->name
);
382 dev_err(&spi_dev
->dev
, "Fail to request convert gpio PIN %d.\n",
386 gpio_direction_input(chip
->convert_pin
);
387 ret
= devm_gpio_request(&spi_dev
->dev
, chip
->busy_pin
,
388 spi_get_device_id(spi_dev
)->name
);
390 dev_err(&spi_dev
->dev
, "Fail to request busy gpio PIN %d.\n",
394 gpio_direction_input(chip
->busy_pin
);
396 indio_dev
->name
= spi_get_device_id(spi_dev
)->name
;
397 indio_dev
->dev
.parent
= &spi_dev
->dev
;
398 indio_dev
->info
= &ad7816_info
;
399 indio_dev
->modes
= INDIO_DIRECT_MODE
;
402 /* Only low trigger is supported in ad7816/7/8 */
403 ret
= devm_request_threaded_irq(&spi_dev
->dev
, spi_dev
->irq
,
405 &ad7816_event_handler
,
406 IRQF_TRIGGER_LOW
| IRQF_ONESHOT
,
413 ret
= devm_iio_device_register(&spi_dev
->dev
, indio_dev
);
417 dev_info(&spi_dev
->dev
, "%s temperature sensor and ADC registered.\n",
423 static const struct spi_device_id ad7816_id
[] = {
430 MODULE_DEVICE_TABLE(spi
, ad7816_id
);
432 static struct spi_driver ad7816_driver
= {
436 .probe
= ad7816_probe
,
437 .id_table
= ad7816_id
,
439 module_spi_driver(ad7816_driver
);
441 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
442 MODULE_DESCRIPTION("Analog Devices AD7816/7/8 digital temperature sensor driver");
443 MODULE_LICENSE("GPL v2");