UsbUtility.c

Go to the documentation of this file.

 
#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
//
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
    }
  }
};
 
EFI_STATUS
UsbHcGetCapability (
  IN  USB_BUS  *UsbBus,
  OUT UINT8    *MaxSpeed,
  OUT UINT8    *NumOfPort,
  OUT UINT8    *Is64BitCapable
  )
{
  EFI_STATUS  Status;
 
  if (UsbBus->Usb2Hc != NULL) {
    Status = UsbBus->Usb2Hc->GetCapability (
                               UsbBus->Usb2Hc,
                               MaxSpeed,
                               NumOfPort,
                               Is64BitCapable
                               );
  } else {
    Status = UsbBus->UsbHc->GetRootHubPortNumber (UsbBus->UsbHc, NumOfPort);
 
    *MaxSpeed       = EFI_USB_SPEED_FULL;
    *Is64BitCapable = (UINT8)FALSE;
  }
 
  return Status;
}
 
EFI_STATUS
UsbHcGetRootHubPortStatus (
  IN  USB_BUS              *UsbBus,
  IN  UINT8                PortIndex,
  OUT EFI_USB_PORT_STATUS  *PortStatus
  )
{
  EFI_STATUS  Status;
 
  if (UsbBus->Usb2Hc != NULL) {
    Status = UsbBus->Usb2Hc->GetRootHubPortStatus (UsbBus->Usb2Hc, PortIndex, PortStatus);
  } else {
    Status = UsbBus->UsbHc->GetRootHubPortStatus (UsbBus->UsbHc, PortIndex, PortStatus);
  }
 
  return Status;
}
 
EFI_STATUS
UsbHcSetRootHubPortFeature (
  IN USB_BUS               *UsbBus,
  IN UINT8                 PortIndex,
  IN EFI_USB_PORT_FEATURE  Feature
  )
{
  EFI_STATUS  Status;
 
  if (UsbBus->Usb2Hc != NULL) {
    Status = UsbBus->Usb2Hc->SetRootHubPortFeature (UsbBus->Usb2Hc, PortIndex, Feature);
  } else {
    Status = UsbBus->UsbHc->SetRootHubPortFeature (UsbBus->UsbHc, PortIndex, Feature);
  }
 
  return Status;
}
 
EFI_STATUS
UsbHcClearRootHubPortFeature (
  IN USB_BUS               *UsbBus,
  IN UINT8                 PortIndex,
  IN EFI_USB_PORT_FEATURE  Feature
  )
{
  EFI_STATUS  Status;
 
  if (UsbBus->Usb2Hc != NULL) {
    Status = UsbBus->Usb2Hc->ClearRootHubPortFeature (UsbBus->Usb2Hc, PortIndex, Feature);
  } else {
    Status = UsbBus->UsbHc->ClearRootHubPortFeature (UsbBus->UsbHc, PortIndex, Feature);
  }
 
  return Status;
}
 
EFI_STATUS
UsbHcControlTransfer (
  IN  USB_BUS                             *UsbBus,
  IN  UINT8                               DevAddr,
  IN  UINT8                               DevSpeed,
  IN  UINTN                               MaxPacket,
  IN  EFI_USB_DEVICE_REQUEST              *Request,
  IN  EFI_USB_DATA_DIRECTION              Direction,
  IN  OUT VOID                            *Data,
  IN  OUT UINTN                           *DataLength,
  IN  UINTN                               TimeOut,
  IN  EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,
  OUT UINT32                              *UsbResult
  )
{
  EFI_STATUS  Status;
  BOOLEAN     IsSlowDevice;
 
  if (UsbBus->Usb2Hc != NULL) {
    Status = UsbBus->Usb2Hc->ControlTransfer (
                               UsbBus->Usb2Hc,
                               DevAddr,
                               DevSpeed,
                               MaxPacket,
                               Request,
                               Direction,
                               Data,
                               DataLength,
                               TimeOut,
                               Translator,
                               UsbResult
                               );
  } else {
    IsSlowDevice = (BOOLEAN)(EFI_USB_SPEED_LOW == DevSpeed);
    Status       = UsbBus->UsbHc->ControlTransfer (
                                    UsbBus->UsbHc,
                                    DevAddr,
                                    IsSlowDevice,
                                    (UINT8)MaxPacket,
                                    Request,
                                    Direction,
                                    Data,
                                    DataLength,
                                    TimeOut,
                                    UsbResult
                                    );
  }
 
  return Status;
}
 
EFI_STATUS
UsbHcBulkTransfer (
  IN  USB_BUS                             *UsbBus,
  IN  UINT8                               DevAddr,
  IN  UINT8                               EpAddr,
  IN  UINT8                               DevSpeed,
  IN  UINTN                               MaxPacket,
  IN  UINT8                               BufferNum,
  IN  OUT VOID                            *Data[],
  IN  OUT UINTN                           *DataLength,
  IN  OUT UINT8                           *DataToggle,
  IN  UINTN                               TimeOut,
  IN  EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,
  OUT UINT32                              *UsbResult
  )
{
  EFI_STATUS  Status;
 
  if (UsbBus->Usb2Hc != NULL) {
    Status = UsbBus->Usb2Hc->BulkTransfer (
                               UsbBus->Usb2Hc,
                               DevAddr,
                               EpAddr,
                               DevSpeed,
                               MaxPacket,
                               BufferNum,
                               Data,
                               DataLength,
                               DataToggle,
                               TimeOut,
                               Translator,
                               UsbResult
                               );
  } else {
    Status = UsbBus->UsbHc->BulkTransfer (
                              UsbBus->UsbHc,
                              DevAddr,
                              EpAddr,
                              (UINT8)MaxPacket,
                              *Data,
                              DataLength,
                              DataToggle,
                              TimeOut,
                              UsbResult
                              );
  }
 
  return Status;
}
 
EFI_STATUS
UsbHcAsyncInterruptTransfer (
  IN  USB_BUS                             *UsbBus,
  IN  UINT8                               DevAddr,
  IN  UINT8                               EpAddr,
  IN  UINT8                               DevSpeed,
  IN  UINTN                               MaxPacket,
  IN  BOOLEAN                             IsNewTransfer,
  IN OUT UINT8                            *DataToggle,
  IN  UINTN                               PollingInterval,
  IN  UINTN                               DataLength,
  IN  EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,
  IN  EFI_ASYNC_USB_TRANSFER_CALLBACK     Callback,
  IN  VOID                                *Context OPTIONAL
  )
{
  EFI_STATUS  Status;
  BOOLEAN     IsSlowDevice;
 
  if (UsbBus->Usb2Hc != NULL) {
    Status = UsbBus->Usb2Hc->AsyncInterruptTransfer (
                               UsbBus->Usb2Hc,
                               DevAddr,
                               EpAddr,
                               DevSpeed,
                               MaxPacket,
                               IsNewTransfer,
                               DataToggle,
                               PollingInterval,
                               DataLength,
                               Translator,
                               Callback,
                               Context
                               );
  } else {
    IsSlowDevice = (BOOLEAN)(EFI_USB_SPEED_LOW == DevSpeed);
 
    Status = UsbBus->UsbHc->AsyncInterruptTransfer (
                              UsbBus->UsbHc,
                              DevAddr,
                              EpAddr,
                              IsSlowDevice,
                              (UINT8)MaxPacket,
                              IsNewTransfer,
                              DataToggle,
                              PollingInterval,
                              DataLength,
                              Callback,
                              Context
                              );
  }
 
  return Status;
}
 
EFI_STATUS
UsbHcSyncInterruptTransfer (
  IN  USB_BUS                             *UsbBus,
  IN  UINT8                               DevAddr,
  IN  UINT8                               EpAddr,
  IN  UINT8                               DevSpeed,
  IN  UINTN                               MaxPacket,
  IN OUT VOID                             *Data,
  IN OUT UINTN                            *DataLength,
  IN OUT UINT8                            *DataToggle,
  IN  UINTN                               TimeOut,
  IN  EFI_USB2_HC_TRANSACTION_TRANSLATOR  *Translator,
  OUT UINT32                              *UsbResult
  )
{
  EFI_STATUS  Status;
  BOOLEAN     IsSlowDevice;
 
  if (UsbBus->Usb2Hc != NULL) {
    Status = UsbBus->Usb2Hc->SyncInterruptTransfer (
                               UsbBus->Usb2Hc,
                               DevAddr,
                               EpAddr,
                               DevSpeed,
                               MaxPacket,
                               Data,
                               DataLength,
                               DataToggle,
                               TimeOut,
                               Translator,
                               UsbResult
                               );
  } else {
    IsSlowDevice = (BOOLEAN)((EFI_USB_SPEED_LOW == DevSpeed) ? TRUE : FALSE);
    Status       = UsbBus->UsbHc->SyncInterruptTransfer (
                                    UsbBus->UsbHc,
                                    DevAddr,
                                    EpAddr,
                                    IsSlowDevice,
                                    (UINT8)MaxPacket,
                                    Data,
                                    DataLength,
                                    DataToggle,
                                    TimeOut,
                                    UsbResult
                                    );
  }
 
  return Status;
}
 
EFI_STATUS
UsbOpenHostProtoByChild (
  IN USB_BUS     *Bus,
  IN EFI_HANDLE  Child
  )
{
  EFI_USB_HC_PROTOCOL   *UsbHc;
  EFI_USB2_HC_PROTOCOL  *Usb2Hc;
  EFI_STATUS            Status;
 
  if (Bus->Usb2Hc != NULL) {
    Status = gBS->OpenProtocol (
                    Bus->HostHandle,
                    &gEfiUsb2HcProtocolGuid,
                    (VOID **)&Usb2Hc,
                    mUsbBusDriverBinding.DriverBindingHandle,
                    Child,
                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                    );
  } else {
    Status = gBS->OpenProtocol (
                    Bus->HostHandle,
                    &gEfiUsbHcProtocolGuid,
                    (VOID **)&UsbHc,
                    mUsbBusDriverBinding.DriverBindingHandle,
                    Child,
                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                    );
  }
 
  return Status;
}
 
VOID
UsbCloseHostProtoByChild (
  IN USB_BUS     *Bus,
  IN EFI_HANDLE  Child
  )
{
  if (Bus->Usb2Hc != NULL) {
    gBS->CloseProtocol (
           Bus->HostHandle,
           &gEfiUsb2HcProtocolGuid,
           mUsbBusDriverBinding.DriverBindingHandle,
           Child
           );
  } else {
    gBS->CloseProtocol (
           Bus->HostHandle,
           &gEfiUsbHcProtocolGuid,
           mUsbBusDriverBinding.DriverBindingHandle,
           Child
           );
  }
}
 
EFI_TPL
UsbGetCurrentTpl (
  VOID
  )
{
  EFI_TPL  Tpl;
 
  Tpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
  gBS->RestoreTPL (Tpl);
 
  return Tpl;
}
 
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 ((!IsDevicePathEnd (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 ((!IsDevicePathEnd (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;
}
 
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;
}
 
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;
}
 
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;
  ASSERT (IfDesc->ActiveIndex < USB_MAX_INTERFACE_SETTING);
  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 addition, 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 in Device Descriptor is set to 0, the counterparts in interface should be checked.
    //
    if (DevDesc->DeviceClass == 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;
}
 
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                        Index;
  CHAR16                        *CompareStr;
  UINTN                         CompareLen;
  UINTN                         Length;
 
  if ((UsbWWIDDevicePathPtr->Header.Type != MESSAGING_DEVICE_PATH) ||
      (UsbWWIDDevicePathPtr->Header.SubType != MSG_USB_WWID_DP))
  {
    ASSERT (0);
    return FALSE;
  }
 
  IfDesc = UsbIf->IfDesc;
  ASSERT (IfDesc->ActiveIndex < USB_MAX_INTERFACE_SETTING);
  ActIfDesc = &(IfDesc->Settings[IfDesc->ActiveIndex]->Desc);
  DevDesc   = &(UsbIf->Device->DevDesc->Desc);
 
  //
  // In addition, Hub interface is always matched for this policy.
  //
  if ((ActIfDesc->InterfaceClass == USB_HUB_CLASS_CODE) &&
      (ActIfDesc->InterfaceSubClass == USB_HUB_SUBCLASS_CODE))
  {
    return TRUE;
  }
 
  //
  // Check Vendor Id, Product Id and Interface Number.
  //
  if ((DevDesc->IdVendor != UsbWWIDDevicePathPtr->VendorId) ||
      (DevDesc->IdProduct != UsbWWIDDevicePathPtr->ProductId) ||
      (ActIfDesc->InterfaceNumber != UsbWWIDDevicePathPtr->InterfaceNumber))
  {
    return FALSE;
  }
 
  //
  // Check SerialNumber.
  //
  if (DevDesc->StrSerialNumber == 0) {
    return FALSE;
  }
 
  //
  // Serial number in USB WWID device path is the last 64-or-less UTF-16 characters.
  //
  CompareStr = (CHAR16 *)(UINTN)(UsbWWIDDevicePathPtr + 1);
  CompareLen = (DevicePathNodeLength (UsbWWIDDevicePathPtr) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16);
  if (CompareStr[CompareLen - 1] == L'\0') {
    CompareLen--;
  }
 
  //
  // Compare serial number in each supported language.
  //
  for (Index = 0; Index < UsbIf->Device->TotalLangId; Index++) {
    StrDesc = UsbGetOneString (UsbIf->Device, DevDesc->StrSerialNumber, UsbIf->Device->LangId[Index]);
    if (StrDesc == NULL) {
      continue;
    }
 
    Length = (StrDesc->Length - 2) / sizeof (CHAR16);
    if ((Length >= CompareLen) &&
        (CompareMem (StrDesc->String + Length - CompareLen, CompareStr, CompareLen * sizeof (CHAR16)) == 0))
    {
      return TRUE;
    }
  }
 
  return FALSE;
}
 
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;
}
 
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) && !IsDevicePathEnd (RemainingDevicePath)) {
    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 if (!IsDevicePathEnd (RemainingDevicePath)) {
    //
    // If RemainingDevicePath isn't the End of Device Path Node,
    // Create new Usb device path according to the usb part in remaining device path
    //
    DevicePathPtr = GetUsbDPFromFullDP (RemainingDevicePath);
  } else {
    //
    // If RemainingDevicePath is the End of Device Path Node,
    // skip enumerate any device and return EFI_SUCCESS
    //
    return EFI_SUCCESS;
  }
 
  ASSERT (DevicePathPtr != NULL);
  Status = AddUsbDPToList (DevicePathPtr, &Bus->WantedUsbIoDPList);
  ASSERT (!EFI_ERROR (Status));
  FreePool (DevicePathPtr);
  return EFI_SUCCESS;
}
 
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;
  }
}
 
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 ((DEBUG_INFO, "UsbBusRecursivelyConnectWantedUsbIo: TPL before connect is %d\n", (UINT32)UsbGetCurrentTpl ()));
        Status           = gBS->ConnectController (UsbIf->Handle, NULL, NULL, TRUE);
        UsbIf->IsManaged = (BOOLEAN) !EFI_ERROR (Status);
        DEBUG ((DEBUG_INFO, "UsbBusRecursivelyConnectWantedUsbIo: TPL after connect is %d\n", (UINT32)UsbGetCurrentTpl ()));
      }
    }
  }
 
  FreePool (UsbIoBuffer);
 
  return EFI_SUCCESS;
}