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 int retval; 893 894 retval = usb_lock_device_interruptible(udev); 895 if (retval < 0) 896 return -EINTR; 897 /* The binary attribute begins with the device descriptor. 898 * Following that are the raw descriptor entries for all the 899 * configurations (config plus subsidiary descriptors). 900 */ 901 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations && 902 nleft > 0; ++cfgno) { 903 if (cfgno < 0) { 904 src = &udev->descriptor; 905 srclen = sizeof(struct usb_device_descriptor); 906 } else { 907 src = udev->rawdescriptors[cfgno]; 908 srclen = __le16_to_cpu(udev->config[cfgno].desc. 909 wTotalLength); 910 } 911 if (off < srclen) { 912 n = min(nleft, srclen - (size_t) off); 913 memcpy(buf, src + off, n); 914 nleft -= n; 915 buf += n; 916 off = 0; 917 } else { 918 off -= srclen; 919 } 920 } 921 usb_unlock_device(udev); 922 return count - nleft; 923 } 924 925 static struct bin_attribute dev_bin_attr_descriptors = { 926 .attr = {.name = "descriptors", .mode = 0444}, 927 .read = read_descriptors, 928 .size = 18 + 65535, /* dev descr + max-size raw descriptor */ 929 }; 930 931 /* 932 * Show & store the current value of authorized_default 933 */ 934 static ssize_t authorized_default_show(struct device *dev, 935 struct device_attribute *attr, char *buf) 936 { 937 struct usb_device *rh_usb_dev = to_usb_device(dev); 938 struct usb_bus *usb_bus = rh_usb_dev->bus; 939 struct usb_hcd *hcd; 940 941 hcd = bus_to_hcd(usb_bus); 942 return snprintf(buf, PAGE_SIZE, "%u\n", hcd->dev_policy); 943 } 944 945 static ssize_t authorized_default_store(struct device *dev, 946 struct device_attribute *attr, 947 const char *buf, size_t size) 948 { 949 ssize_t result; 950 unsigned int val; 951 struct usb_device *rh_usb_dev = to_usb_device(dev); 952 struct usb_bus *usb_bus = rh_usb_dev->bus; 953 struct usb_hcd *hcd; 954 955 hcd = bus_to_hcd(usb_bus); 956 result = sscanf(buf, "%u\n", &val); 957 if (result == 1) { 958 hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ? 959 val : USB_DEVICE_AUTHORIZE_ALL; 960 result = size; 961 } else { 962 result = -EINVAL; 963 } 964 return result; 965 } 966 static DEVICE_ATTR_RW(authorized_default); 967 968 /* 969 * interface_authorized_default_show - show default authorization status 970 * for USB interfaces 971 * 972 * note: interface_authorized_default is the default value 973 * for initializing the authorized attribute of interfaces 974 */ 975 static ssize_t interface_authorized_default_show(struct device *dev, 976 struct device_attribute *attr, char *buf) 977 { 978 struct usb_device *usb_dev = to_usb_device(dev); 979 struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus); 980 981 return sprintf(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd)); 982 } 983 984 /* 985 * interface_authorized_default_store - store default authorization status 986 * for USB interfaces 987 * 988 * note: interface_authorized_default is the default value 989 * for initializing the authorized attribute of interfaces 990 */ 991 static ssize_t interface_authorized_default_store(struct device *dev, 992 struct device_attribute *attr, const char *buf, size_t count) 993 { 994 struct usb_device *usb_dev = to_usb_device(dev); 995 struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus); 996 int rc = count; 997 bool val; 998 999 if (strtobool(buf, &val) != 0) 1000 return -EINVAL; 1001 1002 if (val) 1003 set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags); 1004 else 1005 clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags); 1006 1007 return rc; 1008 } 1009 static DEVICE_ATTR_RW(interface_authorized_default); 1010 1011 /* Group all the USB bus attributes */ 1012 static struct attribute *usb_bus_attrs[] = { 1013 &dev_attr_authorized_default.attr, 1014 &dev_attr_interface_authorized_default.attr, 1015 NULL, 1016 }; 1017 1018 static const struct attribute_group usb_bus_attr_group = { 1019 .name = NULL, /* we want them in the same directory */ 1020 .attrs = usb_bus_attrs, 1021 }; 1022 1023 1024 static int add_default_authorized_attributes(struct device *dev) 1025 { 1026 int rc = 0; 1027 1028 if (is_usb_device(dev)) 1029 rc = sysfs_create_group(&dev->kobj, &usb_bus_attr_group); 1030 1031 return rc; 1032 } 1033 1034 static void remove_default_authorized_attributes(struct device *dev) 1035 { 1036 if (is_usb_device(dev)) { 1037 sysfs_remove_group(&dev->kobj, &usb_bus_attr_group); 1038 } 1039 } 1040 1041 int usb_create_sysfs_dev_files(struct usb_device *udev) 1042 { 1043 struct device *dev = &udev->dev; 1044 int retval; 1045 1046 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors); 1047 if (retval) 1048 goto error; 1049 1050 retval = add_persist_attributes(dev); 1051 if (retval) 1052 goto error; 1053 1054 retval = add_power_attributes(dev); 1055 if (retval) 1056 goto error; 1057 1058 if (is_root_hub(udev)) { 1059 retval = add_default_authorized_attributes(dev); 1060 if (retval) 1061 goto error; 1062 } 1063 return retval; 1064 1065 error: 1066 usb_remove_sysfs_dev_files(udev); 1067 return retval; 1068 } 1069 1070 void usb_remove_sysfs_dev_files(struct usb_device *udev) 1071 { 1072 struct device *dev = &udev->dev; 1073 1074 if (is_root_hub(udev)) 1075 remove_default_authorized_attributes(dev); 1076 1077 remove_power_attributes(dev); 1078 remove_persist_attributes(dev); 1079 device_remove_bin_file(dev, &dev_bin_attr_descriptors); 1080 } 1081 1082 /* Interface Association Descriptor fields */ 1083 #define usb_intf_assoc_attr(field, format_string) \ 1084 static ssize_t \ 1085 iad_##field##_show(struct device *dev, struct device_attribute *attr, \ 1086 char *buf) \ 1087 { \ 1088 struct usb_interface *intf = to_usb_interface(dev); \ 1089 \ 1090 return sprintf(buf, format_string, \ 1091 intf->intf_assoc->field); \ 1092 } \ 1093 static DEVICE_ATTR_RO(iad_##field) 1094 1095 usb_intf_assoc_attr(bFirstInterface, "%02x\n"); 1096 usb_intf_assoc_attr(bInterfaceCount, "%02d\n"); 1097 usb_intf_assoc_attr(bFunctionClass, "%02x\n"); 1098 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n"); 1099 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n"); 1100 1101 /* Interface fields */ 1102 #define usb_intf_attr(field, format_string) \ 1103 static ssize_t \ 1104 field##_show(struct device *dev, struct device_attribute *attr, \ 1105 char *buf) \ 1106 { \ 1107 struct usb_interface *intf = to_usb_interface(dev); \ 1108 \ 1109 return sprintf(buf, format_string, \ 1110 intf->cur_altsetting->desc.field); \ 1111 } \ 1112 static DEVICE_ATTR_RO(field) 1113 1114 usb_intf_attr(bInterfaceNumber, "%02x\n"); 1115 usb_intf_attr(bAlternateSetting, "%2d\n"); 1116 usb_intf_attr(bNumEndpoints, "%02x\n"); 1117 usb_intf_attr(bInterfaceClass, "%02x\n"); 1118 usb_intf_attr(bInterfaceSubClass, "%02x\n"); 1119 usb_intf_attr(bInterfaceProtocol, "%02x\n"); 1120 1121 static ssize_t interface_show(struct device *dev, struct device_attribute *attr, 1122 char *buf) 1123 { 1124 struct usb_interface *intf; 1125 char *string; 1126 1127 intf = to_usb_interface(dev); 1128 string = READ_ONCE(intf->cur_altsetting->string); 1129 if (!string) 1130 return 0; 1131 return sprintf(buf, "%s\n", string); 1132 } 1133 static DEVICE_ATTR_RO(interface); 1134 1135 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 1136 char *buf) 1137 { 1138 struct usb_interface *intf; 1139 struct usb_device *udev; 1140 struct usb_host_interface *alt; 1141 1142 intf = to_usb_interface(dev); 1143 udev = interface_to_usbdev(intf); 1144 alt = READ_ONCE(intf->cur_altsetting); 1145 1146 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 1147 "ic%02Xisc%02Xip%02Xin%02X\n", 1148 le16_to_cpu(udev->descriptor.idVendor), 1149 le16_to_cpu(udev->descriptor.idProduct), 1150 le16_to_cpu(udev->descriptor.bcdDevice), 1151 udev->descriptor.bDeviceClass, 1152 udev->descriptor.bDeviceSubClass, 1153 udev->descriptor.bDeviceProtocol, 1154 alt->desc.bInterfaceClass, 1155 alt->desc.bInterfaceSubClass, 1156 alt->desc.bInterfaceProtocol, 1157 alt->desc.bInterfaceNumber); 1158 } 1159 static DEVICE_ATTR_RO(modalias); 1160 1161 static ssize_t supports_autosuspend_show(struct device *dev, 1162 struct device_attribute *attr, 1163 char *buf) 1164 { 1165 int s; 1166 1167 s = device_lock_interruptible(dev); 1168 if (s < 0) 1169 return -EINTR; 1170 /* Devices will be autosuspended even when an interface isn't claimed */ 1171 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend); 1172 device_unlock(dev); 1173 1174 return sprintf(buf, "%u\n", s); 1175 } 1176 static DEVICE_ATTR_RO(supports_autosuspend); 1177 1178 /* 1179 * interface_authorized_show - show authorization status of an USB interface 1180 * 1 is authorized, 0 is deauthorized 1181 */ 1182 static ssize_t interface_authorized_show(struct device *dev, 1183 struct device_attribute *attr, char *buf) 1184 { 1185 struct usb_interface *intf = to_usb_interface(dev); 1186 1187 return sprintf(buf, "%u\n", intf->authorized); 1188 } 1189 1190 /* 1191 * interface_authorized_store - authorize or deauthorize an USB interface 1192 */ 1193 static ssize_t interface_authorized_store(struct device *dev, 1194 struct device_attribute *attr, const char *buf, size_t count) 1195 { 1196 struct usb_interface *intf = to_usb_interface(dev); 1197 bool val; 1198 1199 if (strtobool(buf, &val) != 0) 1200 return -EINVAL; 1201 1202 if (val) 1203 usb_authorize_interface(intf); 1204 else 1205 usb_deauthorize_interface(intf); 1206 1207 return count; 1208 } 1209 static struct device_attribute dev_attr_interface_authorized = 1210 __ATTR(authorized, S_IRUGO | S_IWUSR, 1211 interface_authorized_show, interface_authorized_store); 1212 1213 static struct attribute *intf_attrs[] = { 1214 &dev_attr_bInterfaceNumber.attr, 1215 &dev_attr_bAlternateSetting.attr, 1216 &dev_attr_bNumEndpoints.attr, 1217 &dev_attr_bInterfaceClass.attr, 1218 &dev_attr_bInterfaceSubClass.attr, 1219 &dev_attr_bInterfaceProtocol.attr, 1220 &dev_attr_modalias.attr, 1221 &dev_attr_supports_autosuspend.attr, 1222 &dev_attr_interface_authorized.attr, 1223 NULL, 1224 }; 1225 static struct attribute_group intf_attr_grp = { 1226 .attrs = intf_attrs, 1227 }; 1228 1229 static struct attribute *intf_assoc_attrs[] = { 1230 &dev_attr_iad_bFirstInterface.attr, 1231 &dev_attr_iad_bInterfaceCount.attr, 1232 &dev_attr_iad_bFunctionClass.attr, 1233 &dev_attr_iad_bFunctionSubClass.attr, 1234 &dev_attr_iad_bFunctionProtocol.attr, 1235 NULL, 1236 }; 1237 1238 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj, 1239 struct attribute *a, int n) 1240 { 1241 struct device *dev = kobj_to_dev(kobj); 1242 struct usb_interface *intf = to_usb_interface(dev); 1243 1244 if (intf->intf_assoc == NULL) 1245 return 0; 1246 return a->mode; 1247 } 1248 1249 static struct attribute_group intf_assoc_attr_grp = { 1250 .attrs = intf_assoc_attrs, 1251 .is_visible = intf_assoc_attrs_are_visible, 1252 }; 1253 1254 const struct attribute_group *usb_interface_groups[] = { 1255 &intf_attr_grp, 1256 &intf_assoc_attr_grp, 1257 NULL 1258 }; 1259 1260 void usb_create_sysfs_intf_files(struct usb_interface *intf) 1261 { 1262 struct usb_device *udev = interface_to_usbdev(intf); 1263 struct usb_host_interface *alt = intf->cur_altsetting; 1264 1265 if (intf->sysfs_files_created || intf->unregistering) 1266 return; 1267 1268 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) 1269 alt->string = usb_cache_string(udev, alt->desc.iInterface); 1270 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface)) { 1271 /* This is not a serious error */ 1272 dev_dbg(&intf->dev, "interface string descriptor file not created\n"); 1273 } 1274 intf->sysfs_files_created = 1; 1275 } 1276 1277 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 1278 { 1279 if (!intf->sysfs_files_created) 1280 return; 1281 1282 device_remove_file(&intf->dev, &dev_attr_interface); 1283 intf->sysfs_files_created = 0; 1284 } 1285