linux/drivers/hid/hid-multitouch.c
<<
>>
Prefs
   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/usb.h>
  46#include <linux/input/mt.h>
  47#include <linux/string.h>
  48
  49
  50MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
  51MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
  52MODULE_DESCRIPTION("HID multitouch panels");
  53MODULE_LICENSE("GPL");
  54
  55#include "hid-ids.h"
  56
  57/* quirks to control the device */
  58#define MT_QUIRK_NOT_SEEN_MEANS_UP      (1 << 0)
  59#define MT_QUIRK_SLOT_IS_CONTACTID      (1 << 1)
  60#define MT_QUIRK_CYPRESS                (1 << 2)
  61#define MT_QUIRK_SLOT_IS_CONTACTNUMBER  (1 << 3)
  62#define MT_QUIRK_ALWAYS_VALID           (1 << 4)
  63#define MT_QUIRK_VALID_IS_INRANGE       (1 << 5)
  64#define MT_QUIRK_VALID_IS_CONFIDENCE    (1 << 6)
  65#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE    (1 << 8)
  66#define MT_QUIRK_NO_AREA                (1 << 9)
  67#define MT_QUIRK_IGNORE_DUPLICATES      (1 << 10)
  68#define MT_QUIRK_HOVERING               (1 << 11)
  69#define MT_QUIRK_CONTACT_CNT_ACCURATE   (1 << 12)
  70
  71struct mt_slot {
  72        __s32 x, y, cx, cy, p, w, h;
  73        __s32 contactid;        /* the device ContactID assigned to this slot */
  74        bool touch_state;       /* is the touch valid? */
  75        bool inrange_state;     /* is the finger in proximity of the sensor? */
  76};
  77
  78struct mt_class {
  79        __s32 name;     /* MT_CLS */
  80        __s32 quirks;
  81        __s32 sn_move;  /* Signal/noise ratio for move events */
  82        __s32 sn_width; /* Signal/noise ratio for width events */
  83        __s32 sn_height;        /* Signal/noise ratio for height events */
  84        __s32 sn_pressure;      /* Signal/noise ratio for pressure events */
  85        __u8 maxcontacts;
  86        bool is_indirect;       /* true for touchpads */
  87};
  88
  89struct mt_fields {
  90        unsigned usages[HID_MAX_FIELDS];
  91        unsigned int length;
  92};
  93
  94struct mt_device {
  95        struct mt_slot curdata; /* placeholder of incoming data */
  96        struct mt_class mtclass;        /* our mt device class */
  97        struct mt_fields *fields;       /* temporary placeholder for storing the
  98                                           multitouch fields */
  99        int cc_index;   /* contact count field index in the report */
 100        int cc_value_index;     /* contact count value index in the field */
 101        unsigned last_slot_field;       /* the last field of a slot */
 102        unsigned mt_report_id;  /* the report ID of the multitouch device */
 103        unsigned pen_report_id; /* the report ID of the pen device */
 104        __s8 inputmode;         /* InputMode HID feature, -1 if non-existent */
 105        __s8 inputmode_index;   /* InputMode HID feature index in the report */
 106        __s8 maxcontact_report_id;      /* Maximum Contact Number HID feature,
 107                                   -1 if non-existent */
 108        __u8 num_received;      /* how many contacts we received */
 109        __u8 num_expected;      /* expected last contact index */
 110        __u8 maxcontacts;
 111        __u8 touches_by_report; /* how many touches are present in one report:
 112                                * 1 means we should use a serial protocol
 113                                * > 1 means hybrid (multitouch) protocol */
 114        bool serial_maybe;      /* need to check for serial protocol */
 115        bool curvalid;          /* is the current contact valid? */
 116        unsigned mt_flags;      /* flags to pass to input-mt */
 117};
 118
 119static void mt_post_parse_default_settings(struct mt_device *td);
 120static void mt_post_parse(struct mt_device *td);
 121
 122/* classes of device behavior */
 123#define MT_CLS_DEFAULT                          0x0001
 124
 125#define MT_CLS_SERIAL                           0x0002
 126#define MT_CLS_CONFIDENCE                       0x0003
 127#define MT_CLS_CONFIDENCE_CONTACT_ID            0x0004
 128#define MT_CLS_CONFIDENCE_MINUS_ONE             0x0005
 129#define MT_CLS_DUAL_INRANGE_CONTACTID           0x0006
 130#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER       0x0007
 131#define MT_CLS_DUAL_NSMU_CONTACTID              0x0008
 132#define MT_CLS_INRANGE_CONTACTNUMBER            0x0009
 133#define MT_CLS_NSMU                             0x000a
 134#define MT_CLS_DUAL_CONTACT_NUMBER              0x0010
 135#define MT_CLS_DUAL_CONTACT_ID                  0x0011
 136
 137/* vendor specific classes */
 138#define MT_CLS_3M                               0x0101
 139#define MT_CLS_CYPRESS                          0x0102
 140#define MT_CLS_EGALAX                           0x0103
 141#define MT_CLS_EGALAX_SERIAL                    0x0104
 142#define MT_CLS_TOPSEED                          0x0105
 143#define MT_CLS_PANASONIC                        0x0106
 144#define MT_CLS_FLATFROG                         0x0107
 145#define MT_CLS_GENERALTOUCH_TWOFINGERS          0x0108
 146#define MT_CLS_GENERALTOUCH_PWT_TENFINGERS      0x0109
 147
 148#define MT_DEFAULT_MAXCONTACT   10
 149#define MT_MAX_MAXCONTACT       250
 150
 151#define MT_USB_DEVICE(v, p)     HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH, v, p)
 152#define MT_BT_DEVICE(v, p)      HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_MULTITOUCH, v, p)
 153
 154/*
 155 * these device-dependent functions determine what slot corresponds
 156 * to a valid contact that was just read.
 157 */
 158
 159static int cypress_compute_slot(struct mt_device *td)
 160{
 161        if (td->curdata.contactid != 0 || td->num_received == 0)
 162                return td->curdata.contactid;
 163        else
 164                return -1;
 165}
 166
 167static struct mt_class mt_classes[] = {
 168        { .name = MT_CLS_DEFAULT,
 169                .quirks = MT_QUIRK_ALWAYS_VALID |
 170                        MT_QUIRK_CONTACT_CNT_ACCURATE },
 171        { .name = MT_CLS_NSMU,
 172                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
 173        { .name = MT_CLS_SERIAL,
 174                .quirks = MT_QUIRK_ALWAYS_VALID},
 175        { .name = MT_CLS_CONFIDENCE,
 176                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
 177        { .name = MT_CLS_CONFIDENCE_CONTACT_ID,
 178                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 179                        MT_QUIRK_SLOT_IS_CONTACTID },
 180        { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
 181                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 182                        MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
 183        { .name = MT_CLS_DUAL_INRANGE_CONTACTID,
 184                .quirks = MT_QUIRK_VALID_IS_INRANGE |
 185                        MT_QUIRK_SLOT_IS_CONTACTID,
 186                .maxcontacts = 2 },
 187        { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 188                .quirks = MT_QUIRK_VALID_IS_INRANGE |
 189                        MT_QUIRK_SLOT_IS_CONTACTNUMBER,
 190                .maxcontacts = 2 },
 191        { .name = MT_CLS_DUAL_NSMU_CONTACTID,
 192                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 193                        MT_QUIRK_SLOT_IS_CONTACTID,
 194                .maxcontacts = 2 },
 195        { .name = MT_CLS_INRANGE_CONTACTNUMBER,
 196                .quirks = MT_QUIRK_VALID_IS_INRANGE |
 197                        MT_QUIRK_SLOT_IS_CONTACTNUMBER },
 198        { .name = MT_CLS_DUAL_CONTACT_NUMBER,
 199                .quirks = MT_QUIRK_ALWAYS_VALID |
 200                        MT_QUIRK_CONTACT_CNT_ACCURATE |
 201                        MT_QUIRK_SLOT_IS_CONTACTNUMBER,
 202                .maxcontacts = 2 },
 203        { .name = MT_CLS_DUAL_CONTACT_ID,
 204                .quirks = MT_QUIRK_ALWAYS_VALID |
 205                        MT_QUIRK_CONTACT_CNT_ACCURATE |
 206                        MT_QUIRK_SLOT_IS_CONTACTID,
 207                .maxcontacts = 2 },
 208
 209        /*
 210         * vendor specific classes
 211         */
 212        { .name = MT_CLS_3M,
 213                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 214                        MT_QUIRK_SLOT_IS_CONTACTID,
 215                .sn_move = 2048,
 216                .sn_width = 128,
 217                .sn_height = 128,
 218                .maxcontacts = 60,
 219        },
 220        { .name = MT_CLS_CYPRESS,
 221                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 222                        MT_QUIRK_CYPRESS,
 223                .maxcontacts = 10 },
 224        { .name = MT_CLS_EGALAX,
 225                .quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
 226                        MT_QUIRK_VALID_IS_INRANGE,
 227                .sn_move = 4096,
 228                .sn_pressure = 32,
 229        },
 230        { .name = MT_CLS_EGALAX_SERIAL,
 231                .quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
 232                        MT_QUIRK_ALWAYS_VALID,
 233                .sn_move = 4096,
 234                .sn_pressure = 32,
 235        },
 236        { .name = MT_CLS_TOPSEED,
 237                .quirks = MT_QUIRK_ALWAYS_VALID,
 238                .is_indirect = true,
 239                .maxcontacts = 2,
 240        },
 241        { .name = MT_CLS_PANASONIC,
 242                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP,
 243                .maxcontacts = 4 },
 244        { .name = MT_CLS_GENERALTOUCH_TWOFINGERS,
 245                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 246                        MT_QUIRK_VALID_IS_INRANGE |
 247                        MT_QUIRK_SLOT_IS_CONTACTNUMBER,
 248                .maxcontacts = 2
 249        },
 250        { .name = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
 251                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 252                        MT_QUIRK_SLOT_IS_CONTACTNUMBER
 253        },
 254
 255        { .name = MT_CLS_FLATFROG,
 256                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 257                        MT_QUIRK_NO_AREA,
 258                .sn_move = 2048,
 259                .maxcontacts = 40,
 260        },
 261        { }
 262};
 263
 264static void mt_free_input_name(struct hid_input *hi)
 265{
 266        struct hid_device *hdev = hi->report->device;
 267        const char *name = hi->input->name;
 268
 269        if (name != hdev->name) {
 270                hi->input->name = hdev->name;
 271                kfree(name);
 272        }
 273}
 274
 275static ssize_t mt_show_quirks(struct device *dev,
 276                           struct device_attribute *attr,
 277                           char *buf)
 278{
 279        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 280        struct mt_device *td = hid_get_drvdata(hdev);
 281
 282        return sprintf(buf, "%u\n", td->mtclass.quirks);
 283}
 284
 285static ssize_t mt_set_quirks(struct device *dev,
 286                          struct device_attribute *attr,
 287                          const char *buf, size_t count)
 288{
 289        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 290        struct mt_device *td = hid_get_drvdata(hdev);
 291
 292        unsigned long val;
 293
 294        if (kstrtoul(buf, 0, &val))
 295                return -EINVAL;
 296
 297        td->mtclass.quirks = val;
 298
 299        if (td->cc_index < 0)
 300                td->mtclass.quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
 301
 302        return count;
 303}
 304
 305static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
 306
 307static struct attribute *sysfs_attrs[] = {
 308        &dev_attr_quirks.attr,
 309        NULL
 310};
 311
 312static struct attribute_group mt_attribute_group = {
 313        .attrs = sysfs_attrs
 314};
 315
 316static void mt_feature_mapping(struct hid_device *hdev,
 317                struct hid_field *field, struct hid_usage *usage)
 318{
 319        struct mt_device *td = hid_get_drvdata(hdev);
 320        int i;
 321
 322        switch (usage->hid) {
 323        case HID_DG_INPUTMODE:
 324                td->inputmode = field->report->id;
 325                td->inputmode_index = 0; /* has to be updated below */
 326
 327                for (i=0; i < field->maxusage; i++) {
 328                        if (field->usage[i].hid == usage->hid) {
 329                                td->inputmode_index = i;
 330                                break;
 331                        }
 332                }
 333
 334                break;
 335        case HID_DG_CONTACTMAX:
 336                td->maxcontact_report_id = field->report->id;
 337                td->maxcontacts = field->value[0];
 338                if (!td->maxcontacts &&
 339                    field->logical_maximum <= MT_MAX_MAXCONTACT)
 340                        td->maxcontacts = field->logical_maximum;
 341                if (td->mtclass.maxcontacts)
 342                        /* check if the maxcontacts is given by the class */
 343                        td->maxcontacts = td->mtclass.maxcontacts;
 344
 345                break;
 346        case 0xff0000c5:
 347                if (field->report_count == 256 && field->report_size == 8) {
 348                        /* Win 8 devices need special quirks */
 349                        __s32 *quirks = &td->mtclass.quirks;
 350                        *quirks |= MT_QUIRK_ALWAYS_VALID;
 351                        *quirks |= MT_QUIRK_IGNORE_DUPLICATES;
 352                        *quirks |= MT_QUIRK_HOVERING;
 353                        *quirks |= MT_QUIRK_CONTACT_CNT_ACCURATE;
 354                        *quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
 355                        *quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
 356                        *quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;
 357                }
 358                break;
 359        }
 360}
 361
 362static void set_abs(struct input_dev *input, unsigned int code,
 363                struct hid_field *field, int snratio)
 364{
 365        int fmin = field->logical_minimum;
 366        int fmax = field->logical_maximum;
 367        int fuzz = snratio ? (fmax - fmin) / snratio : 0;
 368        input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
 369        input_abs_set_res(input, code, hidinput_calc_abs_res(field, code));
 370}
 371
 372static void mt_store_field(struct hid_usage *usage, struct mt_device *td,
 373                struct hid_input *hi)
 374{
 375        struct mt_fields *f = td->fields;
 376
 377        if (f->length >= HID_MAX_FIELDS)
 378                return;
 379
 380        f->usages[f->length++] = usage->hid;
 381}
 382
 383static int mt_pen_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 384                struct hid_field *field, struct hid_usage *usage,
 385                unsigned long **bit, int *max)
 386{
 387        struct mt_device *td = hid_get_drvdata(hdev);
 388
 389        td->pen_report_id = field->report->id;
 390
 391        return 0;
 392}
 393
 394static int mt_pen_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 395                struct hid_field *field, struct hid_usage *usage,
 396                unsigned long **bit, int *max)
 397{
 398        return 0;
 399}
 400
 401static int mt_pen_event(struct hid_device *hid, struct hid_field *field,
 402                                struct hid_usage *usage, __s32 value)
 403{
 404        /* let hid-input handle it */
 405        return 0;
 406}
 407
 408static void mt_pen_report(struct hid_device *hid, struct hid_report *report)
 409{
 410        struct hid_field *field = report->field[0];
 411
 412        input_sync(field->hidinput->input);
 413}
 414
 415static void mt_pen_input_configured(struct hid_device *hdev,
 416                                        struct hid_input *hi)
 417{
 418        char *name = kzalloc(strlen(hi->input->name) + 5, GFP_KERNEL);
 419        if (name) {
 420                sprintf(name, "%s Pen", hi->input->name);
 421                mt_free_input_name(hi);
 422                hi->input->name = name;
 423        }
 424
 425        /* force BTN_STYLUS to allow tablet matching in udev */
 426        __set_bit(BTN_STYLUS, hi->input->keybit);
 427}
 428
 429static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 430                struct hid_field *field, struct hid_usage *usage,
 431                unsigned long **bit, int *max)
 432{
 433        struct mt_device *td = hid_get_drvdata(hdev);
 434        struct mt_class *cls = &td->mtclass;
 435        int code;
 436        struct hid_usage *prev_usage = NULL;
 437
 438        if (field->application == HID_DG_TOUCHSCREEN)
 439                td->mt_flags |= INPUT_MT_DIRECT;
 440
 441        /*
 442         * Model touchscreens providing buttons as touchpads.
 443         */
 444        if (field->application == HID_DG_TOUCHPAD ||
 445            (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
 446                td->mt_flags |= INPUT_MT_POINTER;
 447
 448        if (usage->usage_index)
 449                prev_usage = &field->usage[usage->usage_index - 1];
 450
 451        switch (usage->hid & HID_USAGE_PAGE) {
 452
 453        case HID_UP_GENDESK:
 454                switch (usage->hid) {
 455                case HID_GD_X:
 456                        if (prev_usage && (prev_usage->hid == usage->hid)) {
 457                                hid_map_usage(hi, usage, bit, max,
 458                                        EV_ABS, ABS_MT_TOOL_X);
 459                                set_abs(hi->input, ABS_MT_TOOL_X, field,
 460                                        cls->sn_move);
 461                        } else {
 462                                hid_map_usage(hi, usage, bit, max,
 463                                        EV_ABS, ABS_MT_POSITION_X);
 464                                set_abs(hi->input, ABS_MT_POSITION_X, field,
 465                                        cls->sn_move);
 466                        }
 467
 468                        mt_store_field(usage, td, hi);
 469                        return 1;
 470                case HID_GD_Y:
 471                        if (prev_usage && (prev_usage->hid == usage->hid)) {
 472                                hid_map_usage(hi, usage, bit, max,
 473                                        EV_ABS, ABS_MT_TOOL_Y);
 474                                set_abs(hi->input, ABS_MT_TOOL_Y, field,
 475                                        cls->sn_move);
 476                        } else {
 477                                hid_map_usage(hi, usage, bit, max,
 478                                        EV_ABS, ABS_MT_POSITION_Y);
 479                                set_abs(hi->input, ABS_MT_POSITION_Y, field,
 480                                        cls->sn_move);
 481                        }
 482
 483                        mt_store_field(usage, td, hi);
 484                        return 1;
 485                }
 486                return 0;
 487
 488        case HID_UP_DIGITIZER:
 489                switch (usage->hid) {
 490                case HID_DG_INRANGE:
 491                        if (cls->quirks & MT_QUIRK_HOVERING) {
 492                                hid_map_usage(hi, usage, bit, max,
 493                                        EV_ABS, ABS_MT_DISTANCE);
 494                                input_set_abs_params(hi->input,
 495                                        ABS_MT_DISTANCE, 0, 1, 0, 0);
 496                        }
 497                        mt_store_field(usage, td, hi);
 498                        return 1;
 499                case HID_DG_CONFIDENCE:
 500                        mt_store_field(usage, td, hi);
 501                        return 1;
 502                case HID_DG_TIPSWITCH:
 503                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
 504                        input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
 505                        mt_store_field(usage, td, hi);
 506                        return 1;
 507                case HID_DG_CONTACTID:
 508                        mt_store_field(usage, td, hi);
 509                        td->touches_by_report++;
 510                        td->mt_report_id = field->report->id;
 511                        return 1;
 512                case HID_DG_WIDTH:
 513                        hid_map_usage(hi, usage, bit, max,
 514                                        EV_ABS, ABS_MT_TOUCH_MAJOR);
 515                        if (!(cls->quirks & MT_QUIRK_NO_AREA))
 516                                set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
 517                                        cls->sn_width);
 518                        mt_store_field(usage, td, hi);
 519                        return 1;
 520                case HID_DG_HEIGHT:
 521                        hid_map_usage(hi, usage, bit, max,
 522                                        EV_ABS, ABS_MT_TOUCH_MINOR);
 523                        if (!(cls->quirks & MT_QUIRK_NO_AREA)) {
 524                                set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
 525                                        cls->sn_height);
 526                                input_set_abs_params(hi->input,
 527                                        ABS_MT_ORIENTATION, 0, 1, 0, 0);
 528                        }
 529                        mt_store_field(usage, td, hi);
 530                        return 1;
 531                case HID_DG_TIPPRESSURE:
 532                        hid_map_usage(hi, usage, bit, max,
 533                                        EV_ABS, ABS_MT_PRESSURE);
 534                        set_abs(hi->input, ABS_MT_PRESSURE, field,
 535                                cls->sn_pressure);
 536                        mt_store_field(usage, td, hi);
 537                        return 1;
 538                case HID_DG_CONTACTCOUNT:
 539                        td->cc_index = field->index;
 540                        td->cc_value_index = usage->usage_index;
 541                        return 1;
 542                case HID_DG_CONTACTMAX:
 543                        /* we don't set td->last_slot_field as contactcount and
 544                         * contact max are global to the report */
 545                        return -1;
 546                case HID_DG_TOUCH:
 547                        /* Legacy devices use TIPSWITCH and not TOUCH.
 548                         * Let's just ignore this field. */
 549                        return -1;
 550                }
 551                /* let hid-input decide for the others */
 552                return 0;
 553
 554        case HID_UP_BUTTON:
 555                code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
 556                hid_map_usage(hi, usage, bit, max, EV_KEY, code);
 557                input_set_capability(hi->input, EV_KEY, code);
 558                return 1;
 559
 560        case 0xff000000:
 561                /* we do not want to map these: no input-oriented meaning */
 562                return -1;
 563        }
 564
 565        return 0;
 566}
 567
 568static int mt_touch_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 569                struct hid_field *field, struct hid_usage *usage,
 570                unsigned long **bit, int *max)
 571{
 572        if (usage->type == EV_KEY || usage->type == EV_ABS)
 573                set_bit(usage->type, hi->input->evbit);
 574
 575        return -1;
 576}
 577
 578static int mt_compute_slot(struct mt_device *td, struct input_dev *input)
 579{
 580        __s32 quirks = td->mtclass.quirks;
 581
 582        if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
 583                return td->curdata.contactid;
 584
 585        if (quirks & MT_QUIRK_CYPRESS)
 586                return cypress_compute_slot(td);
 587
 588        if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
 589                return td->num_received;
 590
 591        if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
 592                return td->curdata.contactid - 1;
 593
 594        return input_mt_get_slot_by_key(input, td->curdata.contactid);
 595}
 596
 597/*
 598 * this function is called when a whole contact has been processed,
 599 * so that it can assign it to a slot and store the data there
 600 */
 601static void mt_complete_slot(struct mt_device *td, struct input_dev *input)
 602{
 603        if ((td->mtclass.quirks & MT_QUIRK_CONTACT_CNT_ACCURATE) &&
 604            td->num_received >= td->num_expected)
 605                return;
 606
 607        if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) {
 608                int slotnum = mt_compute_slot(td, input);
 609                struct mt_slot *s = &td->curdata;
 610                struct input_mt *mt = input->mt;
 611
 612                if (slotnum < 0 || slotnum >= td->maxcontacts)
 613                        return;
 614
 615                if ((td->mtclass.quirks & MT_QUIRK_IGNORE_DUPLICATES) && mt) {
 616                        struct input_mt_slot *slot = &mt->slots[slotnum];
 617                        if (input_mt_is_active(slot) &&
 618                            input_mt_is_used(mt, slot))
 619                                return;
 620                }
 621
 622                input_mt_slot(input, slotnum);
 623                input_mt_report_slot_state(input, MT_TOOL_FINGER,
 624                        s->touch_state || s->inrange_state);
 625                if (s->touch_state || s->inrange_state) {
 626                        /* this finger is in proximity of the sensor */
 627                        int wide = (s->w > s->h);
 628                        /* divided by two to match visual scale of touch */
 629                        int major = max(s->w, s->h) >> 1;
 630                        int minor = min(s->w, s->h) >> 1;
 631
 632                        input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
 633                        input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
 634                        input_event(input, EV_ABS, ABS_MT_TOOL_X, s->cx);
 635                        input_event(input, EV_ABS, ABS_MT_TOOL_Y, s->cy);
 636                        input_event(input, EV_ABS, ABS_MT_DISTANCE,
 637                                !s->touch_state);
 638                        input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
 639                        input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
 640                        input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
 641                        input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
 642                }
 643        }
 644
 645        td->num_received++;
 646}
 647
 648/*
 649 * this function is called when a whole packet has been received and processed,
 650 * so that it can decide what to send to the input layer.
 651 */
 652static void mt_sync_frame(struct mt_device *td, struct input_dev *input)
 653{
 654        input_mt_sync_frame(input);
 655        input_sync(input);
 656        td->num_received = 0;
 657}
 658
 659static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
 660                                struct hid_usage *usage, __s32 value)
 661{
 662        /* we will handle the hidinput part later, now remains hiddev */
 663        if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
 664                hid->hiddev_hid_event(hid, field, usage, value);
 665
 666        return 1;
 667}
 668
 669static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
 670                                struct hid_usage *usage, __s32 value)
 671{
 672        struct mt_device *td = hid_get_drvdata(hid);
 673        __s32 quirks = td->mtclass.quirks;
 674        struct input_dev *input = field->hidinput->input;
 675
 676        if (hid->claimed & HID_CLAIMED_INPUT) {
 677                switch (usage->hid) {
 678                case HID_DG_INRANGE:
 679                        if (quirks & MT_QUIRK_VALID_IS_INRANGE)
 680                                td->curvalid = value;
 681                        if (quirks & MT_QUIRK_HOVERING)
 682                                td->curdata.inrange_state = value;
 683                        break;
 684                case HID_DG_TIPSWITCH:
 685                        if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
 686                                td->curvalid = value;
 687                        td->curdata.touch_state = value;
 688                        break;
 689                case HID_DG_CONFIDENCE:
 690                        if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
 691                                td->curvalid = value;
 692                        break;
 693                case HID_DG_CONTACTID:
 694                        td->curdata.contactid = value;
 695                        break;
 696                case HID_DG_TIPPRESSURE:
 697                        td->curdata.p = value;
 698                        break;
 699                case HID_GD_X:
 700                        if (usage->code == ABS_MT_TOOL_X)
 701                                td->curdata.cx = value;
 702                        else
 703                                td->curdata.x = value;
 704                        break;
 705                case HID_GD_Y:
 706                        if (usage->code == ABS_MT_TOOL_Y)
 707                                td->curdata.cy = value;
 708                        else
 709                                td->curdata.y = value;
 710                        break;
 711                case HID_DG_WIDTH:
 712                        td->curdata.w = value;
 713                        break;
 714                case HID_DG_HEIGHT:
 715                        td->curdata.h = value;
 716                        break;
 717                case HID_DG_CONTACTCOUNT:
 718                        break;
 719                case HID_DG_TOUCH:
 720                        /* do nothing */
 721                        break;
 722
 723                default:
 724                        if (usage->type)
 725                                input_event(input, usage->type, usage->code,
 726                                                value);
 727                        return;
 728                }
 729
 730                if (usage->usage_index + 1 == field->report_count) {
 731                        /* we only take into account the last report. */
 732                        if (usage->hid == td->last_slot_field)
 733                                mt_complete_slot(td, field->hidinput->input);
 734                }
 735
 736        }
 737}
 738
 739static void mt_touch_report(struct hid_device *hid, struct hid_report *report)
 740{
 741        struct mt_device *td = hid_get_drvdata(hid);
 742        struct hid_field *field;
 743        unsigned count;
 744        int r, n;
 745
 746        /*
 747         * Includes multi-packet support where subsequent
 748         * packets are sent with zero contactcount.
 749         */
 750        if (td->cc_index >= 0) {
 751                struct hid_field *field = report->field[td->cc_index];
 752                int value = field->value[td->cc_value_index];
 753                if (value)
 754                        td->num_expected = value;
 755        }
 756
 757        for (r = 0; r < report->maxfield; r++) {
 758                field = report->field[r];
 759                count = field->report_count;
 760
 761                if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
 762                        continue;
 763
 764                for (n = 0; n < count; n++)
 765                        mt_process_mt_event(hid, field, &field->usage[n],
 766                                        field->value[n]);
 767        }
 768
 769        if (td->num_received >= td->num_expected)
 770                mt_sync_frame(td, report->field[0]->hidinput->input);
 771}
 772
 773static void mt_touch_input_configured(struct hid_device *hdev,
 774                                        struct hid_input *hi)
 775{
 776        struct mt_device *td = hid_get_drvdata(hdev);
 777        struct mt_class *cls = &td->mtclass;
 778        struct input_dev *input = hi->input;
 779
 780        if (!td->maxcontacts)
 781                td->maxcontacts = MT_DEFAULT_MAXCONTACT;
 782
 783        mt_post_parse(td);
 784        if (td->serial_maybe)
 785                mt_post_parse_default_settings(td);
 786
 787        if (cls->is_indirect)
 788                td->mt_flags |= INPUT_MT_POINTER;
 789
 790        if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
 791                td->mt_flags |= INPUT_MT_DROP_UNUSED;
 792
 793        input_mt_init_slots(input, td->maxcontacts, td->mt_flags);
 794
 795        td->mt_flags = 0;
 796}
 797
 798static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 799                struct hid_field *field, struct hid_usage *usage,
 800                unsigned long **bit, int *max)
 801{
 802        /* Only map fields from TouchScreen or TouchPad collections.
 803        * We need to ignore fields that belong to other collections
 804        * such as Mouse that might have the same GenericDesktop usages. */
 805        if (field->application != HID_DG_TOUCHSCREEN &&
 806            field->application != HID_DG_PEN &&
 807            field->application != HID_DG_TOUCHPAD)
 808                return -1;
 809
 810        if (field->physical == HID_DG_STYLUS)
 811                return mt_pen_input_mapping(hdev, hi, field, usage, bit, max);
 812
 813        return mt_touch_input_mapping(hdev, hi, field, usage, bit, max);
 814}
 815
 816static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 817                struct hid_field *field, struct hid_usage *usage,
 818                unsigned long **bit, int *max)
 819{
 820        if (field->physical == HID_DG_STYLUS)
 821                return mt_pen_input_mapped(hdev, hi, field, usage, bit, max);
 822
 823        return mt_touch_input_mapped(hdev, hi, field, usage, bit, max);
 824}
 825
 826static int mt_event(struct hid_device *hid, struct hid_field *field,
 827                                struct hid_usage *usage, __s32 value)
 828{
 829        struct mt_device *td = hid_get_drvdata(hid);
 830
 831        if (field->report->id == td->mt_report_id)
 832                return mt_touch_event(hid, field, usage, value);
 833
 834        if (field->report->id == td->pen_report_id)
 835                return mt_pen_event(hid, field, usage, value);
 836
 837        /* ignore other reports */
 838        return 1;
 839}
 840
 841static void mt_report(struct hid_device *hid, struct hid_report *report)
 842{
 843        struct mt_device *td = hid_get_drvdata(hid);
 844
 845        if (!(hid->claimed & HID_CLAIMED_INPUT))
 846                return;
 847
 848        if (report->id == td->mt_report_id)
 849                mt_touch_report(hid, report);
 850
 851        if (report->id == td->pen_report_id)
 852                mt_pen_report(hid, report);
 853}
 854
 855static void mt_set_input_mode(struct hid_device *hdev)
 856{
 857        struct mt_device *td = hid_get_drvdata(hdev);
 858        struct hid_report *r;
 859        struct hid_report_enum *re;
 860
 861        if (td->inputmode < 0)
 862                return;
 863
 864        re = &(hdev->report_enum[HID_FEATURE_REPORT]);
 865        r = re->report_id_hash[td->inputmode];
 866        if (r) {
 867                r->field[0]->value[td->inputmode_index] = 0x02;
 868                hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
 869        }
 870}
 871
 872static void mt_set_maxcontacts(struct hid_device *hdev)
 873{
 874        struct mt_device *td = hid_get_drvdata(hdev);
 875        struct hid_report *r;
 876        struct hid_report_enum *re;
 877        int fieldmax, max;
 878
 879        if (td->maxcontact_report_id < 0)
 880                return;
 881
 882        if (!td->mtclass.maxcontacts)
 883                return;
 884
 885        re = &hdev->report_enum[HID_FEATURE_REPORT];
 886        r = re->report_id_hash[td->maxcontact_report_id];
 887        if (r) {
 888                max = td->mtclass.maxcontacts;
 889                fieldmax = r->field[0]->logical_maximum;
 890                max = min(fieldmax, max);
 891                if (r->field[0]->value[0] != max) {
 892                        r->field[0]->value[0] = max;
 893                        hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
 894                }
 895        }
 896}
 897
 898static void mt_post_parse_default_settings(struct mt_device *td)
 899{
 900        __s32 quirks = td->mtclass.quirks;
 901
 902        /* unknown serial device needs special quirks */
 903        if (td->touches_by_report == 1) {
 904                quirks |= MT_QUIRK_ALWAYS_VALID;
 905                quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP;
 906                quirks &= ~MT_QUIRK_VALID_IS_INRANGE;
 907                quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE;
 908                quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
 909        }
 910
 911        td->mtclass.quirks = quirks;
 912}
 913
 914static void mt_post_parse(struct mt_device *td)
 915{
 916        struct mt_fields *f = td->fields;
 917        struct mt_class *cls = &td->mtclass;
 918
 919        if (td->touches_by_report > 0) {
 920                int field_count_per_touch = f->length / td->touches_by_report;
 921                td->last_slot_field = f->usages[field_count_per_touch - 1];
 922        }
 923
 924        if (td->cc_index < 0)
 925                cls->quirks &= ~MT_QUIRK_CONTACT_CNT_ACCURATE;
 926}
 927
 928static void mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
 929{
 930        struct mt_device *td = hid_get_drvdata(hdev);
 931        char *name = kstrdup(hdev->name, GFP_KERNEL);
 932
 933        if (name)
 934                hi->input->name = name;
 935
 936        if (hi->report->id == td->mt_report_id)
 937                mt_touch_input_configured(hdev, hi);
 938
 939        if (hi->report->id == td->pen_report_id)
 940                mt_pen_input_configured(hdev, hi);
 941}
 942
 943static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
 944{
 945        int ret, i;
 946        struct mt_device *td;
 947        struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
 948        struct hid_input *hi;
 949
 950        for (i = 0; mt_classes[i].name ; i++) {
 951                if (id->driver_data == mt_classes[i].name) {
 952                        mtclass = &(mt_classes[i]);
 953                        break;
 954                }
 955        }
 956
 957        /* This allows the driver to correctly support devices
 958         * that emit events over several HID messages.
 959         */
 960        hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
 961
 962        /*
 963         * This allows the driver to handle different input sensors
 964         * that emits events through different reports on the same HID
 965         * device.
 966         */
 967        hdev->quirks |= HID_QUIRK_MULTI_INPUT;
 968        hdev->quirks |= HID_QUIRK_NO_EMPTY_INPUT;
 969
 970        td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
 971        if (!td) {
 972                dev_err(&hdev->dev, "cannot allocate multitouch data\n");
 973                return -ENOMEM;
 974        }
 975        td->mtclass = *mtclass;
 976        td->inputmode = -1;
 977        td->maxcontact_report_id = -1;
 978        td->cc_index = -1;
 979        td->mt_report_id = -1;
 980        td->pen_report_id = -1;
 981        hid_set_drvdata(hdev, td);
 982
 983        td->fields = kzalloc(sizeof(struct mt_fields), GFP_KERNEL);
 984        if (!td->fields) {
 985                dev_err(&hdev->dev, "cannot allocate multitouch fields data\n");
 986                ret = -ENOMEM;
 987                goto fail;
 988        }
 989
 990        if (id->vendor == HID_ANY_ID && id->product == HID_ANY_ID)
 991                td->serial_maybe = true;
 992
 993        ret = hid_parse(hdev);
 994        if (ret != 0)
 995                goto fail;
 996
 997        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 998        if (ret)
 999                goto hid_fail;
1000
1001        ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
1002
1003        mt_set_maxcontacts(hdev);
1004        mt_set_input_mode(hdev);
1005
1006        kfree(td->fields);
1007        td->fields = NULL;
1008
1009        return 0;
1010
1011hid_fail:
1012        list_for_each_entry(hi, &hdev->inputs, list)
1013                mt_free_input_name(hi);
1014fail:
1015        kfree(td->fields);
1016        kfree(td);
1017        return ret;
1018}
1019
1020#ifdef CONFIG_PM
1021static int mt_reset_resume(struct hid_device *hdev)
1022{
1023        mt_set_maxcontacts(hdev);
1024        mt_set_input_mode(hdev);
1025        return 0;
1026}
1027
1028static int mt_resume(struct hid_device *hdev)
1029{
1030        /* Some Elan legacy devices require SET_IDLE to be set on resume.
1031         * It should be safe to send it to other devices too.
1032         * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */
1033
1034        hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE);
1035
1036        return 0;
1037}
1038#endif
1039
1040static void mt_remove(struct hid_device *hdev)
1041{
1042        struct mt_device *td = hid_get_drvdata(hdev);
1043        struct hid_input *hi;
1044
1045        sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
1046        list_for_each_entry(hi, &hdev->inputs, list)
1047                mt_free_input_name(hi);
1048
1049        hid_hw_stop(hdev);
1050
1051        kfree(td);
1052        hid_set_drvdata(hdev, NULL);
1053}
1054
1055static const struct hid_device_id mt_devices[] = {
1056
1057        /* 3M panels */
1058        { .driver_data = MT_CLS_3M,
1059                MT_USB_DEVICE(USB_VENDOR_ID_3M,
1060                        USB_DEVICE_ID_3M1968) },
1061        { .driver_data = MT_CLS_3M,
1062                MT_USB_DEVICE(USB_VENDOR_ID_3M,
1063                        USB_DEVICE_ID_3M2256) },
1064        { .driver_data = MT_CLS_3M,
1065                MT_USB_DEVICE(USB_VENDOR_ID_3M,
1066                        USB_DEVICE_ID_3M3266) },
1067
1068        /* ActionStar panels */
1069        { .driver_data = MT_CLS_NSMU,
1070                MT_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
1071                        USB_DEVICE_ID_ACTIONSTAR_1011) },
1072
1073        /* Atmel panels */
1074        { .driver_data = MT_CLS_SERIAL,
1075                MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
1076                        USB_DEVICE_ID_ATMEL_MULTITOUCH) },
1077        { .driver_data = MT_CLS_SERIAL,
1078                MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
1079                        USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
1080
1081        /* Baanto multitouch devices */
1082        { .driver_data = MT_CLS_NSMU,
1083                MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
1084                        USB_DEVICE_ID_BAANTO_MT_190W2) },
1085        /* Cando panels */
1086        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1087                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1088                        USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
1089        { .driver_data = MT_CLS_DUAL_CONTACT_NUMBER,
1090                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1091                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
1092        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1093                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1094                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
1095        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1096                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1097                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
1098
1099        /* Chunghwa Telecom touch panels */
1100        {  .driver_data = MT_CLS_NSMU,
1101                MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
1102                        USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
1103
1104        /* CVTouch panels */
1105        { .driver_data = MT_CLS_NSMU,
1106                MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
1107                        USB_DEVICE_ID_CVTOUCH_SCREEN) },
1108
1109        /* Cypress panel */
1110        { .driver_data = MT_CLS_CYPRESS,
1111                HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
1112                        USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
1113
1114        /* Data Modul easyMaxTouch */
1115        { .driver_data = MT_CLS_DEFAULT,
1116                MT_USB_DEVICE(USB_VENDOR_ID_DATA_MODUL,
1117                        USB_VENDOR_ID_DATA_MODUL_EASYMAXTOUCH) },
1118
1119        /* eGalax devices (resistive) */
1120        { .driver_data = MT_CLS_EGALAX,
1121                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1122                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
1123        { .driver_data = MT_CLS_EGALAX,
1124                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1125                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
1126
1127        /* eGalax devices (capacitive) */
1128        { .driver_data = MT_CLS_EGALAX_SERIAL,
1129                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1130                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
1131        { .driver_data = MT_CLS_EGALAX,
1132                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1133                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
1134        { .driver_data = MT_CLS_EGALAX_SERIAL,
1135                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1136                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
1137        { .driver_data = MT_CLS_EGALAX_SERIAL,
1138                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1139                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
1140        { .driver_data = MT_CLS_EGALAX_SERIAL,
1141                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1142                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
1143        { .driver_data = MT_CLS_EGALAX_SERIAL,
1144                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1145                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
1146        { .driver_data = MT_CLS_EGALAX,
1147                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1148                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
1149        { .driver_data = MT_CLS_EGALAX,
1150                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1151                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
1152        { .driver_data = MT_CLS_EGALAX_SERIAL,
1153                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1154                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
1155        { .driver_data = MT_CLS_EGALAX,
1156                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1157                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
1158        { .driver_data = MT_CLS_EGALAX,
1159                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
1160                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
1161        { .driver_data = MT_CLS_EGALAX,
1162                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1163                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
1164        { .driver_data = MT_CLS_EGALAX,
1165                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1166                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
1167        { .driver_data = MT_CLS_EGALAX_SERIAL,
1168                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1169                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349) },
1170        { .driver_data = MT_CLS_EGALAX_SERIAL,
1171                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1172                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7) },
1173        { .driver_data = MT_CLS_EGALAX_SERIAL,
1174                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1175                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
1176
1177        /* Elo TouchSystems IntelliTouch Plus panel */
1178        { .driver_data = MT_CLS_DUAL_CONTACT_ID,
1179                MT_USB_DEVICE(USB_VENDOR_ID_ELO,
1180                        USB_DEVICE_ID_ELO_TS2515) },
1181
1182        /* Flatfrog Panels */
1183        { .driver_data = MT_CLS_FLATFROG,
1184                MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG,
1185                        USB_DEVICE_ID_MULTITOUCH_3200) },
1186
1187        /* GeneralTouch panel */
1188        { .driver_data = MT_CLS_GENERALTOUCH_TWOFINGERS,
1189                MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1190                        USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
1191        { .driver_data = MT_CLS_GENERALTOUCH_PWT_TENFINGERS,
1192                MT_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
1193                        USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS) },
1194
1195        /* Gametel game controller */
1196        { .driver_data = MT_CLS_NSMU,
1197                MT_BT_DEVICE(USB_VENDOR_ID_FRUCTEL,
1198                        USB_DEVICE_ID_GAMETEL_MT_MODE) },
1199
1200        /* GoodTouch panels */
1201        { .driver_data = MT_CLS_NSMU,
1202                MT_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
1203                        USB_DEVICE_ID_GOODTOUCH_000f) },
1204
1205        /* Hanvon panels */
1206        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1207                MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
1208                        USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
1209
1210        /* Ideacom panel */
1211        { .driver_data = MT_CLS_SERIAL,
1212                MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
1213                        USB_DEVICE_ID_IDEACOM_IDC6650) },
1214        { .driver_data = MT_CLS_SERIAL,
1215                MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
1216                        USB_DEVICE_ID_IDEACOM_IDC6651) },
1217
1218        /* Ilitek dual touch panel */
1219        {  .driver_data = MT_CLS_NSMU,
1220                MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
1221                        USB_DEVICE_ID_ILITEK_MULTITOUCH) },
1222
1223        /* IRTOUCH panels */
1224        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1225                MT_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
1226                        USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
1227
1228        /* LG Display panels */
1229        { .driver_data = MT_CLS_DEFAULT,
1230                MT_USB_DEVICE(USB_VENDOR_ID_LG,
1231                        USB_DEVICE_ID_LG_MULTITOUCH) },
1232
1233        /* Lumio panels */
1234        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1235                MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
1236                        USB_DEVICE_ID_CRYSTALTOUCH) },
1237        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1238                MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
1239                        USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
1240
1241        /* MosArt panels */
1242        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1243                MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
1244                        USB_DEVICE_ID_ASUS_T91MT)},
1245        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1246                MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
1247                        USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
1248        { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1249                MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
1250                        USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
1251
1252        /* Nexio panels */
1253        { .driver_data = MT_CLS_DEFAULT,
1254                MT_USB_DEVICE(USB_VENDOR_ID_NEXIO,
1255                        USB_DEVICE_ID_NEXIO_MULTITOUCH_420)},
1256
1257        /* Panasonic panels */
1258        { .driver_data = MT_CLS_PANASONIC,
1259                MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
1260                        USB_DEVICE_ID_PANABOARD_UBT780) },
1261        { .driver_data = MT_CLS_PANASONIC,
1262                MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
1263                        USB_DEVICE_ID_PANABOARD_UBT880) },
1264
1265        /* Novatek Panel */
1266        { .driver_data = MT_CLS_NSMU,
1267                MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
1268                        USB_DEVICE_ID_NOVATEK_PCT) },
1269
1270        /* PenMount panels */
1271        { .driver_data = MT_CLS_CONFIDENCE,
1272                MT_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
1273                        USB_DEVICE_ID_PENMOUNT_PCI) },
1274
1275        /* PixArt optical touch screen */
1276        { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1277                MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1278                        USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
1279        { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1280                MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1281                        USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
1282        { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1283                MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
1284                        USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
1285
1286        /* PixCir-based panels */
1287        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1288                MT_USB_DEVICE(USB_VENDOR_ID_HANVON,
1289                        USB_DEVICE_ID_HANVON_MULTITOUCH) },
1290        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1291                MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1292                        USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
1293
1294        /* Quanta-based panels */
1295        { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1296                MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1297                        USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
1298        { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1299                MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1300                        USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
1301        { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1302                MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1303                        USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) },
1304
1305        /* Stantum panels */
1306        { .driver_data = MT_CLS_CONFIDENCE,
1307                MT_USB_DEVICE(USB_VENDOR_ID_STANTUM,
1308                        USB_DEVICE_ID_MTP)},
1309        { .driver_data = MT_CLS_CONFIDENCE,
1310                MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
1311                        USB_DEVICE_ID_MTP_STM)},
1312        { .driver_data = MT_CLS_DEFAULT,
1313                MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX,
1314                        USB_DEVICE_ID_MTP_SITRONIX)},
1315
1316        /* TopSeed panels */
1317        { .driver_data = MT_CLS_TOPSEED,
1318                MT_USB_DEVICE(USB_VENDOR_ID_TOPSEED2,
1319                        USB_DEVICE_ID_TOPSEED2_PERIPAD_701) },
1320
1321        /* Touch International panels */
1322        { .driver_data = MT_CLS_NSMU,
1323                MT_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
1324                        USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
1325
1326        /* Unitec panels */
1327        { .driver_data = MT_CLS_NSMU,
1328                MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
1329                        USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
1330        { .driver_data = MT_CLS_NSMU,
1331                MT_USB_DEVICE(USB_VENDOR_ID_UNITEC,
1332                        USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
1333        /* XAT */
1334        { .driver_data = MT_CLS_NSMU,
1335                MT_USB_DEVICE(USB_VENDOR_ID_XAT,
1336                        USB_DEVICE_ID_XAT_CSR) },
1337
1338        /* Xiroku */
1339        { .driver_data = MT_CLS_NSMU,
1340                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1341                        USB_DEVICE_ID_XIROKU_SPX) },
1342        { .driver_data = MT_CLS_NSMU,
1343                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1344                        USB_DEVICE_ID_XIROKU_MPX) },
1345        { .driver_data = MT_CLS_NSMU,
1346                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1347                        USB_DEVICE_ID_XIROKU_CSR) },
1348        { .driver_data = MT_CLS_NSMU,
1349                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1350                        USB_DEVICE_ID_XIROKU_SPX1) },
1351        { .driver_data = MT_CLS_NSMU,
1352                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1353                        USB_DEVICE_ID_XIROKU_MPX1) },
1354        { .driver_data = MT_CLS_NSMU,
1355                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1356                        USB_DEVICE_ID_XIROKU_CSR1) },
1357        { .driver_data = MT_CLS_NSMU,
1358                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1359                        USB_DEVICE_ID_XIROKU_SPX2) },
1360        { .driver_data = MT_CLS_NSMU,
1361                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1362                        USB_DEVICE_ID_XIROKU_MPX2) },
1363        { .driver_data = MT_CLS_NSMU,
1364                MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1365                        USB_DEVICE_ID_XIROKU_CSR2) },
1366
1367        /* Zytronic panels */
1368        { .driver_data = MT_CLS_SERIAL,
1369                MT_USB_DEVICE(USB_VENDOR_ID_ZYTRONIC,
1370                        USB_DEVICE_ID_ZYTRONIC_ZXY100) },
1371
1372        /* Generic MT device */
1373        { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
1374        { }
1375};
1376MODULE_DEVICE_TABLE(hid, mt_devices);
1377
1378static const struct hid_usage_id mt_grabbed_usages[] = {
1379        { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
1380        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
1381};
1382
1383static struct hid_driver mt_driver = {
1384        .name = "hid-multitouch",
1385        .id_table = mt_devices,
1386        .probe = mt_probe,
1387        .remove = mt_remove,
1388        .input_mapping = mt_input_mapping,
1389        .input_mapped = mt_input_mapped,
1390        .input_configured = mt_input_configured,
1391        .feature_mapping = mt_feature_mapping,
1392        .usage_table = mt_grabbed_usages,
1393        .event = mt_event,
1394        .report = mt_report,
1395#ifdef CONFIG_PM
1396        .reset_resume = mt_reset_resume,
1397        .resume = mt_resume,
1398#endif
1399};
1400module_hid_driver(mt_driver);
1401
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.