drivers/input/touchscreen/bcm_iproc_tsc.c

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