drivers/input/touchscreen/imx6ul_tsc.c

   1 /*
   2  * Freescale i.MX6UL touchscreen controller driver
   3  *
   4  * Copyright (C) 2015 Freescale Semiconductor, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/errno.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/gpio/consumer.h>
  15 #include <linux/input.h>
  16 #include <linux/slab.h>
  17 #include <linux/completion.h>
  18 #include <linux/delay.h>
  19 #include <linux/of.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/clk.h>
  23 #include <linux/io.h>
  24
  25 /* ADC configuration registers field define */
  26 #define ADC_AIEN                (0x1 << 7)
  27 #define ADC_CONV_DISABLE        0x1F
  28 #define ADC_CAL                 (0x1 << 7)
  29 #define ADC_CALF                0x2
  30 #define ADC_12BIT_MODE          (0x2 << 2)
  31 #define ADC_IPG_CLK             0x00
  32 #define ADC_CLK_DIV_8           (0x03 << 5)
  33 #define ADC_SHORT_SAMPLE_MODE   (0x0 << 4)
  34 #define ADC_HARDWARE_TRIGGER    (0x1 << 13)
  35 #define SELECT_CHANNEL_4        0x04
  36 #define SELECT_CHANNEL_1        0x01
  37 #define DISABLE_CONVERSION_INT  (0x0 << 7)
  38
  39 /* ADC registers */
  40 #define REG_ADC_HC0             0x00
  41 #define REG_ADC_HC1             0x04
  42 #define REG_ADC_HC2             0x08
  43 #define REG_ADC_HC3             0x0C
  44 #define REG_ADC_HC4             0x10
  45 #define REG_ADC_HS              0x14
  46 #define REG_ADC_R0              0x18
  47 #define REG_ADC_CFG             0x2C
  48 #define REG_ADC_GC              0x30
  49 #define REG_ADC_GS              0x34
  50
  51 #define ADC_TIMEOUT             msecs_to_jiffies(100)
  52
  53 /* TSC registers */
  54 #define REG_TSC_BASIC_SETING    0x00
  55 #define REG_TSC_PRE_CHARGE_TIME 0x10
  56 #define REG_TSC_FLOW_CONTROL    0x20
  57 #define REG_TSC_MEASURE_VALUE   0x30
  58 #define REG_TSC_INT_EN          0x40
  59 #define REG_TSC_INT_SIG_EN      0x50
  60 #define REG_TSC_INT_STATUS      0x60
  61 #define REG_TSC_DEBUG_MODE      0x70
  62 #define REG_TSC_DEBUG_MODE2     0x80
  63
  64 /* TSC configuration registers field define */
  65 #define DETECT_4_WIRE_MODE      (0x0 << 4)
  66 #define AUTO_MEASURE            0x1
  67 #define MEASURE_SIGNAL          0x1
  68 #define DETECT_SIGNAL           (0x1 << 4)
  69 #define VALID_SIGNAL            (0x1 << 8)
  70 #define MEASURE_INT_EN          0x1
  71 #define MEASURE_SIG_EN          0x1
  72 #define VALID_SIG_EN            (0x1 << 8)
  73 #define DE_GLITCH_2             (0x2 << 29)
  74 #define START_SENSE             (0x1 << 12)
  75 #define TSC_DISABLE             (0x1 << 16)
  76 #define DETECT_MODE             0x2
  77
  78 struct imx6ul_tsc {
  79         struct device *dev;
  80         struct input_dev *input;
  81         void __iomem *tsc_regs;
  82         void __iomem *adc_regs;
  83         struct clk *tsc_clk;
  84         struct clk *adc_clk;
  85         struct gpio_desc *xnur_gpio;
  86
  87         int measure_delay_time;
  88         int pre_charge_time;
  89
  90         struct completion completion;
  91 };
  92
  93 /*
  94  * TSC module need ADC to get the measure value. So
  95  * before config TSC, we should initialize ADC module.
  96  */
  97 static void imx6ul_adc_init(struct imx6ul_tsc *tsc)
  98 {
  99         int adc_hc = 0;
 100         int adc_gc;
 101         int adc_gs;
 102         int adc_cfg;
 103         int timeout;
 104
 105         reinit_completion(&tsc->completion);
 106
 107         adc_cfg = readl(tsc->adc_regs + REG_ADC_CFG);
 108         adc_cfg |= ADC_12BIT_MODE | ADC_IPG_CLK;
 109         adc_cfg |= ADC_CLK_DIV_8 | ADC_SHORT_SAMPLE_MODE;
 110         adc_cfg &= ~ADC_HARDWARE_TRIGGER;
 111         writel(adc_cfg, tsc->adc_regs + REG_ADC_CFG);
 112
 113         /* enable calibration interrupt */
 114         adc_hc |= ADC_AIEN;
 115         adc_hc |= ADC_CONV_DISABLE;
 116         writel(adc_hc, tsc->adc_regs + REG_ADC_HC0);
 117
 118         /* start ADC calibration */
 119         adc_gc = readl(tsc->adc_regs + REG_ADC_GC);
 120         adc_gc |= ADC_CAL;
 121         writel(adc_gc, tsc->adc_regs + REG_ADC_GC);
 122
 123         timeout = wait_for_completion_timeout
 124                         (&tsc->completion, ADC_TIMEOUT);
 125         if (timeout == 0)
 126                 dev_err(tsc->dev, "Timeout for adc calibration\n");
 127
 128         adc_gs = readl(tsc->adc_regs + REG_ADC_GS);
 129         if (adc_gs & ADC_CALF)
 130                 dev_err(tsc->dev, "ADC calibration failed\n");
 131
 132         /* TSC need the ADC work in hardware trigger */
 133         adc_cfg = readl(tsc->adc_regs + REG_ADC_CFG);
 134         adc_cfg |= ADC_HARDWARE_TRIGGER;
 135         writel(adc_cfg, tsc->adc_regs + REG_ADC_CFG);
 136 }
 137
 138 /*
 139  * This is a TSC workaround. Currently TSC misconnect two
 140  * ADC channels, this function remap channel configure for
 141  * hardware trigger.
 142  */
 143 static void imx6ul_tsc_channel_config(struct imx6ul_tsc *tsc)
 144 {
 145         int adc_hc0, adc_hc1, adc_hc2, adc_hc3, adc_hc4;
 146
 147         adc_hc0 = DISABLE_CONVERSION_INT;
 148         writel(adc_hc0, tsc->adc_regs + REG_ADC_HC0);
 149
 150         adc_hc1 = DISABLE_CONVERSION_INT | SELECT_CHANNEL_4;
 151         writel(adc_hc1, tsc->adc_regs + REG_ADC_HC1);
 152
 153         adc_hc2 = DISABLE_CONVERSION_INT;
 154         writel(adc_hc2, tsc->adc_regs + REG_ADC_HC2);
 155
 156         adc_hc3 = DISABLE_CONVERSION_INT | SELECT_CHANNEL_1;
 157         writel(adc_hc3, tsc->adc_regs + REG_ADC_HC3);
 158
 159         adc_hc4 = DISABLE_CONVERSION_INT;
 160         writel(adc_hc4, tsc->adc_regs + REG_ADC_HC4);
 161 }
 162
 163 /*
 164  * TSC setting, confige the pre-charge time and measure delay time.
 165  * different touch screen may need different pre-charge time and
 166  * measure delay time.
 167  */
 168 static void imx6ul_tsc_set(struct imx6ul_tsc *tsc)
 169 {
 170         int basic_setting = 0;
 171         int start;
 172
 173         basic_setting |= tsc->measure_delay_time << 8;
 174         basic_setting |= DETECT_4_WIRE_MODE | AUTO_MEASURE;
 175         writel(basic_setting, tsc->tsc_regs + REG_TSC_BASIC_SETING);
 176
 177         writel(DE_GLITCH_2, tsc->tsc_regs + REG_TSC_DEBUG_MODE2);
 178
 179         writel(tsc->pre_charge_time, tsc->tsc_regs + REG_TSC_PRE_CHARGE_TIME);
 180         writel(MEASURE_INT_EN, tsc->tsc_regs + REG_TSC_INT_EN);
 181         writel(MEASURE_SIG_EN | VALID_SIG_EN,
 182                 tsc->tsc_regs + REG_TSC_INT_SIG_EN);
 183
 184         /* start sense detection */
 185         start = readl(tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 186         start |= START_SENSE;
 187         start &= ~TSC_DISABLE;
 188         writel(start, tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 189 }
 190
 191 static void imx6ul_tsc_init(struct imx6ul_tsc *tsc)
 192 {
 193         imx6ul_adc_init(tsc);
 194         imx6ul_tsc_channel_config(tsc);
 195         imx6ul_tsc_set(tsc);
 196 }
 197
 198 static void imx6ul_tsc_disable(struct imx6ul_tsc *tsc)
 199 {
 200         int tsc_flow;
 201         int adc_cfg;
 202
 203         /* TSC controller enters to idle status */
 204         tsc_flow = readl(tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 205         tsc_flow |= TSC_DISABLE;
 206         writel(tsc_flow, tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 207
 208         /* ADC controller enters to stop mode */
 209         adc_cfg = readl(tsc->adc_regs + REG_ADC_HC0);
 210         adc_cfg |= ADC_CONV_DISABLE;
 211         writel(adc_cfg, tsc->adc_regs + REG_ADC_HC0);
 212 }
 213
 214 /* Delay some time (max 2ms), wait the pre-charge done. */
 215 static bool tsc_wait_detect_mode(struct imx6ul_tsc *tsc)
 216 {
 217         unsigned long timeout = jiffies + msecs_to_jiffies(2);
 218         int state_machine;
 219         int debug_mode2;
 220
 221         do {
 222                 if (time_after(jiffies, timeout))
 223                         return false;
 224
 225                 usleep_range(200, 400);
 226                 debug_mode2 = readl(tsc->tsc_regs + REG_TSC_DEBUG_MODE2);
 227                 state_machine = (debug_mode2 >> 20) & 0x7;
 228         } while (state_machine != DETECT_MODE);
 229
 230         usleep_range(200, 400);
 231         return true;
 232 }
 233
 234 static irqreturn_t tsc_irq_fn(int irq, void *dev_id)
 235 {
 236         struct imx6ul_tsc *tsc = dev_id;
 237         int status;
 238         int value;
 239         int x, y;
 240         int start;
 241
 242         status = readl(tsc->tsc_regs + REG_TSC_INT_STATUS);
 243
 244         /* write 1 to clear the bit measure-signal */
 245         writel(MEASURE_SIGNAL | DETECT_SIGNAL,
 246                 tsc->tsc_regs + REG_TSC_INT_STATUS);
 247
 248         /* It's a HW self-clean bit. Set this bit and start sense detection */
 249         start = readl(tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 250         start |= START_SENSE;
 251         writel(start, tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 252
 253         if (status & MEASURE_SIGNAL) {
 254                 value = readl(tsc->tsc_regs + REG_TSC_MEASURE_VALUE);
 255                 x = (value >> 16) & 0x0fff;
 256                 y = value & 0x0fff;
 257
 258                 /*
 259                  * In detect mode, we can get the xnur gpio value,
 260                  * otherwise assume contact is stiull active.
 261                  */
 262                 if (!tsc_wait_detect_mode(tsc) ||
 263                     gpiod_get_value_cansleep(tsc->xnur_gpio)) {
 264                         input_report_key(tsc->input, BTN_TOUCH, 1);
 265                         input_report_abs(tsc->input, ABS_X, x);
 266                         input_report_abs(tsc->input, ABS_Y, y);
 267                 } else {
 268                         input_report_key(tsc->input, BTN_TOUCH, 0);
 269                 }
 270
 271                 input_sync(tsc->input);
 272         }
 273
 274         return IRQ_HANDLED;
 275 }
 276
 277 static irqreturn_t adc_irq_fn(int irq, void *dev_id)
 278 {
 279         struct imx6ul_tsc *tsc = dev_id;
 280         int coco;
 281         int value;
 282
 283         coco = readl(tsc->adc_regs + REG_ADC_HS);
 284         if (coco & 0x01) {
 285                 value = readl(tsc->adc_regs + REG_ADC_R0);
 286                 complete(&tsc->completion);
 287         }
 288
 289         return IRQ_HANDLED;
 290 }
 291
 292 static int imx6ul_tsc_open(struct input_dev *input_dev)
 293 {
 294         struct imx6ul_tsc *tsc = input_get_drvdata(input_dev);
 295         int err;
 296
 297         err = clk_prepare_enable(tsc->adc_clk);
 298         if (err) {
 299                 dev_err(tsc->dev,
 300                         "Could not prepare or enable the adc clock: %d\n",
 301                         err);
 302                 return err;
 303         }
 304
 305         err = clk_prepare_enable(tsc->tsc_clk);
 306         if (err) {
 307                 dev_err(tsc->dev,
 308                         "Could not prepare or enable the tsc clock: %d\n",
 309                         err);
 310                 clk_disable_unprepare(tsc->adc_clk);
 311                 return err;
 312         }
 313
 314         imx6ul_tsc_init(tsc);
 315
 316         return 0;
 317 }
 318
 319 static void imx6ul_tsc_close(struct input_dev *input_dev)
 320 {
 321         struct imx6ul_tsc *tsc = input_get_drvdata(input_dev);
 322
 323         imx6ul_tsc_disable(tsc);
 324
 325         clk_disable_unprepare(tsc->tsc_clk);
 326         clk_disable_unprepare(tsc->adc_clk);
 327 }
 328
 329 static int imx6ul_tsc_probe(struct platform_device *pdev)
 330 {
 331         struct device_node *np = pdev->dev.of_node;
 332         struct imx6ul_tsc *tsc;
 333         struct input_dev *input_dev;
 334         struct resource *tsc_mem;
 335         struct resource *adc_mem;
 336         int err;
 337         int tsc_irq;
 338         int adc_irq;
 339
 340         tsc = devm_kzalloc(&pdev->dev, sizeof(struct imx6ul_tsc), GFP_KERNEL);
 341         if (!tsc)
 342                 return -ENOMEM;
 343
 344         input_dev = devm_input_allocate_device(&pdev->dev);
 345         if (!input_dev)
 346                 return -ENOMEM;
 347
 348         input_dev->name = "iMX6UL TouchScreen Controller";
 349         input_dev->id.bustype = BUS_HOST;
 350
 351         input_dev->open = imx6ul_tsc_open;
 352         input_dev->close = imx6ul_tsc_close;
 353
 354         input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
 355         input_set_abs_params(input_dev, ABS_X, 0, 0xFFF, 0, 0);
 356         input_set_abs_params(input_dev, ABS_Y, 0, 0xFFF, 0, 0);
 357
 358         input_set_drvdata(input_dev, tsc);
 359
 360         tsc->dev = &pdev->dev;
 361         tsc->input = input_dev;
 362         init_completion(&tsc->completion);
 363
 364         tsc->xnur_gpio = devm_gpiod_get(&pdev->dev, "xnur", GPIOD_IN);
 365         if (IS_ERR(tsc->xnur_gpio)) {
 366                 err = PTR_ERR(tsc->xnur_gpio);
 367                 dev_err(&pdev->dev,
 368                         "failed to request GPIO tsc_X- (xnur): %d\n", err);
 369                 return err;
 370         }
 371
 372         tsc_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 373         tsc->tsc_regs = devm_ioremap_resource(&pdev->dev, tsc_mem);
 374         if (IS_ERR(tsc->tsc_regs)) {
 375                 err = PTR_ERR(tsc->tsc_regs);
 376                 dev_err(&pdev->dev, "failed to remap tsc memory: %d\n", err);
 377                 return err;
 378         }
 379
 380         adc_mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 381         tsc->adc_regs = devm_ioremap_resource(&pdev->dev, adc_mem);
 382         if (IS_ERR(tsc->adc_regs)) {
 383                 err = PTR_ERR(tsc->adc_regs);
 384                 dev_err(&pdev->dev, "failed to remap adc memory: %d\n", err);
 385                 return err;
 386         }
 387
 388         tsc->tsc_clk = devm_clk_get(&pdev->dev, "tsc");
 389         if (IS_ERR(tsc->tsc_clk)) {
 390                 err = PTR_ERR(tsc->tsc_clk);
 391                 dev_err(&pdev->dev, "failed getting tsc clock: %d\n", err);
 392                 return err;
 393         }
 394
 395         tsc->adc_clk = devm_clk_get(&pdev->dev, "adc");
 396         if (IS_ERR(tsc->adc_clk)) {
 397                 err = PTR_ERR(tsc->adc_clk);
 398                 dev_err(&pdev->dev, "failed getting adc clock: %d\n", err);
 399                 return err;
 400         }
 401
 402         tsc_irq = platform_get_irq(pdev, 0);
 403         if (tsc_irq < 0) {
 404                 dev_err(&pdev->dev, "no tsc irq resource?\n");
 405                 return tsc_irq;
 406         }
 407
 408         adc_irq = platform_get_irq(pdev, 1);
 409         if (adc_irq <= 0) {
 410                 dev_err(&pdev->dev, "no adc irq resource?\n");
 411                 return adc_irq;
 412         }
 413
 414         err = devm_request_threaded_irq(tsc->dev, tsc_irq,
 415                                         NULL, tsc_irq_fn, IRQF_ONESHOT,
 416                                         dev_name(&pdev->dev), tsc);
 417         if (err) {
 418                 dev_err(&pdev->dev,
 419                         "failed requesting tsc irq %d: %d\n",
 420                         tsc_irq, err);
 421                 return err;
 422         }
 423
 424         err = devm_request_irq(tsc->dev, adc_irq, adc_irq_fn, 0,
 425                                 dev_name(&pdev->dev), tsc);
 426         if (err) {
 427                 dev_err(&pdev->dev,
 428                         "failed requesting adc irq %d: %d\n",
 429                         adc_irq, err);
 430                 return err;
 431         }
 432
 433         err = of_property_read_u32(np, "measure-delay-time",
 434                                    &tsc->measure_delay_time);
 435         if (err)
 436                 tsc->measure_delay_time = 0xffff;
 437
 438         err = of_property_read_u32(np, "pre-charge-time",
 439                                    &tsc->pre_charge_time);
 440         if (err)
 441                 tsc->pre_charge_time = 0xfff;
 442
 443         err = input_register_device(tsc->input);
 444         if (err) {
 445                 dev_err(&pdev->dev,
 446                         "failed to register input device: %d\n", err);
 447                 return err;
 448         }
 449
 450         platform_set_drvdata(pdev, tsc);
 451         return 0;
 452 }
 453
 454 static int __maybe_unused imx6ul_tsc_suspend(struct device *dev)
 455 {
 456         struct platform_device *pdev = to_platform_device(dev);
 457         struct imx6ul_tsc *tsc = platform_get_drvdata(pdev);
 458         struct input_dev *input_dev = tsc->input;
 459
 460         mutex_lock(&input_dev->mutex);
 461
 462         if (input_dev->users) {
 463                 imx6ul_tsc_disable(tsc);
 464
 465                 clk_disable_unprepare(tsc->tsc_clk);
 466                 clk_disable_unprepare(tsc->adc_clk);
 467         }
 468
 469         mutex_unlock(&input_dev->mutex);
 470
 471         return 0;
 472 }
 473
 474 static int __maybe_unused imx6ul_tsc_resume(struct device *dev)
 475 {
 476         struct platform_device *pdev = to_platform_device(dev);
 477         struct imx6ul_tsc *tsc = platform_get_drvdata(pdev);
 478         struct input_dev *input_dev = tsc->input;
 479         int retval = 0;
 480
 481         mutex_lock(&input_dev->mutex);
 482
 483         if (input_dev->users) {
 484                 retval = clk_prepare_enable(tsc->adc_clk);
 485                 if (retval)
 486                         goto out;
 487
 488                 retval = clk_prepare_enable(tsc->tsc_clk);
 489                 if (retval) {
 490                         clk_disable_unprepare(tsc->adc_clk);
 491                         goto out;
 492                 }
 493
 494                 imx6ul_tsc_init(tsc);
 495         }
 496
 497 out:
 498         mutex_unlock(&input_dev->mutex);
 499         return retval;
 500 }
 501
 502 static SIMPLE_DEV_PM_OPS(imx6ul_tsc_pm_ops,
 503                          imx6ul_tsc_suspend, imx6ul_tsc_resume);
 504
 505 static const struct of_device_id imx6ul_tsc_match[] = {
 506         { .compatible = "fsl,imx6ul-tsc", },
 507         { /* sentinel */ }
 508 };
 509 MODULE_DEVICE_TABLE(of, imx6ul_tsc_match);
 510
 511 static struct platform_driver imx6ul_tsc_driver = {
 512         .driver         = {
 513                 .name   = "imx6ul-tsc",
 514                 .of_match_table = imx6ul_tsc_match,
 515                 .pm     = &imx6ul_tsc_pm_ops,
 516         },
 517         .probe          = imx6ul_tsc_probe,
 518 };
 519 module_platform_driver(imx6ul_tsc_driver);
 520
 521 MODULE_AUTHOR("Haibo Chen <haibo.chen@freescale.com>");
 522 MODULE_DESCRIPTION("Freescale i.MX6UL Touchscreen controller driver");
 523 MODULE_LICENSE("GPL v2");