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