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