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, multiplier, format_string) \ 21 static ssize_t show_##field(struct device *dev, \ 22 struct device_attribute *attr, char *buf) \ 23 { \ 24 struct usb_device *udev; \ 25 struct usb_host_config *actconfig; \ 26 \ 27 udev = to_usb_device(dev); \ 28 actconfig = udev->actconfig; \ 29 if (actconfig) \ 30 return sprintf(buf, format_string, \ 31 actconfig->desc.field * multiplier); \ 32 else \ 33 return 0; \ 34 } \ 35 36 #define usb_actconfig_attr(field, multiplier, format_string) \ 37 usb_actconfig_show(field, multiplier, format_string) \ 38 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 39 40 usb_actconfig_attr(bNumInterfaces, 1, "%2d\n") 41 usb_actconfig_attr(bmAttributes, 1, "%2x\n") 42 usb_actconfig_attr(bMaxPower, 2, "%3dmA\n") 43 44 static ssize_t show_configuration_string(struct device *dev, 45 struct device_attribute *attr, char *buf) 46 { 47 struct usb_device *udev; 48 struct usb_host_config *actconfig; 49 50 udev = to_usb_device(dev); 51 actconfig = udev->actconfig; 52 if ((!actconfig) || (!actconfig->string)) 53 return 0; 54 return sprintf(buf, "%s\n", actconfig->string); 55 } 56 static DEVICE_ATTR(configuration, S_IRUGO, show_configuration_string, NULL); 57 58 /* configuration value is always present, and r/w */ 59 usb_actconfig_show(bConfigurationValue, 1, "%u\n"); 60 61 static ssize_t 62 set_bConfigurationValue(struct device *dev, struct device_attribute *attr, 63 const char *buf, size_t count) 64 { 65 struct usb_device *udev = to_usb_device(dev); 66 int config, value; 67 68 if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255) 69 return -EINVAL; 70 usb_lock_device(udev); 71 value = usb_set_configuration(udev, config); 72 usb_unlock_device(udev); 73 return (value < 0) ? value : count; 74 } 75 76 static DEVICE_ATTR(bConfigurationValue, S_IRUGO | S_IWUSR, 77 show_bConfigurationValue, set_bConfigurationValue); 78 79 /* String fields */ 80 #define usb_string_attr(name) \ 81 static ssize_t show_##name(struct device *dev, \ 82 struct device_attribute *attr, char *buf) \ 83 { \ 84 struct usb_device *udev; \ 85 \ 86 udev = to_usb_device(dev); \ 87 return sprintf(buf, "%s\n", udev->name); \ 88 } \ 89 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL); 90 91 usb_string_attr(product); 92 usb_string_attr(manufacturer); 93 usb_string_attr(serial); 94 95 static ssize_t 96 show_speed(struct device *dev, struct device_attribute *attr, char *buf) 97 { 98 struct usb_device *udev; 99 char *speed; 100 101 udev = to_usb_device(dev); 102 103 switch (udev->speed) { 104 case USB_SPEED_LOW: 105 speed = "1.5"; 106 break; 107 case USB_SPEED_UNKNOWN: 108 case USB_SPEED_FULL: 109 speed = "12"; 110 break; 111 case USB_SPEED_HIGH: 112 speed = "480"; 113 break; 114 default: 115 speed = "unknown"; 116 } 117 return sprintf(buf, "%s\n", speed); 118 } 119 static DEVICE_ATTR(speed, S_IRUGO, show_speed, NULL); 120 121 static ssize_t 122 show_busnum(struct device *dev, struct device_attribute *attr, char *buf) 123 { 124 struct usb_device *udev; 125 126 udev = to_usb_device(dev); 127 return sprintf(buf, "%d\n", udev->bus->busnum); 128 } 129 static DEVICE_ATTR(busnum, S_IRUGO, show_busnum, NULL); 130 131 static ssize_t 132 show_devnum(struct device *dev, struct device_attribute *attr, char *buf) 133 { 134 struct usb_device *udev; 135 136 udev = to_usb_device(dev); 137 return sprintf(buf, "%d\n", udev->devnum); 138 } 139 static DEVICE_ATTR(devnum, S_IRUGO, show_devnum, NULL); 140 141 static ssize_t 142 show_version(struct device *dev, struct device_attribute *attr, char *buf) 143 { 144 struct usb_device *udev; 145 u16 bcdUSB; 146 147 udev = to_usb_device(dev); 148 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB); 149 return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff); 150 } 151 static DEVICE_ATTR(version, S_IRUGO, show_version, NULL); 152 153 static ssize_t 154 show_maxchild(struct device *dev, struct device_attribute *attr, char *buf) 155 { 156 struct usb_device *udev; 157 158 udev = to_usb_device(dev); 159 return sprintf(buf, "%d\n", udev->maxchild); 160 } 161 static DEVICE_ATTR(maxchild, S_IRUGO, show_maxchild, NULL); 162 163 static ssize_t 164 show_quirks(struct device *dev, struct device_attribute *attr, char *buf) 165 { 166 struct usb_device *udev; 167 168 udev = to_usb_device(dev); 169 return sprintf(buf, "0x%x\n", udev->quirks); 170 } 171 static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL); 172 173 static ssize_t 174 show_urbnum(struct device *dev, struct device_attribute *attr, char *buf) 175 { 176 struct usb_device *udev; 177 178 udev = to_usb_device(dev); 179 return sprintf(buf, "%d\n", atomic_read(&udev->urbnum)); 180 } 181 static DEVICE_ATTR(urbnum, S_IRUGO, show_urbnum, NULL); 182 183 184 #ifdef CONFIG_PM 185 186 static const char power_group[] = "power"; 187 188 static ssize_t 189 show_persist(struct device *dev, struct device_attribute *attr, char *buf) 190 { 191 struct usb_device *udev = to_usb_device(dev); 192 193 return sprintf(buf, "%d\n", udev->persist_enabled); 194 } 195 196 static ssize_t 197 set_persist(struct device *dev, struct device_attribute *attr, 198 const char *buf, size_t count) 199 { 200 struct usb_device *udev = to_usb_device(dev); 201 int value; 202 203 /* Hubs are always enabled for USB_PERSIST */ 204 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) 205 return -EPERM; 206 207 if (sscanf(buf, "%d", &value) != 1) 208 return -EINVAL; 209 usb_pm_lock(udev); 210 udev->persist_enabled = !!value; 211 usb_pm_unlock(udev); 212 return count; 213 } 214 215 static DEVICE_ATTR(persist, S_IRUGO | S_IWUSR, show_persist, set_persist); 216 217 static int add_persist_attributes(struct device *dev) 218 { 219 int rc = 0; 220 221 if (is_usb_device(dev)) { 222 struct usb_device *udev = to_usb_device(dev); 223 224 /* Hubs are automatically enabled for USB_PERSIST, 225 * no point in creating the attribute file. 226 */ 227 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB) 228 rc = sysfs_add_file_to_group(&dev->kobj, 229 &dev_attr_persist.attr, 230 power_group); 231 } 232 return rc; 233 } 234 235 static void remove_persist_attributes(struct device *dev) 236 { 237 sysfs_remove_file_from_group(&dev->kobj, 238 &dev_attr_persist.attr, 239 power_group); 240 } 241 #else 242 243 #define add_persist_attributes(dev) 0 244 #define remove_persist_attributes(dev) do {} while (0) 245 246 #endif /* CONFIG_PM */ 247 248 #ifdef CONFIG_USB_SUSPEND 249 250 static ssize_t 251 show_connected_duration(struct device *dev, struct device_attribute *attr, 252 char *buf) 253 { 254 struct usb_device *udev = to_usb_device(dev); 255 256 return sprintf(buf, "%u\n", 257 jiffies_to_msecs(jiffies - udev->connect_time)); 258 } 259 260 static DEVICE_ATTR(connected_duration, S_IRUGO, show_connected_duration, NULL); 261 262 /* 263 * If the device is resumed, the last time the device was suspended has 264 * been pre-subtracted from active_duration. We add the current time to 265 * get the duration that the device was actually active. 266 * 267 * If the device is suspended, the active_duration is up-to-date. 268 */ 269 static ssize_t 270 show_active_duration(struct device *dev, struct device_attribute *attr, 271 char *buf) 272 { 273 struct usb_device *udev = to_usb_device(dev); 274 int duration; 275 276 if (udev->state != USB_STATE_SUSPENDED) 277 duration = jiffies_to_msecs(jiffies + udev->active_duration); 278 else 279 duration = jiffies_to_msecs(udev->active_duration); 280 return sprintf(buf, "%u\n", duration); 281 } 282 283 static DEVICE_ATTR(active_duration, S_IRUGO, show_active_duration, NULL); 284 285 static ssize_t 286 show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf) 287 { 288 struct usb_device *udev = to_usb_device(dev); 289 290 return sprintf(buf, "%d\n", udev->autosuspend_delay / HZ); 291 } 292 293 static ssize_t 294 set_autosuspend(struct device *dev, struct device_attribute *attr, 295 const char *buf, size_t count) 296 { 297 struct usb_device *udev = to_usb_device(dev); 298 int value; 299 300 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ || 301 value <= - INT_MAX/HZ) 302 return -EINVAL; 303 value *= HZ; 304 305 udev->autosuspend_delay = value; 306 if (value >= 0) 307 usb_try_autosuspend_device(udev); 308 else { 309 if (usb_autoresume_device(udev) == 0) 310 usb_autosuspend_device(udev); 311 } 312 return count; 313 } 314 315 static DEVICE_ATTR(autosuspend, S_IRUGO | S_IWUSR, 316 show_autosuspend, set_autosuspend); 317 318 static const char on_string[] = "on"; 319 static const char auto_string[] = "auto"; 320 static const char suspend_string[] = "suspend"; 321 322 static ssize_t 323 show_level(struct device *dev, struct device_attribute *attr, char *buf) 324 { 325 struct usb_device *udev = to_usb_device(dev); 326 const char *p = auto_string; 327 328 if (udev->state == USB_STATE_SUSPENDED) { 329 if (udev->autoresume_disabled) 330 p = suspend_string; 331 } else { 332 if (udev->autosuspend_disabled) 333 p = on_string; 334 } 335 return sprintf(buf, "%s\n", p); 336 } 337 338 static ssize_t 339 set_level(struct device *dev, struct device_attribute *attr, 340 const char *buf, size_t count) 341 { 342 struct usb_device *udev = to_usb_device(dev); 343 int len = count; 344 char *cp; 345 int rc = 0; 346 int old_autosuspend_disabled, old_autoresume_disabled; 347 348 cp = memchr(buf, '\n', count); 349 if (cp) 350 len = cp - buf; 351 352 usb_lock_device(udev); 353 old_autosuspend_disabled = udev->autosuspend_disabled; 354 old_autoresume_disabled = udev->autoresume_disabled; 355 356 /* Setting the flags without calling usb_pm_lock is a subject to 357 * races, but who cares... 358 */ 359 if (len == sizeof on_string - 1 && 360 strncmp(buf, on_string, len) == 0) { 361 udev->autosuspend_disabled = 1; 362 udev->autoresume_disabled = 0; 363 rc = usb_external_resume_device(udev, PMSG_USER_RESUME); 364 365 } else if (len == sizeof auto_string - 1 && 366 strncmp(buf, auto_string, len) == 0) { 367 udev->autosuspend_disabled = 0; 368 udev->autoresume_disabled = 0; 369 rc = usb_external_resume_device(udev, PMSG_USER_RESUME); 370 371 } else if (len == sizeof suspend_string - 1 && 372 strncmp(buf, suspend_string, len) == 0) { 373 udev->autosuspend_disabled = 0; 374 udev->autoresume_disabled = 1; 375 rc = usb_external_suspend_device(udev, PMSG_USER_SUSPEND); 376 377 } else 378 rc = -EINVAL; 379 380 if (rc) { 381 udev->autosuspend_disabled = old_autosuspend_disabled; 382 udev->autoresume_disabled = old_autoresume_disabled; 383 } 384 usb_unlock_device(udev); 385 return (rc < 0 ? rc : count); 386 } 387 388 static DEVICE_ATTR(level, S_IRUGO | S_IWUSR, show_level, set_level); 389 390 static int add_power_attributes(struct device *dev) 391 { 392 int rc = 0; 393 394 if (is_usb_device(dev)) { 395 rc = sysfs_add_file_to_group(&dev->kobj, 396 &dev_attr_autosuspend.attr, 397 power_group); 398 if (rc == 0) 399 rc = sysfs_add_file_to_group(&dev->kobj, 400 &dev_attr_level.attr, 401 power_group); 402 if (rc == 0) 403 rc = sysfs_add_file_to_group(&dev->kobj, 404 &dev_attr_connected_duration.attr, 405 power_group); 406 if (rc == 0) 407 rc = sysfs_add_file_to_group(&dev->kobj, 408 &dev_attr_active_duration.attr, 409 power_group); 410 } 411 return rc; 412 } 413 414 static void remove_power_attributes(struct device *dev) 415 { 416 sysfs_remove_file_from_group(&dev->kobj, 417 &dev_attr_active_duration.attr, 418 power_group); 419 sysfs_remove_file_from_group(&dev->kobj, 420 &dev_attr_connected_duration.attr, 421 power_group); 422 sysfs_remove_file_from_group(&dev->kobj, 423 &dev_attr_level.attr, 424 power_group); 425 sysfs_remove_file_from_group(&dev->kobj, 426 &dev_attr_autosuspend.attr, 427 power_group); 428 } 429 430 #else 431 432 #define add_power_attributes(dev) 0 433 #define remove_power_attributes(dev) do {} while (0) 434 435 #endif /* CONFIG_USB_SUSPEND */ 436 437 438 /* Descriptor fields */ 439 #define usb_descriptor_attr_le16(field, format_string) \ 440 static ssize_t \ 441 show_##field(struct device *dev, struct device_attribute *attr, \ 442 char *buf) \ 443 { \ 444 struct usb_device *udev; \ 445 \ 446 udev = to_usb_device(dev); \ 447 return sprintf(buf, format_string, \ 448 le16_to_cpu(udev->descriptor.field)); \ 449 } \ 450 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 451 452 usb_descriptor_attr_le16(idVendor, "%04x\n") 453 usb_descriptor_attr_le16(idProduct, "%04x\n") 454 usb_descriptor_attr_le16(bcdDevice, "%04x\n") 455 456 #define usb_descriptor_attr(field, format_string) \ 457 static ssize_t \ 458 show_##field(struct device *dev, struct device_attribute *attr, \ 459 char *buf) \ 460 { \ 461 struct usb_device *udev; \ 462 \ 463 udev = to_usb_device(dev); \ 464 return sprintf(buf, format_string, udev->descriptor.field); \ 465 } \ 466 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 467 468 usb_descriptor_attr(bDeviceClass, "%02x\n") 469 usb_descriptor_attr(bDeviceSubClass, "%02x\n") 470 usb_descriptor_attr(bDeviceProtocol, "%02x\n") 471 usb_descriptor_attr(bNumConfigurations, "%d\n") 472 usb_descriptor_attr(bMaxPacketSize0, "%d\n") 473 474 475 476 /* show if the device is authorized (1) or not (0) */ 477 static ssize_t usb_dev_authorized_show(struct device *dev, 478 struct device_attribute *attr, 479 char *buf) 480 { 481 struct usb_device *usb_dev = to_usb_device(dev); 482 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized); 483 } 484 485 486 /* 487 * Authorize a device to be used in the system 488 * 489 * Writing a 0 deauthorizes the device, writing a 1 authorizes it. 490 */ 491 static ssize_t usb_dev_authorized_store(struct device *dev, 492 struct device_attribute *attr, 493 const char *buf, size_t size) 494 { 495 ssize_t result; 496 struct usb_device *usb_dev = to_usb_device(dev); 497 unsigned val; 498 result = sscanf(buf, "%u\n", &val); 499 if (result != 1) 500 result = -EINVAL; 501 else if (val == 0) 502 result = usb_deauthorize_device(usb_dev); 503 else 504 result = usb_authorize_device(usb_dev); 505 return result < 0? result : size; 506 } 507 508 static DEVICE_ATTR(authorized, 0644, 509 usb_dev_authorized_show, usb_dev_authorized_store); 510 511 512 static struct attribute *dev_attrs[] = { 513 /* current configuration's attributes */ 514 &dev_attr_configuration.attr, 515 &dev_attr_bNumInterfaces.attr, 516 &dev_attr_bConfigurationValue.attr, 517 &dev_attr_bmAttributes.attr, 518 &dev_attr_bMaxPower.attr, 519 &dev_attr_urbnum.attr, 520 /* device attributes */ 521 &dev_attr_idVendor.attr, 522 &dev_attr_idProduct.attr, 523 &dev_attr_bcdDevice.attr, 524 &dev_attr_bDeviceClass.attr, 525 &dev_attr_bDeviceSubClass.attr, 526 &dev_attr_bDeviceProtocol.attr, 527 &dev_attr_bNumConfigurations.attr, 528 &dev_attr_bMaxPacketSize0.attr, 529 &dev_attr_speed.attr, 530 &dev_attr_busnum.attr, 531 &dev_attr_devnum.attr, 532 &dev_attr_version.attr, 533 &dev_attr_maxchild.attr, 534 &dev_attr_quirks.attr, 535 &dev_attr_authorized.attr, 536 NULL, 537 }; 538 static struct attribute_group dev_attr_grp = { 539 .attrs = dev_attrs, 540 }; 541 542 /* When modifying this list, be sure to modify dev_string_attrs_are_visible() 543 * accordingly. 544 */ 545 static struct attribute *dev_string_attrs[] = { 546 &dev_attr_manufacturer.attr, 547 &dev_attr_product.attr, 548 &dev_attr_serial.attr, 549 NULL 550 }; 551 552 static mode_t dev_string_attrs_are_visible(struct kobject *kobj, 553 struct attribute *a, int n) 554 { 555 struct device *dev = container_of(kobj, struct device, kobj); 556 struct usb_device *udev = to_usb_device(dev); 557 558 if (a == &dev_attr_manufacturer.attr) { 559 if (udev->manufacturer == NULL) 560 return 0; 561 } else if (a == &dev_attr_product.attr) { 562 if (udev->product == NULL) 563 return 0; 564 } else if (a == &dev_attr_serial.attr) { 565 if (udev->serial == NULL) 566 return 0; 567 } 568 return a->mode; 569 } 570 571 static struct attribute_group dev_string_attr_grp = { 572 .attrs = dev_string_attrs, 573 .is_visible = dev_string_attrs_are_visible, 574 }; 575 576 const struct attribute_group *usb_device_groups[] = { 577 &dev_attr_grp, 578 &dev_string_attr_grp, 579 NULL 580 }; 581 582 /* Binary descriptors */ 583 584 static ssize_t 585 read_descriptors(struct kobject *kobj, struct bin_attribute *attr, 586 char *buf, loff_t off, size_t count) 587 { 588 struct device *dev = container_of(kobj, struct device, kobj); 589 struct usb_device *udev = to_usb_device(dev); 590 size_t nleft = count; 591 size_t srclen, n; 592 int cfgno; 593 void *src; 594 595 /* The binary attribute begins with the device descriptor. 596 * Following that are the raw descriptor entries for all the 597 * configurations (config plus subsidiary descriptors). 598 */ 599 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations && 600 nleft > 0; ++cfgno) { 601 if (cfgno < 0) { 602 src = &udev->descriptor; 603 srclen = sizeof(struct usb_device_descriptor); 604 } else { 605 src = udev->rawdescriptors[cfgno]; 606 srclen = __le16_to_cpu(udev->config[cfgno].desc. 607 wTotalLength); 608 } 609 if (off < srclen) { 610 n = min(nleft, srclen - (size_t) off); 611 memcpy(buf, src + off, n); 612 nleft -= n; 613 buf += n; 614 off = 0; 615 } else { 616 off -= srclen; 617 } 618 } 619 return count - nleft; 620 } 621 622 static struct bin_attribute dev_bin_attr_descriptors = { 623 .attr = {.name = "descriptors", .mode = 0444}, 624 .read = read_descriptors, 625 .size = 18 + 65535, /* dev descr + max-size raw descriptor */ 626 }; 627 628 int usb_create_sysfs_dev_files(struct usb_device *udev) 629 { 630 struct device *dev = &udev->dev; 631 int retval; 632 633 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors); 634 if (retval) 635 goto error; 636 637 retval = add_persist_attributes(dev); 638 if (retval) 639 goto error; 640 641 retval = add_power_attributes(dev); 642 if (retval) 643 goto error; 644 return retval; 645 error: 646 usb_remove_sysfs_dev_files(udev); 647 return retval; 648 } 649 650 void usb_remove_sysfs_dev_files(struct usb_device *udev) 651 { 652 struct device *dev = &udev->dev; 653 654 remove_power_attributes(dev); 655 remove_persist_attributes(dev); 656 device_remove_bin_file(dev, &dev_bin_attr_descriptors); 657 } 658 659 /* Interface Accociation Descriptor fields */ 660 #define usb_intf_assoc_attr(field, format_string) \ 661 static ssize_t \ 662 show_iad_##field(struct device *dev, struct device_attribute *attr, \ 663 char *buf) \ 664 { \ 665 struct usb_interface *intf = to_usb_interface(dev); \ 666 \ 667 return sprintf(buf, format_string, \ 668 intf->intf_assoc->field); \ 669 } \ 670 static DEVICE_ATTR(iad_##field, S_IRUGO, show_iad_##field, NULL); 671 672 usb_intf_assoc_attr(bFirstInterface, "%02x\n") 673 usb_intf_assoc_attr(bInterfaceCount, "%02d\n") 674 usb_intf_assoc_attr(bFunctionClass, "%02x\n") 675 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n") 676 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n") 677 678 /* Interface fields */ 679 #define usb_intf_attr(field, format_string) \ 680 static ssize_t \ 681 show_##field(struct device *dev, struct device_attribute *attr, \ 682 char *buf) \ 683 { \ 684 struct usb_interface *intf = to_usb_interface(dev); \ 685 \ 686 return sprintf(buf, format_string, \ 687 intf->cur_altsetting->desc.field); \ 688 } \ 689 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 690 691 usb_intf_attr(bInterfaceNumber, "%02x\n") 692 usb_intf_attr(bAlternateSetting, "%2d\n") 693 usb_intf_attr(bNumEndpoints, "%02x\n") 694 usb_intf_attr(bInterfaceClass, "%02x\n") 695 usb_intf_attr(bInterfaceSubClass, "%02x\n") 696 usb_intf_attr(bInterfaceProtocol, "%02x\n") 697 698 static ssize_t show_interface_string(struct device *dev, 699 struct device_attribute *attr, char *buf) 700 { 701 struct usb_interface *intf; 702 char *string; 703 704 intf = to_usb_interface(dev); 705 string = intf->cur_altsetting->string; 706 barrier(); /* The altsetting might change! */ 707 708 if (!string) 709 return 0; 710 return sprintf(buf, "%s\n", string); 711 } 712 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL); 713 714 static ssize_t show_modalias(struct device *dev, 715 struct device_attribute *attr, char *buf) 716 { 717 struct usb_interface *intf; 718 struct usb_device *udev; 719 struct usb_host_interface *alt; 720 721 intf = to_usb_interface(dev); 722 udev = interface_to_usbdev(intf); 723 alt = intf->cur_altsetting; 724 725 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 726 "ic%02Xisc%02Xip%02X\n", 727 le16_to_cpu(udev->descriptor.idVendor), 728 le16_to_cpu(udev->descriptor.idProduct), 729 le16_to_cpu(udev->descriptor.bcdDevice), 730 udev->descriptor.bDeviceClass, 731 udev->descriptor.bDeviceSubClass, 732 udev->descriptor.bDeviceProtocol, 733 alt->desc.bInterfaceClass, 734 alt->desc.bInterfaceSubClass, 735 alt->desc.bInterfaceProtocol); 736 } 737 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL); 738 739 static ssize_t show_supports_autosuspend(struct device *dev, 740 struct device_attribute *attr, char *buf) 741 { 742 struct usb_interface *intf; 743 struct usb_device *udev; 744 int ret; 745 746 intf = to_usb_interface(dev); 747 udev = interface_to_usbdev(intf); 748 749 usb_lock_device(udev); 750 /* Devices will be autosuspended even when an interface isn't claimed */ 751 if (!intf->dev.driver || 752 to_usb_driver(intf->dev.driver)->supports_autosuspend) 753 ret = sprintf(buf, "%u\n", 1); 754 else 755 ret = sprintf(buf, "%u\n", 0); 756 usb_unlock_device(udev); 757 758 return ret; 759 } 760 static DEVICE_ATTR(supports_autosuspend, S_IRUGO, show_supports_autosuspend, NULL); 761 762 static struct attribute *intf_attrs[] = { 763 &dev_attr_bInterfaceNumber.attr, 764 &dev_attr_bAlternateSetting.attr, 765 &dev_attr_bNumEndpoints.attr, 766 &dev_attr_bInterfaceClass.attr, 767 &dev_attr_bInterfaceSubClass.attr, 768 &dev_attr_bInterfaceProtocol.attr, 769 &dev_attr_modalias.attr, 770 &dev_attr_supports_autosuspend.attr, 771 NULL, 772 }; 773 static struct attribute_group intf_attr_grp = { 774 .attrs = intf_attrs, 775 }; 776 777 static struct attribute *intf_assoc_attrs[] = { 778 &dev_attr_iad_bFirstInterface.attr, 779 &dev_attr_iad_bInterfaceCount.attr, 780 &dev_attr_iad_bFunctionClass.attr, 781 &dev_attr_iad_bFunctionSubClass.attr, 782 &dev_attr_iad_bFunctionProtocol.attr, 783 NULL, 784 }; 785 786 static mode_t intf_assoc_attrs_are_visible(struct kobject *kobj, 787 struct attribute *a, int n) 788 { 789 struct device *dev = container_of(kobj, struct device, kobj); 790 struct usb_interface *intf = to_usb_interface(dev); 791 792 if (intf->intf_assoc == NULL) 793 return 0; 794 return a->mode; 795 } 796 797 static struct attribute_group intf_assoc_attr_grp = { 798 .attrs = intf_assoc_attrs, 799 .is_visible = intf_assoc_attrs_are_visible, 800 }; 801 802 const struct attribute_group *usb_interface_groups[] = { 803 &intf_attr_grp, 804 &intf_assoc_attr_grp, 805 NULL 806 }; 807 808 int usb_create_sysfs_intf_files(struct usb_interface *intf) 809 { 810 struct usb_device *udev = interface_to_usbdev(intf); 811 struct usb_host_interface *alt = intf->cur_altsetting; 812 int retval; 813 814 if (intf->sysfs_files_created || intf->unregistering) 815 return 0; 816 817 if (alt->string == NULL && 818 !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) 819 alt->string = usb_cache_string(udev, alt->desc.iInterface); 820 if (alt->string) 821 retval = device_create_file(&intf->dev, &dev_attr_interface); 822 intf->sysfs_files_created = 1; 823 return 0; 824 } 825 826 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 827 { 828 if (!intf->sysfs_files_created) 829 return; 830 831 device_remove_file(&intf->dev, &dev_attr_interface); 832 intf->sysfs_files_created = 0; 833 } 834