1 /* 2 * TI Touch Screen driver 3 * 4 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation version 2. 9 * 10 * This program is distributed "as is" WITHOUT ANY WARRANTY of any 11 * kind, whether express or implied; without even the implied warranty 12 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 */ 15 16 17 #include <linux/kernel.h> 18 #include <linux/err.h> 19 #include <linux/module.h> 20 #include <linux/input.h> 21 #include <linux/slab.h> 22 #include <linux/interrupt.h> 23 #include <linux/clk.h> 24 #include <linux/platform_device.h> 25 #include <linux/io.h> 26 #include <linux/delay.h> 27 #include <linux/of.h> 28 #include <linux/of_device.h> 29 #include <linux/sort.h> 30 31 #include <linux/mfd/ti_am335x_tscadc.h> 32 33 #define ADCFSM_STEPID 0x10 34 #define SEQ_SETTLE 275 35 #define MAX_12BIT ((1 << 12) - 1) 36 37 #define TSC_IRQENB_MASK (IRQENB_FIFO0THRES | IRQENB_EOS | IRQENB_HW_PEN) 38 39 static const int config_pins[] = { 40 STEPCONFIG_XPP, 41 STEPCONFIG_XNN, 42 STEPCONFIG_YPP, 43 STEPCONFIG_YNN, 44 }; 45 46 struct titsc { 47 struct input_dev *input; 48 struct ti_tscadc_dev *mfd_tscadc; 49 unsigned int irq; 50 unsigned int wires; 51 unsigned int x_plate_resistance; 52 bool pen_down; 53 int coordinate_readouts; 54 u32 config_inp[4]; 55 u32 bit_xp, bit_xn, bit_yp, bit_yn; 56 u32 inp_xp, inp_xn, inp_yp, inp_yn; 57 u32 step_mask; 58 u32 charge_delay; 59 }; 60 61 static unsigned int titsc_readl(struct titsc *ts, unsigned int reg) 62 { 63 return readl(ts->mfd_tscadc->tscadc_base + reg); 64 } 65 66 static void titsc_writel(struct titsc *tsc, unsigned int reg, 67 unsigned int val) 68 { 69 writel(val, tsc->mfd_tscadc->tscadc_base + reg); 70 } 71 72 static int titsc_config_wires(struct titsc *ts_dev) 73 { 74 u32 analog_line[4]; 75 u32 wire_order[4]; 76 int i, bit_cfg; 77 78 for (i = 0; i < 4; i++) { 79 /* 80 * Get the order in which TSC wires are attached 81 * w.r.t. each of the analog input lines on the EVM. 82 */ 83 analog_line[i] = (ts_dev->config_inp[i] & 0xF0) >> 4; 84 wire_order[i] = ts_dev->config_inp[i] & 0x0F; 85 if (WARN_ON(analog_line[i] > 7)) 86 return -EINVAL; 87 if (WARN_ON(wire_order[i] > ARRAY_SIZE(config_pins))) 88 return -EINVAL; 89 } 90 91 for (i = 0; i < 4; i++) { 92 int an_line; 93 int wi_order; 94 95 an_line = analog_line[i]; 96 wi_order = wire_order[i]; 97 bit_cfg = config_pins[wi_order]; 98 if (bit_cfg == 0) 99 return -EINVAL; 100 switch (wi_order) { 101 case 0: 102 ts_dev->bit_xp = bit_cfg; 103 ts_dev->inp_xp = an_line; 104 break; 105 106 case 1: 107 ts_dev->bit_xn = bit_cfg; 108 ts_dev->inp_xn = an_line; 109 break; 110 111 case 2: 112 ts_dev->bit_yp = bit_cfg; 113 ts_dev->inp_yp = an_line; 114 break; 115 case 3: 116 ts_dev->bit_yn = bit_cfg; 117 ts_dev->inp_yn = an_line; 118 break; 119 } 120 } 121 return 0; 122 } 123 124 static void titsc_step_config(struct titsc *ts_dev) 125 { 126 unsigned int config; 127 int i; 128 int end_step, first_step, tsc_steps; 129 u32 stepenable; 130 131 config = STEPCONFIG_MODE_HWSYNC | 132 STEPCONFIG_AVG_16 | ts_dev->bit_xp; 133 switch (ts_dev->wires) { 134 case 4: 135 config |= STEPCONFIG_INP(ts_dev->inp_yp) | ts_dev->bit_xn; 136 break; 137 case 5: 138 config |= ts_dev->bit_yn | 139 STEPCONFIG_INP_AN4 | ts_dev->bit_xn | 140 ts_dev->bit_yp; 141 break; 142 case 8: 143 config |= STEPCONFIG_INP(ts_dev->inp_yp) | ts_dev->bit_xn; 144 break; 145 } 146 147 tsc_steps = ts_dev->coordinate_readouts * 2 + 2; 148 first_step = TOTAL_STEPS - tsc_steps; 149 /* Steps 16 to 16-coordinate_readouts is for X */ 150 end_step = first_step + tsc_steps; 151 for (i = end_step - ts_dev->coordinate_readouts; i < end_step; i++) { 152 titsc_writel(ts_dev, REG_STEPCONFIG(i), config); 153 titsc_writel(ts_dev, REG_STEPDELAY(i), STEPCONFIG_OPENDLY); 154 } 155 156 config = 0; 157 config = STEPCONFIG_MODE_HWSYNC | 158 STEPCONFIG_AVG_16 | ts_dev->bit_yn | 159 STEPCONFIG_INM_ADCREFM; 160 switch (ts_dev->wires) { 161 case 4: 162 config |= ts_dev->bit_yp | STEPCONFIG_INP(ts_dev->inp_xp); 163 break; 164 case 5: 165 config |= ts_dev->bit_xp | STEPCONFIG_INP_AN4 | 166 STEPCONFIG_XNP | STEPCONFIG_YPN; 167 break; 168 case 8: 169 config |= ts_dev->bit_yp | STEPCONFIG_INP(ts_dev->inp_xp); 170 break; 171 } 172 173 /* 1 ... coordinate_readouts is for Y */ 174 end_step = first_step + ts_dev->coordinate_readouts; 175 for (i = first_step; i < end_step; i++) { 176 titsc_writel(ts_dev, REG_STEPCONFIG(i), config); 177 titsc_writel(ts_dev, REG_STEPDELAY(i), STEPCONFIG_OPENDLY); 178 } 179 180 /* Make CHARGECONFIG same as IDLECONFIG */ 181 182 config = titsc_readl(ts_dev, REG_IDLECONFIG); 183 titsc_writel(ts_dev, REG_CHARGECONFIG, config); 184 titsc_writel(ts_dev, REG_CHARGEDELAY, ts_dev->charge_delay); 185 186 /* coordinate_readouts + 1 ... coordinate_readouts + 2 is for Z */ 187 config = STEPCONFIG_MODE_HWSYNC | 188 STEPCONFIG_AVG_16 | ts_dev->bit_yp | 189 ts_dev->bit_xn | STEPCONFIG_INM_ADCREFM | 190 STEPCONFIG_INP(ts_dev->inp_xp); 191 titsc_writel(ts_dev, REG_STEPCONFIG(end_step), config); 192 titsc_writel(ts_dev, REG_STEPDELAY(end_step), 193 STEPCONFIG_OPENDLY); 194 195 end_step++; 196 config |= STEPCONFIG_INP(ts_dev->inp_yn); 197 titsc_writel(ts_dev, REG_STEPCONFIG(end_step), config); 198 titsc_writel(ts_dev, REG_STEPDELAY(end_step), 199 STEPCONFIG_OPENDLY); 200 201 /* The steps end ... end - readouts * 2 + 2 and bit 0 for TS_Charge */ 202 stepenable = 1; 203 for (i = 0; i < tsc_steps; i++) 204 stepenable |= 1 << (first_step + i + 1); 205 206 ts_dev->step_mask = stepenable; 207 am335x_tsc_se_set_cache(ts_dev->mfd_tscadc, ts_dev->step_mask); 208 } 209 210 static int titsc_cmp_coord(const void *a, const void *b) 211 { 212 return *(int *)a - *(int *)b; 213 } 214 215 static void titsc_read_coordinates(struct titsc *ts_dev, 216 u32 *x, u32 *y, u32 *z1, u32 *z2) 217 { 218 unsigned int yvals[7], xvals[7]; 219 unsigned int i, xsum = 0, ysum = 0; 220 unsigned int creads = ts_dev->coordinate_readouts; 221 222 for (i = 0; i < creads; i++) { 223 yvals[i] = titsc_readl(ts_dev, REG_FIFO0); 224 yvals[i] &= 0xfff; 225 } 226 227 *z1 = titsc_readl(ts_dev, REG_FIFO0); 228 *z1 &= 0xfff; 229 *z2 = titsc_readl(ts_dev, REG_FIFO0); 230 *z2 &= 0xfff; 231 232 for (i = 0; i < creads; i++) { 233 xvals[i] = titsc_readl(ts_dev, REG_FIFO0); 234 xvals[i] &= 0xfff; 235 } 236 237 /* 238 * If co-ordinates readouts is less than 4 then 239 * report the average. In case of 4 or more 240 * readouts, sort the co-ordinate samples, drop 241 * min and max values and report the average of 242 * remaining values. 243 */ 244 if (creads <= 3) { 245 for (i = 0; i < creads; i++) { 246 ysum += yvals[i]; 247 xsum += xvals[i]; 248 } 249 ysum /= creads; 250 xsum /= creads; 251 } else { 252 sort(yvals, creads, sizeof(unsigned int), 253 titsc_cmp_coord, NULL); 254 sort(xvals, creads, sizeof(unsigned int), 255 titsc_cmp_coord, NULL); 256 for (i = 1; i < creads - 1; i++) { 257 ysum += yvals[i]; 258 xsum += xvals[i]; 259 } 260 ysum /= creads - 2; 261 xsum /= creads - 2; 262 } 263 *y = ysum; 264 *x = xsum; 265 } 266 267 static irqreturn_t titsc_irq(int irq, void *dev) 268 { 269 struct titsc *ts_dev = dev; 270 struct input_dev *input_dev = ts_dev->input; 271 unsigned int fsm, status, irqclr = 0; 272 unsigned int x = 0, y = 0; 273 unsigned int z1, z2, z; 274 275 status = titsc_readl(ts_dev, REG_RAWIRQSTATUS); 276 if (status & IRQENB_HW_PEN) { 277 ts_dev->pen_down = true; 278 irqclr |= IRQENB_HW_PEN; 279 pm_stay_awake(ts_dev->mfd_tscadc->dev); 280 } 281 282 if (status & IRQENB_PENUP) { 283 fsm = titsc_readl(ts_dev, REG_ADCFSM); 284 if (fsm == ADCFSM_STEPID) { 285 ts_dev->pen_down = false; 286 input_report_key(input_dev, BTN_TOUCH, 0); 287 input_report_abs(input_dev, ABS_PRESSURE, 0); 288 input_sync(input_dev); 289 pm_relax(ts_dev->mfd_tscadc->dev); 290 } else { 291 ts_dev->pen_down = true; 292 } 293 irqclr |= IRQENB_PENUP; 294 } 295 296 if (status & IRQENB_EOS) 297 irqclr |= IRQENB_EOS; 298 299 /* 300 * ADC and touchscreen share the IRQ line. 301 * FIFO1 interrupts are used by ADC. Handle FIFO0 IRQs here only 302 */ 303 if (status & IRQENB_FIFO0THRES) { 304 305 titsc_read_coordinates(ts_dev, &x, &y, &z1, &z2); 306 307 if (ts_dev->pen_down && z1 != 0 && z2 != 0) { 308 /* 309 * Calculate pressure using formula 310 * Resistance(touch) = x plate resistance * 311 * x postion/4096 * ((z2 / z1) - 1) 312 */ 313 z = z1 - z2; 314 z *= x; 315 z *= ts_dev->x_plate_resistance; 316 z /= z2; 317 z = (z + 2047) >> 12; 318 319 if (z <= MAX_12BIT) { 320 input_report_abs(input_dev, ABS_X, x); 321 input_report_abs(input_dev, ABS_Y, y); 322 input_report_abs(input_dev, ABS_PRESSURE, z); 323 input_report_key(input_dev, BTN_TOUCH, 1); 324 input_sync(input_dev); 325 } 326 } 327 irqclr |= IRQENB_FIFO0THRES; 328 } 329 if (irqclr) { 330 titsc_writel(ts_dev, REG_IRQSTATUS, irqclr); 331 if (status & IRQENB_EOS) 332 am335x_tsc_se_set_cache(ts_dev->mfd_tscadc, 333 ts_dev->step_mask); 334 return IRQ_HANDLED; 335 } 336 return IRQ_NONE; 337 } 338 339 static int titsc_parse_dt(struct platform_device *pdev, 340 struct titsc *ts_dev) 341 { 342 struct device_node *node = pdev->dev.of_node; 343 int err; 344 345 if (!node) 346 return -EINVAL; 347 348 err = of_property_read_u32(node, "ti,wires", &ts_dev->wires); 349 if (err < 0) 350 return err; 351 switch (ts_dev->wires) { 352 case 4: 353 case 5: 354 case 8: 355 break; 356 default: 357 return -EINVAL; 358 } 359 360 err = of_property_read_u32(node, "ti,x-plate-resistance", 361 &ts_dev->x_plate_resistance); 362 if (err < 0) 363 return err; 364 365 /* 366 * Try with the new binding first. If it fails, try again with 367 * bogus, miss-spelled version. 368 */ 369 err = of_property_read_u32(node, "ti,coordinate-readouts", 370 &ts_dev->coordinate_readouts); 371 if (err < 0) { 372 dev_warn(&pdev->dev, "please use 'ti,coordinate-readouts' instead\n"); 373 err = of_property_read_u32(node, "ti,coordiante-readouts", 374 &ts_dev->coordinate_readouts); 375 } 376 377 if (err < 0) 378 return err; 379 380 if (ts_dev->coordinate_readouts <= 0) { 381 dev_warn(&pdev->dev, 382 "invalid co-ordinate readouts, resetting it to 5\n"); 383 ts_dev->coordinate_readouts = 5; 384 } 385 386 err = of_property_read_u32(node, "ti,charge-delay", 387 &ts_dev->charge_delay); 388 /* 389 * If ti,charge-delay value is not specified, then use 390 * CHARGEDLY_OPENDLY as the default value. 391 */ 392 if (err < 0) { 393 ts_dev->charge_delay = CHARGEDLY_OPENDLY; 394 dev_warn(&pdev->dev, "ti,charge-delay not specified\n"); 395 } 396 397 return of_property_read_u32_array(node, "ti,wire-config", 398 ts_dev->config_inp, ARRAY_SIZE(ts_dev->config_inp)); 399 } 400 401 /* 402 * The functions for inserting/removing driver as a module. 403 */ 404 405 static int titsc_probe(struct platform_device *pdev) 406 { 407 struct titsc *ts_dev; 408 struct input_dev *input_dev; 409 struct ti_tscadc_dev *tscadc_dev = ti_tscadc_dev_get(pdev); 410 int err; 411 412 /* Allocate memory for device */ 413 ts_dev = kzalloc(sizeof(*ts_dev), GFP_KERNEL); 414 input_dev = input_allocate_device(); 415 if (!ts_dev || !input_dev) { 416 dev_err(&pdev->dev, "failed to allocate memory.\n"); 417 err = -ENOMEM; 418 goto err_free_mem; 419 } 420 421 tscadc_dev->tsc = ts_dev; 422 ts_dev->mfd_tscadc = tscadc_dev; 423 ts_dev->input = input_dev; 424 ts_dev->irq = tscadc_dev->irq; 425 426 err = titsc_parse_dt(pdev, ts_dev); 427 if (err) { 428 dev_err(&pdev->dev, "Could not find valid DT data.\n"); 429 goto err_free_mem; 430 } 431 432 err = request_irq(ts_dev->irq, titsc_irq, 433 IRQF_SHARED, pdev->dev.driver->name, ts_dev); 434 if (err) { 435 dev_err(&pdev->dev, "failed to allocate irq.\n"); 436 goto err_free_mem; 437 } 438 439 titsc_writel(ts_dev, REG_IRQSTATUS, TSC_IRQENB_MASK); 440 titsc_writel(ts_dev, REG_IRQENABLE, IRQENB_FIFO0THRES); 441 titsc_writel(ts_dev, REG_IRQENABLE, IRQENB_EOS); 442 err = titsc_config_wires(ts_dev); 443 if (err) { 444 dev_err(&pdev->dev, "wrong i/p wire configuration\n"); 445 goto err_free_irq; 446 } 447 titsc_step_config(ts_dev); 448 titsc_writel(ts_dev, REG_FIFO0THR, 449 ts_dev->coordinate_readouts * 2 + 2 - 1); 450 451 input_dev->name = "ti-tsc"; 452 input_dev->dev.parent = &pdev->dev; 453 454 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 455 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 456 457 input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0); 458 input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0); 459 input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, 0, 0); 460 461 /* register to the input system */ 462 err = input_register_device(input_dev); 463 if (err) 464 goto err_free_irq; 465 466 platform_set_drvdata(pdev, ts_dev); 467 return 0; 468 469 err_free_irq: 470 free_irq(ts_dev->irq, ts_dev); 471 err_free_mem: 472 input_free_device(input_dev); 473 kfree(ts_dev); 474 return err; 475 } 476 477 static int titsc_remove(struct platform_device *pdev) 478 { 479 struct titsc *ts_dev = platform_get_drvdata(pdev); 480 u32 steps; 481 482 free_irq(ts_dev->irq, ts_dev); 483 484 /* total steps followed by the enable mask */ 485 steps = 2 * ts_dev->coordinate_readouts + 2; 486 steps = (1 << steps) - 1; 487 am335x_tsc_se_clr(ts_dev->mfd_tscadc, steps); 488 489 input_unregister_device(ts_dev->input); 490 491 kfree(ts_dev); 492 return 0; 493 } 494 495 static int __maybe_unused titsc_suspend(struct device *dev) 496 { 497 struct titsc *ts_dev = dev_get_drvdata(dev); 498 struct ti_tscadc_dev *tscadc_dev; 499 unsigned int idle; 500 501 tscadc_dev = ti_tscadc_dev_get(to_platform_device(dev)); 502 if (device_may_wakeup(tscadc_dev->dev)) { 503 titsc_writel(ts_dev, REG_IRQSTATUS, TSC_IRQENB_MASK); 504 idle = titsc_readl(ts_dev, REG_IRQENABLE); 505 titsc_writel(ts_dev, REG_IRQENABLE, 506 (idle | IRQENB_HW_PEN)); 507 titsc_writel(ts_dev, REG_IRQWAKEUP, IRQWKUP_ENB); 508 } 509 return 0; 510 } 511 512 static int __maybe_unused titsc_resume(struct device *dev) 513 { 514 struct titsc *ts_dev = dev_get_drvdata(dev); 515 struct ti_tscadc_dev *tscadc_dev; 516 517 tscadc_dev = ti_tscadc_dev_get(to_platform_device(dev)); 518 if (device_may_wakeup(tscadc_dev->dev)) { 519 titsc_writel(ts_dev, REG_IRQWAKEUP, 520 0x00); 521 titsc_writel(ts_dev, REG_IRQCLR, IRQENB_HW_PEN); 522 pm_relax(ts_dev->mfd_tscadc->dev); 523 } 524 titsc_step_config(ts_dev); 525 titsc_writel(ts_dev, REG_FIFO0THR, 526 ts_dev->coordinate_readouts * 2 + 2 - 1); 527 return 0; 528 } 529 530 static SIMPLE_DEV_PM_OPS(titsc_pm_ops, titsc_suspend, titsc_resume); 531 532 static const struct of_device_id ti_tsc_dt_ids[] = { 533 { .compatible = "ti,am3359-tsc", }, 534 { } 535 }; 536 MODULE_DEVICE_TABLE(of, ti_tsc_dt_ids); 537 538 static struct platform_driver ti_tsc_driver = { 539 .probe = titsc_probe, 540 .remove = titsc_remove, 541 .driver = { 542 .name = "TI-am335x-tsc", 543 .pm = &titsc_pm_ops, 544 .of_match_table = ti_tsc_dt_ids, 545 }, 546 }; 547 module_platform_driver(ti_tsc_driver); 548 549 MODULE_DESCRIPTION("TI touchscreen controller driver"); 550 MODULE_AUTHOR("Rachna Patil <rachna@ti.com>"); 551 MODULE_LICENSE("GPL"); 552