drivers/staging/iio/adc/adt7410.c

   1 /*
   2  * ADT7410 digital temperature sensor driver supporting ADT7410
   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/list.h>
  15 #include <linux/i2c.h>
  16 #include <linux/module.h>
  17
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/sysfs.h>
  20 #include <linux/iio/events.h>
  21
  22 /*
  23  * ADT7410 registers definition
  24  */
  25
  26 #define ADT7410_TEMPERATURE             0
  27 #define ADT7410_STATUS                  2
  28 #define ADT7410_CONFIG                  3
  29 #define ADT7410_T_ALARM_HIGH            4
  30 #define ADT7410_T_ALARM_LOW             6
  31 #define ADT7410_T_CRIT                  8
  32 #define ADT7410_T_HYST                  0xA
  33 #define ADT7410_ID                      0xB
  34 #define ADT7410_RESET                   0x2F
  35
  36 /*
  37  * ADT7410 status
  38  */
  39 #define ADT7410_STAT_T_LOW              0x10
  40 #define ADT7410_STAT_T_HIGH             0x20
  41 #define ADT7410_STAT_T_CRIT             0x40
  42 #define ADT7410_STAT_NOT_RDY            0x80
  43
  44 /*
  45  * ADT7410 config
  46  */
  47 #define ADT7410_FAULT_QUEUE_MASK        0x3
  48 #define ADT7410_CT_POLARITY             0x4
  49 #define ADT7410_INT_POLARITY            0x8
  50 #define ADT7410_EVENT_MODE              0x10
  51 #define ADT7410_MODE_MASK               0x60
  52 #define ADT7410_ONESHOT                 0x20
  53 #define ADT7410_SPS                     0x40
  54 #define ADT7410_PD                      0x60
  55 #define ADT7410_RESOLUTION              0x80
  56
  57 /*
  58  * ADT7410 masks
  59  */
  60 #define ADT7410_T16_VALUE_SIGN                  0x8000
  61 #define ADT7410_T16_VALUE_FLOAT_OFFSET          7
  62 #define ADT7410_T16_VALUE_FLOAT_MASK            0x7F
  63 #define ADT7410_T13_VALUE_SIGN                  0x1000
  64 #define ADT7410_T13_VALUE_OFFSET                3
  65 #define ADT7410_T13_VALUE_FLOAT_OFFSET          4
  66 #define ADT7410_T13_VALUE_FLOAT_MASK            0xF
  67 #define ADT7410_T_HYST_MASK                     0xF
  68 #define ADT7410_DEVICE_ID_MASK                  0xF
  69 #define ADT7410_MANUFACTORY_ID_MASK             0xF0
  70 #define ADT7410_MANUFACTORY_ID_OFFSET           4
  71
  72 #define ADT7410_IRQS                            2
  73
  74 /*
  75  * struct adt7410_chip_info - chip specifc information
  76  */
  77
  78 struct adt7410_chip_info {
  79         struct i2c_client *client;
  80         u8  config;
  81 };
  82
  83 /*
  84  * adt7410 register access by I2C
  85  */
  86
  87 static int adt7410_i2c_read_word(struct adt7410_chip_info *chip, u8 reg, u16 *data)
  88 {
  89         struct i2c_client *client = chip->client;
  90         int ret = 0;
  91
  92         ret = i2c_smbus_read_word_data(client, reg);
  93         if (ret < 0) {
  94                 dev_err(&client->dev, "I2C read error\n");
  95                 return ret;
  96         }
  97
  98         *data = swab16((u16)ret);
  99
 100         return 0;
 101 }
 102
 103 static int adt7410_i2c_write_word(struct adt7410_chip_info *chip, u8 reg, u16 data)
 104 {
 105         struct i2c_client *client = chip->client;
 106         int ret = 0;
 107
 108         ret = i2c_smbus_write_word_data(client, reg, swab16(data));
 109         if (ret < 0)
 110                 dev_err(&client->dev, "I2C write error\n");
 111
 112         return ret;
 113 }
 114
 115 static int adt7410_i2c_read_byte(struct adt7410_chip_info *chip, u8 reg, u8 *data)
 116 {
 117         struct i2c_client *client = chip->client;
 118         int ret = 0;
 119
 120         ret = i2c_smbus_read_byte_data(client, reg);
 121         if (ret < 0) {
 122                 dev_err(&client->dev, "I2C read error\n");
 123                 return ret;
 124         }
 125
 126         *data = (u8)ret;
 127
 128         return 0;
 129 }
 130
 131 static int adt7410_i2c_write_byte(struct adt7410_chip_info *chip, u8 reg, u8 data)
 132 {
 133         struct i2c_client *client = chip->client;
 134         int ret = 0;
 135
 136         ret = i2c_smbus_write_byte_data(client, reg, data);
 137         if (ret < 0)
 138                 dev_err(&client->dev, "I2C write error\n");
 139
 140         return ret;
 141 }
 142
 143 static ssize_t adt7410_show_mode(struct device *dev,
 144                 struct device_attribute *attr,
 145                 char *buf)
 146 {
 147         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 148         struct adt7410_chip_info *chip = iio_priv(dev_info);
 149         u8 config;
 150
 151         config = chip->config & ADT7410_MODE_MASK;
 152
 153         switch (config) {
 154         case ADT7410_PD:
 155                 return sprintf(buf, "power-down\n");
 156         case ADT7410_ONESHOT:
 157                 return sprintf(buf, "one-shot\n");
 158         case ADT7410_SPS:
 159                 return sprintf(buf, "sps\n");
 160         default:
 161                 return sprintf(buf, "full\n");
 162         }
 163 }
 164
 165 static ssize_t adt7410_store_mode(struct device *dev,
 166                 struct device_attribute *attr,
 167                 const char *buf,
 168                 size_t len)
 169 {
 170         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 171         struct adt7410_chip_info *chip = iio_priv(dev_info);
 172         u16 config;
 173         int ret;
 174
 175         ret = adt7410_i2c_read_byte(chip, ADT7410_CONFIG, &chip->config);
 176         if (ret)
 177                 return -EIO;
 178
 179         config = chip->config & (~ADT7410_MODE_MASK);
 180         if (strcmp(buf, "power-down"))
 181                 config |= ADT7410_PD;
 182         else if (strcmp(buf, "one-shot"))
 183                 config |= ADT7410_ONESHOT;
 184         else if (strcmp(buf, "sps"))
 185                 config |= ADT7410_SPS;
 186
 187         ret = adt7410_i2c_write_byte(chip, ADT7410_CONFIG, config);
 188         if (ret)
 189                 return -EIO;
 190
 191         chip->config = config;
 192
 193         return ret;
 194 }
 195
 196 static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
 197                 adt7410_show_mode,
 198                 adt7410_store_mode,
 199                 0);
 200
 201 static ssize_t adt7410_show_available_modes(struct device *dev,
 202                 struct device_attribute *attr,
 203                 char *buf)
 204 {
 205         return sprintf(buf, "full\none-shot\nsps\npower-down\n");
 206 }
 207
 208 static IIO_DEVICE_ATTR(available_modes, S_IRUGO, adt7410_show_available_modes, NULL, 0);
 209
 210 static ssize_t adt7410_show_resolution(struct device *dev,
 211                 struct device_attribute *attr,
 212                 char *buf)
 213 {
 214         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 215         struct adt7410_chip_info *chip = iio_priv(dev_info);
 216         int ret;
 217         int bits;
 218
 219         ret = adt7410_i2c_read_byte(chip, ADT7410_CONFIG, &chip->config);
 220         if (ret)
 221                 return -EIO;
 222
 223         if (chip->config & ADT7410_RESOLUTION)
 224                 bits = 16;
 225         else
 226                 bits = 13;
 227
 228         return sprintf(buf, "%d bits\n", bits);
 229 }
 230
 231 static ssize_t adt7410_store_resolution(struct device *dev,
 232                 struct device_attribute *attr,
 233                 const char *buf,
 234                 size_t len)
 235 {
 236         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 237         struct adt7410_chip_info *chip = iio_priv(dev_info);
 238         unsigned long data;
 239         u16 config;
 240         int ret;
 241
 242         ret = strict_strtoul(buf, 10, &data);
 243         if (ret)
 244                 return -EINVAL;
 245
 246         ret = adt7410_i2c_read_byte(chip, ADT7410_CONFIG, &chip->config);
 247         if (ret)
 248                 return -EIO;
 249
 250         config = chip->config & (~ADT7410_RESOLUTION);
 251         if (data)
 252                 config |= ADT7410_RESOLUTION;
 253
 254         ret = adt7410_i2c_write_byte(chip, ADT7410_CONFIG, config);
 255         if (ret)
 256                 return -EIO;
 257
 258         chip->config = config;
 259
 260         return len;
 261 }
 262
 263 static IIO_DEVICE_ATTR(resolution, S_IRUGO | S_IWUSR,
 264                 adt7410_show_resolution,
 265                 adt7410_store_resolution,
 266                 0);
 267
 268 static ssize_t adt7410_show_id(struct device *dev,
 269                 struct device_attribute *attr,
 270                 char *buf)
 271 {
 272         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 273         struct adt7410_chip_info *chip = iio_priv(dev_info);
 274         u8 id;
 275         int ret;
 276
 277         ret = adt7410_i2c_read_byte(chip, ADT7410_ID, &id);
 278         if (ret)
 279                 return -EIO;
 280
 281         return sprintf(buf, "device id: 0x%x\nmanufactory id: 0x%x\n",
 282                         id & ADT7410_DEVICE_ID_MASK,
 283                         (id & ADT7410_MANUFACTORY_ID_MASK) >> ADT7410_MANUFACTORY_ID_OFFSET);
 284 }
 285
 286 static IIO_DEVICE_ATTR(id, S_IRUGO | S_IWUSR,
 287                 adt7410_show_id,
 288                 NULL,
 289                 0);
 290
 291 static ssize_t adt7410_convert_temperature(struct adt7410_chip_info *chip,
 292                 u16 data, char *buf)
 293 {
 294         char sign = ' ';
 295
 296         if (!(chip->config & ADT7410_RESOLUTION))
 297                 data &= ~0x7;
 298
 299         if (data & ADT7410_T16_VALUE_SIGN) {
 300                 /* convert supplement to positive value */
 301                 data = (u16)((ADT7410_T16_VALUE_SIGN << 1) - (u32)data);
 302                 sign = '-';
 303         }
 304         return sprintf(buf, "%c%d.%.7d\n", sign,
 305                         (data >> ADT7410_T16_VALUE_FLOAT_OFFSET),
 306                         (data & ADT7410_T16_VALUE_FLOAT_MASK) * 78125);
 307 }
 308
 309 static ssize_t adt7410_show_value(struct device *dev,
 310                 struct device_attribute *attr,
 311                 char *buf)
 312 {
 313         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 314         struct adt7410_chip_info *chip = iio_priv(dev_info);
 315         u8 status;
 316         u16 data;
 317         int ret, i = 0;
 318
 319         do {
 320                 ret = adt7410_i2c_read_byte(chip, ADT7410_STATUS, &status);
 321                 if (ret)
 322                         return -EIO;
 323                 i++;
 324                 if (i == 10000)
 325                         return -EIO;
 326         } while (status & ADT7410_STAT_NOT_RDY);
 327
 328         ret = adt7410_i2c_read_word(chip, ADT7410_TEMPERATURE, &data);
 329         if (ret)
 330                 return -EIO;
 331
 332         return adt7410_convert_temperature(chip, data, buf);
 333 }
 334
 335 static IIO_DEVICE_ATTR(value, S_IRUGO, adt7410_show_value, NULL, 0);
 336
 337 static struct attribute *adt7410_attributes[] = {
 338         &iio_dev_attr_available_modes.dev_attr.attr,
 339         &iio_dev_attr_mode.dev_attr.attr,
 340         &iio_dev_attr_resolution.dev_attr.attr,
 341         &iio_dev_attr_id.dev_attr.attr,
 342         &iio_dev_attr_value.dev_attr.attr,
 343         NULL,
 344 };
 345
 346 static const struct attribute_group adt7410_attribute_group = {
 347         .attrs = adt7410_attributes,
 348 };
 349
 350 static irqreturn_t adt7410_event_handler(int irq, void *private)
 351 {
 352         struct iio_dev *indio_dev = private;
 353         struct adt7410_chip_info *chip = iio_priv(indio_dev);
 354         s64 timestamp = iio_get_time_ns();
 355         u8 status;
 356
 357         if (adt7410_i2c_read_byte(chip, ADT7410_STATUS, &status))
 358                 return IRQ_HANDLED;
 359
 360         if (status & ADT7410_STAT_T_HIGH)
 361                 iio_push_event(indio_dev,
 362                                IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
 363                                                     IIO_EV_TYPE_THRESH,
 364                                                     IIO_EV_DIR_RISING),
 365                                timestamp);
 366         if (status & ADT7410_STAT_T_LOW)
 367                 iio_push_event(indio_dev,
 368                                IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
 369                                                     IIO_EV_TYPE_THRESH,
 370                                                     IIO_EV_DIR_FALLING),
 371                                timestamp);
 372         if (status & ADT7410_STAT_T_CRIT)
 373                 iio_push_event(indio_dev,
 374                                IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
 375                                                     IIO_EV_TYPE_THRESH,
 376                                                     IIO_EV_DIR_RISING),
 377                                timestamp);
 378
 379         return IRQ_HANDLED;
 380 }
 381
 382 static ssize_t adt7410_show_event_mode(struct device *dev,
 383                 struct device_attribute *attr,
 384                 char *buf)
 385 {
 386         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 387         struct adt7410_chip_info *chip = iio_priv(dev_info);
 388         int ret;
 389
 390         ret = adt7410_i2c_read_byte(chip, ADT7410_CONFIG, &chip->config);
 391         if (ret)
 392                 return -EIO;
 393
 394         if (chip->config & ADT7410_EVENT_MODE)
 395                 return sprintf(buf, "interrupt\n");
 396         else
 397                 return sprintf(buf, "comparator\n");
 398 }
 399
 400 static ssize_t adt7410_set_event_mode(struct device *dev,
 401                 struct device_attribute *attr,
 402                 const char *buf,
 403                 size_t len)
 404 {
 405         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 406         struct adt7410_chip_info *chip = iio_priv(dev_info);
 407         u16 config;
 408         int ret;
 409
 410         ret = adt7410_i2c_read_byte(chip, ADT7410_CONFIG, &chip->config);
 411         if (ret)
 412                 return -EIO;
 413
 414         config = chip->config &= ~ADT7410_EVENT_MODE;
 415         if (strcmp(buf, "comparator") != 0)
 416                 config |= ADT7410_EVENT_MODE;
 417
 418         ret = adt7410_i2c_write_byte(chip, ADT7410_CONFIG, config);
 419         if (ret)
 420                 return -EIO;
 421
 422         chip->config = config;
 423
 424         return ret;
 425 }
 426
 427 static ssize_t adt7410_show_available_event_modes(struct device *dev,
 428                 struct device_attribute *attr,
 429                 char *buf)
 430 {
 431         return sprintf(buf, "comparator\ninterrupt\n");
 432 }
 433
 434 static ssize_t adt7410_show_fault_queue(struct device *dev,
 435                 struct device_attribute *attr,
 436                 char *buf)
 437 {
 438         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 439         struct adt7410_chip_info *chip = iio_priv(dev_info);
 440         int ret;
 441
 442         ret = adt7410_i2c_read_byte(chip, ADT7410_CONFIG, &chip->config);
 443         if (ret)
 444                 return -EIO;
 445
 446         return sprintf(buf, "%d\n", chip->config & ADT7410_FAULT_QUEUE_MASK);
 447 }
 448
 449 static ssize_t adt7410_set_fault_queue(struct device *dev,
 450                 struct device_attribute *attr,
 451                 const char *buf,
 452                 size_t len)
 453 {
 454         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 455         struct adt7410_chip_info *chip = iio_priv(dev_info);
 456         unsigned long data;
 457         int ret;
 458         u8 config;
 459
 460         ret = strict_strtoul(buf, 10, &data);
 461         if (ret || data > 3)
 462                 return -EINVAL;
 463
 464         ret = adt7410_i2c_read_byte(chip, ADT7410_CONFIG, &chip->config);
 465         if (ret)
 466                 return -EIO;
 467
 468         config = chip->config & ~ADT7410_FAULT_QUEUE_MASK;
 469         config |= data;
 470         ret = adt7410_i2c_write_byte(chip, ADT7410_CONFIG, config);
 471         if (ret)
 472                 return -EIO;
 473
 474         chip->config = config;
 475
 476         return ret;
 477 }
 478
 479 static inline ssize_t adt7410_show_t_bound(struct device *dev,
 480                 struct device_attribute *attr,
 481                 u8 bound_reg,
 482                 char *buf)
 483 {
 484         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 485         struct adt7410_chip_info *chip = iio_priv(dev_info);
 486         u16 data;
 487         int ret;
 488
 489         ret = adt7410_i2c_read_word(chip, bound_reg, &data);
 490         if (ret)
 491                 return -EIO;
 492
 493         return adt7410_convert_temperature(chip, data, buf);
 494 }
 495
 496 static inline ssize_t adt7410_set_t_bound(struct device *dev,
 497                 struct device_attribute *attr,
 498                 u8 bound_reg,
 499                 const char *buf,
 500                 size_t len)
 501 {
 502         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 503         struct adt7410_chip_info *chip = iio_priv(dev_info);
 504         long tmp1, tmp2;
 505         u16 data;
 506         char *pos;
 507         int ret;
 508
 509         pos = strchr(buf, '.');
 510
 511         ret = strict_strtol(buf, 10, &tmp1);
 512
 513         if (ret || tmp1 > 127 || tmp1 < -128)
 514                 return -EINVAL;
 515
 516         if (pos) {
 517                 len = strlen(pos);
 518
 519                 if (chip->config & ADT7410_RESOLUTION) {
 520                         if (len > ADT7410_T16_VALUE_FLOAT_OFFSET)
 521                                 len = ADT7410_T16_VALUE_FLOAT_OFFSET;
 522                         pos[len] = 0;
 523                         ret = strict_strtol(pos, 10, &tmp2);
 524
 525                         if (!ret)
 526                                 tmp2 = (tmp2 / 78125) * 78125;
 527                 } else {
 528                         if (len > ADT7410_T13_VALUE_FLOAT_OFFSET)
 529                                 len = ADT7410_T13_VALUE_FLOAT_OFFSET;
 530                         pos[len] = 0;
 531                         ret = strict_strtol(pos, 10, &tmp2);
 532
 533                         if (!ret)
 534                                 tmp2 = (tmp2 / 625) * 625;
 535                 }
 536         }
 537
 538         if (tmp1 < 0)
 539                 data = (u16)(-tmp1);
 540         else
 541                 data = (u16)tmp1;
 542
 543         if (chip->config & ADT7410_RESOLUTION) {
 544                 data = (data << ADT7410_T16_VALUE_FLOAT_OFFSET) |
 545                         (tmp2 & ADT7410_T16_VALUE_FLOAT_MASK);
 546
 547                 if (tmp1 < 0)
 548                         /* convert positive value to supplyment */
 549                         data = (u16)((ADT7410_T16_VALUE_SIGN << 1) - (u32)data);
 550         } else {
 551                 data = (data << ADT7410_T13_VALUE_FLOAT_OFFSET) |
 552                         (tmp2 & ADT7410_T13_VALUE_FLOAT_MASK);
 553
 554                 if (tmp1 < 0)
 555                         /* convert positive value to supplyment */
 556                         data = (ADT7410_T13_VALUE_SIGN << 1) - data;
 557                 data <<= ADT7410_T13_VALUE_OFFSET;
 558         }
 559
 560         ret = adt7410_i2c_write_word(chip, bound_reg, data);
 561         if (ret)
 562                 return -EIO;
 563
 564         return ret;
 565 }
 566
 567 static ssize_t adt7410_show_t_alarm_high(struct device *dev,
 568                 struct device_attribute *attr,
 569                 char *buf)
 570 {
 571         return adt7410_show_t_bound(dev, attr,
 572                         ADT7410_T_ALARM_HIGH, buf);
 573 }
 574
 575 static inline ssize_t adt7410_set_t_alarm_high(struct device *dev,
 576                 struct device_attribute *attr,
 577                 const char *buf,
 578                 size_t len)
 579 {
 580         return adt7410_set_t_bound(dev, attr,
 581                         ADT7410_T_ALARM_HIGH, buf, len);
 582 }
 583
 584 static ssize_t adt7410_show_t_alarm_low(struct device *dev,
 585                 struct device_attribute *attr,
 586                 char *buf)
 587 {
 588         return adt7410_show_t_bound(dev, attr,
 589                         ADT7410_T_ALARM_LOW, buf);
 590 }
 591
 592 static inline ssize_t adt7410_set_t_alarm_low(struct device *dev,
 593                 struct device_attribute *attr,
 594                 const char *buf,
 595                 size_t len)
 596 {
 597         return adt7410_set_t_bound(dev, attr,
 598                         ADT7410_T_ALARM_LOW, buf, len);
 599 }
 600
 601 static ssize_t adt7410_show_t_crit(struct device *dev,
 602                 struct device_attribute *attr,
 603                 char *buf)
 604 {
 605         return adt7410_show_t_bound(dev, attr,
 606                         ADT7410_T_CRIT, buf);
 607 }
 608
 609 static inline ssize_t adt7410_set_t_crit(struct device *dev,
 610                 struct device_attribute *attr,
 611                 const char *buf,
 612                 size_t len)
 613 {
 614         return adt7410_set_t_bound(dev, attr,
 615                         ADT7410_T_CRIT, buf, len);
 616 }
 617
 618 static ssize_t adt7410_show_t_hyst(struct device *dev,
 619                 struct device_attribute *attr,
 620                 char *buf)
 621 {
 622         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 623         struct adt7410_chip_info *chip = iio_priv(dev_info);
 624         int ret;
 625         u8 t_hyst;
 626
 627         ret = adt7410_i2c_read_byte(chip, ADT7410_T_HYST, &t_hyst);
 628         if (ret)
 629                 return -EIO;
 630
 631         return sprintf(buf, "%d\n", t_hyst & ADT7410_T_HYST_MASK);
 632 }
 633
 634 static inline ssize_t adt7410_set_t_hyst(struct device *dev,
 635                 struct device_attribute *attr,
 636                 const char *buf,
 637                 size_t len)
 638 {
 639         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 640         struct adt7410_chip_info *chip = iio_priv(dev_info);
 641         int ret;
 642         unsigned long data;
 643         u8 t_hyst;
 644
 645         ret = strict_strtol(buf, 10, &data);
 646
 647         if (ret || data > ADT7410_T_HYST_MASK)
 648                 return -EINVAL;
 649
 650         t_hyst = (u8)data;
 651
 652         ret = adt7410_i2c_write_byte(chip, ADT7410_T_HYST, t_hyst);
 653         if (ret)
 654                 return -EIO;
 655
 656         return ret;
 657 }
 658
 659 static IIO_DEVICE_ATTR(event_mode,
 660                        S_IRUGO | S_IWUSR,
 661                        adt7410_show_event_mode, adt7410_set_event_mode, 0);
 662 static IIO_DEVICE_ATTR(available_event_modes,
 663                        S_IRUGO,
 664                        adt7410_show_available_event_modes, NULL, 0);
 665 static IIO_DEVICE_ATTR(fault_queue,
 666                        S_IRUGO | S_IWUSR,
 667                        adt7410_show_fault_queue, adt7410_set_fault_queue, 0);
 668 static IIO_DEVICE_ATTR(t_alarm_high,
 669                        S_IRUGO | S_IWUSR,
 670                        adt7410_show_t_alarm_high, adt7410_set_t_alarm_high, 0);
 671 static IIO_DEVICE_ATTR(t_alarm_low,
 672                        S_IRUGO | S_IWUSR,
 673                        adt7410_show_t_alarm_low, adt7410_set_t_alarm_low, 0);
 674 static IIO_DEVICE_ATTR(t_crit,
 675                        S_IRUGO | S_IWUSR,
 676                        adt7410_show_t_crit, adt7410_set_t_crit, 0);
 677 static IIO_DEVICE_ATTR(t_hyst,
 678                        S_IRUGO | S_IWUSR,
 679                        adt7410_show_t_hyst, adt7410_set_t_hyst, 0);
 680
 681 static struct attribute *adt7410_event_int_attributes[] = {
 682         &iio_dev_attr_event_mode.dev_attr.attr,
 683         &iio_dev_attr_available_event_modes.dev_attr.attr,
 684         &iio_dev_attr_fault_queue.dev_attr.attr,
 685         &iio_dev_attr_t_alarm_high.dev_attr.attr,
 686         &iio_dev_attr_t_alarm_low.dev_attr.attr,
 687         &iio_dev_attr_t_crit.dev_attr.attr,
 688         &iio_dev_attr_t_hyst.dev_attr.attr,
 689         NULL,
 690 };
 691
 692 static struct attribute_group adt7410_event_attribute_group = {
 693         .attrs = adt7410_event_int_attributes,
 694         .name = "events",
 695 };
 696
 697 static const struct iio_info adt7410_info = {
 698         .attrs = &adt7410_attribute_group,
 699         .event_attrs = &adt7410_event_attribute_group,
 700         .driver_module = THIS_MODULE,
 701 };
 702
 703 /*
 704  * device probe and remove
 705  */
 706
 707 static int __devinit adt7410_probe(struct i2c_client *client,
 708                 const struct i2c_device_id *id)
 709 {
 710         struct adt7410_chip_info *chip;
 711         struct iio_dev *indio_dev;
 712         int ret = 0;
 713         unsigned long *adt7410_platform_data = client->dev.platform_data;
 714         unsigned long local_pdata[] = {0, 0};
 715
 716         indio_dev = iio_device_alloc(sizeof(*chip));
 717         if (indio_dev == NULL) {
 718                 ret = -ENOMEM;
 719                 goto error_ret;
 720         }
 721         chip = iio_priv(indio_dev);
 722         /* this is only used for device removal purposes */
 723         i2c_set_clientdata(client, indio_dev);
 724
 725         chip->client = client;
 726
 727         indio_dev->name = id->name;
 728         indio_dev->dev.parent = &client->dev;
 729         indio_dev->info = &adt7410_info;
 730         indio_dev->modes = INDIO_DIRECT_MODE;
 731
 732         if (!adt7410_platform_data)
 733                 adt7410_platform_data = local_pdata;
 734
 735         /* CT critcal temperature event. line 0 */
 736         if (client->irq) {
 737                 ret = request_threaded_irq(client->irq,
 738                                            NULL,
 739                                            &adt7410_event_handler,
 740                                            IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 741                                            id->name,
 742                                            indio_dev);
 743                 if (ret)
 744                         goto error_free_dev;
 745         }
 746
 747         /* INT bound temperature alarm event. line 1 */
 748         if (adt7410_platform_data[0]) {
 749                 ret = request_threaded_irq(adt7410_platform_data[0],
 750                                            NULL,
 751                                            &adt7410_event_handler,
 752                                            adt7410_platform_data[1] |
 753                                            IRQF_ONESHOT,
 754                                            id->name,
 755                                            indio_dev);
 756                 if (ret)
 757                         goto error_unreg_ct_irq;
 758         }
 759
 760         ret = adt7410_i2c_read_byte(chip, ADT7410_CONFIG, &chip->config);
 761         if (ret) {
 762                 ret = -EIO;
 763                 goto error_unreg_int_irq;
 764         }
 765
 766         chip->config |= ADT7410_RESOLUTION;
 767
 768         if (client->irq && adt7410_platform_data[0]) {
 769
 770                 /* set irq polarity low level */
 771                 chip->config &= ~ADT7410_CT_POLARITY;
 772
 773                 if (adt7410_platform_data[1] & IRQF_TRIGGER_HIGH)
 774                         chip->config |= ADT7410_INT_POLARITY;
 775                 else
 776                         chip->config &= ~ADT7410_INT_POLARITY;
 777         }
 778
 779         ret = adt7410_i2c_write_byte(chip, ADT7410_CONFIG, chip->config);
 780         if (ret) {
 781                 ret = -EIO;
 782                 goto error_unreg_int_irq;
 783         }
 784         ret = iio_device_register(indio_dev);
 785         if (ret)
 786                 goto error_unreg_int_irq;
 787
 788         dev_info(&client->dev, "%s temperature sensor registered.\n",
 789                          id->name);
 790
 791         return 0;
 792
 793 error_unreg_int_irq:
 794         free_irq(adt7410_platform_data[0], indio_dev);
 795 error_unreg_ct_irq:
 796         free_irq(client->irq, indio_dev);
 797 error_free_dev:
 798         iio_device_free(indio_dev);
 799 error_ret:
 800         return ret;
 801 }
 802
 803 static int __devexit adt7410_remove(struct i2c_client *client)
 804 {
 805         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 806         unsigned long *adt7410_platform_data = client->dev.platform_data;
 807
 808         iio_device_unregister(indio_dev);
 809         if (adt7410_platform_data[0])
 810                 free_irq(adt7410_platform_data[0], indio_dev);
 811         if (client->irq)
 812                 free_irq(client->irq, indio_dev);
 813         iio_device_free(indio_dev);
 814
 815         return 0;
 816 }
 817
 818 static const struct i2c_device_id adt7410_id[] = {
 819         { "adt7410", 0 },
 820         {}
 821 };
 822
 823 MODULE_DEVICE_TABLE(i2c, adt7410_id);
 824
 825 static struct i2c_driver adt7410_driver = {
 826         .driver = {
 827                 .name = "adt7410",
 828         },
 829         .probe = adt7410_probe,
 830         .remove = __devexit_p(adt7410_remove),
 831         .id_table = adt7410_id,
 832 };
 833 module_i2c_driver(adt7410_driver);
 834
 835 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
 836 MODULE_DESCRIPTION("Analog Devices ADT7410 digital"
 837                         " temperature sensor driver");
 838 MODULE_LICENSE("GPL v2");