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         else
 471                 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
 472                                 "2 - External Temperature\n");
 473 }
 474
 475 static IIO_DEVICE_ATTR(all_ad_channels, S_IRUGO,
 476                 adt7316_show_all_ad_channels, NULL, 0);
 477
 478 static ssize_t adt7316_show_disable_averaging(struct device *dev,
 479                 struct device_attribute *attr,
 480                 char *buf)
 481 {
 482         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 483         struct adt7316_chip_info *chip = iio_priv(dev_info);
 484
 485         return sprintf(buf, "%d\n",
 486                 !!(chip->config2 & ADT7316_DISABLE_AVERAGING));
 487 }
 488
 489 static ssize_t adt7316_store_disable_averaging(struct device *dev,
 490                 struct device_attribute *attr,
 491                 const char *buf,
 492                 size_t len)
 493 {
 494         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 495         struct adt7316_chip_info *chip = iio_priv(dev_info);
 496         u8 config2;
 497         int ret;
 498
 499         config2 = chip->config2 & (~ADT7316_DISABLE_AVERAGING);
 500         if (buf[0] == '1')
 501                 config2 |= ADT7316_DISABLE_AVERAGING;
 502
 503         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
 504         if (ret)
 505                 return -EIO;
 506
 507         chip->config2 = config2;
 508
 509         return len;
 510 }
 511
 512 static IIO_DEVICE_ATTR(disable_averaging, S_IRUGO | S_IWUSR,
 513                 adt7316_show_disable_averaging,
 514                 adt7316_store_disable_averaging,
 515                 0);
 516
 517 static ssize_t adt7316_show_enable_smbus_timeout(struct device *dev,
 518                 struct device_attribute *attr,
 519                 char *buf)
 520 {
 521         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 522         struct adt7316_chip_info *chip = iio_priv(dev_info);
 523
 524         return sprintf(buf, "%d\n",
 525                 !!(chip->config2 & ADT7316_EN_SMBUS_TIMEOUT));
 526 }
 527
 528 static ssize_t adt7316_store_enable_smbus_timeout(struct device *dev,
 529                 struct device_attribute *attr,
 530                 const char *buf,
 531                 size_t len)
 532 {
 533         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 534         struct adt7316_chip_info *chip = iio_priv(dev_info);
 535         u8 config2;
 536         int ret;
 537
 538         config2 = chip->config2 & (~ADT7316_EN_SMBUS_TIMEOUT);
 539         if (buf[0] == '1')
 540                 config2 |= ADT7316_EN_SMBUS_TIMEOUT;
 541
 542         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2);
 543         if (ret)
 544                 return -EIO;
 545
 546         chip->config2 = config2;
 547
 548         return len;
 549 }
 550
 551 static IIO_DEVICE_ATTR(enable_smbus_timeout, S_IRUGO | S_IWUSR,
 552                 adt7316_show_enable_smbus_timeout,
 553                 adt7316_store_enable_smbus_timeout,
 554                 0);
 555
 556 static ssize_t adt7316_show_powerdown(struct device *dev,
 557                 struct device_attribute *attr,
 558                 char *buf)
 559 {
 560         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 561         struct adt7316_chip_info *chip = iio_priv(dev_info);
 562
 563         return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_PD));
 564 }
 565
 566 static ssize_t adt7316_store_powerdown(struct device *dev,
 567                 struct device_attribute *attr,
 568                 const char *buf,
 569                 size_t len)
 570 {
 571         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 572         struct adt7316_chip_info *chip = iio_priv(dev_info);
 573         u8 config1;
 574         int ret;
 575
 576         config1 = chip->config1 & (~ADT7316_PD);
 577         if (buf[0] == '1')
 578                 config1 |= ADT7316_PD;
 579
 580         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
 581         if (ret)
 582                 return -EIO;
 583
 584         chip->config1 = config1;
 585
 586         return len;
 587 }
 588
 589 static IIO_DEVICE_ATTR(powerdown, S_IRUGO | S_IWUSR,
 590                 adt7316_show_powerdown,
 591                 adt7316_store_powerdown,
 592                 0);
 593
 594 static ssize_t adt7316_show_fast_ad_clock(struct device *dev,
 595                 struct device_attribute *attr,
 596                 char *buf)
 597 {
 598         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 599         struct adt7316_chip_info *chip = iio_priv(dev_info);
 600
 601         return sprintf(buf, "%d\n", !!(chip->config3 & ADT7316_ADCLK_22_5));
 602 }
 603
 604 static ssize_t adt7316_store_fast_ad_clock(struct device *dev,
 605                 struct device_attribute *attr,
 606                 const char *buf,
 607                 size_t len)
 608 {
 609         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 610         struct adt7316_chip_info *chip = iio_priv(dev_info);
 611         u8 config3;
 612         int ret;
 613
 614         config3 = chip->config3 & (~ADT7316_ADCLK_22_5);
 615         if (buf[0] == '1')
 616                 config3 |= ADT7316_ADCLK_22_5;
 617
 618         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 619         if (ret)
 620                 return -EIO;
 621
 622         chip->config3 = config3;
 623
 624         return len;
 625 }
 626
 627 static IIO_DEVICE_ATTR(fast_ad_clock, S_IRUGO | S_IWUSR,
 628                 adt7316_show_fast_ad_clock,
 629                 adt7316_store_fast_ad_clock,
 630                 0);
 631
 632 static ssize_t adt7316_show_da_high_resolution(struct device *dev,
 633                 struct device_attribute *attr,
 634                 char *buf)
 635 {
 636         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 637         struct adt7316_chip_info *chip = iio_priv(dev_info);
 638
 639         if (chip->config3 & ADT7316_DA_HIGH_RESOLUTION) {
 640                 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516)
 641                         return sprintf(buf, "1 (12 bits)\n");
 642                 else if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517)
 643                         return sprintf(buf, "1 (10 bits)\n");
 644         }
 645
 646         return sprintf(buf, "0 (8 bits)\n");
 647 }
 648
 649 static ssize_t adt7316_store_da_high_resolution(struct device *dev,
 650                 struct device_attribute *attr,
 651                 const char *buf,
 652                 size_t len)
 653 {
 654         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 655         struct adt7316_chip_info *chip = iio_priv(dev_info);
 656         u8 config3;
 657         int ret;
 658
 659         chip->dac_bits = 8;
 660
 661         if (buf[0] == '1') {
 662                 config3 = chip->config3 | ADT7316_DA_HIGH_RESOLUTION;
 663                 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516)
 664                         chip->dac_bits = 12;
 665                 else if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517)
 666                         chip->dac_bits = 10;
 667         } else
 668                 config3 = chip->config3 & (~ADT7316_DA_HIGH_RESOLUTION);
 669
 670         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 671         if (ret)
 672                 return -EIO;
 673
 674         chip->config3 = config3;
 675
 676         return len;
 677 }
 678
 679 static IIO_DEVICE_ATTR(da_high_resolution, S_IRUGO | S_IWUSR,
 680                 adt7316_show_da_high_resolution,
 681                 adt7316_store_da_high_resolution,
 682                 0);
 683
 684 static ssize_t adt7316_show_AIN_internal_Vref(struct device *dev,
 685                 struct device_attribute *attr,
 686                 char *buf)
 687 {
 688         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 689         struct adt7316_chip_info *chip = iio_priv(dev_info);
 690
 691         if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
 692                 return -EPERM;
 693
 694         return sprintf(buf, "%d\n",
 695                 !!(chip->config3 & ADT7516_AIN_IN_VREF));
 696 }
 697
 698 static ssize_t adt7316_store_AIN_internal_Vref(struct device *dev,
 699                 struct device_attribute *attr,
 700                 const char *buf,
 701                 size_t len)
 702 {
 703         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 704         struct adt7316_chip_info *chip = iio_priv(dev_info);
 705         u8 config3;
 706         int ret;
 707
 708         if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
 709                 return -EPERM;
 710
 711         if (buf[0] != '1')
 712                 config3 = chip->config3 & (~ADT7516_AIN_IN_VREF);
 713         else
 714                 config3 = chip->config3 | ADT7516_AIN_IN_VREF;
 715
 716         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 717         if (ret)
 718                 return -EIO;
 719
 720         chip->config3 = config3;
 721
 722         return len;
 723 }
 724
 725 static IIO_DEVICE_ATTR(AIN_internal_Vref, S_IRUGO | S_IWUSR,
 726                 adt7316_show_AIN_internal_Vref,
 727                 adt7316_store_AIN_internal_Vref,
 728                 0);
 729
 730
 731 static ssize_t adt7316_show_enable_prop_DACA(struct device *dev,
 732                 struct device_attribute *attr,
 733                 char *buf)
 734 {
 735         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 736         struct adt7316_chip_info *chip = iio_priv(dev_info);
 737
 738         return sprintf(buf, "%d\n",
 739                 !!(chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA));
 740 }
 741
 742 static ssize_t adt7316_store_enable_prop_DACA(struct device *dev,
 743                 struct device_attribute *attr,
 744                 const char *buf,
 745                 size_t len)
 746 {
 747         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 748         struct adt7316_chip_info *chip = iio_priv(dev_info);
 749         u8 config3;
 750         int ret;
 751
 752         config3 = chip->config3 & (~ADT7316_EN_IN_TEMP_PROP_DACA);
 753         if (buf[0] == '1')
 754                 config3 |= ADT7316_EN_IN_TEMP_PROP_DACA;
 755
 756         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 757         if (ret)
 758                 return -EIO;
 759
 760         chip->config3 = config3;
 761
 762         return len;
 763 }
 764
 765 static IIO_DEVICE_ATTR(enable_proportion_DACA, S_IRUGO | S_IWUSR,
 766                 adt7316_show_enable_prop_DACA,
 767                 adt7316_store_enable_prop_DACA,
 768                 0);
 769
 770 static ssize_t adt7316_show_enable_prop_DACB(struct device *dev,
 771                 struct device_attribute *attr,
 772                 char *buf)
 773 {
 774         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 775         struct adt7316_chip_info *chip = iio_priv(dev_info);
 776
 777         return sprintf(buf, "%d\n",
 778                 !!(chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB));
 779 }
 780
 781 static ssize_t adt7316_store_enable_prop_DACB(struct device *dev,
 782                 struct device_attribute *attr,
 783                 const char *buf,
 784                 size_t len)
 785 {
 786         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 787         struct adt7316_chip_info *chip = iio_priv(dev_info);
 788         u8 config3;
 789         int ret;
 790
 791         config3 = chip->config3 & (~ADT7316_EN_EX_TEMP_PROP_DACB);
 792         if (buf[0] == '1')
 793                 config3 |= ADT7316_EN_EX_TEMP_PROP_DACB;
 794
 795         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3);
 796         if (ret)
 797                 return -EIO;
 798
 799         chip->config3 = config3;
 800
 801         return len;
 802 }
 803
 804 static IIO_DEVICE_ATTR(enable_proportion_DACB, S_IRUGO | S_IWUSR,
 805                 adt7316_show_enable_prop_DACB,
 806                 adt7316_store_enable_prop_DACB,
 807                 0);
 808
 809 static ssize_t adt7316_show_DAC_2Vref_ch_mask(struct device *dev,
 810                 struct device_attribute *attr,
 811                 char *buf)
 812 {
 813         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 814         struct adt7316_chip_info *chip = iio_priv(dev_info);
 815
 816         return sprintf(buf, "0x%x\n",
 817                 chip->dac_config & ADT7316_DA_2VREF_CH_MASK);
 818 }
 819
 820 static ssize_t adt7316_store_DAC_2Vref_ch_mask(struct device *dev,
 821                 struct device_attribute *attr,
 822                 const char *buf,
 823                 size_t len)
 824 {
 825         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 826         struct adt7316_chip_info *chip = iio_priv(dev_info);
 827         u8 dac_config;
 828         u8 data;
 829         int ret;
 830
 831         ret = kstrtou8(buf, 16, &data);
 832         if (ret || data > ADT7316_DA_2VREF_CH_MASK)
 833                 return -EINVAL;
 834
 835         dac_config = chip->dac_config & (~ADT7316_DA_2VREF_CH_MASK);
 836         dac_config |= data;
 837
 838         ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
 839         if (ret)
 840                 return -EIO;
 841
 842         chip->dac_config = dac_config;
 843
 844         return len;
 845 }
 846
 847 static IIO_DEVICE_ATTR(DAC_2Vref_channels_mask, S_IRUGO | S_IWUSR,
 848                 adt7316_show_DAC_2Vref_ch_mask,
 849                 adt7316_store_DAC_2Vref_ch_mask,
 850                 0);
 851
 852 static ssize_t adt7316_show_DAC_update_mode(struct device *dev,
 853                 struct device_attribute *attr,
 854                 char *buf)
 855 {
 856         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 857         struct adt7316_chip_info *chip = iio_priv(dev_info);
 858
 859         if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA))
 860                 return sprintf(buf, "manual\n");
 861
 862         switch (chip->dac_config & ADT7316_DA_EN_MODE_MASK) {
 863         case ADT7316_DA_EN_MODE_SINGLE:
 864                 return sprintf(buf,
 865                         "0 - auto at any MSB DAC writing\n");
 866         case ADT7316_DA_EN_MODE_AB_CD:
 867                 return sprintf(buf,
 868                         "1 - auto at MSB DAC AB and CD writing\n");
 869         case ADT7316_DA_EN_MODE_ABCD:
 870                 return sprintf(buf,
 871                         "2 - auto at MSB DAC ABCD writing\n");
 872         default: /* ADT7316_DA_EN_MODE_LDAC */
 873                 return sprintf(buf, "3 - manual\n");
 874         }
 875 }
 876
 877 static ssize_t adt7316_store_DAC_update_mode(struct device *dev,
 878                 struct device_attribute *attr,
 879                 const char *buf,
 880                 size_t len)
 881 {
 882         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 883         struct adt7316_chip_info *chip = iio_priv(dev_info);
 884         u8 dac_config;
 885         u8 data;
 886         int ret;
 887
 888         if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA))
 889                 return -EPERM;
 890
 891         ret = kstrtou8(buf, 10, &data);
 892         if (ret || data > ADT7316_DA_EN_MODE_MASK)
 893                 return -EINVAL;
 894
 895         dac_config = chip->dac_config & (~ADT7316_DA_EN_MODE_MASK);
 896         dac_config |= data;
 897
 898         ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
 899         if (ret)
 900                 return -EIO;
 901
 902         chip->dac_config = dac_config;
 903
 904         return len;
 905 }
 906
 907 static IIO_DEVICE_ATTR(DAC_update_mode, S_IRUGO | S_IWUSR,
 908                 adt7316_show_DAC_update_mode,
 909                 adt7316_store_DAC_update_mode,
 910                 0);
 911
 912 static ssize_t adt7316_show_all_DAC_update_modes(struct device *dev,
 913                 struct device_attribute *attr,
 914                 char *buf)
 915 {
 916         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 917         struct adt7316_chip_info *chip = iio_priv(dev_info);
 918
 919         if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA)
 920                 return sprintf(buf, "0 - auto at any MSB DAC writing\n"
 921                                 "1 - auto at MSB DAC AB and CD writing\n"
 922                                 "2 - auto at MSB DAC ABCD writing\n"
 923                                 "3 - manual\n");
 924         else
 925                 return sprintf(buf, "manual\n");
 926 }
 927
 928 static IIO_DEVICE_ATTR(all_DAC_update_modes, S_IRUGO,
 929                 adt7316_show_all_DAC_update_modes, NULL, 0);
 930
 931
 932 static ssize_t adt7316_store_update_DAC(struct device *dev,
 933                 struct device_attribute *attr,
 934                 const char *buf,
 935                 size_t len)
 936 {
 937         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 938         struct adt7316_chip_info *chip = iio_priv(dev_info);
 939         u8 ldac_config;
 940         u8 data;
 941         int ret;
 942
 943         if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA) {
 944                 if ((chip->dac_config & ADT7316_DA_EN_MODE_MASK) !=
 945                         ADT7316_DA_EN_MODE_LDAC)
 946                         return -EPERM;
 947
 948                 ret = kstrtou8(buf, 16, &data);
 949                 if (ret || data > ADT7316_LDAC_EN_DA_MASK)
 950                         return -EINVAL;
 951
 952                 ldac_config = chip->ldac_config & (~ADT7316_LDAC_EN_DA_MASK);
 953                 ldac_config |= data;
 954
 955                 ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG,
 956                         ldac_config);
 957                 if (ret)
 958                         return -EIO;
 959         } else {
 960                 gpio_set_value(chip->ldac_pin, 0);
 961                 gpio_set_value(chip->ldac_pin, 1);
 962         }
 963
 964         return len;
 965 }
 966
 967 static IIO_DEVICE_ATTR(update_DAC, S_IRUGO | S_IWUSR,
 968                 NULL,
 969                 adt7316_store_update_DAC,
 970                 0);
 971
 972 static ssize_t adt7316_show_DA_AB_Vref_bypass(struct device *dev,
 973                 struct device_attribute *attr,
 974                 char *buf)
 975 {
 976         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 977         struct adt7316_chip_info *chip = iio_priv(dev_info);
 978
 979         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
 980                 return -EPERM;
 981
 982         return sprintf(buf, "%d\n",
 983                 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_AB));
 984 }
 985
 986 static ssize_t adt7316_store_DA_AB_Vref_bypass(struct device *dev,
 987                 struct device_attribute *attr,
 988                 const char *buf,
 989                 size_t len)
 990 {
 991         struct iio_dev *dev_info = dev_to_iio_dev(dev);
 992         struct adt7316_chip_info *chip = iio_priv(dev_info);
 993         u8 dac_config;
 994         int ret;
 995
 996         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
 997                 return -EPERM;
 998
 999         dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_AB);
1000         if (buf[0] == '1')
1001                 dac_config |= ADT7316_VREF_BYPASS_DAC_AB;
1002
1003         ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
1004         if (ret)
1005                 return -EIO;
1006
1007         chip->dac_config = dac_config;
1008
1009         return len;
1010 }
1011
1012 static IIO_DEVICE_ATTR(DA_AB_Vref_bypass, S_IRUGO | S_IWUSR,
1013                 adt7316_show_DA_AB_Vref_bypass,
1014                 adt7316_store_DA_AB_Vref_bypass,
1015                 0);
1016
1017 static ssize_t adt7316_show_DA_CD_Vref_bypass(struct device *dev,
1018                 struct device_attribute *attr,
1019                 char *buf)
1020 {
1021         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1022         struct adt7316_chip_info *chip = iio_priv(dev_info);
1023
1024         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1025                 return -EPERM;
1026
1027         return sprintf(buf, "%d\n",
1028                 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_CD));
1029 }
1030
1031 static ssize_t adt7316_store_DA_CD_Vref_bypass(struct device *dev,
1032                 struct device_attribute *attr,
1033                 const char *buf,
1034                 size_t len)
1035 {
1036         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1037         struct adt7316_chip_info *chip = iio_priv(dev_info);
1038         u8 dac_config;
1039         int ret;
1040
1041         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1042                 return -EPERM;
1043
1044         dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_CD);
1045         if (buf[0] == '1')
1046                 dac_config |= ADT7316_VREF_BYPASS_DAC_CD;
1047
1048         ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config);
1049         if (ret)
1050                 return -EIO;
1051
1052         chip->dac_config = dac_config;
1053
1054         return len;
1055 }
1056
1057 static IIO_DEVICE_ATTR(DA_CD_Vref_bypass, S_IRUGO | S_IWUSR,
1058                 adt7316_show_DA_CD_Vref_bypass,
1059                 adt7316_store_DA_CD_Vref_bypass,
1060                 0);
1061
1062 static ssize_t adt7316_show_DAC_internal_Vref(struct device *dev,
1063                 struct device_attribute *attr,
1064                 char *buf)
1065 {
1066         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1067         struct adt7316_chip_info *chip = iio_priv(dev_info);
1068
1069         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1070                 return sprintf(buf, "0x%x\n",
1071                         (chip->dac_config & ADT7516_DAC_IN_VREF_MASK) >>
1072                         ADT7516_DAC_IN_VREF_OFFSET);
1073         else
1074                 return sprintf(buf, "%d\n",
1075                         !!(chip->dac_config & ADT7316_DAC_IN_VREF));
1076 }
1077
1078 static ssize_t adt7316_store_DAC_internal_Vref(struct device *dev,
1079                 struct device_attribute *attr,
1080                 const char *buf,
1081                 size_t len)
1082 {
1083         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1084         struct adt7316_chip_info *chip = iio_priv(dev_info);
1085         u8 ldac_config;
1086         u8 data;
1087         int ret;
1088
1089         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) {
1090                 ret = kstrtou8(buf, 16, &data);
1091                 if (ret || data > 3)
1092                         return -EINVAL;
1093
1094                 ldac_config = chip->ldac_config & (~ADT7516_DAC_IN_VREF_MASK);
1095                 if (data & 0x1)
1096                         ldac_config |= ADT7516_DAC_AB_IN_VREF;
1097                 if (data & 0x2)
1098                         ldac_config |= ADT7516_DAC_CD_IN_VREF;
1099         } else {
1100                 ret = kstrtou8(buf, 16, &data);
1101                 if (ret)
1102                         return -EINVAL;
1103
1104                 ldac_config = chip->ldac_config & (~ADT7316_DAC_IN_VREF);
1105                 if (data)
1106                         ldac_config = chip->ldac_config | ADT7316_DAC_IN_VREF;
1107         }
1108
1109         ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG,
1110                         ldac_config);
1111         if (ret)
1112                 return -EIO;
1113
1114         chip->ldac_config = ldac_config;
1115
1116         return len;
1117 }
1118
1119 static IIO_DEVICE_ATTR(DAC_internal_Vref, S_IRUGO | S_IWUSR,
1120                 adt7316_show_DAC_internal_Vref,
1121                 adt7316_store_DAC_internal_Vref,
1122                 0);
1123
1124 static ssize_t adt7316_show_ad(struct adt7316_chip_info *chip,
1125                 int channel, char *buf)
1126 {
1127         u16 data;
1128         u8 msb, lsb;
1129         char sign = ' ';
1130         int ret;
1131
1132         if ((chip->config2 & ADT7316_AD_SINGLE_CH_MODE) &&
1133                 channel != (chip->config2 & ADT7516_AD_SINGLE_CH_MASK))
1134                 return -EPERM;
1135
1136         switch (channel) {
1137         case ADT7316_AD_SINGLE_CH_IN:
1138                 ret = chip->bus.read(chip->bus.client,
1139                         ADT7316_LSB_IN_TEMP_VDD, &lsb);
1140                 if (ret)
1141                         return -EIO;
1142
1143                 ret = chip->bus.read(chip->bus.client,
1144                         ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1145                 if (ret)
1146                         return -EIO;
1147
1148                 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1149                 data |= lsb & ADT7316_LSB_IN_TEMP_MASK;
1150                 break;
1151         case ADT7316_AD_SINGLE_CH_VDD:
1152                 ret = chip->bus.read(chip->bus.client,
1153                         ADT7316_LSB_IN_TEMP_VDD, &lsb);
1154                 if (ret)
1155                         return -EIO;
1156
1157                 ret = chip->bus.read(chip->bus.client,
1158
1159                         ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1160                 if (ret)
1161                         return -EIO;
1162
1163                 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1164                 data |= (lsb & ADT7316_LSB_VDD_MASK) >> ADT7316_LSB_VDD_OFFSET;
1165                 return sprintf(buf, "%d\n", data);
1166         default: /* ex_temp and ain */
1167                 ret = chip->bus.read(chip->bus.client,
1168                         ADT7316_LSB_EX_TEMP_AIN, &lsb);
1169                 if (ret)
1170                         return -EIO;
1171
1172                 ret = chip->bus.read(chip->bus.client,
1173                         ADT7316_AD_MSB_DATA_BASE + channel, &msb);
1174                 if (ret)
1175                         return -EIO;
1176
1177                 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET;
1178                 data |= lsb & (ADT7316_LSB_EX_TEMP_MASK <<
1179                         (ADT7516_LSB_AIN_SHIFT * (channel -
1180                         (ADT7316_MSB_EX_TEMP - ADT7316_AD_MSB_DATA_BASE))));
1181
1182                 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1183                         return sprintf(buf, "%d\n", data);
1184
1185                 break;
1186         }
1187
1188         if (data & ADT7316_T_VALUE_SIGN) {
1189                 /* convert supplement to positive value */
1190                 data = (ADT7316_T_VALUE_SIGN << 1) - data;
1191                 sign = '-';
1192         }
1193
1194         return sprintf(buf, "%c%d.%.2d\n", sign,
1195                 (data >> ADT7316_T_VALUE_FLOAT_OFFSET),
1196                 (data & ADT7316_T_VALUE_FLOAT_MASK) * 25);
1197 }
1198
1199 static ssize_t adt7316_show_VDD(struct device *dev,
1200                 struct device_attribute *attr,
1201                 char *buf)
1202 {
1203         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1204         struct adt7316_chip_info *chip = iio_priv(dev_info);
1205
1206         return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_VDD, buf);
1207 }
1208 static IIO_DEVICE_ATTR(VDD, S_IRUGO, adt7316_show_VDD, NULL, 0);
1209
1210 static ssize_t adt7316_show_in_temp(struct device *dev,
1211                 struct device_attribute *attr,
1212                 char *buf)
1213 {
1214         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1215         struct adt7316_chip_info *chip = iio_priv(dev_info);
1216
1217         return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_IN, buf);
1218 }
1219
1220 static IIO_DEVICE_ATTR(in_temp, S_IRUGO, adt7316_show_in_temp, NULL, 0);
1221
1222 static ssize_t adt7316_show_ex_temp_AIN1(struct device *dev,
1223                 struct device_attribute *attr,
1224                 char *buf)
1225 {
1226         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1227         struct adt7316_chip_info *chip = iio_priv(dev_info);
1228
1229         return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_EX, buf);
1230 }
1231
1232 static IIO_DEVICE_ATTR(ex_temp_AIN1, S_IRUGO, adt7316_show_ex_temp_AIN1,
1233                 NULL, 0);
1234 static IIO_DEVICE_ATTR(ex_temp, S_IRUGO, adt7316_show_ex_temp_AIN1, NULL, 0);
1235
1236 static ssize_t adt7316_show_AIN2(struct device *dev,
1237                 struct device_attribute *attr,
1238                 char *buf)
1239 {
1240         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1241         struct adt7316_chip_info *chip = iio_priv(dev_info);
1242
1243         return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN2, buf);
1244 }
1245 static IIO_DEVICE_ATTR(AIN2, S_IRUGO, adt7316_show_AIN2, NULL, 0);
1246
1247 static ssize_t adt7316_show_AIN3(struct device *dev,
1248                 struct device_attribute *attr,
1249                 char *buf)
1250 {
1251         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1252         struct adt7316_chip_info *chip = iio_priv(dev_info);
1253
1254         return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN3, buf);
1255 }
1256 static IIO_DEVICE_ATTR(AIN3, S_IRUGO, adt7316_show_AIN3, NULL, 0);
1257
1258 static ssize_t adt7316_show_AIN4(struct device *dev,
1259                 struct device_attribute *attr,
1260                 char *buf)
1261 {
1262         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1263         struct adt7316_chip_info *chip = iio_priv(dev_info);
1264
1265         return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN4, buf);
1266 }
1267 static IIO_DEVICE_ATTR(AIN4, S_IRUGO, adt7316_show_AIN4, NULL, 0);
1268
1269 static ssize_t adt7316_show_temp_offset(struct adt7316_chip_info *chip,
1270                 int offset_addr, char *buf)
1271 {
1272         int data;
1273         u8 val;
1274         int ret;
1275
1276         ret = chip->bus.read(chip->bus.client, offset_addr, &val);
1277         if (ret)
1278                 return -EIO;
1279
1280         data = (int)val;
1281         if (val & 0x80)
1282                 data -= 256;
1283
1284         return sprintf(buf, "%d\n", data);
1285 }
1286
1287 static ssize_t adt7316_store_temp_offset(struct adt7316_chip_info *chip,
1288                 int offset_addr, const char *buf, size_t len)
1289 {
1290         int data;
1291         u8 val;
1292         int ret;
1293
1294         ret = kstrtoint(buf, 10, &data);
1295         if (ret || data > 127 || data < -128)
1296                 return -EINVAL;
1297
1298         if (data < 0)
1299                 data += 256;
1300
1301         val = (u8)data;
1302
1303         ret = chip->bus.write(chip->bus.client, offset_addr, val);
1304         if (ret)
1305                 return -EIO;
1306
1307         return len;
1308 }
1309
1310 static ssize_t adt7316_show_in_temp_offset(struct device *dev,
1311                 struct device_attribute *attr,
1312                 char *buf)
1313 {
1314         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1315         struct adt7316_chip_info *chip = iio_priv(dev_info);
1316
1317         return adt7316_show_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf);
1318 }
1319
1320 static ssize_t adt7316_store_in_temp_offset(struct device *dev,
1321                 struct device_attribute *attr,
1322                 const char *buf,
1323                 size_t len)
1324 {
1325         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1326         struct adt7316_chip_info *chip = iio_priv(dev_info);
1327
1328         return adt7316_store_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf,
1329                         len);
1330 }
1331
1332 static IIO_DEVICE_ATTR(in_temp_offset, S_IRUGO | S_IWUSR,
1333                 adt7316_show_in_temp_offset,
1334                 adt7316_store_in_temp_offset, 0);
1335
1336 static ssize_t adt7316_show_ex_temp_offset(struct device *dev,
1337                 struct device_attribute *attr,
1338                 char *buf)
1339 {
1340         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1341         struct adt7316_chip_info *chip = iio_priv(dev_info);
1342
1343         return adt7316_show_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf);
1344 }
1345
1346 static ssize_t adt7316_store_ex_temp_offset(struct device *dev,
1347                 struct device_attribute *attr,
1348                 const char *buf,
1349                 size_t len)
1350 {
1351         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1352         struct adt7316_chip_info *chip = iio_priv(dev_info);
1353
1354         return adt7316_store_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf,
1355                         len);
1356 }
1357
1358 static IIO_DEVICE_ATTR(ex_temp_offset, S_IRUGO | S_IWUSR,
1359                 adt7316_show_ex_temp_offset,
1360                 adt7316_store_ex_temp_offset, 0);
1361
1362 static ssize_t adt7316_show_in_analog_temp_offset(struct device *dev,
1363                 struct device_attribute *attr,
1364                 char *buf)
1365 {
1366         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1367         struct adt7316_chip_info *chip = iio_priv(dev_info);
1368
1369         return adt7316_show_temp_offset(chip,
1370                         ADT7316_IN_ANALOG_TEMP_OFFSET, buf);
1371 }
1372
1373 static ssize_t adt7316_store_in_analog_temp_offset(struct device *dev,
1374                 struct device_attribute *attr,
1375                 const char *buf,
1376                 size_t len)
1377 {
1378         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1379         struct adt7316_chip_info *chip = iio_priv(dev_info);
1380
1381         return adt7316_store_temp_offset(chip,
1382                         ADT7316_IN_ANALOG_TEMP_OFFSET, buf, len);
1383 }
1384
1385 static IIO_DEVICE_ATTR(in_analog_temp_offset, S_IRUGO | S_IWUSR,
1386                 adt7316_show_in_analog_temp_offset,
1387                 adt7316_store_in_analog_temp_offset, 0);
1388
1389 static ssize_t adt7316_show_ex_analog_temp_offset(struct device *dev,
1390                 struct device_attribute *attr,
1391                 char *buf)
1392 {
1393         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1394         struct adt7316_chip_info *chip = iio_priv(dev_info);
1395
1396         return adt7316_show_temp_offset(chip,
1397                         ADT7316_EX_ANALOG_TEMP_OFFSET, buf);
1398 }
1399
1400 static ssize_t adt7316_store_ex_analog_temp_offset(struct device *dev,
1401                 struct device_attribute *attr,
1402                 const char *buf,
1403                 size_t len)
1404 {
1405         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1406         struct adt7316_chip_info *chip = iio_priv(dev_info);
1407
1408         return adt7316_store_temp_offset(chip,
1409                         ADT7316_EX_ANALOG_TEMP_OFFSET, buf, len);
1410 }
1411
1412 static IIO_DEVICE_ATTR(ex_analog_temp_offset, S_IRUGO | S_IWUSR,
1413                 adt7316_show_ex_analog_temp_offset,
1414                 adt7316_store_ex_analog_temp_offset, 0);
1415
1416 static ssize_t adt7316_show_DAC(struct adt7316_chip_info *chip,
1417                 int channel, char *buf)
1418 {
1419         u16 data = 0;
1420         u8 msb, lsb, offset;
1421         int ret;
1422
1423         if (channel >= ADT7316_DA_MSB_DATA_REGS ||
1424                 (channel == 0 &&
1425                 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) ||
1426                 (channel == 1 &&
1427                 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)))
1428                 return -EPERM;
1429
1430         offset = chip->dac_bits - 8;
1431
1432         if (chip->dac_bits > 8) {
1433                 ret = chip->bus.read(chip->bus.client,
1434                         ADT7316_DA_DATA_BASE + channel * 2, &lsb);
1435                 if (ret)
1436                         return -EIO;
1437         }
1438
1439         ret = chip->bus.read(chip->bus.client,
1440                 ADT7316_DA_DATA_BASE + 1 + channel * 2, &msb);
1441         if (ret)
1442                 return -EIO;
1443
1444         if (chip->dac_bits == 12)
1445                 data = lsb >> ADT7316_DA_12_BIT_LSB_SHIFT;
1446         else if (chip->dac_bits == 10)
1447                 data = lsb >> ADT7316_DA_10_BIT_LSB_SHIFT;
1448         data |= msb << offset;
1449
1450         return sprintf(buf, "%d\n", data);
1451 }
1452
1453 static ssize_t adt7316_store_DAC(struct adt7316_chip_info *chip,
1454                 int channel, const char *buf, size_t len)
1455 {
1456         u8 msb, lsb, lsb_reg, offset;
1457         u16 data;
1458         int ret;
1459
1460         if (channel >= ADT7316_DA_MSB_DATA_REGS ||
1461                 (channel == 0 &&
1462                 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) ||
1463                 (channel == 1 &&
1464                 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)))
1465                 return -EPERM;
1466
1467         offset = chip->dac_bits - 8;
1468
1469         ret = kstrtou16(buf, 10, &data);
1470         if (ret || data >= (1 << chip->dac_bits))
1471                 return -EINVAL;
1472
1473         if (chip->dac_bits > 8) {
1474                 lsb = data & ((1 << offset) - 1);
1475                 if (chip->dac_bits == 12)
1476                         lsb_reg = lsb << ADT7316_DA_12_BIT_LSB_SHIFT;
1477                 else
1478                         lsb_reg = lsb << ADT7316_DA_10_BIT_LSB_SHIFT;
1479                 ret = chip->bus.write(chip->bus.client,
1480                         ADT7316_DA_DATA_BASE + channel * 2, lsb_reg);
1481                 if (ret)
1482                         return -EIO;
1483         }
1484
1485         msb = data >> offset;
1486         ret = chip->bus.write(chip->bus.client,
1487                 ADT7316_DA_DATA_BASE + 1 + channel * 2, msb);
1488         if (ret)
1489                 return -EIO;
1490
1491         return len;
1492 }
1493
1494 static ssize_t adt7316_show_DAC_A(struct device *dev,
1495                 struct device_attribute *attr,
1496                 char *buf)
1497 {
1498         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1499         struct adt7316_chip_info *chip = iio_priv(dev_info);
1500
1501         return adt7316_show_DAC(chip, 0, buf);
1502 }
1503
1504 static ssize_t adt7316_store_DAC_A(struct device *dev,
1505                 struct device_attribute *attr,
1506                 const char *buf,
1507                 size_t len)
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_store_DAC(chip, 0, buf, len);
1513 }
1514
1515 static IIO_DEVICE_ATTR(DAC_A, S_IRUGO | S_IWUSR, adt7316_show_DAC_A,
1516                 adt7316_store_DAC_A, 0);
1517
1518 static ssize_t adt7316_show_DAC_B(struct device *dev,
1519                 struct device_attribute *attr,
1520                 char *buf)
1521 {
1522         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1523         struct adt7316_chip_info *chip = iio_priv(dev_info);
1524
1525         return adt7316_show_DAC(chip, 1, buf);
1526 }
1527
1528 static ssize_t adt7316_store_DAC_B(struct device *dev,
1529                 struct device_attribute *attr,
1530                 const char *buf,
1531                 size_t len)
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_store_DAC(chip, 1, buf, len);
1537 }
1538
1539 static IIO_DEVICE_ATTR(DAC_B, S_IRUGO | S_IWUSR, adt7316_show_DAC_B,
1540                 adt7316_store_DAC_B, 0);
1541
1542 static ssize_t adt7316_show_DAC_C(struct device *dev,
1543                 struct device_attribute *attr,
1544                 char *buf)
1545 {
1546         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1547         struct adt7316_chip_info *chip = iio_priv(dev_info);
1548
1549         return adt7316_show_DAC(chip, 2, buf);
1550 }
1551
1552 static ssize_t adt7316_store_DAC_C(struct device *dev,
1553                 struct device_attribute *attr,
1554                 const char *buf,
1555                 size_t len)
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_store_DAC(chip, 2, buf, len);
1561 }
1562
1563 static IIO_DEVICE_ATTR(DAC_C, S_IRUGO | S_IWUSR, adt7316_show_DAC_C,
1564                 adt7316_store_DAC_C, 0);
1565
1566 static ssize_t adt7316_show_DAC_D(struct device *dev,
1567                 struct device_attribute *attr,
1568                 char *buf)
1569 {
1570         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1571         struct adt7316_chip_info *chip = iio_priv(dev_info);
1572
1573         return adt7316_show_DAC(chip, 3, buf);
1574 }
1575
1576 static ssize_t adt7316_store_DAC_D(struct device *dev,
1577                 struct device_attribute *attr,
1578                 const char *buf,
1579                 size_t len)
1580 {
1581         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1582         struct adt7316_chip_info *chip = iio_priv(dev_info);
1583
1584         return adt7316_store_DAC(chip, 3, buf, len);
1585 }
1586
1587 static IIO_DEVICE_ATTR(DAC_D, S_IRUGO | S_IWUSR, adt7316_show_DAC_D,
1588                 adt7316_store_DAC_D, 0);
1589
1590 static ssize_t adt7316_show_device_id(struct device *dev,
1591                 struct device_attribute *attr,
1592                 char *buf)
1593 {
1594         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1595         struct adt7316_chip_info *chip = iio_priv(dev_info);
1596         u8 id;
1597         int ret;
1598
1599         ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_ID, &id);
1600         if (ret)
1601                 return -EIO;
1602
1603         return sprintf(buf, "%d\n", id);
1604 }
1605
1606 static IIO_DEVICE_ATTR(device_id, S_IRUGO, adt7316_show_device_id, NULL, 0);
1607
1608 static ssize_t adt7316_show_manufactorer_id(struct device *dev,
1609                 struct device_attribute *attr,
1610                 char *buf)
1611 {
1612         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1613         struct adt7316_chip_info *chip = iio_priv(dev_info);
1614         u8 id;
1615         int ret;
1616
1617         ret = chip->bus.read(chip->bus.client, ADT7316_MANUFACTURE_ID, &id);
1618         if (ret)
1619                 return -EIO;
1620
1621         return sprintf(buf, "%d\n", id);
1622 }
1623
1624 static IIO_DEVICE_ATTR(manufactorer_id, S_IRUGO,
1625                 adt7316_show_manufactorer_id, NULL, 0);
1626
1627 static ssize_t adt7316_show_device_rev(struct device *dev,
1628                 struct device_attribute *attr,
1629                 char *buf)
1630 {
1631         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1632         struct adt7316_chip_info *chip = iio_priv(dev_info);
1633         u8 rev;
1634         int ret;
1635
1636         ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_REV, &rev);
1637         if (ret)
1638                 return -EIO;
1639
1640         return sprintf(buf, "%d\n", rev);
1641 }
1642
1643 static IIO_DEVICE_ATTR(device_rev, S_IRUGO, adt7316_show_device_rev, NULL, 0);
1644
1645 static ssize_t adt7316_show_bus_type(struct device *dev,
1646                 struct device_attribute *attr,
1647                 char *buf)
1648 {
1649         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1650         struct adt7316_chip_info *chip = iio_priv(dev_info);
1651         u8 stat;
1652         int ret;
1653
1654         ret = chip->bus.read(chip->bus.client, ADT7316_SPI_LOCK_STAT, &stat);
1655         if (ret)
1656                 return -EIO;
1657
1658         if (stat)
1659                 return sprintf(buf, "spi\n");
1660
1661         return sprintf(buf, "i2c\n");
1662 }
1663
1664 static IIO_DEVICE_ATTR(bus_type, S_IRUGO, adt7316_show_bus_type, NULL, 0);
1665
1666 static struct attribute *adt7316_attributes[] = {
1667         &iio_dev_attr_all_modes.dev_attr.attr,
1668         &iio_dev_attr_mode.dev_attr.attr,
1669         &iio_dev_attr_enabled.dev_attr.attr,
1670         &iio_dev_attr_ad_channel.dev_attr.attr,
1671         &iio_dev_attr_all_ad_channels.dev_attr.attr,
1672         &iio_dev_attr_disable_averaging.dev_attr.attr,
1673         &iio_dev_attr_enable_smbus_timeout.dev_attr.attr,
1674         &iio_dev_attr_powerdown.dev_attr.attr,
1675         &iio_dev_attr_fast_ad_clock.dev_attr.attr,
1676         &iio_dev_attr_da_high_resolution.dev_attr.attr,
1677         &iio_dev_attr_enable_proportion_DACA.dev_attr.attr,
1678         &iio_dev_attr_enable_proportion_DACB.dev_attr.attr,
1679         &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr,
1680         &iio_dev_attr_DAC_update_mode.dev_attr.attr,
1681         &iio_dev_attr_all_DAC_update_modes.dev_attr.attr,
1682         &iio_dev_attr_update_DAC.dev_attr.attr,
1683         &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr,
1684         &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr,
1685         &iio_dev_attr_DAC_internal_Vref.dev_attr.attr,
1686         &iio_dev_attr_VDD.dev_attr.attr,
1687         &iio_dev_attr_in_temp.dev_attr.attr,
1688         &iio_dev_attr_ex_temp.dev_attr.attr,
1689         &iio_dev_attr_in_temp_offset.dev_attr.attr,
1690         &iio_dev_attr_ex_temp_offset.dev_attr.attr,
1691         &iio_dev_attr_in_analog_temp_offset.dev_attr.attr,
1692         &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr,
1693         &iio_dev_attr_DAC_A.dev_attr.attr,
1694         &iio_dev_attr_DAC_B.dev_attr.attr,
1695         &iio_dev_attr_DAC_C.dev_attr.attr,
1696         &iio_dev_attr_DAC_D.dev_attr.attr,
1697         &iio_dev_attr_device_id.dev_attr.attr,
1698         &iio_dev_attr_manufactorer_id.dev_attr.attr,
1699         &iio_dev_attr_device_rev.dev_attr.attr,
1700         &iio_dev_attr_bus_type.dev_attr.attr,
1701         NULL,
1702 };
1703
1704 static const struct attribute_group adt7316_attribute_group = {
1705         .attrs = adt7316_attributes,
1706 };
1707
1708 static struct attribute *adt7516_attributes[] = {
1709         &iio_dev_attr_all_modes.dev_attr.attr,
1710         &iio_dev_attr_mode.dev_attr.attr,
1711         &iio_dev_attr_select_ex_temp.dev_attr.attr,
1712         &iio_dev_attr_enabled.dev_attr.attr,
1713         &iio_dev_attr_ad_channel.dev_attr.attr,
1714         &iio_dev_attr_all_ad_channels.dev_attr.attr,
1715         &iio_dev_attr_disable_averaging.dev_attr.attr,
1716         &iio_dev_attr_enable_smbus_timeout.dev_attr.attr,
1717         &iio_dev_attr_powerdown.dev_attr.attr,
1718         &iio_dev_attr_fast_ad_clock.dev_attr.attr,
1719         &iio_dev_attr_AIN_internal_Vref.dev_attr.attr,
1720         &iio_dev_attr_da_high_resolution.dev_attr.attr,
1721         &iio_dev_attr_enable_proportion_DACA.dev_attr.attr,
1722         &iio_dev_attr_enable_proportion_DACB.dev_attr.attr,
1723         &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr,
1724         &iio_dev_attr_DAC_update_mode.dev_attr.attr,
1725         &iio_dev_attr_all_DAC_update_modes.dev_attr.attr,
1726         &iio_dev_attr_update_DAC.dev_attr.attr,
1727         &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr,
1728         &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr,
1729         &iio_dev_attr_DAC_internal_Vref.dev_attr.attr,
1730         &iio_dev_attr_VDD.dev_attr.attr,
1731         &iio_dev_attr_in_temp.dev_attr.attr,
1732         &iio_dev_attr_ex_temp_AIN1.dev_attr.attr,
1733         &iio_dev_attr_AIN2.dev_attr.attr,
1734         &iio_dev_attr_AIN3.dev_attr.attr,
1735         &iio_dev_attr_AIN4.dev_attr.attr,
1736         &iio_dev_attr_in_temp_offset.dev_attr.attr,
1737         &iio_dev_attr_ex_temp_offset.dev_attr.attr,
1738         &iio_dev_attr_in_analog_temp_offset.dev_attr.attr,
1739         &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr,
1740         &iio_dev_attr_DAC_A.dev_attr.attr,
1741         &iio_dev_attr_DAC_B.dev_attr.attr,
1742         &iio_dev_attr_DAC_C.dev_attr.attr,
1743         &iio_dev_attr_DAC_D.dev_attr.attr,
1744         &iio_dev_attr_device_id.dev_attr.attr,
1745         &iio_dev_attr_manufactorer_id.dev_attr.attr,
1746         &iio_dev_attr_device_rev.dev_attr.attr,
1747         &iio_dev_attr_bus_type.dev_attr.attr,
1748         NULL,
1749 };
1750
1751 static const struct attribute_group adt7516_attribute_group = {
1752         .attrs = adt7516_attributes,
1753 };
1754
1755 static irqreturn_t adt7316_event_handler(int irq, void *private)
1756 {
1757         struct iio_dev *indio_dev = private;
1758         struct adt7316_chip_info *chip = iio_priv(indio_dev);
1759         u8 stat1, stat2;
1760         int ret;
1761         s64 time;
1762
1763         ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT1, &stat1);
1764         if (!ret) {
1765                 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
1766                         stat1 &= 0x1F;
1767
1768                 time = iio_get_time_ns();
1769                 if (stat1 & BIT(0))
1770                         iio_push_event(indio_dev,
1771                                        IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
1772                                                             IIO_EV_TYPE_THRESH,
1773                                                             IIO_EV_DIR_RISING),
1774                                        time);
1775                 if (stat1 & BIT(1))
1776                         iio_push_event(indio_dev,
1777                                        IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
1778                                                             IIO_EV_TYPE_THRESH,
1779                                                             IIO_EV_DIR_FALLING),
1780                                        time);
1781                 if (stat1 & BIT(2))
1782                         iio_push_event(indio_dev,
1783                                        IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
1784                                                             IIO_EV_TYPE_THRESH,
1785                                                             IIO_EV_DIR_RISING),
1786                                        time);
1787                 if (stat1 & BIT(3))
1788                         iio_push_event(indio_dev,
1789                                        IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
1790                                                             IIO_EV_TYPE_THRESH,
1791                                                             IIO_EV_DIR_FALLING),
1792                                        time);
1793                 if (stat1 & BIT(5))
1794                         iio_push_event(indio_dev,
1795                                        IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1,
1796                                                             IIO_EV_TYPE_THRESH,
1797                                                             IIO_EV_DIR_EITHER),
1798                                        time);
1799                 if (stat1 & BIT(6))
1800                         iio_push_event(indio_dev,
1801                                        IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 2,
1802                                                             IIO_EV_TYPE_THRESH,
1803                                                             IIO_EV_DIR_EITHER),
1804                                        time);
1805                 if (stat1 & BIT(7))
1806                         iio_push_event(indio_dev,
1807                                        IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 3,
1808                                                             IIO_EV_TYPE_THRESH,
1809                                                             IIO_EV_DIR_EITHER),
1810                                        time);
1811                 }
1812         ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT2, &stat2);
1813         if (!ret) {
1814                 if (stat2 & ADT7316_INT_MASK2_VDD)
1815                         iio_push_event(indio_dev,
1816                                        IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
1817                                                             0,
1818                                                             IIO_EV_TYPE_THRESH,
1819                                                             IIO_EV_DIR_RISING),
1820                                        iio_get_time_ns());
1821         }
1822
1823         return IRQ_HANDLED;
1824 }
1825
1826 /*
1827  * Show mask of enabled interrupts in Hex.
1828  */
1829 static ssize_t adt7316_show_int_mask(struct device *dev,
1830                 struct device_attribute *attr,
1831                 char *buf)
1832 {
1833         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1834         struct adt7316_chip_info *chip = iio_priv(dev_info);
1835
1836         return sprintf(buf, "0x%x\n", chip->int_mask);
1837 }
1838
1839 /*
1840  * Set 1 to the mask in Hex to enabled interrupts.
1841  */
1842 static ssize_t adt7316_set_int_mask(struct device *dev,
1843                 struct device_attribute *attr,
1844                 const char *buf,
1845                 size_t len)
1846 {
1847         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1848         struct adt7316_chip_info *chip = iio_priv(dev_info);
1849         u16 data;
1850         int ret;
1851         u8 mask;
1852
1853         ret = kstrtou16(buf, 16, &data);
1854         if (ret || data >= ADT7316_VDD_INT_MASK + 1)
1855                 return -EINVAL;
1856
1857         if (data & ADT7316_VDD_INT_MASK)
1858                 mask = 0;                       /* enable vdd int */
1859         else
1860                 mask = ADT7316_INT_MASK2_VDD;   /* disable vdd int */
1861
1862         ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK2, mask);
1863         if (!ret) {
1864                 chip->int_mask &= ~ADT7316_VDD_INT_MASK;
1865                 chip->int_mask |= data & ADT7316_VDD_INT_MASK;
1866         }
1867
1868         if (data & ADT7316_TEMP_AIN_INT_MASK) {
1869                 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX)
1870                         /* mask in reg is opposite, set 1 to disable */
1871                         mask = (~data) & ADT7316_TEMP_INT_MASK;
1872                 else
1873                         /* mask in reg is opposite, set 1 to disable */
1874                         mask = (~data) & ADT7316_TEMP_AIN_INT_MASK;
1875         }
1876         ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK1, mask);
1877
1878         chip->int_mask = mask;
1879
1880         return len;
1881 }
1882 static inline ssize_t adt7316_show_ad_bound(struct device *dev,
1883                 struct device_attribute *attr,
1884                 char *buf)
1885 {
1886         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1887         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1888         struct adt7316_chip_info *chip = iio_priv(dev_info);
1889         u8 val;
1890         int data;
1891         int ret;
1892
1893         if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1894                 this_attr->address > ADT7316_EX_TEMP_LOW)
1895                 return -EPERM;
1896
1897         ret = chip->bus.read(chip->bus.client, this_attr->address, &val);
1898         if (ret)
1899                 return -EIO;
1900
1901         data = (int)val;
1902
1903         if (!((chip->id & ID_FAMILY_MASK) == ID_ADT75XX &&
1904                 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)) {
1905                 if (data & 0x80)
1906                         data -= 256;
1907         }
1908
1909         return sprintf(buf, "%d\n", data);
1910 }
1911
1912 static inline ssize_t adt7316_set_ad_bound(struct device *dev,
1913                 struct device_attribute *attr,
1914                 const char *buf,
1915                 size_t len)
1916 {
1917         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1918         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1919         struct adt7316_chip_info *chip = iio_priv(dev_info);
1920         int data;
1921         u8 val;
1922         int ret;
1923
1924         if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1925                 this_attr->address > ADT7316_EX_TEMP_LOW)
1926                 return -EPERM;
1927
1928         ret = kstrtoint(buf, 10, &data);
1929         if (ret)
1930                 return -EINVAL;
1931
1932         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX &&
1933                 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0) {
1934                 if (data > 255 || data < 0)
1935                         return -EINVAL;
1936         } else {
1937                 if (data > 127 || data < -128)
1938                         return -EINVAL;
1939
1940                 if (data < 0)
1941                         data += 256;
1942         }
1943
1944         val = (u8)data;
1945
1946         ret = chip->bus.write(chip->bus.client, this_attr->address, val);
1947         if (ret)
1948                 return -EIO;
1949
1950         return len;
1951 }
1952
1953 static ssize_t adt7316_show_int_enabled(struct device *dev,
1954                 struct device_attribute *attr,
1955                 char *buf)
1956 {
1957         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1958         struct adt7316_chip_info *chip = iio_priv(dev_info);
1959
1960         return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_INT_EN));
1961 }
1962
1963 static ssize_t adt7316_set_int_enabled(struct device *dev,
1964                 struct device_attribute *attr,
1965                 const char *buf,
1966                 size_t len)
1967 {
1968         struct iio_dev *dev_info = dev_to_iio_dev(dev);
1969         struct adt7316_chip_info *chip = iio_priv(dev_info);
1970         u8 config1;
1971         int ret;
1972
1973         config1 = chip->config1 & (~ADT7316_INT_EN);
1974         if (buf[0] == '1')
1975                 config1 |= ADT7316_INT_EN;
1976
1977         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1);
1978         if (ret)
1979                 return -EIO;
1980
1981         chip->config1 = config1;
1982
1983         return len;
1984 }
1985
1986 static IIO_DEVICE_ATTR(int_mask,
1987                        S_IRUGO | S_IWUSR,
1988                        adt7316_show_int_mask, adt7316_set_int_mask,
1989                        0);
1990 static IIO_DEVICE_ATTR(in_temp_high_value,
1991                        S_IRUGO | S_IWUSR,
1992                        adt7316_show_ad_bound, adt7316_set_ad_bound,
1993                        ADT7316_IN_TEMP_HIGH);
1994 static IIO_DEVICE_ATTR(in_temp_low_value,
1995                        S_IRUGO | S_IWUSR,
1996                        adt7316_show_ad_bound, adt7316_set_ad_bound,
1997                        ADT7316_IN_TEMP_LOW);
1998 static IIO_DEVICE_ATTR(ex_temp_high_value,
1999                        S_IRUGO | S_IWUSR,
2000                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2001                        ADT7316_EX_TEMP_HIGH);
2002 static IIO_DEVICE_ATTR(ex_temp_low_value,
2003                        S_IRUGO | S_IWUSR,
2004                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2005                        ADT7316_EX_TEMP_LOW);
2006
2007 /* NASTY duplication to be fixed */
2008 static IIO_DEVICE_ATTR(ex_temp_ain1_high_value,
2009                        S_IRUGO | S_IWUSR,
2010                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2011                        ADT7316_EX_TEMP_HIGH);
2012 static IIO_DEVICE_ATTR(ex_temp_ain1_low_value,
2013                        S_IRUGO | S_IWUSR,
2014                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2015                        ADT7316_EX_TEMP_LOW);
2016 static IIO_DEVICE_ATTR(ain2_high_value,
2017                        S_IRUGO | S_IWUSR,
2018                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2019                        ADT7516_AIN2_HIGH);
2020 static IIO_DEVICE_ATTR(ain2_low_value,
2021                        S_IRUGO | S_IWUSR,
2022                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2023                        ADT7516_AIN2_LOW);
2024 static IIO_DEVICE_ATTR(ain3_high_value,
2025                        S_IRUGO | S_IWUSR,
2026                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2027                        ADT7516_AIN3_HIGH);
2028 static IIO_DEVICE_ATTR(ain3_low_value,
2029                        S_IRUGO | S_IWUSR,
2030                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2031                        ADT7516_AIN3_LOW);
2032 static IIO_DEVICE_ATTR(ain4_high_value,
2033                        S_IRUGO | S_IWUSR,
2034                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2035                        ADT7516_AIN4_HIGH);
2036 static IIO_DEVICE_ATTR(ain4_low_value,
2037                        S_IRUGO | S_IWUSR,
2038                        adt7316_show_ad_bound, adt7316_set_ad_bound,
2039                        ADT7516_AIN4_LOW);
2040 static IIO_DEVICE_ATTR(int_enabled,
2041                        S_IRUGO | S_IWUSR,
2042                        adt7316_show_int_enabled,
2043                        adt7316_set_int_enabled, 0);
2044
2045 static struct attribute *adt7316_event_attributes[] = {
2046         &iio_dev_attr_int_mask.dev_attr.attr,
2047         &iio_dev_attr_in_temp_high_value.dev_attr.attr,
2048         &iio_dev_attr_in_temp_low_value.dev_attr.attr,
2049         &iio_dev_attr_ex_temp_high_value.dev_attr.attr,
2050         &iio_dev_attr_ex_temp_low_value.dev_attr.attr,
2051         &iio_dev_attr_int_enabled.dev_attr.attr,
2052         NULL,
2053 };
2054
2055 static struct attribute_group adt7316_event_attribute_group = {
2056         .attrs = adt7316_event_attributes,
2057         .name = "events",
2058 };
2059
2060 static struct attribute *adt7516_event_attributes[] = {
2061         &iio_dev_attr_int_mask.dev_attr.attr,
2062         &iio_dev_attr_in_temp_high_value.dev_attr.attr,
2063         &iio_dev_attr_in_temp_low_value.dev_attr.attr,
2064         &iio_dev_attr_ex_temp_ain1_high_value.dev_attr.attr,
2065         &iio_dev_attr_ex_temp_ain1_low_value.dev_attr.attr,
2066         &iio_dev_attr_ain2_high_value.dev_attr.attr,
2067         &iio_dev_attr_ain2_low_value.dev_attr.attr,
2068         &iio_dev_attr_ain3_high_value.dev_attr.attr,
2069         &iio_dev_attr_ain3_low_value.dev_attr.attr,
2070         &iio_dev_attr_ain4_high_value.dev_attr.attr,
2071         &iio_dev_attr_ain4_low_value.dev_attr.attr,
2072         &iio_dev_attr_int_enabled.dev_attr.attr,
2073         NULL,
2074 };
2075
2076 static struct attribute_group adt7516_event_attribute_group = {
2077         .attrs = adt7516_event_attributes,
2078         .name = "events",
2079 };
2080
2081 #ifdef CONFIG_PM_SLEEP
2082 static int adt7316_disable(struct device *dev)
2083 {
2084         struct iio_dev *dev_info = dev_get_drvdata(dev);
2085         struct adt7316_chip_info *chip = iio_priv(dev_info);
2086
2087         return _adt7316_store_enabled(chip, 0);
2088 }
2089
2090 static int adt7316_enable(struct device *dev)
2091 {
2092         struct iio_dev *dev_info = dev_get_drvdata(dev);
2093         struct adt7316_chip_info *chip = iio_priv(dev_info);
2094
2095         return _adt7316_store_enabled(chip, 1);
2096 }
2097
2098 SIMPLE_DEV_PM_OPS(adt7316_pm_ops, adt7316_disable, adt7316_enable);
2099 EXPORT_SYMBOL_GPL(adt7316_pm_ops);
2100 #endif
2101
2102 static const struct iio_info adt7316_info = {
2103         .attrs = &adt7316_attribute_group,
2104         .event_attrs = &adt7316_event_attribute_group,
2105         .driver_module = THIS_MODULE,
2106 };
2107
2108 static const struct iio_info adt7516_info = {
2109         .attrs = &adt7516_attribute_group,
2110         .event_attrs = &adt7516_event_attribute_group,
2111         .driver_module = THIS_MODULE,
2112 };
2113
2114 /*
2115  * device probe and remove
2116  */
2117 int adt7316_probe(struct device *dev, struct adt7316_bus *bus,
2118                 const char *name)
2119 {
2120         struct adt7316_chip_info *chip;
2121         struct iio_dev *indio_dev;
2122         unsigned short *adt7316_platform_data = dev->platform_data;
2123         int ret = 0;
2124
2125         indio_dev = devm_iio_device_alloc(dev, sizeof(*chip));
2126         if (!indio_dev)
2127                 return -ENOMEM;
2128         chip = iio_priv(indio_dev);
2129         /* this is only used for device removal purposes */
2130         dev_set_drvdata(dev, indio_dev);
2131
2132         chip->bus = *bus;
2133
2134         if (name[4] == '3')
2135                 chip->id = ID_ADT7316 + (name[6] - '6');
2136         else if (name[4] == '5')
2137                 chip->id = ID_ADT7516 + (name[6] - '6');
2138         else
2139                 return -ENODEV;
2140
2141         chip->ldac_pin = adt7316_platform_data[1];
2142         if (chip->ldac_pin) {
2143                 chip->config3 |= ADT7316_DA_EN_VIA_DAC_LDCA;
2144                 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2145                         chip->config1 |= ADT7516_SEL_AIN3;
2146         }
2147         chip->int_mask = ADT7316_TEMP_INT_MASK | ADT7316_VDD_INT_MASK;
2148         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2149                 chip->int_mask |= ADT7516_AIN_INT_MASK;
2150
2151         indio_dev->dev.parent = dev;
2152         if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2153                 indio_dev->info = &adt7516_info;
2154         else
2155                 indio_dev->info = &adt7316_info;
2156         indio_dev->name = name;
2157         indio_dev->modes = INDIO_DIRECT_MODE;
2158
2159         if (chip->bus.irq > 0) {
2160                 if (adt7316_platform_data[0])
2161                         chip->bus.irq_flags = adt7316_platform_data[0];
2162
2163                 ret = devm_request_threaded_irq(dev, chip->bus.irq,
2164                                                 NULL,
2165                                                 adt7316_event_handler,
2166                                                 chip->bus.irq_flags |
2167                                                 IRQF_ONESHOT,
2168                                                 indio_dev->name,
2169                                                 indio_dev);
2170                 if (ret)
2171                         return ret;
2172
2173                 if (chip->bus.irq_flags & IRQF_TRIGGER_HIGH)
2174                         chip->config1 |= ADT7316_INT_POLARITY;
2175         }
2176
2177         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, chip->config1);
2178         if (ret)
2179                 return -EIO;
2180
2181         ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, chip->config3);
2182         if (ret)
2183                 return -EIO;
2184
2185         ret = devm_iio_device_register(dev, indio_dev);
2186         if (ret)
2187                 return ret;
2188
2189         dev_info(dev, "%s temperature sensor, ADC and DAC registered.\n",
2190                         indio_dev->name);
2191
2192         return 0;
2193 }
2194 EXPORT_SYMBOL(adt7316_probe);
2195
2196 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
2197 MODULE_DESCRIPTION("Analog Devices ADT7316/7/8 and ADT7516/7/9 digital temperature sensor, ADC and DAC driver");
2198 MODULE_LICENSE("GPL v2");