1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
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>
65
66#include "wusbhc.h"
67#include "wa-hc.h"
68
69static int __rpipe_get_descr(struct wahc *wa,
70 struct usb_rpipe_descriptor *descr, u16 index)
71{
72 ssize_t result;
73 struct device *dev = &wa->usb_iface->dev;
74
75
76
77
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 );
84 if (result < 0) {
85 dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
86 index, (int)result);
87 goto error;
88 }
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;
95 }
96 result = 0;
97
98error:
99 return result;
100}
101
102
103
104
105
106
107static int __rpipe_set_descr(struct wahc *wa,
108 struct usb_rpipe_descriptor *descr, u16 index)
109{
110 ssize_t result;
111 struct device *dev = &wa->usb_iface->dev;
112
113
114
115
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;
126 }
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;
133 }
134 result = 0;
135
136error:
137 return result;
138
139}
140
141static void rpipe_init(struct wa_rpipe *rpipe)
142{
143 kref_init(&rpipe->refcnt);
144 spin_lock_init(&rpipe->seg_lock);
145 INIT_LIST_HEAD(&rpipe->seg_list);
146}
147
148static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
149{
150 unsigned long flags;
151
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);
157
158 return rpipe_idx;
159}
160
161static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
162{
163 unsigned long flags;
164
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);
168}
169
170void rpipe_destroy(struct kref *_rpipe)
171{
172 struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
173 u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
174
175 if (rpipe->ep)
176 rpipe->ep->hcpriv = NULL;
177 rpipe_put_idx(rpipe->wa, index);
178 wa_put(rpipe->wa);
179 kfree(rpipe);
180}
181EXPORT_SYMBOL_GPL(rpipe_destroy);
182
183
184
185
186
187
188
189
190
191
192
193static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs,
194 gfp_t gfp)
195{
196 int result;
197 unsigned rpipe_idx;
198 struct wa_rpipe *rpipe;
199 struct device *dev = &wa->usb_iface->dev;
200
201 rpipe = kzalloc(sizeof(*rpipe), gfp);
202 if (rpipe == NULL)
203 return -ENOMEM;
204 rpipe_init(rpipe);
205
206
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)
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);
218 }
219 *prpipe = NULL;
220 kfree(rpipe);
221 return -ENXIO;
222
223found:
224 set_bit(rpipe_idx, wa->rpipe_bm);
225 rpipe->wa = wa_get(wa);
226 *prpipe = rpipe;
227 return 0;
228}
229
230static int __rpipe_reset(struct wahc *wa, unsigned index)
231{
232 int result;
233 struct device *dev = &wa->usb_iface->dev;
234
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 );
240 if (result < 0)
241 dev_err(dev, "rpipe %u: reset failed: %d\n",
242 index, result);
243 return result;
244}
245
246
247
248
249
250
251static struct usb_wireless_ep_comp_descriptor epc0 = {
252 .bLength = sizeof(epc0),
253 .bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP,
254 .bMaxBurst = 1,
255 .bMaxSequence = 2,
256};
257
258
259
260
261
262
263static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
264 struct device *dev, struct usb_host_endpoint *ep)
265{
266 void *itr;
267 size_t itr_size;
268 struct usb_descriptor_header *hdr;
269 struct usb_wireless_ep_comp_descriptor *epcd;
270
271 if (ep->desc.bEndpointAddress == 0) {
272 epcd = &epc0;
273 goto out;
274 }
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;
285 }
286 hdr = itr;
287 if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) {
288 epcd = itr;
289 break;
290 }
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;
299 }
300 itr += hdr->bLength;
301 itr_size -= hdr->bDescriptorType;
302 }
303out:
304 return epcd;
305}
306
307
308
309
310
311
312
313static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
314 struct usb_host_endpoint *ep, struct urb *urb, gfp_t gfp)
315{
316 int result = -ENOMSG;
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;
322
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;
328 }
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
333
334 rpipe->descr.wBlocks = cpu_to_le16(16);
335
336 rpipe->descr.wMaxPacketSize = cpu_to_le16(ep->desc.wMaxPacketSize);
337
338 rpipe->descr.hwa_bMaxBurst = max(min_t(unsigned int,
339 epcd->bMaxBurst, 16U), 1U);
340 rpipe->descr.hwa_bDeviceInfoIndex =
341 wusb_port_no_to_idx(urb->dev->portnum);
342
343 rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
344 UWB_PHY_RATE_53 : UWB_PHY_RATE_200;
345
346 dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
347 urb->dev->devnum, urb->dev->devnum | unauth,
348 le16_to_cpu(rpipe->descr.wRPipeIndex),
349 usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);
350
351 rpipe->descr.hwa_reserved = 0;
352
353 rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress;
354
355 rpipe->descr.bDataSequence = 0;
356
357
358 ack_window = 0xFFFFFFFF >> (32 - rpipe->descr.hwa_bMaxBurst);
359 rpipe->descr.dwCurrentWindow = cpu_to_le32(ack_window);
360 epcd_max_sequence = max(min_t(unsigned int,
361 epcd->bMaxSequence, 32U), 2U);
362 rpipe->descr.bMaxDataSequence = epcd_max_sequence - 1;
363 rpipe->descr.bInterval = ep->desc.bInterval;
364
365 rpipe->descr.bOverTheAirInterval = 0;
366
367 rpipe->descr.bmAttribute = (ep->desc.bmAttributes &
368 USB_ENDPOINT_XFERTYPE_MASK);
369
370 rpipe->descr.bmRetryOptions = (wa->wusb->retry_count & 0xF);
371
372 rpipe->descr.wNumTransactionErrors = 0;
373 result = __rpipe_set_descr(wa, &rpipe->descr,
374 le16_to_cpu(rpipe->descr.wRPipeIndex));
375 if (result < 0) {
376 dev_err(dev, "Cannot aim rpipe: %d\n", result);
377 goto error;
378 }
379 result = 0;
380error:
381 return result;
382}
383
384
385
386
387
388
389
390static int rpipe_check_aim(const struct wa_rpipe *rpipe, const struct wahc *wa,
391 const struct usb_host_endpoint *ep,
392 const struct urb *urb, gfp_t gfp)
393{
394 int result = 0;
395 struct device *dev = &wa->usb_iface->dev;
396 u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);
397
398#define AIM_CHECK(rdf, val, text) \
399 do { \
400 if (rpipe->descr.rdf != (val)) { \
401 dev_err(dev, \
402 "rpipe aim discrepancy: " #rdf " " text "\n", \
403 rpipe->descr.rdf, (val)); \
404 result = -EINVAL; \
405 WARN_ON(1); \
406 } \
407 } while (0)
408 AIM_CHECK(hwa_bDeviceInfoIndex, portnum, "(%u vs %u)");
409 AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ?
410 UWB_PHY_RATE_53 : UWB_PHY_RATE_200,
411 "(%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
425
426
427
428
429
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
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);
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
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
503
504
505
506
507
508
509
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 );
525 rpipe_put(rpipe);
526 }
527 mutex_unlock(&wa->rpipe_mutex);
528}
529EXPORT_SYMBOL_GPL(rpipe_ep_disable);
530
531
532void rpipe_clear_feature_stalled(struct wahc *wa, struct usb_host_endpoint *ep)
533{
534 struct wa_rpipe *rpipe;
535
536 mutex_lock(&wa->rpipe_mutex);
537 rpipe = ep->hcpriv;
538 if (rpipe != NULL) {
539 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
540
541 usb_control_msg(
542 wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
543 USB_REQ_CLEAR_FEATURE,
544 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
545 RPIPE_STALL, index, NULL, 0, 1000);
546 }
547 mutex_unlock(&wa->rpipe_mutex);
548}
549EXPORT_SYMBOL_GPL(rpipe_clear_feature_stalled);
550
551