2 * drivers/usb/core/endpoint.c
4 * (C) Copyright 2002,2004,2006 Greg Kroah-Hartman
5 * (C) Copyright 2002,2004 IBM Corp.
6 * (C) Copyright 2006 Novell Inc.
12 #include <linux/kernel.h>
13 #include <linux/spinlock.h>
14 #include <linux/idr.h>
15 #include <linux/usb.h>
18 #define MAX_ENDPOINT_MINORS (64*128*32)
19 static int usb_endpoint_major
;
20 static DEFINE_IDR(endpoint_idr
);
23 struct usb_endpoint_descriptor
*desc
;
24 struct usb_device
*udev
;
28 #define to_ep_device(_dev) \
29 container_of(_dev, struct ep_device, dev)
32 struct attribute attr
;
33 ssize_t (*show
)(struct usb_device
*,
34 struct usb_endpoint_descriptor
*, char *);
36 #define to_ep_attribute(_attr) \
37 container_of(_attr, struct ep_attribute, attr)
39 #define usb_ep_attr(field, format_string) \
40 static ssize_t show_ep_##field(struct device *dev, \
41 struct device_attribute *attr, \
44 struct ep_device *ep = to_ep_device(dev); \
45 return sprintf(buf, format_string, ep->desc->field); \
47 static DEVICE_ATTR(field, S_IRUGO, show_ep_##field, NULL);
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")
54 static ssize_t
show_ep_wMaxPacketSize(struct device
*dev
,
55 struct device_attribute
*attr
, char *buf
)
57 struct ep_device
*ep
= to_ep_device(dev
);
58 return sprintf(buf
, "%04x\n",
59 le16_to_cpu(ep
->desc
->wMaxPacketSize
) & 0x07ff);
61 static DEVICE_ATTR(wMaxPacketSize
, S_IRUGO
, show_ep_wMaxPacketSize
, NULL
);
63 static ssize_t
show_ep_type(struct device
*dev
, struct device_attribute
*attr
,
66 struct ep_device
*ep
= to_ep_device(dev
);
67 char *type
= "unknown";
69 switch (ep
->desc
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) {
70 case USB_ENDPOINT_XFER_CONTROL
:
73 case USB_ENDPOINT_XFER_ISOC
:
76 case USB_ENDPOINT_XFER_BULK
:
79 case USB_ENDPOINT_XFER_INT
:
83 return sprintf(buf
, "%s\n", type
);
85 static DEVICE_ATTR(type
, S_IRUGO
, show_ep_type
, NULL
);
87 static ssize_t
show_ep_interval(struct device
*dev
,
88 struct device_attribute
*attr
, char *buf
)
90 struct ep_device
*ep
= to_ep_device(dev
);
92 unsigned interval
= 0;
95 in
= (ep
->desc
->bEndpointAddress
& USB_DIR_IN
);
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
;
102 case USB_ENDPOINT_XFER_ISOC
:
103 interval
= 1 << (ep
->desc
->bInterval
- 1);
105 case USB_ENDPOINT_XFER_BULK
:
106 if (ep
->udev
->speed
== USB_SPEED_HIGH
&& !in
) /* uframes per NAK */
107 interval
= ep
->desc
->bInterval
;
109 case USB_ENDPOINT_XFER_INT
:
110 if (ep
->udev
->speed
== USB_SPEED_HIGH
)
111 interval
= 1 << (ep
->desc
->bInterval
- 1);
113 interval
= ep
->desc
->bInterval
;
116 interval
*= (ep
->udev
->speed
== USB_SPEED_HIGH
) ? 125 : 1000;
124 return sprintf(buf
, "%d%cs\n", interval
, unit
);
126 static DEVICE_ATTR(interval
, S_IRUGO
, show_ep_interval
, NULL
);
128 static ssize_t
show_ep_direction(struct device
*dev
,
129 struct device_attribute
*attr
, char *buf
)
131 struct ep_device
*ep
= to_ep_device(dev
);
134 if ((ep
->desc
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
135 USB_ENDPOINT_XFER_CONTROL
)
137 else if (ep
->desc
->bEndpointAddress
& USB_DIR_IN
)
141 return sprintf(buf
, "%s\n", direction
);
143 static DEVICE_ATTR(direction
, S_IRUGO
, show_ep_direction
, NULL
);
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
,
153 &dev_attr_direction
.attr
,
156 static struct attribute_group ep_dev_attr_grp
= {
157 .attrs
= ep_dev_attrs
,
159 static struct attribute_group
*ep_dev_groups
[] = {
164 static int usb_endpoint_major_init(void)
169 error
= alloc_chrdev_region(&dev
, 0, MAX_ENDPOINT_MINORS
,
172 printk(KERN_ERR
"Unable to get a dynamic major for "
176 usb_endpoint_major
= MAJOR(dev
);
181 static void usb_endpoint_major_cleanup(void)
183 unregister_chrdev_region(MKDEV(usb_endpoint_major
, 0),
184 MAX_ENDPOINT_MINORS
);
187 static int endpoint_get_minor(struct ep_device
*ep_dev
)
189 static DEFINE_MUTEX(minor_lock
);
190 int retval
= -ENOMEM
;
193 mutex_lock(&minor_lock
);
194 if (idr_pre_get(&endpoint_idr
, GFP_KERNEL
) == 0)
197 retval
= idr_get_new(&endpoint_idr
, ep_dev
, &id
);
199 if (retval
== -EAGAIN
)
203 ep_dev
->minor
= id
& MAX_ID_MASK
;
205 mutex_unlock(&minor_lock
);
209 static void endpoint_free_minor(struct ep_device
*ep_dev
)
211 idr_remove(&endpoint_idr
, ep_dev
->minor
);
214 static struct endpoint_class
{
219 static int init_endpoint_class(void)
223 if (ep_class
!= NULL
) {
224 kref_get(&ep_class
->kref
);
228 ep_class
= kmalloc(sizeof(*ep_class
), GFP_KERNEL
);
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
;
241 result
= usb_endpoint_major_init();
243 goto endpoint_major_error
;
247 endpoint_major_error
:
248 class_destroy(ep_class
->class);
256 static void release_endpoint_class(struct kref
*kref
)
258 /* Ok, we cheat as we know we only have one ep_class */
259 class_destroy(ep_class
->class);
262 usb_endpoint_major_cleanup();
265 static void destroy_endpoint_class(void)
268 kref_put(&ep_class
->kref
, release_endpoint_class
);
271 static void ep_device_release(struct device
*dev
)
273 struct ep_device
*ep_dev
= to_ep_device(dev
);
275 endpoint_free_minor(ep_dev
);
279 int usb_create_ep_devs(struct device
*parent
,
280 struct usb_host_endpoint
*endpoint
,
281 struct usb_device
*udev
)
284 struct ep_device
*ep_dev
;
287 retval
= init_endpoint_class();
291 ep_dev
= kzalloc(sizeof(*ep_dev
), GFP_KERNEL
);
297 retval
= endpoint_get_minor(ep_dev
);
299 dev_err(parent
, "can not allocate minor number for %s\n",
300 dev_name(&ep_dev
->dev
));
304 ep_dev
->desc
= &endpoint
->desc
;
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
);
315 retval
= device_register(&ep_dev
->dev
);
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
);
324 endpoint
->ep_dev
= ep_dev
;
328 device_unregister(&ep_dev
->dev
);
329 destroy_endpoint_class();
333 endpoint_free_minor(ep_dev
);
338 destroy_endpoint_class();
343 void usb_remove_ep_devs(struct usb_host_endpoint
*endpoint
)
345 struct ep_device
*ep_dev
= endpoint
->ep_dev
;
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();