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:
121 return sprintf(buf, "%s\n", speed);
123 static DEVICE_ATTR(speed, S_IRUGO, show_speed, NULL);
126 show_busnum(struct device *dev, struct device_attribute *attr, char *buf)
128 struct usb_device *udev;
130 udev = to_usb_device(dev);
131 return sprintf(buf, "%d\n", udev->bus->busnum);
133 static DEVICE_ATTR(busnum, S_IRUGO, show_busnum, NULL);
136 show_devnum(struct device *dev, struct device_attribute *attr, char *buf)
138 struct usb_device *udev;
140 udev = to_usb_device(dev);
141 return sprintf(buf, "%d\n", udev->devnum);
143 static DEVICE_ATTR(devnum, S_IRUGO, show_devnum, NULL);
146 show_devpath(struct device *dev, struct device_attribute *attr, char *buf)
148 struct usb_device *udev;
150 udev = to_usb_device(dev);
151 return sprintf(buf, "%s\n", udev->devpath);
153 static DEVICE_ATTR(devpath, S_IRUGO, show_devpath, NULL);
156 show_version(struct device *dev, struct device_attribute *attr, char *buf)
158 struct usb_device *udev;
161 udev = to_usb_device(dev);
162 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
163 return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
165 static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
168 show_maxchild(struct device *dev, struct device_attribute *attr, char *buf)
170 struct usb_device *udev;
172 udev = to_usb_device(dev);
173 return sprintf(buf, "%d\n", udev->maxchild);
175 static DEVICE_ATTR(maxchild, S_IRUGO, show_maxchild, NULL);
178 show_quirks(struct device *dev, struct device_attribute *attr, char *buf)
180 struct usb_device *udev;
182 udev = to_usb_device(dev);
183 return sprintf(buf, "0x%x\n", udev->quirks);
185 static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL);
188 show_urbnum(struct device *dev, struct device_attribute *attr, char *buf)
190 struct usb_device *udev;
192 udev = to_usb_device(dev);
193 return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
195 static DEVICE_ATTR(urbnum, S_IRUGO, show_urbnum, NULL);
200 static const char power_group[] = "power";
203 show_persist(struct device *dev, struct device_attribute *attr, char *buf)
205 struct usb_device *udev = to_usb_device(dev);
207 return sprintf(buf, "%d\n", udev->persist_enabled);
211 set_persist(struct device *dev, struct device_attribute *attr,
212 const char *buf, size_t count)
214 struct usb_device *udev = to_usb_device(dev);
217 /* Hubs are always enabled for USB_PERSIST */
218 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
221 if (sscanf(buf, "%d", &value) != 1)
224 udev->persist_enabled = !!value;
229 static DEVICE_ATTR(persist, S_IRUGO | S_IWUSR, show_persist, set_persist);
231 static int add_persist_attributes(struct device *dev)
235 if (is_usb_device(dev)) {
236 struct usb_device *udev = to_usb_device(dev);
238 /* Hubs are automatically enabled for USB_PERSIST,
239 * no point in creating the attribute file.
241 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
242 rc = sysfs_add_file_to_group(&dev->kobj,
243 &dev_attr_persist.attr,
249 static void remove_persist_attributes(struct device *dev)
251 sysfs_remove_file_from_group(&dev->kobj,
252 &dev_attr_persist.attr,
257 #define add_persist_attributes(dev) 0
258 #define remove_persist_attributes(dev) do {} while (0)
260 #endif /* CONFIG_PM */
262 #ifdef CONFIG_USB_SUSPEND
265 show_connected_duration(struct device *dev, struct device_attribute *attr,
268 struct usb_device *udev = to_usb_device(dev);
270 return sprintf(buf, "%u\n",
271 jiffies_to_msecs(jiffies - udev->connect_time));
274 static DEVICE_ATTR(connected_duration, S_IRUGO, show_connected_duration, NULL);
277 * If the device is resumed, the last time the device was suspended has
278 * been pre-subtracted from active_duration. We add the current time to
279 * get the duration that the device was actually active.
281 * If the device is suspended, the active_duration is up-to-date.
284 show_active_duration(struct device *dev, struct device_attribute *attr,
287 struct usb_device *udev = to_usb_device(dev);
290 if (udev->state != USB_STATE_SUSPENDED)
291 duration = jiffies_to_msecs(jiffies + udev->active_duration);
293 duration = jiffies_to_msecs(udev->active_duration);
294 return sprintf(buf, "%u\n", duration);
297 static DEVICE_ATTR(active_duration, S_IRUGO, show_active_duration, NULL);
300 show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf)
302 struct usb_device *udev = to_usb_device(dev);
304 return sprintf(buf, "%d\n", udev->autosuspend_delay / HZ);
308 set_autosuspend(struct device *dev, struct device_attribute *attr,
309 const char *buf, size_t count)
311 struct usb_device *udev = to_usb_device(dev);
314 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ ||
315 value <= - INT_MAX/HZ)
319 udev->autosuspend_delay = value;
321 usb_try_autosuspend_device(udev);
323 if (usb_autoresume_device(udev) == 0)
324 usb_autosuspend_device(udev);
329 static DEVICE_ATTR(autosuspend, S_IRUGO | S_IWUSR,
330 show_autosuspend, set_autosuspend);
332 static const char on_string[] = "on";
333 static const char auto_string[] = "auto";
336 show_level(struct device *dev, struct device_attribute *attr, char *buf)
338 struct usb_device *udev = to_usb_device(dev);
339 const char *p = auto_string;
341 if (udev->state != USB_STATE_SUSPENDED && udev->autosuspend_disabled)
343 return sprintf(buf, "%s\n", p);
347 set_level(struct device *dev, struct device_attribute *attr,
348 const char *buf, size_t count)
350 struct usb_device *udev = to_usb_device(dev);
354 int old_autosuspend_disabled;
356 cp = memchr(buf, '\n', count);
360 usb_lock_device(udev);
361 old_autosuspend_disabled = udev->autosuspend_disabled;
363 /* Setting the flags without calling usb_pm_lock is a subject to
364 * races, but who cares...
366 if (len == sizeof on_string - 1 &&
367 strncmp(buf, on_string, len) == 0) {
368 udev->autosuspend_disabled = 1;
369 rc = usb_external_resume_device(udev, PMSG_USER_RESUME);
371 } else if (len == sizeof auto_string - 1 &&
372 strncmp(buf, auto_string, len) == 0) {
373 udev->autosuspend_disabled = 0;
374 rc = usb_external_resume_device(udev, PMSG_USER_RESUME);
380 udev->autosuspend_disabled = old_autosuspend_disabled;
381 usb_unlock_device(udev);
382 return (rc < 0 ? rc : count);
385 static DEVICE_ATTR(level, S_IRUGO | S_IWUSR, show_level, set_level);
387 static int add_power_attributes(struct device *dev)
391 if (is_usb_device(dev)) {
392 rc = sysfs_add_file_to_group(&dev->kobj,
393 &dev_attr_autosuspend.attr,
396 rc = sysfs_add_file_to_group(&dev->kobj,
397 &dev_attr_level.attr,
400 rc = sysfs_add_file_to_group(&dev->kobj,
401 &dev_attr_connected_duration.attr,
404 rc = sysfs_add_file_to_group(&dev->kobj,
405 &dev_attr_active_duration.attr,
411 static void remove_power_attributes(struct device *dev)
413 sysfs_remove_file_from_group(&dev->kobj,
414 &dev_attr_active_duration.attr,
416 sysfs_remove_file_from_group(&dev->kobj,
417 &dev_attr_connected_duration.attr,
419 sysfs_remove_file_from_group(&dev->kobj,
420 &dev_attr_level.attr,
422 sysfs_remove_file_from_group(&dev->kobj,
423 &dev_attr_autosuspend.attr,
429 #define add_power_attributes(dev) 0
430 #define remove_power_attributes(dev) do {} while (0)
432 #endif /* CONFIG_USB_SUSPEND */
435 /* Descriptor fields */
436 #define usb_descriptor_attr_le16(field, format_string) \
438 show_##field(struct device *dev, struct device_attribute *attr, \
441 struct usb_device *udev; \
443 udev = to_usb_device(dev); \
444 return sprintf(buf, format_string, \
445 le16_to_cpu(udev->descriptor.field)); \
447 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
449 usb_descriptor_attr_le16(idVendor, "%04x\n")
450 usb_descriptor_attr_le16(idProduct, "%04x\n")
451 usb_descriptor_attr_le16(bcdDevice, "%04x\n")
453 #define usb_descriptor_attr(field, format_string) \
455 show_##field(struct device *dev, struct device_attribute *attr, \
458 struct usb_device *udev; \
460 udev = to_usb_device(dev); \
461 return sprintf(buf, format_string, udev->descriptor.field); \
463 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
465 usb_descriptor_attr(bDeviceClass, "%02x\n")
466 usb_descriptor_attr(bDeviceSubClass, "%02x\n")
467 usb_descriptor_attr(bDeviceProtocol, "%02x\n")
468 usb_descriptor_attr(bNumConfigurations, "%d\n")
469 usb_descriptor_attr(bMaxPacketSize0, "%d\n")
473 /* show if the device is authorized (1) or not (0) */
474 static ssize_t usb_dev_authorized_show(struct device *dev,
475 struct device_attribute *attr,
478 struct usb_device *usb_dev = to_usb_device(dev);
479 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
484 * Authorize a device to be used in the system
486 * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
488 static ssize_t usb_dev_authorized_store(struct device *dev,
489 struct device_attribute *attr,
490 const char *buf, size_t size)
493 struct usb_device *usb_dev = to_usb_device(dev);
495 result = sscanf(buf, "%u\n", &val);
499 result = usb_deauthorize_device(usb_dev);
501 result = usb_authorize_device(usb_dev);
502 return result < 0? result : size;
505 static DEVICE_ATTR(authorized, 0644,
506 usb_dev_authorized_show, usb_dev_authorized_store);
508 /* "Safely remove a device" */
509 static ssize_t usb_remove_store(struct device *dev,
510 struct device_attribute *attr,
511 const char *buf, size_t count)
513 struct usb_device *udev = to_usb_device(dev);
516 usb_lock_device(udev);
517 if (udev->state != USB_STATE_NOTATTACHED) {
519 /* To avoid races, first unconfigure and then remove */
520 usb_set_configuration(udev, -1);
521 rc = usb_remove_device(udev);
525 usb_unlock_device(udev);
528 static DEVICE_ATTR(remove, 0200, NULL, usb_remove_store);
531 static struct attribute *dev_attrs[] = {
532 /* current configuration's attributes */
533 &dev_attr_configuration.attr,
534 &dev_attr_bNumInterfaces.attr,
535 &dev_attr_bConfigurationValue.attr,
536 &dev_attr_bmAttributes.attr,
537 &dev_attr_bMaxPower.attr,
538 /* device attributes */
539 &dev_attr_urbnum.attr,
540 &dev_attr_idVendor.attr,
541 &dev_attr_idProduct.attr,
542 &dev_attr_bcdDevice.attr,
543 &dev_attr_bDeviceClass.attr,
544 &dev_attr_bDeviceSubClass.attr,
545 &dev_attr_bDeviceProtocol.attr,
546 &dev_attr_bNumConfigurations.attr,
547 &dev_attr_bMaxPacketSize0.attr,
548 &dev_attr_speed.attr,
549 &dev_attr_busnum.attr,
550 &dev_attr_devnum.attr,
551 &dev_attr_devpath.attr,
552 &dev_attr_version.attr,
553 &dev_attr_maxchild.attr,
554 &dev_attr_quirks.attr,
555 &dev_attr_authorized.attr,
556 &dev_attr_remove.attr,
559 static struct attribute_group dev_attr_grp = {
563 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
566 static struct attribute *dev_string_attrs[] = {
567 &dev_attr_manufacturer.attr,
568 &dev_attr_product.attr,
569 &dev_attr_serial.attr,
573 static mode_t dev_string_attrs_are_visible(struct kobject *kobj,
574 struct attribute *a, int n)
576 struct device *dev = container_of(kobj, struct device, kobj);
577 struct usb_device *udev = to_usb_device(dev);
579 if (a == &dev_attr_manufacturer.attr) {
580 if (udev->manufacturer == NULL)
582 } else if (a == &dev_attr_product.attr) {
583 if (udev->product == NULL)
585 } else if (a == &dev_attr_serial.attr) {
586 if (udev->serial == NULL)
592 static struct attribute_group dev_string_attr_grp = {
593 .attrs = dev_string_attrs,
594 .is_visible = dev_string_attrs_are_visible,
597 const struct attribute_group *usb_device_groups[] = {
599 &dev_string_attr_grp,
603 /* Binary descriptors */
606 read_descriptors(struct kobject *kobj, struct bin_attribute *attr,
607 char *buf, loff_t off, size_t count)
609 struct device *dev = container_of(kobj, struct device, kobj);
610 struct usb_device *udev = to_usb_device(dev);
611 size_t nleft = count;
616 /* The binary attribute begins with the device descriptor.
617 * Following that are the raw descriptor entries for all the
618 * configurations (config plus subsidiary descriptors).
620 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
621 nleft > 0; ++cfgno) {
623 src = &udev->descriptor;
624 srclen = sizeof(struct usb_device_descriptor);
626 src = udev->rawdescriptors[cfgno];
627 srclen = __le16_to_cpu(udev->config[cfgno].desc.
631 n = min(nleft, srclen - (size_t) off);
632 memcpy(buf, src + off, n);
640 return count - nleft;
643 static struct bin_attribute dev_bin_attr_descriptors = {
644 .attr = {.name = "descriptors", .mode = 0444},
645 .read = read_descriptors,
646 .size = 18 + 65535, /* dev descr + max-size raw descriptor */
649 int usb_create_sysfs_dev_files(struct usb_device *udev)
651 struct device *dev = &udev->dev;
654 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
658 retval = add_persist_attributes(dev);
662 retval = add_power_attributes(dev);
667 usb_remove_sysfs_dev_files(udev);
671 void usb_remove_sysfs_dev_files(struct usb_device *udev)
673 struct device *dev = &udev->dev;
675 remove_power_attributes(dev);
676 remove_persist_attributes(dev);
677 device_remove_bin_file(dev, &dev_bin_attr_descriptors);
680 /* Interface Accociation Descriptor fields */
681 #define usb_intf_assoc_attr(field, format_string) \
683 show_iad_##field(struct device *dev, struct device_attribute *attr, \
686 struct usb_interface *intf = to_usb_interface(dev); \
688 return sprintf(buf, format_string, \
689 intf->intf_assoc->field); \
691 static DEVICE_ATTR(iad_##field, S_IRUGO, show_iad_##field, NULL);
693 usb_intf_assoc_attr(bFirstInterface, "%02x\n")
694 usb_intf_assoc_attr(bInterfaceCount, "%02d\n")
695 usb_intf_assoc_attr(bFunctionClass, "%02x\n")
696 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n")
697 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n")
699 /* Interface fields */
700 #define usb_intf_attr(field, format_string) \
702 show_##field(struct device *dev, struct device_attribute *attr, \
705 struct usb_interface *intf = to_usb_interface(dev); \
707 return sprintf(buf, format_string, \
708 intf->cur_altsetting->desc.field); \
710 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
712 usb_intf_attr(bInterfaceNumber, "%02x\n")
713 usb_intf_attr(bAlternateSetting, "%2d\n")
714 usb_intf_attr(bNumEndpoints, "%02x\n")
715 usb_intf_attr(bInterfaceClass, "%02x\n")
716 usb_intf_attr(bInterfaceSubClass, "%02x\n")
717 usb_intf_attr(bInterfaceProtocol, "%02x\n")
719 static ssize_t show_interface_string(struct device *dev,
720 struct device_attribute *attr, char *buf)
722 struct usb_interface *intf;
725 intf = to_usb_interface(dev);
726 string = intf->cur_altsetting->string;
727 barrier(); /* The altsetting might change! */
731 return sprintf(buf, "%s\n", string);
733 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL);
735 static ssize_t show_modalias(struct device *dev,
736 struct device_attribute *attr, char *buf)
738 struct usb_interface *intf;
739 struct usb_device *udev;
740 struct usb_host_interface *alt;
742 intf = to_usb_interface(dev);
743 udev = interface_to_usbdev(intf);
744 alt = intf->cur_altsetting;
746 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
747 "ic%02Xisc%02Xip%02X\n",
748 le16_to_cpu(udev->descriptor.idVendor),
749 le16_to_cpu(udev->descriptor.idProduct),
750 le16_to_cpu(udev->descriptor.bcdDevice),
751 udev->descriptor.bDeviceClass,
752 udev->descriptor.bDeviceSubClass,
753 udev->descriptor.bDeviceProtocol,
754 alt->desc.bInterfaceClass,
755 alt->desc.bInterfaceSubClass,
756 alt->desc.bInterfaceProtocol);
758 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
760 static ssize_t show_supports_autosuspend(struct device *dev,
761 struct device_attribute *attr, char *buf)
763 struct usb_interface *intf;
764 struct usb_device *udev;
767 intf = to_usb_interface(dev);
768 udev = interface_to_usbdev(intf);
770 usb_lock_device(udev);
771 /* Devices will be autosuspended even when an interface isn't claimed */
772 if (!intf->dev.driver ||
773 to_usb_driver(intf->dev.driver)->supports_autosuspend)
774 ret = sprintf(buf, "%u\n", 1);
776 ret = sprintf(buf, "%u\n", 0);
777 usb_unlock_device(udev);
781 static DEVICE_ATTR(supports_autosuspend, S_IRUGO, show_supports_autosuspend, NULL);
783 static struct attribute *intf_attrs[] = {
784 &dev_attr_bInterfaceNumber.attr,
785 &dev_attr_bAlternateSetting.attr,
786 &dev_attr_bNumEndpoints.attr,
787 &dev_attr_bInterfaceClass.attr,
788 &dev_attr_bInterfaceSubClass.attr,
789 &dev_attr_bInterfaceProtocol.attr,
790 &dev_attr_modalias.attr,
791 &dev_attr_supports_autosuspend.attr,
794 static struct attribute_group intf_attr_grp = {
798 static struct attribute *intf_assoc_attrs[] = {
799 &dev_attr_iad_bFirstInterface.attr,
800 &dev_attr_iad_bInterfaceCount.attr,
801 &dev_attr_iad_bFunctionClass.attr,
802 &dev_attr_iad_bFunctionSubClass.attr,
803 &dev_attr_iad_bFunctionProtocol.attr,
807 static mode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
808 struct attribute *a, int n)
810 struct device *dev = container_of(kobj, struct device, kobj);
811 struct usb_interface *intf = to_usb_interface(dev);
813 if (intf->intf_assoc == NULL)
818 static struct attribute_group intf_assoc_attr_grp = {
819 .attrs = intf_assoc_attrs,
820 .is_visible = intf_assoc_attrs_are_visible,
823 const struct attribute_group *usb_interface_groups[] = {
825 &intf_assoc_attr_grp,
829 int usb_create_sysfs_intf_files(struct usb_interface *intf)
831 struct usb_device *udev = interface_to_usbdev(intf);
832 struct usb_host_interface *alt = intf->cur_altsetting;
835 if (intf->sysfs_files_created || intf->unregistering)
838 if (alt->string == NULL &&
839 !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
840 alt->string = usb_cache_string(udev, alt->desc.iInterface);
842 retval = device_create_file(&intf->dev, &dev_attr_interface);
843 intf->sysfs_files_created = 1;
847 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
849 if (!intf->sysfs_files_created)
852 device_remove_file(&intf->dev, &dev_attr_interface);
853 intf->sysfs_files_created = 0;