dwc2.c revision 1.21 1 /* $NetBSD: dwc2.c,v 1.21 2013/11/28 06:56:36 skrll Exp $ */
2
3 /*-
4 * Copyright (c) 2013 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Nick Hudson
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: dwc2.c,v 1.21 2013/11/28 06:56:36 skrll Exp $");
34
35 #include "opt_usb.h"
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/kmem.h>
40 #include <sys/kernel.h>
41 #include <sys/device.h>
42 #include <sys/select.h>
43 #include <sys/proc.h>
44 #include <sys/queue.h>
45 #include <sys/cpu.h>
46
47 #include <machine/endian.h>
48
49 #include <dev/usb/usb.h>
50 #include <dev/usb/usbdi.h>
51 #include <dev/usb/usbdivar.h>
52 #include <dev/usb/usb_mem.h>
53
54 #include <dev/usb/usbroothub_subr.h>
55
56 #include <dwc2/dwc2.h>
57 #include <dwc2/dwc2var.h>
58
59 #include "dwc2_core.h"
60 #include "dwc2_hcd.h"
61
62 #ifdef DWC2_COUNTERS
63 #define DWC2_EVCNT_ADD(a,b) ((void)((a).ev_count += (b)))
64 #else
65 #define DWC2_EVCNT_ADD(a,b) do { } while (/*CONSTCOND*/0)
66 #endif
67 #define DWC2_EVCNT_INCR(a) DWC2_EVCNT_ADD((a), 1)
68
69 #ifdef DWC2_DEBUG
70 #define DPRINTFN(n,fmt,...) do { \
71 if (dwc2debug >= (n)) { \
72 printf("%s: " fmt, \
73 __FUNCTION__,## __VA_ARGS__); \
74 } \
75 } while (0)
76 #define DPRINTF(...) DPRINTFN(1, __VA_ARGS__)
77 int dwc2debug = 0;
78 #else
79 #define DPRINTF(...) do { } while (0)
80 #define DPRINTFN(...) do { } while (0)
81 #endif
82
83 Static usbd_status dwc2_open(usbd_pipe_handle);
84 Static void dwc2_poll(struct usbd_bus *);
85 Static void dwc2_softintr(void *);
86 Static void dwc2_waitintr(struct dwc2_softc *, usbd_xfer_handle);
87
88 Static usbd_status dwc2_allocm(struct usbd_bus *, usb_dma_t *, uint32_t);
89 Static void dwc2_freem(struct usbd_bus *, usb_dma_t *);
90
91 Static usbd_xfer_handle dwc2_allocx(struct usbd_bus *);
92 Static void dwc2_freex(struct usbd_bus *, usbd_xfer_handle);
93 Static void dwc2_get_lock(struct usbd_bus *, kmutex_t **);
94
95 Static usbd_status dwc2_root_ctrl_transfer(usbd_xfer_handle);
96 Static usbd_status dwc2_root_ctrl_start(usbd_xfer_handle);
97 Static void dwc2_root_ctrl_abort(usbd_xfer_handle);
98 Static void dwc2_root_ctrl_close(usbd_pipe_handle);
99 Static void dwc2_root_ctrl_done(usbd_xfer_handle);
100
101 Static usbd_status dwc2_root_intr_transfer(usbd_xfer_handle);
102 Static usbd_status dwc2_root_intr_start(usbd_xfer_handle);
103 Static void dwc2_root_intr_abort(usbd_xfer_handle);
104 Static void dwc2_root_intr_close(usbd_pipe_handle);
105 Static void dwc2_root_intr_done(usbd_xfer_handle);
106
107 Static usbd_status dwc2_device_ctrl_transfer(usbd_xfer_handle);
108 Static usbd_status dwc2_device_ctrl_start(usbd_xfer_handle);
109 Static void dwc2_device_ctrl_abort(usbd_xfer_handle);
110 Static void dwc2_device_ctrl_close(usbd_pipe_handle);
111 Static void dwc2_device_ctrl_done(usbd_xfer_handle);
112
113 Static usbd_status dwc2_device_bulk_transfer(usbd_xfer_handle);
114 Static usbd_status dwc2_device_bulk_start(usbd_xfer_handle);
115 Static void dwc2_device_bulk_abort(usbd_xfer_handle);
116 Static void dwc2_device_bulk_close(usbd_pipe_handle);
117 Static void dwc2_device_bulk_done(usbd_xfer_handle);
118
119 Static usbd_status dwc2_device_intr_transfer(usbd_xfer_handle);
120 Static usbd_status dwc2_device_intr_start(usbd_xfer_handle);
121 Static void dwc2_device_intr_abort(usbd_xfer_handle);
122 Static void dwc2_device_intr_close(usbd_pipe_handle);
123 Static void dwc2_device_intr_done(usbd_xfer_handle);
124
125 Static usbd_status dwc2_device_isoc_transfer(usbd_xfer_handle);
126 Static usbd_status dwc2_device_isoc_start(usbd_xfer_handle);
127 Static void dwc2_device_isoc_abort(usbd_xfer_handle);
128 Static void dwc2_device_isoc_close(usbd_pipe_handle);
129 Static void dwc2_device_isoc_done(usbd_xfer_handle);
130
131 Static usbd_status dwc2_device_start(usbd_xfer_handle);
132
133 Static void dwc2_close_pipe(usbd_pipe_handle);
134 Static void dwc2_abort_xfer(usbd_xfer_handle, usbd_status);
135
136 Static void dwc2_device_clear_toggle(usbd_pipe_handle);
137 Static void dwc2_noop(usbd_pipe_handle pipe);
138
139 Static int dwc2_interrupt(struct dwc2_softc *);
140 Static void dwc2_rhc(void *);
141
142 Static void dwc2_timeout(void *);
143 Static void dwc2_timeout_task(void *);
144
145
146
147 static inline void
148 dwc2_allocate_bus_bandwidth(struct dwc2_hsotg *hsotg, u16 bw,
149 usbd_xfer_handle xfer)
150 {
151 }
152
153 static inline void
154 dwc2_free_bus_bandwidth(struct dwc2_hsotg *hsotg, u16 bw,
155 usbd_xfer_handle xfer)
156 {
157 }
158
159 #define DWC2_INTR_ENDPT 1
160
161 Static const struct usbd_bus_methods dwc2_bus_methods = {
162 .open_pipe = dwc2_open,
163 .soft_intr = dwc2_softintr,
164 .do_poll = dwc2_poll,
165 .allocm = dwc2_allocm,
166 .freem = dwc2_freem,
167 .allocx = dwc2_allocx,
168 .freex = dwc2_freex,
169 .get_lock = dwc2_get_lock,
170 };
171
172 Static const struct usbd_pipe_methods dwc2_root_ctrl_methods = {
173 .transfer = dwc2_root_ctrl_transfer,
174 .start = dwc2_root_ctrl_start,
175 .abort = dwc2_root_ctrl_abort,
176 .close = dwc2_root_ctrl_close,
177 .cleartoggle = dwc2_noop,
178 .done = dwc2_root_ctrl_done,
179 };
180
181 Static const struct usbd_pipe_methods dwc2_root_intr_methods = {
182 .transfer = dwc2_root_intr_transfer,
183 .start = dwc2_root_intr_start,
184 .abort = dwc2_root_intr_abort,
185 .close = dwc2_root_intr_close,
186 .cleartoggle = dwc2_noop,
187 .done = dwc2_root_intr_done,
188 };
189
190 Static const struct usbd_pipe_methods dwc2_device_ctrl_methods = {
191 .transfer = dwc2_device_ctrl_transfer,
192 .start = dwc2_device_ctrl_start,
193 .abort = dwc2_device_ctrl_abort,
194 .close = dwc2_device_ctrl_close,
195 .cleartoggle = dwc2_noop,
196 .done = dwc2_device_ctrl_done,
197 };
198
199 Static const struct usbd_pipe_methods dwc2_device_intr_methods = {
200 .transfer = dwc2_device_intr_transfer,
201 .start = dwc2_device_intr_start,
202 .abort = dwc2_device_intr_abort,
203 .close = dwc2_device_intr_close,
204 .cleartoggle = dwc2_device_clear_toggle,
205 .done = dwc2_device_intr_done,
206 };
207
208 Static const struct usbd_pipe_methods dwc2_device_bulk_methods = {
209 .transfer = dwc2_device_bulk_transfer,
210 .start = dwc2_device_bulk_start,
211 .abort = dwc2_device_bulk_abort,
212 .close = dwc2_device_bulk_close,
213 .cleartoggle = dwc2_device_clear_toggle,
214 .done = dwc2_device_bulk_done,
215 };
216
217 Static const struct usbd_pipe_methods dwc2_device_isoc_methods = {
218 .transfer = dwc2_device_isoc_transfer,
219 .start = dwc2_device_isoc_start,
220 .abort = dwc2_device_isoc_abort,
221 .close = dwc2_device_isoc_close,
222 .cleartoggle = dwc2_noop,
223 .done = dwc2_device_isoc_done,
224 };
225
226 Static usbd_status
227 dwc2_allocm(struct usbd_bus *bus, usb_dma_t *dma, uint32_t size)
228 {
229 struct dwc2_softc *sc = DWC2_BUS2SC(bus);
230 usbd_status status;
231
232 DPRINTFN(10, "\n");
233
234 status = usb_allocmem(&sc->sc_bus, size, 0, dma);
235 if (status == USBD_NOMEM)
236 status = usb_reserve_allocm(&sc->sc_dma_reserve, dma, size);
237 return status;
238 }
239
240 Static void
241 dwc2_freem(struct usbd_bus *bus, usb_dma_t *dma)
242 {
243 struct dwc2_softc *sc = DWC2_BUS2SC(bus);
244
245 DPRINTFN(10, "\n");
246
247 if (dma->block->flags & USB_DMA_RESERVE) {
248 usb_reserve_freem(&sc->sc_dma_reserve, dma);
249 return;
250 }
251 usb_freemem(&sc->sc_bus, dma);
252 }
253
254 usbd_xfer_handle
255 dwc2_allocx(struct usbd_bus *bus)
256 {
257 struct dwc2_softc *sc = DWC2_BUS2SC(bus);
258 struct dwc2_xfer *dxfer;
259
260 DPRINTFN(10, "\n");
261
262 DWC2_EVCNT_INCR(sc->sc_ev_xferpoolget);
263 dxfer = pool_cache_get(sc->sc_xferpool, PR_NOWAIT);
264 if (dxfer != NULL) {
265 memset(dxfer, 0, sizeof(*dxfer));
266
267 dxfer->urb = dwc2_hcd_urb_alloc(sc->sc_hsotg,
268 DWC2_MAXISOCPACKETS, GFP_KERNEL);
269
270 #ifdef DIAGNOSTIC
271 dxfer->xfer.busy_free = XFER_BUSY;
272 #endif
273 }
274 return (usbd_xfer_handle)dxfer;
275 }
276
277 void
278 dwc2_freex(struct usbd_bus *bus, usbd_xfer_handle xfer)
279 {
280 struct dwc2_xfer *dxfer = DWC2_XFER2DXFER(xfer);
281 struct dwc2_softc *sc = DWC2_BUS2SC(bus);
282
283 DPRINTFN(10, "\n");
284
285 #ifdef DIAGNOSTIC
286 if (xfer->busy_free != XFER_BUSY) {
287 DPRINTF("xfer=%p not busy, 0x%08x\n", xfer, xfer->busy_free);
288 }
289 xfer->busy_free = XFER_FREE;
290 #endif
291 DWC2_EVCNT_INCR(sc->sc_ev_xferpoolput);
292 dwc2_hcd_urb_free(sc->sc_hsotg, dxfer->urb, DWC2_MAXISOCPACKETS);
293 pool_cache_put(sc->sc_xferpool, xfer);
294 }
295
296 Static void
297 dwc2_get_lock(struct usbd_bus *bus, kmutex_t **lock)
298 {
299 struct dwc2_softc *sc = DWC2_BUS2SC(bus);
300
301 *lock = &sc->sc_lock;
302 }
303
304 Static void
305 dwc2_rhc(void *addr)
306 {
307 struct dwc2_softc *sc = addr;
308 usbd_xfer_handle xfer;
309 u_char *p;
310
311 DPRINTF("\n");
312 mutex_enter(&sc->sc_lock);
313 xfer = sc->sc_intrxfer;
314
315 if (xfer == NULL) {
316 /* Just ignore the change. */
317 mutex_exit(&sc->sc_lock);
318 return;
319
320 }
321 /* set port bit */
322 p = KERNADDR(&xfer->dmabuf, 0);
323
324 p[0] = 0x02; /* we only have one port (1 << 1) */
325
326 xfer->actlen = xfer->length;
327 xfer->status = USBD_NORMAL_COMPLETION;
328
329 usb_transfer_complete(xfer);
330 mutex_exit(&sc->sc_lock);
331 }
332
333 Static void
334 dwc2_softintr(void *v)
335 {
336 struct usbd_bus *bus = v;
337 struct dwc2_softc *sc = DWC2_BUS2SC(bus);
338 struct dwc2_hsotg *hsotg = sc->sc_hsotg;
339 struct dwc2_xfer *dxfer;
340
341 KASSERT(sc->sc_bus.use_polling || mutex_owned(&sc->sc_lock));
342
343 mutex_spin_enter(&hsotg->lock);
344 while ((dxfer = TAILQ_FIRST(&sc->sc_complete)) != NULL) {
345 /*
346 * dwc2_abort_xfer will remove this transfer from the
347 * sc_complete queue
348 */
349 /*XXXNH not tested */
350 if (dxfer->xfer.hcflags & UXFER_ABORTING) {
351 cv_broadcast(&dxfer->xfer.hccv);
352 continue;
353 }
354
355 TAILQ_REMOVE(&sc->sc_complete, dxfer, xnext);
356 /* XXXNH Already done - can I assert this? */
357 callout_stop(&dxfer->xfer.timeout_handle);
358
359 mutex_spin_exit(&hsotg->lock);
360 usb_transfer_complete(&dxfer->xfer);
361 mutex_spin_enter(&hsotg->lock);
362 }
363 mutex_spin_exit(&hsotg->lock);
364 }
365
366 Static void
367 dwc2_waitintr(struct dwc2_softc *sc, usbd_xfer_handle xfer)
368 {
369 struct dwc2_hsotg *hsotg = sc->sc_hsotg;
370 uint32_t intrs;
371 int timo;
372
373 xfer->status = USBD_IN_PROGRESS;
374 for (timo = xfer->timeout; timo >= 0; timo--) {
375 usb_delay_ms(&sc->sc_bus, 1);
376 if (sc->sc_dying)
377 break;
378 intrs = dwc2_read_core_intr(hsotg);
379
380 DPRINTFN(15, "0x%08x\n", intrs);
381
382 if (intrs) {
383 mutex_spin_enter(&hsotg->lock);
384 dwc2_interrupt(sc);
385 mutex_spin_exit(&hsotg->lock);
386 if (xfer->status != USBD_IN_PROGRESS)
387 return;
388 }
389 }
390
391 /* Timeout */
392 DPRINTF("timeout\n");
393
394 mutex_enter(&sc->sc_lock);
395 xfer->status = USBD_TIMEOUT;
396 usb_transfer_complete(xfer);
397 mutex_exit(&sc->sc_lock);
398 }
399
400 Static void
401 dwc2_timeout(void *addr)
402 {
403 usbd_xfer_handle xfer = addr;
404 struct dwc2_xfer *dxfer = DWC2_XFER2DXFER(xfer);
405 // struct dwc2_pipe *dpipe = DWC2_XFER2DPIPE(xfer);
406 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
407
408 DPRINTF("dxfer=%p\n", dxfer);
409
410 if (sc->sc_dying) {
411 mutex_enter(&sc->sc_lock);
412 dwc2_abort_xfer(&dxfer->xfer, USBD_TIMEOUT);
413 mutex_exit(&sc->sc_lock);
414 return;
415 }
416
417 /* Execute the abort in a process context. */
418 usb_init_task(&dxfer->abort_task, dwc2_timeout_task, addr,
419 USB_TASKQ_MPSAFE);
420 usb_add_task(dxfer->xfer.pipe->device, &dxfer->abort_task,
421 USB_TASKQ_HC);
422 }
423
424 Static void
425 dwc2_timeout_task(void *addr)
426 {
427 usbd_xfer_handle xfer = addr;
428 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
429
430 DPRINTF("xfer=%p\n", xfer);
431
432 mutex_enter(&sc->sc_lock);
433 dwc2_abort_xfer(xfer, USBD_TIMEOUT);
434 mutex_exit(&sc->sc_lock);
435 }
436
437 usbd_status
438 dwc2_open(usbd_pipe_handle pipe)
439 {
440 usbd_device_handle dev = pipe->device;
441 struct dwc2_softc *sc = DWC2_PIPE2SC(pipe);
442 struct dwc2_pipe *dpipe = DWC2_PIPE2DPIPE(pipe);
443 usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc;
444 uint8_t addr = dev->address;
445 uint8_t xfertype = UE_GET_XFERTYPE(ed->bmAttributes);
446 usbd_status err;
447
448 DPRINTF("pipe %p addr %d xfertype %d dir %s\n", pipe, addr, xfertype,
449 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN ? "in" : "out");
450
451 if (sc->sc_dying) {
452 return USBD_IOERROR;
453 }
454
455 if (addr == sc->sc_addr) {
456 switch (ed->bEndpointAddress) {
457 case USB_CONTROL_ENDPOINT:
458 pipe->methods = &dwc2_root_ctrl_methods;
459 break;
460 case UE_DIR_IN | DWC2_INTR_ENDPT:
461 pipe->methods = &dwc2_root_intr_methods;
462 break;
463 default:
464 DPRINTF("bad bEndpointAddress 0x%02x\n",
465 ed->bEndpointAddress);
466 return USBD_INVAL;
467 }
468 DPRINTF("root hub pipe open\n");
469 return USBD_NORMAL_COMPLETION;
470 }
471
472 switch (xfertype) {
473 case UE_CONTROL:
474 pipe->methods = &dwc2_device_ctrl_methods;
475 err = usb_allocmem(&sc->sc_bus, sizeof(usb_device_request_t),
476 0, &dpipe->req_dma);
477 if (err)
478 return err;
479 break;
480 case UE_INTERRUPT:
481 pipe->methods = &dwc2_device_intr_methods;
482 break;
483 case UE_ISOCHRONOUS:
484 pipe->methods = &dwc2_device_isoc_methods;
485 break;
486 case UE_BULK:
487 pipe->methods = &dwc2_device_bulk_methods;
488 break;
489 default:
490 DPRINTF("bad xfer type %d\n", xfertype);
491 return USBD_INVAL;
492 }
493
494 dpipe->priv = NULL; /* QH */
495
496 return USBD_NORMAL_COMPLETION;
497 }
498
499 Static void
500 dwc2_poll(struct usbd_bus *bus)
501 {
502 struct dwc2_softc *sc = DWC2_BUS2SC(bus);
503 struct dwc2_hsotg *hsotg = sc->sc_hsotg;
504
505 mutex_spin_enter(&hsotg->lock);
506 dwc2_interrupt(sc);
507 mutex_spin_exit(&hsotg->lock);
508 }
509
510 /*
511 * Close a reqular pipe.
512 * Assumes that there are no pending transactions.
513 */
514 Static void
515 dwc2_close_pipe(usbd_pipe_handle pipe)
516 {
517 #ifdef DIAGNOSTIC
518 struct dwc2_softc *sc = pipe->device->bus->hci_private;
519 #endif
520
521 KASSERT(mutex_owned(&sc->sc_lock));
522 }
523
524 /*
525 * Abort a device request.
526 */
527 Static void
528 dwc2_abort_xfer(usbd_xfer_handle xfer, usbd_status status)
529 {
530 struct dwc2_xfer *dxfer = DWC2_XFER2DXFER(xfer);
531 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
532 struct dwc2_hsotg *hsotg = sc->sc_hsotg;
533 struct dwc2_xfer *d, *tmp;
534 bool wake;
535 int err;
536
537 DPRINTF("xfer=%p\n", xfer);
538
539 KASSERT(mutex_owned(&sc->sc_lock));
540 KASSERT(!cpu_intr_p() && !cpu_softintr_p());
541
542 if (sc->sc_dying) {
543 xfer->status = status;
544 callout_stop(&xfer->timeout_handle);
545 usb_transfer_complete(xfer);
546 return;
547 }
548
549 /*
550 * If an abort is already in progress then just wait for it to
551 * complete and return.
552 */
553 if (xfer->hcflags & UXFER_ABORTING) {
554 xfer->status = status;
555 xfer->hcflags |= UXFER_ABORTWAIT;
556 while (xfer->hcflags & UXFER_ABORTING)
557 cv_wait(&xfer->hccv, &sc->sc_lock);
558 return;
559 }
560
561 /*
562 * Step 1: Make the stack ignore it and stop the callout.
563 */
564 mutex_spin_enter(&hsotg->lock);
565 xfer->hcflags |= UXFER_ABORTING;
566
567 xfer->status = status; /* make software ignore it */
568 callout_stop(&xfer->timeout_handle);
569
570 /* XXXNH suboptimal */
571 TAILQ_FOREACH_SAFE(d, &sc->sc_complete, xnext, tmp) {
572 if (d == dxfer) {
573 TAILQ_REMOVE(&sc->sc_complete, dxfer, xnext);
574 }
575 }
576
577 err = dwc2_hcd_urb_dequeue(hsotg, dxfer->urb);
578 if (err) {
579 DPRINTF("dwc2_hcd_urb_dequeue failed\n");
580 }
581
582 mutex_spin_exit(&hsotg->lock);
583
584 /*
585 * Step 2: Execute callback.
586 */
587 wake = xfer->hcflags & UXFER_ABORTWAIT;
588 xfer->hcflags &= ~(UXFER_ABORTING | UXFER_ABORTWAIT);
589
590 usb_transfer_complete(xfer);
591 if (wake) {
592 cv_broadcast(&xfer->hccv);
593 }
594 }
595
596 Static void
597 dwc2_noop(usbd_pipe_handle pipe)
598 {
599
600 }
601
602 Static void
603 dwc2_device_clear_toggle(usbd_pipe_handle pipe)
604 {
605
606 DPRINTF("toggle %d -> 0", pipe->endpoint->datatoggle);
607 }
608
609 /***********************************************************************/
610
611 /*
612 * Data structures and routines to emulate the root hub.
613 */
614
615 Static const usb_device_descriptor_t dwc2_devd = {
616 .bLength = sizeof(usb_device_descriptor_t),
617 .bDescriptorType = UDESC_DEVICE,
618 .bcdUSB = {0x00, 0x02},
619 .bDeviceClass = UDCLASS_HUB,
620 .bDeviceSubClass = UDSUBCLASS_HUB,
621 .bDeviceProtocol = UDPROTO_HSHUBSTT,
622 .bMaxPacketSize = 64,
623 .bcdDevice = {0x00, 0x01},
624 .iManufacturer = 1,
625 .iProduct = 2,
626 .bNumConfigurations = 1,
627 };
628
629 struct dwc2_config_desc {
630 usb_config_descriptor_t confd;
631 usb_interface_descriptor_t ifcd;
632 usb_endpoint_descriptor_t endpd;
633 } __packed;
634
635 Static const struct dwc2_config_desc dwc2_confd = {
636 .confd = {
637 .bLength = USB_CONFIG_DESCRIPTOR_SIZE,
638 .bDescriptorType = UDESC_CONFIG,
639 .wTotalLength[0] = sizeof(dwc2_confd),
640 .bNumInterface = 1,
641 .bConfigurationValue = 1,
642 .iConfiguration = 0,
643 .bmAttributes = UC_SELF_POWERED,
644 .bMaxPower = 0,
645 },
646 .ifcd = {
647 .bLength = USB_INTERFACE_DESCRIPTOR_SIZE,
648 .bDescriptorType = UDESC_INTERFACE,
649 .bInterfaceNumber = 0,
650 .bAlternateSetting = 0,
651 .bNumEndpoints = 1,
652 .bInterfaceClass = UICLASS_HUB,
653 .bInterfaceSubClass = UISUBCLASS_HUB,
654 .bInterfaceProtocol = UIPROTO_HSHUBSTT,
655 .iInterface = 0
656 },
657 .endpd = {
658 .bLength = USB_ENDPOINT_DESCRIPTOR_SIZE,
659 .bDescriptorType = UDESC_ENDPOINT,
660 .bEndpointAddress = UE_DIR_IN | DWC2_INTR_ENDPT,
661 .bmAttributes = UE_INTERRUPT,
662 .wMaxPacketSize = {8, 0}, /* max packet */
663 .bInterval = 255,
664 },
665 };
666
667 #define HSETW(ptr, val) ptr = { (uint8_t)(val), (uint8_t)((val) >> 8) }
668 Static const usb_hub_descriptor_t dwc2_hubd = {
669 .bDescLength = USB_HUB_DESCRIPTOR_SIZE,
670 .bDescriptorType = UDESC_HUB,
671 .bNbrPorts = 1,
672 HSETW(.wHubCharacteristics, (UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL)),
673 .bPwrOn2PwrGood = 50,
674 .bHubContrCurrent = 0,
675 .DeviceRemovable = {0}, /* port is removable */
676 };
677
678 Static usbd_status
679 dwc2_root_ctrl_transfer(usbd_xfer_handle xfer)
680 {
681 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
682 usbd_status err;
683
684 mutex_enter(&sc->sc_lock);
685 err = usb_insert_transfer(xfer);
686 mutex_exit(&sc->sc_lock);
687 if (err)
688 return err;
689
690 return dwc2_root_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
691 }
692
693 Static usbd_status
694 dwc2_root_ctrl_start(usbd_xfer_handle xfer)
695 {
696 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
697 usb_device_request_t *req;
698 uint8_t *buf;
699 uint16_t len;
700 int value, index, l, totlen;
701 usbd_status err = USBD_IOERROR;
702
703 if (sc->sc_dying)
704 return USBD_IOERROR;
705
706 req = &xfer->request;
707
708 DPRINTFN(4, "type=0x%02x request=%02x\n",
709 req->bmRequestType, req->bRequest);
710
711 len = UGETW(req->wLength);
712 value = UGETW(req->wValue);
713 index = UGETW(req->wIndex);
714
715 buf = len ? KERNADDR(&xfer->dmabuf, 0) : NULL;
716
717 totlen = 0;
718
719 #define C(x,y) ((x) | ((y) << 8))
720 switch (C(req->bRequest, req->bmRequestType)) {
721 case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE):
722 case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE):
723 case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT):
724 /*
725 * DEVICE_REMOTE_WAKEUP and ENDPOINT_HALT are no-ops
726 * for the integrated root hub.
727 */
728 break;
729 case C(UR_GET_CONFIG, UT_READ_DEVICE):
730 if (len > 0) {
731 *buf = sc->sc_conf;
732 totlen = 1;
733 }
734 break;
735 case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
736 DPRINTFN(8, "wValue=0x%04x\n", value);
737
738 if (len == 0)
739 break;
740 switch (value) {
741 case C(0, UDESC_DEVICE):
742 l = min(len, USB_DEVICE_DESCRIPTOR_SIZE);
743 // USETW(dwc2_devd.idVendor, sc->sc_id_vendor);
744 memcpy(buf, &dwc2_devd, l);
745 buf += l;
746 len -= l;
747 totlen += l;
748
749 break;
750 case C(0, UDESC_CONFIG):
751 l = min(len, sizeof(dwc2_confd));
752 memcpy(buf, &dwc2_confd, l);
753 buf += l;
754 len -= l;
755 totlen += l;
756
757 break;
758 #define sd ((usb_string_descriptor_t *)buf)
759 case C(0, UDESC_STRING):
760 totlen = usb_makelangtbl(sd, len);
761 break;
762 case C(1, UDESC_STRING):
763 totlen = usb_makestrdesc(sd, len, sc->sc_vendor);
764 break;
765 case C(2, UDESC_STRING):
766 totlen = usb_makestrdesc(sd, len, "DWC2 root hub");
767 break;
768 #undef sd
769 default:
770 goto fail;
771 }
772 break;
773 case C(UR_GET_INTERFACE, UT_READ_INTERFACE):
774 if (len > 0) {
775 *buf = 0;
776 totlen = 1;
777 }
778 break;
779 case C(UR_GET_STATUS, UT_READ_DEVICE):
780 if (len > 1) {
781 USETW(((usb_status_t *)buf)->wStatus,UDS_SELF_POWERED);
782 totlen = 2;
783 }
784 break;
785 case C(UR_GET_STATUS, UT_READ_INTERFACE):
786 case C(UR_GET_STATUS, UT_READ_ENDPOINT):
787 if (len > 1) {
788 USETW(((usb_status_t *)buf)->wStatus, 0);
789 totlen = 2;
790 }
791 break;
792 case C(UR_SET_ADDRESS, UT_WRITE_DEVICE):
793 DPRINTF("UR_SET_ADDRESS, UT_WRITE_DEVICE: addr %d\n",
794 value);
795 if (value >= USB_MAX_DEVICES)
796 goto fail;
797
798 sc->sc_addr = value;
799 break;
800 case C(UR_SET_CONFIG, UT_WRITE_DEVICE):
801 if (value != 0 && value != 1)
802 goto fail;
803
804 sc->sc_conf = value;
805 break;
806 case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE):
807 break;
808 case C(UR_SET_FEATURE, UT_WRITE_DEVICE):
809 case C(UR_SET_FEATURE, UT_WRITE_INTERFACE):
810 case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT):
811 err = USBD_IOERROR;
812 goto fail;
813 case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE):
814 break;
815 case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT):
816 break;
817 default:
818 /* Hub requests - XXXNH len check? */
819 err = dwc2_hcd_hub_control(sc->sc_hsotg,
820 C(req->bRequest, req->bmRequestType), value, index,
821 buf, len);
822 if (err) {
823 err = USBD_IOERROR;
824 goto fail;
825 }
826 totlen = len;
827 }
828 xfer->actlen = totlen;
829 err = USBD_NORMAL_COMPLETION;
830
831 fail:
832 mutex_enter(&sc->sc_lock);
833 xfer->status = err;
834 usb_transfer_complete(xfer);
835 mutex_exit(&sc->sc_lock);
836
837 return USBD_IN_PROGRESS;
838 }
839
840 Static void
841 dwc2_root_ctrl_abort(usbd_xfer_handle xfer)
842 {
843 DPRINTFN(10, "\n");
844
845 /* Nothing to do, all transfers are synchronous. */
846 }
847
848 Static void
849 dwc2_root_ctrl_close(usbd_pipe_handle pipe)
850 {
851 DPRINTFN(10, "\n");
852
853 /* Nothing to do. */
854 }
855
856 Static void
857 dwc2_root_ctrl_done(usbd_xfer_handle xfer)
858 {
859 DPRINTFN(10, "\n");
860
861 /* Nothing to do. */
862 }
863
864 Static usbd_status
865 dwc2_root_intr_transfer(usbd_xfer_handle xfer)
866 {
867 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
868 usbd_status err;
869
870 DPRINTF("\n");
871
872 /* Insert last in queue. */
873 mutex_enter(&sc->sc_lock);
874 err = usb_insert_transfer(xfer);
875 mutex_exit(&sc->sc_lock);
876 if (err)
877 return err;
878
879 /* Pipe isn't running, start first */
880 return dwc2_root_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
881 }
882
883 Static usbd_status
884 dwc2_root_intr_start(usbd_xfer_handle xfer)
885 {
886 struct dwc2_softc *sc = DWC2_PIPE2SC(xfer);
887
888 DPRINTF("\n");
889
890 if (sc->sc_dying)
891 return USBD_IOERROR;
892
893 mutex_enter(&sc->sc_lock);
894 KASSERT(sc->sc_intrxfer == NULL);
895 sc->sc_intrxfer = xfer;
896 mutex_exit(&sc->sc_lock);
897
898 return USBD_IN_PROGRESS;
899 }
900
901 /* Abort a root interrupt request. */
902 Static void
903 dwc2_root_intr_abort(usbd_xfer_handle xfer)
904 {
905 #ifdef DIAGNOSTIC
906 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
907 #endif
908 DPRINTF("xfer=%p\n", xfer);
909
910 KASSERT(mutex_owned(&sc->sc_lock));
911
912 if (xfer->pipe->intrxfer == xfer) {
913 DPRINTF("remove\n");
914 xfer->pipe->intrxfer = NULL;
915 }
916 xfer->status = USBD_CANCELLED;
917 usb_transfer_complete(xfer);
918 }
919
920 Static void
921 dwc2_root_intr_close(usbd_pipe_handle pipe)
922 {
923 struct dwc2_softc *sc = DWC2_PIPE2SC(pipe);
924
925 DPRINTF("\n");
926
927 KASSERT(mutex_owned(&sc->sc_lock));
928
929 sc->sc_intrxfer = NULL;
930 }
931
932 Static void
933 dwc2_root_intr_done(usbd_xfer_handle xfer)
934 {
935
936 DPRINTF("\n");
937 }
938
939 /***********************************************************************/
940
941 Static usbd_status
942 dwc2_device_ctrl_transfer(usbd_xfer_handle xfer)
943 {
944 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
945 usbd_status err;
946
947 DPRINTF("\n");
948
949 /* Insert last in queue. */
950 mutex_enter(&sc->sc_lock);
951 err = usb_insert_transfer(xfer);
952 mutex_exit(&sc->sc_lock);
953 if (err)
954 return err;
955
956 /* Pipe isn't running, start first */
957 return dwc2_device_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
958 }
959
960 Static usbd_status
961 dwc2_device_ctrl_start(usbd_xfer_handle xfer)
962 {
963 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
964 usbd_status err;
965
966 DPRINTF("\n");
967
968 mutex_enter(&sc->sc_lock);
969 xfer->status = USBD_IN_PROGRESS;
970 err = dwc2_device_start(xfer);
971 mutex_exit(&sc->sc_lock);
972
973 if (err)
974 return err;
975
976 if (sc->sc_bus.use_polling)
977 dwc2_waitintr(sc, xfer);
978
979 return USBD_IN_PROGRESS;
980 }
981
982 Static void
983 dwc2_device_ctrl_abort(usbd_xfer_handle xfer)
984 {
985 #ifdef DIAGNOSTIC
986 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
987 #endif
988 KASSERT(mutex_owned(&sc->sc_lock));
989
990 DPRINTF("xfer=%p\n", xfer);
991 dwc2_abort_xfer(xfer, USBD_CANCELLED);
992 }
993
994 Static void
995 dwc2_device_ctrl_close(usbd_pipe_handle pipe)
996 {
997
998 DPRINTF("pipe=%p\n", pipe);
999 dwc2_close_pipe(pipe);
1000 }
1001
1002 Static void
1003 dwc2_device_ctrl_done(usbd_xfer_handle xfer)
1004 {
1005
1006 DPRINTF("xfer=%p\n", xfer);
1007 }
1008
1009 /***********************************************************************/
1010
1011 Static usbd_status
1012 dwc2_device_bulk_transfer(usbd_xfer_handle xfer)
1013 {
1014 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
1015 usbd_status err;
1016
1017 DPRINTF("xfer=%p\n", xfer);
1018
1019 /* Insert last in queue. */
1020 mutex_enter(&sc->sc_lock);
1021 err = usb_insert_transfer(xfer);
1022 mutex_exit(&sc->sc_lock);
1023 if (err)
1024 return err;
1025
1026 /* Pipe isn't running, start first */
1027 return dwc2_device_bulk_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
1028 }
1029
1030 Static usbd_status
1031 dwc2_device_bulk_start(usbd_xfer_handle xfer)
1032 {
1033 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
1034 usbd_status err;
1035
1036 DPRINTF("xfer=%p\n", xfer);
1037 mutex_enter(&sc->sc_lock);
1038 xfer->status = USBD_IN_PROGRESS;
1039 err = dwc2_device_start(xfer);
1040 mutex_exit(&sc->sc_lock);
1041
1042 return err;
1043 }
1044
1045 Static void
1046 dwc2_device_bulk_abort(usbd_xfer_handle xfer)
1047 {
1048 #ifdef DIAGNOSTIC
1049 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
1050 #endif
1051 KASSERT(mutex_owned(&sc->sc_lock));
1052
1053 DPRINTF("xfer=%p\n", xfer);
1054 dwc2_abort_xfer(xfer, USBD_CANCELLED);
1055 }
1056
1057 Static void
1058 dwc2_device_bulk_close(usbd_pipe_handle pipe)
1059 {
1060
1061 DPRINTF("pipe=%p\n", pipe);
1062
1063 dwc2_close_pipe(pipe);
1064 }
1065
1066 Static void
1067 dwc2_device_bulk_done(usbd_xfer_handle xfer)
1068 {
1069
1070 DPRINTF("xfer=%p\n", xfer);
1071 }
1072
1073 /***********************************************************************/
1074
1075 Static usbd_status
1076 dwc2_device_intr_transfer(usbd_xfer_handle xfer)
1077 {
1078 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
1079 usbd_status err;
1080
1081 DPRINTF("xfer=%p\n", xfer);
1082
1083 /* Insert last in queue. */
1084 mutex_enter(&sc->sc_lock);
1085 err = usb_insert_transfer(xfer);
1086 mutex_exit(&sc->sc_lock);
1087 if (err)
1088 return err;
1089
1090 /* Pipe isn't running, start first */
1091 return dwc2_device_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
1092 }
1093
1094 Static usbd_status
1095 dwc2_device_intr_start(usbd_xfer_handle xfer)
1096 {
1097 struct dwc2_pipe *dpipe = (struct dwc2_pipe *)xfer->pipe;
1098 usbd_device_handle dev = dpipe->pipe.device;
1099 struct dwc2_softc *sc = dev->bus->hci_private;
1100 usbd_status err;
1101
1102 mutex_enter(&sc->sc_lock);
1103 xfer->status = USBD_IN_PROGRESS;
1104 err = dwc2_device_start(xfer);
1105 mutex_exit(&sc->sc_lock);
1106
1107 if (err)
1108 return err;
1109
1110 if (sc->sc_bus.use_polling)
1111 dwc2_waitintr(sc, xfer);
1112
1113 return USBD_IN_PROGRESS;
1114 }
1115
1116 /* Abort a device interrupt request. */
1117 Static void
1118 dwc2_device_intr_abort(usbd_xfer_handle xfer)
1119 {
1120 #ifdef DIAGNOSTIC
1121 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
1122 #endif
1123
1124 KASSERT(mutex_owned(&sc->sc_lock));
1125
1126 if (xfer->pipe->intrxfer == xfer) {
1127 DPRINTF("remove\n");
1128 xfer->pipe->intrxfer = NULL;
1129 }
1130 DPRINTF("xfer=%p\n", xfer);
1131 dwc2_abort_xfer(xfer, USBD_CANCELLED);
1132 }
1133
1134 Static void
1135 dwc2_device_intr_close(usbd_pipe_handle pipe)
1136 {
1137
1138 DPRINTF("pipe=%p\n", pipe);
1139
1140 dwc2_close_pipe(pipe);
1141 }
1142
1143 Static void
1144 dwc2_device_intr_done(usbd_xfer_handle xfer)
1145 {
1146
1147 DPRINTF("\n");
1148
1149 if (xfer->pipe->repeat) {
1150 xfer->status = USBD_IN_PROGRESS;
1151 dwc2_device_start(xfer);
1152 }
1153 }
1154
1155 /***********************************************************************/
1156
1157 usbd_status
1158 dwc2_device_isoc_transfer(usbd_xfer_handle xfer)
1159 {
1160 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
1161 usbd_status err;
1162
1163 DPRINTF("xfer=%p\n", xfer);
1164
1165 /* Insert last in queue. */
1166 mutex_enter(&sc->sc_lock);
1167 err = usb_insert_transfer(xfer);
1168 mutex_exit(&sc->sc_lock);
1169 if (err)
1170 return err;
1171
1172 /* Pipe isn't running, start first */
1173 return dwc2_device_isoc_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
1174 }
1175
1176 usbd_status
1177 dwc2_device_isoc_start(usbd_xfer_handle xfer)
1178 {
1179 struct dwc2_pipe *dpipe = (struct dwc2_pipe *)xfer->pipe;
1180 usbd_device_handle dev = dpipe->pipe.device;
1181 struct dwc2_softc *sc = dev->bus->hci_private;
1182 usbd_status err;
1183
1184 mutex_enter(&sc->sc_lock);
1185 xfer->status = USBD_IN_PROGRESS;
1186 err = dwc2_device_start(xfer);
1187 mutex_exit(&sc->sc_lock);
1188
1189 if (sc->sc_bus.use_polling)
1190 dwc2_waitintr(sc, xfer);
1191
1192 return err;
1193 }
1194
1195 void
1196 dwc2_device_isoc_abort(usbd_xfer_handle xfer)
1197 {
1198 #ifdef DIAGNOSTIC
1199 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
1200 #endif
1201 KASSERT(mutex_owned(&sc->sc_lock));
1202
1203 DPRINTF("xfer=%p\n", xfer);
1204 dwc2_abort_xfer(xfer, USBD_CANCELLED);
1205 }
1206
1207 void
1208 dwc2_device_isoc_close(usbd_pipe_handle pipe)
1209 {
1210 DPRINTF("\n");
1211
1212 dwc2_close_pipe(pipe);
1213 }
1214
1215 void
1216 dwc2_device_isoc_done(usbd_xfer_handle xfer)
1217 {
1218
1219 DPRINTF("\n");
1220 }
1221
1222
1223 usbd_status
1224 dwc2_device_start(usbd_xfer_handle xfer)
1225 {
1226 struct dwc2_xfer *dxfer = DWC2_XFER2DXFER(xfer);
1227 struct dwc2_pipe *dpipe = DWC2_XFER2DPIPE(xfer);
1228 struct dwc2_softc *sc = DWC2_XFER2SC(xfer);
1229 struct dwc2_hsotg *hsotg = sc->sc_hsotg;
1230 struct dwc2_hcd_urb *dwc2_urb;
1231
1232 usbd_device_handle dev = xfer->pipe->device;
1233 usb_endpoint_descriptor_t *ed = xfer->pipe->endpoint->edesc;
1234 uint8_t addr = dev->address;
1235 uint8_t xfertype = UE_GET_XFERTYPE(ed->bmAttributes);
1236 uint8_t epnum = UE_GET_ADDR(ed->bEndpointAddress);
1237 uint8_t dir = UE_GET_DIR(ed->bEndpointAddress);
1238 uint16_t mps = UE_GET_SIZE(UGETW(ed->wMaxPacketSize));
1239 uint32_t len;
1240
1241 uint32_t flags = 0;
1242 uint32_t off = 0;
1243 int retval, err = USBD_IN_PROGRESS;
1244 int alloc_bandwidth = 0;
1245 int i;
1246
1247 DPRINTFN(1, "xfer=%p pipe=%p\n", xfer, xfer->pipe);
1248
1249 if (xfertype == UE_ISOCHRONOUS ||
1250 xfertype == UE_INTERRUPT) {
1251 mutex_spin_enter(&hsotg->lock);
1252 if (!dwc2_hcd_is_bandwidth_allocated(hsotg, xfer))
1253 alloc_bandwidth = 1;
1254 mutex_spin_exit(&hsotg->lock);
1255 }
1256
1257 /*
1258 * For Control pipe the direction is from the request, all other
1259 * transfers have been set correctly at pipe open time.
1260 */
1261 if (xfertype == UE_CONTROL) {
1262 usb_device_request_t *req = &xfer->request;
1263
1264 DPRINTFN(3, "xfer=%p type=0x%02x request=0x%02x wValue=0x%04x "
1265 "wIndex=0x%04x len=%d addr=%d endpt=%d dir=%s speed=%d "
1266 "mps=%d\n",
1267 xfer, req->bmRequestType, req->bRequest, UGETW(req->wValue),
1268 UGETW(req->wIndex), UGETW(req->wLength), dev->address,
1269 epnum, dir == UT_READ ? "in" :"out", dev->speed, mps);
1270
1271 /* Copy request packet to our DMA buffer */
1272 memcpy(KERNADDR(&dpipe->req_dma, 0), req, sizeof(*req));
1273 usb_syncmem(&dpipe->req_dma, 0, sizeof(*req),
1274 BUS_DMASYNC_PREWRITE);
1275 len = UGETW(req->wLength);
1276 if ((req->bmRequestType & UT_READ) == UT_READ) {
1277 dir = UE_DIR_IN;
1278 } else {
1279 dir = UE_DIR_OUT;
1280 }
1281
1282 DPRINTFN(3, "req = %p dma = %" PRIxBUSADDR " len %d dir %s\n",
1283 KERNADDR(&dpipe->req_dma, 0), DMAADDR(&dpipe->req_dma, 0),
1284 len, dir == UE_DIR_IN ? "in" : "out");
1285 } else {
1286 DPRINTFN(3, "xfer=%p len=%d flags=%d addr=%d endpt=%d,"
1287 " mps=%d dir %s\n", xfer, xfer->length, xfer->flags, addr,
1288 epnum, mps, dir == UT_READ ? "in" :"out");
1289
1290 len = xfer->length;
1291 }
1292
1293 dwc2_urb = dxfer->urb;
1294 if (!dwc2_urb)
1295 return USBD_NOMEM;
1296
1297 memset(dwc2_urb, 0, sizeof(*dwc2_urb) +
1298 sizeof(dwc2_urb->iso_descs[0]) * DWC2_MAXISOCPACKETS);
1299
1300 dwc2_urb->priv = xfer;
1301 dwc2_hcd_urb_set_pipeinfo(hsotg, dwc2_urb, addr, epnum, xfertype, dir,
1302 mps);
1303
1304 if (xfertype == UE_CONTROL) {
1305 dwc2_urb->setup_usbdma = &dpipe->req_dma;
1306 dwc2_urb->setup_packet = KERNADDR(&dpipe->req_dma, 0);
1307 dwc2_urb->setup_dma = DMAADDR(&dpipe->req_dma, 0);
1308 } else {
1309 /* XXXNH - % mps required? */
1310 if ((xfer->flags & USBD_FORCE_SHORT_XFER) && (len % mps) == 0)
1311 flags |= URB_SEND_ZERO_PACKET;
1312 }
1313 flags |= URB_GIVEBACK_ASAP;
1314
1315 /* XXXNH this shouldn't be required */
1316 if (xfertype == UE_CONTROL && len == 0) {
1317 dwc2_urb->usbdma = &dpipe->req_dma;
1318 } else {
1319 dwc2_urb->usbdma = &xfer->dmabuf;
1320 }
1321 dwc2_urb->buf = KERNADDR(dwc2_urb->usbdma, 0);
1322 dwc2_urb->dma = DMAADDR(dwc2_urb->usbdma, 0);
1323 dwc2_urb->length = len;
1324 dwc2_urb->flags = flags;
1325 dwc2_urb->status = -EINPROGRESS;
1326 dwc2_urb->packet_count = xfer->nframes;
1327
1328 if (xfertype == UE_INTERRUPT ||
1329 xfertype == UE_ISOCHRONOUS) {
1330 uint16_t ival;
1331
1332 if (xfertype == UE_INTERRUPT &&
1333 dpipe->pipe.interval != USBD_DEFAULT_INTERVAL) {
1334 ival = dpipe->pipe.interval;
1335 } else {
1336 ival = ed->bInterval;
1337 }
1338
1339 if (ival < 1) {
1340 retval = -ENODEV;
1341 goto fail;
1342 }
1343 if (dev->speed == USB_SPEED_HIGH ||
1344 (dev->speed == USB_SPEED_FULL && xfertype == UE_ISOCHRONOUS)) {
1345 if (ival > 16) {
1346 /*
1347 * illegal with HS/FS, but there were
1348 * documentation bugs in the spec
1349 */
1350 ival = 256;
1351 } else {
1352 ival = (1 << (ival - 1));
1353 }
1354 } else {
1355 if (xfertype == UE_INTERRUPT && ival < 10)
1356 ival = 10;
1357 }
1358 dwc2_urb->interval = ival;
1359 }
1360
1361 /* XXXNH bring down from callers?? */
1362 // mutex_enter(&sc->sc_lock);
1363
1364 xfer->actlen = 0;
1365
1366 KASSERT(xfertype != UE_ISOCHRONOUS ||
1367 xfer->nframes < DWC2_MAXISOCPACKETS);
1368 KASSERTMSG(xfer->nframes == 0 || xfertype == UE_ISOCHRONOUS,
1369 "nframes %d xfertype %d\n", xfer->nframes, xfertype);
1370
1371 for (off = i = 0; i < xfer->nframes; ++i) {
1372 DPRINTFN(3, "xfer=%p frame=%d offset=%d length=%d\n", xfer, i,
1373 off, xfer->frlengths[i]);
1374
1375 dwc2_hcd_urb_set_iso_desc_params(dwc2_urb, i, off,
1376 xfer->frlengths[i]);
1377 off += xfer->frlengths[i];
1378 }
1379
1380 /* might need to check cpu_intr_p */
1381 retval = dwc2_hcd_urb_enqueue(hsotg, dwc2_urb, &dpipe->priv, 0);
1382 if (retval)
1383 goto fail;
1384
1385 if (xfer->timeout && !sc->sc_bus.use_polling) {
1386 callout_reset(&xfer->timeout_handle, mstohz(xfer->timeout),
1387 dwc2_timeout, xfer);
1388 }
1389
1390 if (alloc_bandwidth) {
1391 mutex_spin_enter(&hsotg->lock);
1392 dwc2_allocate_bus_bandwidth(hsotg,
1393 dwc2_hcd_get_ep_bandwidth(hsotg, dpipe),
1394 xfer);
1395 mutex_spin_exit(&hsotg->lock);
1396 }
1397
1398 fail:
1399 // mutex_exit(&sc->sc_lock);
1400
1401 switch (retval) {
1402 case 0:
1403 break;
1404 case -ENODEV:
1405 err = USBD_INVAL;
1406 break;
1407 case -ENOMEM:
1408 err = USBD_NOMEM;
1409 break;
1410 default:
1411 err = USBD_IOERROR;
1412 }
1413
1414 return err;
1415
1416 }
1417
1418 void
1419 dwc2_worker(struct work *wk, void *priv)
1420 {
1421 struct dwc2_softc *sc = priv;
1422 struct dwc2_hsotg *hsotg = sc->sc_hsotg;
1423
1424 Debugger();
1425 #if 0
1426 usbd_xfer_handle xfer = dwork->xfer;
1427 struct dwc2_xfer *dxfer = DWC2_XFER2DXFER(xfer);
1428
1429 dwc2_hcd_endpoint_disable(sc->dwc_dev.hcd, dpipe->priv, 250);
1430 dwc_free(NULL, dpipe->urb);
1431 #endif
1432
1433 mutex_enter(&sc->sc_lock);
1434 if (wk == &hsotg->wf_otg) {
1435 dwc2_conn_id_status_change(wk);
1436 } else if (wk == &hsotg->start_work.work) {
1437 dwc2_hcd_start_func(wk);
1438 } else if (wk == &hsotg->reset_work.work) {
1439 dwc2_hcd_reset_func(wk);
1440 } else {
1441 #if 0
1442 KASSERT(dwork->xfer != NULL);
1443 KASSERT(dxfer->queued == true);
1444
1445 if (!(xfer->hcflags & UXFER_ABORTING)) {
1446 dwc2_start_standard_chain(xfer);
1447 }
1448 dxfer->queued = false;
1449 cv_broadcast(&xfer->hccv);
1450 #endif
1451 }
1452 mutex_exit(&sc->sc_lock);
1453 }
1454
1455 int dwc2_intr(void *p)
1456 {
1457 struct dwc2_softc *sc = p;
1458 struct dwc2_hsotg *hsotg;
1459 int ret = 0;
1460
1461 if (sc == NULL)
1462 return 0;
1463
1464 hsotg = sc->sc_hsotg;
1465 mutex_spin_enter(&hsotg->lock);
1466
1467 if (sc->sc_dying || !device_has_power(sc->sc_dev))
1468 goto done;
1469
1470 if (sc->sc_bus.use_polling) {
1471 uint32_t intrs;
1472
1473 intrs = dwc2_read_core_intr(hsotg);
1474 DWC2_WRITE_4(hsotg, GINTSTS, intrs);
1475 } else {
1476 ret = dwc2_interrupt(sc);
1477 }
1478
1479 done:
1480 mutex_spin_exit(&hsotg->lock);
1481
1482 return ret;
1483 }
1484
1485 int
1486 dwc2_interrupt(struct dwc2_softc *sc)
1487 {
1488 int ret = 0;
1489
1490 if (sc->sc_hcdenabled) {
1491 ret |= dwc2_handle_hcd_intr(sc->sc_hsotg);
1492 }
1493
1494 ret |= dwc2_handle_common_intr(sc->sc_hsotg);
1495
1496 return ret;
1497 }
1498
1499 /***********************************************************************/
1500
1501 int
1502 dwc2_detach(struct dwc2_softc *sc, int flags)
1503 {
1504 int rv = 0;
1505
1506 if (sc->sc_child != NULL)
1507 rv = config_detach(sc->sc_child, flags);
1508
1509 return rv;
1510 }
1511
1512 bool
1513 dwc2_shutdown(device_t self, int flags)
1514 {
1515 struct dwc2_softc *sc = device_private(self);
1516
1517 sc = sc;
1518
1519 return true;
1520 }
1521
1522 void
1523 dwc2_childdet(device_t self, device_t child)
1524 {
1525 struct dwc2_softc *sc = device_private(self);
1526
1527 sc = sc;
1528 }
1529
1530 int
1531 dwc2_activate(device_t self, enum devact act)
1532 {
1533 struct dwc2_softc *sc = device_private(self);
1534
1535 sc = sc;
1536
1537 return 0;
1538 }
1539
1540 bool
1541 dwc2_resume(device_t dv, const pmf_qual_t *qual)
1542 {
1543 struct dwc2_softc *sc = device_private(dv);
1544
1545 sc = sc;
1546
1547 return true;
1548 }
1549
1550 bool
1551 dwc2_suspend(device_t dv, const pmf_qual_t *qual)
1552 {
1553 struct dwc2_softc *sc = device_private(dv);
1554
1555 sc = sc;
1556
1557 return true;
1558 }
1559
1560 /***********************************************************************/
1561 int
1562 dwc2_init(struct dwc2_softc *sc)
1563 {
1564 int err = 0;
1565
1566 sc->sc_bus.hci_private = sc;
1567 sc->sc_bus.usbrev = USBREV_2_0;
1568 sc->sc_bus.methods = &dwc2_bus_methods;
1569 sc->sc_bus.pipe_size = sizeof(struct dwc2_pipe);
1570 sc->sc_hcdenabled = false;
1571
1572 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
1573
1574 TAILQ_INIT(&sc->sc_complete);
1575
1576 sc->sc_rhc_si = softint_establish(SOFTINT_NET | SOFTINT_MPSAFE,
1577 dwc2_rhc, sc);
1578
1579 usb_setup_reserve(sc->sc_dev, &sc->sc_dma_reserve, sc->sc_bus.dmatag,
1580 USB_MEM_RESERVE);
1581
1582 sc->sc_xferpool = pool_cache_init(sizeof(struct dwc2_xfer), 0, 0, 0,
1583 "dwc2xfer", NULL, IPL_USB, NULL, NULL, NULL);
1584 sc->sc_qhpool = pool_cache_init(sizeof(struct dwc2_qh), 0, 0, 0,
1585 "dwc2qh", NULL, IPL_USB, NULL, NULL, NULL);
1586 sc->sc_qtdpool = pool_cache_init(sizeof(struct dwc2_qtd), 0, 0, 0,
1587 "dwc2qtd", NULL, IPL_USB, NULL, NULL, NULL);
1588
1589 sc->sc_hsotg = kmem_zalloc(sizeof(struct dwc2_hsotg), KM_SLEEP);
1590 if (sc->sc_hsotg == NULL) {
1591 err = ENOMEM;
1592 goto fail1;
1593 }
1594
1595 sc->sc_hsotg->hsotg_sc = sc;
1596 sc->sc_hsotg->dev = sc->sc_dev;
1597 sc->sc_hcdenabled = true;
1598
1599 err = dwc2_hcd_init(sc->sc_hsotg, sc->sc_params);
1600 if (err) {
1601 err = -err;
1602 goto fail2;
1603 }
1604
1605 return 0;
1606
1607 fail2:
1608 kmem_free(sc->sc_hsotg, sizeof(struct dwc2_hsotg));
1609 fail1:
1610 softint_disestablish(sc->sc_rhc_si);
1611
1612 return err;
1613 }
1614
1615 #if 0
1616 /*
1617 * curmode is a mode indication bit 0 = device, 1 = host
1618 */
1619 static const char * const intnames[32] = {
1620 "curmode", "modemis", "otgint", "sof",
1621 "rxflvl", "nptxfemp", "ginnakeff", "goutnakeff",
1622 "ulpickint", "i2cint", "erlysusp", "usbsusp",
1623 "usbrst", "enumdone", "isooutdrop", "eopf",
1624 "restore_done", "epmis", "iepint", "oepint",
1625 "incompisoin", "incomplp", "fetsusp", "resetdet",
1626 "prtint", "hchint", "ptxfemp", "lpm",
1627 "conidstschng", "disconnint", "sessreqint", "wkupint"
1628 };
1629
1630
1631 /***********************************************************************/
1632
1633 #endif
1634
1635
1636 void
1637 dw_callout(void *arg)
1638 {
1639 struct delayed_work *dw = arg;
1640
1641 workqueue_enqueue(dw->dw_wq, &dw->work, NULL);
1642 }
1643
1644 void dwc2_host_hub_info(struct dwc2_hsotg *hsotg, void *context, int *hub_addr,
1645 int *hub_port)
1646 {
1647 usbd_xfer_handle xfer = context;
1648 struct dwc2_pipe *dpipe = DWC2_XFER2DPIPE(xfer);
1649 usbd_device_handle dev = dpipe->pipe.device;
1650
1651 *hub_addr = dev->myhsport->parent->address;
1652 *hub_port = dev->myhsport->portno;
1653 }
1654
1655 int dwc2_host_get_speed(struct dwc2_hsotg *hsotg, void *context)
1656 {
1657 usbd_xfer_handle xfer = context;
1658 struct dwc2_pipe *dpipe = DWC2_XFER2DPIPE(xfer);
1659 usbd_device_handle dev = dpipe->pipe.device;
1660
1661 return dev->speed;
1662 }
1663
1664 /*
1665 * Sets the final status of an URB and returns it to the upper layer. Any
1666 * required cleanup of the URB is performed.
1667 *
1668 * Must be called with interrupt disabled and spinlock held
1669 */
1670 void dwc2_host_complete(struct dwc2_hsotg *hsotg, struct dwc2_qtd *qtd,
1671 int status)
1672 {
1673 usbd_xfer_handle xfer;
1674 struct dwc2_xfer *dxfer;
1675 struct dwc2_softc *sc;
1676 usb_endpoint_descriptor_t *ed;
1677 uint8_t xfertype;
1678
1679 if (!qtd) {
1680 dev_dbg(hsotg->dev, "## %s: qtd is NULL ##\n", __func__);
1681 return;
1682 }
1683
1684 if (!qtd->urb) {
1685 dev_dbg(hsotg->dev, "## %s: qtd->urb is NULL ##\n", __func__);
1686 return;
1687 }
1688
1689 xfer = qtd->urb->priv;
1690 if (!xfer) {
1691 dev_dbg(hsotg->dev, "## %s: urb->priv is NULL ##\n", __func__);
1692 return;
1693 }
1694
1695 dxfer = DWC2_XFER2DXFER(xfer);
1696 sc = DWC2_XFER2SC(xfer);
1697 ed = xfer->pipe->endpoint->edesc;
1698 xfertype = UE_GET_XFERTYPE(ed->bmAttributes);
1699
1700 xfer->actlen = dwc2_hcd_urb_get_actual_length(qtd->urb);
1701
1702 if (xfertype == UE_ISOCHRONOUS && dbg_perio()) {
1703 int i;
1704
1705 for (i = 0; i < xfer->nframes; i++)
1706 dev_vdbg(hsotg->dev, " ISO Desc %d status %d\n",
1707 i, qtd->urb->iso_descs[i].status);
1708 }
1709
1710 if (xfertype == UE_ISOCHRONOUS) {
1711 int i;
1712
1713 xfer->actlen = 0;
1714 for (i = 0; i < xfer->nframes; ++i) {
1715 xfer->frlengths[i] =
1716 dwc2_hcd_urb_get_iso_desc_actual_length(
1717 qtd->urb, i);
1718 xfer->actlen += xfer->frlengths[i];
1719 }
1720 }
1721
1722 if (!status) {
1723 if (!(xfer->flags & USBD_SHORT_XFER_OK) &&
1724 xfer->actlen < xfer->length)
1725 status = -EIO;
1726 }
1727
1728 switch (status) {
1729 case 0:
1730 xfer->status = USBD_NORMAL_COMPLETION;
1731 break;
1732 case -EPIPE:
1733 xfer->status = USBD_STALLED;
1734 break;
1735 case -ETIMEDOUT:
1736 xfer->status = USBD_TIMEOUT;
1737 break;
1738 case -EPROTO:
1739 xfer->status = USBD_INVAL;
1740 break;
1741 case -EIO:
1742 xfer->status = USBD_IOERROR;
1743 break;
1744 case -EOVERFLOW:
1745 xfer->status = USBD_IOERROR;
1746 break;
1747 default:
1748 printf("%s: unknown error status %d\n", __func__, status);
1749 }
1750
1751 if (xfertype == UE_ISOCHRONOUS ||
1752 xfertype == UE_INTERRUPT) {
1753 struct dwc2_pipe *dpipe = DWC2_XFER2DPIPE(xfer);
1754
1755 dwc2_free_bus_bandwidth(hsotg,
1756 dwc2_hcd_get_ep_bandwidth(hsotg, dpipe),
1757 xfer);
1758 }
1759
1760 qtd->urb = NULL;
1761 callout_stop(&xfer->timeout_handle);
1762
1763 KASSERT(mutex_owned(&hsotg->lock));
1764
1765 TAILQ_INSERT_TAIL(&sc->sc_complete, dxfer, xnext);
1766
1767 mutex_spin_exit(&hsotg->lock);
1768 usb_schedsoftintr(&sc->sc_bus);
1769 mutex_spin_enter(&hsotg->lock);
1770 }
1771
1772
1773 int
1774 _dwc2_hcd_start(struct dwc2_hsotg *hsotg)
1775 {
1776 dev_dbg(hsotg->dev, "DWC OTG HCD START\n");
1777
1778 mutex_spin_enter(&hsotg->lock);
1779
1780 hsotg->op_state = OTG_STATE_A_HOST;
1781
1782 dwc2_hcd_reinit(hsotg);
1783
1784 /*XXXNH*/
1785 delay(50);
1786
1787 mutex_spin_exit(&hsotg->lock);
1788 return 0;
1789 }
1790
1791 int dwc2_host_is_b_hnp_enabled(struct dwc2_hsotg *hsotg)
1792 {
1793
1794 return false;
1795 }
1796