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 int 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                 return -ETIMEDOUT;
 128         }
 129
 130         adc_gs = readl(tsc->adc_regs + REG_ADC_GS);
 131         if (adc_gs & ADC_CALF) {
 132                 dev_err(tsc->dev, "ADC calibration failed\n");
 133                 return -EINVAL;
 134         }
 135
 136         /* TSC need the ADC work in hardware trigger */
 137         adc_cfg = readl(tsc->adc_regs + REG_ADC_CFG);
 138         adc_cfg |= ADC_HARDWARE_TRIGGER;
 139         writel(adc_cfg, tsc->adc_regs + REG_ADC_CFG);
 140
 141         return 0;
 142 }
 143
 144 /*
 145  * This is a TSC workaround. Currently TSC misconnect two
 146  * ADC channels, this function remap channel configure for
 147  * hardware trigger.
 148  */
 149 static void imx6ul_tsc_channel_config(struct imx6ul_tsc *tsc)
 150 {
 151         int adc_hc0, adc_hc1, adc_hc2, adc_hc3, adc_hc4;
 152
 153         adc_hc0 = DISABLE_CONVERSION_INT;
 154         writel(adc_hc0, tsc->adc_regs + REG_ADC_HC0);
 155
 156         adc_hc1 = DISABLE_CONVERSION_INT | SELECT_CHANNEL_4;
 157         writel(adc_hc1, tsc->adc_regs + REG_ADC_HC1);
 158
 159         adc_hc2 = DISABLE_CONVERSION_INT;
 160         writel(adc_hc2, tsc->adc_regs + REG_ADC_HC2);
 161
 162         adc_hc3 = DISABLE_CONVERSION_INT | SELECT_CHANNEL_1;
 163         writel(adc_hc3, tsc->adc_regs + REG_ADC_HC3);
 164
 165         adc_hc4 = DISABLE_CONVERSION_INT;
 166         writel(adc_hc4, tsc->adc_regs + REG_ADC_HC4);
 167 }
 168
 169 /*
 170  * TSC setting, confige the pre-charge time and measure delay time.
 171  * different touch screen may need different pre-charge time and
 172  * measure delay time.
 173  */
 174 static void imx6ul_tsc_set(struct imx6ul_tsc *tsc)
 175 {
 176         int basic_setting = 0;
 177         int start;
 178
 179         basic_setting |= tsc->measure_delay_time << 8;
 180         basic_setting |= DETECT_4_WIRE_MODE | AUTO_MEASURE;
 181         writel(basic_setting, tsc->tsc_regs + REG_TSC_BASIC_SETING);
 182
 183         writel(DE_GLITCH_2, tsc->tsc_regs + REG_TSC_DEBUG_MODE2);
 184
 185         writel(tsc->pre_charge_time, tsc->tsc_regs + REG_TSC_PRE_CHARGE_TIME);
 186         writel(MEASURE_INT_EN, tsc->tsc_regs + REG_TSC_INT_EN);
 187         writel(MEASURE_SIG_EN | VALID_SIG_EN,
 188                 tsc->tsc_regs + REG_TSC_INT_SIG_EN);
 189
 190         /* start sense detection */
 191         start = readl(tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 192         start |= START_SENSE;
 193         start &= ~TSC_DISABLE;
 194         writel(start, tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 195 }
 196
 197 static int imx6ul_tsc_init(struct imx6ul_tsc *tsc)
 198 {
 199         int err;
 200
 201         err = imx6ul_adc_init(tsc);
 202         if (err)
 203                 return err;
 204         imx6ul_tsc_channel_config(tsc);
 205         imx6ul_tsc_set(tsc);
 206
 207         return 0;
 208 }
 209
 210 static void imx6ul_tsc_disable(struct imx6ul_tsc *tsc)
 211 {
 212         int tsc_flow;
 213         int adc_cfg;
 214
 215         /* TSC controller enters to idle status */
 216         tsc_flow = readl(tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 217         tsc_flow |= TSC_DISABLE;
 218         writel(tsc_flow, tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 219
 220         /* ADC controller enters to stop mode */
 221         adc_cfg = readl(tsc->adc_regs + REG_ADC_HC0);
 222         adc_cfg |= ADC_CONV_DISABLE;
 223         writel(adc_cfg, tsc->adc_regs + REG_ADC_HC0);
 224 }
 225
 226 /* Delay some time (max 2ms), wait the pre-charge done. */
 227 static bool tsc_wait_detect_mode(struct imx6ul_tsc *tsc)
 228 {
 229         unsigned long timeout = jiffies + msecs_to_jiffies(2);
 230         int state_machine;
 231         int debug_mode2;
 232
 233         do {
 234                 if (time_after(jiffies, timeout))
 235                         return false;
 236
 237                 usleep_range(200, 400);
 238                 debug_mode2 = readl(tsc->tsc_regs + REG_TSC_DEBUG_MODE2);
 239                 state_machine = (debug_mode2 >> 20) & 0x7;
 240         } while (state_machine != DETECT_MODE);
 241
 242         usleep_range(200, 400);
 243         return true;
 244 }
 245
 246 static irqreturn_t tsc_irq_fn(int irq, void *dev_id)
 247 {
 248         struct imx6ul_tsc *tsc = dev_id;
 249         int status;
 250         int value;
 251         int x, y;
 252         int start;
 253
 254         status = readl(tsc->tsc_regs + REG_TSC_INT_STATUS);
 255
 256         /* write 1 to clear the bit measure-signal */
 257         writel(MEASURE_SIGNAL | DETECT_SIGNAL,
 258                 tsc->tsc_regs + REG_TSC_INT_STATUS);
 259
 260         /* It's a HW self-clean bit. Set this bit and start sense detection */
 261         start = readl(tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 262         start |= START_SENSE;
 263         writel(start, tsc->tsc_regs + REG_TSC_FLOW_CONTROL);
 264
 265         if (status & MEASURE_SIGNAL) {
 266                 value = readl(tsc->tsc_regs + REG_TSC_MEASURE_VALUE);
 267                 x = (value >> 16) & 0x0fff;
 268                 y = value & 0x0fff;
 269
 270                 /*
 271                  * In detect mode, we can get the xnur gpio value,
 272                  * otherwise assume contact is stiull active.
 273                  */
 274                 if (!tsc_wait_detect_mode(tsc) ||
 275                     gpiod_get_value_cansleep(tsc->xnur_gpio)) {
 276                         input_report_key(tsc->input, BTN_TOUCH, 1);
 277                         input_report_abs(tsc->input, ABS_X, x);
 278                         input_report_abs(tsc->input, ABS_Y, y);
 279                 } else {
 280                         input_report_key(tsc->input, BTN_TOUCH, 0);
 281                 }
 282
 283                 input_sync(tsc->input);
 284         }
 285
 286         return IRQ_HANDLED;
 287 }
 288
 289 static irqreturn_t adc_irq_fn(int irq, void *dev_id)
 290 {
 291         struct imx6ul_tsc *tsc = dev_id;
 292         int coco;
 293         int value;
 294
 295         coco = readl(tsc->adc_regs + REG_ADC_HS);
 296         if (coco & 0x01) {
 297                 value = readl(tsc->adc_regs + REG_ADC_R0);
 298                 complete(&tsc->completion);
 299         }
 300
 301         return IRQ_HANDLED;
 302 }
 303
 304 static int imx6ul_tsc_open(struct input_dev *input_dev)
 305 {
 306         struct imx6ul_tsc *tsc = input_get_drvdata(input_dev);
 307         int err;
 308
 309         err = clk_prepare_enable(tsc->adc_clk);
 310         if (err) {
 311                 dev_err(tsc->dev,
 312                         "Could not prepare or enable the adc clock: %d\n",
 313                         err);
 314                 return err;
 315         }
 316
 317         err = clk_prepare_enable(tsc->tsc_clk);
 318         if (err) {
 319                 dev_err(tsc->dev,
 320                         "Could not prepare or enable the tsc clock: %d\n",
 321                         err);
 322                 clk_disable_unprepare(tsc->adc_clk);
 323                 return err;
 324         }
 325
 326         return imx6ul_tsc_init(tsc);
 327 }
 328
 329 static void imx6ul_tsc_close(struct input_dev *input_dev)
 330 {
 331         struct imx6ul_tsc *tsc = input_get_drvdata(input_dev);
 332
 333         imx6ul_tsc_disable(tsc);
 334
 335         clk_disable_unprepare(tsc->tsc_clk);
 336         clk_disable_unprepare(tsc->adc_clk);
 337 }
 338
 339 static int imx6ul_tsc_probe(struct platform_device *pdev)
 340 {
 341         struct device_node *np = pdev->dev.of_node;
 342         struct imx6ul_tsc *tsc;
 343         struct input_dev *input_dev;
 344         struct resource *tsc_mem;
 345         struct resource *adc_mem;
 346         int err;
 347         int tsc_irq;
 348         int adc_irq;
 349
 350         tsc = devm_kzalloc(&pdev->dev, sizeof(*tsc), GFP_KERNEL);
 351         if (!tsc)
 352                 return -ENOMEM;
 353
 354         input_dev = devm_input_allocate_device(&pdev->dev);
 355         if (!input_dev)
 356                 return -ENOMEM;
 357
 358         input_dev->name = "iMX6UL Touchscreen Controller";
 359         input_dev->id.bustype = BUS_HOST;
 360
 361         input_dev->open = imx6ul_tsc_open;
 362         input_dev->close = imx6ul_tsc_close;
 363
 364         input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
 365         input_set_abs_params(input_dev, ABS_X, 0, 0xFFF, 0, 0);
 366         input_set_abs_params(input_dev, ABS_Y, 0, 0xFFF, 0, 0);
 367
 368         input_set_drvdata(input_dev, tsc);
 369
 370         tsc->dev = &pdev->dev;
 371         tsc->input = input_dev;
 372         init_completion(&tsc->completion);
 373
 374         tsc->xnur_gpio = devm_gpiod_get(&pdev->dev, "xnur", GPIOD_IN);
 375         if (IS_ERR(tsc->xnur_gpio)) {
 376                 err = PTR_ERR(tsc->xnur_gpio);
 377                 dev_err(&pdev->dev,
 378                         "failed to request GPIO tsc_X- (xnur): %d\n", err);
 379                 return err;
 380         }
 381
 382         tsc_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 383         tsc->tsc_regs = devm_ioremap_resource(&pdev->dev, tsc_mem);
 384         if (IS_ERR(tsc->tsc_regs)) {
 385                 err = PTR_ERR(tsc->tsc_regs);
 386                 dev_err(&pdev->dev, "failed to remap tsc memory: %d\n", err);
 387                 return err;
 388         }
 389
 390         adc_mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 391         tsc->adc_regs = devm_ioremap_resource(&pdev->dev, adc_mem);
 392         if (IS_ERR(tsc->adc_regs)) {
 393                 err = PTR_ERR(tsc->adc_regs);
 394                 dev_err(&pdev->dev, "failed to remap adc memory: %d\n", err);
 395                 return err;
 396         }
 397
 398         tsc->tsc_clk = devm_clk_get(&pdev->dev, "tsc");
 399         if (IS_ERR(tsc->tsc_clk)) {
 400                 err = PTR_ERR(tsc->tsc_clk);
 401                 dev_err(&pdev->dev, "failed getting tsc clock: %d\n", err);
 402                 return err;
 403         }
 404
 405         tsc->adc_clk = devm_clk_get(&pdev->dev, "adc");
 406         if (IS_ERR(tsc->adc_clk)) {
 407                 err = PTR_ERR(tsc->adc_clk);
 408                 dev_err(&pdev->dev, "failed getting adc clock: %d\n", err);
 409                 return err;
 410         }
 411
 412         tsc_irq = platform_get_irq(pdev, 0);
 413         if (tsc_irq < 0) {
 414                 dev_err(&pdev->dev, "no tsc irq resource?\n");
 415                 return tsc_irq;
 416         }
 417
 418         adc_irq = platform_get_irq(pdev, 1);
 419         if (adc_irq < 0) {
 420                 dev_err(&pdev->dev, "no adc irq resource?\n");
 421                 return adc_irq;
 422         }
 423
 424         err = devm_request_threaded_irq(tsc->dev, tsc_irq,
 425                                         NULL, tsc_irq_fn, IRQF_ONESHOT,
 426                                         dev_name(&pdev->dev), tsc);
 427         if (err) {
 428                 dev_err(&pdev->dev,
 429                         "failed requesting tsc irq %d: %d\n",
 430                         tsc_irq, err);
 431                 return err;
 432         }
 433
 434         err = devm_request_irq(tsc->dev, adc_irq, adc_irq_fn, 0,
 435                                 dev_name(&pdev->dev), tsc);
 436         if (err) {
 437                 dev_err(&pdev->dev,
 438                         "failed requesting adc irq %d: %d\n",
 439                         adc_irq, err);
 440                 return err;
 441         }
 442
 443         err = of_property_read_u32(np, "measure-delay-time",
 444                                    &tsc->measure_delay_time);
 445         if (err)
 446                 tsc->measure_delay_time = 0xffff;
 447
 448         err = of_property_read_u32(np, "pre-charge-time",
 449                                    &tsc->pre_charge_time);
 450         if (err)
 451                 tsc->pre_charge_time = 0xfff;
 452
 453         err = input_register_device(tsc->input);
 454         if (err) {
 455                 dev_err(&pdev->dev,
 456                         "failed to register input device: %d\n", err);
 457                 return err;
 458         }
 459
 460         platform_set_drvdata(pdev, tsc);
 461         return 0;
 462 }
 463
 464 static int __maybe_unused imx6ul_tsc_suspend(struct device *dev)
 465 {
 466         struct platform_device *pdev = to_platform_device(dev);
 467         struct imx6ul_tsc *tsc = platform_get_drvdata(pdev);
 468         struct input_dev *input_dev = tsc->input;
 469
 470         mutex_lock(&input_dev->mutex);
 471
 472         if (input_dev->users) {
 473                 imx6ul_tsc_disable(tsc);
 474
 475                 clk_disable_unprepare(tsc->tsc_clk);
 476                 clk_disable_unprepare(tsc->adc_clk);
 477         }
 478
 479         mutex_unlock(&input_dev->mutex);
 480
 481         return 0;
 482 }
 483
 484 static int __maybe_unused imx6ul_tsc_resume(struct device *dev)
 485 {
 486         struct platform_device *pdev = to_platform_device(dev);
 487         struct imx6ul_tsc *tsc = platform_get_drvdata(pdev);
 488         struct input_dev *input_dev = tsc->input;
 489         int retval = 0;
 490
 491         mutex_lock(&input_dev->mutex);
 492
 493         if (input_dev->users) {
 494                 retval = clk_prepare_enable(tsc->adc_clk);
 495                 if (retval)
 496                         goto out;
 497
 498                 retval = clk_prepare_enable(tsc->tsc_clk);
 499                 if (retval) {
 500                         clk_disable_unprepare(tsc->adc_clk);
 501                         goto out;
 502                 }
 503
 504                 retval = imx6ul_tsc_init(tsc);
 505         }
 506
 507 out:
 508         mutex_unlock(&input_dev->mutex);
 509         return retval;
 510 }
 511
 512 static SIMPLE_DEV_PM_OPS(imx6ul_tsc_pm_ops,
 513                          imx6ul_tsc_suspend, imx6ul_tsc_resume);
 514
 515 static const struct of_device_id imx6ul_tsc_match[] = {
 516         { .compatible = "fsl,imx6ul-tsc", },
 517         { /* sentinel */ }
 518 };
 519 MODULE_DEVICE_TABLE(of, imx6ul_tsc_match);
 520
 521 static struct platform_driver imx6ul_tsc_driver = {
 522         .driver         = {
 523                 .name   = "imx6ul-tsc",
 524                 .of_match_table = imx6ul_tsc_match,
 525                 .pm     = &imx6ul_tsc_pm_ops,
 526         },
 527         .probe          = imx6ul_tsc_probe,
 528 };
 529 module_platform_driver(imx6ul_tsc_driver);
 530
 531 MODULE_AUTHOR("Haibo Chen <haibo.chen@freescale.com>");
 532 MODULE_DESCRIPTION("Freescale i.MX6UL Touchscreen controller driver");
 533 MODULE_LICENSE("GPL v2");