/** @file
|
Platform Info PEIM.
|
|
@copyright
|
Copyright 1999 - 2021 Intel Corporation.
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
**/
|
|
#include "PlatformInfo.h"
|
#include <GpioPinsSklH.h>
|
#include <Library/GpioLib.h>
|
#include <Library/PchInfoLib.h>
|
|
#include <Ppi/DynamicSiLibraryPpi.h>
|
|
#include <Library/UbaGpioPlatformConfig.h>
|
#include <UncoreCommonIncludes.h>
|
#include <PlatformInfoTypes.h>
|
|
#include <Library/PeiServicesLib.h>
|
|
#define TEMP_BUS_NUMBER (0x3F)
|
|
|
STATIC EFI_PEI_PPI_DESCRIPTOR mPlatformInfoPpi = {
|
EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
|
&gEfiPlatformInfoGuid,
|
NULL
|
};
|
|
#define BOARD_ID_GPIO_PADS_NUMBER 6
|
#define BOARD_REV_ID_GPIO_PADS_NUMBER 3
|
|
//
|
// These pads shall not be board specific as these are used for Board ID and Rev ID detection
|
// Therefore can not be moved to UBA and are common for all Purley boards
|
//
|
GPIO_PAD mBoardId [BOARD_ID_GPIO_PADS_NUMBER] = {
|
// BoardId pads - PADCFG register for GPIO G12
|
// WARNING: The pad number must be obtained from board schematics
|
GPIO_SKL_H_GPP_G12,
|
GPIO_SKL_H_GPP_G13,
|
GPIO_SKL_H_GPP_G14,
|
GPIO_SKL_H_GPP_G15,
|
GPIO_SKL_H_GPP_G16,
|
GPIO_SKL_H_GPP_B19
|
};
|
|
GPIO_PAD mBoardRevId [BOARD_REV_ID_GPIO_PADS_NUMBER] = {
|
// Board RevId pads - Start from pad C12
|
// WARNING: This should be obtained from board schematics
|
GPIO_SKL_H_GPP_C12,
|
GPIO_SKL_H_GPP_C13,
|
GPIO_SKL_H_GPP_B9
|
};
|
|
GPIO_CONFIG mBoardAndRevIdConfig = {
|
// Board and Revision ID pads configuration required for proper reading the values
|
GpioPadModeGpio, GpioHostOwnDefault, GpioDirIn, GpioOutDefault, GpioIntDefault,
|
GpioPlatformReset, GpioTermDefault, GpioLockDefault, GpioRxRaw1Default
|
};
|
|
|
VOID
|
GpioConfigForBoardId (
|
VOID
|
)
|
{
|
UINT8 i;
|
EFI_STATUS Status;
|
GPIO_CONFIG PadConfig;
|
DYNAMIC_SI_LIBARY_PPI *DynamicSiLibraryPpi = NULL;
|
|
PadConfig.PadMode = mBoardAndRevIdConfig.PadMode;
|
PadConfig.HostSoftPadOwn = mBoardAndRevIdConfig.HostSoftPadOwn;
|
PadConfig.Direction = mBoardAndRevIdConfig.Direction;
|
PadConfig.OutputState = mBoardAndRevIdConfig.OutputState;
|
PadConfig.InterruptConfig = mBoardAndRevIdConfig.InterruptConfig;
|
PadConfig.PowerConfig = mBoardAndRevIdConfig.PowerConfig;
|
PadConfig.ElectricalConfig = mBoardAndRevIdConfig.ElectricalConfig;
|
PadConfig.LockConfig = mBoardAndRevIdConfig.LockConfig;
|
PadConfig.OtherSettings = mBoardAndRevIdConfig.OtherSettings;
|
|
Status = PeiServicesLocatePpi (&gDynamicSiLibraryPpiGuid, 0, NULL, &DynamicSiLibraryPpi);
|
if (EFI_ERROR (Status)) {
|
ASSERT_EFI_ERROR (Status);
|
return;
|
}
|
|
for (i = 0; i < BOARD_ID_GPIO_PADS_NUMBER; i++) {
|
Status = DynamicSiLibraryPpi->GpioSetPadConfig (mBoardId[i], &PadConfig);
|
ASSERT_EFI_ERROR (Status);
|
}
|
}
|
|
|
VOID
|
GpioConfigForBoardRevId (
|
VOID
|
)
|
{
|
UINT8 i;
|
EFI_STATUS Status;
|
GPIO_CONFIG PadConfig;
|
DYNAMIC_SI_LIBARY_PPI *DynamicSiLibraryPpi = NULL;
|
|
PadConfig.PadMode = mBoardAndRevIdConfig.PadMode;
|
PadConfig.HostSoftPadOwn = mBoardAndRevIdConfig.HostSoftPadOwn;
|
PadConfig.Direction = mBoardAndRevIdConfig.Direction;
|
PadConfig.OutputState = mBoardAndRevIdConfig.OutputState;
|
PadConfig.InterruptConfig = mBoardAndRevIdConfig.InterruptConfig;
|
PadConfig.PowerConfig = mBoardAndRevIdConfig.PowerConfig;
|
PadConfig.ElectricalConfig = mBoardAndRevIdConfig.ElectricalConfig;
|
PadConfig.LockConfig = mBoardAndRevIdConfig.LockConfig;
|
PadConfig.OtherSettings = mBoardAndRevIdConfig.OtherSettings;
|
|
Status = PeiServicesLocatePpi (&gDynamicSiLibraryPpiGuid, 0, NULL, &DynamicSiLibraryPpi);
|
if (EFI_ERROR (Status)) {
|
ASSERT_EFI_ERROR (Status);
|
return;
|
}
|
|
for (i = 0; i < BOARD_REV_ID_GPIO_PADS_NUMBER; i++) {
|
Status = DynamicSiLibraryPpi->GpioSetPadConfig (mBoardRevId[i], &PadConfig);
|
ASSERT_EFI_ERROR (Status);
|
}
|
}
|
|
/**
|
|
Reads GPIO pins to get Board ID value
|
|
@retval Status - Success if GPIO's are read properly
|
|
**/
|
EFI_STATUS
|
GpioGetBoardId (
|
OUT UINT32 *BoardId
|
)
|
{
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
UINT32 Data32;
|
UINT8 i;
|
UINT32 BdId;
|
DYNAMIC_SI_LIBARY_PPI *DynamicSiLibraryPpi = NULL;
|
|
if (BoardId == NULL) {
|
return EFI_UNSUPPORTED;
|
}
|
|
Status = PeiServicesLocatePpi (&gDynamicSiLibraryPpiGuid, 0, NULL, &DynamicSiLibraryPpi);
|
if (EFI_ERROR (Status)) {
|
ASSERT_EFI_ERROR (Status);
|
return Status;
|
}
|
|
BdId = 0;
|
|
GpioConfigForBoardId ();
|
|
for (i = 0; i < BOARD_ID_GPIO_PADS_NUMBER; i++) {
|
Status = DynamicSiLibraryPpi->GpioGetInputValue (mBoardId[i], &Data32);
|
if (EFI_ERROR(Status)) {
|
break;
|
}
|
if (Data32) {
|
BdId = BdId | (1 << i);
|
}
|
}
|
if (Status != EFI_SUCCESS) {
|
return Status;
|
}
|
*BoardId = BdId;
|
return EFI_SUCCESS;
|
}
|
|
/**
|
|
Reads GPIO pins to get Board Revision ID value
|
|
@retval Status - Success if GPIO's are read properly
|
|
**/
|
EFI_STATUS
|
GpioGetBoardRevId (
|
OUT UINT32 *BoardRevId
|
)
|
{
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
UINT32 Data32;
|
UINT8 i;
|
UINT32 RevId;
|
DYNAMIC_SI_LIBARY_PPI *DynamicSiLibraryPpi = NULL;
|
|
if (BoardRevId == NULL) {
|
return EFI_UNSUPPORTED;
|
}
|
|
Status = PeiServicesLocatePpi (&gDynamicSiLibraryPpiGuid, 0, NULL, &DynamicSiLibraryPpi);
|
if (EFI_ERROR (Status)) {
|
ASSERT_EFI_ERROR (Status);
|
return Status;
|
}
|
|
RevId = 0;
|
|
GpioConfigForBoardRevId ();
|
|
for (i = 0; i < BOARD_REV_ID_GPIO_PADS_NUMBER; i++){
|
Status = DynamicSiLibraryPpi->GpioGetInputValue (mBoardRevId[i], &Data32);
|
if (EFI_ERROR(Status)) {
|
break;
|
}
|
if (Data32) {
|
RevId = RevId | (1 << i);
|
}
|
}
|
if (Status != EFI_SUCCESS) {
|
return Status;
|
}
|
*BoardRevId = RevId;
|
return EFI_SUCCESS;
|
|
}
|
|
/**
|
|
Returns the Model ID of the CPU.
|
Model ID = EAX[7:4]
|
|
**/
|
VOID
|
GetCpuInfo (
|
UINT32 *CpuType,
|
UINT8 *CpuStepping
|
)
|
|
{
|
UINT32 RegEax=0;
|
|
AsmCpuid (CPUID_VERSION_INFO, &RegEax, NULL, NULL, NULL);
|
|
*CpuStepping = (UINT8) (RegEax & 0x0F);
|
*CpuType = (UINT32) (RegEax >> 4);
|
}
|
|
|
/**
|
|
GC_TODO: add routine description
|
|
@param BAR - GC_TODO: add arg description
|
@param PeiServices - GC_TODO: add arg description
|
|
@retval None
|
|
**/
|
VOID
|
InitGSX(
|
UINT32 *BAR,
|
IN EFI_PEI_SERVICES **PeiServices
|
)
|
{
|
}
|
|
/**
|
|
GC_TODO: add routine description
|
|
@param Data - GC_TODO: add arg description
|
@param PeiServices - GC_TODO: add arg description
|
|
@retval EFI_SUCCESS - GC_TODO: add retval description
|
@retval EFI_UNSUPPORTED - GC_TODO: add retval description
|
|
**/
|
EFI_STATUS
|
GsxRead(
|
UINT32 *Data,
|
IN EFI_PEI_SERVICES **PeiServices
|
)
|
{
|
return EFI_UNSUPPORTED;
|
}
|
|
/**
|
|
GC_TODO: add routine description
|
|
@param Data - GC_TODO: add arg description
|
@param PeiServices - GC_TODO: add arg description
|
|
@retval None
|
|
**/
|
VOID
|
GetGsxBoardID(
|
BOARD_ID *Data,
|
IN EFI_PEI_SERVICES **PeiServices
|
)
|
{
|
|
EFI_STATUS Status;
|
UINT32 GSXIN[2];
|
UINT32 RetryCount;
|
|
RetryCount = 0;
|
GSXIN[0] = 0;
|
GSXIN[1] = 0;
|
|
do {
|
Status = GsxRead(GSXIN, PeiServices);
|
|
if(Status){
|
// if EFI_SUCCESS != Success then retry one more time
|
RetryCount ++;
|
}else{
|
// if EFI_SUCCESS read Board ID and exit
|
RetryCount = 0xFFFFFFFF;
|
}
|
|
if (GSXIN[0] & BIT0) {
|
Data->BoardID.BoardID0 = 1;
|
}
|
|
if (GSXIN[0] & BIT1) {
|
Data->BoardID.BoardID1 = 1;
|
}
|
|
if (GSXIN[0] & BIT2) {
|
Data->BoardID.BoardID2 = 1;
|
}
|
|
if (GSXIN[0] & BIT3) {
|
Data->BoardID.BoardID3 = 1;
|
}
|
|
if (GSXIN[0] & BIT4) {
|
Data->BoardID.BoardID4 = 1;
|
}
|
|
if (GSXIN[0] & BIT5) {
|
Data->BoardID.BoardRev0 = 1;
|
}
|
|
if (GSXIN[0] & BIT6) {
|
Data->BoardID.BoardRev1 = 1;
|
}
|
|
} while(RetryCount < 1);
|
|
if(Status){
|
//
|
// Unhable to read GSX HW error Hang the system
|
//
|
DEBUG ((EFI_D_ERROR, "ERROR: GSX HW is unavailable, SYSTEM HANG\n"));
|
CpuDeadLoop ();
|
}
|
}
|
|
/**
|
Get Platform Type by read Platform Data Region in SPI flash.
|
SPI Descriptor Mode Routines for Accessing Platform Info from Platform Data Region (PDR)
|
|
@param PeiServices - General purpose services available to every PEIM.
|
@param PlatformInfoHob - Platform Type is returned in PlatformInfoHob->BoardId
|
|
@retval Status EFI_SUCCESS - PDR read success
|
@retval Status EFI_INCOMPATIBLE_VERSION - PDR read but it is not valid Platform Type
|
|
**/
|
EFI_STATUS
|
PdrGetPlatformInfo (
|
IN CONST EFI_PEI_SERVICES **PeiServices,
|
OUT EFI_PLATFORM_INFO *PlatformInfoHob
|
)
|
{
|
EFI_STATUS Status;
|
PCH_SPI_PROTOCOL *SpiPpi;
|
UINTN Size;
|
|
//
|
// Locate the SPI PPI Interface
|
//
|
Status = (*PeiServices)->LocatePpi (
|
PeiServices,
|
&gPchSpiPpiGuid,
|
0,
|
NULL,
|
&SpiPpi
|
);
|
|
if (EFI_ERROR (Status)) {
|
ASSERT_EFI_ERROR (Status);
|
return Status;
|
}
|
|
//
|
// Read the PIT (Platform Info Table) from the SPI Flash Platform Data Region
|
//
|
Size = sizeof (EFI_PLATFORM_INFO);
|
Status = SpiPpi->FlashRead (
|
SpiPpi,
|
FlashRegionPlatformData,
|
PDR_REGION_START_OFFSET,
|
(UINT32) Size,
|
(UINT8 *) PlatformInfoHob
|
);
|
if (EFI_ERROR (Status)) {
|
ASSERT_EFI_ERROR (Status);
|
return Status;
|
}
|
|
if ((PlatformInfoHob->BoardId >= TypePlatformMin) && (PlatformInfoHob->BoardId <= TypePlatformMax)) {
|
//
|
// Valid Platform Identified
|
//
|
DEBUG ((DEBUG_INFO, "Platform Info from PDR: Type = %x\n",PlatformInfoHob->BoardId));
|
} else {
|
//
|
// Reading PIT from SPI PDR Failed or a unknown platform identified
|
//
|
DEBUG ((EFI_D_ERROR, "PIT from SPI PDR reports Platform ID as %x. This is unknown ID. Assuming Greencity Platform!\n", PlatformInfoHob->BoardId));
|
PlatformInfoHob->BoardId = TypePlatformUnknown;
|
Status = EFI_INCOMPATIBLE_VERSION;
|
}
|
return Status;
|
}
|
|
VOID
|
GatherQATInfo(OUT EFI_PLATFORM_INFO *PlatformInfoHob)
|
/**
|
|
GC_TODO: add routine description
|
|
@param None
|
|
@ret None
|
**/
|
{
|
EFI_STATUS Status;
|
GPIO_CONFIG PadConfig;
|
DYNAMIC_SI_LIBARY_PPI *DynamicSiLibraryPpi = NULL;
|
|
// Gpio programming to QAT board detection
|
PadConfig.PadMode = GpioPadModeGpio;
|
PadConfig.HostSoftPadOwn = GpioHostOwnDefault;
|
PadConfig.Direction = GpioDirIn;
|
PadConfig.OutputState = GpioOutLow;
|
PadConfig.InterruptConfig = GpioIntDis;
|
PadConfig.PowerConfig = GpioResetPwrGood;
|
PadConfig.ElectricalConfig = GpioTermNone;
|
PadConfig.LockConfig = GpioPadConfigLock;
|
PadConfig.OtherSettings = 00;
|
|
Status = PeiServicesLocatePpi (&gDynamicSiLibraryPpiGuid, 0, NULL, &DynamicSiLibraryPpi);
|
if (EFI_ERROR (Status)) {
|
ASSERT_EFI_ERROR (Status);
|
return;
|
}
|
|
Status = DynamicSiLibraryPpi->GpioSetPadConfig (GPIO_SKL_H_GPP_B3, &PadConfig);
|
Status = DynamicSiLibraryPpi->GpioGetInputValue (GPIO_SKL_H_GPP_B3, &PlatformInfoHob->QATDis);
|
Status = DynamicSiLibraryPpi->GpioSetPadConfig (GPIO_SKL_H_GPP_B4, &PadConfig);
|
Status = DynamicSiLibraryPpi->GpioGetInputValue (GPIO_SKL_H_GPP_B4, &PlatformInfoHob->QATSel);
|
}
|
|
EFI_STATUS
|
GetPlatformInfo (
|
IN CONST EFI_PEI_SERVICES **PeiServices,
|
OUT EFI_PLATFORM_INFO *PlatformInfoHob
|
)
|
/**
|
|
GC_TODO: add routine description
|
|
@param PeiServices - GC_TODO: add arg description
|
@param PlatformInfoHob - GC_TODO: add arg description
|
|
@retval EFI_UNSUPPORTED - GC_TODO: add retval description
|
@retval EFI_SUCCESS - GC_TODO: add retval description
|
|
**/
|
{
|
|
|
UINT32 BoardId;
|
UINT32 BoardRev;
|
EFI_PEI_PCI_CFG2_PPI *PciCfgPpi;
|
EFI_STATUS Status;
|
|
PciCfgPpi = (**PeiServices).PciCfg;
|
ASSERT (PciCfgPpi != NULL);
|
|
PlatformInfoHob->BoardId = TypeNeonCityEPRP;
|
DEBUG ((DEBUG_INFO, "Use GPIO to read Board ID\n"));
|
|
Status = GpioGetBoardId (&BoardId);
|
if (EFI_ERROR (Status)) {
|
DEBUG ((EFI_D_ERROR, "Error: Can't read GPIO to get Board ID!\n"));
|
return Status;
|
}
|
Status = GpioGetBoardRevId (&BoardRev);
|
if (EFI_ERROR(Status)) {
|
DEBUG ((EFI_D_ERROR, "Error: Can't read GPIO to get Board ID!\n"));
|
return Status;
|
}
|
PlatformInfoHob->TypeRevisionId = BoardRev;
|
|
switch (BoardId) {
|
case 0x00: // for Simics
|
PlatformInfoHob->BoardId = TypeWilsonCityRP;
|
break;
|
case 0x01:
|
PlatformInfoHob->BoardId = TypeWilsonCityRP;
|
DEBUG ((DEBUG_INFO, "Board ID = TypeWilsonCityRP\n"));
|
break;
|
case 0x12:
|
PlatformInfoHob->BoardId = TypeWilsonCityRP;
|
DEBUG((DEBUG_INFO, "Board ID = TypeWilsonCityRP\n"));
|
break;
|
case 0x15:
|
PlatformInfoHob->BoardId = TypeWilsonCitySMT;
|
DEBUG((DEBUG_INFO, "Board ID = TypeWilsonCitySMT\n"));
|
break;
|
case 0x17:
|
case 0x18:
|
PlatformInfoHob->BoardId = TypeCooperCityRP;
|
DEBUG((DEBUG_INFO, "Board ID = TypeCooperCityRP\n"));
|
break;
|
default:
|
PlatformInfoHob->BoardId = TypePlatformDefault;
|
DEBUG ((DEBUG_INFO, "Board ID = %2X Default set to TypePlatformDefault\n",BoardId));
|
break;
|
}
|
|
GatherQATInfo(PlatformInfoHob);
|
|
DEBUG ((DEBUG_INFO, "Board Rev.: %d\n", BoardRev));
|
return EFI_SUCCESS;
|
}
|
|
/**
|
|
This function initializes the board related flag to indicates if
|
PCH and Lan-On-Motherboard (LOM) devices is supported.
|
|
**/
|
VOID
|
GetPchLanSupportInfo(
|
IN EFI_PLATFORM_INFO *PlatformInfoHob
|
)
|
{
|
PlatformInfoHob->PchData.LomLanSupported = 0;
|
}
|
|
/**
|
|
GC_TODO: add routine description
|
|
@param PeiVariable - GC_TODO: add arg description
|
@param PlatformInfoHob - GC_TODO: add arg description
|
|
@retval EFI_SUCCESS - GC_TODO: add retval description
|
|
**/
|
EFI_STATUS
|
EFIAPI
|
GetIioCommonRcPlatformSetupPolicy(
|
OUT EFI_PLATFORM_INFO *PlatformInfoHob
|
)
|
{
|
UINT8 IsocEn;
|
|
CopyMem (&IsocEn, (UINT8 *)PcdGetPtr(PcdSocketCommonRcConfig) + OFFSET_OF(SOCKET_COMMONRC_CONFIGURATION, IsocEn), sizeof(UINT8));
|
|
PlatformInfoHob->SysData.IsocEn = IsocEn; // ISOC enabled
|
|
return EFI_SUCCESS;
|
}
|
/**
|
|
GC_TODO: add routine description
|
|
@param PeiVariable - GC_TODO: add arg description
|
@param PlatformInfoHob - GC_TODO: add arg description
|
|
@retval EFI_SUCCESS - GC_TODO: add retval description
|
|
**/
|
EFI_STATUS
|
EFIAPI
|
GetIioPlatformSetupPolicy(
|
OUT EFI_PLATFORM_INFO *PlatformInfoHob
|
)
|
{
|
return EFI_SUCCESS;
|
}
|
|
|
/**
|
Platform Type detection. Because the PEI globle variable
|
is in the flash, it could not change directly.So use
|
2 PPIs to distinguish the platform type.
|
|
@param FfsHeader - Pointer to Firmware File System file header.
|
@param PeiServices - General purpose services available to every PEIM.
|
|
@retval EFI_SUCCESS - Memory initialization completed successfully.
|
@retval Others - All other error conditions encountered result in an ASSERT.
|
|
**/
|
EFI_STATUS
|
EFIAPI
|
PlatformInfoInit (
|
IN EFI_PEI_FILE_HANDLE FileHandle,
|
IN CONST EFI_PEI_SERVICES **PeiServices
|
)
|
{
|
EFI_STATUS Status;
|
EFI_PEI_PCI_CFG2_PPI *PciCfgPpi;
|
EFI_PEI_READ_ONLY_VARIABLE2_PPI *PeiVariable;
|
EFI_PLATFORM_INFO PlatformInfoHob;
|
EFI_PLATFORM_INFO tempPlatformInfoHob;
|
UINT8 ChipId;
|
UINT32 Delay;
|
UINT32 CpuType;
|
UINT8 CpuStepping;
|
DYNAMIC_SI_LIBARY_PPI *DynamicSiLibraryPpi = NULL;
|
|
PciCfgPpi = (**PeiServices).PciCfg;
|
if (PciCfgPpi == NULL) {
|
DEBUG ((EFI_D_ERROR, "\nError! PlatformInfoInit() - PeiServices is a NULL Pointer!!!\n"));
|
ASSERT_EFI_ERROR (EFI_INVALID_PARAMETER);
|
return EFI_INVALID_PARAMETER;
|
}
|
|
//
|
// Locate Variable PPI
|
//
|
Status = PeiServicesLocatePpi (&gEfiPeiReadOnlyVariable2PpiGuid, 0, NULL, &PeiVariable);
|
|
(*PeiServices)->SetMem (&PlatformInfoHob, sizeof (PlatformInfoHob), 0);
|
|
Status = PeiServicesLocatePpi (&gDynamicSiLibraryPpiGuid, 0, NULL, &DynamicSiLibraryPpi);
|
if (EFI_ERROR (Status)) {
|
ASSERT_EFI_ERROR (Status);
|
return Status;
|
}
|
|
//
|
// --------------------------------------------------
|
//
|
// Detect the iBMC SIO for CV/CRB Platforms
|
// 0x2E/0x2F decoding has been enabled in MonoStatusCode PEIM.
|
//
|
IoWrite8 (PILOTIV_SIO_INDEX_PORT, PILOTIV_SIO_UNLOCK);
|
for (Delay = 0; Delay < 40; Delay++) IoRead8 (0x61);
|
IoWrite8 (PILOTIV_SIO_INDEX_PORT, PILOTIV_CHIP_ID_REG);
|
for (Delay = 0; Delay < 40; Delay++) IoRead8 (0x61);
|
ChipId = IoRead8 (PILOTIV_SIO_DATA_PORT);
|
for (Delay = 0; Delay < 40; Delay++) IoRead8 (0x61);
|
IoWrite8 (PILOTIV_SIO_INDEX_PORT, PILOTIV_SIO_LOCK);
|
for (Delay = 0; Delay < 40; Delay++) IoRead8 (0x61);
|
|
if (EFI_ERROR (Status))
|
{
|
DEBUG((EFI_D_ERROR, "LocatePpi Error in PlatformInfo.c !\n"));
|
}
|
|
Status = GetIioPlatformSetupPolicy (&PlatformInfoHob);
|
ASSERT_EFI_ERROR (Status);
|
Status = GetIioCommonRcPlatformSetupPolicy (&PlatformInfoHob);
|
ASSERT_EFI_ERROR (Status);
|
|
//
|
// Update PCH Type
|
//
|
PlatformInfoHob.PchType = DynamicSiLibraryPpi->GetPchSeries ();
|
PlatformInfoHob.PchSku = DynamicSiLibraryPpi->GetPchLpcDeviceId ();
|
PlatformInfoHob.PchRevision = (UINT8) DynamicSiLibraryPpi->PchStepping ();
|
PlatformInfoHob.MaxNumOfPchs = 1;
|
Status = EFI_SUCCESS;
|
|
if(!EFI_ERROR(Status)) {
|
Status = GetPlatformInfo (PeiServices, &PlatformInfoHob);
|
if(EFI_ERROR (Status)) {
|
Status = PdrGetPlatformInfo (PeiServices, &tempPlatformInfoHob);
|
PlatformInfoHob.BoardId = tempPlatformInfoHob.BoardId;
|
PlatformInfoHob.TypeRevisionId = tempPlatformInfoHob.TypeRevisionId;
|
if (EFI_ERROR(Status)) {
|
PlatformInfoHob.BoardId = TypePlatformUnknown;
|
}
|
}
|
} else {
|
PlatformInfoHob.BoardId = TypePlatformUnknown;
|
}
|
|
//
|
// Update IIO Type
|
//
|
PlatformInfoHob.IioRevision = 0;
|
|
|
//
|
// Get Subtractive decode enable bit from descriptor
|
//
|
|
if (DynamicSiLibraryPpi->PchIsGbeRegionValid () == FALSE) {
|
PlatformInfoHob.PchData.GbeRegionInvalid = 1;
|
} else {
|
PlatformInfoHob.PchData.GbeRegionInvalid = 0;
|
}
|
GetPchLanSupportInfo (&PlatformInfoHob);
|
PlatformInfoHob.PchData.GbePciePortNum = 0xFF;
|
PlatformInfoHob.PchData.GbePciePortNum = (UINT8) DynamicSiLibraryPpi->PchGetGbePortNumber ();
|
PlatformInfoHob.PchData.GbeEnabled = DynamicSiLibraryPpi->PchIsGbePresent ();
|
PlatformInfoHob.PchData.PchStepping = (UINT8) DynamicSiLibraryPpi->PchStepping ();
|
|
PlatformInfoHob.SysData.SysSioExist = (UINT8)IsSioExist();
|
|
GetCpuInfo (&CpuType, &CpuStepping);
|
PlatformInfoHob.CpuType = CpuType;
|
PlatformInfoHob.CpuStepping = CpuStepping;
|
|
//
|
// Set default memory topology to DaisyChainTopology. This should be modified in UBA board
|
// specific file.
|
//
|
(*PeiServices)->SetMem (&PlatformInfoHob.MemoryTopology, sizeof (PlatformInfoHob.MemoryTopology), DaisyChainTopology);
|
|
//
|
// Set default memory type connector to DimmConnectorPth. This should be modified in UBA board
|
// specific file.
|
//
|
(*PeiServices)->SetMem (&PlatformInfoHob.MemoryConnectorType, sizeof (PlatformInfoHob.MemoryConnectorType), DimmConnectorPth);
|
|
//
|
// Build HOB for setup memory information
|
//
|
BuildGuidDataHob (
|
&gEfiPlatformInfoGuid,
|
&(PlatformInfoHob),
|
sizeof (EFI_PLATFORM_INFO)
|
);
|
|
Status = (**PeiServices).InstallPpi (PeiServices, &mPlatformInfoPpi);
|
ASSERT_EFI_ERROR (Status);
|
|
//
|
// Save PlatformInfoHob.BoardId in CMOS
|
//
|
IoWrite8 (R_IOPORT_CMOS_UPPER_INDEX, CMOS_PLATFORM_ID_LO);
|
IoWrite8 (R_IOPORT_CMOS_UPPER_DATA, (UINT8)PlatformInfoHob.BoardId);
|
|
IoWrite8 (R_IOPORT_CMOS_UPPER_INDEX, CMOS_PLATFORM_ID_HI);
|
IoWrite8 (R_IOPORT_CMOS_UPPER_DATA, (UINT8)((PlatformInfoHob.PcieRiser2Type << 4) + (PlatformInfoHob.PcieRiser1Type)));
|
|
return EFI_SUCCESS;
|
}
|
