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