1 /* 2 * Copyright (C) 2012 Simon Budig, <simon.budig@kernelconcepts.de> 3 * 4 * This software is licensed under the terms of the GNU General Public 5 * License version 2, as published by the Free Software Foundation, and 6 * may be copied, distributed, and modified under those terms. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this library; if not, write to the Free Software 15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 16 */ 17 18 /* 19 * This is a driver for the EDT "Polytouch" family of touch controllers 20 * based on the FocalTech FT5x06 line of chips. 21 * 22 * Development of this driver has been sponsored by Glyn: 23 * http://www.glyn.com/Products/Displays 24 */ 25 26 #include <linux/module.h> 27 #include <linux/ratelimit.h> 28 #include <linux/interrupt.h> 29 #include <linux/input.h> 30 #include <linux/i2c.h> 31 #include <linux/uaccess.h> 32 #include <linux/delay.h> 33 #include <linux/debugfs.h> 34 #include <linux/slab.h> 35 #include <linux/gpio.h> 36 #include <linux/input/mt.h> 37 #include <linux/input/edt-ft5x06.h> 38 39 #define MAX_SUPPORT_POINTS 5 40 41 #define WORK_REGISTER_THRESHOLD 0x00 42 #define WORK_REGISTER_REPORT_RATE 0x08 43 #define WORK_REGISTER_GAIN 0x30 44 #define WORK_REGISTER_OFFSET 0x31 45 #define WORK_REGISTER_NUM_X 0x33 46 #define WORK_REGISTER_NUM_Y 0x34 47 48 #define WORK_REGISTER_OPMODE 0x3c 49 #define FACTORY_REGISTER_OPMODE 0x01 50 51 #define TOUCH_EVENT_DOWN 0x00 52 #define TOUCH_EVENT_UP 0x01 53 #define TOUCH_EVENT_ON 0x02 54 #define TOUCH_EVENT_RESERVED 0x03 55 56 #define EDT_NAME_LEN 23 57 #define EDT_SWITCH_MODE_RETRIES 10 58 #define EDT_SWITCH_MODE_DELAY 5 /* msec */ 59 #define EDT_RAW_DATA_RETRIES 100 60 #define EDT_RAW_DATA_DELAY 1 /* msec */ 61 62 struct edt_ft5x06_ts_data { 63 struct i2c_client *client; 64 struct input_dev *input; 65 u16 num_x; 66 u16 num_y; 67 68 #if defined(CONFIG_DEBUG_FS) 69 struct dentry *debug_dir; 70 u8 *raw_buffer; 71 size_t raw_bufsize; 72 #endif 73 74 struct mutex mutex; 75 bool factory_mode; 76 int threshold; 77 int gain; 78 int offset; 79 int report_rate; 80 81 char name[EDT_NAME_LEN]; 82 }; 83 84 static int edt_ft5x06_ts_readwrite(struct i2c_client *client, 85 u16 wr_len, u8 *wr_buf, 86 u16 rd_len, u8 *rd_buf) 87 { 88 struct i2c_msg wrmsg[2]; 89 int i = 0; 90 int ret; 91 92 if (wr_len) { 93 wrmsg[i].addr = client->addr; 94 wrmsg[i].flags = 0; 95 wrmsg[i].len = wr_len; 96 wrmsg[i].buf = wr_buf; 97 i++; 98 } 99 if (rd_len) { 100 wrmsg[i].addr = client->addr; 101 wrmsg[i].flags = I2C_M_RD; 102 wrmsg[i].len = rd_len; 103 wrmsg[i].buf = rd_buf; 104 i++; 105 } 106 107 ret = i2c_transfer(client->adapter, wrmsg, i); 108 if (ret < 0) 109 return ret; 110 if (ret != i) 111 return -EIO; 112 113 return 0; 114 } 115 116 static bool edt_ft5x06_ts_check_crc(struct edt_ft5x06_ts_data *tsdata, 117 u8 *buf, int buflen) 118 { 119 int i; 120 u8 crc = 0; 121 122 for (i = 0; i < buflen - 1; i++) 123 crc ^= buf[i]; 124 125 if (crc != buf[buflen-1]) { 126 dev_err_ratelimited(&tsdata->client->dev, 127 "crc error: 0x%02x expected, got 0x%02x\n", 128 crc, buf[buflen-1]); 129 return false; 130 } 131 132 return true; 133 } 134 135 static irqreturn_t edt_ft5x06_ts_isr(int irq, void *dev_id) 136 { 137 struct edt_ft5x06_ts_data *tsdata = dev_id; 138 struct device *dev = &tsdata->client->dev; 139 u8 cmd = 0xf9; 140 u8 rdbuf[26]; 141 int i, type, x, y, id; 142 int error; 143 144 memset(rdbuf, 0, sizeof(rdbuf)); 145 146 error = edt_ft5x06_ts_readwrite(tsdata->client, 147 sizeof(cmd), &cmd, 148 sizeof(rdbuf), rdbuf); 149 if (error) { 150 dev_err_ratelimited(dev, "Unable to fetch data, error: %d\n", 151 error); 152 goto out; 153 } 154 155 if (rdbuf[0] != 0xaa || rdbuf[1] != 0xaa || rdbuf[2] != 26) { 156 dev_err_ratelimited(dev, "Unexpected header: %02x%02x%02x!\n", 157 rdbuf[0], rdbuf[1], rdbuf[2]); 158 goto out; 159 } 160 161 if (!edt_ft5x06_ts_check_crc(tsdata, rdbuf, 26)) 162 goto out; 163 164 for (i = 0; i < MAX_SUPPORT_POINTS; i++) { 165 u8 *buf = &rdbuf[i * 4 + 5]; 166 bool down; 167 168 type = buf[0] >> 6; 169 /* ignore Reserved events */ 170 if (type == TOUCH_EVENT_RESERVED) 171 continue; 172 173 x = ((buf[0] << 8) | buf[1]) & 0x0fff; 174 y = ((buf[2] << 8) | buf[3]) & 0x0fff; 175 id = (buf[2] >> 4) & 0x0f; 176 down = (type != TOUCH_EVENT_UP); 177 178 input_mt_slot(tsdata->input, id); 179 input_mt_report_slot_state(tsdata->input, MT_TOOL_FINGER, down); 180 181 if (!down) 182 continue; 183 184 input_report_abs(tsdata->input, ABS_MT_POSITION_X, x); 185 input_report_abs(tsdata->input, ABS_MT_POSITION_Y, y); 186 } 187 188 input_mt_report_pointer_emulation(tsdata->input, true); 189 input_sync(tsdata->input); 190 191 out: 192 return IRQ_HANDLED; 193 } 194 195 static int edt_ft5x06_register_write(struct edt_ft5x06_ts_data *tsdata, 196 u8 addr, u8 value) 197 { 198 u8 wrbuf[4]; 199 200 wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc; 201 wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f; 202 wrbuf[2] = value; 203 wrbuf[3] = wrbuf[0] ^ wrbuf[1] ^ wrbuf[2]; 204 205 return edt_ft5x06_ts_readwrite(tsdata->client, 4, wrbuf, 0, NULL); 206 } 207 208 static int edt_ft5x06_register_read(struct edt_ft5x06_ts_data *tsdata, 209 u8 addr) 210 { 211 u8 wrbuf[2], rdbuf[2]; 212 int error; 213 214 wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc; 215 wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f; 216 wrbuf[1] |= tsdata->factory_mode ? 0x80 : 0x40; 217 218 error = edt_ft5x06_ts_readwrite(tsdata->client, 2, wrbuf, 2, rdbuf); 219 if (error) 220 return error; 221 222 if ((wrbuf[0] ^ wrbuf[1] ^ rdbuf[0]) != rdbuf[1]) { 223 dev_err(&tsdata->client->dev, 224 "crc error: 0x%02x expected, got 0x%02x\n", 225 wrbuf[0] ^ wrbuf[1] ^ rdbuf[0], rdbuf[1]); 226 return -EIO; 227 } 228 229 return rdbuf[0]; 230 } 231 232 struct edt_ft5x06_attribute { 233 struct device_attribute dattr; 234 size_t field_offset; 235 u8 limit_low; 236 u8 limit_high; 237 u8 addr; 238 }; 239 240 #define EDT_ATTR(_field, _mode, _addr, _limit_low, _limit_high) \ 241 struct edt_ft5x06_attribute edt_ft5x06_attr_##_field = { \ 242 .dattr = __ATTR(_field, _mode, \ 243 edt_ft5x06_setting_show, \ 244 edt_ft5x06_setting_store), \ 245 .field_offset = \ 246 offsetof(struct edt_ft5x06_ts_data, _field), \ 247 .limit_low = _limit_low, \ 248 .limit_high = _limit_high, \ 249 .addr = _addr, \ 250 } 251 252 static ssize_t edt_ft5x06_setting_show(struct device *dev, 253 struct device_attribute *dattr, 254 char *buf) 255 { 256 struct i2c_client *client = to_i2c_client(dev); 257 struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client); 258 struct edt_ft5x06_attribute *attr = 259 container_of(dattr, struct edt_ft5x06_attribute, dattr); 260 u8 *field = (u8 *)((char *)tsdata + attr->field_offset); 261 int val; 262 size_t count = 0; 263 int error = 0; 264 265 mutex_lock(&tsdata->mutex); 266 267 if (tsdata->factory_mode) { 268 error = -EIO; 269 goto out; 270 } 271 272 val = edt_ft5x06_register_read(tsdata, attr->addr); 273 if (val < 0) { 274 error = val; 275 dev_err(&tsdata->client->dev, 276 "Failed to fetch attribute %s, error %d\n", 277 dattr->attr.name, error); 278 goto out; 279 } 280 281 if (val != *field) { 282 dev_warn(&tsdata->client->dev, 283 "%s: read (%d) and stored value (%d) differ\n", 284 dattr->attr.name, val, *field); 285 *field = val; 286 } 287 288 count = scnprintf(buf, PAGE_SIZE, "%d\n", val); 289 out: 290 mutex_unlock(&tsdata->mutex); 291 return error ?: count; 292 } 293 294 static ssize_t edt_ft5x06_setting_store(struct device *dev, 295 struct device_attribute *dattr, 296 const char *buf, size_t count) 297 { 298 struct i2c_client *client = to_i2c_client(dev); 299 struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client); 300 struct edt_ft5x06_attribute *attr = 301 container_of(dattr, struct edt_ft5x06_attribute, dattr); 302 u8 *field = (u8 *)((char *)tsdata + attr->field_offset); 303 unsigned int val; 304 int error; 305 306 mutex_lock(&tsdata->mutex); 307 308 if (tsdata->factory_mode) { 309 error = -EIO; 310 goto out; 311 } 312 313 error = kstrtouint(buf, 0, &val); 314 if (error) 315 goto out; 316 317 if (val < attr->limit_low || val > attr->limit_high) { 318 error = -ERANGE; 319 goto out; 320 } 321 322 error = edt_ft5x06_register_write(tsdata, attr->addr, val); 323 if (error) { 324 dev_err(&tsdata->client->dev, 325 "Failed to update attribute %s, error: %d\n", 326 dattr->attr.name, error); 327 goto out; 328 } 329 330 *field = val; 331 332 out: 333 mutex_unlock(&tsdata->mutex); 334 return error ?: count; 335 } 336 337 static EDT_ATTR(gain, S_IWUSR | S_IRUGO, WORK_REGISTER_GAIN, 0, 31); 338 static EDT_ATTR(offset, S_IWUSR | S_IRUGO, WORK_REGISTER_OFFSET, 0, 31); 339 static EDT_ATTR(threshold, S_IWUSR | S_IRUGO, 340 WORK_REGISTER_THRESHOLD, 20, 80); 341 static EDT_ATTR(report_rate, S_IWUSR | S_IRUGO, 342 WORK_REGISTER_REPORT_RATE, 3, 14); 343 344 static struct attribute *edt_ft5x06_attrs[] = { 345 &edt_ft5x06_attr_gain.dattr.attr, 346 &edt_ft5x06_attr_offset.dattr.attr, 347 &edt_ft5x06_attr_threshold.dattr.attr, 348 &edt_ft5x06_attr_report_rate.dattr.attr, 349 NULL 350 }; 351 352 static const struct attribute_group edt_ft5x06_attr_group = { 353 .attrs = edt_ft5x06_attrs, 354 }; 355 356 #ifdef CONFIG_DEBUG_FS 357 static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data *tsdata) 358 { 359 struct i2c_client *client = tsdata->client; 360 int retries = EDT_SWITCH_MODE_RETRIES; 361 int ret; 362 int error; 363 364 disable_irq(client->irq); 365 366 if (!tsdata->raw_buffer) { 367 tsdata->raw_bufsize = tsdata->num_x * tsdata->num_y * 368 sizeof(u16); 369 tsdata->raw_buffer = kzalloc(tsdata->raw_bufsize, GFP_KERNEL); 370 if (!tsdata->raw_buffer) { 371 error = -ENOMEM; 372 goto err_out; 373 } 374 } 375 376 /* mode register is 0x3c when in the work mode */ 377 error = edt_ft5x06_register_write(tsdata, WORK_REGISTER_OPMODE, 0x03); 378 if (error) { 379 dev_err(&client->dev, 380 "failed to switch to factory mode, error %d\n", error); 381 goto err_out; 382 } 383 384 tsdata->factory_mode = true; 385 do { 386 mdelay(EDT_SWITCH_MODE_DELAY); 387 /* mode register is 0x01 when in factory mode */ 388 ret = edt_ft5x06_register_read(tsdata, FACTORY_REGISTER_OPMODE); 389 if (ret == 0x03) 390 break; 391 } while (--retries > 0); 392 393 if (retries == 0) { 394 dev_err(&client->dev, "not in factory mode after %dms.\n", 395 EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY); 396 error = -EIO; 397 goto err_out; 398 } 399 400 return 0; 401 402 err_out: 403 kfree(tsdata->raw_buffer); 404 tsdata->raw_buffer = NULL; 405 tsdata->factory_mode = false; 406 enable_irq(client->irq); 407 408 return error; 409 } 410 411 static int edt_ft5x06_work_mode(struct edt_ft5x06_ts_data *tsdata) 412 { 413 struct i2c_client *client = tsdata->client; 414 int retries = EDT_SWITCH_MODE_RETRIES; 415 int ret; 416 int error; 417 418 /* mode register is 0x01 when in the factory mode */ 419 error = edt_ft5x06_register_write(tsdata, FACTORY_REGISTER_OPMODE, 0x1); 420 if (error) { 421 dev_err(&client->dev, 422 "failed to switch to work mode, error: %d\n", error); 423 return error; 424 } 425 426 tsdata->factory_mode = false; 427 428 do { 429 mdelay(EDT_SWITCH_MODE_DELAY); 430 /* mode register is 0x01 when in factory mode */ 431 ret = edt_ft5x06_register_read(tsdata, WORK_REGISTER_OPMODE); 432 if (ret == 0x01) 433 break; 434 } while (--retries > 0); 435 436 if (retries == 0) { 437 dev_err(&client->dev, "not in work mode after %dms.\n", 438 EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY); 439 tsdata->factory_mode = true; 440 return -EIO; 441 } 442 443 kfree(tsdata->raw_buffer); 444 tsdata->raw_buffer = NULL; 445 446 /* restore parameters */ 447 edt_ft5x06_register_write(tsdata, WORK_REGISTER_THRESHOLD, 448 tsdata->threshold); 449 edt_ft5x06_register_write(tsdata, WORK_REGISTER_GAIN, 450 tsdata->gain); 451 edt_ft5x06_register_write(tsdata, WORK_REGISTER_OFFSET, 452 tsdata->offset); 453 edt_ft5x06_register_write(tsdata, WORK_REGISTER_REPORT_RATE, 454 tsdata->report_rate); 455 456 enable_irq(client->irq); 457 458 return 0; 459 } 460 461 static int edt_ft5x06_debugfs_mode_get(void *data, u64 *mode) 462 { 463 struct edt_ft5x06_ts_data *tsdata = data; 464 465 *mode = tsdata->factory_mode; 466 467 return 0; 468 }; 469 470 static int edt_ft5x06_debugfs_mode_set(void *data, u64 mode) 471 { 472 struct edt_ft5x06_ts_data *tsdata = data; 473 int retval = 0; 474 475 if (mode > 1) 476 return -ERANGE; 477 478 mutex_lock(&tsdata->mutex); 479 480 if (mode != tsdata->factory_mode) { 481 retval = mode ? edt_ft5x06_factory_mode(tsdata) : 482 edt_ft5x06_work_mode(tsdata); 483 } 484 485 mutex_unlock(&tsdata->mutex); 486 487 return retval; 488 }; 489 490 DEFINE_SIMPLE_ATTRIBUTE(debugfs_mode_fops, edt_ft5x06_debugfs_mode_get, 491 edt_ft5x06_debugfs_mode_set, "%llu\n"); 492 493 static ssize_t edt_ft5x06_debugfs_raw_data_read(struct file *file, 494 char __user *buf, size_t count, loff_t *off) 495 { 496 struct edt_ft5x06_ts_data *tsdata = file->private_data; 497 struct i2c_client *client = tsdata->client; 498 int retries = EDT_RAW_DATA_RETRIES; 499 int val, i, error; 500 size_t read = 0; 501 int colbytes; 502 char wrbuf[3]; 503 u8 *rdbuf; 504 505 if (*off < 0 || *off >= tsdata->raw_bufsize) 506 return 0; 507 508 mutex_lock(&tsdata->mutex); 509 510 if (!tsdata->factory_mode || !tsdata->raw_buffer) { 511 error = -EIO; 512 goto out; 513 } 514 515 error = edt_ft5x06_register_write(tsdata, 0x08, 0x01); 516 if (error) { 517 dev_dbg(&client->dev, 518 "failed to write 0x08 register, error %d\n", error); 519 goto out; 520 } 521 522 do { 523 msleep(EDT_RAW_DATA_DELAY); 524 val = edt_ft5x06_register_read(tsdata, 0x08); 525 if (val < 1) 526 break; 527 } while (--retries > 0); 528 529 if (val < 0) { 530 error = val; 531 dev_dbg(&client->dev, 532 "failed to read 0x08 register, error %d\n", error); 533 goto out; 534 } 535 536 if (retries == 0) { 537 dev_dbg(&client->dev, 538 "timed out waiting for register to settle\n"); 539 error = -ETIMEDOUT; 540 goto out; 541 } 542 543 rdbuf = tsdata->raw_buffer; 544 colbytes = tsdata->num_y * sizeof(u16); 545 546 wrbuf[0] = 0xf5; 547 wrbuf[1] = 0x0e; 548 for (i = 0; i < tsdata->num_x; i++) { 549 wrbuf[2] = i; /* column index */ 550 error = edt_ft5x06_ts_readwrite(tsdata->client, 551 sizeof(wrbuf), wrbuf, 552 colbytes, rdbuf); 553 if (error) 554 goto out; 555 556 rdbuf += colbytes; 557 } 558 559 read = min_t(size_t, count, tsdata->raw_bufsize - *off); 560 if (copy_to_user(buf, tsdata->raw_buffer + *off, read)) { 561 error = -EFAULT; 562 goto out; 563 } 564 565 *off += read; 566 out: 567 mutex_unlock(&tsdata->mutex); 568 return error ?: read; 569 }; 570 571 572 static const struct file_operations debugfs_raw_data_fops = { 573 .open = simple_open, 574 .read = edt_ft5x06_debugfs_raw_data_read, 575 }; 576 577 static void 578 edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata, 579 const char *debugfs_name) 580 { 581 tsdata->debug_dir = debugfs_create_dir(debugfs_name, NULL); 582 if (!tsdata->debug_dir) 583 return; 584 585 debugfs_create_u16("num_x", S_IRUSR, tsdata->debug_dir, &tsdata->num_x); 586 debugfs_create_u16("num_y", S_IRUSR, tsdata->debug_dir, &tsdata->num_y); 587 588 debugfs_create_file("mode", S_IRUSR | S_IWUSR, 589 tsdata->debug_dir, tsdata, &debugfs_mode_fops); 590 debugfs_create_file("raw_data", S_IRUSR, 591 tsdata->debug_dir, tsdata, &debugfs_raw_data_fops); 592 } 593 594 static void 595 edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata) 596 { 597 if (tsdata->debug_dir) 598 debugfs_remove_recursive(tsdata->debug_dir); 599 kfree(tsdata->raw_buffer); 600 } 601 602 #else 603 604 static inline void 605 edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata, 606 const char *debugfs_name) 607 { 608 } 609 610 static inline void 611 edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata) 612 { 613 } 614 615 #endif /* CONFIG_DEBUGFS */ 616 617 618 619 static int edt_ft5x06_ts_reset(struct i2c_client *client, 620 int reset_pin) 621 { 622 int error; 623 624 if (gpio_is_valid(reset_pin)) { 625 /* this pulls reset down, enabling the low active reset */ 626 error = gpio_request_one(reset_pin, GPIOF_OUT_INIT_LOW, 627 "edt-ft5x06 reset"); 628 if (error) { 629 dev_err(&client->dev, 630 "Failed to request GPIO %d as reset pin, error %d\n", 631 reset_pin, error); 632 return error; 633 } 634 635 mdelay(50); 636 gpio_set_value(reset_pin, 1); 637 mdelay(100); 638 } 639 640 return 0; 641 } 642 643 static int edt_ft5x06_ts_identify(struct i2c_client *client, 644 char *model_name, 645 char *fw_version) 646 { 647 u8 rdbuf[EDT_NAME_LEN]; 648 char *p; 649 int error; 650 651 error = edt_ft5x06_ts_readwrite(client, 1, "\xbb", 652 EDT_NAME_LEN - 1, rdbuf); 653 if (error) 654 return error; 655 656 /* remove last '$' end marker */ 657 rdbuf[EDT_NAME_LEN - 1] = '\0'; 658 if (rdbuf[EDT_NAME_LEN - 2] == '$') 659 rdbuf[EDT_NAME_LEN - 2] = '\0'; 660 661 /* look for Model/Version separator */ 662 p = strchr(rdbuf, '*'); 663 if (p) 664 *p++ = '\0'; 665 666 strlcpy(model_name, rdbuf + 1, EDT_NAME_LEN); 667 strlcpy(fw_version, p ? p : "", EDT_NAME_LEN); 668 669 return 0; 670 } 671 672 #define EDT_ATTR_CHECKSET(name, reg) \ 673 if (pdata->name >= edt_ft5x06_attr_##name.limit_low && \ 674 pdata->name <= edt_ft5x06_attr_##name.limit_high) \ 675 edt_ft5x06_register_write(tsdata, reg, pdata->name) 676 677 static void 678 edt_ft5x06_ts_get_defaults(struct edt_ft5x06_ts_data *tsdata, 679 const struct edt_ft5x06_platform_data *pdata) 680 { 681 if (!pdata->use_parameters) 682 return; 683 684 /* pick up defaults from the platform data */ 685 EDT_ATTR_CHECKSET(threshold, WORK_REGISTER_THRESHOLD); 686 EDT_ATTR_CHECKSET(gain, WORK_REGISTER_GAIN); 687 EDT_ATTR_CHECKSET(offset, WORK_REGISTER_OFFSET); 688 EDT_ATTR_CHECKSET(report_rate, WORK_REGISTER_REPORT_RATE); 689 } 690 691 static void 692 edt_ft5x06_ts_get_parameters(struct edt_ft5x06_ts_data *tsdata) 693 { 694 tsdata->threshold = edt_ft5x06_register_read(tsdata, 695 WORK_REGISTER_THRESHOLD); 696 tsdata->gain = edt_ft5x06_register_read(tsdata, WORK_REGISTER_GAIN); 697 tsdata->offset = edt_ft5x06_register_read(tsdata, WORK_REGISTER_OFFSET); 698 tsdata->report_rate = edt_ft5x06_register_read(tsdata, 699 WORK_REGISTER_REPORT_RATE); 700 tsdata->num_x = edt_ft5x06_register_read(tsdata, WORK_REGISTER_NUM_X); 701 tsdata->num_y = edt_ft5x06_register_read(tsdata, WORK_REGISTER_NUM_Y); 702 } 703 704 static int edt_ft5x06_ts_probe(struct i2c_client *client, 705 const struct i2c_device_id *id) 706 { 707 const struct edt_ft5x06_platform_data *pdata = 708 client->dev.platform_data; 709 struct edt_ft5x06_ts_data *tsdata; 710 struct input_dev *input; 711 int error; 712 char fw_version[EDT_NAME_LEN]; 713 714 dev_dbg(&client->dev, "probing for EDT FT5x06 I2C\n"); 715 716 if (!pdata) { 717 dev_err(&client->dev, "no platform data?\n"); 718 return -EINVAL; 719 } 720 721 error = edt_ft5x06_ts_reset(client, pdata->reset_pin); 722 if (error) 723 return error; 724 725 if (gpio_is_valid(pdata->irq_pin)) { 726 error = gpio_request_one(pdata->irq_pin, 727 GPIOF_IN, "edt-ft5x06 irq"); 728 if (error) { 729 dev_err(&client->dev, 730 "Failed to request GPIO %d, error %d\n", 731 pdata->irq_pin, error); 732 return error; 733 } 734 } 735 736 tsdata = kzalloc(sizeof(*tsdata), GFP_KERNEL); 737 input = input_allocate_device(); 738 if (!tsdata || !input) { 739 dev_err(&client->dev, "failed to allocate driver data.\n"); 740 error = -ENOMEM; 741 goto err_free_mem; 742 } 743 744 mutex_init(&tsdata->mutex); 745 tsdata->client = client; 746 tsdata->input = input; 747 tsdata->factory_mode = false; 748 749 error = edt_ft5x06_ts_identify(client, tsdata->name, fw_version); 750 if (error) { 751 dev_err(&client->dev, "touchscreen probe failed\n"); 752 goto err_free_mem; 753 } 754 755 edt_ft5x06_ts_get_defaults(tsdata, pdata); 756 edt_ft5x06_ts_get_parameters(tsdata); 757 758 dev_dbg(&client->dev, 759 "Model \"%s\", Rev. \"%s\", %dx%d sensors\n", 760 tsdata->name, fw_version, tsdata->num_x, tsdata->num_y); 761 762 input->name = tsdata->name; 763 input->id.bustype = BUS_I2C; 764 input->dev.parent = &client->dev; 765 766 __set_bit(EV_SYN, input->evbit); 767 __set_bit(EV_KEY, input->evbit); 768 __set_bit(EV_ABS, input->evbit); 769 __set_bit(BTN_TOUCH, input->keybit); 770 input_set_abs_params(input, ABS_X, 0, tsdata->num_x * 64 - 1, 0, 0); 771 input_set_abs_params(input, ABS_Y, 0, tsdata->num_y * 64 - 1, 0, 0); 772 input_set_abs_params(input, ABS_MT_POSITION_X, 773 0, tsdata->num_x * 64 - 1, 0, 0); 774 input_set_abs_params(input, ABS_MT_POSITION_Y, 775 0, tsdata->num_y * 64 - 1, 0, 0); 776 error = input_mt_init_slots(input, MAX_SUPPORT_POINTS, 0); 777 if (error) { 778 dev_err(&client->dev, "Unable to init MT slots.\n"); 779 goto err_free_mem; 780 } 781 782 input_set_drvdata(input, tsdata); 783 i2c_set_clientdata(client, tsdata); 784 785 error = request_threaded_irq(client->irq, NULL, edt_ft5x06_ts_isr, 786 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 787 client->name, tsdata); 788 if (error) { 789 dev_err(&client->dev, "Unable to request touchscreen IRQ.\n"); 790 goto err_free_mem; 791 } 792 793 error = sysfs_create_group(&client->dev.kobj, &edt_ft5x06_attr_group); 794 if (error) 795 goto err_free_irq; 796 797 error = input_register_device(input); 798 if (error) 799 goto err_remove_attrs; 800 801 edt_ft5x06_ts_prepare_debugfs(tsdata, dev_driver_string(&client->dev)); 802 device_init_wakeup(&client->dev, 1); 803 804 dev_dbg(&client->dev, 805 "EDT FT5x06 initialized: IRQ pin %d, Reset pin %d.\n", 806 pdata->irq_pin, pdata->reset_pin); 807 808 return 0; 809 810 err_remove_attrs: 811 sysfs_remove_group(&client->dev.kobj, &edt_ft5x06_attr_group); 812 err_free_irq: 813 free_irq(client->irq, tsdata); 814 err_free_mem: 815 input_free_device(input); 816 kfree(tsdata); 817 818 if (gpio_is_valid(pdata->irq_pin)) 819 gpio_free(pdata->irq_pin); 820 821 return error; 822 } 823 824 static int edt_ft5x06_ts_remove(struct i2c_client *client) 825 { 826 const struct edt_ft5x06_platform_data *pdata = 827 dev_get_platdata(&client->dev); 828 struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client); 829 830 edt_ft5x06_ts_teardown_debugfs(tsdata); 831 sysfs_remove_group(&client->dev.kobj, &edt_ft5x06_attr_group); 832 833 free_irq(client->irq, tsdata); 834 input_unregister_device(tsdata->input); 835 836 if (gpio_is_valid(pdata->irq_pin)) 837 gpio_free(pdata->irq_pin); 838 if (gpio_is_valid(pdata->reset_pin)) 839 gpio_free(pdata->reset_pin); 840 841 kfree(tsdata); 842 843 return 0; 844 } 845 846 #ifdef CONFIG_PM_SLEEP 847 static int edt_ft5x06_ts_suspend(struct device *dev) 848 { 849 struct i2c_client *client = to_i2c_client(dev); 850 851 if (device_may_wakeup(dev)) 852 enable_irq_wake(client->irq); 853 854 return 0; 855 } 856 857 static int edt_ft5x06_ts_resume(struct device *dev) 858 { 859 struct i2c_client *client = to_i2c_client(dev); 860 861 if (device_may_wakeup(dev)) 862 disable_irq_wake(client->irq); 863 864 return 0; 865 } 866 #endif 867 868 static SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops, 869 edt_ft5x06_ts_suspend, edt_ft5x06_ts_resume); 870 871 static const struct i2c_device_id edt_ft5x06_ts_id[] = { 872 { "edt-ft5x06", 0 }, 873 { } 874 }; 875 MODULE_DEVICE_TABLE(i2c, edt_ft5x06_ts_id); 876 877 static struct i2c_driver edt_ft5x06_ts_driver = { 878 .driver = { 879 .owner = THIS_MODULE, 880 .name = "edt_ft5x06", 881 .pm = &edt_ft5x06_ts_pm_ops, 882 }, 883 .id_table = edt_ft5x06_ts_id, 884 .probe = edt_ft5x06_ts_probe, 885 .remove = edt_ft5x06_ts_remove, 886 }; 887 888 module_i2c_driver(edt_ft5x06_ts_driver); 889 890 MODULE_AUTHOR("Simon Budig <simon.budig@kernelconcepts.de>"); 891 MODULE_DESCRIPTION("EDT FT5x06 I2C Touchscreen Driver"); 892 MODULE_LICENSE("GPL"); 893