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/idr.h>
  16 #include <linux/usb.h>
  17 #include "usb.h"
  18
  19 struct ep_device {
  20         struct usb_endpoint_descriptor *desc;
  21         struct usb_device *udev;
  22         struct device dev;
  23 };
  24 #define to_ep_device(_dev) \
  25         container_of(_dev, struct ep_device, dev)
  26
  27 struct device_type usb_ep_device_type = {
  28         .name =         "usb_endpoint",
  29 };
  30
  31 struct ep_attribute {
  32         struct attribute attr;
  33         ssize_t (*show)(struct usb_device *,
  34                         struct usb_endpoint_descriptor *, char *);
  35 };
  36 #define to_ep_attribute(_attr) \
  37         container_of(_attr, struct ep_attribute, attr)
  38
  39 #define usb_ep_attr(field, format_string)                       \
  40 static ssize_t show_ep_##field(struct device *dev,              \
  41                                struct device_attribute *attr,   \
  42                                char *buf)                       \
  43 {                                                               \
  44         struct ep_device *ep = to_ep_device(dev);               \
  45         return sprintf(buf, format_string, ep->desc->field);    \
  46 }                                                               \
  47 static DEVICE_ATTR(field, S_IRUGO, show_ep_##field, NULL);
  48
  49 usb_ep_attr(bLength, "%02x\n")
  50 usb_ep_attr(bEndpointAddress, "%02x\n")
  51 usb_ep_attr(bmAttributes, "%02x\n")
  52 usb_ep_attr(bInterval, "%02x\n")
  53
  54 static ssize_t show_ep_wMaxPacketSize(struct device *dev,
  55                                       struct device_attribute *attr, char *buf)
  56 {
  57         struct ep_device *ep = to_ep_device(dev);
  58         return sprintf(buf, "%04x\n",
  59                         usb_endpoint_maxp(ep->desc) & 0x07ff);
  60 }
  61 static DEVICE_ATTR(wMaxPacketSize, S_IRUGO, show_ep_wMaxPacketSize, NULL);
  62
  63 static ssize_t show_ep_type(struct device *dev, struct device_attribute *attr,
  64                             char *buf)
  65 {
  66         struct ep_device *ep = to_ep_device(dev);
  67         char *type = "unknown";
  68
  69         switch (usb_endpoint_type(ep->desc)) {
  70         case USB_ENDPOINT_XFER_CONTROL:
  71                 type = "Control";
  72                 break;
  73         case USB_ENDPOINT_XFER_ISOC:
  74                 type = "Isoc";
  75                 break;
  76         case USB_ENDPOINT_XFER_BULK:
  77                 type = "Bulk";
  78                 break;
  79         case USB_ENDPOINT_XFER_INT:
  80                 type = "Interrupt";
  81                 break;
  82         }
  83         return sprintf(buf, "%s\n", type);
  84 }
  85 static DEVICE_ATTR(type, S_IRUGO, show_ep_type, NULL);
  86
  87 static ssize_t show_ep_interval(struct device *dev,
  88                                 struct device_attribute *attr, char *buf)
  89 {
  90         struct ep_device *ep = to_ep_device(dev);
  91         char unit;
  92         unsigned interval = 0;
  93         unsigned in;
  94
  95         in = (ep->desc->bEndpointAddress & USB_DIR_IN);
  96
  97         switch (usb_endpoint_type(ep->desc)) {
  98         case USB_ENDPOINT_XFER_CONTROL:
  99                 if (ep->udev->speed == USB_SPEED_HIGH)
 100                         /* uframes per NAK */
 101                         interval = ep->desc->bInterval;
 102                 break;
 103
 104         case USB_ENDPOINT_XFER_ISOC:
 105                 interval = 1 << (ep->desc->bInterval - 1);
 106                 break;
 107
 108         case USB_ENDPOINT_XFER_BULK:
 109                 if (ep->udev->speed == USB_SPEED_HIGH && !in)
 110                         /* uframes per NAK */
 111                         interval = ep->desc->bInterval;
 112                 break;
 113
 114         case USB_ENDPOINT_XFER_INT:
 115                 if (ep->udev->speed == USB_SPEED_HIGH)
 116                         interval = 1 << (ep->desc->bInterval - 1);
 117                 else
 118                         interval = ep->desc->bInterval;
 119                 break;
 120         }
 121         interval *= (ep->udev->speed == USB_SPEED_HIGH) ? 125 : 1000;
 122         if (interval % 1000)
 123                 unit = 'u';
 124         else {
 125                 unit = 'm';
 126                 interval /= 1000;
 127         }
 128
 129         return sprintf(buf, "%d%cs\n", interval, unit);
 130 }
 131 static DEVICE_ATTR(interval, S_IRUGO, show_ep_interval, NULL);
 132
 133 static ssize_t show_ep_direction(struct device *dev,
 134                                  struct device_attribute *attr, char *buf)
 135 {
 136         struct ep_device *ep = to_ep_device(dev);
 137         char *direction;
 138
 139         if (usb_endpoint_xfer_control(ep->desc))
 140                 direction = "both";
 141         else if (usb_endpoint_dir_in(ep->desc))
 142                 direction = "in";
 143         else
 144                 direction = "out";
 145         return sprintf(buf, "%s\n", direction);
 146 }
 147 static DEVICE_ATTR(direction, S_IRUGO, show_ep_direction, NULL);
 148
 149 static struct attribute *ep_dev_attrs[] = {
 150         &dev_attr_bLength.attr,
 151         &dev_attr_bEndpointAddress.attr,
 152         &dev_attr_bmAttributes.attr,
 153         &dev_attr_bInterval.attr,
 154         &dev_attr_wMaxPacketSize.attr,
 155         &dev_attr_interval.attr,
 156         &dev_attr_type.attr,
 157         &dev_attr_direction.attr,
 158         NULL,
 159 };
 160 static struct attribute_group ep_dev_attr_grp = {
 161         .attrs = ep_dev_attrs,
 162 };
 163 static const struct attribute_group *ep_dev_groups[] = {
 164         &ep_dev_attr_grp,
 165         NULL
 166 };
 167
 168 static void ep_device_release(struct device *dev)
 169 {
 170         struct ep_device *ep_dev = to_ep_device(dev);
 171
 172         kfree(ep_dev);
 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         ep_dev->dev.release = ep_device_release;
 194         dev_set_name(&ep_dev->dev, "ep_%02x", endpoint->desc.bEndpointAddress);
 195
 196         retval = device_register(&ep_dev->dev);
 197         if (retval)
 198                 goto error_register;
 199
 200         device_enable_async_suspend(&ep_dev->dev);
 201         endpoint->ep_dev = ep_dev;
 202         return retval;
 203
 204 error_register:
 205         put_device(&ep_dev->dev);
 206 exit:
 207         return retval;
 208 }
 209
 210 void usb_remove_ep_devs(struct usb_host_endpoint *endpoint)
 211 {
 212         struct ep_device *ep_dev = endpoint->ep_dev;
 213
 214         if (ep_dev) {
 215                 device_unregister(&ep_dev->dev);
 216                 endpoint->ep_dev = NULL;
 217         }
 218 }