sys/mips/cavium/usb/octusb.c

   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 };