xref: /openbmc/linux/drivers/hid/hid-multitouch.c (revision 1d5c7d0a)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  HID driver for multitouch panels
4  *
5  *  Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
6  *  Copyright (c) 2010-2013 Benjamin Tissoires <benjamin.tissoires@gmail.com>
7  *  Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
8  *  Copyright (c) 2012-2013 Red Hat, Inc
9  *
10  *  This code is partly based on hid-egalax.c:
11  *
12  *  Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
13  *  Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
14  *  Copyright (c) 2010 Canonical, Ltd.
15  *
16  *  This code is partly based on hid-3m-pct.c:
17  *
18  *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
19  *  Copyright (c) 2010      Henrik Rydberg <rydberg@euromail.se>
20  *  Copyright (c) 2010      Canonical, Ltd.
21  */
22 
23 /*
24  */
25 
26 /*
27  * This driver is regularly tested thanks to the test suite in hid-tools[1].
28  * Please run these regression tests before patching this module so that
29  * your patch won't break existing known devices.
30  *
31  * [1] https://gitlab.freedesktop.org/libevdev/hid-tools
32  */
33 
34 #include <linux/device.h>
35 #include <linux/hid.h>
36 #include <linux/module.h>
37 #include <linux/slab.h>
38 #include <linux/input/mt.h>
39 #include <linux/jiffies.h>
40 #include <linux/string.h>
41 #include <linux/timer.h>
42 
43 
44 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
45 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
46 MODULE_DESCRIPTION("HID multitouch panels");
47 MODULE_LICENSE("GPL");
48 
49 #include "hid-ids.h"
50 
51 /* quirks to control the device */
52 #define MT_QUIRK_NOT_SEEN_MEANS_UP	BIT(0)
53 #define MT_QUIRK_SLOT_IS_CONTACTID	BIT(1)
54 #define MT_QUIRK_CYPRESS		BIT(2)
55 #define MT_QUIRK_SLOT_IS_CONTACTNUMBER	BIT(3)
56 #define MT_QUIRK_ALWAYS_VALID		BIT(4)
57 #define MT_QUIRK_VALID_IS_INRANGE	BIT(5)
58 #define MT_QUIRK_VALID_IS_CONFIDENCE	BIT(6)
59 #define MT_QUIRK_CONFIDENCE		BIT(7)
60 #define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE	BIT(8)
61 #define MT_QUIRK_NO_AREA		BIT(9)
62 #define MT_QUIRK_IGNORE_DUPLICATES	BIT(10)
63 #define MT_QUIRK_HOVERING		BIT(11)
64 #define MT_QUIRK_CONTACT_CNT_ACCURATE	BIT(12)
65 #define MT_QUIRK_FORCE_GET_FEATURE	BIT(13)
66 #define MT_QUIRK_FIX_CONST_CONTACT_ID	BIT(14)
67 #define MT_QUIRK_TOUCH_SIZE_SCALING	BIT(15)
68 #define MT_QUIRK_STICKY_FINGERS		BIT(16)
69 #define MT_QUIRK_ASUS_CUSTOM_UP		BIT(17)
70 #define MT_QUIRK_WIN8_PTP_BUTTONS	BIT(18)
71 #define MT_QUIRK_SEPARATE_APP_REPORT	BIT(19)
72 #define MT_QUIRK_FORCE_MULTI_INPUT	BIT(20)
73 #define MT_QUIRK_DISABLE_WAKEUP		BIT(21)
74 #define MT_QUIRK_ORIENTATION_INVERT	BIT(22)
75 
76 #define MT_INPUTMODE_TOUCHSCREEN	0x02
77 #define MT_INPUTMODE_TOUCHPAD		0x03
78 
79 #define MT_BUTTONTYPE_CLICKPAD		0
80 
81 enum latency_mode {
82 	HID_LATENCY_NORMAL = 0,
83 	HID_LATENCY_HIGH = 1,
84 };
85 
86 #define MT_IO_FLAGS_RUNNING		0
87 #define MT_IO_FLAGS_ACTIVE_SLOTS	1
88 #define MT_IO_FLAGS_PENDING_SLOTS	2
89 
90 static const bool mtrue = true;		/* default for true */
91 static const bool mfalse;		/* default for false */
92 static const __s32 mzero;		/* default for 0 */
93 
94 #define DEFAULT_TRUE	((void *)&mtrue)
95 #define DEFAULT_FALSE	((void *)&mfalse)
96 #define DEFAULT_ZERO	((void *)&mzero)
97 
98 struct mt_usages {
99 	struct list_head list;
100 	__s32 *x, *y, *cx, *cy, *p, *w, *h, *a;
101 	__s32 *contactid;	/* the device ContactID assigned to this slot */
102 	bool *tip_state;	/* is the touch valid? */
103 	bool *inrange_state;	/* is the finger in proximity of the sensor? */
104 	bool *confidence_state;	/* is the touch made by a finger? */
105 };
106 
107 struct mt_application {
108 	struct list_head list;
109 	unsigned int application;
110 	unsigned int report_id;
111 	struct list_head mt_usages;	/* mt usages list */
112 
113 	__s32 quirks;
114 
115 	__s32 *scantime;		/* scantime reported */
116 	__s32 scantime_logical_max;	/* max value for raw scantime */
117 
118 	__s32 *raw_cc;			/* contact count in the report */
119 	int left_button_state;		/* left button state */
120 	unsigned int mt_flags;		/* flags to pass to input-mt */
121 
122 	unsigned long *pending_palm_slots;	/* slots where we reported palm
123 						 * and need to release */
124 
125 	__u8 num_received;	/* how many contacts we received */
126 	__u8 num_expected;	/* expected last contact index */
127 	__u8 buttons_count;	/* number of physical buttons per touchpad */
128 	__u8 touches_by_report;	/* how many touches are present in one report:
129 				 * 1 means we should use a serial protocol
130 				 * > 1 means hybrid (multitouch) protocol
131 				 */
132 
133 	__s32 dev_time;		/* the scan time provided by the device */
134 	unsigned long jiffies;	/* the frame's jiffies */
135 	int timestamp;		/* the timestamp to be sent */
136 	int prev_scantime;		/* scantime reported previously */
137 
138 	bool have_contact_count;
139 };
140 
141 struct mt_class {
142 	__s32 name;	/* MT_CLS */
143 	__s32 quirks;
144 	__s32 sn_move;	/* Signal/noise ratio for move events */
145 	__s32 sn_width;	/* Signal/noise ratio for width events */
146 	__s32 sn_height;	/* Signal/noise ratio for height events */
147 	__s32 sn_pressure;	/* Signal/noise ratio for pressure events */
148 	__u8 maxcontacts;
149 	bool is_indirect;	/* true for touchpads */
150 	bool export_all_inputs;	/* do not ignore mouse, keyboards, etc... */
151 };
152 
153 struct mt_report_data {
154 	struct list_head list;
155 	struct hid_report *report;
156 	struct mt_application *application;
157 	bool is_mt_collection;
158 };
159 
160 struct mt_device {
161 	struct mt_class mtclass;	/* our mt device class */
162 	struct timer_list release_timer;	/* to release sticky fingers */
163 	struct hid_device *hdev;	/* hid_device we're attached to */
164 	unsigned long mt_io_flags;	/* mt flags (MT_IO_FLAGS_*) */
165 	__u8 inputmode_value;	/* InputMode HID feature value */
166 	__u8 maxcontacts;
167 	bool is_buttonpad;	/* is this device a button pad? */
168 	bool serial_maybe;	/* need to check for serial protocol */
169 
170 	struct list_head applications;
171 	struct list_head reports;
172 };
173 
174 static void mt_post_parse_default_settings(struct mt_device *td,
175 					   struct mt_application *app);
176 static void mt_post_parse(struct mt_device *td, struct mt_application *app);
177 
178 /* classes of device behavior */
179 #define MT_CLS_DEFAULT				0x0001
180 
181 #define MT_CLS_SERIAL				0x0002
182 #define MT_CLS_CONFIDENCE			0x0003
183 #define MT_CLS_CONFIDENCE_CONTACT_ID		0x0004
184 #define MT_CLS_CONFIDENCE_MINUS_ONE		0x0005
185 #define MT_CLS_DUAL_INRANGE_CONTACTID		0x0006
186 #define MT_CLS_DUAL_INRANGE_CONTACTNUMBER	0x0007
187 /* reserved					0x0008 */
188 #define MT_CLS_INRANGE_CONTACTNUMBER		0x0009
189 #define MT_CLS_NSMU				0x000a
190 /* reserved					0x0010 */
191 /* reserved					0x0011 */
192 #define MT_CLS_WIN_8				0x0012
193 #define MT_CLS_EXPORT_ALL_INPUTS		0x0013
194 /* reserved					0x0014 */
195 #define MT_CLS_WIN_8_FORCE_MULTI_INPUT		0x0015
196 #define MT_CLS_WIN_8_DISABLE_WAKEUP		0x0016
197 #define MT_CLS_WIN_8_NO_STICKY_FINGERS		0x0017
198 #define MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU	0x0018
199 
200 /* vendor specific classes */
201 #define MT_CLS_3M				0x0101
202 /* reserved					0x0102 */
203 #define MT_CLS_EGALAX				0x0103
204 #define MT_CLS_EGALAX_SERIAL			0x0104
205 #define MT_CLS_TOPSEED				0x0105
206 #define MT_CLS_PANASONIC			0x0106
207 #define MT_CLS_FLATFROG				0x0107
208 #define MT_CLS_GENERALTOUCH_TWOFINGERS		0x0108
209 #define MT_CLS_GENERALTOUCH_PWT_TENFINGERS	0x0109
210 #define MT_CLS_LG				0x010a
211 #define MT_CLS_ASUS				0x010b
212 #define MT_CLS_VTL				0x0110
213 #define MT_CLS_GOOGLE				0x0111
214 #define MT_CLS_RAZER_BLADE_STEALTH		0x0112
215 #define MT_CLS_SMART_TECH			0x0113
216 
217 #define MT_DEFAULT_MAXCONTACT	10
218 #define MT_MAX_MAXCONTACT	250
219 
220 /*
221  * Resync device and local timestamps after that many microseconds without
222  * receiving data.
223  */
224 #define MAX_TIMESTAMP_INTERVAL	1000000
225 
226 #define MT_USB_DEVICE(v, p)	HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p)
227 #define MT_BT_DEVICE(v, p)	HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p)
228 
229 /*
230  * these device-dependent functions determine what slot corresponds
231  * to a valid contact that was just read.
232  */
233 
cypress_compute_slot(struct mt_application * application,struct mt_usages * slot)234 static int cypress_compute_slot(struct mt_application *application,
235 				struct mt_usages *slot)
236 {
237 	if (*slot->contactid != 0 || application->num_received == 0)
238 		return *slot->contactid;
239 	else
240 		return -1;
241 }
242 
243 static const struct mt_class mt_classes[] = {
244 	{ .name = MT_CLS_DEFAULT,
245 		.quirks = MT_QUIRK_ALWAYS_VALID |
246 			MT_QUIRK_CONTACT_CNT_ACCURATE },
247 	{ .name = MT_CLS_NSMU,
248 		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
249 	{ .name = MT_CLS_SERIAL,
250 		.quirks = MT_QUIRK_ALWAYS_VALID},
251 	{ .name = MT_CLS_CONFIDENCE,
252 		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
253 	{ .name = MT_CLS_CONFIDENCE_CONTACT_ID,
254 		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
255 			MT_QUIRK_SLOT_IS_CONTACTID },
256 	{ .name = MT_CLS_CONFIDENCE_MINUS_ONE,
257 		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
258 			MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
259 	{ .name = MT_CLS_DUAL_INRANGE_CONTACTID,
260 		.quirks = MT_QUIRK_VALID_IS_INRANGE |
261 			MT_QUIRK_SLOT_IS_CONTACTID,
262 		.maxcontacts = 2 },
263 	{ .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
264 		.quirks = MT_QUIRK_VALID_IS_INRANGE |
265 			MT_QUIRK_SLOT_IS_CONTACTNUMBER,
266 		.maxcontacts = 2 },
267 	{ .name = MT_CLS_INRANGE_CONTACTNUMBER,
268 		.quirks = MT_QUIRK_VALID_IS_INRANGE |
269 			MT_QUIRK_SLOT_IS_CONTACTNUMBER },
270 	{ .name = MT_CLS_WIN_8,
271 		.quirks = MT_QUIRK_ALWAYS_VALID |
272 			MT_QUIRK_IGNORE_DUPLICATES |
273 			MT_QUIRK_HOVERING |
274 			MT_QUIRK_CONTACT_CNT_ACCURATE |
275 			MT_QUIRK_STICKY_FINGERS |
276 			MT_QUIRK_WIN8_PTP_BUTTONS,
277 		.export_all_inputs = true },
278 	{ .name = MT_CLS_EXPORT_ALL_INPUTS,
279 		.quirks = MT_QUIRK_ALWAYS_VALID |
280 			MT_QUIRK_CONTACT_CNT_ACCURATE,
281 		.export_all_inputs = true },
282 	{ .name = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
283 		.quirks = MT_QUIRK_ALWAYS_VALID |
284 			MT_QUIRK_IGNORE_DUPLICATES |
285 			MT_QUIRK_HOVERING |
286 			MT_QUIRK_CONTACT_CNT_ACCURATE |
287 			MT_QUIRK_STICKY_FINGERS |
288 			MT_QUIRK_WIN8_PTP_BUTTONS |
289 			MT_QUIRK_FORCE_MULTI_INPUT,
290 		.export_all_inputs = true },
291 	{ .name = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
292 		.quirks = MT_QUIRK_IGNORE_DUPLICATES |
293 			MT_QUIRK_HOVERING |
294 			MT_QUIRK_CONTACT_CNT_ACCURATE |
295 			MT_QUIRK_STICKY_FINGERS |
296 			MT_QUIRK_WIN8_PTP_BUTTONS |
297 			MT_QUIRK_FORCE_MULTI_INPUT |
298 			MT_QUIRK_NOT_SEEN_MEANS_UP,
299 		.export_all_inputs = true },
300 	{ .name = MT_CLS_WIN_8_DISABLE_WAKEUP,
301 		.quirks = MT_QUIRK_ALWAYS_VALID |
302 			MT_QUIRK_IGNORE_DUPLICATES |
303 			MT_QUIRK_HOVERING |
304 			MT_QUIRK_CONTACT_CNT_ACCURATE |
305 			MT_QUIRK_STICKY_FINGERS |
306 			MT_QUIRK_WIN8_PTP_BUTTONS |
307 			MT_QUIRK_DISABLE_WAKEUP,
308 		.export_all_inputs = true },
309 	{ .name = MT_CLS_WIN_8_NO_STICKY_FINGERS,
310 		.quirks = MT_QUIRK_ALWAYS_VALID |
311 			MT_QUIRK_IGNORE_DUPLICATES |
312 			MT_QUIRK_HOVERING |
313 			MT_QUIRK_CONTACT_CNT_ACCURATE |
314 			MT_QUIRK_WIN8_PTP_BUTTONS,
315 		.export_all_inputs = true },
316 
317 	/*
318 	 * vendor specific classes
319 	 */
320 	{ .name = MT_CLS_3M,
321 		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
322 			MT_QUIRK_SLOT_IS_CONTACTID |
323 			MT_QUIRK_TOUCH_SIZE_SCALING,
324 		.sn_move = 2048,
325 		.sn_width = 128,
326 		.sn_height = 128,
327 		.maxcontacts = 60,
328 	},
329 	{ .name = MT_CLS_EGALAX,
330 		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
331 			MT_QUIRK_VALID_IS_INRANGE,
332 		.sn_move = 4096,
333 		.sn_pressure = 32,
334 	},
335 	{ .name = MT_CLS_EGALAX_SERIAL,
336 		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
337 			MT_QUIRK_ALWAYS_VALID,
338 		.sn_move = 4096,
339 		.sn_pressure = 32,
340 	},
341 	{ .name = MT_CLS_TOPSEED,
342 		.quirks = MT_QUIRK_ALWAYS_VALID,
343 		.is_indirect = true,
344 		.maxcontacts = 2,
345 	},
346 	{ .name = MT_CLS_PANASONIC,
347 		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
348 		.maxcontacts = 4 },
349 	{ .name	= MT_CLS_GENERALTOUCH_TWOFINGERS,
350 		.quirks	= MT_QUIRK_NOT_SEEN_MEANS_UP |
351 			MT_QUIRK_VALID_IS_INRANGE |
352 			MT_QUIRK_SLOT_IS_CONTACTID,
353 		.maxcontacts = 2
354 	},
355 	{ .name	= MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
356 		.quirks	= MT_QUIRK_NOT_SEEN_MEANS_UP |
357 			MT_QUIRK_SLOT_IS_CONTACTID
358 	},
359 
360 	{ .name = MT_CLS_FLATFROG,
361 		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
362 			MT_QUIRK_NO_AREA,
363 		.sn_move = 2048,
364 		.maxcontacts = 40,
365 	},
366 	{ .name = MT_CLS_LG,
367 		.quirks = MT_QUIRK_ALWAYS_VALID |
368 			MT_QUIRK_FIX_CONST_CONTACT_ID |
369 			MT_QUIRK_IGNORE_DUPLICATES |
370 			MT_QUIRK_HOVERING |
371 			MT_QUIRK_CONTACT_CNT_ACCURATE },
372 	{ .name = MT_CLS_ASUS,
373 		.quirks = MT_QUIRK_ALWAYS_VALID |
374 			MT_QUIRK_CONTACT_CNT_ACCURATE |
375 			MT_QUIRK_ASUS_CUSTOM_UP },
376 	{ .name = MT_CLS_VTL,
377 		.quirks = MT_QUIRK_ALWAYS_VALID |
378 			MT_QUIRK_CONTACT_CNT_ACCURATE |
379 			MT_QUIRK_FORCE_GET_FEATURE,
380 	},
381 	{ .name = MT_CLS_GOOGLE,
382 		.quirks = MT_QUIRK_ALWAYS_VALID |
383 			MT_QUIRK_CONTACT_CNT_ACCURATE |
384 			MT_QUIRK_SLOT_IS_CONTACTID |
385 			MT_QUIRK_HOVERING
386 	},
387 	{ .name = MT_CLS_RAZER_BLADE_STEALTH,
388 		.quirks = MT_QUIRK_ALWAYS_VALID |
389 			MT_QUIRK_IGNORE_DUPLICATES |
390 			MT_QUIRK_HOVERING |
391 			MT_QUIRK_CONTACT_CNT_ACCURATE |
392 			MT_QUIRK_WIN8_PTP_BUTTONS,
393 	},
394 	{ .name = MT_CLS_SMART_TECH,
395 		.quirks = MT_QUIRK_ALWAYS_VALID |
396 			MT_QUIRK_IGNORE_DUPLICATES |
397 			MT_QUIRK_CONTACT_CNT_ACCURATE |
398 			MT_QUIRK_SEPARATE_APP_REPORT,
399 	},
400 	{ }
401 };
402 
mt_show_quirks(struct device * dev,struct device_attribute * attr,char * buf)403 static ssize_t mt_show_quirks(struct device *dev,
404 			   struct device_attribute *attr,
405 			   char *buf)
406 {
407 	struct hid_device *hdev = to_hid_device(dev);
408 	struct mt_device *td = hid_get_drvdata(hdev);
409 
410 	return sprintf(buf, "%u\n", td->mtclass.quirks);
411 }
412 
mt_set_quirks(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)413 static ssize_t mt_set_quirks(struct device *dev,
414 			  struct device_attribute *attr,
415 			  const char *buf, size_t count)
416 {
417 	struct hid_device *hdev = to_hid_device(dev);
418 	struct mt_device *td = hid_get_drvdata(hdev);
419 	struct mt_application *application;
420 
421 	unsigned long val;
422 
423 	if (kstrtoul(buf, 0, &val))
424 		return -EINVAL;
425 
426 	td->mtclass.quirks = val;
427 
428 	list_for_each_entry(application, &td->applications, list) {
429 		application->quirks = val;
430 		if (!application->have_contact_count)
431 			application->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
432 	}
433 
434 	return count;
435 }
436 
437 static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
438 
439 static struct attribute *sysfs_attrs[] = {
440 	&dev_attr_quirks.attr,
441 	NULL
442 };
443 
444 static const struct attribute_group mt_attribute_group = {
445 	.attrs = sysfs_attrs
446 };
447 
mt_get_feature(struct hid_device * hdev,struct hid_report * report)448 static void mt_get_feature(struct hid_device *hdev, struct hid_report *report)
449 {
450 	int ret;
451 	u32 size = hid_report_len(report);
452 	u8 *buf;
453 
454 	/*
455 	 * Do not fetch the feature report if the device has been explicitly
456 	 * marked as non-capable.
457 	 */
458 	if (hdev->quirks & HID_QUIRK_NO_INIT_REPORTS)
459 		return;
460 
461 	buf = hid_alloc_report_buf(report, GFP_KERNEL);
462 	if (!buf)
463 		return;
464 
465 	ret = hid_hw_raw_request(hdev, report->id, buf, size,
466 				 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
467 	if (ret < 0) {
468 		dev_warn(&hdev->dev, "failed to fetch feature %d\n",
469 			 report->id);
470 	} else {
471 		ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf,
472 					   size, 0);
473 		if (ret)
474 			dev_warn(&hdev->dev, "failed to report feature\n");
475 	}
476 
477 	kfree(buf);
478 }
479 
mt_feature_mapping(struct hid_device * hdev,struct hid_field * field,struct hid_usage * usage)480 static void mt_feature_mapping(struct hid_device *hdev,
481 		struct hid_field *field, struct hid_usage *usage)
482 {
483 	struct mt_device *td = hid_get_drvdata(hdev);
484 
485 	switch (usage->hid) {
486 	case HID_DG_CONTACTMAX:
487 		mt_get_feature(hdev, field->report);
488 
489 		td->maxcontacts = field->value[0];
490 		if (!td->maxcontacts &&
491 		    field->logical_maximum <= MT_MAX_MAXCONTACT)
492 			td->maxcontacts = field->logical_maximum;
493 		if (td->mtclass.maxcontacts)
494 			/* check if the maxcontacts is given by the class */
495 			td->maxcontacts = td->mtclass.maxcontacts;
496 
497 		break;
498 	case HID_DG_BUTTONTYPE:
499 		if (usage->usage_index >= field->report_count) {
500 			dev_err(&hdev->dev, "HID_DG_BUTTONTYPE out of range\n");
501 			break;
502 		}
503 
504 		mt_get_feature(hdev, field->report);
505 		if (field->value[usage->usage_index] == MT_BUTTONTYPE_CLICKPAD)
506 			td->is_buttonpad = true;
507 
508 		break;
509 	case 0xff0000c5:
510 		/* Retrieve the Win8 blob once to enable some devices */
511 		if (usage->usage_index == 0)
512 			mt_get_feature(hdev, field->report);
513 		break;
514 	}
515 }
516 
set_abs(struct input_dev * input,unsigned int code,struct hid_field * field,int snratio)517 static void set_abs(struct input_dev *input, unsigned int code,
518 		struct hid_field *field, int snratio)
519 {
520 	int fmin = field->logical_minimum;
521 	int fmax = field->logical_maximum;
522 	int fuzz = snratio ? (fmax - fmin) / snratio : 0;
523 	input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
524 	input_abs_set_res(input, code, hidinput_calc_abs_res(field, code));
525 }
526 
mt_allocate_usage(struct hid_device * hdev,struct mt_application * application)527 static struct mt_usages *mt_allocate_usage(struct hid_device *hdev,
528 					   struct mt_application *application)
529 {
530 	struct mt_usages *usage;
531 
532 	usage = devm_kzalloc(&hdev->dev, sizeof(*usage), GFP_KERNEL);
533 	if (!usage)
534 		return NULL;
535 
536 	/* set some defaults so we do not need to check for null pointers */
537 	usage->x = DEFAULT_ZERO;
538 	usage->y = DEFAULT_ZERO;
539 	usage->cx = DEFAULT_ZERO;
540 	usage->cy = DEFAULT_ZERO;
541 	usage->p = DEFAULT_ZERO;
542 	usage->w = DEFAULT_ZERO;
543 	usage->h = DEFAULT_ZERO;
544 	usage->a = DEFAULT_ZERO;
545 	usage->contactid = DEFAULT_ZERO;
546 	usage->tip_state = DEFAULT_FALSE;
547 	usage->inrange_state = DEFAULT_FALSE;
548 	usage->confidence_state = DEFAULT_TRUE;
549 
550 	list_add_tail(&usage->list, &application->mt_usages);
551 
552 	return usage;
553 }
554 
mt_allocate_application(struct mt_device * td,struct hid_report * report)555 static struct mt_application *mt_allocate_application(struct mt_device *td,
556 						      struct hid_report *report)
557 {
558 	unsigned int application = report->application;
559 	struct mt_application *mt_application;
560 
561 	mt_application = devm_kzalloc(&td->hdev->dev, sizeof(*mt_application),
562 				      GFP_KERNEL);
563 	if (!mt_application)
564 		return NULL;
565 
566 	mt_application->application = application;
567 	INIT_LIST_HEAD(&mt_application->mt_usages);
568 
569 	if (application == HID_DG_TOUCHSCREEN)
570 		mt_application->mt_flags |= INPUT_MT_DIRECT;
571 
572 	/*
573 	 * Model touchscreens providing buttons as touchpads.
574 	 */
575 	if (application == HID_DG_TOUCHPAD) {
576 		mt_application->mt_flags |= INPUT_MT_POINTER;
577 		td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
578 	}
579 
580 	mt_application->scantime = DEFAULT_ZERO;
581 	mt_application->raw_cc = DEFAULT_ZERO;
582 	mt_application->quirks = td->mtclass.quirks;
583 	mt_application->report_id = report->id;
584 
585 	list_add_tail(&mt_application->list, &td->applications);
586 
587 	return mt_application;
588 }
589 
mt_find_application(struct mt_device * td,struct hid_report * report)590 static struct mt_application *mt_find_application(struct mt_device *td,
591 						  struct hid_report *report)
592 {
593 	unsigned int application = report->application;
594 	struct mt_application *tmp, *mt_application = NULL;
595 
596 	list_for_each_entry(tmp, &td->applications, list) {
597 		if (application == tmp->application) {
598 			if (!(td->mtclass.quirks & MT_QUIRK_SEPARATE_APP_REPORT) ||
599 			    tmp->report_id == report->id) {
600 				mt_application = tmp;
601 				break;
602 			}
603 		}
604 	}
605 
606 	if (!mt_application)
607 		mt_application = mt_allocate_application(td, report);
608 
609 	return mt_application;
610 }
611 
mt_allocate_report_data(struct mt_device * td,struct hid_report * report)612 static struct mt_report_data *mt_allocate_report_data(struct mt_device *td,
613 						      struct hid_report *report)
614 {
615 	struct mt_report_data *rdata;
616 	struct hid_field *field;
617 	int r, n;
618 
619 	rdata = devm_kzalloc(&td->hdev->dev, sizeof(*rdata), GFP_KERNEL);
620 	if (!rdata)
621 		return NULL;
622 
623 	rdata->report = report;
624 	rdata->application = mt_find_application(td, report);
625 
626 	if (!rdata->application) {
627 		devm_kfree(&td->hdev->dev, rdata);
628 		return NULL;
629 	}
630 
631 	for (r = 0; r < report->maxfield; r++) {
632 		field = report->field[r];
633 
634 		if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
635 			continue;
636 
637 		if (field->logical == HID_DG_FINGER || td->hdev->group != HID_GROUP_MULTITOUCH_WIN_8) {
638 			for (n = 0; n < field->report_count; n++) {
639 				if (field->usage[n].hid == HID_DG_CONTACTID) {
640 					rdata->is_mt_collection = true;
641 					break;
642 				}
643 			}
644 		}
645 	}
646 
647 	list_add_tail(&rdata->list, &td->reports);
648 
649 	return rdata;
650 }
651 
mt_find_report_data(struct mt_device * td,struct hid_report * report)652 static struct mt_report_data *mt_find_report_data(struct mt_device *td,
653 						  struct hid_report *report)
654 {
655 	struct mt_report_data *tmp, *rdata = NULL;
656 
657 	list_for_each_entry(tmp, &td->reports, list) {
658 		if (report == tmp->report) {
659 			rdata = tmp;
660 			break;
661 		}
662 	}
663 
664 	if (!rdata)
665 		rdata = mt_allocate_report_data(td, report);
666 
667 	return rdata;
668 }
669 
mt_store_field(struct hid_device * hdev,struct mt_application * application,__s32 * value,size_t offset)670 static void mt_store_field(struct hid_device *hdev,
671 			   struct mt_application *application,
672 			   __s32 *value,
673 			   size_t offset)
674 {
675 	struct mt_usages *usage;
676 	__s32 **target;
677 
678 	if (list_empty(&application->mt_usages))
679 		usage = mt_allocate_usage(hdev, application);
680 	else
681 		usage = list_last_entry(&application->mt_usages,
682 					struct mt_usages,
683 					list);
684 
685 	if (!usage)
686 		return;
687 
688 	target = (__s32 **)((char *)usage + offset);
689 
690 	/* the value has already been filled, create a new slot */
691 	if (*target != DEFAULT_TRUE &&
692 	    *target != DEFAULT_FALSE &&
693 	    *target != DEFAULT_ZERO) {
694 		if (usage->contactid == DEFAULT_ZERO ||
695 		    usage->x == DEFAULT_ZERO ||
696 		    usage->y == DEFAULT_ZERO) {
697 			hid_dbg(hdev,
698 				"ignoring duplicate usage on incomplete");
699 			return;
700 		}
701 		usage = mt_allocate_usage(hdev, application);
702 		if (!usage)
703 			return;
704 
705 		target = (__s32 **)((char *)usage + offset);
706 	}
707 
708 	*target = value;
709 }
710 
711 #define MT_STORE_FIELD(__name)						\
712 	mt_store_field(hdev, app,					\
713 		       &field->value[usage->usage_index],		\
714 		       offsetof(struct mt_usages, __name))
715 
mt_touch_input_mapping(struct hid_device * hdev,struct hid_input * hi,struct hid_field * field,struct hid_usage * usage,unsigned long ** bit,int * max,struct mt_application * app)716 static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
717 		struct hid_field *field, struct hid_usage *usage,
718 		unsigned long **bit, int *max, struct mt_application *app)
719 {
720 	struct mt_device *td = hid_get_drvdata(hdev);
721 	struct mt_class *cls = &td->mtclass;
722 	int code;
723 	struct hid_usage *prev_usage = NULL;
724 
725 	/*
726 	 * Model touchscreens providing buttons as touchpads.
727 	 */
728 	if (field->application == HID_DG_TOUCHSCREEN &&
729 	    (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
730 		app->mt_flags |= INPUT_MT_POINTER;
731 		td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
732 	}
733 
734 	/* count the buttons on touchpads */
735 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
736 		app->buttons_count++;
737 
738 	if (usage->usage_index)
739 		prev_usage = &field->usage[usage->usage_index - 1];
740 
741 	switch (usage->hid & HID_USAGE_PAGE) {
742 
743 	case HID_UP_GENDESK:
744 		switch (usage->hid) {
745 		case HID_GD_X:
746 			if (prev_usage && (prev_usage->hid == usage->hid)) {
747 				code = ABS_MT_TOOL_X;
748 				MT_STORE_FIELD(cx);
749 			} else {
750 				code = ABS_MT_POSITION_X;
751 				MT_STORE_FIELD(x);
752 			}
753 
754 			set_abs(hi->input, code, field, cls->sn_move);
755 
756 			/*
757 			 * A system multi-axis that exports X and Y has a high
758 			 * chance of being used directly on a surface
759 			 */
760 			if (field->application == HID_GD_SYSTEM_MULTIAXIS) {
761 				__set_bit(INPUT_PROP_DIRECT,
762 					  hi->input->propbit);
763 				input_set_abs_params(hi->input,
764 						     ABS_MT_TOOL_TYPE,
765 						     MT_TOOL_DIAL,
766 						     MT_TOOL_DIAL, 0, 0);
767 			}
768 
769 			return 1;
770 		case HID_GD_Y:
771 			if (prev_usage && (prev_usage->hid == usage->hid)) {
772 				code = ABS_MT_TOOL_Y;
773 				MT_STORE_FIELD(cy);
774 			} else {
775 				code = ABS_MT_POSITION_Y;
776 				MT_STORE_FIELD(y);
777 			}
778 
779 			set_abs(hi->input, code, field, cls->sn_move);
780 
781 			return 1;
782 		}
783 		return 0;
784 
785 	case HID_UP_DIGITIZER:
786 		switch (usage->hid) {
787 		case HID_DG_INRANGE:
788 			if (app->quirks & MT_QUIRK_HOVERING) {
789 				input_set_abs_params(hi->input,
790 					ABS_MT_DISTANCE, 0, 1, 0, 0);
791 			}
792 			MT_STORE_FIELD(inrange_state);
793 			return 1;
794 		case HID_DG_CONFIDENCE:
795 			if ((cls->name == MT_CLS_WIN_8 ||
796 			     cls->name == MT_CLS_WIN_8_FORCE_MULTI_INPUT ||
797 			     cls->name == MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU ||
798 			     cls->name == MT_CLS_WIN_8_DISABLE_WAKEUP) &&
799 				(field->application == HID_DG_TOUCHPAD ||
800 				 field->application == HID_DG_TOUCHSCREEN))
801 				app->quirks |= MT_QUIRK_CONFIDENCE;
802 
803 			if (app->quirks & MT_QUIRK_CONFIDENCE)
804 				input_set_abs_params(hi->input,
805 						     ABS_MT_TOOL_TYPE,
806 						     MT_TOOL_FINGER,
807 						     MT_TOOL_PALM, 0, 0);
808 
809 			MT_STORE_FIELD(confidence_state);
810 			return 1;
811 		case HID_DG_TIPSWITCH:
812 			if (field->application != HID_GD_SYSTEM_MULTIAXIS)
813 				input_set_capability(hi->input,
814 						     EV_KEY, BTN_TOUCH);
815 			MT_STORE_FIELD(tip_state);
816 			return 1;
817 		case HID_DG_CONTACTID:
818 			MT_STORE_FIELD(contactid);
819 			app->touches_by_report++;
820 			return 1;
821 		case HID_DG_WIDTH:
822 			if (!(app->quirks & MT_QUIRK_NO_AREA))
823 				set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
824 					cls->sn_width);
825 			MT_STORE_FIELD(w);
826 			return 1;
827 		case HID_DG_HEIGHT:
828 			if (!(app->quirks & MT_QUIRK_NO_AREA)) {
829 				set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
830 					cls->sn_height);
831 
832 				/*
833 				 * Only set ABS_MT_ORIENTATION if it is not
834 				 * already set by the HID_DG_AZIMUTH usage.
835 				 */
836 				if (!test_bit(ABS_MT_ORIENTATION,
837 						hi->input->absbit))
838 					input_set_abs_params(hi->input,
839 						ABS_MT_ORIENTATION, 0, 1, 0, 0);
840 			}
841 			MT_STORE_FIELD(h);
842 			return 1;
843 		case HID_DG_TIPPRESSURE:
844 			set_abs(hi->input, ABS_MT_PRESSURE, field,
845 				cls->sn_pressure);
846 			MT_STORE_FIELD(p);
847 			return 1;
848 		case HID_DG_SCANTIME:
849 			input_set_capability(hi->input, EV_MSC, MSC_TIMESTAMP);
850 			app->scantime = &field->value[usage->usage_index];
851 			app->scantime_logical_max = field->logical_maximum;
852 			return 1;
853 		case HID_DG_CONTACTCOUNT:
854 			app->have_contact_count = true;
855 			app->raw_cc = &field->value[usage->usage_index];
856 			return 1;
857 		case HID_DG_AZIMUTH:
858 			/*
859 			 * Azimuth has the range of [0, MAX) representing a full
860 			 * revolution. Set ABS_MT_ORIENTATION to a quarter of
861 			 * MAX according the definition of ABS_MT_ORIENTATION
862 			 */
863 			input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
864 				-field->logical_maximum / 4,
865 				field->logical_maximum / 4,
866 				cls->sn_move ?
867 				field->logical_maximum / cls->sn_move : 0, 0);
868 			MT_STORE_FIELD(a);
869 			return 1;
870 		case HID_DG_CONTACTMAX:
871 			/* contact max are global to the report */
872 			return -1;
873 		case HID_DG_TOUCH:
874 			/* Legacy devices use TIPSWITCH and not TOUCH.
875 			 * Let's just ignore this field. */
876 			return -1;
877 		}
878 		/* let hid-input decide for the others */
879 		return 0;
880 
881 	case HID_UP_BUTTON:
882 		code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
883 		/*
884 		 * MS PTP spec says that external buttons left and right have
885 		 * usages 2 and 3.
886 		 */
887 		if ((app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
888 		    field->application == HID_DG_TOUCHPAD &&
889 		    (usage->hid & HID_USAGE) > 1)
890 			code--;
891 
892 		if (field->application == HID_GD_SYSTEM_MULTIAXIS)
893 			code = BTN_0  + ((usage->hid - 1) & HID_USAGE);
894 
895 		hid_map_usage(hi, usage, bit, max, EV_KEY, code);
896 		if (!*bit)
897 			return -1;
898 		input_set_capability(hi->input, EV_KEY, code);
899 		return 1;
900 
901 	case 0xff000000:
902 		/* we do not want to map these: no input-oriented meaning */
903 		return -1;
904 	}
905 
906 	return 0;
907 }
908 
mt_compute_slot(struct mt_device * td,struct mt_application * app,struct mt_usages * slot,struct input_dev * input)909 static int mt_compute_slot(struct mt_device *td, struct mt_application *app,
910 			   struct mt_usages *slot,
911 			   struct input_dev *input)
912 {
913 	__s32 quirks = app->quirks;
914 
915 	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
916 		return *slot->contactid;
917 
918 	if (quirks & MT_QUIRK_CYPRESS)
919 		return cypress_compute_slot(app, slot);
920 
921 	if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
922 		return app->num_received;
923 
924 	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
925 		return *slot->contactid - 1;
926 
927 	return input_mt_get_slot_by_key(input, *slot->contactid);
928 }
929 
mt_release_pending_palms(struct mt_device * td,struct mt_application * app,struct input_dev * input)930 static void mt_release_pending_palms(struct mt_device *td,
931 				     struct mt_application *app,
932 				     struct input_dev *input)
933 {
934 	int slotnum;
935 	bool need_sync = false;
936 
937 	for_each_set_bit(slotnum, app->pending_palm_slots, td->maxcontacts) {
938 		clear_bit(slotnum, app->pending_palm_slots);
939 
940 		input_mt_slot(input, slotnum);
941 		input_mt_report_slot_inactive(input);
942 
943 		need_sync = true;
944 	}
945 
946 	if (need_sync) {
947 		input_mt_sync_frame(input);
948 		input_sync(input);
949 	}
950 }
951 
952 /*
953  * this function is called when a whole packet has been received and processed,
954  * so that it can decide what to send to the input layer.
955  */
mt_sync_frame(struct mt_device * td,struct mt_application * app,struct input_dev * input)956 static void mt_sync_frame(struct mt_device *td, struct mt_application *app,
957 			  struct input_dev *input)
958 {
959 	if (app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS)
960 		input_event(input, EV_KEY, BTN_LEFT, app->left_button_state);
961 
962 	input_mt_sync_frame(input);
963 	input_event(input, EV_MSC, MSC_TIMESTAMP, app->timestamp);
964 	input_sync(input);
965 
966 	mt_release_pending_palms(td, app, input);
967 
968 	app->num_received = 0;
969 	app->left_button_state = 0;
970 
971 	if (test_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags))
972 		set_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
973 	else
974 		clear_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
975 	clear_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
976 }
977 
mt_compute_timestamp(struct mt_application * app,__s32 value)978 static int mt_compute_timestamp(struct mt_application *app, __s32 value)
979 {
980 	long delta = value - app->prev_scantime;
981 	unsigned long jdelta = jiffies_to_usecs(jiffies - app->jiffies);
982 
983 	app->jiffies = jiffies;
984 
985 	if (delta < 0)
986 		delta += app->scantime_logical_max;
987 
988 	/* HID_DG_SCANTIME is expressed in 100us, we want it in us. */
989 	delta *= 100;
990 
991 	if (jdelta > MAX_TIMESTAMP_INTERVAL)
992 		/* No data received for a while, resync the timestamp. */
993 		return 0;
994 	else
995 		return app->timestamp + delta;
996 }
997 
mt_touch_event(struct hid_device * hid,struct hid_field * field,struct hid_usage * usage,__s32 value)998 static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
999 				struct hid_usage *usage, __s32 value)
1000 {
1001 	/* we will handle the hidinput part later, now remains hiddev */
1002 	if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
1003 		hid->hiddev_hid_event(hid, field, usage, value);
1004 
1005 	return 1;
1006 }
1007 
mt_process_slot(struct mt_device * td,struct input_dev * input,struct mt_application * app,struct mt_usages * slot)1008 static int mt_process_slot(struct mt_device *td, struct input_dev *input,
1009 			    struct mt_application *app,
1010 			    struct mt_usages *slot)
1011 {
1012 	struct input_mt *mt = input->mt;
1013 	struct hid_device *hdev = td->hdev;
1014 	__s32 quirks = app->quirks;
1015 	bool valid = true;
1016 	bool confidence_state = true;
1017 	bool inrange_state = false;
1018 	int active;
1019 	int slotnum;
1020 	int tool = MT_TOOL_FINGER;
1021 
1022 	if (!slot)
1023 		return -EINVAL;
1024 
1025 	if ((quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) &&
1026 	    app->num_received >= app->num_expected)
1027 		return -EAGAIN;
1028 
1029 	if (!(quirks & MT_QUIRK_ALWAYS_VALID)) {
1030 		if (quirks & MT_QUIRK_VALID_IS_INRANGE)
1031 			valid = *slot->inrange_state;
1032 		if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
1033 			valid = *slot->tip_state;
1034 		if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
1035 			valid = *slot->confidence_state;
1036 
1037 		if (!valid)
1038 			return 0;
1039 	}
1040 
1041 	slotnum = mt_compute_slot(td, app, slot, input);
1042 	if (slotnum < 0 || slotnum >= td->maxcontacts)
1043 		return 0;
1044 
1045 	if ((quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) {
1046 		struct input_mt_slot *i_slot = &mt->slots[slotnum];
1047 
1048 		if (input_mt_is_active(i_slot) &&
1049 		    input_mt_is_used(mt, i_slot))
1050 			return -EAGAIN;
1051 	}
1052 
1053 	if (quirks & MT_QUIRK_CONFIDENCE)
1054 		confidence_state = *slot->confidence_state;
1055 
1056 	if (quirks & MT_QUIRK_HOVERING)
1057 		inrange_state = *slot->inrange_state;
1058 
1059 	active = *slot->tip_state || inrange_state;
1060 
1061 	if (app->application == HID_GD_SYSTEM_MULTIAXIS)
1062 		tool = MT_TOOL_DIAL;
1063 	else if (unlikely(!confidence_state)) {
1064 		tool = MT_TOOL_PALM;
1065 		if (!active && mt &&
1066 		    input_mt_is_active(&mt->slots[slotnum])) {
1067 			/*
1068 			 * The non-confidence was reported for
1069 			 * previously valid contact that is also no
1070 			 * longer valid. We can't simply report
1071 			 * lift-off as userspace will not be aware
1072 			 * of non-confidence, so we need to split
1073 			 * it into 2 events: active MT_TOOL_PALM
1074 			 * and a separate liftoff.
1075 			 */
1076 			active = true;
1077 			set_bit(slotnum, app->pending_palm_slots);
1078 		}
1079 	}
1080 
1081 	input_mt_slot(input, slotnum);
1082 	input_mt_report_slot_state(input, tool, active);
1083 	if (active) {
1084 		/* this finger is in proximity of the sensor */
1085 		int wide = (*slot->w > *slot->h);
1086 		int major = max(*slot->w, *slot->h);
1087 		int minor = min(*slot->w, *slot->h);
1088 		int orientation = wide;
1089 		int max_azimuth;
1090 		int azimuth;
1091 		int x;
1092 		int y;
1093 		int cx;
1094 		int cy;
1095 
1096 		if (slot->a != DEFAULT_ZERO) {
1097 			/*
1098 			 * Azimuth is counter-clockwise and ranges from [0, MAX)
1099 			 * (a full revolution). Convert it to clockwise ranging
1100 			 * [-MAX/2, MAX/2].
1101 			 *
1102 			 * Note that ABS_MT_ORIENTATION require us to report
1103 			 * the limit of [-MAX/4, MAX/4], but the value can go
1104 			 * out of range to [-MAX/2, MAX/2] to report an upside
1105 			 * down ellipsis.
1106 			 */
1107 			azimuth = *slot->a;
1108 			max_azimuth = input_abs_get_max(input,
1109 							ABS_MT_ORIENTATION);
1110 			if (azimuth > max_azimuth * 2)
1111 				azimuth -= max_azimuth * 4;
1112 			orientation = -azimuth;
1113 			if (quirks & MT_QUIRK_ORIENTATION_INVERT)
1114 				orientation = -orientation;
1115 
1116 		}
1117 
1118 		if (quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
1119 			/*
1120 			 * divided by two to match visual scale of touch
1121 			 * for devices with this quirk
1122 			 */
1123 			major = major >> 1;
1124 			minor = minor >> 1;
1125 		}
1126 
1127 		x = hdev->quirks & HID_QUIRK_X_INVERT ?
1128 			input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->x :
1129 			*slot->x;
1130 		y = hdev->quirks & HID_QUIRK_Y_INVERT ?
1131 			input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->y :
1132 			*slot->y;
1133 		cx = hdev->quirks & HID_QUIRK_X_INVERT ?
1134 			input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->cx :
1135 			*slot->cx;
1136 		cy = hdev->quirks & HID_QUIRK_Y_INVERT ?
1137 			input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->cy :
1138 			*slot->cy;
1139 
1140 		input_event(input, EV_ABS, ABS_MT_POSITION_X, x);
1141 		input_event(input, EV_ABS, ABS_MT_POSITION_Y, y);
1142 		input_event(input, EV_ABS, ABS_MT_TOOL_X, cx);
1143 		input_event(input, EV_ABS, ABS_MT_TOOL_Y, cy);
1144 		input_event(input, EV_ABS, ABS_MT_DISTANCE, !*slot->tip_state);
1145 		input_event(input, EV_ABS, ABS_MT_ORIENTATION, orientation);
1146 		input_event(input, EV_ABS, ABS_MT_PRESSURE, *slot->p);
1147 		input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
1148 		input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
1149 
1150 		set_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
1151 	}
1152 
1153 	return 0;
1154 }
1155 
mt_process_mt_event(struct hid_device * hid,struct mt_application * app,struct hid_field * field,struct hid_usage * usage,__s32 value,bool first_packet)1156 static void mt_process_mt_event(struct hid_device *hid,
1157 				struct mt_application *app,
1158 				struct hid_field *field,
1159 				struct hid_usage *usage,
1160 				__s32 value,
1161 				bool first_packet)
1162 {
1163 	__s32 quirks = app->quirks;
1164 	struct input_dev *input = field->hidinput->input;
1165 
1166 	if (!usage->type || !(hid->claimed & HID_CLAIMED_INPUT))
1167 		return;
1168 
1169 	if (quirks & MT_QUIRK_WIN8_PTP_BUTTONS) {
1170 
1171 		/*
1172 		 * For Win8 PTP touchpads we should only look at
1173 		 * non finger/touch events in the first_packet of a
1174 		 * (possible) multi-packet frame.
1175 		 */
1176 		if (!first_packet)
1177 			return;
1178 
1179 		/*
1180 		 * For Win8 PTP touchpads we map both the clickpad click
1181 		 * and any "external" left buttons to BTN_LEFT if a
1182 		 * device claims to have both we need to report 1 for
1183 		 * BTN_LEFT if either is pressed, so we or all values
1184 		 * together and report the result in mt_sync_frame().
1185 		 */
1186 		if (usage->type == EV_KEY && usage->code == BTN_LEFT) {
1187 			app->left_button_state |= value;
1188 			return;
1189 		}
1190 	}
1191 
1192 	input_event(input, usage->type, usage->code, value);
1193 }
1194 
mt_touch_report(struct hid_device * hid,struct mt_report_data * rdata)1195 static void mt_touch_report(struct hid_device *hid,
1196 			    struct mt_report_data *rdata)
1197 {
1198 	struct mt_device *td = hid_get_drvdata(hid);
1199 	struct hid_report *report = rdata->report;
1200 	struct mt_application *app = rdata->application;
1201 	struct hid_field *field;
1202 	struct input_dev *input;
1203 	struct mt_usages *slot;
1204 	bool first_packet;
1205 	unsigned count;
1206 	int r, n;
1207 	int scantime = 0;
1208 	int contact_count = -1;
1209 
1210 	/* sticky fingers release in progress, abort */
1211 	if (test_and_set_bit_lock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
1212 		return;
1213 
1214 	scantime = *app->scantime;
1215 	app->timestamp = mt_compute_timestamp(app, scantime);
1216 	if (app->raw_cc != DEFAULT_ZERO)
1217 		contact_count = *app->raw_cc;
1218 
1219 	/*
1220 	 * Includes multi-packet support where subsequent
1221 	 * packets are sent with zero contactcount.
1222 	 */
1223 	if (contact_count >= 0) {
1224 		/*
1225 		 * For Win8 PTPs the first packet (td->num_received == 0) may
1226 		 * have a contactcount of 0 if there only is a button event.
1227 		 * We double check that this is not a continuation packet
1228 		 * of a possible multi-packet frame be checking that the
1229 		 * timestamp has changed.
1230 		 */
1231 		if ((app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
1232 		    app->num_received == 0 &&
1233 		    app->prev_scantime != scantime)
1234 			app->num_expected = contact_count;
1235 		/* A non 0 contact count always indicates a first packet */
1236 		else if (contact_count)
1237 			app->num_expected = contact_count;
1238 	}
1239 	app->prev_scantime = scantime;
1240 
1241 	first_packet = app->num_received == 0;
1242 
1243 	input = report->field[0]->hidinput->input;
1244 
1245 	list_for_each_entry(slot, &app->mt_usages, list) {
1246 		if (!mt_process_slot(td, input, app, slot))
1247 			app->num_received++;
1248 	}
1249 
1250 	for (r = 0; r < report->maxfield; r++) {
1251 		field = report->field[r];
1252 		count = field->report_count;
1253 
1254 		if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
1255 			continue;
1256 
1257 		for (n = 0; n < count; n++)
1258 			mt_process_mt_event(hid, app, field,
1259 					    &field->usage[n], field->value[n],
1260 					    first_packet);
1261 	}
1262 
1263 	if (app->num_received >= app->num_expected)
1264 		mt_sync_frame(td, app, input);
1265 
1266 	/*
1267 	 * Windows 8 specs says 2 things:
1268 	 * - once a contact has been reported, it has to be reported in each
1269 	 *   subsequent report
1270 	 * - the report rate when fingers are present has to be at least
1271 	 *   the refresh rate of the screen, 60 or 120 Hz
1272 	 *
1273 	 * I interprete this that the specification forces a report rate of
1274 	 * at least 60 Hz for a touchscreen to be certified.
1275 	 * Which means that if we do not get a report whithin 16 ms, either
1276 	 * something wrong happens, either the touchscreen forgets to send
1277 	 * a release. Taking a reasonable margin allows to remove issues
1278 	 * with USB communication or the load of the machine.
1279 	 *
1280 	 * Given that Win 8 devices are forced to send a release, this will
1281 	 * only affect laggish machines and the ones that have a firmware
1282 	 * defect.
1283 	 */
1284 	if (app->quirks & MT_QUIRK_STICKY_FINGERS) {
1285 		if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1286 			mod_timer(&td->release_timer,
1287 				  jiffies + msecs_to_jiffies(100));
1288 		else
1289 			del_timer(&td->release_timer);
1290 	}
1291 
1292 	clear_bit_unlock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
1293 }
1294 
mt_touch_input_configured(struct hid_device * hdev,struct hid_input * hi,struct mt_application * app)1295 static int mt_touch_input_configured(struct hid_device *hdev,
1296 				     struct hid_input *hi,
1297 				     struct mt_application *app)
1298 {
1299 	struct mt_device *td = hid_get_drvdata(hdev);
1300 	struct mt_class *cls = &td->mtclass;
1301 	struct input_dev *input = hi->input;
1302 	int ret;
1303 
1304 	if (!td->maxcontacts)
1305 		td->maxcontacts = MT_DEFAULT_MAXCONTACT;
1306 
1307 	mt_post_parse(td, app);
1308 	if (td->serial_maybe)
1309 		mt_post_parse_default_settings(td, app);
1310 
1311 	if (cls->is_indirect)
1312 		app->mt_flags |= INPUT_MT_POINTER;
1313 
1314 	if (app->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
1315 		app->mt_flags |= INPUT_MT_DROP_UNUSED;
1316 
1317 	/* check for clickpads */
1318 	if ((app->mt_flags & INPUT_MT_POINTER) &&
1319 	    (app->buttons_count == 1))
1320 		td->is_buttonpad = true;
1321 
1322 	if (td->is_buttonpad)
1323 		__set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
1324 
1325 	app->pending_palm_slots = devm_kcalloc(&hi->input->dev,
1326 					       BITS_TO_LONGS(td->maxcontacts),
1327 					       sizeof(long),
1328 					       GFP_KERNEL);
1329 	if (!app->pending_palm_slots)
1330 		return -ENOMEM;
1331 
1332 	ret = input_mt_init_slots(input, td->maxcontacts, app->mt_flags);
1333 	if (ret)
1334 		return ret;
1335 
1336 	app->mt_flags = 0;
1337 	return 0;
1338 }
1339 
1340 #define mt_map_key_clear(c)	hid_map_usage_clear(hi, usage, bit, \
1341 						    max, EV_KEY, (c))
mt_input_mapping(struct hid_device * hdev,struct hid_input * hi,struct hid_field * field,struct hid_usage * usage,unsigned long ** bit,int * max)1342 static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
1343 		struct hid_field *field, struct hid_usage *usage,
1344 		unsigned long **bit, int *max)
1345 {
1346 	struct mt_device *td = hid_get_drvdata(hdev);
1347 	struct mt_application *application;
1348 	struct mt_report_data *rdata;
1349 
1350 	rdata = mt_find_report_data(td, field->report);
1351 	if (!rdata) {
1352 		hid_err(hdev, "failed to allocate data for report\n");
1353 		return 0;
1354 	}
1355 
1356 	application = rdata->application;
1357 
1358 	/*
1359 	 * If mtclass.export_all_inputs is not set, only map fields from
1360 	 * TouchScreen or TouchPad collections. We need to ignore fields
1361 	 * that belong to other collections such as Mouse that might have
1362 	 * the same GenericDesktop usages.
1363 	 */
1364 	if (!td->mtclass.export_all_inputs &&
1365 	    field->application != HID_DG_TOUCHSCREEN &&
1366 	    field->application != HID_DG_PEN &&
1367 	    field->application != HID_DG_TOUCHPAD &&
1368 	    field->application != HID_GD_KEYBOARD &&
1369 	    field->application != HID_GD_SYSTEM_CONTROL &&
1370 	    field->application != HID_CP_CONSUMER_CONTROL &&
1371 	    field->application != HID_GD_WIRELESS_RADIO_CTLS &&
1372 	    field->application != HID_GD_SYSTEM_MULTIAXIS &&
1373 	    !(field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS &&
1374 	      application->quirks & MT_QUIRK_ASUS_CUSTOM_UP))
1375 		return -1;
1376 
1377 	/*
1378 	 * Some Asus keyboard+touchpad devices have the hotkeys defined in the
1379 	 * touchpad report descriptor. We need to treat these as an array to
1380 	 * map usages to input keys.
1381 	 */
1382 	if (field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS &&
1383 	    application->quirks & MT_QUIRK_ASUS_CUSTOM_UP &&
1384 	    (usage->hid & HID_USAGE_PAGE) == HID_UP_CUSTOM) {
1385 		set_bit(EV_REP, hi->input->evbit);
1386 		if (field->flags & HID_MAIN_ITEM_VARIABLE)
1387 			field->flags &= ~HID_MAIN_ITEM_VARIABLE;
1388 		switch (usage->hid & HID_USAGE) {
1389 		case 0x10: mt_map_key_clear(KEY_BRIGHTNESSDOWN);	break;
1390 		case 0x20: mt_map_key_clear(KEY_BRIGHTNESSUP);		break;
1391 		case 0x35: mt_map_key_clear(KEY_DISPLAY_OFF);		break;
1392 		case 0x6b: mt_map_key_clear(KEY_F21);			break;
1393 		case 0x6c: mt_map_key_clear(KEY_SLEEP);			break;
1394 		default:
1395 			return -1;
1396 		}
1397 		return 1;
1398 	}
1399 
1400 	if (rdata->is_mt_collection)
1401 		return mt_touch_input_mapping(hdev, hi, field, usage, bit, max,
1402 					      application);
1403 
1404 	/*
1405 	 * some egalax touchscreens have "application == DG_TOUCHSCREEN"
1406 	 * for the stylus. Overwrite the hid_input application
1407 	 */
1408 	if (field->physical == HID_DG_STYLUS)
1409 		hi->application = HID_DG_STYLUS;
1410 
1411 	/* let hid-core decide for the others */
1412 	return 0;
1413 }
1414 
mt_input_mapped(struct hid_device * hdev,struct hid_input * hi,struct hid_field * field,struct hid_usage * usage,unsigned long ** bit,int * max)1415 static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
1416 		struct hid_field *field, struct hid_usage *usage,
1417 		unsigned long **bit, int *max)
1418 {
1419 	struct mt_device *td = hid_get_drvdata(hdev);
1420 	struct mt_report_data *rdata;
1421 
1422 	rdata = mt_find_report_data(td, field->report);
1423 	if (rdata && rdata->is_mt_collection) {
1424 		/* We own these mappings, tell hid-input to ignore them */
1425 		return -1;
1426 	}
1427 
1428 	/* let hid-core decide for the others */
1429 	return 0;
1430 }
1431 
mt_event(struct hid_device * hid,struct hid_field * field,struct hid_usage * usage,__s32 value)1432 static int mt_event(struct hid_device *hid, struct hid_field *field,
1433 				struct hid_usage *usage, __s32 value)
1434 {
1435 	struct mt_device *td = hid_get_drvdata(hid);
1436 	struct mt_report_data *rdata;
1437 
1438 	rdata = mt_find_report_data(td, field->report);
1439 	if (rdata && rdata->is_mt_collection)
1440 		return mt_touch_event(hid, field, usage, value);
1441 
1442 	return 0;
1443 }
1444 
mt_report_fixup(struct hid_device * hdev,__u8 * rdesc,unsigned int * size)1445 static __u8 *mt_report_fixup(struct hid_device *hdev, __u8 *rdesc,
1446 			     unsigned int *size)
1447 {
1448 	if (hdev->vendor == I2C_VENDOR_ID_GOODIX &&
1449 	    (hdev->product == I2C_DEVICE_ID_GOODIX_01E8 ||
1450 	     hdev->product == I2C_DEVICE_ID_GOODIX_01E9)) {
1451 		if (rdesc[607] == 0x15) {
1452 			rdesc[607] = 0x25;
1453 			dev_info(
1454 				&hdev->dev,
1455 				"GT7868Q report descriptor fixup is applied.\n");
1456 		} else {
1457 			dev_info(
1458 				&hdev->dev,
1459 				"The byte is not expected for fixing the report descriptor. \
1460 It's possible that the touchpad firmware is not suitable for applying the fix. \
1461 got: %x\n",
1462 				rdesc[607]);
1463 		}
1464 	}
1465 
1466 	return rdesc;
1467 }
1468 
mt_report(struct hid_device * hid,struct hid_report * report)1469 static void mt_report(struct hid_device *hid, struct hid_report *report)
1470 {
1471 	struct mt_device *td = hid_get_drvdata(hid);
1472 	struct hid_field *field = report->field[0];
1473 	struct mt_report_data *rdata;
1474 
1475 	if (!(hid->claimed & HID_CLAIMED_INPUT))
1476 		return;
1477 
1478 	rdata = mt_find_report_data(td, report);
1479 	if (rdata && rdata->is_mt_collection)
1480 		return mt_touch_report(hid, rdata);
1481 
1482 	if (field && field->hidinput && field->hidinput->input)
1483 		input_sync(field->hidinput->input);
1484 }
1485 
mt_need_to_apply_feature(struct hid_device * hdev,struct hid_field * field,struct hid_usage * usage,enum latency_mode latency,bool surface_switch,bool button_switch,bool * inputmode_found)1486 static bool mt_need_to_apply_feature(struct hid_device *hdev,
1487 				     struct hid_field *field,
1488 				     struct hid_usage *usage,
1489 				     enum latency_mode latency,
1490 				     bool surface_switch,
1491 				     bool button_switch,
1492 				     bool *inputmode_found)
1493 {
1494 	struct mt_device *td = hid_get_drvdata(hdev);
1495 	struct mt_class *cls = &td->mtclass;
1496 	struct hid_report *report = field->report;
1497 	unsigned int index = usage->usage_index;
1498 	char *buf;
1499 	u32 report_len;
1500 	int max;
1501 
1502 	switch (usage->hid) {
1503 	case HID_DG_INPUTMODE:
1504 		/*
1505 		 * Some elan panels wrongly declare 2 input mode features,
1506 		 * and silently ignore when we set the value in the second
1507 		 * field. Skip the second feature and hope for the best.
1508 		 */
1509 		if (*inputmode_found)
1510 			return false;
1511 
1512 		if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) {
1513 			report_len = hid_report_len(report);
1514 			buf = hid_alloc_report_buf(report, GFP_KERNEL);
1515 			if (!buf) {
1516 				hid_err(hdev,
1517 					"failed to allocate buffer for report\n");
1518 				return false;
1519 			}
1520 			hid_hw_raw_request(hdev, report->id, buf, report_len,
1521 					   HID_FEATURE_REPORT,
1522 					   HID_REQ_GET_REPORT);
1523 			kfree(buf);
1524 		}
1525 
1526 		field->value[index] = td->inputmode_value;
1527 		*inputmode_found = true;
1528 		return true;
1529 
1530 	case HID_DG_CONTACTMAX:
1531 		if (cls->maxcontacts) {
1532 			max = min_t(int, field->logical_maximum,
1533 				    cls->maxcontacts);
1534 			if (field->value[index] != max) {
1535 				field->value[index] = max;
1536 				return true;
1537 			}
1538 		}
1539 		break;
1540 
1541 	case HID_DG_LATENCYMODE:
1542 		field->value[index] = latency;
1543 		return true;
1544 
1545 	case HID_DG_SURFACESWITCH:
1546 		field->value[index] = surface_switch;
1547 		return true;
1548 
1549 	case HID_DG_BUTTONSWITCH:
1550 		field->value[index] = button_switch;
1551 		return true;
1552 	}
1553 
1554 	return false; /* no need to update the report */
1555 }
1556 
mt_set_modes(struct hid_device * hdev,enum latency_mode latency,bool surface_switch,bool button_switch)1557 static void mt_set_modes(struct hid_device *hdev, enum latency_mode latency,
1558 			 bool surface_switch, bool button_switch)
1559 {
1560 	struct hid_report_enum *rep_enum;
1561 	struct hid_report *rep;
1562 	struct hid_usage *usage;
1563 	int i, j;
1564 	bool update_report;
1565 	bool inputmode_found = false;
1566 
1567 	rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
1568 	list_for_each_entry(rep, &rep_enum->report_list, list) {
1569 		update_report = false;
1570 
1571 		for (i = 0; i < rep->maxfield; i++) {
1572 			/* Ignore if report count is out of bounds. */
1573 			if (rep->field[i]->report_count < 1)
1574 				continue;
1575 
1576 			for (j = 0; j < rep->field[i]->maxusage; j++) {
1577 				usage = &rep->field[i]->usage[j];
1578 
1579 				if (mt_need_to_apply_feature(hdev,
1580 							     rep->field[i],
1581 							     usage,
1582 							     latency,
1583 							     surface_switch,
1584 							     button_switch,
1585 							     &inputmode_found))
1586 					update_report = true;
1587 			}
1588 		}
1589 
1590 		if (update_report)
1591 			hid_hw_request(hdev, rep, HID_REQ_SET_REPORT);
1592 	}
1593 }
1594 
mt_post_parse_default_settings(struct mt_device * td,struct mt_application * app)1595 static void mt_post_parse_default_settings(struct mt_device *td,
1596 					   struct mt_application *app)
1597 {
1598 	__s32 quirks = app->quirks;
1599 
1600 	/* unknown serial device needs special quirks */
1601 	if (list_is_singular(&app->mt_usages)) {
1602 		quirks |= MT_QUIRK_ALWAYS_VALID;
1603 		quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
1604 		quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
1605 		quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;
1606 		quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
1607 	}
1608 
1609 	app->quirks = quirks;
1610 }
1611 
mt_post_parse(struct mt_device * td,struct mt_application * app)1612 static void mt_post_parse(struct mt_device *td, struct mt_application *app)
1613 {
1614 	if (!app->have_contact_count)
1615 		app->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
1616 }
1617 
mt_input_configured(struct hid_device * hdev,struct hid_input * hi)1618 static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
1619 {
1620 	struct mt_device *td = hid_get_drvdata(hdev);
1621 	const char *suffix = NULL;
1622 	struct mt_report_data *rdata;
1623 	struct mt_application *mt_application = NULL;
1624 	struct hid_report *report;
1625 	int ret;
1626 
1627 	list_for_each_entry(report, &hi->reports, hidinput_list) {
1628 		rdata = mt_find_report_data(td, report);
1629 		if (!rdata) {
1630 			hid_err(hdev, "failed to allocate data for report\n");
1631 			return -ENOMEM;
1632 		}
1633 
1634 		mt_application = rdata->application;
1635 
1636 		if (rdata->is_mt_collection) {
1637 			ret = mt_touch_input_configured(hdev, hi,
1638 							mt_application);
1639 			if (ret)
1640 				return ret;
1641 		}
1642 	}
1643 
1644 	switch (hi->application) {
1645 	case HID_GD_KEYBOARD:
1646 	case HID_GD_KEYPAD:
1647 	case HID_GD_MOUSE:
1648 	case HID_DG_TOUCHPAD:
1649 	case HID_GD_SYSTEM_CONTROL:
1650 	case HID_CP_CONSUMER_CONTROL:
1651 	case HID_GD_WIRELESS_RADIO_CTLS:
1652 	case HID_GD_SYSTEM_MULTIAXIS:
1653 		/* already handled by hid core */
1654 		break;
1655 	case HID_DG_TOUCHSCREEN:
1656 		/* we do not set suffix = "Touchscreen" */
1657 		hi->input->name = hdev->name;
1658 		break;
1659 	case HID_VD_ASUS_CUSTOM_MEDIA_KEYS:
1660 		suffix = "Custom Media Keys";
1661 		break;
1662 	case HID_DG_STYLUS:
1663 		/* force BTN_STYLUS to allow tablet matching in udev */
1664 		__set_bit(BTN_STYLUS, hi->input->keybit);
1665 		break;
1666 	default:
1667 		suffix = "UNKNOWN";
1668 		break;
1669 	}
1670 
1671 	if (suffix)
1672 		hi->input->name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
1673 						 "%s %s", hdev->name, suffix);
1674 
1675 	return 0;
1676 }
1677 
mt_fix_const_field(struct hid_field * field,unsigned int usage)1678 static void mt_fix_const_field(struct hid_field *field, unsigned int usage)
1679 {
1680 	if (field->usage[0].hid != usage ||
1681 	    !(field->flags & HID_MAIN_ITEM_CONSTANT))
1682 		return;
1683 
1684 	field->flags &= ~HID_MAIN_ITEM_CONSTANT;
1685 	field->flags |= HID_MAIN_ITEM_VARIABLE;
1686 }
1687 
mt_fix_const_fields(struct hid_device * hdev,unsigned int usage)1688 static void mt_fix_const_fields(struct hid_device *hdev, unsigned int usage)
1689 {
1690 	struct hid_report *report;
1691 	int i;
1692 
1693 	list_for_each_entry(report,
1694 			    &hdev->report_enum[HID_INPUT_REPORT].report_list,
1695 			    list) {
1696 
1697 		if (!report->maxfield)
1698 			continue;
1699 
1700 		for (i = 0; i < report->maxfield; i++)
1701 			if (report->field[i]->maxusage >= 1)
1702 				mt_fix_const_field(report->field[i], usage);
1703 	}
1704 }
1705 
mt_release_contacts(struct hid_device * hid)1706 static void mt_release_contacts(struct hid_device *hid)
1707 {
1708 	struct hid_input *hidinput;
1709 	struct mt_application *application;
1710 	struct mt_device *td = hid_get_drvdata(hid);
1711 
1712 	list_for_each_entry(hidinput, &hid->inputs, list) {
1713 		struct input_dev *input_dev = hidinput->input;
1714 		struct input_mt *mt = input_dev->mt;
1715 		int i;
1716 
1717 		if (mt) {
1718 			for (i = 0; i < mt->num_slots; i++) {
1719 				input_mt_slot(input_dev, i);
1720 				input_mt_report_slot_inactive(input_dev);
1721 			}
1722 			input_mt_sync_frame(input_dev);
1723 			input_sync(input_dev);
1724 		}
1725 	}
1726 
1727 	list_for_each_entry(application, &td->applications, list) {
1728 		application->num_received = 0;
1729 	}
1730 }
1731 
mt_expired_timeout(struct timer_list * t)1732 static void mt_expired_timeout(struct timer_list *t)
1733 {
1734 	struct mt_device *td = from_timer(td, t, release_timer);
1735 	struct hid_device *hdev = td->hdev;
1736 
1737 	/*
1738 	 * An input report came in just before we release the sticky fingers,
1739 	 * it will take care of the sticky fingers.
1740 	 */
1741 	if (test_and_set_bit_lock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
1742 		return;
1743 	if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1744 		mt_release_contacts(hdev);
1745 	clear_bit_unlock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
1746 }
1747 
mt_probe(struct hid_device * hdev,const struct hid_device_id * id)1748 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
1749 {
1750 	int ret, i;
1751 	struct mt_device *td;
1752 	const struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
1753 
1754 	for (i = 0; mt_classes[i].name ; i++) {
1755 		if (id->driver_data == mt_classes[i].name) {
1756 			mtclass = &(mt_classes[i]);
1757 			break;
1758 		}
1759 	}
1760 
1761 	td = devm_kzalloc(&hdev->dev, sizeof(struct mt_device), GFP_KERNEL);
1762 	if (!td) {
1763 		dev_err(&hdev->dev, "cannot allocate multitouch data\n");
1764 		return -ENOMEM;
1765 	}
1766 	td->hdev = hdev;
1767 	td->mtclass = *mtclass;
1768 	td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN;
1769 	hid_set_drvdata(hdev, td);
1770 
1771 	INIT_LIST_HEAD(&td->applications);
1772 	INIT_LIST_HEAD(&td->reports);
1773 
1774 	if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
1775 		td->serial_maybe = true;
1776 
1777 
1778 	/* Orientation is inverted if the X or Y axes are
1779 	 * flipped, but normalized if both are inverted.
1780 	 */
1781 	if (hdev->quirks & (HID_QUIRK_X_INVERT | HID_QUIRK_Y_INVERT) &&
1782 	    !((hdev->quirks & HID_QUIRK_X_INVERT)
1783 	      && (hdev->quirks & HID_QUIRK_Y_INVERT)))
1784 		td->mtclass.quirks = MT_QUIRK_ORIENTATION_INVERT;
1785 
1786 	/* This allows the driver to correctly support devices
1787 	 * that emit events over several HID messages.
1788 	 */
1789 	hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
1790 
1791 	/*
1792 	 * This allows the driver to handle different input sensors
1793 	 * that emits events through different applications on the same HID
1794 	 * device.
1795 	 */
1796 	hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
1797 
1798 	if (id->group != HID_GROUP_MULTITOUCH_WIN_8)
1799 		hdev->quirks |= HID_QUIRK_MULTI_INPUT;
1800 
1801 	if (mtclass->quirks & MT_QUIRK_FORCE_MULTI_INPUT) {
1802 		hdev->quirks &= ~HID_QUIRK_INPUT_PER_APP;
1803 		hdev->quirks |= HID_QUIRK_MULTI_INPUT;
1804 	}
1805 
1806 	timer_setup(&td->release_timer, mt_expired_timeout, 0);
1807 
1808 	ret = hid_parse(hdev);
1809 	if (ret != 0)
1810 		return ret;
1811 
1812 	if (mtclass->quirks & MT_QUIRK_FIX_CONST_CONTACT_ID)
1813 		mt_fix_const_fields(hdev, HID_DG_CONTACTID);
1814 
1815 	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
1816 	if (ret)
1817 		return ret;
1818 
1819 	ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
1820 	if (ret)
1821 		dev_warn(&hdev->dev, "Cannot allocate sysfs group for %s\n",
1822 				hdev->name);
1823 
1824 	mt_set_modes(hdev, HID_LATENCY_NORMAL, true, true);
1825 
1826 	return 0;
1827 }
1828 
1829 #ifdef CONFIG_PM
mt_suspend(struct hid_device * hdev,pm_message_t state)1830 static int mt_suspend(struct hid_device *hdev, pm_message_t state)
1831 {
1832 	struct mt_device *td = hid_get_drvdata(hdev);
1833 
1834 	/* High latency is desirable for power savings during S3/S0ix */
1835 	if ((td->mtclass.quirks & MT_QUIRK_DISABLE_WAKEUP) ||
1836 	    !hid_hw_may_wakeup(hdev))
1837 		mt_set_modes(hdev, HID_LATENCY_HIGH, false, false);
1838 	else
1839 		mt_set_modes(hdev, HID_LATENCY_HIGH, true, true);
1840 
1841 	return 0;
1842 }
1843 
mt_reset_resume(struct hid_device * hdev)1844 static int mt_reset_resume(struct hid_device *hdev)
1845 {
1846 	mt_release_contacts(hdev);
1847 	mt_set_modes(hdev, HID_LATENCY_NORMAL, true, true);
1848 	return 0;
1849 }
1850 
mt_resume(struct hid_device * hdev)1851 static int mt_resume(struct hid_device *hdev)
1852 {
1853 	/* Some Elan legacy devices require SET_IDLE to be set on resume.
1854 	 * It should be safe to send it to other devices too.
1855 	 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */
1856 
1857 	hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE);
1858 
1859 	mt_set_modes(hdev, HID_LATENCY_NORMAL, true, true);
1860 
1861 	return 0;
1862 }
1863 #endif
1864 
mt_remove(struct hid_device * hdev)1865 static void mt_remove(struct hid_device *hdev)
1866 {
1867 	struct mt_device *td = hid_get_drvdata(hdev);
1868 
1869 	del_timer_sync(&td->release_timer);
1870 
1871 	sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
1872 	hid_hw_stop(hdev);
1873 }
1874 
1875 /*
1876  * This list contains only:
1877  * - VID/PID of products not working with the default multitouch handling
1878  * - 2 generic rules.
1879  * So there is no point in adding here any device with MT_CLS_DEFAULT.
1880  */
1881 static const struct hid_device_id mt_devices[] = {
1882 
1883 	/* 3M panels */
1884 	{ .driver_data = MT_CLS_3M,
1885 		MT_USB_DEVICE(USB_VENDOR_ID_3M,
1886 			USB_DEVICE_ID_3M1968) },
1887 	{ .driver_data = MT_CLS_3M,
1888 		MT_USB_DEVICE(USB_VENDOR_ID_3M,
1889 			USB_DEVICE_ID_3M2256) },
1890 	{ .driver_data = MT_CLS_3M,
1891 		MT_USB_DEVICE(USB_VENDOR_ID_3M,
1892 			USB_DEVICE_ID_3M3266) },
1893 
1894 	/* Anton devices */
1895 	{ .driver_data = MT_CLS_EXPORT_ALL_INPUTS,
1896 		MT_USB_DEVICE(USB_VENDOR_ID_ANTON,
1897 			USB_DEVICE_ID_ANTON_TOUCH_PAD) },
1898 
1899 	/* Asus T101HA */
1900 	{ .driver_data = MT_CLS_WIN_8_DISABLE_WAKEUP,
1901 		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
1902 			   USB_VENDOR_ID_ASUSTEK,
1903 			   USB_DEVICE_ID_ASUSTEK_T101HA_KEYBOARD) },
1904 
1905 	/* Asus T304UA */
1906 	{ .driver_data = MT_CLS_ASUS,
1907 		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
1908 			USB_VENDOR_ID_ASUSTEK,
1909 			USB_DEVICE_ID_ASUSTEK_T304_KEYBOARD) },
1910 
1911 	/* Atmel panels */
1912 	{ .driver_data = MT_CLS_SERIAL,
1913 		MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
1914 			USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
1915 
1916 	/* Baanto multitouch devices */
1917 	{ .driver_data = MT_CLS_NSMU,
1918 		MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
1919 			USB_DEVICE_ID_BAANTO_MT_190W2) },
1920 
1921 	/* Cando panels */
1922 	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1923 		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1924 			USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
1925 	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1926 		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1927 			USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
1928 
1929 	/* Chunghwa Telecom touch panels */
1930 	{  .driver_data = MT_CLS_NSMU,
1931 		MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
1932 			USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
1933 
1934 	/* CJTouch panels */
1935 	{ .driver_data = MT_CLS_NSMU,
1936 		MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
1937 			USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020) },
1938 	{ .driver_data = MT_CLS_NSMU,
1939 		MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
1940 			USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040) },
1941 
1942 	/* CVTouch panels */
1943 	{ .driver_data = MT_CLS_NSMU,
1944 		MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
1945 			USB_DEVICE_ID_CVTOUCH_SCREEN) },
1946 
1947 	/* eGalax devices (SAW) */
1948 	{ .driver_data = MT_CLS_EXPORT_ALL_INPUTS,
1949 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1950 			USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER) },
1951 
1952 	/* eGalax devices (resistive) */
1953 	{ .driver_data = MT_CLS_EGALAX,
1954 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1955 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
1956 	{ .driver_data = MT_CLS_EGALAX,
1957 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1958 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
1959 
1960 	/* eGalax devices (capacitive) */
1961 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1962 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1963 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
1964 	{ .driver_data = MT_CLS_EGALAX,
1965 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1966 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
1967 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1968 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1969 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
1970 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1971 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1972 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
1973 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1974 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1975 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
1976 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1977 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1978 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
1979 	{ .driver_data = MT_CLS_EGALAX,
1980 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1981 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
1982 	{ .driver_data = MT_CLS_EGALAX,
1983 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1984 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
1985 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1986 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1987 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
1988 	{ .driver_data = MT_CLS_EGALAX,
1989 		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1990 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
1991 	{ .driver_data = MT_CLS_EGALAX,
1992 		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1993 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
1994 	{ .driver_data = MT_CLS_EGALAX,
1995 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1996 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
1997 	{ .driver_data = MT_CLS_EGALAX,
1998 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1999 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
2000 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
2001 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
2002 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
2003 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
2004 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
2005 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) },
2006 	{ .driver_data = MT_CLS_EGALAX_SERIAL,
2007 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
2008 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
2009 	{ .driver_data = MT_CLS_EGALAX,
2010 		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
2011 			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_C002) },
2012 
2013 	/* Elan devices */
2014 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2015 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2016 			USB_VENDOR_ID_ELAN, 0x313a) },
2017 
2018 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2019 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2020 			USB_VENDOR_ID_ELAN, 0x3148) },
2021 
2022 	/* Elitegroup panel */
2023 	{ .driver_data = MT_CLS_SERIAL,
2024 		MT_USB_DEVICE(USB_VENDOR_ID_ELITEGROUP,
2025 			USB_DEVICE_ID_ELITEGROUP_05D8) },
2026 
2027 	/* Flatfrog Panels */
2028 	{ .driver_data = MT_CLS_FLATFROG,
2029 		MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG,
2030 			USB_DEVICE_ID_MULTITOUCH_3200) },
2031 
2032 	/* FocalTech Panels */
2033 	{ .driver_data = MT_CLS_SERIAL,
2034 		MT_USB_DEVICE(USB_VENDOR_ID_CYGNAL,
2035 			USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH) },
2036 
2037 	/* GeneralTouch panel */
2038 	{ .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
2039 		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2040 			USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
2041 	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2042 		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2043 			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) },
2044 	{ .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
2045 		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2046 			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0101) },
2047 	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2048 		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2049 			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0102) },
2050 	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2051 		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2052 			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0106) },
2053 	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2054 		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2055 			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A) },
2056 	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2057 		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2058 			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100) },
2059 
2060 	/* Gametel game controller */
2061 	{ .driver_data = MT_CLS_NSMU,
2062 		MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
2063 			USB_DEVICE_ID_GAMETEL_MT_MODE) },
2064 
2065 	/* Goodix GT7868Q devices */
2066 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
2067 	  HID_DEVICE(BUS_I2C, HID_GROUP_ANY, I2C_VENDOR_ID_GOODIX,
2068 		     I2C_DEVICE_ID_GOODIX_01E8) },
2069 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
2070 	  HID_DEVICE(BUS_I2C, HID_GROUP_ANY, I2C_VENDOR_ID_GOODIX,
2071 		     I2C_DEVICE_ID_GOODIX_01E8) },
2072 
2073 	/* GoodTouch panels */
2074 	{ .driver_data = MT_CLS_NSMU,
2075 		MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
2076 			USB_DEVICE_ID_GOODTOUCH_000f) },
2077 
2078 	/* Hanvon panels */
2079 	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
2080 		MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
2081 			USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
2082 
2083 	/* HONOR GLO-GXXX panel */
2084 	{ .driver_data = MT_CLS_VTL,
2085 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2086 			0x347d, 0x7853) },
2087 
2088 	/* Ilitek dual touch panel */
2089 	{  .driver_data = MT_CLS_NSMU,
2090 		MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
2091 			USB_DEVICE_ID_ILITEK_MULTITOUCH) },
2092 
2093 	/* LG Melfas panel */
2094 	{ .driver_data = MT_CLS_LG,
2095 		HID_USB_DEVICE(USB_VENDOR_ID_LG,
2096 			USB_DEVICE_ID_LG_MELFAS_MT) },
2097 	{ .driver_data = MT_CLS_LG,
2098 		HID_DEVICE(BUS_I2C, HID_GROUP_GENERIC,
2099 			USB_VENDOR_ID_LG, I2C_DEVICE_ID_LG_7010) },
2100 
2101 	/* Lenovo X1 TAB Gen 2 */
2102 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2103 		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2104 			   USB_VENDOR_ID_LENOVO,
2105 			   USB_DEVICE_ID_LENOVO_X1_TAB) },
2106 
2107 	/* Lenovo X1 TAB Gen 3 */
2108 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2109 		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2110 			   USB_VENDOR_ID_LENOVO,
2111 			   USB_DEVICE_ID_LENOVO_X1_TAB3) },
2112 
2113 	/* Lenovo X12 TAB Gen 1 */
2114 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
2115 		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2116 			   USB_VENDOR_ID_LENOVO,
2117 			   USB_DEVICE_ID_LENOVO_X12_TAB) },
2118 
2119 	/* Logitech devices */
2120 	{ .driver_data = MT_CLS_NSMU,
2121 		HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH_WIN_8,
2122 			USB_VENDOR_ID_LOGITECH,
2123 			USB_DEVICE_ID_LOGITECH_CASA_TOUCHPAD) },
2124 
2125 	/* MosArt panels */
2126 	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2127 		MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
2128 			USB_DEVICE_ID_ASUS_T91MT)},
2129 	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2130 		MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
2131 			USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
2132 	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2133 		MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
2134 			USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
2135 
2136 	/* Novatek Panel */
2137 	{ .driver_data = MT_CLS_NSMU,
2138 		MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
2139 			USB_DEVICE_ID_NOVATEK_PCT) },
2140 
2141 	/* Ntrig Panel */
2142 	{ .driver_data = MT_CLS_NSMU,
2143 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2144 			USB_VENDOR_ID_NTRIG, 0x1b05) },
2145 
2146 	/* Panasonic panels */
2147 	{ .driver_data = MT_CLS_PANASONIC,
2148 		MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
2149 			USB_DEVICE_ID_PANABOARD_UBT780) },
2150 	{ .driver_data = MT_CLS_PANASONIC,
2151 		MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
2152 			USB_DEVICE_ID_PANABOARD_UBT880) },
2153 
2154 	/* PixArt optical touch screen */
2155 	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2156 		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
2157 			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
2158 	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2159 		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
2160 			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
2161 	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2162 		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
2163 			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
2164 
2165 	/* PixCir-based panels */
2166 	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
2167 		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
2168 			USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
2169 
2170 	/* Quanta-based panels */
2171 	{ .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
2172 		MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
2173 			USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
2174 
2175 	/* Razer touchpads */
2176 	{ .driver_data = MT_CLS_RAZER_BLADE_STEALTH,
2177 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2178 			USB_VENDOR_ID_SYNAPTICS, 0x8323) },
2179 
2180 	/* Smart Tech panels */
2181 	{ .driver_data = MT_CLS_SMART_TECH,
2182 		MT_USB_DEVICE(0x0b8c, 0x0092)},
2183 
2184 	/* Stantum panels */
2185 	{ .driver_data = MT_CLS_CONFIDENCE,
2186 		MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
2187 			USB_DEVICE_ID_MTP_STM)},
2188 
2189 	/* Synaptics devices */
2190 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2191 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2192 			USB_VENDOR_ID_SYNAPTICS, 0xcd7e) },
2193 
2194 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2195 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2196 			USB_VENDOR_ID_SYNAPTICS, 0xcddc) },
2197 
2198 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2199 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2200 			USB_VENDOR_ID_SYNAPTICS, 0xce08) },
2201 
2202 	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2203 		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2204 			USB_VENDOR_ID_SYNAPTICS, 0xce09) },
2205 
2206 	/* TopSeed panels */
2207 	{ .driver_data = MT_CLS_TOPSEED,
2208 		MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
2209 			USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },
2210 
2211 	/* Touch International panels */
2212 	{ .driver_data = MT_CLS_NSMU,
2213 		MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
2214 			USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
2215 
2216 	/* Unitec panels */
2217 	{ .driver_data = MT_CLS_NSMU,
2218 		MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
2219 			USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
2220 	{ .driver_data = MT_CLS_NSMU,
2221 		MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
2222 			USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
2223 
2224 	/* VTL panels */
2225 	{ .driver_data = MT_CLS_VTL,
2226 		MT_USB_DEVICE(USB_VENDOR_ID_VTL,
2227 			USB_DEVICE_ID_VTL_MULTITOUCH_FF3F) },
2228 
2229 	/* Winbond Electronics Corp. */
2230 	{ .driver_data = MT_CLS_WIN_8_NO_STICKY_FINGERS,
2231 		HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8,
2232 			   USB_VENDOR_ID_WINBOND, USB_DEVICE_ID_TSTP_MTOUCH) },
2233 
2234 	/* Wistron panels */
2235 	{ .driver_data = MT_CLS_NSMU,
2236 		MT_USB_DEVICE(USB_VENDOR_ID_WISTRON,
2237 			USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH) },
2238 
2239 	/* XAT */
2240 	{ .driver_data = MT_CLS_NSMU,
2241 		MT_USB_DEVICE(USB_VENDOR_ID_XAT,
2242 			USB_DEVICE_ID_XAT_CSR) },
2243 
2244 	/* Xiroku */
2245 	{ .driver_data = MT_CLS_NSMU,
2246 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2247 			USB_DEVICE_ID_XIROKU_SPX) },
2248 	{ .driver_data = MT_CLS_NSMU,
2249 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2250 			USB_DEVICE_ID_XIROKU_MPX) },
2251 	{ .driver_data = MT_CLS_NSMU,
2252 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2253 			USB_DEVICE_ID_XIROKU_CSR) },
2254 	{ .driver_data = MT_CLS_NSMU,
2255 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2256 			USB_DEVICE_ID_XIROKU_SPX1) },
2257 	{ .driver_data = MT_CLS_NSMU,
2258 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2259 			USB_DEVICE_ID_XIROKU_MPX1) },
2260 	{ .driver_data = MT_CLS_NSMU,
2261 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2262 			USB_DEVICE_ID_XIROKU_CSR1) },
2263 	{ .driver_data = MT_CLS_NSMU,
2264 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2265 			USB_DEVICE_ID_XIROKU_SPX2) },
2266 	{ .driver_data = MT_CLS_NSMU,
2267 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2268 			USB_DEVICE_ID_XIROKU_MPX2) },
2269 	{ .driver_data = MT_CLS_NSMU,
2270 		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2271 			USB_DEVICE_ID_XIROKU_CSR2) },
2272 
2273 	/* Google MT devices */
2274 	{ .driver_data = MT_CLS_GOOGLE,
2275 		HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_GOOGLE,
2276 			USB_DEVICE_ID_GOOGLE_TOUCH_ROSE) },
2277 	{ .driver_data = MT_CLS_GOOGLE,
2278 		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8, USB_VENDOR_ID_GOOGLE,
2279 			USB_DEVICE_ID_GOOGLE_WHISKERS) },
2280 
2281 	/* Generic MT device */
2282 	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
2283 
2284 	/* Generic Win 8 certified MT device */
2285 	{  .driver_data = MT_CLS_WIN_8,
2286 		HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8,
2287 			HID_ANY_ID, HID_ANY_ID) },
2288 	{ }
2289 };
2290 MODULE_DEVICE_TABLE(hid, mt_devices);
2291 
2292 static const struct hid_usage_id mt_grabbed_usages[] = {
2293 	{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
2294 	{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
2295 };
2296 
2297 static struct hid_driver mt_driver = {
2298 	.name = "hid-multitouch",
2299 	.id_table = mt_devices,
2300 	.probe = mt_probe,
2301 	.remove = mt_remove,
2302 	.input_mapping = mt_input_mapping,
2303 	.input_mapped = mt_input_mapped,
2304 	.input_configured = mt_input_configured,
2305 	.feature_mapping = mt_feature_mapping,
2306 	.usage_table = mt_grabbed_usages,
2307 	.event = mt_event,
2308 	.report_fixup = mt_report_fixup,
2309 	.report = mt_report,
2310 #ifdef CONFIG_PM
2311 	.suspend = mt_suspend,
2312 	.reset_resume = mt_reset_resume,
2313 	.resume = mt_resume,
2314 #endif
2315 };
2316 module_hid_driver(mt_driver);
2317