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