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