MdeModulePkg: Replace BSD License with BSD+Patent License

[mirror_edk2.git] / MdeModulePkg / Bus / Usb / UsbBusDxe / UsbDesc.c

/** @file\r
\r
    Manage Usb Descriptor List\r
\r
Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "UsbBus.h"\r
\r
\r
/**\r
  Free the interface setting descriptor.\r
\r
  @param  Setting               The descriptor to free.\r
\r
**/\r
VOID\r
UsbFreeInterfaceDesc (\r
  IN USB_INTERFACE_SETTING  *Setting\r
  )\r
{\r
  USB_ENDPOINT_DESC       *Ep;\r
  UINTN                   Index;\r
\r
  if (Setting->Endpoints != NULL) {\r
    //\r
    // Each interface setting may have several endpoints, free them first.\r
    //\r
    for (Index = 0; Index < Setting->Desc.NumEndpoints; Index++) {\r
      Ep = Setting->Endpoints[Index];\r
\r
      if (Ep != NULL) {\r
        FreePool (Ep);\r
      }\r
    }\r
\r
    //\r
    // Only call FreePool() if NumEndpoints > 0.\r
    //\r
    if (Setting->Desc.NumEndpoints > 0) {\r
      FreePool (Setting->Endpoints);\r
    }\r
  }\r
\r
  FreePool (Setting);\r
}\r
\r
\r
/**\r
  Free a configuration descriptor with its interface\r
  descriptors. It may be initialized partially.\r
\r
  @param  Config                The configuration descriptor to free.\r
\r
**/\r
VOID\r
UsbFreeConfigDesc (\r
  IN USB_CONFIG_DESC      *Config\r
  )\r
{\r
  USB_INTERFACE_DESC      *Interface;\r
  UINTN                   Index;\r
  UINTN                   SetIndex;\r
\r
  if (Config->Interfaces != NULL) {\r
    //\r
    // A configuration may have several interfaces, free the interface\r
    //\r
    for (Index = 0; Index < Config->Desc.NumInterfaces; Index++) {\r
      Interface = Config->Interfaces[Index];\r
\r
      if (Interface == NULL) {\r
        continue;\r
      }\r
\r
      //\r
      // Each interface may have several settings, free the settings\r
      //\r
      for (SetIndex = 0; SetIndex < Interface->NumOfSetting; SetIndex++) {\r
        if (Interface->Settings[SetIndex] != NULL) {\r
          UsbFreeInterfaceDesc (Interface->Settings[SetIndex]);\r
        }\r
      }\r
\r
      FreePool (Interface);\r
    }\r
\r
    FreePool (Config->Interfaces);\r
  }\r
\r
  FreePool (Config);\r
\r
}\r
\r
\r
/**\r
  Free a device descriptor with its configurations.\r
\r
  @param  DevDesc               The device descriptor.\r
\r
**/\r
VOID\r
UsbFreeDevDesc (\r
  IN USB_DEVICE_DESC      *DevDesc\r
  )\r
{\r
  UINTN                   Index;\r
\r
  if (DevDesc->Configs != NULL) {\r
    for (Index = 0; Index < DevDesc->Desc.NumConfigurations; Index++) {\r
      if (DevDesc->Configs[Index] != NULL) {\r
        UsbFreeConfigDesc (DevDesc->Configs[Index]);\r
      }\r
    }\r
\r
    FreePool (DevDesc->Configs);\r
  }\r
\r
  FreePool (DevDesc);\r
}\r
\r
\r
/**\r
  Create a descriptor.\r
\r
  @param  DescBuf               The buffer of raw descriptor.\r
  @param  Len                   The length of the raw descriptor buffer.\r
  @param  Type                  The type of descriptor to create.\r
  @param  Consumed              Number of bytes consumed.\r
\r
  @return Created descriptor or NULL.\r
\r
**/\r
VOID *\r
UsbCreateDesc (\r
  IN  UINT8               *DescBuf,\r
  IN  UINTN               Len,\r
  IN  UINT8               Type,\r
  OUT UINTN               *Consumed\r
  )\r
{\r
  USB_DESC_HEAD           *Head;\r
  UINTN                   DescLen;\r
  UINTN                   CtrlLen;\r
  UINTN                   Offset;\r
  VOID                    *Desc;\r
\r
  DescLen   = 0;\r
  CtrlLen   = 0;\r
  *Consumed = 0;\r
\r
  switch (Type) {\r
  case USB_DESC_TYPE_DEVICE:\r
    DescLen = sizeof (EFI_USB_DEVICE_DESCRIPTOR);\r
    CtrlLen = sizeof (USB_DEVICE_DESC);\r
    break;\r
\r
  case USB_DESC_TYPE_CONFIG:\r
    DescLen = sizeof (EFI_USB_CONFIG_DESCRIPTOR);\r
    CtrlLen = sizeof (USB_CONFIG_DESC);\r
    break;\r
\r
  case USB_DESC_TYPE_INTERFACE:\r
    DescLen = sizeof (EFI_USB_INTERFACE_DESCRIPTOR);\r
    CtrlLen = sizeof (USB_INTERFACE_SETTING);\r
    break;\r
\r
  case USB_DESC_TYPE_ENDPOINT:\r
    DescLen = sizeof (EFI_USB_ENDPOINT_DESCRIPTOR);\r
    CtrlLen = sizeof (USB_ENDPOINT_DESC);\r
    break;\r
\r
  default:\r
    ASSERT (FALSE);\r
    return NULL;\r
  }\r
\r
  //\r
  // Total length is too small that cannot hold the single descriptor header plus data.\r
  //\r
  if (Len <= sizeof (USB_DESC_HEAD)) {\r
    DEBUG ((DEBUG_ERROR, "UsbCreateDesc: met mal-format descriptor, total length = %d!\n", Len));\r
    return NULL;\r
  }\r
\r
  //\r
  // All the descriptor has a common LTV (Length, Type, Value)\r
  // format. Skip the descriptor that isn't of this Type\r
  //\r
  Offset = 0;\r
  Head   = (USB_DESC_HEAD *)DescBuf;\r
  while (Offset < Len - sizeof (USB_DESC_HEAD)) {\r
    //\r
    // Above condition make sure Head->Len and Head->Type are safe to access\r
    //\r
    Head = (USB_DESC_HEAD *)&DescBuf[Offset];\r
\r
    if (Head->Len == 0) {\r
      DEBUG ((DEBUG_ERROR, "UsbCreateDesc: met mal-format descriptor, Head->Len = 0!\n"));\r
      return NULL;\r
    }\r
\r
    //\r
    // Make sure no overflow when adding Head->Len to Offset.\r
    //\r
    if (Head->Len > MAX_UINTN - Offset) {\r
      DEBUG ((DEBUG_ERROR, "UsbCreateDesc: met mal-format descriptor, Head->Len = %d!\n", Head->Len));\r
      return NULL;\r
    }\r
\r
    Offset += Head->Len;\r
\r
    if (Head->Type == Type) {\r
      break;\r
    }\r
  }\r
\r
  //\r
  // Head->Len is invalid resulting data beyond boundary, or\r
  // Descriptor cannot be found: No such type.\r
  //\r
  if (Len < Offset) {\r
    DEBUG ((DEBUG_ERROR, "UsbCreateDesc: met mal-format descriptor, Offset/Len = %d/%d!\n", Offset, Len));\r
    return NULL;\r
  }\r
\r
  if ((Head->Type != Type) || (Head->Len < DescLen)) {\r
    DEBUG ((DEBUG_ERROR, "UsbCreateDesc: descriptor cannot be found, Header(T/L) = %d/%d!\n", Head->Type, Head->Len));\r
    return NULL;\r
  }\r
\r
  Desc = AllocateZeroPool ((UINTN) CtrlLen);\r
  if (Desc == NULL) {\r
    return NULL;\r
  }\r
\r
  CopyMem (Desc, Head, (UINTN) DescLen);\r
\r
  *Consumed = Offset;\r
\r
  return Desc;\r
}\r
\r
\r
/**\r
  Parse an interface descriptor and its endpoints.\r
\r
  @param  DescBuf               The buffer of raw descriptor.\r
  @param  Len                   The length of the raw descriptor buffer.\r
  @param  Consumed              The number of raw descriptor consumed.\r
\r
  @return The create interface setting or NULL if failed.\r
\r
**/\r
USB_INTERFACE_SETTING *\r
UsbParseInterfaceDesc (\r
  IN  UINT8               *DescBuf,\r
  IN  UINTN               Len,\r
  OUT UINTN               *Consumed\r
  )\r
{\r
  USB_INTERFACE_SETTING   *Setting;\r
  USB_ENDPOINT_DESC       *Ep;\r
  UINTN                   Index;\r
  UINTN                   NumEp;\r
  UINTN                   Used;\r
  UINTN                   Offset;\r
\r
  *Consumed = 0;\r
  Setting   = UsbCreateDesc (DescBuf, Len, USB_DESC_TYPE_INTERFACE, &Used);\r
\r
  if (Setting == NULL) {\r
    DEBUG (( EFI_D_ERROR, "UsbParseInterfaceDesc: failed to create interface descriptor\n"));\r
    return NULL;\r
  }\r
\r
  Offset = Used;\r
\r
  //\r
  // Create an array to hold the interface's endpoints\r
  //\r
  NumEp  = Setting->Desc.NumEndpoints;\r
\r
  DEBUG (( EFI_D_INFO, "UsbParseInterfaceDesc: interface %d(setting %d) has %d endpoints\n",\r
              Setting->Desc.InterfaceNumber, Setting->Desc.AlternateSetting, (UINT32)NumEp));\r
\r
  if (NumEp == 0) {\r
    goto ON_EXIT;\r
  }\r
\r
  Setting->Endpoints  = AllocateZeroPool (sizeof (USB_ENDPOINT_DESC *) * NumEp);\r
\r
  if (Setting->Endpoints == NULL) {\r
    goto ON_ERROR;\r
  }\r
\r
  //\r
  // Create the endpoints for this interface\r
  //\r
  for (Index = 0; (Index < NumEp) && (Offset < Len); Index++) {\r
    Ep = UsbCreateDesc (DescBuf + Offset, Len - Offset, USB_DESC_TYPE_ENDPOINT, &Used);\r
\r
    if (Ep == NULL) {\r
      DEBUG (( EFI_D_ERROR, "UsbParseInterfaceDesc: failed to create endpoint(index %d)\n", (UINT32)Index));\r
      goto ON_ERROR;\r
    }\r
\r
    Setting->Endpoints[Index]  = Ep;\r
    Offset                    += Used;\r
  }\r
\r
\r
ON_EXIT:\r
  *Consumed = Offset;\r
  return Setting;\r
\r
ON_ERROR:\r
  UsbFreeInterfaceDesc (Setting);\r
  return NULL;\r
}\r
\r
\r
/**\r
  Parse the configuration descriptor and its interfaces.\r
\r
  @param  DescBuf               The buffer of raw descriptor.\r
  @param  Len                   The length of the raw descriptor buffer.\r
\r
  @return The created configuration descriptor.\r
\r
**/\r
USB_CONFIG_DESC *\r
UsbParseConfigDesc (\r
  IN UINT8                *DescBuf,\r
  IN UINTN                Len\r
  )\r
{\r
  USB_CONFIG_DESC         *Config;\r
  USB_INTERFACE_SETTING   *Setting;\r
  USB_INTERFACE_DESC      *Interface;\r
  UINTN                   Index;\r
  UINTN                   NumIf;\r
  UINTN                   Consumed;\r
\r
  ASSERT (DescBuf != NULL);\r
\r
  Config = UsbCreateDesc (DescBuf, Len, USB_DESC_TYPE_CONFIG, &Consumed);\r
\r
  if (Config == NULL) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Initialize an array of setting for the configuration's interfaces.\r
  //\r
  NumIf               = Config->Desc.NumInterfaces;\r
  Config->Interfaces  = AllocateZeroPool (sizeof (USB_INTERFACE_DESC *) * NumIf);\r
\r
  if (Config->Interfaces == NULL) {\r
    goto ON_ERROR;\r
  }\r
\r
  DEBUG (( EFI_D_INFO, "UsbParseConfigDesc: config %d has %d interfaces\n",\r
                Config->Desc.ConfigurationValue, (UINT32)NumIf));\r
\r
  for (Index = 0; Index < NumIf; Index++) {\r
    Interface = AllocateZeroPool (sizeof (USB_INTERFACE_DESC));\r
\r
    if (Interface == NULL) {\r
      goto ON_ERROR;\r
    }\r
\r
    Config->Interfaces[Index] = Interface;\r
  }\r
\r
  //\r
  // If a configuration has several interfaces, these interfaces are\r
  // numbered from zero to n. If a interface has several settings,\r
  // these settings are also number from zero to m. The interface\r
  // setting must be organized as |interface 0, setting 0|interface 0\r
  // setting 1|interface 1, setting 0|interface 2, setting 0|. Check\r
  // USB2.0 spec, page 267.\r
  //\r
  DescBuf += Consumed;\r
  Len     -= Consumed;\r
\r
  //\r
  // Make allowances for devices that return extra data at the\r
  // end of their config descriptors\r
  //\r
  while (Len >= sizeof (EFI_USB_INTERFACE_DESCRIPTOR)) {\r
    Setting = UsbParseInterfaceDesc (DescBuf, Len, &Consumed);\r
\r
    if (Setting == NULL) {\r
      DEBUG (( EFI_D_ERROR, "UsbParseConfigDesc: warning: failed to get interface setting, stop parsing now.\n"));\r
      break;\r
\r
    } else if (Setting->Desc.InterfaceNumber >= NumIf) {\r
      DEBUG (( EFI_D_ERROR, "UsbParseConfigDesc: mal-formated interface descriptor\n"));\r
\r
      UsbFreeInterfaceDesc (Setting);\r
      goto ON_ERROR;\r
    }\r
\r
    //\r
    // Insert the descriptor to the corresponding set.\r
    //\r
    Interface = Config->Interfaces[Setting->Desc.InterfaceNumber];\r
\r
    if (Interface->NumOfSetting >= USB_MAX_INTERFACE_SETTING) {\r
      goto ON_ERROR;\r
    }\r
\r
    Interface->Settings[Interface->NumOfSetting] = Setting;\r
    Interface->NumOfSetting++;\r
\r
    DescBuf += Consumed;\r
    Len     -= Consumed;\r
  }\r
\r
  return Config;\r
\r
ON_ERROR:\r
  UsbFreeConfigDesc (Config);\r
  return NULL;\r
}\r
\r
\r
/**\r
  USB standard control transfer support routine. This\r
  function is used by USB device. It is possible that\r
  the device's interfaces are still waiting to be\r
  enumerated.\r
\r
  @param  UsbDev                The usb device.\r
  @param  Direction             The direction of data transfer.\r
  @param  Type                  Standard / class specific / vendor specific.\r
  @param  Target                The receiving target.\r
  @param  Request               Which request.\r
  @param  Value                 The wValue parameter of the request.\r
  @param  Index                 The wIndex parameter of the request.\r
  @param  Buf                   The buffer to receive data into / transmit from.\r
  @param  Length                The length of the buffer.\r
\r
  @retval EFI_SUCCESS           The control request is executed.\r
  @retval EFI_DEVICE_ERROR      Failed to execute the control transfer.\r
\r
**/\r
EFI_STATUS\r
UsbCtrlRequest (\r
  IN USB_DEVICE             *UsbDev,\r
  IN EFI_USB_DATA_DIRECTION Direction,\r
  IN UINTN                  Type,\r
  IN UINTN                  Target,\r
  IN UINTN                  Request,\r
  IN UINT16                 Value,\r
  IN UINT16                 Index,\r
  IN OUT VOID               *Buf,\r
  IN UINTN                  Length\r
  )\r
{\r
  EFI_USB_DEVICE_REQUEST  DevReq;\r
  EFI_STATUS              Status;\r
  UINT32                  Result;\r
  UINTN                   Len;\r
\r
  ASSERT ((UsbDev != NULL) && (UsbDev->Bus != NULL));\r
\r
  DevReq.RequestType  = USB_REQUEST_TYPE (Direction, Type, Target);\r
  DevReq.Request      = (UINT8) Request;\r
  DevReq.Value        = Value;\r
  DevReq.Index        = Index;\r
  DevReq.Length       = (UINT16) Length;\r
\r
  Len                 = Length;\r
  Status = UsbHcControlTransfer (\r
             UsbDev->Bus,\r
             UsbDev->Address,\r
             UsbDev->Speed,\r
             UsbDev->MaxPacket0,\r
             &DevReq,\r
             Direction,\r
             Buf,\r
             &Len,\r
             USB_GENERAL_DEVICE_REQUEST_TIMEOUT,\r
             &UsbDev->Translator,\r
             &Result\r
             );\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Get the standard descriptors.\r
\r
  @param  UsbDev                The USB device to read descriptor from.\r
  @param  DescType              The type of descriptor to read.\r
  @param  DescIndex             The index of descriptor to read.\r
  @param  LangId                Language ID, only used to get string, otherwise set\r
                                it to 0.\r
  @param  Buf                   The buffer to hold the descriptor read.\r
  @param  Length                The length of the buffer.\r
\r
  @retval EFI_SUCCESS           The descriptor is read OK.\r
  @retval Others                Failed to retrieve the descriptor.\r
\r
**/\r
EFI_STATUS\r
UsbCtrlGetDesc (\r
  IN  USB_DEVICE          *UsbDev,\r
  IN  UINTN               DescType,\r
  IN  UINTN               DescIndex,\r
  IN  UINT16              LangId,\r
  OUT VOID                *Buf,\r
  IN  UINTN               Length\r
  )\r
{\r
  EFI_STATUS              Status;\r
\r
  Status = UsbCtrlRequest (\r
             UsbDev,\r
             EfiUsbDataIn,\r
             USB_REQ_TYPE_STANDARD,\r
             USB_TARGET_DEVICE,\r
             USB_REQ_GET_DESCRIPTOR,\r
             (UINT16) ((DescType << 8) | DescIndex),\r
             LangId,\r
             Buf,\r
             Length\r
             );\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Return the max packet size for endpoint zero. This function\r
  is the first function called to get descriptors during bus\r
  enumeration.\r
\r
  @param  UsbDev                The usb device.\r
\r
  @retval EFI_SUCCESS           The max packet size of endpoint zero is retrieved.\r
  @retval EFI_DEVICE_ERROR      Failed to retrieve it.\r
\r
**/\r
EFI_STATUS\r
UsbGetMaxPacketSize0 (\r
  IN USB_DEVICE           *UsbDev\r
  )\r
{\r
  EFI_USB_DEVICE_DESCRIPTOR DevDesc;\r
  EFI_STATUS                Status;\r
  UINTN                     Index;\r
\r
\r
  //\r
  // Get the first 8 bytes of the device descriptor which contains\r
  // max packet size for endpoint 0, which is at least 8.\r
  //\r
  for (Index = 0; Index < 3; Index++) {\r
    Status = UsbCtrlGetDesc (UsbDev, USB_DESC_TYPE_DEVICE, 0, 0, &DevDesc, 8);\r
\r
    if (!EFI_ERROR (Status)) {\r
      if ((DevDesc.BcdUSB >= 0x0300) && (DevDesc.MaxPacketSize0 == 9)) {\r
        UsbDev->MaxPacket0 = 1 << 9;\r
        return EFI_SUCCESS;\r
      }\r
      UsbDev->MaxPacket0 = DevDesc.MaxPacketSize0;\r
      return EFI_SUCCESS;\r
    }\r
\r
    gBS->Stall (USB_RETRY_MAX_PACK_SIZE_STALL);\r
  }\r
\r
  return EFI_DEVICE_ERROR;\r
}\r
\r
\r
/**\r
  Get the device descriptor for the device.\r
\r
  @param  UsbDev                The Usb device to retrieve descriptor from.\r
\r
  @retval EFI_SUCCESS           The device descriptor is returned.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate memory.\r
\r
**/\r
EFI_STATUS\r
UsbGetDevDesc (\r
  IN USB_DEVICE           *UsbDev\r
  )\r
{\r
  USB_DEVICE_DESC         *DevDesc;\r
  EFI_STATUS              Status;\r
\r
  DevDesc = AllocateZeroPool (sizeof (USB_DEVICE_DESC));\r
\r
  if (DevDesc == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Status  = UsbCtrlGetDesc (\r
              UsbDev,\r
              USB_DESC_TYPE_DEVICE,\r
              0,\r
              0,\r
              DevDesc,\r
              sizeof (EFI_USB_DEVICE_DESCRIPTOR)\r
              );\r
\r
  if (EFI_ERROR (Status)) {\r
    gBS->FreePool (DevDesc);\r
  } else {\r
    UsbDev->DevDesc = DevDesc;\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Retrieve the indexed string for the language. It requires two\r
  steps to get a string, first to get the string's length. Then\r
  the string itself.\r
\r
  @param  UsbDev                The usb device.\r
  @param  Index                 The index the string to retrieve.\r
  @param  LangId                Language ID.\r
\r
  @return The created string descriptor or NULL.\r
\r
**/\r
EFI_USB_STRING_DESCRIPTOR *\r
UsbGetOneString (\r
  IN     USB_DEVICE       *UsbDev,\r
  IN     UINT8            Index,\r
  IN     UINT16           LangId\r
  )\r
{\r
  EFI_USB_STRING_DESCRIPTOR Desc;\r
  EFI_STATUS                Status;\r
  UINT8                     *Buf;\r
\r
  //\r
  // First get two bytes which contains the string length.\r
  //\r
  Status = UsbCtrlGetDesc (UsbDev, USB_DESC_TYPE_STRING, Index, LangId, &Desc, 2);\r
\r
  //\r
  // Reject if Length even cannot cover itself, or odd because Unicode string byte length should be even.\r
  //\r
  if (EFI_ERROR (Status) ||\r
      (Desc.Length < OFFSET_OF (EFI_USB_STRING_DESCRIPTOR, Length) + sizeof (Desc.Length)) ||\r
      (Desc.Length % 2 != 0)\r
    ) {\r
    return NULL;\r
  }\r
\r
  Buf = AllocateZeroPool (Desc.Length);\r
\r
  if (Buf == NULL) {\r
    return NULL;\r
  }\r
\r
  Status = UsbCtrlGetDesc (\r
             UsbDev,\r
             USB_DESC_TYPE_STRING,\r
             Index,\r
             LangId,\r
             Buf,\r
             Desc.Length\r
             );\r
\r
  if (EFI_ERROR (Status)) {\r
    FreePool (Buf);\r
    return NULL;\r
  }\r
\r
  return (EFI_USB_STRING_DESCRIPTOR *) Buf;\r
}\r
\r
\r
/**\r
  Build the language ID table for string descriptors.\r
\r
  @param  UsbDev                The Usb device.\r
\r
  @retval EFI_UNSUPPORTED       This device doesn't support string table.\r
\r
**/\r
EFI_STATUS\r
UsbBuildLangTable (\r
  IN USB_DEVICE           *UsbDev\r
  )\r
{\r
  EFI_USB_STRING_DESCRIPTOR *Desc;\r
  EFI_STATUS                Status;\r
  UINTN                     Index;\r
  UINTN                     Max;\r
  UINT16                    *Point;\r
\r
  //\r
  // The string of language ID zero returns the supported languages\r
  //\r
  Desc = UsbGetOneString (UsbDev, 0, 0);\r
\r
  if (Desc == NULL) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  if (Desc->Length < 4) {\r
    Status = EFI_UNSUPPORTED;\r
    goto ON_EXIT;\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
  Max   = (Desc->Length - 2) / 2;\r
  Max   = MIN(Max, USB_MAX_LANG_ID);\r
\r
  Point = Desc->String;\r
  for (Index = 0; Index < Max; Index++) {\r
    UsbDev->LangId[Index] = *Point;\r
    Point++;\r
  }\r
\r
  UsbDev->TotalLangId = (UINT16)Max;\r
\r
ON_EXIT:\r
  gBS->FreePool (Desc);\r
  return Status;\r
}\r
\r
\r
/**\r
  Retrieve the indexed configure for the device. USB device\r
  returns the configuration together with the interfaces for\r
  this configuration. Configuration descriptor is also of\r
  variable length.\r
\r
  @param  UsbDev                The Usb interface.\r
  @param  Index                 The index of the configuration.\r
\r
  @return The created configuration descriptor.\r
\r
**/\r
EFI_USB_CONFIG_DESCRIPTOR *\r
UsbGetOneConfig (\r
  IN USB_DEVICE           *UsbDev,\r
  IN UINT8                Index\r
  )\r
{\r
  EFI_USB_CONFIG_DESCRIPTOR Desc;\r
  EFI_STATUS                Status;\r
  VOID                      *Buf;\r
\r
  //\r
  // First get four bytes which contains the total length\r
  // for this configuration.\r
  //\r
  Status = UsbCtrlGetDesc (UsbDev, USB_DESC_TYPE_CONFIG, Index, 0, &Desc, 8);\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG (( EFI_D_ERROR, "UsbGetOneConfig: failed to get descript length(%d) %r\n",\r
                Desc.TotalLength, Status));\r
\r
    return NULL;\r
  }\r
\r
  DEBUG (( EFI_D_INFO, "UsbGetOneConfig: total length is %d\n", Desc.TotalLength));\r
\r
  //\r
  // Reject if TotalLength even cannot cover itself.\r
  //\r
  if (Desc.TotalLength < OFFSET_OF (EFI_USB_CONFIG_DESCRIPTOR, TotalLength) + sizeof (Desc.TotalLength)) {\r
    return NULL;\r
  }\r
\r
  Buf = AllocateZeroPool (Desc.TotalLength);\r
\r
  if (Buf == NULL) {\r
    return NULL;\r
  }\r
\r
  Status = UsbCtrlGetDesc (UsbDev, USB_DESC_TYPE_CONFIG, Index, 0, Buf, Desc.TotalLength);\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG (( EFI_D_ERROR, "UsbGetOneConfig: failed to get full descript %r\n", Status));\r
\r
    FreePool (Buf);\r
    return NULL;\r
  }\r
\r
  return Buf;\r
}\r
\r
\r
/**\r
  Build the whole array of descriptors. This function must\r
  be called after UsbGetMaxPacketSize0 returns the max packet\r
  size correctly for endpoint 0.\r
\r
  @param  UsbDev                The Usb device.\r
\r
  @retval EFI_SUCCESS           The descriptor table is build.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource for the descriptor.\r
\r
**/\r
EFI_STATUS\r
UsbBuildDescTable (\r
  IN USB_DEVICE           *UsbDev\r
  )\r
{\r
  EFI_USB_CONFIG_DESCRIPTOR *Config;\r
  USB_DEVICE_DESC           *DevDesc;\r
  USB_CONFIG_DESC           *ConfigDesc;\r
  UINT8                     NumConfig;\r
  EFI_STATUS                Status;\r
  UINT8                     Index;\r
\r
  //\r
  // Get the device descriptor, then allocate the configure\r
  // descriptor pointer array to hold configurations.\r
  //\r
  Status = UsbGetDevDesc (UsbDev);\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG (( EFI_D_ERROR, "UsbBuildDescTable: failed to get device descriptor - %r\n", Status));\r
    return Status;\r
  }\r
\r
  DevDesc   = UsbDev->DevDesc;\r
  NumConfig = DevDesc->Desc.NumConfigurations;\r
  if (NumConfig == 0) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  DevDesc->Configs = AllocateZeroPool (NumConfig * sizeof (USB_CONFIG_DESC *));\r
  if (DevDesc->Configs == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  DEBUG (( EFI_D_INFO, "UsbBuildDescTable: device has %d configures\n", NumConfig));\r
\r
  //\r
  // Read each configurations, then parse them\r
  //\r
  for (Index = 0; Index < NumConfig; Index++) {\r
    Config = UsbGetOneConfig (UsbDev, Index);\r
\r
    if (Config == NULL) {\r
      DEBUG (( EFI_D_ERROR, "UsbBuildDescTable: failed to get configure (index %d)\n", Index));\r
\r
      //\r
      // If we can get the default descriptor, it is likely that the\r
      // device is still operational.\r
      //\r
      if (Index == 0) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      break;\r
    }\r
\r
    ConfigDesc = UsbParseConfigDesc ((UINT8 *) Config, Config->TotalLength);\r
\r
    FreePool (Config);\r
\r
    if (ConfigDesc == NULL) {\r
      DEBUG (( EFI_D_ERROR, "UsbBuildDescTable: failed to parse configure (index %d)\n", Index));\r
\r
      //\r
      // If we can get the default descriptor, it is likely that the\r
      // device is still operational.\r
      //\r
      if (Index == 0) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      break;\r
    }\r
\r
    DevDesc->Configs[Index] = ConfigDesc;\r
  }\r
\r
  //\r
  // Don't return error even this function failed because\r
  // it is possible for the device to not support strings.\r
  //\r
  Status = UsbBuildLangTable (UsbDev);\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG (( EFI_D_INFO, "UsbBuildDescTable: get language ID table %r\n", Status));\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Set the device's address.\r
\r
  @param  UsbDev                The device to set address to.\r
  @param  Address               The address to set.\r
\r
  @retval EFI_SUCCESS           The device is set to the address.\r
  @retval Others                Failed to set the device address.\r
\r
**/\r
EFI_STATUS\r
UsbSetAddress (\r
  IN USB_DEVICE           *UsbDev,\r
  IN UINT8                Address\r
  )\r
{\r
  EFI_STATUS              Status;\r
\r
  Status = UsbCtrlRequest (\r
             UsbDev,\r
             EfiUsbNoData,\r
             USB_REQ_TYPE_STANDARD,\r
             USB_TARGET_DEVICE,\r
             USB_REQ_SET_ADDRESS,\r
             Address,\r
             0,\r
             NULL,\r
             0\r
             );\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Set the device's configuration. This function changes\r
  the device's internal state. UsbSelectConfig changes\r
  the Usb bus's internal state.\r
\r
  @param  UsbDev                The USB device to set configure to.\r
  @param  ConfigIndex           The configure index to set.\r
\r
  @retval EFI_SUCCESS           The device is configured now.\r
  @retval Others                Failed to set the device configure.\r
\r
**/\r
EFI_STATUS\r
UsbSetConfig (\r
  IN USB_DEVICE           *UsbDev,\r
  IN UINT8                ConfigIndex\r
  )\r
{\r
  EFI_STATUS              Status;\r
\r
  Status = UsbCtrlRequest (\r
             UsbDev,\r
             EfiUsbNoData,\r
             USB_REQ_TYPE_STANDARD,\r
             USB_TARGET_DEVICE,\r
             USB_REQ_SET_CONFIG,\r
             ConfigIndex,\r
             0,\r
             NULL,\r
             0\r
            );\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Usb UsbIo interface to clear the feature. This is should\r
  only be used by HUB which is considered a device driver\r
  on top of the UsbIo interface.\r
\r
  @param  UsbIo                 The UsbIo interface.\r
  @param  Target                The target of the transfer: endpoint/device.\r
  @param  Feature               The feature to clear.\r
  @param  Index                 The wIndex parameter.\r
\r
  @retval EFI_SUCCESS           The device feature is cleared.\r
  @retval Others                Failed to clear the feature.\r
\r
**/\r
EFI_STATUS\r
UsbIoClearFeature (\r
  IN  EFI_USB_IO_PROTOCOL *UsbIo,\r
  IN  UINTN               Target,\r
  IN  UINT16              Feature,\r
  IN  UINT16              Index\r
  )\r
{\r
  EFI_USB_DEVICE_REQUEST  DevReq;\r
  UINT32                  UsbResult;\r
  EFI_STATUS              Status;\r
\r
  DevReq.RequestType  = USB_REQUEST_TYPE (EfiUsbNoData, USB_REQ_TYPE_STANDARD, Target);\r
  DevReq.Request      = USB_REQ_CLEAR_FEATURE;\r
  DevReq.Value        = Feature;\r
  DevReq.Index        = Index;\r
  DevReq.Length       = 0;\r
\r
  Status = UsbIo->UsbControlTransfer (\r
                    UsbIo,\r
                    &DevReq,\r
                    EfiUsbNoData,\r
                    USB_CLEAR_FEATURE_REQUEST_TIMEOUT,\r
                    NULL,\r
                    0,\r
                    &UsbResult\r
                    );\r
\r
  return Status;\r
}\r