[mirror_edk2.git] / ShellPkg / Library / UefiShellCommandLib / ConsistMapping.c

/** @file\r
  Main file for support of shell consist mapping.\r
\r
  Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
**/\r
\r
#include "UefiShellCommandLib.h"\r
#include <Library/DevicePathLib.h>\r
#include <Library/SortLib.h>\r
#include <Library/UefiLib.h>\r
#include <Protocol/UsbIo.h>\r
#include <Protocol/BlockIo.h>\r
#include <Protocol/SimpleFileSystem.h>\r
\r
\r
\r
typedef enum {\r
  MTDTypeUnknown,\r
  MTDTypeFloppy,\r
  MTDTypeHardDisk,\r
  MTDTypeCDRom,\r
  MTDTypeEnd\r
} MTD_TYPE;\r
\r
typedef struct {\r
  CHAR16  *Str;\r
  UINTN   Len;\r
} POOL_PRINT;\r
\r
typedef struct {\r
  UINTN       Hi;\r
  MTD_TYPE    Mtd;\r
  POOL_PRINT  Csd;\r
  BOOLEAN     Digital;\r
} DEVICE_CONSIST_MAPPING_INFO;\r
\r
typedef struct {\r
  MTD_TYPE  MTDType;\r
  CHAR16    *Name;\r
} MTD_NAME;\r
\r
/**\r
  Serial Decode function.\r
\r
  @param  DevPath          The Device path info.\r
  @param  MapInfo          The map info.\r
  @param  OrigDevPath      The original device path protocol.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
typedef\r
EFI_STATUS\r
(*SERIAL_DECODE_FUNCTION) (\r
  EFI_DEVICE_PATH_PROTOCOL    *DevPath,\r
  DEVICE_CONSIST_MAPPING_INFO *MapInfo,\r
  EFI_DEVICE_PATH_PROTOCOL    *OrigDevPath\r
  );\r
\r
typedef struct {\r
  UINT8 Type;\r
  UINT8 SubType;\r
  SERIAL_DECODE_FUNCTION SerialFun;\r
  INTN (EFIAPI *CompareFun) (EFI_DEVICE_PATH_PROTOCOL *DevPath, EFI_DEVICE_PATH_PROTOCOL *DevPath2);\r
} DEV_PATH_CONSIST_MAPPING_TABLE;\r
\r
\r
/**\r
  Concatenates a formatted unicode string to allocated pool.\r
  The caller must free the resulting buffer.\r
\r
  @param  Str      Tracks the allocated pool, size in use, and amount of pool allocated.\r
  @param  Fmt      The format string\r
  @param  ...      The data will be printed.\r
\r
  @retval EFI_SUCCESS          The string is concatenated successfully.\r
  @retval EFI_OUT_OF_RESOURCES Out of resources.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
CatPrint (\r
  IN OUT POOL_PRINT   *Str,\r
  IN CHAR16           *Fmt,\r
  ...\r
  )\r
{\r
  UINT16  *AppendStr;\r
  VA_LIST Args;\r
  UINTN   StringSize;\r
  CHAR16  *NewStr;\r
\r
  AppendStr = AllocateZeroPool (0x1000);\r
  if (AppendStr == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  VA_START (Args, Fmt);\r
  UnicodeVSPrint (AppendStr, 0x1000, Fmt, Args);\r
  VA_END (Args);\r
  if (NULL == Str->Str) {\r
    StringSize = StrSize (AppendStr);\r
    NewStr = AllocateZeroPool (StringSize);\r
  } else {\r
    StringSize = StrSize (AppendStr);\r
    StringSize += (StrSize (Str->Str) - sizeof (UINT16));\r
\r
    NewStr = ReallocatePool (\r
               StrSize (Str->Str),\r
               StringSize,\r
               Str->Str\r
               );\r
  }\r
  if (NewStr == NULL) {\r
    FreePool (AppendStr);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Str->Str = NewStr;\r
  StrCatS (Str->Str, StringSize/sizeof(CHAR16), AppendStr);\r
  Str->Len = StringSize;\r
\r
  FreePool (AppendStr);\r
  return EFI_SUCCESS;\r
}\r
\r
MTD_NAME  mMTDName[] = {\r
  {\r
    MTDTypeUnknown,\r
    L"F"\r
  },\r
  {\r
    MTDTypeFloppy,\r
    L"FP"\r
  },\r
  {\r
    MTDTypeHardDisk,\r
    L"HD"\r
  },\r
  {\r
    MTDTypeCDRom,\r
    L"CD"\r
  },\r
  {\r
    MTDTypeEnd,\r
    NULL\r
  }\r
};\r
\r
/**\r
  Function to append a 64 bit number / 25 onto the string.\r
\r
  @param[in, out] Str          The string so append onto.\r
  @param[in]      Num          The number to divide and append.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
AppendCSDNum2 (\r
  IN OUT POOL_PRINT       *Str,\r
  IN UINT64               Num\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINT64     Result;\r
  UINT32     Rem;\r
\r
  ASSERT (Str != NULL);\r
\r
  Result = DivU64x32Remainder (Num, 25, &Rem);\r
  if (Result > 0) {\r
    Status = AppendCSDNum2 (Str, Result);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  return CatPrint (Str, L"%c", Rem + 'a');\r
}\r
\r
/**\r
  Function to append a 64 bit number onto the mapping info.\r
\r
  @param[in, out] MappingItem  The mapping info object to append onto.\r
  @param[in]      Num          The info to append.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
\r
**/\r
EFI_STATUS\r
AppendCSDNum (\r
  IN OUT DEVICE_CONSIST_MAPPING_INFO            *MappingItem,\r
  IN     UINT64                                 Num\r
  )\r
{\r
  EFI_STATUS Status;\r
  ASSERT (MappingItem != NULL);\r
\r
  if (MappingItem->Digital) {\r
    Status = CatPrint (&MappingItem->Csd, L"%ld", Num);\r
  } else {\r
    Status = AppendCSDNum2 (&MappingItem->Csd, Num);\r
  }\r
\r
  if (!EFI_ERROR (Status)) {\r
    MappingItem->Digital = (BOOLEAN) !(MappingItem->Digital);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Function to append string into the mapping info.\r
\r
  @param[in, out] MappingItem  The mapping info object to append onto.\r
  @param[in]      Str          The info to append.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
AppendCSDStr (\r
  IN OUT DEVICE_CONSIST_MAPPING_INFO            *MappingItem,\r
  IN     CHAR16                                 *Str\r
  )\r
{\r
  CHAR16     *Index;\r
  EFI_STATUS Status;\r
\r
  ASSERT (Str != NULL && MappingItem != NULL);\r
\r
  Status = EFI_SUCCESS;\r
\r
  if (MappingItem->Digital) {\r
    //\r
    // To aVOID mult-meaning, the mapping is:\r
    //  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r
    //  0  16 2  3  4  5  6  7  8  9  10 11 12 13 14 15\r
    //\r
    for (Index = Str; *Index != 0; Index++) {\r
      switch (*Index) {\r
      case '0':\r
      case '2':\r
      case '3':\r
      case '4':\r
      case '5':\r
      case '6':\r
      case '7':\r
      case '8':\r
      case '9':\r
        Status = CatPrint (&MappingItem->Csd, L"%c", *Index);\r
        break;\r
\r
      case '1':\r
        Status = CatPrint (&MappingItem->Csd, L"16");\r
        break;\r
\r
      case 'a':\r
      case 'b':\r
      case 'c':\r
      case 'd':\r
      case 'e':\r
      case 'f':\r
        Status = CatPrint (&MappingItem->Csd, L"1%c", *Index - 'a' + '0');\r
        break;\r
\r
      case 'A':\r
      case 'B':\r
      case 'C':\r
      case 'D':\r
      case 'E':\r
      case 'F':\r
        Status = CatPrint (&MappingItem->Csd, L"1%c", *Index - 'A' + '0');\r
        break;\r
      }\r
\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
    }\r
  } else {\r
    for (Index = Str; *Index != 0; Index++) {\r
      //\r
      //  The mapping is:\r
      //  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r
      //  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p\r
      //\r
      if (*Index >= '0' && *Index <= '9') {\r
        Status = CatPrint (&MappingItem->Csd, L"%c", *Index - '0' + 'a');\r
      } else if (*Index >= 'a' && *Index <= 'f') {\r
        Status = CatPrint (&MappingItem->Csd, L"%c", *Index - 'a' + 'k');\r
      } else if (*Index >= 'A' && *Index <= 'F') {\r
        Status = CatPrint (&MappingItem->Csd, L"%c", *Index - 'A' + 'k');\r
      }\r
\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
    }\r
  }\r
\r
  MappingItem->Digital = (BOOLEAN)!(MappingItem->Digital);\r
\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  Function to append a Guid to the mapping item.\r
\r
  @param[in, out] MappingItem  The item to append onto.\r
  @param[in]      Guid         The guid to append.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
AppendCSDGuid (\r
  DEVICE_CONSIST_MAPPING_INFO            *MappingItem,\r
  EFI_GUID                               *Guid\r
  )\r
{\r
  CHAR16  Buffer[64];\r
\r
  ASSERT (Guid != NULL && MappingItem != NULL);\r
\r
  UnicodeSPrint (\r
    Buffer,\r
    0,\r
    L"%g",\r
    Guid\r
   );\r
\r
  return AppendCSDStr (MappingItem, Buffer);\r
}\r
\r
/**\r
  Function to compare 2 APCI device paths.\r
\r
  @param[in] DevicePath1        The first device path to compare.\r
  @param[in] DevicePath2        The second device path to compare.\r
\r
  @retval 0 The device paths represent the same device.\r
  @return   Non zero if the devices are different, zero otherwise.\r
**/\r
INTN\r
EFIAPI\r
DevPathCompareAcpi (\r
  IN EFI_DEVICE_PATH_PROTOCOL       *DevicePath1,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *DevicePath2\r
  )\r
{\r
  ACPI_HID_DEVICE_PATH  *Acpi1;\r
  ACPI_HID_DEVICE_PATH  *Acpi2;\r
\r
  if (DevicePath1 == NULL || DevicePath2 == NULL) {\r
    return (-2);\r
  }\r
\r
  Acpi1 = (ACPI_HID_DEVICE_PATH *) DevicePath1;\r
  Acpi2 = (ACPI_HID_DEVICE_PATH *) DevicePath2;\r
  if (Acpi1->HID > Acpi2->HID || (Acpi1->HID == Acpi2->HID && Acpi1->UID > Acpi2->UID)) {\r
    return 1;\r
  }\r
\r
  if (Acpi1->HID == Acpi2->HID && Acpi1->UID == Acpi2->UID) {\r
    return 0;\r
  }\r
\r
  return -1;\r
}\r
\r
/**\r
  Function to compare 2 PCI device paths.\r
\r
  @param[in] DevicePath1        The first device path to compare.\r
  @param[in] DevicePath2        The second device path to compare.\r
\r
  @retval 0 The device paths represent the same device.\r
  @return   Non zero if the devices are different, zero otherwise.\r
**/\r
INTN\r
EFIAPI\r
DevPathComparePci (\r
  IN EFI_DEVICE_PATH_PROTOCOL       *DevicePath1,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *DevicePath2\r
  )\r
{\r
  PCI_DEVICE_PATH *Pci1;\r
  PCI_DEVICE_PATH *Pci2;\r
\r
  ASSERT(DevicePath1 != NULL);\r
  ASSERT(DevicePath2 != NULL);\r
\r
  Pci1  = (PCI_DEVICE_PATH *) DevicePath1;\r
  Pci2  = (PCI_DEVICE_PATH *) DevicePath2;\r
  if (Pci1->Device > Pci2->Device || (Pci1->Device == Pci2->Device && Pci1->Function > Pci2->Function)) {\r
    return 1;\r
  }\r
\r
  if (Pci1->Device == Pci2->Device && Pci1->Function == Pci2->Function) {\r
    return 0;\r
  }\r
\r
  return -1;\r
}\r
\r
/**\r
  Do a comparison on 2 device paths.\r
\r
  @param[in] DevicePath1   The first device path.\r
  @param[in] DevicePath2   The second device path.\r
\r
  @retval 0 The 2 device paths are the same.\r
  @retval <0  DevicePath2 is greater than DevicePath1.\r
  @retval >0  DevicePath1 is greater than DevicePath2.\r
**/\r
INTN\r
EFIAPI\r
DevPathCompareDefault (\r
  IN EFI_DEVICE_PATH_PROTOCOL       *DevicePath1,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *DevicePath2\r
  )\r
{\r
  UINTN DevPathSize1;\r
  UINTN DevPathSize2;\r
\r
  ASSERT(DevicePath1 != NULL);\r
  ASSERT(DevicePath2 != NULL);\r
\r
  DevPathSize1  = DevicePathNodeLength (DevicePath1);\r
  DevPathSize2  = DevicePathNodeLength (DevicePath2);\r
  if (DevPathSize1 > DevPathSize2) {\r
    return 1;\r
  } else if (DevPathSize1 < DevPathSize2) {\r
    return -1;\r
  } else {\r
    return CompareMem (DevicePath1, DevicePath2, DevPathSize1);\r
  }\r
}\r
\r
/**\r
  DevicePathNode must be SerialHDD Channel type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialHardDrive (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  HARDDRIVE_DEVICE_PATH *Hd;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Hd = (HARDDRIVE_DEVICE_PATH *) DevicePathNode;\r
  if (MappingItem->Mtd == MTDTypeUnknown) {\r
    MappingItem->Mtd = MTDTypeHardDisk;\r
  }\r
\r
  return AppendCSDNum (MappingItem, Hd->PartitionNumber);\r
}\r
\r
/**\r
  DevicePathNode must be SerialAtapi Channel type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialAtapi (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  ATAPI_DEVICE_PATH *Atapi;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Atapi = (ATAPI_DEVICE_PATH *) DevicePathNode;\r
  return AppendCSDNum (MappingItem, (Atapi->PrimarySecondary * 2 + Atapi->SlaveMaster));\r
}\r
\r
/**\r
  DevicePathNode must be SerialCDROM Channel type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialCdRom (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  CDROM_DEVICE_PATH *Cd;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Cd                = (CDROM_DEVICE_PATH *) DevicePathNode;\r
  MappingItem->Mtd  = MTDTypeCDRom;\r
  return AppendCSDNum (MappingItem, Cd->BootEntry);\r
}\r
\r
/**\r
  DevicePathNode must be SerialFibre Channel type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialFibre (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  FIBRECHANNEL_DEVICE_PATH  *Fibre;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Fibre = (FIBRECHANNEL_DEVICE_PATH *) DevicePathNode;\r
  Status = AppendCSDNum (MappingItem, Fibre->WWN);\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Fibre->Lun);\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be SerialUart type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialUart (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  UART_DEVICE_PATH          *Uart;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Uart = (UART_DEVICE_PATH *) DevicePathNode;\r
  Status = AppendCSDNum (MappingItem, Uart->BaudRate);\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Uart->DataBits);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Uart->Parity);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Uart->StopBits);\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be SerialUSB type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialUsb (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  USB_DEVICE_PATH           *Usb;\r
  EFI_USB_IO_PROTOCOL       *UsbIo;\r
  EFI_HANDLE                TempHandle;\r
  EFI_STATUS                Status;\r
  USB_INTERFACE_DESCRIPTOR  InterfaceDesc;\r
\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Usb = (USB_DEVICE_PATH *) DevicePathNode;\r
  Status = AppendCSDNum (MappingItem, Usb->ParentPortNumber);\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Usb->InterfaceNumber);\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (PcdGetBool(PcdUsbExtendedDecode)) {\r
    Status = gBS->LocateDevicePath( &gEfiUsbIoProtocolGuid, &DevicePath, &TempHandle );\r
    UsbIo = NULL;\r
    if (!EFI_ERROR(Status)) {\r
      Status = gBS->OpenProtocol(TempHandle, &gEfiUsbIoProtocolGuid, (VOID**)&UsbIo, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
    }\r
\r
    if (!EFI_ERROR(Status)) {\r
      ASSERT(UsbIo != NULL);\r
      Status = UsbIo->UsbGetInterfaceDescriptor(UsbIo, &InterfaceDesc);\r
      if (!EFI_ERROR(Status)) {\r
        if (InterfaceDesc.InterfaceClass == USB_MASS_STORE_CLASS && MappingItem->Mtd == MTDTypeUnknown) {\r
          switch (InterfaceDesc.InterfaceSubClass){\r
            case USB_MASS_STORE_SCSI:\r
              MappingItem->Mtd = MTDTypeHardDisk;\r
              break;\r
            case USB_MASS_STORE_8070I:\r
            case USB_MASS_STORE_UFI:\r
              MappingItem->Mtd = MTDTypeFloppy;\r
              break;\r
            case USB_MASS_STORE_8020I:\r
              MappingItem->Mtd  = MTDTypeCDRom;\r
              break;\r
          }\r
        }\r
      }\r
    }\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be SerialVendor type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialVendor (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS          Status;\r
  VENDOR_DEVICE_PATH  *Vendor;\r
  SAS_DEVICE_PATH     *Sas;\r
  UINTN               TargetNameLength;\r
  UINTN               Index;\r
  CHAR16              *Buffer;\r
  CHAR16              *NewBuffer;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Vendor = (VENDOR_DEVICE_PATH *) DevicePathNode;\r
  Status = AppendCSDGuid (MappingItem, &Vendor->Guid);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (CompareGuid (&gEfiSasDevicePathGuid, &Vendor->Guid)) {\r
    Sas = (SAS_DEVICE_PATH *) Vendor;\r
    Status = AppendCSDNum (MappingItem, Sas->SasAddress);\r
    if (!EFI_ERROR (Status)) {\r
      Status = AppendCSDNum (MappingItem, Sas->Lun);\r
    }\r
    if (!EFI_ERROR (Status)) {\r
      Status = AppendCSDNum (MappingItem, Sas->DeviceTopology);\r
    }\r
    if (!EFI_ERROR (Status)) {\r
      Status = AppendCSDNum (MappingItem, Sas->RelativeTargetPort);\r
    }\r
  } else {\r
    TargetNameLength = MIN(DevicePathNodeLength (DevicePathNode) - sizeof (VENDOR_DEVICE_PATH), PcdGet32(PcdShellVendorExtendedDecode));\r
    if (TargetNameLength != 0) {\r
      //\r
      // String is 2 chars per data byte, plus NULL terminator\r
      //\r
      Buffer = AllocateZeroPool (((TargetNameLength * 2) + 1) * sizeof(CHAR16));\r
      if (Buffer == NULL) {\r
        return EFI_OUT_OF_RESOURCES;\r
      }\r
\r
      //\r
      // Build the string data\r
      //\r
      for (Index = 0; Index < TargetNameLength; Index++) {\r
        NewBuffer = CatSPrint (Buffer, L"%02x", *((UINT8*)Vendor + sizeof (VENDOR_DEVICE_PATH) + Index));\r
        if (NewBuffer == NULL) {\r
          Status = EFI_OUT_OF_RESOURCES;\r
          break;\r
        }\r
        Buffer = NewBuffer;\r
      }\r
\r
      //\r
      // Append the new data block\r
      //\r
      if (!EFI_ERROR (Status)) {\r
        Status = AppendCSDStr (MappingItem, Buffer);\r
      }\r
\r
      FreePool(Buffer);\r
    }\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be SerialLun type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialLun (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  DEVICE_LOGICAL_UNIT_DEVICE_PATH *Lun;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Lun = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *) DevicePathNode;\r
  return AppendCSDNum (MappingItem, Lun->Lun);\r
}\r
\r
/**\r
  DevicePathNode must be SerialSata type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialSata (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS        Status;\r
  SATA_DEVICE_PATH  *Sata;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Sata = (SATA_DEVICE_PATH  *) DevicePathNode;\r
  Status = AppendCSDNum (MappingItem, Sata->HBAPortNumber);\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Sata->PortMultiplierPortNumber);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Sata->Lun);\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be SerialSCSI type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialIScsi (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS         Status;\r
  ISCSI_DEVICE_PATH  *IScsi;\r
  UINT8              *IScsiTargetName;\r
  CHAR16             *TargetName;\r
  UINTN              TargetNameLength;\r
  UINTN              Index;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Status = EFI_SUCCESS;\r
\r
  if (PcdGetBool(PcdShellDecodeIScsiMapNames)) {\r
    IScsi = (ISCSI_DEVICE_PATH  *) DevicePathNode;\r
    Status = AppendCSDNum (MappingItem, IScsi->NetworkProtocol);\r
    if (!EFI_ERROR (Status)) {\r
      Status = AppendCSDNum (MappingItem, IScsi->LoginOption);\r
    }\r
    if (!EFI_ERROR (Status)) {\r
      Status = AppendCSDNum (MappingItem, IScsi->Lun);\r
    }\r
    if (!EFI_ERROR (Status)) {\r
      Status = AppendCSDNum (MappingItem, IScsi->TargetPortalGroupTag);\r
    }\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
    TargetNameLength = DevicePathNodeLength (DevicePathNode) - sizeof (ISCSI_DEVICE_PATH);\r
    if (TargetNameLength > 0) {\r
      TargetName = AllocateZeroPool ((TargetNameLength + 1) * sizeof (CHAR16));\r
      if (TargetName == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
      } else {\r
        IScsiTargetName = (UINT8 *) (IScsi + 1);\r
        for (Index = 0; Index < TargetNameLength; Index++) {\r
          TargetName[Index] = (CHAR16) IScsiTargetName[Index];\r
        }\r
        Status = AppendCSDStr (MappingItem, TargetName);\r
        FreePool (TargetName);\r
      }\r
    }\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be SerialI20 type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialI2O (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  I2O_DEVICE_PATH *DevicePath_I20;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  DevicePath_I20 = (I2O_DEVICE_PATH *) DevicePathNode;\r
  return AppendCSDNum (MappingItem, DevicePath_I20->Tid);\r
}\r
\r
/**\r
  DevicePathNode must be Mac Address type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialMacAddr (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  MAC_ADDR_DEVICE_PATH  *Mac;\r
  UINTN                 HwAddressSize;\r
  UINTN                 Index;\r
  CHAR16                Buffer[64];\r
  CHAR16                *PBuffer;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Mac           = (MAC_ADDR_DEVICE_PATH *) DevicePathNode;\r
\r
  HwAddressSize = sizeof (EFI_MAC_ADDRESS);\r
  if (Mac->IfType == 0x01 || Mac->IfType == 0x00) {\r
    HwAddressSize = 6;\r
  }\r
\r
  for (Index = 0, PBuffer = Buffer; Index < HwAddressSize; Index++, PBuffer += 2) {\r
    UnicodeSPrint (PBuffer, 0, L"%02x", (UINTN) Mac->MacAddress.Addr[Index]);\r
  }\r
\r
  return AppendCSDStr (MappingItem, Buffer);\r
}\r
\r
/**\r
  DevicePathNode must be InfiniBand type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialInfiniBand (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS              Status;\r
  INFINIBAND_DEVICE_PATH  *InfiniBand;\r
  UINTN                   Index;\r
  CHAR16                  Buffer[64];\r
  CHAR16                  *PBuffer;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  InfiniBand = (INFINIBAND_DEVICE_PATH *) DevicePathNode;\r
  for (Index = 0, PBuffer = Buffer; Index < 16; Index++, PBuffer += 2) {\r
    UnicodeSPrint (PBuffer, 0, L"%02x", (UINTN) InfiniBand->PortGid[Index]);\r
  }\r
\r
  Status = AppendCSDStr (MappingItem, Buffer);\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, InfiniBand->ServiceId);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, InfiniBand->TargetPortId);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, InfiniBand->DeviceId);\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be IPv4 type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialIPv4 (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS        Status;\r
  IPv4_DEVICE_PATH  *Ip;\r
  CHAR16            Buffer[10];\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Ip = (IPv4_DEVICE_PATH *) DevicePathNode;\r
  UnicodeSPrint (\r
    Buffer,\r
    0,\r
    L"%02x%02x%02x%02x",\r
    (UINTN) Ip->LocalIpAddress.Addr[0],\r
    (UINTN) Ip->LocalIpAddress.Addr[1],\r
    (UINTN) Ip->LocalIpAddress.Addr[2],\r
    (UINTN) Ip->LocalIpAddress.Addr[3]\r
   );\r
  Status = AppendCSDStr (MappingItem, Buffer);\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Ip->LocalPort);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    UnicodeSPrint (\r
      Buffer,\r
      0,\r
      L"%02x%02x%02x%02x",\r
      (UINTN) Ip->RemoteIpAddress.Addr[0],\r
      (UINTN) Ip->RemoteIpAddress.Addr[1],\r
      (UINTN) Ip->RemoteIpAddress.Addr[2],\r
      (UINTN) Ip->RemoteIpAddress.Addr[3]\r
     );\r
    Status = AppendCSDStr (MappingItem, Buffer);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Ip->RemotePort);\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be IPv6 type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialIPv6 (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS        Status;\r
  IPv6_DEVICE_PATH  *Ip;\r
  UINTN             Index;\r
  CHAR16            Buffer[64];\r
  CHAR16            *PBuffer;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Ip = (IPv6_DEVICE_PATH *) DevicePathNode;\r
  for (Index = 0, PBuffer = Buffer; Index < 16; Index++, PBuffer += 2) {\r
    UnicodeSPrint (PBuffer, 0, L"%02x", (UINTN) Ip->LocalIpAddress.Addr[Index]);\r
  }\r
\r
  Status = AppendCSDStr (MappingItem, Buffer);\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Ip->LocalPort);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    for (Index = 0, PBuffer = Buffer; Index < 16; Index++, PBuffer += 2) {\r
      UnicodeSPrint (PBuffer, 0, L"%02x", (UINTN) Ip->RemoteIpAddress.Addr[Index]);\r
    }\r
\r
    Status = AppendCSDStr (MappingItem, Buffer);\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Ip->RemotePort);\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be SCSI type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialScsi (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  EFI_STATUS        Status;\r
  SCSI_DEVICE_PATH  *Scsi;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Scsi = (SCSI_DEVICE_PATH *) DevicePathNode;\r
  Status = AppendCSDNum (MappingItem, Scsi->Pun);\r
  if (!EFI_ERROR (Status)) {\r
    Status = AppendCSDNum (MappingItem, Scsi->Lun);\r
  }\r
  return Status;\r
}\r
\r
/**\r
  DevicePathNode must be 1394 type and this will populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerial1394 (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  F1394_DEVICE_PATH *DevicePath_F1394;\r
  CHAR16            Buffer[20];\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  DevicePath_F1394 = (F1394_DEVICE_PATH *) DevicePathNode;\r
  UnicodeSPrint (Buffer, 0, L"%lx", DevicePath_F1394->Guid);\r
  return AppendCSDStr (MappingItem, Buffer);\r
}\r
\r
/**\r
  If the node is floppy type then populate the MappingItem.\r
\r
  @param[in] DevicePathNode   The node to get info on.\r
  @param[in] MappingItem      The info item to populate.\r
  @param[in] DevicePath       Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialAcpi (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  ACPI_HID_DEVICE_PATH  *Acpi;\r
\r
  ASSERT(DevicePathNode != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  Acpi = (ACPI_HID_DEVICE_PATH *) DevicePathNode;\r
  if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {\r
    if (EISA_ID_TO_NUM (Acpi->HID) == 0x0604) {\r
      MappingItem->Mtd = MTDTypeFloppy;\r
      return AppendCSDNum (MappingItem, Acpi->UID);\r
    }\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Empty function used for unknown devices.\r
\r
  @param[in] DevicePathNode       Ignored.\r
  @param[in] MappingItem          Ignored.\r
  @param[in] DevicePath           Ignored.\r
\r
  @retval EFI_OUT_OF_RESOURCES    Out of resources.\r
  @retval EFI_SUCCESS             The appending was successful.\r
**/\r
EFI_STATUS\r
DevPathSerialDefault (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,\r
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
DEV_PATH_CONSIST_MAPPING_TABLE  DevPathConsistMappingTable[] = {\r
  {\r
    HARDWARE_DEVICE_PATH,\r
    HW_PCI_DP,\r
    DevPathSerialDefault,\r
    DevPathComparePci\r
  },\r
  {\r
    ACPI_DEVICE_PATH,\r
    ACPI_DP,\r
    DevPathSerialAcpi,\r
    DevPathCompareAcpi\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_ATAPI_DP,\r
    DevPathSerialAtapi,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_SCSI_DP,\r
    DevPathSerialScsi,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_FIBRECHANNEL_DP,\r
    DevPathSerialFibre,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_1394_DP,\r
    DevPathSerial1394,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_USB_DP,\r
    DevPathSerialUsb,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_I2O_DP,\r
    DevPathSerialI2O,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_MAC_ADDR_DP,\r
    DevPathSerialMacAddr,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_IPv4_DP,\r
    DevPathSerialIPv4,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_IPv6_DP,\r
    DevPathSerialIPv6,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_INFINIBAND_DP,\r
    DevPathSerialInfiniBand,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_UART_DP,\r
    DevPathSerialUart,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_VENDOR_DP,\r
    DevPathSerialVendor,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_DEVICE_LOGICAL_UNIT_DP,\r
    DevPathSerialLun,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_SATA_DP,\r
    DevPathSerialSata,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MESSAGING_DEVICE_PATH,\r
    MSG_ISCSI_DP,\r
    DevPathSerialIScsi,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MEDIA_DEVICE_PATH,\r
    MEDIA_HARDDRIVE_DP,\r
    DevPathSerialHardDrive,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MEDIA_DEVICE_PATH,\r
    MEDIA_CDROM_DP,\r
    DevPathSerialCdRom,\r
    DevPathCompareDefault\r
  },\r
  {\r
    MEDIA_DEVICE_PATH,\r
    MEDIA_VENDOR_DP,\r
    DevPathSerialVendor,\r
    DevPathCompareDefault\r
  },\r
  {\r
    0,\r
    0,\r
    NULL,\r
    NULL\r
  }\r
};\r
\r
/**\r
  Function to determine if a device path node is Hi or not.\r
\r
  @param[in] DevicePathNode   The node to check.\r
\r
  @retval TRUE    The node is Hi.\r
  @retval FALSE   The node is not Hi.\r
**/\r
BOOLEAN\r
IsHIDevicePathNode (\r
  IN EFI_DEVICE_PATH_PROTOCOL *DevicePathNode\r
  )\r
{\r
  ACPI_HID_DEVICE_PATH  *Acpi;\r
\r
  ASSERT(DevicePathNode != NULL);\r
\r
  if (DevicePathNode->Type == HARDWARE_DEVICE_PATH) {\r
    return TRUE;\r
  }\r
\r
  if (DevicePathNode->Type == ACPI_DEVICE_PATH) {\r
    Acpi = (ACPI_HID_DEVICE_PATH *) DevicePathNode;\r
    switch (EISA_ID_TO_NUM (Acpi->HID)) {\r
    case 0x0301:\r
    case 0x0401:\r
    case 0x0501:\r
    case 0x0604:\r
      return FALSE;\r
    }\r
\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Function to convert a standard device path structure into a Hi version.\r
\r
  @param[in] DevicePath   The device path to convert.\r
\r
  @return   the device path portion that is Hi.\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
GetHIDevicePath (\r
  IN EFI_DEVICE_PATH_PROTOCOL        *DevicePath\r
  )\r
{\r
  UINTN                     NonHIDevicePathNodeCount;\r
  UINTN                     Index;\r
  EFI_DEV_PATH              Node;\r
  EFI_DEVICE_PATH_PROTOCOL  *HIDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;\r
\r
  ASSERT(DevicePath != NULL);\r
\r
  NonHIDevicePathNodeCount  = 0;\r
\r
  HIDevicePath              = AllocateZeroPool (sizeof (EFI_DEVICE_PATH_PROTOCOL));\r
  SetDevicePathEndNode (HIDevicePath);\r
\r
  Node.DevPath.Type       = END_DEVICE_PATH_TYPE;\r
  Node.DevPath.SubType    = END_INSTANCE_DEVICE_PATH_SUBTYPE;\r
  Node.DevPath.Length[0]  = (UINT8)sizeof (EFI_DEVICE_PATH_PROTOCOL);\r
  Node.DevPath.Length[1]  = 0;\r
\r
  while (!IsDevicePathEnd (DevicePath)) {\r
    if (IsHIDevicePathNode (DevicePath)) {\r
      for (Index = 0; Index < NonHIDevicePathNodeCount; Index++) {\r
        TempDevicePath = AppendDevicePathNode (HIDevicePath, &Node.DevPath);\r
        FreePool (HIDevicePath);\r
        HIDevicePath = TempDevicePath;\r
      }\r
\r
      TempDevicePath = AppendDevicePathNode (HIDevicePath, DevicePath);\r
      FreePool (HIDevicePath);\r
      HIDevicePath = TempDevicePath;\r
    } else {\r
      NonHIDevicePathNodeCount++;\r
    }\r
    //\r
    // Next device path node\r
    //\r
    DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) NextDevicePathNode (DevicePath);\r
  }\r
\r
  return HIDevicePath;\r
}\r
\r
/**\r
  Function to walk the device path looking for a dumpable node.\r
\r
  @param[in] MappingItem      The Item to fill with data.\r
  @param[in] DevicePath       The path of the item to get data on.\r
\r
  @return EFI_SUCCESS         Always returns success.\r
**/\r
EFI_STATUS\r
GetDeviceConsistMappingInfo (\r
  IN DEVICE_CONSIST_MAPPING_INFO    *MappingItem,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *DevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  SERIAL_DECODE_FUNCTION    SerialFun;\r
  UINTN                     Index;\r
  EFI_DEVICE_PATH_PROTOCOL  *OriginalDevicePath;\r
\r
  ASSERT(DevicePath != NULL);\r
  ASSERT(MappingItem != NULL);\r
\r
  SetMem (&MappingItem->Csd, sizeof (POOL_PRINT), 0);\r
  OriginalDevicePath = DevicePath;\r
\r
  while (!IsDevicePathEnd (DevicePath)) {\r
    //\r
    // Find the handler to dump this device path node and\r
    // initialize with generic function in case nothing is found\r
    //\r
    for (SerialFun = DevPathSerialDefault, Index = 0; DevPathConsistMappingTable[Index].SerialFun != NULL; Index += 1) {\r
\r
      if (DevicePathType (DevicePath) == DevPathConsistMappingTable[Index].Type &&\r
          DevicePathSubType (DevicePath) == DevPathConsistMappingTable[Index].SubType\r
         ) {\r
        SerialFun = DevPathConsistMappingTable[Index].SerialFun;\r
        break;\r
      }\r
    }\r
\r
    Status = SerialFun (DevicePath, MappingItem, OriginalDevicePath);\r
    if (EFI_ERROR (Status)) {\r
      SHELL_FREE_NON_NULL (MappingItem->Csd.Str);\r
      return Status;\r
    }\r
\r
    //\r
    // Next device path node\r
    //\r
    DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) NextDevicePathNode (DevicePath);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Function to initialize the table for creating consistent map names.\r
\r
  @param[out] Table             The pointer to pointer to pointer to DevicePathProtocol object.\r
\r
  @retval EFI_SUCCESS           The table was created successfully.\r
**/\r
EFI_STATUS\r
EFIAPI\r
ShellCommandConsistMappingInitialize (\r
  OUT EFI_DEVICE_PATH_PROTOCOL           ***Table\r
  )\r
{\r
  EFI_HANDLE                      *HandleBuffer;\r
  UINTN                           HandleNum;\r
  UINTN                           HandleLoop;\r
  EFI_DEVICE_PATH_PROTOCOL        **TempTable;\r
  EFI_DEVICE_PATH_PROTOCOL        *DevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL        *HIDevicePath;\r
  EFI_BLOCK_IO_PROTOCOL           *BlockIo;\r
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFileSystem;\r
  UINTN                           Index;\r
  EFI_STATUS                      Status;\r
\r
  HandleBuffer              = NULL;\r
\r
  Status = gBS->LocateHandleBuffer (\r
              ByProtocol,\r
              &gEfiDevicePathProtocolGuid,\r
              NULL,\r
              &HandleNum,\r
              &HandleBuffer\r
             );\r
  ASSERT_EFI_ERROR(Status);\r
\r
  TempTable     = AllocateZeroPool ((HandleNum + 1) * sizeof (EFI_DEVICE_PATH_PROTOCOL *));\r
  if (TempTable == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  for (HandleLoop = 0 ; HandleLoop < HandleNum ; HandleLoop++) {\r
    DevicePath = DevicePathFromHandle (HandleBuffer[HandleLoop]);\r
    if (DevicePath == NULL) {\r
      continue;\r
    }\r
\r
    HIDevicePath = GetHIDevicePath (DevicePath);\r
    if (HIDevicePath == NULL) {\r
      continue;\r
    }\r
\r
    Status = gBS->HandleProtocol( HandleBuffer[HandleLoop],\r
                                  &gEfiBlockIoProtocolGuid,\r
                                  (VOID **)&BlockIo\r
                                  );\r
    if (EFI_ERROR(Status)) {\r
      Status = gBS->HandleProtocol( HandleBuffer[HandleLoop],\r
                                    &gEfiSimpleFileSystemProtocolGuid,\r
                                    (VOID **)&SimpleFileSystem\r
                                    );\r
      if (EFI_ERROR(Status)) {\r
        FreePool (HIDevicePath);\r
        continue;\r
      }\r
    }\r
\r
    for (Index = 0; TempTable[Index] != NULL; Index++) {\r
      if (DevicePathCompare (&TempTable[Index], &HIDevicePath) == 0) {\r
        FreePool (HIDevicePath);\r
        break;\r
      }\r
    }\r
\r
    if (TempTable[Index] == NULL) {\r
      TempTable[Index] = HIDevicePath;\r
    }\r
  }\r
\r
  for (Index = 0; TempTable[Index] != NULL; Index++);\r
  PerformQuickSort(TempTable, Index, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);\r
  *Table = TempTable;\r
\r
  if (HandleBuffer != NULL) {\r
    FreePool (HandleBuffer);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Function to uninitialize the table for creating consistent map names.\r
\r
  The parameter must have been received from ShellCommandConsistMappingInitialize.\r
\r
  @param[out] Table             The pointer to pointer to DevicePathProtocol object.\r
\r
  @retval EFI_SUCCESS           The table was deleted successfully.\r
**/\r
EFI_STATUS\r
EFIAPI\r
ShellCommandConsistMappingUnInitialize (\r
  EFI_DEVICE_PATH_PROTOCOL **Table\r
  )\r
{\r
  UINTN Index;\r
\r
  ASSERT(Table  != NULL);\r
\r
  for (Index = 0; Table[Index] != NULL; Index++) {\r
    FreePool (Table[Index]);\r
  }\r
\r
  FreePool (Table);\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Create a consistent mapped name for the device specified by DevicePath\r
  based on the Table.\r
\r
  This must be called after ShellCommandConsistMappingInitialize() and\r
  before ShellCommandConsistMappingUnInitialize() is called.\r
\r
  @param[in] DevicePath   The pointer to the dev path for the device.\r
  @param[in] Table        The Table of mapping information.\r
\r
  @retval NULL            A consistent mapped name could not be created.\r
  @return                 A pointer to a string allocated from pool with the device name.\r
**/\r
CHAR16 *\r
EFIAPI\r
ShellCommandConsistMappingGenMappingName (\r
  IN EFI_DEVICE_PATH_PROTOCOL    *DevicePath,\r
  IN EFI_DEVICE_PATH_PROTOCOL    **Table\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  POOL_PRINT                  Str;\r
  DEVICE_CONSIST_MAPPING_INFO MappingInfo;\r
  EFI_DEVICE_PATH_PROTOCOL    *HIDevicePath;\r
  UINTN                       Index;\r
\r
  ASSERT(DevicePath         != NULL);\r
  ASSERT(Table  != NULL);\r
\r
  HIDevicePath = GetHIDevicePath (DevicePath);\r
  if (HIDevicePath == NULL) {\r
    return NULL;\r
  }\r
\r
  for (Index = 0; Table[Index] != NULL; Index++) {\r
    if (DevicePathCompare (&Table[Index], &HIDevicePath) == 0) {\r
      break;\r
    }\r
  }\r
\r
  FreePool (HIDevicePath);\r
  if (Table[Index] == NULL) {\r
    return NULL;\r
  }\r
\r
  MappingInfo.Hi      = Index;\r
  MappingInfo.Mtd     = MTDTypeUnknown;\r
  MappingInfo.Digital = FALSE;\r
\r
  Status = GetDeviceConsistMappingInfo (&MappingInfo, DevicePath);\r
  if (EFI_ERROR (Status)) {\r
    return NULL;\r
  }\r
\r
  SetMem (&Str, sizeof (Str), 0);\r
  for (Index = 0; mMTDName[Index].MTDType != MTDTypeEnd; Index++) {\r
    if (MappingInfo.Mtd == mMTDName[Index].MTDType) {\r
      break;\r
    }\r
  }\r
\r
  if (mMTDName[Index].MTDType != MTDTypeEnd) {\r
    Status = CatPrint (&Str, L"%s", mMTDName[Index].Name);\r
  }\r
\r
  if (!EFI_ERROR (Status)) {\r
    Status = CatPrint (&Str, L"%d", (UINTN) MappingInfo.Hi);\r
  }\r
  if (!EFI_ERROR (Status) && MappingInfo.Csd.Str != NULL) {\r
    Status = CatPrint (&Str, L"%s", MappingInfo.Csd.Str);\r
    FreePool (MappingInfo.Csd.Str);\r
  }\r
\r
  if (!EFI_ERROR (Status) && Str.Str != NULL) {\r
    Status = CatPrint (&Str, L":");\r
  }\r
  if (EFI_ERROR (Status)) {\r
    SHELL_FREE_NON_NULL (Str.Str);\r
    return NULL;\r
  }\r
\r
  return Str.Str;\r
}\r
\r
/**\r
  Function to search the list of mappings for the node on the list based on the key.\r
\r
  @param[in] MapKey       String Key to search for on the map\r
\r
  @return the node on the list.\r
**/\r
SHELL_MAP_LIST *\r
EFIAPI\r
ShellCommandFindMapItem (\r
  IN CONST CHAR16 *MapKey\r
  )\r
{\r
  SHELL_MAP_LIST *MapListItem;\r
\r
  for ( MapListItem = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)\r
      ; !IsNull(&gShellMapList.Link, &MapListItem->Link)\r
      ; MapListItem = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &MapListItem->Link)\r
     ){\r
    if (gUnicodeCollation->StriColl(gUnicodeCollation,MapListItem->MapName,(CHAR16*)MapKey) == 0) {\r
      return (MapListItem);\r
    }\r
  }\r
  return (NULL);\r
}\r
\r
\r