devicepathfromtext.c

来自「EFI BIOS是Intel提出的下一代的BIOS标准。这里上传的Edk源代码是」· C语言 代码 · 共 2,229 行 · 第 1/4 页

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbTestAndMeasurement (
  IN CHAR16 *TextDeviceNode
  )
{
  USB_CLASS_TEXT  UsbClassText;

  UsbClassText.ClassExist    = FALSE;
  UsbClassText.Class         = USB_CLASS_RESERVE;
  UsbClassText.SubClassExist = FALSE;
  UsbClassText.SubClass      = USB_SUBCLASS_TEST;

  return ConvertFromTextUsbClass (TextDeviceNode, &UsbClassText);
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUsbWwid (
  IN CHAR16 *TextDeviceNode
  )
{
  CHAR16                *VIDStr;
  CHAR16                *PIDStr;
  CHAR16                *InterfaceNumStr;
  USB_WWID_DEVICE_PATH  *UsbWwid;

  VIDStr                    = GetNextParamStr (&TextDeviceNode);
  PIDStr                    = GetNextParamStr (&TextDeviceNode);
  InterfaceNumStr           = GetNextParamStr (&TextDeviceNode);
  UsbWwid                   = (USB_WWID_DEVICE_PATH *) CreateDeviceNode (
                                                         MESSAGING_DEVICE_PATH,
                                                         MSG_USB_WWID_DP,
                                                         sizeof (USB_WWID_DEVICE_PATH)
                                                         );

  UsbWwid->VendorId         = (UINT16) Xtoi (VIDStr);
  UsbWwid->ProductId        = (UINT16) Xtoi (PIDStr);
  UsbWwid->InterfaceNumber  = (UINT16) Xtoi (InterfaceNumStr);

  return (EFI_DEVICE_PATH_PROTOCOL *) UsbWwid;
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextUnit (
  IN CHAR16 *TextDeviceNode
  )
{
  CHAR16                          *LunStr;
  DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;

  LunStr      = GetNextParamStr (&TextDeviceNode);
  LogicalUnit = (DEVICE_LOGICAL_UNIT_DEVICE_PATH *) CreateDeviceNode (
                                                      MESSAGING_DEVICE_PATH,
                                                      MSG_DEVICE_LOGICAL_UNIT_DP,
                                                      sizeof (DEVICE_LOGICAL_UNIT_DEVICE_PATH)
                                                      );

  LogicalUnit->Lun  = (UINT8) Xtoi (LunStr);

  return (EFI_DEVICE_PATH_PROTOCOL *) LogicalUnit;
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextiSCSI (
  IN CHAR16 *TextDeviceNode
  )
{
  UINT16                      Options;
  CHAR16                      *NameStr;
  CHAR16                      *PortalGroupStr;
  CHAR16                      *LunStr;
  CHAR16                      *HeaderDigestStr;
  CHAR16                      *DataDigestStr;
  CHAR16                      *AuthenticationStr;
  CHAR16                      *ProtocolStr;
  ISCSI_DEVICE_PATH_WITH_NAME *iSCSI;

  NameStr           = GetNextParamStr (&TextDeviceNode);
  PortalGroupStr    = GetNextParamStr (&TextDeviceNode);
  LunStr            = GetNextParamStr (&TextDeviceNode);
  HeaderDigestStr   = GetNextParamStr (&TextDeviceNode);
  DataDigestStr     = GetNextParamStr (&TextDeviceNode);
  AuthenticationStr = GetNextParamStr (&TextDeviceNode);
  ProtocolStr       = GetNextParamStr (&TextDeviceNode);
  iSCSI             = (ISCSI_DEVICE_PATH_WITH_NAME *) CreateDeviceNode (
                                                        MESSAGING_DEVICE_PATH,
                                                        MSG_ISCSI_DP,
                                                        sizeof (ISCSI_DEVICE_PATH_WITH_NAME) + (UINT16) (EfiStrLen (NameStr) * 2)
                                                        );

  EfiStrCpy (iSCSI->iSCSITargetName, NameStr);
  iSCSI->TargetPortalGroupTag = (UINT16) Xtoi (PortalGroupStr);
  Xtoi64 (LunStr, &iSCSI->Lun);

  Options = 0x0000;
  if (EfiStrCmp (HeaderDigestStr, L"CRC32C") == 0) {
    Options |= 0x0002;
  }

  if (EfiStrCmp (DataDigestStr, L"CRC32C") == 0) {
    Options |= 0x0008;
  }

  if (EfiStrCmp (AuthenticationStr, L"None") == 0) {
    Options |= 0x0800;
  }

  if (EfiStrCmp (AuthenticationStr, L"CHAP_UNI") == 0) {
    Options |= 0x1000;
  }

  iSCSI->LoginOption      = (UINT16) Options;

  iSCSI->NetworkProtocol  = (UINT16) EfiStrCmp (ProtocolStr, L"TCP");
  iSCSI->Reserved         = (UINT16) 0;

  return (EFI_DEVICE_PATH_PROTOCOL *) iSCSI;
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextHD (
  IN CHAR16 *TextDeviceNode
  )
{
  CHAR16                *PartitionStr;
  CHAR16                *TypeStr;
  CHAR16                *SignatureStr;
  CHAR16                *StartStr;
  CHAR16                *SizeStr;
  UINT32                Signature32;
  EFI_GUID              SignatureGuid;
  HARDDRIVE_DEVICE_PATH *Hd;

  PartitionStr        = GetNextParamStr (&TextDeviceNode);
  TypeStr             = GetNextParamStr (&TextDeviceNode);
  SignatureStr        = GetNextParamStr (&TextDeviceNode);
  StartStr            = GetNextParamStr (&TextDeviceNode);
  SizeStr             = GetNextParamStr (&TextDeviceNode);
  Hd                  = (HARDDRIVE_DEVICE_PATH *) CreateDeviceNode (
                                                    MEDIA_DEVICE_PATH,
                                                    MEDIA_HARDDRIVE_DP,
                                                    sizeof (HARDDRIVE_DEVICE_PATH)
                                                    );

  Hd->PartitionNumber = (UINT32) Atoi (PartitionStr);

  EfiZeroMem (Hd->Signature, 16);
  Hd->MBRType = (UINT8) 0;

  if (EfiStrCmp (TypeStr, L"None") == 0) {
    Hd->SignatureType = (UINT8) 0;
  } else if (EfiStrCmp (TypeStr, L"MBR") == 0) {
    Hd->SignatureType = SIGNATURE_TYPE_MBR;
    Hd->MBRType       = 0x01;

    Signature32       = (UINT32) Xtoi (SignatureStr);
    EfiCopyMem (Hd->Signature, &Signature32, sizeof (UINT32));
  } else if (EfiStrCmp (TypeStr, L"GUID") == 0) {
    Hd->SignatureType = SIGNATURE_TYPE_GUID;
    Hd->MBRType       = 0x02;

    StrToGuid (SignatureStr, &SignatureGuid);
    EfiCopyMem (Hd->Signature, &SignatureGuid, sizeof (EFI_GUID));
  } else {
    Hd->SignatureType = 0xff;

  }

  Xtoi64 (StartStr, &Hd->PartitionStart);
  Xtoi64 (SizeStr, &Hd->PartitionSize);

  return (EFI_DEVICE_PATH_PROTOCOL *) Hd;
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextCDROM (
  IN CHAR16 *TextDeviceNode
  )
{
  CHAR16            *EntryStr;
  CHAR16            *StartStr;
  CHAR16            *SizeStr;
  CDROM_DEVICE_PATH *CDROM;

  EntryStr              = GetNextParamStr (&TextDeviceNode);
  StartStr              = GetNextParamStr (&TextDeviceNode);
  SizeStr               = GetNextParamStr (&TextDeviceNode);
  CDROM                 = (CDROM_DEVICE_PATH *) CreateDeviceNode (
                                                  MEDIA_DEVICE_PATH,
                                                  MEDIA_CDROM_DP,
                                                  sizeof (CDROM_DEVICE_PATH)
                                                  );

  CDROM->BootEntry      = (UINT32) Xtoi (EntryStr);
  Xtoi64 (StartStr, &CDROM->PartitionStart);
  Xtoi64 (SizeStr, &CDROM->PartitionSize);

  return (EFI_DEVICE_PATH_PROTOCOL *) CDROM;
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextVenMEDIA (
  IN CHAR16 *TextDeviceNode
  )
{
  return ConvertFromTextVendor (
           TextDeviceNode,
           MEDIA_DEVICE_PATH,
           MEDIA_VENDOR_DP
           );
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextFilePath (
  IN CHAR16 *TextDeviceNode
  )
{
  FILEPATH_DEVICE_PATH  *File;

  File = (FILEPATH_DEVICE_PATH *) CreateDeviceNode (
                                    MEDIA_DEVICE_PATH,
                                    MEDIA_FILEPATH_DP,
                                    sizeof (FILEPATH_DEVICE_PATH) + (UINT16) (EfiStrLen (TextDeviceNode) * 2)
                                    );

  EfiStrCpy (File->PathName, TextDeviceNode);

  return (EFI_DEVICE_PATH_PROTOCOL *) File;
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextMedia (
  IN CHAR16 *TextDeviceNode
  )
{
  CHAR16                      *GuidStr;
  MEDIA_PROTOCOL_DEVICE_PATH  *Media;

  GuidStr = GetNextParamStr (&TextDeviceNode);
  Media   = (MEDIA_PROTOCOL_DEVICE_PATH *) CreateDeviceNode (
                                             MEDIA_DEVICE_PATH,
                                             MEDIA_PROTOCOL_DP,
                                             sizeof (MEDIA_PROTOCOL_DEVICE_PATH)
                                             );

  StrToGuid (GuidStr, &Media->Protocol);

  return (EFI_DEVICE_PATH_PROTOCOL *) Media;
}

EFI_DEVICE_PATH_PROTOCOL *
DevPathFromTextBBS (
  IN CHAR16 *TextDeviceNode
  )
{
  CHAR16              *TypeStr;
  CHAR16              *IdStr;
  CHAR16              *FlagsStr;
  UINT8               *AsciiStr;
  BBS_BBS_DEVICE_PATH *Bbs;

  TypeStr   = GetNextParamStr (&TextDeviceNode);
  IdStr     = GetNextParamStr (&TextDeviceNode);
  FlagsStr  = GetNextParamStr (&TextDeviceNode);
  Bbs       = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode (
                                        BBS_DEVICE_PATH,
                                        BBS_BBS_DP,
                                        sizeof (BBS_BBS_DEVICE_PATH) + (UINT16) (EfiStrLen (IdStr))
                                        );

  if (EfiStrCmp (TypeStr, L"Floppy") == 0) {
    Bbs->DeviceType = BBS_TYPE_FLOPPY;
  } else if (EfiStrCmp (TypeStr, L"HD") == 0) {
    Bbs->DeviceType = BBS_TYPE_HARDDRIVE;
  } else if (EfiStrCmp (TypeStr, L"CDROM") == 0) {
    Bbs->DeviceType = BBS_TYPE_CDROM;
  } else if (EfiStrCmp (TypeStr, L"PCMCIA") == 0) {
    Bbs->DeviceType = BBS_TYPE_PCMCIA;
  } else if (EfiStrCmp (TypeStr, L"USB") == 0) {
    Bbs->DeviceType = BBS_TYPE_USB;
  } else if (EfiStrCmp (TypeStr, L"Network") == 0) {
    Bbs->DeviceType = BBS_TYPE_EMBEDDED_NETWORK;
  } else {
    Bbs->DeviceType = BBS_TYPE_UNKNOWN;
  }

  AsciiStr = Bbs->String;
  StrToAscii (IdStr, &AsciiStr);

  Bbs->StatusFlag = (UINT16) Xtoi (FlagsStr);

  return (EFI_DEVICE_PATH_PROTOCOL *) Bbs;
}

DEVICE_PATH_FROM_TEXT_TABLE DevPathFromTextTable[] = {
  L"Pci",
  DevPathFromTextPci,
  L"PcCard",
  DevPathFromTextPcCard,
  L"MemoryMapped",
  DevPathFromTextMemoryMapped,
  L"VenHw",
  DevPathFromTextVenHw,
  L"Ctrl",
  DevPathFromTextCtrl,
  L"Acpi",
  DevPathFromTextAcpi,
  L"PciRoot",
  DevPathFromTextPciRoot,
  L"Floppy",
  DevPathFromTextFloppy,
  L"Keyboard",
  DevPathFromTextKeyboard,
  L"Serial",
  DevPathFromTextSerial,
  L"ParallelPort",
  DevPathFromTextParallelPort,
  L"AcpiEx",
  DevPathFromTextAcpiEx,
  L"AcpiExp",
  DevPathFromTextAcpiExp,
  L"Ata",
  DevPathFromTextAta,
  L"Scsi",
  DevPathFromTextScsi,
  L"Fibre",
  DevPathFromTextFibre,
  L"I1394",
  DevPathFromText1394,
  L"USB",
  DevPathFromTextUsb,
  L"I2O",
  DevPathFromTextI2O,
  L"Infiniband",
  DevPathFromTextInfiniband,
  L"VenMsg",
  DevPathFromTextVenMsg,
  L"VenPcAnsi",
  DevPathFromTextVenPcAnsi,
  L"VenVt100",
  DevPathFromTextVenVt100,
  L"VenVt100Plus",
  DevPathFromTextVenVt100Plus,
  L"VenUtf8",
  DevPathFromTextVenUtf8,
  L"UartFlowCtrl",
  DevPathFromTextUartFlowCtrl,
  L"SAS",
  DevPathFromTextSAS,
  L"DebugPort",
  DevPathFromTextDebugPort,
  L"MAC",
  DevPathFromTextMAC,
  L"IPv4",
  DevPathFromTextIPv4,
  L"IPv6",
  DevPathFromTextIPv6,
  L"Uart",
  DevPathFromTextUart,
  L"UsbClass",
  DevPathFromTextUsbClass,
  L"UsbAudio",
  DevPathFromTextUsbAudio,
  L"UsbCDCControl",
  DevPathFromTextUsbCDCControl,
  L"UsbHID",
  DevPathFromTextUsbHID,
  L"UsbImage",
  DevPathFromTextUsbImage,
  L"UsbPrinter",
  DevPathFromTextUsbPrinter,
  L"UsbMassStorage",
  DevPathFromTextUsbMassStorage,
  L"UsbHub",
  DevPathFromTextUsbHub,
  L"UsbCDCData",
  DevPathFromTextUsbCDCData,
  L"UsbSmartCard",
  DevPathFromTextUsbSmartCard,
  L"UsbVideo",
  DevPathFromTextUsbVideo,
  L"UsbDiagnostic",
  DevPathFromTextUsbDiagnostic,
  L"UsbWireless",
  DevPathFromTextUsbWireless,
  L"UsbDeviceFirmwareUpdate",
  DevPathFromTextUsbDeviceFirmwareUpdate,
  L"UsbIrdaBridge",
  DevPathFromTextUsbIrdaBridge,
  L"UsbTestAndMeasurement",
  DevPathFromTextUsbTestAndMeasurement,
  L"UsbWwid",
  DevPathFromTextUsbWwid,
  L"Unit",
  DevPathFromTextUnit,
  L"iSCSI",
  DevPathFromTextiSCSI,
  L"HD",
  DevPathFromTextHD,
  L"CDROM",
  DevPathFromTextCDROM,
  L"VenMEDIA",
  DevPathFromTextVenMEDIA,
  L"Media",
  DevPathFromTextMedia,
  L"BBS",
  DevPathFromTextBBS,
  NULL,
  NULL
};

EFI_DEVICE_PATH_PROTOCOL *
ConvertTextToDeviceNode (
  IN CONST CHAR16 *TextDeviceNode
  )
/*++

  Routine Description:
    Convert text to the binary representation of a device node.

  Arguments:
    TextDeviceNode   -   TextDeviceNode points to the text representation of a device
                         node. Conversion starts with the first character and continues
                         until the first non-device node character.

  Returns:
    A pointer        -   Pointer to the EFI device node.
    NULL             -   If TextDeviceNode is NULL or there was insufficient memory or text unsupported.

--*/
{
  EFI_DEVICE_PATH_PROTOCOL * (*DumpNode) (CHAR16 *);
  CHAR16                   *ParamStr;
  EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
  CHAR16                   *DeviceNodeStr;
  UINTN                    Index;

  if ((TextDeviceNode == NULL) || (IS_NULL (*TextDeviceNode))) {
    return NULL;
  }

  ParamStr      = NULL;
  DumpNode      = NULL;
  DeviceNodeStr = StrDuplicate (TextDeviceNode);

  for (Index = 0; DevPathFromTextTable[Index].Function; Index++) {
    ParamStr = GetParamByNodeName (DeviceNodeStr, DevPathFromTextTable[Index].DevicePathNodeText);
    if (ParamStr != NULL) {
      DumpNode = DevPathFromTextTable[Index].Function;
      break;
    }
  }

  if (DumpNode == NULL) {
    //
    // A file path
    //
    DumpNode = DevPathFromTextFilePath;
    DeviceNode = DumpNode (DeviceNodeStr);
  } else {
    DeviceNode = DumpNode (ParamStr);
    gBS->FreePool (ParamStr);
  }

  gBS->FreePool (DeviceNodeStr);

  return DeviceNode;
}

EFI_DEVICE_PATH_PROTOCOL *
ConvertTextToDevicePath (
  IN CONST CHAR16 *TextDevicePath
  )
/*++

  Routine Description:
    Convert text to the binary representation of a device path.

  Arguments:
    TextDevicePath   -   TextDevicePath points to the text representation of a device
                         path. Conversion starts with the first character and continues
                         until the first non-device node character.

  Returns:
    A pointer        -   Pointer to the allocated device path.
    NULL             -   If TextDeviceNode is NULL or there was insufficient memory.

--*/
{
  EFI_DEVICE_PATH_PROTOCOL * (*DumpNode) (CHAR16 *);
  CHAR16                   *ParamStr;
  EFI_DEVICE_PATH_PROTOCOL *DeviceNode;
  UINTN                    Index;
  EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
  CHAR16                   *DevicePathStr;
  CHAR16                   *Str;
  CHAR16                   *DeviceNodeStr;
  UINT8                    IsInstanceEnd;
  EFI_DEVICE_PATH_PROTOCOL *DevicePath;

  if ((TextDevicePath == NULL) || (IS_NULL (*TextDevicePath))) {
    return NULL;
  }

  DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) EfiLibAllocatePool (END_DEVICE_PATH_LENGTH);
  SetDevicePathEndNode (DevicePath);

  ParamStr            = NULL;
  DeviceNodeStr       = NULL;
  DevicePathStr       = StrDuplicate (TextDevicePath);

  Str                 = DevicePathStr;
  while ((DeviceNodeStr = GetNextDeviceNodeStr (&Str, &IsInstanceEnd)) != NULL) {
    DumpNode = NULL;
    for (Index = 0; DevPathFromTextTable[Index].Function; Index++) {
      ParamStr = GetParamByNodeName (DeviceNodeStr, DevPathFromTextTable[Index].DevicePathNodeText);
      if (ParamStr != NULL) {
        DumpNode = DevPathFromTextTable[Index].Function;
        break;
      }
    }

    if (DumpNode == NULL) {
      //
      // A file path
      //
      DumpNode  = DevPathFromTextFilePath;
      DeviceNode = DumpNode (DeviceNodeStr);
    } else {
      DeviceNode = DumpNode (ParamStr);
      gBS->FreePool (ParamStr);
    }

    NewDevicePath = EfiAppendDevicePathNode (DevicePath, DeviceNode);
    gBS->FreePool (DevicePath);
    gBS->FreePool (DeviceNode);
    DevicePath = NewDevicePath;

    if (IsInstanceEnd) {
      DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) EfiLibAllocatePool (END_DEVICE_PATH_LENGTH);
      SetDevicePathInstanceEndNode (DeviceNode);

      NewDevicePath = EfiAppendDevicePathNode (DevicePath, DeviceNode);
      gBS->FreePool (DevicePath);
      gBS->FreePool (DeviceNode);
      DevicePath = NewDevicePath;
    }
  }

  gBS->FreePool (DevicePathStr);
  return DevicePath;
}