1 /* 2 * Copyright (C) 2015 Broadcom Corporation 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License as 6 * published by the Free Software Foundation version 2. 7 * 8 * This program is distributed "as is" WITHOUT ANY WARRANTY of any 9 * kind, whether express or implied; without even the implied warranty 10 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/input.h> 16 #include <linux/delay.h> 17 #include <linux/interrupt.h> 18 #include <linux/keyboard.h> 19 #include <linux/platform_device.h> 20 #include <linux/slab.h> 21 #include <linux/of.h> 22 #include <asm/irq.h> 23 #include <linux/io.h> 24 #include <linux/clk.h> 25 #include <linux/serio.h> 26 27 #define IPROC_TS_NAME "iproc-ts" 28 29 #define PEN_DOWN_STATUS 1 30 #define PEN_UP_STATUS 0 31 32 #define X_MIN 0 33 #define Y_MIN 0 34 #define X_MAX 0xFFF 35 #define Y_MAX 0xFFF 36 37 /* Value given by controller for invalid coordinate. */ 38 #define INVALID_COORD 0xFFFFFFFF 39 40 /* Register offsets */ 41 #define REGCTL1 0x00 42 #define REGCTL2 0x04 43 #define INTERRUPT_THRES 0x08 44 #define INTERRUPT_MASK 0x0c 45 46 #define INTERRUPT_STATUS 0x10 47 #define CONTROLLER_STATUS 0x14 48 #define FIFO_DATA 0x18 49 #define FIFO_DATA_X_Y_MASK 0xFFFF 50 #define ANALOG_CONTROL 0x1c 51 52 #define AUX_DATA 0x20 53 #define DEBOUNCE_CNTR_STAT 0x24 54 #define SCAN_CNTR_STAT 0x28 55 #define REM_CNTR_STAT 0x2c 56 57 #define SETTLING_TIMER_STAT 0x30 58 #define SPARE_REG 0x34 59 #define SOFT_BYPASS_CONTROL 0x38 60 #define SOFT_BYPASS_DATA 0x3c 61 62 63 /* Bit values for INTERRUPT_MASK and INTERRUPT_STATUS regs */ 64 #define TS_PEN_INTR_MASK BIT(0) 65 #define TS_FIFO_INTR_MASK BIT(2) 66 67 /* Bit values for CONTROLLER_STATUS reg1 */ 68 #define TS_PEN_DOWN BIT(0) 69 70 /* Shift values for control reg1 */ 71 #define SCANNING_PERIOD_SHIFT 24 72 #define DEBOUNCE_TIMEOUT_SHIFT 16 73 #define SETTLING_TIMEOUT_SHIFT 8 74 #define TOUCH_TIMEOUT_SHIFT 0 75 76 /* Shift values for coordinates from fifo */ 77 #define X_COORD_SHIFT 0 78 #define Y_COORD_SHIFT 16 79 80 /* Bit values for REGCTL2 */ 81 #define TS_CONTROLLER_EN_BIT BIT(16) 82 #define TS_CONTROLLER_AVGDATA_SHIFT 8 83 #define TS_CONTROLLER_AVGDATA_MASK (0x7 << TS_CONTROLLER_AVGDATA_SHIFT) 84 #define TS_CONTROLLER_PWR_LDO BIT(5) 85 #define TS_CONTROLLER_PWR_ADC BIT(4) 86 #define TS_CONTROLLER_PWR_BGP BIT(3) 87 #define TS_CONTROLLER_PWR_TS BIT(2) 88 #define TS_WIRE_MODE_BIT BIT(1) 89 90 #define dbg_reg(dev, priv, reg) \ 91 dev_dbg(dev, "%20s= 0x%08x\n", #reg, readl((priv)->regs + reg)) 92 93 struct tsc_param { 94 /* Each step is 1024 us. Valid 1-256 */ 95 u32 scanning_period; 96 97 /* Each step is 512 us. Valid 0-255 */ 98 u32 debounce_timeout; 99 100 /* 101 * The settling duration (in ms) is the amount of time the tsc 102 * waits to allow the voltage to settle after turning on the 103 * drivers in detection mode. Valid values: 0-11 104 * 0 = 0.008 ms 105 * 1 = 0.01 ms 106 * 2 = 0.02 ms 107 * 3 = 0.04 ms 108 * 4 = 0.08 ms 109 * 5 = 0.16 ms 110 * 6 = 0.32 ms 111 * 7 = 0.64 ms 112 * 8 = 1.28 ms 113 * 9 = 2.56 ms 114 * 10 = 5.12 ms 115 * 11 = 10.24 ms 116 */ 117 u32 settling_timeout; 118 119 /* touch timeout in sample counts */ 120 u32 touch_timeout; 121 122 /* 123 * Number of data samples which are averaged before a final data point 124 * is placed into the FIFO 125 */ 126 u32 average_data; 127 128 /* FIFO threshold */ 129 u32 fifo_threshold; 130 131 /* Optional standard touchscreen properties. */ 132 u32 max_x; 133 u32 max_y; 134 u32 fuzz_x; 135 u32 fuzz_y; 136 bool invert_x; 137 bool invert_y; 138 }; 139 140 struct iproc_ts_priv { 141 struct platform_device *pdev; 142 struct input_dev *idev; 143 144 void __iomem *regs; 145 struct clk *tsc_clk; 146 147 int pen_status; 148 struct tsc_param cfg_params; 149 }; 150 151 /* 152 * Set default values the same as hardware reset values 153 * except for fifo_threshold with is set to 1. 154 */ 155 static const struct tsc_param iproc_default_config = { 156 .scanning_period = 0x5, /* 1 to 256 */ 157 .debounce_timeout = 0x28, /* 0 to 255 */ 158 .settling_timeout = 0x7, /* 0 to 11 */ 159 .touch_timeout = 0xa, /* 0 to 255 */ 160 .average_data = 5, /* entry 5 = 32 pts */ 161 .fifo_threshold = 1, /* 0 to 31 */ 162 .max_x = X_MAX, 163 .max_y = Y_MAX, 164 }; 165 166 static void ts_reg_dump(struct iproc_ts_priv *priv) 167 { 168 struct device *dev = &priv->pdev->dev; 169 170 dbg_reg(dev, priv, REGCTL1); 171 dbg_reg(dev, priv, REGCTL2); 172 dbg_reg(dev, priv, INTERRUPT_THRES); 173 dbg_reg(dev, priv, INTERRUPT_MASK); 174 dbg_reg(dev, priv, INTERRUPT_STATUS); 175 dbg_reg(dev, priv, CONTROLLER_STATUS); 176 dbg_reg(dev, priv, FIFO_DATA); 177 dbg_reg(dev, priv, ANALOG_CONTROL); 178 dbg_reg(dev, priv, AUX_DATA); 179 dbg_reg(dev, priv, DEBOUNCE_CNTR_STAT); 180 dbg_reg(dev, priv, SCAN_CNTR_STAT); 181 dbg_reg(dev, priv, REM_CNTR_STAT); 182 dbg_reg(dev, priv, SETTLING_TIMER_STAT); 183 dbg_reg(dev, priv, SPARE_REG); 184 dbg_reg(dev, priv, SOFT_BYPASS_CONTROL); 185 dbg_reg(dev, priv, SOFT_BYPASS_DATA); 186 } 187 188 static irqreturn_t iproc_touchscreen_interrupt(int irq, void *data) 189 { 190 struct platform_device *pdev = data; 191 struct iproc_ts_priv *priv = platform_get_drvdata(pdev); 192 u32 intr_status; 193 u32 raw_coordinate; 194 u16 x; 195 u16 y; 196 int i; 197 bool needs_sync = false; 198 199 intr_status = readl(priv->regs + INTERRUPT_STATUS); 200 intr_status &= TS_PEN_INTR_MASK | TS_FIFO_INTR_MASK; 201 if (intr_status == 0) 202 return IRQ_NONE; 203 204 /* Clear all interrupt status bits, write-1-clear */ 205 writel(intr_status, priv->regs + INTERRUPT_STATUS); 206 207 /* Pen up/down */ 208 if (intr_status & TS_PEN_INTR_MASK) { 209 if (readl(priv->regs + CONTROLLER_STATUS) & TS_PEN_DOWN) 210 priv->pen_status = PEN_DOWN_STATUS; 211 else 212 priv->pen_status = PEN_UP_STATUS; 213 214 input_report_key(priv->idev, BTN_TOUCH, priv->pen_status); 215 needs_sync = true; 216 217 dev_dbg(&priv->pdev->dev, 218 "pen up-down (%d)\n", priv->pen_status); 219 } 220 221 /* coordinates in FIFO exceed the theshold */ 222 if (intr_status & TS_FIFO_INTR_MASK) { 223 for (i = 0; i < priv->cfg_params.fifo_threshold; i++) { 224 raw_coordinate = readl(priv->regs + FIFO_DATA); 225 if (raw_coordinate == INVALID_COORD) 226 continue; 227 228 /* 229 * The x and y coordinate are 16 bits each 230 * with the x in the lower 16 bits and y in the 231 * upper 16 bits. 232 */ 233 x = (raw_coordinate >> X_COORD_SHIFT) & 234 FIFO_DATA_X_Y_MASK; 235 y = (raw_coordinate >> Y_COORD_SHIFT) & 236 FIFO_DATA_X_Y_MASK; 237 238 /* We only want to retain the 12 msb of the 16 */ 239 x = (x >> 4) & 0x0FFF; 240 y = (y >> 4) & 0x0FFF; 241 242 /* adjust x y according to lcd tsc mount angle */ 243 if (priv->cfg_params.invert_x) 244 x = priv->cfg_params.max_x - x; 245 246 if (priv->cfg_params.invert_y) 247 y = priv->cfg_params.max_y - y; 248 249 input_report_abs(priv->idev, ABS_X, x); 250 input_report_abs(priv->idev, ABS_Y, y); 251 needs_sync = true; 252 253 dev_dbg(&priv->pdev->dev, "xy (0x%x 0x%x)\n", x, y); 254 } 255 } 256 257 if (needs_sync) 258 input_sync(priv->idev); 259 260 return IRQ_HANDLED; 261 } 262 263 static int iproc_ts_start(struct input_dev *idev) 264 { 265 struct iproc_ts_priv *priv = input_get_drvdata(idev); 266 u32 val; 267 int error; 268 269 /* Enable clock */ 270 error = clk_prepare_enable(priv->tsc_clk); 271 if (error) { 272 dev_err(&priv->pdev->dev, "%s clk_prepare_enable failed %d\n", 273 __func__, error); 274 return error; 275 } 276 277 /* 278 * Interrupt is generated when: 279 * FIFO reaches the int_th value, and pen event(up/down) 280 */ 281 val = TS_PEN_INTR_MASK | TS_FIFO_INTR_MASK; 282 writel(val, priv->regs + INTERRUPT_MASK); 283 284 writel(priv->cfg_params.fifo_threshold, priv->regs + INTERRUPT_THRES); 285 286 /* Initialize control reg1 */ 287 val = 0; 288 val |= priv->cfg_params.scanning_period << SCANNING_PERIOD_SHIFT; 289 val |= priv->cfg_params.debounce_timeout << DEBOUNCE_TIMEOUT_SHIFT; 290 val |= priv->cfg_params.settling_timeout << SETTLING_TIMEOUT_SHIFT; 291 val |= priv->cfg_params.touch_timeout << TOUCH_TIMEOUT_SHIFT; 292 writel(val, priv->regs + REGCTL1); 293 294 /* Try to clear all interrupt status */ 295 val = readl(priv->regs + INTERRUPT_STATUS); 296 val |= TS_FIFO_INTR_MASK | TS_PEN_INTR_MASK; 297 writel(val, priv->regs + INTERRUPT_STATUS); 298 299 /* Initialize control reg2 */ 300 val = readl(priv->regs + REGCTL2); 301 val |= TS_CONTROLLER_EN_BIT | TS_WIRE_MODE_BIT; 302 303 val &= ~TS_CONTROLLER_AVGDATA_MASK; 304 val |= priv->cfg_params.average_data << TS_CONTROLLER_AVGDATA_SHIFT; 305 306 val &= ~(TS_CONTROLLER_PWR_LDO | /* PWR up LDO */ 307 TS_CONTROLLER_PWR_ADC | /* PWR up ADC */ 308 TS_CONTROLLER_PWR_BGP | /* PWR up BGP */ 309 TS_CONTROLLER_PWR_TS); /* PWR up TS */ 310 311 writel(val, priv->regs + REGCTL2); 312 313 ts_reg_dump(priv); 314 315 return 0; 316 } 317 318 static void iproc_ts_stop(struct input_dev *dev) 319 { 320 u32 val; 321 struct iproc_ts_priv *priv = input_get_drvdata(dev); 322 323 writel(0, priv->regs + INTERRUPT_MASK); /* Disable all interrupts */ 324 325 /* Only power down touch screen controller */ 326 val = readl(priv->regs + REGCTL2); 327 val |= TS_CONTROLLER_PWR_TS; 328 writel(val, priv->regs + REGCTL2); 329 330 clk_disable(priv->tsc_clk); 331 } 332 333 static int iproc_get_tsc_config(struct device *dev, struct iproc_ts_priv *priv) 334 { 335 struct device_node *np = dev->of_node; 336 u32 val; 337 338 priv->cfg_params = iproc_default_config; 339 340 if (!np) 341 return 0; 342 343 if (of_property_read_u32(np, "scanning_period", &val) >= 0) { 344 if (val < 1 || val > 256) { 345 dev_err(dev, "scanning_period (%u) must be [1-256]\n", 346 val); 347 return -EINVAL; 348 } 349 priv->cfg_params.scanning_period = val; 350 } 351 352 if (of_property_read_u32(np, "debounce_timeout", &val) >= 0) { 353 if (val > 255) { 354 dev_err(dev, "debounce_timeout (%u) must be [0-255]\n", 355 val); 356 return -EINVAL; 357 } 358 priv->cfg_params.debounce_timeout = val; 359 } 360 361 if (of_property_read_u32(np, "settling_timeout", &val) >= 0) { 362 if (val > 11) { 363 dev_err(dev, "settling_timeout (%u) must be [0-11]\n", 364 val); 365 return -EINVAL; 366 } 367 priv->cfg_params.settling_timeout = val; 368 } 369 370 if (of_property_read_u32(np, "touch_timeout", &val) >= 0) { 371 if (val > 255) { 372 dev_err(dev, "touch_timeout (%u) must be [0-255]\n", 373 val); 374 return -EINVAL; 375 } 376 priv->cfg_params.touch_timeout = val; 377 } 378 379 if (of_property_read_u32(np, "average_data", &val) >= 0) { 380 if (val > 8) { 381 dev_err(dev, "average_data (%u) must be [0-8]\n", val); 382 return -EINVAL; 383 } 384 priv->cfg_params.average_data = val; 385 } 386 387 if (of_property_read_u32(np, "fifo_threshold", &val) >= 0) { 388 if (val > 31) { 389 dev_err(dev, "fifo_threshold (%u)) must be [0-31]\n", 390 val); 391 return -EINVAL; 392 } 393 priv->cfg_params.fifo_threshold = val; 394 } 395 396 /* Parse optional properties. */ 397 of_property_read_u32(np, "touchscreen-size-x", &priv->cfg_params.max_x); 398 of_property_read_u32(np, "touchscreen-size-y", &priv->cfg_params.max_y); 399 400 of_property_read_u32(np, "touchscreen-fuzz-x", 401 &priv->cfg_params.fuzz_x); 402 of_property_read_u32(np, "touchscreen-fuzz-y", 403 &priv->cfg_params.fuzz_y); 404 405 priv->cfg_params.invert_x = 406 of_property_read_bool(np, "touchscreen-inverted-x"); 407 priv->cfg_params.invert_y = 408 of_property_read_bool(np, "touchscreen-inverted-y"); 409 410 return 0; 411 } 412 413 static int iproc_ts_probe(struct platform_device *pdev) 414 { 415 struct iproc_ts_priv *priv; 416 struct input_dev *idev; 417 struct resource *res; 418 int irq; 419 int error; 420 421 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 422 if (!priv) 423 return -ENOMEM; 424 425 /* touchscreen controller memory mapped regs */ 426 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 427 priv->regs = devm_ioremap_resource(&pdev->dev, res); 428 if (IS_ERR(priv->regs)) { 429 error = PTR_ERR(priv->regs); 430 dev_err(&pdev->dev, "unable to map I/O memory: %d\n", error); 431 return error; 432 } 433 434 priv->tsc_clk = devm_clk_get(&pdev->dev, "tsc_clk"); 435 if (IS_ERR(priv->tsc_clk)) { 436 error = PTR_ERR(priv->tsc_clk); 437 dev_err(&pdev->dev, 438 "failed getting clock tsc_clk: %d\n", error); 439 return error; 440 } 441 442 priv->pdev = pdev; 443 error = iproc_get_tsc_config(&pdev->dev, priv); 444 if (error) { 445 dev_err(&pdev->dev, "get_tsc_config failed: %d\n", error); 446 return error; 447 } 448 449 idev = devm_input_allocate_device(&pdev->dev); 450 if (!idev) { 451 dev_err(&pdev->dev, "failed to allocate input device\n"); 452 return -ENOMEM; 453 } 454 455 priv->idev = idev; 456 priv->pen_status = PEN_UP_STATUS; 457 458 /* Set input device info */ 459 idev->name = IPROC_TS_NAME; 460 idev->dev.parent = &pdev->dev; 461 462 idev->id.bustype = BUS_HOST; 463 idev->id.vendor = SERIO_UNKNOWN; 464 idev->id.product = 0; 465 idev->id.version = 0; 466 467 idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 468 __set_bit(BTN_TOUCH, idev->keybit); 469 470 input_set_abs_params(idev, ABS_X, X_MIN, priv->cfg_params.max_x, 471 priv->cfg_params.fuzz_x, 0); 472 input_set_abs_params(idev, ABS_Y, Y_MIN, priv->cfg_params.max_y, 473 priv->cfg_params.fuzz_y, 0); 474 475 idev->open = iproc_ts_start; 476 idev->close = iproc_ts_stop; 477 478 input_set_drvdata(idev, priv); 479 platform_set_drvdata(pdev, priv); 480 481 /* get interrupt */ 482 irq = platform_get_irq(pdev, 0); 483 if (irq < 0) { 484 dev_err(&pdev->dev, "platform_get_irq failed: %d\n", irq); 485 return irq; 486 } 487 488 error = devm_request_irq(&pdev->dev, irq, 489 iproc_touchscreen_interrupt, 490 IRQF_SHARED, IPROC_TS_NAME, pdev); 491 if (error) 492 return error; 493 494 error = input_register_device(priv->idev); 495 if (error) { 496 dev_err(&pdev->dev, 497 "failed to register input device: %d\n", error); 498 return error; 499 } 500 501 return 0; 502 } 503 504 static const struct of_device_id iproc_ts_of_match[] = { 505 {.compatible = "brcm,iproc-touchscreen", }, 506 { }, 507 }; 508 MODULE_DEVICE_TABLE(of, iproc_ts_of_match); 509 510 static struct platform_driver iproc_ts_driver = { 511 .probe = iproc_ts_probe, 512 .driver = { 513 .name = IPROC_TS_NAME, 514 .of_match_table = of_match_ptr(iproc_ts_of_match), 515 }, 516 }; 517 518 module_platform_driver(iproc_ts_driver); 519 520 MODULE_DESCRIPTION("IPROC Touchscreen driver"); 521 MODULE_AUTHOR("Broadcom"); 522 MODULE_LICENSE("GPL v2"); 523