drivers/staging/iio/addac/adt7316.c

   1 /*
   2  * ADT7316 digital temperature sensor driver supporting ADT7316/7/8 ADT7516/7/9
   3  *
   4  *
   5  * Copyright 2010 Analog Devices Inc.
   6  *
   7  * Licensed under the GPL-2 or later.
   8  */
   9
  10 #include <linux/interrupt.h>
  11 #include <linux/gpio.h>
  12 #include <linux/workqueue.h>
  13 #include <linux/device.h>
  14 #include <linux/kernel.h>
  15 #include <linux/slab.h>
  16 #include <linux/sysfs.h>
  17 #include <linux/list.h>
  18 #include <linux/i2c.h>
  19 #include <linux/rtc.h>
  20
  21 #include "../iio.h"
  22 #include "../sysfs.h"
  23 #include "adt7316.h"
  24
  25 /*
  26  * ADT7316 registers definition
  27  */
  28 #define ADT7316_INT_STAT1               0x0
  29 #define ADT7316_INT_STAT2               0x1
  30 #define ADT7316_LSB_IN_TEMP_VDD         0x3
  31 #define ADT7316_LSB_IN_TEMP_MASK        0x3
  32 #define ADT7316_LSB_VDD_MASK            0xC
  33 #define ADT7316_LSB_VDD_OFFSET          2
  34 #define ADT7316_LSB_EX_TEMP_AIN         0x4
  35 #define ADT7316_LSB_EX_TEMP_MASK        0x3
  36 #define ADT7516_LSB_AIN_SHIFT           2
  37 #define ADT7316_AD_MSB_DATA_BASE        0x6
  38 #define ADT7316_AD_MSB_DATA_REGS        3
  39 #define ADT7516_AD_MSB_DATA_REGS        6
  40 #define ADT7316_MSB_VDD                 0x6
  41 #define ADT7316_MSB_IN_TEMP             0x7
  42 #define ADT7316_MSB_EX_TEMP             0x8
  43 #define ADT7516_MSB_AIN1                0x8
  44 #define ADT7516_MSB_AIN2                0x9
  45 #define ADT7516_MSB_AIN3                0xA
  46 #define ADT7516_MSB_AIN4                0xB
  47 #define ADT7316_DA_DATA_BASE            0x10
  48 #define ADT7316_DA_MSB_DATA_REGS        4
  49 #define ADT7316_LSB_DAC_A               0x10
  50 #define ADT7316_MSB_DAC_A               0x11
  51 #define ADT7316_LSB_DAC_B               0x12
  52 #define ADT7316_MSB_DAC_B               0x13
  53 #define ADT7316_LSB_DAC_C               0x14
  54 #define ADT7316_MSB_DAC_C               0x15
  55 #define ADT7316_LSB_DAC_D               0x16
  56 #define ADT7316_MSB_DAC_D               0x17
  57 #define ADT7316_CONFIG1                 0x18
  58 #define ADT7316_CONFIG2                 0x19
  59 #define ADT7316_CONFIG3                 0x1A
  60 #define ADT7316_LDAC_CONFIG             0x1B
  61 #define ADT7316_DAC_CONFIG              0x1C
  62 #define ADT7316_INT_MASK1               0x1D
  63 #define ADT7316_INT_MASK2               0x1E
  64 #define ADT7316_IN_TEMP_OFFSET          0x1F
  65 #define ADT7316_EX_TEMP_OFFSET          0x20
  66 #define ADT7316_IN_ANALOG_TEMP_OFFSET   0x21
  67 #define ADT7316_EX_ANALOG_TEMP_OFFSET   0x22
  68 #define ADT7316_VDD_HIGH                0x23
  69 #define ADT7316_VDD_LOW                 0x24
  70 #define ADT7316_IN_TEMP_HIGH            0x25
  71 #define ADT7316_IN_TEMP_LOW             0x26
  72 #define ADT7316_EX_TEMP_HIGH            0x27
  73 #define ADT7316_EX_TEMP_LOW             0x28
  74 #define ADT7516_AIN2_HIGH               0x2B
  75 #define ADT7516_AIN2_LOW                0x2C
  76 #define ADT7516_AIN3_HIGH               0x2D
  77 #define ADT7516_AIN3_LOW                0x2E
  78 #define ADT7516_AIN4_HIGH               0x2F
  79 #define ADT7516_AIN4_LOW                0x30
  80 #define ADT7316_DEVICE_ID               0x4D
  81 #define ADT7316_MANUFACTURE_ID          0x4E
  82 #define ADT7316_DEVICE_REV              0x4F
  83 #define ADT7316_SPI_LOCK_STAT           0x7F
  84
  85 /*
  86  * ADT7316 config1
  87  */
  88 #define ADT7316_EN                      0x1
  89 #define ADT7516_SEL_EX_TEMP             0x4
  90 #define ADT7516_SEL_AIN1_2_EX_TEMP_MASK 0x6
  91 #define ADT7516_SEL_AIN3                0x8
  92 #define ADT7316_INT_EN                  0x20
  93 #define ADT7316_INT_POLARITY            0x40
  94 #define ADT7316_PD                      0x80
  95
  96 /*
  97  * ADT7316 config2
  98  */
  99 #define ADT7316_AD_SINGLE_CH_MASK       0x3
 100 #define ADT7516_AD_SINGLE_CH_MASK       0x7
 101 #define ADT7316_AD_SINGLE_CH_VDD        0
 102 #define ADT7316_AD_SINGLE_CH_IN         1
 103 #define ADT7316_AD_SINGLE_CH_EX         2
 104 #define ADT7516_AD_SINGLE_CH_AIN1       2
 105 #define ADT7516_AD_SINGLE_CH_AIN2       3
 106 #define ADT7516_AD_SINGLE_CH_AIN3       4
 107 #define ADT7516_AD_SINGLE_CH_AIN4       5
 108 #define ADT7316_AD_SINGLE_CH_MODE       0x10
 109 #define ADT7316_DISABLE_AVERAGING       0x20
 110 #define ADT7316_EN_SMBUS_TIMEOUT        0x40
 111 #define ADT7316_RESET                   0x80
 112
 113 /*
 114  * ADT7316 config3
 115  */
 116 #define ADT7316_ADCLK_22_5              0x1
 117 #define ADT7316_DA_HIGH_RESOLUTION      0x2
 118 #define ADT7316_DA_EN_VIA_DAC_LDCA      0x4
 119 #define ADT7516_AIN_IN_VREF             0x10
 120 #define ADT7316_EN_IN_TEMP_PROP_DACA    0x20
 121 #define ADT7316_EN_EX_TEMP_PROP_DACB    0x40
 122
 123 /*
 124  * ADT7316 DAC config
 125  */
 126 #define ADT7316_DA_2VREF_CH_MASK        0xF
 127 #define ADT7316_DA_EN_MODE_MASK         0x30
 128 #define ADT7316_DA_EN_MODE_SINGLE       0x00
 129 #define ADT7316_DA_EN_MODE_AB_CD        0x10
 130 #define ADT7316_DA_EN_MODE_ABCD         0x20
 131 #define ADT7316_DA_EN_MODE_LDAC         0x30
 132 #define ADT7316_VREF_BYPASS_DAC_AB      0x40
 133 #define ADT7316_VREF_BYPASS_DAC_CD      0x80
 134
 135 /*
 136  * ADT7316 LDAC config
 137  */
 138 #define ADT7316_LDAC_EN_DA_MASK         0xF
 139 #define ADT7316_DAC_IN_VREF             0x10
 140 #define ADT7516_DAC_AB_IN_VREF          0x10
 141 #define ADT7516_DAC_CD_IN_VREF          0x20
 142 #define ADT7516_DAC_IN_VREF_OFFSET      4
 143 #define ADT7516_DAC_IN_VREF_MASK        0x30
 144
 145 /*
 146  * ADT7316 INT_MASK2
 147  */
 148 #define ADT7316_INT_MASK2_VDD           0x10
 149
 150 /*
 151  * ADT7316 value masks
 152  */
 153 #define ADT7316_VALUE_MASK              0xfff
 154 #define ADT7316_T_VALUE_SIGN            0x400
 155 #define ADT7316_T_VALUE_FLOAT_OFFSET    2
 156 #define ADT7316_T_VALUE_FLOAT_MASK      0x2
 157
 158 /*
 159  * Chip ID
 160  */
 161 #define ID_ADT7316              0x1
 162 #define ID_ADT7317              0x2
 163 #define ID_ADT7318              0x3
 164 #define ID_ADT7516              0x11
 165 #define ID_ADT7517              0x12
 166 #define ID_ADT7519              0x14
 167
 168 #define ID_FAMILY_MASK          0xF0
 169 #define ID_ADT73XX              0x0
 170 #define ID_ADT75XX              0x10
 171
 172 /*
 173  * struct adt7316_chip_info - chip specifc information
 174  */
 175
 176 struct adt7316_chip_info {
 177         struct iio_dev          *indio_dev;
 178         struct adt7316_bus      bus;
 179         u16                     ldac_pin;
 180         u16                     int_mask;       /* 0x2f */
 181         u8                      config1;
 182         u8                      config2;
 183         u8                      config3;
 184         u8                      dac_config;     /* DAC config */
 185         u8                      ldac_config;    /* LDAC config */
 186         u8                      dac_bits;       /* 8, 10, 12 */
 187         u8                      id;             /* chip id */
 188 };
 189
 190 /*
 191  * Logic interrupt mask for user application to enable
 192  * interrupts.
 193  */
 194 #define ADT7316_IN_TEMP_HIGH_INT_MASK   0x1
 195 #define ADT7316_IN_TEMP_LOW_INT_MASK    0x2
 196 #define ADT7316_EX_TEMP_HIGH_INT_MASK   0x4
 197 #define ADT7316_EX_TEMP_LOW_INT_MASK    0x8
 198 #define ADT7316_EX_TEMP_FAULT_INT_MASK  0x10
 199 #define ADT7516_AIN1_INT_MASK           0x4
 200 #define ADT7516_AIN2_INT_MASK           0x20
 201 #define ADT7516_AIN3_INT_MASK           0x40
 202 #define ADT7516_AIN4_INT_MASK           0x80
 203 #define ADT7316_VDD_INT_MASK            0x100
 204 #define ADT7316_TEMP_INT_MASK           0x1F
 205 #define ADT7516_AIN_INT_MASK            0xE0
 206 #define ADT7316_TEMP_AIN_INT_MASK       \
 207         (ADT7316_TEMP_INT_MASK | ADT7316_TEMP_INT_MASK)
 208
 209 /*
 210  * struct adt7316_chip_info - chip specifc information
 211  */
 212
 213 struct adt7316_limit_regs {
 214         u16     data_high;
 215         u16     data_low;
 216 };
 217
 218 static ssize_t adt7316_show_enabled(struct device *dev,
 219                 struct device_attribute *attr,
 220                 char *buf)
 221 {
 222         struct iio_dev *dev_info = dev_get_drvdata(dev);
 223         struct adt7316_chip_info *chip = dev_info->dev_data;
 224
 225         return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_EN));
 226 }
 227
 228 static ssize_t _adt7316_store_enabled(struct adt7316_chip_info *chip,
 229                 int enable)
 230 {
 231         u8 config1;
 232         int ret;
 233
 234         if (enable)
 235                 config1 = chip->config1 | ADT7316_EN;
 236         else
 237                 config1 = chip->config1 & ~ADT7316_EN;
 238
 239         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
 240         if (ret)
 241                 return -EIO;
 242
 243         chip->config1 = config1;
 244
 245         return ret;
 246
 247 }
 248
 249 static ssize_t adt7316_store_enabled(struct device *dev,
 250                 struct device_attribute *attr,
 251                 const char *buf,
 252                 size_t len)
 253 {
 254         struct iio_dev *dev_info = dev_get_drvdata(dev);
 255         struct adt7316_chip_info *chip = dev_info->dev_data;
 256         int enable;
 257
 258         if (!memcmp(buf, "1", 1))
 259                 enable = 1;
 260         else
 261                 enable = 0;
 262
 263         if (_adt7316_store_enabled(chip, enable) < 0)
 264                 return -EIO;
 265         else
 266                 return len;
 267 }
 268
 269 static IIO_DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR,
 270                 adt7316_show_enabled,
 271                 adt7316_store_enabled,
 272                 0);
 273
 274 static ssize_t adt7316_show_select_ex_temp(struct device *dev,
 275                 struct device_attribute *attr,
 276                 char *buf)
 277 {
 278         struct iio_dev *dev_info = dev_get_drvdata(dev);
 279         struct adt7316_chip_info *chip = dev_info->dev_data;
 280
 281         if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
 282                 return -EPERM;
 283
 284         return sprintf(buf, "%d\n", !!(chip->config1 & ADT7516_SEL_EX_TEMP));
 285 }
 286
 287 static ssize_t adt7316_store_select_ex_temp(struct device *dev,
 288                 struct device_attribute *attr,
 289                 const char *buf,
 290                 size_t len)
 291 {
 292         struct iio_dev *dev_info = dev_get_drvdata(dev);
 293         struct adt7316_chip_info *chip = dev_info->dev_data;
 294         u8 config1;
 295         int ret;
 296
 297         if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
 298                 return -EPERM;
 299
 300         config1 = chip->config1 & (~ADT7516_SEL_EX_TEMP);
 301         if (!memcmp(buf, "1", 1))
 302                 config1 |= ADT7516_SEL_EX_TEMP;
 303
 304         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
 305         if (ret)
 306                 return -EIO;
 307
 308         chip->config1 = config1;
 309
 310         return len;
 311 }
 312
 313 static IIO_DEVICE_ATTR(select_ex_temp, S_IRUGO | S_IWUSR,
 314                 adt7316_show_select_ex_temp,
 315                 adt7316_store_select_ex_temp,
 316                 0);
 317
 318 static ssize_t adt7316_show_mode(struct device *dev,
 319                 struct device_attribute *attr,
 320                 char *buf)
 321 {
 322         struct iio_dev *dev_info = dev_get_drvdata(dev);
 323         struct adt7316_chip_info *chip = dev_info->dev_data;
 324
 325         if (chip->config2 & ADT7316_AD_SINGLE_CH_MODE)
 326                 return sprintf(buf, "single_channel\n");
 327         else
 328                 return sprintf(buf, "round_robin\n");
 329 }
 330
 331 static ssize_t adt7316_store_mode(struct device *dev,
 332                 struct device_attribute *attr,
 333                 const char *buf,
 334                 size_t len)
 335 {
 336         struct iio_dev *dev_info = dev_get_drvdata(dev);
 337         struct adt7316_chip_info *chip = dev_info->dev_data;
 338         u8 config2;
 339         int ret;
 340
 341         config2 = chip->config2 & (~ADT7316_AD_SINGLE_CH_MODE);
 342         if (!memcmp(buf, "single_channel", 14))
 343                 config2 |= ADT7316_AD_SINGLE_CH_MODE;
 344
 345         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
 346         if (ret)
 347                 return -EIO;
 348
 349         chip->config2 = config2;
 350
 351         return len;
 352 }
 353
 354 static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
 355                 adt7316_show_mode,
 356                 adt7316_store_mode,
 357                 0);
 358
 359 static ssize_t adt7316_show_all_modes(struct device *dev,
 360                 struct device_attribute *attr,
 361                 char *buf)
 362 {
 363         return sprintf(buf, "single_channel\nround_robin\n");
 364 }
 365
 366 static IIO_DEVICE_ATTR(all_modes, S_IRUGO, adt7316_show_all_modes, NULL, 0);
 367
 368 static ssize_t adt7316_show_ad_channel(struct device *dev,
 369                 struct device_attribute *attr,
 370                 char *buf)
 371 {
 372         struct iio_dev *dev_info = dev_get_drvdata(dev);
 373         struct adt7316_chip_info *chip = dev_info->dev_data;
 374
 375         if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
 376                 return -EPERM;
 377
 378         switch (chip->config2 & ADT7516_AD_SINGLE_CH_MASK) {
 379         case ADT7316_AD_SINGLE_CH_VDD:
 380                 return sprintf(buf, "0 - VDD\n");
 381         case ADT7316_AD_SINGLE_CH_IN:
 382                 return sprintf(buf, "1 - Internal Temperature\n");
 383         case ADT7316_AD_SINGLE_CH_EX:
 384                 if (((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) &&
 385                         (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)
 386                         return sprintf(buf, "2 - AIN1\n");
 387                 else
 388                         return sprintf(buf, "2 - External Temperature\n");
 389         case ADT7516_AD_SINGLE_CH_AIN2:
 390                 if ((chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)
 391                         return sprintf(buf, "3 - AIN2\n");
 392                 else
 393                         return sprintf(buf, "N/A\n");
 394         case ADT7516_AD_SINGLE_CH_AIN3:
 395                 if (chip->config1 & ADT7516_SEL_AIN3)
 396                         return sprintf(buf, "4 - AIN3\n");
 397                 else
 398                         return sprintf(buf, "N/A\n");
 399         case ADT7516_AD_SINGLE_CH_AIN4:
 400                 return sprintf(buf, "5 - AIN4\n");
 401         default:
 402                 return sprintf(buf, "N/A\n");
 403         }
 404 }
 405
 406 static ssize_t adt7316_store_ad_channel(struct device *dev,
 407                 struct device_attribute *attr,
 408                 const char *buf,
 409                 size_t len)
 410 {
 411         struct iio_dev *dev_info = dev_get_drvdata(dev);
 412         struct adt7316_chip_info *chip = dev_info->dev_data;
 413         u8 config2;
 414         unsigned long data = 0;
 415         int ret;
 416
 417         if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
 418                 return -EPERM;
 419
 420         ret = strict_strtoul(buf, 10, &data);
 421         if (ret)
 422                 return -EINVAL;
 423
 424         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) {
 425                 if (data > 5)
 426                         return -EINVAL;
 427
 428                 config2 = chip->config2 & (~ADT7516_AD_SINGLE_CH_MASK);
 429         } else {
 430                 if (data > 2)
 431                         return -EINVAL;
 432
 433                 config2 = chip->config2 & (~ADT7316_AD_SINGLE_CH_MASK);
 434         }
 435
 436
 437         config2 |= data;
 438
 439         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
 440         if (ret)
 441                 return -EIO;
 442
 443         chip->config2 = config2;
 444
 445         return len;
 446 }
 447
 448 static IIO_DEVICE_ATTR(ad_channel, S_IRUGO | S_IWUSR,
 449                 adt7316_show_ad_channel,
 450                 adt7316_store_ad_channel,
 451                 0);
 452
 453 static ssize_t adt7316_show_all_ad_channels(struct device *dev,
 454                 struct device_attribute *attr,
 455                 char *buf)
 456 {
 457         struct iio_dev *dev_info = dev_get_drvdata(dev);
 458         struct adt7316_chip_info *chip = dev_info->dev_data;
 459
 460         if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE))
 461                 return -EPERM;
 462
 463         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
 464                 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
 465                                 "2 - External Temperature or AIN1\n"
 466                                 "3 - AIN2\n4 - AIN3\n5 - AIN4\n");
 467         else
 468                 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
 469                                 "2 - External Temperature\n");
 470 }
 471
 472 static IIO_DEVICE_ATTR(all_ad_channels, S_IRUGO,
 473                 adt7316_show_all_ad_channels, NULL, 0);
 474
 475 static ssize_t adt7316_show_disable_averaging(struct device *dev,
 476                 struct device_attribute *attr,
 477                 char *buf)
 478 {
 479         struct iio_dev *dev_info = dev_get_drvdata(dev);
 480         struct adt7316_chip_info *chip = dev_info->dev_data;
 481
 482         return sprintf(buf, "%d\n",
 483                 !!(chip->config2 & ADT7316_DISABLE_AVERAGING));
 484 }
 485
 486 static ssize_t adt7316_store_disable_averaging(struct device *dev,
 487                 struct device_attribute *attr,
 488                 const char *buf,
 489                 size_t len)
 490 {
 491         struct iio_dev *dev_info = dev_get_drvdata(dev);
 492         struct adt7316_chip_info *chip = dev_info->dev_data;
 493         u8 config2;
 494         int ret;
 495
 496         config2 = chip->config2 & (~ADT7316_DISABLE_AVERAGING);
 497         if (!memcmp(buf, "1", 1))
 498                 config2 |= ADT7316_DISABLE_AVERAGING;
 499
 500         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
 501         if (ret)
 502                 return -EIO;
 503
 504         chip->config2 = config2;
 505
 506         return len;
 507 }
 508
 509 static IIO_DEVICE_ATTR(disable_averaging, S_IRUGO | S_IWUSR,
 510                 adt7316_show_disable_averaging,
 511                 adt7316_store_disable_averaging,
 512                 0);
 513
 514 static ssize_t adt7316_show_enable_smbus_timeout(struct device *dev,
 515                 struct device_attribute *attr,
 516                 char *buf)
 517 {
 518         struct iio_dev *dev_info = dev_get_drvdata(dev);
 519         struct adt7316_chip_info *chip = dev_info->dev_data;
 520
 521         return sprintf(buf, "%d\n",
 522                 !!(chip->config2 & ADT7316_EN_SMBUS_TIMEOUT));
 523 }
 524
 525 static ssize_t adt7316_store_enable_smbus_timeout(struct device *dev,
 526                 struct device_attribute *attr,
 527                 const char *buf,
 528                 size_t len)
 529 {
 530         struct iio_dev *dev_info = dev_get_drvdata(dev);
 531         struct adt7316_chip_info *chip = dev_info->dev_data;
 532         u8 config2;
 533         int ret;
 534
 535         config2 = chip->config2 & (~ADT7316_EN_SMBUS_TIMEOUT);
 536         if (!memcmp(buf, "1", 1))
 537                 config2 |= ADT7316_EN_SMBUS_TIMEOUT;
 538
 539         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
 540         if (ret)
 541                 return -EIO;
 542
 543         chip->config2 = config2;
 544
 545         return len;
 546 }
 547
 548 static IIO_DEVICE_ATTR(enable_smbus_timeout, S_IRUGO | S_IWUSR,
 549                 adt7316_show_enable_smbus_timeout,
 550                 adt7316_store_enable_smbus_timeout,
 551                 0);
 552
 553
 554 static ssize_t adt7316_store_reset(struct device *dev,
 555                 struct device_attribute *attr,
 556                 const char *buf,
 557                 size_t len)
 558 {
 559         struct iio_dev *dev_info = dev_get_drvdata(dev);
 560         struct adt7316_chip_info *chip = dev_info->dev_data;
 561         u8 config2;
 562         int ret;
 563
 564         config2 = chip->config2 | ADT7316_RESET;
 565
 566         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
 567         if (ret)
 568                 return -EIO;
 569
 570         return len;
 571 }
 572
 573 static IIO_DEVICE_ATTR(reset, S_IWUSR,
 574                 NULL,
 575                 adt7316_store_reset,
 576                 0);
 577
 578 static ssize_t adt7316_show_powerdown(struct device *dev,
 579                 struct device_attribute *attr,
 580                 char *buf)
 581 {
 582         struct iio_dev *dev_info = dev_get_drvdata(dev);
 583         struct adt7316_chip_info *chip = dev_info->dev_data;
 584
 585         return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_PD));
 586 }
 587
 588 static ssize_t adt7316_store_powerdown(struct device *dev,
 589                 struct device_attribute *attr,
 590                 const char *buf,
 591                 size_t len)
 592 {
 593         struct iio_dev *dev_info = dev_get_drvdata(dev);
 594         struct adt7316_chip_info *chip = dev_info->dev_data;
 595         u8 config1;
 596         int ret;
 597
 598         config1 = chip->config1 & (~ADT7316_PD);
 599         if (!memcmp(buf, "1", 1))
 600                 config1 |= ADT7316_PD;
 601
 602         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
 603         if (ret)
 604                 return -EIO;
 605
 606         chip->config1 = config1;
 607
 608         return len;
 609 }
 610
 611 static IIO_DEVICE_ATTR(powerdown, S_IRUGO | S_IWUSR,
 612                 adt7316_show_powerdown,
 613                 adt7316_store_powerdown,
 614                 0);
 615
 616 static ssize_t adt7316_show_fast_ad_clock(struct device *dev,
 617                 struct device_attribute *attr,
 618                 char *buf)
 619 {
 620         struct iio_dev *dev_info = dev_get_drvdata(dev);
 621         struct adt7316_chip_info *chip = dev_info->dev_data;
 622
 623         return sprintf(buf, "%d\n", !!(chip->config3 & ADT7316_ADCLK_22_5));
 624 }
 625
 626 static ssize_t adt7316_store_fast_ad_clock(struct device *dev,
 627                 struct device_attribute *attr,
 628                 const char *buf,
 629                 size_t len)
 630 {
 631         struct iio_dev *dev_info = dev_get_drvdata(dev);
 632         struct adt7316_chip_info *chip = dev_info->dev_data;
 633         u8 config3;
 634         int ret;
 635
 636         config3 = chip->config3 & (~ADT7316_ADCLK_22_5);
 637         if (!memcmp(buf, "1", 1))
 638                 config3 |= ADT7316_ADCLK_22_5;
 639
 640         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 641         if (ret)
 642                 return -EIO;
 643
 644         chip->config3 = config3;
 645
 646         return len;
 647 }
 648
 649 static IIO_DEVICE_ATTR(fast_ad_clock, S_IRUGO | S_IWUSR,
 650                 adt7316_show_fast_ad_clock,
 651                 adt7316_store_fast_ad_clock,
 652                 0);
 653
 654 static ssize_t adt7316_show_da_high_resolution(struct device *dev,
 655                 struct device_attribute *attr,
 656                 char *buf)
 657 {
 658         struct iio_dev *dev_info = dev_get_drvdata(dev);
 659         struct adt7316_chip_info *chip = dev_info->dev_data;
 660
 661         if (chip->config3 & ADT7316_DA_HIGH_RESOLUTION) {
 662                 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516)
 663                         return sprintf(buf, "1 (12 bits)\n");
 664                 else if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517)
 665                         return sprintf(buf, "1 (10 bits)\n");
 666         }
 667
 668         return sprintf(buf, "0 (8 bits)\n");
 669 }
 670
 671 static ssize_t adt7316_store_da_high_resolution(struct device *dev,
 672                 struct device_attribute *attr,
 673                 const char *buf,
 674                 size_t len)
 675 {
 676         struct iio_dev *dev_info = dev_get_drvdata(dev);
 677         struct adt7316_chip_info *chip = dev_info->dev_data;
 678         u8 config3;
 679         int ret;
 680
 681         chip->dac_bits = 8;
 682
 683         if (!memcmp(buf, "1", 1)) {
 684                 config3 = chip->config3 | ADT7316_DA_HIGH_RESOLUTION;
 685                 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516)
 686                         chip->dac_bits = 12;
 687                 else if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517)
 688                         chip->dac_bits = 10;
 689         } else
 690                 config3 = chip->config3 & (~ADT7316_DA_HIGH_RESOLUTION);
 691
 692         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 693         if (ret)
 694                 return -EIO;
 695
 696         chip->config3 = config3;
 697
 698         return len;
 699 }
 700
 701 static IIO_DEVICE_ATTR(da_high_resolution, S_IRUGO | S_IWUSR,
 702                 adt7316_show_da_high_resolution,
 703                 adt7316_store_da_high_resolution,
 704                 0);
 705
 706 static ssize_t adt7316_show_AIN_internal_Vref(struct device *dev,
 707                 struct device_attribute *attr,
 708                 char *buf)
 709 {
 710         struct iio_dev *dev_info = dev_get_drvdata(dev);
 711         struct adt7316_chip_info *chip = dev_info->dev_data;
 712
 713         if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
 714                 return -EPERM;
 715
 716         return sprintf(buf, "%d\n",
 717                 !!(chip->config3 & ADT7516_AIN_IN_VREF));
 718 }
 719
 720 static ssize_t adt7316_store_AIN_internal_Vref(struct device *dev,
 721                 struct device_attribute *attr,
 722                 const char *buf,
 723                 size_t len)
 724 {
 725         struct iio_dev *dev_info = dev_get_drvdata(dev);
 726         struct adt7316_chip_info *chip = dev_info->dev_data;
 727         u8 config3;
 728         int ret;
 729
 730         if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
 731                 return -EPERM;
 732
 733         if (memcmp(buf, "1", 1))
 734                 config3 = chip->config3 & (~ADT7516_AIN_IN_VREF);
 735         else
 736                 config3 = chip->config3 | ADT7516_AIN_IN_VREF;
 737
 738         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 739         if (ret)
 740                 return -EIO;
 741
 742         chip->config3 = config3;
 743
 744         return len;
 745 }
 746
 747 static IIO_DEVICE_ATTR(AIN_internal_Vref, S_IRUGO | S_IWUSR,
 748                 adt7316_show_AIN_internal_Vref,
 749                 adt7316_store_AIN_internal_Vref,
 750                 0);
 751
 752
 753 static ssize_t adt7316_show_enable_prop_DACA(struct device *dev,
 754                 struct device_attribute *attr,
 755                 char *buf)
 756 {
 757         struct iio_dev *dev_info = dev_get_drvdata(dev);
 758         struct adt7316_chip_info *chip = dev_info->dev_data;
 759
 760         return sprintf(buf, "%d\n",
 761                 !!(chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA));
 762 }
 763
 764 static ssize_t adt7316_store_enable_prop_DACA(struct device *dev,
 765                 struct device_attribute *attr,
 766                 const char *buf,
 767                 size_t len)
 768 {
 769         struct iio_dev *dev_info = dev_get_drvdata(dev);
 770         struct adt7316_chip_info *chip = dev_info->dev_data;
 771         u8 config3;
 772         int ret;
 773
 774         config3 = chip->config3 & (~ADT7316_EN_IN_TEMP_PROP_DACA);
 775         if (!memcmp(buf, "1", 1))
 776                 config3 |= ADT7316_EN_IN_TEMP_PROP_DACA;
 777
 778         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 779         if (ret)
 780                 return -EIO;
 781
 782         chip->config3 = config3;
 783
 784         return len;
 785 }
 786
 787 static IIO_DEVICE_ATTR(enable_proportion_DACA, S_IRUGO | S_IWUSR,
 788                 adt7316_show_enable_prop_DACA,
 789                 adt7316_store_enable_prop_DACA,
 790                 0);
 791
 792 static ssize_t adt7316_show_enable_prop_DACB(struct device *dev,
 793                 struct device_attribute *attr,
 794                 char *buf)
 795 {
 796         struct iio_dev *dev_info = dev_get_drvdata(dev);
 797         struct adt7316_chip_info *chip = dev_info->dev_data;
 798
 799         return sprintf(buf, "%d\n",
 800                 !!(chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB));
 801 }
 802
 803 static ssize_t adt7316_store_enable_prop_DACB(struct device *dev,
 804                 struct device_attribute *attr,
 805                 const char *buf,
 806                 size_t len)
 807 {
 808         struct iio_dev *dev_info = dev_get_drvdata(dev);
 809         struct adt7316_chip_info *chip = dev_info->dev_data;
 810         u8 config3;
 811         int ret;
 812
 813         config3 = chip->config3 & (~ADT7316_EN_EX_TEMP_PROP_DACB);
 814         if (!memcmp(buf, "1", 1))
 815                 config3 |= ADT7316_EN_EX_TEMP_PROP_DACB;
 816
 817         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 818         if (ret)
 819                 return -EIO;
 820
 821         chip->config3 = config3;
 822
 823         return len;
 824 }
 825
 826 static IIO_DEVICE_ATTR(enable_proportion_DACB, S_IRUGO | S_IWUSR,
 827                 adt7316_show_enable_prop_DACB,
 828                 adt7316_store_enable_prop_DACB,
 829                 0);
 830
 831 static ssize_t adt7316_show_DAC_2Vref_ch_mask(struct device *dev,
 832                 struct device_attribute *attr,
 833                 char *buf)
 834 {
 835         struct iio_dev *dev_info = dev_get_drvdata(dev);
 836         struct adt7316_chip_info *chip = dev_info->dev_data;
 837
 838         return sprintf(buf, "0x%x\n",
 839                 chip->dac_config & ADT7316_DA_2VREF_CH_MASK);
 840 }
 841
 842 static ssize_t adt7316_store_DAC_2Vref_ch_mask(struct device *dev,
 843                 struct device_attribute *attr,
 844                 const char *buf,
 845                 size_t len)
 846 {
 847         struct iio_dev *dev_info = dev_get_drvdata(dev);
 848         struct adt7316_chip_info *chip = dev_info->dev_data;
 849         u8 dac_config;
 850         unsigned long data = 0;
 851         int ret;
 852
 853         ret = strict_strtoul(buf, 16, &data);
 854         if (ret || data > ADT7316_DA_2VREF_CH_MASK)
 855                 return -EINVAL;
 856
 857         dac_config = chip->dac_config & (~ADT7316_DA_2VREF_CH_MASK);
 858         dac_config |= data;
 859
 860         ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
 861         if (ret)
 862                 return -EIO;
 863
 864         chip->dac_config = dac_config;
 865
 866         return len;
 867 }
 868
 869 static IIO_DEVICE_ATTR(DAC_2Vref_channels_mask, S_IRUGO | S_IWUSR,
 870                 adt7316_show_DAC_2Vref_ch_mask,
 871                 adt7316_store_DAC_2Vref_ch_mask,
 872                 0);
 873
 874 static ssize_t adt7316_show_DAC_update_mode(struct device *dev,
 875                 struct device_attribute *attr,
 876                 char *buf)
 877 {
 878         struct iio_dev *dev_info = dev_get_drvdata(dev);
 879         struct adt7316_chip_info *chip = dev_info->dev_data;
 880
 881         if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA))
 882                 return sprintf(buf, "manual\n");
 883         else {
 884                 switch (chip->dac_config & ADT7316_DA_EN_MODE_MASK) {
 885                 case ADT7316_DA_EN_MODE_SINGLE:
 886                         return sprintf(buf, "0 - auto at any MSB DAC writing\n");
 887                 case ADT7316_DA_EN_MODE_AB_CD:
 888                         return sprintf(buf, "1 - auto at MSB DAC AB and CD writing\n");
 889                 case ADT7316_DA_EN_MODE_ABCD:
 890                         return sprintf(buf, "2 - auto at MSB DAC ABCD writing\n");
 891                 default: /* ADT7316_DA_EN_MODE_LDAC */
 892                         return sprintf(buf, "3 - manual\n");
 893                 }
 894         }
 895 }
 896
 897 static ssize_t adt7316_store_DAC_update_mode(struct device *dev,
 898                 struct device_attribute *attr,
 899                 const char *buf,
 900                 size_t len)
 901 {
 902         struct iio_dev *dev_info = dev_get_drvdata(dev);
 903         struct adt7316_chip_info *chip = dev_info->dev_data;
 904         u8 dac_config;
 905         unsigned long data;
 906         int ret;
 907
 908         if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA))
 909                 return -EPERM;
 910
 911         ret = strict_strtoul(buf, 10, &data);
 912         if (ret || data > ADT7316_DA_EN_MODE_MASK)
 913                 return -EINVAL;
 914
 915         dac_config = chip->dac_config & (~ADT7316_DA_EN_MODE_MASK);
 916         dac_config |= data;
 917
 918         ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
 919         if (ret)
 920                 return -EIO;
 921
 922         chip->dac_config = dac_config;
 923
 924         return len;
 925 }
 926
 927 static IIO_DEVICE_ATTR(DAC_update_mode, S_IRUGO | S_IWUSR,
 928                 adt7316_show_DAC_update_mode,
 929                 adt7316_store_DAC_update_mode,
 930                 0);
 931
 932 static ssize_t adt7316_show_all_DAC_update_modes(struct device *dev,
 933                 struct device_attribute *attr,
 934                 char *buf)
 935 {
 936         struct iio_dev *dev_info = dev_get_drvdata(dev);
 937         struct adt7316_chip_info *chip = dev_info->dev_data;
 938
 939         if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA)
 940                 return sprintf(buf, "0 - auto at any MSB DAC writing\n"
 941                                 "1 - auto at MSB DAC AB and CD writing\n"
 942                                 "2 - auto at MSB DAC ABCD writing\n"
 943                                 "3 - manual\n");
 944         else
 945                 return sprintf(buf, "manual\n");
 946 }
 947
 948 static IIO_DEVICE_ATTR(all_DAC_update_modes, S_IRUGO,
 949                 adt7316_show_all_DAC_update_modes, NULL, 0);
 950
 951
 952 static ssize_t adt7316_store_update_DAC(struct device *dev,
 953                 struct device_attribute *attr,
 954                 const char *buf,
 955                 size_t len)
 956 {
 957         struct iio_dev *dev_info = dev_get_drvdata(dev);
 958         struct adt7316_chip_info *chip = dev_info->dev_data;
 959         u8 ldac_config;
 960         unsigned long data;
 961         int ret;
 962
 963         if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA) {
 964                 if ((chip->dac_config & ADT7316_DA_EN_MODE_MASK) !=
 965                         ADT7316_DA_EN_MODE_LDAC)
 966                         return -EPERM;
 967
 968                 ret = strict_strtoul(buf, 16, &data);
 969                 if (ret || data > ADT7316_LDAC_EN_DA_MASK)
 970                         return -EINVAL;
 971
 972                 ldac_config = chip->ldac_config & (~ADT7316_LDAC_EN_DA_MASK);
 973                 ldac_config |= data;
 974
 975                 ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG,
 976                         ldac_config);
 977                 if (ret)
 978                         return -EIO;
 979         } else {
 980                 gpio_set_value(chip->ldac_pin, 0);
 981                 gpio_set_value(chip->ldac_pin, 1);
 982         }
 983
 984         return len;
 985 }
 986
 987 static IIO_DEVICE_ATTR(update_DAC, S_IRUGO | S_IWUSR,
 988                 NULL,
 989                 adt7316_store_update_DAC,
 990                 0);
 991
 992 static ssize_t adt7316_show_DA_AB_Vref_bypass(struct device *dev,
 993                 struct device_attribute *attr,
 994                 char *buf)
 995 {
 996         struct iio_dev *dev_info = dev_get_drvdata(dev);
 997         struct adt7316_chip_info *chip = dev_info->dev_data;
 998
 999         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1000                 return -EPERM;
1001
1002         return sprintf(buf, "%d\n",
1003                 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_AB));
1004 }
1005
1006 static ssize_t adt7316_store_DA_AB_Vref_bypass(struct device *dev,
1007                 struct device_attribute *attr,
1008                 const char *buf,
1009                 size_t len)
1010 {
1011         struct iio_dev *dev_info = dev_get_drvdata(dev);
1012         struct adt7316_chip_info *chip = dev_info->dev_data;
1013         u8 dac_config;
1014         int ret;
1015
1016         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1017                 return -EPERM;
1018
1019         dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_AB);
1020         if (!memcmp(buf, "1", 1))
1021                 dac_config |= ADT7316_VREF_BYPASS_DAC_AB;
1022
1023         ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
1024         if (ret)
1025                 return -EIO;
1026
1027         chip->dac_config = dac_config;
1028
1029         return len;
1030 }
1031
1032 static IIO_DEVICE_ATTR(DA_AB_Vref_bypass, S_IRUGO | S_IWUSR,
1033                 adt7316_show_DA_AB_Vref_bypass,
1034                 adt7316_store_DA_AB_Vref_bypass,
1035                 0);
1036
1037 static ssize_t adt7316_show_DA_CD_Vref_bypass(struct device *dev,
1038                 struct device_attribute *attr,
1039                 char *buf)
1040 {
1041         struct iio_dev *dev_info = dev_get_drvdata(dev);
1042         struct adt7316_chip_info *chip = dev_info->dev_data;
1043
1044         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1045                 return -EPERM;
1046
1047         return sprintf(buf, "%d\n",
1048                 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_CD));
1049 }
1050
1051 static ssize_t adt7316_store_DA_CD_Vref_bypass(struct device *dev,
1052                 struct device_attribute *attr,
1053                 const char *buf,
1054                 size_t len)
1055 {
1056         struct iio_dev *dev_info = dev_get_drvdata(dev);
1057         struct adt7316_chip_info *chip = dev_info->dev_data;
1058         u8 dac_config;
1059         int ret;
1060
1061         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1062                 return -EPERM;
1063
1064         dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_CD);
1065         if (!memcmp(buf, "1", 1))
1066                 dac_config |= ADT7316_VREF_BYPASS_DAC_CD;
1067
1068         ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
1069         if (ret)
1070                 return -EIO;
1071
1072         chip->dac_config = dac_config;
1073
1074         return len;
1075 }
1076
1077 static IIO_DEVICE_ATTR(DA_CD_Vref_bypass, S_IRUGO | S_IWUSR,
1078                 adt7316_show_DA_CD_Vref_bypass,
1079                 adt7316_store_DA_CD_Vref_bypass,
1080                 0);
1081
1082 static ssize_t adt7316_show_DAC_internal_Vref(struct device *dev,
1083                 struct device_attribute *attr,
1084                 char *buf)
1085 {
1086         struct iio_dev *dev_info = dev_get_drvdata(dev);
1087         struct adt7316_chip_info *chip = dev_info->dev_data;
1088
1089         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1090                 return sprintf(buf, "0x%x\n",
1091                         (chip->dac_config & ADT7516_DAC_IN_VREF_MASK) >>
1092                         ADT7516_DAC_IN_VREF_OFFSET);
1093         else
1094                 return sprintf(buf, "%d\n",
1095                         !!(chip->dac_config & ADT7316_DAC_IN_VREF));
1096 }
1097
1098 static ssize_t adt7316_store_DAC_internal_Vref(struct device *dev,
1099                 struct device_attribute *attr,
1100                 const char *buf,
1101                 size_t len)
1102 {
1103         struct iio_dev *dev_info = dev_get_drvdata(dev);
1104         struct adt7316_chip_info *chip = dev_info->dev_data;
1105         u8 ldac_config;
1106         unsigned long data;
1107         int ret;
1108
1109         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) {
1110                 ret = strict_strtoul(buf, 16, &data);
1111                 if (ret || data > 3)
1112                         return -EINVAL;
1113
1114                 ldac_config = chip->ldac_config & (~ADT7516_DAC_IN_VREF_MASK);
1115                 if (data & 0x1)
1116                         ldac_config |= ADT7516_DAC_AB_IN_VREF;
1117                 else if (data & 0x2)
1118                         ldac_config |= ADT7516_DAC_CD_IN_VREF;
1119         } else {
1120                 ret = strict_strtoul(buf, 16, &data);
1121                 if (ret)
1122                         return -EINVAL;
1123
1124                 ldac_config = chip->ldac_config & (~ADT7316_DAC_IN_VREF);
1125                 if (data)
1126                         ldac_config = chip->ldac_config | ADT7316_DAC_IN_VREF;
1127         }
1128
1129         ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG, ldac_config);
1130         if (ret)
1131                 return -EIO;
1132
1133         chip->ldac_config = ldac_config;
1134
1135         return len;
1136 }
1137
1138 static IIO_DEVICE_ATTR(DAC_internal_Vref, S_IRUGO | S_IWUSR,
1139                 adt7316_show_DAC_internal_Vref,
1140                 adt7316_store_DAC_internal_Vref,
1141                 0);
1142
1143 static ssize_t adt7316_show_ad(struct adt7316_chip_info *chip,
1144                 int channel, char *buf)
1145 {
1146         u16 data;
1147         u8 msb, lsb;
1148         char sign = ' ';
1149         int ret;
1150
1151         if ((chip->config2 & ADT7316_AD_SINGLE_CH_MODE) &&
1152                 channel != (chip->config2 & ADT7516_AD_SINGLE_CH_MASK))
1153                 return -EPERM;
1154
1155         switch (channel) {
1156         case ADT7316_AD_SINGLE_CH_IN:
1157                 ret = chip->bus.read(chip->bus.client,
1158                         ADT7316_LSB_IN_TEMP_VDD, &lsb);
1159                 if (ret)
1160                         return -EIO;
1161
1162                 ret = chip->bus.read(chip->bus.client,
1163                         ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1164                 if (ret)
1165                         return -EIO;
1166
1167                 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1168                 data |= lsb & ADT7316_LSB_IN_TEMP_MASK;
1169                 break;
1170         case ADT7316_AD_SINGLE_CH_VDD:
1171                 ret = chip->bus.read(chip->bus.client,
1172                         ADT7316_LSB_IN_TEMP_VDD, &lsb);
1173                 if (ret)
1174                         return -EIO;
1175
1176                 ret = chip->bus.read(chip->bus.client,
1177
1178                         ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1179                 if (ret)
1180                         return -EIO;
1181
1182                 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1183                 data |= (lsb & ADT7316_LSB_VDD_MASK) >> ADT7316_LSB_VDD_OFFSET;
1184                 return sprintf(buf, "%d\n", data);
1185         default: /* ex_temp and ain */
1186                 ret = chip->bus.read(chip->bus.client,
1187                         ADT7316_LSB_EX_TEMP_AIN, &lsb);
1188                 if (ret)
1189                         return -EIO;
1190
1191                 ret = chip->bus.read(chip->bus.client,
1192                         ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1193                 if (ret)
1194                         return -EIO;
1195
1196                 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1197                 data |= lsb & (ADT7316_LSB_EX_TEMP_MASK <<
1198                         (ADT7516_LSB_AIN_SHIFT * (channel -
1199                         (ADT7316_MSB_EX_TEMP - ADT7316_AD_MSB_DATA_BASE))));
1200
1201                 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1202                         return sprintf(buf, "%d\n", data);
1203                 else
1204                         break;
1205         }
1206
1207         if (data & ADT7316_T_VALUE_SIGN) {
1208                 /* convert supplement to positive value */
1209                 data = (ADT7316_T_VALUE_SIGN << 1) - data;
1210                 sign = '-';
1211         }
1212
1213         return sprintf(buf, "%c%d.%.2d\n", sign,
1214                 (data >> ADT7316_T_VALUE_FLOAT_OFFSET),
1215                 (data & ADT7316_T_VALUE_FLOAT_MASK) * 25);
1216 }
1217
1218 static ssize_t adt7316_show_VDD(struct device *dev,
1219                 struct device_attribute *attr,
1220                 char *buf)
1221 {
1222         struct iio_dev *dev_info = dev_get_drvdata(dev);
1223         struct adt7316_chip_info *chip = dev_info->dev_data;
1224
1225         return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_VDD, buf);
1226 }
1227 static IIO_DEVICE_ATTR(VDD, S_IRUGO, adt7316_show_VDD, NULL, 0);
1228
1229 static ssize_t adt7316_show_in_temp(struct device *dev,
1230                 struct device_attribute *attr,
1231                 char *buf)
1232 {
1233         struct iio_dev *dev_info = dev_get_drvdata(dev);
1234         struct adt7316_chip_info *chip = dev_info->dev_data;
1235
1236         return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_IN, buf);
1237 }
1238
1239 static IIO_DEVICE_ATTR(in_temp, S_IRUGO, adt7316_show_in_temp, NULL, 0);
1240
1241 static ssize_t adt7316_show_ex_temp_AIN1(struct device *dev,
1242                 struct device_attribute *attr,
1243                 char *buf)
1244 {
1245         struct iio_dev *dev_info = dev_get_drvdata(dev);
1246         struct adt7316_chip_info *chip = dev_info->dev_data;
1247
1248         return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_EX, buf);
1249 }
1250
1251 static IIO_DEVICE_ATTR(ex_temp_AIN1, S_IRUGO, adt7316_show_ex_temp_AIN1, NULL, 0);
1252 static IIO_DEVICE_ATTR(ex_temp, S_IRUGO, adt7316_show_ex_temp_AIN1, NULL, 0);
1253
1254 static ssize_t adt7316_show_AIN2(struct device *dev,
1255                 struct device_attribute *attr,
1256                 char *buf)
1257 {
1258         struct iio_dev *dev_info = dev_get_drvdata(dev);
1259         struct adt7316_chip_info *chip = dev_info->dev_data;
1260
1261         return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN2, buf);
1262 }
1263 static IIO_DEVICE_ATTR(AIN2, S_IRUGO, adt7316_show_AIN2, NULL, 0);
1264
1265 static ssize_t adt7316_show_AIN3(struct device *dev,
1266                 struct device_attribute *attr,
1267                 char *buf)
1268 {
1269         struct iio_dev *dev_info = dev_get_drvdata(dev);
1270         struct adt7316_chip_info *chip = dev_info->dev_data;
1271
1272         return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN3, buf);
1273 }
1274 static IIO_DEVICE_ATTR(AIN3, S_IRUGO, adt7316_show_AIN3, NULL, 0);
1275
1276 static ssize_t adt7316_show_AIN4(struct device *dev,
1277                 struct device_attribute *attr,
1278                 char *buf)
1279 {
1280         struct iio_dev *dev_info = dev_get_drvdata(dev);
1281         struct adt7316_chip_info *chip = dev_info->dev_data;
1282
1283         return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN4, buf);
1284 }
1285 static IIO_DEVICE_ATTR(AIN4, S_IRUGO, adt7316_show_AIN4, NULL, 0);
1286
1287 static ssize_t adt7316_show_temp_offset(struct adt7316_chip_info *chip,
1288                 int offset_addr, char *buf)
1289 {
1290         int data;
1291         u8 val;
1292         int ret;
1293
1294         ret = chip->bus.read(chip->bus.client, offset_addr, &val);
1295         if (ret)
1296                 return -EIO;
1297
1298         data = (int)val;
1299         if (val & 0x80)
1300                 data -= 256;
1301
1302         return sprintf(buf, "%d\n", data);
1303 }
1304
1305 static ssize_t adt7316_store_temp_offset(struct adt7316_chip_info *chip,
1306                 int offset_addr, const char *buf, size_t len)
1307 {
1308         long data;
1309         u8 val;
1310         int ret;
1311
1312         ret = strict_strtol(buf, 10, &data);
1313         if (ret || data > 127 || data < -128)
1314                 return -EINVAL;
1315
1316         if (data < 0)
1317                 data += 256;
1318
1319         val = (u8)data;
1320
1321         ret = chip->bus.write(chip->bus.client, offset_addr, val);
1322         if (ret)
1323                 return -EIO;
1324
1325         return len;
1326 }
1327
1328 static ssize_t adt7316_show_in_temp_offset(struct device *dev,
1329                 struct device_attribute *attr,
1330                 char *buf)
1331 {
1332         struct iio_dev *dev_info = dev_get_drvdata(dev);
1333         struct adt7316_chip_info *chip = dev_info->dev_data;
1334
1335         return adt7316_show_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf);
1336 }
1337
1338 static ssize_t adt7316_store_in_temp_offset(struct device *dev,
1339                 struct device_attribute *attr,
1340                 const char *buf,
1341                 size_t len)
1342 {
1343         struct iio_dev *dev_info = dev_get_drvdata(dev);
1344         struct adt7316_chip_info *chip = dev_info->dev_data;
1345
1346         return adt7316_store_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf, len);
1347 }
1348
1349 static IIO_DEVICE_ATTR(in_temp_offset, S_IRUGO | S_IWUSR,
1350                 adt7316_show_in_temp_offset,
1351                 adt7316_store_in_temp_offset, 0);
1352
1353 static ssize_t adt7316_show_ex_temp_offset(struct device *dev,
1354                 struct device_attribute *attr,
1355                 char *buf)
1356 {
1357         struct iio_dev *dev_info = dev_get_drvdata(dev);
1358         struct adt7316_chip_info *chip = dev_info->dev_data;
1359
1360         return adt7316_show_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf);
1361 }
1362
1363 static ssize_t adt7316_store_ex_temp_offset(struct device *dev,
1364                 struct device_attribute *attr,
1365                 const char *buf,
1366                 size_t len)
1367 {
1368         struct iio_dev *dev_info = dev_get_drvdata(dev);
1369         struct adt7316_chip_info *chip = dev_info->dev_data;
1370
1371         return adt7316_store_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf, len);
1372 }
1373
1374 static IIO_DEVICE_ATTR(ex_temp_offset, S_IRUGO | S_IWUSR,
1375                 adt7316_show_ex_temp_offset,
1376                 adt7316_store_ex_temp_offset, 0);
1377
1378 static ssize_t adt7316_show_in_analog_temp_offset(struct device *dev,
1379                 struct device_attribute *attr,
1380                 char *buf)
1381 {
1382         struct iio_dev *dev_info = dev_get_drvdata(dev);
1383         struct adt7316_chip_info *chip = dev_info->dev_data;
1384
1385         return adt7316_show_temp_offset(chip,
1386                         ADT7316_IN_ANALOG_TEMP_OFFSET, buf);
1387 }
1388
1389 static ssize_t adt7316_store_in_analog_temp_offset(struct device *dev,
1390                 struct device_attribute *attr,
1391                 const char *buf,
1392                 size_t len)
1393 {
1394         struct iio_dev *dev_info = dev_get_drvdata(dev);
1395         struct adt7316_chip_info *chip = dev_info->dev_data;
1396
1397         return adt7316_store_temp_offset(chip,
1398                         ADT7316_IN_ANALOG_TEMP_OFFSET, buf, len);
1399 }
1400
1401 static IIO_DEVICE_ATTR(in_analog_temp_offset, S_IRUGO | S_IWUSR,
1402                 adt7316_show_in_analog_temp_offset,
1403                 adt7316_store_in_analog_temp_offset, 0);
1404
1405 static ssize_t adt7316_show_ex_analog_temp_offset(struct device *dev,
1406                 struct device_attribute *attr,
1407                 char *buf)
1408 {
1409         struct iio_dev *dev_info = dev_get_drvdata(dev);
1410         struct adt7316_chip_info *chip = dev_info->dev_data;
1411
1412         return adt7316_show_temp_offset(chip,
1413                         ADT7316_EX_ANALOG_TEMP_OFFSET, buf);
1414 }
1415
1416 static ssize_t adt7316_store_ex_analog_temp_offset(struct device *dev,
1417                 struct device_attribute *attr,
1418                 const char *buf,
1419                 size_t len)
1420 {
1421         struct iio_dev *dev_info = dev_get_drvdata(dev);
1422         struct adt7316_chip_info *chip = dev_info->dev_data;
1423
1424         return adt7316_store_temp_offset(chip,
1425                         ADT7316_EX_ANALOG_TEMP_OFFSET, buf, len);
1426 }
1427
1428 static IIO_DEVICE_ATTR(ex_analog_temp_offset, S_IRUGO | S_IWUSR,
1429                 adt7316_show_ex_analog_temp_offset,
1430                 adt7316_store_ex_analog_temp_offset, 0);
1431
1432 static ssize_t adt7316_show_DAC(struct adt7316_chip_info *chip,
1433                 int channel, char *buf)
1434 {
1435         u16 data;
1436         u8 msb, lsb, offset;
1437         int ret;
1438
1439         if (channel >= ADT7316_DA_MSB_DATA_REGS ||
1440                 (channel == 0 &&
1441                 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) ||
1442                 (channel == 1 &&
1443                 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)))
1444                 return -EPERM;
1445
1446         offset = chip->dac_bits - 8;
1447
1448         if (chip->dac_bits > 8) {
1449                 ret = chip->bus.read(chip->bus.client,
1450                         ADT7316_DA_DATA_BASE + channel * 2, &lsb);
1451                 if (ret)
1452                         return -EIO;
1453         }
1454
1455         ret = chip->bus.read(chip->bus.client,
1456                 ADT7316_DA_DATA_BASE + 1 + channel * 2, &msb);
1457         if (ret)
1458                 return -EIO;
1459
1460         data = (msb << offset) + (lsb & ((1 << offset) - 1));
1461
1462         return sprintf(buf, "%d\n", data);
1463 }
1464
1465 static ssize_t adt7316_store_DAC(struct adt7316_chip_info *chip,
1466                 int channel, const char *buf, size_t len)
1467 {
1468         u8 msb, lsb, offset;
1469         unsigned long data;
1470         int ret;
1471
1472         if (channel >= ADT7316_DA_MSB_DATA_REGS ||
1473                 (channel == 0 &&
1474                 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) ||
1475                 (channel == 1 &&
1476                 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)))
1477                 return -EPERM;
1478
1479         offset = chip->dac_bits - 8;
1480
1481         ret = strict_strtoul(buf, 10, &data);
1482         if (ret || data >= (1 << chip->dac_bits))
1483                 return -EINVAL;
1484
1485         if (chip->dac_bits > 8) {
1486                 lsb = data & (1 << offset);
1487                 ret = chip->bus.write(chip->bus.client,
1488                         ADT7316_DA_DATA_BASE + channel * 2, lsb);
1489                 if (ret)
1490                         return -EIO;
1491         }
1492
1493         msb = data >> offset;
1494         ret = chip->bus.write(chip->bus.client,
1495                 ADT7316_DA_DATA_BASE + 1 + channel * 2, msb);
1496         if (ret)
1497                 return -EIO;
1498
1499         return len;
1500 }
1501
1502 static ssize_t adt7316_show_DAC_A(struct device *dev,
1503                 struct device_attribute *attr,
1504                 char *buf)
1505 {
1506         struct iio_dev *dev_info = dev_get_drvdata(dev);
1507         struct adt7316_chip_info *chip = dev_info->dev_data;
1508
1509         return adt7316_show_DAC(chip, 0, buf);
1510 }
1511
1512 static ssize_t adt7316_store_DAC_A(struct device *dev,
1513                 struct device_attribute *attr,
1514                 const char *buf,
1515                 size_t len)
1516 {
1517         struct iio_dev *dev_info = dev_get_drvdata(dev);
1518         struct adt7316_chip_info *chip = dev_info->dev_data;
1519
1520         return adt7316_store_DAC(chip, 0, buf, len);
1521 }
1522
1523 static IIO_DEVICE_ATTR(DAC_A, S_IRUGO | S_IWUSR, adt7316_show_DAC_A,
1524                 adt7316_store_DAC_A, 0);
1525
1526 static ssize_t adt7316_show_DAC_B(struct device *dev,
1527                 struct device_attribute *attr,
1528                 char *buf)
1529 {
1530         struct iio_dev *dev_info = dev_get_drvdata(dev);
1531         struct adt7316_chip_info *chip = dev_info->dev_data;
1532
1533         return adt7316_show_DAC(chip, 1, buf);
1534 }
1535
1536 static ssize_t adt7316_store_DAC_B(struct device *dev,
1537                 struct device_attribute *attr,
1538                 const char *buf,
1539                 size_t len)
1540 {
1541         struct iio_dev *dev_info = dev_get_drvdata(dev);
1542         struct adt7316_chip_info *chip = dev_info->dev_data;
1543
1544         return adt7316_store_DAC(chip, 1, buf, len);
1545 }
1546
1547 static IIO_DEVICE_ATTR(DAC_B, S_IRUGO | S_IWUSR, adt7316_show_DAC_B,
1548                 adt7316_store_DAC_B, 0);
1549
1550 static ssize_t adt7316_show_DAC_C(struct device *dev,
1551                 struct device_attribute *attr,
1552                 char *buf)
1553 {
1554         struct iio_dev *dev_info = dev_get_drvdata(dev);
1555         struct adt7316_chip_info *chip = dev_info->dev_data;
1556
1557         return adt7316_show_DAC(chip, 2, buf);
1558 }
1559
1560 static ssize_t adt7316_store_DAC_C(struct device *dev,
1561                 struct device_attribute *attr,
1562                 const char *buf,
1563                 size_t len)
1564 {
1565         struct iio_dev *dev_info = dev_get_drvdata(dev);
1566         struct adt7316_chip_info *chip = dev_info->dev_data;
1567
1568         return adt7316_store_DAC(chip, 2, buf, len);
1569 }
1570
1571 static IIO_DEVICE_ATTR(DAC_C, S_IRUGO | S_IWUSR, adt7316_show_DAC_C,
1572                 adt7316_store_DAC_C, 0);
1573
1574 static ssize_t adt7316_show_DAC_D(struct device *dev,
1575                 struct device_attribute *attr,
1576                 char *buf)
1577 {
1578         struct iio_dev *dev_info = dev_get_drvdata(dev);
1579         struct adt7316_chip_info *chip = dev_info->dev_data;
1580
1581         return adt7316_show_DAC(chip, 3, buf);
1582 }
1583
1584 static ssize_t adt7316_store_DAC_D(struct device *dev,
1585                 struct device_attribute *attr,
1586                 const char *buf,
1587                 size_t len)
1588 {
1589         struct iio_dev *dev_info = dev_get_drvdata(dev);
1590         struct adt7316_chip_info *chip = dev_info->dev_data;
1591
1592         return adt7316_store_DAC(chip, 3, buf, len);
1593 }
1594
1595 static IIO_DEVICE_ATTR(DAC_D, S_IRUGO | S_IWUSR, adt7316_show_DAC_D,
1596                 adt7316_store_DAC_D, 0);
1597
1598 static ssize_t adt7316_show_device_id(struct device *dev,
1599                 struct device_attribute *attr,
1600                 char *buf)
1601 {
1602         struct iio_dev *dev_info = dev_get_drvdata(dev);
1603         struct adt7316_chip_info *chip = dev_info->dev_data;
1604         u8 id;
1605         int ret;
1606
1607         ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_ID, &id);
1608         if (ret)
1609                 return -EIO;
1610
1611         return sprintf(buf, "%d\n", id);
1612 }
1613
1614 static IIO_DEVICE_ATTR(device_id, S_IRUGO, adt7316_show_device_id, NULL, 0);
1615
1616 static ssize_t adt7316_show_manufactorer_id(struct device *dev,
1617                 struct device_attribute *attr,
1618                 char *buf)
1619 {
1620         struct iio_dev *dev_info = dev_get_drvdata(dev);
1621         struct adt7316_chip_info *chip = dev_info->dev_data;
1622         u8 id;
1623         int ret;
1624
1625         ret = chip->bus.read(chip->bus.client, ADT7316_MANUFACTURE_ID, &id);
1626         if (ret)
1627                 return -EIO;
1628
1629         return sprintf(buf, "%d\n", id);
1630 }
1631
1632 static IIO_DEVICE_ATTR(manufactorer_id, S_IRUGO,
1633                 adt7316_show_manufactorer_id, NULL, 0);
1634
1635 static ssize_t adt7316_show_device_rev(struct device *dev,
1636                 struct device_attribute *attr,
1637                 char *buf)
1638 {
1639         struct iio_dev *dev_info = dev_get_drvdata(dev);
1640         struct adt7316_chip_info *chip = dev_info->dev_data;
1641         u8 rev;
1642         int ret;
1643
1644         ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_REV, &rev);
1645         if (ret)
1646                 return -EIO;
1647
1648         return sprintf(buf, "%d\n", rev);
1649 }
1650
1651 static IIO_DEVICE_ATTR(device_rev, S_IRUGO, adt7316_show_device_rev, NULL, 0);
1652
1653 static ssize_t adt7316_show_bus_type(struct device *dev,
1654                 struct device_attribute *attr,
1655                 char *buf)
1656 {
1657         struct iio_dev *dev_info = dev_get_drvdata(dev);
1658         struct adt7316_chip_info *chip = dev_info->dev_data;
1659         u8 stat;
1660         int ret;
1661
1662         ret = chip->bus.read(chip->bus.client, ADT7316_SPI_LOCK_STAT, &stat);
1663         if (ret)
1664                 return -EIO;
1665
1666         if (stat)
1667                 return sprintf(buf, "spi\n");
1668         else
1669                 return sprintf(buf, "i2c\n");
1670 }
1671
1672 static IIO_DEVICE_ATTR(bus_type, S_IRUGO, adt7316_show_bus_type, NULL, 0);
1673
1674 static struct attribute *adt7316_attributes[] = {
1675         &iio_dev_attr_all_modes.dev_attr.attr,
1676         &iio_dev_attr_mode.dev_attr.attr,
1677         &iio_dev_attr_reset.dev_attr.attr,
1678         &iio_dev_attr_enabled.dev_attr.attr,
1679         &iio_dev_attr_ad_channel.dev_attr.attr,
1680         &iio_dev_attr_all_ad_channels.dev_attr.attr,
1681         &iio_dev_attr_disable_averaging.dev_attr.attr,
1682         &iio_dev_attr_enable_smbus_timeout.dev_attr.attr,
1683         &iio_dev_attr_powerdown.dev_attr.attr,
1684         &iio_dev_attr_fast_ad_clock.dev_attr.attr,
1685         &iio_dev_attr_da_high_resolution.dev_attr.attr,
1686         &iio_dev_attr_enable_proportion_DACA.dev_attr.attr,
1687         &iio_dev_attr_enable_proportion_DACB.dev_attr.attr,
1688         &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr,
1689         &iio_dev_attr_DAC_update_mode.dev_attr.attr,
1690         &iio_dev_attr_all_DAC_update_modes.dev_attr.attr,
1691         &iio_dev_attr_update_DAC.dev_attr.attr,
1692         &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr,
1693         &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr,
1694         &iio_dev_attr_DAC_internal_Vref.dev_attr.attr,
1695         &iio_dev_attr_VDD.dev_attr.attr,
1696         &iio_dev_attr_in_temp.dev_attr.attr,
1697         &iio_dev_attr_ex_temp.dev_attr.attr,
1698         &iio_dev_attr_in_temp_offset.dev_attr.attr,
1699         &iio_dev_attr_ex_temp_offset.dev_attr.attr,
1700         &iio_dev_attr_in_analog_temp_offset.dev_attr.attr,
1701         &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr,
1702         &iio_dev_attr_DAC_A.dev_attr.attr,
1703         &iio_dev_attr_DAC_B.dev_attr.attr,
1704         &iio_dev_attr_DAC_C.dev_attr.attr,
1705         &iio_dev_attr_DAC_D.dev_attr.attr,
1706         &iio_dev_attr_device_id.dev_attr.attr,
1707         &iio_dev_attr_manufactorer_id.dev_attr.attr,
1708         &iio_dev_attr_device_rev.dev_attr.attr,
1709         &iio_dev_attr_bus_type.dev_attr.attr,
1710         NULL,
1711 };
1712
1713 static const struct attribute_group adt7316_attribute_group = {
1714         .attrs = adt7316_attributes,
1715 };
1716
1717 static struct attribute *adt7516_attributes[] = {
1718         &iio_dev_attr_all_modes.dev_attr.attr,
1719         &iio_dev_attr_mode.dev_attr.attr,
1720         &iio_dev_attr_select_ex_temp.dev_attr.attr,
1721         &iio_dev_attr_reset.dev_attr.attr,
1722         &iio_dev_attr_enabled.dev_attr.attr,
1723         &iio_dev_attr_ad_channel.dev_attr.attr,
1724         &iio_dev_attr_all_ad_channels.dev_attr.attr,
1725         &iio_dev_attr_disable_averaging.dev_attr.attr,
1726         &iio_dev_attr_enable_smbus_timeout.dev_attr.attr,
1727         &iio_dev_attr_powerdown.dev_attr.attr,
1728         &iio_dev_attr_fast_ad_clock.dev_attr.attr,
1729         &iio_dev_attr_AIN_internal_Vref.dev_attr.attr,
1730         &iio_dev_attr_da_high_resolution.dev_attr.attr,
1731         &iio_dev_attr_enable_proportion_DACA.dev_attr.attr,
1732         &iio_dev_attr_enable_proportion_DACB.dev_attr.attr,
1733         &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr,
1734         &iio_dev_attr_DAC_update_mode.dev_attr.attr,
1735         &iio_dev_attr_all_DAC_update_modes.dev_attr.attr,
1736         &iio_dev_attr_update_DAC.dev_attr.attr,
1737         &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr,
1738         &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr,
1739         &iio_dev_attr_DAC_internal_Vref.dev_attr.attr,
1740         &iio_dev_attr_VDD.dev_attr.attr,
1741         &iio_dev_attr_in_temp.dev_attr.attr,
1742         &iio_dev_attr_ex_temp_AIN1.dev_attr.attr,
1743         &iio_dev_attr_AIN2.dev_attr.attr,
1744         &iio_dev_attr_AIN3.dev_attr.attr,
1745         &iio_dev_attr_AIN4.dev_attr.attr,
1746         &iio_dev_attr_in_temp_offset.dev_attr.attr,
1747         &iio_dev_attr_ex_temp_offset.dev_attr.attr,
1748         &iio_dev_attr_in_analog_temp_offset.dev_attr.attr,
1749         &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr,
1750         &iio_dev_attr_DAC_A.dev_attr.attr,
1751         &iio_dev_attr_DAC_B.dev_attr.attr,
1752         &iio_dev_attr_DAC_C.dev_attr.attr,
1753         &iio_dev_attr_DAC_D.dev_attr.attr,
1754         &iio_dev_attr_device_id.dev_attr.attr,
1755         &iio_dev_attr_manufactorer_id.dev_attr.attr,
1756         &iio_dev_attr_device_rev.dev_attr.attr,
1757         &iio_dev_attr_bus_type.dev_attr.attr,
1758         NULL,
1759 };
1760
1761 static const struct attribute_group adt7516_attribute_group = {
1762         .attrs = adt7516_attributes,
1763 };
1764
1765 static irqreturn_t adt7316_event_handler(int irq, void *private)
1766 {
1767         struct iio_dev *indio_dev = private;
1768         struct adt7316_chip_info *chip = iio_dev_get_devdata(indio_dev);
1769         u8 stat1, stat2;
1770         int ret;
1771         s64 time;
1772
1773         ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT1, &stat1);
1774         if (!ret) {
1775                 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
1776                         stat1 &= 0x1F;
1777
1778                 time = iio_get_time_ns();
1779                 if (stat1 & (1 << 0))
1780                         iio_push_event(chip->indio_dev, 0,
1781                                        IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
1782                                                             IIO_EV_TYPE_THRESH,
1783                                                             IIO_EV_DIR_RISING),
1784                                        time);
1785                 if (stat1 & (1 << 1))
1786                         iio_push_event(chip->indio_dev, 0,
1787                                        IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
1788                                                             IIO_EV_TYPE_THRESH,
1789                                                             IIO_EV_DIR_FALLING),
1790                                        time);
1791                 if (stat1 & (1 << 2))
1792                         iio_push_event(chip->indio_dev, 0,
1793                                        IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
1794                                                             IIO_EV_TYPE_THRESH,
1795                                                             IIO_EV_DIR_RISING),
1796                                        time);
1797                 if (stat1 & (1 << 3))
1798                         iio_push_event(chip->indio_dev, 0,
1799                                        IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
1800                                                             IIO_EV_TYPE_THRESH,
1801                                                             IIO_EV_DIR_FALLING),
1802                                        time);
1803                 if (stat1 & (1 << 5))
1804                         iio_push_event(chip->indio_dev, 0,
1805                                        IIO_UNMOD_EVENT_CODE(IIO_IN, 1,
1806                                                             IIO_EV_TYPE_THRESH,
1807                                                             IIO_EV_DIR_EITHER),
1808                                        time);
1809                 if (stat1 & (1 << 6))
1810                         iio_push_event(chip->indio_dev, 0,
1811                                        IIO_UNMOD_EVENT_CODE(IIO_IN, 2,
1812                                                             IIO_EV_TYPE_THRESH,
1813                                                             IIO_EV_DIR_EITHER),
1814                                        time);
1815                 if (stat1 & (1 << 7))
1816                         iio_push_event(chip->indio_dev, 0,
1817                                        IIO_UNMOD_EVENT_CODE(IIO_IN, 3,
1818                                                             IIO_EV_TYPE_THRESH,
1819                                                             IIO_EV_DIR_EITHER),
1820                                        time);
1821                 }
1822         ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT2, &stat2);
1823         if (!ret) {
1824                 if (stat2 & ADT7316_INT_MASK2_VDD)
1825                         iio_push_event(chip->indio_dev, 0,
1826                                        IIO_UNMOD_EVENT_CODE(IIO_IN,
1827                                                             0,
1828                                                             IIO_EV_TYPE_THRESH,
1829                                                             IIO_EV_DIR_RISING),
1830                                        iio_get_time_ns());
1831         }
1832
1833         return IRQ_HANDLED;
1834 }
1835
1836 /*
1837  * Show mask of enabled interrupts in Hex.
1838  */
1839 static ssize_t adt7316_show_int_mask(struct device *dev,
1840                 struct device_attribute *attr,
1841                 char *buf)
1842 {
1843         struct iio_dev *dev_info = dev_get_drvdata(dev);
1844         struct adt7316_chip_info *chip = dev_info->dev_data;
1845
1846         return sprintf(buf, "0x%x\n", chip->int_mask);
1847 }
1848
1849 /*
1850  * Set 1 to the mask in Hex to enabled interrupts.
1851  */
1852 static ssize_t adt7316_set_int_mask(struct device *dev,
1853                 struct device_attribute *attr,
1854                 const char *buf,
1855                 size_t len)
1856 {
1857         struct iio_dev *dev_info = dev_get_drvdata(dev);
1858         struct adt7316_chip_info *chip = dev_info->dev_data;
1859         unsigned long data;
1860         int ret;
1861         u8 mask;
1862
1863         ret = strict_strtoul(buf, 16, &data);
1864         if (ret || data >= ADT7316_VDD_INT_MASK + 1)
1865                 return -EINVAL;
1866
1867         if (data & ADT7316_VDD_INT_MASK)
1868                 mask = 0;                       /* enable vdd int */
1869         else
1870                 mask = ADT7316_INT_MASK2_VDD;   /* disable vdd int */
1871
1872         ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK2, mask);
1873         if (!ret) {
1874                 chip->int_mask &= ~ADT7316_VDD_INT_MASK;
1875                 chip->int_mask |= data & ADT7316_VDD_INT_MASK;
1876         }
1877
1878         if (data & ADT7316_TEMP_AIN_INT_MASK) {
1879                 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX)
1880                         /* mask in reg is opposite, set 1 to disable */
1881                         mask = (~data) & ADT7316_TEMP_INT_MASK;
1882                 else
1883                         /* mask in reg is opposite, set 1 to disable */
1884                         mask = (~data) & ADT7316_TEMP_AIN_INT_MASK;
1885         }
1886         ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK1, mask);
1887
1888         chip->int_mask = mask;
1889
1890         return len;
1891 }
1892 static inline ssize_t adt7316_show_ad_bound(struct device *dev,
1893                 struct device_attribute *attr,
1894                 char *buf)
1895 {
1896         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1897         struct iio_dev *dev_info = dev_get_drvdata(dev);
1898         struct adt7316_chip_info *chip = dev_info->dev_data;
1899         u8 val;
1900         int data;
1901         int ret;
1902
1903         if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1904                 this_attr->address > ADT7316_EX_TEMP_LOW)
1905                 return -EPERM;
1906
1907         ret = chip->bus.read(chip->bus.client, this_attr->address, &val);
1908         if (ret)
1909                 return -EIO;
1910
1911         data = (int)val;
1912
1913         if (!((chip->id & ID_FAMILY_MASK) == ID_ADT75XX &&
1914                 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)) {
1915                 if (data & 0x80)
1916                         data -= 256;
1917         }
1918
1919         return sprintf(buf, "%d\n", data);
1920 }
1921
1922 static inline ssize_t adt7316_set_ad_bound(struct device *dev,
1923                 struct device_attribute *attr,
1924                 const char *buf,
1925                 size_t len)
1926 {
1927         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1928         struct iio_dev *dev_info = dev_get_drvdata(dev);
1929         struct adt7316_chip_info *chip = dev_info->dev_data;
1930         long data;
1931         u8 val;
1932         int ret;
1933
1934         if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1935                 this_attr->address > ADT7316_EX_TEMP_LOW)
1936                 return -EPERM;
1937
1938         ret = strict_strtol(buf, 10, &data);
1939         if (ret)
1940                 return -EINVAL;
1941
1942         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX &&
1943                 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0) {
1944                 if (data > 255 || data < 0)
1945                         return -EINVAL;
1946         } else {
1947                 if (data > 127 || data < -128)
1948                         return -EINVAL;
1949
1950                 if (data < 0)
1951                         data += 256;
1952         }
1953
1954         val = (u8)data;
1955
1956         ret = chip->bus.write(chip->bus.client, this_attr->address, val);
1957         if (ret)
1958                 return -EIO;
1959
1960         return len;
1961 }
1962
1963 static ssize_t adt7316_show_int_enabled(struct device *dev,
1964                 struct device_attribute *attr,
1965                 char *buf)
1966 {
1967         struct iio_dev *dev_info = dev_get_drvdata(dev);
1968         struct adt7316_chip_info *chip = dev_info->dev_data;
1969
1970         return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_INT_EN));
1971 }
1972
1973 static ssize_t adt7316_set_int_enabled(struct device *dev,
1974                 struct device_attribute *attr,
1975                 const char *buf,
1976                 size_t len)
1977 {
1978         struct iio_dev *dev_info = dev_get_drvdata(dev);
1979         struct adt7316_chip_info *chip = dev_info->dev_data;
1980         u8 config1;
1981         int ret;
1982
1983         config1 = chip->config1 & (~ADT7316_INT_EN);
1984         if (!memcmp(buf, "1", 1))
1985                 config1 |= ADT7316_INT_EN;
1986
1987         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
1988         if (ret)
1989                 return -EIO;
1990
1991         chip->config1 = config1;
1992
1993         return len;
1994 }
1995
1996 static IIO_DEVICE_ATTR(int_mask,
1997                        S_IRUGO | S_IWUSR,
1998                        adt7316_show_int_mask, adt7316_set_int_mask,
1999                        0);
2000 static IIO_DEVICE_ATTR(in_temp_high_value,
2001                        S_IRUGO | S_IWUSR,
2002                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2003                        ADT7316_IN_TEMP_HIGH);
2004 static IIO_DEVICE_ATTR(in_temp_low_value,
2005                        S_IRUGO | S_IWUSR,
2006                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2007                        ADT7316_IN_TEMP_LOW);
2008 static IIO_DEVICE_ATTR(ex_temp_high_value,
2009                        S_IRUGO | S_IWUSR,
2010                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2011                        ADT7316_EX_TEMP_HIGH);
2012 static IIO_DEVICE_ATTR(ex_temp_low_value,
2013                        S_IRUGO | S_IWUSR,
2014                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2015                        ADT7316_EX_TEMP_LOW);
2016
2017 /* NASTY duplication to be fixed */
2018 static IIO_DEVICE_ATTR(ex_temp_ain1_high_value,
2019                        S_IRUGO | S_IWUSR,
2020                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2021                        ADT7316_EX_TEMP_HIGH);
2022 static IIO_DEVICE_ATTR(ex_temp_ain1_low_value,
2023                        S_IRUGO | S_IWUSR,
2024                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2025                        ADT7316_EX_TEMP_LOW);
2026 static IIO_DEVICE_ATTR(ain2_high_value,
2027                        S_IRUGO | S_IWUSR,
2028                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2029                        ADT7516_AIN2_HIGH);
2030 static IIO_DEVICE_ATTR(ain2_low_value,
2031                        S_IRUGO | S_IWUSR,
2032                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2033                        ADT7516_AIN2_LOW);
2034 static IIO_DEVICE_ATTR(ain3_high_value,
2035                        S_IRUGO | S_IWUSR,
2036                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2037                        ADT7516_AIN3_HIGH);
2038 static IIO_DEVICE_ATTR(ain3_low_value,
2039                        S_IRUGO | S_IWUSR,
2040                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2041                        ADT7516_AIN3_LOW);
2042 static IIO_DEVICE_ATTR(ain4_high_value,
2043                        S_IRUGO | S_IWUSR,
2044                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2045                        ADT7516_AIN4_HIGH);
2046 static IIO_DEVICE_ATTR(ain4_low_value,
2047                        S_IRUGO | S_IWUSR,
2048                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2049                        ADT7516_AIN4_LOW);
2050 static IIO_DEVICE_ATTR(int_enabled,
2051                        S_IRUGO | S_IWUSR,
2052                        adt7316_show_int_enabled,
2053                        adt7316_set_int_enabled, 0);
2054
2055 static struct attribute *adt7316_event_attributes[] = {
2056         &iio_dev_attr_int_mask.dev_attr.attr,
2057         &iio_dev_attr_in_temp_high_value.dev_attr.attr,
2058         &iio_dev_attr_in_temp_low_value.dev_attr.attr,
2059         &iio_dev_attr_ex_temp_high_value.dev_attr.attr,
2060         &iio_dev_attr_ex_temp_low_value.dev_attr.attr,
2061         &iio_dev_attr_int_enabled.dev_attr.attr,
2062         NULL,
2063 };
2064
2065 static struct attribute_group adt7316_event_attribute_group = {
2066         .attrs = adt7316_event_attributes,
2067 };
2068
2069 static struct attribute *adt7516_event_attributes[] = {
2070         &iio_dev_attr_int_mask.dev_attr.attr,
2071         &iio_dev_attr_in_temp_high_value.dev_attr.attr,
2072         &iio_dev_attr_in_temp_low_value.dev_attr.attr,
2073         &iio_dev_attr_ex_temp_ain1_high_value.dev_attr.attr,
2074         &iio_dev_attr_ex_temp_ain1_low_value.dev_attr.attr,
2075         &iio_dev_attr_ain2_high_value.dev_attr.attr,
2076         &iio_dev_attr_ain2_low_value.dev_attr.attr,
2077         &iio_dev_attr_ain3_high_value.dev_attr.attr,
2078         &iio_dev_attr_ain3_low_value.dev_attr.attr,
2079         &iio_dev_attr_ain4_high_value.dev_attr.attr,
2080         &iio_dev_attr_ain4_low_value.dev_attr.attr,
2081         &iio_dev_attr_int_enabled.dev_attr.attr,
2082         NULL,
2083 };
2084
2085 static struct attribute_group adt7516_event_attribute_group = {
2086         .attrs = adt7516_event_attributes,
2087 };
2088
2089 #ifdef CONFIG_PM
2090 int adt7316_disable(struct device *dev)
2091 {
2092         struct iio_dev *dev_info = dev_get_drvdata(dev);
2093         struct adt7316_chip_info *chip = dev_info->dev_data;
2094
2095         return _adt7316_store_enabled(chip, 0);
2096 }
2097 EXPORT_SYMBOL(adt7316_disable);
2098
2099 int adt7316_enable(struct device *dev)
2100 {
2101         struct iio_dev *dev_info = dev_get_drvdata(dev);
2102         struct adt7316_chip_info *chip = dev_info->dev_data;
2103
2104         return _adt7316_store_enabled(chip, 1);
2105 }
2106 EXPORT_SYMBOL(adt7316_enable);
2107 #endif
2108
2109 static const struct iio_info adt7316_info = {
2110         .attrs = &adt7316_attribute_group,
2111         .num_interrupt_lines = 1,
2112         .event_attrs = &adt7316_event_attribute_group,
2113         .driver_module = THIS_MODULE,
2114 };
2115
2116 static const struct iio_info adt7516_info = {
2117         .attrs = &adt7516_attribute_group,
2118         .num_interrupt_lines = 1,
2119         .event_attrs = &adt7516_event_attribute_group,
2120         .driver_module = THIS_MODULE,
2121 };
2122
2123 /*
2124  * device probe and remove
2125  */
2126 int __devinit adt7316_probe(struct device *dev, struct adt7316_bus *bus,
2127                 const char *name)
2128 {
2129         struct adt7316_chip_info *chip;
2130         unsigned short *adt7316_platform_data = dev->platform_data;
2131         int ret = 0;
2132
2133         chip = kzalloc(sizeof(struct adt7316_chip_info), GFP_KERNEL);
2134
2135         if (chip == NULL)
2136                 return -ENOMEM;
2137
2138         /* this is only used for device removal purposes */
2139         dev_set_drvdata(dev, chip);
2140
2141         chip->bus = *bus;
2142
2143         if (name[4] == '3')
2144                 chip->id = ID_ADT7316 + (name[6] - '6');
2145         else if (name[4] == '5')
2146                 chip->id = ID_ADT7516 + (name[6] - '6');
2147         else
2148                 return -ENODEV;
2149
2150         chip->ldac_pin = adt7316_platform_data[1];
2151         if (chip->ldac_pin) {
2152                 chip->config3 |= ADT7316_DA_EN_VIA_DAC_LDCA;
2153                 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2154                         chip->config1 |= ADT7516_SEL_AIN3;
2155         }
2156         chip->int_mask = ADT7316_TEMP_INT_MASK | ADT7316_VDD_INT_MASK;
2157         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2158                 chip->int_mask |= ADT7516_AIN_INT_MASK;
2159
2160         chip->indio_dev = iio_allocate_device(0);
2161         if (chip->indio_dev == NULL) {
2162                 ret = -ENOMEM;
2163                 goto error_free_chip;
2164         }
2165
2166         chip->indio_dev->dev.parent = dev;
2167         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2168                 chip->indio_dev->info = &adt7516_info;
2169         else
2170                 chip->indio_dev->info = &adt7316_info;
2171         chip->indio_dev->name = name;
2172         chip->indio_dev->dev_data = (void *)chip;
2173         chip->indio_dev->modes = INDIO_DIRECT_MODE;
2174
2175         ret = iio_device_register(chip->indio_dev);
2176         if (ret)
2177                 goto error_free_dev;
2178
2179         if (chip->bus.irq > 0) {
2180                 if (adt7316_platform_data[0])
2181                         chip->bus.irq_flags = adt7316_platform_data[0];
2182
2183                 ret = request_threaded_irq(chip->bus.irq,
2184                                            NULL,
2185                                            &adt7316_event_handler,
2186                                            chip->bus.irq_flags | IRQF_ONESHOT,
2187                                            chip->indio_dev->name,
2188                                            chip->indio_dev);
2189                 if (ret)
2190                         goto error_unreg_dev;
2191
2192                 if (chip->bus.irq_flags & IRQF_TRIGGER_HIGH)
2193                         chip->config1 |= ADT7316_INT_POLARITY;
2194         }
2195
2196         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, chip->config1);
2197         if (ret) {
2198                 ret = -EIO;
2199                 goto error_unreg_irq;
2200         }
2201
2202         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, chip->config3);
2203         if (ret) {
2204                 ret = -EIO;
2205                 goto error_unreg_irq;
2206         }
2207
2208         dev_info(dev, "%s temperature sensor, ADC and DAC registered.\n",
2209                         chip->indio_dev->name);
2210
2211         return 0;
2212
2213 error_unreg_irq:
2214         free_irq(chip->bus.irq, chip->indio_dev);
2215 error_unreg_dev:
2216         iio_device_unregister(chip->indio_dev);
2217 error_free_dev:
2218         iio_free_device(chip->indio_dev);
2219 error_free_chip:
2220         kfree(chip);
2221
2222         return ret;
2223 }
2224 EXPORT_SYMBOL(adt7316_probe);
2225
2226 int __devexit adt7316_remove(struct device *dev)
2227 {
2228
2229         struct iio_dev *dev_info = dev_get_drvdata(dev);
2230         struct adt7316_chip_info *chip = dev_info->dev_data;
2231
2232         dev_set_drvdata(dev, NULL);
2233         if (chip->bus.irq)
2234                 free_irq(chip->bus.irq, chip->indio_dev);
2235         iio_device_unregister(chip->indio_dev);
2236         iio_free_device(chip->indio_dev);
2237         kfree(chip);
2238
2239         return 0;
2240 }
2241 EXPORT_SYMBOL(adt7316_remove);
2242
2243 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
2244 MODULE_DESCRIPTION("Analog Devices ADT7316/7/8 and ADT7516/7/9 digital"
2245                         " temperature sensor, ADC and DAC driver");
2246 MODULE_LICENSE("GPL v2");