Change p9a_mss_freq to work on PROC_CHIP target

Previously p9a_mss_freq ran on the MEM_PORT target, even though
the freq domain is at the PROC_CHIP level. This change will allow
DDIMMs to be binned to the same freq across the domain.
Also removes a lot of FAPI_INF messages to reduce UT log size.

Change-Id: I7d4e2ee8897fdd62c0672d96cc1731c7a14643dd
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/88736
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: HWSV CI <hwsv-ci+hostboot@us.ibm.com>
Reviewed-by: STEPHEN GLANCY <sglancy@us.ibm.com>
Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com>
Dev-Ready: Louis Stermole <stermole@us.ibm.com>
Reviewed-by: Mark Pizzutillo <mark.pizzutillo@ibm.com>
Reviewed-by: Jennifer A Stofer <stofer@us.ibm.com>
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/89672
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M Crowell <dcrowell@us.ibm.com>

7 files changed, 67 insertions, 61 deletions

diff --git a/src/import/generic/memory/lib/spd/spd_utils.C b/src/import/generic/memory/lib/spd/spd_utils.C
index bfe380dc5..38bf99577 100644
--- a/src/import/generic/memory/lib/spd/spd_utils.C
+++ b/src/import/generic/memory/lib/spd/spd_utils.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2018                             */
+/* Contributors Listed Below - COPYRIGHT 2018,2020                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -113,7 +113,7 @@ fapi2::ReturnCode get_timebases( const mss::spd::facade& i_spd_decoder,
                  "Could not find a mapped value that matched the key (%d) for %s",
                  l_spd_ftb, spd::c_str(l_target) );
 
-    FAPI_INF("MTB: %d, FTB: %d for %s", o_mtb, o_ftb, spd::c_str(l_target));
+    FAPI_DBG("MTB: %d, FTB: %d for %s", o_mtb, o_ftb, spd::c_str(l_target));
 
 fapi_try_exit:
     return fapi2::current_err;
@@ -162,7 +162,7 @@ fapi2::ReturnCode get_tckmin( const mss::spd::facade& i_spd_decoder,
 
     o_value = l_temp;
 
-    FAPI_INF("%s. tCKmin (ps): %d",
+    FAPI_DBG("%s. tCKmin (ps): %d",
              spd::c_str(l_target),
              o_value );
 
@@ -213,7 +213,7 @@ fapi2::ReturnCode get_tckmax( const mss::spd::facade& i_spd_decoder,
 
     o_value = l_temp;
 
-    FAPI_INF( "%s. tCKmax (ps): %d",
+    FAPI_DBG( "%s. tCKmax (ps): %d",
               spd::c_str(l_target),
               o_value);
 
diff --git a/src/import/generic/memory/lib/utils/count_dimm.H b/src/import/generic/memory/lib/utils/count_dimm.H
index 8f75b984b..3ceea2fab 100644
--- a/src/import/generic/memory/lib/utils/count_dimm.H
+++ b/src/import/generic/memory/lib/utils/count_dimm.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2016,2019                        */
+/* Contributors Listed Below - COPYRIGHT 2016,2020                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -55,7 +55,6 @@ inline size_t count_dimm(const fapi2::Target<T>& i_target)
     // in the case of an over-ride and there are no DIMM in the config, we want to let
     // people know. Which is how we found we needed to add this code ...
     size_t l_dimm_count = find_targets<fapi2::TARGET_TYPE_DIMM>(i_target).size();
-    FAPI_INF("%d DIMM on %s", l_dimm_count, mss::c_str(i_target));
     return l_dimm_count;
 }
 
diff --git a/src/import/generic/memory/lib/utils/freq/cas_latency.H b/src/import/generic/memory/lib/utils/freq/cas_latency.H
index 1b71481e2..0605189c2 100644
--- a/src/import/generic/memory/lib/utils/freq/cas_latency.H
+++ b/src/import/generic/memory/lib/utils/freq/cas_latency.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2016,2019                        */
+/* Contributors Listed Below - COPYRIGHT 2016,2020                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -571,7 +571,7 @@ class cas_latency
                         l_temp);
 
             o_value = l_temp;
-            FAPI_INF( "%s. tAAmin (ps): %d",
+            FAPI_DBG( "%s. tAAmin (ps): %d",
                       mss::spd::c_str(l_target),
                       o_value);
 
@@ -628,7 +628,7 @@ class cas_latency
         {
             FAPI_TRY( spd::calc_nck(i_taa, i_tck, spd::INVERSE_DDR4_CORRECTION_FACTOR, o_cas_latency) );
 
-            FAPI_INF("%s. tAA (ps): %d, tCK (ps): %d, CL (nck): %d",
+            FAPI_DBG("%s. tAA (ps): %d, tCK (ps): %d, CL (nck): %d",
                      mss::spd::c_str(iv_target),
                      i_taa,
                      i_tck,
@@ -651,8 +651,8 @@ class cas_latency
             const uint64_t l_min_cl = get_min_cl(l_cl_mask);
             const uint64_t l_max_cl = get_max_cl(l_cl_mask);
 
-            FAPI_INF("%s. min CL %lu", mss::spd::c_str(iv_target), l_min_cl);
-            FAPI_INF("%s. max CL %lu", mss::spd::c_str(iv_target), l_max_cl);
+            FAPI_DBG("%s. min CL %lu", mss::spd::c_str(iv_target), l_min_cl);
+            FAPI_DBG("%s. max CL %lu", mss::spd::c_str(iv_target), l_max_cl);
 
             for(uint64_t l_cas_latency = l_min_cl; l_cas_latency <= l_max_cl; ++l_cas_latency)
             {
@@ -688,7 +688,7 @@ class cas_latency
         {
             const bool l_found = std::binary_search(i_common_cls.begin(), i_common_cls.end(), i_cas_latency);
 
-            FAPI_INF("Found CL: %d in common CL mask: 0x%llX ? %s for %s",
+            FAPI_DBG("Found CL: %d in common CL mask: 0x%llX ? %s for %s",
                      i_cas_latency, iv_common_cl_bitmap, l_found ? "yes" : "no", mss::spd::c_str(iv_target));
 
             return l_found;
@@ -709,7 +709,7 @@ class cas_latency
             const size_t l_taa_max = (iv_is_3ds == loading::NOT_3DS) ? TAA_MAX_DDR4 : TAA_MAX_DDR4_3DS;
             const bool l_is_cl_exceeding_taa = l_cas_latency_time > l_taa_max;
 
-            FAPI_INF("%s. CL (%d) * tCK (%d) = %d > %d ? %s",
+            FAPI_DBG("%s. CL (%d) * tCK (%d) = %d > %d ? %s",
                      mss::spd::c_str(iv_target),
                      i_cas_latency,
                      i_tck,
@@ -758,7 +758,7 @@ class cas_latency
             FAPI_TRY( freq_to_ps(l_proposed_freq, io_tck),
                       "%s. Failed freq_to_ps()", mss::spd::c_str(iv_target) );
 
-            FAPI_INF("%s Supported dimm speed override %d MT/s (Clock period %d in ps)",
+            FAPI_DBG("%s Supported dimm speed override %d MT/s (Clock period %d in ps)",
                      mss::spd::c_str(iv_target), l_proposed_freq, io_tck);
 
             // Sanity check
diff --git a/src/import/generic/memory/lib/utils/freq/gen_mss_freq.H b/src/import/generic/memory/lib/utils/freq/gen_mss_freq.H
index 6ad2c7ea6..c681f2e59 100644
--- a/src/import/generic/memory/lib/utils/freq/gen_mss_freq.H
+++ b/src/import/generic/memory/lib/utils/freq/gen_mss_freq.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2018,2019                        */
+/* Contributors Listed Below - COPYRIGHT 2018,2020                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -105,7 +105,7 @@ fapi2::ReturnCode get_dimm_type(const fapi2::Target<T>& i_target,
 /// @return FAPI2_RC_SUCCESS iff ok
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-fapi2::ReturnCode callout_bad_freq_calculated(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+fapi2::ReturnCode callout_bad_freq_calculated(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
         const uint64_t i_final_freq);
 
 ///
@@ -208,7 +208,7 @@ fapi2::ReturnCode check_freq_support_vpd( const fapi2::Target<TT::PORT_TARGET_TY
 /// @return     FAPI2_RC_SUCCESS iff ok
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-inline fapi2::ReturnCode set_freq_attrs(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+inline fapi2::ReturnCode set_freq_attrs(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
                                         const std::vector<uint64_t>& i_dimm_freq)
 {
     // Find the minimum (but non-0) freq in the vector. If we see all 0's we'll write a 0. However,
@@ -245,7 +245,7 @@ fapi_try_exit:
 /// @return FAPI2_RC_SUCCESS iff okay
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-inline fapi2::ReturnCode spd_supported_freq(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+inline fapi2::ReturnCode spd_supported_freq(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
         std::vector<uint32_t>& o_supported_freqs)
 {
     uint64_t l_largest_tck = 0;
@@ -255,7 +255,17 @@ inline fapi2::ReturnCode spd_supported_freq(const fapi2::Target<TT::FREQ_TARGET_
 
     // Get cached decoder
     std::vector< mss::spd::facade > l_spd_facades;
-    FAPI_TRY( get_spd_decoder_list(i_target, l_spd_facades), "%s get decoder - spd", mss::c_str(i_target) );
+
+    for (const auto& l_port : mss::find_targets<TT::PORT_TARGET_TYPE>(i_target))
+    {
+        std::vector< mss::spd::facade > l_these_spd_facades;
+        FAPI_TRY( get_spd_decoder_list(l_port, l_these_spd_facades), "%s get decoder - spd", mss::c_str(l_port) );
+
+        for (const auto& l_spd_facade : l_these_spd_facades)
+        {
+            l_spd_facades.push_back(l_spd_facade);
+        }
+    }
 
     // Looking for the biggest application period on an MC.
     // This will further reduce supported frequencies the system can run on.
@@ -263,7 +273,7 @@ inline fapi2::ReturnCode spd_supported_freq(const fapi2::Target<TT::FREQ_TARGET_
     {
         const auto l_dimm = l_cache.get_dimm_target();
         const auto l_port = mss::find_target<TT::PORT_TARGET_TYPE>(l_dimm);
-        const auto l_port_pos = mss::relative_pos<TT::FREQ_TARGET_TYPE>(l_port);
+        const auto l_port_pos = mss::relative_pos<TT::FREQ_DOMAIN_TARGET_TYPE>(l_port);
         uint64_t l_tckmax_in_ps = 0;
         uint64_t l_tck_min_in_ps = 0;
         uint32_t l_dimm_freq = 0;
@@ -279,7 +289,7 @@ inline fapi2::ReturnCode spd_supported_freq(const fapi2::Target<TT::FREQ_TARGET_
         l_largest_tck = std::min(l_largest_tck, l_tckmax_in_ps);
 
         FAPI_TRY( mss::ps_to_freq(l_largest_tck, l_dimm_freq), "%s ps to freq %lu", mss::c_str(i_target), l_largest_tck );
-        FAPI_INF("Biggest freq supported from SPD %d MT/s for %s",
+        FAPI_DBG("Biggest freq supported from SPD %d MT/s for %s",
                  l_dimm_freq, mss::c_str(l_dimm));
 
         o_supported_freqs[l_port_pos] = std::min(l_dimm_freq, o_supported_freqs[l_port_pos]);
@@ -299,12 +309,12 @@ fapi_try_exit:
 ///
 // Pass in the syncronous target
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-fapi2::ReturnCode vpd_supported_freqs( const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+fapi2::ReturnCode vpd_supported_freqs( const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
                                        std::vector<std::vector<uint32_t>>& o_vpd_supported_freqs)
 {
     // This bitmap will keep track of the ports we visit.
     // Any we don't are not configured, so will support all frequencies in the scoreboard
-    fapi2::buffer<uint8_t> configured_ports;
+    fapi2::buffer<uint64_t> configured_ports;
 
     // Clearing output Just.In.Case
     o_vpd_supported_freqs.clear();
@@ -317,7 +327,8 @@ fapi2::ReturnCode vpd_supported_freqs( const fapi2::Target<TT::FREQ_TARGET_TYPE>
     // Just go to find target for the port level
     for( const auto& p : mss::find_targets<TT::PORT_TARGET_TYPE>(i_target) )
     {
-        const auto l_port_pos = mss::relative_pos<TT::FREQ_TARGET_TYPE>(p);
+        const auto l_port_pos = mss::relative_pos<TT::FREQ_DOMAIN_TARGET_TYPE>(p);
+
         FAPI_TRY( configured_ports.setBit(l_port_pos) );
 
         if( mss::count_dimm(p) == 0 )
@@ -342,7 +353,7 @@ fapi2::ReturnCode vpd_supported_freqs( const fapi2::Target<TT::FREQ_TARGET_TYPE>
             // Add supported freqs to our output
             if (l_supported)
             {
-                FAPI_INF("VPD supported freq added: %d for %s", freq, mss::c_str(p) );
+                FAPI_DBG("VPD supported freq added: %d for %s", freq, mss::c_str(p) );
                 o_vpd_supported_freqs[l_port_pos].push_back(freq);
             }
         }
@@ -381,7 +392,7 @@ fapi_try_exit:
 /// @return FAPI2_RC_SUCCESS iff okay
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-inline fapi2::ReturnCode find_min_dimm_freq(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+inline fapi2::ReturnCode find_min_dimm_freq(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
         const std::vector<uint32_t>& i_supported_freqs,
         std::vector<uint64_t>& o_min_dimm_freq)
 {
@@ -420,14 +431,14 @@ inline fapi2::ReturnCode find_min_dimm_freq(const fapi2::Target<TT::FREQ_TARGET_
             // Find CAS latency using JEDEC algorithm
             FAPI_TRY( l_cas_latency.find_cl(l_desired_cl, l_tCKmin), "%s failed to find a cas latency", mss::c_str(i_target) );
 
-            FAPI_INF("%s. Result from CL algorithm, CL (nck): %d, tCK (ps): %d",
+            FAPI_DBG("%s. Result from CL algorithm, CL (nck): %d, tCK (ps): %d",
                      mss::c_str(l_port), l_desired_cl, l_tCKmin);
 
             // Find dimm transfer speed from selected tCK
             FAPI_TRY( mss::ps_to_freq(l_tCKmin, l_desired_freq),
                       "%s. Failed ps_to_freq()", mss::c_str(l_port) );
 
-            FAPI_INF("DIMM speed %d from selected tCK (ps): %d for %s",
+            FAPI_DBG("DIMM speed %d from selected tCK (ps): %d for %s",
                      l_desired_freq,
                      l_tCKmin,
                      mss::c_str(l_port));
@@ -437,7 +448,7 @@ inline fapi2::ReturnCode find_min_dimm_freq(const fapi2::Target<TT::FREQ_TARGET_
         }// end else
 
         FAPI_TRY(set_CL_attr<P>(l_port, l_desired_cl), "%s. Failed set_CL_attr()", mss::c_str(l_port) );
-    } // mca
+    } // port
 
 fapi_try_exit:
     return fapi2::current_err;
@@ -452,7 +463,7 @@ fapi_try_exit:
 /// @return FAPI2_RC_SUCCESS iff okay
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-inline fapi2::ReturnCode supported_freqs(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+inline fapi2::ReturnCode supported_freqs(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
         std::vector<uint32_t>& o_freqs)
 {
     o_freqs.clear();
@@ -466,12 +477,14 @@ inline fapi2::ReturnCode supported_freqs(const fapi2::Target<TT::FREQ_TARGET_TYP
 
     // Retrieve system MRW, SPD, and VPD constraints
     FAPI_TRY( max_allowed_dimm_freq<P>(l_max_mrw_freqs.data()), "%s max_allowed_dimm_freq", mss::c_str(i_target) );
+
     FAPI_TRY( spd_supported_freq<P>(i_target, l_spd_supported_freq),
               "%s spd supported freqs", mss::c_str(i_target) );
+
     FAPI_TRY( vpd_supported_freqs<P>(i_target, l_vpd_supported_freqs),
               "%s vpd supported freqs", mss::c_str(i_target) );
 
-    // Limits the frequency by the Nimbus processor constraints (sync mode)
+    // Limits the frequency by the processor constraints (sync mode)
     FAPI_TRY( limit_freq_by_processor<P>(i_target, l_scoreboard) );
 
     // Limit frequency scoreboard according to MRW constraints
@@ -512,7 +525,7 @@ namespace check
 /// @return FAPI2_RC_SUCCESS iff okay
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-fapi2::ReturnCode final_freq(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target);
+fapi2::ReturnCode final_freq(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target);
 
 } // check nameespace
 
@@ -524,16 +537,16 @@ fapi2::ReturnCode final_freq(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target
 /// @return FAPI2_RC_SUCCESS iff okay
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-fapi2::ReturnCode generate_freq(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target)
+fapi2::ReturnCode generate_freq(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target)
 {
     std::vector<uint64_t> l_min_dimm_freq;
     std::vector<uint32_t> l_supported_freqs;
 
-    // Get supported freqs for this MCBIST
+    // Get supported freqs for this domain
     FAPI_TRY( mss::supported_freqs<P>(i_target, l_supported_freqs), "%s failed to get supported frequencies",
               mss::c_str(i_target) );
 
-    // Finds the minimum supported DIMM frequencies for this MCBIST
+    // Finds the minimum supported DIMM frequencies for this domain
     FAPI_TRY(mss::find_min_dimm_freq<P>(i_target, l_supported_freqs, l_min_dimm_freq),
              "%s. Failed find_min_dimm_freq()", mss::c_str(i_target) );
 
diff --git a/src/import/generic/memory/lib/utils/freq/mss_freq_scoreboard.H b/src/import/generic/memory/lib/utils/freq/mss_freq_scoreboard.H
index 91b89fc83..94bdcc980 100644
--- a/src/import/generic/memory/lib/utils/freq/mss_freq_scoreboard.H
+++ b/src/import/generic/memory/lib/utils/freq/mss_freq_scoreboard.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2018,2019                        */
+/* Contributors Listed Below - COPYRIGHT 2018,2020                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -161,7 +161,6 @@ class freq_scoreboard
 
                     if ( l_scoreboard_freq > i_freq_limit )
                     {
-                        FAPI_INF("Removing freq %d on port %d since it's above the limit %d", l_scoreboard_freq, i_port_pos, i_freq_limit);
                         l_port_supported_freqs[l_index] = false;
                     }
                 }
@@ -229,7 +228,6 @@ class freq_scoreboard
 
                 if (l_it == i_freq_list.end())
                 {
-                    FAPI_INF("Removing freq %d on port %d since it's not supported", iv_freq_values[l_index], i_port_pos);
                     iv_supported_port_freqs[i_port_pos][l_index] = false;
                 }
             }
@@ -313,7 +311,7 @@ class freq_scoreboard
         /// @return FAPI2_RC_SUCCESS if successful
         ///
         template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-        fapi2::ReturnCode resolve(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+        fapi2::ReturnCode resolve(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
                                   const std::vector<std::vector<uint32_t>>& i_vpd_supported_freqs,
                                   std::vector<uint8_t>& o_deconfigured,
                                   std::vector<fapi2::Target<TT::PORT_TARGET_TYPE>>& o_deconfigured_targets,
@@ -419,7 +417,7 @@ class freq_scoreboard
         /// @returh l_supported_vector return the fector of supported frequencies
         ///
         template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-        std::vector<uint64_t> count_supported_frequencies(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+        std::vector<uint64_t> count_supported_frequencies(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
                 const std::vector<fapi2::Target<TT::PORT_TARGET_TYPE>>& i_ports,
                 std::vector<uint32_t>& o_freqs)
         {
@@ -436,7 +434,7 @@ class freq_scoreboard
                 {
                     if (l_supported[l_index])
                     {
-                        FAPI_INF("%s Frequency %d is supported by port%d", mss::c_str(i_target), TT::SUPPORTED_FREQS[l_index], l_pos);
+                        FAPI_DBG("%s Frequency %d is supported by port%d", mss::c_str(i_target), TT::SUPPORTED_FREQS[l_index], l_pos);
                         ++l_support_counts[l_index];
                     }
 
@@ -444,7 +442,7 @@ class freq_scoreboard
                     // Note that deconfigured ports will support all frequencies due to the way the scoreboard is built
                     if (l_support_counts[l_index] == iv_num_ports)
                     {
-                        FAPI_INF("%s Frequency %d is supported by all ports", mss::c_str(i_target), TT::SUPPORTED_FREQS[l_index]);
+                        FAPI_DBG("%s Frequency %d is supported by all ports", mss::c_str(i_target), TT::SUPPORTED_FREQS[l_index]);
                         o_freqs.push_back(TT::SUPPORTED_FREQS[l_index]);
                     }
 
@@ -467,7 +465,7 @@ class freq_scoreboard
         /// @return FAPI2_RC_SUCCESS iff ok
         ///
         template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-        fapi2::ReturnCode deconfigure_ports(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+        fapi2::ReturnCode deconfigure_ports(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
                                             const std::vector<fapi2::Target<TT::PORT_TARGET_TYPE>>& i_ports,
                                             const uint64_t i_best_freq_index,
                                             std::vector<uint8_t>& o_deconfigured,
@@ -483,7 +481,7 @@ class freq_scoreboard
                                                     i_ports.end(),
                                                     [l_pos]( const fapi2::Target<TT::PORT_TARGET_TYPE>& i_rhs) -> bool
                 {
-                    return (mss::relative_pos<TT::FREQ_TARGET_TYPE>(i_rhs) == l_pos);
+                    return (mss::relative_pos<TT::FREQ_DOMAIN_TARGET_TYPE>(i_rhs) == l_pos);
                 });
 
                 // If we didn't find an port for a given position, there wasn't one configured there
@@ -494,7 +492,7 @@ class freq_scoreboard
 
                 // and call it out if it doesn't support the selected freq
                 const auto& p = *l_it_port;
-                FAPI_INF("Checking if port %d (%s) supports common frequency", l_pos, mss::c_str(p));
+                FAPI_DBG("Checking if port %d (%s) supports common frequency", l_pos, mss::c_str(p));
 
                 if (!iv_supported_port_freqs[l_pos][i_best_freq_index])
                 {
@@ -532,7 +530,7 @@ class freq_scoreboard
 /// @return FAPI2_RC_SUCCESS iff ok
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-fapi2::ReturnCode limit_freq_by_processor(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+fapi2::ReturnCode limit_freq_by_processor(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
         freq_scoreboard& io_scoreboard);
 
 ///
@@ -547,7 +545,7 @@ fapi2::ReturnCode limit_freq_by_processor(const fapi2::Target<TT::FREQ_TARGET_TY
 /// have a path for testing
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-inline fapi2::ReturnCode limit_freq_by_mrw(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+inline fapi2::ReturnCode limit_freq_by_mrw(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
         const std::vector<uint32_t>& i_max_mrw_freqs,
         freq_scoreboard& io_scoreboard)
 {
@@ -574,13 +572,13 @@ inline fapi2::ReturnCode limit_freq_by_mrw(const fapi2::Target<TT::FREQ_TARGET_T
                  mss::c_str(i_target),
                  i_max_mrw_freqs.size());
 
-    FAPI_INF("attribute supported max allowed dimm freqs %d %d %d %d %d for %s",
+    FAPI_DBG("attribute supported max allowed dimm freqs %d %d %d %d %d for %s",
              i_max_mrw_freqs[0], i_max_mrw_freqs[1], i_max_mrw_freqs[2], i_max_mrw_freqs[3], i_max_mrw_freqs[4],
              mss::c_str(i_target));
 
     for( const auto& p : mss::find_targets<TT::PORT_TARGET_TYPE>(i_target) )
     {
-        const auto l_port_pos = mss::relative_pos<TT::FREQ_TARGET_TYPE>(p);
+        const auto l_port_pos = mss::relative_pos<TT::FREQ_DOMAIN_TARGET_TYPE>(p);
         const auto l_dimms = mss::find_targets<fapi2::TARGET_TYPE_DIMM>(p);
         const uint64_t l_dimms_on_port = l_dimms.size();
 
@@ -618,7 +616,7 @@ inline fapi2::ReturnCode limit_freq_by_mrw(const fapi2::Target<TT::FREQ_TARGET_T
             // If we have an LRDIMM, it's treated as a one rank DIMM from the memory controller's perspective
             l_rank_index = l_dimm_type == TT::LRDIMM_TYPE ? 0 : l_num_master_ranks - 1;
             l_index = l_indexes[l_dimms_on_port - 1][l_rank_index];
-            FAPI_INF("%s is %s. rank_index%u index:%u", spd::c_str(d), l_dimm_type == TT::LRDIMM_TYPE ? "LRDIMM" : "RDIMM",
+            FAPI_DBG("%s is %s. rank_index%u index:%u", spd::c_str(d), l_dimm_type == TT::LRDIMM_TYPE ? "LRDIMM" : "RDIMM",
                      l_rank_index, l_index);
 
             FAPI_ASSERT( (l_index < NUM_MAX_FREQS),
@@ -631,7 +629,7 @@ inline fapi2::ReturnCode limit_freq_by_mrw(const fapi2::Target<TT::FREQ_TARGET_T
                          l_num_master_ranks,
                          mss::c_str(d));
 
-            FAPI_INF("%s rank config %d drop %d yields max freq attribute index of %d (%d)",
+            FAPI_DBG("%s rank config %d drop %d yields max freq attribute index of %d (%d)",
                      mss::c_str(d), l_num_master_ranks, l_dimms_on_port,
                      l_indexes[l_dimms_on_port - 1][l_rank_index],
                      i_max_mrw_freqs[l_index] );
@@ -661,7 +659,7 @@ fapi_try_exit:
 /// have a path for testing
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-fapi2::ReturnCode limit_freq_by_vpd(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+fapi2::ReturnCode limit_freq_by_vpd(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
                                     const std::vector<std::vector<uint32_t>>& i_hw_freqs,
                                     freq_scoreboard& io_scoreboard)
 {
@@ -675,7 +673,7 @@ fapi2::ReturnCode limit_freq_by_vpd(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i
 
     for( const auto& p : mss::find_targets<TT::PORT_TARGET_TYPE>(i_target) )
     {
-        const auto l_port_pos = mss::relative_pos<TT::FREQ_TARGET_TYPE>(p);
+        const auto l_port_pos = mss::relative_pos<TT::FREQ_DOMAIN_TARGET_TYPE>(p);
         const auto& l_port_freqs = i_hw_freqs[l_port_pos];
 
         // This is the list of supported frequencies for VPD
@@ -715,13 +713,13 @@ fapi_try_exit:
 /// have a path for testing
 ///
 template<mss::proc_type P, typename TT = mss::frequency_traits<P>>
-fapi2::ReturnCode limit_freq_by_spd(const fapi2::Target<TT::FREQ_TARGET_TYPE>& i_target,
+fapi2::ReturnCode limit_freq_by_spd(const fapi2::Target<TT::FREQ_DOMAIN_TARGET_TYPE>& i_target,
                                     const std::vector<uint32_t>& i_hw_freqs,
                                     freq_scoreboard& io_scoreboard)
 {
     for( const auto& p : mss::find_targets<TT::PORT_TARGET_TYPE>(i_target) )
     {
-        const auto l_port_pos = mss::relative_pos<TT::FREQ_TARGET_TYPE>(p);
+        const auto l_port_pos = mss::relative_pos<TT::FREQ_DOMAIN_TARGET_TYPE>(p);
 
         // Remove any frequencies that aren't in this port's list from the scoreboard
         io_scoreboard.remove_freqs_above_limit(l_port_pos, i_hw_freqs);
diff --git a/src/import/generic/memory/lib/utils/power_thermal/gen_throttle.H b/src/import/generic/memory/lib/utils/power_thermal/gen_throttle.H
index c65ffb637..0b15b6ab2 100644
--- a/src/import/generic/memory/lib/utils/power_thermal/gen_throttle.H
+++ b/src/import/generic/memory/lib/utils/power_thermal/gen_throttle.H
@@ -591,8 +591,6 @@ fapi2::ReturnCode throttle<MC, TT>::power_regulator_throttles ()
     double  l_databus_dimm_max[TT::DIMMS_PER_PORT] = {};
     double  l_calc_databus_port_idle[TT::DIMMS_PER_PORT] = {TT::IDLE_UTIL, TT::IDLE_UTIL};
 
-    FAPI_INF("Starting power regulator throttles for %s", mss::c_str(iv_target));
-
     //Decide utilization for each dimm based off of dimm count and power slopes
     FAPI_TRY( calc_databus(iv_databus_port_max, l_databus_dimm_max),
               "Failed to calculate each DIMMs' percentage of dram databus utilization for target %s, max port databus is %d",
@@ -1072,7 +1070,7 @@ fapi2::ReturnCode throttle<MC, TT>::calc_split_util(
     //assumptions slot <= port, l_count_dimms <=2
     if (i_util_slot * l_count_dimms > i_util_port)
     {
-        FAPI_INF("In mss::power_thermal::calc_split i_util_slot is %f, i_util_port is %f, l_count_dimms is %d for %s",
+        FAPI_INF("i_util_slot is %f, i_util_port is %f, l_count_dimms is %d for %s",
                  i_util_slot,
                  i_util_port,
                  l_count_dimms,
diff --git a/src/import/generic/memory/lib/utils/voltage/gen_mss_volt.H b/src/import/generic/memory/lib/utils/voltage/gen_mss_volt.H
index d84c97dbe..9ff39109e 100644
--- a/src/import/generic/memory/lib/utils/voltage/gen_mss_volt.H
+++ b/src/import/generic/memory/lib/utils/voltage/gen_mss_volt.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2018                             */
+/* Contributors Listed Below - COPYRIGHT 2018,2020                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -115,8 +115,6 @@ inline fapi2::ReturnCode setup_voltage_rail_values(const fapi2::Target<TT::SPD_T
     FAPI_TRY( (mss::set_voltage_attributes<M, D>(l_voltage_target, l_dram_voltages)),
               "Failed to set volt attributes for %s", mss::c_str(l_voltage_target) );
 
-    FAPI_INF("%s End setup_voltage_rail_values", mss::c_str(i_target));
-
 fapi_try_exit:
     return fapi2::current_err;
 }