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