drivers/hid/hid-multitouch.c

   1 /*
   2  *  HID driver for multitouch panels
   3  *
   4  *  Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
   5  *  Copyright (c) 2010-2013 Benjamin Tissoires <benjamin.tissoires@gmail.com>
   6  *  Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
   7  *  Copyright (c) 2012-2013 Red Hat, Inc
   8  *
   9  *  This code is partly based on hid-egalax.c:
  10  *
  11  *  Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
  12  *  Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
  13  *  Copyright (c) 2010 Canonical, Ltd.
  14  *
  15  *  This code is partly based on hid-3m-pct.c:
  16  *
  17  *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
  18  *  Copyright (c) 2010      Henrik Rydberg <rydberg@euromail.se>
  19  *  Copyright (c) 2010      Canonical, Ltd.
  20  *
  21  */
  22
  23 /*
  24  * This program is free software; you can redistribute it and/or modify it
  25  * under the terms of the GNU General Public License as published by the Free
  26  * Software Foundation; either version 2 of the License, or (at your option)
  27  * any later version.
  28  */
  29
  30 /*
  31  * This driver is regularly tested thanks to the tool hid-test[1].
  32  * This tool relies on hid-replay[2] and a database of hid devices[3].
  33  * Please run these regression tests before patching this module so that
  34  * your patch won't break existing known devices.
  35  *
  36  * [1] https://github.com/bentiss/hid-test
  37  * [2] https://github.com/bentiss/hid-replay
  38  * [3] https://github.com/bentiss/hid-devices
  39  */
  40
  41 #include <linux/device.h>
  42 #include <linux/hid.h>
  43 #include <linux/module.h>
  44 #include <linux/slab.h>
  45 #include <linux/input/mt.h>
  46 #include <linux/string.h>
  47 #include <linux/timer.h>
  48
  49
  50 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
  51 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
  52 MODULE_DESCRIPTION("HID multitouch panels");
  53 MODULE_LICENSE("GPL");
  54
  55 #include "hid-ids.h"
  56
  57 /* quirks to control the device */
  58 #define MT_QUIRK_NOT_SEEN_MEANS_UP      BIT(0)
  59 #define MT_QUIRK_SLOT_IS_CONTACTID      BIT(1)
  60 #define MT_QUIRK_CYPRESS                BIT(2)
  61 #define MT_QUIRK_SLOT_IS_CONTACTNUMBER  BIT(3)
  62 #define MT_QUIRK_ALWAYS_VALID           BIT(4)
  63 #define MT_QUIRK_VALID_IS_INRANGE       BIT(5)
  64 #define MT_QUIRK_VALID_IS_CONFIDENCE    BIT(6)
  65 #define MT_QUIRK_CONFIDENCE             BIT(7)
  66 #define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE    BIT(8)
  67 #define MT_QUIRK_NO_AREA                BIT(9)
  68 #define MT_QUIRK_IGNORE_DUPLICATES      BIT(10)
  69 #define MT_QUIRK_HOVERING               BIT(11)
  70 #define MT_QUIRK_CONTACT_CNT_ACCURATE   BIT(12)
  71 #define MT_QUIRK_FORCE_GET_FEATURE      BIT(13)
  72 #define MT_QUIRK_FIX_CONST_CONTACT_ID   BIT(14)
  73 #define MT_QUIRK_TOUCH_SIZE_SCALING     BIT(15)
  74 #define MT_QUIRK_STICKY_FINGERS         BIT(16)
  75
  76 #define MT_INPUTMODE_TOUCHSCREEN        0x02
  77 #define MT_INPUTMODE_TOUCHPAD           0x03
  78
  79 #define MT_BUTTONTYPE_CLICKPAD          0
  80
  81 #define MT_IO_FLAGS_RUNNING             0
  82 #define MT_IO_FLAGS_ACTIVE_SLOTS        1
  83 #define MT_IO_FLAGS_PENDING_SLOTS       2
  84
  85 struct mt_slot {
  86         __s32 x, y, cx, cy, p, w, h;
  87         __s32 contactid;        /* the device ContactID assigned to this slot */
  88         bool touch_state;       /* is the touch valid? */
  89         bool inrange_state;     /* is the finger in proximity of the sensor? */
  90         bool confidence_state;  /* is the touch made by a finger? */
  91 };
  92
  93 struct mt_class {
  94         __s32 name;     /* MT_CLS */
  95         __s32 quirks;
  96         __s32 sn_move;  /* Signal/noise ratio for move events */
  97         __s32 sn_width; /* Signal/noise ratio for width events */
  98         __s32 sn_height;        /* Signal/noise ratio for height events */
  99         __s32 sn_pressure;      /* Signal/noise ratio for pressure events */
 100         __u8 maxcontacts;
 101         bool is_indirect;       /* true for touchpads */
 102         bool export_all_inputs; /* do not ignore mouse, keyboards, etc... */
 103 };
 104
 105 struct mt_fields {
 106         unsigned usages[HID_MAX_FIELDS];
 107         unsigned int length;
 108 };
 109
 110 struct mt_device {
 111         struct mt_slot curdata; /* placeholder of incoming data */
 112         struct mt_class mtclass;        /* our mt device class */
 113         struct timer_list release_timer;        /* to release sticky fingers */
 114         struct mt_fields *fields;       /* temporary placeholder for storing the
 115                                            multitouch fields */
 116         unsigned long mt_io_flags;      /* mt flags (MT_IO_FLAGS_*) */
 117         int cc_index;   /* contact count field index in the report */
 118         int cc_value_index;     /* contact count value index in the field */
 119         unsigned last_slot_field;       /* the last field of a slot */
 120         unsigned mt_report_id;  /* the report ID of the multitouch device */
 121         unsigned long initial_quirks;   /* initial quirks state */
 122         __s16 inputmode;        /* InputMode HID feature, -1 if non-existent */
 123         __s16 inputmode_index;  /* InputMode HID feature index in the report */
 124         __s16 maxcontact_report_id;     /* Maximum Contact Number HID feature,
 125                                    -1 if non-existent */
 126         __u8 inputmode_value;  /* InputMode HID feature value */
 127         __u8 num_received;      /* how many contacts we received */
 128         __u8 num_expected;      /* expected last contact index */
 129         __u8 maxcontacts;
 130         __u8 touches_by_report; /* how many touches are present in one report:
 131                                 * 1 means we should use a serial protocol
 132                                 * > 1 means hybrid (multitouch) protocol */
 133         __u8 buttons_count;     /* number of physical buttons per touchpad */
 134         bool is_buttonpad;      /* is this device a button pad? */
 135         bool serial_maybe;      /* need to check for serial protocol */
 136         bool curvalid;          /* is the current contact valid? */
 137         unsigned mt_flags;      /* flags to pass to input-mt */
 138 };
 139
 140 static void mt_post_parse_default_settings(struct mt_device *td);
 141 static void mt_post_parse(struct mt_device *td);
 142
 143 /* classes of device behavior */
 144 #define MT_CLS_DEFAULT                          0x0001
 145
 146 #define MT_CLS_SERIAL                           0x0002
 147 #define MT_CLS_CONFIDENCE                       0x0003
 148 #define MT_CLS_CONFIDENCE_CONTACT_ID            0x0004
 149 #define MT_CLS_CONFIDENCE_MINUS_ONE             0x0005
 150 #define MT_CLS_DUAL_INRANGE_CONTACTID           0x0006
 151 #define MT_CLS_DUAL_INRANGE_CONTACTNUMBER       0x0007
 152 /* reserved                                     0x0008 */
 153 #define MT_CLS_INRANGE_CONTACTNUMBER            0x0009
 154 #define MT_CLS_NSMU                             0x000a
 155 /* reserved                                     0x0010 */
 156 /* reserved                                     0x0011 */
 157 #define MT_CLS_WIN_8                            0x0012
 158 #define MT_CLS_EXPORT_ALL_INPUTS                0x0013
 159 #define MT_CLS_WIN_8_DUAL                       0x0014
 160
 161 /* vendor specific classes */
 162 #define MT_CLS_3M                               0x0101
 163 /* reserved                                     0x0102 */
 164 #define MT_CLS_EGALAX                           0x0103
 165 #define MT_CLS_EGALAX_SERIAL                    0x0104
 166 #define MT_CLS_TOPSEED                          0x0105
 167 #define MT_CLS_PANASONIC                        0x0106
 168 #define MT_CLS_FLATFROG                         0x0107
 169 #define MT_CLS_GENERALTOUCH_TWOFINGERS          0x0108
 170 #define MT_CLS_GENERALTOUCH_PWT_TENFINGERS      0x0109
 171 #define MT_CLS_LG                               0x010a
 172 #define MT_CLS_VTL                              0x0110
 173 #define MT_CLS_GOOGLE                           0x0111
 174
 175 #define MT_DEFAULT_MAXCONTACT   10
 176 #define MT_MAX_MAXCONTACT       250
 177
 178 #define MT_USB_DEVICE(v, p)     HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p)
 179 #define MT_BT_DEVICE(v, p)      HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p)
 180
 181 /*
 182  * these device-dependent functions determine what slot corresponds
 183  * to a valid contact that was just read.
 184  */
 185
 186 static int cypress_compute_slot(struct mt_device *td)
 187 {
 188         if (td->curdata.contactid != 0 || td->num_received == 0)
 189                 return td->curdata.contactid;
 190         else
 191                 return -1;
 192 }
 193
 194 static struct mt_class mt_classes[] = {
 195         { .name = MT_CLS_DEFAULT,
 196                 .quirks = MT_QUIRK_ALWAYS_VALID |
 197                         MT_QUIRK_CONTACT_CNT_ACCURATE },
 198         { .name = MT_CLS_NSMU,
 199                 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
 200         { .name = MT_CLS_SERIAL,
 201                 .quirks = MT_QUIRK_ALWAYS_VALID},
 202         { .name = MT_CLS_CONFIDENCE,
 203                 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
 204         { .name = MT_CLS_CONFIDENCE_CONTACT_ID,
 205                 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 206                         MT_QUIRK_SLOT_IS_CONTACTID },
 207         { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
 208                 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 209                         MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
 210         { .name = MT_CLS_DUAL_INRANGE_CONTACTID,
 211                 .quirks = MT_QUIRK_VALID_IS_INRANGE |
 212                         MT_QUIRK_SLOT_IS_CONTACTID,
 213                 .maxcontacts = 2 },
 214         { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 215                 .quirks = MT_QUIRK_VALID_IS_INRANGE |
 216                         MT_QUIRK_SLOT_IS_CONTACTNUMBER,
 217                 .maxcontacts = 2 },
 218         { .name = MT_CLS_INRANGE_CONTACTNUMBER,
 219                 .quirks = MT_QUIRK_VALID_IS_INRANGE |
 220                         MT_QUIRK_SLOT_IS_CONTACTNUMBER },
 221         { .name = MT_CLS_WIN_8,
 222                 .quirks = MT_QUIRK_ALWAYS_VALID |
 223                         MT_QUIRK_IGNORE_DUPLICATES |
 224                         MT_QUIRK_HOVERING |
 225                         MT_QUIRK_CONTACT_CNT_ACCURATE |
 226                         MT_QUIRK_STICKY_FINGERS },
 227         { .name = MT_CLS_EXPORT_ALL_INPUTS,
 228                 .quirks = MT_QUIRK_ALWAYS_VALID |
 229                         MT_QUIRK_CONTACT_CNT_ACCURATE,
 230                 .export_all_inputs = true },
 231         { .name = MT_CLS_WIN_8_DUAL,
 232                 .quirks = MT_QUIRK_ALWAYS_VALID |
 233                         MT_QUIRK_IGNORE_DUPLICATES |
 234                         MT_QUIRK_HOVERING |
 235                         MT_QUIRK_CONTACT_CNT_ACCURATE,
 236                 .export_all_inputs = true },
 237
 238         /*
 239          * vendor specific classes
 240          */
 241         { .name = MT_CLS_3M,
 242                 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 243                         MT_QUIRK_SLOT_IS_CONTACTID |
 244                         MT_QUIRK_TOUCH_SIZE_SCALING,
 245                 .sn_move = 2048,
 246                 .sn_width = 128,
 247                 .sn_height = 128,
 248                 .maxcontacts = 60,
 249         },
 250         { .name = MT_CLS_EGALAX,
 251                 .quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
 252                         MT_QUIRK_VALID_IS_INRANGE,
 253                 .sn_move = 4096,
 254                 .sn_pressure = 32,
 255         },
 256         { .name = MT_CLS_EGALAX_SERIAL,
 257                 .quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
 258                         MT_QUIRK_ALWAYS_VALID,
 259                 .sn_move = 4096,
 260                 .sn_pressure = 32,
 261         },
 262         { .name = MT_CLS_TOPSEED,
 263                 .quirks = MT_QUIRK_ALWAYS_VALID,
 264                 .is_indirect = true,
 265                 .maxcontacts = 2,
 266         },
 267         { .name = MT_CLS_PANASONIC,
 268                 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
 269                 .maxcontacts = 4 },
 270         { .name = MT_CLS_GENERALTOUCH_TWOFINGERS,
 271                 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 272                         MT_QUIRK_VALID_IS_INRANGE |
 273                         MT_QUIRK_SLOT_IS_CONTACTID,
 274                 .maxcontacts = 2
 275         },
 276         { .name = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
 277                 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 278                         MT_QUIRK_SLOT_IS_CONTACTID
 279         },
 280
 281         { .name = MT_CLS_FLATFROG,
 282                 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 283                         MT_QUIRK_NO_AREA,
 284                 .sn_move = 2048,
 285                 .maxcontacts = 40,
 286         },
 287         { .name = MT_CLS_LG,
 288                 .quirks = MT_QUIRK_ALWAYS_VALID |
 289                         MT_QUIRK_FIX_CONST_CONTACT_ID |
 290                         MT_QUIRK_IGNORE_DUPLICATES |
 291                         MT_QUIRK_HOVERING |
 292                         MT_QUIRK_CONTACT_CNT_ACCURATE },
 293         { .name = MT_CLS_VTL,
 294                 .quirks = MT_QUIRK_ALWAYS_VALID |
 295                         MT_QUIRK_CONTACT_CNT_ACCURATE |
 296                         MT_QUIRK_FORCE_GET_FEATURE,
 297         },
 298         { .name = MT_CLS_GOOGLE,
 299                 .quirks = MT_QUIRK_ALWAYS_VALID |
 300                         MT_QUIRK_CONTACT_CNT_ACCURATE |
 301                         MT_QUIRK_SLOT_IS_CONTACTID |
 302                         MT_QUIRK_HOVERING
 303         },
 304         { }
 305 };
 306
 307 static ssize_t mt_show_quirks(struct device *dev,
 308                            struct device_attribute *attr,
 309                            char *buf)
 310 {
 311         struct hid_device *hdev = to_hid_device(dev);
 312         struct mt_device *td = hid_get_drvdata(hdev);
 313
 314         return sprintf(buf, "%u\n", td->mtclass.quirks);
 315 }
 316
 317 static ssize_t mt_set_quirks(struct device *dev,
 318                           struct device_attribute *attr,
 319                           const char *buf, size_t count)
 320 {
 321         struct hid_device *hdev = to_hid_device(dev);
 322         struct mt_device *td = hid_get_drvdata(hdev);
 323
 324         unsigned long val;
 325
 326         if (kstrtoul(buf, 0, &val))
 327                 return -EINVAL;
 328
 329         td->mtclass.quirks = val;
 330
 331         if (td->cc_index < 0)
 332                 td->mtclass.quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
 333
 334         return count;
 335 }
 336
 337 static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
 338
 339 static struct attribute *sysfs_attrs[] = {
 340         &dev_attr_quirks.attr,
 341         NULL
 342 };
 343
 344 static struct attribute_group mt_attribute_group = {
 345         .attrs = sysfs_attrs
 346 };
 347
 348 static void mt_get_feature(struct hid_device *hdev, struct hid_report *report)
 349 {
 350         struct mt_device *td = hid_get_drvdata(hdev);
 351         int ret, size = hid_report_len(report);
 352         u8 *buf;
 353
 354         /*
 355          * Do not fetch the feature report if the device has been explicitly
 356          * marked as non-capable.
 357          */
 358         if (td->initial_quirks & HID_QUIRK_NO_INIT_REPORTS)
 359                 return;
 360
 361         buf = hid_alloc_report_buf(report, GFP_KERNEL);
 362         if (!buf)
 363                 return;
 364
 365         ret = hid_hw_raw_request(hdev, report->id, buf, size,
 366                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
 367         if (ret < 0) {
 368                 dev_warn(&hdev->dev, "failed to fetch feature %d\n",
 369                          report->id);
 370         } else {
 371                 ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf,
 372                                            size, 0);
 373                 if (ret)
 374                         dev_warn(&hdev->dev, "failed to report feature\n");
 375         }
 376
 377         kfree(buf);
 378 }
 379
 380 static void mt_feature_mapping(struct hid_device *hdev,
 381                 struct hid_field *field, struct hid_usage *usage)
 382 {
 383         struct mt_device *td = hid_get_drvdata(hdev);
 384
 385         switch (usage->hid) {
 386         case HID_DG_INPUTMODE:
 387                 /* Ignore if value index is out of bounds. */
 388                 if (usage->usage_index >= field->report_count) {
 389                         dev_err(&hdev->dev, "HID_DG_INPUTMODE out of range\n");
 390                         break;
 391                 }
 392
 393                 if (td->inputmode < 0) {
 394                         td->inputmode = field->report->id;
 395                         td->inputmode_index = usage->usage_index;
 396                 } else {
 397                         /*
 398                          * Some elan panels wrongly declare 2 input mode
 399                          * features, and silently ignore when we set the
 400                          * value in the second field. Skip the second feature
 401                          * and hope for the best.
 402                          */
 403                         dev_info(&hdev->dev,
 404                                  "Ignoring the extra HID_DG_INPUTMODE\n");
 405                 }
 406
 407                 break;
 408         case HID_DG_CONTACTMAX:
 409                 mt_get_feature(hdev, field->report);
 410
 411                 td->maxcontact_report_id = field->report->id;
 412                 td->maxcontacts = field->value[0];
 413                 if (!td->maxcontacts &&
 414                     field->logical_maximum <= MT_MAX_MAXCONTACT)
 415                         td->maxcontacts = field->logical_maximum;
 416                 if (td->mtclass.maxcontacts)
 417                         /* check if the maxcontacts is given by the class */
 418                         td->maxcontacts = td->mtclass.maxcontacts;
 419
 420                 break;
 421         case HID_DG_BUTTONTYPE:
 422                 if (usage->usage_index >= field->report_count) {
 423                         dev_err(&hdev->dev, "HID_DG_BUTTONTYPE out of range\n");
 424                         break;
 425                 }
 426
 427                 mt_get_feature(hdev, field->report);
 428                 if (field->value[usage->usage_index] == MT_BUTTONTYPE_CLICKPAD)
 429                         td->is_buttonpad = true;
 430
 431                 break;
 432         case 0xff0000c5:
 433                 /* Retrieve the Win8 blob once to enable some devices */
 434                 if (usage->usage_index == 0)
 435                         mt_get_feature(hdev, field->report);
 436                 break;
 437         }
 438 }
 439
 440 static void set_abs(struct input_dev *input, unsigned int code,
 441                 struct hid_field *field, int snratio)
 442 {
 443         int fmin = field->logical_minimum;
 444         int fmax = field->logical_maximum;
 445         int fuzz = snratio ? (fmax - fmin) / snratio : 0;
 446         input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
 447         input_abs_set_res(input, code, hidinput_calc_abs_res(field, code));
 448 }
 449
 450 static void mt_store_field(struct hid_usage *usage, struct mt_device *td,
 451                 struct hid_input *hi)
 452 {
 453         struct mt_fields *f = td->fields;
 454
 455         if (f->length >= HID_MAX_FIELDS)
 456                 return;
 457
 458         f->usages[f->length++] = usage->hid;
 459 }
 460
 461 static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 462                 struct hid_field *field, struct hid_usage *usage,
 463                 unsigned long **bit, int *max)
 464 {
 465         struct mt_device *td = hid_get_drvdata(hdev);
 466         struct mt_class *cls = &td->mtclass;
 467         int code;
 468         struct hid_usage *prev_usage = NULL;
 469
 470         if (field->application == HID_DG_TOUCHSCREEN)
 471                 td->mt_flags |= INPUT_MT_DIRECT;
 472
 473         /*
 474          * Model touchscreens providing buttons as touchpads.
 475          */
 476         if (field->application == HID_DG_TOUCHPAD ||
 477             (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
 478                 td->mt_flags |= INPUT_MT_POINTER;
 479                 td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
 480         }
 481
 482         /* count the buttons on touchpads */
 483         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
 484                 td->buttons_count++;
 485
 486         if (usage->usage_index)
 487                 prev_usage = &field->usage[usage->usage_index - 1];
 488
 489         switch (usage->hid & HID_USAGE_PAGE) {
 490
 491         case HID_UP_GENDESK:
 492                 switch (usage->hid) {
 493                 case HID_GD_X:
 494                         if (prev_usage && (prev_usage->hid == usage->hid)) {
 495                                 hid_map_usage(hi, usage, bit, max,
 496                                         EV_ABS, ABS_MT_TOOL_X);
 497                                 set_abs(hi->input, ABS_MT_TOOL_X, field,
 498                                         cls->sn_move);
 499                         } else {
 500                                 hid_map_usage(hi, usage, bit, max,
 501                                         EV_ABS, ABS_MT_POSITION_X);
 502                                 set_abs(hi->input, ABS_MT_POSITION_X, field,
 503                                         cls->sn_move);
 504                         }
 505
 506                         mt_store_field(usage, td, hi);
 507                         return 1;
 508                 case HID_GD_Y:
 509                         if (prev_usage && (prev_usage->hid == usage->hid)) {
 510                                 hid_map_usage(hi, usage, bit, max,
 511                                         EV_ABS, ABS_MT_TOOL_Y);
 512                                 set_abs(hi->input, ABS_MT_TOOL_Y, field,
 513                                         cls->sn_move);
 514                         } else {
 515                                 hid_map_usage(hi, usage, bit, max,
 516                                         EV_ABS, ABS_MT_POSITION_Y);
 517                                 set_abs(hi->input, ABS_MT_POSITION_Y, field,
 518                                         cls->sn_move);
 519                         }
 520
 521                         mt_store_field(usage, td, hi);
 522                         return 1;
 523                 }
 524                 return 0;
 525
 526         case HID_UP_DIGITIZER:
 527                 switch (usage->hid) {
 528                 case HID_DG_INRANGE:
 529                         if (cls->quirks & MT_QUIRK_HOVERING) {
 530                                 hid_map_usage(hi, usage, bit, max,
 531                                         EV_ABS, ABS_MT_DISTANCE);
 532                                 input_set_abs_params(hi->input,
 533                                         ABS_MT_DISTANCE, 0, 1, 0, 0);
 534                         }
 535                         mt_store_field(usage, td, hi);
 536                         return 1;
 537                 case HID_DG_CONFIDENCE:
 538                         if ((cls->name == MT_CLS_WIN_8 ||
 539                                 cls->name == MT_CLS_WIN_8_DUAL) &&
 540                                 field->application == HID_DG_TOUCHPAD)
 541                                 cls->quirks |= MT_QUIRK_CONFIDENCE;
 542                         mt_store_field(usage, td, hi);
 543                         return 1;
 544                 case HID_DG_TIPSWITCH:
 545                         hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
 546                         input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
 547                         mt_store_field(usage, td, hi);
 548                         return 1;
 549                 case HID_DG_CONTACTID:
 550                         mt_store_field(usage, td, hi);
 551                         td->touches_by_report++;
 552                         td->mt_report_id = field->report->id;
 553                         return 1;
 554                 case HID_DG_WIDTH:
 555                         hid_map_usage(hi, usage, bit, max,
 556                                         EV_ABS, ABS_MT_TOUCH_MAJOR);
 557                         if (!(cls->quirks & MT_QUIRK_NO_AREA))
 558                                 set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
 559                                         cls->sn_width);
 560                         mt_store_field(usage, td, hi);
 561                         return 1;
 562                 case HID_DG_HEIGHT:
 563                         hid_map_usage(hi, usage, bit, max,
 564                                         EV_ABS, ABS_MT_TOUCH_MINOR);
 565                         if (!(cls->quirks & MT_QUIRK_NO_AREA)) {
 566                                 set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
 567                                         cls->sn_height);
 568                                 input_set_abs_params(hi->input,
 569                                         ABS_MT_ORIENTATION, 0, 1, 0, 0);
 570                         }
 571                         mt_store_field(usage, td, hi);
 572                         return 1;
 573                 case HID_DG_TIPPRESSURE:
 574                         hid_map_usage(hi, usage, bit, max,
 575                                         EV_ABS, ABS_MT_PRESSURE);
 576                         set_abs(hi->input, ABS_MT_PRESSURE, field,
 577                                 cls->sn_pressure);
 578                         mt_store_field(usage, td, hi);
 579                         return 1;
 580                 case HID_DG_CONTACTCOUNT:
 581                         /* Ignore if indexes are out of bounds. */
 582                         if (field->index >= field->report->maxfield ||
 583                             usage->usage_index >= field->report_count)
 584                                 return 1;
 585                         td->cc_index = field->index;
 586                         td->cc_value_index = usage->usage_index;
 587                         return 1;
 588                 case HID_DG_CONTACTMAX:
 589                         /* we don't set td->last_slot_field as contactcount and
 590                          * contact max are global to the report */
 591                         return -1;
 592                 case HID_DG_TOUCH:
 593                         /* Legacy devices use TIPSWITCH and not TOUCH.
 594                          * Let's just ignore this field. */
 595                         return -1;
 596                 }
 597                 /* let hid-input decide for the others */
 598                 return 0;
 599
 600         case HID_UP_BUTTON:
 601                 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
 602                 /*
 603                  * MS PTP spec says that external buttons left and right have
 604                  * usages 2 and 3.
 605                  */
 606                 if ((cls->name == MT_CLS_WIN_8 ||
 607                         cls->name == MT_CLS_WIN_8_DUAL) &&
 608                     field->application == HID_DG_TOUCHPAD &&
 609                     (usage->hid & HID_USAGE) > 1)
 610                         code--;
 611                 hid_map_usage(hi, usage, bit, max, EV_KEY, code);
 612                 input_set_capability(hi->input, EV_KEY, code);
 613                 return 1;
 614
 615         case 0xff000000:
 616                 /* we do not want to map these: no input-oriented meaning */
 617                 return -1;
 618         }
 619
 620         return 0;
 621 }
 622
 623 static int mt_touch_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 624                 struct hid_field *field, struct hid_usage *usage,
 625                 unsigned long **bit, int *max)
 626 {
 627         if (usage->type == EV_KEY || usage->type == EV_ABS)
 628                 set_bit(usage->type, hi->input->evbit);
 629
 630         return -1;
 631 }
 632
 633 static int mt_compute_slot(struct mt_device *td, struct input_dev *input)
 634 {
 635         __s32 quirks = td->mtclass.quirks;
 636
 637         if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
 638                 return td->curdata.contactid;
 639
 640         if (quirks & MT_QUIRK_CYPRESS)
 641                 return cypress_compute_slot(td);
 642
 643         if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
 644                 return td->num_received;
 645
 646         if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
 647                 return td->curdata.contactid - 1;
 648
 649         return input_mt_get_slot_by_key(input, td->curdata.contactid);
 650 }
 651
 652 /*
 653  * this function is called when a whole contact has been processed,
 654  * so that it can assign it to a slot and store the data there
 655  */
 656 static void mt_complete_slot(struct mt_device *td, struct input_dev *input)
 657 {
 658         if ((td->mtclass.quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) &&
 659             td->num_received >= td->num_expected)
 660                 return;
 661
 662         if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) {
 663                 int active;
 664                 int slotnum = mt_compute_slot(td, input);
 665                 struct mt_slot *s = &td->curdata;
 666                 struct input_mt *mt = input->mt;
 667
 668                 if (slotnum < 0 || slotnum >= td->maxcontacts)
 669                         return;
 670
 671                 if ((td->mtclass.quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) {
 672                         struct input_mt_slot *slot = &mt->slots[slotnum];
 673                         if (input_mt_is_active(slot) &&
 674                             input_mt_is_used(mt, slot))
 675                                 return;
 676                 }
 677
 678                 if (!(td->mtclass.quirks & MT_QUIRK_CONFIDENCE))
 679                         s->confidence_state = 1;
 680                 active = (s->touch_state || s->inrange_state) &&
 681                                                         s->confidence_state;
 682
 683                 input_mt_slot(input, slotnum);
 684                 input_mt_report_slot_state(input, MT_TOOL_FINGER, active);
 685                 if (active) {
 686                         /* this finger is in proximity of the sensor */
 687                         int wide = (s->w > s->h);
 688                         int major = max(s->w, s->h);
 689                         int minor = min(s->w, s->h);
 690
 691                         /*
 692                          * divided by two to match visual scale of touch
 693                          * for devices with this quirk
 694                          */
 695                         if (td->mtclass.quirks & MT_QUIRK_TOUCH_SIZE_SCALING) {
 696                                 major = major >> 1;
 697                                 minor = minor >> 1;
 698                         }
 699
 700                         input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
 701                         input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
 702                         input_event(input, EV_ABS, ABS_MT_TOOL_X, s->cx);
 703                         input_event(input, EV_ABS, ABS_MT_TOOL_Y, s->cy);
 704                         input_event(input, EV_ABS, ABS_MT_DISTANCE,
 705                                 !s->touch_state);
 706                         input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
 707                         input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
 708                         input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
 709                         input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
 710
 711                         set_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
 712                 }
 713         }
 714
 715         td->num_received++;
 716 }
 717
 718 /*
 719  * this function is called when a whole packet has been received and processed,
 720  * so that it can decide what to send to the input layer.
 721  */
 722 static void mt_sync_frame(struct mt_device *td, struct input_dev *input)
 723 {
 724         input_mt_sync_frame(input);
 725         input_sync(input);
 726         td->num_received = 0;
 727         if (test_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags))
 728                 set_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
 729         else
 730                 clear_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags);
 731         clear_bit(MT_IO_FLAGS_ACTIVE_SLOTS, &td->mt_io_flags);
 732 }
 733
 734 static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
 735                                 struct hid_usage *usage, __s32 value)
 736 {
 737         /* we will handle the hidinput part later, now remains hiddev */
 738         if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
 739                 hid->hiddev_hid_event(hid, field, usage, value);
 740
 741         return 1;
 742 }
 743
 744 static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
 745                                 struct hid_usage *usage, __s32 value)
 746 {
 747         struct mt_device *td = hid_get_drvdata(hid);
 748         __s32 quirks = td->mtclass.quirks;
 749         struct input_dev *input = field->hidinput->input;
 750
 751         if (hid->claimed & HID_CLAIMED_INPUT) {
 752                 switch (usage->hid) {
 753                 case HID_DG_INRANGE:
 754                         if (quirks & MT_QUIRK_VALID_IS_INRANGE)
 755                                 td->curvalid = value;
 756                         if (quirks & MT_QUIRK_HOVERING)
 757                                 td->curdata.inrange_state = value;
 758                         break;
 759                 case HID_DG_TIPSWITCH:
 760                         if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
 761                                 td->curvalid = value;
 762                         td->curdata.touch_state = value;
 763                         break;
 764                 case HID_DG_CONFIDENCE:
 765                         if (quirks & MT_QUIRK_CONFIDENCE)
 766                                 td->curdata.confidence_state = value;
 767                         if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
 768                                 td->curvalid = value;
 769                         break;
 770                 case HID_DG_CONTACTID:
 771                         td->curdata.contactid = value;
 772                         break;
 773                 case HID_DG_TIPPRESSURE:
 774                         td->curdata.p = value;
 775                         break;
 776                 case HID_GD_X:
 777                         if (usage->code == ABS_MT_TOOL_X)
 778                                 td->curdata.cx = value;
 779                         else
 780                                 td->curdata.x = value;
 781                         break;
 782                 case HID_GD_Y:
 783                         if (usage->code == ABS_MT_TOOL_Y)
 784                                 td->curdata.cy = value;
 785                         else
 786                                 td->curdata.y = value;
 787                         break;
 788                 case HID_DG_WIDTH:
 789                         td->curdata.w = value;
 790                         break;
 791                 case HID_DG_HEIGHT:
 792                         td->curdata.h = value;
 793                         break;
 794                 case HID_DG_CONTACTCOUNT:
 795                         break;
 796                 case HID_DG_TOUCH:
 797                         /* do nothing */
 798                         break;
 799
 800                 default:
 801                         if (usage->type)
 802                                 input_event(input, usage->type, usage->code,
 803                                                 value);
 804                         return;
 805                 }
 806
 807                 if (usage->usage_index + 1 == field->report_count) {
 808                         /* we only take into account the last report. */
 809                         if (usage->hid == td->last_slot_field)
 810                                 mt_complete_slot(td, field->hidinput->input);
 811                 }
 812
 813         }
 814 }
 815
 816 static void mt_touch_report(struct hid_device *hid, struct hid_report *report)
 817 {
 818         struct mt_device *td = hid_get_drvdata(hid);
 819         struct hid_field *field;
 820         unsigned count;
 821         int r, n;
 822
 823         /* sticky fingers release in progress, abort */
 824         if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
 825                 return;
 826
 827         /*
 828          * Includes multi-packet support where subsequent
 829          * packets are sent with zero contactcount.
 830          */
 831         if (td->cc_index >= 0) {
 832                 struct hid_field *field = report->field[td->cc_index];
 833                 int value = field->value[td->cc_value_index];
 834                 if (value)
 835                         td->num_expected = value;
 836         }
 837
 838         for (r = 0; r < report->maxfield; r++) {
 839                 field = report->field[r];
 840                 count = field->report_count;
 841
 842                 if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
 843                         continue;
 844
 845                 for (n = 0; n < count; n++)
 846                         mt_process_mt_event(hid, field, &field->usage[n],
 847                                         field->value[n]);
 848         }
 849
 850         if (td->num_received >= td->num_expected)
 851                 mt_sync_frame(td, report->field[0]->hidinput->input);
 852
 853         /*
 854          * Windows 8 specs says 2 things:
 855          * - once a contact has been reported, it has to be reported in each
 856          *   subsequent report
 857          * - the report rate when fingers are present has to be at least
 858          *   the refresh rate of the screen, 60 or 120 Hz
 859          *
 860          * I interprete this that the specification forces a report rate of
 861          * at least 60 Hz for a touchscreen to be certified.
 862          * Which means that if we do not get a report whithin 16 ms, either
 863          * something wrong happens, either the touchscreen forgets to send
 864          * a release. Taking a reasonable margin allows to remove issues
 865          * with USB communication or the load of the machine.
 866          *
 867          * Given that Win 8 devices are forced to send a release, this will
 868          * only affect laggish machines and the ones that have a firmware
 869          * defect.
 870          */
 871         if (td->mtclass.quirks & MT_QUIRK_STICKY_FINGERS) {
 872                 if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
 873                         mod_timer(&td->release_timer,
 874                                   jiffies + msecs_to_jiffies(100));
 875                 else
 876                         del_timer(&td->release_timer);
 877         }
 878
 879         clear_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
 880 }
 881
 882 static int mt_touch_input_configured(struct hid_device *hdev,
 883                                         struct hid_input *hi)
 884 {
 885         struct mt_device *td = hid_get_drvdata(hdev);
 886         struct mt_class *cls = &td->mtclass;
 887         struct input_dev *input = hi->input;
 888         int ret;
 889
 890         if (!td->maxcontacts)
 891                 td->maxcontacts = MT_DEFAULT_MAXCONTACT;
 892
 893         mt_post_parse(td);
 894         if (td->serial_maybe)
 895                 mt_post_parse_default_settings(td);
 896
 897         if (cls->is_indirect)
 898                 td->mt_flags |= INPUT_MT_POINTER;
 899
 900         if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
 901                 td->mt_flags |= INPUT_MT_DROP_UNUSED;
 902
 903         /* check for clickpads */
 904         if ((td->mt_flags & INPUT_MT_POINTER) && (td->buttons_count == 1))
 905                 td->is_buttonpad = true;
 906
 907         if (td->is_buttonpad)
 908                 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
 909
 910         ret = input_mt_init_slots(input, td->maxcontacts, td->mt_flags);
 911         if (ret)
 912                 return ret;
 913
 914         td->mt_flags = 0;
 915         return 0;
 916 }
 917
 918 static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 919                 struct hid_field *field, struct hid_usage *usage,
 920                 unsigned long **bit, int *max)
 921 {
 922         struct mt_device *td = hid_get_drvdata(hdev);
 923
 924         /*
 925          * If mtclass.export_all_inputs is not set, only map fields from
 926          * TouchScreen or TouchPad collections. We need to ignore fields
 927          * that belong to other collections such as Mouse that might have
 928          * the same GenericDesktop usages.
 929          */
 930         if (!td->mtclass.export_all_inputs &&
 931             field->application != HID_DG_TOUCHSCREEN &&
 932             field->application != HID_DG_PEN &&
 933             field->application != HID_DG_TOUCHPAD &&
 934             field->application != HID_GD_KEYBOARD &&
 935             field->application != HID_CP_CONSUMER_CONTROL)
 936                 return -1;
 937
 938         /*
 939          * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN"
 940          * for the stylus.
 941          * The check for mt_report_id ensures we don't process
 942          * HID_DG_CONTACTCOUNT from the pen report as it is outside the physical
 943          * collection, but within the report ID.
 944          */
 945         if (field->physical == HID_DG_STYLUS)
 946                 return 0;
 947         else if ((field->physical == 0) &&
 948                  (field->report->id != td->mt_report_id) &&
 949                  (td->mt_report_id != -1))
 950                 return 0;
 951
 952         if (field->application == HID_DG_TOUCHSCREEN ||
 953             field->application == HID_DG_TOUCHPAD)
 954                 return mt_touch_input_mapping(hdev, hi, field, usage, bit, max);
 955
 956         /* let hid-core decide for the others */
 957         return 0;
 958 }
 959
 960 static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 961                 struct hid_field *field, struct hid_usage *usage,
 962                 unsigned long **bit, int *max)
 963 {
 964         /*
 965          * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN"
 966          * for the stylus.
 967          */
 968         if (field->physical == HID_DG_STYLUS)
 969                 return 0;
 970
 971         if (field->application == HID_DG_TOUCHSCREEN ||
 972             field->application == HID_DG_TOUCHPAD)
 973                 return mt_touch_input_mapped(hdev, hi, field, usage, bit, max);
 974
 975         /* let hid-core decide for the others */
 976         return 0;
 977 }
 978
 979 static int mt_event(struct hid_device *hid, struct hid_field *field,
 980                                 struct hid_usage *usage, __s32 value)
 981 {
 982         struct mt_device *td = hid_get_drvdata(hid);
 983
 984         if (field->report->id == td->mt_report_id)
 985                 return mt_touch_event(hid, field, usage, value);
 986
 987         return 0;
 988 }
 989
 990 static void mt_report(struct hid_device *hid, struct hid_report *report)
 991 {
 992         struct mt_device *td = hid_get_drvdata(hid);
 993         struct hid_field *field = report->field[0];
 994
 995         if (!(hid->claimed & HID_CLAIMED_INPUT))
 996                 return;
 997
 998         if (report->id == td->mt_report_id)
 999                 return mt_touch_report(hid, report);
1000
1001         if (field && field->hidinput && field->hidinput->input)
1002                 input_sync(field->hidinput->input);
1003 }
1004
1005 static void mt_set_input_mode(struct hid_device *hdev)
1006 {
1007         struct mt_device *td = hid_get_drvdata(hdev);
1008         struct hid_report *r;
1009         struct hid_report_enum *re;
1010         struct mt_class *cls = &td->mtclass;
1011         char *buf;
1012         int report_len;
1013
1014         if (td->inputmode < 0)
1015                 return;
1016
1017         re = &(hdev->report_enum[HID_FEATURE_REPORT]);
1018         r = re->report_id_hash[td->inputmode];
1019         if (r) {
1020                 if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) {
1021                         report_len = hid_report_len(r);
1022                         buf = hid_alloc_report_buf(r, GFP_KERNEL);
1023                         if (!buf) {
1024                                 hid_err(hdev, "failed to allocate buffer for report\n");
1025                                 return;
1026                         }
1027                         hid_hw_raw_request(hdev, r->id, buf, report_len,
1028                                            HID_FEATURE_REPORT,
1029                                            HID_REQ_GET_REPORT);
1030                         kfree(buf);
1031                 }
1032                 r->field[0]->value[td->inputmode_index] = td->inputmode_value;
1033                 hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
1034         }
1035 }
1036
1037 static void mt_set_maxcontacts(struct hid_device *hdev)
1038 {
1039         struct mt_device *td = hid_get_drvdata(hdev);
1040         struct hid_report *r;
1041         struct hid_report_enum *re;
1042         int fieldmax, max;
1043
1044         if (td->maxcontact_report_id < 0)
1045                 return;
1046
1047         if (!td->mtclass.maxcontacts)
1048                 return;
1049
1050         re = &hdev->report_enum[HID_FEATURE_REPORT];
1051         r = re->report_id_hash[td->maxcontact_report_id];
1052         if (r) {
1053                 max = td->mtclass.maxcontacts;
1054                 fieldmax = r->field[0]->logical_maximum;
1055                 max = min(fieldmax, max);
1056                 if (r->field[0]->value[0] != max) {
1057                         r->field[0]->value[0] = max;
1058                         hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
1059                 }
1060         }
1061 }
1062
1063 static void mt_post_parse_default_settings(struct mt_device *td)
1064 {
1065         __s32 quirks = td->mtclass.quirks;
1066
1067         /* unknown serial device needs special quirks */
1068         if (td->touches_by_report == 1) {
1069                 quirks |= MT_QUIRK_ALWAYS_VALID;
1070                 quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
1071                 quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
1072                 quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;
1073                 quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
1074         }
1075
1076         td->mtclass.quirks = quirks;
1077 }
1078
1079 static void mt_post_parse(struct mt_device *td)
1080 {
1081         struct mt_fields *f = td->fields;
1082         struct mt_class *cls = &td->mtclass;
1083
1084         if (td->touches_by_report > 0) {
1085                 int field_count_per_touch = f->length / td->touches_by_report;
1086                 td->last_slot_field = f->usages[field_count_per_touch - 1];
1087         }
1088
1089         if (td->cc_index < 0)
1090                 cls->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
1091 }
1092
1093 static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
1094 {
1095         struct mt_device *td = hid_get_drvdata(hdev);
1096         char *name;
1097         const char *suffix = NULL;
1098         struct hid_field *field = hi->report->field[0];
1099         int ret;
1100
1101         if (hi->report->id == td->mt_report_id) {
1102                 ret = mt_touch_input_configured(hdev, hi);
1103                 if (ret)
1104                         return ret;
1105         }
1106
1107         /*
1108          * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN"
1109          * for the stylus. Check this first, and then rely on the application
1110          * field.
1111          */
1112         if (hi->report->field[0]->physical == HID_DG_STYLUS) {
1113                 suffix = "Pen";
1114                 /* force BTN_STYLUS to allow tablet matching in udev */
1115                 __set_bit(BTN_STYLUS, hi->input->keybit);
1116         } else {
1117                 switch (field->application) {
1118                 case HID_GD_KEYBOARD:
1119                         suffix = "Keyboard";
1120                         break;
1121                 case HID_GD_KEYPAD:
1122                         suffix = "Keypad";
1123                         break;
1124                 case HID_GD_MOUSE:
1125                         suffix = "Mouse";
1126                         break;
1127                 case HID_DG_STYLUS:
1128                         suffix = "Pen";
1129                         /* force BTN_STYLUS to allow tablet matching in udev */
1130                         __set_bit(BTN_STYLUS, hi->input->keybit);
1131                         break;
1132                 case HID_DG_TOUCHSCREEN:
1133                         /* we do not set suffix = "Touchscreen" */
1134                         break;
1135                 case HID_DG_TOUCHPAD:
1136                         suffix = "Touchpad";
1137                         break;
1138                 case HID_GD_SYSTEM_CONTROL:
1139                         suffix = "System Control";
1140                         break;
1141                 case HID_CP_CONSUMER_CONTROL:
1142                         suffix = "Consumer Control";
1143                         break;
1144                 default:
1145                         suffix = "UNKNOWN";
1146                         break;
1147                 }
1148         }
1149
1150         if (suffix) {
1151                 name = devm_kzalloc(&hi->input->dev,
1152                                     strlen(hdev->name) + strlen(suffix) + 2,
1153                                     GFP_KERNEL);
1154                 if (name) {
1155                         sprintf(name, "%s %s", hdev->name, suffix);
1156                         hi->input->name = name;
1157                 }
1158         }
1159
1160         return 0;
1161 }
1162
1163 static void mt_fix_const_field(struct hid_field *field, unsigned int usage)
1164 {
1165         if (field->usage[0].hid != usage ||
1166             !(field->flags & HID_MAIN_ITEM_CONSTANT))
1167                 return;
1168
1169         field->flags &= ~HID_MAIN_ITEM_CONSTANT;
1170         field->flags |= HID_MAIN_ITEM_VARIABLE;
1171 }
1172
1173 static void mt_fix_const_fields(struct hid_device *hdev, unsigned int usage)
1174 {
1175         struct hid_report *report;
1176         int i;
1177
1178         list_for_each_entry(report,
1179                             &hdev->report_enum[HID_INPUT_REPORT].report_list,
1180                             list) {
1181
1182                 if (!report->maxfield)
1183                         continue;
1184
1185                 for (i = 0; i < report->maxfield; i++)
1186                         if (report->field[i]->maxusage >= 1)
1187                                 mt_fix_const_field(report->field[i], usage);
1188         }
1189 }
1190
1191 static void mt_release_contacts(struct hid_device *hid)
1192 {
1193         struct hid_input *hidinput;
1194         struct mt_device *td = hid_get_drvdata(hid);
1195
1196         list_for_each_entry(hidinput, &hid->inputs, list) {
1197                 struct input_dev *input_dev = hidinput->input;
1198                 struct input_mt *mt = input_dev->mt;
1199                 int i;
1200
1201                 if (mt) {
1202                         for (i = 0; i < mt->num_slots; i++) {
1203                                 input_mt_slot(input_dev, i);
1204                                 input_mt_report_slot_state(input_dev,
1205                                                            MT_TOOL_FINGER,
1206                                                            false);
1207                         }
1208                         input_mt_sync_frame(input_dev);
1209                         input_sync(input_dev);
1210                 }
1211         }
1212
1213         td->num_received = 0;
1214 }
1215
1216 static void mt_expired_timeout(unsigned long arg)
1217 {
1218         struct hid_device *hdev = (void *)arg;
1219         struct mt_device *td = hid_get_drvdata(hdev);
1220
1221         /*
1222          * An input report came in just before we release the sticky fingers,
1223          * it will take care of the sticky fingers.
1224          */
1225         if (test_and_set_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags))
1226                 return;
1227         if (test_bit(MT_IO_FLAGS_PENDING_SLOTS, &td->mt_io_flags))
1228                 mt_release_contacts(hdev);
1229         clear_bit(MT_IO_FLAGS_RUNNING, &td->mt_io_flags);
1230 }
1231
1232 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
1233 {
1234         int ret, i;
1235         struct mt_device *td;
1236         struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
1237
1238         for (i = 0; mt_classes[i].name ; i++) {
1239                 if (id->driver_data == mt_classes[i].name) {
1240                         mtclass = &(mt_classes[i]);
1241                         break;
1242                 }
1243         }
1244
1245         td = devm_kzalloc(&hdev->dev, sizeof(struct mt_device), GFP_KERNEL);
1246         if (!td) {
1247                 dev_err(&hdev->dev, "cannot allocate multitouch data\n");
1248                 return -ENOMEM;
1249         }
1250         td->mtclass = *mtclass;
1251         td->inputmode = -1;
1252         td->maxcontact_report_id = -1;
1253         td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN;
1254         td->cc_index = -1;
1255         td->mt_report_id = -1;
1256         hid_set_drvdata(hdev, td);
1257
1258         td->fields = devm_kzalloc(&hdev->dev, sizeof(struct mt_fields),
1259                                   GFP_KERNEL);
1260         if (!td->fields) {
1261                 dev_err(&hdev->dev, "cannot allocate multitouch fields data\n");
1262                 return -ENOMEM;
1263         }
1264
1265         if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
1266                 td->serial_maybe = true;
1267
1268         /*
1269          * Store the initial quirk state
1270          */
1271         td->initial_quirks = hdev->quirks;
1272
1273         /* This allows the driver to correctly support devices
1274          * that emit events over several HID messages.
1275          */
1276         hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
1277
1278         /*
1279          * This allows the driver to handle different input sensors
1280          * that emits events through different reports on the same HID
1281          * device.
1282          */
1283         hdev->quirks |= HID_QUIRK_MULTI_INPUT;
1284         hdev->quirks |= HID_QUIRK_NO_EMPTY_INPUT;
1285
1286         /*
1287          * Some multitouch screens do not like to be polled for input
1288          * reports. Fortunately, the Win8 spec says that all touches
1289          * should be sent during each report, making the initialization
1290          * of input reports unnecessary. For Win7 devices, well, let's hope
1291          * they will still be happy (this is only be a problem if a touch
1292          * was already there while probing the device).
1293          *
1294          * In addition some touchpads do not behave well if we read
1295          * all feature reports from them. Instead we prevent
1296          * initial report fetching and then selectively fetch each
1297          * report we are interested in.
1298          */
1299         hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
1300
1301         setup_timer(&td->release_timer, mt_expired_timeout, (long)hdev);
1302
1303         ret = hid_parse(hdev);
1304         if (ret != 0)
1305                 return ret;
1306
1307         if (mtclass->quirks & MT_QUIRK_FIX_CONST_CONTACT_ID)
1308                 mt_fix_const_fields(hdev, HID_DG_CONTACTID);
1309
1310         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
1311         if (ret)
1312                 return ret;
1313
1314         ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
1315         if (ret)
1316                 dev_warn(&hdev->dev, "Cannot allocate sysfs group for %s\n",
1317                                 hdev->name);
1318
1319         mt_set_maxcontacts(hdev);
1320         mt_set_input_mode(hdev);
1321
1322         /* release .fields memory as it is not used anymore */
1323         devm_kfree(&hdev->dev, td->fields);
1324         td->fields = NULL;
1325
1326         return 0;
1327 }
1328
1329 #ifdef CONFIG_PM
1330 static int mt_reset_resume(struct hid_device *hdev)
1331 {
1332         mt_release_contacts(hdev);
1333         mt_set_maxcontacts(hdev);
1334         mt_set_input_mode(hdev);
1335         return 0;
1336 }
1337
1338 static int mt_resume(struct hid_device *hdev)
1339 {
1340         /* Some Elan legacy devices require SET_IDLE to be set on resume.
1341          * It should be safe to send it to other devices too.
1342          * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */
1343
1344         hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE);
1345
1346         return 0;
1347 }
1348 #endif
1349
1350 static void mt_remove(struct hid_device *hdev)
1351 {
1352         struct mt_device *td = hid_get_drvdata(hdev);
1353
1354         del_timer_sync(&td->release_timer);
1355
1356         sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
1357         hid_hw_stop(hdev);
1358         hdev->quirks = td->initial_quirks;
1359 }
1360
1361 /*
1362  * This list contains only:
1363  * - VID/PID of products not working with the default multitouch handling
1364  * - 2 generic rules.
1365  * So there is no point in adding here any device with MT_CLS_DEFAULT.
1366  */
1367 static const struct hid_device_id mt_devices[] = {
1368
1369         /* 3M panels */
1370         { .driver_data = MT_CLS_3M,
1371                 MT_USB_DEVICE(USB_VENDOR_ID_3M,
1372                         USB_DEVICE_ID_3M1968) },
1373         { .driver_data = MT_CLS_3M,
1374                 MT_USB_DEVICE(USB_VENDOR_ID_3M,
1375                         USB_DEVICE_ID_3M2256) },
1376         { .driver_data = MT_CLS_3M,
1377                 MT_USB_DEVICE(USB_VENDOR_ID_3M,
1378                         USB_DEVICE_ID_3M3266) },
1379
1380         /* Alps devices */
1381         { .driver_data = MT_CLS_WIN_8_DUAL,
1382                 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1383                         USB_VENDOR_ID_ALPS_JP,
1384                         HID_DEVICE_ID_ALPS_U1_DUAL_PTP) },
1385         { .driver_data = MT_CLS_WIN_8_DUAL,
1386                 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1387                         USB_VENDOR_ID_ALPS_JP,
1388                         HID_DEVICE_ID_ALPS_U1_DUAL_3BTN_PTP) },
1389
1390         /* Anton devices */
1391         { .driver_data = MT_CLS_EXPORT_ALL_INPUTS,
1392                 MT_USB_DEVICE(USB_VENDOR_ID_ANTON,
1393                         USB_DEVICE_ID_ANTON_TOUCH_PAD) },
1394
1395         /* Atmel panels */
1396         { .driver_data = MT_CLS_SERIAL,
1397                 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
1398                         USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
1399
1400         /* Baanto multitouch devices */
1401         { .driver_data = MT_CLS_NSMU,
1402                 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
1403                         USB_DEVICE_ID_BAANTO_MT_190W2) },
1404
1405         /* Cando panels */
1406         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1407                 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1408                         USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
1409         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1410                 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1411                         USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
1412
1413         /* Chunghwa Telecom touch panels */
1414         {  .driver_data = MT_CLS_NSMU,
1415                 MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
1416                         USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
1417
1418         /* CJTouch panels */
1419         { .driver_data = MT_CLS_NSMU,
1420                 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
1421                         USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020) },
1422         { .driver_data = MT_CLS_NSMU,
1423                 MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
1424                         USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040) },
1425
1426         /* CVTouch panels */
1427         { .driver_data = MT_CLS_NSMU,
1428                 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
1429                         USB_DEVICE_ID_CVTOUCH_SCREEN) },
1430
1431         /* eGalax devices (resistive) */
1432         { .driver_data = MT_CLS_EGALAX,
1433                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1434                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
1435         { .driver_data = MT_CLS_EGALAX,
1436                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1437                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
1438
1439         /* eGalax devices (capacitive) */
1440         { .driver_data = MT_CLS_EGALAX_SERIAL,
1441                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1442                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
1443         { .driver_data = MT_CLS_EGALAX,
1444                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1445                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
1446         { .driver_data = MT_CLS_EGALAX_SERIAL,
1447                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1448                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
1449         { .driver_data = MT_CLS_EGALAX_SERIAL,
1450                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1451                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
1452         { .driver_data = MT_CLS_EGALAX_SERIAL,
1453                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1454                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
1455         { .driver_data = MT_CLS_EGALAX_SERIAL,
1456                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1457                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
1458         { .driver_data = MT_CLS_EGALAX,
1459                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1460                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
1461         { .driver_data = MT_CLS_EGALAX,
1462                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1463                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
1464         { .driver_data = MT_CLS_EGALAX_SERIAL,
1465                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1466                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
1467         { .driver_data = MT_CLS_EGALAX,
1468                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1469                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
1470         { .driver_data = MT_CLS_EGALAX,
1471                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1472                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
1473         { .driver_data = MT_CLS_EGALAX,
1474                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1475                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
1476         { .driver_data = MT_CLS_EGALAX,
1477                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1478                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
1479         { .driver_data = MT_CLS_EGALAX_SERIAL,
1480                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1481                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
1482         { .driver_data = MT_CLS_EGALAX_SERIAL,
1483                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1484                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) },
1485         { .driver_data = MT_CLS_EGALAX_SERIAL,
1486                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1487                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
1488
1489         /* Elitegroup panel */
1490         { .driver_data = MT_CLS_SERIAL,
1491                 MT_USB_DEVICE(USB_VENDOR_ID_ELITEGROUP,
1492                         USB_DEVICE_ID_ELITEGROUP_05D8) },
1493
1494         /* Flatfrog Panels */
1495         { .driver_data = MT_CLS_FLATFROG,
1496                 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG,
1497                         USB_DEVICE_ID_MULTITOUCH_3200) },
1498
1499         /* FocalTech Panels */
1500         { .driver_data = MT_CLS_SERIAL,
1501                 MT_USB_DEVICE(USB_VENDOR_ID_CYGNAL,
1502                         USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH) },
1503
1504         /* GeneralTouch panel */
1505         { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
1506                 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1507                         USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
1508         { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1509                 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1510                         USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) },
1511         { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
1512                 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1513                         USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0101) },
1514         { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1515                 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1516                         USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0102) },
1517         { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1518                 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1519                         USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0106) },
1520         { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1521                 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1522                         USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A) },
1523         { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1524                 MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1525                         USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100) },
1526
1527         /* Gametel game controller */
1528         { .driver_data = MT_CLS_NSMU,
1529                 MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
1530                         USB_DEVICE_ID_GAMETEL_MT_MODE) },
1531
1532         /* GoodTouch panels */
1533         { .driver_data = MT_CLS_NSMU,
1534                 MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
1535                         USB_DEVICE_ID_GOODTOUCH_000f) },
1536
1537         /* Hanvon panels */
1538         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1539                 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
1540                         USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
1541
1542         /* Ilitek dual touch panel */
1543         {  .driver_data = MT_CLS_NSMU,
1544                 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
1545                         USB_DEVICE_ID_ILITEK_MULTITOUCH) },
1546
1547         /* LG Melfas panel */
1548         { .driver_data = MT_CLS_LG,
1549                 HID_USB_DEVICE(USB_VENDOR_ID_LG,
1550                         USB_DEVICE_ID_LG_MELFAS_MT) },
1551
1552         /* MosArt panels */
1553         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1554                 MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
1555                         USB_DEVICE_ID_ASUS_T91MT)},
1556         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1557                 MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
1558                         USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
1559         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1560                 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
1561                         USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
1562
1563         /* Panasonic panels */
1564         { .driver_data = MT_CLS_PANASONIC,
1565                 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
1566                         USB_DEVICE_ID_PANABOARD_UBT780) },
1567         { .driver_data = MT_CLS_PANASONIC,
1568                 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
1569                         USB_DEVICE_ID_PANABOARD_UBT880) },
1570
1571         /* Novatek Panel */
1572         { .driver_data = MT_CLS_NSMU,
1573                 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
1574                         USB_DEVICE_ID_NOVATEK_PCT) },
1575
1576         /* Ntrig Panel */
1577         { .driver_data = MT_CLS_NSMU,
1578                 HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
1579                         USB_VENDOR_ID_NTRIG, 0x1b05) },
1580
1581         /* PixArt optical touch screen */
1582         { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1583                 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1584                         USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
1585         { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1586                 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1587                         USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
1588         { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1589                 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1590                         USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
1591
1592         /* PixCir-based panels */
1593         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1594                 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1595                         USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
1596
1597         /* Quanta-based panels */
1598         { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1599                 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1600                         USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
1601
1602         /* Stantum panels */
1603         { .driver_data = MT_CLS_CONFIDENCE,
1604                 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
1605                         USB_DEVICE_ID_MTP_STM)},
1606
1607         /* TopSeed panels */
1608         { .driver_data = MT_CLS_TOPSEED,
1609                 MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
1610                         USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },
1611
1612         /* Touch International panels */
1613         { .driver_data = MT_CLS_NSMU,
1614                 MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
1615                         USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
1616
1617         /* Unitec panels */
1618         { .driver_data = MT_CLS_NSMU,
1619                 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
1620                         USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
1621         { .driver_data = MT_CLS_NSMU,
1622                 MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
1623                         USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
1624
1625         /* VTL panels */
1626         { .driver_data = MT_CLS_VTL,
1627                 MT_USB_DEVICE(USB_VENDOR_ID_VTL,
1628                         USB_DEVICE_ID_VTL_MULTITOUCH_FF3F) },
1629
1630         /* Wistron panels */
1631         { .driver_data = MT_CLS_NSMU,
1632                 MT_USB_DEVICE(USB_VENDOR_ID_WISTRON,
1633                         USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH) },
1634
1635         /* XAT */
1636         { .driver_data = MT_CLS_NSMU,
1637                 MT_USB_DEVICE(USB_VENDOR_ID_XAT,
1638                         USB_DEVICE_ID_XAT_CSR) },
1639
1640         /* Xiroku */
1641         { .driver_data = MT_CLS_NSMU,
1642                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1643                         USB_DEVICE_ID_XIROKU_SPX) },
1644         { .driver_data = MT_CLS_NSMU,
1645                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1646                         USB_DEVICE_ID_XIROKU_MPX) },
1647         { .driver_data = MT_CLS_NSMU,
1648                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1649                         USB_DEVICE_ID_XIROKU_CSR) },
1650         { .driver_data = MT_CLS_NSMU,
1651                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1652                         USB_DEVICE_ID_XIROKU_SPX1) },
1653         { .driver_data = MT_CLS_NSMU,
1654                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1655                         USB_DEVICE_ID_XIROKU_MPX1) },
1656         { .driver_data = MT_CLS_NSMU,
1657                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1658                         USB_DEVICE_ID_XIROKU_CSR1) },
1659         { .driver_data = MT_CLS_NSMU,
1660                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1661                         USB_DEVICE_ID_XIROKU_SPX2) },
1662         { .driver_data = MT_CLS_NSMU,
1663                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1664                         USB_DEVICE_ID_XIROKU_MPX2) },
1665         { .driver_data = MT_CLS_NSMU,
1666                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1667                         USB_DEVICE_ID_XIROKU_CSR2) },
1668
1669         /* Google MT devices */
1670         { .driver_data = MT_CLS_GOOGLE,
1671                 HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_GOOGLE,
1672                         USB_DEVICE_ID_GOOGLE_TOUCH_ROSE) },
1673
1674         /* Generic MT device */
1675         { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
1676
1677         /* Generic Win 8 certified MT device */
1678         {  .driver_data = MT_CLS_WIN_8,
1679                 HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH_WIN_8,
1680                         HID_ANY_ID, HID_ANY_ID) },
1681         { }
1682 };
1683 MODULE_DEVICE_TABLE(hid, mt_devices);
1684
1685 static const struct hid_usage_id mt_grabbed_usages[] = {
1686         { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
1687         { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
1688 };
1689
1690 static struct hid_driver mt_driver = {
1691         .name = "hid-multitouch",
1692         .id_table = mt_devices,
1693         .probe = mt_probe,
1694         .remove = mt_remove,
1695         .input_mapping = mt_input_mapping,
1696         .input_mapped = mt_input_mapped,
1697         .input_configured = mt_input_configured,
1698         .feature_mapping = mt_feature_mapping,
1699         .usage_table = mt_grabbed_usages,
1700         .event = mt_event,
1701         .report = mt_report,
1702 #ifdef CONFIG_PM
1703         .reset_resume = mt_reset_resume,
1704         .resume = mt_resume,
1705 #endif
1706 };
1707 module_hid_driver(mt_driver);