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
  26 #include <linux/mfd/ti_am335x_tscadc.h>
  27 #include <linux/platform_data/ti_am335x_adc.h>
  28
  29 struct tiadc_device {
  30         struct ti_tscadc_dev *mfd_tscadc;
  31         int channels;
  32 };
  33
  34 static unsigned int tiadc_readl(struct tiadc_device *adc, unsigned int reg)
  35 {
  36         return readl(adc->mfd_tscadc->tscadc_base + reg);
  37 }
  38
  39 static void tiadc_writel(struct tiadc_device *adc, unsigned int reg,
  40                                         unsigned int val)
  41 {
  42         writel(val, adc->mfd_tscadc->tscadc_base + reg);
  43 }
  44
  45 static void tiadc_step_config(struct tiadc_device *adc_dev)
  46 {
  47         unsigned int stepconfig;
  48         int i, channels = 0, steps;
  49
  50         /*
  51          * There are 16 configurable steps and 8 analog input
  52          * lines available which are shared between Touchscreen and ADC.
  53          *
  54          * Steps backwards i.e. from 16 towards 0 are used by ADC
  55          * depending on number of input lines needed.
  56          * Channel would represent which analog input
  57          * needs to be given to ADC to digitalize data.
  58          */
  59
  60         steps = TOTAL_STEPS - adc_dev->channels;
  61         channels = TOTAL_CHANNELS - adc_dev->channels;
  62
  63         stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1;
  64
  65         for (i = (steps + 1); i <= TOTAL_STEPS; i++) {
  66                 tiadc_writel(adc_dev, REG_STEPCONFIG(i),
  67                                 stepconfig | STEPCONFIG_INP(channels));
  68                 tiadc_writel(adc_dev, REG_STEPDELAY(i),
  69                                 STEPCONFIG_OPENDLY);
  70                 channels++;
  71         }
  72         tiadc_writel(adc_dev, REG_SE, STPENB_STEPENB);
  73 }
  74
  75 static int tiadc_channel_init(struct iio_dev *indio_dev, int channels)
  76 {
  77         struct iio_chan_spec *chan_array;
  78         int i;
  79
  80         indio_dev->num_channels = channels;
  81         chan_array = kcalloc(indio_dev->num_channels,
  82                         sizeof(struct iio_chan_spec), GFP_KERNEL);
  83
  84         if (chan_array == NULL)
  85                 return -ENOMEM;
  86
  87         for (i = 0; i < (indio_dev->num_channels); i++) {
  88                 struct iio_chan_spec *chan = chan_array + i;
  89                 chan->type = IIO_VOLTAGE;
  90                 chan->indexed = 1;
  91                 chan->channel = i;
  92                 chan->info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT;
  93         }
  94
  95         indio_dev->channels = chan_array;
  96
  97         return indio_dev->num_channels;
  98 }
  99
 100 static void tiadc_channels_remove(struct iio_dev *indio_dev)
 101 {
 102         kfree(indio_dev->channels);
 103 }
 104
 105 static int tiadc_read_raw(struct iio_dev *indio_dev,
 106                 struct iio_chan_spec const *chan,
 107                 int *val, int *val2, long mask)
 108 {
 109         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 110         int i;
 111         unsigned int fifo1count, readx1;
 112
 113         /*
 114          * When the sub-system is first enabled,
 115          * the sequencer will always start with the
 116          * lowest step (1) and continue until step (16).
 117          * For ex: If we have enabled 4 ADC channels and
 118          * currently use only 1 out of them, the
 119          * sequencer still configures all the 4 steps,
 120          * leading to 3 unwanted data.
 121          * Hence we need to flush out this data.
 122          */
 123
 124         fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT);
 125         for (i = 0; i < fifo1count; i++) {
 126                 readx1 = tiadc_readl(adc_dev, REG_FIFO1);
 127                 if (i == chan->channel)
 128                         *val = readx1 & 0xfff;
 129         }
 130         tiadc_writel(adc_dev, REG_SE, STPENB_STEPENB);
 131
 132         return IIO_VAL_INT;
 133 }
 134
 135 static const struct iio_info tiadc_info = {
 136         .read_raw = &tiadc_read_raw,
 137 };
 138
 139 static int tiadc_probe(struct platform_device *pdev)
 140 {
 141         struct iio_dev          *indio_dev;
 142         struct tiadc_device     *adc_dev;
 143         struct ti_tscadc_dev    *tscadc_dev = pdev->dev.platform_data;
 144         struct mfd_tscadc_board *pdata;
 145         int                     err;
 146
 147         pdata = tscadc_dev->dev->platform_data;
 148         if (!pdata || !pdata->adc_init) {
 149                 dev_err(&pdev->dev, "Could not find platform data\n");
 150                 return -EINVAL;
 151         }
 152
 153         indio_dev = iio_device_alloc(sizeof(struct tiadc_device));
 154         if (indio_dev == NULL) {
 155                 dev_err(&pdev->dev, "failed to allocate iio device\n");
 156                 err = -ENOMEM;
 157                 goto err_ret;
 158         }
 159         adc_dev = iio_priv(indio_dev);
 160
 161         adc_dev->mfd_tscadc = tscadc_dev;
 162         adc_dev->channels = pdata->adc_init->adc_channels;
 163
 164         indio_dev->dev.parent = &pdev->dev;
 165         indio_dev->name = dev_name(&pdev->dev);
 166         indio_dev->modes = INDIO_DIRECT_MODE;
 167         indio_dev->info = &tiadc_info;
 168
 169         tiadc_step_config(adc_dev);
 170
 171         err = tiadc_channel_init(indio_dev, adc_dev->channels);
 172         if (err < 0)
 173                 goto err_free_device;
 174
 175         err = iio_device_register(indio_dev);
 176         if (err)
 177                 goto err_free_channels;
 178
 179         platform_set_drvdata(pdev, indio_dev);
 180
 181         return 0;
 182
 183 err_free_channels:
 184         tiadc_channels_remove(indio_dev);
 185 err_free_device:
 186         iio_device_free(indio_dev);
 187 err_ret:
 188         return err;
 189 }
 190
 191 static int tiadc_remove(struct platform_device *pdev)
 192 {
 193         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 194
 195         iio_device_unregister(indio_dev);
 196         tiadc_channels_remove(indio_dev);
 197
 198         iio_device_free(indio_dev);
 199
 200         return 0;
 201 }
 202
 203 #ifdef CONFIG_PM
 204 static int tiadc_suspend(struct device *dev)
 205 {
 206         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 207         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 208         struct ti_tscadc_dev *tscadc_dev = dev->platform_data;
 209         unsigned int idle;
 210
 211         if (!device_may_wakeup(tscadc_dev->dev)) {
 212                 idle = tiadc_readl(adc_dev, REG_CTRL);
 213                 idle &= ~(CNTRLREG_TSCSSENB);
 214                 tiadc_writel(adc_dev, REG_CTRL, (idle |
 215                                 CNTRLREG_POWERDOWN));
 216         }
 217
 218         return 0;
 219 }
 220
 221 static int tiadc_resume(struct device *dev)
 222 {
 223         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 224         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 225         unsigned int restore;
 226
 227         /* Make sure ADC is powered up */
 228         restore = tiadc_readl(adc_dev, REG_CTRL);
 229         restore &= ~(CNTRLREG_POWERDOWN);
 230         tiadc_writel(adc_dev, REG_CTRL, restore);
 231
 232         tiadc_step_config(adc_dev);
 233
 234         return 0;
 235 }
 236
 237 static const struct dev_pm_ops tiadc_pm_ops = {
 238         .suspend = tiadc_suspend,
 239         .resume = tiadc_resume,
 240 };
 241 #define TIADC_PM_OPS (&tiadc_pm_ops)
 242 #else
 243 #define TIADC_PM_OPS NULL
 244 #endif
 245
 246 static struct platform_driver tiadc_driver = {
 247         .driver = {
 248                 .name   = "tiadc",
 249                 .owner  = THIS_MODULE,
 250                 .pm     = TIADC_PM_OPS,
 251         },
 252         .probe  = tiadc_probe,
 253         .remove = tiadc_remove,
 254 };
 255
 256 module_platform_driver(tiadc_driver);
 257
 258 MODULE_DESCRIPTION("TI ADC controller driver");
 259 MODULE_AUTHOR("Rachna Patil <rachna@ti.com>");
 260 MODULE_LICENSE("GPL");