Merge tag 'iio-for-3.8f' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio into staging-next

Jonathan writes:
  "6th set of IIO new driver support, clean up and fixes for the 3.8 cycle
   (possibly wait until 3.9 cycle given timing).

   Here we have
   * the cleanup and move out of staging of ad7793.
   * addition support for additional parts to ad7793.
   * a basic new driver for TI ADC081C021/027
   * 4 little fixes for the recent addition of ad16136 and ad16480.

   So some nice work with nothing controversial or anything that
   will effect stuff outside the drivers in question."

9 files changed, 537 insertions, 171 deletions

diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index cd5eed60be28..961b8d0a4bac 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -42,6 +42,18 @@ config AD7791
           To compile this driver as a module, choose M here: the module will be
           called ad7791.
 
+config AD7793
+        tristate "Analog Devices AD7793 and similar ADCs driver"
+        depends on SPI
+        select AD_SIGMA_DELTA
+        help
+          Say yes here to build support for Analog Devices AD7785, AD7792, AD7793,
+          AD7794 and AD7795 SPI analog to digital converters (ADC).
+          If unsure, say N (but it's safe to say "Y").
+
+          To compile this driver as a module, choose M here: the
+          module will be called AD7793.
+
 config AD7476
         tristate "Analog Devices AD7476 and similar 1-channel ADCs driver"
         depends on SPI
@@ -103,4 +115,14 @@ config MAX1363
           max11646, max11647) Provides direct access via sysfs and buffered
           data via the iio dev interface.
 
+config TI_ADC081C
+        tristate "Texas Instruments ADC081C021/027"
+        depends on I2C
+        help
+          If you say yes here you get support for Texas Instruments ADC081C021
+          and ADC081C027 ADC chips.
+
+          This driver can also be built as a module. If so, the module will be
+          called ti-adc081c.
+
 endmenu
diff --git a/drivers/iio/adc/Makefile b/drivers/iio/adc/Makefile
index 3256dc64a466..472fd7cd2417 100644
--- a/drivers/iio/adc/Makefile
+++ b/drivers/iio/adc/Makefile
@@ -7,7 +7,10 @@ obj-$(CONFIG_AD7266) += ad7266.o
 obj-$(CONFIG_AD7298) += ad7298.o
 obj-$(CONFIG_AD7476) += ad7476.o
 obj-$(CONFIG_AD7791) += ad7791.o
+obj-$(CONFIG_AD7793) += ad7793.o
 obj-$(CONFIG_AD7887) += ad7887.o
 obj-$(CONFIG_AT91_ADC) += at91_adc.o
 obj-$(CONFIG_LP8788_ADC) += lp8788_adc.o
 obj-$(CONFIG_MAX1363) += max1363.o
+obj-$(CONFIG_TI_ADC081C) += ti-adc081c.o
+
diff --git a/drivers/staging/iio/adc/ad7793.c b/drivers/iio/adc/ad7793.c
index b0a57e475410..334e31ff7a4e 100644
--- a/drivers/staging/iio/adc/ad7793.c
+++ b/drivers/iio/adc/ad7793.c
@@ -25,8 +25,106 @@
 #include <linux/iio/trigger_consumer.h>
 #include <linux/iio/triggered_buffer.h>
 #include <linux/iio/adc/ad_sigma_delta.h>
-
-#include "ad7793.h"
+#include <linux/platform_data/ad7793.h>
+
+/* Registers */
+#define AD7793_REG_COMM         0 /* Communications Register (WO, 8-bit) */
+#define AD7793_REG_STAT         0 /* Status Register         (RO, 8-bit) */
+#define AD7793_REG_MODE         1 /* Mode Register           (RW, 16-bit */
+#define AD7793_REG_CONF         2 /* Configuration Register  (RW, 16-bit) */
+#define AD7793_REG_DATA         3 /* Data Register           (RO, 16-/24-bit) */
+#define AD7793_REG_ID           4 /* ID Register             (RO, 8-bit) */
+#define AD7793_REG_IO           5 /* IO Register             (RO, 8-bit) */
+#define AD7793_REG_OFFSET       6 /* Offset Register         (RW, 16-bit
+                                   * (AD7792)/24-bit (AD7793)) */
+#define AD7793_REG_FULLSALE     7 /* Full-Scale Register
+                                   * (RW, 16-bit (AD7792)/24-bit (AD7793)) */
+
+/* Communications Register Bit Designations (AD7793_REG_COMM) */
+#define AD7793_COMM_WEN         (1 << 7) /* Write Enable */
+#define AD7793_COMM_WRITE       (0 << 6) /* Write Operation */
+#define AD7793_COMM_READ        (1 << 6) /* Read Operation */
+#define AD7793_COMM_ADDR(x)     (((x) & 0x7) << 3) /* Register Address */
+#define AD7793_COMM_CREAD       (1 << 2) /* Continuous Read of Data Register */
+
+/* Status Register Bit Designations (AD7793_REG_STAT) */
+#define AD7793_STAT_RDY         (1 << 7) /* Ready */
+#define AD7793_STAT_ERR         (1 << 6) /* Error (Overrange, Underrange) */
+#define AD7793_STAT_CH3         (1 << 2) /* Channel 3 */
+#define AD7793_STAT_CH2         (1 << 1) /* Channel 2 */
+#define AD7793_STAT_CH1         (1 << 0) /* Channel 1 */
+
+/* Mode Register Bit Designations (AD7793_REG_MODE) */
+#define AD7793_MODE_SEL(x)      (((x) & 0x7) << 13) /* Operation Mode Select */
+#define AD7793_MODE_SEL_MASK    (0x7 << 13) /* Operation Mode Select mask */
+#define AD7793_MODE_CLKSRC(x)   (((x) & 0x3) << 6) /* ADC Clock Source Select */
+#define AD7793_MODE_RATE(x)     ((x) & 0xF) /* Filter Update Rate Select */
+
+#define AD7793_MODE_CONT                0 /* Continuous Conversion Mode */
+#define AD7793_MODE_SINGLE              1 /* Single Conversion Mode */
+#define AD7793_MODE_IDLE                2 /* Idle Mode */
+#define AD7793_MODE_PWRDN               3 /* Power-Down Mode */
+#define AD7793_MODE_CAL_INT_ZERO        4 /* Internal Zero-Scale Calibration */
+#define AD7793_MODE_CAL_INT_FULL        5 /* Internal Full-Scale Calibration */
+#define AD7793_MODE_CAL_SYS_ZERO        6 /* System Zero-Scale Calibration */
+#define AD7793_MODE_CAL_SYS_FULL        7 /* System Full-Scale Calibration */
+
+#define AD7793_CLK_INT          0 /* Internal 64 kHz Clock not
+                                   * available at the CLK pin */
+#define AD7793_CLK_INT_CO       1 /* Internal 64 kHz Clock available
+                                   * at the CLK pin */
+#define AD7793_CLK_EXT          2 /* External 64 kHz Clock */
+#define AD7793_CLK_EXT_DIV2     3 /* External Clock divided by 2 */
+
+/* Configuration Register Bit Designations (AD7793_REG_CONF) */
+#define AD7793_CONF_VBIAS(x)    (((x) & 0x3) << 14) /* Bias Voltage
+                                                     * Generator Enable */
+#define AD7793_CONF_BO_EN       (1 << 13) /* Burnout Current Enable */
+#define AD7793_CONF_UNIPOLAR    (1 << 12) /* Unipolar/Bipolar Enable */
+#define AD7793_CONF_BOOST       (1 << 11) /* Boost Enable */
+#define AD7793_CONF_GAIN(x)     (((x) & 0x7) << 8) /* Gain Select */
+#define AD7793_CONF_REFSEL(x)   ((x) << 6) /* INT/EXT Reference Select */
+#define AD7793_CONF_BUF         (1 << 4) /* Buffered Mode Enable */
+#define AD7793_CONF_CHAN(x)     ((x) & 0xf) /* Channel select */
+#define AD7793_CONF_CHAN_MASK   0xf /* Channel select mask */
+
+#define AD7793_CH_AIN1P_AIN1M   0 /* AIN1(+) - AIN1(-) */
+#define AD7793_CH_AIN2P_AIN2M   1 /* AIN2(+) - AIN2(-) */
+#define AD7793_CH_AIN3P_AIN3M   2 /* AIN3(+) - AIN3(-) */
+#define AD7793_CH_AIN1M_AIN1M   3 /* AIN1(-) - AIN1(-) */
+#define AD7793_CH_TEMP          6 /* Temp Sensor */
+#define AD7793_CH_AVDD_MONITOR  7 /* AVDD Monitor */
+
+#define AD7795_CH_AIN4P_AIN4M   4 /* AIN4(+) - AIN4(-) */
+#define AD7795_CH_AIN5P_AIN5M   5 /* AIN5(+) - AIN5(-) */
+#define AD7795_CH_AIN6P_AIN6M   6 /* AIN6(+) - AIN6(-) */
+#define AD7795_CH_AIN1M_AIN1M   8 /* AIN1(-) - AIN1(-) */
+
+/* ID Register Bit Designations (AD7793_REG_ID) */
+#define AD7785_ID               0xB
+#define AD7792_ID               0xA
+#define AD7793_ID               0xB
+#define AD7794_ID               0xF
+#define AD7795_ID               0xF
+#define AD7796_ID               0xA
+#define AD7797_ID               0xB
+#define AD7798_ID               0x8
+#define AD7799_ID               0x9
+#define AD7793_ID_MASK          0xF
+
+/* IO (Excitation Current Sources) Register Bit Designations (AD7793_REG_IO) */
+#define AD7793_IO_IEXC1_IOUT1_IEXC2_IOUT2       0 /* IEXC1 connect to IOUT1,
+                                                   * IEXC2 connect to IOUT2 */
+#define AD7793_IO_IEXC1_IOUT2_IEXC2_IOUT1       1 /* IEXC1 connect to IOUT2,
+                                                   * IEXC2 connect to IOUT1 */
+#define AD7793_IO_IEXC1_IEXC2_IOUT1             2 /* Both current sources
+                                                   * IEXC1,2 connect to IOUT1 */
+#define AD7793_IO_IEXC1_IEXC2_IOUT2             3 /* Both current sources
+                                                   * IEXC1,2 connect to IOUT2 */
+
+#define AD7793_IO_IXCEN_10uA    (1 << 0) /* Excitation Current 10uA */
+#define AD7793_IO_IXCEN_210uA   (2 << 0) /* Excitation Current 210uA */
+#define AD7793_IO_IXCEN_1mA     (3 << 0) /* Excitation Current 1mA */
 
 /* NOTE:
  * The AD7792/AD7793 features a dual use data out ready DOUT/RDY output.
@@ -36,9 +134,21 @@
  * The DOUT/RDY output must also be wired to an interrupt capable GPIO.
  */
 
+#define AD7793_FLAG_HAS_CLKSEL          BIT(0)
+#define AD7793_FLAG_HAS_REFSEL          BIT(1)
+#define AD7793_FLAG_HAS_VBIAS           BIT(2)
+#define AD7793_HAS_EXITATION_CURRENT    BIT(3)
+#define AD7793_FLAG_HAS_GAIN            BIT(4)
+#define AD7793_FLAG_HAS_BUFFER          BIT(5)
+
 struct ad7793_chip_info {
+        unsigned int id;
         const struct iio_chan_spec *channels;
         unsigned int num_channels;
+        unsigned int flags;
+
+        const struct iio_info *iio_info;
+        const u16 *sample_freq_avail;
 };
 
 struct ad7793_state {
@@ -59,6 +169,10 @@ enum ad7793_supported_device_ids {
         ID_AD7793,
         ID_AD7794,
         ID_AD7795,
+        ID_AD7796,
+        ID_AD7797,
+        ID_AD7798,
+        ID_AD7799,
 };
 
 static struct ad7793_state *ad_sigma_delta_to_ad7793(struct ad_sigma_delta *sd)
@@ -110,19 +224,52 @@ static int ad7793_calibrate_all(struct ad7793_state *st)
                                    ARRAY_SIZE(ad7793_calib_arr));
 }
 
-static int ad7793_setup(struct iio_dev *indio_dev,
+static int ad7793_check_platform_data(struct ad7793_state *st,
         const struct ad7793_platform_data *pdata)
 {
+        if ((pdata->current_source_direction == AD7793_IEXEC1_IEXEC2_IOUT1 ||
+                pdata->current_source_direction == AD7793_IEXEC1_IEXEC2_IOUT2) &&
+                ((pdata->exitation_current != AD7793_IX_10uA) &&
+                (pdata->exitation_current != AD7793_IX_210uA)))
+                return -EINVAL;
+
+        if (!(st->chip_info->flags & AD7793_FLAG_HAS_CLKSEL) &&
+                pdata->clock_src != AD7793_CLK_SRC_INT)
+                return -EINVAL;
+
+        if (!(st->chip_info->flags & AD7793_FLAG_HAS_REFSEL) &&
+                pdata->refsel != AD7793_REFSEL_REFIN1)
+                return -EINVAL;
+
+        if (!(st->chip_info->flags & AD7793_FLAG_HAS_VBIAS) &&
+                pdata->bias_voltage != AD7793_BIAS_VOLTAGE_DISABLED)
+                return -EINVAL;
+
+        if (!(st->chip_info->flags & AD7793_HAS_EXITATION_CURRENT) &&
+                pdata->exitation_current != AD7793_IX_DISABLED)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int ad7793_setup(struct iio_dev *indio_dev,
+        const struct ad7793_platform_data *pdata,
+        unsigned int vref_mv)
+{
         struct ad7793_state *st = iio_priv(indio_dev);
         int i, ret = -1;
         unsigned long long scale_uv;
         u32 id;
 
+        ret = ad7793_check_platform_data(st, pdata);
+        if (ret)
+                return ret;
+
         /* reset the serial interface */
         ret = spi_write(st->sd.spi, (u8 *)&ret, sizeof(ret));
         if (ret < 0)
                 goto out;
-        msleep(1); /* Wait for at least 500us */
+        usleep_range(500, 2000); /* Wait for at least 500us */
 
         /* write/read test for device presence */
         ret = ad_sd_read_reg(&st->sd, AD7793_REG_ID, 1, &id);
@@ -131,13 +278,32 @@ static int ad7793_setup(struct iio_dev *indio_dev,
 
         id &= AD7793_ID_MASK;
 
-        if (!((id == AD7792_ID) || (id == AD7793_ID) || (id == AD7795_ID))) {
+        if (id != st->chip_info->id) {
                 dev_err(&st->sd.spi->dev, "device ID query failed\n");
                 goto out;
         }
 
-        st->mode = pdata->mode;
-        st->conf = pdata->conf;
+        st->mode = AD7793_MODE_RATE(1);
+        st->conf = 0;
+
+        if (st->chip_info->flags & AD7793_FLAG_HAS_CLKSEL)
+                st->mode |= AD7793_MODE_CLKSRC(pdata->clock_src);
+        if (st->chip_info->flags & AD7793_FLAG_HAS_REFSEL)
+                st->conf |= AD7793_CONF_REFSEL(pdata->refsel);
+        if (st->chip_info->flags & AD7793_FLAG_HAS_VBIAS)
+                st->conf |= AD7793_CONF_VBIAS(pdata->bias_voltage);
+        if (pdata->buffered || !(st->chip_info->flags & AD7793_FLAG_HAS_BUFFER))
+                st->conf |= AD7793_CONF_BUF;
+        if (pdata->boost_enable &&
+                (st->chip_info->flags & AD7793_FLAG_HAS_VBIAS))
+                st->conf |= AD7793_CONF_BOOST;
+        if (pdata->burnout_current)
+                st->conf |= AD7793_CONF_BO_EN;
+        if (pdata->unipolar)
+                st->conf |= AD7793_CONF_UNIPOLAR;
+
+        if (!(st->chip_info->flags & AD7793_FLAG_HAS_GAIN))
+                st->conf |= AD7793_CONF_GAIN(7);
 
         ret = ad7793_set_mode(&st->sd, AD_SD_MODE_IDLE);
         if (ret)
@@ -147,10 +313,13 @@ static int ad7793_setup(struct iio_dev *indio_dev,
         if (ret)
                 goto out;
 
-        ret = ad_sd_write_reg(&st->sd, AD7793_REG_IO,
-                               sizeof(pdata->io), pdata->io);
-        if (ret)
-                goto out;
+        if (st->chip_info->flags & AD7793_HAS_EXITATION_CURRENT) {
+                ret = ad_sd_write_reg(&st->sd, AD7793_REG_IO, 1,
+                                pdata->exitation_current |
+                                (pdata->current_source_direction << 2));
+                if (ret)
+                        goto out;
+        }
 
         ret = ad7793_calibrate_all(st);
         if (ret)
@@ -158,7 +327,7 @@ static int ad7793_setup(struct iio_dev *indio_dev,
 
         /* Populate available ADC input ranges */
         for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++) {
-                scale_uv = ((u64)st->int_vref_mv * 100000000)
+                scale_uv = ((u64)vref_mv * 100000000)
                         >> (st->chip_info->channels[0].scan_type.realbits -
                         (!!(st->conf & AD7793_CONF_UNIPOLAR) ? 0 : 1));
                 scale_uv >>= i;
@@ -173,8 +342,11 @@ out:
         return ret;
 }
 
-static const u16 sample_freq_avail[16] = {0, 470, 242, 123, 62, 50, 39, 33, 19,
-                                          17, 16, 12, 10, 8, 6, 4};
+static const u16 ad7793_sample_freq_avail[16] = {0, 470, 242, 123, 62, 50, 39,
+                                        33, 19, 17, 16, 12, 10, 8, 6, 4};
+
+static const u16 ad7797_sample_freq_avail[16] = {0, 0, 0, 123, 62, 50, 0,
+                                        33, 0, 17, 16, 12, 10, 8, 6, 4};
 
 static ssize_t ad7793_read_frequency(struct device *dev,
                 struct device_attribute *attr,
@@ -184,7 +356,7 @@ static ssize_t ad7793_read_frequency(struct device *dev,
         struct ad7793_state *st = iio_priv(indio_dev);
 
         return sprintf(buf, "%d\n",
-                       sample_freq_avail[AD7793_MODE_RATE(st->mode)]);
+               st->chip_info->sample_freq_avail[AD7793_MODE_RATE(st->mode)]);
 }
 
 static ssize_t ad7793_write_frequency(struct device *dev,
@@ -204,14 +376,17 @@ static ssize_t ad7793_write_frequency(struct device *dev,
         }
         mutex_unlock(&indio_dev->mlock);
 
-        ret = strict_strtol(buf, 10, &lval);
+        ret = kstrtol(buf, 10, &lval);
         if (ret)
                 return ret;
 
+        if (lval == 0)
+                return -EINVAL;
+
         ret = -EINVAL;
 
-        for (i = 0; i < ARRAY_SIZE(sample_freq_avail); i++)
-                if (lval == sample_freq_avail[i]) {
+        for (i = 0; i < 16; i++)
+                if (lval == st->chip_info->sample_freq_avail[i]) {
                         mutex_lock(&indio_dev->mlock);
                         st->mode &= ~AD7793_MODE_RATE(-1);
                         st->mode |= AD7793_MODE_RATE(i);
@@ -231,6 +406,9 @@ static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
         "470 242 123 62 50 39 33 19 17 16 12 10 8 6 4");
 
+static IIO_CONST_ATTR_NAMED(sampling_frequency_available_ad7797,
+        sampling_frequency_available, "123 62 50 33 17 16 12 10 8 6 4");
+
 static ssize_t ad7793_show_scale_available(struct device *dev,
                         struct device_attribute *attr, char *buf)
 {
@@ -262,6 +440,16 @@ static const struct attribute_group ad7793_attribute_group = {
         .attrs = ad7793_attributes,
 };
 
+static struct attribute *ad7797_attributes[] = {
+        &iio_dev_attr_sampling_frequency.dev_attr.attr,
+        &iio_const_attr_sampling_frequency_available_ad7797.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group ad7797_attribute_group = {
+        .attrs = ad7797_attributes,
+};
+
 static int ad7793_read_raw(struct iio_dev *indio_dev,
                            struct iio_chan_spec const *chan,
                            int *val,
@@ -292,12 +480,12 @@ static int ad7793_read_raw(struct iio_dev *indio_dev,
                                 return IIO_VAL_INT_PLUS_NANO;
                         } else {
                                 /* 1170mV / 2^23 * 6 */
-                                scale_uv = (1170ULL * 100000000ULL * 6ULL);
+                                scale_uv = (1170ULL * 1000000000ULL * 6ULL);
                         }
                         break;
                 case IIO_TEMP:
                                 /* 1170mV / 0.81 mV/C / 2^23 */
-                                scale_uv = 1444444444444ULL;
+                                scale_uv = 1444444444444444ULL;
                         break;
                 default:
                         return -EINVAL;
@@ -387,6 +575,15 @@ static const struct iio_info ad7793_info = {
         .driver_module = THIS_MODULE,
 };
 
+static const struct iio_info ad7797_info = {
+        .read_raw = &ad7793_read_raw,
+        .write_raw = &ad7793_write_raw,
+        .write_raw_get_fmt = &ad7793_write_raw_get_fmt,
+        .attrs = &ad7793_attribute_group,
+        .validate_trigger = ad_sd_validate_trigger,
+        .driver_module = THIS_MODULE,
+};
+
 #define DECLARE_AD7793_CHANNELS(_name, _b, _sb, _s) \
 const struct iio_chan_spec _name##_channels[] = { \
         AD_SD_DIFF_CHANNEL(0, 0, 0, AD7793_CH_AIN1P_AIN1M, (_b), (_sb), (_s)), \
@@ -412,32 +609,134 @@ const struct iio_chan_spec _name##_channels[] = { \
         IIO_CHAN_SOFT_TIMESTAMP(9), \
 }
 
+#define DECLARE_AD7797_CHANNELS(_name, _b, _sb) \
+const struct iio_chan_spec _name##_channels[] = { \
+        AD_SD_DIFF_CHANNEL(0, 0, 0, AD7793_CH_AIN1P_AIN1M, (_b), (_sb), 0), \
+        AD_SD_SHORTED_CHANNEL(1, 0, AD7793_CH_AIN1M_AIN1M, (_b), (_sb), 0), \
+        AD_SD_TEMP_CHANNEL(2, AD7793_CH_TEMP, (_b), (_sb), 0), \
+        AD_SD_SUPPLY_CHANNEL(3, 3, AD7793_CH_AVDD_MONITOR, (_b), (_sb), 0), \
+        IIO_CHAN_SOFT_TIMESTAMP(4), \
+}
+
+#define DECLARE_AD7799_CHANNELS(_name, _b, _sb) \
+const struct iio_chan_spec _name##_channels[] = { \
+        AD_SD_DIFF_CHANNEL(0, 0, 0, AD7793_CH_AIN1P_AIN1M, (_b), (_sb), 0), \
+        AD_SD_DIFF_CHANNEL(1, 1, 1, AD7793_CH_AIN2P_AIN2M, (_b), (_sb), 0), \
+        AD_SD_DIFF_CHANNEL(2, 2, 2, AD7793_CH_AIN3P_AIN3M, (_b), (_sb), 0), \
+        AD_SD_SHORTED_CHANNEL(3, 0, AD7793_CH_AIN1M_AIN1M, (_b), (_sb), 0), \
+        AD_SD_SUPPLY_CHANNEL(4, 3, AD7793_CH_AVDD_MONITOR, (_b), (_sb), 0), \
+        IIO_CHAN_SOFT_TIMESTAMP(5), \
+}
+
 static DECLARE_AD7793_CHANNELS(ad7785, 20, 32, 4);
 static DECLARE_AD7793_CHANNELS(ad7792, 16, 32, 0);
 static DECLARE_AD7793_CHANNELS(ad7793, 24, 32, 0);
 static DECLARE_AD7795_CHANNELS(ad7794, 16, 32);
 static DECLARE_AD7795_CHANNELS(ad7795, 24, 32);
+static DECLARE_AD7797_CHANNELS(ad7796, 16, 16);
+static DECLARE_AD7797_CHANNELS(ad7797, 24, 32);
+static DECLARE_AD7799_CHANNELS(ad7798, 16, 16);
+static DECLARE_AD7799_CHANNELS(ad7799, 24, 32);
 
 static const struct ad7793_chip_info ad7793_chip_info_tbl[] = {
         [ID_AD7785] = {
+                .id = AD7785_ID,
                 .channels = ad7785_channels,
                 .num_channels = ARRAY_SIZE(ad7785_channels),
+                .iio_info = &ad7793_info,
+                .sample_freq_avail = ad7793_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_CLKSEL |
+                        AD7793_FLAG_HAS_REFSEL |
+                        AD7793_FLAG_HAS_VBIAS |
+                        AD7793_HAS_EXITATION_CURRENT |
+                        AD7793_FLAG_HAS_GAIN |
+                        AD7793_FLAG_HAS_BUFFER,
         },
         [ID_AD7792] = {
+                .id = AD7792_ID,
                 .channels = ad7792_channels,
                 .num_channels = ARRAY_SIZE(ad7792_channels),
+                .iio_info = &ad7793_info,
+                .sample_freq_avail = ad7793_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_CLKSEL |
+                        AD7793_FLAG_HAS_REFSEL |
+                        AD7793_FLAG_HAS_VBIAS |
+                        AD7793_HAS_EXITATION_CURRENT |
+                        AD7793_FLAG_HAS_GAIN |
+                        AD7793_FLAG_HAS_BUFFER,
         },
         [ID_AD7793] = {
+                .id = AD7793_ID,
                 .channels = ad7793_channels,
                 .num_channels = ARRAY_SIZE(ad7793_channels),
+                .iio_info = &ad7793_info,
+                .sample_freq_avail = ad7793_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_CLKSEL |
+                        AD7793_FLAG_HAS_REFSEL |
+                        AD7793_FLAG_HAS_VBIAS |
+                        AD7793_HAS_EXITATION_CURRENT |
+                        AD7793_FLAG_HAS_GAIN |
+                        AD7793_FLAG_HAS_BUFFER,
         },
         [ID_AD7794] = {
+                .id = AD7794_ID,
                 .channels = ad7794_channels,
                 .num_channels = ARRAY_SIZE(ad7794_channels),
+                .iio_info = &ad7793_info,
+                .sample_freq_avail = ad7793_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_CLKSEL |
+                        AD7793_FLAG_HAS_REFSEL |
+                        AD7793_FLAG_HAS_VBIAS |
+                        AD7793_HAS_EXITATION_CURRENT |
+                        AD7793_FLAG_HAS_GAIN |
+                        AD7793_FLAG_HAS_BUFFER,
         },
         [ID_AD7795] = {
+                .id = AD7795_ID,
                 .channels = ad7795_channels,
                 .num_channels = ARRAY_SIZE(ad7795_channels),
+                .iio_info = &ad7793_info,
+                .sample_freq_avail = ad7793_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_CLKSEL |
+                        AD7793_FLAG_HAS_REFSEL |
+                        AD7793_FLAG_HAS_VBIAS |
+                        AD7793_HAS_EXITATION_CURRENT |
+                        AD7793_FLAG_HAS_GAIN |
+                        AD7793_FLAG_HAS_BUFFER,
+        },
+        [ID_AD7796] = {
+                .id = AD7796_ID,
+                .channels = ad7796_channels,
+                .num_channels = ARRAY_SIZE(ad7796_channels),
+                .iio_info = &ad7797_info,
+                .sample_freq_avail = ad7797_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_CLKSEL,
+        },
+        [ID_AD7797] = {
+                .id = AD7797_ID,
+                .channels = ad7797_channels,
+                .num_channels = ARRAY_SIZE(ad7797_channels),
+                .iio_info = &ad7797_info,
+                .sample_freq_avail = ad7797_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_CLKSEL,
+        },
+        [ID_AD7798] = {
+                .id = AD7798_ID,
+                .channels = ad7798_channels,
+                .num_channels = ARRAY_SIZE(ad7798_channels),
+                .iio_info = &ad7793_info,
+                .sample_freq_avail = ad7793_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_GAIN |
+                        AD7793_FLAG_HAS_BUFFER,
+        },
+        [ID_AD7799] = {
+                .id = AD7799_ID,
+                .channels = ad7799_channels,
+                .num_channels = ARRAY_SIZE(ad7799_channels),
+                .iio_info = &ad7793_info,
+                .sample_freq_avail = ad7793_sample_freq_avail,
+                .flags = AD7793_FLAG_HAS_GAIN |
+                        AD7793_FLAG_HAS_BUFFER,
         },
 };
 
@@ -446,7 +745,7 @@ static int ad7793_probe(struct spi_device *spi)
         const struct ad7793_platform_data *pdata = spi->dev.platform_data;
         struct ad7793_state *st;
         struct iio_dev *indio_dev;
-        int ret, voltage_uv = 0;
+        int ret, vref_mv = 0;
 
         if (!pdata) {
                 dev_err(&spi->dev, "no platform data?\n");
@@ -466,25 +765,31 @@ static int ad7793_probe(struct spi_device *spi)
 
         ad_sd_init(&st->sd, indio_dev, spi, &ad7793_sigma_delta_info);
 
-        st->reg = regulator_get(&spi->dev, "vcc");
-        if (!IS_ERR(st->reg)) {
+        if (pdata->refsel != AD7793_REFSEL_INTERNAL) {
+                st->reg = regulator_get(&spi->dev, "refin");
+                if (IS_ERR(st->reg)) {
+                        ret = PTR_ERR(st->reg);
+                        goto error_device_free;
+                }
+
                 ret = regulator_enable(st->reg);
                 if (ret)
                         goto error_put_reg;
 
-                voltage_uv = regulator_get_voltage(st->reg);
+                vref_mv = regulator_get_voltage(st->reg);
+                if (vref_mv < 0) {
+                        ret = vref_mv;
+                        goto error_disable_reg;
+                }
+
+                vref_mv /= 1000;
+        } else {
+                vref_mv = 1170; /* Build-in ref */
         }
 
         st->chip_info =
                 &ad7793_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 
-        if (pdata && pdata->vref_mv)
-                st->int_vref_mv = pdata->vref_mv;
-        else if (voltage_uv)
-                st->int_vref_mv = voltage_uv / 1000;
-        else
-                st->int_vref_mv = 1170; /* Build-in ref */
-
         spi_set_drvdata(spi, indio_dev);
 
         indio_dev->dev.parent = &spi->dev;
@@ -492,13 +797,13 @@ static int ad7793_probe(struct spi_device *spi)
         indio_dev->modes = INDIO_DIRECT_MODE;
         indio_dev->channels = st->chip_info->channels;
         indio_dev->num_channels = st->chip_info->num_channels;
-        indio_dev->info = &ad7793_info;
+        indio_dev->info = st->chip_info->iio_info;
 
         ret = ad_sd_setup_buffer_and_trigger(indio_dev);
         if (ret)
                 goto error_disable_reg;
 
-        ret = ad7793_setup(indio_dev, pdata);
+        ret = ad7793_setup(indio_dev, pdata, vref_mv);
         if (ret)
                 goto error_remove_trigger;
 
@@ -511,12 +816,12 @@ static int ad7793_probe(struct spi_device *spi)
 error_remove_trigger:
         ad_sd_cleanup_buffer_and_trigger(indio_dev);
 error_disable_reg:
-        if (!IS_ERR(st->reg))
+        if (pdata->refsel != AD7793_REFSEL_INTERNAL)
                 regulator_disable(st->reg);
 error_put_reg:
-        if (!IS_ERR(st->reg))
+        if (pdata->refsel != AD7793_REFSEL_INTERNAL)
                 regulator_put(st->reg);
-
+error_device_free:
         iio_device_free(indio_dev);
 
         return ret;
@@ -524,13 +829,14 @@ error_put_reg:
 
 static int ad7793_remove(struct spi_device *spi)
 {
+        const struct ad7793_platform_data *pdata = spi->dev.platform_data;
         struct iio_dev *indio_dev = spi_get_drvdata(spi);
         struct ad7793_state *st = iio_priv(indio_dev);
 
         iio_device_unregister(indio_dev);
         ad_sd_cleanup_buffer_and_trigger(indio_dev);
 
-        if (!IS_ERR(st->reg)) {
+        if (pdata->refsel != AD7793_REFSEL_INTERNAL) {
                 regulator_disable(st->reg);
                 regulator_put(st->reg);
         }
@@ -546,6 +852,10 @@ static const struct spi_device_id ad7793_id[] = {
         {"ad7793", ID_AD7793},
         {"ad7794", ID_AD7794},
         {"ad7795", ID_AD7795},
+        {"ad7796", ID_AD7796},
+        {"ad7797", ID_AD7797},
+        {"ad7798", ID_AD7798},
+        {"ad7799", ID_AD7799},
         {}
 };
 MODULE_DEVICE_TABLE(spi, ad7793_id);
diff --git a/drivers/iio/adc/ti-adc081c.c b/drivers/iio/adc/ti-adc081c.c
new file mode 100644
index 000000000000..f4a46dd8f43b
--- /dev/null
+++ b/drivers/iio/adc/ti-adc081c.c
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2012 Avionic Design GmbH
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+
+#include <linux/iio/iio.h>
+#include <linux/regulator/consumer.h>
+
+struct adc081c {
+        struct i2c_client *i2c;
+        struct regulator *ref;
+};
+
+#define REG_CONV_RES 0x00
+
+static int adc081c_read_raw(struct iio_dev *iio,
+                            struct iio_chan_spec const *channel, int *value,
+                            int *shift, long mask)
+{
+        struct adc081c *adc = iio_priv(iio);
+        int err;
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                err = i2c_smbus_read_word_swapped(adc->i2c, REG_CONV_RES);
+                if (err < 0)
+                        return err;
+
+                *value = (err >> 4) & 0xff;
+                return IIO_VAL_INT;
+
+        case IIO_CHAN_INFO_SCALE:
+                err = regulator_get_voltage(adc->ref);
+                if (err < 0)
+                        return err;
+
+                *value = err / 1000;
+                *shift = 8;
+
+                return IIO_VAL_FRACTIONAL_LOG2;
+
+        default:
+                break;
+        }
+
+        return -EINVAL;
+}
+
+static const struct iio_chan_spec adc081c_channel = {
+        .type = IIO_VOLTAGE,
+        .info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT |
+                     IIO_CHAN_INFO_RAW_SEPARATE_BIT,
+};
+
+static const struct iio_info adc081c_info = {
+        .read_raw = adc081c_read_raw,
+        .driver_module = THIS_MODULE,
+};
+
+static int adc081c_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct iio_dev *iio;
+        struct adc081c *adc;
+        int err;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA))
+                return -ENODEV;
+
+        iio = iio_device_alloc(sizeof(*adc));
+        if (!iio)
+                return -ENOMEM;
+
+        adc = iio_priv(iio);
+        adc->i2c = client;
+
+        adc->ref = regulator_get(&client->dev, "vref");
+        if (IS_ERR(adc->ref)) {
+                err = PTR_ERR(adc->ref);
+                goto iio_free;
+        }
+
+        err = regulator_enable(adc->ref);
+        if (err < 0)
+                goto regulator_put;
+
+        iio->dev.parent = &client->dev;
+        iio->name = dev_name(&client->dev);
+        iio->modes = INDIO_DIRECT_MODE;
+        iio->info = &adc081c_info;
+
+        iio->channels = &adc081c_channel;
+        iio->num_channels = 1;
+
+        err = iio_device_register(iio);
+        if (err < 0)
+                goto regulator_disable;
+
+        i2c_set_clientdata(client, iio);
+
+        return 0;
+
+regulator_disable:
+        regulator_disable(adc->ref);
+regulator_put:
+        regulator_put(adc->ref);
+iio_free:
+        iio_device_free(iio);
+
+        return err;
+}
+
+static int adc081c_remove(struct i2c_client *client)
+{
+        struct iio_dev *iio = i2c_get_clientdata(client);
+        struct adc081c *adc = iio_priv(iio);
+
+        iio_device_unregister(iio);
+        regulator_disable(adc->ref);
+        regulator_put(adc->ref);
+        iio_device_free(iio);
+
+        return 0;
+}
+
+static const struct i2c_device_id adc081c_id[] = {
+        { "adc081c", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, adc081c_id);
+
+#ifdef CONFIG_OF
+static const struct of_device_id adc081c_of_match[] = {
+        { .compatible = "ti,adc081c" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, adc081c_of_match);
+#endif
+
+static struct i2c_driver adc081c_driver = {
+        .driver = {
+                .name = "adc081c",
+                .owner = THIS_MODULE,
+                .of_match_table = of_match_ptr(adc081c_of_match),
+        },
+        .probe = adc081c_probe,
+        .remove = adc081c_remove,
+        .id_table = adc081c_id,
+};
+module_i2c_driver(adc081c_driver);
+
+MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
+MODULE_DESCRIPTION("Texas Instruments ADC081C021/027 driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/gyro/adis16136.c b/drivers/iio/gyro/adis16136.c
index 05486dfd721b..8cb0bcbfd609 100644
--- a/drivers/iio/gyro/adis16136.c
+++ b/drivers/iio/gyro/adis16136.c
@@ -22,7 +22,6 @@
 #include <linux/iio/buffer.h>
 #include <linux/iio/imu/adis.h>
 
-#include <linux/iio/iio.h>
 #include <linux/debugfs.h>
 
 #define ADIS16136_REG_FLASH_CNT         0x00
@@ -203,10 +202,10 @@ static ssize_t adis16136_write_frequency(struct device *dev,
 {
         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
         struct adis16136 *adis16136 = iio_priv(indio_dev);
-        long val;
+        unsigned int val;
         int ret;
 
-        ret = kstrtol(buf, 10, &val);
+        ret = kstrtouint(buf, 10, &val);
         if (ret)
                 return ret;
 
diff --git a/drivers/iio/imu/adis16480.c b/drivers/iio/imu/adis16480.c
index a080b3515015..8c26a5f7cd5d 100644
--- a/drivers/iio/imu/adis16480.c
+++ b/drivers/iio/imu/adis16480.c
@@ -24,7 +24,6 @@
 #include <linux/iio/buffer.h>
 #include <linux/iio/imu/adis.h>
 
-#include <linux/iio/iio.h>
 #include <linux/debugfs.h>
 
 #define ADIS16480_PAGE_SIZE 0x80
@@ -125,7 +124,7 @@ static ssize_t adis16480_show_firmware_revision(struct file *file,
                 char __user *userbuf, size_t count, loff_t *ppos)
 {
         struct adis16480 *adis16480 = file->private_data;
-        char buf[6];
+        char buf[7];
         size_t len;
         u16 rev;
         int ret;
@@ -134,7 +133,7 @@ static ssize_t adis16480_show_firmware_revision(struct file *file,
         if (ret < 0)
                 return ret;
 
-        len = snprintf(buf, sizeof(buf), "%x.%x\n", rev >> 8, rev & 0xff);
+        len = scnprintf(buf, sizeof(buf), "%x.%x\n", rev >> 8, rev & 0xff);
 
         return simple_read_from_buffer(userbuf, count, ppos, buf, len);
 }
diff --git a/drivers/staging/iio/adc/Kconfig b/drivers/staging/iio/adc/Kconfig
index dc8582b95b61..fb8c239b0c88 100644
--- a/drivers/staging/iio/adc/Kconfig
+++ b/drivers/staging/iio/adc/Kconfig
@@ -70,18 +70,6 @@ config AD7780
           To compile this driver as a module, choose M here: the
           module will be called ad7780.
 
-config AD7793
-        tristate "Analog Devices AD7793 and similar ADCs driver"
-        depends on SPI
-        select AD_SIGMA_DELTA
-        help
-          Say yes here to build support for Analog Devices AD7785, AD7792, AD7793,
-          AD7794 and AD7795 SPI analog to digital converters (ADC).
-          If unsure, say N (but it's safe to say "Y").
-
-          To compile this driver as a module, choose M here: the
-          module will be called AD7793.
-
 config AD7816
         tristate "Analog Devices AD7816/7/8 temperature sensor and ADC driver"
         depends on SPI
diff --git a/drivers/staging/iio/adc/Makefile b/drivers/staging/iio/adc/Makefile
index 7281451a613a..d285596272a0 100644
--- a/drivers/staging/iio/adc/Makefile
+++ b/drivers/staging/iio/adc/Makefile
@@ -14,7 +14,6 @@ obj-$(CONFIG_AD799X) += ad799x.o
 
 obj-$(CONFIG_AD7291) += ad7291.o
 obj-$(CONFIG_AD7780) += ad7780.o
-obj-$(CONFIG_AD7793) += ad7793.o
 obj-$(CONFIG_AD7816) += ad7816.o
 obj-$(CONFIG_AD7192) += ad7192.o
 obj-$(CONFIG_ADT7410) += adt7410.o
diff --git a/drivers/staging/iio/adc/ad7793.h b/drivers/staging/iio/adc/ad7793.h
deleted file mode 100644
index 8fdd450a2cd9..000000000000
--- a/drivers/staging/iio/adc/ad7793.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * AD7792/AD7793 SPI ADC driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-#ifndef IIO_ADC_AD7793_H_
-#define IIO_ADC_AD7793_H_
-
-/*
- * TODO: struct ad7793_platform_data needs to go into include/linux/iio
- */
-
-/* Registers */
-#define AD7793_REG_COMM         0 /* Communications Register (WO, 8-bit) */
-#define AD7793_REG_STAT         0 /* Status Register         (RO, 8-bit) */
-#define AD7793_REG_MODE         1 /* Mode Register           (RW, 16-bit */
-#define AD7793_REG_CONF         2 /* Configuration Register  (RW, 16-bit) */
-#define AD7793_REG_DATA         3 /* Data Register           (RO, 16-/24-bit) */
-#define AD7793_REG_ID           4 /* ID Register             (RO, 8-bit) */
-#define AD7793_REG_IO           5 /* IO Register             (RO, 8-bit) */
-#define AD7793_REG_OFFSET       6 /* Offset Register         (RW, 16-bit
-                                   * (AD7792)/24-bit (AD7793)) */
-#define AD7793_REG_FULLSALE     7 /* Full-Scale Register
-                                   * (RW, 16-bit (AD7792)/24-bit (AD7793)) */
-
-/* Communications Register Bit Designations (AD7793_REG_COMM) */
-#define AD7793_COMM_WEN         (1 << 7) /* Write Enable */
-#define AD7793_COMM_WRITE       (0 << 6) /* Write Operation */
-#define AD7793_COMM_READ        (1 << 6) /* Read Operation */
-#define AD7793_COMM_ADDR(x)     (((x) & 0x7) << 3) /* Register Address */
-#define AD7793_COMM_CREAD       (1 << 2) /* Continuous Read of Data Register */
-
-/* Status Register Bit Designations (AD7793_REG_STAT) */
-#define AD7793_STAT_RDY         (1 << 7) /* Ready */
-#define AD7793_STAT_ERR         (1 << 6) /* Error (Overrange, Underrange) */
-#define AD7793_STAT_CH3         (1 << 2) /* Channel 3 */
-#define AD7793_STAT_CH2         (1 << 1) /* Channel 2 */
-#define AD7793_STAT_CH1         (1 << 0) /* Channel 1 */
-
-/* Mode Register Bit Designations (AD7793_REG_MODE) */
-#define AD7793_MODE_SEL(x)      (((x) & 0x7) << 13) /* Operation Mode Select */
-#define AD7793_MODE_SEL_MASK    (0x7 << 13) /* Operation Mode Select mask */
-#define AD7793_MODE_CLKSRC(x)   (((x) & 0x3) << 6) /* ADC Clock Source Select */
-#define AD7793_MODE_RATE(x)     ((x) & 0xF) /* Filter Update Rate Select */
-
-#define AD7793_MODE_CONT                0 /* Continuous Conversion Mode */
-#define AD7793_MODE_SINGLE              1 /* Single Conversion Mode */
-#define AD7793_MODE_IDLE                2 /* Idle Mode */
-#define AD7793_MODE_PWRDN               3 /* Power-Down Mode */
-#define AD7793_MODE_CAL_INT_ZERO        4 /* Internal Zero-Scale Calibration */
-#define AD7793_MODE_CAL_INT_FULL        5 /* Internal Full-Scale Calibration */
-#define AD7793_MODE_CAL_SYS_ZERO        6 /* System Zero-Scale Calibration */
-#define AD7793_MODE_CAL_SYS_FULL        7 /* System Full-Scale Calibration */
-
-#define AD7793_CLK_INT          0 /* Internal 64 kHz Clock not
-                                   * available at the CLK pin */
-#define AD7793_CLK_INT_CO       1 /* Internal 64 kHz Clock available
-                                   * at the CLK pin */
-#define AD7793_CLK_EXT          2 /* External 64 kHz Clock */
-#define AD7793_CLK_EXT_DIV2     3 /* External Clock divided by 2 */
-
-/* Configuration Register Bit Designations (AD7793_REG_CONF) */
-#define AD7793_CONF_VBIAS(x)    (((x) & 0x3) << 14) /* Bias Voltage
-                                                     * Generator Enable */
-#define AD7793_CONF_BO_EN       (1 << 13) /* Burnout Current Enable */
-#define AD7793_CONF_UNIPOLAR    (1 << 12) /* Unipolar/Bipolar Enable */
-#define AD7793_CONF_BOOST       (1 << 11) /* Boost Enable */
-#define AD7793_CONF_GAIN(x)     (((x) & 0x7) << 8) /* Gain Select */
-#define AD7793_CONF_REFSEL      (1 << 7) /* INT/EXT Reference Select */
-#define AD7793_CONF_BUF         (1 << 4) /* Buffered Mode Enable */
-#define AD7793_CONF_CHAN(x)     ((x) & 0xf) /* Channel select */
-#define AD7793_CONF_CHAN_MASK   0xf /* Channel select mask */
-
-#define AD7793_CH_AIN1P_AIN1M   0 /* AIN1(+) - AIN1(-) */
-#define AD7793_CH_AIN2P_AIN2M   1 /* AIN2(+) - AIN2(-) */
-#define AD7793_CH_AIN3P_AIN3M   2 /* AIN3(+) - AIN3(-) */
-#define AD7793_CH_AIN1M_AIN1M   3 /* AIN1(-) - AIN1(-) */
-#define AD7793_CH_TEMP          6 /* Temp Sensor */
-#define AD7793_CH_AVDD_MONITOR  7 /* AVDD Monitor */
-
-#define AD7795_CH_AIN4P_AIN4M   4 /* AIN4(+) - AIN4(-) */
-#define AD7795_CH_AIN5P_AIN5M   5 /* AIN5(+) - AIN5(-) */
-#define AD7795_CH_AIN6P_AIN6M   6 /* AIN6(+) - AIN6(-) */
-#define AD7795_CH_AIN1M_AIN1M   8 /* AIN1(-) - AIN1(-) */
-
-/* ID Register Bit Designations (AD7793_REG_ID) */
-#define AD7792_ID               0xA
-#define AD7793_ID               0xB
-#define AD7795_ID               0xF
-#define AD7793_ID_MASK          0xF
-
-/* IO (Excitation Current Sources) Register Bit Designations (AD7793_REG_IO) */
-#define AD7793_IO_IEXC1_IOUT1_IEXC2_IOUT2       0 /* IEXC1 connect to IOUT1,
-                                                   * IEXC2 connect to IOUT2 */
-#define AD7793_IO_IEXC1_IOUT2_IEXC2_IOUT1       1 /* IEXC1 connect to IOUT2,
-                                                   * IEXC2 connect to IOUT1 */
-#define AD7793_IO_IEXC1_IEXC2_IOUT1             2 /* Both current sources
-                                                   * IEXC1,2 connect to IOUT1 */
-#define AD7793_IO_IEXC1_IEXC2_IOUT2             3 /* Both current sources
-                                                   * IEXC1,2 connect to IOUT2 */
-
-#define AD7793_IO_IXCEN_10uA    (1 << 0) /* Excitation Current 10uA */
-#define AD7793_IO_IXCEN_210uA   (2 << 0) /* Excitation Current 210uA */
-#define AD7793_IO_IXCEN_1mA     (3 << 0) /* Excitation Current 1mA */
-
-struct ad7793_platform_data {
-        u16                     vref_mv;
-        u16                     mode;
-        u16                     conf;
-        u8                      io;
-};
-
-#endif /* IIO_ADC_AD7793_H_ */