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/config.h>
14 #include <linux/kernel.h>
16 #ifdef CONFIG_USB_DEBUG
21 #include <linux/usb.h>
27 struct usb_endpoint_descriptor *desc;
28 struct usb_device *udev;
31 #define to_ep_object(_kobj) \
32 container_of(_kobj, struct ep_object, kobj)
35 struct attribute attr;
36 ssize_t (*show)(struct usb_device *,
37 struct usb_endpoint_descriptor *, char *);
39 #define to_ep_attribute(_attr) \
40 container_of(_attr, struct ep_attribute, attr)
42 #define EP_ATTR(_name) \
43 struct ep_attribute ep_##_name = { \
44 .attr = {.name = #_name, .owner = THIS_MODULE, \
46 .show = show_ep_##_name}
48 #define usb_ep_attr(field, format_string) \
49 static ssize_t show_ep_##field(struct usb_device *udev, \
50 struct usb_endpoint_descriptor *desc, \
53 return sprintf(buf, format_string, desc->field); \
55 static EP_ATTR(field);
57 usb_ep_attr(bLength, "%02x\n")
58 usb_ep_attr(bEndpointAddress, "%02x\n")
59 usb_ep_attr(bmAttributes, "%02x\n")
60 usb_ep_attr(bInterval, "%02x\n")
62 static ssize_t show_ep_wMaxPacketSize(struct usb_device *udev,
63 struct usb_endpoint_descriptor *desc, char *buf)
65 return sprintf(buf, "%04x\n",
66 le16_to_cpu(desc->wMaxPacketSize) & 0x07ff);
68 static EP_ATTR(wMaxPacketSize);
70 static ssize_t show_ep_type(struct usb_device *udev,
71 struct usb_endpoint_descriptor *desc, char *buf)
73 char *type = "unknown";
75 switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
76 case USB_ENDPOINT_XFER_CONTROL:
79 case USB_ENDPOINT_XFER_ISOC:
82 case USB_ENDPOINT_XFER_BULK:
85 case USB_ENDPOINT_XFER_INT:
89 return sprintf(buf, "%s\n", type);
93 static ssize_t show_ep_interval(struct usb_device *udev,
94 struct usb_endpoint_descriptor *desc, char *buf)
97 unsigned interval = 0;
100 in = (desc->bEndpointAddress & USB_DIR_IN);
102 switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
103 case USB_ENDPOINT_XFER_CONTROL:
104 if (udev->speed == USB_SPEED_HIGH) /* uframes per NAK */
105 interval = desc->bInterval;
107 case USB_ENDPOINT_XFER_ISOC:
108 interval = 1 << (desc->bInterval - 1);
110 case USB_ENDPOINT_XFER_BULK:
111 if (udev->speed == USB_SPEED_HIGH && !in) /* uframes per NAK */
112 interval = desc->bInterval;
114 case USB_ENDPOINT_XFER_INT:
115 if (udev->speed == USB_SPEED_HIGH)
116 interval = 1 << (desc->bInterval - 1);
118 interval = desc->bInterval;
121 interval *= (udev->speed == USB_SPEED_HIGH) ? 125 : 1000;
129 return sprintf(buf, "%d%cs\n", interval, unit);
131 static EP_ATTR(interval);
133 static ssize_t show_ep_direction(struct usb_device *udev,
134 struct usb_endpoint_descriptor *desc, char *buf)
138 if ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
139 USB_ENDPOINT_XFER_CONTROL)
141 else if (desc->bEndpointAddress & USB_DIR_IN)
145 return sprintf(buf, "%s\n", direction);
147 static EP_ATTR(direction);
149 static struct attribute *ep_attrs[] = {
151 &ep_bEndpointAddress.attr,
152 &ep_bmAttributes.attr,
154 &ep_wMaxPacketSize.attr,
161 static void ep_object_release(struct kobject *kobj)
163 kfree(to_ep_object(kobj));
166 static ssize_t ep_object_show(struct kobject *kobj, struct attribute *attr,
169 struct ep_object *ep_obj = to_ep_object(kobj);
170 struct ep_attribute *ep_attr = to_ep_attribute(attr);
172 return (ep_attr->show)(ep_obj->udev, ep_obj->desc, buf);
175 static struct sysfs_ops ep_object_sysfs_ops = {
176 .show = ep_object_show,
179 static struct kobj_type ep_object_ktype = {
180 .release = ep_object_release,
181 .sysfs_ops = &ep_object_sysfs_ops,
182 .default_attrs = ep_attrs,
185 static void usb_create_ep_files(struct kobject *parent,
186 struct usb_host_endpoint *endpoint,
187 struct usb_device *udev)
189 struct ep_object *ep_obj;
190 struct kobject *kobj;
192 ep_obj = kzalloc(sizeof(struct ep_object), GFP_KERNEL);
196 ep_obj->desc = &endpoint->desc;
199 kobj = &ep_obj->kobj;
200 kobject_set_name(kobj, "ep_%02x", endpoint->desc.bEndpointAddress);
201 kobj->parent = parent;
202 kobj->ktype = &ep_object_ktype;
204 /* Don't use kobject_register, because it generates a hotplug event */
206 if (kobject_add(kobj) == 0)
207 endpoint->kobj = kobj;
212 static void usb_remove_ep_files(struct usb_host_endpoint *endpoint)
215 if (endpoint->kobj) {
216 kobject_del(endpoint->kobj);
217 kobject_put(endpoint->kobj);
218 endpoint->kobj = NULL;
222 /* Active configuration fields */
223 #define usb_actconfig_show(field, multiplier, format_string) \
224 static ssize_t show_##field (struct device *dev, \
225 struct device_attribute *attr, char *buf) \
227 struct usb_device *udev; \
228 struct usb_host_config *actconfig; \
230 udev = to_usb_device (dev); \
231 actconfig = udev->actconfig; \
233 return sprintf (buf, format_string, \
234 actconfig->desc.field * multiplier); \
239 #define usb_actconfig_attr(field, multiplier, format_string) \
240 usb_actconfig_show(field, multiplier, format_string) \
241 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
243 usb_actconfig_attr (bNumInterfaces, 1, "%2d\n")
244 usb_actconfig_attr (bmAttributes, 1, "%2x\n")
245 usb_actconfig_attr (bMaxPower, 2, "%3dmA\n")
247 static ssize_t show_configuration_string(struct device *dev,
248 struct device_attribute *attr, char *buf)
250 struct usb_device *udev;
251 struct usb_host_config *actconfig;
253 udev = to_usb_device (dev);
254 actconfig = udev->actconfig;
255 if ((!actconfig) || (!actconfig->string))
257 return sprintf(buf, "%s\n", actconfig->string);
259 static DEVICE_ATTR(configuration, S_IRUGO, show_configuration_string, NULL);
261 /* configuration value is always present, and r/w */
262 usb_actconfig_show(bConfigurationValue, 1, "%u\n");
265 set_bConfigurationValue (struct device *dev, struct device_attribute *attr,
266 const char *buf, size_t count)
268 struct usb_device *udev = udev = to_usb_device (dev);
271 if (sscanf (buf, "%u", &config) != 1 || config > 255)
273 usb_lock_device(udev);
274 value = usb_set_configuration (udev, config);
275 usb_unlock_device(udev);
276 return (value < 0) ? value : count;
279 static DEVICE_ATTR(bConfigurationValue, S_IRUGO | S_IWUSR,
280 show_bConfigurationValue, set_bConfigurationValue);
283 #define usb_string_attr(name) \
284 static ssize_t show_##name(struct device *dev, \
285 struct device_attribute *attr, char *buf) \
287 struct usb_device *udev; \
289 udev = to_usb_device (dev); \
290 return sprintf(buf, "%s\n", udev->name); \
292 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
294 usb_string_attr(product);
295 usb_string_attr(manufacturer);
296 usb_string_attr(serial);
299 show_speed (struct device *dev, struct device_attribute *attr, char *buf)
301 struct usb_device *udev;
304 udev = to_usb_device (dev);
306 switch (udev->speed) {
310 case USB_SPEED_UNKNOWN:
320 return sprintf (buf, "%s\n", speed);
322 static DEVICE_ATTR(speed, S_IRUGO, show_speed, NULL);
325 show_devnum (struct device *dev, struct device_attribute *attr, char *buf)
327 struct usb_device *udev;
329 udev = to_usb_device (dev);
330 return sprintf (buf, "%d\n", udev->devnum);
332 static DEVICE_ATTR(devnum, S_IRUGO, show_devnum, NULL);
335 show_version (struct device *dev, struct device_attribute *attr, char *buf)
337 struct usb_device *udev;
340 udev = to_usb_device(dev);
341 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
342 return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
344 static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
347 show_maxchild (struct device *dev, struct device_attribute *attr, char *buf)
349 struct usb_device *udev;
351 udev = to_usb_device (dev);
352 return sprintf (buf, "%d\n", udev->maxchild);
354 static DEVICE_ATTR(maxchild, S_IRUGO, show_maxchild, NULL);
356 /* Descriptor fields */
357 #define usb_descriptor_attr_le16(field, format_string) \
359 show_##field (struct device *dev, struct device_attribute *attr, \
362 struct usb_device *udev; \
364 udev = to_usb_device (dev); \
365 return sprintf (buf, format_string, \
366 le16_to_cpu(udev->descriptor.field)); \
368 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
370 usb_descriptor_attr_le16(idVendor, "%04x\n")
371 usb_descriptor_attr_le16(idProduct, "%04x\n")
372 usb_descriptor_attr_le16(bcdDevice, "%04x\n")
374 #define usb_descriptor_attr(field, format_string) \
376 show_##field (struct device *dev, struct device_attribute *attr, \
379 struct usb_device *udev; \
381 udev = to_usb_device (dev); \
382 return sprintf (buf, format_string, udev->descriptor.field); \
384 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
386 usb_descriptor_attr (bDeviceClass, "%02x\n")
387 usb_descriptor_attr (bDeviceSubClass, "%02x\n")
388 usb_descriptor_attr (bDeviceProtocol, "%02x\n")
389 usb_descriptor_attr (bNumConfigurations, "%d\n")
390 usb_descriptor_attr (bMaxPacketSize0, "%d\n")
392 static struct attribute *dev_attrs[] = {
393 /* current configuration's attributes */
394 &dev_attr_bNumInterfaces.attr,
395 &dev_attr_bConfigurationValue.attr,
396 &dev_attr_bmAttributes.attr,
397 &dev_attr_bMaxPower.attr,
398 /* device attributes */
399 &dev_attr_idVendor.attr,
400 &dev_attr_idProduct.attr,
401 &dev_attr_bcdDevice.attr,
402 &dev_attr_bDeviceClass.attr,
403 &dev_attr_bDeviceSubClass.attr,
404 &dev_attr_bDeviceProtocol.attr,
405 &dev_attr_bNumConfigurations.attr,
406 &dev_attr_bMaxPacketSize0.attr,
407 &dev_attr_speed.attr,
408 &dev_attr_devnum.attr,
409 &dev_attr_version.attr,
410 &dev_attr_maxchild.attr,
413 static struct attribute_group dev_attr_grp = {
417 void usb_create_sysfs_dev_files (struct usb_device *udev)
419 struct device *dev = &udev->dev;
421 sysfs_create_group(&dev->kobj, &dev_attr_grp);
423 if (udev->manufacturer)
424 device_create_file (dev, &dev_attr_manufacturer);
426 device_create_file (dev, &dev_attr_product);
428 device_create_file (dev, &dev_attr_serial);
429 device_create_file (dev, &dev_attr_configuration);
430 usb_create_ep_files(&dev->kobj, &udev->ep0, udev);
433 void usb_remove_sysfs_dev_files (struct usb_device *udev)
435 struct device *dev = &udev->dev;
437 usb_remove_ep_files(&udev->ep0);
438 sysfs_remove_group(&dev->kobj, &dev_attr_grp);
440 if (udev->manufacturer)
441 device_remove_file(dev, &dev_attr_manufacturer);
443 device_remove_file(dev, &dev_attr_product);
445 device_remove_file(dev, &dev_attr_serial);
446 device_remove_file (dev, &dev_attr_configuration);
449 /* Interface fields */
450 #define usb_intf_attr(field, format_string) \
452 show_##field (struct device *dev, struct device_attribute *attr, \
455 struct usb_interface *intf = to_usb_interface (dev); \
457 return sprintf (buf, format_string, \
458 intf->cur_altsetting->desc.field); \
460 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
462 usb_intf_attr (bInterfaceNumber, "%02x\n")
463 usb_intf_attr (bAlternateSetting, "%2d\n")
464 usb_intf_attr (bNumEndpoints, "%02x\n")
465 usb_intf_attr (bInterfaceClass, "%02x\n")
466 usb_intf_attr (bInterfaceSubClass, "%02x\n")
467 usb_intf_attr (bInterfaceProtocol, "%02x\n")
469 static ssize_t show_interface_string(struct device *dev,
470 struct device_attribute *attr, char *buf)
472 struct usb_interface *intf;
473 struct usb_device *udev;
476 intf = to_usb_interface (dev);
477 udev = interface_to_usbdev (intf);
478 len = snprintf(buf, 256, "%s", intf->cur_altsetting->string);
485 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL);
487 static ssize_t show_modalias(struct device *dev,
488 struct device_attribute *attr, char *buf)
490 struct usb_interface *intf;
491 struct usb_device *udev;
492 struct usb_host_interface *alt;
494 intf = to_usb_interface(dev);
495 udev = interface_to_usbdev(intf);
496 alt = intf->cur_altsetting;
498 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
499 "ic%02Xisc%02Xip%02X\n",
500 le16_to_cpu(udev->descriptor.idVendor),
501 le16_to_cpu(udev->descriptor.idProduct),
502 le16_to_cpu(udev->descriptor.bcdDevice),
503 udev->descriptor.bDeviceClass,
504 udev->descriptor.bDeviceSubClass,
505 udev->descriptor.bDeviceProtocol,
506 alt->desc.bInterfaceClass,
507 alt->desc.bInterfaceSubClass,
508 alt->desc.bInterfaceProtocol);
510 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
512 static struct attribute *intf_attrs[] = {
513 &dev_attr_bInterfaceNumber.attr,
514 &dev_attr_bAlternateSetting.attr,
515 &dev_attr_bNumEndpoints.attr,
516 &dev_attr_bInterfaceClass.attr,
517 &dev_attr_bInterfaceSubClass.attr,
518 &dev_attr_bInterfaceProtocol.attr,
519 &dev_attr_modalias.attr,
522 static struct attribute_group intf_attr_grp = {
526 static inline void usb_create_intf_ep_files(struct usb_interface *intf,
527 struct usb_device *udev)
529 struct usb_host_interface *iface_desc;
532 iface_desc = intf->cur_altsetting;
533 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
534 usb_create_ep_files(&intf->dev.kobj, &iface_desc->endpoint[i],
538 static inline void usb_remove_intf_ep_files(struct usb_interface *intf)
540 struct usb_host_interface *iface_desc;
543 iface_desc = intf->cur_altsetting;
544 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
545 usb_remove_ep_files(&iface_desc->endpoint[i]);
548 void usb_create_sysfs_intf_files (struct usb_interface *intf)
550 struct usb_device *udev = interface_to_usbdev(intf);
551 struct usb_host_interface *alt = intf->cur_altsetting;
553 sysfs_create_group(&intf->dev.kobj, &intf_attr_grp);
555 if (alt->string == NULL)
556 alt->string = usb_cache_string(udev, alt->desc.iInterface);
558 device_create_file(&intf->dev, &dev_attr_interface);
559 usb_create_intf_ep_files(intf, udev);
562 void usb_remove_sysfs_intf_files (struct usb_interface *intf)
564 usb_remove_intf_ep_files(intf);
565 sysfs_remove_group(&intf->dev.kobj, &intf_attr_grp);
567 if (intf->cur_altsetting->string)
568 device_remove_file(&intf->dev, &dev_attr_interface);