1 /* 2 * HID driver for multitouch panels 3 * 4 * Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr> 5 * Copyright (c) 2010-2012 Benjamin Tissoires <benjamin.tissoires@gmail.com> 6 * Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France 7 * 8 * This code is partly based on hid-egalax.c: 9 * 10 * Copyright (c) 2010 Stephane Chatty <chatty@enac.fr> 11 * Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se> 12 * Copyright (c) 2010 Canonical, Ltd. 13 * 14 * This code is partly based on hid-3m-pct.c: 15 * 16 * Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr> 17 * Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se> 18 * Copyright (c) 2010 Canonical, Ltd. 19 * 20 */ 21 22 /* 23 * This program is free software; you can redistribute it and/or modify it 24 * under the terms of the GNU General Public License as published by the Free 25 * Software Foundation; either version 2 of the License, or (at your option) 26 * any later version. 27 */ 28 29 #include <linux/device.h> 30 #include <linux/hid.h> 31 #include <linux/module.h> 32 #include <linux/slab.h> 33 #include <linux/usb.h> 34 #include <linux/input/mt.h> 35 #include "usbhid/usbhid.h" 36 37 38 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>"); 39 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>"); 40 MODULE_DESCRIPTION("HID multitouch panels"); 41 MODULE_LICENSE("GPL"); 42 43 #include "hid-ids.h" 44 45 /* quirks to control the device */ 46 #define MT_QUIRK_NOT_SEEN_MEANS_UP (1 << 0) 47 #define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1) 48 #define MT_QUIRK_CYPRESS (1 << 2) 49 #define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3) 50 #define MT_QUIRK_ALWAYS_VALID (1 << 4) 51 #define MT_QUIRK_VALID_IS_INRANGE (1 << 5) 52 #define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 6) 53 #define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 8) 54 #define MT_QUIRK_NO_AREA (1 << 9) 55 #define MT_QUIRK_IGNORE_DUPLICATES (1 << 10) 56 #define MT_QUIRK_HOVERING (1 << 11) 57 #define MT_QUIRK_CONTACT_CNT_ACCURATE (1 << 12) 58 59 struct mt_slot { 60 __s32 x, y, cx, cy, p, w, h; 61 __s32 contactid; /* the device ContactID assigned to this slot */ 62 bool touch_state; /* is the touch valid? */ 63 bool inrange_state; /* is the finger in proximity of the sensor? */ 64 }; 65 66 struct mt_class { 67 __s32 name; /* MT_CLS */ 68 __s32 quirks; 69 __s32 sn_move; /* Signal/noise ratio for move events */ 70 __s32 sn_width; /* Signal/noise ratio for width events */ 71 __s32 sn_height; /* Signal/noise ratio for height events */ 72 __s32 sn_pressure; /* Signal/noise ratio for pressure events */ 73 __u8 maxcontacts; 74 bool is_indirect; /* true for touchpads */ 75 }; 76 77 struct mt_fields { 78 unsigned usages[HID_MAX_FIELDS]; 79 unsigned int length; 80 }; 81 82 struct mt_device { 83 struct mt_slot curdata; /* placeholder of incoming data */ 84 struct mt_class mtclass; /* our mt device class */ 85 struct mt_fields *fields; /* temporary placeholder for storing the 86 multitouch fields */ 87 int cc_index; /* contact count field index in the report */ 88 int cc_value_index; /* contact count value index in the field */ 89 unsigned last_field_index; /* last field index of the report */ 90 unsigned last_slot_field; /* the last field of a slot */ 91 unsigned mt_report_id; /* the report ID of the multitouch device */ 92 __s8 inputmode; /* InputMode HID feature, -1 if non-existent */ 93 __s8 inputmode_index; /* InputMode HID feature index in the report */ 94 __s8 maxcontact_report_id; /* Maximum Contact Number HID feature, 95 -1 if non-existent */ 96 __u8 num_received; /* how many contacts we received */ 97 __u8 num_expected; /* expected last contact index */ 98 __u8 maxcontacts; 99 __u8 touches_by_report; /* how many touches are present in one report: 100 * 1 means we should use a serial protocol 101 * > 1 means hybrid (multitouch) protocol */ 102 bool serial_maybe; /* need to check for serial protocol */ 103 bool curvalid; /* is the current contact valid? */ 104 unsigned mt_flags; /* flags to pass to input-mt */ 105 }; 106 107 /* classes of device behavior */ 108 #define MT_CLS_DEFAULT 0x0001 109 110 #define MT_CLS_SERIAL 0x0002 111 #define MT_CLS_CONFIDENCE 0x0003 112 #define MT_CLS_CONFIDENCE_CONTACT_ID 0x0004 113 #define MT_CLS_CONFIDENCE_MINUS_ONE 0x0005 114 #define MT_CLS_DUAL_INRANGE_CONTACTID 0x0006 115 #define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0007 116 #define MT_CLS_DUAL_NSMU_CONTACTID 0x0008 117 #define MT_CLS_INRANGE_CONTACTNUMBER 0x0009 118 #define MT_CLS_NSMU 0x000a 119 #define MT_CLS_DUAL_CONTACT_NUMBER 0x0010 120 #define MT_CLS_DUAL_CONTACT_ID 0x0011 121 122 /* vendor specific classes */ 123 #define MT_CLS_3M 0x0101 124 #define MT_CLS_CYPRESS 0x0102 125 #define MT_CLS_EGALAX 0x0103 126 #define MT_CLS_EGALAX_SERIAL 0x0104 127 #define MT_CLS_TOPSEED 0x0105 128 #define MT_CLS_PANASONIC 0x0106 129 #define MT_CLS_FLATFROG 0x0107 130 #define MT_CLS_GENERALTOUCH_TWOFINGERS 0x0108 131 #define MT_CLS_GENERALTOUCH_PWT_TENFINGERS 0x0109 132 133 #define MT_DEFAULT_MAXCONTACT 10 134 #define MT_MAX_MAXCONTACT 250 135 136 #define MT_USB_DEVICE(v, p) HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p) 137 #define MT_BT_DEVICE(v, p) HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p) 138 139 /* 140 * these device-dependent functions determine what slot corresponds 141 * to a valid contact that was just read. 142 */ 143 144 static int cypress_compute_slot(struct mt_device *td) 145 { 146 if (td->curdata.contactid != 0 || td->num_received == 0) 147 return td->curdata.contactid; 148 else 149 return -1; 150 } 151 152 static struct mt_class mt_classes[] = { 153 { .name = MT_CLS_DEFAULT, 154 .quirks = MT_QUIRK_ALWAYS_VALID | 155 MT_QUIRK_CONTACT_CNT_ACCURATE }, 156 { .name = MT_CLS_NSMU, 157 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP }, 158 { .name = MT_CLS_SERIAL, 159 .quirks = MT_QUIRK_ALWAYS_VALID}, 160 { .name = MT_CLS_CONFIDENCE, 161 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE }, 162 { .name = MT_CLS_CONFIDENCE_CONTACT_ID, 163 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 164 MT_QUIRK_SLOT_IS_CONTACTID }, 165 { .name = MT_CLS_CONFIDENCE_MINUS_ONE, 166 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 167 MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE }, 168 { .name = MT_CLS_DUAL_INRANGE_CONTACTID, 169 .quirks = MT_QUIRK_VALID_IS_INRANGE | 170 MT_QUIRK_SLOT_IS_CONTACTID, 171 .maxcontacts = 2 }, 172 { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 173 .quirks = MT_QUIRK_VALID_IS_INRANGE | 174 MT_QUIRK_SLOT_IS_CONTACTNUMBER, 175 .maxcontacts = 2 }, 176 { .name = MT_CLS_DUAL_NSMU_CONTACTID, 177 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 178 MT_QUIRK_SLOT_IS_CONTACTID, 179 .maxcontacts = 2 }, 180 { .name = MT_CLS_INRANGE_CONTACTNUMBER, 181 .quirks = MT_QUIRK_VALID_IS_INRANGE | 182 MT_QUIRK_SLOT_IS_CONTACTNUMBER }, 183 { .name = MT_CLS_DUAL_CONTACT_NUMBER, 184 .quirks = MT_QUIRK_ALWAYS_VALID | 185 MT_QUIRK_CONTACT_CNT_ACCURATE | 186 MT_QUIRK_SLOT_IS_CONTACTNUMBER, 187 .maxcontacts = 2 }, 188 { .name = MT_CLS_DUAL_CONTACT_ID, 189 .quirks = MT_QUIRK_ALWAYS_VALID | 190 MT_QUIRK_CONTACT_CNT_ACCURATE | 191 MT_QUIRK_SLOT_IS_CONTACTID, 192 .maxcontacts = 2 }, 193 194 /* 195 * vendor specific classes 196 */ 197 { .name = MT_CLS_3M, 198 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE | 199 MT_QUIRK_SLOT_IS_CONTACTID, 200 .sn_move = 2048, 201 .sn_width = 128, 202 .sn_height = 128, 203 .maxcontacts = 60, 204 }, 205 { .name = MT_CLS_CYPRESS, 206 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 207 MT_QUIRK_CYPRESS, 208 .maxcontacts = 10 }, 209 { .name = MT_CLS_EGALAX, 210 .quirks = MT_QUIRK_SLOT_IS_CONTACTID | 211 MT_QUIRK_VALID_IS_INRANGE, 212 .sn_move = 4096, 213 .sn_pressure = 32, 214 }, 215 { .name = MT_CLS_EGALAX_SERIAL, 216 .quirks = MT_QUIRK_SLOT_IS_CONTACTID | 217 MT_QUIRK_ALWAYS_VALID, 218 .sn_move = 4096, 219 .sn_pressure = 32, 220 }, 221 { .name = MT_CLS_TOPSEED, 222 .quirks = MT_QUIRK_ALWAYS_VALID, 223 .is_indirect = true, 224 .maxcontacts = 2, 225 }, 226 { .name = MT_CLS_PANASONIC, 227 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP, 228 .maxcontacts = 4 }, 229 { .name = MT_CLS_GENERALTOUCH_TWOFINGERS, 230 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 231 MT_QUIRK_VALID_IS_INRANGE | 232 MT_QUIRK_SLOT_IS_CONTACTNUMBER, 233 .maxcontacts = 2 234 }, 235 { .name = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 236 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 237 MT_QUIRK_SLOT_IS_CONTACTNUMBER 238 }, 239 240 { .name = MT_CLS_FLATFROG, 241 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP | 242 MT_QUIRK_NO_AREA, 243 .sn_move = 2048, 244 .maxcontacts = 40, 245 }, 246 { } 247 }; 248 249 static ssize_t mt_show_quirks(struct device *dev, 250 struct device_attribute *attr, 251 char *buf) 252 { 253 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 254 struct mt_device *td = hid_get_drvdata(hdev); 255 256 return sprintf(buf, "%u\n", td->mtclass.quirks); 257 } 258 259 static ssize_t mt_set_quirks(struct device *dev, 260 struct device_attribute *attr, 261 const char *buf, size_t count) 262 { 263 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 264 struct mt_device *td = hid_get_drvdata(hdev); 265 266 unsigned long val; 267 268 if (kstrtoul(buf, 0, &val)) 269 return -EINVAL; 270 271 td->mtclass.quirks = val; 272 273 if (td->cc_index < 0) 274 td->mtclass.quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 275 276 return count; 277 } 278 279 static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks); 280 281 static struct attribute *sysfs_attrs[] = { 282 &dev_attr_quirks.attr, 283 NULL 284 }; 285 286 static struct attribute_group mt_attribute_group = { 287 .attrs = sysfs_attrs 288 }; 289 290 static void mt_feature_mapping(struct hid_device *hdev, 291 struct hid_field *field, struct hid_usage *usage) 292 { 293 struct mt_device *td = hid_get_drvdata(hdev); 294 int i; 295 296 switch (usage->hid) { 297 case HID_DG_INPUTMODE: 298 td->inputmode = field->report->id; 299 td->inputmode_index = 0; /* has to be updated below */ 300 301 for (i=0; i < field->maxusage; i++) { 302 if (field->usage[i].hid == usage->hid) { 303 td->inputmode_index = i; 304 break; 305 } 306 } 307 308 break; 309 case HID_DG_CONTACTMAX: 310 td->maxcontact_report_id = field->report->id; 311 td->maxcontacts = field->value[0]; 312 if (!td->maxcontacts && 313 field->logical_maximum <= MT_MAX_MAXCONTACT) 314 td->maxcontacts = field->logical_maximum; 315 if (td->mtclass.maxcontacts) 316 /* check if the maxcontacts is given by the class */ 317 td->maxcontacts = td->mtclass.maxcontacts; 318 319 break; 320 case 0xff0000c5: 321 if (field->report_count == 256 && field->report_size == 8) { 322 /* Win 8 devices need special quirks */ 323 __s32 *quirks = &td->mtclass.quirks; 324 *quirks |= MT_QUIRK_ALWAYS_VALID; 325 *quirks |= MT_QUIRK_IGNORE_DUPLICATES; 326 *quirks |= MT_QUIRK_HOVERING; 327 *quirks |= MT_QUIRK_CONTACT_CNT_ACCURATE; 328 *quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP; 329 *quirks &= ~MT_QUIRK_VALID_IS_INRANGE; 330 *quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE; 331 } 332 break; 333 } 334 } 335 336 static void set_abs(struct input_dev *input, unsigned int code, 337 struct hid_field *field, int snratio) 338 { 339 int fmin = field->logical_minimum; 340 int fmax = field->logical_maximum; 341 int fuzz = snratio ? (fmax - fmin) / snratio : 0; 342 input_set_abs_params(input, code, fmin, fmax, fuzz, 0); 343 input_abs_set_res(input, code, hidinput_calc_abs_res(field, code)); 344 } 345 346 static void mt_store_field(struct hid_usage *usage, struct mt_device *td, 347 struct hid_input *hi) 348 { 349 struct mt_fields *f = td->fields; 350 351 if (f->length >= HID_MAX_FIELDS) 352 return; 353 354 f->usages[f->length++] = usage->hid; 355 } 356 357 static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, 358 struct hid_field *field, struct hid_usage *usage, 359 unsigned long **bit, int *max) 360 { 361 struct mt_device *td = hid_get_drvdata(hdev); 362 struct mt_class *cls = &td->mtclass; 363 int code; 364 struct hid_usage *prev_usage = NULL; 365 366 /* Only map fields from TouchScreen or TouchPad collections. 367 * We need to ignore fields that belong to other collections 368 * such as Mouse that might have the same GenericDesktop usages. */ 369 if (field->application == HID_DG_TOUCHSCREEN) 370 td->mt_flags |= INPUT_MT_DIRECT; 371 else if (field->application != HID_DG_TOUCHPAD) 372 return 0; 373 374 /* 375 * Model touchscreens providing buttons as touchpads. 376 */ 377 if (field->application == HID_DG_TOUCHPAD || 378 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) 379 td->mt_flags |= INPUT_MT_POINTER; 380 381 /* eGalax devices provide a Digitizer.Stylus input which overrides 382 * the correct Digitizers.Finger X/Y ranges. 383 * Let's just ignore this input. */ 384 if (field->physical == HID_DG_STYLUS) 385 return -1; 386 387 if (usage->usage_index) 388 prev_usage = &field->usage[usage->usage_index - 1]; 389 390 switch (usage->hid & HID_USAGE_PAGE) { 391 392 case HID_UP_GENDESK: 393 switch (usage->hid) { 394 case HID_GD_X: 395 if (prev_usage && (prev_usage->hid == usage->hid)) { 396 hid_map_usage(hi, usage, bit, max, 397 EV_ABS, ABS_MT_TOOL_X); 398 set_abs(hi->input, ABS_MT_TOOL_X, field, 399 cls->sn_move); 400 } else { 401 hid_map_usage(hi, usage, bit, max, 402 EV_ABS, ABS_MT_POSITION_X); 403 set_abs(hi->input, ABS_MT_POSITION_X, field, 404 cls->sn_move); 405 } 406 407 mt_store_field(usage, td, hi); 408 td->last_field_index = field->index; 409 return 1; 410 case HID_GD_Y: 411 if (prev_usage && (prev_usage->hid == usage->hid)) { 412 hid_map_usage(hi, usage, bit, max, 413 EV_ABS, ABS_MT_TOOL_Y); 414 set_abs(hi->input, ABS_MT_TOOL_Y, field, 415 cls->sn_move); 416 } else { 417 hid_map_usage(hi, usage, bit, max, 418 EV_ABS, ABS_MT_POSITION_Y); 419 set_abs(hi->input, ABS_MT_POSITION_Y, field, 420 cls->sn_move); 421 } 422 423 mt_store_field(usage, td, hi); 424 td->last_field_index = field->index; 425 return 1; 426 } 427 return 0; 428 429 case HID_UP_DIGITIZER: 430 switch (usage->hid) { 431 case HID_DG_INRANGE: 432 if (cls->quirks & MT_QUIRK_HOVERING) { 433 hid_map_usage(hi, usage, bit, max, 434 EV_ABS, ABS_MT_DISTANCE); 435 input_set_abs_params(hi->input, 436 ABS_MT_DISTANCE, 0, 1, 0, 0); 437 } 438 mt_store_field(usage, td, hi); 439 td->last_field_index = field->index; 440 return 1; 441 case HID_DG_CONFIDENCE: 442 mt_store_field(usage, td, hi); 443 td->last_field_index = field->index; 444 return 1; 445 case HID_DG_TIPSWITCH: 446 hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH); 447 input_set_capability(hi->input, EV_KEY, BTN_TOUCH); 448 mt_store_field(usage, td, hi); 449 td->last_field_index = field->index; 450 return 1; 451 case HID_DG_CONTACTID: 452 mt_store_field(usage, td, hi); 453 td->last_field_index = field->index; 454 td->touches_by_report++; 455 td->mt_report_id = field->report->id; 456 return 1; 457 case HID_DG_WIDTH: 458 hid_map_usage(hi, usage, bit, max, 459 EV_ABS, ABS_MT_TOUCH_MAJOR); 460 if (!(cls->quirks & MT_QUIRK_NO_AREA)) 461 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field, 462 cls->sn_width); 463 mt_store_field(usage, td, hi); 464 td->last_field_index = field->index; 465 return 1; 466 case HID_DG_HEIGHT: 467 hid_map_usage(hi, usage, bit, max, 468 EV_ABS, ABS_MT_TOUCH_MINOR); 469 if (!(cls->quirks & MT_QUIRK_NO_AREA)) { 470 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field, 471 cls->sn_height); 472 input_set_abs_params(hi->input, 473 ABS_MT_ORIENTATION, 0, 1, 0, 0); 474 } 475 mt_store_field(usage, td, hi); 476 td->last_field_index = field->index; 477 return 1; 478 case HID_DG_TIPPRESSURE: 479 hid_map_usage(hi, usage, bit, max, 480 EV_ABS, ABS_MT_PRESSURE); 481 set_abs(hi->input, ABS_MT_PRESSURE, field, 482 cls->sn_pressure); 483 mt_store_field(usage, td, hi); 484 td->last_field_index = field->index; 485 return 1; 486 case HID_DG_CONTACTCOUNT: 487 td->cc_index = field->index; 488 td->cc_value_index = usage->usage_index; 489 td->last_field_index = field->index; 490 return 1; 491 case HID_DG_CONTACTMAX: 492 /* we don't set td->last_slot_field as contactcount and 493 * contact max are global to the report */ 494 td->last_field_index = field->index; 495 return -1; 496 case HID_DG_TOUCH: 497 /* Legacy devices use TIPSWITCH and not TOUCH. 498 * Let's just ignore this field. */ 499 return -1; 500 } 501 /* let hid-input decide for the others */ 502 return 0; 503 504 case HID_UP_BUTTON: 505 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE); 506 hid_map_usage(hi, usage, bit, max, EV_KEY, code); 507 input_set_capability(hi->input, EV_KEY, code); 508 return 1; 509 510 case 0xff000000: 511 /* we do not want to map these: no input-oriented meaning */ 512 return -1; 513 } 514 515 return 0; 516 } 517 518 static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi, 519 struct hid_field *field, struct hid_usage *usage, 520 unsigned long **bit, int *max) 521 { 522 if (usage->type == EV_KEY || usage->type == EV_ABS) 523 set_bit(usage->type, hi->input->evbit); 524 525 return -1; 526 } 527 528 static int mt_compute_slot(struct mt_device *td, struct input_dev *input) 529 { 530 __s32 quirks = td->mtclass.quirks; 531 532 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID) 533 return td->curdata.contactid; 534 535 if (quirks & MT_QUIRK_CYPRESS) 536 return cypress_compute_slot(td); 537 538 if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER) 539 return td->num_received; 540 541 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE) 542 return td->curdata.contactid - 1; 543 544 return input_mt_get_slot_by_key(input, td->curdata.contactid); 545 } 546 547 /* 548 * this function is called when a whole contact has been processed, 549 * so that it can assign it to a slot and store the data there 550 */ 551 static void mt_complete_slot(struct mt_device *td, struct input_dev *input) 552 { 553 if ((td->mtclass.quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) && 554 td->num_received >= td->num_expected) 555 return; 556 557 if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) { 558 int slotnum = mt_compute_slot(td, input); 559 struct mt_slot *s = &td->curdata; 560 struct input_mt *mt = input->mt; 561 562 if (slotnum < 0 || slotnum >= td->maxcontacts) 563 return; 564 565 if ((td->mtclass.quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) { 566 struct input_mt_slot *slot = &mt->slots[slotnum]; 567 if (input_mt_is_active(slot) && 568 input_mt_is_used(mt, slot)) 569 return; 570 } 571 572 input_mt_slot(input, slotnum); 573 input_mt_report_slot_state(input, MT_TOOL_FINGER, 574 s->touch_state || s->inrange_state); 575 if (s->touch_state || s->inrange_state) { 576 /* this finger is in proximity of the sensor */ 577 int wide = (s->w > s->h); 578 /* divided by two to match visual scale of touch */ 579 int major = max(s->w, s->h) >> 1; 580 int minor = min(s->w, s->h) >> 1; 581 582 input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x); 583 input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y); 584 input_event(input, EV_ABS, ABS_MT_TOOL_X, s->cx); 585 input_event(input, EV_ABS, ABS_MT_TOOL_Y, s->cy); 586 input_event(input, EV_ABS, ABS_MT_DISTANCE, 587 !s->touch_state); 588 input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide); 589 input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p); 590 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major); 591 input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor); 592 } 593 } 594 595 td->num_received++; 596 } 597 598 /* 599 * this function is called when a whole packet has been received and processed, 600 * so that it can decide what to send to the input layer. 601 */ 602 static void mt_sync_frame(struct mt_device *td, struct input_dev *input) 603 { 604 input_mt_sync_frame(input); 605 input_sync(input); 606 td->num_received = 0; 607 } 608 609 static int mt_event(struct hid_device *hid, struct hid_field *field, 610 struct hid_usage *usage, __s32 value) 611 { 612 /* we will handle the hidinput part later, now remains hiddev */ 613 if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event) 614 hid->hiddev_hid_event(hid, field, usage, value); 615 616 return 1; 617 } 618 619 static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field, 620 struct hid_usage *usage, __s32 value) 621 { 622 struct mt_device *td = hid_get_drvdata(hid); 623 __s32 quirks = td->mtclass.quirks; 624 struct input_dev *input = field->hidinput->input; 625 626 if (hid->claimed & HID_CLAIMED_INPUT) { 627 switch (usage->hid) { 628 case HID_DG_INRANGE: 629 if (quirks & MT_QUIRK_VALID_IS_INRANGE) 630 td->curvalid = value; 631 if (quirks & MT_QUIRK_HOVERING) 632 td->curdata.inrange_state = value; 633 break; 634 case HID_DG_TIPSWITCH: 635 if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 636 td->curvalid = value; 637 td->curdata.touch_state = value; 638 break; 639 case HID_DG_CONFIDENCE: 640 if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE) 641 td->curvalid = value; 642 break; 643 case HID_DG_CONTACTID: 644 td->curdata.contactid = value; 645 break; 646 case HID_DG_TIPPRESSURE: 647 td->curdata.p = value; 648 break; 649 case HID_GD_X: 650 if (usage->code == ABS_MT_TOOL_X) 651 td->curdata.cx = value; 652 else 653 td->curdata.x = value; 654 break; 655 case HID_GD_Y: 656 if (usage->code == ABS_MT_TOOL_Y) 657 td->curdata.cy = value; 658 else 659 td->curdata.y = value; 660 break; 661 case HID_DG_WIDTH: 662 td->curdata.w = value; 663 break; 664 case HID_DG_HEIGHT: 665 td->curdata.h = value; 666 break; 667 case HID_DG_CONTACTCOUNT: 668 break; 669 case HID_DG_TOUCH: 670 /* do nothing */ 671 break; 672 673 default: 674 if (usage->type) 675 input_event(input, usage->type, usage->code, 676 value); 677 return; 678 } 679 680 if (usage->usage_index + 1 == field->report_count) { 681 /* we only take into account the last report. */ 682 if (usage->hid == td->last_slot_field) 683 mt_complete_slot(td, input); 684 685 if (field->index == td->last_field_index 686 && td->num_received >= td->num_expected) 687 mt_sync_frame(td, field->hidinput->input); 688 } 689 690 } 691 } 692 693 static void mt_report(struct hid_device *hid, struct hid_report *report) 694 { 695 struct mt_device *td = hid_get_drvdata(hid); 696 struct hid_field *field; 697 unsigned count; 698 int r, n; 699 700 if (report->id != td->mt_report_id) 701 return; 702 703 if (!(hid->claimed & HID_CLAIMED_INPUT)) 704 return; 705 706 /* 707 * Includes multi-packet support where subsequent 708 * packets are sent with zero contactcount. 709 */ 710 if (td->cc_index >= 0) { 711 struct hid_field *field = report->field[td->cc_index]; 712 int value = field->value[td->cc_value_index]; 713 if (value) 714 td->num_expected = value; 715 } 716 717 for (r = 0; r < report->maxfield; r++) { 718 field = report->field[r]; 719 count = field->report_count; 720 721 if (!(HID_MAIN_ITEM_VARIABLE & field->flags)) 722 continue; 723 724 for (n = 0; n < count; n++) 725 mt_process_mt_event(hid, field, &field->usage[n], 726 field->value[n]); 727 } 728 } 729 730 static void mt_set_input_mode(struct hid_device *hdev) 731 { 732 struct mt_device *td = hid_get_drvdata(hdev); 733 struct hid_report *r; 734 struct hid_report_enum *re; 735 736 if (td->inputmode < 0) 737 return; 738 739 re = &(hdev->report_enum[HID_FEATURE_REPORT]); 740 r = re->report_id_hash[td->inputmode]; 741 if (r) { 742 r->field[0]->value[td->inputmode_index] = 0x02; 743 usbhid_submit_report(hdev, r, USB_DIR_OUT); 744 } 745 } 746 747 static void mt_set_maxcontacts(struct hid_device *hdev) 748 { 749 struct mt_device *td = hid_get_drvdata(hdev); 750 struct hid_report *r; 751 struct hid_report_enum *re; 752 int fieldmax, max; 753 754 if (td->maxcontact_report_id < 0) 755 return; 756 757 if (!td->mtclass.maxcontacts) 758 return; 759 760 re = &hdev->report_enum[HID_FEATURE_REPORT]; 761 r = re->report_id_hash[td->maxcontact_report_id]; 762 if (r) { 763 max = td->mtclass.maxcontacts; 764 fieldmax = r->field[0]->logical_maximum; 765 max = min(fieldmax, max); 766 if (r->field[0]->value[0] != max) { 767 r->field[0]->value[0] = max; 768 usbhid_submit_report(hdev, r, USB_DIR_OUT); 769 } 770 } 771 } 772 773 static void mt_post_parse_default_settings(struct mt_device *td) 774 { 775 __s32 quirks = td->mtclass.quirks; 776 777 /* unknown serial device needs special quirks */ 778 if (td->touches_by_report == 1) { 779 quirks |= MT_QUIRK_ALWAYS_VALID; 780 quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP; 781 quirks &= ~MT_QUIRK_VALID_IS_INRANGE; 782 quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE; 783 quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 784 } 785 786 td->mtclass.quirks = quirks; 787 } 788 789 static void mt_post_parse(struct mt_device *td) 790 { 791 struct mt_fields *f = td->fields; 792 struct mt_class *cls = &td->mtclass; 793 794 if (td->touches_by_report > 0) { 795 int field_count_per_touch = f->length / td->touches_by_report; 796 td->last_slot_field = f->usages[field_count_per_touch - 1]; 797 } 798 799 if (td->cc_index < 0) 800 cls->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 801 } 802 803 static void mt_input_configured(struct hid_device *hdev, struct hid_input *hi) 804 805 { 806 struct mt_device *td = hid_get_drvdata(hdev); 807 struct mt_class *cls = &td->mtclass; 808 struct input_dev *input = hi->input; 809 810 /* Only initialize slots for MT input devices */ 811 if (!test_bit(ABS_MT_POSITION_X, input->absbit)) 812 return; 813 814 if (!td->maxcontacts) 815 td->maxcontacts = MT_DEFAULT_MAXCONTACT; 816 817 mt_post_parse(td); 818 if (td->serial_maybe) 819 mt_post_parse_default_settings(td); 820 821 if (cls->is_indirect) 822 td->mt_flags |= INPUT_MT_POINTER; 823 824 if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 825 td->mt_flags |= INPUT_MT_DROP_UNUSED; 826 827 input_mt_init_slots(input, td->maxcontacts, td->mt_flags); 828 829 td->mt_flags = 0; 830 } 831 832 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) 833 { 834 int ret, i; 835 struct mt_device *td; 836 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */ 837 838 for (i = 0; mt_classes[i].name ; i++) { 839 if (id->driver_data == mt_classes[i].name) { 840 mtclass = &(mt_classes[i]); 841 break; 842 } 843 } 844 845 /* This allows the driver to correctly support devices 846 * that emit events over several HID messages. 847 */ 848 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; 849 850 td = kzalloc(sizeof(struct mt_device), GFP_KERNEL); 851 if (!td) { 852 dev_err(&hdev->dev, "cannot allocate multitouch data\n"); 853 return -ENOMEM; 854 } 855 td->mtclass = *mtclass; 856 td->inputmode = -1; 857 td->maxcontact_report_id = -1; 858 td->cc_index = -1; 859 hid_set_drvdata(hdev, td); 860 861 td->fields = kzalloc(sizeof(struct mt_fields), GFP_KERNEL); 862 if (!td->fields) { 863 dev_err(&hdev->dev, "cannot allocate multitouch fields data\n"); 864 ret = -ENOMEM; 865 goto fail; 866 } 867 868 if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID) 869 td->serial_maybe = true; 870 871 ret = hid_parse(hdev); 872 if (ret != 0) 873 goto fail; 874 875 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 876 if (ret) 877 goto fail; 878 879 ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group); 880 881 mt_set_maxcontacts(hdev); 882 mt_set_input_mode(hdev); 883 884 kfree(td->fields); 885 td->fields = NULL; 886 887 return 0; 888 889 fail: 890 kfree(td->fields); 891 kfree(td); 892 return ret; 893 } 894 895 #ifdef CONFIG_PM 896 static int mt_reset_resume(struct hid_device *hdev) 897 { 898 mt_set_maxcontacts(hdev); 899 mt_set_input_mode(hdev); 900 return 0; 901 } 902 903 static int mt_resume(struct hid_device *hdev) 904 { 905 struct usb_interface *intf; 906 struct usb_host_interface *interface; 907 struct usb_device *dev; 908 909 if (hdev->bus != BUS_USB) 910 return 0; 911 912 intf = to_usb_interface(hdev->dev.parent); 913 interface = intf->cur_altsetting; 914 dev = hid_to_usb_dev(hdev); 915 916 /* Some Elan legacy devices require SET_IDLE to be set on resume. 917 * It should be safe to send it to other devices too. 918 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */ 919 920 usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 921 HID_REQ_SET_IDLE, 922 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 923 0, interface->desc.bInterfaceNumber, 924 NULL, 0, USB_CTRL_SET_TIMEOUT); 925 926 return 0; 927 } 928 #endif 929 930 static void mt_remove(struct hid_device *hdev) 931 { 932 struct mt_device *td = hid_get_drvdata(hdev); 933 sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group); 934 hid_hw_stop(hdev); 935 kfree(td); 936 hid_set_drvdata(hdev, NULL); 937 } 938 939 static const struct hid_device_id mt_devices[] = { 940 941 /* 3M panels */ 942 { .driver_data = MT_CLS_3M, 943 MT_USB_DEVICE(USB_VENDOR_ID_3M, 944 USB_DEVICE_ID_3M1968) }, 945 { .driver_data = MT_CLS_3M, 946 MT_USB_DEVICE(USB_VENDOR_ID_3M, 947 USB_DEVICE_ID_3M2256) }, 948 { .driver_data = MT_CLS_3M, 949 MT_USB_DEVICE(USB_VENDOR_ID_3M, 950 USB_DEVICE_ID_3M3266) }, 951 952 /* ActionStar panels */ 953 { .driver_data = MT_CLS_NSMU, 954 MT_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR, 955 USB_DEVICE_ID_ACTIONSTAR_1011) }, 956 957 /* Atmel panels */ 958 { .driver_data = MT_CLS_SERIAL, 959 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL, 960 USB_DEVICE_ID_ATMEL_MULTITOUCH) }, 961 { .driver_data = MT_CLS_SERIAL, 962 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL, 963 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) }, 964 965 /* Baanto multitouch devices */ 966 { .driver_data = MT_CLS_NSMU, 967 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO, 968 USB_DEVICE_ID_BAANTO_MT_190W2) }, 969 /* Cando panels */ 970 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 971 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 972 USB_DEVICE_ID_CANDO_MULTI_TOUCH) }, 973 { .driver_data = MT_CLS_DUAL_CONTACT_NUMBER, 974 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 975 USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) }, 976 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 977 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 978 USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) }, 979 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 980 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 981 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) }, 982 983 /* Chunghwa Telecom touch panels */ 984 { .driver_data = MT_CLS_NSMU, 985 MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, 986 USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) }, 987 988 /* CVTouch panels */ 989 { .driver_data = MT_CLS_NSMU, 990 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, 991 USB_DEVICE_ID_CVTOUCH_SCREEN) }, 992 993 /* Cypress panel */ 994 { .driver_data = MT_CLS_CYPRESS, 995 HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, 996 USB_DEVICE_ID_CYPRESS_TRUETOUCH) }, 997 998 /* eGalax devices (resistive) */ 999 { .driver_data = MT_CLS_EGALAX, 1000 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1001 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) }, 1002 { .driver_data = MT_CLS_EGALAX, 1003 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1004 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) }, 1005 1006 /* eGalax devices (capacitive) */ 1007 { .driver_data = MT_CLS_EGALAX, 1008 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1009 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) }, 1010 { .driver_data = MT_CLS_EGALAX_SERIAL, 1011 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1012 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) }, 1013 { .driver_data = MT_CLS_EGALAX_SERIAL, 1014 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1015 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) }, 1016 { .driver_data = MT_CLS_EGALAX_SERIAL, 1017 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1018 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, 1019 { .driver_data = MT_CLS_EGALAX_SERIAL, 1020 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1021 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) }, 1022 { .driver_data = MT_CLS_EGALAX, 1023 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1024 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) }, 1025 { .driver_data = MT_CLS_EGALAX_SERIAL, 1026 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1027 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) }, 1028 { .driver_data = MT_CLS_EGALAX, 1029 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1030 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) }, 1031 { .driver_data = MT_CLS_EGALAX_SERIAL, 1032 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1033 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) }, 1034 { .driver_data = MT_CLS_EGALAX, 1035 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1036 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) }, 1037 { .driver_data = MT_CLS_EGALAX, 1038 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1039 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) }, 1040 { .driver_data = MT_CLS_EGALAX_SERIAL, 1041 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1042 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) }, 1043 { .driver_data = MT_CLS_EGALAX_SERIAL, 1044 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1045 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) }, 1046 { .driver_data = MT_CLS_EGALAX_SERIAL, 1047 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1048 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) }, 1049 { .driver_data = MT_CLS_EGALAX, 1050 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1051 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, 1052 { .driver_data = MT_CLS_EGALAX, 1053 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1054 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) }, 1055 { .driver_data = MT_CLS_EGALAX, 1056 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1057 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) }, 1058 1059 /* Elo TouchSystems IntelliTouch Plus panel */ 1060 { .driver_data = MT_CLS_DUAL_CONTACT_ID, 1061 MT_USB_DEVICE(USB_VENDOR_ID_ELO, 1062 USB_DEVICE_ID_ELO_TS2515) }, 1063 1064 /* Flatfrog Panels */ 1065 { .driver_data = MT_CLS_FLATFROG, 1066 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG, 1067 USB_DEVICE_ID_MULTITOUCH_3200) }, 1068 1069 /* GeneralTouch panel */ 1070 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS, 1071 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1072 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) }, 1073 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1074 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1075 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) }, 1076 1077 /* Gametel game controller */ 1078 { .driver_data = MT_CLS_NSMU, 1079 MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL, 1080 USB_DEVICE_ID_GAMETEL_MT_MODE) }, 1081 1082 /* GoodTouch panels */ 1083 { .driver_data = MT_CLS_NSMU, 1084 MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, 1085 USB_DEVICE_ID_GOODTOUCH_000f) }, 1086 1087 /* Hanvon panels */ 1088 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1089 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, 1090 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) }, 1091 1092 /* Ideacom panel */ 1093 { .driver_data = MT_CLS_SERIAL, 1094 MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM, 1095 USB_DEVICE_ID_IDEACOM_IDC6650) }, 1096 { .driver_data = MT_CLS_SERIAL, 1097 MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM, 1098 USB_DEVICE_ID_IDEACOM_IDC6651) }, 1099 1100 /* Ilitek dual touch panel */ 1101 { .driver_data = MT_CLS_NSMU, 1102 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK, 1103 USB_DEVICE_ID_ILITEK_MULTITOUCH) }, 1104 1105 /* IRTOUCH panels */ 1106 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1107 MT_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, 1108 USB_DEVICE_ID_IRTOUCH_INFRARED_USB) }, 1109 1110 /* LG Display panels */ 1111 { .driver_data = MT_CLS_DEFAULT, 1112 MT_USB_DEVICE(USB_VENDOR_ID_LG, 1113 USB_DEVICE_ID_LG_MULTITOUCH) }, 1114 1115 /* Lumio panels */ 1116 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1117 MT_USB_DEVICE(USB_VENDOR_ID_LUMIO, 1118 USB_DEVICE_ID_CRYSTALTOUCH) }, 1119 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1120 MT_USB_DEVICE(USB_VENDOR_ID_LUMIO, 1121 USB_DEVICE_ID_CRYSTALTOUCH_DUAL) }, 1122 1123 /* MosArt panels */ 1124 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1125 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1126 USB_DEVICE_ID_ASUS_T91MT)}, 1127 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1128 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1129 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) }, 1130 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1131 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX, 1132 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) }, 1133 1134 /* Nexio panels */ 1135 { .driver_data = MT_CLS_DEFAULT, 1136 MT_USB_DEVICE(USB_VENDOR_ID_NEXIO, 1137 USB_DEVICE_ID_NEXIO_MULTITOUCH_420)}, 1138 1139 /* Panasonic panels */ 1140 { .driver_data = MT_CLS_PANASONIC, 1141 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1142 USB_DEVICE_ID_PANABOARD_UBT780) }, 1143 { .driver_data = MT_CLS_PANASONIC, 1144 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1145 USB_DEVICE_ID_PANABOARD_UBT880) }, 1146 1147 /* Novatek Panel */ 1148 { .driver_data = MT_CLS_NSMU, 1149 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK, 1150 USB_DEVICE_ID_NOVATEK_PCT) }, 1151 1152 /* PenMount panels */ 1153 { .driver_data = MT_CLS_CONFIDENCE, 1154 MT_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, 1155 USB_DEVICE_ID_PENMOUNT_PCI) }, 1156 1157 /* PixArt optical touch screen */ 1158 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1159 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1160 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) }, 1161 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1162 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1163 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) }, 1164 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1165 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1166 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) }, 1167 1168 /* PixCir-based panels */ 1169 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1170 MT_USB_DEVICE(USB_VENDOR_ID_HANVON, 1171 USB_DEVICE_ID_HANVON_MULTITOUCH) }, 1172 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1173 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1174 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) }, 1175 1176 /* Quanta-based panels */ 1177 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1178 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1179 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) }, 1180 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1181 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1182 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) }, 1183 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1184 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1185 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) }, 1186 1187 /* Stantum panels */ 1188 { .driver_data = MT_CLS_CONFIDENCE, 1189 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM, 1190 USB_DEVICE_ID_MTP)}, 1191 { .driver_data = MT_CLS_CONFIDENCE, 1192 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, 1193 USB_DEVICE_ID_MTP_STM)}, 1194 { .driver_data = MT_CLS_DEFAULT, 1195 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX, 1196 USB_DEVICE_ID_MTP_SITRONIX)}, 1197 1198 /* TopSeed panels */ 1199 { .driver_data = MT_CLS_TOPSEED, 1200 MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, 1201 USB_DEVICE_ID_TOPSEED2_PERIPAD_701) }, 1202 1203 /* Touch International panels */ 1204 { .driver_data = MT_CLS_NSMU, 1205 MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, 1206 USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) }, 1207 1208 /* Unitec panels */ 1209 { .driver_data = MT_CLS_NSMU, 1210 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1211 USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) }, 1212 { .driver_data = MT_CLS_NSMU, 1213 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1214 USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) }, 1215 /* XAT */ 1216 { .driver_data = MT_CLS_NSMU, 1217 MT_USB_DEVICE(USB_VENDOR_ID_XAT, 1218 USB_DEVICE_ID_XAT_CSR) }, 1219 1220 /* Xiroku */ 1221 { .driver_data = MT_CLS_NSMU, 1222 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1223 USB_DEVICE_ID_XIROKU_SPX) }, 1224 { .driver_data = MT_CLS_NSMU, 1225 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1226 USB_DEVICE_ID_XIROKU_MPX) }, 1227 { .driver_data = MT_CLS_NSMU, 1228 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1229 USB_DEVICE_ID_XIROKU_CSR) }, 1230 { .driver_data = MT_CLS_NSMU, 1231 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1232 USB_DEVICE_ID_XIROKU_SPX1) }, 1233 { .driver_data = MT_CLS_NSMU, 1234 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1235 USB_DEVICE_ID_XIROKU_MPX1) }, 1236 { .driver_data = MT_CLS_NSMU, 1237 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1238 USB_DEVICE_ID_XIROKU_CSR1) }, 1239 { .driver_data = MT_CLS_NSMU, 1240 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1241 USB_DEVICE_ID_XIROKU_SPX2) }, 1242 { .driver_data = MT_CLS_NSMU, 1243 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1244 USB_DEVICE_ID_XIROKU_MPX2) }, 1245 { .driver_data = MT_CLS_NSMU, 1246 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1247 USB_DEVICE_ID_XIROKU_CSR2) }, 1248 1249 /* Zytronic panels */ 1250 { .driver_data = MT_CLS_SERIAL, 1251 MT_USB_DEVICE(USB_VENDOR_ID_ZYTRONIC, 1252 USB_DEVICE_ID_ZYTRONIC_ZXY100) }, 1253 1254 /* Generic MT device */ 1255 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) }, 1256 { } 1257 }; 1258 MODULE_DEVICE_TABLE(hid, mt_devices); 1259 1260 static const struct hid_usage_id mt_grabbed_usages[] = { 1261 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID }, 1262 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1} 1263 }; 1264 1265 static struct hid_driver mt_driver = { 1266 .name = "hid-multitouch", 1267 .id_table = mt_devices, 1268 .probe = mt_probe, 1269 .remove = mt_remove, 1270 .input_mapping = mt_input_mapping, 1271 .input_mapped = mt_input_mapped, 1272 .input_configured = mt_input_configured, 1273 .feature_mapping = mt_feature_mapping, 1274 .usage_table = mt_grabbed_usages, 1275 .event = mt_event, 1276 .report = mt_report, 1277 #ifdef CONFIG_PM 1278 .reset_resume = mt_reset_resume, 1279 .resume = mt_resume, 1280 #endif 1281 }; 1282 module_hid_driver(mt_driver); 1283