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 BAMBOO_PEN:
2304         case BAMBOO_TOUCH:
2305         case INTUOSHT:
2306                 if (wacom_wac->data[0] == WACOM_REPORT_USB)
2307                         sync = wacom_status_irq(wacom_wac, len);
2308                 else
2309                         sync = wacom_bpt_irq(wacom_wac, len);
2310                 break;
2311
2312         case BAMBOO_PAD:
2313                 sync = wacom_bamboo_pad_irq(wacom_wac, len);
2314                 break;
2315
2316         case WIRELESS:
2317                 sync = wacom_wireless_irq(wacom_wac, len);
2318                 break;
2319
2320         case REMOTE:
2321                 if (wacom_wac->data[0] == WACOM_REPORT_DEVICE_LIST)
2322                         sync = wacom_remote_status_irq(wacom_wac, len);
2323                 else
2324                         sync = wacom_remote_irq(wacom_wac, len);
2325                 break;
2326
2327         default:
2328                 sync = false;
2329                 break;
2330         }
2331
2332         if (sync) {
2333                 if (wacom_wac->pen_input)
2334                         input_sync(wacom_wac->pen_input);
2335                 if (wacom_wac->touch_input)
2336                         input_sync(wacom_wac->touch_input);
2337                 if (wacom_wac->pad_input)
2338                         input_sync(wacom_wac->pad_input);
2339         }
2340 }
2341
2342 static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
2343 {
2344         struct input_dev *input_dev = wacom_wac->pen_input;
2345
2346         input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
2347
2348         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2349         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2350         __set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
2351         __set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
2352         __set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
2353         __set_bit(BTN_STYLUS, input_dev->keybit);
2354         __set_bit(BTN_STYLUS2, input_dev->keybit);
2355
2356         input_set_abs_params(input_dev, ABS_DISTANCE,
2357                              0, wacom_wac->features.distance_max, 0, 0);
2358         input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
2359         input_set_abs_params(input_dev, ABS_TILT_X, -64, 63, 0, 0);
2360         input_abs_set_res(input_dev, ABS_TILT_X, 57);
2361         input_set_abs_params(input_dev, ABS_TILT_Y, -64, 63, 0, 0);
2362         input_abs_set_res(input_dev, ABS_TILT_Y, 57);
2363 }
2364
2365 static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
2366 {
2367         struct input_dev *input_dev = wacom_wac->pen_input;
2368
2369         input_set_capability(input_dev, EV_REL, REL_WHEEL);
2370
2371         wacom_setup_cintiq(wacom_wac);
2372
2373         __set_bit(BTN_LEFT, input_dev->keybit);
2374         __set_bit(BTN_RIGHT, input_dev->keybit);
2375         __set_bit(BTN_MIDDLE, input_dev->keybit);
2376         __set_bit(BTN_SIDE, input_dev->keybit);
2377         __set_bit(BTN_EXTRA, input_dev->keybit);
2378         __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
2379         __set_bit(BTN_TOOL_LENS, input_dev->keybit);
2380
2381         input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
2382         input_abs_set_res(input_dev, ABS_RZ, 287);
2383         input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
2384 }
2385
2386 void wacom_setup_device_quirks(struct wacom *wacom)
2387 {
2388         struct wacom_features *features = &wacom->wacom_wac.features;
2389
2390         /* The pen and pad share the same interface on most devices */
2391         if (features->type == GRAPHIRE_BT || features->type == WACOM_G4 ||
2392             features->type == DTUS ||
2393             (features->type >= INTUOS3S && features->type <= WACOM_MO)) {
2394                 if (features->device_type & WACOM_DEVICETYPE_PEN)
2395                         features->device_type |= WACOM_DEVICETYPE_PAD;
2396         }
2397
2398         /* touch device found but size is not defined. use default */
2399         if (features->device_type & WACOM_DEVICETYPE_TOUCH && !features->x_max) {
2400                 features->x_max = 1023;
2401                 features->y_max = 1023;
2402         }
2403
2404         /*
2405          * Intuos5/Pro and Bamboo 3rd gen have no useful data about its
2406          * touch interface in its HID descriptor. If this is the touch
2407          * interface (PacketSize of WACOM_PKGLEN_BBTOUCH3), override the
2408          * tablet values.
2409          */
2410         if ((features->type >= INTUOS5S && features->type <= INTUOSPL) ||
2411                 (features->type >= INTUOSHT && features->type <= BAMBOO_PT)) {
2412                 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
2413                         if (features->touch_max)
2414                                 features->device_type |= WACOM_DEVICETYPE_TOUCH;
2415                         if (features->type >= INTUOSHT || features->type <= BAMBOO_PT)
2416                                 features->device_type |= WACOM_DEVICETYPE_PAD;
2417
2418                         features->x_max = 4096;
2419                         features->y_max = 4096;
2420                 }
2421                 else if (features->pktlen == WACOM_PKGLEN_BBTOUCH) {
2422                         features->device_type |= WACOM_DEVICETYPE_PAD;
2423                 }
2424         }
2425
2426         /*
2427          * Raw Wacom-mode pen and touch events both come from interface
2428          * 0, whose HID descriptor has an application usage of 0xFF0D
2429          * (i.e., WACOM_VENDORDEFINED_PEN). We route pen packets back
2430          * out through the HID_GENERIC device created for interface 1,
2431          * so rewrite this one to be of type WACOM_DEVICETYPE_TOUCH.
2432          */
2433         if (features->type == BAMBOO_PAD)
2434                 features->device_type = WACOM_DEVICETYPE_TOUCH;
2435
2436         if (features->type == REMOTE)
2437                 features->device_type = WACOM_DEVICETYPE_PAD;
2438
2439         if (wacom->hdev->bus == BUS_BLUETOOTH)
2440                 features->quirks |= WACOM_QUIRK_BATTERY;
2441
2442         /* quirk for bamboo touch with 2 low res touches */
2443         if (features->type == BAMBOO_PT &&
2444             features->pktlen == WACOM_PKGLEN_BBTOUCH) {
2445                 features->x_max <<= 5;
2446                 features->y_max <<= 5;
2447                 features->x_fuzz <<= 5;
2448                 features->y_fuzz <<= 5;
2449                 features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
2450         }
2451
2452         if (features->type == WIRELESS) {
2453                 if (features->device_type == WACOM_DEVICETYPE_WL_MONITOR) {
2454                         features->quirks |= WACOM_QUIRK_BATTERY;
2455                 }
2456         }
2457 }
2458
2459 int wacom_setup_pen_input_capabilities(struct input_dev *input_dev,
2460                                    struct wacom_wac *wacom_wac)
2461 {
2462         struct wacom_features *features = &wacom_wac->features;
2463
2464         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2465
2466         if (!(features->device_type & WACOM_DEVICETYPE_PEN))
2467                 return -ENODEV;
2468
2469         if (features->type == HID_GENERIC)
2470                 /* setup has already been done */
2471                 return 0;
2472
2473         __set_bit(BTN_TOUCH, input_dev->keybit);
2474         __set_bit(ABS_MISC, input_dev->absbit);
2475
2476         input_set_abs_params(input_dev, ABS_X, features->x_min,
2477                              features->x_max, features->x_fuzz, 0);
2478         input_set_abs_params(input_dev, ABS_Y, features->y_min,
2479                              features->y_max, features->y_fuzz, 0);
2480         input_set_abs_params(input_dev, ABS_PRESSURE, 0,
2481                 features->pressure_max, features->pressure_fuzz, 0);
2482
2483         /* penabled devices have fixed resolution for each model */
2484         input_abs_set_res(input_dev, ABS_X, features->x_resolution);
2485         input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
2486
2487
2488         switch (features->type) {
2489         case GRAPHIRE_BT:
2490                 __clear_bit(ABS_MISC, input_dev->absbit);
2491
2492         case WACOM_MO:
2493         case WACOM_G4:
2494                 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
2495                                               features->distance_max,
2496                                               0, 0);
2497                 /* fall through */
2498
2499         case GRAPHIRE:
2500                 input_set_capability(input_dev, EV_REL, REL_WHEEL);
2501
2502                 __set_bit(BTN_LEFT, input_dev->keybit);
2503                 __set_bit(BTN_RIGHT, input_dev->keybit);
2504                 __set_bit(BTN_MIDDLE, input_dev->keybit);
2505
2506                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2507                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2508                 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
2509                 __set_bit(BTN_STYLUS, input_dev->keybit);
2510                 __set_bit(BTN_STYLUS2, input_dev->keybit);
2511
2512                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2513                 break;
2514
2515         case WACOM_27QHD:
2516         case WACOM_24HD:
2517         case DTK:
2518         case WACOM_22HD:
2519         case WACOM_21UX2:
2520         case WACOM_BEE:
2521         case CINTIQ:
2522         case WACOM_13HD:
2523         case CINTIQ_HYBRID:
2524                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
2525                 input_abs_set_res(input_dev, ABS_Z, 287);
2526                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
2527                 wacom_setup_cintiq(wacom_wac);
2528                 break;
2529
2530         case INTUOS3:
2531         case INTUOS3L:
2532         case INTUOS3S:
2533         case INTUOS4:
2534         case INTUOS4WL:
2535         case INTUOS4L:
2536         case INTUOS4S:
2537                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
2538                 input_abs_set_res(input_dev, ABS_Z, 287);
2539                 /* fall through */
2540
2541         case INTUOS:
2542                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2543
2544                 wacom_setup_intuos(wacom_wac);
2545                 break;
2546
2547         case INTUOS5:
2548         case INTUOS5L:
2549         case INTUOSPM:
2550         case INTUOSPL:
2551         case INTUOS5S:
2552         case INTUOSPS:
2553                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2554
2555                 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
2556                                       features->distance_max,
2557                                       0, 0);
2558
2559                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
2560                 input_abs_set_res(input_dev, ABS_Z, 287);
2561
2562                 wacom_setup_intuos(wacom_wac);
2563                 break;
2564
2565         case WACOM_24HDT:
2566         case WACOM_27QHDT:
2567         case MTSCREEN:
2568         case MTTPC:
2569         case MTTPC_B:
2570         case TABLETPC2FG:
2571         case TABLETPC:
2572         case TABLETPCE:
2573                 __clear_bit(ABS_MISC, input_dev->absbit);
2574                 /* fall through */
2575
2576         case DTUS:
2577         case DTUSX:
2578         case PL:
2579         case DTU:
2580                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2581                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2582                 __set_bit(BTN_STYLUS, input_dev->keybit);
2583                 __set_bit(BTN_STYLUS2, input_dev->keybit);
2584
2585                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
2586                 break;
2587
2588         case PTU:
2589                 __set_bit(BTN_STYLUS2, input_dev->keybit);
2590                 /* fall through */
2591
2592         case PENPARTNER:
2593                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2594                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2595                 __set_bit(BTN_STYLUS, input_dev->keybit);
2596
2597                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2598                 break;
2599
2600         case INTUOSHT:
2601         case BAMBOO_PT:
2602         case BAMBOO_PEN:
2603                 __clear_bit(ABS_MISC, input_dev->absbit);
2604
2605                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2606                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
2607                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
2608                 __set_bit(BTN_STYLUS, input_dev->keybit);
2609                 __set_bit(BTN_STYLUS2, input_dev->keybit);
2610                 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
2611                                       features->distance_max,
2612                                       0, 0);
2613                 break;
2614         case BAMBOO_PAD:
2615                 __clear_bit(ABS_MISC, input_dev->absbit);
2616                 break;
2617         }
2618         return 0;
2619 }
2620
2621 int wacom_setup_touch_input_capabilities(struct input_dev *input_dev,
2622                                          struct wacom_wac *wacom_wac)
2623 {
2624         struct wacom_features *features = &wacom_wac->features;
2625
2626         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2627
2628         if (!(features->device_type & WACOM_DEVICETYPE_TOUCH))
2629                 return -ENODEV;
2630
2631         if (features->type == HID_GENERIC)
2632                 /* setup has already been done */
2633                 return 0;
2634
2635         __set_bit(BTN_TOUCH, input_dev->keybit);
2636
2637         if (features->touch_max == 1) {
2638                 input_set_abs_params(input_dev, ABS_X, 0,
2639                         features->x_max, features->x_fuzz, 0);
2640                 input_set_abs_params(input_dev, ABS_Y, 0,
2641                         features->y_max, features->y_fuzz, 0);
2642                 input_abs_set_res(input_dev, ABS_X,
2643                                   features->x_resolution);
2644                 input_abs_set_res(input_dev, ABS_Y,
2645                                   features->y_resolution);
2646         }
2647         else if (features->touch_max > 1) {
2648                 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
2649                         features->x_max, features->x_fuzz, 0);
2650                 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
2651                         features->y_max, features->y_fuzz, 0);
2652                 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
2653                                   features->x_resolution);
2654                 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
2655                                   features->y_resolution);
2656         }
2657
2658         switch (features->type) {
2659         case INTUOS5:
2660         case INTUOS5L:
2661         case INTUOSPM:
2662         case INTUOSPL:
2663         case INTUOS5S:
2664         case INTUOSPS:
2665                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
2666
2667                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
2668                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, features->y_max, 0, 0);
2669                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
2670                 break;
2671
2672         case WACOM_24HDT:
2673                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
2674                 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
2675                 input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
2676                 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
2677                 /* fall through */
2678
2679         case WACOM_27QHDT:
2680         case MTSCREEN:
2681         case MTTPC:
2682         case MTTPC_B:
2683         case TABLETPC2FG:
2684                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_DIRECT);
2685                 /*fall through */
2686
2687         case TABLETPC:
2688         case TABLETPCE:
2689                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
2690                 break;
2691
2692         case INTUOSHT:
2693                 input_dev->evbit[0] |= BIT_MASK(EV_SW);
2694                 __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
2695                 /* fall through */
2696
2697         case BAMBOO_PT:
2698         case BAMBOO_TOUCH:
2699                 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
2700                         input_set_abs_params(input_dev,
2701                                      ABS_MT_TOUCH_MAJOR,
2702                                      0, features->x_max, 0, 0);
2703                         input_set_abs_params(input_dev,
2704                                      ABS_MT_TOUCH_MINOR,
2705                                      0, features->y_max, 0, 0);
2706                 }
2707                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
2708                 break;
2709
2710         case BAMBOO_PAD:
2711                 input_mt_init_slots(input_dev, features->touch_max,
2712                                     INPUT_MT_POINTER);
2713                 __set_bit(BTN_LEFT, input_dev->keybit);
2714                 __set_bit(BTN_RIGHT, input_dev->keybit);
2715                 break;
2716         }
2717         return 0;
2718 }
2719
2720 static void wacom_setup_numbered_buttons(struct input_dev *input_dev,
2721                                 int button_count)
2722 {
2723         int i;
2724
2725         for (i = 0; i < button_count && i < 10; i++)
2726                 __set_bit(BTN_0 + i, input_dev->keybit);
2727         for (i = 10; i < button_count && i < 16; i++)
2728                 __set_bit(BTN_A + (i-10), input_dev->keybit);
2729         for (i = 16; i < button_count && i < 18; i++)
2730                 __set_bit(BTN_BASE + (i-16), input_dev->keybit);
2731 }
2732
2733 int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
2734                                    struct wacom_wac *wacom_wac)
2735 {
2736         struct wacom_features *features = &wacom_wac->features;
2737
2738         if (!(features->device_type & WACOM_DEVICETYPE_PAD))
2739                 return -ENODEV;
2740
2741         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
2742
2743         /* kept for making legacy xf86-input-wacom working with the wheels */
2744         __set_bit(ABS_MISC, input_dev->absbit);
2745
2746         /* kept for making legacy xf86-input-wacom accepting the pad */
2747         input_set_abs_params(input_dev, ABS_X, 0, 1, 0, 0);
2748         input_set_abs_params(input_dev, ABS_Y, 0, 1, 0, 0);
2749
2750         /* kept for making udev and libwacom accepting the pad */
2751         __set_bit(BTN_STYLUS, input_dev->keybit);
2752
2753         wacom_setup_numbered_buttons(input_dev, features->numbered_buttons);
2754
2755         switch (features->type) {
2756
2757         case CINTIQ_HYBRID:
2758         case DTK:
2759         case DTUS:
2760         case GRAPHIRE_BT:
2761                 break;
2762
2763         case WACOM_MO:
2764                 __set_bit(BTN_BACK, input_dev->keybit);
2765                 __set_bit(BTN_LEFT, input_dev->keybit);
2766                 __set_bit(BTN_FORWARD, input_dev->keybit);
2767                 __set_bit(BTN_RIGHT, input_dev->keybit);
2768                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2769                 break;
2770
2771         case WACOM_G4:
2772                 __set_bit(BTN_BACK, input_dev->keybit);
2773                 __set_bit(BTN_FORWARD, input_dev->keybit);
2774                 input_set_capability(input_dev, EV_REL, REL_WHEEL);
2775                 break;
2776
2777         case WACOM_24HD:
2778                 __set_bit(KEY_PROG1, input_dev->keybit);
2779                 __set_bit(KEY_PROG2, input_dev->keybit);
2780                 __set_bit(KEY_PROG3, input_dev->keybit);
2781
2782                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2783                 input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
2784                 break;
2785
2786         case WACOM_27QHD:
2787                 __set_bit(KEY_PROG1, input_dev->keybit);
2788                 __set_bit(KEY_PROG2, input_dev->keybit);
2789                 __set_bit(KEY_PROG3, input_dev->keybit);
2790                 input_set_abs_params(input_dev, ABS_X, -2048, 2048, 0, 0);
2791                 input_abs_set_res(input_dev, ABS_X, 1024); /* points/g */
2792                 input_set_abs_params(input_dev, ABS_Y, -2048, 2048, 0, 0);
2793                 input_abs_set_res(input_dev, ABS_Y, 1024);
2794                 input_set_abs_params(input_dev, ABS_Z, -2048, 2048, 0, 0);
2795                 input_abs_set_res(input_dev, ABS_Z, 1024);
2796                 __set_bit(INPUT_PROP_ACCELEROMETER, input_dev->propbit);
2797                 break;
2798
2799         case WACOM_22HD:
2800                 __set_bit(KEY_PROG1, input_dev->keybit);
2801                 __set_bit(KEY_PROG2, input_dev->keybit);
2802                 __set_bit(KEY_PROG3, input_dev->keybit);
2803                 /* fall through */
2804
2805         case WACOM_21UX2:
2806         case WACOM_BEE:
2807         case CINTIQ:
2808                 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
2809                 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2810                 break;
2811
2812         case WACOM_13HD:
2813                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2814                 break;
2815
2816         case INTUOS3:
2817         case INTUOS3L:
2818                 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2819                 /* fall through */
2820
2821         case INTUOS3S:
2822                 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
2823                 break;
2824
2825         case INTUOS5:
2826         case INTUOS5L:
2827         case INTUOSPM:
2828         case INTUOSPL:
2829         case INTUOS5S:
2830         case INTUOSPS:
2831                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2832                 break;
2833
2834         case INTUOS4WL:
2835                 /*
2836                  * For Bluetooth devices, the udev rule does not work correctly
2837                  * for pads unless we add a stylus capability, which forces
2838                  * ID_INPUT_TABLET to be set.
2839                  */
2840                 __set_bit(BTN_STYLUS, input_dev->keybit);
2841                 /* fall through */
2842
2843         case INTUOS4:
2844         case INTUOS4L:
2845         case INTUOS4S:
2846                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2847                 break;
2848
2849         case INTUOSHT:
2850         case BAMBOO_PT:
2851         case BAMBOO_TOUCH:
2852                 __clear_bit(ABS_MISC, input_dev->absbit);
2853
2854                 __set_bit(BTN_LEFT, input_dev->keybit);
2855                 __set_bit(BTN_FORWARD, input_dev->keybit);
2856                 __set_bit(BTN_BACK, input_dev->keybit);
2857                 __set_bit(BTN_RIGHT, input_dev->keybit);
2858
2859                 break;
2860
2861         case REMOTE:
2862                 input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
2863                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2864                 break;
2865
2866         default:
2867                 /* no pad supported */
2868                 return -ENODEV;
2869         }
2870         return 0;
2871 }
2872
2873 static const struct wacom_features wacom_features_0x00 =
2874         { "Wacom Penpartner", 5040, 3780, 255, 0,
2875           PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
2876 static const struct wacom_features wacom_features_0x10 =
2877         { "Wacom Graphire", 10206, 7422, 511, 63,
2878           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2879 static const struct wacom_features wacom_features_0x81 =
2880         { "Wacom Graphire BT", 16704, 12064, 511, 32,
2881           GRAPHIRE_BT, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES, 2 };
2882 static const struct wacom_features wacom_features_0x11 =
2883         { "Wacom Graphire2 4x5", 10206, 7422, 511, 63,
2884           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2885 static const struct wacom_features wacom_features_0x12 =
2886         { "Wacom Graphire2 5x7", 13918, 10206, 511, 63,
2887           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2888 static const struct wacom_features wacom_features_0x13 =
2889         { "Wacom Graphire3", 10208, 7424, 511, 63,
2890           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2891 static const struct wacom_features wacom_features_0x14 =
2892         { "Wacom Graphire3 6x8", 16704, 12064, 511, 63,
2893           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2894 static const struct wacom_features wacom_features_0x15 =
2895         { "Wacom Graphire4 4x5", 10208, 7424, 511, 63,
2896           WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2897 static const struct wacom_features wacom_features_0x16 =
2898         { "Wacom Graphire4 6x8", 16704, 12064, 511, 63,
2899           WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2900 static const struct wacom_features wacom_features_0x17 =
2901         { "Wacom BambooFun 4x5", 14760, 9225, 511, 63,
2902           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2903 static const struct wacom_features wacom_features_0x18 =
2904         { "Wacom BambooFun 6x8", 21648, 13530, 511, 63,
2905           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2906 static const struct wacom_features wacom_features_0x19 =
2907         { "Wacom Bamboo1 Medium", 16704, 12064, 511, 63,
2908           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2909 static const struct wacom_features wacom_features_0x60 =
2910         { "Wacom Volito", 5104, 3712, 511, 63,
2911           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2912 static const struct wacom_features wacom_features_0x61 =
2913         { "Wacom PenStation2", 3250, 2320, 255, 63,
2914           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2915 static const struct wacom_features wacom_features_0x62 =
2916         { "Wacom Volito2 4x5", 5104, 3712, 511, 63,
2917           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2918 static const struct wacom_features wacom_features_0x63 =
2919         { "Wacom Volito2 2x3", 3248, 2320, 511, 63,
2920           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2921 static const struct wacom_features wacom_features_0x64 =
2922         { "Wacom PenPartner2", 3250, 2320, 511, 63,
2923           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2924 static const struct wacom_features wacom_features_0x65 =
2925         { "Wacom Bamboo", 14760, 9225, 511, 63,
2926           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2927 static const struct wacom_features wacom_features_0x69 =
2928         { "Wacom Bamboo1", 5104, 3712, 511, 63,
2929           GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
2930 static const struct wacom_features wacom_features_0x6A =
2931         { "Wacom Bamboo1 4x6", 14760, 9225, 1023, 63,
2932           GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2933 static const struct wacom_features wacom_features_0x6B =
2934         { "Wacom Bamboo1 5x8", 21648, 13530, 1023, 63,
2935           GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2936 static const struct wacom_features wacom_features_0x20 =
2937         { "Wacom Intuos 4x5", 12700, 10600, 1023, 31,
2938           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2939 static const struct wacom_features wacom_features_0x21 =
2940         { "Wacom Intuos 6x8", 20320, 16240, 1023, 31,
2941           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2942 static const struct wacom_features wacom_features_0x22 =
2943         { "Wacom Intuos 9x12", 30480, 24060, 1023, 31,
2944           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2945 static const struct wacom_features wacom_features_0x23 =
2946         { "Wacom Intuos 12x12", 30480, 31680, 1023, 31,
2947           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2948 static const struct wacom_features wacom_features_0x24 =
2949         { "Wacom Intuos 12x18", 45720, 31680, 1023, 31,
2950           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2951 static const struct wacom_features wacom_features_0x30 =
2952         { "Wacom PL400", 5408, 4056, 255, 0,
2953           PL, WACOM_PL_RES, WACOM_PL_RES };
2954 static const struct wacom_features wacom_features_0x31 =
2955         { "Wacom PL500", 6144, 4608, 255, 0,
2956           PL, WACOM_PL_RES, WACOM_PL_RES };
2957 static const struct wacom_features wacom_features_0x32 =
2958         { "Wacom PL600", 6126, 4604, 255, 0,
2959           PL, WACOM_PL_RES, WACOM_PL_RES };
2960 static const struct wacom_features wacom_features_0x33 =
2961         { "Wacom PL600SX", 6260, 5016, 255, 0,
2962           PL, WACOM_PL_RES, WACOM_PL_RES };
2963 static const struct wacom_features wacom_features_0x34 =
2964         { "Wacom PL550", 6144, 4608, 511, 0,
2965           PL, WACOM_PL_RES, WACOM_PL_RES };
2966 static const struct wacom_features wacom_features_0x35 =
2967         { "Wacom PL800", 7220, 5780, 511, 0,
2968           PL, WACOM_PL_RES, WACOM_PL_RES };
2969 static const struct wacom_features wacom_features_0x37 =
2970         { "Wacom PL700", 6758, 5406, 511, 0,
2971           PL, WACOM_PL_RES, WACOM_PL_RES };
2972 static const struct wacom_features wacom_features_0x38 =
2973         { "Wacom PL510", 6282, 4762, 511, 0,
2974           PL, WACOM_PL_RES, WACOM_PL_RES };
2975 static const struct wacom_features wacom_features_0x39 =
2976         { "Wacom DTU710", 34080, 27660, 511, 0,
2977           PL, WACOM_PL_RES, WACOM_PL_RES };
2978 static const struct wacom_features wacom_features_0xC4 =
2979         { "Wacom DTF521", 6282, 4762, 511, 0,
2980           PL, WACOM_PL_RES, WACOM_PL_RES };
2981 static const struct wacom_features wacom_features_0xC0 =
2982         { "Wacom DTF720", 6858, 5506, 511, 0,
2983           PL, WACOM_PL_RES, WACOM_PL_RES };
2984 static const struct wacom_features wacom_features_0xC2 =
2985         { "Wacom DTF720a", 6858, 5506, 511, 0,
2986           PL, WACOM_PL_RES, WACOM_PL_RES };
2987 static const struct wacom_features wacom_features_0x03 =
2988         { "Wacom Cintiq Partner", 20480, 15360, 511, 0,
2989           PTU, WACOM_PL_RES, WACOM_PL_RES };
2990 static const struct wacom_features wacom_features_0x41 =
2991         { "Wacom Intuos2 4x5", 12700, 10600, 1023, 31,
2992           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2993 static const struct wacom_features wacom_features_0x42 =
2994         { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
2995           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2996 static const struct wacom_features wacom_features_0x43 =
2997         { "Wacom Intuos2 9x12", 30480, 24060, 1023, 31,
2998           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2999 static const struct wacom_features wacom_features_0x44 =
3000         { "Wacom Intuos2 12x12", 30480, 31680, 1023, 31,
3001           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3002 static const struct wacom_features wacom_features_0x45 =
3003         { "Wacom Intuos2 12x18", 45720, 31680, 1023, 31,
3004           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3005 static const struct wacom_features wacom_features_0xB0 =
3006         { "Wacom Intuos3 4x5", 25400, 20320, 1023, 63,
3007           INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
3008 static const struct wacom_features wacom_features_0xB1 =
3009         { "Wacom Intuos3 6x8", 40640, 30480, 1023, 63,
3010           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3011 static const struct wacom_features wacom_features_0xB2 =
3012         { "Wacom Intuos3 9x12", 60960, 45720, 1023, 63,
3013           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3014 static const struct wacom_features wacom_features_0xB3 =
3015         { "Wacom Intuos3 12x12", 60960, 60960, 1023, 63,
3016           INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3017 static const struct wacom_features wacom_features_0xB4 =
3018         { "Wacom Intuos3 12x19", 97536, 60960, 1023, 63,
3019           INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3020 static const struct wacom_features wacom_features_0xB5 =
3021         { "Wacom Intuos3 6x11", 54204, 31750, 1023, 63,
3022           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3023 static const struct wacom_features wacom_features_0xB7 =
3024         { "Wacom Intuos3 4x6", 31496, 19685, 1023, 63,
3025           INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
3026 static const struct wacom_features wacom_features_0xB8 =
3027         { "Wacom Intuos4 4x6", 31496, 19685, 2047, 63,
3028           INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
3029 static const struct wacom_features wacom_features_0xB9 =
3030         { "Wacom Intuos4 6x9", 44704, 27940, 2047, 63,
3031           INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3032 static const struct wacom_features wacom_features_0xBA =
3033         { "Wacom Intuos4 8x13", 65024, 40640, 2047, 63,
3034           INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3035 static const struct wacom_features wacom_features_0xBB =
3036         { "Wacom Intuos4 12x19", 97536, 60960, 2047, 63,
3037           INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3038 static const struct wacom_features wacom_features_0xBC =
3039         { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
3040           INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3041 static const struct wacom_features wacom_features_0xBD =
3042         { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
3043           INTUOS4WL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3044 static const struct wacom_features wacom_features_0x26 =
3045         { "Wacom Intuos5 touch S", 31496, 19685, 2047, 63,
3046           INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16 };
3047 static const struct wacom_features wacom_features_0x27 =
3048         { "Wacom Intuos5 touch M", 44704, 27940, 2047, 63,
3049           INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
3050 static const struct wacom_features wacom_features_0x28 =
3051         { "Wacom Intuos5 touch L", 65024, 40640, 2047, 63,
3052           INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
3053 static const struct wacom_features wacom_features_0x29 =
3054         { "Wacom Intuos5 S", 31496, 19685, 2047, 63,
3055           INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
3056 static const struct wacom_features wacom_features_0x2A =
3057         { "Wacom Intuos5 M", 44704, 27940, 2047, 63,
3058           INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
3059 static const struct wacom_features wacom_features_0x314 =
3060         { "Wacom Intuos Pro S", 31496, 19685, 2047, 63,
3061           INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16,
3062           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3063 static const struct wacom_features wacom_features_0x315 =
3064         { "Wacom Intuos Pro M", 44704, 27940, 2047, 63,
3065           INTUOSPM, 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_0x317 =
3068         { "Wacom Intuos Pro L", 65024, 40640, 2047, 63,
3069           INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
3070           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3071 static const struct wacom_features wacom_features_0xF4 =
3072         { "Wacom Cintiq 24HD", 104080, 65200, 2047, 63,
3073           WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
3074           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3075 static const struct wacom_features wacom_features_0xF8 =
3076         { "Wacom Cintiq 24HD touch", 104080, 65200, 2047, 63, /* Pen */
3077           WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
3078           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3079           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
3080 static const struct wacom_features wacom_features_0xF6 =
3081         { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
3082           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
3083           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3084 static const struct wacom_features wacom_features_0x32A =
3085         { "Wacom Cintiq 27QHD", 119740, 67520, 2047, 63,
3086           WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
3087           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3088 static const struct wacom_features wacom_features_0x32B =
3089         { "Wacom Cintiq 27QHD touch", 119740, 67520, 2047, 63,
3090           WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
3091           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3092           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32C };
3093 static const struct wacom_features wacom_features_0x32C =
3094         { "Wacom Cintiq 27QHD touch", .type = WACOM_27QHDT,
3095           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32B, .touch_max = 10 };
3096 static const struct wacom_features wacom_features_0x3F =
3097         { "Wacom Cintiq 21UX", 87200, 65600, 1023, 63,
3098           CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
3099 static const struct wacom_features wacom_features_0xC5 =
3100         { "Wacom Cintiq 20WSX", 86680, 54180, 1023, 63,
3101           WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
3102 static const struct wacom_features wacom_features_0xC6 =
3103         { "Wacom Cintiq 12WX", 53020, 33440, 1023, 63,
3104           WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
3105 static const struct wacom_features wacom_features_0x304 =
3106         { "Wacom Cintiq 13HD", 59152, 33448, 1023, 63,
3107           WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
3108           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3109 static const struct wacom_features wacom_features_0x333 =
3110         { "Wacom Cintiq 13HD touch", 59152, 33448, 2047, 63,
3111           WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
3112           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3113           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x335 };
3114 static const struct wacom_features wacom_features_0x335 =
3115         { "Wacom Cintiq 13HD touch", .type = WACOM_24HDT, /* Touch */
3116           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x333, .touch_max = 10,
3117           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3118 static const struct wacom_features wacom_features_0xC7 =
3119         { "Wacom DTU1931", 37832, 30305, 511, 0,
3120           PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3121 static const struct wacom_features wacom_features_0xCE =
3122         { "Wacom DTU2231", 47864, 27011, 511, 0,
3123           DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3124           .check_for_hid_type = true, .hid_type = HID_TYPE_USBMOUSE };
3125 static const struct wacom_features wacom_features_0xF0 =
3126         { "Wacom DTU1631", 34623, 19553, 511, 0,
3127           DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3128 static const struct wacom_features wacom_features_0xFB =
3129         { "Wacom DTU1031", 21896, 13760, 511, 0,
3130           DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
3131           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
3132 static const struct wacom_features wacom_features_0x32F =
3133         { "Wacom DTU1031X", 22472, 12728, 511, 0,
3134           DTUSX, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 0,
3135           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
3136 static const struct wacom_features wacom_features_0x336 =
3137         { "Wacom DTU1141", 23472, 13203, 1023, 0,
3138           DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4 };
3139 static const struct wacom_features wacom_features_0x57 =
3140         { "Wacom DTK2241", 95640, 54060, 2047, 63,
3141           DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
3142           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3143 static const struct wacom_features wacom_features_0x59 = /* Pen */
3144         { "Wacom DTH2242", 95640, 54060, 2047, 63,
3145           DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
3146           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3147           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
3148 static const struct wacom_features wacom_features_0x5D = /* Touch */
3149         { "Wacom DTH2242",       .type = WACOM_24HDT,
3150           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10,
3151           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3152 static const struct wacom_features wacom_features_0xCC =
3153         { "Wacom Cintiq 21UX2", 86800, 65200, 2047, 63,
3154           WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
3155           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3156 static const struct wacom_features wacom_features_0xFA =
3157         { "Wacom Cintiq 22HD", 95440, 53860, 2047, 63,
3158           WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
3159           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
3160 static const struct wacom_features wacom_features_0x5B =
3161         { "Wacom Cintiq 22HDT", 95440, 53860, 2047, 63,
3162           WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
3163           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3164           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e };
3165 static const struct wacom_features wacom_features_0x5E =
3166         { "Wacom Cintiq 22HDT", .type = WACOM_24HDT,
3167           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10,
3168           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3169 static const struct wacom_features wacom_features_0x90 =
3170         { "Wacom ISDv4 90", 26202, 16325, 255, 0,
3171           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3172 static const struct wacom_features wacom_features_0x93 =
3173         { "Wacom ISDv4 93", 26202, 16325, 255, 0,
3174           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3175 static const struct wacom_features wacom_features_0x97 =
3176         { "Wacom ISDv4 97", 26202, 16325, 511, 0,
3177           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3178 static const struct wacom_features wacom_features_0x9A =
3179         { "Wacom ISDv4 9A", 26202, 16325, 255, 0,
3180           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3181 static const struct wacom_features wacom_features_0x9F =
3182         { "Wacom ISDv4 9F", 26202, 16325, 255, 0,
3183           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3184 static const struct wacom_features wacom_features_0xE2 =
3185         { "Wacom ISDv4 E2", 26202, 16325, 255, 0,
3186           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3187 static const struct wacom_features wacom_features_0xE3 =
3188         { "Wacom ISDv4 E3", 26202, 16325, 255, 0,
3189           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3190 static const struct wacom_features wacom_features_0xE5 =
3191         { "Wacom ISDv4 E5", 26202, 16325, 255, 0,
3192           MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3193 static const struct wacom_features wacom_features_0xE6 =
3194         { "Wacom ISDv4 E6", 27760, 15694, 255, 0,
3195           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3196 static const struct wacom_features wacom_features_0xEC =
3197         { "Wacom ISDv4 EC", 25710, 14500, 255, 0,
3198           TABLETPC,    WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3199 static const struct wacom_features wacom_features_0xED =
3200         { "Wacom ISDv4 ED", 26202, 16325, 255, 0,
3201           TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3202 static const struct wacom_features wacom_features_0xEF =
3203         { "Wacom ISDv4 EF", 26202, 16325, 255, 0,
3204           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3205 static const struct wacom_features wacom_features_0x100 =
3206         { "Wacom ISDv4 100", 26202, 16325, 255, 0,
3207           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3208 static const struct wacom_features wacom_features_0x101 =
3209         { "Wacom ISDv4 101", 26202, 16325, 255, 0,
3210           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3211 static const struct wacom_features wacom_features_0x10D =
3212         { "Wacom ISDv4 10D", 26202, 16325, 255, 0,
3213           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3214 static const struct wacom_features wacom_features_0x10E =
3215         { "Wacom ISDv4 10E", 27760, 15694, 255, 0,
3216           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3217 static const struct wacom_features wacom_features_0x10F =
3218         { "Wacom ISDv4 10F", 27760, 15694, 255, 0,
3219           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3220 static const struct wacom_features wacom_features_0x116 =
3221         { "Wacom ISDv4 116", 26202, 16325, 255, 0,
3222           TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3223 static const struct wacom_features wacom_features_0x12C =
3224         { "Wacom ISDv4 12C", 27848, 15752, 2047, 0,
3225           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3226 static const struct wacom_features wacom_features_0x4001 =
3227         { "Wacom ISDv4 4001", 26202, 16325, 255, 0,
3228           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3229 static const struct wacom_features wacom_features_0x4004 =
3230         { "Wacom ISDv4 4004", 11060, 6220, 255, 0,
3231           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3232 static const struct wacom_features wacom_features_0x5000 =
3233         { "Wacom ISDv4 5000", 27848, 15752, 1023, 0,
3234           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3235 static const struct wacom_features wacom_features_0x5002 =
3236         { "Wacom ISDv4 5002", 29576, 16724, 1023, 0,
3237           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3238 static const struct wacom_features wacom_features_0x47 =
3239         { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
3240           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3241 static const struct wacom_features wacom_features_0x84 =
3242         { "Wacom Wireless Receiver", .type = WIRELESS, .touch_max = 16 };
3243 static const struct wacom_features wacom_features_0xD0 =
3244         { "Wacom Bamboo 2FG", 14720, 9200, 1023, 31,
3245           BAMBOO_TOUCH, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3246 static const struct wacom_features wacom_features_0xD1 =
3247         { "Wacom Bamboo 2FG 4x5", 14720, 9200, 1023, 31,
3248           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3249 static const struct wacom_features wacom_features_0xD2 =
3250         { "Wacom Bamboo Craft", 14720, 9200, 1023, 31,
3251           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3252 static const struct wacom_features wacom_features_0xD3 =
3253         { "Wacom Bamboo 2FG 6x8", 21648, 13700, 1023, 31,
3254           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3255 static const struct wacom_features wacom_features_0xD4 =
3256         { "Wacom Bamboo Pen", 14720, 9200, 1023, 31,
3257           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3258 static const struct wacom_features wacom_features_0xD5 =
3259         { "Wacom Bamboo Pen 6x8", 21648, 13700, 1023, 31,
3260           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3261 static const struct wacom_features wacom_features_0xD6 =
3262         { "Wacom BambooPT 2FG 4x5", 14720, 9200, 1023, 31,
3263           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3264 static const struct wacom_features wacom_features_0xD7 =
3265         { "Wacom BambooPT 2FG Small", 14720, 9200, 1023, 31,
3266           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3267 static const struct wacom_features wacom_features_0xD8 =
3268         { "Wacom Bamboo Comic 2FG", 21648, 13700, 1023, 31,
3269           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3270 static const struct wacom_features wacom_features_0xDA =
3271         { "Wacom Bamboo 2FG 4x5 SE", 14720, 9200, 1023, 31,
3272           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3273 static const struct wacom_features wacom_features_0xDB =
3274         { "Wacom Bamboo 2FG 6x8 SE", 21648, 13700, 1023, 31,
3275           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
3276 static const struct wacom_features wacom_features_0xDD =
3277         { "Wacom Bamboo Connect", 14720, 9200, 1023, 31,
3278           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3279 static const struct wacom_features wacom_features_0xDE =
3280         { "Wacom Bamboo 16FG 4x5", 14720, 9200, 1023, 31,
3281           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
3282 static const struct wacom_features wacom_features_0xDF =
3283         { "Wacom Bamboo 16FG 6x8", 21648, 13700, 1023, 31,
3284           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
3285 static const struct wacom_features wacom_features_0x300 =
3286         { "Wacom Bamboo One S", 14720, 9225, 1023, 31,
3287           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3288 static const struct wacom_features wacom_features_0x301 =
3289         { "Wacom Bamboo One M", 21648, 13530, 1023, 31,
3290           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3291 static const struct wacom_features wacom_features_0x302 =
3292         { "Wacom Intuos PT S", 15200, 9500, 1023, 31,
3293           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
3294           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3295 static const struct wacom_features wacom_features_0x303 =
3296         { "Wacom Intuos PT M", 21600, 13500, 1023, 31,
3297           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
3298           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3299 static const struct wacom_features wacom_features_0x30E =
3300         { "Wacom Intuos S", 15200, 9500, 1023, 31,
3301           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3302           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3303 static const struct wacom_features wacom_features_0x6004 =
3304         { "ISD-V4", 12800, 8000, 255, 0,
3305           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
3306 static const struct wacom_features wacom_features_0x307 =
3307         { "Wacom ISDv5 307", 59152, 33448, 2047, 63,
3308           CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
3309           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3310           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
3311 static const struct wacom_features wacom_features_0x309 =
3312         { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
3313           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10,
3314           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3315 static const struct wacom_features wacom_features_0x30A =
3316         { "Wacom ISDv5 30A", 59152, 33448, 2047, 63,
3317           CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
3318           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
3319           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30C };
3320 static const struct wacom_features wacom_features_0x30C =
3321         { "Wacom ISDv5 30C", .type = WACOM_24HDT, /* Touch */
3322           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30A, .touch_max = 10,
3323           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3324 static const struct wacom_features wacom_features_0x318 =
3325         { "Wacom USB Bamboo PAD", 4095, 4095, /* Touch */
3326           .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
3327 static const struct wacom_features wacom_features_0x319 =
3328         { "Wacom Wireless Bamboo PAD", 4095, 4095, /* Touch */
3329           .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
3330 static const struct wacom_features wacom_features_0x323 =
3331         { "Wacom Intuos P M", 21600, 13500, 1023, 31,
3332           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
3333           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
3334 static const struct wacom_features wacom_features_0x331 =
3335         { "Wacom Express Key Remote", .type = REMOTE,
3336           .numbered_buttons = 18, .check_for_hid_type = true,
3337           .hid_type = HID_TYPE_USBNONE };
3338
3339 static const struct wacom_features wacom_features_HID_ANY_ID =
3340         { "Wacom HID", .type = HID_GENERIC };
3341
3342 #define USB_DEVICE_WACOM(prod)                                          \
3343         HID_DEVICE(BUS_USB, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3344         .driver_data = (kernel_ulong_t)&wacom_features_##prod
3345
3346 #define BT_DEVICE_WACOM(prod)                                           \
3347         HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3348         .driver_data = (kernel_ulong_t)&wacom_features_##prod
3349
3350 #define I2C_DEVICE_WACOM(prod)                                          \
3351         HID_DEVICE(BUS_I2C, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
3352         .driver_data = (kernel_ulong_t)&wacom_features_##prod
3353
3354 #define USB_DEVICE_LENOVO(prod)                                 \
3355         HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),                     \
3356         .driver_data = (kernel_ulong_t)&wacom_features_##prod
3357
3358 const struct hid_device_id wacom_ids[] = {
3359         { USB_DEVICE_WACOM(0x00) },
3360         { USB_DEVICE_WACOM(0x03) },
3361         { USB_DEVICE_WACOM(0x10) },
3362         { USB_DEVICE_WACOM(0x11) },
3363         { USB_DEVICE_WACOM(0x12) },
3364         { USB_DEVICE_WACOM(0x13) },
3365         { USB_DEVICE_WACOM(0x14) },
3366         { USB_DEVICE_WACOM(0x15) },
3367         { USB_DEVICE_WACOM(0x16) },
3368         { USB_DEVICE_WACOM(0x17) },
3369         { USB_DEVICE_WACOM(0x18) },
3370         { USB_DEVICE_WACOM(0x19) },
3371         { USB_DEVICE_WACOM(0x20) },
3372         { USB_DEVICE_WACOM(0x21) },
3373         { USB_DEVICE_WACOM(0x22) },
3374         { USB_DEVICE_WACOM(0x23) },
3375         { USB_DEVICE_WACOM(0x24) },
3376         { USB_DEVICE_WACOM(0x26) },
3377         { USB_DEVICE_WACOM(0x27) },
3378         { USB_DEVICE_WACOM(0x28) },
3379         { USB_DEVICE_WACOM(0x29) },
3380         { USB_DEVICE_WACOM(0x2A) },
3381         { USB_DEVICE_WACOM(0x30) },
3382         { USB_DEVICE_WACOM(0x31) },
3383         { USB_DEVICE_WACOM(0x32) },
3384         { USB_DEVICE_WACOM(0x33) },
3385         { USB_DEVICE_WACOM(0x34) },
3386         { USB_DEVICE_WACOM(0x35) },
3387         { USB_DEVICE_WACOM(0x37) },
3388         { USB_DEVICE_WACOM(0x38) },
3389         { USB_DEVICE_WACOM(0x39) },
3390         { USB_DEVICE_WACOM(0x3F) },
3391         { USB_DEVICE_WACOM(0x41) },
3392         { USB_DEVICE_WACOM(0x42) },
3393         { USB_DEVICE_WACOM(0x43) },
3394         { USB_DEVICE_WACOM(0x44) },
3395         { USB_DEVICE_WACOM(0x45) },
3396         { USB_DEVICE_WACOM(0x47) },
3397         { USB_DEVICE_WACOM(0x57) },
3398         { USB_DEVICE_WACOM(0x59) },
3399         { USB_DEVICE_WACOM(0x5B) },
3400         { USB_DEVICE_WACOM(0x5D) },
3401         { USB_DEVICE_WACOM(0x5E) },
3402         { USB_DEVICE_WACOM(0x60) },
3403         { USB_DEVICE_WACOM(0x61) },
3404         { USB_DEVICE_WACOM(0x62) },
3405         { USB_DEVICE_WACOM(0x63) },
3406         { USB_DEVICE_WACOM(0x64) },
3407         { USB_DEVICE_WACOM(0x65) },
3408         { USB_DEVICE_WACOM(0x69) },
3409         { USB_DEVICE_WACOM(0x6A) },
3410         { USB_DEVICE_WACOM(0x6B) },
3411         { BT_DEVICE_WACOM(0x81) },
3412         { USB_DEVICE_WACOM(0x84) },
3413         { USB_DEVICE_WACOM(0x90) },
3414         { USB_DEVICE_WACOM(0x93) },
3415         { USB_DEVICE_WACOM(0x97) },
3416         { USB_DEVICE_WACOM(0x9A) },
3417         { USB_DEVICE_WACOM(0x9F) },
3418         { USB_DEVICE_WACOM(0xB0) },
3419         { USB_DEVICE_WACOM(0xB1) },
3420         { USB_DEVICE_WACOM(0xB2) },
3421         { USB_DEVICE_WACOM(0xB3) },
3422         { USB_DEVICE_WACOM(0xB4) },
3423         { USB_DEVICE_WACOM(0xB5) },
3424         { USB_DEVICE_WACOM(0xB7) },
3425         { USB_DEVICE_WACOM(0xB8) },
3426         { USB_DEVICE_WACOM(0xB9) },
3427         { USB_DEVICE_WACOM(0xBA) },
3428         { USB_DEVICE_WACOM(0xBB) },
3429         { USB_DEVICE_WACOM(0xBC) },
3430         { BT_DEVICE_WACOM(0xBD) },
3431         { USB_DEVICE_WACOM(0xC0) },
3432         { USB_DEVICE_WACOM(0xC2) },
3433         { USB_DEVICE_WACOM(0xC4) },
3434         { USB_DEVICE_WACOM(0xC5) },
3435         { USB_DEVICE_WACOM(0xC6) },
3436         { USB_DEVICE_WACOM(0xC7) },
3437         { USB_DEVICE_WACOM(0xCC) },
3438         { USB_DEVICE_WACOM(0xCE) },
3439         { USB_DEVICE_WACOM(0xD0) },
3440         { USB_DEVICE_WACOM(0xD1) },
3441         { USB_DEVICE_WACOM(0xD2) },
3442         { USB_DEVICE_WACOM(0xD3) },
3443         { USB_DEVICE_WACOM(0xD4) },
3444         { USB_DEVICE_WACOM(0xD5) },
3445         { USB_DEVICE_WACOM(0xD6) },
3446         { USB_DEVICE_WACOM(0xD7) },
3447         { USB_DEVICE_WACOM(0xD8) },
3448         { USB_DEVICE_WACOM(0xDA) },
3449         { USB_DEVICE_WACOM(0xDB) },
3450         { USB_DEVICE_WACOM(0xDD) },
3451         { USB_DEVICE_WACOM(0xDE) },
3452         { USB_DEVICE_WACOM(0xDF) },
3453         { USB_DEVICE_WACOM(0xE2) },
3454         { USB_DEVICE_WACOM(0xE3) },
3455         { USB_DEVICE_WACOM(0xE5) },
3456         { USB_DEVICE_WACOM(0xE6) },
3457         { USB_DEVICE_WACOM(0xEC) },
3458         { USB_DEVICE_WACOM(0xED) },
3459         { USB_DEVICE_WACOM(0xEF) },
3460         { USB_DEVICE_WACOM(0xF0) },
3461         { USB_DEVICE_WACOM(0xF4) },
3462         { USB_DEVICE_WACOM(0xF6) },
3463         { USB_DEVICE_WACOM(0xF8) },
3464         { USB_DEVICE_WACOM(0xFA) },
3465         { USB_DEVICE_WACOM(0xFB) },
3466         { USB_DEVICE_WACOM(0x100) },
3467         { USB_DEVICE_WACOM(0x101) },
3468         { USB_DEVICE_WACOM(0x10D) },
3469         { USB_DEVICE_WACOM(0x10E) },
3470         { USB_DEVICE_WACOM(0x10F) },
3471         { USB_DEVICE_WACOM(0x116) },
3472         { USB_DEVICE_WACOM(0x12C) },
3473         { USB_DEVICE_WACOM(0x300) },
3474         { USB_DEVICE_WACOM(0x301) },
3475         { USB_DEVICE_WACOM(0x302) },
3476         { USB_DEVICE_WACOM(0x303) },
3477         { USB_DEVICE_WACOM(0x304) },
3478         { USB_DEVICE_WACOM(0x307) },
3479         { USB_DEVICE_WACOM(0x309) },
3480         { USB_DEVICE_WACOM(0x30A) },
3481         { USB_DEVICE_WACOM(0x30C) },
3482         { USB_DEVICE_WACOM(0x30E) },
3483         { USB_DEVICE_WACOM(0x314) },
3484         { USB_DEVICE_WACOM(0x315) },
3485         { USB_DEVICE_WACOM(0x317) },
3486         { USB_DEVICE_WACOM(0x318) },
3487         { USB_DEVICE_WACOM(0x319) },
3488         { USB_DEVICE_WACOM(0x323) },
3489         { USB_DEVICE_WACOM(0x32A) },
3490         { USB_DEVICE_WACOM(0x32B) },
3491         { USB_DEVICE_WACOM(0x32C) },
3492         { USB_DEVICE_WACOM(0x32F) },
3493         { USB_DEVICE_WACOM(0x331) },
3494         { USB_DEVICE_WACOM(0x333) },
3495         { USB_DEVICE_WACOM(0x335) },
3496         { USB_DEVICE_WACOM(0x336) },
3497         { USB_DEVICE_WACOM(0x4001) },
3498         { USB_DEVICE_WACOM(0x4004) },
3499         { USB_DEVICE_WACOM(0x5000) },
3500         { USB_DEVICE_WACOM(0x5002) },
3501         { USB_DEVICE_LENOVO(0x6004) },
3502
3503         { USB_DEVICE_WACOM(HID_ANY_ID) },
3504         { I2C_DEVICE_WACOM(HID_ANY_ID) },
3505         { }
3506 };
3507 MODULE_DEVICE_TABLE(hid, wacom_ids);