Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/mips/cavium/usb/octusb.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 #include <sys/cdefs.h> 2 __FBSDID("$FreeBSD$"); 3 4 /*- 5 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 6 * 7 * Copyright (c) 2010 Hans Petter Selasky. All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 /* 32 * This file contains the driver for Octeon Executive Library USB 33 * Controller driver API. 34 */ 35 36 /* TODO: The root HUB port callback is not yet implemented. */ 37 38 #include <sys/stdint.h> 39 #include <sys/stddef.h> 40 #include <sys/param.h> 41 #include <sys/queue.h> 42 #include <sys/types.h> 43 #include <sys/systm.h> 44 #include <sys/kernel.h> 45 #include <sys/bus.h> 46 #include <sys/module.h> 47 #include <sys/lock.h> 48 #include <sys/mutex.h> 49 #include <sys/condvar.h> 50 #include <sys/sysctl.h> 51 #include <sys/sx.h> 52 #include <sys/unistd.h> 53 #include <sys/callout.h> 54 #include <sys/malloc.h> 55 #include <sys/priv.h> 56 57 #include <dev/usb/usb.h> 58 #include <dev/usb/usbdi.h> 59 60 #define USB_DEBUG_VAR octusbdebug 61 62 #include <dev/usb/usb_core.h> 63 #include <dev/usb/usb_debug.h> 64 #include <dev/usb/usb_busdma.h> 65 #include <dev/usb/usb_process.h> 66 #include <dev/usb/usb_transfer.h> 67 #include <dev/usb/usb_device.h> 68 #include <dev/usb/usb_hub.h> 69 #include <dev/usb/usb_util.h> 70 71 #include <dev/usb/usb_controller.h> 72 #include <dev/usb/usb_bus.h> 73 74 #include <contrib/octeon-sdk/cvmx.h> 75 #include <contrib/octeon-sdk/cvmx-usb.h> 76 77 #include <mips/cavium/usb/octusb.h> 78 79 #define OCTUSB_BUS2SC(bus) \ 80 ((struct octusb_softc *)(((uint8_t *)(bus)) - \ 81 ((uint8_t *)&(((struct octusb_softc *)0)->sc_bus)))) 82 83 #ifdef USB_DEBUG 84 static int octusbdebug = 0; 85 86 static SYSCTL_NODE(_hw_usb, OID_AUTO, octusb, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 87 "OCTUSB"); 88 SYSCTL_INT(_hw_usb_octusb, OID_AUTO, debug, CTLFLAG_RWTUN, 89 &octusbdebug, 0, "OCTUSB debug level"); 90 #endif 91 92 struct octusb_std_temp { 93 octusb_cmd_t *func; 94 struct octusb_td *td; 95 struct octusb_td *td_next; 96 struct usb_page_cache *pc; 97 uint32_t offset; 98 uint32_t len; 99 uint8_t short_pkt; 100 uint8_t setup_alt_next; 101 }; 102 103 extern struct usb_bus_methods octusb_bus_methods; 104 extern struct usb_pipe_methods octusb_device_bulk_methods; 105 extern struct usb_pipe_methods octusb_device_ctrl_methods; 106 extern struct usb_pipe_methods octusb_device_intr_methods; 107 extern struct usb_pipe_methods octusb_device_isoc_methods; 108 109 static void octusb_standard_done(struct usb_xfer *); 110 static void octusb_device_done(struct usb_xfer *, usb_error_t); 111 static void octusb_timeout(void *); 112 static void octusb_do_poll(struct usb_bus *); 113 114 static cvmx_usb_speed_t 115 octusb_convert_speed(enum usb_dev_speed speed) 116 { 117 ; /* indent fix */ 118 switch (speed) { 119 case USB_SPEED_HIGH: 120 return (CVMX_USB_SPEED_HIGH); 121 case USB_SPEED_FULL: 122 return (CVMX_USB_SPEED_FULL); 123 default: 124 return (CVMX_USB_SPEED_LOW); 125 } 126 } 127 128 static cvmx_usb_transfer_t 129 octusb_convert_ep_type(uint8_t ep_type) 130 { 131 ; /* indent fix */ 132 switch (ep_type & UE_XFERTYPE) { 133 case UE_CONTROL: 134 return (CVMX_USB_TRANSFER_CONTROL); 135 case UE_INTERRUPT: 136 return (CVMX_USB_TRANSFER_INTERRUPT); 137 case UE_ISOCHRONOUS: 138 return (CVMX_USB_TRANSFER_ISOCHRONOUS); 139 case UE_BULK: 140 return (CVMX_USB_TRANSFER_BULK); 141 default: 142 return (0); /* should not happen */ 143 } 144 } 145 146 static uint8_t 147 octusb_host_alloc_endpoint(struct octusb_td *td) 148 { 149 struct octusb_softc *sc; 150 int ep_handle; 151 152 if (td->qh->fixup_pending) 153 return (1); /* busy */ 154 155 if (td->qh->ep_allocated) 156 return (0); /* success */ 157 158 /* get softc */ 159 sc = td->qh->sc; 160 161 ep_handle = cvmx_usb_open_pipe( 162 &sc->sc_port[td->qh->root_port_index].state, 163 0, 164 td->qh->dev_addr, 165 td->qh->ep_num & UE_ADDR, 166 octusb_convert_speed(td->qh->dev_speed), 167 td->qh->max_packet_size, 168 octusb_convert_ep_type(td->qh->ep_type), 169 (td->qh->ep_num & UE_DIR_IN) ? CVMX_USB_DIRECTION_IN : 170 CVMX_USB_DIRECTION_OUT, 171 td->qh->ep_interval, 172 (td->qh->dev_speed == USB_SPEED_HIGH) ? td->qh->ep_mult : 0, 173 td->qh->hs_hub_addr, 174 td->qh->hs_hub_port); 175 176 if (ep_handle < 0) { 177 DPRINTFN(1, "cvmx_usb_open_pipe failed: %d\n", ep_handle); 178 return (1); /* busy */ 179 } 180 181 cvmx_usb_set_toggle( 182 &sc->sc_port[td->qh->root_port_index].state, 183 ep_handle, td->qh->ep_toggle_next); 184 185 td->qh->fixup_handle = -1; 186 td->qh->fixup_complete = 0; 187 td->qh->fixup_len = 0; 188 td->qh->fixup_off = 0; 189 td->qh->fixup_pending = 0; 190 td->qh->fixup_actlen = 0; 191 192 td->qh->ep_handle = ep_handle; 193 td->qh->ep_allocated = 1; 194 195 return (0); /* success */ 196 } 197 198 static void 199 octusb_host_free_endpoint(struct octusb_td *td) 200 { 201 struct octusb_softc *sc; 202 203 if (td->qh->ep_allocated == 0) 204 return; 205 206 /* get softc */ 207 sc = td->qh->sc; 208 209 if (td->qh->fixup_handle >= 0) { 210 /* cancel, if any */ 211 cvmx_usb_cancel(&sc->sc_port[td->qh->root_port_index].state, 212 td->qh->ep_handle, td->qh->fixup_handle); 213 } 214 cvmx_usb_close_pipe(&sc->sc_port[td->qh->root_port_index].state, td->qh->ep_handle); 215 216 td->qh->ep_allocated = 0; 217 } 218 219 static void 220 octusb_complete_cb(cvmx_usb_state_t *state, 221 cvmx_usb_callback_t reason, 222 cvmx_usb_complete_t status, 223 int pipe_handle, int submit_handle, 224 int bytes_transferred, void *user_data) 225 { 226 struct octusb_td *td; 227 228 if (reason != CVMX_USB_CALLBACK_TRANSFER_COMPLETE) 229 return; 230 231 td = user_data; 232 233 td->qh->fixup_complete = 1; 234 td->qh->fixup_pending = 0; 235 td->qh->fixup_actlen = bytes_transferred; 236 td->qh->fixup_handle = -1; 237 238 switch (status) { 239 case CVMX_USB_COMPLETE_SUCCESS: 240 case CVMX_USB_COMPLETE_SHORT: 241 td->error_any = 0; 242 td->error_stall = 0; 243 break; 244 case CVMX_USB_COMPLETE_STALL: 245 td->error_stall = 1; 246 td->error_any = 1; 247 break; 248 default: 249 td->error_any = 1; 250 break; 251 } 252 } 253 254 static uint8_t 255 octusb_host_control_header_tx(struct octusb_td *td) 256 { 257 int status; 258 259 /* allocate endpoint and check pending */ 260 if (octusb_host_alloc_endpoint(td)) 261 return (1); /* busy */ 262 263 /* check error */ 264 if (td->error_any) 265 return (0); /* done */ 266 267 if (td->qh->fixup_complete != 0) { 268 /* clear complete flag */ 269 td->qh->fixup_complete = 0; 270 271 /* flush data */ 272 usb_pc_cpu_invalidate(td->qh->fixup_pc); 273 return (0); /* done */ 274 } 275 /* verify length */ 276 if (td->remainder != 8) { 277 td->error_any = 1; 278 return (0); /* done */ 279 } 280 usbd_copy_out(td->pc, td->offset, td->qh->fixup_buf, 8); 281 282 /* update offset and remainder */ 283 td->offset += 8; 284 td->remainder -= 8; 285 286 /* setup data length and offset */ 287 td->qh->fixup_len = UGETW(td->qh->fixup_buf + 6); 288 td->qh->fixup_off = 0; 289 290 if (td->qh->fixup_len > (OCTUSB_MAX_FIXUP - 8)) { 291 td->error_any = 1; 292 return (0); /* done */ 293 } 294 /* do control IN request */ 295 if (td->qh->fixup_buf[0] & UE_DIR_IN) { 296 struct octusb_softc *sc; 297 298 /* get softc */ 299 sc = td->qh->sc; 300 301 /* flush data */ 302 usb_pc_cpu_flush(td->qh->fixup_pc); 303 304 status = cvmx_usb_submit_control( 305 &sc->sc_port[td->qh->root_port_index].state, 306 td->qh->ep_handle, td->qh->fixup_phys, 307 td->qh->fixup_phys + 8, td->qh->fixup_len, 308 &octusb_complete_cb, td); 309 /* check status */ 310 if (status < 0) { 311 td->error_any = 1; 312 return (0); /* done */ 313 } 314 td->qh->fixup_handle = status; 315 td->qh->fixup_pending = 1; 316 td->qh->fixup_complete = 0; 317 318 return (1); /* busy */ 319 } 320 return (0); /* done */ 321 } 322 323 static uint8_t 324 octusb_host_control_data_tx(struct octusb_td *td) 325 { 326 uint32_t rem; 327 328 /* allocate endpoint and check pending */ 329 if (octusb_host_alloc_endpoint(td)) 330 return (1); /* busy */ 331 332 /* check error */ 333 if (td->error_any) 334 return (0); /* done */ 335 336 rem = td->qh->fixup_len - td->qh->fixup_off; 337 338 if (td->remainder > rem) { 339 td->error_any = 1; 340 DPRINTFN(1, "Excess setup transmit data\n"); 341 return (0); /* done */ 342 } 343 usbd_copy_out(td->pc, td->offset, td->qh->fixup_buf + 344 td->qh->fixup_off + 8, td->remainder); 345 346 td->offset += td->remainder; 347 td->qh->fixup_off += td->remainder; 348 td->remainder = 0; 349 350 return (0); /* done */ 351 } 352 353 static uint8_t 354 octusb_host_control_data_rx(struct octusb_td *td) 355 { 356 uint32_t rem; 357 358 /* allocate endpoint and check pending */ 359 if (octusb_host_alloc_endpoint(td)) 360 return (1); /* busy */ 361 362 /* check error */ 363 if (td->error_any) 364 return (0); /* done */ 365 366 /* copy data from buffer */ 367 rem = td->qh->fixup_actlen - td->qh->fixup_off; 368 369 if (rem > td->remainder) 370 rem = td->remainder; 371 372 usbd_copy_in(td->pc, td->offset, td->qh->fixup_buf + 373 td->qh->fixup_off + 8, rem); 374 375 td->offset += rem; 376 td->remainder -= rem; 377 td->qh->fixup_off += rem; 378 379 return (0); /* done */ 380 } 381 382 static uint8_t 383 octusb_host_control_status_tx(struct octusb_td *td) 384 { 385 int status; 386 387 /* allocate endpoint and check pending */ 388 if (octusb_host_alloc_endpoint(td)) 389 return (1); /* busy */ 390 391 /* check error */ 392 if (td->error_any) 393 return (0); /* done */ 394 395 if (td->qh->fixup_complete != 0) { 396 /* clear complete flag */ 397 td->qh->fixup_complete = 0; 398 /* done */ 399 return (0); 400 } 401 /* do control IN request */ 402 if (!(td->qh->fixup_buf[0] & UE_DIR_IN)) { 403 struct octusb_softc *sc; 404 405 /* get softc */ 406 sc = td->qh->sc; 407 408 /* flush data */ 409 usb_pc_cpu_flush(td->qh->fixup_pc); 410 411 /* start USB transfer */ 412 status = cvmx_usb_submit_control( 413 &sc->sc_port[td->qh->root_port_index].state, 414 td->qh->ep_handle, td->qh->fixup_phys, 415 td->qh->fixup_phys + 8, td->qh->fixup_len, 416 &octusb_complete_cb, td); 417 418 /* check status */ 419 if (status < 0) { 420 td->error_any = 1; 421 return (0); /* done */ 422 } 423 td->qh->fixup_handle = status; 424 td->qh->fixup_pending = 1; 425 td->qh->fixup_complete = 0; 426 427 return (1); /* busy */ 428 } 429 return (0); /* done */ 430 } 431 432 static uint8_t 433 octusb_non_control_data_tx(struct octusb_td *td) 434 { 435 struct octusb_softc *sc; 436 uint32_t rem; 437 int status; 438 439 /* allocate endpoint and check pending */ 440 if (octusb_host_alloc_endpoint(td)) 441 return (1); /* busy */ 442 443 /* check error */ 444 if (td->error_any) 445 return (0); /* done */ 446 447 if ((td->qh->fixup_complete != 0) && 448 ((td->qh->ep_type & UE_XFERTYPE) == UE_ISOCHRONOUS)) { 449 td->qh->fixup_complete = 0; 450 return (0); /* done */ 451 } 452 /* check complete */ 453 if (td->remainder == 0) { 454 if (td->short_pkt) 455 return (0); /* complete */ 456 /* else need to send a zero length packet */ 457 rem = 0; 458 td->short_pkt = 1; 459 } else { 460 /* get maximum length */ 461 rem = OCTUSB_MAX_FIXUP % td->qh->max_frame_size; 462 rem = OCTUSB_MAX_FIXUP - rem; 463 464 if (rem == 0) { 465 /* should not happen */ 466 DPRINTFN(1, "Fixup buffer is too small\n"); 467 td->error_any = 1; 468 return (0); /* done */ 469 } 470 /* get minimum length */ 471 if (rem > td->remainder) { 472 rem = td->remainder; 473 if ((rem == 0) || (rem % td->qh->max_frame_size)) 474 td->short_pkt = 1; 475 } 476 /* copy data into fixup buffer */ 477 usbd_copy_out(td->pc, td->offset, td->qh->fixup_buf, rem); 478 479 /* flush data */ 480 usb_pc_cpu_flush(td->qh->fixup_pc); 481 482 /* pre-increment TX buffer offset */ 483 td->offset += rem; 484 td->remainder -= rem; 485 } 486 487 /* get softc */ 488 sc = td->qh->sc; 489 490 switch (td->qh->ep_type & UE_XFERTYPE) { 491 case UE_ISOCHRONOUS: 492 td->qh->iso_pkt.offset = 0; 493 td->qh->iso_pkt.length = rem; 494 td->qh->iso_pkt.status = 0; 495 /* start USB transfer */ 496 status = cvmx_usb_submit_isochronous(&sc->sc_port[td->qh->root_port_index].state, 497 td->qh->ep_handle, 1, CVMX_USB_ISOCHRONOUS_FLAGS_ALLOW_SHORT | 498 CVMX_USB_ISOCHRONOUS_FLAGS_ASAP, 1, &td->qh->iso_pkt, 499 td->qh->fixup_phys, rem, &octusb_complete_cb, td); 500 break; 501 case UE_BULK: 502 /* start USB transfer */ 503 status = cvmx_usb_submit_bulk(&sc->sc_port[td->qh->root_port_index].state, 504 td->qh->ep_handle, td->qh->fixup_phys, rem, &octusb_complete_cb, td); 505 break; 506 case UE_INTERRUPT: 507 /* start USB transfer (interrupt or interrupt) */ 508 status = cvmx_usb_submit_interrupt(&sc->sc_port[td->qh->root_port_index].state, 509 td->qh->ep_handle, td->qh->fixup_phys, rem, &octusb_complete_cb, td); 510 break; 511 default: 512 status = -1; 513 break; 514 } 515 516 /* check status */ 517 if (status < 0) { 518 td->error_any = 1; 519 return (0); /* done */ 520 } 521 td->qh->fixup_handle = status; 522 td->qh->fixup_len = rem; 523 td->qh->fixup_pending = 1; 524 td->qh->fixup_complete = 0; 525 526 return (1); /* busy */ 527 } 528 529 static uint8_t 530 octusb_non_control_data_rx(struct octusb_td *td) 531 { 532 struct octusb_softc *sc; 533 uint32_t rem; 534 int status; 535 uint8_t got_short; 536 537 /* allocate endpoint and check pending */ 538 if (octusb_host_alloc_endpoint(td)) 539 return (1); /* busy */ 540 541 /* check error */ 542 if (td->error_any) 543 return (0); /* done */ 544 545 got_short = 0; 546 547 if (td->qh->fixup_complete != 0) { 548 /* invalidate data */ 549 usb_pc_cpu_invalidate(td->qh->fixup_pc); 550 551 rem = td->qh->fixup_actlen; 552 553 /* verify transfer length */ 554 if (rem != td->qh->fixup_len) { 555 if (rem < td->qh->fixup_len) { 556 /* we have a short packet */ 557 td->short_pkt = 1; 558 got_short = 1; 559 } else { 560 /* invalid USB packet */ 561 td->error_any = 1; 562 return (0); /* we are complete */ 563 } 564 } 565 /* copy data into fixup buffer */ 566 usbd_copy_in(td->pc, td->offset, td->qh->fixup_buf, rem); 567 568 /* post-increment RX buffer offset */ 569 td->offset += rem; 570 td->remainder -= rem; 571 572 td->qh->fixup_complete = 0; 573 574 if ((td->qh->ep_type & UE_XFERTYPE) == UE_ISOCHRONOUS) 575 return (0); /* done */ 576 } 577 /* check if we are complete */ 578 if ((td->remainder == 0) || got_short) { 579 if (td->short_pkt) { 580 /* we are complete */ 581 return (0); 582 } 583 /* else need to receive a zero length packet */ 584 rem = 0; 585 td->short_pkt = 1; 586 } else { 587 /* get maximum length */ 588 rem = OCTUSB_MAX_FIXUP % td->qh->max_frame_size; 589 rem = OCTUSB_MAX_FIXUP - rem; 590 591 if (rem == 0) { 592 /* should not happen */ 593 DPRINTFN(1, "Fixup buffer is too small\n"); 594 td->error_any = 1; 595 return (0); /* done */ 596 } 597 /* get minimum length */ 598 if (rem > td->remainder) 599 rem = td->remainder; 600 } 601 602 /* invalidate data */ 603 usb_pc_cpu_invalidate(td->qh->fixup_pc); 604 605 /* get softc */ 606 sc = td->qh->sc; 607 608 switch (td->qh->ep_type & UE_XFERTYPE) { 609 case UE_ISOCHRONOUS: 610 td->qh->iso_pkt.offset = 0; 611 td->qh->iso_pkt.length = rem; 612 td->qh->iso_pkt.status = 0; 613 /* start USB transfer */ 614 status = cvmx_usb_submit_isochronous(&sc->sc_port[td->qh->root_port_index].state, 615 td->qh->ep_handle, 1, CVMX_USB_ISOCHRONOUS_FLAGS_ALLOW_SHORT | 616 CVMX_USB_ISOCHRONOUS_FLAGS_ASAP, 1, &td->qh->iso_pkt, 617 td->qh->fixup_phys, rem, &octusb_complete_cb, td); 618 break; 619 case UE_BULK: 620 /* start USB transfer */ 621 status = cvmx_usb_submit_bulk(&sc->sc_port[td->qh->root_port_index].state, 622 td->qh->ep_handle, td->qh->fixup_phys, rem, &octusb_complete_cb, td); 623 break; 624 case UE_INTERRUPT: 625 /* start USB transfer */ 626 status = cvmx_usb_submit_interrupt(&sc->sc_port[td->qh->root_port_index].state, 627 td->qh->ep_handle, td->qh->fixup_phys, rem, &octusb_complete_cb, td); 628 break; 629 default: 630 status = -1; 631 break; 632 } 633 634 /* check status */ 635 if (status < 0) { 636 td->error_any = 1; 637 return (0); /* done */ 638 } 639 td->qh->fixup_handle = status; 640 td->qh->fixup_len = rem; 641 td->qh->fixup_pending = 1; 642 td->qh->fixup_complete = 0; 643 644 return (1); /* busy */ 645 } 646 647 static uint8_t 648 octusb_xfer_do_fifo(struct usb_xfer *xfer) 649 { 650 struct octusb_td *td; 651 652 DPRINTFN(8, "\n"); 653 654 td = xfer->td_transfer_cache; 655 656 while (1) { 657 if ((td->func) (td)) { 658 /* operation in progress */ 659 break; 660 } 661 if (((void *)td) == xfer->td_transfer_last) { 662 goto done; 663 } 664 if (td->error_any) { 665 goto done; 666 } else if (td->remainder > 0) { 667 /* 668 * We had a short transfer. If there is no 669 * alternate next, stop processing ! 670 */ 671 if (td->alt_next == 0) 672 goto done; 673 } 674 /* 675 * Fetch the next transfer descriptor and transfer 676 * some flags to the next transfer descriptor 677 */ 678 td = td->obj_next; 679 xfer->td_transfer_cache = td; 680 } 681 return (1); /* not complete */ 682 683 done: 684 /* compute all actual lengths */ 685 686 octusb_standard_done(xfer); 687 688 return (0); /* complete */ 689 } 690 691 static usb_error_t 692 octusb_standard_done_sub(struct usb_xfer *xfer) 693 { 694 struct octusb_td *td; 695 uint32_t len; 696 usb_error_t error; 697 698 DPRINTFN(8, "\n"); 699 700 td = xfer->td_transfer_cache; 701 702 do { 703 len = td->remainder; 704 705 if (xfer->aframes != xfer->nframes) { 706 /* 707 * Verify the length and subtract 708 * the remainder from "frlengths[]": 709 */ 710 if (len > xfer->frlengths[xfer->aframes]) { 711 td->error_any = 1; 712 } else { 713 xfer->frlengths[xfer->aframes] -= len; 714 } 715 } 716 /* Check for transfer error */ 717 if (td->error_any) { 718 /* the transfer is finished */ 719 error = td->error_stall ? USB_ERR_STALLED : USB_ERR_IOERROR; 720 td = NULL; 721 break; 722 } 723 /* Check for short transfer */ 724 if (len > 0) { 725 if (xfer->flags_int.short_frames_ok) { 726 /* follow alt next */ 727 if (td->alt_next) { 728 td = td->obj_next; 729 } else { 730 td = NULL; 731 } 732 } else { 733 /* the transfer is finished */ 734 td = NULL; 735 } 736 error = 0; 737 break; 738 } 739 td = td->obj_next; 740 741 /* this USB frame is complete */ 742 error = 0; 743 break; 744 745 } while (0); 746 747 /* update transfer cache */ 748 749 xfer->td_transfer_cache = td; 750 751 return (error); 752 } 753 754 static void 755 octusb_standard_done(struct usb_xfer *xfer) 756 { 757 struct octusb_softc *sc; 758 struct octusb_qh *qh; 759 usb_error_t error = 0; 760 761 DPRINTFN(12, "xfer=%p endpoint=%p transfer done\n", 762 xfer, xfer->endpoint); 763 764 /* reset scanner */ 765 766 xfer->td_transfer_cache = xfer->td_transfer_first; 767 768 if (xfer->flags_int.control_xfr) { 769 if (xfer->flags_int.control_hdr) 770 error = octusb_standard_done_sub(xfer); 771 772 xfer->aframes = 1; 773 774 if (xfer->td_transfer_cache == NULL) 775 goto done; 776 } 777 while (xfer->aframes != xfer->nframes) { 778 error = octusb_standard_done_sub(xfer); 779 780 xfer->aframes++; 781 782 if (xfer->td_transfer_cache == NULL) 783 goto done; 784 } 785 786 if (xfer->flags_int.control_xfr && 787 !xfer->flags_int.control_act) 788 error = octusb_standard_done_sub(xfer); 789 790 done: 791 /* update data toggle */ 792 793 qh = xfer->qh_start[0]; 794 sc = qh->sc; 795 796 xfer->endpoint->toggle_next = 797 cvmx_usb_get_toggle( 798 &sc->sc_port[qh->root_port_index].state, 799 qh->ep_handle) ? 1 : 0; 800 801 octusb_device_done(xfer, error); 802 } 803 804 static void 805 octusb_interrupt_poll(struct octusb_softc *sc) 806 { 807 struct usb_xfer *xfer; 808 uint8_t x; 809 810 /* poll all ports */ 811 for (x = 0; x != sc->sc_noport; x++) 812 cvmx_usb_poll(&sc->sc_port[x].state); 813 814 repeat: 815 TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) { 816 if (!octusb_xfer_do_fifo(xfer)) { 817 /* queue has been modified */ 818 goto repeat; 819 } 820 } 821 } 822 823 static void 824 octusb_start_standard_chain(struct usb_xfer *xfer) 825 { 826 DPRINTFN(8, "\n"); 827 828 /* poll one time */ 829 if (octusb_xfer_do_fifo(xfer)) { 830 /* put transfer on interrupt queue */ 831 usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); 832 833 /* start timeout, if any */ 834 if (xfer->timeout != 0) { 835 usbd_transfer_timeout_ms(xfer, 836 &octusb_timeout, xfer->timeout); 837 } 838 } 839 } 840 841 void 842 octusb_iterate_hw_softc(struct usb_bus *bus, usb_bus_mem_sub_cb_t *cb) 843 { 844 845 } 846 847 usb_error_t 848 octusb_init(struct octusb_softc *sc) 849 { 850 cvmx_usb_initialize_flags_t flags; 851 int status; 852 uint8_t x; 853 854 /* flush all cache into memory */ 855 856 usb_bus_mem_flush_all(&sc->sc_bus, &octusb_iterate_hw_softc); 857 858 /* set up the bus struct */ 859 sc->sc_bus.methods = &octusb_bus_methods; 860 861 /* get number of ports */ 862 sc->sc_noport = cvmx_usb_get_num_ports(); 863 864 /* check number of ports */ 865 if (sc->sc_noport > OCTUSB_MAX_PORTS) 866 sc->sc_noport = OCTUSB_MAX_PORTS; 867 868 /* set USB revision */ 869 sc->sc_bus.usbrev = USB_REV_2_0; 870 871 /* flags for port initialization */ 872 flags = CVMX_USB_INITIALIZE_FLAGS_CLOCK_AUTO; 873 #ifdef USB_DEBUG 874 if (octusbdebug > 100) 875 flags |= CVMX_USB_INITIALIZE_FLAGS_DEBUG_ALL; 876 #endif 877 878 USB_BUS_LOCK(&sc->sc_bus); 879 880 /* setup all ports */ 881 for (x = 0; x != sc->sc_noport; x++) { 882 status = cvmx_usb_initialize(&sc->sc_port[x].state, x, flags); 883 if (status < 0) 884 sc->sc_port[x].disabled = 1; 885 } 886 887 USB_BUS_UNLOCK(&sc->sc_bus); 888 889 /* catch lost interrupts */ 890 octusb_do_poll(&sc->sc_bus); 891 892 return (0); 893 } 894 895 usb_error_t 896 octusb_uninit(struct octusb_softc *sc) 897 { 898 uint8_t x; 899 900 USB_BUS_LOCK(&sc->sc_bus); 901 902 for (x = 0; x != sc->sc_noport; x++) { 903 if (sc->sc_port[x].disabled == 0) 904 cvmx_usb_shutdown(&sc->sc_port[x].state); 905 } 906 USB_BUS_UNLOCK(&sc->sc_bus); 907 908 return (0); 909 910 } 911 912 static void 913 octusb_suspend(struct octusb_softc *sc) 914 { 915 /* TODO */ 916 } 917 918 static void 919 octusb_resume(struct octusb_softc *sc) 920 { 921 /* TODO */ 922 } 923 924 /*------------------------------------------------------------------------* 925 * octusb_interrupt - OCTUSB interrupt handler 926 *------------------------------------------------------------------------*/ 927 void 928 octusb_interrupt(struct octusb_softc *sc) 929 { 930 USB_BUS_LOCK(&sc->sc_bus); 931 932 DPRINTFN(16, "real interrupt\n"); 933 934 /* poll all the USB transfers */ 935 octusb_interrupt_poll(sc); 936 937 USB_BUS_UNLOCK(&sc->sc_bus); 938 } 939 940 /*------------------------------------------------------------------------* 941 * octusb_timeout - OCTUSB transfer timeout handler 942 *------------------------------------------------------------------------*/ 943 static void 944 octusb_timeout(void *arg) 945 { 946 struct usb_xfer *xfer = arg; 947 948 DPRINTF("xfer=%p\n", xfer); 949 950 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED); 951 952 /* transfer is transferred */ 953 octusb_device_done(xfer, USB_ERR_TIMEOUT); 954 } 955 956 /*------------------------------------------------------------------------* 957 * octusb_do_poll - OCTUSB poll transfers 958 *------------------------------------------------------------------------*/ 959 static void 960 octusb_do_poll(struct usb_bus *bus) 961 { 962 struct octusb_softc *sc = OCTUSB_BUS2SC(bus); 963 964 USB_BUS_LOCK(&sc->sc_bus); 965 octusb_interrupt_poll(sc); 966 USB_BUS_UNLOCK(&sc->sc_bus); 967 } 968 969 static void 970 octusb_setup_standard_chain_sub(struct octusb_std_temp *temp) 971 { 972 struct octusb_td *td; 973 974 /* get current Transfer Descriptor */ 975 td = temp->td_next; 976 temp->td = td; 977 978 /* prepare for next TD */ 979 temp->td_next = td->obj_next; 980 981 /* fill out the Transfer Descriptor */ 982 td->func = temp->func; 983 td->pc = temp->pc; 984 td->offset = temp->offset; 985 td->remainder = temp->len; 986 td->error_any = 0; 987 td->error_stall = 0; 988 td->short_pkt = temp->short_pkt; 989 td->alt_next = temp->setup_alt_next; 990 } 991 992 static void 993 octusb_setup_standard_chain(struct usb_xfer *xfer) 994 { 995 struct octusb_std_temp temp; 996 struct octusb_td *td; 997 uint32_t x; 998 999 DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", 1000 xfer->address, UE_GET_ADDR(xfer->endpointno), 1001 xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); 1002 1003 /* setup starting point */ 1004 td = xfer->td_start[0]; 1005 xfer->td_transfer_first = td; 1006 xfer->td_transfer_cache = td; 1007 1008 temp.td = NULL; 1009 temp.td_next = td; 1010 temp.setup_alt_next = xfer->flags_int.short_frames_ok; 1011 temp.offset = 0; 1012 1013 /* check if we should prepend a setup message */ 1014 1015 if (xfer->flags_int.control_xfr) { 1016 if (xfer->flags_int.control_hdr) { 1017 temp.func = &octusb_host_control_header_tx; 1018 temp.len = xfer->frlengths[0]; 1019 temp.pc = xfer->frbuffers + 0; 1020 temp.short_pkt = temp.len ? 1 : 0; 1021 1022 /* check for last frame */ 1023 if (xfer->nframes == 1) { 1024 /* 1025 * no STATUS stage yet, SETUP is 1026 * last 1027 */ 1028 if (xfer->flags_int.control_act) 1029 temp.setup_alt_next = 0; 1030 } 1031 octusb_setup_standard_chain_sub(&temp); 1032 } 1033 x = 1; 1034 } else { 1035 x = 0; 1036 } 1037 1038 if (x != xfer->nframes) { 1039 if (xfer->endpointno & UE_DIR_IN) { 1040 if (xfer->flags_int.control_xfr) 1041 temp.func = &octusb_host_control_data_rx; 1042 else 1043 temp.func = &octusb_non_control_data_rx; 1044 } else { 1045 if (xfer->flags_int.control_xfr) 1046 temp.func = &octusb_host_control_data_tx; 1047 else 1048 temp.func = &octusb_non_control_data_tx; 1049 } 1050 1051 /* setup "pc" pointer */ 1052 temp.pc = xfer->frbuffers + x; 1053 } 1054 while (x != xfer->nframes) { 1055 /* DATA0 or DATA1 message */ 1056 1057 temp.len = xfer->frlengths[x]; 1058 1059 x++; 1060 1061 if (x == xfer->nframes) { 1062 if (xfer->flags_int.control_xfr) { 1063 /* no STATUS stage yet, DATA is last */ 1064 if (xfer->flags_int.control_act) 1065 temp.setup_alt_next = 0; 1066 } else { 1067 temp.setup_alt_next = 0; 1068 } 1069 } 1070 if (temp.len == 0) { 1071 /* make sure that we send an USB packet */ 1072 1073 temp.short_pkt = 0; 1074 1075 } else { 1076 /* regular data transfer */ 1077 1078 temp.short_pkt = (xfer->flags.force_short_xfer) ? 0 : 1; 1079 } 1080 1081 octusb_setup_standard_chain_sub(&temp); 1082 1083 if (xfer->flags_int.isochronous_xfr) { 1084 /* get next data offset */ 1085 temp.offset += temp.len; 1086 } else { 1087 /* get next Page Cache pointer */ 1088 temp.pc = xfer->frbuffers + x; 1089 } 1090 } 1091 1092 /* check if we should append a status stage */ 1093 1094 if (xfer->flags_int.control_xfr && 1095 !xfer->flags_int.control_act) { 1096 temp.func = &octusb_host_control_status_tx; 1097 temp.len = 0; 1098 temp.pc = NULL; 1099 temp.short_pkt = 0; 1100 temp.setup_alt_next = 0; 1101 1102 octusb_setup_standard_chain_sub(&temp); 1103 } 1104 /* must have at least one frame! */ 1105 td = temp.td; 1106 xfer->td_transfer_last = td; 1107 1108 /* properly setup QH */ 1109 1110 td->qh->ep_allocated = 0; 1111 td->qh->ep_toggle_next = xfer->endpoint->toggle_next ? 1 : 0; 1112 } 1113 1114 /*------------------------------------------------------------------------* 1115 * octusb_device_done - OCTUSB transfers done code 1116 * 1117 * NOTE: This function can be called more than one time in a row. 1118 *------------------------------------------------------------------------*/ 1119 static void 1120 octusb_device_done(struct usb_xfer *xfer, usb_error_t error) 1121 { 1122 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED); 1123 1124 DPRINTFN(2, "xfer=%p, endpoint=%p, error=%d\n", 1125 xfer, xfer->endpoint, error); 1126 1127 /* 1128 * 1) Free any endpoints. 1129 * 2) Control transfers can be split and we should not re-open 1130 * the data pipe between transactions unless there is an error. 1131 */ 1132 if ((xfer->flags_int.control_act == 0) || (error != 0)) { 1133 struct octusb_td *td; 1134 1135 td = xfer->td_start[0]; 1136 1137 octusb_host_free_endpoint(td); 1138 } 1139 /* dequeue transfer and start next transfer */ 1140 usbd_transfer_done(xfer, error); 1141 } 1142 1143 /*------------------------------------------------------------------------* 1144 * octusb bulk support 1145 *------------------------------------------------------------------------*/ 1146 static void 1147 octusb_device_bulk_open(struct usb_xfer *xfer) 1148 { 1149 return; 1150 } 1151 1152 static void 1153 octusb_device_bulk_close(struct usb_xfer *xfer) 1154 { 1155 octusb_device_done(xfer, USB_ERR_CANCELLED); 1156 } 1157 1158 static void 1159 octusb_device_bulk_enter(struct usb_xfer *xfer) 1160 { 1161 return; 1162 } 1163 1164 static void 1165 octusb_device_bulk_start(struct usb_xfer *xfer) 1166 { 1167 /* setup TDs */ 1168 octusb_setup_standard_chain(xfer); 1169 octusb_start_standard_chain(xfer); 1170 } 1171 1172 struct usb_pipe_methods octusb_device_bulk_methods = 1173 { 1174 .open = octusb_device_bulk_open, 1175 .close = octusb_device_bulk_close, 1176 .enter = octusb_device_bulk_enter, 1177 .start = octusb_device_bulk_start, 1178 }; 1179 1180 /*------------------------------------------------------------------------* 1181 * octusb control support 1182 *------------------------------------------------------------------------*/ 1183 static void 1184 octusb_device_ctrl_open(struct usb_xfer *xfer) 1185 { 1186 return; 1187 } 1188 1189 static void 1190 octusb_device_ctrl_close(struct usb_xfer *xfer) 1191 { 1192 octusb_device_done(xfer, USB_ERR_CANCELLED); 1193 } 1194 1195 static void 1196 octusb_device_ctrl_enter(struct usb_xfer *xfer) 1197 { 1198 return; 1199 } 1200 1201 static void 1202 octusb_device_ctrl_start(struct usb_xfer *xfer) 1203 { 1204 /* setup TDs */ 1205 octusb_setup_standard_chain(xfer); 1206 octusb_start_standard_chain(xfer); 1207 } 1208 1209 struct usb_pipe_methods octusb_device_ctrl_methods = 1210 { 1211 .open = octusb_device_ctrl_open, 1212 .close = octusb_device_ctrl_close, 1213 .enter = octusb_device_ctrl_enter, 1214 .start = octusb_device_ctrl_start, 1215 }; 1216 1217 /*------------------------------------------------------------------------* 1218 * octusb interrupt support 1219 *------------------------------------------------------------------------*/ 1220 static void 1221 octusb_device_intr_open(struct usb_xfer *xfer) 1222 { 1223 return; 1224 } 1225 1226 static void 1227 octusb_device_intr_close(struct usb_xfer *xfer) 1228 { 1229 octusb_device_done(xfer, USB_ERR_CANCELLED); 1230 } 1231 1232 static void 1233 octusb_device_intr_enter(struct usb_xfer *xfer) 1234 { 1235 return; 1236 } 1237 1238 static void 1239 octusb_device_intr_start(struct usb_xfer *xfer) 1240 { 1241 /* setup TDs */ 1242 octusb_setup_standard_chain(xfer); 1243 octusb_start_standard_chain(xfer); 1244 } 1245 1246 struct usb_pipe_methods octusb_device_intr_methods = 1247 { 1248 .open = octusb_device_intr_open, 1249 .close = octusb_device_intr_close, 1250 .enter = octusb_device_intr_enter, 1251 .start = octusb_device_intr_start, 1252 }; 1253 1254 /*------------------------------------------------------------------------* 1255 * octusb isochronous support 1256 *------------------------------------------------------------------------*/ 1257 static void 1258 octusb_device_isoc_open(struct usb_xfer *xfer) 1259 { 1260 return; 1261 } 1262 1263 static void 1264 octusb_device_isoc_close(struct usb_xfer *xfer) 1265 { 1266 octusb_device_done(xfer, USB_ERR_CANCELLED); 1267 } 1268 1269 static void 1270 octusb_device_isoc_enter(struct usb_xfer *xfer) 1271 { 1272 struct octusb_softc *sc = OCTUSB_BUS2SC(xfer->xroot->bus); 1273 uint32_t temp; 1274 uint32_t frame_count; 1275 uint32_t fs_frames; 1276 1277 DPRINTFN(5, "xfer=%p next=%d nframes=%d\n", 1278 xfer, xfer->endpoint->isoc_next, xfer->nframes); 1279 1280 /* get the current frame index */ 1281 1282 frame_count = cvmx_usb_get_frame_number( 1283 &sc->sc_port[xfer->xroot->udev->port_index].state); 1284 1285 /* 1286 * check if the frame index is within the window where the frames 1287 * will be inserted 1288 */ 1289 temp = (frame_count - xfer->endpoint->isoc_next) & 0x7FF; 1290 1291 if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) { 1292 fs_frames = (xfer->nframes + 7) / 8; 1293 } else { 1294 fs_frames = xfer->nframes; 1295 } 1296 1297 if ((xfer->endpoint->is_synced == 0) || (temp < fs_frames)) { 1298 /* 1299 * If there is data underflow or the pipe queue is 1300 * empty we schedule the transfer a few frames ahead 1301 * of the current frame position. Else two isochronous 1302 * transfers might overlap. 1303 */ 1304 xfer->endpoint->isoc_next = (frame_count + 3) & 0x7FF; 1305 xfer->endpoint->is_synced = 1; 1306 DPRINTFN(2, "start next=%d\n", xfer->endpoint->isoc_next); 1307 } 1308 /* 1309 * compute how many milliseconds the insertion is ahead of the 1310 * current frame position: 1311 */ 1312 temp = (xfer->endpoint->isoc_next - frame_count) & 0x7FF; 1313 1314 /* 1315 * pre-compute when the isochronous transfer will be finished: 1316 */ 1317 xfer->isoc_time_complete = 1318 usb_isoc_time_expand(&sc->sc_bus, frame_count) + temp + 1319 fs_frames; 1320 1321 /* compute frame number for next insertion */ 1322 xfer->endpoint->isoc_next += fs_frames; 1323 } 1324 1325 static void 1326 octusb_device_isoc_start(struct usb_xfer *xfer) 1327 { 1328 /* setup TDs */ 1329 octusb_setup_standard_chain(xfer); 1330 octusb_start_standard_chain(xfer); 1331 } 1332 1333 struct usb_pipe_methods octusb_device_isoc_methods = 1334 { 1335 .open = octusb_device_isoc_open, 1336 .close = octusb_device_isoc_close, 1337 .enter = octusb_device_isoc_enter, 1338 .start = octusb_device_isoc_start, 1339 }; 1340 1341 /*------------------------------------------------------------------------* 1342 * OCTUSB root HUB support 1343 *------------------------------------------------------------------------* 1344 * Simulate a hardware HUB by handling all the necessary requests. 1345 *------------------------------------------------------------------------*/ 1346 static const 1347 struct usb_device_descriptor octusb_devd = { 1348 .bLength = sizeof(octusb_devd), 1349 .bDescriptorType = UDESC_DEVICE, 1350 .bcdUSB = {0x00, 0x02}, 1351 .bDeviceClass = UDCLASS_HUB, 1352 .bDeviceSubClass = UDSUBCLASS_HUB, 1353 .bDeviceProtocol = UDPROTO_FSHUB, 1354 .bMaxPacketSize = 64, 1355 .idVendor = {0}, 1356 .idProduct = {0}, 1357 .bcdDevice = {0x00, 0x01}, 1358 .iManufacturer = 1, 1359 .iProduct = 2, 1360 .iSerialNumber = 0, 1361 .bNumConfigurations = 1, 1362 }; 1363 1364 static const 1365 struct usb_device_qualifier octusb_odevd = { 1366 .bLength = sizeof(octusb_odevd), 1367 .bDescriptorType = UDESC_DEVICE_QUALIFIER, 1368 .bcdUSB = {0x00, 0x02}, 1369 .bDeviceClass = UDCLASS_HUB, 1370 .bDeviceSubClass = UDSUBCLASS_HUB, 1371 .bDeviceProtocol = UDPROTO_FSHUB, 1372 .bMaxPacketSize0 = 0, 1373 .bNumConfigurations = 0, 1374 .bReserved = 0, 1375 }; 1376 1377 static const 1378 struct octusb_config_desc octusb_confd = { 1379 .confd = { 1380 .bLength = sizeof(struct usb_config_descriptor), 1381 .bDescriptorType = UDESC_CONFIG, 1382 .wTotalLength[0] = sizeof(octusb_confd), 1383 .bNumInterface = 1, 1384 .bConfigurationValue = 1, 1385 .iConfiguration = 0, 1386 .bmAttributes = UC_SELF_POWERED, 1387 .bMaxPower = 0 /* max power */ 1388 }, 1389 .ifcd = { 1390 .bLength = sizeof(struct usb_interface_descriptor), 1391 .bDescriptorType = UDESC_INTERFACE, 1392 .bNumEndpoints = 1, 1393 .bInterfaceClass = UICLASS_HUB, 1394 .bInterfaceSubClass = UISUBCLASS_HUB, 1395 .bInterfaceProtocol = UIPROTO_FSHUB, 1396 }, 1397 .endpd = { 1398 .bLength = sizeof(struct usb_endpoint_descriptor), 1399 .bDescriptorType = UDESC_ENDPOINT, 1400 .bEndpointAddress = UE_DIR_IN | OCTUSB_INTR_ENDPT, 1401 .bmAttributes = UE_INTERRUPT, 1402 .wMaxPacketSize[0] = 8, /* max packet (63 ports) */ 1403 .bInterval = 255, 1404 }, 1405 }; 1406 1407 static const 1408 struct usb_hub_descriptor_min octusb_hubd = 1409 { 1410 .bDescLength = sizeof(octusb_hubd), 1411 .bDescriptorType = UDESC_HUB, 1412 .bNbrPorts = 2, 1413 .wHubCharacteristics = {UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL, 0}, 1414 .bPwrOn2PwrGood = 50, 1415 .bHubContrCurrent = 0, 1416 .DeviceRemovable = {0x00}, /* all ports are removable */ 1417 }; 1418 1419 static usb_error_t 1420 octusb_roothub_exec(struct usb_device *udev, 1421 struct usb_device_request *req, const void **pptr, uint16_t *plength) 1422 { 1423 struct octusb_softc *sc = OCTUSB_BUS2SC(udev->bus); 1424 const void *ptr; 1425 const char *str_ptr; 1426 uint16_t value; 1427 uint16_t index; 1428 uint16_t status; 1429 uint16_t change; 1430 uint16_t len; 1431 usb_error_t err; 1432 cvmx_usb_port_status_t usb_port_status; 1433 1434 USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 1435 1436 /* XXX disable power save mode, hence it is not supported */ 1437 udev->power_mode = USB_POWER_MODE_ON; 1438 1439 /* buffer reset */ 1440 ptr = (const void *)&sc->sc_hub_desc.temp; 1441 len = 0; 1442 err = 0; 1443 1444 value = UGETW(req->wValue); 1445 index = UGETW(req->wIndex); 1446 1447 DPRINTFN(3, "type=0x%02x request=0x%02x wLen=0x%04x " 1448 "wValue=0x%04x wIndex=0x%04x\n", 1449 req->bmRequestType, req->bRequest, 1450 UGETW(req->wLength), value, index); 1451 1452 #define C(x,y) ((x) | ((y) << 8)) 1453 switch (C(req->bRequest, req->bmRequestType)) { 1454 case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE): 1455 case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE): 1456 case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT): 1457 break; 1458 case C(UR_GET_CONFIG, UT_READ_DEVICE): 1459 len = 1; 1460 sc->sc_hub_desc.temp[0] = sc->sc_conf; 1461 break; 1462 case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE): 1463 switch (value >> 8) { 1464 case UDESC_DEVICE: 1465 if ((value & 0xff) != 0) { 1466 err = USB_ERR_IOERROR; 1467 goto done; 1468 } 1469 len = sizeof(octusb_devd); 1470 1471 ptr = (const void *)&octusb_devd; 1472 break; 1473 1474 case UDESC_DEVICE_QUALIFIER: 1475 if ((value & 0xff) != 0) { 1476 err = USB_ERR_IOERROR; 1477 goto done; 1478 } 1479 len = sizeof(octusb_odevd); 1480 ptr = (const void *)&octusb_odevd; 1481 break; 1482 1483 case UDESC_CONFIG: 1484 if ((value & 0xff) != 0) { 1485 err = USB_ERR_IOERROR; 1486 goto done; 1487 } 1488 len = sizeof(octusb_confd); 1489 ptr = (const void *)&octusb_confd; 1490 break; 1491 1492 case UDESC_STRING: 1493 switch (value & 0xff) { 1494 case 0: /* Language table */ 1495 str_ptr = "\001"; 1496 break; 1497 1498 case 1: /* Vendor */ 1499 str_ptr = "Cavium Networks"; 1500 break; 1501 1502 case 2: /* Product */ 1503 str_ptr = "OCTUSB Root HUB"; 1504 break; 1505 1506 default: 1507 str_ptr = ""; 1508 break; 1509 } 1510 1511 len = usb_make_str_desc(sc->sc_hub_desc.temp, 1512 sizeof(sc->sc_hub_desc.temp), str_ptr); 1513 break; 1514 1515 default: 1516 err = USB_ERR_IOERROR; 1517 goto done; 1518 } 1519 break; 1520 case C(UR_GET_INTERFACE, UT_READ_INTERFACE): 1521 len = 1; 1522 sc->sc_hub_desc.temp[0] = 0; 1523 break; 1524 case C(UR_GET_STATUS, UT_READ_DEVICE): 1525 len = 2; 1526 USETW(sc->sc_hub_desc.stat.wStatus, UDS_SELF_POWERED); 1527 break; 1528 case C(UR_GET_STATUS, UT_READ_INTERFACE): 1529 case C(UR_GET_STATUS, UT_READ_ENDPOINT): 1530 len = 2; 1531 USETW(sc->sc_hub_desc.stat.wStatus, 0); 1532 break; 1533 case C(UR_SET_ADDRESS, UT_WRITE_DEVICE): 1534 if (value >= OCTUSB_MAX_DEVICES) { 1535 err = USB_ERR_IOERROR; 1536 goto done; 1537 } 1538 sc->sc_addr = value; 1539 break; 1540 case C(UR_SET_CONFIG, UT_WRITE_DEVICE): 1541 if ((value != 0) && (value != 1)) { 1542 err = USB_ERR_IOERROR; 1543 goto done; 1544 } 1545 sc->sc_conf = value; 1546 break; 1547 case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE): 1548 break; 1549 case C(UR_SET_FEATURE, UT_WRITE_DEVICE): 1550 case C(UR_SET_FEATURE, UT_WRITE_INTERFACE): 1551 case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT): 1552 err = USB_ERR_IOERROR; 1553 goto done; 1554 case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE): 1555 break; 1556 case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT): 1557 break; 1558 /* Hub requests */ 1559 case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_DEVICE): 1560 break; 1561 case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_OTHER): 1562 DPRINTFN(4, "UR_CLEAR_PORT_FEATURE " 1563 "port=%d feature=%d\n", 1564 index, value); 1565 if ((index < 1) || 1566 (index > sc->sc_noport) || 1567 sc->sc_port[index - 1].disabled) { 1568 err = USB_ERR_IOERROR; 1569 goto done; 1570 } 1571 index--; 1572 1573 switch (value) { 1574 case UHF_PORT_ENABLE: 1575 cvmx_usb_disable(&sc->sc_port[index].state); 1576 break; 1577 case UHF_PORT_SUSPEND: 1578 case UHF_PORT_RESET: 1579 break; 1580 case UHF_C_PORT_CONNECTION: 1581 cvmx_usb_set_status(&sc->sc_port[index].state, 1582 cvmx_usb_get_status(&sc->sc_port[index].state)); 1583 break; 1584 case UHF_C_PORT_ENABLE: 1585 cvmx_usb_set_status(&sc->sc_port[index].state, 1586 cvmx_usb_get_status(&sc->sc_port[index].state)); 1587 break; 1588 case UHF_C_PORT_OVER_CURRENT: 1589 cvmx_usb_set_status(&sc->sc_port[index].state, 1590 cvmx_usb_get_status(&sc->sc_port[index].state)); 1591 break; 1592 case UHF_C_PORT_RESET: 1593 sc->sc_isreset = 0; 1594 goto done; 1595 case UHF_C_PORT_SUSPEND: 1596 break; 1597 case UHF_PORT_CONNECTION: 1598 case UHF_PORT_OVER_CURRENT: 1599 case UHF_PORT_POWER: 1600 case UHF_PORT_LOW_SPEED: 1601 default: 1602 err = USB_ERR_IOERROR; 1603 goto done; 1604 } 1605 break; 1606 case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE): 1607 if ((value & 0xff) != 0) { 1608 err = USB_ERR_IOERROR; 1609 goto done; 1610 } 1611 sc->sc_hubd = octusb_hubd; 1612 sc->sc_hubd.bNbrPorts = sc->sc_noport; 1613 len = sizeof(sc->sc_hubd); 1614 ptr = (const void *)&sc->sc_hubd; 1615 break; 1616 case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE): 1617 len = 16; 1618 memset(sc->sc_hub_desc.temp, 0, 16); 1619 break; 1620 case C(UR_GET_STATUS, UT_READ_CLASS_OTHER): 1621 if ((index < 1) || 1622 (index > sc->sc_noport) || 1623 sc->sc_port[index - 1].disabled) { 1624 err = USB_ERR_IOERROR; 1625 goto done; 1626 } 1627 index--; 1628 1629 usb_port_status = cvmx_usb_get_status(&sc->sc_port[index].state); 1630 1631 status = change = 0; 1632 if (usb_port_status.connected) 1633 status |= UPS_CURRENT_CONNECT_STATUS; 1634 if (usb_port_status.port_enabled) 1635 status |= UPS_PORT_ENABLED; 1636 if (usb_port_status.port_over_current) 1637 status |= UPS_OVERCURRENT_INDICATOR; 1638 if (usb_port_status.port_powered) 1639 status |= UPS_PORT_POWER; 1640 1641 switch (usb_port_status.port_speed) { 1642 case CVMX_USB_SPEED_HIGH: 1643 status |= UPS_HIGH_SPEED; 1644 break; 1645 case CVMX_USB_SPEED_FULL: 1646 break; 1647 default: 1648 status |= UPS_LOW_SPEED; 1649 break; 1650 } 1651 1652 if (usb_port_status.connect_change) 1653 change |= UPS_C_CONNECT_STATUS; 1654 if (sc->sc_isreset) 1655 change |= UPS_C_PORT_RESET; 1656 1657 USETW(sc->sc_hub_desc.ps.wPortStatus, status); 1658 USETW(sc->sc_hub_desc.ps.wPortChange, change); 1659 1660 len = sizeof(sc->sc_hub_desc.ps); 1661 break; 1662 case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE): 1663 err = USB_ERR_IOERROR; 1664 goto done; 1665 case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE): 1666 break; 1667 case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER): 1668 if ((index < 1) || 1669 (index > sc->sc_noport) || 1670 sc->sc_port[index - 1].disabled) { 1671 err = USB_ERR_IOERROR; 1672 goto done; 1673 } 1674 index--; 1675 1676 switch (value) { 1677 case UHF_PORT_ENABLE: 1678 break; 1679 case UHF_PORT_RESET: 1680 cvmx_usb_disable(&sc->sc_port[index].state); 1681 if (cvmx_usb_enable(&sc->sc_port[index].state)) { 1682 err = USB_ERR_IOERROR; 1683 goto done; 1684 } 1685 sc->sc_isreset = 1; 1686 goto done; 1687 case UHF_PORT_POWER: 1688 /* pretend we turned on power */ 1689 goto done; 1690 case UHF_PORT_SUSPEND: 1691 case UHF_C_PORT_CONNECTION: 1692 case UHF_C_PORT_ENABLE: 1693 case UHF_C_PORT_OVER_CURRENT: 1694 case UHF_PORT_CONNECTION: 1695 case UHF_PORT_OVER_CURRENT: 1696 case UHF_PORT_LOW_SPEED: 1697 case UHF_C_PORT_SUSPEND: 1698 case UHF_C_PORT_RESET: 1699 default: 1700 err = USB_ERR_IOERROR; 1701 goto done; 1702 } 1703 break; 1704 default: 1705 err = USB_ERR_IOERROR; 1706 goto done; 1707 } 1708 done: 1709 *plength = len; 1710 *pptr = ptr; 1711 return (err); 1712 } 1713 1714 static void 1715 octusb_xfer_setup(struct usb_setup_params *parm) 1716 { 1717 struct usb_page_search page_info; 1718 struct usb_page_cache *pc; 1719 struct octusb_softc *sc; 1720 struct octusb_qh *qh; 1721 struct usb_xfer *xfer; 1722 struct usb_device *hub; 1723 void *last_obj; 1724 uint32_t n; 1725 uint32_t ntd; 1726 1727 sc = OCTUSB_BUS2SC(parm->udev->bus); 1728 xfer = parm->curr_xfer; 1729 qh = NULL; 1730 1731 /* 1732 * NOTE: This driver does not use any of the parameters that 1733 * are computed from the following values. Just set some 1734 * reasonable dummies: 1735 */ 1736 1737 parm->hc_max_packet_size = 0x400; 1738 parm->hc_max_packet_count = 3; 1739 parm->hc_max_frame_size = 0xC00; 1740 1741 usbd_transfer_setup_sub(parm); 1742 1743 if (parm->err) 1744 return; 1745 1746 /* Allocate a queue head */ 1747 1748 if (usbd_transfer_setup_sub_malloc( 1749 parm, &pc, sizeof(struct octusb_qh), 1750 USB_HOST_ALIGN, 1)) { 1751 parm->err = USB_ERR_NOMEM; 1752 return; 1753 } 1754 if (parm->buf) { 1755 usbd_get_page(pc, 0, &page_info); 1756 1757 qh = page_info.buffer; 1758 1759 /* fill out QH */ 1760 1761 qh->sc = OCTUSB_BUS2SC(xfer->xroot->bus); 1762 qh->max_frame_size = xfer->max_frame_size; 1763 qh->max_packet_size = xfer->max_packet_size; 1764 qh->ep_num = xfer->endpointno; 1765 qh->ep_type = xfer->endpoint->edesc->bmAttributes; 1766 qh->dev_addr = xfer->address; 1767 qh->dev_speed = usbd_get_speed(xfer->xroot->udev); 1768 qh->root_port_index = xfer->xroot->udev->port_index; 1769 /* We need Octeon USB HUB's port index, not the local port */ 1770 hub = xfer->xroot->udev->parent_hub; 1771 while(hub && hub->parent_hub) { 1772 qh->root_port_index = hub->port_index; 1773 hub = hub->parent_hub; 1774 } 1775 1776 switch (xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE) { 1777 case UE_INTERRUPT: 1778 if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) 1779 qh->ep_interval = xfer->interval * 8; 1780 else 1781 qh->ep_interval = xfer->interval * 1; 1782 break; 1783 case UE_ISOCHRONOUS: 1784 qh->ep_interval = 1 << xfer->fps_shift; 1785 break; 1786 default: 1787 qh->ep_interval = 0; 1788 break; 1789 } 1790 1791 qh->ep_mult = xfer->max_packet_count & 3; 1792 qh->hs_hub_addr = xfer->xroot->udev->hs_hub_addr; 1793 qh->hs_hub_port = xfer->xroot->udev->hs_port_no; 1794 } 1795 xfer->qh_start[0] = qh; 1796 1797 /* Allocate a fixup buffer */ 1798 1799 if (usbd_transfer_setup_sub_malloc( 1800 parm, &pc, OCTUSB_MAX_FIXUP, 1801 OCTUSB_MAX_FIXUP, 1)) { 1802 parm->err = USB_ERR_NOMEM; 1803 return; 1804 } 1805 if (parm->buf) { 1806 usbd_get_page(pc, 0, &page_info); 1807 1808 qh->fixup_phys = page_info.physaddr; 1809 qh->fixup_pc = pc; 1810 qh->fixup_buf = page_info.buffer; 1811 } 1812 /* Allocate transfer descriptors */ 1813 1814 last_obj = NULL; 1815 1816 ntd = xfer->nframes + 1 /* STATUS */ + 1 /* SYNC */ ; 1817 1818 if (usbd_transfer_setup_sub_malloc( 1819 parm, &pc, sizeof(struct octusb_td), 1820 USB_HOST_ALIGN, ntd)) { 1821 parm->err = USB_ERR_NOMEM; 1822 return; 1823 } 1824 if (parm->buf) { 1825 for (n = 0; n != ntd; n++) { 1826 struct octusb_td *td; 1827 1828 usbd_get_page(pc + n, 0, &page_info); 1829 1830 td = page_info.buffer; 1831 1832 td->qh = qh; 1833 td->obj_next = last_obj; 1834 1835 last_obj = td; 1836 } 1837 } 1838 xfer->td_start[0] = last_obj; 1839 } 1840 1841 static void 1842 octusb_ep_init(struct usb_device *udev, struct usb_endpoint_descriptor *edesc, 1843 struct usb_endpoint *ep) 1844 { 1845 struct octusb_softc *sc = OCTUSB_BUS2SC(udev->bus); 1846 1847 DPRINTFN(2, "endpoint=%p, addr=%d, endpt=%d, mode=%d (%d)\n", 1848 ep, udev->address, edesc->bEndpointAddress, 1849 udev->flags.usb_mode, sc->sc_addr); 1850 1851 if (udev->device_index != sc->sc_addr) { 1852 switch (edesc->bmAttributes & UE_XFERTYPE) { 1853 case UE_CONTROL: 1854 ep->methods = &octusb_device_ctrl_methods; 1855 break; 1856 case UE_INTERRUPT: 1857 ep->methods = &octusb_device_intr_methods; 1858 break; 1859 case UE_ISOCHRONOUS: 1860 if (udev->speed != USB_SPEED_LOW) 1861 ep->methods = &octusb_device_isoc_methods; 1862 break; 1863 case UE_BULK: 1864 ep->methods = &octusb_device_bulk_methods; 1865 break; 1866 default: 1867 /* do nothing */ 1868 break; 1869 } 1870 } 1871 } 1872 1873 static void 1874 octusb_xfer_unsetup(struct usb_xfer *xfer) 1875 { 1876 DPRINTF("Nothing to do.\n"); 1877 } 1878 1879 static void 1880 octusb_get_dma_delay(struct usb_device *udev, uint32_t *pus) 1881 { 1882 /* DMA delay - wait until any use of memory is finished */ 1883 *pus = (2125); /* microseconds */ 1884 } 1885 1886 static void 1887 octusb_device_resume(struct usb_device *udev) 1888 { 1889 DPRINTF("Nothing to do.\n"); 1890 } 1891 1892 static void 1893 octusb_device_suspend(struct usb_device *udev) 1894 { 1895 DPRINTF("Nothing to do.\n"); 1896 } 1897 1898 static void 1899 octusb_set_hw_power(struct usb_bus *bus) 1900 { 1901 DPRINTF("Nothing to do.\n"); 1902 } 1903 1904 static void 1905 octusb_set_hw_power_sleep(struct usb_bus *bus, uint32_t state) 1906 { 1907 struct octusb_softc *sc = OCTUSB_BUS2SC(bus); 1908 1909 switch (state) { 1910 case USB_HW_POWER_SUSPEND: 1911 octusb_suspend(sc); 1912 break; 1913 case USB_HW_POWER_SHUTDOWN: 1914 octusb_uninit(sc); 1915 break; 1916 case USB_HW_POWER_RESUME: 1917 octusb_resume(sc); 1918 break; 1919 default: 1920 break; 1921 } 1922 } 1923 1924 struct usb_bus_methods octusb_bus_methods = { 1925 .endpoint_init = octusb_ep_init, 1926 .xfer_setup = octusb_xfer_setup, 1927 .xfer_unsetup = octusb_xfer_unsetup, 1928 .get_dma_delay = octusb_get_dma_delay, 1929 .device_resume = octusb_device_resume, 1930 .device_suspend = octusb_device_suspend, 1931 .set_hw_power = octusb_set_hw_power, 1932 .set_hw_power_sleep = octusb_set_hw_power_sleep, 1933 .roothub_exec = octusb_roothub_exec, 1934 .xfer_poll = octusb_do_poll, 1935 };
Cache object: a0da1d44a5d15745f14bb685b45af344
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]