hid-ntrig.c revision f41a52d3010579949a3b9fd76783120d9643b60b
1/* 2 * HID driver for N-Trig touchscreens 3 * 4 * Copyright (c) 2008-2010 Rafi Rubin 5 * Copyright (c) 2009-2010 Stephane Chatty 6 * 7 */ 8 9/* 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the Free 12 * Software Foundation; either version 2 of the License, or (at your option) 13 * any later version. 14 */ 15 16#include <linux/device.h> 17#include <linux/hid.h> 18#include <linux/usb.h> 19#include "usbhid/usbhid.h" 20#include <linux/module.h> 21#include <linux/slab.h> 22 23#include "hid-ids.h" 24 25#define NTRIG_DUPLICATE_USAGES 0x001 26 27static unsigned int min_width; 28module_param(min_width, uint, 0644); 29MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept."); 30 31static unsigned int min_height; 32module_param(min_height, uint, 0644); 33MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept."); 34 35static unsigned int activate_slack = 1; 36module_param(activate_slack, uint, 0644); 37MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at " 38 "the start of touch input."); 39 40static unsigned int deactivate_slack = 4; 41module_param(deactivate_slack, uint, 0644); 42MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before " 43 "deactivating touch."); 44 45static unsigned int activation_width = 64; 46module_param(activation_width, uint, 0644); 47MODULE_PARM_DESC(activation_width, "Width threshold to immediately start " 48 "processing touch events."); 49 50static unsigned int activation_height = 32; 51module_param(activation_height, uint, 0644); 52MODULE_PARM_DESC(activation_height, "Height threshold to immediately start " 53 "processing touch events."); 54 55struct ntrig_data { 56 /* Incoming raw values for a single contact */ 57 __u16 x, y, w, h; 58 __u16 id; 59 60 bool tipswitch; 61 bool confidence; 62 bool first_contact_touch; 63 64 bool reading_mt; 65 66 __u8 mt_footer[4]; 67 __u8 mt_foot_count; 68 69 /* The current activation state. */ 70 __s8 act_state; 71 72 /* Empty frames to ignore before recognizing the end of activity */ 73 __s8 deactivate_slack; 74 75 /* Frames to ignore before acknowledging the start of activity */ 76 __s8 activate_slack; 77 78 /* Minimum size contact to accept */ 79 __u16 min_width; 80 __u16 min_height; 81 82 /* Threshold to override activation slack */ 83 __u16 activation_width; 84 __u16 activation_height; 85 86 __u16 sensor_logical_width; 87 __u16 sensor_logical_height; 88 __u16 sensor_physical_width; 89 __u16 sensor_physical_height; 90}; 91 92 93/* 94 * This function converts the 4 byte raw firmware code into 95 * a string containing 5 comma separated numbers. 96 */ 97static int ntrig_version_string(unsigned char *raw, char *buf) 98{ 99 __u8 a = (raw[1] & 0x0e) >> 1; 100 __u8 b = (raw[0] & 0x3c) >> 2; 101 __u8 c = ((raw[0] & 0x03) << 3) | ((raw[3] & 0xe0) >> 5); 102 __u8 d = ((raw[3] & 0x07) << 3) | ((raw[2] & 0xe0) >> 5); 103 __u8 e = raw[2] & 0x07; 104 105 /* 106 * As yet unmapped bits: 107 * 0b11000000 0b11110001 0b00011000 0b00011000 108 */ 109 110 return sprintf(buf, "%u.%u.%u.%u.%u", a, b, c, d, e); 111} 112 113static void ntrig_report_version(struct hid_device *hdev) 114{ 115 int ret; 116 char buf[20]; 117 struct usb_device *usb_dev = hid_to_usb_dev(hdev); 118 unsigned char *data = kmalloc(8, GFP_KERNEL); 119 120 if (!data) 121 goto err_free; 122 123 ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0), 124 USB_REQ_CLEAR_FEATURE, 125 USB_TYPE_CLASS | USB_RECIP_INTERFACE | 126 USB_DIR_IN, 127 0x30c, 1, data, 8, 128 USB_CTRL_SET_TIMEOUT); 129 130 if (ret == 8) { 131 ret = ntrig_version_string(&data[2], buf); 132 133 hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n", 134 buf, data[2], data[3], data[4], data[5]); 135 } 136 137err_free: 138 kfree(data); 139} 140 141static ssize_t show_phys_width(struct device *dev, 142 struct device_attribute *attr, 143 char *buf) 144{ 145 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 146 struct ntrig_data *nd = hid_get_drvdata(hdev); 147 148 return sprintf(buf, "%d\n", nd->sensor_physical_width); 149} 150 151static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL); 152 153static ssize_t show_phys_height(struct device *dev, 154 struct device_attribute *attr, 155 char *buf) 156{ 157 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 158 struct ntrig_data *nd = hid_get_drvdata(hdev); 159 160 return sprintf(buf, "%d\n", nd->sensor_physical_height); 161} 162 163static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL); 164 165static ssize_t show_log_width(struct device *dev, 166 struct device_attribute *attr, 167 char *buf) 168{ 169 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 170 struct ntrig_data *nd = hid_get_drvdata(hdev); 171 172 return sprintf(buf, "%d\n", nd->sensor_logical_width); 173} 174 175static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL); 176 177static ssize_t show_log_height(struct device *dev, 178 struct device_attribute *attr, 179 char *buf) 180{ 181 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 182 struct ntrig_data *nd = hid_get_drvdata(hdev); 183 184 return sprintf(buf, "%d\n", nd->sensor_logical_height); 185} 186 187static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL); 188 189static ssize_t show_min_width(struct device *dev, 190 struct device_attribute *attr, 191 char *buf) 192{ 193 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 194 struct ntrig_data *nd = hid_get_drvdata(hdev); 195 196 return sprintf(buf, "%d\n", nd->min_width * 197 nd->sensor_physical_width / 198 nd->sensor_logical_width); 199} 200 201static ssize_t set_min_width(struct device *dev, 202 struct device_attribute *attr, 203 const char *buf, size_t count) 204{ 205 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 206 struct ntrig_data *nd = hid_get_drvdata(hdev); 207 208 unsigned long val; 209 210 if (strict_strtoul(buf, 0, &val)) 211 return -EINVAL; 212 213 if (val > nd->sensor_physical_width) 214 return -EINVAL; 215 216 nd->min_width = val * nd->sensor_logical_width / 217 nd->sensor_physical_width; 218 219 return count; 220} 221 222static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width); 223 224static ssize_t show_min_height(struct device *dev, 225 struct device_attribute *attr, 226 char *buf) 227{ 228 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 229 struct ntrig_data *nd = hid_get_drvdata(hdev); 230 231 return sprintf(buf, "%d\n", nd->min_height * 232 nd->sensor_physical_height / 233 nd->sensor_logical_height); 234} 235 236static ssize_t set_min_height(struct device *dev, 237 struct device_attribute *attr, 238 const char *buf, size_t count) 239{ 240 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 241 struct ntrig_data *nd = hid_get_drvdata(hdev); 242 243 unsigned long val; 244 245 if (strict_strtoul(buf, 0, &val)) 246 return -EINVAL; 247 248 if (val > nd->sensor_physical_height) 249 return -EINVAL; 250 251 nd->min_height = val * nd->sensor_logical_height / 252 nd->sensor_physical_height; 253 254 return count; 255} 256 257static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height, 258 set_min_height); 259 260static ssize_t show_activate_slack(struct device *dev, 261 struct device_attribute *attr, 262 char *buf) 263{ 264 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 265 struct ntrig_data *nd = hid_get_drvdata(hdev); 266 267 return sprintf(buf, "%d\n", nd->activate_slack); 268} 269 270static ssize_t set_activate_slack(struct device *dev, 271 struct device_attribute *attr, 272 const char *buf, size_t count) 273{ 274 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 275 struct ntrig_data *nd = hid_get_drvdata(hdev); 276 277 unsigned long val; 278 279 if (strict_strtoul(buf, 0, &val)) 280 return -EINVAL; 281 282 if (val > 0x7f) 283 return -EINVAL; 284 285 nd->activate_slack = val; 286 287 return count; 288} 289 290static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack, 291 set_activate_slack); 292 293static ssize_t show_activation_width(struct device *dev, 294 struct device_attribute *attr, 295 char *buf) 296{ 297 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 298 struct ntrig_data *nd = hid_get_drvdata(hdev); 299 300 return sprintf(buf, "%d\n", nd->activation_width * 301 nd->sensor_physical_width / 302 nd->sensor_logical_width); 303} 304 305static ssize_t set_activation_width(struct device *dev, 306 struct device_attribute *attr, 307 const char *buf, size_t count) 308{ 309 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 310 struct ntrig_data *nd = hid_get_drvdata(hdev); 311 312 unsigned long val; 313 314 if (strict_strtoul(buf, 0, &val)) 315 return -EINVAL; 316 317 if (val > nd->sensor_physical_width) 318 return -EINVAL; 319 320 nd->activation_width = val * nd->sensor_logical_width / 321 nd->sensor_physical_width; 322 323 return count; 324} 325 326static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width, 327 set_activation_width); 328 329static ssize_t show_activation_height(struct device *dev, 330 struct device_attribute *attr, 331 char *buf) 332{ 333 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 334 struct ntrig_data *nd = hid_get_drvdata(hdev); 335 336 return sprintf(buf, "%d\n", nd->activation_height * 337 nd->sensor_physical_height / 338 nd->sensor_logical_height); 339} 340 341static ssize_t set_activation_height(struct device *dev, 342 struct device_attribute *attr, 343 const char *buf, size_t count) 344{ 345 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 346 struct ntrig_data *nd = hid_get_drvdata(hdev); 347 348 unsigned long val; 349 350 if (strict_strtoul(buf, 0, &val)) 351 return -EINVAL; 352 353 if (val > nd->sensor_physical_height) 354 return -EINVAL; 355 356 nd->activation_height = val * nd->sensor_logical_height / 357 nd->sensor_physical_height; 358 359 return count; 360} 361 362static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO, 363 show_activation_height, set_activation_height); 364 365static ssize_t show_deactivate_slack(struct device *dev, 366 struct device_attribute *attr, 367 char *buf) 368{ 369 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 370 struct ntrig_data *nd = hid_get_drvdata(hdev); 371 372 return sprintf(buf, "%d\n", -nd->deactivate_slack); 373} 374 375static ssize_t set_deactivate_slack(struct device *dev, 376 struct device_attribute *attr, 377 const char *buf, size_t count) 378{ 379 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 380 struct ntrig_data *nd = hid_get_drvdata(hdev); 381 382 unsigned long val; 383 384 if (strict_strtoul(buf, 0, &val)) 385 return -EINVAL; 386 387 /* 388 * No more than 8 terminal frames have been observed so far 389 * and higher slack is highly likely to leave the single 390 * touch emulation stuck down. 391 */ 392 if (val > 7) 393 return -EINVAL; 394 395 nd->deactivate_slack = -val; 396 397 return count; 398} 399 400static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack, 401 set_deactivate_slack); 402 403static struct attribute *sysfs_attrs[] = { 404 &dev_attr_sensor_physical_width.attr, 405 &dev_attr_sensor_physical_height.attr, 406 &dev_attr_sensor_logical_width.attr, 407 &dev_attr_sensor_logical_height.attr, 408 &dev_attr_min_height.attr, 409 &dev_attr_min_width.attr, 410 &dev_attr_activate_slack.attr, 411 &dev_attr_activation_width.attr, 412 &dev_attr_activation_height.attr, 413 &dev_attr_deactivate_slack.attr, 414 NULL 415}; 416 417static struct attribute_group ntrig_attribute_group = { 418 .attrs = sysfs_attrs 419}; 420 421/* 422 * this driver is aimed at two firmware versions in circulation: 423 * - dual pen/finger single touch 424 * - finger multitouch, pen not working 425 */ 426 427static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi, 428 struct hid_field *field, struct hid_usage *usage, 429 unsigned long **bit, int *max) 430{ 431 struct ntrig_data *nd = hid_get_drvdata(hdev); 432 433 /* No special mappings needed for the pen and single touch */ 434 if (field->physical) 435 return 0; 436 437 switch (usage->hid & HID_USAGE_PAGE) { 438 case HID_UP_GENDESK: 439 switch (usage->hid) { 440 case HID_GD_X: 441 hid_map_usage(hi, usage, bit, max, 442 EV_ABS, ABS_MT_POSITION_X); 443 input_set_abs_params(hi->input, ABS_X, 444 field->logical_minimum, 445 field->logical_maximum, 0, 0); 446 447 if (!nd->sensor_logical_width) { 448 nd->sensor_logical_width = 449 field->logical_maximum - 450 field->logical_minimum; 451 nd->sensor_physical_width = 452 field->physical_maximum - 453 field->physical_minimum; 454 nd->activation_width = activation_width * 455 nd->sensor_logical_width / 456 nd->sensor_physical_width; 457 nd->min_width = min_width * 458 nd->sensor_logical_width / 459 nd->sensor_physical_width; 460 } 461 return 1; 462 case HID_GD_Y: 463 hid_map_usage(hi, usage, bit, max, 464 EV_ABS, ABS_MT_POSITION_Y); 465 input_set_abs_params(hi->input, ABS_Y, 466 field->logical_minimum, 467 field->logical_maximum, 0, 0); 468 469 if (!nd->sensor_logical_height) { 470 nd->sensor_logical_height = 471 field->logical_maximum - 472 field->logical_minimum; 473 nd->sensor_physical_height = 474 field->physical_maximum - 475 field->physical_minimum; 476 nd->activation_height = activation_height * 477 nd->sensor_logical_height / 478 nd->sensor_physical_height; 479 nd->min_height = min_height * 480 nd->sensor_logical_height / 481 nd->sensor_physical_height; 482 } 483 return 1; 484 } 485 return 0; 486 487 case HID_UP_DIGITIZER: 488 switch (usage->hid) { 489 /* we do not want to map these for now */ 490 case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */ 491 case HID_DG_INPUTMODE: 492 case HID_DG_DEVICEINDEX: 493 case HID_DG_CONTACTMAX: 494 return -1; 495 496 /* width/height mapped on TouchMajor/TouchMinor/Orientation */ 497 case HID_DG_WIDTH: 498 hid_map_usage(hi, usage, bit, max, 499 EV_ABS, ABS_MT_TOUCH_MAJOR); 500 return 1; 501 case HID_DG_HEIGHT: 502 hid_map_usage(hi, usage, bit, max, 503 EV_ABS, ABS_MT_TOUCH_MINOR); 504 input_set_abs_params(hi->input, ABS_MT_ORIENTATION, 505 0, 1, 0, 0); 506 return 1; 507 } 508 return 0; 509 510 case 0xff000000: 511 /* we do not want to map these: no input-oriented meaning */ 512 return -1; 513 } 514 515 return 0; 516} 517 518static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi, 519 struct hid_field *field, struct hid_usage *usage, 520 unsigned long **bit, int *max) 521{ 522 /* No special mappings needed for the pen and single touch */ 523 if (field->physical) 524 return 0; 525 526 if (usage->type == EV_KEY || usage->type == EV_REL 527 || usage->type == EV_ABS) 528 clear_bit(usage->code, *bit); 529 530 return 0; 531} 532 533/* 534 * this function is called upon all reports 535 * so that we can filter contact point information, 536 * decide whether we are in multi or single touch mode 537 * and call input_mt_sync after each point if necessary 538 */ 539static int ntrig_event (struct hid_device *hid, struct hid_field *field, 540 struct hid_usage *usage, __s32 value) 541{ 542 struct ntrig_data *nd = hid_get_drvdata(hid); 543 struct input_dev *input; 544 545 /* Skip processing if not a claimed input */ 546 if (!(hid->claimed & HID_CLAIMED_INPUT)) 547 goto not_claimed_input; 548 549 /* This function is being called before the structures are fully 550 * initialized */ 551 if(!(field->hidinput && field->hidinput->input)) 552 return -EINVAL; 553 554 input = field->hidinput->input; 555 556 /* No special handling needed for the pen */ 557 if (field->application == HID_DG_PEN) 558 return 0; 559 560 if (hid->claimed & HID_CLAIMED_INPUT) { 561 switch (usage->hid) { 562 case 0xff000001: 563 /* Tag indicating the start of a multitouch group */ 564 nd->reading_mt = 1; 565 nd->first_contact_touch = 0; 566 break; 567 case HID_DG_TIPSWITCH: 568 nd->tipswitch = value; 569 /* Prevent emission of touch until validated */ 570 return 1; 571 case HID_DG_CONFIDENCE: 572 nd->confidence = value; 573 break; 574 case HID_GD_X: 575 nd->x = value; 576 /* Clear the contact footer */ 577 nd->mt_foot_count = 0; 578 break; 579 case HID_GD_Y: 580 nd->y = value; 581 break; 582 case HID_DG_CONTACTID: 583 nd->id = value; 584 break; 585 case HID_DG_WIDTH: 586 nd->w = value; 587 break; 588 case HID_DG_HEIGHT: 589 nd->h = value; 590 /* 591 * when in single touch mode, this is the last 592 * report received in a finger event. We want 593 * to emit a normal (X, Y) position 594 */ 595 if (!nd->reading_mt) { 596 /* 597 * TipSwitch indicates the presence of a 598 * finger in single touch mode. 599 */ 600 input_report_key(input, BTN_TOUCH, 601 nd->tipswitch); 602 input_report_key(input, BTN_TOOL_DOUBLETAP, 603 nd->tipswitch); 604 input_event(input, EV_ABS, ABS_X, nd->x); 605 input_event(input, EV_ABS, ABS_Y, nd->y); 606 } 607 break; 608 case 0xff000002: 609 /* 610 * we receive this when the device is in multitouch 611 * mode. The first of the three values tagged with 612 * this usage tells if the contact point is real 613 * or a placeholder 614 */ 615 616 /* Shouldn't get more than 4 footer packets, so skip */ 617 if (nd->mt_foot_count >= 4) 618 break; 619 620 nd->mt_footer[nd->mt_foot_count++] = value; 621 622 /* if the footer isn't complete break */ 623 if (nd->mt_foot_count != 4) 624 break; 625 626 /* Pen activity signal. */ 627 if (nd->mt_footer[2]) { 628 /* 629 * When the pen deactivates touch, we see a 630 * bogus frame with ContactCount > 0. 631 * We can 632 * save a bit of work by ensuring act_state < 0 633 * even if deactivation slack is turned off. 634 */ 635 nd->act_state = deactivate_slack - 1; 636 nd->confidence = 0; 637 break; 638 } 639 640 /* 641 * The first footer value indicates the presence of a 642 * finger. 643 */ 644 if (nd->mt_footer[0]) { 645 /* 646 * We do not want to process contacts under 647 * the size threshold, but do not want to 648 * ignore them for activation state 649 */ 650 if (nd->w < nd->min_width || 651 nd->h < nd->min_height) 652 nd->confidence = 0; 653 } else 654 break; 655 656 if (nd->act_state > 0) { 657 /* 658 * Contact meets the activation size threshold 659 */ 660 if (nd->w >= nd->activation_width && 661 nd->h >= nd->activation_height) { 662 if (nd->id) 663 /* 664 * first contact, activate now 665 */ 666 nd->act_state = 0; 667 else { 668 /* 669 * avoid corrupting this frame 670 * but ensure next frame will 671 * be active 672 */ 673 nd->act_state = 1; 674 break; 675 } 676 } else 677 /* 678 * Defer adjusting the activation state 679 * until the end of the frame. 680 */ 681 break; 682 } 683 684 /* Discarding this contact */ 685 if (!nd->confidence) 686 break; 687 688 /* emit a normal (X, Y) for the first point only */ 689 if (nd->id == 0) { 690 /* 691 * TipSwitch is superfluous in multitouch 692 * mode. The footer events tell us 693 * if there is a finger on the screen or 694 * not. 695 */ 696 nd->first_contact_touch = nd->confidence; 697 input_event(input, EV_ABS, ABS_X, nd->x); 698 input_event(input, EV_ABS, ABS_Y, nd->y); 699 } 700 701 /* Emit MT events */ 702 input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x); 703 input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y); 704 705 /* 706 * Translate from height and width to size 707 * and orientation. 708 */ 709 if (nd->w > nd->h) { 710 input_event(input, EV_ABS, 711 ABS_MT_ORIENTATION, 1); 712 input_event(input, EV_ABS, 713 ABS_MT_TOUCH_MAJOR, nd->w); 714 input_event(input, EV_ABS, 715 ABS_MT_TOUCH_MINOR, nd->h); 716 } else { 717 input_event(input, EV_ABS, 718 ABS_MT_ORIENTATION, 0); 719 input_event(input, EV_ABS, 720 ABS_MT_TOUCH_MAJOR, nd->h); 721 input_event(input, EV_ABS, 722 ABS_MT_TOUCH_MINOR, nd->w); 723 } 724 input_mt_sync(field->hidinput->input); 725 break; 726 727 case HID_DG_CONTACTCOUNT: /* End of a multitouch group */ 728 if (!nd->reading_mt) /* Just to be sure */ 729 break; 730 731 nd->reading_mt = 0; 732 733 734 /* 735 * Activation state machine logic: 736 * 737 * Fundamental states: 738 * state > 0: Inactive 739 * state <= 0: Active 740 * state < -deactivate_slack: 741 * Pen termination of touch 742 * 743 * Specific values of interest 744 * state == activate_slack 745 * no valid input since the last reset 746 * 747 * state == 0 748 * general operational state 749 * 750 * state == -deactivate_slack 751 * read sufficient empty frames to accept 752 * the end of input and reset 753 */ 754 755 if (nd->act_state > 0) { /* Currently inactive */ 756 if (value) 757 /* 758 * Consider each live contact as 759 * evidence of intentional activity. 760 */ 761 nd->act_state = (nd->act_state > value) 762 ? nd->act_state - value 763 : 0; 764 else 765 /* 766 * Empty frame before we hit the 767 * activity threshold, reset. 768 */ 769 nd->act_state = nd->activate_slack; 770 771 /* 772 * Entered this block inactive and no 773 * coordinates sent this frame, so hold off 774 * on button state. 775 */ 776 break; 777 } else { /* Currently active */ 778 if (value && nd->act_state >= 779 nd->deactivate_slack) 780 /* 781 * Live point: clear accumulated 782 * deactivation count. 783 */ 784 nd->act_state = 0; 785 else if (nd->act_state <= nd->deactivate_slack) 786 /* 787 * We've consumed the deactivation 788 * slack, time to deactivate and reset. 789 */ 790 nd->act_state = 791 nd->activate_slack; 792 else { /* Move towards deactivation */ 793 nd->act_state--; 794 break; 795 } 796 } 797 798 if (nd->first_contact_touch && nd->act_state <= 0) { 799 /* 800 * Check to see if we're ready to start 801 * emitting touch events. 802 * 803 * Note: activation slack will decrease over 804 * the course of the frame, and it will be 805 * inconsistent from the start to the end of 806 * the frame. However if the frame starts 807 * with slack, first_contact_touch will still 808 * be 0 and we will not get to this point. 809 */ 810 input_report_key(input, BTN_TOOL_DOUBLETAP, 1); 811 input_report_key(input, BTN_TOUCH, 1); 812 } else { 813 input_report_key(input, BTN_TOOL_DOUBLETAP, 0); 814 input_report_key(input, BTN_TOUCH, 0); 815 } 816 break; 817 818 default: 819 /* fall-back to the generic hidinput handling */ 820 return 0; 821 } 822 } 823 824not_claimed_input: 825 826 /* we have handled the hidinput part, now remains hiddev */ 827 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event) 828 hid->hiddev_hid_event(hid, field, usage, value); 829 830 return 1; 831} 832 833static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id) 834{ 835 int ret; 836 struct ntrig_data *nd; 837 struct hid_input *hidinput; 838 struct input_dev *input; 839 struct hid_report *report; 840 841 if (id->driver_data) 842 hdev->quirks |= HID_QUIRK_MULTI_INPUT; 843 844 nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL); 845 if (!nd) { 846 hid_err(hdev, "cannot allocate N-Trig data\n"); 847 return -ENOMEM; 848 } 849 850 nd->reading_mt = 0; 851 nd->min_width = 0; 852 nd->min_height = 0; 853 nd->activate_slack = activate_slack; 854 nd->act_state = activate_slack; 855 nd->deactivate_slack = -deactivate_slack; 856 nd->sensor_logical_width = 0; 857 nd->sensor_logical_height = 0; 858 nd->sensor_physical_width = 0; 859 nd->sensor_physical_height = 0; 860 861 hid_set_drvdata(hdev, nd); 862 863 ret = hid_parse(hdev); 864 if (ret) { 865 hid_err(hdev, "parse failed\n"); 866 goto err_free; 867 } 868 869 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF); 870 if (ret) { 871 hid_err(hdev, "hw start failed\n"); 872 goto err_free; 873 } 874 875 876 list_for_each_entry(hidinput, &hdev->inputs, list) { 877 if (hidinput->report->maxfield < 1) 878 continue; 879 880 input = hidinput->input; 881 switch (hidinput->report->field[0]->application) { 882 case HID_DG_PEN: 883 input->name = "N-Trig Pen"; 884 break; 885 case HID_DG_TOUCHSCREEN: 886 /* These keys are redundant for fingers, clear them 887 * to prevent incorrect identification */ 888 __clear_bit(BTN_TOOL_PEN, input->keybit); 889 __clear_bit(BTN_TOOL_FINGER, input->keybit); 890 __clear_bit(BTN_0, input->keybit); 891 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit); 892 /* 893 * The physical touchscreen (single touch) 894 * input has a value for physical, whereas 895 * the multitouch only has logical input 896 * fields. 897 */ 898 input->name = 899 (hidinput->report->field[0] 900 ->physical) ? 901 "N-Trig Touchscreen" : 902 "N-Trig MultiTouch"; 903 break; 904 } 905 } 906 907 /* This is needed for devices with more recent firmware versions */ 908 report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a]; 909 if (report) 910 usbhid_submit_report(hdev, report, USB_DIR_OUT); 911 912 ntrig_report_version(hdev); 913 914 ret = sysfs_create_group(&hdev->dev.kobj, 915 &ntrig_attribute_group); 916 917 return 0; 918err_free: 919 kfree(nd); 920 return ret; 921} 922 923static void ntrig_remove(struct hid_device *hdev) 924{ 925 sysfs_remove_group(&hdev->dev.kobj, 926 &ntrig_attribute_group); 927 hid_hw_stop(hdev); 928 kfree(hid_get_drvdata(hdev)); 929} 930 931static const struct hid_device_id ntrig_devices[] = { 932 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN), 933 .driver_data = NTRIG_DUPLICATE_USAGES }, 934 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1), 935 .driver_data = NTRIG_DUPLICATE_USAGES }, 936 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2), 937 .driver_data = NTRIG_DUPLICATE_USAGES }, 938 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3), 939 .driver_data = NTRIG_DUPLICATE_USAGES }, 940 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4), 941 .driver_data = NTRIG_DUPLICATE_USAGES }, 942 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5), 943 .driver_data = NTRIG_DUPLICATE_USAGES }, 944 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6), 945 .driver_data = NTRIG_DUPLICATE_USAGES }, 946 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7), 947 .driver_data = NTRIG_DUPLICATE_USAGES }, 948 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8), 949 .driver_data = NTRIG_DUPLICATE_USAGES }, 950 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9), 951 .driver_data = NTRIG_DUPLICATE_USAGES }, 952 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10), 953 .driver_data = NTRIG_DUPLICATE_USAGES }, 954 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11), 955 .driver_data = NTRIG_DUPLICATE_USAGES }, 956 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12), 957 .driver_data = NTRIG_DUPLICATE_USAGES }, 958 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13), 959 .driver_data = NTRIG_DUPLICATE_USAGES }, 960 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14), 961 .driver_data = NTRIG_DUPLICATE_USAGES }, 962 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15), 963 .driver_data = NTRIG_DUPLICATE_USAGES }, 964 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16), 965 .driver_data = NTRIG_DUPLICATE_USAGES }, 966 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17), 967 .driver_data = NTRIG_DUPLICATE_USAGES }, 968 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18), 969 .driver_data = NTRIG_DUPLICATE_USAGES }, 970 { } 971}; 972MODULE_DEVICE_TABLE(hid, ntrig_devices); 973 974static const struct hid_usage_id ntrig_grabbed_usages[] = { 975 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID }, 976 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 } 977}; 978 979static struct hid_driver ntrig_driver = { 980 .name = "ntrig", 981 .id_table = ntrig_devices, 982 .probe = ntrig_probe, 983 .remove = ntrig_remove, 984 .input_mapping = ntrig_input_mapping, 985 .input_mapped = ntrig_input_mapped, 986 .usage_table = ntrig_grabbed_usages, 987 .event = ntrig_event, 988}; 989 990static int __init ntrig_init(void) 991{ 992 return hid_register_driver(&ntrig_driver); 993} 994 995static void __exit ntrig_exit(void) 996{ 997 hid_unregister_driver(&ntrig_driver); 998} 999 1000module_init(ntrig_init); 1001module_exit(ntrig_exit); 1002MODULE_LICENSE("GPL"); 1003