drivers/usb/core/endpoint.c

   1 /*
   2  * drivers/usb/core/endpoint.c
   3  *
   4  * (C) Copyright 2002,2004,2006 Greg Kroah-Hartman
   5  * (C) Copyright 2002,2004 IBM Corp.
   6  * (C) Copyright 2006 Novell Inc.
   7  *
   8  * Endpoint sysfs stuff
   9  *
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/slab.h>
  15 #include <linux/usb.h>
  16 #include "usb.h"
  17
  18 struct ep_device {
  19         struct usb_endpoint_descriptor *desc;
  20         struct usb_device *udev;
  21         struct device dev;
  22 };
  23 #define to_ep_device(_dev) \
  24         container_of(_dev, struct ep_device, dev)
  25
  26 struct ep_attribute {
  27         struct attribute attr;
  28         ssize_t (*show)(struct usb_device *,
  29                         struct usb_endpoint_descriptor *, char *);
  30 };
  31 #define to_ep_attribute(_attr) \
  32         container_of(_attr, struct ep_attribute, attr)
  33
  34 #define usb_ep_attr(field, format_string)                       \
  35 static ssize_t field##_show(struct device *dev,                 \
  36                                struct device_attribute *attr,   \
  37                                char *buf)                       \
  38 {                                                               \
  39         struct ep_device *ep = to_ep_device(dev);               \
  40         return sprintf(buf, format_string, ep->desc->field);    \
  41 }                                                               \
  42 static DEVICE_ATTR_RO(field)
  43
  44 usb_ep_attr(bLength, "%02x\n");
  45 usb_ep_attr(bEndpointAddress, "%02x\n");
  46 usb_ep_attr(bmAttributes, "%02x\n");
  47 usb_ep_attr(bInterval, "%02x\n");
  48
  49 static ssize_t wMaxPacketSize_show(struct device *dev,
  50                                    struct device_attribute *attr, char *buf)
  51 {
  52         struct ep_device *ep = to_ep_device(dev);
  53         return sprintf(buf, "%04x\n",
  54                         usb_endpoint_maxp(ep->desc) & 0x07ff);
  55 }
  56 static DEVICE_ATTR_RO(wMaxPacketSize);
  57
  58 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
  59                          char *buf)
  60 {
  61         struct ep_device *ep = to_ep_device(dev);
  62         char *type = "unknown";
  63
  64         switch (usb_endpoint_type(ep->desc)) {
  65         case USB_ENDPOINT_XFER_CONTROL:
  66                 type = "Control";
  67                 break;
  68         case USB_ENDPOINT_XFER_ISOC:
  69                 type = "Isoc";
  70                 break;
  71         case USB_ENDPOINT_XFER_BULK:
  72                 type = "Bulk";
  73                 break;
  74         case USB_ENDPOINT_XFER_INT:
  75                 type = "Interrupt";
  76                 break;
  77         }
  78         return sprintf(buf, "%s\n", type);
  79 }
  80 static DEVICE_ATTR_RO(type);
  81
  82 static ssize_t interval_show(struct device *dev, struct device_attribute *attr,
  83                              char *buf)
  84 {
  85         struct ep_device *ep = to_ep_device(dev);
  86         char unit;
  87         unsigned interval = 0;
  88         unsigned in;
  89
  90         in = (ep->desc->bEndpointAddress & USB_DIR_IN);
  91
  92         switch (usb_endpoint_type(ep->desc)) {
  93         case USB_ENDPOINT_XFER_CONTROL:
  94                 if (ep->udev->speed == USB_SPEED_HIGH)
  95                         /* uframes per NAK */
  96                         interval = ep->desc->bInterval;
  97                 break;
  98
  99         case USB_ENDPOINT_XFER_ISOC:
 100                 interval = 1 << (ep->desc->bInterval - 1);
 101                 break;
 102
 103         case USB_ENDPOINT_XFER_BULK:
 104                 if (ep->udev->speed == USB_SPEED_HIGH && !in)
 105                         /* uframes per NAK */
 106                         interval = ep->desc->bInterval;
 107                 break;
 108
 109         case USB_ENDPOINT_XFER_INT:
 110                 if (ep->udev->speed == USB_SPEED_HIGH)
 111                         interval = 1 << (ep->desc->bInterval - 1);
 112                 else
 113                         interval = ep->desc->bInterval;
 114                 break;
 115         }
 116         interval *= (ep->udev->speed == USB_SPEED_HIGH) ? 125 : 1000;
 117         if (interval % 1000)
 118                 unit = 'u';
 119         else {
 120                 unit = 'm';
 121                 interval /= 1000;
 122         }
 123
 124         return sprintf(buf, "%d%cs\n", interval, unit);
 125 }
 126 static DEVICE_ATTR_RO(interval);
 127
 128 static ssize_t direction_show(struct device *dev, struct device_attribute *attr,
 129                               char *buf)
 130 {
 131         struct ep_device *ep = to_ep_device(dev);
 132         char *direction;
 133
 134         if (usb_endpoint_xfer_control(ep->desc))
 135                 direction = "both";
 136         else if (usb_endpoint_dir_in(ep->desc))
 137                 direction = "in";
 138         else
 139                 direction = "out";
 140         return sprintf(buf, "%s\n", direction);
 141 }
 142 static DEVICE_ATTR_RO(direction);
 143
 144 static struct attribute *ep_dev_attrs[] = {
 145         &dev_attr_bLength.attr,
 146         &dev_attr_bEndpointAddress.attr,
 147         &dev_attr_bmAttributes.attr,
 148         &dev_attr_bInterval.attr,
 149         &dev_attr_wMaxPacketSize.attr,
 150         &dev_attr_interval.attr,
 151         &dev_attr_type.attr,
 152         &dev_attr_direction.attr,
 153         NULL,
 154 };
 155 static struct attribute_group ep_dev_attr_grp = {
 156         .attrs = ep_dev_attrs,
 157 };
 158 static const struct attribute_group *ep_dev_groups[] = {
 159         &ep_dev_attr_grp,
 160         NULL
 161 };
 162
 163 static void ep_device_release(struct device *dev)
 164 {
 165         struct ep_device *ep_dev = to_ep_device(dev);
 166
 167         kfree(ep_dev);
 168 }
 169
 170 struct device_type usb_ep_device_type = {
 171         .name =         "usb_endpoint",
 172         .release = ep_device_release,
 173 };
 174
 175 int usb_create_ep_devs(struct device *parent,
 176                         struct usb_host_endpoint *endpoint,
 177                         struct usb_device *udev)
 178 {
 179         struct ep_device *ep_dev;
 180         int retval;
 181
 182         ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL);
 183         if (!ep_dev) {
 184                 retval = -ENOMEM;
 185                 goto exit;
 186         }
 187
 188         ep_dev->desc = &endpoint->desc;
 189         ep_dev->udev = udev;
 190         ep_dev->dev.groups = ep_dev_groups;
 191         ep_dev->dev.type = &usb_ep_device_type;
 192         ep_dev->dev.parent = parent;
 193         dev_set_name(&ep_dev->dev, "ep_%02x", endpoint->desc.bEndpointAddress);
 194
 195         retval = device_register(&ep_dev->dev);
 196         if (retval)
 197                 goto error_register;
 198
 199         device_enable_async_suspend(&ep_dev->dev);
 200         endpoint->ep_dev = ep_dev;
 201         return retval;
 202
 203 error_register:
 204         put_device(&ep_dev->dev);
 205 exit:
 206         return retval;
 207 }
 208
 209 void usb_remove_ep_devs(struct usb_host_endpoint *endpoint)
 210 {
 211         struct ep_device *ep_dev = endpoint->ep_dev;
 212
 213         if (ep_dev) {
 214                 device_unregister(&ep_dev->dev);
 215                 endpoint->ep_dev = NULL;
 216         }
 217 }