Enhance the Usb bus driver to support Star with Remaining device path.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@4437 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 637 insertions, 0 deletions

diff --git a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbUtility.c b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbUtility.c
index d4184fe1a2..37e6c05a2f 100644
--- a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbUtility.c
+++ b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbUtility.c
@@ -25,6 +25,34 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 

 #include "UsbBus.h"

 

+//

+// if RemainingDevicePath== NULL, then all Usb child devices in this bus are wanted.

+// Use a shor form Usb class Device Path, which could match any usb device, in WantedUsbIoDPList to indicate all Usb devices

+// are wanted Usb devices

+//

+STATIC USB_CLASS_FORMAT_DEVICE_PATH mAllUsbClassDevicePath = {

+  {

+    {

+      MESSAGING_DEVICE_PATH,

+      MSG_USB_CLASS_DP,

+      (UINT8) (sizeof (USB_CLASS_DEVICE_PATH)),

+      (UINT8) ((sizeof (USB_CLASS_DEVICE_PATH)) >> 8)

+    },

+    0xffff, // VendorId

+    0xffff, // ProductId

+    0xff,   // DeviceClass

+    0xff,   // DeviceSubClass

+    0xff    // DeviceProtocol

+  },

+

+  {

+    END_DEVICE_PATH_TYPE,

+    END_ENTIRE_DEVICE_PATH_SUBTYPE,

+    END_DEVICE_PATH_LENGTH,

+    0

+  }

+};

+

 

 /**

   Get the capability of the host controller

@@ -711,3 +739,612 @@ UsbGetCurrentTpl (
   return Tpl;

 }

 

+/**

+  Create a new device path which only contain the first Usb part of the DevicePath

+

+  @param DevicePath  A full device path which contain the usb nodes

+

+  @return            A new device path which only contain the Usb part of the DevicePath

+

+**/

+EFI_DEVICE_PATH_PROTOCOL *

+EFIAPI

+GetUsbDPFromFullDP (

+  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath

+  )

+{

+  EFI_DEVICE_PATH_PROTOCOL    *UsbDevicePathPtr;

+  EFI_DEVICE_PATH_PROTOCOL    *UsbDevicePathBeginPtr;

+  EFI_DEVICE_PATH_PROTOCOL    *UsbDevicePathEndPtr;

+  UINTN                       Size;

+

+  //

+  // Get the Usb part first Begin node in full device path

+  //

+  UsbDevicePathBeginPtr = DevicePath;

+  while ( (!EfiIsDevicePathEnd (UsbDevicePathBeginPtr))&&

+         ((UsbDevicePathBeginPtr->Type != MESSAGING_DEVICE_PATH) ||

+         (UsbDevicePathBeginPtr->SubType != MSG_USB_DP &&

+          UsbDevicePathBeginPtr->SubType != MSG_USB_CLASS_DP

+          && UsbDevicePathBeginPtr->SubType != MSG_USB_WWID_DP

+          ))) {

+

+    UsbDevicePathBeginPtr = NextDevicePathNode(UsbDevicePathBeginPtr);

+  }

+

+  //

+  // Get the Usb part first End node in full device path

+  //

+  UsbDevicePathEndPtr = UsbDevicePathBeginPtr;

+  while ((!EfiIsDevicePathEnd (UsbDevicePathEndPtr))&&

+         (UsbDevicePathEndPtr->Type == MESSAGING_DEVICE_PATH) &&

+         (UsbDevicePathEndPtr->SubType == MSG_USB_DP ||

+          UsbDevicePathEndPtr->SubType == MSG_USB_CLASS_DP

+          || UsbDevicePathEndPtr->SubType == MSG_USB_WWID_DP

+          )) {

+

+    UsbDevicePathEndPtr = NextDevicePathNode(UsbDevicePathEndPtr);

+  }

+

+  Size  = GetDevicePathSize (UsbDevicePathBeginPtr);

+  Size -= GetDevicePathSize (UsbDevicePathEndPtr);

+  if (Size ==0){

+    //

+    // The passed in DevicePath does not contain the usb nodes

+    //

+    return NULL;

+  }

+

+  //

+  // Create a new device path which only contain the above Usb part

+  //

+  UsbDevicePathPtr = AllocateZeroPool (Size + sizeof (EFI_DEVICE_PATH_PROTOCOL));

+  ASSERT (UsbDevicePathPtr != NULL);

+  CopyMem (UsbDevicePathPtr, UsbDevicePathBeginPtr, Size);

+  //

+  // Append end device path node

+  //

+  UsbDevicePathEndPtr = (EFI_DEVICE_PATH_PROTOCOL *) ((UINTN) UsbDevicePathPtr + Size);

+  SetDevicePathEndNode (UsbDevicePathEndPtr);

+  return UsbDevicePathPtr;

+}

+

+/**

+  Check whether a usb device path is in a DEVICE_PATH_LIST_ITEM list.

+

+  @param UsbDP       a usb device path of DEVICE_PATH_LIST_ITEM

+  @parem UsbIoDPList a DEVICE_PATH_LIST_ITEM list

+

+  @retval TRUE       there is a DEVICE_PATH_LIST_ITEM in UsbIoDPList which contains the passed in UsbDP

+  @retval FALSE      there is no DEVICE_PATH_LIST_ITEM in UsbIoDPList which contains the passed in UsbDP

+

+**/

+BOOLEAN

+EFIAPI

+SearchUsbDPInList (

+  IN EFI_DEVICE_PATH_PROTOCOL     *UsbDP,

+  IN LIST_ENTRY                   *UsbIoDPList

+  )

+{

+  LIST_ENTRY                  *ListIndex;

+  DEVICE_PATH_LIST_ITEM       *ListItem;

+  BOOLEAN                     Found;

+  UINTN                       UsbDpDevicePathSize;

+

+  //

+  // Check that UsbDP and UsbIoDPList are valid

+  //

+  if ((UsbIoDPList == NULL) || (UsbDP == NULL)) {

+    return FALSE;

+  }

+

+  Found = FALSE;

+  ListIndex = UsbIoDPList->ForwardLink;

+  while (ListIndex != UsbIoDPList){

+    ListItem = CR(ListIndex, DEVICE_PATH_LIST_ITEM, Link, DEVICE_PATH_LIST_ITEM_SIGNATURE);

+    //

+    // Compare DEVICE_PATH_LIST_ITEM.DevicePath[]

+    //

+    ASSERT (ListItem->DevicePath != NULL);

+

+    UsbDpDevicePathSize  = GetDevicePathSize (UsbDP);

+    if (UsbDpDevicePathSize == GetDevicePathSize (ListItem->DevicePath)) {

+      if ((CompareMem (UsbDP, ListItem->DevicePath, UsbDpDevicePathSize)) == 0) {

+        Found = TRUE;

+        break;

+      }

+    }

+    ListIndex =  ListIndex->ForwardLink;

+  }

+

+  return Found;

+}

+

+/**

+  Add a usb device path into the DEVICE_PATH_LIST_ITEM list.

+

+  @param UsbDP        a usb device path of DEVICE_PATH_LIST_ITEM

+  @param UsbIoDPList  a DEVICE_PATH_LIST_ITEM list

+

+  @retval EFI_INVALID_PARAMETER

+  @retval EFI_SUCCESS

+

+**/

+EFI_STATUS

+EFIAPI

+AddUsbDPToList (

+  IN EFI_DEVICE_PATH_PROTOCOL     *UsbDP,

+  IN LIST_ENTRY                   *UsbIoDPList

+  )

+{

+  DEVICE_PATH_LIST_ITEM       *ListItem;

+

+  //

+  // Check that UsbDP and UsbIoDPList are valid

+  //

+  if ((UsbIoDPList == NULL) || (UsbDP == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (SearchUsbDPInList (UsbDP, UsbIoDPList)){

+    return EFI_SUCCESS;

+  }

+

+  //

+  // Prepare the usbio device path DEVICE_PATH_LIST_ITEM structure.

+  //

+  ListItem = AllocateZeroPool (sizeof (DEVICE_PATH_LIST_ITEM));

+  ASSERT (ListItem != NULL);

+  ListItem->Signature = DEVICE_PATH_LIST_ITEM_SIGNATURE;

+  ListItem->DevicePath = DuplicateDevicePath (UsbDP);

+

+  InsertTailList (UsbIoDPList, &ListItem->Link);

+

+  return EFI_SUCCESS;

+}

+

+/**

+  Check whether usb device, whose interface is UsbIf, matches the usb class which indicated by

+  UsbClassDevicePathPtr whose is a short form usb class device path

+

+  @param UsbClassDevicePathPtr    a short form usb class device path

+  @param UsbIf                    a usb device interface

+

+  @retval TRUE                    the usb device match the usb class

+  @retval FALSE                   the usb device does not match the usb class

+

+**/

+BOOLEAN

+EFIAPI

+MatchUsbClass (

+  IN USB_CLASS_DEVICE_PATH      *UsbClassDevicePathPtr,

+  IN USB_INTERFACE              *UsbIf

+  )

+{

+  USB_INTERFACE_DESC            *IfDesc;

+  EFI_USB_INTERFACE_DESCRIPTOR  *ActIfDesc;

+  EFI_USB_DEVICE_DESCRIPTOR     *DevDesc;

+

+

+  if ((UsbClassDevicePathPtr->Header.Type != MESSAGING_DEVICE_PATH) ||

+      (UsbClassDevicePathPtr->Header.SubType != MSG_USB_CLASS_DP)){

+    ASSERT (0);

+    return FALSE;

+  }

+

+  IfDesc       = UsbIf->IfDesc;

+  ActIfDesc    = &(IfDesc->Settings[IfDesc->ActiveIndex]->Desc);

+  DevDesc      = &(UsbIf->Device->DevDesc->Desc);

+

+  //

+  // If connect class policy, determine whether to create device handle by the five fields

+  // in class device path node.

+  //

+  // In addtion, hub interface is always matched for this policy.

+  //

+  if ((ActIfDesc->InterfaceClass == USB_HUB_CLASS_CODE) &&

+      (ActIfDesc->InterfaceSubClass == USB_HUB_SUBCLASS_CODE)) {

+    return TRUE;

+  }

+

+  //

+  // If vendor id or product id is 0xffff, they will be ignored.

+  //

+  if ((UsbClassDevicePathPtr->VendorId == 0xffff || UsbClassDevicePathPtr->VendorId == DevDesc->IdVendor) &&

+      (UsbClassDevicePathPtr->ProductId == 0xffff || UsbClassDevicePathPtr->ProductId == DevDesc->IdProduct)) {

+

+    //

+    // If class or subclass or protocol is 0, the counterparts in interface should be checked.

+    //

+    if (DevDesc->DeviceClass == 0 &&

+        DevDesc->DeviceSubClass == 0 &&

+        DevDesc->DeviceProtocol == 0) {

+

+      if ((UsbClassDevicePathPtr->DeviceClass == ActIfDesc->InterfaceClass ||

+                                          UsbClassDevicePathPtr->DeviceClass == 0xff) &&

+          (UsbClassDevicePathPtr->DeviceSubClass == ActIfDesc->InterfaceSubClass ||

+                                       UsbClassDevicePathPtr->DeviceSubClass == 0xff) &&

+          (UsbClassDevicePathPtr->DeviceProtocol == ActIfDesc->InterfaceProtocol) ||

+                                       UsbClassDevicePathPtr->DeviceProtocol == 0xff) {

+        return TRUE;

+      }

+

+    } else if ((UsbClassDevicePathPtr->DeviceClass != DevDesc->DeviceClass ||

+                                         UsbClassDevicePathPtr->DeviceClass == 0xff) &&

+               (UsbClassDevicePathPtr->DeviceSubClass == DevDesc->DeviceSubClass ||

+                                      UsbClassDevicePathPtr->DeviceSubClass == 0xff) &&

+               (UsbClassDevicePathPtr->DeviceProtocol == DevDesc->DeviceProtocol) ||

+                                      UsbClassDevicePathPtr->DeviceProtocol == 0xff) {

+

+      return TRUE;

+    }

+  }

+

+  return FALSE;

+}

+

+/**

+  Check whether usb device, whose interface is UsbIf, matches the usb WWID requirement which indicated by

+  UsbWWIDDevicePathPtr whose is a short form usb WWID device path

+

+  @param UsbClassDevicePathPtr   a short form usb WWID device path

+  @param UsbIf                   a usb device interface

+

+  @retval TRUE                   the usb device match the usb WWID requirement

+  @retval FALSE                  the usb device does not match the usb WWID requirement

+

+**/

+STATIC

+BOOLEAN

+MatchUsbWwid (

+  IN USB_WWID_DEVICE_PATH       *UsbWWIDDevicePathPtr,

+  IN USB_INTERFACE              *UsbIf

+  )

+{

+  USB_INTERFACE_DESC            *IfDesc;

+  EFI_USB_INTERFACE_DESCRIPTOR  *ActIfDesc;

+  EFI_USB_DEVICE_DESCRIPTOR     *DevDesc;

+  EFI_USB_STRING_DESCRIPTOR     *StrDesc;

+  UINT16                        *SnString;

+

+  if ((UsbWWIDDevicePathPtr->Header.Type != MESSAGING_DEVICE_PATH) ||

+     (UsbWWIDDevicePathPtr->Header.SubType != MSG_USB_WWID_DP )){

+    ASSERT (0);

+    return FALSE;

+  }

+

+  IfDesc       = UsbIf->IfDesc;

+  ActIfDesc    = &(IfDesc->Settings[IfDesc->ActiveIndex]->Desc);

+  DevDesc      = &(UsbIf->Device->DevDesc->Desc);

+  StrDesc      = UsbGetOneString (UsbIf->Device, DevDesc->StrSerialNumber, USB_US_LAND_ID);

+  SnString     = (UINT16 *) ((UINT8 *)UsbWWIDDevicePathPtr + 10);

+

+  //

+  //In addtion, hub interface is always matched for this policy.

+  //

+  if ((ActIfDesc->InterfaceClass == USB_HUB_CLASS_CODE) &&

+      (ActIfDesc->InterfaceSubClass == USB_HUB_SUBCLASS_CODE)) {

+    return TRUE;

+  }

+  //

+  // If connect wwid policy, determine the objective device by the serial number of

+  // device descriptor.

+  // Get serial number index from device descriptor, then get serial number by index

+  // and land id, compare the serial number with wwid device path node at last

+  //

+  // BugBug: only check serial number here, should check Interface Number, Device Vendor Id, Device Product Id  in later version

+  //

+  if (StrDesc != NULL && !StrnCmp (StrDesc->String, SnString, StrDesc->Length)) {

+

+    return TRUE;

+  }

+

+  return FALSE;

+}

+

+/**

+  Free a DEVICE_PATH_LIST_ITEM list

+

+  @param UsbIoDPList  a DEVICE_PATH_LIST_ITEM list pointer

+

+  @retval EFI_INVALID_PARAMETER

+  @retval EFI_SUCCESS

+

+**/

+EFI_STATUS

+EFIAPI

+UsbBusFreeUsbDPList (

+  IN LIST_ENTRY          *UsbIoDPList

+  )

+{

+  LIST_ENTRY                  *ListIndex;

+  DEVICE_PATH_LIST_ITEM       *ListItem;

+

+  //

+  // Check that ControllerHandle is a valid handle

+  //

+  if (UsbIoDPList == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  ListIndex = UsbIoDPList->ForwardLink;

+  while (ListIndex != UsbIoDPList){

+    ListItem = CR(ListIndex, DEVICE_PATH_LIST_ITEM, Link, DEVICE_PATH_LIST_ITEM_SIGNATURE);

+    //

+    // Free DEVICE_PATH_LIST_ITEM.DevicePath[]

+    //

+    if (ListItem->DevicePath != NULL){

+      FreePool(ListItem->DevicePath);

+    }

+    //

+    // Free DEVICE_PATH_LIST_ITEM itself

+    //

+    ListIndex =  ListIndex->ForwardLink;

+    RemoveEntryList (&ListItem->Link);

+    FreePool (ListItem);

+  }

+

+  InitializeListHead (UsbIoDPList);

+  return EFI_SUCCESS;

+}

+

+/**

+  Store a wanted usb child device info (its Usb part of device path) which is indicated by

+  RemainingDevicePath in a Usb bus which  is indicated by UsbBusId

+

+  @param UsbBusId              Point to EFI_USB_BUS_PROTOCOL interface

+  @param RemainingDevicePath   The remaining device patch

+

+  @retval EFI_SUCCESS

+  @retval EFI_INVALID_PARAMETER

+  @retval EFI_OUT_OF_RESOURCES

+

+**/

+EFI_STATUS

+EFIAPI

+UsbBusAddWantedUsbIoDP (

+  IN EFI_USB_BUS_PROTOCOL         *UsbBusId,

+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath

+  )

+{

+  USB_BUS                       *Bus;

+  EFI_STATUS                    Status;

+  EFI_DEVICE_PATH_PROTOCOL      *DevicePathPtr;

+

+  //

+  // Check whether remaining device path is valid

+  //

+  if (RemainingDevicePath != NULL) {

+    if ((RemainingDevicePath->Type    != MESSAGING_DEVICE_PATH) ||

+        (RemainingDevicePath->SubType != MSG_USB_DP &&

+         RemainingDevicePath->SubType != MSG_USB_CLASS_DP

+         && RemainingDevicePath->SubType != MSG_USB_WWID_DP

+         )) {

+      return EFI_INVALID_PARAMETER;

+    }

+  }

+

+  if (UsbBusId == NULL){

+    return EFI_INVALID_PARAMETER;

+  }

+

+  Bus = USB_BUS_FROM_THIS (UsbBusId);

+

+  if (RemainingDevicePath == NULL) {

+    //

+    // RemainingDevicePath== NULL means all Usb devices in this bus are wanted.

+    // Here use a Usb class Device Path in WantedUsbIoDPList to indicate all Usb devices

+    // are wanted Usb devices

+    //

+    Status = UsbBusFreeUsbDPList (&Bus->WantedUsbIoDPList);

+    ASSERT (!EFI_ERROR (Status));

+    DevicePathPtr = DuplicateDevicePath ((EFI_DEVICE_PATH_PROTOCOL *) &mAllUsbClassDevicePath);

+  } else {

+    //

+    // Create new Usb device path according to the usb part in remaining device path

+    //

+    DevicePathPtr = GetUsbDPFromFullDP (RemainingDevicePath);

+  }

+

+  ASSERT (DevicePathPtr != NULL);

+  Status = AddUsbDPToList (DevicePathPtr, &Bus->WantedUsbIoDPList);

+  ASSERT (!EFI_ERROR (Status));

+  gBS->FreePool (DevicePathPtr);

+  return EFI_SUCCESS;

+}

+

+/**

+  Check whether a usb child  device is the wanted device in a bus

+

+  @param Bus      The Usb bus's private data pointer

+  @param UsbIf    The usb child  device inferface

+

+  @retval EFI_SUCCESS

+  @retval EFI_INVALID_PARAMETER

+  @retval EFI_OUT_OF_RESOURCES

+

+**/

+BOOLEAN

+EFIAPI

+UsbBusIsWantedUsbIO (

+  IN USB_BUS                 *Bus,

+  IN USB_INTERFACE           *UsbIf

+  )

+{

+  EFI_DEVICE_PATH_PROTOCOL      *DevicePathPtr;

+  LIST_ENTRY                    *WantedUsbIoDPListPtr;

+  LIST_ENTRY                    *WantedListIndex;

+  DEVICE_PATH_LIST_ITEM         *WantedListItem;

+  BOOLEAN                       DoConvert;

+  UINTN                         FirstDevicePathSize;

+

+  //

+  // Check whether passed in parameters are valid

+  //

+  if ((UsbIf == NULL) || (Bus == NULL)) {

+    return FALSE;

+  }

+  //

+  // Check whether UsbIf is Hub

+  //

+  if (UsbIf->IsHub) {

+    return TRUE;

+  }

+

+  //

+  // Check whether all Usb devices in this bus are wanted

+  //

+  if (SearchUsbDPInList ((EFI_DEVICE_PATH_PROTOCOL *)&mAllUsbClassDevicePath, &Bus->WantedUsbIoDPList)){

+    return TRUE;

+  }

+

+  //

+  // Check whether the Usb device match any item in WantedUsbIoDPList

+  //

+  WantedUsbIoDPListPtr = &Bus->WantedUsbIoDPList;

+  //

+  // Create new Usb device path according to the usb part in UsbIo full device path

+  //

+  DevicePathPtr = GetUsbDPFromFullDP (UsbIf->DevicePath);

+  ASSERT (DevicePathPtr != NULL);

+

+  DoConvert = FALSE;

+  WantedListIndex = WantedUsbIoDPListPtr->ForwardLink;

+  while (WantedListIndex != WantedUsbIoDPListPtr){

+    WantedListItem = CR(WantedListIndex, DEVICE_PATH_LIST_ITEM, Link, DEVICE_PATH_LIST_ITEM_SIGNATURE);

+    ASSERT (WantedListItem->DevicePath->Type == MESSAGING_DEVICE_PATH);

+    switch (WantedListItem->DevicePath->SubType) {

+    case MSG_USB_DP:

+      FirstDevicePathSize = GetDevicePathSize (WantedListItem->DevicePath);

+      if (FirstDevicePathSize == GetDevicePathSize (DevicePathPtr)) {

+        if (CompareMem (

+              WantedListItem->DevicePath,

+              DevicePathPtr,

+              GetDevicePathSize (DevicePathPtr)) == 0

+            ) {

+          DoConvert = TRUE;

+        }

+      }

+      break;

+    case MSG_USB_CLASS_DP:

+      if (MatchUsbClass((USB_CLASS_DEVICE_PATH *)WantedListItem->DevicePath, UsbIf)) {

+        DoConvert = TRUE;

+      }

+      break;

+   case MSG_USB_WWID_DP:

+      if (MatchUsbWwid((USB_WWID_DEVICE_PATH *)WantedListItem->DevicePath, UsbIf)) {

+        DoConvert = TRUE;

+      }

+      break;

+    default:

+      ASSERT (0);

+      break;

+    }

+

+    if (DoConvert) {

+      break;

+    }

+

+    WantedListIndex =  WantedListIndex->ForwardLink;

+  }

+  gBS->FreePool (DevicePathPtr);

+

+  //

+  // Check whether the new Usb device path is wanted

+  //

+  if (DoConvert){

+    return TRUE;

+  } else {

+    return FALSE;

+  }

+}

+

+/**

+  Recursively connnect every wanted usb child device to ensure they all fully connected.

+  Check all the child Usb IO handles in this bus, recursively connecte if it is wanted usb child device

+

+  @param UsbBusId   point to EFI_USB_BUS_PROTOCOL interface

+

+  @retval EFI_SUCCESS

+  @retval EFI_INVALID_PARAMETER

+  @retval EFI_OUT_OF_RESOURCES

+

+**/

+EFI_STATUS

+EFIAPI

+UsbBusRecursivelyConnectWantedUsbIo (

+  IN EFI_USB_BUS_PROTOCOL         *UsbBusId

+  )

+{

+  USB_BUS                       *Bus;

+  EFI_STATUS                    Status;

+  UINTN                         Index;

+  EFI_USB_IO_PROTOCOL           *UsbIo;

+  USB_INTERFACE                 *UsbIf;

+  UINTN                         UsbIoHandleCount;

+  EFI_HANDLE                    *UsbIoBuffer;

+  EFI_DEVICE_PATH_PROTOCOL      *UsbIoDevicePath;

+

+  if (UsbBusId == NULL){

+    return EFI_INVALID_PARAMETER;

+  }

+

+  Bus = USB_BUS_FROM_THIS (UsbBusId);

+

+  //

+  // Get all Usb IO handles in system

+  //

+  UsbIoHandleCount = 0;

+  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiUsbIoProtocolGuid, NULL, &UsbIoHandleCount, &UsbIoBuffer);

+  if (Status == EFI_NOT_FOUND || UsbIoHandleCount == 0) {

+    return EFI_SUCCESS;

+  }

+  ASSERT (!EFI_ERROR (Status));

+

+  for (Index = 0; Index < UsbIoHandleCount; Index++) {

+    //

+    // Check whether the USB IO handle is a child of this bus

+    // Note: The usb child handle maybe invalid because of hot plugged out during the loop

+    //

+    UsbIoDevicePath = NULL;

+    Status = gBS->HandleProtocol (UsbIoBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID *) &UsbIoDevicePath);

+    if (EFI_ERROR (Status) || UsbIoDevicePath == NULL) {

+      continue;

+    }

+    if (CompareMem (

+            UsbIoDevicePath,

+            Bus->DevicePath,

+            (GetDevicePathSize (Bus->DevicePath) - sizeof (EFI_DEVICE_PATH_PROTOCOL))

+            ) != 0) {

+      continue;

+    }

+

+    //

+    // Get the child Usb IO interface

+    //

+    Status = gBS->HandleProtocol(

+                     UsbIoBuffer[Index],

+                     &gEfiUsbIoProtocolGuid,

+                     (VOID **) &UsbIo

+                     );

+    if (EFI_ERROR (Status)) {

+      continue;

+    }

+    UsbIf   = USB_INTERFACE_FROM_USBIO (UsbIo);

+

+    if (UsbBusIsWantedUsbIO (Bus, UsbIf)) {

+      if (!UsbIf->IsManaged) {

+        //

+        // Recursively connect the wanted Usb Io handle

+        //

+        DEBUG ((EFI_D_INFO, "UsbConnectDriver: TPL before connect is %d\n", UsbGetCurrentTpl ()));

+        Status            = gBS->ConnectController (UsbIf->Handle, NULL, NULL, TRUE);

+        UsbIf->IsManaged  = (BOOLEAN)!EFI_ERROR (Status);

+        DEBUG ((EFI_D_INFO, "UsbConnectDriver: TPL after connect is %d\n", UsbGetCurrentTpl()));

+      }

+    }

+  }

+

+  return EFI_SUCCESS;

+}

+