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