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 625 if (hid->claimed & HID_CLAIMED_INPUT) { 626 switch (usage->hid) { 627 case HID_DG_INRANGE: 628 if (quirks & MT_QUIRK_VALID_IS_INRANGE) 629 td->curvalid = value; 630 if (quirks & MT_QUIRK_HOVERING) 631 td->curdata.inrange_state = value; 632 break; 633 case HID_DG_TIPSWITCH: 634 if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 635 td->curvalid = value; 636 td->curdata.touch_state = value; 637 break; 638 case HID_DG_CONFIDENCE: 639 if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE) 640 td->curvalid = value; 641 break; 642 case HID_DG_CONTACTID: 643 td->curdata.contactid = value; 644 break; 645 case HID_DG_TIPPRESSURE: 646 td->curdata.p = value; 647 break; 648 case HID_GD_X: 649 if (usage->code == ABS_MT_TOOL_X) 650 td->curdata.cx = value; 651 else 652 td->curdata.x = value; 653 break; 654 case HID_GD_Y: 655 if (usage->code == ABS_MT_TOOL_Y) 656 td->curdata.cy = value; 657 else 658 td->curdata.y = value; 659 break; 660 case HID_DG_WIDTH: 661 td->curdata.w = value; 662 break; 663 case HID_DG_HEIGHT: 664 td->curdata.h = value; 665 break; 666 case HID_DG_CONTACTCOUNT: 667 break; 668 case HID_DG_TOUCH: 669 /* do nothing */ 670 break; 671 672 default: 673 return; 674 } 675 676 if (usage->usage_index + 1 == field->report_count) { 677 /* we only take into account the last report. */ 678 if (usage->hid == td->last_slot_field) 679 mt_complete_slot(td, field->hidinput->input); 680 681 if (field->index == td->last_field_index 682 && td->num_received >= td->num_expected) 683 mt_sync_frame(td, field->hidinput->input); 684 } 685 686 } 687 } 688 689 static void mt_report(struct hid_device *hid, struct hid_report *report) 690 { 691 struct mt_device *td = hid_get_drvdata(hid); 692 struct hid_field *field; 693 unsigned count; 694 int r, n; 695 696 if (report->id != td->mt_report_id) 697 return; 698 699 if (!(hid->claimed & HID_CLAIMED_INPUT)) 700 return; 701 702 /* 703 * Includes multi-packet support where subsequent 704 * packets are sent with zero contactcount. 705 */ 706 if (td->cc_index >= 0) { 707 struct hid_field *field = report->field[td->cc_index]; 708 int value = field->value[td->cc_value_index]; 709 if (value) 710 td->num_expected = value; 711 } 712 713 for (r = 0; r < report->maxfield; r++) { 714 field = report->field[r]; 715 count = field->report_count; 716 717 if (!(HID_MAIN_ITEM_VARIABLE & field->flags)) 718 continue; 719 720 for (n = 0; n < count; n++) 721 mt_process_mt_event(hid, field, &field->usage[n], 722 field->value[n]); 723 } 724 } 725 726 static void mt_set_input_mode(struct hid_device *hdev) 727 { 728 struct mt_device *td = hid_get_drvdata(hdev); 729 struct hid_report *r; 730 struct hid_report_enum *re; 731 732 if (td->inputmode < 0) 733 return; 734 735 re = &(hdev->report_enum[HID_FEATURE_REPORT]); 736 r = re->report_id_hash[td->inputmode]; 737 if (r) { 738 r->field[0]->value[td->inputmode_index] = 0x02; 739 usbhid_submit_report(hdev, r, USB_DIR_OUT); 740 } 741 } 742 743 static void mt_set_maxcontacts(struct hid_device *hdev) 744 { 745 struct mt_device *td = hid_get_drvdata(hdev); 746 struct hid_report *r; 747 struct hid_report_enum *re; 748 int fieldmax, max; 749 750 if (td->maxcontact_report_id < 0) 751 return; 752 753 if (!td->mtclass.maxcontacts) 754 return; 755 756 re = &hdev->report_enum[HID_FEATURE_REPORT]; 757 r = re->report_id_hash[td->maxcontact_report_id]; 758 if (r) { 759 max = td->mtclass.maxcontacts; 760 fieldmax = r->field[0]->logical_maximum; 761 max = min(fieldmax, max); 762 if (r->field[0]->value[0] != max) { 763 r->field[0]->value[0] = max; 764 usbhid_submit_report(hdev, r, USB_DIR_OUT); 765 } 766 } 767 } 768 769 static void mt_post_parse_default_settings(struct mt_device *td) 770 { 771 __s32 quirks = td->mtclass.quirks; 772 773 /* unknown serial device needs special quirks */ 774 if (td->touches_by_report == 1) { 775 quirks |= MT_QUIRK_ALWAYS_VALID; 776 quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP; 777 quirks &= ~MT_QUIRK_VALID_IS_INRANGE; 778 quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE; 779 quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 780 } 781 782 td->mtclass.quirks = quirks; 783 } 784 785 static void mt_post_parse(struct mt_device *td) 786 { 787 struct mt_fields *f = td->fields; 788 struct mt_class *cls = &td->mtclass; 789 790 if (td->touches_by_report > 0) { 791 int field_count_per_touch = f->length / td->touches_by_report; 792 td->last_slot_field = f->usages[field_count_per_touch - 1]; 793 } 794 795 if (td->cc_index < 0) 796 cls->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE; 797 } 798 799 static void mt_input_configured(struct hid_device *hdev, struct hid_input *hi) 800 801 { 802 struct mt_device *td = hid_get_drvdata(hdev); 803 struct mt_class *cls = &td->mtclass; 804 struct input_dev *input = hi->input; 805 806 /* Only initialize slots for MT input devices */ 807 if (!test_bit(ABS_MT_POSITION_X, input->absbit)) 808 return; 809 810 if (!td->maxcontacts) 811 td->maxcontacts = MT_DEFAULT_MAXCONTACT; 812 813 mt_post_parse(td); 814 if (td->serial_maybe) 815 mt_post_parse_default_settings(td); 816 817 if (cls->is_indirect) 818 td->mt_flags |= INPUT_MT_POINTER; 819 820 if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) 821 td->mt_flags |= INPUT_MT_DROP_UNUSED; 822 823 input_mt_init_slots(input, td->maxcontacts, td->mt_flags); 824 825 td->mt_flags = 0; 826 } 827 828 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) 829 { 830 int ret, i; 831 struct mt_device *td; 832 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */ 833 834 for (i = 0; mt_classes[i].name ; i++) { 835 if (id->driver_data == mt_classes[i].name) { 836 mtclass = &(mt_classes[i]); 837 break; 838 } 839 } 840 841 /* This allows the driver to correctly support devices 842 * that emit events over several HID messages. 843 */ 844 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; 845 846 td = kzalloc(sizeof(struct mt_device), GFP_KERNEL); 847 if (!td) { 848 dev_err(&hdev->dev, "cannot allocate multitouch data\n"); 849 return -ENOMEM; 850 } 851 td->mtclass = *mtclass; 852 td->inputmode = -1; 853 td->maxcontact_report_id = -1; 854 td->cc_index = -1; 855 hid_set_drvdata(hdev, td); 856 857 td->fields = kzalloc(sizeof(struct mt_fields), GFP_KERNEL); 858 if (!td->fields) { 859 dev_err(&hdev->dev, "cannot allocate multitouch fields data\n"); 860 ret = -ENOMEM; 861 goto fail; 862 } 863 864 if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID) 865 td->serial_maybe = true; 866 867 ret = hid_parse(hdev); 868 if (ret != 0) 869 goto fail; 870 871 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 872 if (ret) 873 goto fail; 874 875 ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group); 876 877 mt_set_maxcontacts(hdev); 878 mt_set_input_mode(hdev); 879 880 kfree(td->fields); 881 td->fields = NULL; 882 883 return 0; 884 885 fail: 886 kfree(td->fields); 887 kfree(td); 888 return ret; 889 } 890 891 #ifdef CONFIG_PM 892 static int mt_reset_resume(struct hid_device *hdev) 893 { 894 mt_set_maxcontacts(hdev); 895 mt_set_input_mode(hdev); 896 return 0; 897 } 898 899 static int mt_resume(struct hid_device *hdev) 900 { 901 struct usb_interface *intf; 902 struct usb_host_interface *interface; 903 struct usb_device *dev; 904 905 if (hdev->bus != BUS_USB) 906 return 0; 907 908 intf = to_usb_interface(hdev->dev.parent); 909 interface = intf->cur_altsetting; 910 dev = hid_to_usb_dev(hdev); 911 912 /* Some Elan legacy devices require SET_IDLE to be set on resume. 913 * It should be safe to send it to other devices too. 914 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */ 915 916 usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 917 HID_REQ_SET_IDLE, 918 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 919 0, interface->desc.bInterfaceNumber, 920 NULL, 0, USB_CTRL_SET_TIMEOUT); 921 922 return 0; 923 } 924 #endif 925 926 static void mt_remove(struct hid_device *hdev) 927 { 928 struct mt_device *td = hid_get_drvdata(hdev); 929 sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group); 930 hid_hw_stop(hdev); 931 kfree(td); 932 hid_set_drvdata(hdev, NULL); 933 } 934 935 static const struct hid_device_id mt_devices[] = { 936 937 /* 3M panels */ 938 { .driver_data = MT_CLS_3M, 939 MT_USB_DEVICE(USB_VENDOR_ID_3M, 940 USB_DEVICE_ID_3M1968) }, 941 { .driver_data = MT_CLS_3M, 942 MT_USB_DEVICE(USB_VENDOR_ID_3M, 943 USB_DEVICE_ID_3M2256) }, 944 { .driver_data = MT_CLS_3M, 945 MT_USB_DEVICE(USB_VENDOR_ID_3M, 946 USB_DEVICE_ID_3M3266) }, 947 948 /* ActionStar panels */ 949 { .driver_data = MT_CLS_NSMU, 950 MT_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR, 951 USB_DEVICE_ID_ACTIONSTAR_1011) }, 952 953 /* Atmel panels */ 954 { .driver_data = MT_CLS_SERIAL, 955 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL, 956 USB_DEVICE_ID_ATMEL_MULTITOUCH) }, 957 { .driver_data = MT_CLS_SERIAL, 958 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL, 959 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) }, 960 961 /* Baanto multitouch devices */ 962 { .driver_data = MT_CLS_NSMU, 963 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO, 964 USB_DEVICE_ID_BAANTO_MT_190W2) }, 965 /* Cando panels */ 966 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 967 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 968 USB_DEVICE_ID_CANDO_MULTI_TOUCH) }, 969 { .driver_data = MT_CLS_DUAL_CONTACT_NUMBER, 970 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 971 USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) }, 972 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 973 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 974 USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) }, 975 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 976 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 977 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) }, 978 979 /* Chunghwa Telecom touch panels */ 980 { .driver_data = MT_CLS_NSMU, 981 MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, 982 USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) }, 983 984 /* CVTouch panels */ 985 { .driver_data = MT_CLS_NSMU, 986 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, 987 USB_DEVICE_ID_CVTOUCH_SCREEN) }, 988 989 /* Cypress panel */ 990 { .driver_data = MT_CLS_CYPRESS, 991 HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, 992 USB_DEVICE_ID_CYPRESS_TRUETOUCH) }, 993 994 /* eGalax devices (resistive) */ 995 { .driver_data = MT_CLS_EGALAX, 996 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 997 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) }, 998 { .driver_data = MT_CLS_EGALAX, 999 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1000 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) }, 1001 1002 /* eGalax devices (capacitive) */ 1003 { .driver_data = MT_CLS_EGALAX, 1004 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1005 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) }, 1006 { .driver_data = MT_CLS_EGALAX_SERIAL, 1007 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1008 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) }, 1009 { .driver_data = MT_CLS_EGALAX_SERIAL, 1010 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1011 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) }, 1012 { .driver_data = MT_CLS_EGALAX_SERIAL, 1013 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1014 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, 1015 { .driver_data = MT_CLS_EGALAX_SERIAL, 1016 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1017 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) }, 1018 { .driver_data = MT_CLS_EGALAX, 1019 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1020 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) }, 1021 { .driver_data = MT_CLS_EGALAX_SERIAL, 1022 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1023 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) }, 1024 { .driver_data = MT_CLS_EGALAX, 1025 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1026 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) }, 1027 { .driver_data = MT_CLS_EGALAX_SERIAL, 1028 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1029 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) }, 1030 { .driver_data = MT_CLS_EGALAX, 1031 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1032 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) }, 1033 { .driver_data = MT_CLS_EGALAX, 1034 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1035 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) }, 1036 { .driver_data = MT_CLS_EGALAX_SERIAL, 1037 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1038 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) }, 1039 { .driver_data = MT_CLS_EGALAX_SERIAL, 1040 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1041 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) }, 1042 { .driver_data = MT_CLS_EGALAX_SERIAL, 1043 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1044 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) }, 1045 { .driver_data = MT_CLS_EGALAX, 1046 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1047 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, 1048 { .driver_data = MT_CLS_EGALAX, 1049 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1050 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) }, 1051 { .driver_data = MT_CLS_EGALAX, 1052 HID_USB_DEVICE(USB_VENDOR_ID_DWAV, 1053 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) }, 1054 1055 /* Elo TouchSystems IntelliTouch Plus panel */ 1056 { .driver_data = MT_CLS_DUAL_CONTACT_ID, 1057 MT_USB_DEVICE(USB_VENDOR_ID_ELO, 1058 USB_DEVICE_ID_ELO_TS2515) }, 1059 1060 /* Flatfrog Panels */ 1061 { .driver_data = MT_CLS_FLATFROG, 1062 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG, 1063 USB_DEVICE_ID_MULTITOUCH_3200) }, 1064 1065 /* GeneralTouch panel */ 1066 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS, 1067 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1068 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) }, 1069 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS, 1070 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 1071 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) }, 1072 1073 /* Gametel game controller */ 1074 { .driver_data = MT_CLS_NSMU, 1075 MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL, 1076 USB_DEVICE_ID_GAMETEL_MT_MODE) }, 1077 1078 /* GoodTouch panels */ 1079 { .driver_data = MT_CLS_NSMU, 1080 MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, 1081 USB_DEVICE_ID_GOODTOUCH_000f) }, 1082 1083 /* Hanvon panels */ 1084 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1085 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, 1086 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) }, 1087 1088 /* Ideacom panel */ 1089 { .driver_data = MT_CLS_SERIAL, 1090 MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM, 1091 USB_DEVICE_ID_IDEACOM_IDC6650) }, 1092 { .driver_data = MT_CLS_SERIAL, 1093 MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM, 1094 USB_DEVICE_ID_IDEACOM_IDC6651) }, 1095 1096 /* Ilitek dual touch panel */ 1097 { .driver_data = MT_CLS_NSMU, 1098 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK, 1099 USB_DEVICE_ID_ILITEK_MULTITOUCH) }, 1100 1101 /* IRTOUCH panels */ 1102 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1103 MT_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, 1104 USB_DEVICE_ID_IRTOUCH_INFRARED_USB) }, 1105 1106 /* LG Display panels */ 1107 { .driver_data = MT_CLS_DEFAULT, 1108 MT_USB_DEVICE(USB_VENDOR_ID_LG, 1109 USB_DEVICE_ID_LG_MULTITOUCH) }, 1110 1111 /* Lumio panels */ 1112 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1113 MT_USB_DEVICE(USB_VENDOR_ID_LUMIO, 1114 USB_DEVICE_ID_CRYSTALTOUCH) }, 1115 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1116 MT_USB_DEVICE(USB_VENDOR_ID_LUMIO, 1117 USB_DEVICE_ID_CRYSTALTOUCH_DUAL) }, 1118 1119 /* MosArt panels */ 1120 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1121 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1122 USB_DEVICE_ID_ASUS_T91MT)}, 1123 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1124 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1125 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) }, 1126 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1127 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX, 1128 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) }, 1129 1130 /* Nexio panels */ 1131 { .driver_data = MT_CLS_DEFAULT, 1132 MT_USB_DEVICE(USB_VENDOR_ID_NEXIO, 1133 USB_DEVICE_ID_NEXIO_MULTITOUCH_420)}, 1134 1135 /* Panasonic panels */ 1136 { .driver_data = MT_CLS_PANASONIC, 1137 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1138 USB_DEVICE_ID_PANABOARD_UBT780) }, 1139 { .driver_data = MT_CLS_PANASONIC, 1140 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1141 USB_DEVICE_ID_PANABOARD_UBT880) }, 1142 1143 /* Novatek Panel */ 1144 { .driver_data = MT_CLS_NSMU, 1145 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK, 1146 USB_DEVICE_ID_NOVATEK_PCT) }, 1147 1148 /* PenMount panels */ 1149 { .driver_data = MT_CLS_CONFIDENCE, 1150 MT_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, 1151 USB_DEVICE_ID_PENMOUNT_PCI) }, 1152 1153 /* PixArt optical touch screen */ 1154 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1155 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1156 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) }, 1157 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1158 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1159 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) }, 1160 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1161 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1162 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) }, 1163 1164 /* PixCir-based panels */ 1165 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1166 MT_USB_DEVICE(USB_VENDOR_ID_HANVON, 1167 USB_DEVICE_ID_HANVON_MULTITOUCH) }, 1168 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1169 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1170 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) }, 1171 1172 /* Quanta-based panels */ 1173 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1174 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1175 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) }, 1176 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1177 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1178 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) }, 1179 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1180 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1181 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) }, 1182 1183 /* Stantum panels */ 1184 { .driver_data = MT_CLS_CONFIDENCE, 1185 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM, 1186 USB_DEVICE_ID_MTP)}, 1187 { .driver_data = MT_CLS_CONFIDENCE, 1188 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, 1189 USB_DEVICE_ID_MTP_STM)}, 1190 { .driver_data = MT_CLS_DEFAULT, 1191 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX, 1192 USB_DEVICE_ID_MTP_SITRONIX)}, 1193 1194 /* TopSeed panels */ 1195 { .driver_data = MT_CLS_TOPSEED, 1196 MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, 1197 USB_DEVICE_ID_TOPSEED2_PERIPAD_701) }, 1198 1199 /* Touch International panels */ 1200 { .driver_data = MT_CLS_NSMU, 1201 MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, 1202 USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) }, 1203 1204 /* Unitec panels */ 1205 { .driver_data = MT_CLS_NSMU, 1206 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1207 USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) }, 1208 { .driver_data = MT_CLS_NSMU, 1209 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC, 1210 USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) }, 1211 /* XAT */ 1212 { .driver_data = MT_CLS_NSMU, 1213 MT_USB_DEVICE(USB_VENDOR_ID_XAT, 1214 USB_DEVICE_ID_XAT_CSR) }, 1215 1216 /* Xiroku */ 1217 { .driver_data = MT_CLS_NSMU, 1218 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1219 USB_DEVICE_ID_XIROKU_SPX) }, 1220 { .driver_data = MT_CLS_NSMU, 1221 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1222 USB_DEVICE_ID_XIROKU_MPX) }, 1223 { .driver_data = MT_CLS_NSMU, 1224 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1225 USB_DEVICE_ID_XIROKU_CSR) }, 1226 { .driver_data = MT_CLS_NSMU, 1227 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1228 USB_DEVICE_ID_XIROKU_SPX1) }, 1229 { .driver_data = MT_CLS_NSMU, 1230 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1231 USB_DEVICE_ID_XIROKU_MPX1) }, 1232 { .driver_data = MT_CLS_NSMU, 1233 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1234 USB_DEVICE_ID_XIROKU_CSR1) }, 1235 { .driver_data = MT_CLS_NSMU, 1236 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1237 USB_DEVICE_ID_XIROKU_SPX2) }, 1238 { .driver_data = MT_CLS_NSMU, 1239 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1240 USB_DEVICE_ID_XIROKU_MPX2) }, 1241 { .driver_data = MT_CLS_NSMU, 1242 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1243 USB_DEVICE_ID_XIROKU_CSR2) }, 1244 1245 /* Zytronic panels */ 1246 { .driver_data = MT_CLS_SERIAL, 1247 MT_USB_DEVICE(USB_VENDOR_ID_ZYTRONIC, 1248 USB_DEVICE_ID_ZYTRONIC_ZXY100) }, 1249 1250 /* Generic MT device */ 1251 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) }, 1252 { } 1253 }; 1254 MODULE_DEVICE_TABLE(hid, mt_devices); 1255 1256 static const struct hid_usage_id mt_grabbed_usages[] = { 1257 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID }, 1258 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1} 1259 }; 1260 1261 static struct hid_driver mt_driver = { 1262 .name = "hid-multitouch", 1263 .id_table = mt_devices, 1264 .probe = mt_probe, 1265 .remove = mt_remove, 1266 .input_mapping = mt_input_mapping, 1267 .input_mapped = mt_input_mapped, 1268 .input_configured = mt_input_configured, 1269 .feature_mapping = mt_feature_mapping, 1270 .usage_table = mt_grabbed_usages, 1271 .event = mt_event, 1272 .report = mt_report, 1273 #ifdef CONFIG_PM 1274 .reset_resume = mt_reset_resume, 1275 .resume = mt_resume, 1276 #endif 1277 }; 1278 module_hid_driver(mt_driver); 1279