1 /* 2 * Copyright (C) 2012-2013 MundoReader S.L. 3 * Author: Heiko Stuebner <heiko@sntech.de> 4 * 5 * based in parts on Nook zforce driver 6 * 7 * Copyright (C) 2010 Barnes & Noble, Inc. 8 * Author: Pieter Truter<ptruter@intrinsyc.com> 9 * 10 * This software is licensed under the terms of the GNU General Public 11 * License version 2, as published by the Free Software Foundation, and 12 * may be copied, distributed, and modified under those terms. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 */ 19 20 #include <linux/module.h> 21 #include <linux/hrtimer.h> 22 #include <linux/slab.h> 23 #include <linux/input.h> 24 #include <linux/interrupt.h> 25 #include <linux/i2c.h> 26 #include <linux/delay.h> 27 #include <linux/gpio.h> 28 #include <linux/device.h> 29 #include <linux/sysfs.h> 30 #include <linux/input/mt.h> 31 #include <linux/platform_data/zforce_ts.h> 32 #include <linux/of.h> 33 #include <linux/of_gpio.h> 34 35 #define WAIT_TIMEOUT msecs_to_jiffies(1000) 36 37 #define FRAME_START 0xee 38 #define FRAME_MAXSIZE 257 39 40 /* Offsets of the different parts of the payload the controller sends */ 41 #define PAYLOAD_HEADER 0 42 #define PAYLOAD_LENGTH 1 43 #define PAYLOAD_BODY 2 44 45 /* Response offsets */ 46 #define RESPONSE_ID 0 47 #define RESPONSE_DATA 1 48 49 /* Commands */ 50 #define COMMAND_DEACTIVATE 0x00 51 #define COMMAND_INITIALIZE 0x01 52 #define COMMAND_RESOLUTION 0x02 53 #define COMMAND_SETCONFIG 0x03 54 #define COMMAND_DATAREQUEST 0x04 55 #define COMMAND_SCANFREQ 0x08 56 #define COMMAND_STATUS 0X1e 57 58 /* 59 * Responses the controller sends as a result of 60 * command requests 61 */ 62 #define RESPONSE_DEACTIVATE 0x00 63 #define RESPONSE_INITIALIZE 0x01 64 #define RESPONSE_RESOLUTION 0x02 65 #define RESPONSE_SETCONFIG 0x03 66 #define RESPONSE_SCANFREQ 0x08 67 #define RESPONSE_STATUS 0X1e 68 69 /* 70 * Notifications are sent by the touch controller without 71 * being requested by the driver and include for example 72 * touch indications 73 */ 74 #define NOTIFICATION_TOUCH 0x04 75 #define NOTIFICATION_BOOTCOMPLETE 0x07 76 #define NOTIFICATION_OVERRUN 0x25 77 #define NOTIFICATION_PROXIMITY 0x26 78 #define NOTIFICATION_INVALID_COMMAND 0xfe 79 80 #define ZFORCE_REPORT_POINTS 2 81 #define ZFORCE_MAX_AREA 0xff 82 83 #define STATE_DOWN 0 84 #define STATE_MOVE 1 85 #define STATE_UP 2 86 87 #define SETCONFIG_DUALTOUCH (1 << 0) 88 89 struct zforce_point { 90 int coord_x; 91 int coord_y; 92 int state; 93 int id; 94 int area_major; 95 int area_minor; 96 int orientation; 97 int pressure; 98 int prblty; 99 }; 100 101 /* 102 * @client the i2c_client 103 * @input the input device 104 * @suspending in the process of going to suspend (don't emit wakeup 105 * events for commands executed to suspend the device) 106 * @suspended device suspended 107 * @access_mutex serialize i2c-access, to keep multipart reads together 108 * @command_done completion to wait for the command result 109 * @command_mutex serialize commands sent to the ic 110 * @command_waiting the id of the command that is currently waiting 111 * for a result 112 * @command_result returned result of the command 113 */ 114 struct zforce_ts { 115 struct i2c_client *client; 116 struct input_dev *input; 117 const struct zforce_ts_platdata *pdata; 118 char phys[32]; 119 120 bool suspending; 121 bool suspended; 122 bool boot_complete; 123 124 /* Firmware version information */ 125 u16 version_major; 126 u16 version_minor; 127 u16 version_build; 128 u16 version_rev; 129 130 struct mutex access_mutex; 131 132 struct completion command_done; 133 struct mutex command_mutex; 134 int command_waiting; 135 int command_result; 136 }; 137 138 static int zforce_command(struct zforce_ts *ts, u8 cmd) 139 { 140 struct i2c_client *client = ts->client; 141 char buf[3]; 142 int ret; 143 144 dev_dbg(&client->dev, "%s: 0x%x\n", __func__, cmd); 145 146 buf[0] = FRAME_START; 147 buf[1] = 1; /* data size, command only */ 148 buf[2] = cmd; 149 150 mutex_lock(&ts->access_mutex); 151 ret = i2c_master_send(client, &buf[0], ARRAY_SIZE(buf)); 152 mutex_unlock(&ts->access_mutex); 153 if (ret < 0) { 154 dev_err(&client->dev, "i2c send data request error: %d\n", ret); 155 return ret; 156 } 157 158 return 0; 159 } 160 161 static int zforce_send_wait(struct zforce_ts *ts, const char *buf, int len) 162 { 163 struct i2c_client *client = ts->client; 164 int ret; 165 166 ret = mutex_trylock(&ts->command_mutex); 167 if (!ret) { 168 dev_err(&client->dev, "already waiting for a command\n"); 169 return -EBUSY; 170 } 171 172 dev_dbg(&client->dev, "sending %d bytes for command 0x%x\n", 173 buf[1], buf[2]); 174 175 ts->command_waiting = buf[2]; 176 177 mutex_lock(&ts->access_mutex); 178 ret = i2c_master_send(client, buf, len); 179 mutex_unlock(&ts->access_mutex); 180 if (ret < 0) { 181 dev_err(&client->dev, "i2c send data request error: %d\n", ret); 182 goto unlock; 183 } 184 185 dev_dbg(&client->dev, "waiting for result for command 0x%x\n", buf[2]); 186 187 if (wait_for_completion_timeout(&ts->command_done, WAIT_TIMEOUT) == 0) { 188 ret = -ETIME; 189 goto unlock; 190 } 191 192 ret = ts->command_result; 193 194 unlock: 195 mutex_unlock(&ts->command_mutex); 196 return ret; 197 } 198 199 static int zforce_command_wait(struct zforce_ts *ts, u8 cmd) 200 { 201 struct i2c_client *client = ts->client; 202 char buf[3]; 203 int ret; 204 205 dev_dbg(&client->dev, "%s: 0x%x\n", __func__, cmd); 206 207 buf[0] = FRAME_START; 208 buf[1] = 1; /* data size, command only */ 209 buf[2] = cmd; 210 211 ret = zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf)); 212 if (ret < 0) { 213 dev_err(&client->dev, "i2c send data request error: %d\n", ret); 214 return ret; 215 } 216 217 return 0; 218 } 219 220 static int zforce_resolution(struct zforce_ts *ts, u16 x, u16 y) 221 { 222 struct i2c_client *client = ts->client; 223 char buf[7] = { FRAME_START, 5, COMMAND_RESOLUTION, 224 (x & 0xff), ((x >> 8) & 0xff), 225 (y & 0xff), ((y >> 8) & 0xff) }; 226 227 dev_dbg(&client->dev, "set resolution to (%d,%d)\n", x, y); 228 229 return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf)); 230 } 231 232 static int zforce_scan_frequency(struct zforce_ts *ts, u16 idle, u16 finger, 233 u16 stylus) 234 { 235 struct i2c_client *client = ts->client; 236 char buf[9] = { FRAME_START, 7, COMMAND_SCANFREQ, 237 (idle & 0xff), ((idle >> 8) & 0xff), 238 (finger & 0xff), ((finger >> 8) & 0xff), 239 (stylus & 0xff), ((stylus >> 8) & 0xff) }; 240 241 dev_dbg(&client->dev, 242 "set scan frequency to (idle: %d, finger: %d, stylus: %d)\n", 243 idle, finger, stylus); 244 245 return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf)); 246 } 247 248 static int zforce_setconfig(struct zforce_ts *ts, char b1) 249 { 250 struct i2c_client *client = ts->client; 251 char buf[7] = { FRAME_START, 5, COMMAND_SETCONFIG, 252 b1, 0, 0, 0 }; 253 254 dev_dbg(&client->dev, "set config to (%d)\n", b1); 255 256 return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf)); 257 } 258 259 static int zforce_start(struct zforce_ts *ts) 260 { 261 struct i2c_client *client = ts->client; 262 const struct zforce_ts_platdata *pdata = ts->pdata; 263 int ret; 264 265 dev_dbg(&client->dev, "starting device\n"); 266 267 ret = zforce_command_wait(ts, COMMAND_INITIALIZE); 268 if (ret) { 269 dev_err(&client->dev, "Unable to initialize, %d\n", ret); 270 return ret; 271 } 272 273 ret = zforce_resolution(ts, pdata->x_max, pdata->y_max); 274 if (ret) { 275 dev_err(&client->dev, "Unable to set resolution, %d\n", ret); 276 goto error; 277 } 278 279 ret = zforce_scan_frequency(ts, 10, 50, 50); 280 if (ret) { 281 dev_err(&client->dev, "Unable to set scan frequency, %d\n", 282 ret); 283 goto error; 284 } 285 286 ret = zforce_setconfig(ts, SETCONFIG_DUALTOUCH); 287 if (ret) { 288 dev_err(&client->dev, "Unable to set config\n"); 289 goto error; 290 } 291 292 /* start sending touch events */ 293 ret = zforce_command(ts, COMMAND_DATAREQUEST); 294 if (ret) { 295 dev_err(&client->dev, "Unable to request data\n"); 296 goto error; 297 } 298 299 /* 300 * Per NN, initial cal. take max. of 200msec. 301 * Allow time to complete this calibration 302 */ 303 msleep(200); 304 305 return 0; 306 307 error: 308 zforce_command_wait(ts, COMMAND_DEACTIVATE); 309 return ret; 310 } 311 312 static int zforce_stop(struct zforce_ts *ts) 313 { 314 struct i2c_client *client = ts->client; 315 int ret; 316 317 dev_dbg(&client->dev, "stopping device\n"); 318 319 /* Deactivates touch sensing and puts the device into sleep. */ 320 ret = zforce_command_wait(ts, COMMAND_DEACTIVATE); 321 if (ret != 0) { 322 dev_err(&client->dev, "could not deactivate device, %d\n", 323 ret); 324 return ret; 325 } 326 327 return 0; 328 } 329 330 static int zforce_touch_event(struct zforce_ts *ts, u8 *payload) 331 { 332 struct i2c_client *client = ts->client; 333 const struct zforce_ts_platdata *pdata = ts->pdata; 334 struct zforce_point point; 335 int count, i, num = 0; 336 337 count = payload[0]; 338 if (count > ZFORCE_REPORT_POINTS) { 339 dev_warn(&client->dev, 340 "too many coordinates %d, expected max %d\n", 341 count, ZFORCE_REPORT_POINTS); 342 count = ZFORCE_REPORT_POINTS; 343 } 344 345 for (i = 0; i < count; i++) { 346 point.coord_x = 347 payload[9 * i + 2] << 8 | payload[9 * i + 1]; 348 point.coord_y = 349 payload[9 * i + 4] << 8 | payload[9 * i + 3]; 350 351 if (point.coord_x > pdata->x_max || 352 point.coord_y > pdata->y_max) { 353 dev_warn(&client->dev, "coordinates (%d,%d) invalid\n", 354 point.coord_x, point.coord_y); 355 point.coord_x = point.coord_y = 0; 356 } 357 358 point.state = payload[9 * i + 5] & 0x03; 359 point.id = (payload[9 * i + 5] & 0xfc) >> 2; 360 361 /* determine touch major, minor and orientation */ 362 point.area_major = max(payload[9 * i + 6], 363 payload[9 * i + 7]); 364 point.area_minor = min(payload[9 * i + 6], 365 payload[9 * i + 7]); 366 point.orientation = payload[9 * i + 6] > payload[9 * i + 7]; 367 368 point.pressure = payload[9 * i + 8]; 369 point.prblty = payload[9 * i + 9]; 370 371 dev_dbg(&client->dev, 372 "point %d/%d: state %d, id %d, pressure %d, prblty %d, x %d, y %d, amajor %d, aminor %d, ori %d\n", 373 i, count, point.state, point.id, 374 point.pressure, point.prblty, 375 point.coord_x, point.coord_y, 376 point.area_major, point.area_minor, 377 point.orientation); 378 379 /* the zforce id starts with "1", so needs to be decreased */ 380 input_mt_slot(ts->input, point.id - 1); 381 382 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, 383 point.state != STATE_UP); 384 385 if (point.state != STATE_UP) { 386 input_report_abs(ts->input, ABS_MT_POSITION_X, 387 point.coord_x); 388 input_report_abs(ts->input, ABS_MT_POSITION_Y, 389 point.coord_y); 390 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, 391 point.area_major); 392 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, 393 point.area_minor); 394 input_report_abs(ts->input, ABS_MT_ORIENTATION, 395 point.orientation); 396 num++; 397 } 398 } 399 400 input_mt_sync_frame(ts->input); 401 402 input_mt_report_finger_count(ts->input, num); 403 404 input_sync(ts->input); 405 406 return 0; 407 } 408 409 static int zforce_read_packet(struct zforce_ts *ts, u8 *buf) 410 { 411 struct i2c_client *client = ts->client; 412 int ret; 413 414 mutex_lock(&ts->access_mutex); 415 416 /* read 2 byte message header */ 417 ret = i2c_master_recv(client, buf, 2); 418 if (ret < 0) { 419 dev_err(&client->dev, "error reading header: %d\n", ret); 420 goto unlock; 421 } 422 423 if (buf[PAYLOAD_HEADER] != FRAME_START) { 424 dev_err(&client->dev, "invalid frame start: %d\n", buf[0]); 425 ret = -EIO; 426 goto unlock; 427 } 428 429 if (buf[PAYLOAD_LENGTH] == 0) { 430 dev_err(&client->dev, "invalid payload length: %d\n", 431 buf[PAYLOAD_LENGTH]); 432 ret = -EIO; 433 goto unlock; 434 } 435 436 /* read the message */ 437 ret = i2c_master_recv(client, &buf[PAYLOAD_BODY], buf[PAYLOAD_LENGTH]); 438 if (ret < 0) { 439 dev_err(&client->dev, "error reading payload: %d\n", ret); 440 goto unlock; 441 } 442 443 dev_dbg(&client->dev, "read %d bytes for response command 0x%x\n", 444 buf[PAYLOAD_LENGTH], buf[PAYLOAD_BODY]); 445 446 unlock: 447 mutex_unlock(&ts->access_mutex); 448 return ret; 449 } 450 451 static void zforce_complete(struct zforce_ts *ts, int cmd, int result) 452 { 453 struct i2c_client *client = ts->client; 454 455 if (ts->command_waiting == cmd) { 456 dev_dbg(&client->dev, "completing command 0x%x\n", cmd); 457 ts->command_result = result; 458 complete(&ts->command_done); 459 } else { 460 dev_dbg(&client->dev, "command %d not for us\n", cmd); 461 } 462 } 463 464 static irqreturn_t zforce_irq(int irq, void *dev_id) 465 { 466 struct zforce_ts *ts = dev_id; 467 struct i2c_client *client = ts->client; 468 469 if (ts->suspended && device_may_wakeup(&client->dev)) 470 pm_wakeup_event(&client->dev, 500); 471 472 return IRQ_WAKE_THREAD; 473 } 474 475 static irqreturn_t zforce_irq_thread(int irq, void *dev_id) 476 { 477 struct zforce_ts *ts = dev_id; 478 struct i2c_client *client = ts->client; 479 const struct zforce_ts_platdata *pdata = ts->pdata; 480 int ret; 481 u8 payload_buffer[FRAME_MAXSIZE]; 482 u8 *payload; 483 484 /* 485 * When still suspended, return. 486 * Due to the level-interrupt we will get re-triggered later. 487 */ 488 if (ts->suspended) { 489 msleep(20); 490 return IRQ_HANDLED; 491 } 492 493 dev_dbg(&client->dev, "handling interrupt\n"); 494 495 /* Don't emit wakeup events from commands run by zforce_suspend */ 496 if (!ts->suspending && device_may_wakeup(&client->dev)) 497 pm_stay_awake(&client->dev); 498 499 while (!gpio_get_value(pdata->gpio_int)) { 500 ret = zforce_read_packet(ts, payload_buffer); 501 if (ret < 0) { 502 dev_err(&client->dev, 503 "could not read packet, ret: %d\n", ret); 504 break; 505 } 506 507 payload = &payload_buffer[PAYLOAD_BODY]; 508 509 switch (payload[RESPONSE_ID]) { 510 case NOTIFICATION_TOUCH: 511 /* 512 * Always report touch-events received while 513 * suspending, when being a wakeup source 514 */ 515 if (ts->suspending && device_may_wakeup(&client->dev)) 516 pm_wakeup_event(&client->dev, 500); 517 zforce_touch_event(ts, &payload[RESPONSE_DATA]); 518 break; 519 520 case NOTIFICATION_BOOTCOMPLETE: 521 ts->boot_complete = payload[RESPONSE_DATA]; 522 zforce_complete(ts, payload[RESPONSE_ID], 0); 523 break; 524 525 case RESPONSE_INITIALIZE: 526 case RESPONSE_DEACTIVATE: 527 case RESPONSE_SETCONFIG: 528 case RESPONSE_RESOLUTION: 529 case RESPONSE_SCANFREQ: 530 zforce_complete(ts, payload[RESPONSE_ID], 531 payload[RESPONSE_DATA]); 532 break; 533 534 case RESPONSE_STATUS: 535 /* 536 * Version Payload Results 537 * [2:major] [2:minor] [2:build] [2:rev] 538 */ 539 ts->version_major = (payload[RESPONSE_DATA + 1] << 8) | 540 payload[RESPONSE_DATA]; 541 ts->version_minor = (payload[RESPONSE_DATA + 3] << 8) | 542 payload[RESPONSE_DATA + 2]; 543 ts->version_build = (payload[RESPONSE_DATA + 5] << 8) | 544 payload[RESPONSE_DATA + 4]; 545 ts->version_rev = (payload[RESPONSE_DATA + 7] << 8) | 546 payload[RESPONSE_DATA + 6]; 547 dev_dbg(&ts->client->dev, 548 "Firmware Version %04x:%04x %04x:%04x\n", 549 ts->version_major, ts->version_minor, 550 ts->version_build, ts->version_rev); 551 552 zforce_complete(ts, payload[RESPONSE_ID], 0); 553 break; 554 555 case NOTIFICATION_INVALID_COMMAND: 556 dev_err(&ts->client->dev, "invalid command: 0x%x\n", 557 payload[RESPONSE_DATA]); 558 break; 559 560 default: 561 dev_err(&ts->client->dev, 562 "unrecognized response id: 0x%x\n", 563 payload[RESPONSE_ID]); 564 break; 565 } 566 } 567 568 if (!ts->suspending && device_may_wakeup(&client->dev)) 569 pm_relax(&client->dev); 570 571 dev_dbg(&client->dev, "finished interrupt\n"); 572 573 return IRQ_HANDLED; 574 } 575 576 static int zforce_input_open(struct input_dev *dev) 577 { 578 struct zforce_ts *ts = input_get_drvdata(dev); 579 int ret; 580 581 ret = zforce_start(ts); 582 if (ret) 583 return ret; 584 585 return 0; 586 } 587 588 static void zforce_input_close(struct input_dev *dev) 589 { 590 struct zforce_ts *ts = input_get_drvdata(dev); 591 struct i2c_client *client = ts->client; 592 int ret; 593 594 ret = zforce_stop(ts); 595 if (ret) 596 dev_warn(&client->dev, "stopping zforce failed\n"); 597 598 return; 599 } 600 601 #ifdef CONFIG_PM_SLEEP 602 static int zforce_suspend(struct device *dev) 603 { 604 struct i2c_client *client = to_i2c_client(dev); 605 struct zforce_ts *ts = i2c_get_clientdata(client); 606 struct input_dev *input = ts->input; 607 int ret = 0; 608 609 mutex_lock(&input->mutex); 610 ts->suspending = true; 611 612 /* 613 * When configured as a wakeup source device should always wake 614 * the system, therefore start device if necessary. 615 */ 616 if (device_may_wakeup(&client->dev)) { 617 dev_dbg(&client->dev, "suspend while being a wakeup source\n"); 618 619 /* Need to start device, if not open, to be a wakeup source. */ 620 if (!input->users) { 621 ret = zforce_start(ts); 622 if (ret) 623 goto unlock; 624 } 625 626 enable_irq_wake(client->irq); 627 } else if (input->users) { 628 dev_dbg(&client->dev, 629 "suspend without being a wakeup source\n"); 630 631 ret = zforce_stop(ts); 632 if (ret) 633 goto unlock; 634 635 disable_irq(client->irq); 636 } 637 638 ts->suspended = true; 639 640 unlock: 641 ts->suspending = false; 642 mutex_unlock(&input->mutex); 643 644 return ret; 645 } 646 647 static int zforce_resume(struct device *dev) 648 { 649 struct i2c_client *client = to_i2c_client(dev); 650 struct zforce_ts *ts = i2c_get_clientdata(client); 651 struct input_dev *input = ts->input; 652 int ret = 0; 653 654 mutex_lock(&input->mutex); 655 656 ts->suspended = false; 657 658 if (device_may_wakeup(&client->dev)) { 659 dev_dbg(&client->dev, "resume from being a wakeup source\n"); 660 661 disable_irq_wake(client->irq); 662 663 /* need to stop device if it was not open on suspend */ 664 if (!input->users) { 665 ret = zforce_stop(ts); 666 if (ret) 667 goto unlock; 668 } 669 } else if (input->users) { 670 dev_dbg(&client->dev, "resume without being a wakeup source\n"); 671 672 enable_irq(client->irq); 673 674 ret = zforce_start(ts); 675 if (ret < 0) 676 goto unlock; 677 } 678 679 unlock: 680 mutex_unlock(&input->mutex); 681 682 return ret; 683 } 684 #endif 685 686 static SIMPLE_DEV_PM_OPS(zforce_pm_ops, zforce_suspend, zforce_resume); 687 688 static void zforce_reset(void *data) 689 { 690 struct zforce_ts *ts = data; 691 692 gpio_set_value(ts->pdata->gpio_rst, 0); 693 } 694 695 static struct zforce_ts_platdata *zforce_parse_dt(struct device *dev) 696 { 697 struct zforce_ts_platdata *pdata; 698 struct device_node *np = dev->of_node; 699 700 if (!np) 701 return ERR_PTR(-ENOENT); 702 703 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 704 if (!pdata) { 705 dev_err(dev, "failed to allocate platform data\n"); 706 return ERR_PTR(-ENOMEM); 707 } 708 709 pdata->gpio_int = of_get_gpio(np, 0); 710 if (!gpio_is_valid(pdata->gpio_int)) { 711 dev_err(dev, "failed to get interrupt gpio\n"); 712 return ERR_PTR(-EINVAL); 713 } 714 715 pdata->gpio_rst = of_get_gpio(np, 1); 716 if (!gpio_is_valid(pdata->gpio_rst)) { 717 dev_err(dev, "failed to get reset gpio\n"); 718 return ERR_PTR(-EINVAL); 719 } 720 721 if (of_property_read_u32(np, "x-size", &pdata->x_max)) { 722 dev_err(dev, "failed to get x-size property\n"); 723 return ERR_PTR(-EINVAL); 724 } 725 726 if (of_property_read_u32(np, "y-size", &pdata->y_max)) { 727 dev_err(dev, "failed to get y-size property\n"); 728 return ERR_PTR(-EINVAL); 729 } 730 731 return pdata; 732 } 733 734 static int zforce_probe(struct i2c_client *client, 735 const struct i2c_device_id *id) 736 { 737 const struct zforce_ts_platdata *pdata = dev_get_platdata(&client->dev); 738 struct zforce_ts *ts; 739 struct input_dev *input_dev; 740 int ret; 741 742 if (!pdata) { 743 pdata = zforce_parse_dt(&client->dev); 744 if (IS_ERR(pdata)) 745 return PTR_ERR(pdata); 746 } 747 748 ts = devm_kzalloc(&client->dev, sizeof(struct zforce_ts), GFP_KERNEL); 749 if (!ts) 750 return -ENOMEM; 751 752 ret = devm_gpio_request_one(&client->dev, pdata->gpio_int, GPIOF_IN, 753 "zforce_ts_int"); 754 if (ret) { 755 dev_err(&client->dev, "request of gpio %d failed, %d\n", 756 pdata->gpio_int, ret); 757 return ret; 758 } 759 760 ret = devm_gpio_request_one(&client->dev, pdata->gpio_rst, 761 GPIOF_OUT_INIT_LOW, "zforce_ts_rst"); 762 if (ret) { 763 dev_err(&client->dev, "request of gpio %d failed, %d\n", 764 pdata->gpio_rst, ret); 765 return ret; 766 } 767 768 ret = devm_add_action(&client->dev, zforce_reset, ts); 769 if (ret) { 770 dev_err(&client->dev, "failed to register reset action, %d\n", 771 ret); 772 return ret; 773 } 774 775 snprintf(ts->phys, sizeof(ts->phys), 776 "%s/input0", dev_name(&client->dev)); 777 778 input_dev = devm_input_allocate_device(&client->dev); 779 if (!input_dev) { 780 dev_err(&client->dev, "could not allocate input device\n"); 781 return -ENOMEM; 782 } 783 784 mutex_init(&ts->access_mutex); 785 mutex_init(&ts->command_mutex); 786 787 ts->pdata = pdata; 788 ts->client = client; 789 ts->input = input_dev; 790 791 input_dev->name = "Neonode zForce touchscreen"; 792 input_dev->phys = ts->phys; 793 input_dev->id.bustype = BUS_I2C; 794 795 input_dev->open = zforce_input_open; 796 input_dev->close = zforce_input_close; 797 798 __set_bit(EV_KEY, input_dev->evbit); 799 __set_bit(EV_SYN, input_dev->evbit); 800 __set_bit(EV_ABS, input_dev->evbit); 801 802 /* For multi touch */ 803 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, 804 pdata->x_max, 0, 0); 805 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, 806 pdata->y_max, 0, 0); 807 808 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 809 ZFORCE_MAX_AREA, 0, 0); 810 input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, 811 ZFORCE_MAX_AREA, 0, 0); 812 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0); 813 input_mt_init_slots(input_dev, ZFORCE_REPORT_POINTS, INPUT_MT_DIRECT); 814 815 input_set_drvdata(ts->input, ts); 816 817 init_completion(&ts->command_done); 818 819 /* 820 * The zforce pulls the interrupt low when it has data ready. 821 * After it is triggered the isr thread runs until all the available 822 * packets have been read and the interrupt is high again. 823 * Therefore we can trigger the interrupt anytime it is low and do 824 * not need to limit it to the interrupt edge. 825 */ 826 ret = devm_request_threaded_irq(&client->dev, client->irq, 827 zforce_irq, zforce_irq_thread, 828 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 829 input_dev->name, ts); 830 if (ret) { 831 dev_err(&client->dev, "irq %d request failed\n", client->irq); 832 return ret; 833 } 834 835 i2c_set_clientdata(client, ts); 836 837 /* let the controller boot */ 838 gpio_set_value(pdata->gpio_rst, 1); 839 840 ts->command_waiting = NOTIFICATION_BOOTCOMPLETE; 841 if (wait_for_completion_timeout(&ts->command_done, WAIT_TIMEOUT) == 0) 842 dev_warn(&client->dev, "bootcomplete timed out\n"); 843 844 /* need to start device to get version information */ 845 ret = zforce_command_wait(ts, COMMAND_INITIALIZE); 846 if (ret) { 847 dev_err(&client->dev, "unable to initialize, %d\n", ret); 848 return ret; 849 } 850 851 /* this gets the firmware version among other information */ 852 ret = zforce_command_wait(ts, COMMAND_STATUS); 853 if (ret < 0) { 854 dev_err(&client->dev, "couldn't get status, %d\n", ret); 855 zforce_stop(ts); 856 return ret; 857 } 858 859 /* stop device and put it into sleep until it is opened */ 860 ret = zforce_stop(ts); 861 if (ret < 0) 862 return ret; 863 864 device_set_wakeup_capable(&client->dev, true); 865 866 ret = input_register_device(input_dev); 867 if (ret) { 868 dev_err(&client->dev, "could not register input device, %d\n", 869 ret); 870 return ret; 871 } 872 873 return 0; 874 } 875 876 static struct i2c_device_id zforce_idtable[] = { 877 { "zforce-ts", 0 }, 878 { } 879 }; 880 MODULE_DEVICE_TABLE(i2c, zforce_idtable); 881 882 #ifdef CONFIG_OF 883 static const struct of_device_id zforce_dt_idtable[] = { 884 { .compatible = "neonode,zforce" }, 885 {}, 886 }; 887 MODULE_DEVICE_TABLE(of, zforce_dt_idtable); 888 #endif 889 890 static struct i2c_driver zforce_driver = { 891 .driver = { 892 .owner = THIS_MODULE, 893 .name = "zforce-ts", 894 .pm = &zforce_pm_ops, 895 .of_match_table = of_match_ptr(zforce_dt_idtable), 896 }, 897 .probe = zforce_probe, 898 .id_table = zforce_idtable, 899 }; 900 901 module_i2c_driver(zforce_driver); 902 903 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); 904 MODULE_DESCRIPTION("zForce TouchScreen Driver"); 905 MODULE_LICENSE("GPL"); 906