1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * drivers/usb/core/sysfs.c 4 * 5 * (C) Copyright 2002 David Brownell 6 * (C) Copyright 2002,2004 Greg Kroah-Hartman 7 * (C) Copyright 2002,2004 IBM Corp. 8 * 9 * All of the sysfs file attributes for usb devices and interfaces. 10 * 11 * Released under the GPLv2 only. 12 */ 13 14 15 #include <linux/kernel.h> 16 #include <linux/string.h> 17 #include <linux/usb.h> 18 #include <linux/usb/quirks.h> 19 #include <linux/of.h> 20 #include "usb.h" 21 22 /* Active configuration fields */ 23 #define usb_actconfig_show(field, format_string) \ 24 static ssize_t field##_show(struct device *dev, \ 25 struct device_attribute *attr, char *buf) \ 26 { \ 27 struct usb_device *udev; \ 28 struct usb_host_config *actconfig; \ 29 ssize_t rc; \ 30 \ 31 udev = to_usb_device(dev); \ 32 rc = usb_lock_device_interruptible(udev); \ 33 if (rc < 0) \ 34 return -EINTR; \ 35 actconfig = udev->actconfig; \ 36 if (actconfig) \ 37 rc = sprintf(buf, format_string, \ 38 actconfig->desc.field); \ 39 usb_unlock_device(udev); \ 40 return rc; \ 41 } \ 42 43 #define usb_actconfig_attr(field, format_string) \ 44 usb_actconfig_show(field, format_string) \ 45 static DEVICE_ATTR_RO(field) 46 47 usb_actconfig_attr(bNumInterfaces, "%2d\n"); 48 usb_actconfig_attr(bmAttributes, "%2x\n"); 49 50 static ssize_t bMaxPower_show(struct device *dev, 51 struct device_attribute *attr, char *buf) 52 { 53 struct usb_device *udev; 54 struct usb_host_config *actconfig; 55 ssize_t rc; 56 57 udev = to_usb_device(dev); 58 rc = usb_lock_device_interruptible(udev); 59 if (rc < 0) 60 return -EINTR; 61 actconfig = udev->actconfig; 62 if (actconfig) 63 rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig)); 64 usb_unlock_device(udev); 65 return rc; 66 } 67 static DEVICE_ATTR_RO(bMaxPower); 68 69 static ssize_t configuration_show(struct device *dev, 70 struct device_attribute *attr, char *buf) 71 { 72 struct usb_device *udev; 73 struct usb_host_config *actconfig; 74 ssize_t rc; 75 76 udev = to_usb_device(dev); 77 rc = usb_lock_device_interruptible(udev); 78 if (rc < 0) 79 return -EINTR; 80 actconfig = udev->actconfig; 81 if (actconfig && actconfig->string) 82 rc = sprintf(buf, "%s\n", actconfig->string); 83 usb_unlock_device(udev); 84 return rc; 85 } 86 static DEVICE_ATTR_RO(configuration); 87 88 /* configuration value is always present, and r/w */ 89 usb_actconfig_show(bConfigurationValue, "%u\n"); 90 91 static ssize_t bConfigurationValue_store(struct device *dev, 92 struct device_attribute *attr, 93 const char *buf, size_t count) 94 { 95 struct usb_device *udev = to_usb_device(dev); 96 int config, value, rc; 97 98 if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255) 99 return -EINVAL; 100 rc = usb_lock_device_interruptible(udev); 101 if (rc < 0) 102 return -EINTR; 103 value = usb_set_configuration(udev, config); 104 usb_unlock_device(udev); 105 return (value < 0) ? value : count; 106 } 107 static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR, 108 bConfigurationValue_show, bConfigurationValue_store); 109 110 #ifdef CONFIG_OF 111 static ssize_t devspec_show(struct device *dev, struct device_attribute *attr, 112 char *buf) 113 { 114 struct device_node *of_node = dev->of_node; 115 116 return sprintf(buf, "%pOF\n", of_node); 117 } 118 static DEVICE_ATTR_RO(devspec); 119 #endif 120 121 /* String fields */ 122 #define usb_string_attr(name) \ 123 static ssize_t name##_show(struct device *dev, \ 124 struct device_attribute *attr, char *buf) \ 125 { \ 126 struct usb_device *udev; \ 127 int retval; \ 128 \ 129 udev = to_usb_device(dev); \ 130 retval = usb_lock_device_interruptible(udev); \ 131 if (retval < 0) \ 132 return -EINTR; \ 133 retval = sprintf(buf, "%s\n", udev->name); \ 134 usb_unlock_device(udev); \ 135 return retval; \ 136 } \ 137 static DEVICE_ATTR_RO(name) 138 139 usb_string_attr(product); 140 usb_string_attr(manufacturer); 141 usb_string_attr(serial); 142 143 static ssize_t speed_show(struct device *dev, struct device_attribute *attr, 144 char *buf) 145 { 146 struct usb_device *udev; 147 char *speed; 148 149 udev = to_usb_device(dev); 150 151 switch (udev->speed) { 152 case USB_SPEED_LOW: 153 speed = "1.5"; 154 break; 155 case USB_SPEED_UNKNOWN: 156 case USB_SPEED_FULL: 157 speed = "12"; 158 break; 159 case USB_SPEED_HIGH: 160 speed = "480"; 161 break; 162 case USB_SPEED_WIRELESS: 163 speed = "480"; 164 break; 165 case USB_SPEED_SUPER: 166 speed = "5000"; 167 break; 168 case USB_SPEED_SUPER_PLUS: 169 speed = "10000"; 170 break; 171 default: 172 speed = "unknown"; 173 } 174 return sprintf(buf, "%s\n", speed); 175 } 176 static DEVICE_ATTR_RO(speed); 177 178 static ssize_t busnum_show(struct device *dev, struct device_attribute *attr, 179 char *buf) 180 { 181 struct usb_device *udev; 182 183 udev = to_usb_device(dev); 184 return sprintf(buf, "%d\n", udev->bus->busnum); 185 } 186 static DEVICE_ATTR_RO(busnum); 187 188 static ssize_t devnum_show(struct device *dev, struct device_attribute *attr, 189 char *buf) 190 { 191 struct usb_device *udev; 192 193 udev = to_usb_device(dev); 194 return sprintf(buf, "%d\n", udev->devnum); 195 } 196 static DEVICE_ATTR_RO(devnum); 197 198 static ssize_t devpath_show(struct device *dev, struct device_attribute *attr, 199 char *buf) 200 { 201 struct usb_device *udev; 202 203 udev = to_usb_device(dev); 204 return sprintf(buf, "%s\n", udev->devpath); 205 } 206 static DEVICE_ATTR_RO(devpath); 207 208 static ssize_t version_show(struct device *dev, struct device_attribute *attr, 209 char *buf) 210 { 211 struct usb_device *udev; 212 u16 bcdUSB; 213 214 udev = to_usb_device(dev); 215 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB); 216 return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff); 217 } 218 static DEVICE_ATTR_RO(version); 219 220 static ssize_t maxchild_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 sprintf(buf, "%d\n", udev->maxchild); 227 } 228 static DEVICE_ATTR_RO(maxchild); 229 230 static ssize_t quirks_show(struct device *dev, struct device_attribute *attr, 231 char *buf) 232 { 233 struct usb_device *udev; 234 235 udev = to_usb_device(dev); 236 return sprintf(buf, "0x%x\n", udev->quirks); 237 } 238 static DEVICE_ATTR_RO(quirks); 239 240 static ssize_t avoid_reset_quirk_show(struct device *dev, 241 struct device_attribute *attr, char *buf) 242 { 243 struct usb_device *udev; 244 245 udev = to_usb_device(dev); 246 return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET)); 247 } 248 249 static ssize_t avoid_reset_quirk_store(struct device *dev, 250 struct device_attribute *attr, 251 const char *buf, size_t count) 252 { 253 struct usb_device *udev = to_usb_device(dev); 254 int val, rc; 255 256 if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1) 257 return -EINVAL; 258 rc = usb_lock_device_interruptible(udev); 259 if (rc < 0) 260 return -EINTR; 261 if (val) 262 udev->quirks |= USB_QUIRK_RESET; 263 else 264 udev->quirks &= ~USB_QUIRK_RESET; 265 usb_unlock_device(udev); 266 return count; 267 } 268 static DEVICE_ATTR_RW(avoid_reset_quirk); 269 270 static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr, 271 char *buf) 272 { 273 struct usb_device *udev; 274 275 udev = to_usb_device(dev); 276 return sprintf(buf, "%d\n", atomic_read(&udev->urbnum)); 277 } 278 static DEVICE_ATTR_RO(urbnum); 279 280 static ssize_t removable_show(struct device *dev, struct device_attribute *attr, 281 char *buf) 282 { 283 struct usb_device *udev; 284 char *state; 285 286 udev = to_usb_device(dev); 287 288 switch (udev->removable) { 289 case USB_DEVICE_REMOVABLE: 290 state = "removable"; 291 break; 292 case USB_DEVICE_FIXED: 293 state = "fixed"; 294 break; 295 default: 296 state = "unknown"; 297 } 298 299 return sprintf(buf, "%s\n", state); 300 } 301 static DEVICE_ATTR_RO(removable); 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 sprintf(buf, "%s\n", "yes"); 308 return sprintf(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 sprintf(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 int value, rc; 327 328 /* Hubs are always enabled for USB_PERSIST */ 329 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) 330 return -EPERM; 331 332 if (sscanf(buf, "%d", &value) != 1) 333 return -EINVAL; 334 335 rc = usb_lock_device_interruptible(udev); 336 if (rc < 0) 337 return -EINTR; 338 udev->persist_enabled = !!value; 339 usb_unlock_device(udev); 340 return count; 341 } 342 static DEVICE_ATTR_RW(persist); 343 344 static int add_persist_attributes(struct device *dev) 345 { 346 int rc = 0; 347 348 if (is_usb_device(dev)) { 349 struct usb_device *udev = to_usb_device(dev); 350 351 /* Hubs are automatically enabled for USB_PERSIST, 352 * no point in creating the attribute file. 353 */ 354 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB) 355 rc = sysfs_add_file_to_group(&dev->kobj, 356 &dev_attr_persist.attr, 357 power_group_name); 358 } 359 return rc; 360 } 361 362 static void remove_persist_attributes(struct device *dev) 363 { 364 sysfs_remove_file_from_group(&dev->kobj, 365 &dev_attr_persist.attr, 366 power_group_name); 367 } 368 369 static ssize_t connected_duration_show(struct device *dev, 370 struct device_attribute *attr, char *buf) 371 { 372 struct usb_device *udev = to_usb_device(dev); 373 374 return sprintf(buf, "%u\n", 375 jiffies_to_msecs(jiffies - udev->connect_time)); 376 } 377 static DEVICE_ATTR_RO(connected_duration); 378 379 /* 380 * If the device is resumed, the last time the device was suspended has 381 * been pre-subtracted from active_duration. We add the current time to 382 * get the duration that the device was actually active. 383 * 384 * If the device is suspended, the active_duration is up-to-date. 385 */ 386 static ssize_t active_duration_show(struct device *dev, 387 struct device_attribute *attr, char *buf) 388 { 389 struct usb_device *udev = to_usb_device(dev); 390 int duration; 391 392 if (udev->state != USB_STATE_SUSPENDED) 393 duration = jiffies_to_msecs(jiffies + udev->active_duration); 394 else 395 duration = jiffies_to_msecs(udev->active_duration); 396 return sprintf(buf, "%u\n", duration); 397 } 398 static DEVICE_ATTR_RO(active_duration); 399 400 static ssize_t autosuspend_show(struct device *dev, 401 struct device_attribute *attr, char *buf) 402 { 403 return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000); 404 } 405 406 static ssize_t autosuspend_store(struct device *dev, 407 struct device_attribute *attr, const char *buf, 408 size_t count) 409 { 410 int value; 411 412 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 || 413 value <= -INT_MAX/1000) 414 return -EINVAL; 415 416 pm_runtime_set_autosuspend_delay(dev, value * 1000); 417 return count; 418 } 419 static DEVICE_ATTR_RW(autosuspend); 420 421 static const char on_string[] = "on"; 422 static const char auto_string[] = "auto"; 423 424 static void warn_level(void) 425 { 426 static int level_warned; 427 428 if (!level_warned) { 429 level_warned = 1; 430 printk(KERN_WARNING "WARNING! power/level is deprecated; " 431 "use power/control instead\n"); 432 } 433 } 434 435 static ssize_t level_show(struct device *dev, struct device_attribute *attr, 436 char *buf) 437 { 438 struct usb_device *udev = to_usb_device(dev); 439 const char *p = auto_string; 440 441 warn_level(); 442 if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto) 443 p = on_string; 444 return sprintf(buf, "%s\n", p); 445 } 446 447 static ssize_t level_store(struct device *dev, struct device_attribute *attr, 448 const char *buf, size_t count) 449 { 450 struct usb_device *udev = to_usb_device(dev); 451 int len = count; 452 char *cp; 453 int rc = count; 454 int rv; 455 456 warn_level(); 457 cp = memchr(buf, '\n', count); 458 if (cp) 459 len = cp - buf; 460 461 rv = usb_lock_device_interruptible(udev); 462 if (rv < 0) 463 return -EINTR; 464 465 if (len == sizeof on_string - 1 && 466 strncmp(buf, on_string, len) == 0) 467 usb_disable_autosuspend(udev); 468 469 else if (len == sizeof auto_string - 1 && 470 strncmp(buf, auto_string, len) == 0) 471 usb_enable_autosuspend(udev); 472 473 else 474 rc = -EINVAL; 475 476 usb_unlock_device(udev); 477 return rc; 478 } 479 static DEVICE_ATTR_RW(level); 480 481 static ssize_t usb2_hardware_lpm_show(struct device *dev, 482 struct device_attribute *attr, char *buf) 483 { 484 struct usb_device *udev = to_usb_device(dev); 485 const char *p; 486 487 if (udev->usb2_hw_lpm_allowed == 1) 488 p = "enabled"; 489 else 490 p = "disabled"; 491 492 return sprintf(buf, "%s\n", p); 493 } 494 495 static ssize_t usb2_hardware_lpm_store(struct device *dev, 496 struct device_attribute *attr, 497 const char *buf, size_t count) 498 { 499 struct usb_device *udev = to_usb_device(dev); 500 bool value; 501 int ret; 502 503 ret = usb_lock_device_interruptible(udev); 504 if (ret < 0) 505 return -EINTR; 506 507 ret = strtobool(buf, &value); 508 509 if (!ret) { 510 udev->usb2_hw_lpm_allowed = value; 511 ret = usb_set_usb2_hardware_lpm(udev, value); 512 } 513 514 usb_unlock_device(udev); 515 516 if (!ret) 517 return count; 518 519 return ret; 520 } 521 static DEVICE_ATTR_RW(usb2_hardware_lpm); 522 523 static ssize_t usb2_lpm_l1_timeout_show(struct device *dev, 524 struct device_attribute *attr, 525 char *buf) 526 { 527 struct usb_device *udev = to_usb_device(dev); 528 return sprintf(buf, "%d\n", udev->l1_params.timeout); 529 } 530 531 static ssize_t usb2_lpm_l1_timeout_store(struct device *dev, 532 struct device_attribute *attr, 533 const char *buf, size_t count) 534 { 535 struct usb_device *udev = to_usb_device(dev); 536 u16 timeout; 537 538 if (kstrtou16(buf, 0, &timeout)) 539 return -EINVAL; 540 541 udev->l1_params.timeout = timeout; 542 543 return count; 544 } 545 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout); 546 547 static ssize_t usb2_lpm_besl_show(struct device *dev, 548 struct device_attribute *attr, char *buf) 549 { 550 struct usb_device *udev = to_usb_device(dev); 551 return sprintf(buf, "%d\n", udev->l1_params.besl); 552 } 553 554 static ssize_t usb2_lpm_besl_store(struct device *dev, 555 struct device_attribute *attr, 556 const char *buf, size_t count) 557 { 558 struct usb_device *udev = to_usb_device(dev); 559 u8 besl; 560 561 if (kstrtou8(buf, 0, &besl) || besl > 15) 562 return -EINVAL; 563 564 udev->l1_params.besl = besl; 565 566 return count; 567 } 568 static DEVICE_ATTR_RW(usb2_lpm_besl); 569 570 static ssize_t usb3_hardware_lpm_u1_show(struct device *dev, 571 struct device_attribute *attr, char *buf) 572 { 573 struct usb_device *udev = to_usb_device(dev); 574 const char *p; 575 int rc; 576 577 rc = usb_lock_device_interruptible(udev); 578 if (rc < 0) 579 return -EINTR; 580 581 if (udev->usb3_lpm_u1_enabled) 582 p = "enabled"; 583 else 584 p = "disabled"; 585 586 usb_unlock_device(udev); 587 588 return sprintf(buf, "%s\n", p); 589 } 590 static DEVICE_ATTR_RO(usb3_hardware_lpm_u1); 591 592 static ssize_t usb3_hardware_lpm_u2_show(struct device *dev, 593 struct device_attribute *attr, char *buf) 594 { 595 struct usb_device *udev = to_usb_device(dev); 596 const char *p; 597 int rc; 598 599 rc = usb_lock_device_interruptible(udev); 600 if (rc < 0) 601 return -EINTR; 602 603 if (udev->usb3_lpm_u2_enabled) 604 p = "enabled"; 605 else 606 p = "disabled"; 607 608 usb_unlock_device(udev); 609 610 return sprintf(buf, "%s\n", p); 611 } 612 static DEVICE_ATTR_RO(usb3_hardware_lpm_u2); 613 614 static struct attribute *usb2_hardware_lpm_attr[] = { 615 &dev_attr_usb2_hardware_lpm.attr, 616 &dev_attr_usb2_lpm_l1_timeout.attr, 617 &dev_attr_usb2_lpm_besl.attr, 618 NULL, 619 }; 620 static struct attribute_group usb2_hardware_lpm_attr_group = { 621 .name = power_group_name, 622 .attrs = usb2_hardware_lpm_attr, 623 }; 624 625 static struct attribute *usb3_hardware_lpm_attr[] = { 626 &dev_attr_usb3_hardware_lpm_u1.attr, 627 &dev_attr_usb3_hardware_lpm_u2.attr, 628 NULL, 629 }; 630 static struct attribute_group usb3_hardware_lpm_attr_group = { 631 .name = power_group_name, 632 .attrs = usb3_hardware_lpm_attr, 633 }; 634 635 static struct attribute *power_attrs[] = { 636 &dev_attr_autosuspend.attr, 637 &dev_attr_level.attr, 638 &dev_attr_connected_duration.attr, 639 &dev_attr_active_duration.attr, 640 NULL, 641 }; 642 static struct attribute_group power_attr_group = { 643 .name = power_group_name, 644 .attrs = power_attrs, 645 }; 646 647 static int add_power_attributes(struct device *dev) 648 { 649 int rc = 0; 650 651 if (is_usb_device(dev)) { 652 struct usb_device *udev = to_usb_device(dev); 653 rc = sysfs_merge_group(&dev->kobj, &power_attr_group); 654 if (udev->usb2_hw_lpm_capable == 1) 655 rc = sysfs_merge_group(&dev->kobj, 656 &usb2_hardware_lpm_attr_group); 657 if ((udev->speed == USB_SPEED_SUPER || 658 udev->speed == USB_SPEED_SUPER_PLUS) && 659 udev->lpm_capable == 1) 660 rc = sysfs_merge_group(&dev->kobj, 661 &usb3_hardware_lpm_attr_group); 662 } 663 664 return rc; 665 } 666 667 static void remove_power_attributes(struct device *dev) 668 { 669 sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group); 670 sysfs_unmerge_group(&dev->kobj, &power_attr_group); 671 } 672 673 #else 674 675 #define add_persist_attributes(dev) 0 676 #define remove_persist_attributes(dev) do {} while (0) 677 678 #define add_power_attributes(dev) 0 679 #define remove_power_attributes(dev) do {} while (0) 680 681 #endif /* CONFIG_PM */ 682 683 684 /* Descriptor fields */ 685 #define usb_descriptor_attr_le16(field, format_string) \ 686 static ssize_t \ 687 field##_show(struct device *dev, struct device_attribute *attr, \ 688 char *buf) \ 689 { \ 690 struct usb_device *udev; \ 691 \ 692 udev = to_usb_device(dev); \ 693 return sprintf(buf, format_string, \ 694 le16_to_cpu(udev->descriptor.field)); \ 695 } \ 696 static DEVICE_ATTR_RO(field) 697 698 usb_descriptor_attr_le16(idVendor, "%04x\n"); 699 usb_descriptor_attr_le16(idProduct, "%04x\n"); 700 usb_descriptor_attr_le16(bcdDevice, "%04x\n"); 701 702 #define usb_descriptor_attr(field, format_string) \ 703 static ssize_t \ 704 field##_show(struct device *dev, struct device_attribute *attr, \ 705 char *buf) \ 706 { \ 707 struct usb_device *udev; \ 708 \ 709 udev = to_usb_device(dev); \ 710 return sprintf(buf, format_string, udev->descriptor.field); \ 711 } \ 712 static DEVICE_ATTR_RO(field) 713 714 usb_descriptor_attr(bDeviceClass, "%02x\n"); 715 usb_descriptor_attr(bDeviceSubClass, "%02x\n"); 716 usb_descriptor_attr(bDeviceProtocol, "%02x\n"); 717 usb_descriptor_attr(bNumConfigurations, "%d\n"); 718 usb_descriptor_attr(bMaxPacketSize0, "%d\n"); 719 720 721 /* show if the device is authorized (1) or not (0) */ 722 static ssize_t authorized_show(struct device *dev, 723 struct device_attribute *attr, char *buf) 724 { 725 struct usb_device *usb_dev = to_usb_device(dev); 726 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized); 727 } 728 729 /* 730 * Authorize a device to be used in the system 731 * 732 * Writing a 0 deauthorizes the device, writing a 1 authorizes it. 733 */ 734 static ssize_t authorized_store(struct device *dev, 735 struct device_attribute *attr, const char *buf, 736 size_t size) 737 { 738 ssize_t result; 739 struct usb_device *usb_dev = to_usb_device(dev); 740 unsigned val; 741 result = sscanf(buf, "%u\n", &val); 742 if (result != 1) 743 result = -EINVAL; 744 else if (val == 0) 745 result = usb_deauthorize_device(usb_dev); 746 else 747 result = usb_authorize_device(usb_dev); 748 return result < 0 ? result : size; 749 } 750 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR, 751 authorized_show, authorized_store); 752 753 /* "Safely remove a device" */ 754 static ssize_t remove_store(struct device *dev, struct device_attribute *attr, 755 const char *buf, size_t count) 756 { 757 struct usb_device *udev = to_usb_device(dev); 758 int rc = 0; 759 760 usb_lock_device(udev); 761 if (udev->state != USB_STATE_NOTATTACHED) { 762 763 /* To avoid races, first unconfigure and then remove */ 764 usb_set_configuration(udev, -1); 765 rc = usb_remove_device(udev); 766 } 767 if (rc == 0) 768 rc = count; 769 usb_unlock_device(udev); 770 return rc; 771 } 772 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store); 773 774 775 static struct attribute *dev_attrs[] = { 776 /* current configuration's attributes */ 777 &dev_attr_configuration.attr, 778 &dev_attr_bNumInterfaces.attr, 779 &dev_attr_bConfigurationValue.attr, 780 &dev_attr_bmAttributes.attr, 781 &dev_attr_bMaxPower.attr, 782 /* device attributes */ 783 &dev_attr_urbnum.attr, 784 &dev_attr_idVendor.attr, 785 &dev_attr_idProduct.attr, 786 &dev_attr_bcdDevice.attr, 787 &dev_attr_bDeviceClass.attr, 788 &dev_attr_bDeviceSubClass.attr, 789 &dev_attr_bDeviceProtocol.attr, 790 &dev_attr_bNumConfigurations.attr, 791 &dev_attr_bMaxPacketSize0.attr, 792 &dev_attr_speed.attr, 793 &dev_attr_busnum.attr, 794 &dev_attr_devnum.attr, 795 &dev_attr_devpath.attr, 796 &dev_attr_version.attr, 797 &dev_attr_maxchild.attr, 798 &dev_attr_quirks.attr, 799 &dev_attr_avoid_reset_quirk.attr, 800 &dev_attr_authorized.attr, 801 &dev_attr_remove.attr, 802 &dev_attr_removable.attr, 803 &dev_attr_ltm_capable.attr, 804 #ifdef CONFIG_OF 805 &dev_attr_devspec.attr, 806 #endif 807 NULL, 808 }; 809 static struct attribute_group dev_attr_grp = { 810 .attrs = dev_attrs, 811 }; 812 813 /* When modifying this list, be sure to modify dev_string_attrs_are_visible() 814 * accordingly. 815 */ 816 static struct attribute *dev_string_attrs[] = { 817 &dev_attr_manufacturer.attr, 818 &dev_attr_product.attr, 819 &dev_attr_serial.attr, 820 NULL 821 }; 822 823 static umode_t dev_string_attrs_are_visible(struct kobject *kobj, 824 struct attribute *a, int n) 825 { 826 struct device *dev = container_of(kobj, struct device, kobj); 827 struct usb_device *udev = to_usb_device(dev); 828 829 if (a == &dev_attr_manufacturer.attr) { 830 if (udev->manufacturer == NULL) 831 return 0; 832 } else if (a == &dev_attr_product.attr) { 833 if (udev->product == NULL) 834 return 0; 835 } else if (a == &dev_attr_serial.attr) { 836 if (udev->serial == NULL) 837 return 0; 838 } 839 return a->mode; 840 } 841 842 static struct attribute_group dev_string_attr_grp = { 843 .attrs = dev_string_attrs, 844 .is_visible = dev_string_attrs_are_visible, 845 }; 846 847 const struct attribute_group *usb_device_groups[] = { 848 &dev_attr_grp, 849 &dev_string_attr_grp, 850 NULL 851 }; 852 853 /* Binary descriptors */ 854 855 static ssize_t 856 read_descriptors(struct file *filp, struct kobject *kobj, 857 struct bin_attribute *attr, 858 char *buf, loff_t off, size_t count) 859 { 860 struct device *dev = container_of(kobj, struct device, 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 894 static struct bin_attribute dev_bin_attr_descriptors = { 895 .attr = {.name = "descriptors", .mode = 0444}, 896 .read = read_descriptors, 897 .size = 18 + 65535, /* dev descr + max-size raw descriptor */ 898 }; 899 900 int usb_create_sysfs_dev_files(struct usb_device *udev) 901 { 902 struct device *dev = &udev->dev; 903 int retval; 904 905 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors); 906 if (retval) 907 goto error; 908 909 retval = add_persist_attributes(dev); 910 if (retval) 911 goto error; 912 913 retval = add_power_attributes(dev); 914 if (retval) 915 goto error; 916 return retval; 917 error: 918 usb_remove_sysfs_dev_files(udev); 919 return retval; 920 } 921 922 void usb_remove_sysfs_dev_files(struct usb_device *udev) 923 { 924 struct device *dev = &udev->dev; 925 926 remove_power_attributes(dev); 927 remove_persist_attributes(dev); 928 device_remove_bin_file(dev, &dev_bin_attr_descriptors); 929 } 930 931 /* Interface Association Descriptor fields */ 932 #define usb_intf_assoc_attr(field, format_string) \ 933 static ssize_t \ 934 iad_##field##_show(struct device *dev, struct device_attribute *attr, \ 935 char *buf) \ 936 { \ 937 struct usb_interface *intf = to_usb_interface(dev); \ 938 \ 939 return sprintf(buf, format_string, \ 940 intf->intf_assoc->field); \ 941 } \ 942 static DEVICE_ATTR_RO(iad_##field) 943 944 usb_intf_assoc_attr(bFirstInterface, "%02x\n"); 945 usb_intf_assoc_attr(bInterfaceCount, "%02d\n"); 946 usb_intf_assoc_attr(bFunctionClass, "%02x\n"); 947 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n"); 948 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n"); 949 950 /* Interface fields */ 951 #define usb_intf_attr(field, format_string) \ 952 static ssize_t \ 953 field##_show(struct device *dev, struct device_attribute *attr, \ 954 char *buf) \ 955 { \ 956 struct usb_interface *intf = to_usb_interface(dev); \ 957 \ 958 return sprintf(buf, format_string, \ 959 intf->cur_altsetting->desc.field); \ 960 } \ 961 static DEVICE_ATTR_RO(field) 962 963 usb_intf_attr(bInterfaceNumber, "%02x\n"); 964 usb_intf_attr(bAlternateSetting, "%2d\n"); 965 usb_intf_attr(bNumEndpoints, "%02x\n"); 966 usb_intf_attr(bInterfaceClass, "%02x\n"); 967 usb_intf_attr(bInterfaceSubClass, "%02x\n"); 968 usb_intf_attr(bInterfaceProtocol, "%02x\n"); 969 970 static ssize_t interface_show(struct device *dev, struct device_attribute *attr, 971 char *buf) 972 { 973 struct usb_interface *intf; 974 char *string; 975 976 intf = to_usb_interface(dev); 977 string = READ_ONCE(intf->cur_altsetting->string); 978 if (!string) 979 return 0; 980 return sprintf(buf, "%s\n", string); 981 } 982 static DEVICE_ATTR_RO(interface); 983 984 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 985 char *buf) 986 { 987 struct usb_interface *intf; 988 struct usb_device *udev; 989 struct usb_host_interface *alt; 990 991 intf = to_usb_interface(dev); 992 udev = interface_to_usbdev(intf); 993 alt = READ_ONCE(intf->cur_altsetting); 994 995 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 996 "ic%02Xisc%02Xip%02Xin%02X\n", 997 le16_to_cpu(udev->descriptor.idVendor), 998 le16_to_cpu(udev->descriptor.idProduct), 999 le16_to_cpu(udev->descriptor.bcdDevice), 1000 udev->descriptor.bDeviceClass, 1001 udev->descriptor.bDeviceSubClass, 1002 udev->descriptor.bDeviceProtocol, 1003 alt->desc.bInterfaceClass, 1004 alt->desc.bInterfaceSubClass, 1005 alt->desc.bInterfaceProtocol, 1006 alt->desc.bInterfaceNumber); 1007 } 1008 static DEVICE_ATTR_RO(modalias); 1009 1010 static ssize_t supports_autosuspend_show(struct device *dev, 1011 struct device_attribute *attr, 1012 char *buf) 1013 { 1014 int s; 1015 1016 s = device_lock_interruptible(dev); 1017 if (s < 0) 1018 return -EINTR; 1019 /* Devices will be autosuspended even when an interface isn't claimed */ 1020 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend); 1021 device_unlock(dev); 1022 1023 return sprintf(buf, "%u\n", s); 1024 } 1025 static DEVICE_ATTR_RO(supports_autosuspend); 1026 1027 /* 1028 * interface_authorized_show - show authorization status of an USB interface 1029 * 1 is authorized, 0 is deauthorized 1030 */ 1031 static ssize_t interface_authorized_show(struct device *dev, 1032 struct device_attribute *attr, char *buf) 1033 { 1034 struct usb_interface *intf = to_usb_interface(dev); 1035 1036 return sprintf(buf, "%u\n", intf->authorized); 1037 } 1038 1039 /* 1040 * interface_authorized_store - authorize or deauthorize an USB interface 1041 */ 1042 static ssize_t interface_authorized_store(struct device *dev, 1043 struct device_attribute *attr, const char *buf, size_t count) 1044 { 1045 struct usb_interface *intf = to_usb_interface(dev); 1046 bool val; 1047 1048 if (strtobool(buf, &val) != 0) 1049 return -EINVAL; 1050 1051 if (val) 1052 usb_authorize_interface(intf); 1053 else 1054 usb_deauthorize_interface(intf); 1055 1056 return count; 1057 } 1058 static struct device_attribute dev_attr_interface_authorized = 1059 __ATTR(authorized, S_IRUGO | S_IWUSR, 1060 interface_authorized_show, interface_authorized_store); 1061 1062 static struct attribute *intf_attrs[] = { 1063 &dev_attr_bInterfaceNumber.attr, 1064 &dev_attr_bAlternateSetting.attr, 1065 &dev_attr_bNumEndpoints.attr, 1066 &dev_attr_bInterfaceClass.attr, 1067 &dev_attr_bInterfaceSubClass.attr, 1068 &dev_attr_bInterfaceProtocol.attr, 1069 &dev_attr_modalias.attr, 1070 &dev_attr_supports_autosuspend.attr, 1071 &dev_attr_interface_authorized.attr, 1072 NULL, 1073 }; 1074 static struct attribute_group intf_attr_grp = { 1075 .attrs = intf_attrs, 1076 }; 1077 1078 static struct attribute *intf_assoc_attrs[] = { 1079 &dev_attr_iad_bFirstInterface.attr, 1080 &dev_attr_iad_bInterfaceCount.attr, 1081 &dev_attr_iad_bFunctionClass.attr, 1082 &dev_attr_iad_bFunctionSubClass.attr, 1083 &dev_attr_iad_bFunctionProtocol.attr, 1084 NULL, 1085 }; 1086 1087 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj, 1088 struct attribute *a, int n) 1089 { 1090 struct device *dev = container_of(kobj, struct device, kobj); 1091 struct usb_interface *intf = to_usb_interface(dev); 1092 1093 if (intf->intf_assoc == NULL) 1094 return 0; 1095 return a->mode; 1096 } 1097 1098 static struct attribute_group intf_assoc_attr_grp = { 1099 .attrs = intf_assoc_attrs, 1100 .is_visible = intf_assoc_attrs_are_visible, 1101 }; 1102 1103 const struct attribute_group *usb_interface_groups[] = { 1104 &intf_attr_grp, 1105 &intf_assoc_attr_grp, 1106 NULL 1107 }; 1108 1109 void usb_create_sysfs_intf_files(struct usb_interface *intf) 1110 { 1111 struct usb_device *udev = interface_to_usbdev(intf); 1112 struct usb_host_interface *alt = intf->cur_altsetting; 1113 1114 if (intf->sysfs_files_created || intf->unregistering) 1115 return; 1116 1117 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) 1118 alt->string = usb_cache_string(udev, alt->desc.iInterface); 1119 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface)) 1120 ; /* We don't actually care if the function fails. */ 1121 intf->sysfs_files_created = 1; 1122 } 1123 1124 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 1125 { 1126 if (!intf->sysfs_files_created) 1127 return; 1128 1129 device_remove_file(&intf->dev, &dev_attr_interface); 1130 intf->sysfs_files_created = 0; 1131 } 1132