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/kstrtox.h> 17 #include <linux/string.h> 18 #include <linux/usb.h> 19 #include <linux/usb/hcd.h> 20 #include <linux/usb/quirks.h> 21 #include <linux/of.h> 22 #include "usb.h" 23 24 /* Active configuration fields */ 25 #define usb_actconfig_show(field, format_string) \ 26 static ssize_t field##_show(struct device *dev, \ 27 struct device_attribute *attr, char *buf) \ 28 { \ 29 struct usb_device *udev; \ 30 struct usb_host_config *actconfig; \ 31 ssize_t rc; \ 32 \ 33 udev = to_usb_device(dev); \ 34 rc = usb_lock_device_interruptible(udev); \ 35 if (rc < 0) \ 36 return -EINTR; \ 37 actconfig = udev->actconfig; \ 38 if (actconfig) \ 39 rc = sysfs_emit(buf, format_string, \ 40 actconfig->desc.field); \ 41 usb_unlock_device(udev); \ 42 return rc; \ 43 } \ 44 45 #define usb_actconfig_attr(field, format_string) \ 46 usb_actconfig_show(field, format_string) \ 47 static DEVICE_ATTR_RO(field) 48 49 usb_actconfig_attr(bNumInterfaces, "%2d\n"); 50 usb_actconfig_attr(bmAttributes, "%2x\n"); 51 52 static ssize_t bMaxPower_show(struct device *dev, 53 struct device_attribute *attr, char *buf) 54 { 55 struct usb_device *udev; 56 struct usb_host_config *actconfig; 57 ssize_t rc; 58 59 udev = to_usb_device(dev); 60 rc = usb_lock_device_interruptible(udev); 61 if (rc < 0) 62 return -EINTR; 63 actconfig = udev->actconfig; 64 if (actconfig) 65 rc = sysfs_emit(buf, "%dmA\n", usb_get_max_power(udev, actconfig)); 66 usb_unlock_device(udev); 67 return rc; 68 } 69 static DEVICE_ATTR_RO(bMaxPower); 70 71 static ssize_t configuration_show(struct device *dev, 72 struct device_attribute *attr, char *buf) 73 { 74 struct usb_device *udev; 75 struct usb_host_config *actconfig; 76 ssize_t rc; 77 78 udev = to_usb_device(dev); 79 rc = usb_lock_device_interruptible(udev); 80 if (rc < 0) 81 return -EINTR; 82 actconfig = udev->actconfig; 83 if (actconfig && actconfig->string) 84 rc = sysfs_emit(buf, "%s\n", actconfig->string); 85 usb_unlock_device(udev); 86 return rc; 87 } 88 static DEVICE_ATTR_RO(configuration); 89 90 /* configuration value is always present, and r/w */ 91 usb_actconfig_show(bConfigurationValue, "%u\n"); 92 93 static ssize_t bConfigurationValue_store(struct device *dev, 94 struct device_attribute *attr, 95 const char *buf, size_t count) 96 { 97 struct usb_device *udev = to_usb_device(dev); 98 int config, value, rc; 99 100 if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255) 101 return -EINVAL; 102 rc = usb_lock_device_interruptible(udev); 103 if (rc < 0) 104 return -EINTR; 105 value = usb_set_configuration(udev, config); 106 usb_unlock_device(udev); 107 return (value < 0) ? value : count; 108 } 109 static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR, 110 bConfigurationValue_show, bConfigurationValue_store); 111 112 #ifdef CONFIG_OF 113 static ssize_t devspec_show(struct device *dev, struct device_attribute *attr, 114 char *buf) 115 { 116 struct device_node *of_node = dev->of_node; 117 118 return sysfs_emit(buf, "%pOF\n", of_node); 119 } 120 static DEVICE_ATTR_RO(devspec); 121 #endif 122 123 /* String fields */ 124 #define usb_string_attr(name) \ 125 static ssize_t name##_show(struct device *dev, \ 126 struct device_attribute *attr, char *buf) \ 127 { \ 128 struct usb_device *udev; \ 129 int retval; \ 130 \ 131 udev = to_usb_device(dev); \ 132 retval = usb_lock_device_interruptible(udev); \ 133 if (retval < 0) \ 134 return -EINTR; \ 135 retval = sysfs_emit(buf, "%s\n", udev->name); \ 136 usb_unlock_device(udev); \ 137 return retval; \ 138 } \ 139 static DEVICE_ATTR_RO(name) 140 141 usb_string_attr(product); 142 usb_string_attr(manufacturer); 143 usb_string_attr(serial); 144 145 static ssize_t speed_show(struct device *dev, struct device_attribute *attr, 146 char *buf) 147 { 148 struct usb_device *udev; 149 char *speed; 150 151 udev = to_usb_device(dev); 152 153 switch (udev->speed) { 154 case USB_SPEED_LOW: 155 speed = "1.5"; 156 break; 157 case USB_SPEED_UNKNOWN: 158 case USB_SPEED_FULL: 159 speed = "12"; 160 break; 161 case USB_SPEED_HIGH: 162 speed = "480"; 163 break; 164 case USB_SPEED_SUPER: 165 speed = "5000"; 166 break; 167 case USB_SPEED_SUPER_PLUS: 168 if (udev->ssp_rate == USB_SSP_GEN_2x2) 169 speed = "20000"; 170 else 171 speed = "10000"; 172 break; 173 default: 174 speed = "unknown"; 175 } 176 return sysfs_emit(buf, "%s\n", speed); 177 } 178 static DEVICE_ATTR_RO(speed); 179 180 static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr, 181 char *buf) 182 { 183 struct usb_device *udev; 184 185 udev = to_usb_device(dev); 186 return sysfs_emit(buf, "%d\n", udev->rx_lanes); 187 } 188 static DEVICE_ATTR_RO(rx_lanes); 189 190 static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr, 191 char *buf) 192 { 193 struct usb_device *udev; 194 195 udev = to_usb_device(dev); 196 return sysfs_emit(buf, "%d\n", udev->tx_lanes); 197 } 198 static DEVICE_ATTR_RO(tx_lanes); 199 200 static ssize_t busnum_show(struct device *dev, struct device_attribute *attr, 201 char *buf) 202 { 203 struct usb_device *udev; 204 205 udev = to_usb_device(dev); 206 return sysfs_emit(buf, "%d\n", udev->bus->busnum); 207 } 208 static DEVICE_ATTR_RO(busnum); 209 210 static ssize_t devnum_show(struct device *dev, struct device_attribute *attr, 211 char *buf) 212 { 213 struct usb_device *udev; 214 215 udev = to_usb_device(dev); 216 return sysfs_emit(buf, "%d\n", udev->devnum); 217 } 218 static DEVICE_ATTR_RO(devnum); 219 220 static ssize_t devpath_show(struct device *dev, struct device_attribute *attr, 221 char *buf) 222 { 223 struct usb_device *udev; 224 225 udev = to_usb_device(dev); 226 return sysfs_emit(buf, "%s\n", udev->devpath); 227 } 228 static DEVICE_ATTR_RO(devpath); 229 230 static ssize_t version_show(struct device *dev, struct device_attribute *attr, 231 char *buf) 232 { 233 struct usb_device *udev; 234 u16 bcdUSB; 235 236 udev = to_usb_device(dev); 237 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB); 238 return sysfs_emit(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff); 239 } 240 static DEVICE_ATTR_RO(version); 241 242 static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr, 243 char *buf) 244 { 245 struct usb_device *udev; 246 247 udev = to_usb_device(dev); 248 return sysfs_emit(buf, "%d\n", udev->maxchild); 249 } 250 static DEVICE_ATTR_RO(maxchild); 251 252 static ssize_t quirks_show(struct device *dev, struct device_attribute *attr, 253 char *buf) 254 { 255 struct usb_device *udev; 256 257 udev = to_usb_device(dev); 258 return sysfs_emit(buf, "0x%x\n", udev->quirks); 259 } 260 static DEVICE_ATTR_RO(quirks); 261 262 static ssize_t avoid_reset_quirk_show(struct device *dev, 263 struct device_attribute *attr, char *buf) 264 { 265 struct usb_device *udev; 266 267 udev = to_usb_device(dev); 268 return sysfs_emit(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET)); 269 } 270 271 static ssize_t avoid_reset_quirk_store(struct device *dev, 272 struct device_attribute *attr, 273 const char *buf, size_t count) 274 { 275 struct usb_device *udev = to_usb_device(dev); 276 bool val; 277 int rc; 278 279 if (kstrtobool(buf, &val) != 0) 280 return -EINVAL; 281 rc = usb_lock_device_interruptible(udev); 282 if (rc < 0) 283 return -EINTR; 284 if (val) 285 udev->quirks |= USB_QUIRK_RESET; 286 else 287 udev->quirks &= ~USB_QUIRK_RESET; 288 usb_unlock_device(udev); 289 return count; 290 } 291 static DEVICE_ATTR_RW(avoid_reset_quirk); 292 293 static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr, 294 char *buf) 295 { 296 struct usb_device *udev; 297 298 udev = to_usb_device(dev); 299 return sysfs_emit(buf, "%d\n", atomic_read(&udev->urbnum)); 300 } 301 static DEVICE_ATTR_RO(urbnum); 302 303 static ssize_t ltm_capable_show(struct device *dev, 304 struct device_attribute *attr, char *buf) 305 { 306 if (usb_device_supports_ltm(to_usb_device(dev))) 307 return sysfs_emit(buf, "%s\n", "yes"); 308 return sysfs_emit(buf, "%s\n", "no"); 309 } 310 static DEVICE_ATTR_RO(ltm_capable); 311 312 #ifdef CONFIG_PM 313 314 static ssize_t persist_show(struct device *dev, struct device_attribute *attr, 315 char *buf) 316 { 317 struct usb_device *udev = to_usb_device(dev); 318 319 return sysfs_emit(buf, "%d\n", udev->persist_enabled); 320 } 321 322 static ssize_t persist_store(struct device *dev, struct device_attribute *attr, 323 const char *buf, size_t count) 324 { 325 struct usb_device *udev = to_usb_device(dev); 326 bool value; 327 int rc; 328 329 /* Hubs are always enabled for USB_PERSIST */ 330 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) 331 return -EPERM; 332 333 if (kstrtobool(buf, &value) != 0) 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 sysfs_emit(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 sysfs_emit(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 sysfs_emit(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 sysfs_emit(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 sysfs_emit(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 = kstrtobool(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 sysfs_emit(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 sysfs_emit(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 sysfs_emit(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 sysfs_emit(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, &usb3_hardware_lpm_attr_group); 674 sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group); 675 sysfs_unmerge_group(&dev->kobj, &power_attr_group); 676 } 677 678 #else 679 680 #define add_persist_attributes(dev) 0 681 #define remove_persist_attributes(dev) do {} while (0) 682 683 #define add_power_attributes(dev) 0 684 #define remove_power_attributes(dev) do {} while (0) 685 686 #endif /* CONFIG_PM */ 687 688 689 /* Descriptor fields */ 690 #define usb_descriptor_attr_le16(field, format_string) \ 691 static ssize_t \ 692 field##_show(struct device *dev, struct device_attribute *attr, \ 693 char *buf) \ 694 { \ 695 struct usb_device *udev; \ 696 \ 697 udev = to_usb_device(dev); \ 698 return sysfs_emit(buf, format_string, \ 699 le16_to_cpu(udev->descriptor.field)); \ 700 } \ 701 static DEVICE_ATTR_RO(field) 702 703 usb_descriptor_attr_le16(idVendor, "%04x\n"); 704 usb_descriptor_attr_le16(idProduct, "%04x\n"); 705 usb_descriptor_attr_le16(bcdDevice, "%04x\n"); 706 707 #define usb_descriptor_attr(field, format_string) \ 708 static ssize_t \ 709 field##_show(struct device *dev, struct device_attribute *attr, \ 710 char *buf) \ 711 { \ 712 struct usb_device *udev; \ 713 \ 714 udev = to_usb_device(dev); \ 715 return sysfs_emit(buf, format_string, udev->descriptor.field); \ 716 } \ 717 static DEVICE_ATTR_RO(field) 718 719 usb_descriptor_attr(bDeviceClass, "%02x\n"); 720 usb_descriptor_attr(bDeviceSubClass, "%02x\n"); 721 usb_descriptor_attr(bDeviceProtocol, "%02x\n"); 722 usb_descriptor_attr(bNumConfigurations, "%d\n"); 723 usb_descriptor_attr(bMaxPacketSize0, "%d\n"); 724 725 726 /* show if the device is authorized (1) or not (0) */ 727 static ssize_t authorized_show(struct device *dev, 728 struct device_attribute *attr, char *buf) 729 { 730 struct usb_device *usb_dev = to_usb_device(dev); 731 return sysfs_emit(buf, "%u\n", usb_dev->authorized); 732 } 733 734 /* 735 * Authorize a device to be used in the system 736 * 737 * Writing a 0 deauthorizes the device, writing a 1 authorizes it. 738 */ 739 static ssize_t authorized_store(struct device *dev, 740 struct device_attribute *attr, const char *buf, 741 size_t size) 742 { 743 ssize_t result; 744 struct usb_device *usb_dev = to_usb_device(dev); 745 bool val; 746 747 if (kstrtobool(buf, &val) != 0) 748 result = -EINVAL; 749 else if (val) 750 result = usb_authorize_device(usb_dev); 751 else 752 result = usb_deauthorize_device(usb_dev); 753 return result < 0 ? result : size; 754 } 755 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR, 756 authorized_show, authorized_store); 757 758 /* "Safely remove a device" */ 759 static ssize_t remove_store(struct device *dev, struct device_attribute *attr, 760 const char *buf, size_t count) 761 { 762 struct usb_device *udev = to_usb_device(dev); 763 int rc = 0; 764 765 usb_lock_device(udev); 766 if (udev->state != USB_STATE_NOTATTACHED) { 767 768 /* To avoid races, first unconfigure and then remove */ 769 usb_set_configuration(udev, -1); 770 rc = usb_remove_device(udev); 771 } 772 if (rc == 0) 773 rc = count; 774 usb_unlock_device(udev); 775 return rc; 776 } 777 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store); 778 779 780 static struct attribute *dev_attrs[] = { 781 /* current configuration's attributes */ 782 &dev_attr_configuration.attr, 783 &dev_attr_bNumInterfaces.attr, 784 &dev_attr_bConfigurationValue.attr, 785 &dev_attr_bmAttributes.attr, 786 &dev_attr_bMaxPower.attr, 787 /* device attributes */ 788 &dev_attr_urbnum.attr, 789 &dev_attr_idVendor.attr, 790 &dev_attr_idProduct.attr, 791 &dev_attr_bcdDevice.attr, 792 &dev_attr_bDeviceClass.attr, 793 &dev_attr_bDeviceSubClass.attr, 794 &dev_attr_bDeviceProtocol.attr, 795 &dev_attr_bNumConfigurations.attr, 796 &dev_attr_bMaxPacketSize0.attr, 797 &dev_attr_speed.attr, 798 &dev_attr_rx_lanes.attr, 799 &dev_attr_tx_lanes.attr, 800 &dev_attr_busnum.attr, 801 &dev_attr_devnum.attr, 802 &dev_attr_devpath.attr, 803 &dev_attr_version.attr, 804 &dev_attr_maxchild.attr, 805 &dev_attr_quirks.attr, 806 &dev_attr_avoid_reset_quirk.attr, 807 &dev_attr_authorized.attr, 808 &dev_attr_remove.attr, 809 &dev_attr_ltm_capable.attr, 810 #ifdef CONFIG_OF 811 &dev_attr_devspec.attr, 812 #endif 813 NULL, 814 }; 815 static const struct attribute_group dev_attr_grp = { 816 .attrs = dev_attrs, 817 }; 818 819 /* When modifying this list, be sure to modify dev_string_attrs_are_visible() 820 * accordingly. 821 */ 822 static struct attribute *dev_string_attrs[] = { 823 &dev_attr_manufacturer.attr, 824 &dev_attr_product.attr, 825 &dev_attr_serial.attr, 826 NULL 827 }; 828 829 static umode_t dev_string_attrs_are_visible(struct kobject *kobj, 830 struct attribute *a, int n) 831 { 832 struct device *dev = kobj_to_dev(kobj); 833 struct usb_device *udev = to_usb_device(dev); 834 835 if (a == &dev_attr_manufacturer.attr) { 836 if (udev->manufacturer == NULL) 837 return 0; 838 } else if (a == &dev_attr_product.attr) { 839 if (udev->product == NULL) 840 return 0; 841 } else if (a == &dev_attr_serial.attr) { 842 if (udev->serial == NULL) 843 return 0; 844 } 845 return a->mode; 846 } 847 848 static const struct attribute_group dev_string_attr_grp = { 849 .attrs = dev_string_attrs, 850 .is_visible = dev_string_attrs_are_visible, 851 }; 852 853 /* Binary descriptors */ 854 855 static ssize_t 856 descriptors_read(struct file *filp, struct kobject *kobj, 857 const struct bin_attribute *attr, 858 char *buf, loff_t off, size_t count) 859 { 860 struct device *dev = kobj_to_dev(kobj); 861 struct usb_device *udev = to_usb_device(dev); 862 size_t nleft = count; 863 size_t srclen, n; 864 int cfgno; 865 void *src; 866 867 /* The binary attribute begins with the device descriptor. 868 * Following that are the raw descriptor entries for all the 869 * configurations (config plus subsidiary descriptors). 870 */ 871 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations && 872 nleft > 0; ++cfgno) { 873 if (cfgno < 0) { 874 src = &udev->descriptor; 875 srclen = sizeof(struct usb_device_descriptor); 876 } else { 877 src = udev->rawdescriptors[cfgno]; 878 srclen = le16_to_cpu(udev->config[cfgno].desc. 879 wTotalLength); 880 } 881 if (off < srclen) { 882 n = min(nleft, srclen - (size_t) off); 883 memcpy(buf, src + off, n); 884 nleft -= n; 885 buf += n; 886 off = 0; 887 } else { 888 off -= srclen; 889 } 890 } 891 return count - nleft; 892 } 893 static const BIN_ATTR_RO(descriptors, 18 + 65535); /* dev descr + max-size raw descriptor */ 894 895 static ssize_t 896 bos_descriptors_read(struct file *filp, struct kobject *kobj, 897 const struct bin_attribute *attr, 898 char *buf, loff_t off, size_t count) 899 { 900 struct device *dev = kobj_to_dev(kobj); 901 struct usb_device *udev = to_usb_device(dev); 902 struct usb_host_bos *bos; 903 struct usb_bos_descriptor *desc; 904 size_t desclen, n = 0; 905 int rc; 906 907 rc = usb_lock_device_interruptible(udev); 908 if (rc < 0) 909 return -EINTR; 910 bos = udev->bos; 911 if (bos) { 912 desc = bos->desc; 913 desclen = le16_to_cpu(desc->wTotalLength); 914 if (off < desclen) { 915 n = min(count, desclen - (size_t) off); 916 memcpy(buf, (void *) desc + off, n); 917 } 918 } 919 usb_unlock_device(udev); 920 return n; 921 } 922 static const BIN_ATTR_RO(bos_descriptors, 65535); /* max-size BOS */ 923 924 /* When modifying this list, be sure to modify dev_bin_attrs_are_visible() 925 * accordingly. 926 */ 927 static const struct bin_attribute *const dev_bin_attrs[] = { 928 &bin_attr_descriptors, 929 &bin_attr_bos_descriptors, 930 NULL 931 }; 932 933 static umode_t dev_bin_attrs_are_visible(struct kobject *kobj, 934 const struct bin_attribute *a, int n) 935 { 936 struct device *dev = kobj_to_dev(kobj); 937 struct usb_device *udev = to_usb_device(dev); 938 939 /* 940 * There's no need to check if the descriptors attribute should 941 * be visible because all devices have a device descriptor. The 942 * bos_descriptors attribute should be visible if and only if 943 * the device has a BOS, so check if it exists here. 944 */ 945 if (a == &bin_attr_bos_descriptors) { 946 if (udev->bos == NULL) 947 return 0; 948 } 949 return a->attr.mode; 950 } 951 952 static const struct attribute_group dev_bin_attr_grp = { 953 .bin_attrs = dev_bin_attrs, 954 .is_bin_visible = dev_bin_attrs_are_visible, 955 }; 956 957 const struct attribute_group *usb_device_groups[] = { 958 &dev_attr_grp, 959 &dev_string_attr_grp, 960 &dev_bin_attr_grp, 961 NULL 962 }; 963 964 /* 965 * Show & store the current value of authorized_default 966 */ 967 static ssize_t authorized_default_show(struct device *dev, 968 struct device_attribute *attr, char *buf) 969 { 970 struct usb_device *rh_usb_dev = to_usb_device(dev); 971 struct usb_bus *usb_bus = rh_usb_dev->bus; 972 struct usb_hcd *hcd; 973 974 hcd = bus_to_hcd(usb_bus); 975 return sysfs_emit(buf, "%u\n", hcd->dev_policy); 976 } 977 978 static ssize_t authorized_default_store(struct device *dev, 979 struct device_attribute *attr, 980 const char *buf, size_t size) 981 { 982 ssize_t result; 983 unsigned int val; 984 struct usb_device *rh_usb_dev = to_usb_device(dev); 985 struct usb_bus *usb_bus = rh_usb_dev->bus; 986 struct usb_hcd *hcd; 987 988 hcd = bus_to_hcd(usb_bus); 989 result = sscanf(buf, "%u\n", &val); 990 if (result == 1) { 991 hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ? 992 val : USB_DEVICE_AUTHORIZE_ALL; 993 result = size; 994 } else { 995 result = -EINVAL; 996 } 997 return result; 998 } 999 static DEVICE_ATTR_RW(authorized_default); 1000 1001 /* 1002 * interface_authorized_default_show - show default authorization status 1003 * for USB interfaces 1004 * 1005 * note: interface_authorized_default is the default value 1006 * for initializing the authorized attribute of interfaces 1007 */ 1008 static ssize_t interface_authorized_default_show(struct device *dev, 1009 struct device_attribute *attr, char *buf) 1010 { 1011 struct usb_device *usb_dev = to_usb_device(dev); 1012 struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus); 1013 1014 return sysfs_emit(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd)); 1015 } 1016 1017 /* 1018 * interface_authorized_default_store - store default authorization status 1019 * for USB interfaces 1020 * 1021 * note: interface_authorized_default is the default value 1022 * for initializing the authorized attribute of interfaces 1023 */ 1024 static ssize_t interface_authorized_default_store(struct device *dev, 1025 struct device_attribute *attr, const char *buf, size_t count) 1026 { 1027 struct usb_device *usb_dev = to_usb_device(dev); 1028 struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus); 1029 int rc = count; 1030 bool val; 1031 1032 if (kstrtobool(buf, &val) != 0) 1033 return -EINVAL; 1034 1035 if (val) 1036 set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags); 1037 else 1038 clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags); 1039 1040 return rc; 1041 } 1042 static DEVICE_ATTR_RW(interface_authorized_default); 1043 1044 /* Group all the USB bus attributes */ 1045 static struct attribute *usb_bus_attrs[] = { 1046 &dev_attr_authorized_default.attr, 1047 &dev_attr_interface_authorized_default.attr, 1048 NULL, 1049 }; 1050 1051 static const struct attribute_group usb_bus_attr_group = { 1052 .name = NULL, /* we want them in the same directory */ 1053 .attrs = usb_bus_attrs, 1054 }; 1055 1056 1057 static int add_default_authorized_attributes(struct device *dev) 1058 { 1059 int rc = 0; 1060 1061 if (is_usb_device(dev)) 1062 rc = sysfs_create_group(&dev->kobj, &usb_bus_attr_group); 1063 1064 return rc; 1065 } 1066 1067 static void remove_default_authorized_attributes(struct device *dev) 1068 { 1069 if (is_usb_device(dev)) { 1070 sysfs_remove_group(&dev->kobj, &usb_bus_attr_group); 1071 } 1072 } 1073 1074 int usb_create_sysfs_dev_files(struct usb_device *udev) 1075 { 1076 struct device *dev = &udev->dev; 1077 int retval; 1078 1079 retval = add_persist_attributes(dev); 1080 if (retval) 1081 goto error; 1082 1083 retval = add_power_attributes(dev); 1084 if (retval) 1085 goto error; 1086 1087 if (is_root_hub(udev)) { 1088 retval = add_default_authorized_attributes(dev); 1089 if (retval) 1090 goto error; 1091 } 1092 return retval; 1093 1094 error: 1095 usb_remove_sysfs_dev_files(udev); 1096 return retval; 1097 } 1098 1099 void usb_remove_sysfs_dev_files(struct usb_device *udev) 1100 { 1101 struct device *dev = &udev->dev; 1102 1103 if (is_root_hub(udev)) 1104 remove_default_authorized_attributes(dev); 1105 1106 remove_power_attributes(dev); 1107 remove_persist_attributes(dev); 1108 } 1109 1110 /* Interface Association Descriptor fields */ 1111 #define usb_intf_assoc_attr(field, format_string) \ 1112 static ssize_t \ 1113 iad_##field##_show(struct device *dev, struct device_attribute *attr, \ 1114 char *buf) \ 1115 { \ 1116 struct usb_interface *intf = to_usb_interface(dev); \ 1117 \ 1118 return sysfs_emit(buf, format_string, \ 1119 intf->intf_assoc->field); \ 1120 } \ 1121 static DEVICE_ATTR_RO(iad_##field) 1122 1123 usb_intf_assoc_attr(bFirstInterface, "%02x\n"); 1124 usb_intf_assoc_attr(bInterfaceCount, "%02d\n"); 1125 usb_intf_assoc_attr(bFunctionClass, "%02x\n"); 1126 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n"); 1127 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n"); 1128 1129 /* Interface fields */ 1130 #define usb_intf_attr(field, format_string) \ 1131 static ssize_t \ 1132 field##_show(struct device *dev, struct device_attribute *attr, \ 1133 char *buf) \ 1134 { \ 1135 struct usb_interface *intf = to_usb_interface(dev); \ 1136 \ 1137 return sysfs_emit(buf, format_string, \ 1138 intf->cur_altsetting->desc.field); \ 1139 } \ 1140 static DEVICE_ATTR_RO(field) 1141 1142 usb_intf_attr(bInterfaceNumber, "%02x\n"); 1143 usb_intf_attr(bAlternateSetting, "%2d\n"); 1144 usb_intf_attr(bNumEndpoints, "%02x\n"); 1145 usb_intf_attr(bInterfaceClass, "%02x\n"); 1146 usb_intf_attr(bInterfaceSubClass, "%02x\n"); 1147 usb_intf_attr(bInterfaceProtocol, "%02x\n"); 1148 1149 static ssize_t interface_show(struct device *dev, struct device_attribute *attr, 1150 char *buf) 1151 { 1152 struct usb_interface *intf; 1153 char *string; 1154 1155 intf = to_usb_interface(dev); 1156 string = READ_ONCE(intf->cur_altsetting->string); 1157 if (!string) 1158 return 0; 1159 return sysfs_emit(buf, "%s\n", string); 1160 } 1161 static DEVICE_ATTR_RO(interface); 1162 1163 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 1164 char *buf) 1165 { 1166 struct usb_interface *intf; 1167 struct usb_device *udev; 1168 struct usb_host_interface *alt; 1169 1170 intf = to_usb_interface(dev); 1171 udev = interface_to_usbdev(intf); 1172 alt = READ_ONCE(intf->cur_altsetting); 1173 1174 return sysfs_emit(buf, 1175 "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 1176 "ic%02Xisc%02Xip%02Xin%02X\n", 1177 le16_to_cpu(udev->descriptor.idVendor), 1178 le16_to_cpu(udev->descriptor.idProduct), 1179 le16_to_cpu(udev->descriptor.bcdDevice), 1180 udev->descriptor.bDeviceClass, 1181 udev->descriptor.bDeviceSubClass, 1182 udev->descriptor.bDeviceProtocol, 1183 alt->desc.bInterfaceClass, 1184 alt->desc.bInterfaceSubClass, 1185 alt->desc.bInterfaceProtocol, 1186 alt->desc.bInterfaceNumber); 1187 } 1188 static DEVICE_ATTR_RO(modalias); 1189 1190 static ssize_t supports_autosuspend_show(struct device *dev, 1191 struct device_attribute *attr, 1192 char *buf) 1193 { 1194 int s; 1195 1196 s = device_lock_interruptible(dev); 1197 if (s < 0) 1198 return -EINTR; 1199 /* Devices will be autosuspended even when an interface isn't claimed */ 1200 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend); 1201 device_unlock(dev); 1202 1203 return sysfs_emit(buf, "%u\n", s); 1204 } 1205 static DEVICE_ATTR_RO(supports_autosuspend); 1206 1207 /* 1208 * interface_authorized_show - show authorization status of an USB interface 1209 * 1 is authorized, 0 is deauthorized 1210 */ 1211 static ssize_t interface_authorized_show(struct device *dev, 1212 struct device_attribute *attr, char *buf) 1213 { 1214 struct usb_interface *intf = to_usb_interface(dev); 1215 1216 return sysfs_emit(buf, "%u\n", intf->authorized); 1217 } 1218 1219 /* 1220 * interface_authorized_store - authorize or deauthorize an USB interface 1221 */ 1222 static ssize_t interface_authorized_store(struct device *dev, 1223 struct device_attribute *attr, const char *buf, size_t count) 1224 { 1225 struct usb_interface *intf = to_usb_interface(dev); 1226 bool val; 1227 struct kernfs_node *kn; 1228 1229 if (kstrtobool(buf, &val) != 0) 1230 return -EINVAL; 1231 1232 if (val) { 1233 usb_authorize_interface(intf); 1234 } else { 1235 /* 1236 * Prevent deadlock if another process is concurrently 1237 * trying to unregister intf. 1238 */ 1239 kn = sysfs_break_active_protection(&dev->kobj, &attr->attr); 1240 if (kn) { 1241 usb_deauthorize_interface(intf); 1242 sysfs_unbreak_active_protection(kn); 1243 } 1244 } 1245 1246 return count; 1247 } 1248 static struct device_attribute dev_attr_interface_authorized = 1249 __ATTR(authorized, S_IRUGO | S_IWUSR, 1250 interface_authorized_show, interface_authorized_store); 1251 1252 static struct attribute *intf_attrs[] = { 1253 &dev_attr_bInterfaceNumber.attr, 1254 &dev_attr_bAlternateSetting.attr, 1255 &dev_attr_bNumEndpoints.attr, 1256 &dev_attr_bInterfaceClass.attr, 1257 &dev_attr_bInterfaceSubClass.attr, 1258 &dev_attr_bInterfaceProtocol.attr, 1259 &dev_attr_modalias.attr, 1260 &dev_attr_supports_autosuspend.attr, 1261 &dev_attr_interface_authorized.attr, 1262 NULL, 1263 }; 1264 static const struct attribute_group intf_attr_grp = { 1265 .attrs = intf_attrs, 1266 }; 1267 1268 static struct attribute *intf_assoc_attrs[] = { 1269 &dev_attr_iad_bFirstInterface.attr, 1270 &dev_attr_iad_bInterfaceCount.attr, 1271 &dev_attr_iad_bFunctionClass.attr, 1272 &dev_attr_iad_bFunctionSubClass.attr, 1273 &dev_attr_iad_bFunctionProtocol.attr, 1274 NULL, 1275 }; 1276 1277 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj, 1278 struct attribute *a, int n) 1279 { 1280 struct device *dev = kobj_to_dev(kobj); 1281 struct usb_interface *intf = to_usb_interface(dev); 1282 1283 if (intf->intf_assoc == NULL) 1284 return 0; 1285 return a->mode; 1286 } 1287 1288 static const struct attribute_group intf_assoc_attr_grp = { 1289 .attrs = intf_assoc_attrs, 1290 .is_visible = intf_assoc_attrs_are_visible, 1291 }; 1292 1293 static ssize_t wireless_status_show(struct device *dev, 1294 struct device_attribute *attr, char *buf) 1295 { 1296 struct usb_interface *intf; 1297 1298 intf = to_usb_interface(dev); 1299 if (intf->wireless_status == USB_WIRELESS_STATUS_DISCONNECTED) 1300 return sysfs_emit(buf, "%s\n", "disconnected"); 1301 return sysfs_emit(buf, "%s\n", "connected"); 1302 } 1303 static DEVICE_ATTR_RO(wireless_status); 1304 1305 static struct attribute *intf_wireless_status_attrs[] = { 1306 &dev_attr_wireless_status.attr, 1307 NULL 1308 }; 1309 1310 static umode_t intf_wireless_status_attr_is_visible(struct kobject *kobj, 1311 struct attribute *a, int n) 1312 { 1313 struct device *dev = kobj_to_dev(kobj); 1314 struct usb_interface *intf = to_usb_interface(dev); 1315 1316 if (a != &dev_attr_wireless_status.attr || 1317 intf->wireless_status != USB_WIRELESS_STATUS_NA) 1318 return a->mode; 1319 return 0; 1320 } 1321 1322 static const struct attribute_group intf_wireless_status_attr_grp = { 1323 .attrs = intf_wireless_status_attrs, 1324 .is_visible = intf_wireless_status_attr_is_visible, 1325 }; 1326 1327 int usb_update_wireless_status_attr(struct usb_interface *intf) 1328 { 1329 struct device *dev = &intf->dev; 1330 int ret; 1331 1332 ret = sysfs_update_group(&dev->kobj, &intf_wireless_status_attr_grp); 1333 if (ret < 0) 1334 return ret; 1335 1336 sysfs_notify(&dev->kobj, NULL, "wireless_status"); 1337 kobject_uevent(&dev->kobj, KOBJ_CHANGE); 1338 1339 return 0; 1340 } 1341 1342 const struct attribute_group *usb_interface_groups[] = { 1343 &intf_attr_grp, 1344 &intf_assoc_attr_grp, 1345 &intf_wireless_status_attr_grp, 1346 NULL 1347 }; 1348 1349 void usb_create_sysfs_intf_files(struct usb_interface *intf) 1350 { 1351 struct usb_device *udev = interface_to_usbdev(intf); 1352 struct usb_host_interface *alt = intf->cur_altsetting; 1353 1354 if (intf->sysfs_files_created || intf->unregistering) 1355 return; 1356 1357 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) 1358 alt->string = usb_cache_string(udev, alt->desc.iInterface); 1359 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface)) { 1360 /* This is not a serious error */ 1361 dev_dbg(&intf->dev, "interface string descriptor file not created\n"); 1362 } 1363 intf->sysfs_files_created = 1; 1364 } 1365 1366 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 1367 { 1368 if (!intf->sysfs_files_created) 1369 return; 1370 1371 device_remove_file(&intf->dev, &dev_attr_interface); 1372 intf->sysfs_files_created = 0; 1373 } 1374