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;
476 ret = usb_enable_usb2_hardware_lpm(udev);
478 ret = usb_disable_usb2_hardware_lpm(udev);
481 usb_unlock_device(udev);
488 static DEVICE_ATTR_RW(usb2_hardware_lpm);
490 static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
491 struct device_attribute *attr,
494 struct usb_device *udev = to_usb_device(dev);
495 return sprintf(buf, "%d\n", udev->l1_params.timeout);
498 static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
499 struct device_attribute *attr,
500 const char *buf, size_t count)
502 struct usb_device *udev = to_usb_device(dev);
505 if (kstrtou16(buf, 0, &timeout))
508 udev->l1_params.timeout = timeout;
512 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);
514 static ssize_t usb2_lpm_besl_show(struct device *dev,
515 struct device_attribute *attr, char *buf)
517 struct usb_device *udev = to_usb_device(dev);
518 return sprintf(buf, "%d\n", udev->l1_params.besl);
521 static ssize_t usb2_lpm_besl_store(struct device *dev,
522 struct device_attribute *attr,
523 const char *buf, size_t count)
525 struct usb_device *udev = to_usb_device(dev);
528 if (kstrtou8(buf, 0, &besl) || besl > 15)
531 udev->l1_params.besl = besl;
535 static DEVICE_ATTR_RW(usb2_lpm_besl);
537 static ssize_t usb3_hardware_lpm_u1_show(struct device *dev,
538 struct device_attribute *attr, char *buf)
540 struct usb_device *udev = to_usb_device(dev);
543 usb_lock_device(udev);
545 if (udev->usb3_lpm_u1_enabled)
550 usb_unlock_device(udev);
552 return sprintf(buf, "%s\n", p);
554 static DEVICE_ATTR_RO(usb3_hardware_lpm_u1);
556 static ssize_t usb3_hardware_lpm_u2_show(struct device *dev,
557 struct device_attribute *attr, char *buf)
559 struct usb_device *udev = to_usb_device(dev);
562 usb_lock_device(udev);
564 if (udev->usb3_lpm_u2_enabled)
569 usb_unlock_device(udev);
571 return sprintf(buf, "%s\n", p);
573 static DEVICE_ATTR_RO(usb3_hardware_lpm_u2);
575 static struct attribute *usb2_hardware_lpm_attr[] = {
576 &dev_attr_usb2_hardware_lpm.attr,
577 &dev_attr_usb2_lpm_l1_timeout.attr,
578 &dev_attr_usb2_lpm_besl.attr,
581 static struct attribute_group usb2_hardware_lpm_attr_group = {
582 .name = power_group_name,
583 .attrs = usb2_hardware_lpm_attr,
586 static struct attribute *usb3_hardware_lpm_attr[] = {
587 &dev_attr_usb3_hardware_lpm_u1.attr,
588 &dev_attr_usb3_hardware_lpm_u2.attr,
591 static struct attribute_group usb3_hardware_lpm_attr_group = {
592 .name = power_group_name,
593 .attrs = usb3_hardware_lpm_attr,
596 static struct attribute *power_attrs[] = {
597 &dev_attr_autosuspend.attr,
598 &dev_attr_level.attr,
599 &dev_attr_connected_duration.attr,
600 &dev_attr_active_duration.attr,
603 static struct attribute_group power_attr_group = {
604 .name = power_group_name,
605 .attrs = power_attrs,
608 static int add_power_attributes(struct device *dev)
612 if (is_usb_device(dev)) {
613 struct usb_device *udev = to_usb_device(dev);
614 rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
615 if (udev->usb2_hw_lpm_capable == 1)
616 rc = sysfs_merge_group(&dev->kobj,
617 &usb2_hardware_lpm_attr_group);
618 if (udev->speed == USB_SPEED_SUPER &&
619 udev->lpm_capable == 1)
620 rc = sysfs_merge_group(&dev->kobj,
621 &usb3_hardware_lpm_attr_group);
627 static void remove_power_attributes(struct device *dev)
629 sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
630 sysfs_unmerge_group(&dev->kobj, &power_attr_group);
635 #define add_persist_attributes(dev) 0
636 #define remove_persist_attributes(dev) do {} while (0)
638 #define add_power_attributes(dev) 0
639 #define remove_power_attributes(dev) do {} while (0)
641 #endif /* CONFIG_PM */
644 /* Descriptor fields */
645 #define usb_descriptor_attr_le16(field, format_string) \
647 field##_show(struct device *dev, struct device_attribute *attr, \
650 struct usb_device *udev; \
652 udev = to_usb_device(dev); \
653 return sprintf(buf, format_string, \
654 le16_to_cpu(udev->descriptor.field)); \
656 static DEVICE_ATTR_RO(field)
658 usb_descriptor_attr_le16(idVendor, "%04x\n");
659 usb_descriptor_attr_le16(idProduct, "%04x\n");
660 usb_descriptor_attr_le16(bcdDevice, "%04x\n");
662 #define usb_descriptor_attr(field, format_string) \
664 field##_show(struct device *dev, struct device_attribute *attr, \
667 struct usb_device *udev; \
669 udev = to_usb_device(dev); \
670 return sprintf(buf, format_string, udev->descriptor.field); \
672 static DEVICE_ATTR_RO(field)
674 usb_descriptor_attr(bDeviceClass, "%02x\n");
675 usb_descriptor_attr(bDeviceSubClass, "%02x\n");
676 usb_descriptor_attr(bDeviceProtocol, "%02x\n");
677 usb_descriptor_attr(bNumConfigurations, "%d\n");
678 usb_descriptor_attr(bMaxPacketSize0, "%d\n");
681 /* show if the device is authorized (1) or not (0) */
682 static ssize_t authorized_show(struct device *dev,
683 struct device_attribute *attr, char *buf)
685 struct usb_device *usb_dev = to_usb_device(dev);
686 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
690 * Authorize a device to be used in the system
692 * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
694 static ssize_t authorized_store(struct device *dev,
695 struct device_attribute *attr, const char *buf,
699 struct usb_device *usb_dev = to_usb_device(dev);
701 result = sscanf(buf, "%u\n", &val);
705 result = usb_deauthorize_device(usb_dev);
707 result = usb_authorize_device(usb_dev);
708 return result < 0 ? result : size;
710 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
711 authorized_show, authorized_store);
713 /* "Safely remove a device" */
714 static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
715 const char *buf, size_t count)
717 struct usb_device *udev = to_usb_device(dev);
720 usb_lock_device(udev);
721 if (udev->state != USB_STATE_NOTATTACHED) {
723 /* To avoid races, first unconfigure and then remove */
724 usb_set_configuration(udev, -1);
725 rc = usb_remove_device(udev);
729 usb_unlock_device(udev);
732 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
735 static struct attribute *dev_attrs[] = {
736 /* current configuration's attributes */
737 &dev_attr_configuration.attr,
738 &dev_attr_bNumInterfaces.attr,
739 &dev_attr_bConfigurationValue.attr,
740 &dev_attr_bmAttributes.attr,
741 &dev_attr_bMaxPower.attr,
742 /* device attributes */
743 &dev_attr_urbnum.attr,
744 &dev_attr_idVendor.attr,
745 &dev_attr_idProduct.attr,
746 &dev_attr_bcdDevice.attr,
747 &dev_attr_bDeviceClass.attr,
748 &dev_attr_bDeviceSubClass.attr,
749 &dev_attr_bDeviceProtocol.attr,
750 &dev_attr_bNumConfigurations.attr,
751 &dev_attr_bMaxPacketSize0.attr,
752 &dev_attr_speed.attr,
753 &dev_attr_busnum.attr,
754 &dev_attr_devnum.attr,
755 &dev_attr_devpath.attr,
756 &dev_attr_version.attr,
757 &dev_attr_maxchild.attr,
758 &dev_attr_quirks.attr,
759 &dev_attr_avoid_reset_quirk.attr,
760 &dev_attr_authorized.attr,
761 &dev_attr_remove.attr,
762 &dev_attr_removable.attr,
763 &dev_attr_ltm_capable.attr,
766 static struct attribute_group dev_attr_grp = {
770 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
773 static struct attribute *dev_string_attrs[] = {
774 &dev_attr_manufacturer.attr,
775 &dev_attr_product.attr,
776 &dev_attr_serial.attr,
780 static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
781 struct attribute *a, int n)
783 struct device *dev = container_of(kobj, struct device, kobj);
784 struct usb_device *udev = to_usb_device(dev);
786 if (a == &dev_attr_manufacturer.attr) {
787 if (udev->manufacturer == NULL)
789 } else if (a == &dev_attr_product.attr) {
790 if (udev->product == NULL)
792 } else if (a == &dev_attr_serial.attr) {
793 if (udev->serial == NULL)
799 static struct attribute_group dev_string_attr_grp = {
800 .attrs = dev_string_attrs,
801 .is_visible = dev_string_attrs_are_visible,
804 const struct attribute_group *usb_device_groups[] = {
806 &dev_string_attr_grp,
810 /* Binary descriptors */
813 read_descriptors(struct file *filp, struct kobject *kobj,
814 struct bin_attribute *attr,
815 char *buf, loff_t off, size_t count)
817 struct device *dev = container_of(kobj, struct device, kobj);
818 struct usb_device *udev = to_usb_device(dev);
819 size_t nleft = count;
824 /* The binary attribute begins with the device descriptor.
825 * Following that are the raw descriptor entries for all the
826 * configurations (config plus subsidiary descriptors).
828 usb_lock_device(udev);
829 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
830 nleft > 0; ++cfgno) {
832 src = &udev->descriptor;
833 srclen = sizeof(struct usb_device_descriptor);
835 src = udev->rawdescriptors[cfgno];
836 srclen = __le16_to_cpu(udev->config[cfgno].desc.
840 n = min(nleft, srclen - (size_t) off);
841 memcpy(buf, src + off, n);
849 usb_unlock_device(udev);
850 return count - nleft;
853 static struct bin_attribute dev_bin_attr_descriptors = {
854 .attr = {.name = "descriptors", .mode = 0444},
855 .read = read_descriptors,
856 .size = 18 + 65535, /* dev descr + max-size raw descriptor */
859 int usb_create_sysfs_dev_files(struct usb_device *udev)
861 struct device *dev = &udev->dev;
864 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
868 retval = add_persist_attributes(dev);
872 retval = add_power_attributes(dev);
877 usb_remove_sysfs_dev_files(udev);
881 void usb_remove_sysfs_dev_files(struct usb_device *udev)
883 struct device *dev = &udev->dev;
885 remove_power_attributes(dev);
886 remove_persist_attributes(dev);
887 device_remove_bin_file(dev, &dev_bin_attr_descriptors);
890 /* Interface Association Descriptor fields */
891 #define usb_intf_assoc_attr(field, format_string) \
893 iad_##field##_show(struct device *dev, struct device_attribute *attr, \
896 struct usb_interface *intf = to_usb_interface(dev); \
898 return sprintf(buf, format_string, \
899 intf->intf_assoc->field); \
901 static DEVICE_ATTR_RO(iad_##field)
903 usb_intf_assoc_attr(bFirstInterface, "%02x\n");
904 usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
905 usb_intf_assoc_attr(bFunctionClass, "%02x\n");
906 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
907 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
909 /* Interface fields */
910 #define usb_intf_attr(field, format_string) \
912 field##_show(struct device *dev, struct device_attribute *attr, \
915 struct usb_interface *intf = to_usb_interface(dev); \
917 return sprintf(buf, format_string, \
918 intf->cur_altsetting->desc.field); \
920 static DEVICE_ATTR_RO(field)
922 usb_intf_attr(bInterfaceNumber, "%02x\n");
923 usb_intf_attr(bAlternateSetting, "%2d\n");
924 usb_intf_attr(bNumEndpoints, "%02x\n");
925 usb_intf_attr(bInterfaceClass, "%02x\n");
926 usb_intf_attr(bInterfaceSubClass, "%02x\n");
927 usb_intf_attr(bInterfaceProtocol, "%02x\n");
929 static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
932 struct usb_interface *intf;
935 intf = to_usb_interface(dev);
936 string = ACCESS_ONCE(intf->cur_altsetting->string);
939 return sprintf(buf, "%s\n", string);
941 static DEVICE_ATTR_RO(interface);
943 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
946 struct usb_interface *intf;
947 struct usb_device *udev;
948 struct usb_host_interface *alt;
950 intf = to_usb_interface(dev);
951 udev = interface_to_usbdev(intf);
952 alt = ACCESS_ONCE(intf->cur_altsetting);
954 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
955 "ic%02Xisc%02Xip%02Xin%02X\n",
956 le16_to_cpu(udev->descriptor.idVendor),
957 le16_to_cpu(udev->descriptor.idProduct),
958 le16_to_cpu(udev->descriptor.bcdDevice),
959 udev->descriptor.bDeviceClass,
960 udev->descriptor.bDeviceSubClass,
961 udev->descriptor.bDeviceProtocol,
962 alt->desc.bInterfaceClass,
963 alt->desc.bInterfaceSubClass,
964 alt->desc.bInterfaceProtocol,
965 alt->desc.bInterfaceNumber);
967 static DEVICE_ATTR_RO(modalias);
969 static ssize_t supports_autosuspend_show(struct device *dev,
970 struct device_attribute *attr,
976 /* Devices will be autosuspended even when an interface isn't claimed */
977 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
980 return sprintf(buf, "%u\n", s);
982 static DEVICE_ATTR_RO(supports_autosuspend);
985 * interface_authorized_show - show authorization status of an USB interface
986 * 1 is authorized, 0 is deauthorized
988 static ssize_t interface_authorized_show(struct device *dev,
989 struct device_attribute *attr, char *buf)
991 struct usb_interface *intf = to_usb_interface(dev);
993 return sprintf(buf, "%u\n", intf->authorized);
997 * interface_authorized_store - authorize or deauthorize an USB interface
999 static ssize_t interface_authorized_store(struct device *dev,
1000 struct device_attribute *attr, const char *buf, size_t count)
1002 struct usb_interface *intf = to_usb_interface(dev);
1005 if (strtobool(buf, &val) != 0)
1009 usb_authorize_interface(intf);
1011 usb_deauthorize_interface(intf);
1015 static struct device_attribute dev_attr_interface_authorized =
1016 __ATTR(authorized, S_IRUGO | S_IWUSR,
1017 interface_authorized_show, interface_authorized_store);
1019 static struct attribute *intf_attrs[] = {
1020 &dev_attr_bInterfaceNumber.attr,
1021 &dev_attr_bAlternateSetting.attr,
1022 &dev_attr_bNumEndpoints.attr,
1023 &dev_attr_bInterfaceClass.attr,
1024 &dev_attr_bInterfaceSubClass.attr,
1025 &dev_attr_bInterfaceProtocol.attr,
1026 &dev_attr_modalias.attr,
1027 &dev_attr_supports_autosuspend.attr,
1028 &dev_attr_interface_authorized.attr,
1031 static struct attribute_group intf_attr_grp = {
1032 .attrs = intf_attrs,
1035 static struct attribute *intf_assoc_attrs[] = {
1036 &dev_attr_iad_bFirstInterface.attr,
1037 &dev_attr_iad_bInterfaceCount.attr,
1038 &dev_attr_iad_bFunctionClass.attr,
1039 &dev_attr_iad_bFunctionSubClass.attr,
1040 &dev_attr_iad_bFunctionProtocol.attr,
1044 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
1045 struct attribute *a, int n)
1047 struct device *dev = container_of(kobj, struct device, kobj);
1048 struct usb_interface *intf = to_usb_interface(dev);
1050 if (intf->intf_assoc == NULL)
1055 static struct attribute_group intf_assoc_attr_grp = {
1056 .attrs = intf_assoc_attrs,
1057 .is_visible = intf_assoc_attrs_are_visible,
1060 const struct attribute_group *usb_interface_groups[] = {
1062 &intf_assoc_attr_grp,
1066 void usb_create_sysfs_intf_files(struct usb_interface *intf)
1068 struct usb_device *udev = interface_to_usbdev(intf);
1069 struct usb_host_interface *alt = intf->cur_altsetting;
1071 if (intf->sysfs_files_created || intf->unregistering)
1074 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
1075 alt->string = usb_cache_string(udev, alt->desc.iInterface);
1076 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
1077 ; /* We don't actually care if the function fails. */
1078 intf->sysfs_files_created = 1;
1081 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
1083 if (!intf->sysfs_files_created)
1086 device_remove_file(&intf->dev, &dev_attr_interface);
1087 intf->sysfs_files_created = 0;