← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-lowlatency/quantal-proposed

« back to all changes in this revision

Viewing changes to drivers/hid/hid-multitouch.c

  • Committer: Package Import Robot
  • Author(s): Andy Whitcroft, Andy Whitcroft
  • Date: 2012-06-21 09:16:38 UTC
  • Revision ID: package-import@ubuntu.com-20120621091638-gubhv4nox8xez1ct
Tags: 3.5.0-1.1
[ Andy Whitcroft]

* Rebuild lowlatency against Ubuntu-3.5.0-1.1
* All new configuration system to allow configuration deltas to be
  exposed via debian.lowlatency/config-delta

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/hid/hid-multitouch.c
1
1
/*
2
2
 *  HID driver for multitouch panels
3
3
 *
4
 
 *  Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
5
 
 *  Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
6
 
 *  Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
 
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
7
7
 *
8
8
 *  This code is partly based on hid-egalax.c:
9
9
 *
50
50
#define MT_QUIRK_ALWAYS_VALID           (1 << 4)
51
51
#define MT_QUIRK_VALID_IS_INRANGE       (1 << 5)
52
52
#define MT_QUIRK_VALID_IS_CONFIDENCE    (1 << 6)
53
 
#define MT_QUIRK_EGALAX_XYZ_FIXUP       (1 << 7)
54
53
#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE    (1 << 8)
55
54
 
56
55
struct mt_slot {
60
59
        bool seen_in_this_frame;/* has this slot been updated */
61
60
};
62
61
 
 
62
struct 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;
 
70
        bool is_indirect;       /* true for touchpads */
 
71
};
 
72
 
 
73
struct mt_fields {
 
74
        unsigned usages[HID_MAX_FIELDS];
 
75
        unsigned int length;
 
76
};
 
77
 
63
78
struct mt_device {
64
79
        struct mt_slot curdata; /* placeholder of incoming data */
65
 
        struct mt_class *mtclass;       /* our mt device class */
 
80
        struct mt_class mtclass;        /* our mt device class */
 
81
        struct mt_fields *fields;       /* temporary placeholder for storing the
 
82
                                           multitouch fields */
66
83
        unsigned last_field_index;      /* last field index of the report */
67
84
        unsigned last_slot_field;       /* the last field of a slot */
68
 
        int last_mt_collection; /* last known mt-related collection */
69
85
        __s8 inputmode;         /* InputMode HID feature, -1 if non-existent */
 
86
        __s8 maxcontact_report_id;      /* Maximum Contact Number HID feature,
 
87
                                   -1 if non-existent */
70
88
        __u8 num_received;      /* how many contacts we received */
71
89
        __u8 num_expected;      /* expected last contact index */
72
90
        __u8 maxcontacts;
 
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 */
73
94
        bool curvalid;          /* is the current contact valid? */
74
95
        struct mt_slot *slots;
75
96
};
76
97
 
77
 
struct mt_class {
78
 
        __s32 name;     /* MT_CLS */
79
 
        __s32 quirks;
80
 
        __s32 sn_move;  /* Signal/noise ratio for move events */
81
 
        __s32 sn_width; /* Signal/noise ratio for width events */
82
 
        __s32 sn_height;        /* Signal/noise ratio for height events */
83
 
        __s32 sn_pressure;      /* Signal/noise ratio for pressure events */
84
 
        __u8 maxcontacts;
85
 
};
86
 
 
87
98
/* classes of device behavior */
88
99
#define MT_CLS_DEFAULT                          0x0001
89
100
 
90
101
#define MT_CLS_SERIAL                           0x0002
91
102
#define MT_CLS_CONFIDENCE                       0x0003
92
 
#define MT_CLS_CONFIDENCE_MINUS_ONE             0x0004
93
 
#define MT_CLS_DUAL_INRANGE_CONTACTID           0x0005
94
 
#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER       0x0006
95
 
#define MT_CLS_DUAL_NSMU_CONTACTID              0x0007
 
103
#define MT_CLS_CONFIDENCE_CONTACT_ID            0x0004
 
104
#define MT_CLS_CONFIDENCE_MINUS_ONE             0x0005
 
105
#define MT_CLS_DUAL_INRANGE_CONTACTID           0x0006
 
106
#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER       0x0007
 
107
#define MT_CLS_DUAL_NSMU_CONTACTID              0x0008
 
108
#define MT_CLS_INRANGE_CONTACTNUMBER            0x0009
96
109
 
97
110
/* vendor specific classes */
98
111
#define MT_CLS_3M                               0x0101
99
112
#define MT_CLS_CYPRESS                          0x0102
100
113
#define MT_CLS_EGALAX                           0x0103
 
114
#define MT_CLS_EGALAX_SERIAL                    0x0104
 
115
#define MT_CLS_TOPSEED                          0x0105
 
116
#define MT_CLS_PANASONIC                        0x0106
101
117
 
102
118
#define MT_DEFAULT_MAXCONTACT   10
103
119
 
 
120
#define MT_USB_DEVICE(v, p)     HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p)
 
121
#define MT_BT_DEVICE(v, p)      HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p)
 
122
 
104
123
/*
105
124
 * these device-dependent functions determine what slot corresponds
106
125
 * to a valid contact that was just read.
133
152
        return -1;
134
153
}
135
154
 
136
 
struct mt_class mt_classes[] = {
 
155
static struct mt_class mt_classes[] = {
137
156
        { .name = MT_CLS_DEFAULT,
138
157
                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
139
158
        { .name = MT_CLS_SERIAL,
140
159
                .quirks = MT_QUIRK_ALWAYS_VALID},
141
160
        { .name = MT_CLS_CONFIDENCE,
142
161
                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
 
162
        { .name = MT_CLS_CONFIDENCE_CONTACT_ID,
 
163
                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 
164
                        MT_QUIRK_SLOT_IS_CONTACTID },
143
165
        { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
144
166
                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
145
167
                        MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
155
177
                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
156
178
                        MT_QUIRK_SLOT_IS_CONTACTID,
157
179
                .maxcontacts = 2 },
 
180
        { .name = MT_CLS_INRANGE_CONTACTNUMBER,
 
181
                .quirks = MT_QUIRK_VALID_IS_INRANGE |
 
182
                        MT_QUIRK_SLOT_IS_CONTACTNUMBER },
158
183
 
159
184
        /*
160
185
         * vendor specific classes
171
196
                .maxcontacts = 10 },
172
197
        { .name = MT_CLS_EGALAX,
173
198
                .quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
174
 
                        MT_QUIRK_VALID_IS_INRANGE |
175
 
                        MT_QUIRK_EGALAX_XYZ_FIXUP,
 
199
                        MT_QUIRK_VALID_IS_INRANGE,
 
200
                .sn_move = 4096,
 
201
                .sn_pressure = 32,
 
202
        },
 
203
        { .name = MT_CLS_EGALAX_SERIAL,
 
204
                .quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
 
205
                        MT_QUIRK_ALWAYS_VALID,
 
206
                .sn_move = 4096,
 
207
                .sn_pressure = 32,
 
208
        },
 
209
        { .name = MT_CLS_TOPSEED,
 
210
                .quirks = MT_QUIRK_ALWAYS_VALID,
 
211
                .is_indirect = true,
176
212
                .maxcontacts = 2,
177
 
                .sn_move = 4096,
178
 
                .sn_pressure = 32,
179
213
        },
 
214
        { .name = MT_CLS_PANASONIC,
 
215
                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
 
216
                .maxcontacts = 4 },
180
217
 
181
218
        { }
182
219
};
183
220
 
 
221
static ssize_t mt_show_quirks(struct device *dev,
 
222
                           struct device_attribute *attr,
 
223
                           char *buf)
 
224
{
 
225
        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 
226
        struct mt_device *td = hid_get_drvdata(hdev);
 
227
 
 
228
        return sprintf(buf, "%u\n", td->mtclass.quirks);
 
229
}
 
230
 
 
231
static ssize_t mt_set_quirks(struct device *dev,
 
232
                          struct device_attribute *attr,
 
233
                          const char *buf, size_t count)
 
234
{
 
235
        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 
236
        struct mt_device *td = hid_get_drvdata(hdev);
 
237
 
 
238
        unsigned long val;
 
239
 
 
240
        if (kstrtoul(buf, 0, &val))
 
241
                return -EINVAL;
 
242
 
 
243
        td->mtclass.quirks = val;
 
244
 
 
245
        return count;
 
246
}
 
247
 
 
248
static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
 
249
 
 
250
static struct attribute *sysfs_attrs[] = {
 
251
        &dev_attr_quirks.attr,
 
252
        NULL
 
253
};
 
254
 
 
255
static struct attribute_group mt_attribute_group = {
 
256
        .attrs = sysfs_attrs
 
257
};
 
258
 
184
259
static void mt_feature_mapping(struct hid_device *hdev,
185
260
                struct hid_field *field, struct hid_usage *usage)
186
261
{
191
266
                td->inputmode = field->report->id;
192
267
                break;
193
268
        case HID_DG_CONTACTMAX:
 
269
                td->maxcontact_report_id = field->report->id;
194
270
                td->maxcontacts = field->value[0];
195
 
                if (td->mtclass->maxcontacts)
 
271
                if (td->mtclass.maxcontacts)
196
272
                        /* check if the maxcontacts is given by the class */
197
 
                        td->maxcontacts = td->mtclass->maxcontacts;
 
273
                        td->maxcontacts = td->mtclass.maxcontacts;
198
274
 
199
275
                break;
200
276
        }
209
285
        input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
210
286
}
211
287
 
 
288
static void mt_store_field(struct hid_usage *usage, struct mt_device *td,
 
289
                struct hid_input *hi)
 
290
{
 
291
        struct mt_fields *f = td->fields;
 
292
 
 
293
        if (f->length >= HID_MAX_FIELDS)
 
294
                return;
 
295
 
 
296
        f->usages[f->length++] = usage->hid;
 
297
}
 
298
 
212
299
static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
213
300
                struct hid_field *field, struct hid_usage *usage,
214
301
                unsigned long **bit, int *max)
215
302
{
216
303
        struct mt_device *td = hid_get_drvdata(hdev);
217
 
        struct mt_class *cls = td->mtclass;
218
 
        __s32 quirks = cls->quirks;
 
304
        struct mt_class *cls = &td->mtclass;
 
305
        int code;
219
306
 
220
307
        /* Only map fields from TouchScreen or TouchPad collections.
221
 
         * We need to ignore fields that belong to other collections
222
 
         * such as Mouse that might have the same GenericDesktop usages. */
 
308
        * We need to ignore fields that belong to other collections
 
309
        * such as Mouse that might have the same GenericDesktop usages. */
223
310
        if (field->application == HID_DG_TOUCHSCREEN)
224
311
                set_bit(INPUT_PROP_DIRECT, hi->input->propbit);
225
 
        else if (field->application == HID_DG_TOUCHPAD)
 
312
        else if (field->application != HID_DG_TOUCHPAD)
 
313
                return 0;
 
314
 
 
315
        /* In case of an indirect device (touchpad), we need to add
 
316
         * specific BTN_TOOL_* to be handled by the synaptics xorg
 
317
         * driver.
 
318
         * We also consider that touchscreens providing buttons are touchpads.
 
319
         */
 
320
        if (field->application == HID_DG_TOUCHPAD ||
 
321
            (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON ||
 
322
            cls->is_indirect) {
226
323
                set_bit(INPUT_PROP_POINTER, hi->input->propbit);
227
 
        else
228
 
                return 0;
 
324
                set_bit(BTN_TOOL_FINGER, hi->input->keybit);
 
325
                set_bit(BTN_TOOL_DOUBLETAP, hi->input->keybit);
 
326
                set_bit(BTN_TOOL_TRIPLETAP, hi->input->keybit);
 
327
                set_bit(BTN_TOOL_QUADTAP, hi->input->keybit);
 
328
        }
 
329
 
 
330
        /* eGalax devices provide a Digitizer.Stylus input which overrides
 
331
         * the correct Digitizers.Finger X/Y ranges.
 
332
         * Let's just ignore this input. */
 
333
        if (field->physical == HID_DG_STYLUS)
 
334
                return -1;
229
335
 
230
336
        switch (usage->hid & HID_USAGE_PAGE) {
231
337
 
232
338
        case HID_UP_GENDESK:
233
339
                switch (usage->hid) {
234
340
                case HID_GD_X:
235
 
                        if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
236
 
                                field->logical_maximum = 32760;
237
341
                        hid_map_usage(hi, usage, bit, max,
238
342
                                        EV_ABS, ABS_MT_POSITION_X);
239
343
                        set_abs(hi->input, ABS_MT_POSITION_X, field,
240
344
                                cls->sn_move);
241
345
                        /* touchscreen emulation */
242
346
                        set_abs(hi->input, ABS_X, field, cls->sn_move);
243
 
                        if (td->last_mt_collection == usage->collection_index) {
244
 
                                td->last_slot_field = usage->hid;
245
 
                                td->last_field_index = field->index;
246
 
                        }
 
347
                        mt_store_field(usage, td, hi);
 
348
                        td->last_field_index = field->index;
247
349
                        return 1;
248
350
                case HID_GD_Y:
249
 
                        if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
250
 
                                field->logical_maximum = 32760;
251
351
                        hid_map_usage(hi, usage, bit, max,
252
352
                                        EV_ABS, ABS_MT_POSITION_Y);
253
353
                        set_abs(hi->input, ABS_MT_POSITION_Y, field,
254
354
                                cls->sn_move);
255
355
                        /* touchscreen emulation */
256
356
                        set_abs(hi->input, ABS_Y, field, cls->sn_move);
257
 
                        if (td->last_mt_collection == usage->collection_index) {
258
 
                                td->last_slot_field = usage->hid;
259
 
                                td->last_field_index = field->index;
260
 
                        }
 
357
                        mt_store_field(usage, td, hi);
 
358
                        td->last_field_index = field->index;
261
359
                        return 1;
262
360
                }
263
361
                return 0;
265
363
        case HID_UP_DIGITIZER:
266
364
                switch (usage->hid) {
267
365
                case HID_DG_INRANGE:
268
 
                        if (td->last_mt_collection == usage->collection_index) {
269
 
                                td->last_slot_field = usage->hid;
270
 
                                td->last_field_index = field->index;
271
 
                        }
 
366
                        mt_store_field(usage, td, hi);
 
367
                        td->last_field_index = field->index;
272
368
                        return 1;
273
369
                case HID_DG_CONFIDENCE:
274
 
                        if (td->last_mt_collection == usage->collection_index) {
275
 
                                td->last_slot_field = usage->hid;
276
 
                                td->last_field_index = field->index;
277
 
                        }
 
370
                        mt_store_field(usage, td, hi);
 
371
                        td->last_field_index = field->index;
278
372
                        return 1;
279
373
                case HID_DG_TIPSWITCH:
280
374
                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
281
375
                        input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
282
 
                        if (td->last_mt_collection == usage->collection_index) {
283
 
                                td->last_slot_field = usage->hid;
284
 
                                td->last_field_index = field->index;
285
 
                        }
 
376
                        mt_store_field(usage, td, hi);
 
377
                        td->last_field_index = field->index;
286
378
                        return 1;
287
379
                case HID_DG_CONTACTID:
288
380
                        if (!td->maxcontacts)
289
381
                                td->maxcontacts = MT_DEFAULT_MAXCONTACT;
290
382
                        input_mt_init_slots(hi->input, td->maxcontacts);
291
 
                        td->last_slot_field = usage->hid;
 
383
                        mt_store_field(usage, td, hi);
292
384
                        td->last_field_index = field->index;
293
 
                        td->last_mt_collection = usage->collection_index;
 
385
                        td->touches_by_report++;
294
386
                        return 1;
295
387
                case HID_DG_WIDTH:
296
388
                        hid_map_usage(hi, usage, bit, max,
297
389
                                        EV_ABS, ABS_MT_TOUCH_MAJOR);
298
390
                        set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
299
391
                                cls->sn_width);
300
 
                        if (td->last_mt_collection == usage->collection_index) {
301
 
                                td->last_slot_field = usage->hid;
302
 
                                td->last_field_index = field->index;
303
 
                        }
 
392
                        mt_store_field(usage, td, hi);
 
393
                        td->last_field_index = field->index;
304
394
                        return 1;
305
395
                case HID_DG_HEIGHT:
306
396
                        hid_map_usage(hi, usage, bit, max,
309
399
                                cls->sn_height);
310
400
                        input_set_abs_params(hi->input,
311
401
                                        ABS_MT_ORIENTATION, 0, 1, 0, 0);
312
 
                        if (td->last_mt_collection == usage->collection_index) {
313
 
                                td->last_slot_field = usage->hid;
314
 
                                td->last_field_index = field->index;
315
 
                        }
 
402
                        mt_store_field(usage, td, hi);
 
403
                        td->last_field_index = field->index;
316
404
                        return 1;
317
405
                case HID_DG_TIPPRESSURE:
318
 
                        if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
319
 
                                field->logical_minimum = 0;
320
406
                        hid_map_usage(hi, usage, bit, max,
321
407
                                        EV_ABS, ABS_MT_PRESSURE);
322
408
                        set_abs(hi->input, ABS_MT_PRESSURE, field,
324
410
                        /* touchscreen emulation */
325
411
                        set_abs(hi->input, ABS_PRESSURE, field,
326
412
                                cls->sn_pressure);
327
 
                        if (td->last_mt_collection == usage->collection_index) {
328
 
                                td->last_slot_field = usage->hid;
329
 
                                td->last_field_index = field->index;
330
 
                        }
 
413
                        mt_store_field(usage, td, hi);
 
414
                        td->last_field_index = field->index;
331
415
                        return 1;
332
416
                case HID_DG_CONTACTCOUNT:
333
 
                        if (td->last_mt_collection == usage->collection_index)
334
 
                                td->last_field_index = field->index;
 
417
                        td->last_field_index = field->index;
335
418
                        return 1;
336
419
                case HID_DG_CONTACTMAX:
337
420
                        /* we don't set td->last_slot_field as contactcount and
338
421
                         * contact max are global to the report */
339
 
                        if (td->last_mt_collection == usage->collection_index)
340
 
                                td->last_field_index = field->index;
 
422
                        td->last_field_index = field->index;
341
423
                        return -1;
342
424
                }
 
425
                case HID_DG_TOUCH:
 
426
                        /* Legacy devices use TIPSWITCH and not TOUCH.
 
427
                         * Let's just ignore this field. */
 
428
                        return -1;
343
429
                /* let hid-input decide for the others */
344
430
                return 0;
345
431
 
 
432
        case HID_UP_BUTTON:
 
433
                code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
 
434
                hid_map_usage(hi, usage, bit, max, EV_KEY, code);
 
435
                input_set_capability(hi->input, EV_KEY, code);
 
436
                return 1;
 
437
 
346
438
        case 0xff000000:
347
439
                /* we do not want to map these: no input-oriented meaning */
348
440
                return -1;
363
455
 
364
456
static int mt_compute_slot(struct mt_device *td)
365
457
{
366
 
        __s32 quirks = td->mtclass->quirks;
 
458
        __s32 quirks = td->mtclass.quirks;
367
459
 
368
460
        if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
369
461
                return td->curdata.contactid;
407
499
 
408
500
        for (i = 0; i < td->maxcontacts; ++i) {
409
501
                struct mt_slot *s = &(td->slots[i]);
410
 
                if ((td->mtclass->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
 
502
                if ((td->mtclass.quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
411
503
                        !s->seen_in_this_frame) {
412
504
                        s->touch_state = false;
413
505
                }
444
536
                                struct hid_usage *usage, __s32 value)
445
537
{
446
538
        struct mt_device *td = hid_get_drvdata(hid);
447
 
        __s32 quirks = td->mtclass->quirks;
 
539
        __s32 quirks = td->mtclass.quirks;
448
540
 
449
541
        if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
450
542
                switch (usage->hid) {
489
581
                        if (value)
490
582
                                td->num_expected = value;
491
583
                        break;
 
584
                case HID_DG_TOUCH:
 
585
                        /* do nothing */
 
586
                        break;
492
587
 
493
588
                default:
494
589
                        /* fallback to the generic hidinput handling */
495
590
                        return 0;
496
591
                }
497
592
 
498
 
                if (usage->hid == td->last_slot_field) {
 
593
                if (usage->hid == td->last_slot_field)
499
594
                        mt_complete_slot(td);
500
 
                }
501
595
 
502
596
                if (field->index == td->last_field_index
503
597
                        && td->num_received >= td->num_expected)
529
623
        }
530
624
}
531
625
 
 
626
static void mt_set_maxcontacts(struct hid_device *hdev)
 
627
{
 
628
        struct mt_device *td = hid_get_drvdata(hdev);
 
629
        struct hid_report *r;
 
630
        struct hid_report_enum *re;
 
631
        int fieldmax, max;
 
632
 
 
633
        if (td->maxcontact_report_id < 0)
 
634
                return;
 
635
 
 
636
        if (!td->mtclass.maxcontacts)
 
637
                return;
 
638
 
 
639
        re = &hdev->report_enum[HID_FEATURE_REPORT];
 
640
        r = re->report_id_hash[td->maxcontact_report_id];
 
641
        if (r) {
 
642
                max = td->mtclass.maxcontacts;
 
643
                fieldmax = r->field[0]->logical_maximum;
 
644
                max = min(fieldmax, max);
 
645
                if (r->field[0]->value[0] != max) {
 
646
                        r->field[0]->value[0] = max;
 
647
                        usbhid_submit_report(hdev, r, USB_DIR_OUT);
 
648
                }
 
649
        }
 
650
}
 
651
 
 
652
static void mt_post_parse_default_settings(struct mt_device *td)
 
653
{
 
654
        __s32 quirks = td->mtclass.quirks;
 
655
 
 
656
        /* unknown serial device needs special quirks */
 
657
        if (td->touches_by_report == 1) {
 
658
                quirks |= MT_QUIRK_ALWAYS_VALID;
 
659
                quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
 
660
                quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
 
661
                quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;
 
662
        }
 
663
 
 
664
        td->mtclass.quirks = quirks;
 
665
}
 
666
 
 
667
static void mt_post_parse(struct mt_device *td)
 
668
{
 
669
        struct mt_fields *f = td->fields;
 
670
 
 
671
        if (td->touches_by_report > 0) {
 
672
                int field_count_per_touch = f->length / td->touches_by_report;
 
673
                td->last_slot_field = f->usages[field_count_per_touch - 1];
 
674
        }
 
675
}
 
676
 
532
677
static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
533
678
{
534
679
        int ret, i;
535
680
        struct mt_device *td;
536
681
        struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
537
682
 
538
 
        for (i = 0; mt_classes[i].name ; i++) {
539
 
                if (id->driver_data == mt_classes[i].name) {
540
 
                        mtclass = &(mt_classes[i]);
541
 
                        break;
 
683
        if (id) {
 
684
                for (i = 0; mt_classes[i].name ; i++) {
 
685
                        if (id->driver_data == mt_classes[i].name) {
 
686
                                mtclass = &(mt_classes[i]);
 
687
                                break;
 
688
                        }
542
689
                }
543
690
        }
544
691
 
552
699
                dev_err(&hdev->dev, "cannot allocate multitouch data\n");
553
700
                return -ENOMEM;
554
701
        }
555
 
        td->mtclass = mtclass;
 
702
        td->mtclass = *mtclass;
556
703
        td->inputmode = -1;
557
 
        td->last_mt_collection = -1;
 
704
        td->maxcontact_report_id = -1;
558
705
        hid_set_drvdata(hdev, td);
559
706
 
 
707
        td->fields = kzalloc(sizeof(struct mt_fields), GFP_KERNEL);
 
708
        if (!td->fields) {
 
709
                dev_err(&hdev->dev, "cannot allocate multitouch fields data\n");
 
710
                ret = -ENOMEM;
 
711
                goto fail;
 
712
        }
 
713
 
560
714
        ret = hid_parse(hdev);
561
715
        if (ret != 0)
562
716
                goto fail;
565
719
        if (ret)
566
720
                goto fail;
567
721
 
 
722
        mt_post_parse(td);
 
723
 
 
724
        if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
 
725
                mt_post_parse_default_settings(td);
 
726
 
568
727
        td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
569
728
                                GFP_KERNEL);
570
729
        if (!td->slots) {
574
733
                goto fail;
575
734
        }
576
735
 
 
736
        ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
 
737
 
 
738
        mt_set_maxcontacts(hdev);
577
739
        mt_set_input_mode(hdev);
578
740
 
 
741
        kfree(td->fields);
 
742
        td->fields = NULL;
 
743
 
579
744
        return 0;
580
745
 
581
746
fail:
 
747
        kfree(td->fields);
582
748
        kfree(td);
583
749
        return ret;
584
750
}
586
752
#ifdef CONFIG_PM
587
753
static int mt_reset_resume(struct hid_device *hdev)
588
754
{
 
755
        mt_set_maxcontacts(hdev);
589
756
        mt_set_input_mode(hdev);
590
757
        return 0;
591
758
}
594
761
static void mt_remove(struct hid_device *hdev)
595
762
{
596
763
        struct mt_device *td = hid_get_drvdata(hdev);
 
764
        sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
597
765
        hid_hw_stop(hdev);
598
766
        kfree(td->slots);
599
767
        kfree(td);
604
772
 
605
773
        /* 3M panels */
606
774
        { .driver_data = MT_CLS_3M,
607
 
                HID_USB_DEVICE(USB_VENDOR_ID_3M,
 
775
                MT_USB_DEVICE(USB_VENDOR_ID_3M,
608
776
                        USB_DEVICE_ID_3M1968) },
609
777
        { .driver_data = MT_CLS_3M,
610
 
                HID_USB_DEVICE(USB_VENDOR_ID_3M,
 
778
                MT_USB_DEVICE(USB_VENDOR_ID_3M,
611
779
                        USB_DEVICE_ID_3M2256) },
612
780
        { .driver_data = MT_CLS_3M,
613
 
                HID_USB_DEVICE(USB_VENDOR_ID_3M,
 
781
                MT_USB_DEVICE(USB_VENDOR_ID_3M,
614
782
                        USB_DEVICE_ID_3M3266) },
615
783
 
616
784
        /* ActionStar panels */
617
785
        { .driver_data = MT_CLS_DEFAULT,
618
 
                HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
 
786
                MT_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
619
787
                        USB_DEVICE_ID_ACTIONSTAR_1011) },
620
788
 
621
789
        /* Atmel panels */
622
790
        { .driver_data = MT_CLS_SERIAL,
623
 
                HID_USB_DEVICE(USB_VENDOR_ID_ATMEL,
 
791
                MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
624
792
                        USB_DEVICE_ID_ATMEL_MULTITOUCH) },
 
793
        { .driver_data = MT_CLS_SERIAL,
 
794
                MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
 
795
                        USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
625
796
 
 
797
        /* Baanto multitouch devices */
 
798
        { .driver_data = MT_CLS_DEFAULT,
 
799
                MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
 
800
                        USB_DEVICE_ID_BAANTO_MT_190W2) },
626
801
        /* Cando panels */
627
802
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
628
 
                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 
803
                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
629
804
                        USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
630
805
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
631
 
                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 
806
                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
632
807
                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
633
808
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
634
 
                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 
809
                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
635
810
                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
636
811
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
637
 
                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 
812
                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
638
813
                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
639
814
 
640
815
        /* Chunghwa Telecom touch panels */
641
816
        {  .driver_data = MT_CLS_DEFAULT,
642
 
                HID_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
 
817
                MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
643
818
                        USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
644
819
 
645
820
        /* CVTouch panels */
646
821
        { .driver_data = MT_CLS_DEFAULT,
647
 
                HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
 
822
                MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
648
823
                        USB_DEVICE_ID_CVTOUCH_SCREEN) },
649
824
 
650
825
        /* Cypress panel */
654
829
 
655
830
        /* eGalax devices (resistive) */
656
831
        { .driver_data = MT_CLS_EGALAX,
657
 
                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
832
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
658
833
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
659
834
        { .driver_data = MT_CLS_EGALAX,
660
 
                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
835
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
661
836
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
662
837
 
663
838
        /* eGalax devices (capacitive) */
664
839
        { .driver_data = MT_CLS_EGALAX,
665
 
                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
840
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
666
841
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
 
842
        { .driver_data = MT_CLS_EGALAX_SERIAL,
 
843
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
844
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
 
845
        { .driver_data = MT_CLS_EGALAX_SERIAL,
 
846
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
847
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
 
848
        { .driver_data = MT_CLS_EGALAX_SERIAL,
 
849
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
850
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
 
851
        { .driver_data = MT_CLS_EGALAX_SERIAL,
 
852
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
853
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
667
854
        { .driver_data = MT_CLS_EGALAX,
668
 
                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
855
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
669
856
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
 
857
        { .driver_data = MT_CLS_EGALAX_SERIAL,
 
858
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
859
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
670
860
        { .driver_data = MT_CLS_EGALAX,
671
 
                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
861
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
672
862
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
 
863
        { .driver_data = MT_CLS_EGALAX_SERIAL,
 
864
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
865
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
673
866
        { .driver_data = MT_CLS_EGALAX,
674
 
                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
867
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
675
868
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
676
869
        { .driver_data = MT_CLS_EGALAX,
677
 
                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
870
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
678
871
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
679
 
        { .driver_data = MT_CLS_EGALAX,
680
 
                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
872
        { .driver_data = MT_CLS_EGALAX_SERIAL,
 
873
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
 
874
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
 
875
        { .driver_data = MT_CLS_EGALAX_SERIAL,
 
876
                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
681
877
                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
682
878
 
683
879
        /* Elo TouchSystems IntelliTouch Plus panel */
684
880
        { .driver_data = MT_CLS_DUAL_NSMU_CONTACTID,
685
 
                HID_USB_DEVICE(USB_VENDOR_ID_ELO,
 
881
                MT_USB_DEVICE(USB_VENDOR_ID_ELO,
686
882
                        USB_DEVICE_ID_ELO_TS2515) },
687
883
 
688
884
        /* GeneralTouch panel */
689
885
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
690
 
                HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
 
886
                MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
691
887
                        USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
692
888
 
 
889
        /* Gametel game controller */
 
890
        { .driver_data = MT_CLS_DEFAULT,
 
891
                MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
 
892
                        USB_DEVICE_ID_GAMETEL_MT_MODE) },
 
893
 
693
894
        /* GoodTouch panels */
694
895
        { .driver_data = MT_CLS_DEFAULT,
695
 
                HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
 
896
                MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
696
897
                        USB_DEVICE_ID_GOODTOUCH_000f) },
697
898
 
698
899
        /* Hanvon panels */
699
900
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
700
 
                HID_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
 
901
                MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
701
902
                        USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
702
903
 
703
904
        /* Ideacom panel */
704
905
        { .driver_data = MT_CLS_SERIAL,
705
 
                HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
 
906
                MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
706
907
                        USB_DEVICE_ID_IDEACOM_IDC6650) },
 
908
        { .driver_data = MT_CLS_SERIAL,
 
909
                MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
 
910
                        USB_DEVICE_ID_IDEACOM_IDC6651) },
707
911
 
708
912
        /* Ilitek dual touch panel */
709
913
        {  .driver_data = MT_CLS_DEFAULT,
710
 
                HID_USB_DEVICE(USB_VENDOR_ID_ILITEK,
 
914
                MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
711
915
                        USB_DEVICE_ID_ILITEK_MULTITOUCH) },
712
916
 
713
917
        /* IRTOUCH panels */
714
918
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
715
 
                HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
 
919
                MT_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
716
920
                        USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
717
921
 
718
922
        /* LG Display panels */
719
923
        { .driver_data = MT_CLS_DEFAULT,
720
 
                HID_USB_DEVICE(USB_VENDOR_ID_LG,
 
924
                MT_USB_DEVICE(USB_VENDOR_ID_LG,
721
925
                        USB_DEVICE_ID_LG_MULTITOUCH) },
722
926
 
723
927
        /* Lumio panels */
724
928
        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
725
 
                HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
 
929
                MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
726
930
                        USB_DEVICE_ID_CRYSTALTOUCH) },
727
931
        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
728
 
                HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
 
932
                MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
729
933
                        USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
730
934
 
731
935
        /* MosArt panels */
732
936
        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
733
 
                HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
 
937
                MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
734
938
                        USB_DEVICE_ID_ASUS_T91MT)},
735
939
        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
736
 
                HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
 
940
                MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
737
941
                        USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
738
942
        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
739
 
                HID_USB_DEVICE(USB_VENDOR_ID_TURBOX,
 
943
                MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
740
944
                        USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
741
945
 
 
946
        /* Panasonic panels */
 
947
        { .driver_data = MT_CLS_PANASONIC,
 
948
                MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
 
949
                        USB_DEVICE_ID_PANABOARD_UBT780) },
 
950
        { .driver_data = MT_CLS_PANASONIC,
 
951
                MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
 
952
                        USB_DEVICE_ID_PANABOARD_UBT880) },
 
953
 
742
954
        /* PenMount panels */
743
955
        { .driver_data = MT_CLS_CONFIDENCE,
744
 
                HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
 
956
                MT_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
745
957
                        USB_DEVICE_ID_PENMOUNT_PCI) },
746
958
 
 
959
        /* PixArt optical touch screen */
 
960
        { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
 
961
                MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
 
962
                        USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
 
963
        { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
 
964
                MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
 
965
                        USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
 
966
        { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
 
967
                MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
 
968
                        USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
 
969
 
747
970
        /* PixCir-based panels */
748
971
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
749
 
                HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
 
972
                MT_USB_DEVICE(USB_VENDOR_ID_HANVON,
750
973
                        USB_DEVICE_ID_HANVON_MULTITOUCH) },
751
974
        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
752
 
                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 
975
                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
753
976
                        USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
754
977
 
 
978
        /* Quanta-based panels */
 
979
        { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
 
980
                MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
 
981
                        USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
 
982
        { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
 
983
                MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
 
984
                        USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
 
985
        { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
 
986
                MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
 
987
                        USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) },
 
988
 
755
989
        /* Stantum panels */
756
990
        { .driver_data = MT_CLS_CONFIDENCE,
757
 
                HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
 
991
                MT_USB_DEVICE(USB_VENDOR_ID_STANTUM,
758
992
                        USB_DEVICE_ID_MTP)},
759
993
        { .driver_data = MT_CLS_CONFIDENCE,
760
 
                HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
 
994
                MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
761
995
                        USB_DEVICE_ID_MTP_STM)},
762
996
        { .driver_data = MT_CLS_CONFIDENCE,
763
 
                HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX,
 
997
                MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX,
764
998
                        USB_DEVICE_ID_MTP_SITRONIX)},
765
999
 
 
1000
        /* TopSeed panels */
 
1001
        { .driver_data = MT_CLS_TOPSEED,
 
1002
                MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
 
1003
                        USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },
 
1004
 
766
1005
        /* Touch International panels */
767
1006
        { .driver_data = MT_CLS_DEFAULT,
768
 
                HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
 
1007
                MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
769
1008
                        USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
770
1009
 
771
1010
        /* Unitec panels */
772
1011
        { .driver_data = MT_CLS_DEFAULT,
773
 
                HID_USB_DEVICE(USB_VENDOR_ID_UNITEC,
 
1012
                MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
774
1013
                        USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
775
1014
        { .driver_data = MT_CLS_DEFAULT,
776
 
                HID_USB_DEVICE(USB_VENDOR_ID_UNITEC,
 
1015
                MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
777
1016
                        USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
778
1017
        /* XAT */
779
1018
        { .driver_data = MT_CLS_DEFAULT,
780
 
                HID_USB_DEVICE(USB_VENDOR_ID_XAT,
 
1019
                MT_USB_DEVICE(USB_VENDOR_ID_XAT,
781
1020
                        USB_DEVICE_ID_XAT_CSR) },
782
1021
 
783
1022
        /* Xiroku */
784
1023
        { .driver_data = MT_CLS_DEFAULT,
785
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1024
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
786
1025
                        USB_DEVICE_ID_XIROKU_SPX) },
787
1026
        { .driver_data = MT_CLS_DEFAULT,
788
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1027
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
789
1028
                        USB_DEVICE_ID_XIROKU_MPX) },
790
1029
        { .driver_data = MT_CLS_DEFAULT,
791
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1030
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
792
1031
                        USB_DEVICE_ID_XIROKU_CSR) },
793
1032
        { .driver_data = MT_CLS_DEFAULT,
794
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1033
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
795
1034
                        USB_DEVICE_ID_XIROKU_SPX1) },
796
1035
        { .driver_data = MT_CLS_DEFAULT,
797
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1036
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
798
1037
                        USB_DEVICE_ID_XIROKU_MPX1) },
799
1038
        { .driver_data = MT_CLS_DEFAULT,
800
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1039
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
801
1040
                        USB_DEVICE_ID_XIROKU_CSR1) },
802
1041
        { .driver_data = MT_CLS_DEFAULT,
803
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1042
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
804
1043
                        USB_DEVICE_ID_XIROKU_SPX2) },
805
1044
        { .driver_data = MT_CLS_DEFAULT,
806
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1045
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
807
1046
                        USB_DEVICE_ID_XIROKU_MPX2) },
808
1047
        { .driver_data = MT_CLS_DEFAULT,
809
 
                HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
 
1048
                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
810
1049
                        USB_DEVICE_ID_XIROKU_CSR2) },
811
1050
 
 
1051
        /* Generic MT device */
 
1052
        { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
812
1053
        { }
813
1054
};
814
1055
MODULE_DEVICE_TABLE(hid, mt_devices);