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
  64         /*
  65          * There are 16 configurable steps and 8 analog input
  66          * lines available which are shared between Touchscreen and ADC.
  67          *
  68          * Steps backwards i.e. from 16 towards 0 are used by ADC
  69          * depending on number of input lines needed.
  70          * Channel would represent which analog input
  71          * needs to be given to ADC to digitalize data.
  72          */
  73
  74         steps = TOTAL_STEPS - adc_dev->channels;
  75         stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1;
  76
  77         for (i = 0; i < adc_dev->channels; i++) {
  78                 int chan;
  79
  80                 chan = adc_dev->channel_line[i];
  81                 tiadc_writel(adc_dev, REG_STEPCONFIG(steps),
  82                                 stepconfig | STEPCONFIG_INP(chan));
  83                 tiadc_writel(adc_dev, REG_STEPDELAY(steps),
  84                                 STEPCONFIG_OPENDLY);
  85                 adc_dev->channel_step[i] = steps;
  86                 steps++;
  87         }
  88
  89 }
  90
  91 static const char * const chan_name_ain[] = {
  92         "AIN0",
  93         "AIN1",
  94         "AIN2",
  95         "AIN3",
  96         "AIN4",
  97         "AIN5",
  98         "AIN6",
  99         "AIN7",
 100 };
 101
 102 static int tiadc_channel_init(struct iio_dev *indio_dev, int channels)
 103 {
 104         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 105         struct iio_chan_spec *chan_array;
 106         struct iio_chan_spec *chan;
 107         int i;
 108
 109         indio_dev->num_channels = channels;
 110         chan_array = kcalloc(channels,
 111                         sizeof(struct iio_chan_spec), GFP_KERNEL);
 112         if (chan_array == NULL)
 113                 return -ENOMEM;
 114
 115         chan = chan_array;
 116         for (i = 0; i < channels; i++, chan++) {
 117
 118                 chan->type = IIO_VOLTAGE;
 119                 chan->indexed = 1;
 120                 chan->channel = adc_dev->channel_line[i];
 121                 chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
 122                 chan->datasheet_name = chan_name_ain[chan->channel];
 123                 chan->scan_type.sign = 'u';
 124                 chan->scan_type.realbits = 12;
 125                 chan->scan_type.storagebits = 32;
 126         }
 127
 128         indio_dev->channels = chan_array;
 129
 130         return 0;
 131 }
 132
 133 static void tiadc_channels_remove(struct iio_dev *indio_dev)
 134 {
 135         kfree(indio_dev->channels);
 136 }
 137
 138 static int tiadc_read_raw(struct iio_dev *indio_dev,
 139                 struct iio_chan_spec const *chan,
 140                 int *val, int *val2, long mask)
 141 {
 142         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 143         int i, map_val;
 144         unsigned int fifo1count, read, stepid;
 145         u32 step = UINT_MAX;
 146         bool found = false;
 147         u32 step_en;
 148         unsigned long timeout = jiffies + usecs_to_jiffies
 149                                 (IDLE_TIMEOUT * adc_dev->channels);
 150         step_en = get_adc_step_mask(adc_dev);
 151         am335x_tsc_se_set(adc_dev->mfd_tscadc, step_en);
 152
 153         /* Wait for ADC sequencer to complete sampling */
 154         while (tiadc_readl(adc_dev, REG_ADCFSM) & SEQ_STATUS) {
 155                 if (time_after(jiffies, timeout))
 156                         return -EAGAIN;
 157                 }
 158         map_val = chan->channel + TOTAL_CHANNELS;
 159
 160         /*
 161          * When the sub-system is first enabled,
 162          * the sequencer will always start with the
 163          * lowest step (1) and continue until step (16).
 164          * For ex: If we have enabled 4 ADC channels and
 165          * currently use only 1 out of them, the
 166          * sequencer still configures all the 4 steps,
 167          * leading to 3 unwanted data.
 168          * Hence we need to flush out this data.
 169          */
 170
 171         for (i = 0; i < ARRAY_SIZE(adc_dev->channel_step); i++) {
 172                 if (chan->channel == adc_dev->channel_line[i]) {
 173                         step = adc_dev->channel_step[i];
 174                         break;
 175                 }
 176         }
 177         if (WARN_ON_ONCE(step == UINT_MAX))
 178                 return -EINVAL;
 179
 180         fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT);
 181         for (i = 0; i < fifo1count; i++) {
 182                 read = tiadc_readl(adc_dev, REG_FIFO1);
 183                 stepid = read & FIFOREAD_CHNLID_MASK;
 184                 stepid = stepid >> 0x10;
 185
 186                 if (stepid == map_val) {
 187                         read = read & FIFOREAD_DATA_MASK;
 188                         found = true;
 189                         *val = read;
 190                 }
 191         }
 192
 193         if (found == false)
 194                 return -EBUSY;
 195         return IIO_VAL_INT;
 196 }
 197
 198 static const struct iio_info tiadc_info = {
 199         .read_raw = &tiadc_read_raw,
 200         .driver_module = THIS_MODULE,
 201 };
 202
 203 static int tiadc_probe(struct platform_device *pdev)
 204 {
 205         struct iio_dev          *indio_dev;
 206         struct tiadc_device     *adc_dev;
 207         struct device_node      *node = pdev->dev.of_node;
 208         struct property         *prop;
 209         const __be32            *cur;
 210         int                     err;
 211         u32                     val;
 212         int                     channels = 0;
 213
 214         if (!node) {
 215                 dev_err(&pdev->dev, "Could not find valid DT data.\n");
 216                 return -EINVAL;
 217         }
 218
 219         indio_dev = iio_device_alloc(sizeof(struct tiadc_device));
 220         if (indio_dev == NULL) {
 221                 dev_err(&pdev->dev, "failed to allocate iio device\n");
 222                 err = -ENOMEM;
 223                 goto err_ret;
 224         }
 225         adc_dev = iio_priv(indio_dev);
 226
 227         adc_dev->mfd_tscadc = ti_tscadc_dev_get(pdev);
 228
 229         of_property_for_each_u32(node, "ti,adc-channels", prop, cur, val) {
 230                 adc_dev->channel_line[channels] = val;
 231                 channels++;
 232         }
 233         adc_dev->channels = channels;
 234
 235         indio_dev->dev.parent = &pdev->dev;
 236         indio_dev->name = dev_name(&pdev->dev);
 237         indio_dev->modes = INDIO_DIRECT_MODE;
 238         indio_dev->info = &tiadc_info;
 239
 240         tiadc_step_config(adc_dev);
 241
 242         err = tiadc_channel_init(indio_dev, adc_dev->channels);
 243         if (err < 0)
 244                 goto err_free_device;
 245
 246         err = iio_device_register(indio_dev);
 247         if (err)
 248                 goto err_free_channels;
 249
 250         platform_set_drvdata(pdev, indio_dev);
 251
 252         return 0;
 253
 254 err_free_channels:
 255         tiadc_channels_remove(indio_dev);
 256 err_free_device:
 257         iio_device_free(indio_dev);
 258 err_ret:
 259         return err;
 260 }
 261
 262 static int tiadc_remove(struct platform_device *pdev)
 263 {
 264         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 265         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 266         u32 step_en;
 267
 268         iio_device_unregister(indio_dev);
 269         tiadc_channels_remove(indio_dev);
 270
 271         step_en = get_adc_step_mask(adc_dev);
 272         am335x_tsc_se_clr(adc_dev->mfd_tscadc, step_en);
 273
 274         iio_device_free(indio_dev);
 275
 276         return 0;
 277 }
 278
 279 #ifdef CONFIG_PM
 280 static int tiadc_suspend(struct device *dev)
 281 {
 282         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 283         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 284         struct ti_tscadc_dev *tscadc_dev;
 285         unsigned int idle;
 286
 287         tscadc_dev = ti_tscadc_dev_get(to_platform_device(dev));
 288         if (!device_may_wakeup(tscadc_dev->dev)) {
 289                 idle = tiadc_readl(adc_dev, REG_CTRL);
 290                 idle &= ~(CNTRLREG_TSCSSENB);
 291                 tiadc_writel(adc_dev, REG_CTRL, (idle |
 292                                 CNTRLREG_POWERDOWN));
 293         }
 294
 295         return 0;
 296 }
 297
 298 static int tiadc_resume(struct device *dev)
 299 {
 300         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 301         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 302         unsigned int restore;
 303
 304         /* Make sure ADC is powered up */
 305         restore = tiadc_readl(adc_dev, REG_CTRL);
 306         restore &= ~(CNTRLREG_POWERDOWN);
 307         tiadc_writel(adc_dev, REG_CTRL, restore);
 308
 309         tiadc_step_config(adc_dev);
 310
 311         return 0;
 312 }
 313
 314 static const struct dev_pm_ops tiadc_pm_ops = {
 315         .suspend = tiadc_suspend,
 316         .resume = tiadc_resume,
 317 };
 318 #define TIADC_PM_OPS (&tiadc_pm_ops)
 319 #else
 320 #define TIADC_PM_OPS NULL
 321 #endif
 322
 323 static const struct of_device_id ti_adc_dt_ids[] = {
 324         { .compatible = "ti,am3359-adc", },
 325         { }
 326 };
 327 MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
 328
 329 static struct platform_driver tiadc_driver = {
 330         .driver = {
 331                 .name   = "TI-am335x-adc",
 332                 .owner  = THIS_MODULE,
 333                 .pm     = TIADC_PM_OPS,
 334                 .of_match_table = of_match_ptr(ti_adc_dt_ids),
 335         },
 336         .probe  = tiadc_probe,
 337         .remove = tiadc_remove,
 338 };
 339 module_platform_driver(tiadc_driver);
 340
 341 MODULE_DESCRIPTION("TI ADC controller driver");
 342 MODULE_AUTHOR("Rachna Patil <rachna@ti.com>");
 343 MODULE_LICENSE("GPL");