Merge branch 'fix/pcm-jiffies-check' into fix/asoc
[linux-2.6] / 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 (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)  /* 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 (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(direction, S_IRUGO, show_ep_direction, NULL);
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 struct attribute_group *ep_dev_groups[] = {
159         &ep_dev_attr_grp,
160         NULL
161 };
162
163 static int usb_endpoint_major_init(void)
164 {
165         dev_t dev;
166         int error;
167
168         error = alloc_chrdev_region(&dev, 0, MAX_ENDPOINT_MINORS,
169                                     "usb_endpoint");
170         if (error) {
171                 printk(KERN_ERR "Unable to get a dynamic major for "
172                        "usb endpoints.\n");
173                 return error;
174         }
175         usb_endpoint_major = MAJOR(dev);
176
177         return error;
178 }
179
180 static void usb_endpoint_major_cleanup(void)
181 {
182         unregister_chrdev_region(MKDEV(usb_endpoint_major, 0),
183                                  MAX_ENDPOINT_MINORS);
184 }
185
186 static int endpoint_get_minor(struct ep_device *ep_dev)
187 {
188         static DEFINE_MUTEX(minor_lock);
189         int retval = -ENOMEM;
190         int id;
191
192         mutex_lock(&minor_lock);
193         if (idr_pre_get(&endpoint_idr, GFP_KERNEL) == 0)
194                 goto exit;
195
196         retval = idr_get_new(&endpoint_idr, ep_dev, &id);
197         if (retval < 0) {
198                 if (retval == -EAGAIN)
199                         retval = -ENOMEM;
200                 goto exit;
201         }
202         ep_dev->minor = id & MAX_ID_MASK;
203 exit:
204         mutex_unlock(&minor_lock);
205         return retval;
206 }
207
208 static void endpoint_free_minor(struct ep_device *ep_dev)
209 {
210         idr_remove(&endpoint_idr, ep_dev->minor);
211 }
212
213 static struct endpoint_class {
214         struct kref kref;
215         struct class *class;
216 } *ep_class;
217
218 static int init_endpoint_class(void)
219 {
220         int result = 0;
221
222         if (ep_class != NULL) {
223                 kref_get(&ep_class->kref);
224                 goto exit;
225         }
226
227         ep_class = kmalloc(sizeof(*ep_class), GFP_KERNEL);
228         if (!ep_class) {
229                 result = -ENOMEM;
230                 goto exit;
231         }
232
233         kref_init(&ep_class->kref);
234         ep_class->class = class_create(THIS_MODULE, "usb_endpoint");
235         if (IS_ERR(ep_class->class)) {
236                 result = PTR_ERR(ep_class->class);
237                 goto class_create_error;
238         }
239
240         result = usb_endpoint_major_init();
241         if (result)
242                 goto endpoint_major_error;
243
244         goto exit;
245
246 endpoint_major_error:
247         class_destroy(ep_class->class);
248 class_create_error:
249         kfree(ep_class);
250         ep_class = NULL;
251 exit:
252         return result;
253 }
254
255 static void release_endpoint_class(struct kref *kref)
256 {
257         /* Ok, we cheat as we know we only have one ep_class */
258         class_destroy(ep_class->class);
259         kfree(ep_class);
260         ep_class = NULL;
261         usb_endpoint_major_cleanup();
262 }
263
264 static void destroy_endpoint_class(void)
265 {
266         if (ep_class)
267                 kref_put(&ep_class->kref, release_endpoint_class);
268 }
269
270 static void ep_device_release(struct device *dev)
271 {
272         struct ep_device *ep_dev = to_ep_device(dev);
273
274         endpoint_free_minor(ep_dev);
275         kfree(ep_dev);
276 }
277
278 int usb_create_ep_devs(struct device *parent,
279                         struct usb_host_endpoint *endpoint,
280                         struct usb_device *udev)
281 {
282         char name[8];
283         struct ep_device *ep_dev;
284         int retval;
285
286         retval = init_endpoint_class();
287         if (retval)
288                 goto exit;
289
290         ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL);
291         if (!ep_dev) {
292                 retval = -ENOMEM;
293                 goto error_alloc;
294         }
295
296         retval = endpoint_get_minor(ep_dev);
297         if (retval) {
298                 dev_err(parent, "can not allocate minor number for %s\n",
299                         dev_name(&ep_dev->dev));
300                 goto error_register;
301         }
302
303         ep_dev->desc = &endpoint->desc;
304         ep_dev->udev = udev;
305         ep_dev->dev.groups = ep_dev_groups;
306         ep_dev->dev.devt = MKDEV(usb_endpoint_major, ep_dev->minor);
307         ep_dev->dev.class = ep_class->class;
308         ep_dev->dev.parent = parent;
309         ep_dev->dev.release = ep_device_release;
310         dev_set_name(&ep_dev->dev, "usbdev%d.%d_ep%02x",
311                  udev->bus->busnum, udev->devnum,
312                  endpoint->desc.bEndpointAddress);
313
314         retval = device_register(&ep_dev->dev);
315         if (retval)
316                 goto error_chrdev;
317
318         /* create the symlink to the old-style "ep_XX" directory */
319         sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress);
320         retval = sysfs_create_link(&parent->kobj, &ep_dev->dev.kobj, name);
321         if (retval)
322                 goto error_link;
323         endpoint->ep_dev = ep_dev;
324         return retval;
325
326 error_link:
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_devs(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                 device_unregister(&ep_dev->dev);
352                 endpoint->ep_dev = NULL;
353                 destroy_endpoint_class();
354         }
355 }