drivers/iio/adc/ti_am335x_adc.c

   1 /*
   2  * TI ADC MFD driver
   3  *
   4  * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation version 2.
   9  *
  10  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  11  * kind, whether express or implied; without even the implied warranty
  12  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <linux/init.h>
  17 #include <linux/kernel.h>
  18 #include <linux/err.h>
  19 #include <linux/module.h>
  20 #include <linux/slab.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/io.h>
  24 #include <linux/iio/iio.h>
  25 #include <linux/of.h>
  26 #include <linux/of_device.h>
  27 #include <linux/iio/machine.h>
  28 #include <linux/iio/driver.h>
  29
  30 #include <linux/mfd/ti_am335x_tscadc.h>
  31
  32 struct tiadc_device {
  33         struct ti_tscadc_dev *mfd_tscadc;
  34         int channels;
  35         u8 channel_line[8];
  36         u8 channel_step[8];
  37 };
  38
  39 static unsigned int tiadc_readl(struct tiadc_device *adc, unsigned int reg)
  40 {
  41         return readl(adc->mfd_tscadc->tscadc_base + reg);
  42 }
  43
  44 static void tiadc_writel(struct tiadc_device *adc, unsigned int reg,
  45                                         unsigned int val)
  46 {
  47         writel(val, adc->mfd_tscadc->tscadc_base + reg);
  48 }
  49
  50 static u32 get_adc_step_mask(struct tiadc_device *adc_dev)
  51 {
  52         u32 step_en;
  53
  54         step_en = ((1 << adc_dev->channels) - 1);
  55         step_en <<= TOTAL_STEPS - adc_dev->channels + 1;
  56         return step_en;
  57 }
  58
  59 static void tiadc_step_config(struct tiadc_device *adc_dev)
  60 {
  61         unsigned int stepconfig;
  62         int i, steps;
  63         u32 step_en;
  64
  65         /*
  66          * There are 16 configurable steps and 8 analog input
  67          * lines available which are shared between Touchscreen and ADC.
  68          *
  69          * Steps backwards i.e. from 16 towards 0 are used by ADC
  70          * depending on number of input lines needed.
  71          * Channel would represent which analog input
  72          * needs to be given to ADC to digitalize data.
  73          */
  74
  75         steps = TOTAL_STEPS - adc_dev->channels;
  76         stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1;
  77
  78         for (i = 0; i < adc_dev->channels; i++) {
  79                 int chan;
  80
  81                 chan = adc_dev->channel_line[i];
  82                 tiadc_writel(adc_dev, REG_STEPCONFIG(steps),
  83                                 stepconfig | STEPCONFIG_INP(chan));
  84                 tiadc_writel(adc_dev, REG_STEPDELAY(steps),
  85                                 STEPCONFIG_OPENDLY);
  86                 adc_dev->channel_step[i] = steps;
  87                 steps++;
  88         }
  89         step_en = get_adc_step_mask(adc_dev);
  90         am335x_tsc_se_set(adc_dev->mfd_tscadc, step_en);
  91 }
  92
  93 static const char * const chan_name_ain[] = {
  94         "AIN0",
  95         "AIN1",
  96         "AIN2",
  97         "AIN3",
  98         "AIN4",
  99         "AIN5",
 100         "AIN6",
 101         "AIN7",
 102 };
 103
 104 static int tiadc_channel_init(struct iio_dev *indio_dev, int channels)
 105 {
 106         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 107         struct iio_chan_spec *chan_array;
 108         struct iio_chan_spec *chan;
 109         int i;
 110
 111         indio_dev->num_channels = channels;
 112         chan_array = kcalloc(channels,
 113                         sizeof(struct iio_chan_spec), GFP_KERNEL);
 114         if (chan_array == NULL)
 115                 return -ENOMEM;
 116
 117         chan = chan_array;
 118         for (i = 0; i < channels; i++, chan++) {
 119
 120                 chan->type = IIO_VOLTAGE;
 121                 chan->indexed = 1;
 122                 chan->channel = adc_dev->channel_line[i];
 123                 chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
 124                 chan->datasheet_name = chan_name_ain[chan->channel];
 125                 chan->scan_type.sign = 'u';
 126                 chan->scan_type.realbits = 12;
 127                 chan->scan_type.storagebits = 32;
 128         }
 129
 130         indio_dev->channels = chan_array;
 131
 132         return 0;
 133 }
 134
 135 static void tiadc_channels_remove(struct iio_dev *indio_dev)
 136 {
 137         kfree(indio_dev->channels);
 138 }
 139
 140 static int tiadc_read_raw(struct iio_dev *indio_dev,
 141                 struct iio_chan_spec const *chan,
 142                 int *val, int *val2, long mask)
 143 {
 144         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 145         int i;
 146         unsigned int fifo1count, read;
 147         u32 step = UINT_MAX;
 148
 149         /*
 150          * When the sub-system is first enabled,
 151          * the sequencer will always start with the
 152          * lowest step (1) and continue until step (16).
 153          * For ex: If we have enabled 4 ADC channels and
 154          * currently use only 1 out of them, the
 155          * sequencer still configures all the 4 steps,
 156          * leading to 3 unwanted data.
 157          * Hence we need to flush out this data.
 158          */
 159
 160         for (i = 0; i < ARRAY_SIZE(adc_dev->channel_step); i++) {
 161                 if (chan->channel == adc_dev->channel_line[i]) {
 162                         step = adc_dev->channel_step[i];
 163                         break;
 164                 }
 165         }
 166         if (WARN_ON_ONCE(step == UINT_MAX))
 167                 return -EINVAL;
 168
 169         fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT);
 170         for (i = 0; i < fifo1count; i++) {
 171                 read = tiadc_readl(adc_dev, REG_FIFO1);
 172                 if (read >> 16 == step)
 173                         *val = read & 0xfff;
 174         }
 175         am335x_tsc_se_update(adc_dev->mfd_tscadc);
 176
 177         return IIO_VAL_INT;
 178 }
 179
 180 static const struct iio_info tiadc_info = {
 181         .read_raw = &tiadc_read_raw,
 182 };
 183
 184 static int tiadc_probe(struct platform_device *pdev)
 185 {
 186         struct iio_dev          *indio_dev;
 187         struct tiadc_device     *adc_dev;
 188         struct device_node      *node = pdev->dev.of_node;
 189         struct property         *prop;
 190         const __be32            *cur;
 191         int                     err;
 192         u32                     val;
 193         int                     channels = 0;
 194
 195         if (!node) {
 196                 dev_err(&pdev->dev, "Could not find valid DT data.\n");
 197                 return -EINVAL;
 198         }
 199
 200         indio_dev = iio_device_alloc(sizeof(struct tiadc_device));
 201         if (indio_dev == NULL) {
 202                 dev_err(&pdev->dev, "failed to allocate iio device\n");
 203                 err = -ENOMEM;
 204                 goto err_ret;
 205         }
 206         adc_dev = iio_priv(indio_dev);
 207
 208         adc_dev->mfd_tscadc = ti_tscadc_dev_get(pdev);
 209
 210         of_property_for_each_u32(node, "ti,adc-channels", prop, cur, val) {
 211                 adc_dev->channel_line[channels] = val;
 212                 channels++;
 213         }
 214         adc_dev->channels = channels;
 215
 216         indio_dev->dev.parent = &pdev->dev;
 217         indio_dev->name = dev_name(&pdev->dev);
 218         indio_dev->modes = INDIO_DIRECT_MODE;
 219         indio_dev->info = &tiadc_info;
 220
 221         tiadc_step_config(adc_dev);
 222
 223         err = tiadc_channel_init(indio_dev, adc_dev->channels);
 224         if (err < 0)
 225                 goto err_free_device;
 226
 227         err = iio_device_register(indio_dev);
 228         if (err)
 229                 goto err_free_channels;
 230
 231         platform_set_drvdata(pdev, indio_dev);
 232
 233         return 0;
 234
 235 err_free_channels:
 236         tiadc_channels_remove(indio_dev);
 237 err_free_device:
 238         iio_device_free(indio_dev);
 239 err_ret:
 240         return err;
 241 }
 242
 243 static int tiadc_remove(struct platform_device *pdev)
 244 {
 245         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 246         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 247         u32 step_en;
 248
 249         iio_device_unregister(indio_dev);
 250         tiadc_channels_remove(indio_dev);
 251
 252         step_en = get_adc_step_mask(adc_dev);
 253         am335x_tsc_se_clr(adc_dev->mfd_tscadc, step_en);
 254
 255         iio_device_free(indio_dev);
 256
 257         return 0;
 258 }
 259
 260 #ifdef CONFIG_PM
 261 static int tiadc_suspend(struct device *dev)
 262 {
 263         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 264         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 265         struct ti_tscadc_dev *tscadc_dev;
 266         unsigned int idle;
 267
 268         tscadc_dev = ti_tscadc_dev_get(to_platform_device(dev));
 269         if (!device_may_wakeup(tscadc_dev->dev)) {
 270                 idle = tiadc_readl(adc_dev, REG_CTRL);
 271                 idle &= ~(CNTRLREG_TSCSSENB);
 272                 tiadc_writel(adc_dev, REG_CTRL, (idle |
 273                                 CNTRLREG_POWERDOWN));
 274         }
 275
 276         return 0;
 277 }
 278
 279 static int tiadc_resume(struct device *dev)
 280 {
 281         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 282         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 283         unsigned int restore;
 284
 285         /* Make sure ADC is powered up */
 286         restore = tiadc_readl(adc_dev, REG_CTRL);
 287         restore &= ~(CNTRLREG_POWERDOWN);
 288         tiadc_writel(adc_dev, REG_CTRL, restore);
 289
 290         tiadc_step_config(adc_dev);
 291
 292         return 0;
 293 }
 294
 295 static const struct dev_pm_ops tiadc_pm_ops = {
 296         .suspend = tiadc_suspend,
 297         .resume = tiadc_resume,
 298 };
 299 #define TIADC_PM_OPS (&tiadc_pm_ops)
 300 #else
 301 #define TIADC_PM_OPS NULL
 302 #endif
 303
 304 static const struct of_device_id ti_adc_dt_ids[] = {
 305         { .compatible = "ti,am3359-adc", },
 306         { }
 307 };
 308 MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
 309
 310 static struct platform_driver tiadc_driver = {
 311         .driver = {
 312                 .name   = "TI-am335x-adc",
 313                 .owner  = THIS_MODULE,
 314                 .pm     = TIADC_PM_OPS,
 315                 .of_match_table = of_match_ptr(ti_adc_dt_ids),
 316         },
 317         .probe  = tiadc_probe,
 318         .remove = tiadc_remove,
 319 };
 320 module_platform_driver(tiadc_driver);
 321
 322 MODULE_DESCRIPTION("TI ADC controller driver");
 323 MODULE_AUTHOR("Rachna Patil <rachna@ti.com>");
 324 MODULE_LICENSE("GPL");