ConsistMapping.c

Go to the documentation of this file.

 
#include "UefiShellCommandLib.h"
#include <Library/DevicePathLib.h>
#include <Library/SortLib.h>
#include <Library/UefiLib.h>
#include <Protocol/UsbIo.h>
#include <Protocol/BlockIo.h>
#include <Protocol/SimpleFileSystem.h>
 
typedef enum {
  MTDTypeUnknown,
  MTDTypeFloppy,
  MTDTypeHardDisk,
  MTDTypeCDRom,
  MTDTypeEnd
} MTD_TYPE;
 
typedef struct {
  CHAR16    *Str;
  UINTN     Len;
} POOL_PRINT;
 
typedef struct {
  UINTN         Hi;
  MTD_TYPE      Mtd;
  POOL_PRINT    Csd;
  BOOLEAN       Digital;
} DEVICE_CONSIST_MAPPING_INFO;
 
typedef struct {
  MTD_TYPE    MTDType;
  CHAR16      *Name;
} MTD_NAME;
 
typedef
EFI_STATUS
(*SERIAL_DECODE_FUNCTION) (
  EFI_DEVICE_PATH_PROTOCOL     *DevPath,
  DEVICE_CONSIST_MAPPING_INFO  *MapInfo,
  EFI_DEVICE_PATH_PROTOCOL     *OrigDevPath
  );
 
typedef struct {
  UINT8                     Type;
  UINT8                     SubType;
  SERIAL_DECODE_FUNCTION    SerialFun;
  INTN (EFIAPI *CompareFun)(EFI_DEVICE_PATH_PROTOCOL *DevPath, EFI_DEVICE_PATH_PROTOCOL *DevPath2);
} DEV_PATH_CONSIST_MAPPING_TABLE;
 
EFI_STATUS
EFIAPI
CatPrint (
  IN OUT POOL_PRINT  *Str,
  IN CHAR16          *Fmt,
  ...
  )
{
  UINT16   *AppendStr;
  VA_LIST  Args;
  UINTN    StringSize;
  CHAR16   *NewStr;
 
  AppendStr = AllocateZeroPool (0x1000);
  if (AppendStr == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  VA_START (Args, Fmt);
  UnicodeVSPrint (AppendStr, 0x1000, Fmt, Args);
  VA_END (Args);
  if (NULL == Str->Str) {
    StringSize = StrSize (AppendStr);
    NewStr     = AllocateZeroPool (StringSize);
  } else {
    StringSize  = StrSize (AppendStr);
    StringSize += (StrSize (Str->Str) - sizeof (UINT16));
 
    NewStr = ReallocatePool (
               StrSize (Str->Str),
               StringSize,
               Str->Str
               );
  }
 
  if (NewStr == NULL) {
    FreePool (AppendStr);
    return EFI_OUT_OF_RESOURCES;
  }
 
  Str->Str = NewStr;
  StrCatS (Str->Str, StringSize/sizeof (CHAR16), AppendStr);
  Str->Len = StringSize;
 
  FreePool (AppendStr);
  return EFI_SUCCESS;
}
 
MTD_NAME  mMTDName[] = {
  {
    MTDTypeUnknown,
    L"F"
  },
  {
    MTDTypeFloppy,
    L"FP"
  },
  {
    MTDTypeHardDisk,
    L"HD"
  },
  {
    MTDTypeCDRom,
    L"CD"
  },
  {
    MTDTypeEnd,
    NULL
  }
};
 
EFI_STATUS
AppendCSDNum2 (
  IN OUT POOL_PRINT  *Str,
  IN UINT64          Num
  )
{
  EFI_STATUS  Status;
  UINT64      Result;
  UINT32      Rem;
 
  ASSERT (Str != NULL);
 
  Result = DivU64x32Remainder (Num, 25, &Rem);
  if (Result > 0) {
    Status = AppendCSDNum2 (Str, Result);
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  return CatPrint (Str, L"%c", Rem + 'a');
}
 
EFI_STATUS
AppendCSDNum (
  IN OUT DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN     UINT64                       Num
  )
{
  EFI_STATUS  Status;
 
  ASSERT (MappingItem != NULL);
 
  if (MappingItem->Digital) {
    Status = CatPrint (&MappingItem->Csd, L"%ld", Num);
  } else {
    Status = AppendCSDNum2 (&MappingItem->Csd, Num);
  }
 
  if (!EFI_ERROR (Status)) {
    MappingItem->Digital = (BOOLEAN) !(MappingItem->Digital);
  }
 
  return Status;
}
 
EFI_STATUS
AppendCSDStr (
  IN OUT DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN     CHAR16                       *Str
  )
{
  CHAR16      *Index;
  EFI_STATUS  Status;
 
  ASSERT (Str != NULL && MappingItem != NULL);
 
  Status = EFI_SUCCESS;
 
  if (MappingItem->Digital) {
    //
    // To aVOID mult-meaning, the mapping is:
    //  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
    //  0  16 2  3  4  5  6  7  8  9  10 11 12 13 14 15
    //
    for (Index = Str; *Index != 0; Index++) {
      switch (*Index) {
        case '0':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
          Status = CatPrint (&MappingItem->Csd, L"%c", *Index);
          break;
 
        case '1':
          Status = CatPrint (&MappingItem->Csd, L"16");
          break;
 
        case 'a':
        case 'b':
        case 'c':
        case 'd':
        case 'e':
        case 'f':
          Status = CatPrint (&MappingItem->Csd, L"1%c", *Index - 'a' + '0');
          break;
 
        case 'A':
        case 'B':
        case 'C':
        case 'D':
        case 'E':
        case 'F':
          Status = CatPrint (&MappingItem->Csd, L"1%c", *Index - 'A' + '0');
          break;
      }
 
      if (EFI_ERROR (Status)) {
        return Status;
      }
    }
  } else {
    for (Index = Str; *Index != 0; Index++) {
      //
      //  The mapping is:
      //  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
      //  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p
      //
      if ((*Index >= '0') && (*Index <= '9')) {
        Status = CatPrint (&MappingItem->Csd, L"%c", *Index - '0' + 'a');
      } else if ((*Index >= 'a') && (*Index <= 'f')) {
        Status = CatPrint (&MappingItem->Csd, L"%c", *Index - 'a' + 'k');
      } else if ((*Index >= 'A') && (*Index <= 'F')) {
        Status = CatPrint (&MappingItem->Csd, L"%c", *Index - 'A' + 'k');
      }
 
      if (EFI_ERROR (Status)) {
        return Status;
      }
    }
  }
 
  MappingItem->Digital = (BOOLEAN) !(MappingItem->Digital);
 
  return (EFI_SUCCESS);
}
 
EFI_STATUS
AppendCSDGuid (
  DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  EFI_GUID                     *Guid
  )
{
  CHAR16  Buffer[64];
 
  ASSERT (Guid != NULL && MappingItem != NULL);
 
  UnicodeSPrint (
    Buffer,
    0,
    L"%g",
    Guid
    );
 
  return AppendCSDStr (MappingItem, Buffer);
}
 
INTN
EFIAPI
DevPathCompareAcpi (
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath1,
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath2
  )
{
  ACPI_HID_DEVICE_PATH  *Acpi1;
  ACPI_HID_DEVICE_PATH  *Acpi2;
 
  if ((DevicePath1 == NULL) || (DevicePath2 == NULL)) {
    return (-2);
  }
 
  Acpi1 = (ACPI_HID_DEVICE_PATH *)DevicePath1;
  Acpi2 = (ACPI_HID_DEVICE_PATH *)DevicePath2;
  if ((Acpi1->HID > Acpi2->HID) || ((Acpi1->HID == Acpi2->HID) && (Acpi1->UID > Acpi2->UID))) {
    return 1;
  }
 
  if ((Acpi1->HID == Acpi2->HID) && (Acpi1->UID == Acpi2->UID)) {
    return 0;
  }
 
  return -1;
}
 
INTN
EFIAPI
DevPathComparePci (
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath1,
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath2
  )
{
  PCI_DEVICE_PATH  *Pci1;
  PCI_DEVICE_PATH  *Pci2;
 
  ASSERT (DevicePath1 != NULL);
  ASSERT (DevicePath2 != NULL);
 
  Pci1 = (PCI_DEVICE_PATH *)DevicePath1;
  Pci2 = (PCI_DEVICE_PATH *)DevicePath2;
  if ((Pci1->Device > Pci2->Device) || ((Pci1->Device == Pci2->Device) && (Pci1->Function > Pci2->Function))) {
    return 1;
  }
 
  if ((Pci1->Device == Pci2->Device) && (Pci1->Function == Pci2->Function)) {
    return 0;
  }
 
  return -1;
}
 
INTN
EFIAPI
DevPathCompareDefault (
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath1,
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath2
  )
{
  UINTN  DevPathSize1;
  UINTN  DevPathSize2;
 
  ASSERT (DevicePath1 != NULL);
  ASSERT (DevicePath2 != NULL);
 
  DevPathSize1 = DevicePathNodeLength (DevicePath1);
  DevPathSize2 = DevicePathNodeLength (DevicePath2);
  if (DevPathSize1 > DevPathSize2) {
    return 1;
  } else if (DevPathSize1 < DevPathSize2) {
    return -1;
  } else {
    return CompareMem (DevicePath1, DevicePath2, DevPathSize1);
  }
}
 
EFI_STATUS
DevPathSerialHardDrive (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  HARDDRIVE_DEVICE_PATH  *Hd;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Hd = (HARDDRIVE_DEVICE_PATH *)DevicePathNode;
  if (MappingItem->Mtd == MTDTypeUnknown) {
    MappingItem->Mtd = MTDTypeHardDisk;
  }
 
  return AppendCSDNum (MappingItem, Hd->PartitionNumber);
}
 
EFI_STATUS
DevPathSerialAtapi (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  ATAPI_DEVICE_PATH  *Atapi;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Atapi = (ATAPI_DEVICE_PATH *)DevicePathNode;
  return AppendCSDNum (MappingItem, (Atapi->PrimarySecondary * 2 + Atapi->SlaveMaster));
}
 
EFI_STATUS
DevPathSerialCdRom (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  CDROM_DEVICE_PATH  *Cd;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Cd               = (CDROM_DEVICE_PATH *)DevicePathNode;
  MappingItem->Mtd = MTDTypeCDRom;
  return AppendCSDNum (MappingItem, Cd->BootEntry);
}
 
EFI_STATUS
DevPathSerialFibre (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS                Status;
  FIBRECHANNEL_DEVICE_PATH  *Fibre;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Fibre  = (FIBRECHANNEL_DEVICE_PATH *)DevicePathNode;
  Status = AppendCSDNum (MappingItem, Fibre->WWN);
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Fibre->Lun);
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialUart (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS        Status;
  UART_DEVICE_PATH  *Uart;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Uart   = (UART_DEVICE_PATH *)DevicePathNode;
  Status = AppendCSDNum (MappingItem, Uart->BaudRate);
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Uart->DataBits);
  }
 
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Uart->Parity);
  }
 
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Uart->StopBits);
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialUsb (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  USB_DEVICE_PATH           *Usb;
  EFI_USB_IO_PROTOCOL       *UsbIo;
  EFI_HANDLE                TempHandle;
  EFI_STATUS                Status;
  USB_INTERFACE_DESCRIPTOR  InterfaceDesc;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Usb    = (USB_DEVICE_PATH *)DevicePathNode;
  Status = AppendCSDNum (MappingItem, Usb->ParentPortNumber);
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Usb->InterfaceNumber);
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (PcdGetBool (PcdUsbExtendedDecode)) {
    Status = gBS->LocateDevicePath (&gEfiUsbIoProtocolGuid, &DevicePath, &TempHandle);
    UsbIo  = NULL;
    if (!EFI_ERROR (Status)) {
      Status = gBS->OpenProtocol (TempHandle, &gEfiUsbIoProtocolGuid, (VOID **)&UsbIo, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
    }
 
    if (!EFI_ERROR (Status)) {
      ASSERT (UsbIo != NULL);
      Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDesc);
      if (!EFI_ERROR (Status)) {
        if ((InterfaceDesc.InterfaceClass == USB_MASS_STORE_CLASS) && (MappingItem->Mtd == MTDTypeUnknown)) {
          switch (InterfaceDesc.InterfaceSubClass) {
            case USB_MASS_STORE_SCSI:
              MappingItem->Mtd = MTDTypeHardDisk;
              break;
            case USB_MASS_STORE_8070I:
            case USB_MASS_STORE_UFI:
              MappingItem->Mtd = MTDTypeFloppy;
              break;
            case USB_MASS_STORE_8020I:
              MappingItem->Mtd = MTDTypeCDRom;
              break;
          }
        }
      }
    }
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialVendor (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS          Status;
  VENDOR_DEVICE_PATH  *Vendor;
  SAS_DEVICE_PATH     *Sas;
  UINTN               TargetNameLength;
  UINTN               Index;
  CHAR16              *Buffer;
  CHAR16              *NewBuffer;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Vendor = (VENDOR_DEVICE_PATH *)DevicePathNode;
  Status = AppendCSDGuid (MappingItem, &Vendor->Guid);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (CompareGuid (&gEfiSasDevicePathGuid, &Vendor->Guid)) {
    Sas    = (SAS_DEVICE_PATH *)Vendor;
    Status = AppendCSDNum (MappingItem, Sas->SasAddress);
    if (!EFI_ERROR (Status)) {
      Status = AppendCSDNum (MappingItem, Sas->Lun);
    }
 
    if (!EFI_ERROR (Status)) {
      Status = AppendCSDNum (MappingItem, Sas->DeviceTopology);
    }
 
    if (!EFI_ERROR (Status)) {
      Status = AppendCSDNum (MappingItem, Sas->RelativeTargetPort);
    }
  } else {
    TargetNameLength = MIN (DevicePathNodeLength (DevicePathNode) - sizeof (VENDOR_DEVICE_PATH), PcdGet32 (PcdShellVendorExtendedDecode));
    if (TargetNameLength != 0) {
      //
      // String is 2 chars per data byte, plus NULL terminator
      //
      Buffer = AllocateZeroPool (((TargetNameLength * 2) + 1) * sizeof (CHAR16));
      if (Buffer == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }
 
      //
      // Build the string data
      //
      for (Index = 0; Index < TargetNameLength; Index++) {
        NewBuffer = CatSPrint (Buffer, L"%02x", *((UINT8 *)Vendor + sizeof (VENDOR_DEVICE_PATH) + Index));
        if (NewBuffer == NULL) {
          Status = EFI_OUT_OF_RESOURCES;
          break;
        }
 
        Buffer = NewBuffer;
      }
 
      //
      // Append the new data block
      //
      if (!EFI_ERROR (Status)) {
        Status = AppendCSDStr (MappingItem, Buffer);
      }
 
      FreePool (Buffer);
    }
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialLun (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  DEVICE_LOGICAL_UNIT_DEVICE_PATH  *Lun;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Lun = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *)DevicePathNode;
  return AppendCSDNum (MappingItem, Lun->Lun);
}
 
EFI_STATUS
DevPathSerialSata (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS        Status;
  SATA_DEVICE_PATH  *Sata;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Sata   = (SATA_DEVICE_PATH  *)DevicePathNode;
  Status = AppendCSDNum (MappingItem, Sata->HBAPortNumber);
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Sata->PortMultiplierPortNumber);
  }
 
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Sata->Lun);
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialIScsi (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS         Status;
  ISCSI_DEVICE_PATH  *IScsi;
  UINT8              *IScsiTargetName;
  CHAR16             *TargetName;
  UINTN              TargetNameLength;
  UINTN              Index;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Status = EFI_SUCCESS;
 
  if (PcdGetBool (PcdShellDecodeIScsiMapNames)) {
    IScsi  = (ISCSI_DEVICE_PATH  *)DevicePathNode;
    Status = AppendCSDNum (MappingItem, IScsi->NetworkProtocol);
    if (!EFI_ERROR (Status)) {
      Status = AppendCSDNum (MappingItem, IScsi->LoginOption);
    }
 
    if (!EFI_ERROR (Status)) {
      Status = AppendCSDNum (MappingItem, IScsi->Lun);
    }
 
    if (!EFI_ERROR (Status)) {
      Status = AppendCSDNum (MappingItem, IScsi->TargetPortalGroupTag);
    }
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    TargetNameLength = DevicePathNodeLength (DevicePathNode) - sizeof (ISCSI_DEVICE_PATH);
    if (TargetNameLength > 0) {
      TargetName = AllocateZeroPool ((TargetNameLength + 1) * sizeof (CHAR16));
      if (TargetName == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
      } else {
        IScsiTargetName = (UINT8 *)(IScsi + 1);
        for (Index = 0; Index < TargetNameLength; Index++) {
          TargetName[Index] = (CHAR16)IScsiTargetName[Index];
        }
 
        Status = AppendCSDStr (MappingItem, TargetName);
        FreePool (TargetName);
      }
    }
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialI2O (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  I2O_DEVICE_PATH  *DevicePath_I20;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  DevicePath_I20 = (I2O_DEVICE_PATH *)DevicePathNode;
  return AppendCSDNum (MappingItem, DevicePath_I20->Tid);
}
 
EFI_STATUS
DevPathSerialMacAddr (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  MAC_ADDR_DEVICE_PATH  *Mac;
  UINTN                 HwAddressSize;
  UINTN                 Index;
  CHAR16                Buffer[64];
  CHAR16                *PBuffer;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Mac = (MAC_ADDR_DEVICE_PATH *)DevicePathNode;
 
  HwAddressSize = sizeof (EFI_MAC_ADDRESS);
  if ((Mac->IfType == 0x01) || (Mac->IfType == 0x00)) {
    HwAddressSize = 6;
  }
 
  for (Index = 0, PBuffer = Buffer; Index < HwAddressSize; Index++, PBuffer += 2) {
    UnicodeSPrint (PBuffer, 0, L"%02x", (UINTN)Mac->MacAddress.Addr[Index]);
  }
 
  return AppendCSDStr (MappingItem, Buffer);
}
 
EFI_STATUS
DevPathSerialInfiniBand (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS              Status;
  INFINIBAND_DEVICE_PATH  *InfiniBand;
  UINTN                   Index;
  CHAR16                  Buffer[64];
  CHAR16                  *PBuffer;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  InfiniBand = (INFINIBAND_DEVICE_PATH *)DevicePathNode;
  for (Index = 0, PBuffer = Buffer; Index < 16; Index++, PBuffer += 2) {
    UnicodeSPrint (PBuffer, 0, L"%02x", (UINTN)InfiniBand->PortGid[Index]);
  }
 
  Status = AppendCSDStr (MappingItem, Buffer);
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, InfiniBand->ServiceId);
  }
 
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, InfiniBand->TargetPortId);
  }
 
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, InfiniBand->DeviceId);
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialIPv4 (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS        Status;
  IPv4_DEVICE_PATH  *Ip;
  CHAR16            Buffer[10];
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Ip = (IPv4_DEVICE_PATH *)DevicePathNode;
  UnicodeSPrint (
    Buffer,
    0,
    L"%02x%02x%02x%02x",
    (UINTN)Ip->LocalIpAddress.Addr[0],
    (UINTN)Ip->LocalIpAddress.Addr[1],
    (UINTN)Ip->LocalIpAddress.Addr[2],
    (UINTN)Ip->LocalIpAddress.Addr[3]
    );
  Status = AppendCSDStr (MappingItem, Buffer);
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Ip->LocalPort);
  }
 
  if (!EFI_ERROR (Status)) {
    UnicodeSPrint (
      Buffer,
      0,
      L"%02x%02x%02x%02x",
      (UINTN)Ip->RemoteIpAddress.Addr[0],
      (UINTN)Ip->RemoteIpAddress.Addr[1],
      (UINTN)Ip->RemoteIpAddress.Addr[2],
      (UINTN)Ip->RemoteIpAddress.Addr[3]
      );
    Status = AppendCSDStr (MappingItem, Buffer);
  }
 
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Ip->RemotePort);
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialIPv6 (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS        Status;
  IPv6_DEVICE_PATH  *Ip;
  UINTN             Index;
  CHAR16            Buffer[64];
  CHAR16            *PBuffer;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Ip = (IPv6_DEVICE_PATH *)DevicePathNode;
  for (Index = 0, PBuffer = Buffer; Index < 16; Index++, PBuffer += 2) {
    UnicodeSPrint (PBuffer, 0, L"%02x", (UINTN)Ip->LocalIpAddress.Addr[Index]);
  }
 
  Status = AppendCSDStr (MappingItem, Buffer);
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Ip->LocalPort);
  }
 
  if (!EFI_ERROR (Status)) {
    for (Index = 0, PBuffer = Buffer; Index < 16; Index++, PBuffer += 2) {
      UnicodeSPrint (PBuffer, 0, L"%02x", (UINTN)Ip->RemoteIpAddress.Addr[Index]);
    }
 
    Status = AppendCSDStr (MappingItem, Buffer);
  }
 
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Ip->RemotePort);
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerialScsi (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS        Status;
  SCSI_DEVICE_PATH  *Scsi;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Scsi   = (SCSI_DEVICE_PATH *)DevicePathNode;
  Status = AppendCSDNum (MappingItem, Scsi->Pun);
  if (!EFI_ERROR (Status)) {
    Status = AppendCSDNum (MappingItem, Scsi->Lun);
  }
 
  return Status;
}
 
EFI_STATUS
DevPathSerial1394 (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  F1394_DEVICE_PATH  *DevicePath_F1394;
  CHAR16             Buffer[20];
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  DevicePath_F1394 = (F1394_DEVICE_PATH *)DevicePathNode;
  UnicodeSPrint (Buffer, 0, L"%lx", DevicePath_F1394->Guid);
  return AppendCSDStr (MappingItem, Buffer);
}
 
EFI_STATUS
DevPathSerialAcpi (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  ACPI_HID_DEVICE_PATH  *Acpi;
 
  ASSERT (DevicePathNode != NULL);
  ASSERT (MappingItem != NULL);
 
  Acpi = (ACPI_HID_DEVICE_PATH *)DevicePathNode;
  if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
    if (EISA_ID_TO_NUM (Acpi->HID) == 0x0604) {
      MappingItem->Mtd = MTDTypeFloppy;
      return AppendCSDNum (MappingItem, Acpi->UID);
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
DevPathSerialDefault (
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  return EFI_SUCCESS;
}
 
DEV_PATH_CONSIST_MAPPING_TABLE  DevPathConsistMappingTable[] = {
  {
    HARDWARE_DEVICE_PATH,
    HW_PCI_DP,
    DevPathSerialDefault,
    DevPathComparePci
  },
  {
    ACPI_DEVICE_PATH,
    ACPI_DP,
    DevPathSerialAcpi,
    DevPathCompareAcpi
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_ATAPI_DP,
    DevPathSerialAtapi,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_SCSI_DP,
    DevPathSerialScsi,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_FIBRECHANNEL_DP,
    DevPathSerialFibre,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_1394_DP,
    DevPathSerial1394,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_USB_DP,
    DevPathSerialUsb,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_I2O_DP,
    DevPathSerialI2O,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_MAC_ADDR_DP,
    DevPathSerialMacAddr,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_IPv4_DP,
    DevPathSerialIPv4,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_IPv6_DP,
    DevPathSerialIPv6,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_INFINIBAND_DP,
    DevPathSerialInfiniBand,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_UART_DP,
    DevPathSerialUart,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_VENDOR_DP,
    DevPathSerialVendor,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_DEVICE_LOGICAL_UNIT_DP,
    DevPathSerialLun,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_SATA_DP,
    DevPathSerialSata,
    DevPathCompareDefault
  },
  {
    MESSAGING_DEVICE_PATH,
    MSG_ISCSI_DP,
    DevPathSerialIScsi,
    DevPathCompareDefault
  },
  {
    MEDIA_DEVICE_PATH,
    MEDIA_HARDDRIVE_DP,
    DevPathSerialHardDrive,
    DevPathCompareDefault
  },
  {
    MEDIA_DEVICE_PATH,
    MEDIA_CDROM_DP,
    DevPathSerialCdRom,
    DevPathCompareDefault
  },
  {
    MEDIA_DEVICE_PATH,
    MEDIA_VENDOR_DP,
    DevPathSerialVendor,
    DevPathCompareDefault
  },
  {
    0,
    0,
    NULL,
    NULL
  }
};
 
BOOLEAN
IsHIDevicePathNode (
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode
  )
{
  ACPI_HID_DEVICE_PATH  *Acpi;
 
  ASSERT (DevicePathNode != NULL);
 
  if (DevicePathNode->Type == HARDWARE_DEVICE_PATH) {
    return TRUE;
  }
 
  if (DevicePathNode->Type == ACPI_DEVICE_PATH) {
    Acpi = (ACPI_HID_DEVICE_PATH *)DevicePathNode;
    switch (EISA_ID_TO_NUM (Acpi->HID)) {
      case 0x0301:
      case 0x0401:
      case 0x0501:
      case 0x0604:
        return FALSE;
    }
 
    return TRUE;
  }
 
  return FALSE;
}
 
EFI_DEVICE_PATH_PROTOCOL *
GetHIDevicePath (
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath
  )
{
  UINTN                     NonHIDevicePathNodeCount;
  UINTN                     Index;
  EFI_DEV_PATH              Node;
  EFI_DEVICE_PATH_PROTOCOL  *HIDevicePath;
  EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;
 
  ASSERT (DevicePath != NULL);
 
  NonHIDevicePathNodeCount = 0;
 
  HIDevicePath = AllocateZeroPool (sizeof (EFI_DEVICE_PATH_PROTOCOL));
  if (HIDevicePath == NULL) {
    return NULL;
  }
 
  SetDevicePathEndNode (HIDevicePath);
 
  Node.DevPath.Type      = END_DEVICE_PATH_TYPE;
  Node.DevPath.SubType   = END_INSTANCE_DEVICE_PATH_SUBTYPE;
  Node.DevPath.Length[0] = (UINT8)sizeof (EFI_DEVICE_PATH_PROTOCOL);
  Node.DevPath.Length[1] = 0;
 
  while (!IsDevicePathEnd (DevicePath)) {
    if (IsHIDevicePathNode (DevicePath)) {
      for (Index = 0; Index < NonHIDevicePathNodeCount; Index++) {
        TempDevicePath = AppendDevicePathNode (HIDevicePath, &Node.DevPath);
        FreePool (HIDevicePath);
        HIDevicePath = TempDevicePath;
      }
 
      TempDevicePath = AppendDevicePathNode (HIDevicePath, DevicePath);
      FreePool (HIDevicePath);
      HIDevicePath = TempDevicePath;
    } else {
      NonHIDevicePathNodeCount++;
    }
 
    //
    // Next device path node
    //
    DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)NextDevicePathNode (DevicePath);
  }
 
  return HIDevicePath;
}
 
EFI_STATUS
GetDeviceConsistMappingInfo (
  IN DEVICE_CONSIST_MAPPING_INFO  *MappingItem,
  IN EFI_DEVICE_PATH_PROTOCOL     *DevicePath
  )
{
  EFI_STATUS                Status;
  SERIAL_DECODE_FUNCTION    SerialFun;
  UINTN                     Index;
  EFI_DEVICE_PATH_PROTOCOL  *OriginalDevicePath;
 
  ASSERT (DevicePath != NULL);
  ASSERT (MappingItem != NULL);
 
  SetMem (&MappingItem->Csd, sizeof (POOL_PRINT), 0);
  OriginalDevicePath = DevicePath;
 
  while (!IsDevicePathEnd (DevicePath)) {
    //
    // Find the handler to dump this device path node and
    // initialize with generic function in case nothing is found
    //
    for (SerialFun = DevPathSerialDefault, Index = 0; DevPathConsistMappingTable[Index].SerialFun != NULL; Index += 1) {
      if ((DevicePathType (DevicePath) == DevPathConsistMappingTable[Index].Type) &&
          (DevicePathSubType (DevicePath) == DevPathConsistMappingTable[Index].SubType)
          )
      {
        SerialFun = DevPathConsistMappingTable[Index].SerialFun;
        break;
      }
    }
 
    Status = SerialFun (DevicePath, MappingItem, OriginalDevicePath);
    if (EFI_ERROR (Status)) {
      SHELL_FREE_NON_NULL (MappingItem->Csd.Str);
      return Status;
    }
 
    //
    // Next device path node
    //
    DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)NextDevicePathNode (DevicePath);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
ShellCommandConsistMappingInitialize (
  OUT EFI_DEVICE_PATH_PROTOCOL  ***Table
  )
{
  EFI_HANDLE                       *HandleBuffer;
  UINTN                            HandleNum;
  UINTN                            HandleLoop;
  EFI_DEVICE_PATH_PROTOCOL         **TempTable;
  EFI_DEVICE_PATH_PROTOCOL         *DevicePath;
  EFI_DEVICE_PATH_PROTOCOL         *HIDevicePath;
  EFI_BLOCK_IO_PROTOCOL            *BlockIo;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *SimpleFileSystem;
  UINTN                            Index;
  EFI_STATUS                       Status;
 
  HandleBuffer = NULL;
 
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  &gEfiDevicePathProtocolGuid,
                  NULL,
                  &HandleNum,
                  &HandleBuffer
                  );
  ASSERT_EFI_ERROR (Status);
 
  TempTable = AllocateZeroPool ((HandleNum + 1) * sizeof (EFI_DEVICE_PATH_PROTOCOL *));
  if (TempTable == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  for (HandleLoop = 0; HandleLoop < HandleNum; HandleLoop++) {
    DevicePath = DevicePathFromHandle (HandleBuffer[HandleLoop]);
    if (DevicePath == NULL) {
      continue;
    }
 
    HIDevicePath = GetHIDevicePath (DevicePath);
    if (HIDevicePath == NULL) {
      continue;
    }
 
    Status = gBS->HandleProtocol (
                    HandleBuffer[HandleLoop],
                    &gEfiBlockIoProtocolGuid,
                    (VOID **)&BlockIo
                    );
    if (EFI_ERROR (Status)) {
      Status = gBS->HandleProtocol (
                      HandleBuffer[HandleLoop],
                      &gEfiSimpleFileSystemProtocolGuid,
                      (VOID **)&SimpleFileSystem
                      );
      if (EFI_ERROR (Status)) {
        FreePool (HIDevicePath);
        continue;
      }
    }
 
    for (Index = 0; TempTable[Index] != NULL; Index++) {
      if (DevicePathCompare (&TempTable[Index], &HIDevicePath) == 0) {
        FreePool (HIDevicePath);
        break;
      }
    }
 
    if (TempTable[Index] == NULL) {
      TempTable[Index] = HIDevicePath;
    }
  }
 
  for (Index = 0; TempTable[Index] != NULL; Index++) {
  }
 
  PerformQuickSort (TempTable, Index, sizeof (EFI_DEVICE_PATH_PROTOCOL *), DevicePathCompare);
  *Table = TempTable;
 
  if (HandleBuffer != NULL) {
    FreePool (HandleBuffer);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
ShellCommandConsistMappingUnInitialize (
  EFI_DEVICE_PATH_PROTOCOL  **Table
  )
{
  UINTN  Index;
 
  ASSERT (Table  != NULL);
 
  for (Index = 0; Table[Index] != NULL; Index++) {
    FreePool (Table[Index]);
  }
 
  FreePool (Table);
  return EFI_SUCCESS;
}
 
CHAR16 *
EFIAPI
ShellCommandConsistMappingGenMappingName (
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
  IN EFI_DEVICE_PATH_PROTOCOL  **Table
  )
{
  EFI_STATUS                   Status;
  POOL_PRINT                   Str;
  DEVICE_CONSIST_MAPPING_INFO  MappingInfo;
  EFI_DEVICE_PATH_PROTOCOL     *HIDevicePath;
  UINTN                        Index;
 
  ASSERT (DevicePath         != NULL);
  ASSERT (Table  != NULL);
 
  HIDevicePath = GetHIDevicePath (DevicePath);
  if (HIDevicePath == NULL) {
    return NULL;
  }
 
  for (Index = 0; Table[Index] != NULL; Index++) {
    if (DevicePathCompare (&Table[Index], &HIDevicePath) == 0) {
      break;
    }
  }
 
  FreePool (HIDevicePath);
  if (Table[Index] == NULL) {
    return NULL;
  }
 
  MappingInfo.Hi      = Index;
  MappingInfo.Mtd     = MTDTypeUnknown;
  MappingInfo.Digital = FALSE;
 
  Status = GetDeviceConsistMappingInfo (&MappingInfo, DevicePath);
  if (EFI_ERROR (Status)) {
    return NULL;
  }
 
  SetMem (&Str, sizeof (Str), 0);
  for (Index = 0; mMTDName[Index].MTDType != MTDTypeEnd; Index++) {
    if (MappingInfo.Mtd == mMTDName[Index].MTDType) {
      break;
    }
  }
 
  if (mMTDName[Index].MTDType != MTDTypeEnd) {
    Status = CatPrint (&Str, L"%s", mMTDName[Index].Name);
  }
 
  if (!EFI_ERROR (Status)) {
    Status = CatPrint (&Str, L"%d", (UINTN)MappingInfo.Hi);
  }
 
  if (!EFI_ERROR (Status) && (MappingInfo.Csd.Str != NULL)) {
    Status = CatPrint (&Str, L"%s", MappingInfo.Csd.Str);
    FreePool (MappingInfo.Csd.Str);
  }
 
  if (!EFI_ERROR (Status) && (Str.Str != NULL)) {
    Status = CatPrint (&Str, L":");
  }
 
  if (EFI_ERROR (Status)) {
    SHELL_FREE_NON_NULL (Str.Str);
    return NULL;
  }
 
  return Str.Str;
}
 
SHELL_MAP_LIST *
EFIAPI
ShellCommandFindMapItem (
  IN CONST CHAR16  *MapKey
  )
{
  SHELL_MAP_LIST  *MapListItem;
 
  for ( MapListItem = (SHELL_MAP_LIST *)GetFirstNode (&gShellMapList.Link)
        ; !IsNull (&gShellMapList.Link, &MapListItem->Link)
        ; MapListItem = (SHELL_MAP_LIST *)GetNextNode (&gShellMapList.Link, &MapListItem->Link)
        )
  {
    if (gUnicodeCollation->StriColl (gUnicodeCollation, MapListItem->MapName, (CHAR16 *)MapKey) == 0) {
      return (MapListItem);
    }
  }
 
  return (NULL);
}