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