2
* AD7298 digital temperature sensor driver supporting AD7298
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/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/spi/spi.h>
18
#include <linux/rtc.h>
27
#define AD7298_T_AVG_MASK 0x2
28
#define AD7298_EXT_REF 0x4
29
#define AD7298_T_SENSE_MASK 0x20
30
#define AD7298_VOLTAGE_MASK 0x3fc0
31
#define AD7298_VOLTAGE_OFFSET 0x6
32
#define AD7298_VOLTAGE_LIMIT_COUNT 8
33
#define AD7298_REPEAT 0x40
34
#define AD7298_WRITE 0x80
39
#define AD7298_CHANNEL_MASK 0xf000
40
#define AD7298_VALUE_MASK 0xfff
41
#define AD7298_T_VALUE_SIGN 0x400
42
#define AD7298_T_VALUE_FLOAT_OFFSET 2
43
#define AD7298_T_VALUE_FLOAT_MASK 0x2
46
* struct ad7298_chip_info - chip specifc information
49
struct ad7298_chip_info {
51
struct spi_device *spi_dev;
52
struct iio_dev *indio_dev;
55
u8 channels; /* Active voltage channels */
59
* ad7298 register access by SPI
61
static int ad7298_spi_write(struct ad7298_chip_info *chip, u16 data)
63
struct spi_device *spi_dev = chip->spi_dev;
67
data = cpu_to_be16(data);
68
ret = spi_write(spi_dev, (u8 *)&data, sizeof(data));
70
dev_err(&spi_dev->dev, "SPI write error\n");
75
static int ad7298_spi_read(struct ad7298_chip_info *chip, u16 mask, u16 *data)
77
struct spi_device *spi_dev = chip->spi_dev;
79
u8 count = chip->channels;
83
if (mask & AD7298_T_SENSE_MASK) {
84
command = chip->command & ~(AD7298_T_AVG_MASK | AD7298_VOLTAGE_MASK);
85
command |= AD7298_T_SENSE_MASK;
87
} else if (mask & AD7298_T_AVG_MASK) {
88
command = chip->command & ~AD7298_VOLTAGE_MASK;
89
command |= AD7298_T_SENSE_MASK | AD7298_T_AVG_MASK;
91
} else if (mask & AD7298_VOLTAGE_MASK) {
92
command = chip->command & ~(AD7298_T_AVG_MASK | AD7298_T_SENSE_MASK);
93
count = chip->channels;
96
ret = ad7298_spi_write(chip, chip->command);
98
dev_err(&spi_dev->dev, "SPI write command error\n");
102
ret = spi_read(spi_dev, (u8 *)&command, sizeof(command));
104
dev_err(&spi_dev->dev, "SPI read error\n");
109
while (i && gpio_get_value(chip->busy_pin)) {
114
dev_err(&spi_dev->dev, "Always in busy convertion.\n");
118
for (i = 0; i < count; i++) {
119
ret = spi_read(spi_dev, (u8 *)&data[i], sizeof(data[i]));
121
dev_err(&spi_dev->dev, "SPI read error\n");
124
*data = be16_to_cpu(data[i]);
130
static ssize_t ad7298_show_mode(struct device *dev,
131
struct device_attribute *attr,
134
struct iio_dev *dev_info = dev_get_drvdata(dev);
135
struct ad7298_chip_info *chip = dev_info->dev_data;
137
if (chip->command & AD7298_REPEAT)
138
return sprintf(buf, "repeat\n");
140
return sprintf(buf, "normal\n");
143
static ssize_t ad7298_store_mode(struct device *dev,
144
struct device_attribute *attr,
148
struct iio_dev *dev_info = dev_get_drvdata(dev);
149
struct ad7298_chip_info *chip = dev_info->dev_data;
151
if (strcmp(buf, "repeat"))
152
chip->command |= AD7298_REPEAT;
154
chip->command &= (~AD7298_REPEAT);
159
static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
164
static ssize_t ad7298_show_available_modes(struct device *dev,
165
struct device_attribute *attr,
168
return sprintf(buf, "normal\nrepeat\n");
171
static IIO_DEVICE_ATTR(available_modes, S_IRUGO, ad7298_show_available_modes, NULL, 0);
173
static ssize_t ad7298_store_reset(struct device *dev,
174
struct device_attribute *attr,
178
struct iio_dev *dev_info = dev_get_drvdata(dev);
179
struct ad7298_chip_info *chip = dev_info->dev_data;
183
command = chip->command & ~AD7298_PD;
185
ret = ad7298_spi_write(chip, command);
189
command = chip->command | AD7298_PD;
191
ret = ad7298_spi_write(chip, command);
198
static IIO_DEVICE_ATTR(reset, S_IWUSR,
203
static ssize_t ad7298_show_ext_ref(struct device *dev,
204
struct device_attribute *attr,
207
struct iio_dev *dev_info = dev_get_drvdata(dev);
208
struct ad7298_chip_info *chip = dev_info->dev_data;
210
return sprintf(buf, "%d\n", !!(chip->command & AD7298_EXT_REF));
213
static ssize_t ad7298_store_ext_ref(struct device *dev,
214
struct device_attribute *attr,
218
struct iio_dev *dev_info = dev_get_drvdata(dev);
219
struct ad7298_chip_info *chip = dev_info->dev_data;
223
command = chip->command & (~AD7298_EXT_REF);
224
if (strcmp(buf, "1"))
225
command |= AD7298_EXT_REF;
227
ret = ad7298_spi_write(chip, command);
231
chip->command = command;
236
static IIO_DEVICE_ATTR(ext_ref, S_IRUGO | S_IWUSR,
238
ad7298_store_ext_ref,
241
static ssize_t ad7298_show_t_sense(struct device *dev,
242
struct device_attribute *attr,
245
struct iio_dev *dev_info = dev_get_drvdata(dev);
246
struct ad7298_chip_info *chip = dev_info->dev_data;
251
ret = ad7298_spi_read(chip, AD7298_T_SENSE_MASK, &data);
255
if (data & AD7298_T_VALUE_SIGN) {
256
/* convert supplement to positive value */
257
data = (AD7298_T_VALUE_SIGN << 1) - data;
261
return sprintf(buf, "%c%d.%.2d\n", sign,
262
(data >> AD7298_T_VALUE_FLOAT_OFFSET),
263
(data & AD7298_T_VALUE_FLOAT_MASK) * 25);
266
static IIO_DEVICE_ATTR(t_sense, S_IRUGO, ad7298_show_t_sense, NULL, 0);
268
static ssize_t ad7298_show_t_average(struct device *dev,
269
struct device_attribute *attr,
272
struct iio_dev *dev_info = dev_get_drvdata(dev);
273
struct ad7298_chip_info *chip = dev_info->dev_data;
278
ret = ad7298_spi_read(chip, AD7298_T_AVG_MASK, data);
282
if (data[1] & AD7298_T_VALUE_SIGN) {
283
/* convert supplement to positive value */
284
data[1] = (AD7298_T_VALUE_SIGN << 1) - data[1];
288
return sprintf(buf, "%c%d.%.2d\n", sign,
289
(data[1] >> AD7298_T_VALUE_FLOAT_OFFSET),
290
(data[1] & AD7298_T_VALUE_FLOAT_MASK) * 25);
293
static IIO_DEVICE_ATTR(t_average, S_IRUGO, ad7298_show_t_average, NULL, 0);
295
static ssize_t ad7298_show_voltage(struct device *dev,
296
struct device_attribute *attr,
299
struct iio_dev *dev_info = dev_get_drvdata(dev);
300
struct ad7298_chip_info *chip = dev_info->dev_data;
301
u16 data[AD7298_VOLTAGE_LIMIT_COUNT];
304
ret = ad7298_spi_read(chip, AD7298_VOLTAGE_MASK, data);
308
for (i = 0; i < AD7298_VOLTAGE_LIMIT_COUNT; i++) {
309
if (chip->command & (AD7298_T_SENSE_MASK << i)) {
310
ret = sprintf(buf, "channel[%d]=%d\n", i,
311
data[i] & AD7298_VALUE_MASK);
322
static IIO_DEVICE_ATTR(voltage, S_IRUGO, ad7298_show_voltage, NULL, 0);
324
static ssize_t ad7298_show_channel_mask(struct device *dev,
325
struct device_attribute *attr,
328
struct iio_dev *dev_info = dev_get_drvdata(dev);
329
struct ad7298_chip_info *chip = dev_info->dev_data;
331
return sprintf(buf, "0x%x\n", (chip->command & AD7298_VOLTAGE_MASK) >>
332
AD7298_VOLTAGE_OFFSET);
335
static ssize_t ad7298_store_channel_mask(struct device *dev,
336
struct device_attribute *attr,
340
struct iio_dev *dev_info = dev_get_drvdata(dev);
341
struct ad7298_chip_info *chip = dev_info->dev_data;
345
ret = strict_strtoul(buf, 16, &data);
346
if (ret || data > 0xff)
349
chip->command &= (~AD7298_VOLTAGE_MASK);
350
chip->command |= data << AD7298_VOLTAGE_OFFSET;
352
for (i = 0, chip->channels = 0; i < AD7298_VOLTAGE_LIMIT_COUNT; i++) {
353
if (chip->command & (AD7298_T_SENSE_MASK << i))
360
static IIO_DEVICE_ATTR(channel_mask, S_IRUGO | S_IWUSR,
361
ad7298_show_channel_mask,
362
ad7298_store_channel_mask,
365
static ssize_t ad7298_show_name(struct device *dev,
366
struct device_attribute *attr,
369
struct iio_dev *dev_info = dev_get_drvdata(dev);
370
struct ad7298_chip_info *chip = dev_info->dev_data;
371
return sprintf(buf, "%s\n", chip->name);
374
static IIO_DEVICE_ATTR(name, S_IRUGO, ad7298_show_name, NULL, 0);
376
static struct attribute *ad7298_attributes[] = {
377
&iio_dev_attr_available_modes.dev_attr.attr,
378
&iio_dev_attr_mode.dev_attr.attr,
379
&iio_dev_attr_reset.dev_attr.attr,
380
&iio_dev_attr_ext_ref.dev_attr.attr,
381
&iio_dev_attr_t_sense.dev_attr.attr,
382
&iio_dev_attr_t_average.dev_attr.attr,
383
&iio_dev_attr_voltage.dev_attr.attr,
384
&iio_dev_attr_channel_mask.dev_attr.attr,
385
&iio_dev_attr_name.dev_attr.attr,
389
static const struct attribute_group ad7298_attribute_group = {
390
.attrs = ad7298_attributes,
394
* device probe and remove
396
static int __devinit ad7298_probe(struct spi_device *spi_dev)
398
struct ad7298_chip_info *chip;
399
unsigned short *pins = spi_dev->dev.platform_data;
402
chip = kzalloc(sizeof(struct ad7298_chip_info), GFP_KERNEL);
407
/* this is only used for device removal purposes */
408
dev_set_drvdata(&spi_dev->dev, chip);
410
chip->spi_dev = spi_dev;
411
chip->name = spi_dev->modalias;
412
chip->busy_pin = pins[0];
414
ret = gpio_request(chip->busy_pin, chip->name);
416
dev_err(&spi_dev->dev, "Fail to request busy gpio PIN %d.\n",
418
goto error_free_chip;
420
gpio_direction_input(chip->busy_pin);
422
chip->indio_dev = iio_allocate_device();
423
if (chip->indio_dev == NULL) {
425
goto error_free_gpio;
428
chip->indio_dev->dev.parent = &spi_dev->dev;
429
chip->indio_dev->attrs = &ad7298_attribute_group;
430
chip->indio_dev->dev_data = (void *)chip;
431
chip->indio_dev->driver_module = THIS_MODULE;
432
chip->indio_dev->modes = INDIO_DIRECT_MODE;
434
ret = iio_device_register(chip->indio_dev);
438
dev_info(&spi_dev->dev, "%s temperature sensor and ADC registered.\n",
444
iio_free_device(chip->indio_dev);
446
gpio_free(chip->busy_pin);
453
static int __devexit ad7298_remove(struct spi_device *spi_dev)
455
struct ad7298_chip_info *chip = dev_get_drvdata(&spi_dev->dev);
456
struct iio_dev *indio_dev = chip->indio_dev;
458
dev_set_drvdata(&spi_dev->dev, NULL);
459
iio_device_unregister(indio_dev);
460
iio_free_device(chip->indio_dev);
461
gpio_free(chip->busy_pin);
467
static const struct spi_device_id ad7298_id[] = {
472
MODULE_DEVICE_TABLE(spi, ad7298_id);
474
static struct spi_driver ad7298_driver = {
477
.bus = &spi_bus_type,
478
.owner = THIS_MODULE,
480
.probe = ad7298_probe,
481
.remove = __devexit_p(ad7298_remove),
482
.id_table = ad7298_id,
485
static __init int ad7298_init(void)
487
return spi_register_driver(&ad7298_driver);
490
static __exit void ad7298_exit(void)
492
spi_unregister_driver(&ad7298_driver);
495
MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
496
MODULE_DESCRIPTION("Analog Devices AD7298 digital"
497
" temperature sensor and ADC driver");
498
MODULE_LICENSE("GPL v2");
500
module_init(ad7298_init);
501
module_exit(ad7298_exit);