Memory workaround for 1200 CDIMMS

Change-Id: I8f6ffc2ef653d4245bc002cdca66f59a6e1771fa
RTC: 76932
Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/5901
Reviewed-by: MIKE J. JONES <mjjones@us.ibm.com>
Reviewed-by: Brian H. Horton <brianh@linux.ibm.com>
Tested-by: Jenkins Server
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

11 files changed, 500 insertions, 125 deletions

diff --git a/src/include/usr/hwpf/fapi/fapiMBvpdAccess.H b/src/include/usr/hwpf/fapi/fapiMBvpdAccess.H
index 270b48dff..5082ada2d 100644
--- a/src/include/usr/hwpf/fapi/fapiMBvpdAccess.H
+++ b/src/include/usr/hwpf/fapi/fapiMBvpdAccess.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* IBM CONFIDENTIAL                                                       */
 /*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2012,2013              */
+/* COPYRIGHT International Business Machines Corp. 2013                   */
 /*                                                                        */
 /* p1                                                                     */
 /*                                                                        */
@@ -20,7 +20,7 @@
 /* Origin: 30                                                             */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-// $Id: fapiMBvpdAccess.H,v 1.3 2013/06/11 15:15:16 whs Exp $
+// $Id: fapiMBvpdAccess.H,v 1.5 2013/10/09 20:45:47 mjjones Exp $
 /**
  *  @file fapiMBvpdAccess.H
  *
@@ -69,6 +69,7 @@ namespace fapi
         MBVPD_KEYWORD_MV  = 0x08,
         MBVPD_KEYWORD_AM  = 0x09,
         MBVPD_KEYWORD_VZ  = 0x0a,
+        MBVPD_KEYWORD_PDD  = 0x0b,
     };
 
 }
diff --git a/src/include/usr/vpd/cvpdenums.H b/src/include/usr/vpd/cvpdenums.H
index 52c582976..d768267fb 100644
--- a/src/include/usr/vpd/cvpdenums.H
+++ b/src/include/usr/vpd/cvpdenums.H
@@ -62,6 +62,8 @@ namespace CVPD
         MV           = 0x08,
         AM           = 0x09,
         VZ           = 0x0a,
+        pdD          = 0x0b,
+
         // Last Keyword
         CVPD_LAST_KEYWORD,
         CVPD_TEST_KEYWORD,  // Test purposes ONLY!
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdRing.C b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdRing.C
new file mode 100644
index 000000000..0d2ea52d2
--- /dev/null
+++ b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdRing.C
@@ -0,0 +1,69 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/hwpf/hwp/mvpd_accessors/getMBvpdRing.C $              */
+/*                                                                        */
+/* IBM CONFIDENTIAL                                                       */
+/*                                                                        */
+/* COPYRIGHT International Business Machines Corp. 2013                   */
+/*                                                                        */
+/* p1                                                                     */
+/*                                                                        */
+/* Object Code Only (OCO) source materials                                */
+/* Licensed Internal Code Source Materials                                */
+/* IBM HostBoot Licensed Internal Code                                    */
+/*                                                                        */
+/* The source code for this program is not published or otherwise         */
+/* divested of its trade secrets, irrespective of what has been           */
+/* deposited with the U.S. Copyright Office.                              */
+/*                                                                        */
+/* Origin: 30                                                             */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+// $Id: getMBvpdRing.C,v 1.1 2013/10/09 20:52:37 mjjones Exp $
+/**
+ *  @file getMBvpdRing.C
+ *
+ *  @brief function to fetch repair rings from MBVPD  records
+ *
+ */
+
+#include    <stdint.h>
+#include    <fapi.H> //  fapi support
+#include    <getMBvpdRing.H>
+#include    <mvpdRingFuncs.H>
+
+extern "C"
+{
+using   namespace   fapi;
+
+// getMBvpdRing: Wrapper to call common function mbvpdRingFunc
+fapi::ReturnCode getMBvpdRing(fapi::MBvpdRecord   i_record,
+                              fapi::MBvpdKeyword  i_keyword,
+                              const fapi::Target &i_fapiTarget,
+                              const uint8_t       i_chipletId,
+                              const uint8_t       i_ringId,
+                              uint8_t             *i_pRingBuf,
+                              uint32_t            &io_rRingBufsize)
+{
+    fapi::ReturnCode  l_fapirc;
+
+    FAPI_INF("getMBvpdRing: entry ringId=0x%x, chipletId=0x%x, size=0x%x",
+             i_ringId, i_chipletId, io_rRingBufsize );
+
+    // Pass the parameters into mbvpdRingFunc
+    l_fapirc = mbvpdRingFunc(MBVPD_RING_GET,
+                            i_record,
+                            i_keyword,
+                            i_fapiTarget,
+                            i_chipletId,
+                            i_ringId,
+                            i_pRingBuf,
+                            io_rRingBufsize );
+
+    FAPI_INF("getMBvpdRing: exit rc=0x%x", static_cast<uint32_t>(l_fapirc));
+
+    return  l_fapirc;
+}
+
+}   // extern "C"
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdRing.H b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdRing.H
new file mode 100644
index 000000000..315415b54
--- /dev/null
+++ b/src/usr/hwpf/hwp/mvpd_accessors/getMBvpdRing.H
@@ -0,0 +1,93 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/hwpf/hwp/mvpd_accessors/getMBvpdRing.H $              */
+/*                                                                        */
+/* IBM CONFIDENTIAL                                                       */
+/*                                                                        */
+/* COPYRIGHT International Business Machines Corp. 2013                   */
+/*                                                                        */
+/* p1                                                                     */
+/*                                                                        */
+/* Object Code Only (OCO) source materials                                */
+/* Licensed Internal Code Source Materials                                */
+/* IBM HostBoot Licensed Internal Code                                    */
+/*                                                                        */
+/* The source code for this program is not published or otherwise         */
+/* divested of its trade secrets, irrespective of what has been           */
+/* deposited with the U.S. Copyright Office.                              */
+/*                                                                        */
+/* Origin: 30                                                             */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+// $Id: getMBvpdRing.H,v 1.1 2013/10/09 20:53:03 mjjones Exp $
+/**
+ *  @file getMBvpdRing.H
+ *
+ *  @brief Prototype for getMBvpdRing() -
+ *          get a repair ring from a MBVPD record
+ */
+
+ #ifndef    _HWP_GETMBVPDRING_
+ #define    _HWP_GETMBVPDRING_
+
+ #include   <fapi.H>
+
+// function pointer typedef definition for HWP call support
+typedef fapi::ReturnCode (*getMBvpdRing_FP_t)
+     (fapi::MBvpdRecord,fapi::MBvpdKeyword,const fapi::Target &,
+      const uint8_t, const uint8_t, uint8_t *, uint32_t &);
+
+
+extern "C"
+{
+/**
+ * @brief  get specified ring from MBVPD for the specified memory buffer target.
+ *
+ * A Ring Id Chiplet Id should be unique in the mbvpd record.
+ * The code does not validate. No assumption should be made on which would
+ * be returned if there are multiple.
+ *
+ * @param i_record          -   Record enumerator
+ * @param i_keyword         -   Keyword enumerator
+ * Supported Rings are:
+ *                   MBVPD_RECORD_VSPD - MBVPD_KEYWORD_PDD
+ * @param i_fapiTarget      -   memory buffer target
+ * @param i_chipletId       -   Chiplet ID
+ * @param i_ringId          -   Ring ID
+ * @param i_pRingBuf        -   pointer to a buffer allocated by the caller
+ *                              to receive the ring header and data.
+ *                              if NULL, the size of the min buffer required
+ *                              buffer will be returned in io_rRingBufsize
+ *                              with rc FAPI_RC_SUCCESS.
+ * @param io_rRingBufsize   -   in:     size of ring buffer that caller has
+ *                                      allocated
+ *                              out:    number of BYTES that were copied to the
+ *                                      output buffer.
+ *                                      If the ring was not found, an error
+ *                                      will be returned and this will be 0.
+ *                                      If the output buffer is not big enough,
+ *                                      an error will be returned and this will
+ *                                      be the minimum size required.
+ *                              The buffer contains the CompressedScanData
+ *                              structure followed by compressed data. The
+ *                              caller does compression and decompression.
+ *  Buffer:   io_rRingBufsize returns xNN.
+ *    byte x0  CompressedScanData structure (rs4 header)
+ *    byte x18 compressed data (sizeof CompressedScanData is 0x18)
+ *    byte xNN last byte of compressed data
+ *
+ * @return fapi::ReturnCode -   FAPI_RC_SUCCESS if success,
+ *                              relevant error code for failure.
+ */
+fapi::ReturnCode getMBvpdRing(  fapi::MBvpdRecord   i_record,
+                                fapi::MBvpdKeyword  i_keyword,
+                                const fapi::Target  &i_fapiTarget,
+                                const uint8_t       i_chipletId,
+                                const uint8_t       i_ringId,
+                                uint8_t             *io_pRingBuf,
+                                uint32_t            &io_rRingBufsize );
+
+}
+
+#endif
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/mvpd.mk b/src/usr/hwpf/hwp/mvpd_accessors/mvpd.mk
index 0f598f554..592431034 100644
--- a/src/usr/hwpf/hwp/mvpd_accessors/mvpd.mk
+++ b/src/usr/hwpf/hwp/mvpd_accessors/mvpd.mk
@@ -26,6 +26,7 @@ EXTRAINCDIR += ${ROOTPATH}/src/include/usr/hwpf/hwp/mvpd_accessors
 VPATH += mvpd_accessors
 
 OBJS += getMvpdRing.o \
+        getMBvpdRing.o \
         setMvpdRing.o \
         mvpdRingFuncs.o \
         getMvpdExL2SingleMemberEnable.o \
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.C b/src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.C
index 970d2612b..1464526c8 100644
--- a/src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.C
+++ b/src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.C
@@ -1,7 +1,7 @@
 /* IBM_PROLOG_BEGIN_TAG                                                   */
 /* This is an automatically generated prolog.                             */
 /*                                                                        */
-/* $Source: /afs/awd/projects/eclipz/KnowledgeBase/.cvsroot/eclipz/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.C,v $             */
+/* $Source: src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.C $             */
 /*                                                                        */
 /* IBM CONFIDENTIAL                                                       */
 /*                                                                        */
@@ -20,7 +20,7 @@
 /* Origin: 30                                                             */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-// $Id: mvpdRingFuncs.C,v 1.5 2013/09/26 17:28:18 bwieman Exp $ 
+// $Id: mvpdRingFuncs.C,v 1.6 2013/10/09 20:54:11 mjjones Exp $
 /**
  *  @file mvpdRingFuncs.C
  *
@@ -43,32 +43,33 @@ extern "C"
 using   namespace   fapi;
 
 // functions internal to this file
-fapi::ReturnCode mvpdValidateRingHeader( CompressedScanData * i_pRing,
-                                         uint8_t              i_chipletId,
-                                         uint8_t              i_ringId,
-                                         uint32_t             i_ringBufsize);
-
-fapi::ReturnCode mvpdRingFuncFind( const uint8_t    i_chipletId,
-                                const uint8_t       i_ringId,
-                                uint8_t           * i_pRecordBuf,
-                                uint32_t            i_recordBufLen,
-                                uint8_t           * &o_rRingBuf,
-                                uint32_t            &o_rRingBufsize);
-
-fapi::ReturnCode mvpdRingFuncGet ( uint8_t     *i_pRing,
-                                   uint32_t     i_ringLen,
-                                   uint8_t     *i_pCallerRingBuf,
-                                   uint32_t    &io_rCallerRingBufLen);
-
-fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
-                                   uint32_t     i_recordLen,
-                                   uint8_t     *i_pRing,
-                                   uint32_t     i_ringLen,
-                                   uint8_t     *i_pCallerRingBuf,
-                                   uint32_t     i_callerRingBufLen);
+// these functions are common for both mvpdRingFunc and mbvpdRingFunc
+fapi::ReturnCode validateRingHeader( CompressedScanData * i_pRing,
+                                     uint8_t              i_chipletId,
+                                     uint8_t              i_ringId,
+                                     uint32_t             i_ringBufsize);
+
+fapi::ReturnCode ringFuncFind( const uint8_t    i_chipletId,
+                               const uint8_t       i_ringId,
+                               uint8_t           * i_pRecordBuf,
+                               uint32_t            i_recordBufLen,
+                               uint8_t           * &o_rRingBuf,
+                               uint32_t            &o_rRingBufsize);
+
+fapi::ReturnCode ringFuncGet ( uint8_t     *i_pRing,
+                               uint32_t     i_ringLen,
+                               uint8_t     *i_pCallerRingBuf,
+                               uint32_t    &io_rCallerRingBufLen);
+
+fapi::ReturnCode ringFuncSet ( uint8_t     *i_pRecordBuf,
+                               uint32_t     i_recordLen,
+                               uint8_t     *i_pRing,
+                               uint32_t     i_ringLen,
+                               uint8_t     *i_pCallerRingBuf,
+                               uint32_t     i_callerRingBufLen);
 
 //******************************************************************************
-// mvpdValidateRecordKeyword
+// mvpdValidateRecordKeyword & mbvpdValidateRecordKeyword
 // Check for supported combinations of Record and Keyword.
 // The record needs to contain rings of RS4 header (CompressedScanData) format
 //  note: "getting" data not in RS4 header format would likely just fail to find
@@ -89,13 +90,13 @@ fapi::ReturnCode mvpdValidateRecordKeyword( fapi::MvpdRecord i_record,
     };
     fapi::ReturnCode        l_fapirc;
     bool l_validPair = false;
-    const uint32_t numPairs = 
+    const uint32_t numPairs =
              sizeof(supportedRecordKeywords)/sizeof(supportedRecordKeywords[0]);
 
     for (uint32_t curPair = 0; curPair < numPairs; curPair++ )
     {
         if (supportedRecordKeywords[curPair].record == i_record &&
-            supportedRecordKeywords[curPair].keyword == i_keyword) 
+            supportedRecordKeywords[curPair].keyword == i_keyword)
         {
             l_validPair = true;
             break;
@@ -108,10 +109,44 @@ fapi::ReturnCode mvpdValidateRecordKeyword( fapi::MvpdRecord i_record,
 
 };
 
+fapi::ReturnCode mbvpdValidateRecordKeyword(fapi::MBvpdRecord i_record,
+                                            fapi::MBvpdKeyword i_keyword)
+{
+    // add record/keywords with rings with RS4 header here.
+    struct _supportedRecordKeywords {
+                                fapi::MBvpdRecord record;
+                                fapi::MBvpdKeyword keyword;
+    } supportedRecordKeywords [] = {
+        { MBVPD_RECORD_VSPD, MBVPD_KEYWORD_PDD },
+    };
+
+    fapi::ReturnCode l_fapirc;
+    bool l_validPair = false;
+
+    const uint32_t numPairs =
+             sizeof(supportedRecordKeywords)/sizeof(supportedRecordKeywords[0]);
+
+    for (uint32_t curPair = 0; curPair < numPairs; curPair++ )
+    {
+        if (supportedRecordKeywords[curPair].record == i_record &&
+            supportedRecordKeywords[curPair].keyword == i_keyword)
+        {
+            l_validPair = true;
+            break;
+        }
+    }
+    if (!l_validPair)
+    {
+        FAPI_SET_HWP_ERROR(l_fapirc, RC_MBVPD_RING_FUNC_INVALID_PARAMETER );
+    }
+    return l_fapirc;
+
+};
+
 //******************************************************************************
 // mvpdRingFunc: the getMvpdRing and setMvpdRing wrappers call this function
 //               to do all the processing.
-// note: io_rRingBufsize is only 'output' for get. 
+// note: io_rRingBufsize is only 'output' for get.
 //******************************************************************************
 fapi::ReturnCode mvpdRingFunc(  const mvpdRingFuncOp i_mvpdRingFuncOp,
                                 fapi::MvpdRecord i_record,
@@ -160,7 +195,7 @@ fapi::ReturnCode mvpdRingFunc(  const mvpdRingFuncOp i_mvpdRingFuncOp,
             }
 
             // Validate ring header to protect vpd
-            l_fapirc =  mvpdValidateRingHeader(
+            l_fapirc =  validateRingHeader(
                          reinterpret_cast<CompressedScanData *>(i_pRingBuf),
                          i_chipletId,
                          i_ringId,
@@ -212,7 +247,7 @@ fapi::ReturnCode mvpdRingFunc(  const mvpdRingFuncOp i_mvpdRingFuncOp,
         // find ring in the record. It is an error if not there for a "get".
         // Its ok if not there for a "set". The ring will be added.
         // l_ringLen set to 0 if not there with l_pRing at the start of padding.
-        l_fapirc = mvpdRingFuncFind (i_chipletId,
+        l_fapirc = ringFuncFind (i_chipletId,
                                      i_ringId,
                                      l_recordBuf,
                                      l_recordLen,
@@ -220,7 +255,7 @@ fapi::ReturnCode mvpdRingFunc(  const mvpdRingFuncOp i_mvpdRingFuncOp,
                                      l_ringLen);
         if ( l_fapirc )
         {
-            FAPI_ERR("mvpdRingFunc: mvpdRingFuncFind failed rc=0x%x",
+            FAPI_ERR("mvpdRingFunc: ringFuncFind failed rc=0x%x",
                      static_cast<uint32_t>(l_fapirc));
             //  break out with fapirc
             break;
@@ -239,13 +274,13 @@ fapi::ReturnCode mvpdRingFunc(  const mvpdRingFuncOp i_mvpdRingFuncOp,
             }
 
             // copy ring back to caller's buffer
-            l_fapirc = mvpdRingFuncGet ( l_pRing,
+            l_fapirc = ringFuncGet ( l_pRing,
                                          l_ringLen,
                                          i_pRingBuf,
                                          io_rRingBufsize);
             if ( l_fapirc )
             {
-                FAPI_ERR("mvpdRingFunc: mvpdRingFuncGet failed rc=0x%x",
+                FAPI_ERR("mvpdRingFunc: ringFuncGet failed rc=0x%x",
                      static_cast<uint32_t>(l_fapirc));
                 //  break out with fapirc
                 break;
@@ -254,7 +289,7 @@ fapi::ReturnCode mvpdRingFunc(  const mvpdRingFuncOp i_mvpdRingFuncOp,
         } else {     // set operation
 
             // update record with caller's ring
-            l_fapirc = mvpdRingFuncSet ( l_recordBuf,
+            l_fapirc = ringFuncSet ( l_recordBuf,
                                          l_recordLen,
                                          l_pRing,
                                          l_ringLen,
@@ -262,7 +297,7 @@ fapi::ReturnCode mvpdRingFunc(  const mvpdRingFuncOp i_mvpdRingFuncOp,
                                          io_rRingBufsize);
             if ( l_fapirc )
             {
-                FAPI_ERR("mvpdRingFunc: mvpdRingFuncSet failed rc=0x%x",
+                FAPI_ERR("mvpdRingFunc: ringFuncSet failed rc=0x%x",
                      static_cast<uint32_t>(l_fapirc));
                 //  break out with fapirc
                 break;
@@ -296,16 +331,145 @@ fapi::ReturnCode mvpdRingFunc(  const mvpdRingFuncOp i_mvpdRingFuncOp,
     return  l_fapirc;
 }
 
+//******************************************************************************
+// mbvpdRingFunc: getMBvpdRing calls this function to get repair ring
+// note: io_rRingBufsize is only 'output' for get.
+//******************************************************************************
+fapi::ReturnCode mbvpdRingFunc( const mbvpdRingFuncOp i_mbvpdRingFuncOp,
+                                fapi::MBvpdRecord i_record,
+                                fapi::MBvpdKeyword i_keyword,
+                                const fapi::Target &i_fapiTarget,
+                                const uint8_t i_chipletId,
+                                const uint8_t i_ringId,
+                                uint8_t *i_pRingBuf,
+                                uint32_t &io_rRingBufsize)
+{
+    fapi::ReturnCode l_fapirc;
+    uint32_t l_recordLen = 0;
+    uint8_t *l_recordBuf = NULL;
+    uint8_t *l_pRing = NULL;
+    uint32_t l_ringLen = 0;
+
+   FAPI_DBG("mbvpdRingFunc:entry op=0x%x ringId=0x%x chipletId=0x%x size=0x%x ",
+             i_mbvpdRingFuncOp, i_ringId, i_chipletId, io_rRingBufsize  );
+
+    do {
+        // do input parameter error checks
+        // check for supported combination of Record and Keyword
+        l_fapirc = mbvpdValidateRecordKeyword( i_record, i_keyword);
+
+        if (l_fapirc)
+        {
+             FAPI_ERR(" mbvpdRingFunc: unsupported record keyword pair ");
+            //  break out with fapirc
+            break;
+        }
+
+        //  call fapiGetMBvpdField once with a NULL pointer to get the buffer
+        //  size no error should be returned.
+        l_fapirc = fapiGetMBvpdField( i_record,
+                                      i_keyword,
+                                      i_fapiTarget,
+                                      NULL,
+                                      l_recordLen );
+        if (l_fapirc)
+        {
+            FAPI_ERR("mbvpdRingFunc:fapiGetMBvpdField failed to get buffer size");
+            //  break out with fapirc
+            break;
+        }
+
+        FAPI_DBG("mbvpdRingFunc: fapiGetMBvpdField returned record len=0x%x",
+                  l_recordLen );
+
+        //  allocate buffer for the record. Always works
+        l_recordBuf = new uint8_t[l_recordLen];
+
+        //  load ring from MBVPD for this target
+        l_fapirc = fapiGetMBvpdField( i_record,
+                                      i_keyword,
+                                      i_fapiTarget,
+                                      l_recordBuf,
+                                      l_recordLen );
+        if (l_fapirc)
+        {
+            FAPI_ERR("mbvpdRingFunc: fapiGetMBvpdField failed rc=0x%x",
+                     static_cast<uint32_t>(l_fapirc));
+            //  break out with fapirc
+            break;
+        }
+
+        // find ring in the record. It is an error if not there for a "get".
+        l_fapirc = ringFuncFind ( i_chipletId,
+                                  i_ringId,
+                                  l_recordBuf,
+                                  l_recordLen,
+                                  l_pRing,
+                                  l_ringLen);
+        if (l_fapirc)
+        {
+            FAPI_ERR("mbvpdRingFunc: ringFuncFind failed rc=0x%x",
+                     static_cast<uint32_t>(l_fapirc));
+            //  break out with fapirc
+            break;
+        }
+        // do the get operations
+        if (i_mbvpdRingFuncOp == MBVPD_RING_GET) // do the get operation
+        {
+            // ensure ring was found. Must be there for "get"
+            if (l_ringLen == 0)  //not found
+            {
+                const uint8_t & RING_MODIFIER = i_ringId;
+                const uint8_t & CHIPLET_ID = i_chipletId;
+                FAPI_SET_HWP_ERROR(l_fapirc, RC_REPAIR_RING_NOT_FOUND );
+                //  break out with fapirc
+                break;
+            }
+
+            // copy ring back to caller's buffer
+            l_fapirc = ringFuncGet ( l_pRing,
+                                     l_ringLen,
+                                     i_pRingBuf,
+                                     io_rRingBufsize);
+            if (l_fapirc)
+            {
+                FAPI_ERR("mbvpdRingFunc: ringFuncGet failed rc=0x%x",
+                     static_cast<uint32_t>(l_fapirc));
+                //  break out with fapirc
+                break;
+            }
+        }
+        else
+        {
+            // Set operation has been removed, if need to be implemented
+            //copy over from mvpdRingFuncs
+            FAPI_ERR("mbvpdRingFunc: Invalid parameter function");
+            assert(0);
+        }
+
+    } while ( 0 );
+
+    //  unload the repair ring
+    delete[]  l_recordBuf;
+    l_recordBuf =   NULL;
+
+    FAPI_DBG( "mbvpdRingFunc: exit bufsize= 0x%x rc= 0x%x",
+                          io_rRingBufsize,
+                          static_cast<uint32_t>(l_fapirc) );
+    return  l_fapirc;
+}
+
+
 
 //******************************************************************************
-// mvpdRingFuncFind: step through the record looking at rings for a match.
+// ringFuncFind: step through the record looking at rings for a match.
 // o_rpRing returns a pointer to the ring if it is there in the record
 //          if not there, returns a pointer to the start of the padding after
 //          the last ring.
 // o_rRingLen returns the number of bytes in the ring (header and data)
 //          Will be 0 if ring not found.
 //******************************************************************************
-fapi::ReturnCode mvpdRingFuncFind( const uint8_t    i_chipletId,
+fapi::ReturnCode ringFuncFind( const uint8_t    i_chipletId,
                                 const uint8_t       i_ringId,
                                 uint8_t           * i_pRecordBuf,
                                 uint32_t            i_recordBufLen,
@@ -322,7 +486,7 @@ fapi::ReturnCode mvpdRingFuncFind( const uint8_t    i_chipletId,
     o_rpRing=NULL;
     o_rRingLen=0;
 
-    FAPI_DBG("mvpdRingFuncFind: entry chipletId=0x%x, ringId=0x%x ",
+    FAPI_DBG("ringFuncFind: entry chipletId=0x%x, ringId=0x%x ",
              i_chipletId,
              i_ringId  );
 
@@ -336,7 +500,7 @@ fapi::ReturnCode mvpdRingFuncFind( const uint8_t    i_chipletId,
         //  First byte in record should be the version number, skip
         //      over this.
         //
-        FAPI_DBG( "mvpdRingFuncFind: record version = 0x%x", *l_pRing );
+        FAPI_DBG( "ringFuncFind: record version = 0x%x", *l_pRing );
         l_pRing++;
         l_offset    =   0;
 
@@ -351,20 +515,20 @@ fapi::ReturnCode mvpdRingFuncFind( const uint8_t    i_chipletId,
             //  Check magic key to make sure this is a valid record.
             if ( FAPI_BE32TOH(l_pScanData->iv_magic) != RS4_MAGIC )
             {
-                FAPI_DBG("mvpdRingFuncFind:Header 0x%x offset 0x%x,end of list",
+                FAPI_DBG("ringFuncFind:Header 0x%x offset 0x%x,end of list",
                             FAPI_BE32TOH(l_pScanData->iv_magic),
                             l_offset  );
                 //  TODO: RTC 51917 how to tell the end of the list? Assume that
                 // finding a header without RS4_MAGIC is the end.
-                // keep the following incase there is a different way to find 
-                // the end. 
+                // keep the following incase there is a different way to find
+                // the end.
                 // $$const   uint32_t    &MAGIC = l_pScanData->magic;
                 // $$FAPI_SET_HWP_ERROR(l_fapirc,RC_REPAIR_RING_INVALID_MAGIC );
                 // break out of scan loop, ring not found
                 break;
             }
             //  dump record info for debug
-            FAPI_DBG("mvpdRingFuncFind:%d ringId=0x%x chipletId=0x%x ringlen=0x%x size=0x%x",
+            FAPI_DBG("ringFuncFind:%d ringId=0x%x chipletId=0x%x ringlen=0x%x size=0x%x",
                         l_offset,
                         l_pScanData->iv_ringId,
                         l_pScanData->iv_chipletId,
@@ -375,12 +539,12 @@ fapi::ReturnCode mvpdRingFuncFind( const uint8_t    i_chipletId,
             if (    (l_pScanData->iv_ringId == i_ringId)
                  && (l_pScanData->iv_chipletId == i_chipletId) )
             {
-                FAPI_DBG( "mvpdRingFuncFind: Found it: ring=0x%x, chiplet=0x%x, ringlen=0x%x",
+                FAPI_DBG( "ringFuncFind: Found it: ring=0x%x, chiplet=0x%x, ringlen=0x%x",
                           i_ringId,
                           i_chipletId,
                           FAPI_BE32TOH(l_pScanData->iv_length) );
 
-                if (l_offset+FAPI_BE32TOH(l_pScanData->iv_size)>i_recordBufLen) 
+                if (l_offset+FAPI_BE32TOH(l_pScanData->iv_size)>i_recordBufLen)
                 {
                     // shouldn't happen, but does not all fit
                     FAPI_SET_HWP_ERROR(l_fapirc, RC_REPAIR_RING_INVALID_SIZE );
@@ -415,7 +579,8 @@ fapi::ReturnCode mvpdRingFuncFind( const uint8_t    i_chipletId,
     }  while ( 0 );
 
 
-    FAPI_DBG("mvpdRingFuncFind: exit *ring= 0x%p size=0x%x RC=0x%x",
+
+    FAPI_DBG("ringFuncFind: exit *ring= 0x%p size=0x%x RC=0x%x",
                           o_rpRing,
                           o_rRingLen,
                           static_cast<uint32_t>(l_fapirc) );
@@ -424,12 +589,12 @@ fapi::ReturnCode mvpdRingFuncFind( const uint8_t    i_chipletId,
 }
 
 //******************************************************************************
-// mvpdValidateRingHeader
+// validateRingHeader
 //******************************************************************************
-fapi::ReturnCode mvpdValidateRingHeader( CompressedScanData * i_pRingBuf,
-                                         uint8_t              i_chipletId,
-                                         uint8_t              i_ringId,
-                                         uint32_t             i_ringBufsize)
+fapi::ReturnCode validateRingHeader( CompressedScanData * i_pRingBuf,
+                                     uint8_t              i_chipletId,
+                                     uint8_t              i_ringId,
+                                     uint32_t             i_ringBufsize)
 {
     fapi::ReturnCode        l_fapirc;
 
@@ -445,16 +610,16 @@ fapi::ReturnCode mvpdValidateRingHeader( CompressedScanData * i_pRingBuf,
 }
 
 //******************************************************************************
-// mvpdRingFuncGet: copy the ring back to the caller
+// ringFuncGet: copy the ring back to the caller
 //******************************************************************************
-fapi::ReturnCode mvpdRingFuncGet ( uint8_t     *i_pRing,
-                                   uint32_t     i_ringLen,
-                                   uint8_t     *i_pCallerRingBuf,
-                                   uint32_t    &io_rCallerRingBufLen)
+fapi::ReturnCode ringFuncGet ( uint8_t     *i_pRing,
+                               uint32_t     i_ringLen,
+                               uint8_t     *i_pCallerRingBuf,
+                               uint32_t    &io_rCallerRingBufLen)
 {
     fapi::ReturnCode        l_fapirc;
 
-    do { 
+    do {
         //  return buffer pointer is NULL if just looking for the size
         if  (   i_pCallerRingBuf == NULL )
         {
@@ -465,7 +630,7 @@ fapi::ReturnCode mvpdRingFuncGet ( uint8_t     *i_pRing,
         //  check if we have enough space
         if ( io_rCallerRingBufLen < i_ringLen )
         {
-            FAPI_ERR( "mpvdRingFuncGet: output buffer too small:  0x%x < 0x%x",
+            FAPI_ERR( "ringFuncGet: output buffer too small:  0x%x < 0x%x",
                           io_rCallerRingBufLen,
                           i_ringLen
                           );
@@ -479,7 +644,7 @@ fapi::ReturnCode mvpdRingFuncGet ( uint8_t     *i_pRing,
             break;
         }
        //  we're good, copy data into the passed-in buffer
-       FAPI_DBG( "mvpdRingFuncGet: memcpy 0x%p 0x%p 0x%x",
+       FAPI_DBG( "ringFuncGet: memcpy 0x%p 0x%p 0x%x",
                     i_pCallerRingBuf,
                     i_pRing,
                     i_ringLen );
@@ -488,7 +653,7 @@ fapi::ReturnCode mvpdRingFuncGet ( uint8_t     *i_pRing,
 
    }  while (0);
 
-   FAPI_DBG( "mvpdRingFuncGet: exit bufsize= 0x%x rc= 0x%x",
+   FAPI_DBG( "ringFuncGet: exit bufsize= 0x%x rc= 0x%x",
                           io_rCallerRingBufLen,
                           static_cast<uint32_t>(l_fapirc) );
 
@@ -496,14 +661,14 @@ fapi::ReturnCode mvpdRingFuncGet ( uint8_t     *i_pRing,
 }
 
 //******************************************************************************
-// mvpdRingFuncSet: update the record with the caller's ring.
+// ringFuncSet: update the record with the caller's ring.
 //******************************************************************************
-fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
-                                   uint32_t     i_recordLen,
-                                   uint8_t     *i_pRing,
-                                   uint32_t     i_ringLen,
-                                   uint8_t     *i_pCallerRingBuf,
-                                   uint32_t     i_callerRingBufLen)
+fapi::ReturnCode ringFuncSet ( uint8_t     *i_pRecordBuf,
+                               uint32_t     i_recordLen,
+                               uint8_t     *i_pRing,
+                               uint32_t     i_ringLen,
+                               uint8_t     *i_pCallerRingBuf,
+                               uint32_t     i_callerRingBufLen)
 {
     fapi::ReturnCode l_fapirc;
     uint8_t          *l_to = NULL;
@@ -511,12 +676,12 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
     uint32_t         l_len = 0;
     uint8_t          *l_pRingEnd; // pointer into record to start of pad at end
 
-    FAPI_DBG( "mvpdRingFuncSet: pRing=0x%p Len=0x%x pCaller=0x%p Len=0x%x",
+    FAPI_DBG( "ringFuncSet: pRing=0x%p Len=0x%x pCaller=0x%p Len=0x%x",
                        i_pRing,
                        i_ringLen,
                        i_pCallerRingBuf,
                        i_callerRingBufLen);
-   
+
     do {
         // if exact fit, update in place
         if (i_callerRingBufLen == i_ringLen)
@@ -524,7 +689,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
             l_to = i_pRing;
             l_fr = i_pCallerRingBuf;
             l_len = i_callerRingBufLen;
-            FAPI_DBG( "mvpdRingFuncSet: update in place-memcpy 0x%p 0x%p 0x%x",
+            FAPI_DBG( "ringFuncSet: update in place-memcpy 0x%p 0x%p 0x%x",
                        l_to,
                        l_fr,
                        l_len);
@@ -535,7 +700,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
         }
 
         // will need the end for shifting... look for something invalid
-        l_fapirc = mvpdRingFuncFind (0x00,
+        l_fapirc = ringFuncFind (0x00,
                                      0x00,
                                      i_pRecordBuf,
                                      i_recordLen,
@@ -543,21 +708,21 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
                                      l_len);
         if ( l_fapirc )
         {
-            FAPI_ERR("mvpdRingFuncSet: mvpdRingFuncFind failed rc=0x%x",
+            FAPI_ERR("ringFuncSet: ringFuncFind failed rc=0x%x",
                      static_cast<uint32_t>(l_fapirc));
             //  break out with fapirc
             break;
         }
-        FAPI_DBG( "mvpdRingFuncSet: end= 0x%p",
+        FAPI_DBG( "ringFuncSet: end= 0x%p",
                                  l_pRingEnd);
 
         // if not there, then append if it fits
         if (i_ringLen == 0 ) //is not currently in record (0 len from find)
         {
-            if (l_pRingEnd+i_callerRingBufLen > i_pRecordBuf+i_recordLen) 
+            if (l_pRingEnd+i_callerRingBufLen > i_pRecordBuf+i_recordLen)
             {
-	        FAPI_ERR( "mvpdRingFuncSet: not enough room to append ");
-                FAPI_SET_HWP_ERROR(l_fapirc, 
+          FAPI_ERR( "ringFuncSet: not enough room to append ");
+                FAPI_SET_HWP_ERROR(l_fapirc,
                                  RC_MVPD_RING_FUNC_INSUFFICIENT_RECORD_SPACE );
                 //  break out of do block with fapi rc set
                 break;
@@ -565,7 +730,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
             l_to = i_pRing;
             l_fr = i_pCallerRingBuf;
             l_len = i_callerRingBufLen;
-            FAPI_DBG( "mvpdRingFuncSet: append-memcpy 0x%p 0x%p 0x%x",
+            FAPI_DBG( "ringFuncSet: append-memcpy 0x%p 0x%p 0x%x",
                        l_to,
                        l_fr,
                        l_len);
@@ -581,7 +746,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
             l_to = i_pRing;
             l_fr = i_pCallerRingBuf;
             l_len = i_callerRingBufLen;
-            FAPI_DBG( "mvpdRingFuncSet: shrink-memcpy 0x%p 0x%p 0x%x",
+            FAPI_DBG( "ringFuncSet: shrink-memcpy 0x%p 0x%p 0x%x",
                        l_to,
                        l_fr,
                        l_len);
@@ -590,7 +755,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
             l_to = i_pRing+i_callerRingBufLen;
             l_fr = i_pRing+i_ringLen;
             l_len = (l_pRingEnd)-(i_pRing+i_ringLen);
-            FAPI_DBG( "mvpdRingFuncSet: shrink-memmove 0x%p 0x%p 0x%x",
+            FAPI_DBG( "ringFuncSet: shrink-memmove 0x%p 0x%p 0x%x",
                        l_to,
                        l_fr,
                        l_len);
@@ -598,7 +763,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
 
             l_to = (l_pRingEnd)-(i_ringLen-i_callerRingBufLen);
             l_len = i_ringLen-i_callerRingBufLen;
-            FAPI_DBG( "mvpdRingFuncSet: shrink-memset 0x%p 0x%x 0x%x",
+            FAPI_DBG( "ringFuncSet: shrink-memset 0x%p 0x%x 0x%x",
                        l_to,
                        0x00,
                        l_len);
@@ -606,7 +771,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
 
             // break out successful
             break;
-            
+
         }
 
         // if larger, then shift right, if it fits
@@ -614,9 +779,9 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
         {
             // ensure the padding can contain the growth
             if ((l_pRingEnd + (i_callerRingBufLen - i_ringLen))  >
-                (i_pRecordBuf + i_recordLen)) 
+                (i_pRecordBuf + i_recordLen))
             {
-                FAPI_ERR( "mvpdRingFuncSet: not enough room to insert ");
+                FAPI_ERR( "ringFuncSet: not enough room to insert ");
                 FAPI_SET_HWP_ERROR(l_fapirc,
                                  RC_MVPD_RING_FUNC_INSUFFICIENT_RECORD_SPACE );
                 //  break out of do block with fapi rc set
@@ -626,7 +791,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
             l_to = i_pRing+i_callerRingBufLen;
             l_fr = i_pRing+i_ringLen;
             l_len = l_pRingEnd-(i_pRing+i_ringLen);
-            FAPI_DBG( "mvpdRingFuncSet: insert-memmove 0x%p 0x%p 0x%x",
+            FAPI_DBG( "ringFuncSet: insert-memmove 0x%p 0x%p 0x%x",
                        l_to,
                        l_fr,
                        l_len);
@@ -635,7 +800,7 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
             l_to = i_pRing;
             l_fr = i_pCallerRingBuf;
             l_len = i_callerRingBufLen;
-            FAPI_DBG( "mvpdRingFuncSet: insert-memcpy 0x%p 0x%p 0x%x",
+            FAPI_DBG( "ringFuncSet: insert-memcpy 0x%p 0x%p 0x%x",
                        l_to,
                        l_fr,
                        l_len);
@@ -644,11 +809,11 @@ fapi::ReturnCode mvpdRingFuncSet ( uint8_t     *i_pRecordBuf,
             // break out successful
             break;
         }
-        FAPI_ERR( "mvpdRingFuncSet: shouldn't get to here" );
+        FAPI_ERR( "ringFuncSet: shouldn't get to here" );
 
     } while (0);
 
-    FAPI_DBG( "mvpdRingFuncSet: exit  rc= 0x%x",
+    FAPI_DBG( "ringFuncSet: exit  rc= 0x%x",
                           static_cast<uint32_t>(l_fapirc) );
 
    return l_fapirc;
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.H b/src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.H
index d4f1e3c4e..877496529 100644
--- a/src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.H
+++ b/src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.H
@@ -1,30 +1,30 @@
- /*  IBM_PROLOG_BEGIN_TAG
- *  This is an automatically generated prolog.
- *
- *  $Source: src/include/usr/hwpf/hwp/mvpdRingFuncs.H $
- *
- *  IBM CONFIDENTIAL
- *
- *  COPYRIGHT International Business Machines Corp. 2012
- *
- *  p1
- *
- *  Object Code Only (OCO) source materials
- *  Licensed Internal Code Source Materials
- *  IBM HostBoot Licensed Internal Code
- *
- *  The source code for this program is not published or other-
- *  wise divested of its trade secrets, irrespective of what has
- *  been deposited with the U.S. Copyright Office.
- *
- *  Origin: 30
- *
- *  IBM_PROLOG_END_TAG
- */
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/hwpf/hwp/mvpd_accessors/mvpdRingFuncs.H $             */
+/*                                                                        */
+/* IBM CONFIDENTIAL                                                       */
+/*                                                                        */
+/* COPYRIGHT International Business Machines Corp. 2012,2013              */
+/*                                                                        */
+/* p1                                                                     */
+/*                                                                        */
+/* Object Code Only (OCO) source materials                                */
+/* Licensed Internal Code Source Materials                                */
+/* IBM HostBoot Licensed Internal Code                                    */
+/*                                                                        */
+/* The source code for this program is not published or otherwise         */
+/* divested of its trade secrets, irrespective of what has been           */
+/* deposited with the U.S. Copyright Office.                              */
+/*                                                                        */
+/* Origin: 30                                                             */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+// $Id: mvpdRingFuncs.H,v 1.3 2013/10/09 20:54:13 mjjones Exp $
 /**
  *  @file mvpdRingFuncs.H
  *
- *  @brief Prototype for mvpdRingFuncs() 
+ *  @brief Prototype for mvpdRingFuncs()
  */
 
  #ifndef    _HWP_MVPDRINGFUNCS_
@@ -34,11 +34,17 @@
 
 // mvpdRingFunc can be used for get and set
 enum mvpdRingFuncOp
-{ 
+{
     MVPD_RING_GET,
     MVPD_RING_SET,
 };
 
+// Only get operation for mbvpd Rings
+enum mbvpdRingFuncOp
+{
+    MBVPD_RING_GET,
+};
+
 extern "C"
 {
 
@@ -46,22 +52,22 @@ extern "C"
  * @brief   get or set the requested ring for the record and keyword
  *          for the specified target CPU.
  *
- *          detailed comments on get and set are in the 
+ *          detailed comments on get and set are in the
  *          getMvpdRing.H and setMvpdRing.H and apply here as well.
  *
  * @param i_mvpdRingFuncOp  -   indicate get or set via enum mvpdRingFuncOp
- * @param i_record          -   Record enumerator 
- * @param i_keyword         -   Keyword enumerator 
+ * @param i_record          -   Record enumerator
+ * @param i_keyword         -   Keyword enumerator
  * @param i_fapiTarget      -   cpu target
- * @param i_chipletId       -   Chiplet ID 
- * @param i_ringId          -   Ring ID 
+ * @param i_chipletId       -   Chiplet ID
+ * @param i_ringId          -   Ring ID
  * @param i_pRingBuf        -   The buffer to receive or send the ring
  * @param io_rRingBufsize   -   Size of ring / ring buffer
  *
  * @return fapi::ReturnCode -   FAPI_RC_SUCCESS if success,
  *                              relevant error code for failure.
  */
-fapi::ReturnCode mvpdRingFunc(  mvpdRingFuncOp       i_mvpdRingFuncOp, 
+fapi::ReturnCode mvpdRingFunc(  mvpdRingFuncOp       i_mvpdRingFuncOp,
                                 fapi::MvpdRecord     i_record,
                                 fapi::MvpdKeyword    i_keyword,
                                 const fapi::Target   &i_fapiTarget,
@@ -70,7 +76,35 @@ fapi::ReturnCode mvpdRingFunc(  mvpdRingFuncOp       i_mvpdRingFuncOp,
                                 uint8_t              *i_pRingBuf,
                                 uint32_t             &io_rRingBufsize);
 
+/**
+ * @brief   get the requested ring for the record and keyword
+ *          for the specified target CPU.
+ *
+ *          detailed comments on get are in getMbvpdRing.H
+ *          and apply here as well.
+ *
+ * @param i_mbvpdRingFuncOp  -  indicate get or set via enum mbvpdRingFuncOp
+ * @param i_record          -   Record enumerator
+ * @param i_keyword         -   Keyword enumerator
+ * @param i_fapiTarget      -   cpu target
+ * @param i_chipletId       -   Chiplet ID
+ * @param i_ringId          -   Ring ID
+ * @param i_pRingBuf        -   The buffer to receive or send the ring
+ * @param io_rRingBufsize   -   Size of ring / ring buffer
+ *
+ * @return fapi::ReturnCode -   FAPI_RC_SUCCESS if success,
+ *                              relevant error code for failure.
+ */
+fapi::ReturnCode mbvpdRingFunc( mbvpdRingFuncOp i_mbvpdRingFuncOp,
+                                fapi::MBvpdRecord i_record,
+                                fapi::MBvpdKeyword i_keyword,
+                                const fapi::Target &i_fapiTarget,
+                                const uint8_t i_chipletId,
+                                const uint8_t i_ringId,
+                                uint8_t *i_pRingBuf,
+                                uint32_t &io_rRingBufsize);
+
 
 } // extern "C"
 
-#endif // _HWP_REPAIRRINGFUNC
+#endif
diff --git a/src/usr/hwpf/hwp/mvpd_accessors/mvpd_errors.xml b/src/usr/hwpf/hwp/mvpd_accessors/mvpd_errors.xml
index 711b8dbbe..103219f2a 100644
--- a/src/usr/hwpf/hwp/mvpd_accessors/mvpd_errors.xml
+++ b/src/usr/hwpf/hwp/mvpd_accessors/mvpd_errors.xml
@@ -20,7 +20,7 @@
 <!-- Origin: 30                                                             -->
 <!--                                                                        -->
 <!-- IBM_PROLOG_END_TAG                                                     -->
-<!-- $Id: mvpd_errors.xml,v 1.7 2013/07/18 15:32:12 whs Exp $ -->
+<!-- $Id: mvpd_errors.xml,v 1.8 2013/10/09 20:54:58 mjjones Exp $ -->
 <hwpErrors>
   <!-- ********************************************************************* -->
   <hwpError>
@@ -116,4 +116,11 @@
     </description>
     <ffdc>MODULE_ID</ffdc>
   </hwpError>
+  <!-- ********************************************************************* -->
+  <hwpError>
+    <rc>RC_MBVPD_RING_FUNC_INVALID_PARAMETER</rc>
+    <description>
+        An invalid parameter was passed to a mbvpd ring function.
+    </description>
+  </hwpError>
 </hwpErrors>
diff --git a/src/usr/hwpf/hwp/sbe_centaur_init/makefile b/src/usr/hwpf/hwp/sbe_centaur_init/makefile
index d81f5da83..e3792a837 100644
--- a/src/usr/hwpf/hwp/sbe_centaur_init/makefile
+++ b/src/usr/hwpf/hwp/sbe_centaur_init/makefile
@@ -43,6 +43,7 @@ EXTRAINCDIR += ${ROOTPATH}/src/usr/pore/poreve/porevesrc
 ##  NOTE: add a new EXTRAINCDIR when you add a new HWP
 EXTRAINCDIR += ${ROOTPATH}/src/usr/hwpf/hwp/sbe_centaur_init
 EXTRAINCDIR += ${ROOTPATH}/src/usr/hwpf/hwp/build_winkle_images/p8_slw_build
+EXTRAINCDIR += ${ROOTPATH}/src/usr/hwpf/hwp/mvpd_accessors
 
 
 OBJS =  sbe_centaur_init.o cen_xip_customize.o
diff --git a/src/usr/hwpf/plat/fapiPlatMBvpdAccess.C b/src/usr/hwpf/plat/fapiPlatMBvpdAccess.C
index 670da1379..9c9d0318f 100644
--- a/src/usr/hwpf/plat/fapiPlatMBvpdAccess.C
+++ b/src/usr/hwpf/plat/fapiPlatMBvpdAccess.C
@@ -120,6 +120,7 @@ fapi::ReturnCode MBvpdKeywordXlate(const fapi::MBvpdKeyword i_fapiKeyword,
         CVPD::MV,
         CVPD::AM,
         CVPD::VZ,
+        CVPD::pdD,
     };
     const uint8_t NUM_MBVPD_KEYWORDS =
      sizeof(mbvpdFapiKeywordToHbKeyword)/sizeof(mbvpdFapiKeywordToHbKeyword[0]);
@@ -204,7 +205,7 @@ fapi::ReturnCode fapiGetMBvpdField(const fapi::MBvpdRecord i_record,
             i_pBuffer,
             l_fieldLen,
             DEVICE_CVPD_ADDRESS(l_hbRecord, l_hbKeyword));
- 
+
         if (l_errl)
         {
             FAPI_ERR("fapGetMBvpdField: ERROR: deviceRead : errorlog PLID=0x%x",
@@ -256,7 +257,7 @@ fapi::ReturnCode fapiSetMBvpdField(const fapi::MBvpdRecord i_record,
         CVPD::cvpdKeyword l_hbKeyword = CVPD::CVPD_INVALID_KEYWORD;
 
         l_rc = fapi::MBvpdKeywordXlate(i_keyword, l_hbKeyword);
- 
+
         if (l_rc)
         {
             break;
diff --git a/src/usr/vpd/cvpd.H b/src/usr/vpd/cvpd.H
index 3598e144c..6659a8847 100644
--- a/src/usr/vpd/cvpd.H
+++ b/src/usr/vpd/cvpd.H
@@ -95,6 +95,7 @@ namespace CVPD
         { MV,  "MV" },
         { AM,  "AM" },
         { VZ,  "VZ" },
+        { pdD, "#D" },
         // -------------------------------------------------------------------
         // DO NOT USE!!  This is for test purposes ONLY!
         { CVPD_TEST_KEYWORD, "XX" },