66f6a64dd9
__FUNCTION__ is a pre-standard extension that gcc and Visual C++ among others support, while __func__ was standardized in C99. Since it's more standard, replace __FUNCTION__ with __func__ throughout EmulatorPkg. Signed-off-by: Rebecca Cran <rebecca@bsdio.com> Reviewed-by: Michael D Kinney <michael.d.kinney@intel.com> Reviewed-by: Ard Biesheuvel <ardb@kernel.org> Reviewed-by: Abner Chang <Abner.Chang@amd.com> Reviewed-by: Ray Ni <ray.ni@intel.com>
571 lines
19 KiB
C
571 lines
19 KiB
C
/** @file
|
|
PCI/PCIe network interface instace of RedfishPlatformHostInterfaceLib
|
|
|
|
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
|
|
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
|
|
Copyright (C) 2022 Advanced Micro Devices, Inc. All rights reserved.<BR>
|
|
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
**/
|
|
|
|
#include <Uefi.h>
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/DevicePathLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/PrintLib.h>
|
|
#include <Library/RedfishHostInterfaceLib.h>
|
|
#include <Library/UefiLib.h>
|
|
#include <Library/UefiBootServicesTableLib.h>
|
|
#include <Library/UefiRuntimeServicesTableLib.h>
|
|
|
|
#include <Pcd/RestExServiceDevicePath.h>
|
|
#include <Guid/GlobalVariable.h>
|
|
|
|
#define VERBOSE_COLUME_SIZE (16)
|
|
|
|
REDFISH_OVER_IP_PROTOCOL_DATA *mRedfishOverIpProtocolData;
|
|
UINT8 mRedfishProtocolDataSize;
|
|
|
|
/**
|
|
Get the MAC address of NIC.
|
|
|
|
@param[out] MacAddress Pointer to retrieve MAC address
|
|
|
|
@retval EFI_SUCCESS MAC address is returned in MacAddress
|
|
|
|
**/
|
|
EFI_STATUS
|
|
GetMacAddressInformation (
|
|
OUT EFI_MAC_ADDRESS *MacAddress
|
|
)
|
|
{
|
|
MAC_ADDR_DEVICE_PATH *Mac;
|
|
REST_EX_SERVICE_DEVICE_PATH_DATA *RestExServiceDevicePathData;
|
|
EFI_DEVICE_PATH_PROTOCOL *RestExServiceDevicePath;
|
|
MAC_ADDR_DEVICE_PATH *MacAddressDevicePath;
|
|
|
|
Mac = NULL;
|
|
RestExServiceDevicePathData = NULL;
|
|
RestExServiceDevicePath = NULL;
|
|
|
|
RestExServiceDevicePathData = (REST_EX_SERVICE_DEVICE_PATH_DATA *)PcdGetPtr (PcdRedfishRestExServiceDevicePath);
|
|
if ((RestExServiceDevicePathData == NULL) ||
|
|
(RestExServiceDevicePathData->DevicePathNum == 0) ||
|
|
!IsDevicePathValid (RestExServiceDevicePathData->DevicePath, 0))
|
|
{
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
RestExServiceDevicePath = RestExServiceDevicePathData->DevicePath;
|
|
if (RestExServiceDevicePathData->DevicePathMatchMode != DEVICE_PATH_MATCH_MAC_NODE) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Find Mac DevicePath Node.
|
|
//
|
|
while (!IsDevicePathEnd (RestExServiceDevicePath) &&
|
|
((DevicePathType (RestExServiceDevicePath) != MESSAGING_DEVICE_PATH) ||
|
|
(DevicePathSubType (RestExServiceDevicePath) != MSG_MAC_ADDR_DP)))
|
|
{
|
|
RestExServiceDevicePath = NextDevicePathNode (RestExServiceDevicePath);
|
|
}
|
|
|
|
if (!IsDevicePathEnd (RestExServiceDevicePath)) {
|
|
MacAddressDevicePath = (MAC_ADDR_DEVICE_PATH *)RestExServiceDevicePath;
|
|
CopyMem ((VOID *)MacAddress, (VOID *)&MacAddressDevicePath->MacAddress, sizeof (EFI_MAC_ADDRESS));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
/**
|
|
Get platform Redfish host interface device descriptor.
|
|
|
|
@param[out] DeviceType Pointer to retrieve device type.
|
|
@param[out] DeviceDescriptor Pointer to retrieve REDFISH_INTERFACE_DATA, caller has to free
|
|
this memory using FreePool().
|
|
@retval EFI_SUCCESS Device descriptor is returned successfully in DeviceDescriptor.
|
|
@retval EFI_NOT_FOUND No Redfish host interface descriptor provided on this platform.
|
|
@retval Others Fail to get device descriptor.
|
|
**/
|
|
EFI_STATUS
|
|
RedfishPlatformHostInterfaceDeviceDescriptor (
|
|
OUT UINT8 *DeviceType,
|
|
OUT REDFISH_INTERFACE_DATA **DeviceDescriptor
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_MAC_ADDRESS MacAddress;
|
|
REDFISH_INTERFACE_DATA *RedfishInterfaceData;
|
|
PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2 *ThisDeviceDescriptor;
|
|
|
|
RedfishInterfaceData = AllocateZeroPool (sizeof (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2) + 1);
|
|
if (RedfishInterfaceData == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
RedfishInterfaceData->DeviceType = REDFISH_HOST_INTERFACE_DEVICE_TYPE_PCI_PCIE_V2;
|
|
//
|
|
// Fill up device type information.
|
|
//
|
|
ThisDeviceDescriptor = (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2 *)((UINT8 *)RedfishInterfaceData + 1);
|
|
ThisDeviceDescriptor->Length = sizeof (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2) + 1;
|
|
Status = GetMacAddressInformation (&MacAddress);
|
|
if (EFI_ERROR (Status)) {
|
|
FreePool (RedfishInterfaceData);
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
CopyMem ((VOID *)&ThisDeviceDescriptor->MacAddress, (VOID *)&MacAddress, sizeof (ThisDeviceDescriptor->MacAddress));
|
|
*DeviceType = REDFISH_HOST_INTERFACE_DEVICE_TYPE_PCI_PCIE_V2;
|
|
*DeviceDescriptor = RedfishInterfaceData;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Get platform Redfish host interface protocol data.
|
|
Caller should pass NULL in ProtocolRecord to retrive the first protocol record.
|
|
Then continuously pass previous ProtocolRecord for retrieving the next ProtocolRecord.
|
|
|
|
@param[out] ProtocolRecord Pointer to retrieve the protocol record.
|
|
caller has to free the new protocol record returned from
|
|
this function using FreePool().
|
|
@param[in] IndexOfProtocolData The index of protocol data.
|
|
|
|
@retval EFI_SUCCESS Protocol records are all returned.
|
|
@retval EFI_NOT_FOUND No more protocol records.
|
|
@retval Others Fail to get protocol records.
|
|
**/
|
|
EFI_STATUS
|
|
RedfishPlatformHostInterfaceProtocolData (
|
|
OUT MC_HOST_INTERFACE_PROTOCOL_RECORD **ProtocolRecord,
|
|
IN UINT8 IndexOfProtocolData
|
|
)
|
|
{
|
|
MC_HOST_INTERFACE_PROTOCOL_RECORD *ThisProtocolRecord;
|
|
|
|
if (mRedfishOverIpProtocolData == 0) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
if (IndexOfProtocolData == 0) {
|
|
//
|
|
// Return the first Redfish protocol data to caller. We only have
|
|
// one protocol data in this case.
|
|
//
|
|
ThisProtocolRecord = (MC_HOST_INTERFACE_PROTOCOL_RECORD *)AllocatePool (mRedfishProtocolDataSize + sizeof (MC_HOST_INTERFACE_PROTOCOL_RECORD) - 1);
|
|
ThisProtocolRecord->ProtocolType = MCHostInterfaceProtocolTypeRedfishOverIP;
|
|
ThisProtocolRecord->ProtocolTypeDataLen = mRedfishProtocolDataSize;
|
|
CopyMem ((VOID *)&ThisProtocolRecord->ProtocolTypeData, (VOID *)mRedfishOverIpProtocolData, mRedfishProtocolDataSize);
|
|
*ProtocolRecord = ThisProtocolRecord;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
/**
|
|
Dump IPv4 address.
|
|
|
|
@param[in] Ip IPv4 address
|
|
**/
|
|
VOID
|
|
InternalDumpIp4Addr (
|
|
IN EFI_IPv4_ADDRESS *Ip
|
|
)
|
|
{
|
|
UINTN Index;
|
|
|
|
for (Index = 0; Index < 4; Index++) {
|
|
DEBUG ((DEBUG_VERBOSE, "%d", Ip->Addr[Index]));
|
|
if (Index < 3) {
|
|
DEBUG ((DEBUG_VERBOSE, "."));
|
|
}
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "\n"));
|
|
}
|
|
|
|
/**
|
|
Dump IPv6 address.
|
|
|
|
@param[in] Ip IPv6 address
|
|
**/
|
|
VOID
|
|
InternalDumpIp6Addr (
|
|
IN EFI_IPv6_ADDRESS *Ip
|
|
)
|
|
{
|
|
UINTN Index;
|
|
|
|
for (Index = 0; Index < 16; Index++) {
|
|
if (Ip->Addr[Index] != 0) {
|
|
DEBUG ((DEBUG_VERBOSE, "%x", Ip->Addr[Index]));
|
|
}
|
|
|
|
Index++;
|
|
|
|
if (Index > 15) {
|
|
return;
|
|
}
|
|
|
|
if (((Ip->Addr[Index] & 0xf0) == 0) && (Ip->Addr[Index - 1] != 0)) {
|
|
DEBUG ((DEBUG_VERBOSE, "0"));
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "%x", Ip->Addr[Index]));
|
|
|
|
if (Index < 15) {
|
|
DEBUG ((DEBUG_VERBOSE, ":"));
|
|
}
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "\n"));
|
|
}
|
|
|
|
/**
|
|
Dump data
|
|
|
|
@param[in] Data Pointer to data.
|
|
@param[in] Size size of data to dump.
|
|
**/
|
|
VOID
|
|
InternalDumpData (
|
|
IN UINT8 *Data,
|
|
IN UINTN Size
|
|
)
|
|
{
|
|
UINTN Index;
|
|
|
|
for (Index = 0; Index < Size; Index++) {
|
|
DEBUG ((DEBUG_VERBOSE, "%02x ", (UINTN)Data[Index]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
Dump hex data
|
|
|
|
@param[in] Data Pointer to hex data.
|
|
@param[in] Size size of hex data to dump.
|
|
**/
|
|
VOID
|
|
InternalDumpHex (
|
|
IN UINT8 *Data,
|
|
IN UINTN Size
|
|
)
|
|
{
|
|
UINTN Index;
|
|
UINTN Count;
|
|
UINTN Left;
|
|
|
|
Count = Size / VERBOSE_COLUME_SIZE;
|
|
Left = Size % VERBOSE_COLUME_SIZE;
|
|
for (Index = 0; Index < Count; Index++) {
|
|
InternalDumpData (Data + Index * VERBOSE_COLUME_SIZE, VERBOSE_COLUME_SIZE);
|
|
DEBUG ((DEBUG_VERBOSE, "\n"));
|
|
}
|
|
|
|
if (Left != 0) {
|
|
InternalDumpData (Data + Index * VERBOSE_COLUME_SIZE, Left);
|
|
DEBUG ((DEBUG_VERBOSE, "\n"));
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "\n"));
|
|
}
|
|
|
|
/**
|
|
Dump Redfish over IP protocol data
|
|
|
|
@param[in] RedfishProtocolData Pointer to REDFISH_OVER_IP_PROTOCOL_DATA
|
|
@param[in] RedfishProtocolDataSize size of data to dump.
|
|
**/
|
|
VOID
|
|
DumpRedfishIpProtocolData (
|
|
IN REDFISH_OVER_IP_PROTOCOL_DATA *RedfishProtocolData,
|
|
IN UINT8 RedfishProtocolDataSize
|
|
)
|
|
{
|
|
CHAR16 Hostname[16];
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData: \n"));
|
|
InternalDumpHex ((UINT8 *)RedfishProtocolData, RedfishProtocolDataSize);
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "Parsing as below: \n"));
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->ServiceUuid - %g\n", &(RedfishProtocolData->ServiceUuid)));
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAssignmentType - %d\n", RedfishProtocolData->HostIpAssignmentType));
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAddressFormat - %d\n", RedfishProtocolData->HostIpAddressFormat));
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAddress: \n"));
|
|
if (RedfishProtocolData->HostIpAddressFormat == 0x01) {
|
|
InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *)(RedfishProtocolData->HostIpAddress));
|
|
} else {
|
|
InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *)(RedfishProtocolData->HostIpAddress));
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpMask: \n"));
|
|
if (RedfishProtocolData->HostIpAddressFormat == 0x01) {
|
|
InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *)(RedfishProtocolData->HostIpMask));
|
|
} else {
|
|
InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *)(RedfishProtocolData->HostIpMask));
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpDiscoveryType - %d\n", RedfishProtocolData->RedfishServiceIpDiscoveryType));
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpAddressFormat - %d\n", RedfishProtocolData->RedfishServiceIpAddressFormat));
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpAddress: \n"));
|
|
if (RedfishProtocolData->RedfishServiceIpAddressFormat == 0x01) {
|
|
InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *)(RedfishProtocolData->RedfishServiceIpAddress));
|
|
} else {
|
|
InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *)(RedfishProtocolData->RedfishServiceIpAddress));
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpMask: \n"));
|
|
if (RedfishProtocolData->RedfishServiceIpAddressFormat == 0x01) {
|
|
InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *)(RedfishProtocolData->RedfishServiceIpMask));
|
|
} else {
|
|
InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *)(RedfishProtocolData->RedfishServiceIpMask));
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpPort - %d\n", RedfishProtocolData->RedfishServiceIpPort));
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceVlanId - %d\n", RedfishProtocolData->RedfishServiceVlanId));
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceHostnameLength - %d\n", RedfishProtocolData->RedfishServiceHostnameLength));
|
|
|
|
AsciiStrToUnicodeStrS ((CHAR8 *)RedfishProtocolData->RedfishServiceHostname, Hostname, sizeof (Hostname) / sizeof (Hostname[0]));
|
|
DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceHostname - %s\n", Hostname));
|
|
}
|
|
|
|
/**
|
|
Get Redfish host interface protocol data from variale.
|
|
|
|
@param[out] RedfishProtocolData Pointer to retrieve REDFISH_OVER_IP_PROTOCOL_DATA.
|
|
@param[out] RedfishProtocolDataSize Size of REDFISH_OVER_IP_PROTOCOL_DATA.
|
|
|
|
@retval EFI_SUCESS REDFISH_OVER_IP_PROTOCOL_DATA is returned successfully.
|
|
**/
|
|
EFI_STATUS
|
|
GetRedfishRecordFromVariable (
|
|
OUT REDFISH_OVER_IP_PROTOCOL_DATA **RedfishProtocolData,
|
|
OUT UINT8 *RedfishProtocolDataSize
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT8 HostIpAssignmentType;
|
|
UINTN HostIpAssignmentTypeSize;
|
|
EFI_IPv4_ADDRESS HostIpAddress;
|
|
UINTN IPv4DataSize;
|
|
EFI_IPv4_ADDRESS HostIpMask;
|
|
EFI_IPv4_ADDRESS RedfishServiceIpAddress;
|
|
EFI_IPv4_ADDRESS RedfishServiceIpMask;
|
|
UINT16 RedfishServiceIpPort;
|
|
UINTN IpPortDataSize;
|
|
UINT8 HostNameSize;
|
|
CHAR8 RedfishHostName[20];
|
|
|
|
if ((RedfishProtocolData == NULL) || (RedfishProtocolDataSize == NULL)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// 1. Retrieve Address Information from variable.
|
|
//
|
|
Status = gRT->GetVariable (
|
|
L"HostIpAssignmentType",
|
|
&gEmuRedfishServiceGuid,
|
|
NULL,
|
|
&HostIpAssignmentTypeSize,
|
|
&HostIpAssignmentType
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpAssignmentType - %r\n", Status));
|
|
return Status;
|
|
}
|
|
|
|
IPv4DataSize = sizeof (EFI_IPv4_ADDRESS);
|
|
if (HostIpAssignmentType == 1 ) {
|
|
Status = gRT->GetVariable (
|
|
L"HostIpAddress",
|
|
&gEmuRedfishServiceGuid,
|
|
NULL,
|
|
&IPv4DataSize,
|
|
&HostIpAddress
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpAddress - %r\n", Status));
|
|
return Status;
|
|
}
|
|
|
|
Status = gRT->GetVariable (
|
|
L"HostIpMask",
|
|
&gEmuRedfishServiceGuid,
|
|
NULL,
|
|
&IPv4DataSize,
|
|
&HostIpMask
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpMask - %r\n", Status));
|
|
return Status;
|
|
}
|
|
}
|
|
|
|
Status = gRT->GetVariable (
|
|
L"RedfishServiceIpAddress",
|
|
&gEmuRedfishServiceGuid,
|
|
NULL,
|
|
&IPv4DataSize,
|
|
&RedfishServiceIpAddress
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpAddress - %r\n", Status));
|
|
return Status;
|
|
}
|
|
|
|
Status = gRT->GetVariable (
|
|
L"RedfishServiceIpMask",
|
|
&gEmuRedfishServiceGuid,
|
|
NULL,
|
|
&IPv4DataSize,
|
|
&RedfishServiceIpMask
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpMask - %r\n", Status));
|
|
return Status;
|
|
}
|
|
|
|
Status = gRT->GetVariable (
|
|
L"RedfishServiceIpPort",
|
|
&gEmuRedfishServiceGuid,
|
|
NULL,
|
|
&IpPortDataSize,
|
|
&RedfishServiceIpPort
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpPort - %r\n", Status));
|
|
return Status;
|
|
}
|
|
|
|
AsciiSPrint (
|
|
RedfishHostName,
|
|
sizeof (RedfishHostName),
|
|
"%d.%d.%d.%d",
|
|
RedfishServiceIpAddress.Addr[0],
|
|
RedfishServiceIpAddress.Addr[1],
|
|
RedfishServiceIpAddress.Addr[2],
|
|
RedfishServiceIpAddress.Addr[3]
|
|
);
|
|
|
|
HostNameSize = (UINT8)AsciiStrLen (RedfishHostName) + 1;
|
|
|
|
//
|
|
// 2. Protocol Data Size.
|
|
//
|
|
*RedfishProtocolDataSize = sizeof (REDFISH_OVER_IP_PROTOCOL_DATA) - 1 + HostNameSize;
|
|
|
|
//
|
|
// 3. Protocol Data.
|
|
//
|
|
*RedfishProtocolData = (REDFISH_OVER_IP_PROTOCOL_DATA *)AllocateZeroPool (*RedfishProtocolDataSize);
|
|
if (*RedfishProtocolData == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
CopyGuid (&(*RedfishProtocolData)->ServiceUuid, &gEmuRedfishServiceGuid);
|
|
|
|
(*RedfishProtocolData)->HostIpAssignmentType = HostIpAssignmentType;
|
|
(*RedfishProtocolData)->HostIpAddressFormat = 1; // Only support IPv4
|
|
|
|
if (HostIpAssignmentType == 1 ) {
|
|
(*RedfishProtocolData)->HostIpAddress[0] = HostIpAddress.Addr[0];
|
|
(*RedfishProtocolData)->HostIpAddress[1] = HostIpAddress.Addr[1];
|
|
(*RedfishProtocolData)->HostIpAddress[2] = HostIpAddress.Addr[2];
|
|
(*RedfishProtocolData)->HostIpAddress[3] = HostIpAddress.Addr[3];
|
|
|
|
(*RedfishProtocolData)->HostIpMask[0] = HostIpMask.Addr[0];
|
|
(*RedfishProtocolData)->HostIpMask[1] = HostIpMask.Addr[1];
|
|
(*RedfishProtocolData)->HostIpMask[2] = HostIpMask.Addr[2];
|
|
(*RedfishProtocolData)->HostIpMask[3] = HostIpMask.Addr[3];
|
|
}
|
|
|
|
(*RedfishProtocolData)->RedfishServiceIpDiscoveryType = 1; // Use static IP address
|
|
(*RedfishProtocolData)->RedfishServiceIpAddressFormat = 1; // Only support IPv4
|
|
|
|
(*RedfishProtocolData)->RedfishServiceIpAddress[0] = RedfishServiceIpAddress.Addr[0];
|
|
(*RedfishProtocolData)->RedfishServiceIpAddress[1] = RedfishServiceIpAddress.Addr[1];
|
|
(*RedfishProtocolData)->RedfishServiceIpAddress[2] = RedfishServiceIpAddress.Addr[2];
|
|
(*RedfishProtocolData)->RedfishServiceIpAddress[3] = RedfishServiceIpAddress.Addr[3];
|
|
|
|
(*RedfishProtocolData)->RedfishServiceIpMask[0] = RedfishServiceIpMask.Addr[0];
|
|
(*RedfishProtocolData)->RedfishServiceIpMask[1] = RedfishServiceIpMask.Addr[1];
|
|
(*RedfishProtocolData)->RedfishServiceIpMask[2] = RedfishServiceIpMask.Addr[2];
|
|
(*RedfishProtocolData)->RedfishServiceIpMask[3] = RedfishServiceIpMask.Addr[3];
|
|
|
|
(*RedfishProtocolData)->RedfishServiceIpPort = RedfishServiceIpPort;
|
|
(*RedfishProtocolData)->RedfishServiceVlanId = 0xffffffff;
|
|
|
|
(*RedfishProtocolData)->RedfishServiceHostnameLength = HostNameSize;
|
|
AsciiStrCpyS ((CHAR8 *)((*RedfishProtocolData)->RedfishServiceHostname), HostNameSize, RedfishHostName);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Construct Redfish host interface protocol data.
|
|
|
|
@param ImageHandle The image handle.
|
|
@param SystemTable The system table.
|
|
|
|
@retval EFI_SUCEESS Install Boot manager menu success.
|
|
@retval Other Return error status.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
RedfishPlatformHostInterfaceConstructor (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
Status = GetRedfishRecordFromVariable (&mRedfishOverIpProtocolData, &mRedfishProtocolDataSize);
|
|
DEBUG ((DEBUG_INFO, "%a: GetRedfishRecordFromVariable() - %r\n", __func__, Status));
|
|
if (!EFI_ERROR (Status)) {
|
|
DumpRedfishIpProtocolData (mRedfishOverIpProtocolData, mRedfishProtocolDataSize);
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Get the EFI protocol GUID installed by platform library which
|
|
indicates the necessary information is ready for building
|
|
SMBIOS 42h record.
|
|
|
|
@param[out] InformationReadinessGuid Pointer to retrive the protocol
|
|
GUID.
|
|
|
|
@retval EFI_SUCCESS Notification is required for building up
|
|
SMBIOS type 42h record.
|
|
@retval EFI_UNSUPPORTED Notification is not required for building up
|
|
SMBIOS type 42h record.
|
|
@retval EFI_ALREADY_STARTED Platform host information is already ready.
|
|
@retval Others Other errors.
|
|
**/
|
|
EFI_STATUS
|
|
RedfishPlatformHostInterfaceNotification (
|
|
OUT EFI_GUID **InformationReadinessGuid
|
|
)
|
|
{
|
|
return EFI_UNSUPPORTED;
|
|
}
|