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