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