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