1 /* 2 * Driver for Pixcir I2C touchscreen controllers. 3 * 4 * Copyright (C) 2010-2011 Pixcir, Inc. 5 * 6 * This software is licensed under the terms of the GNU General Public 7 * License version 2, as published by the Free Software Foundation, and 8 * may be copied, distributed, and modified under those terms. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public 16 * License along with this library; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 */ 19 20 #include <linux/delay.h> 21 #include <linux/module.h> 22 #include <linux/interrupt.h> 23 #include <linux/slab.h> 24 #include <linux/i2c.h> 25 #include <linux/input.h> 26 #include <linux/input/mt.h> 27 #include <linux/input/touchscreen.h> 28 #include <linux/gpio.h> 29 #include <linux/gpio/consumer.h> 30 /*#include <linux/of.h>*/ 31 #include <linux/of_device.h> 32 #include <linux/platform_data/pixcir_i2c_ts.h> 33 34 #define PIXCIR_MAX_SLOTS 5 /* Max fingers supported by driver */ 35 36 struct pixcir_i2c_ts_data { 37 struct i2c_client *client; 38 struct input_dev *input; 39 struct gpio_desc *gpio_attb; 40 struct gpio_desc *gpio_reset; 41 struct gpio_desc *gpio_enable; 42 struct gpio_desc *gpio_wake; 43 const struct pixcir_i2c_chip_data *chip; 44 int max_fingers; /* Max fingers supported in this instance */ 45 bool running; 46 }; 47 48 struct pixcir_touch { 49 int x; 50 int y; 51 int id; 52 }; 53 54 struct pixcir_report_data { 55 int num_touches; 56 struct pixcir_touch touches[PIXCIR_MAX_SLOTS]; 57 }; 58 59 static void pixcir_ts_parse(struct pixcir_i2c_ts_data *tsdata, 60 struct pixcir_report_data *report) 61 { 62 u8 rdbuf[2 + PIXCIR_MAX_SLOTS * 5]; 63 u8 wrbuf[1] = { 0 }; 64 u8 *bufptr; 65 u8 touch; 66 int ret, i; 67 int readsize; 68 const struct pixcir_i2c_chip_data *chip = tsdata->chip; 69 70 memset(report, 0, sizeof(struct pixcir_report_data)); 71 72 i = chip->has_hw_ids ? 1 : 0; 73 readsize = 2 + tsdata->max_fingers * (4 + i); 74 if (readsize > sizeof(rdbuf)) 75 readsize = sizeof(rdbuf); 76 77 ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf)); 78 if (ret != sizeof(wrbuf)) { 79 dev_err(&tsdata->client->dev, 80 "%s: i2c_master_send failed(), ret=%d\n", 81 __func__, ret); 82 return; 83 } 84 85 ret = i2c_master_recv(tsdata->client, rdbuf, readsize); 86 if (ret != readsize) { 87 dev_err(&tsdata->client->dev, 88 "%s: i2c_master_recv failed(), ret=%d\n", 89 __func__, ret); 90 return; 91 } 92 93 touch = rdbuf[0] & 0x7; 94 if (touch > tsdata->max_fingers) 95 touch = tsdata->max_fingers; 96 97 report->num_touches = touch; 98 bufptr = &rdbuf[2]; 99 100 for (i = 0; i < touch; i++) { 101 report->touches[i].x = (bufptr[1] << 8) | bufptr[0]; 102 report->touches[i].y = (bufptr[3] << 8) | bufptr[2]; 103 104 if (chip->has_hw_ids) { 105 report->touches[i].id = bufptr[4]; 106 bufptr = bufptr + 5; 107 } else { 108 bufptr = bufptr + 4; 109 } 110 } 111 } 112 113 static void pixcir_ts_report(struct pixcir_i2c_ts_data *ts, 114 struct pixcir_report_data *report) 115 { 116 struct input_mt_pos pos[PIXCIR_MAX_SLOTS]; 117 int slots[PIXCIR_MAX_SLOTS]; 118 struct pixcir_touch *touch; 119 int n, i, slot; 120 struct device *dev = &ts->client->dev; 121 const struct pixcir_i2c_chip_data *chip = ts->chip; 122 123 n = report->num_touches; 124 if (n > PIXCIR_MAX_SLOTS) 125 n = PIXCIR_MAX_SLOTS; 126 127 if (!ts->chip->has_hw_ids) { 128 for (i = 0; i < n; i++) { 129 touch = &report->touches[i]; 130 pos[i].x = touch->x; 131 pos[i].y = touch->y; 132 } 133 134 input_mt_assign_slots(ts->input, slots, pos, n, 0); 135 } 136 137 for (i = 0; i < n; i++) { 138 touch = &report->touches[i]; 139 140 if (chip->has_hw_ids) { 141 slot = input_mt_get_slot_by_key(ts->input, touch->id); 142 if (slot < 0) { 143 dev_dbg(dev, "no free slot for id 0x%x\n", 144 touch->id); 145 continue; 146 } 147 } else { 148 slot = slots[i]; 149 } 150 151 input_mt_slot(ts->input, slot); 152 input_mt_report_slot_state(ts->input, 153 MT_TOOL_FINGER, true); 154 155 input_event(ts->input, EV_ABS, ABS_MT_POSITION_X, touch->x); 156 input_event(ts->input, EV_ABS, ABS_MT_POSITION_Y, touch->y); 157 158 dev_dbg(dev, "%d: slot %d, x %d, y %d\n", 159 i, slot, touch->x, touch->y); 160 } 161 162 input_mt_sync_frame(ts->input); 163 input_sync(ts->input); 164 } 165 166 static irqreturn_t pixcir_ts_isr(int irq, void *dev_id) 167 { 168 struct pixcir_i2c_ts_data *tsdata = dev_id; 169 struct pixcir_report_data report; 170 171 while (tsdata->running) { 172 /* parse packet */ 173 pixcir_ts_parse(tsdata, &report); 174 175 /* report it */ 176 pixcir_ts_report(tsdata, &report); 177 178 if (gpiod_get_value_cansleep(tsdata->gpio_attb)) { 179 if (report.num_touches) { 180 /* 181 * Last report with no finger up? 182 * Do it now then. 183 */ 184 input_mt_sync_frame(tsdata->input); 185 input_sync(tsdata->input); 186 } 187 break; 188 } 189 190 msleep(20); 191 } 192 193 return IRQ_HANDLED; 194 } 195 196 static void pixcir_reset(struct pixcir_i2c_ts_data *tsdata) 197 { 198 if (!IS_ERR_OR_NULL(tsdata->gpio_reset)) { 199 gpiod_set_value_cansleep(tsdata->gpio_reset, 1); 200 ndelay(100); /* datasheet section 1.2.3 says 80ns min. */ 201 gpiod_set_value_cansleep(tsdata->gpio_reset, 0); 202 /* wait for controller ready. 100ms guess. */ 203 msleep(100); 204 } 205 } 206 207 static int pixcir_set_power_mode(struct pixcir_i2c_ts_data *ts, 208 enum pixcir_power_mode mode) 209 { 210 struct device *dev = &ts->client->dev; 211 int ret; 212 213 if (mode == PIXCIR_POWER_ACTIVE || mode == PIXCIR_POWER_IDLE) { 214 if (ts->gpio_wake) 215 gpiod_set_value_cansleep(ts->gpio_wake, 1); 216 } 217 218 ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_POWER_MODE); 219 if (ret < 0) { 220 dev_err(dev, "%s: can't read reg 0x%x : %d\n", 221 __func__, PIXCIR_REG_POWER_MODE, ret); 222 return ret; 223 } 224 225 ret &= ~PIXCIR_POWER_MODE_MASK; 226 ret |= mode; 227 228 /* Always AUTO_IDLE */ 229 ret |= PIXCIR_POWER_ALLOW_IDLE; 230 231 ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_POWER_MODE, ret); 232 if (ret < 0) { 233 dev_err(dev, "%s: can't write reg 0x%x : %d\n", 234 __func__, PIXCIR_REG_POWER_MODE, ret); 235 return ret; 236 } 237 238 if (mode == PIXCIR_POWER_HALT) { 239 if (ts->gpio_wake) 240 gpiod_set_value_cansleep(ts->gpio_wake, 0); 241 } 242 243 return 0; 244 } 245 246 /* 247 * Set the interrupt mode for the device i.e. ATTB line behaviour 248 * 249 * @polarity : 1 for active high, 0 for active low. 250 */ 251 static int pixcir_set_int_mode(struct pixcir_i2c_ts_data *ts, 252 enum pixcir_int_mode mode, bool polarity) 253 { 254 struct device *dev = &ts->client->dev; 255 int ret; 256 257 ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE); 258 if (ret < 0) { 259 dev_err(dev, "%s: can't read reg 0x%x : %d\n", 260 __func__, PIXCIR_REG_INT_MODE, ret); 261 return ret; 262 } 263 264 ret &= ~PIXCIR_INT_MODE_MASK; 265 ret |= mode; 266 267 if (polarity) 268 ret |= PIXCIR_INT_POL_HIGH; 269 else 270 ret &= ~PIXCIR_INT_POL_HIGH; 271 272 ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret); 273 if (ret < 0) { 274 dev_err(dev, "%s: can't write reg 0x%x : %d\n", 275 __func__, PIXCIR_REG_INT_MODE, ret); 276 return ret; 277 } 278 279 return 0; 280 } 281 282 /* 283 * Enable/disable interrupt generation 284 */ 285 static int pixcir_int_enable(struct pixcir_i2c_ts_data *ts, bool enable) 286 { 287 struct device *dev = &ts->client->dev; 288 int ret; 289 290 ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE); 291 if (ret < 0) { 292 dev_err(dev, "%s: can't read reg 0x%x : %d\n", 293 __func__, PIXCIR_REG_INT_MODE, ret); 294 return ret; 295 } 296 297 if (enable) 298 ret |= PIXCIR_INT_ENABLE; 299 else 300 ret &= ~PIXCIR_INT_ENABLE; 301 302 ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret); 303 if (ret < 0) { 304 dev_err(dev, "%s: can't write reg 0x%x : %d\n", 305 __func__, PIXCIR_REG_INT_MODE, ret); 306 return ret; 307 } 308 309 return 0; 310 } 311 312 static int pixcir_start(struct pixcir_i2c_ts_data *ts) 313 { 314 struct device *dev = &ts->client->dev; 315 int error; 316 317 if (ts->gpio_enable) { 318 gpiod_set_value_cansleep(ts->gpio_enable, 1); 319 msleep(100); 320 } 321 322 /* LEVEL_TOUCH interrupt with active low polarity */ 323 error = pixcir_set_int_mode(ts, PIXCIR_INT_LEVEL_TOUCH, 0); 324 if (error) { 325 dev_err(dev, "Failed to set interrupt mode: %d\n", error); 326 return error; 327 } 328 329 ts->running = true; 330 mb(); /* Update status before IRQ can fire */ 331 332 /* enable interrupt generation */ 333 error = pixcir_int_enable(ts, true); 334 if (error) { 335 dev_err(dev, "Failed to enable interrupt generation: %d\n", 336 error); 337 return error; 338 } 339 340 return 0; 341 } 342 343 static int pixcir_stop(struct pixcir_i2c_ts_data *ts) 344 { 345 int error; 346 347 /* Disable interrupt generation */ 348 error = pixcir_int_enable(ts, false); 349 if (error) { 350 dev_err(&ts->client->dev, 351 "Failed to disable interrupt generation: %d\n", 352 error); 353 return error; 354 } 355 356 /* Exit ISR if running, no more report parsing */ 357 ts->running = false; 358 mb(); /* update status before we synchronize irq */ 359 360 /* Wait till running ISR is complete */ 361 synchronize_irq(ts->client->irq); 362 363 if (ts->gpio_enable) 364 gpiod_set_value_cansleep(ts->gpio_enable, 0); 365 366 return 0; 367 } 368 369 static int pixcir_input_open(struct input_dev *dev) 370 { 371 struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev); 372 373 return pixcir_start(ts); 374 } 375 376 static void pixcir_input_close(struct input_dev *dev) 377 { 378 struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev); 379 380 pixcir_stop(ts); 381 } 382 383 static int __maybe_unused pixcir_i2c_ts_suspend(struct device *dev) 384 { 385 struct i2c_client *client = to_i2c_client(dev); 386 struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client); 387 struct input_dev *input = ts->input; 388 int ret = 0; 389 390 mutex_lock(&input->mutex); 391 392 if (device_may_wakeup(&client->dev)) { 393 if (!input->users) { 394 ret = pixcir_start(ts); 395 if (ret) { 396 dev_err(dev, "Failed to start\n"); 397 goto unlock; 398 } 399 } 400 } else if (input->users) { 401 ret = pixcir_stop(ts); 402 } 403 404 unlock: 405 mutex_unlock(&input->mutex); 406 407 return ret; 408 } 409 410 static int __maybe_unused pixcir_i2c_ts_resume(struct device *dev) 411 { 412 struct i2c_client *client = to_i2c_client(dev); 413 struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client); 414 struct input_dev *input = ts->input; 415 int ret = 0; 416 417 mutex_lock(&input->mutex); 418 419 if (device_may_wakeup(&client->dev)) { 420 421 if (!input->users) { 422 ret = pixcir_stop(ts); 423 if (ret) { 424 dev_err(dev, "Failed to stop\n"); 425 goto unlock; 426 } 427 } 428 } else if (input->users) { 429 ret = pixcir_start(ts); 430 } 431 432 unlock: 433 mutex_unlock(&input->mutex); 434 435 return ret; 436 } 437 438 static SIMPLE_DEV_PM_OPS(pixcir_dev_pm_ops, 439 pixcir_i2c_ts_suspend, pixcir_i2c_ts_resume); 440 441 #ifdef CONFIG_OF 442 static const struct of_device_id pixcir_of_match[]; 443 444 static int pixcir_parse_dt(struct device *dev, 445 struct pixcir_i2c_ts_data *tsdata) 446 { 447 const struct of_device_id *match; 448 449 match = of_match_device(of_match_ptr(pixcir_of_match), dev); 450 if (!match) 451 return -EINVAL; 452 453 tsdata->chip = (const struct pixcir_i2c_chip_data *)match->data; 454 if (!tsdata->chip) 455 return -EINVAL; 456 457 return 0; 458 } 459 #else 460 static int pixcir_parse_dt(struct device *dev, 461 struct pixcir_i2c_ts_data *tsdata) 462 { 463 return -EINVAL; 464 } 465 #endif 466 467 static int pixcir_i2c_ts_probe(struct i2c_client *client, 468 const struct i2c_device_id *id) 469 { 470 const struct pixcir_ts_platform_data *pdata = 471 dev_get_platdata(&client->dev); 472 struct device *dev = &client->dev; 473 struct pixcir_i2c_ts_data *tsdata; 474 struct input_dev *input; 475 int error; 476 477 tsdata = devm_kzalloc(dev, sizeof(*tsdata), GFP_KERNEL); 478 if (!tsdata) 479 return -ENOMEM; 480 481 if (pdata) { 482 tsdata->chip = &pdata->chip; 483 } else if (dev->of_node) { 484 error = pixcir_parse_dt(dev, tsdata); 485 if (error) 486 return error; 487 } else { 488 dev_err(&client->dev, "platform data not defined\n"); 489 return -EINVAL; 490 } 491 492 if (!tsdata->chip->max_fingers) { 493 dev_err(dev, "Invalid max_fingers in chip data\n"); 494 return -EINVAL; 495 } 496 497 input = devm_input_allocate_device(dev); 498 if (!input) { 499 dev_err(dev, "Failed to allocate input device\n"); 500 return -ENOMEM; 501 } 502 503 tsdata->client = client; 504 tsdata->input = input; 505 506 input->name = client->name; 507 input->id.bustype = BUS_I2C; 508 input->open = pixcir_input_open; 509 input->close = pixcir_input_close; 510 input->dev.parent = &client->dev; 511 512 if (pdata) { 513 input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->x_max, 0, 0); 514 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->y_max, 0, 0); 515 } else { 516 input_set_capability(input, EV_ABS, ABS_MT_POSITION_X); 517 input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y); 518 touchscreen_parse_properties(input, true); 519 if (!input_abs_get_max(input, ABS_MT_POSITION_X) || 520 !input_abs_get_max(input, ABS_MT_POSITION_Y)) { 521 dev_err(dev, "Touchscreen size is not specified\n"); 522 return -EINVAL; 523 } 524 } 525 526 tsdata->max_fingers = tsdata->chip->max_fingers; 527 if (tsdata->max_fingers > PIXCIR_MAX_SLOTS) { 528 tsdata->max_fingers = PIXCIR_MAX_SLOTS; 529 dev_info(dev, "Limiting maximum fingers to %d\n", 530 tsdata->max_fingers); 531 } 532 533 error = input_mt_init_slots(input, tsdata->max_fingers, 534 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 535 if (error) { 536 dev_err(dev, "Error initializing Multi-Touch slots\n"); 537 return error; 538 } 539 540 input_set_drvdata(input, tsdata); 541 542 tsdata->gpio_attb = devm_gpiod_get(dev, "attb", GPIOD_IN); 543 if (IS_ERR(tsdata->gpio_attb)) { 544 error = PTR_ERR(tsdata->gpio_attb); 545 dev_err(dev, "Failed to request ATTB gpio: %d\n", error); 546 return error; 547 } 548 549 tsdata->gpio_reset = devm_gpiod_get_optional(dev, "reset", 550 GPIOD_OUT_LOW); 551 if (IS_ERR(tsdata->gpio_reset)) { 552 error = PTR_ERR(tsdata->gpio_reset); 553 dev_err(dev, "Failed to request RESET gpio: %d\n", error); 554 return error; 555 } 556 557 tsdata->gpio_wake = devm_gpiod_get_optional(dev, "wake", 558 GPIOD_OUT_HIGH); 559 if (IS_ERR(tsdata->gpio_wake)) { 560 error = PTR_ERR(tsdata->gpio_wake); 561 if (error != -EPROBE_DEFER) 562 dev_err(dev, "Failed to get wake gpio: %d\n", error); 563 return error; 564 } 565 566 tsdata->gpio_enable = devm_gpiod_get_optional(dev, "enable", 567 GPIOD_OUT_HIGH); 568 if (IS_ERR(tsdata->gpio_enable)) { 569 error = PTR_ERR(tsdata->gpio_enable); 570 if (error != -EPROBE_DEFER) 571 dev_err(dev, "Failed to get enable gpio: %d\n", error); 572 return error; 573 } 574 575 if (tsdata->gpio_enable) 576 msleep(100); 577 578 error = devm_request_threaded_irq(dev, client->irq, NULL, pixcir_ts_isr, 579 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 580 client->name, tsdata); 581 if (error) { 582 dev_err(dev, "failed to request irq %d\n", client->irq); 583 return error; 584 } 585 586 pixcir_reset(tsdata); 587 588 /* Always be in IDLE mode to save power, device supports auto wake */ 589 error = pixcir_set_power_mode(tsdata, PIXCIR_POWER_IDLE); 590 if (error) { 591 dev_err(dev, "Failed to set IDLE mode\n"); 592 return error; 593 } 594 595 /* Stop device till opened */ 596 error = pixcir_stop(tsdata); 597 if (error) 598 return error; 599 600 error = input_register_device(input); 601 if (error) 602 return error; 603 604 i2c_set_clientdata(client, tsdata); 605 606 return 0; 607 } 608 609 static const struct i2c_device_id pixcir_i2c_ts_id[] = { 610 { "pixcir_ts", 0 }, 611 { "pixcir_tangoc", 0 }, 612 { } 613 }; 614 MODULE_DEVICE_TABLE(i2c, pixcir_i2c_ts_id); 615 616 #ifdef CONFIG_OF 617 static const struct pixcir_i2c_chip_data pixcir_ts_data = { 618 .max_fingers = 2, 619 /* no hw id support */ 620 }; 621 622 static const struct pixcir_i2c_chip_data pixcir_tangoc_data = { 623 .max_fingers = 5, 624 .has_hw_ids = true, 625 }; 626 627 static const struct of_device_id pixcir_of_match[] = { 628 { .compatible = "pixcir,pixcir_ts", .data = &pixcir_ts_data }, 629 { .compatible = "pixcir,pixcir_tangoc", .data = &pixcir_tangoc_data }, 630 { } 631 }; 632 MODULE_DEVICE_TABLE(of, pixcir_of_match); 633 #endif 634 635 static struct i2c_driver pixcir_i2c_ts_driver = { 636 .driver = { 637 .name = "pixcir_ts", 638 .pm = &pixcir_dev_pm_ops, 639 .of_match_table = of_match_ptr(pixcir_of_match), 640 }, 641 .probe = pixcir_i2c_ts_probe, 642 .id_table = pixcir_i2c_ts_id, 643 }; 644 645 module_i2c_driver(pixcir_i2c_ts_driver); 646 647 MODULE_AUTHOR("Jianchun Bian <jcbian@pixcir.com.cn>, Dequan Meng <dqmeng@pixcir.com.cn>"); 648 MODULE_DESCRIPTION("Pixcir I2C Touchscreen Driver"); 649 MODULE_LICENSE("GPL"); 650