projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'pm-6.16-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
[linux-2.6-block.git] / drivers / hid / hid-multitouch.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
5519cab4
BT		 2/*
3 * HID driver for multitouch panels
4 *
c2ef8f21 5 * Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
b0a78681 6 * Copyright (c) 2010-2013 Benjamin Tissoires <benjamin.tissoires@gmail.com>
c2ef8f21 7 * Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
b0a78681 8 * Copyright (c) 2012-2013 Red Hat, Inc
5519cab4 9 *
4875ac11
RN		 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 *
f786bba4
BT		 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.
5519cab4
BT		 21 */
22
23/*
5519cab4
BT		 24 */
25
b0a78681 26/*
f146d1c4 27 * This driver is regularly tested thanks to the test suite in hid-tools[1].
b0a78681
BT		 28 * Please run these regression tests before patching this module so that
29 * your patch won't break existing known devices.
30 *
f146d1c4 31 * [1] https://gitlab.freedesktop.org/libevdev/hid-tools
b0a78681
BT		 32 */
33
e8a05819 34#include <linux/bits.h>
5519cab4
BT		 35#include <linux/device.h>
36#include <linux/hid.h>
37#include <linux/module.h>
38#include <linux/slab.h>
5519cab4 39#include <linux/input/mt.h>
29cc309d 40#include <linux/jiffies.h>
49a5a827 41#include <linux/string.h>
4f4001bc 42#include <linux/timer.h>
5519cab4
BT		 43
44
45MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
ef2fafb3 46MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
5519cab4
BT		 47MODULE_DESCRIPTION("HID multitouch panels");
48MODULE_LICENSE("GPL");
49
50#include "hid-ids.h"
51
52/* quirks to control the device */
fd911896
BT		 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)
4f4001bc 69#define MT_QUIRK_STICKY_FINGERS BIT(16)
957b8dff 70#define MT_QUIRK_ASUS_CUSTOM_UP BIT(17)
d9c57a70 71#define MT_QUIRK_WIN8_PTP_BUTTONS BIT(18)
69ecd44d 72#define MT_QUIRK_SEPARATE_APP_REPORT BIT(19)
40d5bb87 73#define MT_QUIRK_FORCE_MULTI_INPUT BIT(20)
31a4cf1d 74#define MT_QUIRK_DISABLE_WAKEUP BIT(21)
a2f416bf 75#define MT_QUIRK_ORIENTATION_INVERT BIT(22)
5519cab4 76
9abebedb
AD		 77#define MT_INPUTMODE_TOUCHSCREEN 0x02
78#define MT_INPUTMODE_TOUCHPAD 0x03
79
2c6e0277
SF		 80#define MT_BUTTONTYPE_CLICKPAD 0
81
02946f4b
BT		 82enum latency_mode {
83 HID_LATENCY_NORMAL = 0,
84 HID_LATENCY_HIGH = 1,
85};
86
e8a05819
DT		 87enum 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
4f4001bc 94#define MT_IO_FLAGS_RUNNING 0
96098274
BT		 95#define MT_IO_FLAGS_ACTIVE_SLOTS 1
96#define MT_IO_FLAGS_PENDING_SLOTS 2
4f4001bc 97
01eaac7e
BT		 98static const bool mtrue = true; /* default for true */
99static const bool mfalse; /* default for false */
100static 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
106struct 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? */
5519cab4
BT		 113};
114
f146d1c4
BT		 115struct mt_application {
116 struct list_head list;
117 unsigned int application;
69ecd44d 118 unsigned int report_id;
01eaac7e 119 struct list_head mt_usages; /* mt usages list */
3ceb3826
BT		 120
121 __s32 quirks;
122
01eaac7e
BT		 123 __s32 *scantime; /* scantime reported */
124 __s32 scantime_logical_max; /* max value for raw scantime */
f146d1c4 125
01eaac7e 126 __s32 *raw_cc; /* contact count in the report */
f146d1c4
BT		 127 int left_button_state; /* left button state */
128 unsigned int mt_flags; /* flags to pass to input-mt */
129
28a042a3
DT		 130 unsigned long *pending_palm_slots; /* slots where we reported palm
131 * and need to release */
132
f146d1c4
BT		 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
f146d1c4
BT		 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
eec29e3d
BT		 148struct 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;
c2ef8f21 156 bool is_indirect; /* true for touchpads */
6aef704e 157 bool export_all_inputs; /* do not ignore mouse, keyboards, etc... */
eec29e3d
BT		 158};
159
8dfe14b3
BT		 160struct 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
5519cab4 167struct mt_device {
eec29e3d 168 struct mt_class mtclass; /* our mt device class */
4f4001bc 169 struct timer_list release_timer; /* to release sticky fingers */
0ee32774 170 struct hid_device *hdev; /* hid_device we're attached to */
4f4001bc 171 unsigned long mt_io_flags; /* mt flags (MT_IO_FLAGS_*) */
7f81c8db 172 __u8 inputmode_value; /* InputMode HID feature value */
9498f954 173 __u8 maxcontacts;
2c6e0277 174 bool is_buttonpad; /* is this device a button pad? */
76f5902a 175 bool serial_maybe; /* need to check for serial protocol */
f146d1c4
BT		 176
177 struct list_head applications;
8dfe14b3 178 struct list_head reports;
5519cab4
BT		 179};
180
f146d1c4
BT		 181static void mt_post_parse_default_settings(struct mt_device *td,
182 struct mt_application *app);
183static void mt_post_parse(struct mt_device *td, struct mt_application *app);
a69c5f8b 184
5519cab4 185/* classes of device behavior */
22408283
BT		 186#define MT_CLS_DEFAULT 0x0001
187
a062cc5a
SC		 188#define MT_CLS_SERIAL 0x0002
189#define MT_CLS_CONFIDENCE 0x0003
5e7ea11f
BT		 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
0fa9c616 194/* reserved 0x0008 */
b7ea95ff 195#define MT_CLS_INRANGE_CONTACTNUMBER 0x0009
dc3e1d80 196#define MT_CLS_NSMU 0x000a
0fa9c616
BT		 197/* reserved 0x0010 */
198/* reserved 0x0011 */
f961bd35 199#define MT_CLS_WIN_8 0x0012
6aef704e 200#define MT_CLS_EXPORT_ALL_INPUTS 0x0013
27a6f701 201/* reserved 0x0014 */
40d5bb87 202#define MT_CLS_WIN_8_FORCE_MULTI_INPUT 0x0015
31a4cf1d 203#define MT_CLS_WIN_8_DISABLE_WAKEUP 0x0016
08b9a61a 204#define MT_CLS_WIN_8_NO_STICKY_FINGERS 0x0017
54eed5c7 205#define MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU 0x0018
22408283
BT		 206
207/* vendor specific classes */
208#define MT_CLS_3M 0x0101
0fa9c616 209/* reserved 0x0102 */
22408283 210#define MT_CLS_EGALAX 0x0103
1b723e8d 211#define MT_CLS_EGALAX_SERIAL 0x0104
847672cd 212#define MT_CLS_TOPSEED 0x0105
2258e863 213#define MT_CLS_PANASONIC 0x0106
77723e3b 214#define MT_CLS_FLATFROG 0x0107
cdcd3ac4
JK		 215#define MT_CLS_GENERALTOUCH_TWOFINGERS 0x0108
216#define MT_CLS_GENERALTOUCH_PWT_TENFINGERS 0x0109
f3287a99 217#define MT_CLS_LG 0x010a
957b8dff 218#define MT_CLS_ASUS 0x010b
da10bc25 219#define MT_CLS_VTL 0x0110
0e82232c 220#define MT_CLS_GOOGLE 0x0111
843e475f 221#define MT_CLS_RAZER_BLADE_STEALTH 0x0112
69ecd44d 222#define MT_CLS_SMART_TECH 0x0113
de07af0a 223#define MT_CLS_SIS 0x0457
5519cab4 224
9498f954 225#define MT_DEFAULT_MAXCONTACT 10
afbcb04c 226#define MT_MAX_MAXCONTACT 250
9498f954 227
29cc309d
NB		 228/*
229 * Resync device and local timestamps after that many microseconds without
230 * receiving data.
231 */
232#define MAX_TIMESTAMP_INTERVAL 1000000
233
2c2110e9
HR		 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
5519cab4
BT		 237/*
238 * these device-dependent functions determine what slot corresponds
239 * to a valid contact that was just read.
240 */
241
01eaac7e
BT		 242static int cypress_compute_slot(struct mt_application *application,
243 struct mt_usages *slot)
a3b5e577 244{
01eaac7e
BT		 245 if (*slot->contactid != 0 || application->num_received == 0)
246 return *slot->contactid;
a3b5e577
BT		 247 else
248 return -1;
249}
250
cf6d15d7 251static const struct mt_class mt_classes[] = {
2d93666e 252 { .name = MT_CLS_DEFAULT,
dc3e1d80
BT		 253 .quirks = MT_QUIRK_ALWAYS_VALID |
254 MT_QUIRK_CONTACT_CNT_ACCURATE },
255 { .name = MT_CLS_NSMU,
9498f954 256 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
a062cc5a
SC		 257 { .name = MT_CLS_SERIAL,
258 .quirks = MT_QUIRK_ALWAYS_VALID},
22408283
BT		 259 { .name = MT_CLS_CONFIDENCE,
260 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
5e7ea11f
BT		 261 { .name = MT_CLS_CONFIDENCE_CONTACT_ID,
262 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
263 MT_QUIRK_SLOT_IS_CONTACTID },
22408283
BT		 264 { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
265 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
266 MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
1e9cf35b 267 { .name = MT_CLS_DUAL_INRANGE_CONTACTID,
2d93666e
BT		 268 .quirks = MT_QUIRK_VALID_IS_INRANGE |
269 MT_QUIRK_SLOT_IS_CONTACTID,
270 .maxcontacts = 2 },
1e9cf35b 271 { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
2d93666e
BT		 272 .quirks = MT_QUIRK_VALID_IS_INRANGE |
273 MT_QUIRK_SLOT_IS_CONTACTNUMBER,
274 .maxcontacts = 2 },
b7ea95ff
AT		 275 { .name = MT_CLS_INRANGE_CONTACTNUMBER,
276 .quirks = MT_QUIRK_VALID_IS_INRANGE |
277 MT_QUIRK_SLOT_IS_CONTACTNUMBER },
f961bd35
BT		 278 { .name = MT_CLS_WIN_8,
279 .quirks = MT_QUIRK_ALWAYS_VALID |
280 MT_QUIRK_IGNORE_DUPLICATES |
281 MT_QUIRK_HOVERING |
4f4001bc 282 MT_QUIRK_CONTACT_CNT_ACCURATE |
d9c57a70 283 MT_QUIRK_STICKY_FINGERS |
c23e2043
BT		 284 MT_QUIRK_WIN8_PTP_BUTTONS,
285 .export_all_inputs = true },
6aef704e
BT		 286 { .name = MT_CLS_EXPORT_ALL_INPUTS,
287 .quirks = MT_QUIRK_ALWAYS_VALID |
288 MT_QUIRK_CONTACT_CNT_ACCURATE,
289 .export_all_inputs = true },
40d5bb87
BT		 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 },
54eed5c7
TJ		 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 },
31a4cf1d
HG		 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 },
08b9a61a
JE		 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 },
22408283
BT		 324
325 /*
326 * vendor specific classes
327 */
328 { .name = MT_CLS_3M,
329 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
e9d0a26d
HC		 330 MT_QUIRK_SLOT_IS_CONTACTID |
331 MT_QUIRK_TOUCH_SIZE_SCALING,
22408283
BT		 332 .sn_move = 2048,
333 .sn_width = 128,
c5d40be5
HR		 334 .sn_height = 128,
335 .maxcontacts = 60,
336 },
4875ac11
RN		 337 { .name = MT_CLS_EGALAX,
338 .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
2261bb9f 339 MT_QUIRK_VALID_IS_INRANGE,
4875ac11
RN		 340 .sn_move = 4096,
341 .sn_pressure = 32,
342 },
1b723e8d
BT		 343 { .name = MT_CLS_EGALAX_SERIAL,
344 .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
345 MT_QUIRK_ALWAYS_VALID,
4875ac11
RN		 346 .sn_move = 4096,
347 .sn_pressure = 32,
348 },
847672cd
BT		 349 { .name = MT_CLS_TOPSEED,
350 .quirks = MT_QUIRK_ALWAYS_VALID,
351 .is_indirect = true,
352 .maxcontacts = 2,
353 },
2258e863
DK		 354 { .name = MT_CLS_PANASONIC,
355 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
356 .maxcontacts = 4 },
f5ff4e1e
XY		 357 { .name = MT_CLS_GENERALTOUCH_TWOFINGERS,
358 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
359 MT_QUIRK_VALID_IS_INRANGE |
7b226292 360 MT_QUIRK_SLOT_IS_CONTACTID,
f5ff4e1e
XY		 361 .maxcontacts = 2
362 },
363 { .name = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
364 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
7b226292 365 MT_QUIRK_SLOT_IS_CONTACTID
f5ff4e1e 366 },
043b403a 367
77723e3b
HR		 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 },
f3287a99
BT		 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 },
957b8dff
JPRV		 380 { .name = MT_CLS_ASUS,
381 .quirks = MT_QUIRK_ALWAYS_VALID |
382 MT_QUIRK_CONTACT_CNT_ACCURATE |
383 MT_QUIRK_ASUS_CUSTOM_UP },
da10bc25
MM		 384 { .name = MT_CLS_VTL,
385 .quirks = MT_QUIRK_ALWAYS_VALID |
386 MT_QUIRK_CONTACT_CNT_ACCURATE |
387 MT_QUIRK_FORCE_GET_FEATURE,
388 },
0e82232c
WNH		 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 },
843e475f
BT		 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 },
69ecd44d
BT		 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 },
de07af0a 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 },
2d93666e 413 { }
5519cab4
BT		 414};
415
eec29e3d
BT		 416static ssize_t mt_show_quirks(struct device *dev,
417 struct device_attribute *attr,
418 char *buf)
419{
ee79a8f8 420 struct hid_device *hdev = to_hid_device(dev);
eec29e3d
BT		 421 struct mt_device *td = hid_get_drvdata(hdev);
422
423 return sprintf(buf, "%u\n", td->mtclass.quirks);
424}
425
426static ssize_t mt_set_quirks(struct device *dev,
427 struct device_attribute *attr,
428 const char *buf, size_t count)
429{
ee79a8f8 430 struct hid_device *hdev = to_hid_device(dev);
eec29e3d 431 struct mt_device *td = hid_get_drvdata(hdev);
f146d1c4 432 struct mt_application *application;
eec29e3d
BT		 433
434 unsigned long val;
435
436 if (kstrtoul(buf, 0, &val))
437 return -EINVAL;
438
439 td->mtclass.quirks = val;
440
f146d1c4 441 list_for_each_entry(application, &td->applications, list) {
3ceb3826
BT		 442 application->quirks = val;
443 if (!application->have_contact_count)
444 application->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
f146d1c4
BT		 445 }
446
eec29e3d
BT		 447 return count;
448}
449
450static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
451
452static struct attribute *sysfs_attrs[] = {
453 &dev_attr_quirks.attr,
454 NULL
455};
456
9182fb98 457static const struct attribute_group mt_attribute_group = {
eec29e3d
BT		 458 .attrs = sysfs_attrs
459};
460
6d4f5440
MW		 461static void mt_get_feature(struct hid_device *hdev, struct hid_report *report)
462{
3064a03b
AM		 463 int ret;
464 u32 size = hid_report_len(report);
6d4f5440
MW		 465 u8 *buf;
466
467 /*
b897f6db
BT		 468 * Do not fetch the feature report if the device has been explicitly
469 * marked as non-capable.
6d4f5440 470 */
adaabbf4 471 if (hdev->quirks & HID_QUIRK_NO_INIT_REPORTS)
6d4f5440
MW		 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, report->id, buf, size,
479 HID_FEATURE_REPORT, 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(hdev, HID_FEATURE_REPORT, buf,
485 size, 0);
486 if (ret)
487 dev_warn(&hdev->dev, "failed to report feature\n");
488 }
489
490 kfree(buf);
491}
492
f635bd11 493static void mt_feature_mapping(struct hid_device *hdev,
5519cab4
BT		 494 struct hid_field *field, struct hid_usage *usage)
495{
9498f954
BT		 496 struct mt_device *td = hid_get_drvdata(hdev);
497
498 switch (usage->hid) {
9498f954 499 case HID_DG_CONTACTMAX:
6d4f5440
MW		 500 mt_get_feature(hdev, field->report);
501
9498f954 502 td->maxcontacts = field->value[0];
afbcb04c
BT		 503 if (!td->maxcontacts &&
504 field->logical_maximum <= MT_MAX_MAXCONTACT)
505 td->maxcontacts = field->logical_maximum;
eec29e3d 506 if (td->mtclass.maxcontacts)
9498f954 507 /* check if the maxcontacts is given by the class */
eec29e3d 508 td->maxcontacts = td->mtclass.maxcontacts;
9498f954 509
2c6e0277
SF		 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
6d4f5440 517 mt_get_feature(hdev, field->report);
2c6e0277
SF		 518 if (field->value[usage->usage_index] == MT_BUTTONTYPE_CLICKPAD)
519 td->is_buttonpad = true;
520
9498f954 521 break;
45c5c682
BT		 522 case 0xff0000c5:
523 /* Retrieve the Win8 blob once to enable some devices */
524 if (usage->usage_index == 0)
525 mt_get_feature(hdev, field->report);
526 break;
5519cab4
BT		 527 }
528}
529
530static 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(input, code, fmin, fmax, fuzz, 0);
37cf6e6f 537 input_abs_set_res(input, code, hidinput_calc_abs_res(field, code));
5519cab4
BT		 538}
539
01eaac7e
BT		 540static 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(&hdev->dev, 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(&usage->list, &application->mt_usages);
564
565 return usage;
566}
567
f146d1c4 568static struct mt_application *mt_allocate_application(struct mt_device *td,
69ecd44d 569 struct hid_report *report)
f146d1c4 570{
69ecd44d 571 unsigned int application = report->application;
f146d1c4
BT		 572 struct mt_application *mt_application;
573
574 mt_application = devm_kzalloc(&td->hdev->dev, sizeof(*mt_application),
575 GFP_KERNEL);
576 if (!mt_application)
577 return NULL;
578
579 mt_application->application = application;
01eaac7e 580 INIT_LIST_HEAD(&mt_application->mt_usages);
f146d1c4
BT		 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
01eaac7e
BT		 593 mt_application->scantime = DEFAULT_ZERO;
594 mt_application->raw_cc = DEFAULT_ZERO;
3ceb3826 595 mt_application->quirks = td->mtclass.quirks;
69ecd44d 596 mt_application->report_id = report->id;
f146d1c4
BT		 597
598 list_add_tail(&mt_application->list, &td->applications);
599
600 return mt_application;
601}
602
603static struct mt_application *mt_find_application(struct mt_device *td,
69ecd44d 604 struct hid_report *report)
f146d1c4 605{
69ecd44d 606 unsigned int application = report->application;
f146d1c4
BT		 607 struct mt_application *tmp, *mt_application = NULL;
608
609 list_for_each_entry(tmp, &td->applications, list) {
610 if (application == tmp->application) {
69ecd44d
BT		 611 if (!(td->mtclass.quirks & MT_QUIRK_SEPARATE_APP_REPORT) ||
612 tmp->report_id == report->id) {
613 mt_application = tmp;
614 break;
615 }
f146d1c4
BT		 616 }
617 }
618
619 if (!mt_application)
69ecd44d 620 mt_application = mt_allocate_application(td, report);
f146d1c4
BT		 621
622 return mt_application;
623}
624
8dfe14b3
BT		 625static 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(&td->hdev->dev, sizeof(*rdata), GFP_KERNEL);
633 if (!rdata)
634 return NULL;
635
636 rdata->report = report;
69ecd44d 637 rdata->application = mt_find_application(td, report);
8dfe14b3
BT		 638
639 if (!rdata->application) {
640 devm_kfree(&td->hdev->dev, 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
a2353e3b
AZ		 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 }
8dfe14b3
BT		 657 }
658 }
659
660 list_add_tail(&rdata->list, &td->reports);
661
662 return rdata;
663}
664
665static 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
01eaac7e
BT		 683static void mt_store_field(struct hid_device *hdev,
684 struct mt_application *application,
685 __s32 *value,
686 size_t offset)
ed9d5c96 687{
01eaac7e
BT		 688 struct mt_usages *usage;
689 __s32 **target;
690
691 if (list_empty(&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);
3ac36d15 697
01eaac7e 698 if (!usage)
3ac36d15
BT		 699 return;
700
01eaac7e
BT		 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) {
81bcbad5
BT		 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 }
01eaac7e
BT		 714 usage = mt_allocate_usage(hdev, application);
715 if (!usage)
716 return;
717
718 target = (__s32 **)((char *)usage + offset);
719 }
720
721 *target = value;
ed9d5c96
BT		 722}
723
01eaac7e
BT		 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
a69c5f8b 729static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
5519cab4 730 struct hid_field *field, struct hid_usage *usage,
f146d1c4 731 unsigned long **bit, int *max, struct mt_application *app)
5519cab4
BT		 732{
733 struct mt_device *td = hid_get_drvdata(hdev);
eec29e3d 734 struct mt_class *cls = &td->mtclass;
c2ef8f21 735 int code;
349fd670 736 struct hid_usage *prev_usage = NULL;
4875ac11 737
76f5902a
HR		 738 /*
739 * Model touchscreens providing buttons as touchpads.
c2ef8f21 740 */
ba6b055e
BT		 741 if (field->application == HID_DG_TOUCHSCREEN &&
742 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
f146d1c4 743 app->mt_flags |= INPUT_MT_POINTER;
9abebedb
AD		 744 td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
745 }
c2ef8f21 746
015fdaa9
BT		 747 /* count the buttons on touchpads */
748 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
f146d1c4 749 app->buttons_count++;
015fdaa9 750
349fd670
BT		 751 if (usage->usage_index)
752 prev_usage = &field->usage[usage->usage_index - 1];
753
5519cab4
BT		 754 switch (usage->hid & HID_USAGE_PAGE) {
755
756 case HID_UP_GENDESK:
757 switch (usage->hid) {
758 case HID_GD_X:
01eaac7e 759 if (prev_usage && (prev_usage->hid == usage->hid)) {
f146d1c4 760 code = ABS_MT_TOOL_X;
01eaac7e
BT		 761 MT_STORE_FIELD(cx);
762 } else {
f146d1c4 763 code = ABS_MT_POSITION_X;
01eaac7e
BT		 764 MT_STORE_FIELD(x);
765 }
349fd670 766
f146d1c4 767 set_abs(hi->input, code, field, cls->sn_move);
01eaac7e 768
ba6b055e
BT		 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(hi->input,
777 ABS_MT_TOOL_TYPE,
778 MT_TOOL_DIAL,
779 MT_TOOL_DIAL, 0, 0);
780 }
781
5519cab4
BT		 782 return 1;
783 case HID_GD_Y:
01eaac7e 784 if (prev_usage && (prev_usage->hid == usage->hid)) {
f146d1c4 785 code = ABS_MT_TOOL_Y;
01eaac7e
BT		 786 MT_STORE_FIELD(cy);
787 } else {
f146d1c4 788 code = ABS_MT_POSITION_Y;
01eaac7e
BT		 789 MT_STORE_FIELD(y);
790 }
349fd670 791
f146d1c4 792 set_abs(hi->input, code, field, cls->sn_move);
01eaac7e 793
5519cab4
BT		 794 return 1;
795 }
796 return 0;
797
798 case HID_UP_DIGITIZER:
799 switch (usage->hid) {
800 case HID_DG_INRANGE:
3ceb3826 801 if (app->quirks & MT_QUIRK_HOVERING) {
9b3bb9b8
BT		 802 input_set_abs_params(hi->input,
803 ABS_MT_DISTANCE, 0, 1, 0, 0);
804 }
01eaac7e 805 MT_STORE_FIELD(inrange_state);
5519cab4
BT		 806 return 1;
807 case HID_DG_CONFIDENCE:
794c6133 808 if ((cls->name == MT_CLS_WIN_8 ||
31a4cf1d 809 cls->name == MT_CLS_WIN_8_FORCE_MULTI_INPUT ||
54eed5c7 810 cls->name == MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU ||
31a4cf1d 811 cls->name == MT_CLS_WIN_8_DISABLE_WAKEUP) &&
f9024374
DT		 812 (field->application == HID_DG_TOUCHPAD ||
813 field->application == HID_DG_TOUCHSCREEN))
3ceb3826 814 app->quirks |= MT_QUIRK_CONFIDENCE;
9152c7d7
DT		 815
816 if (app->quirks & MT_QUIRK_CONFIDENCE)
817 input_set_abs_params(hi->input,
818 ABS_MT_TOOL_TYPE,
819 MT_TOOL_FINGER,
820 MT_TOOL_PALM, 0, 0);
821
01eaac7e 822 MT_STORE_FIELD(confidence_state);
5519cab4
BT		 823 return 1;
824 case HID_DG_TIPSWITCH:
ba6b055e
BT		 825 if (field->application != HID_GD_SYSTEM_MULTIAXIS)
826 input_set_capability(hi->input,
827 EV_KEY, BTN_TOUCH);
01eaac7e 828 MT_STORE_FIELD(tip_state);
5519cab4
BT		 829 return 1;
830 case HID_DG_CONTACTID:
01eaac7e 831 MT_STORE_FIELD(contactid);
f146d1c4 832 app->touches_by_report++;
5519cab4
BT		 833 return 1;
834 case HID_DG_WIDTH:
3ceb3826 835 if (!(app->quirks & MT_QUIRK_NO_AREA))
77723e3b
HR		 836 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
837 cls->sn_width);
01eaac7e 838 MT_STORE_FIELD(w);
5519cab4
BT		 839 return 1;
840 case HID_DG_HEIGHT:
3ceb3826 841 if (!(app->quirks & MT_QUIRK_NO_AREA)) {
77723e3b
HR		 842 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
843 cls->sn_height);
00720277
WNH		 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(hi->input,
852 ABS_MT_ORIENTATION, 0, 1, 0, 0);
77723e3b 853 }
01eaac7e 854 MT_STORE_FIELD(h);
5519cab4
BT		 855 return 1;
856 case HID_DG_TIPPRESSURE:
5519cab4
BT		 857 set_abs(hi->input, ABS_MT_PRESSURE, field,
858 cls->sn_pressure);
01eaac7e 859 MT_STORE_FIELD(p);
5519cab4 860 return 1;
29cc309d 861 case HID_DG_SCANTIME:
29cc309d 862 input_set_capability(hi->input, EV_MSC, MSC_TIMESTAMP);
01eaac7e
BT		 863 app->scantime = &field->value[usage->usage_index];
864 app->scantime_logical_max = field->logical_maximum;
29cc309d 865 return 1;
5519cab4 866 case HID_DG_CONTACTCOUNT:
01eaac7e
BT		 867 app->have_contact_count = true;
868 app->raw_cc = &field->value[usage->usage_index];
5519cab4 869 return 1;
00720277 870 case HID_DG_AZIMUTH:
00720277
WNH		 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(hi->input, ABS_MT_ORIENTATION,
877 -field->logical_maximum / 4,
878 field->logical_maximum / 4,
879 cls->sn_move ?
880 field->logical_maximum / cls->sn_move : 0, 0);
01eaac7e 881 MT_STORE_FIELD(a);
00720277 882 return 1;
5519cab4 883 case HID_DG_CONTACTMAX:
01eaac7e 884 /* contact max are global to the report */
5519cab4 885 return -1;
c2ef8f21
BT		 886 case HID_DG_TOUCH:
887 /* Legacy devices use TIPSWITCH and not TOUCH.
888 * Let's just ignore this field. */
889 return -1;
65b258e9 890 }
5519cab4
BT		 891 /* let hid-input decide for the others */
892 return 0;
893
c2ef8f21
BT		 894 case HID_UP_BUTTON:
895 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
594312b8
BT		 896 /*
897 * MS PTP spec says that external buttons left and right have
898 * usages 2 and 3.
899 */
3ceb3826 900 if ((app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
594312b8
BT		 901 field->application == HID_DG_TOUCHPAD &&
902 (usage->hid & HID_USAGE) > 1)
903 code--;
ba6b055e
BT		 904
905 if (field->application == HID_GD_SYSTEM_MULTIAXIS)
906 code = BTN_0 + ((usage->hid - 1) & HID_USAGE);
907
c2ef8f21 908 hid_map_usage(hi, usage, bit, max, EV_KEY, code);
35556bed
MZ		 909 if (!*bit)
910 return -1;
c2ef8f21
BT		 911 input_set_capability(hi->input, EV_KEY, code);
912 return 1;
913
5519cab4
BT		 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
f146d1c4 922static int mt_compute_slot(struct mt_device *td, struct mt_application *app,
01eaac7e 923 struct mt_usages *slot,
f146d1c4 924 struct input_dev *input)
5519cab4 925{
3ceb3826 926 __s32 quirks = app->quirks;
5519cab4 927
2d93666e 928 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
01eaac7e 929 return *slot->contactid;
5519cab4 930
2d93666e 931 if (quirks & MT_QUIRK_CYPRESS)
01eaac7e 932 return cypress_compute_slot(app, slot);
a3b5e577 933
2d93666e 934 if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
f146d1c4 935 return app->num_received;
5572da08 936
4a6ee685 937 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
01eaac7e 938 return *slot->contactid - 1;
4a6ee685 939
01eaac7e 940 return input_mt_get_slot_by_key(input, *slot->contactid);
3e1b5015
HR		 941}
942
28a042a3
DT		 943static 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(slotnum, app->pending_palm_slots);
952
953 input_mt_slot(input, slotnum);
5fc70e35 954 input_mt_report_slot_inactive(input);
28a042a3
DT		 955
956 need_sync = true;
957 }
958
959 if (need_sync) {
960 input_mt_sync_frame(input);
961 input_sync(input);
962 }
963}
964
3e1b5015
HR		 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 */
f146d1c4
BT		 969static void mt_sync_frame(struct mt_device *td, struct mt_application *app,
970 struct input_dev *input)
3e1b5015 971{
3ceb3826 972 if (app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS)
f146d1c4 973 input_event(input, EV_KEY, BTN_LEFT, app->left_button_state);
127e71bd 974
76f5902a 975 input_mt_sync_frame(input);
f146d1c4 976 input_event(input, EV_MSC, MSC_TIMESTAMP, app->timestamp);
5519cab4 977 input_sync(input);
28a042a3
DT		 978
979 mt_release_pending_palms(td, app, input);
980
f146d1c4
BT		 981 app->num_received = 0;
982 app->left_button_state = 0;
983
96098274
BT		 984 if (test_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags))
985 set_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
986 else
987 clear_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
988 clear_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
5519cab4
BT		 989}
990
01eaac7e 991static int mt_compute_timestamp(struct mt_application *app, __s32 value)
29cc309d 992{
f146d1c4
BT		 993 long delta = value - app->prev_scantime;
994 unsigned long jdelta = jiffies_to_usecs(jiffies - app->jiffies);
29cc309d 995
f146d1c4 996 app->jiffies = jiffies;
29cc309d
NB		 997
998 if (delta < 0)
01eaac7e 999 delta += app->scantime_logical_max;
29cc309d
NB		 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
f146d1c4 1008 return app->timestamp + delta;
29cc309d
NB		 1009}
1010
a69c5f8b 1011static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
5519cab4 1012 struct hid_usage *usage, __s32 value)
55978fa9
BT		 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
01eaac7e
BT		 1021static int mt_process_slot(struct mt_device *td, struct input_dev *input,
1022 struct mt_application *app,
1023 struct mt_usages *slot)
5519cab4 1024{
01eaac7e 1025 struct input_mt *mt = input->mt;
a2f416bf 1026 struct hid_device *hdev = td->hdev;
3ceb3826 1027 __s32 quirks = app->quirks;
01eaac7e
BT		 1028 bool valid = true;
1029 bool confidence_state = true;
1030 bool inrange_state = false;
1031 int active;
1032 int slotnum;
ba6b055e 1033 int tool = MT_TOOL_FINGER;
5519cab4 1034
01eaac7e
BT		 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(i_slot) &&
1062 input_mt_is_used(mt, 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
9152c7d7 1072 active = *slot->tip_state || inrange_state;
01eaac7e 1073
ba6b055e
BT		 1074 if (app->application == HID_GD_SYSTEM_MULTIAXIS)
1075 tool = MT_TOOL_DIAL;
28a042a3 1076 else if (unlikely(!confidence_state)) {
9152c7d7 1077 tool = MT_TOOL_PALM;
306d5acb 1078 if (!active && mt &&
28a042a3
DT		 1079 input_mt_is_active(&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(slotnum, app->pending_palm_slots);
1091 }
1092 }
ba6b055e 1093
01eaac7e 1094 input_mt_slot(input, slotnum);
ba6b055e 1095 input_mt_report_slot_state(input, tool, active);
01eaac7e
BT		 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;
a2f416bf
AB		 1104 int x;
1105 int y;
1106 int cx;
1107 int cy;
01eaac7e
BT		 1108
1109 if (slot->a != DEFAULT_ZERO) {
00720277
WNH		 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 */
01eaac7e
BT		 1120 azimuth = *slot->a;
1121 max_azimuth = input_abs_get_max(input,
1122 ABS_MT_ORIENTATION);
1123 if (azimuth > max_azimuth * 2)
1124 azimuth -= max_azimuth * 4;
1125 orientation = -azimuth;
a2f416bf
AB		 1126 if (quirks & MT_QUIRK_ORIENTATION_INVERT)
1127 orientation = -orientation;
1128
01eaac7e 1129 }
5519cab4 1130
01eaac7e 1131 if (quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
9152c7d7
DT		 1132 /*
1133 * divided by two to match visual scale of touch
1134 * for devices with this quirk
1135 */
01eaac7e
BT		 1136 major = major >> 1;
1137 minor = minor >> 1;
1138 }
55746d28 1139
a2f416bf
AB		 1140 x = hdev->quirks & HID_QUIRK_X_INVERT ?
1141 input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->x :
1142 *slot->x;
1143 y = hdev->quirks & HID_QUIRK_Y_INVERT ?
1144 input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->y :
1145 *slot->y;
1146 cx = hdev->quirks & HID_QUIRK_X_INVERT ?
1147 input_abs_get_max(input, ABS_MT_POSITION_X) - *slot->cx :
1148 *slot->cx;
1149 cy = hdev->quirks & HID_QUIRK_Y_INVERT ?
1150 input_abs_get_max(input, ABS_MT_POSITION_Y) - *slot->cy :
1151 *slot->cy;
1152
1153 input_event(input, EV_ABS, ABS_MT_POSITION_X, x);
1154 input_event(input, EV_ABS, ABS_MT_POSITION_Y, y);
1155 input_event(input, EV_ABS, ABS_MT_TOOL_X, cx);
1156 input_event(input, EV_ABS, ABS_MT_TOOL_Y, cy);
01eaac7e
BT		 1157 input_event(input, EV_ABS, ABS_MT_DISTANCE, !*slot->tip_state);
1158 input_event(input, EV_ABS, ABS_MT_ORIENTATION, orientation);
1159 input_event(input, EV_ABS, ABS_MT_PRESSURE, *slot->p);
1160 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
1161 input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
1162
1163 set_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
1164 }
127e71bd 1165
01eaac7e
BT		 1166 return 0;
1167}
1168
1169static 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)
55978fa9 1190 return;
5519cab4 1191
01eaac7e
BT		 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;
54f4c0c3 1202 }
2d93666e 1203 }
01eaac7e
BT		 1204
1205 input_event(input, usage->type, usage->code, value);
55978fa9 1206}
5519cab4 1207
8dfe14b3
BT		 1208static void mt_touch_report(struct hid_device *hid,
1209 struct mt_report_data *rdata)
55978fa9
BT		 1210{
1211 struct mt_device *td = hid_get_drvdata(hid);
8dfe14b3
BT		 1212 struct hid_report *report = rdata->report;
1213 struct mt_application *app = rdata->application;
55978fa9 1214 struct hid_field *field;
01eaac7e
BT		 1215 struct input_dev *input;
1216 struct mt_usages *slot;
55746d28 1217 bool first_packet;
55978fa9 1218 unsigned count;
f146d1c4
BT		 1219 int r, n;
1220 int scantime = 0;
1221 int contact_count = -1;
5519cab4 1222
4f4001bc 1223 /* sticky fingers release in progress, abort */
be6e2b57 1224 if (test_and_set_bit_lock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
4f4001bc
BT		 1225 return;
1226
01eaac7e
BT		 1227 scantime = *app->scantime;
1228 app->timestamp = mt_compute_timestamp(app, scantime);
1229 if (app->raw_cc != DEFAULT_ZERO)
1230 contact_count = *app->raw_cc;
1231
c2517f62
BT		 1232 /*
1233 * Includes multi-packet support where subsequent
1234 * packets are sent with zero contactcount.
1235 */
01eaac7e 1236 if (contact_count >= 0) {
af8dc4d0
HG		 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 */
3ceb3826 1244 if ((app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
f146d1c4
BT		 1245 app->num_received == 0 &&
1246 app->prev_scantime != scantime)
1247 app->num_expected = contact_count;
af8dc4d0 1248 /* A non 0 contact count always indicates a first packet */
f146d1c4
BT		 1249 else if (contact_count)
1250 app->num_expected = contact_count;
7e3cc447 1251 }
f146d1c4 1252 app->prev_scantime = scantime;
c2517f62 1253
f146d1c4 1254 first_packet = app->num_received == 0;
01eaac7e
BT		 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
55978fa9
BT		 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++)
01eaac7e
BT		 1271 mt_process_mt_event(hid, app, field,
1272 &field->usage[n], field->value[n],
1273 first_packet);
55978fa9 1274 }
5b62efd8 1275
f146d1c4 1276 if (app->num_received >= app->num_expected)
01eaac7e 1277 mt_sync_frame(td, app, input);
4f4001bc
BT		 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 */
3ceb3826 1297 if (app->quirks & MT_QUIRK_STICKY_FINGERS) {
96098274
BT		 1298 if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1299 mod_timer(&td->release_timer,
1300 jiffies + msecs_to_jiffies(100));
1301 else
8fa7292f 1302 timer_delete(&td->release_timer);
96098274 1303 }
4f4001bc 1304
be6e2b57 1305 clear_bit_unlock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
5519cab4
BT		 1306}
1307
b2c68a2f 1308static int mt_touch_input_configured(struct hid_device *hdev,
f146d1c4
BT		 1309 struct hid_input *hi,
1310 struct mt_application *app)
a69c5f8b
BT		 1311{
1312 struct mt_device *td = hid_get_drvdata(hdev);
1313 struct mt_class *cls = &td->mtclass;
1314 struct input_dev *input = hi->input;
b2c68a2f 1315 int ret;
a69c5f8b
BT		 1316
1317 if (!td->maxcontacts)
1318 td->maxcontacts = MT_DEFAULT_MAXCONTACT;
1319
f146d1c4 1320 mt_post_parse(td, app);
a69c5f8b 1321 if (td->serial_maybe)
f146d1c4 1322 mt_post_parse_default_settings(td, app);
a69c5f8b
BT		 1323
1324 if (cls->is_indirect)
f146d1c4 1325 app->mt_flags |= INPUT_MT_POINTER;
a69c5f8b 1326
3ceb3826 1327 if (app->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
f146d1c4 1328 app->mt_flags |= INPUT_MT_DROP_UNUSED;
a69c5f8b 1329
015fdaa9 1330 /* check for clickpads */
f146d1c4
BT		 1331 if ((app->mt_flags & INPUT_MT_POINTER) &&
1332 (app->buttons_count == 1))
2c6e0277
SF		 1333 td->is_buttonpad = true;
1334
1335 if (td->is_buttonpad)
015fdaa9
BT		 1336 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
1337
28a042a3
DT		 1338 app->pending_palm_slots = devm_kcalloc(&hi->input->dev,
1339 BITS_TO_LONGS(td->maxcontacts),
1340 sizeof(long),
1341 GFP_KERNEL);
1342 if (!app->pending_palm_slots)
1343 return -ENOMEM;
1344
f146d1c4 1345 ret = input_mt_init_slots(input, td->maxcontacts, app->mt_flags);
b2c68a2f
DT		 1346 if (ret)
1347 return ret;
a69c5f8b 1348
f146d1c4 1349 app->mt_flags = 0;
b2c68a2f 1350 return 0;
a69c5f8b
BT		 1351}
1352
957b8dff
JPRV		 1353#define mt_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, \
1354 max, EV_KEY, (c))
a69c5f8b
BT		 1355static 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{
6aef704e 1359 struct mt_device *td = hid_get_drvdata(hdev);
f146d1c4 1360 struct mt_application *application;
8dfe14b3
BT		 1361 struct mt_report_data *rdata;
1362
1363 rdata = mt_find_report_data(td, field->report);
1364 if (!rdata) {
1365 hid_err(hdev, "failed to allocate data for report\n");
1366 return 0;
1367 }
6aef704e 1368
8dfe14b3 1369 application = rdata->application;
3ceb3826 1370
6aef704e
BT		 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 &&
fa11aa72 1379 field->application != HID_DG_PEN &&
8fe89ef0
BT		 1380 field->application != HID_DG_TOUCHPAD &&
1381 field->application != HID_GD_KEYBOARD &&
e57f4e67 1382 field->application != HID_GD_SYSTEM_CONTROL &&
1fbf74ef 1383 field->application != HID_CP_CONSUMER_CONTROL &&
957b8dff 1384 field->application != HID_GD_WIRELESS_RADIO_CTLS &&
ba6b055e 1385 field->application != HID_GD_SYSTEM_MULTIAXIS &&
957b8dff 1386 !(field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS &&
3ceb3826 1387 application->quirks & MT_QUIRK_ASUS_CUSTOM_UP))
6f492f28 1388 return -1;
a69c5f8b 1389
957b8dff
JPRV		 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 */
39bbf402 1395 if (field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS &&
3ceb3826 1396 application->quirks & MT_QUIRK_ASUS_CUSTOM_UP &&
957b8dff
JPRV		 1397 (usage->hid & HID_USAGE_PAGE) == HID_UP_CUSTOM) {
1398 set_bit(EV_REP, 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
ba6b055e 1413 if (rdata->is_mt_collection)
f146d1c4
BT		 1414 return mt_touch_input_mapping(hdev, hi, field, usage, bit, max,
1415 application);
6aef704e 1416
7ffa13be
BT		 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
6aef704e
BT		 1424 /* let hid-core decide for the others */
1425 return 0;
a69c5f8b
BT		 1426}
1427
1428static 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{
ba6b055e
BT		 1432 struct mt_device *td = hid_get_drvdata(hdev);
1433 struct mt_report_data *rdata;
fa11aa72 1434
ba6b055e
BT		 1435 rdata = mt_find_report_data(td, field->report);
1436 if (rdata && rdata->is_mt_collection) {
4cf56a89
DT		 1437 /* We own these mappings, tell hid-input to ignore them */
1438 return -1;
1439 }
6aef704e
BT		 1440
1441 /* let hid-core decide for the others */
1442 return 0;
a69c5f8b
BT		 1443}
1444
1445static 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(hid);
8dfe14b3 1449 struct mt_report_data *rdata;
a69c5f8b 1450
8dfe14b3
BT		 1451 rdata = mt_find_report_data(td, field->report);
1452 if (rdata && rdata->is_mt_collection)
a69c5f8b
BT		 1453 return mt_touch_event(hid, field, usage, value);
1454
e55f6200 1455 return 0;
a69c5f8b
BT		 1456}
1457
fe73965d 1458static const __u8 *mt_report_fixup(struct hid_device *hdev, __u8 *rdesc,
c8000deb
DS		 1459 unsigned int *size)
1460{
1461 if (hdev->vendor == I2C_VENDOR_ID_GOODIX &&
1462 (hdev->product == I2C_DEVICE_ID_GOODIX_01E8 ||
3d88ba86 1463 hdev->product == I2C_DEVICE_ID_GOODIX_01E9)) {
c8000deb
DS		 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. \
1473It's possible that the touchpad firmware is not suitable for applying the fix. \
1474got: %x\n",
1475 rdesc[607]);
1476 }
1477 }
1478
1479 return rdesc;
1480}
1481
a69c5f8b
BT		 1482static void mt_report(struct hid_device *hid, struct hid_report *report)
1483{
1484 struct mt_device *td = hid_get_drvdata(hid);
e55f6200 1485 struct hid_field *field = report->field[0];
8dfe14b3 1486 struct mt_report_data *rdata;
a69c5f8b
BT		 1487
1488 if (!(hid->claimed & HID_CLAIMED_INPUT))
1489 return;
1490
8dfe14b3
BT		 1491 rdata = mt_find_report_data(td, report);
1492 if (rdata && rdata->is_mt_collection)
1493 return mt_touch_report(hid, rdata);
fa11aa72 1494
e55f6200
BT		 1495 if (field && field->hidinput && field->hidinput->input)
1496 input_sync(field->hidinput->input);
5519cab4
BT		 1497}
1498
7f81c8db
BT		 1499static bool mt_need_to_apply_feature(struct hid_device *hdev,
1500 struct hid_field *field,
02946f4b
BT		 1501 struct hid_usage *usage,
1502 enum latency_mode latency,
e8a05819 1503 enum report_mode report_mode,
ec6adef5 1504 bool *inputmode_found)
5519cab4
BT		 1505{
1506 struct mt_device *td = hid_get_drvdata(hdev);
da10bc25 1507 struct mt_class *cls = &td->mtclass;
7f81c8db
BT		 1508 struct hid_report *report = field->report;
1509 unsigned int index = usage->usage_index;
da10bc25 1510 char *buf;
3064a03b 1511 u32 report_len;
7f81c8db 1512 int max;
5519cab4 1513
7f81c8db
BT		 1514 switch (usage->hid) {
1515 case HID_DG_INPUTMODE:
ec6adef5
BT		 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
da10bc25 1524 if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) {
7f81c8db
BT		 1525 report_len = hid_report_len(report);
1526 buf = hid_alloc_report_buf(report, GFP_KERNEL);
da10bc25 1527 if (!buf) {
7f81c8db
BT		 1528 hid_err(hdev,
1529 "failed to allocate buffer for report\n");
1530 return false;
da10bc25 1531 }
7f81c8db 1532 hid_hw_raw_request(hdev, report->id, buf, report_len,
da10bc25
MM		 1533 HID_FEATURE_REPORT,
1534 HID_REQ_GET_REPORT);
1535 kfree(buf);
1536 }
5519cab4 1537
7f81c8db 1538 field->value[index] = td->inputmode_value;
ec6adef5 1539 *inputmode_found = true;
7f81c8db 1540 return true;
31ae9bdd 1541
7f81c8db 1542 case HID_DG_CONTACTMAX:
3ceb3826 1543 if (cls->maxcontacts) {
7f81c8db 1544 max = min_t(int, field->logical_maximum,
3ceb3826 1545 cls->maxcontacts);
7f81c8db
BT		 1546 if (field->value[index] != max) {
1547 field->value[index] = max;
1548 return true;
1549 }
1550 }
1551 break;
02946f4b
BT		 1552
1553 case HID_DG_LATENCYMODE:
1554 field->value[index] = latency;
99c703ac 1555 return true;
02946f4b
BT		 1556
1557 case HID_DG_SURFACESWITCH:
e8a05819 1558 field->value[index] = !!(report_mode & TOUCHPAD_REPORT_CONTACTS);
99c703ac 1559 return true;
02946f4b
BT		 1560
1561 case HID_DG_BUTTONSWITCH:
e8a05819 1562 field->value[index] = !!(report_mode & TOUCHPAD_REPORT_BUTTONS);
99c703ac 1563 return true;
7f81c8db 1564 }
31ae9bdd 1565
7f81c8db
BT		 1566 return false; /* no need to update the report */
1567}
31ae9bdd 1568
02946f4b 1569static void mt_set_modes(struct hid_device *hdev, enum latency_mode latency,
e8a05819 1570 enum report_mode report_mode)
7f81c8db
BT		 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;
ec6adef5 1577 bool inputmode_found = false;
7f81c8db
BT		 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 rep->field[i],
02946f4b
BT		 1593 usage,
1594 latency,
e8a05819 1595 report_mode,
ec6adef5 1596 &inputmode_found))
7f81c8db
BT		 1597 update_report = true;
1598 }
31ae9bdd 1599 }
7f81c8db
BT		 1600
1601 if (update_report)
1602 hid_hw_request(hdev, rep, HID_REQ_SET_REPORT);
31ae9bdd
BT		 1603 }
1604}
1605
f146d1c4
BT		 1606static void mt_post_parse_default_settings(struct mt_device *td,
1607 struct mt_application *app)
4fa3a583 1608{
3ceb3826 1609 __s32 quirks = app->quirks;
4fa3a583
HR		 1610
1611 /* unknown serial device needs special quirks */
01eaac7e 1612 if (list_is_singular(&app->mt_usages)) {
4fa3a583
HR		 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;
e0bb8f9a 1617 quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
4fa3a583
HR		 1618 }
1619
3ceb3826 1620 app->quirks = quirks;
4fa3a583
HR		 1621}
1622
f146d1c4 1623static void mt_post_parse(struct mt_device *td, struct mt_application *app)
3ac36d15 1624{
01eaac7e 1625 if (!app->have_contact_count)
3ceb3826 1626 app->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
3ac36d15
BT		 1627}
1628
b2c68a2f 1629static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
76f5902a
HR		 1630{
1631 struct mt_device *td = hid_get_drvdata(hdev);
c08d46aa 1632 const char *suffix = NULL;
8dfe14b3 1633 struct mt_report_data *rdata;
f146d1c4 1634 struct mt_application *mt_application = NULL;
40ec2603 1635 struct hid_report *report;
b2c68a2f 1636 int ret;
76f5902a 1637
40ec2603 1638 list_for_each_entry(report, &hi->reports, hidinput_list) {
8dfe14b3
BT		 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;
f146d1c4 1646
8dfe14b3 1647 if (rdata->is_mt_collection) {
f146d1c4
BT		 1648 ret = mt_touch_input_configured(hdev, hi,
1649 mt_application);
40ec2603
BT		 1650 if (ret)
1651 return ret;
1652 }
b2c68a2f 1653 }
76f5902a 1654
7ffa13be
BT		 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;
7ffa13be
BT		 1670 case HID_VD_ASUS_CUSTOM_MEDIA_KEYS:
1671 suffix = "Custom Media Keys";
1672 break;
bc8b796f
AZ		 1673 case HID_DG_STYLUS:
1674 /* force BTN_STYLUS to allow tablet matching in udev */
1675 __set_bit(BTN_STYLUS, hi->input->keybit);
69ecd44d 1676 break;
7ffa13be
BT		 1677 default:
1678 suffix = "UNKNOWN";
1679 break;
c08d46aa
BT		 1680 }
1681
9b8e2220 1682 if (suffix) {
47943946
RR		 1683 hi->input->name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
1684 "%s %s", hdev->name, suffix);
9b8e2220
CH		 1685 if (!hi->input->name)
1686 return -ENOMEM;
1687 }
b2c68a2f
DT		 1688
1689 return 0;
76f5902a
HR		 1690}
1691
f3287a99
BT		 1692static 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
1702static 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(report->field[i], usage);
1717 }
1718}
1719
4f4001bc
BT		 1720static void mt_release_contacts(struct hid_device *hid)
1721{
1722 struct hid_input *hidinput;
f146d1c4 1723 struct mt_application *application;
4f4001bc
BT		 1724 struct mt_device *td = hid_get_drvdata(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(input_dev, i);
5fc70e35 1734 input_mt_report_slot_inactive(input_dev);
4f4001bc
BT		 1735 }
1736 input_mt_sync_frame(input_dev);
1737 input_sync(input_dev);
1738 }
1739 }
1740
f146d1c4
BT		 1741 list_for_each_entry(application, &td->applications, list) {
1742 application->num_received = 0;
1743 }
4f4001bc
BT		 1744}
1745
0ee32774 1746static void mt_expired_timeout(struct timer_list *t)
4f4001bc 1747{
41cb0855 1748 struct mt_device *td = timer_container_of(td, t, release_timer);
0ee32774 1749 struct hid_device *hdev = td->hdev;
4f4001bc
BT		 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 */
be6e2b57 1755 if (test_and_set_bit_lock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
4f4001bc 1756 return;
96098274
BT		 1757 if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1758 mt_release_contacts(hdev);
be6e2b57 1759 clear_bit_unlock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
4f4001bc
BT		 1760}
1761
5519cab4
BT		 1762static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
1763{
2d93666e 1764 int ret, i;
5519cab4 1765 struct mt_device *td;
cf6d15d7 1766 const struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
2d93666e 1767
94b5485c
HR		 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;
2d93666e
BT		 1772 }
1773 }
5519cab4 1774
c08d46aa 1775 td = devm_kzalloc(&hdev->dev, sizeof(struct mt_device), GFP_KERNEL);
5519cab4
BT		 1776 if (!td) {
1777 dev_err(&hdev->dev, "cannot allocate multitouch data\n");
1778 return -ENOMEM;
1779 }
0ee32774 1780 td->hdev = hdev;
eec29e3d 1781 td->mtclass = *mtclass;
9abebedb 1782 td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN;
5519cab4
BT		 1783 hid_set_drvdata(hdev, td);
1784
f146d1c4 1785 INIT_LIST_HEAD(&td->applications);
8dfe14b3 1786 INIT_LIST_HEAD(&td->reports);
f146d1c4 1787
76f5902a
HR		 1788 if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
1789 td->serial_maybe = true;
1790
a2f416bf
AB		 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
b897f6db
BT		 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
40ec2603 1807 * that emits events through different applications on the same HID
b897f6db
BT		 1808 * device.
1809 */
40ec2603 1810 hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
b897f6db 1811
0d6c3011
BT		 1812 if (id->group != HID_GROUP_MULTITOUCH_WIN_8)
1813 hdev->quirks |= HID_QUIRK_MULTI_INPUT;
1814
40d5bb87
BT		 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
0ee32774 1820 timer_setup(&td->release_timer, mt_expired_timeout, 0);
4f4001bc 1821
5519cab4
BT		 1822 ret = hid_parse(hdev);
1823 if (ret != 0)
c08d46aa 1824 return ret;
5519cab4 1825
f3287a99
BT		 1826 if (mtclass->quirks & MT_QUIRK_FIX_CONST_CONTACT_ID)
1827 mt_fix_const_fields(hdev, HID_DG_CONTACTID);
1828
de07af0a 1829 if (hdev->vendor == USB_VENDOR_ID_SIS_TOUCH)
1830 hdev->quirks |= HID_QUIRK_NOGET;
1831
5519cab4 1832 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
2d93666e 1833 if (ret)
c08d46aa 1834 return ret;
5519cab4 1835
eec29e3d 1836 ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
0c4b3c63
NK		 1837 if (ret)
1838 dev_warn(&hdev->dev, "Cannot allocate sysfs group for %s\n",
1839 hdev->name);
eec29e3d 1840
e8a05819 1841 mt_set_modes(hdev, HID_LATENCY_NORMAL, TOUCHPAD_REPORT_ALL);
5519cab4
BT		 1842
1843 return 0;
5519cab4
BT		 1844}
1845
c7aa374e
BH		 1846static int mt_suspend(struct hid_device *hdev, pm_message_t state)
1847{
31a4cf1d
HG		 1848 struct mt_device *td = hid_get_drvdata(hdev);
1849
c7aa374e 1850 /* High latency is desirable for power savings during S3/S0ix */
498d0ddc
HG		 1851 if ((td->mtclass.quirks & MT_QUIRK_DISABLE_WAKEUP) ||
1852 !hid_hw_may_wakeup(hdev))
e8a05819 1853 mt_set_modes(hdev, HID_LATENCY_HIGH, TOUCHPAD_REPORT_NONE);
31a4cf1d 1854 else
e8a05819 1855 mt_set_modes(hdev, HID_LATENCY_HIGH, TOUCHPAD_REPORT_ALL);
31a4cf1d 1856
c7aa374e
BH		 1857 return 0;
1858}
1859
5519cab4
BT		 1860static int mt_reset_resume(struct hid_device *hdev)
1861{
d3e69b9a 1862 mt_release_contacts(hdev);
e8a05819 1863 mt_set_modes(hdev, HID_LATENCY_NORMAL, TOUCHPAD_REPORT_ALL);
5519cab4
BT		 1864 return 0;
1865}
dfeefd10
SL		 1866
1867static int mt_resume(struct hid_device *hdev)
1868{
dfeefd10
SL		 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
4ba25d3f 1873 hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE);
dfeefd10 1874
e8a05819 1875 mt_set_modes(hdev, HID_LATENCY_NORMAL, TOUCHPAD_REPORT_ALL);
c7aa374e 1876
dfeefd10
SL		 1877 return 0;
1878}
5519cab4
BT		 1879
1880static void mt_remove(struct hid_device *hdev)
1881{
b897f6db
BT		 1882 struct mt_device *td = hid_get_drvdata(hdev);
1883
8fa7292f 1884 timer_delete_sync(&td->release_timer);
4f4001bc 1885
eec29e3d 1886 sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
5939212d 1887 hid_hw_stop(hdev);
5519cab4
BT		 1888}
1889
6a9e76f7
WS		 1890static void mt_on_hid_hw_open(struct hid_device *hdev)
1891{
1892 mt_set_modes(hdev, HID_LATENCY_NORMAL, TOUCHPAD_REPORT_ALL);
1893}
1894
1895static void mt_on_hid_hw_close(struct hid_device *hdev)
1896{
1897 mt_set_modes(hdev, HID_LATENCY_HIGH, TOUCHPAD_REPORT_NONE);
1898}
1899
0fa9c616
BT		 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 */
5519cab4
BT		 1906static const struct hid_device_id mt_devices[] = {
1907
f786bba4
BT		 1908 /* 3M panels */
1909 { .driver_data = MT_CLS_3M,
2c2110e9 1910 MT_USB_DEVICE(USB_VENDOR_ID_3M,
f786bba4
BT		 1911 USB_DEVICE_ID_3M1968) },
1912 { .driver_data = MT_CLS_3M,
2c2110e9 1913 MT_USB_DEVICE(USB_VENDOR_ID_3M,
f786bba4 1914 USB_DEVICE_ID_3M2256) },
c4fad877 1915 { .driver_data = MT_CLS_3M,
2c2110e9 1916 MT_USB_DEVICE(USB_VENDOR_ID_3M,
c4fad877 1917 USB_DEVICE_ID_3M3266) },
f786bba4 1918
6aef704e
BT		 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) },
e6aac342 1923
31a4cf1d
HG		 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
957b8dff
JPRV		 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
b1057124 1936 /* Atmel panels */
841cb157 1937 { .driver_data = MT_CLS_SERIAL,
2c2110e9 1938 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
841cb157 1939 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
b1057124 1940
9ed32695 1941 /* Baanto multitouch devices */
dc3e1d80 1942 { .driver_data = MT_CLS_NSMU,
16b79bb8 1943 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
9ed32695 1944 USB_DEVICE_ID_BAANTO_MT_190W2) },
0fa9c616 1945
a841b62c
BT		 1946 /* Cando panels */
1947 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
2c2110e9 1948 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
a841b62c 1949 USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
a841b62c 1950 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
2c2110e9 1951 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
a841b62c
BT		 1952 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
1953
942fd422 1954 /* Chunghwa Telecom touch panels */
dc3e1d80 1955 { .driver_data = MT_CLS_NSMU,
2c2110e9 1956 MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
942fd422
AZ		 1957 USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
1958
070f63b4
YB		 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
79603dc9 1967 /* CVTouch panels */
dc3e1d80 1968 { .driver_data = MT_CLS_NSMU,
2c2110e9 1969 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
79603dc9
BT		 1970 USB_DEVICE_ID_CVTOUCH_SCREEN) },
1971
32bea357
OZ		 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
22408283 1977 /* eGalax devices (resistive) */
e36f690b 1978 { .driver_data = MT_CLS_EGALAX,
2c2110e9 1979 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b
BT		 1980 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
1981 { .driver_data = MT_CLS_EGALAX,
2c2110e9 1982 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b 1983 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
22408283
BT		 1984
1985 /* eGalax devices (capacitive) */
fd1d1525 1986 { .driver_data = MT_CLS_EGALAX_SERIAL,
2c2110e9 1987 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
fd1d1525 1988 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
aa672da1 1989 { .driver_data = MT_CLS_EGALAX,
2c2110e9 1990 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
aa672da1 1991 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
fd1d1525 1992 { .driver_data = MT_CLS_EGALAX_SERIAL,
2c2110e9 1993 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
fd1d1525 1994 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
2ce09df4 1995 { .driver_data = MT_CLS_EGALAX_SERIAL,
2c2110e9 1996 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
2ce09df4 1997 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
aa672da1 1998 { .driver_data = MT_CLS_EGALAX_SERIAL,
2c2110e9 1999 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
aa672da1 2000 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
fd1d1525 2001 { .driver_data = MT_CLS_EGALAX_SERIAL,
2c2110e9 2002 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
fd1d1525 2003 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
aa672da1
AS		 2004 { .driver_data = MT_CLS_EGALAX,
2005 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
2006 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
e36f690b 2007 { .driver_data = MT_CLS_EGALAX,
2c2110e9 2008 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b 2009 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
fd1d1525 2010 { .driver_data = MT_CLS_EGALAX_SERIAL,
2c2110e9 2011 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
fd1d1525 2012 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
aa672da1
AS		 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) },
66f06127 2019 { .driver_data = MT_CLS_EGALAX,
2c2110e9 2020 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
66f06127 2021 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
bb9ff210 2022 { .driver_data = MT_CLS_EGALAX,
2c2110e9 2023 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
bb9ff210 2024 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
fd1d1525 2025 { .driver_data = MT_CLS_EGALAX_SERIAL,
2c2110e9 2026 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
fd1d1525 2027 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
1b723e8d 2028 { .driver_data = MT_CLS_EGALAX_SERIAL,
ae01c9e5
TR		 2029 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
2030 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) },
1b723e8d 2031 { .driver_data = MT_CLS_EGALAX_SERIAL,
2c2110e9 2032 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b 2033 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
f9e82295
SR		 2034 { .driver_data = MT_CLS_EGALAX,
2035 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
2036 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_C002) },
22408283 2037
40d5bb87
BT		 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
4eab1c2f
JE		 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
1a5cbb52
SB		 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
7c7606a2
TS		 2051 /* Elitegroup panel */
2052 { .driver_data = MT_CLS_SERIAL,
2053 MT_USB_DEVICE(USB_VENDOR_ID_ELITEGROUP,
2054 USB_DEVICE_ID_ELITEGROUP_05D8) },
2055
77723e3b
HR		 2056 /* Flatfrog Panels */
2057 { .driver_data = MT_CLS_FLATFROG,
2058 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG,
2059 USB_DEVICE_ID_MULTITOUCH_3200) },
2060
3db187e7
BT		 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
5572da08 2066 /* GeneralTouch panel */
f5ff4e1e 2067 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
2c2110e9 2068 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
5572da08 2069 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
f5ff4e1e
XY		 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) },
7b226292
L		 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) },
5572da08 2088
4d5df5d1 2089 /* Gametel game controller */
dc3e1d80 2090 { .driver_data = MT_CLS_NSMU,
2c2110e9 2091 MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
4d5df5d1
AN		 2092 USB_DEVICE_ID_GAMETEL_MT_MODE) },
2093
c8000deb
DS		 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,
8ade5e05 2100 I2C_DEVICE_ID_GOODIX_01E9) },
c8000deb 2101
ee0fbd14 2102 /* GoodTouch panels */
dc3e1d80 2103 { .driver_data = MT_CLS_NSMU,
2c2110e9 2104 MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
ee0fbd14
BT		 2105 USB_DEVICE_ID_GOODTOUCH_000f) },
2106
54580365
BT		 2107 /* Hanvon panels */
2108 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
2c2110e9 2109 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
54580365
BT		 2110 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
2111
9ffccb69
A		 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
7a5ab807
W		 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
4e61f0d7 2122 /* Ilitek dual touch panel */
dc3e1d80 2123 { .driver_data = MT_CLS_NSMU,
2c2110e9 2124 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
4e61f0d7
AZ		 2125 USB_DEVICE_ID_ILITEK_MULTITOUCH) },
2126
f3287a99
BT		 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) },
348b80b2
AM		 2131 { .driver_data = MT_CLS_LG,
2132 HID_DEVICE(BUS_I2C, HID_GROUP_GENERIC,
2133 USB_VENDOR_ID_LG, I2C_DEVICE_ID_LG_7010) },
f3287a99 2134
a8905238 2135 /* Lenovo X1 TAB Gen 1 */
4a6a4c96
MW		 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
a8905238
AI		 2141 /* Lenovo X1 TAB Gen 2 */
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_TAB2) },
2146
140958da
MW		 2147 /* Lenovo X1 TAB Gen 3 */
2148 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2149 HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2150 USB_VENDOR_ID_LENOVO,
2151 USB_DEVICE_ID_LENOVO_X1_TAB3) },
2152
95cd2cdc 2153 /* Lenovo X12 TAB Gen 1 */
54eed5c7 2154 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
95cd2cdc
TJ		 2155 HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2156 USB_VENDOR_ID_LENOVO,
2157 USB_DEVICE_ID_LENOVO_X12_TAB) },
2158
65b72ea9
VS		 2159 /* Lenovo X12 TAB Gen 2 */
2160 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
2161 HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2162 USB_VENDOR_ID_LENOVO,
2163 USB_DEVICE_ID_LENOVO_X12_TAB2) },
2164
dd2c345a
SB		 2165 /* Logitech devices */
2166 { .driver_data = MT_CLS_NSMU,
2167 HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH_WIN_8,
2168 USB_VENDOR_ID_LOGITECH,
2169 USB_DEVICE_ID_LOGITECH_CASA_TOUCHPAD) },
526748b9
KA		 2170 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
2171 HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2172 USB_VENDOR_ID_LOGITECH,
2173 USB_DEVICE_ID_LOGITECH_BOLT_RECEIVER) },
dd2c345a 2174
4a6ee685
BT		 2175 /* MosArt panels */
2176 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2c2110e9 2177 MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
4a6ee685
BT		 2178 USB_DEVICE_ID_ASUS_T91MT)},
2179 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2c2110e9 2180 MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
4a6ee685
BT		 2181 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
2182 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2c2110e9 2183 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
4a6ee685
BT		 2184 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
2185
4db703ea 2186 /* Novatek Panel */
dc3e1d80 2187 { .driver_data = MT_CLS_NSMU,
4380d819 2188 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
4db703ea
AH		 2189 USB_DEVICE_ID_NOVATEK_PCT) },
2190
a80e803a
BT		 2191 /* Ntrig Panel */
2192 { .driver_data = MT_CLS_NSMU,
2193 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2194 USB_VENDOR_ID_NTRIG, 0x1b05) },
2195
fb55b402
HG		 2196 /* Panasonic panels */
2197 { .driver_data = MT_CLS_PANASONIC,
2198 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
2199 USB_DEVICE_ID_PANABOARD_UBT780) },
2200 { .driver_data = MT_CLS_PANASONIC,
2201 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
2202 USB_DEVICE_ID_PANABOARD_UBT880) },
2203
b7ea95ff
AT		 2204 /* PixArt optical touch screen */
2205 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2c2110e9 2206 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
b7ea95ff
AT		 2207 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
2208 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2c2110e9 2209 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
b7ea95ff
AT		 2210 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
2211 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2c2110e9 2212 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
b7ea95ff
AT		 2213 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
2214
5519cab4 2215 /* PixCir-based panels */
1e9cf35b 2216 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
2c2110e9 2217 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
5519cab4
BT		 2218 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
2219
5e7ea11f 2220 /* Quanta-based panels */
5e7ea11f 2221 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
2c2110e9 2222 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
5e7ea11f 2223 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
a6802e00 2224
843e475f
BT		 2225 /* Razer touchpads */
2226 { .driver_data = MT_CLS_RAZER_BLADE_STEALTH,
2227 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2228 USB_VENDOR_ID_SYNAPTICS, 0x8323) },
2229
69ecd44d
BT		 2230 /* Smart Tech panels */
2231 { .driver_data = MT_CLS_SMART_TECH,
2232 MT_USB_DEVICE(0x0b8c, 0x0092)},
2233
043b403a 2234 /* Stantum panels */
bf5af9b5 2235 { .driver_data = MT_CLS_CONFIDENCE,
2c2110e9 2236 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
043b403a 2237 USB_DEVICE_ID_MTP_STM)},
043b403a 2238
40d5bb87 2239 /* Synaptics devices */
1437e454
RR		 2240 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2241 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2242 USB_VENDOR_ID_SYNAPTICS, 0xcd7e) },
2243
1741a826
MF		 2244 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2245 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2246 USB_VENDOR_ID_SYNAPTICS, 0xcddc) },
2247
40d5bb87
BT		 2248 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2249 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2250 USB_VENDOR_ID_SYNAPTICS, 0xce08) },
2251
c3d6eb6e
KHF		 2252 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2253 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2254 USB_VENDOR_ID_SYNAPTICS, 0xce09) },
2255
847672cd
BT		 2256 /* TopSeed panels */
2257 { .driver_data = MT_CLS_TOPSEED,
2c2110e9 2258 MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
847672cd
BT		 2259 USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },
2260
5e74e56d 2261 /* Touch International panels */
dc3e1d80 2262 { .driver_data = MT_CLS_NSMU,
2c2110e9 2263 MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
5e74e56d
BT		 2264 USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
2265
617b64f9 2266 /* Unitec panels */
dc3e1d80 2267 { .driver_data = MT_CLS_NSMU,
2c2110e9 2268 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
617b64f9 2269 USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
dc3e1d80 2270 { .driver_data = MT_CLS_NSMU,
2c2110e9 2271 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
617b64f9 2272 USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
bf9d121e 2273
da10bc25
MM		 2274 /* VTL panels */
2275 { .driver_data = MT_CLS_VTL,
2276 MT_USB_DEVICE(USB_VENDOR_ID_VTL,
2277 USB_DEVICE_ID_VTL_MULTITOUCH_FF3F) },
2278
08b9a61a
JE		 2279 /* Winbond Electronics Corp. */
2280 { .driver_data = MT_CLS_WIN_8_NO_STICKY_FINGERS,
2281 HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8,
2282 USB_VENDOR_ID_WINBOND, USB_DEVICE_ID_TSTP_MTOUCH) },
2283
bf9d121e
KC		 2284 /* Wistron panels */
2285 { .driver_data = MT_CLS_NSMU,
2286 MT_USB_DEVICE(USB_VENDOR_ID_WISTRON,
2287 USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH) },
2288
bc8a2a9b 2289 /* XAT */
dc3e1d80 2290 { .driver_data = MT_CLS_NSMU,
2c2110e9 2291 MT_USB_DEVICE(USB_VENDOR_ID_XAT,
bc8a2a9b 2292 USB_DEVICE_ID_XAT_CSR) },
617b64f9 2293
11576c61 2294 /* Xiroku */
dc3e1d80 2295 { .driver_data = MT_CLS_NSMU,
2c2110e9 2296 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61 2297 USB_DEVICE_ID_XIROKU_SPX) },
dc3e1d80 2298 { .driver_data = MT_CLS_NSMU,
2c2110e9 2299 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61 2300 USB_DEVICE_ID_XIROKU_MPX) },
dc3e1d80 2301 { .driver_data = MT_CLS_NSMU,
2c2110e9 2302 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61 2303 USB_DEVICE_ID_XIROKU_CSR) },
dc3e1d80 2304 { .driver_data = MT_CLS_NSMU,
2c2110e9 2305 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61 2306 USB_DEVICE_ID_XIROKU_SPX1) },
dc3e1d80 2307 { .driver_data = MT_CLS_NSMU,
2c2110e9 2308 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61 2309 USB_DEVICE_ID_XIROKU_MPX1) },
dc3e1d80 2310 { .driver_data = MT_CLS_NSMU,
2c2110e9 2311 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61 2312 USB_DEVICE_ID_XIROKU_CSR1) },
dc3e1d80 2313 { .driver_data = MT_CLS_NSMU,
2c2110e9 2314 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61 2315 USB_DEVICE_ID_XIROKU_SPX2) },
dc3e1d80 2316 { .driver_data = MT_CLS_NSMU,
2c2110e9 2317 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61 2318 USB_DEVICE_ID_XIROKU_MPX2) },
dc3e1d80 2319 { .driver_data = MT_CLS_NSMU,
2c2110e9 2320 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
11576c61
MH		 2321 USB_DEVICE_ID_XIROKU_CSR2) },
2322
0e82232c
WNH		 2323 /* Google MT devices */
2324 { .driver_data = MT_CLS_GOOGLE,
2325 HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_GOOGLE,
2326 USB_DEVICE_ID_GOOGLE_TOUCH_ROSE) },
1d07cef7
MM		 2327 { .driver_data = MT_CLS_GOOGLE,
2328 HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8, USB_VENDOR_ID_GOOGLE,
2329 USB_DEVICE_ID_GOOGLE_WHISKERS) },
0e82232c 2330
de07af0a 2331 /* sis */
2332 { .driver_data = MT_CLS_SIS,
2333 HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_SIS_TOUCH,
2334 HID_ANY_ID) },
2335
b5e65ae5
YW		 2336 /* Hantick */
2337 { .driver_data = MT_CLS_NSMU,
2338 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2339 I2C_VENDOR_ID_HANTICK, I2C_PRODUCT_ID_HANTICK_5288) },
2340
4fa3a583
HR		 2341 /* Generic MT device */
2342 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
f961bd35
BT		 2343
2344 /* Generic Win 8 certified MT device */
2345 { .driver_data = MT_CLS_WIN_8,
2346 HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8,
2347 HID_ANY_ID, HID_ANY_ID) },
5519cab4
BT		 2348 { }
2349};
2350MODULE_DEVICE_TABLE(hid, mt_devices);
2351
2352static const struct hid_usage_id mt_grabbed_usages[] = {
2353 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
2354 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
2355};
2356
2357static struct hid_driver mt_driver = {
2358 .name = "hid-multitouch",
2359 .id_table = mt_devices,
2360 .probe = mt_probe,
2361 .remove = mt_remove,
2362 .input_mapping = mt_input_mapping,
2363 .input_mapped = mt_input_mapped,
76f5902a 2364 .input_configured = mt_input_configured,
5519cab4
BT		 2365 .feature_mapping = mt_feature_mapping,
2366 .usage_table = mt_grabbed_usages,
2367 .event = mt_event,
c8000deb 2368 .report_fixup = mt_report_fixup,
55978fa9 2369 .report = mt_report,
fc254341
TW		 2370 .suspend = pm_ptr(mt_suspend),
2371 .reset_resume = pm_ptr(mt_reset_resume),
2372 .resume = pm_ptr(mt_resume),
6a9e76f7
WS		 2373 .on_hid_hw_open = mt_on_hid_hw_open,
2374 .on_hid_hw_close = mt_on_hid_hw_close,
5519cab4 2375};
f425458e 2376module_hid_driver(mt_driver);
Linux 6.x block layer and io_uring tree(s)