#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
\r
-#define OR_SEED 0x0101010101010101ull\r
-#define CLEAR_SEED 0xFFFFFFFFFFFFFFFFull\r
-#define MAX_WEIGHT MAX_UINT8\r
-#define SCRATCH_BUFFER_SIZE (4 * SIZE_4KB)\r
-#define MTRR_LIB_ASSERT_ALIGNED(B, L) ASSERT ((B & ~(L - 1)) == B);\r
+#define OR_SEED 0x0101010101010101ull\r
+#define CLEAR_SEED 0xFFFFFFFFFFFFFFFFull\r
+#define MAX_WEIGHT MAX_UINT8\r
+#define SCRATCH_BUFFER_SIZE (4 * SIZE_4KB)\r
+#define MTRR_LIB_ASSERT_ALIGNED(B, L) ASSERT ((B & ~(L - 1)) == B);\r
\r
-#define M(x,y) ((x) * VertexCount + (y))\r
-#define O(x,y) ((y) * VertexCount + (x))\r
+#define M(x, y) ((x) * VertexCount + (y))\r
+#define O(x, y) ((y) * VertexCount + (x))\r
\r
//\r
// Context to save and restore when MTRRs are programmed\r
//\r
typedef struct {\r
- UINTN Cr4;\r
- BOOLEAN InterruptState;\r
+ UINTN Cr4;\r
+ BOOLEAN InterruptState;\r
} MTRR_CONTEXT;\r
\r
typedef struct {\r
- UINT64 Address;\r
- UINT64 Alignment;\r
- UINT64 Length;\r
- MTRR_MEMORY_CACHE_TYPE Type : 7;\r
+ UINT64 Address;\r
+ UINT64 Alignment;\r
+ UINT64 Length;\r
+ MTRR_MEMORY_CACHE_TYPE Type : 7;\r
\r
//\r
// Temprary use for calculating the best MTRR settings.\r
//\r
- BOOLEAN Visited : 1;\r
- UINT8 Weight;\r
- UINT16 Previous;\r
+ BOOLEAN Visited : 1;\r
+ UINT8 Weight;\r
+ UINT16 Previous;\r
} MTRR_LIB_ADDRESS;\r
\r
//\r
//\r
// Lookup table used to print MTRRs\r
//\r
-GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 *mMtrrMemoryCacheTypeShortName[] = {\r
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 *mMtrrMemoryCacheTypeShortName[] = {\r
"UC", // CacheUncacheable\r
"WC", // CacheWriteCombining\r
"R*", // Invalid\r
"R*" // Invalid\r
};\r
\r
-\r
/**\r
Worker function prints all MTRRs for debugging.\r
\r
**/\r
VOID\r
MtrrDebugPrintAllMtrrsWorker (\r
- IN MTRR_SETTINGS *MtrrSetting\r
+ IN MTRR_SETTINGS *MtrrSetting\r
);\r
\r
/**\r
VOID\r
)\r
{\r
- MSR_IA32_MTRRCAP_REGISTER MtrrCap;\r
+ MSR_IA32_MTRRCAP_REGISTER MtrrCap;\r
\r
MtrrCap.Uint64 = AsmReadMsr64 (MSR_IA32_MTRRCAP);\r
- ASSERT (MtrrCap.Bits.VCNT <= ARRAY_SIZE (((MTRR_VARIABLE_SETTINGS *) 0)->Mtrr));\r
+ ASSERT (MtrrCap.Bits.VCNT <= ARRAY_SIZE (((MTRR_VARIABLE_SETTINGS *)0)->Mtrr));\r
return MtrrCap.Bits.VCNT;\r
}\r
\r
if (!IsMtrrSupported ()) {\r
return 0;\r
}\r
+\r
return GetVariableMtrrCountWorker ();\r
}\r
\r
UINT32 VariableMtrrCount;\r
UINT32 ReservedMtrrNumber;\r
\r
- VariableMtrrCount = GetVariableMtrrCountWorker ();\r
+ VariableMtrrCount = GetVariableMtrrCountWorker ();\r
ReservedMtrrNumber = PcdGet32 (PcdCpuNumberOfReservedVariableMtrrs);\r
if (VariableMtrrCount < ReservedMtrrNumber) {\r
return 0;\r
if (!IsMtrrSupported ()) {\r
return 0;\r
}\r
+\r
return GetFirmwareVariableMtrrCountWorker ();\r
}\r
\r
**/\r
MTRR_MEMORY_CACHE_TYPE\r
MtrrGetDefaultMemoryTypeWorker (\r
- IN MTRR_SETTINGS *MtrrSetting\r
+ IN MTRR_SETTINGS *MtrrSetting\r
)\r
{\r
- MSR_IA32_MTRR_DEF_TYPE_REGISTER DefType;\r
+ MSR_IA32_MTRR_DEF_TYPE_REGISTER DefType;\r
\r
if (MtrrSetting == NULL) {\r
DefType.Uint64 = AsmReadMsr64 (MSR_IA32_MTRR_DEF_TYPE);\r
DefType.Uint64 = MtrrSetting->MtrrDefType;\r
}\r
\r
- return (MTRR_MEMORY_CACHE_TYPE) DefType.Bits.Type;\r
+ return (MTRR_MEMORY_CACHE_TYPE)DefType.Bits.Type;\r
}\r
\r
-\r
/**\r
Returns the default MTRR cache type for the system.\r
\r
if (!IsMtrrSupported ()) {\r
return CacheUncacheable;\r
}\r
+\r
return MtrrGetDefaultMemoryTypeWorker (NULL);\r
}\r
\r
)\r
{\r
MSR_IA32_MTRR_DEF_TYPE_REGISTER DefType;\r
+\r
//\r
// Disable interrupts and save current interrupt state\r
//\r
- MtrrContext->InterruptState = SaveAndDisableInterrupts();\r
+ MtrrContext->InterruptState = SaveAndDisableInterrupts ();\r
\r
//\r
// Enter no fill cache mode, CD=1(Bit30), NW=0 (Bit29)\r
)\r
{\r
MSR_IA32_MTRR_DEF_TYPE_REGISTER DefType;\r
+\r
//\r
// Enable Cache MTRR\r
//\r
- DefType.Uint64 = AsmReadMsr64 (MSR_IA32_MTRR_DEF_TYPE);\r
- DefType.Bits.E = 1;\r
+ DefType.Uint64 = AsmReadMsr64 (MSR_IA32_MTRR_DEF_TYPE);\r
+ DefType.Bits.E = 1;\r
DefType.Bits.FE = 1;\r
AsmWriteMsr64 (MSR_IA32_MTRR_DEF_TYPE, DefType.Uint64);\r
\r
@retval The pointer of FixedSettings\r
\r
**/\r
-MTRR_FIXED_SETTINGS*\r
+MTRR_FIXED_SETTINGS *\r
MtrrGetFixedMtrrWorker (\r
- OUT MTRR_FIXED_SETTINGS *FixedSettings\r
+ OUT MTRR_FIXED_SETTINGS *FixedSettings\r
)\r
{\r
UINT32 Index;\r
\r
for (Index = 0; Index < MTRR_NUMBER_OF_FIXED_MTRR; Index++) {\r
- FixedSettings->Mtrr[Index] =\r
- AsmReadMsr64 (mMtrrLibFixedMtrrTable[Index].Msr);\r
+ FixedSettings->Mtrr[Index] =\r
+ AsmReadMsr64 (mMtrrLibFixedMtrrTable[Index].Msr);\r
}\r
\r
return FixedSettings;\r
}\r
\r
-\r
/**\r
This function gets the content in fixed MTRRs\r
\r
@retval The pointer of FixedSettings\r
\r
**/\r
-MTRR_FIXED_SETTINGS*\r
+MTRR_FIXED_SETTINGS *\r
EFIAPI\r
MtrrGetFixedMtrr (\r
- OUT MTRR_FIXED_SETTINGS *FixedSettings\r
+ OUT MTRR_FIXED_SETTINGS *FixedSettings\r
)\r
{\r
if (!IsMtrrSupported ()) {\r
return MtrrGetFixedMtrrWorker (FixedSettings);\r
}\r
\r
-\r
/**\r
Worker function will get the raw value in variable MTRRs\r
\r
@return The VariableSettings input pointer\r
\r
**/\r
-MTRR_VARIABLE_SETTINGS*\r
+MTRR_VARIABLE_SETTINGS *\r
MtrrGetVariableMtrrWorker (\r
IN MTRR_SETTINGS *MtrrSetting,\r
IN UINT32 VariableMtrrCount,\r
}\r
}\r
\r
- return VariableSettings;\r
+ return VariableSettings;\r
}\r
\r
/**\r
for (MsrIndex = *LastMsrIndex + 1; MsrIndex < ARRAY_SIZE (mMtrrLibFixedMtrrTable); MsrIndex++) {\r
if ((*Base >= mMtrrLibFixedMtrrTable[MsrIndex].BaseAddress) &&\r
(*Base <\r
- (\r
- mMtrrLibFixedMtrrTable[MsrIndex].BaseAddress +\r
- (8 * mMtrrLibFixedMtrrTable[MsrIndex].Length)\r
- )\r
- )\r
- ) {\r
+ (\r
+ mMtrrLibFixedMtrrTable[MsrIndex].BaseAddress +\r
+ (8 * mMtrrLibFixedMtrrTable[MsrIndex].Length)\r
+ )\r
+ )\r
+ )\r
+ {\r
break;\r
}\r
}\r
//\r
return RETURN_UNSUPPORTED;\r
}\r
+\r
LeftByteShift = ((UINT32)*Base - mMtrrLibFixedMtrrTable[MsrIndex].BaseAddress) / mMtrrLibFixedMtrrTable[MsrIndex].Length;\r
ASSERT (LeftByteShift < 8);\r
\r
//\r
return RETURN_UNSUPPORTED;\r
}\r
+\r
RightByteShift = 8 - LeftByteShift - (UINT32)(*Length) / mMtrrLibFixedMtrrTable[MsrIndex].Length;\r
//\r
// Update SubLength by actual length\r
}\r
\r
*ClearMask = CLEAR_SEED;\r
- *OrMask = MultU64x32 (OR_SEED, (UINT32) Type);\r
+ *OrMask = MultU64x32 (OR_SEED, (UINT32)Type);\r
\r
if (LeftByteShift != 0) {\r
//\r
// Clear the low bits by LeftByteShift\r
//\r
*ClearMask &= LShiftU64 (*ClearMask, LeftByteShift * 8);\r
- *OrMask &= LShiftU64 (*OrMask, LeftByteShift * 8);\r
+ *OrMask &= LShiftU64 (*OrMask, LeftByteShift * 8);\r
}\r
\r
if (RightByteShift != 0) {\r
// Clear the high bits by RightByteShift\r
//\r
*ClearMask &= RShiftU64 (*ClearMask, RightByteShift * 8);\r
- *OrMask &= RShiftU64 (*OrMask, RightByteShift * 8);\r
+ *OrMask &= RShiftU64 (*OrMask, RightByteShift * 8);\r
}\r
\r
*Length -= SubLength;\r
*Base += SubLength;\r
\r
- *LastMsrIndex = MsrIndex;\r
+ *LastMsrIndex = MsrIndex;\r
\r
return RETURN_SUCCESS;\r
}\r
\r
-\r
/**\r
Worker function gets the attribute of variable MTRRs.\r
\r
\r
ZeroMem (VariableMtrr, sizeof (VARIABLE_MTRR) * ARRAY_SIZE (VariableSettings->Mtrr));\r
for (Index = 0, UsedMtrr = 0; Index < VariableMtrrCount; Index++) {\r
- if (((MSR_IA32_MTRR_PHYSMASK_REGISTER *) &VariableSettings->Mtrr[Index].Mask)->Bits.V != 0) {\r
+ if (((MSR_IA32_MTRR_PHYSMASK_REGISTER *)&VariableSettings->Mtrr[Index].Mask)->Bits.V != 0) {\r
VariableMtrr[Index].Msr = (UINT32)Index;\r
VariableMtrr[Index].BaseAddress = (VariableSettings->Mtrr[Index].Base & MtrrValidAddressMask);\r
VariableMtrr[Index].Length =\r
((~(VariableSettings->Mtrr[Index].Mask & MtrrValidAddressMask)) & MtrrValidBitsMask) + 1;\r
- VariableMtrr[Index].Type = (VariableSettings->Mtrr[Index].Base & 0x0ff);\r
- VariableMtrr[Index].Valid = TRUE;\r
- VariableMtrr[Index].Used = TRUE;\r
+ VariableMtrr[Index].Type = (VariableSettings->Mtrr[Index].Base & 0x0ff);\r
+ VariableMtrr[Index].Valid = TRUE;\r
+ VariableMtrr[Index].Used = TRUE;\r
UsedMtrr++;\r
}\r
}\r
+\r
return UsedMtrr;\r
}\r
\r
\r
ZeroMem (VariableMtrr, sizeof (MTRR_MEMORY_RANGE) * ARRAY_SIZE (VariableSettings->Mtrr));\r
for (Index = 0, UsedMtrr = 0; Index < VariableMtrrCount; Index++) {\r
- if (((MSR_IA32_MTRR_PHYSMASK_REGISTER *) &VariableSettings->Mtrr[Index].Mask)->Bits.V != 0) {\r
+ if (((MSR_IA32_MTRR_PHYSMASK_REGISTER *)&VariableSettings->Mtrr[Index].Mask)->Bits.V != 0) {\r
VariableMtrr[Index].BaseAddress = (VariableSettings->Mtrr[Index].Base & MtrrValidAddressMask);\r
VariableMtrr[Index].Length =\r
((~(VariableSettings->Mtrr[Index].Mask & MtrrValidAddressMask)) & MtrrValidBitsMask) + 1;\r
- VariableMtrr[Index].Type = (MTRR_MEMORY_CACHE_TYPE)(VariableSettings->Mtrr[Index].Base & 0x0ff);\r
+ VariableMtrr[Index].Type = (MTRR_MEMORY_CACHE_TYPE)(VariableSettings->Mtrr[Index].Base & 0x0ff);\r
UsedMtrr++;\r
}\r
}\r
+\r
return UsedMtrr;\r
}\r
\r
UINT32\r
EFIAPI\r
MtrrGetMemoryAttributeInVariableMtrr (\r
- IN UINT64 MtrrValidBitsMask,\r
- IN UINT64 MtrrValidAddressMask,\r
- OUT VARIABLE_MTRR *VariableMtrr\r
+ IN UINT64 MtrrValidBitsMask,\r
+ IN UINT64 MtrrValidAddressMask,\r
+ OUT VARIABLE_MTRR *VariableMtrr\r
)\r
{\r
MTRR_VARIABLE_SETTINGS VariableSettings;\r
**/\r
UINT64\r
MtrrLibBiggestAlignment (\r
- UINT64 Address,\r
- UINT64 Alignment0\r
-)\r
+ UINT64 Address,\r
+ UINT64 Alignment0\r
+ )\r
{\r
if (Address == 0) {\r
return Alignment0;\r
MtrrLibTypeLeftPrecedeRight (\r
IN MTRR_MEMORY_CACHE_TYPE Left,\r
IN MTRR_MEMORY_CACHE_TYPE Right\r
-)\r
+ )\r
{\r
- return (BOOLEAN) (Left == CacheUncacheable || (Left == CacheWriteThrough && Right == CacheWriteBack));\r
+ return (BOOLEAN)(Left == CacheUncacheable || (Left == CacheWriteThrough && Right == CacheWriteBack));\r
}\r
\r
/**\r
**/\r
VOID\r
MtrrLibInitializeMtrrMask (\r
- OUT UINT64 *MtrrValidBitsMask,\r
- OUT UINT64 *MtrrValidAddressMask\r
+ OUT UINT64 *MtrrValidBitsMask,\r
+ OUT UINT64 *MtrrValidAddressMask\r
)\r
{\r
UINT32 MaxExtendedFunction;\r
CPUID_VIR_PHY_ADDRESS_SIZE_EAX VirPhyAddressSize;\r
\r
-\r
AsmCpuid (CPUID_EXTENDED_FUNCTION, &MaxExtendedFunction, NULL, NULL, NULL);\r
\r
if (MaxExtendedFunction >= CPUID_VIR_PHY_ADDRESS_SIZE) {\r
VirPhyAddressSize.Bits.PhysicalAddressBits = 36;\r
}\r
\r
- *MtrrValidBitsMask = LShiftU64 (1, VirPhyAddressSize.Bits.PhysicalAddressBits) - 1;\r
+ *MtrrValidBitsMask = LShiftU64 (1, VirPhyAddressSize.Bits.PhysicalAddressBits) - 1;\r
*MtrrValidAddressMask = *MtrrValidBitsMask & 0xfffffffffffff000ULL;\r
}\r
\r
-\r
/**\r
Determines the real attribute of a memory range.\r
\r
**/\r
MTRR_MEMORY_CACHE_TYPE\r
MtrrLibPrecedence (\r
- IN MTRR_MEMORY_CACHE_TYPE MtrrType1,\r
- IN MTRR_MEMORY_CACHE_TYPE MtrrType2\r
+ IN MTRR_MEMORY_CACHE_TYPE MtrrType1,\r
+ IN MTRR_MEMORY_CACHE_TYPE MtrrType2\r
)\r
{\r
if (MtrrType1 == MtrrType2) {\r
ASSERT (\r
MtrrLibTypeLeftPrecedeRight (MtrrType1, MtrrType2) ||\r
MtrrLibTypeLeftPrecedeRight (MtrrType2, MtrrType1)\r
- );\r
+ );\r
\r
if (MtrrLibTypeLeftPrecedeRight (MtrrType1, MtrrType2)) {\r
return MtrrType1;\r
**/\r
MTRR_MEMORY_CACHE_TYPE\r
MtrrGetMemoryAttributeByAddressWorker (\r
- IN MTRR_SETTINGS *MtrrSetting,\r
- IN PHYSICAL_ADDRESS Address\r
+ IN MTRR_SETTINGS *MtrrSetting,\r
+ IN PHYSICAL_ADDRESS Address\r
)\r
{\r
- MSR_IA32_MTRR_DEF_TYPE_REGISTER DefType;\r
- UINT64 FixedMtrr;\r
- UINTN Index;\r
- UINTN SubIndex;\r
- MTRR_MEMORY_CACHE_TYPE MtrrType;\r
- MTRR_MEMORY_RANGE VariableMtrr[ARRAY_SIZE (MtrrSetting->Variables.Mtrr)];\r
- UINT64 MtrrValidBitsMask;\r
- UINT64 MtrrValidAddressMask;\r
- UINT32 VariableMtrrCount;\r
- MTRR_VARIABLE_SETTINGS VariableSettings;\r
+ MSR_IA32_MTRR_DEF_TYPE_REGISTER DefType;\r
+ UINT64 FixedMtrr;\r
+ UINTN Index;\r
+ UINTN SubIndex;\r
+ MTRR_MEMORY_CACHE_TYPE MtrrType;\r
+ MTRR_MEMORY_RANGE VariableMtrr[ARRAY_SIZE (MtrrSetting->Variables.Mtrr)];\r
+ UINT64 MtrrValidBitsMask;\r
+ UINT64 MtrrValidAddressMask;\r
+ UINT32 VariableMtrrCount;\r
+ MTRR_VARIABLE_SETTINGS VariableSettings;\r
\r
//\r
// Check if MTRR is enabled, if not, return UC as attribute\r
// Go through the fixed MTRR\r
//\r
for (Index = 0; Index < MTRR_NUMBER_OF_FIXED_MTRR; Index++) {\r
- if (Address >= mMtrrLibFixedMtrrTable[Index].BaseAddress &&\r
- Address < mMtrrLibFixedMtrrTable[Index].BaseAddress +\r
- (mMtrrLibFixedMtrrTable[Index].Length * 8)) {\r
+ if ((Address >= mMtrrLibFixedMtrrTable[Index].BaseAddress) &&\r
+ (Address < mMtrrLibFixedMtrrTable[Index].BaseAddress +\r
+ (mMtrrLibFixedMtrrTable[Index].Length * 8)))\r
+ {\r
SubIndex =\r
- ((UINTN) Address - mMtrrLibFixedMtrrTable[Index].BaseAddress) /\r
+ ((UINTN)Address - mMtrrLibFixedMtrrTable[Index].BaseAddress) /\r
mMtrrLibFixedMtrrTable[Index].Length;\r
if (MtrrSetting == NULL) {\r
FixedMtrr = AsmReadMsr64 (mMtrrLibFixedMtrrTable[Index].Msr);\r
} else {\r
FixedMtrr = MtrrSetting->Fixed.Mtrr[Index];\r
}\r
- return (MTRR_MEMORY_CACHE_TYPE) (RShiftU64 (FixedMtrr, SubIndex * 8) & 0xFF);\r
+\r
+ return (MTRR_MEMORY_CACHE_TYPE)(RShiftU64 (FixedMtrr, SubIndex * 8) & 0xFF);\r
}\r
}\r
}\r
MtrrValidBitsMask,\r
MtrrValidAddressMask,\r
VariableMtrr\r
- );\r
+ );\r
\r
//\r
// Go through the variable MTRR\r
MtrrType = CacheInvalid;\r
for (Index = 0; Index < VariableMtrrCount; Index++) {\r
if (VariableMtrr[Index].Length != 0) {\r
- if (Address >= VariableMtrr[Index].BaseAddress &&\r
- Address < VariableMtrr[Index].BaseAddress + VariableMtrr[Index].Length) {\r
+ if ((Address >= VariableMtrr[Index].BaseAddress) &&\r
+ (Address < VariableMtrr[Index].BaseAddress + VariableMtrr[Index].Length))\r
+ {\r
if (MtrrType == CacheInvalid) {\r
- MtrrType = (MTRR_MEMORY_CACHE_TYPE) VariableMtrr[Index].Type;\r
+ MtrrType = (MTRR_MEMORY_CACHE_TYPE)VariableMtrr[Index].Type;\r
} else {\r
- MtrrType = MtrrLibPrecedence (MtrrType, (MTRR_MEMORY_CACHE_TYPE) VariableMtrr[Index].Type);\r
+ MtrrType = MtrrLibPrecedence (MtrrType, (MTRR_MEMORY_CACHE_TYPE)VariableMtrr[Index].Type);\r
}\r
}\r
}\r
// If there is no MTRR which covers the Address, use the default MTRR type.\r
//\r
if (MtrrType == CacheInvalid) {\r
- MtrrType = (MTRR_MEMORY_CACHE_TYPE) DefType.Bits.Type;\r
+ MtrrType = (MTRR_MEMORY_CACHE_TYPE)DefType.Bits.Type;\r
}\r
\r
return MtrrType;\r
}\r
\r
-\r
/**\r
This function will get the memory cache type of the specific address.\r
\r
MTRR_MEMORY_CACHE_TYPE\r
EFIAPI\r
MtrrGetMemoryAttribute (\r
- IN PHYSICAL_ADDRESS Address\r
+ IN PHYSICAL_ADDRESS Address\r
)\r
{\r
if (!IsMtrrSupported ()) {\r
**/\r
RETURN_STATUS\r
MtrrLibSetMemoryType (\r
- IN MTRR_MEMORY_RANGE *Ranges,\r
- IN UINTN Capacity,\r
- IN OUT UINTN *Count,\r
- IN UINT64 BaseAddress,\r
- IN UINT64 Length,\r
- IN MTRR_MEMORY_CACHE_TYPE Type\r
+ IN MTRR_MEMORY_RANGE *Ranges,\r
+ IN UINTN Capacity,\r
+ IN OUT UINTN *Count,\r
+ IN UINT64 BaseAddress,\r
+ IN UINT64 Length,\r
+ IN MTRR_MEMORY_CACHE_TYPE Type\r
)\r
{\r
- UINTN Index;\r
- UINT64 Limit;\r
- UINT64 LengthLeft;\r
- UINT64 LengthRight;\r
- UINTN StartIndex;\r
- UINTN EndIndex;\r
- UINTN DeltaCount;\r
+ UINTN Index;\r
+ UINT64 Limit;\r
+ UINT64 LengthLeft;\r
+ UINT64 LengthRight;\r
+ UINTN StartIndex;\r
+ UINTN EndIndex;\r
+ UINTN DeltaCount;\r
\r
LengthRight = 0;\r
LengthLeft = 0;\r
- Limit = BaseAddress + Length;\r
- StartIndex = *Count;\r
- EndIndex = *Count;\r
+ Limit = BaseAddress + Length;\r
+ StartIndex = *Count;\r
+ EndIndex = *Count;\r
for (Index = 0; Index < *Count; Index++) {\r
if ((StartIndex == *Count) &&\r
(Ranges[Index].BaseAddress <= BaseAddress) &&\r
- (BaseAddress < Ranges[Index].BaseAddress + Ranges[Index].Length)) {\r
+ (BaseAddress < Ranges[Index].BaseAddress + Ranges[Index].Length))\r
+ {\r
StartIndex = Index;\r
LengthLeft = BaseAddress - Ranges[Index].BaseAddress;\r
}\r
\r
if ((EndIndex == *Count) &&\r
(Ranges[Index].BaseAddress < Limit) &&\r
- (Limit <= Ranges[Index].BaseAddress + Ranges[Index].Length)) {\r
- EndIndex = Index;\r
+ (Limit <= Ranges[Index].BaseAddress + Ranges[Index].Length))\r
+ {\r
+ EndIndex = Index;\r
LengthRight = Ranges[Index].BaseAddress + Ranges[Index].Length - Limit;\r
break;\r
}\r
}\r
\r
ASSERT (StartIndex != *Count && EndIndex != *Count);\r
- if (StartIndex == EndIndex && Ranges[StartIndex].Type == Type) {\r
+ if ((StartIndex == EndIndex) && (Ranges[StartIndex].Type == Type)) {\r
return RETURN_ALREADY_STARTED;\r
}\r
\r
// logic doesn't need to consider merging.\r
//\r
if (StartIndex != 0) {\r
- if (LengthLeft == 0 && Ranges[StartIndex - 1].Type == Type) {\r
+ if ((LengthLeft == 0) && (Ranges[StartIndex - 1].Type == Type)) {\r
StartIndex--;\r
- Length += Ranges[StartIndex].Length;\r
+ Length += Ranges[StartIndex].Length;\r
BaseAddress -= Ranges[StartIndex].Length;\r
}\r
}\r
+\r
if (EndIndex != (*Count) - 1) {\r
- if (LengthRight == 0 && Ranges[EndIndex + 1].Type == Type) {\r
+ if ((LengthRight == 0) && (Ranges[EndIndex + 1].Type == Type)) {\r
EndIndex++;\r
Length += Ranges[EndIndex].Length;\r
}\r
if (LengthLeft == 0) {\r
DeltaCount++;\r
}\r
+\r
if (LengthRight == 0) {\r
DeltaCount++;\r
}\r
+\r
if (*Count - DeltaCount > Capacity) {\r
return RETURN_OUT_OF_RESOURCES;\r
}\r
Ranges[StartIndex].Length = LengthLeft;\r
StartIndex++;\r
}\r
+\r
if (LengthRight != 0) {\r
Ranges[EndIndex - DeltaCount].BaseAddress = BaseAddress + Length;\r
- Ranges[EndIndex - DeltaCount].Length = LengthRight;\r
- Ranges[EndIndex - DeltaCount].Type = Ranges[EndIndex].Type;\r
+ Ranges[EndIndex - DeltaCount].Length = LengthRight;\r
+ Ranges[EndIndex - DeltaCount].Type = Ranges[EndIndex].Type;\r
}\r
+\r
Ranges[StartIndex].BaseAddress = BaseAddress;\r
- Ranges[StartIndex].Length = Length;\r
- Ranges[StartIndex].Type = Type;\r
+ Ranges[StartIndex].Length = Length;\r
+ Ranges[StartIndex].Type = Type;\r
return RETURN_SUCCESS;\r
}\r
\r
**/\r
UINT8\r
MtrrLibGetNumberOfTypes (\r
- IN CONST MTRR_MEMORY_RANGE *Ranges,\r
- IN UINTN RangeCount,\r
- IN UINT64 BaseAddress,\r
- IN UINT64 Length,\r
- IN OUT UINT8 *Types OPTIONAL\r
+ IN CONST MTRR_MEMORY_RANGE *Ranges,\r
+ IN UINTN RangeCount,\r
+ IN UINT64 BaseAddress,\r
+ IN UINT64 Length,\r
+ IN OUT UINT8 *Types OPTIONAL\r
)\r
{\r
- UINTN Index;\r
- UINT8 TypeCount;\r
- UINT8 LocalTypes;\r
+ UINTN Index;\r
+ UINT8 TypeCount;\r
+ UINT8 LocalTypes;\r
\r
- TypeCount = 0;\r
+ TypeCount = 0;\r
LocalTypes = 0;\r
for (Index = 0; Index < RangeCount; Index++) {\r
if ((Ranges[Index].BaseAddress <= BaseAddress) &&\r
(BaseAddress < Ranges[Index].BaseAddress + Ranges[Index].Length)\r
- ) {\r
+ )\r
+ {\r
if ((LocalTypes & (1 << Ranges[Index].Type)) == 0) {\r
LocalTypes |= (UINT8)(1 << Ranges[Index].Type);\r
TypeCount++;\r
}\r
\r
if (BaseAddress + Length > Ranges[Index].BaseAddress + Ranges[Index].Length) {\r
- Length -= Ranges[Index].BaseAddress + Ranges[Index].Length - BaseAddress;\r
+ Length -= Ranges[Index].BaseAddress + Ranges[Index].Length - BaseAddress;\r
BaseAddress = Ranges[Index].BaseAddress + Ranges[Index].Length;\r
} else {\r
break;\r
if (Types != NULL) {\r
*Types = LocalTypes;\r
}\r
+\r
return TypeCount;\r
}\r
\r
**/\r
VOID\r
MtrrLibCalculateLeastMtrrs (\r
- IN UINT16 VertexCount,\r
- IN MTRR_LIB_ADDRESS *Vertices,\r
- IN OUT CONST UINT8 *Weight,\r
- IN UINT16 Start,\r
- IN UINT16 Stop,\r
- IN BOOLEAN IncludeOptional\r
+ IN UINT16 VertexCount,\r
+ IN MTRR_LIB_ADDRESS *Vertices,\r
+ IN OUT CONST UINT8 *Weight,\r
+ IN UINT16 Start,\r
+ IN UINT16 Stop,\r
+ IN BOOLEAN IncludeOptional\r
)\r
{\r
- UINT16 Index;\r
- UINT8 MinWeight;\r
- UINT16 MinI;\r
- UINT8 Mandatory;\r
- UINT8 Optional;\r
+ UINT16 Index;\r
+ UINT8 MinWeight;\r
+ UINT16 MinI;\r
+ UINT8 Mandatory;\r
+ UINT8 Optional;\r
\r
for (Index = Start; Index <= Stop; Index++) {\r
Vertices[Index].Visited = FALSE;\r
- Mandatory = Weight[M(Start,Index)];\r
- Vertices[Index].Weight = Mandatory;\r
+ Mandatory = Weight[M (Start, Index)];\r
+ Vertices[Index].Weight = Mandatory;\r
if (Mandatory != MAX_WEIGHT) {\r
- Optional = IncludeOptional ? Weight[O(Start, Index)] : 0;\r
+ Optional = IncludeOptional ? Weight[O (Start, Index)] : 0;\r
Vertices[Index].Weight += Optional;\r
ASSERT (Vertices[Index].Weight >= Optional);\r
}\r
}\r
\r
- MinI = Start;\r
+ MinI = Start;\r
MinWeight = 0;\r
while (!Vertices[Stop].Visited) {\r
//\r
//\r
for (Index = Start + 1; Index <= Stop; Index++) {\r
if (!Vertices[Index].Visited) {\r
- Mandatory = Weight[M(MinI, Index)];\r
+ Mandatory = Weight[M (MinI, Index)];\r
if (Mandatory != MAX_WEIGHT) {\r
- Optional = IncludeOptional ? Weight[O(MinI, Index)] : 0;\r
+ Optional = IncludeOptional ? Weight[O (MinI, Index)] : 0;\r
if (MinWeight + Mandatory + Optional <= Vertices[Index].Weight) {\r
Vertices[Index].Weight = MinWeight + Mandatory + Optional;\r
Vertices[Index].Previous = MinI; // Previous is Start based.\r
MinI = VertexCount;\r
MinWeight = MAX_WEIGHT;\r
for (Index = Start + 1; Index <= Stop; Index++) {\r
- if (!Vertices[Index].Visited && MinWeight > Vertices[Index].Weight) {\r
+ if (!Vertices[Index].Visited && (MinWeight > Vertices[Index].Weight)) {\r
MinI = Index;\r
MinWeight = Vertices[Index].Weight;\r
}\r
**/\r
MTRR_MEMORY_CACHE_TYPE\r
MtrrLibLowestType (\r
- IN UINT8 TypeBits\r
-)\r
+ IN UINT8 TypeBits\r
+ )\r
{\r
- INT8 Type;\r
+ INT8 Type;\r
\r
ASSERT (TypeBits != 0);\r
- for (Type = 7; (INT8)TypeBits > 0; Type--, TypeBits <<= 1);\r
+ for (Type = 7; (INT8)TypeBits > 0; Type--, TypeBits <<= 1) {\r
+ }\r
+\r
return (MTRR_MEMORY_CACHE_TYPE)Type;\r
}\r
\r
**/\r
BOOLEAN\r
MtrrLibIsPowerOfTwo (\r
- IN UINT64 Operand\r
-)\r
+ IN UINT64 Operand\r
+ )\r
{\r
ASSERT (Operand != 0);\r
- return (BOOLEAN) ((Operand & (Operand - 1)) == 0);\r
+ return (BOOLEAN)((Operand & (Operand - 1)) == 0);\r
}\r
\r
/**\r
**/\r
RETURN_STATUS\r
MtrrLibCalculateSubtractivePath (\r
- IN MTRR_MEMORY_CACHE_TYPE DefaultType,\r
- IN UINT64 A0,\r
- IN CONST MTRR_MEMORY_RANGE *Ranges,\r
- IN UINTN RangeCount,\r
- IN UINT16 VertexCount,\r
- IN MTRR_LIB_ADDRESS *Vertices,\r
- IN OUT UINT8 *Weight,\r
- IN UINT16 Start,\r
- IN UINT16 Stop,\r
- IN UINT8 Types,\r
- IN UINT8 TypeCount,\r
- IN OUT MTRR_MEMORY_RANGE *Mtrrs OPTIONAL,\r
- IN UINT32 MtrrCapacity OPTIONAL,\r
- IN OUT UINT32 *MtrrCount OPTIONAL\r
+ IN MTRR_MEMORY_CACHE_TYPE DefaultType,\r
+ IN UINT64 A0,\r
+ IN CONST MTRR_MEMORY_RANGE *Ranges,\r
+ IN UINTN RangeCount,\r
+ IN UINT16 VertexCount,\r
+ IN MTRR_LIB_ADDRESS *Vertices,\r
+ IN OUT UINT8 *Weight,\r
+ IN UINT16 Start,\r
+ IN UINT16 Stop,\r
+ IN UINT8 Types,\r
+ IN UINT8 TypeCount,\r
+ IN OUT MTRR_MEMORY_RANGE *Mtrrs OPTIONAL,\r
+ IN UINT32 MtrrCapacity OPTIONAL,\r
+ IN OUT UINT32 *MtrrCount OPTIONAL\r
)\r
{\r
- RETURN_STATUS Status;\r
- UINT64 Base;\r
- UINT64 Length;\r
- UINT8 PrecedentTypes;\r
- UINTN Index;\r
- UINT64 HBase;\r
- UINT64 HLength;\r
- UINT64 SubLength;\r
- UINT16 SubStart;\r
- UINT16 SubStop;\r
- UINT16 Cur;\r
- UINT16 Pre;\r
- MTRR_MEMORY_CACHE_TYPE LowestType;\r
- MTRR_MEMORY_CACHE_TYPE LowestPrecedentType;\r
+ RETURN_STATUS Status;\r
+ UINT64 Base;\r
+ UINT64 Length;\r
+ UINT8 PrecedentTypes;\r
+ UINTN Index;\r
+ UINT64 HBase;\r
+ UINT64 HLength;\r
+ UINT64 SubLength;\r
+ UINT16 SubStart;\r
+ UINT16 SubStop;\r
+ UINT16 Cur;\r
+ UINT16 Pre;\r
+ MTRR_MEMORY_CACHE_TYPE LowestType;\r
+ MTRR_MEMORY_CACHE_TYPE LowestPrecedentType;\r
\r
Base = Vertices[Start].Address;\r
Length = Vertices[Stop].Address - Base;\r
//\r
// Clear the lowest type (highest bit) to get the precedent types\r
//\r
- PrecedentTypes = ~(1 << LowestType) & Types;\r
+ PrecedentTypes = ~(1 << LowestType) & Types;\r
LowestPrecedentType = MtrrLibLowestType (PrecedentTypes);\r
\r
if (Mtrrs == NULL) {\r
- Weight[M(Start, Stop)] = ((LowestType == DefaultType) ? 0 : 1);\r
- Weight[O(Start, Stop)] = ((LowestType == DefaultType) ? 1 : 0);\r
+ Weight[M (Start, Stop)] = ((LowestType == DefaultType) ? 0 : 1);\r
+ Weight[O (Start, Stop)] = ((LowestType == DefaultType) ? 1 : 0);\r
}\r
\r
// Add all high level ranges\r
- HBase = MAX_UINT64;\r
+ HBase = MAX_UINT64;\r
HLength = 0;\r
for (Index = 0; Index < RangeCount; Index++) {\r
if (Length == 0) {\r
break;\r
}\r
+\r
if ((Base < Ranges[Index].BaseAddress) || (Ranges[Index].BaseAddress + Ranges[Index].Length <= Base)) {\r
continue;\r
}\r
} else {\r
SubLength = Length;\r
}\r
+\r
if (((1 << Ranges[Index].Type) & PrecedentTypes) != 0) {\r
//\r
// Meet a range whose types take precedence.\r
if (HBase == MAX_UINT64) {\r
HBase = Base;\r
}\r
+\r
HLength += SubLength;\r
}\r
\r
- Base += SubLength;\r
+ Base += SubLength;\r
Length -= SubLength;\r
\r
if (HLength == 0) {\r
continue;\r
}\r
\r
- if ((Ranges[Index].Type == LowestType) || (Length == 0)) { // meet low type or end\r
+ if ((Ranges[Index].Type == LowestType) || (Length == 0)) {\r
+ // meet low type or end\r
\r
//\r
// Add the MTRRs for each high priority type range\r
break;\r
}\r
}\r
+\r
ASSERT (Vertices[SubStart].Address == HBase);\r
ASSERT (Vertices[SubStop].Address == HBase + HLength);\r
\r
} else {\r
while (SubStart != SubStop) {\r
Status = MtrrLibAppendVariableMtrr (\r
- Mtrrs, MtrrCapacity, MtrrCount,\r
- Vertices[SubStart].Address, Vertices[SubStart].Length, Vertices[SubStart].Type\r
- );\r
+ Mtrrs,\r
+ MtrrCapacity,\r
+ MtrrCount,\r
+ Vertices[SubStart].Address,\r
+ Vertices[SubStart].Length,\r
+ Vertices[SubStart].Type\r
+ );\r
if (RETURN_ERROR (Status)) {\r
return Status;\r
}\r
+\r
SubStart++;\r
}\r
}\r
} else {\r
// When we need to collect the optimal path from SubStart to SubStop\r
while (SubStop != SubStart) {\r
- Cur = SubStop;\r
- Pre = Vertices[Cur].Previous;\r
+ Cur = SubStop;\r
+ Pre = Vertices[Cur].Previous;\r
SubStop = Pre;\r
\r
if (Weight[M (Pre, Cur)] + Weight[O (Pre, Cur)] != 0) {\r
Status = MtrrLibAppendVariableMtrr (\r
- Mtrrs, MtrrCapacity, MtrrCount,\r
- Vertices[Pre].Address, Vertices[Cur].Address - Vertices[Pre].Address,\r
- (Pre != Cur - 1) ? LowestPrecedentType : Vertices[Pre].Type\r
- );\r
+ Mtrrs,\r
+ MtrrCapacity,\r
+ MtrrCount,\r
+ Vertices[Pre].Address,\r
+ Vertices[Cur].Address - Vertices[Pre].Address,\r
+ (Pre != Cur - 1) ? LowestPrecedentType : Vertices[Pre].Type\r
+ );\r
if (RETURN_ERROR (Status)) {\r
return Status;\r
}\r
}\r
+\r
if (Pre != Cur - 1) {\r
Status = MtrrLibCalculateSubtractivePath (\r
- DefaultType, A0,\r
- Ranges, RangeCount,\r
- VertexCount, Vertices, Weight,\r
- Pre, Cur, PrecedentTypes, 2,\r
- Mtrrs, MtrrCapacity, MtrrCount\r
- );\r
+ DefaultType,\r
+ A0,\r
+ Ranges,\r
+ RangeCount,\r
+ VertexCount,\r
+ Vertices,\r
+ Weight,\r
+ Pre,\r
+ Cur,\r
+ PrecedentTypes,\r
+ 2,\r
+ Mtrrs,\r
+ MtrrCapacity,\r
+ MtrrCount\r
+ );\r
if (RETURN_ERROR (Status)) {\r
return Status;\r
}\r
}\r
}\r
}\r
-\r
}\r
+\r
//\r
// Reset HBase, HLength\r
//\r
- HBase = MAX_UINT64;\r
+ HBase = MAX_UINT64;\r
HLength = 0;\r
}\r
}\r
+\r
return RETURN_SUCCESS;\r
}\r
\r
**/\r
RETURN_STATUS\r
MtrrLibCalculateMtrrs (\r
- IN MTRR_MEMORY_CACHE_TYPE DefaultType,\r
- IN UINT64 A0,\r
- IN CONST MTRR_MEMORY_RANGE *Ranges,\r
- IN UINTN RangeCount,\r
- IN VOID *Scratch,\r
- IN OUT UINTN *ScratchSize,\r
- IN OUT MTRR_MEMORY_RANGE *Mtrrs,\r
- IN UINT32 MtrrCapacity,\r
- IN OUT UINT32 *MtrrCount\r
+ IN MTRR_MEMORY_CACHE_TYPE DefaultType,\r
+ IN UINT64 A0,\r
+ IN CONST MTRR_MEMORY_RANGE *Ranges,\r
+ IN UINTN RangeCount,\r
+ IN VOID *Scratch,\r
+ IN OUT UINTN *ScratchSize,\r
+ IN OUT MTRR_MEMORY_RANGE *Mtrrs,\r
+ IN UINT32 MtrrCapacity,\r
+ IN OUT UINT32 *MtrrCount\r
)\r
{\r
- UINT64 Base0;\r
- UINT64 Base1;\r
- UINTN Index;\r
- UINT64 Base;\r
- UINT64 Length;\r
- UINT64 Alignment;\r
- UINT64 SubLength;\r
- MTRR_LIB_ADDRESS *Vertices;\r
- UINT8 *Weight;\r
- UINT32 VertexIndex;\r
- UINT32 VertexCount;\r
- UINTN RequiredScratchSize;\r
- UINT8 TypeCount;\r
- UINT16 Start;\r
- UINT16 Stop;\r
- UINT8 Type;\r
- RETURN_STATUS Status;\r
+ UINT64 Base0;\r
+ UINT64 Base1;\r
+ UINTN Index;\r
+ UINT64 Base;\r
+ UINT64 Length;\r
+ UINT64 Alignment;\r
+ UINT64 SubLength;\r
+ MTRR_LIB_ADDRESS *Vertices;\r
+ UINT8 *Weight;\r
+ UINT32 VertexIndex;\r
+ UINT32 VertexCount;\r
+ UINTN RequiredScratchSize;\r
+ UINT8 TypeCount;\r
+ UINT16 Start;\r
+ UINT16 Stop;\r
+ UINT8 Type;\r
+ RETURN_STATUS Status;\r
\r
Base0 = Ranges[0].BaseAddress;\r
Base1 = Ranges[RangeCount - 1].BaseAddress + Ranges[RangeCount - 1].Length;\r
//\r
// Count the number of vertices.\r
//\r
- Vertices = (MTRR_LIB_ADDRESS*)Scratch;\r
+ Vertices = (MTRR_LIB_ADDRESS *)Scratch;\r
for (VertexIndex = 0, Index = 0; Index < RangeCount; Index++) {\r
- Base = Ranges[Index].BaseAddress;\r
+ Base = Ranges[Index].BaseAddress;\r
Length = Ranges[Index].Length;\r
while (Length != 0) {\r
Alignment = MtrrLibBiggestAlignment (Base, A0);\r
if (SubLength > Length) {\r
SubLength = GetPowerOfTwo64 (Length);\r
}\r
+\r
if (VertexIndex < *ScratchSize / sizeof (*Vertices)) {\r
Vertices[VertexIndex].Address = Base;\r
Vertices[VertexIndex].Alignment = Alignment;\r
Vertices[VertexIndex].Type = Ranges[Index].Type;\r
Vertices[VertexIndex].Length = SubLength;\r
}\r
+\r
Base += SubLength;\r
Length -= SubLength;\r
VertexIndex++;\r
}\r
}\r
+\r
//\r
// Vertices[VertexIndex] = Base1, so whole vertex count is (VertexIndex + 1).\r
//\r
VertexCount = VertexIndex + 1;\r
DEBUG ((\r
- DEBUG_CACHE, " Count of vertices (%016llx - %016llx) = %d\n",\r
- Ranges[0].BaseAddress, Ranges[RangeCount - 1].BaseAddress + Ranges[RangeCount - 1].Length, VertexCount\r
+ DEBUG_CACHE,\r
+ " Count of vertices (%016llx - %016llx) = %d\n",\r
+ Ranges[0].BaseAddress,\r
+ Ranges[RangeCount - 1].BaseAddress + Ranges[RangeCount - 1].Length,\r
+ VertexCount\r
));\r
ASSERT (VertexCount < MAX_UINT16);\r
\r
*ScratchSize = RequiredScratchSize;\r
return RETURN_BUFFER_TOO_SMALL;\r
}\r
+\r
Vertices[VertexCount - 1].Address = Base1;\r
\r
- Weight = (UINT8 *) &Vertices[VertexCount];\r
+ Weight = (UINT8 *)&Vertices[VertexCount];\r
for (VertexIndex = 0; VertexIndex < VertexCount; VertexIndex++) {\r
//\r
// Set optional weight between vertices and self->self to 0\r
//\r
- SetMem (&Weight[M(VertexIndex, 0)], VertexIndex + 1, 0);\r
+ SetMem (&Weight[M (VertexIndex, 0)], VertexIndex + 1, 0);\r
//\r
// Set mandatory weight between vertices to MAX_WEIGHT\r
//\r
//\r
break;\r
}\r
- if ((Weight[M(Start, Stop)] == MAX_WEIGHT) && MtrrLibIsPowerOfTwo (Length)) {\r
+\r
+ if ((Weight[M (Start, Stop)] == MAX_WEIGHT) && MtrrLibIsPowerOfTwo (Length)) {\r
if (MtrrLibGetNumberOfTypes (\r
- Ranges, RangeCount, Vertices[Start].Address, Vertices[Stop].Address - Vertices[Start].Address, &Type\r
- ) == TypeCount) {\r
+ Ranges,\r
+ RangeCount,\r
+ Vertices[Start].Address,\r
+ Vertices[Stop].Address - Vertices[Start].Address,\r
+ &Type\r
+ ) == TypeCount)\r
+ {\r
//\r
// Update the Weight[Start, Stop] using subtractive path.\r
//\r
MtrrLibCalculateSubtractivePath (\r
- DefaultType, A0,\r
- Ranges, RangeCount,\r
- (UINT16)VertexCount, Vertices, Weight,\r
- Start, Stop, Type, TypeCount,\r
- NULL, 0, NULL\r
+ DefaultType,\r
+ A0,\r
+ Ranges,\r
+ RangeCount,\r
+ (UINT16)VertexCount,\r
+ Vertices,\r
+ Weight,\r
+ Start,\r
+ Stop,\r
+ Type,\r
+ TypeCount,\r
+ NULL,\r
+ 0,\r
+ NULL\r
);\r
} else if (TypeCount == 2) {\r
//\r
}\r
\r
Status = RETURN_SUCCESS;\r
- MtrrLibCalculateLeastMtrrs ((UINT16) VertexCount, Vertices, Weight, 0, (UINT16) VertexCount - 1, FALSE);\r
- Stop = (UINT16) VertexCount - 1;\r
+ MtrrLibCalculateLeastMtrrs ((UINT16)VertexCount, Vertices, Weight, 0, (UINT16)VertexCount - 1, FALSE);\r
+ Stop = (UINT16)VertexCount - 1;\r
while (Stop != 0) {\r
- Start = Vertices[Stop].Previous;\r
+ Start = Vertices[Stop].Previous;\r
TypeCount = MAX_UINT8;\r
- Type = 0;\r
- if (Weight[M(Start, Stop)] != 0) {\r
+ Type = 0;\r
+ if (Weight[M (Start, Stop)] != 0) {\r
TypeCount = MtrrLibGetNumberOfTypes (Ranges, RangeCount, Vertices[Start].Address, Vertices[Stop].Address - Vertices[Start].Address, &Type);\r
- Status = MtrrLibAppendVariableMtrr (\r
- Mtrrs, MtrrCapacity, MtrrCount,\r
- Vertices[Start].Address, Vertices[Stop].Address - Vertices[Start].Address,\r
- MtrrLibLowestType (Type)\r
- );\r
+ Status = MtrrLibAppendVariableMtrr (\r
+ Mtrrs,\r
+ MtrrCapacity,\r
+ MtrrCount,\r
+ Vertices[Start].Address,\r
+ Vertices[Stop].Address - Vertices[Start].Address,\r
+ MtrrLibLowestType (Type)\r
+ );\r
if (RETURN_ERROR (Status)) {\r
break;\r
}\r
//\r
if (TypeCount == MAX_UINT8) {\r
TypeCount = MtrrLibGetNumberOfTypes (\r
- Ranges, RangeCount, Vertices[Start].Address, Vertices[Stop].Address - Vertices[Start].Address, &Type\r
+ Ranges,\r
+ RangeCount,\r
+ Vertices[Start].Address,\r
+ Vertices[Stop].Address - Vertices[Start].Address,\r
+ &Type\r
);\r
}\r
+\r
Status = MtrrLibCalculateSubtractivePath (\r
- DefaultType, A0,\r
- Ranges, RangeCount,\r
- (UINT16) VertexCount, Vertices, Weight, Start, Stop,\r
- Type, TypeCount,\r
- Mtrrs, MtrrCapacity, MtrrCount\r
+ DefaultType,\r
+ A0,\r
+ Ranges,\r
+ RangeCount,\r
+ (UINT16)VertexCount,\r
+ Vertices,\r
+ Weight,\r
+ Start,\r
+ Stop,\r
+ Type,\r
+ TypeCount,\r
+ Mtrrs,\r
+ MtrrCapacity,\r
+ MtrrCount\r
);\r
if (RETURN_ERROR (Status)) {\r
break;\r
}\r
}\r
+\r
Stop = Start;\r
}\r
+\r
return Status;\r
}\r
\r
-\r
/**\r
Apply the fixed MTRR settings to memory range array.\r
\r
IN OUT UINTN *RangeCount\r
)\r
{\r
- RETURN_STATUS Status;\r
- UINTN MsrIndex;\r
- UINTN Index;\r
- MTRR_MEMORY_CACHE_TYPE MemoryType;\r
- UINT64 Base;\r
+ RETURN_STATUS Status;\r
+ UINTN MsrIndex;\r
+ UINTN Index;\r
+ MTRR_MEMORY_CACHE_TYPE MemoryType;\r
+ UINT64 Base;\r
\r
Base = 0;\r
for (MsrIndex = 0; MsrIndex < ARRAY_SIZE (mMtrrLibFixedMtrrTable); MsrIndex++) {\r
ASSERT (Base == mMtrrLibFixedMtrrTable[MsrIndex].BaseAddress);\r
for (Index = 0; Index < sizeof (UINT64); Index++) {\r
MemoryType = (MTRR_MEMORY_CACHE_TYPE)((UINT8 *)(&Fixed->Mtrr[MsrIndex]))[Index];\r
- Status = MtrrLibSetMemoryType (\r
- Ranges, RangeCapacity, RangeCount, Base, mMtrrLibFixedMtrrTable[MsrIndex].Length, MemoryType\r
- );\r
+ Status = MtrrLibSetMemoryType (\r
+ Ranges,\r
+ RangeCapacity,\r
+ RangeCount,\r
+ Base,\r
+ mMtrrLibFixedMtrrTable[MsrIndex].Length,\r
+ MemoryType\r
+ );\r
if (Status == RETURN_OUT_OF_RESOURCES) {\r
return Status;\r
}\r
+\r
Base += mMtrrLibFixedMtrrTable[MsrIndex].Length;\r
}\r
}\r
+\r
ASSERT (Base == BASE_1MB);\r
return RETURN_SUCCESS;\r
}\r
**/\r
RETURN_STATUS\r
MtrrLibApplyVariableMtrrs (\r
- IN CONST MTRR_MEMORY_RANGE *VariableMtrr,\r
- IN UINT32 VariableMtrrCount,\r
- IN OUT MTRR_MEMORY_RANGE *Ranges,\r
- IN UINTN RangeCapacity,\r
- IN OUT UINTN *RangeCount\r
+ IN CONST MTRR_MEMORY_RANGE *VariableMtrr,\r
+ IN UINT32 VariableMtrrCount,\r
+ IN OUT MTRR_MEMORY_RANGE *Ranges,\r
+ IN UINTN RangeCapacity,\r
+ IN OUT UINTN *RangeCount\r
)\r
{\r
- RETURN_STATUS Status;\r
- UINTN Index;\r
+ RETURN_STATUS Status;\r
+ UINTN Index;\r
\r
//\r
// WT > WB\r
for (Index = 0; Index < VariableMtrrCount; Index++) {\r
if ((VariableMtrr[Index].Length != 0) && (VariableMtrr[Index].Type == CacheWriteBack)) {\r
Status = MtrrLibSetMemoryType (\r
- Ranges, RangeCapacity, RangeCount,\r
- VariableMtrr[Index].BaseAddress, VariableMtrr[Index].Length, VariableMtrr[Index].Type\r
- );\r
+ Ranges,\r
+ RangeCapacity,\r
+ RangeCount,\r
+ VariableMtrr[Index].BaseAddress,\r
+ VariableMtrr[Index].Length,\r
+ VariableMtrr[Index].Type\r
+ );\r
if (Status == RETURN_OUT_OF_RESOURCES) {\r
return Status;\r
}\r
//\r
for (Index = 0; Index < VariableMtrrCount; Index++) {\r
if ((VariableMtrr[Index].Length != 0) &&\r
- (VariableMtrr[Index].Type != CacheWriteBack) && (VariableMtrr[Index].Type != CacheUncacheable)) {\r
+ (VariableMtrr[Index].Type != CacheWriteBack) && (VariableMtrr[Index].Type != CacheUncacheable))\r
+ {\r
Status = MtrrLibSetMemoryType (\r
- Ranges, RangeCapacity, RangeCount,\r
- VariableMtrr[Index].BaseAddress, VariableMtrr[Index].Length, VariableMtrr[Index].Type\r
+ Ranges,\r
+ RangeCapacity,\r
+ RangeCount,\r
+ VariableMtrr[Index].BaseAddress,\r
+ VariableMtrr[Index].Length,\r
+ VariableMtrr[Index].Type\r
);\r
if (Status == RETURN_OUT_OF_RESOURCES) {\r
return Status;\r
// 3. Set UC\r
//\r
for (Index = 0; Index < VariableMtrrCount; Index++) {\r
- if (VariableMtrr[Index].Length != 0 && VariableMtrr[Index].Type == CacheUncacheable) {\r
+ if ((VariableMtrr[Index].Length != 0) && (VariableMtrr[Index].Type == CacheUncacheable)) {\r
Status = MtrrLibSetMemoryType (\r
- Ranges, RangeCapacity, RangeCount,\r
- VariableMtrr[Index].BaseAddress, VariableMtrr[Index].Length, VariableMtrr[Index].Type\r
+ Ranges,\r
+ RangeCapacity,\r
+ RangeCount,\r
+ VariableMtrr[Index].BaseAddress,\r
+ VariableMtrr[Index].Length,\r
+ VariableMtrr[Index].Type\r
);\r
if (Status == RETURN_OUT_OF_RESOURCES) {\r
return Status;\r
}\r
}\r
}\r
+\r
return RETURN_SUCCESS;\r
}\r
\r
**/\r
UINT8\r
MtrrLibGetCompatibleTypes (\r
- IN CONST MTRR_MEMORY_RANGE *Ranges,\r
- IN UINTN RangeCount\r
+ IN CONST MTRR_MEMORY_RANGE *Ranges,\r
+ IN UINTN RangeCount\r
)\r
{\r
ASSERT (RangeCount != 0);\r
\r
switch (Ranges[0].Type) {\r
- case CacheWriteBack:\r
- case CacheWriteThrough:\r
- return (1 << CacheWriteBack) | (1 << CacheWriteThrough) | (1 << CacheUncacheable);\r
- break;\r
-\r
- case CacheWriteCombining:\r
- case CacheWriteProtected:\r
- return (1 << Ranges[0].Type) | (1 << CacheUncacheable);\r
- break;\r
-\r
- case CacheUncacheable:\r
- if (RangeCount == 1) {\r
- return (1 << CacheUncacheable);\r
- }\r
- return MtrrLibGetCompatibleTypes (&Ranges[1], RangeCount - 1);\r
- break;\r
+ case CacheWriteBack:\r
+ case CacheWriteThrough:\r
+ return (1 << CacheWriteBack) | (1 << CacheWriteThrough) | (1 << CacheUncacheable);\r
+ break;\r
+\r
+ case CacheWriteCombining:\r
+ case CacheWriteProtected:\r
+ return (1 << Ranges[0].Type) | (1 << CacheUncacheable);\r
+ break;\r
+\r
+ case CacheUncacheable:\r
+ if (RangeCount == 1) {\r
+ return (1 << CacheUncacheable);\r
+ }\r
\r
- case CacheInvalid:\r
- default:\r
- ASSERT (FALSE);\r
- break;\r
+ return MtrrLibGetCompatibleTypes (&Ranges[1], RangeCount - 1);\r
+ break;\r
+\r
+ case CacheInvalid:\r
+ default:\r
+ ASSERT (FALSE);\r
+ break;\r
}\r
+\r
return 0;\r
}\r
\r
**/\r
VOID\r
MtrrLibMergeVariableMtrr (\r
- MTRR_MEMORY_RANGE *DstMtrrs,\r
- UINT32 DstMtrrCount,\r
- MTRR_MEMORY_RANGE *SrcMtrrs,\r
- UINT32 SrcMtrrCount,\r
- BOOLEAN *Modified\r
+ MTRR_MEMORY_RANGE *DstMtrrs,\r
+ UINT32 DstMtrrCount,\r
+ MTRR_MEMORY_RANGE *SrcMtrrs,\r
+ UINT32 SrcMtrrCount,\r
+ BOOLEAN *Modified\r
)\r
{\r
- UINT32 DstIndex;\r
- UINT32 SrcIndex;\r
+ UINT32 DstIndex;\r
+ UINT32 SrcIndex;\r
\r
ASSERT (SrcMtrrCount <= DstMtrrCount);\r
\r
if (DstMtrrs[DstIndex].Length == 0) {\r
continue;\r
}\r
+\r
for (SrcIndex = 0; SrcIndex < SrcMtrrCount; SrcIndex++) {\r
- if (DstMtrrs[DstIndex].BaseAddress == SrcMtrrs[SrcIndex].BaseAddress &&\r
- DstMtrrs[DstIndex].Length == SrcMtrrs[SrcIndex].Length &&\r
- DstMtrrs[DstIndex].Type == SrcMtrrs[SrcIndex].Type) {\r
+ if ((DstMtrrs[DstIndex].BaseAddress == SrcMtrrs[SrcIndex].BaseAddress) &&\r
+ (DstMtrrs[DstIndex].Length == SrcMtrrs[SrcIndex].Length) &&\r
+ (DstMtrrs[DstIndex].Type == SrcMtrrs[SrcIndex].Type))\r
+ {\r
break;\r
}\r
}\r
// Remove the one from DstMtrrs which is not in SrcMtrrs\r
//\r
DstMtrrs[DstIndex].Length = 0;\r
- Modified[DstIndex] = TRUE;\r
+ Modified[DstIndex] = TRUE;\r
} else {\r
//\r
// Remove the one from SrcMtrrs which is also in DstMtrrs\r
DstIndex = 0;\r
for (SrcIndex = 0; SrcIndex < SrcMtrrCount; SrcIndex++) {\r
if (SrcMtrrs[SrcIndex].Length != 0) {\r
-\r
//\r
// Find the empty slot in DstMtrrs\r
//\r
if (DstMtrrs[DstIndex].Length == 0) {\r
break;\r
}\r
+\r
DstIndex++;\r
}\r
+\r
ASSERT (DstIndex < DstMtrrCount);\r
CopyMem (&DstMtrrs[DstIndex], &SrcMtrrs[SrcIndex], sizeof (SrcMtrrs[0]));\r
Modified[DstIndex] = TRUE;\r
**/\r
RETURN_STATUS\r
MtrrLibSetMemoryRanges (\r
- IN MTRR_MEMORY_CACHE_TYPE DefaultType,\r
- IN UINT64 A0,\r
- IN MTRR_MEMORY_RANGE *Ranges,\r
- IN UINTN RangeCount,\r
- IN VOID *Scratch,\r
- IN OUT UINTN *ScratchSize,\r
- OUT MTRR_MEMORY_RANGE *VariableMtrr,\r
- IN UINT32 VariableMtrrCapacity,\r
- OUT UINT32 *VariableMtrrCount\r
+ IN MTRR_MEMORY_CACHE_TYPE DefaultType,\r
+ IN UINT64 A0,\r
+ IN MTRR_MEMORY_RANGE *Ranges,\r
+ IN UINTN RangeCount,\r
+ IN VOID *Scratch,\r
+ IN OUT UINTN *ScratchSize,\r
+ OUT MTRR_MEMORY_RANGE *VariableMtrr,\r
+ IN UINT32 VariableMtrrCapacity,\r
+ OUT UINT32 *VariableMtrrCount\r
)\r
{\r
- RETURN_STATUS Status;\r
- UINT32 Index;\r
- UINT64 Base0;\r
- UINT64 Base1;\r
- UINT64 Alignment;\r
- UINT8 CompatibleTypes;\r
- UINT64 Length;\r
- UINT32 End;\r
- UINTN ActualScratchSize;\r
- UINTN BiggestScratchSize;\r
+ RETURN_STATUS Status;\r
+ UINT32 Index;\r
+ UINT64 Base0;\r
+ UINT64 Base1;\r
+ UINT64 Alignment;\r
+ UINT8 CompatibleTypes;\r
+ UINT64 Length;\r
+ UINT32 End;\r
+ UINTN ActualScratchSize;\r
+ UINTN BiggestScratchSize;\r
\r
*VariableMtrrCount = 0;\r
\r
while (Base0 + Alignment <= Ranges[Index].BaseAddress + Ranges[Index].Length) {\r
if ((BiggestScratchSize <= *ScratchSize) && (Ranges[Index].Type != DefaultType)) {\r
Status = MtrrLibAppendVariableMtrr (\r
- VariableMtrr, VariableMtrrCapacity, VariableMtrrCount,\r
- Base0, Alignment, Ranges[Index].Type\r
- );\r
+ VariableMtrr,\r
+ VariableMtrrCapacity,\r
+ VariableMtrrCount,\r
+ Base0,\r
+ Alignment,\r
+ Ranges[Index].Type\r
+ );\r
if (RETURN_ERROR (Status)) {\r
return Status;\r
}\r
}\r
- Base0 += Alignment;\r
+\r
+ Base0 += Alignment;\r
Alignment = MtrrLibBiggestAlignment (Base0, A0);\r
}\r
\r
//\r
// Remove the above range from Ranges[Index]\r
//\r
- Ranges[Index].Length -= Base0 - Ranges[Index].BaseAddress;\r
+ Ranges[Index].Length -= Base0 - Ranges[Index].BaseAddress;\r
Ranges[Index].BaseAddress = Base0;\r
if (Ranges[Index].Length != 0) {\r
break;\r
if (((1 << Ranges[End + 1].Type) & CompatibleTypes) == 0) {\r
break;\r
}\r
+\r
End++;\r
}\r
+\r
Alignment = MtrrLibBiggestAlignment (Base0, A0);\r
Length = GetPowerOfTwo64 (Ranges[End].BaseAddress + Ranges[End].Length - Base0);\r
Base1 = Base0 + MIN (Alignment, Length);\r
if (Base1 <= Ranges[End + 1].BaseAddress) {\r
break;\r
}\r
+\r
End++;\r
}\r
\r
- Length = Ranges[End].Length;\r
+ Length = Ranges[End].Length;\r
Ranges[End].Length = Base1 - Ranges[End].BaseAddress;\r
ActualScratchSize = *ScratchSize;\r
- Status = MtrrLibCalculateMtrrs (\r
- DefaultType, A0,\r
- &Ranges[Index], End + 1 - Index,\r
- Scratch, &ActualScratchSize,\r
- VariableMtrr, VariableMtrrCapacity, VariableMtrrCount\r
- );\r
+ Status = MtrrLibCalculateMtrrs (\r
+ DefaultType,\r
+ A0,\r
+ &Ranges[Index],\r
+ End + 1 - Index,\r
+ Scratch,\r
+ &ActualScratchSize,\r
+ VariableMtrr,\r
+ VariableMtrrCapacity,\r
+ VariableMtrrCount\r
+ );\r
if (Status == RETURN_BUFFER_TOO_SMALL) {\r
BiggestScratchSize = MAX (BiggestScratchSize, ActualScratchSize);\r
//\r
//\r
Status = RETURN_SUCCESS;\r
}\r
+\r
if (RETURN_ERROR (Status)) {\r
return Status;\r
}\r
\r
if (Length != Ranges[End].Length) {\r
Ranges[End].BaseAddress = Base1;\r
- Ranges[End].Length = Length - Ranges[End].Length;\r
- Index = End;\r
+ Ranges[End].Length = Length - Ranges[End].Length;\r
+ Index = End;\r
} else {\r
Index = End + 1;\r
}\r
*ScratchSize = BiggestScratchSize;\r
return RETURN_BUFFER_TOO_SMALL;\r
}\r
+\r
return RETURN_SUCCESS;\r
}\r
\r
**/\r
RETURN_STATUS\r
MtrrLibSetBelow1MBMemoryAttribute (\r
- IN OUT UINT64 *ClearMasks,\r
- IN OUT UINT64 *OrMasks,\r
- IN PHYSICAL_ADDRESS BaseAddress,\r
- IN UINT64 Length,\r
- IN MTRR_MEMORY_CACHE_TYPE Type\r
+ IN OUT UINT64 *ClearMasks,\r
+ IN OUT UINT64 *OrMasks,\r
+ IN PHYSICAL_ADDRESS BaseAddress,\r
+ IN UINT64 Length,\r
+ IN MTRR_MEMORY_CACHE_TYPE Type\r
)\r
{\r
- RETURN_STATUS Status;\r
- UINT32 MsrIndex;\r
- UINT64 ClearMask;\r
- UINT64 OrMask;\r
+ RETURN_STATUS Status;\r
+ UINT32 MsrIndex;\r
+ UINT64 ClearMask;\r
+ UINT64 OrMask;\r
\r
ASSERT (BaseAddress < BASE_1MB);\r
\r
if (RETURN_ERROR (Status)) {\r
return Status;\r
}\r
+\r
ClearMasks[MsrIndex] = ClearMasks[MsrIndex] | ClearMask;\r
OrMasks[MsrIndex] = (OrMasks[MsrIndex] & ~ClearMask) | OrMask;\r
}\r
+\r
return RETURN_SUCCESS;\r
}\r
\r
RETURN_STATUS\r
EFIAPI\r
MtrrSetMemoryAttributesInMtrrSettings (\r
- IN OUT MTRR_SETTINGS *MtrrSetting,\r
- IN VOID *Scratch,\r
- IN OUT UINTN *ScratchSize,\r
- IN CONST MTRR_MEMORY_RANGE *Ranges,\r
- IN UINTN RangeCount\r
+ IN OUT MTRR_SETTINGS *MtrrSetting,\r
+ IN VOID *Scratch,\r
+ IN OUT UINTN *ScratchSize,\r
+ IN CONST MTRR_MEMORY_RANGE *Ranges,\r
+ IN UINTN RangeCount\r
)\r
{\r
- RETURN_STATUS Status;\r
- UINT32 Index;\r
- UINT64 BaseAddress;\r
- UINT64 Length;\r
- BOOLEAN Above1MbExist;\r
-\r
- UINT64 MtrrValidBitsMask;\r
- UINT64 MtrrValidAddressMask;\r
- MTRR_MEMORY_CACHE_TYPE DefaultType;\r
- MTRR_VARIABLE_SETTINGS VariableSettings;\r
- MTRR_MEMORY_RANGE WorkingRanges[2 * ARRAY_SIZE (MtrrSetting->Variables.Mtrr) + 2];\r
- UINTN WorkingRangeCount;\r
- BOOLEAN Modified;\r
- MTRR_VARIABLE_SETTING VariableSetting;\r
- UINT32 OriginalVariableMtrrCount;\r
- UINT32 FirmwareVariableMtrrCount;\r
- UINT32 WorkingVariableMtrrCount;\r
- MTRR_MEMORY_RANGE OriginalVariableMtrr[ARRAY_SIZE (MtrrSetting->Variables.Mtrr)];\r
- MTRR_MEMORY_RANGE WorkingVariableMtrr[ARRAY_SIZE (MtrrSetting->Variables.Mtrr)];\r
- BOOLEAN VariableSettingModified[ARRAY_SIZE (MtrrSetting->Variables.Mtrr)];\r
-\r
- UINT64 ClearMasks[ARRAY_SIZE (mMtrrLibFixedMtrrTable)];\r
- UINT64 OrMasks[ARRAY_SIZE (mMtrrLibFixedMtrrTable)];\r
-\r
- MTRR_CONTEXT MtrrContext;\r
- BOOLEAN MtrrContextValid;\r
+ RETURN_STATUS Status;\r
+ UINT32 Index;\r
+ UINT64 BaseAddress;\r
+ UINT64 Length;\r
+ BOOLEAN Above1MbExist;\r
+\r
+ UINT64 MtrrValidBitsMask;\r
+ UINT64 MtrrValidAddressMask;\r
+ MTRR_MEMORY_CACHE_TYPE DefaultType;\r
+ MTRR_VARIABLE_SETTINGS VariableSettings;\r
+ MTRR_MEMORY_RANGE WorkingRanges[2 * ARRAY_SIZE (MtrrSetting->Variables.Mtrr) + 2];\r
+ UINTN WorkingRangeCount;\r
+ BOOLEAN Modified;\r
+ MTRR_VARIABLE_SETTING VariableSetting;\r
+ UINT32 OriginalVariableMtrrCount;\r
+ UINT32 FirmwareVariableMtrrCount;\r
+ UINT32 WorkingVariableMtrrCount;\r
+ MTRR_MEMORY_RANGE OriginalVariableMtrr[ARRAY_SIZE (MtrrSetting->Variables.Mtrr)];\r
+ MTRR_MEMORY_RANGE WorkingVariableMtrr[ARRAY_SIZE (MtrrSetting->Variables.Mtrr)];\r
+ BOOLEAN VariableSettingModified[ARRAY_SIZE (MtrrSetting->Variables.Mtrr)];\r
+\r
+ UINT64 ClearMasks[ARRAY_SIZE (mMtrrLibFixedMtrrTable)];\r
+ UINT64 OrMasks[ARRAY_SIZE (mMtrrLibFixedMtrrTable)];\r
+\r
+ MTRR_CONTEXT MtrrContext;\r
+ BOOLEAN MtrrContextValid;\r
\r
Status = RETURN_SUCCESS;\r
MtrrLibInitializeMtrrMask (&MtrrValidBitsMask, &MtrrValidAddressMask);\r
// 0. Dump the requests.\r
//\r
DEBUG_CODE_BEGIN ();\r
- DEBUG ((DEBUG_CACHE, "Mtrr: Set Mem Attribute to %a, ScratchSize = %x%a",\r
- (MtrrSetting == NULL) ? "Hardware" : "Buffer", *ScratchSize,\r
- (RangeCount <= 1) ? "," : "\n"\r
- ));\r
- for (Index = 0; Index < RangeCount; Index++) {\r
- DEBUG ((DEBUG_CACHE, " %a: [%016lx, %016lx)\n",\r
- mMtrrMemoryCacheTypeShortName[MIN (Ranges[Index].Type, CacheInvalid)],\r
- Ranges[Index].BaseAddress, Ranges[Index].BaseAddress + Ranges[Index].Length\r
- ));\r
- }\r
+ DEBUG ((\r
+ DEBUG_CACHE,\r
+ "Mtrr: Set Mem Attribute to %a, ScratchSize = %x%a",\r
+ (MtrrSetting == NULL) ? "Hardware" : "Buffer",\r
+ *ScratchSize,\r
+ (RangeCount <= 1) ? "," : "\n"\r
+ ));\r
+ for (Index = 0; Index < RangeCount; Index++) {\r
+ DEBUG ((\r
+ DEBUG_CACHE,\r
+ " %a: [%016lx, %016lx)\n",\r
+ mMtrrMemoryCacheTypeShortName[MIN (Ranges[Index].Type, CacheInvalid)],\r
+ Ranges[Index].BaseAddress,\r
+ Ranges[Index].BaseAddress + Ranges[Index].Length\r
+ ));\r
+ }\r
+\r
DEBUG_CODE_END ();\r
\r
//\r
Status = RETURN_INVALID_PARAMETER;\r
goto Exit;\r
}\r
+\r
if (((Ranges[Index].BaseAddress & ~MtrrValidAddressMask) != 0) ||\r
((((Ranges[Index].BaseAddress + Ranges[Index].Length) & ~MtrrValidAddressMask) != 0) &&\r
- (Ranges[Index].BaseAddress + Ranges[Index].Length) != MtrrValidBitsMask + 1)\r
- ) {\r
+ ((Ranges[Index].BaseAddress + Ranges[Index].Length) != MtrrValidBitsMask + 1))\r
+ )\r
+ {\r
//\r
// Either the BaseAddress or the Limit doesn't follow the alignment requirement.\r
// Note: It's still valid if Limit doesn't follow the alignment requirement but equals to MAX Address.\r
Status = RETURN_UNSUPPORTED;\r
goto Exit;\r
}\r
+\r
if ((Ranges[Index].Type != CacheUncacheable) &&\r
(Ranges[Index].Type != CacheWriteCombining) &&\r
(Ranges[Index].Type != CacheWriteThrough) &&\r
(Ranges[Index].Type != CacheWriteProtected) &&\r
- (Ranges[Index].Type != CacheWriteBack)) {\r
+ (Ranges[Index].Type != CacheWriteBack))\r
+ {\r
Status = RETURN_INVALID_PARAMETER;\r
goto Exit;\r
}\r
+\r
if (Ranges[Index].BaseAddress + Ranges[Index].Length > BASE_1MB) {\r
Above1MbExist = TRUE;\r
}\r
OriginalVariableMtrrCount = GetVariableMtrrCountWorker ();\r
MtrrGetVariableMtrrWorker (MtrrSetting, OriginalVariableMtrrCount, &VariableSettings);\r
MtrrLibGetRawVariableRanges (\r
- &VariableSettings, OriginalVariableMtrrCount,\r
- MtrrValidBitsMask, MtrrValidAddressMask, OriginalVariableMtrr\r
+ &VariableSettings,\r
+ OriginalVariableMtrrCount,\r
+ MtrrValidBitsMask,\r
+ MtrrValidAddressMask,\r
+ OriginalVariableMtrr\r
);\r
\r
- DefaultType = MtrrGetDefaultMemoryTypeWorker (MtrrSetting);\r
- WorkingRangeCount = 1;\r
+ DefaultType = MtrrGetDefaultMemoryTypeWorker (MtrrSetting);\r
+ WorkingRangeCount = 1;\r
WorkingRanges[0].BaseAddress = 0;\r
WorkingRanges[0].Length = MtrrValidBitsMask + 1;\r
WorkingRanges[0].Type = DefaultType;\r
\r
Status = MtrrLibApplyVariableMtrrs (\r
- OriginalVariableMtrr, OriginalVariableMtrrCount,\r
- WorkingRanges, ARRAY_SIZE (WorkingRanges), &WorkingRangeCount);\r
+ OriginalVariableMtrr,\r
+ OriginalVariableMtrrCount,\r
+ WorkingRanges,\r
+ ARRAY_SIZE (WorkingRanges),\r
+ &WorkingRangeCount\r
+ );\r
ASSERT_RETURN_ERROR (Status);\r
\r
ASSERT (OriginalVariableMtrrCount >= PcdGet32 (PcdCpuNumberOfReservedVariableMtrrs));\r
// 2.2. Force [0, 1M) to UC, so that it doesn't impact subtraction algorithm.\r
//\r
Status = MtrrLibSetMemoryType (\r
- WorkingRanges, ARRAY_SIZE (WorkingRanges), &WorkingRangeCount,\r
- 0, SIZE_1MB, CacheUncacheable\r
+ WorkingRanges,\r
+ ARRAY_SIZE (WorkingRanges),\r
+ &WorkingRangeCount,\r
+ 0,\r
+ SIZE_1MB,\r
+ CacheUncacheable\r
);\r
ASSERT (Status != RETURN_OUT_OF_RESOURCES);\r
\r
Modified = FALSE;\r
for (Index = 0; Index < RangeCount; Index++) {\r
BaseAddress = Ranges[Index].BaseAddress;\r
- Length = Ranges[Index].Length;\r
+ Length = Ranges[Index].Length;\r
if (BaseAddress < BASE_1MB) {\r
if (Length <= BASE_1MB - BaseAddress) {\r
continue;\r
}\r
- Length -= BASE_1MB - BaseAddress;\r
+\r
+ Length -= BASE_1MB - BaseAddress;\r
BaseAddress = BASE_1MB;\r
}\r
+\r
Status = MtrrLibSetMemoryType (\r
- WorkingRanges, ARRAY_SIZE (WorkingRanges), &WorkingRangeCount,\r
- BaseAddress, Length, Ranges[Index].Type\r
+ WorkingRanges,\r
+ ARRAY_SIZE (WorkingRanges),\r
+ &WorkingRangeCount,\r
+ BaseAddress,\r
+ Length,\r
+ Ranges[Index].Type\r
);\r
if (Status == RETURN_ALREADY_STARTED) {\r
Status = RETURN_SUCCESS;\r
// Buffer Too Small may be returned if the scratch buffer size is insufficient.\r
//\r
Status = MtrrLibSetMemoryRanges (\r
- DefaultType, LShiftU64 (1, (UINTN)HighBitSet64 (MtrrValidBitsMask)), WorkingRanges, WorkingRangeCount,\r
- Scratch, ScratchSize,\r
- WorkingVariableMtrr, FirmwareVariableMtrrCount + 1, &WorkingVariableMtrrCount\r
+ DefaultType,\r
+ LShiftU64 (1, (UINTN)HighBitSet64 (MtrrValidBitsMask)),\r
+ WorkingRanges,\r
+ WorkingRangeCount,\r
+ Scratch,\r
+ ScratchSize,\r
+ WorkingVariableMtrr,\r
+ FirmwareVariableMtrrCount + 1,\r
+ &WorkingVariableMtrrCount\r
);\r
if (RETURN_ERROR (Status)) {\r
goto Exit;\r
// 2.5. Remove the [0, 1MB) MTRR if it still exists (not merged with other range)\r
//\r
for (Index = 0; Index < WorkingVariableMtrrCount; Index++) {\r
- if (WorkingVariableMtrr[Index].BaseAddress == 0 && WorkingVariableMtrr[Index].Length == SIZE_1MB) {\r
+ if ((WorkingVariableMtrr[Index].BaseAddress == 0) && (WorkingVariableMtrr[Index].Length == SIZE_1MB)) {\r
ASSERT (WorkingVariableMtrr[Index].Type == CacheUncacheable);\r
WorkingVariableMtrrCount--;\r
CopyMem (\r
- &WorkingVariableMtrr[Index], &WorkingVariableMtrr[Index + 1],\r
+ &WorkingVariableMtrr[Index],\r
+ &WorkingVariableMtrr[Index + 1],\r
(WorkingVariableMtrrCount - Index) * sizeof (WorkingVariableMtrr[0])\r
);\r
break;\r
// Make sure least modification is made to OriginalVariableMtrr.\r
//\r
MtrrLibMergeVariableMtrr (\r
- OriginalVariableMtrr, OriginalVariableMtrrCount,\r
- WorkingVariableMtrr, WorkingVariableMtrrCount,\r
+ OriginalVariableMtrr,\r
+ OriginalVariableMtrrCount,\r
+ WorkingVariableMtrr,\r
+ WorkingVariableMtrrCount,\r
VariableSettingModified\r
- );\r
+ );\r
}\r
}\r
\r
}\r
\r
Status = MtrrLibSetBelow1MBMemoryAttribute (\r
- ClearMasks, OrMasks,\r
- Ranges[Index].BaseAddress, Ranges[Index].Length, Ranges[Index].Type\r
+ ClearMasks,\r
+ OrMasks,\r
+ Ranges[Index].BaseAddress,\r
+ Ranges[Index].Length,\r
+ Ranges[Index].Type\r
);\r
if (RETURN_ERROR (Status)) {\r
goto Exit;\r
MtrrLibPreMtrrChange (&MtrrContext);\r
MtrrContextValid = TRUE;\r
}\r
+\r
AsmMsrAndThenOr64 (mMtrrLibFixedMtrrTable[Index].Msr, ~ClearMasks[Index], OrMasks[Index]);\r
}\r
}\r
if (VariableSettingModified[Index]) {\r
if (OriginalVariableMtrr[Index].Length != 0) {\r
VariableSetting.Base = (OriginalVariableMtrr[Index].BaseAddress & MtrrValidAddressMask)\r
- | (UINT8)OriginalVariableMtrr[Index].Type;\r
+ | (UINT8)OriginalVariableMtrr[Index].Type;\r
VariableSetting.Mask = ((~(OriginalVariableMtrr[Index].Length - 1)) & MtrrValidAddressMask) | BIT11;\r
} else {\r
VariableSetting.Base = 0;\r
VariableSetting.Mask = 0;\r
}\r
+\r
if (MtrrSetting != NULL) {\r
CopyMem (&MtrrSetting->Variables.Mtrr[Index], &VariableSetting, sizeof (VariableSetting));\r
} else {\r
MtrrLibPreMtrrChange (&MtrrContext);\r
MtrrContextValid = TRUE;\r
}\r
+\r
AsmWriteMsr64 (\r
MSR_IA32_MTRR_PHYSBASE0 + (Index << 1),\r
VariableSetting.Base\r
- );\r
+ );\r
AsmWriteMsr64 (\r
MSR_IA32_MTRR_PHYSMASK0 + (Index << 1),\r
VariableSetting.Mask\r
- );\r
+ );\r
}\r
}\r
}\r
\r
if (MtrrSetting != NULL) {\r
- ((MSR_IA32_MTRR_DEF_TYPE_REGISTER *)&MtrrSetting->MtrrDefType)->Bits.E = 1;\r
+ ((MSR_IA32_MTRR_DEF_TYPE_REGISTER *)&MtrrSetting->MtrrDefType)->Bits.E = 1;\r
((MSR_IA32_MTRR_DEF_TYPE_REGISTER *)&MtrrSetting->MtrrDefType)->Bits.FE = 1;\r
} else {\r
if (MtrrContextValid) {\r
if (!RETURN_ERROR (Status)) {\r
MtrrDebugPrintAllMtrrsWorker (MtrrSetting);\r
}\r
+\r
return Status;\r
}\r
\r
IN MTRR_MEMORY_CACHE_TYPE Attribute\r
)\r
{\r
- UINT8 Scratch[SCRATCH_BUFFER_SIZE];\r
- UINTN ScratchSize;\r
- MTRR_MEMORY_RANGE Range;\r
+ UINT8 Scratch[SCRATCH_BUFFER_SIZE];\r
+ UINTN ScratchSize;\r
+ MTRR_MEMORY_RANGE Range;\r
\r
Range.BaseAddress = BaseAddress;\r
Range.Length = Length;\r
Range.Type = Attribute;\r
- ScratchSize = sizeof (Scratch);\r
+ ScratchSize = sizeof (Scratch);\r
return MtrrSetMemoryAttributesInMtrrSettings (MtrrSetting, Scratch, &ScratchSize, &Range, 1);\r
}\r
\r
**/\r
VOID\r
MtrrSetVariableMtrrWorker (\r
- IN MTRR_VARIABLE_SETTINGS *VariableSettings\r
+ IN MTRR_VARIABLE_SETTINGS *VariableSettings\r
)\r
{\r
UINT32 Index;\r
**/\r
VOID\r
MtrrSetFixedMtrrWorker (\r
- IN MTRR_FIXED_SETTINGS *FixedSettings\r
+ IN MTRR_FIXED_SETTINGS *FixedSettings\r
)\r
{\r
UINT32 Index;\r
\r
for (Index = 0; Index < MTRR_NUMBER_OF_FIXED_MTRR; Index++) {\r
- AsmWriteMsr64 (\r
- mMtrrLibFixedMtrrTable[Index].Msr,\r
- FixedSettings->Mtrr[Index]\r
- );\r
+ AsmWriteMsr64 (\r
+ mMtrrLibFixedMtrrTable[Index].Msr,\r
+ FixedSettings->Mtrr[Index]\r
+ );\r
}\r
}\r
\r
-\r
/**\r
This function gets the content in all MTRRs (variable and fixed)\r
\r
MTRR_SETTINGS *\r
EFIAPI\r
MtrrGetAllMtrrs (\r
- OUT MTRR_SETTINGS *MtrrSetting\r
+ OUT MTRR_SETTINGS *MtrrSetting\r
)\r
{\r
if (!IsMtrrSupported ()) {\r
return MtrrSetting;\r
}\r
\r
-\r
/**\r
This function sets all MTRRs (variable and fixed)\r
\r
MTRR_SETTINGS *\r
EFIAPI\r
MtrrSetAllMtrrs (\r
- IN MTRR_SETTINGS *MtrrSetting\r
+ IN MTRR_SETTINGS *MtrrSetting\r
)\r
{\r
MTRR_CONTEXT MtrrContext;\r
return MtrrSetting;\r
}\r
\r
-\r
/**\r
Checks if MTRR is supported.\r
\r
VOID\r
)\r
{\r
- CPUID_VERSION_INFO_EDX Edx;\r
- MSR_IA32_MTRRCAP_REGISTER MtrrCap;\r
+ CPUID_VERSION_INFO_EDX Edx;\r
+ MSR_IA32_MTRRCAP_REGISTER MtrrCap;\r
\r
//\r
// Check CPUID(1).EDX[12] for MTRR capability\r
if ((MtrrCap.Bits.VCNT == 0) || (MtrrCap.Bits.FIX == 0)) {\r
return FALSE;\r
}\r
+\r
return TRUE;\r
}\r
\r
-\r
/**\r
Worker function prints all MTRRs for debugging.\r
\r
**/\r
VOID\r
MtrrDebugPrintAllMtrrsWorker (\r
- IN MTRR_SETTINGS *MtrrSetting\r
+ IN MTRR_SETTINGS *MtrrSetting\r
)\r
{\r
DEBUG_CODE_BEGIN ();\r
- MTRR_SETTINGS LocalMtrrs;\r
- MTRR_SETTINGS *Mtrrs;\r
- UINTN Index;\r
- UINTN RangeCount;\r
- UINT64 MtrrValidBitsMask;\r
- UINT64 MtrrValidAddressMask;\r
- UINT32 VariableMtrrCount;\r
- BOOLEAN ContainVariableMtrr;\r
- MTRR_MEMORY_RANGE Ranges[\r
- ARRAY_SIZE (mMtrrLibFixedMtrrTable) * sizeof (UINT64) + 2 * ARRAY_SIZE (Mtrrs->Variables.Mtrr) + 1\r
- ];\r
- MTRR_MEMORY_RANGE RawVariableRanges[ARRAY_SIZE (Mtrrs->Variables.Mtrr)];\r
-\r
- if (!IsMtrrSupported ()) {\r
- return;\r
- }\r
+ MTRR_SETTINGS LocalMtrrs;\r
+ MTRR_SETTINGS *Mtrrs;\r
+ UINTN Index;\r
+ UINTN RangeCount;\r
+ UINT64 MtrrValidBitsMask;\r
+ UINT64 MtrrValidAddressMask;\r
+ UINT32 VariableMtrrCount;\r
+ BOOLEAN ContainVariableMtrr;\r
+ MTRR_MEMORY_RANGE Ranges[\r
+ ARRAY_SIZE (mMtrrLibFixedMtrrTable) * sizeof (UINT64) + 2 * ARRAY_SIZE (Mtrrs->Variables.Mtrr) + 1\r
+ ];\r
+ MTRR_MEMORY_RANGE RawVariableRanges[ARRAY_SIZE (Mtrrs->Variables.Mtrr)];\r
\r
- VariableMtrrCount = GetVariableMtrrCountWorker ();\r
+ if (!IsMtrrSupported ()) {\r
+ return;\r
+ }\r
\r
- if (MtrrSetting != NULL) {\r
- Mtrrs = MtrrSetting;\r
- } else {\r
- MtrrGetAllMtrrs (&LocalMtrrs);\r
- Mtrrs = &LocalMtrrs;\r
- }\r
+ VariableMtrrCount = GetVariableMtrrCountWorker ();\r
\r
- //\r
- // Dump RAW MTRR contents\r
- //\r
- DEBUG ((DEBUG_CACHE, "MTRR Settings:\n"));\r
- DEBUG ((DEBUG_CACHE, "=============\n"));\r
- DEBUG ((DEBUG_CACHE, "MTRR Default Type: %016lx\n", Mtrrs->MtrrDefType));\r
- for (Index = 0; Index < ARRAY_SIZE (mMtrrLibFixedMtrrTable); Index++) {\r
- DEBUG ((DEBUG_CACHE, "Fixed MTRR[%02d] : %016lx\n", Index, Mtrrs->Fixed.Mtrr[Index]));\r
- }\r
- ContainVariableMtrr = FALSE;\r
- for (Index = 0; Index < VariableMtrrCount; Index++) {\r
- if ((Mtrrs->Variables.Mtrr[Index].Mask & BIT11) == 0) {\r
- //\r
- // If mask is not valid, then do not display range\r
- //\r
- continue;\r
- }\r
- ContainVariableMtrr = TRUE;\r
- DEBUG ((DEBUG_CACHE, "Variable MTRR[%02d]: Base=%016lx Mask=%016lx\n",\r
- Index,\r
- Mtrrs->Variables.Mtrr[Index].Base,\r
- Mtrrs->Variables.Mtrr[Index].Mask\r
- ));\r
- }\r
- if (!ContainVariableMtrr) {\r
- DEBUG ((DEBUG_CACHE, "Variable MTRR : None.\n"));\r
+ if (MtrrSetting != NULL) {\r
+ Mtrrs = MtrrSetting;\r
+ } else {\r
+ MtrrGetAllMtrrs (&LocalMtrrs);\r
+ Mtrrs = &LocalMtrrs;\r
+ }\r
+\r
+ //\r
+ // Dump RAW MTRR contents\r
+ //\r
+ DEBUG ((DEBUG_CACHE, "MTRR Settings:\n"));\r
+ DEBUG ((DEBUG_CACHE, "=============\n"));\r
+ DEBUG ((DEBUG_CACHE, "MTRR Default Type: %016lx\n", Mtrrs->MtrrDefType));\r
+ for (Index = 0; Index < ARRAY_SIZE (mMtrrLibFixedMtrrTable); Index++) {\r
+ DEBUG ((DEBUG_CACHE, "Fixed MTRR[%02d] : %016lx\n", Index, Mtrrs->Fixed.Mtrr[Index]));\r
+ }\r
+\r
+ ContainVariableMtrr = FALSE;\r
+ for (Index = 0; Index < VariableMtrrCount; Index++) {\r
+ if ((Mtrrs->Variables.Mtrr[Index].Mask & BIT11) == 0) {\r
+ //\r
+ // If mask is not valid, then do not display range\r
+ //\r
+ continue;\r
}\r
- DEBUG((DEBUG_CACHE, "\n"));\r
\r
- //\r
- // Dump MTRR setting in ranges\r
- //\r
- DEBUG((DEBUG_CACHE, "Memory Ranges:\n"));\r
- DEBUG((DEBUG_CACHE, "====================================\n"));\r
- MtrrLibInitializeMtrrMask (&MtrrValidBitsMask, &MtrrValidAddressMask);\r
- Ranges[0].BaseAddress = 0;\r
- Ranges[0].Length = MtrrValidBitsMask + 1;\r
- Ranges[0].Type = MtrrGetDefaultMemoryTypeWorker (Mtrrs);\r
- RangeCount = 1;\r
+ ContainVariableMtrr = TRUE;\r
+ DEBUG ((\r
+ DEBUG_CACHE,\r
+ "Variable MTRR[%02d]: Base=%016lx Mask=%016lx\n",\r
+ Index,\r
+ Mtrrs->Variables.Mtrr[Index].Base,\r
+ Mtrrs->Variables.Mtrr[Index].Mask\r
+ ));\r
+ }\r
\r
- MtrrLibGetRawVariableRanges (\r
- &Mtrrs->Variables, VariableMtrrCount,\r
- MtrrValidBitsMask, MtrrValidAddressMask, RawVariableRanges\r
- );\r
- MtrrLibApplyVariableMtrrs (\r
- RawVariableRanges, VariableMtrrCount,\r
- Ranges, ARRAY_SIZE (Ranges), &RangeCount\r
- );\r
+ if (!ContainVariableMtrr) {\r
+ DEBUG ((DEBUG_CACHE, "Variable MTRR : None.\n"));\r
+ }\r
\r
- MtrrLibApplyFixedMtrrs (&Mtrrs->Fixed, Ranges, ARRAY_SIZE (Ranges), &RangeCount);\r
+ DEBUG ((DEBUG_CACHE, "\n"));\r
+\r
+ //\r
+ // Dump MTRR setting in ranges\r
+ //\r
+ DEBUG ((DEBUG_CACHE, "Memory Ranges:\n"));\r
+ DEBUG ((DEBUG_CACHE, "====================================\n"));\r
+ MtrrLibInitializeMtrrMask (&MtrrValidBitsMask, &MtrrValidAddressMask);\r
+ Ranges[0].BaseAddress = 0;\r
+ Ranges[0].Length = MtrrValidBitsMask + 1;\r
+ Ranges[0].Type = MtrrGetDefaultMemoryTypeWorker (Mtrrs);\r
+ RangeCount = 1;\r
+\r
+ MtrrLibGetRawVariableRanges (\r
+ &Mtrrs->Variables,\r
+ VariableMtrrCount,\r
+ MtrrValidBitsMask,\r
+ MtrrValidAddressMask,\r
+ RawVariableRanges\r
+ );\r
+ MtrrLibApplyVariableMtrrs (\r
+ RawVariableRanges,\r
+ VariableMtrrCount,\r
+ Ranges,\r
+ ARRAY_SIZE (Ranges),\r
+ &RangeCount\r
+ );\r
+\r
+ MtrrLibApplyFixedMtrrs (&Mtrrs->Fixed, Ranges, ARRAY_SIZE (Ranges), &RangeCount);\r
+\r
+ for (Index = 0; Index < RangeCount; Index++) {\r
+ DEBUG ((\r
+ DEBUG_CACHE,\r
+ "%a:%016lx-%016lx\n",\r
+ mMtrrMemoryCacheTypeShortName[Ranges[Index].Type],\r
+ Ranges[Index].BaseAddress,\r
+ Ranges[Index].BaseAddress + Ranges[Index].Length - 1\r
+ ));\r
+ }\r
\r
- for (Index = 0; Index < RangeCount; Index++) {\r
- DEBUG ((DEBUG_CACHE, "%a:%016lx-%016lx\n",\r
- mMtrrMemoryCacheTypeShortName[Ranges[Index].Type],\r
- Ranges[Index].BaseAddress, Ranges[Index].BaseAddress + Ranges[Index].Length - 1\r
- ));\r
- }\r
DEBUG_CODE_END ();\r
}\r
\r
projects / mirror_edk2.git / blobdiff