drivers/staging/iio/adc/adt75.c

   1 /*
   2  * ADT75 digital temperature sensor driver supporting ADT75
   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/device.h>
  11 #include <linux/kernel.h>
  12 #include <linux/slab.h>
  13 #include <linux/sysfs.h>
  14 #include <linux/i2c.h>
  15 #include <linux/module.h>
  16
  17 #include "../iio.h"
  18 #include "../sysfs.h"
  19
  20 /*
  21  * ADT75 registers definition
  22  */
  23
  24 #define ADT75_TEMPERATURE               0
  25 #define ADT75_CONFIG                    1
  26 #define ADT75_T_HYST                    2
  27 #define ADT75_T_OS                      3
  28 #define ADT75_ONESHOT                   4
  29
  30 /*
  31  * ADT75 config
  32  */
  33 #define ADT75_PD                        0x1
  34 #define ADT75_OS_INT                    0x2
  35 #define ADT75_OS_POLARITY               0x4
  36 #define ADT75_FAULT_QUEUE_MASK          0x18
  37 #define ADT75_FAULT_QUEUE_OFFSET        3
  38 #define ADT75_SMBUS_ALART               0x8
  39
  40 /*
  41  * ADT75 masks
  42  */
  43 #define ADT75_VALUE_SIGN                0x800
  44 #define ADT75_VALUE_OFFSET              4
  45 #define ADT75_VALUE_FLOAT_OFFSET        4
  46 #define ADT75_VALUE_FLOAT_MASK          0xF
  47
  48
  49 /*
  50  * struct adt75_chip_info - chip specifc information
  51  */
  52
  53 struct adt75_chip_info {
  54         struct i2c_client *client;
  55         u8  config;
  56 };
  57
  58 /*
  59  * adt75 register access by I2C
  60  */
  61
  62 static int adt75_i2c_read(struct iio_dev *dev_info, u8 reg, u8 *data)
  63 {
  64         struct adt75_chip_info *chip = iio_priv(dev_info);
  65         struct i2c_client *client = chip->client;
  66         int ret = 0, len;
  67
  68         ret = i2c_smbus_write_byte(client, reg);
  69         if (ret < 0) {
  70                 dev_err(&client->dev, "I2C read register address error\n");
  71                 return ret;
  72         }
  73
  74         if (reg == ADT75_CONFIG || reg == ADT75_ONESHOT)
  75                 len = 1;
  76         else
  77                 len = 2;
  78
  79         ret = i2c_master_recv(client, data, len);
  80         if (ret < 0) {
  81                 dev_err(&client->dev, "I2C read error\n");
  82                 return ret;
  83         }
  84
  85         return ret;
  86 }
  87
  88 static int adt75_i2c_write(struct iio_dev *dev_info, u8 reg, u8 data)
  89 {
  90         struct adt75_chip_info *chip = iio_priv(dev_info);
  91         struct i2c_client *client = chip->client;
  92         int ret = 0;
  93
  94         if (reg == ADT75_CONFIG || reg == ADT75_ONESHOT)
  95                 ret = i2c_smbus_write_byte_data(client, reg, data);
  96         else
  97                 ret = i2c_smbus_write_word_data(client, reg, data);
  98
  99         if (ret < 0)
 100                 dev_err(&client->dev, "I2C write error\n");
 101
 102         return ret;
 103 }
 104
 105 static ssize_t adt75_show_mode(struct device *dev,
 106                 struct device_attribute *attr,
 107                 char *buf)
 108 {
 109         struct adt75_chip_info *chip = iio_priv(dev_get_drvdata(dev));
 110
 111         if (chip->config & ADT75_PD)
 112                 return sprintf(buf, "power-save\n");
 113         else
 114                 return sprintf(buf, "full\n");
 115 }
 116
 117 static ssize_t adt75_store_mode(struct device *dev,
 118                 struct device_attribute *attr,
 119                 const char *buf,
 120                 size_t len)
 121 {
 122         struct iio_dev *dev_info = dev_get_drvdata(dev);
 123         struct adt75_chip_info *chip = iio_priv(dev_info);
 124         int ret;
 125         u8 config;
 126
 127         ret = adt75_i2c_read(dev_info, ADT75_CONFIG, &chip->config);
 128         if (ret)
 129                 return -EIO;
 130
 131         config = chip->config & ~ADT75_PD;
 132         if (!strcmp(buf, "full"))
 133                 config |= ADT75_PD;
 134
 135         ret = adt75_i2c_write(dev_info, ADT75_CONFIG, config);
 136         if (ret)
 137                 return -EIO;
 138
 139         chip->config = config;
 140
 141         return ret;
 142 }
 143
 144 static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
 145                 adt75_show_mode,
 146                 adt75_store_mode,
 147                 0);
 148
 149 static ssize_t adt75_show_available_modes(struct device *dev,
 150                 struct device_attribute *attr,
 151                 char *buf)
 152 {
 153         return sprintf(buf, "full\npower-down\n");
 154 }
 155
 156 static IIO_DEVICE_ATTR(available_modes, S_IRUGO, adt75_show_available_modes, NULL, 0);
 157
 158 static ssize_t adt75_show_oneshot(struct device *dev,
 159                 struct device_attribute *attr,
 160                 char *buf)
 161 {
 162         struct adt75_chip_info *chip = iio_priv(dev_get_drvdata(dev));
 163
 164         return sprintf(buf, "%d\n", !!(chip->config & ADT75_ONESHOT));
 165 }
 166
 167 static ssize_t adt75_store_oneshot(struct device *dev,
 168                 struct device_attribute *attr,
 169                 const char *buf,
 170                 size_t len)
 171 {
 172         struct iio_dev *dev_info = dev_get_drvdata(dev);
 173         struct adt75_chip_info *chip = iio_priv(dev_info);
 174         unsigned long data = 0;
 175         int ret;
 176         u8 config;
 177
 178         ret = strict_strtoul(buf, 10, &data);
 179         if (ret)
 180                 return -EINVAL;
 181
 182
 183         ret = adt75_i2c_read(dev_info, ADT75_CONFIG, &chip->config);
 184         if (ret)
 185                 return -EIO;
 186
 187         config = chip->config & ~ADT75_ONESHOT;
 188         if (data)
 189                 config |= ADT75_ONESHOT;
 190
 191         ret = adt75_i2c_write(dev_info, ADT75_CONFIG, config);
 192         if (ret)
 193                 return -EIO;
 194
 195         chip->config = config;
 196
 197         return ret;
 198 }
 199
 200 static IIO_DEVICE_ATTR(oneshot, S_IRUGO | S_IWUSR,
 201                 adt75_show_oneshot,
 202                 adt75_store_oneshot,
 203                 0);
 204
 205 static ssize_t adt75_show_value(struct device *dev,
 206                 struct device_attribute *attr,
 207                 char *buf)
 208 {
 209         struct iio_dev *dev_info = dev_get_drvdata(dev);
 210         struct adt75_chip_info *chip = iio_priv(dev_info);
 211         u16 data;
 212         char sign = ' ';
 213         int ret;
 214
 215         if (chip->config & ADT75_PD) {
 216                 dev_err(dev, "Can't read value in power-down mode.\n");
 217                 return -EIO;
 218         }
 219
 220         if (chip->config & ADT75_ONESHOT) {
 221                 /* write to active converter */
 222                 ret = i2c_smbus_write_byte(chip->client, ADT75_ONESHOT);
 223                 if (ret)
 224                         return -EIO;
 225         }
 226
 227         ret = adt75_i2c_read(dev_info, ADT75_TEMPERATURE, (u8 *)&data);
 228         if (ret)
 229                 return -EIO;
 230
 231         data = swab16(data) >> ADT75_VALUE_OFFSET;
 232         if (data & ADT75_VALUE_SIGN) {
 233                 /* convert supplement to positive value */
 234                 data = (ADT75_VALUE_SIGN << 1) - data;
 235                 sign = '-';
 236         }
 237
 238         return sprintf(buf, "%c%d.%.4d\n", sign,
 239                 (data >> ADT75_VALUE_FLOAT_OFFSET),
 240                 (data & ADT75_VALUE_FLOAT_MASK) * 625);
 241 }
 242
 243 static IIO_DEVICE_ATTR(value, S_IRUGO, adt75_show_value, NULL, 0);
 244
 245 static struct attribute *adt75_attributes[] = {
 246         &iio_dev_attr_available_modes.dev_attr.attr,
 247         &iio_dev_attr_mode.dev_attr.attr,
 248         &iio_dev_attr_oneshot.dev_attr.attr,
 249         &iio_dev_attr_value.dev_attr.attr,
 250         NULL,
 251 };
 252
 253 static const struct attribute_group adt75_attribute_group = {
 254         .attrs = adt75_attributes,
 255 };
 256
 257 /*
 258  * temperature bound events
 259  */
 260
 261 #define IIO_EVENT_CODE_ADT75_OTI IIO_UNMOD_EVENT_CODE(IIO_TEMP,         \
 262                                                       0,                \
 263                                                       IIO_EV_TYPE_THRESH, \
 264                                                       IIO_EV_DIR_FALLING)
 265
 266 static irqreturn_t adt75_event_handler(int irq, void *private)
 267 {
 268         iio_push_event(private,
 269                        IIO_EVENT_CODE_ADT75_OTI,
 270                        iio_get_time_ns());
 271
 272         return IRQ_HANDLED;
 273 }
 274
 275 static ssize_t adt75_show_oti_mode(struct device *dev,
 276                 struct device_attribute *attr,
 277                 char *buf)
 278 {
 279         struct iio_dev *dev_info = dev_get_drvdata(dev);
 280         struct adt75_chip_info *chip = iio_priv(dev_info);
 281         int ret;
 282
 283         /* retrive ALART status */
 284         ret = adt75_i2c_read(dev_info, ADT75_CONFIG, &chip->config);
 285         if (ret)
 286                 return -EIO;
 287
 288         if (chip->config & ADT75_OS_INT)
 289                 return sprintf(buf, "interrupt\n");
 290         else
 291                 return sprintf(buf, "comparator\n");
 292 }
 293
 294 static ssize_t adt75_set_oti_mode(struct device *dev,
 295                 struct device_attribute *attr,
 296                 const char *buf,
 297                 size_t len)
 298 {
 299         struct iio_dev *dev_info = dev_get_drvdata(dev);
 300         struct adt75_chip_info *chip = iio_priv(dev_info);
 301         int ret;
 302         u8 config;
 303
 304         /* retrive ALART status */
 305         ret = adt75_i2c_read(dev_info, ADT75_CONFIG, &chip->config);
 306         if (ret)
 307                 return -EIO;
 308
 309         config = chip->config & ~ADT75_OS_INT;
 310         if (strcmp(buf, "comparator") != 0)
 311                 config |= ADT75_OS_INT;
 312
 313         ret = adt75_i2c_write(dev_info, ADT75_CONFIG, config);
 314         if (ret)
 315                 return -EIO;
 316
 317         chip->config = config;
 318
 319         return ret;
 320 }
 321
 322 static ssize_t adt75_show_available_oti_modes(struct device *dev,
 323                 struct device_attribute *attr,
 324                 char *buf)
 325 {
 326         return sprintf(buf, "comparator\ninterrupt\n");
 327 }
 328
 329 static ssize_t adt75_show_smbus_alart(struct device *dev,
 330                 struct device_attribute *attr,
 331                 char *buf)
 332 {
 333         struct iio_dev *dev_info = dev_get_drvdata(dev);
 334         struct adt75_chip_info *chip = iio_priv(dev_info);
 335         int ret;
 336
 337         /* retrive ALART status */
 338         ret = adt75_i2c_read(dev_info, ADT75_CONFIG, &chip->config);
 339         if (ret)
 340                 return -EIO;
 341
 342         return sprintf(buf, "%d\n", !!(chip->config & ADT75_SMBUS_ALART));
 343 }
 344
 345 static ssize_t adt75_set_smbus_alart(struct device *dev,
 346                 struct device_attribute *attr,
 347                 const char *buf,
 348                 size_t len)
 349 {
 350         struct iio_dev *dev_info = dev_get_drvdata(dev);
 351         struct adt75_chip_info *chip = iio_priv(dev_info);
 352         unsigned long data = 0;
 353         int ret;
 354         u8 config;
 355
 356         ret = strict_strtoul(buf, 10, &data);
 357         if (ret)
 358                 return -EINVAL;
 359
 360         /* retrive ALART status */
 361         ret = adt75_i2c_read(dev_info, ADT75_CONFIG, &chip->config);
 362         if (ret)
 363                 return -EIO;
 364
 365         config = chip->config & ~ADT75_SMBUS_ALART;
 366         if (data)
 367                 config |= ADT75_SMBUS_ALART;
 368
 369         ret = adt75_i2c_write(dev_info, ADT75_CONFIG, config);
 370         if (ret)
 371                 return -EIO;
 372
 373         chip->config = config;
 374
 375         return ret;
 376 }
 377
 378 static ssize_t adt75_show_fault_queue(struct device *dev,
 379                 struct device_attribute *attr,
 380                 char *buf)
 381 {
 382         struct iio_dev *dev_info = dev_get_drvdata(dev);
 383         struct adt75_chip_info *chip = iio_priv(dev_info);
 384         int ret;
 385
 386         /* retrive ALART status */
 387         ret = adt75_i2c_read(dev_info, ADT75_CONFIG, &chip->config);
 388         if (ret)
 389                 return -EIO;
 390
 391         return sprintf(buf, "%d\n", (chip->config & ADT75_FAULT_QUEUE_MASK) >>
 392                                 ADT75_FAULT_QUEUE_OFFSET);
 393 }
 394
 395 static ssize_t adt75_set_fault_queue(struct device *dev,
 396                 struct device_attribute *attr,
 397                 const char *buf,
 398                 size_t len)
 399 {
 400         struct iio_dev *dev_info = dev_get_drvdata(dev);
 401         struct adt75_chip_info *chip = iio_priv(dev_info);
 402         unsigned long data;
 403         int ret;
 404         u8 config;
 405
 406         ret = strict_strtoul(buf, 10, &data);
 407         if (ret || data > 3)
 408                 return -EINVAL;
 409
 410         /* retrive ALART status */
 411         ret = adt75_i2c_read(dev_info, ADT75_CONFIG, &chip->config);
 412         if (ret)
 413                 return -EIO;
 414
 415         config = chip->config & ~ADT75_FAULT_QUEUE_MASK;
 416         config |= (data << ADT75_FAULT_QUEUE_OFFSET);
 417         ret = adt75_i2c_write(dev_info, ADT75_CONFIG, config);
 418         if (ret)
 419                 return -EIO;
 420
 421         chip->config = config;
 422
 423         return ret;
 424 }
 425 static inline ssize_t adt75_show_t_bound(struct device *dev,
 426                 struct device_attribute *attr,
 427                 char *buf)
 428 {
 429         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 430         struct iio_dev *dev_info = dev_get_drvdata(dev);
 431         u16 data;
 432         char sign = ' ';
 433         int ret;
 434
 435         ret = adt75_i2c_read(dev_info, this_attr->address, (u8 *)&data);
 436         if (ret)
 437                 return -EIO;
 438
 439         data = swab16(data) >> ADT75_VALUE_OFFSET;
 440         if (data & ADT75_VALUE_SIGN) {
 441                 /* convert supplement to positive value */
 442                 data = (ADT75_VALUE_SIGN << 1) - data;
 443                 sign = '-';
 444         }
 445
 446         return sprintf(buf, "%c%d.%.4d\n", sign,
 447                 (data >> ADT75_VALUE_FLOAT_OFFSET),
 448                 (data & ADT75_VALUE_FLOAT_MASK) * 625);
 449 }
 450
 451 static inline ssize_t adt75_set_t_bound(struct device *dev,
 452                 struct device_attribute *attr,
 453                 const char *buf,
 454                 size_t len)
 455 {
 456         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 457         struct iio_dev *dev_info = dev_get_drvdata(dev);
 458         long tmp1, tmp2;
 459         u16 data;
 460         char *pos;
 461         int ret;
 462
 463         pos = strchr(buf, '.');
 464
 465         ret = strict_strtol(buf, 10, &tmp1);
 466
 467         if (ret || tmp1 > 127 || tmp1 < -128)
 468                 return -EINVAL;
 469
 470         if (pos) {
 471                 len = strlen(pos);
 472                 if (len > ADT75_VALUE_FLOAT_OFFSET)
 473                         len = ADT75_VALUE_FLOAT_OFFSET;
 474                 pos[len] = 0;
 475                 ret = strict_strtol(pos, 10, &tmp2);
 476
 477                 if (!ret)
 478                         tmp2 = (tmp2 / 625) * 625;
 479         }
 480
 481         if (tmp1 < 0)
 482                 data = (u16)(-tmp1);
 483         else
 484                 data = (u16)tmp1;
 485         data = (data << ADT75_VALUE_FLOAT_OFFSET) | (tmp2 & ADT75_VALUE_FLOAT_MASK);
 486         if (tmp1 < 0)
 487                 /* convert positive value to supplyment */
 488                 data = (ADT75_VALUE_SIGN << 1) - data;
 489         data <<= ADT75_VALUE_OFFSET;
 490         data = swab16(data);
 491
 492         ret = adt75_i2c_write(dev_info, this_attr->address, (u8)data);
 493         if (ret)
 494                 return -EIO;
 495
 496         return ret;
 497 }
 498
 499
 500 static IIO_DEVICE_ATTR(oti_mode,
 501                        S_IRUGO | S_IWUSR,
 502                        adt75_show_oti_mode, adt75_set_oti_mode, 0);
 503 static IIO_DEVICE_ATTR(available_oti_modes,
 504                        S_IRUGO,
 505                        adt75_show_available_oti_modes, NULL, 0);
 506 static IIO_DEVICE_ATTR(smbus_alart,
 507                        S_IRUGO | S_IWUSR,
 508                        adt75_show_smbus_alart, adt75_set_smbus_alart, 0);
 509 static IIO_DEVICE_ATTR(fault_queue,
 510                        S_IRUGO | S_IWUSR,
 511                        adt75_show_fault_queue, adt75_set_fault_queue, 0);
 512 static IIO_DEVICE_ATTR(t_os_value,
 513                        S_IRUGO | S_IWUSR,
 514                        adt75_show_t_bound, adt75_set_t_bound,
 515                        ADT75_T_OS);
 516 static IIO_DEVICE_ATTR(t_hyst_value,
 517                        S_IRUGO | S_IWUSR,
 518                        adt75_show_t_bound, adt75_set_t_bound,
 519                        ADT75_T_HYST);
 520
 521 static struct attribute *adt75_event_attributes[] = {
 522         &iio_dev_attr_oti_mode.dev_attr.attr,
 523         &iio_dev_attr_available_oti_modes.dev_attr.attr,
 524         &iio_dev_attr_smbus_alart.dev_attr.attr,
 525         &iio_dev_attr_fault_queue.dev_attr.attr,
 526         &iio_dev_attr_t_os_value.dev_attr.attr,
 527         &iio_dev_attr_t_hyst_value.dev_attr.attr,
 528         NULL,
 529 };
 530
 531 static struct attribute_group adt75_event_attribute_group = {
 532         .attrs = adt75_event_attributes,
 533         .name = "events",
 534 };
 535
 536 static const struct iio_info adt75_info = {
 537         .attrs = &adt75_attribute_group,
 538         .event_attrs = &adt75_event_attribute_group,
 539         .driver_module = THIS_MODULE,
 540 };
 541
 542 /*
 543  * device probe and remove
 544  */
 545
 546 static int __devinit adt75_probe(struct i2c_client *client,
 547                 const struct i2c_device_id *id)
 548 {
 549         struct adt75_chip_info *chip;
 550         struct iio_dev *indio_dev;
 551         int ret = 0;
 552
 553         indio_dev = iio_allocate_device(sizeof(*chip));
 554         if (indio_dev == NULL) {
 555                 ret = -ENOMEM;
 556                 goto error_ret;
 557         }
 558         chip = iio_priv(indio_dev);
 559
 560         /* this is only used for device removal purposes */
 561         i2c_set_clientdata(client, indio_dev);
 562
 563         chip->client = client;
 564
 565         indio_dev->name = id->name;
 566         indio_dev->dev.parent = &client->dev;
 567         indio_dev->info = &adt75_info;
 568         indio_dev->modes = INDIO_DIRECT_MODE;
 569
 570         ret = iio_device_register(indio_dev);
 571         if (ret)
 572                 goto error_free_dev;
 573
 574         if (client->irq > 0) {
 575                 ret = request_threaded_irq(client->irq,
 576                                            NULL,
 577                                            &adt75_event_handler,
 578                                            IRQF_TRIGGER_LOW,
 579                                            indio_dev->name,
 580                                            indio_dev);
 581                 if (ret)
 582                         goto error_unreg_dev;
 583
 584                 ret = adt75_i2c_read(indio_dev, ADT75_CONFIG, &chip->config);
 585                 if (ret) {
 586                         ret = -EIO;
 587                         goto error_unreg_irq;
 588                 }
 589
 590                 /* set irq polarity low level */
 591                 chip->config &= ~ADT75_OS_POLARITY;
 592
 593                 ret = adt75_i2c_write(indio_dev, ADT75_CONFIG, chip->config);
 594                 if (ret) {
 595                         ret = -EIO;
 596                         goto error_unreg_irq;
 597                 }
 598         }
 599
 600         dev_info(&client->dev, "%s temperature sensor registered.\n",
 601                          indio_dev->name);
 602
 603         return 0;
 604 error_unreg_irq:
 605         free_irq(client->irq, indio_dev);
 606 error_unreg_dev:
 607         iio_device_unregister(indio_dev);
 608 error_free_dev:
 609         iio_free_device(indio_dev);
 610 error_ret:
 611         return ret;
 612 }
 613
 614 static int __devexit adt75_remove(struct i2c_client *client)
 615 {
 616         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 617
 618         if (client->irq)
 619                 free_irq(client->irq, indio_dev);
 620         iio_device_unregister(indio_dev);
 621         iio_free_device(indio_dev);
 622
 623         return 0;
 624 }
 625
 626 static const struct i2c_device_id adt75_id[] = {
 627         { "adt75", 0 },
 628         {}
 629 };
 630
 631 MODULE_DEVICE_TABLE(i2c, adt75_id);
 632
 633 static struct i2c_driver adt75_driver = {
 634         .driver = {
 635                 .name = "adt75",
 636         },
 637         .probe = adt75_probe,
 638         .remove = __devexit_p(adt75_remove),
 639         .id_table = adt75_id,
 640 };
 641
 642 static __init int adt75_init(void)
 643 {
 644         return i2c_add_driver(&adt75_driver);
 645 }
 646
 647 static __exit void adt75_exit(void)
 648 {
 649         i2c_del_driver(&adt75_driver);
 650 }
 651
 652 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
 653 MODULE_DESCRIPTION("Analog Devices ADT75 digital"
 654                         " temperature sensor driver");
 655 MODULE_LICENSE("GPL v2");
 656
 657 module_init(adt75_init);
 658 module_exit(adt75_exit);