PRD: add L2/L3 Line Delete/Column Repair FFDC to eLog

Change-Id: I7b7533723fce668119ea0975d2967af2f0209a2d
RTC: 121304
Reviewed-on: http://gfw160.aus.stglabs.ibm.com:8080/gerrit/15324
Reviewed-by: Zane Shelley <zshelle@us.ibm.com>
Tested-by: Jenkins Server
Reviewed-on: http://gfw160.aus.stglabs.ibm.com:8080/gerrit/15742
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

4 files changed, 252 insertions, 0 deletions

diff --git a/src/usr/diag/prdf/common/plugins/prdfLogParse_common.C b/src/usr/diag/prdf/common/plugins/prdfLogParse_common.C
index c24e1e3ae..c1718491c 100644
--- a/src/usr/diag/prdf/common/plugins/prdfLogParse_common.C
+++ b/src/usr/diag/prdf/common/plugins/prdfLogParse_common.C
@@ -385,6 +385,14 @@ bool parseCaptureData( void * i_buffer, uint32_t i_buflen,
             {
                 parseTodFfdcData( sigData, sigDataSize, i_parser );
             }
+            else if ( Util::hashString(LD_CR_FFDC::L2TITLE) == sigId )
+            {
+                 parseL2LdCrFfdc( sigData, sigDataSize, i_parser );
+            }
+            else if ( Util::hashString(LD_CR_FFDC::L3TITLE) == sigId )
+            {
+                 parseL3LdCrFfdc( sigData, sigDataSize, i_parser );
+            }
             else if ( (0 != sigDataSize) && (sizeof(uint64_t) >= sigDataSize) )
             {
                 // Print one reg/line if the data size <= 8 bytes
diff --git a/src/usr/diag/prdf/common/plugins/prdfParserEnums.H b/src/usr/diag/prdf/common/plugins/prdfParserEnums.H
index 94ae251b6..9c4313cbc 100644
--- a/src/usr/diag/prdf/common/plugins/prdfParserEnums.H
+++ b/src/usr/diag/prdf/common/plugins/prdfParserEnums.H
@@ -184,6 +184,125 @@ namespace SLW_FFDC_DATA
 
 } // namespace SLW_FFDC_DATA
 
+// LineDelete/ColumnRepair FFDC
+namespace LD_CR_FFDC
+{
+    static const char * const L2TITLE = "L2_LD_COLRPR_FFDC";
+    static const char * const L3TITLE = "L3_LD_COLRPR_FFDC";
+
+    struct L2LdCrFfdc
+    {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+        uint32_t L2LDcnt        : 4;
+        uint32_t L2LDallowed    : 1;
+        uint32_t L2LDMaxAllowed : 4;
+        uint32_t L2CRMaxAllowed : 4;
+        uint32_t L2CRPresent    : 4;
+        uint32_t L2reserved1    :15;
+
+        uint32_t L2errMember    : 3;
+        uint32_t L2errDW        : 3;
+        uint32_t L2errMacro     : 2;
+        uint32_t L2errBank      : 1;
+        uint32_t L2errOWSelect  : 1;
+        uint32_t L2errBitLine   : 4;
+        uint32_t L2errIsTopSA   : 1;
+        uint32_t L2errAddress   :10;
+        uint32_t L2reserved2    : 7;
+
+        L2LdCrFfdc():
+           L2LDcnt(0), L2LDallowed(0), L2LDMaxAllowed(0),
+           L2CRMaxAllowed(0), L2CRPresent(0), L2reserved1(0),
+           L2errMember(0), L2errDW(0), L2errMacro(0),
+           L2errBank(0), L2errOWSelect(0), L2errBitLine(0),
+           L2errIsTopSA(0), L2errAddress(0), L2reserved2(0)
+        {}
+#else
+        uint32_t L2reserved1    :15;
+        uint32_t L2CRPresent    : 4;
+        uint32_t L2CRMaxAllowed : 4;
+        uint32_t L2LDMaxAllowed : 4;
+        uint32_t L2LDallowed    : 1;
+        uint32_t L2LDcnt        : 4;
+
+        uint32_t L2reserved2    : 7;
+        uint32_t L2errAddress   :10;
+        uint32_t L2errIsTopSA   : 1;
+        uint32_t L2errBitLine   : 4;
+        uint32_t L2errOWSelect  : 1;
+        uint32_t L2errBank      : 1;
+        uint32_t L2errMacro     : 2;
+        uint32_t L2errDW        : 3;
+        uint32_t L2errMember    : 3;
+
+        L2LdCrFfdc():
+           L2reserved1(0), L2CRPresent(0), L2CRMaxAllowed(0),
+           L2LDMaxAllowed(0), L2LDallowed(0), L2LDcnt(0),
+           L2reserved2(0),L2errAddress(0), L2errIsTopSA(0),
+           L2errBitLine(0), L2errOWSelect(0), L2errBank(0),
+           L2errMacro(0), L2errDW(0), L2errMember(0)
+        {}
+#endif
+
+    };
+
+    struct L3LdCrFfdc
+    {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+        uint32_t L3LDcnt        : 4;
+        uint32_t L3LDallowed    : 1;
+        uint32_t L3LDMaxAllowed : 4;
+        uint32_t L3CRMaxAllowed : 4;
+        uint32_t L3CRPresent    : 4;
+        uint32_t L3reserved1    :15;
+
+        uint32_t L3errMember    : 3;
+        uint32_t L3errDW        : 3;
+        uint32_t L3errBank      : 1;
+        uint32_t L3errDataOut   : 1;
+        uint32_t L3errAddress   : 4;
+        uint32_t L3errIO        : 1;
+        uint32_t L3errRow       :10;
+        uint32_t L3reserved2    : 9;
+
+        L3LdCrFfdc():
+           L3LDcnt(0), L3LDallowed(0), L3LDMaxAllowed(0),
+           L3CRMaxAllowed(0), L3CRPresent(0),
+           L3reserved1(0), L3errMember(0), L3errDW(0),
+           L3errBank(0), L3errDataOut(0), L3errAddress(0),
+           L3errIO(0), L3errRow(0), L3reserved2(0)
+        {}
+#else
+        uint32_t L3reserved1    :15;
+        uint32_t L3CRPresent    : 4;
+        uint32_t L3CRMaxAllowed : 4;
+        uint32_t L3LDMaxAllowed : 4;
+        uint32_t L3LDallowed    : 1;
+        uint32_t L3LDcnt        : 4;
+
+        uint32_t L3reserved2    : 9;
+        uint32_t L3errRow       :10;
+        uint32_t L3errIO        : 1;
+        uint32_t L3errAddress   : 4;
+        uint32_t L3errDataOut   : 1;
+        uint32_t L3errBank      : 1;
+        uint32_t L3errDW        : 3;
+        uint32_t L3errMember    : 3;
+
+        L3LdCrFfdc():
+           L3reserved1(0), L3CRPresent(0), L3CRMaxAllowed(0),
+           L3LDMaxAllowed(0), L3LDallowed(0), L3LDcnt(0),
+           L3reserved2(0), L3errRow(0), L3errIO(0),
+           L3errAddress(0), L3errDataOut(0), L3errBank(0),
+           L3errDW(0), L3errMember(0)
+        {}
+#endif
+
+    };
+
+
+} // namespace LD_CR_FFDC
+
 #ifdef PRDF_HOSTBOOT_ERRL_PLUGIN
 } // end namespace HOSTBOOT
 #endif
diff --git a/src/usr/diag/prdf/common/plugins/prdfProcLogParse.C b/src/usr/diag/prdf/common/plugins/prdfProcLogParse.C
index b377e4917..8910f9e43 100644
--- a/src/usr/diag/prdf/common/plugins/prdfProcLogParse.C
+++ b/src/usr/diag/prdf/common/plugins/prdfProcLogParse.C
@@ -169,6 +169,113 @@ bool parseTodFfdcData(  uint8_t * i_buffer, uint32_t i_buflen,
     return o_rc;
 }
 
+//------------------------------------------------------------------------------
+
+bool parseL2LdCrFfdc( uint8_t * i_buffer, uint32_t i_buflen,
+                      ErrlUsrParser & i_parser )
+{
+    bool o_rc = true;
+
+    const char * lines = "---------------------------------------------";
+    i_parser.PrintString( LD_CR_FFDC::L2TITLE, lines );
+
+    do
+    {
+        if ( NULL == i_buffer ) { o_rc = false; break; }
+
+        if ( i_buflen < sizeof(LD_CR_FFDC::L2LdCrFfdc) )
+            { o_rc = false; break; }
+
+        LD_CR_FFDC::L2LdCrFfdc ldcrffdc;
+        memcpy( &ldcrffdc, i_buffer, sizeof(LD_CR_FFDC::L2LdCrFfdc));
+
+        i_parser.PrintNumber( "   L2 LD Counts", "%d", ldcrffdc.L2LDcnt );
+        i_parser.PrintBool(   "   L2 LD Allowed",
+                                              0 != ldcrffdc.L2LDallowed );
+        i_parser.PrintNumber( "   L2 LD Max Allowed", "%d",
+                                              ldcrffdc.L2LDMaxAllowed );
+        i_parser.PrintNumber( "   L2 CR Max Allowed", "%d",
+                                              ldcrffdc.L2CRMaxAllowed );
+        i_parser.PrintNumber( "   L2 CR Present", "%d",
+                                              ldcrffdc.L2CRPresent );
+
+        i_parser.PrintNumber( "   L2 Error Member", "%d",
+                                               ldcrffdc.L2errMember );
+        i_parser.PrintNumber( "   L2 Error DW", "%d", ldcrffdc.L2errDW );
+        i_parser.PrintNumber( "   L2 Error Macro", "%d",
+                                               ldcrffdc.L2errMacro );
+        i_parser.PrintNumber( "   L2 Error Bank", "%d",
+                                               ldcrffdc.L2errBank );
+        i_parser.PrintNumber( "   L2 Error OW Select", "%d",
+                                               ldcrffdc.L2errOWSelect );
+        i_parser.PrintNumber( "   L2 Error Bit Line", "%d",
+                                               ldcrffdc.L2errBitLine );
+        i_parser.PrintBool(   "   L2 Error Is Top SA",
+                                               0 != ldcrffdc.L2errIsTopSA );
+        i_parser.PrintNumber( "   L2 Error Address", "%d",
+                                               ldcrffdc.L2errAddress );
+
+    } while (0);
+
+    if ( !o_rc && i_buffer )
+    {
+        i_parser.PrintHexDump(i_buffer, i_buflen);
+    }
+
+    return o_rc;
+}
+
+//------------------------------------------------------------------------------
+
+bool parseL3LdCrFfdc( uint8_t * i_buffer, uint32_t i_buflen,
+                      ErrlUsrParser & i_parser )
+{
+    bool o_rc = true;
+
+    const char * lines = "---------------------------------------------";
+    i_parser.PrintString( LD_CR_FFDC::L3TITLE, lines );
+
+    do
+    {
+        if ( NULL == i_buffer ) { o_rc = false; break; }
+
+        if ( i_buflen < sizeof(LD_CR_FFDC::L3LdCrFfdc) )
+            { o_rc = false; break; }
+
+        LD_CR_FFDC::L3LdCrFfdc ldcrffdc;
+        memcpy( &ldcrffdc, i_buffer, sizeof(LD_CR_FFDC::L3LdCrFfdc));
+
+        i_parser.PrintNumber( "   L3 LD Counts", "%d", ldcrffdc.L3LDcnt );
+        i_parser.PrintBool(   "   L3 LD Allowed",
+                                               0 != ldcrffdc.L3LDallowed );
+        i_parser.PrintNumber( "   L3 LD Max Allowed", "%d",
+                                                ldcrffdc.L3LDMaxAllowed );
+        i_parser.PrintNumber( "   L3 CR Max Allowed", "%d",
+                                                ldcrffdc.L3CRMaxAllowed );
+        i_parser.PrintNumber( "   L3 CR Present", "%d",
+                                                ldcrffdc.L3CRPresent );
+
+        i_parser.PrintNumber( "   L3 Error Member", "%d",
+                                                ldcrffdc.L3errMember );
+        i_parser.PrintNumber( "   L3 Error DW", "%d", ldcrffdc.L3errDW );
+        i_parser.PrintNumber( "   L3 Error Bank", "%d", ldcrffdc.L3errBank );
+        i_parser.PrintNumber( "   L3 Error Data Out", "%d",
+                                                ldcrffdc.L3errDataOut );
+        i_parser.PrintNumber( "   L3 Error Address", "%d",
+                                                ldcrffdc.L3errAddress );
+        i_parser.PrintNumber( "   L3 Error IO", "%d", ldcrffdc.L3errIO );
+        i_parser.PrintNumber( "   L3 Error Row", "%d", ldcrffdc.L3errRow );
+
+    } while (0);
+
+    if ( !o_rc && i_buffer )
+    {
+        i_parser.PrintHexDump(i_buffer, i_buflen);
+    }
+
+    return o_rc;
+}
+
 } // namespace FSP/HOSTBBOT
 } // end namespace PRDF
 
diff --git a/src/usr/diag/prdf/common/plugins/prdfProcLogParse.H b/src/usr/diag/prdf/common/plugins/prdfProcLogParse.H
index b6d8f0cb6..af6f27666 100644
--- a/src/usr/diag/prdf/common/plugins/prdfProcLogParse.H
+++ b/src/usr/diag/prdf/common/plugins/prdfProcLogParse.H
@@ -55,6 +55,24 @@ bool parseSlwFfdcData( uint8_t * i_buffer, uint32_t i_buflen,
 bool parseTodFfdcData( uint8_t * i_buffer, uint32_t i_buflen,
                        ErrlUsrParser & i_parser );
 
+/**
+ * @brief Parses the L2 Line Delete/Column Repair section.
+ * @param i_buffer The data buffer.
+ * @param i_buflen The buffer length.
+ * @param i_parser The error log parser.
+ */
+bool parseL2LdCrFfdc( uint8_t * i_buffer, uint32_t i_buflen,
+                      ErrlUsrParser & i_parser );
+
+/**
+ * @brief Parses the L3 Line Delete/Column Repair section.
+ * @param i_buffer The data buffer.
+ * @param i_buflen The buffer length.
+ * @param i_parser The error log parser.
+ */
+bool parseL3LdCrFfdc( uint8_t * i_buffer, uint32_t i_buflen,
+                      ErrlUsrParser & i_parser );
+
 } // namespace FSP/HOSTBBOT
 } // end namespace PRDF