drivers/hid/hid-multitouch.c

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