LXR linux/drivers/input/tablet/wacom

   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#include <linux/hid.h>
  19
  20/* resolution for penabled devices */
  21#define WACOM_PL_RES            20
  22#define WACOM_PENPRTN_RES       40
  23#define WACOM_VOLITO_RES        50
  24#define WACOM_GRAPHIRE_RES      80
  25#define WACOM_INTUOS_RES        100
  26#define WACOM_INTUOS3_RES       200
  27
  28/* Scale factor relating reported contact size to logical contact area.
  29 * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
  30 */
  31#define WACOM_CONTACT_AREA_SCALE 2607
  32
  33static int wacom_penpartner_irq(struct wacom_wac *wacom)
  34{
  35        unsigned char *data = wacom->data;
  36        struct input_dev *input = wacom->input;
  37
  38        switch (data[0]) {
  39        case 1:
  40                if (data[5] & 0x80) {
  41                        wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
  42                        wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
  43                        input_report_key(input, wacom->tool[0], 1);
  44                        input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
  45                        input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
  46                        input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
  47                        input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
  48                        input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
  49                        input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
  50                } else {
  51                        input_report_key(input, wacom->tool[0], 0);
  52                        input_report_abs(input, ABS_MISC, 0); /* report tool id */
  53                        input_report_abs(input, ABS_PRESSURE, -1);
  54                        input_report_key(input, BTN_TOUCH, 0);
  55                }
  56                break;
  57
  58        case 2:
  59                input_report_key(input, BTN_TOOL_PEN, 1);
  60                input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
  61                input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
  62                input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
  63                input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
  64                input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
  65                input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
  66                break;
  67
  68        default:
  69                dev_dbg(input->dev.parent,
  70                        "%s: received unknown report #%d\n", __func__, data[0]);
  71                return 0;
  72        }
  73
  74        return 1;
  75}
  76
  77static int wacom_pl_irq(struct wacom_wac *wacom)
  78{
  79        struct wacom_features *features = &wacom->features;
  80        unsigned char *data = wacom->data;
  81        struct input_dev *input = wacom->input;
  82        int prox, pressure;
  83
  84        if (data[0] != WACOM_REPORT_PENABLED) {
  85                dev_dbg(input->dev.parent,
  86                        "%s: received unknown report #%d\n", __func__, data[0]);
  87                return 0;
  88        }
  89
  90        prox = data[1] & 0x40;
  91
  92        if (prox) {
  93                wacom->id[0] = ERASER_DEVICE_ID;
  94                pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
  95                if (features->pressure_max > 255)
  96                        pressure = (pressure << 1) | ((data[4] >> 6) & 1);
  97                pressure += (features->pressure_max + 1) / 2;
  98
  99                /*
 100                 * if going from out of proximity into proximity select between the eraser
 101                 * and the pen based on the state of the stylus2 button, choose eraser if
 102                 * pressed else choose pen. if not a proximity change from out to in, send
 103                 * an out of proximity for previous tool then a in for new tool.
 104                 */
 105                if (!wacom->tool[0]) {
 106                        /* Eraser bit set for DTF */
 107                        if (data[1] & 0x10)
 108                                wacom->tool[1] = BTN_TOOL_RUBBER;
 109                        else
 110                                /* Going into proximity select tool */
 111                                wacom->tool[1] = (data[4] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
 112                } else {
 113                        /* was entered with stylus2 pressed */
 114                        if (wacom->tool[1] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
 115                                /* report out proximity for previous tool */
 116                                input_report_key(input, wacom->tool[1], 0);
 117                                input_sync(input);
 118                                wacom->tool[1] = BTN_TOOL_PEN;
 119                                return 0;
 120                        }
 121                }
 122                if (wacom->tool[1] != BTN_TOOL_RUBBER) {
 123                        /* Unknown tool selected default to pen tool */
 124                        wacom->tool[1] = BTN_TOOL_PEN;
 125                        wacom->id[0] = STYLUS_DEVICE_ID;
 126                }
 127                input_report_key(input, wacom->tool[1], prox); /* report in proximity for tool */
 128                input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
 129                input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
 130                input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
 131                input_report_abs(input, ABS_PRESSURE, pressure);
 132
 133                input_report_key(input, BTN_TOUCH, data[4] & 0x08);
 134                input_report_key(input, BTN_STYLUS, data[4] & 0x10);
 135                /* Only allow the stylus2 button to be reported for the pen tool. */
 136                input_report_key(input, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
 137        } else {
 138                /* report proximity-out of a (valid) tool */
 139                if (wacom->tool[1] != BTN_TOOL_RUBBER) {
 140                        /* Unknown tool selected default to pen tool */
 141                        wacom->tool[1] = BTN_TOOL_PEN;
 142                }
 143                input_report_key(input, wacom->tool[1], prox);
 144        }
 145
 146        wacom->tool[0] = prox; /* Save proximity state */
 147        return 1;
 148}
 149
 150static int wacom_ptu_irq(struct wacom_wac *wacom)
 151{
 152        unsigned char *data = wacom->data;
 153        struct input_dev *input = wacom->input;
 154
 155        if (data[0] != WACOM_REPORT_PENABLED) {
 156                dev_dbg(input->dev.parent,
 157                        "%s: received unknown report #%d\n", __func__, data[0]);
 158                return 0;
 159        }
 160
 161        if (data[1] & 0x04) {
 162                input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
 163                input_report_key(input, BTN_TOUCH, data[1] & 0x08);
 164                wacom->id[0] = ERASER_DEVICE_ID;
 165        } else {
 166                input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
 167                input_report_key(input, BTN_TOUCH, data[1] & 0x01);
 168                wacom->id[0] = STYLUS_DEVICE_ID;
 169        }
 170        input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
 171        input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 172        input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 173        input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
 174        input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 175        input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
 176        return 1;
 177}
 178
 179static int wacom_dtu_irq(struct wacom_wac *wacom)
 180{
 181        struct wacom_features *features = &wacom->features;
 182        char *data = wacom->data;
 183        struct input_dev *input = wacom->input;
 184        int prox = data[1] & 0x20, pressure;
 185
 186        dev_dbg(input->dev.parent,
 187                "%s: received report #%d", __func__, data[0]);
 188
 189        if (prox) {
 190                /* Going into proximity select tool */
 191                wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
 192                if (wacom->tool[0] == BTN_TOOL_PEN)
 193                        wacom->id[0] = STYLUS_DEVICE_ID;
 194                else
 195                        wacom->id[0] = ERASER_DEVICE_ID;
 196        }
 197        input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 198        input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
 199        input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 200        input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 201        pressure = ((data[7] & 0x01) << 8) | data[6];
 202        if (pressure < 0)
 203                pressure = features->pressure_max + pressure + 1;
 204        input_report_abs(input, ABS_PRESSURE, pressure);
 205        input_report_key(input, BTN_TOUCH, data[1] & 0x05);
 206        if (!prox) /* out-prox */
 207                wacom->id[0] = 0;
 208        input_report_key(input, wacom->tool[0], prox);
 209        input_report_abs(input, ABS_MISC, wacom->id[0]);
 210        return 1;
 211}
 212
 213static int wacom_graphire_irq(struct wacom_wac *wacom)
 214{
 215        struct wacom_features *features = &wacom->features;
 216        unsigned char *data = wacom->data;
 217        struct input_dev *input = wacom->input;
 218        int prox;
 219        int rw = 0;
 220        int retval = 0;
 221
 222        if (data[0] != WACOM_REPORT_PENABLED) {
 223                dev_dbg(input->dev.parent,
 224                        "%s: received unknown report #%d\n", __func__, data[0]);
 225                goto exit;
 226        }
 227
 228        prox = data[1] & 0x80;
 229        if (prox || wacom->id[0]) {
 230                if (prox) {
 231                        switch ((data[1] >> 5) & 3) {
 232
 233                        case 0: /* Pen */
 234                                wacom->tool[0] = BTN_TOOL_PEN;
 235                                wacom->id[0] = STYLUS_DEVICE_ID;
 236                                break;
 237
 238                        case 1: /* Rubber */
 239                                wacom->tool[0] = BTN_TOOL_RUBBER;
 240                                wacom->id[0] = ERASER_DEVICE_ID;
 241                                break;
 242
 243                        case 2: /* Mouse with wheel */
 244                                input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
 245                                /* fall through */
 246
 247                        case 3: /* Mouse without wheel */
 248                                wacom->tool[0] = BTN_TOOL_MOUSE;
 249                                wacom->id[0] = CURSOR_DEVICE_ID;
 250                                break;
 251                        }
 252                }
 253                input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
 254                input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
 255                if (wacom->tool[0] != BTN_TOOL_MOUSE) {
 256                        input_report_abs(input, ABS_PRESSURE, data[6] | ((data[7] & 0x03) << 8));
 257                        input_report_key(input, BTN_TOUCH, data[1] & 0x01);
 258                        input_report_key(input, BTN_STYLUS, data[1] & 0x02);
 259                        input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
 260                } else {
 261                        input_report_key(input, BTN_LEFT, data[1] & 0x01);
 262                        input_report_key(input, BTN_RIGHT, data[1] & 0x02);
 263                        if (features->type == WACOM_G4 ||
 264                                        features->type == WACOM_MO) {
 265                                input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
 266                                rw = (data[7] & 0x04) - (data[7] & 0x03);
 267                        } else {
 268                                input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
 269                                rw = -(signed char)data[6];
 270                        }
 271                        input_report_rel(input, REL_WHEEL, rw);
 272                }
 273
 274                if (!prox)
 275                        wacom->id[0] = 0;
 276                input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
 277                input_report_key(input, wacom->tool[0], prox);
 278                input_event(input, EV_MSC, MSC_SERIAL, 1);
 279                input_sync(input); /* sync last event */
 280        }
 281
 282        /* send pad data */
 283        switch (features->type) {
 284        case WACOM_G4:
 285                prox = data[7] & 0xf8;
 286                if (prox || wacom->id[1]) {
 287                        wacom->id[1] = PAD_DEVICE_ID;
 288                        input_report_key(input, BTN_BACK, (data[7] & 0x40));
 289                        input_report_key(input, BTN_FORWARD, (data[7] & 0x80));
 290                        rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
 291                        input_report_rel(input, REL_WHEEL, rw);
 292                        if (!prox)
 293                                wacom->id[1] = 0;
 294                        input_report_abs(input, ABS_MISC, wacom->id[1]);
 295                        input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
 296                        retval = 1;
 297                }
 298                break;
 299
 300        case WACOM_MO:
 301                prox = (data[7] & 0xf8) || data[8];
 302                if (prox || wacom->id[1]) {
 303                        wacom->id[1] = PAD_DEVICE_ID;
 304                        input_report_key(input, BTN_BACK, (data[7] & 0x08));
 305                        input_report_key(input, BTN_LEFT, (data[7] & 0x20));
 306                        input_report_key(input, BTN_FORWARD, (data[7] & 0x10));
 307                        input_report_key(input, BTN_RIGHT, (data[7] & 0x40));
 308                        input_report_abs(input, ABS_WHEEL, (data[8] & 0x7f));
 309                        if (!prox)
 310                                wacom->id[1] = 0;
 311                        input_report_abs(input, ABS_MISC, wacom->id[1]);
 312                        input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
 313                        retval = 1;
 314                }
 315                break;
 316        }
 317exit:
 318        return retval;
 319}
 320
 321static int wacom_intuos_inout(struct wacom_wac *wacom)
 322{
 323        struct wacom_features *features = &wacom->features;
 324        unsigned char *data = wacom->data;
 325        struct input_dev *input = wacom->input;
 326        int idx = 0;
 327
 328        /* tool number */
 329        if (features->type == INTUOS)
 330                idx = data[1] & 0x01;
 331
 332        /* Enter report */
 333        if ((data[1] & 0xfc) == 0xc0) {
 334                if (features->quirks == WACOM_QUIRK_MULTI_INPUT)
 335                        wacom->shared->stylus_in_proximity = true;
 336
 337                /* serial number of the tool */
 338                wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
 339                        (data[4] << 20) + (data[5] << 12) +
 340                        (data[6] << 4) + (data[7] >> 4);
 341
 342                wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
 343                        ((data[7] & 0x0f) << 20) | ((data[8] & 0xf0) << 12);
 344
 345                switch (wacom->id[idx] & 0xfffff) {
 346                case 0x812: /* Inking pen */
 347                case 0x801: /* Intuos3 Inking pen */
 348                case 0x20802: /* Intuos4 Inking Pen */
 349                case 0x012:
 350                        wacom->tool[idx] = BTN_TOOL_PENCIL;
 351                        break;
 352
 353                case 0x822: /* Pen */
 354                case 0x842:
 355                case 0x852:
 356                case 0x823: /* Intuos3 Grip Pen */
 357                case 0x813: /* Intuos3 Classic Pen */
 358                case 0x885: /* Intuos3 Marker Pen */
 359                case 0x802: /* Intuos4 General Pen */
 360                case 0x804: /* Intuos4 Marker Pen */
 361                case 0x40802: /* Intuos4 Classic Pen */
 362                case 0x022:
 363                        wacom->tool[idx] = BTN_TOOL_PEN;
 364                        break;
 365
 366                case 0x832: /* Stroke pen */
 367                case 0x032:
 368                        wacom->tool[idx] = BTN_TOOL_BRUSH;
 369                        break;
 370
 371                case 0x007: /* Mouse 4D and 2D */
 372                case 0x09c:
 373                case 0x094:
 374                case 0x017: /* Intuos3 2D Mouse */
 375                case 0x806: /* Intuos4 Mouse */
 376                        wacom->tool[idx] = BTN_TOOL_MOUSE;
 377                        break;
 378
 379                case 0x096: /* Lens cursor */
 380                case 0x097: /* Intuos3 Lens cursor */
 381                case 0x006: /* Intuos4 Lens cursor */
 382                        wacom->tool[idx] = BTN_TOOL_LENS;
 383                        break;
 384
 385                case 0x82a: /* Eraser */
 386                case 0x85a:
 387                case 0x91a:
 388                case 0xd1a:
 389                case 0x0fa:
 390                case 0x82b: /* Intuos3 Grip Pen Eraser */
 391                case 0x81b: /* Intuos3 Classic Pen Eraser */
 392                case 0x91b: /* Intuos3 Airbrush Eraser */
 393                case 0x80c: /* Intuos4 Marker Pen Eraser */
 394                case 0x80a: /* Intuos4 General Pen Eraser */
 395                case 0x4080a: /* Intuos4 Classic Pen Eraser */
 396                case 0x90a: /* Intuos4 Airbrush Eraser */
 397                        wacom->tool[idx] = BTN_TOOL_RUBBER;
 398                        break;
 399
 400                case 0xd12:
 401                case 0x912:
 402                case 0x112:
 403                case 0x913: /* Intuos3 Airbrush */
 404                case 0x902: /* Intuos4 Airbrush */
 405                        wacom->tool[idx] = BTN_TOOL_AIRBRUSH;
 406                        break;
 407
 408                default: /* Unknown tool */
 409                        wacom->tool[idx] = BTN_TOOL_PEN;
 410                        break;
 411                }
 412                return 1;
 413        }
 414
 415        /* older I4 styli don't work with new Cintiqs */
 416        if (!((wacom->id[idx] >> 20) & 0x01) &&
 417                        (features->type == WACOM_21UX2))
 418                return 1;
 419
 420        /* Exit report */
 421        if ((data[1] & 0xfe) == 0x80) {
 422                if (features->quirks == WACOM_QUIRK_MULTI_INPUT)
 423                        wacom->shared->stylus_in_proximity = false;
 424
 425                /*
 426                 * Reset all states otherwise we lose the initial states
 427                 * when in-prox next time
 428                 */
 429                input_report_abs(input, ABS_X, 0);
 430                input_report_abs(input, ABS_Y, 0);
 431                input_report_abs(input, ABS_DISTANCE, 0);
 432                input_report_abs(input, ABS_TILT_X, 0);
 433                input_report_abs(input, ABS_TILT_Y, 0);
 434                if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
 435                        input_report_key(input, BTN_LEFT, 0);
 436                        input_report_key(input, BTN_MIDDLE, 0);
 437                        input_report_key(input, BTN_RIGHT, 0);
 438                        input_report_key(input, BTN_SIDE, 0);
 439                        input_report_key(input, BTN_EXTRA, 0);
 440                        input_report_abs(input, ABS_THROTTLE, 0);
 441                        input_report_abs(input, ABS_RZ, 0);
 442                } else {
 443                        input_report_abs(input, ABS_PRESSURE, 0);
 444                        input_report_key(input, BTN_STYLUS, 0);
 445                        input_report_key(input, BTN_STYLUS2, 0);
 446                        input_report_key(input, BTN_TOUCH, 0);
 447                        input_report_abs(input, ABS_WHEEL, 0);
 448                        if (features->type >= INTUOS3S)
 449                                input_report_abs(input, ABS_Z, 0);
 450                }
 451                input_report_key(input, wacom->tool[idx], 0);
 452                input_report_abs(input, ABS_MISC, 0); /* reset tool id */
 453                input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
 454                wacom->id[idx] = 0;
 455                return 2;
 456        }
 457        return 0;
 458}
 459
 460static void wacom_intuos_general(struct wacom_wac *wacom)
 461{
 462        struct wacom_features *features = &wacom->features;
 463        unsigned char *data = wacom->data;
 464        struct input_dev *input = wacom->input;
 465        unsigned int t;
 466
 467        /* general pen packet */
 468        if ((data[1] & 0xb8) == 0xa0) {
 469                t = (data[6] << 2) | ((data[7] >> 6) & 3);
 470                if (features->type >= INTUOS4S && features->type <= WACOM_24HD) {
 471                        t = (t << 1) | (data[1] & 1);
 472                }
 473                input_report_abs(input, ABS_PRESSURE, t);
 474                input_report_abs(input, ABS_TILT_X,
 475                                ((data[7] << 1) & 0x7e) | (data[8] >> 7));
 476                input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
 477                input_report_key(input, BTN_STYLUS, data[1] & 2);
 478                input_report_key(input, BTN_STYLUS2, data[1] & 4);
 479                input_report_key(input, BTN_TOUCH, t > 10);
 480        }
 481
 482        /* airbrush second packet */
 483        if ((data[1] & 0xbc) == 0xb4) {
 484                input_report_abs(input, ABS_WHEEL,
 485                                (data[6] << 2) | ((data[7] >> 6) & 3));
 486                input_report_abs(input, ABS_TILT_X,
 487                                ((data[7] << 1) & 0x7e) | (data[8] >> 7));
 488                input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
 489        }
 490}
 491
 492static int wacom_intuos_irq(struct wacom_wac *wacom)
 493{
 494        struct wacom_features *features = &wacom->features;
 495        unsigned char *data = wacom->data;
 496        struct input_dev *input = wacom->input;
 497        unsigned int t;
 498        int idx = 0, result;
 499
 500        if (data[0] != WACOM_REPORT_PENABLED &&
 501            data[0] != WACOM_REPORT_INTUOSREAD &&
 502            data[0] != WACOM_REPORT_INTUOSWRITE &&
 503            data[0] != WACOM_REPORT_INTUOSPAD &&
 504            data[0] != WACOM_REPORT_INTUOS5PAD) {
 505                dev_dbg(input->dev.parent,
 506                        "%s: received unknown report #%d\n", __func__, data[0]);
 507                return 0;
 508        }
 509
 510        /* tool number */
 511        if (features->type == INTUOS)
 512                idx = data[1] & 0x01;
 513
 514        /* pad packets. Works as a second tool and is always in prox */
 515        if (data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD) {
 516                if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
 517                        input_report_key(input, BTN_0, (data[2] & 0x01));
 518                        input_report_key(input, BTN_1, (data[3] & 0x01));
 519                        input_report_key(input, BTN_2, (data[3] & 0x02));
 520                        input_report_key(input, BTN_3, (data[3] & 0x04));
 521                        input_report_key(input, BTN_4, (data[3] & 0x08));
 522                        input_report_key(input, BTN_5, (data[3] & 0x10));
 523                        input_report_key(input, BTN_6, (data[3] & 0x20));
 524                        if (data[1] & 0x80) {
 525                                input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
 526                        } else {
 527                                /* Out of proximity, clear wheel value. */
 528                                input_report_abs(input, ABS_WHEEL, 0);
 529                        }
 530                        if (features->type != INTUOS4S) {
 531                                input_report_key(input, BTN_7, (data[3] & 0x40));
 532                                input_report_key(input, BTN_8, (data[3] & 0x80));
 533                        }
 534                        if (data[1] | (data[2] & 0x01) | data[3]) {
 535                                input_report_key(input, wacom->tool[1], 1);
 536                                input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
 537                        } else {
 538                                input_report_key(input, wacom->tool[1], 0);
 539                                input_report_abs(input, ABS_MISC, 0);
 540                        }
 541                } else if (features->type == WACOM_24HD) {
 542                        input_report_key(input, BTN_0, (data[6] & 0x01));
 543                        input_report_key(input, BTN_1, (data[6] & 0x02));
 544                        input_report_key(input, BTN_2, (data[6] & 0x04));
 545                        input_report_key(input, BTN_3, (data[6] & 0x08));
 546                        input_report_key(input, BTN_4, (data[6] & 0x10));
 547                        input_report_key(input, BTN_5, (data[6] & 0x20));
 548                        input_report_key(input, BTN_6, (data[6] & 0x40));
 549                        input_report_key(input, BTN_7, (data[6] & 0x80));
 550                        input_report_key(input, BTN_8, (data[8] & 0x01));
 551                        input_report_key(input, BTN_9, (data[8] & 0x02));
 552                        input_report_key(input, BTN_A, (data[8] & 0x04));
 553                        input_report_key(input, BTN_B, (data[8] & 0x08));
 554                        input_report_key(input, BTN_C, (data[8] & 0x10));
 555                        input_report_key(input, BTN_X, (data[8] & 0x20));
 556                        input_report_key(input, BTN_Y, (data[8] & 0x40));
 557                        input_report_key(input, BTN_Z, (data[8] & 0x80));
 558
 559                        /*
 560                         * Three "buttons" are available on the 24HD which are
 561                         * physically implemented as a touchstrip. Each button
 562                         * is approximately 3 bits wide with a 2 bit spacing.
 563                         * The raw touchstrip bits are stored at:
 564                         *    ((data[3] & 0x1f) << 8) | data[4])
 565                         */
 566                        input_report_key(input, KEY_PROG1, data[4] & 0x07);
 567                        input_report_key(input, KEY_PROG2, data[4] & 0xE0);
 568                        input_report_key(input, KEY_PROG3, data[3] & 0x1C);
 569
 570                        if (data[1] & 0x80) {
 571                                input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
 572                        } else {
 573                                /* Out of proximity, clear wheel value. */
 574                                input_report_abs(input, ABS_WHEEL, 0);
 575                        }
 576
 577                        if (data[2] & 0x80) {
 578                                input_report_abs(input, ABS_THROTTLE, (data[2] & 0x7f));
 579                        } else {
 580                                /* Out of proximity, clear second wheel value. */
 581                                input_report_abs(input, ABS_THROTTLE, 0);
 582                        }
 583
 584                        if (data[1] | data[2] | (data[3] & 0x1f) | data[4] | data[6] | data[8]) {
 585                                input_report_key(input, wacom->tool[1], 1);
 586                                input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
 587                        } else {
 588                                input_report_key(input, wacom->tool[1], 0);
 589                                input_report_abs(input, ABS_MISC, 0);
 590                        }
 591                } else if (features->type >= INTUOS5S && features->type <= INTUOS5L) {
 592                        int i;
 593
 594                        /* Touch ring mode switch has no capacitive sensor */
 595                        input_report_key(input, BTN_0, (data[3] & 0x01));
 596
 597                        /*
 598                         * ExpressKeys on Intuos5 have a capacitive sensor in
 599                         * addition to the mechanical switch. Switch data is
 600                         * stored in data[4], capacitive data in data[5].
 601                         */
 602                        for (i = 0; i < 8; i++)
 603                                input_report_key(input, BTN_1 + i, data[4] & (1 << i));
 604
 605                        if (data[2] & 0x80) {
 606                                input_report_abs(input, ABS_WHEEL, (data[2] & 0x7f));
 607                        } else {
 608                                /* Out of proximity, clear wheel value. */
 609                                input_report_abs(input, ABS_WHEEL, 0);
 610                        }
 611
 612                        if (data[2] | (data[3] & 0x01) | data[4] | data[5]) {
 613                                input_report_key(input, wacom->tool[1], 1);
 614                                input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
 615                        } else {
 616                                input_report_key(input, wacom->tool[1], 0);
 617                                input_report_abs(input, ABS_MISC, 0);
 618                        }
 619                } else {
 620                        if (features->type == WACOM_21UX2 || features->type == WACOM_22HD) {
 621                                input_report_key(input, BTN_0, (data[5] & 0x01));
 622                                input_report_key(input, BTN_1, (data[6] & 0x01));
 623                                input_report_key(input, BTN_2, (data[6] & 0x02));
 624                                input_report_key(input, BTN_3, (data[6] & 0x04));
 625                                input_report_key(input, BTN_4, (data[6] & 0x08));
 626                                input_report_key(input, BTN_5, (data[6] & 0x10));
 627                                input_report_key(input, BTN_6, (data[6] & 0x20));
 628                                input_report_key(input, BTN_7, (data[6] & 0x40));
 629                                input_report_key(input, BTN_8, (data[6] & 0x80));
 630                                input_report_key(input, BTN_9, (data[7] & 0x01));
 631                                input_report_key(input, BTN_A, (data[8] & 0x01));
 632                                input_report_key(input, BTN_B, (data[8] & 0x02));
 633                                input_report_key(input, BTN_C, (data[8] & 0x04));
 634                                input_report_key(input, BTN_X, (data[8] & 0x08));
 635                                input_report_key(input, BTN_Y, (data[8] & 0x10));
 636                                input_report_key(input, BTN_Z, (data[8] & 0x20));
 637                                input_report_key(input, BTN_BASE, (data[8] & 0x40));
 638                                input_report_key(input, BTN_BASE2, (data[8] & 0x80));
 639
 640                                if (features->type == WACOM_22HD) {
 641                                        input_report_key(input, KEY_PROG1, data[9] & 0x01);
 642                                        input_report_key(input, KEY_PROG2, data[9] & 0x02);
 643                                        input_report_key(input, KEY_PROG3, data[9] & 0x04);
 644                                }
 645                        } else {
 646                                input_report_key(input, BTN_0, (data[5] & 0x01));
 647                                input_report_key(input, BTN_1, (data[5] & 0x02));
 648                                input_report_key(input, BTN_2, (data[5] & 0x04));
 649                                input_report_key(input, BTN_3, (data[5] & 0x08));
 650                                input_report_key(input, BTN_4, (data[6] & 0x01));
 651                                input_report_key(input, BTN_5, (data[6] & 0x02));
 652                                input_report_key(input, BTN_6, (data[6] & 0x04));
 653                                input_report_key(input, BTN_7, (data[6] & 0x08));
 654                                input_report_key(input, BTN_8, (data[5] & 0x10));
 655                                input_report_key(input, BTN_9, (data[6] & 0x10));
 656                        }
 657                        input_report_abs(input, ABS_RX, ((data[1] & 0x1f) << 8) | data[2]);
 658                        input_report_abs(input, ABS_RY, ((data[3] & 0x1f) << 8) | data[4]);
 659
 660                        if ((data[5] & 0x1f) | data[6] | (data[1] & 0x1f) |
 661                                data[2] | (data[3] & 0x1f) | data[4] | data[8] |
 662                                (data[7] & 0x01)) {
 663                                input_report_key(input, wacom->tool[1], 1);
 664                                input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
 665                        } else {
 666                                input_report_key(input, wacom->tool[1], 0);
 667                                input_report_abs(input, ABS_MISC, 0);
 668                        }
 669                }
 670                input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
 671                return 1;
 672        }
 673
 674        /* process in/out prox events */
 675        result = wacom_intuos_inout(wacom);
 676        if (result)
 677                return result - 1;
 678
 679        /* don't proceed if we don't know the ID */
 680        if (!wacom->id[idx])
 681                return 0;
 682
 683        /* Only large Intuos support Lense Cursor */
 684        if (wacom->tool[idx] == BTN_TOOL_LENS &&
 685            (features->type == INTUOS3 ||
 686             features->type == INTUOS3S ||
 687             features->type == INTUOS4 ||
 688             features->type == INTUOS4S ||
 689             features->type == INTUOS5 ||
 690             features->type == INTUOS5S)) {
 691
 692                return 0;
 693        }
 694
 695        /* Cintiq doesn't send data when RDY bit isn't set */
 696        if (features->type == CINTIQ && !(data[1] & 0x40))
 697                 return 0;
 698
 699        if (features->type >= INTUOS3S) {
 700                input_report_abs(input, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1));
 701                input_report_abs(input, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1));
 702                input_report_abs(input, ABS_DISTANCE, ((data[9] >> 2) & 0x3f));
 703        } else {
 704                input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[2]));
 705                input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[4]));
 706                input_report_abs(input, ABS_DISTANCE, ((data[9] >> 3) & 0x1f));
 707        }
 708
 709        /* process general packets */
 710        wacom_intuos_general(wacom);
 711
 712        /* 4D mouse, 2D mouse, marker pen rotation, tilt mouse, or Lens cursor packets */
 713        if ((data[1] & 0xbc) == 0xa8 || (data[1] & 0xbe) == 0xb0 || (data[1] & 0xbc) == 0xac) {
 714
 715                if (data[1] & 0x02) {
 716                        /* Rotation packet */
 717                        if (features->type >= INTUOS3S) {
 718                                /* I3 marker pen rotation */
 719                                t = (data[6] << 3) | ((data[7] >> 5) & 7);
 720                                t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
 721                                        ((t-1) / 2 + 450)) : (450 - t / 2) ;
 722                                input_report_abs(input, ABS_Z, t);
 723                        } else {
 724                                /* 4D mouse rotation packet */
 725                                t = (data[6] << 3) | ((data[7] >> 5) & 7);
 726                                input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
 727                                        ((t - 1) / 2) : -t / 2);
 728                        }
 729
 730                } else if (!(data[1] & 0x10) && features->type < INTUOS3S) {
 731                        /* 4D mouse packet */
 732                        input_report_key(input, BTN_LEFT,   data[8] & 0x01);
 733                        input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
 734                        input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
 735
 736                        input_report_key(input, BTN_SIDE,   data[8] & 0x20);
 737                        input_report_key(input, BTN_EXTRA,  data[8] & 0x10);
 738                        t = (data[6] << 2) | ((data[7] >> 6) & 3);
 739                        input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
 740
 741                } else if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
 742                        /* I4 mouse */
 743                        if ((features->type >= INTUOS4S && features->type <= INTUOS4L) ||
 744                            (features->type >= INTUOS5S && features->type <= INTUOS5L)) {
 745                                input_report_key(input, BTN_LEFT,   data[6] & 0x01);
 746                                input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
 747                                input_report_key(input, BTN_RIGHT,  data[6] & 0x04);
 748                                input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
 749                                                 - ((data[7] & 0x40) >> 6));
 750                                input_report_key(input, BTN_SIDE,   data[6] & 0x08);
 751                                input_report_key(input, BTN_EXTRA,  data[6] & 0x10);
 752
 753                                input_report_abs(input, ABS_TILT_X,
 754                                        ((data[7] << 1) & 0x7e) | (data[8] >> 7));
 755                                input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
 756                        } else {
 757                                /* 2D mouse packet */
 758                                input_report_key(input, BTN_LEFT,   data[8] & 0x04);
 759                                input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
 760                                input_report_key(input, BTN_RIGHT,  data[8] & 0x10);
 761                                input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
 762                                                 - ((data[8] & 0x02) >> 1));
 763
 764                                /* I3 2D mouse side buttons */
 765                                if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
 766                                        input_report_key(input, BTN_SIDE,   data[8] & 0x40);
 767                                        input_report_key(input, BTN_EXTRA,  data[8] & 0x20);
 768                                }
 769                        }
 770                } else if ((features->type < INTUOS3S || features->type == INTUOS3L ||
 771                                features->type == INTUOS4L || features->type == INTUOS5L) &&
 772                           wacom->tool[idx] == BTN_TOOL_LENS) {
 773                        /* Lens cursor packets */
 774                        input_report_key(input, BTN_LEFT,   data[8] & 0x01);
 775                        input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
 776                        input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
 777                        input_report_key(input, BTN_SIDE,   data[8] & 0x10);
 778                        input_report_key(input, BTN_EXTRA,  data[8] & 0x08);
 779                }
 780        }
 781
 782        input_report_abs(input, ABS_MISC, wacom->id[idx]); /* report tool id */
 783        input_report_key(input, wacom->tool[idx], 1);
 784        input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
 785        return 1;
 786}
 787
 788static int find_slot_from_contactid(struct wacom_wac *wacom, int contactid)
 789{
 790        int touch_max = wacom->features.touch_max;
 791        int i;
 792
 793        if (!wacom->slots)
 794                return -1;
 795
 796        for (i = 0; i < touch_max; ++i) {
 797                if (wacom->slots[i] == contactid)
 798                        return i;
 799        }
 800        for (i = 0; i < touch_max; ++i) {
 801                if (wacom->slots[i] == -1)
 802                        return i;
 803        }
 804        return -1;
 805}
 806
 807static int int_dist(int x1, int y1, int x2, int y2)
 808{
 809        int x = x2 - x1;
 810        int y = y2 - y1;
 811
 812        return int_sqrt(x*x + y*y);
 813}
 814
 815static int wacom_24hdt_irq(struct wacom_wac *wacom)
 816{
 817        struct input_dev *input = wacom->input;
 818        char *data = wacom->data;
 819        int i;
 820        int current_num_contacts = data[61];
 821        int contacts_to_send = 0;
 822
 823        /*
 824         * First packet resets the counter since only the first
 825         * packet in series will have non-zero current_num_contacts.
 826         */
 827        if (current_num_contacts)
 828                wacom->num_contacts_left = current_num_contacts;
 829
 830        /* There are at most 4 contacts per packet */
 831        contacts_to_send = min(4, wacom->num_contacts_left);
 832
 833        for (i = 0; i < contacts_to_send; i++) {
 834                int offset = (WACOM_BYTES_PER_24HDT_PACKET * i) + 1;
 835                bool touch = data[offset] & 0x1 && !wacom->shared->stylus_in_proximity;
 836                int id = data[offset + 1];
 837                int slot = find_slot_from_contactid(wacom, id);
 838
 839                if (slot < 0)
 840                        continue;
 841                input_mt_slot(input, slot);
 842                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
 843
 844                if (touch) {
 845                        int t_x = le16_to_cpup((__le16 *)&data[offset + 2]);
 846                        int c_x = le16_to_cpup((__le16 *)&data[offset + 4]);
 847                        int t_y = le16_to_cpup((__le16 *)&data[offset + 6]);
 848                        int c_y = le16_to_cpup((__le16 *)&data[offset + 8]);
 849                        int w = le16_to_cpup((__le16 *)&data[offset + 10]);
 850                        int h = le16_to_cpup((__le16 *)&data[offset + 12]);
 851
 852                        input_report_abs(input, ABS_MT_POSITION_X, t_x);
 853                        input_report_abs(input, ABS_MT_POSITION_Y, t_y);
 854                        input_report_abs(input, ABS_MT_TOUCH_MAJOR, min(w,h));
 855                        input_report_abs(input, ABS_MT_WIDTH_MAJOR, min(w, h) + int_dist(t_x, t_y, c_x, c_y));
 856                        input_report_abs(input, ABS_MT_WIDTH_MINOR, min(w, h));
 857                        input_report_abs(input, ABS_MT_ORIENTATION, w > h);
 858                }
 859                wacom->slots[slot] = touch ? id : -1;
 860        }
 861
 862        input_mt_report_pointer_emulation(input, true);
 863
 864        wacom->num_contacts_left -= contacts_to_send;
 865        if (wacom->num_contacts_left <= 0)
 866                wacom->num_contacts_left = 0;
 867
 868        return 1;
 869}
 870
 871static int wacom_mt_touch(struct wacom_wac *wacom)
 872{
 873        struct input_dev *input = wacom->input;
 874        char *data = wacom->data;
 875        int i;
 876        int current_num_contacts = data[2];
 877        int contacts_to_send = 0;
 878        int x_offset = 0;
 879
 880        /* MTTPC does not support Height and Width */
 881        if (wacom->features.type == MTTPC)
 882                x_offset = -4;
 883
 884        /*
 885         * First packet resets the counter since only the first
 886         * packet in series will have non-zero current_num_contacts.
 887         */
 888        if (current_num_contacts)
 889                wacom->num_contacts_left = current_num_contacts;
 890
 891        /* There are at most 5 contacts per packet */
 892        contacts_to_send = min(5, wacom->num_contacts_left);
 893
 894        for (i = 0; i < contacts_to_send; i++) {
 895                int offset = (WACOM_BYTES_PER_MT_PACKET + x_offset) * i + 3;
 896                bool touch = data[offset] & 0x1;
 897                int id = le16_to_cpup((__le16 *)&data[offset + 1]);
 898                int slot = find_slot_from_contactid(wacom, id);
 899
 900                if (slot < 0)
 901                        continue;
 902
 903                input_mt_slot(input, slot);
 904                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
 905                if (touch) {
 906                        int x = le16_to_cpup((__le16 *)&data[offset + x_offset + 7]);
 907                        int y = le16_to_cpup((__le16 *)&data[offset + x_offset + 9]);
 908                        input_report_abs(input, ABS_MT_POSITION_X, x);
 909                        input_report_abs(input, ABS_MT_POSITION_Y, y);
 910                }
 911                wacom->slots[slot] = touch ? id : -1;
 912        }
 913
 914        input_mt_report_pointer_emulation(input, true);
 915
 916        wacom->num_contacts_left -= contacts_to_send;
 917        if (wacom->num_contacts_left < 0)
 918                wacom->num_contacts_left = 0;
 919
 920        return 1;
 921}
 922
 923static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
 924{
 925        struct input_dev *input = wacom->input;
 926        unsigned char *data = wacom->data;
 927        int contact_with_no_pen_down_count = 0;
 928        int i;
 929
 930        for (i = 0; i < 2; i++) {
 931                int p = data[1] & (1 << i);
 932                bool touch = p && !wacom->shared->stylus_in_proximity;
 933
 934                input_mt_slot(input, i);
 935                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
 936                if (touch) {
 937                        int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
 938                        int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;
 939
 940                        input_report_abs(input, ABS_MT_POSITION_X, x);
 941                        input_report_abs(input, ABS_MT_POSITION_Y, y);
 942                        contact_with_no_pen_down_count++;
 943                }
 944        }
 945
 946        /* keep touch state for pen event */
 947        wacom->shared->touch_down = (contact_with_no_pen_down_count > 0);
 948
 949        input_mt_report_pointer_emulation(input, true);
 950
 951        return 1;
 952}
 953
 954static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
 955{
 956        char *data = wacom->data;
 957        struct input_dev *input = wacom->input;
 958        bool prox;
 959        int x = 0, y = 0;
 960
 961        if (wacom->features.touch_max > 1 || len > WACOM_PKGLEN_TPC2FG)
 962                return 0;
 963
 964        if (!wacom->shared->stylus_in_proximity) {
 965                if (len == WACOM_PKGLEN_TPC1FG) {
 966                        prox = data[0] & 0x01;
 967                        x = get_unaligned_le16(&data[1]);
 968                        y = get_unaligned_le16(&data[3]);
 969                } else {
 970                        prox = data[1] & 0x01;
 971                        x = le16_to_cpup((__le16 *)&data[2]);
 972                        y = le16_to_cpup((__le16 *)&data[4]);
 973                }
 974        } else
 975                /* force touch out when pen is in prox */
 976                prox = 0;
 977
 978        if (prox) {
 979                input_report_abs(input, ABS_X, x);
 980                input_report_abs(input, ABS_Y, y);
 981        }
 982        input_report_key(input, BTN_TOUCH, prox);
 983
 984        /* keep touch state for pen events */
 985        wacom->shared->touch_down = prox;
 986
 987        return 1;
 988}
 989
 990static int wacom_tpc_pen(struct wacom_wac *wacom)
 991{
 992        struct wacom_features *features = &wacom->features;
 993        char *data = wacom->data;
 994        struct input_dev *input = wacom->input;
 995        int pressure;
 996        bool prox = data[1] & 0x20;
 997
 998        if (!wacom->shared->stylus_in_proximity) /* first in prox */
 999                /* Going into proximity select tool */
1000                wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;

1001
1002        /* keep pen state for touch events */
1003        wacom->shared->stylus_in_proximity = prox;
1004
1005        /* send pen events only when touch is up or forced out */
1006        if (!wacom->shared->touch_down) {
1007                input_report_key(input, BTN_STYLUS, data[1] & 0x02);
1008                input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
1009                input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
1010                input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
1011                pressure = ((data[7] & 0x01) << 8) | data[6];
1012                if (pressure < 0)
1013                        pressure = features->pressure_max + pressure + 1;
1014                input_report_abs(input, ABS_PRESSURE, pressure);
1015                input_report_key(input, BTN_TOUCH, data[1] & 0x05);
1016                input_report_key(input, wacom->tool[0], prox);
1017                return 1;
1018        }
1019
1020        return 0;
1021}
1022
1023static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
1024{
1025        char *data = wacom->data;
1026
1027        dev_dbg(wacom->input->dev.parent,
1028                "%s: received report #%d\n", __func__, data[0]);
1029
1030        switch (len) {
1031        case WACOM_PKGLEN_TPC1FG:
1032                return wacom_tpc_single_touch(wacom, len);
1033
1034        case WACOM_PKGLEN_TPC2FG:
1035                return wacom_tpc_mt_touch(wacom);
1036
1037        default:
1038                switch (data[0]) {
1039                case WACOM_REPORT_TPC1FG:
1040                case WACOM_REPORT_TPCHID:
1041                case WACOM_REPORT_TPCST:
1042                case WACOM_REPORT_TPC1FGE:
1043                        return wacom_tpc_single_touch(wacom, len);
1044
1045                case WACOM_REPORT_TPCMT:
1046                        return wacom_mt_touch(wacom);
1047
1048                case WACOM_REPORT_PENABLED:
1049                        return wacom_tpc_pen(wacom);
1050                }
1051        }
1052
1053        return 0;
1054}
1055
1056static int wacom_bpt_touch(struct wacom_wac *wacom)
1057{
1058        struct wacom_features *features = &wacom->features;
1059        struct input_dev *input = wacom->input;
1060        unsigned char *data = wacom->data;
1061        int i;
1062
1063        if (data[0] != 0x02)
1064            return 0;
1065
1066        for (i = 0; i < 2; i++) {
1067                int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
1068                bool touch = data[offset + 3] & 0x80;
1069
1070                /*
1071                 * Touch events need to be disabled while stylus is
1072                 * in proximity because user's hand is resting on touchpad
1073                 * and sending unwanted events.  User expects tablet buttons
1074                 * to continue working though.
1075                 */
1076                touch = touch && !wacom->shared->stylus_in_proximity;
1077
1078                input_mt_slot(input, i);
1079                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1080                if (touch) {
1081                        int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
1082                        int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
1083                        if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
1084                                x <<= 5;
1085                                y <<= 5;
1086                        }
1087                        input_report_abs(input, ABS_MT_POSITION_X, x);
1088                        input_report_abs(input, ABS_MT_POSITION_Y, y);
1089                }
1090        }
1091
1092        input_mt_report_pointer_emulation(input, true);
1093
1094        input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
1095        input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
1096        input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
1097        input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
1098
1099        input_sync(input);
1100
1101        return 0;
1102}
1103
1104static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
1105{
1106        struct input_dev *input = wacom->input;
1107        int slot_id = data[0] - 2;  /* data[0] is between 2 and 17 */
1108        bool touch = data[1] & 0x80;
1109
1110        touch = touch && !wacom->shared->stylus_in_proximity;
1111
1112        input_mt_slot(input, slot_id);
1113        input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1114
1115        if (touch) {
1116                int x = (data[2] << 4) | (data[4] >> 4);
1117                int y = (data[3] << 4) | (data[4] & 0x0f);
1118                int a = data[5];
1119
1120                // "a" is a scaled-down area which we assume is roughly
1121                // circular and which can be described as: a=(pi*r^2)/C.
1122                int x_res  = input_abs_get_res(input, ABS_X);
1123                int y_res  = input_abs_get_res(input, ABS_Y);
1124                int width  = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
1125                int height = width * y_res / x_res;
1126
1127                input_report_abs(input, ABS_MT_POSITION_X, x);
1128                input_report_abs(input, ABS_MT_POSITION_Y, y);
1129                input_report_abs(input, ABS_MT_TOUCH_MAJOR, width);
1130                input_report_abs(input, ABS_MT_TOUCH_MINOR, height);
1131        }
1132}
1133
1134static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
1135{
1136        struct input_dev *input = wacom->input;
1137
1138        input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
1139        input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
1140        input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
1141        input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
1142}
1143
1144static int wacom_bpt3_touch(struct wacom_wac *wacom)
1145{
1146        struct input_dev *input = wacom->input;
1147        unsigned char *data = wacom->data;
1148        int count = data[1] & 0x07;
1149        int i;
1150
1151        if (data[0] != 0x02)
1152            return 0;
1153
1154        /* data has up to 7 fixed sized 8-byte messages starting at data[2] */
1155        for (i = 0; i < count; i++) {
1156                int offset = (8 * i) + 2;
1157                int msg_id = data[offset];
1158
1159                if (msg_id >= 2 && msg_id <= 17)
1160                        wacom_bpt3_touch_msg(wacom, data + offset);
1161                else if (msg_id == 128)
1162                        wacom_bpt3_button_msg(wacom, data + offset);
1163
1164        }
1165
1166        input_mt_report_pointer_emulation(input, true);
1167
1168        input_sync(input);
1169
1170        return 0;
1171}
1172
1173static int wacom_bpt_pen(struct wacom_wac *wacom)
1174{
1175        struct input_dev *input = wacom->input;
1176        unsigned char *data = wacom->data;
1177        int prox = 0, x = 0, y = 0, p = 0, d = 0, pen = 0, btn1 = 0, btn2 = 0;
1178
1179        if (data[0] != 0x02)
1180            return 0;
1181
1182        prox = (data[1] & 0x20) == 0x20;
1183
1184        /*
1185         * All reports shared between PEN and RUBBER tool must be
1186         * forced to a known starting value (zero) when transitioning to
1187         * out-of-prox.
1188         *
1189         * If not reset then, to userspace, it will look like lost events
1190         * if new tool comes in-prox with same values as previous tool sent.
1191         *
1192         * Hardware does report zero in most out-of-prox cases but not all.
1193         */
1194        if (prox) {
1195                if (!wacom->shared->stylus_in_proximity) {
1196                        if (data[1] & 0x08) {
1197                                wacom->tool[0] = BTN_TOOL_RUBBER;
1198                                wacom->id[0] = ERASER_DEVICE_ID;
1199                        } else {
1200                                wacom->tool[0] = BTN_TOOL_PEN;
1201                                wacom->id[0] = STYLUS_DEVICE_ID;
1202                        }
1203                        wacom->shared->stylus_in_proximity = true;
1204                }
1205                x = le16_to_cpup((__le16 *)&data[2]);
1206                y = le16_to_cpup((__le16 *)&data[4]);
1207                p = le16_to_cpup((__le16 *)&data[6]);
1208                /*
1209                 * Convert distance from out prox to distance from tablet.
1210                 * distance will be greater than distance_max once
1211                 * touching and applying pressure; do not report negative
1212                 * distance.
1213                 */
1214                if (data[8] <= wacom->features.distance_max)
1215                        d = wacom->features.distance_max - data[8];
1216
1217                pen = data[1] & 0x01;
1218                btn1 = data[1] & 0x02;
1219                btn2 = data[1] & 0x04;
1220        }
1221
1222        input_report_key(input, BTN_TOUCH, pen);
1223        input_report_key(input, BTN_STYLUS, btn1);
1224        input_report_key(input, BTN_STYLUS2, btn2);
1225
1226        input_report_abs(input, ABS_X, x);
1227        input_report_abs(input, ABS_Y, y);
1228        input_report_abs(input, ABS_PRESSURE, p);
1229        input_report_abs(input, ABS_DISTANCE, d);
1230
1231        if (!prox) {
1232                wacom->id[0] = 0;
1233                wacom->shared->stylus_in_proximity = false;
1234        }
1235
1236        input_report_key(input, wacom->tool[0], prox); /* PEN or RUBBER */
1237        input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */
1238
1239        return 1;
1240}
1241
1242static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
1243{
1244        if (len == WACOM_PKGLEN_BBTOUCH)
1245                return wacom_bpt_touch(wacom);
1246        else if (len == WACOM_PKGLEN_BBTOUCH3)
1247                return wacom_bpt3_touch(wacom);
1248        else if (len == WACOM_PKGLEN_BBFUN || len == WACOM_PKGLEN_BBPEN)
1249                return wacom_bpt_pen(wacom);
1250
1251        return 0;
1252}
1253
1254static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
1255{
1256        unsigned char *data = wacom->data;
1257        int connected;
1258
1259        if (len != WACOM_PKGLEN_WIRELESS || data[0] != 0x80)
1260                return 0;
1261
1262        connected = data[1] & 0x01;
1263        if (connected) {
1264                int pid, battery;
1265
1266                pid = get_unaligned_be16(&data[6]);
1267                battery = data[5] & 0x3f;
1268                if (wacom->pid != pid) {
1269                        wacom->pid = pid;
1270                        wacom_schedule_work(wacom);
1271                }
1272                wacom->battery_capacity = battery;
1273        } else if (wacom->pid != 0) {
1274                /* disconnected while previously connected */
1275                wacom->pid = 0;
1276                wacom_schedule_work(wacom);
1277                wacom->battery_capacity = 0;
1278        }
1279
1280        return 0;
1281}
1282
1283void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
1284{
1285        bool sync;
1286
1287        switch (wacom_wac->features.type) {
1288        case PENPARTNER:
1289                sync = wacom_penpartner_irq(wacom_wac);
1290                break;
1291
1292        case PL:
1293                sync = wacom_pl_irq(wacom_wac);
1294                break;
1295
1296        case WACOM_G4:
1297        case GRAPHIRE:
1298        case WACOM_MO:
1299                sync = wacom_graphire_irq(wacom_wac);
1300                break;
1301
1302        case PTU:
1303                sync = wacom_ptu_irq(wacom_wac);
1304                break;
1305
1306        case DTU:
1307                sync = wacom_dtu_irq(wacom_wac);
1308                break;
1309
1310        case INTUOS:
1311        case INTUOS3S:
1312        case INTUOS3:
1313        case INTUOS3L:
1314        case INTUOS4S:
1315        case INTUOS4:
1316        case INTUOS4L:
1317        case CINTIQ:
1318        case WACOM_BEE:
1319        case WACOM_21UX2:
1320        case WACOM_22HD:
1321        case WACOM_24HD:
1322                sync = wacom_intuos_irq(wacom_wac);
1323                break;
1324
1325        case WACOM_24HDT:
1326                sync = wacom_24hdt_irq(wacom_wac);
1327                break;
1328
1329        case INTUOS5S:
1330        case INTUOS5:
1331        case INTUOS5L:
1332                if (len == WACOM_PKGLEN_BBTOUCH3)
1333                        sync = wacom_bpt3_touch(wacom_wac);
1334                else
1335                        sync = wacom_intuos_irq(wacom_wac);
1336                break;
1337
1338        case TABLETPC:
1339        case TABLETPCE:
1340        case TABLETPC2FG:
1341        case MTSCREEN:
1342        case MTTPC:
1343                sync = wacom_tpc_irq(wacom_wac, len);
1344                break;
1345
1346        case BAMBOO_PT:
1347                sync = wacom_bpt_irq(wacom_wac, len);
1348                break;
1349
1350        case WIRELESS:
1351                sync = wacom_wireless_irq(wacom_wac, len);
1352                break;
1353
1354        default:
1355                sync = false;
1356                break;
1357        }
1358
1359        if (sync)
1360                input_sync(wacom_wac->input);
1361}
1362
1363static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
1364{
1365        struct input_dev *input_dev = wacom_wac->input;
1366
1367        input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
1368
1369        __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1370        __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1371        __set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
1372        __set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
1373        __set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
1374        __set_bit(BTN_STYLUS, input_dev->keybit);
1375        __set_bit(BTN_STYLUS2, input_dev->keybit);
1376
1377        input_set_abs_params(input_dev, ABS_DISTANCE,
1378                             0, wacom_wac->features.distance_max, 0, 0);
1379        input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
1380        input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);
1381        input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);
1382}
1383
1384static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
1385{
1386        struct input_dev *input_dev = wacom_wac->input;
1387
1388        input_set_capability(input_dev, EV_REL, REL_WHEEL);
1389
1390        wacom_setup_cintiq(wacom_wac);
1391
1392        __set_bit(BTN_LEFT, input_dev->keybit);
1393        __set_bit(BTN_RIGHT, input_dev->keybit);
1394        __set_bit(BTN_MIDDLE, input_dev->keybit);
1395        __set_bit(BTN_SIDE, input_dev->keybit);
1396        __set_bit(BTN_EXTRA, input_dev->keybit);
1397        __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
1398        __set_bit(BTN_TOOL_LENS, input_dev->keybit);
1399
1400        input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
1401        input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
1402}
1403
1404void wacom_setup_device_quirks(struct wacom_features *features)
1405{
1406
1407        /* touch device found but size is not defined. use default */
1408        if (features->device_type == BTN_TOOL_FINGER && !features->x_max) {
1409                features->x_max = 1023;
1410                features->y_max = 1023;
1411        }
1412
1413        /* these device have multiple inputs */
1414        if (features->type >= WIRELESS ||
1415            (features->type >= INTUOS5S && features->type <= INTUOS5L) ||
1416            (features->oVid && features->oPid))
1417                features->quirks |= WACOM_QUIRK_MULTI_INPUT;
1418
1419        /* quirk for bamboo touch with 2 low res touches */
1420        if (features->type == BAMBOO_PT &&
1421            features->pktlen == WACOM_PKGLEN_BBTOUCH) {
1422                features->x_max <<= 5;
1423                features->y_max <<= 5;
1424                features->x_fuzz <<= 5;
1425                features->y_fuzz <<= 5;
1426                features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
1427        }
1428
1429        if (features->type == WIRELESS) {
1430
1431                /* monitor never has input and pen/touch have delayed create */
1432                features->quirks |= WACOM_QUIRK_NO_INPUT;
1433
1434                /* must be monitor interface if no device_type set */
1435                if (!features->device_type)
1436                        features->quirks |= WACOM_QUIRK_MONITOR;
1437        }
1438}
1439
1440static unsigned int wacom_calculate_touch_res(unsigned int logical_max,
1441                                              unsigned int physical_max)
1442{
1443       /* Touch physical dimensions are in 100th of mm */
1444       return (logical_max * 100) / physical_max;
1445}
1446
1447int wacom_setup_input_capabilities(struct input_dev *input_dev,
1448                                   struct wacom_wac *wacom_wac)
1449{
1450        struct wacom_features *features = &wacom_wac->features;
1451        int i;
1452
1453        input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1454
1455        __set_bit(BTN_TOUCH, input_dev->keybit);
1456
1457        input_set_abs_params(input_dev, ABS_X, 0, features->x_max,
1458                             features->x_fuzz, 0);
1459        input_set_abs_params(input_dev, ABS_Y, 0, features->y_max,
1460                             features->y_fuzz, 0);
1461
1462        if (features->device_type == BTN_TOOL_PEN) {
1463                input_set_abs_params(input_dev, ABS_PRESSURE, 0, features->pressure_max,
1464                             features->pressure_fuzz, 0);
1465
1466                /* penabled devices have fixed resolution for each model */
1467                input_abs_set_res(input_dev, ABS_X, features->x_resolution);
1468                input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
1469        } else {
1470                input_abs_set_res(input_dev, ABS_X,
1471                        wacom_calculate_touch_res(features->x_max,
1472                                                features->x_phy));
1473                input_abs_set_res(input_dev, ABS_Y,
1474                        wacom_calculate_touch_res(features->y_max,
1475                                                features->y_phy));
1476        }
1477
1478        __set_bit(ABS_MISC, input_dev->absbit);
1479
1480        switch (wacom_wac->features.type) {
1481        case WACOM_MO:
1482                input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
1483                /* fall through */
1484
1485        case WACOM_G4:
1486                input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
1487
1488                __set_bit(BTN_BACK, input_dev->keybit);
1489                __set_bit(BTN_FORWARD, input_dev->keybit);
1490                /* fall through */
1491
1492        case GRAPHIRE:
1493                input_set_capability(input_dev, EV_REL, REL_WHEEL);
1494
1495                __set_bit(BTN_LEFT, input_dev->keybit);
1496                __set_bit(BTN_RIGHT, input_dev->keybit);
1497                __set_bit(BTN_MIDDLE, input_dev->keybit);
1498
1499                __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1500                __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1501                __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
1502                __set_bit(BTN_STYLUS, input_dev->keybit);
1503                __set_bit(BTN_STYLUS2, input_dev->keybit);
1504
1505                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1506                break;
1507
1508        case WACOM_24HD:
1509                __set_bit(BTN_A, input_dev->keybit);
1510                __set_bit(BTN_B, input_dev->keybit);
1511                __set_bit(BTN_C, input_dev->keybit);
1512                __set_bit(BTN_X, input_dev->keybit);
1513                __set_bit(BTN_Y, input_dev->keybit);
1514                __set_bit(BTN_Z, input_dev->keybit);
1515
1516                for (i = 0; i < 10; i++)
1517                        __set_bit(BTN_0 + i, input_dev->keybit);
1518
1519                __set_bit(KEY_PROG1, input_dev->keybit);
1520                __set_bit(KEY_PROG2, input_dev->keybit);
1521                __set_bit(KEY_PROG3, input_dev->keybit);
1522
1523                input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1524                input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
1525
1526                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1527
1528                wacom_setup_cintiq(wacom_wac);
1529                break;
1530
1531        case WACOM_22HD:
1532                __set_bit(KEY_PROG1, input_dev->keybit);
1533                __set_bit(KEY_PROG2, input_dev->keybit);
1534                __set_bit(KEY_PROG3, input_dev->keybit);
1535                /* fall through */
1536
1537        case WACOM_21UX2:
1538                __set_bit(BTN_A, input_dev->keybit);
1539                __set_bit(BTN_B, input_dev->keybit);
1540                __set_bit(BTN_C, input_dev->keybit);
1541                __set_bit(BTN_X, input_dev->keybit);
1542                __set_bit(BTN_Y, input_dev->keybit);
1543                __set_bit(BTN_Z, input_dev->keybit);
1544                __set_bit(BTN_BASE, input_dev->keybit);
1545                __set_bit(BTN_BASE2, input_dev->keybit);
1546                /* fall through */
1547
1548        case WACOM_BEE:
1549                __set_bit(BTN_8, input_dev->keybit);
1550                __set_bit(BTN_9, input_dev->keybit);
1551                /* fall through */
1552
1553        case CINTIQ:
1554                for (i = 0; i < 8; i++)
1555                        __set_bit(BTN_0 + i, input_dev->keybit);
1556
1557                input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
1558                input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
1559                input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1560
1561                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1562
1563                wacom_setup_cintiq(wacom_wac);
1564                break;
1565
1566        case INTUOS3:
1567        case INTUOS3L:
1568                __set_bit(BTN_4, input_dev->keybit);
1569                __set_bit(BTN_5, input_dev->keybit);
1570                __set_bit(BTN_6, input_dev->keybit);
1571                __set_bit(BTN_7, input_dev->keybit);
1572
1573                input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
1574                /* fall through */
1575
1576        case INTUOS3S:
1577                __set_bit(BTN_0, input_dev->keybit);
1578                __set_bit(BTN_1, input_dev->keybit);
1579                __set_bit(BTN_2, input_dev->keybit);
1580                __set_bit(BTN_3, input_dev->keybit);
1581
1582                input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
1583                input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1584                /* fall through */
1585
1586        case INTUOS:
1587                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1588
1589                wacom_setup_intuos(wacom_wac);
1590                break;
1591
1592        case INTUOS5:
1593        case INTUOS5L:
1594                if (features->device_type == BTN_TOOL_PEN) {
1595                        __set_bit(BTN_7, input_dev->keybit);
1596                        __set_bit(BTN_8, input_dev->keybit);
1597                }
1598                /* fall through */
1599
1600        case INTUOS5S:
1601                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1602
1603                if (features->device_type == BTN_TOOL_PEN) {
1604                        for (i = 0; i < 7; i++)
1605                                __set_bit(BTN_0 + i, input_dev->keybit);
1606
1607                        input_set_abs_params(input_dev, ABS_DISTANCE, 0,
1608                                              features->distance_max,
1609                                              0, 0);
1610
1611                        input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1612
1613                        wacom_setup_intuos(wacom_wac);
1614                } else if (features->device_type == BTN_TOOL_FINGER) {
1615                        __clear_bit(ABS_MISC, input_dev->absbit);
1616
1617                        __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
1618                        __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
1619                        __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
1620                        __set_bit(BTN_TOOL_QUADTAP, input_dev->keybit);
1621
1622                        input_mt_init_slots(input_dev, features->touch_max, 0);
1623
1624                        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1625                                             0, features->x_max, 0, 0);
1626                        input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR,
1627                                             0, features->y_max, 0, 0);
1628
1629                        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1630                                             0, features->x_max,
1631                                             features->x_fuzz, 0);
1632                        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1633                                             0, features->y_max,
1634                                             features->y_fuzz, 0);
1635                }
1636                break;
1637
1638        case INTUOS4:
1639        case INTUOS4L:
1640                __set_bit(BTN_7, input_dev->keybit);
1641                __set_bit(BTN_8, input_dev->keybit);
1642                /* fall through */
1643
1644        case INTUOS4S:
1645                for (i = 0; i < 7; i++)
1646                        __set_bit(BTN_0 + i, input_dev->keybit);
1647
1648                input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1649                wacom_setup_intuos(wacom_wac);
1650
1651                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1652                break;
1653
1654        case WACOM_24HDT:
1655                if (features->device_type == BTN_TOOL_FINGER) {
1656                        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
1657                        input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
1658                        input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
1659                        input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
1660                }
1661                /* fall through */
1662
1663        case MTSCREEN:
1664        case MTTPC:
1665                if (features->device_type == BTN_TOOL_FINGER) {
1666                        wacom_wac->slots = kmalloc(features->touch_max *
1667                                                        sizeof(int),
1668                                                   GFP_KERNEL);
1669                        if (!wacom_wac->slots)
1670                                return -ENOMEM;
1671
1672                        for (i = 0; i < features->touch_max; i++)
1673                                wacom_wac->slots[i] = -1;
1674                }
1675                /* fall through */
1676
1677        case TABLETPC2FG:
1678                if (features->device_type == BTN_TOOL_FINGER) {
1679                        input_mt_init_slots(input_dev, features->touch_max, 0);
1680                        input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
1681                                        0, MT_TOOL_MAX, 0, 0);
1682                        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1683                                        0, features->x_max, 0, 0);
1684                        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1685                                        0, features->y_max, 0, 0);
1686                }
1687                /* fall through */
1688
1689        case TABLETPC:
1690        case TABLETPCE:
1691                __clear_bit(ABS_MISC, input_dev->absbit);
1692
1693                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1694
1695                if (features->device_type != BTN_TOOL_PEN)
1696                        break;  /* no need to process stylus stuff */
1697
1698                /* fall through */
1699
1700        case PL:
1701        case DTU:
1702                __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1703                __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1704                __set_bit(BTN_STYLUS, input_dev->keybit);
1705                __set_bit(BTN_STYLUS2, input_dev->keybit);
1706
1707                __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1708                break;
1709
1710        case PTU:
1711                __set_bit(BTN_STYLUS2, input_dev->keybit);
1712                /* fall through */
1713
1714        case PENPARTNER:
1715                __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1716                __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1717                __set_bit(BTN_STYLUS, input_dev->keybit);
1718
1719                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1720                break;
1721
1722        case BAMBOO_PT:
1723                __clear_bit(ABS_MISC, input_dev->absbit);
1724
1725                __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1726
1727                if (features->device_type == BTN_TOOL_FINGER) {
1728                        __set_bit(BTN_LEFT, input_dev->keybit);
1729                        __set_bit(BTN_FORWARD, input_dev->keybit);
1730                        __set_bit(BTN_BACK, input_dev->keybit);
1731                        __set_bit(BTN_RIGHT, input_dev->keybit);
1732
1733                        __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
1734                        __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
1735                        input_mt_init_slots(input_dev, features->touch_max, 0);
1736
1737                        if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
1738                                __set_bit(BTN_TOOL_TRIPLETAP,
1739                                          input_dev->keybit);
1740                                __set_bit(BTN_TOOL_QUADTAP,
1741                                          input_dev->keybit);
1742
1743                                input_set_abs_params(input_dev,
1744                                                     ABS_MT_TOUCH_MAJOR,
1745                                                     0, features->x_max, 0, 0);
1746                                input_set_abs_params(input_dev,
1747                                                     ABS_MT_TOUCH_MINOR,
1748                                                     0, features->y_max, 0, 0);
1749                        }
1750
1751                        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1752                                             0, features->x_max,
1753                                             features->x_fuzz, 0);
1754                        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1755                                             0, features->y_max,
1756                                             features->y_fuzz, 0);
1757                } else if (features->device_type == BTN_TOOL_PEN) {
1758                        __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1759                        __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1760                        __set_bit(BTN_STYLUS, input_dev->keybit);
1761                        __set_bit(BTN_STYLUS2, input_dev->keybit);
1762                        input_set_abs_params(input_dev, ABS_DISTANCE, 0,
1763                                              features->distance_max,
1764                                              0, 0);
1765                }
1766                break;
1767        }
1768        return 0;
1769}
1770
1771static const struct wacom_features wacom_features_0x00 =
1772        { "Wacom Penpartner",     WACOM_PKGLEN_PENPRTN,    5040,  3780,  255,
1773          0, PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
1774static const struct wacom_features wacom_features_0x10 =
1775        { "Wacom Graphire",       WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511,
1776          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1777static const struct wacom_features wacom_features_0x11 =
1778        { "Wacom Graphire2 4x5",  WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511,
1779          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1780static const struct wacom_features wacom_features_0x12 =
1781        { "Wacom Graphire2 5x7",  WACOM_PKGLEN_GRAPHIRE,  13918, 10206,  511,
1782          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1783static const struct wacom_features wacom_features_0x13 =
1784        { "Wacom Graphire3",      WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511,
1785          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1786static const struct wacom_features wacom_features_0x14 =
1787        { "Wacom Graphire3 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
1788          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1789static const struct wacom_features wacom_features_0x15 =
1790        { "Wacom Graphire4 4x5",  WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511,
1791          63, WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1792static const struct wacom_features wacom_features_0x16 =
1793        { "Wacom Graphire4 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
1794          63, WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1795static const struct wacom_features wacom_features_0x17 =
1796        { "Wacom BambooFun 4x5",  WACOM_PKGLEN_BBFUN,     14760,  9225,  511,
1797          63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1798static const struct wacom_features wacom_features_0x18 =
1799        { "Wacom BambooFun 6x8",  WACOM_PKGLEN_BBFUN,     21648, 13530,  511,
1800          63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1801static const struct wacom_features wacom_features_0x19 =
1802        { "Wacom Bamboo1 Medium", WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
1803          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1804static const struct wacom_features wacom_features_0x60 =
1805        { "Wacom Volito",         WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
1806          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1807static const struct wacom_features wacom_features_0x61 =
1808        { "Wacom PenStation2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  255,
1809          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1810static const struct wacom_features wacom_features_0x62 =
1811        { "Wacom Volito2 4x5",    WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
1812          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1813static const struct wacom_features wacom_features_0x63 =
1814        { "Wacom Volito2 2x3",    WACOM_PKGLEN_GRAPHIRE,   3248,  2320,  511,
1815          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1816static const struct wacom_features wacom_features_0x64 =
1817        { "Wacom PenPartner2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  511,
1818          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1819static const struct wacom_features wacom_features_0x65 =
1820        { "Wacom Bamboo",         WACOM_PKGLEN_BBFUN,     14760,  9225,  511,
1821          63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1822static const struct wacom_features wacom_features_0x69 =
1823        { "Wacom Bamboo1",        WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
1824          63, GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
1825static const struct wacom_features wacom_features_0x6A =
1826        { "Wacom Bamboo1 4x6",    WACOM_PKGLEN_GRAPHIRE,  14760,  9225, 1023,
1827          63, GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1828static const struct wacom_features wacom_features_0x6B =
1829        { "Wacom Bamboo1 5x8",    WACOM_PKGLEN_GRAPHIRE,  21648, 13530, 1023,
1830          63, GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1831static const struct wacom_features wacom_features_0x20 =
1832        { "Wacom Intuos 4x5",     WACOM_PKGLEN_INTUOS,    12700, 10600, 1023,
1833          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1834static const struct wacom_features wacom_features_0x21 =
1835        { "Wacom Intuos 6x8",     WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
1836          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1837static const struct wacom_features wacom_features_0x22 =
1838        { "Wacom Intuos 9x12",    WACOM_PKGLEN_INTUOS,    30480, 24060, 1023,
1839          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1840static const struct wacom_features wacom_features_0x23 =
1841        { "Wacom Intuos 12x12",   WACOM_PKGLEN_INTUOS,    30480, 31680, 1023,
1842          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1843static const struct wacom_features wacom_features_0x24 =
1844        { "Wacom Intuos 12x18",   WACOM_PKGLEN_INTUOS,    45720, 31680, 1023,
1845          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1846static const struct wacom_features wacom_features_0x30 =
1847        { "Wacom PL400",          WACOM_PKGLEN_GRAPHIRE,   5408,  4056,  255,
1848          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1849static const struct wacom_features wacom_features_0x31 =
1850        { "Wacom PL500",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  255,
1851          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1852static const struct wacom_features wacom_features_0x32 =
1853        { "Wacom PL600",          WACOM_PKGLEN_GRAPHIRE,   6126,  4604,  255,
1854          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1855static const struct wacom_features wacom_features_0x33 =
1856        { "Wacom PL600SX",        WACOM_PKGLEN_GRAPHIRE,   6260,  5016,  255,
1857          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1858static const struct wacom_features wacom_features_0x34 =
1859        { "Wacom PL550",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  511,
1860          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1861static const struct wacom_features wacom_features_0x35 =
1862        { "Wacom PL800",          WACOM_PKGLEN_GRAPHIRE,   7220,  5780,  511,
1863          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1864static const struct wacom_features wacom_features_0x37 =
1865        { "Wacom PL700",          WACOM_PKGLEN_GRAPHIRE,   6758,  5406,  511,
1866          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1867static const struct wacom_features wacom_features_0x38 =
1868        { "Wacom PL510",          WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,
1869          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1870static const struct wacom_features wacom_features_0x39 =
1871        { "Wacom DTU710",         WACOM_PKGLEN_GRAPHIRE,  34080, 27660,  511,
1872          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1873static const struct wacom_features wacom_features_0xC4 =
1874        { "Wacom DTF521",         WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,
1875          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1876static const struct wacom_features wacom_features_0xC0 =
1877        { "Wacom DTF720",         WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,
1878          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1879static const struct wacom_features wacom_features_0xC2 =
1880        { "Wacom DTF720a",        WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,
1881          0, PL, WACOM_PL_RES, WACOM_PL_RES };
1882static const struct wacom_features wacom_features_0x03 =
1883        { "Wacom Cintiq Partner", WACOM_PKGLEN_GRAPHIRE,  20480, 15360,  511,
1884          0, PTU, WACOM_PL_RES, WACOM_PL_RES };
1885static const struct wacom_features wacom_features_0x41 =
1886        { "Wacom Intuos2 4x5",    WACOM_PKGLEN_INTUOS,    12700, 10600, 1023,
1887          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1888static const struct wacom_features wacom_features_0x42 =
1889        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
1890          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1891static const struct wacom_features wacom_features_0x43 =
1892        { "Wacom Intuos2 9x12",   WACOM_PKGLEN_INTUOS,    30480, 24060, 1023,
1893          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1894static const struct wacom_features wacom_features_0x44 =
1895        { "Wacom Intuos2 12x12",  WACOM_PKGLEN_INTUOS,    30480, 31680, 1023,
1896          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1897static const struct wacom_features wacom_features_0x45 =
1898        { "Wacom Intuos2 12x18",  WACOM_PKGLEN_INTUOS,    45720, 31680, 1023,
1899          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1900static const struct wacom_features wacom_features_0xB0 =
1901        { "Wacom Intuos3 4x5",    WACOM_PKGLEN_INTUOS,    25400, 20320, 1023,
1902          63, INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1903static const struct wacom_features wacom_features_0xB1 =
1904        { "Wacom Intuos3 6x8",    WACOM_PKGLEN_INTUOS,    40640, 30480, 1023,
1905          63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1906static const struct wacom_features wacom_features_0xB2 =
1907        { "Wacom Intuos3 9x12",   WACOM_PKGLEN_INTUOS,    60960, 45720, 1023,
1908          63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1909static const struct wacom_features wacom_features_0xB3 =
1910        { "Wacom Intuos3 12x12",  WACOM_PKGLEN_INTUOS,    60960, 60960, 1023,
1911          63, INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1912static const struct wacom_features wacom_features_0xB4 =
1913        { "Wacom Intuos3 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 1023,
1914          63, INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1915static const struct wacom_features wacom_features_0xB5 =
1916        { "Wacom Intuos3 6x11",   WACOM_PKGLEN_INTUOS,    54204, 31750, 1023,
1917          63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1918static const struct wacom_features wacom_features_0xB7 =
1919        { "Wacom Intuos3 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 1023,
1920          63, INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1921static const struct wacom_features wacom_features_0xB8 =
1922        { "Wacom Intuos4 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 2047,
1923          63, INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1924static const struct wacom_features wacom_features_0xB9 =
1925        { "Wacom Intuos4 6x9",    WACOM_PKGLEN_INTUOS,    44704, 27940, 2047,
1926          63, INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1927static const struct wacom_features wacom_features_0xBA =
1928        { "Wacom Intuos4 8x13",   WACOM_PKGLEN_INTUOS,    65024, 40640, 2047,
1929          63, INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1930static const struct wacom_features wacom_features_0xBB =
1931        { "Wacom Intuos4 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 2047,
1932          63, INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1933static const struct wacom_features wacom_features_0xBC =
1934        { "Wacom Intuos4 WL",     WACOM_PKGLEN_INTUOS,    40840, 25400, 2047,
1935          63, INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1936static const struct wacom_features wacom_features_0x26 =
1937        { "Wacom Intuos5 touch S", WACOM_PKGLEN_INTUOS,  31496, 19685, 2047,
1938          63, INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
1939          .touch_max = 16 };
1940static const struct wacom_features wacom_features_0x27 =
1941        { "Wacom Intuos5 touch M", WACOM_PKGLEN_INTUOS,  44704, 27940, 2047,
1942          63, INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
1943          .touch_max = 16 };
1944static const struct wacom_features wacom_features_0x28 =
1945        { "Wacom Intuos5 touch L", WACOM_PKGLEN_INTUOS, 65024, 40640, 2047,
1946          63, INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES,
1947          .touch_max = 16 };
1948static const struct wacom_features wacom_features_0x29 =
1949        { "Wacom Intuos5 S", WACOM_PKGLEN_INTUOS,  31496, 19685, 2047,
1950          63, INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1951static const struct wacom_features wacom_features_0x2A =
1952        { "Wacom Intuos5 M", WACOM_PKGLEN_INTUOS,  44704, 27940, 2047,
1953          63, INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1954static const struct wacom_features wacom_features_0xF4 =
1955        { "Wacom Cintiq 24HD",       WACOM_PKGLEN_INTUOS,   104480, 65600, 2047,
1956          63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1957static const struct wacom_features wacom_features_0xF8 =
1958        { "Wacom Cintiq 24HD touch", WACOM_PKGLEN_INTUOS,   104480, 65600, 2047, /* Pen */
1959          63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
1960static const struct wacom_features wacom_features_0xF6 =
1961        { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
1962          .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10 };
1963static const struct wacom_features wacom_features_0x3F =
1964        { "Wacom Cintiq 21UX",    WACOM_PKGLEN_INTUOS,    87200, 65600, 1023,
1965          63, CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1966static const struct wacom_features wacom_features_0xC5 =
1967        { "Wacom Cintiq 20WSX",   WACOM_PKGLEN_INTUOS,    86680, 54180, 1023,
1968          63, WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1969static const struct wacom_features wacom_features_0xC6 =
1970        { "Wacom Cintiq 12WX",    WACOM_PKGLEN_INTUOS,    53020, 33440, 1023,
1971          63, WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1972static const struct wacom_features wacom_features_0xC7 =
1973        { "Wacom DTU1931",        WACOM_PKGLEN_GRAPHIRE,  37832, 30305,  511,
1974          0, PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1975static const struct wacom_features wacom_features_0xCE =
1976        { "Wacom DTU2231",        WACOM_PKGLEN_GRAPHIRE,  47864, 27011,  511,
1977          0, DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1978static const struct wacom_features wacom_features_0xF0 =
1979        { "Wacom DTU1631",        WACOM_PKGLEN_GRAPHIRE,  34623, 19553,  511,
1980          0, DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1981static const struct wacom_features wacom_features_0xCC =
1982        { "Wacom Cintiq 21UX2",   WACOM_PKGLEN_INTUOS,    87200, 65600, 2047,
1983          63, WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1984static const struct wacom_features wacom_features_0xFA =
1985        { "Wacom Cintiq 22HD",    WACOM_PKGLEN_INTUOS,    95840, 54260, 2047,
1986          63, WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
1987static const struct wacom_features wacom_features_0x90 =
1988        { "Wacom ISDv4 90",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
1989          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1990static const struct wacom_features wacom_features_0x93 =
1991        { "Wacom ISDv4 93",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
1992          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1993static const struct wacom_features wacom_features_0x97 =
1994        { "Wacom ISDv4 97",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  511,
1995          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1996static const struct wacom_features wacom_features_0x9A =
1997        { "Wacom ISDv4 9A",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
1998          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1999static const struct wacom_features wacom_features_0x9F =
2000        { "Wacom ISDv4 9F",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,

2001          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2002static const struct wacom_features wacom_features_0xE2 =
2003        { "Wacom ISDv4 E2",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,
2004          0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2005          .touch_max = 2 };
2006static const struct wacom_features wacom_features_0xE3 =
2007        { "Wacom ISDv4 E3",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,
2008          0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2009          .touch_max = 2 };
2010static const struct wacom_features wacom_features_0xE5 =
2011        { "Wacom ISDv4 E5",       WACOM_PKGLEN_MTOUCH,    26202, 16325,  255,
2012          0, MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2013static const struct wacom_features wacom_features_0xE6 =
2014        { "Wacom ISDv4 E6",       WACOM_PKGLEN_TPC2FG,    27760, 15694,  255,
2015          0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2016        .touch_max = 2 };
2017static const struct wacom_features wacom_features_0xEC =
2018        { "Wacom ISDv4 EC",       WACOM_PKGLEN_GRAPHIRE,  25710, 14500,  255,
2019          0, TABLETPC,    WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2020static const struct wacom_features wacom_features_0xED =
2021        { "Wacom ISDv4 ED",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
2022          0, TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2023static const struct wacom_features wacom_features_0xEF =
2024        { "Wacom ISDv4 EF",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
2025          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2026static const struct wacom_features wacom_features_0x100 =
2027        { "Wacom ISDv4 100",      WACOM_PKGLEN_MTTPC,     26202, 16325,  255,
2028          0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2029static const struct wacom_features wacom_features_0x101 =
2030        { "Wacom ISDv4 101",      WACOM_PKGLEN_MTTPC,     26202, 16325,  255,
2031          0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2032static const struct wacom_features wacom_features_0x4001 =
2033        { "Wacom ISDv4 4001",      WACOM_PKGLEN_MTTPC,     26202, 16325,  255,
2034          0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2035static const struct wacom_features wacom_features_0x47 =
2036        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
2037          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2038static const struct wacom_features wacom_features_0x84 =
2039        { "Wacom Wireless Receiver", WACOM_PKGLEN_WIRELESS, 0, 0, 0,
2040          0, WIRELESS, 0, 0, .touch_max = 16 };
2041static const struct wacom_features wacom_features_0xD0 =
2042        { "Wacom Bamboo 2FG",     WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
2043          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2044          .touch_max = 2 };
2045static const struct wacom_features wacom_features_0xD1 =
2046        { "Wacom Bamboo 2FG 4x5", WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
2047          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2048          .touch_max = 2 };
2049static const struct wacom_features wacom_features_0xD2 =
2050        { "Wacom Bamboo Craft",   WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
2051          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2052          .touch_max = 2 };
2053static const struct wacom_features wacom_features_0xD3 =
2054        { "Wacom Bamboo 2FG 6x8", WACOM_PKGLEN_BBFUN,     21648, 13700, 1023,
2055          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2056          .touch_max = 2 };
2057static const struct wacom_features wacom_features_0xD4 =
2058        { "Wacom Bamboo Pen",     WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
2059          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2060static const struct wacom_features wacom_features_0xD5 =
2061        { "Wacom Bamboo Pen 6x8",     WACOM_PKGLEN_BBFUN, 21648, 13700, 1023,
2062          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2063static const struct wacom_features wacom_features_0xD6 =
2064        { "Wacom BambooPT 2FG 4x5", WACOM_PKGLEN_BBFUN,   14720,  9200, 1023,
2065          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2066          .touch_max = 2 };
2067static const struct wacom_features wacom_features_0xD7 =
2068        { "Wacom BambooPT 2FG Small", WACOM_PKGLEN_BBFUN, 14720,  9200, 1023,
2069          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2070          .touch_max = 2 };
2071static const struct wacom_features wacom_features_0xD8 =
2072        { "Wacom Bamboo Comic 2FG", WACOM_PKGLEN_BBFUN,   21648, 13700, 1023,
2073          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2074          .touch_max = 2 };
2075static const struct wacom_features wacom_features_0xDA =
2076        { "Wacom Bamboo 2FG 4x5 SE", WACOM_PKGLEN_BBFUN,  14720,  9200, 1023,
2077          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2078          .touch_max = 2 };
2079static struct wacom_features wacom_features_0xDB =
2080        { "Wacom Bamboo 2FG 6x8 SE", WACOM_PKGLEN_BBFUN,  21648, 13700, 1023,
2081          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2082          .touch_max = 2 };
2083static const struct wacom_features wacom_features_0xDD =
2084        { "Wacom Bamboo Connect", WACOM_PKGLEN_BBPEN,     14720,  9200, 1023,
2085          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2086static const struct wacom_features wacom_features_0xDE =
2087        { "Wacom Bamboo 16FG 4x5", WACOM_PKGLEN_BBPEN,    14720,  9200, 1023,
2088          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2089          .touch_max = 16 };
2090static const struct wacom_features wacom_features_0xDF =
2091        { "Wacom Bamboo 16FG 6x8", WACOM_PKGLEN_BBPEN,    21648, 13700, 1023,
2092          31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2093          .touch_max = 16 };
2094static const struct wacom_features wacom_features_0x6004 =
2095        { "ISD-V4",               WACOM_PKGLEN_GRAPHIRE,  12800,  8000,  255,
2096          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2097
2098#define USB_DEVICE_WACOM(prod)                                  \
2099        USB_DEVICE(USB_VENDOR_ID_WACOM, prod),                  \
2100        .driver_info = (kernel_ulong_t)&wacom_features_##prod
2101
2102#define USB_DEVICE_DETAILED(prod, class, sub, proto)                    \
2103        USB_DEVICE_AND_INTERFACE_INFO(USB_VENDOR_ID_WACOM, prod, class, \
2104                                      sub, proto),                      \
2105        .driver_info = (kernel_ulong_t)&wacom_features_##prod
2106
2107#define USB_DEVICE_LENOVO(prod)                                 \
2108        USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),                 \
2109        .driver_info = (kernel_ulong_t)&wacom_features_##prod
2110
2111const struct usb_device_id wacom_ids[] = {
2112        { USB_DEVICE_WACOM(0x00) },
2113        { USB_DEVICE_WACOM(0x10) },
2114        { USB_DEVICE_WACOM(0x11) },
2115        { USB_DEVICE_WACOM(0x12) },
2116        { USB_DEVICE_WACOM(0x13) },
2117        { USB_DEVICE_WACOM(0x14) },
2118        { USB_DEVICE_WACOM(0x15) },
2119        { USB_DEVICE_WACOM(0x16) },
2120        { USB_DEVICE_WACOM(0x17) },
2121        { USB_DEVICE_WACOM(0x18) },
2122        { USB_DEVICE_WACOM(0x19) },
2123        { USB_DEVICE_WACOM(0x60) },
2124        { USB_DEVICE_WACOM(0x61) },
2125        { USB_DEVICE_WACOM(0x62) },
2126        { USB_DEVICE_WACOM(0x63) },
2127        { USB_DEVICE_WACOM(0x64) },
2128        { USB_DEVICE_WACOM(0x65) },
2129        { USB_DEVICE_WACOM(0x69) },
2130        { USB_DEVICE_WACOM(0x6A) },
2131        { USB_DEVICE_WACOM(0x6B) },
2132        { USB_DEVICE_WACOM(0x20) },
2133        { USB_DEVICE_WACOM(0x21) },
2134        { USB_DEVICE_WACOM(0x22) },
2135        { USB_DEVICE_WACOM(0x23) },
2136        { USB_DEVICE_WACOM(0x24) },
2137        { USB_DEVICE_WACOM(0x30) },
2138        { USB_DEVICE_WACOM(0x31) },
2139        { USB_DEVICE_WACOM(0x32) },
2140        { USB_DEVICE_WACOM(0x33) },
2141        { USB_DEVICE_WACOM(0x34) },
2142        { USB_DEVICE_WACOM(0x35) },
2143        { USB_DEVICE_WACOM(0x37) },
2144        { USB_DEVICE_WACOM(0x38) },
2145        { USB_DEVICE_WACOM(0x39) },
2146        { USB_DEVICE_WACOM(0xC4) },
2147        { USB_DEVICE_WACOM(0xC0) },
2148        { USB_DEVICE_WACOM(0xC2) },
2149        { USB_DEVICE_WACOM(0x03) },
2150        { USB_DEVICE_WACOM(0x41) },
2151        { USB_DEVICE_WACOM(0x42) },
2152        { USB_DEVICE_WACOM(0x43) },
2153        { USB_DEVICE_WACOM(0x44) },
2154        { USB_DEVICE_WACOM(0x45) },
2155        { USB_DEVICE_WACOM(0xB0) },
2156        { USB_DEVICE_WACOM(0xB1) },
2157        { USB_DEVICE_WACOM(0xB2) },
2158        { USB_DEVICE_WACOM(0xB3) },
2159        { USB_DEVICE_WACOM(0xB4) },
2160        { USB_DEVICE_WACOM(0xB5) },
2161        { USB_DEVICE_WACOM(0xB7) },
2162        { USB_DEVICE_WACOM(0xB8) },
2163        { USB_DEVICE_WACOM(0xB9) },
2164        { USB_DEVICE_WACOM(0xBA) },
2165        { USB_DEVICE_WACOM(0xBB) },
2166        { USB_DEVICE_WACOM(0xBC) },
2167        { USB_DEVICE_WACOM(0x26) },
2168        { USB_DEVICE_WACOM(0x27) },
2169        { USB_DEVICE_WACOM(0x28) },
2170        { USB_DEVICE_WACOM(0x29) },
2171        { USB_DEVICE_WACOM(0x2A) },
2172        { USB_DEVICE_WACOM(0x3F) },
2173        { USB_DEVICE_WACOM(0xC5) },
2174        { USB_DEVICE_WACOM(0xC6) },
2175        { USB_DEVICE_WACOM(0xC7) },
2176        /*
2177         * DTU-2231 has two interfaces on the same configuration,
2178         * only one is used.
2179         */
2180        { USB_DEVICE_DETAILED(0xCE, USB_CLASS_HID,
2181                              USB_INTERFACE_SUBCLASS_BOOT,
2182                              USB_INTERFACE_PROTOCOL_MOUSE) },
2183        { USB_DEVICE_WACOM(0x84) },
2184        { USB_DEVICE_WACOM(0xD0) },
2185        { USB_DEVICE_WACOM(0xD1) },
2186        { USB_DEVICE_WACOM(0xD2) },
2187        { USB_DEVICE_WACOM(0xD3) },
2188        { USB_DEVICE_WACOM(0xD4) },
2189        { USB_DEVICE_WACOM(0xD5) },
2190        { USB_DEVICE_WACOM(0xD6) },
2191        { USB_DEVICE_WACOM(0xD7) },
2192        { USB_DEVICE_WACOM(0xD8) },
2193        { USB_DEVICE_WACOM(0xDA) },
2194        { USB_DEVICE_WACOM(0xDB) },
2195        { USB_DEVICE_WACOM(0xDD) },
2196        { USB_DEVICE_WACOM(0xDE) },
2197        { USB_DEVICE_WACOM(0xDF) },
2198        { USB_DEVICE_WACOM(0xF0) },
2199        { USB_DEVICE_WACOM(0xCC) },
2200        { USB_DEVICE_WACOM(0x90) },
2201        { USB_DEVICE_WACOM(0x93) },
2202        { USB_DEVICE_WACOM(0x97) },
2203        { USB_DEVICE_WACOM(0x9A) },
2204        { USB_DEVICE_WACOM(0x9F) },
2205        { USB_DEVICE_WACOM(0xE2) },
2206        { USB_DEVICE_WACOM(0xE3) },
2207        { USB_DEVICE_WACOM(0xE5) },
2208        { USB_DEVICE_WACOM(0xE6) },
2209        { USB_DEVICE_WACOM(0xEC) },
2210        { USB_DEVICE_WACOM(0xED) },
2211        { USB_DEVICE_WACOM(0xEF) },
2212        { USB_DEVICE_WACOM(0x100) },
2213        { USB_DEVICE_WACOM(0x101) },
2214        { USB_DEVICE_WACOM(0x4001) },
2215        { USB_DEVICE_WACOM(0x47) },
2216        { USB_DEVICE_WACOM(0xF4) },
2217        { USB_DEVICE_WACOM(0xF8) },
2218        { USB_DEVICE_WACOM(0xF6) },
2219        { USB_DEVICE_WACOM(0xFA) },
2220        { USB_DEVICE_LENOVO(0x6004) },
2221        { }
2222};
2223MODULE_DEVICE_TABLE(usb, wacom_ids);
2224