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