init. 1AQQW051HEADmaster

1 files changed, 529 insertions, 0 deletions

diff --git a/ReferenceCode/Chipset/SystemAgent/MemoryInit/Pei/Source/Api/MrcBdat.c b/ReferenceCode/Chipset/SystemAgent/MemoryInit/Pei/Source/Api/MrcBdat.c
new file mode 100644
index 0000000..7670487
--- /dev/null
+++ b/ReferenceCode/Chipset/SystemAgent/MemoryInit/Pei/Source/Api/MrcBdat.c
@@ -0,0 +1,529 @@
+/** @file
+  Copies the memory related timing and configuration information into the
+  Compatible BIOS data (BDAT) table.
+
+@copyright
+  Copyright (c) 2010 - 2012 Intel Corporation. All rights reserved.
+  This software and associated documentation (if any) is furnished
+  under a license and may only be used or copied in accordance
+  with the terms of the license. Except as permitted by such
+  license, no part of this software or documentation may be
+  reproduced, stored in a retrieval system, or transmitted in any
+  form or by any means without the express written consent of
+  Intel Corporation.
+
+  This file contains an 'Intel Peripheral Driver' and uniquely
+  identified as "Intel Reference Module" and is
+  licensed for Intel CPUs and chipsets under the terms of your
+  license agreement with Intel or your vendor.  This file may
+  be modified by the user, subject to additional terms of the
+  license agreement.
+**/
+
+#include "MrcTypes.h"
+#include "MrcApi.h"
+#include "MrcGlobal.h"
+#include "MrcOem.h"
+#include "MrcSpdProcessing.h"
+#include "McAddress.h"
+
+#ifdef BDAT_SUPPORT
+#define TBD                       0
+#define CRC_SEED                  0
+#define CRC_XOR_MASK              0x1021
+#define MAX_UINT8_VALUE           (((1UL) << CHAR_BITS) - 1)
+#define HOST_BRIDGE_BUS           0
+#define HOST_BRIDGE_DEVICE        0
+#define HOST_BRIDGE_FUNCTION      0
+#define HOST_BRIDGE_OFFSET_DEVID  0
+#define HOST_BRIDGE_OFFSET_REVID  8
+#define CopyMem                   MrcOemMemoryCpy
+#define GetCrc16                  GetDimmCrc
+
+typedef U8  UINT8;
+typedef U16 UINT16;
+
+/**
+  @brief
+  Finds the window value for the given DQ value and if it is less than the
+    current value, then save the end point values.
+
+    @param[in, out] Rank1         - Pointer to the first rank training value (left or low).
+    @param[in, out] Rank2         - Pointer to the second rank training value (right or high).
+    @param[in, out] CurrentWindow - The current window value.
+    @param[in] Value1        - The first training value (left or low).
+    @param[in] Value2        - The second training value (right or high).
+
+    @retval Nothing.
+**/
+void
+ConvertDq2Rank (
+  IN OUT UINT8        *Rank1,
+  IN OUT UINT8        *Rank2,
+  IN OUT UINT8        *CurrentWindow,
+  IN     const UINT8  Value1,
+  IN     const UINT8  Value2
+  )
+{
+  UINT8 Window;  // The calculated window value.
+
+  Window = MAX (Value1, Value2) - MIN (Value1, Value2);
+  if (Window < *CurrentWindow) {
+    *CurrentWindow  = Window;
+    *Rank1          = Value1;
+    *Rank2          = Value2;
+  } // if
+  return;
+}
+
+/**
+@brief
+  Initialize the memory rank margin area of the RMT_STRUCTURE.
+
+  @param[in] MrcData - The MRC "global data".
+  @param[in, out] RmtRankMargin - Pointer to the start of the rank margin information in the RMT table.
+  @param[in] RmtDq         - Pointer to the start of the dq margin information in the RMT table.
+
+  @retval Nothing.
+**/
+void
+MrcFillRmtRankMargin (
+  IN     const MrcParameters  *MrcData,
+  IN OUT RmtRankMargin        *RmtRankMargin,
+  IN     RmtDqMargin          *RmtDq
+  )
+{
+  RmtDqMargin *RmtDqMargin;         // Pointer to the current DQ margin in the RMT structure.
+  UINT8       Dq;                   // DQ number in the rank.
+  UINT8       DqEnd;
+  UINT8       SmallestWindowRxDq;   // The smallest of the Rx DQ windows.
+  UINT8       SmallestWindowTxDq;   // The smallest of the Tx DQ windows.
+  UINT8       SmallestWindowRxVref; // The smallest of the Rx Vref windows.
+  UINT8       SmallestWindowTxVref; // The smallest of the Tx Vref windows.
+
+  SmallestWindowRxDq   = (UINT8) MAX_UINT8_VALUE;
+  SmallestWindowTxDq   = (UINT8) MAX_UINT8_VALUE;
+  SmallestWindowRxVref = (UINT8) MAX_UINT8_VALUE;
+  SmallestWindowTxVref = (UINT8) MAX_UINT8_VALUE;
+  DqEnd                = (MrcData->SysOut.Outputs.EccSupport) ? MAX_DQ : (MAX_DQ - MAX_BITS);
+  for (Dq = 0; Dq < DqEnd; Dq++) {
+    RmtDqMargin = &RmtDq[Dq];
+    ConvertDq2Rank (
+      &RmtRankMargin->RxDqLeft,
+      &RmtRankMargin->RxDqRight,
+      &SmallestWindowRxDq,
+      RmtDqMargin->RxDqLeft,
+      RmtDqMargin->RxDqRight
+      );
+    ConvertDq2Rank (
+      &RmtRankMargin->TxDqLeft,
+      &RmtRankMargin->TxDqRight,
+      &SmallestWindowTxDq,
+      RmtDqMargin->TxDqLeft,
+      RmtDqMargin->TxDqRight
+      );
+    ConvertDq2Rank (
+      &RmtRankMargin->RxVrefLow,
+      &RmtRankMargin->RxVrefHigh,
+      &SmallestWindowRxVref,
+      RmtDqMargin->RxVrefLow,
+      RmtDqMargin->RxVrefHigh
+      );
+    ConvertDq2Rank (
+      &RmtRankMargin->TxVrefLow,
+      &RmtRankMargin->TxVrefHigh,
+      &SmallestWindowTxVref,
+      RmtDqMargin->TxVrefLow,
+      RmtDqMargin->TxVrefHigh
+      );
+  } // Dq loop
+  return;
+}
+
+/**
+@brief
+  Initialize the memory DQ area of the RMT_STRUCTURE.
+
+  @param[in, out] RmtDq   - Pointer to the start of the DQ information in the RMT table.
+  @param[in] Channel - Specific Channel
+  @param[in] Dimm    - Specific Dimm
+  @param[in] Rank    - Specific Rank
+  @param[in] MrcData - The MRC "global data".
+
+  @retval Nothing.
+**/
+void
+MrcFillRmtDqMargin (
+  IN OUT RmtDqMargin          *RmtDq,
+  IN     const UINT8          Controller,
+  IN     const UINT8          Channel,
+  IN     const UINT8          Dimm,
+  IN     const UINT8          Rank,
+  IN     const MrcParameters  *MrcData
+  )
+{
+  const MrcOutput       *Outputs;
+  const MrcChannelOut   *ChannelOut;
+  const MrcDqTimeMargin *RxDqMargin;      // Pointer to the output portion of the MRC global data area.
+  const MrcDqTimeMargin *TxDqMargin;      // Pointer to the output portion of the MRC global data area.
+  const MrcDqVrefMargin *RxVrefDqMargin;  // Pointer to the output portion of the MRC global data area.
+  const MrcDqVrefMargin *TxVrefDqMargin;  // Pointer to the output portion of the MRC global data area.
+  RmtDqMargin           *RmtDqMargin;     // Pointer to the current DQ margin in the RMT structure.
+  UINT8                 RankInChannel;
+  UINT8                 Sdram;
+  UINT8                 Dq;               // DQ number in the rank.
+  UINT8                 DqEnd;
+  UINT8                 Bit;
+
+  Outputs       = &MrcData->SysOut.Outputs;
+  ChannelOut    = &Outputs->Controller[Controller].Channel[Channel];
+  RankInChannel = (Dimm * MAX_RANK_IN_DIMM) + Rank;
+  DqEnd         = (Outputs->EccSupport) ? MAX_DQ : (MAX_DQ - MAX_BITS);
+  for (Dq = 0; Dq < DqEnd; Dq++) {
+    Sdram                   = Dq / CHAR_BITS;
+    Bit                     = Dq % CHAR_BITS;
+    RxDqMargin              = &ChannelOut->RxDqPb[RankInChannel][Sdram][Bit];
+    TxDqMargin              = &ChannelOut->TxDqPb[RankInChannel][Sdram][Bit];
+    RxVrefDqMargin          = &ChannelOut->RxDqVrefPb[RankInChannel][Sdram][Bit];
+    TxVrefDqMargin          = &ChannelOut->TxDqVrefPb[RankInChannel][Sdram][Bit];
+    RmtDqMargin             = &RmtDq[Dq];
+    RmtDqMargin->RxDqLeft   = RxDqMargin->Left;
+    RmtDqMargin->RxDqRight  = RxDqMargin->Right;
+    RmtDqMargin->TxDqLeft   = TxDqMargin->Left;
+    RmtDqMargin->TxDqRight  = TxDqMargin->Right;
+    RmtDqMargin->RxVrefLow  = RxVrefDqMargin->Low;
+    RmtDqMargin->RxVrefHigh = RxVrefDqMargin->High;
+    RmtDqMargin->TxVrefLow  = TxVrefDqMargin->Low;
+    RmtDqMargin->TxVrefHigh = TxVrefDqMargin->High;
+  } // Dq loop
+  return;
+}
+
+/**
+@brief
+  Initialize the memory rank training area of the RMT_STRUCTURE.
+
+  @param[in, out] RmtRankTraining - Pointer to the start of the rank training information in the RMT table.
+  @param[in] Channel         - Specific Channel
+  @param[in] Dimm            - Specific Dimm
+  @param[in] Rank            - Specific Rank
+  @param[in] MrcData         - The MRC "global data".
+
+  @retval Nothing.
+**/
+void
+MrcFillRmtRankTraining (
+  IN OUT RmtRankTraining      *RmtRankTraining,
+  IN     const UINT8          Controller,
+  IN     const UINT8          Channel,
+  IN     const UINT8          Dimm,
+  IN     const UINT8          Rank,
+  IN     const MrcParameters  *MrcData
+  )
+{
+  const MrcOutput     *Outputs;     // Pointer to the output portion of the MRC global data area.
+  const MrcChannelOut *ChannelOut;  // Pointer to the channel portion of the MRC global data area.
+  UINT8               Index;
+  UINT8               RankInChannel;
+  UINT8               Sdram;
+  UINT8               Strobe;
+
+  Outputs       = &MrcData->SysOut.Outputs;
+  ChannelOut    = &Outputs->Controller[Controller].Channel[Channel];
+  RankInChannel = (Dimm * MAX_RANK_IN_DIMM) + Rank;
+  for (Strobe = 0; Strobe < MAX_STROBE; Strobe++) {
+    Sdram = Strobe / 2;
+    RmtRankTraining->RecEnDelay[Strobe] = ChannelOut->RcvEn[RankInChannel][Sdram];
+    RmtRankTraining->WlDelay[Strobe]    = ChannelOut->WlDelay[RankInChannel][Sdram];
+    RmtRankTraining->RxDqDelay[Strobe]  = (Strobe % 2)
+                                        ? ChannelOut->RxDqsN[RankInChannel][Sdram]
+                                        : ChannelOut->RxDqsP[RankInChannel][Sdram];
+    RmtRankTraining->TxDqDelay[Strobe]  = ((U8) (ChannelOut->TxDq[RankInChannel][Sdram] >> 6)) & 7;
+  } // Strobe loop
+  RmtRankTraining->ClkDelay = ChannelOut->ClkPiCode[RankInChannel];
+  RmtRankTraining->CtlDelay = ChannelOut->CtlPiCode[RankInChannel];
+  for (Index = 0; Index < (sizeof (RmtRankTraining->CmdDelay) / sizeof (RmtRankTraining->CmdDelay[0])); Index++) {
+    RmtRankTraining->CmdDelay[Index] = TBD;  // Need to implement code.
+  } // Index loop
+  RmtRankTraining->IoLatency = ChannelOut->IoLatency[RankInChannel];
+  RmtRankTraining->Roundtrip = ChannelOut->RTLatency[RankInChannel];
+  return;
+}
+
+/**
+@brief
+  Initialize the memory rank area of the RMT_STRUCTURE.
+
+  @param[in, out] RmtRank  - Pointer to the start of the rank information in the RMT table.
+  @param[in] MrcData  - The MRC "global data".
+  @param[in] Channel  - Current channel number.
+  @param[in] Dimm     - Current dimm number.
+
+  @retval Nothing.
+**/
+void
+MrcFillRmtRankStructure (
+  IN OUT RmtRankList         *RmtRank,
+  IN     const MrcParameters *MrcData,
+  IN     UINT8               Controller,
+  IN     UINT8               Channel,
+  IN     UINT8               Dimm
+)
+{
+  const MrcOutput     *Outputs;          // Pointer to the output portion of the MRC global data area.
+  const MrcChannelOut *ChannelOut;       // Pointer to the DIMM output portion of the MRC global data area.
+  const MrcDimmOut    *DimmOut;          // Pointer to the DIMM output portion of the MRC global data area.
+  RmtRankList         *RmtRankLists;     // Pointer to the current rank list in the RMT structure.
+  RmtRankTraining     *RmtRankTraining;  // Pointer to the current rank training in the RMT structure.
+  UINT8               Rank;              // Rank count for sequencing.
+  UINT8               RankInChannel;     // Rank number in a channel.
+
+  Outputs    = &MrcData->SysOut.Outputs;
+  ChannelOut = &Outputs->Controller[Controller].Channel[Channel];
+  DimmOut    = &ChannelOut->Dimm[Dimm];
+  for (Rank = 0; (Rank < MAX_RANK_IN_DIMM) && (Rank < DimmOut->RankInDIMM); Rank++) {
+    RmtRankLists                    = &RmtRank[Rank];
+    RmtRankTraining                 = &RmtRankLists->RankTraining;
+    RankInChannel                   = (Dimm * MAX_RANK_IN_DIMM) + Rank;
+    RmtRankLists->RankEnabled       = TRUE;
+    RmtRankLists->RankMarginEnabled = TRUE;
+    RmtRankLists->DqMarginEnabled   = TRUE;
+    MrcFillRmtDqMargin (&RmtRankLists->DqMargin[0], Controller, Channel, Dimm, Rank, MrcData);
+    MrcFillRmtRankMargin (MrcData, &RmtRankLists->RankMargin, &RmtRankLists->DqMargin[0]);
+    MrcFillRmtRankTraining (&RmtRankLists->RankTraining, Controller, Channel, Dimm, Rank, MrcData);
+    CopyMem (
+      (UINT8 *) &RmtRankLists->RankMRS.ModeRegister[0],
+      (UINT8 *) &DimmOut->Rank[Rank].MR[0],
+      sizeof (RmtRankMrs)
+      );
+    RmtRankLists->RankMargin.CmdLeft      = ChannelOut->Command[RankInChannel].Left;
+    RmtRankLists->RankMargin.CmdRight     = ChannelOut->Command[RankInChannel].Right;
+    RmtRankLists->RankMargin.CmdVrefLow   = ChannelOut->Command[RankInChannel].Low;
+    RmtRankLists->RankMargin.CmdVrefHigh  = ChannelOut->Command[RankInChannel].High;
+    RmtRankLists->RankMargin.RecvenLeft   = ChannelOut->ReceiveEnable[RankInChannel].Left;
+    RmtRankLists->RankMargin.RecvenRight  = ChannelOut->ReceiveEnable[RankInChannel].Right;
+    RmtRankLists->RankMargin.WrLevelLeft  = ChannelOut->WriteLevel[RankInChannel].Left;
+    RmtRankLists->RankMargin.WrLevelRight = ChannelOut->WriteLevel[RankInChannel].Right;
+  }  // Rank loop
+  return;
+}
+
+/**
+@brief
+  Initialize the memory dimm area of the RMT_STRUCTURE.
+
+  @param[in, out] RmtDimm - Pointer to the start of the dimm information in the RMT table.
+  @param[in] MrcData - The MRC "global data".
+  @param[in] Channel - Current channel number.
+
+  @retval Nothing.
+**/
+void
+MrcFillRmtDimmStructure (
+  IN OUT RmtDimmList         *RmtDimm,
+  IN     const MrcParameters *MrcData,
+  IN     UINT8               Controller,
+  IN     UINT8               Channel
+  )
+{
+  const MrcInput      *Inputs;              // Pointer to the input portion of the MRC global data area.
+  const MrcDimmIn     *DimmIn;              // Pointer to the DIMM input portion of the MRC global data area.
+  const MrcSpd        *SpdIn;               // Pointer to the SPD input portion of the MRC global data area.
+  const MrcOutput     *Outputs;             // Pointer to the output portion of the MRC global data area.
+  const MrcChannelOut *ChannelOut;          // Pointer to the channel output portion of the MRC global data area.
+  const MrcDimmOut    *DimmOut;             // Pointer to the DIMM output portion of the MRC global data area.
+  RmtDimmList         *RmtDimmList;         // Pointer to the current DIMM in the RMT structure.
+  RmtSpd              *RmtSpdList;          // Pointer to the current SPD in the RMT structure.
+  UINT8               Dimm;                 // Dimm count for sequencing.
+
+  Inputs     = &MrcData->SysIn.Inputs;
+  Outputs    = &MrcData->SysOut.Outputs;
+  ChannelOut = &Outputs->Controller[Controller].Channel[Channel];
+  for (Dimm = 0; Dimm < MAX_DIMMS_IN_CHANNEL; Dimm++) {
+    DimmOut = &ChannelOut->Dimm[Dimm];
+    if (DimmOut->Status == DIMM_PRESENT) {
+      RmtDimmList               = &RmtDimm[Dimm];
+      RmtSpdList                = &RmtDimmList->SpdBytes;
+      DimmIn                    = &Inputs->Controller[Controller].Channel[Channel].Dimm[Dimm];
+      SpdIn                     = &DimmIn->Spd;
+      RmtDimmList->DimmEnabled  = TRUE;
+      CopyMem ((UINT8 *) &RmtSpdList->SpdData[0], (UINT8 *) SpdIn, 128);
+#if (defined SUPPORT_XMP && SUPPORT_XMP == SUPPORT)
+      CopyMem (&RmtSpdList->SpdData[128], ((UINT8 *) SpdIn) + 128, 128);
+#endif // (defined SUPPORT_XMP && SUPPORT_XMP == SUPPORT)
+      CopyMem ((UINT8 *) &RmtSpdList->SpdValid, (UINT8 *) &DimmIn->SpdValid, sizeof (RmtDimmList->SpdBytes.SpdValid));
+
+      //
+      // Initialize the memory rank area of the RMT_STRUCTURE.
+      //
+      MrcFillRmtRankStructure (&RmtDimmList->RankList[0], MrcData, Controller, Channel, Dimm);
+    } // end if
+  } // Dimm loop
+  return;
+}
+
+/**
+@brief
+  Initialize the memory channel area of the RMT_STRUCTURE.
+
+  @param[in, out] RmtChannel - Pointer to the start of the channel information in the RMT table.
+  @param[in] MrcData     - The MRC "global data".
+
+  @retval Nothing.
+**/
+void
+MrcFillRmtChannelStructure (
+  IN OUT RmtChannelList      *RmtChannel,
+  IN     const MrcParameters *MrcData,
+  IN     const UINT8         Controller
+  )
+{
+  const MrcOutput *Outputs;             // Pointer to the output portion of the MRC global data area.
+  RmtChannelList  *RmtChannelList;      // Pointer to the current channel in the RMT structure.
+  UINT8           Channel;              // Channel count for sequencing.
+
+  Outputs = &MrcData->SysOut.Outputs;
+  for (Channel = 0; Channel < MAX_CHANNEL; Channel++) {
+    if (Outputs->Controller[Controller].Channel[Channel].Status == CHANNEL_PRESENT) {
+      RmtChannelList                  = &RmtChannel[Channel];
+      RmtChannelList->ChannelEnabled  = TRUE;
+      RmtChannelList->NumDimmSlot     = MAX_DIMMS_IN_CHANNEL;
+
+      //
+      // Initialize the memory DIMM area of the RMT_STRUCTURE.
+      //
+      MrcFillRmtDimmStructure (&RmtChannelList->DimmList[0], MrcData, Controller, Channel);
+    } // end if
+  } // Channel loop
+  return;
+}
+
+/**
+@brief
+  Initialize the memory controller area of the RMT_STRUCTURE.
+
+  @param[in, out] RmtController - Pointer to the start of the controller information in the RMT table.
+  @param[in] MrcData        - The MRC "global data".
+
+  @retval Nothing.
+**/
+void
+MrcFillRmtControllerStructure (
+  IN OUT RmtControllerList   *RmtController,
+  IN     const MrcParameters *MrcData
+  )
+{
+  const MrcInput    *Inputs;
+  const MrcOutput   *Outputs;
+  RmtControllerList *RmtControllerList;
+  UINT8             Controller;
+  MrcVddSelect      VddVoltage;
+
+  Inputs     = &MrcData->SysIn.Inputs;
+  Outputs    = &MrcData->SysOut.Outputs;
+  VddVoltage = Outputs->VddVoltage[Inputs->MemoryProfile];
+  for (Controller = 0; Controller < MAX_CONTROLLERS; Controller++) {
+    if (Outputs->Controller[Controller].Status == CONTROLLER_PRESENT) {
+      RmtControllerList                       = &RmtController[Controller];
+      RmtControllerList->ControllerEnabled    = TRUE;
+      RmtControllerList->ControllerDeviceId   = Outputs->Controller[Controller].DeviceId;
+      RmtControllerList->ControllerRevisionId = Outputs->Controller[Controller].RevisionId;
+      RmtControllerList->MemoryFrequency      = (UINT16) (Outputs->Frequency / 10);
+      RmtControllerList->MemoryVoltage        = (UINT16) VddVoltage;
+      //
+      // Step unit = piStep * (tCK / 2048)
+      //
+      RmtControllerList->PiStep               = (UINT8) PI_STEP;
+      RmtControllerList->RecvenStep           = (UINT8) PI_STEP;
+      RmtControllerList->WrLevelStep          = (UINT8) PI_STEP;
+      if (VddVoltage > 0) {
+        //
+        // Step unit = __VrefStep * Vdd / 100
+        //
+        RmtControllerList->RxVrefStep  = (UINT16) RX_VREF (VddVoltage);
+        RmtControllerList->TxVrefStep  = (UINT16) TX_VREF (VddVoltage);
+        RmtControllerList->CaVrefStep  = (UINT16) CA_VREF (VddVoltage);
+      } else {
+        RmtControllerList->RxVrefStep  = 0;
+        RmtControllerList->TxVrefStep  = 0;
+        RmtControllerList->CaVrefStep  = 0;
+      }
+      //
+      // Initialize the memory channel area of the RMT_STRUCTURE.
+      //
+      MrcFillRmtChannelStructure (&RmtControllerList->ChannelList[0], MrcData, Controller);
+    } // Controller loop
+  }
+
+  return;
+}
+
+/**
+@brief
+  Fill the compatible data structure RMT with the information provided by
+  the memory initialization code.
+
+  @param[in, out] MrcData - Constant pointer to the Mrc data structure which conatins the Rmt structure to fill.
+
+  @retval Nothing.
+**/
+MrcStatus
+MrcFillRmtStructure (
+  IN OUT MrcParameters *const MrcData
+  )
+{
+  const UINT8       RmtHeaderSign[] = {'B', 'D', 'A', 'T', 'H', 'E', 'A', 'D'};
+  const MrcVersion  *Version;             // Pointer to the output portion of the MRC global data area.
+  RmtData           *Rmt;
+  RmtHeader         *RmtHeader;           // Pointer to the header data area in the RMT structure.
+  RmtSystem         *RmtSystem;           // Pointer to the system data area in the RMT structure.
+  const MrcInput    *Inputs;
+  MrcOutput         *Outputs;
+
+  Inputs  = &MrcData->SysIn.Inputs;
+  Outputs = &MrcData->SysOut.Outputs;
+  if (Inputs->RmtBdatEnable) {
+    //
+    // Initialize the header area of the RMT_STRUCTURE.
+    //
+    Rmt       = &MrcData->Rmt;
+    RmtHeader = &Rmt->RmtHeader;
+    CopyMem (&RmtHeader->BiosDataSignature[0], (UINT8 *) RmtHeaderSign, sizeof (RmtHeader->BiosDataSignature));
+    RmtHeader->BiosDataStructSize           = sizeof (RmtData);
+    RmtHeader->Version.S[PRIMARY_OFFSET]    = RMT_PRIMARY_VERSION;
+    RmtHeader->Version.S[SECONDARY_OFFSET]  = RMT_SECONDARY_VERSION;
+    RmtHeader->OemOffset                    = OEM_OFFSET;
+    RmtHeader->Reserved1 = (Inputs->BaseTime.Hours << 16) | (Inputs->BaseTime.Minutes << 8) | Inputs->BaseTime.Seconds;
+    RmtHeader->Reserved2 = (Inputs->BaseTime.Year << 16) | (Inputs->BaseTime.Month << 8) | Inputs->BaseTime.DayOfMonth;
+
+    //
+    // Initialize the system area of the RMT_STRUCTURE.
+    //
+    Version                               = &Outputs->Version;
+    RmtSystem                             = &Rmt->RmtSystem;
+    RmtSystem->RefCodeRevision.c.Major    = Version->Major;
+    RmtSystem->RefCodeRevision.c.Minor    = Version->Minor;
+    RmtSystem->RefCodeRevision.c.Revision = Version->Rev;
+    RmtSystem->RefCodeRevision.c.Build    = Version->Build;
+    RmtSystem->MaxController              = MAX_CONTROLLERS;
+    RmtSystem->MaxChannel                 = MAX_CHANNEL;
+    RmtSystem->MaxDimm                    = MAX_DIMMS_IN_CHANNEL;
+    RmtSystem->MaxRankDimm                = MAX_RANK_IN_DIMM;
+    RmtSystem->MaxStrobe                  = MAX_STROBE;
+    RmtSystem->MaxDq                      = MAX_DQ;
+    RmtSystem->MarginLoopCount            = Outputs->DQPatLC;
+    //
+    // Initialize the memory controller area of the RMT_STRUCTURE.
+    //
+    MrcFillRmtControllerStructure (&RmtSystem->ControllerList[0], MrcData);
+
+    //
+    // Initialize the CRC of the RMT_STRUCTURE.
+    // Ensure that the CRC calculation is the last field initialized.
+    //
+    GetCrc16 ((const UINT8 *const) Rmt, sizeof (RmtData), &Rmt->RmtHeader.Crc16);
+    MrcOemMmioWrite (NCDECS_CR_SCRATCHPAD_NCU_2_REG, (U32) Rmt, Inputs->MchBarBaseAddress);
+  } // end if
+  return mrcSuccess;
+}
+#endif // BDAT_SUPPORT