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