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