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