drivers/staging/iio/addac/adt7316.c

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