drivers/hid/hid-multitouch.c

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