1 /* 2 * drivers/input/tablet/wacom_sys.c 3 * 4 * USB Wacom tablet support - system specific code 5 */ 6 7 /* 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 */ 13 14 #include "wacom_wac.h" 15 #include "wacom.h" 16 #include <linux/input/mt.h> 17 18 #define WAC_MSG_RETRIES 5 19 20 #define WAC_CMD_WL_LED_CONTROL 0x03 21 #define WAC_CMD_LED_CONTROL 0x20 22 #define WAC_CMD_ICON_START 0x21 23 #define WAC_CMD_ICON_XFER 0x23 24 #define WAC_CMD_ICON_BT_XFER 0x26 25 #define WAC_CMD_RETRIES 10 26 #define WAC_CMD_DELETE_PAIRING 0x20 27 #define WAC_CMD_UNPAIR_ALL 0xFF 28 #define WAC_REMOTE_SERIAL_MAX_STRLEN 9 29 30 #define DEV_ATTR_RW_PERM (S_IRUGO | S_IWUSR | S_IWGRP) 31 #define DEV_ATTR_WO_PERM (S_IWUSR | S_IWGRP) 32 #define DEV_ATTR_RO_PERM (S_IRUSR | S_IRGRP) 33 34 static int wacom_get_report(struct hid_device *hdev, u8 type, u8 *buf, 35 size_t size, unsigned int retries) 36 { 37 int retval; 38 39 do { 40 retval = hid_hw_raw_request(hdev, buf[0], buf, size, type, 41 HID_REQ_GET_REPORT); 42 } while ((retval == -ETIMEDOUT || retval == -EAGAIN) && --retries); 43 44 if (retval < 0) 45 hid_err(hdev, "wacom_get_report: ran out of retries " 46 "(last error = %d)\n", retval); 47 48 return retval; 49 } 50 51 static int wacom_set_report(struct hid_device *hdev, u8 type, u8 *buf, 52 size_t size, unsigned int retries) 53 { 54 int retval; 55 56 do { 57 retval = hid_hw_raw_request(hdev, buf[0], buf, size, type, 58 HID_REQ_SET_REPORT); 59 } while ((retval == -ETIMEDOUT || retval == -EAGAIN) && --retries); 60 61 if (retval < 0) 62 hid_err(hdev, "wacom_set_report: ran out of retries " 63 "(last error = %d)\n", retval); 64 65 return retval; 66 } 67 68 static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report, 69 u8 *raw_data, int size) 70 { 71 struct wacom *wacom = hid_get_drvdata(hdev); 72 73 if (size > WACOM_PKGLEN_MAX) 74 return 1; 75 76 memcpy(wacom->wacom_wac.data, raw_data, size); 77 78 wacom_wac_irq(&wacom->wacom_wac, size); 79 80 return 0; 81 } 82 83 static int wacom_open(struct input_dev *dev) 84 { 85 struct wacom *wacom = input_get_drvdata(dev); 86 87 return hid_hw_open(wacom->hdev); 88 } 89 90 static void wacom_close(struct input_dev *dev) 91 { 92 struct wacom *wacom = input_get_drvdata(dev); 93 94 hid_hw_close(wacom->hdev); 95 } 96 97 /* 98 * Calculate the resolution of the X or Y axis using hidinput_calc_abs_res. 99 */ 100 static int wacom_calc_hid_res(int logical_extents, int physical_extents, 101 unsigned unit, int exponent) 102 { 103 struct hid_field field = { 104 .logical_maximum = logical_extents, 105 .physical_maximum = physical_extents, 106 .unit = unit, 107 .unit_exponent = exponent, 108 }; 109 110 return hidinput_calc_abs_res(&field, ABS_X); 111 } 112 113 static void wacom_feature_mapping(struct hid_device *hdev, 114 struct hid_field *field, struct hid_usage *usage) 115 { 116 struct wacom *wacom = hid_get_drvdata(hdev); 117 struct wacom_features *features = &wacom->wacom_wac.features; 118 struct hid_data *hid_data = &wacom->wacom_wac.hid_data; 119 u8 *data; 120 int ret; 121 122 switch (usage->hid) { 123 case HID_DG_CONTACTMAX: 124 /* leave touch_max as is if predefined */ 125 if (!features->touch_max) { 126 /* read manually */ 127 data = kzalloc(2, GFP_KERNEL); 128 if (!data) 129 break; 130 data[0] = field->report->id; 131 ret = wacom_get_report(hdev, HID_FEATURE_REPORT, 132 data, 2, WAC_CMD_RETRIES); 133 if (ret == 2) { 134 features->touch_max = data[1]; 135 } else { 136 features->touch_max = 16; 137 hid_warn(hdev, "wacom_feature_mapping: " 138 "could not get HID_DG_CONTACTMAX, " 139 "defaulting to %d\n", 140 features->touch_max); 141 } 142 kfree(data); 143 } 144 break; 145 case HID_DG_INPUTMODE: 146 /* Ignore if value index is out of bounds. */ 147 if (usage->usage_index >= field->report_count) { 148 dev_err(&hdev->dev, "HID_DG_INPUTMODE out of range\n"); 149 break; 150 } 151 152 hid_data->inputmode = field->report->id; 153 hid_data->inputmode_index = usage->usage_index; 154 break; 155 156 case HID_UP_DIGITIZER: 157 if (field->report->id == 0x0B && 158 (field->application == WACOM_G9_DIGITIZER || 159 field->application == WACOM_G11_DIGITIZER)) { 160 wacom->wacom_wac.mode_report = field->report->id; 161 wacom->wacom_wac.mode_value = 0; 162 } 163 break; 164 165 case WACOM_G9_PAGE: 166 case WACOM_G11_PAGE: 167 if (field->report->id == 0x03 && 168 (field->application == WACOM_G9_TOUCHSCREEN || 169 field->application == WACOM_G11_TOUCHSCREEN)) { 170 wacom->wacom_wac.mode_report = field->report->id; 171 wacom->wacom_wac.mode_value = 0; 172 } 173 break; 174 } 175 } 176 177 /* 178 * Interface Descriptor of wacom devices can be incomplete and 179 * inconsistent so wacom_features table is used to store stylus 180 * device's packet lengths, various maximum values, and tablet 181 * resolution based on product ID's. 182 * 183 * For devices that contain 2 interfaces, wacom_features table is 184 * inaccurate for the touch interface. Since the Interface Descriptor 185 * for touch interfaces has pretty complete data, this function exists 186 * to query tablet for this missing information instead of hard coding in 187 * an additional table. 188 * 189 * A typical Interface Descriptor for a stylus will contain a 190 * boot mouse application collection that is not of interest and this 191 * function will ignore it. 192 * 193 * It also contains a digitizer application collection that also is not 194 * of interest since any information it contains would be duplicate 195 * of what is in wacom_features. Usually it defines a report of an array 196 * of bytes that could be used as max length of the stylus packet returned. 197 * If it happens to define a Digitizer-Stylus Physical Collection then 198 * the X and Y logical values contain valid data but it is ignored. 199 * 200 * A typical Interface Descriptor for a touch interface will contain a 201 * Digitizer-Finger Physical Collection which will define both logical 202 * X/Y maximum as well as the physical size of tablet. Since touch 203 * interfaces haven't supported pressure or distance, this is enough 204 * information to override invalid values in the wacom_features table. 205 * 206 * Intuos5 touch interface and 3rd gen Bamboo Touch do not contain useful 207 * data. We deal with them after returning from this function. 208 */ 209 static void wacom_usage_mapping(struct hid_device *hdev, 210 struct hid_field *field, struct hid_usage *usage) 211 { 212 struct wacom *wacom = hid_get_drvdata(hdev); 213 struct wacom_features *features = &wacom->wacom_wac.features; 214 bool finger = WACOM_FINGER_FIELD(field); 215 bool pen = WACOM_PEN_FIELD(field); 216 217 /* 218 * Requiring Stylus Usage will ignore boot mouse 219 * X/Y values and some cases of invalid Digitizer X/Y 220 * values commonly reported. 221 */ 222 if (pen) 223 features->device_type |= WACOM_DEVICETYPE_PEN; 224 else if (finger) 225 features->device_type |= WACOM_DEVICETYPE_TOUCH; 226 else 227 return; 228 229 /* 230 * Bamboo models do not support HID_DG_CONTACTMAX. 231 * And, Bamboo Pen only descriptor contains touch. 232 */ 233 if (features->type > BAMBOO_PT) { 234 /* ISDv4 touch devices at least supports one touch point */ 235 if (finger && !features->touch_max) 236 features->touch_max = 1; 237 } 238 239 switch (usage->hid) { 240 case HID_GD_X: 241 features->x_max = field->logical_maximum; 242 if (finger) { 243 features->x_phy = field->physical_maximum; 244 if ((features->type != BAMBOO_PT) && 245 (features->type != BAMBOO_TOUCH)) { 246 features->unit = field->unit; 247 features->unitExpo = field->unit_exponent; 248 } 249 } 250 break; 251 case HID_GD_Y: 252 features->y_max = field->logical_maximum; 253 if (finger) { 254 features->y_phy = field->physical_maximum; 255 if ((features->type != BAMBOO_PT) && 256 (features->type != BAMBOO_TOUCH)) { 257 features->unit = field->unit; 258 features->unitExpo = field->unit_exponent; 259 } 260 } 261 break; 262 case HID_DG_TIPPRESSURE: 263 if (pen) 264 features->pressure_max = field->logical_maximum; 265 break; 266 } 267 268 if (features->type == HID_GENERIC) 269 wacom_wac_usage_mapping(hdev, field, usage); 270 } 271 272 static void wacom_post_parse_hid(struct hid_device *hdev, 273 struct wacom_features *features) 274 { 275 struct wacom *wacom = hid_get_drvdata(hdev); 276 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 277 278 if (features->type == HID_GENERIC) { 279 /* Any last-minute generic device setup */ 280 if (features->touch_max > 1) { 281 input_mt_init_slots(wacom_wac->touch_input, wacom_wac->features.touch_max, 282 INPUT_MT_DIRECT); 283 } 284 } 285 } 286 287 static void wacom_parse_hid(struct hid_device *hdev, 288 struct wacom_features *features) 289 { 290 struct hid_report_enum *rep_enum; 291 struct hid_report *hreport; 292 int i, j; 293 294 /* check features first */ 295 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT]; 296 list_for_each_entry(hreport, &rep_enum->report_list, list) { 297 for (i = 0; i < hreport->maxfield; i++) { 298 /* Ignore if report count is out of bounds. */ 299 if (hreport->field[i]->report_count < 1) 300 continue; 301 302 for (j = 0; j < hreport->field[i]->maxusage; j++) { 303 wacom_feature_mapping(hdev, hreport->field[i], 304 hreport->field[i]->usage + j); 305 } 306 } 307 } 308 309 /* now check the input usages */ 310 rep_enum = &hdev->report_enum[HID_INPUT_REPORT]; 311 list_for_each_entry(hreport, &rep_enum->report_list, list) { 312 313 if (!hreport->maxfield) 314 continue; 315 316 for (i = 0; i < hreport->maxfield; i++) 317 for (j = 0; j < hreport->field[i]->maxusage; j++) 318 wacom_usage_mapping(hdev, hreport->field[i], 319 hreport->field[i]->usage + j); 320 } 321 322 wacom_post_parse_hid(hdev, features); 323 } 324 325 static int wacom_hid_set_device_mode(struct hid_device *hdev) 326 { 327 struct wacom *wacom = hid_get_drvdata(hdev); 328 struct hid_data *hid_data = &wacom->wacom_wac.hid_data; 329 struct hid_report *r; 330 struct hid_report_enum *re; 331 332 if (hid_data->inputmode < 0) 333 return 0; 334 335 re = &(hdev->report_enum[HID_FEATURE_REPORT]); 336 r = re->report_id_hash[hid_data->inputmode]; 337 if (r) { 338 r->field[0]->value[hid_data->inputmode_index] = 2; 339 hid_hw_request(hdev, r, HID_REQ_SET_REPORT); 340 } 341 return 0; 342 } 343 344 static int wacom_set_device_mode(struct hid_device *hdev, 345 struct wacom_wac *wacom_wac) 346 { 347 u8 *rep_data; 348 struct hid_report *r; 349 struct hid_report_enum *re; 350 int length; 351 int error = -ENOMEM, limit = 0; 352 353 if (wacom_wac->mode_report < 0) 354 return 0; 355 356 re = &(hdev->report_enum[HID_FEATURE_REPORT]); 357 r = re->report_id_hash[wacom_wac->mode_report]; 358 if (!r) 359 return -EINVAL; 360 361 rep_data = hid_alloc_report_buf(r, GFP_KERNEL); 362 if (!rep_data) 363 return -ENOMEM; 364 365 length = hid_report_len(r); 366 367 do { 368 rep_data[0] = wacom_wac->mode_report; 369 rep_data[1] = wacom_wac->mode_value; 370 371 error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 372 length, 1); 373 if (error >= 0) 374 error = wacom_get_report(hdev, HID_FEATURE_REPORT, 375 rep_data, length, 1); 376 } while (error >= 0 && 377 rep_data[1] != wacom_wac->mode_report && 378 limit++ < WAC_MSG_RETRIES); 379 380 kfree(rep_data); 381 382 return error < 0 ? error : 0; 383 } 384 385 static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed, 386 struct wacom_features *features) 387 { 388 struct wacom *wacom = hid_get_drvdata(hdev); 389 int ret; 390 u8 rep_data[2]; 391 392 switch (features->type) { 393 case GRAPHIRE_BT: 394 rep_data[0] = 0x03; 395 rep_data[1] = 0x00; 396 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2, 397 3); 398 399 if (ret >= 0) { 400 rep_data[0] = speed == 0 ? 0x05 : 0x06; 401 rep_data[1] = 0x00; 402 403 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, 404 rep_data, 2, 3); 405 406 if (ret >= 0) { 407 wacom->wacom_wac.bt_high_speed = speed; 408 return 0; 409 } 410 } 411 412 /* 413 * Note that if the raw queries fail, it's not a hard failure 414 * and it is safe to continue 415 */ 416 hid_warn(hdev, "failed to poke device, command %d, err %d\n", 417 rep_data[0], ret); 418 break; 419 case INTUOS4WL: 420 if (speed == 1) 421 wacom->wacom_wac.bt_features &= ~0x20; 422 else 423 wacom->wacom_wac.bt_features |= 0x20; 424 425 rep_data[0] = 0x03; 426 rep_data[1] = wacom->wacom_wac.bt_features; 427 428 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2, 429 1); 430 if (ret >= 0) 431 wacom->wacom_wac.bt_high_speed = speed; 432 break; 433 } 434 435 return 0; 436 } 437 438 /* 439 * Switch the tablet into its most-capable mode. Wacom tablets are 440 * typically configured to power-up in a mode which sends mouse-like 441 * reports to the OS. To get absolute position, pressure data, etc. 442 * from the tablet, it is necessary to switch the tablet out of this 443 * mode and into one which sends the full range of tablet data. 444 */ 445 static int wacom_query_tablet_data(struct hid_device *hdev, 446 struct wacom_features *features) 447 { 448 struct wacom *wacom = hid_get_drvdata(hdev); 449 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 450 451 if (hdev->bus == BUS_BLUETOOTH) 452 return wacom_bt_query_tablet_data(hdev, 1, features); 453 454 if (features->type != HID_GENERIC) { 455 if (features->device_type & WACOM_DEVICETYPE_TOUCH) { 456 if (features->type > TABLETPC) { 457 /* MT Tablet PC touch */ 458 wacom_wac->mode_report = 3; 459 wacom_wac->mode_value = 4; 460 } else if (features->type == WACOM_24HDT) { 461 wacom_wac->mode_report = 18; 462 wacom_wac->mode_value = 2; 463 } else if (features->type == WACOM_27QHDT) { 464 wacom_wac->mode_report = 131; 465 wacom_wac->mode_value = 2; 466 } else if (features->type == BAMBOO_PAD) { 467 wacom_wac->mode_report = 2; 468 wacom_wac->mode_value = 2; 469 } 470 } else if (features->device_type & WACOM_DEVICETYPE_PEN) { 471 if (features->type <= BAMBOO_PT) { 472 wacom_wac->mode_report = 2; 473 wacom_wac->mode_value = 2; 474 } 475 } 476 } 477 478 wacom_set_device_mode(hdev, wacom_wac); 479 480 if (features->type == HID_GENERIC) 481 return wacom_hid_set_device_mode(hdev); 482 483 return 0; 484 } 485 486 static void wacom_retrieve_hid_descriptor(struct hid_device *hdev, 487 struct wacom_features *features) 488 { 489 struct wacom *wacom = hid_get_drvdata(hdev); 490 struct usb_interface *intf = wacom->intf; 491 492 /* default features */ 493 features->x_fuzz = 4; 494 features->y_fuzz = 4; 495 features->pressure_fuzz = 0; 496 features->distance_fuzz = 1; 497 features->tilt_fuzz = 1; 498 499 /* 500 * The wireless device HID is basic and layout conflicts with 501 * other tablets (monitor and touch interface can look like pen). 502 * Skip the query for this type and modify defaults based on 503 * interface number. 504 */ 505 if (features->type == WIRELESS) { 506 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) 507 features->device_type = WACOM_DEVICETYPE_WL_MONITOR; 508 else 509 features->device_type = WACOM_DEVICETYPE_NONE; 510 return; 511 } 512 513 wacom_parse_hid(hdev, features); 514 } 515 516 struct wacom_hdev_data { 517 struct list_head list; 518 struct kref kref; 519 struct hid_device *dev; 520 struct wacom_shared shared; 521 }; 522 523 static LIST_HEAD(wacom_udev_list); 524 static DEFINE_MUTEX(wacom_udev_list_lock); 525 526 static bool wacom_are_sibling(struct hid_device *hdev, 527 struct hid_device *sibling) 528 { 529 struct wacom *wacom = hid_get_drvdata(hdev); 530 struct wacom_features *features = &wacom->wacom_wac.features; 531 int vid = features->oVid; 532 int pid = features->oPid; 533 int n1,n2; 534 535 if (vid == 0 && pid == 0) { 536 vid = hdev->vendor; 537 pid = hdev->product; 538 } 539 540 if (vid != sibling->vendor || pid != sibling->product) 541 return false; 542 543 /* Compare the physical path. */ 544 n1 = strrchr(hdev->phys, '.') - hdev->phys; 545 n2 = strrchr(sibling->phys, '.') - sibling->phys; 546 if (n1 != n2 || n1 <= 0 || n2 <= 0) 547 return false; 548 549 return !strncmp(hdev->phys, sibling->phys, n1); 550 } 551 552 static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev) 553 { 554 struct wacom_hdev_data *data; 555 556 list_for_each_entry(data, &wacom_udev_list, list) { 557 if (wacom_are_sibling(hdev, data->dev)) { 558 kref_get(&data->kref); 559 return data; 560 } 561 } 562 563 return NULL; 564 } 565 566 static int wacom_add_shared_data(struct hid_device *hdev) 567 { 568 struct wacom *wacom = hid_get_drvdata(hdev); 569 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 570 struct wacom_hdev_data *data; 571 int retval = 0; 572 573 mutex_lock(&wacom_udev_list_lock); 574 575 data = wacom_get_hdev_data(hdev); 576 if (!data) { 577 data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL); 578 if (!data) { 579 retval = -ENOMEM; 580 goto out; 581 } 582 583 kref_init(&data->kref); 584 data->dev = hdev; 585 list_add_tail(&data->list, &wacom_udev_list); 586 } 587 588 wacom_wac->shared = &data->shared; 589 590 if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH) 591 wacom_wac->shared->touch = hdev; 592 else if (wacom_wac->features.device_type & WACOM_DEVICETYPE_PEN) 593 wacom_wac->shared->pen = hdev; 594 595 out: 596 mutex_unlock(&wacom_udev_list_lock); 597 return retval; 598 } 599 600 static void wacom_release_shared_data(struct kref *kref) 601 { 602 struct wacom_hdev_data *data = 603 container_of(kref, struct wacom_hdev_data, kref); 604 605 mutex_lock(&wacom_udev_list_lock); 606 list_del(&data->list); 607 mutex_unlock(&wacom_udev_list_lock); 608 609 kfree(data); 610 } 611 612 static void wacom_remove_shared_data(struct wacom *wacom) 613 { 614 struct wacom_hdev_data *data; 615 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 616 617 if (wacom_wac->shared) { 618 data = container_of(wacom_wac->shared, struct wacom_hdev_data, 619 shared); 620 621 if (wacom_wac->shared->touch == wacom->hdev) 622 wacom_wac->shared->touch = NULL; 623 else if (wacom_wac->shared->pen == wacom->hdev) 624 wacom_wac->shared->pen = NULL; 625 626 kref_put(&data->kref, wacom_release_shared_data); 627 wacom_wac->shared = NULL; 628 } 629 } 630 631 static int wacom_led_control(struct wacom *wacom) 632 { 633 unsigned char *buf; 634 int retval; 635 unsigned char report_id = WAC_CMD_LED_CONTROL; 636 int buf_size = 9; 637 638 if (wacom->wacom_wac.pid) { /* wireless connected */ 639 report_id = WAC_CMD_WL_LED_CONTROL; 640 buf_size = 13; 641 } 642 buf = kzalloc(buf_size, GFP_KERNEL); 643 if (!buf) 644 return -ENOMEM; 645 646 if (wacom->wacom_wac.features.type >= INTUOS5S && 647 wacom->wacom_wac.features.type <= INTUOSPL) { 648 /* 649 * Touch Ring and crop mark LED luminance may take on 650 * one of four values: 651 * 0 = Low; 1 = Medium; 2 = High; 3 = Off 652 */ 653 int ring_led = wacom->led.select[0] & 0x03; 654 int ring_lum = (((wacom->led.llv & 0x60) >> 5) - 1) & 0x03; 655 int crop_lum = 0; 656 unsigned char led_bits = (crop_lum << 4) | (ring_lum << 2) | (ring_led); 657 658 buf[0] = report_id; 659 if (wacom->wacom_wac.pid) { 660 wacom_get_report(wacom->hdev, HID_FEATURE_REPORT, 661 buf, buf_size, WAC_CMD_RETRIES); 662 buf[0] = report_id; 663 buf[4] = led_bits; 664 } else 665 buf[1] = led_bits; 666 } 667 else { 668 int led = wacom->led.select[0] | 0x4; 669 670 if (wacom->wacom_wac.features.type == WACOM_21UX2 || 671 wacom->wacom_wac.features.type == WACOM_24HD) 672 led |= (wacom->led.select[1] << 4) | 0x40; 673 674 buf[0] = report_id; 675 buf[1] = led; 676 buf[2] = wacom->led.llv; 677 buf[3] = wacom->led.hlv; 678 buf[4] = wacom->led.img_lum; 679 } 680 681 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, buf_size, 682 WAC_CMD_RETRIES); 683 kfree(buf); 684 685 return retval; 686 } 687 688 static int wacom_led_putimage(struct wacom *wacom, int button_id, u8 xfer_id, 689 const unsigned len, const void *img) 690 { 691 unsigned char *buf; 692 int i, retval; 693 const unsigned chunk_len = len / 4; /* 4 chunks are needed to be sent */ 694 695 buf = kzalloc(chunk_len + 3 , GFP_KERNEL); 696 if (!buf) 697 return -ENOMEM; 698 699 /* Send 'start' command */ 700 buf[0] = WAC_CMD_ICON_START; 701 buf[1] = 1; 702 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2, 703 WAC_CMD_RETRIES); 704 if (retval < 0) 705 goto out; 706 707 buf[0] = xfer_id; 708 buf[1] = button_id & 0x07; 709 for (i = 0; i < 4; i++) { 710 buf[2] = i; 711 memcpy(buf + 3, img + i * chunk_len, chunk_len); 712 713 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, 714 buf, chunk_len + 3, WAC_CMD_RETRIES); 715 if (retval < 0) 716 break; 717 } 718 719 /* Send 'stop' */ 720 buf[0] = WAC_CMD_ICON_START; 721 buf[1] = 0; 722 wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2, 723 WAC_CMD_RETRIES); 724 725 out: 726 kfree(buf); 727 return retval; 728 } 729 730 static ssize_t wacom_led_select_store(struct device *dev, int set_id, 731 const char *buf, size_t count) 732 { 733 struct hid_device *hdev = to_hid_device(dev); 734 struct wacom *wacom = hid_get_drvdata(hdev); 735 unsigned int id; 736 int err; 737 738 err = kstrtouint(buf, 10, &id); 739 if (err) 740 return err; 741 742 mutex_lock(&wacom->lock); 743 744 wacom->led.select[set_id] = id & 0x3; 745 err = wacom_led_control(wacom); 746 747 mutex_unlock(&wacom->lock); 748 749 return err < 0 ? err : count; 750 } 751 752 #define DEVICE_LED_SELECT_ATTR(SET_ID) \ 753 static ssize_t wacom_led##SET_ID##_select_store(struct device *dev, \ 754 struct device_attribute *attr, const char *buf, size_t count) \ 755 { \ 756 return wacom_led_select_store(dev, SET_ID, buf, count); \ 757 } \ 758 static ssize_t wacom_led##SET_ID##_select_show(struct device *dev, \ 759 struct device_attribute *attr, char *buf) \ 760 { \ 761 struct hid_device *hdev = to_hid_device(dev);\ 762 struct wacom *wacom = hid_get_drvdata(hdev); \ 763 return scnprintf(buf, PAGE_SIZE, "%d\n", \ 764 wacom->led.select[SET_ID]); \ 765 } \ 766 static DEVICE_ATTR(status_led##SET_ID##_select, DEV_ATTR_RW_PERM, \ 767 wacom_led##SET_ID##_select_show, \ 768 wacom_led##SET_ID##_select_store) 769 770 DEVICE_LED_SELECT_ATTR(0); 771 DEVICE_LED_SELECT_ATTR(1); 772 773 static ssize_t wacom_luminance_store(struct wacom *wacom, u8 *dest, 774 const char *buf, size_t count) 775 { 776 unsigned int value; 777 int err; 778 779 err = kstrtouint(buf, 10, &value); 780 if (err) 781 return err; 782 783 mutex_lock(&wacom->lock); 784 785 *dest = value & 0x7f; 786 err = wacom_led_control(wacom); 787 788 mutex_unlock(&wacom->lock); 789 790 return err < 0 ? err : count; 791 } 792 793 #define DEVICE_LUMINANCE_ATTR(name, field) \ 794 static ssize_t wacom_##name##_luminance_store(struct device *dev, \ 795 struct device_attribute *attr, const char *buf, size_t count) \ 796 { \ 797 struct hid_device *hdev = to_hid_device(dev);\ 798 struct wacom *wacom = hid_get_drvdata(hdev); \ 799 \ 800 return wacom_luminance_store(wacom, &wacom->led.field, \ 801 buf, count); \ 802 } \ 803 static ssize_t wacom_##name##_luminance_show(struct device *dev, \ 804 struct device_attribute *attr, char *buf) \ 805 { \ 806 struct wacom *wacom = dev_get_drvdata(dev); \ 807 return scnprintf(buf, PAGE_SIZE, "%d\n", wacom->led.field); \ 808 } \ 809 static DEVICE_ATTR(name##_luminance, DEV_ATTR_RW_PERM, \ 810 wacom_##name##_luminance_show, \ 811 wacom_##name##_luminance_store) 812 813 DEVICE_LUMINANCE_ATTR(status0, llv); 814 DEVICE_LUMINANCE_ATTR(status1, hlv); 815 DEVICE_LUMINANCE_ATTR(buttons, img_lum); 816 817 static ssize_t wacom_button_image_store(struct device *dev, int button_id, 818 const char *buf, size_t count) 819 { 820 struct hid_device *hdev = to_hid_device(dev); 821 struct wacom *wacom = hid_get_drvdata(hdev); 822 int err; 823 unsigned len; 824 u8 xfer_id; 825 826 if (hdev->bus == BUS_BLUETOOTH) { 827 len = 256; 828 xfer_id = WAC_CMD_ICON_BT_XFER; 829 } else { 830 len = 1024; 831 xfer_id = WAC_CMD_ICON_XFER; 832 } 833 834 if (count != len) 835 return -EINVAL; 836 837 mutex_lock(&wacom->lock); 838 839 err = wacom_led_putimage(wacom, button_id, xfer_id, len, buf); 840 841 mutex_unlock(&wacom->lock); 842 843 return err < 0 ? err : count; 844 } 845 846 #define DEVICE_BTNIMG_ATTR(BUTTON_ID) \ 847 static ssize_t wacom_btnimg##BUTTON_ID##_store(struct device *dev, \ 848 struct device_attribute *attr, const char *buf, size_t count) \ 849 { \ 850 return wacom_button_image_store(dev, BUTTON_ID, buf, count); \ 851 } \ 852 static DEVICE_ATTR(button##BUTTON_ID##_rawimg, DEV_ATTR_WO_PERM, \ 853 NULL, wacom_btnimg##BUTTON_ID##_store) 854 855 DEVICE_BTNIMG_ATTR(0); 856 DEVICE_BTNIMG_ATTR(1); 857 DEVICE_BTNIMG_ATTR(2); 858 DEVICE_BTNIMG_ATTR(3); 859 DEVICE_BTNIMG_ATTR(4); 860 DEVICE_BTNIMG_ATTR(5); 861 DEVICE_BTNIMG_ATTR(6); 862 DEVICE_BTNIMG_ATTR(7); 863 864 static struct attribute *cintiq_led_attrs[] = { 865 &dev_attr_status_led0_select.attr, 866 &dev_attr_status_led1_select.attr, 867 NULL 868 }; 869 870 static struct attribute_group cintiq_led_attr_group = { 871 .name = "wacom_led", 872 .attrs = cintiq_led_attrs, 873 }; 874 875 static struct attribute *intuos4_led_attrs[] = { 876 &dev_attr_status0_luminance.attr, 877 &dev_attr_status1_luminance.attr, 878 &dev_attr_status_led0_select.attr, 879 &dev_attr_buttons_luminance.attr, 880 &dev_attr_button0_rawimg.attr, 881 &dev_attr_button1_rawimg.attr, 882 &dev_attr_button2_rawimg.attr, 883 &dev_attr_button3_rawimg.attr, 884 &dev_attr_button4_rawimg.attr, 885 &dev_attr_button5_rawimg.attr, 886 &dev_attr_button6_rawimg.attr, 887 &dev_attr_button7_rawimg.attr, 888 NULL 889 }; 890 891 static struct attribute_group intuos4_led_attr_group = { 892 .name = "wacom_led", 893 .attrs = intuos4_led_attrs, 894 }; 895 896 static struct attribute *intuos5_led_attrs[] = { 897 &dev_attr_status0_luminance.attr, 898 &dev_attr_status_led0_select.attr, 899 NULL 900 }; 901 902 static struct attribute_group intuos5_led_attr_group = { 903 .name = "wacom_led", 904 .attrs = intuos5_led_attrs, 905 }; 906 907 static int wacom_initialize_leds(struct wacom *wacom) 908 { 909 int error; 910 911 if (!(wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD)) 912 return 0; 913 914 /* Initialize default values */ 915 switch (wacom->wacom_wac.features.type) { 916 case INTUOS4S: 917 case INTUOS4: 918 case INTUOS4WL: 919 case INTUOS4L: 920 wacom->led.select[0] = 0; 921 wacom->led.select[1] = 0; 922 wacom->led.llv = 10; 923 wacom->led.hlv = 20; 924 wacom->led.img_lum = 10; 925 error = sysfs_create_group(&wacom->hdev->dev.kobj, 926 &intuos4_led_attr_group); 927 break; 928 929 case WACOM_24HD: 930 case WACOM_21UX2: 931 wacom->led.select[0] = 0; 932 wacom->led.select[1] = 0; 933 wacom->led.llv = 0; 934 wacom->led.hlv = 0; 935 wacom->led.img_lum = 0; 936 937 error = sysfs_create_group(&wacom->hdev->dev.kobj, 938 &cintiq_led_attr_group); 939 break; 940 941 case INTUOS5S: 942 case INTUOS5: 943 case INTUOS5L: 944 case INTUOSPS: 945 case INTUOSPM: 946 case INTUOSPL: 947 wacom->led.select[0] = 0; 948 wacom->led.select[1] = 0; 949 wacom->led.llv = 32; 950 wacom->led.hlv = 0; 951 wacom->led.img_lum = 0; 952 953 error = sysfs_create_group(&wacom->hdev->dev.kobj, 954 &intuos5_led_attr_group); 955 break; 956 957 default: 958 return 0; 959 } 960 961 if (error) { 962 hid_err(wacom->hdev, 963 "cannot create sysfs group err: %d\n", error); 964 return error; 965 } 966 wacom_led_control(wacom); 967 wacom->led_initialized = true; 968 969 return 0; 970 } 971 972 static void wacom_destroy_leds(struct wacom *wacom) 973 { 974 if (!wacom->led_initialized) 975 return; 976 977 if (!(wacom->wacom_wac.features.device_type & WACOM_DEVICETYPE_PAD)) 978 return; 979 980 wacom->led_initialized = false; 981 982 switch (wacom->wacom_wac.features.type) { 983 case INTUOS4S: 984 case INTUOS4: 985 case INTUOS4WL: 986 case INTUOS4L: 987 sysfs_remove_group(&wacom->hdev->dev.kobj, 988 &intuos4_led_attr_group); 989 break; 990 991 case WACOM_24HD: 992 case WACOM_21UX2: 993 sysfs_remove_group(&wacom->hdev->dev.kobj, 994 &cintiq_led_attr_group); 995 break; 996 997 case INTUOS5S: 998 case INTUOS5: 999 case INTUOS5L: 1000 case INTUOSPS: 1001 case INTUOSPM: 1002 case INTUOSPL: 1003 sysfs_remove_group(&wacom->hdev->dev.kobj, 1004 &intuos5_led_attr_group); 1005 break; 1006 } 1007 } 1008 1009 static enum power_supply_property wacom_battery_props[] = { 1010 POWER_SUPPLY_PROP_PRESENT, 1011 POWER_SUPPLY_PROP_STATUS, 1012 POWER_SUPPLY_PROP_SCOPE, 1013 POWER_SUPPLY_PROP_CAPACITY 1014 }; 1015 1016 static enum power_supply_property wacom_ac_props[] = { 1017 POWER_SUPPLY_PROP_PRESENT, 1018 POWER_SUPPLY_PROP_ONLINE, 1019 POWER_SUPPLY_PROP_SCOPE, 1020 }; 1021 1022 static int wacom_battery_get_property(struct power_supply *psy, 1023 enum power_supply_property psp, 1024 union power_supply_propval *val) 1025 { 1026 struct wacom *wacom = power_supply_get_drvdata(psy); 1027 int ret = 0; 1028 1029 switch (psp) { 1030 case POWER_SUPPLY_PROP_PRESENT: 1031 val->intval = wacom->wacom_wac.bat_connected; 1032 break; 1033 case POWER_SUPPLY_PROP_SCOPE: 1034 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 1035 break; 1036 case POWER_SUPPLY_PROP_CAPACITY: 1037 val->intval = 1038 wacom->wacom_wac.battery_capacity; 1039 break; 1040 case POWER_SUPPLY_PROP_STATUS: 1041 if (wacom->wacom_wac.bat_charging) 1042 val->intval = POWER_SUPPLY_STATUS_CHARGING; 1043 else if (wacom->wacom_wac.battery_capacity == 100 && 1044 wacom->wacom_wac.ps_connected) 1045 val->intval = POWER_SUPPLY_STATUS_FULL; 1046 else if (wacom->wacom_wac.ps_connected) 1047 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 1048 else 1049 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 1050 break; 1051 default: 1052 ret = -EINVAL; 1053 break; 1054 } 1055 1056 return ret; 1057 } 1058 1059 static int wacom_ac_get_property(struct power_supply *psy, 1060 enum power_supply_property psp, 1061 union power_supply_propval *val) 1062 { 1063 struct wacom *wacom = power_supply_get_drvdata(psy); 1064 int ret = 0; 1065 1066 switch (psp) { 1067 case POWER_SUPPLY_PROP_PRESENT: 1068 /* fall through */ 1069 case POWER_SUPPLY_PROP_ONLINE: 1070 val->intval = wacom->wacom_wac.ps_connected; 1071 break; 1072 case POWER_SUPPLY_PROP_SCOPE: 1073 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 1074 break; 1075 default: 1076 ret = -EINVAL; 1077 break; 1078 } 1079 return ret; 1080 } 1081 1082 static int wacom_initialize_battery(struct wacom *wacom) 1083 { 1084 static atomic_t battery_no = ATOMIC_INIT(0); 1085 struct power_supply_config psy_cfg = { .drv_data = wacom, }; 1086 unsigned long n; 1087 1088 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) { 1089 struct power_supply_desc *bat_desc = &wacom->battery_desc; 1090 struct power_supply_desc *ac_desc = &wacom->ac_desc; 1091 n = atomic_inc_return(&battery_no) - 1; 1092 1093 bat_desc->properties = wacom_battery_props; 1094 bat_desc->num_properties = ARRAY_SIZE(wacom_battery_props); 1095 bat_desc->get_property = wacom_battery_get_property; 1096 sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n); 1097 bat_desc->name = wacom->wacom_wac.bat_name; 1098 bat_desc->type = POWER_SUPPLY_TYPE_BATTERY; 1099 bat_desc->use_for_apm = 0; 1100 1101 ac_desc->properties = wacom_ac_props; 1102 ac_desc->num_properties = ARRAY_SIZE(wacom_ac_props); 1103 ac_desc->get_property = wacom_ac_get_property; 1104 sprintf(wacom->wacom_wac.ac_name, "wacom_ac_%ld", n); 1105 ac_desc->name = wacom->wacom_wac.ac_name; 1106 ac_desc->type = POWER_SUPPLY_TYPE_MAINS; 1107 ac_desc->use_for_apm = 0; 1108 1109 wacom->battery = power_supply_register(&wacom->hdev->dev, 1110 &wacom->battery_desc, &psy_cfg); 1111 if (IS_ERR(wacom->battery)) 1112 return PTR_ERR(wacom->battery); 1113 1114 power_supply_powers(wacom->battery, &wacom->hdev->dev); 1115 1116 wacom->ac = power_supply_register(&wacom->hdev->dev, 1117 &wacom->ac_desc, 1118 &psy_cfg); 1119 if (IS_ERR(wacom->ac)) { 1120 power_supply_unregister(wacom->battery); 1121 return PTR_ERR(wacom->ac); 1122 } 1123 1124 power_supply_powers(wacom->ac, &wacom->hdev->dev); 1125 } 1126 1127 return 0; 1128 } 1129 1130 static void wacom_destroy_battery(struct wacom *wacom) 1131 { 1132 if (wacom->battery) { 1133 power_supply_unregister(wacom->battery); 1134 wacom->battery = NULL; 1135 power_supply_unregister(wacom->ac); 1136 wacom->ac = NULL; 1137 } 1138 } 1139 1140 static ssize_t wacom_show_speed(struct device *dev, 1141 struct device_attribute 1142 *attr, char *buf) 1143 { 1144 struct hid_device *hdev = to_hid_device(dev); 1145 struct wacom *wacom = hid_get_drvdata(hdev); 1146 1147 return snprintf(buf, PAGE_SIZE, "%i\n", wacom->wacom_wac.bt_high_speed); 1148 } 1149 1150 static ssize_t wacom_store_speed(struct device *dev, 1151 struct device_attribute *attr, 1152 const char *buf, size_t count) 1153 { 1154 struct hid_device *hdev = to_hid_device(dev); 1155 struct wacom *wacom = hid_get_drvdata(hdev); 1156 u8 new_speed; 1157 1158 if (kstrtou8(buf, 0, &new_speed)) 1159 return -EINVAL; 1160 1161 if (new_speed != 0 && new_speed != 1) 1162 return -EINVAL; 1163 1164 wacom_bt_query_tablet_data(hdev, new_speed, &wacom->wacom_wac.features); 1165 1166 return count; 1167 } 1168 1169 static DEVICE_ATTR(speed, DEV_ATTR_RW_PERM, 1170 wacom_show_speed, wacom_store_speed); 1171 1172 1173 static ssize_t wacom_show_remote_mode(struct kobject *kobj, 1174 struct kobj_attribute *kattr, 1175 char *buf, int index) 1176 { 1177 struct device *dev = kobj_to_dev(kobj->parent); 1178 struct hid_device *hdev = to_hid_device(dev); 1179 struct wacom *wacom = hid_get_drvdata(hdev); 1180 u8 mode; 1181 1182 mode = wacom->led.select[index]; 1183 if (mode >= 0 && mode < 3) 1184 return snprintf(buf, PAGE_SIZE, "%d\n", mode); 1185 else 1186 return snprintf(buf, PAGE_SIZE, "%d\n", -1); 1187 } 1188 1189 #define DEVICE_EKR_ATTR_GROUP(SET_ID) \ 1190 static ssize_t wacom_show_remote##SET_ID##_mode(struct kobject *kobj, \ 1191 struct kobj_attribute *kattr, char *buf) \ 1192 { \ 1193 return wacom_show_remote_mode(kobj, kattr, buf, SET_ID); \ 1194 } \ 1195 static struct kobj_attribute remote##SET_ID##_mode_attr = { \ 1196 .attr = {.name = "remote_mode", \ 1197 .mode = DEV_ATTR_RO_PERM}, \ 1198 .show = wacom_show_remote##SET_ID##_mode, \ 1199 }; \ 1200 static struct attribute *remote##SET_ID##_serial_attrs[] = { \ 1201 &remote##SET_ID##_mode_attr.attr, \ 1202 NULL \ 1203 }; \ 1204 static struct attribute_group remote##SET_ID##_serial_group = { \ 1205 .name = NULL, \ 1206 .attrs = remote##SET_ID##_serial_attrs, \ 1207 } 1208 1209 DEVICE_EKR_ATTR_GROUP(0); 1210 DEVICE_EKR_ATTR_GROUP(1); 1211 DEVICE_EKR_ATTR_GROUP(2); 1212 DEVICE_EKR_ATTR_GROUP(3); 1213 DEVICE_EKR_ATTR_GROUP(4); 1214 1215 int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial, int index) 1216 { 1217 int error = 0; 1218 char *buf; 1219 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 1220 1221 wacom_wac->serial[index] = serial; 1222 1223 buf = kzalloc(WAC_REMOTE_SERIAL_MAX_STRLEN, GFP_KERNEL); 1224 if (!buf) 1225 return -ENOMEM; 1226 snprintf(buf, WAC_REMOTE_SERIAL_MAX_STRLEN, "%d", serial); 1227 wacom->remote_group[index].name = buf; 1228 1229 error = sysfs_create_group(wacom->remote_dir, 1230 &wacom->remote_group[index]); 1231 if (error) { 1232 hid_err(wacom->hdev, 1233 "cannot create sysfs group err: %d\n", error); 1234 kobject_put(wacom->remote_dir); 1235 return error; 1236 } 1237 1238 return 0; 1239 } 1240 1241 void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial) 1242 { 1243 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 1244 int i; 1245 1246 if (!serial) 1247 return; 1248 1249 for (i = 0; i < WACOM_MAX_REMOTES; i++) { 1250 if (wacom_wac->serial[i] == serial) { 1251 wacom_wac->serial[i] = 0; 1252 wacom->led.select[i] = WACOM_STATUS_UNKNOWN; 1253 if (wacom->remote_group[i].name) { 1254 sysfs_remove_group(wacom->remote_dir, 1255 &wacom->remote_group[i]); 1256 kfree(wacom->remote_group[i].name); 1257 wacom->remote_group[i].name = NULL; 1258 } 1259 } 1260 } 1261 } 1262 1263 static int wacom_cmd_unpair_remote(struct wacom *wacom, unsigned char selector) 1264 { 1265 const size_t buf_size = 2; 1266 unsigned char *buf; 1267 int retval; 1268 1269 buf = kzalloc(buf_size, GFP_KERNEL); 1270 if (!buf) 1271 return -ENOMEM; 1272 1273 buf[0] = WAC_CMD_DELETE_PAIRING; 1274 buf[1] = selector; 1275 1276 retval = wacom_set_report(wacom->hdev, HID_OUTPUT_REPORT, buf, 1277 buf_size, WAC_CMD_RETRIES); 1278 kfree(buf); 1279 1280 return retval; 1281 } 1282 1283 static ssize_t wacom_store_unpair_remote(struct kobject *kobj, 1284 struct kobj_attribute *attr, 1285 const char *buf, size_t count) 1286 { 1287 unsigned char selector = 0; 1288 struct device *dev = kobj_to_dev(kobj->parent); 1289 struct hid_device *hdev = to_hid_device(dev); 1290 struct wacom *wacom = hid_get_drvdata(hdev); 1291 int err; 1292 1293 if (!strncmp(buf, "*\n", 2)) { 1294 selector = WAC_CMD_UNPAIR_ALL; 1295 } else { 1296 hid_info(wacom->hdev, "remote: unrecognized unpair code: %s\n", 1297 buf); 1298 return -1; 1299 } 1300 1301 mutex_lock(&wacom->lock); 1302 1303 err = wacom_cmd_unpair_remote(wacom, selector); 1304 mutex_unlock(&wacom->lock); 1305 1306 return err < 0 ? err : count; 1307 } 1308 1309 static struct kobj_attribute unpair_remote_attr = { 1310 .attr = {.name = "unpair_remote", .mode = 0200}, 1311 .store = wacom_store_unpair_remote, 1312 }; 1313 1314 static const struct attribute *remote_unpair_attrs[] = { 1315 &unpair_remote_attr.attr, 1316 NULL 1317 }; 1318 1319 static int wacom_initialize_remote(struct wacom *wacom) 1320 { 1321 int error = 0; 1322 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); 1323 int i; 1324 1325 if (wacom->wacom_wac.features.type != REMOTE) 1326 return 0; 1327 1328 wacom->remote_group[0] = remote0_serial_group; 1329 wacom->remote_group[1] = remote1_serial_group; 1330 wacom->remote_group[2] = remote2_serial_group; 1331 wacom->remote_group[3] = remote3_serial_group; 1332 wacom->remote_group[4] = remote4_serial_group; 1333 1334 wacom->remote_dir = kobject_create_and_add("wacom_remote", 1335 &wacom->hdev->dev.kobj); 1336 if (!wacom->remote_dir) 1337 return -ENOMEM; 1338 1339 error = sysfs_create_files(wacom->remote_dir, remote_unpair_attrs); 1340 1341 if (error) { 1342 hid_err(wacom->hdev, 1343 "cannot create sysfs group err: %d\n", error); 1344 return error; 1345 } 1346 1347 for (i = 0; i < WACOM_MAX_REMOTES; i++) { 1348 wacom->led.select[i] = WACOM_STATUS_UNKNOWN; 1349 wacom_wac->serial[i] = 0; 1350 } 1351 1352 return 0; 1353 } 1354 1355 static struct input_dev *wacom_allocate_input(struct wacom *wacom) 1356 { 1357 struct input_dev *input_dev; 1358 struct hid_device *hdev = wacom->hdev; 1359 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); 1360 1361 input_dev = input_allocate_device(); 1362 if (!input_dev) 1363 return NULL; 1364 1365 input_dev->name = wacom_wac->features.name; 1366 input_dev->phys = hdev->phys; 1367 input_dev->dev.parent = &hdev->dev; 1368 input_dev->open = wacom_open; 1369 input_dev->close = wacom_close; 1370 input_dev->uniq = hdev->uniq; 1371 input_dev->id.bustype = hdev->bus; 1372 input_dev->id.vendor = hdev->vendor; 1373 input_dev->id.product = wacom_wac->pid ? wacom_wac->pid : hdev->product; 1374 input_dev->id.version = hdev->version; 1375 input_set_drvdata(input_dev, wacom); 1376 1377 return input_dev; 1378 } 1379 1380 static void wacom_clean_inputs(struct wacom *wacom) 1381 { 1382 if (wacom->wacom_wac.pen_input) { 1383 if (wacom->wacom_wac.pen_registered) 1384 input_unregister_device(wacom->wacom_wac.pen_input); 1385 else 1386 input_free_device(wacom->wacom_wac.pen_input); 1387 } 1388 if (wacom->wacom_wac.touch_input) { 1389 if (wacom->wacom_wac.touch_registered) 1390 input_unregister_device(wacom->wacom_wac.touch_input); 1391 else 1392 input_free_device(wacom->wacom_wac.touch_input); 1393 } 1394 if (wacom->wacom_wac.pad_input) { 1395 if (wacom->wacom_wac.pad_registered) 1396 input_unregister_device(wacom->wacom_wac.pad_input); 1397 else 1398 input_free_device(wacom->wacom_wac.pad_input); 1399 } 1400 kobject_put(wacom->remote_dir); 1401 wacom->wacom_wac.pen_input = NULL; 1402 wacom->wacom_wac.touch_input = NULL; 1403 wacom->wacom_wac.pad_input = NULL; 1404 wacom->wacom_wac.pen_registered = false; 1405 wacom->wacom_wac.touch_registered = false; 1406 wacom->wacom_wac.pad_registered = false; 1407 wacom_destroy_leds(wacom); 1408 } 1409 1410 static int wacom_allocate_inputs(struct wacom *wacom) 1411 { 1412 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); 1413 1414 wacom_wac->pen_input = wacom_allocate_input(wacom); 1415 wacom_wac->touch_input = wacom_allocate_input(wacom); 1416 wacom_wac->pad_input = wacom_allocate_input(wacom); 1417 if (!wacom_wac->pen_input || !wacom_wac->touch_input || !wacom_wac->pad_input) { 1418 wacom_clean_inputs(wacom); 1419 return -ENOMEM; 1420 } 1421 1422 wacom_wac->pen_input->name = wacom_wac->pen_name; 1423 wacom_wac->touch_input->name = wacom_wac->touch_name; 1424 wacom_wac->pad_input->name = wacom_wac->pad_name; 1425 1426 return 0; 1427 } 1428 1429 static int wacom_register_inputs(struct wacom *wacom) 1430 { 1431 struct input_dev *pen_input_dev, *touch_input_dev, *pad_input_dev; 1432 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); 1433 int error = 0; 1434 1435 pen_input_dev = wacom_wac->pen_input; 1436 touch_input_dev = wacom_wac->touch_input; 1437 pad_input_dev = wacom_wac->pad_input; 1438 1439 if (!pen_input_dev || !touch_input_dev || !pad_input_dev) 1440 return -EINVAL; 1441 1442 error = wacom_setup_pen_input_capabilities(pen_input_dev, wacom_wac); 1443 if (error) { 1444 /* no pen in use on this interface */ 1445 input_free_device(pen_input_dev); 1446 wacom_wac->pen_input = NULL; 1447 pen_input_dev = NULL; 1448 } else { 1449 error = input_register_device(pen_input_dev); 1450 if (error) 1451 goto fail_register_pen_input; 1452 wacom_wac->pen_registered = true; 1453 } 1454 1455 error = wacom_setup_touch_input_capabilities(touch_input_dev, wacom_wac); 1456 if (error) { 1457 /* no touch in use on this interface */ 1458 input_free_device(touch_input_dev); 1459 wacom_wac->touch_input = NULL; 1460 touch_input_dev = NULL; 1461 } else { 1462 error = input_register_device(touch_input_dev); 1463 if (error) 1464 goto fail_register_touch_input; 1465 wacom_wac->touch_registered = true; 1466 } 1467 1468 error = wacom_setup_pad_input_capabilities(pad_input_dev, wacom_wac); 1469 if (error) { 1470 /* no pad in use on this interface */ 1471 input_free_device(pad_input_dev); 1472 wacom_wac->pad_input = NULL; 1473 pad_input_dev = NULL; 1474 } else { 1475 error = input_register_device(pad_input_dev); 1476 if (error) 1477 goto fail_register_pad_input; 1478 wacom_wac->pad_registered = true; 1479 1480 error = wacom_initialize_leds(wacom); 1481 if (error) 1482 goto fail_leds; 1483 1484 error = wacom_initialize_remote(wacom); 1485 if (error) 1486 goto fail_remote; 1487 } 1488 1489 return 0; 1490 1491 fail_remote: 1492 wacom_destroy_leds(wacom); 1493 fail_leds: 1494 input_unregister_device(pad_input_dev); 1495 pad_input_dev = NULL; 1496 wacom_wac->pad_registered = false; 1497 fail_register_pad_input: 1498 if (touch_input_dev) 1499 input_unregister_device(touch_input_dev); 1500 wacom_wac->touch_input = NULL; 1501 wacom_wac->touch_registered = false; 1502 fail_register_touch_input: 1503 if (pen_input_dev) 1504 input_unregister_device(pen_input_dev); 1505 wacom_wac->pen_input = NULL; 1506 wacom_wac->pen_registered = false; 1507 fail_register_pen_input: 1508 return error; 1509 } 1510 1511 /* 1512 * Not all devices report physical dimensions from HID. 1513 * Compute the default from hardcoded logical dimension 1514 * and resolution before driver overwrites them. 1515 */ 1516 static void wacom_set_default_phy(struct wacom_features *features) 1517 { 1518 if (features->x_resolution) { 1519 features->x_phy = (features->x_max * 100) / 1520 features->x_resolution; 1521 features->y_phy = (features->y_max * 100) / 1522 features->y_resolution; 1523 } 1524 } 1525 1526 static void wacom_calculate_res(struct wacom_features *features) 1527 { 1528 /* set unit to "100th of a mm" for devices not reported by HID */ 1529 if (!features->unit) { 1530 features->unit = 0x11; 1531 features->unitExpo = -3; 1532 } 1533 1534 features->x_resolution = wacom_calc_hid_res(features->x_max, 1535 features->x_phy, 1536 features->unit, 1537 features->unitExpo); 1538 features->y_resolution = wacom_calc_hid_res(features->y_max, 1539 features->y_phy, 1540 features->unit, 1541 features->unitExpo); 1542 } 1543 1544 void wacom_battery_work(struct work_struct *work) 1545 { 1546 struct wacom *wacom = container_of(work, struct wacom, work); 1547 1548 if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) && 1549 !wacom->battery) { 1550 wacom_initialize_battery(wacom); 1551 } 1552 else if (!(wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) && 1553 wacom->battery) { 1554 wacom_destroy_battery(wacom); 1555 } 1556 } 1557 1558 static size_t wacom_compute_pktlen(struct hid_device *hdev) 1559 { 1560 struct hid_report_enum *report_enum; 1561 struct hid_report *report; 1562 size_t size = 0; 1563 1564 report_enum = hdev->report_enum + HID_INPUT_REPORT; 1565 1566 list_for_each_entry(report, &report_enum->report_list, list) { 1567 size_t report_size = hid_report_len(report); 1568 if (report_size > size) 1569 size = report_size; 1570 } 1571 1572 return size; 1573 } 1574 1575 static void wacom_update_name(struct wacom *wacom, const char *suffix) 1576 { 1577 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 1578 struct wacom_features *features = &wacom_wac->features; 1579 char name[WACOM_NAME_MAX]; 1580 1581 /* Generic devices name unspecified */ 1582 if ((features->type == HID_GENERIC) && !strcmp("Wacom HID", features->name)) { 1583 if (strstr(wacom->hdev->name, "Wacom") || 1584 strstr(wacom->hdev->name, "wacom") || 1585 strstr(wacom->hdev->name, "WACOM")) { 1586 /* name is in HID descriptor, use it */ 1587 strlcpy(name, wacom->hdev->name, sizeof(name)); 1588 1589 /* strip out excess whitespaces */ 1590 while (1) { 1591 char *gap = strstr(name, " "); 1592 if (gap == NULL) 1593 break; 1594 /* shift everything including the terminator */ 1595 memmove(gap, gap+1, strlen(gap)); 1596 } 1597 /* get rid of trailing whitespace */ 1598 if (name[strlen(name)-1] == ' ') 1599 name[strlen(name)-1] = '\0'; 1600 } else { 1601 /* no meaningful name retrieved. use product ID */ 1602 snprintf(name, sizeof(name), 1603 "%s %X", features->name, wacom->hdev->product); 1604 } 1605 } else { 1606 strlcpy(name, features->name, sizeof(name)); 1607 } 1608 1609 /* Append the device type to the name */ 1610 snprintf(wacom_wac->pen_name, sizeof(wacom_wac->pen_name), 1611 "%s%s Pen", name, suffix); 1612 snprintf(wacom_wac->touch_name, sizeof(wacom_wac->touch_name), 1613 "%s%s Finger", name, suffix); 1614 snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name), 1615 "%s%s Pad", name, suffix); 1616 } 1617 1618 static int wacom_parse_and_register(struct wacom *wacom, bool wireless) 1619 { 1620 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 1621 struct wacom_features *features = &wacom_wac->features; 1622 struct hid_device *hdev = wacom->hdev; 1623 int error; 1624 unsigned int connect_mask = HID_CONNECT_HIDRAW; 1625 1626 features->pktlen = wacom_compute_pktlen(hdev); 1627 if (features->pktlen > WACOM_PKGLEN_MAX) 1628 return -EINVAL; 1629 1630 error = wacom_allocate_inputs(wacom); 1631 if (error) 1632 return error; 1633 1634 /* 1635 * Bamboo Pad has a generic hid handling for the Pen, and we switch it 1636 * into debug mode for the touch part. 1637 * We ignore the other interfaces. 1638 */ 1639 if (features->type == BAMBOO_PAD) { 1640 if (features->pktlen == WACOM_PKGLEN_PENABLED) { 1641 features->type = HID_GENERIC; 1642 } else if ((features->pktlen != WACOM_PKGLEN_BPAD_TOUCH) && 1643 (features->pktlen != WACOM_PKGLEN_BPAD_TOUCH_USB)) { 1644 error = -ENODEV; 1645 goto fail_allocate_inputs; 1646 } 1647 } 1648 1649 /* set the default size in case we do not get them from hid */ 1650 wacom_set_default_phy(features); 1651 1652 /* Retrieve the physical and logical size for touch devices */ 1653 wacom_retrieve_hid_descriptor(hdev, features); 1654 wacom_setup_device_quirks(wacom); 1655 1656 if (features->device_type == WACOM_DEVICETYPE_NONE && 1657 features->type != WIRELESS) { 1658 error = features->type == HID_GENERIC ? -ENODEV : 0; 1659 1660 dev_warn(&hdev->dev, "Unknown device_type for '%s'. %s.", 1661 hdev->name, 1662 error ? "Ignoring" : "Assuming pen"); 1663 1664 if (error) 1665 goto fail_parsed; 1666 1667 features->device_type |= WACOM_DEVICETYPE_PEN; 1668 } 1669 1670 wacom_calculate_res(features); 1671 1672 wacom_update_name(wacom, wireless ? " (WL)" : ""); 1673 1674 error = wacom_add_shared_data(hdev); 1675 if (error) 1676 goto fail_shared_data; 1677 1678 if (!(features->device_type & WACOM_DEVICETYPE_WL_MONITOR) && 1679 (features->quirks & WACOM_QUIRK_BATTERY)) { 1680 error = wacom_initialize_battery(wacom); 1681 if (error) 1682 goto fail_battery; 1683 } 1684 1685 error = wacom_register_inputs(wacom); 1686 if (error) 1687 goto fail_register_inputs; 1688 1689 if (features->type == HID_GENERIC) 1690 connect_mask |= HID_CONNECT_DRIVER; 1691 1692 /* Regular HID work starts now */ 1693 error = hid_hw_start(hdev, connect_mask); 1694 if (error) { 1695 hid_err(hdev, "hw start failed\n"); 1696 goto fail_hw_start; 1697 } 1698 1699 if (!wireless) { 1700 /* Note that if query fails it is not a hard failure */ 1701 wacom_query_tablet_data(hdev, features); 1702 } 1703 1704 /* touch only Bamboo doesn't support pen */ 1705 if ((features->type == BAMBOO_TOUCH) && 1706 (features->device_type & WACOM_DEVICETYPE_PEN)) { 1707 error = -ENODEV; 1708 goto fail_hw_start; 1709 } 1710 1711 /* pen only Bamboo neither support touch nor pad */ 1712 if ((features->type == BAMBOO_PEN) && 1713 ((features->device_type & WACOM_DEVICETYPE_TOUCH) || 1714 (features->device_type & WACOM_DEVICETYPE_PAD))) { 1715 error = -ENODEV; 1716 goto fail_hw_start; 1717 } 1718 1719 if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR) 1720 error = hid_hw_open(hdev); 1721 1722 if ((wacom_wac->features.type == INTUOSHT || 1723 wacom_wac->features.type == INTUOSHT2) && 1724 (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH)) { 1725 wacom_wac->shared->touch_input = wacom_wac->touch_input; 1726 } 1727 1728 return 0; 1729 1730 fail_hw_start: 1731 hid_hw_stop(hdev); 1732 fail_register_inputs: 1733 wacom_clean_inputs(wacom); 1734 wacom_destroy_battery(wacom); 1735 fail_battery: 1736 wacom_remove_shared_data(wacom); 1737 fail_shared_data: 1738 fail_parsed: 1739 fail_allocate_inputs: 1740 wacom_clean_inputs(wacom); 1741 return error; 1742 } 1743 1744 static void wacom_wireless_work(struct work_struct *work) 1745 { 1746 struct wacom *wacom = container_of(work, struct wacom, work); 1747 struct usb_device *usbdev = wacom->usbdev; 1748 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 1749 struct hid_device *hdev1, *hdev2; 1750 struct wacom *wacom1, *wacom2; 1751 struct wacom_wac *wacom_wac1, *wacom_wac2; 1752 int error; 1753 1754 /* 1755 * Regardless if this is a disconnect or a new tablet, 1756 * remove any existing input and battery devices. 1757 */ 1758 1759 wacom_destroy_battery(wacom); 1760 1761 /* Stylus interface */ 1762 hdev1 = usb_get_intfdata(usbdev->config->interface[1]); 1763 wacom1 = hid_get_drvdata(hdev1); 1764 wacom_wac1 = &(wacom1->wacom_wac); 1765 wacom_clean_inputs(wacom1); 1766 1767 /* Touch interface */ 1768 hdev2 = usb_get_intfdata(usbdev->config->interface[2]); 1769 wacom2 = hid_get_drvdata(hdev2); 1770 wacom_wac2 = &(wacom2->wacom_wac); 1771 wacom_clean_inputs(wacom2); 1772 1773 if (wacom_wac->pid == 0) { 1774 hid_info(wacom->hdev, "wireless tablet disconnected\n"); 1775 wacom_wac1->shared->type = 0; 1776 } else { 1777 const struct hid_device_id *id = wacom_ids; 1778 1779 hid_info(wacom->hdev, "wireless tablet connected with PID %x\n", 1780 wacom_wac->pid); 1781 1782 while (id->bus) { 1783 if (id->vendor == USB_VENDOR_ID_WACOM && 1784 id->product == wacom_wac->pid) 1785 break; 1786 id++; 1787 } 1788 1789 if (!id->bus) { 1790 hid_info(wacom->hdev, "ignoring unknown PID.\n"); 1791 return; 1792 } 1793 1794 /* Stylus interface */ 1795 wacom_wac1->features = 1796 *((struct wacom_features *)id->driver_data); 1797 1798 wacom_wac1->pid = wacom_wac->pid; 1799 hid_hw_stop(hdev1); 1800 error = wacom_parse_and_register(wacom1, true); 1801 if (error) 1802 goto fail; 1803 1804 /* Touch interface */ 1805 if (wacom_wac1->features.touch_max || 1806 (wacom_wac1->features.type >= INTUOSHT && 1807 wacom_wac1->features.type <= BAMBOO_PT)) { 1808 wacom_wac2->features = 1809 *((struct wacom_features *)id->driver_data); 1810 wacom_wac2->pid = wacom_wac->pid; 1811 hid_hw_stop(hdev2); 1812 error = wacom_parse_and_register(wacom2, true); 1813 if (error) 1814 goto fail; 1815 } 1816 1817 error = wacom_initialize_battery(wacom); 1818 if (error) 1819 goto fail; 1820 } 1821 1822 return; 1823 1824 fail: 1825 wacom_clean_inputs(wacom1); 1826 wacom_clean_inputs(wacom2); 1827 return; 1828 } 1829 1830 static int wacom_probe(struct hid_device *hdev, 1831 const struct hid_device_id *id) 1832 { 1833 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 1834 struct usb_device *dev = interface_to_usbdev(intf); 1835 struct wacom *wacom; 1836 struct wacom_wac *wacom_wac; 1837 struct wacom_features *features; 1838 int error; 1839 1840 if (!id->driver_data) 1841 return -EINVAL; 1842 1843 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 1844 1845 /* hid-core sets this quirk for the boot interface */ 1846 hdev->quirks &= ~HID_QUIRK_NOGET; 1847 1848 wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL); 1849 if (!wacom) 1850 return -ENOMEM; 1851 1852 hid_set_drvdata(hdev, wacom); 1853 wacom->hdev = hdev; 1854 1855 wacom_wac = &wacom->wacom_wac; 1856 wacom_wac->features = *((struct wacom_features *)id->driver_data); 1857 features = &wacom_wac->features; 1858 1859 if (features->check_for_hid_type && features->hid_type != hdev->type) { 1860 error = -ENODEV; 1861 goto fail_type; 1862 } 1863 1864 wacom_wac->hid_data.inputmode = -1; 1865 wacom_wac->mode_report = -1; 1866 1867 wacom->usbdev = dev; 1868 wacom->intf = intf; 1869 mutex_init(&wacom->lock); 1870 INIT_WORK(&wacom->work, wacom_wireless_work); 1871 1872 /* ask for the report descriptor to be loaded by HID */ 1873 error = hid_parse(hdev); 1874 if (error) { 1875 hid_err(hdev, "parse failed\n"); 1876 goto fail_parse; 1877 } 1878 1879 error = wacom_parse_and_register(wacom, false); 1880 if (error) 1881 goto fail_parse; 1882 1883 if (hdev->bus == BUS_BLUETOOTH) { 1884 error = device_create_file(&hdev->dev, &dev_attr_speed); 1885 if (error) 1886 hid_warn(hdev, 1887 "can't create sysfs speed attribute err: %d\n", 1888 error); 1889 } 1890 1891 return 0; 1892 1893 fail_type: 1894 fail_parse: 1895 kfree(wacom); 1896 hid_set_drvdata(hdev, NULL); 1897 return error; 1898 } 1899 1900 static void wacom_remove(struct hid_device *hdev) 1901 { 1902 struct wacom *wacom = hid_get_drvdata(hdev); 1903 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 1904 struct wacom_features *features = &wacom_wac->features; 1905 1906 if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR) 1907 hid_hw_close(hdev); 1908 1909 hid_hw_stop(hdev); 1910 1911 cancel_work_sync(&wacom->work); 1912 wacom_clean_inputs(wacom); 1913 if (hdev->bus == BUS_BLUETOOTH) 1914 device_remove_file(&hdev->dev, &dev_attr_speed); 1915 wacom_destroy_battery(wacom); 1916 wacom_remove_shared_data(wacom); 1917 1918 hid_set_drvdata(hdev, NULL); 1919 kfree(wacom); 1920 } 1921 1922 #ifdef CONFIG_PM 1923 static int wacom_resume(struct hid_device *hdev) 1924 { 1925 struct wacom *wacom = hid_get_drvdata(hdev); 1926 struct wacom_features *features = &wacom->wacom_wac.features; 1927 1928 mutex_lock(&wacom->lock); 1929 1930 /* switch to wacom mode first */ 1931 wacom_query_tablet_data(hdev, features); 1932 wacom_led_control(wacom); 1933 1934 mutex_unlock(&wacom->lock); 1935 1936 return 0; 1937 } 1938 1939 static int wacom_reset_resume(struct hid_device *hdev) 1940 { 1941 return wacom_resume(hdev); 1942 } 1943 #endif /* CONFIG_PM */ 1944 1945 static struct hid_driver wacom_driver = { 1946 .name = "wacom", 1947 .id_table = wacom_ids, 1948 .probe = wacom_probe, 1949 .remove = wacom_remove, 1950 .report = wacom_wac_report, 1951 #ifdef CONFIG_PM 1952 .resume = wacom_resume, 1953 .reset_resume = wacom_reset_resume, 1954 #endif 1955 .raw_event = wacom_raw_event, 1956 }; 1957 module_hid_driver(wacom_driver); 1958 1959 MODULE_VERSION(DRIVER_VERSION); 1960 MODULE_AUTHOR(DRIVER_AUTHOR); 1961 MODULE_DESCRIPTION(DRIVER_DESC); 1962 MODULE_LICENSE(DRIVER_LICENSE); 1963