drivers/staging/iio/adc/ad7816.c

   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  */
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 470 static __init int ad7816_init(void)
 471 {
 472         return spi_register_driver(&ad7816_driver);
 473 }
 474
 475 static __exit void ad7816_exit(void)
 476 {
 477         spi_unregister_driver(&ad7816_driver);
 478 }
 479
 480 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
 481 MODULE_DESCRIPTION("Analog Devices AD7816/7/8 digital"
 482                         " temperature sensor driver");
 483 MODULE_LICENSE("GPL v2");
 484
 485 module_init(ad7816_init);
 486 module_exit(ad7816_exit);