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 #define MAX_ENDPOINT_MINORS (64*128*32)
  19 static int usb_endpoint_major;
  20 static DEFINE_IDR(endpoint_idr);
  21
  22 struct ep_device {
  23         struct usb_endpoint_descriptor *desc;
  24         struct usb_device *udev;
  25         struct device dev;
  26         int minor;
  27 };
  28 #define to_ep_device(_dev) \
  29         container_of(_dev, struct ep_device, dev)
  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                         le16_to_cpu(ep->desc->wMaxPacketSize) & 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 (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
  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 (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
  98         case USB_ENDPOINT_XFER_CONTROL:
  99                 if (ep->udev->speed == USB_SPEED_HIGH)  /* uframes per NAK */
 100                         interval = ep->desc->bInterval;
 101                 break;
 102         case USB_ENDPOINT_XFER_ISOC:
 103                 interval = 1 << (ep->desc->bInterval - 1);
 104                 break;
 105         case USB_ENDPOINT_XFER_BULK:
 106                 if (ep->udev->speed == USB_SPEED_HIGH && !in) /* uframes per NAK */
 107                         interval = ep->desc->bInterval;
 108                 break;
 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(interval, S_IRUGO, show_ep_interval, NULL);
 127
 128 static ssize_t show_ep_direction(struct device *dev,
 129                                  struct device_attribute *attr, char *buf)
 130 {
 131         struct ep_device *ep = to_ep_device(dev);
 132         char *direction;
 133
 134         if ((ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 135                         USB_ENDPOINT_XFER_CONTROL)
 136                 direction = "both";
 137         else if (ep->desc->bEndpointAddress & USB_DIR_IN)
 138                 direction = "in";
 139         else
 140                 direction = "out";
 141         return sprintf(buf, "%s\n", direction);
 142 }
 143 static DEVICE_ATTR(direction, S_IRUGO, show_ep_direction, NULL);
 144
 145 static struct attribute *ep_dev_attrs[] = {
 146         &dev_attr_bLength.attr,
 147         &dev_attr_bEndpointAddress.attr,
 148         &dev_attr_bmAttributes.attr,
 149         &dev_attr_bInterval.attr,
 150         &dev_attr_wMaxPacketSize.attr,
 151         &dev_attr_interval.attr,
 152         &dev_attr_type.attr,
 153         &dev_attr_direction.attr,
 154         NULL,
 155 };
 156 static struct attribute_group ep_dev_attr_grp = {
 157         .attrs = ep_dev_attrs,
 158 };
 159
 160 static int usb_endpoint_major_init(void)
 161 {
 162         dev_t dev;
 163         int error;
 164
 165         error = alloc_chrdev_region(&dev, 0, MAX_ENDPOINT_MINORS,
 166                                     "usb_endpoint");
 167         if (error) {
 168                 err("unable to get a dynamic major for usb endpoints");
 169                 return error;
 170         }
 171         usb_endpoint_major = MAJOR(dev);
 172
 173         return error;
 174 }
 175
 176 static void usb_endpoint_major_cleanup(void)
 177 {
 178         unregister_chrdev_region(MKDEV(usb_endpoint_major, 0),
 179                                  MAX_ENDPOINT_MINORS);
 180 }
 181
 182 static int endpoint_get_minor(struct ep_device *ep_dev)
 183 {
 184         static DEFINE_MUTEX(minor_lock);
 185         int retval = -ENOMEM;
 186         int id;
 187
 188         mutex_lock(&minor_lock);
 189         if (idr_pre_get(&endpoint_idr, GFP_KERNEL) == 0)
 190                 goto exit;
 191
 192         retval = idr_get_new(&endpoint_idr, ep_dev, &id);
 193         if (retval < 0) {
 194                 if (retval == -EAGAIN)
 195                         retval = -ENOMEM;
 196                 goto exit;
 197         }
 198         ep_dev->minor = id & MAX_ID_MASK;
 199 exit:
 200         mutex_unlock(&minor_lock);
 201         return retval;
 202 }
 203
 204 static void endpoint_free_minor(struct ep_device *ep_dev)
 205 {
 206         idr_remove(&endpoint_idr, ep_dev->minor);
 207 }
 208
 209 static struct endpoint_class {
 210         struct kref kref;
 211         struct class *class;
 212 } *ep_class;
 213
 214 static int init_endpoint_class(void)
 215 {
 216         int result = 0;
 217
 218         if (ep_class != NULL) {
 219                 kref_get(&ep_class->kref);
 220                 goto exit;
 221         }
 222
 223         ep_class = kmalloc(sizeof(*ep_class), GFP_KERNEL);
 224         if (!ep_class) {
 225                 result = -ENOMEM;
 226                 goto exit;
 227         }
 228
 229         kref_init(&ep_class->kref);
 230         ep_class->class = class_create(THIS_MODULE, "usb_endpoint");
 231         if (IS_ERR(ep_class->class)) {
 232                 result = PTR_ERR(ep_class->class);
 233                 goto class_create_error;
 234         }
 235
 236         result = usb_endpoint_major_init();
 237         if (result)
 238                 goto endpoint_major_error;
 239
 240         goto exit;
 241
 242 endpoint_major_error:
 243         class_destroy(ep_class->class);
 244 class_create_error:
 245         kfree(ep_class);
 246         ep_class = NULL;
 247 exit:
 248         return result;
 249 }
 250
 251 static void release_endpoint_class(struct kref *kref)
 252 {
 253         /* Ok, we cheat as we know we only have one ep_class */
 254         class_destroy(ep_class->class);
 255         kfree(ep_class);
 256         ep_class = NULL;
 257         usb_endpoint_major_cleanup();
 258 }
 259
 260 static void destroy_endpoint_class(void)
 261 {
 262         if (ep_class)
 263                 kref_put(&ep_class->kref, release_endpoint_class);
 264 }
 265
 266 static void ep_device_release(struct device *dev)
 267 {
 268         struct ep_device *ep_dev = to_ep_device(dev);
 269
 270         endpoint_free_minor(ep_dev);
 271         kfree(ep_dev);
 272 }
 273
 274 int usb_create_ep_files(struct device *parent,
 275                         struct usb_host_endpoint *endpoint,
 276                         struct usb_device *udev)
 277 {
 278         char name[8];
 279         struct ep_device *ep_dev;
 280         int retval;
 281
 282         retval = init_endpoint_class();
 283         if (retval)
 284                 goto exit;
 285
 286         ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL);
 287         if (!ep_dev) {
 288                 retval = -ENOMEM;
 289                 goto error_alloc;
 290         }
 291
 292         retval = endpoint_get_minor(ep_dev);
 293         if (retval) {
 294                 dev_err(parent, "can not allocate minor number for %s\n",
 295                         ep_dev->dev.bus_id);
 296                 goto error_register;
 297         }
 298
 299         ep_dev->desc = &endpoint->desc;
 300         ep_dev->udev = udev;
 301         ep_dev->dev.devt = MKDEV(usb_endpoint_major, ep_dev->minor);
 302         ep_dev->dev.class = ep_class->class;
 303         ep_dev->dev.parent = parent;
 304         ep_dev->dev.release = ep_device_release;
 305         snprintf(ep_dev->dev.bus_id, BUS_ID_SIZE, "usbdev%d.%d_ep%02x",
 306                  udev->bus->busnum, udev->devnum,
 307                  endpoint->desc.bEndpointAddress);
 308
 309         retval = device_register(&ep_dev->dev);
 310         if (retval)
 311                 goto error_chrdev;
 312         retval = sysfs_create_group(&ep_dev->dev.kobj, &ep_dev_attr_grp);
 313         if (retval)
 314                 goto error_group;
 315
 316         /* create the symlink to the old-style "ep_XX" directory */
 317         sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress);
 318         retval = sysfs_create_link(&parent->kobj, &ep_dev->dev.kobj, name);
 319         if (retval)
 320                 goto error_link;
 321         endpoint->ep_dev = ep_dev;
 322         return retval;
 323
 324 error_link:
 325         sysfs_remove_group(&ep_dev->dev.kobj, &ep_dev_attr_grp);
 326 error_group:
 327         device_unregister(&ep_dev->dev);
 328         destroy_endpoint_class();
 329         return retval;
 330
 331 error_chrdev:
 332         endpoint_free_minor(ep_dev);
 333
 334 error_register:
 335         kfree(ep_dev);
 336 error_alloc:
 337         destroy_endpoint_class();
 338 exit:
 339         return retval;
 340 }
 341
 342 void usb_remove_ep_files(struct usb_host_endpoint *endpoint)
 343 {
 344         struct ep_device *ep_dev = endpoint->ep_dev;
 345
 346         if (ep_dev) {
 347                 char name[8];
 348
 349                 sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress);
 350                 sysfs_remove_link(&ep_dev->dev.parent->kobj, name);
 351                 sysfs_remove_group(&ep_dev->dev.kobj, &ep_dev_attr_grp);
 352                 device_unregister(&ep_dev->dev);
 353                 endpoint->ep_dev = NULL;
 354                 destroy_endpoint_class();
 355         }
 356 }