Extend FFDC class for host interface

Change-Id: I0097f9ed7c7fdb2f5c8a483f0a54b8831ec3a09a
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/39985
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: AMIT J. TENDOLKAR <amit.tendolkar@in.ibm.com>
Reviewed-by: Sachin Gupta <sgupta2m@in.ibm.com>

4 files changed, 149 insertions, 39 deletions

diff --git a/src/sbefw/sbeFFDC.C b/src/sbefw/sbeFFDC.C
index 09a381dd..7f1203c3 100644
--- a/src/sbefw/sbeFFDC.C
+++ b/src/sbefw/sbeFFDC.C
@@ -31,12 +31,6 @@
 #include "sbe_build_info.H"
 #include "sbeglobals.H"
 
-/*
- * @bried updateUserDataHeader - method to update user data fields
- *                               based on input config
- *
- * @param[in] i_fieldsConfig   - input fields configuration
- */
 void SbeFFDCPackage::updateUserDataHeader(uint32_t i_fieldsConfig)
 {
     //Update the user data header with dump fields configuration
@@ -57,24 +51,10 @@ void SbeFFDCPackage::updateUserDataHeader(uint32_t i_fieldsConfig)
     }
 }
 
-/*
- * @brief sendOverFIFO           - method to pack and send SBE internal FFDC
- *                                 only if isSendInternalFFDCSet() is true
- *                                 over FIFO interface
- * @param[in] i_hdr              - Fifo response header
- * @param[in] i_fieldsConfig     - bitmap indicating the field
- *                                 to be sent in FFDC
- * @param[out] o_bytesSent       - number of bytes sent
- * @param[in] i_skipffdcBitCheck - Boolean to indicate whether
- *                                 ffdc bit should be checked or not.
- *                                 By default it is false.
- *
- * @return                       - SBE secondary RC
- */
 uint32_t SbeFFDCPackage::sendOverFIFO(const sbeRespGenHdr_t &i_hdr,
-                                      uint32_t i_fieldsConfig,
+                                      const uint32_t i_fieldsConfig,
                                       uint32_t &o_bytesSent,
-                                      bool i_skipffdcBitCheck)
+                                      const bool i_skipffdcBitCheck)
 {
     #define SBE_FUNC "sendOverFIFO"
     SBE_ENTER(SBE_FUNC);
@@ -167,3 +147,105 @@ uint32_t SbeFFDCPackage::sendOverFIFO(const sbeRespGenHdr_t &i_hdr,
     return rc;
     #undef SBE_FUNC
 }
+
+uint32_t SbeFFDCPackage::sendOverHostIntf(const sbeSbe2PsuRespHdr_t &i_hdr,
+                                          const uint32_t i_fieldsConfig,
+                                          sbeMemAccessInterface *i_pMemInterface,
+                                          uint32_t i_allocatedSize,
+                                          const bool i_skipffdcBitCheck)
+{
+    #define SBE_FUNC "sendOverHostIntf"
+    SBE_ENTER(SBE_FUNC);
+    uint32_t rc = SBE_SEC_OPERATION_SUCCESSFUL;
+    uint32_t length = 0;
+    bool isLastAccess = false;
+    fapi2::ReturnCode fapiRc = fapi2::FAPI2_RC_SUCCESS;
+
+    do
+    {
+        //check if SBE internal FFDC should be generated
+        if(!i_skipffdcBitCheck &&
+           (SbeRegAccess::theSbeRegAccess().isSendInternalFFDCSet()
+            == false))
+        {
+            SBE_INFO(SBE_FUNC" isSendInternalFFDCSet()=false, "
+                    "not generating SBE InternalFFDC");
+            rc = SBE_SEC_OPERATION_SUCCESSFUL;
+            break;
+        }
+
+        // update the primary and secondary status
+        iv_sbeFFDCDataHeader.primaryStatus = i_hdr.primStatus;
+        iv_sbeFFDCDataHeader.secondaryStatus = i_hdr.secStatus;
+        iv_sbeFFDCDataHeader.fwCommitID = SBE_COMMIT_ID;
+        // Set failed command information
+        iv_sbeFFDCHeader.setCmdInfo(i_hdr.seqID, i_hdr.cmdClass, i_hdr.command);
+        //Update the user data header with dump fields configuration
+        updateUserDataHeader(i_fieldsConfig);
+
+        //Send FFDC package header
+        length = sizeof(iv_sbeFFDCHeader);
+        MEM_AVAILABLE_CHECK(i_allocatedSize, length, isLastAccess);
+        fapiRc = i_pMemInterface->accessWithBuffer(&iv_sbeFFDCHeader, length,
+                                                    isLastAccess);
+        if(fapiRc != fapi2::FAPI2_RC_SUCCESS)
+        {
+            rc = SBE_SEC_GENERIC_FAILURE_IN_EXECUTION;
+            break;
+        }
+
+        //Send FFDC user data header
+        length = sizeof(iv_sbeFFDCDataHeader);
+        MEM_AVAILABLE_CHECK(i_allocatedSize, length, isLastAccess);
+        fapiRc = i_pMemInterface->accessWithBuffer(&iv_sbeFFDCDataHeader,
+                                                   length,
+                                                   isLastAccess);
+        if(fapiRc != fapi2::FAPI2_RC_SUCCESS)
+        {
+            rc = SBE_SEC_GENERIC_FAILURE_IN_EXECUTION;
+            break;
+        }
+
+        //Send FFDC user data blobs
+        for(auto &sbeFFDCUserData:sbeFFDCUserDataArray)
+        {
+            if(sbeFFDCUserData.userDataId.fieldId & i_fieldsConfig)
+            {
+                //Send User data identifer and length
+                length = sizeof(sbeFFDCUserDataIdentifier_t);
+                MEM_AVAILABLE_CHECK(i_allocatedSize, length, isLastAccess);
+                fapiRc = i_pMemInterface->accessWithBuffer(
+                                            &sbeFFDCUserData.userDataId,
+                                            length,
+                                            isLastAccess);
+                if(fapiRc != fapi2::FAPI2_RC_SUCCESS)
+                {
+                    rc = SBE_SEC_GENERIC_FAILURE_IN_EXECUTION;
+                    break;
+                }
+
+                //Send User data
+                length = sbeFFDCUserData.userDataId.fieldLen;
+                MEM_AVAILABLE_CHECK(i_allocatedSize, length, isLastAccess);
+                isLastAccess = isLastAccess ||
+                                 (&sbeFFDCUserData ==
+                                    &sbeFFDCUserDataArray[NUM_USER_DATA_ELE-1]);
+                fapiRc = i_pMemInterface->accessWithBuffer(
+                                            sbeFFDCUserData.userDataPtr,
+                                            length,
+                                            isLastAccess);
+                if(fapiRc != fapi2::FAPI2_RC_SUCCESS)
+                {
+                    rc = SBE_SEC_GENERIC_FAILURE_IN_EXECUTION;
+                    break;
+                }
+            }
+        }
+    } while(false);
+    SBE_INFO(SBE_FUNC" [%d] bytes sent",
+                            SBE_GLOBAL->hostFFDCAddr.size - i_allocatedSize);
+
+    SBE_EXIT(SBE_FUNC);
+    return rc;
+    #undef SBE_FUNC
+}
diff --git a/src/sbefw/sbeFFDC.H b/src/sbefw/sbeFFDC.H
index 4c9448e3..1b652f75 100644
--- a/src/sbefw/sbeFFDC.H
+++ b/src/sbefw/sbeFFDC.H
@@ -30,6 +30,8 @@
 #include "pk_trace.h"
 #include "sbeFFDCType.H"
 #include "sbeSpMsg.H"
+#include "sbeHostUtils.H"
+#include "sbeMemAccessInterface.H"
 
 //PIBMEM attribute dump
 extern G_sbe_attrs_t G_sbe_attrs;
@@ -50,6 +52,8 @@ const sbeFFDCUserData_t sbeFFDCUserDataArray[] =
                                                 },
                                               };
 
+#define NUM_USER_DATA_ELE (sizeof(sbeFFDCUserDataArray)/sizeof(sbeFFDCUserData_t))
+
 //SBE internal FFDC package class
 class SbeFFDCPackage
 {
@@ -108,27 +112,30 @@ public:
      * @return                       - SBE secondary RC
      */
     uint32_t sendOverFIFO(const sbeRespGenHdr_t &i_hdr,
-                          uint32_t i_fieldsConfig,
+                          const uint32_t i_fieldsConfig,
                           uint32_t &o_bytesSent,
-                          bool i_skipffdcBitCheck = false);
-    /* TODO via RTC:150786
-     * @brief sendOverHOST - method to pack and send SBE internal FFDC
-     *                       only if isSendInternalFFDCSet() is true
-     *                       over HOST interface
-     *
-     * @param[in] i_primStatus   - Primary status of Chip op
-     * @param[in] i_secStatus    - Secondary status of Chip op
-     * @param[in] i_fieldsConfig - bitmap indicating the field
-     *                             to be sent in FFDC
+                          const bool i_skipffdcBitCheck = false);
+
+    /* @brief sendOverHostIntf       - method to pack and send SBE internal FFDC
+     *                                 only if isSendInternalFFDCSet() is true
+     *                                 over HOST interface
      *
-     * @param[out] o_bytesSent - number of bytes sent
+     * @param[in] i_hdr              - Host response header
+     * @param[in] i_fieldsConfig     - bitmap indicating the field
+     *                                 to be sent in FFDC
+     * @param[in] i_pMemInterface    - pointer to memory interface object
+     * @param[in] i_allocatedSize    - size allocated for FFDC
+     * @param[in] i_skipffdcBitCheck - Boolean to indicate whether
+     *                                 ffdc bit should be checked or not.
+     *                                 By default it is false.
      *
-     * @return - SBE secondary RC
+     * @return                       - SBE secondary RC
      */
-    //uint32_t sendOverHOST(uint32_t i_primStatus,
-    //                      uint32_t i_secStatus,
-    //                      uint32_t i_fieldsConfig,
-    //                      uint32_t &o_bytesSent) {};
+    uint32_t sendOverHostIntf(const sbeSbe2PsuRespHdr_t &i_hdr,
+                              const uint32_t i_fieldsConfig,
+                              sbeMemAccessInterface *i_pMemInterface,
+                              uint32_t i_allocatedSize,
+                              const bool i_skipffdcBitCheck = false);
 };
 
 #endif //__SBE_FFDC_H
diff --git a/src/sbefw/sbeMemAccessInterface.C b/src/sbefw/sbeMemAccessInterface.C
index a0e597f5..1dde9faf 100644
--- a/src/sbefw/sbeMemAccessInterface.C
+++ b/src/sbefw/sbeMemAccessInterface.C
@@ -32,6 +32,17 @@ p9_adu_setup_FP_t p9_adu_setup_hwp = &p9_adu_setup;
 
 using namespace fapi2;
 
+void MEM_AVAILABLE_CHECK(uint32_t &io_available_len,uint32_t &io_len_to_send,bool &io_is_last_access)
+{
+    if(io_len_to_send > io_available_len)
+    {
+        SBE_INFO(SBE_FUNC" Allocated memory is less, truncating the access");
+        io_len_to_send = io_available_len;
+        io_is_last_access = true;
+    }
+    io_available_len -= io_len_to_send;
+}
+
 ReturnCode sbeMemAccessInterface::setup()
 {
 #define SBE_FUNC "sbeMemAccessInterface::setup"
diff --git a/src/sbefw/sbeMemAccessInterface.H b/src/sbefw/sbeMemAccessInterface.H
index 8d828e1b..6e268b01 100644
--- a/src/sbefw/sbeMemAccessInterface.H
+++ b/src/sbefw/sbeMemAccessInterface.H
@@ -51,6 +51,16 @@ enum sbeMemAccessInterfaceType
     SBE_MEM_ACCESS_ADU,
 };
 
+// Helper functions
+/*
+ * @brief function to check if the length to send can be
+ * accomodated in the available memory, else make it a last
+ * access on the interface
+ */
+void MEM_AVAILABLE_CHECK(uint32_t &io_available_len,
+                         uint32_t &io_len_to_send,
+                         bool &io_is_last_access);
+
 class sbeMemAccessInterface
 {
     private: