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