drivers/input/touchscreen/fsl-imx25-tcq.c

   1 /*
   2  * Copyright (C) 2014-2015 Pengutronix, Markus Pargmann <mpa@pengutronix.de>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it under
   5  * the terms of the GNU General Public License version 2 as published by the
   6  * Free Software Foundation.
   7  *
   8  * Based on driver from 2011:
   9  *   Juergen Beisert, Pengutronix <kernel@pengutronix.de>
  10  *
  11  * This is the driver for the imx25 TCQ (Touchscreen Conversion Queue)
  12  * connected to the imx25 ADC.
  13  */
  14
  15 #include <linux/clk.h>
  16 #include <linux/device.h>
  17 #include <linux/input.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/mfd/imx25-tsadc.h>
  20 #include <linux/module.h>
  21 #include <linux/of.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/regmap.h>
  24
  25 static const char mx25_tcq_name[] = "mx25-tcq";
  26
  27 enum mx25_tcq_mode {
  28         MX25_TS_4WIRE,
  29 };
  30
  31 struct mx25_tcq_priv {
  32         struct regmap *regs;
  33         struct regmap *core_regs;
  34         struct input_dev *idev;
  35         enum mx25_tcq_mode mode;
  36         unsigned int pen_threshold;
  37         unsigned int sample_count;
  38         unsigned int expected_samples;
  39         unsigned int pen_debounce;
  40         unsigned int settling_time;
  41         struct clk *clk;
  42         int irq;
  43         struct device *dev;
  44 };
  45
  46 static struct regmap_config mx25_tcq_regconfig = {
  47         .fast_io = true,
  48         .max_register = 0x5c,
  49         .reg_bits = 32,
  50         .val_bits = 32,
  51         .reg_stride = 4,
  52 };
  53
  54 static const struct of_device_id mx25_tcq_ids[] = {
  55         { .compatible = "fsl,imx25-tcq", },
  56         { /* Sentinel */ }
  57 };
  58 MODULE_DEVICE_TABLE(of, mx25_tcq_ids);
  59
  60 #define TSC_4WIRE_PRE_INDEX 0
  61 #define TSC_4WIRE_X_INDEX 1
  62 #define TSC_4WIRE_Y_INDEX 2
  63 #define TSC_4WIRE_POST_INDEX 3
  64 #define TSC_4WIRE_LEAVE 4
  65
  66 #define MX25_TSC_DEF_THRESHOLD 80
  67 #define TSC_MAX_SAMPLES 16
  68
  69 #define MX25_TSC_REPEAT_WAIT 14
  70
  71 enum mx25_adc_configurations {
  72         MX25_CFG_PRECHARGE = 0,
  73         MX25_CFG_TOUCH_DETECT,
  74         MX25_CFG_X_MEASUREMENT,
  75         MX25_CFG_Y_MEASUREMENT,
  76 };
  77
  78 #define MX25_PRECHARGE_VALUE (\
  79                         MX25_ADCQ_CFG_YPLL_OFF | \
  80                         MX25_ADCQ_CFG_XNUR_OFF | \
  81                         MX25_ADCQ_CFG_XPUL_HIGH | \
  82                         MX25_ADCQ_CFG_REFP_INT | \
  83                         MX25_ADCQ_CFG_IN_XP | \
  84                         MX25_ADCQ_CFG_REFN_NGND2 | \
  85                         MX25_ADCQ_CFG_IGS)
  86
  87 #define MX25_TOUCH_DETECT_VALUE (\
  88                         MX25_ADCQ_CFG_YNLR | \
  89                         MX25_ADCQ_CFG_YPLL_OFF | \
  90                         MX25_ADCQ_CFG_XNUR_OFF | \
  91                         MX25_ADCQ_CFG_XPUL_OFF | \
  92                         MX25_ADCQ_CFG_REFP_INT | \
  93                         MX25_ADCQ_CFG_IN_XP | \
  94                         MX25_ADCQ_CFG_REFN_NGND2 | \
  95                         MX25_ADCQ_CFG_PENIACK)
  96
  97 static void imx25_setup_queue_cfgs(struct mx25_tcq_priv *priv,
  98                                    unsigned int settling_cnt)
  99 {
 100         u32 precharge_cfg =
 101                         MX25_PRECHARGE_VALUE |
 102                         MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt);
 103         u32 touch_detect_cfg =
 104                         MX25_TOUCH_DETECT_VALUE |
 105                         MX25_ADCQ_CFG_NOS(1) |
 106                         MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt);
 107
 108         regmap_write(priv->core_regs, MX25_TSC_TICR, precharge_cfg);
 109
 110         /* PRECHARGE */
 111         regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_PRECHARGE),
 112                      precharge_cfg);
 113
 114         /* TOUCH_DETECT */
 115         regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_TOUCH_DETECT),
 116                      touch_detect_cfg);
 117
 118         /* X Measurement */
 119         regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_X_MEASUREMENT),
 120                      MX25_ADCQ_CFG_YPLL_OFF |
 121                      MX25_ADCQ_CFG_XNUR_LOW |
 122                      MX25_ADCQ_CFG_XPUL_HIGH |
 123                      MX25_ADCQ_CFG_REFP_XP |
 124                      MX25_ADCQ_CFG_IN_YP |
 125                      MX25_ADCQ_CFG_REFN_XN |
 126                      MX25_ADCQ_CFG_NOS(priv->sample_count) |
 127                      MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt));
 128
 129         /* Y Measurement */
 130         regmap_write(priv->regs, MX25_ADCQ_CFG(MX25_CFG_Y_MEASUREMENT),
 131                      MX25_ADCQ_CFG_YNLR |
 132                      MX25_ADCQ_CFG_YPLL_HIGH |
 133                      MX25_ADCQ_CFG_XNUR_OFF |
 134                      MX25_ADCQ_CFG_XPUL_OFF |
 135                      MX25_ADCQ_CFG_REFP_YP |
 136                      MX25_ADCQ_CFG_IN_XP |
 137                      MX25_ADCQ_CFG_REFN_YN |
 138                      MX25_ADCQ_CFG_NOS(priv->sample_count) |
 139                      MX25_ADCQ_CFG_SETTLING_TIME(settling_cnt));
 140
 141         /* Enable the touch detection right now */
 142         regmap_write(priv->core_regs, MX25_TSC_TICR, touch_detect_cfg |
 143                      MX25_ADCQ_CFG_IGS);
 144 }
 145
 146 static int imx25_setup_queue_4wire(struct mx25_tcq_priv *priv,
 147                                    unsigned settling_cnt, int *items)
 148 {
 149         imx25_setup_queue_cfgs(priv, settling_cnt);
 150
 151         /* Setup the conversion queue */
 152         regmap_write(priv->regs, MX25_ADCQ_ITEM_7_0,
 153                      MX25_ADCQ_ITEM(0, MX25_CFG_PRECHARGE) |
 154                      MX25_ADCQ_ITEM(1, MX25_CFG_TOUCH_DETECT) |
 155                      MX25_ADCQ_ITEM(2, MX25_CFG_X_MEASUREMENT) |
 156                      MX25_ADCQ_ITEM(3, MX25_CFG_Y_MEASUREMENT) |
 157                      MX25_ADCQ_ITEM(4, MX25_CFG_PRECHARGE) |
 158                      MX25_ADCQ_ITEM(5, MX25_CFG_TOUCH_DETECT));
 159
 160         /*
 161          * We measure X/Y with 'sample_count' number of samples and execute a
 162          * touch detection twice, with 1 sample each
 163          */
 164         priv->expected_samples = priv->sample_count * 2 + 2;
 165         *items = 6;
 166
 167         return 0;
 168 }
 169
 170 static void mx25_tcq_disable_touch_irq(struct mx25_tcq_priv *priv)
 171 {
 172         regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK,
 173                            MX25_ADCQ_CR_PDMSK);
 174 }
 175
 176 static void mx25_tcq_enable_touch_irq(struct mx25_tcq_priv *priv)
 177 {
 178         regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_PDMSK, 0);
 179 }
 180
 181 static void mx25_tcq_disable_fifo_irq(struct mx25_tcq_priv *priv)
 182 {
 183         regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ,
 184                            MX25_ADCQ_MR_FDRY_IRQ);
 185 }
 186
 187 static void mx25_tcq_enable_fifo_irq(struct mx25_tcq_priv *priv)
 188 {
 189         regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_FDRY_IRQ, 0);
 190 }
 191
 192 static void mx25_tcq_force_queue_start(struct mx25_tcq_priv *priv)
 193 {
 194         regmap_update_bits(priv->regs, MX25_ADCQ_CR,
 195                            MX25_ADCQ_CR_FQS,
 196                            MX25_ADCQ_CR_FQS);
 197 }
 198
 199 static void mx25_tcq_force_queue_stop(struct mx25_tcq_priv *priv)
 200 {
 201         regmap_update_bits(priv->regs, MX25_ADCQ_CR,
 202                            MX25_ADCQ_CR_FQS, 0);
 203 }
 204
 205 static void mx25_tcq_fifo_reset(struct mx25_tcq_priv *priv)
 206 {
 207         u32 tcqcr;
 208
 209         regmap_read(priv->regs, MX25_ADCQ_CR, &tcqcr);
 210         regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST,
 211                            MX25_ADCQ_CR_FRST);
 212         regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_FRST, 0);
 213         regmap_write(priv->regs, MX25_ADCQ_CR, tcqcr);
 214 }
 215
 216 static void mx25_tcq_re_enable_touch_detection(struct mx25_tcq_priv *priv)
 217 {
 218         /* stop the queue from looping */
 219         mx25_tcq_force_queue_stop(priv);
 220
 221         /* for a clean touch detection, preload the X plane */
 222         regmap_write(priv->core_regs, MX25_TSC_TICR, MX25_PRECHARGE_VALUE);
 223
 224         /* waste some time now to pre-load the X plate to high voltage */
 225         mx25_tcq_fifo_reset(priv);
 226
 227         /* re-enable the detection right now */
 228         regmap_write(priv->core_regs, MX25_TSC_TICR,
 229                      MX25_TOUCH_DETECT_VALUE | MX25_ADCQ_CFG_IGS);
 230
 231         regmap_update_bits(priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_PD,
 232                            MX25_ADCQ_SR_PD);
 233
 234         /* enable the pen down event to be a source for the interrupt */
 235         regmap_update_bits(priv->regs, MX25_ADCQ_MR, MX25_ADCQ_MR_PD_IRQ, 0);
 236
 237         /* lets fire the next IRQ if someone touches the touchscreen */
 238         mx25_tcq_enable_touch_irq(priv);
 239 }
 240
 241 static void mx25_tcq_create_event_for_4wire(struct mx25_tcq_priv *priv,
 242                                             u32 *sample_buf,
 243                                             unsigned int samples)
 244 {
 245         unsigned int x_pos = 0;
 246         unsigned int y_pos = 0;
 247         unsigned int touch_pre = 0;
 248         unsigned int touch_post = 0;
 249         unsigned int i;
 250
 251         for (i = 0; i < samples; i++) {
 252                 unsigned int index = MX25_ADCQ_FIFO_ID(sample_buf[i]);
 253                 unsigned int val = MX25_ADCQ_FIFO_DATA(sample_buf[i]);
 254
 255                 switch (index) {
 256                 case 1:
 257                         touch_pre = val;
 258                         break;
 259                 case 2:
 260                         x_pos = val;
 261                         break;
 262                 case 3:
 263                         y_pos = val;
 264                         break;
 265                 case 5:
 266                         touch_post = val;
 267                         break;
 268                 default:
 269                         dev_dbg(priv->dev, "Dropped samples because of invalid index %d\n",
 270                                 index);
 271                         return;
 272                 }
 273         }
 274
 275         if (samples != 0) {
 276                 /*
 277                  * only if both touch measures are below a threshold,
 278                  * the position is valid
 279                  */
 280                 if (touch_pre < priv->pen_threshold &&
 281                     touch_post < priv->pen_threshold) {
 282                         /* valid samples, generate a report */
 283                         x_pos /= priv->sample_count;
 284                         y_pos /= priv->sample_count;
 285                         input_report_abs(priv->idev, ABS_X, x_pos);
 286                         input_report_abs(priv->idev, ABS_Y, y_pos);
 287                         input_report_key(priv->idev, BTN_TOUCH, 1);
 288                         input_sync(priv->idev);
 289
 290                         /* get next sample */
 291                         mx25_tcq_enable_fifo_irq(priv);
 292                 } else if (touch_pre >= priv->pen_threshold &&
 293                            touch_post >= priv->pen_threshold) {
 294                         /*
 295                          * if both samples are invalid,
 296                          * generate a release report
 297                          */
 298                         input_report_key(priv->idev, BTN_TOUCH, 0);
 299                         input_sync(priv->idev);
 300                         mx25_tcq_re_enable_touch_detection(priv);
 301                 } else {
 302                         /*
 303                          * if only one of both touch measurements are
 304                          * below the threshold, still some bouncing
 305                          * happens. Take additional samples in this
 306                          * case to be sure
 307                          */
 308                         mx25_tcq_enable_fifo_irq(priv);
 309                 }
 310         }
 311 }
 312
 313 static irqreturn_t mx25_tcq_irq_thread(int irq, void *dev_id)
 314 {
 315         struct mx25_tcq_priv *priv = dev_id;
 316         u32 sample_buf[TSC_MAX_SAMPLES];
 317         unsigned int samples;
 318         u32 stats;
 319         unsigned int i;
 320
 321         /*
 322          * Check how many samples are available. We always have to read exactly
 323          * sample_count samples from the fifo, or a multiple of sample_count.
 324          * Otherwise we mixup samples into different touch events.
 325          */
 326         regmap_read(priv->regs, MX25_ADCQ_SR, &stats);
 327         samples = MX25_ADCQ_SR_FDN(stats);
 328         samples -= samples % priv->sample_count;
 329
 330         if (!samples)
 331                 return IRQ_HANDLED;
 332
 333         for (i = 0; i != samples; ++i)
 334                 regmap_read(priv->regs, MX25_ADCQ_FIFO, &sample_buf[i]);
 335
 336         mx25_tcq_create_event_for_4wire(priv, sample_buf, samples);
 337
 338         return IRQ_HANDLED;
 339 }
 340
 341 static irqreturn_t mx25_tcq_irq(int irq, void *dev_id)
 342 {
 343         struct mx25_tcq_priv *priv = dev_id;
 344         u32 stat;
 345         int ret = IRQ_HANDLED;
 346
 347         regmap_read(priv->regs, MX25_ADCQ_SR, &stat);
 348
 349         if (stat & (MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR))
 350                 mx25_tcq_re_enable_touch_detection(priv);
 351
 352         if (stat & MX25_ADCQ_SR_PD) {
 353                 mx25_tcq_disable_touch_irq(priv);
 354                 mx25_tcq_force_queue_start(priv);
 355                 mx25_tcq_enable_fifo_irq(priv);
 356         }
 357
 358         if (stat & MX25_ADCQ_SR_FDRY) {
 359                 mx25_tcq_disable_fifo_irq(priv);
 360                 ret = IRQ_WAKE_THREAD;
 361         }
 362
 363         regmap_update_bits(priv->regs, MX25_ADCQ_SR, MX25_ADCQ_SR_FRR |
 364                            MX25_ADCQ_SR_FUR | MX25_ADCQ_SR_FOR |
 365                            MX25_ADCQ_SR_PD,
 366                            MX25_ADCQ_SR_FRR | MX25_ADCQ_SR_FUR |
 367                            MX25_ADCQ_SR_FOR | MX25_ADCQ_SR_PD);
 368
 369         return ret;
 370 }
 371
 372 /* configure the state machine for a 4-wire touchscreen */
 373 static int mx25_tcq_init(struct mx25_tcq_priv *priv)
 374 {
 375         u32 tgcr;
 376         unsigned int ipg_div;
 377         unsigned int adc_period;
 378         unsigned int debounce_cnt;
 379         unsigned int settling_cnt;
 380         int itemct;
 381         int error;
 382
 383         regmap_read(priv->core_regs, MX25_TSC_TGCR, &tgcr);
 384         ipg_div = max_t(unsigned int, 4, MX25_TGCR_GET_ADCCLK(tgcr));
 385         adc_period = USEC_PER_SEC * ipg_div * 2 + 2;
 386         adc_period /= clk_get_rate(priv->clk) / 1000 + 1;
 387         debounce_cnt = DIV_ROUND_UP(priv->pen_debounce, adc_period * 8) - 1;
 388         settling_cnt = DIV_ROUND_UP(priv->settling_time, adc_period * 8) - 1;
 389
 390         /* Reset */
 391         regmap_write(priv->regs, MX25_ADCQ_CR,
 392                      MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST);
 393         regmap_update_bits(priv->regs, MX25_ADCQ_CR,
 394                            MX25_ADCQ_CR_QRST | MX25_ADCQ_CR_FRST, 0);
 395
 396         /* up to 128 * 8 ADC clocks are possible */
 397         if (debounce_cnt > 127)
 398                 debounce_cnt = 127;
 399
 400         /* up to 255 * 8 ADC clocks are possible */
 401         if (settling_cnt > 255)
 402                 settling_cnt = 255;
 403
 404         error = imx25_setup_queue_4wire(priv, settling_cnt, &itemct);
 405         if (error)
 406                 return error;
 407
 408         regmap_update_bits(priv->regs, MX25_ADCQ_CR,
 409                            MX25_ADCQ_CR_LITEMID_MASK | MX25_ADCQ_CR_WMRK_MASK,
 410                            MX25_ADCQ_CR_LITEMID(itemct - 1) |
 411                            MX25_ADCQ_CR_WMRK(priv->expected_samples - 1));
 412
 413         /* setup debounce count */
 414         regmap_update_bits(priv->core_regs, MX25_TSC_TGCR,
 415                            MX25_TGCR_PDBTIME_MASK,
 416                            MX25_TGCR_PDBTIME(debounce_cnt));
 417
 418         /* enable debounce */
 419         regmap_update_bits(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDBEN,
 420                            MX25_TGCR_PDBEN);
 421         regmap_update_bits(priv->core_regs, MX25_TSC_TGCR, MX25_TGCR_PDEN,
 422                            MX25_TGCR_PDEN);
 423
 424         /* enable the engine on demand */
 425         regmap_update_bits(priv->regs, MX25_ADCQ_CR, MX25_ADCQ_CR_QSM_MASK,
 426                            MX25_ADCQ_CR_QSM_FQS);
 427
 428         /* Enable repeat and repeat wait */
 429         regmap_update_bits(priv->regs, MX25_ADCQ_CR,
 430                            MX25_ADCQ_CR_RPT | MX25_ADCQ_CR_RWAIT_MASK,
 431                            MX25_ADCQ_CR_RPT |
 432                            MX25_ADCQ_CR_RWAIT(MX25_TSC_REPEAT_WAIT));
 433
 434         return 0;
 435 }
 436
 437 static int mx25_tcq_parse_dt(struct platform_device *pdev,
 438                              struct mx25_tcq_priv *priv)
 439 {
 440         struct device_node *np = pdev->dev.of_node;
 441         u32 wires;
 442         int error;
 443
 444         /* Setup defaults */
 445         priv->pen_threshold = 500;
 446         priv->sample_count = 3;
 447         priv->pen_debounce = 1000000;
 448         priv->settling_time = 250000;
 449
 450         error = of_property_read_u32(np, "fsl,wires", &wires);
 451         if (error) {
 452                 dev_err(&pdev->dev, "Failed to find fsl,wires properties\n");
 453                 return error;
 454         }
 455
 456         if (wires == 4) {
 457                 priv->mode = MX25_TS_4WIRE;
 458         } else {
 459                 dev_err(&pdev->dev, "%u-wire mode not supported\n", wires);
 460                 return -EINVAL;
 461         }
 462
 463         /* These are optional, we don't care about the return values */
 464         of_property_read_u32(np, "fsl,pen-threshold", &priv->pen_threshold);
 465         of_property_read_u32(np, "fsl,settling-time-ns", &priv->settling_time);
 466         of_property_read_u32(np, "fsl,pen-debounce-ns", &priv->pen_debounce);
 467
 468         return 0;
 469 }
 470
 471 static int mx25_tcq_open(struct input_dev *idev)
 472 {
 473         struct device *dev = &idev->dev;
 474         struct mx25_tcq_priv *priv = dev_get_drvdata(dev);
 475         int error;
 476
 477         error = clk_prepare_enable(priv->clk);
 478         if (error) {
 479                 dev_err(dev, "Failed to enable ipg clock\n");
 480                 return error;
 481         }
 482
 483         error = mx25_tcq_init(priv);
 484         if (error) {
 485                 dev_err(dev, "Failed to init tcq\n");
 486                 clk_disable_unprepare(priv->clk);
 487                 return error;
 488         }
 489
 490         mx25_tcq_re_enable_touch_detection(priv);
 491
 492         return 0;
 493 }
 494
 495 static void mx25_tcq_close(struct input_dev *idev)
 496 {
 497         struct mx25_tcq_priv *priv = input_get_drvdata(idev);
 498
 499         mx25_tcq_force_queue_stop(priv);
 500         mx25_tcq_disable_touch_irq(priv);
 501         mx25_tcq_disable_fifo_irq(priv);
 502         clk_disable_unprepare(priv->clk);
 503 }
 504
 505 static int mx25_tcq_probe(struct platform_device *pdev)
 506 {
 507         struct device *dev = &pdev->dev;
 508         struct input_dev *idev;
 509         struct mx25_tcq_priv *priv;
 510         struct mx25_tsadc *tsadc = dev_get_drvdata(dev->parent);
 511         struct resource *res;
 512         void __iomem *mem;
 513         int error;
 514
 515         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 516         if (!priv)
 517                 return -ENOMEM;
 518         priv->dev = dev;
 519
 520         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 521         mem = devm_ioremap_resource(dev, res);
 522         if (IS_ERR(mem))
 523                 return PTR_ERR(mem);
 524
 525         error = mx25_tcq_parse_dt(pdev, priv);
 526         if (error)
 527                 return error;
 528
 529         priv->regs = devm_regmap_init_mmio(dev, mem, &mx25_tcq_regconfig);
 530         if (IS_ERR(priv->regs)) {
 531                 dev_err(dev, "Failed to initialize regmap\n");
 532                 return PTR_ERR(priv->regs);
 533         }
 534
 535         priv->irq = platform_get_irq(pdev, 0);
 536         if (priv->irq <= 0) {
 537                 dev_err(dev, "Failed to get IRQ\n");
 538                 return priv->irq;
 539         }
 540
 541         idev = devm_input_allocate_device(dev);
 542         if (!idev) {
 543                 dev_err(dev, "Failed to allocate input device\n");
 544                 return -ENOMEM;
 545         }
 546
 547         idev->name = mx25_tcq_name;
 548         input_set_capability(idev, EV_KEY, BTN_TOUCH);
 549         input_set_abs_params(idev, ABS_X, 0, 0xfff, 0, 0);
 550         input_set_abs_params(idev, ABS_Y, 0, 0xfff, 0, 0);
 551
 552         idev->id.bustype = BUS_HOST;
 553         idev->open = mx25_tcq_open;
 554         idev->close = mx25_tcq_close;
 555
 556         priv->idev = idev;
 557         input_set_drvdata(idev, priv);
 558
 559         priv->core_regs = tsadc->regs;
 560         if (!priv->core_regs)
 561                 return -EINVAL;
 562
 563         priv->clk = tsadc->clk;
 564         if (!priv->clk)
 565                 return -EINVAL;
 566
 567         platform_set_drvdata(pdev, priv);
 568
 569         error = devm_request_threaded_irq(dev, priv->irq, mx25_tcq_irq,
 570                                           mx25_tcq_irq_thread, 0, pdev->name,
 571                                           priv);
 572         if (error) {
 573                 dev_err(dev, "Failed requesting IRQ\n");
 574                 return error;
 575         }
 576
 577         error = input_register_device(idev);
 578         if (error) {
 579                 dev_err(dev, "Failed to register input device\n");
 580                 return error;
 581         }
 582
 583         return 0;
 584 }
 585
 586 static struct platform_driver mx25_tcq_driver = {
 587         .driver         = {
 588                 .name   = "mx25-tcq",
 589                 .of_match_table = mx25_tcq_ids,
 590         },
 591         .probe          = mx25_tcq_probe,
 592 };
 593 module_platform_driver(mx25_tcq_driver);
 594
 595 MODULE_DESCRIPTION("TS input driver for Freescale mx25");
 596 MODULE_AUTHOR("Markus Pargmann <mpa@pengutronix.de>");
 597 MODULE_LICENSE("GPL v2");