Loading...
Note: File does not exist in v6.8.
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 * Targeted 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 Address 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 <linux/atomic.h>
62#include <linux/bitmap.h>
63#include <linux/slab.h>
64
65#include "wusbhc.h"
66#include "wa-hc.h"
67
68static int __rpipe_get_descr(struct wahc *wa,
69 struct usb_rpipe_descriptor *descr, u16 index)
70{
71 ssize_t result;
72 struct device *dev = &wa->usb_iface->dev;
73
74 /* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor()
75 * function because the arguments are different.
76 */
77 result = usb_control_msg(
78 wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
79 USB_REQ_GET_DESCRIPTOR,
80 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_RPIPE,
81 USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
82 1000 /* FIXME: arbitrary */);
83 if (result < 0) {
84 dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
85 index, (int)result);
86 goto error;
87 }
88 if (result < sizeof(*descr)) {
89 dev_err(dev, "rpipe %u: got short descriptor "
90 "(%zd vs %zd bytes needed)\n",
91 index, result, sizeof(*descr));
92 result = -EINVAL;
93 goto error;
94 }
95 result = 0;
96
97error:
98 return result;
99}
100
101/*
102 *
103 * The descriptor is assumed to be properly initialized (ie: you got
104 * it through __rpipe_get_descr()).
105 */
106static int __rpipe_set_descr(struct wahc *wa,
107 struct usb_rpipe_descriptor *descr, u16 index)
108{
109 ssize_t result;
110 struct device *dev = &wa->usb_iface->dev;
111
112 /* we cannot use the usb_get_descriptor() function because the
113 * arguments are different.
114 */
115 result = usb_control_msg(
116 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
117 USB_REQ_SET_DESCRIPTOR,
118 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
119 USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
120 HZ / 10);
121 if (result < 0) {
122 dev_err(dev, "rpipe %u: set descriptor failed: %d\n",
123 index, (int)result);
124 goto error;
125 }
126 if (result < sizeof(*descr)) {
127 dev_err(dev, "rpipe %u: sent short descriptor "
128 "(%zd vs %zd bytes required)\n",
129 index, result, sizeof(*descr));
130 result = -EINVAL;
131 goto error;
132 }
133 result = 0;
134
135error:
136 return result;
137
138}
139
140static void rpipe_init(struct wa_rpipe *rpipe)
141{
142 kref_init(&rpipe->refcnt);
143 spin_lock_init(&rpipe->seg_lock);
144 INIT_LIST_HEAD(&rpipe->seg_list);
145}
146
147static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
148{
149 unsigned long flags;
150
151 spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
152 rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx);
153 if (rpipe_idx < wa->rpipes)
154 set_bit(rpipe_idx, wa->rpipe_bm);
155 spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags);
156
157 return rpipe_idx;
158}
159
160static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
161{
162 unsigned long flags;
163
164 spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
165 clear_bit(rpipe_idx, wa->rpipe_bm);
166 spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags);
167}
168
169void rpipe_destroy(struct kref *_rpipe)
170{
171 struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
172 u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
173
174 if (rpipe->ep)
175 rpipe->ep->hcpriv = NULL;
176 rpipe_put_idx(rpipe->wa, index);
177 wa_put(rpipe->wa);
178 kfree(rpipe);
179}
180EXPORT_SYMBOL_GPL(rpipe_destroy);
181
182/*
183 * Locate an idle rpipe, create an structure for it and return it
184 *
185 * @wa is referenced and unlocked
186 * @crs enum rpipe_attr, required endpoint characteristics
187 *
188 * The rpipe can be used only sequentially (not in parallel).
189 *
190 * The rpipe is moved into the "ready" state.
191 */
192static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs,
193 gfp_t gfp)
194{
195 int result;
196 unsigned rpipe_idx;
197 struct wa_rpipe *rpipe;
198 struct device *dev = &wa->usb_iface->dev;
199
200 rpipe = kzalloc(sizeof(*rpipe), gfp);
201 if (rpipe == NULL)
202 return -ENOMEM;
203 rpipe_init(rpipe);
204
205 /* Look for an idle pipe */
206 for (rpipe_idx = 0; rpipe_idx < wa->rpipes; rpipe_idx++) {
207 rpipe_idx = rpipe_get_idx(wa, rpipe_idx);
208 if (rpipe_idx >= wa->rpipes) /* no more pipes :( */
209 break;
210 result = __rpipe_get_descr(wa, &rpipe->descr, rpipe_idx);
211 if (result < 0)
212 dev_err(dev, "Can't get descriptor for rpipe %u: %d\n",
213 rpipe_idx, result);
214 else if ((rpipe->descr.bmCharacteristics & crs) != 0)
215 goto found;
216 rpipe_put_idx(wa, rpipe_idx);
217 }
218 *prpipe = NULL;
219 kfree(rpipe);
220 return -ENXIO;
221
222found:
223 set_bit(rpipe_idx, wa->rpipe_bm);
224 rpipe->wa = wa_get(wa);
225 *prpipe = rpipe;
226 return 0;
227}
228
229static int __rpipe_reset(struct wahc *wa, unsigned index)
230{
231 int result;
232 struct device *dev = &wa->usb_iface->dev;
233
234 result = usb_control_msg(
235 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
236 USB_REQ_RPIPE_RESET,
237 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
238 0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
239 if (result < 0)
240 dev_err(dev, "rpipe %u: reset failed: %d\n",
241 index, result);
242 return result;
243}
244
245/*
246 * Fake companion descriptor for ep0
247 *
248 * See WUSB1.0[7.4.4], most of this is zero for bulk/int/ctl
249 */
250static struct usb_wireless_ep_comp_descriptor epc0 = {
251 .bLength = sizeof(epc0),
252 .bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP,
253/* .bMaxBurst = 1, */
254 .bMaxSequence = 31,
255};
256
257/*
258 * Look for EP companion descriptor
259 *
260 * Get there, look for Inara in the endpoint's extra descriptors
261 */
262static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
263 struct device *dev, struct usb_host_endpoint *ep)
264{
265 void *itr;
266 size_t itr_size;
267 struct usb_descriptor_header *hdr;
268 struct usb_wireless_ep_comp_descriptor *epcd;
269
270 if (ep->desc.bEndpointAddress == 0) {
271 epcd = &epc0;
272 goto out;
273 }
274 itr = ep->extra;
275 itr_size = ep->extralen;
276 epcd = NULL;
277 while (itr_size > 0) {
278 if (itr_size < sizeof(*hdr)) {
279 dev_err(dev, "HW Bug? ep 0x%02x: extra descriptors "
280 "at offset %zu: only %zu bytes left\n",
281 ep->desc.bEndpointAddress,
282 itr - (void *) ep->extra, itr_size);
283 break;
284 }
285 hdr = itr;
286 if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) {
287 epcd = itr;
288 break;
289 }
290 if (hdr->bLength > itr_size) {
291 dev_err(dev, "HW Bug? ep 0x%02x: extra descriptor "
292 "at offset %zu (type 0x%02x) "
293 "length %d but only %zu bytes left\n",
294 ep->desc.bEndpointAddress,
295 itr - (void *) ep->extra, hdr->bDescriptorType,
296 hdr->bLength, itr_size);
297 break;
298 }
299 itr += hdr->bLength;
300 itr_size -= hdr->bDescriptorType;
301 }
302out:
303 return epcd;
304}
305
306/*
307 * Aim an rpipe to its device & endpoint destination
308 *
309 * Make sure we change the address to unauthenticathed if the device
310 * is WUSB and it is not authenticated.
311 */
312static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
313 struct usb_host_endpoint *ep, struct urb *urb, gfp_t gfp)
314{
315 int result = -ENOMSG; /* better code for lack of companion? */
316 struct device *dev = &wa->usb_iface->dev;
317 struct usb_device *usb_dev = urb->dev;
318 struct usb_wireless_ep_comp_descriptor *epcd;
319 u8 unauth;
320
321 epcd = rpipe_epc_find(dev, ep);
322 if (epcd == NULL) {
323 dev_err(dev, "ep 0x%02x: can't find companion descriptor\n",
324 ep->desc.bEndpointAddress);
325 goto error;
326 }
327 unauth = usb_dev->wusb && !usb_dev->authenticated ? 0x80 : 0;
328 __rpipe_reset(wa, le16_to_cpu(rpipe->descr.wRPipeIndex));
329 atomic_set(&rpipe->segs_available, le16_to_cpu(rpipe->descr.wRequests));
330 /* FIXME: block allocation system; request with queuing and timeout */
331 /* FIXME: compute so seg_size > ep->maxpktsize */
332 rpipe->descr.wBlocks = cpu_to_le16(16); /* given */
333 /* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */
334 rpipe->descr.wMaxPacketSize = cpu_to_le16(ep->desc.wMaxPacketSize);
335 rpipe->descr.bHSHubAddress = 0; /* reserved: zero */
336 rpipe->descr.bHSHubPort = wusb_port_no_to_idx(urb->dev->portnum);
337 /* FIXME: use maximum speed as supported or recommended by device */
338 rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
339 UWB_PHY_RATE_53 : UWB_PHY_RATE_200;
340
341 dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
342 urb->dev->devnum, urb->dev->devnum | unauth,
343 le16_to_cpu(rpipe->descr.wRPipeIndex),
344 usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);
345
346 /* see security.c:wusb_update_address() */
347 if (unlikely(urb->dev->devnum == 0x80))
348 rpipe->descr.bDeviceAddress = 0;
349 else
350 rpipe->descr.bDeviceAddress = urb->dev->devnum | unauth;
351 rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress;
352 /* FIXME: bDataSequence */
353 rpipe->descr.bDataSequence = 0;
354 /* FIXME: dwCurrentWindow */
355 rpipe->descr.dwCurrentWindow = cpu_to_le32(1);
356 /* FIXME: bMaxDataSequence */
357 rpipe->descr.bMaxDataSequence = epcd->bMaxSequence - 1;
358 rpipe->descr.bInterval = ep->desc.bInterval;
359 /* FIXME: bOverTheAirInterval */
360 rpipe->descr.bOverTheAirInterval = 0; /* 0 if not isoc */
361 /* FIXME: xmit power & preamble blah blah */
362 rpipe->descr.bmAttribute = ep->desc.bmAttributes & 0x03;
363 /* rpipe->descr.bmCharacteristics RO */
364 /* FIXME: bmRetryOptions */
365 rpipe->descr.bmRetryOptions = 15;
366 /* FIXME: use for assessing link quality? */
367 rpipe->descr.wNumTransactionErrors = 0;
368 result = __rpipe_set_descr(wa, &rpipe->descr,
369 le16_to_cpu(rpipe->descr.wRPipeIndex));
370 if (result < 0) {
371 dev_err(dev, "Cannot aim rpipe: %d\n", result);
372 goto error;
373 }
374 result = 0;
375error:
376 return result;
377}
378
379/*
380 * Check an aimed rpipe to make sure it points to where we want
381 *
382 * We use bit 19 of the Linux USB pipe bitmap for unauth vs auth
383 * space; when it is like that, we or 0x80 to make an unauth address.
384 */
385static int rpipe_check_aim(const struct wa_rpipe *rpipe, const struct wahc *wa,
386 const struct usb_host_endpoint *ep,
387 const struct urb *urb, gfp_t gfp)
388{
389 int result = 0; /* better code for lack of companion? */
390 struct device *dev = &wa->usb_iface->dev;
391 struct usb_device *usb_dev = urb->dev;
392 u8 unauth = (usb_dev->wusb && !usb_dev->authenticated) ? 0x80 : 0;
393 u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);
394
395#define AIM_CHECK(rdf, val, text) \
396 do { \
397 if (rpipe->descr.rdf != (val)) { \
398 dev_err(dev, \
399 "rpipe aim discrepancy: " #rdf " " text "\n", \
400 rpipe->descr.rdf, (val)); \
401 result = -EINVAL; \
402 WARN_ON(1); \
403 } \
404 } while (0)
405 AIM_CHECK(wMaxPacketSize, cpu_to_le16(ep->desc.wMaxPacketSize),
406 "(%u vs %u)");
407 AIM_CHECK(bHSHubPort, portnum, "(%u vs %u)");
408 AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ?
409 UWB_PHY_RATE_53 : UWB_PHY_RATE_200,
410 "(%u vs %u)");
411 AIM_CHECK(bDeviceAddress, urb->dev->devnum | unauth, "(%u vs %u)");
412 AIM_CHECK(bEndpointAddress, ep->desc.bEndpointAddress, "(%u vs %u)");
413 AIM_CHECK(bInterval, ep->desc.bInterval, "(%u vs %u)");
414 AIM_CHECK(bmAttribute, ep->desc.bmAttributes & 0x03, "(%u vs %u)");
415#undef AIM_CHECK
416 return result;
417}
418
419#ifndef CONFIG_BUG
420#define CONFIG_BUG 0
421#endif
422
423/*
424 * Make sure there is an rpipe allocated for an endpoint
425 *
426 * If already allocated, we just refcount it; if not, we get an
427 * idle one, aim it to the right location and take it.
428 *
429 * Attaches to ep->hcpriv and rpipe->ep to ep.
430 */
431int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep,
432 struct urb *urb, gfp_t gfp)
433{
434 int result = 0;
435 struct device *dev = &wa->usb_iface->dev;
436 struct wa_rpipe *rpipe;
437 u8 eptype;
438
439 mutex_lock(&wa->rpipe_mutex);
440 rpipe = ep->hcpriv;
441 if (rpipe != NULL) {
442 if (CONFIG_BUG == 1) {
443 result = rpipe_check_aim(rpipe, wa, ep, urb, gfp);
444 if (result < 0)
445 goto error;
446 }
447 __rpipe_get(rpipe);
448 dev_dbg(dev, "ep 0x%02x: reusing rpipe %u\n",
449 ep->desc.bEndpointAddress,
450 le16_to_cpu(rpipe->descr.wRPipeIndex));
451 } else {
452 /* hmm, assign idle rpipe, aim it */
453 result = -ENOBUFS;
454 eptype = ep->desc.bmAttributes & 0x03;
455 result = rpipe_get_idle(&rpipe, wa, 1 << eptype, gfp);
456 if (result < 0)
457 goto error;
458 result = rpipe_aim(rpipe, wa, ep, urb, gfp);
459 if (result < 0) {
460 rpipe_put(rpipe);
461 goto error;
462 }
463 ep->hcpriv = rpipe;
464 rpipe->ep = ep;
465 __rpipe_get(rpipe); /* for caching into ep->hcpriv */
466 dev_dbg(dev, "ep 0x%02x: using rpipe %u\n",
467 ep->desc.bEndpointAddress,
468 le16_to_cpu(rpipe->descr.wRPipeIndex));
469 }
470error:
471 mutex_unlock(&wa->rpipe_mutex);
472 return result;
473}
474
475/*
476 * Allocate the bitmap for each rpipe.
477 */
478int wa_rpipes_create(struct wahc *wa)
479{
480 wa->rpipes = wa->wa_descr->wNumRPipes;
481 wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long),
482 GFP_KERNEL);
483 if (wa->rpipe_bm == NULL)
484 return -ENOMEM;
485 return 0;
486}
487
488void wa_rpipes_destroy(struct wahc *wa)
489{
490 struct device *dev = &wa->usb_iface->dev;
491
492 if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) {
493 char buf[256];
494 WARN_ON(1);
495 bitmap_scnprintf(buf, sizeof(buf), wa->rpipe_bm, wa->rpipes);
496 dev_err(dev, "BUG: pipes not released on exit: %s\n", buf);
497 }
498 kfree(wa->rpipe_bm);
499}
500
501/*
502 * Release resources allocated for an endpoint
503 *
504 * If there is an associated rpipe to this endpoint, Abort any pending
505 * transfers and put it. If the rpipe ends up being destroyed,
506 * __rpipe_destroy() will cleanup ep->hcpriv.
507 *
508 * This is called before calling hcd->stop(), so you don't need to do
509 * anything else in there.
510 */
511void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
512{
513 struct wa_rpipe *rpipe;
514
515 mutex_lock(&wa->rpipe_mutex);
516 rpipe = ep->hcpriv;
517 if (rpipe != NULL) {
518 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
519
520 usb_control_msg(
521 wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
522 USB_REQ_RPIPE_ABORT,
523 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
524 0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
525 rpipe_put(rpipe);
526 }
527 mutex_unlock(&wa->rpipe_mutex);
528}
529EXPORT_SYMBOL_GPL(rpipe_ep_disable);