hid-multitouch.c 33.4 KB
Newer Older
1 2 3
/*
 *  HID driver for multitouch panels
 *
4 5 6
 *  Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
 *  Copyright (c) 2010-2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
 *  Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
7
 *
8 9 10 11 12 13
 *  This code is partly based on hid-egalax.c:
 *
 *  Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
 *  Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
 *  Copyright (c) 2010 Canonical, Ltd.
 *
14 15 16 17 18 19
 *  This code is partly based on hid-3m-pct.c:
 *
 *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
 *  Copyright (c) 2010      Henrik Rydberg <rydberg@euromail.se>
 *  Copyright (c) 2010      Canonical, Ltd.
 *
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include <linux/input/mt.h>
#include "usbhid/usbhid.h"


MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
39
MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
40 41 42 43 44 45 46 47
MODULE_DESCRIPTION("HID multitouch panels");
MODULE_LICENSE("GPL");

#include "hid-ids.h"

/* quirks to control the device */
#define MT_QUIRK_NOT_SEEN_MEANS_UP	(1 << 0)
#define MT_QUIRK_SLOT_IS_CONTACTID	(1 << 1)
48
#define MT_QUIRK_CYPRESS		(1 << 2)
49
#define MT_QUIRK_SLOT_IS_CONTACTNUMBER	(1 << 3)
50 51 52 53
#define MT_QUIRK_ALWAYS_VALID		(1 << 4)
#define MT_QUIRK_VALID_IS_INRANGE	(1 << 5)
#define MT_QUIRK_VALID_IS_CONFIDENCE	(1 << 6)
#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE	(1 << 8)
54
#define MT_QUIRK_NO_AREA		(1 << 9)
55
#define MT_QUIRK_IGNORE_DUPLICATES	(1 << 10)
56 57

struct mt_slot {
58
	__s32 x, y, cx, cy, p, w, h;
59 60 61 62
	__s32 contactid;	/* the device ContactID assigned to this slot */
	bool touch_state;	/* is the touch valid? */
};

63 64 65 66 67 68 69 70
struct mt_class {
	__s32 name;	/* MT_CLS */
	__s32 quirks;
	__s32 sn_move;	/* Signal/noise ratio for move events */
	__s32 sn_width;	/* Signal/noise ratio for width events */
	__s32 sn_height;	/* Signal/noise ratio for height events */
	__s32 sn_pressure;	/* Signal/noise ratio for pressure events */
	__u8 maxcontacts;
71
	bool is_indirect;	/* true for touchpads */
72 73
};

74 75 76 77 78
struct mt_fields {
	unsigned usages[HID_MAX_FIELDS];
	unsigned int length;
};

79 80
struct mt_device {
	struct mt_slot curdata;	/* placeholder of incoming data */
81
	struct mt_class mtclass;	/* our mt device class */
82 83
	struct mt_fields *fields;	/* temporary placeholder for storing the
					   multitouch fields */
84 85 86
	unsigned last_field_index;	/* last field index of the report */
	unsigned last_slot_field;	/* the last field of a slot */
	__s8 inputmode;		/* InputMode HID feature, -1 if non-existent */
87
	__s8 inputmode_index;	/* InputMode HID feature index in the report */
88 89
	__s8 maxcontact_report_id;	/* Maximum Contact Number HID feature,
				   -1 if non-existent */
90 91
	__u8 num_received;	/* how many contacts we received */
	__u8 num_expected;	/* expected last contact index */
92
	__u8 maxcontacts;
93 94 95
	__u8 touches_by_report;	/* how many touches are present in one report:
				* 1 means we should use a serial protocol
				* > 1 means hybrid (multitouch) protocol */
96
	bool serial_maybe;	/* need to check for serial protocol */
97
	bool curvalid;		/* is the current contact valid? */
98
	unsigned mt_flags;	/* flags to pass to input-mt */
99 100 101
};

/* classes of device behavior */
102 103
#define MT_CLS_DEFAULT				0x0001

104 105
#define MT_CLS_SERIAL				0x0002
#define MT_CLS_CONFIDENCE			0x0003
106 107 108 109 110
#define MT_CLS_CONFIDENCE_CONTACT_ID		0x0004
#define MT_CLS_CONFIDENCE_MINUS_ONE		0x0005
#define MT_CLS_DUAL_INRANGE_CONTACTID		0x0006
#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER	0x0007
#define MT_CLS_DUAL_NSMU_CONTACTID		0x0008
111
#define MT_CLS_INRANGE_CONTACTNUMBER		0x0009
112 113 114 115 116

/* vendor specific classes */
#define MT_CLS_3M				0x0101
#define MT_CLS_CYPRESS				0x0102
#define MT_CLS_EGALAX				0x0103
117
#define MT_CLS_EGALAX_SERIAL			0x0104
118
#define MT_CLS_TOPSEED				0x0105
119
#define MT_CLS_PANASONIC			0x0106
120
#define MT_CLS_FLATFROG				0x0107
121 122
#define MT_CLS_GENERALTOUCH_TWOFINGERS		0x0108
#define MT_CLS_GENERALTOUCH_PWT_TENFINGERS	0x0109
123

124
#define MT_DEFAULT_MAXCONTACT	10
125
#define MT_MAX_MAXCONTACT	250
126

127 128 129
#define MT_USB_DEVICE(v, p)	HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p)
#define MT_BT_DEVICE(v, p)	HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p)

130 131 132 133 134
/*
 * these device-dependent functions determine what slot corresponds
 * to a valid contact that was just read.
 */

135 136 137 138 139 140 141 142
static int cypress_compute_slot(struct mt_device *td)
{
	if (td->curdata.contactid != 0 || td->num_received == 0)
		return td->curdata.contactid;
	else
		return -1;
}

143
static struct mt_class mt_classes[] = {
144
	{ .name = MT_CLS_DEFAULT,
145
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
146 147
	{ .name = MT_CLS_SERIAL,
		.quirks = MT_QUIRK_ALWAYS_VALID},
148 149
	{ .name = MT_CLS_CONFIDENCE,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
150 151 152
	{ .name = MT_CLS_CONFIDENCE_CONTACT_ID,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
			MT_QUIRK_SLOT_IS_CONTACTID },
153 154 155
	{ .name = MT_CLS_CONFIDENCE_MINUS_ONE,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
			MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
156
	{ .name = MT_CLS_DUAL_INRANGE_CONTACTID,
157 158 159
		.quirks = MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTID,
		.maxcontacts = 2 },
160
	{ .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
161 162 163
		.quirks = MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTNUMBER,
		.maxcontacts = 2 },
164 165 166 167
	{ .name = MT_CLS_DUAL_NSMU_CONTACTID,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
			MT_QUIRK_SLOT_IS_CONTACTID,
		.maxcontacts = 2 },
168 169 170
	{ .name = MT_CLS_INRANGE_CONTACTNUMBER,
		.quirks = MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTNUMBER },
171 172 173 174 175 176 177 178 179

	/*
	 * vendor specific classes
	 */
	{ .name = MT_CLS_3M,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
			MT_QUIRK_SLOT_IS_CONTACTID,
		.sn_move = 2048,
		.sn_width = 128,
180 181 182
		.sn_height = 128,
		.maxcontacts = 60,
	},
183 184 185 186
	{ .name = MT_CLS_CYPRESS,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
			MT_QUIRK_CYPRESS,
		.maxcontacts = 10 },
187 188
	{ .name = MT_CLS_EGALAX,
		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
189
			MT_QUIRK_VALID_IS_INRANGE,
190 191 192
		.sn_move = 4096,
		.sn_pressure = 32,
	},
193 194 195
	{ .name = MT_CLS_EGALAX_SERIAL,
		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
			MT_QUIRK_ALWAYS_VALID,
196 197 198
		.sn_move = 4096,
		.sn_pressure = 32,
	},
199 200 201 202 203
	{ .name = MT_CLS_TOPSEED,
		.quirks = MT_QUIRK_ALWAYS_VALID,
		.is_indirect = true,
		.maxcontacts = 2,
	},
204 205 206
	{ .name = MT_CLS_PANASONIC,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
		.maxcontacts = 4 },
207 208 209 210 211 212 213 214
	{ .name	= MT_CLS_GENERALTOUCH_TWOFINGERS,
		.quirks	= MT_QUIRK_NOT_SEEN_MEANS_UP |
			MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTNUMBER,
		.maxcontacts = 2
	},
	{ .name	= MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
		.quirks	= MT_QUIRK_NOT_SEEN_MEANS_UP |
215
			MT_QUIRK_SLOT_IS_CONTACTNUMBER
216
	},
217

218 219 220 221 222 223
	{ .name = MT_CLS_FLATFROG,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
			MT_QUIRK_NO_AREA,
		.sn_move = 2048,
		.maxcontacts = 40,
	},
224
	{ }
225 226
};

227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
static ssize_t mt_show_quirks(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
	struct mt_device *td = hid_get_drvdata(hdev);

	return sprintf(buf, "%u\n", td->mtclass.quirks);
}

static ssize_t mt_set_quirks(struct device *dev,
			  struct device_attribute *attr,
			  const char *buf, size_t count)
{
	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
	struct mt_device *td = hid_get_drvdata(hdev);

	unsigned long val;

	if (kstrtoul(buf, 0, &val))
		return -EINVAL;

	td->mtclass.quirks = val;

	return count;
}

static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);

static struct attribute *sysfs_attrs[] = {
	&dev_attr_quirks.attr,
	NULL
};

static struct attribute_group mt_attribute_group = {
	.attrs = sysfs_attrs
};

265
static void mt_feature_mapping(struct hid_device *hdev,
266 267
		struct hid_field *field, struct hid_usage *usage)
{
268
	struct mt_device *td = hid_get_drvdata(hdev);
269
	int i;
270 271 272

	switch (usage->hid) {
	case HID_DG_INPUTMODE:
273
		td->inputmode = field->report->id;
274 275 276 277 278 279 280 281 282
		td->inputmode_index = 0; /* has to be updated below */

		for (i=0; i < field->maxusage; i++) {
			if (field->usage[i].hid == usage->hid) {
				td->inputmode_index = i;
				break;
			}
		}

283 284
		break;
	case HID_DG_CONTACTMAX:
285
		td->maxcontact_report_id = field->report->id;
286
		td->maxcontacts = field->value[0];
287 288 289
		if (!td->maxcontacts &&
		    field->logical_maximum <= MT_MAX_MAXCONTACT)
			td->maxcontacts = field->logical_maximum;
290
		if (td->mtclass.maxcontacts)
291
			/* check if the maxcontacts is given by the class */
292
			td->maxcontacts = td->mtclass.maxcontacts;
293 294

		break;
295 296 297 298 299 300 301 302 303 304
	}
}

static void set_abs(struct input_dev *input, unsigned int code,
		struct hid_field *field, int snratio)
{
	int fmin = field->logical_minimum;
	int fmax = field->logical_maximum;
	int fuzz = snratio ? (fmax - fmin) / snratio : 0;
	input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
305
	input_abs_set_res(input, code, hidinput_calc_abs_res(field, code));
306 307
}

308
static void mt_store_field(struct hid_usage *usage, struct mt_device *td,
309 310
		struct hid_input *hi)
{
311 312 313 314 315 316
	struct mt_fields *f = td->fields;

	if (f->length >= HID_MAX_FIELDS)
		return;

	f->usages[f->length++] = usage->hid;
317 318
}

319 320 321 322 323
static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	struct mt_device *td = hid_get_drvdata(hdev);
324
	struct mt_class *cls = &td->mtclass;
325
	int code;
326
	struct hid_usage *prev_usage = NULL;
327

328
	/* Only map fields from TouchScreen or TouchPad collections.
329 330
	* We need to ignore fields that belong to other collections
	* such as Mouse that might have the same GenericDesktop usages. */
331
	if (field->application == HID_DG_TOUCHSCREEN)
332
		td->mt_flags |= INPUT_MT_DIRECT;
333
	else if (field->application != HID_DG_TOUCHPAD)
334 335
		return 0;

336 337
	/*
	 * Model touchscreens providing buttons as touchpads.
338 339
	 */
	if (field->application == HID_DG_TOUCHPAD ||
340 341
	    (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
		td->mt_flags |= INPUT_MT_POINTER;
342

343 344 345 346 347 348
	/* eGalax devices provide a Digitizer.Stylus input which overrides
	 * the correct Digitizers.Finger X/Y ranges.
	 * Let's just ignore this input. */
	if (field->physical == HID_DG_STYLUS)
		return -1;

349 350 351
	if (usage->usage_index)
		prev_usage = &field->usage[usage->usage_index - 1];

352 353 354 355 356
	switch (usage->hid & HID_USAGE_PAGE) {

	case HID_UP_GENDESK:
		switch (usage->hid) {
		case HID_GD_X:
357 358 359 360 361 362 363
			if (prev_usage && (prev_usage->hid == usage->hid)) {
				hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TOOL_X);
				set_abs(hi->input, ABS_MT_TOOL_X, field,
					cls->sn_move);
			} else {
				hid_map_usage(hi, usage, bit, max,
364
					EV_ABS, ABS_MT_POSITION_X);
365 366 367 368
				set_abs(hi->input, ABS_MT_POSITION_X, field,
					cls->sn_move);
			}

369
			mt_store_field(usage, td, hi);
370
			td->last_field_index = field->index;
371 372
			return 1;
		case HID_GD_Y:
373 374 375 376 377 378 379
			if (prev_usage && (prev_usage->hid == usage->hid)) {
				hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TOOL_Y);
				set_abs(hi->input, ABS_MT_TOOL_Y, field,
					cls->sn_move);
			} else {
				hid_map_usage(hi, usage, bit, max,
380
					EV_ABS, ABS_MT_POSITION_Y);
381 382 383 384
				set_abs(hi->input, ABS_MT_POSITION_Y, field,
					cls->sn_move);
			}

385
			mt_store_field(usage, td, hi);
386
			td->last_field_index = field->index;
387 388 389 390 391 392 393
			return 1;
		}
		return 0;

	case HID_UP_DIGITIZER:
		switch (usage->hid) {
		case HID_DG_INRANGE:
394
			mt_store_field(usage, td, hi);
395
			td->last_field_index = field->index;
396 397
			return 1;
		case HID_DG_CONFIDENCE:
398
			mt_store_field(usage, td, hi);
399
			td->last_field_index = field->index;
400 401 402 403
			return 1;
		case HID_DG_TIPSWITCH:
			hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
			input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
404
			mt_store_field(usage, td, hi);
405
			td->last_field_index = field->index;
406 407
			return 1;
		case HID_DG_CONTACTID:
408
			mt_store_field(usage, td, hi);
409
			td->last_field_index = field->index;
410
			td->touches_by_report++;
411 412 413 414
			return 1;
		case HID_DG_WIDTH:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TOUCH_MAJOR);
415 416 417
			if (!(cls->quirks & MT_QUIRK_NO_AREA))
				set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
					cls->sn_width);
418
			mt_store_field(usage, td, hi);
419
			td->last_field_index = field->index;
420 421 422 423
			return 1;
		case HID_DG_HEIGHT:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TOUCH_MINOR);
424 425 426 427
			if (!(cls->quirks & MT_QUIRK_NO_AREA)) {
				set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
					cls->sn_height);
				input_set_abs_params(hi->input,
428
					ABS_MT_ORIENTATION, 0, 1, 0, 0);
429
			}
430
			mt_store_field(usage, td, hi);
431
			td->last_field_index = field->index;
432 433 434 435 436 437
			return 1;
		case HID_DG_TIPPRESSURE:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_PRESSURE);
			set_abs(hi->input, ABS_MT_PRESSURE, field,
				cls->sn_pressure);
438
			mt_store_field(usage, td, hi);
439
			td->last_field_index = field->index;
440 441
			return 1;
		case HID_DG_CONTACTCOUNT:
442
			td->last_field_index = field->index;
443 444 445 446
			return 1;
		case HID_DG_CONTACTMAX:
			/* we don't set td->last_slot_field as contactcount and
			 * contact max are global to the report */
447
			td->last_field_index = field->index;
448
			return -1;
449 450 451 452
		case HID_DG_TOUCH:
			/* Legacy devices use TIPSWITCH and not TOUCH.
			 * Let's just ignore this field. */
			return -1;
453
		}
454 455 456
		/* let hid-input decide for the others */
		return 0;

457 458 459 460 461 462
	case HID_UP_BUTTON:
		code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
		hid_map_usage(hi, usage, bit, max, EV_KEY, code);
		input_set_capability(hi->input, EV_KEY, code);
		return 1;

463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
	case 0xff000000:
		/* we do not want to map these: no input-oriented meaning */
		return -1;
	}

	return 0;
}

static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	if (usage->type == EV_KEY || usage->type == EV_ABS)
		set_bit(usage->type, hi->input->evbit);

	return -1;
}

481
static int mt_compute_slot(struct mt_device *td, struct input_dev *input)
482
{
483
	__s32 quirks = td->mtclass.quirks;
484

485 486
	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
		return td->curdata.contactid;
487

488
	if (quirks & MT_QUIRK_CYPRESS)
489 490
		return cypress_compute_slot(td);

491 492
	if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
		return td->num_received;
493

494 495 496
	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
		return td->curdata.contactid - 1;

497
	return input_mt_get_slot_by_key(input, td->curdata.contactid);
498 499 500 501 502 503
}

/*
 * this function is called when a whole contact has been processed,
 * so that it can assign it to a slot and store the data there
 */
504
static void mt_complete_slot(struct mt_device *td, struct input_dev *input)
505
{
506
	if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) {
507 508
		int slotnum = mt_compute_slot(td, input);
		struct mt_slot *s = &td->curdata;
509
		struct input_mt *mt = input->mt;
510

511 512
		if (slotnum < 0 || slotnum >= td->maxcontacts)
			return;
513

514 515 516 517 518 519 520
		if ((td->mtclass.quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) {
			struct input_mt_slot *slot = &mt->slots[slotnum];
			if (input_mt_is_active(slot) &&
			    input_mt_is_used(mt, slot))
				return;
		}

521
		input_mt_slot(input, slotnum);
522 523
		input_mt_report_slot_state(input, MT_TOOL_FINGER,
			s->touch_state);
524
		if (s->touch_state) {
525 526 527 528 529 530
			/* this finger is on the screen */
			int wide = (s->w > s->h);
			/* divided by two to match visual scale of touch */
			int major = max(s->w, s->h) >> 1;
			int minor = min(s->w, s->h) >> 1;

531 532
			input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
			input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
533 534
			input_event(input, EV_ABS, ABS_MT_TOOL_X, s->cx);
			input_event(input, EV_ABS, ABS_MT_TOOL_Y, s->cy);
535
			input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
536
			input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
537 538
			input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
			input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
539
		}
540 541
	}

542 543 544 545 546 547 548 549 550
	td->num_received++;
}

/*
 * this function is called when a whole packet has been received and processed,
 * so that it can decide what to send to the input layer.
 */
static void mt_sync_frame(struct mt_device *td, struct input_dev *input)
{
551
	input_mt_sync_frame(input);
552 553 554 555 556 557 558 559
	input_sync(input);
	td->num_received = 0;
}

static int mt_event(struct hid_device *hid, struct hid_field *field,
				struct hid_usage *usage, __s32 value)
{
	struct mt_device *td = hid_get_drvdata(hid);
560
	__s32 quirks = td->mtclass.quirks;
561

562
	if (hid->claimed & HID_CLAIMED_INPUT) {
563 564
		switch (usage->hid) {
		case HID_DG_INRANGE:
565
			if (quirks & MT_QUIRK_VALID_IS_INRANGE)
566
				td->curvalid = value;
567 568
			break;
		case HID_DG_TIPSWITCH:
569 570
			if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
				td->curvalid = value;
571 572 573
			td->curdata.touch_state = value;
			break;
		case HID_DG_CONFIDENCE:
574 575
			if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
				td->curvalid = value;
576 577 578 579 580 581 582 583
			break;
		case HID_DG_CONTACTID:
			td->curdata.contactid = value;
			break;
		case HID_DG_TIPPRESSURE:
			td->curdata.p = value;
			break;
		case HID_GD_X:
584 585 586 587
			if (usage->code == ABS_MT_TOOL_X)
				td->curdata.cx = value;
			else
				td->curdata.x = value;
588 589
			break;
		case HID_GD_Y:
590 591 592 593
			if (usage->code == ABS_MT_TOOL_Y)
				td->curdata.cy = value;
			else
				td->curdata.y = value;
594 595 596 597 598 599 600 601 602
			break;
		case HID_DG_WIDTH:
			td->curdata.w = value;
			break;
		case HID_DG_HEIGHT:
			td->curdata.h = value;
			break;
		case HID_DG_CONTACTCOUNT:
			/*
603 604
			 * Includes multi-packet support where subsequent
			 * packets are sent with zero contactcount.
605 606
			 */
			if (value)
607
				td->num_expected = value;
608
			break;
609 610 611
		case HID_DG_TOUCH:
			/* do nothing */
			break;
612 613 614 615 616 617

		default:
			/* fallback to the generic hidinput handling */
			return 0;
		}

618 619 620 621 622 623 624 625 626
		if (usage->usage_index + 1 == field->report_count) {
			/* we only take into account the last report. */
			if (usage->hid == td->last_slot_field)
				mt_complete_slot(td, field->hidinput->input);

			if (field->index == td->last_field_index
				&& td->num_received >= td->num_expected)
				mt_sync_frame(td, field->hidinput->input);
		}
627

628
	}
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648

	/* we have handled the hidinput part, now remains hiddev */
	if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
		hid->hiddev_hid_event(hid, field, usage, value);

	return 1;
}

static void mt_set_input_mode(struct hid_device *hdev)
{
	struct mt_device *td = hid_get_drvdata(hdev);
	struct hid_report *r;
	struct hid_report_enum *re;

	if (td->inputmode < 0)
		return;

	re = &(hdev->report_enum[HID_FEATURE_REPORT]);
	r = re->report_id_hash[td->inputmode];
	if (r) {
649
		r->field[0]->value[td->inputmode_index] = 0x02;
650 651 652 653
		usbhid_submit_report(hdev, r, USB_DIR_OUT);
	}
}

654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
static void mt_set_maxcontacts(struct hid_device *hdev)
{
	struct mt_device *td = hid_get_drvdata(hdev);
	struct hid_report *r;
	struct hid_report_enum *re;
	int fieldmax, max;

	if (td->maxcontact_report_id < 0)
		return;

	if (!td->mtclass.maxcontacts)
		return;

	re = &hdev->report_enum[HID_FEATURE_REPORT];
	r = re->report_id_hash[td->maxcontact_report_id];
	if (r) {
		max = td->mtclass.maxcontacts;
		fieldmax = r->field[0]->logical_maximum;
		max = min(fieldmax, max);
		if (r->field[0]->value[0] != max) {
			r->field[0]->value[0] = max;
			usbhid_submit_report(hdev, r, USB_DIR_OUT);
		}
	}
}

680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
static void mt_post_parse_default_settings(struct mt_device *td)
{
	__s32 quirks = td->mtclass.quirks;

	/* unknown serial device needs special quirks */
	if (td->touches_by_report == 1) {
		quirks |= MT_QUIRK_ALWAYS_VALID;
		quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
		quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
		quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;
	}

	td->mtclass.quirks = quirks;
}

695 696 697 698 699 700 701 702 703 704
static void mt_post_parse(struct mt_device *td)
{
	struct mt_fields *f = td->fields;

	if (td->touches_by_report > 0) {
		int field_count_per_touch = f->length / td->touches_by_report;
		td->last_slot_field = f->usages[field_count_per_touch - 1];
	}
}

705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
static void mt_input_configured(struct hid_device *hdev, struct hid_input *hi)

{
	struct mt_device *td = hid_get_drvdata(hdev);
	struct mt_class *cls = &td->mtclass;
	struct input_dev *input = hi->input;

	/* Only initialize slots for MT input devices */
	if (!test_bit(ABS_MT_POSITION_X, input->absbit))
		return;

	if (!td->maxcontacts)
		td->maxcontacts = MT_DEFAULT_MAXCONTACT;

	mt_post_parse(td);
	if (td->serial_maybe)
		mt_post_parse_default_settings(td);

	if (cls->is_indirect)
		td->mt_flags |= INPUT_MT_POINTER;

726 727 728
	if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
		td->mt_flags |= INPUT_MT_DROP_UNUSED;

729 730 731 732 733
	input_mt_init_slots(input, td->maxcontacts, td->mt_flags);

	td->mt_flags = 0;
}

734 735
static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
736
	int ret, i;
737
	struct mt_device *td;
738 739
	struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */

740 741 742 743
	for (i = 0; mt_classes[i].name ; i++) {
		if (id->driver_data == mt_classes[i].name) {
			mtclass = &(mt_classes[i]);
			break;
744 745
		}
	}
746

747 748 749 750
	/* This allows the driver to correctly support devices
	 * that emit events over several HID messages.
	 */
	hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
751

752
	td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
753 754 755 756
	if (!td) {
		dev_err(&hdev->dev, "cannot allocate multitouch data\n");
		return -ENOMEM;
	}
757
	td->mtclass = *mtclass;
758
	td->inputmode = -1;
759
	td->maxcontact_report_id = -1;
760 761
	hid_set_drvdata(hdev, td);

762 763 764 765 766 767 768
	td->fields = kzalloc(sizeof(struct mt_fields), GFP_KERNEL);
	if (!td->fields) {
		dev_err(&hdev->dev, "cannot allocate multitouch fields data\n");
		ret = -ENOMEM;
		goto fail;
	}

769 770 771
	if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
		td->serial_maybe = true;

772 773 774 775 776
	ret = hid_parse(hdev);
	if (ret != 0)
		goto fail;

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
777
	if (ret)
778 779
		goto fail;

780 781
	ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);

782
	mt_set_maxcontacts(hdev);
783 784
	mt_set_input_mode(hdev);

785 786 787
	kfree(td->fields);
	td->fields = NULL;

788 789 790
	return 0;

fail:
791
	kfree(td->fields);
792 793 794 795 796 797 798
	kfree(td);
	return ret;
}

#ifdef CONFIG_PM
static int mt_reset_resume(struct hid_device *hdev)
{
799
	mt_set_maxcontacts(hdev);
800 801 802
	mt_set_input_mode(hdev);
	return 0;
}
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828

static int mt_resume(struct hid_device *hdev)
{
	struct usb_interface *intf;
	struct usb_host_interface *interface;
	struct usb_device *dev;

	if (hdev->bus != BUS_USB)
		return 0;

	intf = to_usb_interface(hdev->dev.parent);
	interface = intf->cur_altsetting;
	dev = hid_to_usb_dev(hdev);

	/* Some Elan legacy devices require SET_IDLE to be set on resume.
	 * It should be safe to send it to other devices too.
	 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */

	usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			HID_REQ_SET_IDLE,
			USB_TYPE_CLASS | USB_RECIP_INTERFACE,
			0, interface->desc.bInterfaceNumber,
			NULL, 0, USB_CTRL_SET_TIMEOUT);

	return 0;
}
829 830 831 832 833
#endif

static void mt_remove(struct hid_device *hdev)
{
	struct mt_device *td = hid_get_drvdata(hdev);
834
	sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
835 836 837 838 839 840 841
	hid_hw_stop(hdev);
	kfree(td);
	hid_set_drvdata(hdev, NULL);
}

static const struct hid_device_id mt_devices[] = {

842 843
	/* 3M panels */
	{ .driver_data = MT_CLS_3M,
844
		MT_USB_DEVICE(USB_VENDOR_ID_3M,
845 846
			USB_DEVICE_ID_3M1968) },
	{ .driver_data = MT_CLS_3M,
847
		MT_USB_DEVICE(USB_VENDOR_ID_3M,
848
			USB_DEVICE_ID_3M2256) },
849
	{ .driver_data = MT_CLS_3M,
850
		MT_USB_DEVICE(USB_VENDOR_ID_3M,
851
			USB_DEVICE_ID_3M3266) },
852

853 854
	/* ActionStar panels */
	{ .driver_data = MT_CLS_DEFAULT,
855
		MT_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
856 857
			USB_DEVICE_ID_ACTIONSTAR_1011) },

858 859
	/* Atmel panels */
	{ .driver_data = MT_CLS_SERIAL,
860
		MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
861
			USB_DEVICE_ID_ATMEL_MULTITOUCH) },
862
	{ .driver_data = MT_CLS_SERIAL,
863
		MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
864
			USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
865

866 867
	/* Baanto multitouch devices */
	{ .driver_data = MT_CLS_DEFAULT,
868
		MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
869
			USB_DEVICE_ID_BAANTO_MT_190W2) },
870 871
	/* Cando panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
872
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
873 874
			USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
875
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
876 877
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
878
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
879 880
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
881
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
882 883
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },

884 885
	/* Chunghwa Telecom touch panels */
	{  .driver_data = MT_CLS_DEFAULT,
886
		MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
887 888
			USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },

889 890
	/* CVTouch panels */
	{ .driver_data = MT_CLS_DEFAULT,
891
		MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
892 893
			USB_DEVICE_ID_CVTOUCH_SCREEN) },

894 895 896 897 898
	/* Cypress panel */
	{ .driver_data = MT_CLS_CYPRESS,
		HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
			USB_DEVICE_ID_CYPRESS_TRUETOUCH) },

899
	/* eGalax devices (resistive) */
900
	{ .driver_data = MT_CLS_EGALAX,
901
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
902 903
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
	{ .driver_data = MT_CLS_EGALAX,
904
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
905
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
906 907

	/* eGalax devices (capacitive) */
908
	{ .driver_data = MT_CLS_EGALAX,
909
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
910
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
911
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
912
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
913 914
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
915
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
916 917
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
918
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
919
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
920
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
921
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
922
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
923
	{ .driver_data = MT_CLS_EGALAX,
924
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
925
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
926
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
927
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
928
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
929
	{ .driver_data = MT_CLS_EGALAX,
930
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
931
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
932
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
933
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
934
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
935
	{ .driver_data = MT_CLS_EGALAX,
936
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
937
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
938
	{ .driver_data = MT_CLS_EGALAX,
939
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
940
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
941
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
942
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
943
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
944
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
945 946
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) },
947
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
948
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
949
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
950 951 952 953 954 955 956 957 958
	{ .driver_data = MT_CLS_EGALAX,
		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
	{ .driver_data = MT_CLS_EGALAX,
		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
	{ .driver_data = MT_CLS_EGALAX,
		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
959

960 961
	/* Elo TouchSystems IntelliTouch Plus panel */
	{ .driver_data = MT_CLS_DUAL_NSMU_CONTACTID,
962
		MT_USB_DEVICE(USB_VENDOR_ID_ELO,
963 964
			USB_DEVICE_ID_ELO_TS2515) },

965 966 967 968 969
	/* Flatfrog Panels */
	{ .driver_data = MT_CLS_FLATFROG,
		MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG,
			USB_DEVICE_ID_MULTITOUCH_3200) },

970
	/* GeneralTouch panel */
971
	{ .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
972
		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
973
			USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
974 975 976
	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) },
977

978 979
	/* Gametel game controller */
	{ .driver_data = MT_CLS_DEFAULT,
980
		MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
981 982
			USB_DEVICE_ID_GAMETEL_MT_MODE) },

983 984
	/* GoodTouch panels */
	{ .driver_data = MT_CLS_DEFAULT,
985
		MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
986 987
			USB_DEVICE_ID_GOODTOUCH_000f) },

988 989
	/* Hanvon panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
990
		MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
991 992
			USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },

993 994
	/* Ideacom panel */
	{ .driver_data = MT_CLS_SERIAL,
995
		MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
996
			USB_DEVICE_ID_IDEACOM_IDC6650) },
997
	{ .driver_data = MT_CLS_SERIAL,
998
		MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
999
			USB_DEVICE_ID_IDEACOM_IDC6651) },
1000

1001 1002
	/* Ilitek dual touch panel */
	{  .driver_data = MT_CLS_DEFAULT,
1003
		MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
1004 1005
			USB_DEVICE_ID_ILITEK_MULTITOUCH) },

1006 1007
	/* IRTOUCH panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1008
		MT_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
1009 1010
			USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },

1011 1012
	/* LG Display panels */
	{ .driver_data = MT_CLS_DEFAULT,
1013
		MT_USB_DEVICE(USB_VENDOR_ID_LG,
1014 1015
			USB_DEVICE_ID_LG_MULTITOUCH) },

1016 1017
	/* Lumio panels */
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1018
		MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
1019
			USB_DEVICE_ID_CRYSTALTOUCH) },
1020
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1021
		MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
1022
			USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
1023

1024 1025
	/* MosArt panels */
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1026
		MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
1027 1028
			USB_DEVICE_ID_ASUS_T91MT)},
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1029
		MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
1030 1031
			USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1032
		MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
1033 1034
			USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },

1035 1036
	/* Panasonic panels */
	{ .driver_data = MT_CLS_PANASONIC,
1037
		MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
1038 1039
			USB_DEVICE_ID_PANABOARD_UBT780) },
	{ .driver_data = MT_CLS_PANASONIC,
1040
		MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
1041 1042
			USB_DEVICE_ID_PANABOARD_UBT880) },

1043 1044
	/* Novatek Panel */
	{ .driver_data = MT_CLS_DEFAULT,
1045
		MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
1046 1047
			USB_DEVICE_ID_NOVATEK_PCT) },

1048 1049
	/* PenMount panels */
	{ .driver_data = MT_CLS_CONFIDENCE,
1050
		MT_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
1051 1052
			USB_DEVICE_ID_PENMOUNT_PCI) },

1053 1054
	/* PixArt optical touch screen */
	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1055
		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1056 1057
			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1058
		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1059 1060
			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1061
		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1062 1063
			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },

1064
	/* PixCir-based panels */
1065
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1066
		MT_USB_DEVICE(USB_VENDOR_ID_HANVON,
1067
			USB_DEVICE_ID_HANVON_MULTITOUCH) },
1068
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1069
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1070 1071
			USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },

1072 1073
	/* Quanta-based panels */
	{ .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1074
		MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1075 1076
			USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
	{ .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1077
		MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1078 1079
			USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
	{ .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1080
		MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1081 1082
			USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) },

1083
	/* Stantum panels */
1084
	{ .driver_data = MT_CLS_CONFIDENCE,
1085
		MT_USB_DEVICE(USB_VENDOR_ID_STANTUM,
1086
			USB_DEVICE_ID_MTP)},
1087
	{ .driver_data = MT_CLS_CONFIDENCE,
1088
		MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
1089
			USB_DEVICE_ID_MTP_STM)},
1090
	{ .driver_data = MT_CLS_CONFIDENCE,
1091
		MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX,
1092 1093
			USB_DEVICE_ID_MTP_SITRONIX)},

1094 1095
	/* TopSeed panels */
	{ .driver_data = MT_CLS_TOPSEED,
1096
		MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
1097 1098
			USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },

1099 1100
	/* Touch International panels */
	{ .driver_data = MT_CLS_DEFAULT,
1101
		MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
1102 1103
			USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },

1104 1105
	/* Unitec panels */
	{ .driver_data = MT_CLS_DEFAULT,
1106
		MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
1107 1108
			USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
	{ .driver_data = MT_CLS_DEFAULT,
1109
		MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
1110
			USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
1111 1112
	/* XAT */
	{ .driver_data = MT_CLS_DEFAULT,
1113
		MT_USB_DEVICE(USB_VENDOR_ID_XAT,
1114
			USB_DEVICE_ID_XAT_CSR) },
1115

1116 1117
	/* Xiroku */
	{ .driver_data = MT_CLS_DEFAULT,
1118
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1119 1120
			USB_DEVICE_ID_XIROKU_SPX) },
	{ .driver_data = MT_CLS_DEFAULT,
1121
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1122 1123
			USB_DEVICE_ID_XIROKU_MPX) },
	{ .driver_data = MT_CLS_DEFAULT,
1124
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1125 1126
			USB_DEVICE_ID_XIROKU_CSR) },
	{ .driver_data = MT_CLS_DEFAULT,
1127
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1128 1129
			USB_DEVICE_ID_XIROKU_SPX1) },
	{ .driver_data = MT_CLS_DEFAULT,
1130
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1131 1132
			USB_DEVICE_ID_XIROKU_MPX1) },
	{ .driver_data = MT_CLS_DEFAULT,
1133
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1134 1135
			USB_DEVICE_ID_XIROKU_CSR1) },
	{ .driver_data = MT_CLS_DEFAULT,
1136
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1137 1138
			USB_DEVICE_ID_XIROKU_SPX2) },
	{ .driver_data = MT_CLS_DEFAULT,
1139
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1140 1141
			USB_DEVICE_ID_XIROKU_MPX2) },
	{ .driver_data = MT_CLS_DEFAULT,
1142
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1143 1144
			USB_DEVICE_ID_XIROKU_CSR2) },

1145 1146 1147 1148 1149
	/* Zytronic panels */
	{ .driver_data = MT_CLS_SERIAL,
		MT_USB_DEVICE(USB_VENDOR_ID_ZYTRONIC,
			USB_DEVICE_ID_ZYTRONIC_ZXY100) },

1150 1151
	/* Generic MT device */
	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
	{ }
};
MODULE_DEVICE_TABLE(hid, mt_devices);

static const struct hid_usage_id mt_grabbed_usages[] = {
	{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
	{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
};

static struct hid_driver mt_driver = {
	.name = "hid-multitouch",
	.id_table = mt_devices,
	.probe = mt_probe,
	.remove = mt_remove,
	.input_mapping = mt_input_mapping,
	.input_mapped = mt_input_mapped,
1168
	.input_configured = mt_input_configured,
1169 1170 1171 1172 1173
	.feature_mapping = mt_feature_mapping,
	.usage_table = mt_grabbed_usages,
	.event = mt_event,
#ifdef CONFIG_PM
	.reset_resume = mt_reset_resume,
1174
	.resume = mt_resume,
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
#endif
};

static int __init mt_init(void)
{
	return hid_register_driver(&mt_driver);
}

static void __exit mt_exit(void)
{
	hid_unregister_driver(&mt_driver);
}

module_init(mt_init);
module_exit(mt_exit);