Commit | Line | Data |
---|---|---|
84412f62 GKH |
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> | |
7e27780f SB |
13 | #include <linux/spinlock.h> |
14 | #include <linux/idr.h> | |
84412f62 GKH |
15 | #include <linux/usb.h> |
16 | #include "usb.h" | |
17 | ||
7e27780f SB |
18 | #define MAX_ENDPOINT_MINORS (64*128*32) |
19 | static int usb_endpoint_major; | |
20 | static DEFINE_IDR(endpoint_idr); | |
9bde7497 GKH |
21 | |
22 | struct ep_device { | |
84412f62 GKH |
23 | struct usb_endpoint_descriptor *desc; |
24 | struct usb_device *udev; | |
9bde7497 | 25 | struct device dev; |
7e27780f | 26 | int minor; |
84412f62 | 27 | }; |
9bde7497 GKH |
28 | #define to_ep_device(_dev) \ |
29 | container_of(_dev, struct ep_device, dev) | |
84412f62 GKH |
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 | ||
84412f62 | 39 | #define usb_ep_attr(field, format_string) \ |
9bde7497 GKH |
40 | static ssize_t show_ep_##field(struct device *dev, \ |
41 | struct device_attribute *attr, \ | |
42 | char *buf) \ | |
84412f62 | 43 | { \ |
9bde7497 GKH |
44 | struct ep_device *ep = to_ep_device(dev); \ |
45 | return sprintf(buf, format_string, ep->desc->field); \ | |
84412f62 | 46 | } \ |
9bde7497 | 47 | static DEVICE_ATTR(field, S_IRUGO, show_ep_##field, NULL); |
84412f62 GKH |
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 | ||
9bde7497 GKH |
54 | static ssize_t show_ep_wMaxPacketSize(struct device *dev, |
55 | struct device_attribute *attr, char *buf) | |
84412f62 | 56 | { |
9bde7497 | 57 | struct ep_device *ep = to_ep_device(dev); |
84412f62 | 58 | return sprintf(buf, "%04x\n", |
9bde7497 | 59 | le16_to_cpu(ep->desc->wMaxPacketSize) & 0x07ff); |
84412f62 | 60 | } |
9bde7497 | 61 | static DEVICE_ATTR(wMaxPacketSize, S_IRUGO, show_ep_wMaxPacketSize, NULL); |
84412f62 | 62 | |
9bde7497 GKH |
63 | static ssize_t show_ep_type(struct device *dev, struct device_attribute *attr, |
64 | char *buf) | |
84412f62 | 65 | { |
9bde7497 | 66 | struct ep_device *ep = to_ep_device(dev); |
84412f62 GKH |
67 | char *type = "unknown"; |
68 | ||
9bde7497 | 69 | switch (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { |
84412f62 GKH |
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 | } | |
9bde7497 | 85 | static DEVICE_ATTR(type, S_IRUGO, show_ep_type, NULL); |
84412f62 | 86 | |
9bde7497 GKH |
87 | static ssize_t show_ep_interval(struct device *dev, |
88 | struct device_attribute *attr, char *buf) | |
84412f62 | 89 | { |
9bde7497 | 90 | struct ep_device *ep = to_ep_device(dev); |
84412f62 GKH |
91 | char unit; |
92 | unsigned interval = 0; | |
93 | unsigned in; | |
94 | ||
9bde7497 | 95 | in = (ep->desc->bEndpointAddress & USB_DIR_IN); |
84412f62 | 96 | |
9bde7497 | 97 | switch (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { |
84412f62 | 98 | case USB_ENDPOINT_XFER_CONTROL: |
9bde7497 GKH |
99 | if (ep->udev->speed == USB_SPEED_HIGH) /* uframes per NAK */ |
100 | interval = ep->desc->bInterval; | |
84412f62 GKH |
101 | break; |
102 | case USB_ENDPOINT_XFER_ISOC: | |
9bde7497 | 103 | interval = 1 << (ep->desc->bInterval - 1); |
84412f62 GKH |
104 | break; |
105 | case USB_ENDPOINT_XFER_BULK: | |
9bde7497 GKH |
106 | if (ep->udev->speed == USB_SPEED_HIGH && !in) /* uframes per NAK */ |
107 | interval = ep->desc->bInterval; | |
84412f62 GKH |
108 | break; |
109 | case USB_ENDPOINT_XFER_INT: | |
9bde7497 GKH |
110 | if (ep->udev->speed == USB_SPEED_HIGH) |
111 | interval = 1 << (ep->desc->bInterval - 1); | |
84412f62 | 112 | else |
9bde7497 | 113 | interval = ep->desc->bInterval; |
84412f62 GKH |
114 | break; |
115 | } | |
9bde7497 | 116 | interval *= (ep->udev->speed == USB_SPEED_HIGH) ? 125 : 1000; |
84412f62 GKH |
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 | } | |
9bde7497 | 126 | static DEVICE_ATTR(interval, S_IRUGO, show_ep_interval, NULL); |
84412f62 | 127 | |
9bde7497 GKH |
128 | static ssize_t show_ep_direction(struct device *dev, |
129 | struct device_attribute *attr, char *buf) | |
84412f62 | 130 | { |
9bde7497 | 131 | struct ep_device *ep = to_ep_device(dev); |
84412f62 GKH |
132 | char *direction; |
133 | ||
9bde7497 | 134 | if ((ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == |
84412f62 GKH |
135 | USB_ENDPOINT_XFER_CONTROL) |
136 | direction = "both"; | |
9bde7497 | 137 | else if (ep->desc->bEndpointAddress & USB_DIR_IN) |
84412f62 GKH |
138 | direction = "in"; |
139 | else | |
140 | direction = "out"; | |
141 | return sprintf(buf, "%s\n", direction); | |
142 | } | |
9bde7497 GKH |
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, | |
84412f62 GKH |
154 | NULL, |
155 | }; | |
9bde7497 GKH |
156 | static struct attribute_group ep_dev_attr_grp = { |
157 | .attrs = ep_dev_attrs, | |
158 | }; | |
2e5f10e4 AS |
159 | static struct attribute_group *ep_dev_groups[] = { |
160 | &ep_dev_attr_grp, | |
161 | NULL | |
162 | }; | |
84412f62 | 163 | |
7e27780f SB |
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) { | |
69a85942 GKH |
172 | printk(KERN_ERR "Unable to get a dynamic major for " |
173 | "usb endpoints.\n"); | |
7e27780f SB |
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 | ||
9bde7497 GKH |
214 | static struct endpoint_class { |
215 | struct kref kref; | |
216 | struct class *class; | |
217 | } *ep_class; | |
218 | ||
219 | static int init_endpoint_class(void) | |
84412f62 | 220 | { |
9bde7497 GKH |
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)) { | |
c5999f0d | 237 | result = PTR_ERR(ep_class->class); |
7e27780f | 238 | goto class_create_error; |
9bde7497 GKH |
239 | } |
240 | ||
7e27780f SB |
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; | |
9bde7497 GKH |
252 | exit: |
253 | return result; | |
84412f62 GKH |
254 | } |
255 | ||
9bde7497 | 256 | static void release_endpoint_class(struct kref *kref) |
84412f62 | 257 | { |
9bde7497 GKH |
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; | |
7e27780f | 262 | usb_endpoint_major_cleanup(); |
9bde7497 | 263 | } |
84412f62 | 264 | |
9bde7497 GKH |
265 | static void destroy_endpoint_class(void) |
266 | { | |
267 | if (ep_class) | |
268 | kref_put(&ep_class->kref, release_endpoint_class); | |
84412f62 GKH |
269 | } |
270 | ||
9bde7497 GKH |
271 | static void ep_device_release(struct device *dev) |
272 | { | |
273 | struct ep_device *ep_dev = to_ep_device(dev); | |
84412f62 | 274 | |
c07be136 | 275 | endpoint_free_minor(ep_dev); |
9bde7497 GKH |
276 | kfree(ep_dev); |
277 | } | |
84412f62 | 278 | |
1b21d5e1 GKH |
279 | int usb_create_ep_files(struct device *parent, |
280 | struct usb_host_endpoint *endpoint, | |
281 | struct usb_device *udev) | |
84412f62 | 282 | { |
9bde7497 GKH |
283 | char name[8]; |
284 | struct ep_device *ep_dev; | |
9bde7497 GKH |
285 | int retval; |
286 | ||
287 | retval = init_endpoint_class(); | |
288 | if (retval) | |
289 | goto exit; | |
84412f62 | 290 | |
9bde7497 GKH |
291 | ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL); |
292 | if (!ep_dev) { | |
293 | retval = -ENOMEM; | |
d5477c11 | 294 | goto error_alloc; |
9bde7497 | 295 | } |
84412f62 | 296 | |
7e27780f SB |
297 | retval = endpoint_get_minor(ep_dev); |
298 | if (retval) { | |
898eb71c | 299 | dev_err(parent, "can not allocate minor number for %s\n", |
7071a3ce | 300 | dev_name(&ep_dev->dev)); |
7e27780f SB |
301 | goto error_register; |
302 | } | |
84412f62 | 303 | |
9bde7497 GKH |
304 | ep_dev->desc = &endpoint->desc; |
305 | ep_dev->udev = udev; | |
2e5f10e4 | 306 | ep_dev->dev.groups = ep_dev_groups; |
7e27780f | 307 | ep_dev->dev.devt = MKDEV(usb_endpoint_major, ep_dev->minor); |
9bde7497 GKH |
308 | ep_dev->dev.class = ep_class->class; |
309 | ep_dev->dev.parent = parent; | |
310 | ep_dev->dev.release = ep_device_release; | |
0031a06e | 311 | dev_set_name(&ep_dev->dev, "usbdev%d.%d_ep%02x", |
9bde7497 GKH |
312 | udev->bus->busnum, udev->devnum, |
313 | endpoint->desc.bEndpointAddress); | |
84412f62 | 314 | |
9bde7497 GKH |
315 | retval = device_register(&ep_dev->dev); |
316 | if (retval) | |
7e27780f | 317 | goto error_chrdev; |
9bde7497 | 318 | |
9bde7497 GKH |
319 | /* create the symlink to the old-style "ep_XX" directory */ |
320 | sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress); | |
d5477c11 | 321 | retval = sysfs_create_link(&parent->kobj, &ep_dev->dev.kobj, name); |
1b21d5e1 GKH |
322 | if (retval) |
323 | goto error_link; | |
d5477c11 | 324 | endpoint->ep_dev = ep_dev; |
1b21d5e1 GKH |
325 | return retval; |
326 | ||
327 | error_link: | |
1b21d5e1 | 328 | device_unregister(&ep_dev->dev); |
1b21d5e1 GKH |
329 | destroy_endpoint_class(); |
330 | return retval; | |
d5477c11 | 331 | |
7e27780f SB |
332 | error_chrdev: |
333 | endpoint_free_minor(ep_dev); | |
334 | ||
d5477c11 | 335 | error_register: |
9bde7497 | 336 | kfree(ep_dev); |
d5477c11 | 337 | error_alloc: |
1b21d5e1 | 338 | destroy_endpoint_class(); |
d5477c11 | 339 | exit: |
1b21d5e1 | 340 | return retval; |
84412f62 GKH |
341 | } |
342 | ||
343 | void usb_remove_ep_files(struct usb_host_endpoint *endpoint) | |
344 | { | |
7e27780f | 345 | struct ep_device *ep_dev = endpoint->ep_dev; |
84412f62 | 346 | |
7e27780f | 347 | if (ep_dev) { |
9bde7497 GKH |
348 | char name[8]; |
349 | ||
350 | sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress); | |
7e27780f | 351 | sysfs_remove_link(&ep_dev->dev.parent->kobj, name); |
7e27780f | 352 | device_unregister(&ep_dev->dev); |
9bde7497 | 353 | endpoint->ep_dev = NULL; |
c40fd5ea | 354 | destroy_endpoint_class(); |
84412f62 GKH |
355 | } |
356 | } |