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 #include <linux/iio/buffer.h>
  32 #include <linux/iio/kfifo_buf.h>
  33
  34 struct tiadc_device {
  35         struct ti_tscadc_dev *mfd_tscadc;
  36         int channels;
  37         u8 channel_line[8];
  38         u8 channel_step[8];
  39         int buffer_en_ch_steps;
  40         u16 data[8];
  41 };
  42
  43 static unsigned int tiadc_readl(struct tiadc_device *adc, unsigned int reg)
  44 {
  45         return readl(adc->mfd_tscadc->tscadc_base + reg);
  46 }
  47
  48 static void tiadc_writel(struct tiadc_device *adc, unsigned int reg,
  49                                         unsigned int val)
  50 {
  51         writel(val, adc->mfd_tscadc->tscadc_base + reg);
  52 }
  53
  54 static u32 get_adc_step_mask(struct tiadc_device *adc_dev)
  55 {
  56         u32 step_en;
  57
  58         step_en = ((1 << adc_dev->channels) - 1);
  59         step_en <<= TOTAL_STEPS - adc_dev->channels + 1;
  60         return step_en;
  61 }
  62
  63 static u32 get_adc_step_bit(struct tiadc_device *adc_dev, int chan)
  64 {
  65         return 1 << adc_dev->channel_step[chan];
  66 }
  67
  68 static void tiadc_step_config(struct iio_dev *indio_dev)
  69 {
  70         struct tiadc_device *adc_dev = iio_priv(indio_dev);
  71         unsigned int stepconfig;
  72         int i, steps;
  73
  74         /*
  75          * There are 16 configurable steps and 8 analog input
  76          * lines available which are shared between Touchscreen and ADC.
  77          *
  78          * Steps backwards i.e. from 16 towards 0 are used by ADC
  79          * depending on number of input lines needed.
  80          * Channel would represent which analog input
  81          * needs to be given to ADC to digitalize data.
  82          */
  83
  84         steps = TOTAL_STEPS - adc_dev->channels;
  85         if (iio_buffer_enabled(indio_dev))
  86                 stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1
  87                                         | STEPCONFIG_MODE_SWCNT;
  88         else
  89                 stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1;
  90
  91         for (i = 0; i < adc_dev->channels; i++) {
  92                 int chan;
  93
  94                 chan = adc_dev->channel_line[i];
  95                 tiadc_writel(adc_dev, REG_STEPCONFIG(steps),
  96                                 stepconfig | STEPCONFIG_INP(chan));
  97                 tiadc_writel(adc_dev, REG_STEPDELAY(steps),
  98                                 STEPCONFIG_OPENDLY);
  99                 adc_dev->channel_step[i] = steps;
 100                 steps++;
 101         }
 102 }
 103
 104 static irqreturn_t tiadc_irq_h(int irq, void *private)
 105 {
 106         struct iio_dev *indio_dev = private;
 107         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 108         unsigned int status, config;
 109         status = tiadc_readl(adc_dev, REG_IRQSTATUS);
 110
 111         /*
 112          * ADC and touchscreen share the IRQ line.
 113          * FIFO0 interrupts are used by TSC. Handle FIFO1 IRQs here only
 114          */
 115         if (status & IRQENB_FIFO1OVRRUN) {
 116                 /* FIFO Overrun. Clear flag. Disable/Enable ADC to recover */
 117                 config = tiadc_readl(adc_dev, REG_CTRL);
 118                 config &= ~(CNTRLREG_TSCSSENB);
 119                 tiadc_writel(adc_dev, REG_CTRL, config);
 120                 tiadc_writel(adc_dev, REG_IRQSTATUS, IRQENB_FIFO1OVRRUN
 121                                 | IRQENB_FIFO1UNDRFLW | IRQENB_FIFO1THRES);
 122                 tiadc_writel(adc_dev, REG_CTRL, (config | CNTRLREG_TSCSSENB));
 123                 return IRQ_HANDLED;
 124         } else if (status & IRQENB_FIFO1THRES) {
 125                 /* Disable irq and wake worker thread */
 126                 tiadc_writel(adc_dev, REG_IRQCLR, IRQENB_FIFO1THRES);
 127                 return IRQ_WAKE_THREAD;
 128         }
 129
 130         return IRQ_NONE;
 131 }
 132
 133 static irqreturn_t tiadc_worker_h(int irq, void *private)
 134 {
 135         struct iio_dev *indio_dev = private;
 136         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 137         int i, k, fifo1count, read;
 138         u16 *data = adc_dev->data;
 139
 140         fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT);
 141         for (k = 0; k < fifo1count; k = k + i) {
 142                 for (i = 0; i < (indio_dev->scan_bytes)/2; i++) {
 143                         read = tiadc_readl(adc_dev, REG_FIFO1);
 144                         data[i] = read & FIFOREAD_DATA_MASK;
 145                 }
 146                 iio_push_to_buffers(indio_dev, (u8 *) data);
 147         }
 148
 149         tiadc_writel(adc_dev, REG_IRQSTATUS, IRQENB_FIFO1THRES);
 150         tiadc_writel(adc_dev, REG_IRQENABLE, IRQENB_FIFO1THRES);
 151
 152         return IRQ_HANDLED;
 153 }
 154
 155 static int tiadc_buffer_preenable(struct iio_dev *indio_dev)
 156 {
 157         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 158         int i, fifo1count, read;
 159
 160         tiadc_writel(adc_dev, REG_IRQCLR, (IRQENB_FIFO1THRES |
 161                                 IRQENB_FIFO1OVRRUN |
 162                                 IRQENB_FIFO1UNDRFLW));
 163
 164         /* Flush FIFO. Needed in corner cases in simultaneous tsc/adc use */
 165         fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT);
 166         for (i = 0; i < fifo1count; i++)
 167                 read = tiadc_readl(adc_dev, REG_FIFO1);
 168
 169         return 0;
 170 }
 171
 172 static int tiadc_buffer_postenable(struct iio_dev *indio_dev)
 173 {
 174         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 175         struct iio_buffer *buffer = indio_dev->buffer;
 176         unsigned int enb = 0;
 177         u8 bit;
 178
 179         tiadc_step_config(indio_dev);
 180         for_each_set_bit(bit, buffer->scan_mask, adc_dev->channels)
 181                 enb |= (get_adc_step_bit(adc_dev, bit) << 1);
 182         adc_dev->buffer_en_ch_steps = enb;
 183
 184         am335x_tsc_se_set(adc_dev->mfd_tscadc, enb);
 185
 186         tiadc_writel(adc_dev,  REG_IRQSTATUS, IRQENB_FIFO1THRES
 187                                 | IRQENB_FIFO1OVRRUN | IRQENB_FIFO1UNDRFLW);
 188         tiadc_writel(adc_dev,  REG_IRQENABLE, IRQENB_FIFO1THRES
 189                                 | IRQENB_FIFO1OVRRUN);
 190
 191         return 0;
 192 }
 193
 194 static int tiadc_buffer_predisable(struct iio_dev *indio_dev)
 195 {
 196         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 197         int fifo1count, i, read;
 198
 199         tiadc_writel(adc_dev, REG_IRQCLR, (IRQENB_FIFO1THRES |
 200                                 IRQENB_FIFO1OVRRUN | IRQENB_FIFO1UNDRFLW));
 201         am335x_tsc_se_clr(adc_dev->mfd_tscadc, adc_dev->buffer_en_ch_steps);
 202
 203         /* Flush FIFO of leftover data in the time it takes to disable adc */
 204         fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT);
 205         for (i = 0; i < fifo1count; i++)
 206                 read = tiadc_readl(adc_dev, REG_FIFO1);
 207
 208         return 0;
 209 }
 210
 211 static int tiadc_buffer_postdisable(struct iio_dev *indio_dev)
 212 {
 213         tiadc_step_config(indio_dev);
 214
 215         return 0;
 216 }
 217
 218 static const struct iio_buffer_setup_ops tiadc_buffer_setup_ops = {
 219         .preenable = &tiadc_buffer_preenable,
 220         .postenable = &tiadc_buffer_postenable,
 221         .predisable = &tiadc_buffer_predisable,
 222         .postdisable = &tiadc_buffer_postdisable,
 223 };
 224
 225 static int tiadc_iio_buffered_hardware_setup(struct iio_dev *indio_dev,
 226         irqreturn_t (*pollfunc_bh)(int irq, void *p),
 227         irqreturn_t (*pollfunc_th)(int irq, void *p),
 228         int irq,
 229         unsigned long flags,
 230         const struct iio_buffer_setup_ops *setup_ops)
 231 {
 232         struct iio_buffer *buffer;
 233         int ret;
 234
 235         buffer = iio_kfifo_allocate(indio_dev);
 236         if (!buffer)
 237                 return -ENOMEM;
 238
 239         iio_device_attach_buffer(indio_dev, buffer);
 240
 241         ret = request_threaded_irq(irq, pollfunc_th, pollfunc_bh,
 242                                 flags, indio_dev->name, indio_dev);
 243         if (ret)
 244                 goto error_kfifo_free;
 245
 246         indio_dev->setup_ops = setup_ops;
 247         indio_dev->modes |= INDIO_BUFFER_HARDWARE;
 248
 249         ret = iio_buffer_register(indio_dev,
 250                                   indio_dev->channels,
 251                                   indio_dev->num_channels);
 252         if (ret)
 253                 goto error_free_irq;
 254
 255         return 0;
 256
 257 error_free_irq:
 258         free_irq(irq, indio_dev);
 259 error_kfifo_free:
 260         iio_kfifo_free(indio_dev->buffer);
 261         return ret;
 262 }
 263
 264 static void tiadc_iio_buffered_hardware_remove(struct iio_dev *indio_dev)
 265 {
 266         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 267
 268         free_irq(adc_dev->mfd_tscadc->irq, indio_dev);
 269         iio_kfifo_free(indio_dev->buffer);
 270         iio_buffer_unregister(indio_dev);
 271 }
 272
 273
 274 static const char * const chan_name_ain[] = {
 275         "AIN0",
 276         "AIN1",
 277         "AIN2",
 278         "AIN3",
 279         "AIN4",
 280         "AIN5",
 281         "AIN6",
 282         "AIN7",
 283 };
 284
 285 static int tiadc_channel_init(struct iio_dev *indio_dev, int channels)
 286 {
 287         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 288         struct iio_chan_spec *chan_array;
 289         struct iio_chan_spec *chan;
 290         int i;
 291
 292         indio_dev->num_channels = channels;
 293         chan_array = kcalloc(channels,
 294                         sizeof(struct iio_chan_spec), GFP_KERNEL);
 295         if (chan_array == NULL)
 296                 return -ENOMEM;
 297
 298         chan = chan_array;
 299         for (i = 0; i < channels; i++, chan++) {
 300
 301                 chan->type = IIO_VOLTAGE;
 302                 chan->indexed = 1;
 303                 chan->channel = adc_dev->channel_line[i];
 304                 chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
 305                 chan->datasheet_name = chan_name_ain[chan->channel];
 306                 chan->scan_index = i;
 307                 chan->scan_type.sign = 'u';
 308                 chan->scan_type.realbits = 12;
 309                 chan->scan_type.storagebits = 16;
 310         }
 311
 312         indio_dev->channels = chan_array;
 313
 314         return 0;
 315 }
 316
 317 static void tiadc_channels_remove(struct iio_dev *indio_dev)
 318 {
 319         kfree(indio_dev->channels);
 320 }
 321
 322 static int tiadc_read_raw(struct iio_dev *indio_dev,
 323                 struct iio_chan_spec const *chan,
 324                 int *val, int *val2, long mask)
 325 {
 326         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 327         int i, map_val;
 328         unsigned int fifo1count, read, stepid;
 329         bool found = false;
 330         u32 step_en;
 331         unsigned long timeout = jiffies + usecs_to_jiffies
 332                                 (IDLE_TIMEOUT * adc_dev->channels);
 333
 334         if (iio_buffer_enabled(indio_dev))
 335                 return -EBUSY;
 336
 337         step_en = get_adc_step_mask(adc_dev);
 338         am335x_tsc_se_set(adc_dev->mfd_tscadc, step_en);
 339
 340         /* Wait for ADC sequencer to complete sampling */
 341         while (tiadc_readl(adc_dev, REG_ADCFSM) & SEQ_STATUS) {
 342                 if (time_after(jiffies, timeout))
 343                         return -EAGAIN;
 344                 }
 345         map_val = chan->channel + TOTAL_CHANNELS;
 346
 347         /*
 348          * When the sub-system is first enabled,
 349          * the sequencer will always start with the
 350          * lowest step (1) and continue until step (16).
 351          * For ex: If we have enabled 4 ADC channels and
 352          * currently use only 1 out of them, the
 353          * sequencer still configures all the 4 steps,
 354          * leading to 3 unwanted data.
 355          * Hence we need to flush out this data.
 356          */
 357
 358         fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT);
 359         for (i = 0; i < fifo1count; i++) {
 360                 read = tiadc_readl(adc_dev, REG_FIFO1);
 361                 stepid = read & FIFOREAD_CHNLID_MASK;
 362                 stepid = stepid >> 0x10;
 363
 364                 if (stepid == map_val) {
 365                         read = read & FIFOREAD_DATA_MASK;
 366                         found = true;
 367                         *val = (u16) read;
 368                 }
 369         }
 370
 371         if (found == false)
 372                 return -EBUSY;
 373         return IIO_VAL_INT;
 374 }
 375
 376 static const struct iio_info tiadc_info = {
 377         .read_raw = &tiadc_read_raw,
 378         .driver_module = THIS_MODULE,
 379 };
 380
 381 static int tiadc_probe(struct platform_device *pdev)
 382 {
 383         struct iio_dev          *indio_dev;
 384         struct tiadc_device     *adc_dev;
 385         struct device_node      *node = pdev->dev.of_node;
 386         struct property         *prop;
 387         const __be32            *cur;
 388         int                     err;
 389         u32                     val;
 390         int                     channels = 0;
 391
 392         if (!node) {
 393                 dev_err(&pdev->dev, "Could not find valid DT data.\n");
 394                 return -EINVAL;
 395         }
 396
 397         indio_dev = devm_iio_device_alloc(&pdev->dev,
 398                                           sizeof(struct tiadc_device));
 399         if (indio_dev == NULL) {
 400                 dev_err(&pdev->dev, "failed to allocate iio device\n");
 401                 return -ENOMEM;
 402         }
 403         adc_dev = iio_priv(indio_dev);
 404
 405         adc_dev->mfd_tscadc = ti_tscadc_dev_get(pdev);
 406
 407         of_property_for_each_u32(node, "ti,adc-channels", prop, cur, val) {
 408                 adc_dev->channel_line[channels] = val;
 409                 channels++;
 410         }
 411         adc_dev->channels = channels;
 412
 413         indio_dev->dev.parent = &pdev->dev;
 414         indio_dev->name = dev_name(&pdev->dev);
 415         indio_dev->modes = INDIO_DIRECT_MODE;
 416         indio_dev->info = &tiadc_info;
 417
 418         tiadc_step_config(indio_dev);
 419         tiadc_writel(adc_dev, REG_FIFO1THR, FIFO1_THRESHOLD);
 420
 421         err = tiadc_channel_init(indio_dev, adc_dev->channels);
 422         if (err < 0)
 423                 return err;
 424
 425         err = tiadc_iio_buffered_hardware_setup(indio_dev,
 426                 &tiadc_worker_h,
 427                 &tiadc_irq_h,
 428                 adc_dev->mfd_tscadc->irq,
 429                 IRQF_SHARED,
 430                 &tiadc_buffer_setup_ops);
 431
 432         if (err)
 433                 goto err_free_channels;
 434
 435         err = iio_device_register(indio_dev);
 436         if (err)
 437                 goto err_buffer_unregister;
 438
 439         platform_set_drvdata(pdev, indio_dev);
 440
 441         return 0;
 442
 443 err_buffer_unregister:
 444         tiadc_iio_buffered_hardware_remove(indio_dev);
 445 err_free_channels:
 446         tiadc_channels_remove(indio_dev);
 447         return err;
 448 }
 449
 450 static int tiadc_remove(struct platform_device *pdev)
 451 {
 452         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 453         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 454         u32 step_en;
 455
 456         iio_device_unregister(indio_dev);
 457         tiadc_iio_buffered_hardware_remove(indio_dev);
 458         tiadc_channels_remove(indio_dev);
 459
 460         step_en = get_adc_step_mask(adc_dev);
 461         am335x_tsc_se_clr(adc_dev->mfd_tscadc, step_en);
 462
 463         return 0;
 464 }
 465
 466 #ifdef CONFIG_PM
 467 static int tiadc_suspend(struct device *dev)
 468 {
 469         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 470         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 471         struct ti_tscadc_dev *tscadc_dev;
 472         unsigned int idle;
 473
 474         tscadc_dev = ti_tscadc_dev_get(to_platform_device(dev));
 475         if (!device_may_wakeup(tscadc_dev->dev)) {
 476                 idle = tiadc_readl(adc_dev, REG_CTRL);
 477                 idle &= ~(CNTRLREG_TSCSSENB);
 478                 tiadc_writel(adc_dev, REG_CTRL, (idle |
 479                                 CNTRLREG_POWERDOWN));
 480         }
 481
 482         return 0;
 483 }
 484
 485 static int tiadc_resume(struct device *dev)
 486 {
 487         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 488         struct tiadc_device *adc_dev = iio_priv(indio_dev);
 489         unsigned int restore;
 490
 491         /* Make sure ADC is powered up */
 492         restore = tiadc_readl(adc_dev, REG_CTRL);
 493         restore &= ~(CNTRLREG_POWERDOWN);
 494         tiadc_writel(adc_dev, REG_CTRL, restore);
 495
 496         tiadc_step_config(indio_dev);
 497
 498         return 0;
 499 }
 500
 501 static const struct dev_pm_ops tiadc_pm_ops = {
 502         .suspend = tiadc_suspend,
 503         .resume = tiadc_resume,
 504 };
 505 #define TIADC_PM_OPS (&tiadc_pm_ops)
 506 #else
 507 #define TIADC_PM_OPS NULL
 508 #endif
 509
 510 static const struct of_device_id ti_adc_dt_ids[] = {
 511         { .compatible = "ti,am3359-adc", },
 512         { }
 513 };
 514 MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
 515
 516 static struct platform_driver tiadc_driver = {
 517         .driver = {
 518                 .name   = "TI-am335x-adc",
 519                 .owner  = THIS_MODULE,
 520                 .pm     = TIADC_PM_OPS,
 521                 .of_match_table = ti_adc_dt_ids,
 522         },
 523         .probe  = tiadc_probe,
 524         .remove = tiadc_remove,
 525 };
 526 module_platform_driver(tiadc_driver);
 527
 528 MODULE_DESCRIPTION("TI ADC controller driver");
 529 MODULE_AUTHOR("Rachna Patil <rachna@ti.com>");
 530 MODULE_LICENSE("GPL");