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