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