1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  HID driver for N-Trig touchscreens
   4 *
   5 *  Copyright (c) 2008-2010 Rafi Rubin
   6 *  Copyright (c) 2009-2010 Stephane Chatty
   7 */
   8
   9/*
  10 */
  11
  12#include <linux/device.h>
  13#include <linux/hid.h>
  14#include <linux/usb.h>
  15#include "usbhid/usbhid.h"
  16#include <linux/module.h>
  17#include <linux/slab.h>
  18
  19#include "hid-ids.h"
  20
  21#define NTRIG_DUPLICATE_USAGES	0x001
  22
  23static unsigned int min_width;
  24module_param(min_width, uint, 0644);
  25MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept.");
  26
  27static unsigned int min_height;
  28module_param(min_height, uint, 0644);
  29MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept.");
  30
  31static unsigned int activate_slack = 1;
  32module_param(activate_slack, uint, 0644);
  33MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at "
  34		 "the start of touch input.");
  35
  36static unsigned int deactivate_slack = 4;
  37module_param(deactivate_slack, uint, 0644);
  38MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before "
  39		 "deactivating touch.");
  40
  41static unsigned int activation_width = 64;
  42module_param(activation_width, uint, 0644);
  43MODULE_PARM_DESC(activation_width, "Width threshold to immediately start "
  44		 "processing touch events.");
  45
  46static unsigned int activation_height = 32;
  47module_param(activation_height, uint, 0644);
  48MODULE_PARM_DESC(activation_height, "Height threshold to immediately start "
  49		 "processing touch events.");
  50
  51struct ntrig_data {
  52	/* Incoming raw values for a single contact */
  53	__u16 x, y, w, h;
  54	__u16 id;
  55
  56	bool tipswitch;
  57	bool confidence;
  58	bool first_contact_touch;
  59
  60	bool reading_mt;
  61
  62	__u8 mt_footer[4];
  63	__u8 mt_foot_count;
  64
  65	/* The current activation state. */
  66	__s8 act_state;
  67
  68	/* Empty frames to ignore before recognizing the end of activity */
  69	__s8 deactivate_slack;
  70
  71	/* Frames to ignore before acknowledging the start of activity */
  72	__s8 activate_slack;
  73
  74	/* Minimum size contact to accept */
  75	__u16 min_width;
  76	__u16 min_height;
  77
  78	/* Threshold to override activation slack */
  79	__u16 activation_width;
  80	__u16 activation_height;
  81
  82	__u16 sensor_logical_width;
  83	__u16 sensor_logical_height;
  84	__u16 sensor_physical_width;
  85	__u16 sensor_physical_height;
  86};
  87
  88
  89/*
  90 * This function converts the 4 byte raw firmware code into
  91 * a string containing 5 comma separated numbers.
  92 */
  93static int ntrig_version_string(unsigned char *raw, char *buf)
  94{
  95	__u8 a =  (raw[1] & 0x0e) >> 1;
  96	__u8 b =  (raw[0] & 0x3c) >> 2;
  97	__u8 c = ((raw[0] & 0x03) << 3) | ((raw[3] & 0xe0) >> 5);
  98	__u8 d = ((raw[3] & 0x07) << 3) | ((raw[2] & 0xe0) >> 5);
  99	__u8 e =   raw[2] & 0x07;
 100
 101	/*
 102	 * As yet unmapped bits:
 103	 * 0b11000000 0b11110001 0b00011000 0b00011000
 104	 */
 105
 106	return sprintf(buf, "%u.%u.%u.%u.%u", a, b, c, d, e);
 107}
 108
 109static inline int ntrig_get_mode(struct hid_device *hdev)
 110{
 111	struct hid_report *report = hdev->report_enum[HID_FEATURE_REPORT].
 112				    report_id_hash[0x0d];
 113
 114	if (!report || report->maxfield < 1 ||
 115	    report->field[0]->report_count < 1)
 116		return -EINVAL;
 117
 118	hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
 119	hid_hw_wait(hdev);
 120	return (int)report->field[0]->value[0];
 121}
 122
 123static inline void ntrig_set_mode(struct hid_device *hdev, const int mode)
 124{
 125	struct hid_report *report;
 126	__u8 mode_commands[4] = { 0xe, 0xf, 0x1b, 0x10 };
 127
 128	if (mode < 0 || mode > 3)
 129		return;
 130
 131	report = hdev->report_enum[HID_FEATURE_REPORT].
 132		 report_id_hash[mode_commands[mode]];
 133
 134	if (!report)
 135		return;
 136
 137	hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
 138}
 139
 140static void ntrig_report_version(struct hid_device *hdev)
 141{
 142	int ret;
 143	char buf[20];
 144	struct usb_device *usb_dev = hid_to_usb_dev(hdev);
 145	unsigned char *data = kmalloc(8, GFP_KERNEL);
 146
 147	if (!data)
 148		goto err_free;
 149
 150	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
 151			      USB_REQ_CLEAR_FEATURE,
 152			      USB_TYPE_CLASS | USB_RECIP_INTERFACE |
 153			      USB_DIR_IN,
 154			      0x30c, 1, data, 8,
 155			      USB_CTRL_SET_TIMEOUT);
 156
 157	if (ret == 8) {
 158		ret = ntrig_version_string(&data[2], buf);
 159
 160		hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n",
 161			 buf, data[2], data[3], data[4], data[5]);
 162	}
 163
 164err_free:
 165	kfree(data);
 166}
 167
 168static ssize_t show_phys_width(struct device *dev,
 169			       struct device_attribute *attr,
 170			       char *buf)
 171{
 172	struct hid_device *hdev = to_hid_device(dev);
 173	struct ntrig_data *nd = hid_get_drvdata(hdev);
 174
 175	return sprintf(buf, "%d\n", nd->sensor_physical_width);
 176}
 177
 178static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
 179
 180static ssize_t show_phys_height(struct device *dev,
 181				struct device_attribute *attr,
 182				char *buf)
 183{
 184	struct hid_device *hdev = to_hid_device(dev);
 185	struct ntrig_data *nd = hid_get_drvdata(hdev);
 186
 187	return sprintf(buf, "%d\n", nd->sensor_physical_height);
 188}
 189
 190static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
 191
 192static ssize_t show_log_width(struct device *dev,
 193			      struct device_attribute *attr,
 194			      char *buf)
 195{
 196	struct hid_device *hdev = to_hid_device(dev);
 197	struct ntrig_data *nd = hid_get_drvdata(hdev);
 198
 199	return sprintf(buf, "%d\n", nd->sensor_logical_width);
 200}
 201
 202static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
 203
 204static ssize_t show_log_height(struct device *dev,
 205			       struct device_attribute *attr,
 206			       char *buf)
 207{
 208	struct hid_device *hdev = to_hid_device(dev);
 209	struct ntrig_data *nd = hid_get_drvdata(hdev);
 210
 211	return sprintf(buf, "%d\n", nd->sensor_logical_height);
 212}
 213
 214static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
 215
 216static ssize_t show_min_width(struct device *dev,
 217			      struct device_attribute *attr,
 218			      char *buf)
 219{
 220	struct hid_device *hdev = to_hid_device(dev);
 221	struct ntrig_data *nd = hid_get_drvdata(hdev);
 222
 223	return sprintf(buf, "%d\n", nd->min_width *
 224				    nd->sensor_physical_width /
 225				    nd->sensor_logical_width);
 226}
 227
 228static ssize_t set_min_width(struct device *dev,
 229			     struct device_attribute *attr,
 230			     const char *buf, size_t count)
 231{
 232	struct hid_device *hdev = to_hid_device(dev);
 233	struct ntrig_data *nd = hid_get_drvdata(hdev);
 234
 235	unsigned long val;
 236
 237	if (kstrtoul(buf, 0, &val))
 238		return -EINVAL;
 239
 240	if (val > nd->sensor_physical_width)
 241		return -EINVAL;
 242
 243	nd->min_width = val * nd->sensor_logical_width /
 244			      nd->sensor_physical_width;
 245
 246	return count;
 247}
 248
 249static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);
 250
 251static ssize_t show_min_height(struct device *dev,
 252			       struct device_attribute *attr,
 253			       char *buf)
 254{
 255	struct hid_device *hdev = to_hid_device(dev);
 256	struct ntrig_data *nd = hid_get_drvdata(hdev);
 257
 258	return sprintf(buf, "%d\n", nd->min_height *
 259				    nd->sensor_physical_height /
 260				    nd->sensor_logical_height);
 261}
 262
 263static ssize_t set_min_height(struct device *dev,
 264			      struct device_attribute *attr,
 265			      const char *buf, size_t count)
 266{
 267	struct hid_device *hdev = to_hid_device(dev);
 268	struct ntrig_data *nd = hid_get_drvdata(hdev);
 269
 270	unsigned long val;
 271
 272	if (kstrtoul(buf, 0, &val))
 273		return -EINVAL;
 274
 275	if (val > nd->sensor_physical_height)
 276		return -EINVAL;
 277
 278	nd->min_height = val * nd->sensor_logical_height /
 279			       nd->sensor_physical_height;
 280
 281	return count;
 282}
 283
 284static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,
 285		   set_min_height);
 286
 287static ssize_t show_activate_slack(struct device *dev,
 288				   struct device_attribute *attr,
 289				   char *buf)
 290{
 291	struct hid_device *hdev = to_hid_device(dev);
 292	struct ntrig_data *nd = hid_get_drvdata(hdev);
 293
 294	return sprintf(buf, "%d\n", nd->activate_slack);
 295}
 296
 297static ssize_t set_activate_slack(struct device *dev,
 298				  struct device_attribute *attr,
 299				  const char *buf, size_t count)
 300{
 301	struct hid_device *hdev = to_hid_device(dev);
 302	struct ntrig_data *nd = hid_get_drvdata(hdev);
 303
 304	unsigned long val;
 305
 306	if (kstrtoul(buf, 0, &val))
 307		return -EINVAL;
 308
 309	if (val > 0x7f)
 310		return -EINVAL;
 311
 312	nd->activate_slack = val;
 313
 314	return count;
 315}
 316
 317static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,
 318		   set_activate_slack);
 319
 320static ssize_t show_activation_width(struct device *dev,
 321				     struct device_attribute *attr,
 322				     char *buf)
 323{
 324	struct hid_device *hdev = to_hid_device(dev);
 325	struct ntrig_data *nd = hid_get_drvdata(hdev);
 326
 327	return sprintf(buf, "%d\n", nd->activation_width *
 328				    nd->sensor_physical_width /
 329				    nd->sensor_logical_width);
 330}
 331
 332static ssize_t set_activation_width(struct device *dev,
 333				    struct device_attribute *attr,
 334				    const char *buf, size_t count)
 335{
 336	struct hid_device *hdev = to_hid_device(dev);
 337	struct ntrig_data *nd = hid_get_drvdata(hdev);
 338
 339	unsigned long val;
 340
 341	if (kstrtoul(buf, 0, &val))
 342		return -EINVAL;
 343
 344	if (val > nd->sensor_physical_width)
 345		return -EINVAL;
 346
 347	nd->activation_width = val * nd->sensor_logical_width /
 348				     nd->sensor_physical_width;
 349
 350	return count;
 351}
 352
 353static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,
 354		   set_activation_width);
 355
 356static ssize_t show_activation_height(struct device *dev,
 357				      struct device_attribute *attr,
 358				      char *buf)
 359{
 360	struct hid_device *hdev = to_hid_device(dev);
 361	struct ntrig_data *nd = hid_get_drvdata(hdev);
 362
 363	return sprintf(buf, "%d\n", nd->activation_height *
 364				    nd->sensor_physical_height /
 365				    nd->sensor_logical_height);
 366}
 367
 368static ssize_t set_activation_height(struct device *dev,
 369				     struct device_attribute *attr,
 370				     const char *buf, size_t count)
 371{
 372	struct hid_device *hdev = to_hid_device(dev);
 373	struct ntrig_data *nd = hid_get_drvdata(hdev);
 374
 375	unsigned long val;
 376
 377	if (kstrtoul(buf, 0, &val))
 378		return -EINVAL;
 379
 380	if (val > nd->sensor_physical_height)
 381		return -EINVAL;
 382
 383	nd->activation_height = val * nd->sensor_logical_height /
 384				      nd->sensor_physical_height;
 385
 386	return count;
 387}
 388
 389static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,
 390		   show_activation_height, set_activation_height);
 391
 392static ssize_t show_deactivate_slack(struct device *dev,
 393				     struct device_attribute *attr,
 394				     char *buf)
 395{
 396	struct hid_device *hdev = to_hid_device(dev);
 397	struct ntrig_data *nd = hid_get_drvdata(hdev);
 398
 399	return sprintf(buf, "%d\n", -nd->deactivate_slack);
 400}
 401
 402static ssize_t set_deactivate_slack(struct device *dev,
 403				    struct device_attribute *attr,
 404				    const char *buf, size_t count)
 405{
 406	struct hid_device *hdev = to_hid_device(dev);
 407	struct ntrig_data *nd = hid_get_drvdata(hdev);
 408
 409	unsigned long val;
 410
 411	if (kstrtoul(buf, 0, &val))
 412		return -EINVAL;
 413
 414	/*
 415	 * No more than 8 terminal frames have been observed so far
 416	 * and higher slack is highly likely to leave the single
 417	 * touch emulation stuck down.
 418	 */
 419	if (val > 7)
 420		return -EINVAL;
 421
 422	nd->deactivate_slack = -val;
 423
 424	return count;
 425}
 426
 427static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack,
 428		   set_deactivate_slack);
 429
 430static struct attribute *sysfs_attrs[] = {
 431	&dev_attr_sensor_physical_width.attr,
 432	&dev_attr_sensor_physical_height.attr,
 433	&dev_attr_sensor_logical_width.attr,
 434	&dev_attr_sensor_logical_height.attr,
 435	&dev_attr_min_height.attr,
 436	&dev_attr_min_width.attr,
 437	&dev_attr_activate_slack.attr,
 438	&dev_attr_activation_width.attr,
 439	&dev_attr_activation_height.attr,
 440	&dev_attr_deactivate_slack.attr,
 441	NULL
 442};
 443
 444static const struct attribute_group ntrig_attribute_group = {
 445	.attrs = sysfs_attrs
 446};
 447
 448/*
 449 * this driver is aimed at two firmware versions in circulation:
 450 *  - dual pen/finger single touch
 451 *  - finger multitouch, pen not working
 452 */
 453
 454static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 455			       struct hid_field *field, struct hid_usage *usage,
 456			       unsigned long **bit, int *max)
 457{
 458	struct ntrig_data *nd = hid_get_drvdata(hdev);
 459
 460	/* No special mappings needed for the pen and single touch */
 461	if (field->physical)
 462		return 0;
 463
 464	switch (usage->hid & HID_USAGE_PAGE) {
 465	case HID_UP_GENDESK:
 466		switch (usage->hid) {
 467		case HID_GD_X:
 468			hid_map_usage(hi, usage, bit, max,
 469					EV_ABS, ABS_MT_POSITION_X);
 470			input_set_abs_params(hi->input, ABS_X,
 471					field->logical_minimum,
 472					field->logical_maximum, 0, 0);
 473
 474			if (!nd->sensor_logical_width) {
 475				nd->sensor_logical_width =
 476					field->logical_maximum -
 477					field->logical_minimum;
 478				nd->sensor_physical_width =
 479					field->physical_maximum -
 480					field->physical_minimum;
 481				nd->activation_width = activation_width *
 482					nd->sensor_logical_width /
 483					nd->sensor_physical_width;
 484				nd->min_width = min_width *
 485					nd->sensor_logical_width /
 486					nd->sensor_physical_width;
 487			}
 488			return 1;
 489		case HID_GD_Y:
 490			hid_map_usage(hi, usage, bit, max,
 491					EV_ABS, ABS_MT_POSITION_Y);
 492			input_set_abs_params(hi->input, ABS_Y,
 493					field->logical_minimum,
 494					field->logical_maximum, 0, 0);
 495
 496			if (!nd->sensor_logical_height) {
 497				nd->sensor_logical_height =
 498					field->logical_maximum -
 499					field->logical_minimum;
 500				nd->sensor_physical_height =
 501					field->physical_maximum -
 502					field->physical_minimum;
 503				nd->activation_height = activation_height *
 504					nd->sensor_logical_height /
 505					nd->sensor_physical_height;
 506				nd->min_height = min_height *
 507					nd->sensor_logical_height /
 508					nd->sensor_physical_height;
 509			}
 510			return 1;
 511		}
 512		return 0;
 513
 514	case HID_UP_DIGITIZER:
 515		switch (usage->hid) {
 516		/* we do not want to map these for now */
 517		case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */
 518		case HID_DG_INPUTMODE:
 519		case HID_DG_DEVICEINDEX:
 520		case HID_DG_CONTACTMAX:
 521			return -1;
 522
 523		/* width/height mapped on TouchMajor/TouchMinor/Orientation */
 524		case HID_DG_WIDTH:
 525			hid_map_usage(hi, usage, bit, max,
 526				      EV_ABS, ABS_MT_TOUCH_MAJOR);
 527			return 1;
 528		case HID_DG_HEIGHT:
 529			hid_map_usage(hi, usage, bit, max,
 530				      EV_ABS, ABS_MT_TOUCH_MINOR);
 531			input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
 532					     0, 1, 0, 0);
 533			return 1;
 534		}
 535		return 0;
 536
 537	case 0xff000000:
 538		/* we do not want to map these: no input-oriented meaning */
 539		return -1;
 540	}
 541
 542	return 0;
 543}
 544
 545static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 546			      struct hid_field *field, struct hid_usage *usage,
 547			      unsigned long **bit, int *max)
 548{
 549	/* No special mappings needed for the pen and single touch */
 550	if (field->physical)
 551		return 0;
 552
 553	if (usage->type == EV_KEY || usage->type == EV_REL
 554			|| usage->type == EV_ABS)
 555		clear_bit(usage->code, *bit);
 556
 557	return 0;
 558}
 559
 560/*
 561 * this function is called upon all reports
 562 * so that we can filter contact point information,
 563 * decide whether we are in multi or single touch mode
 564 * and call input_mt_sync after each point if necessary
 565 */
 566static int ntrig_event (struct hid_device *hid, struct hid_field *field,
 567			struct hid_usage *usage, __s32 value)
 568{
 569	struct ntrig_data *nd = hid_get_drvdata(hid);
 570	struct input_dev *input;
 571
 572	/* Skip processing if not a claimed input */
 573	if (!(hid->claimed & HID_CLAIMED_INPUT))
 574		goto not_claimed_input;
 575
 576	/* This function is being called before the structures are fully
 577	 * initialized */
 578	if(!(field->hidinput && field->hidinput->input))
 579		return -EINVAL;
 580
 581	input = field->hidinput->input;
 582
 583	/* No special handling needed for the pen */
 584	if (field->application == HID_DG_PEN)
 585		return 0;
 586
 587	switch (usage->hid) {
 588	case 0xff000001:
 589		/* Tag indicating the start of a multitouch group */
 590		nd->reading_mt = true;
 591		nd->first_contact_touch = false;
 592		break;
 593	case HID_DG_TIPSWITCH:
 594		nd->tipswitch = value;
 595		/* Prevent emission of touch until validated */
 596		return 1;
 597	case HID_DG_CONFIDENCE:
 598		nd->confidence = value;
 599		break;
 600	case HID_GD_X:
 601		nd->x = value;
 602		/* Clear the contact footer */
 603		nd->mt_foot_count = 0;
 604		break;
 605	case HID_GD_Y:
 606		nd->y = value;
 607		break;
 608	case HID_DG_CONTACTID:
 609		nd->id = value;
 610		break;
 611	case HID_DG_WIDTH:
 612		nd->w = value;
 613		break;
 614	case HID_DG_HEIGHT:
 615		nd->h = value;
 616		/*
 617		 * when in single touch mode, this is the last
 618		 * report received in a finger event. We want
 619		 * to emit a normal (X, Y) position
 620		 */
 621		if (!nd->reading_mt) {
 622			/*
 623			 * TipSwitch indicates the presence of a
 624			 * finger in single touch mode.
 625			 */
 626			input_report_key(input, BTN_TOUCH,
 627					 nd->tipswitch);
 628			input_report_key(input, BTN_TOOL_DOUBLETAP,
 629					 nd->tipswitch);
 630			input_event(input, EV_ABS, ABS_X, nd->x);
 631			input_event(input, EV_ABS, ABS_Y, nd->y);
 632		}
 633		break;
 634	case 0xff000002:
 635		/*
 636		 * we receive this when the device is in multitouch
 637		 * mode. The first of the three values tagged with
 638		 * this usage tells if the contact point is real
 639		 * or a placeholder
 640		 */
 641
 642		/* Shouldn't get more than 4 footer packets, so skip */
 643		if (nd->mt_foot_count >= 4)
 644			break;
 645
 646		nd->mt_footer[nd->mt_foot_count++] = value;
 647
 648		/* if the footer isn't complete break */
 649		if (nd->mt_foot_count != 4)
 650			break;
 651
 652		/* Pen activity signal. */
 653		if (nd->mt_footer[2]) {
 654			/*
 655			 * When the pen deactivates touch, we see a
 656			 * bogus frame with ContactCount > 0.
 657			 * We can
 658			 * save a bit of work by ensuring act_state < 0
 659			 * even if deactivation slack is turned off.
 660			 */
 661			nd->act_state = deactivate_slack - 1;
 662			nd->confidence = false;
 663			break;
 664		}
 665
 666		/*
 667		 * The first footer value indicates the presence of a
 668		 * finger.
 669		 */
 670		if (nd->mt_footer[0]) {
 671			/*
 672			 * We do not want to process contacts under
 673			 * the size threshold, but do not want to
 674			 * ignore them for activation state
 675			 */
 676			if (nd->w < nd->min_width ||
 677			    nd->h < nd->min_height)
 678				nd->confidence = false;
 679		} else
 680			break;
 681
 682		if (nd->act_state > 0) {
 683			/*
 684			 * Contact meets the activation size threshold
 685			 */
 686			if (nd->w >= nd->activation_width &&
 687			    nd->h >= nd->activation_height) {
 688				if (nd->id)
 689					/*
 690					 * first contact, activate now
 691					 */
 692					nd->act_state = 0;
 693				else {
 694					/*
 695					 * avoid corrupting this frame
 696					 * but ensure next frame will
 697					 * be active
 698					 */
 699					nd->act_state = 1;
 700					break;
 701				}
 702			} else
 703				/*
 704				 * Defer adjusting the activation state
 705				 * until the end of the frame.
 706				 */
 707				break;
 708		}
 709
 710		/* Discarding this contact */
 711		if (!nd->confidence)
 712			break;
 713
 714		/* emit a normal (X, Y) for the first point only */
 715		if (nd->id == 0) {
 716			/*
 717			 * TipSwitch is superfluous in multitouch
 718			 * mode.  The footer events tell us
 719			 * if there is a finger on the screen or
 720			 * not.
 721			 */
 722			nd->first_contact_touch = nd->confidence;
 723			input_event(input, EV_ABS, ABS_X, nd->x);
 724			input_event(input, EV_ABS, ABS_Y, nd->y);
 725		}
 726
 727		/* Emit MT events */
 728		input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
 729		input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
 730
 731		/*
 732		 * Translate from height and width to size
 733		 * and orientation.
 734		 */
 735		if (nd->w > nd->h) {
 736			input_event(input, EV_ABS,
 737					ABS_MT_ORIENTATION, 1);
 738			input_event(input, EV_ABS,
 739					ABS_MT_TOUCH_MAJOR, nd->w);
 740			input_event(input, EV_ABS,
 741					ABS_MT_TOUCH_MINOR, nd->h);
 742		} else {
 743			input_event(input, EV_ABS,
 744					ABS_MT_ORIENTATION, 0);
 745			input_event(input, EV_ABS,
 746					ABS_MT_TOUCH_MAJOR, nd->h);
 747			input_event(input, EV_ABS,
 748					ABS_MT_TOUCH_MINOR, nd->w);
 749		}
 750		input_mt_sync(field->hidinput->input);
 751		break;
 752
 753	case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
 754		if (!nd->reading_mt) /* Just to be sure */
 755			break;
 756
 757		nd->reading_mt = false;
 758
 759
 760		/*
 761		 * Activation state machine logic:
 762		 *
 763		 * Fundamental states:
 764		 *	state >  0: Inactive
 765		 *	state <= 0: Active
 766		 *	state <  -deactivate_slack:
 767		 *		 Pen termination of touch
 768		 *
 769		 * Specific values of interest
 770		 *	state == activate_slack
 771		 *		 no valid input since the last reset
 772		 *
 773		 *	state == 0
 774		 *		 general operational state
 775		 *
 776		 *	state == -deactivate_slack
 777		 *		 read sufficient empty frames to accept
 778		 *		 the end of input and reset
 779		 */
 780
 781		if (nd->act_state > 0) { /* Currently inactive */
 782			if (value)
 783				/*
 784				 * Consider each live contact as
 785				 * evidence of intentional activity.
 786				 */
 787				nd->act_state = (nd->act_state > value)
 788						? nd->act_state - value
 789						: 0;
 790			else
 791				/*
 792				 * Empty frame before we hit the
 793				 * activity threshold, reset.
 794				 */
 795				nd->act_state = nd->activate_slack;
 796
 797			/*
 798			 * Entered this block inactive and no
 799			 * coordinates sent this frame, so hold off
 800			 * on button state.
 801			 */
 802			break;
 803		} else { /* Currently active */
 804			if (value && nd->act_state >=
 805				     nd->deactivate_slack)
 806				/*
 807				 * Live point: clear accumulated
 808				 * deactivation count.
 809				 */
 810				nd->act_state = 0;
 811			else if (nd->act_state <= nd->deactivate_slack)
 812				/*
 813				 * We've consumed the deactivation
 814				 * slack, time to deactivate and reset.
 815				 */
 816				nd->act_state =
 817					nd->activate_slack;
 818			else { /* Move towards deactivation */
 819				nd->act_state--;
 820				break;
 821			}
 822		}
 823
 824		if (nd->first_contact_touch && nd->act_state <= 0) {
 825			/*
 826			 * Check to see if we're ready to start
 827			 * emitting touch events.
 828			 *
 829			 * Note: activation slack will decrease over
 830			 * the course of the frame, and it will be
 831			 * inconsistent from the start to the end of
 832			 * the frame.  However if the frame starts
 833			 * with slack, first_contact_touch will still
 834			 * be 0 and we will not get to this point.
 835			 */
 836			input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
 837			input_report_key(input, BTN_TOUCH, 1);
 838		} else {
 839			input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
 840			input_report_key(input, BTN_TOUCH, 0);
 841		}
 842		break;
 843
 844	default:
 845		/* fall-back to the generic hidinput handling */
 846		return 0;
 847	}
 848
 849not_claimed_input:
 850
 851	/* we have handled the hidinput part, now remains hiddev */
 852	if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
 853		hid->hiddev_hid_event(hid, field, usage, value);
 854
 855	return 1;
 856}
 857
 858static int ntrig_input_configured(struct hid_device *hid,
 859		struct hid_input *hidinput)
 860
 861{
 862	struct input_dev *input = hidinput->input;
 863
 864	if (hidinput->report->maxfield < 1)
 865		return 0;
 866
 867	switch (hidinput->report->field[0]->application) {
 868	case HID_DG_PEN:
 869		input->name = "N-Trig Pen";
 870		break;
 871	case HID_DG_TOUCHSCREEN:
 872		/* These keys are redundant for fingers, clear them
 873		 * to prevent incorrect identification */
 874		__clear_bit(BTN_TOOL_PEN, input->keybit);
 875		__clear_bit(BTN_TOOL_FINGER, input->keybit);
 876		__clear_bit(BTN_0, input->keybit);
 877		__set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
 878		/*
 879		 * The physical touchscreen (single touch)
 880		 * input has a value for physical, whereas
 881		 * the multitouch only has logical input
 882		 * fields.
 883		 */
 884		input->name = (hidinput->report->field[0]->physical) ?
 885							"N-Trig Touchscreen" :
 886							"N-Trig MultiTouch";
 887		break;
 888	}
 889
 890	return 0;
 891}
 892
 893static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
 894{
 895	int ret;
 896	struct ntrig_data *nd;
 897	struct hid_report *report;
 898
 899	if (id->driver_data)
 900		hdev->quirks |= HID_QUIRK_MULTI_INPUT
 901				| HID_QUIRK_NO_INIT_REPORTS;
 902
 903	nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
 904	if (!nd) {
 905		hid_err(hdev, "cannot allocate N-Trig data\n");
 906		return -ENOMEM;
 907	}
 908
 909	nd->reading_mt = false;
 910	nd->min_width = 0;
 911	nd->min_height = 0;
 912	nd->activate_slack = activate_slack;
 913	nd->act_state = activate_slack;
 914	nd->deactivate_slack = -deactivate_slack;
 915	nd->sensor_logical_width = 1;
 916	nd->sensor_logical_height = 1;
 917	nd->sensor_physical_width = 1;
 918	nd->sensor_physical_height = 1;
 919
 920	hid_set_drvdata(hdev, nd);
 921
 922	ret = hid_parse(hdev);
 923	if (ret) {
 924		hid_err(hdev, "parse failed\n");
 925		goto err_free;
 926	}
 927
 928	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
 929	if (ret) {
 930		hid_err(hdev, "hw start failed\n");
 931		goto err_free;
 932	}
 933
 934	/* This is needed for devices with more recent firmware versions */
 935	report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];
 936	if (report) {
 937		/* Let the device settle to ensure the wakeup message gets
 938		 * through */
 939		hid_hw_wait(hdev);
 940		hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
 941
 942		/*
 943		 * Sanity check: if the current mode is invalid reset it to
 944		 * something reasonable.
 945		 */
 946		if (ntrig_get_mode(hdev) >= 4)
 947			ntrig_set_mode(hdev, 3);
 948	}
 949
 950	ntrig_report_version(hdev);
 951
 952	ret = sysfs_create_group(&hdev->dev.kobj,
 953			&ntrig_attribute_group);
 954	if (ret)
 955		hid_err(hdev, "cannot create sysfs group\n");
 956
 957	return 0;
 958err_free:
 959	kfree(nd);
 960	return ret;
 961}
 962
 963static void ntrig_remove(struct hid_device *hdev)
 964{
 965	sysfs_remove_group(&hdev->dev.kobj,
 966			   &ntrig_attribute_group);
 967	hid_hw_stop(hdev);
 968	kfree(hid_get_drvdata(hdev));
 969}
 970
 971static const struct hid_device_id ntrig_devices[] = {
 972	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),
 973		.driver_data = NTRIG_DUPLICATE_USAGES },
 974	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1),
 975		.driver_data = NTRIG_DUPLICATE_USAGES },
 976	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2),
 977		.driver_data = NTRIG_DUPLICATE_USAGES },
 978	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3),
 979		.driver_data = NTRIG_DUPLICATE_USAGES },
 980	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4),
 981		.driver_data = NTRIG_DUPLICATE_USAGES },
 982	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5),
 983		.driver_data = NTRIG_DUPLICATE_USAGES },
 984	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6),
 985		.driver_data = NTRIG_DUPLICATE_USAGES },
 986	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7),
 987		.driver_data = NTRIG_DUPLICATE_USAGES },
 988	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8),
 989		.driver_data = NTRIG_DUPLICATE_USAGES },
 990	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9),
 991		.driver_data = NTRIG_DUPLICATE_USAGES },
 992	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10),
 993		.driver_data = NTRIG_DUPLICATE_USAGES },
 994	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11),
 995		.driver_data = NTRIG_DUPLICATE_USAGES },
 996	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12),
 997		.driver_data = NTRIG_DUPLICATE_USAGES },
 998	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13),
 999		.driver_data = NTRIG_DUPLICATE_USAGES },
1000	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14),
1001		.driver_data = NTRIG_DUPLICATE_USAGES },
1002	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15),
1003		.driver_data = NTRIG_DUPLICATE_USAGES },
1004	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16),
1005		.driver_data = NTRIG_DUPLICATE_USAGES },
1006	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17),
1007		.driver_data = NTRIG_DUPLICATE_USAGES },
1008	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18),
1009		.driver_data = NTRIG_DUPLICATE_USAGES },
1010	{ }
1011};
1012MODULE_DEVICE_TABLE(hid, ntrig_devices);
1013
1014static const struct hid_usage_id ntrig_grabbed_usages[] = {
1015	{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
1016	{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }
1017};
1018
1019static struct hid_driver ntrig_driver = {
1020	.name = "ntrig",
1021	.id_table = ntrig_devices,
1022	.probe = ntrig_probe,
1023	.remove = ntrig_remove,
1024	.input_mapping = ntrig_input_mapping,
1025	.input_mapped = ntrig_input_mapped,
1026	.input_configured = ntrig_input_configured,
1027	.usage_table = ntrig_grabbed_usages,
1028	.event = ntrig_event,
1029};
1030module_hid_driver(ntrig_driver);
1031
1032MODULE_LICENSE("GPL");