drivers/hid/wacom_wac.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  USB Wacom tablet support - Wacom specific code
   4  */
   5
   6 #include "wacom_wac.h"
   7 #include "wacom.h"
   8 #include <linux/input/mt.h>
   9 #include <linux/jiffies.h>
  10
  11 /* resolution for penabled devices */
  12 #define WACOM_PL_RES            20
  13 #define WACOM_PENPRTN_RES       40
  14 #define WACOM_VOLITO_RES        50
  15 #define WACOM_GRAPHIRE_RES      80
  16 #define WACOM_INTUOS_RES        100
  17 #define WACOM_INTUOS3_RES       200
  18
  19 /* Newer Cintiq and DTU have an offset between tablet and screen areas */
  20 #define WACOM_DTU_OFFSET        200
  21 #define WACOM_CINTIQ_OFFSET     400
  22
  23 /*
  24  * Scale factor relating reported contact size to logical contact area.
  25  * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
  26  */
  27 #define WACOM_CONTACT_AREA_SCALE 2607
  28
  29 static bool touch_arbitration = 1;
  30 module_param(touch_arbitration, bool, 0644);
  31 MODULE_PARM_DESC(touch_arbitration, " on (Y) off (N)");
  32
  33 static void wacom_report_numbered_buttons(struct input_dev *input_dev,
  34                                 int button_count, int mask);
  35
  36 static int wacom_numbered_button_to_key(int n);
  37
  38 static void wacom_update_led(struct wacom *wacom, int button_count, int mask,
  39                              int group);
  40
  41 static void wacom_force_proxout(struct wacom_wac *wacom_wac)
  42 {
  43         struct input_dev *input = wacom_wac->pen_input;
  44
  45         wacom_wac->shared->stylus_in_proximity = 0;
  46
  47         input_report_key(input, BTN_TOUCH, 0);
  48         input_report_key(input, BTN_STYLUS, 0);
  49         input_report_key(input, BTN_STYLUS2, 0);
  50         input_report_key(input, BTN_STYLUS3, 0);
  51         input_report_key(input, wacom_wac->tool[0], 0);
  52         if (wacom_wac->serial[0]) {
  53                 input_report_abs(input, ABS_MISC, 0);
  54         }
  55         input_report_abs(input, ABS_PRESSURE, 0);
  56
  57         wacom_wac->tool[0] = 0;
  58         wacom_wac->id[0] = 0;
  59         wacom_wac->serial[0] = 0;
  60
  61         input_sync(input);
  62 }
  63
  64 void wacom_idleprox_timeout(struct timer_list *list)
  65 {
  66         struct wacom *wacom = from_timer(wacom, list, idleprox_timer);
  67         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
  68
  69         if (!wacom_wac->hid_data.sense_state) {
  70                 return;
  71         }
  72
  73         hid_warn(wacom->hdev, "%s: tool appears to be hung in-prox. forcing it out.\n", __func__);
  74         wacom_force_proxout(wacom_wac);
  75 }
  76
  77 /*
  78  * Percent of battery capacity for Graphire.
  79  * 8th value means AC online and show 100% capacity.
  80  */
  81 static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
  82
  83 /*
  84  * Percent of battery capacity for Intuos4 WL, AC has a separate bit.
  85  */
  86 static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
  87
  88 static void __wacom_notify_battery(struct wacom_battery *battery,
  89                                    int bat_status, int bat_capacity,
  90                                    bool bat_charging, bool bat_connected,
  91                                    bool ps_connected)
  92 {
  93         bool changed = battery->bat_status       != bat_status    ||
  94                        battery->battery_capacity != bat_capacity  ||
  95                        battery->bat_charging     != bat_charging  ||
  96                        battery->bat_connected    != bat_connected ||
  97                        battery->ps_connected     != ps_connected;
  98
  99         if (changed) {
 100                 battery->bat_status = bat_status;
 101                 battery->battery_capacity = bat_capacity;
 102                 battery->bat_charging = bat_charging;
 103                 battery->bat_connected = bat_connected;
 104                 battery->ps_connected = ps_connected;
 105
 106                 if (battery->battery)
 107                         power_supply_changed(battery->battery);
 108         }
 109 }
 110
 111 static void wacom_notify_battery(struct wacom_wac *wacom_wac,
 112         int bat_status, int bat_capacity, bool bat_charging,
 113         bool bat_connected, bool ps_connected)
 114 {
 115         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
 116         bool bat_initialized = wacom->battery.battery;
 117         bool has_quirk = wacom_wac->features.quirks & WACOM_QUIRK_BATTERY;
 118
 119         if (bat_initialized != has_quirk)
 120                 wacom_schedule_work(wacom_wac, WACOM_WORKER_BATTERY);
 121
 122         __wacom_notify_battery(&wacom->battery, bat_status, bat_capacity,
 123                                bat_charging, bat_connected, ps_connected);
 124 }
 125
 126 static int wacom_penpartner_irq(struct wacom_wac *wacom)
 127 {
 128         unsigned char *data = wacom->data;
 129         struct input_dev *input = wacom->pen_input;
 130
 131         switch (data[0]) {
 132         case 1:
 133                 if (data[5] & 0x80) {
 134                         wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
 135                         wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
 136                         input_report_key(input, wacom->tool[0], 1);
 137                         input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
 138                         input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
 139                         input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
 140                         input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
 141                         input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
 142                         input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
 143                 } else {
 144                         input_report_key(input, wacom->tool[0], 0);
 145                         input_report_abs(input, ABS_MISC, 0); /* report tool id */
 146                         input_report_abs(input, ABS_PRESSURE, -1);
 147                         input_report_key(input, BTN_TOUCH, 0);
 148                 }
 149                 break;
 150
 151         case 2:
 152                 input_report_key(input, BTN_TOOL_PEN, 1);
 153                 input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
 154                 input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
 155                 input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
 156                 input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
 157                 input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
 158                 input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
 159                 break;
 160
 161         default:
 162                 dev_dbg(input->dev.parent,
 163                         "%s: received unknown report #%d\n", __func__, data[0]);
 164                 return 0;
 165         }
 166
 167         return 1;
 168 }
 169
 170 static int wacom_pl_irq(struct wacom_wac *wacom)
 171 {
 172         struct wacom_features *features = &wacom->features;
 173         unsigned char *data = wacom->data;
 174         struct input_dev *input = wacom->pen_input;
 175         int prox, pressure;
 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         prox = data[1] & 0x40;
 184
 185         if (!wacom->id[0]) {
 186                 if ((data[0] & 0x10) || (data[4] & 0x20)) {
 187                         wacom->tool[0] = BTN_TOOL_RUBBER;
 188                         wacom->id[0] = ERASER_DEVICE_ID;
 189                 }
 190                 else {
 191                         wacom->tool[0] = BTN_TOOL_PEN;
 192                         wacom->id[0] = STYLUS_DEVICE_ID;
 193                 }
 194         }
 195
 196         /* If the eraser is in prox, STYLUS2 is always set. If we
 197          * mis-detected the type and notice that STYLUS2 isn't set
 198          * then force the eraser out of prox and let the pen in.
 199          */
 200         if (wacom->tool[0] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
 201                 input_report_key(input, BTN_TOOL_RUBBER, 0);
 202                 input_report_abs(input, ABS_MISC, 0);
 203                 input_sync(input);
 204                 wacom->tool[0] = BTN_TOOL_PEN;
 205                 wacom->id[0] = STYLUS_DEVICE_ID;
 206         }
 207
 208         if (prox) {
 209                 pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
 210                 if (features->pressure_max > 255)
 211                         pressure = (pressure << 1) | ((data[4] >> 6) & 1);
 212                 pressure += (features->pressure_max + 1) / 2;
 213
 214                 input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
 215                 input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
 216                 input_report_abs(input, ABS_PRESSURE, pressure);
 217
 218                 input_report_key(input, BTN_TOUCH, data[4] & 0x08);
 219                 input_report_key(input, BTN_STYLUS, data[4] & 0x10);
 220                 /* Only allow the stylus2 button to be reported for the pen tool. */
 221                 input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20));
 222         }
 223
 224         if (!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_ptu_irq(struct wacom_wac *wacom)
 232 {
 233         unsigned char *data = wacom->data;
 234         struct input_dev *input = wacom->pen_input;
 235
 236         if (data[0] != WACOM_REPORT_PENABLED) {
 237                 dev_dbg(input->dev.parent,
 238                         "%s: received unknown report #%d\n", __func__, data[0]);
 239                 return 0;
 240         }
 241
 242         if (data[1] & 0x04) {
 243                 input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
 244                 input_report_key(input, BTN_TOUCH, data[1] & 0x08);
 245                 wacom->id[0] = ERASER_DEVICE_ID;
 246         } else {
 247                 input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
 248                 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
 249                 wacom->id[0] = STYLUS_DEVICE_ID;
 250         }
 251         input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
 252         input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 253         input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 254         input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
 255         input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 256         input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
 257         return 1;
 258 }
 259
 260 static int wacom_dtu_irq(struct wacom_wac *wacom)
 261 {
 262         unsigned char *data = wacom->data;
 263         struct input_dev *input = wacom->pen_input;
 264         int prox = data[1] & 0x20;
 265
 266         dev_dbg(input->dev.parent,
 267                 "%s: received report #%d", __func__, data[0]);
 268
 269         if (prox) {
 270                 /* Going into proximity select tool */
 271                 wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
 272                 if (wacom->tool[0] == BTN_TOOL_PEN)
 273                         wacom->id[0] = STYLUS_DEVICE_ID;
 274                 else
 275                         wacom->id[0] = ERASER_DEVICE_ID;
 276         }
 277         input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 278         input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
 279         input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 280         input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 281         input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x01) << 8) | data[6]);
 282         input_report_key(input, BTN_TOUCH, data[1] & 0x05);
 283         if (!prox) /* out-prox */
 284                 wacom->id[0] = 0;
 285         input_report_key(input, wacom->tool[0], prox);
 286         input_report_abs(input, ABS_MISC, wacom->id[0]);
 287         return 1;
 288 }
 289
 290 static int wacom_dtus_irq(struct wacom_wac *wacom)
 291 {
 292         unsigned char *data = wacom->data;
 293         struct input_dev *input = wacom->pen_input;
 294         unsigned short prox, pressure = 0;
 295
 296         if (data[0] != WACOM_REPORT_DTUS && data[0] != WACOM_REPORT_DTUSPAD) {
 297                 dev_dbg(input->dev.parent,
 298                         "%s: received unknown report #%d", __func__, data[0]);
 299                 return 0;
 300         } else if (data[0] == WACOM_REPORT_DTUSPAD) {
 301                 input = wacom->pad_input;
 302                 input_report_key(input, BTN_0, (data[1] & 0x01));
 303                 input_report_key(input, BTN_1, (data[1] & 0x02));
 304                 input_report_key(input, BTN_2, (data[1] & 0x04));
 305                 input_report_key(input, BTN_3, (data[1] & 0x08));
 306                 input_report_abs(input, ABS_MISC,
 307                                  data[1] & 0x0f ? PAD_DEVICE_ID : 0);
 308                 return 1;
 309         } else {
 310                 prox = data[1] & 0x80;
 311                 if (prox) {
 312                         switch ((data[1] >> 3) & 3) {
 313                         case 1: /* Rubber */
 314                                 wacom->tool[0] = BTN_TOOL_RUBBER;
 315                                 wacom->id[0] = ERASER_DEVICE_ID;
 316                                 break;
 317
 318                         case 2: /* Pen */
 319                                 wacom->tool[0] = BTN_TOOL_PEN;
 320                                 wacom->id[0] = STYLUS_DEVICE_ID;
 321                                 break;
 322                         }
 323                 }
 324
 325                 input_report_key(input, BTN_STYLUS, data[1] & 0x20);
 326                 input_report_key(input, BTN_STYLUS2, data[1] & 0x40);
 327                 input_report_abs(input, ABS_X, get_unaligned_be16(&data[3]));
 328                 input_report_abs(input, ABS_Y, get_unaligned_be16(&data[5]));
 329                 pressure = ((data[1] & 0x03) << 8) | (data[2] & 0xff);
 330                 input_report_abs(input, ABS_PRESSURE, pressure);
 331                 input_report_key(input, BTN_TOUCH, pressure > 10);
 332
 333                 if (!prox) /* out-prox */
 334                         wacom->id[0] = 0;
 335                 input_report_key(input, wacom->tool[0], prox);
 336                 input_report_abs(input, ABS_MISC, wacom->id[0]);
 337                 return 1;
 338         }
 339 }
 340
 341 static int wacom_graphire_irq(struct wacom_wac *wacom)
 342 {
 343         struct wacom_features *features = &wacom->features;
 344         unsigned char *data = wacom->data;
 345         struct input_dev *input = wacom->pen_input;
 346         struct input_dev *pad_input = wacom->pad_input;
 347         int battery_capacity, ps_connected;
 348         int prox;
 349         int rw = 0;
 350         int retval = 0;
 351
 352         if (features->type == GRAPHIRE_BT) {
 353                 if (data[0] != WACOM_REPORT_PENABLED_BT) {
 354                         dev_dbg(input->dev.parent,
 355                                 "%s: received unknown report #%d\n", __func__,
 356                                 data[0]);
 357                         goto exit;
 358                 }
 359         } else if (data[0] != WACOM_REPORT_PENABLED) {
 360                 dev_dbg(input->dev.parent,
 361                         "%s: received unknown report #%d\n", __func__, data[0]);
 362                 goto exit;
 363         }
 364
 365         prox = data[1] & 0x80;
 366         if (prox || wacom->id[0]) {
 367                 if (prox) {
 368                         switch ((data[1] >> 5) & 3) {
 369
 370                         case 0: /* Pen */
 371                                 wacom->tool[0] = BTN_TOOL_PEN;
 372                                 wacom->id[0] = STYLUS_DEVICE_ID;
 373                                 break;
 374
 375                         case 1: /* Rubber */
 376                                 wacom->tool[0] = BTN_TOOL_RUBBER;
 377                                 wacom->id[0] = ERASER_DEVICE_ID;
 378                                 break;
 379
 380                         case 2: /* Mouse with wheel */
 381                                 input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
 382                                 fallthrough;
 383
 384                         case 3: /* Mouse without wheel */
 385                                 wacom->tool[0] = BTN_TOOL_MOUSE;
 386                                 wacom->id[0] = CURSOR_DEVICE_ID;
 387                                 break;
 388                         }
 389                 }
 390                 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 391                 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 392                 if (wacom->tool[0] != BTN_TOOL_MOUSE) {
 393                         if (features->type == GRAPHIRE_BT)
 394                                 input_report_abs(input, ABS_PRESSURE, data[6] |
 395                                         (((__u16) (data[1] & 0x08)) << 5));
 396                         else
 397                                 input_report_abs(input, ABS_PRESSURE, data[6] |
 398                                         ((data[7] & 0x03) << 8));
 399                         input_report_key(input, BTN_TOUCH, data[1] & 0x01);
 400                         input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 401                         input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
 402                 } else {
 403                         input_report_key(input, BTN_LEFT, data[1] & 0x01);
 404                         input_report_key(input, BTN_RIGHT, data[1] & 0x02);
 405                         if (features->type == WACOM_G4 ||
 406                                         features->type == WACOM_MO) {
 407                                 input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
 408                                 rw = (data[7] & 0x04) - (data[7] & 0x03);
 409                         } else if (features->type == GRAPHIRE_BT) {
 410                                 /* Compute distance between mouse and tablet */
 411                                 rw = 44 - (data[6] >> 2);
 412                                 rw = clamp_val(rw, 0, 31);
 413                                 input_report_abs(input, ABS_DISTANCE, rw);
 414                                 if (((data[1] >> 5) & 3) == 2) {
 415                                         /* Mouse with wheel */
 416                                         input_report_key(input, BTN_MIDDLE,
 417                                                         data[1] & 0x04);
 418                                         rw = (data[6] & 0x01) ? -1 :
 419                                                 (data[6] & 0x02) ? 1 : 0;
 420                                 } else {
 421                                         rw = 0;
 422                                 }
 423                         } else {
 424                                 input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
 425                                 rw = -(signed char)data[6];
 426                         }
 427                         input_report_rel(input, REL_WHEEL, rw);
 428                 }
 429
 430                 if (!prox)
 431                         wacom->id[0] = 0;
 432                 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
 433                 input_report_key(input, wacom->tool[0], prox);
 434                 input_sync(input); /* sync last event */
 435         }
 436
 437         /* send pad data */
 438         switch (features->type) {
 439         case WACOM_G4:
 440                 prox = data[7] & 0xf8;
 441                 if (prox || wacom->id[1]) {
 442                         wacom->id[1] = PAD_DEVICE_ID;
 443                         input_report_key(pad_input, BTN_BACK, (data[7] & 0x40));
 444                         input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x80));
 445                         rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
 446                         input_report_rel(pad_input, REL_WHEEL, rw);
 447                         if (!prox)
 448                                 wacom->id[1] = 0;
 449                         input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
 450                         retval = 1;
 451                 }
 452                 break;
 453
 454         case WACOM_MO:
 455                 prox = (data[7] & 0xf8) || data[8];
 456                 if (prox || wacom->id[1]) {
 457                         wacom->id[1] = PAD_DEVICE_ID;
 458                         input_report_key(pad_input, BTN_BACK, (data[7] & 0x08));
 459                         input_report_key(pad_input, BTN_LEFT, (data[7] & 0x20));
 460                         input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x10));
 461                         input_report_key(pad_input, BTN_RIGHT, (data[7] & 0x40));
 462                         input_report_abs(pad_input, ABS_WHEEL, (data[8] & 0x7f));
 463                         if (!prox)
 464                                 wacom->id[1] = 0;
 465                         input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
 466                         retval = 1;
 467                 }
 468                 break;
 469         case GRAPHIRE_BT:
 470                 prox = data[7] & 0x03;
 471                 if (prox || wacom->id[1]) {
 472                         wacom->id[1] = PAD_DEVICE_ID;
 473                         input_report_key(pad_input, BTN_0, (data[7] & 0x02));
 474                         input_report_key(pad_input, BTN_1, (data[7] & 0x01));
 475                         if (!prox)
 476                                 wacom->id[1] = 0;
 477                         input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
 478                         retval = 1;
 479                 }
 480                 break;
 481         }
 482
 483         /* Store current battery capacity and power supply state */
 484         if (features->type == GRAPHIRE_BT) {
 485                 rw = (data[7] >> 2 & 0x07);
 486                 battery_capacity = batcap_gr[rw];
 487                 ps_connected = rw == 7;
 488                 wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
 489                                      battery_capacity, ps_connected, 1,
 490                                      ps_connected);
 491         }
 492 exit:
 493         return retval;
 494 }
 495
 496 static void wacom_intuos_schedule_prox_event(struct wacom_wac *wacom_wac)
 497 {
 498         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
 499         struct wacom_features *features = &wacom_wac->features;
 500         struct hid_report *r;
 501         struct hid_report_enum *re;
 502
 503         re = &(wacom->hdev->report_enum[HID_FEATURE_REPORT]);
 504         if (features->type == INTUOSHT2)
 505                 r = re->report_id_hash[WACOM_REPORT_INTUOSHT2_ID];
 506         else
 507                 r = re->report_id_hash[WACOM_REPORT_INTUOS_ID1];
 508         if (r) {
 509                 hid_hw_request(wacom->hdev, r, HID_REQ_GET_REPORT);
 510         }
 511 }
 512
 513 static int wacom_intuos_pad(struct wacom_wac *wacom)
 514 {
 515         struct wacom_features *features = &wacom->features;
 516         unsigned char *data = wacom->data;
 517         struct input_dev *input = wacom->pad_input;
 518         int i;
 519         int buttons = 0, nbuttons = features->numbered_buttons;
 520         int keys = 0, nkeys = 0;
 521         int ring1 = 0, ring2 = 0;
 522         int strip1 = 0, strip2 = 0;
 523         bool prox = false;
 524         bool wrench = false, keyboard = false, mute_touch = false, menu = false,
 525              info = false;
 526
 527         /* pad packets. Works as a second tool and is always in prox */
 528         if (!(data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD ||
 529               data[0] == WACOM_REPORT_CINTIQPAD))
 530                 return 0;
 531
 532         if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
 533                 buttons = (data[3] << 1) | (data[2] & 0x01);
 534                 ring1 = data[1];
 535         } else if (features->type == DTK) {
 536                 buttons = data[6];
 537         } else if (features->type == WACOM_13HD) {
 538                 buttons = (data[4] << 1) | (data[3] & 0x01);
 539         } else if (features->type == WACOM_24HD) {
 540                 buttons = (data[8] << 8) | data[6];
 541                 ring1 = data[1];
 542                 ring2 = data[2];
 543
 544                 /*
 545                  * Three "buttons" are available on the 24HD which are
 546                  * physically implemented as a touchstrip. Each button
 547                  * is approximately 3 bits wide with a 2 bit spacing.
 548                  * The raw touchstrip bits are stored at:
 549                  *    ((data[3] & 0x1f) << 8) | data[4])
 550                  */
 551                 nkeys = 3;
 552                 keys = ((data[3] & 0x1C) ? 1<<2 : 0) |
 553                        ((data[4] & 0xE0) ? 1<<1 : 0) |
 554                        ((data[4] & 0x07) ? 1<<0 : 0);
 555                 keyboard = !!(data[4] & 0xE0);
 556                 info = !!(data[3] & 0x1C);
 557
 558                 if (features->oPid) {
 559                         mute_touch = !!(data[4] & 0x07);
 560                         if (mute_touch)
 561                                 wacom->shared->is_touch_on =
 562                                         !wacom->shared->is_touch_on;
 563                 } else {
 564                         wrench = !!(data[4] & 0x07);
 565                 }
 566         } else if (features->type == WACOM_27QHD) {
 567                 nkeys = 3;
 568                 keys = data[2] & 0x07;
 569
 570                 wrench = !!(data[2] & 0x01);
 571                 keyboard = !!(data[2] & 0x02);
 572
 573                 if (features->oPid) {
 574                         mute_touch = !!(data[2] & 0x04);
 575                         if (mute_touch)
 576                                 wacom->shared->is_touch_on =
 577                                         !wacom->shared->is_touch_on;
 578                 } else {
 579                         menu = !!(data[2] & 0x04);
 580                 }
 581                 input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[4]));
 582                 input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[6]));
 583                 input_report_abs(input, ABS_Z, be16_to_cpup((__be16 *)&data[8]));
 584         } else if (features->type == CINTIQ_HYBRID) {
 585                 /*
 586                  * Do not send hardware buttons under Android. They
 587                  * are already sent to the system through GPIO (and
 588                  * have different meaning).
 589                  *
 590                  * d-pad right  -> data[4] & 0x10
 591                  * d-pad up     -> data[4] & 0x20
 592                  * d-pad left   -> data[4] & 0x40
 593                  * d-pad down   -> data[4] & 0x80
 594                  * d-pad center -> data[3] & 0x01
 595                  */
 596                 buttons = (data[4] << 1) | (data[3] & 0x01);
 597         } else if (features->type == CINTIQ_COMPANION_2) {
 598                 /* d-pad right  -> data[2] & 0x10
 599                  * d-pad up     -> data[2] & 0x20
 600                  * d-pad left   -> data[2] & 0x40
 601                  * d-pad down   -> data[2] & 0x80
 602                  * d-pad center -> data[1] & 0x01
 603                  */
 604                 buttons = ((data[2] >> 4) << 7) |
 605                           ((data[1] & 0x04) << 4) |
 606                           ((data[2] & 0x0F) << 2) |
 607                           (data[1] & 0x03);
 608         } else if (features->type >= INTUOS5S && features->type <= INTUOSPL) {
 609                 /*
 610                  * ExpressKeys on Intuos5/Intuos Pro have a capacitive sensor in
 611                  * addition to the mechanical switch. Switch data is
 612                  * stored in data[4], capacitive data in data[5].
 613                  *
 614                  * Touch ring mode switch (data[3]) has no capacitive sensor
 615                  */
 616                 buttons = (data[4] << 1) | (data[3] & 0x01);
 617                 ring1 = data[2];
 618         } else {
 619                 if (features->type == WACOM_21UX2 || features->type == WACOM_22HD) {
 620                         buttons = (data[8] << 10) | ((data[7] & 0x01) << 9) |
 621                                   (data[6] << 1) | (data[5] & 0x01);
 622
 623                         if (features->type == WACOM_22HD) {
 624                                 nkeys = 3;
 625                                 keys = data[9] & 0x07;
 626
 627                                 info = !!(data[9] & 0x01);
 628                                 wrench = !!(data[9] & 0x02);
 629                         }
 630                 } else {
 631                         buttons = ((data[6] & 0x10) << 5)  |
 632                                   ((data[5] & 0x10) << 4)  |
 633                                   ((data[6] & 0x0F) << 4)  |
 634                                   (data[5] & 0x0F);
 635                 }
 636                 strip1 = ((data[1] & 0x1f) << 8) | data[2];
 637                 strip2 = ((data[3] & 0x1f) << 8) | data[4];
 638         }
 639
 640         prox = (buttons & ~(~0U << nbuttons)) | (keys & ~(~0U << nkeys)) |
 641                (ring1 & 0x80) | (ring2 & 0x80) | strip1 | strip2;
 642
 643         wacom_report_numbered_buttons(input, nbuttons, buttons);
 644
 645         for (i = 0; i < nkeys; i++)
 646                 input_report_key(input, KEY_PROG1 + i, keys & (1 << i));
 647
 648         input_report_key(input, KEY_BUTTONCONFIG, wrench);
 649         input_report_key(input, KEY_ONSCREEN_KEYBOARD, keyboard);
 650         input_report_key(input, KEY_CONTROLPANEL, menu);
 651         input_report_key(input, KEY_INFO, info);
 652
 653         if (wacom->shared && wacom->shared->touch_input) {
 654                 input_report_switch(wacom->shared->touch_input,
 655                                     SW_MUTE_DEVICE,
 656                                     !wacom->shared->is_touch_on);
 657                 input_sync(wacom->shared->touch_input);
 658         }
 659
 660         input_report_abs(input, ABS_RX, strip1);
 661         input_report_abs(input, ABS_RY, strip2);
 662
 663         input_report_abs(input, ABS_WHEEL,    (ring1 & 0x80) ? (ring1 & 0x7f) : 0);
 664         input_report_abs(input, ABS_THROTTLE, (ring2 & 0x80) ? (ring2 & 0x7f) : 0);
 665
 666         input_report_key(input, wacom->tool[1], prox ? 1 : 0);
 667         input_report_abs(input, ABS_MISC, prox ? PAD_DEVICE_ID : 0);
 668
 669         input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
 670
 671         return 1;
 672 }
 673
 674 static int wacom_intuos_id_mangle(int tool_id)
 675 {
 676         return (tool_id & ~0xFFF) << 4 | (tool_id & 0xFFF);
 677 }
 678
 679 static bool wacom_is_art_pen(int tool_id)
 680 {
 681         bool is_art_pen = false;
 682
 683         switch (tool_id) {
 684         case 0x885:     /* Intuos3 Marker Pen */
 685         case 0x804:     /* Intuos4/5 13HD/24HD Marker Pen */
 686         case 0x10804:   /* Intuos4/5 13HD/24HD Art Pen */
 687                 is_art_pen = true;
 688                 break;
 689         }
 690         return is_art_pen;
 691 }
 692
 693 static int wacom_intuos_get_tool_type(int tool_id)
 694 {
 695         int tool_type = BTN_TOOL_PEN;
 696
 697         if (wacom_is_art_pen(tool_id))
 698                 return tool_type;
 699
 700         switch (tool_id) {
 701         case 0x812: /* Inking pen */
 702         case 0x801: /* Intuos3 Inking pen */
 703         case 0x12802: /* Intuos4/5 Inking Pen */
 704         case 0x012:
 705                 tool_type = BTN_TOOL_PENCIL;
 706                 break;
 707
 708         case 0x822: /* Pen */
 709         case 0x842:
 710         case 0x852:
 711         case 0x823: /* Intuos3 Grip Pen */
 712         case 0x813: /* Intuos3 Classic Pen */
 713         case 0x802: /* Intuos4/5 13HD/24HD General Pen */
 714         case 0x8e2: /* IntuosHT2 pen */
 715         case 0x022:
 716         case 0x200: /* Pro Pen 3 */
 717         case 0x04200: /* Pro Pen 3 */
 718         case 0x10842: /* MobileStudio Pro Pro Pen slim */
 719         case 0x14802: /* Intuos4/5 13HD/24HD Classic Pen */
 720         case 0x16802: /* Cintiq 13HD Pro Pen */
 721         case 0x18802: /* DTH2242 Pen */
 722         case 0x10802: /* Intuos4/5 13HD/24HD General Pen */
 723         case 0x80842: /* Intuos Pro and Cintiq Pro 3D Pen */
 724                 tool_type = BTN_TOOL_PEN;
 725                 break;
 726
 727         case 0x832: /* Stroke pen */
 728         case 0x032:
 729                 tool_type = BTN_TOOL_BRUSH;
 730                 break;
 731
 732         case 0x007: /* Mouse 4D and 2D */
 733         case 0x09c:
 734         case 0x094:
 735         case 0x017: /* Intuos3 2D Mouse */
 736         case 0x806: /* Intuos4 Mouse */
 737                 tool_type = BTN_TOOL_MOUSE;
 738                 break;
 739
 740         case 0x096: /* Lens cursor */
 741         case 0x097: /* Intuos3 Lens cursor */
 742         case 0x006: /* Intuos4 Lens cursor */
 743                 tool_type = BTN_TOOL_LENS;
 744                 break;
 745
 746         case 0x82a: /* Eraser */
 747         case 0x84a:
 748         case 0x85a:
 749         case 0x91a:
 750         case 0xd1a:
 751         case 0x0fa:
 752         case 0x82b: /* Intuos3 Grip Pen Eraser */
 753         case 0x81b: /* Intuos3 Classic Pen Eraser */
 754         case 0x91b: /* Intuos3 Airbrush Eraser */
 755         case 0x80c: /* Intuos4/5 13HD/24HD Marker Pen Eraser */
 756         case 0x80a: /* Intuos4/5 13HD/24HD General Pen Eraser */
 757         case 0x90a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
 758         case 0x1480a: /* Intuos4/5 13HD/24HD Classic Pen Eraser */
 759         case 0x1090a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
 760         case 0x1080c: /* Intuos4/5 13HD/24HD Art Pen Eraser */
 761         case 0x1084a: /* MobileStudio Pro Pro Pen slim Eraser */
 762         case 0x1680a: /* Cintiq 13HD Pro Pen Eraser */
 763         case 0x1880a: /* DTH2242 Eraser */
 764         case 0x1080a: /* Intuos4/5 13HD/24HD General Pen Eraser */
 765                 tool_type = BTN_TOOL_RUBBER;
 766                 break;
 767
 768         case 0xd12:
 769         case 0x912:
 770         case 0x112:
 771         case 0x913: /* Intuos3 Airbrush */
 772         case 0x902: /* Intuos4/5 13HD/24HD Airbrush */
 773         case 0x10902: /* Intuos4/5 13HD/24HD Airbrush */
 774                 tool_type = BTN_TOOL_AIRBRUSH;
 775                 break;
 776         }
 777         return tool_type;
 778 }
 779
 780 static void wacom_exit_report(struct wacom_wac *wacom)
 781 {
 782         struct input_dev *input = wacom->pen_input;
 783         struct wacom_features *features = &wacom->features;
 784         unsigned char *data = wacom->data;
 785         int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
 786
 787         /*
 788          * Reset all states otherwise we lose the initial states
 789          * when in-prox next time
 790          */
 791         input_report_abs(input, ABS_X, 0);
 792         input_report_abs(input, ABS_Y, 0);
 793         input_report_abs(input, ABS_DISTANCE, 0);
 794         input_report_abs(input, ABS_TILT_X, 0);
 795         input_report_abs(input, ABS_TILT_Y, 0);
 796         if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
 797                 input_report_key(input, BTN_LEFT, 0);
 798                 input_report_key(input, BTN_MIDDLE, 0);
 799                 input_report_key(input, BTN_RIGHT, 0);
 800                 input_report_key(input, BTN_SIDE, 0);
 801                 input_report_key(input, BTN_EXTRA, 0);
 802                 input_report_abs(input, ABS_THROTTLE, 0);
 803                 input_report_abs(input, ABS_RZ, 0);
 804         } else {
 805                 input_report_abs(input, ABS_PRESSURE, 0);
 806                 input_report_key(input, BTN_STYLUS, 0);
 807                 input_report_key(input, BTN_STYLUS2, 0);
 808                 input_report_key(input, BTN_TOUCH, 0);
 809                 input_report_abs(input, ABS_WHEEL, 0);
 810                 if (features->type >= INTUOS3S)
 811                         input_report_abs(input, ABS_Z, 0);
 812         }
 813         input_report_key(input, wacom->tool[idx], 0);
 814         input_report_abs(input, ABS_MISC, 0); /* reset tool id */
 815         input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
 816         wacom->id[idx] = 0;
 817 }
 818
 819 static int wacom_intuos_inout(struct wacom_wac *wacom)
 820 {
 821         struct wacom_features *features = &wacom->features;
 822         unsigned char *data = wacom->data;
 823         struct input_dev *input = wacom->pen_input;
 824         int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
 825
 826         if (!(((data[1] & 0xfc) == 0xc0) ||  /* in prox */
 827             ((data[1] & 0xfe) == 0x20) ||    /* in range */
 828             ((data[1] & 0xfe) == 0x80)))     /* out prox */
 829                 return 0;
 830
 831         /* Enter report */
 832         if ((data[1] & 0xfc) == 0xc0) {
 833                 /* serial number of the tool */
 834                 wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
 835                         (data[4] << 20) + (data[5] << 12) +
 836                         (data[6] << 4) + (data[7] >> 4);
 837
 838                 wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
 839                      ((data[7] & 0x0f) << 16) | ((data[8] & 0xf0) << 8);
 840
 841                 wacom->tool[idx] = wacom_intuos_get_tool_type(wacom->id[idx]);
 842
 843                 wacom->shared->stylus_in_proximity = true;
 844                 return 1;
 845         }
 846
 847         /* in Range */
 848         if ((data[1] & 0xfe) == 0x20) {
 849                 if (features->type != INTUOSHT2)
 850                         wacom->shared->stylus_in_proximity = true;
 851
 852                 /* in Range while exiting */
 853                 if (wacom->reporting_data) {
 854                         input_report_key(input, BTN_TOUCH, 0);
 855                         input_report_abs(input, ABS_PRESSURE, 0);
 856                         input_report_abs(input, ABS_DISTANCE, wacom->features.distance_max);
 857                         return 2;
 858                 }
 859                 return 1;
 860         }
 861
 862         /* Exit report */
 863         if ((data[1] & 0xfe) == 0x80) {
 864                 wacom->shared->stylus_in_proximity = false;
 865                 wacom->reporting_data = false;
 866
 867                 /* don't report exit if we don't know the ID */
 868                 if (!wacom->id[idx])
 869                         return 1;
 870
 871                 wacom_exit_report(wacom);
 872                 return 2;
 873         }
 874
 875         return 0;
 876 }
 877
 878 static inline bool touch_is_muted(struct wacom_wac *wacom_wac)
 879 {
 880         return wacom_wac->probe_complete &&
 881                wacom_wac->shared->has_mute_touch_switch &&
 882                !wacom_wac->shared->is_touch_on;
 883 }
 884
 885 static inline bool report_touch_events(struct wacom_wac *wacom)
 886 {
 887         return (touch_arbitration ? !wacom->shared->stylus_in_proximity : 1);
 888 }
 889
 890 static inline bool delay_pen_events(struct wacom_wac *wacom)
 891 {
 892         return (wacom->shared->touch_down && touch_arbitration);
 893 }
 894
 895 static int wacom_intuos_general(struct wacom_wac *wacom)
 896 {
 897         struct wacom_features *features = &wacom->features;
 898         unsigned char *data = wacom->data;
 899         struct input_dev *input = wacom->pen_input;
 900         int idx = (features->type == INTUOS) ? (data[1] & 0x01) : 0;
 901         unsigned char type = (data[1] >> 1) & 0x0F;
 902         unsigned int x, y, distance, t;
 903
 904         if (data[0] != WACOM_REPORT_PENABLED && data[0] != WACOM_REPORT_CINTIQ &&
 905                 data[0] != WACOM_REPORT_INTUOS_PEN)
 906                 return 0;
 907
 908         if (delay_pen_events(wacom))
 909                 return 1;
 910
 911         /* don't report events if we don't know the tool ID */
 912         if (!wacom->id[idx]) {
 913                 /* but reschedule a read of the current tool */
 914                 wacom_intuos_schedule_prox_event(wacom);
 915                 return 1;
 916         }
 917
 918         /*
 919          * don't report events for invalid data
 920          */
 921         /* older I4 styli don't work with new Cintiqs */
 922         if ((!((wacom->id[idx] >> 16) & 0x01) &&
 923                         (features->type == WACOM_21UX2)) ||
 924             /* Only large Intuos support Lense Cursor */
 925             (wacom->tool[idx] == BTN_TOOL_LENS &&
 926                 (features->type == INTUOS3 ||
 927                  features->type == INTUOS3S ||
 928                  features->type == INTUOS4 ||
 929                  features->type == INTUOS4S ||
 930                  features->type == INTUOS5 ||
 931                  features->type == INTUOS5S ||
 932                  features->type == INTUOSPM ||
 933                  features->type == INTUOSPS)) ||
 934            /* Cintiq doesn't send data when RDY bit isn't set */
 935            (features->type == CINTIQ && !(data[1] & 0x40)))
 936                 return 1;
 937
 938         x = (be16_to_cpup((__be16 *)&data[2]) << 1) | ((data[9] >> 1) & 1);
 939         y = (be16_to_cpup((__be16 *)&data[4]) << 1) | (data[9] & 1);
 940         distance = data[9] >> 2;
 941         if (features->type < INTUOS3S) {
 942                 x >>= 1;
 943                 y >>= 1;
 944                 distance >>= 1;
 945         }
 946         if (features->type == INTUOSHT2)
 947                 distance = features->distance_max - distance;
 948         input_report_abs(input, ABS_X, x);
 949         input_report_abs(input, ABS_Y, y);
 950         input_report_abs(input, ABS_DISTANCE, distance);
 951
 952         switch (type) {
 953         case 0x00:
 954         case 0x01:
 955         case 0x02:
 956         case 0x03:
 957                 /* general pen packet */
 958                 t = (data[6] << 3) | ((data[7] & 0xC0) >> 5) | (data[1] & 1);
 959                 if (features->pressure_max < 2047)
 960                         t >>= 1;
 961                 input_report_abs(input, ABS_PRESSURE, t);
 962                 if (features->type != INTUOSHT2) {
 963                     input_report_abs(input, ABS_TILT_X,
 964                                  (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
 965                     input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
 966                 }
 967                 input_report_key(input, BTN_STYLUS, data[1] & 2);
 968                 input_report_key(input, BTN_STYLUS2, data[1] & 4);
 969                 input_report_key(input, BTN_TOUCH, t > 10);
 970                 break;
 971
 972         case 0x0a:
 973                 /* airbrush second packet */
 974                 input_report_abs(input, ABS_WHEEL,
 975                                 (data[6] << 2) | ((data[7] >> 6) & 3));
 976                 input_report_abs(input, ABS_TILT_X,
 977                                  (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
 978                 input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
 979                 break;
 980
 981         case 0x05:
 982                 /* Rotation packet */
 983                 if (features->type >= INTUOS3S) {
 984                         /* I3 marker pen rotation */
 985                         t = (data[6] << 3) | ((data[7] >> 5) & 7);
 986                         t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
 987                                 ((t-1) / 2 + 450)) : (450 - t / 2) ;
 988                         input_report_abs(input, ABS_Z, t);
 989                 } else {
 990                         /* 4D mouse 2nd packet */
 991                         t = (data[6] << 3) | ((data[7] >> 5) & 7);
 992                         input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
 993                                 ((t - 1) / 2) : -t / 2);
 994                 }
 995                 break;
 996
 997         case 0x04:
 998                 /* 4D mouse 1st packet */
 999                 input_report_key(input, BTN_LEFT,   data[8] & 0x01);
1000                 input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
1001                 input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
1002
1003                 input_report_key(input, BTN_SIDE,   data[8] & 0x20);
1004                 input_report_key(input, BTN_EXTRA,  data[8] & 0x10);
1005                 t = (data[6] << 2) | ((data[7] >> 6) & 3);
1006                 input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
1007                 break;
1008
1009         case 0x06:
1010                 /* I4 mouse */
1011                 input_report_key(input, BTN_LEFT,   data[6] & 0x01);
1012                 input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
1013                 input_report_key(input, BTN_RIGHT,  data[6] & 0x04);
1014                 input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
1015                                  - ((data[7] & 0x40) >> 6));
1016                 input_report_key(input, BTN_SIDE,   data[6] & 0x08);
1017                 input_report_key(input, BTN_EXTRA,  data[6] & 0x10);
1018
1019                 input_report_abs(input, ABS_TILT_X,
1020                         (((data[7] << 1) & 0x7e) | (data[8] >> 7)) - 64);
1021                 input_report_abs(input, ABS_TILT_Y, (data[8] & 0x7f) - 64);
1022                 break;
1023
1024         case 0x08:
1025                 if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
1026                         /* 2D mouse packet */
1027                         input_report_key(input, BTN_LEFT,   data[8] & 0x04);
1028                         input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
1029                         input_report_key(input, BTN_RIGHT,  data[8] & 0x10);
1030                         input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
1031                                          - ((data[8] & 0x02) >> 1));
1032
1033                         /* I3 2D mouse side buttons */
1034                         if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
1035                                 input_report_key(input, BTN_SIDE,   data[8] & 0x40);
1036                                 input_report_key(input, BTN_EXTRA,  data[8] & 0x20);
1037                         }
1038                 }
1039                 else if (wacom->tool[idx] == BTN_TOOL_LENS) {
1040                         /* Lens cursor packets */
1041                         input_report_key(input, BTN_LEFT,   data[8] & 0x01);
1042                         input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
1043                         input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
1044                         input_report_key(input, BTN_SIDE,   data[8] & 0x10);
1045                         input_report_key(input, BTN_EXTRA,  data[8] & 0x08);
1046                 }
1047                 break;
1048
1049         case 0x07:
1050         case 0x09:
1051         case 0x0b:
1052         case 0x0c:
1053         case 0x0d:
1054         case 0x0e:
1055         case 0x0f:
1056                 /* unhandled */
1057                 break;
1058         }
1059
1060         input_report_abs(input, ABS_MISC,
1061                          wacom_intuos_id_mangle(wacom->id[idx])); /* report tool id */
1062         input_report_key(input, wacom->tool[idx], 1);
1063         input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
1064         wacom->reporting_data = true;
1065         return 2;
1066 }
1067
1068 static int wacom_intuos_irq(struct wacom_wac *wacom)
1069 {
1070         unsigned char *data = wacom->data;
1071         struct input_dev *input = wacom->pen_input;
1072         int result;
1073
1074         if (data[0] != WACOM_REPORT_PENABLED &&
1075             data[0] != WACOM_REPORT_INTUOS_ID1 &&
1076             data[0] != WACOM_REPORT_INTUOS_ID2 &&
1077             data[0] != WACOM_REPORT_INTUOSPAD &&
1078             data[0] != WACOM_REPORT_INTUOS_PEN &&
1079             data[0] != WACOM_REPORT_CINTIQ &&
1080             data[0] != WACOM_REPORT_CINTIQPAD &&
1081             data[0] != WACOM_REPORT_INTUOS5PAD) {
1082                 dev_dbg(input->dev.parent,
1083                         "%s: received unknown report #%d\n", __func__, data[0]);
1084                 return 0;
1085         }
1086
1087         /* process pad events */
1088         result = wacom_intuos_pad(wacom);
1089         if (result)
1090                 return result;
1091
1092         /* process in/out prox events */
1093         result = wacom_intuos_inout(wacom);
1094         if (result)
1095                 return result - 1;
1096
1097         /* process general packets */
1098         result = wacom_intuos_general(wacom);
1099         if (result)
1100                 return result - 1;
1101
1102         return 0;
1103 }
1104
1105 static int wacom_remote_irq(struct wacom_wac *wacom_wac, size_t len)
1106 {
1107         unsigned char *data = wacom_wac->data;
1108         struct input_dev *input;
1109         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
1110         struct wacom_remote *remote = wacom->remote;
1111         int bat_charging, bat_percent, touch_ring_mode;
1112         __u32 serial;
1113         int i, index = -1;
1114         unsigned long flags;
1115
1116         if (data[0] != WACOM_REPORT_REMOTE) {
1117                 hid_dbg(wacom->hdev, "%s: received unknown report #%d",
1118                         __func__, data[0]);
1119                 return 0;
1120         }
1121
1122         serial = data[3] + (data[4] << 8) + (data[5] << 16);
1123         wacom_wac->id[0] = PAD_DEVICE_ID;
1124
1125         spin_lock_irqsave(&remote->remote_lock, flags);
1126
1127         for (i = 0; i < WACOM_MAX_REMOTES; i++) {
1128                 if (remote->remotes[i].serial == serial) {
1129                         index = i;
1130                         break;
1131                 }
1132         }
1133
1134         if (index < 0 || !remote->remotes[index].registered)
1135                 goto out;
1136
1137         input = remote->remotes[index].input;
1138
1139         input_report_key(input, BTN_0, (data[9] & 0x01));
1140         input_report_key(input, BTN_1, (data[9] & 0x02));
1141         input_report_key(input, BTN_2, (data[9] & 0x04));
1142         input_report_key(input, BTN_3, (data[9] & 0x08));
1143         input_report_key(input, BTN_4, (data[9] & 0x10));
1144         input_report_key(input, BTN_5, (data[9] & 0x20));
1145         input_report_key(input, BTN_6, (data[9] & 0x40));
1146         input_report_key(input, BTN_7, (data[9] & 0x80));
1147
1148         input_report_key(input, BTN_8, (data[10] & 0x01));
1149         input_report_key(input, BTN_9, (data[10] & 0x02));
1150         input_report_key(input, BTN_A, (data[10] & 0x04));
1151         input_report_key(input, BTN_B, (data[10] & 0x08));
1152         input_report_key(input, BTN_C, (data[10] & 0x10));
1153         input_report_key(input, BTN_X, (data[10] & 0x20));
1154         input_report_key(input, BTN_Y, (data[10] & 0x40));
1155         input_report_key(input, BTN_Z, (data[10] & 0x80));
1156
1157         input_report_key(input, BTN_BASE, (data[11] & 0x01));
1158         input_report_key(input, BTN_BASE2, (data[11] & 0x02));
1159
1160         if (data[12] & 0x80)
1161                 input_report_abs(input, ABS_WHEEL, (data[12] & 0x7f) - 1);
1162         else
1163                 input_report_abs(input, ABS_WHEEL, 0);
1164
1165         bat_percent = data[7] & 0x7f;
1166         bat_charging = !!(data[7] & 0x80);
1167
1168         if (data[9] | data[10] | (data[11] & 0x03) | data[12])
1169                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
1170         else
1171                 input_report_abs(input, ABS_MISC, 0);
1172
1173         input_event(input, EV_MSC, MSC_SERIAL, serial);
1174
1175         input_sync(input);
1176
1177         /*Which mode select (LED light) is currently on?*/
1178         touch_ring_mode = (data[11] & 0xC0) >> 6;
1179
1180         for (i = 0; i < WACOM_MAX_REMOTES; i++) {
1181                 if (remote->remotes[i].serial == serial)
1182                         wacom->led.groups[i].select = touch_ring_mode;
1183         }
1184
1185         __wacom_notify_battery(&remote->remotes[index].battery,
1186                                 WACOM_POWER_SUPPLY_STATUS_AUTO, bat_percent,
1187                                 bat_charging, 1, bat_charging);
1188
1189 out:
1190         spin_unlock_irqrestore(&remote->remote_lock, flags);
1191         return 0;
1192 }
1193
1194 static void wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
1195 {
1196         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
1197         unsigned char *data = wacom_wac->data;
1198         struct wacom_remote *remote = wacom->remote;
1199         struct wacom_remote_data remote_data;
1200         unsigned long flags;
1201         int i, ret;
1202
1203         if (data[0] != WACOM_REPORT_DEVICE_LIST)
1204                 return;
1205
1206         memset(&remote_data, 0, sizeof(struct wacom_remote_data));
1207
1208         for (i = 0; i < WACOM_MAX_REMOTES; i++) {
1209                 int j = i * 6;
1210                 int serial = (data[j+6] << 16) + (data[j+5] << 8) + data[j+4];
1211                 bool connected = data[j+2];
1212
1213                 remote_data.remote[i].serial = serial;
1214                 remote_data.remote[i].connected = connected;
1215         }
1216
1217         spin_lock_irqsave(&remote->remote_lock, flags);
1218
1219         ret = kfifo_in(&remote->remote_fifo, &remote_data, sizeof(remote_data));
1220         if (ret != sizeof(remote_data)) {
1221                 spin_unlock_irqrestore(&remote->remote_lock, flags);
1222                 hid_err(wacom->hdev, "Can't queue Remote status event.\n");
1223                 return;
1224         }
1225
1226         spin_unlock_irqrestore(&remote->remote_lock, flags);
1227
1228         wacom_schedule_work(wacom_wac, WACOM_WORKER_REMOTE);
1229 }
1230
1231 static int int_dist(int x1, int y1, int x2, int y2)
1232 {
1233         int x = x2 - x1;
1234         int y = y2 - y1;
1235
1236         return int_sqrt(x*x + y*y);
1237 }
1238
1239 static void wacom_intuos_bt_process_data(struct wacom_wac *wacom,
1240                 unsigned char *data)
1241 {
1242         memcpy(wacom->data, data, 10);
1243         wacom_intuos_irq(wacom);
1244
1245         input_sync(wacom->pen_input);
1246         if (wacom->pad_input)
1247                 input_sync(wacom->pad_input);
1248 }
1249
1250 static int wacom_intuos_bt_irq(struct wacom_wac *wacom, size_t len)
1251 {
1252         unsigned char data[WACOM_PKGLEN_MAX];
1253         int i = 1;
1254         unsigned power_raw, battery_capacity, bat_charging, ps_connected;
1255
1256         memcpy(data, wacom->data, len);
1257
1258         switch (data[0]) {
1259         case 0x04:
1260                 wacom_intuos_bt_process_data(wacom, data + i);
1261                 i += 10;
1262                 fallthrough;
1263         case 0x03:
1264                 wacom_intuos_bt_process_data(wacom, data + i);
1265                 i += 10;
1266                 wacom_intuos_bt_process_data(wacom, data + i);
1267                 i += 10;
1268                 power_raw = data[i];
1269                 bat_charging = (power_raw & 0x08) ? 1 : 0;
1270                 ps_connected = (power_raw & 0x10) ? 1 : 0;
1271                 battery_capacity = batcap_i4[power_raw & 0x07];
1272                 wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
1273                                      battery_capacity, bat_charging,
1274                                      battery_capacity || bat_charging,
1275                                      ps_connected);
1276                 break;
1277         default:
1278                 dev_dbg(wacom->pen_input->dev.parent,
1279                                 "Unknown report: %d,%d size:%zu\n",
1280                                 data[0], data[1], len);
1281                 return 0;
1282         }
1283         return 0;
1284 }
1285
1286 static int wacom_wac_finger_count_touches(struct wacom_wac *wacom)
1287 {
1288         struct input_dev *input = wacom->touch_input;
1289         unsigned touch_max = wacom->features.touch_max;
1290         int count = 0;
1291         int i;
1292
1293         if (!touch_max)
1294                 return 0;
1295
1296         if (touch_max == 1)
1297                 return test_bit(BTN_TOUCH, input->key) &&
1298                         report_touch_events(wacom);
1299
1300         for (i = 0; i < input->mt->num_slots; i++) {
1301                 struct input_mt_slot *ps = &input->mt->slots[i];
1302                 int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
1303                 if (id >= 0)
1304                         count++;
1305         }
1306
1307         return count;
1308 }
1309
1310 static void wacom_intuos_pro2_bt_pen(struct wacom_wac *wacom)
1311 {
1312         int pen_frame_len, pen_frames;
1313
1314         struct input_dev *pen_input = wacom->pen_input;
1315         unsigned char *data = wacom->data;
1316         int number_of_valid_frames = 0;
1317         int time_interval = 15000000;
1318         ktime_t time_packet_received = ktime_get();
1319         int i;
1320
1321         if (wacom->features.type == INTUOSP2_BT ||
1322             wacom->features.type == INTUOSP2S_BT) {
1323                 wacom->serial[0] = get_unaligned_le64(&data[99]);
1324                 wacom->id[0]     = get_unaligned_le16(&data[107]);
1325                 pen_frame_len = 14;
1326                 pen_frames = 7;
1327         } else {
1328                 wacom->serial[0] = get_unaligned_le64(&data[33]);
1329                 wacom->id[0]     = get_unaligned_le16(&data[41]);
1330                 pen_frame_len = 8;
1331                 pen_frames = 4;
1332         }
1333
1334         if (wacom->serial[0] >> 52 == 1) {
1335                 /* Add back in missing bits of ID for non-USI pens */
1336                 wacom->id[0] |= (wacom->serial[0] >> 32) & 0xFFFFF;
1337         }
1338
1339         /* number of valid frames */
1340         for (i = 0; i < pen_frames; i++) {
1341                 unsigned char *frame = &data[i*pen_frame_len + 1];
1342                 bool valid = frame[0] & 0x80;
1343
1344                 if (valid)
1345                         number_of_valid_frames++;
1346         }
1347
1348         if (number_of_valid_frames) {
1349                 if (wacom->hid_data.time_delayed)
1350                         time_interval = ktime_get() - wacom->hid_data.time_delayed;
1351                 time_interval /= number_of_valid_frames;
1352                 wacom->hid_data.time_delayed = time_packet_received;
1353         }
1354
1355         for (i = 0; i < number_of_valid_frames; i++) {
1356                 unsigned char *frame = &data[i*pen_frame_len + 1];
1357                 bool valid = frame[0] & 0x80;
1358                 bool prox = frame[0] & 0x40;
1359                 bool range = frame[0] & 0x20;
1360                 bool invert = frame[0] & 0x10;
1361                 int frames_number_reversed = number_of_valid_frames - i - 1;
1362                 int event_timestamp = time_packet_received - frames_number_reversed * time_interval;
1363
1364                 if (!valid)
1365                         continue;
1366
1367                 if (!prox) {
1368                         wacom->shared->stylus_in_proximity = false;
1369                         wacom_exit_report(wacom);
1370                         input_sync(pen_input);
1371
1372                         wacom->tool[0] = 0;
1373                         wacom->id[0] = 0;
1374                         wacom->serial[0] = 0;
1375                         wacom->hid_data.time_delayed = 0;
1376                         return;
1377                 }
1378
1379                 if (range) {
1380                         if (!wacom->tool[0]) { /* first in range */
1381                                 /* Going into range select tool */
1382                                 if (invert)
1383                                         wacom->tool[0] = BTN_TOOL_RUBBER;
1384                                 else if (wacom->id[0])
1385                                         wacom->tool[0] = wacom_intuos_get_tool_type(wacom->id[0]);
1386                                 else
1387                                         wacom->tool[0] = BTN_TOOL_PEN;
1388                         }
1389
1390                         input_report_abs(pen_input, ABS_X, get_unaligned_le16(&frame[1]));
1391                         input_report_abs(pen_input, ABS_Y, get_unaligned_le16(&frame[3]));
1392
1393                         if (wacom->features.type == INTUOSP2_BT ||
1394                             wacom->features.type == INTUOSP2S_BT) {
1395                                 /* Fix rotation alignment: userspace expects zero at left */
1396                                 int16_t rotation =
1397                                         (int16_t)get_unaligned_le16(&frame[9]);
1398                                 rotation += 1800/4;
1399
1400                                 if (rotation > 899)
1401                                         rotation -= 1800;
1402
1403                                 input_report_abs(pen_input, ABS_TILT_X,
1404                                                  (char)frame[7]);
1405                                 input_report_abs(pen_input, ABS_TILT_Y,
1406                                                  (char)frame[8]);
1407                                 input_report_abs(pen_input, ABS_Z, rotation);
1408                                 input_report_abs(pen_input, ABS_WHEEL,
1409                                                  get_unaligned_le16(&frame[11]));
1410                         }
1411                 }
1412
1413                 if (wacom->tool[0]) {
1414                         input_report_abs(pen_input, ABS_PRESSURE, get_unaligned_le16(&frame[5]));
1415                         if (wacom->features.type == INTUOSP2_BT ||
1416                             wacom->features.type == INTUOSP2S_BT) {
1417                                 input_report_abs(pen_input, ABS_DISTANCE,
1418                                                  range ? frame[13] : wacom->features.distance_max);
1419                         } else {
1420                                 input_report_abs(pen_input, ABS_DISTANCE,
1421                                                  range ? frame[7] : wacom->features.distance_max);
1422                         }
1423
1424                         input_report_key(pen_input, BTN_TOUCH, frame[0] & 0x09);
1425                         input_report_key(pen_input, BTN_STYLUS, frame[0] & 0x02);
1426                         input_report_key(pen_input, BTN_STYLUS2, frame[0] & 0x04);
1427
1428                         input_report_key(pen_input, wacom->tool[0], prox);
1429                         input_event(pen_input, EV_MSC, MSC_SERIAL, wacom->serial[0]);
1430                         input_report_abs(pen_input, ABS_MISC,
1431                                          wacom_intuos_id_mangle(wacom->id[0])); /* report tool id */
1432                 }
1433
1434                 wacom->shared->stylus_in_proximity = prox;
1435
1436                 /* add timestamp to unpack the frames */
1437                 input_set_timestamp(pen_input, event_timestamp);
1438
1439                 input_sync(pen_input);
1440         }
1441 }
1442
1443 static void wacom_intuos_pro2_bt_touch(struct wacom_wac *wacom)
1444 {
1445         const int finger_touch_len = 8;
1446         const int finger_frames = 4;
1447         const int finger_frame_len = 43;
1448
1449         struct input_dev *touch_input = wacom->touch_input;
1450         unsigned char *data = wacom->data;
1451         int num_contacts_left = 5;
1452         int i, j;
1453
1454         for (i = 0; i < finger_frames; i++) {
1455                 unsigned char *frame = &data[i*finger_frame_len + 109];
1456                 int current_num_contacts = frame[0] & 0x7F;
1457                 int contacts_to_send;
1458
1459                 if (!(frame[0] & 0x80))
1460                         continue;
1461
1462                 /*
1463                  * First packet resets the counter since only the first
1464                  * packet in series will have non-zero current_num_contacts.
1465                  */
1466                 if (current_num_contacts)
1467                         wacom->num_contacts_left = current_num_contacts;
1468
1469                 contacts_to_send = min(num_contacts_left, wacom->num_contacts_left);
1470
1471                 for (j = 0; j < contacts_to_send; j++) {
1472                         unsigned char *touch = &frame[j*finger_touch_len + 1];
1473                         int slot = input_mt_get_slot_by_key(touch_input, touch[0]);
1474                         int x = get_unaligned_le16(&touch[2]);
1475                         int y = get_unaligned_le16(&touch[4]);
1476                         int w = touch[6] * input_abs_get_res(touch_input, ABS_MT_POSITION_X);
1477                         int h = touch[7] * input_abs_get_res(touch_input, ABS_MT_POSITION_Y);
1478
1479                         if (slot < 0)
1480                                 continue;
1481
1482                         input_mt_slot(touch_input, slot);
1483                         input_mt_report_slot_state(touch_input, MT_TOOL_FINGER, touch[1] & 0x01);
1484                         input_report_abs(touch_input, ABS_MT_POSITION_X, x);
1485                         input_report_abs(touch_input, ABS_MT_POSITION_Y, y);
1486                         input_report_abs(touch_input, ABS_MT_TOUCH_MAJOR, max(w, h));
1487                         input_report_abs(touch_input, ABS_MT_TOUCH_MINOR, min(w, h));
1488                         input_report_abs(touch_input, ABS_MT_ORIENTATION, w > h);
1489                 }
1490
1491                 input_mt_sync_frame(touch_input);
1492
1493                 wacom->num_contacts_left -= contacts_to_send;
1494                 if (wacom->num_contacts_left <= 0) {
1495                         wacom->num_contacts_left = 0;
1496                         wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1497                         input_sync(touch_input);
1498                 }
1499         }
1500
1501         if (wacom->num_contacts_left == 0) {
1502                 // Be careful that we don't accidentally call input_sync with
1503                 // only a partial set of fingers of processed
1504                 input_report_switch(touch_input, SW_MUTE_DEVICE, !(data[281] >> 7));
1505                 input_sync(touch_input);
1506         }
1507
1508 }
1509
1510 static void wacom_intuos_pro2_bt_pad(struct wacom_wac *wacom)
1511 {
1512         struct input_dev *pad_input = wacom->pad_input;
1513         unsigned char *data = wacom->data;
1514         int nbuttons = wacom->features.numbered_buttons;
1515
1516         int expresskeys = data[282];
1517         int center = (data[281] & 0x40) >> 6;
1518         int ring = data[285] & 0x7F;
1519         bool ringstatus = data[285] & 0x80;
1520         bool prox = expresskeys || center || ringstatus;
1521
1522         /* Fix touchring data: userspace expects 0 at left and increasing clockwise */
1523         ring = 71 - ring;
1524         ring += 3*72/16;
1525         if (ring > 71)
1526                 ring -= 72;
1527
1528         wacom_report_numbered_buttons(pad_input, nbuttons,
1529                                       expresskeys | (center << (nbuttons - 1)));
1530
1531         input_report_abs(pad_input, ABS_WHEEL, ringstatus ? ring : 0);
1532
1533         input_report_key(pad_input, wacom->tool[1], prox ? 1 : 0);
1534         input_report_abs(pad_input, ABS_MISC, prox ? PAD_DEVICE_ID : 0);
1535         input_event(pad_input, EV_MSC, MSC_SERIAL, 0xffffffff);
1536
1537         input_sync(pad_input);
1538 }
1539
1540 static void wacom_intuos_pro2_bt_battery(struct wacom_wac *wacom)
1541 {
1542         unsigned char *data = wacom->data;
1543
1544         bool chg = data[284] & 0x80;
1545         int battery_status = data[284] & 0x7F;
1546
1547         wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
1548                              battery_status, chg, 1, chg);
1549 }
1550
1551 static void wacom_intuos_gen3_bt_pad(struct wacom_wac *wacom)
1552 {
1553         struct input_dev *pad_input = wacom->pad_input;
1554         unsigned char *data = wacom->data;
1555
1556         int buttons = data[44];
1557
1558         wacom_report_numbered_buttons(pad_input, 4, buttons);
1559
1560         input_report_key(pad_input, wacom->tool[1], buttons ? 1 : 0);
1561         input_report_abs(pad_input, ABS_MISC, buttons ? PAD_DEVICE_ID : 0);
1562         input_event(pad_input, EV_MSC, MSC_SERIAL, 0xffffffff);
1563
1564         input_sync(pad_input);
1565 }
1566
1567 static void wacom_intuos_gen3_bt_battery(struct wacom_wac *wacom)
1568 {
1569         unsigned char *data = wacom->data;
1570
1571         bool chg = data[45] & 0x80;
1572         int battery_status = data[45] & 0x7F;
1573
1574         wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
1575                              battery_status, chg, 1, chg);
1576 }
1577
1578 static int wacom_intuos_pro2_bt_irq(struct wacom_wac *wacom, size_t len)
1579 {
1580         unsigned char *data = wacom->data;
1581
1582         if (data[0] != 0x80 && data[0] != 0x81) {
1583                 dev_dbg(wacom->pen_input->dev.parent,
1584                         "%s: received unknown report #%d\n", __func__, data[0]);
1585                 return 0;
1586         }
1587
1588         wacom_intuos_pro2_bt_pen(wacom);
1589         if (wacom->features.type == INTUOSP2_BT ||
1590             wacom->features.type == INTUOSP2S_BT) {
1591                 wacom_intuos_pro2_bt_touch(wacom);
1592                 wacom_intuos_pro2_bt_pad(wacom);
1593                 wacom_intuos_pro2_bt_battery(wacom);
1594         } else {
1595                 wacom_intuos_gen3_bt_pad(wacom);
1596                 wacom_intuos_gen3_bt_battery(wacom);
1597         }
1598         return 0;
1599 }
1600
1601 static int wacom_24hdt_irq(struct wacom_wac *wacom)
1602 {
1603         struct input_dev *input = wacom->touch_input;
1604         unsigned char *data = wacom->data;
1605         int i;
1606         int current_num_contacts = data[61];
1607         int contacts_to_send = 0;
1608         int num_contacts_left = 4; /* maximum contacts per packet */
1609         int byte_per_packet = WACOM_BYTES_PER_24HDT_PACKET;
1610         int y_offset = 2;
1611
1612         if (touch_is_muted(wacom) && !wacom->shared->touch_down)
1613                 return 0;
1614
1615         if (wacom->features.type == WACOM_27QHDT) {
1616                 current_num_contacts = data[63];
1617                 num_contacts_left = 10;
1618                 byte_per_packet = WACOM_BYTES_PER_QHDTHID_PACKET;
1619                 y_offset = 0;
1620         }
1621
1622         /*
1623          * First packet resets the counter since only the first
1624          * packet in series will have non-zero current_num_contacts.
1625          */
1626         if (current_num_contacts)
1627                 wacom->num_contacts_left = current_num_contacts;
1628
1629         contacts_to_send = min(num_contacts_left, wacom->num_contacts_left);
1630
1631         for (i = 0; i < contacts_to_send; i++) {
1632                 int offset = (byte_per_packet * i) + 1;
1633                 bool touch = (data[offset] & 0x1) && report_touch_events(wacom);
1634                 int slot = input_mt_get_slot_by_key(input, data[offset + 1]);
1635
1636                 if (slot < 0)
1637                         continue;
1638                 input_mt_slot(input, slot);
1639                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1640
1641                 if (touch) {
1642                         int t_x = get_unaligned_le16(&data[offset + 2]);
1643                         int t_y = get_unaligned_le16(&data[offset + 4 + y_offset]);
1644
1645                         input_report_abs(input, ABS_MT_POSITION_X, t_x);
1646                         input_report_abs(input, ABS_MT_POSITION_Y, t_y);
1647
1648                         if (wacom->features.type != WACOM_27QHDT) {
1649                                 int c_x = get_unaligned_le16(&data[offset + 4]);
1650                                 int c_y = get_unaligned_le16(&data[offset + 8]);
1651                                 int w = get_unaligned_le16(&data[offset + 10]);
1652                                 int h = get_unaligned_le16(&data[offset + 12]);
1653
1654                                 input_report_abs(input, ABS_MT_TOUCH_MAJOR, min(w,h));
1655                                 input_report_abs(input, ABS_MT_WIDTH_MAJOR,
1656                                                  min(w, h) + int_dist(t_x, t_y, c_x, c_y));
1657                                 input_report_abs(input, ABS_MT_WIDTH_MINOR, min(w, h));
1658                                 input_report_abs(input, ABS_MT_ORIENTATION, w > h);
1659                         }
1660                 }
1661         }
1662         input_mt_sync_frame(input);
1663
1664         wacom->num_contacts_left -= contacts_to_send;
1665         if (wacom->num_contacts_left <= 0) {
1666                 wacom->num_contacts_left = 0;
1667                 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1668         }
1669         return 1;
1670 }
1671
1672 static int wacom_mt_touch(struct wacom_wac *wacom)
1673 {
1674         struct input_dev *input = wacom->touch_input;
1675         unsigned char *data = wacom->data;
1676         int i;
1677         int current_num_contacts = data[2];
1678         int contacts_to_send = 0;
1679         int x_offset = 0;
1680
1681         /* MTTPC does not support Height and Width */
1682         if (wacom->features.type == MTTPC || wacom->features.type == MTTPC_B)
1683                 x_offset = -4;
1684
1685         /*
1686          * First packet resets the counter since only the first
1687          * packet in series will have non-zero current_num_contacts.
1688          */
1689         if (current_num_contacts)
1690                 wacom->num_contacts_left = current_num_contacts;
1691
1692         /* There are at most 5 contacts per packet */
1693         contacts_to_send = min(5, wacom->num_contacts_left);
1694
1695         for (i = 0; i < contacts_to_send; i++) {
1696                 int offset = (WACOM_BYTES_PER_MT_PACKET + x_offset) * i + 3;
1697                 bool touch = (data[offset] & 0x1) && report_touch_events(wacom);
1698                 int id = get_unaligned_le16(&data[offset + 1]);
1699                 int slot = input_mt_get_slot_by_key(input, id);
1700
1701                 if (slot < 0)
1702                         continue;
1703
1704                 input_mt_slot(input, slot);
1705                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1706                 if (touch) {
1707                         int x = get_unaligned_le16(&data[offset + x_offset + 7]);
1708                         int y = get_unaligned_le16(&data[offset + x_offset + 9]);
1709                         input_report_abs(input, ABS_MT_POSITION_X, x);
1710                         input_report_abs(input, ABS_MT_POSITION_Y, y);
1711                 }
1712         }
1713         input_mt_sync_frame(input);
1714
1715         wacom->num_contacts_left -= contacts_to_send;
1716         if (wacom->num_contacts_left <= 0) {
1717                 wacom->num_contacts_left = 0;
1718                 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1719         }
1720         return 1;
1721 }
1722
1723 static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
1724 {
1725         struct input_dev *input = wacom->touch_input;
1726         unsigned char *data = wacom->data;
1727         int i;
1728
1729         for (i = 0; i < 2; i++) {
1730                 int p = data[1] & (1 << i);
1731                 bool touch = p && report_touch_events(wacom);
1732
1733                 input_mt_slot(input, i);
1734                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1735                 if (touch) {
1736                         int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
1737                         int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;
1738
1739                         input_report_abs(input, ABS_MT_POSITION_X, x);
1740                         input_report_abs(input, ABS_MT_POSITION_Y, y);
1741                 }
1742         }
1743         input_mt_sync_frame(input);
1744
1745         /* keep touch state for pen event */
1746         wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
1747
1748         return 1;
1749 }
1750
1751 static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
1752 {
1753         unsigned char *data = wacom->data;
1754         struct input_dev *input = wacom->touch_input;
1755         bool prox = report_touch_events(wacom);
1756         int x = 0, y = 0;
1757
1758         if (wacom->features.touch_max > 1 || len > WACOM_PKGLEN_TPC2FG)
1759                 return 0;
1760
1761         if (len == WACOM_PKGLEN_TPC1FG) {
1762                 prox = prox && (data[0] & 0x01);
1763                 x = get_unaligned_le16(&data[1]);
1764                 y = get_unaligned_le16(&data[3]);
1765         } else if (len == WACOM_PKGLEN_TPC1FG_B) {
1766                 prox = prox && (data[2] & 0x01);
1767                 x = get_unaligned_le16(&data[3]);
1768                 y = get_unaligned_le16(&data[5]);
1769         } else {
1770                 prox = prox && (data[1] & 0x01);
1771                 x = le16_to_cpup((__le16 *)&data[2]);
1772                 y = le16_to_cpup((__le16 *)&data[4]);
1773         }
1774
1775         if (prox) {
1776                 input_report_abs(input, ABS_X, x);
1777                 input_report_abs(input, ABS_Y, y);
1778         }
1779         input_report_key(input, BTN_TOUCH, prox);
1780
1781         /* keep touch state for pen events */
1782         wacom->shared->touch_down = prox;
1783
1784         return 1;
1785 }
1786
1787 static int wacom_tpc_pen(struct wacom_wac *wacom)
1788 {
1789         unsigned char *data = wacom->data;
1790         struct input_dev *input = wacom->pen_input;
1791         bool prox = data[1] & 0x20;
1792
1793         if (!wacom->shared->stylus_in_proximity) /* first in prox */
1794                 /* Going into proximity select tool */
1795                 wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
1796
1797         /* keep pen state for touch events */
1798         wacom->shared->stylus_in_proximity = prox;
1799
1800         /* send pen events only when touch is up or forced out
1801          * or touch arbitration is off
1802          */
1803         if (!delay_pen_events(wacom)) {
1804                 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
1805                 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
1806                 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
1807                 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
1808                 input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x07) << 8) | data[6]);
1809                 input_report_key(input, BTN_TOUCH, data[1] & 0x05);
1810                 input_report_key(input, wacom->tool[0], prox);
1811                 return 1;
1812         }
1813
1814         return 0;
1815 }
1816
1817 static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
1818 {
1819         unsigned char *data = wacom->data;
1820
1821         if (wacom->pen_input) {
1822                 dev_dbg(wacom->pen_input->dev.parent,
1823                         "%s: received report #%d\n", __func__, data[0]);
1824
1825                 if (len == WACOM_PKGLEN_PENABLED ||
1826                     data[0] == WACOM_REPORT_PENABLED)
1827                         return wacom_tpc_pen(wacom);
1828         }
1829         else if (wacom->touch_input) {
1830                 dev_dbg(wacom->touch_input->dev.parent,
1831                         "%s: received report #%d\n", __func__, data[0]);
1832
1833                 switch (len) {
1834                 case WACOM_PKGLEN_TPC1FG:
1835                         return wacom_tpc_single_touch(wacom, len);
1836
1837                 case WACOM_PKGLEN_TPC2FG:
1838                         return wacom_tpc_mt_touch(wacom);
1839
1840                 default:
1841                         switch (data[0]) {
1842                         case WACOM_REPORT_TPC1FG:
1843                         case WACOM_REPORT_TPCHID:
1844                         case WACOM_REPORT_TPCST:
1845                         case WACOM_REPORT_TPC1FGE:
1846                                 return wacom_tpc_single_touch(wacom, len);
1847
1848                         case WACOM_REPORT_TPCMT:
1849                         case WACOM_REPORT_TPCMT2:
1850                                 return wacom_mt_touch(wacom);
1851
1852                         }
1853                 }
1854         }
1855
1856         return 0;
1857 }
1858
1859 static int wacom_offset_rotation(struct input_dev *input, struct hid_usage *usage,
1860                                  int value, int num, int denom)
1861 {
1862         struct input_absinfo *abs = &input->absinfo[usage->code];
1863         int range = (abs->maximum - abs->minimum + 1);
1864
1865         value += num*range/denom;
1866         if (value > abs->maximum)
1867                 value -= range;
1868         else if (value < abs->minimum)
1869                 value += range;
1870         return value;
1871 }
1872
1873 int wacom_equivalent_usage(int usage)
1874 {
1875         if ((usage & HID_USAGE_PAGE) == WACOM_HID_UP_WACOMDIGITIZER) {
1876                 int subpage = (usage & 0xFF00) << 8;
1877                 int subusage = (usage & 0xFF);
1878
1879                 if (subpage == WACOM_HID_SP_PAD ||
1880                     subpage == WACOM_HID_SP_BUTTON ||
1881                     subpage == WACOM_HID_SP_DIGITIZER ||
1882                     subpage == WACOM_HID_SP_DIGITIZERINFO ||
1883                     usage == WACOM_HID_WD_SENSE ||
1884                     usage == WACOM_HID_WD_SERIALHI ||
1885                     usage == WACOM_HID_WD_TOOLTYPE ||
1886                     usage == WACOM_HID_WD_DISTANCE ||
1887                     usage == WACOM_HID_WD_TOUCHSTRIP ||
1888                     usage == WACOM_HID_WD_TOUCHSTRIP2 ||
1889                     usage == WACOM_HID_WD_TOUCHRING ||
1890                     usage == WACOM_HID_WD_TOUCHRINGSTATUS ||
1891                     usage == WACOM_HID_WD_REPORT_VALID ||
1892                     usage == WACOM_HID_WD_BARRELSWITCH3 ||
1893                     usage == WACOM_HID_WD_SEQUENCENUMBER) {
1894                         return usage;
1895                 }
1896
1897                 if (subpage == HID_UP_UNDEFINED)
1898                         subpage = HID_UP_DIGITIZER;
1899
1900                 return subpage | subusage;
1901         }
1902
1903         if ((usage & HID_USAGE_PAGE) == WACOM_HID_UP_WACOMTOUCH) {
1904                 int subpage = (usage & 0xFF00) << 8;
1905                 int subusage = (usage & 0xFF);
1906
1907                 if (usage == WACOM_HID_WT_REPORT_VALID)
1908                         return usage;
1909
1910                 if (subpage == HID_UP_UNDEFINED)
1911                         subpage = WACOM_HID_SP_DIGITIZER;
1912
1913                 return subpage | subusage;
1914         }
1915
1916         return usage;
1917 }
1918
1919 static void wacom_map_usage(struct input_dev *input, struct hid_usage *usage,
1920                 struct hid_field *field, __u8 type, __u16 code, int fuzz)
1921 {
1922         struct wacom *wacom = input_get_drvdata(input);
1923         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1924         struct wacom_features *features = &wacom_wac->features;
1925         int fmin = field->logical_minimum;
1926         int fmax = field->logical_maximum;
1927         unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
1928         int resolution_code = code;
1929         int resolution = hidinput_calc_abs_res(field, resolution_code);
1930
1931         if (equivalent_usage == HID_DG_TWIST) {
1932                 resolution_code = ABS_RZ;
1933         }
1934
1935         if (equivalent_usage == HID_GD_X) {
1936                 fmin += features->offset_left;
1937                 fmax -= features->offset_right;
1938         }
1939         if (equivalent_usage == HID_GD_Y) {
1940                 fmin += features->offset_top;
1941                 fmax -= features->offset_bottom;
1942         }
1943
1944         usage->type = type;
1945         usage->code = code;
1946
1947         switch (type) {
1948         case EV_ABS:
1949                 input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
1950
1951                 /* older tablet may miss physical usage */
1952                 if ((code == ABS_X || code == ABS_Y) && !resolution) {
1953                         resolution = WACOM_INTUOS_RES;
1954                         hid_warn(input,
1955                                  "Wacom usage (%d) missing resolution \n",
1956                                  code);
1957                 }
1958                 input_abs_set_res(input, code, resolution);
1959                 break;
1960         case EV_KEY:
1961         case EV_MSC:
1962         case EV_SW:
1963                 input_set_capability(input, type, code);
1964                 break;
1965         }
1966 }
1967
1968 static void wacom_wac_battery_usage_mapping(struct hid_device *hdev,
1969                 struct hid_field *field, struct hid_usage *usage)
1970 {
1971         return;
1972 }
1973
1974 static void wacom_wac_battery_event(struct hid_device *hdev, struct hid_field *field,
1975                 struct hid_usage *usage, __s32 value)
1976 {
1977         struct wacom *wacom = hid_get_drvdata(hdev);
1978         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1979         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
1980
1981         switch (equivalent_usage) {
1982         case HID_DG_BATTERYSTRENGTH:
1983                 if (value == 0) {
1984                         wacom_wac->hid_data.bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
1985                 }
1986                 else {
1987                         value = value * 100 / (field->logical_maximum - field->logical_minimum);
1988                         wacom_wac->hid_data.battery_capacity = value;
1989                         wacom_wac->hid_data.bat_connected = 1;
1990                         wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
1991                 }
1992                 wacom_wac->features.quirks |= WACOM_QUIRK_BATTERY;
1993                 break;
1994         case WACOM_HID_WD_BATTERY_LEVEL:
1995                 value = value * 100 / (field->logical_maximum - field->logical_minimum);
1996                 wacom_wac->hid_data.battery_capacity = value;
1997                 wacom_wac->hid_data.bat_connected = 1;
1998                 wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
1999                 wacom_wac->features.quirks |= WACOM_QUIRK_BATTERY;
2000                 break;
2001         case WACOM_HID_WD_BATTERY_CHARGING:
2002                 wacom_wac->hid_data.bat_charging = value;
2003                 wacom_wac->hid_data.ps_connected = value;
2004                 wacom_wac->hid_data.bat_connected = 1;
2005                 wacom_wac->hid_data.bat_status = WACOM_POWER_SUPPLY_STATUS_AUTO;
2006                 wacom_wac->features.quirks |= WACOM_QUIRK_BATTERY;
2007                 break;
2008         }
2009 }
2010
2011 static void wacom_wac_battery_pre_report(struct hid_device *hdev,
2012                 struct hid_report *report)
2013 {
2014         return;
2015 }
2016
2017 static void wacom_wac_battery_report(struct hid_device *hdev,
2018                 struct hid_report *report)
2019 {
2020         struct wacom *wacom = hid_get_drvdata(hdev);
2021         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2022
2023         int status = wacom_wac->hid_data.bat_status;
2024         int capacity = wacom_wac->hid_data.battery_capacity;
2025         bool charging = wacom_wac->hid_data.bat_charging;
2026         bool connected = wacom_wac->hid_data.bat_connected;
2027         bool powered = wacom_wac->hid_data.ps_connected;
2028
2029         wacom_notify_battery(wacom_wac, status, capacity, charging,
2030                              connected, powered);
2031 }
2032
2033 static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
2034                 struct hid_field *field, struct hid_usage *usage)
2035 {
2036         struct wacom *wacom = hid_get_drvdata(hdev);
2037         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2038         struct wacom_features *features = &wacom_wac->features;
2039         struct input_dev *input = wacom_wac->pad_input;
2040         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
2041
2042         switch (equivalent_usage) {
2043         case WACOM_HID_WD_ACCELEROMETER_X:
2044                 __set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
2045                 wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 0);
2046                 features->device_type |= WACOM_DEVICETYPE_PAD;
2047                 break;
2048         case WACOM_HID_WD_ACCELEROMETER_Y:
2049                 __set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
2050                 wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 0);
2051                 features->device_type |= WACOM_DEVICETYPE_PAD;
2052                 break;
2053         case WACOM_HID_WD_ACCELEROMETER_Z:
2054                 __set_bit(INPUT_PROP_ACCELEROMETER, input->propbit);
2055                 wacom_map_usage(input, usage, field, EV_ABS, ABS_Z, 0);
2056                 features->device_type |= WACOM_DEVICETYPE_PAD;
2057                 break;
2058         case WACOM_HID_WD_BUTTONCENTER:
2059         case WACOM_HID_WD_BUTTONHOME:
2060         case WACOM_HID_WD_BUTTONUP:
2061         case WACOM_HID_WD_BUTTONDOWN:
2062         case WACOM_HID_WD_BUTTONLEFT:
2063         case WACOM_HID_WD_BUTTONRIGHT:
2064                 wacom_map_usage(input, usage, field, EV_KEY,
2065                                 wacom_numbered_button_to_key(features->numbered_buttons),
2066                                 0);
2067                 features->numbered_buttons++;
2068                 features->device_type |= WACOM_DEVICETYPE_PAD;
2069                 break;
2070         case WACOM_HID_WD_MUTE_DEVICE:
2071                 /* softkey touch switch */
2072                 wacom_wac->is_soft_touch_switch = true;
2073                 fallthrough;
2074         case WACOM_HID_WD_TOUCHONOFF:
2075                 /*
2076                  * These two usages, which are used to mute touch events, come
2077                  * from the pad packet, but are reported on the touch
2078                  * interface. Because the touch interface may not have
2079                  * been created yet, we cannot call wacom_map_usage(). In
2080                  * order to process the usages when we receive them, we set
2081                  * the usage type and code directly.
2082                  */
2083                 wacom_wac->has_mute_touch_switch = true;
2084                 usage->type = EV_SW;
2085                 usage->code = SW_MUTE_DEVICE;
2086                 break;
2087         case WACOM_HID_WD_TOUCHSTRIP:
2088                 wacom_map_usage(input, usage, field, EV_ABS, ABS_RX, 0);
2089                 features->device_type |= WACOM_DEVICETYPE_PAD;
2090                 break;
2091         case WACOM_HID_WD_TOUCHSTRIP2:
2092                 wacom_map_usage(input, usage, field, EV_ABS, ABS_RY, 0);
2093                 features->device_type |= WACOM_DEVICETYPE_PAD;
2094                 break;
2095         case WACOM_HID_WD_TOUCHRING:
2096                 wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0);
2097                 features->device_type |= WACOM_DEVICETYPE_PAD;
2098                 break;
2099         case WACOM_HID_WD_TOUCHRINGSTATUS:
2100                 /*
2101                  * Only set up type/code association. Completely mapping
2102                  * this usage may overwrite the axis resolution and range.
2103                  */
2104                 usage->type = EV_ABS;
2105                 usage->code = ABS_WHEEL;
2106                 set_bit(EV_ABS, input->evbit);
2107                 features->device_type |= WACOM_DEVICETYPE_PAD;
2108                 break;
2109         case WACOM_HID_WD_BUTTONCONFIG:
2110                 wacom_map_usage(input, usage, field, EV_KEY, KEY_BUTTONCONFIG, 0);
2111                 features->device_type |= WACOM_DEVICETYPE_PAD;
2112                 break;
2113         case WACOM_HID_WD_ONSCREEN_KEYBOARD:
2114                 wacom_map_usage(input, usage, field, EV_KEY, KEY_ONSCREEN_KEYBOARD, 0);
2115                 features->device_type |= WACOM_DEVICETYPE_PAD;
2116                 break;
2117         case WACOM_HID_WD_CONTROLPANEL:
2118                 wacom_map_usage(input, usage, field, EV_KEY, KEY_CONTROLPANEL, 0);
2119                 features->device_type |= WACOM_DEVICETYPE_PAD;
2120                 break;
2121         case WACOM_HID_WD_MODE_CHANGE:
2122                 /* do not overwrite previous data */
2123                 if (!wacom_wac->has_mode_change) {
2124                         wacom_wac->has_mode_change = true;
2125                         wacom_wac->is_direct_mode = true;
2126                 }
2127                 features->device_type |= WACOM_DEVICETYPE_PAD;
2128                 break;
2129         }
2130
2131         switch (equivalent_usage & 0xfffffff0) {
2132         case WACOM_HID_WD_EXPRESSKEY00:
2133                 wacom_map_usage(input, usage, field, EV_KEY,
2134                                 wacom_numbered_button_to_key(features->numbered_buttons),
2135                                 0);
2136                 features->numbered_buttons++;
2137                 features->device_type |= WACOM_DEVICETYPE_PAD;
2138                 break;
2139         }
2140 }
2141
2142 static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field,
2143                 struct hid_usage *usage, __s32 value)
2144 {
2145         struct wacom *wacom = hid_get_drvdata(hdev);
2146         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2147         struct input_dev *input = wacom_wac->pad_input;
2148         struct wacom_features *features = &wacom_wac->features;
2149         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
2150         int i;
2151         bool do_report = false;
2152
2153         /*
2154          * Avoid reporting this event and setting inrange_state if this usage
2155          * hasn't been mapped.
2156          */
2157         if (!usage->type && equivalent_usage != WACOM_HID_WD_MODE_CHANGE)
2158                 return;
2159
2160         if (wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY) {
2161                 if (usage->hid != WACOM_HID_WD_TOUCHRING)
2162                         wacom_wac->hid_data.inrange_state |= value;
2163         }
2164
2165         /* Process touch switch state first since it is reported through touch interface,
2166          * which is indepentent of pad interface. In the case when there are no other pad
2167          * events, the pad interface will not even be created.
2168          */
2169         if ((equivalent_usage == WACOM_HID_WD_MUTE_DEVICE) ||
2170            (equivalent_usage == WACOM_HID_WD_TOUCHONOFF)) {
2171                 if (wacom_wac->shared->touch_input) {
2172                         bool *is_touch_on = &wacom_wac->shared->is_touch_on;
2173
2174                         if (equivalent_usage == WACOM_HID_WD_MUTE_DEVICE && value)
2175                                 *is_touch_on = !(*is_touch_on);
2176                         else if (equivalent_usage == WACOM_HID_WD_TOUCHONOFF)
2177                                 *is_touch_on = value;
2178
2179                         input_report_switch(wacom_wac->shared->touch_input,
2180                                             SW_MUTE_DEVICE, !(*is_touch_on));
2181                         input_sync(wacom_wac->shared->touch_input);
2182                 }
2183                 return;
2184         }
2185
2186         if (!input)
2187                 return;
2188
2189         switch (equivalent_usage) {
2190         case WACOM_HID_WD_TOUCHRING:
2191                 /*
2192                  * Userspace expects touchrings to increase in value with
2193                  * clockwise gestures and have their zero point at the
2194                  * tablet's left. HID events "should" be clockwise-
2195                  * increasing and zero at top, though the MobileStudio
2196                  * Pro and 2nd-gen Intuos Pro don't do this...
2197                  */
2198                 if (hdev->vendor == 0x56a &&
2199                     (hdev->product == 0x34d || hdev->product == 0x34e ||  /* MobileStudio Pro */
2200                      hdev->product == 0x357 || hdev->product == 0x358 ||  /* Intuos Pro 2 */
2201                      hdev->product == 0x392 ||                            /* Intuos Pro 2 */
2202                      hdev->product == 0x398 || hdev->product == 0x399 ||  /* MobileStudio Pro */
2203                      hdev->product == 0x3AA)) {                           /* MobileStudio Pro */
2204                         value = (field->logical_maximum - value);
2205
2206                         if (hdev->product == 0x357 || hdev->product == 0x358 ||
2207                             hdev->product == 0x392)
2208                                 value = wacom_offset_rotation(input, usage, value, 3, 16);
2209                         else if (hdev->product == 0x34d || hdev->product == 0x34e ||
2210                                  hdev->product == 0x398 || hdev->product == 0x399 ||
2211                                  hdev->product == 0x3AA)
2212                                 value = wacom_offset_rotation(input, usage, value, 1, 2);
2213                 }
2214                 else {
2215                         value = wacom_offset_rotation(input, usage, value, 1, 4);
2216                 }
2217                 do_report = true;
2218                 break;
2219         case WACOM_HID_WD_TOUCHRINGSTATUS:
2220                 if (!value)
2221                         input_event(input, usage->type, usage->code, 0);
2222                 break;
2223
2224         case WACOM_HID_WD_MODE_CHANGE:
2225                 if (wacom_wac->is_direct_mode != value) {
2226                         wacom_wac->is_direct_mode = value;
2227                         wacom_schedule_work(&wacom->wacom_wac, WACOM_WORKER_MODE_CHANGE);
2228                 }
2229                 break;
2230
2231         case WACOM_HID_WD_BUTTONCENTER:
2232                 for (i = 0; i < wacom->led.count; i++)
2233                         wacom_update_led(wacom, features->numbered_buttons,
2234                                          value, i);
2235                 fallthrough;
2236         default:
2237                 do_report = true;
2238                 break;
2239         }
2240
2241         if (do_report) {
2242                 input_event(input, usage->type, usage->code, value);
2243                 if (value)
2244                         wacom_wac->hid_data.pad_input_event_flag = true;
2245         }
2246 }
2247
2248 static void wacom_wac_pad_pre_report(struct hid_device *hdev,
2249                 struct hid_report *report)
2250 {
2251         struct wacom *wacom = hid_get_drvdata(hdev);
2252         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2253
2254         wacom_wac->hid_data.inrange_state = 0;
2255 }
2256
2257 static void wacom_wac_pad_report(struct hid_device *hdev,
2258                 struct hid_report *report, struct hid_field *field)
2259 {
2260         struct wacom *wacom = hid_get_drvdata(hdev);
2261         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2262         struct input_dev *input = wacom_wac->pad_input;
2263         bool active = wacom_wac->hid_data.inrange_state != 0;
2264
2265         /* report prox for expresskey events */
2266         if (wacom_wac->hid_data.pad_input_event_flag) {
2267                 input_event(input, EV_ABS, ABS_MISC, active ? PAD_DEVICE_ID : 0);
2268                 input_sync(input);
2269                 if (!active)
2270                         wacom_wac->hid_data.pad_input_event_flag = false;
2271         }
2272 }
2273
2274 static void wacom_set_barrel_switch3_usage(struct wacom_wac *wacom_wac)
2275 {
2276         struct input_dev *input = wacom_wac->pen_input;
2277         struct wacom_features *features = &wacom_wac->features;
2278
2279         if (!(features->quirks & WACOM_QUIRK_AESPEN) &&
2280             wacom_wac->hid_data.barrelswitch &&
2281             wacom_wac->hid_data.barrelswitch2 &&
2282             wacom_wac->hid_data.serialhi &&
2283             !wacom_wac->hid_data.barrelswitch3) {
2284                 input_set_capability(input, EV_KEY, BTN_STYLUS3);
2285                 features->quirks |= WACOM_QUIRK_PEN_BUTTON3;
2286         }
2287 }
2288
2289 static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
2290                 struct hid_field *field, struct hid_usage *usage)
2291 {
2292         struct wacom *wacom = hid_get_drvdata(hdev);
2293         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2294         struct wacom_features *features = &wacom_wac->features;
2295         struct input_dev *input = wacom_wac->pen_input;
2296         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
2297
2298         switch (equivalent_usage) {
2299         case HID_GD_X:
2300                 wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 4);
2301                 break;
2302         case HID_GD_Y:
2303                 wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 4);
2304                 break;
2305         case WACOM_HID_WD_DISTANCE:
2306         case HID_GD_Z:
2307                 wacom_map_usage(input, usage, field, EV_ABS, ABS_DISTANCE, 0);
2308                 break;
2309         case HID_DG_TIPPRESSURE:
2310                 wacom_map_usage(input, usage, field, EV_ABS, ABS_PRESSURE, 0);
2311                 break;
2312         case HID_DG_INRANGE:
2313                 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOOL_PEN, 0);
2314                 break;
2315         case HID_DG_INVERT:
2316                 wacom_map_usage(input, usage, field, EV_KEY,
2317                                 BTN_TOOL_RUBBER, 0);
2318                 break;
2319         case HID_DG_TILT_X:
2320                 wacom_map_usage(input, usage, field, EV_ABS, ABS_TILT_X, 0);
2321                 break;
2322         case HID_DG_TILT_Y:
2323                 wacom_map_usage(input, usage, field, EV_ABS, ABS_TILT_Y, 0);
2324                 break;
2325         case HID_DG_TWIST:
2326                 wacom_map_usage(input, usage, field, EV_ABS, ABS_Z, 0);
2327                 break;
2328         case HID_DG_ERASER:
2329                 input_set_capability(input, EV_KEY, BTN_TOOL_RUBBER);
2330                 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
2331                 break;
2332         case HID_DG_TIPSWITCH:
2333                 input_set_capability(input, EV_KEY, BTN_TOOL_PEN);
2334                 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
2335                 break;
2336         case HID_DG_BARRELSWITCH:
2337                 wacom_wac->hid_data.barrelswitch = true;
2338                 wacom_set_barrel_switch3_usage(wacom_wac);
2339                 wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS, 0);
2340                 break;
2341         case HID_DG_BARRELSWITCH2:
2342                 wacom_wac->hid_data.barrelswitch2 = true;
2343                 wacom_set_barrel_switch3_usage(wacom_wac);
2344                 wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS2, 0);
2345                 break;
2346         case HID_DG_TOOLSERIALNUMBER:
2347                 features->quirks |= WACOM_QUIRK_TOOLSERIAL;
2348                 wacom_map_usage(input, usage, field, EV_MSC, MSC_SERIAL, 0);
2349                 break;
2350         case HID_DG_SCANTIME:
2351                 wacom_map_usage(input, usage, field, EV_MSC, MSC_TIMESTAMP, 0);
2352                 break;
2353         case WACOM_HID_WD_SENSE:
2354                 features->quirks |= WACOM_QUIRK_SENSE;
2355                 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOOL_PEN, 0);
2356                 break;
2357         case WACOM_HID_WD_SERIALHI:
2358                 wacom_wac->hid_data.serialhi = true;
2359                 wacom_set_barrel_switch3_usage(wacom_wac);
2360                 wacom_map_usage(input, usage, field, EV_ABS, ABS_MISC, 0);
2361                 break;
2362         case WACOM_HID_WD_FINGERWHEEL:
2363                 input_set_capability(input, EV_KEY, BTN_TOOL_AIRBRUSH);
2364                 wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0);
2365                 break;
2366         case WACOM_HID_WD_BARRELSWITCH3:
2367                 wacom_wac->hid_data.barrelswitch3 = true;
2368                 wacom_map_usage(input, usage, field, EV_KEY, BTN_STYLUS3, 0);
2369                 features->quirks &= ~WACOM_QUIRK_PEN_BUTTON3;
2370                 break;
2371         }
2372 }
2373
2374 static void wacom_wac_pen_event(struct hid_device *hdev, struct hid_field *field,
2375                 struct hid_usage *usage, __s32 value)
2376 {
2377         struct wacom *wacom = hid_get_drvdata(hdev);
2378         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2379         struct wacom_features *features = &wacom_wac->features;
2380         struct input_dev *input = wacom_wac->pen_input;
2381         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
2382
2383         if (wacom_wac->is_invalid_bt_frame)
2384                 return;
2385
2386         switch (equivalent_usage) {
2387         case HID_GD_Z:
2388                 /*
2389                  * HID_GD_Z "should increase as the control's position is
2390                  * moved from high to low", while ABS_DISTANCE instead
2391                  * increases in value as the tool moves from low to high.
2392                  */
2393                 value = field->logical_maximum - value;
2394                 break;
2395         case HID_DG_INRANGE:
2396                 mod_timer(&wacom->idleprox_timer, jiffies + msecs_to_jiffies(100));
2397                 wacom_wac->hid_data.inrange_state = value;
2398                 if (!(features->quirks & WACOM_QUIRK_SENSE))
2399                         wacom_wac->hid_data.sense_state = value;
2400                 return;
2401         case HID_DG_INVERT:
2402                 wacom_wac->hid_data.invert_state = value;
2403                 return;
2404         case HID_DG_ERASER:
2405         case HID_DG_TIPSWITCH:
2406                 wacom_wac->hid_data.tipswitch |= value;
2407                 return;
2408         case HID_DG_BARRELSWITCH:
2409                 wacom_wac->hid_data.barrelswitch = value;
2410                 return;
2411         case HID_DG_BARRELSWITCH2:
2412                 wacom_wac->hid_data.barrelswitch2 = value;
2413                 return;
2414         case HID_DG_TOOLSERIALNUMBER:
2415                 if (value) {
2416                         wacom_wac->serial[0] = (wacom_wac->serial[0] & ~0xFFFFFFFFULL);
2417                         wacom_wac->serial[0] |= wacom_s32tou(value, field->report_size);
2418                 }
2419                 return;
2420         case HID_DG_TWIST:
2421                 /* don't modify the value if the pen doesn't support the feature */
2422                 if (!wacom_is_art_pen(wacom_wac->id[0])) return;
2423
2424                 /*
2425                  * Userspace expects pen twist to have its zero point when
2426                  * the buttons/finger is on the tablet's left. HID values
2427                  * are zero when buttons are toward the top.
2428                  */
2429                 value = wacom_offset_rotation(input, usage, value, 1, 4);
2430                 break;
2431         case WACOM_HID_WD_SENSE:
2432                 wacom_wac->hid_data.sense_state = value;
2433                 return;
2434         case WACOM_HID_WD_SERIALHI:
2435                 if (value) {
2436                         __u32 raw_value = wacom_s32tou(value, field->report_size);
2437
2438                         wacom_wac->serial[0] = (wacom_wac->serial[0] & 0xFFFFFFFF);
2439                         wacom_wac->serial[0] |= ((__u64)raw_value) << 32;
2440                         /*
2441                          * Non-USI EMR devices may contain additional tool type
2442                          * information here. See WACOM_HID_WD_TOOLTYPE case for
2443                          * more details.
2444                          */
2445                         if (value >> 20 == 1) {
2446                                 wacom_wac->id[0] |= raw_value & 0xFFFFF;
2447                         }
2448                 }
2449                 return;
2450         case WACOM_HID_WD_TOOLTYPE:
2451                 /*
2452                  * Some devices (MobileStudio Pro, and possibly later
2453                  * devices as well) do not return the complete tool
2454                  * type in their WACOM_HID_WD_TOOLTYPE usage. Use a
2455                  * bitwise OR so the complete value can be built
2456                  * up over time :(
2457                  */
2458                 wacom_wac->id[0] |= wacom_s32tou(value, field->report_size);
2459                 return;
2460         case WACOM_HID_WD_OFFSETLEFT:
2461                 if (features->offset_left && value != features->offset_left)
2462                         hid_warn(hdev, "%s: overriding existing left offset "
2463                                  "%d -> %d\n", __func__, value,
2464                                  features->offset_left);
2465                 features->offset_left = value;
2466                 return;
2467         case WACOM_HID_WD_OFFSETRIGHT:
2468                 if (features->offset_right && value != features->offset_right)
2469                         hid_warn(hdev, "%s: overriding existing right offset "
2470                                  "%d -> %d\n", __func__, value,
2471                                  features->offset_right);
2472                 features->offset_right = value;
2473                 return;
2474         case WACOM_HID_WD_OFFSETTOP:
2475                 if (features->offset_top && value != features->offset_top)
2476                         hid_warn(hdev, "%s: overriding existing top offset "
2477                                  "%d -> %d\n", __func__, value,
2478                                  features->offset_top);
2479                 features->offset_top = value;
2480                 return;
2481         case WACOM_HID_WD_OFFSETBOTTOM:
2482                 if (features->offset_bottom && value != features->offset_bottom)
2483                         hid_warn(hdev, "%s: overriding existing bottom offset "
2484                                  "%d -> %d\n", __func__, value,
2485                                  features->offset_bottom);
2486                 features->offset_bottom = value;
2487                 return;
2488         case WACOM_HID_WD_REPORT_VALID:
2489                 wacom_wac->is_invalid_bt_frame = !value;
2490                 return;
2491         case WACOM_HID_WD_BARRELSWITCH3:
2492                 wacom_wac->hid_data.barrelswitch3 = value;
2493                 return;
2494         case WACOM_HID_WD_SEQUENCENUMBER:
2495                 if (wacom_wac->hid_data.sequence_number != value)
2496                         hid_warn(hdev, "Dropped %hu packets", (unsigned short)(value - wacom_wac->hid_data.sequence_number));
2497                 wacom_wac->hid_data.sequence_number = value + 1;
2498                 return;
2499         }
2500
2501         /* send pen events only when touch is up or forced out
2502          * or touch arbitration is off
2503          */
2504         if (!usage->type || delay_pen_events(wacom_wac))
2505                 return;
2506
2507         /* send pen events only when the pen is in range */
2508         if (wacom_wac->hid_data.inrange_state)
2509                 input_event(input, usage->type, usage->code, value);
2510         else if (wacom_wac->shared->stylus_in_proximity && !wacom_wac->hid_data.sense_state)
2511                 input_event(input, usage->type, usage->code, 0);
2512 }
2513
2514 static void wacom_wac_pen_pre_report(struct hid_device *hdev,
2515                 struct hid_report *report)
2516 {
2517         struct wacom *wacom = hid_get_drvdata(hdev);
2518         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2519
2520         wacom_wac->is_invalid_bt_frame = false;
2521         return;
2522 }
2523
2524 static void wacom_wac_pen_report(struct hid_device *hdev,
2525                 struct hid_report *report)
2526 {
2527         struct wacom *wacom = hid_get_drvdata(hdev);
2528         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2529         struct input_dev *input = wacom_wac->pen_input;
2530         bool range = wacom_wac->hid_data.inrange_state;
2531         bool sense = wacom_wac->hid_data.sense_state;
2532
2533         if (wacom_wac->is_invalid_bt_frame)
2534                 return;
2535
2536         if (!wacom_wac->tool[0] && range) { /* first in range */
2537                 /* Going into range select tool */
2538                 if (wacom_wac->hid_data.invert_state)
2539                         wacom_wac->tool[0] = BTN_TOOL_RUBBER;
2540                 else if (wacom_wac->id[0])
2541                         wacom_wac->tool[0] = wacom_intuos_get_tool_type(wacom_wac->id[0]);
2542                 else
2543                         wacom_wac->tool[0] = BTN_TOOL_PEN;
2544         }
2545
2546         /* keep pen state for touch events */
2547         wacom_wac->shared->stylus_in_proximity = sense;
2548
2549         if (!delay_pen_events(wacom_wac) && wacom_wac->tool[0]) {
2550                 int id = wacom_wac->id[0];
2551                 if (wacom_wac->features.quirks & WACOM_QUIRK_PEN_BUTTON3) {
2552                         int sw_state = wacom_wac->hid_data.barrelswitch |
2553                                        (wacom_wac->hid_data.barrelswitch2 << 1);
2554                         wacom_wac->hid_data.barrelswitch = sw_state == 1;
2555                         wacom_wac->hid_data.barrelswitch2 = sw_state == 2;
2556                         wacom_wac->hid_data.barrelswitch3 = sw_state == 3;
2557                 }
2558                 input_report_key(input, BTN_STYLUS, wacom_wac->hid_data.barrelswitch);
2559                 input_report_key(input, BTN_STYLUS2, wacom_wac->hid_data.barrelswitch2);
2560                 input_report_key(input, BTN_STYLUS3, wacom_wac->hid_data.barrelswitch3);
2561
2562                 /*
2563                  * Non-USI EMR tools should have their IDs mangled to
2564                  * match the legacy behavior of wacom_intuos_general
2565                  */
2566                 if (wacom_wac->serial[0] >> 52 == 1)
2567                         id = wacom_intuos_id_mangle(id);
2568
2569                 /*
2570                  * To ensure compatibility with xf86-input-wacom, we should
2571                  * report the BTN_TOOL_* event prior to the ABS_MISC or
2572                  * MSC_SERIAL events.
2573                  */
2574                 input_report_key(input, BTN_TOUCH,
2575                                 wacom_wac->hid_data.tipswitch);
2576                 input_report_key(input, wacom_wac->tool[0], sense);
2577                 if (wacom_wac->serial[0]) {
2578                         input_event(input, EV_MSC, MSC_SERIAL, wacom_wac->serial[0]);
2579                         input_report_abs(input, ABS_MISC, sense ? id : 0);
2580                 }
2581
2582                 wacom_wac->hid_data.tipswitch = false;
2583
2584                 input_sync(input);
2585         }
2586
2587         if (!sense) {
2588                 wacom_wac->tool[0] = 0;
2589                 wacom_wac->id[0] = 0;
2590                 wacom_wac->serial[0] = 0;
2591         }
2592 }
2593
2594 static void wacom_wac_finger_usage_mapping(struct hid_device *hdev,
2595                 struct hid_field *field, struct hid_usage *usage)
2596 {
2597         struct wacom *wacom = hid_get_drvdata(hdev);
2598         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2599         struct input_dev *input = wacom_wac->touch_input;
2600         unsigned touch_max = wacom_wac->features.touch_max;
2601         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
2602
2603         switch (equivalent_usage) {
2604         case HID_GD_X:
2605                 if (touch_max == 1)
2606                         wacom_map_usage(input, usage, field, EV_ABS, ABS_X, 4);
2607                 else
2608                         wacom_map_usage(input, usage, field, EV_ABS,
2609                                         ABS_MT_POSITION_X, 4);
2610                 break;
2611         case HID_GD_Y:
2612                 if (touch_max == 1)
2613                         wacom_map_usage(input, usage, field, EV_ABS, ABS_Y, 4);
2614                 else
2615                         wacom_map_usage(input, usage, field, EV_ABS,
2616                                         ABS_MT_POSITION_Y, 4);
2617                 break;
2618         case HID_DG_WIDTH:
2619         case HID_DG_HEIGHT:
2620                 wacom_map_usage(input, usage, field, EV_ABS, ABS_MT_TOUCH_MAJOR, 0);
2621                 wacom_map_usage(input, usage, field, EV_ABS, ABS_MT_TOUCH_MINOR, 0);
2622                 input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0);
2623                 break;
2624         case HID_DG_TIPSWITCH:
2625                 wacom_map_usage(input, usage, field, EV_KEY, BTN_TOUCH, 0);
2626                 break;
2627         case HID_DG_CONTACTCOUNT:
2628                 wacom_wac->hid_data.cc_report = field->report->id;
2629                 wacom_wac->hid_data.cc_index = field->index;
2630                 wacom_wac->hid_data.cc_value_index = usage->usage_index;
2631                 break;
2632         case HID_DG_CONTACTID:
2633                 if ((field->logical_maximum - field->logical_minimum) < touch_max) {
2634                         /*
2635                          * The HID descriptor for G11 sensors leaves logical
2636                          * maximum set to '1' despite it being a multitouch
2637                          * device. Override to a sensible number.
2638                          */
2639                         field->logical_maximum = 255;
2640                 }
2641                 break;
2642         case HID_DG_SCANTIME:
2643                 wacom_map_usage(input, usage, field, EV_MSC, MSC_TIMESTAMP, 0);
2644                 break;
2645         }
2646 }
2647
2648 static void wacom_wac_finger_slot(struct wacom_wac *wacom_wac,
2649                 struct input_dev *input)
2650 {
2651         struct hid_data *hid_data = &wacom_wac->hid_data;
2652         bool mt = wacom_wac->features.touch_max > 1;
2653         bool prox = hid_data->tipswitch &&
2654                     report_touch_events(wacom_wac);
2655
2656         if (touch_is_muted(wacom_wac)) {
2657                 if (!wacom_wac->shared->touch_down)
2658                         return;
2659                 prox = false;
2660         }
2661
2662         wacom_wac->hid_data.num_received++;
2663         if (wacom_wac->hid_data.num_received > wacom_wac->hid_data.num_expected)
2664                 return;
2665
2666         if (mt) {
2667                 int slot;
2668
2669                 slot = input_mt_get_slot_by_key(input, hid_data->id);
2670                 if (slot < 0) {
2671                         return;
2672                 } else {
2673                         struct input_mt_slot *ps = &input->mt->slots[slot];
2674                         int mt_id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
2675
2676                         if (!prox && mt_id < 0) {
2677                                 // No data to send for this slot; short-circuit
2678                                 return;
2679                         }
2680                 }
2681
2682                 input_mt_slot(input, slot);
2683                 input_mt_report_slot_state(input, MT_TOOL_FINGER, prox);
2684         }
2685         else {
2686                 input_report_key(input, BTN_TOUCH, prox);
2687         }
2688
2689         if (prox) {
2690                 input_report_abs(input, mt ? ABS_MT_POSITION_X : ABS_X,
2691                                  hid_data->x);
2692                 input_report_abs(input, mt ? ABS_MT_POSITION_Y : ABS_Y,
2693                                  hid_data->y);
2694
2695                 if (test_bit(ABS_MT_TOUCH_MAJOR, input->absbit)) {
2696                         input_report_abs(input, ABS_MT_TOUCH_MAJOR, max(hid_data->width, hid_data->height));
2697                         input_report_abs(input, ABS_MT_TOUCH_MINOR, min(hid_data->width, hid_data->height));
2698                         if (hid_data->width != hid_data->height)
2699                                 input_report_abs(input, ABS_MT_ORIENTATION, hid_data->width <= hid_data->height ? 0 : 1);
2700                 }
2701         }
2702 }
2703
2704 static bool wacom_wac_slot_is_active(struct input_dev *dev, int key)
2705 {
2706         struct input_mt *mt = dev->mt;
2707         struct input_mt_slot *s;
2708
2709         if (!mt)
2710                 return false;
2711
2712         for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
2713                 if (s->key == key &&
2714                         input_mt_get_value(s, ABS_MT_TRACKING_ID) >= 0) {
2715                         return true;
2716                 }
2717         }
2718
2719         return false;
2720 }
2721
2722 static void wacom_wac_finger_event(struct hid_device *hdev,
2723                 struct hid_field *field, struct hid_usage *usage, __s32 value)
2724 {
2725         struct wacom *wacom = hid_get_drvdata(hdev);
2726         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2727         unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
2728         struct wacom_features *features = &wacom->wacom_wac.features;
2729
2730         if (touch_is_muted(wacom_wac) && !wacom_wac->shared->touch_down)
2731                 return;
2732
2733         if (wacom_wac->is_invalid_bt_frame)
2734                 return;
2735
2736         switch (equivalent_usage) {
2737         case HID_DG_CONFIDENCE:
2738                 wacom_wac->hid_data.confidence = value;
2739                 break;
2740         case HID_GD_X:
2741                 wacom_wac->hid_data.x = value;
2742                 break;
2743         case HID_GD_Y:
2744                 wacom_wac->hid_data.y = value;
2745                 break;
2746         case HID_DG_WIDTH:
2747                 wacom_wac->hid_data.width = value;
2748                 break;
2749         case HID_DG_HEIGHT:
2750                 wacom_wac->hid_data.height = value;
2751                 break;
2752         case HID_DG_CONTACTID:
2753                 wacom_wac->hid_data.id = value;
2754                 break;
2755         case HID_DG_TIPSWITCH:
2756                 wacom_wac->hid_data.tipswitch = value;
2757                 break;
2758         case WACOM_HID_WT_REPORT_VALID:
2759                 wacom_wac->is_invalid_bt_frame = !value;
2760                 return;
2761         case HID_DG_CONTACTMAX:
2762                 if (!features->touch_max) {
2763                         features->touch_max = value;
2764                 } else {
2765                         hid_warn(hdev, "%s: ignoring attempt to overwrite non-zero touch_max "
2766                                  "%d -> %d\n", __func__, features->touch_max, value);
2767                 }
2768                 return;
2769         }
2770
2771         if (usage->usage_index + 1 == field->report_count) {
2772                 if (equivalent_usage == wacom_wac->hid_data.last_slot_field) {
2773                         bool touch_removed = wacom_wac_slot_is_active(wacom_wac->touch_input,
2774                                 wacom_wac->hid_data.id) && !wacom_wac->hid_data.tipswitch;
2775
2776                         if (wacom_wac->hid_data.confidence || touch_removed) {
2777                                 wacom_wac_finger_slot(wacom_wac, wacom_wac->touch_input);
2778                         }
2779                 }
2780         }
2781 }
2782
2783 static void wacom_wac_finger_pre_report(struct hid_device *hdev,
2784                 struct hid_report *report)
2785 {
2786         struct wacom *wacom = hid_get_drvdata(hdev);
2787         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2788         struct hid_data* hid_data = &wacom_wac->hid_data;
2789         int i;
2790
2791         if (touch_is_muted(wacom_wac) && !wacom_wac->shared->touch_down)
2792                 return;
2793
2794         wacom_wac->is_invalid_bt_frame = false;
2795
2796         hid_data->confidence = true;
2797
2798         hid_data->cc_report = 0;
2799         hid_data->cc_index = -1;
2800         hid_data->cc_value_index = -1;
2801
2802         for (i = 0; i < report->maxfield; i++) {
2803                 struct hid_field *field = report->field[i];
2804                 int j;
2805
2806                 for (j = 0; j < field->maxusage; j++) {
2807                         struct hid_usage *usage = &field->usage[j];
2808                         unsigned int equivalent_usage =
2809                                 wacom_equivalent_usage(usage->hid);
2810
2811                         switch (equivalent_usage) {
2812                         case HID_GD_X:
2813                         case HID_GD_Y:
2814                         case HID_DG_WIDTH:
2815                         case HID_DG_HEIGHT:
2816                         case HID_DG_CONTACTID:
2817                         case HID_DG_INRANGE:
2818                         case HID_DG_INVERT:
2819                         case HID_DG_TIPSWITCH:
2820                                 hid_data->last_slot_field = equivalent_usage;
2821                                 break;
2822                         case HID_DG_CONTACTCOUNT:
2823                                 hid_data->cc_report = report->id;
2824                                 hid_data->cc_index = i;
2825                                 hid_data->cc_value_index = j;
2826                                 break;
2827                         }
2828                 }
2829         }
2830
2831         if (hid_data->cc_report != 0 &&
2832             hid_data->cc_index >= 0) {
2833                 struct hid_field *field = report->field[hid_data->cc_index];
2834                 int value = field->value[hid_data->cc_value_index];
2835                 if (value) {
2836                         hid_data->num_expected = value;
2837                         hid_data->num_received = 0;
2838                 }
2839         }
2840         else {
2841                 hid_data->num_expected = wacom_wac->features.touch_max;
2842                 hid_data->num_received = 0;
2843         }
2844 }
2845
2846 static void wacom_wac_finger_report(struct hid_device *hdev,
2847                 struct hid_report *report)
2848 {
2849         struct wacom *wacom = hid_get_drvdata(hdev);
2850         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2851         struct input_dev *input = wacom_wac->touch_input;
2852         unsigned touch_max = wacom_wac->features.touch_max;
2853
2854         /* if there was nothing to process, don't send an empty sync */
2855         if (wacom_wac->hid_data.num_expected == 0)
2856                 return;
2857
2858         /* If more packets of data are expected, give us a chance to
2859          * process them rather than immediately syncing a partial
2860          * update.
2861          */
2862         if (wacom_wac->hid_data.num_received < wacom_wac->hid_data.num_expected)
2863                 return;
2864
2865         if (touch_max > 1)
2866                 input_mt_sync_frame(input);
2867
2868         input_sync(input);
2869         wacom_wac->hid_data.num_received = 0;
2870         wacom_wac->hid_data.num_expected = 0;
2871
2872         /* keep touch state for pen event */
2873         wacom_wac->shared->touch_down = wacom_wac_finger_count_touches(wacom_wac);
2874 }
2875
2876 void wacom_wac_usage_mapping(struct hid_device *hdev,
2877                 struct hid_field *field, struct hid_usage *usage)
2878 {
2879         struct wacom *wacom = hid_get_drvdata(hdev);
2880         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2881         struct wacom_features *features = &wacom_wac->features;
2882
2883         if (WACOM_DIRECT_DEVICE(field))
2884                 features->device_type |= WACOM_DEVICETYPE_DIRECT;
2885
2886         /* usage tests must precede field tests */
2887         if (WACOM_BATTERY_USAGE(usage))
2888                 wacom_wac_battery_usage_mapping(hdev, field, usage);
2889         else if (WACOM_PAD_FIELD(field))
2890                 wacom_wac_pad_usage_mapping(hdev, field, usage);
2891         else if (WACOM_PEN_FIELD(field))
2892                 wacom_wac_pen_usage_mapping(hdev, field, usage);
2893         else if (WACOM_FINGER_FIELD(field))
2894                 wacom_wac_finger_usage_mapping(hdev, field, usage);
2895 }
2896
2897 void wacom_wac_event(struct hid_device *hdev, struct hid_field *field,
2898                 struct hid_usage *usage, __s32 value)
2899 {
2900         struct wacom *wacom = hid_get_drvdata(hdev);
2901
2902         if (wacom->wacom_wac.features.type != HID_GENERIC)
2903                 return;
2904
2905         if (value > field->logical_maximum || value < field->logical_minimum)
2906                 return;
2907
2908         /* usage tests must precede field tests */
2909         if (WACOM_BATTERY_USAGE(usage))
2910                 wacom_wac_battery_event(hdev, field, usage, value);
2911         else if (WACOM_PAD_FIELD(field))
2912                 wacom_wac_pad_event(hdev, field, usage, value);
2913         else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
2914                 wacom_wac_pen_event(hdev, field, usage, value);
2915         else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
2916                 wacom_wac_finger_event(hdev, field, usage, value);
2917 }
2918
2919 static void wacom_report_events(struct hid_device *hdev,
2920                                 struct hid_report *report, int collection_index,
2921                                 int field_index)
2922 {
2923         int r;
2924
2925         for (r = field_index; r < report->maxfield; r++) {
2926                 struct hid_field *field;
2927                 unsigned count, n;
2928
2929                 field = report->field[r];
2930                 count = field->report_count;
2931
2932                 if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
2933                         continue;
2934
2935                 for (n = 0 ; n < count; n++) {
2936                         if (field->usage[n].collection_index == collection_index)
2937                                 wacom_wac_event(hdev, field, &field->usage[n],
2938                                                 field->value[n]);
2939                         else
2940                                 return;
2941                 }
2942         }
2943 }
2944
2945 static int wacom_wac_collection(struct hid_device *hdev, struct hid_report *report,
2946                          int collection_index, struct hid_field *field,
2947                          int field_index)
2948 {
2949         struct wacom *wacom = hid_get_drvdata(hdev);
2950
2951         wacom_report_events(hdev, report, collection_index, field_index);
2952
2953         /*
2954          * Non-input reports may be sent prior to the device being
2955          * completely initialized. Since only their events need
2956          * to be processed, exit after 'wacom_report_events' has
2957          * been called to prevent potential crashes in the report-
2958          * processing functions.
2959          */
2960         if (report->type != HID_INPUT_REPORT)
2961                 return -1;
2962
2963         if (WACOM_PAD_FIELD(field))
2964                 return 0;
2965         else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
2966                 wacom_wac_pen_report(hdev, report);
2967         else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
2968                 wacom_wac_finger_report(hdev, report);
2969
2970         return 0;
2971 }
2972
2973 void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
2974 {
2975         struct wacom *wacom = hid_get_drvdata(hdev);
2976         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
2977         struct hid_field *field;
2978         bool pad_in_hid_field = false, pen_in_hid_field = false,
2979                 finger_in_hid_field = false, true_pad = false;
2980         int r;
2981         int prev_collection = -1;
2982
2983         if (wacom_wac->features.type != HID_GENERIC)
2984                 return;
2985
2986         for (r = 0; r < report->maxfield; r++) {
2987                 field = report->field[r];
2988
2989                 if (WACOM_PAD_FIELD(field))
2990                         pad_in_hid_field = true;
2991                 if (WACOM_PEN_FIELD(field))
2992                         pen_in_hid_field = true;
2993                 if (WACOM_FINGER_FIELD(field))
2994                         finger_in_hid_field = true;
2995                 if (wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY)
2996                         true_pad = true;
2997         }
2998
2999         wacom_wac_battery_pre_report(hdev, report);
3000
3001         if (pad_in_hid_field && wacom->wacom_wac.pad_input)
3002                 wacom_wac_pad_pre_report(hdev, report);
3003         if (pen_in_hid_field && wacom->wacom_wac.pen_input)
3004                 wacom_wac_pen_pre_report(hdev, report);
3005         if (finger_in_hid_field && wacom->wacom_wac.touch_input)
3006                 wacom_wac_finger_pre_report(hdev, report);
3007
3008         for (r = 0; r < report->maxfield; r++) {
3009                 field = report->field[r];
3010
3011                 if (field->usage[0].collection_index != prev_collection) {
3012                         if (wacom_wac_collection(hdev, report,
3013                                 field->usage[0].collection_index, field, r) < 0)
3014                                 return;
3015                         prev_collection = field->usage[0].collection_index;
3016                 }
3017         }
3018
3019         wacom_wac_battery_report(hdev, report);
3020
3021         if (true_pad && wacom->wacom_wac.pad_input)
3022                 wacom_wac_pad_report(hdev, report, field);
3023 }
3024
3025 static int wacom_bpt_touch(struct wacom_wac *wacom)
3026 {
3027         struct wacom_features *features = &wacom->features;
3028         struct input_dev *input = wacom->touch_input;
3029         struct input_dev *pad_input = wacom->pad_input;
3030         unsigned char *data = wacom->data;
3031         int i;
3032
3033         if (data[0] != 0x02)
3034             return 0;
3035
3036         for (i = 0; i < 2; i++) {
3037                 int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
3038                 bool touch = report_touch_events(wacom)
3039                            && (data[offset + 3] & 0x80);
3040
3041                 input_mt_slot(input, i);
3042                 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
3043                 if (touch) {
3044                         int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
3045                         int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
3046                         if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
3047                                 x <<= 5;
3048                                 y <<= 5;
3049                         }
3050                         input_report_abs(input, ABS_MT_POSITION_X, x);
3051                         input_report_abs(input, ABS_MT_POSITION_Y, y);
3052                 }
3053         }
3054
3055         input_mt_sync_frame(input);
3056
3057         input_report_key(pad_input, BTN_LEFT, (data[1] & 0x08) != 0);
3058         input_report_key(pad_input, BTN_FORWARD, (data[1] & 0x04) != 0);
3059         input_report_key(pad_input, BTN_BACK, (data[1] & 0x02) != 0);
3060         input_report_key(pad_input, BTN_RIGHT, (data[1] & 0x01) != 0);
3061         wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
3062
3063         return 1;
3064 }
3065
3066 static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
3067 {
3068         struct wacom_features *features = &wacom->features;
3069         struct input_dev *input = wacom->touch_input;
3070         bool touch = data[1] & 0x80;
3071         int slot = input_mt_get_slot_by_key(input, data[0]);
3072
3073         if (slot < 0)
3074                 return;
3075
3076         touch = touch && report_touch_events(wacom);
3077
3078         input_mt_slot(input, slot);
3079         input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
3080
3081         if (touch) {
3082                 int x = (data[2] << 4) | (data[4] >> 4);
3083                 int y = (data[3] << 4) | (data[4] & 0x0f);
3084                 int width, height;
3085
3086                 if (features->type >= INTUOSPS && features->type <= INTUOSHT2) {
3087                         width  = data[5] * 100;
3088                         height = data[6] * 100;
3089                 } else {
3090                         /*
3091                          * "a" is a scaled-down area which we assume is
3092                          * roughly circular and which can be described as:
3093                          * a=(pi*r^2)/C.
3094                          */
3095                         int a = data[5];
3096                         int x_res = input_abs_get_res(input, ABS_MT_POSITION_X);
3097                         int y_res = input_abs_get_res(input, ABS_MT_POSITION_Y);
3098                         width = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
3099                         height = width * y_res / x_res;
3100                 }
3101
3102                 input_report_abs(input, ABS_MT_POSITION_X, x);
3103                 input_report_abs(input, ABS_MT_POSITION_Y, y);
3104                 input_report_abs(input, ABS_MT_TOUCH_MAJOR, width);
3105                 input_report_abs(input, ABS_MT_TOUCH_MINOR, height);
3106         }
3107 }
3108
3109 static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
3110 {
3111         struct input_dev *input = wacom->pad_input;
3112         struct wacom_features *features = &wacom->features;
3113
3114         if (features->type == INTUOSHT || features->type == INTUOSHT2) {
3115                 input_report_key(input, BTN_LEFT, (data[1] & 0x02) != 0);
3116                 input_report_key(input, BTN_BACK, (data[1] & 0x08) != 0);
3117         } else {
3118                 input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
3119                 input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
3120         }
3121         input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
3122         input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
3123 }
3124
3125 static int wacom_bpt3_touch(struct wacom_wac *wacom)
3126 {
3127         unsigned char *data = wacom->data;
3128         int count = data[1] & 0x07;
3129         int  touch_changed = 0, i;
3130
3131         if (data[0] != 0x02)
3132             return 0;
3133
3134         /* data has up to 7 fixed sized 8-byte messages starting at data[2] */
3135         for (i = 0; i < count; i++) {
3136                 int offset = (8 * i) + 2;
3137                 int msg_id = data[offset];
3138
3139                 if (msg_id >= 2 && msg_id <= 17) {
3140                         wacom_bpt3_touch_msg(wacom, data + offset);
3141                         touch_changed++;
3142                 } else if (msg_id == 128)
3143                         wacom_bpt3_button_msg(wacom, data + offset);
3144
3145         }
3146
3147         /* only update touch if we actually have a touchpad and touch data changed */
3148         if (wacom->touch_input && touch_changed) {
3149                 input_mt_sync_frame(wacom->touch_input);
3150                 wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom);
3151         }
3152
3153         return 1;
3154 }
3155
3156 static int wacom_bpt_pen(struct wacom_wac *wacom)
3157 {
3158         struct wacom_features *features = &wacom->features;
3159         struct input_dev *input = wacom->pen_input;
3160         unsigned char *data = wacom->data;
3161         int x = 0, y = 0, p = 0, d = 0;
3162         bool pen = false, btn1 = false, btn2 = false;
3163         bool range, prox, rdy;
3164
3165         if (data[0] != WACOM_REPORT_PENABLED)
3166             return 0;
3167
3168         range = (data[1] & 0x80) == 0x80;
3169         prox = (data[1] & 0x40) == 0x40;
3170         rdy = (data[1] & 0x20) == 0x20;
3171
3172         wacom->shared->stylus_in_proximity = range;
3173         if (delay_pen_events(wacom))
3174                 return 0;
3175
3176         if (rdy) {
3177                 p = le16_to_cpup((__le16 *)&data[6]);
3178                 pen = data[1] & 0x01;
3179                 btn1 = data[1] & 0x02;
3180                 btn2 = data[1] & 0x04;
3181         }
3182         if (prox) {
3183                 x = le16_to_cpup((__le16 *)&data[2]);
3184                 y = le16_to_cpup((__le16 *)&data[4]);
3185
3186                 if (data[1] & 0x08) {
3187                         wacom->tool[0] = BTN_TOOL_RUBBER;
3188                         wacom->id[0] = ERASER_DEVICE_ID;
3189                 } else {
3190                         wacom->tool[0] = BTN_TOOL_PEN;
3191                         wacom->id[0] = STYLUS_DEVICE_ID;
3192                 }
3193                 wacom->reporting_data = true;
3194         }
3195         if (range) {
3196                 /*
3197                  * Convert distance from out prox to distance from tablet.
3198                  * distance will be greater than distance_max once
3199                  * touching and applying pressure; do not report negative
3200                  * distance.
3201                  */
3202                 if (data[8] <= features->distance_max)
3203                         d = features->distance_max - data[8];
3204         } else {
3205                 wacom->id[0] = 0;
3206         }
3207
3208         if (wacom->reporting_data) {
3209                 input_report_key(input, BTN_TOUCH, pen);
3210                 input_report_key(input, BTN_STYLUS, btn1);
3211                 input_report_key(input, BTN_STYLUS2, btn2);
3212
3213                 if (prox || !range) {
3214                         input_report_abs(input, ABS_X, x);
3215                         input_report_abs(input, ABS_Y, y);
3216                 }
3217                 input_report_abs(input, ABS_PRESSURE, p);
3218                 input_report_abs(input, ABS_DISTANCE, d);
3219
3220                 input_report_key(input, wacom->tool[0], range); /* PEN or RUBBER */
3221                 input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */
3222         }
3223
3224         if (!range) {
3225                 wacom->reporting_data = false;
3226         }
3227
3228         return 1;
3229 }
3230
3231 static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
3232 {
3233         struct wacom_features *features = &wacom->features;
3234
3235         if ((features->type == INTUOSHT2) &&
3236             (features->device_type & WACOM_DEVICETYPE_PEN))
3237                 return wacom_intuos_irq(wacom);
3238         else if (len == WACOM_PKGLEN_BBTOUCH)
3239                 return wacom_bpt_touch(wacom);
3240         else if (len == WACOM_PKGLEN_BBTOUCH3)
3241                 return wacom_bpt3_touch(wacom);
3242         else if (len == WACOM_PKGLEN_BBFUN || len == WACOM_PKGLEN_BBPEN)
3243                 return wacom_bpt_pen(wacom);
3244
3245         return 0;
3246 }
3247
3248 static void wacom_bamboo_pad_pen_event(struct wacom_wac *wacom,
3249                 unsigned char *data)
3250 {
3251         unsigned char prefix;
3252
3253         /*
3254          * We need to reroute the event from the debug interface to the
3255          * pen interface.
3256          * We need to add the report ID to the actual pen report, so we
3257          * temporary overwrite the first byte to prevent having to kzalloc/kfree
3258          * and memcpy the report.
3259          */
3260         prefix = data[0];
3261         data[0] = WACOM_REPORT_BPAD_PEN;
3262
3263         /*
3264          * actually reroute the event.
3265          * No need to check if wacom->shared->pen is valid, hid_input_report()
3266          * will check for us.
3267          */
3268         hid_input_report(wacom->shared->pen, HID_INPUT_REPORT, data,
3269                          WACOM_PKGLEN_PENABLED, 1);
3270
3271         data[0] = prefix;
3272 }
3273
3274 static int wacom_bamboo_pad_touch_event(struct wacom_wac *wacom,
3275                 unsigned char *data)
3276 {
3277         struct input_dev *input = wacom->touch_input;
3278         unsigned char *finger_data, prefix;
3279         unsigned id;
3280         int x, y;
3281         bool valid;
3282
3283         prefix = data[0];
3284
3285         for (id = 0; id < wacom->features.touch_max; id++) {
3286                 valid = !!(prefix & BIT(id)) &&
3287                         report_touch_events(wacom);
3288
3289                 input_mt_slot(input, id);
3290                 input_mt_report_slot_state(input, MT_TOOL_FINGER, valid);
3291
3292                 if (!valid)
3293                         continue;
3294
3295                 finger_data = data + 1 + id * 3;
3296                 x = finger_data[0] | ((finger_data[1] & 0x0f) << 8);
3297                 y = (finger_data[2] << 4) | (finger_data[1] >> 4);
3298
3299                 input_report_abs(input, ABS_MT_POSITION_X, x);
3300                 input_report_abs(input, ABS_MT_POSITION_Y, y);
3301         }
3302
3303         input_mt_sync_frame(input);
3304
3305         input_report_key(input, BTN_LEFT, prefix & 0x40);
3306         input_report_key(input, BTN_RIGHT, prefix & 0x80);
3307
3308         /* keep touch state for pen event */
3309         wacom->shared->touch_down = !!prefix && report_touch_events(wacom);
3310
3311         return 1;
3312 }
3313
3314 static int wacom_bamboo_pad_irq(struct wacom_wac *wacom, size_t len)
3315 {
3316         unsigned char *data = wacom->data;
3317
3318         if (!((len == WACOM_PKGLEN_BPAD_TOUCH) ||
3319               (len == WACOM_PKGLEN_BPAD_TOUCH_USB)) ||
3320             (data[0] != WACOM_REPORT_BPAD_TOUCH))
3321                 return 0;
3322
3323         if (data[1] & 0x01)
3324                 wacom_bamboo_pad_pen_event(wacom, &data[1]);
3325
3326         if (data[1] & 0x02)
3327                 return wacom_bamboo_pad_touch_event(wacom, &data[9]);
3328
3329         return 0;
3330 }
3331
3332 static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
3333 {
3334         unsigned char *data = wacom->data;
3335         int connected;
3336
3337         if (len != WACOM_PKGLEN_WIRELESS || data[0] != WACOM_REPORT_WL)
3338                 return 0;
3339
3340         connected = data[1] & 0x01;
3341         if (connected) {
3342                 int pid, battery, charging;
3343
3344                 if ((wacom->shared->type == INTUOSHT ||
3345                     wacom->shared->type == INTUOSHT2) &&
3346                     wacom->shared->touch_input &&
3347                     wacom->shared->touch_max) {
3348                         input_report_switch(wacom->shared->touch_input,
3349                                         SW_MUTE_DEVICE, data[5] & 0x40);
3350                         input_sync(wacom->shared->touch_input);
3351                 }
3352
3353                 pid = get_unaligned_be16(&data[6]);
3354                 battery = (data[5] & 0x3f) * 100 / 31;
3355                 charging = !!(data[5] & 0x80);
3356                 if (wacom->pid != pid) {
3357                         wacom->pid = pid;
3358                         wacom_schedule_work(wacom, WACOM_WORKER_WIRELESS);
3359                 }
3360
3361                 wacom_notify_battery(wacom, WACOM_POWER_SUPPLY_STATUS_AUTO,
3362                                      battery, charging, 1, 0);
3363
3364         } else if (wacom->pid != 0) {
3365                 /* disconnected while previously connected */
3366                 wacom->pid = 0;
3367                 wacom_schedule_work(wacom, WACOM_WORKER_WIRELESS);
3368                 wacom_notify_battery(wacom, POWER_SUPPLY_STATUS_UNKNOWN, 0, 0, 0, 0);
3369         }
3370
3371         return 0;
3372 }
3373
3374 static int wacom_status_irq(struct wacom_wac *wacom_wac, size_t len)
3375 {
3376         struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
3377         struct wacom_features *features = &wacom_wac->features;
3378         unsigned char *data = wacom_wac->data;
3379
3380         if (data[0] != WACOM_REPORT_USB)
3381                 return 0;
3382
3383         if ((features->type == INTUOSHT ||
3384             features->type == INTUOSHT2) &&
3385             wacom_wac->shared->touch_input &&
3386             features->touch_max) {
3387                 input_report_switch(wacom_wac->shared->touch_input,
3388                                     SW_MUTE_DEVICE, data[8] & 0x40);
3389                 input_sync(wacom_wac->shared->touch_input);
3390         }
3391
3392         if (data[9] & 0x02) { /* wireless module is attached */
3393                 int battery = (data[8] & 0x3f) * 100 / 31;
3394                 bool charging = !!(data[8] & 0x80);
3395
3396                 features->quirks |= WACOM_QUIRK_BATTERY;
3397                 wacom_notify_battery(wacom_wac, WACOM_POWER_SUPPLY_STATUS_AUTO,
3398                                      battery, charging, battery || charging, 1);
3399         }
3400         else if ((features->quirks & WACOM_QUIRK_BATTERY) &&
3401                  wacom->battery.battery) {
3402                 features->quirks &= ~WACOM_QUIRK_BATTERY;
3403                 wacom_notify_battery(wacom_wac, POWER_SUPPLY_STATUS_UNKNOWN, 0, 0, 0, 0);
3404         }
3405         return 0;
3406 }
3407
3408 void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
3409 {
3410         bool sync;
3411
3412         switch (wacom_wac->features.type) {
3413         case PENPARTNER:
3414                 sync = wacom_penpartner_irq(wacom_wac);
3415                 break;
3416
3417         case PL:
3418                 sync = wacom_pl_irq(wacom_wac);
3419                 break;
3420
3421         case WACOM_G4:
3422         case GRAPHIRE:
3423         case GRAPHIRE_BT:
3424         case WACOM_MO:
3425                 sync = wacom_graphire_irq(wacom_wac);
3426                 break;
3427
3428         case PTU:
3429                 sync = wacom_ptu_irq(wacom_wac);
3430                 break;
3431
3432         case DTU:
3433                 sync = wacom_dtu_irq(wacom_wac);
3434                 break;
3435
3436         case DTUS:
3437         case DTUSX:
3438                 sync = wacom_dtus_irq(wacom_wac);
3439                 break;
3440
3441         case INTUOS:
3442         case INTUOS3S:
3443         case INTUOS3:
3444         case INTUOS3L:
3445         case INTUOS4S:
3446         case INTUOS4:
3447         case INTUOS4L:
3448         case CINTIQ:
3449         case WACOM_BEE:
3450         case WACOM_13HD:
3451         case WACOM_21UX2:
3452         case WACOM_22HD:
3453         case WACOM_24HD:
3454         case WACOM_27QHD:
3455         case DTK:
3456         case CINTIQ_HYBRID:
3457         case CINTIQ_COMPANION_2:
3458                 sync = wacom_intuos_irq(wacom_wac);
3459                 break;
3460
3461         case INTUOS4WL:
3462                 sync = wacom_intuos_bt_irq(wacom_wac, len);
3463                 break;
3464
3465         case WACOM_24HDT:
3466         case WACOM_27QHDT:
3467                 sync = wacom_24hdt_irq(wacom_wac);
3468                 break;
3469
3470         case INTUOS5S:
3471         case INTUOS5:
3472         case INTUOS5L:
3473         case INTUOSPS:
3474         case INTUOSPM:
3475         case INTUOSPL:
3476                 if (len == WACOM_PKGLEN_BBTOUCH3)
3477                         sync = wacom_bpt3_touch(wacom_wac);
3478                 else if (wacom_wac->data[0] == WACOM_REPORT_USB)
3479                         sync = wacom_status_irq(wacom_wac, len);
3480                 else
3481                         sync = wacom_intuos_irq(wacom_wac);
3482                 break;
3483
3484         case INTUOSP2_BT:
3485         case INTUOSP2S_BT:
3486         case INTUOSHT3_BT:
3487                 sync = wacom_intuos_pro2_bt_irq(wacom_wac, len);
3488                 break;
3489
3490         case TABLETPC:
3491         case TABLETPCE:
3492         case TABLETPC2FG:
3493         case MTSCREEN:
3494         case MTTPC:
3495         case MTTPC_B:
3496                 sync = wacom_tpc_irq(wacom_wac, len);
3497                 break;
3498
3499         case BAMBOO_PT:
3500         case BAMBOO_PEN:
3501         case BAMBOO_TOUCH:
3502         case INTUOSHT:
3503         case INTUOSHT2:
3504                 if (wacom_wac->data[0] == WACOM_REPORT_USB)
3505                         sync = wacom_status_irq(wacom_wac, len);
3506                 else
3507                         sync = wacom_bpt_irq(wacom_wac, len);
3508                 break;
3509
3510         case BAMBOO_PAD:
3511                 sync = wacom_bamboo_pad_irq(wacom_wac, len);
3512                 break;
3513
3514         case WIRELESS:
3515                 sync = wacom_wireless_irq(wacom_wac, len);
3516                 break;
3517
3518         case REMOTE:
3519                 sync = false;
3520                 if (wacom_wac->data[0] == WACOM_REPORT_DEVICE_LIST)
3521                         wacom_remote_status_irq(wacom_wac, len);
3522                 else
3523                         sync = wacom_remote_irq(wacom_wac, len);
3524                 break;
3525
3526         default:
3527                 sync = false;
3528                 break;
3529         }
3530
3531         if (sync) {
3532                 if (wacom_wac->pen_input)
3533                         input_sync(wacom_wac->pen_input);
3534                 if (wacom_wac->touch_input)
3535                         input_sync(wacom_wac->touch_input);
3536                 if (wacom_wac->pad_input)
3537                         input_sync(wacom_wac->pad_input);
3538         }
3539 }
3540
3541 static void wacom_setup_basic_pro_pen(struct wacom_wac *wacom_wac)
3542 {
3543         struct input_dev *input_dev = wacom_wac->pen_input;
3544
3545         input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
3546
3547         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
3548         __set_bit(BTN_STYLUS, input_dev->keybit);
3549         __set_bit(BTN_STYLUS2, input_dev->keybit);
3550
3551         input_set_abs_params(input_dev, ABS_DISTANCE,
3552                              0, wacom_wac->features.distance_max, wacom_wac->features.distance_fuzz, 0);
3553 }
3554
3555 static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
3556 {
3557         struct input_dev *input_dev = wacom_wac->pen_input;
3558         struct wacom_features *features = &wacom_wac->features;
3559
3560         wacom_setup_basic_pro_pen(wacom_wac);
3561
3562         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
3563         __set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
3564         __set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
3565         __set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
3566
3567         input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
3568         input_set_abs_params(input_dev, ABS_TILT_X, -64, 63, features->tilt_fuzz, 0);
3569         input_abs_set_res(input_dev, ABS_TILT_X, 57);
3570         input_set_abs_params(input_dev, ABS_TILT_Y, -64, 63, features->tilt_fuzz, 0);
3571         input_abs_set_res(input_dev, ABS_TILT_Y, 57);
3572 }
3573
3574 static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
3575 {
3576         struct input_dev *input_dev = wacom_wac->pen_input;
3577
3578         input_set_capability(input_dev, EV_REL, REL_WHEEL);
3579
3580         wacom_setup_cintiq(wacom_wac);
3581
3582         __set_bit(BTN_LEFT, input_dev->keybit);
3583         __set_bit(BTN_RIGHT, input_dev->keybit);
3584         __set_bit(BTN_MIDDLE, input_dev->keybit);
3585         __set_bit(BTN_SIDE, input_dev->keybit);
3586         __set_bit(BTN_EXTRA, input_dev->keybit);
3587         __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
3588         __set_bit(BTN_TOOL_LENS, input_dev->keybit);
3589
3590         input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
3591         input_abs_set_res(input_dev, ABS_RZ, 287);
3592         input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
3593 }
3594
3595 void wacom_setup_device_quirks(struct wacom *wacom)
3596 {
3597         struct wacom_wac *wacom_wac = &wacom->wacom_wac;
3598         struct wacom_features *features = &wacom->wacom_wac.features;
3599
3600         /* The pen and pad share the same interface on most devices */
3601         if (features->type == GRAPHIRE_BT || features->type == WACOM_G4 ||
3602             features->type == DTUS ||
3603             (features->type >= INTUOS3S && features->type <= WACOM_MO)) {
3604                 if (features->device_type & WACOM_DEVICETYPE_PEN)
3605                         features->device_type |= WACOM_DEVICETYPE_PAD;
3606         }
3607
3608         /* touch device found but size is not defined. use default */
3609         if (features->device_type & WACOM_DEVICETYPE_TOUCH && !features->x_max) {
3610                 features->x_max = 1023;
3611                 features->y_max = 1023;
3612         }
3613
3614         /*
3615          * Intuos5/Pro and Bamboo 3rd gen have no useful data about its
3616          * touch interface in its HID descriptor. If this is the touch
3617          * interface (PacketSize of WACOM_PKGLEN_BBTOUCH3), override the
3618          * tablet values.
3619          */
3620         if ((features->type >= INTUOS5S && features->type <= INTUOSPL) ||
3621                 (features->type >= INTUOSHT && features->type <= BAMBOO_PT)) {
3622                 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
3623                         if (features->touch_max)
3624                                 features->device_type |= WACOM_DEVICETYPE_TOUCH;
3625                         if (features->type >= INTUOSHT && features->type <= BAMBOO_PT)
3626                                 features->device_type |= WACOM_DEVICETYPE_PAD;
3627
3628                         if (features->type == INTUOSHT2) {
3629                                 features->x_max = features->x_max / 10;
3630                                 features->y_max = features->y_max / 10;
3631                         }
3632                         else {
3633                                 features->x_max = 4096;
3634                                 features->y_max = 4096;
3635                         }
3636                 }
3637                 else if (features->pktlen == WACOM_PKGLEN_BBTOUCH) {
3638                         features->device_type |= WACOM_DEVICETYPE_PAD;
3639                 }
3640         }
3641
3642         /*
3643          * Hack for the Bamboo One:
3644          * the device presents a PAD/Touch interface as most Bamboos and even
3645          * sends ghosts PAD data on it. However, later, we must disable this
3646          * ghost interface, and we can not detect it unless we set it here
3647          * to WACOM_DEVICETYPE_PAD or WACOM_DEVICETYPE_TOUCH.
3648          */
3649         if (features->type == BAMBOO_PEN &&
3650             features->pktlen == WACOM_PKGLEN_BBTOUCH3)
3651                 features->device_type |= WACOM_DEVICETYPE_PAD;
3652
3653         /*
3654          * Raw Wacom-mode pen and touch events both come from interface
3655          * 0, whose HID descriptor has an application usage of 0xFF0D
3656          * (i.e., WACOM_HID_WD_DIGITIZER). We route pen packets back
3657          * out through the HID_GENERIC device created for interface 1,
3658          * so rewrite this one to be of type WACOM_DEVICETYPE_TOUCH.
3659          */
3660         if (features->type == BAMBOO_PAD)
3661                 features->device_type = WACOM_DEVICETYPE_TOUCH;
3662
3663         if (features->type == REMOTE)
3664                 features->device_type = WACOM_DEVICETYPE_PAD;
3665
3666         if (features->type == INTUOSP2_BT ||
3667             features->type == INTUOSP2S_BT) {
3668                 features->device_type |= WACOM_DEVICETYPE_PEN |
3669                                          WACOM_DEVICETYPE_PAD |
3670                                          WACOM_DEVICETYPE_TOUCH;
3671                 features->quirks |= WACOM_QUIRK_BATTERY;
3672         }
3673
3674         if (features->type == INTUOSHT3_BT) {
3675                 features->device_type |= WACOM_DEVICETYPE_PEN |
3676                                          WACOM_DEVICETYPE_PAD;
3677                 features->quirks |= WACOM_QUIRK_BATTERY;
3678         }
3679
3680         switch (features->type) {
3681         case PL:
3682         case DTU:
3683         case DTUS:
3684         case DTUSX:
3685         case WACOM_21UX2:
3686         case WACOM_22HD:
3687         case DTK:
3688         case WACOM_24HD:
3689         case WACOM_27QHD:
3690         case CINTIQ_HYBRID:
3691         case CINTIQ_COMPANION_2:
3692         case CINTIQ:
3693         case WACOM_BEE:
3694         case WACOM_13HD:
3695         case WACOM_24HDT:
3696         case WACOM_27QHDT:
3697         case TABLETPC:
3698         case TABLETPCE:
3699         case TABLETPC2FG:
3700         case MTSCREEN:
3701         case MTTPC:
3702         case MTTPC_B:
3703                 features->device_type |= WACOM_DEVICETYPE_DIRECT;
3704                 break;
3705         }
3706
3707         if (wacom->hdev->bus == BUS_BLUETOOTH)
3708                 features->quirks |= WACOM_QUIRK_BATTERY;
3709
3710         /* quirk for bamboo touch with 2 low res touches */
3711         if ((features->type == BAMBOO_PT || features->type == BAMBOO_TOUCH) &&
3712             features->pktlen == WACOM_PKGLEN_BBTOUCH) {
3713                 features->x_max <<= 5;
3714                 features->y_max <<= 5;
3715                 features->x_fuzz <<= 5;
3716                 features->y_fuzz <<= 5;
3717                 features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
3718         }
3719
3720         if (features->type == WIRELESS) {
3721                 if (features->device_type == WACOM_DEVICETYPE_WL_MONITOR) {
3722                         features->quirks |= WACOM_QUIRK_BATTERY;
3723                 }
3724         }
3725
3726         if (features->type == REMOTE)
3727                 features->device_type |= WACOM_DEVICETYPE_WL_MONITOR;
3728
3729         /* HID descriptor for DTK-2451 / DTH-2452 claims to report lots
3730          * of things it shouldn't. Lets fix up the damage...
3731          */
3732         if (wacom->hdev->product == 0x382 || wacom->hdev->product == 0x37d) {
3733                 features->quirks &= ~WACOM_QUIRK_TOOLSERIAL;
3734                 __clear_bit(BTN_TOOL_BRUSH, wacom_wac->pen_input->keybit);
3735                 __clear_bit(BTN_TOOL_PENCIL, wacom_wac->pen_input->keybit);
3736                 __clear_bit(BTN_TOOL_AIRBRUSH, wacom_wac->pen_input->keybit);
3737                 __clear_bit(ABS_Z, wacom_wac->pen_input->absbit);
3738                 __clear_bit(ABS_DISTANCE, wacom_wac->pen_input->absbit);
3739                 __clear_bit(ABS_TILT_X, wacom_wac->pen_input->absbit);
3740                 __clear_bit(ABS_TILT_Y, wacom_wac->pen_input->absbit);
3741                 __clear_bit(ABS_WHEEL, wacom_wac->pen_input->absbit);
3742                 __clear_bit(ABS_MISC, wacom_wac->pen_input->absbit);
3743                 __clear_bit(MSC_SERIAL, wacom_wac->pen_input->mscbit);
3744                 __clear_bit(EV_MSC, wacom_wac->pen_input->evbit);
3745         }
3746 }
3747
3748 int wacom_setup_pen_input_capabilities(struct input_dev *input_dev,
3749                                    struct wacom_wac *wacom_wac)
3750 {
3751         struct wacom_features *features = &wacom_wac->features;
3752
3753         if (!(features->device_type & WACOM_DEVICETYPE_PEN))
3754                 return -ENODEV;
3755
3756         if (features->device_type & WACOM_DEVICETYPE_DIRECT)
3757                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
3758         else
3759                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
3760
3761         if (features->type == HID_GENERIC)
3762                 /* setup has already been done */
3763                 return 0;
3764
3765         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
3766         __set_bit(BTN_TOUCH, input_dev->keybit);
3767         __set_bit(ABS_MISC, input_dev->absbit);
3768
3769         input_set_abs_params(input_dev, ABS_X, 0 + features->offset_left,
3770                              features->x_max - features->offset_right,
3771                              features->x_fuzz, 0);
3772         input_set_abs_params(input_dev, ABS_Y, 0 + features->offset_top,
3773                              features->y_max - features->offset_bottom,
3774                              features->y_fuzz, 0);
3775         input_set_abs_params(input_dev, ABS_PRESSURE, 0,
3776                 features->pressure_max, features->pressure_fuzz, 0);
3777
3778         /* penabled devices have fixed resolution for each model */
3779         input_abs_set_res(input_dev, ABS_X, features->x_resolution);
3780         input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
3781
3782         switch (features->type) {
3783         case GRAPHIRE_BT:
3784                 __clear_bit(ABS_MISC, input_dev->absbit);
3785                 fallthrough;
3786
3787         case WACOM_MO:
3788         case WACOM_G4:
3789                 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
3790                                               features->distance_max,
3791                                               features->distance_fuzz, 0);
3792                 fallthrough;
3793
3794         case GRAPHIRE:
3795                 input_set_capability(input_dev, EV_REL, REL_WHEEL);
3796
3797                 __set_bit(BTN_LEFT, input_dev->keybit);
3798                 __set_bit(BTN_RIGHT, input_dev->keybit);
3799                 __set_bit(BTN_MIDDLE, input_dev->keybit);
3800
3801                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
3802                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
3803                 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
3804                 __set_bit(BTN_STYLUS, input_dev->keybit);
3805                 __set_bit(BTN_STYLUS2, input_dev->keybit);
3806                 break;
3807
3808         case WACOM_27QHD:
3809         case WACOM_24HD:
3810         case DTK:
3811         case WACOM_22HD:
3812         case WACOM_21UX2:
3813         case WACOM_BEE:
3814         case CINTIQ:
3815         case WACOM_13HD:
3816         case CINTIQ_HYBRID:
3817         case CINTIQ_COMPANION_2:
3818                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
3819                 input_abs_set_res(input_dev, ABS_Z, 287);
3820                 wacom_setup_cintiq(wacom_wac);
3821                 break;
3822
3823         case INTUOS3:
3824         case INTUOS3L:
3825         case INTUOS3S:
3826         case INTUOS4:
3827         case INTUOS4WL:
3828         case INTUOS4L:
3829         case INTUOS4S:
3830                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
3831                 input_abs_set_res(input_dev, ABS_Z, 287);
3832                 fallthrough;
3833
3834         case INTUOS:
3835                 wacom_setup_intuos(wacom_wac);
3836                 break;
3837
3838         case INTUOS5:
3839         case INTUOS5L:
3840         case INTUOSPM:
3841         case INTUOSPL:
3842         case INTUOS5S:
3843         case INTUOSPS:
3844         case INTUOSP2_BT:
3845         case INTUOSP2S_BT:
3846                 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
3847                                       features->distance_max,
3848                                       features->distance_fuzz, 0);
3849
3850                 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
3851                 input_abs_set_res(input_dev, ABS_Z, 287);
3852
3853                 wacom_setup_intuos(wacom_wac);
3854                 break;
3855
3856         case WACOM_24HDT:
3857         case WACOM_27QHDT:
3858         case MTSCREEN:
3859         case MTTPC:
3860         case MTTPC_B:
3861         case TABLETPC2FG:
3862         case TABLETPC:
3863         case TABLETPCE:
3864                 __clear_bit(ABS_MISC, input_dev->absbit);
3865                 fallthrough;
3866
3867         case DTUS:
3868         case DTUSX:
3869         case PL:
3870         case DTU:
3871                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
3872                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
3873                 __set_bit(BTN_STYLUS, input_dev->keybit);
3874                 __set_bit(BTN_STYLUS2, input_dev->keybit);
3875                 break;
3876
3877         case PTU:
3878                 __set_bit(BTN_STYLUS2, input_dev->keybit);
3879                 fallthrough;
3880
3881         case PENPARTNER:
3882                 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
3883                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
3884                 __set_bit(BTN_STYLUS, input_dev->keybit);
3885                 break;
3886
3887         case INTUOSHT:
3888         case BAMBOO_PT:
3889         case BAMBOO_PEN:
3890         case INTUOSHT2:
3891         case INTUOSHT3_BT:
3892                 if (features->type == INTUOSHT2 ||
3893                     features->type == INTUOSHT3_BT) {
3894                         wacom_setup_basic_pro_pen(wacom_wac);
3895                 } else {
3896                         __clear_bit(ABS_MISC, input_dev->absbit);
3897                         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
3898                         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
3899                         __set_bit(BTN_STYLUS, input_dev->keybit);
3900                         __set_bit(BTN_STYLUS2, input_dev->keybit);
3901                         input_set_abs_params(input_dev, ABS_DISTANCE, 0,
3902                                       features->distance_max,
3903                                       features->distance_fuzz, 0);
3904                 }
3905                 break;
3906         case BAMBOO_PAD:
3907                 __clear_bit(ABS_MISC, input_dev->absbit);
3908                 break;
3909         }
3910         return 0;
3911 }
3912
3913 int wacom_setup_touch_input_capabilities(struct input_dev *input_dev,
3914                                          struct wacom_wac *wacom_wac)
3915 {
3916         struct wacom_features *features = &wacom_wac->features;
3917
3918         if (!(features->device_type & WACOM_DEVICETYPE_TOUCH))
3919                 return -ENODEV;
3920
3921         if (features->device_type & WACOM_DEVICETYPE_DIRECT)
3922                 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
3923         else
3924                 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
3925
3926         if (features->type == HID_GENERIC)
3927                 /* setup has already been done */
3928                 return 0;
3929
3930         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
3931         __set_bit(BTN_TOUCH, input_dev->keybit);
3932
3933         if (features->touch_max == 1) {
3934                 input_set_abs_params(input_dev, ABS_X, 0,
3935                         features->x_max, features->x_fuzz, 0);
3936                 input_set_abs_params(input_dev, ABS_Y, 0,
3937                         features->y_max, features->y_fuzz, 0);
3938                 input_abs_set_res(input_dev, ABS_X,
3939                                   features->x_resolution);
3940                 input_abs_set_res(input_dev, ABS_Y,
3941                                   features->y_resolution);
3942         }
3943         else if (features->touch_max > 1) {
3944                 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
3945                         features->x_max, features->x_fuzz, 0);
3946                 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
3947                         features->y_max, features->y_fuzz, 0);
3948                 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
3949                                   features->x_resolution);
3950                 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
3951                                   features->y_resolution);
3952         }
3953
3954         switch (features->type) {
3955         case INTUOSP2_BT:
3956         case INTUOSP2S_BT:
3957                 input_dev->evbit[0] |= BIT_MASK(EV_SW);
3958                 __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
3959
3960                 if (wacom_wac->shared->touch->product == 0x361) {
3961                         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
3962                                              0, 12440, 4, 0);
3963                         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
3964                                              0, 8640, 4, 0);
3965                 }
3966                 else if (wacom_wac->shared->touch->product == 0x360) {
3967                         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
3968                                              0, 8960, 4, 0);
3969                         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
3970                                              0, 5920, 4, 0);
3971                 }
3972                 else if (wacom_wac->shared->touch->product == 0x393) {
3973                         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
3974                                              0, 6400, 4, 0);
3975                         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
3976                                              0, 4000, 4, 0);
3977                 }
3978                 input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40);
3979                 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, 40);
3980
3981                 fallthrough;
3982
3983         case INTUOS5:
3984         case INTUOS5L:
3985         case INTUOSPM:
3986         case INTUOSPL:
3987         case INTUOS5S:
3988         case INTUOSPS:
3989                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
3990                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, features->y_max, 0, 0);
3991                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
3992                 break;
3993
3994         case WACOM_24HDT:
3995                 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
3996                 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
3997                 input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
3998                 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
3999                 fallthrough;
4000
4001         case WACOM_27QHDT:
4002                 if (wacom_wac->shared->touch->product == 0x32C ||
4003                     wacom_wac->shared->touch->product == 0xF6) {
4004                         input_dev->evbit[0] |= BIT_MASK(EV_SW);
4005                         __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
4006                         wacom_wac->has_mute_touch_switch = true;
4007                         wacom_wac->is_soft_touch_switch = true;
4008                 }
4009                 fallthrough;
4010
4011         case MTSCREEN:
4012         case MTTPC:
4013         case MTTPC_B:
4014         case TABLETPC2FG:
4015                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_DIRECT);
4016                 fallthrough;
4017
4018         case TABLETPC:
4019         case TABLETPCE:
4020                 break;
4021
4022         case INTUOSHT:
4023         case INTUOSHT2:
4024                 input_dev->evbit[0] |= BIT_MASK(EV_SW);
4025                 __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
4026                 fallthrough;
4027
4028         case BAMBOO_PT:
4029         case BAMBOO_TOUCH:
4030                 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
4031                         input_set_abs_params(input_dev,
4032                                      ABS_MT_TOUCH_MAJOR,
4033                                      0, features->x_max, 0, 0);
4034                         input_set_abs_params(input_dev,
4035                                      ABS_MT_TOUCH_MINOR,
4036                                      0, features->y_max, 0, 0);
4037                 }
4038                 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
4039                 break;
4040
4041         case BAMBOO_PAD:
4042                 input_mt_init_slots(input_dev, features->touch_max,
4043                                     INPUT_MT_POINTER);
4044                 __set_bit(BTN_LEFT, input_dev->keybit);
4045                 __set_bit(BTN_RIGHT, input_dev->keybit);
4046                 break;
4047         }
4048         return 0;
4049 }
4050
4051 static int wacom_numbered_button_to_key(int n)
4052 {
4053         if (n < 10)
4054                 return BTN_0 + n;
4055         else if (n < 16)
4056                 return BTN_A + (n-10);
4057         else if (n < 18)
4058                 return BTN_BASE + (n-16);
4059         else
4060                 return 0;
4061 }
4062
4063 static void wacom_setup_numbered_buttons(struct input_dev *input_dev,
4064                                 int button_count)
4065 {
4066         int i;
4067
4068         for (i = 0; i < button_count; i++) {
4069                 int key = wacom_numbered_button_to_key(i);
4070
4071                 if (key)
4072                         __set_bit(key, input_dev->keybit);
4073         }
4074 }
4075
4076 static void wacom_24hd_update_leds(struct wacom *wacom, int mask, int group)
4077 {
4078         struct wacom_led *led;
4079         int i;
4080         bool updated = false;
4081
4082         /*
4083          * 24HD has LED group 1 to the left and LED group 0 to the right.
4084          * So group 0 matches the second half of the buttons and thus the mask
4085          * needs to be shifted.
4086          */
4087         if (group == 0)
4088                 mask >>= 8;
4089
4090         for (i = 0; i < 3; i++) {
4091                 led = wacom_led_find(wacom, group, i);
4092                 if (!led) {
4093                         hid_err(wacom->hdev, "can't find LED %d in group %d\n",
4094                                 i, group);
4095                         continue;
4096                 }
4097                 if (!updated && mask & BIT(i)) {
4098                         led->held = true;
4099                         led_trigger_event(&led->trigger, LED_FULL);
4100                 } else {
4101                         led->held = false;
4102                 }
4103         }
4104 }
4105
4106 static bool wacom_is_led_toggled(struct wacom *wacom, int button_count,
4107                                  int mask, int group)
4108 {
4109         int group_button;
4110
4111         /*
4112          * 21UX2 has LED group 1 to the left and LED group 0
4113          * to the right. We need to reverse the group to match this
4114          * historical behavior.
4115          */
4116         if (wacom->wacom_wac.features.type == WACOM_21UX2)
4117                 group = 1 - group;
4118
4119         group_button = group * (button_count/wacom->led.count);
4120
4121         if (wacom->wacom_wac.features.type == INTUOSP2_BT)
4122                 group_button = 8;
4123
4124         return mask & (1 << group_button);
4125 }
4126
4127 static void wacom_update_led(struct wacom *wacom, int button_count, int mask,
4128                              int group)
4129 {
4130         struct wacom_led *led, *next_led;
4131         int cur;
4132         bool pressed;
4133
4134         if (wacom->wacom_wac.features.type == WACOM_24HD)
4135                 return wacom_24hd_update_leds(wacom, mask, group);
4136
4137         pressed = wacom_is_led_toggled(wacom, button_count, mask, group);
4138         cur = wacom->led.groups[group].select;
4139
4140         led = wacom_led_find(wacom, group, cur);
4141         if (!led) {
4142                 hid_err(wacom->hdev, "can't find current LED %d in group %d\n",
4143                         cur, group);
4144                 return;
4145         }
4146
4147         if (!pressed) {
4148                 led->held = false;
4149                 return;
4150         }
4151
4152         if (led->held && pressed)
4153                 return;
4154
4155         next_led = wacom_led_next(wacom, led);
4156         if (!next_led) {
4157                 hid_err(wacom->hdev, "can't find next LED in group %d\n",
4158                         group);
4159                 return;
4160         }
4161         if (next_led == led)
4162                 return;
4163
4164         next_led->held = true;
4165         led_trigger_event(&next_led->trigger,
4166                           wacom_leds_brightness_get(next_led));
4167 }
4168
4169 static void wacom_report_numbered_buttons(struct input_dev *input_dev,
4170                                 int button_count, int mask)
4171 {
4172         struct wacom *wacom = input_get_drvdata(input_dev);
4173         int i;
4174
4175         for (i = 0; i < wacom->led.count; i++)
4176                 wacom_update_led(wacom,  button_count, mask, i);
4177
4178         for (i = 0; i < button_count; i++) {
4179                 int key = wacom_numbered_button_to_key(i);
4180
4181                 if (key)
4182                         input_report_key(input_dev, key, mask & (1 << i));
4183         }
4184 }
4185
4186 int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
4187                                    struct wacom_wac *wacom_wac)
4188 {
4189         struct wacom_features *features = &wacom_wac->features;
4190
4191         if ((features->type == HID_GENERIC) && features->numbered_buttons > 0)
4192                 features->device_type |= WACOM_DEVICETYPE_PAD;
4193
4194         if (!(features->device_type & WACOM_DEVICETYPE_PAD))
4195                 return -ENODEV;
4196
4197         if (features->type == REMOTE && input_dev == wacom_wac->pad_input)
4198                 return -ENODEV;
4199
4200         input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
4201
4202         /* kept for making legacy xf86-input-wacom working with the wheels */
4203         __set_bit(ABS_MISC, input_dev->absbit);
4204
4205         /* kept for making legacy xf86-input-wacom accepting the pad */
4206         if (!(input_dev->absinfo && (input_dev->absinfo[ABS_X].minimum ||
4207               input_dev->absinfo[ABS_X].maximum)))
4208                 input_set_abs_params(input_dev, ABS_X, 0, 1, 0, 0);
4209         if (!(input_dev->absinfo && (input_dev->absinfo[ABS_Y].minimum ||
4210               input_dev->absinfo[ABS_Y].maximum)))
4211                 input_set_abs_params(input_dev, ABS_Y, 0, 1, 0, 0);
4212
4213         /* kept for making udev and libwacom accepting the pad */
4214         __set_bit(BTN_STYLUS, input_dev->keybit);
4215
4216         wacom_setup_numbered_buttons(input_dev, features->numbered_buttons);
4217
4218         switch (features->type) {
4219
4220         case CINTIQ_HYBRID:
4221         case CINTIQ_COMPANION_2:
4222         case DTK:
4223         case DTUS:
4224         case GRAPHIRE_BT:
4225                 break;
4226
4227         case WACOM_MO:
4228                 __set_bit(BTN_BACK, input_dev->keybit);
4229                 __set_bit(BTN_LEFT, input_dev->keybit);
4230                 __set_bit(BTN_FORWARD, input_dev->keybit);
4231                 __set_bit(BTN_RIGHT, input_dev->keybit);
4232                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
4233                 break;
4234
4235         case WACOM_G4:
4236                 __set_bit(BTN_BACK, input_dev->keybit);
4237                 __set_bit(BTN_FORWARD, input_dev->keybit);
4238                 input_set_capability(input_dev, EV_REL, REL_WHEEL);
4239                 break;
4240
4241         case WACOM_24HD:
4242                 __set_bit(KEY_PROG1, input_dev->keybit);
4243                 __set_bit(KEY_PROG2, input_dev->keybit);
4244                 __set_bit(KEY_PROG3, input_dev->keybit);
4245
4246                 __set_bit(KEY_ONSCREEN_KEYBOARD, input_dev->keybit);
4247                 __set_bit(KEY_INFO, input_dev->keybit);
4248
4249                 if (!features->oPid)
4250                         __set_bit(KEY_BUTTONCONFIG, input_dev->keybit);
4251
4252                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
4253                 input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
4254                 break;
4255
4256         case WACOM_27QHD:
4257                 __set_bit(KEY_PROG1, input_dev->keybit);
4258                 __set_bit(KEY_PROG2, input_dev->keybit);
4259                 __set_bit(KEY_PROG3, input_dev->keybit);
4260
4261                 __set_bit(KEY_ONSCREEN_KEYBOARD, input_dev->keybit);
4262                 __set_bit(KEY_BUTTONCONFIG, input_dev->keybit);
4263
4264                 if (!features->oPid)
4265                         __set_bit(KEY_CONTROLPANEL, input_dev->keybit);
4266                 input_set_abs_params(input_dev, ABS_X, -2048, 2048, 0, 0);
4267                 input_abs_set_res(input_dev, ABS_X, 1024); /* points/g */
4268                 input_set_abs_params(input_dev, ABS_Y, -2048, 2048, 0, 0);
4269                 input_abs_set_res(input_dev, ABS_Y, 1024);
4270                 input_set_abs_params(input_dev, ABS_Z, -2048, 2048, 0, 0);
4271                 input_abs_set_res(input_dev, ABS_Z, 1024);
4272                 __set_bit(INPUT_PROP_ACCELEROMETER, input_dev->propbit);
4273                 break;
4274
4275         case WACOM_22HD:
4276                 __set_bit(KEY_PROG1, input_dev->keybit);
4277                 __set_bit(KEY_PROG2, input_dev->keybit);
4278                 __set_bit(KEY_PROG3, input_dev->keybit);
4279
4280                 __set_bit(KEY_BUTTONCONFIG, input_dev->keybit);
4281                 __set_bit(KEY_INFO, input_dev->keybit);
4282                 fallthrough;
4283
4284         case WACOM_21UX2:
4285         case WACOM_BEE:
4286         case CINTIQ:
4287                 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
4288                 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
4289                 break;
4290
4291         case WACOM_13HD:
4292                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
4293                 break;
4294
4295         case INTUOS3:
4296         case INTUOS3L:
4297                 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
4298                 fallthrough;
4299
4300         case INTUOS3S:
4301                 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
4302                 break;
4303
4304         case INTUOS5:
4305         case INTUOS5L:
4306         case INTUOSPM:
4307         case INTUOSPL:
4308         case INTUOS5S:
4309         case INTUOSPS:
4310         case INTUOSP2_BT:
4311         case INTUOSP2S_BT:
4312                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
4313                 break;
4314
4315         case INTUOS4WL:
4316                 /*
4317                  * For Bluetooth devices, the udev rule does not work correctly
4318                  * for pads unless we add a stylus capability, which forces
4319                  * ID_INPUT_TABLET to be set.
4320                  */
4321                 __set_bit(BTN_STYLUS, input_dev->keybit);
4322                 fallthrough;
4323
4324         case INTUOS4:
4325         case INTUOS4L:
4326         case INTUOS4S:
4327                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
4328                 break;
4329
4330         case INTUOSHT:
4331         case BAMBOO_PT:
4332         case BAMBOO_TOUCH:
4333         case INTUOSHT2:
4334                 __clear_bit(ABS_MISC, input_dev->absbit);
4335
4336                 __set_bit(BTN_LEFT, input_dev->keybit);
4337                 __set_bit(BTN_FORWARD, input_dev->keybit);
4338                 __set_bit(BTN_BACK, input_dev->keybit);
4339                 __set_bit(BTN_RIGHT, input_dev->keybit);
4340
4341                 break;
4342
4343         case REMOTE:
4344                 input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
4345                 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
4346                 break;
4347
4348         case INTUOSHT3_BT:
4349         case HID_GENERIC:
4350                 break;
4351
4352         default:
4353                 /* no pad supported */
4354                 return -ENODEV;
4355         }
4356         return 0;
4357 }
4358
4359 static const struct wacom_features wacom_features_0x00 =
4360         { "Wacom Penpartner", 5040, 3780, 255, 0,
4361           PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
4362 static const struct wacom_features wacom_features_0x10 =
4363         { "Wacom Graphire", 10206, 7422, 511, 63,
4364           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
4365 static const struct wacom_features wacom_features_0x81 =
4366         { "Wacom Graphire BT", 16704, 12064, 511, 32,
4367           GRAPHIRE_BT, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES, 2 };
4368 static const struct wacom_features wacom_features_0x11 =
4369         { "Wacom Graphire2 4x5", 10206, 7422, 511, 63,
4370           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
4371 static const struct wacom_features wacom_features_0x12 =
4372         { "Wacom Graphire2 5x7", 13918, 10206, 511, 63,
4373           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
4374 static const struct wacom_features wacom_features_0x13 =
4375         { "Wacom Graphire3", 10208, 7424, 511, 63,
4376           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
4377 static const struct wacom_features wacom_features_0x14 =
4378         { "Wacom Graphire3 6x8", 16704, 12064, 511, 63,
4379           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
4380 static const struct wacom_features wacom_features_0x15 =
4381         { "Wacom Graphire4 4x5", 10208, 7424, 511, 63,
4382           WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
4383 static const struct wacom_features wacom_features_0x16 =
4384         { "Wacom Graphire4 6x8", 16704, 12064, 511, 63,
4385           WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
4386 static const struct wacom_features wacom_features_0x17 =
4387         { "Wacom BambooFun 4x5", 14760, 9225, 511, 63,
4388           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4389 static const struct wacom_features wacom_features_0x18 =
4390         { "Wacom BambooFun 6x8", 21648, 13530, 511, 63,
4391           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4392 static const struct wacom_features wacom_features_0x19 =
4393         { "Wacom Bamboo1 Medium", 16704, 12064, 511, 63,
4394           GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
4395 static const struct wacom_features wacom_features_0x60 =
4396         { "Wacom Volito", 5104, 3712, 511, 63,
4397           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
4398 static const struct wacom_features wacom_features_0x61 =
4399         { "Wacom PenStation2", 3250, 2320, 255, 63,
4400           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
4401 static const struct wacom_features wacom_features_0x62 =
4402         { "Wacom Volito2 4x5", 5104, 3712, 511, 63,
4403           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
4404 static const struct wacom_features wacom_features_0x63 =
4405         { "Wacom Volito2 2x3", 3248, 2320, 511, 63,
4406           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
4407 static const struct wacom_features wacom_features_0x64 =
4408         { "Wacom PenPartner2", 3250, 2320, 511, 63,
4409           GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
4410 static const struct wacom_features wacom_features_0x65 =
4411         { "Wacom Bamboo", 14760, 9225, 511, 63,
4412           WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4413 static const struct wacom_features wacom_features_0x69 =
4414         { "Wacom Bamboo1", 5104, 3712, 511, 63,
4415           GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
4416 static const struct wacom_features wacom_features_0x6A =
4417         { "Wacom Bamboo1 4x6", 14760, 9225, 1023, 63,
4418           GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4419 static const struct wacom_features wacom_features_0x6B =
4420         { "Wacom Bamboo1 5x8", 21648, 13530, 1023, 63,
4421           GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4422 static const struct wacom_features wacom_features_0x20 =
4423         { "Wacom Intuos 4x5", 12700, 10600, 1023, 31,
4424           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4425 static const struct wacom_features wacom_features_0x21 =
4426         { "Wacom Intuos 6x8", 20320, 16240, 1023, 31,
4427           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4428 static const struct wacom_features wacom_features_0x22 =
4429         { "Wacom Intuos 9x12", 30480, 24060, 1023, 31,
4430           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4431 static const struct wacom_features wacom_features_0x23 =
4432         { "Wacom Intuos 12x12", 30480, 31680, 1023, 31,
4433           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4434 static const struct wacom_features wacom_features_0x24 =
4435         { "Wacom Intuos 12x18", 45720, 31680, 1023, 31,
4436           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4437 static const struct wacom_features wacom_features_0x30 =
4438         { "Wacom PL400", 5408, 4056, 255, 0,
4439           PL, WACOM_PL_RES, WACOM_PL_RES };
4440 static const struct wacom_features wacom_features_0x31 =
4441         { "Wacom PL500", 6144, 4608, 255, 0,
4442           PL, WACOM_PL_RES, WACOM_PL_RES };
4443 static const struct wacom_features wacom_features_0x32 =
4444         { "Wacom PL600", 6126, 4604, 255, 0,
4445           PL, WACOM_PL_RES, WACOM_PL_RES };
4446 static const struct wacom_features wacom_features_0x33 =
4447         { "Wacom PL600SX", 6260, 5016, 255, 0,
4448           PL, WACOM_PL_RES, WACOM_PL_RES };
4449 static const struct wacom_features wacom_features_0x34 =
4450         { "Wacom PL550", 6144, 4608, 511, 0,
4451           PL, WACOM_PL_RES, WACOM_PL_RES };
4452 static const struct wacom_features wacom_features_0x35 =
4453         { "Wacom PL800", 7220, 5780, 511, 0,
4454           PL, WACOM_PL_RES, WACOM_PL_RES };
4455 static const struct wacom_features wacom_features_0x37 =
4456         { "Wacom PL700", 6758, 5406, 511, 0,
4457           PL, WACOM_PL_RES, WACOM_PL_RES };
4458 static const struct wacom_features wacom_features_0x38 =
4459         { "Wacom PL510", 6282, 4762, 511, 0,
4460           PL, WACOM_PL_RES, WACOM_PL_RES };
4461 static const struct wacom_features wacom_features_0x39 =
4462         { "Wacom DTU710", 34080, 27660, 511, 0,
4463           PL, WACOM_PL_RES, WACOM_PL_RES };
4464 static const struct wacom_features wacom_features_0xC4 =
4465         { "Wacom DTF521", 6282, 4762, 511, 0,
4466           PL, WACOM_PL_RES, WACOM_PL_RES };
4467 static const struct wacom_features wacom_features_0xC0 =
4468         { "Wacom DTF720", 6858, 5506, 511, 0,
4469           PL, WACOM_PL_RES, WACOM_PL_RES };
4470 static const struct wacom_features wacom_features_0xC2 =
4471         { "Wacom DTF720a", 6858, 5506, 511, 0,
4472           PL, WACOM_PL_RES, WACOM_PL_RES };
4473 static const struct wacom_features wacom_features_0x03 =
4474         { "Wacom Cintiq Partner", 20480, 15360, 511, 0,
4475           PTU, WACOM_PL_RES, WACOM_PL_RES };
4476 static const struct wacom_features wacom_features_0x41 =
4477         { "Wacom Intuos2 4x5", 12700, 10600, 1023, 31,
4478           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4479 static const struct wacom_features wacom_features_0x42 =
4480         { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
4481           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4482 static const struct wacom_features wacom_features_0x43 =
4483         { "Wacom Intuos2 9x12", 30480, 24060, 1023, 31,
4484           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4485 static const struct wacom_features wacom_features_0x44 =
4486         { "Wacom Intuos2 12x12", 30480, 31680, 1023, 31,
4487           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4488 static const struct wacom_features wacom_features_0x45 =
4489         { "Wacom Intuos2 12x18", 45720, 31680, 1023, 31,
4490           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4491 static const struct wacom_features wacom_features_0xB0 =
4492         { "Wacom Intuos3 4x5", 25400, 20320, 1023, 63,
4493           INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
4494 static const struct wacom_features wacom_features_0xB1 =
4495         { "Wacom Intuos3 6x8", 40640, 30480, 1023, 63,
4496           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
4497 static const struct wacom_features wacom_features_0xB2 =
4498         { "Wacom Intuos3 9x12", 60960, 45720, 1023, 63,
4499           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
4500 static const struct wacom_features wacom_features_0xB3 =
4501         { "Wacom Intuos3 12x12", 60960, 60960, 1023, 63,
4502           INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
4503 static const struct wacom_features wacom_features_0xB4 =
4504         { "Wacom Intuos3 12x19", 97536, 60960, 1023, 63,
4505           INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
4506 static const struct wacom_features wacom_features_0xB5 =
4507         { "Wacom Intuos3 6x11", 54204, 31750, 1023, 63,
4508           INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
4509 static const struct wacom_features wacom_features_0xB7 =
4510         { "Wacom Intuos3 4x6", 31496, 19685, 1023, 63,
4511           INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 4 };
4512 static const struct wacom_features wacom_features_0xB8 =
4513         { "Wacom Intuos4 4x6", 31496, 19685, 2047, 63,
4514           INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
4515 static const struct wacom_features wacom_features_0xB9 =
4516         { "Wacom Intuos4 6x9", 44704, 27940, 2047, 63,
4517           INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
4518 static const struct wacom_features wacom_features_0xBA =
4519         { "Wacom Intuos4 8x13", 65024, 40640, 2047, 63,
4520           INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
4521 static const struct wacom_features wacom_features_0xBB =
4522         { "Wacom Intuos4 12x19", 97536, 60960, 2047, 63,
4523           INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
4524 static const struct wacom_features wacom_features_0xBC =
4525         { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
4526           INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
4527 static const struct wacom_features wacom_features_0xBD =
4528         { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
4529           INTUOS4WL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
4530 static const struct wacom_features wacom_features_0x26 =
4531         { "Wacom Intuos5 touch S", 31496, 19685, 2047, 63,
4532           INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16 };
4533 static const struct wacom_features wacom_features_0x27 =
4534         { "Wacom Intuos5 touch M", 44704, 27940, 2047, 63,
4535           INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
4536 static const struct wacom_features wacom_features_0x28 =
4537         { "Wacom Intuos5 touch L", 65024, 40640, 2047, 63,
4538           INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16 };
4539 static const struct wacom_features wacom_features_0x29 =
4540         { "Wacom Intuos5 S", 31496, 19685, 2047, 63,
4541           INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7 };
4542 static const struct wacom_features wacom_features_0x2A =
4543         { "Wacom Intuos5 M", 44704, 27940, 2047, 63,
4544           INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9 };
4545 static const struct wacom_features wacom_features_0x314 =
4546         { "Wacom Intuos Pro S", 31496, 19685, 2047, 63,
4547           INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7, .touch_max = 16,
4548           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4549 static const struct wacom_features wacom_features_0x315 =
4550         { "Wacom Intuos Pro M", 44704, 27940, 2047, 63,
4551           INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
4552           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4553 static const struct wacom_features wacom_features_0x317 =
4554         { "Wacom Intuos Pro L", 65024, 40640, 2047, 63,
4555           INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 16,
4556           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4557 static const struct wacom_features wacom_features_0xF4 =
4558         { "Wacom Cintiq 24HD", 104480, 65600, 2047, 63,
4559           WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
4560           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4561           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
4562 static const struct wacom_features wacom_features_0xF8 =
4563         { "Wacom Cintiq 24HD touch", 104480, 65600, 2047, 63, /* Pen */
4564           WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 16,
4565           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4566           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4567           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
4568 static const struct wacom_features wacom_features_0xF6 =
4569         { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
4570           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
4571           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4572 static const struct wacom_features wacom_features_0x32A =
4573         { "Wacom Cintiq 27QHD", 120140, 67920, 2047, 63,
4574           WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
4575           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4576           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
4577 static const struct wacom_features wacom_features_0x32B =
4578         { "Wacom Cintiq 27QHD touch", 120140, 67920, 2047, 63,
4579           WACOM_27QHD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 0,
4580           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4581           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4582           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32C };
4583 static const struct wacom_features wacom_features_0x32C =
4584         { "Wacom Cintiq 27QHD touch", .type = WACOM_27QHDT,
4585           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x32B, .touch_max = 10 };
4586 static const struct wacom_features wacom_features_0x3F =
4587         { "Wacom Cintiq 21UX", 87200, 65600, 1023, 63,
4588           CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 8 };
4589 static const struct wacom_features wacom_features_0xC5 =
4590         { "Wacom Cintiq 20WSX", 86680, 54180, 1023, 63,
4591           WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
4592 static const struct wacom_features wacom_features_0xC6 =
4593         { "Wacom Cintiq 12WX", 53020, 33440, 1023, 63,
4594           WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 10 };
4595 static const struct wacom_features wacom_features_0x304 =
4596         { "Wacom Cintiq 13HD", 59552, 33848, 1023, 63,
4597           WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
4598           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4599           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
4600 static const struct wacom_features wacom_features_0x333 =
4601         { "Wacom Cintiq 13HD touch", 59552, 33848, 2047, 63,
4602           WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
4603           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4604           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4605           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x335 };
4606 static const struct wacom_features wacom_features_0x335 =
4607         { "Wacom Cintiq 13HD touch", .type = WACOM_24HDT, /* Touch */
4608           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x333, .touch_max = 10,
4609           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4610 static const struct wacom_features wacom_features_0xC7 =
4611         { "Wacom DTU1931", 37832, 30305, 511, 0,
4612           PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4613 static const struct wacom_features wacom_features_0xCE =
4614         { "Wacom DTU2231", 47864, 27011, 511, 0,
4615           DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
4616           .check_for_hid_type = true, .hid_type = HID_TYPE_USBMOUSE };
4617 static const struct wacom_features wacom_features_0xF0 =
4618         { "Wacom DTU1631", 34623, 19553, 511, 0,
4619           DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4620 static const struct wacom_features wacom_features_0xFB =
4621         { "Wacom DTU1031", 22096, 13960, 511, 0,
4622           DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
4623           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
4624           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
4625 static const struct wacom_features wacom_features_0x32F =
4626         { "Wacom DTU1031X", 22672, 12928, 511, 0,
4627           DTUSX, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 0,
4628           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
4629           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
4630 static const struct wacom_features wacom_features_0x336 =
4631         { "Wacom DTU1141", 23672, 13403, 1023, 0,
4632           DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
4633           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
4634           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
4635 static const struct wacom_features wacom_features_0x57 =
4636         { "Wacom DTK2241", 95840, 54260, 2047, 63,
4637           DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
4638           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4639           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
4640 static const struct wacom_features wacom_features_0x59 = /* Pen */
4641         { "Wacom DTH2242", 95840, 54260, 2047, 63,
4642           DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 6,
4643           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4644           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4645           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
4646 static const struct wacom_features wacom_features_0x5D = /* Touch */
4647         { "Wacom DTH2242",       .type = WACOM_24HDT,
4648           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10,
4649           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4650 static const struct wacom_features wacom_features_0xCC =
4651         { "Wacom Cintiq 21UX2", 87200, 65600, 2047, 63,
4652           WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
4653           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4654           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
4655 static const struct wacom_features wacom_features_0xFA =
4656         { "Wacom Cintiq 22HD", 95840, 54260, 2047, 63,
4657           WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
4658           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4659           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET };
4660 static const struct wacom_features wacom_features_0x5B =
4661         { "Wacom Cintiq 22HDT", 95840, 54260, 2047, 63,
4662           WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 18,
4663           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4664           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4665           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e };
4666 static const struct wacom_features wacom_features_0x5E =
4667         { "Wacom Cintiq 22HDT", .type = WACOM_24HDT,
4668           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10,
4669           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4670 static const struct wacom_features wacom_features_0x90 =
4671         { "Wacom ISDv4 90", 26202, 16325, 255, 0,
4672           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
4673 static const struct wacom_features wacom_features_0x93 =
4674         { "Wacom ISDv4 93", 26202, 16325, 255, 0,
4675           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
4676 static const struct wacom_features wacom_features_0x97 =
4677         { "Wacom ISDv4 97", 26202, 16325, 511, 0,
4678           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
4679 static const struct wacom_features wacom_features_0x9A =
4680         { "Wacom ISDv4 9A", 26202, 16325, 255, 0,
4681           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
4682 static const struct wacom_features wacom_features_0x9F =
4683         { "Wacom ISDv4 9F", 26202, 16325, 255, 0,
4684           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
4685 static const struct wacom_features wacom_features_0xE2 =
4686         { "Wacom ISDv4 E2", 26202, 16325, 255, 0,
4687           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4688 static const struct wacom_features wacom_features_0xE3 =
4689         { "Wacom ISDv4 E3", 26202, 16325, 255, 0,
4690           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4691 static const struct wacom_features wacom_features_0xE5 =
4692         { "Wacom ISDv4 E5", 26202, 16325, 255, 0,
4693           MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4694 static const struct wacom_features wacom_features_0xE6 =
4695         { "Wacom ISDv4 E6", 27760, 15694, 255, 0,
4696           TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4697 static const struct wacom_features wacom_features_0xEC =
4698         { "Wacom ISDv4 EC", 25710, 14500, 255, 0,
4699           TABLETPC,    WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
4700 static const struct wacom_features wacom_features_0xED =
4701         { "Wacom ISDv4 ED", 26202, 16325, 255, 0,
4702           TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
4703 static const struct wacom_features wacom_features_0xEF =
4704         { "Wacom ISDv4 EF", 26202, 16325, 255, 0,
4705           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
4706 static const struct wacom_features wacom_features_0x100 =
4707         { "Wacom ISDv4 100", 26202, 16325, 255, 0,
4708           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4709 static const struct wacom_features wacom_features_0x101 =
4710         { "Wacom ISDv4 101", 26202, 16325, 255, 0,
4711           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4712 static const struct wacom_features wacom_features_0x10D =
4713         { "Wacom ISDv4 10D", 26202, 16325, 255, 0,
4714           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4715 static const struct wacom_features wacom_features_0x10E =
4716         { "Wacom ISDv4 10E", 27760, 15694, 255, 0,
4717           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4718 static const struct wacom_features wacom_features_0x10F =
4719         { "Wacom ISDv4 10F", 27760, 15694, 255, 0,
4720           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4721 static const struct wacom_features wacom_features_0x116 =
4722         { "Wacom ISDv4 116", 26202, 16325, 255, 0,
4723           TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 1 };
4724 static const struct wacom_features wacom_features_0x12C =
4725         { "Wacom ISDv4 12C", 27848, 15752, 2047, 0,
4726           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; /* Pen-only */
4727 static const struct wacom_features wacom_features_0x4001 =
4728         { "Wacom ISDv4 4001", 26202, 16325, 255, 0,
4729           MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4730 static const struct wacom_features wacom_features_0x4004 =
4731         { "Wacom ISDv4 4004", 11060, 6220, 255, 0,
4732           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4733 static const struct wacom_features wacom_features_0x5000 =
4734         { "Wacom ISDv4 5000", 27848, 15752, 1023, 0,
4735           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4736 static const struct wacom_features wacom_features_0x5002 =
4737         { "Wacom ISDv4 5002", 29576, 16724, 1023, 0,
4738           MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4739 static const struct wacom_features wacom_features_0x47 =
4740         { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
4741           INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4742 static const struct wacom_features wacom_features_0x84 =
4743         { "Wacom Wireless Receiver", .type = WIRELESS, .touch_max = 16 };
4744 static const struct wacom_features wacom_features_0xD0 =
4745         { "Wacom Bamboo 2FG", 14720, 9200, 1023, 31,
4746           BAMBOO_TOUCH, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4747 static const struct wacom_features wacom_features_0xD1 =
4748         { "Wacom Bamboo 2FG 4x5", 14720, 9200, 1023, 31,
4749           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4750 static const struct wacom_features wacom_features_0xD2 =
4751         { "Wacom Bamboo Craft", 14720, 9200, 1023, 31,
4752           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4753 static const struct wacom_features wacom_features_0xD3 =
4754         { "Wacom Bamboo 2FG 6x8", 21648, 13700, 1023, 31,
4755           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4756 static const struct wacom_features wacom_features_0xD4 =
4757         { "Wacom Bamboo Pen", 14720, 9200, 1023, 31,
4758           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4759 static const struct wacom_features wacom_features_0xD5 =
4760         { "Wacom Bamboo Pen 6x8", 21648, 13700, 1023, 31,
4761           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4762 static const struct wacom_features wacom_features_0xD6 =
4763         { "Wacom BambooPT 2FG 4x5", 14720, 9200, 1023, 31,
4764           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4765 static const struct wacom_features wacom_features_0xD7 =
4766         { "Wacom BambooPT 2FG Small", 14720, 9200, 1023, 31,
4767           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4768 static const struct wacom_features wacom_features_0xD8 =
4769         { "Wacom Bamboo Comic 2FG", 21648, 13700, 1023, 31,
4770           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4771 static const struct wacom_features wacom_features_0xDA =
4772         { "Wacom Bamboo 2FG 4x5 SE", 14720, 9200, 1023, 31,
4773           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4774 static const struct wacom_features wacom_features_0xDB =
4775         { "Wacom Bamboo 2FG 6x8 SE", 21648, 13700, 1023, 31,
4776           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
4777 static const struct wacom_features wacom_features_0xDD =
4778         { "Wacom Bamboo Connect", 14720, 9200, 1023, 31,
4779           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4780 static const struct wacom_features wacom_features_0xDE =
4781         { "Wacom Bamboo 16FG 4x5", 14720, 9200, 1023, 31,
4782           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
4783 static const struct wacom_features wacom_features_0xDF =
4784         { "Wacom Bamboo 16FG 6x8", 21648, 13700, 1023, 31,
4785           BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
4786 static const struct wacom_features wacom_features_0x300 =
4787         { "Wacom Bamboo One S", 14720, 9225, 1023, 31,
4788           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4789 static const struct wacom_features wacom_features_0x301 =
4790         { "Wacom Bamboo One M", 21648, 13530, 1023, 31,
4791           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4792 static const struct wacom_features wacom_features_0x302 =
4793         { "Wacom Intuos PT S", 15200, 9500, 1023, 31,
4794           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
4795           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4796 static const struct wacom_features wacom_features_0x303 =
4797         { "Wacom Intuos PT M", 21600, 13500, 1023, 31,
4798           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
4799           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4800 static const struct wacom_features wacom_features_0x30E =
4801         { "Wacom Intuos S", 15200, 9500, 1023, 31,
4802           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
4803           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4804 static const struct wacom_features wacom_features_0x6004 =
4805         { "ISD-V4", 12800, 8000, 255, 0,
4806           TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4807 static const struct wacom_features wacom_features_0x307 =
4808         { "Wacom ISDv5 307", 59552, 33848, 2047, 63,
4809           CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
4810           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4811           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4812           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
4813 static const struct wacom_features wacom_features_0x309 =
4814         { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
4815           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10,
4816           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4817 static const struct wacom_features wacom_features_0x30A =
4818         { "Wacom ISDv5 30A", 59552, 33848, 2047, 63,
4819           CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9,
4820           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4821           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4822           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30C };
4823 static const struct wacom_features wacom_features_0x30C =
4824         { "Wacom ISDv5 30C", .type = WACOM_24HDT, /* Touch */
4825           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x30A, .touch_max = 10,
4826           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4827 static const struct wacom_features wacom_features_0x318 =
4828         { "Wacom USB Bamboo PAD", 4095, 4095, /* Touch */
4829           .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
4830 static const struct wacom_features wacom_features_0x319 =
4831         { "Wacom Wireless Bamboo PAD", 4095, 4095, /* Touch */
4832           .type = BAMBOO_PAD, 35, 48, .touch_max = 4 };
4833 static const struct wacom_features wacom_features_0x325 =
4834         { "Wacom ISDv5 325", 59552, 33848, 2047, 63,
4835           CINTIQ_COMPANION_2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 11,
4836           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4837           WACOM_CINTIQ_OFFSET, WACOM_CINTIQ_OFFSET,
4838           .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x326 };
4839 static const struct wacom_features wacom_features_0x326 = /* Touch */
4840         { "Wacom ISDv5 326", .type = HID_GENERIC, .oVid = USB_VENDOR_ID_WACOM,
4841           .oPid = 0x325 };
4842 static const struct wacom_features wacom_features_0x323 =
4843         { "Wacom Intuos P M", 21600, 13500, 1023, 31,
4844           INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
4845           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4846 static const struct wacom_features wacom_features_0x331 =
4847         { "Wacom Express Key Remote", .type = REMOTE,
4848           .numbered_buttons = 18, .check_for_hid_type = true,
4849           .hid_type = HID_TYPE_USBNONE };
4850 static const struct wacom_features wacom_features_0x33B =
4851         { "Wacom Intuos S 2", 15200, 9500, 2047, 63,
4852           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
4853           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4854 static const struct wacom_features wacom_features_0x33C =
4855         { "Wacom Intuos PT S 2", 15200, 9500, 2047, 63,
4856           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
4857           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4858 static const struct wacom_features wacom_features_0x33D =
4859         { "Wacom Intuos P M 2", 21600, 13500, 2047, 63,
4860           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
4861           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4862 static const struct wacom_features wacom_features_0x33E =
4863         { "Wacom Intuos PT M 2", 21600, 13500, 2047, 63,
4864           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
4865           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
4866 static const struct wacom_features wacom_features_0x343 =
4867         { "Wacom DTK1651", 34816, 19759, 1023, 0,
4868           DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
4869           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET,
4870           WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
4871 static const struct wacom_features wacom_features_0x360 =
4872         { "Wacom Intuos Pro M", 44800, 29600, 8191, 63,
4873           INTUOSP2_BT, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 10 };
4874 static const struct wacom_features wacom_features_0x361 =
4875         { "Wacom Intuos Pro L", 62200, 43200, 8191, 63,
4876           INTUOSP2_BT, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 9, .touch_max = 10 };
4877 static const struct wacom_features wacom_features_0x377 =
4878         { "Wacom Intuos BT S", 15200, 9500, 4095, 63,
4879           INTUOSHT3_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4 };
4880 static const struct wacom_features wacom_features_0x379 =
4881         { "Wacom Intuos BT M", 21600, 13500, 4095, 63,
4882           INTUOSHT3_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4 };
4883 static const struct wacom_features wacom_features_0x37A =
4884         { "Wacom One by Wacom S", 15200, 9500, 2047, 63,
4885           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4886 static const struct wacom_features wacom_features_0x37B =
4887         { "Wacom One by Wacom M", 21600, 13500, 2047, 63,
4888           BAMBOO_PEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
4889 static const struct wacom_features wacom_features_0x393 =
4890         { "Wacom Intuos Pro S", 31920, 19950, 8191, 63,
4891           INTUOSP2S_BT, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7,
4892           .touch_max = 10 };
4893 static const struct wacom_features wacom_features_0x3c6 =
4894         { "Wacom Intuos BT S", 15200, 9500, 4095, 63,
4895           INTUOSHT3_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4 };
4896 static const struct wacom_features wacom_features_0x3c8 =
4897         { "Wacom Intuos BT M", 21600, 13500, 4095, 63,
4898           INTUOSHT3_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4 };
4899 static const struct wacom_features wacom_features_0x3dd =
4900         { "Wacom Intuos Pro S", 31920, 19950, 8191, 63,
4901           INTUOSP2S_BT, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 7,
4902           .touch_max = 10 };
4903
4904 static const struct wacom_features wacom_features_HID_ANY_ID =
4905         { "Wacom HID", .type = HID_GENERIC, .oVid = HID_ANY_ID, .oPid = HID_ANY_ID };
4906
4907 static const struct wacom_features wacom_features_0x94 =
4908         { "Wacom Bootloader", .type = BOOTLOADER };
4909
4910 #define USB_DEVICE_WACOM(prod)                                          \
4911         HID_DEVICE(BUS_USB, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
4912         .driver_data = (kernel_ulong_t)&wacom_features_##prod
4913
4914 #define BT_DEVICE_WACOM(prod)                                           \
4915         HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
4916         .driver_data = (kernel_ulong_t)&wacom_features_##prod
4917
4918 #define I2C_DEVICE_WACOM(prod)                                          \
4919         HID_DEVICE(BUS_I2C, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
4920         .driver_data = (kernel_ulong_t)&wacom_features_##prod
4921
4922 #define USB_DEVICE_LENOVO(prod)                                 \
4923         HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),                     \
4924         .driver_data = (kernel_ulong_t)&wacom_features_##prod
4925
4926 const struct hid_device_id wacom_ids[] = {
4927         { USB_DEVICE_WACOM(0x00) },
4928         { USB_DEVICE_WACOM(0x03) },
4929         { USB_DEVICE_WACOM(0x10) },
4930         { USB_DEVICE_WACOM(0x11) },
4931         { USB_DEVICE_WACOM(0x12) },
4932         { USB_DEVICE_WACOM(0x13) },
4933         { USB_DEVICE_WACOM(0x14) },
4934         { USB_DEVICE_WACOM(0x15) },
4935         { USB_DEVICE_WACOM(0x16) },
4936         { USB_DEVICE_WACOM(0x17) },
4937         { USB_DEVICE_WACOM(0x18) },
4938         { USB_DEVICE_WACOM(0x19) },
4939         { USB_DEVICE_WACOM(0x20) },
4940         { USB_DEVICE_WACOM(0x21) },
4941         { USB_DEVICE_WACOM(0x22) },
4942         { USB_DEVICE_WACOM(0x23) },
4943         { USB_DEVICE_WACOM(0x24) },
4944         { USB_DEVICE_WACOM(0x26) },
4945         { USB_DEVICE_WACOM(0x27) },
4946         { USB_DEVICE_WACOM(0x28) },
4947         { USB_DEVICE_WACOM(0x29) },
4948         { USB_DEVICE_WACOM(0x2A) },
4949         { USB_DEVICE_WACOM(0x30) },
4950         { USB_DEVICE_WACOM(0x31) },
4951         { USB_DEVICE_WACOM(0x32) },
4952         { USB_DEVICE_WACOM(0x33) },
4953         { USB_DEVICE_WACOM(0x34) },
4954         { USB_DEVICE_WACOM(0x35) },
4955         { USB_DEVICE_WACOM(0x37) },
4956         { USB_DEVICE_WACOM(0x38) },
4957         { USB_DEVICE_WACOM(0x39) },
4958         { USB_DEVICE_WACOM(0x3F) },
4959         { USB_DEVICE_WACOM(0x41) },
4960         { USB_DEVICE_WACOM(0x42) },
4961         { USB_DEVICE_WACOM(0x43) },
4962         { USB_DEVICE_WACOM(0x44) },
4963         { USB_DEVICE_WACOM(0x45) },
4964         { USB_DEVICE_WACOM(0x47) },
4965         { USB_DEVICE_WACOM(0x57) },
4966         { USB_DEVICE_WACOM(0x59) },
4967         { USB_DEVICE_WACOM(0x5B) },
4968         { USB_DEVICE_WACOM(0x5D) },
4969         { USB_DEVICE_WACOM(0x5E) },
4970         { USB_DEVICE_WACOM(0x60) },
4971         { USB_DEVICE_WACOM(0x61) },
4972         { USB_DEVICE_WACOM(0x62) },
4973         { USB_DEVICE_WACOM(0x63) },
4974         { USB_DEVICE_WACOM(0x64) },
4975         { USB_DEVICE_WACOM(0x65) },
4976         { USB_DEVICE_WACOM(0x69) },
4977         { USB_DEVICE_WACOM(0x6A) },
4978         { USB_DEVICE_WACOM(0x6B) },
4979         { BT_DEVICE_WACOM(0x81) },
4980         { USB_DEVICE_WACOM(0x84) },
4981         { USB_DEVICE_WACOM(0x90) },
4982         { USB_DEVICE_WACOM(0x93) },
4983         { USB_DEVICE_WACOM(0x94) },
4984         { USB_DEVICE_WACOM(0x97) },
4985         { USB_DEVICE_WACOM(0x9A) },
4986         { USB_DEVICE_WACOM(0x9F) },
4987         { USB_DEVICE_WACOM(0xB0) },
4988         { USB_DEVICE_WACOM(0xB1) },
4989         { USB_DEVICE_WACOM(0xB2) },
4990         { USB_DEVICE_WACOM(0xB3) },
4991         { USB_DEVICE_WACOM(0xB4) },
4992         { USB_DEVICE_WACOM(0xB5) },
4993         { USB_DEVICE_WACOM(0xB7) },
4994         { USB_DEVICE_WACOM(0xB8) },
4995         { USB_DEVICE_WACOM(0xB9) },
4996         { USB_DEVICE_WACOM(0xBA) },
4997         { USB_DEVICE_WACOM(0xBB) },
4998         { USB_DEVICE_WACOM(0xBC) },
4999         { BT_DEVICE_WACOM(0xBD) },
5000         { USB_DEVICE_WACOM(0xC0) },
5001         { USB_DEVICE_WACOM(0xC2) },
5002         { USB_DEVICE_WACOM(0xC4) },
5003         { USB_DEVICE_WACOM(0xC5) },
5004         { USB_DEVICE_WACOM(0xC6) },
5005         { USB_DEVICE_WACOM(0xC7) },
5006         { USB_DEVICE_WACOM(0xCC) },
5007         { USB_DEVICE_WACOM(0xCE) },
5008         { USB_DEVICE_WACOM(0xD0) },
5009         { USB_DEVICE_WACOM(0xD1) },
5010         { USB_DEVICE_WACOM(0xD2) },
5011         { USB_DEVICE_WACOM(0xD3) },
5012         { USB_DEVICE_WACOM(0xD4) },
5013         { USB_DEVICE_WACOM(0xD5) },
5014         { USB_DEVICE_WACOM(0xD6) },
5015         { USB_DEVICE_WACOM(0xD7) },
5016         { USB_DEVICE_WACOM(0xD8) },
5017         { USB_DEVICE_WACOM(0xDA) },
5018         { USB_DEVICE_WACOM(0xDB) },
5019         { USB_DEVICE_WACOM(0xDD) },
5020         { USB_DEVICE_WACOM(0xDE) },
5021         { USB_DEVICE_WACOM(0xDF) },
5022         { USB_DEVICE_WACOM(0xE2) },
5023         { USB_DEVICE_WACOM(0xE3) },
5024         { USB_DEVICE_WACOM(0xE5) },
5025         { USB_DEVICE_WACOM(0xE6) },
5026         { USB_DEVICE_WACOM(0xEC) },
5027         { USB_DEVICE_WACOM(0xED) },
5028         { USB_DEVICE_WACOM(0xEF) },
5029         { USB_DEVICE_WACOM(0xF0) },
5030         { USB_DEVICE_WACOM(0xF4) },
5031         { USB_DEVICE_WACOM(0xF6) },
5032         { USB_DEVICE_WACOM(0xF8) },
5033         { USB_DEVICE_WACOM(0xFA) },
5034         { USB_DEVICE_WACOM(0xFB) },
5035         { USB_DEVICE_WACOM(0x100) },
5036         { USB_DEVICE_WACOM(0x101) },
5037         { USB_DEVICE_WACOM(0x10D) },
5038         { USB_DEVICE_WACOM(0x10E) },
5039         { USB_DEVICE_WACOM(0x10F) },
5040         { USB_DEVICE_WACOM(0x116) },
5041         { USB_DEVICE_WACOM(0x12C) },
5042         { USB_DEVICE_WACOM(0x300) },
5043         { USB_DEVICE_WACOM(0x301) },
5044         { USB_DEVICE_WACOM(0x302) },
5045         { USB_DEVICE_WACOM(0x303) },
5046         { USB_DEVICE_WACOM(0x304) },
5047         { USB_DEVICE_WACOM(0x307) },
5048         { USB_DEVICE_WACOM(0x309) },
5049         { USB_DEVICE_WACOM(0x30A) },
5050         { USB_DEVICE_WACOM(0x30C) },
5051         { USB_DEVICE_WACOM(0x30E) },
5052         { USB_DEVICE_WACOM(0x314) },
5053         { USB_DEVICE_WACOM(0x315) },
5054         { USB_DEVICE_WACOM(0x317) },
5055         { USB_DEVICE_WACOM(0x318) },
5056         { USB_DEVICE_WACOM(0x319) },
5057         { USB_DEVICE_WACOM(0x323) },
5058         { USB_DEVICE_WACOM(0x325) },
5059         { USB_DEVICE_WACOM(0x326) },
5060         { USB_DEVICE_WACOM(0x32A) },
5061         { USB_DEVICE_WACOM(0x32B) },
5062         { USB_DEVICE_WACOM(0x32C) },
5063         { USB_DEVICE_WACOM(0x32F) },
5064         { USB_DEVICE_WACOM(0x331) },
5065         { USB_DEVICE_WACOM(0x333) },
5066         { USB_DEVICE_WACOM(0x335) },
5067         { USB_DEVICE_WACOM(0x336) },
5068         { USB_DEVICE_WACOM(0x33B) },
5069         { USB_DEVICE_WACOM(0x33C) },
5070         { USB_DEVICE_WACOM(0x33D) },
5071         { USB_DEVICE_WACOM(0x33E) },
5072         { USB_DEVICE_WACOM(0x343) },
5073         { BT_DEVICE_WACOM(0x360) },
5074         { BT_DEVICE_WACOM(0x361) },
5075         { BT_DEVICE_WACOM(0x377) },
5076         { BT_DEVICE_WACOM(0x379) },
5077         { USB_DEVICE_WACOM(0x37A) },
5078         { USB_DEVICE_WACOM(0x37B) },
5079         { BT_DEVICE_WACOM(0x393) },
5080         { BT_DEVICE_WACOM(0x3c6) },
5081         { BT_DEVICE_WACOM(0x3c8) },
5082         { BT_DEVICE_WACOM(0x3dd) },
5083         { USB_DEVICE_WACOM(0x4001) },
5084         { USB_DEVICE_WACOM(0x4004) },
5085         { USB_DEVICE_WACOM(0x5000) },
5086         { USB_DEVICE_WACOM(0x5002) },
5087         { USB_DEVICE_LENOVO(0x6004) },
5088
5089         { USB_DEVICE_WACOM(HID_ANY_ID) },
5090         { I2C_DEVICE_WACOM(HID_ANY_ID) },
5091         { BT_DEVICE_WACOM(HID_ANY_ID) },
5092         { }
5093 };
5094 MODULE_DEVICE_TABLE(hid, wacom_ids);