7dc123d6b2d0e2893f9ddac031da0d3fe71ede35
[linux-3.10.git] / 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",
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 }