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