eRepair: Fixed DMI/MemBuf lanes update in vpd

- Fixed addition of new lanes record in vpd
- Fixed to pick right mem buf size for mem buf target
- Fixed null target returned from determineRepairLanesDMI
- Added code to get serial number of chip to verify record in vpd
- Added more traces

Change-Id: I261f3e65bb9b0f6a75ddd203dfbb2b0560992a52
CQ:SW435969
CQ:SW436010
CQ:SW438169
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/62295
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com>
Reviewed-by: William G. Hoffa <wghoffa@us.ibm.com>
Reviewed-by: Benjamin J. Weisenbeck <bweisenb@us.ibm.com>
Reviewed-by: Dean Sanner <dsanner@us.ibm.com>
Reviewed-by: Jennifer A. Stofer <stofer@us.ibm.com>
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/62301
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Christian R. Geddes <crgeddes@us.ibm.com>

3 files changed, 501 insertions, 55 deletions

diff --git a/src/import/chips/p9/procedures/hwp/io/p9_io_erepairAccessorHwpFuncs.H b/src/import/chips/p9/procedures/hwp/io/p9_io_erepairAccessorHwpFuncs.H
index 3e7cb058a..6256163f7 100755
--- a/src/import/chips/p9/procedures/hwp/io/p9_io_erepairAccessorHwpFuncs.H
+++ b/src/import/chips/p9/procedures/hwp/io/p9_io_erepairAccessorHwpFuncs.H
@@ -331,6 +331,8 @@ fapi2::ReturnCode erepairSetFieldFailedLanes(
 {
     fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
 
+    FAPI_DBG(">> erepairSetFieldFailedLanes");
+
     // Execute the Accessor HWP to write the fail lanes to Field VPD
     FAPI_TRY( p9_io_erepairSetFailedLanesHwp(
                   i_endp_target,
@@ -375,6 +377,8 @@ fapi2::ReturnCode mnfgCheckFieldVPD(
 
     l_fieldVPDClear = true;
 
+    FAPI_DBG(">> mnfgCheckFieldVPD");
+
     /***** Read Field VPD *****/
 
     // During Mfg mode IPL, field VPD need to be clear.
@@ -394,7 +398,7 @@ fapi2::ReturnCode mnfgCheckFieldVPD(
        l_endp1_rxFaillanes.size())
     {
         l_fieldVPDClear = false;
-        FAPI_DBG("mnfgCheckFieldVPD: eRepair records found in Field VPD in Tx during Manufacturing mode IPL");
+        FAPI_INF("mnfgCheckFieldVPD: eRepair records found in Field VPD in Tx during Manufacturing mode IPL");
     }
 
     // Get failed lanes for endp2
@@ -412,7 +416,7 @@ fapi2::ReturnCode mnfgCheckFieldVPD(
        l_endp2_rxFaillanes.size())
     {
         l_fieldVPDClear = false;
-        FAPI_DBG("mnfgCheckFieldVPD: eRepair records found in Field VPD in Rx during Manufacturing mode IPL");
+        FAPI_INF("mnfgCheckFieldVPD: eRepair records found in Field VPD in Rx during Manufacturing mode IPL");
     }
 
     FAPI_ASSERT(l_fieldVPDClear == true,
@@ -489,6 +493,8 @@ fapi2::ReturnCode erepairSetMnfgFailedLanes(
 {
     fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
 
+    FAPI_DBG(">> erepairSetMnfgFailedLanes");
+
     // Execute the Accessor HWP to write the fail lanes to Mnfg VPD
     FAPI_TRY( p9_io_erepairSetFailedLanesHwp(
                   i_endp_target,
@@ -753,7 +759,7 @@ fapi2::ReturnCode erepairGetFailedLanes(
     std::vector<uint8_t>           l_rxFailLanes;
     std::vector<uint8_t>::iterator l_it;
 
-    FAPI_INF(">> erepairGetFailedLaness");
+    FAPI_DBG(">> erepairGetFailedLaness");
 
     // Get the erepair lanes from Field VPD
     FAPI_TRY( erepairGetFieldFailedLanes(
@@ -832,7 +838,12 @@ fapi2::ReturnCode erepairSetFailedLanes(
     std::vector<uint8_t> l_emptyVector;
     std::vector<uint8_t> l_throwAway;
 
-    FAPI_INF(">> erepairSetFailedLanes");
+    FAPI_INF(">> erepairSetFailedLanes:Fail lanes size:%d values are:", i_rxFailLanes.size());
+
+    for(uint8_t i = 0; (i < i_rxFailLanes.size() && i_rxFailLanes.size() != 0); i++)
+    {
+        FAPI_INF("%d ", i_rxFailLanes[i]);
+    }
 
     o_thresholdExceed = false;
 
@@ -1028,7 +1039,7 @@ fapi2::ReturnCode erepairGetRestoreLanes(
     fapi2::TargetType       l_endp1_tgtType = fapi2::TARGET_TYPE_NONE;
     fapi2::TargetType       l_endp2_tgtType = fapi2::TARGET_TYPE_NONE;
 
-    FAPI_INF(">>erepairGetRestoreLanes");
+    FAPI_DBG(">>erepairGetRestoreLanes");
 
     FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_MNFG_FLAGS,
                            fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>(),
@@ -1116,7 +1127,7 @@ fapi2::ReturnCode erepairGetRestoreLanes(
 
         if(l_rc)
         {
-            FAPI_DBG("erepairGetRestoreLanes:Error from mnfgCheckFieldVPD");
+            FAPI_INF("erepairGetRestoreLanes:Error from mnfgCheckFieldVPD");
             fapi2::current_err = l_rc;
             goto fapi_try_exit;
         }
@@ -1208,7 +1219,7 @@ fapi2::ReturnCode erepairGetRestoreLanes(
         l_thresholdExceed = true;
         l_numTxFailLanes = o_endp1_txFaillanes.size();
 
-        FAPI_DBG("erepairGetRestoreLanes: eRepair threshold exceed error"
+        FAPI_INF("erepairGetRestoreLanes: eRepair threshold exceed error"
                  " seen in Tx of endp1 target. No.of lanes: %d", l_numTxFailLanes);
     }
 
@@ -1218,7 +1229,7 @@ fapi2::ReturnCode erepairGetRestoreLanes(
         l_thresholdExceed = true;
         l_numRxFailLanes = o_endp1_rxFaillanes.size();
 
-        FAPI_DBG("erepairGetRestoreLanes: eRepair threshold exceed error"
+        FAPI_INF("erepairGetRestoreLanes: eRepair threshold exceed error"
                  " seen in Rx of endp1 target. No.of lanes: %d", l_numRxFailLanes);
     }
 
@@ -1228,7 +1239,7 @@ fapi2::ReturnCode erepairGetRestoreLanes(
         l_thresholdExceed = true;
         l_numTxFailLanes = o_endp2_txFaillanes.size();
 
-        FAPI_DBG("erepairGetRestoreLanes: eRepair threshold exceed error"
+        FAPI_INF("erepairGetRestoreLanes: eRepair threshold exceed error"
                  " seen in Tx of endp2 target. No.of lanes: %d",
                  l_numTxFailLanes);
     }
@@ -1239,7 +1250,7 @@ fapi2::ReturnCode erepairGetRestoreLanes(
         l_thresholdExceed = true;
         l_numRxFailLanes = o_endp2_rxFaillanes.size();
 
-        FAPI_DBG("erepairGetRestoreLanes: eRepair threshold exceed error"
+        FAPI_INF("erepairGetRestoreLanes: eRepair threshold exceed error"
                  " seen in Rx of endp2 target. No.of lanes: %d",
                  l_numRxFailLanes);
     }
diff --git a/src/import/chips/p9/procedures/hwp/io/p9_io_erepairGetFailedLanesHwp.H b/src/import/chips/p9/procedures/hwp/io/p9_io_erepairGetFailedLanesHwp.H
index 9d82c08e3..aa4fe80e1 100755
--- a/src/import/chips/p9/procedures/hwp/io/p9_io_erepairGetFailedLanesHwp.H
+++ b/src/import/chips/p9/procedures/hwp/io/p9_io_erepairGetFailedLanesHwp.H
@@ -124,7 +124,7 @@ fapi2::ReturnCode decodeFailedLanes(
     uint8_t           maxBusLanes       = 0;
     uint32_t          checkBitPosition  = (0x80000000);
 
-    FAPI_DBG(">> decodeFailedLanes");
+    FAPI_INF(">> decodeFailedLanes - IF:0x%x FailBit:%d ", i_busInterface, i_failBit);
 
     // Check for target type and corresponding sub interface
     // to get max lanes supported per interface
@@ -153,7 +153,7 @@ fapi2::ReturnCode decodeFailedLanes(
 
     //Check for all the failed bit SET in the bit stream and update the vector
     //And print the failed lanes
-    FAPI_INF("No. of Failed Lanes:");
+    FAPI_INF("decodeFailedLanes: No. of Failed Lanes:");
 
     for( loop = 0;
          loop < maxBusLanes;
@@ -210,7 +210,7 @@ fapi2::ReturnCode determineRepairLanesProc(
     bool l_bClkGroupFound                       = false;
     fapi2::current_err                          = fapi2::FAPI2_RC_SUCCESS;
 
-    FAPI_DBG(">> determineRepairLanesProc");
+    FAPI_INF(">> determineRepairLanesProc - BufSize:%d ", i_bufSz);
 
     // Get the parent chip target
     l_chipTarget = i_target.template getParent<fapi2::TARGET_TYPE_PROC_CHIP>();
@@ -239,11 +239,14 @@ fapi2::ReturnCode determineRepairLanesProc(
             l_loop < l_numRepairs;
             l_loop++, (l_vpdPtr += l_fabricRepairDataSz))
         {
+            FAPI_INF("Loop data:Numrepair:%d Bytesparse:%d ", l_numRepairs, l_bytesParsed);
+
             // Make sure we are not parsing more data than the passed size
             l_bytesParsed += l_fabricRepairDataSz;
 
             if(l_bytesParsed > i_bufSz)
             {
+                FAPI_INF("Size:Byteparsed:%d BufSize:%d ", l_bytesParsed, i_bufSz);
                 break;
             }
 
@@ -268,6 +271,8 @@ fapi2::ReturnCode determineRepairLanesProc(
             //    continue;
             //}
 
+            FAPI_INF("Type:%d IF:%d ", l_fabricBus->type, l_fabricBus->interface);
+
             if(l_fabricBus->type != EREPAIR::PROCESSOR_EDIP)
             {
                 continue;
@@ -278,6 +283,8 @@ fapi2::ReturnCode determineRepairLanesProc(
                                    i_target,
                                    l_busNum));
 
+            FAPI_INF("Channel:%d BusNum:%d ", l_fabricBus->device.fabricBus, l_busNum);
+
             if(l_fabricBus->device.fabricBus != l_busNum)
             {
                 continue;
@@ -291,6 +298,8 @@ fapi2::ReturnCode determineRepairLanesProc(
             }
 
             // Copy the fail lane numbers in the vectors
+            FAPI_INF("Decode:IF:0x%x FailBit:%d ", l_fabricBus->interface, l_fabricBus->failBit);
+
             if(l_fabricBus->interface == EREPAIR::PBUS_DRIVER)
             {
                 decodeFailedLanes(i_target, l_fabricBus->interface,
@@ -349,7 +358,7 @@ fapi2::ReturnCode determineRepairLanesMemBuf(
     fapi2::ATTR_CHIP_UNIT_POS_Type l_busNum;
     fapi2::current_err                          = fapi2::FAPI2_RC_SUCCESS;
 
-    FAPI_DBG(">> determineRepairLanesMemBuf");
+    FAPI_INF(">> determineRepairLanesMemBuf - BufSize:%d ", i_bufSz);
 
     // Get the chip position
     uint32_t l_chipPosition;
@@ -385,11 +394,14 @@ fapi2::ReturnCode determineRepairLanesMemBuf(
             l_loop < l_numRepairs;
             l_loop++, (l_vpdPtr += l_memRepairDataSz))
         {
+            FAPI_INF("Loop data:Numrepair:%d Bytesparse:%d ", l_numRepairs, l_bytesParsed);
+
             // Make sure we are not parsing more data than the passed size
             l_bytesParsed += l_memRepairDataSz;
 
             if(l_bytesParsed > i_bufSz)
             {
+                FAPI_INF("Size:Byteparsed:%d BufSize:%d ", l_bytesParsed, i_bufSz);
                 break;
             }
 
@@ -414,9 +426,12 @@ fapi2::ReturnCode determineRepairLanesMemBuf(
             if((l_customDimm != fapi2::ENUM_ATTR_CEN_SPD_CUSTOM_YES) &&
                (l_chipPosition != l_memBus->device.proc_centaur_id))
             {
+                FAPI_INF("DIMM:%d ChipPos:%d ", l_customDimm, l_chipPosition);
                 continue;
             }
 
+            FAPI_INF("Type:%d IF:%d ", l_memBus->type, l_memBus->interface);
+
             // Check if we have the matching the Memory Bus types
             if(l_memBus->type != EREPAIR::MEMORY_EDIP)
             {
@@ -428,12 +443,15 @@ fapi2::ReturnCode determineRepairLanesMemBuf(
                                    l_dmiTarget,
                                    l_busNum));
 
+            FAPI_INF("Channel:%d BusNum:%d ", l_memBus->device.memChannel, l_busNum);
+
             if(l_memBus->device.memChannel != l_busNum)
             {
                 continue;
             }
 
             // Copy the fail lane numbers in the vectors
+            FAPI_INF("Decode:IF:0x%x FailBit:%d ", l_memBus->interface, l_memBus->failBit);
             {
                 if(l_memBus->interface == EREPAIR::DMI_MEMBUF_DRIVE)
                 {
@@ -489,13 +507,12 @@ fapi2::ReturnCode determineRepairLanesDMI(
     uint32_t         l_loop               = 0;
     uint32_t         l_bytesParsed        = 0;
     const uint32_t   l_memRepairDataSz    = sizeof(eRepairMemBus);
-    fapi2::Target<fapi2::TARGET_TYPE_DMI>       l_dmiTarget;
     fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP> l_chipTarget;
     fapi2::ReturnCode l_rc                      = fapi2::FAPI2_RC_SUCCESS;
     fapi2::ATTR_CHIP_UNIT_POS_Type l_busNum;
     fapi2::current_err                          = fapi2::FAPI2_RC_SUCCESS;
 
-    FAPI_DBG(">> determineRepairLanesMemDMI");
+    FAPI_INF(">> determineRepairLanesMemDMI - BufSize:%d ", i_bufSz);
 
     // Get the parent chip target
     l_chipTarget = i_target.template getParent<fapi2::TARGET_TYPE_PROC_CHIP>();
@@ -524,11 +541,14 @@ fapi2::ReturnCode determineRepairLanesDMI(
             l_loop < l_numRepairs;
             l_loop++, (l_vpdPtr += l_memRepairDataSz))
         {
+            FAPI_INF("Loop data:Numrepair:%d Bytesparse:%d ", l_numRepairs, l_bytesParsed);
+
             // Make sure we are not parsing more data than the passed size
             l_bytesParsed += l_memRepairDataSz;
 
             if(l_bytesParsed > i_bufSz)
             {
+                FAPI_INF("Size:Byteparsed:%d BufSize:%d ", l_bytesParsed, i_bufSz);
                 break;
             }
 
@@ -550,6 +570,8 @@ fapi2::ReturnCode determineRepairLanesDMI(
             // the Lane eRepair data for multiple Centaurs is maintained in
             // a common VPD.
 
+            FAPI_INF("Type:%d IF:%d ", l_memBus->type, l_memBus->interface);
+
             // Check if we have the matching the Memory Bus types
             if(l_memBus->type != EREPAIR::MEMORY_EDIP)
             {
@@ -558,15 +580,19 @@ fapi2::ReturnCode determineRepairLanesDMI(
 
             // Check if we have the matching memory bus interface
             FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_UNIT_POS,
-                                   l_dmiTarget,
+                                   i_target,
                                    l_busNum));
 
+            FAPI_INF("Channel:%d BusNum:%d ", l_memBus->device.memChannel, l_busNum);
+
             if(l_memBus->device.memChannel != l_busNum)
             {
                 continue;
             }
 
             // Copy the fail lane numbers in the vectors
+            FAPI_INF("Decode:IF:0x%x FailBit:%d ", l_memBus->interface, l_memBus->failBit);
+
             if(l_memBus->interface == EREPAIR::DMI_MCS_DRIVE)
             {
                 decodeFailedLanes(i_target, l_memBus->interface,
@@ -617,7 +643,9 @@ fapi2::ReturnCode retrieveRepairDataProc(
     fapi2::ReturnCode l_rc                       = fapi2::FAPI2_RC_SUCCESS;
     fapi2::current_err                           = fapi2::FAPI2_RC_SUCCESS;
     uint8_t* l_retBuf                            = NULL;
+    uint8_t* l_serialBuf                         = NULL;
     uint32_t l_bufSize                           = 0;
+    uint32_t l_serialNum                         = 0;
     fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>  l_procTarget;
 
     FAPI_DBG(">> retrieveRepairDataProc");
@@ -633,6 +661,42 @@ fapi2::ReturnCode retrieveRepairDataProc(
             l_vpdRecord = fapi2::MVPD_RECORD_MER0;
         }
 
+        // Determine the serial number to uniquely identify the proc
+        FAPI_TRY( getMvpdField(
+                      fapi2::MVPD_RECORD_VINI,
+                      fapi2::MVPD_KEYWORD_SN,
+                      l_procTarget,
+                      NULL,
+                      l_serialNum),
+                  "Serial number size read failed w/rc=0x%x",
+                  (uint64_t)fapi2::current_err );
+
+        FAPI_INF("Serial number size:0x%08x ", l_serialNum);
+
+        if( l_serialNum )
+        {
+            // Allocate memory for buffer
+            l_serialBuf = new uint8_t[l_serialNum];
+
+            // Retrieve the serial number data from the MVPD
+            FAPI_TRY( getMvpdField(
+                          fapi2::MVPD_RECORD_VINI,
+                          fapi2::MVPD_KEYWORD_SN,
+                          l_procTarget,
+                          l_serialBuf,
+                          l_serialNum),
+                      "Serial number read failed w/rc=0x%x",
+                      (uint64_t)fapi2::current_err );
+
+            FAPI_INF("Serial Number: ");
+
+            for(uint32_t i = 0; i < l_serialNum; i++)
+            {
+                FAPI_INF("%02x ", *(l_serialBuf + i));
+            }
+        }
+
+
         // Determine the size of the eRepair data in the VPD
         FAPI_TRY( getMvpdField(
                       l_vpdRecord,
@@ -643,6 +707,8 @@ fapi2::ReturnCode retrieveRepairDataProc(
                   "VPD size read failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
 
+        FAPI_INF("retrieveRepairDataProc:VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MVPD_KEYWORD_PDI, l_bufSize);
+
         if((l_bufSize == 0) ||
            ((i_vpdType == EREPAIR::EREPAIR_VPD_FIELD) &&
             (l_bufSize > EREPAIR::EREPAIR_P9_MODULE_VPD_FIELD_SIZE)) ||
@@ -683,12 +749,13 @@ fapi2::ReturnCode retrieveRepairDataProc(
                       i_clkGroup,
                       o_txFailLanes,
                       o_rxFailLanes),
-                  "Call to determineRepairLanes failed w/rc=0x%x",
+                  "Call to determineRepairLanesProc failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
     }
 
     // Delete the buffer which has Field eRepair data
     delete[] l_retBuf;
+    delete[] l_serialBuf;
 
     FAPI_DBG("<< retrieveRepairDataProc");
 
@@ -724,6 +791,8 @@ fapi2::ReturnCode retrieveRepairDataMemBuf(
     fapi2::ReturnCode l_rc                       = fapi2::FAPI2_RC_SUCCESS;
     fapi2::current_err                           = fapi2::FAPI2_RC_SUCCESS;
     uint8_t* l_retBuf                            = NULL;
+    uint8_t* l_serialBuf                         = NULL;
+    size_t l_serialNum                           = 0;
     size_t l_bufSize                             = 0;
     uint8_t                                      l_customDimm;
 
@@ -737,6 +806,41 @@ fapi2::ReturnCode retrieveRepairDataMemBuf(
             l_vpdRecord = fapi2::MBVPD_RECORD_MER0;
         }
 
+        // Determine the serial number to uniquely identify centaur vpd
+        FAPI_TRY( getMBvpdField(
+                      fapi2::MBVPD_RECORD_VINI,
+                      fapi2::MBVPD_KEYWORD_SN,
+                      i_target,
+                      NULL,
+                      l_serialNum),
+                  "Serial number size read failed w/rc=0x%x",
+                  (uint64_t)fapi2::current_err );
+
+        FAPI_INF("Serial number size:0x%08x ", l_serialNum);
+
+        if( l_serialNum )
+        {
+            // Allocate memory for buffer
+            l_serialBuf = new uint8_t[l_serialNum];
+
+            // Retrieve the serial number data from the MVPD
+            FAPI_TRY( getMBvpdField(
+                          fapi2::MBVPD_RECORD_VINI,
+                          fapi2::MBVPD_KEYWORD_SN,
+                          i_target,
+                          l_serialBuf,
+                          l_serialNum),
+                      "Serial number read failed w/rc=0x%x",
+                      (uint64_t)fapi2::current_err );
+
+            FAPI_INF("Serial Number: ");
+
+            for(size_t i = 0; i < l_serialNum; i++)
+            {
+                FAPI_INF("%02x ", *(l_serialBuf + i));
+            }
+        }
+
         // Determine the size of the eRepair data in the VPD
         FAPI_TRY( getMBvpdField(
                       l_vpdRecord,
@@ -747,6 +851,8 @@ fapi2::ReturnCode retrieveRepairDataMemBuf(
                   "VPD size read failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
 
+        FAPI_INF("retrieveRepairDataMemBuf:VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MBVPD_KEYWORD_PDI, l_bufSize);
+
         // Check whether we have Memory on a CDIMM
         l_rc = getDimmType(i_target, l_customDimm);
 
@@ -797,12 +903,13 @@ fapi2::ReturnCode retrieveRepairDataMemBuf(
                       l_bufSize,
                       o_txFailLanes,
                       o_rxFailLanes),
-                  "Call to determineRepairLanes failed w/rc=0x%x",
+                  "Call to determineRepairLanesMemBuf failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
     }
 
     // Delete the buffer which has Field eRepair data
     delete[] l_retBuf;
+    delete[] l_serialBuf;
 
     FAPI_DBG("<< retrieveRepairDataMemBuf");
 
@@ -838,7 +945,9 @@ fapi2::ReturnCode retrieveRepairDataDMI(
     fapi2::ReturnCode l_rc                       = fapi2::FAPI2_RC_SUCCESS;
     fapi2::current_err                           = fapi2::FAPI2_RC_SUCCESS;
     uint8_t* l_retBuf                            = NULL;
+    uint8_t* l_serialBuf                         = NULL;
     uint32_t l_bufSize                           = 0;
+    uint32_t l_serialNum                         = 0;
     fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>  l_procTarget;
 
     FAPI_DBG(">> retrieveRepairDataDMI");
@@ -854,6 +963,41 @@ fapi2::ReturnCode retrieveRepairDataDMI(
             l_vpdRecord = fapi2::MVPD_RECORD_MER0;
         }
 
+        // Determine the serial number to uniquely identify the proc
+        FAPI_TRY( getMvpdField(
+                      fapi2::MVPD_RECORD_VINI,
+                      fapi2::MVPD_KEYWORD_SN,
+                      l_procTarget,
+                      NULL,
+                      l_serialNum),
+                  "Serial number size read failed w/rc=0x%x",
+                  (uint64_t)fapi2::current_err );
+
+        FAPI_INF("Serial number size:0x%08x ", l_serialNum);
+
+        if( l_serialNum )
+        {
+            // Allocate memory for buffer
+            l_serialBuf = new uint8_t[l_serialNum];
+
+            // Retrieve the serial number data from the MVPD
+            FAPI_TRY( getMvpdField(
+                          fapi2::MVPD_RECORD_VINI,
+                          fapi2::MVPD_KEYWORD_SN,
+                          l_procTarget,
+                          l_serialBuf,
+                          l_serialNum),
+                      "Serial number read failed w/rc=0x%x",
+                      (uint64_t)fapi2::current_err );
+
+            FAPI_INF("Serial Number: ");
+
+            for(uint32_t i = 0; i < l_serialNum; i++)
+            {
+                FAPI_INF("%02x ", *(l_serialBuf + i));
+            }
+        }
+
         // Determine the size of the eRepair data in the VPD
         FAPI_TRY( getMvpdField(
                       l_vpdRecord,
@@ -864,6 +1008,8 @@ fapi2::ReturnCode retrieveRepairDataDMI(
                   "VPD size read failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
 
+        FAPI_INF("retrieveRepairDataDMI:VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MVPD_KEYWORD_PDI, l_bufSize);
+
         if((l_bufSize == 0) ||
            ((i_vpdType == EREPAIR::EREPAIR_VPD_FIELD) &&
             (l_bufSize > EREPAIR::EREPAIR_P9_MODULE_VPD_FIELD_SIZE)) ||
@@ -903,12 +1049,13 @@ fapi2::ReturnCode retrieveRepairDataDMI(
                       l_bufSize,
                       o_txFailLanes,
                       o_rxFailLanes),
-                  "Call to determineRepairLanes failed w/rc=0x%x",
+                  "Call to determineRepairLanesDMI failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
     }
 
     // Delete the buffer which has Field eRepair data
     delete[] l_retBuf;
+    delete[] l_serialBuf;
 
     FAPI_DBG("<< retrieveRepairDataDMI");
 
@@ -953,7 +1100,7 @@ fapi2::ReturnCode p9_io_erepairGetFailedLanesHwp(
                   i_clkGroup,
                   o_txFailLanes,
                   o_rxFailLanes),
-              "p9_io_erepairGetFailedLanesHwp() failed w/rc=0x%x",
+              "retrieveRepairDataProc() failed w/rc=0x%x",
               (uint64_t)fapi2::current_err );
 
 fapi_try_exit:
@@ -980,7 +1127,7 @@ fapi2::ReturnCode p9_io_erepairGetFailedLanesHwp(
                   i_vpdType,
                   o_txFailLanes,
                   o_rxFailLanes),
-              "p9_io_erepairGetFailedLanesHwp() failed w/rc=0x%x",
+              "retrieveRepairDataMemBuf() failed w/rc=0x%x",
               (uint64_t)fapi2::current_err );
 
 fapi_try_exit:
@@ -1007,7 +1154,7 @@ fapi2::ReturnCode p9_io_erepairGetFailedLanesHwp(
                   i_vpdType,
                   o_txFailLanes,
                   o_rxFailLanes),
-              "p9_io_erepairGetFailedLanesHwp() failed w/rc=0x%x",
+              "retrieveRepairDataDMI() failed w/rc=0x%x",
               (uint64_t)fapi2::current_err );
 
 fapi_try_exit:
diff --git a/src/import/chips/p9/procedures/hwp/io/p9_io_erepairSetFailedLanesHwp.H b/src/import/chips/p9/procedures/hwp/io/p9_io_erepairSetFailedLanesHwp.H
index 3a622404b..2a2991684 100755
--- a/src/import/chips/p9/procedures/hwp/io/p9_io_erepairSetFailedLanesHwp.H
+++ b/src/import/chips/p9/procedures/hwp/io/p9_io_erepairSetFailedLanesHwp.H
@@ -74,7 +74,7 @@ fapi2::ReturnCode gatherRepairLanes(
     uint8_t           maxBusLanes       = 0;
     uint32_t          setBitPosition    = (0x80000000);
 
-    FAPI_DBG(">> setRepairLanes");
+    FAPI_INF(">> setRepairLanes - IF:%d repairLane:%d ", i_busInterface, i_repairLane);
 
     // Check for target type and corresponding sub interface
     // to get max lanes supported per interface
@@ -166,9 +166,14 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
     std::vector<uint8_t>::const_iterator l_it;
     fapi2::ATTR_CHIP_UNIT_POS_Type l_busNum;
 
-    FAPI_DBG(">> updateRepairLanesToBuf(XBUS), interface: %s",
+    FAPI_INF(">> updateRepairLanesToBuf(XBUS), interface: %s",
              i_interface == EREPAIR::DRIVE ? "Drive" : "Receive");
 
+    for(uint8_t i = 0; (i < i_failLanes.size() && i_failLanes.size() != 0); i++)
+    {
+        FAPI_INF("(%d):%d ", i, i_failLanes[i]);
+    }
+
     {
         l_repairDataSz = sizeof(eRepairPowerBus); // Size of memory Bus and
         // fabric Bus eRepair data
@@ -489,6 +494,8 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
             l_overWrite   = false;
             l_vpdWritePtr = NULL;
 
+            FAPI_INF("repairLaneCnt-1:it:%d ", l_repairLane);
+
             // Parse the VPD for fabric and memory eRepair records
             for(;
                 (l_repairCnt < l_numRepairs) && (l_bytesParsed <= i_bufSz);
@@ -497,9 +504,15 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
                 l_overWritePtr =
                     reinterpret_cast<eRepairPowerBus*> (l_vpdDataPtr);
 
+                FAPI_DBG("repairLaneCnt-2:repariCnt:%d numRepair:%d byteparsed:%d bufSize:%d ", l_repairCnt, l_numRepairs,
+                         l_bytesParsed,
+                         i_bufSz);
+
                 // Lets find the matching fabric
                 for(uint8_t l_loop = 0; l_loop < 14; l_loop++)
                 {
+                    FAPI_DBG("repairLaneCnt-3:cnt:%d ", l_loop);
+
                     {
                         if((i_interface == l_repairMatch[l_loop].intType)    &&
                            (i_target.getType()   == l_repairMatch[l_loop].tgtType)    &&
@@ -512,6 +525,9 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
                            (l_overWritePtr->device.fabricBus ==
                             l_repairMatch[l_loop].bus.fabBus.device.fabricBus))
                         {
+                            FAPI_INF("repairLaneCnt-4:Found match: Dev id:%d type:%d IF:%d  Bus:%d ", (l_overWritePtr->device).processor_id,
+                                     l_overWritePtr->type, l_overWritePtr->interface, l_overWritePtr->device.fabricBus);
+
                             if(i_clkGroup > 0 && !l_bClkGroupFound)
                             {
                                 l_bClkGroupFound = true;
@@ -529,6 +545,7 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
                                               tptr),
                                           "gatherRepairLanes() failed w/rc=0x%x",
                                           (uint64_t)fapi2::current_err );
+                                FAPI_INF("FailBit:0x%x temp:0x%x ", l_overWritePtr->failBit, temp);
                                 l_overWritePtr->failBit = temp;
                             }
 
@@ -538,6 +555,14 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
                             l_repairCnt++;
                             l_overWrite = true;
 
+                            // Get the record updated
+                            FAPI_INF("Record updated: ");
+
+                            for(uint8_t i = 0; i < 6; i++)
+                            {
+                                FAPI_INF("%02x ", *(l_vpdDataPtr + i));
+                            }
+
                             break;
                         }
                     }
@@ -610,6 +635,9 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
                         l_fabricBus->type = EREPAIR::PROCESSOR_OPT;
                     }
 
+                    FAPI_INF("Fabric Bus(before update):Dev:%d Bus:%d Type:%d MemIF:%d IF:%d ", l_fabricBus->device.processor_id,
+                             l_fabricBus->device.fabricBus, l_fabricBus->type, l_fabricBus->interface, i_interface);
+
                     {
                         uint32_t temp = (uint32_t)(l_fabricBus->failBit);
                         uint32_t* tptr = &temp;
@@ -620,9 +648,22 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
                                       tptr),
                                   "gatherRepairLanes() failed w/rc=0x%x",
                                   (uint64_t)fapi2::current_err );
+                        FAPI_INF("FailBit:0x%x temp:0x%x ", l_fabricBus->failBit, temp);
                         l_fabricBus->failBit = temp;
                     }
 
+                    FAPI_INF("Fabric Bus(after update):Dev:%d Bus:%d Type:%d MemIF:%d IF:%d FailBit:0x%x ",
+                             l_fabricBus->device.processor_id,
+                             l_fabricBus->device.fabricBus, l_fabricBus->type, l_fabricBus->interface, i_interface, l_fabricBus->failBit);
+
+                    // Get the record added
+                    FAPI_INF("Record Added: ");
+
+                    for(uint8_t i = 0; i < 6; i++)
+                    {
+                        FAPI_INF("%02x ", *(l_vpdDataPtr + i));
+                    }
+
                     l_newNumRepairs++;
 
                     // Increment the count of parsed bytes
@@ -638,8 +679,10 @@ fapi2::ReturnCode updateRepairLanesToBufProc(
             } // end of if(l_overWrite == false)
         } // end of for(failLanes)
     }
+
     // Update the eRepair count
     l_vpdHeadPtr->availNumRecord = l_newNumRepairs;
+    FAPI_INF("Result:NumRec:%d ", l_vpdHeadPtr->availNumRecord);
 
 fapi_try_exit:
     return fapi2::current_err;
@@ -689,9 +732,14 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
     std::vector<uint8_t>::const_iterator l_it;
     fapi2::ATTR_CHIP_UNIT_POS_Type l_busNum;
 
-    FAPI_DBG(">> updateRepairLanesToBuf(MemBuf), interface: %s",
+    FAPI_INF(">> updateRepairLanesToBuf(MemBuf), interface: %s",
              i_interface == EREPAIR::DRIVE ? "Drive" : "Receive");
 
+    for(uint8_t i = 0; (i < i_failLanes.size() && i_failLanes.size() != 0); i++)
+    {
+        FAPI_INF("(%d):%d ", i, i_failLanes[i]);
+    }
+
     {
         l_repairDataSz = sizeof(eRepairPowerBus); // Size of memory Bus and
         // fabric Bus eRepair data
@@ -1012,6 +1060,8 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
             l_overWrite   = false;
             l_vpdWritePtr = NULL;
 
+            FAPI_INF("repairLaneCnt-1:it:%d ", l_repairLane);
+
             // Parse the VPD for fabric and memory eRepair records
             for(;
                 (l_repairCnt < l_numRepairs) && (l_bytesParsed <= i_bufSz);
@@ -1020,9 +1070,15 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
                 l_overWritePtr =
                     reinterpret_cast<eRepairPowerBus*> (l_vpdDataPtr);
 
+                FAPI_DBG("repairLaneCnt-2:repariCnt:%d numRepair:%d byteparsed:%d bufSize:%d ", l_repairCnt, l_numRepairs,
+                         l_bytesParsed,
+                         i_bufSz);
+
                 // Lets find the matching fabric
                 for(uint8_t l_loop = 0; l_loop < 14; l_loop++)
                 {
+                    FAPI_DBG("repairLaneCnt-3:cnt:%d ", l_loop);
+
                     {
                         if((i_interface == l_repairMatch[l_loop].intType)    &&
                            (i_target.getType()   == l_repairMatch[l_loop].tgtType)    &&
@@ -1035,6 +1091,9 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
                            (l_overWritePtr->device.fabricBus ==
                             l_repairMatch[l_loop].bus.memBus.device.memChannel))
                         {
+                            FAPI_INF("repairLaneCnt-4:Found match: Dev id:%d type:%d IF:%d  Bus:%d ", (l_overWritePtr->device).processor_id,
+                                     l_overWritePtr->type, l_overWritePtr->interface, l_overWritePtr->device.fabricBus);
+
                             // update the failBit number
                             {
                                 uint32_t temp = (uint32_t)(l_overWritePtr->failBit);
@@ -1046,6 +1105,7 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
                                               tptr),
                                           "gatherRepairLanes() failed w/rc=0x%x",
                                           (uint64_t)fapi2::current_err );
+                                FAPI_INF("FailBit:0x%x temp:0x%x ", l_overWritePtr->failBit, temp);
                                 l_overWritePtr->failBit = temp;
                             }
 
@@ -1055,6 +1115,14 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
                             l_repairCnt++;
                             l_overWrite = true;
 
+                            // Get the record updated
+                            FAPI_INF("Record updated: ");
+
+                            for(uint8_t i = 0; i < 6; i++)
+                            {
+                                FAPI_INF("%02x ", *(l_vpdDataPtr + i));
+                            }
+
                             break;
                         }
                     }
@@ -1133,6 +1201,9 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
                         }
                     }
 
+                    FAPI_INF("Memory Bus(before update):Dev:%d Bus:%d Type:%d MemIF:%d IF:%d ", l_memBus->device.proc_centaur_id,
+                             l_memBus->device.memChannel, l_memBus->type, l_memBus->interface, i_interface);
+
                     {
                         uint32_t temp = (uint32_t)(l_memBus->failBit);
                         uint32_t* tptr = &temp;
@@ -1143,9 +1214,22 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
                                       tptr),
                                   "gatherRepairLanes() failed w/rc=0x%x",
                                   (uint64_t)fapi2::current_err );
+                        FAPI_INF("FailBit:0x%x temp:0x%x ", l_memBus->failBit, temp);
                         l_memBus->failBit = temp;
                     }
 
+                    FAPI_INF("Memory Bus(after update):Dev:%d Bus:%d Type:%d MemIF:%d IF:%d FailBit:0x%x ",
+                             l_memBus->device.proc_centaur_id,
+                             l_memBus->device.memChannel, l_memBus->type, l_memBus->interface, i_interface, l_memBus->failBit);
+
+                    // Get the record added
+                    FAPI_INF("Record added: ");
+
+                    for(uint8_t i = 0; i < 6; i++)
+                    {
+                        FAPI_INF("%02x ", *(l_vpdDataPtr + i));
+                    }
+
                     l_newNumRepairs++;
 
                     // Increment the count of parsed bytes
@@ -1161,8 +1245,10 @@ fapi2::ReturnCode updateRepairLanesToBufMemBuf(
             } // end of if(l_overWrite == false)
         } // end of for(failLanes)
     }
+
     // Update the eRepair count
     l_vpdHeadPtr->availNumRecord = l_newNumRepairs;
+    FAPI_INF("Result:NumRec:%d ", l_vpdHeadPtr->availNumRecord);
 
 fapi_try_exit:
     return fapi2::current_err;
@@ -1212,9 +1298,14 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
     std::vector<uint8_t>::const_iterator l_it;
     fapi2::ATTR_CHIP_UNIT_POS_Type l_busNum;
 
-    FAPI_DBG(">> updateRepairLanesToBuf(DMI), interface: %s",
+    FAPI_INF(">> updateRepairLanesToBuf(DMI), interface: %s",
              i_interface == EREPAIR::DRIVE ? "Drive" : "Receive");
 
+    for(uint8_t i = 0; (i < i_failLanes.size() && i_failLanes.size() != 0); i++)
+    {
+        FAPI_INF("(%d):%d ", i, i_failLanes[i]);
+    }
+
     {
         l_repairDataSz = sizeof(eRepairPowerBus); // Size of memory Bus and
         // fabric Bus eRepair data
@@ -1535,6 +1626,8 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
             l_overWrite   = false;
             l_vpdWritePtr = NULL;
 
+            FAPI_INF("repairLaneCnt-1:it:%d ", l_repairLane);
+
             // Parse the VPD for fabric and memory eRepair records
             for(;
                 (l_repairCnt < l_numRepairs) && (l_bytesParsed <= i_bufSz);
@@ -1543,9 +1636,15 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
                 l_overWritePtr =
                     reinterpret_cast<eRepairPowerBus*> (l_vpdDataPtr);
 
+                FAPI_DBG("repairLaneCnt-2:repariCnt:%d numRepair:%d byteparsed:%d bufSize:%d ", l_repairCnt, l_numRepairs,
+                         l_bytesParsed,
+                         i_bufSz);
+
                 // Lets find the matching fabric
                 for(uint8_t l_loop = 0; l_loop < 14; l_loop++)
                 {
+                    FAPI_DBG("repairLaneCnt-3:cnt:%d ", l_loop);
+
                     {
                         if((i_interface == l_repairMatch[l_loop].intType)    &&
                            (i_target.getType()   == l_repairMatch[l_loop].tgtType)    &&
@@ -1558,6 +1657,9 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
                            (l_overWritePtr->device.fabricBus ==
                             l_repairMatch[l_loop].bus.memBus.device.memChannel))
                         {
+                            FAPI_INF("repairLaneCnt-4:Found match: Dev id:%d type:%d IF:%d  Bus:%d ", (l_overWritePtr->device).processor_id,
+                                     l_overWritePtr->type, l_overWritePtr->interface, l_overWritePtr->device.fabricBus);
+
                             // update the failBit number
                             {
                                 uint32_t temp = (uint32_t)(l_overWritePtr->failBit);
@@ -1569,6 +1671,7 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
                                               tptr),
                                           "gatherRepairLanes() failed w/rc=0x%x",
                                           (uint64_t)fapi2::current_err );
+                                FAPI_INF("FailBit:0x%x temp:0x%x ", l_overWritePtr->failBit, temp);
                                 l_overWritePtr->failBit = temp;
                             }
 
@@ -1578,6 +1681,14 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
                             l_repairCnt++;
                             l_overWrite = true;
 
+                            // Get the record updated
+                            FAPI_INF("Record updated: ");
+
+                            for(uint8_t i = 0; i < 6; i++)
+                            {
+                                FAPI_INF("%02x ", *(l_vpdDataPtr + i));
+                            }
+
                             break;
                         }
                     }
@@ -1656,6 +1767,9 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
                         }
                     }
 
+                    FAPI_INF("DMI Bus(before update):Dev:%d Bus:%d Type:%d MemIF:%d IF:%d ", l_memBus->device.proc_centaur_id,
+                             l_memBus->device.memChannel, l_memBus->type, l_memBus->interface, i_interface);
+
                     {
                         uint32_t temp = (uint32_t)(l_memBus->failBit);
                         uint32_t* tptr = &temp;
@@ -1666,9 +1780,21 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
                                       tptr),
                                   "gatherRepairLanes() failed w/rc=0x%x",
                                   (uint64_t)fapi2::current_err );
+                        FAPI_INF("FailBit:0x%x temp:0x%x ", l_memBus->failBit, temp);
                         l_memBus->failBit = temp;
                     }
 
+                    FAPI_INF("DMI Bus(after update):Dev:%d Bus:%d Type:%d MemIF:%d IF:%d FailBit:0x%x ", l_memBus->device.proc_centaur_id,
+                             l_memBus->device.memChannel, l_memBus->type, l_memBus->interface, i_interface, l_memBus->failBit);
+
+                    // Get the record added
+                    FAPI_INF("Record added: ");
+
+                    for(uint8_t i = 0; i < 6; i++)
+                    {
+                        FAPI_INF("%02x ", *(l_vpdDataPtr + i));
+                    }
+
                     l_newNumRepairs++;
 
                     // Increment the count of parsed bytes
@@ -1684,8 +1810,10 @@ fapi2::ReturnCode updateRepairLanesToBufDMI(
             } // end of if(l_overWrite == false)
         } // end of for(failLanes)
     }
+
     // Update the eRepair count
     l_vpdHeadPtr->availNumRecord = l_newNumRepairs;
+    FAPI_INF("Result:NumRec:%d ", l_vpdHeadPtr->availNumRecord);
 
 fapi_try_exit:
     return fapi2::current_err;
@@ -1717,9 +1845,11 @@ fapi2::ReturnCode writeRepairDataToVPDProc(
     fapi2::current_err                                           = fapi2::FAPI2_RC_SUCCESS;
     fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>                  l_procTarget;
 
-    uint8_t* l_retBuf   = NULL;
-    uint32_t l_bufSize  = 0;
-    FAPI_DBG(">> writeRepairDataToVPD - Proc");
+    uint8_t* l_retBuf    = NULL;
+    uint32_t l_bufSize   = 0;
+    uint32_t l_serialNum = 0;
+    uint8_t* l_serialBuf = NULL;
+    FAPI_INF(">> writeRepairDataToVPD - Proc - RxLaneSize:%d TxLaneSize:%d ", i_rxFailLanes.size(), i_txFailLanes.size());
 
     {
         // Determine the Processor target
@@ -1734,6 +1864,41 @@ fapi2::ReturnCode writeRepairDataToVPDProc(
 
         /*** Read the data from the Module VPD ***/
 
+        // Determine the serial number to uniquely identify the proc
+        FAPI_TRY( getMvpdField(
+                      fapi2::MVPD_RECORD_VINI,
+                      fapi2::MVPD_KEYWORD_SN,
+                      l_procTarget,
+                      NULL,
+                      l_serialNum),
+                  "Serial number size read failed w/rc=0x%x",
+                  (uint64_t)fapi2::current_err );
+
+        FAPI_INF("Serial number size:0x%08x ", l_serialNum);
+
+        if( l_serialNum )
+        {
+            // Allocate memory for buffer
+            l_serialBuf = new uint8_t[l_serialNum];
+
+            // Retrieve the serial number data from the MVPD
+            FAPI_TRY( getMvpdField(
+                          fapi2::MVPD_RECORD_VINI,
+                          fapi2::MVPD_KEYWORD_SN,
+                          l_procTarget,
+                          l_serialBuf,
+                          l_serialNum),
+                      "Serial number read failed w/rc=0x%x",
+                      (uint64_t)fapi2::current_err );
+
+            FAPI_INF("Serial Number: ");
+
+            for(uint32_t i = 0; i < l_serialNum; i++)
+            {
+                FAPI_INF("%02x ", *(l_serialBuf + i));
+            }
+        }
+
         // Determine the size of the eRepair data in the VPD
         FAPI_TRY( getMvpdField(
                       l_vpdRecord,
@@ -1744,6 +1909,8 @@ fapi2::ReturnCode writeRepairDataToVPDProc(
                   "VPD size read failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
 
+        FAPI_INF("VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MVPD_KEYWORD_PDI, l_bufSize);
+
         if((l_bufSize == 0) ||
            ((i_vpdType == EREPAIR::EREPAIR_VPD_FIELD) &&
             (l_bufSize > EREPAIR::EREPAIR_P9_MODULE_VPD_FIELD_SIZE)) ||
@@ -1785,7 +1952,7 @@ fapi2::ReturnCode writeRepairDataToVPDProc(
                           i_clkGroup,
                           i_txFailLanes,
                           l_retBuf),
-                      "updateRepairLanesToBuf(DRIVE) failed w/rc=0x%x",
+                      "updateRepairLanesToBufProc(DRIVE) failed w/rc=0x%x",
                       (uint64_t)fapi2::current_err );
         }
 
@@ -1799,10 +1966,11 @@ fapi2::ReturnCode writeRepairDataToVPDProc(
                           i_clkGroup,
                           i_rxFailLanes,
                           l_retBuf),
-                      "updateRepairLanesToBuf(RECEIVE) failed w/rc=0x%x",
+                      "updateRepairLanesToBufProc(RECEIVE) failed w/rc=0x%x",
                       (uint64_t)fapi2::current_err );
         }
 
+        FAPI_INF("Set VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MVPD_KEYWORD_PDI, l_bufSize);
         /*** Write the updated eRepair buffer back to MVPD ***/
         FAPI_TRY( setMvpdField(
                       l_vpdRecord,
@@ -1816,6 +1984,7 @@ fapi2::ReturnCode writeRepairDataToVPDProc(
 
     // Delete the buffer which has Field eRepair data
     delete[] l_retBuf;
+    delete[] l_serialBuf;
 
 fapi_try_exit:
     return fapi2::current_err;
@@ -1848,11 +2017,12 @@ fapi2::ReturnCode writeRepairDataToVPDMemBuf(
     std::vector<fapi2::Target<fapi2::TARGET_TYPE_MBA_CHIPLET>>   l_mbaChiplets;
     fapi2::Target<fapi2::TARGET_TYPE_MBA>                        l_mbaTarget;
 
-    uint8_t* l_retBuf   = NULL;
-    uint32_t l_bufSize  = 0;
-    size_t   l_mBufSize = 0;
+    uint8_t* l_retBuf    = NULL;
+    size_t   l_mBufSize  = 0;
+    uint8_t* l_serialBuf = NULL;
+    size_t   l_serialNum = 0;
     uint8_t    l_customDimm;
-    FAPI_DBG(">> writeRepairDataToVPD - MemBuf");
+    FAPI_INF(">> writeRepairDataToVPD - MemBuf - RxLaneSize:%d TxLaneSize:%d ", i_rxFailLanes.size(), i_txFailLanes.size());
 
     {
         fapi2::MBvpdRecord l_vpdRecord = fapi2::MBVPD_RECORD_VEIR;
@@ -1864,6 +2034,41 @@ fapi2::ReturnCode writeRepairDataToVPDMemBuf(
 
         /*** Read the data from the FRU VPD ***/
 
+        // Determine the serial number to uniquely identify centaur vpd
+        FAPI_TRY( getMBvpdField(
+                      fapi2::MBVPD_RECORD_VINI,
+                      fapi2::MBVPD_KEYWORD_SN,
+                      i_target,
+                      NULL,
+                      l_serialNum),
+                  "Serial number size read failed w/rc=0x%x",
+                  (uint64_t)fapi2::current_err );
+
+        FAPI_INF("Serial number size:0x%08x ", l_serialNum);
+
+        if( l_serialNum )
+        {
+            // Allocate memory for buffer
+            l_serialBuf = new uint8_t[l_serialNum];
+
+            // Retrieve the serial number data from the MVPD
+            FAPI_TRY( getMBvpdField(
+                          fapi2::MBVPD_RECORD_VINI,
+                          fapi2::MBVPD_KEYWORD_SN,
+                          i_target,
+                          l_serialBuf,
+                          l_serialNum),
+                      "Serial number read failed w/rc=0x%x",
+                      (uint64_t)fapi2::current_err );
+
+            FAPI_INF("Serial Number: ");
+
+            for(size_t i = 0; i < l_serialNum; i++)
+            {
+                FAPI_INF("%02x ", *(l_serialBuf + i));
+            }
+        }
+
         // Determine the size of the eRepair data in the Centaur VPD
         FAPI_TRY( getMBvpdField(
                       l_vpdRecord,
@@ -1874,6 +2079,8 @@ fapi2::ReturnCode writeRepairDataToVPDMemBuf(
                   "VPD size read failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
 
+        FAPI_INF("VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MBVPD_KEYWORD_PDI, l_mBufSize);
+
         // Get the connected MBA chiplet and determine whether we have CDIMM
         l_mbaChiplets = i_target.template getChildren<fapi2::TARGET_TYPE_MBA_CHIPLET>
                         (fapi2::TARGET_STATE_FUNCTIONAL);
@@ -1900,17 +2107,17 @@ fapi2::ReturnCode writeRepairDataToVPDMemBuf(
             l_customDimm = fapi2::ENUM_ATTR_CEN_SPD_CUSTOM_NO;
         }
 
-        if( (l_customDimm == fapi2::ENUM_ATTR_CEN_SPD_CUSTOM_YES) || (l_bufSize == 0) )
+        if( (l_customDimm == fapi2::ENUM_ATTR_CEN_SPD_CUSTOM_YES) || (l_mBufSize == 0) )
         {
-            if((l_bufSize == 0) ||
+            if((l_mBufSize == 0) ||
                ((i_vpdType == EREPAIR::EREPAIR_VPD_FIELD) &&
-                (l_bufSize > EREPAIR::EREPAIR_MEM_FIELD_VPD_SIZE_PER_CENTAUR)) ||
+                (l_mBufSize > EREPAIR::EREPAIR_MEM_FIELD_VPD_SIZE_PER_CENTAUR)) ||
                ((i_vpdType == EREPAIR::EREPAIR_VPD_MNFG) &&
-                (l_bufSize > EREPAIR::EREPAIR_MEM_MNFG_VPD_SIZE_PER_CENTAUR)))
+                (l_mBufSize > EREPAIR::EREPAIR_MEM_MNFG_VPD_SIZE_PER_CENTAUR)))
             {
                 FAPI_ASSERT(false,
                             fapi2::P9_EREPAIR_ACCESSOR_HWP_INVALID_MEM_VPD_SIZE_ERR()
-                            .set_VAL_BUF_SIZE(l_bufSize)
+                            .set_VAL_BUF_SIZE(l_mBufSize)
                             .set_ERROR(fapi2::current_err),
                             "ERROR: Invalid MEM VPD size");
             }
@@ -1921,7 +2128,7 @@ fapi2::ReturnCode writeRepairDataToVPDMemBuf(
 
         FAPI_ASSERT(l_retBuf != NULL,
                     fapi2::P9_EREPAIR_ACCESSOR_HWP_MEMORY_ALLOC_FAIL_ERR()
-                    .set_BUF_SIZE(l_bufSize),
+                    .set_BUF_SIZE(l_mBufSize),
                     "ERROR: Failed to allocate memory size");
 
         // Retrieve the Field eRepair data from the Centaur FRU VPD
@@ -1944,7 +2151,7 @@ fapi2::ReturnCode writeRepairDataToVPDMemBuf(
                           i_clkGroup,
                           i_txFailLanes,
                           l_retBuf),
-                      "updateRepairLanesToBuf(DRIVE) failed w/rc=0x%x",
+                      "updateRepairLanesToBufMemBuf(DRIVE) failed w/rc=0x%x",
                       (uint64_t)fapi2::current_err );
         }
 
@@ -1958,10 +2165,11 @@ fapi2::ReturnCode writeRepairDataToVPDMemBuf(
                           i_clkGroup,
                           i_rxFailLanes,
                           l_retBuf),
-                      "updateRepairLanesToBuf(RECEIVE) failed w/rc=0x%x",
+                      "updateRepairLanesToBufMemBuf(RECEIVE) failed w/rc=0x%x",
                       (uint64_t)fapi2::current_err );
         }
 
+        FAPI_INF("Set VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MBVPD_KEYWORD_PDI, l_mBufSize);
         /*** Write the updated eRepair buffer back to Centaur FRU VPD ***/
         FAPI_TRY( setMBvpdField(
                       l_vpdRecord,
@@ -1975,6 +2183,7 @@ fapi2::ReturnCode writeRepairDataToVPDMemBuf(
 
     // Delete the buffer which has Field eRepair data
     delete[] l_retBuf;
+    delete[] l_serialBuf;
 
 fapi_try_exit:
     return fapi2::current_err;
@@ -2006,9 +2215,11 @@ fapi2::ReturnCode writeRepairDataToVPDDMI(
     fapi2::current_err                                           = fapi2::FAPI2_RC_SUCCESS;
     fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>                  l_procTarget;
 
-    uint8_t* l_retBuf   = NULL;
-    uint32_t l_bufSize  = 0;
-    FAPI_DBG(">> writeRepairDataToVPD - DMI");
+    uint8_t* l_retBuf    = NULL;
+    uint32_t l_bufSize   = 0;
+    uint8_t* l_serialBuf = NULL;
+    uint32_t l_serialNum = 0;
+    FAPI_INF(">> writeRepairDataToVPD - DMI - RxLaneSize:%d TxLaneSize:%d ", i_rxFailLanes.size(), i_txFailLanes.size());
 
     {
         // Determine the Processor target
@@ -2023,6 +2234,41 @@ fapi2::ReturnCode writeRepairDataToVPDDMI(
 
         /*** Read the data from the Module VPD ***/
 
+        // Determine the serial number to uniquely identify the proc
+        FAPI_TRY( getMvpdField(
+                      fapi2::MVPD_RECORD_VINI,
+                      fapi2::MVPD_KEYWORD_SN,
+                      l_procTarget,
+                      NULL,
+                      l_serialNum),
+                  "Serial number size read failed w/rc=0x%x",
+                  (uint64_t)fapi2::current_err );
+
+        FAPI_INF("Serial number size:0x%08x ", l_serialNum);
+
+        if( l_serialNum )
+        {
+            // Allocate memory for buffer
+            l_serialBuf = new uint8_t[l_serialNum];
+
+            // Retrieve the serial number data from the MVPD
+            FAPI_TRY( getMvpdField(
+                          fapi2::MVPD_RECORD_VINI,
+                          fapi2::MVPD_KEYWORD_SN,
+                          l_procTarget,
+                          l_serialBuf,
+                          l_serialNum),
+                      "Serial number read failed w/rc=0x%x",
+                      (uint64_t)fapi2::current_err );
+
+            FAPI_INF("Serial Number: ");
+
+            for(uint32_t i = 0; i < l_serialNum; i++)
+            {
+                FAPI_INF("%02x ", *(l_serialBuf + i));
+            }
+        }
+
         // Determine the size of the eRepair data in the VPD
         FAPI_TRY( getMvpdField(
                       l_vpdRecord,
@@ -2033,6 +2279,8 @@ fapi2::ReturnCode writeRepairDataToVPDDMI(
                   "VPD size read failed w/rc=0x%x",
                   (uint64_t)fapi2::current_err );
 
+        FAPI_INF("VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MVPD_KEYWORD_PDI, l_bufSize);
+
         if((l_bufSize == 0) ||
            ((i_vpdType == EREPAIR::EREPAIR_VPD_FIELD) &&
             (l_bufSize > EREPAIR::EREPAIR_P9_MODULE_VPD_FIELD_SIZE)) ||
@@ -2074,7 +2322,7 @@ fapi2::ReturnCode writeRepairDataToVPDDMI(
                           i_clkGroup,
                           i_txFailLanes,
                           l_retBuf),
-                      "updateRepairLanesToBuf(DRIVE) failed w/rc=0x%x",
+                      "updateRepairLanesToBufDMI(DRIVE) failed w/rc=0x%x",
                       (uint64_t)fapi2::current_err );
         }
 
@@ -2088,10 +2336,11 @@ fapi2::ReturnCode writeRepairDataToVPDDMI(
                           i_clkGroup,
                           i_rxFailLanes,
                           l_retBuf),
-                      "updateRepairLanesToBuf(RECEIVE) failed w/rc=0x%x",
+                      "updateRepairLanesToBufDMI(RECEIVE) failed w/rc=0x%x",
                       (uint64_t)fapi2::current_err );
         }
 
+        FAPI_INF("Set VPD data:RC:0x%x KW:0x%x BS:%d ", l_vpdRecord, fapi2::MVPD_KEYWORD_PDI, l_bufSize);
         /*** Write the updated eRepair buffer back to MVPD ***/
         FAPI_TRY( setMvpdField(
                       l_vpdRecord,
@@ -2105,6 +2354,7 @@ fapi2::ReturnCode writeRepairDataToVPDDMI(
 
     // Delete the buffer which has Field eRepair data
     delete[] l_retBuf;
+    delete[] l_serialBuf;
 
 fapi_try_exit:
     return fapi2::current_err;
@@ -2132,7 +2382,20 @@ fapi2::ReturnCode p9_io_erepairSetFailedLanesHwp(
 {
     fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
 
-    FAPI_INF(">> erepairSetFailedLanesHwp for XBUS");
+    FAPI_INF(">> erepairSetFailedLanesHwp for XBUS - RxLaneSize:%d TxLaneSize:%d ", i_rxFailLanes.size(),
+             i_txFailLanes.size());
+    FAPI_INF("VPD Type:%d ", i_vpdType);
+
+    for(uint8_t i = 0; (i < i_rxFailLanes.size() && i_rxFailLanes.size() != 0); i++)
+    {
+        FAPI_INF("Rx(%d):%d ", i, i_rxFailLanes[i]);
+    }
+
+    for(uint8_t i = 0; (i < i_txFailLanes.size() && i_txFailLanes.size() != 0); i++)
+    {
+        FAPI_INF("Tx(%d):%d ", i_txFailLanes[i]);
+    }
+
 
     FAPI_ASSERT(( (i_txFailLanes.size() != 0) || (i_rxFailLanes.size() != 0) ),
                 fapi2::P9_EREPAIR_NO_RX_TX_FAILED_LANES_ERR()
@@ -2145,7 +2408,7 @@ fapi2::ReturnCode p9_io_erepairSetFailedLanesHwp(
                   i_clkGroup,
                   i_txFailLanes,
                   i_rxFailLanes),
-              "p9_io_erepairSetFailedLanesHwp() failed w/rc=0x%x",
+              "writeRepairDataToVPDProc() failed w/rc=0x%x",
               (uint64_t)fapi2::current_err );
 
 fapi_try_exit:
@@ -2174,7 +2437,20 @@ fapi2::ReturnCode p9_io_erepairSetFailedLanesHwp(
 {
     fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
 
-    FAPI_INF(">> erepairSetFailedLanesHwp for MemBuf");
+    FAPI_INF(">> erepairSetFailedLanesHwp for MemBuf - RxLaneSize:%d TxLaneSize:%d ", i_rxFailLanes.size(),
+             i_txFailLanes.size());
+    FAPI_INF("VPD Type:%d ", i_vpdType);
+
+    for(uint8_t i = 0; (i < i_rxFailLanes.size() && i_rxFailLanes.size() != 0); i++)
+    {
+        FAPI_INF("Rx(%d):%d ", i, i_rxFailLanes[i]);
+    }
+
+    for(uint8_t i = 0; (i < i_txFailLanes.size() && i_txFailLanes.size() != 0); i++)
+    {
+        FAPI_INF("Tx(%d):%d ", i_txFailLanes[i]);
+    }
+
 
     FAPI_ASSERT(( (i_txFailLanes.size() != 0) || (i_rxFailLanes.size() != 0) ),
                 fapi2::P9_EREPAIR_NO_RX_TX_FAILED_LANES_ERR()
@@ -2187,7 +2463,7 @@ fapi2::ReturnCode p9_io_erepairSetFailedLanesHwp(
                   i_clkGroup,
                   i_txFailLanes,
                   i_rxFailLanes),
-              "p9_io_erepairSetFailedLanesHwp() failed w/rc=0x%x",
+              "writeRepairDataToVPDMemBuf() failed w/rc=0x%x",
               (uint64_t)fapi2::current_err );
 
 fapi_try_exit:
@@ -2216,7 +2492,19 @@ fapi2::ReturnCode p9_io_erepairSetFailedLanesHwp(
 {
     fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
 
-    FAPI_INF(">> erepairSetFailedLanesHwp for DMI");
+    FAPI_INF(">> erepairSetFailedLanesHwp for DMI - RxLaneSize:%d TxLaneSize:%d ", i_rxFailLanes.size(),
+             i_txFailLanes.size());
+    FAPI_INF("VPD Type:%d ", i_vpdType);
+
+    for(uint8_t i = 0; (i < i_rxFailLanes.size() && i_rxFailLanes.size() != 0); i++)
+    {
+        FAPI_INF("Rx(%d):%d ", i, i_rxFailLanes[i]);
+    }
+
+    for(uint8_t i = 0; (i < i_txFailLanes.size() && i_txFailLanes.size() != 0); i++)
+    {
+        FAPI_INF("Tx(%d):%d ", i_txFailLanes[i]);
+    }
 
     FAPI_ASSERT(( (i_txFailLanes.size() != 0) || (i_rxFailLanes.size() != 0) ),
                 fapi2::P9_EREPAIR_NO_RX_TX_FAILED_LANES_ERR()
@@ -2229,7 +2517,7 @@ fapi2::ReturnCode p9_io_erepairSetFailedLanesHwp(
                   i_clkGroup,
                   i_txFailLanes,
                   i_rxFailLanes),
-              "p9_io_erepairSetFailedLanesHwp() failed w/rc=0x%x",
+              "writeRepairDataToVPDDMI() failed w/rc=0x%x",
               (uint64_t)fapi2::current_err );
 
 fapi_try_exit: