1 /* 2 * HID driver for multitouch panels 3 * 4 * Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr> 5 * Copyright (c) 2010-2013 Benjamin Tissoires <benjamin.tissoires@gmail.com> 6 * Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France 7 * Copyright (c) 2012-2013 Red Hat, Inc 8 * 9 * This code is partly based on hid-egalax.c: 10 * 11 * Copyright (c) 2010 Stephane Chatty <chatty@enac.fr> 12 * Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se> 13 * Copyright (c) 2010 Canonical, Ltd. 14 * 15 * This code is partly based on hid-3m-pct.c: 16 * 17 * Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr> 18 * Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se> 19 * Copyright (c) 2010 Canonical, Ltd. 20 * 21 */ 22 23 /* 24 * This program is free software; you can redistribute it and/or modify it 25 * under the terms of the GNU General Public License as published by the Free 26 * Software Foundation; either version 2 of the License, or (at your option) 27 * any later version. 28 */ 29 30 /* 31 * This driver is regularly tested thanks to the tool hid-test[1]. 32 * This tool relies on hid-replay[2] and a database of hid devices[3]. 33 * Please run these regression tests before patching this module so that 34 * your patch won't break existing known devices. 35 * 36 * [1] https://github.com/bentiss/hid-test 37 * [2] https://github.com/bentiss/hid-replay 38 * [3] https://github.com/bentiss/hid-devices 39 */ 40 41 #include <linux/device.h> 42 #include <linux/hid.h> 43 #include <linux/module.h> 44 #include <linux/slab.h> 45 #include <linux/input/mt.h> 46 #include <linux/jiffies.h> 47 #include <linux/string.h> 48 #include <linux/timer.h> 49 50 51 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>"); 52 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>"); 53 MODULE_DESCRIPTION("HID multitouch panels"); 54 MODULE_LICENSE("GPL"); 55 56 #include "hid-ids.h" 57 58 /* quirks to control the device */ 59 #define MT_QUIRK_NOT_SEEN_MEANS_UP BIT(0) 60 #define MT_QUIRK_SLOT_IS_CONTACTID BIT(1) 61 #define MT_QUIRK_CYPRESS BIT(2) 62 #define MT_QUIRK_SLOT_IS_CONTACTNUMBER BIT(3) 63 #define MT_QUIRK_ALWAYS_VALID BIT(4) 64 #define MT_QUIRK_VALID_IS_INRANGE BIT(5) 65 #define MT_QUIRK_VALID_IS_CONFIDENCE BIT(6) 66 #define MT_QUIRK_CONFIDENCE BIT(7) 67 #define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE BIT(8) 68 #define MT_QUIRK_NO_AREA BIT(9) 69 #define MT_QUIRK_IGNORE_DUPLICATES BIT(10) 70 #define MT_QUIRK_HOVERING BIT(11) 71 #define MT_QUIRK_CONTACT_CNT_ACCURATE BIT(12) 72 #define MT_QUIRK_FORCE_GET_FEATURE BIT(13) 73 #define MT_QUIRK_FIX_CONST_CONTACT_ID BIT(14) 74 #define MT_QUIRK_TOUCH_SIZE_SCALING BIT(15) 75 #define MT_QUIRK_STICKY_FINGERS BIT(16) 76 #define MT_QUIRK_ASUS_CUSTOM_UP BIT(17) 77 78 #define MT_INPUTMODE_TOUCHSCREEN 0x02 79 #define MT_INPUTMODE_TOUCHPAD 0x03 80 81 #define MT_BUTTONTYPE_CLICKPAD 0 82 83 #define MT_IO_FLAGS_RUNNING 0 84 #define MT_IO_FLAGS_ACTIVE_SLOTS 1 85 #define MT_IO_FLAGS_PENDING_SLOTS 2 86 87 struct mt_slot { 88 __s32 x, y, cx, cy, p, w, h; 89 __s32 contactid; /* the device ContactID assigned to this slot */ 90 bool touch_state; /* is the touch valid? */ 91 bool inrange_state; /* is the finger in proximity of the sensor? */ 92 bool confidence_state; /* is the touch made by a finger? */ 93 }; 94 95 struct mt_class { 96 __s32 name; /* MT_CLS */ 97 __s32 quirks; 98 __s32 sn_move; /* Signal/noise ratio for move events */ 99 __s32 sn_width; /* Signal/noise ratio for width events */ 100 __s32 sn_height; /* Signal/noise ratio for height events */ 101 __s32 sn_pressure; /* Signal/noise ratio for pressure events */ 102 __u8 maxcontacts; 103 bool is_indirect; /* true for touchpads */ 104 bool export_all_inputs; /* do not ignore mouse, keyboards, etc... */ 105 }; 106 107 struct mt_fields { 108 unsigned usages[HID_MAX_FIELDS]; 109 unsigned int length; 110 }; 111 112 struct mt_device { 113 struct mt_slot curdata; /* placeholder of incoming data */ 114 struct mt_class mtclass; /* our mt device class */ 115 struct timer_list release_timer; /* to release sticky fingers */ 116 struct hid_device *hdev; /* hid_device we're attached to */ 117 struct mt_fields *fields; /* temporary placeholder for storing the 118 multitouch fields */ 119 unsigned long mt_io_flags; /* mt flags (MT_IO_FLAGS_*) */ 120 int cc_index; /* contact count field index in the report */ 121 int cc_value_index; /* contact count value index in the field */ 122 unsigned last_slot_field; /* the last field of a slot */ 123 unsigned mt_report_id; /* the report ID of the multitouch device */ 124 unsigned long initial_quirks; /* initial quirks state */ 125 __s16 inputmode; /* InputMode HID feature, -1 if non-existent */ 126 __s16 inputmode_index; /* InputMode HID feature index in the report */ 127 __s16 maxcontact_report_id; /* Maximum Contact Number HID feature, 128 -1 if non-existent */ 129 __u8 inputmode_value; /* InputMode HID feature value */ 130 __u8 num_received; /* how many contacts we received */ 131 __u8 num_expected; /* expected last contact index */ 132 __u8 maxcontacts; 133 __u8 touches_by_report; /* how many touches are present in one report: 134 * 1 means we should use a serial protocol 135 * > 1 means hybrid (multitouch) protocol */ 136 __u8 buttons_count; /* number of physical buttons per touchpad */ 137 bool is_buttonpad; /* is this device a button pad? */ 138 bool serial_maybe; /* need to check for serial protocol */ 139 bool curvalid; /* is the current contact valid? */ 140 unsigned mt_flags; /* flags to pass to input-mt */ 141 __s32 dev_time; /* the scan time provided by the device */ 142 unsigned long jiffies; /* the frame's jiffies */ 143 int timestamp; /* the timestamp to be sent */ 144 }; 145 146 static void mt_post_parse_default_settings(struct mt_device *td); 147 static void mt_post_parse(struct mt_device *td); 148 149 /* classes of device behavior */ 150 #define MT_CLS_DEFAULT 0x0001 151 152 #define MT_CLS_SERIAL 0x0002 153 #define MT_CLS_CONFIDENCE 0x0003 154 #define MT_CLS_CONFIDENCE_CONTACT_ID 0x0004 155 #define MT_CLS_CONFIDENCE_MINUS_ONE 0x0005 156 #define MT_CLS_DUAL_INRANGE_CONTACTID 0x0006 157 #define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0007 158 /* reserved 0x0008 */ 159 #define MT_CLS_INRANGE_CONTACTNUMBER 0x0009 160 #define MT_CLS_NSMU 0x000a 161 /* reserved 0x0010 */ 162 /* reserved 0x0011 */ 163 #define MT_CLS_WIN_8 0x0012 164 #define MT_CLS_EXPORT_ALL_INPUTS 0x0013 165 #define MT_CLS_WIN_8_DUAL 0x0014 166 167 /* vendor specific classes */ 168 #define MT_CLS_3M 0x0101 169 /* reserved 0x0102 */ 170 #define MT_CLS_EGALAX 0x0103 171 #define MT_CLS_EGALAX_SERIAL 0x0104 172 #define MT_CLS_TOPSEED 0x0105 173 #define MT_CLS_PANASONIC 0x0106 174 #define MT_CLS_FLATFROG 0x0107 175 #define MT_CLS_GENERALTOUCH_TWOFINGERS 0x0108 176 #define MT_CLS_GENERALTOUCH_PWT_TENFINGERS 0x0109 177 #define MT_CLS_LG 0x010a 178 #define MT_CLS_ASUS 0x010b 179 #define MT_CLS_VTL 0x0110 180 #define MT_CLS_GOOGLE 0x0111 181 182 #define MT_DEFAULT_MAXCONTACT 10 183 #define MT_MAX_MAXCONTACT 250 184 185 /* 186 * Resync device and local timestamps after that many microseconds without 187 * receiving data. 188 */ 189 #define MAX_TIMESTAMP_INTERVAL 1000000 190 191 #define MT_USB_DEVICE(v, p) HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p) 192 #define MT_BT_DEVICE(v, p) HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p) 193 194 /* 195 * these device-dependent functions determine what slot corresponds 196 * to a valid contact that was just read. 197 */ 198 199 static int cypress_compute_slot(struct mt_device *td) 200 { 201 if (td->curdata.contactid != 0 || td->num_received == 0) 202 return td->curdata.contactid; 203 else 204 return -1; 205 } 206 207 static struct mt_class mt_classes[] = { 208 { .name = MT_CLS_DEFAULT, 209 .quirks = MT_QUIRK_ALWAYS_VALID | 210 MT_QUIRK_CONTACT_CNT_ACCURATE }, 211 { .name = MT_CLS_NSMU, 212 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP }, 213 { .name = MT_CLS_SERIAL, 214 .quirks = MT_QUIRK_ALWAYS_VALID}, 215 { .name = MT_CLS_CONFIDENCE, 216 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE }, 217 { .name = MT_CLS_CONFIDENCE_CONTACT_ID, 218 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 219 MT_QUIRK_SLOT_IS_CONTACTID }, 220 { .name = MT_CLS_CONFIDENCE_MINUS_ONE, 221 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 222 MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE }, 223 { .name = MT_CLS_DUAL_INRANGE_CONTACTID, 224 .quirks = MT_QUIRK_VALID_IS_INRANGE | 225 MT_QUIRK_SLOT_IS_CONTACTID, 226 .maxcontacts = 2 }, 227 { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 228 .quirks = MT_QUIRK_VALID_IS_INRANGE | 229 MT_QUIRK_SLOT_IS_CONTACTNUMBER, 230 .maxcontacts = 2 }, 231 { .name = MT_CLS_INRANGE_CONTACTNUMBER, 232 .quirks = MT_QUIRK_VALID_IS_INRANGE | 233 MT_QUIRK_SLOT_IS_CONTACTNUMBER }, 234 { .name = MT_CLS_WIN_8, 235 .quirks = MT_QUIRK_ALWAYS_VALID | 236 MT_QUIRK_IGNORE_DUPLICATES | 237 MT_QUIRK_HOVERING | 238 MT_QUIRK_CONTACT_CNT_ACCURATE | 239 MT_QUIRK_STICKY_FINGERS }, 240 { .name = MT_CLS_EXPORT_ALL_INPUTS, 241 .quirks = MT_QUIRK_ALWAYS_VALID | 242 MT_QUIRK_CONTACT_CNT_ACCURATE, 243 .export_all_inputs = true }, 244 { .name = MT_CLS_WIN_8_DUAL, 245 .quirks = MT_QUIRK_ALWAYS_VALID | 246 MT_QUIRK_IGNORE_DUPLICATES | 247 MT_QUIRK_HOVERING | 248 MT_QUIRK_CONTACT_CNT_ACCURATE, 249 .export_all_inputs = true }, 250 251 /* 252 * vendor specific classes 253 */ 254 { .name = MT_CLS_3M, 255 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 256 MT_QUIRK_SLOT_IS_CONTACTID | 257 MT_QUIRK_TOUCH_SIZE_SCALING, 258 .sn_move = 2048, 259 .sn_width = 128, 260 .sn_height = 128, 261 .maxcontacts = 60, 262 }, 263 { .name = MT_CLS_EGALAX, 264 .quirks = MT_QUIRK_SLOT_IS_CONTACTID | 265 MT_QUIRK_VALID_IS_INRANGE, 266 .sn_move = 4096, 267 .sn_pressure = 32, 268 }, 269 { .name = MT_CLS_EGALAX_SERIAL, 270 .quirks = MT_QUIRK_SLOT_IS_CONTACTID | 271 MT_QUIRK_ALWAYS_VALID, 272 .sn_move = 4096, 273 .sn_pressure = 32, 274 }, 275 { .name = MT_CLS_TOPSEED, 276 .quirks = MT_QUIRK_ALWAYS_VALID, 277 .is_indirect = true, 278 .maxcontacts = 2, 279 }, 280 { .name = MT_CLS_PANASONIC, 281 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP, 282 .maxcontacts = 4 }, 283 { .name = MT_CLS_GENERALTOUCH_TWOFINGERS, 284 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 285 MT_QUIRK_VALID_IS_INRANGE | 286 MT_QUIRK_SLOT_IS_CONTACTID, 287 .maxcontacts = 2 288 }, 289 { .name = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 290 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 291 MT_QUIRK_SLOT_IS_CONTACTID 292 }, 293 294 { .name = MT_CLS_FLATFROG, 295 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 296 MT_QUIRK_NO_AREA, 297 .sn_move = 2048, 298 .maxcontacts = 40, 299 }, 300 { .name = MT_CLS_LG, 301 .quirks = MT_QUIRK_ALWAYS_VALID | 302 MT_QUIRK_FIX_CONST_CONTACT_ID | 303 MT_QUIRK_IGNORE_DUPLICATES | 304 MT_QUIRK_HOVERING | 305 MT_QUIRK_CONTACT_CNT_ACCURATE }, 306 { .name = MT_CLS_ASUS, 307 .quirks = MT_QUIRK_ALWAYS_VALID | 308 MT_QUIRK_CONTACT_CNT_ACCURATE | 309 MT_QUIRK_ASUS_CUSTOM_UP }, 310 { .name = MT_CLS_VTL, 311 .quirks = MT_QUIRK_ALWAYS_VALID | 312 MT_QUIRK_CONTACT_CNT_ACCURATE | 313 MT_QUIRK_FORCE_GET_FEATURE, 314 }, 315 { .name = MT_CLS_GOOGLE, 316 .quirks = MT_QUIRK_ALWAYS_VALID | 317 MT_QUIRK_CONTACT_CNT_ACCURATE | 318 MT_QUIRK_SLOT_IS_CONTACTID | 319 MT_QUIRK_HOVERING 320 }, 321 { } 322 }; 323 324 static ssize_t mt_show_quirks(struct device *dev, 325 struct device_attribute *attr, 326 char *buf) 327 { 328 struct hid_device *hdev = to_hid_device(dev); 329 struct mt_device *td = hid_get_drvdata(hdev); 330 331 return sprintf(buf, "%u\n", td->mtclass.quirks); 332 } 333 334 static ssize_t mt_set_quirks(struct device *dev, 335 struct device_attribute *attr, 336 const char *buf, size_t count) 337 { 338 struct hid_device *hdev = to_hid_device(dev); 339 struct mt_device *td = hid_get_drvdata(hdev); 340 341 unsigned long val; 342 343 if (kstrtoul(buf, 0, &val)) 344 return -EINVAL; 345 346 td->mtclass.quirks = val; 347 348 if (td->cc_index < 0) 349 td->mtclass.quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 350 351 return count; 352 } 353 354 static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks); 355 356 static struct attribute *sysfs_attrs[] = { 357 &dev_attr_quirks.attr, 358 NULL 359 }; 360 361 static const struct attribute_group mt_attribute_group = { 362 .attrs = sysfs_attrs 363 }; 364 365 static void mt_get_feature(struct hid_device *hdev, struct hid_report *report) 366 { 367 struct mt_device *td = hid_get_drvdata(hdev); 368 int ret, size = hid_report_len(report); 369 u8 *buf; 370 371 /* 372 * Do not fetch the feature report if the device has been explicitly 373 * marked as non-capable. 374 */ 375 if (td->initial_quirks & HID_QUIRK_NO_INIT_REPORTS) 376 return; 377 378 buf = hid_alloc_report_buf(report, GFP_KERNEL); 379 if (!buf) 380 return; 381 382 ret = hid_hw_raw_request(hdev, report->id, buf, size, 383 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 384 if (ret < 0) { 385 dev_warn(&hdev->dev, "failed to fetch feature %d\n", 386 report->id); 387 } else { 388 ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf, 389 size, 0); 390 if (ret) 391 dev_warn(&hdev->dev, "failed to report feature\n"); 392 } 393 394 kfree(buf); 395 } 396 397 static void mt_feature_mapping(struct hid_device *hdev, 398 struct hid_field *field, struct hid_usage *usage) 399 { 400 struct mt_device *td = hid_get_drvdata(hdev); 401 402 switch (usage->hid) { 403 case HID_DG_INPUTMODE: 404 /* Ignore if value index is out of bounds. */ 405 if (usage->usage_index >= field->report_count) { 406 dev_err(&hdev->dev, "HID_DG_INPUTMODE out of range\n"); 407 break; 408 } 409 410 if (td->inputmode < 0) { 411 td->inputmode = field->report->id; 412 td->inputmode_index = usage->usage_index; 413 } else { 414 /* 415 * Some elan panels wrongly declare 2 input mode 416 * features, and silently ignore when we set the 417 * value in the second field. Skip the second feature 418 * and hope for the best. 419 */ 420 dev_info(&hdev->dev, 421 "Ignoring the extra HID_DG_INPUTMODE\n"); 422 } 423 424 break; 425 case HID_DG_CONTACTMAX: 426 mt_get_feature(hdev, field->report); 427 428 td->maxcontact_report_id = field->report->id; 429 td->maxcontacts = field->value[0]; 430 if (!td->maxcontacts && 431 field->logical_maximum <= MT_MAX_MAXCONTACT) 432 td->maxcontacts = field->logical_maximum; 433 if (td->mtclass.maxcontacts) 434 /* check if the maxcontacts is given by the class */ 435 td->maxcontacts = td->mtclass.maxcontacts; 436 437 break; 438 case HID_DG_BUTTONTYPE: 439 if (usage->usage_index >= field->report_count) { 440 dev_err(&hdev->dev, "HID_DG_BUTTONTYPE out of range\n"); 441 break; 442 } 443 444 mt_get_feature(hdev, field->report); 445 if (field->value[usage->usage_index] == MT_BUTTONTYPE_CLICKPAD) 446 td->is_buttonpad = true; 447 448 break; 449 case 0xff0000c5: 450 /* Retrieve the Win8 blob once to enable some devices */ 451 if (usage->usage_index == 0) 452 mt_get_feature(hdev, field->report); 453 break; 454 } 455 } 456 457 static void set_abs(struct input_dev *input, unsigned int code, 458 struct hid_field *field, int snratio) 459 { 460 int fmin = field->logical_minimum; 461 int fmax = field->logical_maximum; 462 int fuzz = snratio ? (fmax - fmin) / snratio : 0; 463 input_set_abs_params(input, code, fmin, fmax, fuzz, 0); 464 input_abs_set_res(input, code, hidinput_calc_abs_res(field, code)); 465 } 466 467 static void mt_store_field(struct hid_usage *usage, struct mt_device *td, 468 struct hid_input *hi) 469 { 470 struct mt_fields *f = td->fields; 471 472 if (f->length >= HID_MAX_FIELDS) 473 return; 474 475 f->usages[f->length++] = usage->hid; 476 } 477 478 static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi, 479 struct hid_field *field, struct hid_usage *usage, 480 unsigned long **bit, int *max) 481 { 482 struct mt_device *td = hid_get_drvdata(hdev); 483 struct mt_class *cls = &td->mtclass; 484 int code; 485 struct hid_usage *prev_usage = NULL; 486 487 if (field->application == HID_DG_TOUCHSCREEN) 488 td->mt_flags |= INPUT_MT_DIRECT; 489 490 /* 491 * Model touchscreens providing buttons as touchpads. 492 */ 493 if (field->application == HID_DG_TOUCHPAD || 494 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { 495 td->mt_flags |= INPUT_MT_POINTER; 496 td->inputmode_value = MT_INPUTMODE_TOUCHPAD; 497 } 498 499 /* count the buttons on touchpads */ 500 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) 501 td->buttons_count++; 502 503 if (usage->usage_index) 504 prev_usage = &field->usage[usage->usage_index - 1]; 505 506 switch (usage->hid & HID_USAGE_PAGE) { 507 508 case HID_UP_GENDESK: 509 switch (usage->hid) { 510 case HID_GD_X: 511 if (prev_usage && (prev_usage->hid == usage->hid)) { 512 hid_map_usage(hi, usage, bit, max, 513 EV_ABS, ABS_MT_TOOL_X); 514 set_abs(hi->input, ABS_MT_TOOL_X, field, 515 cls->sn_move); 516 } else { 517 hid_map_usage(hi, usage, bit, max, 518 EV_ABS, ABS_MT_POSITION_X); 519 set_abs(hi->input, ABS_MT_POSITION_X, field, 520 cls->sn_move); 521 } 522 523 mt_store_field(usage, td, hi); 524 return 1; 525 case HID_GD_Y: 526 if (prev_usage && (prev_usage->hid == usage->hid)) { 527 hid_map_usage(hi, usage, bit, max, 528 EV_ABS, ABS_MT_TOOL_Y); 529 set_abs(hi->input, ABS_MT_TOOL_Y, field, 530 cls->sn_move); 531 } else { 532 hid_map_usage(hi, usage, bit, max, 533 EV_ABS, ABS_MT_POSITION_Y); 534 set_abs(hi->input, ABS_MT_POSITION_Y, field, 535 cls->sn_move); 536 } 537 538 mt_store_field(usage, td, hi); 539 return 1; 540 } 541 return 0; 542 543 case HID_UP_DIGITIZER: 544 switch (usage->hid) { 545 case HID_DG_INRANGE: 546 if (cls->quirks & MT_QUIRK_HOVERING) { 547 hid_map_usage(hi, usage, bit, max, 548 EV_ABS, ABS_MT_DISTANCE); 549 input_set_abs_params(hi->input, 550 ABS_MT_DISTANCE, 0, 1, 0, 0); 551 } 552 mt_store_field(usage, td, hi); 553 return 1; 554 case HID_DG_CONFIDENCE: 555 if ((cls->name == MT_CLS_WIN_8 || 556 cls->name == MT_CLS_WIN_8_DUAL) && 557 field->application == HID_DG_TOUCHPAD) 558 cls->quirks |= MT_QUIRK_CONFIDENCE; 559 mt_store_field(usage, td, hi); 560 return 1; 561 case HID_DG_TIPSWITCH: 562 hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH); 563 input_set_capability(hi->input, EV_KEY, BTN_TOUCH); 564 mt_store_field(usage, td, hi); 565 return 1; 566 case HID_DG_CONTACTID: 567 mt_store_field(usage, td, hi); 568 td->touches_by_report++; 569 td->mt_report_id = field->report->id; 570 return 1; 571 case HID_DG_WIDTH: 572 hid_map_usage(hi, usage, bit, max, 573 EV_ABS, ABS_MT_TOUCH_MAJOR); 574 if (!(cls->quirks & MT_QUIRK_NO_AREA)) 575 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field, 576 cls->sn_width); 577 mt_store_field(usage, td, hi); 578 return 1; 579 case HID_DG_HEIGHT: 580 hid_map_usage(hi, usage, bit, max, 581 EV_ABS, ABS_MT_TOUCH_MINOR); 582 if (!(cls->quirks & MT_QUIRK_NO_AREA)) { 583 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field, 584 cls->sn_height); 585 input_set_abs_params(hi->input, 586 ABS_MT_ORIENTATION, 0, 1, 0, 0); 587 } 588 mt_store_field(usage, td, hi); 589 return 1; 590 case HID_DG_TIPPRESSURE: 591 hid_map_usage(hi, usage, bit, max, 592 EV_ABS, ABS_MT_PRESSURE); 593 set_abs(hi->input, ABS_MT_PRESSURE, field, 594 cls->sn_pressure); 595 mt_store_field(usage, td, hi); 596 return 1; 597 case HID_DG_SCANTIME: 598 hid_map_usage(hi, usage, bit, max, 599 EV_MSC, MSC_TIMESTAMP); 600 input_set_capability(hi->input, EV_MSC, MSC_TIMESTAMP); 601 mt_store_field(usage, td, hi); 602 return 1; 603 case HID_DG_CONTACTCOUNT: 604 /* Ignore if indexes are out of bounds. */ 605 if (field->index >= field->report->maxfield || 606 usage->usage_index >= field->report_count) 607 return 1; 608 td->cc_index = field->index; 609 td->cc_value_index = usage->usage_index; 610 return 1; 611 case HID_DG_CONTACTMAX: 612 /* we don't set td->last_slot_field as contactcount and 613 * contact max are global to the report */ 614 return -1; 615 case HID_DG_TOUCH: 616 /* Legacy devices use TIPSWITCH and not TOUCH. 617 * Let's just ignore this field. */ 618 return -1; 619 } 620 /* let hid-input decide for the others */ 621 return 0; 622 623 case HID_UP_BUTTON: 624 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE); 625 /* 626 * MS PTP spec says that external buttons left and right have 627 * usages 2 and 3. 628 */ 629 if ((cls->name == MT_CLS_WIN_8 || 630 cls->name == MT_CLS_WIN_8_DUAL) && 631 field->application == HID_DG_TOUCHPAD && 632 (usage->hid & HID_USAGE) > 1) 633 code--; 634 hid_map_usage(hi, usage, bit, max, EV_KEY, code); 635 input_set_capability(hi->input, EV_KEY, code); 636 return 1; 637 638 case 0xff000000: 639 /* we do not want to map these: no input-oriented meaning */ 640 return -1; 641 } 642 643 return 0; 644 } 645 646 static int mt_compute_slot(struct mt_device *td, struct input_dev *input) 647 { 648 __s32 quirks = td->mtclass.quirks; 649 650 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID) 651 return td->curdata.contactid; 652 653 if (quirks & MT_QUIRK_CYPRESS) 654 return cypress_compute_slot(td); 655 656 if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER) 657 return td->num_received; 658 659 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE) 660 return td->curdata.contactid - 1; 661 662 return input_mt_get_slot_by_key(input, td->curdata.contactid); 663 } 664 665 /* 666 * this function is called when a whole contact has been processed, 667 * so that it can assign it to a slot and store the data there 668 */ 669 static void mt_complete_slot(struct mt_device *td, struct input_dev *input) 670 { 671 if ((td->mtclass.quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) && 672 td->num_received >= td->num_expected) 673 return; 674 675 if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) { 676 int active; 677 int slotnum = mt_compute_slot(td, input); 678 struct mt_slot *s = &td->curdata; 679 struct input_mt *mt = input->mt; 680 681 if (slotnum < 0 || slotnum >= td->maxcontacts) 682 return; 683 684 if ((td->mtclass.quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) { 685 struct input_mt_slot *slot = &mt->slots[slotnum]; 686 if (input_mt_is_active(slot) && 687 input_mt_is_used(mt, slot)) 688 return; 689 } 690 691 if (!(td->mtclass.quirks & MT_QUIRK_CONFIDENCE)) 692 s->confidence_state = 1; 693 active = (s->touch_state || s->inrange_state) && 694 s->confidence_state; 695 696 input_mt_slot(input, slotnum); 697 input_mt_report_slot_state(input, MT_TOOL_FINGER, active); 698 if (active) { 699 /* this finger is in proximity of the sensor */ 700 int wide = (s->w > s->h); 701 int major = max(s->w, s->h); 702 int minor = min(s->w, s->h); 703 704 /* 705 * divided by two to match visual scale of touch 706 * for devices with this quirk 707 */ 708 if (td->mtclass.quirks & MT_QUIRK_TOUCH_SIZE_SCALING) { 709 major = major >> 1; 710 minor = minor >> 1; 711 } 712 713 input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x); 714 input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y); 715 input_event(input, EV_ABS, ABS_MT_TOOL_X, s->cx); 716 input_event(input, EV_ABS, ABS_MT_TOOL_Y, s->cy); 717 input_event(input, EV_ABS, ABS_MT_DISTANCE, 718 !s->touch_state); 719 input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide); 720 input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p); 721 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major); 722 input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor); 723 724 set_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags); 725 } 726 } 727 728 td->num_received++; 729 } 730 731 /* 732 * this function is called when a whole packet has been received and processed, 733 * so that it can decide what to send to the input layer. 734 */ 735 static void mt_sync_frame(struct mt_device *td, struct input_dev *input) 736 { 737 input_mt_sync_frame(input); 738 input_event(input, EV_MSC, MSC_TIMESTAMP, td->timestamp); 739 input_sync(input); 740 td->num_received = 0; 741 if (test_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags)) 742 set_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags); 743 else 744 clear_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags); 745 clear_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags); 746 } 747 748 static int mt_compute_timestamp(struct mt_device *td, struct hid_field *field, 749 __s32 value) 750 { 751 long delta = value - td->dev_time; 752 unsigned long jdelta = jiffies_to_usecs(jiffies - td->jiffies); 753 754 td->jiffies = jiffies; 755 td->dev_time = value; 756 757 if (delta < 0) 758 delta += field->logical_maximum; 759 760 /* HID_DG_SCANTIME is expressed in 100us, we want it in us. */ 761 delta *= 100; 762 763 if (jdelta > MAX_TIMESTAMP_INTERVAL) 764 /* No data received for a while, resync the timestamp. */ 765 return 0; 766 else 767 return td->timestamp + delta; 768 } 769 770 static int mt_touch_event(struct hid_device *hid, struct hid_field *field, 771 struct hid_usage *usage, __s32 value) 772 { 773 /* we will handle the hidinput part later, now remains hiddev */ 774 if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event) 775 hid->hiddev_hid_event(hid, field, usage, value); 776 777 return 1; 778 } 779 780 static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field, 781 struct hid_usage *usage, __s32 value) 782 { 783 struct mt_device *td = hid_get_drvdata(hid); 784 __s32 quirks = td->mtclass.quirks; 785 struct input_dev *input = field->hidinput->input; 786 787 if (hid->claimed & HID_CLAIMED_INPUT) { 788 switch (usage->hid) { 789 case HID_DG_INRANGE: 790 if (quirks & MT_QUIRK_VALID_IS_INRANGE) 791 td->curvalid = value; 792 if (quirks & MT_QUIRK_HOVERING) 793 td->curdata.inrange_state = value; 794 break; 795 case HID_DG_TIPSWITCH: 796 if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 797 td->curvalid = value; 798 td->curdata.touch_state = value; 799 break; 800 case HID_DG_CONFIDENCE: 801 if (quirks & MT_QUIRK_CONFIDENCE) 802 td->curdata.confidence_state = value; 803 if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE) 804 td->curvalid = value; 805 break; 806 case HID_DG_CONTACTID: 807 td->curdata.contactid = value; 808 break; 809 case HID_DG_TIPPRESSURE: 810 td->curdata.p = value; 811 break; 812 case HID_GD_X: 813 if (usage->code == ABS_MT_TOOL_X) 814 td->curdata.cx = value; 815 else 816 td->curdata.x = value; 817 break; 818 case HID_GD_Y: 819 if (usage->code == ABS_MT_TOOL_Y) 820 td->curdata.cy = value; 821 else 822 td->curdata.y = value; 823 break; 824 case HID_DG_WIDTH: 825 td->curdata.w = value; 826 break; 827 case HID_DG_HEIGHT: 828 td->curdata.h = value; 829 break; 830 case HID_DG_SCANTIME: 831 td->timestamp = mt_compute_timestamp(td, field, value); 832 break; 833 case HID_DG_CONTACTCOUNT: 834 break; 835 case HID_DG_TOUCH: 836 /* do nothing */ 837 break; 838 839 default: 840 if (usage->type) 841 input_event(input, usage->type, usage->code, 842 value); 843 return; 844 } 845 846 if (usage->usage_index + 1 == field->report_count) { 847 /* we only take into account the last report. */ 848 if (usage->hid == td->last_slot_field) 849 mt_complete_slot(td, field->hidinput->input); 850 } 851 852 } 853 } 854 855 static void mt_touch_report(struct hid_device *hid, struct hid_report *report) 856 { 857 struct mt_device *td = hid_get_drvdata(hid); 858 struct hid_field *field; 859 unsigned count; 860 int r, n; 861 862 /* sticky fingers release in progress, abort */ 863 if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags)) 864 return; 865 866 /* 867 * Includes multi-packet support where subsequent 868 * packets are sent with zero contactcount. 869 */ 870 if (td->cc_index >= 0) { 871 struct hid_field *field = report->field[td->cc_index]; 872 int value = field->value[td->cc_value_index]; 873 if (value) 874 td->num_expected = value; 875 } 876 877 for (r = 0; r < report->maxfield; r++) { 878 field = report->field[r]; 879 count = field->report_count; 880 881 if (!(HID_MAIN_ITEM_VARIABLE & field->flags)) 882 continue; 883 884 for (n = 0; n < count; n++) 885 mt_process_mt_event(hid, field, &field->usage[n], 886 field->value[n]); 887 } 888 889 if (td->num_received >= td->num_expected) 890 mt_sync_frame(td, report->field[0]->hidinput->input); 891 892 /* 893 * Windows 8 specs says 2 things: 894 * - once a contact has been reported, it has to be reported in each 895 * subsequent report 896 * - the report rate when fingers are present has to be at least 897 * the refresh rate of the screen, 60 or 120 Hz 898 * 899 * I interprete this that the specification forces a report rate of 900 * at least 60 Hz for a touchscreen to be certified. 901 * Which means that if we do not get a report whithin 16 ms, either 902 * something wrong happens, either the touchscreen forgets to send 903 * a release. Taking a reasonable margin allows to remove issues 904 * with USB communication or the load of the machine. 905 * 906 * Given that Win 8 devices are forced to send a release, this will 907 * only affect laggish machines and the ones that have a firmware 908 * defect. 909 */ 910 if (td->mtclass.quirks & MT_QUIRK_STICKY_FINGERS) { 911 if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags)) 912 mod_timer(&td->release_timer, 913 jiffies + msecs_to_jiffies(100)); 914 else 915 del_timer(&td->release_timer); 916 } 917 918 clear_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags); 919 } 920 921 static int mt_touch_input_configured(struct hid_device *hdev, 922 struct hid_input *hi) 923 { 924 struct mt_device *td = hid_get_drvdata(hdev); 925 struct mt_class *cls = &td->mtclass; 926 struct input_dev *input = hi->input; 927 int ret; 928 929 if (!td->maxcontacts) 930 td->maxcontacts = MT_DEFAULT_MAXCONTACT; 931 932 mt_post_parse(td); 933 if (td->serial_maybe) 934 mt_post_parse_default_settings(td); 935 936 if (cls->is_indirect) 937 td->mt_flags |= INPUT_MT_POINTER; 938 939 if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 940 td->mt_flags |= INPUT_MT_DROP_UNUSED; 941 942 /* check for clickpads */ 943 if ((td->mt_flags & INPUT_MT_POINTER) && (td->buttons_count == 1)) 944 td->is_buttonpad = true; 945 946 if (td->is_buttonpad) 947 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); 948 949 ret = input_mt_init_slots(input, td->maxcontacts, td->mt_flags); 950 if (ret) 951 return ret; 952 953 td->mt_flags = 0; 954 return 0; 955 } 956 957 #define mt_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, \ 958 max, EV_KEY, (c)) 959 static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, 960 struct hid_field *field, struct hid_usage *usage, 961 unsigned long **bit, int *max) 962 { 963 struct mt_device *td = hid_get_drvdata(hdev); 964 965 /* 966 * If mtclass.export_all_inputs is not set, only map fields from 967 * TouchScreen or TouchPad collections. We need to ignore fields 968 * that belong to other collections such as Mouse that might have 969 * the same GenericDesktop usages. 970 */ 971 if (!td->mtclass.export_all_inputs && 972 field->application != HID_DG_TOUCHSCREEN && 973 field->application != HID_DG_PEN && 974 field->application != HID_DG_TOUCHPAD && 975 field->application != HID_GD_KEYBOARD && 976 field->application != HID_GD_SYSTEM_CONTROL && 977 field->application != HID_CP_CONSUMER_CONTROL && 978 field->application != HID_GD_WIRELESS_RADIO_CTLS && 979 !(field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS && 980 td->mtclass.quirks & MT_QUIRK_ASUS_CUSTOM_UP)) 981 return -1; 982 983 /* 984 * Some Asus keyboard+touchpad devices have the hotkeys defined in the 985 * touchpad report descriptor. We need to treat these as an array to 986 * map usages to input keys. 987 */ 988 if (field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS && 989 td->mtclass.quirks & MT_QUIRK_ASUS_CUSTOM_UP && 990 (usage->hid & HID_USAGE_PAGE) == HID_UP_CUSTOM) { 991 set_bit(EV_REP, hi->input->evbit); 992 if (field->flags & HID_MAIN_ITEM_VARIABLE) 993 field->flags &= ~HID_MAIN_ITEM_VARIABLE; 994 switch (usage->hid & HID_USAGE) { 995 case 0x10: mt_map_key_clear(KEY_BRIGHTNESSDOWN); break; 996 case 0x20: mt_map_key_clear(KEY_BRIGHTNESSUP); break; 997 case 0x35: mt_map_key_clear(KEY_DISPLAY_OFF); break; 998 case 0x6b: mt_map_key_clear(KEY_F21); break; 999 case 0x6c: mt_map_key_clear(KEY_SLEEP); break; 1000 default: 1001 return -1; 1002 } 1003 return 1; 1004 } 1005 1006 /* 1007 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 1008 * for the stylus. 1009 * The check for mt_report_id ensures we don't process 1010 * HID_DG_CONTACTCOUNT from the pen report as it is outside the physical 1011 * collection, but within the report ID. 1012 */ 1013 if (field->physical == HID_DG_STYLUS) 1014 return 0; 1015 else if ((field->physical == 0) && 1016 (field->report->id != td->mt_report_id) && 1017 (td->mt_report_id != -1)) 1018 return 0; 1019 1020 if (field->application == HID_DG_TOUCHSCREEN || 1021 field->application == HID_DG_TOUCHPAD) 1022 return mt_touch_input_mapping(hdev, hi, field, usage, bit, max); 1023 1024 /* let hid-core decide for the others */ 1025 return 0; 1026 } 1027 1028 static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi, 1029 struct hid_field *field, struct hid_usage *usage, 1030 unsigned long **bit, int *max) 1031 { 1032 /* 1033 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 1034 * for the stylus. 1035 */ 1036 if (field->physical == HID_DG_STYLUS) 1037 return 0; 1038 1039 if (field->application == HID_DG_TOUCHSCREEN || 1040 field->application == HID_DG_TOUCHPAD) { 1041 /* We own these mappings, tell hid-input to ignore them */ 1042 return -1; 1043 } 1044 1045 /* let hid-core decide for the others */ 1046 return 0; 1047 } 1048 1049 static int mt_event(struct hid_device *hid, struct hid_field *field, 1050 struct hid_usage *usage, __s32 value) 1051 { 1052 struct mt_device *td = hid_get_drvdata(hid); 1053 1054 if (field->report->id == td->mt_report_id) 1055 return mt_touch_event(hid, field, usage, value); 1056 1057 return 0; 1058 } 1059 1060 static void mt_report(struct hid_device *hid, struct hid_report *report) 1061 { 1062 struct mt_device *td = hid_get_drvdata(hid); 1063 struct hid_field *field = report->field[0]; 1064 1065 if (!(hid->claimed & HID_CLAIMED_INPUT)) 1066 return; 1067 1068 if (report->id == td->mt_report_id) 1069 return mt_touch_report(hid, report); 1070 1071 if (field && field->hidinput && field->hidinput->input) 1072 input_sync(field->hidinput->input); 1073 } 1074 1075 static void mt_set_input_mode(struct hid_device *hdev) 1076 { 1077 struct mt_device *td = hid_get_drvdata(hdev); 1078 struct hid_report *r; 1079 struct hid_report_enum *re; 1080 struct mt_class *cls = &td->mtclass; 1081 char *buf; 1082 int report_len; 1083 1084 if (td->inputmode < 0) 1085 return; 1086 1087 re = &(hdev->report_enum[HID_FEATURE_REPORT]); 1088 r = re->report_id_hash[td->inputmode]; 1089 if (r) { 1090 if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) { 1091 report_len = hid_report_len(r); 1092 buf = hid_alloc_report_buf(r, GFP_KERNEL); 1093 if (!buf) { 1094 hid_err(hdev, "failed to allocate buffer for report\n"); 1095 return; 1096 } 1097 hid_hw_raw_request(hdev, r->id, buf, report_len, 1098 HID_FEATURE_REPORT, 1099 HID_REQ_GET_REPORT); 1100 kfree(buf); 1101 } 1102 r->field[0]->value[td->inputmode_index] = td->inputmode_value; 1103 hid_hw_request(hdev, r, HID_REQ_SET_REPORT); 1104 } 1105 } 1106 1107 static void mt_set_maxcontacts(struct hid_device *hdev) 1108 { 1109 struct mt_device *td = hid_get_drvdata(hdev); 1110 struct hid_report *r; 1111 struct hid_report_enum *re; 1112 int fieldmax, max; 1113 1114 if (td->maxcontact_report_id < 0) 1115 return; 1116 1117 if (!td->mtclass.maxcontacts) 1118 return; 1119 1120 re = &hdev->report_enum[HID_FEATURE_REPORT]; 1121 r = re->report_id_hash[td->maxcontact_report_id]; 1122 if (r) { 1123 max = td->mtclass.maxcontacts; 1124 fieldmax = r->field[0]->logical_maximum; 1125 max = min(fieldmax, max); 1126 if (r->field[0]->value[0] != max) { 1127 r->field[0]->value[0] = max; 1128 hid_hw_request(hdev, r, HID_REQ_SET_REPORT); 1129 } 1130 } 1131 } 1132 1133 static void mt_post_parse_default_settings(struct mt_device *td) 1134 { 1135 __s32 quirks = td->mtclass.quirks; 1136 1137 /* unknown serial device needs special quirks */ 1138 if (td->touches_by_report == 1) { 1139 quirks |= MT_QUIRK_ALWAYS_VALID; 1140 quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP; 1141 quirks &= ~MT_QUIRK_VALID_IS_INRANGE; 1142 quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE; 1143 quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 1144 } 1145 1146 td->mtclass.quirks = quirks; 1147 } 1148 1149 static void mt_post_parse(struct mt_device *td) 1150 { 1151 struct mt_fields *f = td->fields; 1152 struct mt_class *cls = &td->mtclass; 1153 1154 if (td->touches_by_report > 0) { 1155 int field_count_per_touch = f->length / td->touches_by_report; 1156 td->last_slot_field = f->usages[field_count_per_touch - 1]; 1157 } 1158 1159 if (td->cc_index < 0) 1160 cls->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 1161 } 1162 1163 static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi) 1164 { 1165 struct mt_device *td = hid_get_drvdata(hdev); 1166 char *name; 1167 const char *suffix = NULL; 1168 struct hid_field *field = hi->report->field[0]; 1169 int ret; 1170 1171 if (hi->report->id == td->mt_report_id) { 1172 ret = mt_touch_input_configured(hdev, hi); 1173 if (ret) 1174 return ret; 1175 } 1176 1177 /* 1178 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 1179 * for the stylus. Check this first, and then rely on the application 1180 * field. 1181 */ 1182 if (hi->report->field[0]->physical == HID_DG_STYLUS) { 1183 suffix = "Pen"; 1184 /* force BTN_STYLUS to allow tablet matching in udev */ 1185 __set_bit(BTN_STYLUS, hi->input->keybit); 1186 } else { 1187 switch (field->application) { 1188 case HID_GD_KEYBOARD: 1189 suffix = "Keyboard"; 1190 break; 1191 case HID_GD_KEYPAD: 1192 suffix = "Keypad"; 1193 break; 1194 case HID_GD_MOUSE: 1195 suffix = "Mouse"; 1196 break; 1197 case HID_DG_STYLUS: 1198 suffix = "Pen"; 1199 /* force BTN_STYLUS to allow tablet matching in udev */ 1200 __set_bit(BTN_STYLUS, hi->input->keybit); 1201 break; 1202 case HID_DG_TOUCHSCREEN: 1203 /* we do not set suffix = "Touchscreen" */ 1204 break; 1205 case HID_DG_TOUCHPAD: 1206 suffix = "Touchpad"; 1207 break; 1208 case HID_GD_SYSTEM_CONTROL: 1209 suffix = "System Control"; 1210 break; 1211 case HID_CP_CONSUMER_CONTROL: 1212 suffix = "Consumer Control"; 1213 break; 1214 case HID_GD_WIRELESS_RADIO_CTLS: 1215 suffix = "Wireless Radio Control"; 1216 break; 1217 case HID_VD_ASUS_CUSTOM_MEDIA_KEYS: 1218 suffix = "Custom Media Keys"; 1219 break; 1220 default: 1221 suffix = "UNKNOWN"; 1222 break; 1223 } 1224 } 1225 1226 if (suffix) { 1227 name = devm_kzalloc(&hi->input->dev, 1228 strlen(hdev->name) + strlen(suffix) + 2, 1229 GFP_KERNEL); 1230 if (name) { 1231 sprintf(name, "%s %s", hdev->name, suffix); 1232 hi->input->name = name; 1233 } 1234 } 1235 1236 return 0; 1237 } 1238 1239 static void mt_fix_const_field(struct hid_field *field, unsigned int usage) 1240 { 1241 if (field->usage[0].hid != usage || 1242 !(field->flags & HID_MAIN_ITEM_CONSTANT)) 1243 return; 1244 1245 field->flags &= ~HID_MAIN_ITEM_CONSTANT; 1246 field->flags |= HID_MAIN_ITEM_VARIABLE; 1247 } 1248 1249 static void mt_fix_const_fields(struct hid_device *hdev, unsigned int usage) 1250 { 1251 struct hid_report *report; 1252 int i; 1253 1254 list_for_each_entry(report, 1255 &hdev->report_enum[HID_INPUT_REPORT].report_list, 1256 list) { 1257 1258 if (!report->maxfield) 1259 continue; 1260 1261 for (i = 0; i < report->maxfield; i++) 1262 if (report->field[i]->maxusage >= 1) 1263 mt_fix_const_field(report->field[i], usage); 1264 } 1265 } 1266 1267 static void mt_release_contacts(struct hid_device *hid) 1268 { 1269 struct hid_input *hidinput; 1270 struct mt_device *td = hid_get_drvdata(hid); 1271 1272 list_for_each_entry(hidinput, &hid->inputs, list) { 1273 struct input_dev *input_dev = hidinput->input; 1274 struct input_mt *mt = input_dev->mt; 1275 int i; 1276 1277 if (mt) { 1278 for (i = 0; i < mt->num_slots; i++) { 1279 input_mt_slot(input_dev, i); 1280 input_mt_report_slot_state(input_dev, 1281 MT_TOOL_FINGER, 1282 false); 1283 } 1284 input_mt_sync_frame(input_dev); 1285 input_sync(input_dev); 1286 } 1287 } 1288 1289 td->num_received = 0; 1290 } 1291 1292 static void mt_expired_timeout(struct timer_list *t) 1293 { 1294 struct mt_device *td = from_timer(td, t, release_timer); 1295 struct hid_device *hdev = td->hdev; 1296 1297 /* 1298 * An input report came in just before we release the sticky fingers, 1299 * it will take care of the sticky fingers. 1300 */ 1301 if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags)) 1302 return; 1303 if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags)) 1304 mt_release_contacts(hdev); 1305 clear_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags); 1306 } 1307 1308 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) 1309 { 1310 int ret, i; 1311 struct mt_device *td; 1312 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */ 1313 1314 for (i = 0; mt_classes[i].name ; i++) { 1315 if (id->driver_data == mt_classes[i].name) { 1316 mtclass = &(mt_classes[i]); 1317 break; 1318 } 1319 } 1320 1321 td = devm_kzalloc(&hdev->dev, sizeof(struct mt_device), GFP_KERNEL); 1322 if (!td) { 1323 dev_err(&hdev->dev, "cannot allocate multitouch data\n"); 1324 return -ENOMEM; 1325 } 1326 td->hdev = hdev; 1327 td->mtclass = *mtclass; 1328 td->inputmode = -1; 1329 td->maxcontact_report_id = -1; 1330 td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN; 1331 td->cc_index = -1; 1332 td->mt_report_id = -1; 1333 hid_set_drvdata(hdev, td); 1334 1335 td->fields = devm_kzalloc(&hdev->dev, sizeof(struct mt_fields), 1336 GFP_KERNEL); 1337 if (!td->fields) { 1338 dev_err(&hdev->dev, "cannot allocate multitouch fields data\n"); 1339 return -ENOMEM; 1340 } 1341 1342 if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID) 1343 td->serial_maybe = true; 1344 1345 /* 1346 * Store the initial quirk state 1347 */ 1348 td->initial_quirks = hdev->quirks; 1349 1350 /* This allows the driver to correctly support devices 1351 * that emit events over several HID messages. 1352 */ 1353 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; 1354 1355 /* 1356 * This allows the driver to handle different input sensors 1357 * that emits events through different reports on the same HID 1358 * device. 1359 */ 1360 hdev->quirks |= HID_QUIRK_MULTI_INPUT; 1361 hdev->quirks |= HID_QUIRK_NO_EMPTY_INPUT; 1362 1363 /* 1364 * Some multitouch screens do not like to be polled for input 1365 * reports. Fortunately, the Win8 spec says that all touches 1366 * should be sent during each report, making the initialization 1367 * of input reports unnecessary. For Win7 devices, well, let's hope 1368 * they will still be happy (this is only be a problem if a touch 1369 * was already there while probing the device). 1370 * 1371 * In addition some touchpads do not behave well if we read 1372 * all feature reports from them. Instead we prevent 1373 * initial report fetching and then selectively fetch each 1374 * report we are interested in. 1375 */ 1376 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 1377 1378 timer_setup(&td->release_timer, mt_expired_timeout, 0); 1379 1380 ret = hid_parse(hdev); 1381 if (ret != 0) 1382 return ret; 1383 1384 if (mtclass->quirks & MT_QUIRK_FIX_CONST_CONTACT_ID) 1385 mt_fix_const_fields(hdev, HID_DG_CONTACTID); 1386 1387 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1388 if (ret) 1389 return ret; 1390 1391 ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group); 1392 if (ret) 1393 dev_warn(&hdev->dev, "Cannot allocate sysfs group for %s\n", 1394 hdev->name); 1395 1396 mt_set_maxcontacts(hdev); 1397 mt_set_input_mode(hdev); 1398 1399 /* release .fields memory as it is not used anymore */ 1400 devm_kfree(&hdev->dev, td->fields); 1401 td->fields = NULL; 1402 1403 return 0; 1404 } 1405 1406 #ifdef CONFIG_PM 1407 static int mt_reset_resume(struct hid_device *hdev) 1408 { 1409 mt_release_contacts(hdev); 1410 mt_set_maxcontacts(hdev); 1411 mt_set_input_mode(hdev); 1412 return 0; 1413 } 1414 1415 static int mt_resume(struct hid_device *hdev) 1416 { 1417 /* Some Elan legacy devices require SET_IDLE to be set on resume. 1418 * It should be safe to send it to other devices too. 1419 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */ 1420 1421 hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE); 1422 1423 return 0; 1424 } 1425 #endif 1426 1427 static void mt_remove(struct hid_device *hdev) 1428 { 1429 struct mt_device *td = hid_get_drvdata(hdev); 1430 1431 del_timer_sync(&td->release_timer); 1432 1433 sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group); 1434 hid_hw_stop(hdev); 1435 hdev->quirks = td->initial_quirks; 1436 } 1437 1438 /* 1439 * This list contains only: 1440 * - VID/PID of products not working with the default multitouch handling 1441 * - 2 generic rules. 1442 * So there is no point in adding here any device with MT_CLS_DEFAULT. 1443 */ 1444 static const struct hid_device_id mt_devices[] = { 1445 1446 /* 3M panels */ 1447 { .driver_data = MT_CLS_3M, 1448 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1449 USB_DEVICE_ID_3M1968) }, 1450 { .driver_data = MT_CLS_3M, 1451 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1452 USB_DEVICE_ID_3M2256) }, 1453 { .driver_data = MT_CLS_3M, 1454 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1455 USB_DEVICE_ID_3M3266) }, 1456 1457 /* Alps devices */ 1458 { .driver_data = MT_CLS_WIN_8_DUAL, 1459 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8, 1460 USB_VENDOR_ID_ALPS_JP, 1461 HID_DEVICE_ID_ALPS_U1_DUAL_PTP) }, 1462 { .driver_data = MT_CLS_WIN_8_DUAL, 1463 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8, 1464 USB_VENDOR_ID_ALPS_JP, 1465 HID_DEVICE_ID_ALPS_U1_DUAL_3BTN_PTP) }, 1466 1467 /* Lenovo X1 TAB Gen 2 */ 1468 { .driver_data = MT_CLS_WIN_8_DUAL, 1469 HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8, 1470 USB_VENDOR_ID_LENOVO, 1471 USB_DEVICE_ID_LENOVO_X1_TAB) }, 1472 1473 /* Anton devices */ 1474 { .driver_data = MT_CLS_EXPORT_ALL_INPUTS, 1475 MT_USB_DEVICE(USB_VENDOR_ID_ANTON, 1476 USB_DEVICE_ID_ANTON_TOUCH_PAD) }, 1477 1478 /* Asus T304UA */ 1479 { .driver_data = MT_CLS_ASUS, 1480 HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8, 1481 USB_VENDOR_ID_ASUSTEK, 1482 USB_DEVICE_ID_ASUSTEK_T304_KEYBOARD) }, 1483 1484 /* Atmel panels */ 1485 { .driver_data = MT_CLS_SERIAL, 1486 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL, 1487 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) }, 1488 1489 /* Baanto multitouch devices */ 1490 { .driver_data = MT_CLS_NSMU, 1491 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO, 1492 USB_DEVICE_ID_BAANTO_MT_190W2) }, 1493 1494 /* Cando panels */ 1495 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 1496 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1497 USB_DEVICE_ID_CANDO_MULTI_TOUCH) }, 1498 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 1499 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1500 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) }, 1501 1502 /* Chunghwa Telecom touch panels */ 1503 { .driver_data = MT_CLS_NSMU, 1504 MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, 1505 USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) }, 1506 1507 /* CJTouch panels */ 1508 { .driver_data = MT_CLS_NSMU, 1509 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH, 1510 USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020) }, 1511 { .driver_data = MT_CLS_NSMU, 1512 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH, 1513 USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040) }, 1514 1515 /* CVTouch panels */ 1516 { .driver_data = MT_CLS_NSMU, 1517 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, 1518 USB_DEVICE_ID_CVTOUCH_SCREEN) }, 1519 1520 /* eGalax devices (resistive) */ 1521 { .driver_data = MT_CLS_EGALAX, 1522 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1523 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) }, 1524 { .driver_data = MT_CLS_EGALAX, 1525 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1526 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) }, 1527 1528 /* eGalax devices (capacitive) */ 1529 { .driver_data = MT_CLS_EGALAX_SERIAL, 1530 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1531 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) }, 1532 { .driver_data = MT_CLS_EGALAX, 1533 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1534 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) }, 1535 { .driver_data = MT_CLS_EGALAX_SERIAL, 1536 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1537 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, 1538 { .driver_data = MT_CLS_EGALAX_SERIAL, 1539 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1540 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) }, 1541 { .driver_data = MT_CLS_EGALAX_SERIAL, 1542 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1543 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) }, 1544 { .driver_data = MT_CLS_EGALAX_SERIAL, 1545 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1546 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) }, 1547 { .driver_data = MT_CLS_EGALAX, 1548 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1549 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) }, 1550 { .driver_data = MT_CLS_EGALAX, 1551 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1552 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) }, 1553 { .driver_data = MT_CLS_EGALAX_SERIAL, 1554 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1555 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) }, 1556 { .driver_data = MT_CLS_EGALAX, 1557 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1558 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) }, 1559 { .driver_data = MT_CLS_EGALAX, 1560 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1561 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) }, 1562 { .driver_data = MT_CLS_EGALAX, 1563 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1564 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) }, 1565 { .driver_data = MT_CLS_EGALAX, 1566 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1567 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) }, 1568 { .driver_data = MT_CLS_EGALAX_SERIAL, 1569 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1570 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) }, 1571 { .driver_data = MT_CLS_EGALAX_SERIAL, 1572 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1573 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) }, 1574 { .driver_data = MT_CLS_EGALAX_SERIAL, 1575 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1576 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) }, 1577 1578 /* Elitegroup panel */ 1579 { .driver_data = MT_CLS_SERIAL, 1580 MT_USB_DEVICE(USB_VENDOR_ID_ELITEGROUP, 1581 USB_DEVICE_ID_ELITEGROUP_05D8) }, 1582 1583 /* Flatfrog Panels */ 1584 { .driver_data = MT_CLS_FLATFROG, 1585 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG, 1586 USB_DEVICE_ID_MULTITOUCH_3200) }, 1587 1588 /* FocalTech Panels */ 1589 { .driver_data = MT_CLS_SERIAL, 1590 MT_USB_DEVICE(USB_VENDOR_ID_CYGNAL, 1591 USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH) }, 1592 1593 /* GeneralTouch panel */ 1594 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS, 1595 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1596 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) }, 1597 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1598 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1599 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) }, 1600 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS, 1601 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1602 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0101) }, 1603 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1604 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1605 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0102) }, 1606 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1607 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1608 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0106) }, 1609 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1610 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1611 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A) }, 1612 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1613 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1614 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100) }, 1615 1616 /* Gametel game controller */ 1617 { .driver_data = MT_CLS_NSMU, 1618 MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL, 1619 USB_DEVICE_ID_GAMETEL_MT_MODE) }, 1620 1621 /* GoodTouch panels */ 1622 { .driver_data = MT_CLS_NSMU, 1623 MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, 1624 USB_DEVICE_ID_GOODTOUCH_000f) }, 1625 1626 /* Hanvon panels */ 1627 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1628 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, 1629 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) }, 1630 1631 /* Ilitek dual touch panel */ 1632 { .driver_data = MT_CLS_NSMU, 1633 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK, 1634 USB_DEVICE_ID_ILITEK_MULTITOUCH) }, 1635 1636 /* LG Melfas panel */ 1637 { .driver_data = MT_CLS_LG, 1638 HID_USB_DEVICE(USB_VENDOR_ID_LG, 1639 USB_DEVICE_ID_LG_MELFAS_MT) }, 1640 1641 /* MosArt panels */ 1642 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1643 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1644 USB_DEVICE_ID_ASUS_T91MT)}, 1645 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1646 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1647 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) }, 1648 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1649 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX, 1650 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) }, 1651 1652 /* Panasonic panels */ 1653 { .driver_data = MT_CLS_PANASONIC, 1654 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1655 USB_DEVICE_ID_PANABOARD_UBT780) }, 1656 { .driver_data = MT_CLS_PANASONIC, 1657 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1658 USB_DEVICE_ID_PANABOARD_UBT880) }, 1659 1660 /* Novatek Panel */ 1661 { .driver_data = MT_CLS_NSMU, 1662 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK, 1663 USB_DEVICE_ID_NOVATEK_PCT) }, 1664 1665 /* Ntrig Panel */ 1666 { .driver_data = MT_CLS_NSMU, 1667 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8, 1668 USB_VENDOR_ID_NTRIG, 0x1b05) }, 1669 1670 /* PixArt optical touch screen */ 1671 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1672 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1673 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) }, 1674 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1675 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1676 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) }, 1677 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1678 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1679 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) }, 1680 1681 /* PixCir-based panels */ 1682 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1683 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1684 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) }, 1685 1686 /* Quanta-based panels */ 1687 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1688 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1689 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) }, 1690 1691 /* Stantum panels */ 1692 { .driver_data = MT_CLS_CONFIDENCE, 1693 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, 1694 USB_DEVICE_ID_MTP_STM)}, 1695 1696 /* TopSeed panels */ 1697 { .driver_data = MT_CLS_TOPSEED, 1698 MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, 1699 USB_DEVICE_ID_TOPSEED2_PERIPAD_701) }, 1700 1701 /* Touch International panels */ 1702 { .driver_data = MT_CLS_NSMU, 1703 MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, 1704 USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) }, 1705 1706 /* Unitec panels */ 1707 { .driver_data = MT_CLS_NSMU, 1708 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1709 USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) }, 1710 { .driver_data = MT_CLS_NSMU, 1711 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1712 USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) }, 1713 1714 /* VTL panels */ 1715 { .driver_data = MT_CLS_VTL, 1716 MT_USB_DEVICE(USB_VENDOR_ID_VTL, 1717 USB_DEVICE_ID_VTL_MULTITOUCH_FF3F) }, 1718 1719 /* Wistron panels */ 1720 { .driver_data = MT_CLS_NSMU, 1721 MT_USB_DEVICE(USB_VENDOR_ID_WISTRON, 1722 USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH) }, 1723 1724 /* XAT */ 1725 { .driver_data = MT_CLS_NSMU, 1726 MT_USB_DEVICE(USB_VENDOR_ID_XAT, 1727 USB_DEVICE_ID_XAT_CSR) }, 1728 1729 /* Xiroku */ 1730 { .driver_data = MT_CLS_NSMU, 1731 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1732 USB_DEVICE_ID_XIROKU_SPX) }, 1733 { .driver_data = MT_CLS_NSMU, 1734 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1735 USB_DEVICE_ID_XIROKU_MPX) }, 1736 { .driver_data = MT_CLS_NSMU, 1737 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1738 USB_DEVICE_ID_XIROKU_CSR) }, 1739 { .driver_data = MT_CLS_NSMU, 1740 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1741 USB_DEVICE_ID_XIROKU_SPX1) }, 1742 { .driver_data = MT_CLS_NSMU, 1743 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1744 USB_DEVICE_ID_XIROKU_MPX1) }, 1745 { .driver_data = MT_CLS_NSMU, 1746 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1747 USB_DEVICE_ID_XIROKU_CSR1) }, 1748 { .driver_data = MT_CLS_NSMU, 1749 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1750 USB_DEVICE_ID_XIROKU_SPX2) }, 1751 { .driver_data = MT_CLS_NSMU, 1752 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1753 USB_DEVICE_ID_XIROKU_MPX2) }, 1754 { .driver_data = MT_CLS_NSMU, 1755 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1756 USB_DEVICE_ID_XIROKU_CSR2) }, 1757 1758 /* Google MT devices */ 1759 { .driver_data = MT_CLS_GOOGLE, 1760 HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_GOOGLE, 1761 USB_DEVICE_ID_GOOGLE_TOUCH_ROSE) }, 1762 1763 /* Generic MT device */ 1764 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) }, 1765 1766 /* Generic Win 8 certified MT device */ 1767 { .driver_data = MT_CLS_WIN_8, 1768 HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8, 1769 HID_ANY_ID, HID_ANY_ID) }, 1770 { } 1771 }; 1772 MODULE_DEVICE_TABLE(hid, mt_devices); 1773 1774 static const struct hid_usage_id mt_grabbed_usages[] = { 1775 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID }, 1776 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1} 1777 }; 1778 1779 static struct hid_driver mt_driver = { 1780 .name = "hid-multitouch", 1781 .id_table = mt_devices, 1782 .probe = mt_probe, 1783 .remove = mt_remove, 1784 .input_mapping = mt_input_mapping, 1785 .input_mapped = mt_input_mapped, 1786 .input_configured = mt_input_configured, 1787 .feature_mapping = mt_feature_mapping, 1788 .usage_table = mt_grabbed_usages, 1789 .event = mt_event, 1790 .report = mt_report, 1791 #ifdef CONFIG_PM 1792 .reset_resume = mt_reset_resume, 1793 .resume = mt_resume, 1794 #endif 1795 }; 1796 module_hid_driver(mt_driver); 1797