sys/mips/cavium/usb/octusb.c

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