/**
*
* Check and enable node interleaving on all nodes.
*
* @param[in,out] *MemMainPtr - Pointer to the MEM_MAIN_DATA_BLOCK
*
* @return TRUE - No fatal error occurs.
* @return FALSE - Fatal error occurs.
*/
BOOLEAN
MemMInterleaveNodes (
IN OUT MEM_MAIN_DATA_BLOCK *MemMainPtr
)
{
UINT8 Node;
UINT8 NodeCnt;
BOOLEAN RetVal;
MEM_NB_BLOCK *NBPtr;
NBPtr = MemMainPtr->NBPtr;
NodeCnt = 0;
RetVal = TRUE;
if (NBPtr->RefPtr->EnableNodeIntlv) {
if (!MemFeatMain.MemClr (MemMainPtr)) {
PutEventLog (AGESA_WARNING, MEM_WARNING_NODE_INTERLEAVING_NOT_ENABLED, 0, 0, 0, 0, &NBPtr->MemPtr->StdHeader);
SetMemError (AGESA_WARNING, NBPtr->MCTPtr);
return FALSE;
}
MemMainPtr->mmSharedPtr->NodeIntlv.IsValid = FALSE;
MemMainPtr->mmSharedPtr->NodeIntlv.NodeIntlvSel = 0;
for (Node = 0; Node < MemMainPtr->DieCount; Node++) {
if (!NBPtr[Node].FeatPtr->CheckInterleaveNodes (&NBPtr[Node])) {
break;
}
if (NBPtr[Node].MCTPtr->NodeMemSize != 0) {
NodeCnt ++;
}
}
if ((Node == MemMainPtr->DieCount) && (NodeCnt != 0) && ((NodeCnt & (NodeCnt - 1)) == 0)) {
MemMainPtr->mmSharedPtr->NodeIntlv.NodeCnt = NodeCnt;
for (Node = 0; Node < MemMainPtr->DieCount; Node++) {
if (NBPtr[Node].MCTPtr->NodeMemSize != 0) {
NBPtr[Node].FeatPtr->InterleaveNodes (&NBPtr[Node]);
}
}
for (Node = 0; Node < MemMainPtr->DieCount; Node++) {
NBPtr[Node].SyncAddrMapToAllNodes (&NBPtr[Node]);
RetVal &= (BOOLEAN) (NBPtr[Node].MCTPtr->ErrCode < AGESA_FATAL);
}
} else {
//
// If all nodes cannot be interleaved
//
PutEventLog (AGESA_WARNING, MEM_WARNING_NODE_INTERLEAVING_NOT_ENABLED, 0, 0, 0, 0, &NBPtr->MemPtr->StdHeader);
SetMemError (AGESA_WARNING, NBPtr->MCTPtr);
}
}
return RetVal;
}
/**
*
* This function handle errors occur in memory code.
*
*
* @param[in,out] *MCTPtr - pointer to DIE_STRUCT.
* @param[in,out] DCT - DCT that needs to be handled.
* @param[in,out] ChipSelMask - Chip select mask that needs to be handled
* @param[in,out] *StdHeader - pointer to AMD_CONFIG_PARAMS
*
* @return TRUE - No fatal error occurs.
* @return FALSE - Fatal error occurs.
*/
BOOLEAN
MemErrHandle (
IN DIE_STRUCT *MCTPtr,
IN UINT8 DCT,
IN UINT16 ChipSelMask,
IN AMD_CONFIG_PARAMS *StdHeader
)
{
BOOLEAN ErrorRecovery;
BOOLEAN IgnoreErr;
DCT_STRUCT *DCTPtr;
UINT8 CurrentDCT;
LOCATE_HEAP_PTR LocHeap;
MEM_NB_BLOCK *NBPtr;
MEM_MAIN_DATA_BLOCK mmData;
DCTPtr = MCTPtr->DctData;
ErrorRecovery = TRUE;
IgnoreErr = FALSE;
IDS_OPTION_HOOK (IDS_MEM_ERROR_RECOVERY, &ErrorRecovery, StdHeader);
if (ErrorRecovery) {
if (DCT == EXCLUDE_ALL_DCT) {
// Exclude all DCTs on a node
for (CurrentDCT = 0; CurrentDCT < MCTPtr->DctCount; CurrentDCT++) {
DCTPtr[CurrentDCT].Timings.CsTestFail = DCTPtr[CurrentDCT].Timings.CsPresent;
}
} else if (ChipSelMask == EXCLUDE_ALL_CHIPSEL) {
// Exclude the specified DCT
DCTPtr[DCT].Timings.CsTestFail = DCTPtr[DCT].Timings.CsPresent;
} else {
// Exclude the chip select that has been marked out
DCTPtr[DCT].Timings.CsTestFail |= ChipSelMask & DCTPtr[DCT].Timings.CsPresent;
IDS_OPTION_HOOK (IDS_LOADCARD_ERROR_RECOVERY, &DCTPtr[DCT], StdHeader);
}
// Exclude the failed dimm to recovery from error
if (MCTPtr->NodeMemSize != 0) {
LocHeap.BufferHandle = AMD_MEM_AUTO_HANDLE;
if (HeapLocateBuffer (&LocHeap, StdHeader) == AGESA_SUCCESS) {
// NB block has already been constructed by main block.
// No need to construct it here.
NBPtr = (MEM_NB_BLOCK *)LocHeap.BufferPtr;
if (!NBPtr->SharedPtr->NodeMap[MCTPtr->NodeId].IsValid) {
// Memory map has not been calculated, no need to remap memory across node here.
// Only need to remap memory within the node.
NBPtr = &NBPtr[MCTPtr->NodeId];
NBPtr->FeatPtr->ExcludeDIMM (NBPtr);
} else {
// Need to remap memory across the whole system.
mmData.MemPtr = NBPtr->MemPtr;
mmData.mmSharedPtr = NBPtr->SharedPtr;
mmData.NBPtr = NBPtr;
mmData.TechPtr = (MEM_TECH_BLOCK *) (&NBPtr[NBPtr->MemPtr->DieCount]);
mmData.DieCount = NBPtr->MemPtr->DieCount;
if (!MemFeatMain.ExcludeDIMM (&mmData)) {
return FALSE;
}
}
}
// If allocation fails, that means the code is not running at BSP.
// Parallel training is in process.
// Remap for parallel training will be done when control returns to BSP.
}
return TRUE;
} else {
IDS_OPTION_HOOK (IDS_MEM_IGNORE_ERROR, &IgnoreErr, StdHeader);
if (IgnoreErr) {
return TRUE;
}
SetMemError (AGESA_FATAL, MCTPtr);
ASSERT(FALSE); // ErrorRecovery is FALSE
return FALSE;
}
}
/**
*
*
* This function defines the DDR3 initialization flow
* when only DDR3 DIMMs are present in the system
*
* @param[in,out] *MemMainPtr - Pointer to the MEM_MAIN_DATA_BLOCK
*
* @return AGESA_STATUS
* - AGESA_FATAL
* - AGESA_CRITICAL
* - AGESA_SUCCESS
*/
AGESA_STATUS
MemMD3FlowKV (
IN OUT MEM_MAIN_DATA_BLOCK *MemMainPtr
)
{
UINT8 Dct;
MEM_NB_BLOCK *NBPtr;
MEM_DATA_STRUCT *MemPtr;
ID_INFO CallOutIdInfo;
INT8 MemPstate;
UINT8 LowestMemPstate;
UINT8 PmuImage;
BOOLEAN ErrorRecovery;
BOOLEAN IgnoreErr;
NBPtr = &MemMainPtr->NBPtr[BSP_DIE];
MemPtr = MemMainPtr->MemPtr;
ErrorRecovery = TRUE;
IgnoreErr = FALSE;
IDS_HDT_CONSOLE (MEM_FLOW, "DDR3 Mode\n");
//----------------------------------------------------------------
// Defines DDR3 registers
//----------------------------------------------------------------
MemNInitNBRegTableD3KV (NBPtr);
//----------------------------------------------------------------
// Clock and power gate unsued channels
//----------------------------------------------------------------
MemNClockAndPowerGateUnusedDctKV (NBPtr);
//----------------------------------------------------------------
// Set DDR3 mode
//----------------------------------------------------------------
MemNSetDdrModeD3KV (NBPtr);
//----------------------------------------------------------------
// Enable PHY Calibration
//----------------------------------------------------------------
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctDimmValid != 0) {
MemNEnablePhyCalibrationKV (NBPtr);
}
}
//----------------------------------------------------------------
// Low voltage DDR3
//----------------------------------------------------------------
// Levelize DDR3 voltage based on socket, as each socket has its own voltage for dimms.
AGESA_TESTPOINT (TpProcMemLvDdr3, &(MemMainPtr->MemPtr->StdHeader));
if (!MemFeatMain.LvDDR3 (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Find the maximum speed that all DCTs are capable running at
//----------------------------------------------------------------
if (!MemTSPDGetTargetSpeed3 (NBPtr->TechPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Adjust memClkFreq based on MaxDdrRate
//----------------------------------------------------------------
MemNAdjustDdrSpeed3Unb (NBPtr);
//------------------------------------------------
// Finalize target frequency
//------------------------------------------------
if (!MemMLvDdr3PerformanceEnhFinalize (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Program DCT address map
//----------------------------------------------------------------
IDS_HDT_CONSOLE (MEM_FLOW, "DCT addr map\n");
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
IDS_HDT_CONSOLE (MEM_STATUS, "\tDct %d\n", Dct);
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctDimmValid == 0) {
MemNDisableDctKV (NBPtr);
} else {
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tCS Addr Map\n");
if (MemTSPDSetBanks3 (NBPtr->TechPtr)) {
if (MemNStitchMemoryNb (NBPtr)) {
if (NBPtr->DCTPtr->Timings.CsEnabled == 0) {
MemNDisableDctKV (NBPtr);
} else {
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tAuto Cfg\n");
MemNAutoConfigKV (NBPtr);
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tTraining Cfg\n");
MemNConfigureDctForTrainingD3KV (NBPtr);
}
}
}
}
}
IDS_OPTION_HOOK (IDS_BEFORE_DRAM_INIT, NBPtr, &(MemMainPtr->MemPtr->StdHeader));
//----------------------------------------------------------------
// Init Phy mode
//----------------------------------------------------------------
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctMemSize != 0) {
IDS_HDT_CONSOLE (MEM_STATUS, "\tDct %d\n", Dct);
// 1. Program D18F2x9C_x0002_0099_dct[3:0][PmuReset,PmuStall] = 1,1.
// 2. Program D18F2x9C_x0002_000E_dct[3:0][PhyDisable]=0. Tester_mode=0.
MemNPmuResetNb (NBPtr);
// 3. According to the type of DRAM attached, program D18F2x9C_x00FFF04A_dct[3:0][MajorMode],
// D18F2x9C_x0002_000E_dct[3:0][G5_Mode], and D18F2x9C_x0002_0098_dct[3:0][CalG5D3].
// D18F2x9C_x0[3,1:0][F,7:0]1_[F,B:0]04A_dct[3:0].
MemNSetPhyDdrModeKV (NBPtr, DRAM_TYPE_DDR3_KV);
// Work-around for CPU A0/A1, PhyReceiverPowerMode
if ((NBPtr->MCTPtr->LogicalCpuid.Revision & AMD_F15_KV_A0) != 0) {
MemNPrePhyReceiverLowPowerKV (NBPtr);
}
}
}
//----------------------------------------------------------------
// Temporary buffer for DRAM CAD Bus Configuration
//----------------------------------------------------------------
if (!MemNInitDramCadBusConfigKV (NBPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Program Mem Pstate dependent registers
//----------------------------------------------------------------
IEM_SKIP_CODE (IEM_EARLY_DCT_CONFIG) {
// PMU required M1 settings regardless Memory Pstate disabled.
LowestMemPstate = 1;
}
for (MemPstate = LowestMemPstate; MemPstate >= 0; MemPstate--) {
// When memory pstate is enabled, this loop will goes through M1 first then M0
// Otherwise, this loop only goes through M0.
MemNSwitchMemPstateKV (NBPtr, MemPstate);
// By default, start up speed is DDR667 for M1
// For M0, we need to set speed to highest possible frequency
if (MemPstate == 0) {
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
NBPtr->DCTPtr->Timings.Speed = NBPtr->DCTPtr->Timings.TargetSpeed;
}
}
IDS_HDT_CONSOLE (MEM_FLOW, "MemClkFreq = %d MHz\n", NBPtr->DCTPtr->Timings.Speed);
// Program SPD timings and frequency dependent settings
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
IDS_HDT_CONSOLE (MEM_STATUS, "\tDct %d\n", Dct);
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctMemSize != 0) {
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tSPD timings\n");
if (MemTAutoCycTiming3 (NBPtr->TechPtr)) {
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tMemPs Reg\n");
MemNProgramMemPstateRegD3KV (NBPtr, MemPstate);
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tPlatform Spec\n");
if (MemNPlatformSpecKV (NBPtr)) {
MemNSetBitFieldNb (NBPtr, BFMemClkDis, 0);
// 7. Program default CAD bus values.
// 8. Program default data bus values.
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tCAD Data Bus Cfg\n");
MemNProgramCadDataBusD3KV (NBPtr);
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tPredriver\n");
MemNPredriverInitKV (NBPtr);
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tMode Register initialization\n");
MemNModeRegisterInitializationKV (NBPtr);
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tDRAM PHY Power Savings\n");
MemNDramPhyPowerSavingsKV (NBPtr);
}
}
}
}
MemFInitTableDrive (NBPtr, MTBeforeDInit);
}
//----------------------------------------------------------------
// Program Phy
//----------------------------------------------------------------
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctMemSize != 0) {
IDS_HDT_CONSOLE (MEM_STATUS, "\tDct %d\n", Dct);
// 4. Program general phy static configuration. See 2.10.7.3.1.
MemNPhyGenCfgKV (NBPtr);
// 5. Phy Voltage Level Programming. See 2.10.7.3.2.
MemNPhyVoltageLevelKV (NBPtr);
// 6. Program DRAM channel frequency. See 2.10.7.3.3.
MemNProgramChannelFreqKV (NBPtr, DRAM_TYPE_DDR3_KV);
// Step 7 and 8 are done in MemPs dependent section
// 9. Program FIFO pointer init values. See 2.10.7.3.6.
MemNPhyFifoConfigD3KV (NBPtr);
}
}
IEM_INSERT_CODE (IEM_EARLY_DEVICE_INIT, IemEarlyDeviceInitD3KV, (NBPtr));
//------------------------------------------------
// Callout before Dram Init
//------------------------------------------------
AGESA_TESTPOINT (TpProcMemBeforeAgesaHookBeforeDramInit, &(MemMainPtr->MemPtr->StdHeader));
CallOutIdInfo.IdField.SocketId = NBPtr->MCTPtr->SocketId;
CallOutIdInfo.IdField.ModuleId = NBPtr->MCTPtr->DieId;
//------------------------------------------------------------------------
// Callout to Platform BIOS to set the VDDP/VDDR voltage based upon Bit 21
// ProductIdentification Register (Dev18Fun3x1FC)
//------------------------------------------------------------------------
if (MemNGetBitFieldNb (NBPtr, BFVddpVddrLowVoltSupp)) {
MemMainPtr->MemPtr->ParameterListPtr->VddpVddrVoltage.Voltage = VOLT0_95;
MemMainPtr->MemPtr->ParameterListPtr->VddpVddrVoltage.IsValid = TRUE;
NBPtr->DCTPtr->Timings.TargetSpeed = DDR1600_FREQUENCY;
} else {
MemMainPtr->MemPtr->ParameterListPtr->VddpVddrVoltage.IsValid = FALSE;
}
IDS_HDT_CONSOLE (MEM_FLOW, "\nCalling out to Platform BIOS on Socket %d, Module %d...\n", CallOutIdInfo.IdField.SocketId, CallOutIdInfo.IdField.ModuleId);
AgesaHookBeforeDramInit ((UINTN) CallOutIdInfo.IdInformation, MemMainPtr->MemPtr);
NBPtr[BSP_DIE].FamilySpecificHook[AmpVoltageDisp] (&NBPtr[BSP_DIE], NULL);
IDS_HDT_CONSOLE (MEM_FLOW, "\nVDDIO = 1.%dV\n", (NBPtr->RefPtr->DDR3Voltage == VOLT1_5) ? 5 :
(NBPtr->RefPtr->DDR3Voltage == VOLT1_35) ? 35 :
(NBPtr->RefPtr->DDR3Voltage == VOLT1_25) ? 25 : 999);
AGESA_TESTPOINT (TpProcMemAfterAgesaHookBeforeDramInit, &(NBPtr->MemPtr->StdHeader));
//----------------------------------------------------------------------------
// Deassert MemResetL
//----------------------------------------------------------------------------
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctMemSize != 0) {
// Deassert Procedure:
// MemResetL = 0
// Go to LP2
// Go to PS0
MemNSetBitFieldNb (NBPtr, BFMemResetL, 0);
MemNSetBitFieldNb (NBPtr, RegPwrStateCmd, 4);
MemNSetBitFieldNb (NBPtr, RegPwrStateCmd, 0);
}
}
MemUWait10ns (20000, NBPtr->MemPtr);
//----------------------------------------------------------------------------
// Program PMU SRAM Message Block, Initiate PMU based Dram init and training
//----------------------------------------------------------------------------
for (PmuImage = 0; PmuImage < MemNNumberOfPmuFirmwareImageKV (NBPtr); ++PmuImage) {
NBPtr->PmuFirmwareImage = PmuImage;
NBPtr->FeatPtr->LoadPmuFirmware (NBPtr);
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctMemSize != 0) {
IDS_HDT_CONSOLE (MEM_STATUS, "Dct %d\n", Dct);
IDS_HDT_CONSOLE (MEM_FLOW, "Initialize the PMU SRAM Message Block buffer\n");
if (MemNInitPmuSramMsgBlockKV (NBPtr) == FALSE) {
IDS_HDT_CONSOLE (MEM_FLOW, "\tNot able to initialize the PMU SRAM Message Block buffer\n");
// Not able to initialize the PMU SRAM Message Block buffer. Log an event.
PutEventLog (AGESA_FATAL, MEM_ERROR_HEAP_ALLOCATE_FOR_PMU_SRAM_MSG_BLOCK, 0, 0, 0, 0, &(MemMainPtr->MemPtr->StdHeader));
return AGESA_FATAL;
}
for (MemPstate = LowestMemPstate; MemPstate >= 0; MemPstate--) {
// When memory pstate is enabled, this loop will goes through M1 first then M0
// Otherwise, this loop only goes through M0.
MemNSwitchMemPstateKV (NBPtr, MemPstate);
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tPMU MemPs Reg\n");
MemNPopulatePmuSramTimingsD3KV (NBPtr);
}
MemNPopulatePmuSramConfigD3KV (NBPtr);
MemNSetPmuSequenceControlKV (NBPtr);
if (MemNWritePmuSramMsgBlockKV (NBPtr) == FALSE) {
IDS_HDT_CONSOLE (MEM_FLOW, "\tNot able to load the PMU SRAM Message Block in to DMEM\n");
// Not able to load the PMU SRAM Message Block in to DMEM. Log an event.
PutEventLog (AGESA_FATAL, MEM_ERROR_HEAP_LOCATE_FOR_PMU_SRAM_MSG_BLOCK, 0, 0, 0, 0, &(MemMainPtr->MemPtr->StdHeader));
return AGESA_FATAL;
}
// Query for the calibrate completion.
MemNPendOnPhyCalibrateCompletionKV (NBPtr);
// Set calibration rate.
MemNStartPmuNb (NBPtr);
}
}
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctMemSize != 0) {
IDS_HDT_CONSOLE (MEM_STATUS, "\tDct %d\n", Dct);
if (MemNPendOnPmuCompletionNb (NBPtr) == FALSE) {
PutEventLog (AGESA_FATAL, MEM_ERROR_PMU_TRAINING, 0, 0, 0, 0, &(MemMainPtr->MemPtr->StdHeader));
AGESA_TESTPOINT (TpProcMemPmuFailed, &(MemMainPtr->MemPtr->StdHeader));
IDS_OPTION_HOOK (IDS_MEM_ERROR_RECOVERY, &ErrorRecovery, &(MemMainPtr->MemPtr->StdHeader));
if (ErrorRecovery) {
IDS_HDT_CONSOLE (MEM_FLOW, "Chipselects that PMU failed training %x\n",MemNGetBitFieldNb (NBPtr, PmuTestFail));
NBPtr->DCTPtr->Timings.CsTrainFail = (UINT16) MemNGetBitFieldNb (NBPtr, PmuTestFail);
NBPtr->MCTPtr->ChannelTrainFail |= (UINT32)1 << Dct;
} else {
IDS_OPTION_HOOK (IDS_MEM_IGNORE_ERROR, &IgnoreErr, &(MemMainPtr->MemPtr->StdHeader));
if (!(IgnoreErr)) {
return AGESA_FATAL;
}
}
}
MemNRateOfPhyCalibrateKV (NBPtr);
}
}
}
//----------------------------------------------------------------
// De-allocate the PMU SRAM Message Block buffer.
//----------------------------------------------------------------
IDS_HDT_CONSOLE (MEM_FLOW, "De-allocate PMU SRAM Message Block buffer\n");
if (MemNPostPmuSramMsgBlockKV (NBPtr) == FALSE) {
IDS_HDT_CONSOLE (MEM_FLOW, "\tNot able to free the PMU SRAM Message Block buffer\n");
// Not able to free the PMU SRAM Message Block buffer. Log an event.
PutEventLog (AGESA_FATAL, MEM_ERROR_HEAP_DEALLOCATE_FOR_PMU_SRAM_MSG_BLOCK, 0, 0, 0, 0, &(MemMainPtr->MemPtr->StdHeader));
return AGESA_FATAL;
}
//----------------------------------------------------------------
// De-allocate temporary buffer for DRAM CAD Bus Configuration
//----------------------------------------------------------------
if (!MemNPostDramCadBusConfigKV (NBPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Disable chipselects that failed training
//----------------------------------------------------------------
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tDIMM Excludes\n");
MemNDimmExcludesKV (NBPtr);
//----------------------------------------------------------------
// Synchronize Channels
//----------------------------------------------------------------
MemNSyncChannelInitKV (NBPtr);
//----------------------------------------------------------------
// Train MaxRdLatency
//----------------------------------------------------------------
IEM_SKIP_CODE (IEM_LATE_DCT_CONFIG) {
NBPtr->TechPtr->FindMaxDlyForMaxRdLat = MemTFindMaxRcvrEnDlyTrainedByPmuByte;
NBPtr->TechPtr->ResetDCTWrPtr = MemNResetRcvFifoKV;
MemTTrainMaxLatency (NBPtr->TechPtr);
// The fourth loop will restore the Northbridge P-State control register
// to the original value.
for (NBPtr->NbFreqChgState = 1; NBPtr->NbFreqChgState <= 4; NBPtr->NbFreqChgState++) {
if (!MemNChangeNbFrequencyWrapUnb (NBPtr, NBPtr->NbFreqChgState) || (NBPtr->NbFreqChgState == 4)) {
break;
}
MemTTrainMaxLatency (NBPtr->TechPtr);
}
}
//----------------------------------------------------------------
// Set MajorMode
//----------------------------------------------------------------
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
// Work-around for CPU A0/A1, PhyReceiverPowerMode
if ((NBPtr->MCTPtr->LogicalCpuid.Revision & AMD_F15_KV_A0) != 0) {
MemNPostPhyReceiverLowPowerKV (NBPtr);
}
}
//----------------------------------------------------------------
// Configure DCT for normal operation
//----------------------------------------------------------------
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctMemSize != 0) {
IDS_HDT_CONSOLE (MEM_STATUS, "\tDct %d\n", Dct);
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tMission mode cfg\n");
MemNConfigureDctNormalD3KV (NBPtr);
//----------------------------------------------------------------
// Program turnaround timings
//----------------------------------------------------------------
for (MemPstate = LowestMemPstate; MemPstate >= 0; MemPstate--) {
MemNSwitchMemPstateKV (NBPtr, MemPstate);
MemNProgramTurnaroundTimingsD3KV (NBPtr);
//----------------------------------------------------------------
// After Mem Pstate1 Partial Training Table values
//----------------------------------------------------------------
MemFInitTableDrive (NBPtr, MTAfterMemPstate1PartialTrn);
}
}
}
IEM_INSERT_CODE (IEM_LATE_DCT_CONFIG, IemLateDctConfigD3KV, (NBPtr));
for (Dct = 0; Dct < NBPtr->DctCount; Dct++) {
MemNSwitchDCTNb (NBPtr, Dct);
if (NBPtr->DCTPtr->Timings.DctMemSize != 0) {
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tAdditional DRAM PHY Power Savings\n");
MemNAddlDramPhyPowerSavingsKV (NBPtr);
}
}
//----------------------------------------------------------------
// Initialize Channels interleave address bit.
//----------------------------------------------------------------
MemNInitChannelIntlvAddressBitKV (NBPtr);
//----------------------------------------------------------------
// Assign physical address ranges for DCTs and node. Also, enable channel interleaving.
//----------------------------------------------------------------
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tHT mem map\n");
if (!NBPtr->FeatPtr->InterleaveChannels (NBPtr)) {
MemNHtMemMapKV (NBPtr);
}
//----------------------------------------------------
// If there is no dimm on the system, do fatal exit
//----------------------------------------------------
if (NBPtr->RefPtr->SysLimit == 0) {
PutEventLog (AGESA_FATAL, MEM_ERROR_NO_DIMM_FOUND_ON_SYSTEM, 0, 0, 0, 0, &(MemMainPtr->MemPtr->StdHeader));
return AGESA_FATAL;
}
//----------------------------------------------------------------
// CpuMemTyping
//----------------------------------------------------------------
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tMem typing\n");
MemNCPUMemTypingNb (NBPtr);
IDS_OPTION_HOOK (IDS_BEFORE_DQS_TRAINING, MemMainPtr, &(MemMainPtr->MemPtr->StdHeader));
//----------------------------------------------------------------
// After Training Table values
//----------------------------------------------------------------
MemFInitTableDrive (NBPtr, MTAfterTrn);
//----------------------------------------------------------------
// Interleave banks
//----------------------------------------------------------------
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tBank Intlv\n");
if (NBPtr->FeatPtr->InterleaveBanks (NBPtr)) {
if (NBPtr->MCTPtr->ErrCode == AGESA_FATAL) {
return AGESA_FATAL;
}
}
//----------------------------------------------------------------
// After Programming Interleave registers
//----------------------------------------------------------------
MemFInitTableDrive (NBPtr, MTAfterInterleave);
//----------------------------------------------------------------
// Memory Clear
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemMemClr, &(MemMainPtr->MemPtr->StdHeader));
if (!MemFeatMain.MemClr (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// ECC
//----------------------------------------------------------------
if (!MemFeatMain.InitEcc (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// C6 and ACP Engine Storage Allocation
//----------------------------------------------------------------
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tC6 and ACP Engine Storage\n");
MemNAllocateC6AndAcpEngineStorageKV (NBPtr);
//----------------------------------------------------------------
// UMA Allocation & UMAMemTyping
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemUMAMemTyping, &(MemMainPtr->MemPtr->StdHeader));
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tUMA Alloc\n");
if (!MemFeatMain.UmaAllocation (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// OnDimm Thermal
//----------------------------------------------------------------
if (NBPtr->FeatPtr->OnDimmThermal (NBPtr)) {
if (NBPtr->MCTPtr->ErrCode == AGESA_FATAL) {
return AGESA_FATAL;
}
}
//----------------------------------------------------------------
// Finalize MCT
//----------------------------------------------------------------
MemNFinalizeMctKV (NBPtr);
MemFInitTableDrive (NBPtr, MTAfterFinalizeMCT);
//----------------------------------------------------------------
// Memory Context Save
//----------------------------------------------------------------
MemFeatMain.MemSave (MemMainPtr);
//----------------------------------------------------------------
// Memory DMI support
//----------------------------------------------------------------
if (!MemFeatMain.MemDmi (MemMainPtr)) {
return AGESA_CRITICAL;
}
//----------------------------------------------------------------
// Memory CRAT support
//----------------------------------------------------------------
if (!MemFeatMain.MemCrat (MemMainPtr)) {
return AGESA_CRITICAL;
}
//----------------------------------------------------------------
// Save memory S3 data
//----------------------------------------------------------------
IDS_HDT_CONSOLE (MEM_FLOW, "\t\tS3 Save\n");
if (!MemMS3Save (MemMainPtr)) {
return AGESA_CRITICAL;
}
//----------------------------------------------------------------
// Switch back to DCT 0 before sending control back
//----------------------------------------------------------------
MemNSwitchDCTNb (NBPtr, 0);
return AGESA_SUCCESS;
}
/**
*
*
* This function defines the memory initialization flow for
* systems that only support RB processors.
*
* @param[in,out] *MemMainPtr - Pointer to the MEM_MAIN_DATA_BLOCK
*
* @return AGESA_STATUS
* - AGESA_ALERT
* - AGESA_FATAL
* - AGESA_SUCCESS
* - AGESA_WARNING
*/
AGESA_STATUS
MemMFlowDA (
IN OUT MEM_MAIN_DATA_BLOCK *MemMainPtr
)
{
UINT8 Node;
UINT8 NodeCnt;
MEM_NB_BLOCK *NBPtr;
MEM_TECH_BLOCK *TechPtr;
NBPtr = MemMainPtr->NBPtr;
TechPtr = MemMainPtr->TechPtr;
NodeCnt = MemMainPtr->DieCount;
//----------------------------------------------------------------
// Initialize MCT
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemInitializeMCT, &(MemMainPtr->MemPtr->StdHeader));
for (Node = 0; Node < NodeCnt; Node++) {
if (!NBPtr[Node].InitializeMCT (&NBPtr[Node])) {
return AGESA_FATAL;
}
}
//----------------------------------------------------------------
// Low voltage DDR3
//----------------------------------------------------------------
// Levelize DDR3 voltage based on socket, as each socket has its own voltage for dimms.
AGESA_TESTPOINT (TpProcMemLvDdr3, &(MemMainPtr->MemPtr->StdHeader));
if (!MemFeatMain.LvDDR3 (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Initialize DRAM and DCTs, and Create Memory Map
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemInitMCT, &(MemMainPtr->MemPtr->StdHeader));
for (Node = 0; Node < NodeCnt; Node++) {
// Initialize Memory Controller and Dram
IDS_HDT_CONSOLE ("!Node %d\n", Node);
if (!NBPtr[Node].InitMCT (&NBPtr[Node])) {
return AGESA_FATAL; // fatalexit
}
// Create memory map
AGESA_TESTPOINT (TpProcMemSystemMemoryMapping, &(MemMainPtr->MemPtr->StdHeader));
if (!NBPtr[Node].HtMemMapInit (&NBPtr[Node])) {
return AGESA_FATAL;
}
}
//----------------------------------------------------
// If there is no dimm on the system, do fatal exit
//----------------------------------------------------
if (NBPtr[BSP_DIE].RefPtr->SysLimit == 0) {
PutEventLog (AGESA_FATAL, MEM_ERROR_NO_DIMM_FOUND_ON_SYSTEM, 0, 0, 0, 0, &(MemMainPtr->MemPtr->StdHeader));
ASSERT (FALSE);
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Synchronize DCTs
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemSynchronizeDcts, &(MemMainPtr->MemPtr->StdHeader));
for (Node = 0; Node < NodeCnt; Node++) {
if (!NBPtr[Node].SyncDctsReady (&NBPtr[Node])) {
return AGESA_FATAL;
}
}
//----------------------------------------------------------------
// CpuMemTyping
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemMtrrConfiguration, &(MemMainPtr->MemPtr->StdHeader));
if (!NBPtr[BSP_DIE].CpuMemTyping (&NBPtr[BSP_DIE])) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Before Training Table values
//----------------------------------------------------------------
for (Node = 0; Node < NodeCnt; Node++) {
MemFInitTableDrive (&NBPtr[Node], MTBeforeTrn);
}
//----------------------------------------------------------------
// Memory Context Restore
//----------------------------------------------------------------
if (!MemFeatMain.MemRestore (MemMainPtr)) {
// Do DQS training only if memory context restore fails
//----------------------------------------------------------------
// Training
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemDramTraining, &(MemMainPtr->MemPtr->StdHeader));
IDS_OPTION_HOOK (IDS_BEFORE_DQS_TRAINING, MemMainPtr, &(MemMainPtr->MemPtr->StdHeader));
MemMainPtr->mmSharedPtr->DimmExcludeFlag = TRAINING;
if (!MemFeatMain.Training (MemMainPtr)) {
return AGESA_FATAL;
}
IDS_HDT_CONSOLE ("\nEnd DQS training\n\n");
}
//----------------------------------------------------------------
// Disable chipselects that fail training
//----------------------------------------------------------------
MemMainPtr->mmSharedPtr->DimmExcludeFlag = END_TRAINING;
MemFeatMain.ExcludeDIMM (MemMainPtr);
MemMainPtr->mmSharedPtr->DimmExcludeFlag = NORMAL;
//----------------------------------------------------------------
// OtherTiming
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemOtherTiming, &(MemMainPtr->MemPtr->StdHeader));
for (Node = 0; Node < NodeCnt; Node++) {
if (!NBPtr[Node].OtherTiming (&NBPtr[Node])) {
return AGESA_FATAL;
}
}
//----------------------------------------------------------------
// After Training Table values
//----------------------------------------------------------------
for (Node = 0; Node < NodeCnt; Node++) {
MemFInitTableDrive (&NBPtr[Node], MTAfterTrn);
}
//----------------------------------------------------------------
// SetDqsEccTimings
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemSetDqsEccTmgs, &(MemMainPtr->MemPtr->StdHeader));
for (Node = 0; Node < NodeCnt; Node++) {
if (!TechPtr[Node].SetDqsEccTmgs (&TechPtr[Node])) {
return AGESA_FATAL;
}
}
//----------------------------------------------------------------
// Online Spare
//----------------------------------------------------------------
if (!MemFeatMain.OnlineSpare (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Interleave banks
//----------------------------------------------------------------
for (Node = 0; Node < NodeCnt; Node++) {
if (NBPtr[Node].FeatPtr->InterleaveBanks (&NBPtr[Node])) {
if (NBPtr[Node].MCTPtr->ErrCode == AGESA_FATAL) {
return AGESA_FATAL;
}
}
}
//----------------------------------------------------------------
// Interleave Nodes
//----------------------------------------------------------------
if (!MemFeatMain.InterleaveNodes (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Interleave channels
//----------------------------------------------------------------
for (Node = 0; Node < NodeCnt; Node++) {
if (NBPtr[Node].FeatPtr->InterleaveChannels (&NBPtr[Node])) {
if (NBPtr[Node].MCTPtr->ErrCode == AGESA_FATAL) {
return AGESA_FATAL;
}
}
}
//----------------------------------------------------------------
// UMA Allocation & UMAMemTyping
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemUMAMemTyping, &(MemMainPtr->MemPtr->StdHeader));
if (!MemFeatMain.UmaAllocation (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Interleave region
//----------------------------------------------------------------
NBPtr[BSP_DIE].FeatPtr->InterleaveRegion (&NBPtr[BSP_DIE]);
//----------------------------------------------------------------
// ECC
//----------------------------------------------------------------
if (!MemFeatMain.InitEcc (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// Memory Clear
//----------------------------------------------------------------
AGESA_TESTPOINT (TpProcMemMemClr, &(MemMainPtr->MemPtr->StdHeader));
if (!MemFeatMain.MemClr (MemMainPtr)) {
return AGESA_FATAL;
}
//----------------------------------------------------------------
// OnDimm Thermal
//----------------------------------------------------------------
for (Node = 0; Node < NodeCnt; Node++) {
if (NBPtr[Node].FeatPtr->OnDimmThermal (&NBPtr[Node])) {
if (NBPtr[Node].MCTPtr->ErrCode == AGESA_FATAL) {
return AGESA_FATAL;
}
}
}
//----------------------------------------------------------------
// Finalize MCT
//----------------------------------------------------------------
for (Node = 0; Node < NodeCnt; Node++) {
if (!NBPtr[Node].FinalizeMCT (&NBPtr[Node])) {
return AGESA_FATAL;
}
}
//----------------------------------------------------------------
// Memory Context Save
//----------------------------------------------------------------
MemFeatMain.MemSave (MemMainPtr);
//----------------------------------------------------------------
// Memory DMI support
//----------------------------------------------------------------
if (!MemFeatMain.MemDmi (MemMainPtr)) {
return AGESA_CRITICAL;
}
return AGESA_SUCCESS;
}
/**
*
* MemM2DTrainingWithAggressor
*
* This function implements standard memory training whereby training functions
* for all nodes are run by the BSP while enabling other dies to eable argressor channel
*
*
* @param[in,out] *mmPtr - Pointer to the MEM_MAIN_DATA_BLOCK
*
* @return TRUE - No fatal error occurs.
* @return FALSE - Fatal error occurs.
*/
BOOLEAN
MemM2DTrainingWithAggressor (
IN OUT MEM_MAIN_DATA_BLOCK *mmPtr
)
{
UINT8 Die;
UINT8 Index;
//
// If training is disabled, return success.
//
if (!UserOptions.CfgDqsTrainingControl) {
return TRUE;
}
mmPtr->mmSharedPtr->CommonSmallestMaxNegVref = 0x7F;
mmPtr->mmSharedPtr->CommonSmallestMaxPosVref = 0x7F;
//
// Run Northbridge-specific Standard Training feature for each die.
//
IDS_HDT_CONSOLE (MEM_STATUS, "\nStart standard serial training\n");
for (Die = 0 ; Die < mmPtr->DieCount ; Die ++ ) {
IDS_HDT_CONSOLE (MEM_STATUS, "Node %d\n", Die);
AGESA_TESTPOINT (TpProcMemBeforeAnyTraining, &(mmPtr->MemPtr->StdHeader));
mmPtr->NBPtr[Die].BeforeDqsTraining (&mmPtr->NBPtr[Die]);
mmPtr->NBPtr[Die].Execute1dMaxRdLatTraining = FALSE;
mmPtr->NBPtr[Die].FeatPtr->Training (&mmPtr->NBPtr[Die]);
if (mmPtr->NBPtr[Die].MCTPtr->ErrCode == AGESA_FATAL) {
break;
}
}
//----------------------------------------------------------------
// Determine Aggressor Chipselects for all DCTs on all nodes.
//----------------------------------------------------------------
MemFeatMain.AggressorDetermination (mmPtr);
IDS_HDT_CONSOLE (MEM_STATUS, "\nStart 2D training with agressors run independently\n");
for (Die = 0 ; Die < mmPtr->DieCount ; Die ++ ) {
IDS_HDT_CONSOLE (MEM_STATUS, "Node %d\n", Die);
AGESA_TESTPOINT (TpProcMemBeforeAnyTraining, &(mmPtr->MemPtr->StdHeader));
if (mmPtr->NBPtr[Die].MCTPtr->NodeMemSize != 0) {
//Execute Technology specific 2D training features
Index = 0;
while (memTrainSequenceDDR3[Index].TrainingSequenceEnabled != 0) {
if (memTrainSequenceDDR3[Index].TrainingSequenceEnabled (&mmPtr->NBPtr[Die])) {
mmPtr->NBPtr[Die].TrainingSequenceIndex = Index;
// Execute 2D RdDqs Training
memTrainSequenceDDR3[Index].MemTechFeatBlock->RdDqs2DTraining (mmPtr->NBPtr[Die].TechPtr);
// Execute MaxRdLat Training After 2D training
do {
if (memTrainSequenceDDR3[Index].MemTechFeatBlock->MaxRdLatencyTraining (mmPtr->NBPtr[Die].TechPtr)) {
MemFInitTableDrive (&mmPtr->NBPtr[Die], MTAfterMaxRdLatTrn);
}
} while (mmPtr->NBPtr->ChangeNbFrequency (&mmPtr->NBPtr[Die]));
break;
}
Index++;
}
}
mmPtr->NBPtr[Die].TechPtr->TechnologySpecificHook[LrdimmSyncTrainedDlys] (mmPtr->NBPtr[Die].TechPtr, NULL);
mmPtr->NBPtr[Die].AfterDqsTraining (&mmPtr->NBPtr[Die]);
if (mmPtr->NBPtr[Die].MCTPtr->ErrCode == AGESA_FATAL) {
break;
}
} // End Die For Loop
return (BOOLEAN) (Die == mmPtr->DieCount);
}
/**
*
* Check and disable Chip selects that fail training on all nodes.
*
* @param[in,out] *MemMainPtr - Pointer to the MEM_MAIN_DATA_BLOCK
*
* @return TRUE - No fatal error occurs.
* @return FALSE - Fatal error occurs.
*/
BOOLEAN
MemMRASExcludeDIMM (
IN OUT MEM_MAIN_DATA_BLOCK *MemMainPtr
)
{
UINT8 Node;
BOOLEAN IsEnabled;
BOOLEAN RetVal;
BOOLEAN IsChannelIntlvEnabled[MAX_NODES_SUPPORTED];
UINT8 FirstEnabledNode;
UINT32 BottomIO;
MEM_NB_BLOCK *NBPtr;
MEM_PARAMETER_STRUCT *RefPtr;
S_UINT64 SMsr;
FirstEnabledNode = 0;
IsEnabled = FALSE;
RetVal = TRUE;
NBPtr = MemMainPtr->NBPtr;
RefPtr = NBPtr[BSP_DIE].RefPtr;
for (Node = 0; Node < MemMainPtr->DieCount; Node++) {
if (NBPtr[Node].FeatPtr->ExcludeDIMM (&NBPtr[Node])) {
if (!IsEnabled) {
// Record the first node that has exclude dimm enabled
FirstEnabledNode = Node;
IsEnabled = TRUE;
}
}
}
if (IsEnabled) {
// Check if all nodes have all dimms excluded. If yes, fatal exit
NBPtr[BSP_DIE].SharedPtr->CurrentNodeSysBase = 0;
BottomIO = (NBPtr[BSP_DIE].RefPtr->BottomIo & 0xF8) << 8;
// If the first node that has excluded dimms does not have a system base smaller
// than bottomIO, then we don't need to reset the GStatus, as we don't need to
// remap memory hole.
if (NBPtr[FirstEnabledNode].MCTPtr->NodeSysBase < BottomIO) {
RefPtr->GStatus[GsbHWHole] = FALSE;
RefPtr->GStatus[GsbSpIntRemapHole] = FALSE;
RefPtr->GStatus[GsbSoftHole] = FALSE;
RefPtr->HoleBase = 0;
RefPtr->SysLimit = 0;
}
// If Node Interleaving has been executed before the remapping then we need to
// start from the first node.
// There may be a few senarios:
// 1. Node interleaving is not enabled before the remap, and still cannot be enabled after
// remap
// 2. Node interleaving cannot be enabled before the remap, but it can be enabled after
// remap
// 3. Node interleaving is enabled before the remap, but it cannot be enabled after the remap
if (NBPtr->SharedPtr->NodeIntlv.IsValid) {
FirstEnabledNode = 0;
}
for (Node = 0; Node < MemMainPtr->DieCount; Node++) {
IsChannelIntlvEnabled [Node] = FALSE;
// Check if node interleaving has been enabled on this node
// if yes, disable it.
if (NBPtr[Node].GetBitField (&NBPtr[Node], BFDramIntlvEn) != 0) {
NBPtr[Node].SetBitField (&NBPtr[Node], BFDramIntlvEn, 0);
NBPtr[Node].SetBitField (&NBPtr[Node], BFDramIntlvSel, 0);
}
if (Node >= FirstEnabledNode) {
// Remap memory on nodes with node number larger than the first node that has excluded dimms.
// If channel interleaving has already been enabled, need to disable it before remapping memory.
if (NBPtr[Node].GetBitField (&NBPtr[Node], BFDctSelIntLvEn) != 0) {
NBPtr[Node].SetBitField (&NBPtr[Node], BFDctSelIntLvEn, 0);
IsChannelIntlvEnabled [Node] = TRUE;
}
NBPtr[Node].MCTPtr->Status[SbHWHole] = FALSE;
NBPtr[Node].MCTPtr->Status[SbSWNodeHole] = FALSE;
NBPtr[Node].SetBitField (&NBPtr[Node], BFDctSelBaseAddr, 0);
NBPtr[Node].SetBitField (&NBPtr[Node], BFDctSelHiRngEn, 0);
NBPtr[Node].SetBitField (&NBPtr[Node], BFDctSelHi, 0);
NBPtr[Node].SetBitField (&NBPtr[Node], BFDctSelBaseOffset, 0);
NBPtr[Node].SetBitField (&NBPtr[Node], BFDramHoleAddrReg, 0);
NBPtr[Node].HtMemMapInit (&NBPtr[Node]);
} else if (NBPtr[Node].MCTPtr->NodeMemSize != 0) {
// No change is needed in the memory map of this node.
// Need to adjust the current system base for other nodes processed later.
NBPtr[Node].SharedPtr->CurrentNodeSysBase = (NBPtr[Node].MCTPtr->NodeSysLimit + 1) & 0xFFFFFFF0;
RefPtr->SysLimit = NBPtr[Node].MCTPtr->NodeSysLimit;
// If the current node does not have the memory hole, then set DramHoleAddrReg to be 0.
// If memory hoisting is enabled later by other node, SyncAddrMapToAllNodes will set the base
// and DramMemHoistValid.
// Otherwise, do not change the register value, as we need to keep DramHoleOffset unchanged, as well
// DramHoleValid.
if (!NBPtr[Node].MCTPtr->Status[SbHWHole]) {
NBPtr[Node].SetBitField (&NBPtr[Node], BFDramHoleAddrReg, 0);
}
}
}
for (Node = 0; Node < MemMainPtr->DieCount; Node++) {
NBPtr[Node].SyncAddrMapToAllNodes (&NBPtr[Node]);
}
LibAmdMsrRead (TOP_MEM, (UINT64 *)&SMsr, &NBPtr->MemPtr->StdHeader);
// Only when TOM is set can CpuMemTyping be re-run
if ((SMsr.hi == 0) && (SMsr.lo == 0)) {
if (RefPtr->SysLimit != 0) {
NBPtr[BSP_DIE].CpuMemTyping (&NBPtr[BSP_DIE]);
}
}
// Re-run node interleaving if it has been exeucuted before the remap
if (NBPtr->SharedPtr->NodeIntlv.IsValid) {
MemFeatMain.InterleaveNodes (MemMainPtr);
}
// Re-enable channel interleaving if it was enabled before remapping memory
for (Node = 0; Node < MemMainPtr->DieCount; Node++) {
if (IsChannelIntlvEnabled [Node]) {
NBPtr[Node].FeatPtr->InterleaveChannels (&NBPtr[Node]);
}
}
}
// if all dimms on all nodes are excluded, do fatal exit
if (RefPtr->SysLimit == 0) {
PutEventLog (AGESA_FATAL, MEM_ERROR_NO_DIMM_FOUND_ON_SYSTEM, 0, 0, 0, 0, &NBPtr->MemPtr->StdHeader);
SetMemError (AGESA_FATAL, NBPtr[BSP_DIE].MCTPtr);
ASSERT (FALSE);
}
for (Node = 0; Node < MemMainPtr->DieCount; Node ++) {
RetVal &= (BOOLEAN) (NBPtr[Node].MCTPtr->ErrCode < AGESA_FATAL);
}
return RetVal;
}
