SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/input/tablet/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
  18 static int wacom_penpartner_irq(struct wacom_wac *wacom, void *wcombo)
  19 {
  20         unsigned char *data = wacom->data;
  21
  22         switch (data[0]) {
  23         case 1:
  24                 if (data[5] & 0x80) {
  25                         wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  26                         wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
  27                         wacom_report_key(wcombo, wacom->tool[0], 1);
  28                         wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
  29                         wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
  30                         wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
  31                         wacom_report_abs(wcombo, ABS_PRESSURE, (signed char)data[6] + 127);
  32                         wacom_report_key(wcombo, BTN_TOUCH, ((signed char)data[6] > -127));
  33                         wacom_report_key(wcombo, BTN_STYLUS, (data[5] & 0x40));
  34                 } else {
  35                         wacom_report_key(wcombo, wacom->tool[0], 0);
  36                         wacom_report_abs(wcombo, ABS_MISC, 0); /* report tool id */
  37                         wacom_report_abs(wcombo, ABS_PRESSURE, -1);
  38                         wacom_report_key(wcombo, BTN_TOUCH, 0);
  39                 }
  40                 break;
  41         case 2:
  42                 wacom_report_key(wcombo, BTN_TOOL_PEN, 1);
  43                 wacom_report_abs(wcombo, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
  44                 wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
  45                 wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
  46                 wacom_report_abs(wcombo, ABS_PRESSURE, (signed char)data[6] + 127);
  47                 wacom_report_key(wcombo, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
  48                 wacom_report_key(wcombo, BTN_STYLUS, (data[5] & 0x40));
  49                 break;
  50         default:
  51                 printk(KERN_INFO "wacom_penpartner_irq: received unknown report #%d\n", data[0]);
  52                 return 0;
  53         }
  54         return 1;
  55 }
  56
  57 static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
  58 {
  59         struct wacom_features *features = &wacom->features;
  60         unsigned char *data = wacom->data;
  61         int prox, pressure;
  62
  63         if (data[0] != WACOM_REPORT_PENABLED) {
  64                 dbg("wacom_pl_irq: received unknown report #%d", data[0]);
  65                 return 0;
  66         }
  67
  68         prox = data[1] & 0x40;
  69
  70         if (prox) {
  71                 wacom->id[0] = ERASER_DEVICE_ID;
  72                 pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
  73                 if (features->pressure_max > 255)
  74                         pressure = (pressure << 1) | ((data[4] >> 6) & 1);
  75                 pressure += (features->pressure_max + 1) / 2;
  76
  77                 /*
  78                  * if going from out of proximity into proximity select between the eraser
  79                  * and the pen based on the state of the stylus2 button, choose eraser if
  80                  * pressed else choose pen. if not a proximity change from out to in, send
  81                  * an out of proximity for previous tool then a in for new tool.
  82                  */
  83                 if (!wacom->tool[0]) {
  84                         /* Eraser bit set for DTF */
  85                         if (data[1] & 0x10)
  86                                 wacom->tool[1] = BTN_TOOL_RUBBER;
  87                         else
  88                                 /* Going into proximity select tool */
  89                                 wacom->tool[1] = (data[4] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  90                 } else {
  91                         /* was entered with stylus2 pressed */
  92                         if (wacom->tool[1] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
  93                                 /* report out proximity for previous tool */
  94                                 wacom_report_key(wcombo, wacom->tool[1], 0);
  95                                 wacom_input_sync(wcombo);
  96                                 wacom->tool[1] = BTN_TOOL_PEN;
  97                                 return 0;
  98                         }
  99                 }
 100                 if (wacom->tool[1] != BTN_TOOL_RUBBER) {
 101                         /* Unknown tool selected default to pen tool */
 102                         wacom->tool[1] = BTN_TOOL_PEN;
 103                         wacom->id[0] = STYLUS_DEVICE_ID;
 104                 }
 105                 wacom_report_key(wcombo, wacom->tool[1], prox); /* report in proximity for tool */
 106                 wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
 107                 wacom_report_abs(wcombo, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
 108                 wacom_report_abs(wcombo, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
 109                 wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
 110
 111                 wacom_report_key(wcombo, BTN_TOUCH, data[4] & 0x08);
 112                 wacom_report_key(wcombo, BTN_STYLUS, data[4] & 0x10);
 113                 /* Only allow the stylus2 button to be reported for the pen tool. */
 114                 wacom_report_key(wcombo, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
 115         } else {
 116                 /* report proximity-out of a (valid) tool */
 117                 if (wacom->tool[1] != BTN_TOOL_RUBBER) {
 118                         /* Unknown tool selected default to pen tool */
 119                         wacom->tool[1] = BTN_TOOL_PEN;
 120                 }
 121                 wacom_report_key(wcombo, wacom->tool[1], prox);
 122         }
 123
 124         wacom->tool[0] = prox; /* Save proximity state */
 125         return 1;
 126 }
 127
 128 static int wacom_ptu_irq(struct wacom_wac *wacom, void *wcombo)
 129 {
 130         unsigned char *data = wacom->data;
 131
 132         if (data[0] != WACOM_REPORT_PENABLED) {
 133                 printk(KERN_INFO "wacom_ptu_irq: received unknown report #%d\n", data[0]);
 134                 return 0;
 135         }
 136
 137         if (data[1] & 0x04) {
 138                 wacom_report_key(wcombo, BTN_TOOL_RUBBER, data[1] & 0x20);
 139                 wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x08);
 140                 wacom->id[0] = ERASER_DEVICE_ID;
 141         } else {
 142                 wacom_report_key(wcombo, BTN_TOOL_PEN, data[1] & 0x20);
 143                 wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x01);
 144                 wacom->id[0] = STYLUS_DEVICE_ID;
 145         }
 146         wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
 147         wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
 148         wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
 149         wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));
 150         wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
 151         wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x10);
 152         return 1;
 153 }
 154
 155 static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
 156 {
 157         struct wacom_features *features = &wacom->features;
 158         unsigned char *data = wacom->data;
 159         int x, y, prox;
 160         int rw = 0;
 161         int retval = 0;
 162
 163         if (data[0] != WACOM_REPORT_PENABLED) {
 164                 dbg("wacom_graphire_irq: received unknown report #%d", data[0]);
 165                 goto exit;
 166         }
 167
 168         prox = data[1] & 0x80;
 169         if (prox || wacom->id[0]) {
 170                 if (prox) {
 171                         switch ((data[1] >> 5) & 3) {
 172
 173                         case 0: /* Pen */
 174                                 wacom->tool[0] = BTN_TOOL_PEN;
 175                                 wacom->id[0] = STYLUS_DEVICE_ID;
 176                                 break;
 177
 178                         case 1: /* Rubber */
 179                                 wacom->tool[0] = BTN_TOOL_RUBBER;
 180                                 wacom->id[0] = ERASER_DEVICE_ID;
 181                                 break;
 182
 183                         case 2: /* Mouse with wheel */
 184                                 wacom_report_key(wcombo, BTN_MIDDLE, data[1] & 0x04);
 185                                 /* fall through */
 186
 187                         case 3: /* Mouse without wheel */
 188                                 wacom->tool[0] = BTN_TOOL_MOUSE;
 189                                 wacom->id[0] = CURSOR_DEVICE_ID;
 190                                 break;
 191                         }
 192                 }
 193                 x = wacom_le16_to_cpu(&data[2]);
 194                 y = wacom_le16_to_cpu(&data[4]);
 195                 wacom_report_abs(wcombo, ABS_X, x);
 196                 wacom_report_abs(wcombo, ABS_Y, y);
 197                 if (wacom->tool[0] != BTN_TOOL_MOUSE) {
 198                         wacom_report_abs(wcombo, ABS_PRESSURE, data[6] | ((data[7] & 0x01) << 8));
 199                         wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x01);
 200                         wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
 201                         wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x04);
 202                 } else {
 203                         wacom_report_key(wcombo, BTN_LEFT, data[1] & 0x01);
 204                         wacom_report_key(wcombo, BTN_RIGHT, data[1] & 0x02);
 205                         if (features->type == WACOM_G4 ||
 206                                         features->type == WACOM_MO) {
 207                                 wacom_report_abs(wcombo, ABS_DISTANCE, data[6] & 0x3f);
 208                                 rw = (signed)(data[7] & 0x04) - (data[7] & 0x03);
 209                         } else {
 210                                 wacom_report_abs(wcombo, ABS_DISTANCE, data[7] & 0x3f);
 211                                 rw = -(signed)data[6];
 212                         }
 213                         wacom_report_rel(wcombo, REL_WHEEL, rw);
 214                 }
 215
 216                 if (!prox)
 217                         wacom->id[0] = 0;
 218                 wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
 219                 wacom_report_key(wcombo, wacom->tool[0], prox);
 220                 wacom_input_sync(wcombo); /* sync last event */
 221         }
 222
 223         /* send pad data */
 224         switch (features->type) {
 225         case WACOM_G4:
 226                 prox = data[7] & 0xf8;
 227                 if (prox || wacom->id[1]) {
 228                         wacom->id[1] = PAD_DEVICE_ID;
 229                         wacom_report_key(wcombo, BTN_0, (data[7] & 0x40));
 230                         wacom_report_key(wcombo, BTN_4, (data[7] & 0x80));
 231                         rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
 232                         wacom_report_rel(wcombo, REL_WHEEL, rw);
 233                         wacom_report_key(wcombo, BTN_TOOL_FINGER, 0xf0);
 234                         wacom_report_abs(wcombo, ABS_MISC, wacom->id[1]);
 235                         if (!prox)
 236                                 wacom->id[1] = 0;
 237                         wacom_report_abs(wcombo, ABS_MISC, wacom->id[1]);
 238                         wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
 239                 }
 240                 retval = 1;
 241                 break;
 242
 243         case WACOM_MO:
 244                 prox = (data[7] & 0xf8) || data[8];
 245                 if (prox || wacom->id[1]) {
 246                         wacom->id[1] = PAD_DEVICE_ID;
 247                         wacom_report_key(wcombo, BTN_0, (data[7] & 0x08));
 248                         wacom_report_key(wcombo, BTN_1, (data[7] & 0x20));
 249                         wacom_report_key(wcombo, BTN_4, (data[7] & 0x10));
 250                         wacom_report_key(wcombo, BTN_5, (data[7] & 0x40));
 251                         wacom_report_abs(wcombo, ABS_WHEEL, (data[8] & 0x7f));
 252                         wacom_report_key(wcombo, BTN_TOOL_FINGER, 0xf0);
 253                         if (!prox)
 254                                 wacom->id[1] = 0;
 255                         wacom_report_abs(wcombo, ABS_MISC, wacom->id[1]);
 256                         wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
 257                 }
 258                 retval = 1;
 259                 break;
 260         }
 261 exit:
 262         return retval;
 263 }
 264
 265 static int wacom_intuos_inout(struct wacom_wac *wacom, void *wcombo)
 266 {
 267         struct wacom_features *features = &wacom->features;
 268         unsigned char *data = wacom->data;
 269         int idx = 0;
 270
 271         /* tool number */
 272         if (features->type == INTUOS)
 273                 idx = data[1] & 0x01;
 274
 275         /* Enter report */
 276         if ((data[1] & 0xfc) == 0xc0) {
 277                 /* serial number of the tool */
 278                 wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
 279                         (data[4] << 20) + (data[5] << 12) +
 280                         (data[6] << 4) + (data[7] >> 4);
 281
 282                 wacom->id[idx] = (data[2] << 4) | (data[3] >> 4);
 283
 284                 switch (wacom->id[idx]) {
 285                 case 0x812: /* Inking pen */
 286                 case 0x801: /* Intuos3 Inking pen */
 287                 case 0x20802: /* Intuos4 Classic Pen */
 288                 case 0x012:
 289                         wacom->tool[idx] = BTN_TOOL_PENCIL;
 290                         break;
 291
 292                 case 0x822: /* Pen */
 293                 case 0x842:
 294                 case 0x852:
 295                 case 0x823: /* Intuos3 Grip Pen */
 296                 case 0x813: /* Intuos3 Classic Pen */
 297                 case 0x885: /* Intuos3 Marker Pen */
 298                 case 0x802: /* Intuos4 Grip Pen Eraser */
 299                 case 0x804: /* Intuos4 Marker Pen */
 300                 case 0x40802: /* Intuos4 Classic Pen */
 301                 case 0x022:
 302                         wacom->tool[idx] = BTN_TOOL_PEN;
 303                         break;
 304
 305                 case 0x832: /* Stroke pen */
 306                 case 0x032:
 307                         wacom->tool[idx] = BTN_TOOL_BRUSH;
 308                         break;
 309
 310                 case 0x007: /* Mouse 4D and 2D */
 311                 case 0x09c:
 312                 case 0x094:
 313                 case 0x017: /* Intuos3 2D Mouse */
 314                 case 0x806: /* Intuos4 Mouse */
 315                         wacom->tool[idx] = BTN_TOOL_MOUSE;
 316                         break;
 317
 318                 case 0x096: /* Lens cursor */
 319                 case 0x097: /* Intuos3 Lens cursor */
 320                 case 0x006: /* Intuos4 Lens cursor */
 321                         wacom->tool[idx] = BTN_TOOL_LENS;
 322                         break;
 323
 324                 case 0x82a: /* Eraser */
 325                 case 0x85a:
 326                 case 0x91a:
 327                 case 0xd1a:
 328                 case 0x0fa:
 329                 case 0x82b: /* Intuos3 Grip Pen Eraser */
 330                 case 0x81b: /* Intuos3 Classic Pen Eraser */
 331                 case 0x91b: /* Intuos3 Airbrush Eraser */
 332                 case 0x80c: /* Intuos4 Marker Pen Eraser */
 333                 case 0x80a: /* Intuos4 Grip Pen Eraser */
 334                 case 0x4080a: /* Intuos4 Classic Pen Eraser */
 335                 case 0x90a: /* Intuos4 Airbrush Eraser */
 336                         wacom->tool[idx] = BTN_TOOL_RUBBER;
 337                         break;
 338
 339                 case 0xd12:
 340                 case 0x912:
 341                 case 0x112:
 342                 case 0x913: /* Intuos3 Airbrush */
 343                 case 0x902: /* Intuos4 Airbrush */
 344                         wacom->tool[idx] = BTN_TOOL_AIRBRUSH;
 345                         break;
 346
 347                 default: /* Unknown tool */
 348                         wacom->tool[idx] = BTN_TOOL_PEN;
 349                         break;
 350                 }
 351                 return 1;
 352         }
 353
 354         /* Exit report */
 355         if ((data[1] & 0xfe) == 0x80) {
 356                 /*
 357                  * Reset all states otherwise we lose the initial states
 358                  * when in-prox next time
 359                  */
 360                 wacom_report_abs(wcombo, ABS_X, 0);
 361                 wacom_report_abs(wcombo, ABS_Y, 0);
 362                 wacom_report_abs(wcombo, ABS_DISTANCE, 0);
 363                 wacom_report_abs(wcombo, ABS_TILT_X, 0);
 364                 wacom_report_abs(wcombo, ABS_TILT_Y, 0);
 365                 if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
 366                         wacom_report_key(wcombo, BTN_LEFT, 0);
 367                         wacom_report_key(wcombo, BTN_MIDDLE, 0);
 368                         wacom_report_key(wcombo, BTN_RIGHT, 0);
 369                         wacom_report_key(wcombo, BTN_SIDE, 0);
 370                         wacom_report_key(wcombo, BTN_EXTRA, 0);
 371                         wacom_report_abs(wcombo, ABS_THROTTLE, 0);
 372                         wacom_report_abs(wcombo, ABS_RZ, 0);
 373                 } else {
 374                         wacom_report_abs(wcombo, ABS_PRESSURE, 0);
 375                         wacom_report_key(wcombo, BTN_STYLUS, 0);
 376                         wacom_report_key(wcombo, BTN_STYLUS2, 0);
 377                         wacom_report_key(wcombo, BTN_TOUCH, 0);
 378                         wacom_report_abs(wcombo, ABS_WHEEL, 0);
 379                         if (features->type >= INTUOS3S)
 380                                 wacom_report_abs(wcombo, ABS_Z, 0);
 381                 }
 382                 wacom_report_key(wcombo, wacom->tool[idx], 0);
 383                 wacom_report_abs(wcombo, ABS_MISC, 0); /* reset tool id */
 384                 wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
 385                 wacom->id[idx] = 0;
 386                 return 2;
 387         }
 388         return 0;
 389 }
 390
 391 static void wacom_intuos_general(struct wacom_wac *wacom, void *wcombo)
 392 {
 393         struct wacom_features *features = &wacom->features;
 394         unsigned char *data = wacom->data;
 395         unsigned int t;
 396
 397         /* general pen packet */
 398         if ((data[1] & 0xb8) == 0xa0) {
 399                 t = (data[6] << 2) | ((data[7] >> 6) & 3);
 400                 if (features->type >= INTUOS4S && features->type <= INTUOS4L)
 401                         t = (t << 1) | (data[1] & 1);
 402                 wacom_report_abs(wcombo, ABS_PRESSURE, t);
 403                 wacom_report_abs(wcombo, ABS_TILT_X,
 404                                 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
 405                 wacom_report_abs(wcombo, ABS_TILT_Y, data[8] & 0x7f);
 406                 wacom_report_key(wcombo, BTN_STYLUS, data[1] & 2);
 407                 wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 4);
 408                 wacom_report_key(wcombo, BTN_TOUCH, t > 10);
 409         }
 410
 411         /* airbrush second packet */
 412         if ((data[1] & 0xbc) == 0xb4) {
 413                 wacom_report_abs(wcombo, ABS_WHEEL,
 414                                 (data[6] << 2) | ((data[7] >> 6) & 3));
 415                 wacom_report_abs(wcombo, ABS_TILT_X,
 416                                 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
 417                 wacom_report_abs(wcombo, ABS_TILT_Y, data[8] & 0x7f);
 418         }
 419 }
 420
 421 static int wacom_intuos_irq(struct wacom_wac *wacom, void *wcombo)
 422 {
 423         struct wacom_features *features = &wacom->features;
 424         unsigned char *data = wacom->data;
 425         unsigned int t;
 426         int idx = 0, result;
 427
 428         if (data[0] != WACOM_REPORT_PENABLED && data[0] != WACOM_REPORT_INTUOSREAD
 429                 && data[0] != WACOM_REPORT_INTUOSWRITE && data[0] != WACOM_REPORT_INTUOSPAD) {
 430                 dbg("wacom_intuos_irq: received unknown report #%d", data[0]);
 431                 return 0;
 432         }
 433
 434         /* tool number */
 435         if (features->type == INTUOS)
 436                 idx = data[1] & 0x01;
 437
 438         /* pad packets. Works as a second tool and is always in prox */
 439         if (data[0] == WACOM_REPORT_INTUOSPAD) {
 440                 /* initiate the pad as a device */
 441                 if (wacom->tool[1] != BTN_TOOL_FINGER)
 442                         wacom->tool[1] = BTN_TOOL_FINGER;
 443
 444                 if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
 445                         wacom_report_key(wcombo, BTN_0, (data[2] & 0x01));
 446                         wacom_report_key(wcombo, BTN_1, (data[3] & 0x01));
 447                         wacom_report_key(wcombo, BTN_2, (data[3] & 0x02));
 448                         wacom_report_key(wcombo, BTN_3, (data[3] & 0x04));
 449                         wacom_report_key(wcombo, BTN_4, (data[3] & 0x08));
 450                         wacom_report_key(wcombo, BTN_5, (data[3] & 0x10));
 451                         wacom_report_key(wcombo, BTN_6, (data[3] & 0x20));
 452                         if (data[1] & 0x80) {
 453                                 wacom_report_abs(wcombo, ABS_WHEEL, (data[1] & 0x7f));
 454                         } else {
 455                                 /* Out of proximity, clear wheel value. */
 456                                 wacom_report_abs(wcombo, ABS_WHEEL, 0);
 457                         }
 458                         if (features->type != INTUOS4S) {
 459                                 wacom_report_key(wcombo, BTN_7, (data[3] & 0x40));
 460                                 wacom_report_key(wcombo, BTN_8, (data[3] & 0x80));
 461                         }
 462                         if (data[1] | (data[2] & 0x01) | data[3]) {
 463                                 wacom_report_key(wcombo, wacom->tool[1], 1);
 464                                 wacom_report_abs(wcombo, ABS_MISC, PAD_DEVICE_ID);
 465                         } else {
 466                                 wacom_report_key(wcombo, wacom->tool[1], 0);
 467                                 wacom_report_abs(wcombo, ABS_MISC, 0);
 468                         }
 469                 } else {
 470                         wacom_report_key(wcombo, BTN_0, (data[5] & 0x01));
 471                         wacom_report_key(wcombo, BTN_1, (data[5] & 0x02));
 472                         wacom_report_key(wcombo, BTN_2, (data[5] & 0x04));
 473                         wacom_report_key(wcombo, BTN_3, (data[5] & 0x08));
 474                         wacom_report_key(wcombo, BTN_4, (data[6] & 0x01));
 475                         wacom_report_key(wcombo, BTN_5, (data[6] & 0x02));
 476                         wacom_report_key(wcombo, BTN_6, (data[6] & 0x04));
 477                         wacom_report_key(wcombo, BTN_7, (data[6] & 0x08));
 478                         wacom_report_key(wcombo, BTN_8, (data[5] & 0x10));
 479                         wacom_report_key(wcombo, BTN_9, (data[6] & 0x10));
 480                         wacom_report_abs(wcombo, ABS_RX, ((data[1] & 0x1f) << 8) | data[2]);
 481                         wacom_report_abs(wcombo, ABS_RY, ((data[3] & 0x1f) << 8) | data[4]);
 482
 483                         if ((data[5] & 0x1f) | (data[6] & 0x1f) | (data[1] & 0x1f) |
 484                                 data[2] | (data[3] & 0x1f) | data[4]) {
 485                                 wacom_report_key(wcombo, wacom->tool[1], 1);
 486                                 wacom_report_abs(wcombo, ABS_MISC, PAD_DEVICE_ID);
 487                         } else {
 488                                 wacom_report_key(wcombo, wacom->tool[1], 0);
 489                                 wacom_report_abs(wcombo, ABS_MISC, 0);
 490                         }
 491                 }
 492                 wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xffffffff);
 493                 return 1;
 494         }
 495
 496         /* process in/out prox events */
 497         result = wacom_intuos_inout(wacom, wcombo);
 498         if (result)
 499                 return result - 1;
 500
 501         /* don't proceed if we don't know the ID */
 502         if (!wacom->id[idx])
 503                 return 0;
 504
 505         /* Only large Intuos support Lense Cursor */
 506         if (wacom->tool[idx] == BTN_TOOL_LENS &&
 507             (features->type == INTUOS3 ||
 508              features->type == INTUOS3S ||
 509              features->type == INTUOS4 ||
 510              features->type == INTUOS4S)) {
 511
 512                 return 0;
 513         }
 514
 515         /* Cintiq doesn't send data when RDY bit isn't set */
 516         if (features->type == CINTIQ && !(data[1] & 0x40))
 517                  return 0;
 518
 519         if (features->type >= INTUOS3S) {
 520                 wacom_report_abs(wcombo, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1));
 521                 wacom_report_abs(wcombo, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1));
 522                 wacom_report_abs(wcombo, ABS_DISTANCE, ((data[9] >> 2) & 0x3f));
 523         } else {
 524                 wacom_report_abs(wcombo, ABS_X, wacom_be16_to_cpu(&data[2]));
 525                 wacom_report_abs(wcombo, ABS_Y, wacom_be16_to_cpu(&data[4]));
 526                 wacom_report_abs(wcombo, ABS_DISTANCE, ((data[9] >> 3) & 0x1f));
 527         }
 528
 529         /* process general packets */
 530         wacom_intuos_general(wacom, wcombo);
 531
 532         /* 4D mouse, 2D mouse, marker pen rotation, tilt mouse, or Lens cursor packets */
 533         if ((data[1] & 0xbc) == 0xa8 || (data[1] & 0xbe) == 0xb0 || (data[1] & 0xbc) == 0xac) {
 534
 535                 if (data[1] & 0x02) {
 536                         /* Rotation packet */
 537                         if (features->type >= INTUOS3S) {
 538                                 /* I3 marker pen rotation */
 539                                 t = (data[6] << 3) | ((data[7] >> 5) & 7);
 540                                 t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
 541                                         ((t-1) / 2 + 450)) : (450 - t / 2) ;
 542                                 wacom_report_abs(wcombo, ABS_Z, t);
 543                         } else {
 544                                 /* 4D mouse rotation packet */
 545                                 t = (data[6] << 3) | ((data[7] >> 5) & 7);
 546                                 wacom_report_abs(wcombo, ABS_RZ, (data[7] & 0x20) ?
 547                                         ((t - 1) / 2) : -t / 2);
 548                         }
 549
 550                 } else if (!(data[1] & 0x10) && features->type < INTUOS3S) {
 551                         /* 4D mouse packet */
 552                         wacom_report_key(wcombo, BTN_LEFT,   data[8] & 0x01);
 553                         wacom_report_key(wcombo, BTN_MIDDLE, data[8] & 0x02);
 554                         wacom_report_key(wcombo, BTN_RIGHT,  data[8] & 0x04);
 555
 556                         wacom_report_key(wcombo, BTN_SIDE,   data[8] & 0x20);
 557                         wacom_report_key(wcombo, BTN_EXTRA,  data[8] & 0x10);
 558                         t = (data[6] << 2) | ((data[7] >> 6) & 3);
 559                         wacom_report_abs(wcombo, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
 560
 561                 } else if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
 562                         /* I4 mouse */
 563                         if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
 564                                 wacom_report_key(wcombo, BTN_LEFT,   data[6] & 0x01);
 565                                 wacom_report_key(wcombo, BTN_MIDDLE, data[6] & 0x02);
 566                                 wacom_report_key(wcombo, BTN_RIGHT,  data[6] & 0x04);
 567                                 wacom_report_rel(wcombo, REL_WHEEL, ((data[7] & 0x80) >> 7)
 568                                                  - ((data[7] & 0x40) >> 6));
 569                                 wacom_report_key(wcombo, BTN_SIDE,   data[6] & 0x08);
 570                                 wacom_report_key(wcombo, BTN_EXTRA,  data[6] & 0x10);
 571
 572                                 wacom_report_abs(wcombo, ABS_TILT_X,
 573                                         ((data[7] << 1) & 0x7e) | (data[8] >> 7));
 574                                 wacom_report_abs(wcombo, ABS_TILT_Y, data[8] & 0x7f);
 575                         } else {
 576                                 /* 2D mouse packet */
 577                                 wacom_report_key(wcombo, BTN_LEFT,   data[8] & 0x04);
 578                                 wacom_report_key(wcombo, BTN_MIDDLE, data[8] & 0x08);
 579                                 wacom_report_key(wcombo, BTN_RIGHT,  data[8] & 0x10);
 580                                 wacom_report_rel(wcombo, REL_WHEEL, (data[8] & 0x01)
 581                                                  - ((data[8] & 0x02) >> 1));
 582
 583                                 /* I3 2D mouse side buttons */
 584                                 if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
 585                                         wacom_report_key(wcombo, BTN_SIDE,   data[8] & 0x40);
 586                                         wacom_report_key(wcombo, BTN_EXTRA,  data[8] & 0x20);
 587                                 }
 588                         }
 589                 } else if ((features->type < INTUOS3S || features->type == INTUOS3L ||
 590                                 features->type == INTUOS4L) &&
 591                            wacom->tool[idx] == BTN_TOOL_LENS) {
 592                         /* Lens cursor packets */
 593                         wacom_report_key(wcombo, BTN_LEFT,   data[8] & 0x01);
 594                         wacom_report_key(wcombo, BTN_MIDDLE, data[8] & 0x02);
 595                         wacom_report_key(wcombo, BTN_RIGHT,  data[8] & 0x04);
 596                         wacom_report_key(wcombo, BTN_SIDE,   data[8] & 0x10);
 597                         wacom_report_key(wcombo, BTN_EXTRA,  data[8] & 0x08);
 598                 }
 599         }
 600
 601         wacom_report_abs(wcombo, ABS_MISC, wacom->id[idx]); /* report tool id */
 602         wacom_report_key(wcombo, wacom->tool[idx], 1);
 603         wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
 604         return 1;
 605 }
 606
 607
 608 static void wacom_tpc_finger_in(struct wacom_wac *wacom, void *wcombo, char *data, int idx)
 609 {
 610         wacom_report_abs(wcombo, ABS_X,
 611                 data[2 + idx * 2] | ((data[3 + idx * 2] & 0x7f) << 8));
 612         wacom_report_abs(wcombo, ABS_Y,
 613                 data[6 + idx * 2] | ((data[7 + idx * 2] & 0x7f) << 8));
 614         wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
 615         wacom_report_key(wcombo, wacom->tool[idx], 1);
 616         if (idx)
 617                 wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
 618         else
 619                 wacom_report_key(wcombo, BTN_TOUCH, 1);
 620 }
 621
 622 static void wacom_tpc_touch_out(struct wacom_wac *wacom, void *wcombo, int idx)
 623 {
 624         wacom_report_abs(wcombo, ABS_X, 0);
 625         wacom_report_abs(wcombo, ABS_Y, 0);
 626         wacom_report_abs(wcombo, ABS_MISC, 0);
 627         wacom_report_key(wcombo, wacom->tool[idx], 0);
 628         if (idx)
 629                 wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
 630         else
 631                 wacom_report_key(wcombo, BTN_TOUCH, 0);
 632         return;
 633 }
 634
 635 static void wacom_tpc_touch_in(struct wacom_wac *wacom, void *wcombo)
 636 {
 637         char *data = wacom->data;
 638         struct urb *urb = ((struct wacom_combo *)wcombo)->urb;
 639         static int firstFinger = 0;
 640         static int secondFinger = 0;
 641
 642         wacom->tool[0] = BTN_TOOL_DOUBLETAP;
 643         wacom->id[0] = TOUCH_DEVICE_ID;
 644         wacom->tool[1] = BTN_TOOL_TRIPLETAP;
 645
 646         if (urb->actual_length != WACOM_PKGLEN_TPC1FG) {
 647
 648                 switch (data[0]) {
 649
 650                 case WACOM_REPORT_TPC1FG:
 651                         wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
 652                         wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
 653                         wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));
 654                         wacom_report_key(wcombo, BTN_TOUCH, wacom_le16_to_cpu(&data[6]));
 655                         wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
 656                         wacom_report_key(wcombo, wacom->tool[0], 1);
 657                         break;
 658
 659                 case WACOM_REPORT_TPC2FG:
 660                         /* keep this byte to send proper out-prox event */
 661                         wacom->id[1] = data[1] & 0x03;
 662
 663                         if (data[1] & 0x01) {
 664                                 wacom_tpc_finger_in(wacom, wcombo, data, 0);
 665                                 firstFinger = 1;
 666                         } else if (firstFinger) {
 667                                 wacom_tpc_touch_out(wacom, wcombo, 0);
 668                         }
 669
 670                         if (data[1] & 0x02) {
 671                                 /* sync first finger data */
 672                                 if (firstFinger)
 673                                         wacom_input_sync(wcombo);
 674
 675                                 wacom_tpc_finger_in(wacom, wcombo, data, 1);
 676                                 secondFinger = 1;
 677                         } else if (secondFinger) {
 678                                 /* sync first finger data */
 679                                 if (firstFinger)
 680                                         wacom_input_sync(wcombo);
 681
 682                                 wacom_tpc_touch_out(wacom, wcombo, 1);
 683                                 secondFinger = 0;
 684                         }
 685                         if (!(data[1] & 0x01))
 686                                 firstFinger = 0;
 687                         break;
 688                 }
 689         } else {
 690                 wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
 691                 wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
 692                 wacom_report_key(wcombo, BTN_TOUCH, 1);
 693                 wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
 694                 wacom_report_key(wcombo, wacom->tool[0], 1);
 695         }
 696 }
 697
 698 static int wacom_tpc_irq(struct wacom_wac *wacom, void *wcombo)
 699 {
 700         struct wacom_features *features = &wacom->features;
 701         char *data = wacom->data;
 702         int prox = 0, pressure, idx = -1;
 703         struct urb *urb = ((struct wacom_combo *)wcombo)->urb;
 704
 705         dbg("wacom_tpc_irq: received report #%d", data[0]);
 706
 707         if (urb->actual_length == WACOM_PKGLEN_TPC1FG || /* single touch */
 708             data[0] == WACOM_REPORT_TPC1FG ||            /* single touch */
 709             data[0] == WACOM_REPORT_TPC2FG) {            /* 2FG touch */
 710                 if (urb->actual_length == WACOM_PKGLEN_TPC1FG) {  /* with touch */
 711                         prox = data[0] & 0x01;
 712                 } else {  /* with capacity */
 713                         if (data[0] == WACOM_REPORT_TPC1FG)
 714                                 /* single touch */
 715                                 prox = data[1] & 0x01;
 716                         else
 717                                 /* 2FG touch data */
 718                                 prox = data[1] & 0x03;
 719                 }
 720
 721                 if (!wacom->shared->stylus_in_proximity) {
 722                         if (prox) {
 723                                 wacom_tpc_touch_in(wacom, wcombo);
 724                         } else {
 725                                 if (data[0] == WACOM_REPORT_TPC2FG) {
 726                                         /* 2FGT out-prox */
 727                                         idx = (wacom->id[1] & 0x01) - 1;
 728                                         if (idx == 0) {
 729                                                 wacom_tpc_touch_out(wacom, wcombo, idx);
 730                                                 /* sync first finger event */
 731                                                 if (wacom->id[1] & 0x02)
 732                                                         wacom_input_sync(wcombo);
 733                                         }
 734                                         idx = (wacom->id[1] & 0x02) - 1;
 735                                         if (idx == 1)
 736                                                 wacom_tpc_touch_out(wacom, wcombo, idx);
 737                                 } else {
 738                                         /* one finger touch */
 739                                         wacom_tpc_touch_out(wacom, wcombo, 0);
 740                                 }
 741                                 wacom->id[0] = 0;
 742                         }
 743                 } else if (wacom->id[0]) { /* force touch out-prox */
 744                         wacom_tpc_touch_out(wacom, wcombo, 0);
 745                 }
 746                 return 1;
 747         } else if (data[0] == WACOM_REPORT_PENABLED) { /* Penabled */
 748                 prox = data[1] & 0x20;
 749
 750                 if (!wacom->id[0]) { /* first in prox */
 751                         /* Going into proximity select tool */
 752                         wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
 753                         if (wacom->tool[0] == BTN_TOOL_PEN)
 754                                 wacom->id[0] = STYLUS_DEVICE_ID;
 755                         else
 756                                 wacom->id[0] = ERASER_DEVICE_ID;
 757
 758                         wacom->shared->stylus_in_proximity = true;
 759                 }
 760                 wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
 761                 wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x10);
 762                 wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
 763                 wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
 764                 pressure = ((data[7] & 0x01) << 8) | data[6];
 765                 if (pressure < 0)
 766                         pressure = features->pressure_max + pressure + 1;
 767                 wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
 768                 wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x05);
 769                 if (!prox) { /* out-prox */
 770                         wacom->id[0] = 0;
 771                         wacom->shared->stylus_in_proximity = false;
 772                 }
 773                 wacom_report_key(wcombo, wacom->tool[0], prox);
 774                 wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
 775                 return 1;
 776         }
 777         return 0;
 778 }
 779
 780 int wacom_wac_irq(struct wacom_wac *wacom_wac, void *wcombo)
 781 {
 782         switch (wacom_wac->features.type) {
 783         case PENPARTNER:
 784                 return wacom_penpartner_irq(wacom_wac, wcombo);
 785
 786         case PL:
 787                 return wacom_pl_irq(wacom_wac, wcombo);
 788
 789         case WACOM_G4:
 790         case GRAPHIRE:
 791         case WACOM_MO:
 792                 return wacom_graphire_irq(wacom_wac, wcombo);
 793
 794         case PTU:
 795                 return wacom_ptu_irq(wacom_wac, wcombo);
 796
 797         case INTUOS:
 798         case INTUOS3S:
 799         case INTUOS3:
 800         case INTUOS3L:
 801         case INTUOS4S:
 802         case INTUOS4:
 803         case INTUOS4L:
 804         case CINTIQ:
 805         case WACOM_BEE:
 806                 return wacom_intuos_irq(wacom_wac, wcombo);
 807
 808         case TABLETPC:
 809         case TABLETPC2FG:
 810                 return wacom_tpc_irq(wacom_wac, wcombo);
 811
 812         default:
 813                 return 0;
 814         }
 815         return 0;
 816 }
 817
 818 void wacom_init_input_dev(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
 819 {
 820         switch (wacom_wac->features.type) {
 821         case WACOM_MO:
 822                 input_dev_mo(input_dev, wacom_wac);
 823
 824         case WACOM_G4:
 825                 input_dev_g4(input_dev, wacom_wac);
 826                 /* fall through */
 827
 828         case GRAPHIRE:
 829                 input_dev_g(input_dev, wacom_wac);
 830                 break;
 831
 832         case WACOM_BEE:
 833                 input_dev_bee(input_dev, wacom_wac);
 834
 835         case INTUOS3:
 836         case INTUOS3L:
 837         case CINTIQ:
 838                 input_dev_i3(input_dev, wacom_wac);
 839                 /* fall through */
 840
 841         case INTUOS3S:
 842                 input_dev_i3s(input_dev, wacom_wac);
 843                 /* fall through */
 844
 845         case INTUOS:
 846                 input_dev_i(input_dev, wacom_wac);
 847                 break;
 848
 849         case INTUOS4:
 850         case INTUOS4L:
 851                 input_dev_i4(input_dev, wacom_wac);
 852                 /* fall through */
 853
 854         case INTUOS4S:
 855                 input_dev_i4s(input_dev, wacom_wac);
 856                 input_dev_i(input_dev, wacom_wac);
 857                 break;
 858
 859         case TABLETPC2FG:
 860                 input_dev_tpc2fg(input_dev, wacom_wac);
 861                 /* fall through */
 862
 863         case TABLETPC:
 864                 input_dev_tpc(input_dev, wacom_wac);
 865                 if (wacom_wac->features.device_type != BTN_TOOL_PEN)
 866                         break;  /* no need to process stylus stuff */
 867                 /* fall through */
 868
 869         case PL:
 870         case PTU:
 871                 input_dev_pl(input_dev, wacom_wac);
 872                 /* fall through */
 873
 874         case PENPARTNER:
 875                 input_dev_pt(input_dev, wacom_wac);
 876                 break;
 877         }
 878 }
 879
 880 static const struct wacom_features wacom_features_0x00 =
 881         { "Wacom Penpartner",     WACOM_PKGLEN_PENPRTN,    5040,  3780,  255,  0, PENPARTNER };
 882 static const struct wacom_features wacom_features_0x10 =
 883         { "Wacom Graphire",       WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511, 63, GRAPHIRE };
 884 static const struct wacom_features wacom_features_0x11 =
 885         { "Wacom Graphire2 4x5",  WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511, 63, GRAPHIRE };
 886 static const struct wacom_features wacom_features_0x12 =
 887         { "Wacom Graphire2 5x7",  WACOM_PKGLEN_GRAPHIRE,  13918, 10206,  511, 63, GRAPHIRE };
 888 static const struct wacom_features wacom_features_0x13 =
 889         { "Wacom Graphire3",      WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511, 63, GRAPHIRE };
 890 static const struct wacom_features wacom_features_0x14 =
 891         { "Wacom Graphire3 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, GRAPHIRE };
 892 static const struct wacom_features wacom_features_0x15 =
 893         { "Wacom Graphire4 4x5",  WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511, 63, WACOM_G4 };
 894 static const struct wacom_features wacom_features_0x16 =
 895         { "Wacom Graphire4 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, WACOM_G4 };
 896 static const struct wacom_features wacom_features_0x17 =
 897         { "Wacom BambooFun 4x5",  WACOM_PKGLEN_BBFUN,     14760,  9225,  511, 63, WACOM_MO };
 898 static const struct wacom_features wacom_features_0x18 =
 899         { "Wacom BambooFun 6x8",  WACOM_PKGLEN_BBFUN,     21648, 13530,  511, 63, WACOM_MO };
 900 static const struct wacom_features wacom_features_0x19 =
 901         { "Wacom Bamboo1 Medium", WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, GRAPHIRE };
 902 static const struct wacom_features wacom_features_0x60 =
 903         { "Wacom Volito",         WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
 904 static const struct wacom_features wacom_features_0x61 =
 905         { "Wacom PenStation2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  255, 63, GRAPHIRE };
 906 static const struct wacom_features wacom_features_0x62 =
 907         { "Wacom Volito2 4x5",    WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
 908 static const struct wacom_features wacom_features_0x63 =
 909         { "Wacom Volito2 2x3",    WACOM_PKGLEN_GRAPHIRE,   3248,  2320,  511, 63, GRAPHIRE };
 910 static const struct wacom_features wacom_features_0x64 =
 911         { "Wacom PenPartner2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  511, 63, GRAPHIRE };
 912 static const struct wacom_features wacom_features_0x65 =
 913         { "Wacom Bamboo",         WACOM_PKGLEN_BBFUN,     14760,  9225,  511, 63, WACOM_MO };
 914 static const struct wacom_features wacom_features_0x69 =
 915         { "Wacom Bamboo1",        WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
 916 static const struct wacom_features wacom_features_0x20 =
 917         { "Wacom Intuos 4x5",     WACOM_PKGLEN_INTUOS,    12700, 10600, 1023, 31, INTUOS };
 918 static const struct wacom_features wacom_features_0x21 =
 919         { "Wacom Intuos 6x8",     WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
 920 static const struct wacom_features wacom_features_0x22 =
 921         { "Wacom Intuos 9x12",    WACOM_PKGLEN_INTUOS,    30480, 24060, 1023, 31, INTUOS };
 922 static const struct wacom_features wacom_features_0x23 =
 923         { "Wacom Intuos 12x12",   WACOM_PKGLEN_INTUOS,    30480, 31680, 1023, 31, INTUOS };
 924 static const struct wacom_features wacom_features_0x24 =
 925         { "Wacom Intuos 12x18",   WACOM_PKGLEN_INTUOS,    45720, 31680, 1023, 31, INTUOS };
 926 static const struct wacom_features wacom_features_0x30 =
 927         { "Wacom PL400",          WACOM_PKGLEN_GRAPHIRE,   5408,  4056,  255,  0, PL };
 928 static const struct wacom_features wacom_features_0x31 =
 929         { "Wacom PL500",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  255,  0, PL };
 930 static const struct wacom_features wacom_features_0x32 =
 931         { "Wacom PL600",          WACOM_PKGLEN_GRAPHIRE,   6126,  4604,  255,  0, PL };
 932 static const struct wacom_features wacom_features_0x33 =
 933         { "Wacom PL600SX",        WACOM_PKGLEN_GRAPHIRE,   6260,  5016,  255,  0, PL };
 934 static const struct wacom_features wacom_features_0x34 =
 935         { "Wacom PL550",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  511,  0, PL };
 936 static const struct wacom_features wacom_features_0x35 =
 937         { "Wacom PL800",          WACOM_PKGLEN_GRAPHIRE,   7220,  5780,  511,  0, PL };
 938 static const struct wacom_features wacom_features_0x37 =
 939         { "Wacom PL700",          WACOM_PKGLEN_GRAPHIRE,   6758,  5406,  511,  0, PL };
 940 static const struct wacom_features wacom_features_0x38 =
 941         { "Wacom PL510",          WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,  0, PL };
 942 static const struct wacom_features wacom_features_0x39 =
 943         { "Wacom DTU710",         WACOM_PKGLEN_GRAPHIRE,  34080, 27660,  511,  0, PL };
 944 static const struct wacom_features wacom_features_0xC4 =
 945         { "Wacom DTF521",         WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,  0, PL };
 946 static const struct wacom_features wacom_features_0xC0 =
 947         { "Wacom DTF720",         WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,  0, PL };
 948 static const struct wacom_features wacom_features_0xC2 =
 949         { "Wacom DTF720a",        WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,  0, PL };
 950 static const struct wacom_features wacom_features_0x03 =
 951         { "Wacom Cintiq Partner", WACOM_PKGLEN_GRAPHIRE,  20480, 15360,  511,  0, PTU };
 952 static const struct wacom_features wacom_features_0x41 =
 953         { "Wacom Intuos2 4x5",    WACOM_PKGLEN_INTUOS,    12700, 10600, 1023, 31, INTUOS };
 954 static const struct wacom_features wacom_features_0x42 =
 955         { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
 956 static const struct wacom_features wacom_features_0x43 =
 957         { "Wacom Intuos2 9x12",   WACOM_PKGLEN_INTUOS,    30480, 24060, 1023, 31, INTUOS };
 958 static const struct wacom_features wacom_features_0x44 =
 959         { "Wacom Intuos2 12x12",  WACOM_PKGLEN_INTUOS,    30480, 31680, 1023, 31, INTUOS };
 960 static const struct wacom_features wacom_features_0x45 =
 961         { "Wacom Intuos2 12x18",  WACOM_PKGLEN_INTUOS,    45720, 31680, 1023, 31, INTUOS };
 962 static const struct wacom_features wacom_features_0xB0 =
 963         { "Wacom Intuos3 4x5",    WACOM_PKGLEN_INTUOS,    25400, 20320, 1023, 63, INTUOS3S };
 964 static const struct wacom_features wacom_features_0xB1 =
 965         { "Wacom Intuos3 6x8",    WACOM_PKGLEN_INTUOS,    40640, 30480, 1023, 63, INTUOS3 };
 966 static const struct wacom_features wacom_features_0xB2 =
 967         { "Wacom Intuos3 9x12",   WACOM_PKGLEN_INTUOS,    60960, 45720, 1023, 63, INTUOS3 };
 968 static const struct wacom_features wacom_features_0xB3 =
 969         { "Wacom Intuos3 12x12",  WACOM_PKGLEN_INTUOS,    60960, 60960, 1023, 63, INTUOS3L };
 970 static const struct wacom_features wacom_features_0xB4 =
 971         { "Wacom Intuos3 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 1023, 63, INTUOS3L };
 972 static const struct wacom_features wacom_features_0xB5 =
 973         { "Wacom Intuos3 6x11",   WACOM_PKGLEN_INTUOS,    54204, 31750, 1023, 63, INTUOS3 };
 974 static const struct wacom_features wacom_features_0xB7 =
 975         { "Wacom Intuos3 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 1023, 63, INTUOS3S };
 976 static const struct wacom_features wacom_features_0xB8 =
 977         { "Wacom Intuos4 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 2047, 63, INTUOS4S };
 978 static const struct wacom_features wacom_features_0xB9 =
 979         { "Wacom Intuos4 6x9",    WACOM_PKGLEN_INTUOS,    44704, 27940, 2047, 63, INTUOS4 };
 980 static const struct wacom_features wacom_features_0xBA =
 981         { "Wacom Intuos4 8x13",   WACOM_PKGLEN_INTUOS,    65024, 40640, 2047, 63, INTUOS4L };
 982 static const struct wacom_features wacom_features_0xBB =
 983         { "Wacom Intuos4 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 2047, 63, INTUOS4L };
 984 static const struct wacom_features wacom_features_0x3F =
 985         { "Wacom Cintiq 21UX",    WACOM_PKGLEN_INTUOS,    87200, 65600, 1023, 63, CINTIQ };
 986 static const struct wacom_features wacom_features_0xC5 =
 987         { "Wacom Cintiq 20WSX",   WACOM_PKGLEN_INTUOS,    86680, 54180, 1023, 63, WACOM_BEE };
 988 static const struct wacom_features wacom_features_0xC6 =
 989         { "Wacom Cintiq 12WX",    WACOM_PKGLEN_INTUOS,    53020, 33440, 1023, 63, WACOM_BEE };
 990 static const struct wacom_features wacom_features_0xC7 =
 991         { "Wacom DTU1931",        WACOM_PKGLEN_GRAPHIRE,  37832, 30305,  511,  0, PL };
 992 static const struct wacom_features wacom_features_0x90 =
 993         { "Wacom ISDv4 90",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
 994 static const struct wacom_features wacom_features_0x93 =
 995         { "Wacom ISDv4 93",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
 996 static const struct wacom_features wacom_features_0x9A =
 997         { "Wacom ISDv4 9A",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
 998 static const struct wacom_features wacom_features_0x9F =
 999         { "Wacom ISDv4 9F",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
1000 static const struct wacom_features wacom_features_0xE2 =
1001         { "Wacom ISDv4 E2",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,  0, TABLETPC2FG };
1002 static const struct wacom_features wacom_features_0xE3 =
1003         { "Wacom ISDv4 E3",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,  0, TABLETPC2FG };
1004 static const struct wacom_features wacom_features_0x47 =
1005         { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
1006
1007 #define USB_DEVICE_WACOM(prod)                                  \
1008         USB_DEVICE(USB_VENDOR_ID_WACOM, prod),                  \
1009         .driver_info = (kernel_ulong_t)&wacom_features_##prod
1010
1011 const struct usb_device_id wacom_ids[] = {
1012         { USB_DEVICE_WACOM(0x00) },
1013         { USB_DEVICE_WACOM(0x10) },
1014         { USB_DEVICE_WACOM(0x11) },
1015         { USB_DEVICE_WACOM(0x12) },
1016         { USB_DEVICE_WACOM(0x13) },
1017         { USB_DEVICE_WACOM(0x14) },
1018         { USB_DEVICE_WACOM(0x15) },
1019         { USB_DEVICE_WACOM(0x16) },
1020         { USB_DEVICE_WACOM(0x17) },
1021         { USB_DEVICE_WACOM(0x18) },
1022         { USB_DEVICE_WACOM(0x19) },
1023         { USB_DEVICE_WACOM(0x60) },
1024         { USB_DEVICE_WACOM(0x61) },
1025         { USB_DEVICE_WACOM(0x62) },
1026         { USB_DEVICE_WACOM(0x63) },
1027         { USB_DEVICE_WACOM(0x64) },
1028         { USB_DEVICE_WACOM(0x65) },
1029         { USB_DEVICE_WACOM(0x69) },
1030         { USB_DEVICE_WACOM(0x20) },
1031         { USB_DEVICE_WACOM(0x21) },
1032         { USB_DEVICE_WACOM(0x22) },
1033         { USB_DEVICE_WACOM(0x23) },
1034         { USB_DEVICE_WACOM(0x24) },
1035         { USB_DEVICE_WACOM(0x30) },
1036         { USB_DEVICE_WACOM(0x31) },
1037         { USB_DEVICE_WACOM(0x32) },
1038         { USB_DEVICE_WACOM(0x33) },
1039         { USB_DEVICE_WACOM(0x34) },
1040         { USB_DEVICE_WACOM(0x35) },
1041         { USB_DEVICE_WACOM(0x37) },
1042         { USB_DEVICE_WACOM(0x38) },
1043         { USB_DEVICE_WACOM(0x39) },
1044         { USB_DEVICE_WACOM(0xC4) },
1045         { USB_DEVICE_WACOM(0xC0) },
1046         { USB_DEVICE_WACOM(0xC2) },
1047         { USB_DEVICE_WACOM(0x03) },
1048         { USB_DEVICE_WACOM(0x41) },
1049         { USB_DEVICE_WACOM(0x42) },
1050         { USB_DEVICE_WACOM(0x43) },
1051         { USB_DEVICE_WACOM(0x44) },
1052         { USB_DEVICE_WACOM(0x45) },
1053         { USB_DEVICE_WACOM(0xB0) },
1054         { USB_DEVICE_WACOM(0xB1) },
1055         { USB_DEVICE_WACOM(0xB2) },
1056         { USB_DEVICE_WACOM(0xB3) },
1057         { USB_DEVICE_WACOM(0xB4) },
1058         { USB_DEVICE_WACOM(0xB5) },
1059         { USB_DEVICE_WACOM(0xB7) },
1060         { USB_DEVICE_WACOM(0xB8) },
1061         { USB_DEVICE_WACOM(0xB9) },
1062         { USB_DEVICE_WACOM(0xBA) },
1063         { USB_DEVICE_WACOM(0xBB) },
1064         { USB_DEVICE_WACOM(0x3F) },
1065         { USB_DEVICE_WACOM(0xC5) },
1066         { USB_DEVICE_WACOM(0xC6) },
1067         { USB_DEVICE_WACOM(0xC7) },
1068         { USB_DEVICE_WACOM(0x90) },
1069         { USB_DEVICE_WACOM(0x93) },
1070         { USB_DEVICE_WACOM(0x9A) },
1071         { USB_DEVICE_WACOM(0x9F) },
1072         { USB_DEVICE_WACOM(0xE2) },
1073         { USB_DEVICE_WACOM(0xE3) },
1074         { USB_DEVICE_WACOM(0x47) },
1075         { }
1076 };
1077 MODULE_DEVICE_TABLE(usb, wacom_ids);