src/vendorcode/amd/agesa/f15/Proc/Mem/NB/DA/mnda.c

   1 /* $NoKeywords:$ */
   2 /**
   3  * @file
   4  *
   5  * mnda.c
   6  *
   7  * Common Northbridge functions for DA
   8  *
   9  * @xrefitem bom "File Content Label" "Release Content"
  10  * @e project: AGESA
  11  * @e sub-project: (Mem/NB/DA)
  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  *                                MODULES USED
  48  *
  49  *----------------------------------------------------------------------------
  50  */
  51
  52
  53
  54 #include "AGESA.h"
  55 #include "AdvancedApi.h"
  56 #include "amdlib.h"
  57 #include "Ids.h"
  58 #include "OptionMemory.h"
  59 #include "mm.h"
  60 #include "mn.h"
  61 #include "mnda.h"
  62 #include "mu.h"
  63 #include "S3.h"
  64 #include "cpuRegisters.h"
  65 #include "cpuFamRegisters.h"
  66 #include "cpuFamilyTranslation.h"
  67 #include "heapManager.h"
  68 #include "GeneralServices.h"
  69 #include "Filecode.h"
  70 CODE_GROUP (G1_PEICC)
  71 RDATA_GROUP (G2_PEI)
  72 #define FILECODE PROC_MEM_NB_DA_MNDA_FILECODE
  73
  74
  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 /*----------------------------------------------------------------------------
  91  *                        PROTOTYPES OF LOCAL FUNCTIONS
  92  *
  93  *----------------------------------------------------------------------------
  94  */
  95
  96 /*----------------------------------------------------------------------------
  97  *                            EXPORTED FUNCTIONS
  98  *
  99  *----------------------------------------------------------------------------
 100  */
 101
 102 extern BUILD_OPT_CFG UserOptions;
 103 extern PSO_ENTRY DefaultPlatformMemoryConfiguration[];
 104
 105 /* -----------------------------------------------------------------------------*/
 106 /**
 107  *
 108  *
 109  *   This function initializes the northbridge block
 110  *
 111  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 112  *     @param[in,out]   *MemPtr  - Pointer to the MEM_DATA_STRUCT
 113  *     @param[in]        *FeatPtr  - Pointer to the MEM_FEAT_BLOCK_NB
 114  *     @param[in]        *SharedPtr - Pointer to the MEM_SHARED_DATA
 115  *     @param[in]        NodeID  - UINT8 indicating node ID of the NB object.
 116  *
 117  *     @return     Boolean indicating that this is the correct memory
 118  *                 controller type for the node number that was passed in.
 119  */
 120
 121 BOOLEAN
 122 MemConstructNBBlockDA (
 123   IN OUT   MEM_NB_BLOCK *NBPtr,
 124   IN OUT   MEM_DATA_STRUCT *MemPtr,
 125   IN       MEM_FEAT_BLOCK_NB *FeatPtr,
 126   IN       MEM_SHARED_DATA *SharedPtr,
 127   IN       UINT8 NodeID
 128   )
 129 {
 130   UINT8 Dct;
 131   UINT8 Channel;
 132   UINT8 SpdSocketIndex;
 133   UINT8 SpdChannelIndex;
 134   DIE_STRUCT *MCTPtr;
 135   ALLOCATE_HEAP_PARAMS AllocHeapParams;
 136
 137   //
 138   // Determine if this is the expected NB Type
 139   //
 140   GetLogicalIdOfSocket (MemPtr->DiesPerSystem[NodeID].SocketId, &(MemPtr->DiesPerSystem[NodeID].LogicalCpuid), &(MemPtr->StdHeader));
 141   if (!MemNIsIdSupportedDA (NBPtr, &(MemPtr->DiesPerSystem[NodeID].LogicalCpuid))) {
 142     return FALSE;
 143   }
 144
 145   NBPtr->MemPtr = MemPtr;
 146   NBPtr->RefPtr = MemPtr->ParameterListPtr;
 147   NBPtr->SharedPtr = SharedPtr;
 148
 149   MCTPtr = &(MemPtr->DiesPerSystem[NodeID]);
 150   NBPtr->MCTPtr = MCTPtr;
 151   NBPtr->MCTPtr->NodeId = NodeID;
 152   NBPtr->PciAddr.AddressValue = MCTPtr->PciAddr.AddressValue;
 153   NBPtr->VarMtrrHiMsk = GetVarMtrrHiMsk (&(MemPtr->DiesPerSystem[NodeID].LogicalCpuid), &(MemPtr->StdHeader));
 154
 155   //
 156   // Allocate buffer for DCT_STRUCTs and CH_DEF_STRUCTs
 157   //
 158   AllocHeapParams.RequestedBufferSize = MAX_DCTS_PER_NODE_DA * (
 159                                           sizeof (DCT_STRUCT) + (
 160                                             MAX_CHANNELS_PER_DCT_DA * (sizeof (CH_DEF_STRUCT) + sizeof (MEM_PS_BLOCK))
 161                                           )
 162                                         );
 163   AllocHeapParams.BufferHandle = GENERATE_MEM_HANDLE (ALLOC_DCT_STRUCT_HANDLE, NodeID, 0, 0);
 164   AllocHeapParams.Persist = HEAP_LOCAL_CACHE;
 165   if (HeapAllocateBuffer (&AllocHeapParams, &MemPtr->StdHeader) != AGESA_SUCCESS) {
 166     PutEventLog (AGESA_FATAL, MEM_ERROR_HEAP_ALLOCATE_FOR_DCT_STRUCT_AND_CH_DEF_STRUCTs, NBPtr->Node, 0, 0, 0, &MemPtr->StdHeader);
 167     SetMemError (AGESA_FATAL, MCTPtr);
 168     return FALSE;
 169   }
 170
 171   MCTPtr->DctCount = MAX_DCTS_PER_NODE_DA;
 172   MCTPtr->DctData = (DCT_STRUCT *) AllocHeapParams.BufferPtr;
 173   AllocHeapParams.BufferPtr += MAX_DCTS_PER_NODE_DA * sizeof (DCT_STRUCT);
 174   for (Dct = 0; Dct < MAX_DCTS_PER_NODE_DA; Dct++) {
 175     MCTPtr->DctData[Dct].Dct = Dct;
 176     MCTPtr->DctData[Dct].ChannelCount = MAX_CHANNELS_PER_DCT_DA;
 177     MCTPtr->DctData[Dct].ChData = (CH_DEF_STRUCT *) AllocHeapParams.BufferPtr;
 178     AllocHeapParams.BufferPtr += MAX_CHANNELS_PER_DCT_DA * sizeof (CH_DEF_STRUCT);
 179   }
 180   NBPtr->PSBlock = (MEM_PS_BLOCK *) AllocHeapParams.BufferPtr;
 181
 182   //
 183   // Initialize Socket List
 184   //
 185   for (Dct = 0; Dct < MAX_DCTS_PER_NODE_DA; Dct++) {
 186     MemPtr->SocketList[MCTPtr->SocketId].ChannelPtr[Dct] = &(MCTPtr->DctData[Dct].ChData[0]);
 187     MemPtr->SocketList[MCTPtr->SocketId].TimingsPtr[Dct] = &(MCTPtr->DctData[Dct].Timings);
 188     MCTPtr->DctData[Dct].ChData[0].ChannelID = Dct;
 189   }
 190
 191   MemNInitNBDataDA (NBPtr);
 192
 193   FeatPtr->InitCPG (NBPtr);
 194   NBPtr->FeatPtr = FeatPtr;
 195   FeatPtr->InitHwRxEn (NBPtr);
 196   //
 197   // Calculate SPD Offsets per channel and assign pointers to the data.  At this point, we calculate the Node-Dct-Channel
 198   // centric offsets and store the pointers to the first DIMM of each channel in the Channel Definition struct for that
 199   // channel.  This pointer is then used later to calculate the offsets to be used for each logical dimm once the
 200   // dimm types(QR or not) are known. This is done in the Technology block constructor.
 201   //
 202   // Calculate the SpdSocketIndex separately from the SpdChannelIndex.
 203   // This will facilitate modifications due to some processors that might
 204   // map the DCT-CHANNEL differently.
 205   //
 206   SpdSocketIndex = GetSpdSocketIndex (NBPtr->RefPtr->PlatformMemoryConfiguration, NBPtr->MCTPtr->SocketId, &MemPtr->StdHeader);
 207   //
 208   // Traverse the Dct/Channel structures
 209   //
 210   for (Dct = 0; Dct < MAX_DCTS_PER_NODE_DA; Dct++) {
 211     for (Channel = 0; Channel < MAX_CHANNELS_PER_DCT_DA; Channel++) {
 212       //
 213       // Calculate the number of Dimms on this channel using the
 214       //   die/dct/channel to Socket/channel conversion.
 215       //
 216       SpdChannelIndex = GetSpdChannelIndex (NBPtr->RefPtr->PlatformMemoryConfiguration,
 217                                             NBPtr->MCTPtr->SocketId,
 218                                             MemNGetSocketRelativeChannelNb (NBPtr, Dct, Channel),
 219                                             &MemPtr->StdHeader);
 220       NBPtr->MCTPtr->DctData[Dct].ChData[Channel].SpdPtr = &(MemPtr->SpdDataStructure[SpdSocketIndex + SpdChannelIndex]);
 221     }
 222   }
 223
 224   MemNSwitchDCTNb (NBPtr, 0);
 225   return TRUE;
 226 }
 227
 228 /* -----------------------------------------------------------------------------*/
 229 /**
 230  *
 231  *   This function initializes member functions and variables of NB block.
 232  *
 233  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 234  *
 235  */
 236
 237 VOID
 238 MemNInitNBDataDA (
 239   IN OUT   MEM_NB_BLOCK *NBPtr
 240   )
 241 {
 242   INT32 i;
 243
 244   NBPtr->DctCachePtr = NBPtr->DctCache;
 245   NBPtr->PsPtr = NBPtr->PSBlock;
 246
 247   InitNBRegTableDA (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_DA;
 252   NBPtr->ChannelCount = MAX_CHANNELS_PER_DCT_DA;
 253   NBPtr->NodeCount = MAX_NODES_SUPPORTED_DA;
 254   NBPtr->Ganged = FALSE;
 255   NBPtr->PosTrnPattern = POS_PATTERN_72B;
 256   NBPtr->MemCleared = FALSE;
 257   NBPtr->StartupSpeed = DDR800_FREQUENCY;
 258   NBPtr->RcvrEnDlyLimit = 0xFF;
 259   NBPtr->DefDctSelIntLvAddr = 3;
 260   NBPtr->CsRegMsk = 0x1FF83FE0;
 261
 262   for (i = 0; i < EnumSize; i++) {
 263     NBPtr->IsSupported[i] = FALSE;
 264   }
 265
 266   LibAmdMemFill (NBPtr->DctCache, 0, sizeof (NBPtr->DctCache), &NBPtr->MemPtr->StdHeader);
 267
 268   NBPtr->SetMaxLatency = MemNSetMaxLatencyNb;
 269   NBPtr->getMaxLatParams = MemNGetMaxLatParamsNb;
 270   NBPtr->GetSysAddr = MemNGetMCTSysAddrNb;
 271   NBPtr->InitializeMCT = MemNInitializeMctDA;
 272   NBPtr->FinalizeMCT = MemNFinalizeMctDA;
 273   NBPtr->SendMrsCmd = MemNSendMrsCmdDA;
 274   NBPtr->sendZQCmd = MemNSendZQCmdNb;
 275   NBPtr->WritePattern = MemNWritePatternDA;
 276   NBPtr->ReadPattern = MemNReadPatternDA;
 277   NBPtr->GenHwRcvEnReads = (VOID (*) (MEM_NB_BLOCK *, UINT32)) memDefRet;
 278   NBPtr->CompareTestPattern = MemNCompareTestPatternNb;
 279   NBPtr->InsDlyCompareTestPattern = MemNInsDlyCompareTestPatternNb;
 280   NBPtr->StitchMemory = MemNStitchMemoryNb;
 281   NBPtr->AutoConfig = memNAutoConfigDA;
 282   NBPtr->PlatformSpec = MemNPlatformSpecNb;
 283   NBPtr->InitMCT = MemNInitMCTNb;
 284   NBPtr->DisableDCT = MemNDisableDCTNb;
 285   NBPtr->StartupDCT = MemNStartupDCTNb;
 286   NBPtr->SyncTargetSpeed = MemNSyncTargetSpeedNb;
 287   NBPtr->ChangeFrequency = MemNChangeFrequencyNb;
 288   NBPtr->RampUpFrequency = MemNRampUpFrequencyNb;
 289   NBPtr->ChangeNbFrequency = (BOOLEAN (*) (MEM_NB_BLOCK *)) memDefFalse;
 290   NBPtr->ProgramCycTimings = MemNProgramCycTimingsNb;
 291   NBPtr->SyncDctsReady = MemNSyncDctsReadyNb;
 292   NBPtr->HtMemMapInit = MemNHtMemMapInitNb;
 293   NBPtr->SyncAddrMapToAllNodes = MemNSyncAddrMapToAllNodesNb;
 294   NBPtr->CpuMemTyping = MemNCPUMemTypingNb;
 295   NBPtr->BeforeDqsTraining = MemNBeforeDQSTrainingNb;
 296   NBPtr->AfterDqsTraining = (VOID (*) (MEM_NB_BLOCK *)) memDefRet;
 297   NBPtr->OtherTiming = MemNOtherTimingDA;
 298   NBPtr->UMAMemTyping = MemNUMAMemTypingNb;
 299   NBPtr->TechBlockSwitch = MemNTechBlockSwitchNb;
 300   NBPtr->MemNCmnGetSetFieldNb = MemNCmnGetSetFieldDA;
 301   NBPtr->SetEccSymbolSize = (VOID (*) (MEM_NB_BLOCK *)) memDefRet;
 302   NBPtr->TrainingFlow = MemNTrainingFlowNb;
 303   NBPtr->MinDataEyeWidth = MemNMinDataEyeWidthNb;
 304   MemNInitNBDataNb (NBPtr);
 305   NBPtr->PollBitField = MemNPollBitFieldNb;
 306   NBPtr->BrdcstCheck = MemNBrdcstCheckNb;
 307   NBPtr->BrdcstSet = MemNBrdcstSetNb;
 308   NBPtr->GetTrainDly = MemNGetTrainDlyNb;
 309   NBPtr->SetTrainDly = MemNSetTrainDlyNb;
 310   NBPtr->PhyFenceTraining = MemNPhyFenceTrainingNb;
 311   NBPtr->GetSysAddr = MemNGetMCTSysAddrNb;
 312   NBPtr->RankEnabled = MemNRankEnabledNb;
 313   NBPtr->MemPPhyFenceTrainingNb = MemNTrainPhyFenceNb;
 314   NBPtr->MemNPlatformSpecificFormFactorInitNb = MemNPlatformSpecificFormFactorInitDA;
 315   NBPtr->MemNBeforePlatformSpecNb = MemNBeforePlatformSpecDA;
 316   NBPtr->MemNcmnGetSetTrainDly = MemNcmnGetSetTrainDlyNb;
 317   NBPtr->MemPNodeMemBoundaryNb = MemPNodeMemBoundaryDA;
 318   NBPtr->MemNInitPhyComp = MemNInitPhyCompNb;
 319   NBPtr->GetSocketRelativeChannel = MemNGetSocketRelativeChannelNb;
 320   NBPtr->MemNBeforeDramInitNb = MemNBeforeDramInitDA;
 321   NBPtr->MemNPFenceAdjustNb = (VOID (*) (MEM_NB_BLOCK *, INT16 *)) memDefRet;
 322   NBPtr->GetTrainDlyParms = MemNGetTrainDlyParmsNb;
 323   NBPtr->TrainingPatternInit = MemNTrainingPatternInitNb;
 324   NBPtr->TrainingPatternFinalize = MemNTrainingPatternFinalizeNb;
 325   NBPtr->GetApproximateWriteDatDelay = MemNGetApproximateWriteDatDelayNb;
 326   NBPtr->CSPerChannel = MemNCSPerChannelNb;
 327   NBPtr->CSPerDelay = MemNCSPerDelayNb;
 328   NBPtr->FlushPattern = MemNFlushPatternNb;
 329   NBPtr->MemNCapSpeedBatteryLife = MemNCapSpeedBatteryLifeDA;
 330   NBPtr->GetUmaSize = MemNGetUmaSizeNb;
 331   NBPtr->GetMemClkFreqId = MemNGetMemClkFreqIdNb;
 332   NBPtr->EnableSwapIntlvRgn = MemNEnableSwapIntlvRgnNb;
 333   NBPtr->WaitXMemClks = MemNWaitXMemClksNb;
 334   NBPtr->MemNGetDramTerm = MemNGetDramTermNb;
 335   NBPtr->MemNGetDynDramTerm = MemNGetDynDramTermNb;
 336   NBPtr->MemNGetMR0CL = MemNGetMR0CLNb;
 337   NBPtr->MemNGetMR0WR = MemNGetMR0WRNb;
 338   NBPtr->MemNSaveMR0 = (VOID (*) (MEM_NB_BLOCK *, UINT32)) memDefRet;
 339   NBPtr->MemNGetMR2CWL = MemNGetMR2CWLNb;
 340   NBPtr->AllocateC6Storage = (VOID (*) (MEM_NB_BLOCK *)) memDefRet;
 341
 342   NBPtr->IsSupported[SetSpareEn] = TRUE;
 343   NBPtr->IsSupported[CheckSpareEn] = TRUE;
 344   NBPtr->IsSupported[SetDllShutDown] = TRUE;
 345   NBPtr->IsSupported[DimmBasedOnSpeed] = TRUE;
 346   NBPtr->IsSupported[CheckMaxDramRate] = TRUE;
 347   NBPtr->IsSupported[Check1GAlign] = TRUE;
 348   NBPtr->IsSupported[CheckMaxRdDqsDlyPtr] = TRUE;
 349   NBPtr->IsSupported[CheckPhyFenceTraining] = TRUE;
 350   NBPtr->IsSupported[CheckGetMCTSysAddr] = TRUE;
 351   NBPtr->IsSupported[CheckFindPSDct] = TRUE;
 352   NBPtr->IsSupported[CheckDllStdBy] = TRUE;
 353   NBPtr->IsSupported[CheckSlewWithMarginImprv] = TRUE;
 354   NBPtr->IsSupported[CheckDllSpeedUp] = TRUE;
 355   NBPtr->IsSupported[CheckDllRegDis] = TRUE;
 356   NBPtr->IsSupported[ForceEnMemHoleRemapping] = TRUE;
 357 }
 358
 359 /* -----------------------------------------------------------------------------*/
 360 /**
 361  *
 362  *
 363  *   This function initializes the default values in the MEM_DATA_STRUCT
 364  *
 365  *     @param[in,out]   *MemPtr  - Pointer to the MEM_DATA_STRUCT
 366  *
 367  */
 368 VOID
 369 MemNInitDefaultsDA (
 370   IN OUT   MEM_DATA_STRUCT *MemPtr
 371   )
 372 {
 373   UINT8 Socket;
 374   UINT8 Channel;
 375   MEM_PARAMETER_STRUCT *RefPtr;
 376   ASSERT (MemPtr != NULL);
 377   RefPtr = MemPtr->ParameterListPtr;
 378
 379   // Memory Map/Mgt.
 380   // Mask Bottom IO with 0xF8 to force hole size to have granularity of 128MB
 381   RefPtr->BottomIo = 0xE0;
 382   RefPtr->UmaMode = UserOptions.CfgUmaMode;
 383   RefPtr->UmaSize = UserOptions.CfgUmaSize;
 384   RefPtr->MemHoleRemapping = TRUE;
 385   RefPtr->LimitMemoryToBelow1Tb = UserOptions.CfgLimitMemoryToBelow1Tb;
 386
 387   // Dram Timing
 388   RefPtr->UserTimingMode = UserOptions.CfgTimingModeSelect;
 389   RefPtr->MemClockValue = UserOptions.CfgMemoryClockSelect;
 390   for (Socket = 0; Socket < MAX_SOCKETS_SUPPORTED; Socket++) {
 391     for (Channel = 0; Channel < MAX_CHANNELS_PER_SOCKET; Channel++) {
 392       MemPtr->SocketList[Socket].ChannelPtr[Channel] = NULL;
 393       MemPtr->SocketList[Socket].TimingsPtr[Channel] = NULL;
 394     }
 395   }
 396
 397   // Memory Clear
 398   RefPtr->EnableMemClr = TRUE;
 399
 400   // TableBasedAlterations
 401   RefPtr->TableBasedAlterations = NULL;
 402
 403   // Platform config table
 404   RefPtr->PlatformMemoryConfiguration = DefaultPlatformMemoryConfiguration;
 405
 406   // Memory Restore
 407   RefPtr->MemRestoreCtl = FALSE;
 408   RefPtr->SaveMemContextCtl = FALSE;
 409   AmdS3ParamsInitializer (&RefPtr->MemContext);
 410
 411   // Dram Configuration
 412   RefPtr->EnableBankIntlv = UserOptions.CfgMemoryEnableBankInterleaving;
 413   RefPtr->EnableNodeIntlv = UserOptions.CfgMemoryEnableNodeInterleaving;
 414   RefPtr->EnableChannelIntlv = UserOptions.CfgMemoryChannelInterleaving;
 415   RefPtr->EnableBankSwizzle = UserOptions.CfgBankSwizzle;
 416   RefPtr->EnableParity = UserOptions.CfgMemoryParityEnable;
 417   RefPtr->EnableOnLineSpareCtl = UserOptions.CfgOnlineSpare;
 418
 419   // Dram Power
 420   RefPtr->EnablePowerDown = UserOptions.CfgMemoryPowerDown;
 421
 422   // ECC
 423   RefPtr->EnableEccFeature = UserOptions.CfgEnableEccFeature;
 424
 425   // Vref
 426   RefPtr->ExternalVrefCtl = UserOptions.CfgExternalVrefCtlFeature;
 427
 428   //Training Mode
 429   RefPtr->ForceTrainMode = UserOptions.CfgForceTrainMode;
 430 }
 431
 432 /*-----------------------------------------------------------------------------*/
 433 /**
 434  *
 435  *      This function writes training pattern
 436  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 437  *     @param[in] Pattern[] - Pattern to write
 438  *     @param[in] Address - System Address [47:16]
 439  *     @param[in] ClCount - Number of cache lines
 440  *
 441  */
 442
 443 VOID
 444 MemNWritePatternDA (
 445   IN OUT   MEM_NB_BLOCK *NBPtr,
 446   IN       UINT32 Address,
 447   IN       UINT8 Pattern[],
 448   IN       UINT16 ClCount
 449   )
 450 {
 451   Address = MemUSetUpperFSbase (Address, NBPtr->MemPtr);
 452   MemUWriteCachelines (Address, Pattern, ClCount);
 453 }
 454
 455 /*-----------------------------------------------------------------------------*/
 456 /**
 457  *
 458  *      This function reads training pattern
 459  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 460  *     @param[in] Buffer[] - Buffer to fill
 461  *     @param[in] Address - System Address [47:16]
 462  *     @param[in] ClCount - Number of cache lines
 463  *
 464  */
 465
 466 VOID
 467 MemNReadPatternDA (
 468   IN OUT   MEM_NB_BLOCK *NBPtr,
 469   IN       UINT8 Buffer[],
 470   IN       UINT32 Address,
 471   IN       UINT16 ClCount
 472   )
 473 {
 474   Address = MemUSetUpperFSbase (Address, NBPtr->MemPtr);
 475   MemUReadCachelines (Buffer, Address, ClCount);
 476 }
 477 /* -----------------------------------------------------------------------------*/
 478 /**
 479  *
 480  *   This function initiates DQS training for Server NB
 481  *
 482  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 483  *
 484  */
 485
 486 BOOLEAN
 487 memNEnableTrainSequenceDA (
 488   IN OUT   MEM_NB_BLOCK *NBPtr
 489   )
 490 {
 491   BOOLEAN Retval;
 492   Retval = TRUE;
 493   if (!MemNIsIdSupportedDA (NBPtr, &(NBPtr->MemPtr->DiesPerSystem[NBPtr->MCTPtr->NodeId].LogicalCpuid))) {
 494     Retval = FALSE;
 495   }
 496   return Retval;
 497 }
 498