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