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