2 * drivers/usb/core/sysfs.c
4 * (C) Copyright 2002 David Brownell
5 * (C) Copyright 2002,2004 Greg Kroah-Hartman
6 * (C) Copyright 2002,2004 IBM Corp.
8 * All of the sysfs file attributes for usb devices and interfaces.
13 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/usb.h>
16 #include <linux/usb/quirks.h>
19 /* Active configuration fields */
20 #define usb_actconfig_show(field, format_string) \
21 static ssize_t field##_show(struct device *dev, \
22 struct device_attribute *attr, char *buf) \
24 struct usb_device *udev; \
25 struct usb_host_config *actconfig; \
28 udev = to_usb_device(dev); \
29 usb_lock_device(udev); \
30 actconfig = udev->actconfig; \
32 rc = sprintf(buf, format_string, \
33 actconfig->desc.field); \
34 usb_unlock_device(udev); \
38 #define usb_actconfig_attr(field, format_string) \
39 usb_actconfig_show(field, format_string) \
40 static DEVICE_ATTR_RO(field)
42 usb_actconfig_attr(bNumInterfaces, "%2d\n");
43 usb_actconfig_attr(bmAttributes, "%2x\n");
45 static ssize_t bMaxPower_show(struct device *dev,
46 struct device_attribute *attr, char *buf)
48 struct usb_device *udev;
49 struct usb_host_config *actconfig;
52 udev = to_usb_device(dev);
53 usb_lock_device(udev);
54 actconfig = udev->actconfig;
56 rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
57 usb_unlock_device(udev);
60 static DEVICE_ATTR_RO(bMaxPower);
62 static ssize_t configuration_show(struct device *dev,
63 struct device_attribute *attr, char *buf)
65 struct usb_device *udev;
66 struct usb_host_config *actconfig;
69 udev = to_usb_device(dev);
70 usb_lock_device(udev);
71 actconfig = udev->actconfig;
72 if (actconfig && actconfig->string)
73 rc = sprintf(buf, "%s\n", actconfig->string);
74 usb_unlock_device(udev);
77 static DEVICE_ATTR_RO(configuration);
79 /* configuration value is always present, and r/w */
80 usb_actconfig_show(bConfigurationValue, "%u\n");
82 static ssize_t bConfigurationValue_store(struct device *dev,
83 struct device_attribute *attr,
84 const char *buf, size_t count)
86 struct usb_device *udev = to_usb_device(dev);
89 if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
91 usb_lock_device(udev);
92 value = usb_set_configuration(udev, config);
93 usb_unlock_device(udev);
94 return (value < 0) ? value : count;
96 static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR,
97 bConfigurationValue_show, bConfigurationValue_store);
100 #define usb_string_attr(name) \
101 static ssize_t name##_show(struct device *dev, \
102 struct device_attribute *attr, char *buf) \
104 struct usb_device *udev; \
107 udev = to_usb_device(dev); \
108 usb_lock_device(udev); \
109 retval = sprintf(buf, "%s\n", udev->name); \
110 usb_unlock_device(udev); \
113 static DEVICE_ATTR_RO(name)
115 usb_string_attr(product);
116 usb_string_attr(manufacturer);
117 usb_string_attr(serial);
119 static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
122 struct usb_device *udev;
125 udev = to_usb_device(dev);
127 switch (udev->speed) {
131 case USB_SPEED_UNKNOWN:
138 case USB_SPEED_WIRELESS:
141 case USB_SPEED_SUPER:
147 return sprintf(buf, "%s\n", speed);
149 static DEVICE_ATTR_RO(speed);
151 static ssize_t busnum_show(struct device *dev, struct device_attribute *attr,
154 struct usb_device *udev;
156 udev = to_usb_device(dev);
157 return sprintf(buf, "%d\n", udev->bus->busnum);
159 static DEVICE_ATTR_RO(busnum);
161 static ssize_t devnum_show(struct device *dev, struct device_attribute *attr,
164 struct usb_device *udev;
166 udev = to_usb_device(dev);
167 return sprintf(buf, "%d\n", udev->devnum);
169 static DEVICE_ATTR_RO(devnum);
171 static ssize_t devpath_show(struct device *dev, struct device_attribute *attr,
174 struct usb_device *udev;
176 udev = to_usb_device(dev);
177 return sprintf(buf, "%s\n", udev->devpath);
179 static DEVICE_ATTR_RO(devpath);
181 static ssize_t version_show(struct device *dev, struct device_attribute *attr,
184 struct usb_device *udev;
187 udev = to_usb_device(dev);
188 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
189 return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
191 static DEVICE_ATTR_RO(version);
193 static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr,
196 struct usb_device *udev;
198 udev = to_usb_device(dev);
199 return sprintf(buf, "%d\n", udev->maxchild);
201 static DEVICE_ATTR_RO(maxchild);
203 static ssize_t quirks_show(struct device *dev, struct device_attribute *attr,
206 struct usb_device *udev;
208 udev = to_usb_device(dev);
209 return sprintf(buf, "0x%x\n", udev->quirks);
211 static DEVICE_ATTR_RO(quirks);
213 static ssize_t avoid_reset_quirk_show(struct device *dev,
214 struct device_attribute *attr, char *buf)
216 struct usb_device *udev;
218 udev = to_usb_device(dev);
219 return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET));
222 static ssize_t avoid_reset_quirk_store(struct device *dev,
223 struct device_attribute *attr,
224 const char *buf, size_t count)
226 struct usb_device *udev = to_usb_device(dev);
229 if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1)
231 usb_lock_device(udev);
233 udev->quirks |= USB_QUIRK_RESET;
235 udev->quirks &= ~USB_QUIRK_RESET;
236 usb_unlock_device(udev);
239 static DEVICE_ATTR_RW(avoid_reset_quirk);
241 static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr,
244 struct usb_device *udev;
246 udev = to_usb_device(dev);
247 return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
249 static DEVICE_ATTR_RO(urbnum);
251 static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
254 struct usb_device *udev;
257 udev = to_usb_device(dev);
259 switch (udev->removable) {
260 case USB_DEVICE_REMOVABLE:
263 case USB_DEVICE_FIXED:
270 return sprintf(buf, "%s\n", state);
272 static DEVICE_ATTR_RO(removable);
274 static ssize_t ltm_capable_show(struct device *dev,
275 struct device_attribute *attr, char *buf)
277 if (usb_device_supports_ltm(to_usb_device(dev)))
278 return sprintf(buf, "%s\n", "yes");
279 return sprintf(buf, "%s\n", "no");
281 static DEVICE_ATTR_RO(ltm_capable);
285 static ssize_t persist_show(struct device *dev, struct device_attribute *attr,
288 struct usb_device *udev = to_usb_device(dev);
290 return sprintf(buf, "%d\n", udev->persist_enabled);
293 static ssize_t persist_store(struct device *dev, struct device_attribute *attr,
294 const char *buf, size_t count)
296 struct usb_device *udev = to_usb_device(dev);
299 /* Hubs are always enabled for USB_PERSIST */
300 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
303 if (sscanf(buf, "%d", &value) != 1)
306 usb_lock_device(udev);
307 udev->persist_enabled = !!value;
308 usb_unlock_device(udev);
311 static DEVICE_ATTR_RW(persist);
313 static int add_persist_attributes(struct device *dev)
317 if (is_usb_device(dev)) {
318 struct usb_device *udev = to_usb_device(dev);
320 /* Hubs are automatically enabled for USB_PERSIST,
321 * no point in creating the attribute file.
323 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
324 rc = sysfs_add_file_to_group(&dev->kobj,
325 &dev_attr_persist.attr,
331 static void remove_persist_attributes(struct device *dev)
333 sysfs_remove_file_from_group(&dev->kobj,
334 &dev_attr_persist.attr,
338 static ssize_t connected_duration_show(struct device *dev,
339 struct device_attribute *attr, char *buf)
341 struct usb_device *udev = to_usb_device(dev);
343 return sprintf(buf, "%u\n",
344 jiffies_to_msecs(jiffies - udev->connect_time));
346 static DEVICE_ATTR_RO(connected_duration);
349 * If the device is resumed, the last time the device was suspended has
350 * been pre-subtracted from active_duration. We add the current time to
351 * get the duration that the device was actually active.
353 * If the device is suspended, the active_duration is up-to-date.
355 static ssize_t active_duration_show(struct device *dev,
356 struct device_attribute *attr, char *buf)
358 struct usb_device *udev = to_usb_device(dev);
361 if (udev->state != USB_STATE_SUSPENDED)
362 duration = jiffies_to_msecs(jiffies + udev->active_duration);
364 duration = jiffies_to_msecs(udev->active_duration);
365 return sprintf(buf, "%u\n", duration);
367 static DEVICE_ATTR_RO(active_duration);
369 static ssize_t autosuspend_show(struct device *dev,
370 struct device_attribute *attr, char *buf)
372 return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
375 static ssize_t autosuspend_store(struct device *dev,
376 struct device_attribute *attr, const char *buf,
381 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
382 value <= -INT_MAX/1000)
385 pm_runtime_set_autosuspend_delay(dev, value * 1000);
388 static DEVICE_ATTR_RW(autosuspend);
390 static const char on_string[] = "on";
391 static const char auto_string[] = "auto";
393 static void warn_level(void)
395 static int level_warned;
399 printk(KERN_WARNING "WARNING! power/level is deprecated; "
400 "use power/control instead\n");
404 static ssize_t level_show(struct device *dev, struct device_attribute *attr,
407 struct usb_device *udev = to_usb_device(dev);
408 const char *p = auto_string;
411 if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto)
413 return sprintf(buf, "%s\n", p);
416 static ssize_t level_store(struct device *dev, struct device_attribute *attr,
417 const char *buf, size_t count)
419 struct usb_device *udev = to_usb_device(dev);
425 cp = memchr(buf, '\n', count);
429 usb_lock_device(udev);
431 if (len == sizeof on_string - 1 &&
432 strncmp(buf, on_string, len) == 0)
433 usb_disable_autosuspend(udev);
435 else if (len == sizeof auto_string - 1 &&
436 strncmp(buf, auto_string, len) == 0)
437 usb_enable_autosuspend(udev);
442 usb_unlock_device(udev);
445 static DEVICE_ATTR_RW(level);
447 static ssize_t usb2_hardware_lpm_show(struct device *dev,
448 struct device_attribute *attr, char *buf)
450 struct usb_device *udev = to_usb_device(dev);
453 if (udev->usb2_hw_lpm_allowed == 1)
458 return sprintf(buf, "%s\n", p);
461 static ssize_t usb2_hardware_lpm_store(struct device *dev,
462 struct device_attribute *attr,
463 const char *buf, size_t count)
465 struct usb_device *udev = to_usb_device(dev);
469 usb_lock_device(udev);
471 ret = strtobool(buf, &value);
474 udev->usb2_hw_lpm_allowed = value;
475 ret = usb_set_usb2_hardware_lpm(udev, value);
478 usb_unlock_device(udev);
485 static DEVICE_ATTR_RW(usb2_hardware_lpm);
487 static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
488 struct device_attribute *attr,
491 struct usb_device *udev = to_usb_device(dev);
492 return sprintf(buf, "%d\n", udev->l1_params.timeout);
495 static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
496 struct device_attribute *attr,
497 const char *buf, size_t count)
499 struct usb_device *udev = to_usb_device(dev);
502 if (kstrtou16(buf, 0, &timeout))
505 udev->l1_params.timeout = timeout;
509 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);
511 static ssize_t usb2_lpm_besl_show(struct device *dev,
512 struct device_attribute *attr, char *buf)
514 struct usb_device *udev = to_usb_device(dev);
515 return sprintf(buf, "%d\n", udev->l1_params.besl);
518 static ssize_t usb2_lpm_besl_store(struct device *dev,
519 struct device_attribute *attr,
520 const char *buf, size_t count)
522 struct usb_device *udev = to_usb_device(dev);
525 if (kstrtou8(buf, 0, &besl) || besl > 15)
528 udev->l1_params.besl = besl;
532 static DEVICE_ATTR_RW(usb2_lpm_besl);
534 static struct attribute *usb2_hardware_lpm_attr[] = {
535 &dev_attr_usb2_hardware_lpm.attr,
536 &dev_attr_usb2_lpm_l1_timeout.attr,
537 &dev_attr_usb2_lpm_besl.attr,
540 static struct attribute_group usb2_hardware_lpm_attr_group = {
541 .name = power_group_name,
542 .attrs = usb2_hardware_lpm_attr,
545 static struct attribute *power_attrs[] = {
546 &dev_attr_autosuspend.attr,
547 &dev_attr_level.attr,
548 &dev_attr_connected_duration.attr,
549 &dev_attr_active_duration.attr,
552 static struct attribute_group power_attr_group = {
553 .name = power_group_name,
554 .attrs = power_attrs,
557 static int add_power_attributes(struct device *dev)
561 if (is_usb_device(dev)) {
562 struct usb_device *udev = to_usb_device(dev);
563 rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
564 if (udev->usb2_hw_lpm_capable == 1)
565 rc = sysfs_merge_group(&dev->kobj,
566 &usb2_hardware_lpm_attr_group);
572 static void remove_power_attributes(struct device *dev)
574 sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
575 sysfs_unmerge_group(&dev->kobj, &power_attr_group);
580 #define add_persist_attributes(dev) 0
581 #define remove_persist_attributes(dev) do {} while (0)
583 #define add_power_attributes(dev) 0
584 #define remove_power_attributes(dev) do {} while (0)
586 #endif /* CONFIG_PM */
589 /* Descriptor fields */
590 #define usb_descriptor_attr_le16(field, format_string) \
592 field##_show(struct device *dev, struct device_attribute *attr, \
595 struct usb_device *udev; \
597 udev = to_usb_device(dev); \
598 return sprintf(buf, format_string, \
599 le16_to_cpu(udev->descriptor.field)); \
601 static DEVICE_ATTR_RO(field)
603 usb_descriptor_attr_le16(idVendor, "%04x\n");
604 usb_descriptor_attr_le16(idProduct, "%04x\n");
605 usb_descriptor_attr_le16(bcdDevice, "%04x\n");
607 #define usb_descriptor_attr(field, format_string) \
609 field##_show(struct device *dev, struct device_attribute *attr, \
612 struct usb_device *udev; \
614 udev = to_usb_device(dev); \
615 return sprintf(buf, format_string, udev->descriptor.field); \
617 static DEVICE_ATTR_RO(field)
619 usb_descriptor_attr(bDeviceClass, "%02x\n");
620 usb_descriptor_attr(bDeviceSubClass, "%02x\n");
621 usb_descriptor_attr(bDeviceProtocol, "%02x\n");
622 usb_descriptor_attr(bNumConfigurations, "%d\n");
623 usb_descriptor_attr(bMaxPacketSize0, "%d\n");
626 /* show if the device is authorized (1) or not (0) */
627 static ssize_t authorized_show(struct device *dev,
628 struct device_attribute *attr, char *buf)
630 struct usb_device *usb_dev = to_usb_device(dev);
631 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
635 * Authorize a device to be used in the system
637 * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
639 static ssize_t authorized_store(struct device *dev,
640 struct device_attribute *attr, const char *buf,
644 struct usb_device *usb_dev = to_usb_device(dev);
646 result = sscanf(buf, "%u\n", &val);
650 result = usb_deauthorize_device(usb_dev);
652 result = usb_authorize_device(usb_dev);
653 return result < 0 ? result : size;
655 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
656 authorized_show, authorized_store);
658 /* "Safely remove a device" */
659 static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
660 const char *buf, size_t count)
662 struct usb_device *udev = to_usb_device(dev);
665 usb_lock_device(udev);
666 if (udev->state != USB_STATE_NOTATTACHED) {
668 /* To avoid races, first unconfigure and then remove */
669 usb_set_configuration(udev, -1);
670 rc = usb_remove_device(udev);
674 usb_unlock_device(udev);
677 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
680 static struct attribute *dev_attrs[] = {
681 /* current configuration's attributes */
682 &dev_attr_configuration.attr,
683 &dev_attr_bNumInterfaces.attr,
684 &dev_attr_bConfigurationValue.attr,
685 &dev_attr_bmAttributes.attr,
686 &dev_attr_bMaxPower.attr,
687 /* device attributes */
688 &dev_attr_urbnum.attr,
689 &dev_attr_idVendor.attr,
690 &dev_attr_idProduct.attr,
691 &dev_attr_bcdDevice.attr,
692 &dev_attr_bDeviceClass.attr,
693 &dev_attr_bDeviceSubClass.attr,
694 &dev_attr_bDeviceProtocol.attr,
695 &dev_attr_bNumConfigurations.attr,
696 &dev_attr_bMaxPacketSize0.attr,
697 &dev_attr_speed.attr,
698 &dev_attr_busnum.attr,
699 &dev_attr_devnum.attr,
700 &dev_attr_devpath.attr,
701 &dev_attr_version.attr,
702 &dev_attr_maxchild.attr,
703 &dev_attr_quirks.attr,
704 &dev_attr_avoid_reset_quirk.attr,
705 &dev_attr_authorized.attr,
706 &dev_attr_remove.attr,
707 &dev_attr_removable.attr,
708 &dev_attr_ltm_capable.attr,
711 static struct attribute_group dev_attr_grp = {
715 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
718 static struct attribute *dev_string_attrs[] = {
719 &dev_attr_manufacturer.attr,
720 &dev_attr_product.attr,
721 &dev_attr_serial.attr,
725 static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
726 struct attribute *a, int n)
728 struct device *dev = container_of(kobj, struct device, kobj);
729 struct usb_device *udev = to_usb_device(dev);
731 if (a == &dev_attr_manufacturer.attr) {
732 if (udev->manufacturer == NULL)
734 } else if (a == &dev_attr_product.attr) {
735 if (udev->product == NULL)
737 } else if (a == &dev_attr_serial.attr) {
738 if (udev->serial == NULL)
744 static struct attribute_group dev_string_attr_grp = {
745 .attrs = dev_string_attrs,
746 .is_visible = dev_string_attrs_are_visible,
749 const struct attribute_group *usb_device_groups[] = {
751 &dev_string_attr_grp,
755 /* Binary descriptors */
758 read_descriptors(struct file *filp, struct kobject *kobj,
759 struct bin_attribute *attr,
760 char *buf, loff_t off, size_t count)
762 struct device *dev = container_of(kobj, struct device, kobj);
763 struct usb_device *udev = to_usb_device(dev);
764 size_t nleft = count;
769 /* The binary attribute begins with the device descriptor.
770 * Following that are the raw descriptor entries for all the
771 * configurations (config plus subsidiary descriptors).
773 usb_lock_device(udev);
774 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
775 nleft > 0; ++cfgno) {
777 src = &udev->descriptor;
778 srclen = sizeof(struct usb_device_descriptor);
780 src = udev->rawdescriptors[cfgno];
781 srclen = __le16_to_cpu(udev->config[cfgno].desc.
785 n = min(nleft, srclen - (size_t) off);
786 memcpy(buf, src + off, n);
794 usb_unlock_device(udev);
795 return count - nleft;
798 static struct bin_attribute dev_bin_attr_descriptors = {
799 .attr = {.name = "descriptors", .mode = 0444},
800 .read = read_descriptors,
801 .size = 18 + 65535, /* dev descr + max-size raw descriptor */
804 int usb_create_sysfs_dev_files(struct usb_device *udev)
806 struct device *dev = &udev->dev;
809 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
813 retval = add_persist_attributes(dev);
817 retval = add_power_attributes(dev);
822 usb_remove_sysfs_dev_files(udev);
826 void usb_remove_sysfs_dev_files(struct usb_device *udev)
828 struct device *dev = &udev->dev;
830 remove_power_attributes(dev);
831 remove_persist_attributes(dev);
832 device_remove_bin_file(dev, &dev_bin_attr_descriptors);
835 /* Interface Association Descriptor fields */
836 #define usb_intf_assoc_attr(field, format_string) \
838 iad_##field##_show(struct device *dev, struct device_attribute *attr, \
841 struct usb_interface *intf = to_usb_interface(dev); \
843 return sprintf(buf, format_string, \
844 intf->intf_assoc->field); \
846 static DEVICE_ATTR_RO(iad_##field)
848 usb_intf_assoc_attr(bFirstInterface, "%02x\n");
849 usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
850 usb_intf_assoc_attr(bFunctionClass, "%02x\n");
851 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
852 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
854 /* Interface fields */
855 #define usb_intf_attr(field, format_string) \
857 field##_show(struct device *dev, struct device_attribute *attr, \
860 struct usb_interface *intf = to_usb_interface(dev); \
862 return sprintf(buf, format_string, \
863 intf->cur_altsetting->desc.field); \
865 static DEVICE_ATTR_RO(field)
867 usb_intf_attr(bInterfaceNumber, "%02x\n");
868 usb_intf_attr(bAlternateSetting, "%2d\n");
869 usb_intf_attr(bNumEndpoints, "%02x\n");
870 usb_intf_attr(bInterfaceClass, "%02x\n");
871 usb_intf_attr(bInterfaceSubClass, "%02x\n");
872 usb_intf_attr(bInterfaceProtocol, "%02x\n");
874 static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
877 struct usb_interface *intf;
880 intf = to_usb_interface(dev);
881 string = ACCESS_ONCE(intf->cur_altsetting->string);
884 return sprintf(buf, "%s\n", string);
886 static DEVICE_ATTR_RO(interface);
888 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
891 struct usb_interface *intf;
892 struct usb_device *udev;
893 struct usb_host_interface *alt;
895 intf = to_usb_interface(dev);
896 udev = interface_to_usbdev(intf);
897 alt = ACCESS_ONCE(intf->cur_altsetting);
899 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
900 "ic%02Xisc%02Xip%02Xin%02X\n",
901 le16_to_cpu(udev->descriptor.idVendor),
902 le16_to_cpu(udev->descriptor.idProduct),
903 le16_to_cpu(udev->descriptor.bcdDevice),
904 udev->descriptor.bDeviceClass,
905 udev->descriptor.bDeviceSubClass,
906 udev->descriptor.bDeviceProtocol,
907 alt->desc.bInterfaceClass,
908 alt->desc.bInterfaceSubClass,
909 alt->desc.bInterfaceProtocol,
910 alt->desc.bInterfaceNumber);
912 static DEVICE_ATTR_RO(modalias);
914 static ssize_t supports_autosuspend_show(struct device *dev,
915 struct device_attribute *attr,
921 /* Devices will be autosuspended even when an interface isn't claimed */
922 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
925 return sprintf(buf, "%u\n", s);
927 static DEVICE_ATTR_RO(supports_autosuspend);
929 static struct attribute *intf_attrs[] = {
930 &dev_attr_bInterfaceNumber.attr,
931 &dev_attr_bAlternateSetting.attr,
932 &dev_attr_bNumEndpoints.attr,
933 &dev_attr_bInterfaceClass.attr,
934 &dev_attr_bInterfaceSubClass.attr,
935 &dev_attr_bInterfaceProtocol.attr,
936 &dev_attr_modalias.attr,
937 &dev_attr_supports_autosuspend.attr,
940 static struct attribute_group intf_attr_grp = {
944 static struct attribute *intf_assoc_attrs[] = {
945 &dev_attr_iad_bFirstInterface.attr,
946 &dev_attr_iad_bInterfaceCount.attr,
947 &dev_attr_iad_bFunctionClass.attr,
948 &dev_attr_iad_bFunctionSubClass.attr,
949 &dev_attr_iad_bFunctionProtocol.attr,
953 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
954 struct attribute *a, int n)
956 struct device *dev = container_of(kobj, struct device, kobj);
957 struct usb_interface *intf = to_usb_interface(dev);
959 if (intf->intf_assoc == NULL)
964 static struct attribute_group intf_assoc_attr_grp = {
965 .attrs = intf_assoc_attrs,
966 .is_visible = intf_assoc_attrs_are_visible,
969 const struct attribute_group *usb_interface_groups[] = {
971 &intf_assoc_attr_grp,
975 void usb_create_sysfs_intf_files(struct usb_interface *intf)
977 struct usb_device *udev = interface_to_usbdev(intf);
978 struct usb_host_interface *alt = intf->cur_altsetting;
980 if (intf->sysfs_files_created || intf->unregistering)
983 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
984 alt->string = usb_cache_string(udev, alt->desc.iInterface);
985 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
986 ; /* We don't actually care if the function fails. */
987 intf->sysfs_files_created = 1;
990 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
992 if (!intf->sysfs_files_created)
995 device_remove_file(&intf->dev, &dev_attr_interface);
996 intf->sysfs_files_created = 0;