Change memdiags interfaces for PRD

  Both of the current sf_read() APIs can now be combined into one API:
    The i_end parameter is no longer needed. The command should always stop
    at the end of the slave rank on error, unless the workaround is place.
    In which case, the command should stop immediately on error.
    The i_address parameter will be optional. By default the start address
    will be the first address of the first port (or all port in broadcast
    mode). Otherwise, start on the address given.

  For the targeted_scrub() API:
    A new parameter will be added to specify if the command should be run
    on a slave rank boundary or a master rank boundary.
    The i_end parameter will need to default to not stop on error. Otherwise,
    PRD will input to stop immediately when necessary.

Change-Id: If5d87af93aed8732277f8f769ae4d090b2bfea4f
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/32335
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com>
Reviewed-by: Zane C. Shelley <zshelle@us.ibm.com>
Reviewed-by: JACOB L. HARVEY <jlharvey@us.ibm.com>
Reviewed-by: Louis Stermole <stermole@us.ibm.com>
Reviewed-by: Jennifer A. Stofer <stofer@us.ibm.com>
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/32339
Reviewed-by: Hostboot Team <hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

Author: brs332

src/import/chips/p9/procedures/hwp/memory/lib/mcbist/memdiags.C

@@ -225,15 +225,15 @@ fapi2::ReturnCode operation<TARGET_TYPE_MCBIST>::single_port_init()
     }
 
     // The address should have the port and DIMM noted in it. All we need to do is calculate the
-    // remainder of the address, assuming the caller didn't setup an end address already.
-    // *INDENT-OFF*
-    if (iv_const.iv_end_address == 0)
+    // remainder of the address
+    if (iv_is_sim)
     {
-        iv_is_sim ?
-            iv_const.iv_start_address.get_sim_end_address(iv_const.iv_end_address) :
-            iv_const.iv_start_address.get_range<mss::mcbist::address::DIMM>(iv_const.iv_end_address);
+        iv_const.iv_start_address.get_sim_end_address(iv_const.iv_end_address);
+    }
+    else if (iv_const.iv_end_address == 0)
+    {
+        iv_const.iv_start_address.get_range<mss::mcbist::address::DIMM>(iv_const.iv_end_address);
     }
-    // *INDENT-ON*
 
     // Configure the address range
     FAPI_TRY( mss::mcbist::config_address_range0(iv_target, iv_const.iv_start_address, iv_const.iv_end_address) );
@@ -426,52 +426,26 @@ fapi_try_exit:
     return fapi2::current_err;
 }
 
-///
-/// @brief Super Fast Read All - used to run superfast read on all memory behind the target
-/// @note Uses broadcast mode if possible
-/// @param[in] i_target the target behind which all memory should be read
-/// @param[in] i_stop stop conditions
-/// @param[in] i_end whether to end, and where - defaults to immediate (stop after failed address)
-/// @return FAPI2_RC_SUCCESS iff everything ok
-/// @note The function is asynchronous, and the caller should be looking for a done attention
-///
-template<>
-fapi2::ReturnCode sf_read( const fapi2::Target<TARGET_TYPE_MCBIST>& i_target,
-                           const stop_conditions& i_stop,
-                           const end_boundary i_end )
-{
-    FAPI_INF("superfast read start");
-
-    fapi2::ReturnCode l_rc;
-    constraints l_const(i_stop, speed::LUDICROUS, i_end, mss::mcbist::address());
-    sf_read_operation<TARGET_TYPE_MCBIST> l_read_op(i_target, l_const, l_rc);
-
-    FAPI_ASSERT( l_rc == FAPI2_RC_SUCCESS,
-                 fapi2::MSS_MEMDIAGS_SUPERFAST_READ_FAILED_TO_INIT().set_TARGET(i_target),
-                 "Unable to initialize the MCBIST engine for a sf read %s", mss::c_str(i_target) );
-
-    return l_read_op.execute();
-
-fapi_try_exit:
-    return fapi2::current_err;
-}
-
 ///
 /// @brief Super Fast Read to End of Port - used to run superfast read on all memory behind the target
+/// @tparam T the fapi2::TargetType of the target
 /// @param[in] i_target the target behind which all memory should be read
 /// @param[in] i_stop stop conditions
-/// @param[in] i_address mcbist::address representing the port, dimm, rank
-/// @param[in] i_end whether to end, and where - defaults to immediate (stop after failed address)
+/// @param[in] i_address mcbist::address representing the address from which to start.
+//    Defaults to the first address behind the target
+/// @param[in] i_end whether to end, and where
+///   Defaults to stop after slave rank
 /// @return FAPI2_RC_SUCCESS iff everything ok
 /// @note The function is asynchronous, and the caller should be looking for a done attention
+/// @note The address is often the port, dimm, rank but this is not enforced in the API.
 ///
 template<>
 fapi2::ReturnCode sf_read( const fapi2::Target<TARGET_TYPE_MCBIST>& i_target,
                            const stop_conditions& i_stop,
                            const mss::mcbist::address& i_address,
-                           const end_boundary i_end )
+                           const end_boundary i_end)
 {
-    FAPI_INF("superfast read - end of port");
+    FAPI_INF("superfast read - start");
 
     fapi2::ReturnCode l_rc;
     constraints l_const(i_stop, speed::LUDICROUS, i_end, i_address);
@@ -523,29 +497,24 @@ fapi_try_exit:
 /// @brief Scrub - targeted scrub all memory behind the target
 /// @param[in] i_target the target behind which all memory should be scrubbed
 /// @param[in] i_stop stop conditions
-/// @param[in] i_speed the speed to scrub
-/// @param[in] i_address mcbist::address representing the port, dimm, rank
-/// @param[in] i_end whether to end, and where
+/// @param[in] i_start_address mcbist::address representing the address from which to start.
+/// @param[in] i_end_address mcbist::address representing the address at which to end.
+/// @param[in] i_end whether to end, and where (defaults to not stop on error)
 /// @return FAPI2_RC_SUCCESS iff everything ok
 /// @note The function is asynchronous, and the caller should be looking for a done attention
+/// @note The caller can use the address range functions to calculate the end address as needed
 ///
 template<>
 fapi2::ReturnCode targeted_scrub( const fapi2::Target<TARGET_TYPE_MCBIST>& i_target,
                                   const stop_conditions& i_stop,
-                                  const speed i_speed,
-                                  const mss::mcbist::address& i_address,
+                                  const mss::mcbist::address& i_start_address,
+                                  const mss::mcbist::address& i_end_address,
                                   const end_boundary i_end )
 {
     FAPI_INF("targeted scrub");
 
-    if (i_end == end_boundary::NONE)
-    {
-        FAPI_ERR("targeted scrub must have end boundaries");
-        return FAPI2_RC_INVALID_PARAMETER;
-    }
-
     fapi2::ReturnCode l_rc;
-    constraints l_const(i_stop, i_speed, i_end, i_address);
+    constraints l_const(i_stop, speed::LUDICROUS, i_end, i_start_address, i_end_address);
     targeted_scrub_operation<TARGET_TYPE_MCBIST> l_op(i_target, l_const, l_rc);
 
     FAPI_ASSERT( l_rc == FAPI2_RC_SUCCESS,

src/import/chips/p9/procedures/hwp/memory/lib/mcbist/memdiags.H

@@ -318,35 +318,24 @@ fapi2::ReturnCode sf_init( const fapi2::Target<T>& i_target,
                            const uint64_t i_pattern = PATTERN_0 );
 
 ///
-/// @brief Super Fast Read All - used to run superfast read on all memory behind the target
-/// @note Uses broadcast mode if possible
-/// @param[in] i_target the target behind which all memory should be read
-/// @param[in] i_stop stop conditions
-/// @param[in] i_end whether to end, and where - defaults to stop after slave rank
-/// @return FAPI2_RC_SUCCESS iff everything ok
-/// @note The function is asynchronous, and the caller should be looking for a done attention
-///
-template< fapi2::TargetType T >
-fapi2::ReturnCode sf_read( const fapi2::Target<T>& i_target,
-                           const stop_conditions& i_stop,
-                           const end_boundary i_end = end_boundary::STOP_AFTER_SLAVE_RANK );
-
-///
-/// @brief Super Fast Read to End of Port - used to run superfast read on all memory behind the target
+/// @brief Super Fast Read - used to run superfast read on all memory behind the target
+/// Determines ability to braodcast to all ports behind a target, does so if possible.
 /// @tparam T the fapi2::TargetType of the target
 /// @param[in] i_target the target behind which all memory should be read
 /// @param[in] i_stop stop conditions
 /// @param[in] i_address mcbist::address representing the address from which to start.
-/// @param[in] i_end whether to end, and where - defaults to immediate (stop after failed address)
+//    Defaults to the first address behind the target
+/// @param[in] i_end whether to end, and where
+///   Defaults to stop after slave rank
 /// @return FAPI2_RC_SUCCESS iff everything ok
 /// @note The function is asynchronous, and the caller should be looking for a done attention
 /// @note The address is often the port, dimm, rank but this is not enforced in the API.
 ///
 template< fapi2::TargetType T >
 fapi2::ReturnCode sf_read( const fapi2::Target<T>& i_target,
                            const stop_conditions& i_stop,
-                           const mss::mcbist::address& i_address,
-                           const end_boundary i_end = end_boundary::STOP_AFTER_ADDRESS );
+                           const mss::mcbist::address& i_address = mss::mcbist::address(),
+                           const end_boundary i_end = end_boundary::STOP_AFTER_SLAVE_RANK );
 
 ///
 /// @brief Scrub - continuous scrub all memory behind the target
@@ -369,7 +358,8 @@ fapi2::ReturnCode background_scrub( const fapi2::Target<T>& i_target,
 /// @param[in] i_target the target behind which all memory should be scrubbed
 /// @param[in] i_stop stop conditions
 /// @param[in] i_speed the speed to scrub
-/// @param[in] i_address mcbist::address representing the address from which to start.
+/// @param[in] i_start_address mcbist::address representing the address from which to start.
+/// @param[in] i_end_address mcbist::address representing the address at which to end.
 /// @param[in] i_end whether to end, and where
 /// @return FAPI2_RC_SUCCESS iff everything ok
 /// @note The function is asynchronous, and the caller should be looking for a done attention
@@ -378,8 +368,8 @@ fapi2::ReturnCode background_scrub( const fapi2::Target<T>& i_target,
 template< fapi2::TargetType T >
 fapi2::ReturnCode targeted_scrub( const fapi2::Target<T>& i_target,
                                   const stop_conditions& i_stop,
-                                  const speed i_speed,
-                                  const mss::mcbist::address& i_address,
+                                  const mss::mcbist::address& i_start_address,
+                                  const mss::mcbist::address& i_end_address,
                                   const end_boundary i_end );
 
 ///

src/import/chips/p9/procedures/hwp/memory/lib/mcbist/settings.H

@@ -755,16 +755,21 @@ struct constraints
     ///
     /// @brief constraints constructor
     /// @param[in] i_stop stop conditions
+    /// @param[in] i_speed the speed at which to run
+    /// @param[in] i_end_boundary the place to stop on error
     /// @param[in] i_start_address address to start from
+    /// @param[in] i_end_address address to end at (optional, run to end)
     ///
     constraints( const stop_conditions& i_stop,
                  const speed i_speed,
                  const end_boundary i_end_boundary,
-                 const address& i_start_address ):
+                 const address& i_start_address,
+                 const address& i_end_address = mcbist::address(0) ):
         constraints(i_stop, i_start_address)
     {
         iv_end_boundary = i_end_boundary;
         iv_speed = i_speed;
+        iv_end_address = i_end_address;
         FAPI_INF("setting up constraints with end boundary %d and speed 0x%x", i_end_boundary, i_speed);
     }