2 * HID driver for multitouch panels
4 * Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
5 * Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
6 * Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
8 * This code is partly based on hid-egalax.c:
10 * Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
11 * Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
12 * Copyright (c) 2010 Canonical, Ltd.
14 * This code is partly based on hid-3m-pct.c:
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.
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)
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"
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");
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_VALID_IS_INRANGE (1 << 4)
51 #define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 5)
52 #define MT_QUIRK_EGALAX_XYZ_FIXUP (1 << 6)
53 #define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 7)
57 __s32 contactid; /* the device ContactID assigned to this slot */
58 bool touch_state; /* is the touch valid? */
59 bool seen_in_this_frame;/* has this slot been updated */
63 struct mt_slot curdata; /* placeholder of incoming data */
64 struct mt_class *mtclass; /* our mt device class */
65 unsigned last_field_index; /* last field index of the report */
66 unsigned last_slot_field; /* the last field of a slot */
67 __s8 inputmode; /* InputMode HID feature, -1 if non-existent */
68 __u8 num_received; /* how many contacts we received */
69 __u8 num_expected; /* expected last contact index */
71 bool curvalid; /* is the current contact valid? */
72 struct mt_slot *slots;
76 __s32 name; /* MT_CLS */
78 __s32 sn_move; /* Signal/noise ratio for move events */
79 __s32 sn_width; /* Signal/noise ratio for width events */
80 __s32 sn_height; /* Signal/noise ratio for height events */
81 __s32 sn_pressure; /* Signal/noise ratio for pressure events */
85 /* classes of device behavior */
86 #define MT_CLS_DEFAULT 1
87 #define MT_CLS_DUAL_INRANGE_CONTACTID 2
88 #define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 3
89 #define MT_CLS_CYPRESS 4
90 #define MT_CLS_EGALAX 5
91 #define MT_CLS_STANTUM 6
93 #define MT_CLS_CONFIDENCE 8
94 #define MT_CLS_CONFIDENCE_MINUS_ONE 9
95 #define MT_CLS_DUAL_NSMU_CONTACTID 10
97 #define MT_DEFAULT_MAXCONTACT 10
100 * these device-dependent functions determine what slot corresponds
101 * to a valid contact that was just read.
104 static int cypress_compute_slot(struct mt_device *td)
106 if (td->curdata.contactid != 0 || td->num_received == 0)
107 return td->curdata.contactid;
112 static int find_slot_from_contactid(struct mt_device *td)
115 for (i = 0; i < td->maxcontacts; ++i) {
116 if (td->slots[i].contactid == td->curdata.contactid &&
117 td->slots[i].touch_state)
120 for (i = 0; i < td->maxcontacts; ++i) {
121 if (!td->slots[i].seen_in_this_frame &&
122 !td->slots[i].touch_state)
125 /* should not occurs. If this happens that means
126 * that the device sent more touches that it says
127 * in the report descriptor. It is ignored then. */
131 struct mt_class mt_classes[] = {
132 { .name = MT_CLS_DEFAULT,
133 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
134 { .name = MT_CLS_DUAL_INRANGE_CONTACTID,
135 .quirks = MT_QUIRK_VALID_IS_INRANGE |
136 MT_QUIRK_SLOT_IS_CONTACTID,
138 { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
139 .quirks = MT_QUIRK_VALID_IS_INRANGE |
140 MT_QUIRK_SLOT_IS_CONTACTNUMBER,
142 { .name = MT_CLS_CYPRESS,
143 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
146 { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
147 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
148 MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
149 { .name = MT_CLS_EGALAX,
150 .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
151 MT_QUIRK_VALID_IS_INRANGE |
152 MT_QUIRK_EGALAX_XYZ_FIXUP,
157 { .name = MT_CLS_STANTUM,
158 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
160 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
161 MT_QUIRK_SLOT_IS_CONTACTID,
165 { .name = MT_CLS_CONFIDENCE,
166 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
167 { .name = MT_CLS_DUAL_NSMU_CONTACTID,
168 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
169 MT_QUIRK_SLOT_IS_CONTACTID,
175 static void mt_feature_mapping(struct hid_device *hdev,
176 struct hid_field *field, struct hid_usage *usage)
178 struct mt_device *td = hid_get_drvdata(hdev);
180 switch (usage->hid) {
181 case HID_DG_INPUTMODE:
182 td->inputmode = field->report->id;
184 case HID_DG_CONTACTMAX:
185 td->maxcontacts = field->value[0];
186 if (td->mtclass->maxcontacts)
187 /* check if the maxcontacts is given by the class */
188 td->maxcontacts = td->mtclass->maxcontacts;
194 static void set_abs(struct input_dev *input, unsigned int code,
195 struct hid_field *field, int snratio)
197 int fmin = field->logical_minimum;
198 int fmax = field->logical_maximum;
199 int fuzz = snratio ? (fmax - fmin) / snratio : 0;
200 input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
203 static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
204 struct hid_field *field, struct hid_usage *usage,
205 unsigned long **bit, int *max)
207 struct mt_device *td = hid_get_drvdata(hdev);
208 struct mt_class *cls = td->mtclass;
209 __s32 quirks = cls->quirks;
211 switch (usage->hid & HID_USAGE_PAGE) {
214 switch (usage->hid) {
216 if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
217 field->logical_maximum = 32760;
218 hid_map_usage(hi, usage, bit, max,
219 EV_ABS, ABS_MT_POSITION_X);
220 set_abs(hi->input, ABS_MT_POSITION_X, field,
222 td->last_slot_field = usage->hid;
223 td->last_field_index = field->index;
226 if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
227 field->logical_maximum = 32760;
228 hid_map_usage(hi, usage, bit, max,
229 EV_ABS, ABS_MT_POSITION_Y);
230 set_abs(hi->input, ABS_MT_POSITION_Y, field,
232 td->last_slot_field = usage->hid;
233 td->last_field_index = field->index;
238 case HID_UP_DIGITIZER:
239 switch (usage->hid) {
241 hid_map_usage(hi, usage, bit, max, EV_KEY,
243 input_set_capability(hi->input, EV_KEY,
245 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field, 0);
246 td->last_slot_field = usage->hid;
247 td->last_field_index = field->index;
249 case HID_DG_CONFIDENCE:
250 hid_map_usage(hi, usage, bit, max, EV_KEY,
252 input_set_capability(hi->input, EV_KEY,
254 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field, 0);
255 td->last_slot_field = usage->hid;
256 td->last_field_index = field->index;
258 case HID_DG_TIPSWITCH:
259 hid_map_usage(hi, usage, bit, max, EV_KEY,
261 input_set_capability(hi->input, EV_KEY,
263 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field, 0);
264 td->last_slot_field = usage->hid;
265 td->last_field_index = field->index;
267 case HID_DG_CONTACTID:
268 hid_map_usage(hi, usage, bit, max, EV_KEY,
270 input_set_capability(hi->input, EV_KEY,
272 set_abs(hi->input, ABS_MT_TRACKING_ID, field, 0);
273 td->last_slot_field = usage->hid;
274 td->last_field_index = field->index;
277 hid_map_usage(hi, usage, bit, max, EV_KEY,
279 input_set_capability(hi->input, EV_KEY,
281 set_abs(hi->input, ABS_MT_WIDTH_MAJOR, field, 0);
282 td->last_slot_field = usage->hid;
283 td->last_field_index = field->index;
286 hid_map_usage(hi, usage, bit, max,
287 EV_ABS, ABS_MT_WIDTH_MINOR);
288 input_set_capability(hi->input, EV_KEY,
290 set_abs(hi->input, ABS_MT_WIDTH_MINOR, field, 0);
291 td->last_slot_field = usage->hid;
292 td->last_field_index = field->index;
294 case HID_DG_TIPPRESSURE:
295 if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
296 field->logical_minimum = 0;
297 hid_map_usage(hi, usage, bit, max,
298 EV_ABS, ABS_MT_PRESSURE);
299 set_abs(hi->input, ABS_MT_PRESSURE, field,
301 /* touchscreen emulation */
302 set_abs(hi->input, ABS_PRESSURE, field,
304 td->last_slot_field = usage->hid;
305 td->last_field_index = field->index;
307 case HID_DG_CONTACTCOUNT:
308 td->last_field_index = field->index;
310 case HID_DG_CONTACTMAX:
311 /* we don't set td->last_slot_field as contactcount and
312 * contact max are global to the report */
313 td->last_field_index = field->index;
316 /* let hid-input decide for the others */
320 /* we do not want to map these: no input-oriented meaning */
327 static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
328 struct hid_field *field, struct hid_usage *usage,
329 unsigned long **bit, int *max)
331 if (usage->type == EV_KEY || usage->type == EV_ABS)
332 set_bit(usage->type, hi->input->evbit);
337 static int mt_compute_slot(struct mt_device *td)
339 __s32 quirks = td->mtclass->quirks;
341 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
342 return td->curdata.contactid;
344 if (quirks & MT_QUIRK_CYPRESS)
345 return cypress_compute_slot(td);
347 if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
348 return td->num_received;
350 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
351 return td->curdata.contactid - 1;
353 return find_slot_from_contactid(td);
357 * this function is called when a whole contact has been processed,
358 * so that it can assign it to a slot and store the data there
360 static void mt_complete_slot(struct mt_device *td)
362 td->curdata.seen_in_this_frame = true;
364 int slotnum = mt_compute_slot(td);
366 if (slotnum >= 0 && slotnum < td->maxcontacts)
367 td->slots[slotnum] = td->curdata;
374 * this function is called when a whole packet has been received and processed,
375 * so that it can decide what to send to the input layer.
377 static void mt_emit_event(struct mt_device *td, struct input_dev *input)
381 for (i = 0; i < td->maxcontacts; ++i) {
382 struct mt_slot *s = &(td->slots[i]);
383 if ((td->mtclass->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
384 !s->seen_in_this_frame) {
385 if (s->touch_state) {
386 s->touch_state = false;
387 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, s->touch_state);
388 input_mt_sync(input);
390 s->seen_in_this_frame = false;
394 if (!s->seen_in_this_frame)
397 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, s->touch_state);
398 if (s->touch_state) {
399 /* this finger is on the screen */
400 int wide = (s->w > s->h);
401 /* divided by two to match visual scale of touch */
402 int major = max(s->w, s->h) >> 1;
403 int minor = min(s->w, s->h) >> 1;
405 input_event(input, EV_ABS, ABS_MT_TRACKING_ID, s->contactid);
406 input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
407 input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
408 input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
409 input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
410 input_event(input, EV_ABS, ABS_MT_WIDTH_MAJOR, major);
411 input_event(input, EV_ABS, ABS_MT_WIDTH_MINOR, minor);
413 input_mt_sync(input);
414 s->seen_in_this_frame = false;
419 td->num_received = 0;
424 static int mt_event(struct hid_device *hid, struct hid_field *field,
425 struct hid_usage *usage, __s32 value)
427 struct mt_device *td = hid_get_drvdata(hid);
428 __s32 quirks = td->mtclass->quirks;
430 if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
431 switch (usage->hid) {
433 if (quirks & MT_QUIRK_VALID_IS_INRANGE)
434 td->curvalid = value;
436 case HID_DG_TIPSWITCH:
437 if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
438 td->curvalid = value;
439 td->curdata.touch_state = value;
441 case HID_DG_CONFIDENCE:
442 if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
443 td->curvalid = value;
445 case HID_DG_CONTACTID:
446 td->curdata.contactid = value;
448 case HID_DG_TIPPRESSURE:
449 td->curdata.p = value;
452 td->curdata.x = value;
455 td->curdata.y = value;
458 td->curdata.w = value;
461 td->curdata.h = value;
463 case HID_DG_CONTACTCOUNT:
465 * Includes multi-packet support where subsequent
466 * packets are sent with zero contactcount.
469 td->num_expected = value;
473 /* fallback to the generic hidinput handling */
477 if (usage->hid == td->last_slot_field) {
478 mt_complete_slot(td);
481 if (field->index == td->last_field_index
482 && td->num_received >= td->num_expected)
483 mt_emit_event(td, field->hidinput->input);
487 /* we have handled the hidinput part, now remains hiddev */
488 if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
489 hid->hiddev_hid_event(hid, field, usage, value);
494 static void mt_set_input_mode(struct hid_device *hdev)
496 struct mt_device *td = hid_get_drvdata(hdev);
497 struct hid_report *r;
498 struct hid_report_enum *re;
500 if (td->inputmode < 0)
503 re = &(hdev->report_enum[HID_FEATURE_REPORT]);
504 r = re->report_id_hash[td->inputmode];
506 r->field[0]->value[0] = 0x02;
507 usbhid_submit_report(hdev, r, USB_DIR_OUT);
511 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
514 struct mt_device *td;
515 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
517 for (i = 0; mt_classes[i].name ; i++) {
518 if (id->driver_data == mt_classes[i].name) {
519 mtclass = &(mt_classes[i]);
524 /* This allows the driver to correctly support devices
525 * that emit events over several HID messages.
527 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
529 td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
531 dev_err(&hdev->dev, "cannot allocate multitouch data\n");
534 td->mtclass = mtclass;
536 hid_set_drvdata(hdev, td);
538 ret = hid_parse(hdev);
542 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
546 if (!td->maxcontacts)
547 td->maxcontacts = MT_DEFAULT_MAXCONTACT;
549 td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
552 dev_err(&hdev->dev, "cannot allocate multitouch slots\n");
558 mt_set_input_mode(hdev);
568 static int mt_reset_resume(struct hid_device *hdev)
570 mt_set_input_mode(hdev);
575 static void mt_remove(struct hid_device *hdev)
577 struct mt_device *td = hid_get_drvdata(hdev);
581 hid_set_drvdata(hdev, NULL);
584 static const struct hid_device_id mt_devices[] = {
587 { .driver_data = MT_CLS_3M,
588 HID_USB_DEVICE(USB_VENDOR_ID_3M,
589 USB_DEVICE_ID_3M1968) },
590 { .driver_data = MT_CLS_3M,
591 HID_USB_DEVICE(USB_VENDOR_ID_3M,
592 USB_DEVICE_ID_3M2256) },
594 /* ActionStar panels */
595 { .driver_data = MT_CLS_DEFAULT,
596 HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
597 USB_DEVICE_ID_ACTIONSTAR_1011) },
600 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
601 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
602 USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
603 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
604 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
605 USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
606 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
607 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
608 USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
609 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
610 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
611 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
614 { .driver_data = MT_CLS_DEFAULT,
615 HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
616 USB_DEVICE_ID_CVTOUCH_SCREEN) },
619 { .driver_data = MT_CLS_CYPRESS,
620 HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
621 USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
623 /* Elo TouchSystems IntelliTouch Plus panel */
624 { .driver_data = MT_CLS_DUAL_NSMU_CONTACTID,
625 HID_USB_DEVICE(USB_VENDOR_ID_ELO,
626 USB_DEVICE_ID_ELO_TS2515) },
628 /* GeneralTouch panel */
629 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
630 HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
631 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
633 /* GoodTouch panels */
634 { .driver_data = MT_CLS_DEFAULT,
635 HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
636 USB_DEVICE_ID_GOODTOUCH_000f) },
638 /* Ilitek dual touch panel */
639 { .driver_data = MT_CLS_DEFAULT,
640 HID_USB_DEVICE(USB_VENDOR_ID_ILITEK,
641 USB_DEVICE_ID_ILITEK_MULTITOUCH) },
644 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
645 HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
646 USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
649 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
650 HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
651 USB_DEVICE_ID_CRYSTALTOUCH) },
654 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
655 HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
656 USB_DEVICE_ID_ASUS_T91MT)},
657 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
658 HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
659 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
660 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
661 HID_USB_DEVICE(USB_VENDOR_ID_TURBOX,
662 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
664 /* PenMount panels */
665 { .driver_data = MT_CLS_CONFIDENCE,
666 HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
667 USB_DEVICE_ID_PENMOUNT_PCI) },
669 /* PixCir-based panels */
670 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
671 HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
672 USB_DEVICE_ID_HANVON_MULTITOUCH) },
673 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
674 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
675 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
677 /* Resistive eGalax devices */
678 { .driver_data = MT_CLS_EGALAX,
679 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
680 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
681 { .driver_data = MT_CLS_EGALAX,
682 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
683 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3) },
685 /* Capacitive eGalax devices */
686 { .driver_data = MT_CLS_EGALAX,
687 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
688 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
689 { .driver_data = MT_CLS_EGALAX,
690 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
691 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2) },
692 { .driver_data = MT_CLS_EGALAX,
693 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
694 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4) },
697 { .driver_data = MT_CLS_STANTUM,
698 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
700 { .driver_data = MT_CLS_STANTUM,
701 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
702 USB_DEVICE_ID_MTP_STM)},
703 { .driver_data = MT_CLS_STANTUM,
704 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
705 USB_DEVICE_ID_MTP_SITRONIX)},
709 MODULE_DEVICE_TABLE(hid, mt_devices);
711 static const struct hid_usage_id mt_grabbed_usages[] = {
712 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
713 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
716 static struct hid_driver mt_driver = {
717 .name = "hid-multitouch",
718 .id_table = mt_devices,
721 .input_mapping = mt_input_mapping,
722 .input_mapped = mt_input_mapped,
723 .feature_mapping = mt_feature_mapping,
724 .usage_table = mt_grabbed_usages,
727 .reset_resume = mt_reset_resume,
731 static int __init mt_init(void)
733 return hid_register_driver(&mt_driver);
736 static void __exit mt_exit(void)
738 hid_unregister_driver(&mt_driver);
741 module_init(mt_init);
742 module_exit(mt_exit);