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
  17 #include "../iio.h"
  18 #include "../sysfs.h"
  19
  20 /*
  21  * ADT7310 registers definition
  22  */
  23
  24 #define ADT7310_STATUS                  0
  25 #define ADT7310_CONFIG                  1
  26 #define ADT7310_TEMPERATURE             2
  27 #define ADT7310_ID                      3
  28 #define ADT7310_T_CRIT                  4
  29 #define ADT7310_T_HYST                  5
  30 #define ADT7310_T_ALARM_HIGH            6
  31 #define ADT7310_T_ALARM_LOW             7
  32
  33 /*
  34  * ADT7310 status
  35  */
  36 #define ADT7310_STAT_T_LOW              0x10
  37 #define ADT7310_STAT_T_HIGH             0x20
  38 #define ADT7310_STAT_T_CRIT             0x40
  39 #define ADT7310_STAT_NOT_RDY            0x80
  40
  41 /*
  42  * ADT7310 config
  43  */
  44 #define ADT7310_FAULT_QUEUE_MASK        0x3
  45 #define ADT7310_CT_POLARITY             0x4
  46 #define ADT7310_INT_POLARITY            0x8
  47 #define ADT7310_EVENT_MODE              0x10
  48 #define ADT7310_MODE_MASK               0x60
  49 #define ADT7310_ONESHOT                 0x20
  50 #define ADT7310_SPS                     0x40
  51 #define ADT7310_PD                      0x60
  52 #define ADT7310_RESOLUTION              0x80
  53
  54 /*
  55  * ADT7310 masks
  56  */
  57 #define ADT7310_T16_VALUE_SIGN                  0x8000
  58 #define ADT7310_T16_VALUE_FLOAT_OFFSET          7
  59 #define ADT7310_T16_VALUE_FLOAT_MASK            0x7F
  60 #define ADT7310_T13_VALUE_SIGN                  0x1000
  61 #define ADT7310_T13_VALUE_OFFSET                3
  62 #define ADT7310_T13_VALUE_FLOAT_OFFSET          4
  63 #define ADT7310_T13_VALUE_FLOAT_MASK            0xF
  64 #define ADT7310_T_HYST_MASK                     0xF
  65 #define ADT7310_DEVICE_ID_MASK                  0x7
  66 #define ADT7310_MANUFACTORY_ID_MASK             0xF8
  67 #define ADT7310_MANUFACTORY_ID_OFFSET           3
  68
  69
  70 #define ADT7310_CMD_REG_MASK                    0x28
  71 #define ADT7310_CMD_REG_OFFSET                  3
  72 #define ADT7310_CMD_READ                        0x40
  73 #define ADT7310_CMD_CON_READ                    0x4
  74
  75 #define ADT7310_IRQS                            2
  76
  77 /*
  78  * struct adt7310_chip_info - chip specifc information
  79  */
  80
  81 struct adt7310_chip_info {
  82         struct spi_device *spi_dev;
  83         struct iio_dev *indio_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_get_drvdata(dev);
 179         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 202         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 246         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 268         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 304         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 354         struct adt7310_chip_info *chip = dev_info->dev_data;
 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 /*
 391  * temperature bound events
 392  */
 393
 394 #define IIO_EVENT_CODE_ADT7310_ABOVE_ALARM    IIO_BUFFER_EVENT_CODE(0)
 395 #define IIO_EVENT_CODE_ADT7310_BELLOW_ALARM   IIO_BUFFER_EVENT_CODE(1)
 396 #define IIO_EVENT_CODE_ADT7310_ABOVE_CRIT     IIO_BUFFER_EVENT_CODE(2)
 397
 398 static irqreturn_t adt7310_event_handler(int irq, void *private)
 399 {
 400         struct iio_dev *indio_dev = private;
 401         struct adt7310_chip_info *chip = iio_dev_get_devdata(indio_dev);
 402         s64 timestamp = iio_get_time_ns();
 403         u8 status;
 404         int ret;
 405
 406         ret = adt7310_spi_read_byte(chip, ADT7310_STATUS, &status);
 407         if (ret)
 408                 return ret;
 409
 410         if (status & ADT7310_STAT_T_HIGH)
 411                 iio_push_event(indio_dev, 0,
 412                         IIO_EVENT_CODE_ADT7310_ABOVE_ALARM,
 413                         timestamp);
 414         if (status & ADT7310_STAT_T_LOW)
 415                 iio_push_event(indio_dev, 0,
 416                         IIO_EVENT_CODE_ADT7310_BELLOW_ALARM,
 417                         timestamp);
 418         if (status & ADT7310_STAT_T_CRIT)
 419                 iio_push_event(indio_dev, 0,
 420                         IIO_EVENT_CODE_ADT7310_ABOVE_CRIT,
 421                         timestamp);
 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_get_drvdata(dev);
 430         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 449         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 482         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 498         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 528         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 546         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 666         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_get_drvdata(dev);
 683         struct adt7310_chip_info *chip = dev_info->dev_data;
 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_hyst.dev_attr.attr,
 731         NULL,
 732 };
 733
 734 static struct attribute *adt7310_event_ct_attributes[] = {
 735         &iio_dev_attr_event_mode.dev_attr.attr,
 736         &iio_dev_attr_available_event_modes.dev_attr.attr,
 737         &iio_dev_attr_fault_queue.dev_attr.attr,
 738         &iio_dev_attr_t_crit.dev_attr.attr,
 739         &iio_dev_attr_t_hyst.dev_attr.attr,
 740         NULL,
 741 };
 742
 743 static struct attribute_group adt7310_event_attribute_group[ADT7310_IRQS] = {
 744         {
 745                 .attrs = adt7310_event_int_attributes,
 746         }, {
 747                 .attrs = adt7310_event_ct_attributes,
 748         }
 749 };
 750
 751 /*
 752  * device probe and remove
 753  */
 754
 755 static int __devinit adt7310_probe(struct spi_device *spi_dev)
 756 {
 757         struct adt7310_chip_info *chip;
 758         int ret = 0;
 759         unsigned long *adt7310_platform_data = spi_dev->dev.platform_data;
 760         unsigned long irq_flags;
 761
 762         chip = kzalloc(sizeof(struct adt7310_chip_info), GFP_KERNEL);
 763
 764         if (chip == NULL)
 765                 return -ENOMEM;
 766
 767         /* this is only used for device removal purposes */
 768         dev_set_drvdata(&spi_dev->dev, chip);
 769
 770         chip->spi_dev = spi_dev;
 771
 772         chip->indio_dev = iio_allocate_device(0);
 773         if (chip->indio_dev == NULL) {
 774                 ret = -ENOMEM;
 775                 goto error_free_chip;
 776         }
 777
 778         chip->indio_dev->dev.parent = &spi_dev->dev;
 779         chip->indio_dev->name = spi_get_device_id(spi_dev)->name;
 780         chip->indio_dev->attrs = &adt7310_attribute_group;
 781         chip->indio_dev->event_attrs = adt7310_event_attribute_group;
 782         chip->indio_dev->dev_data = (void *)chip;
 783         chip->indio_dev->driver_module = THIS_MODULE;
 784         chip->indio_dev->num_interrupt_lines = ADT7310_IRQS;
 785         chip->indio_dev->modes = INDIO_DIRECT_MODE;
 786
 787         ret = iio_device_register(chip->indio_dev);
 788         if (ret)
 789                 goto error_free_dev;
 790
 791         /* CT critcal temperature event. line 0 */
 792         if (spi_dev->irq) {
 793                 if (adt7310_platform_data[2])
 794                         irq_flags = adt7310_platform_data[2];
 795                 else
 796                         irq_flags = IRQF_TRIGGER_LOW;
 797                 ret = request_threaded_irq(spi_dev->irq,
 798                                            NULL,
 799                                            &adt7310_event_handler,
 800                                            irq_flags,
 801                                            chip->indio_dev->name,
 802                                            chip->indio_dev);
 803                 if (ret)
 804                         goto error_unreg_dev;
 805         }
 806
 807         /* INT bound temperature alarm event. line 1 */
 808         if (adt7310_platform_data[0]) {
 809                 ret = request_threaded_irq(adt7310_platform_data[0],
 810                                            NULL,
 811                                            &adt7310_event_handler,
 812                                            adt7310_platform_data[1],
 813                                            chip->indio_dev->name,
 814                                            chip->indio_dev);
 815                 if (ret)
 816                         goto error_unreg_ct_irq;
 817         }
 818
 819         if (spi_dev->irq && adt7310_platform_data[0]) {
 820                 ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
 821                 if (ret) {
 822                         ret = -EIO;
 823                         goto error_unreg_int_irq;
 824                 }
 825
 826                 /* set irq polarity low level */
 827                 chip->config &= ~ADT7310_CT_POLARITY;
 828
 829                 if (adt7310_platform_data[1] & IRQF_TRIGGER_HIGH)
 830                         chip->config |= ADT7310_INT_POLARITY;
 831                 else
 832                         chip->config &= ~ADT7310_INT_POLARITY;
 833
 834                 ret = adt7310_spi_write_byte(chip, ADT7310_CONFIG, chip->config);
 835                 if (ret) {
 836                         ret = -EIO;
 837                         goto error_unreg_int_irq;
 838                 }
 839         }
 840
 841         dev_info(&spi_dev->dev, "%s temperature sensor registered.\n",
 842                         chip->indio_dev->name);
 843
 844         return 0;
 845
 846 error_unreg_int_irq:
 847         free_irq(adt7310_platform_data[0], chip->indio_dev);
 848 error_unreg_ct_irq:
 849         free_irq(spi_dev->irq, chip->indio_dev);
 850 error_unreg_dev:
 851         iio_device_unregister(chip->indio_dev);
 852 error_free_dev:
 853         iio_free_device(chip->indio_dev);
 854 error_free_chip:
 855         kfree(chip);
 856
 857         return ret;
 858 }
 859
 860 static int __devexit adt7310_remove(struct spi_device *spi_dev)
 861 {
 862         struct adt7310_chip_info *chip = dev_get_drvdata(&spi_dev->dev);
 863         struct iio_dev *indio_dev = chip->indio_dev;
 864         unsigned long *adt7310_platform_data = spi_dev->dev.platform_data;
 865
 866         dev_set_drvdata(&spi_dev->dev, NULL);
 867         if (adt7310_platform_data[0])
 868                 free_irq(adt7310_platform_data[0], chip->indio_dev);
 869         if (spi_dev->irq)
 870                 free_irq(spi_dev->irq, chip->indio_dev);
 871         iio_device_unregister(indio_dev);
 872         iio_free_device(chip->indio_dev);
 873         kfree(chip);
 874
 875         return 0;
 876 }
 877
 878 static const struct spi_device_id adt7310_id[] = {
 879         { "adt7310", 0 },
 880         {}
 881 };
 882
 883 MODULE_DEVICE_TABLE(spi, adt7310_id);
 884
 885 static struct spi_driver adt7310_driver = {
 886         .driver = {
 887                 .name = "adt7310",
 888                 .bus = &spi_bus_type,
 889                 .owner = THIS_MODULE,
 890         },
 891         .probe = adt7310_probe,
 892         .remove = __devexit_p(adt7310_remove),
 893         .id_table = adt7310_id,
 894 };
 895
 896 static __init int adt7310_init(void)
 897 {
 898         return spi_register_driver(&adt7310_driver);
 899 }
 900
 901 static __exit void adt7310_exit(void)
 902 {
 903         spi_unregister_driver(&adt7310_driver);
 904 }
 905
 906 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
 907 MODULE_DESCRIPTION("Analog Devices ADT7310 digital"
 908                         " temperature sensor driver");
 909 MODULE_LICENSE("GPL v2");
 910
 911 module_init(adt7310_init);
 912 module_exit(adt7310_exit);