]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/hid/hid-multitouch.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
HID: multitouch: add support for eGalax 0x722a
[mirror_ubuntu-bionic-kernel.git] / drivers / hid / hid-multitouch.c
CommitLineData
5519cab4
BT		 1/*
2 * HID driver for multitouch panels
3 *
c2ef8f21
BT		 4 * Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
5 * Copyright (c) 2010-2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
6 * Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
5519cab4 7 *
4875ac11
RN		 8 * This code is partly based on hid-egalax.c:
9 *
10 * Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
11 * Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
12 * Copyright (c) 2010 Canonical, Ltd.
13 *
f786bba4
BT		 14 * This code is partly based on hid-3m-pct.c:
15 *
16 * Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
17 * Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
18 * Copyright (c) 2010 Canonical, Ltd.
19 *
5519cab4
BT		 20 */
21
22/*
23 * This program is free software; you can redistribute it and/or modify it
24 * under the terms of the GNU General Public License as published by the Free
25 * Software Foundation; either version 2 of the License, or (at your option)
26 * any later version.
27 */
28
29#include <linux/device.h>
30#include <linux/hid.h>
31#include <linux/module.h>
32#include <linux/slab.h>
33#include <linux/usb.h>
34#include <linux/input/mt.h>
35#include "usbhid/usbhid.h"
36
37
38MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
ef2fafb3 39MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
5519cab4
BT		 40MODULE_DESCRIPTION("HID multitouch panels");
41MODULE_LICENSE("GPL");
42
43#include "hid-ids.h"
44
45/* quirks to control the device */
46#define MT_QUIRK_NOT_SEEN_MEANS_UP (1 << 0)
47#define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1)
2d93666e 48#define MT_QUIRK_CYPRESS (1 << 2)
5572da08 49#define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3)
a062cc5a
SC		 50#define MT_QUIRK_ALWAYS_VALID (1 << 4)
51#define MT_QUIRK_VALID_IS_INRANGE (1 << 5)
52#define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 6)
a062cc5a 53#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 8)
5519cab4
BT		 54
55struct mt_slot {
56 __s32 x, y, p, w, h;
57 __s32 contactid; /* the device ContactID assigned to this slot */
58 bool touch_state; /* is the touch valid? */
59 bool seen_in_this_frame;/* has this slot been updated */
60};
61
eec29e3d
BT		 62struct mt_class {
63 __s32 name; /* MT_CLS */
64 __s32 quirks;
65 __s32 sn_move; /* Signal/noise ratio for move events */
66 __s32 sn_width; /* Signal/noise ratio for width events */
67 __s32 sn_height; /* Signal/noise ratio for height events */
68 __s32 sn_pressure; /* Signal/noise ratio for pressure events */
69 __u8 maxcontacts;
c2ef8f21 70 bool is_indirect; /* true for touchpads */
eec29e3d
BT		 71};
72
5519cab4
BT		 73struct mt_device {
74 struct mt_slot curdata; /* placeholder of incoming data */
eec29e3d 75 struct mt_class mtclass; /* our mt device class */
5519cab4
BT		 76 unsigned last_field_index; /* last field index of the report */
77 unsigned last_slot_field; /* the last field of a slot */
b84bd27f 78 int last_mt_collection; /* last known mt-related collection */
5519cab4 79 __s8 inputmode; /* InputMode HID feature, -1 if non-existent */
31ae9bdd
BT		 80 __s8 maxcontact_report_id; /* Maximum Contact Number HID feature,
81 -1 if non-existent */
5519cab4
BT		 82 __u8 num_received; /* how many contacts we received */
83 __u8 num_expected; /* expected last contact index */
9498f954 84 __u8 maxcontacts;
5519cab4 85 bool curvalid; /* is the current contact valid? */
9498f954 86 struct mt_slot *slots;
5519cab4
BT		 87};
88
5519cab4 89/* classes of device behavior */
22408283
BT		 90#define MT_CLS_DEFAULT 0x0001
91
a062cc5a
SC		 92#define MT_CLS_SERIAL 0x0002
93#define MT_CLS_CONFIDENCE 0x0003
5e7ea11f
BT		 94#define MT_CLS_CONFIDENCE_CONTACT_ID 0x0004
95#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0005
96#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0006
97#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0007
98#define MT_CLS_DUAL_NSMU_CONTACTID 0x0008
b7ea95ff 99#define MT_CLS_INRANGE_CONTACTNUMBER 0x0009
22408283
BT		 100
101/* vendor specific classes */
102#define MT_CLS_3M 0x0101
103#define MT_CLS_CYPRESS 0x0102
104#define MT_CLS_EGALAX 0x0103
1b723e8d 105#define MT_CLS_EGALAX_SERIAL 0x0104
847672cd 106#define MT_CLS_TOPSEED 0x0105
2258e863 107#define MT_CLS_PANASONIC 0x0106
5519cab4 108
9498f954
BT		 109#define MT_DEFAULT_MAXCONTACT 10
110
5519cab4
BT		 111/*
112 * these device-dependent functions determine what slot corresponds
113 * to a valid contact that was just read.
114 */
115
a3b5e577
BT		 116static int cypress_compute_slot(struct mt_device *td)
117{
118 if (td->curdata.contactid != 0 || td->num_received == 0)
119 return td->curdata.contactid;
120 else
121 return -1;
122}
123
5519cab4
BT		 124static int find_slot_from_contactid(struct mt_device *td)
125{
126 int i;
9498f954 127 for (i = 0; i < td->maxcontacts; ++i) {
5519cab4
BT		 128 if (td->slots[i].contactid == td->curdata.contactid &&
129 td->slots[i].touch_state)
130 return i;
131 }
9498f954 132 for (i = 0; i < td->maxcontacts; ++i) {
5519cab4
BT		 133 if (!td->slots[i].seen_in_this_frame &&
134 !td->slots[i].touch_state)
135 return i;
136 }
5519cab4
BT		 137 /* should not occurs. If this happens that means
138 * that the device sent more touches that it says
139 * in the report descriptor. It is ignored then. */
2d93666e 140 return -1;
5519cab4
BT		 141}
142
b3c21d2c 143static struct mt_class mt_classes[] = {
2d93666e 144 { .name = MT_CLS_DEFAULT,
9498f954 145 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
a062cc5a
SC		 146 { .name = MT_CLS_SERIAL,
147 .quirks = MT_QUIRK_ALWAYS_VALID},
22408283
BT		 148 { .name = MT_CLS_CONFIDENCE,
149 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
5e7ea11f
BT		 150 { .name = MT_CLS_CONFIDENCE_CONTACT_ID,
151 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
152 MT_QUIRK_SLOT_IS_CONTACTID },
22408283
BT		 153 { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
154 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
155 MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
1e9cf35b 156 { .name = MT_CLS_DUAL_INRANGE_CONTACTID,
2d93666e
BT		 157 .quirks = MT_QUIRK_VALID_IS_INRANGE |
158 MT_QUIRK_SLOT_IS_CONTACTID,
159 .maxcontacts = 2 },
1e9cf35b 160 { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
2d93666e
BT		 161 .quirks = MT_QUIRK_VALID_IS_INRANGE |
162 MT_QUIRK_SLOT_IS_CONTACTNUMBER,
163 .maxcontacts = 2 },
22408283
BT		 164 { .name = MT_CLS_DUAL_NSMU_CONTACTID,
165 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
166 MT_QUIRK_SLOT_IS_CONTACTID,
167 .maxcontacts = 2 },
b7ea95ff
AT		 168 { .name = MT_CLS_INRANGE_CONTACTNUMBER,
169 .quirks = MT_QUIRK_VALID_IS_INRANGE |
170 MT_QUIRK_SLOT_IS_CONTACTNUMBER },
22408283
BT		 171
172 /*
173 * vendor specific classes
174 */
175 { .name = MT_CLS_3M,
176 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
177 MT_QUIRK_SLOT_IS_CONTACTID,
178 .sn_move = 2048,
179 .sn_width = 128,
180 .sn_height = 128 },
2d93666e
BT		 181 { .name = MT_CLS_CYPRESS,
182 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
183 MT_QUIRK_CYPRESS,
184 .maxcontacts = 10 },
4875ac11
RN		 185 { .name = MT_CLS_EGALAX,
186 .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
2261bb9f 187 MT_QUIRK_VALID_IS_INRANGE,
4875ac11
RN		 188 .sn_move = 4096,
189 .sn_pressure = 32,
190 },
1b723e8d
BT		 191 { .name = MT_CLS_EGALAX_SERIAL,
192 .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
193 MT_QUIRK_ALWAYS_VALID,
4875ac11
RN		 194 .sn_move = 4096,
195 .sn_pressure = 32,
196 },
847672cd
BT		 197 { .name = MT_CLS_TOPSEED,
198 .quirks = MT_QUIRK_ALWAYS_VALID,
199 .is_indirect = true,
200 .maxcontacts = 2,
201 },
2258e863
DK		 202 { .name = MT_CLS_PANASONIC,
203 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
204 .maxcontacts = 4 },
043b403a 205
2d93666e 206 { }
5519cab4
BT		 207};
208
eec29e3d
BT		 209static ssize_t mt_show_quirks(struct device *dev,
210 struct device_attribute *attr,
211 char *buf)
212{
213 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
214 struct mt_device *td = hid_get_drvdata(hdev);
215
216 return sprintf(buf, "%u\n", td->mtclass.quirks);
217}
218
219static ssize_t mt_set_quirks(struct device *dev,
220 struct device_attribute *attr,
221 const char *buf, size_t count)
222{
223 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
224 struct mt_device *td = hid_get_drvdata(hdev);
225
226 unsigned long val;
227
228 if (kstrtoul(buf, 0, &val))
229 return -EINVAL;
230
231 td->mtclass.quirks = val;
232
233 return count;
234}
235
236static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
237
238static struct attribute *sysfs_attrs[] = {
239 &dev_attr_quirks.attr,
240 NULL
241};
242
243static struct attribute_group mt_attribute_group = {
244 .attrs = sysfs_attrs
245};
246
f635bd11 247static void mt_feature_mapping(struct hid_device *hdev,
5519cab4
BT		 248 struct hid_field *field, struct hid_usage *usage)
249{
9498f954
BT		 250 struct mt_device *td = hid_get_drvdata(hdev);
251
252 switch (usage->hid) {
253 case HID_DG_INPUTMODE:
5519cab4 254 td->inputmode = field->report->id;
9498f954
BT		 255 break;
256 case HID_DG_CONTACTMAX:
31ae9bdd 257 td->maxcontact_report_id = field->report->id;
9498f954 258 td->maxcontacts = field->value[0];
eec29e3d 259 if (td->mtclass.maxcontacts)
9498f954 260 /* check if the maxcontacts is given by the class */
eec29e3d 261 td->maxcontacts = td->mtclass.maxcontacts;
9498f954
BT		 262
263 break;
5519cab4
BT		 264 }
265}
266
267static void set_abs(struct input_dev *input, unsigned int code,
268 struct hid_field *field, int snratio)
269{
270 int fmin = field->logical_minimum;
271 int fmax = field->logical_maximum;
272 int fuzz = snratio ? (fmax - fmin) / snratio : 0;
273 input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
274}
275
276static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
277 struct hid_field *field, struct hid_usage *usage,
278 unsigned long **bit, int *max)
279{
280 struct mt_device *td = hid_get_drvdata(hdev);
eec29e3d 281 struct mt_class *cls = &td->mtclass;
c2ef8f21 282 int code;
4875ac11 283
658d4aed 284 /* Only map fields from TouchScreen or TouchPad collections.
2258e863
DK		 285 * We need to ignore fields that belong to other collections
286 * such as Mouse that might have the same GenericDesktop usages. */
658d4aed
JB		 287 if (field->application == HID_DG_TOUCHSCREEN)
288 set_bit(INPUT_PROP_DIRECT, hi->input->propbit);
c2ef8f21 289 else if (field->application != HID_DG_TOUCHPAD)
658d4aed
JB		 290 return 0;
291
c2ef8f21
BT		 292 /* In case of an indirect device (touchpad), we need to add
293 * specific BTN_TOOL_* to be handled by the synaptics xorg
294 * driver.
295 * We also consider that touchscreens providing buttons are touchpads.
296 */
297 if (field->application == HID_DG_TOUCHPAD ||
298 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON ||
299 cls->is_indirect) {
300 set_bit(INPUT_PROP_POINTER, hi->input->propbit);
301 set_bit(BTN_TOOL_FINGER, hi->input->keybit);
302 set_bit(BTN_TOOL_DOUBLETAP, hi->input->keybit);
303 set_bit(BTN_TOOL_TRIPLETAP, hi->input->keybit);
304 set_bit(BTN_TOOL_QUADTAP, hi->input->keybit);
305 }
306
2261bb9f
BT		 307 /* eGalax devices provide a Digitizer.Stylus input which overrides
308 * the correct Digitizers.Finger X/Y ranges.
309 * Let's just ignore this input. */
310 if (field->physical == HID_DG_STYLUS)
311 return -1;
312
5519cab4
BT		 313 switch (usage->hid & HID_USAGE_PAGE) {
314
315 case HID_UP_GENDESK:
316 switch (usage->hid) {
317 case HID_GD_X:
318 hid_map_usage(hi, usage, bit, max,
319 EV_ABS, ABS_MT_POSITION_X);
320 set_abs(hi->input, ABS_MT_POSITION_X, field,
321 cls->sn_move);
322 /* touchscreen emulation */
323 set_abs(hi->input, ABS_X, field, cls->sn_move);
b84bd27f
BT		 324 if (td->last_mt_collection == usage->collection_index) {
325 td->last_slot_field = usage->hid;
326 td->last_field_index = field->index;
327 }
5519cab4
BT		 328 return 1;
329 case HID_GD_Y:
330 hid_map_usage(hi, usage, bit, max,
331 EV_ABS, ABS_MT_POSITION_Y);
332 set_abs(hi->input, ABS_MT_POSITION_Y, field,
333 cls->sn_move);
334 /* touchscreen emulation */
335 set_abs(hi->input, ABS_Y, field, cls->sn_move);
b84bd27f
BT		 336 if (td->last_mt_collection == usage->collection_index) {
337 td->last_slot_field = usage->hid;
338 td->last_field_index = field->index;
339 }
5519cab4
BT		 340 return 1;
341 }
342 return 0;
343
344 case HID_UP_DIGITIZER:
345 switch (usage->hid) {
346 case HID_DG_INRANGE:
b84bd27f
BT		 347 if (td->last_mt_collection == usage->collection_index) {
348 td->last_slot_field = usage->hid;
349 td->last_field_index = field->index;
350 }
5519cab4
BT		 351 return 1;
352 case HID_DG_CONFIDENCE:
b84bd27f
BT		 353 if (td->last_mt_collection == usage->collection_index) {
354 td->last_slot_field = usage->hid;
355 td->last_field_index = field->index;
356 }
5519cab4
BT		 357 return 1;
358 case HID_DG_TIPSWITCH:
359 hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
360 input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
b84bd27f
BT		 361 if (td->last_mt_collection == usage->collection_index) {
362 td->last_slot_field = usage->hid;
363 td->last_field_index = field->index;
364 }
5519cab4
BT		 365 return 1;
366 case HID_DG_CONTACTID:
50bc03ab
BT		 367 if (!td->maxcontacts)
368 td->maxcontacts = MT_DEFAULT_MAXCONTACT;
9498f954 369 input_mt_init_slots(hi->input, td->maxcontacts);
5519cab4 370 td->last_slot_field = usage->hid;
2955caed 371 td->last_field_index = field->index;
b84bd27f 372 td->last_mt_collection = usage->collection_index;
5519cab4
BT		 373 return 1;
374 case HID_DG_WIDTH:
375 hid_map_usage(hi, usage, bit, max,
376 EV_ABS, ABS_MT_TOUCH_MAJOR);
f786bba4
BT		 377 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
378 cls->sn_width);
b84bd27f
BT		 379 if (td->last_mt_collection == usage->collection_index) {
380 td->last_slot_field = usage->hid;
381 td->last_field_index = field->index;
382 }
5519cab4
BT		 383 return 1;
384 case HID_DG_HEIGHT:
385 hid_map_usage(hi, usage, bit, max,
386 EV_ABS, ABS_MT_TOUCH_MINOR);
f786bba4
BT		 387 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
388 cls->sn_height);
1e648a13
BT		 389 input_set_abs_params(hi->input,
390 ABS_MT_ORIENTATION, 0, 1, 0, 0);
b84bd27f
BT		 391 if (td->last_mt_collection == usage->collection_index) {
392 td->last_slot_field = usage->hid;
393 td->last_field_index = field->index;
394 }
5519cab4
BT		 395 return 1;
396 case HID_DG_TIPPRESSURE:
397 hid_map_usage(hi, usage, bit, max,
398 EV_ABS, ABS_MT_PRESSURE);
399 set_abs(hi->input, ABS_MT_PRESSURE, field,
400 cls->sn_pressure);
401 /* touchscreen emulation */
402 set_abs(hi->input, ABS_PRESSURE, field,
403 cls->sn_pressure);
b84bd27f
BT		 404 if (td->last_mt_collection == usage->collection_index) {
405 td->last_slot_field = usage->hid;
406 td->last_field_index = field->index;
407 }
5519cab4
BT		 408 return 1;
409 case HID_DG_CONTACTCOUNT:
b84bd27f
BT		 410 if (td->last_mt_collection == usage->collection_index)
411 td->last_field_index = field->index;
5519cab4
BT		 412 return 1;
413 case HID_DG_CONTACTMAX:
414 /* we don't set td->last_slot_field as contactcount and
415 * contact max are global to the report */
b84bd27f
BT		 416 if (td->last_mt_collection == usage->collection_index)
417 td->last_field_index = field->index;
5519cab4
BT		 418 return -1;
419 }
c2ef8f21
BT		 420 case HID_DG_TOUCH:
421 /* Legacy devices use TIPSWITCH and not TOUCH.
422 * Let's just ignore this field. */
423 return -1;
5519cab4
BT		 424 /* let hid-input decide for the others */
425 return 0;
426
c2ef8f21
BT		 427 case HID_UP_BUTTON:
428 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
429 hid_map_usage(hi, usage, bit, max, EV_KEY, code);
430 input_set_capability(hi->input, EV_KEY, code);
431 return 1;
432
5519cab4
BT		 433 case 0xff000000:
434 /* we do not want to map these: no input-oriented meaning */
435 return -1;
436 }
437
438 return 0;
439}
440
441static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
442 struct hid_field *field, struct hid_usage *usage,
443 unsigned long **bit, int *max)
444{
445 if (usage->type == EV_KEY || usage->type == EV_ABS)
446 set_bit(usage->type, hi->input->evbit);
447
448 return -1;
449}
450
451static int mt_compute_slot(struct mt_device *td)
452{
eec29e3d 453 __s32 quirks = td->mtclass.quirks;
5519cab4 454
2d93666e
BT		 455 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
456 return td->curdata.contactid;
5519cab4 457
2d93666e 458 if (quirks & MT_QUIRK_CYPRESS)
a3b5e577
BT		 459 return cypress_compute_slot(td);
460
2d93666e
BT		 461 if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
462 return td->num_received;
5572da08 463
4a6ee685
BT		 464 if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
465 return td->curdata.contactid - 1;
466
5519cab4
BT		 467 return find_slot_from_contactid(td);
468}
469
470/*
471 * this function is called when a whole contact has been processed,
472 * so that it can assign it to a slot and store the data there
473 */
474static void mt_complete_slot(struct mt_device *td)
475{
2d93666e 476 td->curdata.seen_in_this_frame = true;
5519cab4 477 if (td->curvalid) {
5519cab4
BT		 478 int slotnum = mt_compute_slot(td);
479
9498f954 480 if (slotnum >= 0 && slotnum < td->maxcontacts)
2d93666e 481 td->slots[slotnum] = td->curdata;
5519cab4
BT		 482 }
483 td->num_received++;
484}
485
486
487/*
488 * this function is called when a whole packet has been received and processed,
489 * so that it can decide what to send to the input layer.
490 */
491static void mt_emit_event(struct mt_device *td, struct input_dev *input)
492{
493 int i;
494
9498f954 495 for (i = 0; i < td->maxcontacts; ++i) {
5519cab4 496 struct mt_slot *s = &(td->slots[i]);
eec29e3d 497 if ((td->mtclass.quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
5519cab4 498 !s->seen_in_this_frame) {
5519cab4
BT		 499 s->touch_state = false;
500 }
501
502 input_mt_slot(input, i);
503 input_mt_report_slot_state(input, MT_TOOL_FINGER,
504 s->touch_state);
2d93666e 505 if (s->touch_state) {
f786bba4
BT		 506 /* this finger is on the screen */
507 int wide = (s->w > s->h);
508 /* divided by two to match visual scale of touch */
509 int major = max(s->w, s->h) >> 1;
510 int minor = min(s->w, s->h) >> 1;
511
2d93666e
BT		 512 input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
513 input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
f786bba4 514 input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
2d93666e 515 input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
f786bba4
BT		 516 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
517 input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
2d93666e 518 }
5519cab4
BT		 519 s->seen_in_this_frame = false;
520
521 }
522
523 input_mt_report_pointer_emulation(input, true);
524 input_sync(input);
525 td->num_received = 0;
526}
527
528
529
530static int mt_event(struct hid_device *hid, struct hid_field *field,
531 struct hid_usage *usage, __s32 value)
532{
533 struct mt_device *td = hid_get_drvdata(hid);
eec29e3d 534 __s32 quirks = td->mtclass.quirks;
5519cab4 535
9498f954 536 if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
5519cab4
BT		 537 switch (usage->hid) {
538 case HID_DG_INRANGE:
a062cc5a
SC		 539 if (quirks & MT_QUIRK_ALWAYS_VALID)
540 td->curvalid = true;
541 else if (quirks & MT_QUIRK_VALID_IS_INRANGE)
2d93666e 542 td->curvalid = value;
5519cab4
BT		 543 break;
544 case HID_DG_TIPSWITCH:
2d93666e
BT		 545 if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
546 td->curvalid = value;
5519cab4
BT		 547 td->curdata.touch_state = value;
548 break;
549 case HID_DG_CONFIDENCE:
2d93666e
BT		 550 if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
551 td->curvalid = value;
5519cab4
BT		 552 break;
553 case HID_DG_CONTACTID:
554 td->curdata.contactid = value;
555 break;
556 case HID_DG_TIPPRESSURE:
557 td->curdata.p = value;
558 break;
559 case HID_GD_X:
560 td->curdata.x = value;
561 break;
562 case HID_GD_Y:
563 td->curdata.y = value;
564 break;
565 case HID_DG_WIDTH:
566 td->curdata.w = value;
567 break;
568 case HID_DG_HEIGHT:
569 td->curdata.h = value;
570 break;
571 case HID_DG_CONTACTCOUNT:
572 /*
2d93666e
BT		 573 * Includes multi-packet support where subsequent
574 * packets are sent with zero contactcount.
5519cab4
BT		 575 */
576 if (value)
2d93666e 577 td->num_expected = value;
5519cab4 578 break;
c2ef8f21
BT		 579 case HID_DG_TOUCH:
580 /* do nothing */
581 break;
5519cab4
BT		 582
583 default:
584 /* fallback to the generic hidinput handling */
585 return 0;
586 }
5519cab4 587
2258e863 588 if (usage->hid == td->last_slot_field)
2d93666e
BT		 589 mt_complete_slot(td);
590
591 if (field->index == td->last_field_index
592 && td->num_received >= td->num_expected)
593 mt_emit_event(td, field->hidinput->input);
5519cab4 594
2d93666e 595 }
5519cab4
BT		 596
597 /* we have handled the hidinput part, now remains hiddev */
598 if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
599 hid->hiddev_hid_event(hid, field, usage, value);
600
601 return 1;
602}
603
604static void mt_set_input_mode(struct hid_device *hdev)
605{
606 struct mt_device *td = hid_get_drvdata(hdev);
607 struct hid_report *r;
608 struct hid_report_enum *re;
609
610 if (td->inputmode < 0)
611 return;
612
613 re = &(hdev->report_enum[HID_FEATURE_REPORT]);
614 r = re->report_id_hash[td->inputmode];
615 if (r) {
616 r->field[0]->value[0] = 0x02;
617 usbhid_submit_report(hdev, r, USB_DIR_OUT);
618 }
619}
620
31ae9bdd
BT		 621static void mt_set_maxcontacts(struct hid_device *hdev)
622{
623 struct mt_device *td = hid_get_drvdata(hdev);
624 struct hid_report *r;
625 struct hid_report_enum *re;
626 int fieldmax, max;
627
628 if (td->maxcontact_report_id < 0)
629 return;
630
631 if (!td->mtclass.maxcontacts)
632 return;
633
634 re = &hdev->report_enum[HID_FEATURE_REPORT];
635 r = re->report_id_hash[td->maxcontact_report_id];
636 if (r) {
637 max = td->mtclass.maxcontacts;
638 fieldmax = r->field[0]->logical_maximum;
639 max = min(fieldmax, max);
640 if (r->field[0]->value[0] != max) {
641 r->field[0]->value[0] = max;
642 usbhid_submit_report(hdev, r, USB_DIR_OUT);
643 }
644 }
645}
646
5519cab4
BT		 647static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
648{
2d93666e 649 int ret, i;
5519cab4 650 struct mt_device *td;
2d93666e
BT		 651 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
652
653 for (i = 0; mt_classes[i].name ; i++) {
654 if (id->driver_data == mt_classes[i].name) {
655 mtclass = &(mt_classes[i]);
656 break;
657 }
658 }
5519cab4 659
d682bd7f
HR		 660 /* This allows the driver to correctly support devices
661 * that emit events over several HID messages.
662 */
663 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
5519cab4 664
9498f954 665 td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
5519cab4
BT		 666 if (!td) {
667 dev_err(&hdev->dev, "cannot allocate multitouch data\n");
668 return -ENOMEM;
669 }
eec29e3d 670 td->mtclass = *mtclass;
5519cab4 671 td->inputmode = -1;
31ae9bdd 672 td->maxcontact_report_id = -1;
b84bd27f 673 td->last_mt_collection = -1;
5519cab4
BT		 674 hid_set_drvdata(hdev, td);
675
676 ret = hid_parse(hdev);
677 if (ret != 0)
678 goto fail;
679
680 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
2d93666e 681 if (ret)
5519cab4
BT		 682 goto fail;
683
9498f954
BT		 684 td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
685 GFP_KERNEL);
686 if (!td->slots) {
687 dev_err(&hdev->dev, "cannot allocate multitouch slots\n");
688 hid_hw_stop(hdev);
689 ret = -ENOMEM;
690 goto fail;
691 }
692
eec29e3d
BT		 693 ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
694
31ae9bdd 695 mt_set_maxcontacts(hdev);
5519cab4
BT		 696 mt_set_input_mode(hdev);
697
698 return 0;
699
700fail:
701 kfree(td);
702 return ret;
703}
704
705#ifdef CONFIG_PM
706static int mt_reset_resume(struct hid_device *hdev)
707{
31ae9bdd 708 mt_set_maxcontacts(hdev);
5519cab4
BT		 709 mt_set_input_mode(hdev);
710 return 0;
711}
712#endif
713
714static void mt_remove(struct hid_device *hdev)
715{
716 struct mt_device *td = hid_get_drvdata(hdev);
eec29e3d 717 sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
5519cab4 718 hid_hw_stop(hdev);
9498f954 719 kfree(td->slots);
5519cab4
BT		 720 kfree(td);
721 hid_set_drvdata(hdev, NULL);
722}
723
724static const struct hid_device_id mt_devices[] = {
725
f786bba4
BT		 726 /* 3M panels */
727 { .driver_data = MT_CLS_3M,
728 HID_USB_DEVICE(USB_VENDOR_ID_3M,
729 USB_DEVICE_ID_3M1968) },
730 { .driver_data = MT_CLS_3M,
731 HID_USB_DEVICE(USB_VENDOR_ID_3M,
732 USB_DEVICE_ID_3M2256) },
c4fad877
BT		 733 { .driver_data = MT_CLS_3M,
734 HID_USB_DEVICE(USB_VENDOR_ID_3M,
735 USB_DEVICE_ID_3M3266) },
f786bba4 736
e6aac342
BT		 737 /* ActionStar panels */
738 { .driver_data = MT_CLS_DEFAULT,
739 HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
740 USB_DEVICE_ID_ACTIONSTAR_1011) },
741
b1057124
BT		 742 /* Atmel panels */
743 { .driver_data = MT_CLS_SERIAL,
744 HID_USB_DEVICE(USB_VENDOR_ID_ATMEL,
745 USB_DEVICE_ID_ATMEL_MULTITOUCH) },
841cb157
BT		 746 { .driver_data = MT_CLS_SERIAL,
747 HID_USB_DEVICE(USB_VENDOR_ID_ATMEL,
748 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
b1057124 749
a841b62c
BT		 750 /* Cando panels */
751 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
752 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
753 USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
754 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
755 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
756 USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
757 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
758 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
759 USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
760 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
761 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
762 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
763
942fd422
AZ		 764 /* Chunghwa Telecom touch panels */
765 { .driver_data = MT_CLS_DEFAULT,
766 HID_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
767 USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
768
79603dc9
BT		 769 /* CVTouch panels */
770 { .driver_data = MT_CLS_DEFAULT,
771 HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
772 USB_DEVICE_ID_CVTOUCH_SCREEN) },
773
a3b5e577
BT		 774 /* Cypress panel */
775 { .driver_data = MT_CLS_CYPRESS,
776 HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
777 USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
778
22408283 779 /* eGalax devices (resistive) */
e36f690b 780 { .driver_data = MT_CLS_EGALAX,
22408283 781 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b
BT		 782 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
783 { .driver_data = MT_CLS_EGALAX,
22408283 784 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b 785 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
22408283
BT		 786
787 /* eGalax devices (capacitive) */
e36f690b 788 { .driver_data = MT_CLS_EGALAX,
22408283 789 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b 790 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
fd1d1525
BT		 791 { .driver_data = MT_CLS_EGALAX_SERIAL,
792 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
793 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
794 { .driver_data = MT_CLS_EGALAX_SERIAL,
795 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
796 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
797 { .driver_data = MT_CLS_EGALAX_SERIAL,
798 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
799 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
2ce09df4
BT		 800 { .driver_data = MT_CLS_EGALAX_SERIAL,
801 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
802 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
e36f690b 803 { .driver_data = MT_CLS_EGALAX,
22408283 804 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b 805 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
fd1d1525
BT		 806 { .driver_data = MT_CLS_EGALAX_SERIAL,
807 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
808 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
e36f690b 809 { .driver_data = MT_CLS_EGALAX,
22408283 810 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b 811 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
fd1d1525
BT		 812 { .driver_data = MT_CLS_EGALAX_SERIAL,
813 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
814 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
66f06127
BT		 815 { .driver_data = MT_CLS_EGALAX,
816 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
817 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
bb9ff210
MV		 818 { .driver_data = MT_CLS_EGALAX,
819 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
820 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
fd1d1525
BT		 821 { .driver_data = MT_CLS_EGALAX_SERIAL,
822 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
823 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
1b723e8d 824 { .driver_data = MT_CLS_EGALAX_SERIAL,
1fd8f047 825 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
e36f690b 826 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
22408283 827
c04abeef
BT		 828 /* Elo TouchSystems IntelliTouch Plus panel */
829 { .driver_data = MT_CLS_DUAL_NSMU_CONTACTID,
830 HID_USB_DEVICE(USB_VENDOR_ID_ELO,
831 USB_DEVICE_ID_ELO_TS2515) },
832
5572da08 833 /* GeneralTouch panel */
1e9cf35b 834 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
5572da08
BT		 835 HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
836 USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
837
ee0fbd14
BT		 838 /* GoodTouch panels */
839 { .driver_data = MT_CLS_DEFAULT,
840 HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
841 USB_DEVICE_ID_GOODTOUCH_000f) },
842
54580365
BT		 843 /* Hanvon panels */
844 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
845 HID_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
846 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
847
a062cc5a
SC		 848 /* Ideacom panel */
849 { .driver_data = MT_CLS_SERIAL,
850 HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
851 USB_DEVICE_ID_IDEACOM_IDC6650) },
71078b0d
BT		 852 { .driver_data = MT_CLS_SERIAL,
853 HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
854 USB_DEVICE_ID_IDEACOM_IDC6651) },
a062cc5a 855
4e61f0d7
AZ		 856 /* Ilitek dual touch panel */
857 { .driver_data = MT_CLS_DEFAULT,
858 HID_USB_DEVICE(USB_VENDOR_ID_ILITEK,
859 USB_DEVICE_ID_ILITEK_MULTITOUCH) },
860
4dfcced8
BT		 861 /* IRTOUCH panels */
862 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
863 HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
864 USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
865
c50bb1a4
JB		 866 /* LG Display panels */
867 { .driver_data = MT_CLS_DEFAULT,
868 HID_USB_DEVICE(USB_VENDOR_ID_LG,
869 USB_DEVICE_ID_LG_MULTITOUCH) },
870
df167c4a
BT		 871 /* Lumio panels */
872 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
873 HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
874 USB_DEVICE_ID_CRYSTALTOUCH) },
c3ead6de
BT		 875 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
876 HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
877 USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
df167c4a 878
4a6ee685
BT		 879 /* MosArt panels */
880 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
881 HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
882 USB_DEVICE_ID_ASUS_T91MT)},
883 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
884 HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
885 USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
886 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
887 HID_USB_DEVICE(USB_VENDOR_ID_TURBOX,
888 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
889
2258e863
DK		 890 /* Panasonic panels */
891 { .driver_data = MT_CLS_PANASONIC,
892 HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
893 USB_DEVICE_ID_PANABOARD_UBT780) },
894 { .driver_data = MT_CLS_PANASONIC,
895 HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
896 USB_DEVICE_ID_PANABOARD_UBT880) },
897
6ab3a9a6
JS		 898 /* PenMount panels */
899 { .driver_data = MT_CLS_CONFIDENCE,
900 HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
901 USB_DEVICE_ID_PENMOUNT_PCI) },
902
b7ea95ff
AT		 903 /* PixArt optical touch screen */
904 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
905 HID_USB_DEVICE(USB_VENDOR_ID_PIXART,
906 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
907 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
908 HID_USB_DEVICE(USB_VENDOR_ID_PIXART,
909 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
910 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
911 HID_USB_DEVICE(USB_VENDOR_ID_PIXART,
912 USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
913
5519cab4 914 /* PixCir-based panels */
1e9cf35b 915 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
5519cab4
BT		 916 HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
917 USB_DEVICE_ID_HANVON_MULTITOUCH) },
1e9cf35b 918 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
5519cab4
BT		 919 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
920 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
921
5e7ea11f
BT		 922 /* Quanta-based panels */
923 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
924 HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
925 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
926 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
927 HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
928 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
929 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
930 HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
931 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) },
932
043b403a 933 /* Stantum panels */
bf5af9b5 934 { .driver_data = MT_CLS_CONFIDENCE,
043b403a
BT		 935 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
936 USB_DEVICE_ID_MTP)},
bf5af9b5 937 { .driver_data = MT_CLS_CONFIDENCE,
85a60082 938 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
043b403a 939 USB_DEVICE_ID_MTP_STM)},
bf5af9b5 940 { .driver_data = MT_CLS_CONFIDENCE,
85a60082 941 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX,
043b403a
BT		 942 USB_DEVICE_ID_MTP_SITRONIX)},
943
847672cd
BT		 944 /* TopSeed panels */
945 { .driver_data = MT_CLS_TOPSEED,
946 HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
947 USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },
948
5e74e56d
BT		 949 /* Touch International panels */
950 { .driver_data = MT_CLS_DEFAULT,
951 HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
952 USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
953
617b64f9
BT		 954 /* Unitec panels */
955 { .driver_data = MT_CLS_DEFAULT,
956 HID_USB_DEVICE(USB_VENDOR_ID_UNITEC,
957 USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
958 { .driver_data = MT_CLS_DEFAULT,
959 HID_USB_DEVICE(USB_VENDOR_ID_UNITEC,
960 USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
bc8a2a9b 961 /* XAT */
962 { .driver_data = MT_CLS_DEFAULT,
963 HID_USB_DEVICE(USB_VENDOR_ID_XAT,
964 USB_DEVICE_ID_XAT_CSR) },
617b64f9 965
11576c61
MH		 966 /* Xiroku */
967 { .driver_data = MT_CLS_DEFAULT,
968 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
969 USB_DEVICE_ID_XIROKU_SPX) },
970 { .driver_data = MT_CLS_DEFAULT,
971 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
972 USB_DEVICE_ID_XIROKU_MPX) },
973 { .driver_data = MT_CLS_DEFAULT,
974 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
975 USB_DEVICE_ID_XIROKU_CSR) },
976 { .driver_data = MT_CLS_DEFAULT,
977 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
978 USB_DEVICE_ID_XIROKU_SPX1) },
979 { .driver_data = MT_CLS_DEFAULT,
980 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
981 USB_DEVICE_ID_XIROKU_MPX1) },
982 { .driver_data = MT_CLS_DEFAULT,
983 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
984 USB_DEVICE_ID_XIROKU_CSR1) },
985 { .driver_data = MT_CLS_DEFAULT,
986 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
987 USB_DEVICE_ID_XIROKU_SPX2) },
988 { .driver_data = MT_CLS_DEFAULT,
989 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
990 USB_DEVICE_ID_XIROKU_MPX2) },
991 { .driver_data = MT_CLS_DEFAULT,
992 HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
993 USB_DEVICE_ID_XIROKU_CSR2) },
994
5519cab4
BT		 995 { }
996};
997MODULE_DEVICE_TABLE(hid, mt_devices);
998
999static const struct hid_usage_id mt_grabbed_usages[] = {
1000 { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
1001 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
1002};
1003
1004static struct hid_driver mt_driver = {
1005 .name = "hid-multitouch",
1006 .id_table = mt_devices,
1007 .probe = mt_probe,
1008 .remove = mt_remove,
1009 .input_mapping = mt_input_mapping,
1010 .input_mapped = mt_input_mapped,
1011 .feature_mapping = mt_feature_mapping,
1012 .usage_table = mt_grabbed_usages,
1013 .event = mt_event,
1014#ifdef CONFIG_PM
1015 .reset_resume = mt_reset_resume,
1016#endif
1017};
1018
1019static int __init mt_init(void)
1020{
1021 return hid_register_driver(&mt_driver);
1022}
1023
1024static void __exit mt_exit(void)
1025{
1026 hid_unregister_driver(&mt_driver);
1027}
1028
1029module_init(mt_init);
1030module_exit(mt_exit);
ubuntu-bionic-kernel mirror