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