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