drivers/hid/wacom_wac.c

   1 /*
   2  * drivers/input/tablet/wacom_wac.c
   3  *
   4  *  USB Wacom tablet support - Wacom specific code
   5  *
   6  */
   7
   8 /*
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  */
  14
  15 #include "wacom_wac.h"
  16 #include "wacom.h"
  17 #include <linux/input/mt.h>
  18
  19 /* resolution for penabled devices */
  20 #define WACOM_PL_RES            20
  21 #define WACOM_PENPRTN_RES       40
  22 #define WACOM_VOLITO_RES        50
  23 #define WACOM_GRAPHIRE_RES      80
  24 #define WACOM_INTUOS_RES        100
  25 #define WACOM_INTUOS3_RES       200
  26
  27 /* Newer Cintiq and DTU have an offset between tablet and screen areas */
  28 #define WACOM_DTU_OFFSET        200
  29 #define WACOM_CINTIQ_OFFSET     400
  30
  31 /*
  32  * Scale factor relating reported contact size to logical contact area.
  33  * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
  34  */
  35 #define WACOM_CONTACT_AREA_SCALE 2607
  36
  37 static void wacom_report_numbered_buttons(struct input_dev *input_dev,
  38                                 int button_count, int mask);
  39
  40 /*
  41  * Percent of battery capacity for Graphire.
  42  * 8th value means AC online and show 100% capacity.
  43  */
  44 static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
  45
  46 /*
  47  * Percent of battery capacity for Intuos4 WL, AC has a separate bit.
  48  */
  49 static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
  50
  51 static void wacom_notify_battery(struct wacom_wac *wacom_wac,
  52         int bat_capacity, bool bat_charging, bool bat_connected,
  53         bool ps_connected)
  54 {
  55         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
  56         bool changed = wacom_wac->battery_capacity != bat_capacity  ||
  57                        wacom_wac->bat_charging     != bat_charging  ||
  58                        wacom_wac->bat_connected    != bat_connected ||
  59                        wacom_wac->ps_connected     != ps_connected;
  60
  61         if (changed) {
  62                 wacom_wac->battery_capacity = bat_capacity;
  63                 wacom_wac->bat_charging = bat_charging;
  64                 wacom_wac->bat_connected = bat_connected;
  65                 wacom_wac->ps_connected = ps_connected;
  66
  67                 if (wacom->battery)
  68                         power_supply_changed(wacom->battery);
  69         }
  70 }
  71
  72 static int wacom_penpartner_irq(struct wacom_wac *wacom)
  73 {
  74         unsigned char *data = wacom->data;
  75         struct input_dev *input = wacom->pen_input;
  76
  77         switch (data[0]) {
  78         case 1:
  79                 if (data[5] & 0x80) {
  80                         wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  81                         wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
  82                         input_report_key(input, wacom->tool[0], 1);
  83                         input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
  84                         input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
  85                         input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
  86                         input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
  87                         input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
  88                         input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
  89                 } else {
  90                         input_report_key(input, wacom->tool[0], 0);
  91                         input_report_abs(input, ABS_MISC, 0); /* report tool id */
  92                         input_report_abs(input, ABS_PRESSURE, -1);
  93                         input_report_key(input, BTN_TOUCH, 0);
  94                 }
  95                 break;
  96
  97         case 2:
  98                 input_report_key(input, BTN_TOOL_PEN, 1);
  99                 input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
 100                 input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
 101                 input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
 102                 input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
 103                 input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
 104                 input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
 105                 break;
 106
 107         default:
 108                 dev_dbg(input->dev.parent,
 109                         "%s: received unknown report #%d\n", __func__, data[0]);
 110                 return 0;
 111         }
 112
 113         return 1;
 114 }
 115
 116 static int wacom_pl_irq(struct wacom_wac *wacom)
 117 {
 118         struct wacom_features *features = &wacom->features;
 119         unsigned char *data = wacom->data;
 120         struct input_dev *input = wacom->pen_input;
 121         int prox, pressure;
 122
 123         if (data[0] != WACOM_REPORT_PENABLED) {
 124                 dev_dbg(input->dev.parent,
 125                         "%s: received unknown report #%d\n", __func__, data[0]);
 126                 return 0;
 127         }
 128
 129         prox = data[1] & 0x40;
 130
 131         if (!wacom->id[0]) {
 132                 if ((data[0] & 0x10) || (data[4] & 0x20)) {
 133                         wacom->tool[0] = BTN_TOOL_RUBBER;
 134                         wacom->id[0] = ERASER_DEVICE_ID;
 135                 }
 136                 else {
 137                         wacom->tool[0] = BTN_TOOL_PEN;
 138                         wacom->id[0] = STYLUS_DEVICE_ID;
 139                 }
 140         }
 141
 142         /* If the eraser is in prox, STYLUS2 is always set. If we
 143          * mis-detected the type and notice that STYLUS2 isn't set
 144          * then force the eraser out of prox and let the pen in.
 145          */
 146         if (wacom->tool[0] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
 147                 input_report_key(input, BTN_TOOL_RUBBER, 0);
 148                 input_report_abs(input, ABS_MISC, 0);
 149                 input_sync(input);
 150                 wacom->tool[0] = BTN_TOOL_PEN;
 151                 wacom->id[0] = STYLUS_DEVICE_ID;
 152         }
 153
 154         pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
 155         if (features->pressure_max > 255)
 156                 pressure = (pressure << 1) | ((data[4] >> 6) & 1);
 157         pressure += (features->pressure_max + 1) / 2;
 158
 159         input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
 160         input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
 161         input_report_abs(input, ABS_PRESSURE, pressure);
 162
 163         input_report_key(input, BTN_TOUCH, data[4] & 0x08);
 164         input_report_key(input, BTN_STYLUS, data[4] & 0x10);
 165         /* Only allow the stylus2 button to be reported for the pen tool. */
 166         input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20));
 167
 168         if (!prox)
 169                 wacom->id[0] = 0;
 170         input_report_key(input, wacom->tool[0], prox);
 171         input_report_abs(input, ABS_MISC, wacom->id[0]);
 172         return 1;
 173 }
 174
 175 static int wacom_ptu_irq(struct wacom_wac *wacom)
 176 {
 177         unsigned char *data = wacom->data;
 178         struct input_dev *input = wacom->pen_input;
 179
 180         if (data[0] != WACOM_REPORT_PENABLED) {
 181                 dev_dbg(input->dev.parent,
 182                         "%s: received unknown report #%d\n", __func__, data[0]);
 183                 return 0;
 184         }
 185
 186         if (data[1] & 0x04) {
 187                 input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
 188                 input_report_key(input, BTN_TOUCH, data[1] & 0x08);
 189                 wacom->id[0] = ERASER_DEVICE_ID;
 190         } else {
 191                 input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
 192                 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
 193                 wacom->id[0] = STYLUS_DEVICE_ID;
 194         }
 195         input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
 196         input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 197         input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 198         input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
 199         input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 200         input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
 201         return 1;
 202 }
 203
 204 static int wacom_dtu_irq(struct wacom_wac *wacom)
 205 {
 206         unsigned char *data = wacom->data;
 207         struct input_dev *input = wacom->pen_input;
 208         int prox = data[1] & 0x20;
 209
 210         dev_dbg(input->dev.parent,
 211                 "%s: received report #%d", __func__, data[0]);
 212
 213         if (prox) {
 214                 /* Going into proximity select tool */
 215                 wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
 216                 if (wacom->tool[0] == BTN_TOOL_PEN)
 217                         wacom->id[0] = STYLUS_DEVICE_ID;
 218                 else
 219                         wacom->id[0] = ERASER_DEVICE_ID;
 220         }
 221         input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 222         input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
 223         input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 224         input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 225         input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x01) << 8) | data[6]);
 226         input_report_key(input, BTN_TOUCH, data[1] & 0x05);
 227         if (!prox) /* out-prox */
 228                 wacom->id[0] = 0;
 229         input_report_key(input, wacom->tool[0], prox);
 230         input_report_abs(input, ABS_MISC, wacom->id[0]);
 231         return 1;
 232 }
 233
 234 static int wacom_dtus_irq(struct wacom_wac *wacom)
 235 {
 236         char *data = wacom->data;
 237         struct input_dev *input = wacom->pen_input;
 238         unsigned short prox, pressure = 0;
 239
 240         if (data[0] != WACOM_REPORT_DTUS && data[0] != WACOM_REPORT_DTUSPAD) {
 241                 dev_dbg(input->dev.parent,
 242                         "%s: received unknown report #%d", __func__, data[0]);
 243                 return 0;
 244         } else if (data[0] == WACOM_REPORT_DTUSPAD) {
 245                 input = wacom->pad_input;
 246                 input_report_key(input, BTN_0, (data[1] & 0x01));
 247                 input_report_key(input, BTN_1, (data[1] & 0x02));
 248                 input_report_key(input, BTN_2, (data[1] & 0x04));
 249                 input_report_key(input, BTN_3, (data[1] & 0x08));
 250                 input_report_abs(input, ABS_MISC,
 251                                  data[1] & 0x0f ? PAD_DEVICE_ID : 0);
 252                 return 1;
 253         } else {
 254                 prox = data[1] & 0x80;
 255                 if (prox) {
 256                         switch ((data[1] >> 3) & 3) {
 257                         case 1: /* Rubber */
 258                                 wacom->tool[0] = BTN_TOOL_RUBBER;
 259                                 wacom->id[0] = ERASER_DEVICE_ID;
 260                                 break;
 261
 262                         case 2: /* Pen */
 263                                 wacom->tool[0] = BTN_TOOL_PEN;
 264                                 wacom->id[0] = STYLUS_DEVICE_ID;
 265                                 break;
 266                         }
 267                 }
 268
 269                 input_report_key(input, BTN_STYLUS, data[1] & 0x20);
 270                 input_report_key(input, BTN_STYLUS2, data[1] & 0x40);
 271                 input_report_abs(input, ABS_X, get_unaligned_be16(&data[3]));
 272                 input_report_abs(input, ABS_Y, get_unaligned_be16(&data[5]));
 273                 pressure = ((data[1] & 0x03) << 8) | (data[2] & 0xff);
 274                 input_report_abs(input, ABS_PRESSURE, pressure);
 275                 input_report_key(input, BTN_TOUCH, pressure > 10);
 276
 277                 if (!prox) /* out-prox */
 278                         wacom->id[0] = 0;
 279                 input_report_key(input, wacom->tool[0], prox);
 280                 input_report_abs(input, ABS_MISC, wacom->id[0]);
 281                 return 1;
 282         }
 283 }
 284
 285 static int wacom_graphire_irq(struct wacom_wac *wacom)
 286 {
 287         struct wacom_features *features = &wacom->features;
 288         unsigned char *data = wacom->data;
 289         struct input_dev *input = wacom->pen_input;
 290         struct input_dev *pad_input = wacom->pad_input;
 291         int battery_capacity, ps_connected;
 292         int prox;
 293         int rw = 0;
 294         int retval = 0;
 295
 296         if (features->type == GRAPHIRE_BT) {
 297                 if (data[0] != WACOM_REPORT_PENABLED_BT) {
 298                         dev_dbg(input->dev.parent,
 299                                 "%s: received unknown report #%d\n", __func__,
 300                                 data[0]);
 301                         goto exit;
 302                 }
 303         } else if (data[0] != WACOM_REPORT_PENABLED) {
 304                 dev_dbg(input->dev.parent,
 305                         "%s: received unknown report #%d\n", __func__, data[0]);
 306                 goto exit;
 307         }
 308
 309         prox = data[1] & 0x80;
 310         if (prox || wacom->id[0]) {
 311                 if (prox) {
 312                         switch ((data[1] >> 5) & 3) {
 313
 314                         case 0: /* Pen */
 315                                 wacom->tool[0] = BTN_TOOL_PEN;
 316                                 wacom->id[0] = STYLUS_DEVICE_ID;
 317                                 break;
 318
 319                         case 1: /* Rubber */
 320                                 wacom->tool[0] = BTN_TOOL_RUBBER;
 321                                 wacom->id[0] = ERASER_DEVICE_ID;
 322                                 break;
 323
 324                         case 2: /* Mouse with wheel */
 325                                 input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
 326                                 /* fall through */
 327
 328                         case 3: /* Mouse without wheel */
 329                                 wacom->tool[0] = BTN_TOOL_MOUSE;
 330                                 wacom->id[0] = CURSOR_DEVICE_ID;
 331                                 break;
 332                         }
 333                 }
 334                 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 335                 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 336                 if (wacom->tool[0] != BTN_TOOL_MOUSE) {
 337                         if (features->type == GRAPHIRE_BT)
 338                                 input_report_abs(input, ABS_PRESSURE, data[6] |
 339                                         (((__u16) (data[1] & 0x08)) << 5));
 340                         else
 341                                 input_report_abs(input, ABS_PRESSURE, data[6] |
 342                                         ((data[7] & 0x03) << 8));
 343                         input_report_key(input, BTN_TOUCH, data[1] & 0x01);
 344                         input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 345                         input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
 346                 } else {
 347                         input_report_key(input, BTN_LEFT, data[1] & 0x01);
 348                         input_report_key(input, BTN_RIGHT, data[1] & 0x02);
 349                         if (features->type == WACOM_G4 ||
 350                                         features->type == WACOM_MO) {
 351                                 input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
 352                                 rw = (data[7] & 0x04) - (data[7] & 0x03);
 353                         } else if (features->type == GRAPHIRE_BT) {
 354                                 /* Compute distance between mouse and tablet */
 355                                 rw = 44 - (data[6] >> 2);
 356                                 rw = clamp_val(rw, 0, 31);
 357                                 input_report_abs(input, ABS_DISTANCE, rw);
 358                                 if (((data[1] >> 5) & 3) == 2) {
 359                                         /* Mouse with wheel */
 360                                         input_report_key(input, BTN_MIDDLE,
 361                                                         data[1] & 0x04);
 362                                         rw = (data[6] & 0x01) ? -1 :
 363                                                 (data[6] & 0x02) ? 1 : 0;
 364                                 } else {
 365                                         rw = 0;
 366                                 }
 367                         } else {
 368                                 input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
 369                                 rw = -(signed char)data[6];
 370                         }
 371                         input_report_rel(input, REL_WHEEL, rw);
 372                 }
 373
 374                 if (!prox)
 375                         wacom->id[0] = 0;
 376                 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
 377                 input_report_key(input, wacom->tool[0], prox);
 378                 input_sync(input); /* sync last event */
 379         }
 380
 381         /* send pad data */
 382         switch (features->type) {
 383         case WACOM_G4:
 384                 prox = data[7] & 0xf8;
 385                 if (prox || wacom->id[1]) {
 386                         wacom->id[1] = PAD_DEVICE_ID;
 387                         input_report_key(pad_input, BTN_BACK, (data[7] & 0x40));
 388                         input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x80));
 389                         rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
 390                         input_report_rel(pad_input, REL_WHEEL, rw);
 391                         if (!prox)
 392                                 wacom->id[1] = 0;
 393                         input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
 394                         retval = 1;
 395                 }
 396                 break;
 397
 398         case WACOM_MO:
 399                 prox = (data[7] & 0xf8) || data[8];
 400                 if (prox || wacom->id[1]) {
 401                         wacom->id[1] = PAD_DEVICE_ID;
 402                         input_report_key(pad_input, BTN_BACK, (data[7] & 0x08));
 403                         input_report_key(pad_input, BTN_LEFT, (data[7] & 0x20));
 404                         input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x10));
 405                         input_report_key(pad_input, BTN_RIGHT, (data[7] & 0x40));
 406                         input_report_abs(pad_input, ABS_WHEEL, (data[8] & 0x7f));
 407                         if (!prox)
 408                                 wacom->id[1] = 0;
 409                         input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
 410                         retval = 1;
 411                 }
 412                 break;
 413         case GRAPHIRE_BT:
 414                 prox = data[7] & 0x03;
 415                 if (prox || wacom->id[1]) {
 416                         wacom->id[1] = PAD_DEVICE_ID;
 417                         input_report_key(pad_input, BTN_0, (data[7] & 0x02));
 418                         input_report_key(pad_input, BTN_1, (data[7] & 0x01));
 419                         if (!prox)
 420                                 wacom->id[1] = 0;
 421                         input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
 422                         retval = 1;
 423                 }
 424                 break;
 425         }
 426
 427         /* Store current battery capacity and power supply state */
 428         if (features->type == GRAPHIRE_BT) {
 429                 rw = (data[7] >> 2 & 0x07);
 430                 battery_capacity = batcap_gr[rw];
 431                 ps_connected = rw == 7;
 432                 wacom_notify_battery(wacom, battery_capacity, ps_connected,
 433                                      1, ps_connected);
 434         }
 435 exit:
 436         return retval;
 437 }
 438
 439 static void wacom_intuos_schedule_prox_event(struct wacom_wac *wacom_wac)
 440 {
 441         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
 442         struct wacom_features *features = &wacom_wac->features;
 443         struct hid_report *r;
 444         struct hid_report_enum *re;
 445
 446         re = &(wacom->hdev->report_enum[HID_FEATURE_REPORT]);
 447         if (features->type == INTUOSHT2)
 448                 r = re->report_id_hash[WACOM_REPORT_INTUOSHT2_ID];
 449         else
 450                 r = re->report_id_hash[WACOM_REPORT_INTUOS_ID1];
 451         if (r) {
 452                 hid_hw_request(wacom->hdev, r, HID_REQ_GET_REPORT);
 453         }
 454 }
 455
 456 static int wacom_intuos_pad(struct wacom_wac *wacom)
 457 {
 458         struct wacom_features *features = &wacom->features;
 459         unsigned char *data = wacom->data;
 460         struct input_dev *input = wacom->pad_input;
 461         int i;
 462         int buttons = 0, nbuttons = features->numbered_buttons;
 463         int keys = 0, nkeys = 0;
 464         int ring1 = 0, ring2 = 0;
 465         int strip1 = 0, strip2 = 0;
 466         bool prox = false;
 467
 468         /* pad packets. Works as a second tool and is always in prox */
 469         if (!(data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD ||
 470               data[0] == WACOM_REPORT_CINTIQPAD))
 471                 return 0;
 472
 473         if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
 474                 buttons = (data[3] << 1) | (data[2] & 0x01);
 475                 ring1 = data[1];
 476         } else if (features->type == DTK) {
 477                 buttons = data[6];
 478         } else if (features->type == WACOM_13HD) {
 479                 buttons = (data[4] << 1) | (data[3] & 0x01);
 480         } else if (features->type == WACOM_24HD) {
 481                 buttons = (data[8] << 8) | data[6];
 482                 ring1 = data[1];
 483                 ring2 = data[2];
 484
 485                 /*
 486                  * Three "buttons" are available on the 24HD which are
 487                  * physically implemented as a touchstrip. Each button
 488                  * is approximately 3 bits wide with a 2 bit spacing.
 489                  * The raw touchstrip bits are stored at:
 490                  *    ((data[3] & 0x1f) << 8) | data[4])
 491                  */
 492                 nkeys = 3;
 493                 keys = ((data[3] & 0x1C) ? 1<<2 : 0) |
 494                        ((data[4] & 0xE0) ? 1<<1 : 0) |
 495                        ((data[4] & 0x07) ? 1<<0 : 0);
 496         } else if (features->type == WACOM_27QHD) {
 497                 nkeys = 3;
 498                 keys = data[2] & 0x07;
 499
 500                 input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[4]));
 501                 input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[6]));
 502                 input_report_abs(input, ABS_Z, be16_to_cpup((__be16 *)&data[8]));
 503         } else if (features->type == CINTIQ_HYBRID) {
 504                 /*
 505                  * Do not send hardware buttons under Android. They
 506                  * are already sent to the system through GPIO (and
 507                  * have different meaning).
 508                  *
 509                  * d-pad right  -> data[4] & 0x10
 510                  * d-pad up     -> data[4] & 0x20
 511                  * d-pad left   -> data[4] & 0x40
 512                  * d-pad down   -> data[4] & 0x80
 513                  * d-pad center -> data[3] & 0x01
 514                  */
 515                 buttons = (data[4] << 1) | (data[3] & 0x01);
 516         } else if (features->type == CINTIQ_COMPANION_2) {
 517                 /* d-pad right  -> data[4] & 0x10
 518                  * d-pad up     -> data[4] & 0x20
 519                  * d-pad left   -> data[4] & 0x40
 520                  * d-pad down   -> data[4] & 0x80
 521                  * d-pad center -> data[3] & 0x01
 522                  */
 523                 buttons = ((data[2] >> 4) << 7) |
 524                           ((data[1] & 0x04) << 6) |
 525                           ((data[2] & 0x0F) << 2) |
 526                           (data[1] & 0x03);
 527         } else if (features->type >= INTUOS5S && features->type <= INTUOSPL) {
 528                 /*
 529                  * ExpressKeys on Intuos5/Intuos Pro have a capacitive sensor in
 530                  * addition to the mechanical switch. Switch data is
 531                  * stored in data[4], capacitive data in data[5].
 532                  *
 533                  * Touch ring mode switch (data[3]) has no capacitive sensor
 534                  */
 535                 buttons = (data[4] << 1) | (data[3] & 0x01);
 536                 ring1 = data[2];
 537         } else {
 538                 if (features->type == WACOM_21UX2 || features->type == WACOM_22HD) {
 539                         buttons = (data[8] << 10) | ((data[7] & 0x01) << 9) |
 540                                   (data[6] << 1) | (data[5] & 0x01);
 541
 542                         if (features->type == WACOM_22HD) {
 543                                 nkeys = 3;
 544                                 keys = data[9] & 0x07;
 545                         }
 546                 } else {
 547                         buttons = ((data[6] & 0x10) << 10) |
 548                                   ((data[5] & 0x10) << 9)  |
 549                                   ((data[6] & 0x0F) << 4)  |
 550                                   (data[5] & 0x0F);
 551                 }
 552                 strip1 = ((data[1] & 0x1f) << 8) | data[2];
 553                 strip2 = ((data[3] & 0x1f) << 8) | data[4];
 554         }
 555
 556         prox = (buttons & ~(~0 << nbuttons)) | (keys & ~(~0 << nkeys)) |
 557                (ring1 & 0x80) | (ring2 & 0x80) | strip1 | strip2;
 558
 559         wacom_report_numbered_buttons(input, nbuttons, buttons);
 560
 561         for (i = 0; i < nkeys; i++)
 562                 input_report_key(input, KEY_PROG1 + i, keys & (1 << i));
 563
 564         input_report_abs(input, ABS_RX, strip1);
 565         input_report_abs(input, ABS_RY, strip2);
 566
 567         input_report_abs(input, ABS_WHEEL,    (ring1 & 0x80) ? (ring1 & 0x7f) : 0);
 568         input_report_abs(input, ABS_THROTTLE, (ring2 & 0x80) ? (ring2 & 0x7f) : 0);
 569
 570         input_report_key(input, wacom->tool[1], prox ? 1 : 0);
 571         input_report_abs(input, ABS_MISC, prox ? PAD_DEVICE_ID : 0);
 572
 573         input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
 574
 575         return 1;
 576 }
 577
 578 static int wacom_intuos_inout(struct wacom_wac *wacom)
 579 {
 580         struct wacom_features *features = &wacom->features;
 581         unsigned char *data = wacom->data;
 582         struct input_dev *input = wacom->pen_input;
 583         int idx = 0;
 584
 585         /* tool number */
 586         if (features->type == INTUOS)
 587                 idx = data[1] & 0x01;
 588
 589         /* Enter report */
 590         if ((data[1] & 0xfc) == 0xc0) {
 591                 /* serial number of the tool */
 592                 wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
 593                         (data[4] << 20) + (data[5] << 12) +
 594                         (data[6] << 4) + (data[7] >> 4);
 595
 596                 wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
 597                         ((data[7] & 0x0f) << 20) | ((data[8] & 0xf0) << 12);
 598
 599                 switch (wacom->id[idx]) {
 600                 case 0x812: /* Inking pen */
 601                 case 0x801: /* Intuos3 Inking pen */
 602                 case 0x120802: /* Intuos4/5 Inking Pen */
 603                 case 0x012:
 604                         wacom->tool[idx] = BTN_TOOL_PENCIL;
 605                         break;
 606
 607                 case 0x822: /* Pen */
 608                 case 0x842:
 609                 case 0x852:
 610                 case 0x823: /* Intuos3 Grip Pen */
 611                 case 0x813: /* Intuos3 Classic Pen */
 612                 case 0x885: /* Intuos3 Marker Pen */
 613                 case 0x802: /* Intuos4/5 13HD/24HD General Pen */
 614                 case 0x804: /* Intuos4/5 13HD/24HD Marker Pen */
 615                 case 0x022:
 616                 case 0x100804: /* Intuos4/5 13HD/24HD Art Pen */
 617                 case 0x140802: /* Intuos4/5 13HD/24HD Classic Pen */
 618                 case 0x160802: /* Cintiq 13HD Pro Pen */
 619                 case 0x180802: /* DTH2242 Pen */
 620                 case 0x100802: /* Intuos4/5 13HD/24HD General Pen */
 621                         wacom->tool[idx] = BTN_TOOL_PEN;
 622                         break;
 623
 624                 case 0x832: /* Stroke pen */
 625                 case 0x032:
 626                         wacom->tool[idx] = BTN_TOOL_BRUSH;
 627                         break;
 628
 629                 case 0x007: /* Mouse 4D and 2D */
 630                 case 0x09c:
 631                 case 0x094:
 632                 case 0x017: /* Intuos3 2D Mouse */
 633                 case 0x806: /* Intuos4 Mouse */
 634                         wacom->tool[idx] = BTN_TOOL_MOUSE;
 635                         break;
 636
 637                 case 0x096: /* Lens cursor */
 638                 case 0x097: /* Intuos3 Lens cursor */
 639                 case 0x006: /* Intuos4 Lens cursor */
 640                         wacom->tool[idx] = BTN_TOOL_LENS;
 641                         break;
 642
 643                 case 0x82a: /* Eraser */
 644                 case 0x85a:
 645                 case 0x91a:
 646                 case 0xd1a:
 647                 case 0x0fa:
 648                 case 0x82b: /* Intuos3 Grip Pen Eraser */
 649                 case 0x81b: /* Intuos3 Classic Pen Eraser */
 650                 case 0x91b: /* Intuos3 Airbrush Eraser */
 651                 case 0x80c: /* Intuos4/5 13HD/24HD Marker Pen Eraser */
 652                 case 0x80a: /* Intuos4/5 13HD/24HD General Pen Eraser */
 653                 case 0x90a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
 654                 case 0x14080a: /* Intuos4/5 13HD/24HD Classic Pen Eraser */
 655                 case 0x10090a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
 656                 case 0x10080c: /* Intuos4/5 13HD/24HD Art Pen Eraser */
 657                 case 0x16080a: /* Cintiq 13HD Pro Pen Eraser */
 658                 case 0x18080a: /* DTH2242 Eraser */
 659                 case 0x10080a: /* Intuos4/5 13HD/24HD General Pen Eraser */
 660                         wacom->tool[idx] = BTN_TOOL_RUBBER;
 661                         break;
 662
 663                 case 0xd12:
 664                 case 0x912:
 665                 case 0x112:
 666                 case 0x913: /* Intuos3 Airbrush */
 667                 case 0x902: /* Intuos4/5 13HD/24HD Airbrush */
 668                 case 0x100902: /* Intuos4/5 13HD/24HD Airbrush */
 669                         wacom->tool[idx] = BTN_TOOL_AIRBRUSH;
 670                         break;
 671
 672                 default: /* Unknown tool */
 673                         wacom->tool[idx] = BTN_TOOL_PEN;
 674                         break;
 675                 }
 676                 return 1;
 677         }
 678
 679         /*
 680          * don't report events for invalid data
 681          */
 682         /* older I4 styli don't work with new Cintiqs */
 683         if ((!((wacom->id[idx] >> 20) & 0x01) &&
 684                         (features->type == WACOM_21UX2)) ||
 685             /* Only large Intuos support Lense Cursor */
 686             (wacom->tool[idx] == BTN_TOOL_LENS &&
 687                 (features->type == INTUOS3 ||
 688                  features->type == INTUOS3S ||
 689                  features->type == INTUOS4 ||
 690                  features->type == INTUOS4S ||
 691                  features->type == INTUOS5 ||
 692                  features->type == INTUOS5S ||
 693                  features->type == INTUOSPM ||
 694                  features->type == INTUOSPS)) ||
 695            /* Cintiq doesn't send data when RDY bit isn't set */
 696            (features->type == CINTIQ && !(data[1] & 0x40)))
 697                 return 1;
 698
 699         wacom->shared->stylus_in_proximity = true;
 700         if (wacom->shared->touch_down)
 701                 return 1;
 702
 703         /* in Range while exiting */
 704         if (((data[1] & 0xfe) == 0x20) && wacom->reporting_data) {
 705                 input_report_key(input, BTN_TOUCH, 0);
 706                 input_report_abs(input, ABS_PRESSURE, 0);
 707                 input_report_abs(input, ABS_DISTANCE, wacom->features.distance_max);
 708                 return 2;
 709         }
 710
 711         /* Exit report */
 712         if ((data[1] & 0xfe) == 0x80) {
 713                 wacom->shared->stylus_in_proximity = false;
 714                 wacom->reporting_data = false;
 715
 716                 /* don't report exit if we don't know the ID */
 717                 if (!wacom->id[idx])
 718                         return 1;
 719
 720                 /*
 721                  * Reset all states otherwise we lose the initial states
 722                  * when in-prox next time
 723                  */
 724                 input_report_abs(input, ABS_X, 0);
 725                 input_report_abs(input, ABS_Y, 0);
 726                 input_report_abs(input, ABS_DISTANCE, 0);
 727                 input_report_abs(input, ABS_TILT_X, 0);
 728                 input_report_abs(input, ABS_TILT_Y, 0);
 729                 if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
 730                         input_report_key(input, BTN_LEFT, 0);
 731                         input_report_key(input, BTN_MIDDLE, 0);
 732                         input_report_key(input, BTN_RIGHT, 0);
 733                         input_report_key(input, BTN_SIDE, 0);
 734                         input_report_key(input, BTN_EXTRA, 0);
 735                         input_report_abs(input, ABS_THROTTLE, 0);
 736                         input_report_abs(input, ABS_RZ, 0);
 737                 } else {
 738                         input_report_abs(input, ABS_PRESSURE, 0);
 739                         input_report_key(input, BTN_STYLUS, 0);
 740                         input_report_key(input, BTN_STYLUS2, 0);
 741                         input_report_key(input, BTN_TOUCH, 0);
 742                         input_report_abs(input, ABS_WHEEL, 0);
 743                         if (features->type >= INTUOS3S)
 744                                 input_report_abs(input, ABS_Z, 0);
 745                 }
 746                 input_report_key(input, wacom->tool[idx], 0);
 747                 input_report_abs(input, ABS_MISC, 0); /* reset tool id */
 748                 input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
 749                 wacom->id[idx] = 0;
 750                 return 2;
 751         }
 752
 753         /* don't report other events if we don't know the ID */
 754         if (!wacom->id[idx]) {
 755                 /* but reschedule a read of the current tool */
 756                 wacom_intuos_schedule_prox_event(wacom);
 757                 return 1;
 758         }
 759
 760         return 0;
 761 }
 762
 763 static int wacom_remote_irq(struct wacom_wac *wacom_wac, size_t len)
 764 {
 765         unsigned char *data = wacom_wac->data;
 766         struct input_dev *input = wacom_wac->pad_input;
 767         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
 768         struct wacom_features *features = &wacom_wac->features;
 769         int bat_charging, bat_percent, touch_ring_mode;
 770         __u32 serial;
 771         int i;
 772
 773         if (data[0] != WACOM_REPORT_REMOTE) {
 774                 dev_dbg(input->dev.parent,
 775                         "%s: received unknown report #%d", __func__, data[0]);
 776                 return 0;
 777         }
 778
 779         serial = data[3] + (data[4] << 8) + (data[5] << 16);
 780         wacom_wac->id[0] = PAD_DEVICE_ID;
 781
 782         input_report_key(input, BTN_0, (data[9] & 0x01));
 783         input_report_key(input, BTN_1, (data[9] & 0x02));
 784         input_report_key(input, BTN_2, (data[9] & 0x04));
 785         input_report_key(input, BTN_3, (data[9] & 0x08));
 786         input_report_key(input, BTN_4, (data[9] & 0x10));
 787         input_report_key(input, BTN_5, (data[9] & 0x20));
 788         input_report_key(input, BTN_6, (data[9] & 0x40));
 789         input_report_key(input, BTN_7, (data[9] & 0x80));
 790
 791         input_report_key(input, BTN_8, (data[10] & 0x01));
 792         input_report_key(input, BTN_9, (data[10] & 0x02));
 793         input_report_key(input, BTN_A, (data[10] & 0x04));
 794         input_report_key(input, BTN_B, (data[10] & 0x08));
 795         input_report_key(input, BTN_C, (data[10] & 0x10));
 796         input_report_key(input, BTN_X, (data[10] & 0x20));
 797         input_report_key(input, BTN_Y, (data[10] & 0x40));
 798         input_report_key(input, BTN_Z, (data[10] & 0x80));
 799
 800         input_report_key(input, BTN_BASE, (data[11] & 0x01));
 801         input_report_key(input, BTN_BASE2, (data[11] & 0x02));
 802
 803         if (data[12] & 0x80)
 804                 input_report_abs(input, ABS_WHEEL, (data[12] & 0x7f));
 805         else
 806                 input_report_abs(input, ABS_WHEEL, 0);
 807
 808         bat_percent = data[7] & 0x7f;
 809         bat_charging = !!(data[7] & 0x80);
 810
 811         if (data[9] | data[10] | (data[11] & 0x03) | data[12])
 812                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
 813         else
 814                 input_report_abs(input, ABS_MISC, 0);
 815
 816         input_event(input, EV_MSC, MSC_SERIAL, serial);
 817
 818         /*Which mode select (LED light) is currently on?*/
 819         touch_ring_mode = (data[11] & 0xC0) >> 6;
 820
 821         for (i = 0; i < WACOM_MAX_REMOTES; i++) {
 822                 if (wacom_wac->serial[i] == serial)
 823                         wacom->led.select[i] = touch_ring_mode;
 824         }
 825
 826         if (!wacom->battery &&
 827             !(features->quirks & WACOM_QUIRK_BATTERY)) {
 828                 features->quirks |= WACOM_QUIRK_BATTERY;
 829                 INIT_WORK(&wacom->work, wacom_battery_work);
 830                 wacom_schedule_work(wacom_wac);
 831         }
 832
 833         wacom_notify_battery(wacom_wac, bat_percent, bat_charging, 1,
 834                              bat_charging);
 835
 836         return 1;
 837 }
 838
 839 static int wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
 840 {
 841         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
 842         unsigned char *data = wacom_wac->data;
 843         int i;
 844
 845         if (data[0] != WACOM_REPORT_DEVICE_LIST)
 846                 return 0;
 847
 848         for (i = 0; i < WACOM_MAX_REMOTES; i++) {
 849                 int j = i * 6;
 850                 int serial = (data[j+6] << 16) + (data[j+5] << 8) + data[j+4];
 851                 bool connected = data[j+2];
 852
 853                 if (connected) {
 854                         int k;
 855
 856                         if (wacom_wac->serial[i] == serial)
 857                                 continue;
 858
 859                         if (wacom_wac->serial[i]) {
 860                                 wacom_remote_destroy_attr_group(wacom,
 861                                                         wacom_wac->serial[i]);
 862                         }
 863
 864                         /* A remote can pair more than once with an EKR,
 865                          * check to make sure this serial isn't already paired.
 866                          */
 867                         for (k = 0; k < WACOM_MAX_REMOTES; k++) {
 868                                 if (wacom_wac->serial[k] == serial)
 869                                         break;
 870                         }
 871
 872                         if (k < WACOM_MAX_REMOTES) {
 873                                 wacom_wac->serial[i] = serial;
 874                                 continue;
 875                         }
 876                         wacom_remote_create_attr_group(wacom, serial, i);
 877
 878                 } else if (wacom_wac->serial[i]) {
 879                         wacom_remote_destroy_attr_group(wacom,
 880                                                         wacom_wac->serial[i]);
 881                 }
 882         }
 883
 884         return 0;
 885 }
 886
 887 static int wacom_intuos_general(struct wacom_wac *wacom)
 888 {
 889         struct wacom_features *features = &wacom->features;
 890         unsigned char *data = wacom->data;
 891         struct input_dev *input = wacom->pen_input;
 892         int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
 893         unsigned char type = (data[1] >> 1) & 0x0F;
 894         unsigned int x, y, distance, t;
 895
 896         if (data[0] != WACOM_REPORT_PENABLED && data[0] != WACOM_REPORT_CINTIQ &&
 897                 data[0] != WACOM_REPORT_INTUOS_PEN)
 898                 return 0;
 899
 900         x = (be16_to_cpup((__be16 *)&data[2]) << 1) | ((data[9] >> 1) & 1);
 901         y = (be16_to_cpup((__be16 *)&data[4]) << 1) | (data[9] & 1);
 902         distance = data[9] >> 2;
 903         if (features->type < INTUOS3S) {
 904                 x >>= 1;
 905                 y >>= 1;
 906                 distance >>= 1;
 907         }
 908         input_report_abs(input, ABS_X, x);
 909         input_report_abs(input, ABS_Y, y);
 910         input_report_abs(input, ABS_DISTANCE, distance);
 911
 912         switch (type) {
 913         case 0x00:
 914         case 0x01:
 915         case 0x02:
 916         case 0x03:
 917                 /* general pen packet */
 918                 t = (data[6] << 3) | ((data[7] & 0xC0) >> 5) | (data[1] & 1);
 919                 if (features->pressure_max < 2047)
 920                         t >>= 1;
 921                 input_report_abs(input, ABS_PRESSURE, t);
 922                 if (features->type != INTUOSHT2) {
 923                     input_report_abs(input, ABS_TILT_X,
 924                                  (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
 925                     input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
 926                 }
 927                 input_report_key(input, BTN_STYLUS, data[1] & 2);
 928                 input_report_key(input, BTN_STYLUS2, data[1] & 4);
 929                 input_report_key(input, BTN_TOUCH, t > 10);
 930                 break;
 931
 932         case 0x0a:
 933                 /* airbrush second packet */
 934                 input_report_abs(input, ABS_WHEEL,
 935                                 (data[6] << 2) | ((data[7] >> 6) & 3));
 936                 input_report_abs(input, ABS_TILT_X,
 937                                  (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
 938                 input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
 939                 break;
 940
 941         case 0x05:
 942                 /* Rotation packet */
 943                 if (features->type >= INTUOS3S) {
 944                         /* I3 marker pen rotation */
 945                         t = (data[6] << 3) | ((data[7] >> 5) & 7);
 946                         t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
 947                                 ((t-1) / 2 + 450)) : (450 - t / 2) ;
 948                         input_report_abs(input, ABS_Z, t);
 949                 } else {
 950                         /* 4D mouse 2nd packet */
 951                         t = (data[6] << 3) | ((data[7] >> 5) & 7);
 952                         input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
 953                                 ((t - 1) / 2) : -t / 2);
 954                 }
 955                 break;
 956
 957         case 0x04:
 958                 /* 4D mouse 1st packet */
 959                 input_report_key(input, BTN_LEFT,   data[8] & 0x01);
 960                 input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
 961                 input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
 962
 963                 input_report_key(input, BTN_SIDE,   data[8] & 0x20);
 964                 input_report_key(input, BTN_EXTRA,  data[8] & 0x10);
 965                 t = (data[6] << 2) | ((data[7] >> 6) & 3);
 966                 input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
 967                 break;
 968
 969         case 0x06:
 970                 /* I4 mouse */
 971                 input_report_key(input, BTN_LEFT,   data[6] & 0x01);
 972                 input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
 973                 input_report_key(input, BTN_RIGHT,  data[6] & 0x04);
 974                 input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
 975                                  - ((data[7] & 0x40) >> 6));
 976                 input_report_key(input, BTN_SIDE,   data[6] & 0x08);
 977                 input_report_key(input, BTN_EXTRA,  data[6] & 0x10);
 978
 979                 input_report_abs(input, ABS_TILT_X,
 980                         (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
 981                 input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
 982                 break;
 983
 984         case 0x08:
 985                 if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
 986                         /* 2D mouse packet */
 987                         input_report_key(input, BTN_LEFT,   data[8] & 0x04);
 988                         input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
 989                         input_report_key(input, BTN_RIGHT,  data[8] & 0x10);
 990                         input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
 991                                          - ((data[8] & 0x02) >> 1));
 992
 993                         /* I3 2D mouse side buttons */
 994                         if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
 995                                 input_report_key(input, BTN_SIDE,   data[8] & 0x40);
 996                                 input_report_key(input, BTN_EXTRA,  data[8] & 0x20);
 997                         }
 998                 }
 999                 else if (wacom->tool[idx] == BTN_TOOL_LENS) {
1000                         /* Lens cursor packets */
1001                         input_report_key(input, BTN_LEFT,   data[8] & 0x01);
1002                         input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
1003                         input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
1004                         input_report_key(input, BTN_SIDE,   data[8] & 0x10);
1005                         input_report_key(input, BTN_EXTRA,  data[8] & 0x08);
1006                 }
1007                 break;
1008
1009         case 0x07:
1010         case 0x09:
1011         case 0x0b:
1012         case 0x0c:
1013         case 0x0d:
1014         case 0x0e:
1015         case 0x0f:
1016                 /* unhandled */
1017                 break;
1018         }
1019
1020         input_report_abs(input, ABS_MISC, wacom->id[idx]); /* report tool id */
1021         input_report_key(input, wacom->tool[idx], 1);
1022         input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
1023         wacom->reporting_data = true;
1024         return 2;
1025 }
1026
1027 static int wacom_intuos_irq(struct wacom_wac *wacom)
1028 {
1029         unsigned char *data = wacom->data;
1030         struct input_dev *input = wacom->pen_input;
1031         int result;
1032
1033         if (data[0] != WACOM_REPORT_PENABLED &&
1034             data[0] != WACOM_REPORT_INTUOS_ID1 &&
1035             data[0] != WACOM_REPORT_INTUOS_ID2 &&
1036             data[0] != WACOM_REPORT_INTUOSPAD &&
1037             data[0] != WACOM_REPORT_INTUOS_PEN &&
1038             data[0] != WACOM_REPORT_CINTIQ &&
1039             data[0] != WACOM_REPORT_CINTIQPAD &&
1040             data[0] != WACOM_REPORT_INTUOS5PAD) {
1041                 dev_dbg(input->dev.parent,
1042                         "%s: received unknown report #%d\n", __func__, data[0]);
1043                 return 0;
1044         }
1045
1046         /* process pad events */
1047         result = wacom_intuos_pad(wacom);
1048         if (result)
1049                 return result;
1050
1051         /* process in/out prox events */
1052         result = wacom_intuos_inout(wacom);
1053         if (result)
1054                 return result - 1;
1055
1056         /* process general packets */
1057         result = wacom_intuos_general(wacom);
1058         if (result)
1059                 return result - 1;
1060
1061         return 0;
1062 }
1063
1064 static int int_dist(int x1, int y1, int x2, int y2)
1065 {
1066         int x = x2 - x1;
1067         int y = y2 - y1;
1068
1069         return int_sqrt(x*x + y*y);
1070 }
1071
1072 static void wacom_intuos_bt_process_data(struct wacom_wac *wacom,
1073                 unsigned char *data)
1074 {
1075         memcpy(wacom->data, data, 10);
1076         wacom_intuos_irq(wacom);
1077
1078         input_sync(wacom->pen_input);
1079         if (wacom->pad_input)
1080                 input_sync(wacom->pad_input);
1081 }
1082
1083 static int wacom_intuos_bt_irq(struct wacom_wac *wacom, size_t len)
1084 {
1085         unsigned char data[WACOM_PKGLEN_MAX];
1086         int i = 1;
1087         unsigned power_raw, battery_capacity, bat_charging, ps_connected;
1088
1089         memcpy(data, wacom->data, len);
1090
1091         switch (data[0]) {
1092         case 0x04:
1093                 wacom_intuos_bt_process_data(wacom, data + i);
1094                 i += 10;
1095                 /* fall through */
1096         case 0x03:
1097                 wacom_intuos_bt_process_data(wacom, data + i);
1098                 i += 10;
1099                 wacom_intuos_bt_process_data(wacom, data + i);
1100                 i += 10;
1101                 power_raw = data[i];
1102                 bat_charging = (power_raw & 0x08) ? 1 : 0;
1103                 ps_connected = (power_raw & 0x10) ? 1 : 0;
1104                 battery_capacity = batcap_i4[power_raw & 0x07];
1105                 wacom_notify_battery(wacom, battery_capacity, bat_charging,
1106                                      battery_capacity || bat_charging,
1107                                      ps_connected);
1108                 break;
1109         default:
1110                 dev_dbg(wacom->pen_input->dev.parent,
1111                                 "Unknown report: %d,%d size:%zu\n",
1112                                 data[0], data[1], len);
1113                 return 0;
1114         }
1115         return 0;
1116 }
1117
1118 static int wacom_wac_finger_count_touches(struct wacom_wac *wacom)
1119 {
1120         struct input_dev *input = wacom->touch_input;
1121         unsigned touch_max = wacom->features.touch_max;
1122         int count = 0;
1123         int i;
1124
1125         if (!touch_max)
1126                 return 0;
1127
1128         if (touch_max == 1)
1129                 return test_bit(BTN_TOUCH, input->key) &&
1130                        !wacom->shared->stylus_in_proximity;
1131
1132         for (i = 0; i < input->mt->num_slots; i++) {
1133                 struct input_mt_slot *ps = &input->mt->slots[i];
1134                 int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
1135                 if (id >= 0)
1136                         count++;
1137         }
1138
1139         return count;
1140 }
1141
1142 static int wacom_24hdt_irq(struct wacom_wac *wacom)
1143 {
1144         struct input_dev *input = wacom->touch_input;
1145         unsigned char *data = wacom->data;
1146         int i;
1147         int current_num_contacts = data[61];
1148         int contacts_to_send = 0;
1149         int num_contacts_left = 4; /* maximum contacts per packet */
1150         int byte_per_packet = WACOM_BYTES_PER_24HDT_PACKET;
1151         int y_offset = 2;
1152
1153         if (wacom->features.type == WACOM_27QHDT) {
1154                 current_num_contacts = data[63];
1155                 num_contacts_left = 10;
1156                 byte_per_packet = WACOM_BYTES_PER_QHDTHID_PACKET;
1157                 y_offset = 0;
1158         }
1159
1160         /*
1161          * First packet resets the counter since only the first
1162          * packet in series will have non-zero current_num_contacts.
1163          */
1164         if (current_num_contacts)
1165                 wacom->num_contacts_left = current_num_contacts;
1166
1167         contacts_to_send = min(num_contacts_left, wacom->num_contacts_left);
1168
1169         for (i = 0; i < contacts_to_send; i++) {
1170                 int offset = (byte_per_packet * i) + 1;
1171                 bool touch = (data[offset] & 0x1) && !wacom->shared->stylus_in_proximity;
1172                 int slot = input_mt_get_slot_by_key(input, data[offset + 1]);
1173
1174                 if (slot < 0)
1175                         continue;
1176                 input_mt_slot(input, slot);
1177                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1178
1179                 if (touch) {
1180                         int t_x = get_unaligned_le16(&data[offset + 2]);
1181                         int t_y = get_unaligned_le16(&data[offset + 4 + y_offset]);
1182
1183                         input_report_abs(input, ABS_MT_POSITION_X, t_x);
1184                         input_report_abs(input, ABS_MT_POSITION_Y, t_y);
1185
1186                         if (wacom->features.type != WACOM_27QHDT) {
1187                                 int c_x = get_unaligned_le16(&data[offset + 4]);
1188                                 int c_y = get_unaligned_le16(&data[offset + 8]);
1189                                 int w = get_unaligned_le16(&data[offset + 10]);
1190                                 int h = get_unaligned_le16(&data[offset + 12]);
1191
1192                                 input_report_abs(input, ABS_MT_TOUCH_MAJOR, min(w,h));
1193                                 input_report_abs(input, ABS_MT_WIDTH_MAJOR,
1194                                                  min(w, h) + int_dist(t_x, t_y, c_x, c_y));
1195                                 input_report_abs(input, ABS_MT_WIDTH_MINOR, min(w, h));
1196                                 input_report_abs(input, ABS_MT_ORIENTATION, w > h);
1197                         }
1198                 }
1199         }
1200         input_mt_sync_frame(input);
1201
1202         wacom->num_contacts_left -= contacts_to_send;
1203         if (wacom->num_contacts_left <= 0) {
1204                 wacom->num_contacts_left = 0;
1205                 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1206         }
1207         return 1;
1208 }
1209
1210 static int wacom_mt_touch(struct wacom_wac *wacom)
1211 {
1212         struct input_dev *input = wacom->touch_input;
1213         unsigned char *data = wacom->data;
1214         int i;
1215         int current_num_contacts = data[2];
1216         int contacts_to_send = 0;
1217         int x_offset = 0;
1218
1219         /* MTTPC does not support Height and Width */
1220         if (wacom->features.type == MTTPC || wacom->features.type == MTTPC_B)
1221                 x_offset = -4;
1222
1223         /*
1224          * First packet resets the counter since only the first
1225          * packet in series will have non-zero current_num_contacts.
1226          */
1227         if (current_num_contacts)
1228                 wacom->num_contacts_left = current_num_contacts;
1229
1230         /* There are at most 5 contacts per packet */
1231         contacts_to_send = min(5, wacom->num_contacts_left);
1232
1233         for (i = 0; i < contacts_to_send; i++) {
1234                 int offset = (WACOM_BYTES_PER_MT_PACKET + x_offset) * i + 3;
1235                 bool touch = (data[offset] & 0x1) && !wacom->shared->stylus_in_proximity;
1236                 int id = get_unaligned_le16(&data[offset + 1]);
1237                 int slot = input_mt_get_slot_by_key(input, id);
1238
1239                 if (slot < 0)
1240                         continue;
1241
1242                 input_mt_slot(input, slot);
1243                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1244                 if (touch) {
1245                         int x = get_unaligned_le16(&data[offset + x_offset + 7]);
1246                         int y = get_unaligned_le16(&data[offset + x_offset + 9]);
1247                         input_report_abs(input, ABS_MT_POSITION_X, x);
1248                         input_report_abs(input, ABS_MT_POSITION_Y, y);
1249                 }
1250         }
1251         input_mt_sync_frame(input);
1252
1253         wacom->num_contacts_left -= contacts_to_send;
1254         if (wacom->num_contacts_left <= 0) {
1255                 wacom->num_contacts_left = 0;
1256                 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1257         }
1258         return 1;
1259 }
1260
1261 static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
1262 {
1263         struct input_dev *input = wacom->touch_input;
1264         unsigned char *data = wacom->data;
1265         int i;
1266
1267         for (i = 0; i < 2; i++) {
1268                 int p = data[1] & (1 << i);
1269                 bool touch = p && !wacom->shared->stylus_in_proximity;
1270
1271                 input_mt_slot(input, i);
1272                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1273                 if (touch) {
1274                         int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
1275                         int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;
1276
1277                         input_report_abs(input, ABS_MT_POSITION_X, x);
1278                         input_report_abs(input, ABS_MT_POSITION_Y, y);
1279                 }
1280         }
1281         input_mt_sync_frame(input);
1282
1283         /* keep touch state for pen event */
1284         wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1285
1286         return 1;
1287 }
1288
1289 static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
1290 {
1291         unsigned char *data = wacom->data;
1292         struct input_dev *input = wacom->touch_input;
1293         bool prox = !wacom->shared->stylus_in_proximity;
1294         int x = 0, y = 0;
1295
1296         if (wacom->features.touch_max > 1 || len > WACOM_PKGLEN_TPC2FG)
1297                 return 0;
1298
1299         if (len == WACOM_PKGLEN_TPC1FG) {
1300                 prox = prox && (data[0] & 0x01);
1301                 x = get_unaligned_le16(&data[1]);
1302                 y = get_unaligned_le16(&data[3]);
1303         } else if (len == WACOM_PKGLEN_TPC1FG_B) {
1304                 prox = prox && (data[2] & 0x01);
1305                 x = get_unaligned_le16(&data[3]);
1306                 y = get_unaligned_le16(&data[5]);
1307         } else {
1308                 prox = prox && (data[1] & 0x01);
1309                 x = le16_to_cpup((__le16 *)&data[2]);
1310                 y = le16_to_cpup((__le16 *)&data[4]);
1311         }
1312
1313         if (prox) {
1314                 input_report_abs(input, ABS_X, x);
1315                 input_report_abs(input, ABS_Y, y);
1316         }
1317         input_report_key(input, BTN_TOUCH, prox);
1318
1319         /* keep touch state for pen events */
1320         wacom->shared->touch_down = prox;
1321
1322         return 1;
1323 }
1324
1325 static int wacom_tpc_pen(struct wacom_wac *wacom)
1326 {
1327         unsigned char *data = wacom->data;
1328         struct input_dev *input = wacom->pen_input;
1329         bool prox = data[1] & 0x20;
1330
1331         if (!wacom->shared->stylus_in_proximity) /* first in prox */
1332                 /* Going into proximity select tool */
1333                 wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
1334
1335         /* keep pen state for touch events */
1336         wacom->shared->stylus_in_proximity = prox;
1337
1338         /* send pen events only when touch is up or forced out */
1339         if (!wacom->shared->touch_down) {
1340                 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
1341                 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
1342                 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
1343                 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
1344                 input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x07) << 8) | data[6]);
1345                 input_report_key(input, BTN_TOUCH, data[1] & 0x05);
1346                 input_report_key(input, wacom->tool[0], prox);
1347                 return 1;
1348         }
1349
1350         return 0;
1351 }
1352
1353 static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
1354 {
1355         unsigned char *data = wacom->data;
1356
1357         if (wacom->pen_input)
1358                 dev_dbg(wacom->pen_input->dev.parent,
1359                         "%s: received report #%d\n", __func__, data[0]);
1360         else if (wacom->touch_input)
1361                 dev_dbg(wacom->touch_input->dev.parent,
1362                         "%s: received report #%d\n", __func__, data[0]);
1363
1364         switch (len) {
1365         case WACOM_PKGLEN_TPC1FG:
1366                 return wacom_tpc_single_touch(wacom, len);
1367
1368         case WACOM_PKGLEN_TPC2FG:
1369                 return wacom_tpc_mt_touch(wacom);
1370
1371         case WACOM_PKGLEN_PENABLED:
1372                 return wacom_tpc_pen(wacom);
1373
1374         default:
1375                 switch (data[0]) {
1376                 case WACOM_REPORT_TPC1FG:
1377                 case WACOM_REPORT_TPCHID:
1378                 case WACOM_REPORT_TPCST:
1379                 case WACOM_REPORT_TPC1FGE:
1380                         return wacom_tpc_single_touch(wacom, len);
1381
1382                 case WACOM_REPORT_TPCMT:
1383                 case WACOM_REPORT_TPCMT2:
1384                         return wacom_mt_touch(wacom);
1385
1386                 case WACOM_REPORT_PENABLED:
1387                         return wacom_tpc_pen(wacom);
1388                 }
1389         }
1390
1391         return 0;
1392 }
1393
1394 static void wacom_map_usage(struct input_dev *input, struct hid_usage *usage,
1395                 struct hid_field *field, __u8 type, __u16 code, int fuzz)
1396 {
1397         int fmin = field->logical_minimum;
1398         int fmax = field->logical_maximum;
1399
1400         usage->type = type;
1401         usage->code = code;
1402
1403         set_bit(type, input->evbit);
1404
1405         switch (type) {
1406         case EV_ABS:
1407                 input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
1408                 input_abs_set_res(input, code,
1409                                   hidinput_calc_abs_res(field, code));
1410                 break;
1411         case EV_KEY:
1412                 input_set_capability(input, EV_KEY, code);
1413                 break;
1414         case EV_MSC:
1415                 input_set_capability(input, EV_MSC, code);
1416                 break;
1417         }
1418 }
1419
1420 static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
1421                 struct hid_field *field, struct hid_usage *usage)
1422 {
1423         struct wacom *wacom = hid_get_drvdata(hdev);
1424         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1425         struct input_dev *input = wacom_wac->pen_input;
1426
1427         switch (usage->hid) {
1428         case HID_GD_X:
1429                 wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 4);
1430                 break;
1431         case HID_GD_Y:
1432                 wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 4);
1433                 break;
1434         case HID_DG_TIPPRESSURE:
1435                 wacom_map_usage(input, usage, field, EV_ABS, ABS_PRESSURE, 0);
1436                 break;
1437         case HID_DG_INRANGE:
1438                 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOOL_PEN, 0);
1439                 break;
1440         case HID_DG_INVERT:
1441                 wacom_map_usage(input, usage, field, EV_KEY,
1442                                 BTN_TOOL_RUBBER, 0);
1443                 break;
1444         case HID_DG_ERASER:
1445         case HID_DG_TIPSWITCH:
1446                 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
1447                 break;
1448         case HID_DG_BARRELSWITCH:
1449                 wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS, 0);
1450                 break;
1451         case HID_DG_BARRELSWITCH2:
1452                 wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS2, 0);
1453                 break;
1454         case HID_DG_TOOLSERIALNUMBER:
1455                 wacom_map_usage(input, usage, field, EV_MSC, MSC_SERIAL, 0);
1456                 break;
1457         }
1458 }
1459
1460 static int wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
1461                 struct hid_usage *usage, __s32 value)
1462 {
1463         struct wacom *wacom = hid_get_drvdata(hdev);
1464         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1465         struct input_dev *input = wacom_wac->pen_input;
1466
1467         /* checking which Tool / tip switch to send */
1468         switch (usage->hid) {
1469         case HID_DG_INRANGE:
1470                 wacom_wac->hid_data.inrange_state = value;
1471                 return 0;
1472         case HID_DG_INVERT:
1473                 wacom_wac->hid_data.invert_state = value;
1474                 return 0;
1475         case HID_DG_ERASER:
1476         case HID_DG_TIPSWITCH:
1477                 wacom_wac->hid_data.tipswitch |= value;
1478                 return 0;
1479         }
1480
1481         /* send pen events only when touch is up or forced out */
1482         if (!usage->type || wacom_wac->shared->touch_down)
1483                 return 0;
1484
1485         input_event(input, usage->type, usage->code, value);
1486
1487         return 0;
1488 }
1489
1490 static void wacom_wac_pen_pre_report(struct hid_device *hdev,
1491                 struct hid_report *report)
1492 {
1493         return;
1494 }
1495
1496 static void wacom_wac_pen_report(struct hid_device *hdev,
1497                 struct hid_report *report)
1498 {
1499         struct wacom *wacom = hid_get_drvdata(hdev);
1500         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1501         struct input_dev *input = wacom_wac->pen_input;
1502         bool prox = wacom_wac->hid_data.inrange_state;
1503
1504         if (!wacom_wac->shared->stylus_in_proximity) /* first in prox */
1505                 /* Going into proximity select tool */
1506                 wacom_wac->tool[0] = wacom_wac->hid_data.invert_state ?
1507                                                 BTN_TOOL_RUBBER : BTN_TOOL_PEN;
1508
1509         /* keep pen state for touch events */
1510         wacom_wac->shared->stylus_in_proximity = prox;
1511
1512         /* send pen events only when touch is up or forced out */
1513         if (!wacom_wac->shared->touch_down) {
1514                 input_report_key(input, BTN_TOUCH,
1515                                 wacom_wac->hid_data.tipswitch);
1516                 input_report_key(input, wacom_wac->tool[0], prox);
1517
1518                 wacom_wac->hid_data.tipswitch = false;
1519
1520                 input_sync(input);
1521         }
1522 }
1523
1524 static void wacom_wac_finger_usage_mapping(struct hid_device *hdev,
1525                 struct hid_field *field, struct hid_usage *usage)
1526 {
1527         struct wacom *wacom = hid_get_drvdata(hdev);
1528         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1529         struct wacom_features *features = &wacom_wac->features;
1530         struct input_dev *input = wacom_wac->touch_input;
1531         unsigned touch_max = wacom_wac->features.touch_max;
1532
1533         switch (usage->hid) {
1534         case HID_GD_X:
1535                 features->last_slot_field = usage->hid;
1536                 if (touch_max == 1)
1537                         wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 4);
1538                 else
1539                         wacom_map_usage(input, usage, field, EV_ABS,
1540                                         ABS_MT_POSITION_X, 4);
1541                 break;
1542         case HID_GD_Y:
1543                 features->last_slot_field = usage->hid;
1544                 if (touch_max == 1)
1545                         wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 4);
1546                 else
1547                         wacom_map_usage(input, usage, field, EV_ABS,
1548                                         ABS_MT_POSITION_Y, 4);
1549                 break;
1550         case HID_DG_WIDTH:
1551         case HID_DG_HEIGHT:
1552                 features->last_slot_field = usage->hid;
1553                 wacom_map_usage(input, usage, field, EV_ABS, ABS_MT_TOUCH_MAJOR, 0);
1554                 wacom_map_usage(input, usage, field, EV_ABS, ABS_MT_TOUCH_MINOR, 0);
1555                 input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0);
1556                 break;
1557         case HID_DG_CONTACTID:
1558                 features->last_slot_field = usage->hid;
1559                 break;
1560         case HID_DG_INRANGE:
1561                 features->last_slot_field = usage->hid;
1562                 break;
1563         case HID_DG_INVERT:
1564                 features->last_slot_field = usage->hid;
1565                 break;
1566         case HID_DG_TIPSWITCH:
1567                 features->last_slot_field = usage->hid;
1568                 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
1569                 break;
1570         case HID_DG_CONTACTCOUNT:
1571                 wacom_wac->hid_data.cc_report = field->report->id;
1572                 wacom_wac->hid_data.cc_index = field->index;
1573                 wacom_wac->hid_data.cc_value_index = usage->usage_index;
1574                 break;
1575         }
1576 }
1577
1578 static void wacom_wac_finger_slot(struct wacom_wac *wacom_wac,
1579                 struct input_dev *input)
1580 {
1581         struct hid_data *hid_data = &wacom_wac->hid_data;
1582         bool mt = wacom_wac->features.touch_max > 1;
1583         bool prox = hid_data->tipswitch &&
1584                     !wacom_wac->shared->stylus_in_proximity;
1585
1586         wacom_wac->hid_data.num_received++;
1587         if (wacom_wac->hid_data.num_received > wacom_wac->hid_data.num_expected)
1588                 return;
1589
1590         if (mt) {
1591                 int slot;
1592
1593                 slot = input_mt_get_slot_by_key(input, hid_data->id);
1594                 input_mt_slot(input, slot);
1595                 input_mt_report_slot_state(input, MT_TOOL_FINGER, prox);
1596         }
1597         else {
1598                 input_report_key(input, BTN_TOUCH, prox);
1599         }
1600
1601         if (prox) {
1602                 input_report_abs(input, mt ? ABS_MT_POSITION_X : ABS_X,
1603                                  hid_data->x);
1604                 input_report_abs(input, mt ? ABS_MT_POSITION_Y : ABS_Y,
1605                                  hid_data->y);
1606
1607                 if (test_bit(ABS_MT_TOUCH_MAJOR, input->absbit)) {
1608                         input_report_abs(input, ABS_MT_TOUCH_MAJOR, max(hid_data->width, hid_data->height));
1609                         input_report_abs(input, ABS_MT_TOUCH_MINOR, min(hid_data->width, hid_data->height));
1610                         if (hid_data->width != hid_data->height)
1611                                 input_report_abs(input, ABS_MT_ORIENTATION, hid_data->width <= hid_data->height ? 0 : 1);
1612                 }
1613         }
1614 }
1615
1616 static int wacom_wac_finger_event(struct hid_device *hdev,
1617                 struct hid_field *field, struct hid_usage *usage, __s32 value)
1618 {
1619         struct wacom *wacom = hid_get_drvdata(hdev);
1620         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1621
1622         switch (usage->hid) {
1623         case HID_GD_X:
1624                 wacom_wac->hid_data.x = value;
1625                 break;
1626         case HID_GD_Y:
1627                 wacom_wac->hid_data.y = value;
1628                 break;
1629         case HID_DG_WIDTH:
1630                 wacom_wac->hid_data.width = value;
1631                 break;
1632         case HID_DG_HEIGHT:
1633                 wacom_wac->hid_data.height = value;
1634                 break;
1635         case HID_DG_CONTACTID:
1636                 wacom_wac->hid_data.id = value;
1637                 break;
1638         case HID_DG_TIPSWITCH:
1639                 wacom_wac->hid_data.tipswitch = value;
1640                 break;
1641         }
1642
1643
1644         if (usage->usage_index + 1 == field->report_count) {
1645                 if (usage->hid == wacom_wac->features.last_slot_field)
1646                         wacom_wac_finger_slot(wacom_wac, wacom_wac->touch_input);
1647         }
1648
1649         return 0;
1650 }
1651
1652 static void wacom_wac_finger_pre_report(struct hid_device *hdev,
1653                 struct hid_report *report)
1654 {
1655         struct wacom *wacom = hid_get_drvdata(hdev);
1656         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1657         struct hid_data* hid_data = &wacom_wac->hid_data;
1658
1659         if (hid_data->cc_report != 0 &&
1660             hid_data->cc_report != report->id) {
1661                 int i;
1662
1663                 hid_data->cc_report = report->id;
1664                 hid_data->cc_index = -1;
1665                 hid_data->cc_value_index = -1;
1666
1667                 for (i = 0; i < report->maxfield; i++) {
1668                         struct hid_field *field = report->field[i];
1669                         int j;
1670
1671                         for (j = 0; j < field->maxusage; j++) {
1672                                 if (field->usage[j].hid == HID_DG_CONTACTCOUNT) {
1673                                         hid_data->cc_index = i;
1674                                         hid_data->cc_value_index = j;
1675
1676                                         /* break */
1677                                         i = report->maxfield;
1678                                         j = field->maxusage;
1679                                 }
1680                         }
1681                 }
1682         }
1683         if (hid_data->cc_report != 0 &&
1684             hid_data->cc_index >= 0) {
1685                 struct hid_field *field = report->field[hid_data->cc_index];
1686                 int value = field->value[hid_data->cc_value_index];
1687                 if (value)
1688                         hid_data->num_expected = value;
1689         }
1690         else {
1691                 hid_data->num_expected = wacom_wac->features.touch_max;
1692         }
1693 }
1694
1695 static void wacom_wac_finger_report(struct hid_device *hdev,
1696                 struct hid_report *report)
1697 {
1698         struct wacom *wacom = hid_get_drvdata(hdev);
1699         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1700         struct input_dev *input = wacom_wac->touch_input;
1701         unsigned touch_max = wacom_wac->features.touch_max;
1702
1703         /* If more packets of data are expected, give us a chance to
1704          * process them rather than immediately syncing a partial
1705          * update.
1706          */
1707         if (wacom_wac->hid_data.num_received < wacom_wac->hid_data.num_expected)
1708                 return;
1709
1710         if (touch_max > 1)
1711                 input_mt_sync_frame(input);
1712
1713         input_sync(input);
1714         wacom_wac->hid_data.num_received = 0;
1715
1716         /* keep touch state for pen event */
1717         wacom_wac->shared->touch_down = wacom_wac_finger_count_touches(wacom_wac);
1718 }
1719
1720 void wacom_wac_usage_mapping(struct hid_device *hdev,
1721                 struct hid_field *field, struct hid_usage *usage)
1722 {
1723         struct wacom *wacom = hid_get_drvdata(hdev);
1724         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1725
1726         /* currently, only direct devices have proper hid report descriptors */
1727         __set_bit(INPUT_PROP_DIRECT, wacom_wac->pen_input->propbit);
1728         __set_bit(INPUT_PROP_DIRECT, wacom_wac->touch_input->propbit);
1729
1730         if (WACOM_PEN_FIELD(field))
1731                 return wacom_wac_pen_usage_mapping(hdev, field, usage);
1732
1733         if (WACOM_FINGER_FIELD(field))
1734                 return wacom_wac_finger_usage_mapping(hdev, field, usage);
1735 }
1736
1737 int wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
1738                 struct hid_usage *usage, __s32 value)
1739 {
1740         struct wacom *wacom = hid_get_drvdata(hdev);
1741
1742         if (wacom->wacom_wac.features.type != HID_GENERIC)
1743                 return 0;
1744
1745         if (WACOM_PEN_FIELD(field))
1746                 return wacom_wac_pen_event(hdev, field, usage, value);
1747
1748         if (WACOM_FINGER_FIELD(field))
1749                 return wacom_wac_finger_event(hdev, field, usage, value);
1750
1751         return 0;
1752 }
1753
1754 static void wacom_report_events(struct hid_device *hdev, struct hid_report *report)
1755 {
1756         int r;
1757
1758         for (r = 0; r < report->maxfield; r++) {
1759                 struct hid_field *field;
1760                 unsigned count, n;
1761
1762                 field = report->field[r];
1763                 count = field->report_count;
1764
1765                 if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
1766                         continue;
1767
1768                 for (n = 0; n < count; n++)
1769                         wacom_wac_event(hdev, field, &field->usage[n], field->value[n]);
1770         }
1771 }
1772
1773 void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
1774 {
1775         struct wacom *wacom = hid_get_drvdata(hdev);
1776         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1777         struct hid_field *field = report->field[0];
1778
1779         if (wacom_wac->features.type != HID_GENERIC)
1780                 return;
1781
1782         if (WACOM_PEN_FIELD(field))
1783                 wacom_wac_pen_pre_report(hdev, report);
1784
1785         if (WACOM_FINGER_FIELD(field))
1786                 wacom_wac_finger_pre_report(hdev, report);
1787
1788         wacom_report_events(hdev, report);
1789
1790         if (WACOM_PEN_FIELD(field))
1791                 return wacom_wac_pen_report(hdev, report);
1792
1793         if (WACOM_FINGER_FIELD(field))
1794                 return wacom_wac_finger_report(hdev, report);
1795 }
1796
1797 static int wacom_bpt_touch(struct wacom_wac *wacom)
1798 {
1799         struct wacom_features *features = &wacom->features;
1800         struct input_dev *input = wacom->touch_input;
1801         struct input_dev *pad_input = wacom->pad_input;
1802         unsigned char *data = wacom->data;
1803         int i;
1804
1805         if (data[0] != 0x02)
1806             return 0;
1807
1808         for (i = 0; i < 2; i++) {
1809                 int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
1810                 bool touch = data[offset + 3] & 0x80;
1811
1812                 /*
1813                  * Touch events need to be disabled while stylus is
1814                  * in proximity because user's hand is resting on touchpad
1815                  * and sending unwanted events.  User expects tablet buttons
1816                  * to continue working though.
1817                  */
1818                 touch = touch && !wacom->shared->stylus_in_proximity;
1819
1820                 input_mt_slot(input, i);
1821                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1822                 if (touch) {
1823                         int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
1824                         int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
1825                         if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
1826                                 x <<= 5;
1827                                 y <<= 5;
1828                         }
1829                         input_report_abs(input, ABS_MT_POSITION_X, x);
1830                         input_report_abs(input, ABS_MT_POSITION_Y, y);
1831                 }
1832         }
1833
1834         input_mt_sync_frame(input);
1835
1836         input_report_key(pad_input, BTN_LEFT, (data[1] & 0x08) != 0);
1837         input_report_key(pad_input, BTN_FORWARD, (data[1] & 0x04) != 0);
1838         input_report_key(pad_input, BTN_BACK, (data[1] & 0x02) != 0);
1839         input_report_key(pad_input, BTN_RIGHT, (data[1] & 0x01) != 0);
1840         wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1841
1842         return 1;
1843 }
1844
1845 static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
1846 {
1847         struct wacom_features *features = &wacom->features;
1848         struct input_dev *input = wacom->touch_input;
1849         bool touch = data[1] & 0x80;
1850         int slot = input_mt_get_slot_by_key(input, data[0]);
1851
1852         if (slot < 0)
1853                 return;
1854
1855         touch = touch && !wacom->shared->stylus_in_proximity;
1856
1857         input_mt_slot(input, slot);
1858         input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1859
1860         if (touch) {
1861                 int x = (data[2] << 4) | (data[4] >> 4);
1862                 int y = (data[3] << 4) | (data[4] & 0x0f);
1863                 int width, height;
1864
1865                 if (features->type >= INTUOSPS && features->type <= INTUOSHT2) {
1866                         width  = data[5] * 100;
1867                         height = data[6] * 100;
1868                 } else {
1869                         /*
1870                          * "a" is a scaled-down area which we assume is
1871                          * roughly circular and which can be described as:
1872                          * a=(pi*r^2)/C.
1873                          */
1874                         int a = data[5];
1875                         int x_res = input_abs_get_res(input, ABS_MT_POSITION_X);
1876                         int y_res = input_abs_get_res(input, ABS_MT_POSITION_Y);
1877                         width = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
1878                         height = width * y_res / x_res;
1879                 }
1880
1881                 input_report_abs(input, ABS_MT_POSITION_X, x);
1882                 input_report_abs(input, ABS_MT_POSITION_Y, y);
1883                 input_report_abs(input, ABS_MT_TOUCH_MAJOR, width);
1884                 input_report_abs(input, ABS_MT_TOUCH_MINOR, height);
1885         }
1886 }
1887
1888 static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
1889 {
1890         struct input_dev *input = wacom->pad_input;
1891         struct wacom_features *features = &wacom->features;
1892
1893         if (features->type == INTUOSHT || features->type == INTUOSHT2) {
1894                 input_report_key(input, BTN_LEFT, (data[1] & 0x02) != 0);
1895                 input_report_key(input, BTN_BACK, (data[1] & 0x08) != 0);
1896         } else {
1897                 input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
1898                 input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
1899         }
1900         input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
1901         input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
1902 }
1903
1904 static int wacom_bpt3_touch(struct wacom_wac *wacom)
1905 {
1906         unsigned char *data = wacom->data;
1907         int count = data[1] & 0x07;
1908         int  touch_changed = 0, i;
1909
1910         if (data[0] != 0x02)
1911             return 0;
1912
1913         /* data has up to 7 fixed sized 8-byte messages starting at data[2] */
1914         for (i = 0; i < count; i++) {
1915                 int offset = (8 * i) + 2;
1916                 int msg_id = data[offset];
1917
1918                 if (msg_id >= 2 && msg_id <= 17) {
1919                         wacom_bpt3_touch_msg(wacom, data + offset);
1920                         touch_changed++;
1921                 } else if (msg_id == 128)
1922                         wacom_bpt3_button_msg(wacom, data + offset);
1923
1924         }
1925
1926         /* only update touch if we actually have a touchpad and touch data changed */
1927         if (wacom->touch_registered && touch_changed) {
1928                 input_mt_sync_frame(wacom->touch_input);
1929                 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1930         }
1931
1932         return 1;
1933 }
1934
1935 static int wacom_bpt_pen(struct wacom_wac *wacom)
1936 {
1937         struct wacom_features *features = &wacom->features;
1938         struct input_dev *input = wacom->pen_input;
1939         unsigned char *data = wacom->data;
1940         int prox = 0, x = 0, y = 0, p = 0, d = 0, pen = 0, btn1 = 0, btn2 = 0;
1941
1942         if (data[0] != WACOM_REPORT_PENABLED)
1943             return 0;
1944
1945         prox = (data[1] & 0x20) == 0x20;
1946
1947         /*
1948          * All reports shared between PEN and RUBBER tool must be
1949          * forced to a known starting value (zero) when transitioning to
1950          * out-of-prox.
1951          *
1952          * If not reset then, to userspace, it will look like lost events
1953          * if new tool comes in-prox with same values as previous tool sent.
1954          *
1955          * Hardware does report zero in most out-of-prox cases but not all.
1956          */
1957         if (!wacom->shared->stylus_in_proximity) {
1958                 if (data[1] & 0x08) {
1959                         wacom->tool[0] = BTN_TOOL_RUBBER;
1960                         wacom->id[0] = ERASER_DEVICE_ID;
1961                 } else {
1962                         wacom->tool[0] = BTN_TOOL_PEN;
1963                         wacom->id[0] = STYLUS_DEVICE_ID;
1964                 }
1965         }
1966
1967         wacom->shared->stylus_in_proximity = prox;
1968         if (wacom->shared->touch_down)
1969                 return 0;
1970
1971         if (prox) {
1972                 x = le16_to_cpup((__le16 *)&data[2]);
1973                 y = le16_to_cpup((__le16 *)&data[4]);
1974                 p = le16_to_cpup((__le16 *)&data[6]);
1975                 /*
1976                  * Convert distance from out prox to distance from tablet.
1977                  * distance will be greater than distance_max once
1978                  * touching and applying pressure; do not report negative
1979                  * distance.
1980                  */
1981                 if (data[8] <= features->distance_max)
1982                         d = features->distance_max - data[8];
1983
1984                 pen = data[1] & 0x01;
1985                 btn1 = data[1] & 0x02;
1986                 btn2 = data[1] & 0x04;
1987         } else {
1988                 wacom->id[0] = 0;
1989         }
1990
1991         input_report_key(input, BTN_TOUCH, pen);
1992         input_report_key(input, BTN_STYLUS, btn1);
1993         input_report_key(input, BTN_STYLUS2, btn2);
1994
1995         input_report_abs(input, ABS_X, x);
1996         input_report_abs(input, ABS_Y, y);
1997         input_report_abs(input, ABS_PRESSURE, p);
1998         input_report_abs(input, ABS_DISTANCE, d);
1999
2000         input_report_key(input, wacom->tool[0], prox); /* PEN or RUBBER */
2001         input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */
2002
2003         return 1;
2004 }
2005
2006 static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
2007 {
2008         struct wacom_features *features = &wacom->features;
2009
2010         if ((features->type == INTUOSHT2) &&
2011             (features->device_type & WACOM_DEVICETYPE_PEN))
2012                 return wacom_intuos_irq(wacom);
2013         else if (len == WACOM_PKGLEN_BBTOUCH)
2014                 return wacom_bpt_touch(wacom);
2015         else if (len == WACOM_PKGLEN_BBTOUCH3)
2016                 return wacom_bpt3_touch(wacom);
2017         else if (len == WACOM_PKGLEN_BBFUN || len == WACOM_PKGLEN_BBPEN)
2018                 return wacom_bpt_pen(wacom);
2019
2020         return 0;
2021 }
2022
2023 static void wacom_bamboo_pad_pen_event(struct wacom_wac *wacom,
2024                 unsigned char *data)
2025 {
2026         unsigned char prefix;
2027
2028         /*
2029          * We need to reroute the event from the debug interface to the
2030          * pen interface.
2031          * We need to add the report ID to the actual pen report, so we
2032          * temporary overwrite the first byte to prevent having to kzalloc/kfree
2033          * and memcpy the report.
2034          */
2035         prefix = data[0];
2036         data[0] = WACOM_REPORT_BPAD_PEN;
2037
2038         /*
2039          * actually reroute the event.
2040          * No need to check if wacom->shared->pen is valid, hid_input_report()
2041          * will check for us.
2042          */
2043         hid_input_report(wacom->shared->pen, HID_INPUT_REPORT, data,
2044                          WACOM_PKGLEN_PENABLED, 1);
2045
2046         data[0] = prefix;
2047 }
2048
2049 static int wacom_bamboo_pad_touch_event(struct wacom_wac *wacom,
2050                 unsigned char *data)
2051 {
2052         struct input_dev *input = wacom->touch_input;
2053         unsigned char *finger_data, prefix;
2054         unsigned id;
2055         int x, y;
2056         bool valid;
2057
2058         prefix = data[0];
2059
2060         for (id = 0; id < wacom->features.touch_max; id++) {
2061                 valid = !!(prefix & BIT(id)) &&
2062                         !wacom->shared->stylus_in_proximity;
2063
2064                 input_mt_slot(input, id);
2065                 input_mt_report_slot_state(input, MT_TOOL_FINGER, valid);
2066
2067                 if (!valid)
2068                         continue;
2069
2070                 finger_data = data + 1 + id * 3;
2071                 x = finger_data[0] | ((finger_data[1] & 0x0f) << 8);
2072                 y = (finger_data[2] << 4) | (finger_data[1] >> 4);
2073
2074                 input_report_abs(input, ABS_MT_POSITION_X, x);
2075                 input_report_abs(input, ABS_MT_POSITION_Y, y);
2076         }
2077
2078         input_mt_sync_frame(input);
2079
2080         input_report_key(input, BTN_LEFT, prefix & 0x40);
2081         input_report_key(input, BTN_RIGHT, prefix & 0x80);
2082
2083         /* keep touch state for pen event */
2084         wacom->shared->touch_down = !!prefix &&
2085                                     !wacom->shared->stylus_in_proximity;
2086
2087         return 1;
2088 }
2089
2090 static int wacom_bamboo_pad_irq(struct wacom_wac *wacom, size_t len)
2091 {
2092         unsigned char *data = wacom->data;
2093
2094         if (!((len == WACOM_PKGLEN_BPAD_TOUCH) ||
2095               (len == WACOM_PKGLEN_BPAD_TOUCH_USB)) ||
2096             (data[0] != WACOM_REPORT_BPAD_TOUCH))
2097                 return 0;
2098
2099         if (data[1] & 0x01)
2100                 wacom_bamboo_pad_pen_event(wacom, &data[1]);
2101
2102         if (data[1] & 0x02)
2103                 return wacom_bamboo_pad_touch_event(wacom, &data[9]);
2104
2105         return 0;
2106 }
2107
2108 static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
2109 {
2110         unsigned char *data = wacom->data;
2111         int connected;
2112
2113         if (len != WACOM_PKGLEN_WIRELESS || data[0] != WACOM_REPORT_WL)
2114                 return 0;
2115
2116         connected = data[1] & 0x01;
2117         if (connected) {
2118                 int pid, battery, charging;
2119
2120                 if ((wacom->shared->type == INTUOSHT ||
2121                     wacom->shared->type == INTUOSHT2) &&
2122                     wacom->shared->touch_input &&
2123                     wacom->shared->touch_max) {
2124                         input_report_switch(wacom->shared->touch_input,
2125                                         SW_MUTE_DEVICE, data[5] & 0x40);
2126                         input_sync(wacom->shared->touch_input);
2127                 }
2128
2129                 pid = get_unaligned_be16(&data[6]);
2130                 battery = (data[5] & 0x3f) * 100 / 31;
2131                 charging = !!(data[5] & 0x80);
2132                 if (wacom->pid != pid) {
2133                         wacom->pid = pid;
2134                         wacom_schedule_work(wacom);
2135                 }
2136
2137                 if (wacom->shared->type)
2138                         wacom_notify_battery(wacom, battery, charging, 1, 0);
2139
2140         } else if (wacom->pid != 0) {
2141                 /* disconnected while previously connected */
2142                 wacom->pid = 0;
2143                 wacom_schedule_work(wacom);
2144                 wacom_notify_battery(wacom, 0, 0, 0, 0);
2145         }
2146
2147         return 0;
2148 }
2149
2150 static int wacom_status_irq(struct wacom_wac *wacom_wac, size_t len)
2151 {
2152         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
2153         struct wacom_features *features = &wacom_wac->features;
2154         unsigned char *data = wacom_wac->data;
2155
2156         if (data[0] != WACOM_REPORT_USB)
2157                 return 0;
2158
2159         if ((features->type == INTUOSHT ||
2160             features->type == INTUOSHT2) &&
2161             wacom_wac->shared->touch_input &&
2162             features->touch_max) {
2163                 input_report_switch(wacom_wac->shared->touch_input,
2164                                     SW_MUTE_DEVICE, data[8] & 0x40);
2165                 input_sync(wacom_wac->shared->touch_input);
2166         }
2167
2168         if (data[9] & 0x02) { /* wireless module is attached */
2169                 int battery = (data[8] & 0x3f) * 100 / 31;
2170                 bool charging = !!(data[8] & 0x80);
2171
2172                 wacom_notify_battery(wacom_wac, battery, charging,
2173                                      battery || charging, 1);
2174
2175                 if (!wacom->battery &&
2176                     !(features->quirks & WACOM_QUIRK_BATTERY)) {
2177                         features->quirks |= WACOM_QUIRK_BATTERY;
2178                         INIT_WORK(&wacom->work, wacom_battery_work);
2179                         wacom_schedule_work(wacom_wac);
2180                 }
2181         }
2182         else if ((features->quirks & WACOM_QUIRK_BATTERY) &&
2183                  wacom->battery) {
2184                 features->quirks &= ~WACOM_QUIRK_BATTERY;
2185                 INIT_WORK(&wacom->work, wacom_battery_work);
2186                 wacom_schedule_work(wacom_wac);
2187                 wacom_notify_battery(wacom_wac, 0, 0, 0, 0);
2188         }
2189         return 0;
2190 }
2191
2192 void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
2193 {
2194         bool sync;
2195
2196         switch (wacom_wac->features.type) {
2197         case PENPARTNER:
2198                 sync = wacom_penpartner_irq(wacom_wac);
2199                 break;
2200
2201         case PL:
2202                 sync = wacom_pl_irq(wacom_wac);
2203                 break;
2204
2205         case WACOM_G4:
2206         case GRAPHIRE:
2207         case GRAPHIRE_BT:
2208         case WACOM_MO:
2209                 sync = wacom_graphire_irq(wacom_wac);
2210                 break;
2211
2212         case PTU:
2213                 sync = wacom_ptu_irq(wacom_wac);
2214                 break;
2215
2216         case DTU:
2217                 sync = wacom_dtu_irq(wacom_wac);
2218                 break;
2219
2220         case DTUS:
2221         case DTUSX:
2222                 sync = wacom_dtus_irq(wacom_wac);
2223                 break;
2224
2225         case INTUOS:
2226         case INTUOS3S:
2227         case INTUOS3:
2228         case INTUOS3L:
2229         case INTUOS4S:
2230         case INTUOS4:
2231         case INTUOS4L:
2232         case CINTIQ:
2233         case WACOM_BEE:
2234         case WACOM_13HD:
2235         case WACOM_21UX2:
2236         case WACOM_22HD:
2237         case WACOM_24HD:
2238         case WACOM_27QHD:
2239         case DTK:
2240         case CINTIQ_HYBRID:
2241         case CINTIQ_COMPANION_2:
2242                 sync = wacom_intuos_irq(wacom_wac);
2243                 break;
2244
2245         case INTUOS4WL:
2246                 sync = wacom_intuos_bt_irq(wacom_wac, len);
2247                 break;
2248
2249         case WACOM_24HDT:
2250         case WACOM_27QHDT:
2251                 sync = wacom_24hdt_irq(wacom_wac);
2252                 break;
2253
2254         case INTUOS5S:
2255         case INTUOS5:
2256         case INTUOS5L:
2257         case INTUOSPS:
2258         case INTUOSPM:
2259         case INTUOSPL:
2260                 if (len == WACOM_PKGLEN_BBTOUCH3)
2261                         sync = wacom_bpt3_touch(wacom_wac);
2262                 else if (wacom_wac->data[0] == WACOM_REPORT_USB)
2263                         sync = wacom_status_irq(wacom_wac, len);
2264                 else
2265                         sync = wacom_intuos_irq(wacom_wac);
2266                 break;
2267
2268         case TABLETPC:
2269         case TABLETPCE:
2270         case TABLETPC2FG:
2271         case MTSCREEN:
2272         case MTTPC:
2273         case MTTPC_B:
2274                 sync = wacom_tpc_irq(wacom_wac, len);
2275                 break;
2276
2277         case BAMBOO_PT:
2278         case BAMBOO_PEN:
2279         case BAMBOO_TOUCH:
2280         case INTUOSHT:
2281         case INTUOSHT2:
2282                 if (wacom_wac->data[0] == WACOM_REPORT_USB)
2283                         sync = wacom_status_irq(wacom_wac, len);
2284                 else
2285                         sync = wacom_bpt_irq(wacom_wac, len);
2286                 break;
2287
2288         case BAMBOO_PAD:
2289                 sync = wacom_bamboo_pad_irq(wacom_wac, len);
2290                 break;
2291
2292         case WIRELESS:
2293                 sync = wacom_wireless_irq(wacom_wac, len);
2294                 break;
2295
2296         case REMOTE:
2297                 if (wacom_wac->data[0] == WACOM_REPORT_DEVICE_LIST)
2298                         sync = wacom_remote_status_irq(wacom_wac, len);
2299                 else
2300                         sync = wacom_remote_irq(wacom_wac, len);
2301                 break;
2302
2303         default:
2304                 sync = false;
2305                 break;
2306         }
2307
2308         if (sync) {
2309                 if (wacom_wac->pen_input)
2310                         input_sync(wacom_wac->pen_input);
2311                 if (wacom_wac->touch_input)
2312                         input_sync(wacom_wac->touch_input);
2313                 if (wacom_wac->pad_input)
2314                         input_sync(wacom_wac->pad_input);
2315         }
2316 }
2317
2318 static void wacom_setup_basic_pro_pen(struct wacom_wac *wacom_wac)
2319 {
2320         struct input_dev *input_dev = wacom_wac->pen_input;
2321
2322         input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
2323
2324         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2325         __set_bit(BTN_STYLUS, input_dev->keybit);
2326         __set_bit(BTN_STYLUS2, input_dev->keybit);
2327
2328         input_set_abs_params(input_dev, ABS_DISTANCE,
2329                              0, wacom_wac->features.distance_max, 0, 0);
2330 }
2331
2332 static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
2333 {
2334         struct input_dev *input_dev = wacom_wac->pen_input;
2335
2336         wacom_setup_basic_pro_pen(wacom_wac);
2337
2338         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2339         __set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
2340         __set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
2341         __set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
2342
2343         input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
2344         input_set_abs_params(input_dev, ABS_TILT_X, -64, 63, 0, 0);
2345         input_abs_set_res(input_dev, ABS_TILT_X, 57);
2346         input_set_abs_params(input_dev, ABS_TILT_Y, -64, 63, 0, 0);
2347         input_abs_set_res(input_dev, ABS_TILT_Y, 57);
2348 }
2349
2350 static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
2351 {
2352         struct input_dev *input_dev = wacom_wac->pen_input;
2353
2354         input_set_capability(input_dev, EV_REL, REL_WHEEL);
2355
2356         wacom_setup_cintiq(wacom_wac);
2357
2358         __set_bit(BTN_LEFT, input_dev->keybit);
2359         __set_bit(BTN_RIGHT, input_dev->keybit);
2360         __set_bit(BTN_MIDDLE, input_dev->keybit);
2361         __set_bit(BTN_SIDE, input_dev->keybit);
2362         __set_bit(BTN_EXTRA, input_dev->keybit);
2363         __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
2364         __set_bit(BTN_TOOL_LENS, input_dev->keybit);
2365
2366         input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
2367         input_abs_set_res(input_dev, ABS_RZ, 287);
2368         input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
2369 }
2370
2371 void wacom_setup_device_quirks(struct wacom *wacom)
2372 {
2373         struct wacom_features *features = &wacom->wacom_wac.features;
2374
2375         /* The pen and pad share the same interface on most devices */
2376         if (features->type == GRAPHIRE_BT || features->type == WACOM_G4 ||
2377             features->type == DTUS ||
2378             (features->type >= INTUOS3S && features->type <= WACOM_MO)) {
2379                 if (features->device_type & WACOM_DEVICETYPE_PEN)
2380                         features->device_type |= WACOM_DEVICETYPE_PAD;
2381         }
2382
2383         /* touch device found but size is not defined. use default */
2384         if (features->device_type & WACOM_DEVICETYPE_TOUCH && !features->x_max) {
2385                 features->x_max = 1023;
2386                 features->y_max = 1023;
2387         }
2388
2389         /*
2390          * Intuos5/Pro and Bamboo 3rd gen have no useful data about its
2391          * touch interface in its HID descriptor. If this is the touch
2392          * interface (PacketSize of WACOM_PKGLEN_BBTOUCH3), override the
2393          * tablet values.
2394          */
2395         if ((features->type >= INTUOS5S && features->type <= INTUOSPL) ||
2396                 (features->type >= INTUOSHT && features->type <= BAMBOO_PT)) {
2397                 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
2398                         if (features->touch_max)
2399                                 features->device_type |= WACOM_DEVICETYPE_TOUCH;
2400                         if (features->type >= INTUOSHT && features->type <= BAMBOO_PT)
2401                                 features->device_type |= WACOM_DEVICETYPE_PAD;
2402
2403                         features->x_max = 4096;
2404                         features->y_max = 4096;
2405                 }
2406                 else if (features->pktlen == WACOM_PKGLEN_BBTOUCH) {
2407                         features->device_type |= WACOM_DEVICETYPE_PAD;
2408                 }
2409         }
2410
2411         /*
2412          * Raw Wacom-mode pen and touch events both come from interface
2413          * 0, whose HID descriptor has an application usage of 0xFF0D
2414          * (i.e., WACOM_VENDORDEFINED_PEN). We route pen packets back
2415          * out through the HID_GENERIC device created for interface 1,
2416          * so rewrite this one to be of type WACOM_DEVICETYPE_TOUCH.
2417          */
2418         if (features->type == BAMBOO_PAD)
2419                 features->device_type = WACOM_DEVICETYPE_TOUCH;
2420
2421         if (features->type == REMOTE)
2422                 features->device_type = WACOM_DEVICETYPE_PAD;
2423
2424         if (wacom->hdev->bus == BUS_BLUETOOTH)
2425                 features->quirks |= WACOM_QUIRK_BATTERY;
2426
2427         /* quirk for bamboo touch with 2 low res touches */
2428         if ((features->type == BAMBOO_PT || features->type == BAMBOO_TOUCH) &&
2429             features->pktlen == WACOM_PKGLEN_BBTOUCH) {
2430                 features->x_max <<= 5;
2431                 features->y_max <<= 5;
2432                 features->x_fuzz <<= 5;
2433                 features->y_fuzz <<= 5;
2434                 features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
2435         }
2436
2437         if (features->type == WIRELESS) {
2438                 if (features->device_type == WACOM_DEVICETYPE_WL_MONITOR) {
2439                         features->quirks |= WACOM_QUIRK_BATTERY;
2440                 }
2441         }
2442 }
2443
2444 int wacom_setup_pen_input_capabilities(struct input_dev *input_dev,
2445                                    struct wacom_wac *wacom_wac)
2446 {
2447         struct wacom_features *features = &wacom_wac->features;
2448
2449         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2450
2451         if (!(features->device_type & WACOM_DEVICETYPE_PEN))
2452                 return -ENODEV;
2453
2454         if (features->type == HID_GENERIC)
2455                 /* setup has already been done */
2456                 return 0;
2457
2458         __set_bit(BTN_TOUCH, input_dev->keybit);
2459         __set_bit(ABS_MISC, input_dev->absbit);
2460
2461         input_set_abs_params(input_dev, ABS_X, features->x_min,
2462                              features->x_max, features->x_fuzz, 0);
2463         input_set_abs_params(input_dev, ABS_Y, features->y_min,
2464                              features->y_max, features->y_fuzz, 0);
2465         input_set_abs_params(input_dev, ABS_PRESSURE, 0,
2466                 features->pressure_max, features->pressure_fuzz, 0);
2467
2468         /* penabled devices have fixed resolution for each model */
2469         input_abs_set_res(input_dev, ABS_X, features->x_resolution);
2470         input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
2471
2472
2473         switch (features->type) {
2474         case GRAPHIRE_BT:
2475                 __clear_bit(ABS_MISC, input_dev->absbit);
2476
2477         case WACOM_MO:
2478         case WACOM_G4:
2479                 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
2480                                               features->distance_max,
2481                                               0, 0);
2482                 /* fall through */
2483
2484         case GRAPHIRE:
2485                 input_set_capability(input_dev, EV_REL, REL_WHEEL);
2486
2487                 __set_bit(BTN_LEFT, input_dev->keybit);
2488                 __set_bit(BTN_RIGHT, input_dev->keybit);
2489                 __set_bit(BTN_MIDDLE, input_dev->keybit);
2490
2491                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2492                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2493                 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
2494                 __set_bit(BTN_STYLUS, input_dev->keybit);
2495                 __set_bit(BTN_STYLUS2, input_dev->keybit);
2496
2497                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2498                 break;
2499
2500         case WACOM_27QHD:
2501         case WACOM_24HD:
2502         case DTK:
2503         case WACOM_22HD:
2504         case WACOM_21UX2:
2505         case WACOM_BEE:
2506         case CINTIQ:
2507         case WACOM_13HD:
2508         case CINTIQ_HYBRID:
2509         case CINTIQ_COMPANION_2:
2510                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
2511                 input_abs_set_res(input_dev, ABS_Z, 287);
2512                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
2513                 wacom_setup_cintiq(wacom_wac);
2514                 break;
2515
2516         case INTUOS3:
2517         case INTUOS3L:
2518         case INTUOS3S:
2519         case INTUOS4:
2520         case INTUOS4WL:
2521         case INTUOS4L:
2522         case INTUOS4S:
2523                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
2524                 input_abs_set_res(input_dev, ABS_Z, 287);
2525                 /* fall through */
2526
2527         case INTUOS:
2528                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2529
2530                 wacom_setup_intuos(wacom_wac);
2531                 break;
2532
2533         case INTUOS5:
2534         case INTUOS5L:
2535         case INTUOSPM:
2536         case INTUOSPL:
2537         case INTUOS5S:
2538         case INTUOSPS:
2539                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2540
2541                 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
2542                                       features->distance_max,
2543                                       0, 0);
2544
2545                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
2546                 input_abs_set_res(input_dev, ABS_Z, 287);
2547
2548                 wacom_setup_intuos(wacom_wac);
2549                 break;
2550
2551         case WACOM_24HDT:
2552         case WACOM_27QHDT:
2553         case MTSCREEN:
2554         case MTTPC:
2555         case MTTPC_B:
2556         case TABLETPC2FG:
2557         case TABLETPC:
2558         case TABLETPCE:
2559                 __clear_bit(ABS_MISC, input_dev->absbit);
2560                 /* fall through */
2561
2562         case DTUS:
2563         case DTUSX:
2564         case PL:
2565         case DTU:
2566                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2567                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2568                 __set_bit(BTN_STYLUS, input_dev->keybit);
2569                 __set_bit(BTN_STYLUS2, input_dev->keybit);
2570
2571                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
2572                 break;
2573
2574         case PTU:
2575                 __set_bit(BTN_STYLUS2, input_dev->keybit);
2576                 /* fall through */
2577
2578         case PENPARTNER:
2579                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2580                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2581                 __set_bit(BTN_STYLUS, input_dev->keybit);
2582
2583                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2584                 break;
2585
2586         case INTUOSHT:
2587         case BAMBOO_PT:
2588         case BAMBOO_PEN:
2589         case INTUOSHT2:
2590                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2591
2592                 if (features->type == INTUOSHT2) {
2593                         wacom_setup_basic_pro_pen(wacom_wac);
2594                 } else {
2595                         __clear_bit(ABS_MISC, input_dev->absbit);
2596                         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2597                         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2598                         __set_bit(BTN_STYLUS, input_dev->keybit);
2599                         __set_bit(BTN_STYLUS2, input_dev->keybit);
2600                         input_set_abs_params(input_dev, ABS_DISTANCE, 0,
2601                                       features->distance_max,
2602                                       0, 0);
2603                 }
2604                 break;
2605         case BAMBOO_PAD:
2606                 __clear_bit(ABS_MISC, input_dev->absbit);
2607                 break;
2608         }
2609         return 0;
2610 }
2611
2612 int wacom_setup_touch_input_capabilities(struct input_dev *input_dev,
2613                                          struct wacom_wac *wacom_wac)
2614 {
2615         struct wacom_features *features = &wacom_wac->features;
2616
2617         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2618
2619         if (!(features->device_type & WACOM_DEVICETYPE_TOUCH))
2620                 return -ENODEV;
2621
2622         if (features->type == HID_GENERIC)
2623                 /* setup has already been done */
2624                 return 0;
2625
2626         __set_bit(BTN_TOUCH, input_dev->keybit);
2627
2628         if (features->touch_max == 1) {
2629                 input_set_abs_params(input_dev, ABS_X, 0,
2630                         features->x_max, features->x_fuzz, 0);
2631                 input_set_abs_params(input_dev, ABS_Y, 0,
2632                         features->y_max, features->y_fuzz, 0);
2633                 input_abs_set_res(input_dev, ABS_X,
2634                                   features->x_resolution);
2635                 input_abs_set_res(input_dev, ABS_Y,
2636                                   features->y_resolution);
2637         }
2638         else if (features->touch_max > 1) {
2639                 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
2640                         features->x_max, features->x_fuzz, 0);
2641                 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
2642                         features->y_max, features->y_fuzz, 0);
2643                 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
2644                                   features->x_resolution);
2645                 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
2646                                   features->y_resolution);
2647         }
2648
2649         switch (features->type) {
2650         case INTUOS5:
2651         case INTUOS5L:
2652         case INTUOSPM:
2653         case INTUOSPL:
2654         case INTUOS5S:
2655         case INTUOSPS:
2656                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2657
2658                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
2659                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, features->y_max, 0, 0);
2660                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
2661                 break;
2662
2663         case WACOM_24HDT:
2664                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
2665                 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
2666                 input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
2667                 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
2668                 /* fall through */
2669
2670         case WACOM_27QHDT:
2671         case MTSCREEN:
2672         case MTTPC:
2673         case MTTPC_B:
2674         case TABLETPC2FG:
2675                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_DIRECT);
2676                 /*fall through */
2677
2678         case TABLETPC:
2679         case TABLETPCE:
2680                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
2681                 break;
2682
2683         case INTUOSHT:
2684         case INTUOSHT2:
2685                 input_dev->evbit[0] |= BIT_MASK(EV_SW);
2686                 __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
2687                 /* fall through */
2688
2689         case BAMBOO_PT:
2690         case BAMBOO_TOUCH:
2691                 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
2692                         input_set_abs_params(input_dev,
2693                                      ABS_MT_TOUCH_MAJOR,
2694                                      0, features->x_max, 0, 0);
2695                         input_set_abs_params(input_dev,
2696                                      ABS_MT_TOUCH_MINOR,
2697                                      0, features->y_max, 0, 0);
2698                 }
2699                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
2700                 break;
2701
2702         case BAMBOO_PAD:
2703                 input_mt_init_slots(input_dev, features->touch_max,
2704                                     INPUT_MT_POINTER);
2705                 __set_bit(BTN_LEFT, input_dev->keybit);
2706                 __set_bit(BTN_RIGHT, input_dev->keybit);
2707                 break;
2708         }
2709         return 0;
2710 }
2711
2712 static void wacom_setup_numbered_buttons(struct input_dev *input_dev,
2713                                 int button_count)
2714 {
2715         int i;
2716
2717         for (i = 0; i < button_count && i < 10; i++)
2718                 __set_bit(BTN_0 + i, input_dev->keybit);
2719         for (i = 10; i < button_count && i < 16; i++)
2720                 __set_bit(BTN_A + (i-10), input_dev->keybit);
2721         for (i = 16; i < button_count && i < 18; i++)
2722                 __set_bit(BTN_BASE + (i-16), input_dev->keybit);
2723 }
2724
2725 static void wacom_report_numbered_buttons(struct input_dev *input_dev,
2726                                 int button_count, int mask)
2727 {
2728         int i;
2729
2730         for (i = 0; i < button_count && i < 10; i++)
2731                 input_report_key(input_dev, BTN_0 + i, mask & (1 << i));
2732         for (i = 10; i < button_count && i < 16; i++)
2733                 input_report_key(input_dev, BTN_A + (i-10), mask & (1 << i));
2734         for (i = 16; i < button_count && i < 18; i++)
2735                 input_report_key(input_dev, BTN_BASE + (i-16), mask & (1 << i));
2736 }
2737
2738 int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
2739                                    struct wacom_wac *wacom_wac)
2740 {
2741         struct wacom_features *features = &wacom_wac->features;
2742
2743         if (!(features->device_type & WACOM_DEVICETYPE_PAD))
2744                 return -ENODEV;
2745
2746         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2747
2748         /* kept for making legacy xf86-input-wacom working with the wheels */
2749         __set_bit(ABS_MISC, input_dev->absbit);
2750
2751         /* kept for making legacy xf86-input-wacom accepting the pad */
2752         input_set_abs_params(input_dev, ABS_X, 0, 1, 0, 0);
2753         input_set_abs_params(input_dev, ABS_Y, 0, 1, 0, 0);
2754
2755         /* kept for making udev and libwacom accepting the pad */
2756         __set_bit(BTN_STYLUS, input_dev->keybit);
2757
2758         wacom_setup_numbered_buttons(input_dev, features->numbered_buttons);
2759
2760         switch (features->type) {
2761
2762         case CINTIQ_HYBRID:
2763         case CINTIQ_COMPANION_2:
2764         case DTK:
2765         case DTUS:
2766         case GRAPHIRE_BT:
2767                 break;
2768
2769         case WACOM_MO:
2770                 __set_bit(BTN_BACK, input_dev->keybit);
2771                 __set_bit(BTN_LEFT, input_dev->keybit);
2772                 __set_bit(BTN_FORWARD, input_dev->keybit);
2773                 __set_bit(BTN_RIGHT, input_dev->keybit);
2774                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2775                 break;
2776
2777         case WACOM_G4:
2778                 __set_bit(BTN_BACK, input_dev->keybit);
2779                 __set_bit(BTN_FORWARD, input_dev->keybit);
2780                 input_set_capability(input_dev, EV_REL, REL_WHEEL);
2781                 break;
2782
2783         case WACOM_24HD:
2784                 __set_bit(KEY_PROG1, input_dev->keybit);
2785                 __set_bit(KEY_PROG2, input_dev->keybit);
2786                 __set_bit(KEY_PROG3, input_dev->keybit);
2787
2788                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2789                 input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
2790                 break;
2791
2792         case WACOM_27QHD:
2793                 __set_bit(KEY_PROG1, input_dev->keybit);
2794                 __set_bit(KEY_PROG2, input_dev->keybit);
2795                 __set_bit(KEY_PROG3, input_dev->keybit);
2796                 input_set_abs_params(input_dev, ABS_X, -2048, 2048, 0, 0);
2797                 input_abs_set_res(input_dev, ABS_X, 1024); /* points/g */
2798                 input_set_abs_params(input_dev, ABS_Y, -2048, 2048, 0, 0);
2799                 input_abs_set_res(input_dev, ABS_Y, 1024);
2800                 input_set_abs_params(input_dev, ABS_Z, -2048, 2048, 0, 0);
2801                 input_abs_set_res(input_dev, ABS_Z, 1024);
2802                 __set_bit(INPUT_PROP_ACCELEROMETER, input_dev->propbit);
2803                 break;
2804
2805         case WACOM_22HD:
2806                 __set_bit(KEY_PROG1, input_dev->keybit);
2807                 __set_bit(KEY_PROG2, input_dev->keybit);
2808                 __set_bit(KEY_PROG3, input_dev->keybit);
2809                 /* fall through */
2810
2811         case WACOM_21UX2:
2812         case WACOM_BEE:
2813         case CINTIQ:
2814                 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
2815                 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2816                 break;
2817
2818         case WACOM_13HD:
2819                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2820                 break;
2821
2822         case INTUOS3:
2823         case INTUOS3L:
2824                 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2825                 /* fall through */
2826
2827         case INTUOS3S:
2828                 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
2829                 break;
2830
2831         case INTUOS5:
2832         case INTUOS5L:
2833         case INTUOSPM:
2834         case INTUOSPL:
2835         case INTUOS5S:
2836         case INTUOSPS:
2837                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2838                 break;
2839
2840         case INTUOS4WL:
2841                 /*
2842                  * For Bluetooth devices, the udev rule does not work correctly
2843                  * for pads unless we add a stylus capability, which forces
2844                  * ID_INPUT_TABLET to be set.
2845                  */
2846                 __set_bit(BTN_STYLUS, input_dev->keybit);
2847                 /* fall through */
2848
2849         case INTUOS4:
2850         case INTUOS4L:
2851         case INTUOS4S:
2852                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2853                 break;
2854
2855         case INTUOSHT:
2856         case BAMBOO_PT:
2857         case BAMBOO_TOUCH:
2858         case INTUOSHT2:
2859                 __clear_bit(ABS_MISC, input_dev->absbit);
2860
2861                 __set_bit(BTN_LEFT, input_dev->keybit);
2862                 __set_bit(BTN_FORWARD, input_dev->keybit);
2863                 __set_bit(BTN_BACK, input_dev->keybit);
2864                 __set_bit(BTN_RIGHT, input_dev->keybit);
2865
2866                 break;
2867
2868         case REMOTE:
2869                 input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
2870                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2871                 break;
2872
2873         default:
2874                 /* no pad supported */
2875                 return -ENODEV;
2876         }
2877         return 0;
2878 }
2879
2880 static const struct wacom_features wacom_features_0x00 =
2881         { "Wacom Penpartner", 5040, 3780, 255, 0,
2882           PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
2883 static const struct wacom_features wacom_features_0x10 =
2884         { "Wacom Graphire", 10206, 7422, 511, 63,
2885           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2886 static const struct wacom_features wacom_features_0x81 =
2887         { "Wacom Graphire BT", 16704, 12064, 511, 32,
2888           GRAPHIRE_BT, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES, 2 };
2889 static const struct wacom_features wacom_features_0x11 =
2890         { "Wacom Graphire2 4x5", 10206, 7422, 511, 63,
2891           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2892 static const struct wacom_features wacom_features_0x12 =
2893         { "Wacom Graphire2 5x7", 13918, 10206, 511, 63,
2894           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2895 static const struct wacom_features wacom_features_0x13 =
2896         { "Wacom Graphire3", 10208, 7424, 511, 63,
2897           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2898 static const struct wacom_features wacom_features_0x14 =
2899         { "Wacom Graphire3 6x8", 16704, 12064, 511, 63,
2900           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2901 static const struct wacom_features wacom_features_0x15 =
2902         { "Wacom Graphire4 4x5", 10208, 7424, 511, 63,
2903           WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2904 static const struct wacom_features wacom_features_0x16 =
2905         { "Wacom Graphire4 6x8", 16704, 12064, 511, 63,
2906           WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2907 static const struct wacom_features wacom_features_0x17 =
2908         { "Wacom BambooFun 4x5", 14760, 9225, 511, 63,
2909           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2910 static const struct wacom_features wacom_features_0x18 =
2911         { "Wacom BambooFun 6x8", 21648, 13530, 511, 63,
2912           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2913 static const struct wacom_features wacom_features_0x19 =
2914         { "Wacom Bamboo1 Medium", 16704, 12064, 511, 63,
2915           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2916 static const struct wacom_features wacom_features_0x60 =
2917         { "Wacom Volito", 5104, 3712, 511, 63,
2918           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2919 static const struct wacom_features wacom_features_0x61 =
2920         { "Wacom PenStation2", 3250, 2320, 255, 63,
2921           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2922 static const struct wacom_features wacom_features_0x62 =
2923         { "Wacom Volito2 4x5", 5104, 3712, 511, 63,
2924           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2925 static const struct wacom_features wacom_features_0x63 =
2926         { "Wacom Volito2 2x3", 3248, 2320, 511, 63,
2927           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2928 static const struct wacom_features wacom_features_0x64 =
2929         { "Wacom PenPartner2", 3250, 2320, 511, 63,
2930           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2931 static const struct wacom_features wacom_features_0x65 =
2932         { "Wacom Bamboo", 14760, 9225, 511, 63,
2933           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2934 static const struct wacom_features wacom_features_0x69 =
2935         { "Wacom Bamboo1", 5104, 3712, 511, 63,
2936           GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
2937 static const struct wacom_features wacom_features_0x6A =
2938         { "Wacom Bamboo1 4x6", 14760, 9225, 1023, 63,
2939           GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2940 static const struct wacom_features wacom_features_0x6B =
2941         { "Wacom Bamboo1 5x8", 21648, 13530, 1023, 63,
2942           GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2943 static const struct wacom_features wacom_features_0x20 =
2944         { "Wacom Intuos 4x5", 12700, 10600, 1023, 31,
2945           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2946 static const struct wacom_features wacom_features_0x21 =
2947         { "Wacom Intuos 6x8", 20320, 16240, 1023, 31,
2948           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2949 static const struct wacom_features wacom_features_0x22 =
2950         { "Wacom Intuos 9x12", 30480, 24060, 1023, 31,
2951           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2952 static const struct wacom_features wacom_features_0x23 =
2953         { "Wacom Intuos 12x12", 30480, 31680, 1023, 31,
2954           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2955 static const struct wacom_features wacom_features_0x24 =
2956         { "Wacom Intuos 12x18", 45720, 31680, 1023, 31,
2957           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2958 static const struct wacom_features wacom_features_0x30 =
2959         { "Wacom PL400", 5408, 4056, 255, 0,
2960           PL, WACOM_PL_RES, WACOM_PL_RES };
2961 static const struct wacom_features wacom_features_0x31 =
2962         { "Wacom PL500", 6144, 4608, 255, 0,
2963           PL, WACOM_PL_RES, WACOM_PL_RES };
2964 static const struct wacom_features wacom_features_0x32 =
2965         { "Wacom PL600", 6126, 4604, 255, 0,
2966           PL, WACOM_PL_RES, WACOM_PL_RES };
2967 static const struct wacom_features wacom_features_0x33 =
2968         { "Wacom PL600SX", 6260, 5016, 255, 0,
2969           PL, WACOM_PL_RES, WACOM_PL_RES };
2970 static const struct wacom_features wacom_features_0x34 =
2971         { "Wacom PL550", 6144, 4608, 511, 0,
2972           PL, WACOM_PL_RES, WACOM_PL_RES };
2973 static const struct wacom_features wacom_features_0x35 =
2974         { "Wacom PL800", 7220, 5780, 511, 0,
2975           PL, WACOM_PL_RES, WACOM_PL_RES };
2976 static const struct wacom_features wacom_features_0x37 =
2977         { "Wacom PL700", 6758, 5406, 511, 0,
2978           PL, WACOM_PL_RES, WACOM_PL_RES };
2979 static const struct wacom_features wacom_features_0x38 =
2980         { "Wacom PL510", 6282, 4762, 511, 0,
2981           PL, WACOM_PL_RES, WACOM_PL_RES };
2982 static const struct wacom_features wacom_features_0x39 =
2983         { "Wacom DTU710", 34080, 27660, 511, 0,
2984           PL, WACOM_PL_RES, WACOM_PL_RES };
2985 static const struct wacom_features wacom_features_0xC4 =
2986         { "Wacom DTF521", 6282, 4762, 511, 0,
2987           PL, WACOM_PL_RES, WACOM_PL_RES };
2988 static const struct wacom_features wacom_features_0xC0 =
2989         { "Wacom DTF720", 6858, 5506, 511, 0,
2990           PL, WACOM_PL_RES, WACOM_PL_RES };
2991 static const struct wacom_features wacom_features_0xC2 =
2992         { "Wacom DTF720a", 6858, 5506, 511, 0,
2993           PL, WACOM_PL_RES, WACOM_PL_RES };
2994 static const struct wacom_features wacom_features_0x03 =
2995         { "Wacom Cintiq Partner", 20480, 15360, 511, 0,
2996           PTU, WACOM_PL_RES, WACOM_PL_RES };
2997 static const struct wacom_features wacom_features_0x41 =
2998         { "Wacom Intuos2 4x5", 12700, 10600, 1023, 31,
2999           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3000 static const struct wacom_features wacom_features_0x42 =
3001         { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
3002           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3003 static const struct wacom_features wacom_features_0x43 =
3004         { "Wacom Intuos2 9x12", 30480, 24060, 1023, 31,
3005           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3006 static const struct wacom_features wacom_features_0x44 =
3007         { "Wacom Intuos2 12x12", 30480, 31680, 1023, 31,
3008           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3009 static const struct wacom_features wacom_features_0x45 =
3010         { "Wacom Intuos2 12x18", 45720, 31680, 1023, 31,
3011           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3012 static const struct wacom_features wacom_features_0xB0 =
3013         { "Wacom Intuos3 4x5", 25400, 20320, 1023, 63,
3014           INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
3015 static const struct wacom_features wacom_features_0xB1 =
3016         { "Wacom Intuos3 6x8", 40640, 30480, 1023, 63,
3017           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3018 static const struct wacom_features wacom_features_0xB2 =
3019         { "Wacom Intuos3 9x12", 60960, 45720, 1023, 63,
3020           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3021 static const struct wacom_features wacom_features_0xB3 =
3022         { "Wacom Intuos3 12x12", 60960, 60960, 1023, 63,
3023           INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3024 static const struct wacom_features wacom_features_0xB4 =
3025         { "Wacom Intuos3 12x19", 97536, 60960, 1023, 63,
3026           INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3027 static const struct wacom_features wacom_features_0xB5 =
3028         { "Wacom Intuos3 6x11", 54204, 31750, 1023, 63,
3029           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3030 static const struct wacom_features wacom_features_0xB7 =
3031         { "Wacom Intuos3 4x6", 31496, 19685, 1023, 63,
3032           INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
3033 static const struct wacom_features wacom_features_0xB8 =
3034         { "Wacom Intuos4 4x6", 31496, 19685, 2047, 63,
3035           INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
3036 static const struct wacom_features wacom_features_0xB9 =
3037         { "Wacom Intuos4 6x9", 44704, 27940, 2047, 63,
3038           INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3039 static const struct wacom_features wacom_features_0xBA =
3040         { "Wacom Intuos4 8x13", 65024, 40640, 2047, 63,
3041           INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3042 static const struct wacom_features wacom_features_0xBB =
3043         { "Wacom Intuos4 12x19", 97536, 60960, 2047, 63,
3044           INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3045 static const struct wacom_features wacom_features_0xBC =
3046         { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
3047           INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3048 static const struct wacom_features wacom_features_0xBD =
3049         { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
3050           INTUOS4WL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3051 static const struct wacom_features wacom_features_0x26 =
3052         { "Wacom Intuos5 touch S", 31496, 19685, 2047, 63,
3053           INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16 };
3054 static const struct wacom_features wacom_features_0x27 =
3055         { "Wacom Intuos5 touch M", 44704, 27940, 2047, 63,
3056           INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
3057 static const struct wacom_features wacom_features_0x28 =
3058         { "Wacom Intuos5 touch L", 65024, 40640, 2047, 63,
3059           INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
3060 static const struct wacom_features wacom_features_0x29 =
3061         { "Wacom Intuos5 S", 31496, 19685, 2047, 63,
3062           INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
3063 static const struct wacom_features wacom_features_0x2A =
3064         { "Wacom Intuos5 M", 44704, 27940, 2047, 63,
3065           INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3066 static const struct wacom_features wacom_features_0x314 =
3067         { "Wacom Intuos Pro S", 31496, 19685, 2047, 63,
3068           INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16,
3069           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3070 static const struct wacom_features wacom_features_0x315 =
3071         { "Wacom Intuos Pro M", 44704, 27940, 2047, 63,
3072           INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
3073           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3074 static const struct wacom_features wacom_features_0x317 =
3075         { "Wacom Intuos Pro L", 65024, 40640, 2047, 63,
3076           INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
3077           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3078 static const struct wacom_features wacom_features_0xF4 =
3079         { "Wacom Cintiq 24HD", 104080, 65200, 2047, 63,
3080           WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
3081           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3082 static const struct wacom_features wacom_features_0xF8 =
3083         { "Wacom Cintiq 24HD touch", 104080, 65200, 2047, 63, /* Pen */
3084           WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
3085           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3086           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
3087 static const struct wacom_features wacom_features_0xF6 =
3088         { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
3089           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
3090           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3091 static const struct wacom_features wacom_features_0x32A =
3092         { "Wacom Cintiq 27QHD", 119740, 67520, 2047, 63,
3093           WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
3094           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3095 static const struct wacom_features wacom_features_0x32B =
3096         { "Wacom Cintiq 27QHD touch", 119740, 67520, 2047, 63,
3097           WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
3098           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3099           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32C };
3100 static const struct wacom_features wacom_features_0x32C =
3101         { "Wacom Cintiq 27QHD touch", .type = WACOM_27QHDT,
3102           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32B, .touch_max = 10 };
3103 static const struct wacom_features wacom_features_0x3F =
3104         { "Wacom Cintiq 21UX", 87200, 65600, 1023, 63,
3105           CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3106 static const struct wacom_features wacom_features_0xC5 =
3107         { "Wacom Cintiq 20WSX", 86680, 54180, 1023, 63,
3108           WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
3109 static const struct wacom_features wacom_features_0xC6 =
3110         { "Wacom Cintiq 12WX", 53020, 33440, 1023, 63,
3111           WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
3112 static const struct wacom_features wacom_features_0x304 =
3113         { "Wacom Cintiq 13HD", 59152, 33448, 1023, 63,
3114           WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
3115           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3116 static const struct wacom_features wacom_features_0x333 =
3117         { "Wacom Cintiq 13HD touch", 59152, 33448, 2047, 63,
3118           WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
3119           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3120           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x335 };
3121 static const struct wacom_features wacom_features_0x335 =
3122         { "Wacom Cintiq 13HD touch", .type = WACOM_24HDT, /* Touch */
3123           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x333, .touch_max = 10,
3124           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3125 static const struct wacom_features wacom_features_0xC7 =
3126         { "Wacom DTU1931", 37832, 30305, 511, 0,
3127           PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3128 static const struct wacom_features wacom_features_0xCE =
3129         { "Wacom DTU2231", 47864, 27011, 511, 0,
3130           DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3131           .check_for_hid_type = true, .hid_type = HID_TYPE_USBMOUSE };
3132 static const struct wacom_features wacom_features_0xF0 =
3133         { "Wacom DTU1631", 34623, 19553, 511, 0,
3134           DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3135 static const struct wacom_features wacom_features_0xFB =
3136         { "Wacom DTU1031", 21896, 13760, 511, 0,
3137           DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
3138           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
3139 static const struct wacom_features wacom_features_0x32F =
3140         { "Wacom DTU1031X", 22472, 12728, 511, 0,
3141           DTUSX, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 0,
3142           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
3143 static const struct wacom_features wacom_features_0x336 =
3144         { "Wacom DTU1141", 23472, 13203, 1023, 0,
3145           DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
3146           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
3147 static const struct wacom_features wacom_features_0x57 =
3148         { "Wacom DTK2241", 95640, 54060, 2047, 63,
3149           DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
3150           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3151 static const struct wacom_features wacom_features_0x59 = /* Pen */
3152         { "Wacom DTH2242", 95640, 54060, 2047, 63,
3153           DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
3154           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3155           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
3156 static const struct wacom_features wacom_features_0x5D = /* Touch */
3157         { "Wacom DTH2242",       .type = WACOM_24HDT,
3158           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10,
3159           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3160 static const struct wacom_features wacom_features_0xCC =
3161         { "Wacom Cintiq 21UX2", 86800, 65200, 2047, 63,
3162           WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
3163           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3164 static const struct wacom_features wacom_features_0xFA =
3165         { "Wacom Cintiq 22HD", 95440, 53860, 2047, 63,
3166           WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
3167           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3168 static const struct wacom_features wacom_features_0x5B =
3169         { "Wacom Cintiq 22HDT", 95440, 53860, 2047, 63,
3170           WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
3171           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3172           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e };
3173 static const struct wacom_features wacom_features_0x5E =
3174         { "Wacom Cintiq 22HDT", .type = WACOM_24HDT,
3175           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10,
3176           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3177 static const struct wacom_features wacom_features_0x90 =
3178         { "Wacom ISDv4 90", 26202, 16325, 255, 0,
3179           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3180 static const struct wacom_features wacom_features_0x93 =
3181         { "Wacom ISDv4 93", 26202, 16325, 255, 0,
3182           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3183 static const struct wacom_features wacom_features_0x97 =
3184         { "Wacom ISDv4 97", 26202, 16325, 511, 0,
3185           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3186 static const struct wacom_features wacom_features_0x9A =
3187         { "Wacom ISDv4 9A", 26202, 16325, 255, 0,
3188           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3189 static const struct wacom_features wacom_features_0x9F =
3190         { "Wacom ISDv4 9F", 26202, 16325, 255, 0,
3191           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3192 static const struct wacom_features wacom_features_0xE2 =
3193         { "Wacom ISDv4 E2", 26202, 16325, 255, 0,
3194           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3195 static const struct wacom_features wacom_features_0xE3 =
3196         { "Wacom ISDv4 E3", 26202, 16325, 255, 0,
3197           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3198 static const struct wacom_features wacom_features_0xE5 =
3199         { "Wacom ISDv4 E5", 26202, 16325, 255, 0,
3200           MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3201 static const struct wacom_features wacom_features_0xE6 =
3202         { "Wacom ISDv4 E6", 27760, 15694, 255, 0,
3203           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3204 static const struct wacom_features wacom_features_0xEC =
3205         { "Wacom ISDv4 EC", 25710, 14500, 255, 0,
3206           TABLETPC,    WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3207 static const struct wacom_features wacom_features_0xED =
3208         { "Wacom ISDv4 ED", 26202, 16325, 255, 0,
3209           TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3210 static const struct wacom_features wacom_features_0xEF =
3211         { "Wacom ISDv4 EF", 26202, 16325, 255, 0,
3212           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3213 static const struct wacom_features wacom_features_0x100 =
3214         { "Wacom ISDv4 100", 26202, 16325, 255, 0,
3215           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3216 static const struct wacom_features wacom_features_0x101 =
3217         { "Wacom ISDv4 101", 26202, 16325, 255, 0,
3218           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3219 static const struct wacom_features wacom_features_0x10D =
3220         { "Wacom ISDv4 10D", 26202, 16325, 255, 0,
3221           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3222 static const struct wacom_features wacom_features_0x10E =
3223         { "Wacom ISDv4 10E", 27760, 15694, 255, 0,
3224           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3225 static const struct wacom_features wacom_features_0x10F =
3226         { "Wacom ISDv4 10F", 27760, 15694, 255, 0,
3227           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3228 static const struct wacom_features wacom_features_0x116 =
3229         { "Wacom ISDv4 116", 26202, 16325, 255, 0,
3230           TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3231 static const struct wacom_features wacom_features_0x12C =
3232         { "Wacom ISDv4 12C", 27848, 15752, 2047, 0,
3233           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3234 static const struct wacom_features wacom_features_0x4001 =
3235         { "Wacom ISDv4 4001", 26202, 16325, 255, 0,
3236           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3237 static const struct wacom_features wacom_features_0x4004 =
3238         { "Wacom ISDv4 4004", 11060, 6220, 255, 0,
3239           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3240 static const struct wacom_features wacom_features_0x5000 =
3241         { "Wacom ISDv4 5000", 27848, 15752, 1023, 0,
3242           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3243 static const struct wacom_features wacom_features_0x5002 =
3244         { "Wacom ISDv4 5002", 29576, 16724, 1023, 0,
3245           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3246 static const struct wacom_features wacom_features_0x47 =
3247         { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
3248           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3249 static const struct wacom_features wacom_features_0x84 =
3250         { "Wacom Wireless Receiver", .type = WIRELESS, .touch_max = 16 };
3251 static const struct wacom_features wacom_features_0xD0 =
3252         { "Wacom Bamboo 2FG", 14720, 9200, 1023, 31,
3253           BAMBOO_TOUCH, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3254 static const struct wacom_features wacom_features_0xD1 =
3255         { "Wacom Bamboo 2FG 4x5", 14720, 9200, 1023, 31,
3256           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3257 static const struct wacom_features wacom_features_0xD2 =
3258         { "Wacom Bamboo Craft", 14720, 9200, 1023, 31,
3259           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3260 static const struct wacom_features wacom_features_0xD3 =
3261         { "Wacom Bamboo 2FG 6x8", 21648, 13700, 1023, 31,
3262           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3263 static const struct wacom_features wacom_features_0xD4 =
3264         { "Wacom Bamboo Pen", 14720, 9200, 1023, 31,
3265           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3266 static const struct wacom_features wacom_features_0xD5 =
3267         { "Wacom Bamboo Pen 6x8", 21648, 13700, 1023, 31,
3268           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3269 static const struct wacom_features wacom_features_0xD6 =
3270         { "Wacom BambooPT 2FG 4x5", 14720, 9200, 1023, 31,
3271           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3272 static const struct wacom_features wacom_features_0xD7 =
3273         { "Wacom BambooPT 2FG Small", 14720, 9200, 1023, 31,
3274           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3275 static const struct wacom_features wacom_features_0xD8 =
3276         { "Wacom Bamboo Comic 2FG", 21648, 13700, 1023, 31,
3277           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3278 static const struct wacom_features wacom_features_0xDA =
3279         { "Wacom Bamboo 2FG 4x5 SE", 14720, 9200, 1023, 31,
3280           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3281 static const struct wacom_features wacom_features_0xDB =
3282         { "Wacom Bamboo 2FG 6x8 SE", 21648, 13700, 1023, 31,
3283           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3284 static const struct wacom_features wacom_features_0xDD =
3285         { "Wacom Bamboo Connect", 14720, 9200, 1023, 31,
3286           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3287 static const struct wacom_features wacom_features_0xDE =
3288         { "Wacom Bamboo 16FG 4x5", 14720, 9200, 1023, 31,
3289           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
3290 static const struct wacom_features wacom_features_0xDF =
3291         { "Wacom Bamboo 16FG 6x8", 21648, 13700, 1023, 31,
3292           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
3293 static const struct wacom_features wacom_features_0x300 =
3294         { "Wacom Bamboo One S", 14720, 9225, 1023, 31,
3295           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3296 static const struct wacom_features wacom_features_0x301 =
3297         { "Wacom Bamboo One M", 21648, 13530, 1023, 31,
3298           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3299 static const struct wacom_features wacom_features_0x302 =
3300         { "Wacom Intuos PT S", 15200, 9500, 1023, 31,
3301           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
3302           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3303 static const struct wacom_features wacom_features_0x303 =
3304         { "Wacom Intuos PT M", 21600, 13500, 1023, 31,
3305           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
3306           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3307 static const struct wacom_features wacom_features_0x30E =
3308         { "Wacom Intuos S", 15200, 9500, 1023, 31,
3309           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3310           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3311 static const struct wacom_features wacom_features_0x6004 =
3312         { "ISD-V4", 12800, 8000, 255, 0,
3313           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3314 static const struct wacom_features wacom_features_0x307 =
3315         { "Wacom ISDv5 307", 59152, 33448, 2047, 63,
3316           CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
3317           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3318           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
3319 static const struct wacom_features wacom_features_0x309 =
3320         { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
3321           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10,
3322           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3323 static const struct wacom_features wacom_features_0x30A =
3324         { "Wacom ISDv5 30A", 59152, 33448, 2047, 63,
3325           CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
3326           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3327           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30C };
3328 static const struct wacom_features wacom_features_0x30C =
3329         { "Wacom ISDv5 30C", .type = WACOM_24HDT, /* Touch */
3330           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30A, .touch_max = 10,
3331           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3332 static const struct wacom_features wacom_features_0x318 =
3333         { "Wacom USB Bamboo PAD", 4095, 4095, /* Touch */
3334           .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
3335 static const struct wacom_features wacom_features_0x319 =
3336         { "Wacom Wireless Bamboo PAD", 4095, 4095, /* Touch */
3337           .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
3338 static const struct wacom_features wacom_features_0x325 =
3339         { "Wacom ISDv5 325", 59552, 33848, 2047, 63,
3340           CINTIQ_COMPANION_2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 11,
3341           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3342           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x326 };
3343 static const struct wacom_features wacom_features_0x326 = /* Touch */
3344         { "Wacom ISDv5 326", .type = HID_GENERIC, .oVid = USB_VENDOR_ID_WACOM,
3345           .oPid = 0x325 };
3346 static const struct wacom_features wacom_features_0x323 =
3347         { "Wacom Intuos P M", 21600, 13500, 1023, 31,
3348           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3349           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3350 static const struct wacom_features wacom_features_0x331 =
3351         { "Wacom Express Key Remote", .type = REMOTE,
3352           .numbered_buttons = 18, .check_for_hid_type = true,
3353           .hid_type = HID_TYPE_USBNONE };
3354 static const struct wacom_features wacom_features_0x33B =
3355         { "Wacom Intuos S 2", 15200, 9500, 2047, 63,
3356           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3357           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3358 static const struct wacom_features wacom_features_0x33C =
3359         { "Wacom Intuos PT S 2", 15200, 9500, 2047, 63,
3360           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
3361           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3362 static const struct wacom_features wacom_features_0x33D =
3363         { "Wacom Intuos P M 2", 21600, 13500, 2047, 63,
3364           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3365           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3366 static const struct wacom_features wacom_features_0x33E =
3367         { "Wacom Intuos PT M 2", 21600, 13500, 2047, 63,
3368           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
3369           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3370
3371 static const struct wacom_features wacom_features_HID_ANY_ID =
3372         { "Wacom HID", .type = HID_GENERIC };
3373
3374 #define USB_DEVICE_WACOM(prod)                                          \
3375         HID_DEVICE(BUS_USB, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3376         .driver_data = (kernel_ulong_t)&wacom_features_##prod
3377
3378 #define BT_DEVICE_WACOM(prod)                                           \
3379         HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3380         .driver_data = (kernel_ulong_t)&wacom_features_##prod
3381
3382 #define I2C_DEVICE_WACOM(prod)                                          \
3383         HID_DEVICE(BUS_I2C, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3384         .driver_data = (kernel_ulong_t)&wacom_features_##prod
3385
3386 #define USB_DEVICE_LENOVO(prod)                                 \
3387         HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),                     \
3388         .driver_data = (kernel_ulong_t)&wacom_features_##prod
3389
3390 const struct hid_device_id wacom_ids[] = {
3391         { USB_DEVICE_WACOM(0x00) },
3392         { USB_DEVICE_WACOM(0x03) },
3393         { USB_DEVICE_WACOM(0x10) },
3394         { USB_DEVICE_WACOM(0x11) },
3395         { USB_DEVICE_WACOM(0x12) },
3396         { USB_DEVICE_WACOM(0x13) },
3397         { USB_DEVICE_WACOM(0x14) },
3398         { USB_DEVICE_WACOM(0x15) },
3399         { USB_DEVICE_WACOM(0x16) },
3400         { USB_DEVICE_WACOM(0x17) },
3401         { USB_DEVICE_WACOM(0x18) },
3402         { USB_DEVICE_WACOM(0x19) },
3403         { USB_DEVICE_WACOM(0x20) },
3404         { USB_DEVICE_WACOM(0x21) },
3405         { USB_DEVICE_WACOM(0x22) },
3406         { USB_DEVICE_WACOM(0x23) },
3407         { USB_DEVICE_WACOM(0x24) },
3408         { USB_DEVICE_WACOM(0x26) },
3409         { USB_DEVICE_WACOM(0x27) },
3410         { USB_DEVICE_WACOM(0x28) },
3411         { USB_DEVICE_WACOM(0x29) },
3412         { USB_DEVICE_WACOM(0x2A) },
3413         { USB_DEVICE_WACOM(0x30) },
3414         { USB_DEVICE_WACOM(0x31) },
3415         { USB_DEVICE_WACOM(0x32) },
3416         { USB_DEVICE_WACOM(0x33) },
3417         { USB_DEVICE_WACOM(0x34) },
3418         { USB_DEVICE_WACOM(0x35) },
3419         { USB_DEVICE_WACOM(0x37) },
3420         { USB_DEVICE_WACOM(0x38) },
3421         { USB_DEVICE_WACOM(0x39) },
3422         { USB_DEVICE_WACOM(0x3F) },
3423         { USB_DEVICE_WACOM(0x41) },
3424         { USB_DEVICE_WACOM(0x42) },
3425         { USB_DEVICE_WACOM(0x43) },
3426         { USB_DEVICE_WACOM(0x44) },
3427         { USB_DEVICE_WACOM(0x45) },
3428         { USB_DEVICE_WACOM(0x47) },
3429         { USB_DEVICE_WACOM(0x57) },
3430         { USB_DEVICE_WACOM(0x59) },
3431         { USB_DEVICE_WACOM(0x5B) },
3432         { USB_DEVICE_WACOM(0x5D) },
3433         { USB_DEVICE_WACOM(0x5E) },
3434         { USB_DEVICE_WACOM(0x60) },
3435         { USB_DEVICE_WACOM(0x61) },
3436         { USB_DEVICE_WACOM(0x62) },
3437         { USB_DEVICE_WACOM(0x63) },
3438         { USB_DEVICE_WACOM(0x64) },
3439         { USB_DEVICE_WACOM(0x65) },
3440         { USB_DEVICE_WACOM(0x69) },
3441         { USB_DEVICE_WACOM(0x6A) },
3442         { USB_DEVICE_WACOM(0x6B) },
3443         { BT_DEVICE_WACOM(0x81) },
3444         { USB_DEVICE_WACOM(0x84) },
3445         { USB_DEVICE_WACOM(0x90) },
3446         { USB_DEVICE_WACOM(0x93) },
3447         { USB_DEVICE_WACOM(0x97) },
3448         { USB_DEVICE_WACOM(0x9A) },
3449         { USB_DEVICE_WACOM(0x9F) },
3450         { USB_DEVICE_WACOM(0xB0) },
3451         { USB_DEVICE_WACOM(0xB1) },
3452         { USB_DEVICE_WACOM(0xB2) },
3453         { USB_DEVICE_WACOM(0xB3) },
3454         { USB_DEVICE_WACOM(0xB4) },
3455         { USB_DEVICE_WACOM(0xB5) },
3456         { USB_DEVICE_WACOM(0xB7) },
3457         { USB_DEVICE_WACOM(0xB8) },
3458         { USB_DEVICE_WACOM(0xB9) },
3459         { USB_DEVICE_WACOM(0xBA) },
3460         { USB_DEVICE_WACOM(0xBB) },
3461         { USB_DEVICE_WACOM(0xBC) },
3462         { BT_DEVICE_WACOM(0xBD) },
3463         { USB_DEVICE_WACOM(0xC0) },
3464         { USB_DEVICE_WACOM(0xC2) },
3465         { USB_DEVICE_WACOM(0xC4) },
3466         { USB_DEVICE_WACOM(0xC5) },
3467         { USB_DEVICE_WACOM(0xC6) },
3468         { USB_DEVICE_WACOM(0xC7) },
3469         { USB_DEVICE_WACOM(0xCC) },
3470         { USB_DEVICE_WACOM(0xCE) },
3471         { USB_DEVICE_WACOM(0xD0) },
3472         { USB_DEVICE_WACOM(0xD1) },
3473         { USB_DEVICE_WACOM(0xD2) },
3474         { USB_DEVICE_WACOM(0xD3) },
3475         { USB_DEVICE_WACOM(0xD4) },
3476         { USB_DEVICE_WACOM(0xD5) },
3477         { USB_DEVICE_WACOM(0xD6) },
3478         { USB_DEVICE_WACOM(0xD7) },
3479         { USB_DEVICE_WACOM(0xD8) },
3480         { USB_DEVICE_WACOM(0xDA) },
3481         { USB_DEVICE_WACOM(0xDB) },
3482         { USB_DEVICE_WACOM(0xDD) },
3483         { USB_DEVICE_WACOM(0xDE) },
3484         { USB_DEVICE_WACOM(0xDF) },
3485         { USB_DEVICE_WACOM(0xE2) },
3486         { USB_DEVICE_WACOM(0xE3) },
3487         { USB_DEVICE_WACOM(0xE5) },
3488         { USB_DEVICE_WACOM(0xE6) },
3489         { USB_DEVICE_WACOM(0xEC) },
3490         { USB_DEVICE_WACOM(0xED) },
3491         { USB_DEVICE_WACOM(0xEF) },
3492         { USB_DEVICE_WACOM(0xF0) },
3493         { USB_DEVICE_WACOM(0xF4) },
3494         { USB_DEVICE_WACOM(0xF6) },
3495         { USB_DEVICE_WACOM(0xF8) },
3496         { USB_DEVICE_WACOM(0xFA) },
3497         { USB_DEVICE_WACOM(0xFB) },
3498         { USB_DEVICE_WACOM(0x100) },
3499         { USB_DEVICE_WACOM(0x101) },
3500         { USB_DEVICE_WACOM(0x10D) },
3501         { USB_DEVICE_WACOM(0x10E) },
3502         { USB_DEVICE_WACOM(0x10F) },
3503         { USB_DEVICE_WACOM(0x116) },
3504         { USB_DEVICE_WACOM(0x12C) },
3505         { USB_DEVICE_WACOM(0x300) },
3506         { USB_DEVICE_WACOM(0x301) },
3507         { USB_DEVICE_WACOM(0x302) },
3508         { USB_DEVICE_WACOM(0x303) },
3509         { USB_DEVICE_WACOM(0x304) },
3510         { USB_DEVICE_WACOM(0x307) },
3511         { USB_DEVICE_WACOM(0x309) },
3512         { USB_DEVICE_WACOM(0x30A) },
3513         { USB_DEVICE_WACOM(0x30C) },
3514         { USB_DEVICE_WACOM(0x30E) },
3515         { USB_DEVICE_WACOM(0x314) },
3516         { USB_DEVICE_WACOM(0x315) },
3517         { USB_DEVICE_WACOM(0x317) },
3518         { USB_DEVICE_WACOM(0x318) },
3519         { USB_DEVICE_WACOM(0x319) },
3520         { USB_DEVICE_WACOM(0x323) },
3521         { USB_DEVICE_WACOM(0x325) },
3522         { USB_DEVICE_WACOM(0x326) },
3523         { USB_DEVICE_WACOM(0x32A) },
3524         { USB_DEVICE_WACOM(0x32B) },
3525         { USB_DEVICE_WACOM(0x32C) },
3526         { USB_DEVICE_WACOM(0x32F) },
3527         { USB_DEVICE_WACOM(0x331) },
3528         { USB_DEVICE_WACOM(0x333) },
3529         { USB_DEVICE_WACOM(0x335) },
3530         { USB_DEVICE_WACOM(0x336) },
3531         { USB_DEVICE_WACOM(0x33B) },
3532         { USB_DEVICE_WACOM(0x33C) },
3533         { USB_DEVICE_WACOM(0x33D) },
3534         { USB_DEVICE_WACOM(0x33E) },
3535         { USB_DEVICE_WACOM(0x4001) },
3536         { USB_DEVICE_WACOM(0x4004) },
3537         { USB_DEVICE_WACOM(0x5000) },
3538         { USB_DEVICE_WACOM(0x5002) },
3539         { USB_DEVICE_LENOVO(0x6004) },
3540
3541         { USB_DEVICE_WACOM(HID_ANY_ID) },
3542         { I2C_DEVICE_WACOM(HID_ANY_ID) },
3543         { }
3544 };
3545 MODULE_DEVICE_TABLE(hid, wacom_ids);