1 // Code for handling XHCI "Super speed" USB controllers.
2 //
3 // Copyright (C) 2013 Gerd Hoffmann <kraxel@redhat.com>
4 // Copyright (C) 2014 Kevin O'Connor <kevin@koconnor.net>
5 //
6 // This file may be distributed under the terms of the GNU LGPLv3 license.
7
8 #include "config.h" // CONFIG_*
9 #include "malloc.h" // memalign_low
10 #include "memmap.h" // PAGE_SIZE
11 #include "output.h" // dprintf
12 #include "pcidevice.h" // foreachpci
13 #include "pci_ids.h" // PCI_CLASS_SERIAL_USB_XHCI
14 #include "pci_regs.h" // PCI_BASE_ADDRESS_0
15 #include "string.h" // memcpy
16 #include "usb.h" // struct usb_s
17 #include "usb-xhci.h" // struct ehci_qh
18 #include "util.h" // timer_calc
19 #include "x86.h" // readl
20
21 // --------------------------------------------------------------
22 // configuration
23
24 #define XHCI_RING_ITEMS 16
25 #define XHCI_RING_SIZE (XHCI_RING_ITEMS*sizeof(struct xhci_trb))
26
27 /*
28 * xhci_ring structs are allocated with XHCI_RING_SIZE alignment,
29 * then we can get it from a trb pointer (provided by evt ring).
30 */
31 #define XHCI_RING(_trb) \
32 ((struct xhci_ring*)((u32)(_trb) & ~(XHCI_RING_SIZE-1)))
33
34 // --------------------------------------------------------------
35 // bit definitions
36
37 #define XHCI_CMD_RS (1<<0)
38 #define XHCI_CMD_HCRST (1<<1)
39 #define XHCI_CMD_INTE (1<<2)
40 #define XHCI_CMD_HSEE (1<<3)
41 #define XHCI_CMD_LHCRST (1<<7)
42 #define XHCI_CMD_CSS (1<<8)
43 #define XHCI_CMD_CRS (1<<9)
44 #define XHCI_CMD_EWE (1<<10)
45 #define XHCI_CMD_EU3S (1<<11)
46
47 #define XHCI_STS_HCH (1<<0)
48 #define XHCI_STS_HSE (1<<2)
49 #define XHCI_STS_EINT (1<<3)
50 #define XHCI_STS_PCD (1<<4)
51 #define XHCI_STS_SSS (1<<8)
52 #define XHCI_STS_RSS (1<<9)
53 #define XHCI_STS_SRE (1<<10)
54 #define XHCI_STS_CNR (1<<11)
55 #define XHCI_STS_HCE (1<<12)
56
57 #define XHCI_PORTSC_CCS (1<<0)
58 #define XHCI_PORTSC_PED (1<<1)
59 #define XHCI_PORTSC_OCA (1<<3)
60 #define XHCI_PORTSC_PR (1<<4)
61 #define XHCI_PORTSC_PLS_SHIFT 5
62 #define XHCI_PORTSC_PLS_MASK 0xf
63 #define XHCI_PORTSC_PP (1<<9)
64 #define XHCI_PORTSC_SPEED_SHIFT 10
65 #define XHCI_PORTSC_SPEED_MASK 0xf
66 #define XHCI_PORTSC_SPEED_FULL (1<<10)
67 #define XHCI_PORTSC_SPEED_LOW (2<<10)
68 #define XHCI_PORTSC_SPEED_HIGH (3<<10)
69 #define XHCI_PORTSC_SPEED_SUPER (4<<10)
70 #define XHCI_PORTSC_PIC_SHIFT 14
71 #define XHCI_PORTSC_PIC_MASK 0x3
72 #define XHCI_PORTSC_LWS (1<<16)
73 #define XHCI_PORTSC_CSC (1<<17)
74 #define XHCI_PORTSC_PEC (1<<18)
75 #define XHCI_PORTSC_WRC (1<<19)
76 #define XHCI_PORTSC_OCC (1<<20)
77 #define XHCI_PORTSC_PRC (1<<21)
78 #define XHCI_PORTSC_PLC (1<<22)
79 #define XHCI_PORTSC_CEC (1<<23)
80 #define XHCI_PORTSC_CAS (1<<24)
81 #define XHCI_PORTSC_WCE (1<<25)
82 #define XHCI_PORTSC_WDE (1<<26)
83 #define XHCI_PORTSC_WOE (1<<27)
84 #define XHCI_PORTSC_DR (1<<30)
85 #define XHCI_PORTSC_WPR (1<<31)
86
87 #define TRB_C (1<<0)
88 #define TRB_TYPE_SHIFT 10
89 #define TRB_TYPE_MASK 0x3f
90 #define TRB_TYPE(t) (((t) >> TRB_TYPE_SHIFT) & TRB_TYPE_MASK)
91
92 #define TRB_EV_ED (1<<2)
93
94 #define TRB_TR_ENT (1<<1)
95 #define TRB_TR_ISP (1<<2)
96 #define TRB_TR_NS (1<<3)
97 #define TRB_TR_CH (1<<4)
98 #define TRB_TR_IOC (1<<5)
99 #define TRB_TR_IDT (1<<6)
100 #define TRB_TR_TBC_SHIFT 7
101 #define TRB_TR_TBC_MASK 0x3
102 #define TRB_TR_BEI (1<<9)
103 #define TRB_TR_TLBPC_SHIFT 16
104 #define TRB_TR_TLBPC_MASK 0xf
105 #define TRB_TR_FRAMEID_SHIFT 20
106 #define TRB_TR_FRAMEID_MASK 0x7ff
107 #define TRB_TR_SIA (1<<31)
108
109 #define TRB_TR_DIR (1<<16)
110
111 #define TRB_CR_SLOTID_SHIFT 24
112 #define TRB_CR_SLOTID_MASK 0xff
113 #define TRB_CR_EPID_SHIFT 16
114 #define TRB_CR_EPID_MASK 0x1f
115
116 #define TRB_CR_BSR (1<<9)
117 #define TRB_CR_DC (1<<9)
118
119 #define TRB_LK_TC (1<<1)
120
121 #define TRB_INTR_SHIFT 22
122 #define TRB_INTR_MASK 0x3ff
123 #define TRB_INTR(t) (((t).status >> TRB_INTR_SHIFT) & TRB_INTR_MASK)
124
125 typedef enum TRBType {
126 TRB_RESERVED = 0,
127 TR_NORMAL,
128 TR_SETUP,
129 TR_DATA,
130 TR_STATUS,
131 TR_ISOCH,
132 TR_LINK,
133 TR_EVDATA,
134 TR_NOOP,
135 CR_ENABLE_SLOT,
136 CR_DISABLE_SLOT,
137 CR_ADDRESS_DEVICE,
138 CR_CONFIGURE_ENDPOINT,
139 CR_EVALUATE_CONTEXT,
140 CR_RESET_ENDPOINT,
141 CR_STOP_ENDPOINT,
142 CR_SET_TR_DEQUEUE,
143 CR_RESET_DEVICE,
144 CR_FORCE_EVENT,
145 CR_NEGOTIATE_BW,
146 CR_SET_LATENCY_TOLERANCE,
147 CR_GET_PORT_BANDWIDTH,
148 CR_FORCE_HEADER,
149 CR_NOOP,
150 ER_TRANSFER = 32,
151 ER_COMMAND_COMPLETE,
152 ER_PORT_STATUS_CHANGE,
153 ER_BANDWIDTH_REQUEST,
154 ER_DOORBELL,
155 ER_HOST_CONTROLLER,
156 ER_DEVICE_NOTIFICATION,
157 ER_MFINDEX_WRAP,
158 } TRBType;
159
160 typedef enum TRBCCode {
161 CC_INVALID = 0,
162 CC_SUCCESS,
163 CC_DATA_BUFFER_ERROR,
164 CC_BABBLE_DETECTED,
165 CC_USB_TRANSACTION_ERROR,
166 CC_TRB_ERROR,
167 CC_STALL_ERROR,
168 CC_RESOURCE_ERROR,
169 CC_BANDWIDTH_ERROR,
170 CC_NO_SLOTS_ERROR,
171 CC_INVALID_STREAM_TYPE_ERROR,
172 CC_SLOT_NOT_ENABLED_ERROR,
173 CC_EP_NOT_ENABLED_ERROR,
174 CC_SHORT_PACKET,
175 CC_RING_UNDERRUN,
176 CC_RING_OVERRUN,
177 CC_VF_ER_FULL,
178 CC_PARAMETER_ERROR,
179 CC_BANDWIDTH_OVERRUN,
180 CC_CONTEXT_STATE_ERROR,
181 CC_NO_PING_RESPONSE_ERROR,
182 CC_EVENT_RING_FULL_ERROR,
183 CC_INCOMPATIBLE_DEVICE_ERROR,
184 CC_MISSED_SERVICE_ERROR,
185 CC_COMMAND_RING_STOPPED,
186 CC_COMMAND_ABORTED,
187 CC_STOPPED,
188 CC_STOPPED_LENGTH_INVALID,
189 CC_MAX_EXIT_LATENCY_TOO_LARGE_ERROR = 29,
190 CC_ISOCH_BUFFER_OVERRUN = 31,
191 CC_EVENT_LOST_ERROR,
192 CC_UNDEFINED_ERROR,
193 CC_INVALID_STREAM_ID_ERROR,
194 CC_SECONDARY_BANDWIDTH_ERROR,
195 CC_SPLIT_TRANSACTION_ERROR
196 } TRBCCode;
197
198 enum {
199 PLS_U0 = 0,
200 PLS_U1 = 1,
201 PLS_U2 = 2,
202 PLS_U3 = 3,
203 PLS_DISABLED = 4,
204 PLS_RX_DETECT = 5,
205 PLS_INACTIVE = 6,
206 PLS_POLLING = 7,
207 PLS_RECOVERY = 8,
208 PLS_HOT_RESET = 9,
209 PLS_COMPILANCE_MODE = 10,
210 PLS_TEST_MODE = 11,
211 PLS_RESUME = 15,
212 };
213
214 #define xhci_get_field(data, field) \
215 (((data) >> field##_SHIFT) & field##_MASK)
216
217 // --------------------------------------------------------------
218 // state structs
219
220 struct xhci_ring {
221 struct xhci_trb ring[XHCI_RING_ITEMS];
222 struct xhci_trb evt;
223 u32 eidx;
224 u32 nidx;
225 u32 cs;
226 struct mutex_s lock;
227 };
228
229 struct xhci_portmap {
230 u8 start;
231 u8 count;
232 };
233
234 struct usb_xhci_s {
235 struct usb_s usb;
236
237 /* devinfo */
238 u32 xcap;
239 u32 ports;
240 u32 slots;
241 u8 context64;
242 struct xhci_portmap usb2;
243 struct xhci_portmap usb3;
244
245 /* xhci registers */
246 struct xhci_caps *caps;
247 struct xhci_op *op;
248 struct xhci_pr *pr;
249 struct xhci_ir *ir;
250 struct xhci_db *db;
251
252 /* xhci data structures */
253 struct xhci_devlist *devs;
254 struct xhci_ring *cmds;
255 struct xhci_ring *evts;
256 struct xhci_er_seg *eseg;
257 };
258
259 struct xhci_pipe {
260 struct xhci_ring reqs;
261
262 struct usb_pipe pipe;
263 u32 slotid;
264 u32 epid;
265 void *buf;
266 int bufused;
267 };
268
269 // --------------------------------------------------------------
270 // tables
271
272 static const char *speed_name[16] = {
273 [ 0 ] = " - ",
274 [ 1 ] = "Full",
275 [ 2 ] = "Low",
276 [ 3 ] = "High",
277 [ 4 ] = "Super",
278 };
279
280 static const int speed_from_xhci[16] = {
281 [ 0 ] = -1,
282 [ 1 ] = USB_FULLSPEED,
283 [ 2 ] = USB_LOWSPEED,
284 [ 3 ] = USB_HIGHSPEED,
285 [ 4 ] = USB_SUPERSPEED,
286 [ 5 ... 15 ] = -1,
287 };
288
289 static const int speed_to_xhci[] = {
290 [ USB_FULLSPEED ] = 1,
291 [ USB_LOWSPEED ] = 2,
292 [ USB_HIGHSPEED ] = 3,
293 [ USB_SUPERSPEED ] = 4,
294 };
295
wait_bit(u32 * reg,u32 mask,int value,u32 timeout)296 static int wait_bit(u32 *reg, u32 mask, int value, u32 timeout)
297 {
298 u32 end = timer_calc(timeout);
299
300 while ((readl(reg) & mask) != value) {
301 if (timer_check(end)) {
302 warn_timeout();
303 return -1;
304 }
305 yield();
306 }
307 return 0;
308 }
309
310
311 /****************************************************************
312 * Root hub
313 ****************************************************************/
314
315 #define XHCI_TIME_POSTPOWER 20
316
317 // Check if device attached to port
318 static void
xhci_print_port_state(int loglevel,const char * prefix,u32 port,u32 portsc)319 xhci_print_port_state(int loglevel, const char *prefix, u32 port, u32 portsc)
320 {
321 u32 pls = xhci_get_field(portsc, XHCI_PORTSC_PLS);
322 u32 speed = xhci_get_field(portsc, XHCI_PORTSC_SPEED);
323
324 dprintf(loglevel, "%s port #%d: 0x%08x,%s%s pls %d, speed %d [%s]\n",
325 prefix, port + 1, portsc,
326 (portsc & XHCI_PORTSC_PP) ? " powered," : "",
327 (portsc & XHCI_PORTSC_PED) ? " enabled," : "",
328 pls, speed, speed_name[speed]);
329 }
330
331 static int
xhci_hub_detect(struct usbhub_s * hub,u32 port)332 xhci_hub_detect(struct usbhub_s *hub, u32 port)
333 {
334 struct usb_xhci_s *xhci = container_of(hub->cntl, struct usb_xhci_s, usb);
335 u32 portsc = readl(&xhci->pr[port].portsc);
336 return (portsc & XHCI_PORTSC_CCS) ? 1 : 0;
337 }
338
339 // Reset device on port
340 static int
xhci_hub_reset(struct usbhub_s * hub,u32 port)341 xhci_hub_reset(struct usbhub_s *hub, u32 port)
342 {
343 struct usb_xhci_s *xhci = container_of(hub->cntl, struct usb_xhci_s, usb);
344 u32 portsc = readl(&xhci->pr[port].portsc);
345 if (!(portsc & XHCI_PORTSC_CCS))
346 // Device no longer connected?!
347 return -1;
348
349 switch (xhci_get_field(portsc, XHCI_PORTSC_PLS)) {
350 case PLS_U0:
351 // A USB3 port - controller automatically performs reset
352 break;
353 case PLS_POLLING:
354 // A USB2 port - perform device reset
355 xhci_print_port_state(3, __func__, port, portsc);
356 writel(&xhci->pr[port].portsc, portsc | XHCI_PORTSC_PR);
357 break;
358 default:
359 return -1;
360 }
361
362 // Wait for device to complete reset and be enabled
363 u32 end = timer_calc(100);
364 for (;;) {
365 portsc = readl(&xhci->pr[port].portsc);
366 if (!(portsc & XHCI_PORTSC_CCS))
367 // Device disconnected during reset
368 return -1;
369 if (portsc & XHCI_PORTSC_PED)
370 // Reset complete
371 break;
372 if (timer_check(end)) {
373 warn_timeout();
374 return -1;
375 }
376 yield();
377 }
378
379 int rc = speed_from_xhci[xhci_get_field(portsc, XHCI_PORTSC_SPEED)];
380 xhci_print_port_state(1, "XHCI", port, portsc);
381 return rc;
382 }
383
384 static int
xhci_hub_portmap(struct usbhub_s * hub,u32 vport)385 xhci_hub_portmap(struct usbhub_s *hub, u32 vport)
386 {
387 struct usb_xhci_s *xhci = container_of(hub->cntl, struct usb_xhci_s, usb);
388 u32 pport = vport + 1;
389
390 if (vport + 1 >= xhci->usb3.start &&
391 vport + 1 < xhci->usb3.start + xhci->usb3.count)
392 pport = vport + 2 - xhci->usb3.start;
393
394 if (vport + 1 >= xhci->usb2.start &&
395 vport + 1 < xhci->usb2.start + xhci->usb2.count)
396 pport = vport + 2 - xhci->usb2.start;
397
398 return pport;
399 }
400
401 static void
xhci_hub_disconnect(struct usbhub_s * hub,u32 port)402 xhci_hub_disconnect(struct usbhub_s *hub, u32 port)
403 {
404 // XXX - should turn the port power off.
405 }
406
407 static struct usbhub_op_s xhci_hub_ops = {
408 .detect = xhci_hub_detect,
409 .reset = xhci_hub_reset,
410 .portmap = xhci_hub_portmap,
411 .disconnect = xhci_hub_disconnect,
412 };
413
414 // Find any devices connected to the root hub.
415 static int
xhci_check_ports(struct usb_xhci_s * xhci)416 xhci_check_ports(struct usb_xhci_s *xhci)
417 {
418 // Wait for port power to stabilize.
419 msleep(XHCI_TIME_POSTPOWER);
420
421 struct usbhub_s hub;
422 memset(&hub, 0, sizeof(hub));
423 hub.cntl = &xhci->usb;
424 hub.portcount = xhci->ports;
425 hub.op = &xhci_hub_ops;
426 usb_enumerate(&hub);
427 return hub.devcount;
428 }
429
430
431 /****************************************************************
432 * Setup
433 ****************************************************************/
434
435 static void
xhci_free_pipes(struct usb_xhci_s * xhci)436 xhci_free_pipes(struct usb_xhci_s *xhci)
437 {
438 // XXX - should walk list of pipes and free unused pipes.
439 }
440
441 static void
configure_xhci(void * data)442 configure_xhci(void *data)
443 {
444 struct usb_xhci_s *xhci = data;
445 u32 reg;
446
447 xhci->devs = memalign_high(64, sizeof(*xhci->devs) * (xhci->slots + 1));
448 xhci->eseg = memalign_high(64, sizeof(*xhci->eseg));
449 xhci->cmds = memalign_high(XHCI_RING_SIZE, sizeof(*xhci->cmds));
450 xhci->evts = memalign_high(XHCI_RING_SIZE, sizeof(*xhci->evts));
451 if (!xhci->devs || !xhci->cmds || !xhci->evts || !xhci->eseg) {
452 warn_noalloc();
453 goto fail;
454 }
455 memset(xhci->devs, 0, sizeof(*xhci->devs) * (xhci->slots + 1));
456 memset(xhci->cmds, 0, sizeof(*xhci->cmds));
457 memset(xhci->evts, 0, sizeof(*xhci->evts));
458 memset(xhci->eseg, 0, sizeof(*xhci->eseg));
459
460 reg = readl(&xhci->op->usbcmd);
461 if (reg & XHCI_CMD_RS) {
462 reg &= ~XHCI_CMD_RS;
463 writel(&xhci->op->usbcmd, reg);
464 if (wait_bit(&xhci->op->usbsts, XHCI_STS_HCH, XHCI_STS_HCH, 32) != 0)
465 goto fail;
466 }
467
468 dprintf(3, "%s: resetting\n", __func__);
469 writel(&xhci->op->usbcmd, XHCI_CMD_HCRST);
470 if (wait_bit(&xhci->op->usbcmd, XHCI_CMD_HCRST, 0, 100) != 0)
471 goto fail;
472 if (wait_bit(&xhci->op->usbsts, XHCI_STS_CNR, 0, 100) != 0)
473 goto fail;
474
475 writel(&xhci->op->config, xhci->slots);
476 writel(&xhci->op->dcbaap_low, (u32)xhci->devs);
477 writel(&xhci->op->dcbaap_high, 0);
478 writel(&xhci->op->crcr_low, (u32)xhci->cmds | 1);
479 writel(&xhci->op->crcr_high, 0);
480 xhci->cmds->cs = 1;
481
482 xhci->eseg->ptr_low = (u32)xhci->evts;
483 xhci->eseg->ptr_high = 0;
484 xhci->eseg->size = XHCI_RING_ITEMS;
485 writel(&xhci->ir->erstsz, 1);
486 writel(&xhci->ir->erdp_low, (u32)xhci->evts);
487 writel(&xhci->ir->erdp_high, 0);
488 writel(&xhci->ir->erstba_low, (u32)xhci->eseg);
489 writel(&xhci->ir->erstba_high, 0);
490 xhci->evts->cs = 1;
491
492 reg = readl(&xhci->caps->hcsparams2);
493 u32 spb = (reg >> 21 & 0x1f) << 5 | reg >> 27;
494 if (spb) {
495 dprintf(3, "%s: setup %d scratch pad buffers\n", __func__, spb);
496 u64 *spba = memalign_high(64, sizeof(*spba) * spb);
497 void *pad = memalign_high(PAGE_SIZE, PAGE_SIZE * spb);
498 if (!spba || !pad) {
499 warn_noalloc();
500 free(spba);
501 free(pad);
502 goto fail;
503 }
504 int i;
505 for (i = 0; i < spb; i++)
506 spba[i] = (u32)pad + (i * PAGE_SIZE);
507 xhci->devs[0].ptr_low = (u32)spba;
508 xhci->devs[0].ptr_high = 0;
509 }
510
511 reg = readl(&xhci->op->usbcmd);
512 reg |= XHCI_CMD_RS;
513 writel(&xhci->op->usbcmd, reg);
514
515 // Find devices
516 int count = xhci_check_ports(xhci);
517 xhci_free_pipes(xhci);
518 if (count)
519 // Success
520 return;
521
522 // No devices found - shutdown and free controller.
523 dprintf(1, "XHCI no devices found\n");
524 reg = readl(&xhci->op->usbcmd);
525 reg &= ~XHCI_CMD_RS;
526 writel(&xhci->op->usbcmd, reg);
527 wait_bit(&xhci->op->usbsts, XHCI_STS_HCH, XHCI_STS_HCH, 32);
528
529 fail:
530 free(xhci->eseg);
531 free(xhci->evts);
532 free(xhci->cmds);
533 free(xhci->devs);
534 free(xhci);
535 }
536
537 static void
xhci_controller_setup(struct pci_device * pci)538 xhci_controller_setup(struct pci_device *pci)
539 {
540 void *baseaddr = pci_enable_membar(pci, PCI_BASE_ADDRESS_0);
541 if (!baseaddr)
542 return;
543
544 struct usb_xhci_s *xhci = malloc_high(sizeof(*xhci));
545 if (!xhci) {
546 warn_noalloc();
547 return;
548 }
549 memset(xhci, 0, sizeof(*xhci));
550 xhci->caps = baseaddr;
551 xhci->op = baseaddr + readb(&xhci->caps->caplength);
552 xhci->pr = baseaddr + readb(&xhci->caps->caplength) + 0x400;
553 xhci->db = baseaddr + readl(&xhci->caps->dboff);
554 xhci->ir = baseaddr + readl(&xhci->caps->rtsoff) + 0x20;
555
556 u32 hcs1 = readl(&xhci->caps->hcsparams1);
557 u32 hcc = readl(&xhci->caps->hccparams);
558 xhci->ports = (hcs1 >> 24) & 0xff;
559 xhci->slots = hcs1 & 0xff;
560 xhci->xcap = ((hcc >> 16) & 0xffff) << 2;
561 xhci->context64 = (hcc & 0x04) ? 1 : 0;
562
563 xhci->usb.pci = pci;
564 xhci->usb.type = USB_TYPE_XHCI;
565
566 dprintf(1, "XHCI init on dev %pP: regs @ %p, %d ports, %d slots"
567 ", %d byte contexts\n"
568 , pci, xhci->caps, xhci->ports, xhci->slots
569 , xhci->context64 ? 64 : 32);
570
571 if (xhci->xcap) {
572 u32 off;
573 void *addr = baseaddr + xhci->xcap;
574 do {
575 struct xhci_xcap *xcap = addr;
576 u32 ports, name, cap = readl(&xcap->cap);
577 switch (cap & 0xff) {
578 case 0x02:
579 name = readl(&xcap->data[0]);
580 ports = readl(&xcap->data[1]);
581 u8 major = (cap >> 24) & 0xff;
582 u8 minor = (cap >> 16) & 0xff;
583 u8 count = (ports >> 8) & 0xff;
584 u8 start = (ports >> 0) & 0xff;
585 dprintf(1, "XHCI protocol %c%c%c%c %x.%02x"
586 ", %d ports (offset %d), def %x\n"
587 , (name >> 0) & 0xff
588 , (name >> 8) & 0xff
589 , (name >> 16) & 0xff
590 , (name >> 24) & 0xff
591 , major, minor
592 , count, start
593 , ports >> 16);
594 if (name == 0x20425355 /* "USB " */) {
595 if (major == 2) {
596 xhci->usb2.start = start;
597 xhci->usb2.count = count;
598 }
599 if (major == 3) {
600 xhci->usb3.start = start;
601 xhci->usb3.count = count;
602 }
603 }
604 break;
605 default:
606 dprintf(1, "XHCI extcap 0x%x @ %p\n", cap & 0xff, addr);
607 break;
608 }
609 off = (cap >> 8) & 0xff;
610 addr += off << 2;
611 } while (off > 0);
612 }
613
614 u32 pagesize = readl(&xhci->op->pagesize);
615 if (PAGE_SIZE != (pagesize<<12)) {
616 dprintf(1, "XHCI driver does not support page size code %d\n"
617 , pagesize<<12);
618 free(xhci);
619 return;
620 }
621
622 pci_enable_busmaster(pci);
623
624 run_thread(configure_xhci, xhci);
625 }
626
627 void
xhci_setup(void)628 xhci_setup(void)
629 {
630 if (! CONFIG_USB_XHCI)
631 return;
632 struct pci_device *pci;
633 foreachpci(pci) {
634 if (pci_classprog(pci) == PCI_CLASS_SERIAL_USB_XHCI)
635 xhci_controller_setup(pci);
636 }
637 }
638
639
640 /****************************************************************
641 * End point communication
642 ****************************************************************/
643
xhci_doorbell(struct usb_xhci_s * xhci,u32 slotid,u32 value)644 static void xhci_doorbell(struct usb_xhci_s *xhci, u32 slotid, u32 value)
645 {
646 struct xhci_db *db = xhci->db;
647 void *addr = &db[slotid].doorbell;
648 writel(addr, value);
649 }
650
xhci_process_events(struct usb_xhci_s * xhci)651 static void xhci_process_events(struct usb_xhci_s *xhci)
652 {
653 struct xhci_ring *evts = xhci->evts;
654
655 for (;;) {
656 /* check for event */
657 u32 nidx = evts->nidx;
658 u32 cs = evts->cs;
659 struct xhci_trb *etrb = evts->ring + nidx;
660 u32 control = etrb->control;
661 if ((control & TRB_C) != (cs ? 1 : 0))
662 return;
663
664 /* process event */
665 u32 evt_type = TRB_TYPE(control);
666 u32 evt_cc = (etrb->status >> 24) & 0xff;
667 switch (evt_type) {
668 case ER_TRANSFER:
669 case ER_COMMAND_COMPLETE:
670 {
671 struct xhci_trb *rtrb = (void*)etrb->ptr_low;
672 struct xhci_ring *ring = XHCI_RING(rtrb);
673 struct xhci_trb *evt = &ring->evt;
674 u32 eidx = rtrb - ring->ring + 1;
675 dprintf(5, "%s: ring %p [trb %p, evt %p, type %d, eidx %d, cc %d]\n",
676 __func__, ring, rtrb, evt, evt_type, eidx, evt_cc);
677 memcpy(evt, etrb, sizeof(*etrb));
678 ring->eidx = eidx;
679 break;
680 }
681 case ER_PORT_STATUS_CHANGE:
682 {
683 u32 port = ((etrb->ptr_low >> 24) & 0xff) - 1;
684 // Read status, and clear port status change bits
685 u32 portsc = readl(&xhci->pr[port].portsc);
686 u32 pclear = (((portsc & ~(XHCI_PORTSC_PED|XHCI_PORTSC_PR))
687 & ~(XHCI_PORTSC_PLS_MASK<<XHCI_PORTSC_PLS_SHIFT))
688 | (1<<XHCI_PORTSC_PLS_SHIFT));
689 writel(&xhci->pr[port].portsc, pclear);
690
691 xhci_print_port_state(3, __func__, port, portsc);
692 break;
693 }
694 default:
695 dprintf(1, "%s: unknown event, type %d, cc %d\n",
696 __func__, evt_type, evt_cc);
697 break;
698 }
699
700 /* move ring index, notify xhci */
701 nidx++;
702 if (nidx == XHCI_RING_ITEMS) {
703 nidx = 0;
704 cs = cs ? 0 : 1;
705 evts->cs = cs;
706 }
707 evts->nidx = nidx;
708 struct xhci_ir *ir = xhci->ir;
709 u32 erdp = (u32)(evts->ring + nidx);
710 writel(&ir->erdp_low, erdp);
711 writel(&ir->erdp_high, 0);
712 }
713 }
714
xhci_ring_busy(struct xhci_ring * ring)715 static int xhci_ring_busy(struct xhci_ring *ring)
716 {
717 u32 eidx = ring->eidx;
718 u32 nidx = ring->nidx;
719 return (eidx != nidx);
720 }
721
xhci_event_wait(struct usb_xhci_s * xhci,struct xhci_ring * ring,u32 timeout)722 static int xhci_event_wait(struct usb_xhci_s *xhci,
723 struct xhci_ring *ring,
724 u32 timeout)
725 {
726 u32 end = timer_calc(timeout);
727
728 for (;;) {
729 xhci_process_events(xhci);
730 if (!xhci_ring_busy(ring)) {
731 u32 status = ring->evt.status;
732 return (status >> 24) & 0xff;
733 }
734 if (timer_check(end)) {
735 warn_timeout();
736 return -1;
737 }
738 yield();
739 }
740 }
741
xhci_trb_queue(struct xhci_ring * ring,struct xhci_trb * trb)742 static void xhci_trb_queue(struct xhci_ring *ring,
743 struct xhci_trb *trb)
744 {
745 u32 nidx = ring->nidx;
746 u32 cs = ring->cs;
747 struct xhci_trb *dst;
748 u32 control;
749
750 if (nidx == XHCI_RING_ITEMS-1) {
751 dst = ring->ring + nidx;
752 control = (TR_LINK << 10); // trb type
753 control |= TRB_LK_TC;
754 control |= (cs ? TRB_C : 0);
755 dst->ptr_low = (u32)&ring[0];
756 dst->ptr_high = 0;
757 dst->status = 0;
758 dst->control = control;
759 nidx = 0;
760 cs = cs ? 0 : 1;
761 ring->nidx = nidx;
762 ring->cs = cs;
763
764 dprintf(5, "%s: ring %p [linked]\n", __func__, ring);
765 }
766
767 dst = ring->ring + nidx;
768 control = trb->control | (cs ? TRB_C : 0);
769
770 dst->ptr_low = trb->ptr_low;
771 dst->ptr_high = trb->ptr_high;
772 dst->status = trb->status;
773 dst->control = control;
774 nidx++;
775 ring->nidx = nidx;
776
777 dprintf(5, "%s: ring %p [nidx %d, len %d]\n",
778 __func__, ring, nidx,
779 trb->status & 0xffff);
780 }
781
xhci_cmd_submit(struct usb_xhci_s * xhci,struct xhci_trb * cmd)782 static int xhci_cmd_submit(struct usb_xhci_s *xhci,
783 struct xhci_trb *cmd)
784 {
785 int rc;
786
787 mutex_lock(&xhci->cmds->lock);
788 xhci_trb_queue(xhci->cmds, cmd);
789 xhci_doorbell(xhci, 0, 0);
790 rc = xhci_event_wait(xhci, xhci->cmds, 1000);
791 mutex_unlock(&xhci->cmds->lock);
792 return rc;
793 }
794
xhci_cmd_enable_slot(struct usb_xhci_s * xhci)795 static int xhci_cmd_enable_slot(struct usb_xhci_s *xhci)
796 {
797 struct xhci_trb cmd = {
798 .ptr_low = 0,
799 .ptr_high = 0,
800 .status = 0,
801 .control = (CR_ENABLE_SLOT << 10)
802 };
803 dprintf(3, "%s:\n", __func__);
804 int cc = xhci_cmd_submit(xhci, &cmd);
805 if (cc != CC_SUCCESS)
806 return -1;
807 return (xhci->cmds->evt.control >> 24) & 0xff;
808 }
809
xhci_cmd_disable_slot(struct usb_xhci_s * xhci,u32 slotid)810 static int xhci_cmd_disable_slot(struct usb_xhci_s *xhci, u32 slotid)
811 {
812 struct xhci_trb cmd = {
813 .ptr_low = 0,
814 .ptr_high = 0,
815 .status = 0,
816 .control = (slotid << 24) | (CR_DISABLE_SLOT << 10)
817 };
818 dprintf(3, "%s: slotid %d\n", __func__, slotid);
819 return xhci_cmd_submit(xhci, &cmd);
820 }
821
xhci_cmd_address_device(struct usb_xhci_s * xhci,u32 slotid,struct xhci_inctx * inctx)822 static int xhci_cmd_address_device(struct usb_xhci_s *xhci, u32 slotid
823 , struct xhci_inctx *inctx)
824 {
825 struct xhci_trb cmd = {
826 .ptr_low = (u32)inctx,
827 .ptr_high = 0,
828 .status = 0,
829 .control = (slotid << 24) | (CR_ADDRESS_DEVICE << 10)
830 };
831 dprintf(3, "%s: slotid %d\n", __func__, slotid);
832 return xhci_cmd_submit(xhci, &cmd);
833 }
834
xhci_cmd_configure_endpoint(struct usb_xhci_s * xhci,u32 slotid,struct xhci_inctx * inctx)835 static int xhci_cmd_configure_endpoint(struct usb_xhci_s *xhci, u32 slotid
836 , struct xhci_inctx *inctx)
837 {
838 struct xhci_trb cmd = {
839 .ptr_low = (u32)inctx,
840 .ptr_high = 0,
841 .status = 0,
842 .control = (slotid << 24) | (CR_CONFIGURE_ENDPOINT << 10)
843 };
844 dprintf(3, "%s: slotid %d, add 0x%x, del 0x%x\n", __func__,
845 slotid, inctx->add, inctx->del);
846 return xhci_cmd_submit(xhci, &cmd);
847 }
848
xhci_cmd_evaluate_context(struct usb_xhci_s * xhci,u32 slotid,struct xhci_inctx * inctx)849 static int xhci_cmd_evaluate_context(struct usb_xhci_s *xhci, u32 slotid
850 , struct xhci_inctx *inctx)
851 {
852 struct xhci_trb cmd = {
853 .ptr_low = (u32)inctx,
854 .ptr_high = 0,
855 .status = 0,
856 .control = (slotid << 24) | (CR_EVALUATE_CONTEXT << 10)
857 };
858 dprintf(3, "%s: slotid %d, add 0x%x, del 0x%x\n", __func__,
859 slotid, inctx->add, inctx->del);
860 return xhci_cmd_submit(xhci, &cmd);
861 }
862
863 static struct xhci_inctx *
xhci_alloc_inctx(struct usbdevice_s * usbdev,int maxepid)864 xhci_alloc_inctx(struct usbdevice_s *usbdev, int maxepid)
865 {
866 struct usb_xhci_s *xhci = container_of(
867 usbdev->hub->cntl, struct usb_xhci_s, usb);
868 int size = (sizeof(struct xhci_inctx) * 33) << xhci->context64;
869 struct xhci_inctx *in = memalign_tmphigh(2048 << xhci->context64, size);
870 if (!in) {
871 warn_noalloc();
872 return NULL;
873 }
874 memset(in, 0, size);
875
876 struct xhci_slotctx *slot = (void*)&in[1 << xhci->context64];
877 slot->ctx[0] |= maxepid << 27; // context entries
878 slot->ctx[0] |= speed_to_xhci[usbdev->speed] << 20;
879
880 // Set high-speed hub flags.
881 struct usbdevice_s *hubdev = usbdev->hub->usbdev;
882 if (hubdev) {
883 if (usbdev->speed == USB_LOWSPEED || usbdev->speed == USB_FULLSPEED) {
884 struct xhci_pipe *hpipe = container_of(
885 hubdev->defpipe, struct xhci_pipe, pipe);
886 if (hubdev->speed == USB_HIGHSPEED) {
887 slot->ctx[2] |= hpipe->slotid;
888 slot->ctx[2] |= (usbdev->port+1) << 8;
889 } else {
890 struct xhci_slotctx *hslot = (void*)xhci->devs[hpipe->slotid].ptr_low;
891 slot->ctx[2] = hslot->ctx[2];
892 }
893 }
894 u32 route = 0;
895 while (usbdev->hub->usbdev) {
896 route <<= 4;
897 route |= (usbdev->port+1) & 0xf;
898 usbdev = usbdev->hub->usbdev;
899 }
900 slot->ctx[0] |= route;
901 }
902
903 slot->ctx[1] |= (usbdev->port+1) << 16;
904
905 return in;
906 }
907
xhci_config_hub(struct usbhub_s * hub)908 static int xhci_config_hub(struct usbhub_s *hub)
909 {
910 struct usb_xhci_s *xhci = container_of(
911 hub->cntl, struct usb_xhci_s, usb);
912 struct xhci_pipe *pipe = container_of(
913 hub->usbdev->defpipe, struct xhci_pipe, pipe);
914 struct xhci_slotctx *hdslot = (void*)xhci->devs[pipe->slotid].ptr_low;
915 if ((hdslot->ctx[3] >> 27) == 3)
916 // Already configured
917 return 0;
918 struct xhci_inctx *in = xhci_alloc_inctx(hub->usbdev, 1);
919 if (!in)
920 return -1;
921 in->add = 0x01;
922 struct xhci_slotctx *slot = (void*)&in[1 << xhci->context64];
923 slot->ctx[0] |= 1 << 26;
924 slot->ctx[1] |= hub->portcount << 24;
925
926 int cc = xhci_cmd_configure_endpoint(xhci, pipe->slotid, in);
927 free(in);
928 if (cc != CC_SUCCESS) {
929 dprintf(1, "%s: configure hub: failed (cc %d)\n", __func__, cc);
930 return -1;
931 }
932 return 0;
933 }
934
935 static struct usb_pipe *
xhci_alloc_pipe(struct usbdevice_s * usbdev,struct usb_endpoint_descriptor * epdesc)936 xhci_alloc_pipe(struct usbdevice_s *usbdev
937 , struct usb_endpoint_descriptor *epdesc)
938 {
939 u8 eptype = epdesc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
940 struct usb_xhci_s *xhci = container_of(
941 usbdev->hub->cntl, struct usb_xhci_s, usb);
942 struct xhci_pipe *pipe;
943 u32 epid;
944
945 if (epdesc->bEndpointAddress == 0) {
946 epid = 1;
947 } else {
948 epid = (epdesc->bEndpointAddress & 0x0f) * 2;
949 epid += (epdesc->bEndpointAddress & USB_DIR_IN) ? 1 : 0;
950 }
951
952 if (eptype == USB_ENDPOINT_XFER_CONTROL)
953 pipe = memalign_high(XHCI_RING_SIZE, sizeof(*pipe));
954 else
955 pipe = memalign_low(XHCI_RING_SIZE, sizeof(*pipe));
956 if (!pipe) {
957 warn_noalloc();
958 return NULL;
959 }
960 memset(pipe, 0, sizeof(*pipe));
961
962 usb_desc2pipe(&pipe->pipe, usbdev, epdesc);
963 pipe->epid = epid;
964 pipe->reqs.cs = 1;
965 if (eptype == USB_ENDPOINT_XFER_INT) {
966 pipe->buf = malloc_high(pipe->pipe.maxpacket);
967 if (!pipe->buf) {
968 warn_noalloc();
969 free(pipe);
970 return NULL;
971 }
972 }
973
974 // Allocate input context and initialize endpoint info.
975 struct xhci_inctx *in = xhci_alloc_inctx(usbdev, epid);
976 if (!in)
977 goto fail;
978 in->add = 0x01 | (1 << epid);
979 struct xhci_epctx *ep = (void*)&in[(pipe->epid+1) << xhci->context64];
980 if (eptype == USB_ENDPOINT_XFER_INT)
981 ep->ctx[0] = (usb_get_period(usbdev, epdesc) + 3) << 16;
982 ep->ctx[1] |= eptype << 3;
983 if (epdesc->bEndpointAddress & USB_DIR_IN
984 || eptype == USB_ENDPOINT_XFER_CONTROL)
985 ep->ctx[1] |= 1 << 5;
986 ep->ctx[1] |= pipe->pipe.maxpacket << 16;
987 ep->deq_low = (u32)&pipe->reqs.ring[0];
988 ep->deq_low |= 1; // dcs
989 ep->length = pipe->pipe.maxpacket;
990
991 dprintf(3, "%s: usbdev %p, ring %p, slotid %d, epid %d\n", __func__,
992 usbdev, &pipe->reqs, pipe->slotid, pipe->epid);
993 if (pipe->epid == 1) {
994 if (usbdev->hub->usbdev) {
995 // Make sure parent hub is configured.
996 int ret = xhci_config_hub(usbdev->hub);
997 if (ret)
998 goto fail;
999 }
1000 // Enable slot.
1001 u32 size = (sizeof(struct xhci_slotctx) * 32) << xhci->context64;
1002 struct xhci_slotctx *dev = memalign_high(1024 << xhci->context64, size);
1003 if (!dev) {
1004 warn_noalloc();
1005 goto fail;
1006 }
1007 int slotid = xhci_cmd_enable_slot(xhci);
1008 if (slotid < 0) {
1009 dprintf(1, "%s: enable slot: failed\n", __func__);
1010 free(dev);
1011 goto fail;
1012 }
1013 dprintf(3, "%s: enable slot: got slotid %d\n", __func__, slotid);
1014 memset(dev, 0, size);
1015 xhci->devs[slotid].ptr_low = (u32)dev;
1016 xhci->devs[slotid].ptr_high = 0;
1017
1018 // Send set_address command.
1019 int cc = xhci_cmd_address_device(xhci, slotid, in);
1020 if (cc != CC_SUCCESS) {
1021 dprintf(1, "%s: address device: failed (cc %d)\n", __func__, cc);
1022 cc = xhci_cmd_disable_slot(xhci, slotid);
1023 if (cc != CC_SUCCESS) {
1024 dprintf(1, "%s: disable failed (cc %d)\n", __func__, cc);
1025 goto fail;
1026 }
1027 xhci->devs[slotid].ptr_low = 0;
1028 free(dev);
1029 goto fail;
1030 }
1031 pipe->slotid = slotid;
1032 } else {
1033 struct xhci_pipe *defpipe = container_of(
1034 usbdev->defpipe, struct xhci_pipe, pipe);
1035 pipe->slotid = defpipe->slotid;
1036 // Send configure command.
1037 int cc = xhci_cmd_configure_endpoint(xhci, pipe->slotid, in);
1038 if (cc != CC_SUCCESS) {
1039 dprintf(1, "%s: configure endpoint: failed (cc %d)\n", __func__, cc);
1040 goto fail;
1041 }
1042 }
1043 free(in);
1044 return &pipe->pipe;
1045
1046 fail:
1047 free(pipe->buf);
1048 free(pipe);
1049 free(in);
1050 return NULL;
1051 }
1052
1053 struct usb_pipe *
xhci_realloc_pipe(struct usbdevice_s * usbdev,struct usb_pipe * upipe,struct usb_endpoint_descriptor * epdesc)1054 xhci_realloc_pipe(struct usbdevice_s *usbdev, struct usb_pipe *upipe
1055 , struct usb_endpoint_descriptor *epdesc)
1056 {
1057 if (!CONFIG_USB_XHCI)
1058 return NULL;
1059 if (!epdesc) {
1060 usb_add_freelist(upipe);
1061 return NULL;
1062 }
1063 if (!upipe)
1064 return xhci_alloc_pipe(usbdev, epdesc);
1065 u8 eptype = epdesc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
1066 int oldmaxpacket = upipe->maxpacket;
1067 usb_desc2pipe(upipe, usbdev, epdesc);
1068 struct xhci_pipe *pipe = container_of(upipe, struct xhci_pipe, pipe);
1069 struct usb_xhci_s *xhci = container_of(
1070 pipe->pipe.cntl, struct usb_xhci_s, usb);
1071 dprintf(3, "%s: usbdev %p, ring %p, slotid %d, epid %d\n", __func__,
1072 usbdev, &pipe->reqs, pipe->slotid, pipe->epid);
1073 if (eptype != USB_ENDPOINT_XFER_CONTROL || upipe->maxpacket == oldmaxpacket)
1074 return upipe;
1075
1076 // maxpacket has changed on control endpoint - update controller.
1077 dprintf(1, "%s: reconf ctl endpoint pkt size: %d -> %d\n",
1078 __func__, oldmaxpacket, pipe->pipe.maxpacket);
1079 struct xhci_inctx *in = xhci_alloc_inctx(usbdev, 1);
1080 if (!in)
1081 return upipe;
1082 in->add = (1 << 1);
1083 struct xhci_epctx *ep = (void*)&in[2 << xhci->context64];
1084 ep->ctx[1] |= (pipe->pipe.maxpacket << 16);
1085 int cc = xhci_cmd_evaluate_context(xhci, pipe->slotid, in);
1086 if (cc != CC_SUCCESS) {
1087 dprintf(1, "%s: reconf ctl endpoint: failed (cc %d)\n",
1088 __func__, cc);
1089 }
1090 free(in);
1091
1092 return upipe;
1093 }
1094
xhci_xfer_queue(struct xhci_pipe * pipe,void * data,int datalen,u32 flags)1095 static void xhci_xfer_queue(struct xhci_pipe *pipe,
1096 void *data, int datalen, u32 flags)
1097 {
1098 struct xhci_trb trb;
1099 memset(&trb, 0, sizeof(trb));
1100 if (flags & TRB_TR_IDT)
1101 memcpy(&trb.ptr_low, data, datalen);
1102 else
1103 trb.ptr_low = (u32)data;
1104 trb.status = datalen;
1105 trb.control = flags;
1106 xhci_trb_queue(&pipe->reqs, &trb);
1107 }
1108
xhci_xfer_kick(struct xhci_pipe * pipe)1109 static void xhci_xfer_kick(struct xhci_pipe *pipe)
1110 {
1111 struct usb_xhci_s *xhci = container_of(
1112 pipe->pipe.cntl, struct usb_xhci_s, usb);
1113 u32 slotid = pipe->slotid;
1114 u32 epid = pipe->epid;
1115
1116 dprintf(5, "%s: ring %p, slotid %d, epid %d\n",
1117 __func__, &pipe->reqs, slotid, epid);
1118 xhci_doorbell(xhci, slotid, epid);
1119 }
1120
xhci_xfer_normal(struct xhci_pipe * pipe,void * data,int datalen)1121 static void xhci_xfer_normal(struct xhci_pipe *pipe,
1122 void *data, int datalen)
1123 {
1124 xhci_xfer_queue(pipe, data, datalen, (TR_NORMAL << 10) | TRB_TR_IOC);
1125 xhci_xfer_kick(pipe);
1126 }
1127
1128 int
xhci_send_pipe(struct usb_pipe * p,int dir,const void * cmd,void * data,int datalen)1129 xhci_send_pipe(struct usb_pipe *p, int dir, const void *cmd
1130 , void *data, int datalen)
1131 {
1132 if (!CONFIG_USB_XHCI)
1133 return -1;
1134 struct xhci_pipe *pipe = container_of(p, struct xhci_pipe, pipe);
1135 struct usb_xhci_s *xhci = container_of(
1136 pipe->pipe.cntl, struct usb_xhci_s, usb);
1137
1138 if (cmd) {
1139 const struct usb_ctrlrequest *req = cmd;
1140 if (req->bRequest == USB_REQ_SET_ADDRESS)
1141 // Set address command sent during xhci_alloc_pipe.
1142 return 0;
1143
1144 xhci_xfer_queue(pipe, (void*)req, USB_CONTROL_SETUP_SIZE
1145 , (TR_SETUP << 10) | TRB_TR_IDT
1146 | ((datalen ? (dir ? 3 : 2) : 0) << 16));
1147 if (datalen)
1148 xhci_xfer_queue(pipe, data, datalen, (TR_DATA << 10)
1149 | ((dir ? 1 : 0) << 16));
1150 xhci_xfer_queue(pipe, NULL, 0, (TR_STATUS << 10) | TRB_TR_IOC
1151 | ((dir ? 0 : 1) << 16));
1152 xhci_xfer_kick(pipe);
1153 } else {
1154 xhci_xfer_normal(pipe, data, datalen);
1155 }
1156
1157 int cc = xhci_event_wait(xhci, &pipe->reqs, usb_xfer_time(p, datalen));
1158 if (cc != CC_SUCCESS) {
1159 dprintf(1, "%s: xfer failed (cc %d)\n", __func__, cc);
1160 return -1;
1161 }
1162
1163 return 0;
1164 }
1165
1166 int VISIBLE32FLAT
xhci_poll_intr(struct usb_pipe * p,void * data)1167 xhci_poll_intr(struct usb_pipe *p, void *data)
1168 {
1169 if (!CONFIG_USB_XHCI)
1170 return -1;
1171
1172 struct xhci_pipe *pipe = container_of(p, struct xhci_pipe, pipe);
1173 struct usb_xhci_s *xhci = container_of(
1174 pipe->pipe.cntl, struct usb_xhci_s, usb);
1175 u32 len = pipe->pipe.maxpacket;
1176 void *buf = pipe->buf;
1177 int bufused = pipe->bufused;
1178
1179 if (!bufused) {
1180 xhci_xfer_normal(pipe, buf, len);
1181 bufused = 1;
1182 pipe->bufused = bufused;
1183 return -1;
1184 }
1185
1186 xhci_process_events(xhci);
1187 if (xhci_ring_busy(&pipe->reqs))
1188 return -1;
1189 dprintf(5, "%s: st %x ct %x [ %p <= %p / %d ]\n", __func__,
1190 pipe->reqs.evt.status,
1191 pipe->reqs.evt.control,
1192 data, buf, len);
1193 memcpy(data, buf, len);
1194 xhci_xfer_normal(pipe, buf, len);
1195 return 0;
1196 }
1197