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