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; \
86 udev = to_usb_device(dev); \
87 return sprintf(buf, "%s\n", udev->name); \
89 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
91 usb_string_attr(product
);
92 usb_string_attr(manufacturer
);
93 usb_string_attr(serial
);
96 show_speed(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
98 struct usb_device
*udev
;
101 udev
= to_usb_device(dev
);
103 switch (udev
->speed
) {
107 case USB_SPEED_UNKNOWN
:
117 return sprintf(buf
, "%s\n", speed
);
119 static DEVICE_ATTR(speed
, S_IRUGO
, show_speed
, NULL
);
122 show_busnum(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
124 struct usb_device
*udev
;
126 udev
= to_usb_device(dev
);
127 return sprintf(buf
, "%d\n", udev
->bus
->busnum
);
129 static DEVICE_ATTR(busnum
, S_IRUGO
, show_busnum
, NULL
);
132 show_devnum(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
->devnum
);
139 static DEVICE_ATTR(devnum
, S_IRUGO
, show_devnum
, NULL
);
142 show_devpath(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
144 struct usb_device
*udev
;
146 udev
= to_usb_device(dev
);
147 return sprintf(buf
, "%s\n", udev
->devpath
);
149 static DEVICE_ATTR(devpath
, S_IRUGO
, show_devpath
, NULL
);
152 show_version(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
154 struct usb_device
*udev
;
157 udev
= to_usb_device(dev
);
158 bcdUSB
= le16_to_cpu(udev
->descriptor
.bcdUSB
);
159 return sprintf(buf
, "%2x.%02x\n", bcdUSB
>> 8, bcdUSB
& 0xff);
161 static DEVICE_ATTR(version
, S_IRUGO
, show_version
, NULL
);
164 show_maxchild(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
166 struct usb_device
*udev
;
168 udev
= to_usb_device(dev
);
169 return sprintf(buf
, "%d\n", udev
->maxchild
);
171 static DEVICE_ATTR(maxchild
, S_IRUGO
, show_maxchild
, NULL
);
174 show_quirks(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
176 struct usb_device
*udev
;
178 udev
= to_usb_device(dev
);
179 return sprintf(buf
, "0x%x\n", udev
->quirks
);
181 static DEVICE_ATTR(quirks
, S_IRUGO
, show_quirks
, NULL
);
184 show_urbnum(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
186 struct usb_device
*udev
;
188 udev
= to_usb_device(dev
);
189 return sprintf(buf
, "%d\n", atomic_read(&udev
->urbnum
));
191 static DEVICE_ATTR(urbnum
, S_IRUGO
, show_urbnum
, NULL
);
196 static const char power_group
[] = "power";
199 show_persist(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
201 struct usb_device
*udev
= to_usb_device(dev
);
203 return sprintf(buf
, "%d\n", udev
->persist_enabled
);
207 set_persist(struct device
*dev
, struct device_attribute
*attr
,
208 const char *buf
, size_t count
)
210 struct usb_device
*udev
= to_usb_device(dev
);
213 /* Hubs are always enabled for USB_PERSIST */
214 if (udev
->descriptor
.bDeviceClass
== USB_CLASS_HUB
)
217 if (sscanf(buf
, "%d", &value
) != 1)
220 udev
->persist_enabled
= !!value
;
225 static DEVICE_ATTR(persist
, S_IRUGO
| S_IWUSR
, show_persist
, set_persist
);
227 static int add_persist_attributes(struct device
*dev
)
231 if (is_usb_device(dev
)) {
232 struct usb_device
*udev
= to_usb_device(dev
);
234 /* Hubs are automatically enabled for USB_PERSIST,
235 * no point in creating the attribute file.
237 if (udev
->descriptor
.bDeviceClass
!= USB_CLASS_HUB
)
238 rc
= sysfs_add_file_to_group(&dev
->kobj
,
239 &dev_attr_persist
.attr
,
245 static void remove_persist_attributes(struct device
*dev
)
247 sysfs_remove_file_from_group(&dev
->kobj
,
248 &dev_attr_persist
.attr
,
253 #define add_persist_attributes(dev) 0
254 #define remove_persist_attributes(dev) do {} while (0)
256 #endif /* CONFIG_PM */
258 #ifdef CONFIG_USB_SUSPEND
261 show_connected_duration(struct device
*dev
, struct device_attribute
*attr
,
264 struct usb_device
*udev
= to_usb_device(dev
);
266 return sprintf(buf
, "%u\n",
267 jiffies_to_msecs(jiffies
- udev
->connect_time
));
270 static DEVICE_ATTR(connected_duration
, S_IRUGO
, show_connected_duration
, NULL
);
273 * If the device is resumed, the last time the device was suspended has
274 * been pre-subtracted from active_duration. We add the current time to
275 * get the duration that the device was actually active.
277 * If the device is suspended, the active_duration is up-to-date.
280 show_active_duration(struct device
*dev
, struct device_attribute
*attr
,
283 struct usb_device
*udev
= to_usb_device(dev
);
286 if (udev
->state
!= USB_STATE_SUSPENDED
)
287 duration
= jiffies_to_msecs(jiffies
+ udev
->active_duration
);
289 duration
= jiffies_to_msecs(udev
->active_duration
);
290 return sprintf(buf
, "%u\n", duration
);
293 static DEVICE_ATTR(active_duration
, S_IRUGO
, show_active_duration
, NULL
);
296 show_autosuspend(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
298 struct usb_device
*udev
= to_usb_device(dev
);
300 return sprintf(buf
, "%d\n", udev
->autosuspend_delay
/ HZ
);
304 set_autosuspend(struct device
*dev
, struct device_attribute
*attr
,
305 const char *buf
, size_t count
)
307 struct usb_device
*udev
= to_usb_device(dev
);
310 if (sscanf(buf
, "%d", &value
) != 1 || value
>= INT_MAX
/HZ
||
311 value
<= - INT_MAX
/HZ
)
315 udev
->autosuspend_delay
= value
;
317 usb_try_autosuspend_device(udev
);
319 if (usb_autoresume_device(udev
) == 0)
320 usb_autosuspend_device(udev
);
325 static DEVICE_ATTR(autosuspend
, S_IRUGO
| S_IWUSR
,
326 show_autosuspend
, set_autosuspend
);
328 static const char on_string
[] = "on";
329 static const char auto_string
[] = "auto";
330 static const char suspend_string
[] = "suspend";
333 show_level(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
335 struct usb_device
*udev
= to_usb_device(dev
);
336 const char *p
= auto_string
;
338 if (udev
->state
== USB_STATE_SUSPENDED
) {
339 if (udev
->autoresume_disabled
)
342 if (udev
->autosuspend_disabled
)
345 return sprintf(buf
, "%s\n", p
);
349 set_level(struct device
*dev
, struct device_attribute
*attr
,
350 const char *buf
, size_t count
)
352 struct usb_device
*udev
= to_usb_device(dev
);
356 int old_autosuspend_disabled
, old_autoresume_disabled
;
358 cp
= memchr(buf
, '\n', count
);
362 usb_lock_device(udev
);
363 old_autosuspend_disabled
= udev
->autosuspend_disabled
;
364 old_autoresume_disabled
= udev
->autoresume_disabled
;
366 /* Setting the flags without calling usb_pm_lock is a subject to
367 * races, but who cares...
369 if (len
== sizeof on_string
- 1 &&
370 strncmp(buf
, on_string
, len
) == 0) {
371 udev
->autosuspend_disabled
= 1;
372 udev
->autoresume_disabled
= 0;
373 rc
= usb_external_resume_device(udev
, PMSG_USER_RESUME
);
375 } else if (len
== sizeof auto_string
- 1 &&
376 strncmp(buf
, auto_string
, len
) == 0) {
377 udev
->autosuspend_disabled
= 0;
378 udev
->autoresume_disabled
= 0;
379 rc
= usb_external_resume_device(udev
, PMSG_USER_RESUME
);
381 } else if (len
== sizeof suspend_string
- 1 &&
382 strncmp(buf
, suspend_string
, len
) == 0) {
383 udev
->autosuspend_disabled
= 0;
384 udev
->autoresume_disabled
= 1;
385 rc
= usb_external_suspend_device(udev
, PMSG_USER_SUSPEND
);
391 udev
->autosuspend_disabled
= old_autosuspend_disabled
;
392 udev
->autoresume_disabled
= old_autoresume_disabled
;
394 usb_unlock_device(udev
);
395 return (rc
< 0 ? rc
: count
);
398 static DEVICE_ATTR(level
, S_IRUGO
| S_IWUSR
, show_level
, set_level
);
400 static int add_power_attributes(struct device
*dev
)
404 if (is_usb_device(dev
)) {
405 rc
= sysfs_add_file_to_group(&dev
->kobj
,
406 &dev_attr_autosuspend
.attr
,
409 rc
= sysfs_add_file_to_group(&dev
->kobj
,
410 &dev_attr_level
.attr
,
413 rc
= sysfs_add_file_to_group(&dev
->kobj
,
414 &dev_attr_connected_duration
.attr
,
417 rc
= sysfs_add_file_to_group(&dev
->kobj
,
418 &dev_attr_active_duration
.attr
,
424 static void remove_power_attributes(struct device
*dev
)
426 sysfs_remove_file_from_group(&dev
->kobj
,
427 &dev_attr_active_duration
.attr
,
429 sysfs_remove_file_from_group(&dev
->kobj
,
430 &dev_attr_connected_duration
.attr
,
432 sysfs_remove_file_from_group(&dev
->kobj
,
433 &dev_attr_level
.attr
,
435 sysfs_remove_file_from_group(&dev
->kobj
,
436 &dev_attr_autosuspend
.attr
,
442 #define add_power_attributes(dev) 0
443 #define remove_power_attributes(dev) do {} while (0)
445 #endif /* CONFIG_USB_SUSPEND */
448 /* Descriptor fields */
449 #define usb_descriptor_attr_le16(field, format_string) \
451 show_##field(struct device *dev, struct device_attribute *attr, \
454 struct usb_device *udev; \
456 udev = to_usb_device(dev); \
457 return sprintf(buf, format_string, \
458 le16_to_cpu(udev->descriptor.field)); \
460 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
462 usb_descriptor_attr_le16(idVendor
, "%04x\n")
463 usb_descriptor_attr_le16(idProduct
, "%04x\n")
464 usb_descriptor_attr_le16(bcdDevice
, "%04x\n")
466 #define usb_descriptor_attr(field, format_string) \
468 show_##field(struct device *dev, struct device_attribute *attr, \
471 struct usb_device *udev; \
473 udev = to_usb_device(dev); \
474 return sprintf(buf, format_string, udev->descriptor.field); \
476 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
478 usb_descriptor_attr(bDeviceClass
, "%02x\n")
479 usb_descriptor_attr(bDeviceSubClass
, "%02x\n")
480 usb_descriptor_attr(bDeviceProtocol
, "%02x\n")
481 usb_descriptor_attr(bNumConfigurations
, "%d\n")
482 usb_descriptor_attr(bMaxPacketSize0
, "%d\n")
486 /* show if the device is authorized (1) or not (0) */
487 static ssize_t
usb_dev_authorized_show(struct device
*dev
,
488 struct device_attribute
*attr
,
491 struct usb_device
*usb_dev
= to_usb_device(dev
);
492 return snprintf(buf
, PAGE_SIZE
, "%u\n", usb_dev
->authorized
);
497 * Authorize a device to be used in the system
499 * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
501 static ssize_t
usb_dev_authorized_store(struct device
*dev
,
502 struct device_attribute
*attr
,
503 const char *buf
, size_t size
)
506 struct usb_device
*usb_dev
= to_usb_device(dev
);
508 result
= sscanf(buf
, "%u\n", &val
);
512 result
= usb_deauthorize_device(usb_dev
);
514 result
= usb_authorize_device(usb_dev
);
515 return result
< 0? result
: size
;
518 static DEVICE_ATTR(authorized
, 0644,
519 usb_dev_authorized_show
, usb_dev_authorized_store
);
521 /* "Safely remove a device" */
522 static ssize_t
usb_remove_store(struct device
*dev
,
523 struct device_attribute
*attr
,
524 const char *buf
, size_t count
)
526 struct usb_device
*udev
= to_usb_device(dev
);
529 usb_lock_device(udev
);
530 if (udev
->state
!= USB_STATE_NOTATTACHED
) {
532 /* To avoid races, first unconfigure and then remove */
533 usb_set_configuration(udev
, -1);
534 rc
= usb_remove_device(udev
);
538 usb_unlock_device(udev
);
541 static DEVICE_ATTR(remove
, 0200, NULL
, usb_remove_store
);
544 static struct attribute
*dev_attrs
[] = {
545 /* current configuration's attributes */
546 &dev_attr_configuration
.attr
,
547 &dev_attr_bNumInterfaces
.attr
,
548 &dev_attr_bConfigurationValue
.attr
,
549 &dev_attr_bmAttributes
.attr
,
550 &dev_attr_bMaxPower
.attr
,
551 /* device attributes */
552 &dev_attr_urbnum
.attr
,
553 &dev_attr_idVendor
.attr
,
554 &dev_attr_idProduct
.attr
,
555 &dev_attr_bcdDevice
.attr
,
556 &dev_attr_bDeviceClass
.attr
,
557 &dev_attr_bDeviceSubClass
.attr
,
558 &dev_attr_bDeviceProtocol
.attr
,
559 &dev_attr_bNumConfigurations
.attr
,
560 &dev_attr_bMaxPacketSize0
.attr
,
561 &dev_attr_speed
.attr
,
562 &dev_attr_busnum
.attr
,
563 &dev_attr_devnum
.attr
,
564 &dev_attr_devpath
.attr
,
565 &dev_attr_version
.attr
,
566 &dev_attr_maxchild
.attr
,
567 &dev_attr_quirks
.attr
,
568 &dev_attr_authorized
.attr
,
569 &dev_attr_remove
.attr
,
572 static struct attribute_group dev_attr_grp
= {
576 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
579 static struct attribute
*dev_string_attrs
[] = {
580 &dev_attr_manufacturer
.attr
,
581 &dev_attr_product
.attr
,
582 &dev_attr_serial
.attr
,
586 static mode_t
dev_string_attrs_are_visible(struct kobject
*kobj
,
587 struct attribute
*a
, int n
)
589 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
590 struct usb_device
*udev
= to_usb_device(dev
);
592 if (a
== &dev_attr_manufacturer
.attr
) {
593 if (udev
->manufacturer
== NULL
)
595 } else if (a
== &dev_attr_product
.attr
) {
596 if (udev
->product
== NULL
)
598 } else if (a
== &dev_attr_serial
.attr
) {
599 if (udev
->serial
== NULL
)
605 static struct attribute_group dev_string_attr_grp
= {
606 .attrs
= dev_string_attrs
,
607 .is_visible
= dev_string_attrs_are_visible
,
610 const struct attribute_group
*usb_device_groups
[] = {
612 &dev_string_attr_grp
,
616 /* Binary descriptors */
619 read_descriptors(struct kobject
*kobj
, struct bin_attribute
*attr
,
620 char *buf
, loff_t off
, size_t count
)
622 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
623 struct usb_device
*udev
= to_usb_device(dev
);
624 size_t nleft
= count
;
629 /* The binary attribute begins with the device descriptor.
630 * Following that are the raw descriptor entries for all the
631 * configurations (config plus subsidiary descriptors).
633 for (cfgno
= -1; cfgno
< udev
->descriptor
.bNumConfigurations
&&
634 nleft
> 0; ++cfgno
) {
636 src
= &udev
->descriptor
;
637 srclen
= sizeof(struct usb_device_descriptor
);
639 src
= udev
->rawdescriptors
[cfgno
];
640 srclen
= __le16_to_cpu(udev
->config
[cfgno
].desc
.
644 n
= min(nleft
, srclen
- (size_t) off
);
645 memcpy(buf
, src
+ off
, n
);
653 return count
- nleft
;
656 static struct bin_attribute dev_bin_attr_descriptors
= {
657 .attr
= {.name
= "descriptors", .mode
= 0444},
658 .read
= read_descriptors
,
659 .size
= 18 + 65535, /* dev descr + max-size raw descriptor */
662 int usb_create_sysfs_dev_files(struct usb_device
*udev
)
664 struct device
*dev
= &udev
->dev
;
667 retval
= device_create_bin_file(dev
, &dev_bin_attr_descriptors
);
671 retval
= add_persist_attributes(dev
);
675 retval
= add_power_attributes(dev
);
680 usb_remove_sysfs_dev_files(udev
);
684 void usb_remove_sysfs_dev_files(struct usb_device
*udev
)
686 struct device
*dev
= &udev
->dev
;
688 remove_power_attributes(dev
);
689 remove_persist_attributes(dev
);
690 device_remove_bin_file(dev
, &dev_bin_attr_descriptors
);
693 /* Interface Accociation Descriptor fields */
694 #define usb_intf_assoc_attr(field, format_string) \
696 show_iad_##field(struct device *dev, struct device_attribute *attr, \
699 struct usb_interface *intf = to_usb_interface(dev); \
701 return sprintf(buf, format_string, \
702 intf->intf_assoc->field); \
704 static DEVICE_ATTR(iad_##field, S_IRUGO, show_iad_##field, NULL);
706 usb_intf_assoc_attr(bFirstInterface
, "%02x\n")
707 usb_intf_assoc_attr(bInterfaceCount
, "%02d\n")
708 usb_intf_assoc_attr(bFunctionClass
, "%02x\n")
709 usb_intf_assoc_attr(bFunctionSubClass
, "%02x\n")
710 usb_intf_assoc_attr(bFunctionProtocol
, "%02x\n")
712 /* Interface fields */
713 #define usb_intf_attr(field, format_string) \
715 show_##field(struct device *dev, struct device_attribute *attr, \
718 struct usb_interface *intf = to_usb_interface(dev); \
720 return sprintf(buf, format_string, \
721 intf->cur_altsetting->desc.field); \
723 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
725 usb_intf_attr(bInterfaceNumber
, "%02x\n")
726 usb_intf_attr(bAlternateSetting
, "%2d\n")
727 usb_intf_attr(bNumEndpoints
, "%02x\n")
728 usb_intf_attr(bInterfaceClass
, "%02x\n")
729 usb_intf_attr(bInterfaceSubClass
, "%02x\n")
730 usb_intf_attr(bInterfaceProtocol
, "%02x\n")
732 static ssize_t
show_interface_string(struct device
*dev
,
733 struct device_attribute
*attr
, char *buf
)
735 struct usb_interface
*intf
;
738 intf
= to_usb_interface(dev
);
739 string
= intf
->cur_altsetting
->string
;
740 barrier(); /* The altsetting might change! */
744 return sprintf(buf
, "%s\n", string
);
746 static DEVICE_ATTR(interface
, S_IRUGO
, show_interface_string
, NULL
);
748 static ssize_t
show_modalias(struct device
*dev
,
749 struct device_attribute
*attr
, char *buf
)
751 struct usb_interface
*intf
;
752 struct usb_device
*udev
;
753 struct usb_host_interface
*alt
;
755 intf
= to_usb_interface(dev
);
756 udev
= interface_to_usbdev(intf
);
757 alt
= intf
->cur_altsetting
;
759 return sprintf(buf
, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
760 "ic%02Xisc%02Xip%02X\n",
761 le16_to_cpu(udev
->descriptor
.idVendor
),
762 le16_to_cpu(udev
->descriptor
.idProduct
),
763 le16_to_cpu(udev
->descriptor
.bcdDevice
),
764 udev
->descriptor
.bDeviceClass
,
765 udev
->descriptor
.bDeviceSubClass
,
766 udev
->descriptor
.bDeviceProtocol
,
767 alt
->desc
.bInterfaceClass
,
768 alt
->desc
.bInterfaceSubClass
,
769 alt
->desc
.bInterfaceProtocol
);
771 static DEVICE_ATTR(modalias
, S_IRUGO
, show_modalias
, NULL
);
773 static ssize_t
show_supports_autosuspend(struct device
*dev
,
774 struct device_attribute
*attr
, char *buf
)
776 struct usb_interface
*intf
;
777 struct usb_device
*udev
;
780 intf
= to_usb_interface(dev
);
781 udev
= interface_to_usbdev(intf
);
783 usb_lock_device(udev
);
784 /* Devices will be autosuspended even when an interface isn't claimed */
785 if (!intf
->dev
.driver
||
786 to_usb_driver(intf
->dev
.driver
)->supports_autosuspend
)
787 ret
= sprintf(buf
, "%u\n", 1);
789 ret
= sprintf(buf
, "%u\n", 0);
790 usb_unlock_device(udev
);
794 static DEVICE_ATTR(supports_autosuspend
, S_IRUGO
, show_supports_autosuspend
, NULL
);
796 static struct attribute
*intf_attrs
[] = {
797 &dev_attr_bInterfaceNumber
.attr
,
798 &dev_attr_bAlternateSetting
.attr
,
799 &dev_attr_bNumEndpoints
.attr
,
800 &dev_attr_bInterfaceClass
.attr
,
801 &dev_attr_bInterfaceSubClass
.attr
,
802 &dev_attr_bInterfaceProtocol
.attr
,
803 &dev_attr_modalias
.attr
,
804 &dev_attr_supports_autosuspend
.attr
,
807 static struct attribute_group intf_attr_grp
= {
811 static struct attribute
*intf_assoc_attrs
[] = {
812 &dev_attr_iad_bFirstInterface
.attr
,
813 &dev_attr_iad_bInterfaceCount
.attr
,
814 &dev_attr_iad_bFunctionClass
.attr
,
815 &dev_attr_iad_bFunctionSubClass
.attr
,
816 &dev_attr_iad_bFunctionProtocol
.attr
,
820 static mode_t
intf_assoc_attrs_are_visible(struct kobject
*kobj
,
821 struct attribute
*a
, int n
)
823 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
824 struct usb_interface
*intf
= to_usb_interface(dev
);
826 if (intf
->intf_assoc
== NULL
)
831 static struct attribute_group intf_assoc_attr_grp
= {
832 .attrs
= intf_assoc_attrs
,
833 .is_visible
= intf_assoc_attrs_are_visible
,
836 const struct attribute_group
*usb_interface_groups
[] = {
838 &intf_assoc_attr_grp
,
842 int usb_create_sysfs_intf_files(struct usb_interface
*intf
)
844 struct usb_device
*udev
= interface_to_usbdev(intf
);
845 struct usb_host_interface
*alt
= intf
->cur_altsetting
;
848 if (intf
->sysfs_files_created
|| intf
->unregistering
)
851 if (alt
->string
== NULL
&&
852 !(udev
->quirks
& USB_QUIRK_CONFIG_INTF_STRINGS
))
853 alt
->string
= usb_cache_string(udev
, alt
->desc
.iInterface
);
855 retval
= device_create_file(&intf
->dev
, &dev_attr_interface
);
856 intf
->sysfs_files_created
= 1;
860 void usb_remove_sysfs_intf_files(struct usb_interface
*intf
)
862 if (!intf
->sysfs_files_created
)
865 device_remove_file(&intf
->dev
, &dev_attr_interface
);
866 intf
->sysfs_files_created
= 0;