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