MdeModulePkg/Bus/Usb/UsbBusDxe/usbbus.c

   1 /** @file
   2
   3 Copyright (c) 2004 - 2007, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12   Module Name:
  13
  14     UsbBus.c
  15
  16   Abstract:
  17
  18     Usb Bus Driver Binding and Bus IO Protocol
  19
  20   Revision History
  21
  22
  23 **/
  24
  25 #include "UsbBus.h"
  26
  27 //
  28 // USB_BUS_PROTOCOL is only used to locate USB_BUS
  29 //
  30 EFI_GUID  mUsbBusProtocolGuid = EFI_USB_BUS_PROTOCOL_GUID;
  31
  32
  33 /**
  34   USB_IO function to execute a control transfer. This
  35   function will execute the USB transfer. If transfer
  36   successes, it will sync the internal state of USB bus
  37   with device state.
  38
  39   @param  This                   The USB_IO instance
  40   @param  Request                The control transfer request
  41   @param  Direction              Direction for data stage
  42   @param  Timeout                The time to wait before timeout
  43   @param  Data                   The buffer holding the data
  44   @param  DataLength             Then length of the data
  45   @param  UsbStatus              USB result
  46
  47   @retval EFI_INVALID_PARAMETER  The parameters are invalid
  48   @retval EFI_SUCCESS            The control transfer succeded.
  49   @retval Others                 Failed to execute the transfer
  50
  51 **/
  52 STATIC
  53 EFI_STATUS
  54 EFIAPI
  55 UsbIoControlTransfer (
  56   IN  EFI_USB_IO_PROTOCOL     *This,
  57   IN  EFI_USB_DEVICE_REQUEST  *Request,
  58   IN  EFI_USB_DATA_DIRECTION  Direction,
  59   IN  UINT32                  Timeout,
  60   IN  OUT VOID                *Data,      OPTIONAL
  61   IN  UINTN                   DataLength, OPTIONAL
  62   OUT UINT32                  *UsbStatus
  63   )
  64 {
  65   USB_DEVICE              *Dev;
  66   USB_INTERFACE           *UsbIf;
  67   USB_ENDPOINT_DESC       *EpDesc;
  68   EFI_TPL                 OldTpl;
  69   EFI_STATUS              Status;
  70
  71   if (UsbStatus == NULL) {
  72     return EFI_INVALID_PARAMETER;
  73   }
  74
  75   OldTpl = gBS->RaiseTPL (USB_BUS_TPL);
  76
  77   UsbIf  = USB_INTERFACE_FROM_USBIO (This);
  78   Dev    = UsbIf->Device;
  79
  80   Status = UsbHcControlTransfer (
  81              Dev->Bus,
  82              Dev->Address,
  83              Dev->Speed,
  84              Dev->MaxPacket0,
  85              Request,
  86              Direction,
  87              Data,
  88              &DataLength,
  89              (UINTN) Timeout,
  90              &Dev->Translator,
  91              UsbStatus
  92              );
  93
  94   if (EFI_ERROR (Status) || (*UsbStatus != EFI_USB_NOERROR)) {
  95     //
  96     // Clear TT buffer when CTRL/BULK split transaction failes
  97     // Clear the TRANSLATOR TT buffer, not parent's buffer
  98     //
  99     if (Dev->Translator.TranslatorHubAddress != 0) {
 100       UsbHubCtrlClearTTBuffer (
 101         Dev->Bus->Devices[Dev->Translator.TranslatorHubAddress],
 102         Dev->Translator.TranslatorPortNumber,
 103         Dev->Address,
 104         0,
 105         USB_ENDPOINT_CONTROL
 106         );
 107     }
 108
 109     goto ON_EXIT;
 110   }
 111
 112   //
 113   // Some control transfer will change the device's internal
 114   // status, such as Set_Configuration and Set_Interface.
 115   // We must synchronize the bus driver's status with that in
 116   // device. We ignore the Set_Descriptor request because it's
 117   // hardly used by any device, especially in pre-boot environment
 118   //
 119
 120   //
 121   // Reset the endpoint toggle when endpoint stall is cleared
 122   //
 123   if ((Request->Request     == USB_REQ_CLEAR_FEATURE) &&
 124       (Request->RequestType == USB_REQUEST_TYPE (EfiUsbNoData, USB_REQ_TYPE_STANDARD,
 125                                                  USB_TARGET_ENDPOINT)) &&
 126       (Request->Value       == USB_FEATURE_ENDPOINT_HALT)) {
 127
 128     EpDesc = UsbGetEndpointDesc (UsbIf, (UINT8) Request->Index);
 129
 130     if (EpDesc != NULL) {
 131       EpDesc->Toggle = 0;
 132     }
 133   }
 134
 135   //
 136   // Select a new configuration. This is a dangerous action. Upper driver
 137   // should stop use its current UsbIo after calling this driver. The old
 138   // UsbIo will be uninstalled and new UsbIo be installed. We can't use
 139   // ReinstallProtocol since interfaces in different configuration may be
 140   // completely irrellvant.
 141   //
 142   if ((Request->Request == USB_REQ_SET_CONFIG) &&
 143       (Request->RequestType == USB_REQUEST_TYPE (EfiUsbNoData, USB_REQ_TYPE_STANDARD,
 144                                                  USB_TARGET_DEVICE))) {
 145     //
 146     // Don't re-create the USB interfaces if configuration isn't changed.
 147     //
 148     if ((Dev->ActiveConfig != NULL) &&
 149         (Request->Value == Dev->ActiveConfig->Desc.ConfigurationValue)) {
 150
 151       goto ON_EXIT;
 152     }
 153
 154     USB_DEBUG (("UsbIoControlTransfer: configure changed!!! Do NOT use old UsbIo!!!\n"));
 155
 156     if (Dev->ActiveConfig != NULL) {
 157       UsbRemoveConfig (Dev);
 158     }
 159
 160     if (Request->Value != 0) {
 161       Status = UsbSelectConfig (Dev, (UINT8) Request->Value);
 162     }
 163
 164     //
 165     // Exit now, Old USB_IO is invalid now
 166     //
 167     goto ON_EXIT;
 168   }
 169
 170   //
 171   // A new alternative setting is selected for the interface.
 172   // No need to reinstall UsbIo in this case because only
 173   // underlying communication endpoints are changed. Functionality
 174   // should remains the same.
 175   //
 176   if ((Request->Request     == USB_REQ_SET_INTERFACE) &&
 177       (Request->RequestType == USB_REQUEST_TYPE (EfiUsbNoData, USB_REQ_TYPE_STANDARD,
 178                                                  USB_TARGET_INTERFACE)) &&
 179       (Request->Index       == UsbIf->IfSetting->Desc.InterfaceNumber)) {
 180
 181     Status = UsbSelectSetting (UsbIf->IfDesc, (UINT8) Request->Value);
 182
 183     if (!EFI_ERROR (Status)) {
 184       UsbIf->IfSetting = UsbIf->IfDesc->Settings[UsbIf->IfDesc->ActiveIndex];
 185     }
 186   }
 187
 188 ON_EXIT:
 189   gBS->RestoreTPL (OldTpl);
 190   return Status;
 191 }
 192
 193
 194 /**
 195   Execute a bulk transfer to the device endpoint
 196
 197   @param  This                   The USB IO instance
 198   @param  Endpoint               The device endpoint
 199   @param  Data                   The data to transfer
 200   @param  DataLength             The length of the data to transfer
 201   @param  Timeout                Time to wait before timeout
 202   @param  UsbStatus              The result of USB transfer
 203
 204   @retval EFI_SUCCESS            The bulk transfer is OK
 205   @retval EFI_INVALID_PARAMETER  Some parameters are invalid
 206   @retval Others                 Failed to execute transfer, reason returned in
 207                                  UsbStatus
 208
 209 **/
 210 STATIC
 211 EFI_STATUS
 212 EFIAPI
 213 UsbIoBulkTransfer (
 214   IN  EFI_USB_IO_PROTOCOL *This,
 215   IN  UINT8               Endpoint,
 216   IN  OUT VOID            *Data,
 217   IN  OUT UINTN           *DataLength,
 218   IN  UINTN               Timeout,
 219   OUT UINT32              *UsbStatus
 220   )
 221 {
 222   USB_DEVICE              *Dev;
 223   USB_INTERFACE           *UsbIf;
 224   USB_ENDPOINT_DESC       *EpDesc;
 225   UINT8                   BufNum;
 226   UINT8                   Toggle;
 227   EFI_TPL                 OldTpl;
 228   EFI_STATUS              Status;
 229
 230   if ((USB_ENDPOINT_ADDR (Endpoint) == 0) || (USB_ENDPOINT_ADDR(Endpoint) > 15) ||
 231       (UsbStatus == NULL)) {
 232
 233     return EFI_INVALID_PARAMETER;
 234   }
 235
 236   OldTpl  = gBS->RaiseTPL (USB_BUS_TPL);
 237
 238   UsbIf   = USB_INTERFACE_FROM_USBIO (This);
 239   Dev     = UsbIf->Device;
 240
 241   EpDesc  = UsbGetEndpointDesc (UsbIf, Endpoint);
 242
 243   if ((EpDesc == NULL) || (USB_ENDPOINT_TYPE (&EpDesc->Desc) != USB_ENDPOINT_BULK)) {
 244     Status = EFI_INVALID_PARAMETER;
 245     goto ON_EXIT;
 246   }
 247
 248   BufNum  = 1;
 249   Toggle  = EpDesc->Toggle;
 250   Status  = UsbHcBulkTransfer (
 251               Dev->Bus,
 252               Dev->Address,
 253               Endpoint,
 254               Dev->Speed,
 255               EpDesc->Desc.MaxPacketSize,
 256               BufNum,
 257               &Data,
 258               DataLength,
 259               &Toggle,
 260               Timeout,
 261               &Dev->Translator,
 262               UsbStatus
 263               );
 264
 265   EpDesc->Toggle = Toggle;
 266
 267   if (EFI_ERROR (Status) || (*UsbStatus != EFI_USB_NOERROR)) {
 268     //
 269     // Clear TT buffer when CTRL/BULK split transaction failes.
 270     // Clear the TRANSLATOR TT buffer, not parent's buffer
 271     //
 272     if (Dev->Translator.TranslatorHubAddress != 0) {
 273       UsbHubCtrlClearTTBuffer (
 274         Dev->Bus->Devices[Dev->Translator.TranslatorHubAddress],
 275         Dev->Translator.TranslatorPortNumber,
 276         Dev->Address,
 277         0,
 278         USB_ENDPOINT_BULK
 279         );
 280     }
 281   }
 282
 283 ON_EXIT:
 284   gBS->RestoreTPL (OldTpl);
 285   return Status;
 286 }
 287
 288
 289 /**
 290   Execute a synchronous interrupt transfer
 291
 292   @param  This                   The USB IO instance
 293   @param  Endpoint               The device endpoint
 294   @param  Data                   The data to transfer
 295   @param  DataLength             The length of the data to transfer
 296   @param  Timeout                Time to wait before timeout
 297   @param  UsbStatus              The result of USB transfer
 298
 299   @retval EFI_SUCCESS            The synchronous interrupt transfer is OK
 300   @retval EFI_INVALID_PARAMETER  Some parameters are invalid
 301   @retval Others                 Failed to execute transfer, reason returned in
 302                                  UsbStatus
 303
 304 **/
 305 STATIC
 306 EFI_STATUS
 307 EFIAPI
 308 UsbIoSyncInterruptTransfer (
 309   IN  EFI_USB_IO_PROTOCOL *This,
 310   IN  UINT8               Endpoint,
 311   IN  OUT VOID            *Data,
 312   IN  OUT UINTN           *DataLength,
 313   IN  UINTN               Timeout,
 314   OUT UINT32              *UsbStatus
 315   )
 316 {
 317   USB_DEVICE              *Dev;
 318   USB_INTERFACE           *UsbIf;
 319   USB_ENDPOINT_DESC       *EpDesc;
 320   EFI_TPL                 OldTpl;
 321   UINT8                   Toggle;
 322   EFI_STATUS              Status;
 323
 324   if ((USB_ENDPOINT_ADDR (Endpoint) == 0) || (USB_ENDPOINT_ADDR(Endpoint) > 15) ||
 325       (UsbStatus == NULL)) {
 326
 327     return EFI_INVALID_PARAMETER;
 328   }
 329
 330   OldTpl  = gBS->RaiseTPL (USB_BUS_TPL);
 331
 332   UsbIf   = USB_INTERFACE_FROM_USBIO (This);
 333   Dev     = UsbIf->Device;
 334
 335   EpDesc  = UsbGetEndpointDesc (UsbIf, Endpoint);
 336
 337   if ((EpDesc == NULL) || (USB_ENDPOINT_TYPE (&EpDesc->Desc) != USB_ENDPOINT_INTERRUPT)) {
 338     Status = EFI_INVALID_PARAMETER;
 339     goto ON_EXIT;
 340   }
 341
 342   Toggle = EpDesc->Toggle;
 343   Status = UsbHcSyncInterruptTransfer (
 344              Dev->Bus,
 345              Dev->Address,
 346              Endpoint,
 347              Dev->Speed,
 348              EpDesc->Desc.MaxPacketSize,
 349              Data,
 350              DataLength,
 351              &Toggle,
 352              Timeout,
 353              &Dev->Translator,
 354              UsbStatus
 355              );
 356
 357   EpDesc->Toggle = Toggle;
 358
 359 ON_EXIT:
 360   gBS->RestoreTPL (OldTpl);
 361   return Status;
 362 }
 363
 364
 365 /**
 366   Queue a new asynchronous interrupt transfer, or remove the old
 367   request if (IsNewTransfer == FALSE)
 368
 369   @param  This                   The USB_IO instance
 370   @param  Endpoint               The device endpoint
 371   @param  IsNewTransfer          Whether this is a new request, if it's old, remove
 372                                  the request
 373   @param  PollInterval           The interval to poll the transfer result, (in ms)
 374   @param  DataLength             The length of perodic data transfer
 375   @param  Callback               The function to call periodicaly when transfer is
 376                                  ready
 377   @param  Context                The context to the callback
 378
 379   @retval EFI_SUCCESS            New transfer is queued or old request is removed
 380   @retval EFI_INVALID_PARAMETER  Some parameters are invalid
 381   @retval Others                 Failed to queue the new request or remove the old
 382                                  request
 383
 384 **/
 385 STATIC
 386 EFI_STATUS
 387 EFIAPI
 388 UsbIoAsyncInterruptTransfer (
 389   IN EFI_USB_IO_PROTOCOL              *This,
 390   IN UINT8                            Endpoint,
 391   IN BOOLEAN                          IsNewTransfer,
 392   IN UINTN                            PollInterval,       OPTIONAL
 393   IN UINTN                            DataLength,         OPTIONAL
 394   IN EFI_ASYNC_USB_TRANSFER_CALLBACK  Callback,           OPTIONAL
 395   IN VOID                             *Context            OPTIONAL
 396   )
 397 {
 398   USB_DEVICE              *Dev;
 399   USB_INTERFACE           *UsbIf;
 400   USB_ENDPOINT_DESC       *EpDesc;
 401   EFI_TPL                 OldTpl;
 402   UINT8                   Toggle;
 403   EFI_STATUS              Status;
 404
 405   if ((USB_ENDPOINT_ADDR (Endpoint) == 0) || (USB_ENDPOINT_ADDR (Endpoint) > 15)) {
 406     return EFI_INVALID_PARAMETER;
 407   }
 408
 409   OldTpl  = gBS->RaiseTPL (USB_BUS_TPL);
 410   UsbIf   = USB_INTERFACE_FROM_USBIO (This);
 411   Dev     = UsbIf->Device;
 412
 413   EpDesc  = UsbGetEndpointDesc (UsbIf, Endpoint);
 414
 415   if ((EpDesc == NULL) || (USB_ENDPOINT_TYPE (&EpDesc->Desc) != USB_ENDPOINT_INTERRUPT)) {
 416     Status = EFI_INVALID_PARAMETER;
 417     goto ON_EXIT;
 418   }
 419
 420   Toggle  = EpDesc->Toggle;
 421   Status  = UsbHcAsyncInterruptTransfer (
 422               Dev->Bus,
 423               Dev->Address,
 424               Endpoint,
 425               Dev->Speed,
 426               EpDesc->Desc.MaxPacketSize,
 427               IsNewTransfer,
 428               &Toggle,
 429               PollInterval,
 430               DataLength,
 431               &Dev->Translator,
 432               Callback,
 433               Context
 434               );
 435
 436   EpDesc->Toggle = Toggle;
 437
 438 ON_EXIT:
 439   gBS->RestoreTPL (OldTpl);
 440   return Status;
 441 }
 442
 443
 444 /**
 445   Execute a synchronous isochronous transfer
 446
 447   @param  This                   The USB IO instance
 448   @param  DeviceEndpoint         The device endpoint
 449   @param  Data                   The data to transfer
 450   @param  DataLength             The length of the data to transfer
 451   @param  UsbStatus              The result of USB transfer
 452
 453   @retval EFI_UNSUPPORTED        Currently isochronous transfer isn't supported
 454
 455 **/
 456 STATIC
 457 EFI_STATUS
 458 EFIAPI
 459 UsbIoIsochronousTransfer (
 460   IN  EFI_USB_IO_PROTOCOL *This,
 461   IN  UINT8               DeviceEndpoint,
 462   IN  OUT VOID            *Data,
 463   IN  UINTN               DataLength,
 464   OUT UINT32              *Status
 465   )
 466 {
 467   return EFI_UNSUPPORTED;
 468 }
 469
 470
 471 /**
 472   Queue an asynchronous isochronous transfer
 473
 474   @param  This                   The USB_IO instance
 475   @param  DeviceEndpoint         The device endpoint
 476   @param  DataLength             The length of perodic data transfer
 477   @param  IsochronousCallBack    The function to call periodicaly when transfer is
 478                                  ready
 479   @param  Context                The context to the callback
 480
 481   @retval EFI_UNSUPPORTED        Currently isochronous transfer isn't supported
 482
 483 **/
 484 STATIC
 485 EFI_STATUS
 486 EFIAPI
 487 UsbIoAsyncIsochronousTransfer (
 488   IN EFI_USB_IO_PROTOCOL              *This,
 489   IN UINT8                            DeviceEndpoint,
 490   IN OUT VOID                         *Data,
 491   IN UINTN                            DataLength,
 492   IN EFI_ASYNC_USB_TRANSFER_CALLBACK  IsochronousCallBack,
 493   IN VOID                             *Context              OPTIONAL
 494   )
 495 {
 496   return EFI_UNSUPPORTED;
 497 }
 498
 499
 500 /**
 501   Retrieve the device descriptor of the device
 502
 503   @param  This                   The USB IO instance
 504   @param  Descriptor             The variable to receive the device descriptor
 505
 506   @retval EFI_SUCCESS            The device descriptor is returned
 507   @retval EFI_INVALID_PARAMETER  The parameter is invalid
 508
 509 **/
 510 STATIC
 511 EFI_STATUS
 512 EFIAPI
 513 UsbIoGetDeviceDescriptor (
 514   IN  EFI_USB_IO_PROTOCOL       *This,
 515   OUT EFI_USB_DEVICE_DESCRIPTOR *Descriptor
 516   )
 517 {
 518   USB_DEVICE              *Dev;
 519   USB_INTERFACE           *UsbIf;
 520   EFI_TPL                 OldTpl;
 521
 522   if (Descriptor == NULL) {
 523     return EFI_INVALID_PARAMETER;
 524   }
 525
 526   OldTpl = gBS->RaiseTPL (USB_BUS_TPL);
 527
 528   UsbIf  = USB_INTERFACE_FROM_USBIO (This);
 529   Dev    = UsbIf->Device;
 530
 531   CopyMem (Descriptor, &Dev->DevDesc->Desc, sizeof (EFI_USB_DEVICE_DESCRIPTOR));
 532
 533   gBS->RestoreTPL (OldTpl);
 534   return EFI_SUCCESS;
 535 }
 536
 537
 538 /**
 539   Return the configuration descriptor of the current active configuration
 540
 541   @param  This                   The USB IO instance
 542   @param  Descriptor             The USB configuration descriptor
 543
 544   @retval EFI_SUCCESS            The active configuration descriptor is returned
 545   @retval EFI_INVALID_PARAMETER  Some parameter is invalid
 546   @retval EFI_NOT_FOUND          Currently no active configuration is selected.
 547
 548 **/
 549 STATIC
 550 EFI_STATUS
 551 EFIAPI
 552 UsbIoGetActiveConfigDescriptor (
 553   IN  EFI_USB_IO_PROTOCOL       *This,
 554   OUT EFI_USB_CONFIG_DESCRIPTOR *Descriptor
 555   )
 556 {
 557   USB_DEVICE              *Dev;
 558   USB_INTERFACE           *UsbIf;
 559   EFI_STATUS              Status;
 560   EFI_TPL                 OldTpl;
 561
 562   if (Descriptor == NULL) {
 563     return EFI_INVALID_PARAMETER;
 564   }
 565
 566   Status = EFI_SUCCESS;
 567   OldTpl = gBS->RaiseTPL (USB_BUS_TPL);
 568
 569   UsbIf  = USB_INTERFACE_FROM_USBIO (This);
 570   Dev    = UsbIf->Device;
 571
 572   if (Dev->ActiveConfig == NULL) {
 573     Status = EFI_NOT_FOUND;
 574     goto ON_EXIT;
 575   }
 576
 577   CopyMem (Descriptor, &(Dev->ActiveConfig->Desc), sizeof (EFI_USB_CONFIG_DESCRIPTOR));
 578
 579 ON_EXIT:
 580   gBS->RestoreTPL (OldTpl);
 581   return Status;
 582 }
 583
 584
 585 /**
 586   Retrieve the active interface setting descriptor for this USB IO instance
 587
 588   @param  This                   The USB IO instance
 589   @param  Descriptor             The variable to receive active interface setting
 590
 591   @retval EFI_SUCCESS            The active interface setting is returned
 592   @retval EFI_INVALID_PARAMETER  Some parameter is invalid
 593
 594 **/
 595 STATIC
 596 EFI_STATUS
 597 EFIAPI
 598 UsbIoGetInterfaceDescriptor (
 599   IN  EFI_USB_IO_PROTOCOL           *This,
 600   OUT EFI_USB_INTERFACE_DESCRIPTOR  *Descriptor
 601   )
 602 {
 603   USB_INTERFACE           *UsbIf;
 604   EFI_TPL                 OldTpl;
 605
 606   if (Descriptor == NULL) {
 607     return EFI_INVALID_PARAMETER;
 608   }
 609
 610   OldTpl = gBS->RaiseTPL (USB_BUS_TPL);
 611
 612   UsbIf  = USB_INTERFACE_FROM_USBIO (This);
 613   CopyMem (Descriptor, &(UsbIf->IfSetting->Desc), sizeof (EFI_USB_INTERFACE_DESCRIPTOR));
 614
 615   gBS->RestoreTPL (OldTpl);
 616   return EFI_SUCCESS;
 617 }
 618
 619
 620 /**
 621   Retrieve the endpoint descriptor from this interface setting
 622
 623   @param  This                   The USB IO instance
 624   @param  Index                  The index (start from zero) of the endpoint to
 625                                  retrieve
 626   @param  Descriptor             The variable to receive the descriptor
 627
 628   @retval EFI_SUCCESS            The endpoint descriptor is returned
 629   @retval EFI_INVALID_PARAMETER  Some parameter is invalid
 630
 631 **/
 632 STATIC
 633 EFI_STATUS
 634 EFIAPI
 635 UsbIoGetEndpointDescriptor (
 636   IN  EFI_USB_IO_PROTOCOL         *This,
 637   IN  UINT8                       Index,
 638   OUT EFI_USB_ENDPOINT_DESCRIPTOR *Descriptor
 639   )
 640 {
 641   USB_INTERFACE           *UsbIf;
 642   EFI_TPL                 OldTpl;
 643
 644   OldTpl = gBS->RaiseTPL (USB_BUS_TPL);
 645
 646   UsbIf  = USB_INTERFACE_FROM_USBIO (This);
 647
 648   if ((Descriptor == NULL) || (Index > 15)) {
 649     gBS->RestoreTPL (OldTpl);
 650     return EFI_INVALID_PARAMETER;
 651   }
 652
 653   if (Index >= UsbIf->IfSetting->Desc.NumEndpoints) {
 654     gBS->RestoreTPL (OldTpl);
 655     return EFI_NOT_FOUND;
 656   }
 657
 658   CopyMem (
 659     Descriptor,
 660     &(UsbIf->IfSetting->Endpoints[Index]->Desc),
 661     sizeof (EFI_USB_ENDPOINT_DESCRIPTOR)
 662     );
 663
 664   gBS->RestoreTPL (OldTpl);
 665   return EFI_SUCCESS;
 666 }
 667
 668
 669 /**
 670   Retrieve the supported language ID table from the device
 671
 672   @param  This                   The USB IO instance
 673   @param  LangIDTable            The table to return the language IDs
 674   @param  TableSize              The number of supported languanges
 675
 676   @retval EFI_SUCCESS            The language ID is return
 677
 678 **/
 679 STATIC
 680 EFI_STATUS
 681 EFIAPI
 682 UsbIoGetSupportedLanguages (
 683   IN  EFI_USB_IO_PROTOCOL *This,
 684   OUT UINT16              **LangIDTable,
 685   OUT UINT16              *TableSize
 686   )
 687 {
 688   USB_DEVICE              *Dev;
 689   USB_INTERFACE           *UsbIf;
 690   EFI_TPL                 OldTpl;
 691
 692   OldTpl        = gBS->RaiseTPL (USB_BUS_TPL);
 693
 694   UsbIf         = USB_INTERFACE_FROM_USBIO (This);
 695   Dev           = UsbIf->Device;
 696
 697   *LangIDTable  = Dev->LangId;
 698   *TableSize    = Dev->TotalLangId;
 699
 700   gBS->RestoreTPL (OldTpl);
 701   return EFI_SUCCESS;
 702 }
 703
 704
 705 /**
 706   Retrieve an indexed string in the language of LangID
 707
 708   @param  This                   The USB IO instance
 709   @param  LangID                 The language ID of the string to retrieve
 710   @param  StringIndex            The index of the string
 711   @param  String                 The variable to receive the string
 712
 713   @retval EFI_SUCCESS            The string is returned
 714   @retval EFI_NOT_FOUND          No such string existed
 715
 716 **/
 717 STATIC
 718 EFI_STATUS
 719 EFIAPI
 720 UsbIoGetStringDescriptor (
 721   IN  EFI_USB_IO_PROTOCOL   *This,
 722   IN  UINT16                LangID,
 723   IN  UINT8                 StringIndex,
 724   OUT CHAR16                **String
 725   )
 726 {
 727   USB_DEVICE                *Dev;
 728   USB_INTERFACE             *UsbIf;
 729   EFI_USB_STRING_DESCRIPTOR *StrDesc;
 730   EFI_TPL                   OldTpl;
 731   UINT8                     *Buf;
 732   UINT8                     Index;
 733   EFI_STATUS                Status;
 734
 735   if ((StringIndex == 0) || (LangID == 0)) {
 736     return EFI_NOT_FOUND;
 737   }
 738
 739   OldTpl = gBS->RaiseTPL (USB_BUS_TPL);
 740
 741   UsbIf  = USB_INTERFACE_FROM_USBIO (This);
 742   Dev    = UsbIf->Device;
 743
 744   //
 745   // Check whether language ID is supported
 746   //
 747   Status = EFI_NOT_FOUND;
 748
 749   for (Index = 0; Index < Dev->TotalLangId; Index++) {
 750     if (Dev->LangId[Index] == LangID) {
 751       break;
 752     }
 753   }
 754
 755   if (Index == Dev->TotalLangId) {
 756     goto ON_EXIT;
 757   }
 758
 759   //
 760   // Retrieve the string descriptor then allocate a buffer
 761   // to hold the string itself.
 762   //
 763   StrDesc = UsbGetOneString (Dev, StringIndex, LangID);
 764
 765   if (StrDesc == NULL) {
 766     goto ON_EXIT;
 767   }
 768
 769   if (StrDesc->Length <= 2) {
 770     goto FREE_STR;
 771   }
 772
 773   Buf = AllocateZeroPool (StrDesc->Length);
 774
 775   if (Buf == NULL) {
 776     Status = EFI_OUT_OF_RESOURCES;
 777     goto FREE_STR;
 778   }
 779
 780   CopyMem (Buf, StrDesc->String, StrDesc->Length - 2);
 781   *String = (CHAR16 *) Buf;
 782   Status  = EFI_SUCCESS;
 783
 784 FREE_STR:
 785   gBS->FreePool (StrDesc);
 786
 787 ON_EXIT:
 788   gBS->RestoreTPL (OldTpl);
 789   return Status;
 790 }
 791
 792
 793 /**
 794   Reset the device, then if that succeeds, reconfigure the
 795   device with its address and current active configuration.
 796
 797   @param  This                   The USB IO instance
 798
 799   @retval EFI_SUCCESS            The device is reset and configured
 800   @retval Others                 Failed to reset the device
 801
 802 **/
 803 EFI_STATUS
 804 EFIAPI
 805 UsbIoPortReset (
 806   IN EFI_USB_IO_PROTOCOL  *This
 807   )
 808 {
 809   USB_INTERFACE           *UsbIf;
 810   USB_INTERFACE           *HubIf;
 811   USB_DEVICE              *Dev;
 812   UINT8                   Address;
 813   EFI_TPL                 OldTpl;
 814   EFI_STATUS              Status;
 815
 816   OldTpl = gBS->RaiseTPL (USB_BUS_TPL);
 817
 818   UsbIf  = USB_INTERFACE_FROM_USBIO (This);
 819   Dev    = UsbIf->Device;
 820
 821   if (UsbIf->IsHub == TRUE) {
 822     Status = EFI_INVALID_PARAMETER;
 823     goto ON_EXIT;
 824   }
 825
 826   HubIf  = Dev->ParentIf;
 827   Status = HubIf->HubApi->ResetPort (HubIf, Dev->ParentPort);
 828
 829   if (EFI_ERROR (Status)) {
 830     USB_ERROR (("UsbIoPortReset: failed to reset hub port %d@hub  %d, %r \n",
 831                 Dev->ParentPort, Dev->ParentAddr, Status));
 832
 833     goto ON_EXIT;
 834   }
 835
 836   //
 837   // Reset the device to its current address. The device now has a
 838   // address of ZERO, so need to set Dev->Address to zero first for
 839   // host to communicate with the device
 840   //
 841   Address       = Dev->Address;
 842   Dev->Address  = 0;
 843   Status        = UsbSetAddress (Dev, Address);
 844
 845   if (EFI_ERROR (Status)) {
 846     USB_ERROR (("UsbIoPortReset: failed to set address for device %d - %r\n",
 847                 Address, Status));
 848
 849     goto ON_EXIT;
 850   }
 851
 852   Dev->Address  = Address;
 853
 854   //
 855   // Reset the current active configure, after this device
 856   // is in CONFIGURED state.
 857   //
 858   if (Dev->ActiveConfig != NULL) {
 859     Status = UsbSetConfig (Dev, Dev->ActiveConfig->Desc.ConfigurationValue);
 860
 861     if (EFI_ERROR (Status)) {
 862       USB_ERROR (("UsbIoPortReset: failed to set configure for device %d - %r\n",
 863                   Address, Status));
 864     }
 865   }
 866
 867 ON_EXIT:
 868   gBS->RestoreTPL (OldTpl);
 869   return Status;
 870 }
 871
 872 EFI_USB_IO_PROTOCOL mUsbIoProtocol = {
 873   UsbIoControlTransfer,
 874   UsbIoBulkTransfer,
 875   UsbIoAsyncInterruptTransfer,
 876   UsbIoSyncInterruptTransfer,
 877   UsbIoIsochronousTransfer,
 878   UsbIoAsyncIsochronousTransfer,
 879   UsbIoGetDeviceDescriptor,
 880   UsbIoGetActiveConfigDescriptor,
 881   UsbIoGetInterfaceDescriptor,
 882   UsbIoGetEndpointDescriptor,
 883   UsbIoGetStringDescriptor,
 884   UsbIoGetSupportedLanguages,
 885   UsbIoPortReset
 886 };
 887
 888
 889 EFI_STATUS
 890 EFIAPI
 891 UsbBusDriverEntryPoint (
 892   IN EFI_HANDLE           ImageHandle,
 893   IN EFI_SYSTEM_TABLE     *SystemTable
 894   )
 895 /*++
 896
 897 Routine Description:
 898
 899   The USB bus driver entry pointer
 900
 901 Arguments:
 902
 903   ImageHandle - The driver image handle
 904   SystemTable - The system table
 905
 906 Returns:
 907
 908   EFI_SUCCESS - The component name protocol is installed
 909   Others      - Failed to init the usb driver
 910
 911 --*/
 912 {
 913   return EfiLibInstallAllDriverProtocols (
 914            ImageHandle,
 915            SystemTable,
 916            &mUsbBusDriverBinding,
 917            ImageHandle,
 918            &mUsbBusComponentName,
 919            NULL,
 920            NULL
 921            );
 922 }
 923
 924
 925 /**
 926   Check whether USB bus driver support this device
 927
 928   @param  This                   The USB bus driver binding protocol
 929   @param  Controller             The controller handle to test againist
 930   @param  RemainingDevicePath    The remaining device path
 931
 932   @retval EFI_SUCCESS            The bus supports this controller.
 933   @retval EFI_UNSUPPORTED        This device isn't supported
 934
 935 **/
 936 EFI_STATUS
 937 EFIAPI
 938 UsbBusControllerDriverSupported (
 939   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 940   IN EFI_HANDLE                   Controller,
 941   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 942   )
 943 {
 944   EFI_DEV_PATH_PTR          DevicePathNode;
 945   EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
 946   EFI_USB2_HC_PROTOCOL      *Usb2Hc;
 947   EFI_USB_HC_PROTOCOL       *UsbHc;
 948   EFI_STATUS                Status;
 949
 950   //
 951   // Check whether device path is valid
 952   //
 953   if (RemainingDevicePath != NULL) {
 954     DevicePathNode.DevPath = RemainingDevicePath;
 955
 956     if ((DevicePathNode.DevPath->Type    != MESSAGING_DEVICE_PATH) ||
 957         (DevicePathNode.DevPath->SubType != MSG_USB_DP) ||
 958         (DevicePathNodeLength (DevicePathNode.DevPath) != sizeof (USB_DEVICE_PATH))) {
 959
 960       return EFI_UNSUPPORTED;
 961     }
 962   }
 963
 964   Status = gBS->OpenProtocol (
 965                   Controller,
 966                   &gEfiDevicePathProtocolGuid,
 967                   (VOID **) &ParentDevicePath,
 968                   This->DriverBindingHandle,
 969                   Controller,
 970                   EFI_OPEN_PROTOCOL_BY_DRIVER
 971                   );
 972
 973   if (Status == EFI_ALREADY_STARTED) {
 974     return EFI_SUCCESS;
 975   }
 976
 977   if (EFI_ERROR (Status)) {
 978     return Status;
 979   }
 980
 981   gBS->CloseProtocol (
 982          Controller,
 983          &gEfiDevicePathProtocolGuid,
 984          This->DriverBindingHandle,
 985          Controller
 986          );
 987
 988   //
 989   // Check whether USB_HC2 protocol is installed
 990   //
 991   Status = gBS->OpenProtocol (
 992                   Controller,
 993                   &gEfiUsb2HcProtocolGuid,
 994                   (VOID **) &Usb2Hc,
 995                   This->DriverBindingHandle,
 996                   Controller,
 997                   EFI_OPEN_PROTOCOL_BY_DRIVER
 998                   );
 999
1000   if (Status == EFI_ALREADY_STARTED) {
1001     return EFI_SUCCESS;
1002   }
1003
1004   if (!EFI_ERROR (Status)) {
1005     gBS->CloseProtocol (
1006           Controller,
1007           &gEfiUsb2HcProtocolGuid,
1008           This->DriverBindingHandle,
1009           Controller
1010           );
1011
1012     return EFI_SUCCESS;
1013   }
1014
1015   //
1016   // If failed to open USB_HC2, fall back to USB_HC
1017   //
1018   Status = gBS->OpenProtocol (
1019                   Controller,
1020                   &gEfiUsbHcProtocolGuid,
1021                   (VOID **) &UsbHc,
1022                   This->DriverBindingHandle,
1023                   Controller,
1024                   EFI_OPEN_PROTOCOL_BY_DRIVER
1025                   );
1026
1027   if (Status == EFI_ALREADY_STARTED) {
1028     return EFI_SUCCESS;
1029   }
1030
1031   if (!EFI_ERROR (Status)) {
1032     gBS->CloseProtocol (
1033           Controller,
1034           &gEfiUsbHcProtocolGuid,
1035           This->DriverBindingHandle,
1036           Controller
1037           );
1038   }
1039
1040   return Status;
1041 }
1042
1043
1044 /**
1045   Start to process the controller
1046
1047   @param  This                   The USB bus driver binding instance
1048   @param  Controller             The controller to check
1049   @param  RemainingDevicePath    The remaining device patch
1050
1051   @retval EFI_SUCCESS            The controller is controlled by the usb bus
1052   @retval EFI_ALREADY_STARTED    The controller is already controlled by the usb
1053                                  bus
1054   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources
1055
1056 **/
1057 EFI_STATUS
1058 EFIAPI
1059 UsbBusControllerDriverStart (
1060   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1061   IN EFI_HANDLE                   Controller,
1062   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
1063   )
1064 {
1065   USB_BUS                 *UsbBus;
1066   USB_DEVICE              *RootHub;
1067   USB_INTERFACE           *RootIf;
1068   EFI_USB_BUS_PROTOCOL    *UsbBusId;
1069   EFI_STATUS              Status;
1070   EFI_STATUS              Status2;
1071
1072   //
1073   // Locate the USB bus protocol, if it is found, USB bus
1074   // is already started on this controller.
1075   //
1076   Status = gBS->OpenProtocol (
1077                   Controller,
1078                   &mUsbBusProtocolGuid,
1079                   (VOID **) &UsbBusId,
1080                   This->DriverBindingHandle,
1081                   Controller,
1082                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1083                   );
1084
1085   if (!EFI_ERROR (Status)) {
1086     return EFI_ALREADY_STARTED;
1087   }
1088
1089   UsbBus = AllocateZeroPool (sizeof (USB_BUS));
1090
1091   if (UsbBus == NULL) {
1092     return EFI_OUT_OF_RESOURCES;
1093   }
1094
1095   UsbBus->Signature   = USB_BUS_SIGNATURE;
1096   UsbBus->HostHandle  = Controller;
1097
1098   Status = gBS->OpenProtocol (
1099                   Controller,
1100                   &gEfiDevicePathProtocolGuid,
1101                   (VOID **) &UsbBus->DevicePath,
1102                   This->DriverBindingHandle,
1103                   Controller,
1104                   EFI_OPEN_PROTOCOL_BY_DRIVER
1105                   );
1106
1107   if (EFI_ERROR (Status)) {
1108     USB_ERROR (("UsbBusStart: Failed to open device path %r\n", Status));
1109
1110     gBS->FreePool (UsbBus);
1111     return Status;
1112   }
1113
1114   //
1115   // Get USB_HC2/USB_HC host controller protocol (EHCI/UHCI).
1116   // This is for backward compatbility with EFI 1.x. In UEFI
1117   // 2.x, USB_HC2 replaces USB_HC. We will open both USB_HC2
1118   // and USB_HC because EHCI driver will install both protocols
1119   // (for the same reason). If we don't consume both of them,
1120   // the unconsumed one may be opened by others.
1121   //
1122   Status = gBS->OpenProtocol (
1123                   Controller,
1124                   &gEfiUsb2HcProtocolGuid,
1125                   (VOID **) &(UsbBus->Usb2Hc),
1126                   This->DriverBindingHandle,
1127                   Controller,
1128                   EFI_OPEN_PROTOCOL_BY_DRIVER
1129                   );
1130
1131   Status2 = gBS->OpenProtocol (
1132                    Controller,
1133                    &gEfiUsbHcProtocolGuid,
1134                    (VOID **) &(UsbBus->UsbHc),
1135                    This->DriverBindingHandle,
1136                    Controller,
1137                    EFI_OPEN_PROTOCOL_BY_DRIVER
1138                    );
1139
1140   if (EFI_ERROR (Status) && EFI_ERROR (Status2)) {
1141     USB_ERROR (("UsbBusStart: Failed to open USB_HC/USB2_HC %r\n", Status));
1142
1143     Status = EFI_DEVICE_ERROR;
1144     goto CLOSE_HC;
1145   }
1146
1147   //
1148   // Create a fake usb device for root hub
1149   //
1150   RootHub = AllocateZeroPool (sizeof (USB_DEVICE));
1151
1152   if (RootHub == NULL) {
1153     Status = EFI_OUT_OF_RESOURCES;
1154     goto CLOSE_HC;
1155   }
1156
1157   RootIf = AllocateZeroPool (sizeof (USB_INTERFACE));
1158
1159   if (RootIf == NULL) {
1160     gBS->FreePool (RootHub);
1161     Status = EFI_OUT_OF_RESOURCES;
1162     goto CLOSE_HC;
1163   }
1164
1165   RootHub->Bus            = UsbBus;
1166   RootHub->NumOfInterface = 1;
1167   RootHub->Interfaces[0]  = RootIf;
1168   RootIf->Signature       = USB_INTERFACE_SIGNATURE;
1169   RootIf->Device          = RootHub;
1170   RootIf->DevicePath      = UsbBus->DevicePath;
1171
1172   Status                  = mUsbRootHubApi.Init (RootIf);
1173
1174   if (EFI_ERROR (Status)) {
1175     USB_ERROR (("UsbBusStart: Failed to init root hub %r\n", Status));
1176     goto FREE_ROOTHUB;
1177   }
1178
1179   UsbBus->Devices[0] = RootHub;
1180
1181   //
1182   // Install an EFI_USB_BUS_PROTOCOL to host controler to identify it.
1183   //
1184   Status = gBS->InstallProtocolInterface (
1185                   &Controller,
1186                   &mUsbBusProtocolGuid,
1187                   EFI_NATIVE_INTERFACE,
1188                   &UsbBus->BusId
1189                   );
1190
1191   if (EFI_ERROR (Status)) {
1192     USB_ERROR (("UsbBusStart: Failed to install bus protocol %r\n", Status));
1193
1194     mUsbRootHubApi.Release (RootIf);
1195     goto FREE_ROOTHUB;
1196   }
1197
1198   UsbHcReset (UsbBus, EFI_USB_HC_RESET_GLOBAL);
1199   UsbHcSetState (UsbBus, EfiUsbHcStateOperational);
1200
1201   USB_DEBUG (("UsbBusStart: usb bus started on %x, root hub %x\n", Controller, RootIf));
1202   return EFI_SUCCESS;
1203
1204 FREE_ROOTHUB:
1205   gBS->FreePool (RootIf);
1206   gBS->FreePool (RootHub);
1207
1208 CLOSE_HC:
1209   if (UsbBus->Usb2Hc != NULL) {
1210     gBS->CloseProtocol (
1211           Controller,
1212           &gEfiUsb2HcProtocolGuid,
1213           This->DriverBindingHandle,
1214           Controller
1215           );
1216   }
1217
1218   if (UsbBus->UsbHc != NULL) {
1219     gBS->CloseProtocol (
1220           Controller,
1221           &gEfiUsbHcProtocolGuid,
1222           This->DriverBindingHandle,
1223           Controller
1224           );
1225   }
1226
1227   gBS->CloseProtocol (
1228          Controller,
1229          &gEfiDevicePathProtocolGuid,
1230          This->DriverBindingHandle,
1231          Controller
1232          );
1233
1234   gBS->FreePool (UsbBus);
1235
1236   USB_ERROR (("UsbBusStart: Failed to start bus driver %r\n", Status));
1237   return Status;
1238 }
1239
1240
1241 /**
1242   Stop handle the controller by this USB bus driver
1243
1244   @param  This                   The USB bus driver binding protocol
1245   @param  Controller             The controller to release
1246   @param  NumberOfChildren       The child of USB bus that opened controller
1247                                  BY_CHILD
1248   @param  ChildHandleBuffer      The array of child handle
1249
1250   @retval EFI_SUCCESS            The controller or children are stopped
1251   @retval EFI_DEVICE_ERROR       Failed to stop the driver
1252
1253 **/
1254 EFI_STATUS
1255 EFIAPI
1256 UsbBusControllerDriverStop (
1257   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1258   IN EFI_HANDLE                   Controller,
1259   IN UINTN                        NumberOfChildren,
1260   IN EFI_HANDLE                   *ChildHandleBuffer
1261   )
1262 {
1263   USB_BUS               *Bus;
1264   USB_DEVICE            *RootHub;
1265   USB_DEVICE            *UsbDev;
1266   USB_INTERFACE         *RootIf;
1267   USB_INTERFACE         *UsbIf;
1268   EFI_USB_BUS_PROTOCOL  *BusId;
1269   EFI_USB_IO_PROTOCOL   *UsbIo;
1270   EFI_TPL               OldTpl;
1271   UINTN                 Index;
1272   EFI_STATUS            Status;
1273
1274   Status  = EFI_SUCCESS;
1275
1276   if (NumberOfChildren > 0) {
1277     OldTpl   = gBS->RaiseTPL (USB_BUS_TPL);
1278
1279     for (Index = 0; Index < NumberOfChildren; Index++) {
1280       Status = gBS->OpenProtocol (
1281                       ChildHandleBuffer[Index],
1282                       &gEfiUsbIoProtocolGuid,
1283                       (VOID **) &UsbIo,
1284                       This->DriverBindingHandle,
1285                       Controller,
1286                       EFI_OPEN_PROTOCOL_GET_PROTOCOL
1287                       );
1288
1289       if (EFI_ERROR (Status)) {
1290         //
1291         // It is possible that the child has already been released:
1292         // 1. For combo device, free one device will release others.
1293         // 2. If a hub is released, all devices on its down facing
1294         //    ports are released also.
1295         //
1296         continue;
1297       }
1298
1299       UsbIf   = USB_INTERFACE_FROM_USBIO (UsbIo);
1300       UsbDev  = UsbIf->Device;
1301
1302       UsbRemoveDevice (UsbDev);
1303     }
1304
1305     gBS->RestoreTPL (OldTpl);
1306     return EFI_SUCCESS;
1307   }
1308
1309   USB_DEBUG (("UsbBusStop: usb bus stopped on %x\n", Controller));
1310
1311   //
1312   // Locate USB_BUS for the current host controller
1313   //
1314   Status = gBS->OpenProtocol (
1315                   Controller,
1316                   &mUsbBusProtocolGuid,
1317                   (VOID **) &BusId,
1318                   This->DriverBindingHandle,
1319                   Controller,
1320                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1321                   );
1322
1323   if (EFI_ERROR (Status)) {
1324     return Status;
1325   }
1326
1327   Bus = USB_BUS_FROM_THIS (BusId);
1328
1329   //
1330   // Stop the root hub, then free all the devices
1331   //
1332   OldTpl  = gBS->RaiseTPL (USB_BUS_TPL);
1333   UsbHcSetState (Bus, EfiUsbHcStateHalt);
1334
1335   RootHub = Bus->Devices[0];
1336   RootIf  = RootHub->Interfaces[0];
1337
1338   mUsbRootHubApi.Release (RootIf);
1339
1340   for (Index = 1; Index < USB_MAX_DEVICES; Index++) {
1341     if (Bus->Devices[Index] != NULL) {
1342       UsbRemoveDevice (Bus->Devices[Index]);
1343     }
1344   }
1345
1346   gBS->RestoreTPL (OldTpl);
1347
1348   gBS->FreePool   (RootIf);
1349   gBS->FreePool   (RootHub);
1350
1351   //
1352   // Uninstall the bus identifier and close USB_HC/USB2_HC protocols
1353   //
1354   gBS->UninstallProtocolInterface (Controller, &mUsbBusProtocolGuid, &Bus->BusId);
1355
1356   if (Bus->Usb2Hc != NULL) {
1357     gBS->CloseProtocol (
1358            Controller,
1359            &gEfiUsb2HcProtocolGuid,
1360            This->DriverBindingHandle,
1361            Controller
1362            );
1363   }
1364
1365   if (Bus->UsbHc != NULL) {
1366     gBS->CloseProtocol (
1367            Controller,
1368            &gEfiUsbHcProtocolGuid,
1369            This->DriverBindingHandle,
1370            Controller
1371            );
1372   }
1373
1374   gBS->CloseProtocol (
1375          Controller,
1376          &gEfiDevicePathProtocolGuid,
1377          This->DriverBindingHandle,
1378          Controller
1379          );
1380
1381   gBS->FreePool (Bus);
1382
1383   return Status;
1384 }
1385
1386 EFI_DRIVER_BINDING_PROTOCOL mUsbBusDriverBinding = {
1387   UsbBusControllerDriverSupported,
1388   UsbBusControllerDriverStart,
1389   UsbBusControllerDriverStop,
1390   0xa,
1391   NULL,
1392   NULL
1393 };