drivers/staging/iio/adc/adt7310.c

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