xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Intel/AlderLake/AlderLakePlatSamplePkg/Library/PeiPolicyUpdateLib/PeiSiPolicyUpdate.c

715 lines
27 KiB
C
Raw Blame History

/** @file
;******************************************************************************
;* Copyright (c) 2020, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
/** @file
This file is SampleCode of the library for Intel Silicon PEI
Platform Policy initialization.
@copyright
INTEL CONFIDENTIAL
Copyright 2014 - 2021 Intel Corporation.
The source code contained or described herein and all documents related to the
source code ("Material") are owned by Intel Corporation or its suppliers or
licensors. Title to the Material remains with Intel Corporation or its suppliers
and licensors. The Material may contain trade secrets and proprietary and
confidential information of Intel Corporation and its suppliers and licensors,
and is protected by worldwide copyright and trade secret laws and treaty
provisions. No part of the Material may be used, copied, reproduced, modified,
published, uploaded, posted, transmitted, distributed, or disclosed in any way
without Intel's prior express written permission.
No license under any patent, copyright, trade secret or other intellectual
property right is granted to or conferred upon you by disclosure or delivery
of the Materials, either expressly, by implication, inducement, estoppel or
otherwise. Any license under such intellectual property rights must be
express and approved by Intel in writing.
Unless otherwise agreed by Intel in writing, you may not remove or alter
this notice or any other notice embedded in Materials by Intel or
Intel's suppliers or licensors in any way.
This file contains a 'Sample Driver' and is licensed as such under the terms
of your license agreement with Intel or your vendor. This file may be modified
by the user, subject to the additional terms of the license agreement.
@par Specification Reference:
**/
#include "PeiSiPolicyUpdate.h"
#include <Library/DebugLib.h>
#include <Library/HobLib.h>
//[-start-210218-IB16740133-add]// for build error, it is used in Insyde solution (IB14630306).
#include <Library/MemoryAllocationLib.h>
//[-end-210218-IB16740133-add]//
#include <Library/PcdLib.h>
#include <Library/PeiServicesLib.h>
#include <Library/PeiSiPolicyUpdateLib.h>
#include <Library/SerialIoUartDebugPropertyPcdLib.h>
//[-start-200210-IB14630306-add]//
#include <Library/PeiOemSvcChipsetLib.h>
//[-end-200210-IB14630306-add]//
#include <Library/SerialPortParameterLib.h>
#include <Library/SiPolicyLib.h>
#include <Ppi/ReadOnlyVariable2.h>
#include <BootStateLib.h>
#include <PciePreMemConfig.h>
#include <PolicyUpdateMacro.h>
#include <Setup.h>
#include <SetupVariable.h>
#if FixedPcdGet8(PcdFspModeSelection) == 1
#include <FspmUpd.h>
#include <FspsUpd.h>
#include <Ppi/DebugEventHandler.h>
#endif
//[-start-210723-QINGLIN0001-add]//
#ifdef LCFC_SUPPORT
#include <Library/PciSegmentLib.h>
#endif
//[-end-210723-QINGLIN0001-add]//
//[-start-210723-QINGLIN0001-add]//
#ifdef S570_SUPPORT
SSID_SVID_PEI_CONFIG S570QXZSHostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x380717AA
};
SSID_SVID_PEI_CONFIG S570QXZTHostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x380417AA
};
SSID_SVID_PEI_CONFIG S570QY4THostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x380217AA
};
SSID_SVID_PEI_CONFIG S570QY4YHostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x380117AA
};
#endif
//[start-210819-STORM1106-modify]
#if defined(C770_SUPPORT)
SSID_SVID_PEI_CONFIG C7704621HostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x381C17AA
};
SSID_SVID_PEI_CONFIG C7704641HostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x381617AA
};
SSID_SVID_PEI_CONFIG C7704601HostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x382817AA
};
// temporary , will remove below SSID porting after FVT phase which for ES2 CPU
SSID_SVID_PEI_CONFIG C770eSPIControllerESSsidTablePtr = {
0x00, 0x1F, 0x00, 0x382417AA
};
#endif
//[end-210819-STORM1106-modify]
//[-end-210723-QINGLIN0001-add]//
//[-start-210804-QINGLIN0008-add]//
//[-start-211206-QINGLIN0126-modify]//
#ifdef S370_SUPPORT
SSID_SVID_PEI_CONFIG S370_4601_HostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x380517AA
};
SSID_SVID_PEI_CONFIG S370_4609_HostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x380317AA
};
SSID_SVID_PEI_CONFIG S370_4619_HostBridgeSsidTablePtr = {
0x00, 0x00, 0x00, 0x380217AA
};
#endif
//[-end-211206-QINGLIN0126-modify]//
//[-end-210804-QINGLIN0008-add]//
//[-start-210909-TAMT000007-add]//
#ifdef S77014_SUPPORT
SSID_SVID_PEI_CONFIG S770_14_4621_HostBridgeSsidTablePtr = { //QXZT ES2 J-0
0x00, 0x00, 0x00, 0x380717AA
};
SSID_SVID_PEI_CONFIG S770_14_4641_HostBridgeSsidTablePtr = { //QXZS ES2 J-0
0x00, 0x00, 0x00, 0x380A17AA
};
#endif
//[-end-210909-TAMT000007-add]//
//[-start-220318-Ching000036-add]//
#ifdef S77014IAH_SUPPORT
SSID_SVID_PEI_CONFIG S770_14IAH_4621_HostBridgeSsidTablePtr = { //Q07D SQS
0x00, 0x00, 0x00, 0x380917AA
};
SSID_SVID_PEI_CONFIG S770_14IAH_4641_HostBridgeSsidTablePtr = { //Q07G SQS
0x00, 0x00, 0x00, 0x381017AA
};
SSID_SVID_PEI_CONFIG S770_14IAH_4649_HostBridgeSsidTablePtr = { //Q07F SQS
0x00, 0x00, 0x00, 0x380217AA
};
#endif
//[-end-220318-Ching000036-add]//
//[-start-210925-TAMT000014-add]//
#ifdef S77013_SUPPORT
SSID_SVID_PEI_CONFIG S770_13_4621_HostBridgeSsidTablePtr = { //QXZT ES2 J-0
0x00, 0x00, 0x00, 0x380D17AA
};
SSID_SVID_PEI_CONFIG S770_13_4641_HostBridgeSsidTablePtr = { //QXZS ES2 J-0
0x00, 0x00, 0x00, 0x380B17AA
};
#endif
//[-end-210925-TAMT000014-add]//
/**
This function performs Initinalize global variable for PolicyDefaultCheck using
@retval EFI_SUCCESS The function completed successfully
**/
EFI_STATUS
EFIAPI
PolicyDefaultCheckInit (
)
{
DEBUG ((DEBUG_INFO, "PolicyDefaultCheckInit Entry\n"));
//
// Check FirstBoot and RvpSupport for IsPolicyDefaultCheckRequired using
//
if (IsBootStatePresent()) {
PcdSetBoolS (PcdPolicyCheckIsFirstBoot, 0);
} else {
PcdSetBoolS (PcdPolicyCheckIsFirstBoot, 1);
}
if ((PcdGet16 (PcdBoardId)) == (PcdGet16 (PcdDefaultBoardId))) {
PcdSetBoolS (PcdPolicyCheckIsRvpSupport, 1);
} else {
PcdSetBoolS (PcdPolicyCheckIsRvpSupport, 0);
}
PcdSetBoolS (PcdPolicyCheckPcdInitDone, 1);
DEBUG ((DEBUG_INFO, "IsFirstBoot %x\n", PcdGetBool (PcdPolicyCheckIsFirstBoot)));
DEBUG ((DEBUG_INFO, "IsRvpSupport %x\n", PcdGetBool (PcdPolicyCheckIsRvpSupport)));
DEBUG ((DEBUG_INFO, "PolicyDefaultCheckInitDone %x\n", PcdGetBool (PcdPolicyCheckPcdInitDone)));
DEBUG ((DEBUG_INFO, "PolicyDefaultCheckInit Exist\n"));
return EFI_SUCCESS;
}
/**
This function performs Check First Boot and Rvp Support to see if Policy Default Check Required
@retval BOOLEAN Required TURE or FALSE
**/
BOOLEAN
EFIAPI
IsPolicyDefaultCheckRequired (
)
{
//
// Check PolicyDefaultCheckInit already been done
//
if (!PcdGetBool (PcdPolicyCheckPcdInitDone)) {
PolicyDefaultCheckInit();
}
//
// Policy Default Check only for First Boot and Rvp Support
//
if ((PcdGetBool (PcdPolicyCheckIsFirstBoot)) && (PcdGetBool (PcdPolicyCheckIsRvpSupport))) {
return TRUE;
} else {
return FALSE;
}
}
/**
This function performs Silicon PEI Policy initialization.
@retval EFI_SUCCESS The PPI is installed and initialized.
@retval EFI_NOT_FOUND The FspmUpd is not found.
@retval EFI_OUT_OF_RESOURCES Do not have enough resources to initialize the driver
**/
EFI_STATUS
EFIAPI
UpdatePeiSiPolicyPreMem (
VOID
)
{
EFI_STATUS Status;
EFI_PEI_READ_ONLY_VARIABLE2_PPI *VariableServices;
UINTN VariableSize;
SI_SETUP SiSetup;
#if FixedPcdGet8(PcdFspModeSelection) == 1
VOID *FspmUpd;
EFI_PEI_HOB_POINTERS Hob;
DEBUG_CONFIG_DATA_HOB *DebugConfigData;
UINT8 DebugInterfaces;
DEBUG_EVENT_HABDLER_PPI *DebugEventHandlerPpi;
#else
SI_PREMEM_POLICY_PPI *SiPreMemPolicy;
SI_PREMEM_CONFIG *SiPreMemConfig;
PCIE_PREMEM_CONFIG *PciePreMemConfig;
SiPreMemPolicy = NULL;
SiPreMemConfig = NULL;
PciePreMemConfig = NULL;
#endif
DEBUG ((DEBUG_INFO, "Update PeiSiPolicyUpdate Pre-Mem Start\n"));
#if FixedPcdGet8(PcdFspModeSelection) == 1
FspmUpd = NULL;
FspmUpd = (FSPM_UPD *) PcdGet32 (PcdFspmUpdDataAddress);
ASSERT (FspmUpd != NULL);
if (FspmUpd == NULL) {
return EFI_NOT_FOUND;
}
((FSPM_UPD *)FspmUpd)->FspmArchUpd.StackBase = (VOID *) (UINTN) (PcdGet32 (PcdTemporaryRamBase) + PcdGet32 (PcdTemporaryRamSize) - (PcdGet32 (PcdFspTemporaryRamSize) + PcdGet32 (PcdFspReservedBufferSize)));
((FSPM_UPD *)FspmUpd)->FspmArchUpd.StackSize = PcdGet32 (PcdFspTemporaryRamSize);
Status = PeiServicesGetBootMode (&(((FSPM_UPD *)FspmUpd)->FspmArchUpd.BootMode));
if (EFI_ERROR (Status)) {
((FSPM_UPD *)FspmUpd)->FspmArchUpd.BootMode = BOOT_WITH_FULL_CONFIGURATION;
}
((FSPM_UPD *)FspmUpd)->FspmArchUpd.BootLoaderTolumSize = 0x0;
Status = PeiServicesLocatePpi (
&gDebugEventHandlerPpiGuid, // GUID
0, // INSTANCE
NULL, // EFI_PEI_PPI_DESCRIPTOR
(VOID **) &DebugEventHandlerPpi // PPI
);
if (!EFI_ERROR(Status)) {
((FSPM_UPD *)FspmUpd)->FspmArchUpd.FspEventHandler = (FSP_EVENT_HANDLER *)(UINT32) DebugEventHandlerPpi->DebugEventHandler;
}
//
// Initialize DebugConfigData
//
DebugInterfaces = 0;
Hob.Guid = GetFirstGuidHob (&gDebugConfigHobGuid);
if (Hob.Guid != NULL) {
DebugConfigData = (DEBUG_CONFIG_DATA_HOB *) GET_GUID_HOB_DATA (Hob.Guid);
if (DebugConfigData != NULL) {
// Debug Interfaces
if (DebugConfigData->RamDebugInterface) { DebugInterfaces |= STATUS_CODE_USE_RAM; }
if (DebugConfigData->UartDebugInterface) { DebugInterfaces |= STATUS_CODE_USE_ISA_SERIAL; }
if (DebugConfigData->Usb3DebugInterface) { DebugInterfaces |= STATUS_CODE_USE_USB3; }
if (DebugConfigData->TraceHubDebugInterface) { DebugInterfaces |= STATUS_CODE_USE_TRACEHUB; }
((FSPM_UPD *)FspmUpd)->FspmConfig.PcdDebugInterfaceFlags = DebugInterfaces;
// Serial debug message baud rate
((FSPM_UPD *)FspmUpd)->FspmConfig.PcdSerialDebugBaudRate = DebugConfigData->SerialDebugBaudRate;
// Serial debug message level
((FSPM_UPD *)FspmUpd)->FspmConfig.PcdSerialDebugLevel = DebugConfigData->SerialDebug;
// MRC Serial debug message level
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialDebugMrcLevel = DebugConfigData->SerialDebugMrcLevel;
if (DebugConfigData->SerialIoDebugInterface) {
((FSPM_UPD *)FspmUpd)->FspmConfig.PcdDebugInterfaceFlags |= STATUS_CODE_USE_SERIALIO;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugControllerNumber = DebugConfigData->SerialIoUartDebugControllerNumber;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugBaudRate = DebugConfigData->SerialIoUartDebugBaudRate;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugStopBits = DebugConfigData->SerialIoUartDebugStopBits;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugParity = DebugConfigData->SerialIoUartDebugParity;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugAutoFlow = DebugConfigData->SerialIoUartDebugFlowControl;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugDataBits = DebugConfigData->SerialIoUartDebugDataBits;
// @todo - consider adding GPIO muxes to Setup option
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugRxPinMux = 0x0;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugTxPinMux = 0x0;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugRtsPinMux = 0x0;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugCtsPinMux = 0x0;
((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugMode = 0x2; //SerialIoUartHidden
}
}
}
DEBUG ((DEBUG_INFO, "FspmUpd->FspmConfig.PcdDebugInterfaceFlags is 0x%X\n", ((FSPM_UPD *)FspmUpd)->FspmConfig.PcdDebugInterfaceFlags));
DEBUG ((DEBUG_INFO, "FspmUpd->FspmConfig.PcdSerialDebugBaudRate is 0x%X\n", ((FSPM_UPD *)FspmUpd)->FspmConfig.PcdSerialDebugBaudRate));
DEBUG ((DEBUG_INFO, "FspmUpd->FspmConfig.PcdSerialDebugLevel is 0x%X\n", ((FSPM_UPD *)FspmUpd)->FspmConfig.PcdSerialDebugLevel));
DEBUG ((DEBUG_INFO, "FspmUpd->FspmConfig.SerialDebugMrcLevel is 0x%X\n", ((FSPM_UPD *)FspmUpd)->FspmConfig.SerialDebugMrcLevel));
DEBUG ((DEBUG_INFO, "FspmUpd->FspmConfig.SerialIoUartDebugControllerNumber is 0x%X\n", ((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugControllerNumber));
DEBUG ((DEBUG_INFO, "FspmUpd->FspmConfig.SerialIoUartDebugBaudRate is %d\n", ((FSPM_UPD *)FspmUpd)->FspmConfig.SerialIoUartDebugBaudRate));
#else
Status = PeiServicesLocatePpi (&gSiPreMemPolicyPpiGuid, 0, NULL, (VOID **) &SiPreMemPolicy);
ASSERT_EFI_ERROR (Status);
Status = GetConfigBlock ((VOID *) SiPreMemPolicy, &gSiPreMemConfigGuid, (VOID *) &SiPreMemConfig);
ASSERT_EFI_ERROR (Status);
Status = GetConfigBlock((VOID *)SiPreMemPolicy, &gPciePreMemConfigGuid, (VOID *)&PciePreMemConfig);
ASSERT_EFI_ERROR(Status);
#endif
//
// Retrieve Setup variable
//
Status = PeiServicesLocatePpi (
&gEfiPeiReadOnlyVariable2PpiGuid, // GUID
0, // INSTANCE
NULL, // EFI_PEI_PPI_DESCRIPTOR
(VOID **) &VariableServices // PPI
);
ASSERT_EFI_ERROR (Status);
VariableSize = sizeof (SI_SETUP);
Status = VariableServices->GetVariable (
VariableServices,
L"SiSetup",
&gSiSetupVariableGuid,
NULL,
&VariableSize,
&SiSetup
);
ASSERT_EFI_ERROR (Status);
if (Status == EFI_SUCCESS) {
COMPARE_AND_UPDATE_POLICY (((FSPM_UPD *) FspmUpd)->FspmConfig.PlatformDebugConsent, SiPreMemConfig->PlatformDebugConsent, SiSetup.PlatformDebugConsent, NullIndex);
COMPARE_AND_UPDATE_POLICY (((FSPM_UPD *) FspmUpd)->FspmConfig.PcieImrEnabled, PciePreMemConfig->PcieImr.ImrEnabled, SiSetup.PcieImrEnable, NullIndex);
if (SiSetup.PcieImrEnable) {
COMPARE_AND_UPDATE_POLICY (((FSPM_UPD *) FspmUpd)->FspmConfig.PcieImrRpLocation, PciePreMemConfig->PcieImr.ImrRpLocation, SiSetup.PcieImrRpLocation, NullIndex);
COMPARE_AND_UPDATE_POLICY (((FSPM_UPD *) FspmUpd)->FspmConfig.PcieImrRpSelection, PciePreMemConfig->PcieImr.ImrRpSelection, SiSetup.PcieImrRpSelection, NullIndex);
COMPARE_AND_UPDATE_POLICY (((FSPM_UPD *) FspmUpd)->FspmConfig.PcieImrSize, PciePreMemConfig->PcieImr.ImrSize, SiSetup.PcieImrSize, NullIndex);
}
}
//
// Policy to prevent MRC modify the boot mode while in flash update
//
UPDATE_POLICY (((FSPM_UPD *) FspmUpd)->FspmConfig.SiSkipOverrideBootModeWhenFwUpdate, SiPreMemConfig->SkipOverrideBootModeWhenFwUpdate, (UINT8) FALSE);
return EFI_SUCCESS;
}
/*
STATIC SVID_SID_INIT_ENTRY mSsidTablePtr[SI_MAX_DEVICE_COUNT] = {0};
*/
/**
This provide sample code to update SSID table policy.
@param[in] FspsUpd/SiConfig FSPSUPD structure or SICONFIG policy
**/
STATIC
VOID
UpdateSsidPolicy (
#if FixedPcdGet8(PcdFspModeSelection) == 1
FSPS_UPD *FspsUpd
#else
SI_CONFIG *SiConfig
#endif
)
{
/*
Below provides the sample code to update SSID table.
This is valid when SkipSsidProgramming is FALSE;
It doesn't need to contain entries for all Intel internal devices.
It can only contains the SVID_SID_INIT_ENTRY entries for those Dev# Func# which needs
to be override.
In the enties, only Dev, Function, SubSystemVendorId, and SubSystemId are required.
E.g. Platform only needs to override BDF 0:31:5 to AAAA:BBBB and BDF 0:31:3 to CCCC:DDDD,
it can be done in platform like this:
*/
/*
UINT32 EntryCount;
UPDATE_POLICY (((FSPS_UPD *) FspsUpd)->FspsConfig.SiSkipSsidProgramming, *(UINT32 *)SiConfig->SkipSsidProgramming, FALSE);
UPDATE_POLICY (((FSPS_UPD *) FspsUpd)->FspsConfig.SiCustomizedSvid, *(UINT32 *)SiConfig->CustomizedSvid, 0x1234);
UPDATE_POLICY (((FSPS_UPD *) FspsUpd)->FspsConfig.SiCustomizedSsid, *(UINT32 *)SiConfig->CustomizedSsid, 0x5678);
EntryCount = 0;
mSsidTablePtr[EntryCount].Address.Bits.Device = SpiDeviceNumber ();
mSsidTablePtr[EntryCount].Address.Bits.Function = SpiFunctionNumber ();
mSsidTablePtr[EntryCount].SvidSidValue.SubSystemVendorId = 0xAAAA;
mSsidTablePtr[EntryCount].SvidSidValue.SubSystemId = 0xBBBB;
EntryCount ++;
mSsidTablePtr[EntryCount].Address.Bits.Device = HdaDevNumber ();
mSsidTablePtr[EntryCount].Address.Bits.Function = HdaFuncNumber ();
mSsidTablePtr[EntryCount].SvidSidValue.SubSystemVendorId = 0xCCCC;
mSsidTablePtr[EntryCount].SvidSidValue.SubSystemId = 0xDDDD;
EntryCount ++;
ASSERT (EntryCount < SI_MAX_DEVICE_COUNT);
UPDATE_POLICY (((FSPS_UPD *) FspsUpd)->FspsConfig.SiSsidTablePtr, *(UINT32 *)SiConfig->SsidTablePtr, (UINTN) mSsidTablePtr);
UPDATE_POLICY (((FSPS_UPD *) FspsUpd)->FspsConfig.SiNumberOfSsidTableEntry, SiConfig->NumberOfSsidTableEntry, (UINT16) EntryCount);
*/
//[-start-200210-IB14630306-add]//
UINT32 DefaultSsidSvid;
SSID_SVID_PEI_CONFIG *CustomizedSsidSvidTable;
UINTN CustomizedSsidSvidTableCount;
SVID_SID_INIT_ENTRY *SsidTablePtr;
UINT16 Index;
UPDATE_POLICY (((FSPS_UPD *)FspsUpd)->FspsConfig.SiSkipSsidProgramming, SiConfig->SkipSsidProgramming, FALSE);
DefaultSsidSvid = PcdGet32 (PcdDefaultSsidSvid);
UPDATE_POLICY (((FSPS_UPD *)FspsUpd)->FspsConfig.SiCustomizedSvid, SiConfig->CustomizedSvid, (UINT16)(DefaultSsidSvid & 0xFFFF));
UPDATE_POLICY (((FSPS_UPD *)FspsUpd)->FspsConfig.SiCustomizedSsid, SiConfig->CustomizedSsid, (UINT16)((DefaultSsidSvid >> 16) & 0xFFFF));
CustomizedSsidSvidTable = (SSID_SVID_PEI_CONFIG *)PcdGetPtr (PcdDefaultSsidSvidPeiTable);
CustomizedSsidSvidTableCount = PcdGetSize (PcdDefaultSsidSvidPeiTable) / sizeof (SSID_SVID_PEI_CONFIG);
//[-start-210723-QINGLIN0001-modify]//
//[-start-211015-QINGLIN0100-modify]//
#if defined(S570_SUPPORT)
{
UINT16 DeviceId;
BOOLEAN IsFound = FALSE;
DeviceId = PciSegmentRead16 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 0, 0, 0x02));
if (DeviceId == 0x4641) { //ES2:QXZS QS:QYY8
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S570QXZSHostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (DeviceId == 0x4621) { //ES2:QXZT QS:QYY9 QYYD
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S570QXZTHostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (DeviceId == 0x4601) { //QY4T QY4U
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S570QY4THostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (DeviceId == 0x4609) { //QY4Y
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S570QY4YHostBridgeSsidTablePtr;
IsFound = TRUE;
}
if (IsFound == TRUE) {
CustomizedSsidSvidTableCount += 1;
}
}
#endif
//[-end-211015-QINGLIN0100-modify]//
//[-end-210723-QINGLIN0001-modify]//
//[-start-210804-QINGLIN0008-add]//
//[-start-211206-QINGLIN0126-modify]//
#if defined(S370_SUPPORT)
{
UINT16 DeviceId;
BOOLEAN IsFound = FALSE;
DeviceId = PciSegmentRead16 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 0, 0, 0x02));
if (DeviceId == 0x4601) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S370_4601_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (DeviceId == 0x4609) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S370_4609_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (DeviceId == 0x4619) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S370_4619_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
if (IsFound == TRUE) {
CustomizedSsidSvidTableCount += 1;
}
}
#endif
//[-end-211206-QINGLIN0126-modify]//
//[start-210819-STORM1106-modify]
#if defined(C770_SUPPORT)
{
UINT32 VendorDeviceId;
BOOLEAN IsFound = FALSE;
VendorDeviceId = PciSegmentRead32 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 0, 0, 0x00));
if (0x46218086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = C7704621HostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (0x46418086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = C7704641HostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (0x46018086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = C7704601HostBridgeSsidTablePtr;
IsFound = TRUE;
}
if (IsFound == TRUE) {
CustomizedSsidSvidTableCount += 1;
}
IsFound = FALSE;
// eSPI controller
VendorDeviceId = PciSegmentRead32 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 0x1F, 0, 0x00));
if (0x51818086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = C770eSPIControllerESSsidTablePtr;
IsFound = TRUE;
}
if (IsFound == TRUE) {
CustomizedSsidSvidTableCount += 1;
}
}
#endif
//[end-210819-STORM1106-modify]
//[-end-210804-QINGLIN0008-add]//
//[-start-210909-TAMT000007-add]//
#ifdef S77014_SUPPORT
{
UINT32 VendorDeviceId;
BOOLEAN IsFound = FALSE;
VendorDeviceId = PciSegmentRead32 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 0, 0, 0x00));
if (0x46218086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S770_14_4621_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (0x46418086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S770_14_4641_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
if (IsFound == TRUE) {
CustomizedSsidSvidTableCount += 1;
}
}
#endif
//[-end-210909-TAMT000007-add]//
//[-start-220318-Ching000036-add]//
#ifdef S77014IAH_SUPPORT
{
UINT32 VendorDeviceId;
BOOLEAN IsFound = FALSE;
VendorDeviceId = PciSegmentRead32 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 0, 0, 0x00));
if (0x46218086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S770_14IAH_4621_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (0x46418086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S770_14IAH_4641_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (0x46498086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S770_14IAH_4649_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
if (IsFound == TRUE) {
CustomizedSsidSvidTableCount += 1;
}
}
#endif
//[-end-220318-Ching000036-add]//
//[-start-210925-TAMT000014-add]//
#ifdef S77013_SUPPORT
{
UINT32 VendorDeviceId;
BOOLEAN IsFound = FALSE;
VendorDeviceId = PciSegmentRead32 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 0, 0, 0x00));
if (0x46218086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S770_13_4621_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
else if (0x46418086 == VendorDeviceId) {
*(CustomizedSsidSvidTable + CustomizedSsidSvidTableCount) = S770_13_4641_HostBridgeSsidTablePtr;
IsFound = TRUE;
}
if (IsFound == TRUE) {
CustomizedSsidSvidTableCount += 1;
}
}
#endif
//[-end-210925-TAMT000014-add]//
SsidTablePtr = AllocateZeroPool (CustomizedSsidSvidTableCount * sizeof (SVID_SID_INIT_ENTRY));
for (Index = 0; Index < CustomizedSsidSvidTableCount; Index++) {
SsidTablePtr[Index].Address.Bits.Bus = CustomizedSsidSvidTable[Index].Bus;
SsidTablePtr[Index].Address.Bits.Device = CustomizedSsidSvidTable[Index].Device;
SsidTablePtr[Index].Address.Bits.Function = CustomizedSsidSvidTable[Index].Function;
SsidTablePtr[Index].SvidSidValue.SubSystemVendorId = (UINT16)(CustomizedSsidSvidTable[Index].SsidSvid & 0xFFFF);
SsidTablePtr[Index].SvidSidValue.SubSystemId = (UINT16)((CustomizedSsidSvidTable[Index].SsidSvid >> 16) & 0xFFFF);
}
//[-start-200226-IB14630337-modify]//
#if FixedPcdGet8(PcdFspModeSelection) == 1
UPDATE_POLICY (((FSPS_UPD *)FspsUpd)->FspsConfig.SiSsidTablePtr, *(UINT32 *)SiConfig->SsidTablePtr, (UINTN)SsidTablePtr);
#else
UPDATE_POLICY (((FSPS_UPD *)FspsUpd)->FspsConfig.SiSsidTablePtr, SiConfig->SsidTablePtr, (UINT32 *)SsidTablePtr);
#endif
//[-end-200226-IB14630337-modify]//
UPDATE_POLICY (((FSPS_UPD *)FspsUpd)->FspsConfig.SiNumberOfSsidTableEntry, SiConfig->NumberOfSsidTableEntry, (UINT16)CustomizedSsidSvidTableCount);
//[-end-200210-IB14630306-add]//
}
/**
This function performs Silicon PEI Policy initialization.
@retval EFI_SUCCESS The function completed successfully
**/
EFI_STATUS
EFIAPI
UpdatePeiSiPolicy (
VOID
)
{
EFI_STATUS Status;
#if FixedPcdGet8(PcdFspModeSelection) == 1
VOID *FspsUpd;
DEBUG_EVENT_HABDLER_PPI *DebugEventHandlerPpi;
#else
SI_POLICY_PPI *SiPolicyPpi;
SI_CONFIG *SiConfig;
#endif
DEBUG ((DEBUG_INFO, "Update PeiSiPolicyUpdate Pos-Mem Start\n"));
Status = EFI_SUCCESS;
#if FixedPcdGet8(PcdFspModeSelection) == 1
FspsUpd = NULL;
#else
SiPolicyPpi = NULL;
SiConfig = NULL;
#endif
#if FixedPcdGet8(PcdFspModeSelection) == 1
FspsUpd = (FSPS_UPD *) PcdGet32 (PcdFspsUpdDataAddress);
ASSERT (FspsUpd != NULL);
#else
Status = PeiServicesLocatePpi (&gSiPolicyPpiGuid, 0, NULL, (VOID **) &SiPolicyPpi);
ASSERT_EFI_ERROR (Status);
Status = GetConfigBlock ((VOID *) SiPolicyPpi, &gSiConfigGuid, (VOID *) &SiConfig);
ASSERT_EFI_ERROR (Status);
#endif
UpdateSsidPolicy (
#if FixedPcdGet8(PcdFspModeSelection) == 1
FspsUpd
#else
SiConfig
#endif
);
#if FixedPcdGet8(PcdFspModeSelection) == 1
Status = PeiServicesLocatePpi (
&gDebugEventHandlerPpiGuid, // GUID
0, // INSTANCE
NULL, // EFI_PEI_PPI_DESCRIPTOR
(VOID **) &DebugEventHandlerPpi // PPI
);
if (!EFI_ERROR(Status)) {
((FSPS_UPD *) FspsUpd)->FspsConfig.FspEventHandler = (UINT32) DebugEventHandlerPpi->DebugEventHandler;
}
#endif
#if FixedPcdGet8(PcdEmbeddedEnable) == 0x1
UPDATE_POLICY (((FSPS_UPD *) FspsUpd)->FspsConfig.SiSkipBiosDoneWhenFwUpdate, SiConfig->SkipBiosDoneWhenFwUpdate, (UINT8) FALSE);
#endif
return EFI_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink