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 if (tsdata->raw_buffer) 444 kfree(tsdata->raw_buffer); 445 tsdata->raw_buffer = NULL; 446 447 /* restore parameters */ 448 edt_ft5x06_register_write(tsdata, WORK_REGISTER_THRESHOLD, 449 tsdata->threshold); 450 edt_ft5x06_register_write(tsdata, WORK_REGISTER_GAIN, 451 tsdata->gain); 452 edt_ft5x06_register_write(tsdata, WORK_REGISTER_OFFSET, 453 tsdata->offset); 454 edt_ft5x06_register_write(tsdata, WORK_REGISTER_REPORT_RATE, 455 tsdata->report_rate); 456 457 enable_irq(client->irq); 458 459 return 0; 460 } 461 462 static int edt_ft5x06_debugfs_mode_get(void *data, u64 *mode) 463 { 464 struct edt_ft5x06_ts_data *tsdata = data; 465 466 *mode = tsdata->factory_mode; 467 468 return 0; 469 }; 470 471 static int edt_ft5x06_debugfs_mode_set(void *data, u64 mode) 472 { 473 struct edt_ft5x06_ts_data *tsdata = data; 474 int retval = 0; 475 476 if (mode > 1) 477 return -ERANGE; 478 479 mutex_lock(&tsdata->mutex); 480 481 if (mode != tsdata->factory_mode) { 482 retval = mode ? edt_ft5x06_factory_mode(tsdata) : 483 edt_ft5x06_work_mode(tsdata); 484 } 485 486 mutex_unlock(&tsdata->mutex); 487 488 return retval; 489 }; 490 491 DEFINE_SIMPLE_ATTRIBUTE(debugfs_mode_fops, edt_ft5x06_debugfs_mode_get, 492 edt_ft5x06_debugfs_mode_set, "%llu\n"); 493 494 static int edt_ft5x06_debugfs_raw_data_open(struct inode *inode, 495 struct file *file) 496 { 497 file->private_data = inode->i_private; 498 499 return 0; 500 } 501 502 static ssize_t edt_ft5x06_debugfs_raw_data_read(struct file *file, 503 char __user *buf, size_t count, loff_t *off) 504 { 505 struct edt_ft5x06_ts_data *tsdata = file->private_data; 506 struct i2c_client *client = tsdata->client; 507 int retries = EDT_RAW_DATA_RETRIES; 508 int val, i, error; 509 size_t read = 0; 510 int colbytes; 511 char wrbuf[3]; 512 u8 *rdbuf; 513 514 if (*off < 0 || *off >= tsdata->raw_bufsize) 515 return 0; 516 517 mutex_lock(&tsdata->mutex); 518 519 if (!tsdata->factory_mode || !tsdata->raw_buffer) { 520 error = -EIO; 521 goto out; 522 } 523 524 error = edt_ft5x06_register_write(tsdata, 0x08, 0x01); 525 if (error) { 526 dev_dbg(&client->dev, 527 "failed to write 0x08 register, error %d\n", error); 528 goto out; 529 } 530 531 do { 532 msleep(EDT_RAW_DATA_DELAY); 533 val = edt_ft5x06_register_read(tsdata, 0x08); 534 if (val < 1) 535 break; 536 } while (--retries > 0); 537 538 if (val < 0) { 539 error = val; 540 dev_dbg(&client->dev, 541 "failed to read 0x08 register, error %d\n", error); 542 goto out; 543 } 544 545 if (retries == 0) { 546 dev_dbg(&client->dev, 547 "timed out waiting for register to settle\n"); 548 error = -ETIMEDOUT; 549 goto out; 550 } 551 552 rdbuf = tsdata->raw_buffer; 553 colbytes = tsdata->num_y * sizeof(u16); 554 555 wrbuf[0] = 0xf5; 556 wrbuf[1] = 0x0e; 557 for (i = 0; i < tsdata->num_x; i++) { 558 wrbuf[2] = i; /* column index */ 559 error = edt_ft5x06_ts_readwrite(tsdata->client, 560 sizeof(wrbuf), wrbuf, 561 colbytes, rdbuf); 562 if (error) 563 goto out; 564 565 rdbuf += colbytes; 566 } 567 568 read = min_t(size_t, count, tsdata->raw_bufsize - *off); 569 if (copy_to_user(buf, tsdata->raw_buffer + *off, read)) { 570 error = -EFAULT; 571 goto out; 572 } 573 574 *off += read; 575 out: 576 mutex_unlock(&tsdata->mutex); 577 return error ?: read; 578 }; 579 580 581 static const struct file_operations debugfs_raw_data_fops = { 582 .open = edt_ft5x06_debugfs_raw_data_open, 583 .read = edt_ft5x06_debugfs_raw_data_read, 584 }; 585 586 static void __devinit 587 edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata, 588 const char *debugfs_name) 589 { 590 tsdata->debug_dir = debugfs_create_dir(debugfs_name, NULL); 591 if (!tsdata->debug_dir) 592 return; 593 594 debugfs_create_u16("num_x", S_IRUSR, tsdata->debug_dir, &tsdata->num_x); 595 debugfs_create_u16("num_y", S_IRUSR, tsdata->debug_dir, &tsdata->num_y); 596 597 debugfs_create_file("mode", S_IRUSR | S_IWUSR, 598 tsdata->debug_dir, tsdata, &debugfs_mode_fops); 599 debugfs_create_file("raw_data", S_IRUSR, 600 tsdata->debug_dir, tsdata, &debugfs_raw_data_fops); 601 } 602 603 static void __devexit 604 edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata) 605 { 606 if (tsdata->debug_dir) 607 debugfs_remove_recursive(tsdata->debug_dir); 608 kfree(tsdata->raw_buffer); 609 } 610 611 #else 612 613 static inline void 614 edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata, 615 const char *debugfs_name) 616 { 617 } 618 619 static inline void 620 edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata) 621 { 622 } 623 624 #endif /* CONFIG_DEBUGFS */ 625 626 627 628 static int __devinit edt_ft5x06_ts_reset(struct i2c_client *client, 629 int reset_pin) 630 { 631 int error; 632 633 if (gpio_is_valid(reset_pin)) { 634 /* this pulls reset down, enabling the low active reset */ 635 error = gpio_request_one(reset_pin, GPIOF_OUT_INIT_LOW, 636 "edt-ft5x06 reset"); 637 if (error) { 638 dev_err(&client->dev, 639 "Failed to request GPIO %d as reset pin, error %d\n", 640 reset_pin, error); 641 return error; 642 } 643 644 mdelay(50); 645 gpio_set_value(reset_pin, 1); 646 mdelay(100); 647 } 648 649 return 0; 650 } 651 652 static int __devinit edt_ft5x06_ts_identify(struct i2c_client *client, 653 char *model_name, 654 char *fw_version) 655 { 656 u8 rdbuf[EDT_NAME_LEN]; 657 char *p; 658 int error; 659 660 error = edt_ft5x06_ts_readwrite(client, 1, "\xbb", 661 EDT_NAME_LEN - 1, rdbuf); 662 if (error) 663 return error; 664 665 /* remove last '$' end marker */ 666 rdbuf[EDT_NAME_LEN - 1] = '\0'; 667 if (rdbuf[EDT_NAME_LEN - 2] == '$') 668 rdbuf[EDT_NAME_LEN - 2] = '\0'; 669 670 /* look for Model/Version separator */ 671 p = strchr(rdbuf, '*'); 672 if (p) 673 *p++ = '\0'; 674 675 strlcpy(model_name, rdbuf + 1, EDT_NAME_LEN); 676 strlcpy(fw_version, p ? p : "", EDT_NAME_LEN); 677 678 return 0; 679 } 680 681 #define EDT_ATTR_CHECKSET(name, reg) \ 682 if (pdata->name >= edt_ft5x06_attr_##name.limit_low && \ 683 pdata->name <= edt_ft5x06_attr_##name.limit_high) \ 684 edt_ft5x06_register_write(tsdata, reg, pdata->name) 685 686 static void __devinit 687 edt_ft5x06_ts_get_defaults(struct edt_ft5x06_ts_data *tsdata, 688 const struct edt_ft5x06_platform_data *pdata) 689 { 690 if (!pdata->use_parameters) 691 return; 692 693 /* pick up defaults from the platform data */ 694 EDT_ATTR_CHECKSET(threshold, WORK_REGISTER_THRESHOLD); 695 EDT_ATTR_CHECKSET(gain, WORK_REGISTER_GAIN); 696 EDT_ATTR_CHECKSET(offset, WORK_REGISTER_OFFSET); 697 EDT_ATTR_CHECKSET(report_rate, WORK_REGISTER_REPORT_RATE); 698 } 699 700 static void __devinit 701 edt_ft5x06_ts_get_parameters(struct edt_ft5x06_ts_data *tsdata) 702 { 703 tsdata->threshold = edt_ft5x06_register_read(tsdata, 704 WORK_REGISTER_THRESHOLD); 705 tsdata->gain = edt_ft5x06_register_read(tsdata, WORK_REGISTER_GAIN); 706 tsdata->offset = edt_ft5x06_register_read(tsdata, WORK_REGISTER_OFFSET); 707 tsdata->report_rate = edt_ft5x06_register_read(tsdata, 708 WORK_REGISTER_REPORT_RATE); 709 tsdata->num_x = edt_ft5x06_register_read(tsdata, WORK_REGISTER_NUM_X); 710 tsdata->num_y = edt_ft5x06_register_read(tsdata, WORK_REGISTER_NUM_Y); 711 } 712 713 static int __devinit edt_ft5x06_ts_probe(struct i2c_client *client, 714 const struct i2c_device_id *id) 715 { 716 const struct edt_ft5x06_platform_data *pdata = 717 client->dev.platform_data; 718 struct edt_ft5x06_ts_data *tsdata; 719 struct input_dev *input; 720 int error; 721 char fw_version[EDT_NAME_LEN]; 722 723 dev_dbg(&client->dev, "probing for EDT FT5x06 I2C\n"); 724 725 if (!pdata) { 726 dev_err(&client->dev, "no platform data?\n"); 727 return -EINVAL; 728 } 729 730 error = edt_ft5x06_ts_reset(client, pdata->reset_pin); 731 if (error) 732 return error; 733 734 if (gpio_is_valid(pdata->irq_pin)) { 735 error = gpio_request_one(pdata->irq_pin, 736 GPIOF_IN, "edt-ft5x06 irq"); 737 if (error) { 738 dev_err(&client->dev, 739 "Failed to request GPIO %d, error %d\n", 740 pdata->irq_pin, error); 741 return error; 742 } 743 } 744 745 tsdata = kzalloc(sizeof(*tsdata), GFP_KERNEL); 746 input = input_allocate_device(); 747 if (!tsdata || !input) { 748 dev_err(&client->dev, "failed to allocate driver data.\n"); 749 error = -ENOMEM; 750 goto err_free_mem; 751 } 752 753 mutex_init(&tsdata->mutex); 754 tsdata->client = client; 755 tsdata->input = input; 756 tsdata->factory_mode = false; 757 758 error = edt_ft5x06_ts_identify(client, tsdata->name, fw_version); 759 if (error) { 760 dev_err(&client->dev, "touchscreen probe failed\n"); 761 goto err_free_mem; 762 } 763 764 edt_ft5x06_ts_get_defaults(tsdata, pdata); 765 edt_ft5x06_ts_get_parameters(tsdata); 766 767 dev_dbg(&client->dev, 768 "Model \"%s\", Rev. \"%s\", %dx%d sensors\n", 769 tsdata->name, fw_version, tsdata->num_x, tsdata->num_y); 770 771 input->name = tsdata->name; 772 input->id.bustype = BUS_I2C; 773 input->dev.parent = &client->dev; 774 775 __set_bit(EV_SYN, input->evbit); 776 __set_bit(EV_KEY, input->evbit); 777 __set_bit(EV_ABS, input->evbit); 778 __set_bit(BTN_TOUCH, input->keybit); 779 input_set_abs_params(input, ABS_X, 0, tsdata->num_x * 64 - 1, 0, 0); 780 input_set_abs_params(input, ABS_Y, 0, tsdata->num_y * 64 - 1, 0, 0); 781 input_set_abs_params(input, ABS_MT_POSITION_X, 782 0, tsdata->num_x * 64 - 1, 0, 0); 783 input_set_abs_params(input, ABS_MT_POSITION_Y, 784 0, tsdata->num_y * 64 - 1, 0, 0); 785 error = input_mt_init_slots(input, MAX_SUPPORT_POINTS, 0); 786 if (error) { 787 dev_err(&client->dev, "Unable to init MT slots.\n"); 788 goto err_free_mem; 789 } 790 791 input_set_drvdata(input, tsdata); 792 i2c_set_clientdata(client, tsdata); 793 794 error = request_threaded_irq(client->irq, NULL, edt_ft5x06_ts_isr, 795 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 796 client->name, tsdata); 797 if (error) { 798 dev_err(&client->dev, "Unable to request touchscreen IRQ.\n"); 799 goto err_free_mem; 800 } 801 802 error = sysfs_create_group(&client->dev.kobj, &edt_ft5x06_attr_group); 803 if (error) 804 goto err_free_irq; 805 806 error = input_register_device(input); 807 if (error) 808 goto err_remove_attrs; 809 810 edt_ft5x06_ts_prepare_debugfs(tsdata, dev_driver_string(&client->dev)); 811 device_init_wakeup(&client->dev, 1); 812 813 dev_dbg(&client->dev, 814 "EDT FT5x06 initialized: IRQ pin %d, Reset pin %d.\n", 815 pdata->irq_pin, pdata->reset_pin); 816 817 return 0; 818 819 err_remove_attrs: 820 sysfs_remove_group(&client->dev.kobj, &edt_ft5x06_attr_group); 821 err_free_irq: 822 free_irq(client->irq, tsdata); 823 err_free_mem: 824 input_free_device(input); 825 kfree(tsdata); 826 827 if (gpio_is_valid(pdata->irq_pin)) 828 gpio_free(pdata->irq_pin); 829 830 return error; 831 } 832 833 static int __devexit edt_ft5x06_ts_remove(struct i2c_client *client) 834 { 835 const struct edt_ft5x06_platform_data *pdata = 836 dev_get_platdata(&client->dev); 837 struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client); 838 839 edt_ft5x06_ts_teardown_debugfs(tsdata); 840 sysfs_remove_group(&client->dev.kobj, &edt_ft5x06_attr_group); 841 842 free_irq(client->irq, tsdata); 843 input_unregister_device(tsdata->input); 844 845 if (gpio_is_valid(pdata->irq_pin)) 846 gpio_free(pdata->irq_pin); 847 if (gpio_is_valid(pdata->reset_pin)) 848 gpio_free(pdata->reset_pin); 849 850 kfree(tsdata); 851 852 return 0; 853 } 854 855 #ifdef CONFIG_PM_SLEEP 856 static int edt_ft5x06_ts_suspend(struct device *dev) 857 { 858 struct i2c_client *client = to_i2c_client(dev); 859 860 if (device_may_wakeup(dev)) 861 enable_irq_wake(client->irq); 862 863 return 0; 864 } 865 866 static int edt_ft5x06_ts_resume(struct device *dev) 867 { 868 struct i2c_client *client = to_i2c_client(dev); 869 870 if (device_may_wakeup(dev)) 871 disable_irq_wake(client->irq); 872 873 return 0; 874 } 875 #endif 876 877 static SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops, 878 edt_ft5x06_ts_suspend, edt_ft5x06_ts_resume); 879 880 static const struct i2c_device_id edt_ft5x06_ts_id[] = { 881 { "edt-ft5x06", 0 }, 882 { } 883 }; 884 MODULE_DEVICE_TABLE(i2c, edt_ft5x06_ts_id); 885 886 static struct i2c_driver edt_ft5x06_ts_driver = { 887 .driver = { 888 .owner = THIS_MODULE, 889 .name = "edt_ft5x06", 890 .pm = &edt_ft5x06_ts_pm_ops, 891 }, 892 .id_table = edt_ft5x06_ts_id, 893 .probe = edt_ft5x06_ts_probe, 894 .remove = __devexit_p(edt_ft5x06_ts_remove), 895 }; 896 897 module_i2c_driver(edt_ft5x06_ts_driver); 898 899 MODULE_AUTHOR("Simon Budig <simon.budig@kernelconcepts.de>"); 900 MODULE_DESCRIPTION("EDT FT5x06 I2C Touchscreen Driver"); 901 MODULE_LICENSE("GPL"); 902