atomic: use <linux/atomic.h>
[linux-2.6.git] / drivers / usb / wusbcore / wa-rpipe.c
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
68 static 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
97 error:
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  */
106 static 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
135 error:
136         return result;
137
138 }
139
140 static 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
147 static 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
160 static 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
169 void 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 }
180 EXPORT_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  */
192 static 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
222 found:
223         set_bit(rpipe_idx, wa->rpipe_bm);
224         rpipe->wa = wa_get(wa);
225         *prpipe = rpipe;
226         return 0;
227 }
228
229 static 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  */
250 static 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  */
262 static 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         }
302 out:
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  */
312 static 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;
375 error:
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  */
385 static 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  */
431 int 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         }
470 error:
471         mutex_unlock(&wa->rpipe_mutex);
472         return result;
473 }
474
475 /*
476  * Allocate the bitmap for each rpipe.
477  */
478 int 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
488 void 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  */
511 void 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 }
529 EXPORT_SYMBOL_GPL(rpipe_ep_disable);