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