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 /* Binary descriptors */ 542 543 static ssize_t 544 read_descriptors(struct kobject *kobj, struct bin_attribute *attr, 545 char *buf, loff_t off, size_t count) 546 { 547 struct usb_device *udev = to_usb_device( 548 container_of(kobj, struct device, kobj)); 549 size_t nleft = count; 550 size_t srclen, n; 551 552 usb_lock_device(udev); 553 554 /* The binary attribute begins with the device descriptor */ 555 srclen = sizeof(struct usb_device_descriptor); 556 if (off < srclen) { 557 n = min_t(size_t, nleft, srclen - off); 558 memcpy(buf, off + (char *) &udev->descriptor, n); 559 nleft -= n; 560 buf += n; 561 off = 0; 562 } else { 563 off -= srclen; 564 } 565 566 /* Then follows the raw descriptor entry for the current 567 * configuration (config plus subsidiary descriptors). 568 */ 569 if (udev->actconfig) { 570 int cfgno = udev->actconfig - udev->config; 571 572 srclen = __le16_to_cpu(udev->actconfig->desc.wTotalLength); 573 if (off < srclen) { 574 n = min_t(size_t, nleft, srclen - off); 575 memcpy(buf, off + udev->rawdescriptors[cfgno], n); 576 nleft -= n; 577 } 578 } 579 usb_unlock_device(udev); 580 return count - nleft; 581 } 582 583 static struct bin_attribute dev_bin_attr_descriptors = { 584 .attr = {.name = "descriptors", .mode = 0444}, 585 .read = read_descriptors, 586 .size = 18 + 65535, /* dev descr + max-size raw descriptor */ 587 }; 588 589 int usb_create_sysfs_dev_files(struct usb_device *udev) 590 { 591 struct device *dev = &udev->dev; 592 int retval; 593 594 retval = sysfs_create_group(&dev->kobj, &dev_attr_grp); 595 if (retval) 596 return retval; 597 598 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors); 599 if (retval) 600 goto error; 601 602 retval = add_persist_attributes(dev); 603 if (retval) 604 goto error; 605 606 retval = add_power_attributes(dev); 607 if (retval) 608 goto error; 609 610 if (udev->manufacturer) { 611 retval = device_create_file(dev, &dev_attr_manufacturer); 612 if (retval) 613 goto error; 614 } 615 if (udev->product) { 616 retval = device_create_file(dev, &dev_attr_product); 617 if (retval) 618 goto error; 619 } 620 if (udev->serial) { 621 retval = device_create_file(dev, &dev_attr_serial); 622 if (retval) 623 goto error; 624 } 625 retval = usb_create_ep_files(dev, &udev->ep0, udev); 626 if (retval) 627 goto error; 628 return 0; 629 error: 630 usb_remove_sysfs_dev_files(udev); 631 return retval; 632 } 633 634 void usb_remove_sysfs_dev_files(struct usb_device *udev) 635 { 636 struct device *dev = &udev->dev; 637 638 usb_remove_ep_files(&udev->ep0); 639 device_remove_file(dev, &dev_attr_manufacturer); 640 device_remove_file(dev, &dev_attr_product); 641 device_remove_file(dev, &dev_attr_serial); 642 remove_power_attributes(dev); 643 remove_persist_attributes(dev); 644 device_remove_bin_file(dev, &dev_bin_attr_descriptors); 645 sysfs_remove_group(&dev->kobj, &dev_attr_grp); 646 } 647 648 /* Interface Accociation Descriptor fields */ 649 #define usb_intf_assoc_attr(field, format_string) \ 650 static ssize_t \ 651 show_iad_##field(struct device *dev, struct device_attribute *attr, \ 652 char *buf) \ 653 { \ 654 struct usb_interface *intf = to_usb_interface(dev); \ 655 \ 656 return sprintf(buf, format_string, \ 657 intf->intf_assoc->field); \ 658 } \ 659 static DEVICE_ATTR(iad_##field, S_IRUGO, show_iad_##field, NULL); 660 661 usb_intf_assoc_attr(bFirstInterface, "%02x\n") 662 usb_intf_assoc_attr(bInterfaceCount, "%02d\n") 663 usb_intf_assoc_attr(bFunctionClass, "%02x\n") 664 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n") 665 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n") 666 667 /* Interface fields */ 668 #define usb_intf_attr(field, format_string) \ 669 static ssize_t \ 670 show_##field(struct device *dev, struct device_attribute *attr, \ 671 char *buf) \ 672 { \ 673 struct usb_interface *intf = to_usb_interface(dev); \ 674 \ 675 return sprintf(buf, format_string, \ 676 intf->cur_altsetting->desc.field); \ 677 } \ 678 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 679 680 usb_intf_attr(bInterfaceNumber, "%02x\n") 681 usb_intf_attr(bAlternateSetting, "%2d\n") 682 usb_intf_attr(bNumEndpoints, "%02x\n") 683 usb_intf_attr(bInterfaceClass, "%02x\n") 684 usb_intf_attr(bInterfaceSubClass, "%02x\n") 685 usb_intf_attr(bInterfaceProtocol, "%02x\n") 686 687 static ssize_t show_interface_string(struct device *dev, 688 struct device_attribute *attr, char *buf) 689 { 690 struct usb_interface *intf; 691 struct usb_device *udev; 692 int len; 693 694 intf = to_usb_interface(dev); 695 udev = interface_to_usbdev(intf); 696 len = snprintf(buf, 256, "%s", intf->cur_altsetting->string); 697 if (len < 0) 698 return 0; 699 buf[len] = '\n'; 700 buf[len+1] = 0; 701 return len+1; 702 } 703 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL); 704 705 static ssize_t show_modalias(struct device *dev, 706 struct device_attribute *attr, char *buf) 707 { 708 struct usb_interface *intf; 709 struct usb_device *udev; 710 struct usb_host_interface *alt; 711 712 intf = to_usb_interface(dev); 713 udev = interface_to_usbdev(intf); 714 alt = intf->cur_altsetting; 715 716 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 717 "ic%02Xisc%02Xip%02X\n", 718 le16_to_cpu(udev->descriptor.idVendor), 719 le16_to_cpu(udev->descriptor.idProduct), 720 le16_to_cpu(udev->descriptor.bcdDevice), 721 udev->descriptor.bDeviceClass, 722 udev->descriptor.bDeviceSubClass, 723 udev->descriptor.bDeviceProtocol, 724 alt->desc.bInterfaceClass, 725 alt->desc.bInterfaceSubClass, 726 alt->desc.bInterfaceProtocol); 727 } 728 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL); 729 730 static struct attribute *intf_assoc_attrs[] = { 731 &dev_attr_iad_bFirstInterface.attr, 732 &dev_attr_iad_bInterfaceCount.attr, 733 &dev_attr_iad_bFunctionClass.attr, 734 &dev_attr_iad_bFunctionSubClass.attr, 735 &dev_attr_iad_bFunctionProtocol.attr, 736 NULL, 737 }; 738 static struct attribute_group intf_assoc_attr_grp = { 739 .attrs = intf_assoc_attrs, 740 }; 741 742 static struct attribute *intf_attrs[] = { 743 &dev_attr_bInterfaceNumber.attr, 744 &dev_attr_bAlternateSetting.attr, 745 &dev_attr_bNumEndpoints.attr, 746 &dev_attr_bInterfaceClass.attr, 747 &dev_attr_bInterfaceSubClass.attr, 748 &dev_attr_bInterfaceProtocol.attr, 749 &dev_attr_modalias.attr, 750 NULL, 751 }; 752 static struct attribute_group intf_attr_grp = { 753 .attrs = intf_attrs, 754 }; 755 756 static inline void usb_create_intf_ep_files(struct usb_interface *intf, 757 struct usb_device *udev) 758 { 759 struct usb_host_interface *iface_desc; 760 int i; 761 762 iface_desc = intf->cur_altsetting; 763 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) 764 usb_create_ep_files(&intf->dev, &iface_desc->endpoint[i], 765 udev); 766 } 767 768 static inline void usb_remove_intf_ep_files(struct usb_interface *intf) 769 { 770 struct usb_host_interface *iface_desc; 771 int i; 772 773 iface_desc = intf->cur_altsetting; 774 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) 775 usb_remove_ep_files(&iface_desc->endpoint[i]); 776 } 777 778 int usb_create_sysfs_intf_files(struct usb_interface *intf) 779 { 780 struct device *dev = &intf->dev; 781 struct usb_device *udev = interface_to_usbdev(intf); 782 struct usb_host_interface *alt = intf->cur_altsetting; 783 int retval; 784 785 if (intf->sysfs_files_created) 786 return 0; 787 retval = sysfs_create_group(&dev->kobj, &intf_attr_grp); 788 if (retval) 789 return retval; 790 791 if (alt->string == NULL) 792 alt->string = usb_cache_string(udev, alt->desc.iInterface); 793 if (alt->string) 794 retval = device_create_file(dev, &dev_attr_interface); 795 if (intf->intf_assoc) 796 retval = sysfs_create_group(&dev->kobj, &intf_assoc_attr_grp); 797 usb_create_intf_ep_files(intf, udev); 798 intf->sysfs_files_created = 1; 799 return 0; 800 } 801 802 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 803 { 804 struct device *dev = &intf->dev; 805 806 if (!intf->sysfs_files_created) 807 return; 808 usb_remove_intf_ep_files(intf); 809 device_remove_file(dev, &dev_attr_interface); 810 sysfs_remove_group(&dev->kobj, &intf_attr_grp); 811 sysfs_remove_group(&intf->dev.kobj, &intf_assoc_attr_grp); 812 intf->sysfs_files_created = 0; 813 } 814