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, multiplier, format_string) \
21 static ssize_t show_##field(struct device *dev, \
22 struct device_attribute *attr, char *buf) \
24 struct usb_device *udev; \
25 struct usb_host_config *actconfig; \
27 udev = to_usb_device(dev); \
28 actconfig = udev->actconfig; \
30 return sprintf(buf, format_string, \
31 actconfig->desc.field * multiplier); \
36 #define usb_actconfig_attr(field, multiplier, format_string) \
37 usb_actconfig_show(field, multiplier, format_string) \
38 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
40 usb_actconfig_attr(bNumInterfaces
, 1, "%2d\n")
41 usb_actconfig_attr(bmAttributes
, 1, "%2x\n")
42 usb_actconfig_attr(bMaxPower
, 2, "%3dmA\n")
44 static ssize_t
show_configuration_string(struct device
*dev
,
45 struct device_attribute
*attr
, char *buf
)
47 struct usb_device
*udev
;
48 struct usb_host_config
*actconfig
;
50 udev
= to_usb_device(dev
);
51 actconfig
= udev
->actconfig
;
52 if ((!actconfig
) || (!actconfig
->string
))
54 return sprintf(buf
, "%s\n", actconfig
->string
);
56 static DEVICE_ATTR(configuration
, S_IRUGO
, show_configuration_string
, NULL
);
58 /* configuration value is always present, and r/w */
59 usb_actconfig_show(bConfigurationValue
, 1, "%u\n");
62 set_bConfigurationValue(struct device
*dev
, struct device_attribute
*attr
,
63 const char *buf
, size_t count
)
65 struct usb_device
*udev
= to_usb_device(dev
);
68 if (sscanf(buf
, "%d", &config
) != 1 || config
< -1 || config
> 255)
70 usb_lock_device(udev
);
71 value
= usb_set_configuration(udev
, config
);
72 usb_unlock_device(udev
);
73 return (value
< 0) ? value
: count
;
76 static DEVICE_ATTR(bConfigurationValue
, S_IRUGO
| S_IWUSR
,
77 show_bConfigurationValue
, set_bConfigurationValue
);
80 #define usb_string_attr(name) \
81 static ssize_t show_##name(struct device *dev, \
82 struct device_attribute *attr, char *buf) \
84 struct usb_device *udev; \
87 udev = to_usb_device(dev); \
88 usb_lock_device(udev); \
89 retval = sprintf(buf, "%s\n", udev->name); \
90 usb_unlock_device(udev); \
93 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
95 usb_string_attr(product
);
96 usb_string_attr(manufacturer
);
97 usb_string_attr(serial
);
100 show_speed(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
102 struct usb_device
*udev
;
105 udev
= to_usb_device(dev
);
107 switch (udev
->speed
) {
111 case USB_SPEED_UNKNOWN
:
118 case USB_SPEED_WIRELESS
:
121 case USB_SPEED_SUPER
:
127 return sprintf(buf
, "%s\n", speed
);
129 static DEVICE_ATTR(speed
, S_IRUGO
, show_speed
, NULL
);
132 show_busnum(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
134 struct usb_device
*udev
;
136 udev
= to_usb_device(dev
);
137 return sprintf(buf
, "%d\n", udev
->bus
->busnum
);
139 static DEVICE_ATTR(busnum
, S_IRUGO
, show_busnum
, NULL
);
142 show_devnum(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
144 struct usb_device
*udev
;
146 udev
= to_usb_device(dev
);
147 return sprintf(buf
, "%d\n", udev
->devnum
);
149 static DEVICE_ATTR(devnum
, S_IRUGO
, show_devnum
, NULL
);
152 show_devpath(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
154 struct usb_device
*udev
;
156 udev
= to_usb_device(dev
);
157 return sprintf(buf
, "%s\n", udev
->devpath
);
159 static DEVICE_ATTR(devpath
, S_IRUGO
, show_devpath
, NULL
);
162 show_version(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
164 struct usb_device
*udev
;
167 udev
= to_usb_device(dev
);
168 bcdUSB
= le16_to_cpu(udev
->descriptor
.bcdUSB
);
169 return sprintf(buf
, "%2x.%02x\n", bcdUSB
>> 8, bcdUSB
& 0xff);
171 static DEVICE_ATTR(version
, S_IRUGO
, show_version
, NULL
);
174 show_maxchild(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
176 struct usb_device
*udev
;
178 udev
= to_usb_device(dev
);
179 return sprintf(buf
, "%d\n", udev
->maxchild
);
181 static DEVICE_ATTR(maxchild
, S_IRUGO
, show_maxchild
, NULL
);
184 show_quirks(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
186 struct usb_device
*udev
;
188 udev
= to_usb_device(dev
);
189 return sprintf(buf
, "0x%x\n", udev
->quirks
);
191 static DEVICE_ATTR(quirks
, S_IRUGO
, show_quirks
, NULL
);
194 show_avoid_reset_quirk(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
196 struct usb_device
*udev
;
198 udev
= to_usb_device(dev
);
199 return sprintf(buf
, "%d\n", !!(udev
->quirks
& USB_QUIRK_RESET_MORPHS
));
203 set_avoid_reset_quirk(struct device
*dev
, struct device_attribute
*attr
,
204 const char *buf
, size_t count
)
206 struct usb_device
*udev
= to_usb_device(dev
);
209 if (sscanf(buf
, "%d", &config
) != 1 || config
< 0 || config
> 1)
211 usb_lock_device(udev
);
213 udev
->quirks
|= USB_QUIRK_RESET_MORPHS
;
215 udev
->quirks
&= ~USB_QUIRK_RESET_MORPHS
;
216 usb_unlock_device(udev
);
220 static DEVICE_ATTR(avoid_reset_quirk
, S_IRUGO
| S_IWUSR
,
221 show_avoid_reset_quirk
, set_avoid_reset_quirk
);
224 show_urbnum(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
226 struct usb_device
*udev
;
228 udev
= to_usb_device(dev
);
229 return sprintf(buf
, "%d\n", atomic_read(&udev
->urbnum
));
231 static DEVICE_ATTR(urbnum
, S_IRUGO
, show_urbnum
, NULL
);
234 show_removable(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
236 struct usb_device
*udev
;
239 udev
= to_usb_device(dev
);
241 switch (udev
->removable
) {
242 case USB_DEVICE_REMOVABLE
:
245 case USB_DEVICE_FIXED
:
252 return sprintf(buf
, "%s\n", state
);
254 static DEVICE_ATTR(removable
, S_IRUGO
, show_removable
, NULL
);
259 show_persist(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
261 struct usb_device
*udev
= to_usb_device(dev
);
263 return sprintf(buf
, "%d\n", udev
->persist_enabled
);
267 set_persist(struct device
*dev
, struct device_attribute
*attr
,
268 const char *buf
, size_t count
)
270 struct usb_device
*udev
= to_usb_device(dev
);
273 /* Hubs are always enabled for USB_PERSIST */
274 if (udev
->descriptor
.bDeviceClass
== USB_CLASS_HUB
)
277 if (sscanf(buf
, "%d", &value
) != 1)
280 usb_lock_device(udev
);
281 udev
->persist_enabled
= !!value
;
282 usb_unlock_device(udev
);
286 static DEVICE_ATTR(persist
, S_IRUGO
| S_IWUSR
, show_persist
, set_persist
);
288 static int add_persist_attributes(struct device
*dev
)
292 if (is_usb_device(dev
)) {
293 struct usb_device
*udev
= to_usb_device(dev
);
295 /* Hubs are automatically enabled for USB_PERSIST,
296 * no point in creating the attribute file.
298 if (udev
->descriptor
.bDeviceClass
!= USB_CLASS_HUB
)
299 rc
= sysfs_add_file_to_group(&dev
->kobj
,
300 &dev_attr_persist
.attr
,
306 static void remove_persist_attributes(struct device
*dev
)
308 sysfs_remove_file_from_group(&dev
->kobj
,
309 &dev_attr_persist
.attr
,
314 #define add_persist_attributes(dev) 0
315 #define remove_persist_attributes(dev) do {} while (0)
317 #endif /* CONFIG_PM */
319 #ifdef CONFIG_USB_SUSPEND
322 show_connected_duration(struct device
*dev
, struct device_attribute
*attr
,
325 struct usb_device
*udev
= to_usb_device(dev
);
327 return sprintf(buf
, "%u\n",
328 jiffies_to_msecs(jiffies
- udev
->connect_time
));
331 static DEVICE_ATTR(connected_duration
, S_IRUGO
, show_connected_duration
, NULL
);
334 * If the device is resumed, the last time the device was suspended has
335 * been pre-subtracted from active_duration. We add the current time to
336 * get the duration that the device was actually active.
338 * If the device is suspended, the active_duration is up-to-date.
341 show_active_duration(struct device
*dev
, struct device_attribute
*attr
,
344 struct usb_device
*udev
= to_usb_device(dev
);
347 if (udev
->state
!= USB_STATE_SUSPENDED
)
348 duration
= jiffies_to_msecs(jiffies
+ udev
->active_duration
);
350 duration
= jiffies_to_msecs(udev
->active_duration
);
351 return sprintf(buf
, "%u\n", duration
);
354 static DEVICE_ATTR(active_duration
, S_IRUGO
, show_active_duration
, NULL
);
357 show_autosuspend(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
359 return sprintf(buf
, "%d\n", dev
->power
.autosuspend_delay
/ 1000);
363 set_autosuspend(struct device
*dev
, struct device_attribute
*attr
,
364 const char *buf
, size_t count
)
368 if (sscanf(buf
, "%d", &value
) != 1 || value
>= INT_MAX
/1000 ||
369 value
<= -INT_MAX
/1000)
372 pm_runtime_set_autosuspend_delay(dev
, value
* 1000);
376 static DEVICE_ATTR(autosuspend
, S_IRUGO
| S_IWUSR
,
377 show_autosuspend
, set_autosuspend
);
379 static const char on_string
[] = "on";
380 static const char auto_string
[] = "auto";
382 static void warn_level(void) {
383 static int level_warned
;
387 printk(KERN_WARNING
"WARNING! power/level is deprecated; "
388 "use power/control instead\n");
393 show_level(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
395 struct usb_device
*udev
= to_usb_device(dev
);
396 const char *p
= auto_string
;
399 if (udev
->state
!= USB_STATE_SUSPENDED
&& !udev
->dev
.power
.runtime_auto
)
401 return sprintf(buf
, "%s\n", p
);
405 set_level(struct device
*dev
, struct device_attribute
*attr
,
406 const char *buf
, size_t count
)
408 struct usb_device
*udev
= to_usb_device(dev
);
414 cp
= memchr(buf
, '\n', count
);
418 usb_lock_device(udev
);
420 if (len
== sizeof on_string
- 1 &&
421 strncmp(buf
, on_string
, len
) == 0)
422 usb_disable_autosuspend(udev
);
424 else if (len
== sizeof auto_string
- 1 &&
425 strncmp(buf
, auto_string
, len
) == 0)
426 usb_enable_autosuspend(udev
);
431 usb_unlock_device(udev
);
435 static DEVICE_ATTR(level
, S_IRUGO
| S_IWUSR
, show_level
, set_level
);
438 show_usb2_hardware_lpm(struct device
*dev
, struct device_attribute
*attr
,
441 struct usb_device
*udev
= to_usb_device(dev
);
444 if (udev
->usb2_hw_lpm_enabled
== 1)
449 return sprintf(buf
, "%s\n", p
);
453 set_usb2_hardware_lpm(struct device
*dev
, struct device_attribute
*attr
,
454 const char *buf
, size_t count
)
456 struct usb_device
*udev
= to_usb_device(dev
);
460 usb_lock_device(udev
);
462 ret
= strtobool(buf
, &value
);
465 ret
= usb_set_usb2_hardware_lpm(udev
, value
);
467 usb_unlock_device(udev
);
475 static DEVICE_ATTR(usb2_hardware_lpm
, S_IRUGO
| S_IWUSR
, show_usb2_hardware_lpm
,
476 set_usb2_hardware_lpm
);
478 static struct attribute
*usb2_hardware_lpm_attr
[] = {
479 &dev_attr_usb2_hardware_lpm
.attr
,
482 static struct attribute_group usb2_hardware_lpm_attr_group
= {
483 .name
= power_group_name
,
484 .attrs
= usb2_hardware_lpm_attr
,
487 static struct attribute
*power_attrs
[] = {
488 &dev_attr_autosuspend
.attr
,
489 &dev_attr_level
.attr
,
490 &dev_attr_connected_duration
.attr
,
491 &dev_attr_active_duration
.attr
,
494 static struct attribute_group power_attr_group
= {
495 .name
= power_group_name
,
496 .attrs
= power_attrs
,
499 static int add_power_attributes(struct device
*dev
)
503 if (is_usb_device(dev
)) {
504 struct usb_device
*udev
= to_usb_device(dev
);
505 rc
= sysfs_merge_group(&dev
->kobj
, &power_attr_group
);
506 if (udev
->usb2_hw_lpm_capable
== 1)
507 rc
= sysfs_merge_group(&dev
->kobj
,
508 &usb2_hardware_lpm_attr_group
);
514 static void remove_power_attributes(struct device
*dev
)
516 sysfs_unmerge_group(&dev
->kobj
, &usb2_hardware_lpm_attr_group
);
517 sysfs_unmerge_group(&dev
->kobj
, &power_attr_group
);
522 #define add_power_attributes(dev) 0
523 #define remove_power_attributes(dev) do {} while (0)
525 #endif /* CONFIG_USB_SUSPEND */
528 /* Descriptor fields */
529 #define usb_descriptor_attr_le16(field, format_string) \
531 show_##field(struct device *dev, struct device_attribute *attr, \
534 struct usb_device *udev; \
536 udev = to_usb_device(dev); \
537 return sprintf(buf, format_string, \
538 le16_to_cpu(udev->descriptor.field)); \
540 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
542 usb_descriptor_attr_le16(idVendor
, "%04x\n")
543 usb_descriptor_attr_le16(idProduct
, "%04x\n")
544 usb_descriptor_attr_le16(bcdDevice
, "%04x\n")
546 #define usb_descriptor_attr(field, format_string) \
548 show_##field(struct device *dev, struct device_attribute *attr, \
551 struct usb_device *udev; \
553 udev = to_usb_device(dev); \
554 return sprintf(buf, format_string, udev->descriptor.field); \
556 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
558 usb_descriptor_attr(bDeviceClass
, "%02x\n")
559 usb_descriptor_attr(bDeviceSubClass
, "%02x\n")
560 usb_descriptor_attr(bDeviceProtocol
, "%02x\n")
561 usb_descriptor_attr(bNumConfigurations
, "%d\n")
562 usb_descriptor_attr(bMaxPacketSize0
, "%d\n")
566 /* show if the device is authorized (1) or not (0) */
567 static ssize_t
usb_dev_authorized_show(struct device
*dev
,
568 struct device_attribute
*attr
,
571 struct usb_device
*usb_dev
= to_usb_device(dev
);
572 return snprintf(buf
, PAGE_SIZE
, "%u\n", usb_dev
->authorized
);
577 * Authorize a device to be used in the system
579 * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
581 static ssize_t
usb_dev_authorized_store(struct device
*dev
,
582 struct device_attribute
*attr
,
583 const char *buf
, size_t size
)
586 struct usb_device
*usb_dev
= to_usb_device(dev
);
588 result
= sscanf(buf
, "%u\n", &val
);
592 result
= usb_deauthorize_device(usb_dev
);
594 result
= usb_authorize_device(usb_dev
);
595 return result
< 0? result
: size
;
598 static DEVICE_ATTR(authorized
, 0644,
599 usb_dev_authorized_show
, usb_dev_authorized_store
);
601 /* "Safely remove a device" */
602 static ssize_t
usb_remove_store(struct device
*dev
,
603 struct device_attribute
*attr
,
604 const char *buf
, size_t count
)
606 struct usb_device
*udev
= to_usb_device(dev
);
609 usb_lock_device(udev
);
610 if (udev
->state
!= USB_STATE_NOTATTACHED
) {
612 /* To avoid races, first unconfigure and then remove */
613 usb_set_configuration(udev
, -1);
614 rc
= usb_remove_device(udev
);
618 usb_unlock_device(udev
);
621 static DEVICE_ATTR(remove
, 0200, NULL
, usb_remove_store
);
624 static struct attribute
*dev_attrs
[] = {
625 /* current configuration's attributes */
626 &dev_attr_configuration
.attr
,
627 &dev_attr_bNumInterfaces
.attr
,
628 &dev_attr_bConfigurationValue
.attr
,
629 &dev_attr_bmAttributes
.attr
,
630 &dev_attr_bMaxPower
.attr
,
631 /* device attributes */
632 &dev_attr_urbnum
.attr
,
633 &dev_attr_idVendor
.attr
,
634 &dev_attr_idProduct
.attr
,
635 &dev_attr_bcdDevice
.attr
,
636 &dev_attr_bDeviceClass
.attr
,
637 &dev_attr_bDeviceSubClass
.attr
,
638 &dev_attr_bDeviceProtocol
.attr
,
639 &dev_attr_bNumConfigurations
.attr
,
640 &dev_attr_bMaxPacketSize0
.attr
,
641 &dev_attr_speed
.attr
,
642 &dev_attr_busnum
.attr
,
643 &dev_attr_devnum
.attr
,
644 &dev_attr_devpath
.attr
,
645 &dev_attr_version
.attr
,
646 &dev_attr_maxchild
.attr
,
647 &dev_attr_quirks
.attr
,
648 &dev_attr_avoid_reset_quirk
.attr
,
649 &dev_attr_authorized
.attr
,
650 &dev_attr_remove
.attr
,
651 &dev_attr_removable
.attr
,
654 static struct attribute_group dev_attr_grp
= {
658 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
661 static struct attribute
*dev_string_attrs
[] = {
662 &dev_attr_manufacturer
.attr
,
663 &dev_attr_product
.attr
,
664 &dev_attr_serial
.attr
,
668 static umode_t
dev_string_attrs_are_visible(struct kobject
*kobj
,
669 struct attribute
*a
, int n
)
671 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
672 struct usb_device
*udev
= to_usb_device(dev
);
674 if (a
== &dev_attr_manufacturer
.attr
) {
675 if (udev
->manufacturer
== NULL
)
677 } else if (a
== &dev_attr_product
.attr
) {
678 if (udev
->product
== NULL
)
680 } else if (a
== &dev_attr_serial
.attr
) {
681 if (udev
->serial
== NULL
)
687 static struct attribute_group dev_string_attr_grp
= {
688 .attrs
= dev_string_attrs
,
689 .is_visible
= dev_string_attrs_are_visible
,
692 const struct attribute_group
*usb_device_groups
[] = {
694 &dev_string_attr_grp
,
698 /* Binary descriptors */
701 read_descriptors(struct file
*filp
, struct kobject
*kobj
,
702 struct bin_attribute
*attr
,
703 char *buf
, loff_t off
, size_t count
)
705 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
706 struct usb_device
*udev
= to_usb_device(dev
);
707 size_t nleft
= count
;
712 /* The binary attribute begins with the device descriptor.
713 * Following that are the raw descriptor entries for all the
714 * configurations (config plus subsidiary descriptors).
716 for (cfgno
= -1; cfgno
< udev
->descriptor
.bNumConfigurations
&&
717 nleft
> 0; ++cfgno
) {
719 src
= &udev
->descriptor
;
720 srclen
= sizeof(struct usb_device_descriptor
);
722 src
= udev
->rawdescriptors
[cfgno
];
723 srclen
= __le16_to_cpu(udev
->config
[cfgno
].desc
.
727 n
= min(nleft
, srclen
- (size_t) off
);
728 memcpy(buf
, src
+ off
, n
);
736 return count
- nleft
;
739 static struct bin_attribute dev_bin_attr_descriptors
= {
740 .attr
= {.name
= "descriptors", .mode
= 0444},
741 .read
= read_descriptors
,
742 .size
= 18 + 65535, /* dev descr + max-size raw descriptor */
745 int usb_create_sysfs_dev_files(struct usb_device
*udev
)
747 struct device
*dev
= &udev
->dev
;
750 retval
= device_create_bin_file(dev
, &dev_bin_attr_descriptors
);
754 retval
= add_persist_attributes(dev
);
758 retval
= add_power_attributes(dev
);
763 usb_remove_sysfs_dev_files(udev
);
767 void usb_remove_sysfs_dev_files(struct usb_device
*udev
)
769 struct device
*dev
= &udev
->dev
;
771 remove_power_attributes(dev
);
772 remove_persist_attributes(dev
);
773 device_remove_bin_file(dev
, &dev_bin_attr_descriptors
);
776 /* Interface Accociation Descriptor fields */
777 #define usb_intf_assoc_attr(field, format_string) \
779 show_iad_##field(struct device *dev, struct device_attribute *attr, \
782 struct usb_interface *intf = to_usb_interface(dev); \
784 return sprintf(buf, format_string, \
785 intf->intf_assoc->field); \
787 static DEVICE_ATTR(iad_##field, S_IRUGO, show_iad_##field, NULL);
789 usb_intf_assoc_attr(bFirstInterface
, "%02x\n")
790 usb_intf_assoc_attr(bInterfaceCount
, "%02d\n")
791 usb_intf_assoc_attr(bFunctionClass
, "%02x\n")
792 usb_intf_assoc_attr(bFunctionSubClass
, "%02x\n")
793 usb_intf_assoc_attr(bFunctionProtocol
, "%02x\n")
795 /* Interface fields */
796 #define usb_intf_attr(field, format_string) \
798 show_##field(struct device *dev, struct device_attribute *attr, \
801 struct usb_interface *intf = to_usb_interface(dev); \
803 return sprintf(buf, format_string, \
804 intf->cur_altsetting->desc.field); \
806 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
808 usb_intf_attr(bInterfaceNumber
, "%02x\n")
809 usb_intf_attr(bAlternateSetting
, "%2d\n")
810 usb_intf_attr(bNumEndpoints
, "%02x\n")
811 usb_intf_attr(bInterfaceClass
, "%02x\n")
812 usb_intf_attr(bInterfaceSubClass
, "%02x\n")
813 usb_intf_attr(bInterfaceProtocol
, "%02x\n")
815 static ssize_t
show_interface_string(struct device
*dev
,
816 struct device_attribute
*attr
, char *buf
)
818 struct usb_interface
*intf
;
821 intf
= to_usb_interface(dev
);
822 string
= intf
->cur_altsetting
->string
;
823 barrier(); /* The altsetting might change! */
827 return sprintf(buf
, "%s\n", string
);
829 static DEVICE_ATTR(interface
, S_IRUGO
, show_interface_string
, NULL
);
831 static ssize_t
show_modalias(struct device
*dev
,
832 struct device_attribute
*attr
, char *buf
)
834 struct usb_interface
*intf
;
835 struct usb_device
*udev
;
836 struct usb_host_interface
*alt
;
838 intf
= to_usb_interface(dev
);
839 udev
= interface_to_usbdev(intf
);
840 alt
= intf
->cur_altsetting
;
842 return sprintf(buf
, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
843 "ic%02Xisc%02Xip%02X\n",
844 le16_to_cpu(udev
->descriptor
.idVendor
),
845 le16_to_cpu(udev
->descriptor
.idProduct
),
846 le16_to_cpu(udev
->descriptor
.bcdDevice
),
847 udev
->descriptor
.bDeviceClass
,
848 udev
->descriptor
.bDeviceSubClass
,
849 udev
->descriptor
.bDeviceProtocol
,
850 alt
->desc
.bInterfaceClass
,
851 alt
->desc
.bInterfaceSubClass
,
852 alt
->desc
.bInterfaceProtocol
);
854 static DEVICE_ATTR(modalias
, S_IRUGO
, show_modalias
, NULL
);
856 static ssize_t
show_supports_autosuspend(struct device
*dev
,
857 struct device_attribute
*attr
, char *buf
)
859 struct usb_interface
*intf
;
860 struct usb_device
*udev
;
863 intf
= to_usb_interface(dev
);
864 udev
= interface_to_usbdev(intf
);
866 usb_lock_device(udev
);
867 /* Devices will be autosuspended even when an interface isn't claimed */
868 if (!intf
->dev
.driver
||
869 to_usb_driver(intf
->dev
.driver
)->supports_autosuspend
)
870 ret
= sprintf(buf
, "%u\n", 1);
872 ret
= sprintf(buf
, "%u\n", 0);
873 usb_unlock_device(udev
);
877 static DEVICE_ATTR(supports_autosuspend
, S_IRUGO
, show_supports_autosuspend
, NULL
);
879 static struct attribute
*intf_attrs
[] = {
880 &dev_attr_bInterfaceNumber
.attr
,
881 &dev_attr_bAlternateSetting
.attr
,
882 &dev_attr_bNumEndpoints
.attr
,
883 &dev_attr_bInterfaceClass
.attr
,
884 &dev_attr_bInterfaceSubClass
.attr
,
885 &dev_attr_bInterfaceProtocol
.attr
,
886 &dev_attr_modalias
.attr
,
887 &dev_attr_supports_autosuspend
.attr
,
890 static struct attribute_group intf_attr_grp
= {
894 static struct attribute
*intf_assoc_attrs
[] = {
895 &dev_attr_iad_bFirstInterface
.attr
,
896 &dev_attr_iad_bInterfaceCount
.attr
,
897 &dev_attr_iad_bFunctionClass
.attr
,
898 &dev_attr_iad_bFunctionSubClass
.attr
,
899 &dev_attr_iad_bFunctionProtocol
.attr
,
903 static umode_t
intf_assoc_attrs_are_visible(struct kobject
*kobj
,
904 struct attribute
*a
, int n
)
906 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
907 struct usb_interface
*intf
= to_usb_interface(dev
);
909 if (intf
->intf_assoc
== NULL
)
914 static struct attribute_group intf_assoc_attr_grp
= {
915 .attrs
= intf_assoc_attrs
,
916 .is_visible
= intf_assoc_attrs_are_visible
,
919 const struct attribute_group
*usb_interface_groups
[] = {
921 &intf_assoc_attr_grp
,
925 void usb_create_sysfs_intf_files(struct usb_interface
*intf
)
927 struct usb_device
*udev
= interface_to_usbdev(intf
);
928 struct usb_host_interface
*alt
= intf
->cur_altsetting
;
930 if (intf
->sysfs_files_created
|| intf
->unregistering
)
933 if (!alt
->string
&& !(udev
->quirks
& USB_QUIRK_CONFIG_INTF_STRINGS
))
934 alt
->string
= usb_cache_string(udev
, alt
->desc
.iInterface
);
935 if (alt
->string
&& device_create_file(&intf
->dev
, &dev_attr_interface
))
936 ; /* We don't actually care if the function fails. */
937 intf
->sysfs_files_created
= 1;
940 void usb_remove_sysfs_intf_files(struct usb_interface
*intf
)
942 if (!intf
->sysfs_files_created
)
945 device_remove_file(&intf
->dev
, &dev_attr_interface
);
946 intf
->sysfs_files_created
= 0;