blob: 3f94b4954225b38ea6fa4bea9194bebb1ab8b383 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01002/*
3 * HID driver for multitouch panels
4 *
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +01005 * Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
Benjamin Tissoiresb0a78682013-02-25 11:31:49 +01006 * Copyright (c) 2010-2013 Benjamin Tissoires <benjamin.tissoires@gmail.com>
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +01007 * Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
Benjamin Tissoiresb0a78682013-02-25 11:31:49 +01008 * Copyright (c) 2012-2013 Red Hat, Inc
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01009 *
Richard Nauber4875ac12011-03-09 06:20:57 +010010 * 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 *
Benjamin Tissoiresf786bba2011-03-22 17:34:01 +010016 * 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.
Benjamin Tissoires5519cab2011-01-07 23:45:50 +010021 */
22
23/*
Benjamin Tissoires5519cab2011-01-07 23:45:50 +010024 */
25
Benjamin Tissoiresb0a78682013-02-25 11:31:49 +010026/*
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +020027 * This driver is regularly tested thanks to the test suite in hid-tools[1].
Benjamin Tissoiresb0a78682013-02-25 11:31:49 +010028 * Please run these regression tests before patching this module so that
29 * your patch won't break existing known devices.
30 *
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +020031 * [1] https://gitlab.freedesktop.org/libevdev/hid-tools
Benjamin Tissoiresb0a78682013-02-25 11:31:49 +010032 */
33
Benjamin Tissoires5519cab2011-01-07 23:45:50 +010034#include <linux/device.h>
35#include <linux/hid.h>
36#include <linux/module.h>
37#include <linux/slab.h>
Benjamin Tissoires5519cab2011-01-07 23:45:50 +010038#include <linux/input/mt.h>
Nicolas Boichat29cc3092017-08-22 09:10:11 +080039#include <linux/jiffies.h>
Benjamin Tissoires49a5a822013-03-22 18:38:33 +010040#include <linux/string.h>
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +020041#include <linux/timer.h>
Benjamin Tissoires5519cab2011-01-07 23:45:50 +010042
43
44MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
Benjamin Tissoiresef2fafb2011-01-31 11:28:21 +010045MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
Benjamin Tissoires5519cab2011-01-07 23:45:50 +010046MODULE_DESCRIPTION("HID multitouch panels");
47MODULE_LICENSE("GPL");
48
49#include "hid-ids.h"
50
51/* quirks to control the device */
Benjamin Tissoiresfd911892017-06-15 15:32:03 +020052#define MT_QUIRK_NOT_SEEN_MEANS_UP BIT(0)
53#define MT_QUIRK_SLOT_IS_CONTACTID BIT(1)
54#define MT_QUIRK_CYPRESS BIT(2)
55#define MT_QUIRK_SLOT_IS_CONTACTNUMBER BIT(3)
56#define MT_QUIRK_ALWAYS_VALID BIT(4)
57#define MT_QUIRK_VALID_IS_INRANGE BIT(5)
58#define MT_QUIRK_VALID_IS_CONFIDENCE BIT(6)
59#define MT_QUIRK_CONFIDENCE BIT(7)
60#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE BIT(8)
61#define MT_QUIRK_NO_AREA BIT(9)
62#define MT_QUIRK_IGNORE_DUPLICATES BIT(10)
63#define MT_QUIRK_HOVERING BIT(11)
64#define MT_QUIRK_CONTACT_CNT_ACCURATE BIT(12)
65#define MT_QUIRK_FORCE_GET_FEATURE BIT(13)
66#define MT_QUIRK_FIX_CONST_CONTACT_ID BIT(14)
67#define MT_QUIRK_TOUCH_SIZE_SCALING BIT(15)
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +020068#define MT_QUIRK_STICKY_FINGERS BIT(16)
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -070069#define MT_QUIRK_ASUS_CUSTOM_UP BIT(17)
Benjamin Tissoiresd9c57a72018-03-20 12:04:45 +010070#define MT_QUIRK_WIN8_PTP_BUTTONS BIT(18)
Benjamin Tissoires69ecd442019-08-12 18:23:26 +020071#define MT_QUIRK_SEPARATE_APP_REPORT BIT(19)
Benjamin Tissoires40d5bb82020-05-26 17:07:17 +020072#define MT_QUIRK_FORCE_MULTI_INPUT BIT(20)
Benjamin Tissoires5519cab2011-01-07 23:45:50 +010073
Andrew Duggan9abebed2014-03-19 13:39:03 -070074#define MT_INPUTMODE_TOUCHSCREEN 0x02
75#define MT_INPUTMODE_TOUCHPAD 0x03
76
Seth Forshee2c6e0272015-03-11 17:26:41 -050077#define MT_BUTTONTYPE_CLICKPAD 0
78
Benjamin Tissoires02946f42018-04-24 10:04:37 +020079enum latency_mode {
80 HID_LATENCY_NORMAL = 0,
81 HID_LATENCY_HIGH = 1,
82};
83
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +020084#define MT_IO_FLAGS_RUNNING 0
Benjamin Tissoires96098272017-06-15 15:32:05 +020085#define MT_IO_FLAGS_ACTIVE_SLOTS 1
86#define MT_IO_FLAGS_PENDING_SLOTS 2
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +020087
Benjamin Tissoires01eaac72018-07-13 16:13:48 +020088static const bool mtrue = true; /* default for true */
89static const bool mfalse; /* default for false */
90static const __s32 mzero; /* default for 0 */
91
92#define DEFAULT_TRUE ((void *)&mtrue)
93#define DEFAULT_FALSE ((void *)&mfalse)
94#define DEFAULT_ZERO ((void *)&mzero)
95
96struct mt_usages {
97 struct list_head list;
98 __s32 *x, *y, *cx, *cy, *p, *w, *h, *a;
99 __s32 *contactid; /* the device ContactID assigned to this slot */
100 bool *tip_state; /* is the touch valid? */
101 bool *inrange_state; /* is the finger in proximity of the sensor? */
102 bool *confidence_state; /* is the touch made by a finger? */
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100103};
104
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200105struct mt_application {
106 struct list_head list;
107 unsigned int application;
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200108 unsigned int report_id;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200109 struct list_head mt_usages; /* mt usages list */
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200110
111 __s32 quirks;
112
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200113 __s32 *scantime; /* scantime reported */
114 __s32 scantime_logical_max; /* max value for raw scantime */
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200115
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200116 __s32 *raw_cc; /* contact count in the report */
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200117 int left_button_state; /* left button state */
118 unsigned int mt_flags; /* flags to pass to input-mt */
119
Dmitry Torokhov28a042a2018-07-13 16:13:54 +0200120 unsigned long *pending_palm_slots; /* slots where we reported palm
121 * and need to release */
122
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200123 __u8 num_received; /* how many contacts we received */
124 __u8 num_expected; /* expected last contact index */
125 __u8 buttons_count; /* number of physical buttons per touchpad */
126 __u8 touches_by_report; /* how many touches are present in one report:
127 * 1 means we should use a serial protocol
128 * > 1 means hybrid (multitouch) protocol
129 */
130
131 __s32 dev_time; /* the scan time provided by the device */
132 unsigned long jiffies; /* the frame's jiffies */
133 int timestamp; /* the timestamp to be sent */
134 int prev_scantime; /* scantime reported previously */
135
136 bool have_contact_count;
137};
138
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100139struct mt_class {
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100140 __s32 name; /* MT_CLS */
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100141 __s32 quirks;
142 __s32 sn_move; /* Signal/noise ratio for move events */
Benjamin Tissoiresf786bba2011-03-22 17:34:01 +0100143 __s32 sn_width; /* Signal/noise ratio for width events */
144 __s32 sn_height; /* Signal/noise ratio for height events */
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100145 __s32 sn_pressure; /* Signal/noise ratio for pressure events */
146 __u8 maxcontacts;
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +0100147 bool is_indirect; /* true for touchpads */
Benjamin Tissoires6aef7042014-02-28 11:41:25 -0500148 bool export_all_inputs; /* do not ignore mouse, keyboards, etc... */
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100149};
150
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +0200151struct mt_report_data {
152 struct list_head list;
153 struct hid_report *report;
154 struct mt_application *application;
155 bool is_mt_collection;
156};
157
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100158struct mt_device {
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100159 struct mt_class mtclass; /* our mt device class */
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +0200160 struct timer_list release_timer; /* to release sticky fingers */
Kees Cook0ee32772017-10-04 17:53:24 -0700161 struct hid_device *hdev; /* hid_device we're attached to */
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +0200162 unsigned long mt_io_flags; /* mt flags (MT_IO_FLAGS_*) */
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +0200163 __u8 inputmode_value; /* InputMode HID feature value */
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100164 __u8 maxcontacts;
Seth Forshee2c6e0272015-03-11 17:26:41 -0500165 bool is_buttonpad; /* is this device a button pad? */
Henrik Rydberg76f59022012-09-01 20:11:34 +0200166 bool serial_maybe; /* need to check for serial protocol */
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200167
168 struct list_head applications;
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +0200169 struct list_head reports;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100170};
171
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200172static void mt_post_parse_default_settings(struct mt_device *td,
173 struct mt_application *app);
174static void mt_post_parse(struct mt_device *td, struct mt_application *app);
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +0100175
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100176/* classes of device behavior */
Benjamin Tissoires22408282011-05-20 15:59:34 +0200177#define MT_CLS_DEFAULT 0x0001
178
Stephane Chattya062cc52011-09-17 22:27:30 +0200179#define MT_CLS_SERIAL 0x0002
180#define MT_CLS_CONFIDENCE 0x0003
Benjamin Tissoires5e7ea112011-11-29 13:13:10 +0100181#define MT_CLS_CONFIDENCE_CONTACT_ID 0x0004
182#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0005
183#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0006
184#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0007
Benjamin Tissoires0fa9c612014-02-28 11:41:23 -0500185/* reserved 0x0008 */
Aaron Tianb7ea95f2011-12-15 11:09:06 +0800186#define MT_CLS_INRANGE_CONTACTNUMBER 0x0009
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +0100187#define MT_CLS_NSMU 0x000a
Benjamin Tissoires0fa9c612014-02-28 11:41:23 -0500188/* reserved 0x0010 */
189/* reserved 0x0011 */
Benjamin Tissoiresf961bd32013-08-22 14:51:08 +0200190#define MT_CLS_WIN_8 0x0012
Benjamin Tissoires6aef7042014-02-28 11:41:25 -0500191#define MT_CLS_EXPORT_ALL_INPUTS 0x0013
Kai-Heng Feng27a6f702020-04-14 17:18:42 +0800192/* reserved 0x0014 */
Benjamin Tissoires40d5bb82020-05-26 17:07:17 +0200193#define MT_CLS_WIN_8_FORCE_MULTI_INPUT 0x0015
Benjamin Tissoires22408282011-05-20 15:59:34 +0200194
195/* vendor specific classes */
196#define MT_CLS_3M 0x0101
Benjamin Tissoires0fa9c612014-02-28 11:41:23 -0500197/* reserved 0x0102 */
Benjamin Tissoires22408282011-05-20 15:59:34 +0200198#define MT_CLS_EGALAX 0x0103
Benjamin Tissoires1b723e82011-11-23 10:54:34 +0100199#define MT_CLS_EGALAX_SERIAL 0x0104
Benjamin Tissoires847672c2012-02-04 17:08:50 +0100200#define MT_CLS_TOPSEED 0x0105
Denis Kovalev2258e862012-02-14 00:50:33 -0800201#define MT_CLS_PANASONIC 0x0106
Henrik Rydberg77723e32012-09-07 19:37:40 +0200202#define MT_CLS_FLATFROG 0x0107
Jiri Kosinacdcd3ac2012-10-01 14:38:54 +0200203#define MT_CLS_GENERALTOUCH_TWOFINGERS 0x0108
204#define MT_CLS_GENERALTOUCH_PWT_TENFINGERS 0x0109
Benjamin Tissoiresf3287a92017-01-30 10:48:06 +0100205#define MT_CLS_LG 0x010a
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -0700206#define MT_CLS_ASUS 0x010b
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +0100207#define MT_CLS_VTL 0x0110
Wei-Ning Huang0e822322017-06-21 10:43:25 +0800208#define MT_CLS_GOOGLE 0x0111
Benjamin Tissoires843e4752018-03-20 12:04:46 +0100209#define MT_CLS_RAZER_BLADE_STEALTH 0x0112
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200210#define MT_CLS_SMART_TECH 0x0113
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100211
Benjamin Tissoires9498f952011-03-18 14:27:52 +0100212#define MT_DEFAULT_MAXCONTACT 10
Benjamin Tissoiresafbcb042012-11-14 16:59:18 +0100213#define MT_MAX_MAXCONTACT 250
Benjamin Tissoires9498f952011-03-18 14:27:52 +0100214
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800215/*
216 * Resync device and local timestamps after that many microseconds without
217 * receiving data.
218 */
219#define MAX_TIMESTAMP_INTERVAL 1000000
220
Henrik Rydberg2c2110e2012-05-04 15:32:04 +0200221#define MT_USB_DEVICE(v, p) HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p)
222#define MT_BT_DEVICE(v, p) HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p)
223
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100224/*
225 * these device-dependent functions determine what slot corresponds
226 * to a valid contact that was just read.
227 */
228
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200229static int cypress_compute_slot(struct mt_application *application,
230 struct mt_usages *slot)
Benjamin Tissoiresa3b5e572011-01-07 23:46:30 +0100231{
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200232 if (*slot->contactid != 0 || application->num_received == 0)
233 return *slot->contactid;
Benjamin Tissoiresa3b5e572011-01-07 23:46:30 +0100234 else
235 return -1;
236}
237
Benjamin Tissoirescf6d15d2018-07-13 16:13:44 +0200238static const struct mt_class mt_classes[] = {
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100239 { .name = MT_CLS_DEFAULT,
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +0100240 .quirks = MT_QUIRK_ALWAYS_VALID |
241 MT_QUIRK_CONTACT_CNT_ACCURATE },
242 { .name = MT_CLS_NSMU,
Benjamin Tissoires9498f952011-03-18 14:27:52 +0100243 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
Stephane Chattya062cc52011-09-17 22:27:30 +0200244 { .name = MT_CLS_SERIAL,
245 .quirks = MT_QUIRK_ALWAYS_VALID},
Benjamin Tissoires22408282011-05-20 15:59:34 +0200246 { .name = MT_CLS_CONFIDENCE,
247 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
Benjamin Tissoires5e7ea112011-11-29 13:13:10 +0100248 { .name = MT_CLS_CONFIDENCE_CONTACT_ID,
249 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
250 MT_QUIRK_SLOT_IS_CONTACTID },
Benjamin Tissoires22408282011-05-20 15:59:34 +0200251 { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
252 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
253 MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
Benjamin Tissoires1e9cf35b2011-01-31 11:28:20 +0100254 { .name = MT_CLS_DUAL_INRANGE_CONTACTID,
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100255 .quirks = MT_QUIRK_VALID_IS_INRANGE |
256 MT_QUIRK_SLOT_IS_CONTACTID,
257 .maxcontacts = 2 },
Benjamin Tissoires1e9cf35b2011-01-31 11:28:20 +0100258 { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100259 .quirks = MT_QUIRK_VALID_IS_INRANGE |
260 MT_QUIRK_SLOT_IS_CONTACTNUMBER,
261 .maxcontacts = 2 },
Aaron Tianb7ea95f2011-12-15 11:09:06 +0800262 { .name = MT_CLS_INRANGE_CONTACTNUMBER,
263 .quirks = MT_QUIRK_VALID_IS_INRANGE |
264 MT_QUIRK_SLOT_IS_CONTACTNUMBER },
Benjamin Tissoiresf961bd32013-08-22 14:51:08 +0200265 { .name = MT_CLS_WIN_8,
266 .quirks = MT_QUIRK_ALWAYS_VALID |
267 MT_QUIRK_IGNORE_DUPLICATES |
268 MT_QUIRK_HOVERING |
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +0200269 MT_QUIRK_CONTACT_CNT_ACCURATE |
Benjamin Tissoiresd9c57a72018-03-20 12:04:45 +0100270 MT_QUIRK_STICKY_FINGERS |
Benjamin Tissoiresc23e2042019-08-12 18:23:25 +0200271 MT_QUIRK_WIN8_PTP_BUTTONS,
272 .export_all_inputs = true },
Benjamin Tissoires6aef7042014-02-28 11:41:25 -0500273 { .name = MT_CLS_EXPORT_ALL_INPUTS,
274 .quirks = MT_QUIRK_ALWAYS_VALID |
275 MT_QUIRK_CONTACT_CNT_ACCURATE,
276 .export_all_inputs = true },
Benjamin Tissoires40d5bb82020-05-26 17:07:17 +0200277 { .name = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
278 .quirks = MT_QUIRK_ALWAYS_VALID |
279 MT_QUIRK_IGNORE_DUPLICATES |
280 MT_QUIRK_HOVERING |
281 MT_QUIRK_CONTACT_CNT_ACCURATE |
282 MT_QUIRK_STICKY_FINGERS |
283 MT_QUIRK_WIN8_PTP_BUTTONS |
284 MT_QUIRK_FORCE_MULTI_INPUT,
285 .export_all_inputs = true },
Benjamin Tissoires22408282011-05-20 15:59:34 +0200286
287 /*
288 * vendor specific classes
289 */
290 { .name = MT_CLS_3M,
291 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
HungNien Chene9d0a262017-03-06 11:30:14 +0800292 MT_QUIRK_SLOT_IS_CONTACTID |
293 MT_QUIRK_TOUCH_SIZE_SCALING,
Benjamin Tissoires22408282011-05-20 15:59:34 +0200294 .sn_move = 2048,
295 .sn_width = 128,
Henrik Rydbergc5d40be2012-09-05 16:58:12 +0200296 .sn_height = 128,
297 .maxcontacts = 60,
298 },
Richard Nauber4875ac12011-03-09 06:20:57 +0100299 { .name = MT_CLS_EGALAX,
300 .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
Benjamin Tissoires2261bb92011-11-23 10:54:29 +0100301 MT_QUIRK_VALID_IS_INRANGE,
Richard Nauber4875ac12011-03-09 06:20:57 +0100302 .sn_move = 4096,
303 .sn_pressure = 32,
304 },
Benjamin Tissoires1b723e82011-11-23 10:54:34 +0100305 { .name = MT_CLS_EGALAX_SERIAL,
306 .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
307 MT_QUIRK_ALWAYS_VALID,
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100308 .sn_move = 4096,
309 .sn_pressure = 32,
310 },
Benjamin Tissoires847672c2012-02-04 17:08:50 +0100311 { .name = MT_CLS_TOPSEED,
312 .quirks = MT_QUIRK_ALWAYS_VALID,
313 .is_indirect = true,
314 .maxcontacts = 2,
315 },
Denis Kovalev2258e862012-02-14 00:50:33 -0800316 { .name = MT_CLS_PANASONIC,
317 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
318 .maxcontacts = 4 },
Xianhan Yuf5ff4e12012-09-28 10:18:59 +0800319 { .name = MT_CLS_GENERALTOUCH_TWOFINGERS,
320 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
321 MT_QUIRK_VALID_IS_INRANGE |
Luosong7b226292013-10-02 11:20:00 +0200322 MT_QUIRK_SLOT_IS_CONTACTID,
Xianhan Yuf5ff4e12012-09-28 10:18:59 +0800323 .maxcontacts = 2
324 },
325 { .name = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
326 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
Luosong7b226292013-10-02 11:20:00 +0200327 MT_QUIRK_SLOT_IS_CONTACTID
Xianhan Yuf5ff4e12012-09-28 10:18:59 +0800328 },
Benjamin Tissoires043b4032011-03-18 14:27:53 +0100329
Henrik Rydberg77723e32012-09-07 19:37:40 +0200330 { .name = MT_CLS_FLATFROG,
331 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
332 MT_QUIRK_NO_AREA,
333 .sn_move = 2048,
334 .maxcontacts = 40,
335 },
Benjamin Tissoiresf3287a92017-01-30 10:48:06 +0100336 { .name = MT_CLS_LG,
337 .quirks = MT_QUIRK_ALWAYS_VALID |
338 MT_QUIRK_FIX_CONST_CONTACT_ID |
339 MT_QUIRK_IGNORE_DUPLICATES |
340 MT_QUIRK_HOVERING |
341 MT_QUIRK_CONTACT_CNT_ACCURATE },
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -0700342 { .name = MT_CLS_ASUS,
343 .quirks = MT_QUIRK_ALWAYS_VALID |
344 MT_QUIRK_CONTACT_CNT_ACCURATE |
345 MT_QUIRK_ASUS_CUSTOM_UP },
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +0100346 { .name = MT_CLS_VTL,
347 .quirks = MT_QUIRK_ALWAYS_VALID |
348 MT_QUIRK_CONTACT_CNT_ACCURATE |
349 MT_QUIRK_FORCE_GET_FEATURE,
350 },
Wei-Ning Huang0e822322017-06-21 10:43:25 +0800351 { .name = MT_CLS_GOOGLE,
352 .quirks = MT_QUIRK_ALWAYS_VALID |
353 MT_QUIRK_CONTACT_CNT_ACCURATE |
354 MT_QUIRK_SLOT_IS_CONTACTID |
355 MT_QUIRK_HOVERING
356 },
Benjamin Tissoires843e4752018-03-20 12:04:46 +0100357 { .name = MT_CLS_RAZER_BLADE_STEALTH,
358 .quirks = MT_QUIRK_ALWAYS_VALID |
359 MT_QUIRK_IGNORE_DUPLICATES |
360 MT_QUIRK_HOVERING |
361 MT_QUIRK_CONTACT_CNT_ACCURATE |
362 MT_QUIRK_WIN8_PTP_BUTTONS,
363 },
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200364 { .name = MT_CLS_SMART_TECH,
365 .quirks = MT_QUIRK_ALWAYS_VALID |
366 MT_QUIRK_IGNORE_DUPLICATES |
367 MT_QUIRK_CONTACT_CNT_ACCURATE |
368 MT_QUIRK_SEPARATE_APP_REPORT,
369 },
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100370 { }
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100371};
372
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100373static ssize_t mt_show_quirks(struct device *dev,
374 struct device_attribute *attr,
375 char *buf)
376{
Geliang Tangee79a8f2015-12-27 17:25:21 +0800377 struct hid_device *hdev = to_hid_device(dev);
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100378 struct mt_device *td = hid_get_drvdata(hdev);
379
380 return sprintf(buf, "%u\n", td->mtclass.quirks);
381}
382
383static ssize_t mt_set_quirks(struct device *dev,
384 struct device_attribute *attr,
385 const char *buf, size_t count)
386{
Geliang Tangee79a8f2015-12-27 17:25:21 +0800387 struct hid_device *hdev = to_hid_device(dev);
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100388 struct mt_device *td = hid_get_drvdata(hdev);
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200389 struct mt_application *application;
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100390
391 unsigned long val;
392
393 if (kstrtoul(buf, 0, &val))
394 return -EINVAL;
395
396 td->mtclass.quirks = val;
397
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200398 list_for_each_entry(application, &td->applications, list) {
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200399 application->quirks = val;
400 if (!application->have_contact_count)
401 application->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200402 }
403
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100404 return count;
405}
406
407static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
408
409static struct attribute *sysfs_attrs[] = {
410 &dev_attr_quirks.attr,
411 NULL
412};
413
Arvind Yadav9182fb92017-08-03 16:56:43 +0530414static const struct attribute_group mt_attribute_group = {
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100415 .attrs = sysfs_attrs
416};
417
Mika Westerberg6d4f5442015-10-07 15:33:43 +0300418static void mt_get_feature(struct hid_device *hdev, struct hid_report *report)
419{
Aaron Ma3064a032018-02-03 23:57:15 +0800420 int ret;
421 u32 size = hid_report_len(report);
Mika Westerberg6d4f5442015-10-07 15:33:43 +0300422 u8 *buf;
423
424 /*
Benjamin Tissoiresb897f6d2016-11-25 14:27:22 +0100425 * Do not fetch the feature report if the device has been explicitly
426 * marked as non-capable.
Mika Westerberg6d4f5442015-10-07 15:33:43 +0300427 */
Benjamin Tissoiresadaabbf2018-03-20 12:04:50 +0100428 if (hdev->quirks & HID_QUIRK_NO_INIT_REPORTS)
Mika Westerberg6d4f5442015-10-07 15:33:43 +0300429 return;
430
431 buf = hid_alloc_report_buf(report, GFP_KERNEL);
432 if (!buf)
433 return;
434
435 ret = hid_hw_raw_request(hdev, report->id, buf, size,
436 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
437 if (ret < 0) {
438 dev_warn(&hdev->dev, "failed to fetch feature %d\n",
439 report->id);
440 } else {
441 ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf,
442 size, 0);
443 if (ret)
444 dev_warn(&hdev->dev, "failed to report feature\n");
445 }
446
447 kfree(buf);
448}
449
Henrik Rydbergf635bd12011-02-24 19:30:59 +0100450static void mt_feature_mapping(struct hid_device *hdev,
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100451 struct hid_field *field, struct hid_usage *usage)
452{
Benjamin Tissoires9498f952011-03-18 14:27:52 +0100453 struct mt_device *td = hid_get_drvdata(hdev);
454
455 switch (usage->hid) {
Benjamin Tissoires9498f952011-03-18 14:27:52 +0100456 case HID_DG_CONTACTMAX:
Mika Westerberg6d4f5442015-10-07 15:33:43 +0300457 mt_get_feature(hdev, field->report);
458
Benjamin Tissoires9498f952011-03-18 14:27:52 +0100459 td->maxcontacts = field->value[0];
Benjamin Tissoiresafbcb042012-11-14 16:59:18 +0100460 if (!td->maxcontacts &&
461 field->logical_maximum <= MT_MAX_MAXCONTACT)
462 td->maxcontacts = field->logical_maximum;
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100463 if (td->mtclass.maxcontacts)
Benjamin Tissoires9498f952011-03-18 14:27:52 +0100464 /* check if the maxcontacts is given by the class */
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100465 td->maxcontacts = td->mtclass.maxcontacts;
Benjamin Tissoires9498f952011-03-18 14:27:52 +0100466
467 break;
Seth Forshee2c6e0272015-03-11 17:26:41 -0500468 case HID_DG_BUTTONTYPE:
469 if (usage->usage_index >= field->report_count) {
470 dev_err(&hdev->dev, "HID_DG_BUTTONTYPE out of range\n");
471 break;
472 }
473
Mika Westerberg6d4f5442015-10-07 15:33:43 +0300474 mt_get_feature(hdev, field->report);
Seth Forshee2c6e0272015-03-11 17:26:41 -0500475 if (field->value[usage->usage_index] == MT_BUTTONTYPE_CLICKPAD)
476 td->is_buttonpad = true;
477
478 break;
Benjamin Tissoires45c5c6822016-03-07 11:02:38 +0100479 case 0xff0000c5:
480 /* Retrieve the Win8 blob once to enable some devices */
481 if (usage->usage_index == 0)
482 mt_get_feature(hdev, field->report);
483 break;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100484 }
485}
486
487static void set_abs(struct input_dev *input, unsigned int code,
488 struct hid_field *field, int snratio)
489{
490 int fmin = field->logical_minimum;
491 int fmax = field->logical_maximum;
492 int fuzz = snratio ? (fmax - fmin) / snratio : 0;
493 input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
Benjamin Tissoires37cf6e62012-11-14 16:59:13 +0100494 input_abs_set_res(input, code, hidinput_calc_abs_res(field, code));
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100495}
496
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200497static struct mt_usages *mt_allocate_usage(struct hid_device *hdev,
498 struct mt_application *application)
499{
500 struct mt_usages *usage;
501
502 usage = devm_kzalloc(&hdev->dev, sizeof(*usage), GFP_KERNEL);
503 if (!usage)
504 return NULL;
505
506 /* set some defaults so we do not need to check for null pointers */
507 usage->x = DEFAULT_ZERO;
508 usage->y = DEFAULT_ZERO;
509 usage->cx = DEFAULT_ZERO;
510 usage->cy = DEFAULT_ZERO;
511 usage->p = DEFAULT_ZERO;
512 usage->w = DEFAULT_ZERO;
513 usage->h = DEFAULT_ZERO;
514 usage->a = DEFAULT_ZERO;
515 usage->contactid = DEFAULT_ZERO;
516 usage->tip_state = DEFAULT_FALSE;
517 usage->inrange_state = DEFAULT_FALSE;
518 usage->confidence_state = DEFAULT_TRUE;
519
520 list_add_tail(&usage->list, &application->mt_usages);
521
522 return usage;
523}
524
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200525static struct mt_application *mt_allocate_application(struct mt_device *td,
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200526 struct hid_report *report)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200527{
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200528 unsigned int application = report->application;
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200529 struct mt_application *mt_application;
530
531 mt_application = devm_kzalloc(&td->hdev->dev, sizeof(*mt_application),
532 GFP_KERNEL);
533 if (!mt_application)
534 return NULL;
535
536 mt_application->application = application;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200537 INIT_LIST_HEAD(&mt_application->mt_usages);
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200538
539 if (application == HID_DG_TOUCHSCREEN)
540 mt_application->mt_flags |= INPUT_MT_DIRECT;
541
542 /*
543 * Model touchscreens providing buttons as touchpads.
544 */
545 if (application == HID_DG_TOUCHPAD) {
546 mt_application->mt_flags |= INPUT_MT_POINTER;
547 td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
548 }
549
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200550 mt_application->scantime = DEFAULT_ZERO;
551 mt_application->raw_cc = DEFAULT_ZERO;
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200552 mt_application->quirks = td->mtclass.quirks;
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200553 mt_application->report_id = report->id;
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200554
555 list_add_tail(&mt_application->list, &td->applications);
556
557 return mt_application;
558}
559
560static struct mt_application *mt_find_application(struct mt_device *td,
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200561 struct hid_report *report)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200562{
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200563 unsigned int application = report->application;
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200564 struct mt_application *tmp, *mt_application = NULL;
565
566 list_for_each_entry(tmp, &td->applications, list) {
567 if (application == tmp->application) {
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200568 if (!(td->mtclass.quirks & MT_QUIRK_SEPARATE_APP_REPORT) ||
569 tmp->report_id == report->id) {
570 mt_application = tmp;
571 break;
572 }
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200573 }
574 }
575
576 if (!mt_application)
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200577 mt_application = mt_allocate_application(td, report);
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200578
579 return mt_application;
580}
581
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +0200582static struct mt_report_data *mt_allocate_report_data(struct mt_device *td,
583 struct hid_report *report)
584{
585 struct mt_report_data *rdata;
586 struct hid_field *field;
587 int r, n;
588
589 rdata = devm_kzalloc(&td->hdev->dev, sizeof(*rdata), GFP_KERNEL);
590 if (!rdata)
591 return NULL;
592
593 rdata->report = report;
Benjamin Tissoires69ecd442019-08-12 18:23:26 +0200594 rdata->application = mt_find_application(td, report);
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +0200595
596 if (!rdata->application) {
597 devm_kfree(&td->hdev->dev, rdata);
598 return NULL;
599 }
600
601 for (r = 0; r < report->maxfield; r++) {
602 field = report->field[r];
603
604 if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
605 continue;
606
607 for (n = 0; n < field->report_count; n++) {
608 if (field->usage[n].hid == HID_DG_CONTACTID)
609 rdata->is_mt_collection = true;
610 }
611 }
612
613 list_add_tail(&rdata->list, &td->reports);
614
615 return rdata;
616}
617
618static struct mt_report_data *mt_find_report_data(struct mt_device *td,
619 struct hid_report *report)
620{
621 struct mt_report_data *tmp, *rdata = NULL;
622
623 list_for_each_entry(tmp, &td->reports, list) {
624 if (report == tmp->report) {
625 rdata = tmp;
626 break;
627 }
628 }
629
630 if (!rdata)
631 rdata = mt_allocate_report_data(td, report);
632
633 return rdata;
634}
635
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200636static void mt_store_field(struct hid_device *hdev,
637 struct mt_application *application,
638 __s32 *value,
639 size_t offset)
Benjamin Tissoiresed9d5c92012-03-06 17:57:03 +0100640{
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200641 struct mt_usages *usage;
642 __s32 **target;
Benjamin Tissoires3ac36d12012-05-04 14:53:46 +0200643
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200644 if (list_empty(&application->mt_usages))
645 usage = mt_allocate_usage(hdev, application);
646 else
647 usage = list_last_entry(&application->mt_usages,
648 struct mt_usages,
649 list);
650
651 if (!usage)
Benjamin Tissoires3ac36d12012-05-04 14:53:46 +0200652 return;
653
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200654 target = (__s32 **)((char *)usage + offset);
655
656 /* the value has already been filled, create a new slot */
657 if (*target != DEFAULT_TRUE &&
658 *target != DEFAULT_FALSE &&
659 *target != DEFAULT_ZERO) {
Benjamin Tissoires81bcbad2019-05-21 15:38:31 +0200660 if (usage->contactid == DEFAULT_ZERO ||
661 usage->x == DEFAULT_ZERO ||
662 usage->y == DEFAULT_ZERO) {
663 hid_dbg(hdev,
664 "ignoring duplicate usage on incomplete");
665 return;
666 }
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200667 usage = mt_allocate_usage(hdev, application);
668 if (!usage)
669 return;
670
671 target = (__s32 **)((char *)usage + offset);
672 }
673
674 *target = value;
Benjamin Tissoiresed9d5c92012-03-06 17:57:03 +0100675}
676
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200677#define MT_STORE_FIELD(__name) \
678 mt_store_field(hdev, app, \
679 &field->value[usage->usage_index], \
680 offsetof(struct mt_usages, __name))
681
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +0100682static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100683 struct hid_field *field, struct hid_usage *usage,
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200684 unsigned long **bit, int *max, struct mt_application *app)
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100685{
686 struct mt_device *td = hid_get_drvdata(hdev);
Benjamin Tissoireseec29e32011-11-23 10:54:28 +0100687 struct mt_class *cls = &td->mtclass;
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +0100688 int code;
Benjamin Tissoires349fd6702012-11-14 16:59:19 +0100689 struct hid_usage *prev_usage = NULL;
Richard Nauber4875ac12011-03-09 06:20:57 +0100690
Henrik Rydberg76f59022012-09-01 20:11:34 +0200691 /*
692 * Model touchscreens providing buttons as touchpads.
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +0100693 */
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +0200694 if (field->application == HID_DG_TOUCHSCREEN &&
695 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200696 app->mt_flags |= INPUT_MT_POINTER;
Andrew Duggan9abebed2014-03-19 13:39:03 -0700697 td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
698 }
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +0100699
Benjamin Tissoires015fdaa2015-03-06 11:14:42 -0500700 /* count the buttons on touchpads */
701 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200702 app->buttons_count++;
Benjamin Tissoires015fdaa2015-03-06 11:14:42 -0500703
Benjamin Tissoires349fd6702012-11-14 16:59:19 +0100704 if (usage->usage_index)
705 prev_usage = &field->usage[usage->usage_index - 1];
706
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100707 switch (usage->hid & HID_USAGE_PAGE) {
708
709 case HID_UP_GENDESK:
710 switch (usage->hid) {
711 case HID_GD_X:
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200712 if (prev_usage && (prev_usage->hid == usage->hid)) {
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200713 code = ABS_MT_TOOL_X;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200714 MT_STORE_FIELD(cx);
715 } else {
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200716 code = ABS_MT_POSITION_X;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200717 MT_STORE_FIELD(x);
718 }
Benjamin Tissoires349fd6702012-11-14 16:59:19 +0100719
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200720 set_abs(hi->input, code, field, cls->sn_move);
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200721
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +0200722 /*
723 * A system multi-axis that exports X and Y has a high
724 * chance of being used directly on a surface
725 */
726 if (field->application == HID_GD_SYSTEM_MULTIAXIS) {
727 __set_bit(INPUT_PROP_DIRECT,
728 hi->input->propbit);
729 input_set_abs_params(hi->input,
730 ABS_MT_TOOL_TYPE,
731 MT_TOOL_DIAL,
732 MT_TOOL_DIAL, 0, 0);
733 }
734
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100735 return 1;
736 case HID_GD_Y:
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200737 if (prev_usage && (prev_usage->hid == usage->hid)) {
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200738 code = ABS_MT_TOOL_Y;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200739 MT_STORE_FIELD(cy);
740 } else {
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200741 code = ABS_MT_POSITION_Y;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200742 MT_STORE_FIELD(y);
743 }
Benjamin Tissoires349fd6702012-11-14 16:59:19 +0100744
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200745 set_abs(hi->input, code, field, cls->sn_move);
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200746
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100747 return 1;
748 }
749 return 0;
750
751 case HID_UP_DIGITIZER:
752 switch (usage->hid) {
753 case HID_DG_INRANGE:
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200754 if (app->quirks & MT_QUIRK_HOVERING) {
Benjamin Tissoires9b3bb9b82012-11-14 16:59:24 +0100755 input_set_abs_params(hi->input,
756 ABS_MT_DISTANCE, 0, 1, 0, 0);
757 }
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200758 MT_STORE_FIELD(inrange_state);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100759 return 1;
760 case HID_DG_CONFIDENCE:
Kai-Heng Feng27a6f702020-04-14 17:18:42 +0800761 if (cls->name == MT_CLS_WIN_8 &&
Dmitry Torokhovf9024372018-07-13 16:13:53 +0200762 (field->application == HID_DG_TOUCHPAD ||
763 field->application == HID_DG_TOUCHSCREEN))
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200764 app->quirks |= MT_QUIRK_CONFIDENCE;
Dmitry Torokhov9152c7d2018-07-13 16:13:52 +0200765
766 if (app->quirks & MT_QUIRK_CONFIDENCE)
767 input_set_abs_params(hi->input,
768 ABS_MT_TOOL_TYPE,
769 MT_TOOL_FINGER,
770 MT_TOOL_PALM, 0, 0);
771
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200772 MT_STORE_FIELD(confidence_state);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100773 return 1;
774 case HID_DG_TIPSWITCH:
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +0200775 if (field->application != HID_GD_SYSTEM_MULTIAXIS)
776 input_set_capability(hi->input,
777 EV_KEY, BTN_TOUCH);
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200778 MT_STORE_FIELD(tip_state);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100779 return 1;
780 case HID_DG_CONTACTID:
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200781 MT_STORE_FIELD(contactid);
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200782 app->touches_by_report++;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100783 return 1;
784 case HID_DG_WIDTH:
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200785 if (!(app->quirks & MT_QUIRK_NO_AREA))
Henrik Rydberg77723e32012-09-07 19:37:40 +0200786 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
787 cls->sn_width);
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200788 MT_STORE_FIELD(w);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100789 return 1;
790 case HID_DG_HEIGHT:
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200791 if (!(app->quirks & MT_QUIRK_NO_AREA)) {
Henrik Rydberg77723e32012-09-07 19:37:40 +0200792 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
793 cls->sn_height);
Wei-Ning Huang00720272017-10-12 14:21:43 +0800794
795 /*
796 * Only set ABS_MT_ORIENTATION if it is not
797 * already set by the HID_DG_AZIMUTH usage.
798 */
799 if (!test_bit(ABS_MT_ORIENTATION,
800 hi->input->absbit))
801 input_set_abs_params(hi->input,
802 ABS_MT_ORIENTATION, 0, 1, 0, 0);
Henrik Rydberg77723e32012-09-07 19:37:40 +0200803 }
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200804 MT_STORE_FIELD(h);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100805 return 1;
806 case HID_DG_TIPPRESSURE:
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100807 set_abs(hi->input, ABS_MT_PRESSURE, field,
808 cls->sn_pressure);
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200809 MT_STORE_FIELD(p);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100810 return 1;
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800811 case HID_DG_SCANTIME:
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800812 input_set_capability(hi->input, EV_MSC, MSC_TIMESTAMP);
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200813 app->scantime = &field->value[usage->usage_index];
814 app->scantime_logical_max = field->logical_maximum;
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800815 return 1;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100816 case HID_DG_CONTACTCOUNT:
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200817 app->have_contact_count = true;
818 app->raw_cc = &field->value[usage->usage_index];
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100819 return 1;
Wei-Ning Huang00720272017-10-12 14:21:43 +0800820 case HID_DG_AZIMUTH:
Wei-Ning Huang00720272017-10-12 14:21:43 +0800821 /*
822 * Azimuth has the range of [0, MAX) representing a full
823 * revolution. Set ABS_MT_ORIENTATION to a quarter of
824 * MAX according the definition of ABS_MT_ORIENTATION
825 */
826 input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
827 -field->logical_maximum / 4,
828 field->logical_maximum / 4,
829 cls->sn_move ?
830 field->logical_maximum / cls->sn_move : 0, 0);
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200831 MT_STORE_FIELD(a);
Wei-Ning Huang00720272017-10-12 14:21:43 +0800832 return 1;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100833 case HID_DG_CONTACTMAX:
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200834 /* contact max are global to the report */
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100835 return -1;
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +0100836 case HID_DG_TOUCH:
837 /* Legacy devices use TIPSWITCH and not TOUCH.
838 * Let's just ignore this field. */
839 return -1;
Alan Cox65b258e2012-10-25 15:35:25 +0100840 }
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100841 /* let hid-input decide for the others */
842 return 0;
843
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +0100844 case HID_UP_BUTTON:
845 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
Benjamin Tissoires594312b2016-11-25 11:08:10 +0100846 /*
847 * MS PTP spec says that external buttons left and right have
848 * usages 2 and 3.
849 */
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200850 if ((app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
Benjamin Tissoires594312b2016-11-25 11:08:10 +0100851 field->application == HID_DG_TOUCHPAD &&
852 (usage->hid & HID_USAGE) > 1)
853 code--;
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +0200854
855 if (field->application == HID_GD_SYSTEM_MULTIAXIS)
856 code = BTN_0 + ((usage->hid - 1) & HID_USAGE);
857
Benjamin Tissoiresc2ef8f22012-02-04 17:08:48 +0100858 hid_map_usage(hi, usage, bit, max, EV_KEY, code);
859 input_set_capability(hi->input, EV_KEY, code);
860 return 1;
861
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100862 case 0xff000000:
863 /* we do not want to map these: no input-oriented meaning */
864 return -1;
865 }
866
867 return 0;
868}
869
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200870static int mt_compute_slot(struct mt_device *td, struct mt_application *app,
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200871 struct mt_usages *slot,
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200872 struct input_dev *input)
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100873{
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200874 __s32 quirks = app->quirks;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100875
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100876 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200877 return *slot->contactid;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100878
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100879 if (quirks & MT_QUIRK_CYPRESS)
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200880 return cypress_compute_slot(app, slot);
Benjamin Tissoiresa3b5e572011-01-07 23:46:30 +0100881
Benjamin Tissoires2d936662011-01-11 16:45:54 +0100882 if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200883 return app->num_received;
Benjamin Tissoires5572da02011-01-07 23:47:27 +0100884
Benjamin Tissoires4a6ee682011-04-22 11:51:48 +0200885 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200886 return *slot->contactid - 1;
Benjamin Tissoires4a6ee682011-04-22 11:51:48 +0200887
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200888 return input_mt_get_slot_by_key(input, *slot->contactid);
Henrik Rydberg3e1b5012012-09-01 19:46:58 +0200889}
890
Dmitry Torokhov28a042a2018-07-13 16:13:54 +0200891static void mt_release_pending_palms(struct mt_device *td,
892 struct mt_application *app,
893 struct input_dev *input)
894{
895 int slotnum;
896 bool need_sync = false;
897
898 for_each_set_bit(slotnum, app->pending_palm_slots, td->maxcontacts) {
899 clear_bit(slotnum, app->pending_palm_slots);
900
901 input_mt_slot(input, slotnum);
Jiada Wang5fc70e32020-05-11 13:12:13 -0700902 input_mt_report_slot_inactive(input);
Dmitry Torokhov28a042a2018-07-13 16:13:54 +0200903
904 need_sync = true;
905 }
906
907 if (need_sync) {
908 input_mt_sync_frame(input);
909 input_sync(input);
910 }
911}
912
Henrik Rydberg3e1b5012012-09-01 19:46:58 +0200913/*
914 * this function is called when a whole packet has been received and processed,
915 * so that it can decide what to send to the input layer.
916 */
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200917static void mt_sync_frame(struct mt_device *td, struct mt_application *app,
918 struct input_dev *input)
Henrik Rydberg3e1b5012012-09-01 19:46:58 +0200919{
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200920 if (app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200921 input_event(input, EV_KEY, BTN_LEFT, app->left_button_state);
Hans de Goede127e71b2017-11-22 12:57:10 +0100922
Henrik Rydberg76f59022012-09-01 20:11:34 +0200923 input_mt_sync_frame(input);
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200924 input_event(input, EV_MSC, MSC_TIMESTAMP, app->timestamp);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100925 input_sync(input);
Dmitry Torokhov28a042a2018-07-13 16:13:54 +0200926
927 mt_release_pending_palms(td, app, input);
928
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200929 app->num_received = 0;
930 app->left_button_state = 0;
931
Benjamin Tissoires96098272017-06-15 15:32:05 +0200932 if (test_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags))
933 set_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
934 else
935 clear_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
936 clear_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100937}
938
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200939static int mt_compute_timestamp(struct mt_application *app, __s32 value)
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800940{
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200941 long delta = value - app->prev_scantime;
942 unsigned long jdelta = jiffies_to_usecs(jiffies - app->jiffies);
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800943
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200944 app->jiffies = jiffies;
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800945
946 if (delta < 0)
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200947 delta += app->scantime_logical_max;
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800948
949 /* HID_DG_SCANTIME is expressed in 100us, we want it in us. */
950 delta *= 100;
951
952 if (jdelta > MAX_TIMESTAMP_INTERVAL)
953 /* No data received for a while, resync the timestamp. */
954 return 0;
955 else
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +0200956 return app->timestamp + delta;
Nicolas Boichat29cc3092017-08-22 09:10:11 +0800957}
958
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +0100959static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100960 struct hid_usage *usage, __s32 value)
961{
Benjamin Tissoires55978fa2013-01-31 17:22:24 +0100962 /* we will handle the hidinput part later, now remains hiddev */
963 if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
964 hid->hiddev_hid_event(hid, field, usage, value);
965
966 return 1;
967}
968
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200969static int mt_process_slot(struct mt_device *td, struct input_dev *input,
970 struct mt_application *app,
971 struct mt_usages *slot)
Benjamin Tissoires55978fa2013-01-31 17:22:24 +0100972{
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200973 struct input_mt *mt = input->mt;
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +0200974 __s32 quirks = app->quirks;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200975 bool valid = true;
976 bool confidence_state = true;
977 bool inrange_state = false;
978 int active;
979 int slotnum;
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +0200980 int tool = MT_TOOL_FINGER;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +0100981
Benjamin Tissoires01eaac72018-07-13 16:13:48 +0200982 if (!slot)
983 return -EINVAL;
984
985 if ((quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) &&
986 app->num_received >= app->num_expected)
987 return -EAGAIN;
988
989 if (!(quirks & MT_QUIRK_ALWAYS_VALID)) {
990 if (quirks & MT_QUIRK_VALID_IS_INRANGE)
991 valid = *slot->inrange_state;
992 if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
993 valid = *slot->tip_state;
994 if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
995 valid = *slot->confidence_state;
996
997 if (!valid)
998 return 0;
999 }
1000
1001 slotnum = mt_compute_slot(td, app, slot, input);
1002 if (slotnum < 0 || slotnum >= td->maxcontacts)
1003 return 0;
1004
1005 if ((quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) {
1006 struct input_mt_slot *i_slot = &mt->slots[slotnum];
1007
1008 if (input_mt_is_active(i_slot) &&
1009 input_mt_is_used(mt, i_slot))
1010 return -EAGAIN;
1011 }
1012
1013 if (quirks & MT_QUIRK_CONFIDENCE)
1014 confidence_state = *slot->confidence_state;
1015
1016 if (quirks & MT_QUIRK_HOVERING)
1017 inrange_state = *slot->inrange_state;
1018
Dmitry Torokhov9152c7d2018-07-13 16:13:52 +02001019 active = *slot->tip_state || inrange_state;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001020
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +02001021 if (app->application == HID_GD_SYSTEM_MULTIAXIS)
1022 tool = MT_TOOL_DIAL;
Dmitry Torokhov28a042a2018-07-13 16:13:54 +02001023 else if (unlikely(!confidence_state)) {
Dmitry Torokhov9152c7d2018-07-13 16:13:52 +02001024 tool = MT_TOOL_PALM;
Pan Zhang306d5ac2019-12-19 10:45:30 +08001025 if (!active && mt &&
Dmitry Torokhov28a042a2018-07-13 16:13:54 +02001026 input_mt_is_active(&mt->slots[slotnum])) {
1027 /*
1028 * The non-confidence was reported for
1029 * previously valid contact that is also no
1030 * longer valid. We can't simply report
1031 * lift-off as userspace will not be aware
1032 * of non-confidence, so we need to split
1033 * it into 2 events: active MT_TOOL_PALM
1034 * and a separate liftoff.
1035 */
1036 active = true;
1037 set_bit(slotnum, app->pending_palm_slots);
1038 }
1039 }
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +02001040
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001041 input_mt_slot(input, slotnum);
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +02001042 input_mt_report_slot_state(input, tool, active);
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001043 if (active) {
1044 /* this finger is in proximity of the sensor */
1045 int wide = (*slot->w > *slot->h);
1046 int major = max(*slot->w, *slot->h);
1047 int minor = min(*slot->w, *slot->h);
1048 int orientation = wide;
1049 int max_azimuth;
1050 int azimuth;
1051
1052 if (slot->a != DEFAULT_ZERO) {
Wei-Ning Huang00720272017-10-12 14:21:43 +08001053 /*
1054 * Azimuth is counter-clockwise and ranges from [0, MAX)
1055 * (a full revolution). Convert it to clockwise ranging
1056 * [-MAX/2, MAX/2].
1057 *
1058 * Note that ABS_MT_ORIENTATION require us to report
1059 * the limit of [-MAX/4, MAX/4], but the value can go
1060 * out of range to [-MAX/2, MAX/2] to report an upside
1061 * down ellipsis.
1062 */
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001063 azimuth = *slot->a;
1064 max_azimuth = input_abs_get_max(input,
1065 ABS_MT_ORIENTATION);
1066 if (azimuth > max_azimuth * 2)
1067 azimuth -= max_azimuth * 4;
1068 orientation = -azimuth;
1069 }
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001070
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001071 if (quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
Dmitry Torokhov9152c7d2018-07-13 16:13:52 +02001072 /*
1073 * divided by two to match visual scale of touch
1074 * for devices with this quirk
1075 */
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001076 major = major >> 1;
1077 minor = minor >> 1;
1078 }
Hans de Goede55746d22017-11-22 12:57:09 +01001079
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001080 input_event(input, EV_ABS, ABS_MT_POSITION_X, *slot->x);
1081 input_event(input, EV_ABS, ABS_MT_POSITION_Y, *slot->y);
1082 input_event(input, EV_ABS, ABS_MT_TOOL_X, *slot->cx);
1083 input_event(input, EV_ABS, ABS_MT_TOOL_Y, *slot->cy);
1084 input_event(input, EV_ABS, ABS_MT_DISTANCE, !*slot->tip_state);
1085 input_event(input, EV_ABS, ABS_MT_ORIENTATION, orientation);
1086 input_event(input, EV_ABS, ABS_MT_PRESSURE, *slot->p);
1087 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
1088 input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
Hans de Goede127e71b2017-11-22 12:57:10 +01001089
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001090 set_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
1091 }
1092
1093 return 0;
1094}
1095
1096static void mt_process_mt_event(struct hid_device *hid,
1097 struct mt_application *app,
1098 struct hid_field *field,
1099 struct hid_usage *usage,
1100 __s32 value,
1101 bool first_packet)
1102{
1103 __s32 quirks = app->quirks;
1104 struct input_dev *input = field->hidinput->input;
1105
1106 if (!usage->type || !(hid->claimed & HID_CLAIMED_INPUT))
1107 return;
1108
1109 if (quirks & MT_QUIRK_WIN8_PTP_BUTTONS) {
1110
1111 /*
1112 * For Win8 PTP touchpads we should only look at
1113 * non finger/touch events in the first_packet of a
1114 * (possible) multi-packet frame.
1115 */
1116 if (!first_packet)
1117 return;
1118
1119 /*
1120 * For Win8 PTP touchpads we map both the clickpad click
1121 * and any "external" left buttons to BTN_LEFT if a
1122 * device claims to have both we need to report 1 for
1123 * BTN_LEFT if either is pressed, so we or all values
1124 * together and report the result in mt_sync_frame().
1125 */
1126 if (usage->type == EV_KEY && usage->code == BTN_LEFT) {
1127 app->left_button_state |= value;
Benjamin Tissoires55978fa2013-01-31 17:22:24 +01001128 return;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001129 }
1130 }
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001131
1132 input_event(input, usage->type, usage->code, value);
Benjamin Tissoires55978fa2013-01-31 17:22:24 +01001133}
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001134
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001135static void mt_touch_report(struct hid_device *hid,
1136 struct mt_report_data *rdata)
Benjamin Tissoires55978fa2013-01-31 17:22:24 +01001137{
1138 struct mt_device *td = hid_get_drvdata(hid);
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001139 struct hid_report *report = rdata->report;
1140 struct mt_application *app = rdata->application;
Benjamin Tissoires55978fa2013-01-31 17:22:24 +01001141 struct hid_field *field;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001142 struct input_dev *input;
1143 struct mt_usages *slot;
Hans de Goede55746d22017-11-22 12:57:09 +01001144 bool first_packet;
Benjamin Tissoires55978fa2013-01-31 17:22:24 +01001145 unsigned count;
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001146 int r, n;
1147 int scantime = 0;
1148 int contact_count = -1;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001149
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001150 /* sticky fingers release in progress, abort */
1151 if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
1152 return;
1153
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001154 scantime = *app->scantime;
1155 app->timestamp = mt_compute_timestamp(app, scantime);
1156 if (app->raw_cc != DEFAULT_ZERO)
1157 contact_count = *app->raw_cc;
1158
Benjamin Tissoiresc2517f62013-01-31 17:22:25 +01001159 /*
1160 * Includes multi-packet support where subsequent
1161 * packets are sent with zero contactcount.
1162 */
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001163 if (contact_count >= 0) {
Hans de Goedeaf8dc4d2017-11-22 12:57:08 +01001164 /*
1165 * For Win8 PTPs the first packet (td->num_received == 0) may
1166 * have a contactcount of 0 if there only is a button event.
1167 * We double check that this is not a continuation packet
1168 * of a possible multi-packet frame be checking that the
1169 * timestamp has changed.
1170 */
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001171 if ((app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001172 app->num_received == 0 &&
1173 app->prev_scantime != scantime)
1174 app->num_expected = contact_count;
Hans de Goedeaf8dc4d2017-11-22 12:57:08 +01001175 /* A non 0 contact count always indicates a first packet */
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001176 else if (contact_count)
1177 app->num_expected = contact_count;
Benjamin Tissoires7e3cc442013-02-06 12:10:47 +01001178 }
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001179 app->prev_scantime = scantime;
Benjamin Tissoiresc2517f62013-01-31 17:22:25 +01001180
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001181 first_packet = app->num_received == 0;
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001182
1183 input = report->field[0]->hidinput->input;
1184
1185 list_for_each_entry(slot, &app->mt_usages, list) {
1186 if (!mt_process_slot(td, input, app, slot))
1187 app->num_received++;
1188 }
1189
Benjamin Tissoires55978fa2013-01-31 17:22:24 +01001190 for (r = 0; r < report->maxfield; r++) {
1191 field = report->field[r];
1192 count = field->report_count;
1193
1194 if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
1195 continue;
1196
1197 for (n = 0; n < count; n++)
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001198 mt_process_mt_event(hid, app, field,
1199 &field->usage[n], field->value[n],
1200 first_packet);
Benjamin Tissoires55978fa2013-01-31 17:22:24 +01001201 }
Benjamin Tissoires5b62efd2013-02-27 16:23:15 +01001202
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001203 if (app->num_received >= app->num_expected)
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001204 mt_sync_frame(td, app, input);
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001205
1206 /*
1207 * Windows 8 specs says 2 things:
1208 * - once a contact has been reported, it has to be reported in each
1209 * subsequent report
1210 * - the report rate when fingers are present has to be at least
1211 * the refresh rate of the screen, 60 or 120 Hz
1212 *
1213 * I interprete this that the specification forces a report rate of
1214 * at least 60 Hz for a touchscreen to be certified.
1215 * Which means that if we do not get a report whithin 16 ms, either
1216 * something wrong happens, either the touchscreen forgets to send
1217 * a release. Taking a reasonable margin allows to remove issues
1218 * with USB communication or the load of the machine.
1219 *
1220 * Given that Win 8 devices are forced to send a release, this will
1221 * only affect laggish machines and the ones that have a firmware
1222 * defect.
1223 */
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001224 if (app->quirks & MT_QUIRK_STICKY_FINGERS) {
Benjamin Tissoires96098272017-06-15 15:32:05 +02001225 if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1226 mod_timer(&td->release_timer,
1227 jiffies + msecs_to_jiffies(100));
1228 else
1229 del_timer(&td->release_timer);
1230 }
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001231
1232 clear_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001233}
1234
Dmitry Torokhovb2c68a22015-09-29 15:52:59 -07001235static int mt_touch_input_configured(struct hid_device *hdev,
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001236 struct hid_input *hi,
1237 struct mt_application *app)
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001238{
1239 struct mt_device *td = hid_get_drvdata(hdev);
1240 struct mt_class *cls = &td->mtclass;
1241 struct input_dev *input = hi->input;
Dmitry Torokhovb2c68a22015-09-29 15:52:59 -07001242 int ret;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001243
1244 if (!td->maxcontacts)
1245 td->maxcontacts = MT_DEFAULT_MAXCONTACT;
1246
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001247 mt_post_parse(td, app);
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001248 if (td->serial_maybe)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001249 mt_post_parse_default_settings(td, app);
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001250
1251 if (cls->is_indirect)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001252 app->mt_flags |= INPUT_MT_POINTER;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001253
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001254 if (app->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001255 app->mt_flags |= INPUT_MT_DROP_UNUSED;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001256
Benjamin Tissoires015fdaa2015-03-06 11:14:42 -05001257 /* check for clickpads */
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001258 if ((app->mt_flags & INPUT_MT_POINTER) &&
1259 (app->buttons_count == 1))
Seth Forshee2c6e0272015-03-11 17:26:41 -05001260 td->is_buttonpad = true;
1261
1262 if (td->is_buttonpad)
Benjamin Tissoires015fdaa2015-03-06 11:14:42 -05001263 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
1264
Dmitry Torokhov28a042a2018-07-13 16:13:54 +02001265 app->pending_palm_slots = devm_kcalloc(&hi->input->dev,
1266 BITS_TO_LONGS(td->maxcontacts),
1267 sizeof(long),
1268 GFP_KERNEL);
1269 if (!app->pending_palm_slots)
1270 return -ENOMEM;
1271
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001272 ret = input_mt_init_slots(input, td->maxcontacts, app->mt_flags);
Dmitry Torokhovb2c68a22015-09-29 15:52:59 -07001273 if (ret)
1274 return ret;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001275
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001276 app->mt_flags = 0;
Dmitry Torokhovb2c68a22015-09-29 15:52:59 -07001277 return 0;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001278}
1279
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -07001280#define mt_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, \
1281 max, EV_KEY, (c))
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001282static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
1283 struct hid_field *field, struct hid_usage *usage,
1284 unsigned long **bit, int *max)
1285{
Benjamin Tissoires6aef7042014-02-28 11:41:25 -05001286 struct mt_device *td = hid_get_drvdata(hdev);
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001287 struct mt_application *application;
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001288 struct mt_report_data *rdata;
Benjamin Tissoires6aef7042014-02-28 11:41:25 -05001289
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001290 rdata = mt_find_report_data(td, field->report);
1291 if (!rdata) {
1292 hid_err(hdev, "failed to allocate data for report\n");
1293 return 0;
1294 }
1295
1296 application = rdata->application;
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001297
Benjamin Tissoires6aef7042014-02-28 11:41:25 -05001298 /*
1299 * If mtclass.export_all_inputs is not set, only map fields from
1300 * TouchScreen or TouchPad collections. We need to ignore fields
1301 * that belong to other collections such as Mouse that might have
1302 * the same GenericDesktop usages.
1303 */
1304 if (!td->mtclass.export_all_inputs &&
1305 field->application != HID_DG_TOUCHSCREEN &&
Benjamin Tissoiresfa11aa72013-03-22 18:38:32 +01001306 field->application != HID_DG_PEN &&
Benjamin Tissoires8fe89ef2016-11-25 14:27:23 +01001307 field->application != HID_DG_TOUCHPAD &&
1308 field->application != HID_GD_KEYBOARD &&
Hans de Goedee57f4e62017-08-22 08:37:52 +02001309 field->application != HID_GD_SYSTEM_CONTROL &&
João Paulo Rechi Vita1fbf74ef2017-07-24 14:22:24 -07001310 field->application != HID_CP_CONSUMER_CONTROL &&
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -07001311 field->application != HID_GD_WIRELESS_RADIO_CTLS &&
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +02001312 field->application != HID_GD_SYSTEM_MULTIAXIS &&
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -07001313 !(field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS &&
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001314 application->quirks & MT_QUIRK_ASUS_CUSTOM_UP))
Benjamin Tissoires6f492f22013-03-22 18:38:30 +01001315 return -1;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001316
Benjamin Tissoires6aef7042014-02-28 11:41:25 -05001317 /*
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -07001318 * Some Asus keyboard+touchpad devices have the hotkeys defined in the
1319 * touchpad report descriptor. We need to treat these as an array to
1320 * map usages to input keys.
1321 */
Jiri Kosina39bbf402017-08-03 11:25:32 +02001322 if (field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS &&
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001323 application->quirks & MT_QUIRK_ASUS_CUSTOM_UP &&
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -07001324 (usage->hid & HID_USAGE_PAGE) == HID_UP_CUSTOM) {
1325 set_bit(EV_REP, hi->input->evbit);
1326 if (field->flags & HID_MAIN_ITEM_VARIABLE)
1327 field->flags &= ~HID_MAIN_ITEM_VARIABLE;
1328 switch (usage->hid & HID_USAGE) {
1329 case 0x10: mt_map_key_clear(KEY_BRIGHTNESSDOWN); break;
1330 case 0x20: mt_map_key_clear(KEY_BRIGHTNESSUP); break;
1331 case 0x35: mt_map_key_clear(KEY_DISPLAY_OFF); break;
1332 case 0x6b: mt_map_key_clear(KEY_F21); break;
1333 case 0x6c: mt_map_key_clear(KEY_SLEEP); break;
1334 default:
1335 return -1;
1336 }
1337 return 1;
1338 }
1339
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +02001340 if (rdata->is_mt_collection)
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001341 return mt_touch_input_mapping(hdev, hi, field, usage, bit, max,
1342 application);
Benjamin Tissoires6aef7042014-02-28 11:41:25 -05001343
Benjamin Tissoires7ffa13b2018-09-04 15:31:15 +02001344 /*
1345 * some egalax touchscreens have "application == DG_TOUCHSCREEN"
1346 * for the stylus. Overwrite the hid_input application
1347 */
1348 if (field->physical == HID_DG_STYLUS)
1349 hi->application = HID_DG_STYLUS;
1350
Benjamin Tissoires6aef7042014-02-28 11:41:25 -05001351 /* let hid-core decide for the others */
1352 return 0;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001353}
1354
1355static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
1356 struct hid_field *field, struct hid_usage *usage,
1357 unsigned long **bit, int *max)
1358{
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +02001359 struct mt_device *td = hid_get_drvdata(hdev);
1360 struct mt_report_data *rdata;
Benjamin Tissoiresfa11aa72013-03-22 18:38:32 +01001361
Benjamin Tissoiresba6b0552018-07-13 16:13:49 +02001362 rdata = mt_find_report_data(td, field->report);
1363 if (rdata && rdata->is_mt_collection) {
Dmitry Torokhov4cf56a89c2017-07-11 10:02:18 -07001364 /* We own these mappings, tell hid-input to ignore them */
1365 return -1;
1366 }
Benjamin Tissoires6aef7042014-02-28 11:41:25 -05001367
1368 /* let hid-core decide for the others */
1369 return 0;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001370}
1371
1372static int mt_event(struct hid_device *hid, struct hid_field *field,
1373 struct hid_usage *usage, __s32 value)
1374{
1375 struct mt_device *td = hid_get_drvdata(hid);
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001376 struct mt_report_data *rdata;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001377
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001378 rdata = mt_find_report_data(td, field->report);
1379 if (rdata && rdata->is_mt_collection)
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001380 return mt_touch_event(hid, field, usage, value);
1381
Benjamin Tissoirese55f6202014-02-28 11:41:24 -05001382 return 0;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001383}
1384
1385static void mt_report(struct hid_device *hid, struct hid_report *report)
1386{
1387 struct mt_device *td = hid_get_drvdata(hid);
Benjamin Tissoirese55f6202014-02-28 11:41:24 -05001388 struct hid_field *field = report->field[0];
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001389 struct mt_report_data *rdata;
Benjamin Tissoiresa69c5f82013-03-22 18:38:29 +01001390
1391 if (!(hid->claimed & HID_CLAIMED_INPUT))
1392 return;
1393
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001394 rdata = mt_find_report_data(td, report);
1395 if (rdata && rdata->is_mt_collection)
1396 return mt_touch_report(hid, rdata);
Benjamin Tissoiresfa11aa72013-03-22 18:38:32 +01001397
Benjamin Tissoirese55f6202014-02-28 11:41:24 -05001398 if (field && field->hidinput && field->hidinput->input)
1399 input_sync(field->hidinput->input);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001400}
1401
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001402static bool mt_need_to_apply_feature(struct hid_device *hdev,
1403 struct hid_field *field,
Benjamin Tissoires02946f42018-04-24 10:04:37 +02001404 struct hid_usage *usage,
1405 enum latency_mode latency,
1406 bool surface_switch,
Benjamin Tissoiresec6adef2018-09-04 15:31:12 +02001407 bool button_switch,
1408 bool *inputmode_found)
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001409{
1410 struct mt_device *td = hid_get_drvdata(hdev);
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +01001411 struct mt_class *cls = &td->mtclass;
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001412 struct hid_report *report = field->report;
1413 unsigned int index = usage->usage_index;
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +01001414 char *buf;
Aaron Ma3064a032018-02-03 23:57:15 +08001415 u32 report_len;
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001416 int max;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001417
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001418 switch (usage->hid) {
1419 case HID_DG_INPUTMODE:
Benjamin Tissoiresec6adef2018-09-04 15:31:12 +02001420 /*
1421 * Some elan panels wrongly declare 2 input mode features,
1422 * and silently ignore when we set the value in the second
1423 * field. Skip the second feature and hope for the best.
1424 */
1425 if (*inputmode_found)
1426 return false;
1427
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +01001428 if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) {
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001429 report_len = hid_report_len(report);
1430 buf = hid_alloc_report_buf(report, GFP_KERNEL);
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +01001431 if (!buf) {
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001432 hid_err(hdev,
1433 "failed to allocate buffer for report\n");
1434 return false;
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +01001435 }
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001436 hid_hw_raw_request(hdev, report->id, buf, report_len,
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +01001437 HID_FEATURE_REPORT,
1438 HID_REQ_GET_REPORT);
1439 kfree(buf);
1440 }
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001441
1442 field->value[index] = td->inputmode_value;
Benjamin Tissoiresec6adef2018-09-04 15:31:12 +02001443 *inputmode_found = true;
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001444 return true;
1445
1446 case HID_DG_CONTACTMAX:
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001447 if (cls->maxcontacts) {
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001448 max = min_t(int, field->logical_maximum,
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001449 cls->maxcontacts);
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001450 if (field->value[index] != max) {
1451 field->value[index] = max;
1452 return true;
1453 }
1454 }
1455 break;
Benjamin Tissoires02946f42018-04-24 10:04:37 +02001456
1457 case HID_DG_LATENCYMODE:
1458 field->value[index] = latency;
Jiri Kosina99c703a2018-05-16 11:02:07 +02001459 return true;
Benjamin Tissoires02946f42018-04-24 10:04:37 +02001460
1461 case HID_DG_SURFACESWITCH:
1462 field->value[index] = surface_switch;
Jiri Kosina99c703a2018-05-16 11:02:07 +02001463 return true;
Benjamin Tissoires02946f42018-04-24 10:04:37 +02001464
1465 case HID_DG_BUTTONSWITCH:
1466 field->value[index] = button_switch;
Jiri Kosina99c703a2018-05-16 11:02:07 +02001467 return true;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001468 }
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001469
1470 return false; /* no need to update the report */
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001471}
1472
Benjamin Tissoires02946f42018-04-24 10:04:37 +02001473static void mt_set_modes(struct hid_device *hdev, enum latency_mode latency,
1474 bool surface_switch, bool button_switch)
Benjamin Tissoires31ae9bd2012-02-04 17:08:49 +01001475{
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001476 struct hid_report_enum *rep_enum;
1477 struct hid_report *rep;
1478 struct hid_usage *usage;
1479 int i, j;
1480 bool update_report;
Benjamin Tissoiresec6adef2018-09-04 15:31:12 +02001481 bool inputmode_found = false;
Benjamin Tissoires31ae9bd2012-02-04 17:08:49 +01001482
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001483 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
1484 list_for_each_entry(rep, &rep_enum->report_list, list) {
1485 update_report = false;
Benjamin Tissoires31ae9bd2012-02-04 17:08:49 +01001486
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001487 for (i = 0; i < rep->maxfield; i++) {
1488 /* Ignore if report count is out of bounds. */
1489 if (rep->field[i]->report_count < 1)
1490 continue;
Benjamin Tissoires31ae9bd2012-02-04 17:08:49 +01001491
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001492 for (j = 0; j < rep->field[i]->maxusage; j++) {
1493 usage = &rep->field[i]->usage[j];
1494
1495 if (mt_need_to_apply_feature(hdev,
1496 rep->field[i],
Benjamin Tissoires02946f42018-04-24 10:04:37 +02001497 usage,
1498 latency,
1499 surface_switch,
Benjamin Tissoiresec6adef2018-09-04 15:31:12 +02001500 button_switch,
1501 &inputmode_found))
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001502 update_report = true;
1503 }
Benjamin Tissoires31ae9bd2012-02-04 17:08:49 +01001504 }
Benjamin Tissoires7f81c8d2018-04-24 10:04:36 +02001505
1506 if (update_report)
1507 hid_hw_request(hdev, rep, HID_REQ_SET_REPORT);
Benjamin Tissoires31ae9bd2012-02-04 17:08:49 +01001508 }
1509}
1510
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001511static void mt_post_parse_default_settings(struct mt_device *td,
1512 struct mt_application *app)
Henrik Rydberg4fa3a5832012-05-01 08:40:01 +02001513{
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001514 __s32 quirks = app->quirks;
Henrik Rydberg4fa3a5832012-05-01 08:40:01 +02001515
1516 /* unknown serial device needs special quirks */
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001517 if (list_is_singular(&app->mt_usages)) {
Henrik Rydberg4fa3a5832012-05-01 08:40:01 +02001518 quirks |= MT_QUIRK_ALWAYS_VALID;
1519 quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
1520 quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
1521 quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;
Benjamin Tissoirese0bb8f92013-01-31 17:22:27 +01001522 quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
Henrik Rydberg4fa3a5832012-05-01 08:40:01 +02001523 }
1524
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001525 app->quirks = quirks;
Henrik Rydberg4fa3a5832012-05-01 08:40:01 +02001526}
1527
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001528static void mt_post_parse(struct mt_device *td, struct mt_application *app)
Benjamin Tissoires3ac36d12012-05-04 14:53:46 +02001529{
Benjamin Tissoires01eaac72018-07-13 16:13:48 +02001530 if (!app->have_contact_count)
Benjamin Tissoires3ceb3822018-07-13 16:13:46 +02001531 app->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
Benjamin Tissoires3ac36d12012-05-04 14:53:46 +02001532}
1533
Dmitry Torokhovb2c68a22015-09-29 15:52:59 -07001534static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
Henrik Rydberg76f59022012-09-01 20:11:34 +02001535{
1536 struct mt_device *td = hid_get_drvdata(hdev);
Benjamin Tissoiresc08d46a2013-07-24 19:38:05 +02001537 char *name;
1538 const char *suffix = NULL;
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001539 struct mt_report_data *rdata;
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001540 struct mt_application *mt_application = NULL;
Benjamin Tissoires40ec2602018-04-24 10:04:35 +02001541 struct hid_report *report;
Dmitry Torokhovb2c68a22015-09-29 15:52:59 -07001542 int ret;
Henrik Rydberg76f59022012-09-01 20:11:34 +02001543
Benjamin Tissoires40ec2602018-04-24 10:04:35 +02001544 list_for_each_entry(report, &hi->reports, hidinput_list) {
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001545 rdata = mt_find_report_data(td, report);
1546 if (!rdata) {
1547 hid_err(hdev, "failed to allocate data for report\n");
1548 return -ENOMEM;
1549 }
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001550
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001551 mt_application = rdata->application;
1552
1553 if (rdata->is_mt_collection) {
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001554 ret = mt_touch_input_configured(hdev, hi,
1555 mt_application);
Benjamin Tissoires40ec2602018-04-24 10:04:35 +02001556 if (ret)
1557 return ret;
1558 }
Benjamin Tissoires40ec2602018-04-24 10:04:35 +02001559 }
1560
Benjamin Tissoires7ffa13b2018-09-04 15:31:15 +02001561 switch (hi->application) {
1562 case HID_GD_KEYBOARD:
1563 case HID_GD_KEYPAD:
1564 case HID_GD_MOUSE:
1565 case HID_DG_TOUCHPAD:
1566 case HID_GD_SYSTEM_CONTROL:
1567 case HID_CP_CONSUMER_CONTROL:
1568 case HID_GD_WIRELESS_RADIO_CTLS:
1569 case HID_GD_SYSTEM_MULTIAXIS:
1570 /* already handled by hid core */
1571 break;
1572 case HID_DG_TOUCHSCREEN:
1573 /* we do not set suffix = "Touchscreen" */
1574 hi->input->name = hdev->name;
1575 break;
1576 case HID_DG_STYLUS:
1577 /* force BTN_STYLUS to allow tablet matching in udev */
1578 __set_bit(BTN_STYLUS, hi->input->keybit);
1579 break;
1580 case HID_VD_ASUS_CUSTOM_MEDIA_KEYS:
1581 suffix = "Custom Media Keys";
1582 break;
Benjamin Tissoires69ecd442019-08-12 18:23:26 +02001583 case HID_DG_PEN:
1584 suffix = "Stylus";
1585 break;
Benjamin Tissoires7ffa13b2018-09-04 15:31:15 +02001586 default:
1587 suffix = "UNKNOWN";
1588 break;
Benjamin Tissoiresc08d46a2013-07-24 19:38:05 +02001589 }
1590
1591 if (suffix) {
1592 name = devm_kzalloc(&hi->input->dev,
1593 strlen(hdev->name) + strlen(suffix) + 2,
1594 GFP_KERNEL);
1595 if (name) {
1596 sprintf(name, "%s %s", hdev->name, suffix);
1597 hi->input->name = name;
1598 }
1599 }
Dmitry Torokhovb2c68a22015-09-29 15:52:59 -07001600
1601 return 0;
Henrik Rydberg76f59022012-09-01 20:11:34 +02001602}
1603
Benjamin Tissoiresf3287a92017-01-30 10:48:06 +01001604static void mt_fix_const_field(struct hid_field *field, unsigned int usage)
1605{
1606 if (field->usage[0].hid != usage ||
1607 !(field->flags & HID_MAIN_ITEM_CONSTANT))
1608 return;
1609
1610 field->flags &= ~HID_MAIN_ITEM_CONSTANT;
1611 field->flags |= HID_MAIN_ITEM_VARIABLE;
1612}
1613
1614static void mt_fix_const_fields(struct hid_device *hdev, unsigned int usage)
1615{
1616 struct hid_report *report;
1617 int i;
1618
1619 list_for_each_entry(report,
1620 &hdev->report_enum[HID_INPUT_REPORT].report_list,
1621 list) {
1622
1623 if (!report->maxfield)
1624 continue;
1625
1626 for (i = 0; i < report->maxfield; i++)
1627 if (report->field[i]->maxusage >= 1)
1628 mt_fix_const_field(report->field[i], usage);
1629 }
1630}
1631
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001632static void mt_release_contacts(struct hid_device *hid)
1633{
1634 struct hid_input *hidinput;
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001635 struct mt_application *application;
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001636 struct mt_device *td = hid_get_drvdata(hid);
1637
1638 list_for_each_entry(hidinput, &hid->inputs, list) {
1639 struct input_dev *input_dev = hidinput->input;
1640 struct input_mt *mt = input_dev->mt;
1641 int i;
1642
1643 if (mt) {
1644 for (i = 0; i < mt->num_slots; i++) {
1645 input_mt_slot(input_dev, i);
Jiada Wang5fc70e32020-05-11 13:12:13 -07001646 input_mt_report_slot_inactive(input_dev);
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001647 }
1648 input_mt_sync_frame(input_dev);
1649 input_sync(input_dev);
1650 }
1651 }
1652
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001653 list_for_each_entry(application, &td->applications, list) {
1654 application->num_received = 0;
1655 }
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001656}
1657
Kees Cook0ee32772017-10-04 17:53:24 -07001658static void mt_expired_timeout(struct timer_list *t)
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001659{
Kees Cook0ee32772017-10-04 17:53:24 -07001660 struct mt_device *td = from_timer(td, t, release_timer);
1661 struct hid_device *hdev = td->hdev;
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001662
1663 /*
1664 * An input report came in just before we release the sticky fingers,
1665 * it will take care of the sticky fingers.
1666 */
1667 if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
1668 return;
Benjamin Tissoires96098272017-06-15 15:32:05 +02001669 if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1670 mt_release_contacts(hdev);
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001671 clear_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
1672}
1673
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001674static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
1675{
Benjamin Tissoires2d936662011-01-11 16:45:54 +01001676 int ret, i;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001677 struct mt_device *td;
Benjamin Tissoirescf6d15d2018-07-13 16:13:44 +02001678 const struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
Benjamin Tissoires2d936662011-01-11 16:45:54 +01001679
Henrik Rydberg94b5485c2012-08-08 21:45:50 +02001680 for (i = 0; mt_classes[i].name ; i++) {
1681 if (id->driver_data == mt_classes[i].name) {
1682 mtclass = &(mt_classes[i]);
1683 break;
Benjamin Tissoires2d936662011-01-11 16:45:54 +01001684 }
1685 }
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001686
Benjamin Tissoiresc08d46a2013-07-24 19:38:05 +02001687 td = devm_kzalloc(&hdev->dev, sizeof(struct mt_device), GFP_KERNEL);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001688 if (!td) {
1689 dev_err(&hdev->dev, "cannot allocate multitouch data\n");
1690 return -ENOMEM;
1691 }
Kees Cook0ee32772017-10-04 17:53:24 -07001692 td->hdev = hdev;
Benjamin Tissoireseec29e32011-11-23 10:54:28 +01001693 td->mtclass = *mtclass;
Andrew Duggan9abebed2014-03-19 13:39:03 -07001694 td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001695 hid_set_drvdata(hdev, td);
1696
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001697 INIT_LIST_HEAD(&td->applications);
Benjamin Tissoires8dfe14b2018-07-13 16:13:47 +02001698 INIT_LIST_HEAD(&td->reports);
Benjamin Tissoiresf146d1c2018-07-13 16:13:45 +02001699
Henrik Rydberg76f59022012-09-01 20:11:34 +02001700 if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
1701 td->serial_maybe = true;
1702
Benjamin Tissoiresb897f6d2016-11-25 14:27:22 +01001703 /* This allows the driver to correctly support devices
1704 * that emit events over several HID messages.
1705 */
1706 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
1707
1708 /*
1709 * This allows the driver to handle different input sensors
Benjamin Tissoires40ec2602018-04-24 10:04:35 +02001710 * that emits events through different applications on the same HID
Benjamin Tissoiresb897f6d2016-11-25 14:27:22 +01001711 * device.
1712 */
Benjamin Tissoires40ec2602018-04-24 10:04:35 +02001713 hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
Benjamin Tissoiresb897f6d2016-11-25 14:27:22 +01001714
Benjamin Tissoires0d6c3012018-09-04 15:31:14 +02001715 if (id->group != HID_GROUP_MULTITOUCH_WIN_8)
1716 hdev->quirks |= HID_QUIRK_MULTI_INPUT;
1717
Benjamin Tissoires40d5bb82020-05-26 17:07:17 +02001718 if (mtclass->quirks & MT_QUIRK_FORCE_MULTI_INPUT) {
1719 hdev->quirks &= ~HID_QUIRK_INPUT_PER_APP;
1720 hdev->quirks |= HID_QUIRK_MULTI_INPUT;
1721 }
1722
Kees Cook0ee32772017-10-04 17:53:24 -07001723 timer_setup(&td->release_timer, mt_expired_timeout, 0);
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001724
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001725 ret = hid_parse(hdev);
1726 if (ret != 0)
Benjamin Tissoiresc08d46a2013-07-24 19:38:05 +02001727 return ret;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001728
Benjamin Tissoiresf3287a92017-01-30 10:48:06 +01001729 if (mtclass->quirks & MT_QUIRK_FIX_CONST_CONTACT_ID)
1730 mt_fix_const_fields(hdev, HID_DG_CONTACTID);
1731
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001732 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
Benjamin Tissoires2d936662011-01-11 16:45:54 +01001733 if (ret)
Benjamin Tissoiresc08d46a2013-07-24 19:38:05 +02001734 return ret;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001735
Benjamin Tissoireseec29e32011-11-23 10:54:28 +01001736 ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
Nicholas Krause0c4b3c62016-02-04 10:52:40 -05001737 if (ret)
1738 dev_warn(&hdev->dev, "Cannot allocate sysfs group for %s\n",
1739 hdev->name);
Benjamin Tissoireseec29e32011-11-23 10:54:28 +01001740
Benjamin Tissoires02946f42018-04-24 10:04:37 +02001741 mt_set_modes(hdev, HID_LATENCY_NORMAL, true, true);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001742
1743 return 0;
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001744}
1745
1746#ifdef CONFIG_PM
1747static int mt_reset_resume(struct hid_device *hdev)
1748{
Benson Leungd3e69b92016-03-11 14:19:49 -08001749 mt_release_contacts(hdev);
Benjamin Tissoires02946f42018-04-24 10:04:37 +02001750 mt_set_modes(hdev, HID_LATENCY_NORMAL, true, true);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001751 return 0;
1752}
Scott Liudfeefd12012-08-15 17:21:55 +08001753
1754static int mt_resume(struct hid_device *hdev)
1755{
Scott Liudfeefd12012-08-15 17:21:55 +08001756 /* Some Elan legacy devices require SET_IDLE to be set on resume.
1757 * It should be safe to send it to other devices too.
1758 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */
1759
Benjamin Tissoires4ba25d32013-02-27 16:38:18 +01001760 hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE);
Scott Liudfeefd12012-08-15 17:21:55 +08001761
1762 return 0;
1763}
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001764#endif
1765
1766static void mt_remove(struct hid_device *hdev)
1767{
Benjamin Tissoiresb897f6d2016-11-25 14:27:22 +01001768 struct mt_device *td = hid_get_drvdata(hdev);
1769
Benjamin Tissoires4f4001b2017-06-15 15:32:04 +02001770 del_timer_sync(&td->release_timer);
1771
Benjamin Tissoireseec29e32011-11-23 10:54:28 +01001772 sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
Benjamin Tissoires59392122013-05-29 10:45:09 +02001773 hid_hw_stop(hdev);
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001774}
1775
Benjamin Tissoires0fa9c612014-02-28 11:41:23 -05001776/*
1777 * This list contains only:
1778 * - VID/PID of products not working with the default multitouch handling
1779 * - 2 generic rules.
1780 * So there is no point in adding here any device with MT_CLS_DEFAULT.
1781 */
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01001782static const struct hid_device_id mt_devices[] = {
1783
Benjamin Tissoiresf786bba2011-03-22 17:34:01 +01001784 /* 3M panels */
1785 { .driver_data = MT_CLS_3M,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001786 MT_USB_DEVICE(USB_VENDOR_ID_3M,
Benjamin Tissoiresf786bba2011-03-22 17:34:01 +01001787 USB_DEVICE_ID_3M1968) },
1788 { .driver_data = MT_CLS_3M,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001789 MT_USB_DEVICE(USB_VENDOR_ID_3M,
Benjamin Tissoiresf786bba2011-03-22 17:34:01 +01001790 USB_DEVICE_ID_3M2256) },
Benjamin Tissoiresc4fad872011-12-23 15:41:00 +01001791 { .driver_data = MT_CLS_3M,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001792 MT_USB_DEVICE(USB_VENDOR_ID_3M,
Benjamin Tissoiresc4fad872011-12-23 15:41:00 +01001793 USB_DEVICE_ID_3M3266) },
Benjamin Tissoiresf786bba2011-03-22 17:34:01 +01001794
Benjamin Tissoires6aef7042014-02-28 11:41:25 -05001795 /* Anton devices */
1796 { .driver_data = MT_CLS_EXPORT_ALL_INPUTS,
1797 MT_USB_DEVICE(USB_VENDOR_ID_ANTON,
1798 USB_DEVICE_ID_ANTON_TOUCH_PAD) },
Benjamin Tissoirese6aac342011-05-19 14:18:13 +02001799
João Paulo Rechi Vita957b8df2017-07-24 14:22:25 -07001800 /* Asus T304UA */
1801 { .driver_data = MT_CLS_ASUS,
1802 HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
1803 USB_VENDOR_ID_ASUSTEK,
1804 USB_DEVICE_ID_ASUSTEK_T304_KEYBOARD) },
1805
Benjamin Tissoiresb1057122011-12-23 15:40:59 +01001806 /* Atmel panels */
1807 { .driver_data = MT_CLS_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001808 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
Benjamin Tissoires841cb152012-03-06 10:53:45 +01001809 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
Benjamin Tissoiresb1057122011-12-23 15:40:59 +01001810
Jiri Kosina9ed32692012-04-20 12:15:44 +02001811 /* Baanto multitouch devices */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01001812 { .driver_data = MT_CLS_NSMU,
Jiri Kosina16b79bb2012-05-05 23:32:54 +02001813 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
Jiri Kosina9ed32692012-04-20 12:15:44 +02001814 USB_DEVICE_ID_BAANTO_MT_190W2) },
Benjamin Tissoires0fa9c612014-02-28 11:41:23 -05001815
Benjamin Tissoiresa841b622011-03-18 14:27:54 +01001816 /* Cando panels */
1817 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001818 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
Benjamin Tissoiresa841b622011-03-18 14:27:54 +01001819 USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
Benjamin Tissoiresa841b622011-03-18 14:27:54 +01001820 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001821 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
Benjamin Tissoiresa841b622011-03-18 14:27:54 +01001822 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
1823
Austin Zhang942fd422011-05-28 02:03:47 +08001824 /* Chunghwa Telecom touch panels */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01001825 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001826 MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
Austin Zhang942fd422011-05-28 02:03:47 +08001827 USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
1828
Yang Bo070f63b2015-07-20 09:40:28 -07001829 /* CJTouch panels */
1830 { .driver_data = MT_CLS_NSMU,
1831 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
1832 USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020) },
1833 { .driver_data = MT_CLS_NSMU,
1834 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
1835 USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040) },
1836
Benjamin Tissoires79603dc2011-05-19 14:18:14 +02001837 /* CVTouch panels */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01001838 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001839 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
Benjamin Tissoires79603dc2011-05-19 14:18:14 +02001840 USB_DEVICE_ID_CVTOUCH_SCREEN) },
1841
Benjamin Tissoires22408282011-05-20 15:59:34 +02001842 /* eGalax devices (resistive) */
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001843 { .driver_data = MT_CLS_EGALAX,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001844 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001845 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
1846 { .driver_data = MT_CLS_EGALAX,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001847 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001848 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
Benjamin Tissoires22408282011-05-20 15:59:34 +02001849
1850 /* eGalax devices (capacitive) */
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001851 { .driver_data = MT_CLS_EGALAX_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001852 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001853 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001854 { .driver_data = MT_CLS_EGALAX,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001855 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001856 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001857 { .driver_data = MT_CLS_EGALAX_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001858 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001859 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
Benjamin Tissoires2ce09df2012-03-06 17:57:02 +01001860 { .driver_data = MT_CLS_EGALAX_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001861 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoires2ce09df2012-03-06 17:57:02 +01001862 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
Benjamin Tissoires22408282011-05-20 15:59:34 +02001863 { .driver_data = MT_CLS_EGALAX_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001864 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoires22408282011-05-20 15:59:34 +02001865 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001866 { .driver_data = MT_CLS_EGALAX_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001867 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001868 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001869 { .driver_data = MT_CLS_EGALAX,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001870 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoires22408282011-05-20 15:59:34 +02001871 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
Benjamin Tissoires22408282011-05-20 15:59:34 +02001872 { .driver_data = MT_CLS_EGALAX,
1873 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001874 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001875 { .driver_data = MT_CLS_EGALAX_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001876 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001877 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001878 { .driver_data = MT_CLS_EGALAX,
Andy Shevchenkoaa672da2013-05-17 14:34:48 +03001879 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1880 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
1881 { .driver_data = MT_CLS_EGALAX,
1882 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1883 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
1884 { .driver_data = MT_CLS_EGALAX,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001885 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoires66f06122011-11-23 10:54:33 +01001886 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
1887 { .driver_data = MT_CLS_EGALAX,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001888 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Marek Vasutbb9ff212011-11-23 10:54:32 +01001889 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
Benjamin Tissoires1b723e82011-11-23 10:54:34 +01001890 { .driver_data = MT_CLS_EGALAX_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001891 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoiresfd1d1522012-03-06 10:53:47 +01001892 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
1893 { .driver_data = MT_CLS_EGALAX_SERIAL,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001894 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Thierry Redingae01c9e2012-08-09 08:34:48 +02001895 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) },
1896 { .driver_data = MT_CLS_EGALAX_SERIAL,
1897 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
Benjamin Tissoirese36f6902011-11-23 10:54:31 +01001898 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
Sebastian Reichelf9e82292020-04-13 18:02:37 +02001899 { .driver_data = MT_CLS_EGALAX,
1900 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1901 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_C002) },
Benjamin Tissoires22408282011-05-20 15:59:34 +02001902
Benjamin Tissoires40d5bb82020-05-26 17:07:17 +02001903 /* Elan devices */
1904 { .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
1905 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1906 USB_VENDOR_ID_ELAN, 0x313a) },
1907
Tomas Sokorai7c7606a2014-04-23 10:42:41 -04001908 /* Elitegroup panel */
1909 { .driver_data = MT_CLS_SERIAL,
1910 MT_USB_DEVICE(USB_VENDOR_ID_ELITEGROUP,
1911 USB_DEVICE_ID_ELITEGROUP_05D8) },
1912
Henrik Rydberg77723e32012-09-07 19:37:40 +02001913 /* Flatfrog Panels */
1914 { .driver_data = MT_CLS_FLATFROG,
1915 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG,
1916 USB_DEVICE_ID_MULTITOUCH_3200) },
1917
Benjamin Tissoires3db187e2014-01-23 16:33:14 -05001918 /* FocalTech Panels */
1919 { .driver_data = MT_CLS_SERIAL,
1920 MT_USB_DEVICE(USB_VENDOR_ID_CYGNAL,
1921 USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH) },
1922
Benjamin Tissoires5572da02011-01-07 23:47:27 +01001923 /* GeneralTouch panel */
Xianhan Yuf5ff4e12012-09-28 10:18:59 +08001924 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001925 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
Benjamin Tissoires5572da02011-01-07 23:47:27 +01001926 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
Xianhan Yuf5ff4e12012-09-28 10:18:59 +08001927 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1928 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1929 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) },
Luosong7b226292013-10-02 11:20:00 +02001930 { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
1931 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1932 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0101) },
1933 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1934 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1935 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0102) },
1936 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1937 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1938 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0106) },
1939 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1940 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1941 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A) },
1942 { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1943 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1944 USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100) },
Benjamin Tissoires5572da02011-01-07 23:47:27 +01001945
Andreas Nielsen4d5df5d2012-03-19 15:41:03 +01001946 /* Gametel game controller */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01001947 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001948 MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
Andreas Nielsen4d5df5d2012-03-19 15:41:03 +01001949 USB_DEVICE_ID_GAMETEL_MT_MODE) },
1950
Benjamin Tissoiresee0fbd12011-05-19 14:18:15 +02001951 /* GoodTouch panels */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01001952 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001953 MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
Benjamin Tissoiresee0fbd12011-05-19 14:18:15 +02001954 USB_DEVICE_ID_GOODTOUCH_000f) },
1955
Benjamin Tissoires54580362011-11-29 13:13:12 +01001956 /* Hanvon panels */
1957 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001958 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
Benjamin Tissoires54580362011-11-29 13:13:12 +01001959 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
1960
Austin Zhang4e61f0d2011-05-09 23:54:14 +08001961 /* Ilitek dual touch panel */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01001962 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001963 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
Austin Zhang4e61f0d2011-05-09 23:54:14 +08001964 USB_DEVICE_ID_ILITEK_MULTITOUCH) },
1965
Benjamin Tissoiresf3287a92017-01-30 10:48:06 +01001966 /* LG Melfas panel */
1967 { .driver_data = MT_CLS_LG,
1968 HID_USB_DEVICE(USB_VENDOR_ID_LG,
1969 USB_DEVICE_ID_LG_MELFAS_MT) },
Aaron Ma348b80b2019-12-04 20:42:07 +08001970 { .driver_data = MT_CLS_LG,
1971 HID_DEVICE(BUS_I2C, HID_GROUP_GENERIC,
1972 USB_VENDOR_ID_LG, I2C_DEVICE_ID_LG_7010) },
Benjamin Tissoiresf3287a92017-01-30 10:48:06 +01001973
Benjamin Tissoires4a6ee682011-04-22 11:51:48 +02001974 /* MosArt panels */
1975 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001976 MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
Benjamin Tissoires4a6ee682011-04-22 11:51:48 +02001977 USB_DEVICE_ID_ASUS_T91MT)},
1978 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001979 MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
Benjamin Tissoires4a6ee682011-04-22 11:51:48 +02001980 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
1981 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02001982 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
Benjamin Tissoires4a6ee682011-04-22 11:51:48 +02001983 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
1984
Austin Hendrix4db703e2012-06-04 15:27:51 -07001985 /* Novatek Panel */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01001986 { .driver_data = MT_CLS_NSMU,
Jiri Kosina4380d812012-06-06 16:28:33 +02001987 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
Austin Hendrix4db703e2012-06-04 15:27:51 -07001988 USB_DEVICE_ID_NOVATEK_PCT) },
1989
Benjamin Tissoiresa80e8032016-05-31 17:31:15 +02001990 /* Ntrig Panel */
1991 { .driver_data = MT_CLS_NSMU,
1992 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1993 USB_VENDOR_ID_NTRIG, 0x1b05) },
1994
Hans de Goedefb55b402017-11-22 12:57:07 +01001995 /* Panasonic panels */
1996 { .driver_data = MT_CLS_PANASONIC,
1997 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
1998 USB_DEVICE_ID_PANABOARD_UBT780) },
1999 { .driver_data = MT_CLS_PANASONIC,
2000 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
2001 USB_DEVICE_ID_PANABOARD_UBT880) },
2002
Aaron Tianb7ea95f2011-12-15 11:09:06 +08002003 /* PixArt optical touch screen */
2004 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002005 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
Aaron Tianb7ea95f2011-12-15 11:09:06 +08002006 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
2007 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002008 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
Aaron Tianb7ea95f2011-12-15 11:09:06 +08002009 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
2010 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002011 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
Aaron Tianb7ea95f2011-12-15 11:09:06 +08002012 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
2013
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01002014 /* PixCir-based panels */
Benjamin Tissoires1e9cf35b2011-01-31 11:28:20 +01002015 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002016 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01002017 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
2018
Benjamin Tissoires5e7ea112011-11-29 13:13:10 +01002019 /* Quanta-based panels */
2020 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002021 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
Benjamin Tissoires5e7ea112011-11-29 13:13:10 +01002022 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
Forest Bonda6802e02013-10-21 12:38:49 -04002023
Benjamin Tissoires843e4752018-03-20 12:04:46 +01002024 /* Razer touchpads */
2025 { .driver_data = MT_CLS_RAZER_BLADE_STEALTH,
2026 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2027 USB_VENDOR_ID_SYNAPTICS, 0x8323) },
2028
Benjamin Tissoires69ecd442019-08-12 18:23:26 +02002029 /* Smart Tech panels */
2030 { .driver_data = MT_CLS_SMART_TECH,
2031 MT_USB_DEVICE(0x0b8c, 0x0092)},
2032
Benjamin Tissoires043b4032011-03-18 14:27:53 +01002033 /* Stantum panels */
Benjamin Tissoiresbf5af9b2011-05-19 14:18:18 +02002034 { .driver_data = MT_CLS_CONFIDENCE,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002035 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
Benjamin Tissoires043b4032011-03-18 14:27:53 +01002036 USB_DEVICE_ID_MTP_STM)},
Benjamin Tissoires043b4032011-03-18 14:27:53 +01002037
Benjamin Tissoires40d5bb82020-05-26 17:07:17 +02002038 /* Synaptics 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_SYNAPTICS, 0xce08) },
2042
Benjamin Tissoires847672c2012-02-04 17:08:50 +01002043 /* TopSeed panels */
2044 { .driver_data = MT_CLS_TOPSEED,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002045 MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
Benjamin Tissoires847672c2012-02-04 17:08:50 +01002046 USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },
2047
Benjamin Tissoires5e74e562011-05-19 14:18:16 +02002048 /* Touch International panels */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002049 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002050 MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
Benjamin Tissoires5e74e562011-05-19 14:18:16 +02002051 USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
2052
Benjamin Tissoires617b64f2011-05-19 14:18:17 +02002053 /* Unitec panels */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002054 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002055 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
Benjamin Tissoires617b64f2011-05-19 14:18:17 +02002056 USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002057 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002058 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
Benjamin Tissoires617b64f2011-05-19 14:18:17 +02002059 USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
KaiChung Chengbf9d1212013-11-21 10:04:30 +01002060
Mathieu Magnaudetda10bc22014-11-22 12:02:07 +01002061 /* VTL panels */
2062 { .driver_data = MT_CLS_VTL,
2063 MT_USB_DEVICE(USB_VENDOR_ID_VTL,
2064 USB_DEVICE_ID_VTL_MULTITOUCH_FF3F) },
2065
KaiChung Chengbf9d1212013-11-21 10:04:30 +01002066 /* Wistron panels */
2067 { .driver_data = MT_CLS_NSMU,
2068 MT_USB_DEVICE(USB_VENDOR_ID_WISTRON,
2069 USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH) },
2070
ice chienbc8a2a92011-07-15 16:58:06 +08002071 /* XAT */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002072 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002073 MT_USB_DEVICE(USB_VENDOR_ID_XAT,
ice chienbc8a2a92011-07-15 16:58:06 +08002074 USB_DEVICE_ID_XAT_CSR) },
Benjamin Tissoires617b64f2011-05-19 14:18:17 +02002075
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002076 /* Xiroku */
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002077 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002078 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002079 USB_DEVICE_ID_XIROKU_SPX) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002080 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002081 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002082 USB_DEVICE_ID_XIROKU_MPX) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002083 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002084 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002085 USB_DEVICE_ID_XIROKU_CSR) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002086 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002087 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002088 USB_DEVICE_ID_XIROKU_SPX1) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002089 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002090 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002091 USB_DEVICE_ID_XIROKU_MPX1) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002092 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002093 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002094 USB_DEVICE_ID_XIROKU_CSR1) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002095 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002096 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002097 USB_DEVICE_ID_XIROKU_SPX2) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002098 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002099 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002100 USB_DEVICE_ID_XIROKU_MPX2) },
Benjamin Tissoiresdc3e1d82013-01-31 17:22:31 +01002101 { .driver_data = MT_CLS_NSMU,
Henrik Rydberg2c2110e2012-05-04 15:32:04 +02002102 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
Masatoshi Hoshikawa11576c62012-01-05 11:53:46 +09002103 USB_DEVICE_ID_XIROKU_CSR2) },
2104
Wei-Ning Huang0e822322017-06-21 10:43:25 +08002105 /* Google MT devices */
2106 { .driver_data = MT_CLS_GOOGLE,
2107 HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_GOOGLE,
2108 USB_DEVICE_ID_GOOGLE_TOUCH_ROSE) },
2109
Henrik Rydberg4fa3a5832012-05-01 08:40:01 +02002110 /* Generic MT device */
2111 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
Benjamin Tissoiresf961bd32013-08-22 14:51:08 +02002112
2113 /* Generic Win 8 certified MT device */
2114 { .driver_data = MT_CLS_WIN_8,
2115 HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8,
2116 HID_ANY_ID, HID_ANY_ID) },
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01002117 { }
2118};
2119MODULE_DEVICE_TABLE(hid, mt_devices);
2120
2121static const struct hid_usage_id mt_grabbed_usages[] = {
2122 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
2123 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
2124};
2125
2126static struct hid_driver mt_driver = {
2127 .name = "hid-multitouch",
2128 .id_table = mt_devices,
2129 .probe = mt_probe,
2130 .remove = mt_remove,
2131 .input_mapping = mt_input_mapping,
2132 .input_mapped = mt_input_mapped,
Henrik Rydberg76f59022012-09-01 20:11:34 +02002133 .input_configured = mt_input_configured,
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01002134 .feature_mapping = mt_feature_mapping,
2135 .usage_table = mt_grabbed_usages,
2136 .event = mt_event,
Benjamin Tissoires55978fa2013-01-31 17:22:24 +01002137 .report = mt_report,
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01002138#ifdef CONFIG_PM
2139 .reset_resume = mt_reset_resume,
Scott Liudfeefd12012-08-15 17:21:55 +08002140 .resume = mt_resume,
Benjamin Tissoires5519cab2011-01-07 23:45:50 +01002141#endif
2142};
H Hartley Sweetenf4254582012-12-17 15:28:26 -07002143module_hid_driver(mt_driver);