1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * drivers/usb/core/sysfs.c 4 * 5 * (C) Copyright 2002 David Brownell 6 * (C) Copyright 2002,2004 Greg Kroah-Hartman 7 * (C) Copyright 2002,2004 IBM Corp. 8 * 9 * All of the sysfs file attributes for usb devices and interfaces. 10 * 11 * Released under the GPLv2 only. 12 */ 13 14 15 #include <linux/kernel.h> 16 #include <linux/string.h> 17 #include <linux/usb.h> 18 #include <linux/usb/hcd.h> 19 #include <linux/usb/quirks.h> 20 #include <linux/of.h> 21 #include "usb.h" 22 23 /* Active configuration fields */ 24 #define usb_actconfig_show(field, format_string) \ 25 static ssize_t field##_show(struct device *dev, \ 26 struct device_attribute *attr, char *buf) \ 27 { \ 28 struct usb_device *udev; \ 29 struct usb_host_config *actconfig; \ 30 ssize_t rc; \ 31 \ 32 udev = to_usb_device(dev); \ 33 rc = usb_lock_device_interruptible(udev); \ 34 if (rc < 0) \ 35 return -EINTR; \ 36 actconfig = udev->actconfig; \ 37 if (actconfig) \ 38 rc = sprintf(buf, format_string, \ 39 actconfig->desc.field); \ 40 usb_unlock_device(udev); \ 41 return rc; \ 42 } \ 43 44 #define usb_actconfig_attr(field, format_string) \ 45 usb_actconfig_show(field, format_string) \ 46 static DEVICE_ATTR_RO(field) 47 48 usb_actconfig_attr(bNumInterfaces, "%2d\n"); 49 usb_actconfig_attr(bmAttributes, "%2x\n"); 50 51 static ssize_t bMaxPower_show(struct device *dev, 52 struct device_attribute *attr, char *buf) 53 { 54 struct usb_device *udev; 55 struct usb_host_config *actconfig; 56 ssize_t rc; 57 58 udev = to_usb_device(dev); 59 rc = usb_lock_device_interruptible(udev); 60 if (rc < 0) 61 return -EINTR; 62 actconfig = udev->actconfig; 63 if (actconfig) 64 rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig)); 65 usb_unlock_device(udev); 66 return rc; 67 } 68 static DEVICE_ATTR_RO(bMaxPower); 69 70 static ssize_t configuration_show(struct device *dev, 71 struct device_attribute *attr, char *buf) 72 { 73 struct usb_device *udev; 74 struct usb_host_config *actconfig; 75 ssize_t rc; 76 77 udev = to_usb_device(dev); 78 rc = usb_lock_device_interruptible(udev); 79 if (rc < 0) 80 return -EINTR; 81 actconfig = udev->actconfig; 82 if (actconfig && actconfig->string) 83 rc = sprintf(buf, "%s\n", actconfig->string); 84 usb_unlock_device(udev); 85 return rc; 86 } 87 static DEVICE_ATTR_RO(configuration); 88 89 /* configuration value is always present, and r/w */ 90 usb_actconfig_show(bConfigurationValue, "%u\n"); 91 92 static ssize_t bConfigurationValue_store(struct device *dev, 93 struct device_attribute *attr, 94 const char *buf, size_t count) 95 { 96 struct usb_device *udev = to_usb_device(dev); 97 int config, value, rc; 98 99 if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255) 100 return -EINVAL; 101 rc = usb_lock_device_interruptible(udev); 102 if (rc < 0) 103 return -EINTR; 104 value = usb_set_configuration(udev, config); 105 usb_unlock_device(udev); 106 return (value < 0) ? value : count; 107 } 108 static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR, 109 bConfigurationValue_show, bConfigurationValue_store); 110 111 #ifdef CONFIG_OF 112 static ssize_t devspec_show(struct device *dev, struct device_attribute *attr, 113 char *buf) 114 { 115 struct device_node *of_node = dev->of_node; 116 117 return sprintf(buf, "%pOF\n", of_node); 118 } 119 static DEVICE_ATTR_RO(devspec); 120 #endif 121 122 /* String fields */ 123 #define usb_string_attr(name) \ 124 static ssize_t name##_show(struct device *dev, \ 125 struct device_attribute *attr, char *buf) \ 126 { \ 127 struct usb_device *udev; \ 128 int retval; \ 129 \ 130 udev = to_usb_device(dev); \ 131 retval = usb_lock_device_interruptible(udev); \ 132 if (retval < 0) \ 133 return -EINTR; \ 134 retval = sprintf(buf, "%s\n", udev->name); \ 135 usb_unlock_device(udev); \ 136 return retval; \ 137 } \ 138 static DEVICE_ATTR_RO(name) 139 140 usb_string_attr(product); 141 usb_string_attr(manufacturer); 142 usb_string_attr(serial); 143 144 static ssize_t speed_show(struct device *dev, struct device_attribute *attr, 145 char *buf) 146 { 147 struct usb_device *udev; 148 char *speed; 149 150 udev = to_usb_device(dev); 151 152 switch (udev->speed) { 153 case USB_SPEED_LOW: 154 speed = "1.5"; 155 break; 156 case USB_SPEED_UNKNOWN: 157 case USB_SPEED_FULL: 158 speed = "12"; 159 break; 160 case USB_SPEED_HIGH: 161 speed = "480"; 162 break; 163 case USB_SPEED_WIRELESS: 164 speed = "480"; 165 break; 166 case USB_SPEED_SUPER: 167 speed = "5000"; 168 break; 169 case USB_SPEED_SUPER_PLUS: 170 if (udev->ssp_rate == USB_SSP_GEN_2x2) 171 speed = "20000"; 172 else 173 speed = "10000"; 174 break; 175 default: 176 speed = "unknown"; 177 } 178 return sprintf(buf, "%s\n", speed); 179 } 180 static DEVICE_ATTR_RO(speed); 181 182 static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr, 183 char *buf) 184 { 185 struct usb_device *udev; 186 187 udev = to_usb_device(dev); 188 return sprintf(buf, "%d\n", udev->rx_lanes); 189 } 190 static DEVICE_ATTR_RO(rx_lanes); 191 192 static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr, 193 char *buf) 194 { 195 struct usb_device *udev; 196 197 udev = to_usb_device(dev); 198 return sprintf(buf, "%d\n", udev->tx_lanes); 199 } 200 static DEVICE_ATTR_RO(tx_lanes); 201 202 static ssize_t busnum_show(struct device *dev, struct device_attribute *attr, 203 char *buf) 204 { 205 struct usb_device *udev; 206 207 udev = to_usb_device(dev); 208 return sprintf(buf, "%d\n", udev->bus->busnum); 209 } 210 static DEVICE_ATTR_RO(busnum); 211 212 static ssize_t devnum_show(struct device *dev, struct device_attribute *attr, 213 char *buf) 214 { 215 struct usb_device *udev; 216 217 udev = to_usb_device(dev); 218 return sprintf(buf, "%d\n", udev->devnum); 219 } 220 static DEVICE_ATTR_RO(devnum); 221 222 static ssize_t devpath_show(struct device *dev, struct device_attribute *attr, 223 char *buf) 224 { 225 struct usb_device *udev; 226 227 udev = to_usb_device(dev); 228 return sprintf(buf, "%s\n", udev->devpath); 229 } 230 static DEVICE_ATTR_RO(devpath); 231 232 static ssize_t version_show(struct device *dev, struct device_attribute *attr, 233 char *buf) 234 { 235 struct usb_device *udev; 236 u16 bcdUSB; 237 238 udev = to_usb_device(dev); 239 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB); 240 return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff); 241 } 242 static DEVICE_ATTR_RO(version); 243 244 static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr, 245 char *buf) 246 { 247 struct usb_device *udev; 248 249 udev = to_usb_device(dev); 250 return sprintf(buf, "%d\n", udev->maxchild); 251 } 252 static DEVICE_ATTR_RO(maxchild); 253 254 static ssize_t quirks_show(struct device *dev, struct device_attribute *attr, 255 char *buf) 256 { 257 struct usb_device *udev; 258 259 udev = to_usb_device(dev); 260 return sprintf(buf, "0x%x\n", udev->quirks); 261 } 262 static DEVICE_ATTR_RO(quirks); 263 264 static ssize_t avoid_reset_quirk_show(struct device *dev, 265 struct device_attribute *attr, char *buf) 266 { 267 struct usb_device *udev; 268 269 udev = to_usb_device(dev); 270 return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET)); 271 } 272 273 static ssize_t avoid_reset_quirk_store(struct device *dev, 274 struct device_attribute *attr, 275 const char *buf, size_t count) 276 { 277 struct usb_device *udev = to_usb_device(dev); 278 int val, rc; 279 280 if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1) 281 return -EINVAL; 282 rc = usb_lock_device_interruptible(udev); 283 if (rc < 0) 284 return -EINTR; 285 if (val) 286 udev->quirks |= USB_QUIRK_RESET; 287 else 288 udev->quirks &= ~USB_QUIRK_RESET; 289 usb_unlock_device(udev); 290 return count; 291 } 292 static DEVICE_ATTR_RW(avoid_reset_quirk); 293 294 static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr, 295 char *buf) 296 { 297 struct usb_device *udev; 298 299 udev = to_usb_device(dev); 300 return sprintf(buf, "%d\n", atomic_read(&udev->urbnum)); 301 } 302 static DEVICE_ATTR_RO(urbnum); 303 304 static ssize_t ltm_capable_show(struct device *dev, 305 struct device_attribute *attr, char *buf) 306 { 307 if (usb_device_supports_ltm(to_usb_device(dev))) 308 return sprintf(buf, "%s\n", "yes"); 309 return sprintf(buf, "%s\n", "no"); 310 } 311 static DEVICE_ATTR_RO(ltm_capable); 312 313 #ifdef CONFIG_PM 314 315 static ssize_t persist_show(struct device *dev, struct device_attribute *attr, 316 char *buf) 317 { 318 struct usb_device *udev = to_usb_device(dev); 319 320 return sprintf(buf, "%d\n", udev->persist_enabled); 321 } 322 323 static ssize_t persist_store(struct device *dev, struct device_attribute *attr, 324 const char *buf, size_t count) 325 { 326 struct usb_device *udev = to_usb_device(dev); 327 int value, rc; 328 329 /* Hubs are always enabled for USB_PERSIST */ 330 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) 331 return -EPERM; 332 333 if (sscanf(buf, "%d", &value) != 1) 334 return -EINVAL; 335 336 rc = usb_lock_device_interruptible(udev); 337 if (rc < 0) 338 return -EINTR; 339 udev->persist_enabled = !!value; 340 usb_unlock_device(udev); 341 return count; 342 } 343 static DEVICE_ATTR_RW(persist); 344 345 static int add_persist_attributes(struct device *dev) 346 { 347 int rc = 0; 348 349 if (is_usb_device(dev)) { 350 struct usb_device *udev = to_usb_device(dev); 351 352 /* Hubs are automatically enabled for USB_PERSIST, 353 * no point in creating the attribute file. 354 */ 355 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB) 356 rc = sysfs_add_file_to_group(&dev->kobj, 357 &dev_attr_persist.attr, 358 power_group_name); 359 } 360 return rc; 361 } 362 363 static void remove_persist_attributes(struct device *dev) 364 { 365 sysfs_remove_file_from_group(&dev->kobj, 366 &dev_attr_persist.attr, 367 power_group_name); 368 } 369 370 static ssize_t connected_duration_show(struct device *dev, 371 struct device_attribute *attr, char *buf) 372 { 373 struct usb_device *udev = to_usb_device(dev); 374 375 return sprintf(buf, "%u\n", 376 jiffies_to_msecs(jiffies - udev->connect_time)); 377 } 378 static DEVICE_ATTR_RO(connected_duration); 379 380 /* 381 * If the device is resumed, the last time the device was suspended has 382 * been pre-subtracted from active_duration. We add the current time to 383 * get the duration that the device was actually active. 384 * 385 * If the device is suspended, the active_duration is up-to-date. 386 */ 387 static ssize_t active_duration_show(struct device *dev, 388 struct device_attribute *attr, char *buf) 389 { 390 struct usb_device *udev = to_usb_device(dev); 391 int duration; 392 393 if (udev->state != USB_STATE_SUSPENDED) 394 duration = jiffies_to_msecs(jiffies + udev->active_duration); 395 else 396 duration = jiffies_to_msecs(udev->active_duration); 397 return sprintf(buf, "%u\n", duration); 398 } 399 static DEVICE_ATTR_RO(active_duration); 400 401 static ssize_t autosuspend_show(struct device *dev, 402 struct device_attribute *attr, char *buf) 403 { 404 return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000); 405 } 406 407 static ssize_t autosuspend_store(struct device *dev, 408 struct device_attribute *attr, const char *buf, 409 size_t count) 410 { 411 int value; 412 413 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 || 414 value <= -INT_MAX/1000) 415 return -EINVAL; 416 417 pm_runtime_set_autosuspend_delay(dev, value * 1000); 418 return count; 419 } 420 static DEVICE_ATTR_RW(autosuspend); 421 422 static const char on_string[] = "on"; 423 static const char auto_string[] = "auto"; 424 425 static void warn_level(void) 426 { 427 static int level_warned; 428 429 if (!level_warned) { 430 level_warned = 1; 431 printk(KERN_WARNING "WARNING! power/level is deprecated; " 432 "use power/control instead\n"); 433 } 434 } 435 436 static ssize_t level_show(struct device *dev, struct device_attribute *attr, 437 char *buf) 438 { 439 struct usb_device *udev = to_usb_device(dev); 440 const char *p = auto_string; 441 442 warn_level(); 443 if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto) 444 p = on_string; 445 return sprintf(buf, "%s\n", p); 446 } 447 448 static ssize_t level_store(struct device *dev, struct device_attribute *attr, 449 const char *buf, size_t count) 450 { 451 struct usb_device *udev = to_usb_device(dev); 452 int len = count; 453 char *cp; 454 int rc = count; 455 int rv; 456 457 warn_level(); 458 cp = memchr(buf, '\n', count); 459 if (cp) 460 len = cp - buf; 461 462 rv = usb_lock_device_interruptible(udev); 463 if (rv < 0) 464 return -EINTR; 465 466 if (len == sizeof on_string - 1 && 467 strncmp(buf, on_string, len) == 0) 468 usb_disable_autosuspend(udev); 469 470 else if (len == sizeof auto_string - 1 && 471 strncmp(buf, auto_string, len) == 0) 472 usb_enable_autosuspend(udev); 473 474 else 475 rc = -EINVAL; 476 477 usb_unlock_device(udev); 478 return rc; 479 } 480 static DEVICE_ATTR_RW(level); 481 482 static ssize_t usb2_hardware_lpm_show(struct device *dev, 483 struct device_attribute *attr, char *buf) 484 { 485 struct usb_device *udev = to_usb_device(dev); 486 const char *p; 487 488 if (udev->usb2_hw_lpm_allowed == 1) 489 p = "enabled"; 490 else 491 p = "disabled"; 492 493 return sprintf(buf, "%s\n", p); 494 } 495 496 static ssize_t usb2_hardware_lpm_store(struct device *dev, 497 struct device_attribute *attr, 498 const char *buf, size_t count) 499 { 500 struct usb_device *udev = to_usb_device(dev); 501 bool value; 502 int ret; 503 504 ret = usb_lock_device_interruptible(udev); 505 if (ret < 0) 506 return -EINTR; 507 508 ret = strtobool(buf, &value); 509 510 if (!ret) { 511 udev->usb2_hw_lpm_allowed = value; 512 if (value) 513 ret = usb_enable_usb2_hardware_lpm(udev); 514 else 515 ret = usb_disable_usb2_hardware_lpm(udev); 516 } 517 518 usb_unlock_device(udev); 519 520 if (!ret) 521 return count; 522 523 return ret; 524 } 525 static DEVICE_ATTR_RW(usb2_hardware_lpm); 526 527 static ssize_t usb2_lpm_l1_timeout_show(struct device *dev, 528 struct device_attribute *attr, 529 char *buf) 530 { 531 struct usb_device *udev = to_usb_device(dev); 532 return sprintf(buf, "%d\n", udev->l1_params.timeout); 533 } 534 535 static ssize_t usb2_lpm_l1_timeout_store(struct device *dev, 536 struct device_attribute *attr, 537 const char *buf, size_t count) 538 { 539 struct usb_device *udev = to_usb_device(dev); 540 u16 timeout; 541 542 if (kstrtou16(buf, 0, &timeout)) 543 return -EINVAL; 544 545 udev->l1_params.timeout = timeout; 546 547 return count; 548 } 549 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout); 550 551 static ssize_t usb2_lpm_besl_show(struct device *dev, 552 struct device_attribute *attr, char *buf) 553 { 554 struct usb_device *udev = to_usb_device(dev); 555 return sprintf(buf, "%d\n", udev->l1_params.besl); 556 } 557 558 static ssize_t usb2_lpm_besl_store(struct device *dev, 559 struct device_attribute *attr, 560 const char *buf, size_t count) 561 { 562 struct usb_device *udev = to_usb_device(dev); 563 u8 besl; 564 565 if (kstrtou8(buf, 0, &besl) || besl > 15) 566 return -EINVAL; 567 568 udev->l1_params.besl = besl; 569 570 return count; 571 } 572 static DEVICE_ATTR_RW(usb2_lpm_besl); 573 574 static ssize_t usb3_hardware_lpm_u1_show(struct device *dev, 575 struct device_attribute *attr, char *buf) 576 { 577 struct usb_device *udev = to_usb_device(dev); 578 const char *p; 579 int rc; 580 581 rc = usb_lock_device_interruptible(udev); 582 if (rc < 0) 583 return -EINTR; 584 585 if (udev->usb3_lpm_u1_enabled) 586 p = "enabled"; 587 else 588 p = "disabled"; 589 590 usb_unlock_device(udev); 591 592 return sprintf(buf, "%s\n", p); 593 } 594 static DEVICE_ATTR_RO(usb3_hardware_lpm_u1); 595 596 static ssize_t usb3_hardware_lpm_u2_show(struct device *dev, 597 struct device_attribute *attr, char *buf) 598 { 599 struct usb_device *udev = to_usb_device(dev); 600 const char *p; 601 int rc; 602 603 rc = usb_lock_device_interruptible(udev); 604 if (rc < 0) 605 return -EINTR; 606 607 if (udev->usb3_lpm_u2_enabled) 608 p = "enabled"; 609 else 610 p = "disabled"; 611 612 usb_unlock_device(udev); 613 614 return sprintf(buf, "%s\n", p); 615 } 616 static DEVICE_ATTR_RO(usb3_hardware_lpm_u2); 617 618 static struct attribute *usb2_hardware_lpm_attr[] = { 619 &dev_attr_usb2_hardware_lpm.attr, 620 &dev_attr_usb2_lpm_l1_timeout.attr, 621 &dev_attr_usb2_lpm_besl.attr, 622 NULL, 623 }; 624 static const struct attribute_group usb2_hardware_lpm_attr_group = { 625 .name = power_group_name, 626 .attrs = usb2_hardware_lpm_attr, 627 }; 628 629 static struct attribute *usb3_hardware_lpm_attr[] = { 630 &dev_attr_usb3_hardware_lpm_u1.attr, 631 &dev_attr_usb3_hardware_lpm_u2.attr, 632 NULL, 633 }; 634 static const struct attribute_group usb3_hardware_lpm_attr_group = { 635 .name = power_group_name, 636 .attrs = usb3_hardware_lpm_attr, 637 }; 638 639 static struct attribute *power_attrs[] = { 640 &dev_attr_autosuspend.attr, 641 &dev_attr_level.attr, 642 &dev_attr_connected_duration.attr, 643 &dev_attr_active_duration.attr, 644 NULL, 645 }; 646 static const struct attribute_group power_attr_group = { 647 .name = power_group_name, 648 .attrs = power_attrs, 649 }; 650 651 static int add_power_attributes(struct device *dev) 652 { 653 int rc = 0; 654 655 if (is_usb_device(dev)) { 656 struct usb_device *udev = to_usb_device(dev); 657 rc = sysfs_merge_group(&dev->kobj, &power_attr_group); 658 if (udev->usb2_hw_lpm_capable == 1) 659 rc = sysfs_merge_group(&dev->kobj, 660 &usb2_hardware_lpm_attr_group); 661 if ((udev->speed == USB_SPEED_SUPER || 662 udev->speed == USB_SPEED_SUPER_PLUS) && 663 udev->lpm_capable == 1) 664 rc = sysfs_merge_group(&dev->kobj, 665 &usb3_hardware_lpm_attr_group); 666 } 667 668 return rc; 669 } 670 671 static void remove_power_attributes(struct device *dev) 672 { 673 sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group); 674 sysfs_unmerge_group(&dev->kobj, &power_attr_group); 675 } 676 677 #else 678 679 #define add_persist_attributes(dev) 0 680 #define remove_persist_attributes(dev) do {} while (0) 681 682 #define add_power_attributes(dev) 0 683 #define remove_power_attributes(dev) do {} while (0) 684 685 #endif /* CONFIG_PM */ 686 687 688 /* Descriptor fields */ 689 #define usb_descriptor_attr_le16(field, format_string) \ 690 static ssize_t \ 691 field##_show(struct device *dev, struct device_attribute *attr, \ 692 char *buf) \ 693 { \ 694 struct usb_device *udev; \ 695 \ 696 udev = to_usb_device(dev); \ 697 return sprintf(buf, format_string, \ 698 le16_to_cpu(udev->descriptor.field)); \ 699 } \ 700 static DEVICE_ATTR_RO(field) 701 702 usb_descriptor_attr_le16(idVendor, "%04x\n"); 703 usb_descriptor_attr_le16(idProduct, "%04x\n"); 704 usb_descriptor_attr_le16(bcdDevice, "%04x\n"); 705 706 #define usb_descriptor_attr(field, format_string) \ 707 static ssize_t \ 708 field##_show(struct device *dev, struct device_attribute *attr, \ 709 char *buf) \ 710 { \ 711 struct usb_device *udev; \ 712 \ 713 udev = to_usb_device(dev); \ 714 return sprintf(buf, format_string, udev->descriptor.field); \ 715 } \ 716 static DEVICE_ATTR_RO(field) 717 718 usb_descriptor_attr(bDeviceClass, "%02x\n"); 719 usb_descriptor_attr(bDeviceSubClass, "%02x\n"); 720 usb_descriptor_attr(bDeviceProtocol, "%02x\n"); 721 usb_descriptor_attr(bNumConfigurations, "%d\n"); 722 usb_descriptor_attr(bMaxPacketSize0, "%d\n"); 723 724 725 /* show if the device is authorized (1) or not (0) */ 726 static ssize_t authorized_show(struct device *dev, 727 struct device_attribute *attr, char *buf) 728 { 729 struct usb_device *usb_dev = to_usb_device(dev); 730 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized); 731 } 732 733 /* 734 * Authorize a device to be used in the system 735 * 736 * Writing a 0 deauthorizes the device, writing a 1 authorizes it. 737 */ 738 static ssize_t authorized_store(struct device *dev, 739 struct device_attribute *attr, const char *buf, 740 size_t size) 741 { 742 ssize_t result; 743 struct usb_device *usb_dev = to_usb_device(dev); 744 unsigned val; 745 result = sscanf(buf, "%u\n", &val); 746 if (result != 1) 747 result = -EINVAL; 748 else if (val == 0) 749 result = usb_deauthorize_device(usb_dev); 750 else 751 result = usb_authorize_device(usb_dev); 752 return result < 0 ? result : size; 753 } 754 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR, 755 authorized_show, authorized_store); 756 757 /* "Safely remove a device" */ 758 static ssize_t remove_store(struct device *dev, struct device_attribute *attr, 759 const char *buf, size_t count) 760 { 761 struct usb_device *udev = to_usb_device(dev); 762 int rc = 0; 763 764 usb_lock_device(udev); 765 if (udev->state != USB_STATE_NOTATTACHED) { 766 767 /* To avoid races, first unconfigure and then remove */ 768 usb_set_configuration(udev, -1); 769 rc = usb_remove_device(udev); 770 } 771 if (rc == 0) 772 rc = count; 773 usb_unlock_device(udev); 774 return rc; 775 } 776 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store); 777 778 779 static struct attribute *dev_attrs[] = { 780 /* current configuration's attributes */ 781 &dev_attr_configuration.attr, 782 &dev_attr_bNumInterfaces.attr, 783 &dev_attr_bConfigurationValue.attr, 784 &dev_attr_bmAttributes.attr, 785 &dev_attr_bMaxPower.attr, 786 /* device attributes */ 787 &dev_attr_urbnum.attr, 788 &dev_attr_idVendor.attr, 789 &dev_attr_idProduct.attr, 790 &dev_attr_bcdDevice.attr, 791 &dev_attr_bDeviceClass.attr, 792 &dev_attr_bDeviceSubClass.attr, 793 &dev_attr_bDeviceProtocol.attr, 794 &dev_attr_bNumConfigurations.attr, 795 &dev_attr_bMaxPacketSize0.attr, 796 &dev_attr_speed.attr, 797 &dev_attr_rx_lanes.attr, 798 &dev_attr_tx_lanes.attr, 799 &dev_attr_busnum.attr, 800 &dev_attr_devnum.attr, 801 &dev_attr_devpath.attr, 802 &dev_attr_version.attr, 803 &dev_attr_maxchild.attr, 804 &dev_attr_quirks.attr, 805 &dev_attr_avoid_reset_quirk.attr, 806 &dev_attr_authorized.attr, 807 &dev_attr_remove.attr, 808 &dev_attr_ltm_capable.attr, 809 #ifdef CONFIG_OF 810 &dev_attr_devspec.attr, 811 #endif 812 NULL, 813 }; 814 static const struct attribute_group dev_attr_grp = { 815 .attrs = dev_attrs, 816 }; 817 818 /* When modifying this list, be sure to modify dev_string_attrs_are_visible() 819 * accordingly. 820 */ 821 static struct attribute *dev_string_attrs[] = { 822 &dev_attr_manufacturer.attr, 823 &dev_attr_product.attr, 824 &dev_attr_serial.attr, 825 NULL 826 }; 827 828 static umode_t dev_string_attrs_are_visible(struct kobject *kobj, 829 struct attribute *a, int n) 830 { 831 struct device *dev = kobj_to_dev(kobj); 832 struct usb_device *udev = to_usb_device(dev); 833 834 if (a == &dev_attr_manufacturer.attr) { 835 if (udev->manufacturer == NULL) 836 return 0; 837 } else if (a == &dev_attr_product.attr) { 838 if (udev->product == NULL) 839 return 0; 840 } else if (a == &dev_attr_serial.attr) { 841 if (udev->serial == NULL) 842 return 0; 843 } 844 return a->mode; 845 } 846 847 static const struct attribute_group dev_string_attr_grp = { 848 .attrs = dev_string_attrs, 849 .is_visible = dev_string_attrs_are_visible, 850 }; 851 852 const struct attribute_group *usb_device_groups[] = { 853 &dev_attr_grp, 854 &dev_string_attr_grp, 855 NULL 856 }; 857 858 /* Binary descriptors */ 859 860 static ssize_t 861 read_descriptors(struct file *filp, struct kobject *kobj, 862 struct bin_attribute *attr, 863 char *buf, loff_t off, size_t count) 864 { 865 struct device *dev = kobj_to_dev(kobj); 866 struct usb_device *udev = to_usb_device(dev); 867 size_t nleft = count; 868 size_t srclen, n; 869 int cfgno; 870 void *src; 871 int retval; 872 873 retval = usb_lock_device_interruptible(udev); 874 if (retval < 0) 875 return -EINTR; 876 /* The binary attribute begins with the device descriptor. 877 * Following that are the raw descriptor entries for all the 878 * configurations (config plus subsidiary descriptors). 879 */ 880 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations && 881 nleft > 0; ++cfgno) { 882 if (cfgno < 0) { 883 src = &udev->descriptor; 884 srclen = sizeof(struct usb_device_descriptor); 885 } else { 886 src = udev->rawdescriptors[cfgno]; 887 srclen = __le16_to_cpu(udev->config[cfgno].desc. 888 wTotalLength); 889 } 890 if (off < srclen) { 891 n = min(nleft, srclen - (size_t) off); 892 memcpy(buf, src + off, n); 893 nleft -= n; 894 buf += n; 895 off = 0; 896 } else { 897 off -= srclen; 898 } 899 } 900 usb_unlock_device(udev); 901 return count - nleft; 902 } 903 904 static struct bin_attribute dev_bin_attr_descriptors = { 905 .attr = {.name = "descriptors", .mode = 0444}, 906 .read = read_descriptors, 907 .size = 18 + 65535, /* dev descr + max-size raw descriptor */ 908 }; 909 910 /* 911 * Show & store the current value of authorized_default 912 */ 913 static ssize_t authorized_default_show(struct device *dev, 914 struct device_attribute *attr, char *buf) 915 { 916 struct usb_device *rh_usb_dev = to_usb_device(dev); 917 struct usb_bus *usb_bus = rh_usb_dev->bus; 918 struct usb_hcd *hcd; 919 920 hcd = bus_to_hcd(usb_bus); 921 return snprintf(buf, PAGE_SIZE, "%u\n", hcd->dev_policy); 922 } 923 924 static ssize_t authorized_default_store(struct device *dev, 925 struct device_attribute *attr, 926 const char *buf, size_t size) 927 { 928 ssize_t result; 929 unsigned int val; 930 struct usb_device *rh_usb_dev = to_usb_device(dev); 931 struct usb_bus *usb_bus = rh_usb_dev->bus; 932 struct usb_hcd *hcd; 933 934 hcd = bus_to_hcd(usb_bus); 935 result = sscanf(buf, "%u\n", &val); 936 if (result == 1) { 937 hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ? 938 val : USB_DEVICE_AUTHORIZE_ALL; 939 result = size; 940 } else { 941 result = -EINVAL; 942 } 943 return result; 944 } 945 static DEVICE_ATTR_RW(authorized_default); 946 947 /* 948 * interface_authorized_default_show - show default authorization status 949 * for USB interfaces 950 * 951 * note: interface_authorized_default is the default value 952 * for initializing the authorized attribute of interfaces 953 */ 954 static ssize_t interface_authorized_default_show(struct device *dev, 955 struct device_attribute *attr, char *buf) 956 { 957 struct usb_device *usb_dev = to_usb_device(dev); 958 struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus); 959 960 return sprintf(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd)); 961 } 962 963 /* 964 * interface_authorized_default_store - store default authorization status 965 * for USB interfaces 966 * 967 * note: interface_authorized_default is the default value 968 * for initializing the authorized attribute of interfaces 969 */ 970 static ssize_t interface_authorized_default_store(struct device *dev, 971 struct device_attribute *attr, const char *buf, size_t count) 972 { 973 struct usb_device *usb_dev = to_usb_device(dev); 974 struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus); 975 int rc = count; 976 bool val; 977 978 if (strtobool(buf, &val) != 0) 979 return -EINVAL; 980 981 if (val) 982 set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags); 983 else 984 clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags); 985 986 return rc; 987 } 988 static DEVICE_ATTR_RW(interface_authorized_default); 989 990 /* Group all the USB bus attributes */ 991 static struct attribute *usb_bus_attrs[] = { 992 &dev_attr_authorized_default.attr, 993 &dev_attr_interface_authorized_default.attr, 994 NULL, 995 }; 996 997 static const struct attribute_group usb_bus_attr_group = { 998 .name = NULL, /* we want them in the same directory */ 999 .attrs = usb_bus_attrs, 1000 }; 1001 1002 1003 static int add_default_authorized_attributes(struct device *dev) 1004 { 1005 int rc = 0; 1006 1007 if (is_usb_device(dev)) 1008 rc = sysfs_create_group(&dev->kobj, &usb_bus_attr_group); 1009 1010 return rc; 1011 } 1012 1013 static void remove_default_authorized_attributes(struct device *dev) 1014 { 1015 if (is_usb_device(dev)) { 1016 sysfs_remove_group(&dev->kobj, &usb_bus_attr_group); 1017 } 1018 } 1019 1020 int usb_create_sysfs_dev_files(struct usb_device *udev) 1021 { 1022 struct device *dev = &udev->dev; 1023 int retval; 1024 1025 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors); 1026 if (retval) 1027 goto error; 1028 1029 retval = add_persist_attributes(dev); 1030 if (retval) 1031 goto error; 1032 1033 retval = add_power_attributes(dev); 1034 if (retval) 1035 goto error; 1036 1037 if (is_root_hub(udev)) { 1038 retval = add_default_authorized_attributes(dev); 1039 if (retval) 1040 goto error; 1041 } 1042 return retval; 1043 1044 error: 1045 usb_remove_sysfs_dev_files(udev); 1046 return retval; 1047 } 1048 1049 void usb_remove_sysfs_dev_files(struct usb_device *udev) 1050 { 1051 struct device *dev = &udev->dev; 1052 1053 if (is_root_hub(udev)) 1054 remove_default_authorized_attributes(dev); 1055 1056 remove_power_attributes(dev); 1057 remove_persist_attributes(dev); 1058 device_remove_bin_file(dev, &dev_bin_attr_descriptors); 1059 } 1060 1061 /* Interface Association Descriptor fields */ 1062 #define usb_intf_assoc_attr(field, format_string) \ 1063 static ssize_t \ 1064 iad_##field##_show(struct device *dev, struct device_attribute *attr, \ 1065 char *buf) \ 1066 { \ 1067 struct usb_interface *intf = to_usb_interface(dev); \ 1068 \ 1069 return sprintf(buf, format_string, \ 1070 intf->intf_assoc->field); \ 1071 } \ 1072 static DEVICE_ATTR_RO(iad_##field) 1073 1074 usb_intf_assoc_attr(bFirstInterface, "%02x\n"); 1075 usb_intf_assoc_attr(bInterfaceCount, "%02d\n"); 1076 usb_intf_assoc_attr(bFunctionClass, "%02x\n"); 1077 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n"); 1078 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n"); 1079 1080 /* Interface fields */ 1081 #define usb_intf_attr(field, format_string) \ 1082 static ssize_t \ 1083 field##_show(struct device *dev, struct device_attribute *attr, \ 1084 char *buf) \ 1085 { \ 1086 struct usb_interface *intf = to_usb_interface(dev); \ 1087 \ 1088 return sprintf(buf, format_string, \ 1089 intf->cur_altsetting->desc.field); \ 1090 } \ 1091 static DEVICE_ATTR_RO(field) 1092 1093 usb_intf_attr(bInterfaceNumber, "%02x\n"); 1094 usb_intf_attr(bAlternateSetting, "%2d\n"); 1095 usb_intf_attr(bNumEndpoints, "%02x\n"); 1096 usb_intf_attr(bInterfaceClass, "%02x\n"); 1097 usb_intf_attr(bInterfaceSubClass, "%02x\n"); 1098 usb_intf_attr(bInterfaceProtocol, "%02x\n"); 1099 1100 static ssize_t interface_show(struct device *dev, struct device_attribute *attr, 1101 char *buf) 1102 { 1103 struct usb_interface *intf; 1104 char *string; 1105 1106 intf = to_usb_interface(dev); 1107 string = READ_ONCE(intf->cur_altsetting->string); 1108 if (!string) 1109 return 0; 1110 return sprintf(buf, "%s\n", string); 1111 } 1112 static DEVICE_ATTR_RO(interface); 1113 1114 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 1115 char *buf) 1116 { 1117 struct usb_interface *intf; 1118 struct usb_device *udev; 1119 struct usb_host_interface *alt; 1120 1121 intf = to_usb_interface(dev); 1122 udev = interface_to_usbdev(intf); 1123 alt = READ_ONCE(intf->cur_altsetting); 1124 1125 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 1126 "ic%02Xisc%02Xip%02Xin%02X\n", 1127 le16_to_cpu(udev->descriptor.idVendor), 1128 le16_to_cpu(udev->descriptor.idProduct), 1129 le16_to_cpu(udev->descriptor.bcdDevice), 1130 udev->descriptor.bDeviceClass, 1131 udev->descriptor.bDeviceSubClass, 1132 udev->descriptor.bDeviceProtocol, 1133 alt->desc.bInterfaceClass, 1134 alt->desc.bInterfaceSubClass, 1135 alt->desc.bInterfaceProtocol, 1136 alt->desc.bInterfaceNumber); 1137 } 1138 static DEVICE_ATTR_RO(modalias); 1139 1140 static ssize_t supports_autosuspend_show(struct device *dev, 1141 struct device_attribute *attr, 1142 char *buf) 1143 { 1144 int s; 1145 1146 s = device_lock_interruptible(dev); 1147 if (s < 0) 1148 return -EINTR; 1149 /* Devices will be autosuspended even when an interface isn't claimed */ 1150 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend); 1151 device_unlock(dev); 1152 1153 return sprintf(buf, "%u\n", s); 1154 } 1155 static DEVICE_ATTR_RO(supports_autosuspend); 1156 1157 /* 1158 * interface_authorized_show - show authorization status of an USB interface 1159 * 1 is authorized, 0 is deauthorized 1160 */ 1161 static ssize_t interface_authorized_show(struct device *dev, 1162 struct device_attribute *attr, char *buf) 1163 { 1164 struct usb_interface *intf = to_usb_interface(dev); 1165 1166 return sprintf(buf, "%u\n", intf->authorized); 1167 } 1168 1169 /* 1170 * interface_authorized_store - authorize or deauthorize an USB interface 1171 */ 1172 static ssize_t interface_authorized_store(struct device *dev, 1173 struct device_attribute *attr, const char *buf, size_t count) 1174 { 1175 struct usb_interface *intf = to_usb_interface(dev); 1176 bool val; 1177 1178 if (strtobool(buf, &val) != 0) 1179 return -EINVAL; 1180 1181 if (val) 1182 usb_authorize_interface(intf); 1183 else 1184 usb_deauthorize_interface(intf); 1185 1186 return count; 1187 } 1188 static struct device_attribute dev_attr_interface_authorized = 1189 __ATTR(authorized, S_IRUGO | S_IWUSR, 1190 interface_authorized_show, interface_authorized_store); 1191 1192 static struct attribute *intf_attrs[] = { 1193 &dev_attr_bInterfaceNumber.attr, 1194 &dev_attr_bAlternateSetting.attr, 1195 &dev_attr_bNumEndpoints.attr, 1196 &dev_attr_bInterfaceClass.attr, 1197 &dev_attr_bInterfaceSubClass.attr, 1198 &dev_attr_bInterfaceProtocol.attr, 1199 &dev_attr_modalias.attr, 1200 &dev_attr_supports_autosuspend.attr, 1201 &dev_attr_interface_authorized.attr, 1202 NULL, 1203 }; 1204 static const struct attribute_group intf_attr_grp = { 1205 .attrs = intf_attrs, 1206 }; 1207 1208 static struct attribute *intf_assoc_attrs[] = { 1209 &dev_attr_iad_bFirstInterface.attr, 1210 &dev_attr_iad_bInterfaceCount.attr, 1211 &dev_attr_iad_bFunctionClass.attr, 1212 &dev_attr_iad_bFunctionSubClass.attr, 1213 &dev_attr_iad_bFunctionProtocol.attr, 1214 NULL, 1215 }; 1216 1217 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj, 1218 struct attribute *a, int n) 1219 { 1220 struct device *dev = kobj_to_dev(kobj); 1221 struct usb_interface *intf = to_usb_interface(dev); 1222 1223 if (intf->intf_assoc == NULL) 1224 return 0; 1225 return a->mode; 1226 } 1227 1228 static const struct attribute_group intf_assoc_attr_grp = { 1229 .attrs = intf_assoc_attrs, 1230 .is_visible = intf_assoc_attrs_are_visible, 1231 }; 1232 1233 const struct attribute_group *usb_interface_groups[] = { 1234 &intf_attr_grp, 1235 &intf_assoc_attr_grp, 1236 NULL 1237 }; 1238 1239 void usb_create_sysfs_intf_files(struct usb_interface *intf) 1240 { 1241 struct usb_device *udev = interface_to_usbdev(intf); 1242 struct usb_host_interface *alt = intf->cur_altsetting; 1243 1244 if (intf->sysfs_files_created || intf->unregistering) 1245 return; 1246 1247 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) 1248 alt->string = usb_cache_string(udev, alt->desc.iInterface); 1249 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface)) { 1250 /* This is not a serious error */ 1251 dev_dbg(&intf->dev, "interface string descriptor file not created\n"); 1252 } 1253 intf->sysfs_files_created = 1; 1254 } 1255 1256 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 1257 { 1258 if (!intf->sysfs_files_created) 1259 return; 1260 1261 device_remove_file(&intf->dev, &dev_attr_interface); 1262 intf->sysfs_files_created = 0; 1263 } 1264