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/string.h> 47 48 49 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>"); 50 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>"); 51 MODULE_DESCRIPTION("HID multitouch panels"); 52 MODULE_LICENSE("GPL"); 53 54 #include "hid-ids.h" 55 56 /* quirks to control the device */ 57 #define MT_QUIRK_NOT_SEEN_MEANS_UP (1 << 0) 58 #define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1) 59 #define MT_QUIRK_CYPRESS (1 << 2) 60 #define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3) 61 #define MT_QUIRK_ALWAYS_VALID (1 << 4) 62 #define MT_QUIRK_VALID_IS_INRANGE (1 << 5) 63 #define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 6) 64 #define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 8) 65 #define MT_QUIRK_NO_AREA (1 << 9) 66 #define MT_QUIRK_IGNORE_DUPLICATES (1 << 10) 67 #define MT_QUIRK_HOVERING (1 << 11) 68 #define MT_QUIRK_CONTACT_CNT_ACCURATE (1 << 12) 69 #define MT_QUIRK_FORCE_GET_FEATURE (1 << 13) 70 71 #define MT_INPUTMODE_TOUCHSCREEN 0x02 72 #define MT_INPUTMODE_TOUCHPAD 0x03 73 74 #define MT_BUTTONTYPE_CLICKPAD 0 75 76 struct mt_slot { 77 __s32 x, y, cx, cy, p, w, h; 78 __s32 contactid; /* the device ContactID assigned to this slot */ 79 bool touch_state; /* is the touch valid? */ 80 bool inrange_state; /* is the finger in proximity of the sensor? */ 81 }; 82 83 struct mt_class { 84 __s32 name; /* MT_CLS */ 85 __s32 quirks; 86 __s32 sn_move; /* Signal/noise ratio for move events */ 87 __s32 sn_width; /* Signal/noise ratio for width events */ 88 __s32 sn_height; /* Signal/noise ratio for height events */ 89 __s32 sn_pressure; /* Signal/noise ratio for pressure events */ 90 __u8 maxcontacts; 91 bool is_indirect; /* true for touchpads */ 92 bool export_all_inputs; /* do not ignore mouse, keyboards, etc... */ 93 }; 94 95 struct mt_fields { 96 unsigned usages[HID_MAX_FIELDS]; 97 unsigned int length; 98 }; 99 100 struct mt_device { 101 struct mt_slot curdata; /* placeholder of incoming data */ 102 struct mt_class mtclass; /* our mt device class */ 103 struct mt_fields *fields; /* temporary placeholder for storing the 104 multitouch fields */ 105 int cc_index; /* contact count field index in the report */ 106 int cc_value_index; /* contact count value index in the field */ 107 unsigned last_slot_field; /* the last field of a slot */ 108 unsigned mt_report_id; /* the report ID of the multitouch device */ 109 __s16 inputmode; /* InputMode HID feature, -1 if non-existent */ 110 __s16 inputmode_index; /* InputMode HID feature index in the report */ 111 __s16 maxcontact_report_id; /* Maximum Contact Number HID feature, 112 -1 if non-existent */ 113 __u8 inputmode_value; /* InputMode HID feature value */ 114 __u8 num_received; /* how many contacts we received */ 115 __u8 num_expected; /* expected last contact index */ 116 __u8 maxcontacts; 117 __u8 touches_by_report; /* how many touches are present in one report: 118 * 1 means we should use a serial protocol 119 * > 1 means hybrid (multitouch) protocol */ 120 __u8 buttons_count; /* number of physical buttons per touchpad */ 121 bool is_buttonpad; /* is this device a button pad? */ 122 bool serial_maybe; /* need to check for serial protocol */ 123 bool curvalid; /* is the current contact valid? */ 124 unsigned mt_flags; /* flags to pass to input-mt */ 125 }; 126 127 static void mt_post_parse_default_settings(struct mt_device *td); 128 static void mt_post_parse(struct mt_device *td); 129 130 /* classes of device behavior */ 131 #define MT_CLS_DEFAULT 0x0001 132 133 #define MT_CLS_SERIAL 0x0002 134 #define MT_CLS_CONFIDENCE 0x0003 135 #define MT_CLS_CONFIDENCE_CONTACT_ID 0x0004 136 #define MT_CLS_CONFIDENCE_MINUS_ONE 0x0005 137 #define MT_CLS_DUAL_INRANGE_CONTACTID 0x0006 138 #define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0007 139 /* reserved 0x0008 */ 140 #define MT_CLS_INRANGE_CONTACTNUMBER 0x0009 141 #define MT_CLS_NSMU 0x000a 142 /* reserved 0x0010 */ 143 /* reserved 0x0011 */ 144 #define MT_CLS_WIN_8 0x0012 145 #define MT_CLS_EXPORT_ALL_INPUTS 0x0013 146 147 /* vendor specific classes */ 148 #define MT_CLS_3M 0x0101 149 /* reserved 0x0102 */ 150 #define MT_CLS_EGALAX 0x0103 151 #define MT_CLS_EGALAX_SERIAL 0x0104 152 #define MT_CLS_TOPSEED 0x0105 153 #define MT_CLS_PANASONIC 0x0106 154 #define MT_CLS_FLATFROG 0x0107 155 #define MT_CLS_GENERALTOUCH_TWOFINGERS 0x0108 156 #define MT_CLS_GENERALTOUCH_PWT_TENFINGERS 0x0109 157 #define MT_CLS_VTL 0x0110 158 159 #define MT_DEFAULT_MAXCONTACT 10 160 #define MT_MAX_MAXCONTACT 250 161 162 #define MT_USB_DEVICE(v, p) HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p) 163 #define MT_BT_DEVICE(v, p) HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p) 164 165 /* 166 * these device-dependent functions determine what slot corresponds 167 * to a valid contact that was just read. 168 */ 169 170 static int cypress_compute_slot(struct mt_device *td) 171 { 172 if (td->curdata.contactid != 0 || td->num_received == 0) 173 return td->curdata.contactid; 174 else 175 return -1; 176 } 177 178 static struct mt_class mt_classes[] = { 179 { .name = MT_CLS_DEFAULT, 180 .quirks = MT_QUIRK_ALWAYS_VALID | 181 MT_QUIRK_CONTACT_CNT_ACCURATE }, 182 { .name = MT_CLS_NSMU, 183 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP }, 184 { .name = MT_CLS_SERIAL, 185 .quirks = MT_QUIRK_ALWAYS_VALID}, 186 { .name = MT_CLS_CONFIDENCE, 187 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE }, 188 { .name = MT_CLS_CONFIDENCE_CONTACT_ID, 189 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 190 MT_QUIRK_SLOT_IS_CONTACTID }, 191 { .name = MT_CLS_CONFIDENCE_MINUS_ONE, 192 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 193 MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE }, 194 { .name = MT_CLS_DUAL_INRANGE_CONTACTID, 195 .quirks = MT_QUIRK_VALID_IS_INRANGE | 196 MT_QUIRK_SLOT_IS_CONTACTID, 197 .maxcontacts = 2 }, 198 { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 199 .quirks = MT_QUIRK_VALID_IS_INRANGE | 200 MT_QUIRK_SLOT_IS_CONTACTNUMBER, 201 .maxcontacts = 2 }, 202 { .name = MT_CLS_INRANGE_CONTACTNUMBER, 203 .quirks = MT_QUIRK_VALID_IS_INRANGE | 204 MT_QUIRK_SLOT_IS_CONTACTNUMBER }, 205 { .name = MT_CLS_WIN_8, 206 .quirks = MT_QUIRK_ALWAYS_VALID | 207 MT_QUIRK_IGNORE_DUPLICATES | 208 MT_QUIRK_HOVERING | 209 MT_QUIRK_CONTACT_CNT_ACCURATE }, 210 { .name = MT_CLS_EXPORT_ALL_INPUTS, 211 .quirks = MT_QUIRK_ALWAYS_VALID | 212 MT_QUIRK_CONTACT_CNT_ACCURATE, 213 .export_all_inputs = true }, 214 215 /* 216 * vendor specific classes 217 */ 218 { .name = MT_CLS_3M, 219 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 220 MT_QUIRK_SLOT_IS_CONTACTID, 221 .sn_move = 2048, 222 .sn_width = 128, 223 .sn_height = 128, 224 .maxcontacts = 60, 225 }, 226 { .name = MT_CLS_EGALAX, 227 .quirks = MT_QUIRK_SLOT_IS_CONTACTID | 228 MT_QUIRK_VALID_IS_INRANGE, 229 .sn_move = 4096, 230 .sn_pressure = 32, 231 }, 232 { .name = MT_CLS_EGALAX_SERIAL, 233 .quirks = MT_QUIRK_SLOT_IS_CONTACTID | 234 MT_QUIRK_ALWAYS_VALID, 235 .sn_move = 4096, 236 .sn_pressure = 32, 237 }, 238 { .name = MT_CLS_TOPSEED, 239 .quirks = MT_QUIRK_ALWAYS_VALID, 240 .is_indirect = true, 241 .maxcontacts = 2, 242 }, 243 { .name = MT_CLS_PANASONIC, 244 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP, 245 .maxcontacts = 4 }, 246 { .name = MT_CLS_GENERALTOUCH_TWOFINGERS, 247 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 248 MT_QUIRK_VALID_IS_INRANGE | 249 MT_QUIRK_SLOT_IS_CONTACTID, 250 .maxcontacts = 2 251 }, 252 { .name = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 253 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 254 MT_QUIRK_SLOT_IS_CONTACTID 255 }, 256 257 { .name = MT_CLS_FLATFROG, 258 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 259 MT_QUIRK_NO_AREA, 260 .sn_move = 2048, 261 .maxcontacts = 40, 262 }, 263 { .name = MT_CLS_VTL, 264 .quirks = MT_QUIRK_ALWAYS_VALID | 265 MT_QUIRK_CONTACT_CNT_ACCURATE | 266 MT_QUIRK_FORCE_GET_FEATURE, 267 }, 268 { } 269 }; 270 271 static ssize_t mt_show_quirks(struct device *dev, 272 struct device_attribute *attr, 273 char *buf) 274 { 275 struct hid_device *hdev = to_hid_device(dev); 276 struct mt_device *td = hid_get_drvdata(hdev); 277 278 return sprintf(buf, "%u\n", td->mtclass.quirks); 279 } 280 281 static ssize_t mt_set_quirks(struct device *dev, 282 struct device_attribute *attr, 283 const char *buf, size_t count) 284 { 285 struct hid_device *hdev = to_hid_device(dev); 286 struct mt_device *td = hid_get_drvdata(hdev); 287 288 unsigned long val; 289 290 if (kstrtoul(buf, 0, &val)) 291 return -EINVAL; 292 293 td->mtclass.quirks = val; 294 295 if (td->cc_index < 0) 296 td->mtclass.quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 297 298 return count; 299 } 300 301 static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks); 302 303 static struct attribute *sysfs_attrs[] = { 304 &dev_attr_quirks.attr, 305 NULL 306 }; 307 308 static struct attribute_group mt_attribute_group = { 309 .attrs = sysfs_attrs 310 }; 311 312 static void mt_get_feature(struct hid_device *hdev, struct hid_report *report) 313 { 314 struct mt_device *td = hid_get_drvdata(hdev); 315 int ret, size = hid_report_len(report); 316 u8 *buf; 317 318 /* 319 * Only fetch the feature report if initial reports are not already 320 * been retrieved. Currently this is only done for Windows 8 touch 321 * devices. 322 */ 323 if (!(hdev->quirks & HID_QUIRK_NO_INIT_REPORTS)) 324 return; 325 if (td->mtclass.name != MT_CLS_WIN_8) 326 return; 327 328 buf = hid_alloc_report_buf(report, GFP_KERNEL); 329 if (!buf) 330 return; 331 332 ret = hid_hw_raw_request(hdev, report->id, buf, size, 333 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 334 if (ret < 0) { 335 dev_warn(&hdev->dev, "failed to fetch feature %d\n", 336 report->id); 337 } else { 338 ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf, 339 size, 0); 340 if (ret) 341 dev_warn(&hdev->dev, "failed to report feature\n"); 342 } 343 344 kfree(buf); 345 } 346 347 static void mt_feature_mapping(struct hid_device *hdev, 348 struct hid_field *field, struct hid_usage *usage) 349 { 350 struct mt_device *td = hid_get_drvdata(hdev); 351 352 switch (usage->hid) { 353 case HID_DG_INPUTMODE: 354 /* Ignore if value index is out of bounds. */ 355 if (usage->usage_index >= field->report_count) { 356 dev_err(&hdev->dev, "HID_DG_INPUTMODE out of range\n"); 357 break; 358 } 359 360 if (td->inputmode < 0) { 361 td->inputmode = field->report->id; 362 td->inputmode_index = usage->usage_index; 363 } else { 364 /* 365 * Some elan panels wrongly declare 2 input mode 366 * features, and silently ignore when we set the 367 * value in the second field. Skip the second feature 368 * and hope for the best. 369 */ 370 dev_info(&hdev->dev, 371 "Ignoring the extra HID_DG_INPUTMODE\n"); 372 } 373 374 break; 375 case HID_DG_CONTACTMAX: 376 mt_get_feature(hdev, field->report); 377 378 td->maxcontact_report_id = field->report->id; 379 td->maxcontacts = field->value[0]; 380 if (!td->maxcontacts && 381 field->logical_maximum <= MT_MAX_MAXCONTACT) 382 td->maxcontacts = field->logical_maximum; 383 if (td->mtclass.maxcontacts) 384 /* check if the maxcontacts is given by the class */ 385 td->maxcontacts = td->mtclass.maxcontacts; 386 387 break; 388 case HID_DG_BUTTONTYPE: 389 if (usage->usage_index >= field->report_count) { 390 dev_err(&hdev->dev, "HID_DG_BUTTONTYPE out of range\n"); 391 break; 392 } 393 394 mt_get_feature(hdev, field->report); 395 if (field->value[usage->usage_index] == MT_BUTTONTYPE_CLICKPAD) 396 td->is_buttonpad = true; 397 398 break; 399 } 400 } 401 402 static void set_abs(struct input_dev *input, unsigned int code, 403 struct hid_field *field, int snratio) 404 { 405 int fmin = field->logical_minimum; 406 int fmax = field->logical_maximum; 407 int fuzz = snratio ? (fmax - fmin) / snratio : 0; 408 input_set_abs_params(input, code, fmin, fmax, fuzz, 0); 409 input_abs_set_res(input, code, hidinput_calc_abs_res(field, code)); 410 } 411 412 static void mt_store_field(struct hid_usage *usage, struct mt_device *td, 413 struct hid_input *hi) 414 { 415 struct mt_fields *f = td->fields; 416 417 if (f->length >= HID_MAX_FIELDS) 418 return; 419 420 f->usages[f->length++] = usage->hid; 421 } 422 423 static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi, 424 struct hid_field *field, struct hid_usage *usage, 425 unsigned long **bit, int *max) 426 { 427 struct mt_device *td = hid_get_drvdata(hdev); 428 struct mt_class *cls = &td->mtclass; 429 int code; 430 struct hid_usage *prev_usage = NULL; 431 432 if (field->application == HID_DG_TOUCHSCREEN) 433 td->mt_flags |= INPUT_MT_DIRECT; 434 435 /* 436 * Model touchscreens providing buttons as touchpads. 437 */ 438 if (field->application == HID_DG_TOUCHPAD || 439 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { 440 td->mt_flags |= INPUT_MT_POINTER; 441 td->inputmode_value = MT_INPUTMODE_TOUCHPAD; 442 } 443 444 /* count the buttons on touchpads */ 445 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) 446 td->buttons_count++; 447 448 if (usage->usage_index) 449 prev_usage = &field->usage[usage->usage_index - 1]; 450 451 switch (usage->hid & HID_USAGE_PAGE) { 452 453 case HID_UP_GENDESK: 454 switch (usage->hid) { 455 case HID_GD_X: 456 if (prev_usage && (prev_usage->hid == usage->hid)) { 457 hid_map_usage(hi, usage, bit, max, 458 EV_ABS, ABS_MT_TOOL_X); 459 set_abs(hi->input, ABS_MT_TOOL_X, field, 460 cls->sn_move); 461 } else { 462 hid_map_usage(hi, usage, bit, max, 463 EV_ABS, ABS_MT_POSITION_X); 464 set_abs(hi->input, ABS_MT_POSITION_X, field, 465 cls->sn_move); 466 } 467 468 mt_store_field(usage, td, hi); 469 return 1; 470 case HID_GD_Y: 471 if (prev_usage && (prev_usage->hid == usage->hid)) { 472 hid_map_usage(hi, usage, bit, max, 473 EV_ABS, ABS_MT_TOOL_Y); 474 set_abs(hi->input, ABS_MT_TOOL_Y, field, 475 cls->sn_move); 476 } else { 477 hid_map_usage(hi, usage, bit, max, 478 EV_ABS, ABS_MT_POSITION_Y); 479 set_abs(hi->input, ABS_MT_POSITION_Y, field, 480 cls->sn_move); 481 } 482 483 mt_store_field(usage, td, hi); 484 return 1; 485 } 486 return 0; 487 488 case HID_UP_DIGITIZER: 489 switch (usage->hid) { 490 case HID_DG_INRANGE: 491 if (cls->quirks & MT_QUIRK_HOVERING) { 492 hid_map_usage(hi, usage, bit, max, 493 EV_ABS, ABS_MT_DISTANCE); 494 input_set_abs_params(hi->input, 495 ABS_MT_DISTANCE, 0, 1, 0, 0); 496 } 497 mt_store_field(usage, td, hi); 498 return 1; 499 case HID_DG_CONFIDENCE: 500 if (cls->name == MT_CLS_WIN_8 && 501 field->application == HID_DG_TOUCHPAD) { 502 cls->quirks &= ~MT_QUIRK_ALWAYS_VALID; 503 cls->quirks |= MT_QUIRK_VALID_IS_CONFIDENCE; 504 } 505 mt_store_field(usage, td, hi); 506 return 1; 507 case HID_DG_TIPSWITCH: 508 hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH); 509 input_set_capability(hi->input, EV_KEY, BTN_TOUCH); 510 mt_store_field(usage, td, hi); 511 return 1; 512 case HID_DG_CONTACTID: 513 mt_store_field(usage, td, hi); 514 td->touches_by_report++; 515 td->mt_report_id = field->report->id; 516 return 1; 517 case HID_DG_WIDTH: 518 hid_map_usage(hi, usage, bit, max, 519 EV_ABS, ABS_MT_TOUCH_MAJOR); 520 if (!(cls->quirks & MT_QUIRK_NO_AREA)) 521 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field, 522 cls->sn_width); 523 mt_store_field(usage, td, hi); 524 return 1; 525 case HID_DG_HEIGHT: 526 hid_map_usage(hi, usage, bit, max, 527 EV_ABS, ABS_MT_TOUCH_MINOR); 528 if (!(cls->quirks & MT_QUIRK_NO_AREA)) { 529 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field, 530 cls->sn_height); 531 input_set_abs_params(hi->input, 532 ABS_MT_ORIENTATION, 0, 1, 0, 0); 533 } 534 mt_store_field(usage, td, hi); 535 return 1; 536 case HID_DG_TIPPRESSURE: 537 hid_map_usage(hi, usage, bit, max, 538 EV_ABS, ABS_MT_PRESSURE); 539 set_abs(hi->input, ABS_MT_PRESSURE, field, 540 cls->sn_pressure); 541 mt_store_field(usage, td, hi); 542 return 1; 543 case HID_DG_CONTACTCOUNT: 544 /* Ignore if indexes are out of bounds. */ 545 if (field->index >= field->report->maxfield || 546 usage->usage_index >= field->report_count) 547 return 1; 548 td->cc_index = field->index; 549 td->cc_value_index = usage->usage_index; 550 return 1; 551 case HID_DG_CONTACTMAX: 552 /* we don't set td->last_slot_field as contactcount and 553 * contact max are global to the report */ 554 return -1; 555 case HID_DG_TOUCH: 556 /* Legacy devices use TIPSWITCH and not TOUCH. 557 * Let's just ignore this field. */ 558 return -1; 559 } 560 /* let hid-input decide for the others */ 561 return 0; 562 563 case HID_UP_BUTTON: 564 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE); 565 hid_map_usage(hi, usage, bit, max, EV_KEY, code); 566 input_set_capability(hi->input, EV_KEY, code); 567 return 1; 568 569 case 0xff000000: 570 /* we do not want to map these: no input-oriented meaning */ 571 return -1; 572 } 573 574 return 0; 575 } 576 577 static int mt_touch_input_mapped(struct hid_device *hdev, struct hid_input *hi, 578 struct hid_field *field, struct hid_usage *usage, 579 unsigned long **bit, int *max) 580 { 581 if (usage->type == EV_KEY || usage->type == EV_ABS) 582 set_bit(usage->type, hi->input->evbit); 583 584 return -1; 585 } 586 587 static int mt_compute_slot(struct mt_device *td, struct input_dev *input) 588 { 589 __s32 quirks = td->mtclass.quirks; 590 591 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID) 592 return td->curdata.contactid; 593 594 if (quirks & MT_QUIRK_CYPRESS) 595 return cypress_compute_slot(td); 596 597 if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER) 598 return td->num_received; 599 600 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE) 601 return td->curdata.contactid - 1; 602 603 return input_mt_get_slot_by_key(input, td->curdata.contactid); 604 } 605 606 /* 607 * this function is called when a whole contact has been processed, 608 * so that it can assign it to a slot and store the data there 609 */ 610 static void mt_complete_slot(struct mt_device *td, struct input_dev *input) 611 { 612 if ((td->mtclass.quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) && 613 td->num_received >= td->num_expected) 614 return; 615 616 if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) { 617 int slotnum = mt_compute_slot(td, input); 618 struct mt_slot *s = &td->curdata; 619 struct input_mt *mt = input->mt; 620 621 if (slotnum < 0 || slotnum >= td->maxcontacts) 622 return; 623 624 if ((td->mtclass.quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) { 625 struct input_mt_slot *slot = &mt->slots[slotnum]; 626 if (input_mt_is_active(slot) && 627 input_mt_is_used(mt, slot)) 628 return; 629 } 630 631 input_mt_slot(input, slotnum); 632 input_mt_report_slot_state(input, MT_TOOL_FINGER, 633 s->touch_state || s->inrange_state); 634 if (s->touch_state || s->inrange_state) { 635 /* this finger is in proximity of the sensor */ 636 int wide = (s->w > s->h); 637 /* divided by two to match visual scale of touch */ 638 int major = max(s->w, s->h) >> 1; 639 int minor = min(s->w, s->h) >> 1; 640 641 input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x); 642 input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y); 643 input_event(input, EV_ABS, ABS_MT_TOOL_X, s->cx); 644 input_event(input, EV_ABS, ABS_MT_TOOL_Y, s->cy); 645 input_event(input, EV_ABS, ABS_MT_DISTANCE, 646 !s->touch_state); 647 input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide); 648 input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p); 649 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major); 650 input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor); 651 } 652 } 653 654 td->num_received++; 655 } 656 657 /* 658 * this function is called when a whole packet has been received and processed, 659 * so that it can decide what to send to the input layer. 660 */ 661 static void mt_sync_frame(struct mt_device *td, struct input_dev *input) 662 { 663 input_mt_sync_frame(input); 664 input_sync(input); 665 td->num_received = 0; 666 } 667 668 static int mt_touch_event(struct hid_device *hid, struct hid_field *field, 669 struct hid_usage *usage, __s32 value) 670 { 671 /* we will handle the hidinput part later, now remains hiddev */ 672 if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event) 673 hid->hiddev_hid_event(hid, field, usage, value); 674 675 return 1; 676 } 677 678 static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field, 679 struct hid_usage *usage, __s32 value) 680 { 681 struct mt_device *td = hid_get_drvdata(hid); 682 __s32 quirks = td->mtclass.quirks; 683 struct input_dev *input = field->hidinput->input; 684 685 if (hid->claimed & HID_CLAIMED_INPUT) { 686 switch (usage->hid) { 687 case HID_DG_INRANGE: 688 if (quirks & MT_QUIRK_VALID_IS_INRANGE) 689 td->curvalid = value; 690 if (quirks & MT_QUIRK_HOVERING) 691 td->curdata.inrange_state = value; 692 break; 693 case HID_DG_TIPSWITCH: 694 if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 695 td->curvalid = value; 696 td->curdata.touch_state = value; 697 break; 698 case HID_DG_CONFIDENCE: 699 if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE) 700 td->curvalid = value; 701 break; 702 case HID_DG_CONTACTID: 703 td->curdata.contactid = value; 704 break; 705 case HID_DG_TIPPRESSURE: 706 td->curdata.p = value; 707 break; 708 case HID_GD_X: 709 if (usage->code == ABS_MT_TOOL_X) 710 td->curdata.cx = value; 711 else 712 td->curdata.x = value; 713 break; 714 case HID_GD_Y: 715 if (usage->code == ABS_MT_TOOL_Y) 716 td->curdata.cy = value; 717 else 718 td->curdata.y = value; 719 break; 720 case HID_DG_WIDTH: 721 td->curdata.w = value; 722 break; 723 case HID_DG_HEIGHT: 724 td->curdata.h = value; 725 break; 726 case HID_DG_CONTACTCOUNT: 727 break; 728 case HID_DG_TOUCH: 729 /* do nothing */ 730 break; 731 732 default: 733 if (usage->type) 734 input_event(input, usage->type, usage->code, 735 value); 736 return; 737 } 738 739 if (usage->usage_index + 1 == field->report_count) { 740 /* we only take into account the last report. */ 741 if (usage->hid == td->last_slot_field) 742 mt_complete_slot(td, field->hidinput->input); 743 } 744 745 } 746 } 747 748 static void mt_touch_report(struct hid_device *hid, struct hid_report *report) 749 { 750 struct mt_device *td = hid_get_drvdata(hid); 751 struct hid_field *field; 752 unsigned count; 753 int r, n; 754 755 /* 756 * Includes multi-packet support where subsequent 757 * packets are sent with zero contactcount. 758 */ 759 if (td->cc_index >= 0) { 760 struct hid_field *field = report->field[td->cc_index]; 761 int value = field->value[td->cc_value_index]; 762 if (value) 763 td->num_expected = value; 764 } 765 766 for (r = 0; r < report->maxfield; r++) { 767 field = report->field[r]; 768 count = field->report_count; 769 770 if (!(HID_MAIN_ITEM_VARIABLE & field->flags)) 771 continue; 772 773 for (n = 0; n < count; n++) 774 mt_process_mt_event(hid, field, &field->usage[n], 775 field->value[n]); 776 } 777 778 if (td->num_received >= td->num_expected) 779 mt_sync_frame(td, report->field[0]->hidinput->input); 780 } 781 782 static int mt_touch_input_configured(struct hid_device *hdev, 783 struct hid_input *hi) 784 { 785 struct mt_device *td = hid_get_drvdata(hdev); 786 struct mt_class *cls = &td->mtclass; 787 struct input_dev *input = hi->input; 788 int ret; 789 790 if (!td->maxcontacts) 791 td->maxcontacts = MT_DEFAULT_MAXCONTACT; 792 793 mt_post_parse(td); 794 if (td->serial_maybe) 795 mt_post_parse_default_settings(td); 796 797 if (cls->is_indirect) 798 td->mt_flags |= INPUT_MT_POINTER; 799 800 if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 801 td->mt_flags |= INPUT_MT_DROP_UNUSED; 802 803 /* check for clickpads */ 804 if ((td->mt_flags & INPUT_MT_POINTER) && (td->buttons_count == 1)) 805 td->is_buttonpad = true; 806 807 if (td->is_buttonpad) 808 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); 809 810 ret = input_mt_init_slots(input, td->maxcontacts, td->mt_flags); 811 if (ret) 812 return ret; 813 814 td->mt_flags = 0; 815 return 0; 816 } 817 818 static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, 819 struct hid_field *field, struct hid_usage *usage, 820 unsigned long **bit, int *max) 821 { 822 struct mt_device *td = hid_get_drvdata(hdev); 823 824 /* 825 * If mtclass.export_all_inputs is not set, only map fields from 826 * TouchScreen or TouchPad collections. We need to ignore fields 827 * that belong to other collections such as Mouse that might have 828 * the same GenericDesktop usages. 829 */ 830 if (!td->mtclass.export_all_inputs && 831 field->application != HID_DG_TOUCHSCREEN && 832 field->application != HID_DG_PEN && 833 field->application != HID_DG_TOUCHPAD) 834 return -1; 835 836 /* 837 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 838 * for the stylus. 839 * The check for mt_report_id ensures we don't process 840 * HID_DG_CONTACTCOUNT from the pen report as it is outside the physical 841 * collection, but within the report ID. 842 */ 843 if (field->physical == HID_DG_STYLUS) 844 return 0; 845 else if ((field->physical == 0) && 846 (field->report->id != td->mt_report_id) && 847 (td->mt_report_id != -1)) 848 return 0; 849 850 if (field->application == HID_DG_TOUCHSCREEN || 851 field->application == HID_DG_TOUCHPAD) 852 return mt_touch_input_mapping(hdev, hi, field, usage, bit, max); 853 854 /* let hid-core decide for the others */ 855 return 0; 856 } 857 858 static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi, 859 struct hid_field *field, struct hid_usage *usage, 860 unsigned long **bit, int *max) 861 { 862 /* 863 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 864 * for the stylus. 865 */ 866 if (field->physical == HID_DG_STYLUS) 867 return 0; 868 869 if (field->application == HID_DG_TOUCHSCREEN || 870 field->application == HID_DG_TOUCHPAD) 871 return mt_touch_input_mapped(hdev, hi, field, usage, bit, max); 872 873 /* let hid-core decide for the others */ 874 return 0; 875 } 876 877 static int mt_event(struct hid_device *hid, struct hid_field *field, 878 struct hid_usage *usage, __s32 value) 879 { 880 struct mt_device *td = hid_get_drvdata(hid); 881 882 if (field->report->id == td->mt_report_id) 883 return mt_touch_event(hid, field, usage, value); 884 885 return 0; 886 } 887 888 static void mt_report(struct hid_device *hid, struct hid_report *report) 889 { 890 struct mt_device *td = hid_get_drvdata(hid); 891 struct hid_field *field = report->field[0]; 892 893 if (!(hid->claimed & HID_CLAIMED_INPUT)) 894 return; 895 896 if (report->id == td->mt_report_id) 897 return mt_touch_report(hid, report); 898 899 if (field && field->hidinput && field->hidinput->input) 900 input_sync(field->hidinput->input); 901 } 902 903 static void mt_set_input_mode(struct hid_device *hdev) 904 { 905 struct mt_device *td = hid_get_drvdata(hdev); 906 struct hid_report *r; 907 struct hid_report_enum *re; 908 struct mt_class *cls = &td->mtclass; 909 char *buf; 910 int report_len; 911 912 if (td->inputmode < 0) 913 return; 914 915 re = &(hdev->report_enum[HID_FEATURE_REPORT]); 916 r = re->report_id_hash[td->inputmode]; 917 if (r) { 918 if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) { 919 report_len = hid_report_len(r); 920 buf = hid_alloc_report_buf(r, GFP_KERNEL); 921 if (!buf) { 922 hid_err(hdev, "failed to allocate buffer for report\n"); 923 return; 924 } 925 hid_hw_raw_request(hdev, r->id, buf, report_len, 926 HID_FEATURE_REPORT, 927 HID_REQ_GET_REPORT); 928 kfree(buf); 929 } 930 r->field[0]->value[td->inputmode_index] = td->inputmode_value; 931 hid_hw_request(hdev, r, HID_REQ_SET_REPORT); 932 } 933 } 934 935 static void mt_set_maxcontacts(struct hid_device *hdev) 936 { 937 struct mt_device *td = hid_get_drvdata(hdev); 938 struct hid_report *r; 939 struct hid_report_enum *re; 940 int fieldmax, max; 941 942 if (td->maxcontact_report_id < 0) 943 return; 944 945 if (!td->mtclass.maxcontacts) 946 return; 947 948 re = &hdev->report_enum[HID_FEATURE_REPORT]; 949 r = re->report_id_hash[td->maxcontact_report_id]; 950 if (r) { 951 max = td->mtclass.maxcontacts; 952 fieldmax = r->field[0]->logical_maximum; 953 max = min(fieldmax, max); 954 if (r->field[0]->value[0] != max) { 955 r->field[0]->value[0] = max; 956 hid_hw_request(hdev, r, HID_REQ_SET_REPORT); 957 } 958 } 959 } 960 961 static void mt_post_parse_default_settings(struct mt_device *td) 962 { 963 __s32 quirks = td->mtclass.quirks; 964 965 /* unknown serial device needs special quirks */ 966 if (td->touches_by_report == 1) { 967 quirks |= MT_QUIRK_ALWAYS_VALID; 968 quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP; 969 quirks &= ~MT_QUIRK_VALID_IS_INRANGE; 970 quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE; 971 quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 972 } 973 974 td->mtclass.quirks = quirks; 975 } 976 977 static void mt_post_parse(struct mt_device *td) 978 { 979 struct mt_fields *f = td->fields; 980 struct mt_class *cls = &td->mtclass; 981 982 if (td->touches_by_report > 0) { 983 int field_count_per_touch = f->length / td->touches_by_report; 984 td->last_slot_field = f->usages[field_count_per_touch - 1]; 985 } 986 987 if (td->cc_index < 0) 988 cls->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 989 } 990 991 static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi) 992 { 993 struct mt_device *td = hid_get_drvdata(hdev); 994 char *name; 995 const char *suffix = NULL; 996 struct hid_field *field = hi->report->field[0]; 997 int ret; 998 999 if (hi->report->id == td->mt_report_id) { 1000 ret = mt_touch_input_configured(hdev, hi); 1001 if (ret) 1002 return ret; 1003 } 1004 1005 /* 1006 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 1007 * for the stylus. Check this first, and then rely on the application 1008 * field. 1009 */ 1010 if (hi->report->field[0]->physical == HID_DG_STYLUS) { 1011 suffix = "Pen"; 1012 /* force BTN_STYLUS to allow tablet matching in udev */ 1013 __set_bit(BTN_STYLUS, hi->input->keybit); 1014 } else { 1015 switch (field->application) { 1016 case HID_GD_KEYBOARD: 1017 suffix = "Keyboard"; 1018 break; 1019 case HID_GD_KEYPAD: 1020 suffix = "Keypad"; 1021 break; 1022 case HID_GD_MOUSE: 1023 suffix = "Mouse"; 1024 break; 1025 case HID_DG_STYLUS: 1026 suffix = "Pen"; 1027 /* force BTN_STYLUS to allow tablet matching in udev */ 1028 __set_bit(BTN_STYLUS, hi->input->keybit); 1029 break; 1030 case HID_DG_TOUCHSCREEN: 1031 /* we do not set suffix = "Touchscreen" */ 1032 break; 1033 case HID_DG_TOUCHPAD: 1034 suffix = "Touchpad"; 1035 break; 1036 case HID_GD_SYSTEM_CONTROL: 1037 suffix = "System Control"; 1038 break; 1039 case HID_CP_CONSUMER_CONTROL: 1040 suffix = "Consumer Control"; 1041 break; 1042 default: 1043 suffix = "UNKNOWN"; 1044 break; 1045 } 1046 } 1047 1048 if (suffix) { 1049 name = devm_kzalloc(&hi->input->dev, 1050 strlen(hdev->name) + strlen(suffix) + 2, 1051 GFP_KERNEL); 1052 if (name) { 1053 sprintf(name, "%s %s", hdev->name, suffix); 1054 hi->input->name = name; 1055 } 1056 } 1057 1058 return 0; 1059 } 1060 1061 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) 1062 { 1063 int ret, i; 1064 struct mt_device *td; 1065 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */ 1066 1067 for (i = 0; mt_classes[i].name ; i++) { 1068 if (id->driver_data == mt_classes[i].name) { 1069 mtclass = &(mt_classes[i]); 1070 break; 1071 } 1072 } 1073 1074 /* This allows the driver to correctly support devices 1075 * that emit events over several HID messages. 1076 */ 1077 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; 1078 1079 /* 1080 * This allows the driver to handle different input sensors 1081 * that emits events through different reports on the same HID 1082 * device. 1083 */ 1084 hdev->quirks |= HID_QUIRK_MULTI_INPUT; 1085 hdev->quirks |= HID_QUIRK_NO_EMPTY_INPUT; 1086 1087 /* 1088 * Handle special quirks for Windows 8 certified devices. 1089 */ 1090 if (id->group == HID_GROUP_MULTITOUCH_WIN_8) 1091 /* 1092 * Some multitouch screens do not like to be polled for input 1093 * reports. Fortunately, the Win8 spec says that all touches 1094 * should be sent during each report, making the initialization 1095 * of input reports unnecessary. 1096 * 1097 * In addition some touchpads do not behave well if we read 1098 * all feature reports from them. Instead we prevent 1099 * initial report fetching and then selectively fetch each 1100 * report we are interested in. 1101 */ 1102 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 1103 1104 td = devm_kzalloc(&hdev->dev, sizeof(struct mt_device), GFP_KERNEL); 1105 if (!td) { 1106 dev_err(&hdev->dev, "cannot allocate multitouch data\n"); 1107 return -ENOMEM; 1108 } 1109 td->mtclass = *mtclass; 1110 td->inputmode = -1; 1111 td->maxcontact_report_id = -1; 1112 td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN; 1113 td->cc_index = -1; 1114 td->mt_report_id = -1; 1115 hid_set_drvdata(hdev, td); 1116 1117 td->fields = devm_kzalloc(&hdev->dev, sizeof(struct mt_fields), 1118 GFP_KERNEL); 1119 if (!td->fields) { 1120 dev_err(&hdev->dev, "cannot allocate multitouch fields data\n"); 1121 return -ENOMEM; 1122 } 1123 1124 if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID) 1125 td->serial_maybe = true; 1126 1127 ret = hid_parse(hdev); 1128 if (ret != 0) 1129 return ret; 1130 1131 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1132 if (ret) 1133 return ret; 1134 1135 ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group); 1136 1137 mt_set_maxcontacts(hdev); 1138 mt_set_input_mode(hdev); 1139 1140 /* release .fields memory as it is not used anymore */ 1141 devm_kfree(&hdev->dev, td->fields); 1142 td->fields = NULL; 1143 1144 return 0; 1145 } 1146 1147 #ifdef CONFIG_PM 1148 static int mt_reset_resume(struct hid_device *hdev) 1149 { 1150 mt_set_maxcontacts(hdev); 1151 mt_set_input_mode(hdev); 1152 return 0; 1153 } 1154 1155 static int mt_resume(struct hid_device *hdev) 1156 { 1157 /* Some Elan legacy devices require SET_IDLE to be set on resume. 1158 * It should be safe to send it to other devices too. 1159 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */ 1160 1161 hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE); 1162 1163 return 0; 1164 } 1165 #endif 1166 1167 static void mt_remove(struct hid_device *hdev) 1168 { 1169 sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group); 1170 hid_hw_stop(hdev); 1171 } 1172 1173 /* 1174 * This list contains only: 1175 * - VID/PID of products not working with the default multitouch handling 1176 * - 2 generic rules. 1177 * So there is no point in adding here any device with MT_CLS_DEFAULT. 1178 */ 1179 static const struct hid_device_id mt_devices[] = { 1180 1181 /* 3M panels */ 1182 { .driver_data = MT_CLS_3M, 1183 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1184 USB_DEVICE_ID_3M1968) }, 1185 { .driver_data = MT_CLS_3M, 1186 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1187 USB_DEVICE_ID_3M2256) }, 1188 { .driver_data = MT_CLS_3M, 1189 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1190 USB_DEVICE_ID_3M3266) }, 1191 1192 /* Anton devices */ 1193 { .driver_data = MT_CLS_EXPORT_ALL_INPUTS, 1194 MT_USB_DEVICE(USB_VENDOR_ID_ANTON, 1195 USB_DEVICE_ID_ANTON_TOUCH_PAD) }, 1196 1197 /* Atmel panels */ 1198 { .driver_data = MT_CLS_SERIAL, 1199 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL, 1200 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) }, 1201 1202 /* Baanto multitouch devices */ 1203 { .driver_data = MT_CLS_NSMU, 1204 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO, 1205 USB_DEVICE_ID_BAANTO_MT_190W2) }, 1206 1207 /* Cando panels */ 1208 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 1209 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1210 USB_DEVICE_ID_CANDO_MULTI_TOUCH) }, 1211 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 1212 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1213 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) }, 1214 1215 /* Chunghwa Telecom touch panels */ 1216 { .driver_data = MT_CLS_NSMU, 1217 MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, 1218 USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) }, 1219 1220 /* CJTouch panels */ 1221 { .driver_data = MT_CLS_NSMU, 1222 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH, 1223 USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020) }, 1224 { .driver_data = MT_CLS_NSMU, 1225 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH, 1226 USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040) }, 1227 1228 /* CVTouch panels */ 1229 { .driver_data = MT_CLS_NSMU, 1230 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, 1231 USB_DEVICE_ID_CVTOUCH_SCREEN) }, 1232 1233 /* eGalax devices (resistive) */ 1234 { .driver_data = MT_CLS_EGALAX, 1235 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1236 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) }, 1237 { .driver_data = MT_CLS_EGALAX, 1238 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1239 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) }, 1240 1241 /* eGalax devices (capacitive) */ 1242 { .driver_data = MT_CLS_EGALAX_SERIAL, 1243 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1244 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) }, 1245 { .driver_data = MT_CLS_EGALAX, 1246 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1247 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) }, 1248 { .driver_data = MT_CLS_EGALAX_SERIAL, 1249 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1250 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, 1251 { .driver_data = MT_CLS_EGALAX_SERIAL, 1252 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1253 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) }, 1254 { .driver_data = MT_CLS_EGALAX_SERIAL, 1255 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1256 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) }, 1257 { .driver_data = MT_CLS_EGALAX_SERIAL, 1258 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1259 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) }, 1260 { .driver_data = MT_CLS_EGALAX, 1261 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1262 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) }, 1263 { .driver_data = MT_CLS_EGALAX, 1264 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1265 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) }, 1266 { .driver_data = MT_CLS_EGALAX_SERIAL, 1267 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1268 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) }, 1269 { .driver_data = MT_CLS_EGALAX, 1270 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1271 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) }, 1272 { .driver_data = MT_CLS_EGALAX, 1273 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1274 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) }, 1275 { .driver_data = MT_CLS_EGALAX, 1276 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1277 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) }, 1278 { .driver_data = MT_CLS_EGALAX, 1279 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1280 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) }, 1281 { .driver_data = MT_CLS_EGALAX_SERIAL, 1282 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1283 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) }, 1284 { .driver_data = MT_CLS_EGALAX_SERIAL, 1285 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1286 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) }, 1287 { .driver_data = MT_CLS_EGALAX_SERIAL, 1288 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1289 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) }, 1290 1291 /* Elitegroup panel */ 1292 { .driver_data = MT_CLS_SERIAL, 1293 MT_USB_DEVICE(USB_VENDOR_ID_ELITEGROUP, 1294 USB_DEVICE_ID_ELITEGROUP_05D8) }, 1295 1296 /* Flatfrog Panels */ 1297 { .driver_data = MT_CLS_FLATFROG, 1298 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG, 1299 USB_DEVICE_ID_MULTITOUCH_3200) }, 1300 1301 /* FocalTech Panels */ 1302 { .driver_data = MT_CLS_SERIAL, 1303 MT_USB_DEVICE(USB_VENDOR_ID_CYGNAL, 1304 USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH) }, 1305 1306 /* GeneralTouch panel */ 1307 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS, 1308 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1309 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) }, 1310 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1311 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1312 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) }, 1313 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS, 1314 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1315 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0101) }, 1316 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1317 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1318 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0102) }, 1319 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1320 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1321 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0106) }, 1322 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1323 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1324 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A) }, 1325 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1326 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1327 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100) }, 1328 1329 /* Gametel game controller */ 1330 { .driver_data = MT_CLS_NSMU, 1331 MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL, 1332 USB_DEVICE_ID_GAMETEL_MT_MODE) }, 1333 1334 /* GoodTouch panels */ 1335 { .driver_data = MT_CLS_NSMU, 1336 MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, 1337 USB_DEVICE_ID_GOODTOUCH_000f) }, 1338 1339 /* Hanvon panels */ 1340 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1341 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, 1342 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) }, 1343 1344 /* Ilitek dual touch panel */ 1345 { .driver_data = MT_CLS_NSMU, 1346 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK, 1347 USB_DEVICE_ID_ILITEK_MULTITOUCH) }, 1348 1349 /* MosArt panels */ 1350 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1351 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1352 USB_DEVICE_ID_ASUS_T91MT)}, 1353 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1354 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1355 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) }, 1356 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1357 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX, 1358 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) }, 1359 1360 /* Panasonic panels */ 1361 { .driver_data = MT_CLS_PANASONIC, 1362 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1363 USB_DEVICE_ID_PANABOARD_UBT780) }, 1364 { .driver_data = MT_CLS_PANASONIC, 1365 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1366 USB_DEVICE_ID_PANABOARD_UBT880) }, 1367 1368 /* Novatek Panel */ 1369 { .driver_data = MT_CLS_NSMU, 1370 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK, 1371 USB_DEVICE_ID_NOVATEK_PCT) }, 1372 1373 /* PixArt optical touch screen */ 1374 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1375 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1376 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) }, 1377 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1378 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1379 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) }, 1380 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1381 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1382 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) }, 1383 1384 /* PixCir-based panels */ 1385 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1386 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1387 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) }, 1388 1389 /* Quanta-based panels */ 1390 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1391 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1392 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) }, 1393 1394 /* Stantum panels */ 1395 { .driver_data = MT_CLS_CONFIDENCE, 1396 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, 1397 USB_DEVICE_ID_MTP_STM)}, 1398 1399 /* TopSeed panels */ 1400 { .driver_data = MT_CLS_TOPSEED, 1401 MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, 1402 USB_DEVICE_ID_TOPSEED2_PERIPAD_701) }, 1403 1404 /* Touch International panels */ 1405 { .driver_data = MT_CLS_NSMU, 1406 MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, 1407 USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) }, 1408 1409 /* Unitec panels */ 1410 { .driver_data = MT_CLS_NSMU, 1411 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1412 USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) }, 1413 { .driver_data = MT_CLS_NSMU, 1414 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1415 USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) }, 1416 1417 /* VTL panels */ 1418 { .driver_data = MT_CLS_VTL, 1419 MT_USB_DEVICE(USB_VENDOR_ID_VTL, 1420 USB_DEVICE_ID_VTL_MULTITOUCH_FF3F) }, 1421 1422 /* Wistron panels */ 1423 { .driver_data = MT_CLS_NSMU, 1424 MT_USB_DEVICE(USB_VENDOR_ID_WISTRON, 1425 USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH) }, 1426 1427 /* XAT */ 1428 { .driver_data = MT_CLS_NSMU, 1429 MT_USB_DEVICE(USB_VENDOR_ID_XAT, 1430 USB_DEVICE_ID_XAT_CSR) }, 1431 1432 /* Xiroku */ 1433 { .driver_data = MT_CLS_NSMU, 1434 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1435 USB_DEVICE_ID_XIROKU_SPX) }, 1436 { .driver_data = MT_CLS_NSMU, 1437 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1438 USB_DEVICE_ID_XIROKU_MPX) }, 1439 { .driver_data = MT_CLS_NSMU, 1440 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1441 USB_DEVICE_ID_XIROKU_CSR) }, 1442 { .driver_data = MT_CLS_NSMU, 1443 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1444 USB_DEVICE_ID_XIROKU_SPX1) }, 1445 { .driver_data = MT_CLS_NSMU, 1446 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1447 USB_DEVICE_ID_XIROKU_MPX1) }, 1448 { .driver_data = MT_CLS_NSMU, 1449 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1450 USB_DEVICE_ID_XIROKU_CSR1) }, 1451 { .driver_data = MT_CLS_NSMU, 1452 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1453 USB_DEVICE_ID_XIROKU_SPX2) }, 1454 { .driver_data = MT_CLS_NSMU, 1455 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1456 USB_DEVICE_ID_XIROKU_MPX2) }, 1457 { .driver_data = MT_CLS_NSMU, 1458 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1459 USB_DEVICE_ID_XIROKU_CSR2) }, 1460 1461 /* Generic MT device */ 1462 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) }, 1463 1464 /* Generic Win 8 certified MT device */ 1465 { .driver_data = MT_CLS_WIN_8, 1466 HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8, 1467 HID_ANY_ID, HID_ANY_ID) }, 1468 { } 1469 }; 1470 MODULE_DEVICE_TABLE(hid, mt_devices); 1471 1472 static const struct hid_usage_id mt_grabbed_usages[] = { 1473 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID }, 1474 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1} 1475 }; 1476 1477 static struct hid_driver mt_driver = { 1478 .name = "hid-multitouch", 1479 .id_table = mt_devices, 1480 .probe = mt_probe, 1481 .remove = mt_remove, 1482 .input_mapping = mt_input_mapping, 1483 .input_mapped = mt_input_mapped, 1484 .input_configured = mt_input_configured, 1485 .feature_mapping = mt_feature_mapping, 1486 .usage_table = mt_grabbed_usages, 1487 .event = mt_event, 1488 .report = mt_report, 1489 #ifdef CONFIG_PM 1490 .reset_resume = mt_reset_resume, 1491 .resume = mt_resume, 1492 #endif 1493 }; 1494 module_hid_driver(mt_driver); 1495