x86/xen: resume timer irqs early
[linux/fpc-iii.git] / drivers / usb / wusbcore / wa-rpipe.c
blobb5e4fc19dec0b68124871c10623a43e4188d2def
1 /*
2 * WUSB Wire Adapter
3 * rpipe management
5 * Copyright (C) 2005-2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
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.
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.
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.
23 * FIXME: docs
25 * RPIPE
27 * Targeted at different downstream endpoints
29 * Descriptor: use to config the remote pipe.
31 * The number of blocks could be dynamic (wBlocks in descriptor is
32 * 0)--need to schedule them then.
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'.
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.
45 * Addresses:
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.
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)
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.
60 #include <linux/init.h>
61 #include <linux/atomic.h>
62 #include <linux/bitmap.h>
63 #include <linux/slab.h>
64 #include <linux/export.h>
66 #include "wusbhc.h"
67 #include "wa-hc.h"
69 static int __rpipe_get_descr(struct wahc *wa,
70 struct usb_rpipe_descriptor *descr, u16 index)
72 ssize_t result;
73 struct device *dev = &wa->usb_iface->dev;
75 /* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor()
76 * function because the arguments are different.
78 result = usb_control_msg(
79 wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
80 USB_REQ_GET_DESCRIPTOR,
81 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_RPIPE,
82 USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
83 1000 /* FIXME: arbitrary */);
84 if (result < 0) {
85 dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
86 index, (int)result);
87 goto error;
89 if (result < sizeof(*descr)) {
90 dev_err(dev, "rpipe %u: got short descriptor "
91 "(%zd vs %zd bytes needed)\n",
92 index, result, sizeof(*descr));
93 result = -EINVAL;
94 goto error;
96 result = 0;
98 error:
99 return result;
104 * The descriptor is assumed to be properly initialized (ie: you got
105 * it through __rpipe_get_descr()).
107 static int __rpipe_set_descr(struct wahc *wa,
108 struct usb_rpipe_descriptor *descr, u16 index)
110 ssize_t result;
111 struct device *dev = &wa->usb_iface->dev;
113 /* we cannot use the usb_get_descriptor() function because the
114 * arguments are different.
116 result = usb_control_msg(
117 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
118 USB_REQ_SET_DESCRIPTOR,
119 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
120 USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
121 HZ / 10);
122 if (result < 0) {
123 dev_err(dev, "rpipe %u: set descriptor failed: %d\n",
124 index, (int)result);
125 goto error;
127 if (result < sizeof(*descr)) {
128 dev_err(dev, "rpipe %u: sent short descriptor "
129 "(%zd vs %zd bytes required)\n",
130 index, result, sizeof(*descr));
131 result = -EINVAL;
132 goto error;
134 result = 0;
136 error:
137 return result;
141 static void rpipe_init(struct wa_rpipe *rpipe)
143 kref_init(&rpipe->refcnt);
144 spin_lock_init(&rpipe->seg_lock);
145 INIT_LIST_HEAD(&rpipe->seg_list);
148 static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
150 unsigned long flags;
152 spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
153 rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx);
154 if (rpipe_idx < wa->rpipes)
155 set_bit(rpipe_idx, wa->rpipe_bm);
156 spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags);
158 return rpipe_idx;
161 static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
163 unsigned long flags;
165 spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
166 clear_bit(rpipe_idx, wa->rpipe_bm);
167 spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags);
170 void rpipe_destroy(struct kref *_rpipe)
172 struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
173 u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
175 if (rpipe->ep)
176 rpipe->ep->hcpriv = NULL;
177 rpipe_put_idx(rpipe->wa, index);
178 wa_put(rpipe->wa);
179 kfree(rpipe);
181 EXPORT_SYMBOL_GPL(rpipe_destroy);
184 * Locate an idle rpipe, create an structure for it and return it
186 * @wa is referenced and unlocked
187 * @crs enum rpipe_attr, required endpoint characteristics
189 * The rpipe can be used only sequentially (not in parallel).
191 * The rpipe is moved into the "ready" state.
193 static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs,
194 gfp_t gfp)
196 int result;
197 unsigned rpipe_idx;
198 struct wa_rpipe *rpipe;
199 struct device *dev = &wa->usb_iface->dev;
201 rpipe = kzalloc(sizeof(*rpipe), gfp);
202 if (rpipe == NULL)
203 return -ENOMEM;
204 rpipe_init(rpipe);
206 /* Look for an idle pipe */
207 for (rpipe_idx = 0; rpipe_idx < wa->rpipes; rpipe_idx++) {
208 rpipe_idx = rpipe_get_idx(wa, rpipe_idx);
209 if (rpipe_idx >= wa->rpipes) /* no more pipes :( */
210 break;
211 result = __rpipe_get_descr(wa, &rpipe->descr, rpipe_idx);
212 if (result < 0)
213 dev_err(dev, "Can't get descriptor for rpipe %u: %d\n",
214 rpipe_idx, result);
215 else if ((rpipe->descr.bmCharacteristics & crs) != 0)
216 goto found;
217 rpipe_put_idx(wa, rpipe_idx);
219 *prpipe = NULL;
220 kfree(rpipe);
221 return -ENXIO;
223 found:
224 set_bit(rpipe_idx, wa->rpipe_bm);
225 rpipe->wa = wa_get(wa);
226 *prpipe = rpipe;
227 return 0;
230 static int __rpipe_reset(struct wahc *wa, unsigned index)
232 int result;
233 struct device *dev = &wa->usb_iface->dev;
235 result = usb_control_msg(
236 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
237 USB_REQ_RPIPE_RESET,
238 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
239 0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
240 if (result < 0)
241 dev_err(dev, "rpipe %u: reset failed: %d\n",
242 index, result);
243 return result;
247 * Fake companion descriptor for ep0
249 * See WUSB1.0[7.4.4], most of this is zero for bulk/int/ctl
251 static struct usb_wireless_ep_comp_descriptor epc0 = {
252 .bLength = sizeof(epc0),
253 .bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP,
254 .bMaxBurst = 1,
255 .bMaxSequence = 2,
259 * Look for EP companion descriptor
261 * Get there, look for Inara in the endpoint's extra descriptors
263 static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
264 struct device *dev, struct usb_host_endpoint *ep)
266 void *itr;
267 size_t itr_size;
268 struct usb_descriptor_header *hdr;
269 struct usb_wireless_ep_comp_descriptor *epcd;
271 if (ep->desc.bEndpointAddress == 0) {
272 epcd = &epc0;
273 goto out;
275 itr = ep->extra;
276 itr_size = ep->extralen;
277 epcd = NULL;
278 while (itr_size > 0) {
279 if (itr_size < sizeof(*hdr)) {
280 dev_err(dev, "HW Bug? ep 0x%02x: extra descriptors "
281 "at offset %zu: only %zu bytes left\n",
282 ep->desc.bEndpointAddress,
283 itr - (void *) ep->extra, itr_size);
284 break;
286 hdr = itr;
287 if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) {
288 epcd = itr;
289 break;
291 if (hdr->bLength > itr_size) {
292 dev_err(dev, "HW Bug? ep 0x%02x: extra descriptor "
293 "at offset %zu (type 0x%02x) "
294 "length %d but only %zu bytes left\n",
295 ep->desc.bEndpointAddress,
296 itr - (void *) ep->extra, hdr->bDescriptorType,
297 hdr->bLength, itr_size);
298 break;
300 itr += hdr->bLength;
301 itr_size -= hdr->bDescriptorType;
303 out:
304 return epcd;
308 * Aim an rpipe to its device & endpoint destination
310 * Make sure we change the address to unauthenticathed if the device
311 * is WUSB and it is not authenticated.
313 static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
314 struct usb_host_endpoint *ep, struct urb *urb, gfp_t gfp)
316 int result = -ENOMSG; /* better code for lack of companion? */
317 struct device *dev = &wa->usb_iface->dev;
318 struct usb_device *usb_dev = urb->dev;
319 struct usb_wireless_ep_comp_descriptor *epcd;
320 u32 ack_window, epcd_max_sequence;
321 u8 unauth;
323 epcd = rpipe_epc_find(dev, ep);
324 if (epcd == NULL) {
325 dev_err(dev, "ep 0x%02x: can't find companion descriptor\n",
326 ep->desc.bEndpointAddress);
327 goto error;
329 unauth = usb_dev->wusb && !usb_dev->authenticated ? 0x80 : 0;
330 __rpipe_reset(wa, le16_to_cpu(rpipe->descr.wRPipeIndex));
331 atomic_set(&rpipe->segs_available, le16_to_cpu(rpipe->descr.wRequests));
332 /* FIXME: block allocation system; request with queuing and timeout */
333 /* FIXME: compute so seg_size > ep->maxpktsize */
334 rpipe->descr.wBlocks = cpu_to_le16(16); /* given */
335 /* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */
336 if (usb_endpoint_xfer_isoc(&ep->desc))
337 rpipe->descr.wMaxPacketSize = epcd->wOverTheAirPacketSize;
338 else
339 rpipe->descr.wMaxPacketSize = ep->desc.wMaxPacketSize;
341 rpipe->descr.hwa_bMaxBurst = max(min_t(unsigned int,
342 epcd->bMaxBurst, 16U), 1U);
343 rpipe->descr.hwa_bDeviceInfoIndex =
344 wusb_port_no_to_idx(urb->dev->portnum);
345 /* FIXME: use maximum speed as supported or recommended by device */
346 rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
347 UWB_PHY_RATE_53 : UWB_PHY_RATE_200;
349 dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
350 urb->dev->devnum, urb->dev->devnum | unauth,
351 le16_to_cpu(rpipe->descr.wRPipeIndex),
352 usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);
354 rpipe->descr.hwa_reserved = 0;
356 rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress;
357 /* FIXME: bDataSequence */
358 rpipe->descr.bDataSequence = 0;
360 /* start with base window of hwa_bMaxBurst bits starting at 0. */
361 ack_window = 0xFFFFFFFF >> (32 - rpipe->descr.hwa_bMaxBurst);
362 rpipe->descr.dwCurrentWindow = cpu_to_le32(ack_window);
363 epcd_max_sequence = max(min_t(unsigned int,
364 epcd->bMaxSequence, 32U), 2U);
365 rpipe->descr.bMaxDataSequence = epcd_max_sequence - 1;
366 rpipe->descr.bInterval = ep->desc.bInterval;
367 /* FIXME: bOverTheAirInterval */
368 rpipe->descr.bOverTheAirInterval = 0; /* 0 if not isoc */
369 /* FIXME: xmit power & preamble blah blah */
370 rpipe->descr.bmAttribute = (ep->desc.bmAttributes &
371 USB_ENDPOINT_XFERTYPE_MASK);
372 /* rpipe->descr.bmCharacteristics RO */
373 rpipe->descr.bmRetryOptions = (wa->wusb->retry_count & 0xF);
374 /* FIXME: use for assessing link quality? */
375 rpipe->descr.wNumTransactionErrors = 0;
376 result = __rpipe_set_descr(wa, &rpipe->descr,
377 le16_to_cpu(rpipe->descr.wRPipeIndex));
378 if (result < 0) {
379 dev_err(dev, "Cannot aim rpipe: %d\n", result);
380 goto error;
382 result = 0;
383 error:
384 return result;
388 * Check an aimed rpipe to make sure it points to where we want
390 * We use bit 19 of the Linux USB pipe bitmap for unauth vs auth
391 * space; when it is like that, we or 0x80 to make an unauth address.
393 static int rpipe_check_aim(const struct wa_rpipe *rpipe, const struct wahc *wa,
394 const struct usb_host_endpoint *ep,
395 const struct urb *urb, gfp_t gfp)
397 int result = 0;
398 struct device *dev = &wa->usb_iface->dev;
399 u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);
401 #define AIM_CHECK(rdf, val, text) \
402 do { \
403 if (rpipe->descr.rdf != (val)) { \
404 dev_err(dev, \
405 "rpipe aim discrepancy: " #rdf " " text "\n", \
406 rpipe->descr.rdf, (val)); \
407 result = -EINVAL; \
408 WARN_ON(1); \
410 } while (0)
411 AIM_CHECK(hwa_bDeviceInfoIndex, portnum, "(%u vs %u)");
412 AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ?
413 UWB_PHY_RATE_53 : UWB_PHY_RATE_200,
414 "(%u vs %u)");
415 AIM_CHECK(bEndpointAddress, ep->desc.bEndpointAddress, "(%u vs %u)");
416 AIM_CHECK(bInterval, ep->desc.bInterval, "(%u vs %u)");
417 AIM_CHECK(bmAttribute, ep->desc.bmAttributes & 0x03, "(%u vs %u)");
418 #undef AIM_CHECK
419 return result;
422 #ifndef CONFIG_BUG
423 #define CONFIG_BUG 0
424 #endif
427 * Make sure there is an rpipe allocated for an endpoint
429 * If already allocated, we just refcount it; if not, we get an
430 * idle one, aim it to the right location and take it.
432 * Attaches to ep->hcpriv and rpipe->ep to ep.
434 int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep,
435 struct urb *urb, gfp_t gfp)
437 int result = 0;
438 struct device *dev = &wa->usb_iface->dev;
439 struct wa_rpipe *rpipe;
440 u8 eptype;
442 mutex_lock(&wa->rpipe_mutex);
443 rpipe = ep->hcpriv;
444 if (rpipe != NULL) {
445 if (CONFIG_BUG == 1) {
446 result = rpipe_check_aim(rpipe, wa, ep, urb, gfp);
447 if (result < 0)
448 goto error;
450 __rpipe_get(rpipe);
451 dev_dbg(dev, "ep 0x%02x: reusing rpipe %u\n",
452 ep->desc.bEndpointAddress,
453 le16_to_cpu(rpipe->descr.wRPipeIndex));
454 } else {
455 /* hmm, assign idle rpipe, aim it */
456 result = -ENOBUFS;
457 eptype = ep->desc.bmAttributes & 0x03;
458 result = rpipe_get_idle(&rpipe, wa, 1 << eptype, gfp);
459 if (result < 0)
460 goto error;
461 result = rpipe_aim(rpipe, wa, ep, urb, gfp);
462 if (result < 0) {
463 rpipe_put(rpipe);
464 goto error;
466 ep->hcpriv = rpipe;
467 rpipe->ep = ep;
468 __rpipe_get(rpipe); /* for caching into ep->hcpriv */
469 dev_dbg(dev, "ep 0x%02x: using rpipe %u\n",
470 ep->desc.bEndpointAddress,
471 le16_to_cpu(rpipe->descr.wRPipeIndex));
473 error:
474 mutex_unlock(&wa->rpipe_mutex);
475 return result;
479 * Allocate the bitmap for each rpipe.
481 int wa_rpipes_create(struct wahc *wa)
483 wa->rpipes = wa->wa_descr->wNumRPipes;
484 wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long),
485 GFP_KERNEL);
486 if (wa->rpipe_bm == NULL)
487 return -ENOMEM;
488 return 0;
491 void wa_rpipes_destroy(struct wahc *wa)
493 struct device *dev = &wa->usb_iface->dev;
495 if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) {
496 char buf[256];
497 WARN_ON(1);
498 bitmap_scnprintf(buf, sizeof(buf), wa->rpipe_bm, wa->rpipes);
499 dev_err(dev, "BUG: pipes not released on exit: %s\n", buf);
501 kfree(wa->rpipe_bm);
505 * Release resources allocated for an endpoint
507 * If there is an associated rpipe to this endpoint, Abort any pending
508 * transfers and put it. If the rpipe ends up being destroyed,
509 * __rpipe_destroy() will cleanup ep->hcpriv.
511 * This is called before calling hcd->stop(), so you don't need to do
512 * anything else in there.
514 void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
516 struct wa_rpipe *rpipe;
518 mutex_lock(&wa->rpipe_mutex);
519 rpipe = ep->hcpriv;
520 if (rpipe != NULL) {
521 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
523 usb_control_msg(
524 wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
525 USB_REQ_RPIPE_ABORT,
526 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
527 0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
528 rpipe_put(rpipe);
530 mutex_unlock(&wa->rpipe_mutex);
532 EXPORT_SYMBOL_GPL(rpipe_ep_disable);
534 /* Clear the stalled status of an RPIPE. */
535 void rpipe_clear_feature_stalled(struct wahc *wa, struct usb_host_endpoint *ep)
537 struct wa_rpipe *rpipe;
539 mutex_lock(&wa->rpipe_mutex);
540 rpipe = ep->hcpriv;
541 if (rpipe != NULL) {
542 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
544 usb_control_msg(
545 wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
546 USB_REQ_CLEAR_FEATURE,
547 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
548 RPIPE_STALL, index, NULL, 0, 1000);
550 mutex_unlock(&wa->rpipe_mutex);
552 EXPORT_SYMBOL_GPL(rpipe_clear_feature_stalled);