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) \ 21 static 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 42 usb_actconfig_attr(bNumInterfaces, "%2d\n"); 43 usb_actconfig_attr(bmAttributes, "%2x\n"); 44 45 static 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 } 60 static DEVICE_ATTR_RO(bMaxPower); 61 62 static 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 } 77 static DEVICE_ATTR_RO(configuration); 78 79 /* configuration value is always present, and r/w */ 80 usb_actconfig_show(bConfigurationValue, "%u\n"); 81 82 static 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 } 96 static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR, 97 bConfigurationValue_show, bConfigurationValue_store); 98 99 /* String fields */ 100 #define usb_string_attr(name) \ 101 static 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 } \ 113 static DEVICE_ATTR_RO(name) 114 115 usb_string_attr(product); 116 usb_string_attr(manufacturer); 117 usb_string_attr(serial); 118 119 static 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 } 149 static DEVICE_ATTR_RO(speed); 150 151 static 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 } 159 static DEVICE_ATTR_RO(busnum); 160 161 static 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 } 169 static DEVICE_ATTR_RO(devnum); 170 171 static 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 } 179 static DEVICE_ATTR_RO(devpath); 180 181 static 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 } 191 static DEVICE_ATTR_RO(version); 192 193 static 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 } 201 static DEVICE_ATTR_RO(maxchild); 202 203 static 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 } 211 static DEVICE_ATTR_RO(quirks); 212 213 static 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 222 static 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 } 239 static DEVICE_ATTR_RW(avoid_reset_quirk); 240 241 static 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 } 249 static DEVICE_ATTR_RO(urbnum); 250 251 static 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 } 272 static DEVICE_ATTR_RO(removable); 273 274 static 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 } 281 static DEVICE_ATTR_RO(ltm_capable); 282 283 #ifdef CONFIG_PM 284 285 static 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 293 static 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 } 311 static DEVICE_ATTR_RW(persist); 312 313 static 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 331 static 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 #else 338 339 #define add_persist_attributes(dev) 0 340 #define remove_persist_attributes(dev) do {} while (0) 341 342 #endif /* CONFIG_PM */ 343 344 #ifdef CONFIG_PM_RUNTIME 345 346 static ssize_t connected_duration_show(struct device *dev, 347 struct device_attribute *attr, char *buf) 348 { 349 struct usb_device *udev = to_usb_device(dev); 350 351 return sprintf(buf, "%u\n", 352 jiffies_to_msecs(jiffies - udev->connect_time)); 353 } 354 static DEVICE_ATTR_RO(connected_duration); 355 356 /* 357 * If the device is resumed, the last time the device was suspended has 358 * been pre-subtracted from active_duration. We add the current time to 359 * get the duration that the device was actually active. 360 * 361 * If the device is suspended, the active_duration is up-to-date. 362 */ 363 static ssize_t active_duration_show(struct device *dev, 364 struct device_attribute *attr, char *buf) 365 { 366 struct usb_device *udev = to_usb_device(dev); 367 int duration; 368 369 if (udev->state != USB_STATE_SUSPENDED) 370 duration = jiffies_to_msecs(jiffies + udev->active_duration); 371 else 372 duration = jiffies_to_msecs(udev->active_duration); 373 return sprintf(buf, "%u\n", duration); 374 } 375 static DEVICE_ATTR_RO(active_duration); 376 377 static ssize_t autosuspend_show(struct device *dev, 378 struct device_attribute *attr, char *buf) 379 { 380 return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000); 381 } 382 383 static ssize_t autosuspend_store(struct device *dev, 384 struct device_attribute *attr, const char *buf, 385 size_t count) 386 { 387 int value; 388 389 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 || 390 value <= -INT_MAX/1000) 391 return -EINVAL; 392 393 pm_runtime_set_autosuspend_delay(dev, value * 1000); 394 return count; 395 } 396 static DEVICE_ATTR_RW(autosuspend); 397 398 static const char on_string[] = "on"; 399 static const char auto_string[] = "auto"; 400 401 static void warn_level(void) 402 { 403 static int level_warned; 404 405 if (!level_warned) { 406 level_warned = 1; 407 printk(KERN_WARNING "WARNING! power/level is deprecated; " 408 "use power/control instead\n"); 409 } 410 } 411 412 static ssize_t level_show(struct device *dev, struct device_attribute *attr, 413 char *buf) 414 { 415 struct usb_device *udev = to_usb_device(dev); 416 const char *p = auto_string; 417 418 warn_level(); 419 if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto) 420 p = on_string; 421 return sprintf(buf, "%s\n", p); 422 } 423 424 static ssize_t level_store(struct device *dev, struct device_attribute *attr, 425 const char *buf, size_t count) 426 { 427 struct usb_device *udev = to_usb_device(dev); 428 int len = count; 429 char *cp; 430 int rc = count; 431 432 warn_level(); 433 cp = memchr(buf, '\n', count); 434 if (cp) 435 len = cp - buf; 436 437 usb_lock_device(udev); 438 439 if (len == sizeof on_string - 1 && 440 strncmp(buf, on_string, len) == 0) 441 usb_disable_autosuspend(udev); 442 443 else if (len == sizeof auto_string - 1 && 444 strncmp(buf, auto_string, len) == 0) 445 usb_enable_autosuspend(udev); 446 447 else 448 rc = -EINVAL; 449 450 usb_unlock_device(udev); 451 return rc; 452 } 453 static DEVICE_ATTR_RW(level); 454 455 static ssize_t usb2_hardware_lpm_show(struct device *dev, 456 struct device_attribute *attr, char *buf) 457 { 458 struct usb_device *udev = to_usb_device(dev); 459 const char *p; 460 461 if (udev->usb2_hw_lpm_allowed == 1) 462 p = "enabled"; 463 else 464 p = "disabled"; 465 466 return sprintf(buf, "%s\n", p); 467 } 468 469 static ssize_t usb2_hardware_lpm_store(struct device *dev, 470 struct device_attribute *attr, 471 const char *buf, size_t count) 472 { 473 struct usb_device *udev = to_usb_device(dev); 474 bool value; 475 int ret; 476 477 usb_lock_device(udev); 478 479 ret = strtobool(buf, &value); 480 481 if (!ret) { 482 udev->usb2_hw_lpm_allowed = value; 483 ret = usb_set_usb2_hardware_lpm(udev, value); 484 } 485 486 usb_unlock_device(udev); 487 488 if (!ret) 489 return count; 490 491 return ret; 492 } 493 static DEVICE_ATTR_RW(usb2_hardware_lpm); 494 495 static ssize_t usb2_lpm_l1_timeout_show(struct device *dev, 496 struct device_attribute *attr, 497 char *buf) 498 { 499 struct usb_device *udev = to_usb_device(dev); 500 return sprintf(buf, "%d\n", udev->l1_params.timeout); 501 } 502 503 static ssize_t usb2_lpm_l1_timeout_store(struct device *dev, 504 struct device_attribute *attr, 505 const char *buf, size_t count) 506 { 507 struct usb_device *udev = to_usb_device(dev); 508 u16 timeout; 509 510 if (kstrtou16(buf, 0, &timeout)) 511 return -EINVAL; 512 513 udev->l1_params.timeout = timeout; 514 515 return count; 516 } 517 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout); 518 519 static ssize_t usb2_lpm_besl_show(struct device *dev, 520 struct device_attribute *attr, char *buf) 521 { 522 struct usb_device *udev = to_usb_device(dev); 523 return sprintf(buf, "%d\n", udev->l1_params.besl); 524 } 525 526 static ssize_t usb2_lpm_besl_store(struct device *dev, 527 struct device_attribute *attr, 528 const char *buf, size_t count) 529 { 530 struct usb_device *udev = to_usb_device(dev); 531 u8 besl; 532 533 if (kstrtou8(buf, 0, &besl) || besl > 15) 534 return -EINVAL; 535 536 udev->l1_params.besl = besl; 537 538 return count; 539 } 540 static DEVICE_ATTR_RW(usb2_lpm_besl); 541 542 static struct attribute *usb2_hardware_lpm_attr[] = { 543 &dev_attr_usb2_hardware_lpm.attr, 544 &dev_attr_usb2_lpm_l1_timeout.attr, 545 &dev_attr_usb2_lpm_besl.attr, 546 NULL, 547 }; 548 static struct attribute_group usb2_hardware_lpm_attr_group = { 549 .name = power_group_name, 550 .attrs = usb2_hardware_lpm_attr, 551 }; 552 553 static struct attribute *power_attrs[] = { 554 &dev_attr_autosuspend.attr, 555 &dev_attr_level.attr, 556 &dev_attr_connected_duration.attr, 557 &dev_attr_active_duration.attr, 558 NULL, 559 }; 560 static struct attribute_group power_attr_group = { 561 .name = power_group_name, 562 .attrs = power_attrs, 563 }; 564 565 static int add_power_attributes(struct device *dev) 566 { 567 int rc = 0; 568 569 if (is_usb_device(dev)) { 570 struct usb_device *udev = to_usb_device(dev); 571 rc = sysfs_merge_group(&dev->kobj, &power_attr_group); 572 if (udev->usb2_hw_lpm_capable == 1) 573 rc = sysfs_merge_group(&dev->kobj, 574 &usb2_hardware_lpm_attr_group); 575 } 576 577 return rc; 578 } 579 580 static void remove_power_attributes(struct device *dev) 581 { 582 sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group); 583 sysfs_unmerge_group(&dev->kobj, &power_attr_group); 584 } 585 586 #else 587 588 #define add_power_attributes(dev) 0 589 #define remove_power_attributes(dev) do {} while (0) 590 591 #endif /* CONFIG_PM_RUNTIME */ 592 593 594 /* Descriptor fields */ 595 #define usb_descriptor_attr_le16(field, format_string) \ 596 static ssize_t \ 597 field##_show(struct device *dev, struct device_attribute *attr, \ 598 char *buf) \ 599 { \ 600 struct usb_device *udev; \ 601 \ 602 udev = to_usb_device(dev); \ 603 return sprintf(buf, format_string, \ 604 le16_to_cpu(udev->descriptor.field)); \ 605 } \ 606 static DEVICE_ATTR_RO(field) 607 608 usb_descriptor_attr_le16(idVendor, "%04x\n"); 609 usb_descriptor_attr_le16(idProduct, "%04x\n"); 610 usb_descriptor_attr_le16(bcdDevice, "%04x\n"); 611 612 #define usb_descriptor_attr(field, format_string) \ 613 static ssize_t \ 614 field##_show(struct device *dev, struct device_attribute *attr, \ 615 char *buf) \ 616 { \ 617 struct usb_device *udev; \ 618 \ 619 udev = to_usb_device(dev); \ 620 return sprintf(buf, format_string, udev->descriptor.field); \ 621 } \ 622 static DEVICE_ATTR_RO(field) 623 624 usb_descriptor_attr(bDeviceClass, "%02x\n"); 625 usb_descriptor_attr(bDeviceSubClass, "%02x\n"); 626 usb_descriptor_attr(bDeviceProtocol, "%02x\n"); 627 usb_descriptor_attr(bNumConfigurations, "%d\n"); 628 usb_descriptor_attr(bMaxPacketSize0, "%d\n"); 629 630 631 /* show if the device is authorized (1) or not (0) */ 632 static ssize_t authorized_show(struct device *dev, 633 struct device_attribute *attr, char *buf) 634 { 635 struct usb_device *usb_dev = to_usb_device(dev); 636 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized); 637 } 638 639 /* 640 * Authorize a device to be used in the system 641 * 642 * Writing a 0 deauthorizes the device, writing a 1 authorizes it. 643 */ 644 static ssize_t authorized_store(struct device *dev, 645 struct device_attribute *attr, const char *buf, 646 size_t size) 647 { 648 ssize_t result; 649 struct usb_device *usb_dev = to_usb_device(dev); 650 unsigned val; 651 result = sscanf(buf, "%u\n", &val); 652 if (result != 1) 653 result = -EINVAL; 654 else if (val == 0) 655 result = usb_deauthorize_device(usb_dev); 656 else 657 result = usb_authorize_device(usb_dev); 658 return result < 0 ? result : size; 659 } 660 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR, 661 authorized_show, authorized_store); 662 663 /* "Safely remove a device" */ 664 static ssize_t remove_store(struct device *dev, struct device_attribute *attr, 665 const char *buf, size_t count) 666 { 667 struct usb_device *udev = to_usb_device(dev); 668 int rc = 0; 669 670 usb_lock_device(udev); 671 if (udev->state != USB_STATE_NOTATTACHED) { 672 673 /* To avoid races, first unconfigure and then remove */ 674 usb_set_configuration(udev, -1); 675 rc = usb_remove_device(udev); 676 } 677 if (rc == 0) 678 rc = count; 679 usb_unlock_device(udev); 680 return rc; 681 } 682 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store); 683 684 685 static struct attribute *dev_attrs[] = { 686 /* current configuration's attributes */ 687 &dev_attr_configuration.attr, 688 &dev_attr_bNumInterfaces.attr, 689 &dev_attr_bConfigurationValue.attr, 690 &dev_attr_bmAttributes.attr, 691 &dev_attr_bMaxPower.attr, 692 /* device attributes */ 693 &dev_attr_urbnum.attr, 694 &dev_attr_idVendor.attr, 695 &dev_attr_idProduct.attr, 696 &dev_attr_bcdDevice.attr, 697 &dev_attr_bDeviceClass.attr, 698 &dev_attr_bDeviceSubClass.attr, 699 &dev_attr_bDeviceProtocol.attr, 700 &dev_attr_bNumConfigurations.attr, 701 &dev_attr_bMaxPacketSize0.attr, 702 &dev_attr_speed.attr, 703 &dev_attr_busnum.attr, 704 &dev_attr_devnum.attr, 705 &dev_attr_devpath.attr, 706 &dev_attr_version.attr, 707 &dev_attr_maxchild.attr, 708 &dev_attr_quirks.attr, 709 &dev_attr_avoid_reset_quirk.attr, 710 &dev_attr_authorized.attr, 711 &dev_attr_remove.attr, 712 &dev_attr_removable.attr, 713 &dev_attr_ltm_capable.attr, 714 NULL, 715 }; 716 static struct attribute_group dev_attr_grp = { 717 .attrs = dev_attrs, 718 }; 719 720 /* When modifying this list, be sure to modify dev_string_attrs_are_visible() 721 * accordingly. 722 */ 723 static struct attribute *dev_string_attrs[] = { 724 &dev_attr_manufacturer.attr, 725 &dev_attr_product.attr, 726 &dev_attr_serial.attr, 727 NULL 728 }; 729 730 static umode_t dev_string_attrs_are_visible(struct kobject *kobj, 731 struct attribute *a, int n) 732 { 733 struct device *dev = container_of(kobj, struct device, kobj); 734 struct usb_device *udev = to_usb_device(dev); 735 736 if (a == &dev_attr_manufacturer.attr) { 737 if (udev->manufacturer == NULL) 738 return 0; 739 } else if (a == &dev_attr_product.attr) { 740 if (udev->product == NULL) 741 return 0; 742 } else if (a == &dev_attr_serial.attr) { 743 if (udev->serial == NULL) 744 return 0; 745 } 746 return a->mode; 747 } 748 749 static struct attribute_group dev_string_attr_grp = { 750 .attrs = dev_string_attrs, 751 .is_visible = dev_string_attrs_are_visible, 752 }; 753 754 const struct attribute_group *usb_device_groups[] = { 755 &dev_attr_grp, 756 &dev_string_attr_grp, 757 NULL 758 }; 759 760 /* Binary descriptors */ 761 762 static ssize_t 763 read_descriptors(struct file *filp, struct kobject *kobj, 764 struct bin_attribute *attr, 765 char *buf, loff_t off, size_t count) 766 { 767 struct device *dev = container_of(kobj, struct device, kobj); 768 struct usb_device *udev = to_usb_device(dev); 769 size_t nleft = count; 770 size_t srclen, n; 771 int cfgno; 772 void *src; 773 774 /* The binary attribute begins with the device descriptor. 775 * Following that are the raw descriptor entries for all the 776 * configurations (config plus subsidiary descriptors). 777 */ 778 usb_lock_device(udev); 779 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations && 780 nleft > 0; ++cfgno) { 781 if (cfgno < 0) { 782 src = &udev->descriptor; 783 srclen = sizeof(struct usb_device_descriptor); 784 } else { 785 src = udev->rawdescriptors[cfgno]; 786 srclen = __le16_to_cpu(udev->config[cfgno].desc. 787 wTotalLength); 788 } 789 if (off < srclen) { 790 n = min(nleft, srclen - (size_t) off); 791 memcpy(buf, src + off, n); 792 nleft -= n; 793 buf += n; 794 off = 0; 795 } else { 796 off -= srclen; 797 } 798 } 799 usb_unlock_device(udev); 800 return count - nleft; 801 } 802 803 static struct bin_attribute dev_bin_attr_descriptors = { 804 .attr = {.name = "descriptors", .mode = 0444}, 805 .read = read_descriptors, 806 .size = 18 + 65535, /* dev descr + max-size raw descriptor */ 807 }; 808 809 int usb_create_sysfs_dev_files(struct usb_device *udev) 810 { 811 struct device *dev = &udev->dev; 812 int retval; 813 814 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors); 815 if (retval) 816 goto error; 817 818 retval = add_persist_attributes(dev); 819 if (retval) 820 goto error; 821 822 retval = add_power_attributes(dev); 823 if (retval) 824 goto error; 825 return retval; 826 error: 827 usb_remove_sysfs_dev_files(udev); 828 return retval; 829 } 830 831 void usb_remove_sysfs_dev_files(struct usb_device *udev) 832 { 833 struct device *dev = &udev->dev; 834 835 remove_power_attributes(dev); 836 remove_persist_attributes(dev); 837 device_remove_bin_file(dev, &dev_bin_attr_descriptors); 838 } 839 840 /* Interface Association Descriptor fields */ 841 #define usb_intf_assoc_attr(field, format_string) \ 842 static ssize_t \ 843 iad_##field##_show(struct device *dev, struct device_attribute *attr, \ 844 char *buf) \ 845 { \ 846 struct usb_interface *intf = to_usb_interface(dev); \ 847 \ 848 return sprintf(buf, format_string, \ 849 intf->intf_assoc->field); \ 850 } \ 851 static DEVICE_ATTR_RO(iad_##field) 852 853 usb_intf_assoc_attr(bFirstInterface, "%02x\n"); 854 usb_intf_assoc_attr(bInterfaceCount, "%02d\n"); 855 usb_intf_assoc_attr(bFunctionClass, "%02x\n"); 856 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n"); 857 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n"); 858 859 /* Interface fields */ 860 #define usb_intf_attr(field, format_string) \ 861 static ssize_t \ 862 field##_show(struct device *dev, struct device_attribute *attr, \ 863 char *buf) \ 864 { \ 865 struct usb_interface *intf = to_usb_interface(dev); \ 866 \ 867 return sprintf(buf, format_string, \ 868 intf->cur_altsetting->desc.field); \ 869 } \ 870 static DEVICE_ATTR_RO(field) 871 872 usb_intf_attr(bInterfaceNumber, "%02x\n"); 873 usb_intf_attr(bAlternateSetting, "%2d\n"); 874 usb_intf_attr(bNumEndpoints, "%02x\n"); 875 usb_intf_attr(bInterfaceClass, "%02x\n"); 876 usb_intf_attr(bInterfaceSubClass, "%02x\n"); 877 usb_intf_attr(bInterfaceProtocol, "%02x\n"); 878 879 static ssize_t interface_show(struct device *dev, struct device_attribute *attr, 880 char *buf) 881 { 882 struct usb_interface *intf; 883 char *string; 884 885 intf = to_usb_interface(dev); 886 string = ACCESS_ONCE(intf->cur_altsetting->string); 887 if (!string) 888 return 0; 889 return sprintf(buf, "%s\n", string); 890 } 891 static DEVICE_ATTR_RO(interface); 892 893 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 894 char *buf) 895 { 896 struct usb_interface *intf; 897 struct usb_device *udev; 898 struct usb_host_interface *alt; 899 900 intf = to_usb_interface(dev); 901 udev = interface_to_usbdev(intf); 902 alt = ACCESS_ONCE(intf->cur_altsetting); 903 904 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 905 "ic%02Xisc%02Xip%02Xin%02X\n", 906 le16_to_cpu(udev->descriptor.idVendor), 907 le16_to_cpu(udev->descriptor.idProduct), 908 le16_to_cpu(udev->descriptor.bcdDevice), 909 udev->descriptor.bDeviceClass, 910 udev->descriptor.bDeviceSubClass, 911 udev->descriptor.bDeviceProtocol, 912 alt->desc.bInterfaceClass, 913 alt->desc.bInterfaceSubClass, 914 alt->desc.bInterfaceProtocol, 915 alt->desc.bInterfaceNumber); 916 } 917 static DEVICE_ATTR_RO(modalias); 918 919 static ssize_t supports_autosuspend_show(struct device *dev, 920 struct device_attribute *attr, 921 char *buf) 922 { 923 int s; 924 925 device_lock(dev); 926 /* Devices will be autosuspended even when an interface isn't claimed */ 927 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend); 928 device_unlock(dev); 929 930 return sprintf(buf, "%u\n", s); 931 } 932 static DEVICE_ATTR_RO(supports_autosuspend); 933 934 static struct attribute *intf_attrs[] = { 935 &dev_attr_bInterfaceNumber.attr, 936 &dev_attr_bAlternateSetting.attr, 937 &dev_attr_bNumEndpoints.attr, 938 &dev_attr_bInterfaceClass.attr, 939 &dev_attr_bInterfaceSubClass.attr, 940 &dev_attr_bInterfaceProtocol.attr, 941 &dev_attr_modalias.attr, 942 &dev_attr_supports_autosuspend.attr, 943 NULL, 944 }; 945 static struct attribute_group intf_attr_grp = { 946 .attrs = intf_attrs, 947 }; 948 949 static struct attribute *intf_assoc_attrs[] = { 950 &dev_attr_iad_bFirstInterface.attr, 951 &dev_attr_iad_bInterfaceCount.attr, 952 &dev_attr_iad_bFunctionClass.attr, 953 &dev_attr_iad_bFunctionSubClass.attr, 954 &dev_attr_iad_bFunctionProtocol.attr, 955 NULL, 956 }; 957 958 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj, 959 struct attribute *a, int n) 960 { 961 struct device *dev = container_of(kobj, struct device, kobj); 962 struct usb_interface *intf = to_usb_interface(dev); 963 964 if (intf->intf_assoc == NULL) 965 return 0; 966 return a->mode; 967 } 968 969 static struct attribute_group intf_assoc_attr_grp = { 970 .attrs = intf_assoc_attrs, 971 .is_visible = intf_assoc_attrs_are_visible, 972 }; 973 974 const struct attribute_group *usb_interface_groups[] = { 975 &intf_attr_grp, 976 &intf_assoc_attr_grp, 977 NULL 978 }; 979 980 void usb_create_sysfs_intf_files(struct usb_interface *intf) 981 { 982 struct usb_device *udev = interface_to_usbdev(intf); 983 struct usb_host_interface *alt = intf->cur_altsetting; 984 985 if (intf->sysfs_files_created || intf->unregistering) 986 return; 987 988 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) 989 alt->string = usb_cache_string(udev, alt->desc.iInterface); 990 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface)) 991 ; /* We don't actually care if the function fails. */ 992 intf->sysfs_files_created = 1; 993 } 994 995 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 996 { 997 if (!intf->sysfs_files_created) 998 return; 999 1000 device_remove_file(&intf->dev, &dev_attr_interface); 1001 intf->sysfs_files_created = 0; 1002 } 1003