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 = container_of(dev, struct 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 = container_of(dev, struct 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 td->inputmode = field->report->id; 361 td->inputmode_index = usage->usage_index; 362 363 break; 364 case HID_DG_CONTACTMAX: 365 mt_get_feature(hdev, field->report); 366 367 td->maxcontact_report_id = field->report->id; 368 td->maxcontacts = field->value[0]; 369 if (!td->maxcontacts && 370 field->logical_maximum <= MT_MAX_MAXCONTACT) 371 td->maxcontacts = field->logical_maximum; 372 if (td->mtclass.maxcontacts) 373 /* check if the maxcontacts is given by the class */ 374 td->maxcontacts = td->mtclass.maxcontacts; 375 376 break; 377 case HID_DG_BUTTONTYPE: 378 if (usage->usage_index >= field->report_count) { 379 dev_err(&hdev->dev, "HID_DG_BUTTONTYPE out of range\n"); 380 break; 381 } 382 383 mt_get_feature(hdev, field->report); 384 if (field->value[usage->usage_index] == MT_BUTTONTYPE_CLICKPAD) 385 td->is_buttonpad = true; 386 387 break; 388 } 389 } 390 391 static void set_abs(struct input_dev *input, unsigned int code, 392 struct hid_field *field, int snratio) 393 { 394 int fmin = field->logical_minimum; 395 int fmax = field->logical_maximum; 396 int fuzz = snratio ? (fmax - fmin) / snratio : 0; 397 input_set_abs_params(input, code, fmin, fmax, fuzz, 0); 398 input_abs_set_res(input, code, hidinput_calc_abs_res(field, code)); 399 } 400 401 static void mt_store_field(struct hid_usage *usage, struct mt_device *td, 402 struct hid_input *hi) 403 { 404 struct mt_fields *f = td->fields; 405 406 if (f->length >= HID_MAX_FIELDS) 407 return; 408 409 f->usages[f->length++] = usage->hid; 410 } 411 412 static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi, 413 struct hid_field *field, struct hid_usage *usage, 414 unsigned long **bit, int *max) 415 { 416 struct mt_device *td = hid_get_drvdata(hdev); 417 struct mt_class *cls = &td->mtclass; 418 int code; 419 struct hid_usage *prev_usage = NULL; 420 421 if (field->application == HID_DG_TOUCHSCREEN) 422 td->mt_flags |= INPUT_MT_DIRECT; 423 424 /* 425 * Model touchscreens providing buttons as touchpads. 426 */ 427 if (field->application == HID_DG_TOUCHPAD || 428 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { 429 td->mt_flags |= INPUT_MT_POINTER; 430 td->inputmode_value = MT_INPUTMODE_TOUCHPAD; 431 } 432 433 /* count the buttons on touchpads */ 434 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) 435 td->buttons_count++; 436 437 if (usage->usage_index) 438 prev_usage = &field->usage[usage->usage_index - 1]; 439 440 switch (usage->hid & HID_USAGE_PAGE) { 441 442 case HID_UP_GENDESK: 443 switch (usage->hid) { 444 case HID_GD_X: 445 if (prev_usage && (prev_usage->hid == usage->hid)) { 446 hid_map_usage(hi, usage, bit, max, 447 EV_ABS, ABS_MT_TOOL_X); 448 set_abs(hi->input, ABS_MT_TOOL_X, field, 449 cls->sn_move); 450 } else { 451 hid_map_usage(hi, usage, bit, max, 452 EV_ABS, ABS_MT_POSITION_X); 453 set_abs(hi->input, ABS_MT_POSITION_X, field, 454 cls->sn_move); 455 } 456 457 mt_store_field(usage, td, hi); 458 return 1; 459 case HID_GD_Y: 460 if (prev_usage && (prev_usage->hid == usage->hid)) { 461 hid_map_usage(hi, usage, bit, max, 462 EV_ABS, ABS_MT_TOOL_Y); 463 set_abs(hi->input, ABS_MT_TOOL_Y, field, 464 cls->sn_move); 465 } else { 466 hid_map_usage(hi, usage, bit, max, 467 EV_ABS, ABS_MT_POSITION_Y); 468 set_abs(hi->input, ABS_MT_POSITION_Y, field, 469 cls->sn_move); 470 } 471 472 mt_store_field(usage, td, hi); 473 return 1; 474 } 475 return 0; 476 477 case HID_UP_DIGITIZER: 478 switch (usage->hid) { 479 case HID_DG_INRANGE: 480 if (cls->quirks & MT_QUIRK_HOVERING) { 481 hid_map_usage(hi, usage, bit, max, 482 EV_ABS, ABS_MT_DISTANCE); 483 input_set_abs_params(hi->input, 484 ABS_MT_DISTANCE, 0, 1, 0, 0); 485 } 486 mt_store_field(usage, td, hi); 487 return 1; 488 case HID_DG_CONFIDENCE: 489 mt_store_field(usage, td, hi); 490 return 1; 491 case HID_DG_TIPSWITCH: 492 hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH); 493 input_set_capability(hi->input, EV_KEY, BTN_TOUCH); 494 mt_store_field(usage, td, hi); 495 return 1; 496 case HID_DG_CONTACTID: 497 mt_store_field(usage, td, hi); 498 td->touches_by_report++; 499 td->mt_report_id = field->report->id; 500 return 1; 501 case HID_DG_WIDTH: 502 hid_map_usage(hi, usage, bit, max, 503 EV_ABS, ABS_MT_TOUCH_MAJOR); 504 if (!(cls->quirks & MT_QUIRK_NO_AREA)) 505 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field, 506 cls->sn_width); 507 mt_store_field(usage, td, hi); 508 return 1; 509 case HID_DG_HEIGHT: 510 hid_map_usage(hi, usage, bit, max, 511 EV_ABS, ABS_MT_TOUCH_MINOR); 512 if (!(cls->quirks & MT_QUIRK_NO_AREA)) { 513 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field, 514 cls->sn_height); 515 input_set_abs_params(hi->input, 516 ABS_MT_ORIENTATION, 0, 1, 0, 0); 517 } 518 mt_store_field(usage, td, hi); 519 return 1; 520 case HID_DG_TIPPRESSURE: 521 hid_map_usage(hi, usage, bit, max, 522 EV_ABS, ABS_MT_PRESSURE); 523 set_abs(hi->input, ABS_MT_PRESSURE, field, 524 cls->sn_pressure); 525 mt_store_field(usage, td, hi); 526 return 1; 527 case HID_DG_CONTACTCOUNT: 528 /* Ignore if indexes are out of bounds. */ 529 if (field->index >= field->report->maxfield || 530 usage->usage_index >= field->report_count) 531 return 1; 532 td->cc_index = field->index; 533 td->cc_value_index = usage->usage_index; 534 return 1; 535 case HID_DG_CONTACTMAX: 536 /* we don't set td->last_slot_field as contactcount and 537 * contact max are global to the report */ 538 return -1; 539 case HID_DG_TOUCH: 540 /* Legacy devices use TIPSWITCH and not TOUCH. 541 * Let's just ignore this field. */ 542 return -1; 543 } 544 /* let hid-input decide for the others */ 545 return 0; 546 547 case HID_UP_BUTTON: 548 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE); 549 hid_map_usage(hi, usage, bit, max, EV_KEY, code); 550 input_set_capability(hi->input, EV_KEY, code); 551 return 1; 552 553 case 0xff000000: 554 /* we do not want to map these: no input-oriented meaning */ 555 return -1; 556 } 557 558 return 0; 559 } 560 561 static int mt_touch_input_mapped(struct hid_device *hdev, struct hid_input *hi, 562 struct hid_field *field, struct hid_usage *usage, 563 unsigned long **bit, int *max) 564 { 565 if (usage->type == EV_KEY || usage->type == EV_ABS) 566 set_bit(usage->type, hi->input->evbit); 567 568 return -1; 569 } 570 571 static int mt_compute_slot(struct mt_device *td, struct input_dev *input) 572 { 573 __s32 quirks = td->mtclass.quirks; 574 575 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID) 576 return td->curdata.contactid; 577 578 if (quirks & MT_QUIRK_CYPRESS) 579 return cypress_compute_slot(td); 580 581 if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER) 582 return td->num_received; 583 584 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE) 585 return td->curdata.contactid - 1; 586 587 return input_mt_get_slot_by_key(input, td->curdata.contactid); 588 } 589 590 /* 591 * this function is called when a whole contact has been processed, 592 * so that it can assign it to a slot and store the data there 593 */ 594 static void mt_complete_slot(struct mt_device *td, struct input_dev *input) 595 { 596 if ((td->mtclass.quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) && 597 td->num_received >= td->num_expected) 598 return; 599 600 if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) { 601 int slotnum = mt_compute_slot(td, input); 602 struct mt_slot *s = &td->curdata; 603 struct input_mt *mt = input->mt; 604 605 if (slotnum < 0 || slotnum >= td->maxcontacts) 606 return; 607 608 if ((td->mtclass.quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) { 609 struct input_mt_slot *slot = &mt->slots[slotnum]; 610 if (input_mt_is_active(slot) && 611 input_mt_is_used(mt, slot)) 612 return; 613 } 614 615 input_mt_slot(input, slotnum); 616 input_mt_report_slot_state(input, MT_TOOL_FINGER, 617 s->touch_state || s->inrange_state); 618 if (s->touch_state || s->inrange_state) { 619 /* this finger is in proximity of the sensor */ 620 int wide = (s->w > s->h); 621 /* divided by two to match visual scale of touch */ 622 int major = max(s->w, s->h) >> 1; 623 int minor = min(s->w, s->h) >> 1; 624 625 input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x); 626 input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y); 627 input_event(input, EV_ABS, ABS_MT_TOOL_X, s->cx); 628 input_event(input, EV_ABS, ABS_MT_TOOL_Y, s->cy); 629 input_event(input, EV_ABS, ABS_MT_DISTANCE, 630 !s->touch_state); 631 input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide); 632 input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p); 633 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major); 634 input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor); 635 } 636 } 637 638 td->num_received++; 639 } 640 641 /* 642 * this function is called when a whole packet has been received and processed, 643 * so that it can decide what to send to the input layer. 644 */ 645 static void mt_sync_frame(struct mt_device *td, struct input_dev *input) 646 { 647 input_mt_sync_frame(input); 648 input_sync(input); 649 td->num_received = 0; 650 } 651 652 static int mt_touch_event(struct hid_device *hid, struct hid_field *field, 653 struct hid_usage *usage, __s32 value) 654 { 655 /* we will handle the hidinput part later, now remains hiddev */ 656 if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event) 657 hid->hiddev_hid_event(hid, field, usage, value); 658 659 return 1; 660 } 661 662 static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field, 663 struct hid_usage *usage, __s32 value) 664 { 665 struct mt_device *td = hid_get_drvdata(hid); 666 __s32 quirks = td->mtclass.quirks; 667 struct input_dev *input = field->hidinput->input; 668 669 if (hid->claimed & HID_CLAIMED_INPUT) { 670 switch (usage->hid) { 671 case HID_DG_INRANGE: 672 if (quirks & MT_QUIRK_VALID_IS_INRANGE) 673 td->curvalid = value; 674 if (quirks & MT_QUIRK_HOVERING) 675 td->curdata.inrange_state = value; 676 break; 677 case HID_DG_TIPSWITCH: 678 if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 679 td->curvalid = value; 680 td->curdata.touch_state = value; 681 break; 682 case HID_DG_CONFIDENCE: 683 if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE) 684 td->curvalid = value; 685 break; 686 case HID_DG_CONTACTID: 687 td->curdata.contactid = value; 688 break; 689 case HID_DG_TIPPRESSURE: 690 td->curdata.p = value; 691 break; 692 case HID_GD_X: 693 if (usage->code == ABS_MT_TOOL_X) 694 td->curdata.cx = value; 695 else 696 td->curdata.x = value; 697 break; 698 case HID_GD_Y: 699 if (usage->code == ABS_MT_TOOL_Y) 700 td->curdata.cy = value; 701 else 702 td->curdata.y = value; 703 break; 704 case HID_DG_WIDTH: 705 td->curdata.w = value; 706 break; 707 case HID_DG_HEIGHT: 708 td->curdata.h = value; 709 break; 710 case HID_DG_CONTACTCOUNT: 711 break; 712 case HID_DG_TOUCH: 713 /* do nothing */ 714 break; 715 716 default: 717 if (usage->type) 718 input_event(input, usage->type, usage->code, 719 value); 720 return; 721 } 722 723 if (usage->usage_index + 1 == field->report_count) { 724 /* we only take into account the last report. */ 725 if (usage->hid == td->last_slot_field) 726 mt_complete_slot(td, field->hidinput->input); 727 } 728 729 } 730 } 731 732 static void mt_touch_report(struct hid_device *hid, struct hid_report *report) 733 { 734 struct mt_device *td = hid_get_drvdata(hid); 735 struct hid_field *field; 736 unsigned count; 737 int r, n; 738 739 /* 740 * Includes multi-packet support where subsequent 741 * packets are sent with zero contactcount. 742 */ 743 if (td->cc_index >= 0) { 744 struct hid_field *field = report->field[td->cc_index]; 745 int value = field->value[td->cc_value_index]; 746 if (value) 747 td->num_expected = value; 748 } 749 750 for (r = 0; r < report->maxfield; r++) { 751 field = report->field[r]; 752 count = field->report_count; 753 754 if (!(HID_MAIN_ITEM_VARIABLE & field->flags)) 755 continue; 756 757 for (n = 0; n < count; n++) 758 mt_process_mt_event(hid, field, &field->usage[n], 759 field->value[n]); 760 } 761 762 if (td->num_received >= td->num_expected) 763 mt_sync_frame(td, report->field[0]->hidinput->input); 764 } 765 766 static int mt_touch_input_configured(struct hid_device *hdev, 767 struct hid_input *hi) 768 { 769 struct mt_device *td = hid_get_drvdata(hdev); 770 struct mt_class *cls = &td->mtclass; 771 struct input_dev *input = hi->input; 772 int ret; 773 774 if (!td->maxcontacts) 775 td->maxcontacts = MT_DEFAULT_MAXCONTACT; 776 777 mt_post_parse(td); 778 if (td->serial_maybe) 779 mt_post_parse_default_settings(td); 780 781 if (cls->is_indirect) 782 td->mt_flags |= INPUT_MT_POINTER; 783 784 if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 785 td->mt_flags |= INPUT_MT_DROP_UNUSED; 786 787 /* check for clickpads */ 788 if ((td->mt_flags & INPUT_MT_POINTER) && (td->buttons_count == 1)) 789 td->is_buttonpad = true; 790 791 if (td->is_buttonpad) 792 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); 793 794 ret = input_mt_init_slots(input, td->maxcontacts, td->mt_flags); 795 if (ret) 796 return ret; 797 798 td->mt_flags = 0; 799 return 0; 800 } 801 802 static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, 803 struct hid_field *field, struct hid_usage *usage, 804 unsigned long **bit, int *max) 805 { 806 struct mt_device *td = hid_get_drvdata(hdev); 807 808 /* 809 * If mtclass.export_all_inputs is not set, only map fields from 810 * TouchScreen or TouchPad collections. We need to ignore fields 811 * that belong to other collections such as Mouse that might have 812 * the same GenericDesktop usages. 813 */ 814 if (!td->mtclass.export_all_inputs && 815 field->application != HID_DG_TOUCHSCREEN && 816 field->application != HID_DG_PEN && 817 field->application != HID_DG_TOUCHPAD) 818 return -1; 819 820 /* 821 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 822 * for the stylus. 823 * The check for mt_report_id ensures we don't process 824 * HID_DG_CONTACTCOUNT from the pen report as it is outside the physical 825 * collection, but within the report ID. 826 */ 827 if (field->physical == HID_DG_STYLUS) 828 return 0; 829 else if ((field->physical == 0) && 830 (field->report->id != td->mt_report_id) && 831 (td->mt_report_id != -1)) 832 return 0; 833 834 if (field->application == HID_DG_TOUCHSCREEN || 835 field->application == HID_DG_TOUCHPAD) 836 return mt_touch_input_mapping(hdev, hi, field, usage, bit, max); 837 838 /* let hid-core decide for the others */ 839 return 0; 840 } 841 842 static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi, 843 struct hid_field *field, struct hid_usage *usage, 844 unsigned long **bit, int *max) 845 { 846 /* 847 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 848 * for the stylus. 849 */ 850 if (field->physical == HID_DG_STYLUS) 851 return 0; 852 853 if (field->application == HID_DG_TOUCHSCREEN || 854 field->application == HID_DG_TOUCHPAD) 855 return mt_touch_input_mapped(hdev, hi, field, usage, bit, max); 856 857 /* let hid-core decide for the others */ 858 return 0; 859 } 860 861 static int mt_event(struct hid_device *hid, struct hid_field *field, 862 struct hid_usage *usage, __s32 value) 863 { 864 struct mt_device *td = hid_get_drvdata(hid); 865 866 if (field->report->id == td->mt_report_id) 867 return mt_touch_event(hid, field, usage, value); 868 869 return 0; 870 } 871 872 static void mt_report(struct hid_device *hid, struct hid_report *report) 873 { 874 struct mt_device *td = hid_get_drvdata(hid); 875 struct hid_field *field = report->field[0]; 876 877 if (!(hid->claimed & HID_CLAIMED_INPUT)) 878 return; 879 880 if (report->id == td->mt_report_id) 881 return mt_touch_report(hid, report); 882 883 if (field && field->hidinput && field->hidinput->input) 884 input_sync(field->hidinput->input); 885 } 886 887 static void mt_set_input_mode(struct hid_device *hdev) 888 { 889 struct mt_device *td = hid_get_drvdata(hdev); 890 struct hid_report *r; 891 struct hid_report_enum *re; 892 struct mt_class *cls = &td->mtclass; 893 char *buf; 894 int report_len; 895 896 if (td->inputmode < 0) 897 return; 898 899 re = &(hdev->report_enum[HID_FEATURE_REPORT]); 900 r = re->report_id_hash[td->inputmode]; 901 if (r) { 902 if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) { 903 report_len = hid_report_len(r); 904 buf = hid_alloc_report_buf(r, GFP_KERNEL); 905 if (!buf) { 906 hid_err(hdev, "failed to allocate buffer for report\n"); 907 return; 908 } 909 hid_hw_raw_request(hdev, r->id, buf, report_len, 910 HID_FEATURE_REPORT, 911 HID_REQ_GET_REPORT); 912 kfree(buf); 913 } 914 r->field[0]->value[td->inputmode_index] = td->inputmode_value; 915 hid_hw_request(hdev, r, HID_REQ_SET_REPORT); 916 } 917 } 918 919 static void mt_set_maxcontacts(struct hid_device *hdev) 920 { 921 struct mt_device *td = hid_get_drvdata(hdev); 922 struct hid_report *r; 923 struct hid_report_enum *re; 924 int fieldmax, max; 925 926 if (td->maxcontact_report_id < 0) 927 return; 928 929 if (!td->mtclass.maxcontacts) 930 return; 931 932 re = &hdev->report_enum[HID_FEATURE_REPORT]; 933 r = re->report_id_hash[td->maxcontact_report_id]; 934 if (r) { 935 max = td->mtclass.maxcontacts; 936 fieldmax = r->field[0]->logical_maximum; 937 max = min(fieldmax, max); 938 if (r->field[0]->value[0] != max) { 939 r->field[0]->value[0] = max; 940 hid_hw_request(hdev, r, HID_REQ_SET_REPORT); 941 } 942 } 943 } 944 945 static void mt_post_parse_default_settings(struct mt_device *td) 946 { 947 __s32 quirks = td->mtclass.quirks; 948 949 /* unknown serial device needs special quirks */ 950 if (td->touches_by_report == 1) { 951 quirks |= MT_QUIRK_ALWAYS_VALID; 952 quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP; 953 quirks &= ~MT_QUIRK_VALID_IS_INRANGE; 954 quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE; 955 quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 956 } 957 958 td->mtclass.quirks = quirks; 959 } 960 961 static void mt_post_parse(struct mt_device *td) 962 { 963 struct mt_fields *f = td->fields; 964 struct mt_class *cls = &td->mtclass; 965 966 if (td->touches_by_report > 0) { 967 int field_count_per_touch = f->length / td->touches_by_report; 968 td->last_slot_field = f->usages[field_count_per_touch - 1]; 969 } 970 971 if (td->cc_index < 0) 972 cls->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 973 } 974 975 static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi) 976 { 977 struct mt_device *td = hid_get_drvdata(hdev); 978 char *name; 979 const char *suffix = NULL; 980 struct hid_field *field = hi->report->field[0]; 981 int ret; 982 983 if (hi->report->id == td->mt_report_id) { 984 ret = mt_touch_input_configured(hdev, hi); 985 if (ret) 986 return ret; 987 } 988 989 /* 990 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN" 991 * for the stylus. Check this first, and then rely on the application 992 * field. 993 */ 994 if (hi->report->field[0]->physical == HID_DG_STYLUS) { 995 suffix = "Pen"; 996 /* force BTN_STYLUS to allow tablet matching in udev */ 997 __set_bit(BTN_STYLUS, hi->input->keybit); 998 } else { 999 switch (field->application) { 1000 case HID_GD_KEYBOARD: 1001 suffix = "Keyboard"; 1002 break; 1003 case HID_GD_KEYPAD: 1004 suffix = "Keypad"; 1005 break; 1006 case HID_GD_MOUSE: 1007 suffix = "Mouse"; 1008 break; 1009 case HID_DG_STYLUS: 1010 suffix = "Pen"; 1011 /* force BTN_STYLUS to allow tablet matching in udev */ 1012 __set_bit(BTN_STYLUS, hi->input->keybit); 1013 break; 1014 case HID_DG_TOUCHSCREEN: 1015 /* we do not set suffix = "Touchscreen" */ 1016 break; 1017 case HID_DG_TOUCHPAD: 1018 suffix = "Touchpad"; 1019 break; 1020 case HID_GD_SYSTEM_CONTROL: 1021 suffix = "System Control"; 1022 break; 1023 case HID_CP_CONSUMER_CONTROL: 1024 suffix = "Consumer Control"; 1025 break; 1026 default: 1027 suffix = "UNKNOWN"; 1028 break; 1029 } 1030 } 1031 1032 if (suffix) { 1033 name = devm_kzalloc(&hi->input->dev, 1034 strlen(hdev->name) + strlen(suffix) + 2, 1035 GFP_KERNEL); 1036 if (name) { 1037 sprintf(name, "%s %s", hdev->name, suffix); 1038 hi->input->name = name; 1039 } 1040 } 1041 1042 return 0; 1043 } 1044 1045 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) 1046 { 1047 int ret, i; 1048 struct mt_device *td; 1049 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */ 1050 1051 for (i = 0; mt_classes[i].name ; i++) { 1052 if (id->driver_data == mt_classes[i].name) { 1053 mtclass = &(mt_classes[i]); 1054 break; 1055 } 1056 } 1057 1058 /* This allows the driver to correctly support devices 1059 * that emit events over several HID messages. 1060 */ 1061 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; 1062 1063 /* 1064 * This allows the driver to handle different input sensors 1065 * that emits events through different reports on the same HID 1066 * device. 1067 */ 1068 hdev->quirks |= HID_QUIRK_MULTI_INPUT; 1069 hdev->quirks |= HID_QUIRK_NO_EMPTY_INPUT; 1070 1071 /* 1072 * Handle special quirks for Windows 8 certified devices. 1073 */ 1074 if (id->group == HID_GROUP_MULTITOUCH_WIN_8) 1075 /* 1076 * Some multitouch screens do not like to be polled for input 1077 * reports. Fortunately, the Win8 spec says that all touches 1078 * should be sent during each report, making the initialization 1079 * of input reports unnecessary. 1080 * 1081 * In addition some touchpads do not behave well if we read 1082 * all feature reports from them. Instead we prevent 1083 * initial report fetching and then selectively fetch each 1084 * report we are interested in. 1085 */ 1086 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 1087 1088 td = devm_kzalloc(&hdev->dev, sizeof(struct mt_device), GFP_KERNEL); 1089 if (!td) { 1090 dev_err(&hdev->dev, "cannot allocate multitouch data\n"); 1091 return -ENOMEM; 1092 } 1093 td->mtclass = *mtclass; 1094 td->inputmode = -1; 1095 td->maxcontact_report_id = -1; 1096 td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN; 1097 td->cc_index = -1; 1098 td->mt_report_id = -1; 1099 hid_set_drvdata(hdev, td); 1100 1101 td->fields = devm_kzalloc(&hdev->dev, sizeof(struct mt_fields), 1102 GFP_KERNEL); 1103 if (!td->fields) { 1104 dev_err(&hdev->dev, "cannot allocate multitouch fields data\n"); 1105 return -ENOMEM; 1106 } 1107 1108 if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID) 1109 td->serial_maybe = true; 1110 1111 ret = hid_parse(hdev); 1112 if (ret != 0) 1113 return ret; 1114 1115 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1116 if (ret) 1117 return ret; 1118 1119 ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group); 1120 1121 mt_set_maxcontacts(hdev); 1122 mt_set_input_mode(hdev); 1123 1124 /* release .fields memory as it is not used anymore */ 1125 devm_kfree(&hdev->dev, td->fields); 1126 td->fields = NULL; 1127 1128 return 0; 1129 } 1130 1131 #ifdef CONFIG_PM 1132 static int mt_reset_resume(struct hid_device *hdev) 1133 { 1134 mt_set_maxcontacts(hdev); 1135 mt_set_input_mode(hdev); 1136 return 0; 1137 } 1138 1139 static int mt_resume(struct hid_device *hdev) 1140 { 1141 /* Some Elan legacy devices require SET_IDLE to be set on resume. 1142 * It should be safe to send it to other devices too. 1143 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */ 1144 1145 hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE); 1146 1147 return 0; 1148 } 1149 #endif 1150 1151 static void mt_remove(struct hid_device *hdev) 1152 { 1153 sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group); 1154 hid_hw_stop(hdev); 1155 } 1156 1157 /* 1158 * This list contains only: 1159 * - VID/PID of products not working with the default multitouch handling 1160 * - 2 generic rules. 1161 * So there is no point in adding here any device with MT_CLS_DEFAULT. 1162 */ 1163 static const struct hid_device_id mt_devices[] = { 1164 1165 /* 3M panels */ 1166 { .driver_data = MT_CLS_3M, 1167 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1168 USB_DEVICE_ID_3M1968) }, 1169 { .driver_data = MT_CLS_3M, 1170 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1171 USB_DEVICE_ID_3M2256) }, 1172 { .driver_data = MT_CLS_3M, 1173 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1174 USB_DEVICE_ID_3M3266) }, 1175 1176 /* Anton devices */ 1177 { .driver_data = MT_CLS_EXPORT_ALL_INPUTS, 1178 MT_USB_DEVICE(USB_VENDOR_ID_ANTON, 1179 USB_DEVICE_ID_ANTON_TOUCH_PAD) }, 1180 1181 /* Atmel panels */ 1182 { .driver_data = MT_CLS_SERIAL, 1183 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL, 1184 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) }, 1185 1186 /* Baanto multitouch devices */ 1187 { .driver_data = MT_CLS_NSMU, 1188 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO, 1189 USB_DEVICE_ID_BAANTO_MT_190W2) }, 1190 1191 /* Cando panels */ 1192 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 1193 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1194 USB_DEVICE_ID_CANDO_MULTI_TOUCH) }, 1195 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 1196 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1197 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) }, 1198 1199 /* Chunghwa Telecom touch panels */ 1200 { .driver_data = MT_CLS_NSMU, 1201 MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, 1202 USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) }, 1203 1204 /* CJTouch panels */ 1205 { .driver_data = MT_CLS_NSMU, 1206 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH, 1207 USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020) }, 1208 { .driver_data = MT_CLS_NSMU, 1209 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH, 1210 USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040) }, 1211 1212 /* CVTouch panels */ 1213 { .driver_data = MT_CLS_NSMU, 1214 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, 1215 USB_DEVICE_ID_CVTOUCH_SCREEN) }, 1216 1217 /* eGalax devices (resistive) */ 1218 { .driver_data = MT_CLS_EGALAX, 1219 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1220 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) }, 1221 { .driver_data = MT_CLS_EGALAX, 1222 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1223 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) }, 1224 1225 /* eGalax devices (capacitive) */ 1226 { .driver_data = MT_CLS_EGALAX_SERIAL, 1227 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1228 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) }, 1229 { .driver_data = MT_CLS_EGALAX, 1230 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1231 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) }, 1232 { .driver_data = MT_CLS_EGALAX_SERIAL, 1233 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1234 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, 1235 { .driver_data = MT_CLS_EGALAX_SERIAL, 1236 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1237 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) }, 1238 { .driver_data = MT_CLS_EGALAX_SERIAL, 1239 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1240 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) }, 1241 { .driver_data = MT_CLS_EGALAX_SERIAL, 1242 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1243 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) }, 1244 { .driver_data = MT_CLS_EGALAX, 1245 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1246 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) }, 1247 { .driver_data = MT_CLS_EGALAX, 1248 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1249 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) }, 1250 { .driver_data = MT_CLS_EGALAX_SERIAL, 1251 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1252 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) }, 1253 { .driver_data = MT_CLS_EGALAX, 1254 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1255 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) }, 1256 { .driver_data = MT_CLS_EGALAX, 1257 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1258 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) }, 1259 { .driver_data = MT_CLS_EGALAX, 1260 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1261 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) }, 1262 { .driver_data = MT_CLS_EGALAX, 1263 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1264 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) }, 1265 { .driver_data = MT_CLS_EGALAX_SERIAL, 1266 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1267 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) }, 1268 { .driver_data = MT_CLS_EGALAX_SERIAL, 1269 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1270 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) }, 1271 { .driver_data = MT_CLS_EGALAX_SERIAL, 1272 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1273 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) }, 1274 1275 /* Elitegroup panel */ 1276 { .driver_data = MT_CLS_SERIAL, 1277 MT_USB_DEVICE(USB_VENDOR_ID_ELITEGROUP, 1278 USB_DEVICE_ID_ELITEGROUP_05D8) }, 1279 1280 /* Flatfrog Panels */ 1281 { .driver_data = MT_CLS_FLATFROG, 1282 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG, 1283 USB_DEVICE_ID_MULTITOUCH_3200) }, 1284 1285 /* FocalTech Panels */ 1286 { .driver_data = MT_CLS_SERIAL, 1287 MT_USB_DEVICE(USB_VENDOR_ID_CYGNAL, 1288 USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH) }, 1289 1290 /* GeneralTouch panel */ 1291 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS, 1292 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1293 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) }, 1294 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1295 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1296 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) }, 1297 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS, 1298 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1299 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0101) }, 1300 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1301 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1302 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0102) }, 1303 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1304 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1305 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0106) }, 1306 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1307 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1308 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A) }, 1309 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1310 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1311 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100) }, 1312 1313 /* Gametel game controller */ 1314 { .driver_data = MT_CLS_NSMU, 1315 MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL, 1316 USB_DEVICE_ID_GAMETEL_MT_MODE) }, 1317 1318 /* GoodTouch panels */ 1319 { .driver_data = MT_CLS_NSMU, 1320 MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, 1321 USB_DEVICE_ID_GOODTOUCH_000f) }, 1322 1323 /* Hanvon panels */ 1324 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1325 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, 1326 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) }, 1327 1328 /* Ilitek dual touch panel */ 1329 { .driver_data = MT_CLS_NSMU, 1330 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK, 1331 USB_DEVICE_ID_ILITEK_MULTITOUCH) }, 1332 1333 /* MosArt panels */ 1334 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1335 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1336 USB_DEVICE_ID_ASUS_T91MT)}, 1337 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1338 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1339 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) }, 1340 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1341 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX, 1342 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) }, 1343 1344 /* Panasonic panels */ 1345 { .driver_data = MT_CLS_PANASONIC, 1346 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1347 USB_DEVICE_ID_PANABOARD_UBT780) }, 1348 { .driver_data = MT_CLS_PANASONIC, 1349 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1350 USB_DEVICE_ID_PANABOARD_UBT880) }, 1351 1352 /* Novatek Panel */ 1353 { .driver_data = MT_CLS_NSMU, 1354 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK, 1355 USB_DEVICE_ID_NOVATEK_PCT) }, 1356 1357 /* PixArt optical touch screen */ 1358 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1359 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1360 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) }, 1361 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1362 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1363 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) }, 1364 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1365 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1366 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) }, 1367 1368 /* PixCir-based panels */ 1369 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1370 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1371 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) }, 1372 1373 /* Quanta-based panels */ 1374 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1375 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1376 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) }, 1377 1378 /* Stantum panels */ 1379 { .driver_data = MT_CLS_CONFIDENCE, 1380 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, 1381 USB_DEVICE_ID_MTP_STM)}, 1382 1383 /* TopSeed panels */ 1384 { .driver_data = MT_CLS_TOPSEED, 1385 MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, 1386 USB_DEVICE_ID_TOPSEED2_PERIPAD_701) }, 1387 1388 /* Touch International panels */ 1389 { .driver_data = MT_CLS_NSMU, 1390 MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, 1391 USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) }, 1392 1393 /* Unitec panels */ 1394 { .driver_data = MT_CLS_NSMU, 1395 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1396 USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) }, 1397 { .driver_data = MT_CLS_NSMU, 1398 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1399 USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) }, 1400 1401 /* VTL panels */ 1402 { .driver_data = MT_CLS_VTL, 1403 MT_USB_DEVICE(USB_VENDOR_ID_VTL, 1404 USB_DEVICE_ID_VTL_MULTITOUCH_FF3F) }, 1405 1406 /* Wistron panels */ 1407 { .driver_data = MT_CLS_NSMU, 1408 MT_USB_DEVICE(USB_VENDOR_ID_WISTRON, 1409 USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH) }, 1410 1411 /* XAT */ 1412 { .driver_data = MT_CLS_NSMU, 1413 MT_USB_DEVICE(USB_VENDOR_ID_XAT, 1414 USB_DEVICE_ID_XAT_CSR) }, 1415 1416 /* Xiroku */ 1417 { .driver_data = MT_CLS_NSMU, 1418 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1419 USB_DEVICE_ID_XIROKU_SPX) }, 1420 { .driver_data = MT_CLS_NSMU, 1421 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1422 USB_DEVICE_ID_XIROKU_MPX) }, 1423 { .driver_data = MT_CLS_NSMU, 1424 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1425 USB_DEVICE_ID_XIROKU_CSR) }, 1426 { .driver_data = MT_CLS_NSMU, 1427 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1428 USB_DEVICE_ID_XIROKU_SPX1) }, 1429 { .driver_data = MT_CLS_NSMU, 1430 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1431 USB_DEVICE_ID_XIROKU_MPX1) }, 1432 { .driver_data = MT_CLS_NSMU, 1433 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1434 USB_DEVICE_ID_XIROKU_CSR1) }, 1435 { .driver_data = MT_CLS_NSMU, 1436 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1437 USB_DEVICE_ID_XIROKU_SPX2) }, 1438 { .driver_data = MT_CLS_NSMU, 1439 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1440 USB_DEVICE_ID_XIROKU_MPX2) }, 1441 { .driver_data = MT_CLS_NSMU, 1442 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1443 USB_DEVICE_ID_XIROKU_CSR2) }, 1444 1445 /* Generic MT device */ 1446 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) }, 1447 1448 /* Generic Win 8 certified MT device */ 1449 { .driver_data = MT_CLS_WIN_8, 1450 HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8, 1451 HID_ANY_ID, HID_ANY_ID) }, 1452 { } 1453 }; 1454 MODULE_DEVICE_TABLE(hid, mt_devices); 1455 1456 static const struct hid_usage_id mt_grabbed_usages[] = { 1457 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID }, 1458 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1} 1459 }; 1460 1461 static struct hid_driver mt_driver = { 1462 .name = "hid-multitouch", 1463 .id_table = mt_devices, 1464 .probe = mt_probe, 1465 .remove = mt_remove, 1466 .input_mapping = mt_input_mapping, 1467 .input_mapped = mt_input_mapped, 1468 .input_configured = mt_input_configured, 1469 .feature_mapping = mt_feature_mapping, 1470 .usage_table = mt_grabbed_usages, 1471 .event = mt_event, 1472 .report = mt_report, 1473 #ifdef CONFIG_PM 1474 .reset_resume = mt_reset_resume, 1475 .resume = mt_resume, 1476 #endif 1477 }; 1478 module_hid_driver(mt_driver); 1479