1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  HID driver for multitouch panels
   4 *
   5 *  Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
   6 *  Copyright (c) 2010-2013 Benjamin Tissoires <benjamin.tissoires@gmail.com>
   7 *  Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
   8 *  Copyright (c) 2012-2013 Red Hat, Inc
   9 *
  10 *  This code is partly based on hid-egalax.c:
  11 *
  12 *  Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
  13 *  Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
  14 *  Copyright (c) 2010 Canonical, Ltd.
  15 *
  16 *  This code is partly based on hid-3m-pct.c:
  17 *
  18 *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
  19 *  Copyright (c) 2010      Henrik Rydberg <rydberg@euromail.se>
  20 *  Copyright (c) 2010      Canonical, Ltd.
 
  21 */
  22
  23/*
 
 
 
 
  24 */
  25
  26/*
  27 * This driver is regularly tested thanks to the test suite in hid-tools[1].
 
  28 * Please run these regression tests before patching this module so that
  29 * your patch won't break existing known devices.
  30 *
  31 * [1] https://gitlab.freedesktop.org/libevdev/hid-tools
 
 
  32 */
  33
  34#include <linux/device.h>
  35#include <linux/hid.h>
  36#include <linux/module.h>
  37#include <linux/slab.h>
  38#include <linux/input/mt.h>
  39#include <linux/jiffies.h>
  40#include <linux/string.h>
  41#include <linux/timer.h>
  42
  43
  44MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
  45MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
  46MODULE_DESCRIPTION("HID multitouch panels");
  47MODULE_LICENSE("GPL");
  48
  49#include "hid-ids.h"
  50
  51/* quirks to control the device */
  52#define MT_QUIRK_NOT_SEEN_MEANS_UP	BIT(0)
  53#define MT_QUIRK_SLOT_IS_CONTACTID	BIT(1)
  54#define MT_QUIRK_CYPRESS		BIT(2)
  55#define MT_QUIRK_SLOT_IS_CONTACTNUMBER	BIT(3)
  56#define MT_QUIRK_ALWAYS_VALID		BIT(4)
  57#define MT_QUIRK_VALID_IS_INRANGE	BIT(5)
  58#define MT_QUIRK_VALID_IS_CONFIDENCE	BIT(6)
  59#define MT_QUIRK_CONFIDENCE		BIT(7)
  60#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE	BIT(8)
  61#define MT_QUIRK_NO_AREA		BIT(9)
  62#define MT_QUIRK_IGNORE_DUPLICATES	BIT(10)
  63#define MT_QUIRK_HOVERING		BIT(11)
  64#define MT_QUIRK_CONTACT_CNT_ACCURATE	BIT(12)
  65#define MT_QUIRK_FORCE_GET_FEATURE	BIT(13)
  66#define MT_QUIRK_FIX_CONST_CONTACT_ID	BIT(14)
  67#define MT_QUIRK_TOUCH_SIZE_SCALING	BIT(15)
  68#define MT_QUIRK_STICKY_FINGERS		BIT(16)
  69#define MT_QUIRK_ASUS_CUSTOM_UP		BIT(17)
  70#define MT_QUIRK_WIN8_PTP_BUTTONS	BIT(18)
  71#define MT_QUIRK_SEPARATE_APP_REPORT	BIT(19)
  72#define MT_QUIRK_FORCE_MULTI_INPUT	BIT(20)
  73#define MT_QUIRK_DISABLE_WAKEUP		BIT(21)
  74
  75#define MT_INPUTMODE_TOUCHSCREEN	0x02
  76#define MT_INPUTMODE_TOUCHPAD		0x03
  77
  78#define MT_BUTTONTYPE_CLICKPAD		0
  79
  80enum latency_mode {
  81	HID_LATENCY_NORMAL = 0,
  82	HID_LATENCY_HIGH = 1,
  83};
  84
  85#define MT_IO_FLAGS_RUNNING		0
  86#define MT_IO_FLAGS_ACTIVE_SLOTS	1
  87#define MT_IO_FLAGS_PENDING_SLOTS	2
  88
  89static const bool mtrue = true;		/* default for true */
  90static const bool mfalse;		/* default for false */
  91static const __s32 mzero;		/* default for 0 */
  92
  93#define DEFAULT_TRUE	((void *)&mtrue)
  94#define DEFAULT_FALSE	((void *)&mfalse)
  95#define DEFAULT_ZERO	((void *)&mzero)
  96
  97struct mt_usages {
  98	struct list_head list;
  99	__s32 *x, *y, *cx, *cy, *p, *w, *h, *a;
 100	__s32 *contactid;	/* the device ContactID assigned to this slot */
 101	bool *tip_state;	/* is the touch valid? */
 102	bool *inrange_state;	/* is the finger in proximity of the sensor? */
 103	bool *confidence_state;	/* is the touch made by a finger? */
 104};
 105
 106struct mt_application {
 107	struct list_head list;
 108	unsigned int application;
 109	unsigned int report_id;
 110	struct list_head mt_usages;	/* mt usages list */
 111
 112	__s32 quirks;
 113
 114	__s32 *scantime;		/* scantime reported */
 115	__s32 scantime_logical_max;	/* max value for raw scantime */
 116
 117	__s32 *raw_cc;			/* contact count in the report */
 118	int left_button_state;		/* left button state */
 119	unsigned int mt_flags;		/* flags to pass to input-mt */
 120
 121	unsigned long *pending_palm_slots;	/* slots where we reported palm
 122						 * and need to release */
 123
 124	__u8 num_received;	/* how many contacts we received */
 125	__u8 num_expected;	/* expected last contact index */
 126	__u8 buttons_count;	/* number of physical buttons per touchpad */
 127	__u8 touches_by_report;	/* how many touches are present in one report:
 128				 * 1 means we should use a serial protocol
 129				 * > 1 means hybrid (multitouch) protocol
 130				 */
 131
 132	__s32 dev_time;		/* the scan time provided by the device */
 133	unsigned long jiffies;	/* the frame's jiffies */
 134	int timestamp;		/* the timestamp to be sent */
 135	int prev_scantime;		/* scantime reported previously */
 136
 137	bool have_contact_count;
 138};
 139
 140struct mt_class {
 141	__s32 name;	/* MT_CLS */
 142	__s32 quirks;
 143	__s32 sn_move;	/* Signal/noise ratio for move events */
 144	__s32 sn_width;	/* Signal/noise ratio for width events */
 145	__s32 sn_height;	/* Signal/noise ratio for height events */
 146	__s32 sn_pressure;	/* Signal/noise ratio for pressure events */
 147	__u8 maxcontacts;
 148	bool is_indirect;	/* true for touchpads */
 149	bool export_all_inputs;	/* do not ignore mouse, keyboards, etc... */
 150};
 151
 152struct mt_report_data {
 153	struct list_head list;
 154	struct hid_report *report;
 155	struct mt_application *application;
 156	bool is_mt_collection;
 157};
 158
 159struct mt_device {
 
 160	struct mt_class mtclass;	/* our mt device class */
 161	struct timer_list release_timer;	/* to release sticky fingers */
 162	struct hid_device *hdev;	/* hid_device we're attached to */
 163	unsigned long mt_io_flags;	/* mt flags (MT_IO_FLAGS_*) */
 164	__u8 inputmode_value;	/* InputMode HID feature value */
 
 
 
 
 
 
 
 
 
 165	__u8 maxcontacts;
 
 
 
 
 166	bool is_buttonpad;	/* is this device a button pad? */
 167	bool serial_maybe;	/* need to check for serial protocol */
 168
 169	struct list_head applications;
 170	struct list_head reports;
 171};
 172
 173static void mt_post_parse_default_settings(struct mt_device *td,
 174					   struct mt_application *app);
 175static void mt_post_parse(struct mt_device *td, struct mt_application *app);
 176
 177/* classes of device behavior */
 178#define MT_CLS_DEFAULT				0x0001
 179
 180#define MT_CLS_SERIAL				0x0002
 181#define MT_CLS_CONFIDENCE			0x0003
 182#define MT_CLS_CONFIDENCE_CONTACT_ID		0x0004
 183#define MT_CLS_CONFIDENCE_MINUS_ONE		0x0005
 184#define MT_CLS_DUAL_INRANGE_CONTACTID		0x0006
 185#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER	0x0007
 186/* reserved					0x0008 */
 187#define MT_CLS_INRANGE_CONTACTNUMBER		0x0009
 188#define MT_CLS_NSMU				0x000a
 189/* reserved					0x0010 */
 190/* reserved					0x0011 */
 191#define MT_CLS_WIN_8				0x0012
 192#define MT_CLS_EXPORT_ALL_INPUTS		0x0013
 193/* reserved					0x0014 */
 194#define MT_CLS_WIN_8_FORCE_MULTI_INPUT		0x0015
 195#define MT_CLS_WIN_8_DISABLE_WAKEUP		0x0016
 196#define MT_CLS_WIN_8_NO_STICKY_FINGERS		0x0017
 197#define MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU	0x0018
 198
 199/* vendor specific classes */
 200#define MT_CLS_3M				0x0101
 201/* reserved					0x0102 */
 202#define MT_CLS_EGALAX				0x0103
 203#define MT_CLS_EGALAX_SERIAL			0x0104
 204#define MT_CLS_TOPSEED				0x0105
 205#define MT_CLS_PANASONIC			0x0106
 206#define MT_CLS_FLATFROG				0x0107
 207#define MT_CLS_GENERALTOUCH_TWOFINGERS		0x0108
 208#define MT_CLS_GENERALTOUCH_PWT_TENFINGERS	0x0109
 209#define MT_CLS_LG				0x010a
 210#define MT_CLS_ASUS				0x010b
 211#define MT_CLS_VTL				0x0110
 212#define MT_CLS_GOOGLE				0x0111
 213#define MT_CLS_RAZER_BLADE_STEALTH		0x0112
 214#define MT_CLS_SMART_TECH			0x0113
 215
 216#define MT_DEFAULT_MAXCONTACT	10
 217#define MT_MAX_MAXCONTACT	250
 218
 219/*
 220 * Resync device and local timestamps after that many microseconds without
 221 * receiving data.
 222 */
 223#define MAX_TIMESTAMP_INTERVAL	1000000
 224
 225#define MT_USB_DEVICE(v, p)	HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p)
 226#define MT_BT_DEVICE(v, p)	HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p)
 227
 228/*
 229 * these device-dependent functions determine what slot corresponds
 230 * to a valid contact that was just read.
 231 */
 232
 233static int cypress_compute_slot(struct mt_application *application,
 234				struct mt_usages *slot)
 235{
 236	if (*slot->contactid != 0 || application->num_received == 0)
 237		return *slot->contactid;
 238	else
 239		return -1;
 240}
 241
 242static const struct mt_class mt_classes[] = {
 243	{ .name = MT_CLS_DEFAULT,
 244		.quirks = MT_QUIRK_ALWAYS_VALID |
 245			MT_QUIRK_CONTACT_CNT_ACCURATE },
 246	{ .name = MT_CLS_NSMU,
 247		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
 248	{ .name = MT_CLS_SERIAL,
 249		.quirks = MT_QUIRK_ALWAYS_VALID},
 250	{ .name = MT_CLS_CONFIDENCE,
 251		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
 252	{ .name = MT_CLS_CONFIDENCE_CONTACT_ID,
 253		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 254			MT_QUIRK_SLOT_IS_CONTACTID },
 255	{ .name = MT_CLS_CONFIDENCE_MINUS_ONE,
 256		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 257			MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
 258	{ .name = MT_CLS_DUAL_INRANGE_CONTACTID,
 259		.quirks = MT_QUIRK_VALID_IS_INRANGE |
 260			MT_QUIRK_SLOT_IS_CONTACTID,
 261		.maxcontacts = 2 },
 262	{ .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 263		.quirks = MT_QUIRK_VALID_IS_INRANGE |
 264			MT_QUIRK_SLOT_IS_CONTACTNUMBER,
 265		.maxcontacts = 2 },
 266	{ .name = MT_CLS_INRANGE_CONTACTNUMBER,
 267		.quirks = MT_QUIRK_VALID_IS_INRANGE |
 268			MT_QUIRK_SLOT_IS_CONTACTNUMBER },
 269	{ .name = MT_CLS_WIN_8,
 270		.quirks = MT_QUIRK_ALWAYS_VALID |
 271			MT_QUIRK_IGNORE_DUPLICATES |
 272			MT_QUIRK_HOVERING |
 273			MT_QUIRK_CONTACT_CNT_ACCURATE |
 274			MT_QUIRK_STICKY_FINGERS |
 275			MT_QUIRK_WIN8_PTP_BUTTONS,
 276		.export_all_inputs = true },
 277	{ .name = MT_CLS_EXPORT_ALL_INPUTS,
 278		.quirks = MT_QUIRK_ALWAYS_VALID |
 279			MT_QUIRK_CONTACT_CNT_ACCURATE,
 280		.export_all_inputs = true },
 281	{ .name = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
 282		.quirks = MT_QUIRK_ALWAYS_VALID |
 283			MT_QUIRK_IGNORE_DUPLICATES |
 284			MT_QUIRK_HOVERING |
 285			MT_QUIRK_CONTACT_CNT_ACCURATE |
 286			MT_QUIRK_STICKY_FINGERS |
 287			MT_QUIRK_WIN8_PTP_BUTTONS |
 288			MT_QUIRK_FORCE_MULTI_INPUT,
 289		.export_all_inputs = true },
 290	{ .name = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
 291		.quirks = MT_QUIRK_IGNORE_DUPLICATES |
 292			MT_QUIRK_HOVERING |
 293			MT_QUIRK_CONTACT_CNT_ACCURATE |
 294			MT_QUIRK_STICKY_FINGERS |
 295			MT_QUIRK_WIN8_PTP_BUTTONS |
 296			MT_QUIRK_FORCE_MULTI_INPUT |
 297			MT_QUIRK_NOT_SEEN_MEANS_UP,
 298		.export_all_inputs = true },
 299	{ .name = MT_CLS_WIN_8_DISABLE_WAKEUP,
 300		.quirks = MT_QUIRK_ALWAYS_VALID |
 301			MT_QUIRK_IGNORE_DUPLICATES |
 302			MT_QUIRK_HOVERING |
 303			MT_QUIRK_CONTACT_CNT_ACCURATE |
 304			MT_QUIRK_STICKY_FINGERS |
 305			MT_QUIRK_WIN8_PTP_BUTTONS |
 306			MT_QUIRK_DISABLE_WAKEUP,
 307		.export_all_inputs = true },
 308	{ .name = MT_CLS_WIN_8_NO_STICKY_FINGERS,
 309		.quirks = MT_QUIRK_ALWAYS_VALID |
 310			MT_QUIRK_IGNORE_DUPLICATES |
 311			MT_QUIRK_HOVERING |
 312			MT_QUIRK_CONTACT_CNT_ACCURATE |
 313			MT_QUIRK_WIN8_PTP_BUTTONS,
 314		.export_all_inputs = true },
 315
 316	/*
 317	 * vendor specific classes
 318	 */
 319	{ .name = MT_CLS_3M,
 320		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 321			MT_QUIRK_SLOT_IS_CONTACTID |
 322			MT_QUIRK_TOUCH_SIZE_SCALING,
 323		.sn_move = 2048,
 324		.sn_width = 128,
 325		.sn_height = 128,
 326		.maxcontacts = 60,
 327	},
 328	{ .name = MT_CLS_EGALAX,
 329		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
 330			MT_QUIRK_VALID_IS_INRANGE,
 331		.sn_move = 4096,
 332		.sn_pressure = 32,
 333	},
 334	{ .name = MT_CLS_EGALAX_SERIAL,
 335		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
 336			MT_QUIRK_ALWAYS_VALID,
 337		.sn_move = 4096,
 338		.sn_pressure = 32,
 339	},
 340	{ .name = MT_CLS_TOPSEED,
 341		.quirks = MT_QUIRK_ALWAYS_VALID,
 342		.is_indirect = true,
 343		.maxcontacts = 2,
 344	},
 345	{ .name = MT_CLS_PANASONIC,
 346		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
 347		.maxcontacts = 4 },
 348	{ .name	= MT_CLS_GENERALTOUCH_TWOFINGERS,
 349		.quirks	= MT_QUIRK_NOT_SEEN_MEANS_UP |
 350			MT_QUIRK_VALID_IS_INRANGE |
 351			MT_QUIRK_SLOT_IS_CONTACTID,
 352		.maxcontacts = 2
 353	},
 354	{ .name	= MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
 355		.quirks	= MT_QUIRK_NOT_SEEN_MEANS_UP |
 356			MT_QUIRK_SLOT_IS_CONTACTID
 357	},
 358
 359	{ .name = MT_CLS_FLATFROG,
 360		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 361			MT_QUIRK_NO_AREA,
 362		.sn_move = 2048,
 363		.maxcontacts = 40,
 364	},
 365	{ .name = MT_CLS_LG,
 366		.quirks = MT_QUIRK_ALWAYS_VALID |
 367			MT_QUIRK_FIX_CONST_CONTACT_ID |
 368			MT_QUIRK_IGNORE_DUPLICATES |
 369			MT_QUIRK_HOVERING |
 370			MT_QUIRK_CONTACT_CNT_ACCURATE },
 371	{ .name = MT_CLS_ASUS,
 372		.quirks = MT_QUIRK_ALWAYS_VALID |
 373			MT_QUIRK_CONTACT_CNT_ACCURATE |
 374			MT_QUIRK_ASUS_CUSTOM_UP },
 375	{ .name = MT_CLS_VTL,
 376		.quirks = MT_QUIRK_ALWAYS_VALID |
 377			MT_QUIRK_CONTACT_CNT_ACCURATE |
 378			MT_QUIRK_FORCE_GET_FEATURE,
 379	},
 380	{ .name = MT_CLS_GOOGLE,
 381		.quirks = MT_QUIRK_ALWAYS_VALID |
 382			MT_QUIRK_CONTACT_CNT_ACCURATE |
 383			MT_QUIRK_SLOT_IS_CONTACTID |
 384			MT_QUIRK_HOVERING
 385	},
 386	{ .name = MT_CLS_RAZER_BLADE_STEALTH,
 387		.quirks = MT_QUIRK_ALWAYS_VALID |
 388			MT_QUIRK_IGNORE_DUPLICATES |
 389			MT_QUIRK_HOVERING |
 390			MT_QUIRK_CONTACT_CNT_ACCURATE |
 391			MT_QUIRK_WIN8_PTP_BUTTONS,
 392	},
 393	{ .name = MT_CLS_SMART_TECH,
 394		.quirks = MT_QUIRK_ALWAYS_VALID |
 395			MT_QUIRK_IGNORE_DUPLICATES |
 396			MT_QUIRK_CONTACT_CNT_ACCURATE |
 397			MT_QUIRK_SEPARATE_APP_REPORT,
 398	},
 399	{ }
 400};
 401
 402static ssize_t mt_show_quirks(struct device *dev,
 403			   struct device_attribute *attr,
 404			   char *buf)
 405{
 406	struct hid_device *hdev = to_hid_device(dev);
 407	struct mt_device *td = hid_get_drvdata(hdev);
 408
 409	return sprintf(buf, "%u\n", td->mtclass.quirks);
 410}
 411
 412static ssize_t mt_set_quirks(struct device *dev,
 413			  struct device_attribute *attr,
 414			  const char *buf, size_t count)
 415{
 416	struct hid_device *hdev = to_hid_device(dev);
 417	struct mt_device *td = hid_get_drvdata(hdev);
 418	struct mt_application *application;
 419
 420	unsigned long val;
 421
 422	if (kstrtoul(buf, 0, &val))
 423		return -EINVAL;
 424
 425	td->mtclass.quirks = val;
 426
 427	list_for_each_entry(application, &td->applications, list) {
 428		application->quirks = val;
 429		if (!application->have_contact_count)
 430			application->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
 431	}
 432
 433	return count;
 434}
 435
 436static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
 437
 438static struct attribute *sysfs_attrs[] = {
 439	&dev_attr_quirks.attr,
 440	NULL
 441};
 442
 443static const struct attribute_group mt_attribute_group = {
 444	.attrs = sysfs_attrs
 445};
 446
 447static void mt_get_feature(struct hid_device *hdev, struct hid_report *report)
 448{
 449	int ret;
 450	u32 size = hid_report_len(report);
 451	u8 *buf;
 452
 453	/*
 454	 * Do not fetch the feature report if the device has been explicitly
 455	 * marked as non-capable.
 
 456	 */
 457	if (hdev->quirks & HID_QUIRK_NO_INIT_REPORTS)
 
 
 458		return;
 459
 460	buf = hid_alloc_report_buf(report, GFP_KERNEL);
 461	if (!buf)
 462		return;
 463
 464	ret = hid_hw_raw_request(hdev, report->id, buf, size,
 465				 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
 466	if (ret < 0) {
 467		dev_warn(&hdev->dev, "failed to fetch feature %d\n",
 468			 report->id);
 469	} else {
 470		ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf,
 471					   size, 0);
 472		if (ret)
 473			dev_warn(&hdev->dev, "failed to report feature\n");
 474	}
 475
 476	kfree(buf);
 477}
 478
 479static void mt_feature_mapping(struct hid_device *hdev,
 480		struct hid_field *field, struct hid_usage *usage)
 481{
 482	struct mt_device *td = hid_get_drvdata(hdev);
 483
 484	switch (usage->hid) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 485	case HID_DG_CONTACTMAX:
 486		mt_get_feature(hdev, field->report);
 487
 
 488		td->maxcontacts = field->value[0];
 489		if (!td->maxcontacts &&
 490		    field->logical_maximum <= MT_MAX_MAXCONTACT)
 491			td->maxcontacts = field->logical_maximum;
 492		if (td->mtclass.maxcontacts)
 493			/* check if the maxcontacts is given by the class */
 494			td->maxcontacts = td->mtclass.maxcontacts;
 495
 496		break;
 497	case HID_DG_BUTTONTYPE:
 498		if (usage->usage_index >= field->report_count) {
 499			dev_err(&hdev->dev, "HID_DG_BUTTONTYPE out of range\n");
 500			break;
 501		}
 502
 503		mt_get_feature(hdev, field->report);
 504		if (field->value[usage->usage_index] == MT_BUTTONTYPE_CLICKPAD)
 505			td->is_buttonpad = true;
 506
 507		break;
 508	case 0xff0000c5:
 509		/* Retrieve the Win8 blob once to enable some devices */
 510		if (usage->usage_index == 0)
 511			mt_get_feature(hdev, field->report);
 512		break;
 513	}
 514}
 515
 516static void set_abs(struct input_dev *input, unsigned int code,
 517		struct hid_field *field, int snratio)
 518{
 519	int fmin = field->logical_minimum;
 520	int fmax = field->logical_maximum;
 521	int fuzz = snratio ? (fmax - fmin) / snratio : 0;
 522	input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
 523	input_abs_set_res(input, code, hidinput_calc_abs_res(field, code));
 524}
 525
 526static struct mt_usages *mt_allocate_usage(struct hid_device *hdev,
 527					   struct mt_application *application)
 528{
 529	struct mt_usages *usage;
 530
 531	usage = devm_kzalloc(&hdev->dev, sizeof(*usage), GFP_KERNEL);
 532	if (!usage)
 533		return NULL;
 534
 535	/* set some defaults so we do not need to check for null pointers */
 536	usage->x = DEFAULT_ZERO;
 537	usage->y = DEFAULT_ZERO;
 538	usage->cx = DEFAULT_ZERO;
 539	usage->cy = DEFAULT_ZERO;
 540	usage->p = DEFAULT_ZERO;
 541	usage->w = DEFAULT_ZERO;
 542	usage->h = DEFAULT_ZERO;
 543	usage->a = DEFAULT_ZERO;
 544	usage->contactid = DEFAULT_ZERO;
 545	usage->tip_state = DEFAULT_FALSE;
 546	usage->inrange_state = DEFAULT_FALSE;
 547	usage->confidence_state = DEFAULT_TRUE;
 548
 549	list_add_tail(&usage->list, &application->mt_usages);
 550
 551	return usage;
 552}
 553
 554static struct mt_application *mt_allocate_application(struct mt_device *td,
 555						      struct hid_report *report)
 556{
 557	unsigned int application = report->application;
 558	struct mt_application *mt_application;
 559
 560	mt_application = devm_kzalloc(&td->hdev->dev, sizeof(*mt_application),
 561				      GFP_KERNEL);
 562	if (!mt_application)
 563		return NULL;
 564
 565	mt_application->application = application;
 566	INIT_LIST_HEAD(&mt_application->mt_usages);
 567
 568	if (application == HID_DG_TOUCHSCREEN)
 569		mt_application->mt_flags |= INPUT_MT_DIRECT;
 570
 571	/*
 572	 * Model touchscreens providing buttons as touchpads.
 573	 */
 574	if (application == HID_DG_TOUCHPAD) {
 575		mt_application->mt_flags |= INPUT_MT_POINTER;
 576		td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
 577	}
 578
 579	mt_application->scantime = DEFAULT_ZERO;
 580	mt_application->raw_cc = DEFAULT_ZERO;
 581	mt_application->quirks = td->mtclass.quirks;
 582	mt_application->report_id = report->id;
 583
 584	list_add_tail(&mt_application->list, &td->applications);
 585
 586	return mt_application;
 587}
 588
 589static struct mt_application *mt_find_application(struct mt_device *td,
 590						  struct hid_report *report)
 591{
 592	unsigned int application = report->application;
 593	struct mt_application *tmp, *mt_application = NULL;
 594
 595	list_for_each_entry(tmp, &td->applications, list) {
 596		if (application == tmp->application) {
 597			if (!(td->mtclass.quirks & MT_QUIRK_SEPARATE_APP_REPORT) ||
 598			    tmp->report_id == report->id) {
 599				mt_application = tmp;
 600				break;
 601			}
 602		}
 603	}
 604
 605	if (!mt_application)
 606		mt_application = mt_allocate_application(td, report);
 607
 608	return mt_application;
 609}
 610
 611static struct mt_report_data *mt_allocate_report_data(struct mt_device *td,
 612						      struct hid_report *report)
 613{
 614	struct mt_report_data *rdata;
 615	struct hid_field *field;
 616	int r, n;
 617
 618	rdata = devm_kzalloc(&td->hdev->dev, sizeof(*rdata), GFP_KERNEL);
 619	if (!rdata)
 620		return NULL;
 621
 622	rdata->report = report;
 623	rdata->application = mt_find_application(td, report);
 624
 625	if (!rdata->application) {
 626		devm_kfree(&td->hdev->dev, rdata);
 627		return NULL;
 628	}
 629
 630	for (r = 0; r < report->maxfield; r++) {
 631		field = report->field[r];
 632
 633		if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
 634			continue;
 635
 636		if (field->logical == HID_DG_FINGER || td->hdev->group != HID_GROUP_MULTITOUCH_WIN_8) {
 637			for (n = 0; n < field->report_count; n++) {
 638				if (field->usage[n].hid == HID_DG_CONTACTID) {
 639					rdata->is_mt_collection = true;
 640					break;
 641				}
 642			}
 643		}
 644	}
 645
 646	list_add_tail(&rdata->list, &td->reports);
 647
 648	return rdata;
 649}
 650
 651static struct mt_report_data *mt_find_report_data(struct mt_device *td,
 652						  struct hid_report *report)
 653{
 654	struct mt_report_data *tmp, *rdata = NULL;
 655
 656	list_for_each_entry(tmp, &td->reports, list) {
 657		if (report == tmp->report) {
 658			rdata = tmp;
 659			break;
 660		}
 661	}
 662
 663	if (!rdata)
 664		rdata = mt_allocate_report_data(td, report);
 665
 666	return rdata;
 667}
 668
 669static void mt_store_field(struct hid_device *hdev,
 670			   struct mt_application *application,
 671			   __s32 *value,
 672			   size_t offset)
 673{
 674	struct mt_usages *usage;
 675	__s32 **target;
 676
 677	if (list_empty(&application->mt_usages))
 678		usage = mt_allocate_usage(hdev, application);
 679	else
 680		usage = list_last_entry(&application->mt_usages,
 681					struct mt_usages,
 682					list);
 683
 684	if (!usage)
 685		return;
 686
 687	target = (__s32 **)((char *)usage + offset);
 688
 689	/* the value has already been filled, create a new slot */
 690	if (*target != DEFAULT_TRUE &&
 691	    *target != DEFAULT_FALSE &&
 692	    *target != DEFAULT_ZERO) {
 693		if (usage->contactid == DEFAULT_ZERO ||
 694		    usage->x == DEFAULT_ZERO ||
 695		    usage->y == DEFAULT_ZERO) {
 696			hid_dbg(hdev,
 697				"ignoring duplicate usage on incomplete");
 698			return;
 699		}
 700		usage = mt_allocate_usage(hdev, application);
 701		if (!usage)
 702			return;
 703
 704		target = (__s32 **)((char *)usage + offset);
 705	}
 706
 707	*target = value;
 708}
 709
 710#define MT_STORE_FIELD(__name)						\
 711	mt_store_field(hdev, app,					\
 712		       &field->value[usage->usage_index],		\
 713		       offsetof(struct mt_usages, __name))
 714
 715static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 716		struct hid_field *field, struct hid_usage *usage,
 717		unsigned long **bit, int *max, struct mt_application *app)
 718{
 719	struct mt_device *td = hid_get_drvdata(hdev);
 720	struct mt_class *cls = &td->mtclass;
 721	int code;
 722	struct hid_usage *prev_usage = NULL;
 723
 
 
 
 724	/*
 725	 * Model touchscreens providing buttons as touchpads.
 726	 */
 727	if (field->application == HID_DG_TOUCHSCREEN &&
 728	    (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
 729		app->mt_flags |= INPUT_MT_POINTER;
 730		td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
 731	}
 732
 733	/* count the buttons on touchpads */
 734	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
 735		app->buttons_count++;
 736
 737	if (usage->usage_index)
 738		prev_usage = &field->usage[usage->usage_index - 1];
 739
 740	switch (usage->hid & HID_USAGE_PAGE) {
 741
 742	case HID_UP_GENDESK:
 743		switch (usage->hid) {
 744		case HID_GD_X:
 745			if (prev_usage && (prev_usage->hid == usage->hid)) {
 746				code = ABS_MT_TOOL_X;
 747				MT_STORE_FIELD(cx);
 
 
 748			} else {
 749				code = ABS_MT_POSITION_X;
 750				MT_STORE_FIELD(x);
 751			}
 752
 753			set_abs(hi->input, code, field, cls->sn_move);
 754
 755			/*
 756			 * A system multi-axis that exports X and Y has a high
 757			 * chance of being used directly on a surface
 758			 */
 759			if (field->application == HID_GD_SYSTEM_MULTIAXIS) {
 760				__set_bit(INPUT_PROP_DIRECT,
 761					  hi->input->propbit);
 762				input_set_abs_params(hi->input,
 763						     ABS_MT_TOOL_TYPE,
 764						     MT_TOOL_DIAL,
 765						     MT_TOOL_DIAL, 0, 0);
 766			}
 767
 
 768			return 1;
 769		case HID_GD_Y:
 770			if (prev_usage && (prev_usage->hid == usage->hid)) {
 771				code = ABS_MT_TOOL_Y;
 772				MT_STORE_FIELD(cy);
 
 
 773			} else {
 774				code = ABS_MT_POSITION_Y;
 775				MT_STORE_FIELD(y);
 
 
 776			}
 777
 778			set_abs(hi->input, code, field, cls->sn_move);
 779
 780			return 1;
 781		}
 782		return 0;
 783
 784	case HID_UP_DIGITIZER:
 785		switch (usage->hid) {
 786		case HID_DG_INRANGE:
 787			if (app->quirks & MT_QUIRK_HOVERING) {
 
 
 788				input_set_abs_params(hi->input,
 789					ABS_MT_DISTANCE, 0, 1, 0, 0);
 790			}
 791			MT_STORE_FIELD(inrange_state);
 792			return 1;
 793		case HID_DG_CONFIDENCE:
 794			if ((cls->name == MT_CLS_WIN_8 ||
 795			     cls->name == MT_CLS_WIN_8_FORCE_MULTI_INPUT ||
 796			     cls->name == MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU ||
 797			     cls->name == MT_CLS_WIN_8_DISABLE_WAKEUP) &&
 798				(field->application == HID_DG_TOUCHPAD ||
 799				 field->application == HID_DG_TOUCHSCREEN))
 800				app->quirks |= MT_QUIRK_CONFIDENCE;
 801
 802			if (app->quirks & MT_QUIRK_CONFIDENCE)
 803				input_set_abs_params(hi->input,
 804						     ABS_MT_TOOL_TYPE,
 805						     MT_TOOL_FINGER,
 806						     MT_TOOL_PALM, 0, 0);
 807
 808			MT_STORE_FIELD(confidence_state);
 809			return 1;
 810		case HID_DG_TIPSWITCH:
 811			if (field->application != HID_GD_SYSTEM_MULTIAXIS)
 812				input_set_capability(hi->input,
 813						     EV_KEY, BTN_TOUCH);
 814			MT_STORE_FIELD(tip_state);
 815			return 1;
 816		case HID_DG_CONTACTID:
 817			MT_STORE_FIELD(contactid);
 818			app->touches_by_report++;
 
 819			return 1;
 820		case HID_DG_WIDTH:
 821			if (!(app->quirks & MT_QUIRK_NO_AREA))
 
 
 822				set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
 823					cls->sn_width);
 824			MT_STORE_FIELD(w);
 825			return 1;
 826		case HID_DG_HEIGHT:
 827			if (!(app->quirks & MT_QUIRK_NO_AREA)) {
 
 
 828				set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
 829					cls->sn_height);
 830
 831				/*
 832				 * Only set ABS_MT_ORIENTATION if it is not
 833				 * already set by the HID_DG_AZIMUTH usage.
 834				 */
 835				if (!test_bit(ABS_MT_ORIENTATION,
 836						hi->input->absbit))
 837					input_set_abs_params(hi->input,
 838						ABS_MT_ORIENTATION, 0, 1, 0, 0);
 839			}
 840			MT_STORE_FIELD(h);
 841			return 1;
 842		case HID_DG_TIPPRESSURE:
 
 
 843			set_abs(hi->input, ABS_MT_PRESSURE, field,
 844				cls->sn_pressure);
 845			MT_STORE_FIELD(p);
 846			return 1;
 847		case HID_DG_SCANTIME:
 848			input_set_capability(hi->input, EV_MSC, MSC_TIMESTAMP);
 849			app->scantime = &field->value[usage->usage_index];
 850			app->scantime_logical_max = field->logical_maximum;
 851			return 1;
 852		case HID_DG_CONTACTCOUNT:
 853			app->have_contact_count = true;
 854			app->raw_cc = &field->value[usage->usage_index];
 855			return 1;
 856		case HID_DG_AZIMUTH:
 857			/*
 858			 * Azimuth has the range of [0, MAX) representing a full
 859			 * revolution. Set ABS_MT_ORIENTATION to a quarter of
 860			 * MAX according the definition of ABS_MT_ORIENTATION
 861			 */
 862			input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
 863				-field->logical_maximum / 4,
 864				field->logical_maximum / 4,
 865				cls->sn_move ?
 866				field->logical_maximum / cls->sn_move : 0, 0);
 867			MT_STORE_FIELD(a);
 868			return 1;
 869		case HID_DG_CONTACTMAX:
 870			/* contact max are global to the report */
 
 871			return -1;
 872		case HID_DG_TOUCH:
 873			/* Legacy devices use TIPSWITCH and not TOUCH.
 874			 * Let's just ignore this field. */
 875			return -1;
 876		}
 877		/* let hid-input decide for the others */
 878		return 0;
 879
 880	case HID_UP_BUTTON:
 881		code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
 882		/*
 883		 * MS PTP spec says that external buttons left and right have
 884		 * usages 2 and 3.
 885		 */
 886		if ((app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
 887		    field->application == HID_DG_TOUCHPAD &&
 888		    (usage->hid & HID_USAGE) > 1)
 889			code--;
 890
 891		if (field->application == HID_GD_SYSTEM_MULTIAXIS)
 892			code = BTN_0  + ((usage->hid - 1) & HID_USAGE);
 893
 894		hid_map_usage(hi, usage, bit, max, EV_KEY, code);
 895		if (!*bit)
 896			return -1;
 897		input_set_capability(hi->input, EV_KEY, code);
 898		return 1;
 899
 900	case 0xff000000:
 901		/* we do not want to map these: no input-oriented meaning */
 902		return -1;
 903	}
 904
 905	return 0;
 906}
 907
 908static int mt_compute_slot(struct mt_device *td, struct mt_application *app,
 909			   struct mt_usages *slot,
 910			   struct input_dev *input)
 
 
 
 
 
 
 
 
 911{
 912	__s32 quirks = app->quirks;
 913
 914	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
 915		return *slot->contactid;
 916
 917	if (quirks & MT_QUIRK_CYPRESS)
 918		return cypress_compute_slot(app, slot);
 919
 920	if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
 921		return app->num_received;
 922
 923	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
 924		return *slot->contactid - 1;
 925
 926	return input_mt_get_slot_by_key(input, *slot->contactid);
 927}
 928
 929static void mt_release_pending_palms(struct mt_device *td,
 930				     struct mt_application *app,
 931				     struct input_dev *input)
 
 
 932{
 933	int slotnum;
 934	bool need_sync = false;
 
 935
 936	for_each_set_bit(slotnum, app->pending_palm_slots, td->maxcontacts) {
 937		clear_bit(slotnum, app->pending_palm_slots);
 
 
 938
 939		input_mt_slot(input, slotnum);
 940		input_mt_report_slot_inactive(input);
 941
 942		need_sync = true;
 943	}
 
 
 
 
 944
 945	if (need_sync) {
 946		input_mt_sync_frame(input);
 947		input_sync(input);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 948	}
 
 
 949}
 950
 951/*
 952 * this function is called when a whole packet has been received and processed,
 953 * so that it can decide what to send to the input layer.
 954 */
 955static void mt_sync_frame(struct mt_device *td, struct mt_application *app,
 956			  struct input_dev *input)
 957{
 958	if (app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS)
 959		input_event(input, EV_KEY, BTN_LEFT, app->left_button_state);
 960
 961	input_mt_sync_frame(input);
 962	input_event(input, EV_MSC, MSC_TIMESTAMP, app->timestamp);
 963	input_sync(input);
 964
 965	mt_release_pending_palms(td, app, input);
 966
 967	app->num_received = 0;
 968	app->left_button_state = 0;
 969
 970	if (test_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags))
 971		set_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
 972	else
 973		clear_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
 974	clear_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
 975}
 976
 977static int mt_compute_timestamp(struct mt_application *app, __s32 value)
 978{
 979	long delta = value - app->prev_scantime;
 980	unsigned long jdelta = jiffies_to_usecs(jiffies - app->jiffies);
 981
 982	app->jiffies = jiffies;
 983
 984	if (delta < 0)
 985		delta += app->scantime_logical_max;
 986
 987	/* HID_DG_SCANTIME is expressed in 100us, we want it in us. */
 988	delta *= 100;
 989
 990	if (jdelta > MAX_TIMESTAMP_INTERVAL)
 991		/* No data received for a while, resync the timestamp. */
 992		return 0;
 993	else
 994		return app->timestamp + delta;
 995}
 996
 997static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
 998				struct hid_usage *usage, __s32 value)
 999{
1000	/* we will handle the hidinput part later, now remains hiddev */
1001	if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
1002		hid->hiddev_hid_event(hid, field, usage, value);
1003
1004	return 1;
1005}
1006
1007static int mt_process_slot(struct mt_device *td, struct input_dev *input,
1008			    struct mt_application *app,
1009			    struct mt_usages *slot)
1010{
1011	struct input_mt *mt = input->mt;
1012	__s32 quirks = app->quirks;
1013	bool valid = true;
1014	bool confidence_state = true;
1015	bool inrange_state = false;
1016	int active;
1017	int slotnum;
1018	int tool = MT_TOOL_FINGER;
1019
1020	if (!slot)
1021		return -EINVAL;
1022
1023	if ((quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) &&
1024	    app->num_received >= app->num_expected)
1025		return -EAGAIN;
1026
1027	if (!(quirks & MT_QUIRK_ALWAYS_VALID)) {
1028		if (quirks & MT_QUIRK_VALID_IS_INRANGE)
1029			valid = *slot->inrange_state;
1030		if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
1031			valid = *slot->tip_state;
1032		if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
1033			valid = *slot->confidence_state;
1034
1035		if (!valid)
1036			return 0;
1037	}
1038
1039	slotnum = mt_compute_slot(td, app, slot, input);
1040	if (slotnum < 0 || slotnum >= td->maxcontacts)
1041		return 0;
1042
1043	if ((quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) {
1044		struct input_mt_slot *i_slot = &mt->slots[slotnum];
1045
1046		if (input_mt_is_active(i_slot) &&
1047		    input_mt_is_used(mt, i_slot))
1048			return -EAGAIN;
1049	}
1050
1051	if (quirks & MT_QUIRK_CONFIDENCE)
1052		confidence_state = *slot->confidence_state;
1053
1054	if (quirks & MT_QUIRK_HOVERING)
1055		inrange_state = *slot->inrange_state;
1056
1057	active = *slot->tip_state || inrange_state;
1058
1059	if (app->application == HID_GD_SYSTEM_MULTIAXIS)
1060		tool = MT_TOOL_DIAL;
1061	else if (unlikely(!confidence_state)) {
1062		tool = MT_TOOL_PALM;
1063		if (!active && mt &&
1064		    input_mt_is_active(&mt->slots[slotnum])) {
1065			/*
1066			 * The non-confidence was reported for
1067			 * previously valid contact that is also no
1068			 * longer valid. We can't simply report
1069			 * lift-off as userspace will not be aware
1070			 * of non-confidence, so we need to split
1071			 * it into 2 events: active MT_TOOL_PALM
1072			 * and a separate liftoff.
1073			 */
1074			active = true;
1075			set_bit(slotnum, app->pending_palm_slots);
1076		}
1077	}
1078
1079	input_mt_slot(input, slotnum);
1080	input_mt_report_slot_state(input, tool, active);
1081	if (active) {
1082		/* this finger is in proximity of the sensor */
1083		int wide = (*slot->w > *slot->h);
1084		int major = max(*slot->w, *slot->h);
1085		int minor = min(*slot->w, *slot->h);
1086		int orientation = wide;
1087		int max_azimuth;
1088		int azimuth;
1089
1090		if (slot->a != DEFAULT_ZERO) {
1091			/*
1092			 * Azimuth is counter-clockwise and ranges from [0, MAX)
1093			 * (a full revolution). Convert it to clockwise ranging
1094			 * [-MAX/2, MAX/2].
1095			 *
1096			 * Note that ABS_MT_ORIENTATION require us to report
1097			 * the limit of [-MAX/4, MAX/4], but the value can go
1098			 * out of range to [-MAX/2, MAX/2] to report an upside
1099			 * down ellipsis.
1100			 */
1101			azimuth = *slot->a;
1102			max_azimuth = input_abs_get_max(input,
1103							ABS_MT_ORIENTATION);
1104			if (azimuth > max_azimuth * 2)
1105				azimuth -= max_azimuth * 4;
1106			orientation = -azimuth;
1107		}
1108
1109		if (quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
1110			/*
1111			 * divided by two to match visual scale of touch
1112			 * for devices with this quirk
1113			 */
1114			major = major >> 1;
1115			minor = minor >> 1;
1116		}
1117
1118		input_event(input, EV_ABS, ABS_MT_POSITION_X, *slot->x);
1119		input_event(input, EV_ABS, ABS_MT_POSITION_Y, *slot->y);
1120		input_event(input, EV_ABS, ABS_MT_TOOL_X, *slot->cx);
1121		input_event(input, EV_ABS, ABS_MT_TOOL_Y, *slot->cy);
1122		input_event(input, EV_ABS, ABS_MT_DISTANCE, !*slot->tip_state);
1123		input_event(input, EV_ABS, ABS_MT_ORIENTATION, orientation);
1124		input_event(input, EV_ABS, ABS_MT_PRESSURE, *slot->p);
1125		input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
1126		input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
1127
1128		set_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
1129	}
1130
1131	return 0;
1132}
1133
1134static void mt_process_mt_event(struct hid_device *hid,
1135				struct mt_application *app,
1136				struct hid_field *field,
1137				struct hid_usage *usage,
1138				__s32 value,
1139				bool first_packet)
1140{
1141	__s32 quirks = app->quirks;
 
1142	struct input_dev *input = field->hidinput->input;
1143
1144	if (!usage->type || !(hid->claimed & HID_CLAIMED_INPUT))
1145		return;
1146
1147	if (quirks & MT_QUIRK_WIN8_PTP_BUTTONS) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1148
1149		/*
1150		 * For Win8 PTP touchpads we should only look at
1151		 * non finger/touch events in the first_packet of a
1152		 * (possible) multi-packet frame.
1153		 */
1154		if (!first_packet)
1155			return;
 
1156
1157		/*
1158		 * For Win8 PTP touchpads we map both the clickpad click
1159		 * and any "external" left buttons to BTN_LEFT if a
1160		 * device claims to have both we need to report 1 for
1161		 * BTN_LEFT if either is pressed, so we or all values
1162		 * together and report the result in mt_sync_frame().
1163		 */
1164		if (usage->type == EV_KEY && usage->code == BTN_LEFT) {
1165			app->left_button_state |= value;
1166			return;
1167		}
1168	}
1169
1170	input_event(input, usage->type, usage->code, value);
1171}
1172
1173static void mt_touch_report(struct hid_device *hid,
1174			    struct mt_report_data *rdata)
1175{
1176	struct mt_device *td = hid_get_drvdata(hid);
1177	struct hid_report *report = rdata->report;
1178	struct mt_application *app = rdata->application;
1179	struct hid_field *field;
1180	struct input_dev *input;
1181	struct mt_usages *slot;
1182	bool first_packet;
1183	unsigned count;
1184	int r, n;
1185	int scantime = 0;
1186	int contact_count = -1;
1187
1188	/* sticky fingers release in progress, abort */
1189	if (test_and_set_bit_lock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
1190		return;
1191
1192	scantime = *app->scantime;
1193	app->timestamp = mt_compute_timestamp(app, scantime);
1194	if (app->raw_cc != DEFAULT_ZERO)
1195		contact_count = *app->raw_cc;
1196
1197	/*
1198	 * Includes multi-packet support where subsequent
1199	 * packets are sent with zero contactcount.
1200	 */
1201	if (contact_count >= 0) {
1202		/*
1203		 * For Win8 PTPs the first packet (td->num_received == 0) may
1204		 * have a contactcount of 0 if there only is a button event.
1205		 * We double check that this is not a continuation packet
1206		 * of a possible multi-packet frame be checking that the
1207		 * timestamp has changed.
1208		 */
1209		if ((app->quirks & MT_QUIRK_WIN8_PTP_BUTTONS) &&
1210		    app->num_received == 0 &&
1211		    app->prev_scantime != scantime)
1212			app->num_expected = contact_count;
1213		/* A non 0 contact count always indicates a first packet */
1214		else if (contact_count)
1215			app->num_expected = contact_count;
1216	}
1217	app->prev_scantime = scantime;
1218
1219	first_packet = app->num_received == 0;
1220
1221	input = report->field[0]->hidinput->input;
1222
1223	list_for_each_entry(slot, &app->mt_usages, list) {
1224		if (!mt_process_slot(td, input, app, slot))
1225			app->num_received++;
1226	}
1227
1228	for (r = 0; r < report->maxfield; r++) {
1229		field = report->field[r];
1230		count = field->report_count;
1231
1232		if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
1233			continue;
1234
1235		for (n = 0; n < count; n++)
1236			mt_process_mt_event(hid, app, field,
1237					    &field->usage[n], field->value[n],
1238					    first_packet);
1239	}
1240
1241	if (app->num_received >= app->num_expected)
1242		mt_sync_frame(td, app, input);
1243
1244	/*
1245	 * Windows 8 specs says 2 things:
1246	 * - once a contact has been reported, it has to be reported in each
1247	 *   subsequent report
1248	 * - the report rate when fingers are present has to be at least
1249	 *   the refresh rate of the screen, 60 or 120 Hz
1250	 *
1251	 * I interprete this that the specification forces a report rate of
1252	 * at least 60 Hz for a touchscreen to be certified.
1253	 * Which means that if we do not get a report whithin 16 ms, either
1254	 * something wrong happens, either the touchscreen forgets to send
1255	 * a release. Taking a reasonable margin allows to remove issues
1256	 * with USB communication or the load of the machine.
1257	 *
1258	 * Given that Win 8 devices are forced to send a release, this will
1259	 * only affect laggish machines and the ones that have a firmware
1260	 * defect.
1261	 */
1262	if (app->quirks & MT_QUIRK_STICKY_FINGERS) {
1263		if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1264			mod_timer(&td->release_timer,
1265				  jiffies + msecs_to_jiffies(100));
1266		else
1267			del_timer(&td->release_timer);
1268	}
1269
1270	clear_bit_unlock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
1271}
1272
1273static int mt_touch_input_configured(struct hid_device *hdev,
1274				     struct hid_input *hi,
1275				     struct mt_application *app)
1276{
1277	struct mt_device *td = hid_get_drvdata(hdev);
1278	struct mt_class *cls = &td->mtclass;
1279	struct input_dev *input = hi->input;
1280	int ret;
1281
1282	if (!td->maxcontacts)
1283		td->maxcontacts = MT_DEFAULT_MAXCONTACT;
1284
1285	mt_post_parse(td, app);
1286	if (td->serial_maybe)
1287		mt_post_parse_default_settings(td, app);
1288
1289	if (cls->is_indirect)
1290		app->mt_flags |= INPUT_MT_POINTER;
1291
1292	if (app->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
1293		app->mt_flags |= INPUT_MT_DROP_UNUSED;
1294
1295	/* check for clickpads */
1296	if ((app->mt_flags & INPUT_MT_POINTER) &&
1297	    (app->buttons_count == 1))
1298		td->is_buttonpad = true;
1299
1300	if (td->is_buttonpad)
1301		__set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
1302
1303	app->pending_palm_slots = devm_kcalloc(&hi->input->dev,
1304					       BITS_TO_LONGS(td->maxcontacts),
1305					       sizeof(long),
1306					       GFP_KERNEL);
1307	if (!app->pending_palm_slots)
1308		return -ENOMEM;
1309
1310	ret = input_mt_init_slots(input, td->maxcontacts, app->mt_flags);
1311	if (ret)
1312		return ret;
1313
1314	app->mt_flags = 0;
1315	return 0;
1316}
1317
1318#define mt_map_key_clear(c)	hid_map_usage_clear(hi, usage, bit, \
1319						    max, EV_KEY, (c))
1320static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
1321		struct hid_field *field, struct hid_usage *usage,
1322		unsigned long **bit, int *max)
1323{
1324	struct mt_device *td = hid_get_drvdata(hdev);
1325	struct mt_application *application;
1326	struct mt_report_data *rdata;
1327
1328	rdata = mt_find_report_data(td, field->report);
1329	if (!rdata) {
1330		hid_err(hdev, "failed to allocate data for report\n");
1331		return 0;
1332	}
1333
1334	application = rdata->application;
1335
1336	/*
1337	 * If mtclass.export_all_inputs is not set, only map fields from
1338	 * TouchScreen or TouchPad collections. We need to ignore fields
1339	 * that belong to other collections such as Mouse that might have
1340	 * the same GenericDesktop usages.
1341	 */
1342	if (!td->mtclass.export_all_inputs &&
1343	    field->application != HID_DG_TOUCHSCREEN &&
1344	    field->application != HID_DG_PEN &&
1345	    field->application != HID_DG_TOUCHPAD &&
1346	    field->application != HID_GD_KEYBOARD &&
1347	    field->application != HID_GD_SYSTEM_CONTROL &&
1348	    field->application != HID_CP_CONSUMER_CONTROL &&
1349	    field->application != HID_GD_WIRELESS_RADIO_CTLS &&
1350	    field->application != HID_GD_SYSTEM_MULTIAXIS &&
1351	    !(field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS &&
1352	      application->quirks & MT_QUIRK_ASUS_CUSTOM_UP))
1353		return -1;
1354
1355	/*
1356	 * Some Asus keyboard+touchpad devices have the hotkeys defined in the
1357	 * touchpad report descriptor. We need to treat these as an array to
1358	 * map usages to input keys.
1359	 */
1360	if (field->application == HID_VD_ASUS_CUSTOM_MEDIA_KEYS &&
1361	    application->quirks & MT_QUIRK_ASUS_CUSTOM_UP &&
1362	    (usage->hid & HID_USAGE_PAGE) == HID_UP_CUSTOM) {
1363		set_bit(EV_REP, hi->input->evbit);
1364		if (field->flags & HID_MAIN_ITEM_VARIABLE)
1365			field->flags &= ~HID_MAIN_ITEM_VARIABLE;
1366		switch (usage->hid & HID_USAGE) {
1367		case 0x10: mt_map_key_clear(KEY_BRIGHTNESSDOWN);	break;
1368		case 0x20: mt_map_key_clear(KEY_BRIGHTNESSUP);		break;
1369		case 0x35: mt_map_key_clear(KEY_DISPLAY_OFF);		break;
1370		case 0x6b: mt_map_key_clear(KEY_F21);			break;
1371		case 0x6c: mt_map_key_clear(KEY_SLEEP);			break;
1372		default:
1373			return -1;
1374		}
1375		return 1;
1376	}
1377
1378	if (rdata->is_mt_collection)
1379		return mt_touch_input_mapping(hdev, hi, field, usage, bit, max,
1380					      application);
1381
1382	/*
1383	 * some egalax touchscreens have "application == DG_TOUCHSCREEN"
1384	 * for the stylus. Overwrite the hid_input application
1385	 */
1386	if (field->physical == HID_DG_STYLUS)
1387		hi->application = HID_DG_STYLUS;
 
 
 
 
 
 
 
 
1388
1389	/* let hid-core decide for the others */
1390	return 0;
1391}
1392
1393static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
1394		struct hid_field *field, struct hid_usage *usage,
1395		unsigned long **bit, int *max)
1396{
1397	struct mt_device *td = hid_get_drvdata(hdev);
1398	struct mt_report_data *rdata;
 
 
 
 
1399
1400	rdata = mt_find_report_data(td, field->report);
1401	if (rdata && rdata->is_mt_collection) {
1402		/* We own these mappings, tell hid-input to ignore them */
1403		return -1;
1404	}
1405
1406	/* let hid-core decide for the others */
1407	return 0;
1408}
1409
1410static int mt_event(struct hid_device *hid, struct hid_field *field,
1411				struct hid_usage *usage, __s32 value)
1412{
1413	struct mt_device *td = hid_get_drvdata(hid);
1414	struct mt_report_data *rdata;
1415
1416	rdata = mt_find_report_data(td, field->report);
1417	if (rdata && rdata->is_mt_collection)
1418		return mt_touch_event(hid, field, usage, value);
1419
1420	return 0;
1421}
1422
1423static void mt_report(struct hid_device *hid, struct hid_report *report)
1424{
1425	struct mt_device *td = hid_get_drvdata(hid);
1426	struct hid_field *field = report->field[0];
1427	struct mt_report_data *rdata;
1428
1429	if (!(hid->claimed & HID_CLAIMED_INPUT))
1430		return;
1431
1432	rdata = mt_find_report_data(td, report);
1433	if (rdata && rdata->is_mt_collection)
1434		return mt_touch_report(hid, rdata);
1435
1436	if (field && field->hidinput && field->hidinput->input)
1437		input_sync(field->hidinput->input);
1438}
1439
1440static bool mt_need_to_apply_feature(struct hid_device *hdev,
1441				     struct hid_field *field,
1442				     struct hid_usage *usage,
1443				     enum latency_mode latency,
1444				     bool surface_switch,
1445				     bool button_switch,
1446				     bool *inputmode_found)
1447{
1448	struct mt_device *td = hid_get_drvdata(hdev);
 
 
1449	struct mt_class *cls = &td->mtclass;
1450	struct hid_report *report = field->report;
1451	unsigned int index = usage->usage_index;
1452	char *buf;
1453	u32 report_len;
1454	int max;
1455
1456	switch (usage->hid) {
1457	case HID_DG_INPUTMODE:
1458		/*
1459		 * Some elan panels wrongly declare 2 input mode features,
1460		 * and silently ignore when we set the value in the second
1461		 * field. Skip the second feature and hope for the best.
1462		 */
1463		if (*inputmode_found)
1464			return false;
1465
 
 
 
1466		if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) {
1467			report_len = hid_report_len(report);
1468			buf = hid_alloc_report_buf(report, GFP_KERNEL);
1469			if (!buf) {
1470				hid_err(hdev,
1471					"failed to allocate buffer for report\n");
1472				return false;
1473			}
1474			hid_hw_raw_request(hdev, report->id, buf, report_len,
1475					   HID_FEATURE_REPORT,
1476					   HID_REQ_GET_REPORT);
1477			kfree(buf);
1478		}
1479
1480		field->value[index] = td->inputmode_value;
1481		*inputmode_found = true;
1482		return true;
1483
1484	case HID_DG_CONTACTMAX:
1485		if (cls->maxcontacts) {
1486			max = min_t(int, field->logical_maximum,
1487				    cls->maxcontacts);
1488			if (field->value[index] != max) {
1489				field->value[index] = max;
1490				return true;
1491			}
1492		}
1493		break;
1494
1495	case HID_DG_LATENCYMODE:
1496		field->value[index] = latency;
1497		return true;
1498
1499	case HID_DG_SURFACESWITCH:
1500		field->value[index] = surface_switch;
1501		return true;
1502
1503	case HID_DG_BUTTONSWITCH:
1504		field->value[index] = button_switch;
1505		return true;
1506	}
1507
1508	return false; /* no need to update the report */
1509}
1510
1511static void mt_set_modes(struct hid_device *hdev, enum latency_mode latency,
1512			 bool surface_switch, bool button_switch)
1513{
1514	struct hid_report_enum *rep_enum;
1515	struct hid_report *rep;
1516	struct hid_usage *usage;
1517	int i, j;
1518	bool update_report;
1519	bool inputmode_found = false;
1520
1521	rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
1522	list_for_each_entry(rep, &rep_enum->report_list, list) {
1523		update_report = false;
1524
1525		for (i = 0; i < rep->maxfield; i++) {
1526			/* Ignore if report count is out of bounds. */
1527			if (rep->field[i]->report_count < 1)
1528				continue;
1529
1530			for (j = 0; j < rep->field[i]->maxusage; j++) {
1531				usage = &rep->field[i]->usage[j];
1532
1533				if (mt_need_to_apply_feature(hdev,
1534							     rep->field[i],
1535							     usage,
1536							     latency,
1537							     surface_switch,
1538							     button_switch,
1539							     &inputmode_found))
1540					update_report = true;
1541			}
1542		}
1543
1544		if (update_report)
1545			hid_hw_request(hdev, rep, HID_REQ_SET_REPORT);
 
 
 
 
 
 
 
 
 
 
 
1546	}
1547}
1548
1549static void mt_post_parse_default_settings(struct mt_device *td,
1550					   struct mt_application *app)
1551{
1552	__s32 quirks = app->quirks;
1553
1554	/* unknown serial device needs special quirks */
1555	if (list_is_singular(&app->mt_usages)) {
1556		quirks |= MT_QUIRK_ALWAYS_VALID;
1557		quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
1558		quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
1559		quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;
1560		quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
1561	}
1562
1563	app->quirks = quirks;
1564}
1565
1566static void mt_post_parse(struct mt_device *td, struct mt_application *app)
1567{
1568	if (!app->have_contact_count)
1569		app->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
 
 
 
 
 
 
 
 
1570}
1571
1572static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
1573{
1574	struct mt_device *td = hid_get_drvdata(hdev);
1575	char *name;
1576	const char *suffix = NULL;
1577	struct mt_report_data *rdata;
1578	struct mt_application *mt_application = NULL;
1579	struct hid_report *report;
1580	int ret;
1581
1582	list_for_each_entry(report, &hi->reports, hidinput_list) {
1583		rdata = mt_find_report_data(td, report);
1584		if (!rdata) {
1585			hid_err(hdev, "failed to allocate data for report\n");
1586			return -ENOMEM;
1587		}
1588
1589		mt_application = rdata->application;
1590
1591		if (rdata->is_mt_collection) {
1592			ret = mt_touch_input_configured(hdev, hi,
1593							mt_application);
1594			if (ret)
1595				return ret;
1596		}
1597	}
1598
1599	switch (hi->application) {
1600	case HID_GD_KEYBOARD:
1601	case HID_GD_KEYPAD:
1602	case HID_GD_MOUSE:
1603	case HID_DG_TOUCHPAD:
1604	case HID_GD_SYSTEM_CONTROL:
1605	case HID_CP_CONSUMER_CONTROL:
1606	case HID_GD_WIRELESS_RADIO_CTLS:
1607	case HID_GD_SYSTEM_MULTIAXIS:
1608		/* already handled by hid core */
1609		break;
1610	case HID_DG_TOUCHSCREEN:
1611		/* we do not set suffix = "Touchscreen" */
1612		hi->input->name = hdev->name;
1613		break;
1614	case HID_VD_ASUS_CUSTOM_MEDIA_KEYS:
1615		suffix = "Custom Media Keys";
1616		break;
1617	case HID_DG_STYLUS:
1618		/* force BTN_STYLUS to allow tablet matching in udev */
1619		__set_bit(BTN_STYLUS, hi->input->keybit);
1620		break;
1621	default:
1622		suffix = "UNKNOWN";
1623		break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1624	}
1625
1626	if (suffix) {
1627		name = devm_kzalloc(&hi->input->dev,
1628				    strlen(hdev->name) + strlen(suffix) + 2,
1629				    GFP_KERNEL);
1630		if (name) {
1631			sprintf(name, "%s %s", hdev->name, suffix);
1632			hi->input->name = name;
1633		}
1634	}
1635
1636	return 0;
1637}
1638
1639static void mt_fix_const_field(struct hid_field *field, unsigned int usage)
1640{
1641	if (field->usage[0].hid != usage ||
1642	    !(field->flags & HID_MAIN_ITEM_CONSTANT))
1643		return;
1644
1645	field->flags &= ~HID_MAIN_ITEM_CONSTANT;
1646	field->flags |= HID_MAIN_ITEM_VARIABLE;
1647}
1648
1649static void mt_fix_const_fields(struct hid_device *hdev, unsigned int usage)
1650{
1651	struct hid_report *report;
1652	int i;
1653
1654	list_for_each_entry(report,
1655			    &hdev->report_enum[HID_INPUT_REPORT].report_list,
1656			    list) {
1657
1658		if (!report->maxfield)
1659			continue;
1660
1661		for (i = 0; i < report->maxfield; i++)
1662			if (report->field[i]->maxusage >= 1)
1663				mt_fix_const_field(report->field[i], usage);
1664	}
1665}
1666
1667static void mt_release_contacts(struct hid_device *hid)
1668{
1669	struct hid_input *hidinput;
1670	struct mt_application *application;
1671	struct mt_device *td = hid_get_drvdata(hid);
1672
1673	list_for_each_entry(hidinput, &hid->inputs, list) {
1674		struct input_dev *input_dev = hidinput->input;
1675		struct input_mt *mt = input_dev->mt;
1676		int i;
1677
1678		if (mt) {
1679			for (i = 0; i < mt->num_slots; i++) {
1680				input_mt_slot(input_dev, i);
1681				input_mt_report_slot_inactive(input_dev);
1682			}
1683			input_mt_sync_frame(input_dev);
1684			input_sync(input_dev);
1685		}
1686	}
1687
1688	list_for_each_entry(application, &td->applications, list) {
1689		application->num_received = 0;
1690	}
1691}
1692
1693static void mt_expired_timeout(struct timer_list *t)
1694{
1695	struct mt_device *td = from_timer(td, t, release_timer);
1696	struct hid_device *hdev = td->hdev;
1697
1698	/*
1699	 * An input report came in just before we release the sticky fingers,
1700	 * it will take care of the sticky fingers.
1701	 */
1702	if (test_and_set_bit_lock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
1703		return;
1704	if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1705		mt_release_contacts(hdev);
1706	clear_bit_unlock(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
1707}
1708
1709static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
1710{
1711	int ret, i;
1712	struct mt_device *td;
1713	const struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
1714
1715	for (i = 0; mt_classes[i].name ; i++) {
1716		if (id->driver_data == mt_classes[i].name) {
1717			mtclass = &(mt_classes[i]);
1718			break;
1719		}
1720	}
1721
1722	td = devm_kzalloc(&hdev->dev, sizeof(struct mt_device), GFP_KERNEL);
1723	if (!td) {
1724		dev_err(&hdev->dev, "cannot allocate multitouch data\n");
1725		return -ENOMEM;
1726	}
1727	td->hdev = hdev;
1728	td->mtclass = *mtclass;
1729	td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN;
1730	hid_set_drvdata(hdev, td);
1731
1732	INIT_LIST_HEAD(&td->applications);
1733	INIT_LIST_HEAD(&td->reports);
1734
1735	if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
1736		td->serial_maybe = true;
1737
1738	/* This allows the driver to correctly support devices
1739	 * that emit events over several HID messages.
1740	 */
1741	hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
1742
1743	/*
1744	 * This allows the driver to handle different input sensors
1745	 * that emits events through different applications on the same HID
1746	 * device.
1747	 */
1748	hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
 
1749
1750	if (id->group != HID_GROUP_MULTITOUCH_WIN_8)
1751		hdev->quirks |= HID_QUIRK_MULTI_INPUT;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1752
1753	if (mtclass->quirks & MT_QUIRK_FORCE_MULTI_INPUT) {
1754		hdev->quirks &= ~HID_QUIRK_INPUT_PER_APP;
1755		hdev->quirks |= HID_QUIRK_MULTI_INPUT;
 
1756	}
 
 
 
 
 
 
 
1757
1758	timer_setup(&td->release_timer, mt_expired_timeout, 0);
 
 
 
 
 
 
 
 
1759
1760	ret = hid_parse(hdev);
1761	if (ret != 0)
1762		return ret;
1763
1764	if (mtclass->quirks & MT_QUIRK_FIX_CONST_CONTACT_ID)
1765		mt_fix_const_fields(hdev, HID_DG_CONTACTID);
1766
1767	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
1768	if (ret)
1769		return ret;
1770
1771	ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
1772	if (ret)
1773		dev_warn(&hdev->dev, "Cannot allocate sysfs group for %s\n",
1774				hdev->name);
1775
1776	mt_set_modes(hdev, HID_LATENCY_NORMAL, true, true);
 
 
 
 
 
1777
1778	return 0;
1779}
1780
1781#ifdef CONFIG_PM
1782static int mt_suspend(struct hid_device *hdev, pm_message_t state)
1783{
1784	struct mt_device *td = hid_get_drvdata(hdev);
1785
1786	/* High latency is desirable for power savings during S3/S0ix */
1787	if ((td->mtclass.quirks & MT_QUIRK_DISABLE_WAKEUP) ||
1788	    !hid_hw_may_wakeup(hdev))
1789		mt_set_modes(hdev, HID_LATENCY_HIGH, false, false);
1790	else
1791		mt_set_modes(hdev, HID_LATENCY_HIGH, true, true);
1792
1793	return 0;
 
 
 
 
 
 
 
 
 
 
1794}
1795
1796static int mt_reset_resume(struct hid_device *hdev)
1797{
1798	mt_release_contacts(hdev);
1799	mt_set_modes(hdev, HID_LATENCY_NORMAL, true, true);
 
1800	return 0;
1801}
1802
1803static int mt_resume(struct hid_device *hdev)
1804{
1805	/* Some Elan legacy devices require SET_IDLE to be set on resume.
1806	 * It should be safe to send it to other devices too.
1807	 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */
1808
1809	hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE);
1810
1811	mt_set_modes(hdev, HID_LATENCY_NORMAL, true, true);
1812
1813	return 0;
1814}
1815#endif
1816
1817static void mt_remove(struct hid_device *hdev)
1818{
1819	struct mt_device *td = hid_get_drvdata(hdev);
1820
1821	del_timer_sync(&td->release_timer);
1822
1823	sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
1824	hid_hw_stop(hdev);
1825}
1826
1827/*
1828 * This list contains only:
1829 * - VID/PID of products not working with the default multitouch handling
1830 * - 2 generic rules.
1831 * So there is no point in adding here any device with MT_CLS_DEFAULT.
1832 */
1833static const struct hid_device_id mt_devices[] = {
1834
1835	/* 3M panels */
1836	{ .driver_data = MT_CLS_3M,
1837		MT_USB_DEVICE(USB_VENDOR_ID_3M,
1838			USB_DEVICE_ID_3M1968) },
1839	{ .driver_data = MT_CLS_3M,
1840		MT_USB_DEVICE(USB_VENDOR_ID_3M,
1841			USB_DEVICE_ID_3M2256) },
1842	{ .driver_data = MT_CLS_3M,
1843		MT_USB_DEVICE(USB_VENDOR_ID_3M,
1844			USB_DEVICE_ID_3M3266) },
1845
1846	/* Anton devices */
1847	{ .driver_data = MT_CLS_EXPORT_ALL_INPUTS,
1848		MT_USB_DEVICE(USB_VENDOR_ID_ANTON,
1849			USB_DEVICE_ID_ANTON_TOUCH_PAD) },
1850
1851	/* Asus T101HA */
1852	{ .driver_data = MT_CLS_WIN_8_DISABLE_WAKEUP,
1853		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
1854			   USB_VENDOR_ID_ASUSTEK,
1855			   USB_DEVICE_ID_ASUSTEK_T101HA_KEYBOARD) },
1856
1857	/* Asus T304UA */
1858	{ .driver_data = MT_CLS_ASUS,
1859		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
1860			USB_VENDOR_ID_ASUSTEK,
1861			USB_DEVICE_ID_ASUSTEK_T304_KEYBOARD) },
1862
1863	/* Atmel panels */
1864	{ .driver_data = MT_CLS_SERIAL,
1865		MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
1866			USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
1867
1868	/* Baanto multitouch devices */
1869	{ .driver_data = MT_CLS_NSMU,
1870		MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
1871			USB_DEVICE_ID_BAANTO_MT_190W2) },
1872
1873	/* Cando panels */
1874	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1875		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1876			USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
1877	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1878		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1879			USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
1880
1881	/* Chunghwa Telecom touch panels */
1882	{  .driver_data = MT_CLS_NSMU,
1883		MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
1884			USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
1885
1886	/* CJTouch panels */
1887	{ .driver_data = MT_CLS_NSMU,
1888		MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
1889			USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020) },
1890	{ .driver_data = MT_CLS_NSMU,
1891		MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
1892			USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040) },
1893
1894	/* CVTouch panels */
1895	{ .driver_data = MT_CLS_NSMU,
1896		MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
1897			USB_DEVICE_ID_CVTOUCH_SCREEN) },
1898
1899	/* eGalax devices (SAW) */
1900	{ .driver_data = MT_CLS_EXPORT_ALL_INPUTS,
1901		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1902			USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER) },
1903
1904	/* eGalax devices (resistive) */
1905	{ .driver_data = MT_CLS_EGALAX,
1906		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1907			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
1908	{ .driver_data = MT_CLS_EGALAX,
1909		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1910			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
1911
1912	/* eGalax devices (capacitive) */
1913	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1914		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1915			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
1916	{ .driver_data = MT_CLS_EGALAX,
1917		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1918			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
1919	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1920		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1921			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
1922	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1923		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1924			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
1925	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1926		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1927			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
1928	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1929		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1930			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
1931	{ .driver_data = MT_CLS_EGALAX,
1932		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1933			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
1934	{ .driver_data = MT_CLS_EGALAX,
1935		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1936			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
1937	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1938		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1939			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
1940	{ .driver_data = MT_CLS_EGALAX,
1941		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1942			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
1943	{ .driver_data = MT_CLS_EGALAX,
1944		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1945			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
1946	{ .driver_data = MT_CLS_EGALAX,
1947		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1948			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
1949	{ .driver_data = MT_CLS_EGALAX,
1950		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1951			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
1952	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1953		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1954			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
1955	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1956		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1957			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) },
1958	{ .driver_data = MT_CLS_EGALAX_SERIAL,
1959		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1960			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
1961	{ .driver_data = MT_CLS_EGALAX,
1962		MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1963			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_C002) },
1964
1965	/* Elan devices */
1966	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
1967		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1968			USB_VENDOR_ID_ELAN, 0x313a) },
1969
1970	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
1971		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1972			USB_VENDOR_ID_ELAN, 0x3148) },
1973
1974	/* Elitegroup panel */
1975	{ .driver_data = MT_CLS_SERIAL,
1976		MT_USB_DEVICE(USB_VENDOR_ID_ELITEGROUP,
1977			USB_DEVICE_ID_ELITEGROUP_05D8) },
1978
1979	/* Flatfrog Panels */
1980	{ .driver_data = MT_CLS_FLATFROG,
1981		MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG,
1982			USB_DEVICE_ID_MULTITOUCH_3200) },
1983
1984	/* FocalTech Panels */
1985	{ .driver_data = MT_CLS_SERIAL,
1986		MT_USB_DEVICE(USB_VENDOR_ID_CYGNAL,
1987			USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH) },
1988
1989	/* GeneralTouch panel */
1990	{ .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
1991		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1992			USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
1993	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1994		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1995			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) },
1996	{ .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
1997		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1998			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0101) },
1999	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2000		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2001			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0102) },
2002	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2003		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2004			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0106) },
2005	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2006		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2007			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A) },
2008	{ .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
2009		MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
2010			USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100) },
2011
2012	/* Gametel game controller */
2013	{ .driver_data = MT_CLS_NSMU,
2014		MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
2015			USB_DEVICE_ID_GAMETEL_MT_MODE) },
2016
2017	/* GoodTouch panels */
2018	{ .driver_data = MT_CLS_NSMU,
2019		MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
2020			USB_DEVICE_ID_GOODTOUCH_000f) },
2021
2022	/* Hanvon panels */
2023	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
2024		MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
2025			USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
2026
2027	/* Ilitek dual touch panel */
2028	{  .driver_data = MT_CLS_NSMU,
2029		MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
2030			USB_DEVICE_ID_ILITEK_MULTITOUCH) },
2031
2032	/* LG Melfas panel */
2033	{ .driver_data = MT_CLS_LG,
2034		HID_USB_DEVICE(USB_VENDOR_ID_LG,
2035			USB_DEVICE_ID_LG_MELFAS_MT) },
2036	{ .driver_data = MT_CLS_LG,
2037		HID_DEVICE(BUS_I2C, HID_GROUP_GENERIC,
2038			USB_VENDOR_ID_LG, I2C_DEVICE_ID_LG_7010) },
2039
2040	/* Lenovo X1 TAB Gen 2 */
2041	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2042		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2043			   USB_VENDOR_ID_LENOVO,
2044			   USB_DEVICE_ID_LENOVO_X1_TAB) },
2045
2046	/* Lenovo X1 TAB Gen 3 */
2047	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2048		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2049			   USB_VENDOR_ID_LENOVO,
2050			   USB_DEVICE_ID_LENOVO_X1_TAB3) },
2051
2052	/* Lenovo X12 TAB Gen 1 */
2053	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT_NSMU,
2054		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
2055			   USB_VENDOR_ID_LENOVO,
2056			   USB_DEVICE_ID_LENOVO_X12_TAB) },
2057
2058	/* MosArt panels */
2059	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2060		MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
2061			USB_DEVICE_ID_ASUS_T91MT)},
2062	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2063		MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
2064			USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
2065	{ .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
2066		MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
2067			USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
2068
2069	/* Novatek Panel */
2070	{ .driver_data = MT_CLS_NSMU,
2071		MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
2072			USB_DEVICE_ID_NOVATEK_PCT) },
2073
2074	/* Ntrig Panel */
2075	{ .driver_data = MT_CLS_NSMU,
2076		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2077			USB_VENDOR_ID_NTRIG, 0x1b05) },
2078
2079	/* Panasonic panels */
2080	{ .driver_data = MT_CLS_PANASONIC,
2081		MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
2082			USB_DEVICE_ID_PANABOARD_UBT780) },
2083	{ .driver_data = MT_CLS_PANASONIC,
2084		MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
2085			USB_DEVICE_ID_PANABOARD_UBT880) },
2086
 
 
 
 
 
2087	/* PixArt optical touch screen */
2088	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2089		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
2090			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
2091	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2092		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
2093			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
2094	{ .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
2095		MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
2096			USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
2097
2098	/* PixCir-based panels */
2099	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
2100		MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
2101			USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
2102
2103	/* Quanta-based panels */
2104	{ .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
2105		MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
2106			USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
2107
2108	/* Razer touchpads */
2109	{ .driver_data = MT_CLS_RAZER_BLADE_STEALTH,
2110		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2111			USB_VENDOR_ID_SYNAPTICS, 0x8323) },
2112
2113	/* Smart Tech panels */
2114	{ .driver_data = MT_CLS_SMART_TECH,
2115		MT_USB_DEVICE(0x0b8c, 0x0092)},
2116
2117	/* Stantum panels */
2118	{ .driver_data = MT_CLS_CONFIDENCE,
2119		MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
2120			USB_DEVICE_ID_MTP_STM)},
2121
2122	/* Synaptics devices */
2123	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2124		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2125			USB_VENDOR_ID_SYNAPTICS, 0xce08) },
2126
2127	{ .driver_data = MT_CLS_WIN_8_FORCE_MULTI_INPUT,
2128		HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
2129			USB_VENDOR_ID_SYNAPTICS, 0xce09) },
2130
2131	/* TopSeed panels */
2132	{ .driver_data = MT_CLS_TOPSEED,
2133		MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
2134			USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },
2135
2136	/* Touch International panels */
2137	{ .driver_data = MT_CLS_NSMU,
2138		MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
2139			USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
2140
2141	/* Unitec panels */
2142	{ .driver_data = MT_CLS_NSMU,
2143		MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
2144			USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
2145	{ .driver_data = MT_CLS_NSMU,
2146		MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
2147			USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
2148
2149	/* VTL panels */
2150	{ .driver_data = MT_CLS_VTL,
2151		MT_USB_DEVICE(USB_VENDOR_ID_VTL,
2152			USB_DEVICE_ID_VTL_MULTITOUCH_FF3F) },
2153
2154	/* Winbond Electronics Corp. */
2155	{ .driver_data = MT_CLS_WIN_8_NO_STICKY_FINGERS,
2156		HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8,
2157			   USB_VENDOR_ID_WINBOND, USB_DEVICE_ID_TSTP_MTOUCH) },
2158
2159	/* Wistron panels */
2160	{ .driver_data = MT_CLS_NSMU,
2161		MT_USB_DEVICE(USB_VENDOR_ID_WISTRON,
2162			USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH) },
2163
2164	/* XAT */
2165	{ .driver_data = MT_CLS_NSMU,
2166		MT_USB_DEVICE(USB_VENDOR_ID_XAT,
2167			USB_DEVICE_ID_XAT_CSR) },
2168
2169	/* Xiroku */
2170	{ .driver_data = MT_CLS_NSMU,
2171		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2172			USB_DEVICE_ID_XIROKU_SPX) },
2173	{ .driver_data = MT_CLS_NSMU,
2174		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2175			USB_DEVICE_ID_XIROKU_MPX) },
2176	{ .driver_data = MT_CLS_NSMU,
2177		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2178			USB_DEVICE_ID_XIROKU_CSR) },
2179	{ .driver_data = MT_CLS_NSMU,
2180		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2181			USB_DEVICE_ID_XIROKU_SPX1) },
2182	{ .driver_data = MT_CLS_NSMU,
2183		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2184			USB_DEVICE_ID_XIROKU_MPX1) },
2185	{ .driver_data = MT_CLS_NSMU,
2186		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2187			USB_DEVICE_ID_XIROKU_CSR1) },
2188	{ .driver_data = MT_CLS_NSMU,
2189		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2190			USB_DEVICE_ID_XIROKU_SPX2) },
2191	{ .driver_data = MT_CLS_NSMU,
2192		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2193			USB_DEVICE_ID_XIROKU_MPX2) },
2194	{ .driver_data = MT_CLS_NSMU,
2195		MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
2196			USB_DEVICE_ID_XIROKU_CSR2) },
2197
2198	/* Google MT devices */
2199	{ .driver_data = MT_CLS_GOOGLE,
2200		HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_GOOGLE,
2201			USB_DEVICE_ID_GOOGLE_TOUCH_ROSE) },
2202	{ .driver_data = MT_CLS_GOOGLE,
2203		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8, USB_VENDOR_ID_GOOGLE,
2204			USB_DEVICE_ID_GOOGLE_WHISKERS) },
2205
2206	/* Generic MT device */
2207	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
2208
2209	/* Generic Win 8 certified MT device */
2210	{  .driver_data = MT_CLS_WIN_8,
2211		HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8,
2212			HID_ANY_ID, HID_ANY_ID) },
2213	{ }
2214};
2215MODULE_DEVICE_TABLE(hid, mt_devices);
2216
2217static const struct hid_usage_id mt_grabbed_usages[] = {
2218	{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
2219	{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
2220};
2221
2222static struct hid_driver mt_driver = {
2223	.name = "hid-multitouch",
2224	.id_table = mt_devices,
2225	.probe = mt_probe,
2226	.remove = mt_remove,
2227	.input_mapping = mt_input_mapping,
2228	.input_mapped = mt_input_mapped,
2229	.input_configured = mt_input_configured,
2230	.feature_mapping = mt_feature_mapping,
2231	.usage_table = mt_grabbed_usages,
2232	.event = mt_event,
2233	.report = mt_report,
2234#ifdef CONFIG_PM
2235	.suspend = mt_suspend,
2236	.reset_resume = mt_reset_resume,
2237	.resume = mt_resume,
2238#endif
2239};
2240module_hid_driver(mt_driver);