Adds LRDIMM coarse class

Change-Id: I6677f026134b2ef7898315671c7002acf01727f3
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/72028
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Reviewed-by: STEPHEN GLANCY <sglancy@us.ibm.com>
Reviewed-by: ANDRE A. MARIN <aamarin@us.ibm.com>
Reviewed-by: Jennifer A. Stofer <stofer@us.ibm.com>
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/103318
Reviewed-by: Daniel M Crowell <dcrowell@us.ibm.com>
Tested-by: Daniel M Crowell <dcrowell@us.ibm.com>

Author: Li Meng

src/import/chips/p9/procedures/hwp/memory/lib/phy/mss_lrdimm_training_helper.H

@@ -153,6 +153,127 @@ class mrep_dwl_result
 
 };
 
+///
+/// @class coarse_recorder
+/// @brief Records results on a per-nibble level for coarse calibration algorithms
+/// @note Each vector's array position represents one nibble
+/// @note Each bit in an element represents whether the data compared or mis-compared at that delay
+/// @note Coarse calibration algorithms refer to sub-cycle calibration algorithms (MRD_COARSE and MWD_COARSE)
+///
+struct coarse_recorder
+{
+    public:
+        static constexpr uint64_t CLEAN = 0;
+
+        // Default delay value 2 is for 0 nck
+        static constexpr uint8_t DEFAULT_DELAYS = 2;
+        static constexpr uint8_t DEFAULT_TO_PASS = 0xF8;
+        static constexpr uint8_t PASSING_RESULT = 0x0f;
+        static constexpr uint8_t FAILING_RESULT = 0x00;
+
+        ///
+        /// @brief Default constructor
+        ///
+        coarse_recorder() :
+            iv_results(DEFAULT_TO_PASS),
+            iv_final_delay(DEFAULT_DELAYS),
+            iv_invalid_data_count(CLEAN)
+        {}
+
+        ///
+        /// @brief constructor
+        /// @param[in] i_results results from the COARSE run
+        /// @param[in] i_final final delay chosen by the COARSE run
+        /// @param[in] i_invalid_count invalid data count from COARSE run
+        ///
+        coarse_recorder(const fapi2::buffer<uint8_t> i_results, const uint8_t i_final_delay,
+                        const uint64_t i_invalid_count = CLEAN) :
+            iv_results(i_results),
+            iv_final_delay(i_final_delay),
+            iv_invalid_data_count(i_invalid_count)
+        {}
+
+        // Records a given bit per nibble per delay
+        // 1 = compare
+        // 0 = miscompare
+        // Fun thing is the LRDIMM spec sends out 1's for compares, so no enums needed
+        fapi2::buffer<uint8_t> iv_results;
+        uint8_t iv_final_delay;
+        uint64_t iv_invalid_data_count;
+
+        ///
+        /// @brief Adds results to the recorder
+        /// @param[in] i_delay the current delay
+        /// @param[in] i_result the result for the current nibble - right aligned
+        /// @return fapi2::ReturnCode fapi2::FAPI2_RC_SUCCESS iff ok
+        ///
+        fapi2::ReturnCode add_results(const uint8_t i_delay, const uint8_t i_result)
+        {
+            bool l_passed = false;
+
+            // 0 is not passed
+            if(i_result == FAILING_RESULT)
+            {
+                l_passed = false;
+            }
+
+            // F is passed - only if we had already passed at this location
+            else if(i_result == PASSING_RESULT)
+            {
+                l_passed = iv_results.getBit(i_delay);
+            }
+
+            // Anything else is an error case
+            else
+            {
+                l_passed = false;
+                FAPI_DBG("delay%u has a invalid result of 0x%02x", i_delay, i_result);
+                iv_invalid_data_count++;
+            }
+
+            FAPI_TRY(iv_results.writeBit(l_passed, i_delay));
+
+        fapi_try_exit:
+            return fapi2::current_err;
+        }
+
+
+        ///
+        /// @brief Finds the final result for the whole buffer
+        /// @param[in] i_target the DIMM target for the data
+        /// @param[in] i_dimm_rank the DIMM rank on which to set the delay
+        /// @return fapi2::ReturnCode fapi2::FAPI2_RC_SUCCESS iff ok
+        ///
+        fapi2::ReturnCode find_final_delay(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+                                           const uint64_t i_dimm_rank)
+        {
+            // uint8_t() is to make the bit count compile as it's expecting an integral type
+            // buffers don't count as an integral type as they're classes
+            const uint8_t l_results(iv_results);
+
+            // If we never find a passing region, just log an error and set a 2
+            if(iv_results == 0)
+            {
+                iv_final_delay = 2;
+                FAPI_ERR("%s rank%u found no passing regions setting to an offset of 0 data:0x%02x", mss::c_str(i_target), i_dimm_rank,
+                         iv_results);
+                return fapi2::FAPI2_RC_SUCCESS;
+            }
+
+            // Otherwise, find our first passing region
+            // We should really only have 1, so let's log an error if that's not the case
+            if(bit_count(l_results) > 1)
+            {
+                FAPI_ERR("%s rank%u found more than one passing region data:0x%02x", mss::c_str(i_target), i_dimm_rank, iv_results);
+            }
+
+            iv_final_delay = first_bit_set(l_results);
+
+            return fapi2::FAPI2_RC_SUCCESS;
+        }
+};
+
+
 ///
 /// @class fine_recorder
 /// @brief Records results on a per-bit level for fine calibration algorithms

src/import/chips/p9/procedures/hwp/memory/lib/phy/mss_mrd_coarse.C

@@ -176,7 +176,7 @@ fapi_try_exit:
 fapi2::ReturnCode mrd_coarse::analyze_results(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
         const uint64_t i_dimm_rank,
         const uint8_t i_delay,
-        std::vector<std::pair<recorder, recorder>>& io_results) const
+        std::vector<std::pair<coarse_recorder, coarse_recorder>>& io_results) const
 {
     uint8_t l_buffer = 0;
     const auto& l_mca = mss::find_target<fapi2::TARGET_TYPE_MCA>(i_target);
@@ -239,7 +239,7 @@ fapi_try_exit:
 ///
 uint32_t mrd_coarse::flag_invalid_data( const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
                                         const uint8_t i_rank,
-                                        const std::vector<std::pair<recorder, recorder>>& i_recorders,
+                                        const std::vector<std::pair<coarse_recorder, coarse_recorder>>& i_recorders,
                                         uint64_t& o_invalid_count) const
 {
     o_invalid_count = 0;
@@ -263,8 +263,8 @@ uint32_t mrd_coarse::flag_invalid_data( const fapi2::Target<fapi2::TARGET_TYPE_D
 
         // Updates the bitmap
         o_invalid_count += l_recorder.first.iv_invalid_data_count + l_recorder.second.iv_invalid_data_count;
-        append_nibble_flags(l_recorder.first.iv_invalid_data_count != recorder::CLEAN,
-                            l_recorder.second.iv_invalid_data_count != recorder::CLEAN,
+        append_nibble_flags(l_recorder.first.iv_invalid_data_count != coarse_recorder::CLEAN,
+                            l_recorder.second.iv_invalid_data_count != coarse_recorder::CLEAN,
                             l_per_nibble_flags);
 
         l_buffer++;
@@ -283,7 +283,7 @@ uint32_t mrd_coarse::flag_invalid_data( const fapi2::Target<fapi2::TARGET_TYPE_D
 ///
 fapi2::ReturnCode mrd_coarse::callout_invalid_data( const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
         const uint8_t i_rank,
-        const std::vector<std::pair<recorder, recorder>>& i_recorders) const
+        const std::vector<std::pair<coarse_recorder, coarse_recorder>>& i_recorders) const
 {
     // Per nibble invalid data - bitmap
     // A bitmap is used to simplify the error callouts
@@ -315,7 +315,7 @@ fapi_try_exit:
 ///
 uint32_t mrd_coarse::flag_not_one_passing_region( const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
         const uint8_t i_rank,
-        const std::vector<std::pair<recorder, recorder>>& i_recorders) const
+        const std::vector<std::pair<coarse_recorder, coarse_recorder>>& i_recorders) const
 {
     uint8_t l_buffer = 0;
 
@@ -356,7 +356,7 @@ uint32_t mrd_coarse::flag_not_one_passing_region( const fapi2::Target<fapi2::TAR
 ///
 fapi2::ReturnCode mrd_coarse::callout_not_one_passing_region( const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
         const uint8_t i_rank,
-        const std::vector<std::pair<recorder, recorder>>& i_recorders) const
+        const std::vector<std::pair<coarse_recorder, coarse_recorder>>& i_recorders) const
 {
     // Per nibble weird data and no transition flags - bitmap
     // A bitmap is used to simplify the error callouts
@@ -382,7 +382,7 @@ fapi_try_exit:
 ///
 fapi2::ReturnCode mrd_coarse::find_final_results(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
         const uint64_t i_dimm_rank,
-        std::vector<std::pair<recorder, recorder>>& io_results) const
+        std::vector<std::pair<coarse_recorder, coarse_recorder>>& io_results) const
 {
     for(auto& l_buffer_result : io_results)
     {
@@ -407,7 +407,7 @@ fapi_try_exit:
 ///
 fapi2::ReturnCode mrd_coarse::set_final_delays_helper(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
         const uint64_t i_dimm_rank,
-        const std::vector<std::pair<recorder, recorder>>& i_results,
+        const std::vector<std::pair<coarse_recorder, coarse_recorder>>& i_results,
         mss::ddr4::pba::commands& o_container) const
 {
     uint8_t l_buffer = 0;
@@ -470,7 +470,7 @@ fapi_try_exit:
 ///
 fapi2::ReturnCode mrd_coarse::set_final_delays(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
         const uint64_t i_dimm_rank,
-        const std::vector<std::pair<recorder, recorder>>& i_results) const
+        const std::vector<std::pair<coarse_recorder, coarse_recorder>>& i_results) const
 {
 
     mss::ddr4::pba::commands l_container;
@@ -542,7 +542,7 @@ fapi2::ReturnCode mrd_coarse::run( const fapi2::Target<fapi2::TARGET_TYPE_MCA>&
         const auto l_dimm_rank = mss::index(l_rank);
 
         // Creates our structure of data for the recorders
-        std::vector<std::pair<recorder, recorder>> l_results(MAX_LRDIMM_BUFFERS);
+        std::vector<std::pair<coarse_recorder, coarse_recorder>> l_results(MAX_LRDIMM_BUFFERS);
 
         // Gets our DIMM from this rank
         fapi2::Target<fapi2::TARGET_TYPE_DIMM> l_dimm;