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