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