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