drivers/hid/wacom_wac.c

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