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> | |
13 | #include <linux/usb.h> | |
14 | #include "usb.h" | |
15 | ||
16 | /* endpoint stuff */ | |
9bde7497 GKH |
17 | |
18 | struct ep_device { | |
84412f62 GKH |
19 | struct usb_endpoint_descriptor *desc; |
20 | struct usb_device *udev; | |
9bde7497 | 21 | struct device dev; |
84412f62 | 22 | }; |
9bde7497 GKH |
23 | #define to_ep_device(_dev) \ |
24 | container_of(_dev, struct ep_device, dev) | |
84412f62 GKH |
25 | |
26 | struct ep_attribute { | |
27 | struct attribute attr; | |
28 | ssize_t (*show)(struct usb_device *, | |
29 | struct usb_endpoint_descriptor *, char *); | |
30 | }; | |
31 | #define to_ep_attribute(_attr) \ | |
32 | container_of(_attr, struct ep_attribute, attr) | |
33 | ||
84412f62 | 34 | #define usb_ep_attr(field, format_string) \ |
9bde7497 GKH |
35 | static ssize_t show_ep_##field(struct device *dev, \ |
36 | struct device_attribute *attr, \ | |
37 | char *buf) \ | |
84412f62 | 38 | { \ |
9bde7497 GKH |
39 | struct ep_device *ep = to_ep_device(dev); \ |
40 | return sprintf(buf, format_string, ep->desc->field); \ | |
84412f62 | 41 | } \ |
9bde7497 | 42 | static DEVICE_ATTR(field, S_IRUGO, show_ep_##field, NULL); |
84412f62 GKH |
43 | |
44 | usb_ep_attr(bLength, "%02x\n") | |
45 | usb_ep_attr(bEndpointAddress, "%02x\n") | |
46 | usb_ep_attr(bmAttributes, "%02x\n") | |
47 | usb_ep_attr(bInterval, "%02x\n") | |
48 | ||
9bde7497 GKH |
49 | static ssize_t show_ep_wMaxPacketSize(struct device *dev, |
50 | struct device_attribute *attr, char *buf) | |
84412f62 | 51 | { |
9bde7497 | 52 | struct ep_device *ep = to_ep_device(dev); |
84412f62 | 53 | return sprintf(buf, "%04x\n", |
9bde7497 | 54 | le16_to_cpu(ep->desc->wMaxPacketSize) & 0x07ff); |
84412f62 | 55 | } |
9bde7497 | 56 | static DEVICE_ATTR(wMaxPacketSize, S_IRUGO, show_ep_wMaxPacketSize, NULL); |
84412f62 | 57 | |
9bde7497 GKH |
58 | static ssize_t show_ep_type(struct device *dev, struct device_attribute *attr, |
59 | char *buf) | |
84412f62 | 60 | { |
9bde7497 | 61 | struct ep_device *ep = to_ep_device(dev); |
84412f62 GKH |
62 | char *type = "unknown"; |
63 | ||
9bde7497 | 64 | switch (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { |
84412f62 GKH |
65 | case USB_ENDPOINT_XFER_CONTROL: |
66 | type = "Control"; | |
67 | break; | |
68 | case USB_ENDPOINT_XFER_ISOC: | |
69 | type = "Isoc"; | |
70 | break; | |
71 | case USB_ENDPOINT_XFER_BULK: | |
72 | type = "Bulk"; | |
73 | break; | |
74 | case USB_ENDPOINT_XFER_INT: | |
75 | type = "Interrupt"; | |
76 | break; | |
77 | } | |
78 | return sprintf(buf, "%s\n", type); | |
79 | } | |
9bde7497 | 80 | static DEVICE_ATTR(type, S_IRUGO, show_ep_type, NULL); |
84412f62 | 81 | |
9bde7497 GKH |
82 | static ssize_t show_ep_interval(struct device *dev, |
83 | struct device_attribute *attr, char *buf) | |
84412f62 | 84 | { |
9bde7497 | 85 | struct ep_device *ep = to_ep_device(dev); |
84412f62 GKH |
86 | char unit; |
87 | unsigned interval = 0; | |
88 | unsigned in; | |
89 | ||
9bde7497 | 90 | in = (ep->desc->bEndpointAddress & USB_DIR_IN); |
84412f62 | 91 | |
9bde7497 | 92 | switch (ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { |
84412f62 | 93 | case USB_ENDPOINT_XFER_CONTROL: |
9bde7497 GKH |
94 | if (ep->udev->speed == USB_SPEED_HIGH) /* uframes per NAK */ |
95 | interval = ep->desc->bInterval; | |
84412f62 GKH |
96 | break; |
97 | case USB_ENDPOINT_XFER_ISOC: | |
9bde7497 | 98 | interval = 1 << (ep->desc->bInterval - 1); |
84412f62 GKH |
99 | break; |
100 | case USB_ENDPOINT_XFER_BULK: | |
9bde7497 GKH |
101 | if (ep->udev->speed == USB_SPEED_HIGH && !in) /* uframes per NAK */ |
102 | interval = ep->desc->bInterval; | |
84412f62 GKH |
103 | break; |
104 | case USB_ENDPOINT_XFER_INT: | |
9bde7497 GKH |
105 | if (ep->udev->speed == USB_SPEED_HIGH) |
106 | interval = 1 << (ep->desc->bInterval - 1); | |
84412f62 | 107 | else |
9bde7497 | 108 | interval = ep->desc->bInterval; |
84412f62 GKH |
109 | break; |
110 | } | |
9bde7497 | 111 | interval *= (ep->udev->speed == USB_SPEED_HIGH) ? 125 : 1000; |
84412f62 GKH |
112 | if (interval % 1000) |
113 | unit = 'u'; | |
114 | else { | |
115 | unit = 'm'; | |
116 | interval /= 1000; | |
117 | } | |
118 | ||
119 | return sprintf(buf, "%d%cs\n", interval, unit); | |
120 | } | |
9bde7497 | 121 | static DEVICE_ATTR(interval, S_IRUGO, show_ep_interval, NULL); |
84412f62 | 122 | |
9bde7497 GKH |
123 | static ssize_t show_ep_direction(struct device *dev, |
124 | struct device_attribute *attr, char *buf) | |
84412f62 | 125 | { |
9bde7497 | 126 | struct ep_device *ep = to_ep_device(dev); |
84412f62 GKH |
127 | char *direction; |
128 | ||
9bde7497 | 129 | if ((ep->desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == |
84412f62 GKH |
130 | USB_ENDPOINT_XFER_CONTROL) |
131 | direction = "both"; | |
9bde7497 | 132 | else if (ep->desc->bEndpointAddress & USB_DIR_IN) |
84412f62 GKH |
133 | direction = "in"; |
134 | else | |
135 | direction = "out"; | |
136 | return sprintf(buf, "%s\n", direction); | |
137 | } | |
9bde7497 GKH |
138 | static DEVICE_ATTR(direction, S_IRUGO, show_ep_direction, NULL); |
139 | ||
140 | static struct attribute *ep_dev_attrs[] = { | |
141 | &dev_attr_bLength.attr, | |
142 | &dev_attr_bEndpointAddress.attr, | |
143 | &dev_attr_bmAttributes.attr, | |
144 | &dev_attr_bInterval.attr, | |
145 | &dev_attr_wMaxPacketSize.attr, | |
146 | &dev_attr_interval.attr, | |
147 | &dev_attr_type.attr, | |
148 | &dev_attr_direction.attr, | |
84412f62 GKH |
149 | NULL, |
150 | }; | |
9bde7497 GKH |
151 | static struct attribute_group ep_dev_attr_grp = { |
152 | .attrs = ep_dev_attrs, | |
153 | }; | |
84412f62 | 154 | |
9bde7497 GKH |
155 | static struct endpoint_class { |
156 | struct kref kref; | |
157 | struct class *class; | |
158 | } *ep_class; | |
159 | ||
160 | static int init_endpoint_class(void) | |
84412f62 | 161 | { |
9bde7497 GKH |
162 | int result = 0; |
163 | ||
164 | if (ep_class != NULL) { | |
165 | kref_get(&ep_class->kref); | |
166 | goto exit; | |
167 | } | |
168 | ||
169 | ep_class = kmalloc(sizeof(*ep_class), GFP_KERNEL); | |
170 | if (!ep_class) { | |
171 | result = -ENOMEM; | |
172 | goto exit; | |
173 | } | |
174 | ||
175 | kref_init(&ep_class->kref); | |
176 | ep_class->class = class_create(THIS_MODULE, "usb_endpoint"); | |
177 | if (IS_ERR(ep_class->class)) { | |
178 | result = IS_ERR(ep_class->class); | |
179 | kfree(ep_class); | |
180 | ep_class = NULL; | |
181 | goto exit; | |
182 | } | |
183 | ||
184 | exit: | |
185 | return result; | |
84412f62 GKH |
186 | } |
187 | ||
9bde7497 | 188 | static void release_endpoint_class(struct kref *kref) |
84412f62 | 189 | { |
9bde7497 GKH |
190 | /* Ok, we cheat as we know we only have one ep_class */ |
191 | class_destroy(ep_class->class); | |
192 | kfree(ep_class); | |
193 | ep_class = NULL; | |
194 | } | |
84412f62 | 195 | |
9bde7497 GKH |
196 | static void destroy_endpoint_class(void) |
197 | { | |
198 | if (ep_class) | |
199 | kref_put(&ep_class->kref, release_endpoint_class); | |
84412f62 GKH |
200 | } |
201 | ||
9bde7497 GKH |
202 | static void ep_device_release(struct device *dev) |
203 | { | |
204 | struct ep_device *ep_dev = to_ep_device(dev); | |
84412f62 | 205 | |
9bde7497 GKH |
206 | dev_dbg(dev, "%s called for %s\n", __FUNCTION__, dev->bus_id); |
207 | kfree(ep_dev); | |
208 | } | |
84412f62 | 209 | |
1b21d5e1 GKH |
210 | int usb_create_ep_files(struct device *parent, |
211 | struct usb_host_endpoint *endpoint, | |
212 | struct usb_device *udev) | |
84412f62 | 213 | { |
9bde7497 GKH |
214 | char name[8]; |
215 | struct ep_device *ep_dev; | |
216 | int minor; | |
217 | int retval; | |
218 | ||
219 | retval = init_endpoint_class(); | |
220 | if (retval) | |
221 | goto exit; | |
84412f62 | 222 | |
9bde7497 GKH |
223 | ep_dev = kzalloc(sizeof(*ep_dev), GFP_KERNEL); |
224 | if (!ep_dev) { | |
225 | retval = -ENOMEM; | |
d5477c11 | 226 | goto error_alloc; |
9bde7497 | 227 | } |
84412f62 | 228 | |
9bde7497 GKH |
229 | /* fun calculation to determine the minor of this endpoint */ |
230 | minor = (((udev->bus->busnum - 1) * 128) * 16) + (udev->devnum - 1); | |
84412f62 | 231 | |
9bde7497 GKH |
232 | ep_dev->desc = &endpoint->desc; |
233 | ep_dev->udev = udev; | |
234 | ep_dev->dev.devt = MKDEV(442, minor); // FIXME fake number... | |
235 | ep_dev->dev.class = ep_class->class; | |
236 | ep_dev->dev.parent = parent; | |
237 | ep_dev->dev.release = ep_device_release; | |
238 | snprintf(ep_dev->dev.bus_id, BUS_ID_SIZE, "usbdev%d.%d_ep%02x", | |
239 | udev->bus->busnum, udev->devnum, | |
240 | endpoint->desc.bEndpointAddress); | |
84412f62 | 241 | |
9bde7497 GKH |
242 | retval = device_register(&ep_dev->dev); |
243 | if (retval) | |
d5477c11 | 244 | goto error_register; |
1b21d5e1 GKH |
245 | retval = sysfs_create_group(&ep_dev->dev.kobj, &ep_dev_attr_grp); |
246 | if (retval) | |
247 | goto error_group; | |
9bde7497 | 248 | |
9bde7497 GKH |
249 | /* create the symlink to the old-style "ep_XX" directory */ |
250 | sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress); | |
d5477c11 | 251 | retval = sysfs_create_link(&parent->kobj, &ep_dev->dev.kobj, name); |
1b21d5e1 GKH |
252 | if (retval) |
253 | goto error_link; | |
d5477c11 | 254 | endpoint->ep_dev = ep_dev; |
1b21d5e1 GKH |
255 | return retval; |
256 | ||
257 | error_link: | |
258 | sysfs_remove_group(&ep_dev->dev.kobj, &ep_dev_attr_grp); | |
1b21d5e1 GKH |
259 | error_group: |
260 | device_unregister(&ep_dev->dev); | |
1b21d5e1 GKH |
261 | destroy_endpoint_class(); |
262 | return retval; | |
d5477c11 AS |
263 | |
264 | error_register: | |
9bde7497 | 265 | kfree(ep_dev); |
d5477c11 | 266 | error_alloc: |
1b21d5e1 | 267 | destroy_endpoint_class(); |
d5477c11 | 268 | exit: |
1b21d5e1 | 269 | return retval; |
84412f62 GKH |
270 | } |
271 | ||
272 | void usb_remove_ep_files(struct usb_host_endpoint *endpoint) | |
273 | { | |
274 | ||
9bde7497 GKH |
275 | if (endpoint->ep_dev) { |
276 | char name[8]; | |
277 | ||
278 | sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress); | |
279 | sysfs_remove_link(&endpoint->ep_dev->dev.parent->kobj, name); | |
280 | sysfs_remove_group(&endpoint->ep_dev->dev.kobj, &ep_dev_attr_grp); | |
281 | device_unregister(&endpoint->ep_dev->dev); | |
282 | endpoint->ep_dev = NULL; | |
c40fd5ea | 283 | destroy_endpoint_class(); |
84412f62 GKH |
284 | } |
285 | } |