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 338 static 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 } 346 static 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 */ 355 static 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 } 367 static DEVICE_ATTR_RO(active_duration); 368 369 static 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 375 static 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 } 388 static DEVICE_ATTR_RW(autosuspend); 389 390 static const char on_string[] = "on"; 391 static const char auto_string[] = "auto"; 392 393 static 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 404 static 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 416 static 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 } 445 static DEVICE_ATTR_RW(level); 446 447 static 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 461 static 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 } 485 static DEVICE_ATTR_RW(usb2_hardware_lpm); 486 487 static 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 495 static 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 } 509 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout); 510 511 static 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 518 static 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 } 532 static DEVICE_ATTR_RW(usb2_lpm_besl); 533 534 static 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 }; 540 static struct attribute_group usb2_hardware_lpm_attr_group = { 541 .name = power_group_name, 542 .attrs = usb2_hardware_lpm_attr, 543 }; 544 545 static 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 }; 552 static struct attribute_group power_attr_group = { 553 .name = power_group_name, 554 .attrs = power_attrs, 555 }; 556 557 static 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 572 static 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) \ 591 static ssize_t \ 592 field##_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 } \ 601 static DEVICE_ATTR_RO(field) 602 603 usb_descriptor_attr_le16(idVendor, "%04x\n"); 604 usb_descriptor_attr_le16(idProduct, "%04x\n"); 605 usb_descriptor_attr_le16(bcdDevice, "%04x\n"); 606 607 #define usb_descriptor_attr(field, format_string) \ 608 static ssize_t \ 609 field##_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 } \ 617 static DEVICE_ATTR_RO(field) 618 619 usb_descriptor_attr(bDeviceClass, "%02x\n"); 620 usb_descriptor_attr(bDeviceSubClass, "%02x\n"); 621 usb_descriptor_attr(bDeviceProtocol, "%02x\n"); 622 usb_descriptor_attr(bNumConfigurations, "%d\n"); 623 usb_descriptor_attr(bMaxPacketSize0, "%d\n"); 624 625 626 /* show if the device is authorized (1) or not (0) */ 627 static 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 */ 639 static 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 } 655 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR, 656 authorized_show, authorized_store); 657 658 /* "Safely remove a device" */ 659 static 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 } 677 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store); 678 679 680 static 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 }; 711 static 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 */ 718 static struct attribute *dev_string_attrs[] = { 719 &dev_attr_manufacturer.attr, 720 &dev_attr_product.attr, 721 &dev_attr_serial.attr, 722 NULL 723 }; 724 725 static 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 744 static struct attribute_group dev_string_attr_grp = { 745 .attrs = dev_string_attrs, 746 .is_visible = dev_string_attrs_are_visible, 747 }; 748 749 const struct attribute_group *usb_device_groups[] = { 750 &dev_attr_grp, 751 &dev_string_attr_grp, 752 NULL 753 }; 754 755 /* Binary descriptors */ 756 757 static ssize_t 758 read_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 798 static 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 804 int 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; 821 error: 822 usb_remove_sysfs_dev_files(udev); 823 return retval; 824 } 825 826 void 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) \ 837 static ssize_t \ 838 iad_##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 } \ 846 static DEVICE_ATTR_RO(iad_##field) 847 848 usb_intf_assoc_attr(bFirstInterface, "%02x\n"); 849 usb_intf_assoc_attr(bInterfaceCount, "%02d\n"); 850 usb_intf_assoc_attr(bFunctionClass, "%02x\n"); 851 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n"); 852 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n"); 853 854 /* Interface fields */ 855 #define usb_intf_attr(field, format_string) \ 856 static ssize_t \ 857 field##_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 } \ 865 static DEVICE_ATTR_RO(field) 866 867 usb_intf_attr(bInterfaceNumber, "%02x\n"); 868 usb_intf_attr(bAlternateSetting, "%2d\n"); 869 usb_intf_attr(bNumEndpoints, "%02x\n"); 870 usb_intf_attr(bInterfaceClass, "%02x\n"); 871 usb_intf_attr(bInterfaceSubClass, "%02x\n"); 872 usb_intf_attr(bInterfaceProtocol, "%02x\n"); 873 874 static 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 } 886 static DEVICE_ATTR_RO(interface); 887 888 static 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 } 912 static DEVICE_ATTR_RO(modalias); 913 914 static 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 } 927 static DEVICE_ATTR_RO(supports_autosuspend); 928 929 static 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 }; 940 static struct attribute_group intf_attr_grp = { 941 .attrs = intf_attrs, 942 }; 943 944 static 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 953 static 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 964 static struct attribute_group intf_assoc_attr_grp = { 965 .attrs = intf_assoc_attrs, 966 .is_visible = intf_assoc_attrs_are_visible, 967 }; 968 969 const struct attribute_group *usb_interface_groups[] = { 970 &intf_attr_grp, 971 &intf_assoc_attr_grp, 972 NULL 973 }; 974 975 void 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 990 void 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