src/vendorcode/amd/agesa/f15/Proc/Mem/NB/HY/mnhy.c

   1 /* $NoKeywords:$ */
   2 /**
   3  * @file
   4  *
   5  * mnhy.c
   6  *
   7  * Common Northbridge  functions for Hydra
   8  *
   9  * @xrefitem bom "File Content Label" "Release Content"
  10  * @e project: AGESA
  11  * @e sub-project: (Mem/NB/HY)
  12  * @e \$Revision: 56279 $ @e \$Date: 2011-07-11 13:11:28 -0600 (Mon, 11 Jul 2011) $
  13  *
  14  **/
  15 /*****************************************************************************
  16 *
  17 * Copyright (C) 2012 Advanced Micro Devices, Inc.
  18 * All rights reserved.
  19 *
  20 * Redistribution and use in source and binary forms, with or without
  21 * modification, are permitted provided that the following conditions are met:
  22 *     * Redistributions of source code must retain the above copyright
  23 *       notice, this list of conditions and the following disclaimer.
  24 *     * Redistributions in binary form must reproduce the above copyright
  25 *       notice, this list of conditions and the following disclaimer in the
  26 *       documentation and/or other materials provided with the distribution.
  27 *     * Neither the name of Advanced Micro Devices, Inc. nor the names of
  28 *       its contributors may be used to endorse or promote products derived
  29 *       from this software without specific prior written permission.
  30 *
  31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  32 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  33 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  34 * DISCLAIMED. IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. BE LIABLE FOR ANY
  35 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  36 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  37 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  38 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  39 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  40 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  41 *
  42 * ***************************************************************************
  43 *
  44 */
  45
  46 /*
  47  *----------------------------------------------------------------------------
  48  *                                MODULES USED
  49  *
  50  *----------------------------------------------------------------------------
  51  */
  52
  53
  54
  55 #include "AGESA.h"
  56 #include "AdvancedApi.h"
  57 #include "amdlib.h"
  58 #include "Ids.h"
  59 #include "OptionMemory.h"
  60 #include "mm.h"
  61 #include "mn.h"
  62 #include "mnhy.h"
  63 #include "mu.h"
  64 #include "S3.h"
  65 #include "cpuRegisters.h"
  66 #include "cpuFamRegisters.h"
  67 #include "cpuFamilyTranslation.h"
  68 #include "heapManager.h"
  69 #include "GeneralServices.h"
  70 #include "Filecode.h"
  71 CODE_GROUP (G1_PEICC)
  72 RDATA_GROUP (G2_PEI)
  73
  74 #define FILECODE PROC_MEM_NB_HY_MNHY_FILECODE
  75 /*----------------------------------------------------------------------------
  76  *                          DEFINITIONS AND MACROS
  77  *
  78  *----------------------------------------------------------------------------
  79  */
  80
  81 #define SPLIT_CHANNEL   (UINT32) 0x20000000
  82 #define CHANNEL_SELECT  (UINT32) 0x10000000
  83
  84 /*----------------------------------------------------------------------------
  85  *                           TYPEDEFS AND STRUCTURES
  86  *
  87  *----------------------------------------------------------------------------
  88  */
  89 /*----------------------------------------------------------------------------
  90  *                        PROTOTYPES OF LOCAL FUNCTIONS
  91  *
  92  *----------------------------------------------------------------------------
  93  */
  94
  95 /*----------------------------------------------------------------------------
  96  *                            EXPORTED FUNCTIONS
  97  *
  98  *----------------------------------------------------------------------------
  99  */
 100
 101 extern BUILD_OPT_CFG UserOptions;
 102 extern PSO_ENTRY DefaultPlatformMemoryConfiguration[];
 103
 104 /* -----------------------------------------------------------------------------*/
 105 /**
 106  *
 107  *
 108  *   This function initializes the northbridge block
 109  *
 110  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 111  *     @param[in,out]   *MemPtr  - Pointer to the MEM_DATA_STRUCT
 112  *     @param[in]        *FeatPtr  - Pointer to the MEM_FEAT_BLOCK_NB
 113  *     @param[in]        *SharedPtr - Pointer to the MEM_SHARED_DATA
 114  *     @param[in]        NodeID  - UINT8 indicating node ID of the NB object.
 115  *
 116  *     @return     Boolean indicating that this is the correct memory
 117  *                 controller type for the node number that was passed in.
 118  */
 119
 120 BOOLEAN
 121 MemConstructNBBlockHY (
 122   IN OUT   MEM_NB_BLOCK *NBPtr,
 123   IN OUT   MEM_DATA_STRUCT *MemPtr,
 124   IN       MEM_FEAT_BLOCK_NB *FeatPtr,
 125   IN       MEM_SHARED_DATA *SharedPtr,
 126   IN       UINT8 NodeID
 127   )
 128 {
 129   UINT8 Dct;
 130   UINT8 Channel;
 131   UINT8 SpdSocketIndex;
 132   UINT8 SpdChannelIndex;
 133   DIE_STRUCT *MCTPtr;
 134   ALLOCATE_HEAP_PARAMS AllocHeapParams;
 135
 136   //
 137   // Determine if this is the expected NB Type
 138   //
 139   GetLogicalIdOfSocket (MemPtr->DiesPerSystem[NodeID].SocketId, &(MemPtr->DiesPerSystem[NodeID].LogicalCpuid), &(MemPtr->StdHeader));
 140   if (!MemNIsIdSupportedHy (NBPtr, &(MemPtr->DiesPerSystem[NodeID].LogicalCpuid))) {
 141     return FALSE;
 142   }
 143
 144   NBPtr->MemPtr = MemPtr;
 145   NBPtr->RefPtr = MemPtr->ParameterListPtr;
 146   NBPtr->SharedPtr = SharedPtr;
 147
 148   MCTPtr = &(MemPtr->DiesPerSystem[NodeID]);
 149   NBPtr->MCTPtr = MCTPtr;
 150   NBPtr->MCTPtr->NodeId = NodeID;
 151   NBPtr->PciAddr.AddressValue = MCTPtr->PciAddr.AddressValue;
 152   NBPtr->VarMtrrHiMsk = GetVarMtrrHiMsk (&(MemPtr->DiesPerSystem[NodeID].LogicalCpuid), &(MemPtr->StdHeader));
 153
 154   //
 155   // Allocate buffer for DCT_STRUCTs and CH_DEF_STRUCTs
 156   //
 157   AllocHeapParams.RequestedBufferSize = MAX_DCTS_PER_NODE_HY * (
 158                                           sizeof (DCT_STRUCT) + (
 159                                             MAX_CHANNELS_PER_DCT_HY * (sizeof (CH_DEF_STRUCT) + sizeof (MEM_PS_BLOCK))
 160                                           )
 161                                         );
 162   AllocHeapParams.BufferHandle = GENERATE_MEM_HANDLE (ALLOC_DCT_STRUCT_HANDLE, NodeID, 0, 0);
 163   AllocHeapParams.Persist = HEAP_LOCAL_CACHE;
 164   if (HeapAllocateBuffer (&AllocHeapParams, &MemPtr->StdHeader) != AGESA_SUCCESS) {
 165     PutEventLog (AGESA_FATAL, MEM_ERROR_HEAP_ALLOCATE_FOR_DCT_STRUCT_AND_CH_DEF_STRUCTs, NBPtr->Node, 0, 0, 0, &MemPtr->StdHeader);
 166     SetMemError (AGESA_FATAL, MCTPtr);
 167     ASSERT(FALSE); // Could not allocate buffer for DCT_STRUCTs and CH_DEF_STRUCTs
 168     return FALSE;
 169   }
 170
 171   MCTPtr->DctCount = MAX_DCTS_PER_NODE_HY;
 172   MCTPtr->DctData = (DCT_STRUCT *) AllocHeapParams.BufferPtr;
 173   AllocHeapParams.BufferPtr += MAX_DCTS_PER_NODE_HY * sizeof (DCT_STRUCT);
 174   for (Dct = 0; Dct < MAX_DCTS_PER_NODE_HY; Dct++) {
 175     MCTPtr->DctData[Dct].Dct = Dct;
 176     MCTPtr->DctData[Dct].ChannelCount = MAX_CHANNELS_PER_DCT_HY;
 177     MCTPtr->DctData[Dct].ChData = (CH_DEF_STRUCT *) AllocHeapParams.BufferPtr;
 178     MCTPtr->DctData[Dct].ChData[0].Dct = Dct;
 179     AllocHeapParams.BufferPtr += MAX_CHANNELS_PER_DCT_HY * sizeof (CH_DEF_STRUCT);
 180   }
 181   NBPtr->PSBlock = (MEM_PS_BLOCK *) AllocHeapParams.BufferPtr;
 182
 183   //
 184   // Initialize Socket List
 185   //
 186   for (Dct = 0; Dct < MAX_DCTS_PER_NODE_HY; Dct++) {
 187     MemPtr->SocketList[MCTPtr->SocketId].ChannelPtr[(MCTPtr->DieId * 2) + Dct] = &(MCTPtr->DctData[Dct].ChData[0]);
 188     MemPtr->SocketList[MCTPtr->SocketId].TimingsPtr[(MCTPtr->DieId * 2) + Dct] = &(MCTPtr->DctData[Dct].Timings);
 189     MCTPtr->DctData[Dct].ChData[0].ChannelID = (MCTPtr->DieId * 2) + Dct;
 190   }
 191
 192   MemNInitNBDataHy (NBPtr);
 193
 194   FeatPtr->InitCPG (NBPtr);
 195   NBPtr->FeatPtr = FeatPtr;
 196   FeatPtr->InitHwRxEn (NBPtr);
 197   //
 198   // Calculate SPD Offsets per channel and assign pointers to the data.  At this point, we calculate the Node-Dct-Channel
 199   // centric offsets and store the pointers to the first DIMM of each channel in the Channel Definition struct for that
 200   // channel.  This pointer is then used later to calculate the offsets to be used for each logical dimm once the
 201   // dimm types(QR or not) are known. This is done in the Technology block constructor.
 202   //
 203   // Calculate the SpdSocketIndex separately from the SpdChannelIndex.
 204   // This will facilitate modifications due to some processors that might
 205   // map the DCT-CHANNEL differently.
 206   //
 207   SpdSocketIndex = GetSpdSocketIndex (NBPtr->RefPtr->PlatformMemoryConfiguration, NBPtr->MCTPtr->SocketId, &MemPtr->StdHeader);
 208   //
 209   // Traverse the Dct/Channel structures
 210   //
 211   for (Dct = 0; Dct < MAX_DCTS_PER_NODE_HY; Dct++) {
 212     for (Channel = 0; Channel < MAX_CHANNELS_PER_DCT_HY; Channel++) {
 213       //
 214       // Calculate the number of Dimms on this channel using the
 215       //   die/dct/channel to Socket/channel conversion.
 216       //
 217       SpdChannelIndex = GetSpdChannelIndex (NBPtr->RefPtr->PlatformMemoryConfiguration,
 218                                             NBPtr->MCTPtr->SocketId,
 219                                             MemNGetSocketRelativeChannelNb (NBPtr, Dct, Channel),
 220                                             &MemPtr->StdHeader);
 221       NBPtr->MCTPtr->DctData[Dct].ChData[Channel].SpdPtr = &(MemPtr->SpdDataStructure[SpdSocketIndex + SpdChannelIndex]);
 222     }
 223   }
 224
 225   MemNSwitchDCTNb (NBPtr, 0);
 226
 227   return TRUE;
 228 }
 229
 230 /* -----------------------------------------------------------------------------*/
 231 /**
 232  *
 233  *   This function initializes member functions and variables of NB block.
 234  *
 235  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 236  *
 237  */
 238
 239 VOID
 240 MemNInitNBDataHy (
 241   IN OUT   MEM_NB_BLOCK *NBPtr
 242   )
 243 {
 244   NBPtr->DctCachePtr = NBPtr->DctCache;
 245   NBPtr->PsPtr = NBPtr->PSBlock;
 246
 247   InitNBRegTableHy (NBPtr, NBPtr->NBRegTable);
 248   NBPtr->Node = ((UINT8) NBPtr->PciAddr.Address.Device) - 24;
 249   NBPtr->Dct = 0;
 250   NBPtr->Channel = 0;
 251   NBPtr->DctCount = MAX_DCTS_PER_NODE_HY;
 252   NBPtr->ChannelCount = MAX_CHANNELS_PER_DCT_HY;
 253   NBPtr->NodeCount = MAX_NODES_SUPPORTED_HY;
 254   NBPtr->Ganged = FALSE;
 255   NBPtr->PosTrnPattern = POS_PATTERN_256B;
 256   NBPtr->MemCleared = FALSE;
 257   NBPtr->StartupSpeed = DDR800_FREQUENCY;
 258   NBPtr->RcvrEnDlyLimit = 0x1FF;
 259   NBPtr->DefDctSelIntLvAddr = 3;
 260   NBPtr->CsRegMsk = 0x1FF83FE0;
 261
 262   LibAmdMemFill (NBPtr->DctCache, 0, sizeof (NBPtr->DctCache), &NBPtr->MemPtr->StdHeader);
 263
 264   NBPtr->SetMaxLatency = MemNSetMaxLatencyNb;
 265   NBPtr->getMaxLatParams = MemNGetMaxLatParamsNb;
 266   NBPtr->InitializeMCT = MemNInitializeMctHy;
 267   NBPtr->FinalizeMCT = MemNFinalizeMctHy;
 268   NBPtr->SendMrsCmd = MemNSendMrsCmdHy;
 269   NBPtr->sendZQCmd = MemNSendZQCmdNb;
 270   NBPtr->WritePattern = MemNWritePatternHy;
 271   NBPtr->ReadPattern = MemNReadPatternHy;
 272   NBPtr->GenHwRcvEnReads = (VOID (*) (MEM_NB_BLOCK *, UINT32)) memDefRet;
 273   NBPtr->CompareTestPattern = MemNCompareTestPatternNb;
 274   NBPtr->InsDlyCompareTestPattern = MemNInsDlyCompareTestPatternNb;
 275   NBPtr->StitchMemory = MemNStitchMemoryNb;
 276   NBPtr->AutoConfig = MemNAutoConfigHy;
 277   NBPtr->PlatformSpec = MemNPlatformSpecNb;
 278   NBPtr->InitMCT = MemNInitMCTNb;
 279   NBPtr->DisableDCT = MemNDisableDCTNb;
 280   NBPtr->StartupDCT = MemNStartupDCTNb;
 281   NBPtr->SyncTargetSpeed = MemNSyncTargetSpeedNb;
 282   NBPtr->ChangeFrequency = MemNChangeFrequencyNb;
 283   NBPtr->RampUpFrequency = MemNRampUpFrequencyNb;
 284   NBPtr->ChangeNbFrequency = (BOOLEAN (*) (MEM_NB_BLOCK *)) memDefFalse;
 285   NBPtr->ProgramCycTimings = MemNProgramCycTimingsNb;
 286   NBPtr->SyncDctsReady = MemNSyncDctsReadyNb;
 287   NBPtr->HtMemMapInit = MemNHtMemMapInitNb;
 288   NBPtr->SyncAddrMapToAllNodes = MemNSyncAddrMapToAllNodesNb;
 289   NBPtr->CpuMemTyping = MemNCPUMemTypingNb;
 290   NBPtr->BeforeDqsTraining = MemNBeforeDQSTrainingHy;
 291   NBPtr->AfterDqsTraining = (VOID (*) (MEM_NB_BLOCK *)) memDefRet;
 292   NBPtr->OtherTiming = MemNOtherTimingHy;
 293   NBPtr->UMAMemTyping = MemNUMAMemTypingNb;
 294   NBPtr->GetSocketRelativeChannel = MemNGetSocketRelativeChannelHy;
 295   NBPtr->TechBlockSwitch = MemNTechBlockSwitchNb;
 296   NBPtr->MemNCmnGetSetFieldNb = MemNCmnGetSetFieldHy;
 297   NBPtr->SetEccSymbolSize = MemNSetEccSymbolSizeNb;
 298   NBPtr->TrainingFlow = (VOID (*) (MEM_NB_BLOCK *)) MemNTrainingFlowNb;
 299   MemNInitNBDataNb (NBPtr);
 300   NBPtr->PollBitField = MemNPollBitFieldNb;
 301   NBPtr->BrdcstCheck = MemNBrdcstCheckNb;
 302   NBPtr->BrdcstSet = MemNBrdcstSetNb;
 303   NBPtr->GetTrainDly = MemNGetTrainDlyNb;
 304   NBPtr->SetTrainDly = MemNSetTrainDlyNb;
 305   NBPtr->PhyFenceTraining = MemNPhyFenceTrainingNb;
 306   NBPtr->GetSysAddr = MemNGetMCTSysAddrNb;
 307   NBPtr->RankEnabled = MemNRankEnabledNb;
 308   NBPtr->MemNBeforeDramInitNb = MemNBeforeDramInitHy;
 309   NBPtr->MemNcmnGetSetTrainDly = MemNcmnGetSetTrainDlyNb;
 310   NBPtr->MemPPhyFenceTrainingNb = MemNTrainPhyFenceNb;
 311   NBPtr->MemNInitPhyComp = MemNInitPhyCompHy;
 312   NBPtr->MemNBeforePlatformSpecNb = MemNBeforePlatformSpecHy;
 313   NBPtr->MemNPlatformSpecificFormFactorInitNb = MemNPlatformSpecificFormFactorInitHy;
 314   NBPtr->MemNPFenceAdjustNb = (VOID (*) (MEM_NB_BLOCK *, INT16 *)) memDefRet;
 315   NBPtr->GetTrainDlyParms = MemNGetTrainDlyParmsNb;
 316   NBPtr->TrainingPatternInit = MemNTrainingPatternInitNb;
 317   NBPtr->TrainingPatternFinalize = MemNTrainingPatternFinalizeNb;
 318   NBPtr->GetApproximateWriteDatDelay = MemNGetApproximateWriteDatDelayNb;
 319   NBPtr->CSPerChannel = MemNCSPerChannelNb;
 320   NBPtr->CSPerDelay = MemNCSPerDelayNb;
 321   NBPtr->FlushPattern = MemNFlushPatternNb;
 322   NBPtr->MinDataEyeWidth = MemNMinDataEyeWidthNb;
 323   NBPtr->MemNCapSpeedBatteryLife = (VOID (*) (MEM_NB_BLOCK *)) memDefRet;
 324   NBPtr->GetUmaSize = MemNGetUmaSizeNb;
 325   NBPtr->GetMemClkFreqId = MemNGetMemClkFreqIdNb;
 326   NBPtr->EnableSwapIntlvRgn = (VOID (*) (MEM_NB_BLOCK *, UINT32, UINT32)) memDefRet;
 327   NBPtr->WaitXMemClks = MemNWaitXMemClksNb;
 328   NBPtr->MemNGetDramTerm = MemNGetDramTermNb;
 329   NBPtr->MemNGetDynDramTerm = MemNGetDynDramTermNb;
 330   NBPtr->MemNGetMR0CL = MemNGetMR0CLNb;
 331   NBPtr->MemNGetMR0WR = MemNGetMR0WRNb;
 332   NBPtr->MemNSaveMR0 = (VOID (*) (MEM_NB_BLOCK *, UINT32)) memDefRet;
 333   NBPtr->MemNGetMR2CWL = MemNGetMR2CWLNb;
 334   NBPtr->AllocateC6Storage = (VOID (*) (MEM_NB_BLOCK *)) memDefRet;
 335
 336   NBPtr->IsSupported[SetSpareEn] = TRUE;
 337   NBPtr->IsSupported[CheckSpareEn] = TRUE;
 338   NBPtr->IsSupported[SetDllShutDown] = TRUE;
 339   NBPtr->IsSupported[CheckEccDLLPwrDnConfig] = TRUE;
 340   NBPtr->IsSupported[CheckMaxDramRate] = TRUE;
 341   NBPtr->IsSupported[CheckMemClkCSPresent] = TRUE;
 342   NBPtr->IsSupported[CheckMaxRdDqsDlyPtr] = TRUE;
 343   NBPtr->IsSupported[CheckPhyFenceTraining] = TRUE;
 344   NBPtr->IsSupported[CheckSendAllMRCmds] = TRUE;
 345   NBPtr->IsSupported[CheckFindPSOverideWithSocket] = TRUE;
 346   NBPtr->IsSupported[CheckODTControls] = TRUE;
 347   NBPtr->IsSupported[CheckDummyCLRead] = TRUE;
 348   NBPtr->IsSupported[CheckSlewWithoutMarginImprv] = TRUE;
 349   NBPtr->IsSupported[CheckDllSpeedUp] = TRUE;
 350   NBPtr->IsSupported[ForceEnMemHoleRemapping] = TRUE;
 351
 352   NBPtr->FamilySpecificHook[SendMrsCmdsPerCs] = MemNSendMrsCmdPerCsHy;
 353   NBPtr->FamilySpecificHook[InitExtMMIOAddr] = MemNInitExtMMIOAddrHy;
 354 }
 355
 356 /* -----------------------------------------------------------------------------*/
 357 /**
 358  *
 359  *
 360  *   This function initializes the default values in the MEM_DATA_STRUCT
 361  *
 362  *     @param[in,out]   *MemPtr  - Pointer to the MEM_DATA_STRUCT
 363  *
 364  */
 365 VOID
 366 MemNInitDefaultsHY (
 367   IN OUT   MEM_DATA_STRUCT *MemPtr
 368   )
 369 {
 370   UINT8 Socket;
 371   UINT8 Channel;
 372   MEM_PARAMETER_STRUCT *RefPtr;
 373   ASSERT (MemPtr != NULL);
 374   RefPtr = MemPtr->ParameterListPtr;
 375
 376   // Memory Map/Mgt.
 377   // Mask Bottom IO with 0xF8 to force hole size to have granularity of 128MB
 378   RefPtr->BottomIo = 0xE0;
 379   RefPtr->UmaMode = UserOptions.CfgUmaMode;
 380   RefPtr->UmaSize = UserOptions.CfgUmaSize;
 381   RefPtr->MemHoleRemapping = TRUE;
 382   RefPtr->LimitMemoryToBelow1Tb = UserOptions.CfgLimitMemoryToBelow1Tb;
 383   //
 384
 385
 386   // Dram Timing
 387   RefPtr->UserTimingMode = UserOptions.CfgTimingModeSelect;
 388   RefPtr->MemClockValue = UserOptions.CfgMemoryClockSelect;
 389   for (Socket = 0; Socket < MAX_SOCKETS_SUPPORTED; Socket++) {
 390     for (Channel = 0; Channel < MAX_CHANNELS_PER_SOCKET; Channel++) {
 391       MemPtr->SocketList[Socket].ChannelPtr[Channel] = NULL;
 392       MemPtr->SocketList[Socket].TimingsPtr[Channel] = NULL;
 393     }
 394   }
 395
 396   // Memory Clear
 397   RefPtr->EnableMemClr = TRUE;
 398
 399   // TableBasedAlterations
 400   RefPtr->TableBasedAlterations = NULL;
 401
 402   // Platform config table
 403   RefPtr->PlatformMemoryConfiguration = DefaultPlatformMemoryConfiguration;
 404
 405   // Memory Restore
 406   RefPtr->MemRestoreCtl = FALSE;
 407   RefPtr->SaveMemContextCtl = FALSE;
 408   AmdS3ParamsInitializer (&RefPtr->MemContext);
 409
 410   // Dram Configuration
 411   RefPtr->EnableBankIntlv = UserOptions.CfgMemoryEnableBankInterleaving;
 412   RefPtr->EnableNodeIntlv = UserOptions.CfgMemoryEnableNodeInterleaving;
 413   RefPtr->EnableChannelIntlv = UserOptions.CfgMemoryChannelInterleaving;
 414   RefPtr->EnableBankSwizzle = UserOptions.CfgBankSwizzle;
 415   RefPtr->EnableParity = UserOptions.CfgMemoryParityEnable;
 416   RefPtr->EnableOnLineSpareCtl = UserOptions.CfgOnlineSpare;
 417
 418   // Dram Power
 419   RefPtr->EnablePowerDown = UserOptions.CfgMemoryPowerDown;
 420
 421   // ECC
 422   RefPtr->EnableEccFeature = UserOptions.CfgEnableEccFeature;
 423
 424   // Vref
 425   RefPtr->ExternalVrefCtl = UserOptions.CfgExternalVrefCtlFeature;
 426
 427   //Training Mode
 428   RefPtr->ForceTrainMode = UserOptions.CfgForceTrainMode;
 429 }
 430 /*-----------------------------------------------------------------------------*/
 431 /**
 432  *
 433  *      This function writes training pattern
 434  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 435  *     @param[in] Pattern[] - Pattern to write
 436  *     @param[in] Address - System Address [47:16]
 437  *     @param[in] ClCount - Number of cache lines
 438  *
 439  */
 440
 441 VOID
 442 MemNWritePatternHy (
 443   IN OUT   MEM_NB_BLOCK *NBPtr,
 444   IN       UINT32 Address,
 445   IN       UINT8 Pattern[],
 446   IN       UINT16 ClCount
 447   )
 448 {
 449   Address = MemUSetUpperFSbase (Address, NBPtr->MemPtr);
 450   MemUWriteCachelines (Address, Pattern, ClCount);
 451 }
 452
 453 /*-----------------------------------------------------------------------------*/
 454 /**
 455  *
 456  *      This function reads training pattern
 457  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 458  *     @param[in] Buffer[] - Buffer to fill
 459  *     @param[in] Address - System Address [47:16]
 460  *     @param[in] ClCount - Number of cache lines
 461  *
 462  */
 463
 464 VOID
 465 MemNReadPatternHy (
 466   IN OUT   MEM_NB_BLOCK *NBPtr,
 467   IN       UINT8 Buffer[],
 468   IN       UINT32 Address,
 469   IN       UINT16 ClCount
 470   )
 471 {
 472   Address = MemUSetUpperFSbase (Address, NBPtr->MemPtr);
 473   MemUReadCachelines (Buffer, Address, ClCount);
 474 }
 475 /* -----------------------------------------------------------------------------*/
 476 /**
 477  *
 478  *   This function initiates DQS training for Server NB
 479  *
 480  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 481  *
 482  */
 483
 484 BOOLEAN
 485 memNEnableTrainSequenceHy (
 486   IN OUT   MEM_NB_BLOCK *NBPtr
 487   )
 488 {
 489   BOOLEAN Retval;
 490   Retval = TRUE;
 491   if (!MemNIsIdSupportedHy (NBPtr, &(NBPtr->MemPtr->DiesPerSystem[NBPtr->MCTPtr->NodeId].LogicalCpuid))) {
 492     Retval = FALSE;
 493   }
 494   return Retval;
 495 }
 496