qemu/roms/ipxe/src/drivers/usb/ehci.c

   1 /*
   2  * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <string.h>
  29 #include <strings.h>
  30 #include <errno.h>
  31 #include <byteswap.h>
  32 #include <ipxe/malloc.h>
  33 #include <ipxe/pci.h>
  34 #include <ipxe/usb.h>
  35 #include <ipxe/init.h>
  36 #include "ehci.h"
  37
  38 /** @file
  39  *
  40  * USB Enhanced Host Controller Interface (EHCI) driver
  41  *
  42  */
  43
  44 /**
  45  * Construct error code from transfer descriptor status
  46  *
  47  * @v status            Transfer descriptor status
  48  * @ret rc              Error code
  49  *
  50  * Bits 2-5 of the status code provide some indication as to the root
  51  * cause of the error.  We incorporate these into the error code as
  52  * reported to usb_complete_err().
  53  */
  54 #define EIO_STATUS( status ) EUNIQ ( EINFO_EIO, ( ( (status) >> 2 ) & 0xf ) )
  55
  56 /******************************************************************************
  57  *
  58  * Register access
  59  *
  60  ******************************************************************************
  61  */
  62
  63 /**
  64  * Initialise device
  65  *
  66  * @v ehci              EHCI device
  67  * @v regs              MMIO registers
  68  */
  69 static void ehci_init ( struct ehci_device *ehci, void *regs ) {
  70         uint32_t hcsparams;
  71         uint32_t hccparams;
  72         size_t caplength;
  73
  74         /* Locate capability and operational registers */
  75         ehci->cap = regs;
  76         caplength = readb ( ehci->cap + EHCI_CAP_CAPLENGTH );
  77         ehci->op = ( ehci->cap + caplength );
  78         DBGC2 ( ehci, "EHCI %s cap %08lx op %08lx\n", ehci->name,
  79                 virt_to_phys ( ehci->cap ), virt_to_phys ( ehci->op ) );
  80
  81         /* Read structural parameters */
  82         hcsparams = readl ( ehci->cap + EHCI_CAP_HCSPARAMS );
  83         ehci->ports = EHCI_HCSPARAMS_PORTS ( hcsparams );
  84         DBGC ( ehci, "EHCI %s has %d ports\n", ehci->name, ehci->ports );
  85
  86         /* Read capability parameters 1 */
  87         hccparams = readl ( ehci->cap + EHCI_CAP_HCCPARAMS );
  88         ehci->addr64 = EHCI_HCCPARAMS_ADDR64 ( hccparams );
  89         ehci->flsize = ( EHCI_HCCPARAMS_FLSIZE ( hccparams ) ?
  90                          EHCI_FLSIZE_SMALL : EHCI_FLSIZE_DEFAULT );
  91         ehci->eecp = EHCI_HCCPARAMS_EECP ( hccparams );
  92         DBGC2 ( ehci, "EHCI %s %d-bit flsize %d\n", ehci->name,
  93                 ( ehci->addr64 ? 64 : 32 ), ehci->flsize );
  94 }
  95
  96 /**
  97  * Find extended capability
  98  *
  99  * @v ehci              EHCI device
 100  * @v pci               PCI device
 101  * @v id                Capability ID
 102  * @v offset            Offset to previous extended capability instance, or zero
 103  * @ret offset          Offset to extended capability, or zero if not found
 104  */
 105 static unsigned int ehci_extended_capability ( struct ehci_device *ehci,
 106                                                struct pci_device *pci,
 107                                                unsigned int id,
 108                                                unsigned int offset ) {
 109         uint32_t eecp;
 110
 111         /* Locate the extended capability */
 112         while ( 1 ) {
 113
 114                 /* Locate first or next capability as applicable */
 115                 if ( offset ) {
 116                         pci_read_config_dword ( pci, offset, &eecp );
 117                         offset = EHCI_EECP_NEXT ( eecp );
 118                 } else {
 119                         offset = ehci->eecp;
 120                 }
 121                 if ( ! offset )
 122                         return 0;
 123
 124                 /* Check if this is the requested capability */
 125                 pci_read_config_dword ( pci, offset, &eecp );
 126                 if ( EHCI_EECP_ID ( eecp ) == id )
 127                         return offset;
 128         }
 129 }
 130
 131 /**
 132  * Calculate buffer alignment
 133  *
 134  * @v len               Length
 135  * @ret align           Buffer alignment
 136  *
 137  * Determine alignment required for a buffer which must be aligned to
 138  * at least EHCI_MIN_ALIGN and which must not cross a page boundary.
 139  */
 140 static inline size_t ehci_align ( size_t len ) {
 141         size_t align;
 142
 143         /* Align to own length (rounded up to a power of two) */
 144         align = ( 1 << fls ( len - 1 ) );
 145
 146         /* Round up to EHCI_MIN_ALIGN if needed */
 147         if ( align < EHCI_MIN_ALIGN )
 148                 align = EHCI_MIN_ALIGN;
 149
 150         return align;
 151 }
 152
 153 /**
 154  * Check control data structure reachability
 155  *
 156  * @v ehci              EHCI device
 157  * @v ptr               Data structure pointer
 158  * @ret rc              Return status code
 159  */
 160 static int ehci_ctrl_reachable ( struct ehci_device *ehci, void *ptr ) {
 161         physaddr_t phys = virt_to_phys ( ptr );
 162         uint32_t segment;
 163
 164         /* Always reachable in a 32-bit build */
 165         if ( sizeof ( physaddr_t ) <= sizeof ( uint32_t ) )
 166                 return 0;
 167
 168         /* Reachable only if control segment matches in a 64-bit build */
 169         segment = ( ( ( uint64_t ) phys ) >> 32 );
 170         if ( segment == ehci->ctrldssegment )
 171                 return 0;
 172
 173         return -ENOTSUP;
 174 }
 175
 176 /******************************************************************************
 177  *
 178  * USB legacy support
 179  *
 180  ******************************************************************************
 181  */
 182
 183 /** Prevent the release of ownership back to BIOS */
 184 static int ehci_legacy_prevent_release;
 185
 186 /**
 187  * Initialise USB legacy support
 188  *
 189  * @v ehci              EHCI device
 190  * @v pci               PCI device
 191  */
 192 static void ehci_legacy_init ( struct ehci_device *ehci,
 193                                struct pci_device *pci ) {
 194         unsigned int legacy;
 195         uint8_t bios;
 196
 197         /* Locate USB legacy support capability (if present) */
 198         legacy = ehci_extended_capability ( ehci, pci, EHCI_EECP_ID_LEGACY, 0 );
 199         if ( ! legacy ) {
 200                 /* Not an error; capability may not be present */
 201                 DBGC ( ehci, "EHCI %s has no USB legacy support capability\n",
 202                        ehci->name );
 203                 return;
 204         }
 205
 206         /* Check if legacy USB support is enabled */
 207         pci_read_config_byte ( pci, ( legacy + EHCI_USBLEGSUP_BIOS ), &bios );
 208         if ( ! ( bios & EHCI_USBLEGSUP_BIOS_OWNED ) ) {
 209                 /* Not an error; already owned by OS */
 210                 DBGC ( ehci, "EHCI %s USB legacy support already disabled\n",
 211                        ehci->name );
 212                 return;
 213         }
 214
 215         /* Record presence of USB legacy support capability */
 216         ehci->legacy = legacy;
 217 }
 218
 219 /**
 220  * Claim ownership from BIOS
 221  *
 222  * @v ehci              EHCI device
 223  * @v pci               PCI device
 224  */
 225 static void ehci_legacy_claim ( struct ehci_device *ehci,
 226                                 struct pci_device *pci ) {
 227         unsigned int legacy = ehci->legacy;
 228         uint32_t ctlsts;
 229         uint8_t bios;
 230         unsigned int i;
 231
 232         /* Do nothing unless legacy support capability is present */
 233         if ( ! legacy )
 234                 return;
 235
 236         /* Claim ownership */
 237         pci_write_config_byte ( pci, ( legacy + EHCI_USBLEGSUP_OS ),
 238                                 EHCI_USBLEGSUP_OS_OWNED );
 239
 240         /* Wait for BIOS to release ownership */
 241         for ( i = 0 ; i < EHCI_USBLEGSUP_MAX_WAIT_MS ; i++ ) {
 242
 243                 /* Check if BIOS has released ownership */
 244                 pci_read_config_byte ( pci, ( legacy + EHCI_USBLEGSUP_BIOS ),
 245                                        &bios );
 246                 if ( ! ( bios & EHCI_USBLEGSUP_BIOS_OWNED ) ) {
 247                         DBGC ( ehci, "EHCI %s claimed ownership from BIOS\n",
 248                                ehci->name );
 249                         pci_read_config_dword ( pci, ( legacy +
 250                                                        EHCI_USBLEGSUP_CTLSTS ),
 251                                                 &ctlsts );
 252                         if ( ctlsts ) {
 253                                 DBGC ( ehci, "EHCI %s warning: BIOS retained "
 254                                        "SMIs: %08x\n", ehci->name, ctlsts );
 255                         }
 256                         return;
 257                 }
 258
 259                 /* Delay */
 260                 mdelay ( 1 );
 261         }
 262
 263         /* BIOS did not release ownership.  Claim it forcibly by
 264          * disabling all SMIs.
 265          */
 266         DBGC ( ehci, "EHCI %s could not claim ownership from BIOS: forcibly "
 267                "disabling SMIs\n", ehci->name );
 268         pci_write_config_dword ( pci, ( legacy + EHCI_USBLEGSUP_CTLSTS ), 0 );
 269 }
 270
 271 /**
 272  * Release ownership back to BIOS
 273  *
 274  * @v ehci              EHCI device
 275  * @v pci               PCI device
 276  */
 277 static void ehci_legacy_release ( struct ehci_device *ehci,
 278                                   struct pci_device *pci ) {
 279
 280         /* Do nothing unless legacy support capability is present */
 281         if ( ! ehci->legacy )
 282                 return;
 283
 284         /* Do nothing if releasing ownership is prevented */
 285         if ( ehci_legacy_prevent_release ) {
 286                 DBGC ( ehci, "EHCI %s not releasing ownership to BIOS\n",
 287                        ehci->name );
 288                 return;
 289         }
 290
 291         /* Release ownership */
 292         pci_write_config_byte ( pci, ( ehci->legacy + EHCI_USBLEGSUP_OS ), 0 );
 293         DBGC ( ehci, "EHCI %s released ownership to BIOS\n", ehci->name );
 294 }
 295
 296 /******************************************************************************
 297  *
 298  * Companion controllers
 299  *
 300  ******************************************************************************
 301  */
 302
 303 /**
 304  * Poll child companion controllers
 305  *
 306  * @v ehci              EHCI device
 307  */
 308 static void ehci_poll_companions ( struct ehci_device *ehci ) {
 309         struct usb_bus *bus;
 310         struct device_description *desc;
 311
 312         /* Poll any USB buses belonging to child companion controllers */
 313         for_each_usb_bus ( bus ) {
 314
 315                 /* Get underlying devices description */
 316                 desc = &bus->dev->desc;
 317
 318                 /* Skip buses that are not PCI devices */
 319                 if ( desc->bus_type != BUS_TYPE_PCI )
 320                         continue;
 321
 322                 /* Skip buses that are not part of the same PCI device */
 323                 if ( PCI_FIRST_FUNC ( desc->location ) !=
 324                      PCI_FIRST_FUNC ( ehci->bus->dev->desc.location ) )
 325                         continue;
 326
 327                 /* Skip buses that are not UHCI or OHCI PCI devices */
 328                 if ( ( desc->class != PCI_CLASS ( PCI_CLASS_SERIAL,
 329                                                   PCI_CLASS_SERIAL_USB,
 330                                                   PCI_CLASS_SERIAL_USB_UHCI ))&&
 331                      ( desc->class != PCI_CLASS ( PCI_CLASS_SERIAL,
 332                                                   PCI_CLASS_SERIAL_USB,
 333                                                   PCI_CLASS_SERIAL_USB_OHCI ) ))
 334                         continue;
 335
 336                 /* Poll child companion controller bus */
 337                 DBGC2 ( ehci, "EHCI %s polling companion %s\n",
 338                         ehci->name, bus->name );
 339                 usb_poll ( bus );
 340         }
 341 }
 342
 343 /**
 344  * Locate EHCI companion controller
 345  *
 346  * @v pci               PCI device
 347  * @ret busdevfn        EHCI companion controller bus:dev.fn (if any)
 348  */
 349 unsigned int ehci_companion ( struct pci_device *pci ) {
 350         struct pci_device tmp;
 351         unsigned int busdevfn;
 352         int rc;
 353
 354         /* Look for an EHCI function on the same PCI device */
 355         busdevfn = pci->busdevfn;
 356         while ( ++busdevfn <= PCI_LAST_FUNC ( pci->busdevfn ) ) {
 357                 pci_init ( &tmp, busdevfn );
 358                 if ( ( rc = pci_read_config ( &tmp ) ) != 0 )
 359                         continue;
 360                 if ( tmp.class == PCI_CLASS ( PCI_CLASS_SERIAL,
 361                                               PCI_CLASS_SERIAL_USB,
 362                                               PCI_CLASS_SERIAL_USB_EHCI ) )
 363                         return busdevfn;
 364         }
 365
 366         return 0;
 367 }
 368
 369 /******************************************************************************
 370  *
 371  * Run / stop / reset
 372  *
 373  ******************************************************************************
 374  */
 375
 376 /**
 377  * Start EHCI device
 378  *
 379  * @v ehci              EHCI device
 380  */
 381 static void ehci_run ( struct ehci_device *ehci ) {
 382         uint32_t usbcmd;
 383
 384         /* Set run/stop bit */
 385         usbcmd = readl ( ehci->op + EHCI_OP_USBCMD );
 386         usbcmd &= ~EHCI_USBCMD_FLSIZE_MASK;
 387         usbcmd |= ( EHCI_USBCMD_RUN | EHCI_USBCMD_FLSIZE ( ehci->flsize ) |
 388                     EHCI_USBCMD_PERIODIC | EHCI_USBCMD_ASYNC );
 389         writel ( usbcmd, ehci->op + EHCI_OP_USBCMD );
 390 }
 391
 392 /**
 393  * Stop EHCI device
 394  *
 395  * @v ehci              EHCI device
 396  * @ret rc              Return status code
 397  */
 398 static int ehci_stop ( struct ehci_device *ehci ) {
 399         uint32_t usbcmd;
 400         uint32_t usbsts;
 401         unsigned int i;
 402
 403         /* Clear run/stop bit */
 404         usbcmd = readl ( ehci->op + EHCI_OP_USBCMD );
 405         usbcmd &= ~( EHCI_USBCMD_RUN | EHCI_USBCMD_PERIODIC |
 406                      EHCI_USBCMD_ASYNC );
 407         writel ( usbcmd, ehci->op + EHCI_OP_USBCMD );
 408
 409         /* Wait for device to stop */
 410         for ( i = 0 ; i < EHCI_STOP_MAX_WAIT_MS ; i++ ) {
 411
 412                 /* Check if device is stopped */
 413                 usbsts = readl ( ehci->op + EHCI_OP_USBSTS );
 414                 if ( usbsts & EHCI_USBSTS_HCH )
 415                         return 0;
 416
 417                 /* Delay */
 418                 mdelay ( 1 );
 419         }
 420
 421         DBGC ( ehci, "EHCI %s timed out waiting for stop\n", ehci->name );
 422         return -ETIMEDOUT;
 423 }
 424
 425 /**
 426  * Reset EHCI device
 427  *
 428  * @v ehci              EHCI device
 429  * @ret rc              Return status code
 430  */
 431 static int ehci_reset ( struct ehci_device *ehci ) {
 432         uint32_t usbcmd;
 433         unsigned int i;
 434         int rc;
 435
 436         /* The EHCI specification states that resetting a running
 437          * device may result in undefined behaviour, so try stopping
 438          * it first.
 439          */
 440         if ( ( rc = ehci_stop ( ehci ) ) != 0 ) {
 441                 /* Ignore errors and attempt to reset the device anyway */
 442         }
 443
 444         /* Reset device */
 445         writel ( EHCI_USBCMD_HCRST, ehci->op + EHCI_OP_USBCMD );
 446
 447         /* Wait for reset to complete */
 448         for ( i = 0 ; i < EHCI_RESET_MAX_WAIT_MS ; i++ ) {
 449
 450                 /* Check if reset is complete */
 451                 usbcmd = readl ( ehci->op + EHCI_OP_USBCMD );
 452                 if ( ! ( usbcmd & EHCI_USBCMD_HCRST ) )
 453                         return 0;
 454
 455                 /* Delay */
 456                 mdelay ( 1 );
 457         }
 458
 459         DBGC ( ehci, "EHCI %s timed out waiting for reset\n", ehci->name );
 460         return -ETIMEDOUT;
 461 }
 462
 463 /******************************************************************************
 464  *
 465  * Transfer descriptor rings
 466  *
 467  ******************************************************************************
 468  */
 469
 470 /**
 471  * Allocate transfer descriptor ring
 472  *
 473  * @v ehci              EHCI device
 474  * @v ring              Transfer descriptor ring
 475  * @ret rc              Return status code
 476  */
 477 static int ehci_ring_alloc ( struct ehci_device *ehci,
 478                              struct ehci_ring *ring ) {
 479         struct ehci_transfer_descriptor *desc;
 480         struct ehci_transfer_descriptor *next;
 481         unsigned int i;
 482         size_t len;
 483         uint32_t link;
 484         int rc;
 485
 486         /* Initialise structure */
 487         memset ( ring, 0, sizeof ( *ring ) );
 488
 489         /* Allocate I/O buffers */
 490         ring->iobuf = zalloc ( EHCI_RING_COUNT * sizeof ( ring->iobuf[0] ) );
 491         if ( ! ring->iobuf ) {
 492                 rc = -ENOMEM;
 493                 goto err_alloc_iobuf;
 494         }
 495
 496         /* Allocate queue head */
 497         ring->head = malloc_dma ( sizeof ( *ring->head ),
 498                                   ehci_align ( sizeof ( *ring->head ) ) );
 499         if ( ! ring->head ) {
 500                 rc = -ENOMEM;
 501                 goto err_alloc_queue;
 502         }
 503         if ( ( rc = ehci_ctrl_reachable ( ehci, ring->head ) ) != 0 ) {
 504                 DBGC ( ehci, "EHCI %s queue head unreachable\n", ehci->name );
 505                 goto err_unreachable_queue;
 506         }
 507         memset ( ring->head, 0, sizeof ( *ring->head ) );
 508
 509         /* Allocate transfer descriptors */
 510         len = ( EHCI_RING_COUNT * sizeof ( ring->desc[0] ) );
 511         ring->desc = malloc_dma ( len, sizeof ( ring->desc[0] ) );
 512         if ( ! ring->desc ) {
 513                 rc = -ENOMEM;
 514                 goto err_alloc_desc;
 515         }
 516         memset ( ring->desc, 0, len );
 517
 518         /* Initialise transfer descriptors */
 519         for ( i = 0 ; i < EHCI_RING_COUNT ; i++ ) {
 520                 desc = &ring->desc[i];
 521                 if ( ( rc = ehci_ctrl_reachable ( ehci, desc ) ) != 0 ) {
 522                         DBGC ( ehci, "EHCI %s descriptor unreachable\n",
 523                                ehci->name );
 524                         goto err_unreachable_desc;
 525                 }
 526                 next = &ring->desc[ ( i + 1 ) % EHCI_RING_COUNT ];
 527                 link = virt_to_phys ( next );
 528                 desc->next = cpu_to_le32 ( link );
 529                 desc->alt = cpu_to_le32 ( link );
 530         }
 531
 532         /* Initialise queue head */
 533         link = virt_to_phys ( &ring->desc[0] );
 534         ring->head->cache.next = cpu_to_le32 ( link );
 535
 536         return 0;
 537
 538  err_unreachable_desc:
 539         free_dma ( ring->desc, len );
 540  err_alloc_desc:
 541  err_unreachable_queue:
 542         free_dma ( ring->head, sizeof ( *ring->head ) );
 543  err_alloc_queue:
 544         free ( ring->iobuf );
 545  err_alloc_iobuf:
 546         return rc;
 547 }
 548
 549 /**
 550  * Free transfer descriptor ring
 551  *
 552  * @v ring              Transfer descriptor ring
 553  */
 554 static void ehci_ring_free ( struct ehci_ring *ring ) {
 555         unsigned int i;
 556
 557         /* Sanity checks */
 558         assert ( ehci_ring_fill ( ring ) == 0 );
 559         for ( i = 0 ; i < EHCI_RING_COUNT ; i++ )
 560                 assert ( ring->iobuf[i] == NULL );
 561
 562         /* Free transfer descriptors */
 563         free_dma ( ring->desc, ( EHCI_RING_COUNT * sizeof ( ring->desc[0] ) ) );
 564
 565         /* Free queue head */
 566         free_dma ( ring->head, sizeof ( *ring->head ) );
 567
 568         /* Free I/O buffers */
 569         free ( ring->iobuf );
 570 }
 571
 572 /**
 573  * Enqueue transfer descriptors
 574  *
 575  * @v ehci              EHCI device
 576  * @v ring              Transfer descriptor ring
 577  * @v iobuf             I/O buffer
 578  * @v xfers             Transfers
 579  * @v count             Number of transfers
 580  * @ret rc              Return status code
 581  */
 582 static int ehci_enqueue ( struct ehci_device *ehci, struct ehci_ring *ring,
 583                           struct io_buffer *iobuf,
 584                           const struct ehci_transfer *xfer,
 585                           unsigned int count ) {
 586         struct ehci_transfer_descriptor *desc;
 587         physaddr_t phys;
 588         void *data;
 589         size_t len;
 590         size_t offset;
 591         size_t frag_len;
 592         unsigned int toggle;
 593         unsigned int index;
 594         unsigned int i;
 595
 596         /* Sanity check */
 597         assert ( iobuf != NULL );
 598         assert ( count > 0 );
 599
 600         /* Fail if ring does not have sufficient space */
 601         if ( ehci_ring_remaining ( ring ) < count )
 602                 return -ENOBUFS;
 603
 604         /* Fail if any portion is unreachable */
 605         for ( i = 0 ; i < count ; i++ ) {
 606                 phys = ( virt_to_phys ( xfer[i].data ) + xfer[i].len - 1 );
 607                 if ( ( phys > 0xffffffffUL ) && ( ! ehci->addr64 ) )
 608                         return -ENOTSUP;
 609         }
 610
 611         /* Enqueue each transfer, recording the I/O buffer with the last */
 612         for ( ; count ; ring->prod++, xfer++ ) {
 613
 614                 /* Populate descriptor header */
 615                 index = ( ring->prod % EHCI_RING_COUNT );
 616                 desc = &ring->desc[index];
 617                 toggle = ( xfer->flags & EHCI_FL_TOGGLE );
 618                 assert ( xfer->len <= EHCI_LEN_MASK );
 619                 assert ( EHCI_FL_TOGGLE == EHCI_LEN_TOGGLE );
 620                 desc->len = cpu_to_le16 ( xfer->len | toggle );
 621                 desc->flags = ( xfer->flags | EHCI_FL_CERR_MAX );
 622
 623                 /* Populate buffer pointers */
 624                 data = xfer->data;
 625                 len = xfer->len;
 626                 for ( i = 0 ; len ; i++ ) {
 627
 628                         /* Calculate length of this fragment */
 629                         phys = virt_to_phys ( data );
 630                         offset = ( phys & ( EHCI_PAGE_ALIGN - 1 ) );
 631                         frag_len = ( EHCI_PAGE_ALIGN - offset );
 632                         if ( frag_len > len )
 633                                 frag_len = len;
 634
 635                         /* Sanity checks */
 636                         assert ( ( i == 0 ) || ( offset == 0 ) );
 637                         assert ( i < ( sizeof ( desc->low ) /
 638                                        sizeof ( desc->low[0] ) ) );
 639
 640                         /* Populate buffer pointer */
 641                         desc->low[i] = cpu_to_le32 ( phys );
 642                         if ( sizeof ( physaddr_t ) > sizeof ( uint32_t ) ) {
 643                                 desc->high[i] =
 644                                         cpu_to_le32 ( ((uint64_t) phys) >> 32 );
 645                         }
 646
 647                         /* Move to next fragment */
 648                         data += frag_len;
 649                         len -= frag_len;
 650                 }
 651
 652                 /* Ensure everything is valid before activating descriptor */
 653                 wmb();
 654                 desc->status = EHCI_STATUS_ACTIVE;
 655
 656                 /* Record I/O buffer against last ring index */
 657                 if ( --count == 0 )
 658                         ring->iobuf[index] = iobuf;
 659         }
 660
 661         return 0;
 662 }
 663
 664 /**
 665  * Dequeue a transfer descriptor
 666  *
 667  * @v ring              Transfer descriptor ring
 668  * @ret iobuf           I/O buffer (or NULL)
 669  */
 670 static struct io_buffer * ehci_dequeue ( struct ehci_ring *ring ) {
 671         struct ehci_transfer_descriptor *desc;
 672         struct io_buffer *iobuf;
 673         unsigned int index = ( ring->cons % EHCI_RING_COUNT );
 674
 675         /* Sanity check */
 676         assert ( ehci_ring_fill ( ring ) > 0 );
 677
 678         /* Mark descriptor as inactive (and not halted) */
 679         desc = &ring->desc[index];
 680         desc->status = 0;
 681
 682         /* Retrieve I/O buffer */
 683         iobuf = ring->iobuf[index];
 684         ring->iobuf[index] = NULL;
 685
 686         /* Update consumer counter */
 687         ring->cons++;
 688
 689         return iobuf;
 690 }
 691
 692 /******************************************************************************
 693  *
 694  * Schedule management
 695  *
 696  ******************************************************************************
 697  */
 698
 699 /**
 700  * Get link value for a queue head
 701  *
 702  * @v queue             Queue head
 703  * @ret link            Link value
 704  */
 705 static inline uint32_t ehci_link_qh ( struct ehci_queue_head *queue ) {
 706
 707         return ( virt_to_phys ( queue ) | EHCI_LINK_TYPE_QH );
 708 }
 709
 710 /**
 711  * (Re)build asynchronous schedule
 712  *
 713  * @v ehci              EHCI device
 714  */
 715 static void ehci_async_schedule ( struct ehci_device *ehci ) {
 716         struct ehci_endpoint *endpoint;
 717         struct ehci_queue_head *queue;
 718         uint32_t link;
 719
 720         /* Build schedule in reverse order of execution.  Provided
 721          * that we only ever add or remove single endpoints, this can
 722          * safely run concurrently with hardware execution of the
 723          * schedule.
 724          */
 725         link = ehci_link_qh ( ehci->head );
 726         list_for_each_entry_reverse ( endpoint, &ehci->async, schedule ) {
 727                 queue = endpoint->ring.head;
 728                 queue->link = cpu_to_le32 ( link );
 729                 wmb();
 730                 link = ehci_link_qh ( queue );
 731         }
 732         ehci->head->link = cpu_to_le32 ( link );
 733         wmb();
 734 }
 735
 736 /**
 737  * Add endpoint to asynchronous schedule
 738  *
 739  * @v endpoint          Endpoint
 740  */
 741 static void ehci_async_add ( struct ehci_endpoint *endpoint ) {
 742         struct ehci_device *ehci = endpoint->ehci;
 743
 744         /* Add to end of schedule */
 745         list_add_tail ( &endpoint->schedule, &ehci->async );
 746
 747         /* Rebuild schedule */
 748         ehci_async_schedule ( ehci );
 749 }
 750
 751 /**
 752  * Remove endpoint from asynchronous schedule
 753  *
 754  * @v endpoint          Endpoint
 755  * @ret rc              Return status code
 756  */
 757 static int ehci_async_del ( struct ehci_endpoint *endpoint ) {
 758         struct ehci_device *ehci = endpoint->ehci;
 759         uint32_t usbcmd;
 760         uint32_t usbsts;
 761         unsigned int i;
 762
 763         /* Remove from schedule */
 764         list_check_contains_entry ( endpoint, &ehci->async, schedule );
 765         list_del ( &endpoint->schedule );
 766
 767         /* Rebuild schedule */
 768         ehci_async_schedule ( ehci );
 769
 770         /* Request notification when asynchronous schedule advances */
 771         usbcmd = readl ( ehci->op + EHCI_OP_USBCMD );
 772         usbcmd |= EHCI_USBCMD_ASYNC_ADVANCE;
 773         writel ( usbcmd, ehci->op + EHCI_OP_USBCMD );
 774
 775         /* Wait for asynchronous schedule to advance */
 776         for ( i = 0 ; i < EHCI_ASYNC_ADVANCE_MAX_WAIT_MS ; i++ ) {
 777
 778                 /* Check for asynchronous schedule advancing */
 779                 usbsts = readl ( ehci->op + EHCI_OP_USBSTS );
 780                 if ( usbsts & EHCI_USBSTS_ASYNC_ADVANCE ) {
 781                         usbsts &= ~EHCI_USBSTS_CHANGE;
 782                         usbsts |= EHCI_USBSTS_ASYNC_ADVANCE;
 783                         writel ( usbsts, ehci->op + EHCI_OP_USBSTS );
 784                         return 0;
 785                 }
 786
 787                 /* Delay */
 788                 mdelay ( 1 );
 789         }
 790
 791         /* Bad things will probably happen now */
 792         DBGC ( ehci, "EHCI %s timed out waiting for asynchronous schedule "
 793                "to advance\n", ehci->name );
 794         return -ETIMEDOUT;
 795 }
 796
 797 /**
 798  * (Re)build periodic schedule
 799  *
 800  * @v ehci              EHCI device
 801  */
 802 static void ehci_periodic_schedule ( struct ehci_device *ehci ) {
 803         struct ehci_endpoint *endpoint;
 804         struct ehci_queue_head *queue;
 805         uint32_t link;
 806         unsigned int frames;
 807         unsigned int max_interval;
 808         unsigned int i;
 809
 810         /* Build schedule in reverse order of execution.  Provided
 811          * that we only ever add or remove single endpoints, this can
 812          * safely run concurrently with hardware execution of the
 813          * schedule.
 814          */
 815         DBGCP ( ehci, "EHCI %s periodic schedule: ", ehci->name );
 816         link = EHCI_LINK_TERMINATE;
 817         list_for_each_entry_reverse ( endpoint, &ehci->periodic, schedule ) {
 818                 queue = endpoint->ring.head;
 819                 queue->link = cpu_to_le32 ( link );
 820                 wmb();
 821                 DBGCP ( ehci, "%s%d",
 822                         ( ( link == EHCI_LINK_TERMINATE ) ? "" : "<-" ),
 823                         endpoint->ep->interval );
 824                 link = ehci_link_qh ( queue );
 825         }
 826         DBGCP ( ehci, "\n" );
 827
 828         /* Populate periodic frame list */
 829         DBGCP ( ehci, "EHCI %s periodic frame list:", ehci->name );
 830         frames = EHCI_PERIODIC_FRAMES ( ehci->flsize );
 831         for ( i = 0 ; i < frames ; i++ ) {
 832
 833                 /* Calculate maximum interval (in microframes) which
 834                  * may appear as part of this frame list.
 835                  */
 836                 if ( i == 0 ) {
 837                         /* Start of list: include all endpoints */
 838                         max_interval = -1U;
 839                 } else {
 840                         /* Calculate highest power-of-two frame interval */
 841                         max_interval = ( 1 << ( ffs ( i ) - 1 ) );
 842                         /* Convert to microframes */
 843                         max_interval <<= 3;
 844                         /* Round up to nearest 2^n-1 */
 845                         max_interval = ( ( max_interval << 1 ) - 1 );
 846                 }
 847
 848                 /* Find first endpoint in schedule satisfying this
 849                  * maximum interval constraint.
 850                  */
 851                 link = EHCI_LINK_TERMINATE;
 852                 list_for_each_entry ( endpoint, &ehci->periodic, schedule ) {
 853                         if ( endpoint->ep->interval <= max_interval ) {
 854                                 queue = endpoint->ring.head;
 855                                 link = ehci_link_qh ( queue );
 856                                 DBGCP ( ehci, " %d:%d",
 857                                         i, endpoint->ep->interval );
 858                                 break;
 859                         }
 860                 }
 861                 ehci->frame[i].link = cpu_to_le32 ( link );
 862         }
 863         wmb();
 864         DBGCP ( ehci, "\n" );
 865 }
 866
 867 /**
 868  * Add endpoint to periodic schedule
 869  *
 870  * @v endpoint          Endpoint
 871  */
 872 static void ehci_periodic_add ( struct ehci_endpoint *endpoint ) {
 873         struct ehci_device *ehci = endpoint->ehci;
 874         struct ehci_endpoint *before;
 875         unsigned int interval = endpoint->ep->interval;
 876
 877         /* Find first endpoint with a smaller interval */
 878         list_for_each_entry ( before, &ehci->periodic, schedule ) {
 879                 if ( before->ep->interval < interval )
 880                         break;
 881         }
 882         list_add_tail ( &endpoint->schedule, &before->schedule );
 883
 884         /* Rebuild schedule */
 885         ehci_periodic_schedule ( ehci );
 886 }
 887
 888 /**
 889  * Remove endpoint from periodic schedule
 890  *
 891  * @v endpoint          Endpoint
 892  * @ret rc              Return status code
 893  */
 894 static int ehci_periodic_del ( struct ehci_endpoint *endpoint ) {
 895         struct ehci_device *ehci = endpoint->ehci;
 896
 897         /* Remove from schedule */
 898         list_check_contains_entry ( endpoint, &ehci->periodic, schedule );
 899         list_del ( &endpoint->schedule );
 900
 901         /* Rebuild schedule */
 902         ehci_periodic_schedule ( ehci );
 903
 904         /* Delay for a whole USB frame (with a 100% safety margin) */
 905         mdelay ( 2 );
 906
 907         return 0;
 908 }
 909
 910 /**
 911  * Add endpoint to appropriate schedule
 912  *
 913  * @v endpoint          Endpoint
 914  */
 915 static void ehci_schedule_add ( struct ehci_endpoint *endpoint ) {
 916         struct usb_endpoint *ep = endpoint->ep;
 917         unsigned int attr = ( ep->attributes & USB_ENDPOINT_ATTR_TYPE_MASK );
 918
 919         if ( attr == USB_ENDPOINT_ATTR_INTERRUPT ) {
 920                 ehci_periodic_add ( endpoint );
 921         } else {
 922                 ehci_async_add ( endpoint );
 923         }
 924 }
 925
 926 /**
 927  * Remove endpoint from appropriate schedule
 928  *
 929  * @v endpoint          Endpoint
 930  * @ret rc              Return status code
 931  */
 932 static int ehci_schedule_del ( struct ehci_endpoint *endpoint ) {
 933         struct usb_endpoint *ep = endpoint->ep;
 934         unsigned int attr = ( ep->attributes & USB_ENDPOINT_ATTR_TYPE_MASK );
 935
 936         if ( attr == USB_ENDPOINT_ATTR_INTERRUPT ) {
 937                 return ehci_periodic_del ( endpoint );
 938         } else {
 939                 return ehci_async_del ( endpoint );
 940         }
 941 }
 942
 943 /******************************************************************************
 944  *
 945  * Endpoint operations
 946  *
 947  ******************************************************************************
 948  */
 949
 950 /**
 951  * Determine endpoint characteristics
 952  *
 953  * @v ep                USB endpoint
 954  * @ret chr             Endpoint characteristics
 955  */
 956 static uint32_t ehci_endpoint_characteristics ( struct usb_endpoint *ep ) {
 957         struct usb_device *usb = ep->usb;
 958         unsigned int attr = ( ep->attributes & USB_ENDPOINT_ATTR_TYPE_MASK );
 959         uint32_t chr;
 960
 961         /* Determine basic characteristics */
 962         chr = ( EHCI_CHR_ADDRESS ( usb->address ) |
 963                 EHCI_CHR_ENDPOINT ( ep->address ) |
 964                 EHCI_CHR_MAX_LEN ( ep->mtu ) );
 965
 966         /* Control endpoints require manual control of the data toggle */
 967         if ( attr == USB_ENDPOINT_ATTR_CONTROL )
 968                 chr |= EHCI_CHR_TOGGLE;
 969
 970         /* Determine endpoint speed */
 971         if ( usb->port->speed == USB_SPEED_HIGH ) {
 972                 chr |= EHCI_CHR_EPS_HIGH;
 973         } else {
 974                 if ( usb->port->speed == USB_SPEED_FULL ) {
 975                         chr |= EHCI_CHR_EPS_FULL;
 976                 } else {
 977                         chr |= EHCI_CHR_EPS_LOW;
 978                 }
 979                 if ( attr == USB_ENDPOINT_ATTR_CONTROL )
 980                         chr |= EHCI_CHR_CONTROL;
 981         }
 982
 983         return chr;
 984 }
 985
 986 /**
 987  * Determine endpoint capabilities
 988  *
 989  * @v ep                USB endpoint
 990  * @ret cap             Endpoint capabilities
 991  */
 992 static uint32_t ehci_endpoint_capabilities ( struct usb_endpoint *ep ) {
 993         struct usb_device *usb = ep->usb;
 994         struct usb_port *tt = usb_transaction_translator ( usb );
 995         unsigned int attr = ( ep->attributes & USB_ENDPOINT_ATTR_TYPE_MASK );
 996         uint32_t cap;
 997         unsigned int i;
 998
 999         /* Determine basic capabilities */
1000         cap = EHCI_CAP_MULT ( ep->burst + 1 );
1001
1002         /* Determine interrupt schedule mask, if applicable */
1003         if ( ( attr == USB_ENDPOINT_ATTR_INTERRUPT ) &&
1004              ( ( ep->interval != 0 ) /* avoid infinite loop */ ) ) {
1005                 for ( i = 0 ; i < 8 /* microframes per frame */ ;
1006                       i += ep->interval ) {
1007                         cap |= EHCI_CAP_INTR_SCHED ( i );
1008                 }
1009         }
1010
1011         /* Set transaction translator hub address and port, if applicable */
1012         if ( tt ) {
1013                 assert ( tt->hub->usb );
1014                 cap |= ( EHCI_CAP_TT_HUB ( tt->hub->usb->address ) |
1015                          EHCI_CAP_TT_PORT ( tt->address ) );
1016                 if ( attr == USB_ENDPOINT_ATTR_INTERRUPT )
1017                         cap |= EHCI_CAP_SPLIT_SCHED_DEFAULT;
1018         }
1019
1020         return cap;
1021 }
1022
1023 /**
1024  * Update endpoint characteristics and capabilities
1025  *
1026  * @v ep                USB endpoint
1027  */
1028 static void ehci_endpoint_update ( struct usb_endpoint *ep ) {
1029         struct ehci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
1030         struct ehci_queue_head *head;
1031
1032         /* Update queue characteristics and capabilities */
1033         head = endpoint->ring.head;
1034         head->chr = cpu_to_le32 ( ehci_endpoint_characteristics ( ep ) );
1035         head->cap = cpu_to_le32 ( ehci_endpoint_capabilities ( ep ) );
1036 }
1037
1038 /**
1039  * Open endpoint
1040  *
1041  * @v ep                USB endpoint
1042  * @ret rc              Return status code
1043  */
1044 static int ehci_endpoint_open ( struct usb_endpoint *ep ) {
1045         struct usb_device *usb = ep->usb;
1046         struct ehci_device *ehci = usb_get_hostdata ( usb );
1047         struct ehci_endpoint *endpoint;
1048         int rc;
1049
1050         /* Allocate and initialise structure */
1051         endpoint = zalloc ( sizeof ( *endpoint ) );
1052         if ( ! endpoint ) {
1053                 rc = -ENOMEM;
1054                 goto err_alloc;
1055         }
1056         endpoint->ehci = ehci;
1057         endpoint->ep = ep;
1058         usb_endpoint_set_hostdata ( ep, endpoint );
1059
1060         /* Initialise descriptor ring */
1061         if ( ( rc = ehci_ring_alloc ( ehci, &endpoint->ring ) ) != 0 )
1062                 goto err_ring_alloc;
1063
1064         /* Update queue characteristics and capabilities */
1065         ehci_endpoint_update ( ep );
1066
1067         /* Add to list of endpoints */
1068         list_add_tail ( &endpoint->list, &ehci->endpoints );
1069
1070         /* Add to schedule */
1071         ehci_schedule_add ( endpoint );
1072
1073         return 0;
1074
1075         ehci_ring_free ( &endpoint->ring );
1076  err_ring_alloc:
1077         free ( endpoint );
1078  err_alloc:
1079         return rc;
1080 }
1081
1082 /**
1083  * Close endpoint
1084  *
1085  * @v ep                USB endpoint
1086  */
1087 static void ehci_endpoint_close ( struct usb_endpoint *ep ) {
1088         struct ehci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
1089         struct ehci_device *ehci = endpoint->ehci;
1090         struct usb_device *usb = ep->usb;
1091         struct io_buffer *iobuf;
1092         int rc;
1093
1094         /* Remove from schedule */
1095         if ( ( rc = ehci_schedule_del ( endpoint ) ) != 0 ) {
1096                 /* No way to prevent hardware from continuing to
1097                  * access the memory, so leak it.
1098                  */
1099                 DBGC ( ehci, "EHCI %s %s could not unschedule: %s\n",
1100                        usb->name, usb_endpoint_name ( ep ), strerror ( rc ) );
1101                 return;
1102         }
1103
1104         /* Cancel any incomplete transfers */
1105         while ( ehci_ring_fill ( &endpoint->ring ) ) {
1106                 iobuf = ehci_dequeue ( &endpoint->ring );
1107                 if ( iobuf )
1108                         usb_complete_err ( ep, iobuf, -ECANCELED );
1109         }
1110
1111         /* Remove from list of endpoints */
1112         list_del ( &endpoint->list );
1113
1114         /* Free descriptor ring */
1115         ehci_ring_free ( &endpoint->ring );
1116
1117         /* Free endpoint */
1118         free ( endpoint );
1119 }
1120
1121 /**
1122  * Reset endpoint
1123  *
1124  * @v ep                USB endpoint
1125  * @ret rc              Return status code
1126  */
1127 static int ehci_endpoint_reset ( struct usb_endpoint *ep ) {
1128         struct ehci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
1129         struct ehci_ring *ring = &endpoint->ring;
1130         struct ehci_transfer_descriptor *cache = &ring->head->cache;
1131         uint32_t link;
1132
1133         /* Sanity checks */
1134         assert ( ! ( cache->status & EHCI_STATUS_ACTIVE ) );
1135         assert ( cache->status & EHCI_STATUS_HALTED );
1136
1137         /* Reset residual count */
1138         ring->residual = 0;
1139
1140         /* Reset data toggle */
1141         cache->len = 0;
1142
1143         /* Prepare to restart at next unconsumed descriptor */
1144         link = virt_to_phys ( &ring->desc[ ring->cons % EHCI_RING_COUNT ] );
1145         cache->next = cpu_to_le32 ( link );
1146
1147         /* Restart ring */
1148         wmb();
1149         cache->status = 0;
1150
1151         return 0;
1152 }
1153
1154 /**
1155  * Update MTU
1156  *
1157  * @v ep                USB endpoint
1158  * @ret rc              Return status code
1159  */
1160 static int ehci_endpoint_mtu ( struct usb_endpoint *ep ) {
1161
1162         /* Update endpoint characteristics and capabilities */
1163         ehci_endpoint_update ( ep );
1164
1165         return 0;
1166 }
1167
1168 /**
1169  * Enqueue message transfer
1170  *
1171  * @v ep                USB endpoint
1172  * @v iobuf             I/O buffer
1173  * @ret rc              Return status code
1174  */
1175 static int ehci_endpoint_message ( struct usb_endpoint *ep,
1176                                    struct io_buffer *iobuf ) {
1177         struct ehci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
1178         struct ehci_device *ehci = endpoint->ehci;
1179         struct usb_setup_packet *packet;
1180         unsigned int input;
1181         struct ehci_transfer xfers[3];
1182         struct ehci_transfer *xfer = xfers;
1183         size_t len;
1184         int rc;
1185
1186         /* Construct setup stage */
1187         assert ( iob_len ( iobuf ) >= sizeof ( *packet ) );
1188         packet = iobuf->data;
1189         iob_pull ( iobuf, sizeof ( *packet ) );
1190         xfer->data = packet;
1191         xfer->len = sizeof ( *packet );
1192         xfer->flags = EHCI_FL_PID_SETUP;
1193         xfer++;
1194
1195         /* Construct data stage, if applicable */
1196         len = iob_len ( iobuf );
1197         input = ( packet->request & cpu_to_le16 ( USB_DIR_IN ) );
1198         if ( len ) {
1199                 xfer->data = iobuf->data;
1200                 xfer->len = len;
1201                 xfer->flags = ( EHCI_FL_TOGGLE |
1202                                 ( input ? EHCI_FL_PID_IN : EHCI_FL_PID_OUT ) );
1203                 xfer++;
1204         }
1205
1206         /* Construct status stage */
1207         xfer->data = NULL;
1208         xfer->len = 0;
1209         xfer->flags = ( EHCI_FL_TOGGLE | EHCI_FL_IOC |
1210                         ( ( len && input ) ? EHCI_FL_PID_OUT : EHCI_FL_PID_IN));
1211         xfer++;
1212
1213         /* Enqueue transfer */
1214         if ( ( rc = ehci_enqueue ( ehci, &endpoint->ring, iobuf, xfers,
1215                                    ( xfer - xfers ) ) ) != 0 )
1216                 return rc;
1217
1218         return 0;
1219 }
1220
1221 /**
1222  * Enqueue stream transfer
1223  *
1224  * @v ep                USB endpoint
1225  * @v iobuf             I/O buffer
1226  * @v terminate         Terminate using a short packet
1227  * @ret rc              Return status code
1228  */
1229 static int ehci_endpoint_stream ( struct usb_endpoint *ep,
1230                                   struct io_buffer *iobuf, int terminate ) {
1231         struct ehci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
1232         struct ehci_device *ehci = endpoint->ehci;
1233         unsigned int input = ( ep->address & USB_DIR_IN );
1234         struct ehci_transfer xfers[2];
1235         struct ehci_transfer *xfer = xfers;
1236         size_t len = iob_len ( iobuf );
1237         int rc;
1238
1239         /* Create transfer */
1240         xfer->data = iobuf->data;
1241         xfer->len = len;
1242         xfer->flags = ( EHCI_FL_IOC |
1243                         ( input ? EHCI_FL_PID_IN : EHCI_FL_PID_OUT ) );
1244         xfer++;
1245         if ( terminate && ( ( len & ( ep->mtu - 1 ) ) == 0 ) ) {
1246                 xfer->data = NULL;
1247                 xfer->len = 0;
1248                 assert ( ! input );
1249                 xfer->flags = ( EHCI_FL_IOC | EHCI_FL_PID_OUT );
1250                 xfer++;
1251         }
1252
1253         /* Enqueue transfer */
1254         if ( ( rc = ehci_enqueue ( ehci, &endpoint->ring, iobuf, xfers,
1255                                    ( xfer - xfers ) ) ) != 0 )
1256                 return rc;
1257
1258         return 0;
1259 }
1260
1261 /**
1262  * Poll for completions
1263  *
1264  * @v endpoint          Endpoint
1265  */
1266 static void ehci_endpoint_poll ( struct ehci_endpoint *endpoint ) {
1267         struct ehci_device *ehci = endpoint->ehci;
1268         struct ehci_ring *ring = &endpoint->ring;
1269         struct ehci_transfer_descriptor *desc;
1270         struct usb_endpoint *ep = endpoint->ep;
1271         struct usb_device *usb = ep->usb;
1272         struct io_buffer *iobuf;
1273         unsigned int index;
1274         unsigned int status;
1275         int rc;
1276
1277         /* Consume all completed descriptors */
1278         while ( ehci_ring_fill ( &endpoint->ring ) ) {
1279
1280                 /* Stop if we reach an uncompleted descriptor */
1281                 rmb();
1282                 index = ( ring->cons % EHCI_RING_COUNT );
1283                 desc = &ring->desc[index];
1284                 status = desc->status;
1285                 if ( status & EHCI_STATUS_ACTIVE )
1286                         break;
1287
1288                 /* Consume this descriptor */
1289                 iobuf = ehci_dequeue ( ring );
1290
1291                 /* If we have encountered an error, then consume all
1292                  * remaining descriptors in this transaction, report
1293                  * the error to the USB core, and stop further
1294                  * processing.
1295                  */
1296                 if ( status & EHCI_STATUS_HALTED ) {
1297                         rc = -EIO_STATUS ( status );
1298                         DBGC ( ehci, "EHCI %s %s completion %d failed (status "
1299                                "%02x): %s\n", usb->name,
1300                                usb_endpoint_name ( ep ), index, status,
1301                                strerror ( rc ) );
1302                         while ( ! iobuf )
1303                                 iobuf = ehci_dequeue ( ring );
1304                         usb_complete_err ( endpoint->ep, iobuf, rc );
1305                         return;
1306                 }
1307
1308                 /* Accumulate residual data count */
1309                 ring->residual += ( le16_to_cpu ( desc->len ) & EHCI_LEN_MASK );
1310
1311                 /* If this is not the end of a transaction (i.e. has
1312                  * no I/O buffer), then continue to next descriptor.
1313                  */
1314                 if ( ! iobuf )
1315                         continue;
1316
1317                 /* Update I/O buffer length */
1318                 iob_unput ( iobuf, ring->residual );
1319                 ring->residual = 0;
1320
1321                 /* Report completion to USB core */
1322                 usb_complete ( endpoint->ep, iobuf );
1323         }
1324 }
1325
1326 /******************************************************************************
1327  *
1328  * Device operations
1329  *
1330  ******************************************************************************
1331  */
1332
1333 /**
1334  * Open device
1335  *
1336  * @v usb               USB device
1337  * @ret rc              Return status code
1338  */
1339 static int ehci_device_open ( struct usb_device *usb ) {
1340         struct ehci_device *ehci = usb_bus_get_hostdata ( usb->port->hub->bus );
1341
1342         usb_set_hostdata ( usb, ehci );
1343         return 0;
1344 }
1345
1346 /**
1347  * Close device
1348  *
1349  * @v usb               USB device
1350  */
1351 static void ehci_device_close ( struct usb_device *usb ) {
1352         struct ehci_device *ehci = usb_get_hostdata ( usb );
1353         struct usb_bus *bus = ehci->bus;
1354
1355         /* Free device address, if assigned */
1356         if ( usb->address )
1357                 usb_free_address ( bus, usb->address );
1358 }
1359
1360 /**
1361  * Assign device address
1362  *
1363  * @v usb               USB device
1364  * @ret rc              Return status code
1365  */
1366 static int ehci_device_address ( struct usb_device *usb ) {
1367         struct ehci_device *ehci = usb_get_hostdata ( usb );
1368         struct usb_bus *bus = ehci->bus;
1369         struct usb_endpoint *ep0 = usb_endpoint ( usb, USB_EP0_ADDRESS );
1370         int address;
1371         int rc;
1372
1373         /* Sanity checks */
1374         assert ( usb->address == 0 );
1375         assert ( ep0 != NULL );
1376
1377         /* Allocate device address */
1378         address = usb_alloc_address ( bus );
1379         if ( address < 0 ) {
1380                 rc = address;
1381                 DBGC ( ehci, "EHCI %s could not allocate address: %s\n",
1382                        usb->name, strerror ( rc ) );
1383                 goto err_alloc_address;
1384         }
1385
1386         /* Set address */
1387         if ( ( rc = usb_set_address ( usb, address ) ) != 0 )
1388                 goto err_set_address;
1389
1390         /* Update device address */
1391         usb->address = address;
1392
1393         /* Update control endpoint characteristics and capabilities */
1394         ehci_endpoint_update ( ep0 );
1395
1396         return 0;
1397
1398  err_set_address:
1399         usb_free_address ( bus, address );
1400  err_alloc_address:
1401         return rc;
1402 }
1403
1404 /******************************************************************************
1405  *
1406  * Hub operations
1407  *
1408  ******************************************************************************
1409  */
1410
1411 /**
1412  * Open hub
1413  *
1414  * @v hub               USB hub
1415  * @ret rc              Return status code
1416  */
1417 static int ehci_hub_open ( struct usb_hub *hub __unused ) {
1418
1419         /* Nothing to do */
1420         return 0;
1421 }
1422
1423 /**
1424  * Close hub
1425  *
1426  * @v hub               USB hub
1427  */
1428 static void ehci_hub_close ( struct usb_hub *hub __unused ) {
1429
1430         /* Nothing to do */
1431 }
1432
1433 /******************************************************************************
1434  *
1435  * Root hub operations
1436  *
1437  ******************************************************************************
1438  */
1439
1440 /**
1441  * Open root hub
1442  *
1443  * @v hub               USB hub
1444  * @ret rc              Return status code
1445  */
1446 static int ehci_root_open ( struct usb_hub *hub ) {
1447         struct usb_bus *bus = hub->bus;
1448         struct ehci_device *ehci = usb_bus_get_hostdata ( bus );
1449         uint32_t portsc;
1450         unsigned int i;
1451
1452         /* Route all ports to EHCI controller */
1453         writel ( EHCI_CONFIGFLAG_CF, ehci->op + EHCI_OP_CONFIGFLAG );
1454
1455         /* Enable power to all ports */
1456         for ( i = 1 ; i <= ehci->ports ; i++ ) {
1457                 portsc = readl ( ehci->op + EHCI_OP_PORTSC ( i ) );
1458                 portsc &= ~EHCI_PORTSC_CHANGE;
1459                 portsc |= EHCI_PORTSC_PP;
1460                 writel ( portsc, ehci->op + EHCI_OP_PORTSC ( i ) );
1461         }
1462
1463         /* Wait 20ms after potentially enabling power to a port */
1464         mdelay ( EHCI_PORT_POWER_DELAY_MS );
1465
1466         /* Record hub driver private data */
1467         usb_hub_set_drvdata ( hub, ehci );
1468
1469         return 0;
1470 }
1471
1472 /**
1473  * Close root hub
1474  *
1475  * @v hub               USB hub
1476  */
1477 static void ehci_root_close ( struct usb_hub *hub ) {
1478         struct ehci_device *ehci = usb_hub_get_drvdata ( hub );
1479
1480         /* Route all ports back to companion controllers */
1481         writel ( 0, ehci->op + EHCI_OP_CONFIGFLAG );
1482
1483         /* Clear hub driver private data */
1484         usb_hub_set_drvdata ( hub, NULL );
1485 }
1486
1487 /**
1488  * Enable port
1489  *
1490  * @v hub               USB hub
1491  * @v port              USB port
1492  * @ret rc              Return status code
1493  */
1494 static int ehci_root_enable ( struct usb_hub *hub, struct usb_port *port ) {
1495         struct ehci_device *ehci = usb_hub_get_drvdata ( hub );
1496         uint32_t portsc;
1497         unsigned int line;
1498         unsigned int i;
1499
1500         /* Check for a low-speed device */
1501         portsc = readl ( ehci->op + EHCI_OP_PORTSC ( port->address ) );
1502         line = EHCI_PORTSC_LINE_STATUS ( portsc );
1503         if ( line == EHCI_PORTSC_LINE_STATUS_LOW ) {
1504                 DBGC ( ehci, "EHCI %s-%d detected low-speed device: "
1505                        "disowning\n", ehci->name, port->address );
1506                 goto disown;
1507         }
1508
1509         /* Reset port */
1510         portsc &= ~( EHCI_PORTSC_PED | EHCI_PORTSC_CHANGE );
1511         portsc |= EHCI_PORTSC_PR;
1512         writel ( portsc, ehci->op + EHCI_OP_PORTSC ( port->address ) );
1513         mdelay ( USB_RESET_DELAY_MS );
1514         portsc &= ~EHCI_PORTSC_PR;
1515         writel ( portsc, ehci->op + EHCI_OP_PORTSC ( port->address ) );
1516
1517         /* Wait for reset to complete */
1518         for ( i = 0 ; i < EHCI_PORT_RESET_MAX_WAIT_MS ; i++ ) {
1519
1520                 /* Check port status */
1521                 portsc = readl ( ehci->op + EHCI_OP_PORTSC ( port->address ) );
1522                 if ( ! ( portsc & EHCI_PORTSC_PR ) ) {
1523                         if ( portsc & EHCI_PORTSC_PED )
1524                                 return 0;
1525                         DBGC ( ehci, "EHCI %s-%d not enabled after reset: "
1526                                "disowning\n", ehci->name, port->address );
1527                         goto disown;
1528                 }
1529
1530                 /* Delay */
1531                 mdelay ( 1 );
1532         }
1533
1534         DBGC ( ehci, "EHCI %s-%d timed out waiting for port to reset\n",
1535                ehci->name, port->address );
1536         return -ETIMEDOUT;
1537
1538  disown:
1539         /* Disown port */
1540         portsc &= ~EHCI_PORTSC_CHANGE;
1541         portsc |= EHCI_PORTSC_OWNER;
1542         writel ( portsc, ehci->op + EHCI_OP_PORTSC ( port->address ) );
1543
1544         /* Delay to allow child companion controllers to settle */
1545         mdelay ( EHCI_DISOWN_DELAY_MS );
1546
1547         /* Poll child companion controllers */
1548         ehci_poll_companions ( ehci );
1549
1550         return -ENODEV;
1551 }
1552
1553 /**
1554  * Disable port
1555  *
1556  * @v hub               USB hub
1557  * @v port              USB port
1558  * @ret rc              Return status code
1559  */
1560 static int ehci_root_disable ( struct usb_hub *hub, struct usb_port *port ) {
1561         struct ehci_device *ehci = usb_hub_get_drvdata ( hub );
1562         uint32_t portsc;
1563
1564         /* Disable port */
1565         portsc = readl ( ehci->op + EHCI_OP_PORTSC ( port->address ) );
1566         portsc &= ~( EHCI_PORTSC_PED | EHCI_PORTSC_CHANGE );
1567         writel ( portsc, ehci->op + EHCI_OP_PORTSC ( port->address ) );
1568
1569         return 0;
1570 }
1571
1572 /**
1573  * Update root hub port speed
1574  *
1575  * @v hub               USB hub
1576  * @v port              USB port
1577  * @ret rc              Return status code
1578  */
1579 static int ehci_root_speed ( struct usb_hub *hub, struct usb_port *port ) {
1580         struct ehci_device *ehci = usb_hub_get_drvdata ( hub );
1581         uint32_t portsc;
1582         unsigned int speed;
1583         unsigned int line;
1584         int ccs;
1585         int csc;
1586         int ped;
1587
1588         /* Read port status */
1589         portsc = readl ( ehci->op + EHCI_OP_PORTSC ( port->address ) );
1590         DBGC2 ( ehci, "EHCI %s-%d status is %08x\n",
1591                 ehci->name, port->address, portsc );
1592         ccs = ( portsc & EHCI_PORTSC_CCS );
1593         csc = ( portsc & EHCI_PORTSC_CSC );
1594         ped = ( portsc & EHCI_PORTSC_PED );
1595         line = EHCI_PORTSC_LINE_STATUS ( portsc );
1596
1597         /* Record disconnections and clear changes */
1598         port->disconnected |= csc;
1599         writel ( portsc, ehci->op + EHCI_OP_PORTSC ( port->address ) );
1600
1601         /* Determine port speed */
1602         if ( ! ccs ) {
1603                 /* Port not connected */
1604                 speed = USB_SPEED_NONE;
1605         } else if ( line == EHCI_PORTSC_LINE_STATUS_LOW ) {
1606                 /* Detected as low-speed */
1607                 speed = USB_SPEED_LOW;
1608         } else if ( ped ) {
1609                 /* Port already enabled: must be high-speed */
1610                 speed = USB_SPEED_HIGH;
1611         } else {
1612                 /* Not low-speed and not yet enabled.  Could be either
1613                  * full-speed or high-speed; we can't yet tell.
1614                  */
1615                 speed = USB_SPEED_FULL;
1616         }
1617         port->speed = speed;
1618         return 0;
1619 }
1620
1621 /**
1622  * Clear transaction translator buffer
1623  *
1624  * @v hub               USB hub
1625  * @v port              USB port
1626  * @v ep                USB endpoint
1627  * @ret rc              Return status code
1628  */
1629 static int ehci_root_clear_tt ( struct usb_hub *hub, struct usb_port *port,
1630                                 struct usb_endpoint *ep ) {
1631         struct ehci_device *ehci = usb_hub_get_drvdata ( hub );
1632
1633         /* Should never be called; this is a root hub */
1634         DBGC ( ehci, "EHCI %s-%d nonsensical CLEAR_TT for %s %s\n", ehci->name,
1635                port->address, ep->usb->name, usb_endpoint_name ( ep ) );
1636
1637         return -ENOTSUP;
1638 }
1639
1640 /**
1641  * Poll for port status changes
1642  *
1643  * @v hub               USB hub
1644  * @v port              USB port
1645  */
1646 static void ehci_root_poll ( struct usb_hub *hub, struct usb_port *port ) {
1647         struct ehci_device *ehci = usb_hub_get_drvdata ( hub );
1648         uint32_t portsc;
1649         uint32_t change;
1650
1651         /* Do nothing unless something has changed */
1652         portsc = readl ( ehci->op + EHCI_OP_PORTSC ( port->address ) );
1653         change = ( portsc & EHCI_PORTSC_CHANGE );
1654         if ( ! change )
1655                 return;
1656
1657         /* Record disconnections and clear changes */
1658         port->disconnected |= ( portsc & EHCI_PORTSC_CSC );
1659         writel ( portsc, ehci->op + EHCI_OP_PORTSC ( port->address ) );
1660
1661         /* Report port status change */
1662         usb_port_changed ( port );
1663 }
1664
1665 /******************************************************************************
1666  *
1667  * Bus operations
1668  *
1669  ******************************************************************************
1670  */
1671
1672 /**
1673  * Open USB bus
1674  *
1675  * @v bus               USB bus
1676  * @ret rc              Return status code
1677  */
1678 static int ehci_bus_open ( struct usb_bus *bus ) {
1679         struct ehci_device *ehci = usb_bus_get_hostdata ( bus );
1680         unsigned int frames;
1681         size_t len;
1682         int rc;
1683
1684         /* Sanity checks */
1685         assert ( list_empty ( &ehci->async ) );
1686         assert ( list_empty ( &ehci->periodic ) );
1687
1688         /* Allocate and initialise asynchronous queue head */
1689         ehci->head = malloc_dma ( sizeof ( *ehci->head ),
1690                                   ehci_align ( sizeof ( *ehci->head ) ) );
1691         if ( ! ehci->head ) {
1692                 rc = -ENOMEM;
1693                 goto err_alloc_head;
1694         }
1695         memset ( ehci->head, 0, sizeof ( *ehci->head ) );
1696         ehci->head->chr = cpu_to_le32 ( EHCI_CHR_HEAD );
1697         ehci->head->cache.next = cpu_to_le32 ( EHCI_LINK_TERMINATE );
1698         ehci->head->cache.status = EHCI_STATUS_HALTED;
1699         ehci_async_schedule ( ehci );
1700         writel ( virt_to_phys ( ehci->head ),
1701                  ehci->op + EHCI_OP_ASYNCLISTADDR );
1702
1703         /* Use async queue head to determine control data structure segment */
1704         ehci->ctrldssegment =
1705                 ( ( ( uint64_t ) virt_to_phys ( ehci->head ) ) >> 32 );
1706         if ( ehci->addr64 ) {
1707                 writel ( ehci->ctrldssegment, ehci->op + EHCI_OP_CTRLDSSEGMENT);
1708         } else if ( ehci->ctrldssegment ) {
1709                 DBGC ( ehci, "EHCI %s CTRLDSSEGMENT not supported\n",
1710                        ehci->name );
1711                 rc = -ENOTSUP;
1712                 goto err_ctrldssegment;
1713         }
1714
1715         /* Allocate periodic frame list */
1716         frames = EHCI_PERIODIC_FRAMES ( ehci->flsize );
1717         len = ( frames * sizeof ( ehci->frame[0] ) );
1718         ehci->frame = malloc_dma ( len, EHCI_PAGE_ALIGN );
1719         if ( ! ehci->frame ) {
1720                 rc = -ENOMEM;
1721                 goto err_alloc_frame;
1722         }
1723         if ( ( rc = ehci_ctrl_reachable ( ehci, ehci->frame ) ) != 0 ) {
1724                 DBGC ( ehci, "EHCI %s frame list unreachable\n", ehci->name );
1725                 goto err_unreachable_frame;
1726         }
1727         ehci_periodic_schedule ( ehci );
1728         writel ( virt_to_phys ( ehci->frame ),
1729                  ehci->op + EHCI_OP_PERIODICLISTBASE );
1730
1731         /* Start controller */
1732         ehci_run ( ehci );
1733
1734         return 0;
1735
1736         ehci_stop ( ehci );
1737  err_unreachable_frame:
1738         free_dma ( ehci->frame, len );
1739  err_alloc_frame:
1740  err_ctrldssegment:
1741         free_dma ( ehci->head, sizeof ( *ehci->head ) );
1742  err_alloc_head:
1743         return rc;
1744 }
1745
1746 /**
1747  * Close USB bus
1748  *
1749  * @v bus               USB bus
1750  */
1751 static void ehci_bus_close ( struct usb_bus *bus ) {
1752         struct ehci_device *ehci = usb_bus_get_hostdata ( bus );
1753         unsigned int frames = EHCI_PERIODIC_FRAMES ( ehci->flsize );
1754
1755         /* Sanity checks */
1756         assert ( list_empty ( &ehci->async ) );
1757         assert ( list_empty ( &ehci->periodic ) );
1758
1759         /* Stop controller */
1760         ehci_stop ( ehci );
1761
1762         /* Free periodic frame list */
1763         free_dma ( ehci->frame, ( frames * sizeof ( ehci->frame[0] ) ) );
1764
1765         /* Free asynchronous schedule */
1766         free_dma ( ehci->head, sizeof ( *ehci->head ) );
1767 }
1768
1769 /**
1770  * Poll USB bus
1771  *
1772  * @v bus               USB bus
1773  */
1774 static void ehci_bus_poll ( struct usb_bus *bus ) {
1775         struct ehci_device *ehci = usb_bus_get_hostdata ( bus );
1776         struct usb_hub *hub = bus->hub;
1777         struct ehci_endpoint *endpoint;
1778         unsigned int i;
1779         uint32_t usbsts;
1780         uint32_t change;
1781
1782         /* Do nothing unless something has changed */
1783         usbsts = readl ( ehci->op + EHCI_OP_USBSTS );
1784         assert ( usbsts & EHCI_USBSTS_ASYNC );
1785         assert ( usbsts & EHCI_USBSTS_PERIODIC );
1786         assert ( ! ( usbsts & EHCI_USBSTS_HCH ) );
1787         change = ( usbsts & EHCI_USBSTS_CHANGE );
1788         if ( ! change )
1789                 return;
1790
1791         /* Acknowledge changes */
1792         writel ( usbsts, ehci->op + EHCI_OP_USBSTS );
1793
1794         /* Process completions, if applicable */
1795         if ( change & ( EHCI_USBSTS_USBINT | EHCI_USBSTS_USBERRINT ) ) {
1796
1797                 /* Iterate over all endpoints looking for completed
1798                  * descriptors.  We trust that completion handlers are
1799                  * minimal and will not do anything that could
1800                  * plausibly affect the endpoint list itself.
1801                  */
1802                 list_for_each_entry ( endpoint, &ehci->endpoints, list )
1803                         ehci_endpoint_poll ( endpoint );
1804         }
1805
1806         /* Process port status changes, if applicable */
1807         if ( change & EHCI_USBSTS_PORT ) {
1808
1809                 /* Iterate over all ports looking for status changes */
1810                 for ( i = 1 ; i <= ehci->ports ; i++ )
1811                         ehci_root_poll ( hub, usb_port ( hub, i ) );
1812         }
1813
1814         /* Report fatal errors */
1815         if ( change & EHCI_USBSTS_SYSERR )
1816                 DBGC ( ehci, "EHCI %s host system error\n", ehci->name );
1817 }
1818
1819 /******************************************************************************
1820  *
1821  * PCI interface
1822  *
1823  ******************************************************************************
1824  */
1825
1826 /** USB host controller operations */
1827 static struct usb_host_operations ehci_operations = {
1828         .endpoint = {
1829                 .open = ehci_endpoint_open,
1830                 .close = ehci_endpoint_close,
1831                 .reset = ehci_endpoint_reset,
1832                 .mtu = ehci_endpoint_mtu,
1833                 .message = ehci_endpoint_message,
1834                 .stream = ehci_endpoint_stream,
1835         },
1836         .device = {
1837                 .open = ehci_device_open,
1838                 .close = ehci_device_close,
1839                 .address = ehci_device_address,
1840         },
1841         .bus = {
1842                 .open = ehci_bus_open,
1843                 .close = ehci_bus_close,
1844                 .poll = ehci_bus_poll,
1845         },
1846         .hub = {
1847                 .open = ehci_hub_open,
1848                 .close = ehci_hub_close,
1849         },
1850         .root = {
1851                 .open = ehci_root_open,
1852                 .close = ehci_root_close,
1853                 .enable = ehci_root_enable,
1854                 .disable = ehci_root_disable,
1855                 .speed = ehci_root_speed,
1856                 .clear_tt = ehci_root_clear_tt,
1857         },
1858 };
1859
1860 /**
1861  * Probe PCI device
1862  *
1863  * @v pci               PCI device
1864  * @ret rc              Return status code
1865  */
1866 static int ehci_probe ( struct pci_device *pci ) {
1867         struct ehci_device *ehci;
1868         struct usb_port *port;
1869         unsigned long bar_start;
1870         size_t bar_size;
1871         unsigned int i;
1872         int rc;
1873
1874         /* Allocate and initialise structure */
1875         ehci = zalloc ( sizeof ( *ehci ) );
1876         if ( ! ehci ) {
1877                 rc = -ENOMEM;
1878                 goto err_alloc;
1879         }
1880         ehci->name = pci->dev.name;
1881         INIT_LIST_HEAD ( &ehci->endpoints );
1882         INIT_LIST_HEAD ( &ehci->async );
1883         INIT_LIST_HEAD ( &ehci->periodic );
1884
1885         /* Fix up PCI device */
1886         adjust_pci_device ( pci );
1887
1888         /* Map registers */
1889         bar_start = pci_bar_start ( pci, EHCI_BAR );
1890         bar_size = pci_bar_size ( pci, EHCI_BAR );
1891         ehci->regs = ioremap ( bar_start, bar_size );
1892         if ( ! ehci->regs ) {
1893                 rc = -ENODEV;
1894                 goto err_ioremap;
1895         }
1896
1897         /* Initialise EHCI device */
1898         ehci_init ( ehci, ehci->regs );
1899
1900         /* Initialise USB legacy support and claim ownership */
1901         ehci_legacy_init ( ehci, pci );
1902         ehci_legacy_claim ( ehci, pci );
1903
1904         /* Reset device */
1905         if ( ( rc = ehci_reset ( ehci ) ) != 0 )
1906                 goto err_reset;
1907
1908         /* Allocate USB bus */
1909         ehci->bus = alloc_usb_bus ( &pci->dev, ehci->ports, EHCI_MTU,
1910                                     &ehci_operations );
1911         if ( ! ehci->bus ) {
1912                 rc = -ENOMEM;
1913                 goto err_alloc_bus;
1914         }
1915         usb_bus_set_hostdata ( ehci->bus, ehci );
1916         usb_hub_set_drvdata ( ehci->bus->hub, ehci );
1917
1918         /* Set port protocols */
1919         for ( i = 1 ; i <= ehci->ports ; i++ ) {
1920                 port = usb_port ( ehci->bus->hub, i );
1921                 port->protocol = USB_PROTO_2_0;
1922         }
1923
1924         /* Register USB bus */
1925         if ( ( rc = register_usb_bus ( ehci->bus ) ) != 0 )
1926                 goto err_register;
1927
1928         pci_set_drvdata ( pci, ehci );
1929         return 0;
1930
1931         unregister_usb_bus ( ehci->bus );
1932  err_register:
1933         free_usb_bus ( ehci->bus );
1934  err_alloc_bus:
1935         ehci_reset ( ehci );
1936  err_reset:
1937         ehci_legacy_release ( ehci, pci );
1938         iounmap ( ehci->regs );
1939  err_ioremap:
1940         free ( ehci );
1941  err_alloc:
1942         return rc;
1943 }
1944
1945 /**
1946  * Remove PCI device
1947  *
1948  * @v pci               PCI device
1949  */
1950 static void ehci_remove ( struct pci_device *pci ) {
1951         struct ehci_device *ehci = pci_get_drvdata ( pci );
1952         struct usb_bus *bus = ehci->bus;
1953
1954         unregister_usb_bus ( bus );
1955         assert ( list_empty ( &ehci->async ) );
1956         assert ( list_empty ( &ehci->periodic ) );
1957         free_usb_bus ( bus );
1958         ehci_reset ( ehci );
1959         ehci_legacy_release ( ehci, pci );
1960         iounmap ( ehci->regs );
1961         free ( ehci );
1962 }
1963
1964 /** EHCI PCI device IDs */
1965 static struct pci_device_id ehci_ids[] = {
1966         PCI_ROM ( 0xffff, 0xffff, "ehci", "EHCI", 0 ),
1967 };
1968
1969 /** EHCI PCI driver */
1970 struct pci_driver ehci_driver __pci_driver = {
1971         .ids = ehci_ids,
1972         .id_count = ( sizeof ( ehci_ids ) / sizeof ( ehci_ids[0] ) ),
1973         .class = PCI_CLASS_ID ( PCI_CLASS_SERIAL, PCI_CLASS_SERIAL_USB,
1974                                 PCI_CLASS_SERIAL_USB_EHCI ),
1975         .probe = ehci_probe,
1976         .remove = ehci_remove,
1977 };
1978
1979 /**
1980  * Prepare for exit
1981  *
1982  * @v booting           System is shutting down for OS boot
1983  */
1984 static void ehci_shutdown ( int booting ) {
1985         /* If we are shutting down to boot an OS, then prevent the
1986          * release of ownership back to BIOS.
1987          */
1988         ehci_legacy_prevent_release = booting;
1989 }
1990
1991 /** Startup/shutdown function */
1992 struct startup_fn ehci_startup __startup_fn ( STARTUP_LATE ) = {
1993         .shutdown = ehci_shutdown,
1994 };