tyler.durden/audk
1
0
Fork 0
mirror of https://github.com/acidanthera/audk.git synced 2025-07-26 23:24:03 +02:00
Code Issues Packages Projects Releases Wiki Activity

UefiCpuPkg/RegisterCpuFeaturesLib: avoid use dynamic PCD.

Browse Source 
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=1972

Function in this library may be used by APs. Assert will be trig if AP
uses dynamic pcd.
This patch enhance the current code, remove the unnecessary usage of
dynamic PCD. This change try to avoid report this issue again later.

Cc: Ray Ni <ray.ni@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Cc: Chandana Kumar <chandana.c.kumar@intel.com>
Cc: Star Zeng <star.zeng@intel.com>
Signed-off-by: Eric Dong <eric.dong@intel.com>
Reviewed-by: Ray Ni <ray.ni@intel.com>
Reviewed-by: Star Zeng <star.zeng@intel.com>
This commit is contained in:
Dong, Eric 2019-07-15 15:00:56 +08:00 committed by Eric Dong
parent bbd357ae57
commit 3dafa03822
3 changed files with 79 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
UefiCpuPkg/Library/RegisterCpuFeaturesLib/CpuFeaturesInitialize.c
View File

@ -15,20 +15,16 @@ CHAR16 *mRegisterTypeStr[] = {L"MSR", L"CR", L"MMIO", L"CACHE", L"SEMAP", L"INVA
Worker function to save PcdCpuFeaturesCapability. Worker function to save PcdCpuFeaturesCapability.
@param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer @param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer
@param[in] FeatureMaskSize CPU feature bits mask buffer size. @param[in] BitMaskSize CPU feature bits mask buffer size.
**/ **/
VOID VOID
SetCapabilityPcd ( SetCapabilityPcd (
IN UINT8 *SupportedFeatureMask, IN UINT8 *SupportedFeatureMask,
IN UINT32 FeatureMaskSize IN UINTN BitMaskSize
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
UINTN BitMaskSize;
BitMaskSize = PcdGetSize (PcdCpuFeaturesCapability);
ASSERT (FeatureMaskSize == BitMaskSize);
Status = PcdSetPtrS (PcdCpuFeaturesCapability, &BitMaskSize, SupportedFeatureMask); Status = PcdSetPtrS (PcdCpuFeaturesCapability, &BitMaskSize, SupportedFeatureMask);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
@ -38,16 +34,16 @@ SetCapabilityPcd (
Worker function to save PcdCpuFeaturesSetting. Worker function to save PcdCpuFeaturesSetting.
@param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer @param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer
@param[in] BitMaskSize CPU feature bits mask buffer size.
**/ **/
VOID VOID
SetSettingPcd ( SetSettingPcd (
IN UINT8 *SupportedFeatureMask IN UINT8 *SupportedFeatureMask,
IN UINTN BitMaskSize
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
UINTN BitMaskSize;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting);
Status = PcdSetPtrS (PcdCpuFeaturesSetting, &BitMaskSize, SupportedFeatureMask); Status = PcdSetPtrS (PcdCpuFeaturesSetting, &BitMaskSize, SupportedFeatureMask);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
} }
@ -272,19 +268,20 @@ SupportedMaskOr (
@param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer @param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer
@param[in] AndFeatureBitMask The feature bit mask to do AND operation @param[in] AndFeatureBitMask The feature bit mask to do AND operation
@param[in] BitMaskSize CPU feature bits mask buffer size.
**/ **/
VOID VOID
SupportedMaskAnd ( SupportedMaskAnd (
IN UINT8 *SupportedFeatureMask, IN UINT8 *SupportedFeatureMask,
IN CONST UINT8 *AndFeatureBitMask IN CONST UINT8 *AndFeatureBitMask,
IN UINT32 BitMaskSize
) )
{ {
UINTN Index; UINTN Index;
UINTN BitMaskSize;
UINT8 *Data1; UINT8 *Data1;
CONST UINT8 *Data2; CONST UINT8 *Data2;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting);
Data1 = SupportedFeatureMask; Data1 = SupportedFeatureMask;
Data2 = AndFeatureBitMask; Data2 = AndFeatureBitMask;
for (Index = 0; Index < BitMaskSize; Index++) { for (Index = 0; Index < BitMaskSize; Index++) {
@ -297,19 +294,19 @@ SupportedMaskAnd (
@param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer @param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer
@param[in] AndFeatureBitMask The feature bit mask to do XOR operation @param[in] AndFeatureBitMask The feature bit mask to do XOR operation
@param[in] BitMaskSize CPU feature bits mask buffer size.
**/ **/
VOID VOID
SupportedMaskCleanBit ( SupportedMaskCleanBit (
IN UINT8 *SupportedFeatureMask, IN UINT8 *SupportedFeatureMask,
IN UINT8 *AndFeatureBitMask IN UINT8 *AndFeatureBitMask,
IN UINT32 BitMaskSize
) )
{ {
UINTN Index; UINTN Index;
UINTN BitMaskSize;
UINT8 *Data1; UINT8 *Data1;
UINT8 *Data2; UINT8 *Data2;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting);
Data1 = SupportedFeatureMask; Data1 = SupportedFeatureMask;
Data2 = AndFeatureBitMask; Data2 = AndFeatureBitMask;
for (Index = 0; Index < BitMaskSize; Index++) { for (Index = 0; Index < BitMaskSize; Index++) {
@ -323,6 +320,7 @@ SupportedMaskCleanBit (
@param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer @param[in] SupportedFeatureMask The pointer to CPU feature bits mask buffer
@param[in] ComparedFeatureBitMask The feature bit mask to be compared @param[in] ComparedFeatureBitMask The feature bit mask to be compared
@param[in] BitMaskSize CPU feature bits mask buffer size.
@retval TRUE The ComparedFeatureBitMask is set in CPU feature supported bits @retval TRUE The ComparedFeatureBitMask is set in CPU feature supported bits
mask buffer. mask buffer.
@ -332,16 +330,14 @@ SupportedMaskCleanBit (
BOOLEAN BOOLEAN
IsBitMaskMatch ( IsBitMaskMatch (
IN UINT8 *SupportedFeatureMask, IN UINT8 *SupportedFeatureMask,
IN UINT8 *ComparedFeatureBitMask IN UINT8 *ComparedFeatureBitMask,
IN UINT32 BitMaskSize
) )
{ {
UINTN Index; UINTN Index;
UINTN BitMaskSize;
UINT8 *Data1; UINT8 *Data1;
UINT8 *Data2; UINT8 *Data2;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting);
Data1 = SupportedFeatureMask; Data1 = SupportedFeatureMask;
Data2 = ComparedFeatureBitMask; Data2 = ComparedFeatureBitMask;
for (Index = 0; Index < BitMaskSize; Index++) { for (Index = 0; Index < BitMaskSize; Index++) {
@ -557,14 +553,14 @@ AnalysisProcessorFeatures (
// //
// Calculate the last capability on all processors // Calculate the last capability on all processors
// //
SupportedMaskAnd (CpuFeaturesData->CapabilityPcd, CpuInitOrder->FeaturesSupportedMask); SupportedMaskAnd (CpuFeaturesData->CapabilityPcd, CpuInitOrder->FeaturesSupportedMask, CpuFeaturesData->BitMaskSize);
} }
// //
// Calculate the last setting // Calculate the last setting
// //
CpuFeaturesData->SettingPcd = AllocateCopyPool (CpuFeaturesData->BitMaskSize, CpuFeaturesData->CapabilityPcd); CpuFeaturesData->SettingPcd = AllocateCopyPool (CpuFeaturesData->BitMaskSize, CpuFeaturesData->CapabilityPcd);
ASSERT (CpuFeaturesData->SettingPcd != NULL); ASSERT (CpuFeaturesData->SettingPcd != NULL);
SupportedMaskAnd (CpuFeaturesData->SettingPcd, PcdGetPtr (PcdCpuFeaturesSetting)); SupportedMaskAnd (CpuFeaturesData->SettingPcd, PcdGetPtr (PcdCpuFeaturesSetting), CpuFeaturesData->BitMaskSize);
// //
// Dump the last CPU feature list // Dump the last CPU feature list
@ -574,8 +570,8 @@ AnalysisProcessorFeatures (
Entry = GetFirstNode (&CpuFeaturesData->FeatureList); Entry = GetFirstNode (&CpuFeaturesData->FeatureList);
while (!IsNull (&CpuFeaturesData->FeatureList, Entry)) { while (!IsNull (&CpuFeaturesData->FeatureList, Entry)) {
CpuFeature = CPU_FEATURE_ENTRY_FROM_LINK (Entry); CpuFeature = CPU_FEATURE_ENTRY_FROM_LINK (Entry);
if (IsBitMaskMatch (CpuFeature->FeatureMask, CpuFeaturesData->CapabilityPcd)) { if (IsBitMaskMatch (CpuFeature->FeatureMask, CpuFeaturesData->CapabilityPcd, CpuFeaturesData->BitMaskSize)) {
if (IsBitMaskMatch (CpuFeature->FeatureMask, CpuFeaturesData->SettingPcd)) { if (IsBitMaskMatch (CpuFeature->FeatureMask, CpuFeaturesData->SettingPcd, CpuFeaturesData->BitMaskSize)) {
DEBUG ((DEBUG_INFO, "[Enable ] ")); DEBUG ((DEBUG_INFO, "[Enable ] "));
} else { } else {
DEBUG ((DEBUG_INFO, "[Disable ] ")); DEBUG ((DEBUG_INFO, "[Disable ] "));
@ -583,22 +579,22 @@ AnalysisProcessorFeatures (
} else { } else {
DEBUG ((DEBUG_INFO, "[Unsupport] ")); DEBUG ((DEBUG_INFO, "[Unsupport] "));
} }
DumpCpuFeature (CpuFeature); DumpCpuFeature (CpuFeature, CpuFeaturesData->BitMaskSize);
Entry = Entry->ForwardLink; Entry = Entry->ForwardLink;
} }
DEBUG ((DEBUG_INFO, "PcdCpuFeaturesCapability:\n")); DEBUG ((DEBUG_INFO, "PcdCpuFeaturesCapability:\n"));
DumpCpuFeatureMask (CpuFeaturesData->CapabilityPcd); DumpCpuFeatureMask (CpuFeaturesData->CapabilityPcd, CpuFeaturesData->BitMaskSize);
DEBUG ((DEBUG_INFO, "Origin PcdCpuFeaturesSetting:\n")); DEBUG ((DEBUG_INFO, "Origin PcdCpuFeaturesSetting:\n"));
DumpCpuFeatureMask (PcdGetPtr (PcdCpuFeaturesSetting)); DumpCpuFeatureMask (PcdGetPtr (PcdCpuFeaturesSetting), CpuFeaturesData->BitMaskSize);
DEBUG ((DEBUG_INFO, "Final PcdCpuFeaturesSetting:\n")); DEBUG ((DEBUG_INFO, "Final PcdCpuFeaturesSetting:\n"));
DumpCpuFeatureMask (CpuFeaturesData->SettingPcd); DumpCpuFeatureMask (CpuFeaturesData->SettingPcd, CpuFeaturesData->BitMaskSize);
); );
// //
// Save PCDs and display CPU PCDs // Save PCDs and display CPU PCDs
// //
SetCapabilityPcd (CpuFeaturesData->CapabilityPcd, CpuFeaturesData->BitMaskSize); SetCapabilityPcd (CpuFeaturesData->CapabilityPcd, CpuFeaturesData->BitMaskSize);
SetSettingPcd (CpuFeaturesData->SettingPcd); SetSettingPcd (CpuFeaturesData->SettingPcd, CpuFeaturesData->BitMaskSize);
for (ProcessorNumber = 0; ProcessorNumber < NumberOfCpus; ProcessorNumber++) { for (ProcessorNumber = 0; ProcessorNumber < NumberOfCpus; ProcessorNumber++) {
CpuInitOrder = &CpuFeaturesData->InitOrder[ProcessorNumber]; CpuInitOrder = &CpuFeaturesData->InitOrder[ProcessorNumber];
@ -608,7 +604,7 @@ AnalysisProcessorFeatures (
// Insert each feature into processor's order list // Insert each feature into processor's order list
// //
CpuFeature = CPU_FEATURE_ENTRY_FROM_LINK (Entry); CpuFeature = CPU_FEATURE_ENTRY_FROM_LINK (Entry);
if (IsBitMaskMatch (CpuFeature->FeatureMask, CpuFeaturesData->CapabilityPcd)) { if (IsBitMaskMatch (CpuFeature->FeatureMask, CpuFeaturesData->CapabilityPcd, CpuFeaturesData->BitMaskSize)) {
CpuFeatureInOrder = AllocateCopyPool (sizeof (CPU_FEATURES_ENTRY), CpuFeature); CpuFeatureInOrder = AllocateCopyPool (sizeof (CPU_FEATURES_ENTRY), CpuFeature);
ASSERT (CpuFeatureInOrder != NULL); ASSERT (CpuFeatureInOrder != NULL);
InsertTailList (&CpuInitOrder->OrderList, &CpuFeatureInOrder->Link); InsertTailList (&CpuInitOrder->OrderList, &CpuFeatureInOrder->Link);
@ -624,18 +620,18 @@ AnalysisProcessorFeatures (
CpuFeatureInOrder = CPU_FEATURE_ENTRY_FROM_LINK (Entry); CpuFeatureInOrder = CPU_FEATURE_ENTRY_FROM_LINK (Entry);
Success = FALSE; Success = FALSE;
if (IsBitMaskMatch (CpuFeatureInOrder->FeatureMask, CpuFeaturesData->SettingPcd)) { if (IsBitMaskMatch (CpuFeatureInOrder->FeatureMask, CpuFeaturesData->SettingPcd, CpuFeaturesData->BitMaskSize)) {
Status = CpuFeatureInOrder->InitializeFunc (ProcessorNumber, CpuInfo, CpuFeatureInOrder->ConfigData, TRUE); Status = CpuFeatureInOrder->InitializeFunc (ProcessorNumber, CpuInfo, CpuFeatureInOrder->ConfigData, TRUE);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
// //
// Clean the CpuFeatureInOrder->FeatureMask in setting PCD. // Clean the CpuFeatureInOrder->FeatureMask in setting PCD.
// //
SupportedMaskCleanBit (CpuFeaturesData->SettingPcd, CpuFeatureInOrder->FeatureMask); SupportedMaskCleanBit (CpuFeaturesData->SettingPcd, CpuFeatureInOrder->FeatureMask, CpuFeaturesData->BitMaskSize);
if (CpuFeatureInOrder->FeatureName != NULL) { if (CpuFeatureInOrder->FeatureName != NULL) {
DEBUG ((DEBUG_WARN, "Warning :: Failed to enable Feature: Name = %a.\n", CpuFeatureInOrder->FeatureName)); DEBUG ((DEBUG_WARN, "Warning :: Failed to enable Feature: Name = %a.\n", CpuFeatureInOrder->FeatureName));
} else { } else {
DEBUG ((DEBUG_WARN, "Warning :: Failed to enable Feature: Mask = ")); DEBUG ((DEBUG_WARN, "Warning :: Failed to enable Feature: Mask = "));
DumpCpuFeatureMask (CpuFeatureInOrder->FeatureMask); DumpCpuFeatureMask (CpuFeatureInOrder->FeatureMask, CpuFeaturesData->BitMaskSize);
} }
} else { } else {
Success = TRUE; Success = TRUE;
@ -647,7 +643,7 @@ AnalysisProcessorFeatures (
DEBUG ((DEBUG_WARN, "Warning :: Failed to disable Feature: Name = %a.\n", CpuFeatureInOrder->FeatureName)); DEBUG ((DEBUG_WARN, "Warning :: Failed to disable Feature: Name = %a.\n", CpuFeatureInOrder->FeatureName));
} else { } else {
DEBUG ((DEBUG_WARN, "Warning :: Failed to disable Feature: Mask = ")); DEBUG ((DEBUG_WARN, "Warning :: Failed to disable Feature: Mask = "));
DumpCpuFeatureMask (CpuFeatureInOrder->FeatureMask); DumpCpuFeatureMask (CpuFeatureInOrder->FeatureMask, CpuFeaturesData->BitMaskSize);
} }
} else { } else {
Success = TRUE; Success = TRUE;
@ -699,7 +695,7 @@ AnalysisProcessorFeatures (
// again during initialize the features. // again during initialize the features.
// //
DEBUG ((DEBUG_INFO, "Dump final value for PcdCpuFeaturesSetting:\n")); DEBUG ((DEBUG_INFO, "Dump final value for PcdCpuFeaturesSetting:\n"));
DumpCpuFeatureMask (CpuFeaturesData->SettingPcd); DumpCpuFeatureMask (CpuFeaturesData->SettingPcd, CpuFeaturesData->BitMaskSize);
// //
// Dump the RegisterTable // Dump the RegisterTable

10
UefiCpuPkg/Library/RegisterCpuFeaturesLib/RegisterCpuFeatures.h
View File

@ -180,20 +180,26 @@ SwitchNewBsp (
Function that uses DEBUG() macros to display the contents of a a CPU feature bit mask. Function that uses DEBUG() macros to display the contents of a a CPU feature bit mask.
@param[in] FeatureMask A pointer to the CPU feature bit mask. @param[in] FeatureMask A pointer to the CPU feature bit mask.
@param[in] BitMaskSize CPU feature bits mask buffer size.
**/ **/
VOID VOID
DumpCpuFeatureMask ( DumpCpuFeatureMask (
IN UINT8 *FeatureMask IN UINT8 *FeatureMask,
IN UINT32 BitMaskSize
); );
/** /**
Dump CPU feature name or CPU feature bit mask. Dump CPU feature name or CPU feature bit mask.
@param[in] CpuFeature Pointer to CPU_FEATURES_ENTRY @param[in] CpuFeature Pointer to CPU_FEATURES_ENTRY
@param[in] BitMaskSize CPU feature bits mask buffer size.
**/ **/
VOID VOID
DumpCpuFeature ( DumpCpuFeature (
IN CPU_FEATURES_ENTRY *CpuFeature IN CPU_FEATURES_ENTRY *CpuFeature,
IN UINT32 BitMaskSize
); );
/** /**

107
UefiCpuPkg/Library/RegisterCpuFeaturesLib/RegisterCpuFeaturesLib.c
View File

@ -8,46 +8,22 @@
#include "RegisterCpuFeatures.h" #include "RegisterCpuFeatures.h"
/**
Checks if two CPU feature bit masks are equal.
@param[in] FirstFeatureMask The first input CPU feature bit mask
@param[in] SecondFeatureMask The second input CPU feature bit mask
@retval TRUE Two CPU feature bit masks are equal.
@retval FALSE Two CPU feature bit masks are not equal.
**/
BOOLEAN
IsCpuFeatureMatch (
IN UINT8 *FirstFeatureMask,
IN UINT8 *SecondFeatureMask
)
{
UINTN BitMaskSize;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting);
if (CompareMem (FirstFeatureMask, SecondFeatureMask, BitMaskSize) == 0) {
return TRUE;
} else {
return FALSE;
}
}
/** /**
Function that uses DEBUG() macros to display the contents of a a CPU feature bit mask. Function that uses DEBUG() macros to display the contents of a a CPU feature bit mask.
@param[in] FeatureMask A pointer to the CPU feature bit mask. @param[in] FeatureMask A pointer to the CPU feature bit mask.
@param[in] BitMaskSize CPU feature bits mask buffer size.
**/ **/
VOID VOID
DumpCpuFeatureMask ( DumpCpuFeatureMask (
IN UINT8 *FeatureMask IN UINT8 *FeatureMask,
IN UINT32 BitMaskSize
) )
{ {
UINTN Index; UINTN Index;
UINT8 *Data8; UINT8 *Data8;
UINTN BitMaskSize;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting);
Data8 = (UINT8 *) FeatureMask; Data8 = (UINT8 *) FeatureMask;
for (Index = 0; Index < BitMaskSize; Index++) { for (Index = 0; Index < BitMaskSize; Index++) {
DEBUG ((DEBUG_INFO, " %02x ", *Data8++)); DEBUG ((DEBUG_INFO, " %02x ", *Data8++));
@ -59,10 +35,13 @@ DumpCpuFeatureMask (
Dump CPU feature name or CPU feature bit mask. Dump CPU feature name or CPU feature bit mask.
@param[in] CpuFeature Pointer to CPU_FEATURES_ENTRY @param[in] CpuFeature Pointer to CPU_FEATURES_ENTRY
@param[in] BitMaskSize CPU feature bits mask buffer size.
**/ **/
VOID VOID
DumpCpuFeature ( DumpCpuFeature (
IN CPU_FEATURES_ENTRY *CpuFeature IN CPU_FEATURES_ENTRY *CpuFeature,
IN UINT32 BitMaskSize
) )
{ {
@ -70,7 +49,7 @@ DumpCpuFeature (
DEBUG ((DEBUG_INFO, "FeatureName: %a\n", CpuFeature->FeatureName)); DEBUG ((DEBUG_INFO, "FeatureName: %a\n", CpuFeature->FeatureName));
} else { } else {
DEBUG ((DEBUG_INFO, "FeatureMask = ")); DEBUG ((DEBUG_INFO, "FeatureMask = "));
DumpCpuFeatureMask (CpuFeature->FeatureMask); DumpCpuFeatureMask (CpuFeature->FeatureMask, BitMaskSize);
} }
} }
@ -89,16 +68,16 @@ IsBitMaskMatchCheck (
IN UINT8 *DependentBitMask IN UINT8 *DependentBitMask
) )
{ {
UINTN Index; UINTN Index;
UINTN BitMaskSize; UINT8 *Data1;
UINT8 *Data1; UINT8 *Data2;
UINT8 *Data2; CPU_FEATURES_DATA *CpuFeaturesData;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting); CpuFeaturesData = GetCpuFeaturesData ();
Data1 = FeatureMask; Data1 = FeatureMask;
Data2 = DependentBitMask; Data2 = DependentBitMask;
for (Index = 0; Index < BitMaskSize; Index++) { for (Index = 0; Index < CpuFeaturesData->BitMaskSize; Index++) {
if (((*(Data1++)) & (*(Data2++))) != 0) { if (((*(Data1++)) & (*(Data2++))) != 0) {
return TRUE; return TRUE;
} }
@ -631,6 +610,7 @@ CheckCpuFeaturesDependency (
/** /**
Worker function to register CPU Feature. Worker function to register CPU Feature.
@param[in] CpuFeaturesData Pointer to CPU feature data structure.
@param[in] CpuFeature Pointer to CPU feature entry @param[in] CpuFeature Pointer to CPU feature entry
@retval RETURN_SUCCESS The CPU feature was successfully registered. @retval RETURN_SUCCESS The CPU feature was successfully registered.
@ -642,37 +622,21 @@ CheckCpuFeaturesDependency (
**/ **/
RETURN_STATUS RETURN_STATUS
RegisterCpuFeatureWorker ( RegisterCpuFeatureWorker (
IN CPU_FEATURES_DATA *CpuFeaturesData,
IN CPU_FEATURES_ENTRY *CpuFeature IN CPU_FEATURES_ENTRY *CpuFeature
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
CPU_FEATURES_DATA *CpuFeaturesData;
CPU_FEATURES_ENTRY *CpuFeatureEntry; CPU_FEATURES_ENTRY *CpuFeatureEntry;
LIST_ENTRY *Entry; LIST_ENTRY *Entry;
UINTN BitMaskSize;
BOOLEAN FeatureExist; BOOLEAN FeatureExist;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting);
CpuFeaturesData = GetCpuFeaturesData ();
if (CpuFeaturesData->FeaturesCount == 0) {
InitializeListHead (&CpuFeaturesData->FeatureList);
InitializeSpinLock (&CpuFeaturesData->CpuFlags.MemoryMappedLock);
InitializeSpinLock (&CpuFeaturesData->CpuFlags.ConsoleLogLock);
//
// Driver has assumption that these three PCD should has same buffer size.
//
ASSERT (PcdGetSize (PcdCpuFeaturesSetting) == PcdGetSize (PcdCpuFeaturesCapability));
ASSERT (PcdGetSize (PcdCpuFeaturesSetting) == PcdGetSize (PcdCpuFeaturesSupport));
CpuFeaturesData->BitMaskSize = (UINT32) BitMaskSize;
}
ASSERT (CpuFeaturesData->BitMaskSize == BitMaskSize);
FeatureExist = FALSE; FeatureExist = FALSE;
CpuFeatureEntry = NULL; CpuFeatureEntry = NULL;
Entry = GetFirstNode (&CpuFeaturesData->FeatureList); Entry = GetFirstNode (&CpuFeaturesData->FeatureList);
while (!IsNull (&CpuFeaturesData->FeatureList, Entry)) { while (!IsNull (&CpuFeaturesData->FeatureList, Entry)) {
CpuFeatureEntry = CPU_FEATURE_ENTRY_FROM_LINK (Entry); CpuFeatureEntry = CPU_FEATURE_ENTRY_FROM_LINK (Entry);
if (IsCpuFeatureMatch (CpuFeature->FeatureMask, CpuFeatureEntry->FeatureMask)) { if (CompareMem (CpuFeature->FeatureMask, CpuFeatureEntry->FeatureMask, CpuFeaturesData->BitMaskSize) == 0) {
// //
// If this feature already registered // If this feature already registered
// //
@ -684,12 +648,12 @@ RegisterCpuFeatureWorker (
if (!FeatureExist) { if (!FeatureExist) {
DEBUG ((DEBUG_INFO, "[NEW] ")); DEBUG ((DEBUG_INFO, "[NEW] "));
DumpCpuFeature (CpuFeature); DumpCpuFeature (CpuFeature, CpuFeaturesData->BitMaskSize);
InsertTailList (&CpuFeaturesData->FeatureList, &CpuFeature->Link); InsertTailList (&CpuFeaturesData->FeatureList, &CpuFeature->Link);
CpuFeaturesData->FeaturesCount++; CpuFeaturesData->FeaturesCount++;
} else { } else {
DEBUG ((DEBUG_INFO, "[OVERRIDE] ")); DEBUG ((DEBUG_INFO, "[OVERRIDE] "));
DumpCpuFeature (CpuFeature); DumpCpuFeature (CpuFeature, CpuFeaturesData->BitMaskSize);
ASSERT (CpuFeatureEntry != NULL); ASSERT (CpuFeatureEntry != NULL);
// //
// Overwrite original parameters of CPU feature // Overwrite original parameters of CPU feature
@ -849,7 +813,6 @@ RegisterCpuFeature (
EFI_STATUS Status; EFI_STATUS Status;
VA_LIST Marker; VA_LIST Marker;
UINT32 Feature; UINT32 Feature;
UINTN BitMaskSize;
CPU_FEATURES_ENTRY *CpuFeature; CPU_FEATURES_ENTRY *CpuFeature;
UINT8 *FeatureMask; UINT8 *FeatureMask;
UINT8 *BeforeFeatureBitMask; UINT8 *BeforeFeatureBitMask;
@ -860,6 +823,7 @@ RegisterCpuFeature (
UINT8 *PackageAfterFeatureBitMask; UINT8 *PackageAfterFeatureBitMask;
BOOLEAN BeforeAll; BOOLEAN BeforeAll;
BOOLEAN AfterAll; BOOLEAN AfterAll;
CPU_FEATURES_DATA *CpuFeaturesData;
FeatureMask = NULL; FeatureMask = NULL;
BeforeFeatureBitMask = NULL; BeforeFeatureBitMask = NULL;
@ -871,7 +835,18 @@ RegisterCpuFeature (
BeforeAll = FALSE; BeforeAll = FALSE;
AfterAll = FALSE; AfterAll = FALSE;
BitMaskSize = PcdGetSize (PcdCpuFeaturesSetting); CpuFeaturesData = GetCpuFeaturesData ();
if (CpuFeaturesData->FeaturesCount == 0) {
InitializeListHead (&CpuFeaturesData->FeatureList);
InitializeSpinLock (&CpuFeaturesData->CpuFlags.MemoryMappedLock);
InitializeSpinLock (&CpuFeaturesData->CpuFlags.ConsoleLogLock);
//
// Code assumes below three PCDs have PCD same buffer size.
//
ASSERT (PcdGetSize (PcdCpuFeaturesSetting) == PcdGetSize (PcdCpuFeaturesCapability));
ASSERT (PcdGetSize (PcdCpuFeaturesSetting) == PcdGetSize (PcdCpuFeaturesSupport));
CpuFeaturesData->BitMaskSize = (UINT32) PcdGetSize (PcdCpuFeaturesSetting);
}
VA_START (Marker, InitializeFunc); VA_START (Marker, InitializeFunc);
Feature = VA_ARG (Marker, UINT32); Feature = VA_ARG (Marker, UINT32);
@ -889,19 +864,19 @@ RegisterCpuFeature (
AfterAll = ((Feature & CPU_FEATURE_AFTER_ALL) != 0) ? TRUE : FALSE; AfterAll = ((Feature & CPU_FEATURE_AFTER_ALL) != 0) ? TRUE : FALSE;
Feature &= ~(CPU_FEATURE_BEFORE_ALL | CPU_FEATURE_AFTER_ALL); Feature &= ~(CPU_FEATURE_BEFORE_ALL | CPU_FEATURE_AFTER_ALL);
ASSERT (FeatureMask == NULL); ASSERT (FeatureMask == NULL);
SetCpuFeaturesBitMask (&FeatureMask, Feature, BitMaskSize); SetCpuFeaturesBitMask (&FeatureMask, Feature, CpuFeaturesData->BitMaskSize);
} else if ((Feature & CPU_FEATURE_BEFORE) != 0) { } else if ((Feature & CPU_FEATURE_BEFORE) != 0) {
SetCpuFeaturesBitMask (&BeforeFeatureBitMask, Feature & ~CPU_FEATURE_BEFORE, BitMaskSize); SetCpuFeaturesBitMask (&BeforeFeatureBitMask, Feature & ~CPU_FEATURE_BEFORE, CpuFeaturesData->BitMaskSize);
} else if ((Feature & CPU_FEATURE_AFTER) != 0) { } else if ((Feature & CPU_FEATURE_AFTER) != 0) {
SetCpuFeaturesBitMask (&AfterFeatureBitMask, Feature & ~CPU_FEATURE_AFTER, BitMaskSize); SetCpuFeaturesBitMask (&AfterFeatureBitMask, Feature & ~CPU_FEATURE_AFTER, CpuFeaturesData->BitMaskSize);
} else if ((Feature & CPU_FEATURE_CORE_BEFORE) != 0) { } else if ((Feature & CPU_FEATURE_CORE_BEFORE) != 0) {
SetCpuFeaturesBitMask (&CoreBeforeFeatureBitMask, Feature & ~CPU_FEATURE_CORE_BEFORE, BitMaskSize); SetCpuFeaturesBitMask (&CoreBeforeFeatureBitMask, Feature & ~CPU_FEATURE_CORE_BEFORE, CpuFeaturesData->BitMaskSize);
} else if ((Feature & CPU_FEATURE_CORE_AFTER) != 0) { } else if ((Feature & CPU_FEATURE_CORE_AFTER) != 0) {
SetCpuFeaturesBitMask (&CoreAfterFeatureBitMask, Feature & ~CPU_FEATURE_CORE_AFTER, BitMaskSize); SetCpuFeaturesBitMask (&CoreAfterFeatureBitMask, Feature & ~CPU_FEATURE_CORE_AFTER, CpuFeaturesData->BitMaskSize);
} else if ((Feature & CPU_FEATURE_PACKAGE_BEFORE) != 0) { } else if ((Feature & CPU_FEATURE_PACKAGE_BEFORE) != 0) {
SetCpuFeaturesBitMask (&PackageBeforeFeatureBitMask, Feature & ~CPU_FEATURE_PACKAGE_BEFORE, BitMaskSize); SetCpuFeaturesBitMask (&PackageBeforeFeatureBitMask, Feature & ~CPU_FEATURE_PACKAGE_BEFORE, CpuFeaturesData->BitMaskSize);
} else if ((Feature & CPU_FEATURE_PACKAGE_AFTER) != 0) { } else if ((Feature & CPU_FEATURE_PACKAGE_AFTER) != 0) {
SetCpuFeaturesBitMask (&PackageAfterFeatureBitMask, Feature & ~CPU_FEATURE_PACKAGE_AFTER, BitMaskSize); SetCpuFeaturesBitMask (&PackageAfterFeatureBitMask, Feature & ~CPU_FEATURE_PACKAGE_AFTER, CpuFeaturesData->BitMaskSize);
} }
Feature = VA_ARG (Marker, UINT32); Feature = VA_ARG (Marker, UINT32);
} }
@ -929,7 +904,7 @@ RegisterCpuFeature (
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
} }
Status = RegisterCpuFeatureWorker (CpuFeature); Status = RegisterCpuFeatureWorker (CpuFeaturesData, CpuFeature);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
return RETURN_SUCCESS; return RETURN_SUCCESS;