src/vendorcode/amd/agesa/f15/Proc/Mem/NB/C32/mnc32.c

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