1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for AUO in-cell touchscreens 4 * 5 * Copyright (c) 2011 Heiko Stuebner <heiko@sntech.de> 6 * 7 * loosely based on auo_touch.c from Dell Streak vendor-kernel 8 * 9 * Copyright (c) 2008 QUALCOMM Incorporated. 10 * Copyright (c) 2008 QUALCOMM USA, INC. 11 */ 12 13 #include <linux/err.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/interrupt.h> 17 #include <linux/slab.h> 18 #include <linux/input.h> 19 #include <linux/jiffies.h> 20 #include <linux/i2c.h> 21 #include <linux/mutex.h> 22 #include <linux/delay.h> 23 #include <linux/gpio/consumer.h> 24 #include <linux/of.h> 25 #include <linux/property.h> 26 27 /* 28 * Coordinate calculation: 29 * X1 = X1_LSB + X1_MSB*256 30 * Y1 = Y1_LSB + Y1_MSB*256 31 * X2 = X2_LSB + X2_MSB*256 32 * Y2 = Y2_LSB + Y2_MSB*256 33 */ 34 #define AUO_PIXCIR_REG_X1_LSB 0x00 35 #define AUO_PIXCIR_REG_X1_MSB 0x01 36 #define AUO_PIXCIR_REG_Y1_LSB 0x02 37 #define AUO_PIXCIR_REG_Y1_MSB 0x03 38 #define AUO_PIXCIR_REG_X2_LSB 0x04 39 #define AUO_PIXCIR_REG_X2_MSB 0x05 40 #define AUO_PIXCIR_REG_Y2_LSB 0x06 41 #define AUO_PIXCIR_REG_Y2_MSB 0x07 42 43 #define AUO_PIXCIR_REG_STRENGTH 0x0d 44 #define AUO_PIXCIR_REG_STRENGTH_X1_LSB 0x0e 45 #define AUO_PIXCIR_REG_STRENGTH_X1_MSB 0x0f 46 47 #define AUO_PIXCIR_REG_RAW_DATA_X 0x2b 48 #define AUO_PIXCIR_REG_RAW_DATA_Y 0x4f 49 50 #define AUO_PIXCIR_REG_X_SENSITIVITY 0x6f 51 #define AUO_PIXCIR_REG_Y_SENSITIVITY 0x70 52 #define AUO_PIXCIR_REG_INT_SETTING 0x71 53 #define AUO_PIXCIR_REG_INT_WIDTH 0x72 54 #define AUO_PIXCIR_REG_POWER_MODE 0x73 55 56 #define AUO_PIXCIR_REG_VERSION 0x77 57 #define AUO_PIXCIR_REG_CALIBRATE 0x78 58 59 #define AUO_PIXCIR_REG_TOUCHAREA_X1 0x1e 60 #define AUO_PIXCIR_REG_TOUCHAREA_Y1 0x1f 61 #define AUO_PIXCIR_REG_TOUCHAREA_X2 0x20 62 #define AUO_PIXCIR_REG_TOUCHAREA_Y2 0x21 63 64 #define AUO_PIXCIR_REG_EEPROM_CALIB_X 0x42 65 #define AUO_PIXCIR_REG_EEPROM_CALIB_Y 0xad 66 67 #define AUO_PIXCIR_INT_TPNUM_MASK 0xe0 68 #define AUO_PIXCIR_INT_TPNUM_SHIFT 5 69 #define AUO_PIXCIR_INT_RELEASE (1 << 4) 70 #define AUO_PIXCIR_INT_ENABLE (1 << 3) 71 #define AUO_PIXCIR_INT_POL_HIGH (1 << 2) 72 73 /* 74 * Interrupt modes: 75 * periodical: interrupt is asserted periodicaly 76 * compare coordinates: interrupt is asserted when coordinates change 77 * indicate touch: interrupt is asserted during touch 78 */ 79 #define AUO_PIXCIR_INT_PERIODICAL 0x00 80 #define AUO_PIXCIR_INT_COMP_COORD 0x01 81 #define AUO_PIXCIR_INT_TOUCH_IND 0x02 82 #define AUO_PIXCIR_INT_MODE_MASK 0x03 83 84 /* 85 * Power modes: 86 * active: scan speed 60Hz 87 * sleep: scan speed 10Hz can be auto-activated, wakeup on 1st touch 88 * deep sleep: scan speed 1Hz can only be entered or left manually. 89 */ 90 #define AUO_PIXCIR_POWER_ACTIVE 0x00 91 #define AUO_PIXCIR_POWER_SLEEP 0x01 92 #define AUO_PIXCIR_POWER_DEEP_SLEEP 0x02 93 #define AUO_PIXCIR_POWER_MASK 0x03 94 95 #define AUO_PIXCIR_POWER_ALLOW_SLEEP (1 << 2) 96 #define AUO_PIXCIR_POWER_IDLE_TIME(ms) ((ms & 0xf) << 4) 97 98 #define AUO_PIXCIR_CALIBRATE 0x03 99 100 #define AUO_PIXCIR_EEPROM_CALIB_X_LEN 62 101 #define AUO_PIXCIR_EEPROM_CALIB_Y_LEN 36 102 103 #define AUO_PIXCIR_RAW_DATA_X_LEN 18 104 #define AUO_PIXCIR_RAW_DATA_Y_LEN 11 105 106 #define AUO_PIXCIR_STRENGTH_ENABLE (1 << 0) 107 108 /* Touchscreen absolute values */ 109 #define AUO_PIXCIR_REPORT_POINTS 2 110 #define AUO_PIXCIR_MAX_AREA 0xff 111 #define AUO_PIXCIR_PENUP_TIMEOUT_MS 10 112 113 struct auo_pixcir_ts { 114 struct i2c_client *client; 115 struct input_dev *input; 116 struct gpio_desc *gpio_int; 117 struct gpio_desc *gpio_rst; 118 char phys[32]; 119 120 unsigned int x_max; 121 unsigned int y_max; 122 123 /* special handling for touch_indicate interrupt mode */ 124 bool touch_ind_mode; 125 126 wait_queue_head_t wait; 127 bool stopped; 128 }; 129 130 struct auo_point_t { 131 int coord_x; 132 int coord_y; 133 int area_major; 134 int area_minor; 135 int orientation; 136 }; 137 138 static int auo_pixcir_collect_data(struct auo_pixcir_ts *ts, 139 struct auo_point_t *point) 140 { 141 struct i2c_client *client = ts->client; 142 uint8_t raw_coord[8]; 143 uint8_t raw_area[4]; 144 int i, ret; 145 146 /* touch coordinates */ 147 ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_X1_LSB, 148 8, raw_coord); 149 if (ret < 0) { 150 dev_err(&client->dev, "failed to read coordinate, %d\n", ret); 151 return ret; 152 } 153 154 /* touch area */ 155 ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_TOUCHAREA_X1, 156 4, raw_area); 157 if (ret < 0) { 158 dev_err(&client->dev, "could not read touch area, %d\n", ret); 159 return ret; 160 } 161 162 for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) { 163 point[i].coord_x = 164 raw_coord[4 * i + 1] << 8 | raw_coord[4 * i]; 165 point[i].coord_y = 166 raw_coord[4 * i + 3] << 8 | raw_coord[4 * i + 2]; 167 168 if (point[i].coord_x > ts->x_max || 169 point[i].coord_y > ts->y_max) { 170 dev_warn(&client->dev, "coordinates (%d,%d) invalid\n", 171 point[i].coord_x, point[i].coord_y); 172 point[i].coord_x = point[i].coord_y = 0; 173 } 174 175 /* determine touch major, minor and orientation */ 176 point[i].area_major = max(raw_area[2 * i], raw_area[2 * i + 1]); 177 point[i].area_minor = min(raw_area[2 * i], raw_area[2 * i + 1]); 178 point[i].orientation = raw_area[2 * i] > raw_area[2 * i + 1]; 179 } 180 181 return 0; 182 } 183 184 static irqreturn_t auo_pixcir_interrupt(int irq, void *dev_id) 185 { 186 struct auo_pixcir_ts *ts = dev_id; 187 struct auo_point_t point[AUO_PIXCIR_REPORT_POINTS]; 188 int i; 189 int ret; 190 int fingers = 0; 191 int abs = -1; 192 193 while (!ts->stopped) { 194 195 /* check for up event in touch touch_ind_mode */ 196 if (ts->touch_ind_mode) { 197 if (gpiod_get_value_cansleep(ts->gpio_int) == 0) { 198 input_mt_sync(ts->input); 199 input_report_key(ts->input, BTN_TOUCH, 0); 200 input_sync(ts->input); 201 break; 202 } 203 } 204 205 ret = auo_pixcir_collect_data(ts, point); 206 if (ret < 0) { 207 /* we want to loop only in touch_ind_mode */ 208 if (!ts->touch_ind_mode) 209 break; 210 211 wait_event_timeout(ts->wait, ts->stopped, 212 msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS)); 213 continue; 214 } 215 216 for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) { 217 if (point[i].coord_x > 0 || point[i].coord_y > 0) { 218 input_report_abs(ts->input, ABS_MT_POSITION_X, 219 point[i].coord_x); 220 input_report_abs(ts->input, ABS_MT_POSITION_Y, 221 point[i].coord_y); 222 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, 223 point[i].area_major); 224 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, 225 point[i].area_minor); 226 input_report_abs(ts->input, ABS_MT_ORIENTATION, 227 point[i].orientation); 228 input_mt_sync(ts->input); 229 230 /* use first finger as source for singletouch */ 231 if (fingers == 0) 232 abs = i; 233 234 /* number of touch points could also be queried 235 * via i2c but would require an additional call 236 */ 237 fingers++; 238 } 239 } 240 241 input_report_key(ts->input, BTN_TOUCH, fingers > 0); 242 243 if (abs > -1) { 244 input_report_abs(ts->input, ABS_X, point[abs].coord_x); 245 input_report_abs(ts->input, ABS_Y, point[abs].coord_y); 246 } 247 248 input_sync(ts->input); 249 250 /* we want to loop only in touch_ind_mode */ 251 if (!ts->touch_ind_mode) 252 break; 253 254 wait_event_timeout(ts->wait, ts->stopped, 255 msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS)); 256 } 257 258 return IRQ_HANDLED; 259 } 260 261 /* 262 * Set the power mode of the device. 263 * Valid modes are 264 * - AUO_PIXCIR_POWER_ACTIVE 265 * - AUO_PIXCIR_POWER_SLEEP - automatically left on first touch 266 * - AUO_PIXCIR_POWER_DEEP_SLEEP 267 */ 268 static int auo_pixcir_power_mode(struct auo_pixcir_ts *ts, int mode) 269 { 270 struct i2c_client *client = ts->client; 271 int ret; 272 273 ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_POWER_MODE); 274 if (ret < 0) { 275 dev_err(&client->dev, "unable to read reg %Xh, %d\n", 276 AUO_PIXCIR_REG_POWER_MODE, ret); 277 return ret; 278 } 279 280 ret &= ~AUO_PIXCIR_POWER_MASK; 281 ret |= mode; 282 283 ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_POWER_MODE, ret); 284 if (ret) { 285 dev_err(&client->dev, "unable to write reg %Xh, %d\n", 286 AUO_PIXCIR_REG_POWER_MODE, ret); 287 return ret; 288 } 289 290 return 0; 291 } 292 293 static int auo_pixcir_int_config(struct auo_pixcir_ts *ts, int int_setting) 294 { 295 struct i2c_client *client = ts->client; 296 int ret; 297 298 ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING); 299 if (ret < 0) { 300 dev_err(&client->dev, "unable to read reg %Xh, %d\n", 301 AUO_PIXCIR_REG_INT_SETTING, ret); 302 return ret; 303 } 304 305 ret &= ~AUO_PIXCIR_INT_MODE_MASK; 306 ret |= int_setting; 307 ret |= AUO_PIXCIR_INT_POL_HIGH; /* always use high for interrupts */ 308 309 ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING, 310 ret); 311 if (ret < 0) { 312 dev_err(&client->dev, "unable to write reg %Xh, %d\n", 313 AUO_PIXCIR_REG_INT_SETTING, ret); 314 return ret; 315 } 316 317 ts->touch_ind_mode = int_setting == AUO_PIXCIR_INT_TOUCH_IND; 318 319 return 0; 320 } 321 322 /* control the generation of interrupts on the device side */ 323 static int auo_pixcir_int_toggle(struct auo_pixcir_ts *ts, bool enable) 324 { 325 struct i2c_client *client = ts->client; 326 int ret; 327 328 ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING); 329 if (ret < 0) { 330 dev_err(&client->dev, "unable to read reg %Xh, %d\n", 331 AUO_PIXCIR_REG_INT_SETTING, ret); 332 return ret; 333 } 334 335 if (enable) 336 ret |= AUO_PIXCIR_INT_ENABLE; 337 else 338 ret &= ~AUO_PIXCIR_INT_ENABLE; 339 340 ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING, 341 ret); 342 if (ret < 0) { 343 dev_err(&client->dev, "unable to write reg %Xh, %d\n", 344 AUO_PIXCIR_REG_INT_SETTING, ret); 345 return ret; 346 } 347 348 return 0; 349 } 350 351 static int auo_pixcir_start(struct auo_pixcir_ts *ts) 352 { 353 struct i2c_client *client = ts->client; 354 int ret; 355 356 ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_ACTIVE); 357 if (ret < 0) { 358 dev_err(&client->dev, "could not set power mode, %d\n", 359 ret); 360 return ret; 361 } 362 363 ts->stopped = false; 364 mb(); 365 enable_irq(client->irq); 366 367 ret = auo_pixcir_int_toggle(ts, 1); 368 if (ret < 0) { 369 dev_err(&client->dev, "could not enable interrupt, %d\n", 370 ret); 371 disable_irq(client->irq); 372 return ret; 373 } 374 375 return 0; 376 } 377 378 static int auo_pixcir_stop(struct auo_pixcir_ts *ts) 379 { 380 struct i2c_client *client = ts->client; 381 int ret; 382 383 ret = auo_pixcir_int_toggle(ts, 0); 384 if (ret < 0) { 385 dev_err(&client->dev, "could not disable interrupt, %d\n", 386 ret); 387 return ret; 388 } 389 390 /* disable receiving of interrupts */ 391 disable_irq(client->irq); 392 ts->stopped = true; 393 mb(); 394 wake_up(&ts->wait); 395 396 return auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_DEEP_SLEEP); 397 } 398 399 static int auo_pixcir_input_open(struct input_dev *dev) 400 { 401 struct auo_pixcir_ts *ts = input_get_drvdata(dev); 402 403 return auo_pixcir_start(ts); 404 } 405 406 static void auo_pixcir_input_close(struct input_dev *dev) 407 { 408 struct auo_pixcir_ts *ts = input_get_drvdata(dev); 409 410 auo_pixcir_stop(ts); 411 } 412 413 static int __maybe_unused auo_pixcir_suspend(struct device *dev) 414 { 415 struct i2c_client *client = to_i2c_client(dev); 416 struct auo_pixcir_ts *ts = i2c_get_clientdata(client); 417 struct input_dev *input = ts->input; 418 int ret = 0; 419 420 mutex_lock(&input->mutex); 421 422 /* when configured as wakeup source, device should always wake system 423 * therefore start device if necessary 424 */ 425 if (device_may_wakeup(&client->dev)) { 426 /* need to start device if not open, to be wakeup source */ 427 if (!input_device_enabled(input)) { 428 ret = auo_pixcir_start(ts); 429 if (ret) 430 goto unlock; 431 } 432 433 enable_irq_wake(client->irq); 434 ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_SLEEP); 435 } else if (input_device_enabled(input)) { 436 ret = auo_pixcir_stop(ts); 437 } 438 439 unlock: 440 mutex_unlock(&input->mutex); 441 442 return ret; 443 } 444 445 static int __maybe_unused auo_pixcir_resume(struct device *dev) 446 { 447 struct i2c_client *client = to_i2c_client(dev); 448 struct auo_pixcir_ts *ts = i2c_get_clientdata(client); 449 struct input_dev *input = ts->input; 450 int ret = 0; 451 452 mutex_lock(&input->mutex); 453 454 if (device_may_wakeup(&client->dev)) { 455 disable_irq_wake(client->irq); 456 457 /* need to stop device if it was not open on suspend */ 458 if (!input_device_enabled(input)) { 459 ret = auo_pixcir_stop(ts); 460 if (ret) 461 goto unlock; 462 } 463 464 /* device wakes automatically from SLEEP */ 465 } else if (input_device_enabled(input)) { 466 ret = auo_pixcir_start(ts); 467 } 468 469 unlock: 470 mutex_unlock(&input->mutex); 471 472 return ret; 473 } 474 475 static SIMPLE_DEV_PM_OPS(auo_pixcir_pm_ops, 476 auo_pixcir_suspend, auo_pixcir_resume); 477 478 static void auo_pixcir_reset(void *data) 479 { 480 struct auo_pixcir_ts *ts = data; 481 482 gpiod_set_value_cansleep(ts->gpio_rst, 1); 483 } 484 485 static int auo_pixcir_probe(struct i2c_client *client, 486 const struct i2c_device_id *id) 487 { 488 struct auo_pixcir_ts *ts; 489 struct input_dev *input_dev; 490 int version; 491 int error; 492 493 ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); 494 if (!ts) 495 return -ENOMEM; 496 497 input_dev = devm_input_allocate_device(&client->dev); 498 if (!input_dev) { 499 dev_err(&client->dev, "could not allocate input device\n"); 500 return -ENOMEM; 501 } 502 503 ts->client = client; 504 ts->input = input_dev; 505 ts->touch_ind_mode = 0; 506 ts->stopped = true; 507 init_waitqueue_head(&ts->wait); 508 509 snprintf(ts->phys, sizeof(ts->phys), 510 "%s/input0", dev_name(&client->dev)); 511 512 if (device_property_read_u32(&client->dev, "x-size", &ts->x_max)) { 513 dev_err(&client->dev, "failed to get x-size property\n"); 514 return -EINVAL; 515 } 516 517 if (device_property_read_u32(&client->dev, "y-size", &ts->y_max)) { 518 dev_err(&client->dev, "failed to get y-size property\n"); 519 return -EINVAL; 520 } 521 522 input_dev->name = "AUO-Pixcir touchscreen"; 523 input_dev->phys = ts->phys; 524 input_dev->id.bustype = BUS_I2C; 525 526 input_dev->open = auo_pixcir_input_open; 527 input_dev->close = auo_pixcir_input_close; 528 529 __set_bit(EV_ABS, input_dev->evbit); 530 __set_bit(EV_KEY, input_dev->evbit); 531 532 __set_bit(BTN_TOUCH, input_dev->keybit); 533 534 /* For single touch */ 535 input_set_abs_params(input_dev, ABS_X, 0, ts->x_max, 0, 0); 536 input_set_abs_params(input_dev, ABS_Y, 0, ts->y_max, 0, 0); 537 538 /* For multi touch */ 539 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, ts->x_max, 0, 0); 540 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, ts->y_max, 0, 0); 541 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 542 0, AUO_PIXCIR_MAX_AREA, 0, 0); 543 input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 544 0, AUO_PIXCIR_MAX_AREA, 0, 0); 545 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0); 546 547 input_set_drvdata(ts->input, ts); 548 549 ts->gpio_int = devm_gpiod_get_index(&client->dev, NULL, 0, GPIOD_IN); 550 error = PTR_ERR_OR_ZERO(ts->gpio_int); 551 if (error) { 552 dev_err(&client->dev, 553 "request of int gpio failed: %d\n", error); 554 return error; 555 } 556 557 gpiod_set_consumer_name(ts->gpio_int, "auo_pixcir_ts_int"); 558 559 /* Take the chip out of reset */ 560 ts->gpio_rst = devm_gpiod_get_index(&client->dev, NULL, 1, 561 GPIOD_OUT_LOW); 562 error = PTR_ERR_OR_ZERO(ts->gpio_rst); 563 if (error) { 564 dev_err(&client->dev, 565 "request of reset gpio failed: %d\n", error); 566 return error; 567 } 568 569 gpiod_set_consumer_name(ts->gpio_rst, "auo_pixcir_ts_rst"); 570 571 error = devm_add_action_or_reset(&client->dev, auo_pixcir_reset, ts); 572 if (error) { 573 dev_err(&client->dev, "failed to register reset action, %d\n", 574 error); 575 return error; 576 } 577 578 msleep(200); 579 580 version = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_VERSION); 581 if (version < 0) { 582 error = version; 583 return error; 584 } 585 586 dev_info(&client->dev, "firmware version 0x%X\n", version); 587 588 /* default to asserting the interrupt when the screen is touched */ 589 error = auo_pixcir_int_config(ts, AUO_PIXCIR_INT_TOUCH_IND); 590 if (error) 591 return error; 592 593 error = devm_request_threaded_irq(&client->dev, client->irq, 594 NULL, auo_pixcir_interrupt, 595 IRQF_ONESHOT, 596 input_dev->name, ts); 597 if (error) { 598 dev_err(&client->dev, "irq %d requested failed, %d\n", 599 client->irq, error); 600 return error; 601 } 602 603 /* stop device and put it into deep sleep until it is opened */ 604 error = auo_pixcir_stop(ts); 605 if (error) 606 return error; 607 608 error = input_register_device(input_dev); 609 if (error) { 610 dev_err(&client->dev, "could not register input device, %d\n", 611 error); 612 return error; 613 } 614 615 i2c_set_clientdata(client, ts); 616 617 return 0; 618 } 619 620 static const struct i2c_device_id auo_pixcir_idtable[] = { 621 { "auo_pixcir_ts", 0 }, 622 { } 623 }; 624 MODULE_DEVICE_TABLE(i2c, auo_pixcir_idtable); 625 626 #ifdef CONFIG_OF 627 static const struct of_device_id auo_pixcir_ts_dt_idtable[] = { 628 { .compatible = "auo,auo_pixcir_ts" }, 629 {}, 630 }; 631 MODULE_DEVICE_TABLE(of, auo_pixcir_ts_dt_idtable); 632 #endif 633 634 static struct i2c_driver auo_pixcir_driver = { 635 .driver = { 636 .name = "auo_pixcir_ts", 637 .pm = &auo_pixcir_pm_ops, 638 .of_match_table = of_match_ptr(auo_pixcir_ts_dt_idtable), 639 }, 640 .probe = auo_pixcir_probe, 641 .id_table = auo_pixcir_idtable, 642 }; 643 644 module_i2c_driver(auo_pixcir_driver); 645 646 MODULE_DESCRIPTION("AUO-PIXCIR touchscreen driver"); 647 MODULE_LICENSE("GPL v2"); 648 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); 649