drivers/hid/hid-multitouch.c

   1 /*
   2  *  HID driver for multitouch panels
   3  *
   4  *  Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
   5  *  Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
   6  *  Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
   7  *
   8  *  This code is partly based on hid-egalax.c:
   9  *
  10  *  Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
  11  *  Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
  12  *  Copyright (c) 2010 Canonical, Ltd.
  13  *
  14  *  This code is partly based on hid-3m-pct.c:
  15  *
  16  *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
  17  *  Copyright (c) 2010      Henrik Rydberg <rydberg@euromail.se>
  18  *  Copyright (c) 2010      Canonical, Ltd.
  19  *
  20  */
  21
  22 /*
  23  * This program is free software; you can redistribute it and/or modify it
  24  * under the terms of the GNU General Public License as published by the Free
  25  * Software Foundation; either version 2 of the License, or (at your option)
  26  * any later version.
  27  */
  28
  29 #include <linux/device.h>
  30 #include <linux/hid.h>
  31 #include <linux/module.h>
  32 #include <linux/slab.h>
  33 #include <linux/usb.h>
  34 #include <linux/input/mt.h>
  35 #include "usbhid/usbhid.h"
  36
  37
  38 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
  39 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
  40 MODULE_DESCRIPTION("HID multitouch panels");
  41 MODULE_LICENSE("GPL");
  42
  43 #include "hid-ids.h"
  44
  45 /* quirks to control the device */
  46 #define MT_QUIRK_NOT_SEEN_MEANS_UP      (1 << 0)
  47 #define MT_QUIRK_SLOT_IS_CONTACTID      (1 << 1)
  48 #define MT_QUIRK_CYPRESS                (1 << 2)
  49 #define MT_QUIRK_SLOT_IS_CONTACTNUMBER  (1 << 3)
  50 #define MT_QUIRK_ALWAYS_VALID           (1 << 4)
  51 #define MT_QUIRK_VALID_IS_INRANGE       (1 << 5)
  52 #define MT_QUIRK_VALID_IS_CONFIDENCE    (1 << 6)
  53 #define MT_QUIRK_EGALAX_XYZ_FIXUP       (1 << 7)
  54 #define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE    (1 << 8)
  55
  56 struct mt_slot {
  57         __s32 x, y, p, w, h;
  58         __s32 contactid;        /* the device ContactID assigned to this slot */
  59         bool touch_state;       /* is the touch valid? */
  60         bool seen_in_this_frame;/* has this slot been updated */
  61 };
  62
  63 struct mt_class {
  64         __s32 name;     /* MT_CLS */
  65         __s32 quirks;
  66         __s32 sn_move;  /* Signal/noise ratio for move events */
  67         __s32 sn_width; /* Signal/noise ratio for width events */
  68         __s32 sn_height;        /* Signal/noise ratio for height events */
  69         __s32 sn_pressure;      /* Signal/noise ratio for pressure events */
  70         __u8 maxcontacts;
  71 };
  72
  73 struct mt_device {
  74         struct mt_slot curdata; /* placeholder of incoming data */
  75         struct mt_class mtclass;        /* our mt device class */
  76         unsigned last_field_index;      /* last field index of the report */
  77         unsigned last_slot_field;       /* the last field of a slot */
  78         int last_mt_collection; /* last known mt-related collection */
  79         __s8 inputmode;         /* InputMode HID feature, -1 if non-existent */
  80         __u8 num_received;      /* how many contacts we received */
  81         __u8 num_expected;      /* expected last contact index */
  82         __u8 maxcontacts;
  83         bool curvalid;          /* is the current contact valid? */
  84         struct mt_slot *slots;
  85 };
  86
  87 /* classes of device behavior */
  88 #define MT_CLS_DEFAULT                          0x0001
  89
  90 #define MT_CLS_SERIAL                           0x0002
  91 #define MT_CLS_CONFIDENCE                       0x0003
  92 #define MT_CLS_CONFIDENCE_MINUS_ONE             0x0004
  93 #define MT_CLS_DUAL_INRANGE_CONTACTID           0x0005
  94 #define MT_CLS_DUAL_INRANGE_CONTACTNUMBER       0x0006
  95 #define MT_CLS_DUAL_NSMU_CONTACTID              0x0007
  96
  97 /* vendor specific classes */
  98 #define MT_CLS_3M                               0x0101
  99 #define MT_CLS_CYPRESS                          0x0102
 100 #define MT_CLS_EGALAX                           0x0103
 101
 102 #define MT_DEFAULT_MAXCONTACT   10
 103
 104 /*
 105  * these device-dependent functions determine what slot corresponds
 106  * to a valid contact that was just read.
 107  */
 108
 109 static int cypress_compute_slot(struct mt_device *td)
 110 {
 111         if (td->curdata.contactid != 0 || td->num_received == 0)
 112                 return td->curdata.contactid;
 113         else
 114                 return -1;
 115 }
 116
 117 static int find_slot_from_contactid(struct mt_device *td)
 118 {
 119         int i;
 120         for (i = 0; i < td->maxcontacts; ++i) {
 121                 if (td->slots[i].contactid == td->curdata.contactid &&
 122                         td->slots[i].touch_state)
 123                         return i;
 124         }
 125         for (i = 0; i < td->maxcontacts; ++i) {
 126                 if (!td->slots[i].seen_in_this_frame &&
 127                         !td->slots[i].touch_state)
 128                         return i;
 129         }
 130         /* should not occurs. If this happens that means
 131          * that the device sent more touches that it says
 132          * in the report descriptor. It is ignored then. */
 133         return -1;
 134 }
 135
 136 struct mt_class mt_classes[] = {
 137         { .name = MT_CLS_DEFAULT,
 138                 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
 139         { .name = MT_CLS_SERIAL,
 140                 .quirks = MT_QUIRK_ALWAYS_VALID},
 141         { .name = MT_CLS_CONFIDENCE,
 142                 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
 143         { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
 144                 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 145                         MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
 146         { .name = MT_CLS_DUAL_INRANGE_CONTACTID,
 147                 .quirks = MT_QUIRK_VALID_IS_INRANGE |
 148                         MT_QUIRK_SLOT_IS_CONTACTID,
 149                 .maxcontacts = 2 },
 150         { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 151                 .quirks = MT_QUIRK_VALID_IS_INRANGE |
 152                         MT_QUIRK_SLOT_IS_CONTACTNUMBER,
 153                 .maxcontacts = 2 },
 154         { .name = MT_CLS_DUAL_NSMU_CONTACTID,
 155                 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 156                         MT_QUIRK_SLOT_IS_CONTACTID,
 157                 .maxcontacts = 2 },
 158
 159         /*
 160          * vendor specific classes
 161          */
 162         { .name = MT_CLS_3M,
 163                 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
 164                         MT_QUIRK_SLOT_IS_CONTACTID,
 165                 .sn_move = 2048,
 166                 .sn_width = 128,
 167                 .sn_height = 128 },
 168         { .name = MT_CLS_CYPRESS,
 169                 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
 170                         MT_QUIRK_CYPRESS,
 171                 .maxcontacts = 10 },
 172         { .name = MT_CLS_EGALAX,
 173                 .quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
 174                         MT_QUIRK_VALID_IS_INRANGE |
 175                         MT_QUIRK_EGALAX_XYZ_FIXUP,
 176                 .maxcontacts = 2,
 177                 .sn_move = 4096,
 178                 .sn_pressure = 32,
 179         },
 180
 181         { }
 182 };
 183
 184 static ssize_t mt_show_quirks(struct device *dev,
 185                            struct device_attribute *attr,
 186                            char *buf)
 187 {
 188         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 189         struct mt_device *td = hid_get_drvdata(hdev);
 190
 191         return sprintf(buf, "%u\n", td->mtclass.quirks);
 192 }
 193
 194 static ssize_t mt_set_quirks(struct device *dev,
 195                           struct device_attribute *attr,
 196                           const char *buf, size_t count)
 197 {
 198         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 199         struct mt_device *td = hid_get_drvdata(hdev);
 200
 201         unsigned long val;
 202
 203         if (strict_strtoul(buf, 0, &val))
 204                 return -EINVAL;
 205
 206         td->mtclass.quirks = val;
 207
 208         return count;
 209 }
 210
 211 static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
 212
 213 static struct attribute *sysfs_attrs[] = {
 214         &dev_attr_quirks.attr,
 215         NULL
 216 };
 217
 218 static struct attribute_group mt_attribute_group = {
 219         .attrs = sysfs_attrs
 220 };
 221
 222 static void mt_feature_mapping(struct hid_device *hdev,
 223                 struct hid_field *field, struct hid_usage *usage)
 224 {
 225         struct mt_device *td = hid_get_drvdata(hdev);
 226
 227         switch (usage->hid) {
 228         case HID_DG_INPUTMODE:
 229                 td->inputmode = field->report->id;
 230                 break;
 231         case HID_DG_CONTACTMAX:
 232                 td->maxcontacts = field->value[0];
 233                 if (td->mtclass.maxcontacts)
 234                         /* check if the maxcontacts is given by the class */
 235                         td->maxcontacts = td->mtclass.maxcontacts;
 236
 237                 break;
 238         }
 239 }
 240
 241 static void set_abs(struct input_dev *input, unsigned int code,
 242                 struct hid_field *field, int snratio)
 243 {
 244         int fmin = field->logical_minimum;
 245         int fmax = field->logical_maximum;
 246         int fuzz = snratio ? (fmax - fmin) / snratio : 0;
 247         input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
 248 }
 249
 250 static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 251                 struct hid_field *field, struct hid_usage *usage,
 252                 unsigned long **bit, int *max)
 253 {
 254         struct mt_device *td = hid_get_drvdata(hdev);
 255         struct mt_class *cls = &td->mtclass;
 256         __s32 quirks = cls->quirks;
 257
 258         /* Only map fields from TouchScreen or TouchPad collections.
 259          * We need to ignore fields that belong to other collections
 260          * such as Mouse that might have the same GenericDesktop usages. */
 261         if (field->application == HID_DG_TOUCHSCREEN)
 262                 set_bit(INPUT_PROP_DIRECT, hi->input->propbit);
 263         else if (field->application == HID_DG_TOUCHPAD)
 264                 set_bit(INPUT_PROP_POINTER, hi->input->propbit);
 265         else
 266                 return 0;
 267
 268         switch (usage->hid & HID_USAGE_PAGE) {
 269
 270         case HID_UP_GENDESK:
 271                 switch (usage->hid) {
 272                 case HID_GD_X:
 273                         if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
 274                                 field->logical_maximum = 32760;
 275                         hid_map_usage(hi, usage, bit, max,
 276                                         EV_ABS, ABS_MT_POSITION_X);
 277                         set_abs(hi->input, ABS_MT_POSITION_X, field,
 278                                 cls->sn_move);
 279                         /* touchscreen emulation */
 280                         set_abs(hi->input, ABS_X, field, cls->sn_move);
 281                         if (td->last_mt_collection == usage->collection_index) {
 282                                 td->last_slot_field = usage->hid;
 283                                 td->last_field_index = field->index;
 284                         }
 285                         return 1;
 286                 case HID_GD_Y:
 287                         if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
 288                                 field->logical_maximum = 32760;
 289                         hid_map_usage(hi, usage, bit, max,
 290                                         EV_ABS, ABS_MT_POSITION_Y);
 291                         set_abs(hi->input, ABS_MT_POSITION_Y, field,
 292                                 cls->sn_move);
 293                         /* touchscreen emulation */
 294                         set_abs(hi->input, ABS_Y, field, cls->sn_move);
 295                         if (td->last_mt_collection == usage->collection_index) {
 296                                 td->last_slot_field = usage->hid;
 297                                 td->last_field_index = field->index;
 298                         }
 299                         return 1;
 300                 }
 301                 return 0;
 302
 303         case HID_UP_DIGITIZER:
 304                 switch (usage->hid) {
 305                 case HID_DG_INRANGE:
 306                         if (td->last_mt_collection == usage->collection_index) {
 307                                 td->last_slot_field = usage->hid;
 308                                 td->last_field_index = field->index;
 309                         }
 310                         return 1;
 311                 case HID_DG_CONFIDENCE:
 312                         if (td->last_mt_collection == usage->collection_index) {
 313                                 td->last_slot_field = usage->hid;
 314                                 td->last_field_index = field->index;
 315                         }
 316                         return 1;
 317                 case HID_DG_TIPSWITCH:
 318                         hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
 319                         input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
 320                         if (td->last_mt_collection == usage->collection_index) {
 321                                 td->last_slot_field = usage->hid;
 322                                 td->last_field_index = field->index;
 323                         }
 324                         return 1;
 325                 case HID_DG_CONTACTID:
 326                         if (!td->maxcontacts)
 327                                 td->maxcontacts = MT_DEFAULT_MAXCONTACT;
 328                         input_mt_init_slots(hi->input, td->maxcontacts);
 329                         td->last_slot_field = usage->hid;
 330                         td->last_field_index = field->index;
 331                         td->last_mt_collection = usage->collection_index;
 332                         return 1;
 333                 case HID_DG_WIDTH:
 334                         hid_map_usage(hi, usage, bit, max,
 335                                         EV_ABS, ABS_MT_TOUCH_MAJOR);
 336                         set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
 337                                 cls->sn_width);
 338                         if (td->last_mt_collection == usage->collection_index) {
 339                                 td->last_slot_field = usage->hid;
 340                                 td->last_field_index = field->index;
 341                         }
 342                         return 1;
 343                 case HID_DG_HEIGHT:
 344                         hid_map_usage(hi, usage, bit, max,
 345                                         EV_ABS, ABS_MT_TOUCH_MINOR);
 346                         set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
 347                                 cls->sn_height);
 348                         input_set_abs_params(hi->input,
 349                                         ABS_MT_ORIENTATION, 0, 1, 0, 0);
 350                         if (td->last_mt_collection == usage->collection_index) {
 351                                 td->last_slot_field = usage->hid;
 352                                 td->last_field_index = field->index;
 353                         }
 354                         return 1;
 355                 case HID_DG_TIPPRESSURE:
 356                         if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
 357                                 field->logical_minimum = 0;
 358                         hid_map_usage(hi, usage, bit, max,
 359                                         EV_ABS, ABS_MT_PRESSURE);
 360                         set_abs(hi->input, ABS_MT_PRESSURE, field,
 361                                 cls->sn_pressure);
 362                         /* touchscreen emulation */
 363                         set_abs(hi->input, ABS_PRESSURE, field,
 364                                 cls->sn_pressure);
 365                         if (td->last_mt_collection == usage->collection_index) {
 366                                 td->last_slot_field = usage->hid;
 367                                 td->last_field_index = field->index;
 368                         }
 369                         return 1;
 370                 case HID_DG_CONTACTCOUNT:
 371                         if (td->last_mt_collection == usage->collection_index)
 372                                 td->last_field_index = field->index;
 373                         return 1;
 374                 case HID_DG_CONTACTMAX:
 375                         /* we don't set td->last_slot_field as contactcount and
 376                          * contact max are global to the report */
 377                         if (td->last_mt_collection == usage->collection_index)
 378                                 td->last_field_index = field->index;
 379                         return -1;
 380                 }
 381                 /* let hid-input decide for the others */
 382                 return 0;
 383
 384         case 0xff000000:
 385                 /* we do not want to map these: no input-oriented meaning */
 386                 return -1;
 387         }
 388
 389         return 0;
 390 }
 391
 392 static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 393                 struct hid_field *field, struct hid_usage *usage,
 394                 unsigned long **bit, int *max)
 395 {
 396         if (usage->type == EV_KEY || usage->type == EV_ABS)
 397                 set_bit(usage->type, hi->input->evbit);
 398
 399         return -1;
 400 }
 401
 402 static int mt_compute_slot(struct mt_device *td)
 403 {
 404         __s32 quirks = td->mtclass.quirks;
 405
 406         if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
 407                 return td->curdata.contactid;
 408
 409         if (quirks & MT_QUIRK_CYPRESS)
 410                 return cypress_compute_slot(td);
 411
 412         if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
 413                 return td->num_received;
 414
 415         if (quirks & MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE)
 416                 return td->curdata.contactid - 1;
 417
 418         return find_slot_from_contactid(td);
 419 }
 420
 421 /*
 422  * this function is called when a whole contact has been processed,
 423  * so that it can assign it to a slot and store the data there
 424  */
 425 static void mt_complete_slot(struct mt_device *td)
 426 {
 427         td->curdata.seen_in_this_frame = true;
 428         if (td->curvalid) {
 429                 int slotnum = mt_compute_slot(td);
 430
 431                 if (slotnum >= 0 && slotnum < td->maxcontacts)
 432                         td->slots[slotnum] = td->curdata;
 433         }
 434         td->num_received++;
 435 }
 436
 437
 438 /*
 439  * this function is called when a whole packet has been received and processed,
 440  * so that it can decide what to send to the input layer.
 441  */
 442 static void mt_emit_event(struct mt_device *td, struct input_dev *input)
 443 {
 444         int i;
 445
 446         for (i = 0; i < td->maxcontacts; ++i) {
 447                 struct mt_slot *s = &(td->slots[i]);
 448                 if ((td->mtclass.quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
 449                         !s->seen_in_this_frame) {
 450                         s->touch_state = false;
 451                 }
 452
 453                 input_mt_slot(input, i);
 454                 input_mt_report_slot_state(input, MT_TOOL_FINGER,
 455                         s->touch_state);
 456                 if (s->touch_state) {
 457                         /* this finger is on the screen */
 458                         int wide = (s->w > s->h);
 459                         /* divided by two to match visual scale of touch */
 460                         int major = max(s->w, s->h) >> 1;
 461                         int minor = min(s->w, s->h) >> 1;
 462
 463                         input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
 464                         input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
 465                         input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
 466                         input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
 467                         input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
 468                         input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
 469                 }
 470                 s->seen_in_this_frame = false;
 471
 472         }
 473
 474         input_mt_report_pointer_emulation(input, true);
 475         input_sync(input);
 476         td->num_received = 0;
 477 }
 478
 479
 480
 481 static int mt_event(struct hid_device *hid, struct hid_field *field,
 482                                 struct hid_usage *usage, __s32 value)
 483 {
 484         struct mt_device *td = hid_get_drvdata(hid);
 485         __s32 quirks = td->mtclass.quirks;
 486
 487         if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
 488                 switch (usage->hid) {
 489                 case HID_DG_INRANGE:
 490                         if (quirks & MT_QUIRK_ALWAYS_VALID)
 491                                 td->curvalid = true;
 492                         else if (quirks & MT_QUIRK_VALID_IS_INRANGE)
 493                                 td->curvalid = value;
 494                         break;
 495                 case HID_DG_TIPSWITCH:
 496                         if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
 497                                 td->curvalid = value;
 498                         td->curdata.touch_state = value;
 499                         break;
 500                 case HID_DG_CONFIDENCE:
 501                         if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
 502                                 td->curvalid = value;
 503                         break;
 504                 case HID_DG_CONTACTID:
 505                         td->curdata.contactid = value;
 506                         break;
 507                 case HID_DG_TIPPRESSURE:
 508                         td->curdata.p = value;
 509                         break;
 510                 case HID_GD_X:
 511                         td->curdata.x = value;
 512                         break;
 513                 case HID_GD_Y:
 514                         td->curdata.y = value;
 515                         break;
 516                 case HID_DG_WIDTH:
 517                         td->curdata.w = value;
 518                         break;
 519                 case HID_DG_HEIGHT:
 520                         td->curdata.h = value;
 521                         break;
 522                 case HID_DG_CONTACTCOUNT:
 523                         /*
 524                          * Includes multi-packet support where subsequent
 525                          * packets are sent with zero contactcount.
 526                          */
 527                         if (value)
 528                                 td->num_expected = value;
 529                         break;
 530
 531                 default:
 532                         /* fallback to the generic hidinput handling */
 533                         return 0;
 534                 }
 535
 536                 if (usage->hid == td->last_slot_field) {
 537                         mt_complete_slot(td);
 538                 }
 539
 540                 if (field->index == td->last_field_index
 541                         && td->num_received >= td->num_expected)
 542                         mt_emit_event(td, field->hidinput->input);
 543
 544         }
 545
 546         /* we have handled the hidinput part, now remains hiddev */
 547         if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
 548                 hid->hiddev_hid_event(hid, field, usage, value);
 549
 550         return 1;
 551 }
 552
 553 static void mt_set_input_mode(struct hid_device *hdev)
 554 {
 555         struct mt_device *td = hid_get_drvdata(hdev);
 556         struct hid_report *r;
 557         struct hid_report_enum *re;
 558
 559         if (td->inputmode < 0)
 560                 return;
 561
 562         re = &(hdev->report_enum[HID_FEATURE_REPORT]);
 563         r = re->report_id_hash[td->inputmode];
 564         if (r) {
 565                 r->field[0]->value[0] = 0x02;
 566                 usbhid_submit_report(hdev, r, USB_DIR_OUT);
 567         }
 568 }
 569
 570 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
 571 {
 572         int ret, i;
 573         struct mt_device *td;
 574         struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
 575
 576         for (i = 0; mt_classes[i].name ; i++) {
 577                 if (id->driver_data == mt_classes[i].name) {
 578                         mtclass = &(mt_classes[i]);
 579                         break;
 580                 }
 581         }
 582
 583         /* This allows the driver to correctly support devices
 584          * that emit events over several HID messages.
 585          */
 586         hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
 587
 588         td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
 589         if (!td) {
 590                 dev_err(&hdev->dev, "cannot allocate multitouch data\n");
 591                 return -ENOMEM;
 592         }
 593         td->mtclass = *mtclass;
 594         td->inputmode = -1;
 595         td->last_mt_collection = -1;
 596         hid_set_drvdata(hdev, td);
 597
 598         ret = hid_parse(hdev);
 599         if (ret != 0)
 600                 goto fail;
 601
 602         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 603         if (ret)
 604                 goto fail;
 605
 606         td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
 607                                 GFP_KERNEL);
 608         if (!td->slots) {
 609                 dev_err(&hdev->dev, "cannot allocate multitouch slots\n");
 610                 hid_hw_stop(hdev);
 611                 ret = -ENOMEM;
 612                 goto fail;
 613         }
 614
 615         ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
 616
 617         mt_set_input_mode(hdev);
 618
 619         return 0;
 620
 621 fail:
 622         kfree(td);
 623         return ret;
 624 }
 625
 626 #ifdef CONFIG_PM
 627 static int mt_reset_resume(struct hid_device *hdev)
 628 {
 629         mt_set_input_mode(hdev);
 630         return 0;
 631 }
 632 #endif
 633
 634 static void mt_remove(struct hid_device *hdev)
 635 {
 636         struct mt_device *td = hid_get_drvdata(hdev);
 637         sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
 638         hid_hw_stop(hdev);
 639         kfree(td->slots);
 640         kfree(td);
 641         hid_set_drvdata(hdev, NULL);
 642 }
 643
 644 static const struct hid_device_id mt_devices[] = {
 645
 646         /* 3M panels */
 647         { .driver_data = MT_CLS_3M,
 648                 HID_USB_DEVICE(USB_VENDOR_ID_3M,
 649                         USB_DEVICE_ID_3M1968) },
 650         { .driver_data = MT_CLS_3M,
 651                 HID_USB_DEVICE(USB_VENDOR_ID_3M,
 652                         USB_DEVICE_ID_3M2256) },
 653         { .driver_data = MT_CLS_3M,
 654                 HID_USB_DEVICE(USB_VENDOR_ID_3M,
 655                         USB_DEVICE_ID_3M3266) },
 656
 657         /* ActionStar panels */
 658         { .driver_data = MT_CLS_DEFAULT,
 659                 HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
 660                         USB_DEVICE_ID_ACTIONSTAR_1011) },
 661
 662         /* Cando panels */
 663         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 664                 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 665                         USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
 666         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 667                 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 668                         USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
 669         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 670                 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 671                         USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
 672         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 673                 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 674                         USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
 675
 676         /* Chunghwa Telecom touch panels */
 677         {  .driver_data = MT_CLS_DEFAULT,
 678                 HID_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
 679                         USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
 680
 681         /* CVTouch panels */
 682         { .driver_data = MT_CLS_DEFAULT,
 683                 HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
 684                         USB_DEVICE_ID_CVTOUCH_SCREEN) },
 685
 686         /* Cypress panel */
 687         { .driver_data = MT_CLS_CYPRESS,
 688                 HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
 689                         USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
 690
 691         /* eGalax devices (resistive) */
 692         { .driver_data = MT_CLS_EGALAX,
 693                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 694                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
 695         { .driver_data = MT_CLS_EGALAX,
 696                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 697                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
 698
 699         /* eGalax devices (capacitive) */
 700         { .driver_data = MT_CLS_EGALAX,
 701                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 702                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
 703         { .driver_data = MT_CLS_EGALAX,
 704                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 705                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
 706         { .driver_data = MT_CLS_EGALAX,
 707                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 708                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
 709         { .driver_data = MT_CLS_EGALAX,
 710                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 711                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
 712         { .driver_data = MT_CLS_EGALAX,
 713                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 714                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
 715         { .driver_data = MT_CLS_EGALAX,
 716                 HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
 717                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
 718
 719         /* Elo TouchSystems IntelliTouch Plus panel */
 720         { .driver_data = MT_CLS_DUAL_NSMU_CONTACTID,
 721                 HID_USB_DEVICE(USB_VENDOR_ID_ELO,
 722                         USB_DEVICE_ID_ELO_TS2515) },
 723
 724         /* GeneralTouch panel */
 725         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
 726                 HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
 727                         USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
 728
 729         /* GoodTouch panels */
 730         { .driver_data = MT_CLS_DEFAULT,
 731                 HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
 732                         USB_DEVICE_ID_GOODTOUCH_000f) },
 733
 734         /* Ideacom panel */
 735         { .driver_data = MT_CLS_SERIAL,
 736                 HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
 737                         USB_DEVICE_ID_IDEACOM_IDC6650) },
 738
 739         /* Ilitek dual touch panel */
 740         {  .driver_data = MT_CLS_DEFAULT,
 741                 HID_USB_DEVICE(USB_VENDOR_ID_ILITEK,
 742                         USB_DEVICE_ID_ILITEK_MULTITOUCH) },
 743
 744         /* IRTOUCH panels */
 745         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
 746                 HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
 747                         USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
 748
 749         /* LG Display panels */
 750         { .driver_data = MT_CLS_DEFAULT,
 751                 HID_USB_DEVICE(USB_VENDOR_ID_LG,
 752                         USB_DEVICE_ID_LG_MULTITOUCH) },
 753
 754         /* Lumio panels */
 755         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
 756                 HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
 757                         USB_DEVICE_ID_CRYSTALTOUCH) },
 758         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
 759                 HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
 760                         USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
 761
 762         /* MosArt panels */
 763         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
 764                 HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
 765                         USB_DEVICE_ID_ASUS_T91MT)},
 766         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
 767                 HID_USB_DEVICE(USB_VENDOR_ID_ASUS,
 768                         USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
 769         { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
 770                 HID_USB_DEVICE(USB_VENDOR_ID_TURBOX,
 771                         USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
 772
 773         /* PenMount panels */
 774         { .driver_data = MT_CLS_CONFIDENCE,
 775                 HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
 776                         USB_DEVICE_ID_PENMOUNT_PCI) },
 777
 778         /* PixCir-based panels */
 779         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
 780                 HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
 781                         USB_DEVICE_ID_HANVON_MULTITOUCH) },
 782         { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
 783                 HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
 784                         USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
 785
 786         /* Stantum panels */
 787         { .driver_data = MT_CLS_CONFIDENCE,
 788                 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
 789                         USB_DEVICE_ID_MTP)},
 790         { .driver_data = MT_CLS_CONFIDENCE,
 791                 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
 792                         USB_DEVICE_ID_MTP_STM)},
 793         { .driver_data = MT_CLS_CONFIDENCE,
 794                 HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX,
 795                         USB_DEVICE_ID_MTP_SITRONIX)},
 796
 797         /* Touch International panels */
 798         { .driver_data = MT_CLS_DEFAULT,
 799                 HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL,
 800                         USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
 801
 802         /* Unitec panels */
 803         { .driver_data = MT_CLS_DEFAULT,
 804                 HID_USB_DEVICE(USB_VENDOR_ID_UNITEC,
 805                         USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
 806         { .driver_data = MT_CLS_DEFAULT,
 807                 HID_USB_DEVICE(USB_VENDOR_ID_UNITEC,
 808                         USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
 809         /* XAT */
 810         { .driver_data = MT_CLS_DEFAULT,
 811                 HID_USB_DEVICE(USB_VENDOR_ID_XAT,
 812                         USB_DEVICE_ID_XAT_CSR) },
 813
 814         { }
 815 };
 816 MODULE_DEVICE_TABLE(hid, mt_devices);
 817
 818 static const struct hid_usage_id mt_grabbed_usages[] = {
 819         { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
 820         { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
 821 };
 822
 823 static struct hid_driver mt_driver = {
 824         .name = "hid-multitouch",
 825         .id_table = mt_devices,
 826         .probe = mt_probe,
 827         .remove = mt_remove,
 828         .input_mapping = mt_input_mapping,
 829         .input_mapped = mt_input_mapped,
 830         .feature_mapping = mt_feature_mapping,
 831         .usage_table = mt_grabbed_usages,
 832         .event = mt_event,
 833 #ifdef CONFIG_PM
 834         .reset_resume = mt_reset_resume,
 835 #endif
 836 };
 837
 838 static int __init mt_init(void)
 839 {
 840         return hid_register_driver(&mt_driver);
 841 }
 842
 843 static void __exit mt_exit(void)
 844 {
 845         hid_unregister_driver(&mt_driver);
 846 }
 847
 848 module_init(mt_init);
 849 module_exit(mt_exit);