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