hid-multitouch.c 30.9 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 55 56 57 58 59 60 61

struct mt_slot {
	__s32 x, y, p, w, h;
	__s32 contactid;	/* the device ContactID assigned to this slot */
	bool touch_state;	/* is the touch valid? */
	bool seen_in_this_frame;/* has this slot been updated */
};

62 63 64 65 66 67 68 69
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;
70
	bool is_indirect;	/* true for touchpads */
71 72
};

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

78 79
struct mt_device {
	struct mt_slot curdata;	/* placeholder of incoming data */
80
	struct mt_class mtclass;	/* our mt device class */
81 82
	struct mt_fields *fields;	/* temporary placeholder for storing the
					   multitouch fields */
83 84 85
	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 */
86
	__s8 inputmode_index;	/* InputMode HID feature index in the report */
87 88
	__s8 maxcontact_report_id;	/* Maximum Contact Number HID feature,
				   -1 if non-existent */
89 90
	__u8 num_received;	/* how many contacts we received */
	__u8 num_expected;	/* expected last contact index */
91
	__u8 maxcontacts;
92 93 94
	__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 */
95
	bool curvalid;		/* is the current contact valid? */
96
	struct mt_slot *slots;
97 98 99
};

/* classes of device behavior */
100 101
#define MT_CLS_DEFAULT				0x0001

102 103
#define MT_CLS_SERIAL				0x0002
#define MT_CLS_CONFIDENCE			0x0003
104 105 106 107 108
#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
109
#define MT_CLS_INRANGE_CONTACTNUMBER		0x0009
110 111 112 113 114

/* vendor specific classes */
#define MT_CLS_3M				0x0101
#define MT_CLS_CYPRESS				0x0102
#define MT_CLS_EGALAX				0x0103
115
#define MT_CLS_EGALAX_SERIAL			0x0104
116
#define MT_CLS_TOPSEED				0x0105
117
#define MT_CLS_PANASONIC			0x0106
118

119 120
#define MT_DEFAULT_MAXCONTACT	10

121 122 123
#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)

124 125 126 127 128
/*
 * these device-dependent functions determine what slot corresponds
 * to a valid contact that was just read.
 */

129 130 131 132 133 134 135 136
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;
}

137 138 139
static int find_slot_from_contactid(struct mt_device *td)
{
	int i;
140
	for (i = 0; i < td->maxcontacts; ++i) {
141 142 143 144
		if (td->slots[i].contactid == td->curdata.contactid &&
			td->slots[i].touch_state)
			return i;
	}
145
	for (i = 0; i < td->maxcontacts; ++i) {
146 147 148 149 150 151 152
		if (!td->slots[i].seen_in_this_frame &&
			!td->slots[i].touch_state)
			return i;
	}
	/* should not occurs. If this happens that means
	 * that the device sent more touches that it says
	 * in the report descriptor. It is ignored then. */
153
	return -1;
154 155
}

156
static struct mt_class mt_classes[] = {
157
	{ .name = MT_CLS_DEFAULT,
158
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
159 160
	{ .name = MT_CLS_SERIAL,
		.quirks = MT_QUIRK_ALWAYS_VALID},
161 162
	{ .name = MT_CLS_CONFIDENCE,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
163 164 165
	{ .name = MT_CLS_CONFIDENCE_CONTACT_ID,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
			MT_QUIRK_SLOT_IS_CONTACTID },
166 167 168
	{ .name = MT_CLS_CONFIDENCE_MINUS_ONE,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
			MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
169
	{ .name = MT_CLS_DUAL_INRANGE_CONTACTID,
170 171 172
		.quirks = MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTID,
		.maxcontacts = 2 },
173
	{ .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
174 175 176
		.quirks = MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTNUMBER,
		.maxcontacts = 2 },
177 178 179 180
	{ .name = MT_CLS_DUAL_NSMU_CONTACTID,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
			MT_QUIRK_SLOT_IS_CONTACTID,
		.maxcontacts = 2 },
181 182 183
	{ .name = MT_CLS_INRANGE_CONTACTNUMBER,
		.quirks = MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTNUMBER },
184 185 186 187 188 189 190 191 192 193

	/*
	 * vendor specific classes
	 */
	{ .name = MT_CLS_3M,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
			MT_QUIRK_SLOT_IS_CONTACTID,
		.sn_move = 2048,
		.sn_width = 128,
		.sn_height = 128 },
194 195 196 197
	{ .name = MT_CLS_CYPRESS,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
			MT_QUIRK_CYPRESS,
		.maxcontacts = 10 },
198 199
	{ .name = MT_CLS_EGALAX,
		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
200
			MT_QUIRK_VALID_IS_INRANGE,
201 202 203
		.sn_move = 4096,
		.sn_pressure = 32,
	},
204 205 206
	{ .name = MT_CLS_EGALAX_SERIAL,
		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
			MT_QUIRK_ALWAYS_VALID,
207 208 209
		.sn_move = 4096,
		.sn_pressure = 32,
	},
210 211 212 213 214
	{ .name = MT_CLS_TOPSEED,
		.quirks = MT_QUIRK_ALWAYS_VALID,
		.is_indirect = true,
		.maxcontacts = 2,
	},
215 216 217
	{ .name = MT_CLS_PANASONIC,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
		.maxcontacts = 4 },
218

219
	{ }
220 221
};

222 223 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
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
};

260
static void mt_feature_mapping(struct hid_device *hdev,
261 262
		struct hid_field *field, struct hid_usage *usage)
{
263
	struct mt_device *td = hid_get_drvdata(hdev);
264
	int i;
265 266 267

	switch (usage->hid) {
	case HID_DG_INPUTMODE:
268
		td->inputmode = field->report->id;
269 270 271 272 273 274 275 276 277
		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;
			}
		}

278 279
		break;
	case HID_DG_CONTACTMAX:
280
		td->maxcontact_report_id = field->report->id;
281
		td->maxcontacts = field->value[0];
282
		if (td->mtclass.maxcontacts)
283
			/* check if the maxcontacts is given by the class */
284
			td->maxcontacts = td->mtclass.maxcontacts;
285 286

		break;
287 288 289 290 291 292 293 294 295 296 297 298
	}
}

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);
}

299
static void mt_store_field(struct hid_usage *usage, struct mt_device *td,
300 301
		struct hid_input *hi)
{
302 303 304 305 306 307
	struct mt_fields *f = td->fields;

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

	f->usages[f->length++] = usage->hid;
308 309
}

310 311 312 313 314
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);
315
	struct mt_class *cls = &td->mtclass;
316
	int code;
317

318
	/* Only map fields from TouchScreen or TouchPad collections.
319 320
	* We need to ignore fields that belong to other collections
	* such as Mouse that might have the same GenericDesktop usages. */
321 322
	if (field->application == HID_DG_TOUCHSCREEN)
		set_bit(INPUT_PROP_DIRECT, hi->input->propbit);
323
	else if (field->application != HID_DG_TOUCHPAD)
324 325
		return 0;

326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
	/* In case of an indirect device (touchpad), we need to add
	 * specific BTN_TOOL_* to be handled by the synaptics xorg
	 * driver.
	 * We also consider that touchscreens providing buttons are touchpads.
	 */
	if (field->application == HID_DG_TOUCHPAD ||
	    (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON ||
	    cls->is_indirect) {
		set_bit(INPUT_PROP_POINTER, hi->input->propbit);
		set_bit(BTN_TOOL_FINGER, hi->input->keybit);
		set_bit(BTN_TOOL_DOUBLETAP, hi->input->keybit);
		set_bit(BTN_TOOL_TRIPLETAP, hi->input->keybit);
		set_bit(BTN_TOOL_QUADTAP, hi->input->keybit);
	}

341 342 343 344 345 346
	/* 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;

347 348 349 350 351 352 353 354 355 356 357
	switch (usage->hid & HID_USAGE_PAGE) {

	case HID_UP_GENDESK:
		switch (usage->hid) {
		case HID_GD_X:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_POSITION_X);
			set_abs(hi->input, ABS_MT_POSITION_X, field,
				cls->sn_move);
			/* touchscreen emulation */
			set_abs(hi->input, ABS_X, field, cls->sn_move);
358
			mt_store_field(usage, td, hi);
359
			td->last_field_index = field->index;
360 361 362 363 364 365 366 367
			return 1;
		case HID_GD_Y:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_POSITION_Y);
			set_abs(hi->input, ABS_MT_POSITION_Y, field,
				cls->sn_move);
			/* touchscreen emulation */
			set_abs(hi->input, ABS_Y, field, cls->sn_move);
368
			mt_store_field(usage, td, hi);
369
			td->last_field_index = field->index;
370 371 372 373 374 375 376
			return 1;
		}
		return 0;

	case HID_UP_DIGITIZER:
		switch (usage->hid) {
		case HID_DG_INRANGE:
377
			mt_store_field(usage, td, hi);
378
			td->last_field_index = field->index;
379 380
			return 1;
		case HID_DG_CONFIDENCE:
381
			mt_store_field(usage, td, hi);
382
			td->last_field_index = field->index;
383 384 385 386
			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);
387
			mt_store_field(usage, td, hi);
388
			td->last_field_index = field->index;
389 390
			return 1;
		case HID_DG_CONTACTID:
391 392
			if (!td->maxcontacts)
				td->maxcontacts = MT_DEFAULT_MAXCONTACT;
393
			input_mt_init_slots(hi->input, td->maxcontacts);
394
			mt_store_field(usage, td, hi);
395
			td->last_field_index = field->index;
396
			td->touches_by_report++;
397 398 399 400
			return 1;
		case HID_DG_WIDTH:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TOUCH_MAJOR);
401 402
			set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
				cls->sn_width);
403
			mt_store_field(usage, td, hi);
404
			td->last_field_index = field->index;
405 406 407 408
			return 1;
		case HID_DG_HEIGHT:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TOUCH_MINOR);
409 410
			set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
				cls->sn_height);
411 412
			input_set_abs_params(hi->input,
					ABS_MT_ORIENTATION, 0, 1, 0, 0);
413
			mt_store_field(usage, td, hi);
414
			td->last_field_index = field->index;
415 416 417 418 419 420 421 422 423
			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);
			/* touchscreen emulation */
			set_abs(hi->input, ABS_PRESSURE, field,
				cls->sn_pressure);
424
			mt_store_field(usage, td, hi);
425
			td->last_field_index = field->index;
426 427
			return 1;
		case HID_DG_CONTACTCOUNT:
428
			td->last_field_index = field->index;
429 430 431 432
			return 1;
		case HID_DG_CONTACTMAX:
			/* we don't set td->last_slot_field as contactcount and
			 * contact max are global to the report */
433
			td->last_field_index = field->index;
434 435
			return -1;
		}
436 437 438 439
		case HID_DG_TOUCH:
			/* Legacy devices use TIPSWITCH and not TOUCH.
			 * Let's just ignore this field. */
			return -1;
440 441 442
		/* let hid-input decide for the others */
		return 0;

443 444 445 446 447 448
	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;

449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
	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;
}

static int mt_compute_slot(struct mt_device *td)
{
469
	__s32 quirks = td->mtclass.quirks;
470

471 472
	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
		return td->curdata.contactid;
473

474
	if (quirks & MT_QUIRK_CYPRESS)
475 476
		return cypress_compute_slot(td);

477 478
	if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
		return td->num_received;
479

480 481 482
	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
		return td->curdata.contactid - 1;

483 484 485 486 487 488 489 490 491
	return find_slot_from_contactid(td);
}

/*
 * 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
 */
static void mt_complete_slot(struct mt_device *td)
{
492
	td->curdata.seen_in_this_frame = true;
493 494 495
	if (td->curvalid) {
		int slotnum = mt_compute_slot(td);

496
		if (slotnum >= 0 && slotnum < td->maxcontacts)
497
			td->slots[slotnum] = td->curdata;
498 499 500 501 502 503 504 505 506 507 508 509 510
	}
	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_emit_event(struct mt_device *td, struct input_dev *input)
{
	int i;

511
	for (i = 0; i < td->maxcontacts; ++i) {
512
		struct mt_slot *s = &(td->slots[i]);
513
		if ((td->mtclass.quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
514 515 516 517 518 519 520
			!s->seen_in_this_frame) {
			s->touch_state = false;
		}

		input_mt_slot(input, i);
		input_mt_report_slot_state(input, MT_TOOL_FINGER,
			s->touch_state);
521
		if (s->touch_state) {
522 523 524 525 526 527
			/* 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;

528 529
			input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
			input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
530
			input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
531
			input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
532 533
			input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
			input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
534
		}
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
		s->seen_in_this_frame = false;

	}

	input_mt_report_pointer_emulation(input, true);
	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);
550
	__s32 quirks = td->mtclass.quirks;
551

552
	if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
553 554
		switch (usage->hid) {
		case HID_DG_INRANGE:
555 556 557
			if (quirks & MT_QUIRK_ALWAYS_VALID)
				td->curvalid = true;
			else if (quirks & MT_QUIRK_VALID_IS_INRANGE)
558
				td->curvalid = value;
559 560
			break;
		case HID_DG_TIPSWITCH:
561 562
			if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
				td->curvalid = value;
563 564 565
			td->curdata.touch_state = value;
			break;
		case HID_DG_CONFIDENCE:
566 567
			if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
				td->curvalid = value;
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
			break;
		case HID_DG_CONTACTID:
			td->curdata.contactid = value;
			break;
		case HID_DG_TIPPRESSURE:
			td->curdata.p = value;
			break;
		case HID_GD_X:
			td->curdata.x = value;
			break;
		case HID_GD_Y:
			td->curdata.y = value;
			break;
		case HID_DG_WIDTH:
			td->curdata.w = value;
			break;
		case HID_DG_HEIGHT:
			td->curdata.h = value;
			break;
		case HID_DG_CONTACTCOUNT:
			/*
589 590
			 * Includes multi-packet support where subsequent
			 * packets are sent with zero contactcount.
591 592
			 */
			if (value)
593
				td->num_expected = value;
594
			break;
595 596 597
		case HID_DG_TOUCH:
			/* do nothing */
			break;
598 599 600 601 602 603

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

604
		if (usage->hid == td->last_slot_field)
605 606 607 608 609
			mt_complete_slot(td);

		if (field->index == td->last_field_index
			&& td->num_received >= td->num_expected)
			mt_emit_event(td, field->hidinput->input);
610

611
	}
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631

	/* 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) {
632
		r->field[0]->value[td->inputmode_index] = 0x02;
633 634 635 636
		usbhid_submit_report(hdev, r, USB_DIR_OUT);
	}
}

637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
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);
		}
	}
}

663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
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;
}

678 679 680 681 682 683 684 685 686 687
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];
	}
}

688 689
static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
690
	int ret, i;
691
	struct mt_device *td;
692 693
	struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */

694 695 696 697 698 699
	if (id) {
		for (i = 0; mt_classes[i].name ; i++) {
			if (id->driver_data == mt_classes[i].name) {
				mtclass = &(mt_classes[i]);
				break;
			}
700 701
		}
	}
702

703 704 705 706
	/* This allows the driver to correctly support devices
	 * that emit events over several HID messages.
	 */
	hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
707

708
	td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
709 710 711 712
	if (!td) {
		dev_err(&hdev->dev, "cannot allocate multitouch data\n");
		return -ENOMEM;
	}
713
	td->mtclass = *mtclass;
714
	td->inputmode = -1;
715
	td->maxcontact_report_id = -1;
716 717
	hid_set_drvdata(hdev, td);

718 719 720 721 722 723 724
	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;
	}

725 726 727 728 729
	ret = hid_parse(hdev);
	if (ret != 0)
		goto fail;

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
730
	if (ret)
731 732
		goto fail;

733 734
	mt_post_parse(td);

735 736
	if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
		mt_post_parse_default_settings(td);
737

738 739 740 741 742 743 744 745 746
	td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
				GFP_KERNEL);
	if (!td->slots) {
		dev_err(&hdev->dev, "cannot allocate multitouch slots\n");
		hid_hw_stop(hdev);
		ret = -ENOMEM;
		goto fail;
	}

747 748
	ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);

749
	mt_set_maxcontacts(hdev);
750 751
	mt_set_input_mode(hdev);

752 753 754
	kfree(td->fields);
	td->fields = NULL;

755 756 757
	return 0;

fail:
758
	kfree(td->fields);
759 760 761 762 763 764 765
	kfree(td);
	return ret;
}

#ifdef CONFIG_PM
static int mt_reset_resume(struct hid_device *hdev)
{
766
	mt_set_maxcontacts(hdev);
767 768 769 770 771 772 773 774
	mt_set_input_mode(hdev);
	return 0;
}
#endif

static void mt_remove(struct hid_device *hdev)
{
	struct mt_device *td = hid_get_drvdata(hdev);
775
	sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
776
	hid_hw_stop(hdev);
777
	kfree(td->slots);
778 779 780 781 782 783
	kfree(td);
	hid_set_drvdata(hdev, NULL);
}

static const struct hid_device_id mt_devices[] = {

784 785
	/* 3M panels */
	{ .driver_data = MT_CLS_3M,
786
		MT_USB_DEVICE(USB_VENDOR_ID_3M,
787 788
			USB_DEVICE_ID_3M1968) },
	{ .driver_data = MT_CLS_3M,
789
		MT_USB_DEVICE(USB_VENDOR_ID_3M,
790
			USB_DEVICE_ID_3M2256) },
791
	{ .driver_data = MT_CLS_3M,
792
		MT_USB_DEVICE(USB_VENDOR_ID_3M,
793
			USB_DEVICE_ID_3M3266) },
794

795 796
	/* ActionStar panels */
	{ .driver_data = MT_CLS_DEFAULT,
797
		MT_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
798 799
			USB_DEVICE_ID_ACTIONSTAR_1011) },

800 801
	/* Atmel panels */
	{ .driver_data = MT_CLS_SERIAL,
802
		MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
803
			USB_DEVICE_ID_ATMEL_MULTITOUCH) },
804
	{ .driver_data = MT_CLS_SERIAL,
805
		MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
806
			USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
807

808 809
	/* Baanto multitouch devices */
	{ .driver_data = MT_CLS_DEFAULT,
810
		MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
811
			USB_DEVICE_ID_BAANTO_MT_190W2) },
812 813
	/* Cando panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
814
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
815 816
			USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
817
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
818 819
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
820
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
821 822
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
823
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
824 825
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },

826 827
	/* Chunghwa Telecom touch panels */
	{  .driver_data = MT_CLS_DEFAULT,
828
		MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
829 830
			USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },

831 832
	/* CVTouch panels */
	{ .driver_data = MT_CLS_DEFAULT,
833
		MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
834 835
			USB_DEVICE_ID_CVTOUCH_SCREEN) },

836 837 838 839 840
	/* Cypress panel */
	{ .driver_data = MT_CLS_CYPRESS,
		HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
			USB_DEVICE_ID_CYPRESS_TRUETOUCH) },

841
	/* eGalax devices (resistive) */
842
	{ .driver_data = MT_CLS_EGALAX,
843
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
844 845
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
	{ .driver_data = MT_CLS_EGALAX,
846
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
847
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
848 849

	/* eGalax devices (capacitive) */
850
	{ .driver_data = MT_CLS_EGALAX,
851
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
852
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
853
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
854
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
855 856
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
857
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
858 859
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
860
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
861
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
862
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
863
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
864
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
865
	{ .driver_data = MT_CLS_EGALAX,
866
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
867
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
868
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
869
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
870
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
871
	{ .driver_data = MT_CLS_EGALAX,
872
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
873
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
874
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
875
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
876
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
877
	{ .driver_data = MT_CLS_EGALAX,
878
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
879
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
880
	{ .driver_data = MT_CLS_EGALAX,
881
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
882
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
883
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
884
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
885
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
886
	{ .driver_data = MT_CLS_EGALAX_SERIAL,
887
		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
888
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
889

890 891
	/* Elo TouchSystems IntelliTouch Plus panel */
	{ .driver_data = MT_CLS_DUAL_NSMU_CONTACTID,
892
		MT_USB_DEVICE(USB_VENDOR_ID_ELO,
893 894
			USB_DEVICE_ID_ELO_TS2515) },

895
	/* GeneralTouch panel */
896
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
897
		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
898 899
			USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },

900 901
	/* Gametel game controller */
	{ .driver_data = MT_CLS_DEFAULT,
902
		MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
903 904
			USB_DEVICE_ID_GAMETEL_MT_MODE) },

905 906
	/* GoodTouch panels */
	{ .driver_data = MT_CLS_DEFAULT,
907
		MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
908 909
			USB_DEVICE_ID_GOODTOUCH_000f) },

910 911
	/* Hanvon panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
912
		MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
913 914
			USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },

915 916
	/* Ideacom panel */
	{ .driver_data = MT_CLS_SERIAL,
917
		MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
918
			USB_DEVICE_ID_IDEACOM_IDC6650) },
919
	{ .driver_data = MT_CLS_SERIAL,
920
		MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
921
			USB_DEVICE_ID_IDEACOM_IDC6651) },
922

923 924
	/* Ilitek dual touch panel */
	{  .driver_data = MT_CLS_DEFAULT,
925
		MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
926 927
			USB_DEVICE_ID_ILITEK_MULTITOUCH) },

928 929
	/* IRTOUCH panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
930
		MT_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
931 932
			USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },

933 934
	/* LG Display panels */
	{ .driver_data = MT_CLS_DEFAULT,
935
		MT_USB_DEVICE(USB_VENDOR_ID_LG,
936 937
			USB_DEVICE_ID_LG_MULTITOUCH) },

938 939
	/* Lumio panels */
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
940
		MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
941
			USB_DEVICE_ID_CRYSTALTOUCH) },
942
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
943
		MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
944
			USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
945

946 947
	/* MosArt panels */
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
948
		MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
949 950
			USB_DEVICE_ID_ASUS_T91MT)},
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
951
		MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
952 953
			USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
954
		MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
955 956
			USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },

957 958
	/* Panasonic panels */
	{ .driver_data = MT_CLS_PANASONIC,
959
		MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
960 961
			USB_DEVICE_ID_PANABOARD_UBT780) },
	{ .driver_data = MT_CLS_PANASONIC,
962
		MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
963 964
			USB_DEVICE_ID_PANABOARD_UBT880) },

965 966
	/* Novatek Panel */
	{ .driver_data = MT_CLS_DEFAULT,
967
		MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
968 969
			USB_DEVICE_ID_NOVATEK_PCT) },

970 971
	/* PenMount panels */
	{ .driver_data = MT_CLS_CONFIDENCE,
972
		MT_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
973 974
			USB_DEVICE_ID_PENMOUNT_PCI) },

975 976
	/* PixArt optical touch screen */
	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
977
		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
978 979
			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
980
		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
981 982
			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
983
		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
984 985
			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },

986
	/* PixCir-based panels */
987
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
988
		MT_USB_DEVICE(USB_VENDOR_ID_HANVON,
989
			USB_DEVICE_ID_HANVON_MULTITOUCH) },
990
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
991
		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
992 993
			USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },

994 995
	/* Quanta-based panels */
	{ .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
996
		MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
997 998
			USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
	{ .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
999
		MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1000 1001
			USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
	{ .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1002
		MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1003 1004
			USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) },

1005
	/* Stantum panels */
1006
	{ .driver_data = MT_CLS_CONFIDENCE,
1007
		MT_USB_DEVICE(USB_VENDOR_ID_STANTUM,
1008
			USB_DEVICE_ID_MTP)},
1009
	{ .driver_data = MT_CLS_CONFIDENCE,
1010
		MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
1011
			USB_DEVICE_ID_MTP_STM)},
1012
	{ .driver_data = MT_CLS_CONFIDENCE,
1013
		MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX,
1014 1015
			USB_DEVICE_ID_MTP_SITRONIX)},

1016 1017
	/* TopSeed panels */
	{ .driver_data = MT_CLS_TOPSEED,
1018
		MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
1019 1020
			USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },

1021 1022
	/* Touch International panels */
	{ .driver_data = MT_CLS_DEFAULT,
1023
		MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
1024 1025
			USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },

1026 1027
	/* Unitec panels */
	{ .driver_data = MT_CLS_DEFAULT,
1028
		MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
1029 1030
			USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
	{ .driver_data = MT_CLS_DEFAULT,
1031
		MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
1032
			USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
1033 1034
	/* XAT */
	{ .driver_data = MT_CLS_DEFAULT,
1035
		MT_USB_DEVICE(USB_VENDOR_ID_XAT,
1036
			USB_DEVICE_ID_XAT_CSR) },
1037

1038 1039
	/* Xiroku */
	{ .driver_data = MT_CLS_DEFAULT,
1040
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1041 1042
			USB_DEVICE_ID_XIROKU_SPX) },
	{ .driver_data = MT_CLS_DEFAULT,
1043
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1044 1045
			USB_DEVICE_ID_XIROKU_MPX) },
	{ .driver_data = MT_CLS_DEFAULT,
1046
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1047 1048
			USB_DEVICE_ID_XIROKU_CSR) },
	{ .driver_data = MT_CLS_DEFAULT,
1049
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1050 1051
			USB_DEVICE_ID_XIROKU_SPX1) },
	{ .driver_data = MT_CLS_DEFAULT,
1052
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1053 1054
			USB_DEVICE_ID_XIROKU_MPX1) },
	{ .driver_data = MT_CLS_DEFAULT,
1055
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1056 1057
			USB_DEVICE_ID_XIROKU_CSR1) },
	{ .driver_data = MT_CLS_DEFAULT,
1058
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1059 1060
			USB_DEVICE_ID_XIROKU_SPX2) },
	{ .driver_data = MT_CLS_DEFAULT,
1061
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1062 1063
			USB_DEVICE_ID_XIROKU_MPX2) },
	{ .driver_data = MT_CLS_DEFAULT,
1064
		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1065 1066
			USB_DEVICE_ID_XIROKU_CSR2) },

1067 1068 1069 1070 1071
	/* Zytronic panels */
	{ .driver_data = MT_CLS_SERIAL,
		MT_USB_DEVICE(USB_VENDOR_ID_ZYTRONIC,
			USB_DEVICE_ID_ZYTRONIC_ZXY100) },

1072 1073
	/* Generic MT device */
	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
	{ }
};
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,
	.feature_mapping = mt_feature_mapping,
	.usage_table = mt_grabbed_usages,
	.event = mt_event,
#ifdef CONFIG_PM
	.reset_resume = mt_reset_resume,
#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);