drivers/hid/hid-ntrig.c

   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
  23 static unsigned int min_width;
  24 module_param(min_width, uint, 0644);
  25 MODULE_PARM_DESC(min_width, "Minimum touch contact width to accept.");
  26
  27 static unsigned int min_height;
  28 module_param(min_height, uint, 0644);
  29 MODULE_PARM_DESC(min_height, "Minimum touch contact height to accept.");
  30
  31 static unsigned int activate_slack = 1;
  32 module_param(activate_slack, uint, 0644);
  33 MODULE_PARM_DESC(activate_slack, "Number of touch frames to ignore at "
  34                  "the start of touch input.");
  35
  36 static unsigned int deactivate_slack = 4;
  37 module_param(deactivate_slack, uint, 0644);
  38 MODULE_PARM_DESC(deactivate_slack, "Number of empty frames to ignore before "
  39                  "deactivating touch.");
  40
  41 static unsigned int activation_width = 64;
  42 module_param(activation_width, uint, 0644);
  43 MODULE_PARM_DESC(activation_width, "Width threshold to immediately start "
  44                  "processing touch events.");
  45
  46 static unsigned int activation_height = 32;
  47 module_param(activation_height, uint, 0644);
  48 MODULE_PARM_DESC(activation_height, "Height threshold to immediately start "
  49                  "processing touch events.");
  50
  51 struct 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  */
  93 static 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
 109 static 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
 123 static 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
 140 static 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
 164 err_free:
 165         kfree(data);
 166 }
 167
 168 static 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
 178 static DEVICE_ATTR(sensor_physical_width, S_IRUGO, show_phys_width, NULL);
 179
 180 static 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
 190 static DEVICE_ATTR(sensor_physical_height, S_IRUGO, show_phys_height, NULL);
 191
 192 static 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
 202 static DEVICE_ATTR(sensor_logical_width, S_IRUGO, show_log_width, NULL);
 203
 204 static 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
 214 static DEVICE_ATTR(sensor_logical_height, S_IRUGO, show_log_height, NULL);
 215
 216 static 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
 228 static 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
 249 static DEVICE_ATTR(min_width, S_IWUSR | S_IRUGO, show_min_width, set_min_width);
 250
 251 static 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
 263 static 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
 284 static DEVICE_ATTR(min_height, S_IWUSR | S_IRUGO, show_min_height,
 285                    set_min_height);
 286
 287 static 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
 297 static 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
 317 static DEVICE_ATTR(activate_slack, S_IWUSR | S_IRUGO, show_activate_slack,
 318                    set_activate_slack);
 319
 320 static 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
 332 static 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
 353 static DEVICE_ATTR(activation_width, S_IWUSR | S_IRUGO, show_activation_width,
 354                    set_activation_width);
 355
 356 static 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
 368 static 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
 389 static DEVICE_ATTR(activation_height, S_IWUSR | S_IRUGO,
 390                    show_activation_height, set_activation_height);
 391
 392 static 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
 402 static 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
 427 static DEVICE_ATTR(deactivate_slack, S_IWUSR | S_IRUGO, show_deactivate_slack,
 428                    set_deactivate_slack);
 429
 430 static 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
 444 static 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
 454 static 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
 545 static 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  */
 566 static 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
 849 not_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
 858 static 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
 893 static 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;
 958 err_free:
 959         kfree(nd);
 960         return ret;
 961 }
 962
 963 static 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
 971 static 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 };
1012 MODULE_DEVICE_TABLE(hid, ntrig_devices);
1013
1014 static 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
1019 static 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 };
1030 module_hid_driver(ntrig_driver);
1031
1032 MODULE_LICENSE("GPL");