7 files changed, 146 insertions, 55 deletions

diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 5937030f0444..25378c5882e2 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -385,11 +385,11 @@ config ROCKCHIP_SARADC
           module will be called rockchip_saradc.
 
 config TI_ADC081C
-        tristate "Texas Instruments ADC081C021/027"
+        tristate "Texas Instruments ADC081C/ADC101C/ADC121C family"
         depends on I2C
         help
-          If you say yes here you get support for Texas Instruments ADC081C021
-          and ADC081C027 ADC chips.
+          If you say yes here you get support for Texas Instruments ADC081C,
+          ADC101C and ADC121C ADC chips.
 
           This driver can also be built as a module. If so, the module will be
           called ti-adc081c.
diff --git a/drivers/iio/adc/ad799x.c b/drivers/iio/adc/ad799x.c
index 01d71588d752..a3f5254f4e51 100644
--- a/drivers/iio/adc/ad799x.c
+++ b/drivers/iio/adc/ad799x.c
@@ -477,7 +477,7 @@ static int ad799x_read_event_value(struct iio_dev *indio_dev,
         if (ret < 0)
                 return ret;
         *val = (ret >> chan->scan_type.shift) &
-                GENMASK(chan->scan_type.realbits - 1 , 0);
+                GENMASK(chan->scan_type.realbits - 1, 0);
 
         return IIO_VAL_INT;
 }
diff --git a/drivers/iio/adc/at91_adc.c b/drivers/iio/adc/at91_adc.c
index f284cd6a93d6..52430ba171f3 100644
--- a/drivers/iio/adc/at91_adc.c
+++ b/drivers/iio/adc/at91_adc.c
@@ -797,8 +797,8 @@ static u32 calc_startup_ticks_9x5(u32 startup_time, u32 adc_clk_khz)
          * Startup Time = <lookup_table_value> / ADC Clock
          */
         const int startup_lookup[] = {
-                0  , 8  , 16 , 24 ,
-                64 , 80 , 96 , 112,
+                0,   8,   16,  24,
+                64,  80,  96,  112,
                 512, 576, 640, 704,
                 768, 832, 896, 960
                 };
@@ -924,14 +924,14 @@ static int at91_adc_probe_dt(struct at91_adc_state *st,
                         ret = -EINVAL;
                         goto error_ret;
                 }
-                trig->name = name;
+                trig->name = name;
 
                 if (of_property_read_u32(trig_node, "trigger-value", &prop)) {
                         dev_err(&idev->dev, "Missing trigger-value property in the DT.\n");
                         ret = -EINVAL;
                         goto error_ret;
                 }
-                trig->value = prop;
+                trig->value = prop;
                 trig->is_external = of_property_read_bool(trig_node, "trigger-external");
                 i++;
         }
diff --git a/drivers/iio/adc/mcp3422.c b/drivers/iio/adc/mcp3422.c
index d7b36efd2f3c..d1172dc1e8e2 100644
--- a/drivers/iio/adc/mcp3422.c
+++ b/drivers/iio/adc/mcp3422.c
@@ -61,9 +61,9 @@
 
 static const int mcp3422_scales[4][4] = {
         { 1000000, 500000, 250000, 125000 },
-        { 250000 , 125000, 62500 , 31250  },
-        { 62500  , 31250 , 15625 , 7812   },
-        { 15625  , 7812  , 3906  , 1953   } };
+        { 250000,  125000, 62500,  31250  },
+        { 62500,   31250,  15625,  7812   },
+        { 15625,   7812,   3906,   1953   } };
 
 /* Constant msleep times for data acquisitions */
 static const int mcp3422_read_times[4] = {
diff --git a/drivers/iio/adc/mxs-lradc.c b/drivers/iio/adc/mxs-lradc.c
index 33051b87aac2..ad26da1edbee 100644
--- a/drivers/iio/adc/mxs-lradc.c
+++ b/drivers/iio/adc/mxs-lradc.c
@@ -686,6 +686,17 @@ static void mxs_lradc_prepare_pressure(struct mxs_lradc *lradc)
 
 static void mxs_lradc_enable_touch_detection(struct mxs_lradc *lradc)
 {
+        /* Configure the touchscreen type */
+        if (lradc->soc == IMX28_LRADC) {
+                mxs_lradc_reg_clear(lradc, LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
+                                    LRADC_CTRL0);
+
+                if (lradc->use_touchscreen == MXS_LRADC_TOUCHSCREEN_5WIRE)
+                        mxs_lradc_reg_set(lradc,
+                                          LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
+                                          LRADC_CTRL0);
+        }
+
         mxs_lradc_setup_touch_detection(lradc);
 
         lradc->cur_plate = LRADC_TOUCH;
@@ -1127,6 +1138,7 @@ static int mxs_lradc_ts_register(struct mxs_lradc *lradc)
         __set_bit(EV_ABS, input->evbit);
         __set_bit(EV_KEY, input->evbit);
         __set_bit(BTN_TOUCH, input->keybit);
+        __set_bit(INPUT_PROP_DIRECT, input->propbit);
         input_set_abs_params(input, ABS_X, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
         input_set_abs_params(input, ABS_Y, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
         input_set_abs_params(input, ABS_PRESSURE, 0, LRADC_SINGLE_SAMPLE_MASK,
@@ -1475,18 +1487,13 @@ static const struct iio_chan_spec mx28_lradc_chan_spec[] = {
         MXS_ADC_CHAN(15, IIO_VOLTAGE, "VDD5V"),
 };
 
-static int mxs_lradc_hw_init(struct mxs_lradc *lradc)
+static void mxs_lradc_hw_init(struct mxs_lradc *lradc)
 {
         /* The ADC always uses DELAY CHANNEL 0. */
         const u32 adc_cfg =
                 (1 << (LRADC_DELAY_TRIGGER_DELAYS_OFFSET + 0)) |
                 (LRADC_DELAY_TIMER_PER << LRADC_DELAY_DELAY_OFFSET);
 
-        int ret = stmp_reset_block(lradc->base);
-
-        if (ret)
-                return ret;
-
         /* Configure DELAY CHANNEL 0 for generic ADC sampling. */
         mxs_lradc_reg_wrt(lradc, adc_cfg, LRADC_DELAY(0));
 
@@ -1495,20 +1502,8 @@ static int mxs_lradc_hw_init(struct mxs_lradc *lradc)
         mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(2));
         mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(3));
 
-        /* Configure the touchscreen type */
-        if (lradc->soc == IMX28_LRADC) {
-                mxs_lradc_reg_clear(lradc, LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
-                                    LRADC_CTRL0);
-
-        if (lradc->use_touchscreen == MXS_LRADC_TOUCHSCREEN_5WIRE)
-                mxs_lradc_reg_set(lradc, LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
-                                  LRADC_CTRL0);
-        }
-
         /* Start internal temperature sensing. */
         mxs_lradc_reg_wrt(lradc, 0, LRADC_CTRL2);
-
-        return 0;
 }
 
 static void mxs_lradc_hw_stop(struct mxs_lradc *lradc)
@@ -1708,11 +1703,13 @@ static int mxs_lradc_probe(struct platform_device *pdev)
                 }
         }
 
-        /* Configure the hardware. */
-        ret = mxs_lradc_hw_init(lradc);
+        ret = stmp_reset_block(lradc->base);
         if (ret)
                 goto err_dev;
 
+        /* Configure the hardware. */
+        mxs_lradc_hw_init(lradc);
+
         /* Register the touchscreen input device. */
         if (touch_ret == 0) {
                 ret = mxs_lradc_ts_register(lradc);
diff --git a/drivers/iio/adc/ti-adc081c.c b/drivers/iio/adc/ti-adc081c.c
index ecbc12138d58..9fd032d9f402 100644
--- a/drivers/iio/adc/ti-adc081c.c
+++ b/drivers/iio/adc/ti-adc081c.c
@@ -1,9 +1,21 @@
 /*
+ * TI ADC081C/ADC101C/ADC121C 8/10/12-bit ADC driver
+ *
  * Copyright (C) 2012 Avionic Design GmbH
+ * Copyright (C) 2016 Intel
  *
  * 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.
+ *
+ * Datasheets:
+ *      http://www.ti.com/lit/ds/symlink/adc081c021.pdf
+ *      http://www.ti.com/lit/ds/symlink/adc101c021.pdf
+ *      http://www.ti.com/lit/ds/symlink/adc121c021.pdf
+ *
+ * The devices have a very similar interface and differ mostly in the number of
+ * bits handled. For the 8-bit and 10-bit models the least-significant 4 or 2
+ * bits of value registers are reserved.
  */
 
 #include <linux/err.h>
@@ -12,11 +24,17 @@
 #include <linux/of.h>
 
 #include <linux/iio/iio.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
 #include <linux/regulator/consumer.h>
 
 struct adc081c {
         struct i2c_client *i2c;
         struct regulator *ref;
+
+        /* 8, 10 or 12 */
+        int bits;
 };
 
 #define REG_CONV_RES 0x00
@@ -34,7 +52,7 @@ static int adc081c_read_raw(struct iio_dev *iio,
                 if (err < 0)
                         return err;
 
-                *value = (err >> 4) & 0xff;
+                *value = (err & 0xFFF) >> (12 - adc->bits);
                 return IIO_VAL_INT;
 
         case IIO_CHAN_INFO_SCALE:
@@ -43,7 +61,7 @@ static int adc081c_read_raw(struct iio_dev *iio,
                         return err;
 
                 *value = err / 1000;
-                *shift = 8;
+                *shift = adc->bits;
 
                 return IIO_VAL_FRACTIONAL_LOG2;
 
@@ -54,10 +72,53 @@ static int adc081c_read_raw(struct iio_dev *iio,
         return -EINVAL;
 }
 
-static const struct iio_chan_spec adc081c_channel = {
-        .type = IIO_VOLTAGE,
-        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
-        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+#define ADCxx1C_CHAN(_bits) {                                   \
+        .type = IIO_VOLTAGE,                                    \
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
+        .scan_type = {                                          \
+                .sign = 'u',                                    \
+                .realbits = (_bits),                            \
+                .storagebits = 16,                              \
+                .shift = 12 - (_bits),                          \
+                .endianness = IIO_CPU,                          \
+        },                                                      \
+}
+
+#define DEFINE_ADCxx1C_CHANNELS(_name, _bits)                           \
+        static const struct iio_chan_spec _name ## _channels[] = {      \
+                ADCxx1C_CHAN((_bits)),                                  \
+                IIO_CHAN_SOFT_TIMESTAMP(1),                             \
+        };                                                              \
+
+#define ADC081C_NUM_CHANNELS 2
+
+struct adcxx1c_model {
+        const struct iio_chan_spec* channels;
+        int bits;
+};
+
+#define ADCxx1C_MODEL(_name, _bits)                                     \
+        {                                                               \
+                .channels = _name ## _channels,                         \
+                .bits = (_bits),                                        \
+        }
+
+DEFINE_ADCxx1C_CHANNELS(adc081c,  8);
+DEFINE_ADCxx1C_CHANNELS(adc101c, 10);
+DEFINE_ADCxx1C_CHANNELS(adc121c, 12);
+
+/* Model ids are indexes in _models array */
+enum adcxx1c_model_id {
+        ADC081C = 0,
+        ADC101C = 1,
+        ADC121C = 2,
+};
+
+static struct adcxx1c_model adcxx1c_models[] = {
+        ADCxx1C_MODEL(adc081c,  8),
+        ADCxx1C_MODEL(adc101c, 10),
+        ADCxx1C_MODEL(adc121c, 12),
 };
 
 static const struct iio_info adc081c_info = {
@@ -65,11 +126,30 @@ static const struct iio_info adc081c_info = {
         .driver_module = THIS_MODULE,
 };
 
+static irqreturn_t adc081c_trigger_handler(int irq, void *p)
+{
+        struct iio_poll_func *pf = p;
+        struct iio_dev *indio_dev = pf->indio_dev;
+        struct adc081c *data = iio_priv(indio_dev);
+        u16 buf[8]; /* 2 bytes data + 6 bytes padding + 8 bytes timestamp */
+        int ret;
+
+        ret = i2c_smbus_read_word_swapped(data->i2c, REG_CONV_RES);
+        if (ret < 0)
+                goto out;
+        buf[0] = ret;
+        iio_push_to_buffers_with_timestamp(indio_dev, buf, iio_get_time_ns());
+out:
+        iio_trigger_notify_done(indio_dev->trig);
+        return IRQ_HANDLED;
+}
+
 static int adc081c_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
         struct iio_dev *iio;
         struct adc081c *adc;
+        struct adcxx1c_model *model = &adcxx1c_models[id->driver_data];
         int err;
 
         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA))
@@ -81,6 +161,7 @@ static int adc081c_probe(struct i2c_client *client,
 
         adc = iio_priv(iio);
         adc->i2c = client;
+        adc->bits = model->bits;
 
         adc->ref = devm_regulator_get(&client->dev, "vref");
         if (IS_ERR(adc->ref))
@@ -95,18 +176,26 @@ static int adc081c_probe(struct i2c_client *client,
         iio->modes = INDIO_DIRECT_MODE;
         iio->info = &adc081c_info;
 
-        iio->channels = &adc081c_channel;
-        iio->num_channels = 1;
+        iio->channels = model->channels;
+        iio->num_channels = ADC081C_NUM_CHANNELS;
+
+        err = iio_triggered_buffer_setup(iio, NULL, adc081c_trigger_handler, NULL);
+        if (err < 0) {
+                dev_err(&client->dev, "iio triggered buffer setup failed\n");
+                goto err_regulator_disable;
+        }
 
         err = iio_device_register(iio);
         if (err < 0)
-                goto regulator_disable;
+                goto err_buffer_cleanup;
 
         i2c_set_clientdata(client, iio);
 
         return 0;
 
-regulator_disable:
+err_buffer_cleanup:
+        iio_triggered_buffer_cleanup(iio);
+err_regulator_disable:
         regulator_disable(adc->ref);
 
         return err;
@@ -118,13 +207,16 @@ static int adc081c_remove(struct i2c_client *client)
         struct adc081c *adc = iio_priv(iio);
 
         iio_device_unregister(iio);
+        iio_triggered_buffer_cleanup(iio);
         regulator_disable(adc->ref);
 
         return 0;
 }
 
 static const struct i2c_device_id adc081c_id[] = {
-        { "adc081c", 0 },
+        { "adc081c", ADC081C },
+        { "adc101c", ADC101C },
+        { "adc121c", ADC121C },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, adc081c_id);
@@ -132,6 +224,8 @@ MODULE_DEVICE_TABLE(i2c, adc081c_id);
 #ifdef CONFIG_OF
 static const struct of_device_id adc081c_of_match[] = {
         { .compatible = "ti,adc081c" },
+        { .compatible = "ti,adc101c" },
+        { .compatible = "ti,adc121c" },
         { }
 };
 MODULE_DEVICE_TABLE(of, adc081c_of_match);
@@ -149,5 +243,5 @@ static struct i2c_driver adc081c_driver = {
 module_i2c_driver(adc081c_driver);
 
 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
-MODULE_DESCRIPTION("Texas Instruments ADC081C021/027 driver");
+MODULE_DESCRIPTION("Texas Instruments ADC081C/ADC101C/ADC121C driver");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/adc/vf610_adc.c b/drivers/iio/adc/vf610_adc.c
index b10f629cc44b..653bf1379d2e 100644
--- a/drivers/iio/adc/vf610_adc.c
+++ b/drivers/iio/adc/vf610_adc.c
@@ -714,19 +714,19 @@ static int vf610_write_raw(struct iio_dev *indio_dev,
         int i;
 
         switch (mask) {
-                case IIO_CHAN_INFO_SAMP_FREQ:
-                        for (i = 0;
-                                i < ARRAY_SIZE(info->sample_freq_avail);
-                                i++)
-                                if (val == info->sample_freq_avail[i]) {
-                                        info->adc_feature.sample_rate = i;
-                                        vf610_adc_sample_set(info);
-                                        return 0;
-                                }
-                        break;
+        case IIO_CHAN_INFO_SAMP_FREQ:
+                for (i = 0;
+                        i < ARRAY_SIZE(info->sample_freq_avail);
+                        i++)
+                        if (val == info->sample_freq_avail[i]) {
+                                info->adc_feature.sample_rate = i;
+                                vf610_adc_sample_set(info);
+                                return 0;
+                        }
+                break;
 
-                default:
-                        break;
+        default:
+                break;
         }
 
         return -EINVAL;