path: root/src/vendorcode/amd/agesa/f15tn/Proc/Mem/Main/mmConditionalPso.c

/* $NoKeywords:$ */
/**
 * @file
 *
 * mmConditionalPso.c
 *
 * Functions to support conditional entries in the Platform Specific Override Table
 *
 * @xrefitem bom "File Content Label" "Release Content"
 * @e project: AGESA
 * @e sub-project: (Mem/Main)
 * @e \$Revision: 63425 $ @e \$Date: 2011-12-22 11:24:10 -0600 (Thu, 22 Dec 2011) $
 *
 **/
/*****************************************************************************
*
* Copyright 2008 - 2012 ADVANCED MICRO DEVICES, INC.  All Rights Reserved.
*
* AMD is granting you permission to use this software (the Materials)
* pursuant to the terms and conditions of your Software License Agreement
* with AMD.  This header does *NOT* give you permission to use the Materials
* or any rights under AMD's intellectual property.  Your use of any portion
* of these Materials shall constitute your acceptance of those terms and
* conditions.  If you do not agree to the terms and conditions of the Software
* License Agreement, please do not use any portion of these Materials.
*
* CONFIDENTIALITY:  The Materials and all other information, identified as
* confidential and provided to you by AMD shall be kept confidential in
* accordance with the terms and conditions of the Software License Agreement.
*
* LIMITATION OF LIABILITY: THE MATERIALS AND ANY OTHER RELATED INFORMATION
* PROVIDED TO YOU BY AMD ARE PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY OF ANY KIND, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
* MERCHANTABILITY, NONINFRINGEMENT, TITLE, FITNESS FOR ANY PARTICULAR PURPOSE,
* OR WARRANTIES ARISING FROM CONDUCT, COURSE OF DEALING, OR USAGE OF TRADE.
* IN NO EVENT SHALL AMD OR ITS LICENSORS BE LIABLE FOR ANY DAMAGES WHATSOEVER
* (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF PROFITS, BUSINESS
* INTERRUPTION, OR LOSS OF INFORMATION) ARISING OUT OF AMD'S NEGLIGENCE,
* GROSS NEGLIGENCE, THE USE OF OR INABILITY TO USE THE MATERIALS OR ANY OTHER
* RELATED INFORMATION PROVIDED TO YOU BY AMD, EVEN IF AMD HAS BEEN ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGES.  BECAUSE SOME JURISDICTIONS PROHIBIT THE
* EXCLUSION OR LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES,
* THE ABOVE LIMITATION MAY NOT APPLY TO YOU.
*
* AMD does not assume any responsibility for any errors which may appear in
* the Materials or any other related information provided to you by AMD, or
* result from use of the Materials or any related information.
*
* You agree that you will not reverse engineer or decompile the Materials.
*
* NO SUPPORT OBLIGATION: AMD is not obligated to furnish, support, or make any
* further information, software, technical information, know-how, or show-how
* available to you.  Additionally, AMD retains the right to modify the
* Materials at any time, without notice, and is not obligated to provide such
* modified Materials to you.
*
* U.S. GOVERNMENT RESTRICTED RIGHTS: The Materials are provided with
* "RESTRICTED RIGHTS." Use, duplication, or disclosure by the Government is
* subject to the restrictions as set forth in FAR 52.227-14 and
* DFAR252.227-7013, et seq., or its successor.  Use of the Materials by the
* Government constitutes acknowledgement of AMD's proprietary rights in them.
*
* EXPORT ASSURANCE:  You agree and certify that neither the Materials, nor any
* direct product thereof will be exported directly or indirectly, into any
* country prohibited by the United States Export Administration Act and the
* regulations thereunder, without the required authorization from the U.S.
* government nor will be used for any purpose prohibited by the same.
* ***************************************************************************
*
*/

/*
 *----------------------------------------------------------------------------
 *                                MODULES USED
 *
 *----------------------------------------------------------------------------
 */



#include "AGESA.h"
#include "amdlib.h"
#include "OptionMemory.h"
#include "PlatformMemoryConfiguration.h"
#include "Ids.h"
#include "Filecode.h"
CODE_GROUP (G1_PEICC)
RDATA_GROUP (G1_PEICC)

#define FILECODE PROC_MEM_MAIN_MMCONDITIONALPSO_FILECODE
/*----------------------------------------------------------------------------
 *                          DEFINITIONS AND MACROS
 *
 *----------------------------------------------------------------------------
 */


/*----------------------------------------------------------------------------
 *                           TYPEDEFS AND STRUCTURES
 *
 *----------------------------------------------------------------------------
 */

#define PSO_TYPE    0
#define PSO_LENGTH  1
#define PSO_DATA    2

typedef enum _PSO_STATE {
  PSO_FIND_CONDITION = 100,  // Searching for initial Condition statement
  PSO_FIND_ACTION,           // Searching for initial Action Statement
  PSO_MATCH_ACTION,          // Trying to find an action that matches the caller's request
  PSO_CHECK_CONDITION,       // Checking the condition that preceded the found action
  PSO_DO_ACTION,             // Performing Action
  PSO_COMPLETE               // Completed processing of this request
} PSO_STATE;

typedef struct _D3_CMP_CAL {
  UINT32 D3Cmp0NCal   :3;
  UINT32 Reserved34   :2;
  UINT32 D3Cmp0PCal   :3;
  UINT32 Reserved89   :2;
  UINT32 D3Cmp1NCal   :3;
  UINT32 Reserved1314 :2;
  UINT32 D3Cmp1PCal   :3;
  UINT32 Reserved1819 :2;
  UINT32 D3Cmp2NCal   :3;
  UINT32 Reserved2324 :2;
  UINT32 D3Cmp2PCal   :3;
  UINT32 Reserved2831 :2;
} D3_CMP_CAL;

/*----------------------------------------------------------------------------
 *                        PROTOTYPES OF LOCAL FUNCTIONS
 *
 *----------------------------------------------------------------------------
 */
BOOLEAN
 STATIC
 MemPSODoActionODT (
   IN OUT   MEM_NB_BLOCK *NBPtr,
   IN       UINT8 *Buffer
   );

 BOOLEAN
 STATIC
 MemPSODoActionAddrTmg (
   IN OUT   MEM_NB_BLOCK *NBPtr,
   IN       UINT8 *Buffer
   );

 BOOLEAN
 STATIC
 MemPSODoActionODCControl (
   IN OUT   MEM_NB_BLOCK *NBPtr,
   IN       UINT8 *Buffer
   );

 BOOLEAN
 STATIC
 MemPSODoActionSlewRate (
   IN OUT   MEM_NB_BLOCK *NBPtr,
   IN       UINT8 *Buffer
   );

BOOLEAN
STATIC
MemPSODoActionGetFreqLimit (
  IN OUT   MEM_NB_BLOCK *NBPtr,
  IN       UINT8 *Buffer
  );

BOOLEAN
STATIC
MemCheckRankType (
  IN       CH_DEF_STRUCT *CurrentChannel,
  IN       UINT16 RankType
  );
/*----------------------------------------------------------------------------
 *                            EXPORTED FUNCTIONS
 *
 *----------------------------------------------------------------------------
 */


/* -----------------------------------------------------------------------------*/
/**
 *
 *      Process Conditional Platform Specific Overrides
 *
 *      @param[in] PlatformMemoryConfiguration - Pointer to Platform config table
 *      @param[in] NBPtr - Pointer to Current NBBlock
 *      @param[in] PsoAction - Action type
 *      @param[in] Dimm - Dimm Number
 *
 *      @return          BOOLEAN -            TRUE : Action was performed
 *                                            FALSE: Action was not performed
 *
 * ----------------------------------------------------------------------------
 */
BOOLEAN
MemProcessConditionalOverrides (
  IN       PSO_TABLE *PlatformMemoryConfiguration,
  IN OUT   MEM_NB_BLOCK *NBPtr,
  IN       UINT8 PsoAction,
  IN       UINT8 Dimm
  )
{
  BOOLEAN Result;
  MEM_TECH_BLOCK *TechPtr;
  UINT8 *Buffer;
  UINT8 *ConditionStartPtr;
  UINT8 *ActionStartPtr;
  UINT8 *SpdBufferPtr;
  UINT8 i;
  UINT8 DimmMask;
  UINT8 CurDimmMask;
  BOOLEAN Condition;
  BOOLEAN TmpCond;
  PSO_STATE State;
  ASSERT (PlatformMemoryConfiguration != NULL);
  ASSERT (NBPtr != NULL);
  ASSERT ((PsoAction >= PSO_ACTION_MIN) && (PsoAction <= PSO_ACTION_MAX));
  //
  // Set up local data
  //
  TechPtr = NBPtr->TechPtr;
  Buffer = PlatformMemoryConfiguration;
  State = PSO_FIND_CONDITION;
  ConditionStartPtr = NULL;
  ActionStartPtr = NULL;
  Condition = FALSE;
  DimmMask = 0xFF;
  CurDimmMask = 0xFF;
  Result = FALSE;

  if (Dimm != 0xFF) {
    DimmMask = ( 1 << Dimm);
  }
  DimmMask &= (UINT8) (NBPtr->ChannelPtr->ChDimmValid & 0xFF);
  if (DimmMask == 0) {
    return Result;
  }

  //
  // Search for Condition Entry
  //
  while (State != PSO_COMPLETE) {
    switch (State) {
    //
    // Searching for initial Condition statement
    //
    case PSO_FIND_CONDITION:
      ASSERT (Buffer != NULL);
      while (Buffer[PSO_TYPE] != PSO_CONDITION_AND) {
        //
        // If end of table is reached, Change state to complete and break.
        //
        if (Buffer[PSO_TYPE] == PSO_END) {
          State = PSO_COMPLETE;
          break;
        }
        //
        // Otherwise, increment Buffer Pointer to the next PSO entry.
        //
        Buffer += (Buffer[PSO_LENGTH] + 2);
      }
      //
      // If Condition statement has been found, save the Condition Start Pointer,
      //  and change to next state
      //
      if (State != PSO_COMPLETE) {
        ASSERT (Buffer != NULL);
        State = PSO_FIND_ACTION;
        ConditionStartPtr = Buffer;
        Buffer += (Buffer[PSO_LENGTH] + 2);
      }
      break;
    //
    // Searching for an action that matches the caller's request
    //
    case PSO_FIND_ACTION:
      ASSERT (Buffer != NULL);
      while (Buffer[PSO_TYPE] != PsoAction) {
        //
        // If non-conditional entry, change state to complete and break.
        //
        if ((Buffer[PSO_TYPE] < CONDITIONAL_PSO_MIN) || (Buffer[PSO_TYPE] > CONDITIONAL_PSO_MAX)) {
          State = PSO_COMPLETE;
          break;
        }
        //
        // Check for the Start of a new condition block
        //
        if (Buffer[PSO_TYPE] == PSO_CONDITION_AND) {
          ConditionStartPtr = Buffer;
        }
        //
        // Otherwise, increment buffer pointer to the next PSO entry.
        //
        Buffer += (Buffer[PSO_LENGTH] + 2);
      }
      //
      // If Action statement has been found, Save the Action Start Pointer, Reset Buffer to Condition Start
      //  and Change to next state.
      //
      if (State != PSO_COMPLETE) {
        State = PSO_CHECK_CONDITION;
        ASSERT (Buffer != NULL);
        ActionStartPtr = Buffer;
        Buffer = ConditionStartPtr;
        Condition = TRUE;
      }
      break;
    //
    // Checking the condition that preceded the found action
    //
    case PSO_CHECK_CONDITION:
      ASSERT (Buffer != NULL);
      //
      // Point to the next Condition
      //
      Buffer += (Buffer[PSO_LENGTH] + 2);
      ASSERT ((Buffer[PSO_TYPE] >= CONDITIONAL_PSO_MIN) && (Buffer[PSO_TYPE] <= CONDITIONAL_PSO_MAX));
      //
      // This section has already been checked for invalid statements so just exit on ACTION_xx
      //
      if ((Buffer[PSO_TYPE] >= PSO_ACTION_MIN) && (Buffer[PSO_TYPE] <= PSO_ACTION_MAX)) {
        if (Condition) {
          ASSERT (Buffer != NULL);
          State = PSO_DO_ACTION;              // Perform the Action
        } else {
          State = PSO_FIND_CONDITION;         // Go back and look for another condition/action
        }
        Buffer = ActionStartPtr;              // Restore Action Pointer
        break;
      }
      switch (Buffer[PSO_TYPE]) {

      case PSO_CONDITION_AND:
        //
        // Additional CONDITION_AND is ORed with Previous ones, so if Previous result is TRUE
        //  just restore action pointer and perform the action.
        //
        if (Condition) {
          State = PSO_DO_ACTION;
          Buffer = ActionStartPtr;
        } else {
          //
          // If its false, Start over and evaluate next cond.
          // reset the Current Dimm Mask
          //
          Condition = TRUE;
          CurDimmMask = 0xFF;
        }
        break;

      case PSO_CONDITION_LOC:
        //
        // Condition location
        //
        CurDimmMask = Buffer[4];
        Condition &= ( ((Buffer[2] & (1 << (NBPtr->MCTPtr->SocketId))) != 0) &&
                       ((Buffer[3] & (1 << (NBPtr->ChannelPtr->ChannelID))) != 0) &&
                       ((CurDimmMask & DimmMask) != 0) );
        break;

      case PSO_CONDITION_SPD:
        //
        // Condition SPD
        //
        TmpCond = FALSE;
        for (i = 0; i < MAX_DIMMS_PER_CHANNEL; i ++) {
          if ( ((DimmMask & CurDimmMask) & ((UINT16) (1 << i))) != 0) {
            if (TechPtr->GetDimmSpdBuffer (TechPtr, &SpdBufferPtr, i)) {
              TmpCond |= ( (SpdBufferPtr[Buffer[2]] & Buffer[3]) == Buffer[4]);
            }
          }
        }
        Condition &= TmpCond;
        break;

      case PSO_CONDITION_REG:
        //
        // Condition Register - unsupported at this time
        //
        break;

      default:
        ASSERT (FALSE);
      } // End Condition Switch
    break;

    case PSO_DO_ACTION:
      ASSERT (Buffer != NULL);
      //
      // Performing Action
      //
      if ((Buffer[PSO_TYPE] < PSO_ACTION_MIN) || (Buffer[PSO_TYPE] > PSO_ACTION_MAX)) {
        State = PSO_COMPLETE;
      }
      if (Buffer[PSO_TYPE] == PsoAction) {
        switch (Buffer[PSO_TYPE]) {
        case PSO_ACTION_ODT:
          Result = MemPSODoActionODT (NBPtr, &Buffer[PSO_DATA]);
          break;
        case PSO_ACTION_ADDRTMG:
          Result = MemPSODoActionAddrTmg (NBPtr, &Buffer[PSO_DATA]);
          break;
        case PSO_ACTION_ODCCONTROL:
          Result = MemPSODoActionODCControl (NBPtr, &Buffer[PSO_DATA]);
          break;
        case PSO_ACTION_SLEWRATE:
          Result = MemPSODoActionSlewRate (NBPtr, &Buffer[PSO_DATA]);
          break;
        case PSO_ACTION_SPEEDLIMIT:
          Result = MemPSODoActionGetFreqLimit (NBPtr, &Buffer[PSO_DATA]);
          break;
        case PSO_ACTION_REG:
          break;
        default:
          ASSERT (FALSE);
        } // End Action Switch
        //
        // If Action was performed, mark complete.
        //
        if (Result) {
          State = PSO_COMPLETE;
        }
    }// End Action

      //
      // Point to the next PSO Entry
      //
      Buffer += (Buffer[PSO_LENGTH] + 2);
      break;

    case PSO_COMPLETE:
      //
      // Completed processing of this request
      //
      break;

    default:
      ASSERT (FALSE);
    } // End State Switch

  } // End While

  return Result;
}

/*----------------------------------------------------------------------------
 *                              LOCAL FUNCTIONS
 *
 *----------------------------------------------------------------------------
 */

/* -----------------------------------------------------------------------------*/
/**
 *      Perform ODT Platform Override
 *
 *      @param[in] NBPtr - Pointer to Current NBBlock
 *      @param[in] Buffer - Pointer to the Action Command Data (w/o Type and Len)
 *
 *      @return         BOOLEAN -             TRUE : Action was performed
 *                                            FALSE: Action was not performed
 *
 * ----------------------------------------------------------------------------
 */
BOOLEAN
STATIC
MemPSODoActionODT (
  IN OUT   MEM_NB_BLOCK *NBPtr,
  IN       UINT8 *Buffer
  )
{
  BOOLEAN Result;
  UINT32 Speed;
  UINT8 Dimms;
  UINT8 i;
  UINT8 QR_Dimms;
  Result = FALSE;
  Speed = ((UINT32) 1 << (NBPtr->DCTPtr->Timings.Speed / 66));
  Dimms = NBPtr->ChannelPtr->Dimms;
  QR_Dimms = 0;
  for (i = 0; i < MAX_DIMMS_PER_CHANNEL; i++) {
    if (((NBPtr->ChannelPtr->DimmQrPresent & (UINT16) (1 << i)) != 0) && (i < 2)) {
      QR_Dimms ++;
    }
  }
  if ((Speed & ((UINT32 *) Buffer)[0]) != 0) {
    if ((((UINT8) (1 << (Dimms - 1)) & Buffer[4]) != 0) || (Buffer[4] == ANY_NUM)) {
      if (((QR_Dimms == 0) && (Buffer[5] == NO_DIMM)) ||
          ((QR_Dimms > 0) && (((UINT8) (1 << (QR_Dimms - 1)) & Buffer[5]) != 0)) ||
           (Buffer[5] == ANY_NUM)) {
        NBPtr->PsPtr->DramTerm = Buffer[6];
        NBPtr->PsPtr->QR_DramTerm = Buffer[7];
        NBPtr->PsPtr->DynamicDramTerm = Buffer[8];
        Result = TRUE;
        IDS_HDT_CONSOLE (MEM_FLOW, "      Platform Override: DramTerm:%02x, QRDramTerm:%02x, DynDramTerm:%02x\n", Buffer[6], Buffer[7], Buffer[8]);
      }
    }
  }
  return Result;
 }

 /* -----------------------------------------------------------------------------*/
/**
 *      Perform Address Timing Platform Override
 *
 *      @param[in] NBPtr - Pointer to Current NBBlock
 *      @param[in] Buffer - Pointer to the Action Command Data (w/o Type and Len)
 *
 *      @return          BOOLEAN -             TRUE : Action was performed
 *                                             FALSE: Action was not performed
 *
 * ----------------------------------------------------------------------------
 */
BOOLEAN
STATIC
MemPSODoActionAddrTmg (
  IN OUT   MEM_NB_BLOCK *NBPtr,
  IN       UINT8 *Buffer
  )
{
  BOOLEAN Result;
  CH_DEF_STRUCT *ChannelPtr;
  UINT32 Speed;
  UINT16 DimmConfig;

  Result = FALSE;
  ChannelPtr = NBPtr->ChannelPtr;
  Speed = ((UINT32) 1 << (NBPtr->DCTPtr->Timings.Speed / 66));
  DimmConfig = *(UINT16 *) &(Buffer[4]);

  if ((Speed & ((UINT32 *) Buffer)[0]) != 0) {
    if (MemCheckRankType (ChannelPtr, DimmConfig)) {
      ChannelPtr->DctAddrTmg = *(UINT32*) &(Buffer[6]);
      Result = TRUE;
      IDS_HDT_CONSOLE (MEM_FLOW, "      Platform Override: Address Timing:%08x\n", *(UINT32*) &(Buffer[6]));
    }
  }
  return Result;
 }

  /* -----------------------------------------------------------------------------*/
/**
 *      Perform Drive Strength Platform Override
 *
 *      @param[in] NBPtr - Pointer to Current NBBlock
 *      @param[in] Buffer - Pointer to the Action Command Data (w/o Type and Len)
 *
 *      @return          BOOLEAN -             TRUE : Action was performed
 *                                             FALSE: Action was not performed
 *
 * ----------------------------------------------------------------------------
 */
BOOLEAN
STATIC
MemPSODoActionODCControl (
  IN OUT   MEM_NB_BLOCK *NBPtr,
  IN       UINT8 *Buffer
  )
{
  BOOLEAN Result;
  CH_DEF_STRUCT *ChannelPtr;
  UINT32 Speed;
  UINT16 DimmConfig;

  Result = FALSE;
  ChannelPtr = NBPtr->ChannelPtr;
  Speed = ((UINT32) 1 << (NBPtr->DCTPtr->Timings.Speed / 66));
  DimmConfig = *(UINT16 *) &(Buffer[4]);

  if ((Speed & ((UINT32 *) Buffer)[0]) != 0) {
    if (MemCheckRankType (ChannelPtr, DimmConfig)) {
      ChannelPtr->DctOdcCtl = *(UINT32*) &(Buffer[6]);
      Result = TRUE;
      IDS_HDT_CONSOLE (MEM_FLOW, "      Platform Override: ODC Control:%08x\n", *(UINT32*)&(Buffer[6]));
    }
  }
  return Result;
 }

  /* -----------------------------------------------------------------------------*/
/**
 *      Perform Slew Rate Platform Override
 *
 *      @param[in] NBPtr - Pointer to Current NBBlock
 *      @param[in] Buffer - Pointer to the Action Command Data (w/o Type and Len)
 *
 *     @return          BOOLEAN -             TRUE : Action was performed
 *                                            FALSE: Action was not performed
 *
 * ----------------------------------------------------------------------------
 */
BOOLEAN
STATIC
MemPSODoActionSlewRate (
  IN OUT   MEM_NB_BLOCK *NBPtr,
  IN       UINT8 *Buffer
  )
{
  BOOLEAN Result;
  CH_DEF_STRUCT *ChannelPtr;
  UINT32 Speed;
  UINT16 DimmConfig;

  Result = FALSE;
  ChannelPtr = NBPtr->ChannelPtr;
  Speed = ((UINT32) 1 << (NBPtr->DCTPtr->Timings.Speed / 66));
  DimmConfig = *(UINT16 *) &(Buffer[4]);

  if ((Speed & ((UINT32 *) Buffer)[0]) != 0) {
    if (MemCheckRankType (ChannelPtr, DimmConfig)) {
      MemNSetBitFieldNb (NBPtr, BFD3Cmp0NCal, ((D3_CMP_CAL *) &(Buffer[6]))->D3Cmp0NCal );
      MemNSetBitFieldNb (NBPtr, BFD3Cmp0PCal, ((D3_CMP_CAL *) &(Buffer[6]))->D3Cmp0PCal );
      MemNSetBitFieldNb (NBPtr, BFD3Cmp1NCal, ((D3_CMP_CAL *) &(Buffer[6]))->D3Cmp1NCal );
      MemNSetBitFieldNb (NBPtr, BFD3Cmp1PCal, ((D3_CMP_CAL *) &(Buffer[6]))->D3Cmp1PCal );
      MemNSetBitFieldNb (NBPtr, BFD3Cmp2NCal, ((D3_CMP_CAL *) &(Buffer[6]))->D3Cmp2NCal );
      MemNSetBitFieldNb (NBPtr, BFD3Cmp2PCal, ((D3_CMP_CAL *) &(Buffer[6]))->D3Cmp2PCal );
      Result = TRUE;
      IDS_HDT_CONSOLE (MEM_FLOW, "      Platform Override: Slew Rate:%08x\n", *(UINT32 *) &(Buffer[6]));
    }
  }
  return Result;
 }

/* -----------------------------------------------------------------------------*/
/**
 *
 *    This function overrides the  POR supported speed for a specific config
 *
 *      @param[in] NBPtr - Pointer to Current NBBlock
 *      @param[in] Buffer - Pointer to the Action Command Data (w/o Type and Len)
 *
 *      @return          BOOLEAN -            TRUE : Action was performed
 *                                            FALSE: Action was not performed
 *
 */
BOOLEAN
STATIC
MemPSODoActionGetFreqLimit (
  IN OUT   MEM_NB_BLOCK *NBPtr,
  IN       UINT8 *Buffer
  )
{
  BOOLEAN Result;
  CH_DEF_STRUCT *ChannelPtr;
  DCT_STRUCT *DCTPtr;
  UINT16 DimmConfig;
  UINT16 SpeedLimit;

  Result = FALSE;
  ChannelPtr = NBPtr->ChannelPtr;
  DCTPtr = NBPtr->DCTPtr;
  DimmConfig = *(UINT16*) &(Buffer[0]);
  SpeedLimit = 0;
  //
  // Match number of dimms, then Rank Type
  //
  if (ChannelPtr->Dimms == Buffer[2]) {
    if (MemCheckRankType (ChannelPtr, DimmConfig)) {
      //
      // Select speed based on current voltage
      //
      if (NBPtr->RefPtr->DDR3Voltage == VOLT1_5) {
        SpeedLimit = *(UINT16*) &(Buffer[3]);
      } else if (NBPtr->RefPtr->DDR3Voltage == VOLT1_25) {
        SpeedLimit = *(UINT16*) &(Buffer[7]);
      } else {
        SpeedLimit = *(UINT16*) &(Buffer[5]);
      }
      //
      // Set the Speed limit
      //
      if (DCTPtr->Timings.TargetSpeed > SpeedLimit) {
        DCTPtr->Timings.TargetSpeed = SpeedLimit;
      }
      Result = TRUE;
      IDS_HDT_CONSOLE (MEM_FLOW, "      Platform Override: Max Memory Speed for Channel %d: %d\n", NBPtr->Channel, SpeedLimit);
    }
  }
  return Result;
}

 /* -----------------------------------------------------------------------------*/
/**
 *
 *    This function matches a particular Rank Type Mask to the installed
 *    DIMM configuration on the provided channel.
 *
 *     @param[in]       *CurrentChannel       Pointer to CH_DEF_STRUCT
 *     @param[in]       RankType              Mask of rank type to match
 *
 *     @return          BOOLEAN -             TRUE : Rank types match
 *                                            FALSE: Rank types do not match
 *
 */
BOOLEAN
STATIC
MemCheckRankType (
  IN       CH_DEF_STRUCT *CurrentChannel,
  IN       UINT16 RankType
  )
{
  BOOLEAN Result;
  UINT8 i;
  UINT16 DIMMRankType;

  DIMMRankType = MemAGetPsRankType (CurrentChannel);
  Result = TRUE;
  for (i = 0; i < MAX_DIMMS_PER_CHANNEL; i++) {
    if ( ((DIMMRankType & (0x0F << (i << 2))) + (RankType & (0x0F << (i << 2)))) != 0) {
      Result &= (((DIMMRankType & (0x0F << (i << 2))) & ( RankType & ( 0x0F << ( i << 2)))) != 0);
    }
    if (!Result) {
      break;
    }
  }
  return Result;
}