1 /* 2 * drivers/usb/core/sysfs.c 3 * 4 * (C) Copyright 2002 David Brownell 5 * (C) Copyright 2002,2004 Greg Kroah-Hartman 6 * (C) Copyright 2002,2004 IBM Corp. 7 * 8 * All of the sysfs file attributes for usb devices and interfaces. 9 * 10 * Released under the GPLv2 only. 11 * SPDX-License-Identifier: GPL-2.0 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->lpm_capable == 1) 659 rc = sysfs_merge_group(&dev->kobj, 660 &usb3_hardware_lpm_attr_group); 661 } 662 663 return rc; 664 } 665 666 static void remove_power_attributes(struct device *dev) 667 { 668 sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group); 669 sysfs_unmerge_group(&dev->kobj, &power_attr_group); 670 } 671 672 #else 673 674 #define add_persist_attributes(dev) 0 675 #define remove_persist_attributes(dev) do {} while (0) 676 677 #define add_power_attributes(dev) 0 678 #define remove_power_attributes(dev) do {} while (0) 679 680 #endif /* CONFIG_PM */ 681 682 683 /* Descriptor fields */ 684 #define usb_descriptor_attr_le16(field, format_string) \ 685 static ssize_t \ 686 field##_show(struct device *dev, struct device_attribute *attr, \ 687 char *buf) \ 688 { \ 689 struct usb_device *udev; \ 690 \ 691 udev = to_usb_device(dev); \ 692 return sprintf(buf, format_string, \ 693 le16_to_cpu(udev->descriptor.field)); \ 694 } \ 695 static DEVICE_ATTR_RO(field) 696 697 usb_descriptor_attr_le16(idVendor, "%04x\n"); 698 usb_descriptor_attr_le16(idProduct, "%04x\n"); 699 usb_descriptor_attr_le16(bcdDevice, "%04x\n"); 700 701 #define usb_descriptor_attr(field, format_string) \ 702 static ssize_t \ 703 field##_show(struct device *dev, struct device_attribute *attr, \ 704 char *buf) \ 705 { \ 706 struct usb_device *udev; \ 707 \ 708 udev = to_usb_device(dev); \ 709 return sprintf(buf, format_string, udev->descriptor.field); \ 710 } \ 711 static DEVICE_ATTR_RO(field) 712 713 usb_descriptor_attr(bDeviceClass, "%02x\n"); 714 usb_descriptor_attr(bDeviceSubClass, "%02x\n"); 715 usb_descriptor_attr(bDeviceProtocol, "%02x\n"); 716 usb_descriptor_attr(bNumConfigurations, "%d\n"); 717 usb_descriptor_attr(bMaxPacketSize0, "%d\n"); 718 719 720 /* show if the device is authorized (1) or not (0) */ 721 static ssize_t authorized_show(struct device *dev, 722 struct device_attribute *attr, char *buf) 723 { 724 struct usb_device *usb_dev = to_usb_device(dev); 725 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized); 726 } 727 728 /* 729 * Authorize a device to be used in the system 730 * 731 * Writing a 0 deauthorizes the device, writing a 1 authorizes it. 732 */ 733 static ssize_t authorized_store(struct device *dev, 734 struct device_attribute *attr, const char *buf, 735 size_t size) 736 { 737 ssize_t result; 738 struct usb_device *usb_dev = to_usb_device(dev); 739 unsigned val; 740 result = sscanf(buf, "%u\n", &val); 741 if (result != 1) 742 result = -EINVAL; 743 else if (val == 0) 744 result = usb_deauthorize_device(usb_dev); 745 else 746 result = usb_authorize_device(usb_dev); 747 return result < 0 ? result : size; 748 } 749 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR, 750 authorized_show, authorized_store); 751 752 /* "Safely remove a device" */ 753 static ssize_t remove_store(struct device *dev, struct device_attribute *attr, 754 const char *buf, size_t count) 755 { 756 struct usb_device *udev = to_usb_device(dev); 757 int rc = 0; 758 759 usb_lock_device(udev); 760 if (udev->state != USB_STATE_NOTATTACHED) { 761 762 /* To avoid races, first unconfigure and then remove */ 763 usb_set_configuration(udev, -1); 764 rc = usb_remove_device(udev); 765 } 766 if (rc == 0) 767 rc = count; 768 usb_unlock_device(udev); 769 return rc; 770 } 771 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store); 772 773 774 static struct attribute *dev_attrs[] = { 775 /* current configuration's attributes */ 776 &dev_attr_configuration.attr, 777 &dev_attr_bNumInterfaces.attr, 778 &dev_attr_bConfigurationValue.attr, 779 &dev_attr_bmAttributes.attr, 780 &dev_attr_bMaxPower.attr, 781 /* device attributes */ 782 &dev_attr_urbnum.attr, 783 &dev_attr_idVendor.attr, 784 &dev_attr_idProduct.attr, 785 &dev_attr_bcdDevice.attr, 786 &dev_attr_bDeviceClass.attr, 787 &dev_attr_bDeviceSubClass.attr, 788 &dev_attr_bDeviceProtocol.attr, 789 &dev_attr_bNumConfigurations.attr, 790 &dev_attr_bMaxPacketSize0.attr, 791 &dev_attr_speed.attr, 792 &dev_attr_busnum.attr, 793 &dev_attr_devnum.attr, 794 &dev_attr_devpath.attr, 795 &dev_attr_version.attr, 796 &dev_attr_maxchild.attr, 797 &dev_attr_quirks.attr, 798 &dev_attr_avoid_reset_quirk.attr, 799 &dev_attr_authorized.attr, 800 &dev_attr_remove.attr, 801 &dev_attr_removable.attr, 802 &dev_attr_ltm_capable.attr, 803 #ifdef CONFIG_OF 804 &dev_attr_devspec.attr, 805 #endif 806 NULL, 807 }; 808 static struct attribute_group dev_attr_grp = { 809 .attrs = dev_attrs, 810 }; 811 812 /* When modifying this list, be sure to modify dev_string_attrs_are_visible() 813 * accordingly. 814 */ 815 static struct attribute *dev_string_attrs[] = { 816 &dev_attr_manufacturer.attr, 817 &dev_attr_product.attr, 818 &dev_attr_serial.attr, 819 NULL 820 }; 821 822 static umode_t dev_string_attrs_are_visible(struct kobject *kobj, 823 struct attribute *a, int n) 824 { 825 struct device *dev = container_of(kobj, struct device, kobj); 826 struct usb_device *udev = to_usb_device(dev); 827 828 if (a == &dev_attr_manufacturer.attr) { 829 if (udev->manufacturer == NULL) 830 return 0; 831 } else if (a == &dev_attr_product.attr) { 832 if (udev->product == NULL) 833 return 0; 834 } else if (a == &dev_attr_serial.attr) { 835 if (udev->serial == NULL) 836 return 0; 837 } 838 return a->mode; 839 } 840 841 static struct attribute_group dev_string_attr_grp = { 842 .attrs = dev_string_attrs, 843 .is_visible = dev_string_attrs_are_visible, 844 }; 845 846 const struct attribute_group *usb_device_groups[] = { 847 &dev_attr_grp, 848 &dev_string_attr_grp, 849 NULL 850 }; 851 852 /* Binary descriptors */ 853 854 static ssize_t 855 read_descriptors(struct file *filp, struct kobject *kobj, 856 struct bin_attribute *attr, 857 char *buf, loff_t off, size_t count) 858 { 859 struct device *dev = container_of(kobj, struct device, kobj); 860 struct usb_device *udev = to_usb_device(dev); 861 size_t nleft = count; 862 size_t srclen, n; 863 int cfgno; 864 void *src; 865 866 /* The binary attribute begins with the device descriptor. 867 * Following that are the raw descriptor entries for all the 868 * configurations (config plus subsidiary descriptors). 869 */ 870 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations && 871 nleft > 0; ++cfgno) { 872 if (cfgno < 0) { 873 src = &udev->descriptor; 874 srclen = sizeof(struct usb_device_descriptor); 875 } else { 876 src = udev->rawdescriptors[cfgno]; 877 srclen = __le16_to_cpu(udev->config[cfgno].desc. 878 wTotalLength); 879 } 880 if (off < srclen) { 881 n = min(nleft, srclen - (size_t) off); 882 memcpy(buf, src + off, n); 883 nleft -= n; 884 buf += n; 885 off = 0; 886 } else { 887 off -= srclen; 888 } 889 } 890 return count - nleft; 891 } 892 893 static struct bin_attribute dev_bin_attr_descriptors = { 894 .attr = {.name = "descriptors", .mode = 0444}, 895 .read = read_descriptors, 896 .size = 18 + 65535, /* dev descr + max-size raw descriptor */ 897 }; 898 899 int usb_create_sysfs_dev_files(struct usb_device *udev) 900 { 901 struct device *dev = &udev->dev; 902 int retval; 903 904 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors); 905 if (retval) 906 goto error; 907 908 retval = add_persist_attributes(dev); 909 if (retval) 910 goto error; 911 912 retval = add_power_attributes(dev); 913 if (retval) 914 goto error; 915 return retval; 916 error: 917 usb_remove_sysfs_dev_files(udev); 918 return retval; 919 } 920 921 void usb_remove_sysfs_dev_files(struct usb_device *udev) 922 { 923 struct device *dev = &udev->dev; 924 925 remove_power_attributes(dev); 926 remove_persist_attributes(dev); 927 device_remove_bin_file(dev, &dev_bin_attr_descriptors); 928 } 929 930 /* Interface Association Descriptor fields */ 931 #define usb_intf_assoc_attr(field, format_string) \ 932 static ssize_t \ 933 iad_##field##_show(struct device *dev, struct device_attribute *attr, \ 934 char *buf) \ 935 { \ 936 struct usb_interface *intf = to_usb_interface(dev); \ 937 \ 938 return sprintf(buf, format_string, \ 939 intf->intf_assoc->field); \ 940 } \ 941 static DEVICE_ATTR_RO(iad_##field) 942 943 usb_intf_assoc_attr(bFirstInterface, "%02x\n"); 944 usb_intf_assoc_attr(bInterfaceCount, "%02d\n"); 945 usb_intf_assoc_attr(bFunctionClass, "%02x\n"); 946 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n"); 947 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n"); 948 949 /* Interface fields */ 950 #define usb_intf_attr(field, format_string) \ 951 static ssize_t \ 952 field##_show(struct device *dev, struct device_attribute *attr, \ 953 char *buf) \ 954 { \ 955 struct usb_interface *intf = to_usb_interface(dev); \ 956 \ 957 return sprintf(buf, format_string, \ 958 intf->cur_altsetting->desc.field); \ 959 } \ 960 static DEVICE_ATTR_RO(field) 961 962 usb_intf_attr(bInterfaceNumber, "%02x\n"); 963 usb_intf_attr(bAlternateSetting, "%2d\n"); 964 usb_intf_attr(bNumEndpoints, "%02x\n"); 965 usb_intf_attr(bInterfaceClass, "%02x\n"); 966 usb_intf_attr(bInterfaceSubClass, "%02x\n"); 967 usb_intf_attr(bInterfaceProtocol, "%02x\n"); 968 969 static ssize_t interface_show(struct device *dev, struct device_attribute *attr, 970 char *buf) 971 { 972 struct usb_interface *intf; 973 char *string; 974 975 intf = to_usb_interface(dev); 976 string = READ_ONCE(intf->cur_altsetting->string); 977 if (!string) 978 return 0; 979 return sprintf(buf, "%s\n", string); 980 } 981 static DEVICE_ATTR_RO(interface); 982 983 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 984 char *buf) 985 { 986 struct usb_interface *intf; 987 struct usb_device *udev; 988 struct usb_host_interface *alt; 989 990 intf = to_usb_interface(dev); 991 udev = interface_to_usbdev(intf); 992 alt = READ_ONCE(intf->cur_altsetting); 993 994 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 995 "ic%02Xisc%02Xip%02Xin%02X\n", 996 le16_to_cpu(udev->descriptor.idVendor), 997 le16_to_cpu(udev->descriptor.idProduct), 998 le16_to_cpu(udev->descriptor.bcdDevice), 999 udev->descriptor.bDeviceClass, 1000 udev->descriptor.bDeviceSubClass, 1001 udev->descriptor.bDeviceProtocol, 1002 alt->desc.bInterfaceClass, 1003 alt->desc.bInterfaceSubClass, 1004 alt->desc.bInterfaceProtocol, 1005 alt->desc.bInterfaceNumber); 1006 } 1007 static DEVICE_ATTR_RO(modalias); 1008 1009 static ssize_t supports_autosuspend_show(struct device *dev, 1010 struct device_attribute *attr, 1011 char *buf) 1012 { 1013 int s; 1014 1015 s = device_lock_interruptible(dev); 1016 if (s < 0) 1017 return -EINTR; 1018 /* Devices will be autosuspended even when an interface isn't claimed */ 1019 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend); 1020 device_unlock(dev); 1021 1022 return sprintf(buf, "%u\n", s); 1023 } 1024 static DEVICE_ATTR_RO(supports_autosuspend); 1025 1026 /* 1027 * interface_authorized_show - show authorization status of an USB interface 1028 * 1 is authorized, 0 is deauthorized 1029 */ 1030 static ssize_t interface_authorized_show(struct device *dev, 1031 struct device_attribute *attr, char *buf) 1032 { 1033 struct usb_interface *intf = to_usb_interface(dev); 1034 1035 return sprintf(buf, "%u\n", intf->authorized); 1036 } 1037 1038 /* 1039 * interface_authorized_store - authorize or deauthorize an USB interface 1040 */ 1041 static ssize_t interface_authorized_store(struct device *dev, 1042 struct device_attribute *attr, const char *buf, size_t count) 1043 { 1044 struct usb_interface *intf = to_usb_interface(dev); 1045 bool val; 1046 1047 if (strtobool(buf, &val) != 0) 1048 return -EINVAL; 1049 1050 if (val) 1051 usb_authorize_interface(intf); 1052 else 1053 usb_deauthorize_interface(intf); 1054 1055 return count; 1056 } 1057 static struct device_attribute dev_attr_interface_authorized = 1058 __ATTR(authorized, S_IRUGO | S_IWUSR, 1059 interface_authorized_show, interface_authorized_store); 1060 1061 static struct attribute *intf_attrs[] = { 1062 &dev_attr_bInterfaceNumber.attr, 1063 &dev_attr_bAlternateSetting.attr, 1064 &dev_attr_bNumEndpoints.attr, 1065 &dev_attr_bInterfaceClass.attr, 1066 &dev_attr_bInterfaceSubClass.attr, 1067 &dev_attr_bInterfaceProtocol.attr, 1068 &dev_attr_modalias.attr, 1069 &dev_attr_supports_autosuspend.attr, 1070 &dev_attr_interface_authorized.attr, 1071 NULL, 1072 }; 1073 static struct attribute_group intf_attr_grp = { 1074 .attrs = intf_attrs, 1075 }; 1076 1077 static struct attribute *intf_assoc_attrs[] = { 1078 &dev_attr_iad_bFirstInterface.attr, 1079 &dev_attr_iad_bInterfaceCount.attr, 1080 &dev_attr_iad_bFunctionClass.attr, 1081 &dev_attr_iad_bFunctionSubClass.attr, 1082 &dev_attr_iad_bFunctionProtocol.attr, 1083 NULL, 1084 }; 1085 1086 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj, 1087 struct attribute *a, int n) 1088 { 1089 struct device *dev = container_of(kobj, struct device, kobj); 1090 struct usb_interface *intf = to_usb_interface(dev); 1091 1092 if (intf->intf_assoc == NULL) 1093 return 0; 1094 return a->mode; 1095 } 1096 1097 static struct attribute_group intf_assoc_attr_grp = { 1098 .attrs = intf_assoc_attrs, 1099 .is_visible = intf_assoc_attrs_are_visible, 1100 }; 1101 1102 const struct attribute_group *usb_interface_groups[] = { 1103 &intf_attr_grp, 1104 &intf_assoc_attr_grp, 1105 NULL 1106 }; 1107 1108 void usb_create_sysfs_intf_files(struct usb_interface *intf) 1109 { 1110 struct usb_device *udev = interface_to_usbdev(intf); 1111 struct usb_host_interface *alt = intf->cur_altsetting; 1112 1113 if (intf->sysfs_files_created || intf->unregistering) 1114 return; 1115 1116 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) 1117 alt->string = usb_cache_string(udev, alt->desc.iInterface); 1118 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface)) 1119 ; /* We don't actually care if the function fails. */ 1120 intf->sysfs_files_created = 1; 1121 } 1122 1123 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 1124 { 1125 if (!intf->sysfs_files_created) 1126 return; 1127 1128 device_remove_file(&intf->dev, &dev_attr_interface); 1129 intf->sysfs_files_created = 0; 1130 } 1131