Fix support for multiple VPD versions in mbvpd accessors

The current Term Data and Phase Rotator hwp accessors address  version specific
quirks in vpd layout by code. The current Term Data and Phase Rotator accessors
will be replaced with a table driven approach that will take advantage of the
majority of the layout being common between all versions and provide a table
driven approach to exceptions.

Change-Id: I132b7bf6d066e6c4ccad4d6acae290cc8e8b85e5
RTC: 117485
Reviewed-on: http://gfw160.aus.stglabs.ibm.com:8080/gerrit/14507
Tested-by: Jenkins Server
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>
Reviewed-by: Elizabeth Liner <eliner@us.ibm.com>
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

13 files changed, 2697 insertions, 2456 deletions

diff --git a/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttr.H b/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttr.H
new file mode 100644
index 000000000..b9b4c3054
--- /dev/null
+++ b/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttr.H
@@ -0,0 +1,386 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttr.H $      */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2014,2015                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+// $Id: getMBvpdAttr.H,v 1.1 2014/12/11 13:38:54 whs Exp $
+
+/**
+ *  @file getMBvpdAttr.H
+ *
+ *  @brief Prototype for getMBvpdAttr() -
+ *          get Attribute Data from MBvpd
+ */
+
+#ifndef    _HWP_MBVPDATTR_
+#define    _HWP_MBVPDATTR_
+
+#include   <fapi.H>
+#include   <fapiMBvpdAccess.H>
+
+namespace fapi
+{
+namespace getAttrData
+{
+    //MT and MR keyword layout
+    const uint8_t NUM_MBA =  2;    //There are 2 MBAs per Centaur memory buffer
+    const uint8_t NUM_PORTS = 2;   //Each MBA has 2 ports
+    const uint8_t NUM_DIMMS = 2;   //Each port has 2 DIMMs
+    const uint8_t NUM_RANKS = 4;   //Number of ranks
+    const uint8_t PORT_SECTION_SIZE = 64; //Each port has 64 bytes
+
+    struct port_attributes
+    {
+       uint8_t port_attr[PORT_SECTION_SIZE];
+    };
+    struct mba_attributes
+    {
+        port_attributes mba_port[NUM_PORTS];
+    };
+    struct attr_keyword
+    {
+        mba_attributes mb_mba[NUM_MBA];
+    };
+    // The actual size of the keyword is 255 bytes, which is one byte short
+    // of the attr_keyword struct. One byte is used for the size in the vpd.
+    // As long as there is at least one reserved attribute, then all will fit.
+    const uint32_t ATTR_KEYWORD_SIZE = 255;  // keyword size for attributes
+
+    //  DIMM types
+    enum DimmType
+    {
+        ALL_DIMM,        // Same for all Dimm types
+        CDIMM,
+        ISDIMM,
+    };
+
+    //  Versions to check for
+    enum VpdVersion
+    {
+        ALL_VER=0,  // Same for all versions
+        VBASE=1,    // Use this before any other defined versions
+        V10=0x3130, // Version 6.0 is ascii "10"
+        V13=0x3133, // Version 6.3 is ascii "13"
+    };
+
+//  Output data types
+    enum OutputType
+    {
+        UINT8_BY2         =0x0001,   // uint8_t  [2]
+        UINT8_BY2_BY2     =0x0002,   // uint8_t  [2][2]
+        UINT8_BY2_BY2_BY4 =0x0003,   // uint8_t  [2][2][4]
+        UINT32_BY2        =0x0004,   // uint32_t [2]
+        UINT32_BY2_BY2    =0x0005,   // uint32_t [2][2]
+        UINT64            =0x0006,   // uint64_t
+    };
+    const uint16_t OUTPUT_TYPE_MASK = 0x00FF;
+
+    typedef uint8_t  UINT8_BY2_t [2];
+    typedef uint8_t  UINT8_BY2_BY2_t [2][2];
+    typedef uint8_t  UINT8_BY2_BY2_BY4_t [2][2][4];
+    typedef uint32_t UINT32_BY2_t [2];
+    typedef uint32_t UINT32_BY2_BY2_t [2][2];
+    typedef uint64_t UINT64_t;
+
+    //  Special processing
+    //  Rules:
+    //  Values for "All types" needs to be unquie for all output types
+    //  Values for a particular type only need to be unique within that type
+    enum SpecialProcessing
+    {
+    // for All Types
+        DEFAULT_VALUE  = 0x1000,
+        UINT8_DATA     = 0x2000,  // The vpd data size
+        UINT16_DATA    = 0x3000,  // The vpd data size
+        UINT32_DATA    = 0x4000,  // The vpd data size
+        // All the "all types" need to be within this mask
+        SPECIAL_DATA_MASK  = 0xF000,
+
+    // for UINT8_BY2 (all mutually exclusive)
+        XLATE_SLEW     = 0x0100,
+        HIGH_NIBBLE    = 0x0200,
+        LOW_NIBBLE     = 0x0300,
+        PORT00         = 0x0400,
+        PORT11         = 0x0500,
+
+    // for UINT8_BY2_BY2 (all mutually exclusive)
+        XLATE_DRAM_RON = 0x0100,
+        BOTH_DIMMS     = 0x0200,
+
+    // for UNIT8_BY2_BY2_BY4 (all mutually exclusive)
+        XLATE_RTT_NOM  = 0x0100,
+        XLATE_RTT_WR   = 0x0200,
+
+    // for UINT32_BY2 (all mutually exclusive)
+        XLATE_RD_VREF  = 0x0100,
+        XLATE_WR_VREF  = 0x0200,
+    //  UINT8_DATA supported
+    //  UINT16_DATA supported
+
+    // for UINT32_BY2_BY2
+    //  UINT8_DATA supported
+    //  UINT16_DATA supported
+
+    // for UINT64
+        MERGE          = 0x0100,
+
+    //  all of the "for output type" enums need to be within this mask
+        SPECIAL_XLATE_MASK = 0x0F00,
+
+    //  All enums need to be within this mask. The lower byte is the offset.
+        SPECIAL_PROCESSING_MASK = 0xFF00,
+    };
+
+//  Attribute definition
+    struct MBvpdAttrDef
+    {
+        AttributeId          iv_attrId;
+        DimmType             iv_dimmType;
+        VpdVersion           iv_version;
+        fapi::MBvpdKeyword   iv_keyword;
+        uint8_t              iv_offset;
+        uint16_t             iv_outputType;
+        uint32_t             iv_defaultValue;
+    };
+
+// Declare global table and size
+extern const MBvpdAttrDef g_MBVPD_ATTR_DEF_array [];
+extern const uint32_t g_MBVPD_ATTR_DEF_array_size;
+
+} // getAttrData namespace
+} // fapi namespace
+
+// Template class that is specialized for each attribute specifying it's type
+template<const fapi::AttributeId A>
+    class MBvpdAttrDataType { };
+
+// Term Data attribute specializations
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_DRAM_RON>
+    { public: typedef fapi::ATTR_VPD_DRAM_RON_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_DRAM_RTT_NOM>
+    { public: typedef fapi::ATTR_VPD_DRAM_RTT_NOM_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_DRAM_RTT_WR>
+    { public: typedef fapi::ATTR_VPD_DRAM_RTT_WR_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_ODT_RD>
+    { public: typedef fapi::ATTR_VPD_ODT_RD_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_ODT_WR>
+    { public: typedef fapi::ATTR_VPD_ODT_WR_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_DIMM_RCD_IBT>
+    { public: typedef fapi::ATTR_VPD_DIMM_RCD_IBT_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_DIMM_RCD_OUTPUT_TIMING>
+    { public: typedef fapi::ATTR_VPD_DIMM_RCD_OUTPUT_TIMING_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_RD_VREF>
+    { public: typedef fapi::ATTR_VPD_CEN_RD_VREF_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_DRAM_WR_VREF>
+    { public: typedef fapi::ATTR_VPD_DRAM_WR_VREF_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_DRAM_WRDDR4_VREF>
+    { public: typedef fapi::ATTR_VPD_DRAM_WRDDR4_VREF_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_RCV_IMP_DQ_DQS>
+    { public: typedef fapi::ATTR_VPD_CEN_RCV_IMP_DQ_DQS_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_DQ_DQS>
+    { public: typedef fapi::ATTR_VPD_CEN_DRV_IMP_DQ_DQS_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_CNTL>
+    { public: typedef fapi::ATTR_VPD_CEN_DRV_IMP_CNTL_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_ADDR>
+    { public: typedef fapi::ATTR_VPD_CEN_DRV_IMP_ADDR_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_CLK>
+    { public: typedef fapi::ATTR_VPD_CEN_DRV_IMP_CLK_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_SPCKE>
+    { public: typedef fapi::ATTR_VPD_CEN_DRV_IMP_SPCKE_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_DQ_DQS>
+    { public: typedef fapi::ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_CNTL>
+    { public: typedef fapi::ATTR_VPD_CEN_SLEW_RATE_CNTL_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_ADDR>
+    { public: typedef fapi::ATTR_VPD_CEN_SLEW_RATE_ADDR_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_CLK>
+    { public: typedef fapi::ATTR_VPD_CEN_SLEW_RATE_CLK_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_SPCKE>
+    { public: typedef fapi::ATTR_VPD_CEN_SLEW_RATE_SPCKE_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CKE_PRI_MAP>
+    { public: typedef fapi::ATTR_VPD_CKE_PRI_MAP_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CKE_PWR_MAP>
+    { public: typedef fapi::ATTR_VPD_CKE_PWR_MAP_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_RLO>
+    { public: typedef fapi::ATTR_VPD_RLO_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_WLO>
+    { public: typedef fapi::ATTR_VPD_WLO_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_GPO>
+    { public: typedef fapi::ATTR_VPD_GPO_Type Type; };
+
+// Phase Rotator attribute specializations
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A2>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A2_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A3>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A3_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A4>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A4_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A5>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A5_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A6>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A6_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A7>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A7_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A8>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A8_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A9>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A9_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A10>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A10_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A11>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A11_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A12>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A12_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A13>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A13_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A14>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A14_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A15>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A15_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA2>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA2_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_CASN>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_CASN_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_RASN>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_RASN_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_WEN>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_WEN_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_PAR>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_PAR_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_ACTN>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M_ACTN_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE2>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE2_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE3>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE3_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN2>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN2_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN3>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN3_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE2>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE2_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE3>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE3_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN1_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN2>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN2_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN3>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN3_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT0>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT0_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT1>
+    { public: typedef fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT1_Type Type; };
+// There is no ATTR_VPD_DRAM_2N_MODE attribute. getMBvpdAttr is called
+// directly using ATTR_VPD_DRAM_2N_MODE_ENABLED as an ID.
+//template<>class MBvpdAttrDataType<fapi::ATTR_VPD_DRAM_2N_MODE>
+//    { public: typedef fapi::ATTR_VPD_DRAM_2N_MODE Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_TSYS_ADR>
+    { public: typedef fapi::ATTR_VPD_TSYS_ADR_Type Type; };
+template<>class MBvpdAttrDataType<fapi::ATTR_VPD_TSYS_DP18>
+    { public: typedef fapi::ATTR_VPD_TSYS_DP18_Type Type; };
+
+
+// Template function that checks that the type is as expected.
+// This can be optionally called before calling the main HWP in order
+// to check for the expected type at compile-time.
+template<const fapi::AttributeId ATTR>
+    inline void checkAttrDataType
+        (typename MBvpdAttrDataType<ATTR>::Type &) {}
+
+/* example
+#define ATTR_VPD_DRAM_RON_GETMACRO(ID, PTARGET, VAL)\
+   (checkAddrDataType<fapi::ATTR_VPD_DRAM_RON>(VAL), \
+   fapi::platAttrSvc::fapiPlatGetAddrData\
+      (PTARGET, fapi::ATTR_VPD_DRAM_RON , VAL, sizeof(VAL)))
+*/
+// The complilation will fail unless the output variable matches the type
+// in the per attribute template specialization. The error messages will
+// include text related to template MBvpdAttrDataSize not be able to convert
+// the incorrect output variable's type to the expected type.
+//
+// There will be an additonal error from the general attribute compliation
+// checks related to fapiCheckIdType if the output type does not match
+// any of the expected types
+//
+// The inline function checkTermData will be optimized out by the compiler.
+
+// function pointer typedef definition for HWP call support
+typedef fapi::ReturnCode (*getMBvpdAttr_FP_t)
+     (const fapi::Target &, const fapi::AttributeId,
+      void *, const size_t);
+
+extern "C"
+{
+/**
+ * @brief get Attribute Data from MBvpd
+ *
+ * @param[in]  i_mbaTarget       -   mba target
+ * @param[in]  i_attr            -   Attribute ID
+ * @param[out] o_pVal            -   pointer to variable typed output variable
+ * @param[in]  i_valSize         -   size of output variable
+ *
+ * @return fapi::ReturnCode -   FAPI_RC_SUCCESS if success,
+ *                              relevant error code for failure.
+ */
+fapi::ReturnCode getMBvpdAttr(
+                              const fapi::Target   &i_mbaTarget,
+                              const fapi::AttributeId i_attr,
+                              void  * o_pVal,
+                              const size_t i_valSize);
+}
+
+#endif
diff --git a/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.H b/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.H
deleted file mode 100644
index 139fc9ef2..000000000
--- a/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.H
+++ /dev/null
@@ -1,188 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.H $ */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2012,2014              */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id: getMBvpdPhaseRotatorData.H,v 1.8 2013/11/08 18:13:43 whs Exp $
-
-/**
- *  @file getMBvpdPhaseRotatorData.H
- *
- *  @brief Prototype for getMBvpdPhaseRotatorData() -
- *          get Phase Rotator Data from MBvpd
- */
-
-#ifndef    _HWP_MVPDPHASERATORDATA_
-#define    _HWP_MVPDPHASERATORDATA_
-
-#include   <fapi.H>
-
-namespace fapi
-{
-// The MBvpdPhaseRotatorData enumeration is used on the FAPI_ATTR_GET and
-// getMBvpdPhaseRotatorData HWP accessor interface. The lower byte (6 bits)
-// matches the offset of the vpd field in the MR keyword. This is a convenient
-// use of the value for efficiency to index into the vpd keyword data.
-//
-// Most of the attributes are byte values and can be returned to the requester
-// directly. There are some that require special processing. For those, a
-// special processing flag is added into the value. This also distinguishes
-// values which have the same offset.
-
-// special processing flags to be added on to the MBvpdPhaseRotatorData value
-    enum MBvpdPhaseRotatorSpecial
-    {
-        PHASE_ROT_HIGH_NIBBLE = 0x0100, //bits 0:3 of MSB 0 to LSB 7
-                                        //  shifted right 4
-        PHASE_ROT_LOW_NIBBLE  = 0x0200, //bits 4:7 of MSB 0 to LSB 7
-        PHASE_ROT_PORT00=0x0300, // return vpd port 0 value for 0 and 1
-        PHASE_ROT_PORT11=0x0400, // return vpd port 1 value for 0 and 1
-    };
-// mask to isolate special processing flags
-const uint16_t PHASE_ROT_SPECIAL_MASK = 0x0700;
-
-// The offset changed for some of the attributes going from v5.3 of the vpd
-// layout to v6.0 and after. There is a work around to use the proper offset
-// based on the version
-// Flag to be added into MBvpdPhaseRotatorData value for attributes that need
-// to be checked for the work around.
-const uint8_t  PHASE_ROT_CHK60 = 0x40;  // check version for offset to use
-
-// base values match offset into MR keyword data
-    enum MBvpdPhaseRotatorData
-    {
-        PHASE_ROT_M0_CLK_P0 = 0x00,
-        PHASE_ROT_M0_CLK_P1 = 0x01,
-        PHASE_ROT_M1_CLK_P0 = 0x02,
-        PHASE_ROT_M1_CLK_P1 = 0x03,
-        PHASE_ROT_M_CMD_A0 = 0x04,
-        PHASE_ROT_M_CMD_A1 = 0x05,
-        PHASE_ROT_M_CMD_A2 = 0x06,
-        PHASE_ROT_M_CMD_A3 = 0x07,
-        PHASE_ROT_M_CMD_A4 = 0x08,
-        PHASE_ROT_M_CMD_A5 = 0x09,
-        PHASE_ROT_M_CMD_A6 = 0x0a,
-        PHASE_ROT_M_CMD_A7 = 0x0b,
-        PHASE_ROT_M_CMD_A8 = 0x0c,
-        PHASE_ROT_M_CMD_A9 = 0x0d,
-        PHASE_ROT_M_CMD_A10 = 0x0e,
-        PHASE_ROT_M_CMD_A11 = 0xf,
-        PHASE_ROT_M_CMD_A12 = 0x10,
-        PHASE_ROT_M_CMD_A13 = 0x11,
-        PHASE_ROT_M_CMD_A14 = 0x12,
-        PHASE_ROT_M_CMD_A15 = 0x13,
-        PHASE_ROT_M_CMD_BA0 = 0x14,
-        PHASE_ROT_M_CMD_BA1 = 0x15,
-        PHASE_ROT_M_CMD_BA2 = 0x16,
-        PHASE_ROT_M_CMD_CASN = 0x17,
-        PHASE_ROT_M_CMD_RASN = 0x18,
-        PHASE_ROT_M_CMD_WEN = 0x19,
-        PHASE_ROT_M_PAR = 0x1a,
-        PHASE_ROT_M_ACTN = 0x1b,
-        PHASE_ROT_M0_CNTL_CKE0 = 0x1c,
-        PHASE_ROT_M0_CNTL_CKE1 = 0x1d,
-        PHASE_ROT_M0_CNTL_CKE2 = 0x1e,
-        PHASE_ROT_M0_CNTL_CKE3 = 0x1f,
-        PHASE_ROT_M0_CNTL_CSN0 = 0x20,
-        PHASE_ROT_M0_CNTL_CSN1 = 0x21,
-        PHASE_ROT_M0_CNTL_CSN2 = 0x22,
-        PHASE_ROT_M0_CNTL_CSN3 = 0x23,
-        PHASE_ROT_M0_CNTL_ODT0 = 0x24,
-        PHASE_ROT_M0_CNTL_ODT1 = 0x25,
-        PHASE_ROT_M1_CNTL_CKE0 = 0x26,
-        PHASE_ROT_M1_CNTL_CKE1 = 0x27,
-        PHASE_ROT_M1_CNTL_CKE2 = 0x28,
-        PHASE_ROT_M1_CNTL_CKE3 = 0x29,
-        PHASE_ROT_M1_CNTL_CSN0 = 0x2a,
-        PHASE_ROT_M1_CNTL_CSN1 = 0x2b,
-        PHASE_ROT_M1_CNTL_CSN2 = 0x2c,
-        PHASE_ROT_M1_CNTL_CSN3 = 0x2d,
-        PHASE_ROT_M1_CNTL_ODT0 = 0x2e,
-        PHASE_ROT_M1_CNTL_ODT1 = 0x2f,
-        PHASE_ROT_DRAM_2N_MODE = 0x30,
-        PHASE_ROT_TSYS_ADR  = 0x31 | PHASE_ROT_CHK60 | PHASE_ROT_PORT00,
-        PHASE_ROT_TSYS_DP18 = 0x31 | PHASE_ROT_CHK60 | PHASE_ROT_PORT11,
-// Use these offsets for vpd less than version 6.0
-        PHASE_ROT_RLO_V53 = 0x31 | PHASE_ROT_LOW_NIBBLE,
-        PHASE_ROT_WLO_V53 = 0x31 | PHASE_ROT_HIGH_NIBBLE,
-        PHASE_ROT_GPO_V53= 0x32,
-        PHASE_ROT_TSYS_ADR_V53  = 0x33 | PHASE_ROT_PORT00,
-        PHASE_ROT_TSYS_DP18_V53 = 0x33 | PHASE_ROT_PORT11,
-        // invalid value
-        PHASE_ROT_INVALID = 0x3f,
-    };
-}
-// The max base offset value is 0x3e. The MR keyword is 255 bytes.
-// There is only room for 63 attributes per port. There are 4 x  64 byte
-// sections, but the last one is 1 byte short. See diagram below...
-const uint8_t PHASE_ROT_OFFSET_MASK = 0x003f; // mask attr to isolate base
-                                              // vpd offsetk
-
-// function pointer typedef definition for HWP call support
-typedef fapi::ReturnCode (*getMBvpdPhaseRotatorData_FP_t)
-     (const fapi::Target &, const fapi::MBvpdPhaseRotatorData,
-      uint8_t (&)[2]);
-
-
-extern "C"
-{
-/**
- * @brief   get Phase Rotator Data from cvpd record VSPD keyword MR
- *
- * There are Phase Rotator attributes for the mba's 2 ports in cvpd
- * record VSPD keyword MR. Each attribute has 2 bytes, one for each port.
- * There are two mba per memory buffer, position 0 and position 1.
- * The Termination Data attributes are retrieved from cvpd record VSPD
- * keyword MT.
- *
- * cpvd record VSPD keyword MR
- * -----------------------------------
- * | mba position 0                  |
- * |  -----------------------------  |
- * |  | port 0  (Port A) 64 bytes |  |
- * |  |---------------------------|  |
- * |  | port 1  (Port B) 64 bytes |  |
- * |  -----------------------------  |
- * |---------------------------------|
- * | mba postion 1                   |
- * |  -----------------------------  |
- * |  | port 0  (Port C) 64 bytes |  |
- * |  |---------------------------|  |
- * |  | port 1  (Port D) 63 bytes |  |
- * |  -----------------------------  |
- * -----------------------------------
- *
- * @param i_mbaTarget       -   mba target
- * @param i_attr            -   Phase Rotator Data attribute enumerator
- * @param o_val             -   Phase Rotator Data for each of the 2 ports
- *                              [0] port A (position 0) Port C (position 1)
- *                              [1] port B (position 0) Port D (position 1)
- *
- * @return fapi::ReturnCode -   FAPI_RC_SUCCESS if success,
- *                              relevant error code for failure.
- */
-fapi::ReturnCode getMBvpdPhaseRotatorData(
-                              const        fapi::Target &i_mbaTarget,
-                              const        fapi::MBvpdPhaseRotatorData i_attr,
-                              uint8_t      (&o_val)[2]);
-
-}
-
-#endif
diff --git a/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdTermData.H b/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdTermData.H
deleted file mode 100644
index 3920001b5..000000000
--- a/src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdTermData.H
+++ /dev/null
@@ -1,260 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/include/usr/hwpf/hwp/mvpd_accessors/getMBvpdTermData.H $  */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2014                        */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id: getMBvpdTermData.H,v 1.6 2014/11/24 15:47:50 cswenson Exp $
-
-/**
- *  @file getMBvpdTermData.H
- *
- *  @brief Prototype for getMBvpdTermData() -
- *          get Termination Data from MBvpd
- */
-
-#ifndef    _HWP_MBVPDTERMDATA_
-#define    _HWP_MBVPDTERMDATA_
-
-#include   <fapi.H>
-
-namespace fapi
-{
-
-// The MBvpdTermData enumeration is used on the FAPI_ATTR_GET and
-// getMBvpdTermData HWP accessor interface. The lower byte (6 bits)
-// matches the offset of the vpd field in the MT keyword. This is a convenient
-// use of the value for efficiency to index into the vpd keyword data.
-//
-// Most of the vpd attribute values can be returned to the requester directly.
-// There are some that require special processing. For those, a
-// special processing flag is added into the value. This also distinguishes
-// values which have the same offset.
-
-// special processing flags to be added on to the MBvpdTermData value
-    enum MBvpdTermDataSpecial
-    {
-        TERM_DATA_HIGH_NIBBLE = 0x0100,  //bits 0:3 of MSB 0 to LSB 7
-                                         //  shifted right 4
-        TERM_DATA_LOW_NIBBLE  = 0x0200,  //bits 4:7 of MSB 0 to LSB 7
-    };
-// mask to isolate special processing flags
-const uint16_t TERM_DATA_SPECIAL_MASK = 0x0300;
-
-// The vpd keyword changed for some of the attributes going from v5.3 of the vpd
-// layout to v6.0 and after. There is a work around to use the previous
-// keyword based on the vpd version.
-// Flag to be added into MBvpdTermData value for attributes that need to be
-// checked for work around.
-const uint8_t TERM_DATA_CHK60 = 0x40;  // check version for keyword to use
-
-// Values for DIMM_RCD_IBT when using custom dimm or when the
-// VPD version is earlier than "13"
-const uint32_t TERM_DATA_IBT_CDIMM = 0x0;
-const uint32_t TERM_DATA_IBT_PRE13 = 0x64;  // IBT_100
-
-// Values for DIMM_RCD_OUTPUT_TIMING when using custom dimm or when the
-// VPD version is earlier than "13"
-const uint8_t TERM_DATA_OUTPUT_TIMING_CDIMM = 0x0;
-const uint8_t TERM_DATA_OUTPUT_TIMING_PRE13 = 0x1;  // 1T
-
-// There are multiple types of output values. The type is shown in the comment.
-//
-// Some values are returned directly from the vpd and some vpd values
-// are translated before returning. Those translated are marked in the comment
-// section with <translated>
-//
-// The base offset value is incremented based on the vpd data type.
-    enum MBvpdTermData
-    {
-       TERM_DATA_DRAM_RON =             0x00,  //uint8_t [2][2] <translated>
-       TERM_DATA_DRAM_RTT_NOM =         0x02,  //uint8_t [2][2][4] <translated>
-       TERM_DATA_DRAM_RTT_WR =          0x0a,  //uint8_t [2][2][4] <translated>
-       TERM_DATA_ODT_RD =                  0x12,  //uint8_t [2][2][4]
-       TERM_DATA_ODT_WR =                  0x1a,  //uint8_t [2][2][4]
-       TERM_DATA_DIMM_RCD_IBT =            0x22,  //uint32_t [2][2]
-       TERM_DATA_DIMM_RCD_OUTPUT_TIMING =  0x24,  //uint8_t [2][2]
-       TERM_DATA_CEN_RD_VREF =             0x25,  //uint32_t [2] <translated>
-       TERM_DATA_DRAM_WR_VREF =            0x26,  //uint32_t [2] <translated>
-       TERM_DATA_DRAM_WRDDR4_VREF =        0x2a,  //uint8_t [2]
-       TERM_DATA_CEN_RCV_IMP_DQ_DQS =      0x2b,  //uint8_t [2]
-       TERM_DATA_CEN_DRV_IMP_DQ_DQS =      0x2c,  //uint8_t [2]
-       TERM_DATA_CEN_DRV_IMP_CNTL =        0x2d,  //uint8_t [2]
-       TERM_DATA_CEN_DRV_IMP_ADDR =        0x2e,  //uint8_t [2]
-       TERM_DATA_CEN_DRV_IMP_CLK =         0x2f,  //uint8_t [2]
-       TERM_DATA_CEN_DRV_IMP_SPCKE =       0x30,  //uint8_t [2]
-       TERM_DATA_CEN_SLEW_RATE_DQ_DQS =    0x31,  //uint8_t [2] <translated>
-       TERM_DATA_CEN_SLEW_RATE_CNTL =      0x32,  //uint8_t [2] <translated>
-       TERM_DATA_CEN_SLEW_RATE_ADDR =      0x33,  //uint8_t [2] <translated>
-       TERM_DATA_CEN_SLEW_RATE_CLK =       0x34,  //uint8_t [2] <translated>
-       TERM_DATA_CEN_SLEW_RATE_SPCKE =     0x35,  //uint8_t [2] <translated>
-// TERM_DATA_CKE_PRI_MAP is a uint16 in the vpd data. It is returned as
-// as a uint32. The offset is incremented by only 2 to get the next vpd value.
-       TERM_DATA_CKE_PRI_MAP =             0x36,  //uint32_t [2]
-// TERM_DATA_CKE_PWR_MAP is a uint64_t composed of the uint32_t port 0 and
-// port 1 values at this offset. The offset is incremented by 4.
-       TERM_DATA_CKE_PWR_MAP =             0x38,  //uint64_t
-       TERM_DATA_RLO = 0x3c|TERM_DATA_CHK60|TERM_DATA_LOW_NIBBLE,   //uint8_t[2]
-       TERM_DATA_WLO = 0x3c|TERM_DATA_CHK60|TERM_DATA_HIGH_NIBBLE,  //uint8_t[2]
-       TERM_DATA_GPO = 0x3d|TERM_DATA_CHK60,    //uint8_t[2]
-    };
-}
-// The max base offset value is 0x3e. The MT keyword is 255 bytes.
-// There is only room for 63 attributes per port. There are 4 x  64 byte
-// sections, but the last one is 1 byte short. See diagram below...
-const uint8_t TERM_DATA_OFFSET_MASK = 0x003f; //mask attr to isolate base offset
-
-// Template class that is specialized for each attribute specifying it's type
-template<const fapi::MBvpdTermData A>
-    class MBvpdTermDataSize { };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_DRAM_RON>
-    { public: typedef uint8_t Type[2][2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_DRAM_RTT_NOM>
-    { public: typedef uint8_t Type[2][2][4]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_DRAM_RTT_WR>
-    { public: typedef uint8_t Type[2][2][4]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_ODT_RD>
-    { public: typedef uint8_t Type[2][2][4]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_ODT_WR>
-    { public: typedef uint8_t Type[2][2][4]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_DIMM_RCD_IBT>
-    { public: typedef uint32_t Type[2][2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_DIMM_RCD_OUTPUT_TIMING>
-    { public: typedef uint8_t Type[2][2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_RD_VREF>
-    { public: typedef uint32_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_DRAM_WR_VREF>
-    { public: typedef uint32_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_DRAM_WRDDR4_VREF>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_RCV_IMP_DQ_DQS>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_DRV_IMP_DQ_DQS>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_DRV_IMP_CNTL>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_DRV_IMP_ADDR>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_DRV_IMP_CLK>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_DRV_IMP_SPCKE>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_SLEW_RATE_DQ_DQS>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_SLEW_RATE_CNTL>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_SLEW_RATE_ADDR>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_SLEW_RATE_CLK>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CEN_SLEW_RATE_SPCKE>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CKE_PRI_MAP>
-    { public: typedef uint32_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_CKE_PWR_MAP>
-    { public: typedef uint64_t Type ; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_RLO>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_WLO>
-    { public: typedef uint8_t Type[2]; };
-template<>class MBvpdTermDataSize<fapi::TERM_DATA_GPO>
-    { public: typedef uint8_t Type[2]; };
-
-// Template function that checks that the type is as expected.
-// This can be optionally called before calling the main HWP in order
-// to check for the expected type at compile-time.
-template<const fapi::MBvpdTermData ATTR>
-    inline void checkTermDataType
-        (typename MBvpdTermDataSize<ATTR>::Type &) {}
-/* example
-#define ATTR_VPD_DRAM_RON_GETMACRO(ID, PTARGET, VAL)\
-   (checkTermDataType<fapi::TERM_DATA_DRAM_RON>(VAL), \
-   fapi::platAttrSvc::fapiPlatGetTermData\
-      (PTARGET, fapi::TERM_DATA_DRAM_RON , VAL, sizeof(VAL)))
-*/
-// The complilation will fail unless the output variable matches the type
-// in the per attribute template specialization. The error messages will
-// include text related to template MBvpdTermDataSize not be able to convert
-// the incorrect output variable's type to the expected type.
-//
-// There will be an additonal error from the general attribute compliation
-// checks related to fapiCheckIdType if the output type does not match
-// any of the expected types
-//
-// The inline function checkTermData will be optimized out by the compiler.
-
-// function pointer typedef definition for HWP call support
-typedef fapi::ReturnCode (*getMBvpdTermData_FP_t)
-     (const fapi::Target &, const fapi::MBvpdTermData,
-      void *, const uint32_t);
-
-extern "C"
-{
-/**
- * @brief get Termination Data from cvpd record VSPD keyword MT
- *
- * The Termination Data attributes are retrieved from cvpd record VSPD
- * keyword MT.
- * There are two mba per memory buffer: position 0 and position 1.
- * There are two ports for each mba. There are 4 sets of Termination
- * Data attributes.
- *
- * cpvd record VSPD keyword MT
- * -----------------------------------
- * | mba position 0                  |
- * |  -----------------------------  |
- * |  | port 0  (Port A) 64 bytes |  |
- * |  |---------------------------|  |
- * |  | port 1  (Port B) 64 bytes |  |
- * |  -----------------------------  |
- * |---------------------------------|
- * | mba postion 1                   |
- * |  -----------------------------  |
- * |  | port 0  (Port C) 64 bytes |  |
- * |  |---------------------------|  |
- * |  | port 1  (Port D) 63 bytes |  |
- * |  -----------------------------  |
- * -----------------------------------
- *
- * The Termination Data attributes have multiple types. The output value
- * is a general void * to handle the multiple attributes types. The expected
- * output variable type is shown in the attribute enumeration comment and in
- * the MBvpdTermDataSize template.
- * An error will be returned if output size does not match the size of the
- * expected output type's size.
- *
- * @param[in]  i_mbaTarget       -   mba target
- * @param[in]  i_attr            -   Termination Data attribute enumerator
- * @param[out] o_pVal            -   pointer to variable typed output variable
- * @param[in]  i_valSize         -   size of output variable
- *
- * @return fapi::ReturnCode -   FAPI_RC_SUCCESS if success,
- *                              relevant error code for failure.
- */
-fapi::ReturnCode getMBvpdTermData(
-                              const fapi::Target   &i_mbaTarget,
-                              const fapi::MBvpdTermData i_attr,
-                              void  * o_pVal,
-                              const uint32_t i_valSize);
-}
-
-#endif
-
diff --git a/src/include/usr/hwpf/plat/fapiPlatAttributeService.H b/src/include/usr/hwpf/plat/fapiPlatAttributeService.H
index 70d4ef11c..b2d3a9b9d 100644
--- a/src/include/usr/hwpf/plat/fapiPlatAttributeService.H
+++ b/src/include/usr/hwpf/plat/fapiPlatAttributeService.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2011,2014                        */
+/* Contributors Listed Below - COPYRIGHT 2011,2015                        */
 /* [+] Google Inc.                                                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
@@ -47,9 +47,7 @@
 #include <hwpf/fapi/fapiReturnCode.H>
 #include <hwpf/fapi/fapiTarget.H>
 #include <hwpf/plat/fapiPlatAttrOverrideSync.H>
-#include <hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdAddrMirrorData.H>
-#include <hwpf/hwp/mvpd_accessors/getMBvpdTermData.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdSlopeInterceptData.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdSpareDramData.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdVersion.H>
@@ -58,6 +56,7 @@
 #include <hwpf/hwp/mvpd_accessors/getControlCapableData.H>
 #include <hwpf/hwp/mvpd_accessors/accessMBvpdL4BankDelete.H>
 #include <hwpf/hwp/mvpd_accessors/getISDIMMTOC4DAttrs.H>
+#include <hwpf/hwp/mvpd_accessors/getMBvpdAttr.H>
 #include <hwpf/hwp/spd_accessors/getSpdAttrAccessor.H>
 #include <hwpf/hwp/pll_accessors/getPllRingInfoAttr.H>
 #include <hwpf/hwp/chip_accessors/getOscswitchCtlAttr.H>
@@ -443,21 +442,6 @@ fapi::ReturnCode fapiPlatGetSingleMemberEnableAttr(
 
 /**
  * @brief This function is called by the FAPI_ATTR_GET macro when getting
- * the Phase Rotator Data attributes
- * It should not be called directly.
- *
- *  @param[in]  i_pTarget   Target mba pointer
- *  @param[in]  i_attr      Phase Rotator Data enumerator item
- *  @param[out] o_val       Phase Rotator Data for each of the 2 ports
- *  @return     ReturnCode. Zero on success, else platform specified error
- */
-fapi::ReturnCode fapiPlatGetPhaseRotatorData (
-                                    const fapi::Target * i_pTarget,
-                                    const fapi::MBvpdPhaseRotatorData i_attr,
-                                    uint8_t    (&o_val) [2] );
-
-/**
- * @brief This function is called by the FAPI_ATTR_GET macro when getting
  * the Address Mirroring Data attributes
  * It should not be called directly.
  *
@@ -471,20 +455,21 @@ fapi::ReturnCode fapiPlatGetAddrMirrorData (
 
 /**
  * @brief This function is called by the FAPI_ATTR_GET macro when getting
- * the Termination Data attributes
+ * the vpd attributes
  * It should not be called directly.
  *
  *  @param[in]  i_pTarget   Target MB pointer
- *  @param[in]  i_attr      Termination Data attribute enumerator
+ *  @param[in]  i_attr      Attribute Id
  *  @param[out] o_pVal      Pointer to variable typed output values
  *  @param[in]  i_valSize   Size of output variable
  *  @return     ReturnCode. Zero on success, else platform specified error
  */
-fapi::ReturnCode fapiPlatGetTermData (
+fapi::ReturnCode fapiPlatGetAttrData (
                               const fapi::Target * i_pTarget,
-                              const fapi::MBvpdTermData i_attr,
+                              const fapi::AttributeId i_attr,
                               void  * o_pVal,
-                              const uint32_t i_valSize);
+                              const size_t i_valSize);
+
 /**
  * @brief This function is called by the FAPI_ATTR_GET macro when getting
  * the Slope Intercept Data attributes
@@ -1238,206 +1223,308 @@ fapi::ReturnCode fapiPlatGetRCDCntlWord015 (const fapi::Target * i_pTarget,
 //  MACROS to support MBVPD Phase Rotator attributes
 //------------------------------------------------------------------------------
 #ifndef CONFIG_VPD_GETMACRO_USE_EFF_ATTR
+
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CLK_P0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CLK_P1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CLK_P0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CLK_P1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A2_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A2, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A2>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A2, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A3_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A3, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A3>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A3, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A4_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A4, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A4>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A4, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A5_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A5, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A5>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A5, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A6_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A6, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A6>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A6, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A7_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A7, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A7>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A7, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A8_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A8, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A8>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A8, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A9_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A9, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A9>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A9, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A10_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A10, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A10>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A10, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A11_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A11, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A11>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A11, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A12_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A12, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A12>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A12, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A13_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A13, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A13>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A13, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A14_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A14, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A14>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A14, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_A15_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_A15, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A15>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_A15, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_BA0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_BA1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA2_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_BA2, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA2>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA2, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_CASN_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_CASN, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_CASN>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_CASN, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_RASN_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_RASN, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_RASN>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_RASN, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_CMD_WEN_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_CMD_WEN, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_WEN>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_CMD_WEN, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_PAR_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_PAR, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_PAR>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_PAR, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M_ACTN_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M_ACTN, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M_ACTN>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M_ACTN, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_CKE0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_CKE1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE2_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_CKE2, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE2>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE2, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE3_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_CKE3, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE3>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE3, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_CSN0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_CSN1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN2_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_CSN2, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN2>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN2, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN3_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_CSN3, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN3>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN3, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_ODT0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M0_CNTL_ODT1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_CKE0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_CKE1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE2_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_CKE2, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE2>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE2, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE3_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_CKE3, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE3>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE3, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_CSN0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_CSN1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN1, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN2_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_CSN2, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN2>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN2, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN3_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_CSN3, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN3>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN3, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_ODT0, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT0>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT0, VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT1_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_M1_CNTL_ODT1, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT1>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+         (PTARGET, fapi::ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT1, VAL, sizeof(VAL)))
 #define ATTR_VPD_TSYS_ADR_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_TSYS_ADR, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_TSYS_ADR>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_TSYS_ADR, VAL, sizeof(VAL)))
 #define ATTR_VPD_TSYS_DP18_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
-    fapi::FAPI_RC_SUCCESS : fapi::platAttrSvc::fapiPlatGetPhaseRotatorData\
-        (PTARGET, PHASE_ROT_TSYS_DP18, VAL)
+        fapi::FAPI_RC_SUCCESS :\
+    (checkAttrDataType<fapi::ATTR_VPD_TSYS_DP18>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+            (PTARGET, fapi::ATTR_VPD_TSYS_DP18, VAL, sizeof(VAL)))
+
 #else
 #define ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P0_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
@@ -1865,159 +1952,160 @@ fapi::ReturnCode fapiPlatGetRCDCntlWord015 (const fapi::Target * i_pTarget,
 #define ATTR_VPD_DRAM_RON_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_DRAM_RON>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_DRAM_RON , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_DRAM_RON>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_DRAM_RON , VAL, sizeof(VAL)))
 #define ATTR_VPD_DRAM_RTT_NOM_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_DRAM_RTT_NOM>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_DRAM_RTT_NOM , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_DRAM_RTT_NOM>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_DRAM_RTT_NOM , VAL, sizeof(VAL)))
 #define ATTR_VPD_DRAM_RTT_WR_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_DRAM_RTT_WR>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_DRAM_RTT_WR , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_DRAM_RTT_WR>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_DRAM_RTT_WR , VAL, sizeof(VAL)))
 #define ATTR_VPD_ODT_RD_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_ODT_RD>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_ODT_RD , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_ODT_RD>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_ODT_RD , VAL, sizeof(VAL)))
 #define ATTR_VPD_ODT_WR_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_ODT_WR>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_ODT_WR , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_ODT_WR>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_ODT_WR , VAL, sizeof(VAL)))
 #define ATTR_VPD_DIMM_RCD_IBT_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_DIMM_RCD_IBT>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_DIMM_RCD_IBT , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_DIMM_RCD_IBT>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_DIMM_RCD_IBT , VAL, sizeof(VAL)))
 #define ATTR_VPD_DIMM_RCD_OUTPUT_TIMING_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_DIMM_RCD_OUTPUT_TIMING>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_DIMM_RCD_OUTPUT_TIMING , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_DIMM_RCD_OUTPUT_TIMING>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_DIMM_RCD_OUTPUT_TIMING , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_RD_VREF_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_RD_VREF>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_RD_VREF , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_RD_VREF>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_RD_VREF , VAL, sizeof(VAL)))
 #define ATTR_VPD_DRAM_WR_VREF_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_DRAM_WR_VREF>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_DRAM_WR_VREF , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_DRAM_WR_VREF>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_DRAM_WR_VREF , VAL, sizeof(VAL)))
 #define ATTR_VPD_DRAM_WRDDR4_VREF_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_DRAM_WRDDR4_VREF>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_DRAM_WRDDR4_VREF , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_DRAM_WRDDR4_VREF>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_DRAM_WRDDR4_VREF , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_RCV_IMP_DQ_DQS_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_RCV_IMP_DQ_DQS>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_RCV_IMP_DQ_DQS , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_RCV_IMP_DQ_DQS>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_RCV_IMP_DQ_DQS , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_DRV_IMP_DQ_DQS_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_DRV_IMP_DQ_DQS>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_DRV_IMP_DQ_DQS , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_DQ_DQS>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_DRV_IMP_DQ_DQS , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_DRV_IMP_CNTL_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_DRV_IMP_CNTL>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_DRV_IMP_CNTL , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_CNTL>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_DRV_IMP_CNTL , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_DRV_IMP_ADDR_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_DRV_IMP_ADDR>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_DRV_IMP_ADDR , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_ADDR>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_DRV_IMP_ADDR , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_DRV_IMP_CLK_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_DRV_IMP_CLK>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_DRV_IMP_CLK , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_CLK>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_DRV_IMP_CLK , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_DRV_IMP_SPCKE_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_DRV_IMP_SPCKE>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_DRV_IMP_SPCKE , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_DRV_IMP_SPCKE>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_DRV_IMP_SPCKE , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_SLEW_RATE_DQ_DQS>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_SLEW_RATE_DQ_DQS , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_DQ_DQS>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_SLEW_RATE_DQ_DQS , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_SLEW_RATE_CNTL_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_SLEW_RATE_CNTL>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_SLEW_RATE_CNTL , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_CNTL>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_SLEW_RATE_CNTL , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_SLEW_RATE_ADDR_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_SLEW_RATE_ADDR>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_SLEW_RATE_ADDR , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_ADDR>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_SLEW_RATE_ADDR , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_SLEW_RATE_CLK_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_SLEW_RATE_CLK>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_SLEW_RATE_CLK , VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_CLK>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_SLEW_RATE_CLK , VAL, sizeof(VAL)))
 #define ATTR_VPD_CEN_SLEW_RATE_SPCKE_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CEN_SLEW_RATE_SPCKE>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CEN_SLEW_RATE_SPCKE , VAL, sizeof(VAL)))
-#define ATTR_VPD_RLO_GETMACRO(ID, PTARGET, VAL)\
+    (checkAttrDataType<fapi::ATTR_VPD_CEN_SLEW_RATE_SPCKE>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CEN_SLEW_RATE_SPCKE , VAL, sizeof(VAL)))
+#define ATTR_VPD_CKE_PRI_MAP_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_RLO>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_RLO , VAL, sizeof(VAL)))
-#define ATTR_VPD_WLO_GETMACRO(ID, PTARGET, VAL)\
+    (checkAttrDataType<fapi::ATTR_VPD_CKE_PRI_MAP>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CKE_PRI_MAP , VAL, sizeof(VAL)))
+#define ATTR_VPD_CKE_PWR_MAP_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_WLO>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_WLO , VAL, sizeof(VAL)))
-#define ATTR_VPD_GPO_GETMACRO(ID, PTARGET, VAL)\
+    (checkAttrDataType<fapi::ATTR_VPD_CKE_PWR_MAP>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_CKE_PWR_MAP , &VAL, sizeof(VAL)))
+#define ATTR_VPD_RLO_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_GPO>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_GPO , VAL, sizeof(VAL)))
-#define ATTR_VPD_CKE_PRI_MAP_GETMACRO(ID, PTARGET, VAL)\
+    (checkAttrDataType<fapi::ATTR_VPD_RLO>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_RLO , VAL, sizeof(VAL)))
+#define ATTR_VPD_WLO_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CKE_PRI_MAP>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CKE_PRI_MAP , VAL, sizeof(VAL)))
-#define ATTR_VPD_CKE_PWR_MAP_GETMACRO(ID, PTARGET, VAL)\
+    (checkAttrDataType<fapi::ATTR_VPD_WLO>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_WLO , VAL, sizeof(VAL)))
+#define ATTR_VPD_GPO_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
         fapi::FAPI_RC_SUCCESS :\
-    (checkTermDataType<fapi::TERM_DATA_CKE_PWR_MAP>(VAL), \
-        fapi::platAttrSvc::fapiPlatGetTermData\
-           (PTARGET, fapi::TERM_DATA_CKE_PWR_MAP , &VAL, sizeof(VAL)))
+    (checkAttrDataType<fapi::ATTR_VPD_GPO>(VAL), \
+        fapi::platAttrSvc::fapiPlatGetAttrData\
+           (PTARGET, fapi::ATTR_VPD_GPO , VAL, sizeof(VAL)))
+
 #else
 #define ATTR_VPD_DRAM_RON_GETMACRO(ID, PTARGET, VAL)\
     fapi::AttrOverrideSync::getAttrOverrideFunc(fapi::ID, PTARGET, &VAL) ?\
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttr.C b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttr.C
new file mode 100644
index 000000000..59e2efdf8
--- /dev/null
+++ b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttr.C
@@ -0,0 +1,1700 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttr.C $              */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2015                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+// $Id: getMBvpdAttr.C,v 1.4 2015/01/09 21:53:07 whs Exp $
+/**
+ *  @file getMBvpdAttr.C
+ *
+ *  @brief get Attribute Data from MBvpd
+ *
+ */
+#include    <stdint.h>
+
+//  fapi support
+#include    <fapi.H>
+#include    <fapiUtil.H>
+#include    <getMBvpdAttr.H>
+#include    <getMBvpdVersion.H>
+
+// Used to ensure attribute enums are equal at compile time
+class Error_ConstantsDoNotMatch;
+template<const bool MATCH> void checkConstantsMatch()
+{
+    Error_ConstantsDoNotMatch();
+}
+template <> inline void checkConstantsMatch<true>() {}
+
+extern "C"
+{
+using   namespace   fapi;
+using   namespace   getAttrData;
+
+// ----------------------------------------------------------------------------
+// local functions
+// ----------------------------------------------------------------------------
+/**
+ *  @brief Find dimm info; parent, type, position
+ */
+fapi::ReturnCode findDimmInfo (const fapi::Target   & i_mbaTarget,
+                                     fapi::Target   & o_mbTarget,
+                                     uint8_t        & o_pos,
+                                     DimmType       & o_dimmType);
+/**
+ *  @brief Find attribute definition in global table
+ */
+fapi::ReturnCode findAttrDef (const fapi::Target    & i_mbaTarget,
+                              const DimmType        & i_dimmType,
+                              const fapi::AttributeId & i_attr,
+                              const MBvpdAttrDef*   & o_pAttrDef);
+/**
+ *  @brief Read the attribute keyword
+ */
+fapi::ReturnCode readKeyword (const fapi::Target   & i_mbTarget,
+                              const fapi::Target   & i_mbaTarget,
+                              const MBvpdAttrDef   * i_pAttrDef,
+                              const DimmType       & i_dimmType,
+                                    attr_keyword   * i_pBuffer,
+                              const uint32_t       & i_bufsize);
+/**
+ *  @brief return default output value
+ */
+fapi::ReturnCode returnDefault (const MBvpdAttrDef    * i_pAttrDef,
+                                        void          * o_pVal,
+                                const size_t          & i_valSize);
+
+/**
+ *  @brief Return the output value
+ */
+fapi::ReturnCode returnValue (const MBvpdAttrDef    * i_pAttrDef,
+                              const uint8_t         & i_pos,
+                                    void            * o_pVal,
+                              const size_t          & i_valSize,
+                                    attr_keyword    * i_pBuffer,
+                              const uint32_t        & i_bufsize);
+
+/**
+ *  @brief Translation functions
+ */
+fapi::ReturnCode xlate_DRAM_RON (const fapi::AttributeId i_attr,
+                                     uint8_t & io_value);
+fapi::ReturnCode xlate_RTT_NOM  (const fapi::AttributeId i_attr,
+                                     uint8_t & io_value);
+fapi::ReturnCode xlate_RTT_WR   (const fapi::AttributeId i_attr,
+                                     uint8_t & io_value);
+fapi::ReturnCode xlate_WR_VREF  (const fapi::AttributeId i_attr,
+                                     uint32_t & io_value);
+fapi::ReturnCode xlate_RD_VREF  (const fapi::AttributeId i_attr,
+                                     uint32_t & io_value);
+fapi::ReturnCode xlate_SLEW_RATE (const fapi::AttributeId i_attr,
+                                     uint8_t & io_value);
+
+/**
+ *  @brief Find the ISDIMM MR keyword
+ */
+fapi::ReturnCode FindMRkeyword (const fapi::Target       & i_mbTarget,
+                                      fapi::MBvpdKeyword & o_keyword);
+/**
+ *  @brief Find the ISDIMM MT keyword
+ */
+fapi::ReturnCode FindMTkeyword (const fapi::Target       & i_mbTarget,
+                                const fapi::Target       & i_mbaTarget,
+                                      fapi::MBvpdKeyword & o_keyword);
+// ----------------------------------------------------------------------------
+// HWP accessor to get MBvpd Attribute Data
+// ----------------------------------------------------------------------------
+fapi::ReturnCode getMBvpdAttr(const fapi::Target   &i_mbaTarget,
+                              const fapi::AttributeId i_attr,
+                              void  * o_pVal,
+                              const size_t i_valSize)
+{
+    fapi::ReturnCode l_fapirc;
+    attr_keyword *   l_pBuffer = NULL;
+    const uint32_t   l_bufsize = sizeof(attr_keyword);
+
+    FAPI_DBG("getMBvpdAttr: entry attr=0x%02x, size=%d ",
+             i_attr,i_valSize  );
+
+    do
+    {
+        fapi::Target l_mbTarget;
+        uint8_t  l_pos = NUM_PORTS;     //initialize to out of range value (+1)
+        DimmType l_dimmType = ALL_DIMM;
+        const MBvpdAttrDef * l_pAttrDef = NULL;
+
+        // find DIMM Info; parent, position, dimm type
+        l_fapirc = findDimmInfo (i_mbaTarget, l_mbTarget, l_pos, l_dimmType);
+        if (l_fapirc)
+        {
+            break; // return with error
+        }
+
+        // find Attribute definition
+        l_fapirc = findAttrDef (i_mbaTarget, l_dimmType, i_attr, l_pAttrDef);
+        if (l_fapirc)
+        {
+            break; // return with error
+        }
+
+        // Either just return defaults or read keyword and return vpd data
+        // Mask off the special processing flags from the output type.
+        if (DEFAULT_VALUE ==
+                        ((l_pAttrDef->iv_outputType) & SPECIAL_PROCESSING_MASK))
+        {
+            l_fapirc = returnDefault (l_pAttrDef,
+                                      o_pVal,
+                                      i_valSize);
+            if (l_fapirc) break; // return with error
+
+        }
+        else
+        {
+            l_pBuffer = new attr_keyword;
+            l_fapirc = readKeyword (l_mbTarget,
+                                i_mbaTarget,
+                                l_pAttrDef,
+                                l_dimmType,
+                                l_pBuffer,
+                                l_bufsize);
+            if (l_fapirc) break; // return with error
+
+            // retrun the output value
+            l_fapirc = returnValue (l_pAttrDef,
+                                    l_pos,
+                                    o_pVal,
+                                    i_valSize,
+                                    l_pBuffer,
+                                    l_bufsize);
+            if (l_fapirc) break; // return with error
+        }
+    }
+    while (0);
+
+    delete l_pBuffer;
+    l_pBuffer = NULL;
+
+    FAPI_DBG("getMBvpdAttr: exit rc=0x%08x",
+               static_cast<uint32_t>(l_fapirc));
+
+    return  l_fapirc;
+
+}
+
+// ----------------------------------------------------------------------------
+// local functions
+// ----------------------------------------------------------------------------
+
+
+// find dimm info; parent, type, position
+fapi::ReturnCode findDimmInfo (const fapi::Target & i_mbaTarget,
+                                     fapi::Target & o_mbTarget,
+                                     uint8_t      & o_pos,
+                                     DimmType     & o_dimmType)
+{
+    fapi::ReturnCode l_fapirc;
+
+    do
+    {
+        // find the position of the passed mba on the centuar
+        l_fapirc = FAPI_ATTR_GET(ATTR_CHIP_UNIT_POS,&i_mbaTarget,o_pos);
+        if (l_fapirc)
+        {
+            FAPI_ERR(" getMBvpdAttr: Get MBA position failed ");
+            break;  //  break out with fapirc
+        }
+        FAPI_DBG("getMBvpdAttr: mba %s position=%d",
+             i_mbaTarget.toEcmdString(),
+             o_pos);
+
+        // find the Centaur memmory buffer from the passed MBA
+        l_fapirc = fapiGetParentChip (i_mbaTarget,o_mbTarget);
+        if (l_fapirc)
+        {
+            FAPI_ERR("getMBvpdAttr: Finding the parent mb failed ");
+            break;  //  break out with fapirc
+        }
+        FAPI_DBG("getMBvpdAttr: parent path=%s ",
+             o_mbTarget.toEcmdString()  );
+
+        // Determine if ISDIMM or CDIMM
+        std::vector<fapi::Target> l_target_dimm_array;
+
+        l_fapirc = fapiGetAssociatedDimms(i_mbaTarget, l_target_dimm_array);
+        if(l_fapirc)
+        {
+           FAPI_ERR("getMBvpdAttr: Problem getting DIMMs of MBA");
+           break;   //return error
+        }
+        if(l_target_dimm_array.size() != 0)
+        {
+            uint8_t l_customDimm=0;
+            l_fapirc = FAPI_ATTR_GET(ATTR_SPD_CUSTOM,&l_target_dimm_array[0],
+                          l_customDimm);
+            if(l_fapirc) {
+               FAPI_ERR(" getMBvpdAttr: ATTR_SPD_CUSTOM failed ");
+               break;   //return error
+            }
+
+            if (l_customDimm == fapi::ENUM_ATTR_SPD_CUSTOM_YES)
+            {
+                o_dimmType = CDIMM;
+                FAPI_DBG("getMBvpdAttr: CDIMM TYPE!!!");
+            }
+            else
+            {
+                o_dimmType = ISDIMM;
+                FAPI_DBG("getMBvpdAttr: ISDIMM TYPE!!!");
+            }
+        }
+        else
+        {
+           o_dimmType = ISDIMM;
+           FAPI_DBG("getMBvpdAttr: ISDIMM TYPE (dimm array size = 0)");
+        }
+    }
+    while (0);
+
+    return l_fapirc;
+}
+
+// find attribute definition
+// table rules:
+//     Vesions must be in decreasing order (highest first...)
+//        for a specific Dimm Type. The first match found, searching
+//        from row index 0 to the end, will be used.
+
+fapi::ReturnCode findAttrDef (const fapi::Target    & i_mbaTarget,
+                              const DimmType        & i_dimmType,
+                              const AttributeId     & i_attr,
+                              const MBvpdAttrDef*   & o_pAttrDef)
+{
+    fapi::ReturnCode l_fapirc;
+    o_pAttrDef = NULL;
+
+    // find first row in the attribute defintion table for this attribute
+    uint32_t l_version = ALL_VER; // invalid vpd value
+    uint32_t i=0; //at this scope for the debug message at end
+    for (; i <= g_MBVPD_ATTR_DEF_array_size; i++)
+    {
+        if ( (g_MBVPD_ATTR_DEF_array[i].iv_attrId == i_attr) &&
+             ((i_dimmType == g_MBVPD_ATTR_DEF_array[i].iv_dimmType) ||
+              (ALL_DIMM   == g_MBVPD_ATTR_DEF_array[i].iv_dimmType)) )
+        {
+
+            // most are expected to be the same for all Dimm Types and versions
+            if (ALL_VER  == g_MBVPD_ATTR_DEF_array[i].iv_version)
+            {
+                o_pAttrDef = &g_MBVPD_ATTR_DEF_array[i];
+                break; //use this row
+            }
+            if (ALL_VER == l_version)  // have not read version yet
+            {
+                // get vpd version (only when actually needed)
+                FAPI_EXEC_HWP(l_fapirc,
+                              getMBvpdVersion,
+                              i_mbaTarget,
+                              l_version);
+
+                if (l_fapirc)
+                {
+                    FAPI_ERR("getMBvpdAttr: getMBvpdVersion failed");
+                    break;  //  break out with fapirc
+                }
+                FAPI_DBG("getMBvpdAttr: read vpd version = 0x%04x",
+                          l_version );
+
+            }
+            if ((uint32_t)g_MBVPD_ATTR_DEF_array[i].iv_version <= l_version)
+            {
+                o_pAttrDef = &g_MBVPD_ATTR_DEF_array[i];
+                break; //use this row
+            }
+        }
+    }
+
+    // return an error if definition was not found
+    if (NULL == o_pAttrDef)
+    {
+        if (!l_fapirc) // if no other error found
+        {
+            // Could be due to a table error, which shouldn't happen because
+            // every attribute has an ALL_DIMM ALL_VER entry.
+            // More likely due to an invalid attribute ID being passed.
+            FAPI_ERR("getMBvpdAttr: attr ID not in table 0x%02x dimmType=%d",
+                      i_attr,
+                      i_dimmType);
+            const fapi::AttributeId & ATTR_ID = i_attr;
+            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_ATTRIBUTE_ID);
+        }
+    }
+    else
+    {
+        FAPI_DBG("getMBvpdAttr: use attribute definition row=%d",i );
+    }
+
+    return l_fapirc;
+}
+
+// read the attribute keyword
+// note: i_pAttrDef->iv_dimmType is likely ALL_DIMM were as
+//       l_dimmType will be either CDIMM or ISDIMM
+fapi::ReturnCode readKeyword (const fapi::Target   & i_mbTarget,
+                              const fapi::Target   & i_mbaTarget,
+                              const MBvpdAttrDef   * i_pAttrDef,
+                              const DimmType       & i_dimmType,
+                                    attr_keyword   * i_pBuffer,
+                              const uint32_t       & i_bufsize)
+{
+    fapi::ReturnCode l_fapirc;
+    uint32_t         l_bufsize = i_bufsize;
+    fapi::MBvpdKeyword l_keyword = i_pAttrDef->iv_keyword; //default for CDIMMs
+    fapi::MBvpdRecord  l_record  = MBVPD_RECORD_VSPD;      //default for CDIMMs
+
+    FAPI_DBG("getMBvpdAttr: Read keyword %d ",l_keyword);
+    do
+    {
+        if (CDIMM != i_dimmType)
+        {
+            if (MBVPD_KEYWORD_MT == l_keyword)
+            {
+                l_fapirc = FindMTkeyword (i_mbTarget,
+                                          i_mbaTarget,
+                                          l_keyword);
+                if (l_fapirc) break; //return with error
+            }
+            else if (MBVPD_KEYWORD_MR == l_keyword)
+            {
+                l_fapirc = FindMRkeyword (i_mbTarget,
+                                          l_keyword);
+                if (l_fapirc) break; //return with error
+            }
+            else //table error, shouldn't happen
+            {
+                FAPI_ERR("getMBvpdAttr: invalid keyword %d for dimmType=%d",
+                      l_keyword,
+                      i_dimmType);
+                const fapi::AttributeId & ATTR_ID = i_pAttrDef->iv_attrId;
+                const fapi::MBvpdKeyword & KEYWORD =  l_keyword;
+                FAPI_SET_HWP_ERROR(l_fapirc,RC_MBVPD_UNEXPECTED_ISDIMM_KEYWORD);
+                break; // return error
+            }
+            l_record  = fapi::MBVPD_RECORD_SPDX;      // for ISDIMMs
+        }
+        // Retrieve attribute keyword
+        l_fapirc = fapiGetMBvpdField(l_record,
+                             l_keyword,
+                             i_mbTarget,
+                             reinterpret_cast<uint8_t *>(i_pBuffer),
+                             l_bufsize);
+        if (l_fapirc)
+        {
+            FAPI_ERR("getMBvpdAttr: Read of attr keyword failed");
+            break;  //  break out with fapirc
+        }
+
+        // Check that sufficient keyword was returned.
+        if (l_bufsize < ATTR_KEYWORD_SIZE )
+        {
+            FAPI_ERR("getMBvpdAttr:"
+                     " less keyword returned than expected %d < %d",
+                       i_bufsize, ATTR_KEYWORD_SIZE);
+            const uint32_t & KEYWORD = l_keyword;
+            const uint32_t & RETURNED_SIZE = i_bufsize;
+            const fapi::Target & CHIP_TARGET = i_mbTarget;
+            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INSUFFICIENT_VPD_RETURNED );
+            break;  //  break out with fapirc
+        }
+    }
+    while (0);
+    return l_fapirc;
+}
+
+// used by returnValue to consolidate setting invalid size error
+fapi::ReturnCode sizeMismatch (const size_t   i_correctSize,
+                               const size_t   i_inputSize,
+                               const fapi::AttributeId i_attr)
+{
+    fapi::ReturnCode l_fapirc;
+    do
+    {
+        FAPI_ERR("getMBvpdAttr:"
+                 " output variable size does not match expected %d != %d"
+                 " for attr id=0x%08x",
+                   i_correctSize, i_inputSize, i_attr);
+        const fapi::AttributeId & ATTR_ID = i_attr;
+        const uint32_t & EXPECTED_SIZE = i_correctSize;
+        const uint32_t & PASSED_SIZE = i_inputSize;
+        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE);
+    }
+    while (0);
+    return l_fapirc;
+}
+
+
+// return default output value
+fapi::ReturnCode returnDefault (const MBvpdAttrDef  * i_pAttrDef,
+                                void                * o_pVal,
+                                const size_t        & i_valSize)
+{
+    fapi::ReturnCode l_fapirc;
+    uint16_t  l_outputType = i_pAttrDef->iv_outputType & OUTPUT_TYPE_MASK;
+
+    FAPI_DBG("getMBvpdAttr: default value outputType=0x%04x ",
+              l_outputType);
+
+    // return default according to the attribute varible type
+    switch (l_outputType)
+    {
+        case UINT8_BY2:        // uint8_t [2]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT8_BY2_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT8_BY2_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint8_t l_value = (uint8_t)i_pAttrDef->iv_defaultValue;
+
+            (*(UINT8_BY2_t*)o_pVal)[0] = l_value;
+            (*(UINT8_BY2_t*)o_pVal)[1] = l_value;
+            break;
+        }
+
+        case  UINT8_BY2_BY2:     // uint8_t  [2][2]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT8_BY2_BY2_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT8_BY2_BY2_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint8_t l_value =  (uint8_t)i_pAttrDef->iv_defaultValue;
+            for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
+            {
+                for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
+                {
+                    (*(UINT8_BY2_BY2_t*)o_pVal)[l_port][l_j] = l_value;
+                }
+           }
+           break;
+        }
+
+        case  UINT8_BY2_BY2_BY4: // uint8_t  [2][2][4]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT8_BY2_BY2_BY4_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT8_BY2_BY2_BY4_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint8_t l_value = (uint8_t)i_pAttrDef->iv_defaultValue;
+            for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
+            {
+                for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
+                {
+                    for (uint8_t l_k=0; l_k<NUM_RANKS; l_k++)
+                    {
+                        (*(UINT8_BY2_BY2_BY4_t*)o_pVal)[l_port][l_j][l_k] =
+                                                                        l_value;
+                    }
+                }
+           }
+           break;
+        }
+
+        case  UINT32_BY2:        // uint32_t [2]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT32_BY2_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT32_BY2_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint32_t l_value = (uint32_t)i_pAttrDef->iv_defaultValue;
+
+            for (uint8_t l_port=0; l_port<2;l_port++)
+            {
+                (*(UINT32_BY2_t*)o_pVal)[l_port] = l_value;
+            }
+            break;
+        }
+
+        case  UINT32_BY2_BY2:        // uint32_t [2][2]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT32_BY2_BY2_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT32_BY2_BY2_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint32_t l_value = (uint32_t)i_pAttrDef->iv_defaultValue;
+
+            for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
+            {
+                for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
+                {
+                    (*(UINT32_BY2_BY2_t*)o_pVal)[l_port][l_j] = l_value;
+                }
+            }
+            break;
+        }
+
+        case  UINT64:            // uint64_t
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT64_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT64_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint64_t l_value = (uint64_t)i_pAttrDef->iv_defaultValue;
+            (*(UINT64_t*)o_pVal) = l_value;
+            break ;
+        }
+        default: // Hard to do, but needs to be caught
+            FAPI_ERR("getMBvpdAttrData: invalid output type 0x%04x for"
+                       " attribute ID 0x%08x",
+                       i_pAttrDef->iv_outputType,
+                       i_pAttrDef->iv_attrId);
+            const fapi::AttributeId & ATTR_ID = i_pAttrDef->iv_attrId;
+            const DimmType & DIMM_TYPE =  i_pAttrDef->iv_dimmType;
+            const uint16_t & OUTPUT_TYPE = i_pAttrDef->iv_outputType;
+            FAPI_SET_HWP_ERROR(l_fapirc,
+                                       RC_MBVPD_DEFAULT_UNEXPECTED_OUTPUT_TYPE);
+            break;  //  break out with fapirc
+    }
+
+    return l_fapirc;
+}
+
+// used by returnValue to consolidate pulling an uint32_t value from vpd based
+// on the size of the data in the vpd layout (uint8_t, uint16_t, or uint32_t).
+uint32_t getUint32 (const uint16_t & i_dataSpecial,
+                          uint8_t *  i_pBuffer)
+{
+    uint32_t o_val = 0;
+
+    if (UINT8_DATA == i_dataSpecial)
+    {
+        o_val = *i_pBuffer;
+    }
+    else if (UINT16_DATA == i_dataSpecial)
+    {
+        o_val = *(i_pBuffer+1);      // LSB
+        o_val |= ((*i_pBuffer)<<8);  // MSB
+    }
+    else
+    {
+        o_val  = FAPI_BE32TOH(*(uint32_t*) i_pBuffer);
+    }
+
+    return o_val;
+}
+
+// return the output value
+// i_pBuffer will be NULL if the default value is to be used.
+fapi::ReturnCode returnValue (const MBvpdAttrDef*   i_pAttrDef,
+                              const uint8_t         & i_pos,
+                                    void            * o_pVal,
+                              const size_t          & i_valSize,
+                                    attr_keyword    * i_pBuffer,
+                              const uint32_t        & i_bufsize)
+{
+    fapi::ReturnCode l_fapirc;
+    const uint8_t     l_attrOffset = i_pAttrDef->iv_offset;
+    uint16_t  l_outputType= i_pAttrDef->iv_outputType & OUTPUT_TYPE_MASK;
+    uint16_t  l_special   = i_pAttrDef->iv_outputType & SPECIAL_PROCESSING_MASK;
+
+    FAPI_DBG("getMBvpdAttr: output offset=0%02x pos=%d outputType=0x%04x"
+              " special=0x%04x ",
+              l_attrOffset,i_pos,l_outputType,l_special);
+
+    // return data according to the attribute varible type
+    switch (l_outputType)
+    {
+        case UINT8_BY2:        // uint8_t [2]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT8_BY2_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT8_BY2_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            // pull data from keyword buffer
+            uint8_t l_port0 = i_pBuffer->
+                    mb_mba[i_pos].mba_port[0].port_attr[l_attrOffset];
+            uint8_t l_port1 = i_pBuffer->
+                    mb_mba[i_pos].mba_port[1].port_attr[l_attrOffset];
+
+            switch (l_special)
+            {
+                case LOW_NIBBLE: // return low nibble
+                    l_port0 = l_port0 & 0x0F;
+                    l_port1 = l_port1 & 0x0F;
+                    break;
+
+                case HIGH_NIBBLE: // return high nibble
+                    l_port0 = ((l_port0 & 0xF0)>>4);
+                    l_port1 = ((l_port1 & 0xF0)>>4);
+                    break;
+
+                case PORT00: // return port 0 for both ports 0 and 1
+                    l_port1=l_port0;
+                    break;
+
+                case PORT11: // return port 1 for both ports 0 and 1
+                    l_port0=l_port1;
+                    break;
+
+                case XLATE_SLEW:
+                    l_fapirc = xlate_SLEW_RATE( i_pAttrDef->iv_attrId,l_port0);
+                    if (l_fapirc) break;
+                    l_fapirc = xlate_SLEW_RATE( i_pAttrDef->iv_attrId,l_port1);
+                    if (l_fapirc) break;
+
+                default:
+                     ;      // use data  directly from  keyword buffer
+            }
+            if (l_fapirc) break;
+
+            (*(UINT8_BY2_t*)o_pVal)[0] = l_port0;
+            (*(UINT8_BY2_t*)o_pVal)[1] = l_port1;
+            break;
+        }
+
+        case  UINT8_BY2_BY2:     // uint8_t  [2][2]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT8_BY2_BY2_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT8_BY2_BY2_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
+            {
+                uint8_t l_dimm0 = i_pBuffer->
+                         mb_mba[i_pos].mba_port[l_port].port_attr[l_attrOffset];
+                uint8_t l_dimm1 = 0;
+                if (BOTH_DIMMS == l_special)
+                {
+                    l_dimm1 = l_dimm0; //use vpd value for both DIMMs
+                }
+                else
+                {
+                    l_dimm1 = i_pBuffer->
+                       mb_mba[i_pos].mba_port[l_port].port_attr[l_attrOffset+1];
+                    switch (l_special)
+                    {
+                        case XLATE_DRAM_RON: // translate
+                            l_fapirc =
+                                  xlate_DRAM_RON(i_pAttrDef->iv_attrId,l_dimm0);
+                            if (l_fapirc) break; //break with error
+                            l_fapirc =
+                                  xlate_DRAM_RON(i_pAttrDef->iv_attrId,l_dimm1);
+                        default:
+                            ;      // use data  directly from  keyword buffer
+                    }
+                }
+                if (l_fapirc)  break; // break with error
+                (*(UINT8_BY2_BY2_t*)o_pVal)[l_port][0] = l_dimm0;
+                (*(UINT8_BY2_BY2_t*)o_pVal)[l_port][1] = l_dimm1;
+           }
+           break;
+        }
+
+        case  UINT8_BY2_BY2_BY4: // uint8_t  [2][2][4]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT8_BY2_BY2_BY4_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT8_BY2_BY2_BY4_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint8_t l_value = 0;
+            for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
+            {
+                for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
+                {
+                    for (uint8_t l_k=0; l_k<NUM_RANKS; l_k++)
+                    {
+                        l_value = i_pBuffer->
+     mb_mba[i_pos].mba_port[l_port].port_attr[l_attrOffset+(l_j)*NUM_RANKS+l_k];
+                        switch (l_special)
+                        {
+                            case XLATE_RTT_NOM: // translate
+                                l_fapirc=xlate_RTT_NOM(i_pAttrDef->iv_attrId,
+                                                                       l_value);
+                                break;
+                            case XLATE_RTT_WR: // translate
+                                l_fapirc=xlate_RTT_WR(i_pAttrDef->iv_attrId,
+                                                                       l_value);
+                            default:
+                                ;     // use data  directly from  keyword buffer
+                        }
+                        if (l_fapirc)  break; // break with error
+                        (*(UINT8_BY2_BY2_BY4_t*)o_pVal)[l_port][l_j][l_k] =
+                                                                        l_value;
+                    }
+                    if (l_fapirc)  break; // break with error
+                }
+                if (l_fapirc) break; // break with error
+           }
+           break;
+
+        }
+        case  UINT32_BY2:        // uint32_t [2]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT32_BY2_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT32_BY2_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint16_t l_xlateSpecial = SPECIAL_XLATE_MASK & l_special;
+            uint16_t l_dataSpecial  = SPECIAL_DATA_MASK  & l_special;
+            for (uint8_t l_port=0; l_port<2;l_port++)
+            {
+                uint32_t l_value = getUint32 (l_dataSpecial, &(i_pBuffer->
+                      mb_mba[i_pos].mba_port[l_port].port_attr[l_attrOffset]));
+                switch (l_xlateSpecial)
+                {
+                    case XLATE_RD_VREF: // translate
+                        l_fapirc=xlate_RD_VREF(i_pAttrDef->iv_attrId,
+                                                               l_value);
+                        break;
+                    case XLATE_WR_VREF: // translate
+                        l_fapirc=xlate_WR_VREF(i_pAttrDef->iv_attrId,
+                                                               l_value);
+                    default:
+                        ;     // use data  directly from  keyword buffer
+                }
+                if (l_fapirc)  break; // break with error
+                (*(UINT32_BY2_t*)o_pVal)[l_port] = l_value;
+            }
+            break;
+        }
+        case  UINT32_BY2_BY2:        // uint32_t [2][2]
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT32_BY2_BY2_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT32_BY2_BY2_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint16_t l_dataSpecial  = SPECIAL_DATA_MASK  & l_special;
+            for (uint8_t l_port=0; l_port<2;l_port++)
+            {
+                for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
+                {
+                    uint32_t l_value = getUint32 (l_dataSpecial, &(i_pBuffer->
+                      mb_mba[i_pos].mba_port[l_port].port_attr[l_attrOffset]));
+                    (*(UINT32_BY2_BY2_t*)o_pVal)[l_port][l_j] = l_value;
+                }
+            }
+            break;
+        }
+        case  UINT64:            // uint64_t
+        {
+            // make sure return value size is correct
+            if (sizeof(UINT64_t) != i_valSize)
+            {
+                l_fapirc = sizeMismatch(sizeof(UINT64_t),
+                                        i_valSize,
+                                        i_pAttrDef->iv_attrId);
+                break; //return with error
+            }
+
+            uint64_t l_value = 0;
+            if (MERGE == l_special)
+            {
+                uint32_t l_port0 = getUint32 (UINT32_DATA, &(i_pBuffer->
+                        mb_mba[i_pos].mba_port[0].port_attr[l_attrOffset]));
+                uint32_t l_port1 = getUint32 (UINT32_DATA, &(i_pBuffer->
+                        mb_mba[i_pos].mba_port[1].port_attr[l_attrOffset]));
+                l_value = ( ((static_cast<uint64_t>(l_port0))<<32) |
+                               (static_cast<uint64_t>(l_port1)) );
+            }
+            else
+            {
+                FAPI_ERR("getMBvpdAttrData: invalid output type 0x%04x for"
+                       " attribute ID 0x%08x UINT64_T",
+                       i_pAttrDef->iv_outputType,
+                       i_pAttrDef->iv_attrId);
+                const fapi::AttributeId & ATTR_ID = i_pAttrDef->iv_attrId;
+                const DimmType & DIMM_TYPE =  i_pAttrDef->iv_dimmType;
+                const uint16_t & OUTPUT_TYPE = i_pAttrDef->iv_outputType;
+                FAPI_SET_HWP_ERROR(l_fapirc,
+                                        RC_MBVPD_UINT64_UNEXPECTED_OUTPUT_TYPE);
+                break;  //  break out with fapirc
+            }
+            (*(UINT64_t*)o_pVal) = l_value;
+            break ;
+        }
+        default: // Hard to do, but needs to be caught
+            FAPI_ERR("getMBvpdAttrData: invalid output type 0x%04x for"
+                       " attribute ID 0x%08x",
+                       i_pAttrDef->iv_outputType,
+                       i_pAttrDef->iv_attrId);
+            const fapi::AttributeId & ATTR_ID = i_pAttrDef->iv_attrId;
+            const DimmType & DIMM_TYPE =  i_pAttrDef->iv_dimmType;
+            const uint16_t & OUTPUT_TYPE = i_pAttrDef->iv_outputType;
+            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_UNEXPECTED_OUTPUT_TYPE);
+            break;  //  break out with fapirc
+    }
+    return l_fapirc;
+}
+
+// ----------------------------------------------------------------------------
+// Translate vpd values to attribute enumeration for ATTR_VPD_DRAM_RON
+// ----------------------------------------------------------------------------
+fapi::ReturnCode xlate_DRAM_RON (const fapi::AttributeId i_attr,
+                                     uint8_t & io_value)
+{
+    fapi::ReturnCode l_fapirc;
+    const uint8_t VPD_DRAM_RON_INVALID = 0x00;
+    const uint8_t VPD_DRAM_RON_OHM34 = 0x07;
+    const uint8_t VPD_DRAM_RON_OHM40 = 0x03;
+
+    switch (io_value)
+    {
+    case VPD_DRAM_RON_INVALID:
+        io_value=fapi::ENUM_ATTR_VPD_DRAM_RON_INVALID;
+        break;
+    case VPD_DRAM_RON_OHM34:
+        io_value=fapi::ENUM_ATTR_VPD_DRAM_RON_OHM34;
+        break;
+    case VPD_DRAM_RON_OHM40:
+        io_value=fapi::ENUM_ATTR_VPD_DRAM_RON_OHM40;
+        break;
+    default:
+        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_DRAM_RON 0x%02x",
+                 io_value);
+        const fapi::AttributeId & ATTR_ID = i_attr;
+        const uint8_t  & VPD_VALUE = io_value;
+        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
+        break;
+    }
+
+    return  l_fapirc;
+}
+
+// ----------------------------------------------------------------------------
+// Translate vpd values to attribute enumeration for ATTR_VPD_DRAM_RTT_NOM
+// ----------------------------------------------------------------------------
+fapi::ReturnCode xlate_RTT_NOM (const fapi::AttributeId i_attr,
+                                         uint8_t & io_value)
+{
+    fapi::ReturnCode l_fapirc;
+    const uint8_t DRAM_RTT_NOM_DISABLE = 0x00;
+    const uint8_t DRAM_RTT_NOM_OHM20 = 0x04;
+    const uint8_t DRAM_RTT_NOM_OHM30 = 0x05;
+    const uint8_t DRAM_RTT_NOM_OHM34 = 0x07;
+    const uint8_t DRAM_RTT_NOM_OHM40 = 0x03;
+    const uint8_t DRAM_RTT_NOM_OHM48 = 0x85;
+    const uint8_t DRAM_RTT_NOM_OHM60 = 0x01;
+    const uint8_t DRAM_RTT_NOM_OHM80 = 0x06;
+    const uint8_t DRAM_RTT_NOM_OHM120 = 0x02;
+    const uint8_t DRAM_RTT_NOM_OHM240 = 0x84;
+
+    switch(io_value)
+    {
+    case DRAM_RTT_NOM_DISABLE:
+        io_value=fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_DISABLE;
+        break;
+    case DRAM_RTT_NOM_OHM20:
+        io_value= fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM20;
+        break;
+    case DRAM_RTT_NOM_OHM30:
+        io_value= fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM30;
+        break;
+    case DRAM_RTT_NOM_OHM34:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM34;
+        break;
+    case DRAM_RTT_NOM_OHM40:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM40;
+        break;
+    case DRAM_RTT_NOM_OHM48:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM48;
+        break;
+    case DRAM_RTT_NOM_OHM60:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM60;
+        break;
+    case DRAM_RTT_NOM_OHM80:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM80;
+        break;
+    case DRAM_RTT_NOM_OHM120:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM120;
+        break;
+    case DRAM_RTT_NOM_OHM240:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM240;
+        break;
+    default:
+        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_DRAM_RTT_NOM 0x%02x",
+                    io_value);
+        const fapi::AttributeId & ATTR_ID = i_attr;
+        const uint8_t  & VPD_VALUE = io_value;
+        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
+        break;
+    }
+
+    return  l_fapirc;
+}
+
+// ----------------------------------------------------------------------------
+// Translate vpd values to attribute enumeration for ATTR_VPD_DRAM_RTT_WR
+// ----------------------------------------------------------------------------
+fapi::ReturnCode xlate_RTT_WR (const fapi::AttributeId i_attr,
+                                        uint8_t & io_value)
+{
+    fapi::ReturnCode l_fapirc;
+    const uint8_t DRAM_RTT_WR_DISABLE = 0x00;
+    const uint8_t DRAM_RTT_WR_OHM60   = 0x01;
+    const uint8_t DRAM_RTT_WR_OHM120  = 0x02;
+
+    switch(io_value)
+    {
+    case DRAM_RTT_WR_DISABLE:
+        io_value=fapi::ENUM_ATTR_VPD_DRAM_RTT_WR_DISABLE;
+        break;
+    case DRAM_RTT_WR_OHM60:
+        io_value= fapi::ENUM_ATTR_VPD_DRAM_RTT_WR_OHM60;
+        break;
+    case DRAM_RTT_WR_OHM120:
+        io_value= fapi::ENUM_ATTR_VPD_DRAM_RTT_WR_OHM120;
+        break;
+    default:
+        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_DRAM_RTT_WR 0x%02x",
+                    io_value);
+        const fapi::AttributeId & ATTR_ID = i_attr;
+        const uint8_t  & VPD_VALUE = io_value;
+        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
+        break;
+    }
+
+    return  l_fapirc;
+}
+
+// ----------------------------------------------------------------------------
+// Translate vpd values to attribute enumeration for ATTR_VPD_DRAM_WR_VREF
+// ----------------------------------------------------------------------------
+fapi::ReturnCode xlate_WR_VREF (const fapi::AttributeId i_attr,
+                                         uint32_t & io_value)
+{
+    fapi::ReturnCode l_fapirc;
+    // The following intentionally skips 0x0a..0x0f, 0x1a..0x1f, and 0x2a..0x2f
+    const uint8_t WR_VREF_VDD420 = 0x00;
+    const uint8_t WR_VREF_VDD425 = 0x01;
+    const uint8_t WR_VREF_VDD430 = 0x02;
+    const uint8_t WR_VREF_VDD435 = 0x03;
+    const uint8_t WR_VREF_VDD440 = 0x04;
+    const uint8_t WR_VREF_VDD445 = 0x05;
+    const uint8_t WR_VREF_VDD450 = 0x06;
+    const uint8_t WR_VREF_VDD455 = 0x07;
+    const uint8_t WR_VREF_VDD460 = 0x08;
+    const uint8_t WR_VREF_VDD465 = 0x09;
+    const uint8_t WR_VREF_VDD470 = 0x10;
+    const uint8_t WR_VREF_VDD475 = 0x11;
+    const uint8_t WR_VREF_VDD480 = 0x12;
+    const uint8_t WR_VREF_VDD485 = 0x13;
+    const uint8_t WR_VREF_VDD490 = 0x14;
+    const uint8_t WR_VREF_VDD495 = 0x15;
+    const uint8_t WR_VREF_VDD500 = 0x16;
+    const uint8_t WR_VREF_VDD505 = 0x17;
+    const uint8_t WR_VREF_VDD510 = 0x18;
+    const uint8_t WR_VREF_VDD515 = 0x19;
+    const uint8_t WR_VREF_VDD520 = 0x20;
+    const uint8_t WR_VREF_VDD525 = 0x21;
+    const uint8_t WR_VREF_VDD530 = 0x22;
+    const uint8_t WR_VREF_VDD535 = 0x23;
+    const uint8_t WR_VREF_VDD540 = 0x24;
+    const uint8_t WR_VREF_VDD545 = 0x25;
+    const uint8_t WR_VREF_VDD550 = 0x26;
+    const uint8_t WR_VREF_VDD555 = 0x27;
+    const uint8_t WR_VREF_VDD560 = 0x28;
+    const uint8_t WR_VREF_VDD565 = 0x29;
+    const uint8_t WR_VREF_VDD570 = 0x30;
+    const uint8_t WR_VREF_VDD575 = 0x31;
+
+    switch(io_value)
+    {
+    case WR_VREF_VDD420:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD420;
+        break;
+    case WR_VREF_VDD425:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD425;
+        break;
+    case WR_VREF_VDD430:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD430;
+        break;
+    case WR_VREF_VDD435:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD435;
+        break;
+    case WR_VREF_VDD440:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD440;
+        break;
+    case WR_VREF_VDD445:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD445;
+        break;
+    case WR_VREF_VDD450:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD450;
+        break;
+    case WR_VREF_VDD455:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD455;
+        break;
+    case WR_VREF_VDD460:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD460;
+        break;
+    case WR_VREF_VDD465:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD465;
+        break;
+    case WR_VREF_VDD470:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD470;
+        break;
+    case WR_VREF_VDD475:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD475;
+        break;
+    case WR_VREF_VDD480:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD480;
+        break;
+    case WR_VREF_VDD485:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD485;
+        break;
+    case WR_VREF_VDD490:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD490;
+        break;
+    case WR_VREF_VDD495:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD495;
+        break;
+    case WR_VREF_VDD500:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD500;
+        break;
+    case WR_VREF_VDD505:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD505;
+        break;
+    case WR_VREF_VDD510:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD510;
+        break;
+    case WR_VREF_VDD515:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD515;
+        break;
+    case WR_VREF_VDD520:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD520;
+        break;
+    case WR_VREF_VDD525:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD525;
+        break;
+    case WR_VREF_VDD530:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD530;
+        break;
+    case WR_VREF_VDD535:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD535;
+        break;
+    case WR_VREF_VDD540:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD540;
+        break;
+    case WR_VREF_VDD545:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD545;
+        break;
+    case WR_VREF_VDD550:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD550;
+        break;
+    case WR_VREF_VDD555:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD555;
+        break;
+    case WR_VREF_VDD560:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD560;
+        break;
+    case WR_VREF_VDD565:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD565;
+        break;
+    case WR_VREF_VDD570:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD570;
+        break;
+    case WR_VREF_VDD575:
+        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD575;
+        break;
+    default:
+        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_DRAM_WR_VREF 0x%08x",
+                    io_value);
+        const fapi::AttributeId & ATTR_ID = i_attr;
+        const uint32_t  & VPD_VALUE = io_value;
+        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
+        break;
+    }
+
+    return  l_fapirc;
+}
+
+// ----------------------------------------------------------------------------
+// Translate vpd values to attribute enumeration for ATTR_VPD_CEN_RD_VREF
+// ----------------------------------------------------------------------------
+fapi::ReturnCode xlate_RD_VREF (const fapi::AttributeId i_attr,
+                                        uint32_t & io_value)
+{
+    fapi::ReturnCode l_fapirc;
+    const uint8_t RD_VREF_VDD61000 = 0x15;
+    const uint8_t RD_VREF_VDD59625 = 0x14;
+    const uint8_t RD_VREF_VDD58250 = 0x13;
+    const uint8_t RD_VREF_VDD56875 = 0x12;
+    const uint8_t RD_VREF_VDD55500 = 0x11;
+    const uint8_t RD_VREF_VDD54125 = 0x10;
+    const uint8_t RD_VREF_VDD52750 = 0x09;
+    const uint8_t RD_VREF_VDD51375 = 0x08;
+    const uint8_t RD_VREF_VDD50000 = 0x07;
+    const uint8_t RD_VREF_VDD48625 = 0x06;
+    const uint8_t RD_VREF_VDD47250 = 0x05;
+    const uint8_t RD_VREF_VDD45875 = 0x04;
+    const uint8_t RD_VREF_VDD44500 = 0x03;
+    const uint8_t RD_VREF_VDD43125 = 0x02;
+    const uint8_t RD_VREF_VDD41750 = 0x01;
+    const uint8_t RD_VREF_VDD40375 = 0x00;
+    const uint8_t RD_VREF_VDD81000 = 0x31;
+    const uint8_t RD_VREF_VDD79625 = 0x30;
+    const uint8_t RD_VREF_VDD78250 = 0x29;
+    const uint8_t RD_VREF_VDD76875 = 0x28;
+    const uint8_t RD_VREF_VDD75500 = 0x27;
+    const uint8_t RD_VREF_VDD74125 = 0x26;
+    const uint8_t RD_VREF_VDD72750 = 0x25;
+    const uint8_t RD_VREF_VDD71375 = 0x24;
+    const uint8_t RD_VREF_VDD70000 = 0x23;
+    const uint8_t RD_VREF_VDD68625 = 0x22;
+    const uint8_t RD_VREF_VDD67250 = 0x21;
+    const uint8_t RD_VREF_VDD65875 = 0x20;
+    const uint8_t RD_VREF_VDD64500 = 0x19;
+    const uint8_t RD_VREF_VDD63125 = 0x18;
+    const uint8_t RD_VREF_VDD61750 = 0x17;
+    const uint8_t RD_VREF_VDD60375 = 0x16;
+
+    switch(io_value)
+    {
+    case RD_VREF_VDD61000:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD61000;
+        break;
+    case RD_VREF_VDD59625:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD59625;
+        break;
+    case RD_VREF_VDD58250:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD58250;
+        break;
+    case RD_VREF_VDD56875:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD56875;
+        break;
+    case RD_VREF_VDD55500:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD55500;
+        break;
+    case RD_VREF_VDD54125:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD54125;
+        break;
+    case RD_VREF_VDD52750:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD52750;
+        break;
+    case RD_VREF_VDD51375:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD51375;
+        break;
+    case RD_VREF_VDD50000:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD50000;
+        break;
+    case RD_VREF_VDD48625:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD48625;
+        break;
+    case RD_VREF_VDD47250:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD47250;
+        break;
+    case RD_VREF_VDD45875:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD45875;
+        break;
+    case RD_VREF_VDD44500:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD44500;
+        break;
+    case RD_VREF_VDD43125:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD43125;
+        break;
+    case RD_VREF_VDD41750:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD41750;
+        break;
+    case RD_VREF_VDD40375:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD40375;
+        break;
+    case RD_VREF_VDD81000:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD81000;
+        break;
+    case RD_VREF_VDD79625:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD79625;
+        break;
+    case RD_VREF_VDD78250:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD78250;
+        break;
+    case RD_VREF_VDD76875:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD76875;
+        break;
+    case RD_VREF_VDD75500:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD75500;
+        break;
+    case RD_VREF_VDD74125:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD74125;
+        break;
+    case RD_VREF_VDD72750:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD72750;
+        break;
+    case RD_VREF_VDD71375:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD71375;
+        break;
+    case RD_VREF_VDD70000:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD70000;
+        break;
+    case RD_VREF_VDD68625:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD68625;
+        break;
+    case RD_VREF_VDD67250:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD67250;
+        break;
+    case RD_VREF_VDD65875:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD65875;
+        break;
+    case RD_VREF_VDD64500:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD64500;
+        break;
+    case RD_VREF_VDD63125:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD63125;
+        break;
+    case RD_VREF_VDD61750:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD61750;
+        break;
+    case RD_VREF_VDD60375:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD60375;
+        break;
+    default:
+        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_CEN_RD_VREF 0x%08x",
+                    io_value);
+        const fapi::AttributeId & ATTR_ID = i_attr;
+        const uint32_t  & VPD_VALUE = io_value;
+        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
+        break;
+    }
+
+    return  l_fapirc;
+}
+
+// ----------------------------------------------------------------------------
+// Translate vpd values to attribute enumeration for
+//   ATTR_VPD_CEN_SLEW_RATE_DQ_DQS
+//   ATTR_VPD_CEN_SLEW_RATE_ADDR
+//   ATTR_VPD_CEN_SLEW_RATE_CLK
+//   ATTR_VPD_CEN_SLEW_RATE_SPCKE
+//   ATTR_VPD_CEN_SLEW_RATE_CNTL
+// They all have the same mapping and can share a translation procedure
+// ----------------------------------------------------------------------------
+fapi::ReturnCode xlate_SLEW_RATE (const fapi::AttributeId i_attr,
+                                     uint8_t & io_value)
+{
+    fapi::ReturnCode l_fapirc;
+    const uint8_t SLEW_RATE_3V_NS = 0x03;
+    const uint8_t SLEW_RATE_4V_NS = 0x04;
+    const uint8_t SLEW_RATE_5V_NS = 0x05;
+    const uint8_t SLEW_RATE_6V_NS = 0x06;
+    const uint8_t SLEW_RATE_MAXV_NS = 0x0F;
+
+//  Ensure that the enums are equal so that one routine can be shared
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_3V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_3V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS==
+                       (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_3V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_3V_NS>();
+
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_4V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_4V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS==
+                       (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_4V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_4V_NS>();
+
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_5V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_5V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS==
+                       (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_5V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_5V_NS>();
+
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_6V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_6V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS==
+                       (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_6V_NS>();
+    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS==
+                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_6V_NS>();
+
+    checkConstantsMatch<
+                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS==
+                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_MAXV_NS>();
+    checkConstantsMatch<
+                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS==
+                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_MAXV_NS>();
+    checkConstantsMatch<
+                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS==
+                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_MAXV_NS>();
+    checkConstantsMatch<
+                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS==
+                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_MAXV_NS>();
+
+    switch(io_value)
+    {
+    case SLEW_RATE_3V_NS:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS;
+        break;
+    case SLEW_RATE_4V_NS:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS;
+        break;
+    case SLEW_RATE_5V_NS:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS;
+        break;
+    case SLEW_RATE_6V_NS:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS;
+        break;
+    case SLEW_RATE_MAXV_NS:
+        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS;
+        break;
+    default:
+         FAPI_ERR("Unsupported VPD encode for ATTR_VPD_CEN_SLEW_RATE 0x%02x",
+                    io_value);
+        const fapi::AttributeId & ATTR_ID = i_attr;
+        const uint8_t  & VPD_VALUE = io_value;
+        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
+        break;
+    }
+
+    return  l_fapirc;
+}
+
+// Determine ISDMM MR keyword to use
+fapi::ReturnCode FindMRkeyword (const fapi::Target       & i_mbTarget,
+                                      fapi::MBvpdKeyword & o_keyword)
+{
+    fapi::ReturnCode l_fapirc;
+    const uint8_t l_M0_KEYWORD_SIZE = 32;
+    uint8_t l_m0_keyword[l_M0_KEYWORD_SIZE];
+    uint32_t l_M0Bufsize = l_M0_KEYWORD_SIZE;
+
+    do
+    {
+
+        l_fapirc = fapiGetMBvpdField(fapi::MBVPD_RECORD_SPDX,
+                                     fapi::MBVPD_KEYWORD_M0,
+                                     i_mbTarget,
+                                     (uint8_t *)(&l_m0_keyword),
+                                     l_M0Bufsize);
+        if (l_fapirc)
+        {
+            FAPI_ERR("getMBvpdAttrData: Read of M0 keyword failed");
+            break;  //  break out with fapirc
+        }
+        if (l_M0_KEYWORD_SIZE > l_M0Bufsize)
+        {
+            FAPI_ERR("getMBvpdAttr:"
+                     " less M0 keyword returned than expected %d < %d",
+                       l_M0Bufsize, l_M0_KEYWORD_SIZE);
+            const uint32_t & KEYWORD = fapi::MBVPD_KEYWORD_M0;
+            const uint32_t & RETURNED_SIZE = l_M0Bufsize;
+            const fapi::Target & CHIP_TARGET = i_mbTarget;
+            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INSUFFICIENT_VPD_RETURNED );
+            break;  //  break out with fapirc
+        }
+
+        uint8_t l_index = 0;
+        l_fapirc = FAPI_ATTR_GET(ATTR_ISDIMM_MBVPD_INDEX,&i_mbTarget,
+                                    l_index);
+        if(l_fapirc)
+        {
+            FAPI_ERR("getMBvpdAttrData: read of ISDIMM MBVPD Index failed");
+            break;
+        }
+        if (l_M0_KEYWORD_SIZE < l_index)
+        {
+            FAPI_ERR("unsupported MBVPD index : 0x%02x",l_index);
+            const uint8_t & M0_DATA = l_index;
+            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_M0_DATA);
+            break;
+        }
+
+        o_keyword = fapi::MBVPD_KEYWORD_M1;
+
+        uint8_t l_actualM0Data = l_m0_keyword[l_index];
+
+        switch (l_actualM0Data)
+        {
+            case 1:
+                o_keyword = fapi::MBVPD_KEYWORD_M1;
+                break;
+            case 2:
+                o_keyword = fapi::MBVPD_KEYWORD_M2;
+                break;
+            case 3:
+                o_keyword = fapi::MBVPD_KEYWORD_M3;
+                break;
+            case 4:
+                o_keyword = fapi::MBVPD_KEYWORD_M4;
+                break;
+            case 5:
+                o_keyword = fapi::MBVPD_KEYWORD_M5;
+                break;
+            case 6:
+                o_keyword = fapi::MBVPD_KEYWORD_M6;
+                break;
+            case 7:
+                o_keyword = fapi::MBVPD_KEYWORD_M7;
+                break;
+            case 8:
+                o_keyword = fapi::MBVPD_KEYWORD_M8;
+                break;
+            default:
+                FAPI_ERR("Incorrect M0 data : 0x%02x",l_actualM0Data);
+                const uint8_t & M0_DATA = l_actualM0Data;
+                FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_M0_DATA);
+                break;
+        }
+
+    }
+    while (0);
+    if (!l_fapirc)
+    {
+        FAPI_DBG ("getMBvpdAttr: use MR keyword %d",o_keyword);
+    }
+
+    return  l_fapirc;
+}
+
+// Determine ISDMM MT keyword to use
+fapi::ReturnCode FindMTkeyword (const fapi::Target       & i_mbTarget,
+                                const fapi::Target       & i_mbaTarget,
+                                      fapi::MBvpdKeyword & o_keyword)
+{
+    fapi::ReturnCode l_fapirc;
+    do
+    {
+        //MT keyword is located in the SPDX record,
+        //and found by using ATTR_SPD_NUM_RANKS
+        //T1: one dimm, rank 1  T2: one dimm, rank 2   T3: one dimm, rank 4
+        //T5: two dimm, rank 1  T6: two dimm, rank 2   T8: two dimm, rank 4
+        fapi::ATTR_SPD_NUM_RANKS_Type l_spd_dimm_ranks[2][2] = {
+                {fapi::ENUM_ATTR_SPD_NUM_RANKS_RX,
+                fapi::ENUM_ATTR_SPD_NUM_RANKS_RX},
+                {fapi::ENUM_ATTR_SPD_NUM_RANKS_RX,
+                fapi::ENUM_ATTR_SPD_NUM_RANKS_RX}
+        };
+        uint8_t l_mba_port;
+        uint8_t l_mba_dimm;
+
+        std::vector<fapi::Target> l_target_dimm_array;
+        l_fapirc = fapiGetAssociatedDimms(i_mbaTarget, l_target_dimm_array,
+                                              fapi::TARGET_STATE_PRESENT);
+        if(l_fapirc)
+        {
+            FAPI_ERR("getMBvpdAttr: read of Associated Dimms failed");
+            break;
+        }
+
+        for(uint8_t l_dimm_index=0; l_dimm_index<l_target_dimm_array.size();
+                    l_dimm_index+=1)
+        {
+            l_fapirc = FAPI_ATTR_GET(ATTR_MBA_PORT,
+                            &l_target_dimm_array[l_dimm_index],
+                            l_mba_port);
+            if(l_fapirc)
+            {
+                FAPI_ERR("getMBvpdAttr: read of ATTR_MBA_PORT failed");
+                break;
+            }
+            l_fapirc = FAPI_ATTR_GET(ATTR_MBA_DIMM,
+                            &l_target_dimm_array[l_dimm_index],
+                            l_mba_dimm);
+            if(l_fapirc)
+            {
+                FAPI_ERR("getMBvpdAttr: read of ATTR_MBA_DIMM failed");
+                break;
+            }
+
+            l_fapirc = FAPI_ATTR_GET(ATTR_SPD_NUM_RANKS,
+                            &l_target_dimm_array[l_dimm_index],
+                            l_spd_dimm_ranks[l_mba_port][l_mba_dimm]);
+            if(l_fapirc)
+            {
+                FAPI_ERR("getMBvpdAttr: read of ATTR_SPD_NUM_RANKS failed");
+                break;
+            }
+        }
+        if(l_fapirc)
+        {
+            break;
+        }
+
+        fapi::ATTR_SPD_NUM_RANKS_Type l_rankCopy =
+          fapi::ENUM_ATTR_SPD_NUM_RANKS_RX;
+        uint8_t l_dimmInvalid = 0;
+        bool l_double_drop = false;
+        /* Mismatched rank numbers between the paired ports is an error
+         * that should deconfigure the parent MBA so the data for that
+         * MBA should never be fetched. The same is for mismatched slot 1
+         * and slot 0 on the same port
+         */
+
+        //single or double drop
+        if( (l_spd_dimm_ranks[0][1] == fapi::ENUM_ATTR_SPD_NUM_RANKS_RX)
+          && (l_spd_dimm_ranks[1][1] == fapi::ENUM_ATTR_SPD_NUM_RANKS_RX) )
+        {
+            //if the two match, it's a valid case.
+            if(l_spd_dimm_ranks[0][0] == l_spd_dimm_ranks[1][0])
+            {
+                //0000, set to 1
+                if(l_spd_dimm_ranks[0][0]
+                   == fapi::ENUM_ATTR_SPD_NUM_RANKS_RX)
+                {
+                    l_rankCopy = 1;
+                    //throwing error for all empty
+                    FAPI_ERR("No dimm's found");
+                    const uint8_t DIMM_P0S0 = l_spd_dimm_ranks[0][0];
+                    const uint8_t DIMM_P0S1 = l_spd_dimm_ranks[0][1];
+                    const uint8_t DIMM_P1S0 = l_spd_dimm_ranks[1][0];
+                    const uint8_t DIMM_P1S1 = l_spd_dimm_ranks[1][1];
+                    FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_DIMMS_NOT_FOUND);
+                    break;
+
+                //either 0101,0202,0404.
+                }
+                else
+                {
+                    l_rankCopy = l_spd_dimm_ranks[0][0];
+                }
+            }
+            else
+            {
+                //throwing error for invalid dimm combination
+                l_dimmInvalid = 1;
+            }
+        //if all 4 are the same, its double ranked
+        } else if(l_spd_dimm_ranks[0][1] == l_spd_dimm_ranks[0][0] &&
+                    l_spd_dimm_ranks[1][1] == l_spd_dimm_ranks[1][0] &&
+                    l_spd_dimm_ranks[0][1] == l_spd_dimm_ranks[1][1])
+        {
+            //either 1111,2222,4444
+            l_rankCopy = l_spd_dimm_ranks[0][0];
+            l_double_drop = true;
+        }
+        else
+        {
+            //throwing error for invalid dimm combination
+            l_dimmInvalid = 1;
+        }
+
+        if(l_dimmInvalid)
+        {
+            FAPI_ERR("There is an invalid combination of dimm's found");
+            const uint8_t INVALID_DIMM_P0S0 = l_spd_dimm_ranks[0][0];
+            const uint8_t INVALID_DIMM_P0S1 = l_spd_dimm_ranks[0][1];
+            const uint8_t INVALID_DIMM_P1S0 = l_spd_dimm_ranks[1][0];
+            const uint8_t INVALID_DIMM_P1S1 = l_spd_dimm_ranks[1][1];
+            const fapi::Target & MBA = i_mbaTarget;
+            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_DIMM_FOUND);
+            break;
+        }
+
+        switch (l_rankCopy)
+        {
+            case fapi::ENUM_ATTR_SPD_NUM_RANKS_R1:
+                if( l_double_drop ) {
+                    o_keyword = fapi::MBVPD_KEYWORD_T5;
+                } else {
+                    o_keyword = fapi::MBVPD_KEYWORD_T1;
+                }
+                break;
+            case fapi::ENUM_ATTR_SPD_NUM_RANKS_R2:
+                if( l_double_drop ) {
+                    o_keyword = fapi::MBVPD_KEYWORD_T6;
+                } else {
+                    o_keyword = fapi::MBVPD_KEYWORD_T2;
+                }
+                break;
+            case fapi::ENUM_ATTR_SPD_NUM_RANKS_R4:
+                if( l_double_drop ) {
+                    o_keyword = fapi::MBVPD_KEYWORD_T8;
+                } else {
+                    o_keyword = fapi::MBVPD_KEYWORD_T4;
+                }
+                break;
+            default:
+                FAPI_ERR("Invalid dimm rank : 0x%02x",l_rankCopy);
+                const uint8_t & RANK_NUM = l_rankCopy;
+                FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_MT_DATA);
+                break;
+        }
+
+    }
+    while (0);
+    if (!l_fapirc)
+    {
+        FAPI_DBG ("getMBvpdAttr: use MT keyword %d",o_keyword);
+    }
+
+    return  l_fapirc;
+}
+
+}   // extern "C"
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttrData.C b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttrData.C
new file mode 100644
index 000000000..6aa2b1c39
--- /dev/null
+++ b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttrData.C
@@ -0,0 +1,167 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/hwpf/hwp/mvpd_accessors/getMBvpdAttrData.C $          */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2015                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+// $Id: getMBvpdAttrData.C,v 1.1 2014/12/11 13:39:02 whs Exp $
+/**
+ *  @file getMBvpdAttrData.C
+ *
+ *  @brief get Attribute Data from MBvpd
+ *
+ */
+#include    <stdint.h>
+
+//  fapi support
+#include    <fapi.H>
+#include    <fapiUtil.H>
+#include    <getMBvpdAttr.H>
+
+using   namespace   fapi;
+using   namespace   getAttrData;
+
+namespace fapi
+{
+namespace getAttrData
+{
+
+// ----------------------------------------------------------------------------
+// Attribute definition table
+// ----------------------------------------------------------------------------
+
+//  Attribute defintions
+const MBvpdAttrDef g_MBVPD_ATTR_DEF_array [] =
+{
+
+// Planar ISDIMM changes in V61 (ascii 11) and V63 (ascii 13)
+    {ATTR_VPD_DIMM_RCD_IBT,ISDIMM,V13,MBVPD_KEYWORD_MT,34,UINT32_BY2_BY2|UINT8_DATA,0},
+    {ATTR_VPD_DIMM_RCD_IBT,ISDIMM,VBASE,MBVPD_KEYWORD_MT,34,UINT32_BY2_BY2|DEFAULT_VALUE,0x64},
+    {ATTR_VPD_DIMM_RCD_IBT,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,34,UINT32_BY2_BY2|DEFAULT_VALUE,0},
+
+    {ATTR_VPD_DIMM_RCD_OUTPUT_TIMING,ISDIMM,V13,MBVPD_KEYWORD_MT,36,UINT8_BY2_BY2,0},
+    {ATTR_VPD_DIMM_RCD_OUTPUT_TIMING,ISDIMM,VBASE,MBVPD_KEYWORD_MT,35,UINT8_BY2_BY2|DEFAULT_VALUE,1},
+    {ATTR_VPD_DIMM_RCD_OUTPUT_TIMING,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,36,UINT8_BY2_BY2|DEFAULT_VALUE,0},
+
+    {ATTR_VPD_DRAM_WR_VREF,ISDIMM,V13,MBVPD_KEYWORD_MT,38,UINT32_BY2|UINT8_DATA|XLATE_RD_VREF,0},
+
+// CDIMM changes in V60 (ascii 10)
+    {ATTR_VPD_TSYS_ADR,CDIMM,V10,MBVPD_KEYWORD_MR,49,UINT8_BY2|PORT00,0},
+    {ATTR_VPD_TSYS_ADR,CDIMM,VBASE,MBVPD_KEYWORD_MR,51,UINT8_BY2|PORT00,0},
+
+    {ATTR_VPD_TSYS_DP18,CDIMM,V10,MBVPD_KEYWORD_MR,49,UINT8_BY2|PORT11,0},
+    {ATTR_VPD_TSYS_DP18,CDIMM,VBASE,MBVPD_KEYWORD_MR,51,UINT8_BY2|PORT11,0},
+
+    {ATTR_VPD_RLO,CDIMM,V10,MBVPD_KEYWORD_MT,60,UINT8_BY2|LOW_NIBBLE,0},
+    {ATTR_VPD_RLO,CDIMM,VBASE,MBVPD_KEYWORD_MR,49,UINT8_BY2|LOW_NIBBLE,0},
+
+    {ATTR_VPD_WLO,CDIMM,V10,MBVPD_KEYWORD_MT,60,UINT8_BY2|HIGH_NIBBLE,0},
+    {ATTR_VPD_WLO,CDIMM,VBASE,MBVPD_KEYWORD_MR,49,UINT8_BY2|HIGH_NIBBLE,0},
+
+    {ATTR_VPD_GPO,CDIMM,V10,MBVPD_KEYWORD_MT,61,UINT8_BY2,0},
+    {ATTR_VPD_GPO,CDIMM,VBASE,MBVPD_KEYWORD_MR,50,UINT8_BY2,0},
+
+// Base Term Data definitions to be used if no other version exceptions
+    {ATTR_VPD_DRAM_RON,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,0,UINT8_BY2_BY2|XLATE_DRAM_RON,0},
+    {ATTR_VPD_DRAM_RTT_NOM,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,2,UINT8_BY2_BY2_BY4|XLATE_RTT_NOM,0},
+    {ATTR_VPD_DRAM_RTT_WR,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,10,UINT8_BY2_BY2_BY4|XLATE_RTT_WR,0},
+    {ATTR_VPD_ODT_RD,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,18,UINT8_BY2_BY2_BY4,0},
+    {ATTR_VPD_ODT_WR,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,26,UINT8_BY2_BY2_BY4,0},
+    {ATTR_VPD_CEN_RD_VREF,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,37,UINT32_BY2|UINT8_DATA|XLATE_RD_VREF,0},
+    {ATTR_VPD_DRAM_WR_VREF,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,38,UINT32_BY2|XLATE_WR_VREF,0},
+    {ATTR_VPD_DRAM_WRDDR4_VREF,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,42,UINT8_BY2,0},
+    {ATTR_VPD_CEN_RCV_IMP_DQ_DQS,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,43,UINT8_BY2,0},
+    {ATTR_VPD_CEN_DRV_IMP_DQ_DQS,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,44,UINT8_BY2,0},
+    {ATTR_VPD_CEN_DRV_IMP_CNTL,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,45,UINT8_BY2,0},
+    {ATTR_VPD_CEN_DRV_IMP_ADDR,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,46,UINT8_BY2,0},
+    {ATTR_VPD_CEN_DRV_IMP_CLK,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,47,UINT8_BY2,0},
+    {ATTR_VPD_CEN_DRV_IMP_SPCKE,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,48,UINT8_BY2,0},
+    {ATTR_VPD_CEN_SLEW_RATE_DQ_DQS,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,49,UINT8_BY2|XLATE_SLEW,0},
+    {ATTR_VPD_CEN_SLEW_RATE_CNTL,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,50,UINT8_BY2|XLATE_SLEW,0},
+    {ATTR_VPD_CEN_SLEW_RATE_ADDR,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,51,UINT8_BY2|XLATE_SLEW,0},
+    {ATTR_VPD_CEN_SLEW_RATE_CLK,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,52,UINT8_BY2|XLATE_SLEW,0},
+    {ATTR_VPD_CEN_SLEW_RATE_SPCKE,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,53,UINT8_BY2|XLATE_SLEW,0},
+    {ATTR_VPD_CKE_PRI_MAP,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,54,UINT32_BY2|UINT16_DATA,0},
+    {ATTR_VPD_CKE_PWR_MAP,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,56,UINT64|MERGE,0},
+    {ATTR_VPD_RLO,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,60,UINT8_BY2|LOW_NIBBLE,0},
+    {ATTR_VPD_WLO,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,60,UINT8_BY2|HIGH_NIBBLE,0},
+    {ATTR_VPD_GPO,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MT,61,UINT8_BY2,0},
+
+// Base Phase Rotator definitions to be used if no other version exceptions
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,0,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CLK_P1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,1,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,2,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CLK_P1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,3,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,4,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,5,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A2,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,6,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A3,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,7,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A4,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,8,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A5,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,9,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A6,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,10,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A7,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,11,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A8,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,12,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A9,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,13,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A10,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,14,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A11,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,15,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A12,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,16,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A13,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,17,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A14,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,18,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_A15,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,19,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,20,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,21,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_BA2,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,22,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_CASN,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,23,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_RASN,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,24,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_CMD_WEN,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,25,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_PAR,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,26,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M_ACTN,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,27,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,28,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,29,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE2,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,30,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CKE3,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,31,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,32,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,33,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN2,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,34,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_CSN3,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,35,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,36,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M0_CNTL_ODT1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,37,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,38,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,39,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE2,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,40,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CKE3,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,41,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,42,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,43,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN2,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,44,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_CSN3,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,45,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT0,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,46,UINT8_BY2,0},
+    {ATTR_VPD_CEN_PHASE_ROT_M1_CNTL_ODT1,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,47,UINT8_BY2,0},
+    {ATTR_VPD_DRAM_2N_MODE_ENABLED,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,48,UINT8_BY2,0},
+    {ATTR_VPD_TSYS_ADR,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,49,UINT8_BY2|PORT00,0},
+    {ATTR_VPD_TSYS_DP18,ALL_DIMM,ALL_VER,MBVPD_KEYWORD_MR,49,UINT8_BY2|PORT11,0},
+};
+
+const uint32_t g_MBVPD_ATTR_DEF_array_size =
+    sizeof(g_MBVPD_ATTR_DEF_array) /
+    sizeof(MBvpdAttrDef);
+
+}   // namespace getAttrData
+}   // namespace fapi
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdDram2NModeEnabled.C b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdDram2NModeEnabled.C
index d36a25730..b5b4b95ad 100644
--- a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdDram2NModeEnabled.C
+++ b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdDram2NModeEnabled.C
@@ -5,7 +5,9 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2013,2014              */
+/* Contributors Listed Below - COPYRIGHT 2013,2015                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
 /*                                                                        */
 /* Licensed under the Apache License, Version 2.0 (the "License");        */
 /* you may not use this file except in compliance with the License.       */
@@ -20,7 +22,7 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-// $Id: getMBvpdDram2NModeEnabled.C,v 1.3 2014/02/12 22:11:39 mjjones Exp $
+// $Id: getMBvpdDram2NModeEnabled.C,v 1.4 2014/12/11 13:35:35 whs Exp $
 /**
  *  @file getMBvpdDram2NModeEnabled.C
  *
@@ -35,7 +37,7 @@
 #include    <fapi.H>
 #include    <fapiUtil.H>
 #include    <getMBvpdDram2NModeEnabled.H>
-#include    <getMBvpdPhaseRotatorData.H>
+#include    <getMBvpdAttr.H>
 
 extern "C"
 {
@@ -53,10 +55,11 @@ fapi::ReturnCode getMBvpdDram2NModeEnabled(
     do {
         // Retrieve the Dram 2N Mode from the MR keyword
         FAPI_EXEC_HWP(l_fapirc,
-                      getMBvpdPhaseRotatorData,
+                      getMBvpdAttr,
                       i_mbaTarget,
-                      fapi::PHASE_ROT_DRAM_2N_MODE,
-                      l_dram2NMode);
+                      fapi::ATTR_VPD_DRAM_2N_MODE_ENABLED,
+                      &l_dram2NMode,
+                      sizeof(l_dram2NMode));
         if (l_fapirc)
         {
             FAPI_ERR("getMBvpdDram2NModeEnabled: Read of VZ keyword failed");
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.C b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.C
deleted file mode 100644
index c86af2f3c..000000000
--- a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.C
+++ /dev/null
@@ -1,307 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/usr/hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.C $  */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2015                        */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id: getMBvpdPhaseRotatorData.C,v 1.10 2014/10/23 20:59:36 eliner Exp $
-/**
- *  @file getMBvpdPhaseRotatorData.C
- *
- *  @brief get Phase Rotator Data from MBvpd MR keyword
- *
- */
-
-#include    <stdint.h>
-
-//  fapi support
-#include    <fapi.H>
-#include    <getMBvpdPhaseRotatorData.H>
-#include    <getMBvpdVersion.H>
-
-extern "C"
-{
-using   namespace   fapi;
-
-fapi::ReturnCode getMBvpdPhaseRotatorData(
-                    const        fapi::Target &i_mbaTarget,
-                    const        fapi::MBvpdPhaseRotatorData i_attr,
-                    uint8_t      (&o_val)[2])
-
-{
-
-    //MR keyword layout
-    const uint8_t NUM_MBA =  2;    //There are 2 MBAs per Centaur memory buffer
-    const uint8_t NUM_PORTS = 2;   //Each MBA has 2 ports
-    const uint8_t PHASE_ROTATOR_ATTR_SIZE = 64; //Each port has 64 bytes
-                                                // for attributes
-    struct port_attributes
-    {
-       uint8_t port_attr[PHASE_ROTATOR_ATTR_SIZE];
-    };
-    struct mba_attributes
-    {
-        port_attributes mba_port[NUM_PORTS];
-    };
-    struct mr_keyword
-    {
-        mba_attributes mb_mba[NUM_MBA];
-    };
-    // The actual size of the MR keword is 255 bytes, which is one byte short
-    // of the mr_keyword struct. One byte is used for the size in the vpd.
-    // As long as there is at least one reserved attribute, then all will fit.
-    const uint32_t MR_KEYWORD_SIZE = 255;  // keyword size
-
-    fapi::ReturnCode l_fapirc;
-    fapi::Target l_mbTarget;
-    uint8_t l_pos = NUM_PORTS; //initialize to out of range value (+1)
-    mr_keyword * l_pMrBuffer = NULL; // MBvpd MR keyword buffer
-    uint32_t  l_MrBufsize = sizeof(mr_keyword);
-    // Mask off to isolate vpd offset. MBvpdPhaseRatorData value is the offset
-    // into vpd. Also protects against indexing out of bounds.
-    uint8_t   l_attrOffset = i_attr & PHASE_ROT_OFFSET_MASK;
-    uint32_t  l_special = i_attr & PHASE_ROT_SPECIAL_MASK; // mask off to
-                                // isolate special processing flags
-    FAPI_DBG("getMBvpdPhaseRotatorData: entry attr=0x%04x ",
-             i_attr  );
-
-    do {
-        // find the position of the passed mba on the centuar
-        l_fapirc = FAPI_ATTR_GET(ATTR_CHIP_UNIT_POS,&i_mbaTarget,l_pos);
-        if (l_fapirc)
-        {
-            FAPI_ERR(" getMBvpdPhaseRotatorData: Get MBA position failed ");
-            break;  //  break out with fapirc
-        }
-        FAPI_DBG("getMBvpdPhaseRotatorData: mba %s position=%d",
-             i_mbaTarget.toEcmdString(),
-             l_pos);
-
-        // find the Centaur memmory buffer from the passed MBA
-        l_fapirc = fapiGetParentChip (i_mbaTarget,l_mbTarget);
-        if (l_fapirc)
-        {
-            FAPI_ERR("getMBvpdPhaseRotatorData: Finding the parent mb failed ");
-            break;  //  break out with fapirc
-        }
-        FAPI_DBG("getMBvpdPhaseRotatorData: parent path=%s ",
-             l_mbTarget.toEcmdString()  );
-
-        // Check if the old vpd layout is different for this attr
-        if (PHASE_ROT_CHK60 & i_attr) // need to check vpd version for this attr
-        {
-            uint32_t l_vpdVersion = 0;
-            const uint32_t VPD_VERSION_V60=0x3130; // Version 6.0 is ascii "10"
-
-            // get vpd version
-            FAPI_EXEC_HWP(l_fapirc,
-                          getMBvpdVersion,
-                          i_mbaTarget,
-                          l_vpdVersion);
-            if (l_fapirc)
-            {
-                FAPI_ERR("getMBvpdPhaseRotatorData: getMBvpdVersion failed");
-                break;  //  break out with fapirc
-            }
-
-            FAPI_DBG("getMBvpdPhaseRotatorData: vpd version=0x%08x",
-                l_vpdVersion);
-
-            // Check if work around needed
-            if (l_vpdVersion < VPD_VERSION_V60)
-            {
-                // use the v5.3 offsets and special processing
-                if (PHASE_ROT_TSYS_ADR == i_attr)
-                {
-                    l_attrOffset=PHASE_ROT_TSYS_ADR_V53 & PHASE_ROT_OFFSET_MASK;
-                    l_special=PHASE_ROT_TSYS_ADR_V53 & PHASE_ROT_SPECIAL_MASK;
-                }
-                else if (PHASE_ROT_TSYS_DP18 == i_attr)
-                {
-                    l_attrOffset=PHASE_ROT_TSYS_DP18_V53 &
-                        PHASE_ROT_OFFSET_MASK;
-                    l_special=PHASE_ROT_TSYS_DP18_V53 & PHASE_ROT_SPECIAL_MASK;
-                }
-            }
-        }
-
-        // Read the MR keyword field
-        l_pMrBuffer = new mr_keyword;
-
-        uint8_t l_customDimm = 0;
-
-        l_fapirc = FAPI_ATTR_GET(ATTR_EFF_CUSTOM_DIMM,&i_mbaTarget,
-                        l_customDimm);
-        if(l_fapirc)
-        {
-            FAPI_ERR("getMBvpdPhaseRotatorData: Read of Custom Dimm failed");
-            break;
-        }
-
-        //if custom_dimm = 0, use isdimm
-        if(fapi::ENUM_ATTR_EFF_CUSTOM_DIMM_NO == l_customDimm)
-        {
-            const uint8_t l_M0_KEYWORD_SIZE = 32;
-
-            uint8_t l_m0_keyword[l_M0_KEYWORD_SIZE];
-            uint32_t l_M0Bufsize = l_M0_KEYWORD_SIZE;
-
-            l_fapirc = fapiGetMBvpdField(fapi::MBVPD_RECORD_SPDX,
-                                         fapi::MBVPD_KEYWORD_M0,
-                                         l_mbTarget,
-                                         (uint8_t *)(&l_m0_keyword),
-                                         l_M0Bufsize);
-            if (l_fapirc)
-            {
-                FAPI_ERR("getMBvpdPhaseRotatorData: Read of M0 keyword failed");
-                break;  //  break out with fapirc
-            }
-
-            uint8_t l_dimmPos = 0;
-            l_fapirc = FAPI_ATTR_GET(ATTR_ISDIMM_MBVPD_INDEX,&l_mbTarget,
-                                    l_dimmPos);
-            if(l_fapirc)
-            {
-                FAPI_ERR("getMBvpdPhaseRotatorData: read of ATTR_POS failed");
-                break;
-            }
-
-            fapi::MBvpdKeyword l_MR_Keyword = fapi::MBVPD_KEYWORD_M1;
-
-            uint8_t l_actualM0Data = l_m0_keyword[l_dimmPos];
-
-            switch (l_actualM0Data)
-            {
-                case 1:
-                    l_MR_Keyword = fapi::MBVPD_KEYWORD_M1;
-                    break;
-                case 2:
-                    l_MR_Keyword = fapi::MBVPD_KEYWORD_M2;
-                    break;
-                case 3:
-                    l_MR_Keyword = fapi::MBVPD_KEYWORD_M3;
-                    break;
-                case 4:
-                    l_MR_Keyword = fapi::MBVPD_KEYWORD_M4;
-                    break;
-                case 5:
-                    l_MR_Keyword = fapi::MBVPD_KEYWORD_M5;
-                    break;
-                case 6:
-                    l_MR_Keyword = fapi::MBVPD_KEYWORD_M6;
-                    break;
-                case 7:
-                    l_MR_Keyword = fapi::MBVPD_KEYWORD_M7;
-                    break;
-                case 8:
-                    l_MR_Keyword = fapi::MBVPD_KEYWORD_M8;
-                    break;
-                default:
-                    FAPI_ERR("Incorrect M0 data : 0x%02x",l_actualM0Data);
-                    const uint8_t & M0_DATA = l_actualM0Data;
-                    FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_M0_DATA);
-                    break;
-            }
-            if(l_fapirc)
-            {
-                FAPI_ERR("getMBvpdPhaseRotatorData: Invalid M0 data");
-                break;
-            }
-
-            l_fapirc = fapiGetMBvpdField(fapi::MBVPD_RECORD_SPDX,
-                                 l_MR_Keyword,
-                                 l_mbTarget,
-                                 reinterpret_cast<uint8_t *>(l_pMrBuffer),
-                                 l_MrBufsize);
-        //else custom_dimm is 1 and we need to use the CDIMM
-        }else{
-            l_fapirc = fapiGetMBvpdField(fapi::MBVPD_RECORD_VSPD,
-                                 fapi::MBVPD_KEYWORD_MR,
-                                 l_mbTarget,
-                                 reinterpret_cast<uint8_t *>(l_pMrBuffer),
-                                 l_MrBufsize);
-        }
-
-        if (l_fapirc)
-        {
-            FAPI_ERR("getMBvpdPhaseRotatorData: Read of MR keyword failed");
-            break;  //  break out with fapirc
-        }
-
-        // Check that sufficient MR was returned.
-        if (l_MrBufsize < MR_KEYWORD_SIZE )
-        {
-            FAPI_ERR("getMBvpdPhaseRotatorData:"
-                     " less MR keyword returned than expected %d < %d",
-                       l_MrBufsize, MR_KEYWORD_SIZE);
-            const uint32_t & KEYWORD = fapi::MBVPD_KEYWORD_MR;
-            const uint32_t & RETURNED_SIZE = l_MrBufsize;
-            const fapi::Target & CHIP_TARGET = l_mbTarget;
-            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INSUFFICIENT_VPD_RETURNED );
-            break;  //  break out with fapirc
-        }
-
-        // pull data from MR keyword buffer
-        uint8_t l_port0=
-                l_pMrBuffer->mb_mba[l_pos].mba_port[0].port_attr[l_attrOffset];
-        uint8_t l_port1=
-                l_pMrBuffer->mb_mba[l_pos].mba_port[1].port_attr[l_attrOffset];
-        switch (l_special)
-        {
-            case PHASE_ROT_LOW_NIBBLE: // return low nibble
-                l_port0 = l_port0 & 0x0F;
-                l_port1 = l_port1 & 0x0F;
-                break;
-
-            case PHASE_ROT_HIGH_NIBBLE: // return high nibble
-                l_port0 = ((l_port0 & 0xF0)>>4);
-                l_port1 = ((l_port1 & 0xF0)>>4);
-                break;
-
-            case PHASE_ROT_PORT00: // return port 0 for both ports 0 and 1
-                l_port1=l_port0;
-                break;
-
-            case PHASE_ROT_PORT11:// return port 1 for both ports 0 and 1
-                l_port0=l_port1;
-                break;
-
-            default:
-                 ;      // data is ok directly from MR keyword buffer
-        }
-
-        // return the requested attributes from the MR keyword buffer
-        o_val[0]=l_port0;
-        o_val[1]=l_port1;
-
-    } while (0);
-
-    delete l_pMrBuffer;
-    l_pMrBuffer = NULL;
-
-    FAPI_DBG("getMBvpdPhaseRotatorData: exit rc=0x%08x (0x%02x,0x%02x)",
-               static_cast<uint32_t>(l_fapirc),
-               o_val[0],o_val[1] );
-
-    return  l_fapirc;
-}
-
-}   // extern "C"
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdTermData.C b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdTermData.C
deleted file mode 100644
index 54a2443ff..000000000
--- a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdTermData.C
+++ /dev/null
@@ -1,1444 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/usr/hwpf/hwp/mvpd_accessors/getMBvpdTermData.C $          */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2014                        */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-// $Id: getMBvpdTermData.C,v 1.18 2014/11/24 15:47:48 cswenson Exp $
-/**
- *  @file getMBvpdTermData.C
- *
- *  @brief get Termination Data from MBvpd MT keyword
- *
- */
-#include    <stdint.h>
-
-//  fapi support
-#include    <fapi.H>
-#include    <fapiUtil.H>
-#include    <getMBvpdTermData.H>
-#include    <getMBvpdPhaseRotatorData.H>
-#include    <getMBvpdVersion.H>
-
-// Used to ensure attribute enums are equal at compile time
-class Error_ConstantsDoNotMatch;
-template<const bool MATCH> void checkConstantsMatch()
-{
-    Error_ConstantsDoNotMatch();
-}
-template <> inline void checkConstantsMatch<true>() {}
-
-extern "C"
-{
-using   namespace   fapi;
-
-// local procedures
-fapi::ReturnCode translate_DRAM_RON (const fapi::MBvpdTermData i_attr,
-                              uint8_t & io_value);
-fapi::ReturnCode translate_DRAM_RTT_NOM (const fapi::MBvpdTermData i_attr,
-                              uint8_t & io_value);
-fapi::ReturnCode translate_DRAM_RTT_WR (const fapi::MBvpdTermData i_attr,
-                              uint8_t & io_value);
-fapi::ReturnCode translate_DRAM_WR_VREF (const fapi::MBvpdTermData i_attr,
-                              uint32_t & io_value);
-fapi::ReturnCode translate_CEN_RD_VREF (const fapi::MBvpdTermData i_attr,
-                              uint32_t & io_value);
-fapi::ReturnCode translate_SLEW_RATE (const fapi::MBvpdTermData i_attr,
-                              uint8_t & io_value);
-
-// ----------------------------------------------------------------------------
-// HWP accessor to get Termination Data for MBvpd MT keyword
-// ----------------------------------------------------------------------------
-fapi::ReturnCode getMBvpdTermData(
-                              const fapi::Target   &i_mbaTarget,
-                              const fapi::MBvpdTermData i_attr,
-                              void  * o_pVal,
-                              const uint32_t i_valSize)
-{
-    //MT keyword layout
-    //The following constants are for readibility. They need to stay in sync
-    //  with the attributes and vpd layout.
-    const uint8_t NUM_MBA =  2;    //There are 2 MBAs per Centaur memory buffer
-    const uint8_t NUM_PORTS = 2;   //Each MBA has 2 ports
-    const uint8_t NUM_DIMMS = 2;   //Each port has 2 DIMMs
-    const uint8_t NUM_RANKS = 4;   //Number of ranks
-    const uint8_t TERM_DATA_ATTR_SIZE = 64; //Each port has 64 bytes
-                                            // for attributes
-    struct port_attributes
-    {
-       uint8_t port_attr[TERM_DATA_ATTR_SIZE];
-    };
-    struct mba_attributes
-    {
-        port_attributes mba_port[NUM_PORTS];
-    };
-    struct mt_keyword
-    {
-        mba_attributes mb_mba[NUM_MBA];
-    };
-    // The actual size of the MT keyword is 255 bytes, which is one byte short
-    // of the mt_keyword struct. One byte is used for the size in the vpd.
-    // As long as there is at least one reserved attribute, then all will fit.
-    const uint32_t MT_KEYWORD_SIZE = 255;  // keyword size
-
-    fapi::ReturnCode l_fapirc;
-    fapi::Target l_mbTarget;
-    uint8_t l_pos = NUM_PORTS; //initialize to out of range value (+1)
-    mt_keyword * l_pMtBuffer = NULL; // MBvpd MT keyword buffer
-    uint32_t  l_MtBufsize = sizeof(mt_keyword);
-    uint32_t  l_sizeCheck = 0; //invalid size
-    // Mask off to isolate vpd offset. MBvpdTermData value is offset into vpd.
-    // Also protects against indexing out of bounds
-    uint8_t   l_attrOffset = i_attr & TERM_DATA_OFFSET_MASK;
-
-    FAPI_DBG("getMBvpdTermData: entry attr=0x%02x, size=%d ",
-             i_attr,i_valSize  );
-
-    do {
-        // validate proper output variable size for the attribute
-        switch (i_attr)
-        {
-           case TERM_DATA_DRAM_RON:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_DRAM_RON>::Type);
-               break;
-           case TERM_DATA_DRAM_RTT_NOM:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_DRAM_RTT_NOM>::Type);
-               break;
-           case TERM_DATA_DRAM_RTT_WR:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_DRAM_RTT_WR>::Type);
-               break;
-           case TERM_DATA_ODT_RD:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_ODT_RD>::Type);
-               break;
-           case TERM_DATA_ODT_WR:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_ODT_WR>::Type);
-               break;
-           case TERM_DATA_DIMM_RCD_IBT:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_DIMM_RCD_IBT>::Type);
-               break;
-           case TERM_DATA_DIMM_RCD_OUTPUT_TIMING:
-               l_sizeCheck=
-               sizeof
-                   (MBvpdTermDataSize<TERM_DATA_DIMM_RCD_OUTPUT_TIMING>::Type);
-               break;
-           case TERM_DATA_CEN_RD_VREF:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_RD_VREF>::Type);
-               break;
-           case TERM_DATA_DRAM_WR_VREF:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_DRAM_WR_VREF>::Type);
-               break;
-           case TERM_DATA_DRAM_WRDDR4_VREF:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_DRAM_WRDDR4_VREF>::Type);
-               break;
-           case TERM_DATA_CEN_RCV_IMP_DQ_DQS:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_RCV_IMP_DQ_DQS>::Type);
-               break;
-           case TERM_DATA_CEN_DRV_IMP_DQ_DQS:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_DRV_IMP_DQ_DQS>::Type);
-               break;
-           case TERM_DATA_CEN_DRV_IMP_CNTL:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_DRV_IMP_CNTL>::Type);
-               break;
-           case TERM_DATA_CEN_DRV_IMP_ADDR:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_DRV_IMP_ADDR>::Type);
-               break;
-           case TERM_DATA_CEN_DRV_IMP_CLK:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_DRV_IMP_CLK>::Type);
-               break;
-           case TERM_DATA_CEN_DRV_IMP_SPCKE:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_DRV_IMP_SPCKE>::Type);
-               break;
-           case TERM_DATA_CEN_SLEW_RATE_DQ_DQS:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_SLEW_RATE_DQ_DQS>::Type);
-               break;
-           case TERM_DATA_CEN_SLEW_RATE_CNTL:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_SLEW_RATE_CNTL>::Type);
-               break;
-           case TERM_DATA_CEN_SLEW_RATE_ADDR:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_SLEW_RATE_ADDR>::Type);
-               break;
-           case TERM_DATA_CEN_SLEW_RATE_CLK:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_SLEW_RATE_CLK>::Type);
-               break;
-           case TERM_DATA_CEN_SLEW_RATE_SPCKE:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CEN_SLEW_RATE_SPCKE>::Type);
-               break;
-           case TERM_DATA_CKE_PRI_MAP:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CKE_PRI_MAP>::Type);
-               break;
-           case TERM_DATA_CKE_PWR_MAP:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_CKE_PWR_MAP>::Type);
-               break;
-           case TERM_DATA_RLO:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_RLO>::Type);
-               break;
-           case TERM_DATA_WLO:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_WLO>::Type);
-               break;
-           case TERM_DATA_GPO:
-               l_sizeCheck=
-               sizeof (MBvpdTermDataSize<TERM_DATA_GPO>::Type);
-               break;
-           default: // Hard to do, but needs to be caught
-               FAPI_ERR("getMBvpdTermData: invalid attribute ID 0x%02x",
-                       i_attr);
-               const fapi::MBvpdTermData & ATTR_ID = i_attr;
-               FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_ATTRIBUTE_ID);
-               break;  //  break out with fapirc
-        }
-        if (l_fapirc)
-        {
-            break;  //  break out with fapirc
-        }
-        if (l_sizeCheck != i_valSize)
-        {
-            FAPI_ERR("getMBvpdTermData:"
-                     " output variable size does not match expected %d != %d",
-                       l_sizeCheck, i_valSize);
-            const uint32_t & EXPECTED_SIZE = l_sizeCheck;
-            const uint32_t & PASSED_SIZE = i_valSize;
-            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE);
-            break;  //  break out with fapirc
-        }
-
-        // find the position of the passed mba on the centuar
-        l_fapirc = FAPI_ATTR_GET(ATTR_CHIP_UNIT_POS,&i_mbaTarget,l_pos);
-        if (l_fapirc)
-        {
-            FAPI_ERR(" getMBvpdTermData: Get MBA position failed ");
-            break;  //  break out with fapirc
-        }
-        FAPI_DBG("getMBvpdTermData: mba %s position=%d",
-             i_mbaTarget.toEcmdString(),
-             l_pos);
-
-        // find the Centaur memmory buffer from the passed MBA
-        l_fapirc = fapiGetParentChip (i_mbaTarget,l_mbTarget);
-        if (l_fapirc)
-        {
-            FAPI_ERR("getMBvpdTermData: Finding the parent mb failed ");
-            break;  //  break out with fapirc
-        }
-        FAPI_DBG("getMBvpdTermData: parent path=%s ",
-             l_mbTarget.toEcmdString()  );
-
-        // Check if the old vpd layout is different for this attr
-        if (TERM_DATA_CHK60 & i_attr) // need to check vpd version for this attr
-        {
-            uint32_t l_vpdVersion = 0;
-            const uint32_t VPD_VERSION_V60=0x3130; // Version 6.0 is ascii "10"
-
-            // get vpd version
-            FAPI_EXEC_HWP(l_fapirc,
-                          getMBvpdVersion,
-                          i_mbaTarget,
-                          l_vpdVersion);
-
-            if (l_fapirc)
-            {
-                FAPI_ERR("getMBvpdTermData: getMBvpdVersion failed");
-                break;  //  break out with fapirc
-            }
-            FAPI_DBG("getMBvpdTermData: vpd version=0x%08x",
-                l_vpdVersion);
-
-            // Check if work around needed
-            if (l_vpdVersion < VPD_VERSION_V60)
-            {
-                MBvpdPhaseRotatorData l_phaseRotAttr = PHASE_ROT_INVALID;
-
-                if (TERM_DATA_RLO == i_attr)
-                {
-                    l_phaseRotAttr = PHASE_ROT_RLO_V53;
-                }
-                else if (TERM_DATA_WLO == i_attr)
-                {
-                    l_phaseRotAttr = PHASE_ROT_WLO_V53;
-                }
-                else if (TERM_DATA_GPO == i_attr)
-                {
-                    l_phaseRotAttr = PHASE_ROT_GPO_V53;
-                }
-                else // not expected
-                {
-                    FAPI_ERR("getMBvpdTermData: invalid attribute ID 0x%02x",
-                       i_attr);
-                    const fapi::MBvpdTermData & ATTR_ID = i_attr;
-                    FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_ATTRIBUTE_ID);
-                    break;  //  break out with fapirc
-                }
-
-                // Retrieve these attributes from the MR keyword
-                FAPI_EXEC_HWP(l_fapirc,
-                              getMBvpdPhaseRotatorData,
-                              i_mbaTarget,
-                              l_phaseRotAttr,
-                              *((uint8_t (*)[2])o_pVal));
-                break; // break out with Phase Rotator data fapirc
-            }
-        }
-
-        // Read the MT keyword field
-        l_pMtBuffer = new mt_keyword;
-
-        uint8_t l_customDimm = 0;
-
-        l_fapirc = FAPI_ATTR_GET(ATTR_EFF_CUSTOM_DIMM,&i_mbaTarget,
-                        l_customDimm);
-        if(l_fapirc)
-        {
-            FAPI_ERR("getMBvpdTermData: Read of Custom Dimm failed");
-            break;
-        }
-
-        //if custom_dimm = 0, use isdimm
-        if(fapi::ENUM_ATTR_EFF_CUSTOM_DIMM_NO == l_customDimm)
-        {
-            //MT keyword is located in the SPDX record,
-            //and found by using ATTR_SPD_NUM_RANKS
-            //T1: one dimm, rank 1  T2: one dimm, rank 2   T4: one dimm, rank 4
-            //T5: two dimm, rank 1  T6: two dimm, rank 2   T8: two dimm, rank 4
-            fapi::ATTR_SPD_NUM_RANKS_Type l_spd_dimm_ranks[2][2] = {
-                {fapi::ENUM_ATTR_SPD_NUM_RANKS_RX,
-                fapi::ENUM_ATTR_SPD_NUM_RANKS_RX},
-                {fapi::ENUM_ATTR_SPD_NUM_RANKS_RX,
-                fapi::ENUM_ATTR_SPD_NUM_RANKS_RX}
-            };
-            uint8_t l_mba_port;
-            uint8_t l_mba_dimm;
-
-            std::vector<fapi::Target> l_target_dimm_array;
-            l_fapirc = fapiGetAssociatedDimms(i_mbaTarget, l_target_dimm_array,
-                                              fapi::TARGET_STATE_PRESENT);
-            if(l_fapirc)
-            {
-                FAPI_ERR("getMBvpdTermData: read of Associated Dimms failed");
-                break;
-            }
-
-            for(uint8_t l_dimm_index=0; l_dimm_index<l_target_dimm_array.size();
-                        l_dimm_index+=1)
-            {
-                l_fapirc = FAPI_ATTR_GET(ATTR_MBA_PORT,
-                                &l_target_dimm_array[l_dimm_index],
-                                l_mba_port);
-                if(l_fapirc)
-                {
-                    FAPI_ERR("getMBvpdTermData: read of ATTR_MBA_PORT failed");
-                    break;
-                }
-                l_fapirc = FAPI_ATTR_GET(ATTR_MBA_DIMM,
-                                &l_target_dimm_array[l_dimm_index],
-                                l_mba_dimm);
-                if(l_fapirc)
-                {
-                    FAPI_ERR("getMBvpdTermData: read of ATTR_MBA_DIMM failed");
-                    break;
-                }
-
-                l_fapirc = FAPI_ATTR_GET(ATTR_SPD_NUM_RANKS,
-                                &l_target_dimm_array[l_dimm_index],
-                                l_spd_dimm_ranks[l_mba_port][l_mba_dimm]);
-                if(l_fapirc)
-                {
-                    FAPI_ERR("getMBvpdTermData: read of ATTR_SPD_NUM_RANKS failed");
-                    break;
-                }
-            }
-            if(l_fapirc)
-            {
-                break;
-            }
-
-            fapi::ATTR_SPD_NUM_RANKS_Type l_rankCopy =
-              fapi::ENUM_ATTR_SPD_NUM_RANKS_RX;
-            uint8_t l_dimmInvalid = 0;
-            bool l_double_drop = false;
-            /* Mismatched rank numbers between the paired ports is an error
-             * that should deconfigure the parent MBA so the data for that
-             * MBA should never be fetched. The same is for mismatched slot 1
-             * and slot 0 on the same port
-             */
-
-            //single or double drop
-            if( (l_spd_dimm_ranks[0][1] == fapi::ENUM_ATTR_SPD_NUM_RANKS_RX)
-              && (l_spd_dimm_ranks[1][1] == fapi::ENUM_ATTR_SPD_NUM_RANKS_RX) )
-            {
-                //if the two match, it's a valid case.
-                if(l_spd_dimm_ranks[0][0] == l_spd_dimm_ranks[1][0])
-                {
-                    //0000, set to 1
-                    if(l_spd_dimm_ranks[0][0]
-                       == fapi::ENUM_ATTR_SPD_NUM_RANKS_RX)
-                    {
-                        l_rankCopy = 1;
-                        //throwing error for all empty
-                        FAPI_ERR("No dimm's found");
-                        const uint8_t DIMM_P0S0 = l_spd_dimm_ranks[0][0];
-                        const uint8_t DIMM_P0S1 = l_spd_dimm_ranks[0][1];
-                        const uint8_t DIMM_P1S0 = l_spd_dimm_ranks[1][0];
-                        const uint8_t DIMM_P1S1 = l_spd_dimm_ranks[1][1];
-                        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_DIMMS_NOT_FOUND);
-                        break;
-
-                    //either 0101,0202,0404.
-                    }
-                    else
-                    {
-                        l_rankCopy = l_spd_dimm_ranks[0][0];
-                    }
-                }else
-                {
-                    //throwing error for invalid dimm combination
-                    l_dimmInvalid = 1;
-                }
-            //if all 4 are the same, its double ranked
-            }else if(l_spd_dimm_ranks[0][1] == l_spd_dimm_ranks[0][0] &&
-                        l_spd_dimm_ranks[1][1] == l_spd_dimm_ranks[1][0] &&
-                        l_spd_dimm_ranks[0][1] == l_spd_dimm_ranks[1][1])
-            {
-                //either 1111,2222,4444
-                l_rankCopy = l_spd_dimm_ranks[0][0];
-                l_double_drop = true;
-            }else
-            {
-                //throwing error for invalid dimm combination
-                l_dimmInvalid = 1;
-            }
-
-            if(l_dimmInvalid)
-            {
-                FAPI_ERR("There is an invalid combination of dimm's found");
-                const uint8_t INVALID_DIMM_P0S0 = l_spd_dimm_ranks[0][0];
-                const uint8_t INVALID_DIMM_P0S1 = l_spd_dimm_ranks[0][1];
-                const uint8_t INVALID_DIMM_P1S0 = l_spd_dimm_ranks[1][0];
-                const uint8_t INVALID_DIMM_P1S1 = l_spd_dimm_ranks[1][1];
-                const fapi::Target & MBA = i_mbaTarget;
-                FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_DIMM_FOUND);
-                break;
-            }
-
-            fapi::MBvpdKeyword l_MT_Keyword = fapi::MBVPD_KEYWORD_T1;
-            switch (l_rankCopy)
-            {
-                case fapi::ENUM_ATTR_SPD_NUM_RANKS_R1:
-                    if( l_double_drop ) {
-                        l_MT_Keyword = fapi::MBVPD_KEYWORD_T5;
-                    } else {
-                        l_MT_Keyword = fapi::MBVPD_KEYWORD_T1;
-                    }
-                    break;
-                case fapi::ENUM_ATTR_SPD_NUM_RANKS_R2:
-                    if( l_double_drop ) {
-                        l_MT_Keyword = fapi::MBVPD_KEYWORD_T6;
-                    } else {
-                        l_MT_Keyword = fapi::MBVPD_KEYWORD_T2;
-                    }
-                    break;
-                case fapi::ENUM_ATTR_SPD_NUM_RANKS_R4:
-                    if( l_double_drop ) {
-                        l_MT_Keyword = fapi::MBVPD_KEYWORD_T8;
-                    } else {
-                        l_MT_Keyword = fapi::MBVPD_KEYWORD_T4;
-                    }
-                    break;
-                default:
-                    FAPI_ERR("Invalid dimm rank : 0x%02x",l_rankCopy);
-                    const uint8_t & RANK_NUM = l_rankCopy;
-                    FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INVALID_MT_DATA);
-                    break;
-            }
-            if(l_fapirc)
-            {
-                break;
-            }
-
-            l_fapirc = fapiGetMBvpdField(fapi::MBVPD_RECORD_SPDX,
-                                     l_MT_Keyword,
-                                     l_mbTarget,
-                                     reinterpret_cast<uint8_t *>(l_pMtBuffer),
-                                     l_MtBufsize);
-            if (l_fapirc)
-            {
-                FAPI_ERR("getMBvpdTermData: Read of Tx (%d) keyword failed",l_MT_Keyword);
-                break;  //  break out with fapirc
-            }
-        //else custom_dimm is 1 and we need to use the CDIMM
-        }
-        else
-        {
-            l_fapirc = fapiGetMBvpdField(fapi::MBVPD_RECORD_VSPD,
-                                     fapi::MBVPD_KEYWORD_MT,
-                                     l_mbTarget,
-                                     reinterpret_cast<uint8_t *>(l_pMtBuffer),
-                                     l_MtBufsize);
-            if (l_fapirc)
-            {
-                FAPI_ERR("getMBvpdTermData: Read of MT keyword failed");
-                break;  //  break out with fapirc
-            }
-        }
-
-
-        // Check that sufficient MT was returned.
-        if (l_MtBufsize < MT_KEYWORD_SIZE )
-        {
-            FAPI_ERR("getMBvpdTermData:"
-                     " less MT keyword returned than expected %d < %d",
-                       l_MtBufsize, MT_KEYWORD_SIZE);
-            const uint32_t & KEYWORD = fapi::MBVPD_KEYWORD_MT;
-            const uint32_t & RETURNED_SIZE = l_MtBufsize;
-            const fapi::Target & CHIP_TARGET = l_mbTarget;
-            FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_INSUFFICIENT_VPD_RETURNED );
-            break;  //  break out with fapirc
-        }
-
-        // return data according to the attribute varible type
-        // The value of the attribute is used as an index into the MT buffer
-        switch (i_attr)
-        {
-            // return the uint8_t [2][2] attributes from the MT keyword buffer
-            // requires translation
-            case TERM_DATA_DRAM_RON:
-            {
-                uint8_t (* l_pVal)[2][2] = (uint8_t (*)[2][2])o_pVal;
-                uint8_t l_value = 0;
-
-                for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
-                {
-                    for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
-                    {
-                        l_value = l_pMtBuffer->
-                     mb_mba[l_pos].mba_port[l_port].port_attr[l_attrOffset+l_j];
-                        l_fapirc = translate_DRAM_RON(i_attr,l_value);
-                        if (l_fapirc)
-                        {
-                            break; // break with error
-                        }
-                        (*l_pVal)[l_port][l_j] = l_value;
-                    }
-                    if (l_fapirc)
-                    {
-                        break; // break with error
-                    }
-               }
-               break;
-            }
-            // return the uint8_t [2][2][4] attributes from the MT keyword
-            // requires translation
-            case TERM_DATA_DRAM_RTT_NOM:
-            case TERM_DATA_DRAM_RTT_WR:
-            {
-                uint8_t (* l_pVal)[2][2][4] = (uint8_t (*)[2][2][4])o_pVal;
-                uint8_t l_value = 0;
-
-                for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
-                {
-                    for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
-                    {
-                        for (uint8_t l_k=0; l_k<NUM_RANKS; l_k++)
-                        {
-                            l_value = l_pMtBuffer->
-     mb_mba[l_pos].mba_port[l_port].port_attr[l_attrOffset+(l_j*NUM_RANKS)+l_k];
-                            if (TERM_DATA_DRAM_RTT_NOM == i_attr)
-                            {
-                                l_fapirc=translate_DRAM_RTT_NOM(i_attr,l_value);
-                            }
-                            else
-                            {
-                                l_fapirc=translate_DRAM_RTT_WR(i_attr,l_value);
-                            }
-                            if (l_fapirc)
-                            {
-                                break; // break with error
-                            }
-                            (*l_pVal)[l_port][l_j][l_k] = l_value;
-                        }
-                        if (l_fapirc)
-                        {
-                            break; // break with error
-                        }
-                    }
-                    if (l_fapirc)
-                    {
-                        break; // break with error
-                    }
-               }
-               break;
-            }
-            // return the uint8_t [2][2][4] attributes from the MT keyword
-            case TERM_DATA_ODT_RD:
-            case TERM_DATA_ODT_WR:
-            {
-                uint8_t (* l_pVal)[2][2][4] = (uint8_t (*)[2][2][4])o_pVal;
-                for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
-                {
-                    for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
-                    {
-                        for (uint8_t l_k=0; l_k<NUM_RANKS; l_k++)
-                        {
-                            (*l_pVal)[l_port][l_j][l_k] = l_pMtBuffer->
-     mb_mba[l_pos].mba_port[l_port].port_attr[l_attrOffset+(l_j*NUM_RANKS)+l_k];
-                        }
-                    }
-               }
-               break;
-            }
-            // return the uint32_t [2][2] attributes from the MT keyword
-            case TERM_DATA_DIMM_RCD_IBT:
-            {
-                uint32_t (* l_pVal)[2][2] = (uint32_t (*)[2][2])o_pVal;
-
-                // cdimm
-                if(fapi::ENUM_ATTR_EFF_CUSTOM_DIMM_NO != l_customDimm)
-                {
-                    for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
-                    {
-                        for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
-                        {
-                            (*l_pVal)[l_port][l_j] = TERM_DATA_IBT_CDIMM;
-                        }
-                    }
-                }
-                // isdimm
-                else
-                {
-                    // get vpd version (in ascii)
-                    uint32_t l_vpdVersion = 0;
-                    FAPI_EXEC_HWP(l_fapirc,
-                                  getMBvpdVersion,
-                                  i_mbaTarget,
-                                  l_vpdVersion);
-                    if (l_fapirc)
-                    {
-                        FAPI_ERR("getMBvpdTermData: TERM_DATA_DIMM_RCD_IBT - getMBvpdVersion failed");
-                        break;  //  break out with fapirc
-                    }
-
-                    for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
-                    {
-                        for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
-                        {
-                            if (l_vpdVersion < 0x3133)  // ascii "13"
-                            {
-                                (*l_pVal)[l_port][l_j] = TERM_DATA_IBT_PRE13;
-                            }
-                            // else use the VPD value
-                            else
-                            {
-                                (*l_pVal)[l_port][l_j] = l_pMtBuffer->
-    mb_mba[l_pos].mba_port[l_port].port_attr[l_attrOffset+l_j];
-                            }
-                        }
-                    }
-                }
-                break;
-            }
-            // return the uint8_t [2][2] attributes from the MT keyword
-            case TERM_DATA_DIMM_RCD_OUTPUT_TIMING:
-            {
-                uint8_t (* l_pVal)[2][2] = (uint8_t (*)[2][2])o_pVal;
-
-                // cdimm
-                if(fapi::ENUM_ATTR_EFF_CUSTOM_DIMM_NO != l_customDimm)
-                {
-                    for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
-                    {
-                        for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
-                        {
-                            (*l_pVal)[l_port][l_j] =
-                                            TERM_DATA_OUTPUT_TIMING_CDIMM;
-                        }
-                    }
-                }
-                // isdimm
-                else
-                {
-                    // get vpd version (in ascii)
-                    uint32_t l_vpdVersion = 0;
-                    FAPI_EXEC_HWP(l_fapirc,
-                                  getMBvpdVersion,
-                                  i_mbaTarget,
-                                  l_vpdVersion);
-                    if (l_fapirc)
-                    {
-                        FAPI_ERR("getMBvpdTermData: TERM_DATA_DIMM_RCD_OUTPUT_TIMING - getMBvpdVersion failed");
-                        break;  //  break out with fapirc
-                    }
-
-                    for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
-                    {
-                        for (uint8_t l_j=0; l_j<NUM_DIMMS; l_j++)
-                        {
-                            if (l_vpdVersion < 0x3133)  // ascii "13"
-                            {
-                                (*l_pVal)[l_port][l_j] =
-                                            TERM_DATA_OUTPUT_TIMING_PRE13;
-                            }
-                            // else use the VPD value
-                            // use the same vpd value for dimm0 and dimm1
-                            else
-                            {
-                                (*l_pVal)[l_port][l_j] = l_pMtBuffer->
-    mb_mba[l_pos].mba_port[l_port].port_attr[l_attrOffset];
-                            }
-                        }
-
-                    }
-                }
-                break;
-            }
-            // return the uint32_t [2] attributes from the MT keyword buffer
-            // requires translation
-            case TERM_DATA_CEN_RD_VREF:
-            {
-                uint32_t (* l_pVal)[2] = (uint32_t (*)[2])o_pVal;
-                uint32_t l_value = 0;
-
-                for (uint8_t l_port=0; l_port<2;l_port++)
-                {
-                    l_value =  l_pMtBuffer->
-                        mb_mba[l_pos].mba_port[l_port].port_attr[l_attrOffset];
-                    l_fapirc = translate_CEN_RD_VREF(i_attr,l_value);
-                    if (l_fapirc)
-                    {
-                        break; // break with error
-                    }
-                    (*l_pVal)[l_port] = l_value;
-                }
-                break;
-            }
-            // return the uint32_t [2] attributes from the MT keyword buffer
-            // requires translation
-            case TERM_DATA_DRAM_WR_VREF:
-            {
-                uint32_t (* l_pVal)[2] = (uint32_t (*)[2])o_pVal;
-                uint32_t l_value = 0;
-
-                // get vpd version (in ascii)
-                uint32_t l_vpdVersion = 0;
-                FAPI_EXEC_HWP(l_fapirc,
-                              getMBvpdVersion,
-                              i_mbaTarget,
-                              l_vpdVersion);
-                if (l_fapirc)
-                {
-                    FAPI_ERR("getMBvpdTermData: TERM_DATA_DRAM_WR_VREF - getMBvpdVersion failed");
-                    break;  //  break out with fapirc
-                }
-
-                for (uint8_t l_port=0; l_port<2;l_port++)
-                {
-                    // cdimm or version < "13" ascii
-                    if( (fapi::ENUM_ATTR_EFF_CUSTOM_DIMM_NO != l_customDimm) ||
-                        (l_vpdVersion < 0x3133) )
-                    {
-                        // data is in the last byte of the uint32
-                        uint32_t * l_pWord =  (uint32_t *)&l_pMtBuffer->
-    mb_mba[l_pos].mba_port[l_port].port_attr[l_attrOffset];
-                        l_value  = FAPI_BE32TOH(* l_pWord);
-                    }
-                    // isdimm and version "13" or greater
-                    else
-                    {
-                        // data is in the first byte of the uint32
-                        l_value =  l_pMtBuffer->
-    mb_mba[l_pos].mba_port[l_port].port_attr[l_attrOffset];
-                    }
-
-                    l_fapirc = translate_DRAM_WR_VREF(i_attr,l_value);
-                    if (l_fapirc)
-                    {
-                        break; // break with error
-                    }
-                    (*l_pVal)[l_port] = l_value;
-                }
-                break;
-            }
-            // return the uint64_t attributes from the MT keyword buffer
-            // need to consider endian since they are word fields
-            case TERM_DATA_CKE_PWR_MAP:
-            {
-                uint64_t (* l_pVal) = (uint64_t (*))o_pVal;
-
-                uint32_t * l_pWord =  (uint32_t *)&l_pMtBuffer->
-                        mb_mba[l_pos].mba_port[0].port_attr[l_attrOffset];
-                uint32_t l_port0 = FAPI_BE32TOH(*l_pWord);
-
-                l_pWord =  (uint32_t *)&l_pMtBuffer->
-                        mb_mba[l_pos].mba_port[1].port_attr[l_attrOffset];
-                uint32_t l_port1 = FAPI_BE32TOH(*l_pWord);
-
-                (*l_pVal) = ( ((static_cast<uint64_t>(l_port0))<<32) |
-                               (static_cast<uint64_t>(l_port1)) );
-
-                break;
-            }
-            // return the uint16_t [2] attributes from the MT keyword buffer
-            // into the return uint32_t [2]
-            // need to consider endian since they are word fields
-            case TERM_DATA_CKE_PRI_MAP:
-            {
-                uint32_t (* l_pVal)[2] = (uint32_t (*)[2])o_pVal;
-                (*l_pVal)[0] = l_pMtBuffer->
-                    mb_mba[l_pos].mba_port[0].port_attr[l_attrOffset+1]; //LSB
-                (*l_pVal)[0] |= (l_pMtBuffer->
-                    mb_mba[l_pos].mba_port[0].port_attr[l_attrOffset]<<8); //MSB
-                (*l_pVal)[1] = l_pMtBuffer->
-                    mb_mba[l_pos].mba_port[1].port_attr[l_attrOffset+1]; //LSB
-                (*l_pVal)[1] |= (l_pMtBuffer->
-                    mb_mba[l_pos].mba_port[1].port_attr[l_attrOffset]<<8); //MSB
-                break;
-            }
-            // return the uint8_t [2] attributes from the MT keyword buffer
-            // requires translation
-            case TERM_DATA_CEN_SLEW_RATE_DQ_DQS:
-            case TERM_DATA_CEN_SLEW_RATE_CNTL:
-            case TERM_DATA_CEN_SLEW_RATE_ADDR:
-            case TERM_DATA_CEN_SLEW_RATE_CLK:
-            case TERM_DATA_CEN_SLEW_RATE_SPCKE:
-            {
-                uint8_t (* l_pVal)[2] = (uint8_t (*)[2])o_pVal;
-                uint8_t l_value = 0;
-
-                for (uint8_t l_port=0; l_port<NUM_PORTS;l_port++)
-                {
-                    l_value= l_pMtBuffer->
-                        mb_mba[l_pos].mba_port[l_port].port_attr[i_attr];
-                    l_fapirc = translate_SLEW_RATE(i_attr,l_value);
-                    if (l_fapirc)
-                    {
-                        break; // break with error
-                    }
-                    (*l_pVal)[l_port] = l_value;
-                }
-                break;
-            }
-            // return the uint8_t [2] attributes from the MT keyword buffer
-            case TERM_DATA_DRAM_WRDDR4_VREF:
-            case TERM_DATA_CEN_RCV_IMP_DQ_DQS:
-            case TERM_DATA_CEN_DRV_IMP_DQ_DQS:
-            case TERM_DATA_CEN_DRV_IMP_CNTL:
-            case TERM_DATA_CEN_DRV_IMP_ADDR:
-            case TERM_DATA_CEN_DRV_IMP_CLK:
-            case TERM_DATA_CEN_DRV_IMP_SPCKE:
-            case TERM_DATA_RLO:
-            case TERM_DATA_WLO:
-            case TERM_DATA_GPO:
-            {
-                uint8_t (* l_pVal)[2] = (uint8_t (*)[2])o_pVal;
-
-                // pull data from keyword buffer
-                uint8_t l_port0 = l_pMtBuffer->
-                        mb_mba[l_pos].mba_port[0].port_attr[l_attrOffset];
-                uint8_t l_port1 = l_pMtBuffer->
-                        mb_mba[l_pos].mba_port[1].port_attr[l_attrOffset];
-
-                // isolate special processing flags
-                uint32_t  l_special = i_attr & TERM_DATA_SPECIAL_MASK;
-                switch (l_special)
-                {
-                case TERM_DATA_LOW_NIBBLE: // return low nibble
-                    l_port0 = l_port0 & 0x0F;
-                    l_port1 = l_port1 & 0x0F;
-                    break;
-
-                case TERM_DATA_HIGH_NIBBLE: // return high nibble
-                    l_port0 = ((l_port0 & 0xF0)>>4);
-                    l_port1 = ((l_port1 & 0xF0)>>4);
-                    break;
-                default:
-                         ;      // data is ok directly from keyword buffer
-                }
-
-                (*l_pVal)[0] = l_port0;
-                (*l_pVal)[1] = l_port1;
-                break;
-            }
-        }
-
-
-    } while (0);
-
-    delete l_pMtBuffer;
-    l_pMtBuffer = NULL;
-
-    FAPI_DBG("getMBvpdTermData: exit rc=0x%08x)",
-               static_cast<uint32_t>(l_fapirc));
-
-    return  l_fapirc;
-}
-
-// ----------------------------------------------------------------------------
-// Translate vpd values to attribute enumeration for ATTR_VPD_DRAM_RON
-// ----------------------------------------------------------------------------
-fapi::ReturnCode translate_DRAM_RON (const fapi::MBvpdTermData i_attr,
-                                     uint8_t & io_value)
-{
-    fapi::ReturnCode l_fapirc;
-    const uint8_t VPD_DRAM_RON_INVALID = 0x00;
-    const uint8_t VPD_DRAM_RON_OHM34 = 0x07;
-    const uint8_t VPD_DRAM_RON_OHM40 = 0x03;
-
-    switch (io_value)
-    {
-    case VPD_DRAM_RON_INVALID:
-        io_value=fapi::ENUM_ATTR_VPD_DRAM_RON_INVALID;
-        break;
-    case VPD_DRAM_RON_OHM34:
-        io_value=fapi::ENUM_ATTR_VPD_DRAM_RON_OHM34;
-        break;
-    case VPD_DRAM_RON_OHM40:
-        io_value=fapi::ENUM_ATTR_VPD_DRAM_RON_OHM40;
-        break;
-    default:
-        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_DRAM_RON 0x%02x",
-                 io_value);
-        const fapi::MBvpdTermData & ATTR_ID = i_attr;
-        const uint8_t  & VPD_VALUE = io_value;
-        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
-        break;
-    }
-
-    return  l_fapirc;
-}
-
-// ----------------------------------------------------------------------------
-// Translate vpd values to attribute enumeration for ATTR_VPD_DRAM_RTT_NOM
-// ----------------------------------------------------------------------------
-fapi::ReturnCode translate_DRAM_RTT_NOM (const fapi::MBvpdTermData i_attr,
-                                         uint8_t & io_value)
-{
-    fapi::ReturnCode l_fapirc;
-    const uint8_t DRAM_RTT_NOM_DISABLE = 0x00;
-    const uint8_t DRAM_RTT_NOM_OHM20 = 0x04;
-    const uint8_t DRAM_RTT_NOM_OHM30 = 0x05;
-    const uint8_t DRAM_RTT_NOM_OHM34 = 0x07;
-    const uint8_t DRAM_RTT_NOM_OHM40 = 0x03;
-    const uint8_t DRAM_RTT_NOM_OHM48 = 0x85;
-    const uint8_t DRAM_RTT_NOM_OHM60 = 0x01;
-    const uint8_t DRAM_RTT_NOM_OHM80 = 0x06;
-    const uint8_t DRAM_RTT_NOM_OHM120 = 0x02;
-    const uint8_t DRAM_RTT_NOM_OHM240 = 0x84;
-
-    switch(io_value)
-    {
-    case DRAM_RTT_NOM_DISABLE:
-        io_value=fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_DISABLE;
-        break;
-    case DRAM_RTT_NOM_OHM20:
-        io_value= fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM20;
-        break;
-    case DRAM_RTT_NOM_OHM30:
-        io_value= fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM30;
-        break;
-    case DRAM_RTT_NOM_OHM34:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM34;
-        break;
-    case DRAM_RTT_NOM_OHM40:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM40;
-        break;
-    case DRAM_RTT_NOM_OHM48:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM48;
-        break;
-    case DRAM_RTT_NOM_OHM60:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM60;
-        break;
-    case DRAM_RTT_NOM_OHM80:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM80;
-        break;
-    case DRAM_RTT_NOM_OHM120:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM120;
-        break;
-    case DRAM_RTT_NOM_OHM240:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_RTT_NOM_OHM240;
-        break;
-    default:
-        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_DRAM_RTT_NOM 0x%02x",
-                    io_value);
-        const fapi::MBvpdTermData & ATTR_ID = i_attr;
-        const uint8_t  & VPD_VALUE = io_value;
-        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
-        break;
-    }
-
-    return  l_fapirc;
-}
-
-// ----------------------------------------------------------------------------
-// Translate vpd values to attribute enumeration for ATTR_VPD_DRAM_RTT_WR
-// ----------------------------------------------------------------------------
-fapi::ReturnCode translate_DRAM_RTT_WR (const fapi::MBvpdTermData i_attr,
-                                        uint8_t & io_value)
-{
-    fapi::ReturnCode l_fapirc;
-    const uint8_t DRAM_RTT_WR_DISABLE = 0x00;
-    const uint8_t DRAM_RTT_WR_OHM60   = 0x01;
-    const uint8_t DRAM_RTT_WR_OHM120  = 0x02;
-
-    switch(io_value)
-    {
-    case DRAM_RTT_WR_DISABLE:
-        io_value=fapi::ENUM_ATTR_VPD_DRAM_RTT_WR_DISABLE;
-        break;
-    case DRAM_RTT_WR_OHM60:
-        io_value= fapi::ENUM_ATTR_VPD_DRAM_RTT_WR_OHM60;
-        break;
-    case DRAM_RTT_WR_OHM120:
-        io_value= fapi::ENUM_ATTR_VPD_DRAM_RTT_WR_OHM120;
-        break;
-    default:
-        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_DRAM_RTT_WR 0x%02x",
-                    io_value);
-        const fapi::MBvpdTermData & ATTR_ID = i_attr;
-        const uint8_t  & VPD_VALUE = io_value;
-        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
-        break;
-    }
-
-    return  l_fapirc;
-}
-
-// ----------------------------------------------------------------------------
-// Translate vpd values to attribute enumeration for ATTR_VPD_DRAM_WR_VREF
-// ----------------------------------------------------------------------------
-fapi::ReturnCode translate_DRAM_WR_VREF (const fapi::MBvpdTermData i_attr,
-                                         uint32_t & io_value)
-{
-    fapi::ReturnCode l_fapirc;
-    // The following intentionally skips 0x0a..0x0f, 0x1a..0x1f, and 0x2a..0x2f
-    const uint8_t WR_VREF_VDD420 = 0x00;
-    const uint8_t WR_VREF_VDD425 = 0x01;
-    const uint8_t WR_VREF_VDD430 = 0x02;
-    const uint8_t WR_VREF_VDD435 = 0x03;
-    const uint8_t WR_VREF_VDD440 = 0x04;
-    const uint8_t WR_VREF_VDD445 = 0x05;
-    const uint8_t WR_VREF_VDD450 = 0x06;
-    const uint8_t WR_VREF_VDD455 = 0x07;
-    const uint8_t WR_VREF_VDD460 = 0x08;
-    const uint8_t WR_VREF_VDD465 = 0x09;
-    const uint8_t WR_VREF_VDD470 = 0x10;
-    const uint8_t WR_VREF_VDD475 = 0x11;
-    const uint8_t WR_VREF_VDD480 = 0x12;
-    const uint8_t WR_VREF_VDD485 = 0x13;
-    const uint8_t WR_VREF_VDD490 = 0x14;
-    const uint8_t WR_VREF_VDD495 = 0x15;
-    const uint8_t WR_VREF_VDD500 = 0x16;
-    const uint8_t WR_VREF_VDD505 = 0x17;
-    const uint8_t WR_VREF_VDD510 = 0x18;
-    const uint8_t WR_VREF_VDD515 = 0x19;
-    const uint8_t WR_VREF_VDD520 = 0x20;
-    const uint8_t WR_VREF_VDD525 = 0x21;
-    const uint8_t WR_VREF_VDD530 = 0x22;
-    const uint8_t WR_VREF_VDD535 = 0x23;
-    const uint8_t WR_VREF_VDD540 = 0x24;
-    const uint8_t WR_VREF_VDD545 = 0x25;
-    const uint8_t WR_VREF_VDD550 = 0x26;
-    const uint8_t WR_VREF_VDD555 = 0x27;
-    const uint8_t WR_VREF_VDD560 = 0x28;
-    const uint8_t WR_VREF_VDD565 = 0x29;
-    const uint8_t WR_VREF_VDD570 = 0x30;
-    const uint8_t WR_VREF_VDD575 = 0x31;
-
-    switch(io_value)
-    {
-    case WR_VREF_VDD420:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD420;
-        break;
-    case WR_VREF_VDD425:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD425;
-        break;
-    case WR_VREF_VDD430:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD430;
-        break;
-    case WR_VREF_VDD435:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD435;
-        break;
-    case WR_VREF_VDD440:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD440;
-        break;
-    case WR_VREF_VDD445:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD445;
-        break;
-    case WR_VREF_VDD450:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD450;
-        break;
-    case WR_VREF_VDD455:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD455;
-        break;
-    case WR_VREF_VDD460:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD460;
-        break;
-    case WR_VREF_VDD465:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD465;
-        break;
-    case WR_VREF_VDD470:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD470;
-        break;
-    case WR_VREF_VDD475:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD475;
-        break;
-    case WR_VREF_VDD480:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD480;
-        break;
-    case WR_VREF_VDD485:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD485;
-        break;
-    case WR_VREF_VDD490:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD490;
-        break;
-    case WR_VREF_VDD495:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD495;
-        break;
-    case WR_VREF_VDD500:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD500;
-        break;
-    case WR_VREF_VDD505:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD505;
-        break;
-    case WR_VREF_VDD510:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD510;
-        break;
-    case WR_VREF_VDD515:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD515;
-        break;
-    case WR_VREF_VDD520:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD520;
-        break;
-    case WR_VREF_VDD525:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD525;
-        break;
-    case WR_VREF_VDD530:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD530;
-        break;
-    case WR_VREF_VDD535:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD535;
-        break;
-    case WR_VREF_VDD540:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD540;
-        break;
-    case WR_VREF_VDD545:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD545;
-        break;
-    case WR_VREF_VDD550:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD550;
-        break;
-    case WR_VREF_VDD555:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD555;
-        break;
-    case WR_VREF_VDD560:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD560;
-        break;
-    case WR_VREF_VDD565:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD565;
-        break;
-    case WR_VREF_VDD570:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD570;
-        break;
-    case WR_VREF_VDD575:
-        io_value = fapi::ENUM_ATTR_VPD_DRAM_WR_VREF_VDD575;
-        break;
-    default:
-        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_DRAM_WR_VREF 0x%08x",
-                    io_value);
-        const fapi::MBvpdTermData & ATTR_ID = i_attr;
-        const uint32_t  & VPD_VALUE = io_value;
-        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
-        break;
-    }
-
-    return  l_fapirc;
-}
-
-// ----------------------------------------------------------------------------
-// Translate vpd values to attribute enumeration for ATTR_VPD_CEN_RD_VREF
-// ----------------------------------------------------------------------------
-fapi::ReturnCode translate_CEN_RD_VREF (const fapi::MBvpdTermData i_attr,
-                                        uint32_t & io_value)
-{
-    fapi::ReturnCode l_fapirc;
-    const uint8_t RD_VREF_VDD61000 = 0x15;
-    const uint8_t RD_VREF_VDD59625 = 0x14;
-    const uint8_t RD_VREF_VDD58250 = 0x13;
-    const uint8_t RD_VREF_VDD56875 = 0x12;
-    const uint8_t RD_VREF_VDD55500 = 0x11;
-    const uint8_t RD_VREF_VDD54125 = 0x10;
-    const uint8_t RD_VREF_VDD52750 = 0x09;
-    const uint8_t RD_VREF_VDD51375 = 0x08;
-    const uint8_t RD_VREF_VDD50000 = 0x07;
-    const uint8_t RD_VREF_VDD48625 = 0x06;
-    const uint8_t RD_VREF_VDD47250 = 0x05;
-    const uint8_t RD_VREF_VDD45875 = 0x04;
-    const uint8_t RD_VREF_VDD44500 = 0x03;
-    const uint8_t RD_VREF_VDD43125 = 0x02;
-    const uint8_t RD_VREF_VDD41750 = 0x01;
-    const uint8_t RD_VREF_VDD40375 = 0x00;
-    const uint8_t RD_VREF_VDD81000 = 0x31;
-    const uint8_t RD_VREF_VDD79625 = 0x30;
-    const uint8_t RD_VREF_VDD78250 = 0x29;
-    const uint8_t RD_VREF_VDD76875 = 0x28;
-    const uint8_t RD_VREF_VDD75500 = 0x27;
-    const uint8_t RD_VREF_VDD74125 = 0x26;
-    const uint8_t RD_VREF_VDD72750 = 0x25;
-    const uint8_t RD_VREF_VDD71375 = 0x24;
-    const uint8_t RD_VREF_VDD70000 = 0x23;
-    const uint8_t RD_VREF_VDD68625 = 0x22;
-    const uint8_t RD_VREF_VDD67250 = 0x21;
-    const uint8_t RD_VREF_VDD65875 = 0x20;
-    const uint8_t RD_VREF_VDD64500 = 0x19;
-    const uint8_t RD_VREF_VDD63125 = 0x18;
-    const uint8_t RD_VREF_VDD61750 = 0x17;
-    const uint8_t RD_VREF_VDD60375 = 0x16;
-
-    switch(io_value)
-    {
-    case RD_VREF_VDD61000:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD61000;
-        break;
-    case RD_VREF_VDD59625:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD59625;
-        break;
-    case RD_VREF_VDD58250:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD58250;
-        break;
-    case RD_VREF_VDD56875:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD56875;
-        break;
-    case RD_VREF_VDD55500:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD55500;
-        break;
-    case RD_VREF_VDD54125:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD54125;
-        break;
-    case RD_VREF_VDD52750:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD52750;
-        break;
-    case RD_VREF_VDD51375:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD51375;
-        break;
-    case RD_VREF_VDD50000:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD50000;
-        break;
-    case RD_VREF_VDD48625:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD48625;
-        break;
-    case RD_VREF_VDD47250:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD47250;
-        break;
-    case RD_VREF_VDD45875:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD45875;
-        break;
-    case RD_VREF_VDD44500:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD44500;
-        break;
-    case RD_VREF_VDD43125:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD43125;
-        break;
-    case RD_VREF_VDD41750:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD41750;
-        break;
-    case RD_VREF_VDD40375:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD40375;
-        break;
-    case RD_VREF_VDD81000:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD81000;
-        break;
-    case RD_VREF_VDD79625:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD79625;
-        break;
-    case RD_VREF_VDD78250:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD78250;
-        break;
-    case RD_VREF_VDD76875:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD76875;
-        break;
-    case RD_VREF_VDD75500:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD75500;
-        break;
-    case RD_VREF_VDD74125:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD74125;
-        break;
-    case RD_VREF_VDD72750:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD72750;
-        break;
-    case RD_VREF_VDD71375:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD71375;
-        break;
-    case RD_VREF_VDD70000:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD70000;
-        break;
-    case RD_VREF_VDD68625:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD68625;
-        break;
-    case RD_VREF_VDD67250:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD67250;
-        break;
-    case RD_VREF_VDD65875:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD65875;
-        break;
-    case RD_VREF_VDD64500:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD64500;
-        break;
-    case RD_VREF_VDD63125:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD63125;
-        break;
-    case RD_VREF_VDD61750:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD61750;
-        break;
-    case RD_VREF_VDD60375:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_RD_VREF_VDD60375;
-        break;
-    default:
-        FAPI_ERR("Unsupported VPD encode for ATTR_VPD_CEN_RD_VREF 0x%08x",
-                    io_value);
-        const fapi::MBvpdTermData & ATTR_ID = i_attr;
-        const uint32_t  & VPD_VALUE = io_value;
-        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
-        break;
-    }
-
-    return  l_fapirc;
-}
-
-// ----------------------------------------------------------------------------
-// Translate vpd values to attribute enumeration for
-//   ATTR_VPD_CEN_SLEW_RATE_DQ_DQS
-//   ATTR_VPD_CEN_SLEW_RATE_ADDR
-//   ATTR_VPD_CEN_SLEW_RATE_CLK
-//   ATTR_VPD_CEN_SLEW_RATE_SPCKE
-//   ATTR_VPD_CEN_SLEW_RATE_CNTL
-// They all have the same mapping and can share a translation procedure
-// ----------------------------------------------------------------------------
-fapi::ReturnCode translate_SLEW_RATE (const fapi::MBvpdTermData i_attr,
-                                     uint8_t & io_value)
-{
-    fapi::ReturnCode l_fapirc;
-    const uint8_t SLEW_RATE_3V_NS = 0x03;
-    const uint8_t SLEW_RATE_4V_NS = 0x04;
-    const uint8_t SLEW_RATE_5V_NS = 0x05;
-    const uint8_t SLEW_RATE_6V_NS = 0x06;
-    const uint8_t SLEW_RATE_MAXV_NS = 0x0F;
-
-//  Ensure that the enums are equal so that one routine can be shared
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_3V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_3V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS==
-                       (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_3V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_3V_NS>();
-
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_4V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_4V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS==
-                       (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_4V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_4V_NS>();
-
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_5V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_5V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS==
-                       (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_5V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_5V_NS>();
-
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_6V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_6V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS==
-                       (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_6V_NS>();
-    checkConstantsMatch<(uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS==
-                        (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_6V_NS>();
-
-    checkConstantsMatch<
-                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS==
-                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_ADDR_SLEW_MAXV_NS>();
-    checkConstantsMatch<
-                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS==
-                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CLK_SLEW_MAXV_NS>();
-    checkConstantsMatch<
-                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS==
-                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_SPCKE_SLEW_MAXV_NS>();
-    checkConstantsMatch<
-                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS==
-                     (uint8_t)ENUM_ATTR_VPD_CEN_SLEW_RATE_CNTL_SLEW_MAXV_NS>();
-
-    switch(io_value)
-    {
-    case SLEW_RATE_3V_NS:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_3V_NS;
-        break;
-    case SLEW_RATE_4V_NS:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_4V_NS;
-        break;
-    case SLEW_RATE_5V_NS:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_5V_NS;
-        break;
-    case SLEW_RATE_6V_NS:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_6V_NS;
-        break;
-    case SLEW_RATE_MAXV_NS:
-        io_value = fapi::ENUM_ATTR_VPD_CEN_SLEW_RATE_DQ_DQS_SLEW_MAXV_NS;
-        break;
-    default:
-         FAPI_ERR("Unsupported VPD encode for ATTR_VPD_CEN_SLEW_RATE 0x%02x",
-                    io_value);
-        const fapi::MBvpdTermData & ATTR_ID = i_attr;
-        const uint8_t  & VPD_VALUE = io_value;
-        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_TERM_DATA_UNSUPPORTED_VPD_ENCODE);
-        break;
-    }
-
-    return  l_fapirc;
-}
-
-}   // extern "C"
-
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/mvpd.mk b/src/usr/hwpf/hwp/mvpd_accessors/mvpd.mk
index 985327bea..789d57cdb 100644
--- a/src/usr/hwpf/hwp/mvpd_accessors/mvpd.mk
+++ b/src/usr/hwpf/hwp/mvpd_accessors/mvpd.mk
@@ -5,7 +5,7 @@
 #
 # OpenPOWER HostBoot Project
 #
-# Contributors Listed Below - COPYRIGHT 2012,2014
+# Contributors Listed Below - COPYRIGHT 2012,2015
 # [+] International Business Machines Corp.
 #
 #
@@ -34,9 +34,7 @@ OBJS += getMBvpdRing.o
 OBJS += setMvpdRing.o
 OBJS += mvpdRingFuncs.o
 OBJS += getMvpdExL2SingleMemberEnable.o
-OBJS += getMBvpdPhaseRotatorData.o
 OBJS += getMBvpdAddrMirrorData.o
-OBJS += getMBvpdTermData.o
 OBJS += getMBvpdSlopeInterceptData.o
 OBJS += getMBvpdSpareDramData.o
 OBJS += getMBvpdVersion.o
@@ -47,3 +45,6 @@ OBJS += accessMBvpdL4BankDelete.o
 OBJS += getDecompressedISDIMMAttrs.o
 OBJS += getISDIMMTOC4DAttrs.o
 OBJS += DQCompressionLib.o
+OBJS += getMBvpdAttr.o
+OBJS += getMBvpdAttrData.o
+
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/mvpd_errors.xml b/src/usr/hwpf/hwp/mvpd_accessors/mvpd_errors.xml
index f3ad88b27..47e0f1b77 100644
--- a/src/usr/hwpf/hwp/mvpd_accessors/mvpd_errors.xml
+++ b/src/usr/hwpf/hwp/mvpd_accessors/mvpd_errors.xml
@@ -5,7 +5,7 @@
 <!--                                                                        -->
 <!-- OpenPOWER HostBoot Project                                             -->
 <!--                                                                        -->
-<!-- Contributors Listed Below - COPYRIGHT 2012,2014                        -->
+<!-- Contributors Listed Below - COPYRIGHT 2012,2015                        -->
 <!-- [+] International Business Machines Corp.                              -->
 <!--                                                                        -->
 <!--                                                                        -->
@@ -22,7 +22,7 @@
 <!-- permissions and limitations under the License.                         -->
 <!--                                                                        -->
 <!-- IBM_PROLOG_END_TAG                                                     -->
-<!-- $Id: mvpd_errors.xml,v 1.21 2014/11/03 17:56:17 eliner Exp $ -->
+<!-- $Id: mvpd_errors.xml,v 1.22 2014/12/11 13:30:47 whs Exp $ -->
 <hwpErrors>
   <!-- ********************************************************************* -->
   <hwpError>
@@ -126,6 +126,7 @@
     <description>
         Output variable size must match size of expected output type.
     </description>
+    <ffdc>ATTR_ID</ffdc>
     <ffdc>EXPECTED_SIZE</ffdc>
     <ffdc>PASSED_SIZE</ffdc>
     <callout>
@@ -330,4 +331,60 @@
       <priority>HIGH</priority>
     </callout>
   </hwpError>
+  <!-- ********************************************************************* -->
+  <hwpError>
+    <rc>RC_MBVPD_UNEXPECTED_ISDIMM_KEYWORD</rc>
+    <description>
+         ISDIMM Attribute definition has unexpected keyword value.
+    </description>
+    <ffdc>ATTR_ID</ffdc>
+    <ffdc>KEYWORD</ffdc>
+    <callout>
+      <procedure>CODE</procedure>
+      <priority>HIGH</priority>
+    </callout>
+  </hwpError>
+  <!-- ********************************************************************* -->
+  <hwpError>
+    <rc>RC_MBVPD_DEFAULT_UNEXPECTED_OUTPUT_TYPE</rc>
+    <description>
+         Default attribute definition has unexpected output type.
+    </description>
+    <ffdc>ATTR_ID</ffdc>
+    <ffdc>DIMM_TYPE</ffdc>
+    <ffdc>OUTPUT_TYPE</ffdc>
+    <callout>
+      <procedure>CODE</procedure>
+      <priority>HIGH</priority>
+    </callout>
+  </hwpError>
+  <!-- ********************************************************************* -->
+  <hwpError>
+    <rc>RC_MBVPD_UINT64_UNEXPECTED_OUTPUT_TYPE</rc>
+    <description>
+         Uint64_t attribute definition has unexpected output type.
+    </description>
+    <ffdc>ATTR_ID</ffdc>
+    <ffdc>DIMM_TYPE</ffdc>
+    <ffdc>OUTPUT_TYPE</ffdc>
+    <callout>
+      <procedure>CODE</procedure>
+      <priority>HIGH</priority>
+    </callout>
+  </hwpError>
+  <!-- ********************************************************************* -->
+  <hwpError>
+    <rc>RC_MBVPD_UNEXPECTED_OUTPUT_TYPE</rc>
+    <description>
+         Attribute definition has unexpected output type.
+    </description>
+    <ffdc>ATTR_ID</ffdc>
+    <ffdc>DIMM_TYPE</ffdc>
+    <ffdc>OUTPUT_TYPE</ffdc>
+    <callout>
+      <procedure>CODE</procedure>
+      <priority>HIGH</priority>
+    </callout>
+  </hwpError>
+  <!-- ********************************************************************* -->
 </hwpErrors>
diff --git a/src/usr/hwpf/plat/fapiPlatAttributeService.C b/src/usr/hwpf/plat/fapiPlatAttributeService.C
index 617c97b92..d8fce34f8 100644
--- a/src/usr/hwpf/plat/fapiPlatAttributeService.C
+++ b/src/usr/hwpf/plat/fapiPlatAttributeService.C
@@ -44,14 +44,12 @@
 #include <vpd/spdenums.H>
 #include <devicefw/driverif.H>
 #include <hwpf/hwp/mvpd_accessors/getMvpdExL2SingleMemberEnable.H>
-#include <hwpf/hwp/mvpd_accessors/getMBvpdPhaseRotatorData.H>
-#include <hwpf/hwp/mvpd_accessors/getMBvpdAddrMirrorData.H>
-#include <hwpf/hwp/mvpd_accessors/getMBvpdTermData.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdSlopeInterceptData.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdSpareDramData.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdVersion.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdDram2NModeEnabled.H>
 #include <hwpf/hwp/mvpd_accessors/getMBvpdSensorMap.H>
+#include <hwpf/hwp/mvpd_accessors/getMBvpdAttr.H>
 #include <hwpf/hwp/mvpd_accessors/accessMBvpdL4BankDelete.H>
 #include <hwpf/hwp/chip_accessors/getPciOscswitchConfig.H>
 #include <hwpf/hwp/chip_accessors/getOscswitchCtlAttr.H>
@@ -1032,17 +1030,6 @@ fapi::ReturnCode fapiPlatGetSingleMemberEnableAttr(
     return l_rc;
 }
 
-fapi::ReturnCode fapiPlatGetPhaseRotatorData (
-             const fapi::Target * i_pTarget,
-             const fapi::MBvpdPhaseRotatorData i_attr,
-             uint8_t    (&o_val) [2] )
-{
-    // Call a VPD Accessor HWP to get the data
-    fapi::ReturnCode l_rc;
-    FAPI_EXEC_HWP(l_rc, getMBvpdPhaseRotatorData, *i_pTarget, i_attr, o_val);
-    return l_rc;
-}
-
 fapi::ReturnCode fapiPlatGetAddrMirrorData (
              const fapi::Target * i_pTarget,
              uint8_t   (& o_val) [2][2] )
@@ -1053,15 +1040,15 @@ fapi::ReturnCode fapiPlatGetAddrMirrorData (
     return l_rc;
 }
 
-fapi::ReturnCode fapiPlatGetTermData (
+fapi::ReturnCode fapiPlatGetAttrData (
              const fapi::Target * i_pTarget,
-             const fapi::MBvpdTermData i_attr,
+             const fapi::AttributeId i_attr,
              void  * o_pVal,
-             const uint32_t i_valSize)
+             const size_t i_valSize)
 {
     // Call a VPD Accessor HWP to get the data
     fapi::ReturnCode l_rc;
-    FAPI_EXEC_HWP(l_rc, getMBvpdTermData,
+    FAPI_EXEC_HWP(l_rc, getMBvpdAttr,
                         *i_pTarget, i_attr, o_pVal, i_valSize);
     return l_rc;
 }
diff --git a/src/usr/hwpf/test/hwpMBvpdAccessorTest.H b/src/usr/hwpf/test/hwpMBvpdAccessorTest.H
index 25b85e815..723c97633 100644
--- a/src/usr/hwpf/test/hwpMBvpdAccessorTest.H
+++ b/src/usr/hwpf/test/hwpMBvpdAccessorTest.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2014                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2015                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -51,9 +51,7 @@
 #include    <targeting/common/utilFilter.H>
 
 #include    <setMvpdRing.H>
-#include    <mvpd_accessors/getMBvpdPhaseRotatorData.H>
 #include    <mvpd_accessors/getMBvpdAddrMirrorData.H>
-#include    <mvpd_accessors/getMBvpdTermData.H>
 #include    <mvpd_accessors/getMBvpdSlopeInterceptData.H>
 #include    <mvpd_accessors/getMBvpdVersion.H>
 #include    <mvpd_accessors/getMBvpdDram2NModeEnabled.H>
@@ -61,6 +59,7 @@
 #include    <mvpd_accessors/getControlCapableData.H>
 #include    <mvpd_accessors/accessMBvpdL4BankDelete.H>
 #include    <mvpd_accessors/getDecompressedISDIMMAttrs.H>
+#include    <mvpd_accessors/getMBvpdAttr.H>
 
 #include <errl/errlmanager.H>
 #include <errl/errlentry.H>
@@ -1121,34 +1120,69 @@ public:
     }
 
     /**
-     * @brief call getMBvpdTermData to fetch memory buffer MT attributes
+     * @brief call getMBvpdAttr to fetch memory buffer MT attributes
      *
      */
     void    testGetTermData()
     {
         fapi::ReturnCode    l_fapirc;
         uint8_t val1[2][2] = {{0xFF,0xFF},{0xFF,0xFF}};
+        uint32_t val3[2] = {0xFFFFFFFF,0xFFFFFFFF};
+        uint32_t val7[2][2] = {{0xFFFFFFFF,0xFFFFFFFF},
+                              {0xFFFFFFFF,0xFFFFFFFF}};
 #if HWPMBVPDACCESSORTEST_UT4
         uint8_t val2[2][2][4]={
                               {{0xFF,0xFF,0xFF,0xFF},{0xFF,0xFF,0xFF,0xFF}},
                               {{0xFF,0xFF,0xFF,0xFF},{0xFF,0xFF,0xFF,0xFF}}};
         uint8_t l_errorChk = 1; //do error checks just once
         uint8_t  val4[2] = {0xFF,0xFF};
-        uint32_t val3[2] = {0xFFFFFFFF,0xFFFFFFFF};
         uint8_t  val5[2] = {0xFF,0xFF};
 #endif
         uint64_t val6    = 0xFFFFFFFFFFFFFFFF;
 
 #if HWPMBVPDACCESSORTEST_UT4
-        getMBvpdTermData_FP_t (l_getMBvpdTermData)
-                              = &getMBvpdTermData;
+        getMBvpdAttr_FP_t (l_getMBvpdAttr)
+                              = &getMBvpdAttr;
 #endif
         TS_TRACE( "testGetTermData entry" );
 
+        // ensure attribute look up table is in proper version order
+        for (uint32_t i=0;
+                      i <= fapi::getAttrData::g_MBVPD_ATTR_DEF_array_size; i++)
+        {
+            fapi::AttributeId l_attrId  =
+                       fapi::getAttrData::g_MBVPD_ATTR_DEF_array[i].iv_attrId;
+            fapi::getAttrData::DimmType l_dimmType =
+                       fapi::getAttrData::g_MBVPD_ATTR_DEF_array[i].iv_dimmType;
+            fapi::getAttrData::VpdVersion l_version =
+                       fapi::getAttrData::g_MBVPD_ATTR_DEF_array[i].iv_version;
+            // from this piont to the end of the table, for this attribute
+            // dimm type pair, the version should be less in value.
+            // Otherwise, an intended match will not be found
+            for (uint32_t j=i;
+                       j <= fapi::getAttrData::g_MBVPD_ATTR_DEF_array_size; j++)
+            {
+                if ( (l_attrId ==
+                    fapi::getAttrData::g_MBVPD_ATTR_DEF_array[j].iv_attrId) &&
+                     (l_dimmType ==
+                    fapi::getAttrData::g_MBVPD_ATTR_DEF_array[j].iv_dimmType) &&
+                     (l_version   <
+                    fapi::getAttrData::g_MBVPD_ATTR_DEF_array[j].iv_version))
+                {
+                    TS_FAIL( "testGetTermData table error: "
+                      " attr 0x%08x dimm %d row %d version 0x%04x <"
+                      " row %d version 0x%04x",
+                      l_attrId,l_dimmType,i,l_version,
+                      j,
+                      fapi::getAttrData::g_MBVPD_ATTR_DEF_array[j].iv_version);
+                }
+            }
+        }
+
         TARGETING::TargetHandleList l_memBufList;
         getAllChips(l_memBufList, TYPE_MEMBUF);
 
-        TS_TRACE( "testGetTermData l_memBufList.size()=%d",
+        TS_TRACE( "testGetTermData l_memBufList.size()=%ld",
                                       l_memBufList.size() );
 
         // loop thru memory buffers
@@ -1163,7 +1197,7 @@ public:
             getChildAffinityTargets(l_mbaList,l_memBufList[l_mbNum],
                             CLASS_UNIT,TYPE_MBA,false);
 
-            TS_TRACE( "testGetTermData l_mbaBufList.size()=%d",
+            TS_TRACE( "testGetTermData l_mbaBufList.size()=%ld",
                     l_mbaList.size());
 
             // loop thru all the mbas (should be 2)
@@ -1188,8 +1222,8 @@ public:
             // check for interface errors being caught. Just once.
             if (l_errorChk) {
                // check size matches type for each of the 4 types
-               l_fapirc = (*l_getMBvpdTermData)(l_fapi_mba_target,
-                           fapi::TERM_DATA_DRAM_RON,
+               l_fapirc = (*l_getMBvpdAttr)(l_fapi_mba_target,
+                           fapi::ATTR_VPD_DRAM_RON,
                            &val1, sizeof(val1)+1); //invalid size
                if (l_fapirc != fapi::RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE)
                {
@@ -1198,8 +1232,8 @@ public:
                          fapi::RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE,
                          static_cast<uint32_t>(l_fapirc));
                }
-               l_fapirc = (*l_getMBvpdTermData)(l_fapi_mba_target,
-                           fapi::TERM_DATA_DRAM_RTT_NOM,
+               l_fapirc = (*l_getMBvpdAttr)(l_fapi_mba_target,
+                           fapi::ATTR_VPD_DRAM_RTT_NOM,
                            &val2, sizeof(val2)-1); //invalid size
                if (l_fapirc != fapi::RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE)
                {
@@ -1208,8 +1242,8 @@ public:
                          fapi::RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE,
                          static_cast<uint32_t>(l_fapirc));
                }
-               l_fapirc = (*l_getMBvpdTermData)(l_fapi_mba_target,
-                           fapi::TERM_DATA_CEN_RD_VREF,
+               l_fapirc = (*l_getMBvpdAttr)(l_fapi_mba_target,
+                           fapi::ATTR_VPD_CEN_RD_VREF,
                            &val3, sizeof(val3)+2); //invalid size
                if (l_fapirc != fapi::RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE)
                {
@@ -1218,8 +1252,8 @@ public:
                          fapi::RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE,
                          static_cast<uint32_t>(l_fapirc));
                }
-               l_fapirc = (*l_getMBvpdTermData)(l_fapi_mba_target,
-                           fapi::TERM_DATA_DRAM_WRDDR4_VREF,
+               l_fapirc = (*l_getMBvpdAttr)(l_fapi_mba_target,
+                           fapi::ATTR_VPD_DRAM_WRDDR4_VREF,
                            &val4, 0); //invalid size
                if (l_fapirc != fapi::RC_MBVPD_INVALID_OUTPUT_VARIABLE_SIZE)
                {
@@ -1229,8 +1263,8 @@ public:
                          static_cast<uint32_t>(l_fapirc));
                }
                // check for catching an invalid ID
-               l_fapirc = (*l_getMBvpdTermData)(l_fapi_mba_target,
-                           (fapi::MBvpdTermData)99, //invalid ID
+               l_fapirc = (*l_getMBvpdAttr)(l_fapi_mba_target,
+                           (fapi::AttributeId)99, //invalid ID
                            &val1, sizeof(val1));
                if (l_fapirc != fapi::RC_MBVPD_INVALID_ATTRIBUTE_ID)
                {
@@ -1311,6 +1345,22 @@ public:
                    val2[1][0][0], val2[1][0][1], val2[1][0][2], val2[1][0][3]);
                TS_TRACE("testGetTermData[1][1]=0x%02x,0x%02x,0x%02x,0x%02x",
                    val2[1][1][0], val2[1][1][1], val2[1][1][2], val2[1][1][3]);
+#endif
+           // ATTR_VPD_DIMM_RCD_OUTPUT_TIMING
+               l_fapirc = FAPI_ATTR_GET(ATTR_VPD_DIMM_RCD_OUTPUT_TIMING,
+                   &l_fapi_mba_target, val1);
+               if (l_fapirc) break;
+               TS_TRACE( "testGetTermData attr "
+              "ATTR_VPD_DIMM_RCD_OUTPUT_TIMING=(0x%02x,0x%02x),(0x%02x,0x%02x)",
+                   val1[0][0], val1[0][1], val1[1][0], val1[1][1]);
+
+           // ATTR_VPD_DIMM_RCD_IBT
+               l_fapirc = FAPI_ATTR_GET(ATTR_VPD_DIMM_RCD_IBT,
+                   &l_fapi_mba_target, val7);
+               if (l_fapirc) break;
+               TS_TRACE( "testGetTermData attr "
+              "ATTR_VPD_DIMM_RCD_IBT=(0x%08x,0x%08x),(0x%08x,0x%08x)",
+                   val7[0][0], val7[0][1], val7[1][0], val7[1][1]);
 
            // TERM_DATA_CEN_RD_VREF
                l_fapirc = FAPI_ATTR_GET(ATTR_VPD_CEN_RD_VREF,
@@ -1320,6 +1370,7 @@ public:
                    "TERM_DATA_CEN_RD_VREF=0x%08x,0x%08x",
                    val3[0], val3[1]);
 
+#if HWPMBVPDACCESSORTEST_UT4
            // TERM_DATA_DRAM_WR_VREF
                l_fapirc = FAPI_ATTR_GET(ATTR_VPD_DRAM_WR_VREF,
                    &l_fapi_mba_target, val3);
@@ -1484,7 +1535,7 @@ public:
 
 
     /**
-     * @brief call getMBvpdPhaseRotData to fetch memory buffer MR attributes
+     * @brief call getMBvpdAttr to fetch memory buffer MR attributes
      *
      */
     void    testGetPhaseRotatorData()
@@ -1498,7 +1549,7 @@ public:
         TARGETING::TargetHandleList l_memBufList;
         getAllChips(l_memBufList, TYPE_MEMBUF);
 
-        TS_TRACE( "testGetPhaseRotatorData l_memBufList.size()=%d",
+        TS_TRACE( "testGetPhaseRotatorData l_memBufList.size()=%ld",
                                       l_memBufList.size() );
 
         // loop thru memory buffers
@@ -1513,7 +1564,7 @@ public:
             getChildAffinityTargets(l_mbaList,l_memBufList[l_mbNum],
                             CLASS_UNIT,TYPE_MBA,false);
 
-            TS_TRACE( "testGetPhaseRotatorData l_mbaBufList.size()=%d",
+            TS_TRACE( "testGetPhaseRotatorData l_mbaBufList.size()=%ld",
                     l_mbaList.size());
 
             // loop thru all the mbas (should be 2)