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