Commit | Line | Data |
---|---|---|
df365423 IPG |
1 | /* |
2 | * WUSB Wire Adapter | |
3 | * rpipe management | |
4 | * | |
5 | * Copyright (C) 2005-2006 Intel Corporation | |
6 | * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License version | |
10 | * 2 as published by the Free Software Foundation. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
20 | * 02110-1301, USA. | |
21 | * | |
22 | * | |
23 | * FIXME: docs | |
24 | * | |
25 | * RPIPE | |
26 | * | |
27 | * Targetted at different downstream endpoints | |
28 | * | |
29 | * Descriptor: use to config the remote pipe. | |
30 | * | |
31 | * The number of blocks could be dynamic (wBlocks in descriptor is | |
32 | * 0)--need to schedule them then. | |
33 | * | |
34 | * Each bit in wa->rpipe_bm represents if an rpipe is being used or | |
35 | * not. Rpipes are represented with a 'struct wa_rpipe' that is | |
36 | * attached to the hcpriv member of a 'struct usb_host_endpoint'. | |
37 | * | |
38 | * When you need to xfer data to an endpoint, you get an rpipe for it | |
39 | * with wa_ep_rpipe_get(), which gives you a reference to the rpipe | |
40 | * and keeps a single one (the first one) with the endpoint. When you | |
41 | * are done transferring, you drop that reference. At the end the | |
42 | * rpipe is always allocated and bound to the endpoint. There it might | |
43 | * be recycled when not used. | |
44 | * | |
45 | * Addresses: | |
46 | * | |
47 | * We use a 1:1 mapping mechanism between port address (0 based | |
48 | * index, actually) and the address. The USB stack knows about this. | |
49 | * | |
50 | * USB Stack port number 4 (1 based) | |
51 | * WUSB code port index 3 (0 based) | |
52 | * USB Addresss 5 (2 based -- 0 is for default, 1 for root hub) | |
53 | * | |
54 | * Now, because we don't use the concept as default address exactly | |
55 | * like the (wired) USB code does, we need to kind of skip it. So we | |
56 | * never take addresses from the urb->pipe, but from the | |
57 | * urb->dev->devnum, to make sure that we always have the right | |
58 | * destination address. | |
59 | */ | |
60 | #include <linux/init.h> | |
61 | #include <asm/atomic.h> | |
62 | #include <linux/bitmap.h> | |
63 | #include "wusbhc.h" | |
64 | #include "wa-hc.h" | |
65 | ||
66 | #define D_LOCAL 0 | |
67 | #include <linux/uwb/debug.h> | |
68 | ||
69 | ||
70 | static int __rpipe_get_descr(struct wahc *wa, | |
71 | struct usb_rpipe_descriptor *descr, u16 index) | |
72 | { | |
73 | ssize_t result; | |
74 | struct device *dev = &wa->usb_iface->dev; | |
75 | ||
76 | /* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor() | |
77 | * function because the arguments are different. | |
78 | */ | |
79 | d_printf(1, dev, "rpipe %u: get descr\n", index); | |
80 | result = usb_control_msg( | |
81 | wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0), | |
82 | USB_REQ_GET_DESCRIPTOR, | |
83 | USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_RPIPE, | |
84 | USB_DT_RPIPE<<8, index, descr, sizeof(*descr), | |
85 | 1000 /* FIXME: arbitrary */); | |
86 | if (result < 0) { | |
87 | dev_err(dev, "rpipe %u: get descriptor failed: %d\n", | |
88 | index, (int)result); | |
89 | goto error; | |
90 | } | |
91 | if (result < sizeof(*descr)) { | |
92 | dev_err(dev, "rpipe %u: got short descriptor " | |
93 | "(%zd vs %zd bytes needed)\n", | |
94 | index, result, sizeof(*descr)); | |
95 | result = -EINVAL; | |
96 | goto error; | |
97 | } | |
98 | result = 0; | |
99 | ||
100 | error: | |
101 | return result; | |
102 | } | |
103 | ||
104 | /* | |
105 | * | |
106 | * The descriptor is assumed to be properly initialized (ie: you got | |
107 | * it through __rpipe_get_descr()). | |
108 | */ | |
109 | static int __rpipe_set_descr(struct wahc *wa, | |
110 | struct usb_rpipe_descriptor *descr, u16 index) | |
111 | { | |
112 | ssize_t result; | |
113 | struct device *dev = &wa->usb_iface->dev; | |
114 | ||
115 | /* we cannot use the usb_get_descriptor() function because the | |
116 | * arguments are different. | |
117 | */ | |
118 | d_printf(1, dev, "rpipe %u: set descr\n", index); | |
119 | result = usb_control_msg( | |
120 | wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
121 | USB_REQ_SET_DESCRIPTOR, | |
122 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE, | |
123 | USB_DT_RPIPE<<8, index, descr, sizeof(*descr), | |
124 | HZ / 10); | |
125 | if (result < 0) { | |
126 | dev_err(dev, "rpipe %u: set descriptor failed: %d\n", | |
127 | index, (int)result); | |
128 | goto error; | |
129 | } | |
130 | if (result < sizeof(*descr)) { | |
131 | dev_err(dev, "rpipe %u: sent short descriptor " | |
132 | "(%zd vs %zd bytes required)\n", | |
133 | index, result, sizeof(*descr)); | |
134 | result = -EINVAL; | |
135 | goto error; | |
136 | } | |
137 | result = 0; | |
138 | ||
139 | error: | |
140 | return result; | |
141 | ||
142 | } | |
143 | ||
144 | static void rpipe_init(struct wa_rpipe *rpipe) | |
145 | { | |
146 | kref_init(&rpipe->refcnt); | |
147 | spin_lock_init(&rpipe->seg_lock); | |
148 | INIT_LIST_HEAD(&rpipe->seg_list); | |
149 | } | |
150 | ||
151 | static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx) | |
152 | { | |
153 | unsigned long flags; | |
154 | ||
155 | spin_lock_irqsave(&wa->rpipe_bm_lock, flags); | |
156 | rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx); | |
157 | if (rpipe_idx < wa->rpipes) | |
158 | set_bit(rpipe_idx, wa->rpipe_bm); | |
159 | spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags); | |
160 | ||
161 | return rpipe_idx; | |
162 | } | |
163 | ||
164 | static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx) | |
165 | { | |
166 | unsigned long flags; | |
167 | ||
168 | spin_lock_irqsave(&wa->rpipe_bm_lock, flags); | |
169 | clear_bit(rpipe_idx, wa->rpipe_bm); | |
170 | spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags); | |
171 | } | |
172 | ||
173 | void rpipe_destroy(struct kref *_rpipe) | |
174 | { | |
175 | struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt); | |
176 | u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex); | |
177 | d_fnstart(1, NULL, "(rpipe %p %u)\n", rpipe, index); | |
178 | if (rpipe->ep) | |
179 | rpipe->ep->hcpriv = NULL; | |
180 | rpipe_put_idx(rpipe->wa, index); | |
181 | wa_put(rpipe->wa); | |
182 | kfree(rpipe); | |
183 | d_fnend(1, NULL, "(rpipe %p %u)\n", rpipe, index); | |
184 | } | |
185 | EXPORT_SYMBOL_GPL(rpipe_destroy); | |
186 | ||
187 | /* | |
188 | * Locate an idle rpipe, create an structure for it and return it | |
189 | * | |
190 | * @wa is referenced and unlocked | |
191 | * @crs enum rpipe_attr, required endpoint characteristics | |
192 | * | |
193 | * The rpipe can be used only sequentially (not in parallel). | |
194 | * | |
195 | * The rpipe is moved into the "ready" state. | |
196 | */ | |
197 | static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs, | |
198 | gfp_t gfp) | |
199 | { | |
200 | int result; | |
201 | unsigned rpipe_idx; | |
202 | struct wa_rpipe *rpipe; | |
203 | struct device *dev = &wa->usb_iface->dev; | |
204 | ||
205 | d_fnstart(3, dev, "(wa %p crs 0x%02x)\n", wa, crs); | |
206 | rpipe = kzalloc(sizeof(*rpipe), gfp); | |
207 | if (rpipe == NULL) | |
208 | return -ENOMEM; | |
209 | rpipe_init(rpipe); | |
210 | ||
211 | /* Look for an idle pipe */ | |
212 | for (rpipe_idx = 0; rpipe_idx < wa->rpipes; rpipe_idx++) { | |
213 | rpipe_idx = rpipe_get_idx(wa, rpipe_idx); | |
214 | if (rpipe_idx >= wa->rpipes) /* no more pipes :( */ | |
215 | break; | |
216 | result = __rpipe_get_descr(wa, &rpipe->descr, rpipe_idx); | |
217 | if (result < 0) | |
218 | dev_err(dev, "Can't get descriptor for rpipe %u: %d\n", | |
219 | rpipe_idx, result); | |
220 | else if ((rpipe->descr.bmCharacteristics & crs) != 0) | |
221 | goto found; | |
222 | rpipe_put_idx(wa, rpipe_idx); | |
223 | } | |
224 | *prpipe = NULL; | |
225 | kfree(rpipe); | |
226 | d_fnend(3, dev, "(wa %p crs 0x%02x) = -ENXIO\n", wa, crs); | |
227 | return -ENXIO; | |
228 | ||
229 | found: | |
230 | set_bit(rpipe_idx, wa->rpipe_bm); | |
231 | rpipe->wa = wa_get(wa); | |
232 | *prpipe = rpipe; | |
233 | d_fnstart(3, dev, "(wa %p crs 0x%02x) = 0\n", wa, crs); | |
234 | return 0; | |
235 | } | |
236 | ||
237 | static int __rpipe_reset(struct wahc *wa, unsigned index) | |
238 | { | |
239 | int result; | |
240 | struct device *dev = &wa->usb_iface->dev; | |
241 | ||
242 | d_printf(1, dev, "rpipe %u: reset\n", index); | |
243 | result = usb_control_msg( | |
244 | wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
245 | USB_REQ_RPIPE_RESET, | |
246 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE, | |
247 | 0, index, NULL, 0, 1000 /* FIXME: arbitrary */); | |
248 | if (result < 0) | |
249 | dev_err(dev, "rpipe %u: reset failed: %d\n", | |
250 | index, result); | |
251 | return result; | |
252 | } | |
253 | ||
254 | /* | |
255 | * Fake companion descriptor for ep0 | |
256 | * | |
257 | * See WUSB1.0[7.4.4], most of this is zero for bulk/int/ctl | |
258 | */ | |
259 | static struct usb_wireless_ep_comp_descriptor epc0 = { | |
260 | .bLength = sizeof(epc0), | |
261 | .bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP, | |
262 | /* .bMaxBurst = 1, */ | |
263 | .bMaxSequence = 31, | |
264 | }; | |
265 | ||
266 | /* | |
267 | * Look for EP companion descriptor | |
268 | * | |
269 | * Get there, look for Inara in the endpoint's extra descriptors | |
270 | */ | |
271 | static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find( | |
272 | struct device *dev, struct usb_host_endpoint *ep) | |
273 | { | |
274 | void *itr; | |
275 | size_t itr_size; | |
276 | struct usb_descriptor_header *hdr; | |
277 | struct usb_wireless_ep_comp_descriptor *epcd; | |
278 | ||
279 | d_fnstart(3, dev, "(ep %p)\n", ep); | |
280 | if (ep->desc.bEndpointAddress == 0) { | |
281 | epcd = &epc0; | |
282 | goto out; | |
283 | } | |
284 | itr = ep->extra; | |
285 | itr_size = ep->extralen; | |
286 | epcd = NULL; | |
287 | while (itr_size > 0) { | |
288 | if (itr_size < sizeof(*hdr)) { | |
289 | dev_err(dev, "HW Bug? ep 0x%02x: extra descriptors " | |
290 | "at offset %zu: only %zu bytes left\n", | |
291 | ep->desc.bEndpointAddress, | |
292 | itr - (void *) ep->extra, itr_size); | |
293 | break; | |
294 | } | |
295 | hdr = itr; | |
296 | if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) { | |
297 | epcd = itr; | |
298 | break; | |
299 | } | |
300 | if (hdr->bLength > itr_size) { | |
301 | dev_err(dev, "HW Bug? ep 0x%02x: extra descriptor " | |
302 | "at offset %zu (type 0x%02x) " | |
303 | "length %d but only %zu bytes left\n", | |
304 | ep->desc.bEndpointAddress, | |
305 | itr - (void *) ep->extra, hdr->bDescriptorType, | |
306 | hdr->bLength, itr_size); | |
307 | break; | |
308 | } | |
309 | itr += hdr->bLength; | |
310 | itr_size -= hdr->bDescriptorType; | |
311 | } | |
312 | out: | |
313 | d_fnend(3, dev, "(ep %p) = %p\n", ep, epcd); | |
314 | return epcd; | |
315 | } | |
316 | ||
317 | /* | |
318 | * Aim an rpipe to its device & endpoint destination | |
319 | * | |
320 | * Make sure we change the address to unauthenticathed if the device | |
321 | * is WUSB and it is not authenticated. | |
322 | */ | |
323 | static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa, | |
324 | struct usb_host_endpoint *ep, struct urb *urb, gfp_t gfp) | |
325 | { | |
326 | int result = -ENOMSG; /* better code for lack of companion? */ | |
327 | struct device *dev = &wa->usb_iface->dev; | |
328 | struct usb_device *usb_dev = urb->dev; | |
329 | struct usb_wireless_ep_comp_descriptor *epcd; | |
330 | u8 unauth; | |
331 | ||
332 | d_fnstart(3, dev, "(rpipe %p wa %p ep %p, urb %p)\n", | |
333 | rpipe, wa, ep, urb); | |
334 | epcd = rpipe_epc_find(dev, ep); | |
335 | if (epcd == NULL) { | |
336 | dev_err(dev, "ep 0x%02x: can't find companion descriptor\n", | |
337 | ep->desc.bEndpointAddress); | |
338 | goto error; | |
339 | } | |
340 | unauth = usb_dev->wusb && !usb_dev->authenticated ? 0x80 : 0; | |
341 | __rpipe_reset(wa, le16_to_cpu(rpipe->descr.wRPipeIndex)); | |
342 | atomic_set(&rpipe->segs_available, le16_to_cpu(rpipe->descr.wRequests)); | |
343 | /* FIXME: block allocation system; request with queuing and timeout */ | |
344 | /* FIXME: compute so seg_size > ep->maxpktsize */ | |
345 | rpipe->descr.wBlocks = cpu_to_le16(16); /* given */ | |
346 | /* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */ | |
347 | rpipe->descr.wMaxPacketSize = cpu_to_le16(ep->desc.wMaxPacketSize); | |
348 | rpipe->descr.bHSHubAddress = 0; /* reserved: zero */ | |
349 | rpipe->descr.bHSHubPort = wusb_port_no_to_idx(urb->dev->portnum); | |
350 | /* FIXME: use maximum speed as supported or recommended by device */ | |
351 | rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ? | |
352 | UWB_PHY_RATE_53 : UWB_PHY_RATE_200; | |
353 | d_printf(2, dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n", | |
354 | urb->dev->devnum, urb->dev->devnum | unauth, | |
355 | le16_to_cpu(rpipe->descr.wRPipeIndex), | |
356 | usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed); | |
357 | /* see security.c:wusb_update_address() */ | |
358 | if (unlikely(urb->dev->devnum == 0x80)) | |
359 | rpipe->descr.bDeviceAddress = 0; | |
360 | else | |
361 | rpipe->descr.bDeviceAddress = urb->dev->devnum | unauth; | |
362 | rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress; | |
363 | /* FIXME: bDataSequence */ | |
364 | rpipe->descr.bDataSequence = 0; | |
365 | /* FIXME: dwCurrentWindow */ | |
366 | rpipe->descr.dwCurrentWindow = cpu_to_le32(1); | |
367 | /* FIXME: bMaxDataSequence */ | |
368 | rpipe->descr.bMaxDataSequence = epcd->bMaxSequence - 1; | |
369 | rpipe->descr.bInterval = ep->desc.bInterval; | |
370 | /* FIXME: bOverTheAirInterval */ | |
371 | rpipe->descr.bOverTheAirInterval = 0; /* 0 if not isoc */ | |
372 | /* FIXME: xmit power & preamble blah blah */ | |
373 | rpipe->descr.bmAttribute = ep->desc.bmAttributes & 0x03; | |
374 | /* rpipe->descr.bmCharacteristics RO */ | |
375 | /* FIXME: bmRetryOptions */ | |
376 | rpipe->descr.bmRetryOptions = 15; | |
377 | /* FIXME: use for assessing link quality? */ | |
378 | rpipe->descr.wNumTransactionErrors = 0; | |
379 | result = __rpipe_set_descr(wa, &rpipe->descr, | |
380 | le16_to_cpu(rpipe->descr.wRPipeIndex)); | |
381 | if (result < 0) { | |
382 | dev_err(dev, "Cannot aim rpipe: %d\n", result); | |
383 | goto error; | |
384 | } | |
385 | result = 0; | |
386 | error: | |
387 | d_fnend(3, dev, "(rpipe %p wa %p ep %p urb %p) = %d\n", | |
388 | rpipe, wa, ep, urb, result); | |
389 | return result; | |
390 | } | |
391 | ||
392 | /* | |
393 | * Check an aimed rpipe to make sure it points to where we want | |
394 | * | |
395 | * We use bit 19 of the Linux USB pipe bitmap for unauth vs auth | |
396 | * space; when it is like that, we or 0x80 to make an unauth address. | |
397 | */ | |
398 | static int rpipe_check_aim(const struct wa_rpipe *rpipe, const struct wahc *wa, | |
399 | const struct usb_host_endpoint *ep, | |
400 | const struct urb *urb, gfp_t gfp) | |
401 | { | |
402 | int result = 0; /* better code for lack of companion? */ | |
403 | struct device *dev = &wa->usb_iface->dev; | |
404 | struct usb_device *usb_dev = urb->dev; | |
405 | u8 unauth = (usb_dev->wusb && !usb_dev->authenticated) ? 0x80 : 0; | |
406 | u8 portnum = wusb_port_no_to_idx(urb->dev->portnum); | |
407 | ||
408 | d_fnstart(3, dev, "(rpipe %p wa %p ep %p, urb %p)\n", | |
409 | rpipe, wa, ep, urb); | |
410 | #define AIM_CHECK(rdf, val, text) \ | |
411 | do { \ | |
412 | if (rpipe->descr.rdf != (val)) { \ | |
413 | dev_err(dev, \ | |
414 | "rpipe aim discrepancy: " #rdf " " text "\n", \ | |
415 | rpipe->descr.rdf, (val)); \ | |
416 | result = -EINVAL; \ | |
417 | WARN_ON(1); \ | |
418 | } \ | |
419 | } while (0) | |
420 | AIM_CHECK(wMaxPacketSize, cpu_to_le16(ep->desc.wMaxPacketSize), | |
421 | "(%u vs %u)"); | |
422 | AIM_CHECK(bHSHubPort, portnum, "(%u vs %u)"); | |
423 | AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ? | |
424 | UWB_PHY_RATE_53 : UWB_PHY_RATE_200, | |
425 | "(%u vs %u)"); | |
426 | AIM_CHECK(bDeviceAddress, urb->dev->devnum | unauth, "(%u vs %u)"); | |
427 | AIM_CHECK(bEndpointAddress, ep->desc.bEndpointAddress, "(%u vs %u)"); | |
428 | AIM_CHECK(bInterval, ep->desc.bInterval, "(%u vs %u)"); | |
429 | AIM_CHECK(bmAttribute, ep->desc.bmAttributes & 0x03, "(%u vs %u)"); | |
430 | #undef AIM_CHECK | |
431 | return result; | |
432 | } | |
433 | ||
434 | #ifndef CONFIG_BUG | |
435 | #define CONFIG_BUG 0 | |
436 | #endif | |
437 | ||
438 | /* | |
439 | * Make sure there is an rpipe allocated for an endpoint | |
440 | * | |
441 | * If already allocated, we just refcount it; if not, we get an | |
442 | * idle one, aim it to the right location and take it. | |
443 | * | |
444 | * Attaches to ep->hcpriv and rpipe->ep to ep. | |
445 | */ | |
446 | int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep, | |
447 | struct urb *urb, gfp_t gfp) | |
448 | { | |
449 | int result = 0; | |
450 | struct device *dev = &wa->usb_iface->dev; | |
451 | struct wa_rpipe *rpipe; | |
452 | u8 eptype; | |
453 | ||
454 | d_fnstart(3, dev, "(wa %p ep %p urb %p gfp 0x%08x)\n", wa, ep, urb, | |
455 | gfp); | |
456 | mutex_lock(&wa->rpipe_mutex); | |
457 | rpipe = ep->hcpriv; | |
458 | if (rpipe != NULL) { | |
459 | if (CONFIG_BUG == 1) { | |
460 | result = rpipe_check_aim(rpipe, wa, ep, urb, gfp); | |
461 | if (result < 0) | |
462 | goto error; | |
463 | } | |
464 | __rpipe_get(rpipe); | |
465 | d_printf(2, dev, "ep 0x%02x: reusing rpipe %u\n", | |
466 | ep->desc.bEndpointAddress, | |
467 | le16_to_cpu(rpipe->descr.wRPipeIndex)); | |
468 | } else { | |
469 | /* hmm, assign idle rpipe, aim it */ | |
470 | result = -ENOBUFS; | |
471 | eptype = ep->desc.bmAttributes & 0x03; | |
472 | result = rpipe_get_idle(&rpipe, wa, 1 << eptype, gfp); | |
473 | if (result < 0) | |
474 | goto error; | |
475 | result = rpipe_aim(rpipe, wa, ep, urb, gfp); | |
476 | if (result < 0) { | |
477 | rpipe_put(rpipe); | |
478 | goto error; | |
479 | } | |
480 | ep->hcpriv = rpipe; | |
481 | rpipe->ep = ep; | |
482 | __rpipe_get(rpipe); /* for caching into ep->hcpriv */ | |
483 | d_printf(2, dev, "ep 0x%02x: using rpipe %u\n", | |
484 | ep->desc.bEndpointAddress, | |
485 | le16_to_cpu(rpipe->descr.wRPipeIndex)); | |
486 | } | |
487 | d_dump(4, dev, &rpipe->descr, sizeof(rpipe->descr)); | |
488 | error: | |
489 | mutex_unlock(&wa->rpipe_mutex); | |
490 | d_fnend(3, dev, "(wa %p ep %p urb %p gfp 0x%08x)\n", wa, ep, urb, gfp); | |
491 | return result; | |
492 | } | |
493 | ||
494 | /* | |
495 | * Allocate the bitmap for each rpipe. | |
496 | */ | |
497 | int wa_rpipes_create(struct wahc *wa) | |
498 | { | |
499 | wa->rpipes = wa->wa_descr->wNumRPipes; | |
500 | wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long), | |
501 | GFP_KERNEL); | |
502 | if (wa->rpipe_bm == NULL) | |
503 | return -ENOMEM; | |
504 | return 0; | |
505 | } | |
506 | ||
507 | void wa_rpipes_destroy(struct wahc *wa) | |
508 | { | |
509 | struct device *dev = &wa->usb_iface->dev; | |
510 | d_fnstart(3, dev, "(wa %p)\n", wa); | |
511 | if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) { | |
512 | char buf[256]; | |
513 | WARN_ON(1); | |
514 | bitmap_scnprintf(buf, sizeof(buf), wa->rpipe_bm, wa->rpipes); | |
515 | dev_err(dev, "BUG: pipes not released on exit: %s\n", buf); | |
516 | } | |
517 | kfree(wa->rpipe_bm); | |
518 | d_fnend(3, dev, "(wa %p)\n", wa); | |
519 | } | |
520 | ||
521 | /* | |
522 | * Release resources allocated for an endpoint | |
523 | * | |
524 | * If there is an associated rpipe to this endpoint, Abort any pending | |
525 | * transfers and put it. If the rpipe ends up being destroyed, | |
526 | * __rpipe_destroy() will cleanup ep->hcpriv. | |
527 | * | |
528 | * This is called before calling hcd->stop(), so you don't need to do | |
529 | * anything else in there. | |
530 | */ | |
531 | void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep) | |
532 | { | |
533 | struct device *dev = &wa->usb_iface->dev; | |
534 | struct wa_rpipe *rpipe; | |
535 | d_fnstart(2, dev, "(wa %p ep %p)\n", wa, ep); | |
536 | mutex_lock(&wa->rpipe_mutex); | |
537 | rpipe = ep->hcpriv; | |
538 | if (rpipe != NULL) { | |
539 | unsigned rc = atomic_read(&rpipe->refcnt.refcount); | |
540 | int result; | |
541 | u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex); | |
542 | ||
543 | if (rc != 1) | |
544 | d_printf(1, dev, "(wa %p ep %p) rpipe %p refcnt %u\n", | |
545 | wa, ep, rpipe, rc); | |
546 | ||
547 | d_printf(1, dev, "rpipe %u: abort\n", index); | |
548 | result = usb_control_msg( | |
549 | wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0), | |
550 | USB_REQ_RPIPE_ABORT, | |
b0a81328 | 551 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE, |
df365423 IPG |
552 | 0, index, NULL, 0, 1000 /* FIXME: arbitrary */); |
553 | if (result < 0 && result != -ENODEV /* dev is gone */) | |
554 | d_printf(1, dev, "(wa %p rpipe %u): abort failed: %d\n", | |
555 | wa, index, result); | |
556 | rpipe_put(rpipe); | |
557 | } | |
558 | mutex_unlock(&wa->rpipe_mutex); | |
559 | d_fnend(2, dev, "(wa %p ep %p)\n", wa, ep); | |
560 | return; | |
561 | } | |
562 | EXPORT_SYMBOL_GPL(rpipe_ep_disable); |