Updates exp SPD check to use MFG, height, and size

Picked from  https://rchgit01.rchland.ibm.com/gerrit1/#/c/104520/

Change-Id: I75700f54546937586cb019f3e024698999f512a6
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/104709
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: PPE CI <ppe-ci+hostboot@us.ibm.com>
Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com>
Dev-Ready: STEPHEN GLANCY <sglancy@us.ibm.com>
Reviewed-by: Mark Pizzutillo <mark.pizzutillo@ibm.com>
Reviewed-by: Louis Stermole <stermole@us.ibm.com>
Reviewed-by: Edgar R Cordero <ecordero@us.ibm.com>
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/104733
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>

Author: sglancy6

src/import/chips/p9a/procedures/hwp/memory/lib/plug_rules/p9a_plug_rules.C

@@ -281,71 +281,107 @@ namespace check
 {
 
 ///
-/// @brief Check that we recognize DDIMM module manufacturing ID
+/// @brief Check that we recognize SPD lookup key and return the SPD versions associated with the key
 /// @param[in] i_target dimm target
-/// @param[in] i_module_mfg_id DIMM module manufacturing ID
-/// @param[out] o_latest_combined_rev latest SPD combined revision
+/// @param[in] i_key the SPD lookup key to be used to grab the combined revisions
+/// @param[out] o_minimum_combined_rev minimum SPD combined revisions
+/// @param[out] o_latest_combined_rev latest SPD combined revisions
 /// @return fapi2::FAPI2_RC_SUCCESS if okay. A non-SUCCESS return will also produce an informational log
 ///
-fapi2::ReturnCode module_mfg_id(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
-                                const uint16_t i_module_mfg_id,
-                                uint16_t& o_latest_combined_rev)
+fapi2::ReturnCode spd_revision_key(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+                                   const spd_lookup_key& i_key,
+                                   uint16_t& o_minimum_combined_rev,
+                                   uint16_t& o_latest_combined_rev)
 {
     // Check that we can find the ID in our latest revision list
-    FAPI_ASSERT( mss::find_value_from_key(LATEST_SPD_COMBINED_REV, i_module_mfg_id, o_latest_combined_rev),
-                 fapi2::MSS_UNKNOWN_DIMM_MODULE_MFG_ID()
+    FAPI_ASSERT( mss::find_value_from_key(MINIMUM_SPD_KEY_COMBINED_REV, i_key, o_minimum_combined_rev),
+                 fapi2::MSS_UNKNOWN_DIMM_SPD_KEY()
                  .set_DIMM_TARGET(i_target)
-                 .set_MODULE_MFG_ID(i_module_mfg_id),
-                 "%s DDIMM has unrecognized module manufacturing ID (0x%04X)",
-                 mss::c_str(i_target), i_module_mfg_id );
+                 .set_MODULE_MFG_ID(i_key.iv_module_mfg_id)
+                 .set_DIMM_HEIGHT(i_key.iv_dimm_height)
+                 .set_DIMM_SIZE(i_key.iv_dimm_size),
+                 "%s DDIMM has unrecognized key MFG_ID:0x%04X Height:%u Size:%u for minimum SPD rev",
+                 mss::c_str(i_target), i_key.iv_module_mfg_id, i_key.iv_dimm_height, i_key.iv_dimm_size );
+
+    FAPI_ASSERT( mss::find_value_from_key(LATEST_SPD_KEY_COMBINED_REV, i_key, o_latest_combined_rev),
+                 fapi2::MSS_UNKNOWN_DIMM_SPD_KEY()
+                 .set_DIMM_TARGET(i_target)
+                 .set_MODULE_MFG_ID(i_key.iv_module_mfg_id)
+                 .set_DIMM_HEIGHT(i_key.iv_dimm_height)
+                 .set_DIMM_SIZE(i_key.iv_dimm_size),
+                 "%s DDIMM has unrecognized key MFG_ID:0x%04X Height:%u Size:%u for latest SPD rev",
+                 mss::c_str(i_target), i_key.iv_module_mfg_id, i_key.iv_dimm_height, i_key.iv_dimm_size );
 
     return fapi2::FAPI2_RC_SUCCESS;
 
 fapi_try_exit:
     // Log the error as recovered - we want this error to be informational
     fapi2::logError(fapi2::current_err, fapi2::FAPI2_ERRL_SEV_RECOVERED);
     fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
-    return fapi2::RC_MSS_UNKNOWN_DIMM_MODULE_MFG_ID;
+    return fapi2::RC_MSS_UNKNOWN_DIMM_SPD_KEY;
 }
 
 ///
-/// @brief Check DDIMM SPD revision and content revision versus latest supported
+/// @brief Check DDIMM SPD revision and content revision versus minimum supported
 /// @param[in] i_target dimm target
-/// @param[in] i_spd_rev SPD revision
-/// @param[in] i_spd_content_rev SPD content revision
-/// @param[in] i_latest_combined_rev latest SPD combined revision
+/// @param[in] i_spd_combined_revision the combined SPD revision and content
+/// @param[in] i_min_combined_rev SPD minimum combined revision information
 /// @return fapi2::FAPI2_RC_SUCCESS if okay. A non-SUCCESS return will also produce an informational log
 /// @note The return code from this function is only used in unit tests.
 ///
-fapi2::ReturnCode spd_combined_revision(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
-                                        const uint8_t i_spd_rev,
-                                        const uint8_t i_spd_content_rev,
-                                        const uint16_t i_latest_combined_rev)
+fapi2::ReturnCode spd_minimum_combined_revision(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+        const uint16_t i_spd_combined_rev,
+        const uint16_t i_min_combined_rev)
 {
-    // Assemble the SPD combined revision
-    // We simply put the SPD revision before the content revision
-    fapi2::buffer<uint16_t> l_spd_combined_revision;
-    l_spd_combined_revision.insertFromRight<0, BITS_PER_BYTE>(i_spd_rev)
-    .insertFromRight<BITS_PER_BYTE, BITS_PER_BYTE>(i_spd_content_rev);
 
     // Check the combined revision
-    if(l_spd_combined_revision < i_latest_combined_rev)
+    FAPI_ASSERT( i_spd_combined_rev >= i_min_combined_rev,
+                 fapi2::MSS_UNSUPPORTED_SPD_COMBINED_REVISION()
+                 .set_DIMM_TARGET(i_target)
+                 .set_SPD_COMBINED_REVISION(i_spd_combined_rev)
+                 .set_MINIMUM_FUNCTIONAL_SPD_COMBINED_REVISION(i_min_combined_rev),
+                 "%s DDIMM has an unsupported SPD combined revision and needs to be updated (0x%04X < 0x%04X)",
+                 mss::c_str(i_target), i_spd_combined_rev, i_min_combined_rev );
+
+    return fapi2::FAPI2_RC_SUCCESS;
+
+fapi_try_exit:
+    // Log the error as recovered - we want this error to be informational
+    fapi2::logError(fapi2::current_err, fapi2::FAPI2_ERRL_SEV_RECOVERED);
+    fapi2::current_err = fapi2::FAPI2_RC_SUCCESS;
+    return fapi2::RC_MSS_UNSUPPORTED_SPD_COMBINED_REVISION;
+}
+
+///
+/// @brief Check DDIMM SPD revision and content revision versus latest supported
+/// @param[in] i_target dimm target
+/// @param[in] i_spd_combined_revision the combined SPD revision and content
+/// @param[in] i_latest_combined_rev latest SPD combined revision information
+/// @return fapi2::FAPI2_RC_SUCCESS if okay. A non-SUCCESS return will also produce an informational log
+/// @note The return code from this function is only used in unit tests.
+///
+fapi2::ReturnCode spd_latest_combined_revision(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+        const uint16_t i_spd_combined_rev,
+        const uint16_t i_latest_combined_rev)
+{
+    // Check the combined revision
+    if(i_spd_combined_rev < i_latest_combined_rev)
     {
         // For the lab, we just want to log these as informational errors
 #ifndef __HOSTBOOT_MODULE
         FAPI_INF("%s DDIMM has non-current SPD combined revision and could be updated (0x%04X < 0x%04X)",
-                 mss::c_str(i_target), l_spd_combined_revision, i_latest_combined_rev );
+                 mss::c_str(i_target), i_spd_combined_rev, i_latest_combined_rev );
         // Return a bad RC here for unit test confirmation
         return fapi2::RC_MSS_NON_CURRENT_SPD_COMBINED_REVISION;
 #else
         // For hostboot, we want to generate an informational error log
         FAPI_ASSERT( false,
                      fapi2::MSS_NON_CURRENT_SPD_COMBINED_REVISION()
                      .set_DIMM_TARGET(i_target)
-                     .set_SPD_COMBINED_REVISION(l_spd_combined_revision)
+                     .set_SPD_COMBINED_REVISION(i_spd_combined_rev)
                      .set_LATEST_SPD_COMBINED_REVISION(i_latest_combined_rev),
                      "%s DDIMM has non-current SPD combined revision and could be updated (0x%04X < 0x%04X)",
-                     mss::c_str(i_target), l_spd_combined_revision, i_latest_combined_rev );
+                     mss::c_str(i_target), i_spd_combined_rev, i_latest_combined_rev );
 #endif
     }
 
@@ -378,9 +414,11 @@ fapi2::ReturnCode ddimm_spd_revision(const fapi2::Target<fapi2::TARGET_TYPE_MEM_
 
     for(const auto& l_dimm : mss::find_targets<fapi2::TARGET_TYPE_DIMM>(i_target))
     {
-        uint16_t l_latest_combined_rev = 0;
         uint8_t l_dimm_type = 0;
-        uint16_t l_module_mfg_id = 0;
+        uint16_t l_min_combined_rev = 0;
+        uint16_t l_latest_combined_rev = 0;
+        spd_lookup_key l_key(l_dimm, l_rc);
+        FAPI_TRY(l_rc, "%s failed to build spd_lookup_key", mss::c_str(l_dimm));
 
         FAPI_TRY( mss::attr::get_dimm_type(l_dimm, l_dimm_type) );
 
@@ -391,32 +429,37 @@ fapi2::ReturnCode ddimm_spd_revision(const fapi2::Target<fapi2::TARGET_TYPE_MEM_
             continue;
         }
 
-        FAPI_TRY( mss::attr::get_module_mfg_id(l_dimm, l_module_mfg_id) );
-
-        // First make sure we can get the SPD content revision using the module manufacturing ID
+        // First make sure we can get the SPD combined revision using the key
         // This is not necessarily a hard fail, so don't bomb out, but we have to skip the SPD revision checks.
-        l_rc = check::module_mfg_id(l_dimm, l_module_mfg_id, l_latest_combined_rev);
+        l_rc = check::spd_revision_key(l_dimm, l_key, l_min_combined_rev, l_latest_combined_rev);
 
         if (l_rc != fapi2::FAPI2_RC_SUCCESS)
         {
-            FAPI_INF("Skipping SPD revision plug rule check on %s because it has an unrecognized module manufacturing ID 0x%04X",
-                     mss::c_str(i_target), l_module_mfg_id);
+            FAPI_INF("Skipping SPD revision plug rule check on %s because it has an unrecognized SPD key MFG_ID:0x%04X Height:%u Size:%u",
+                     mss::c_str(i_target), l_key.iv_module_mfg_id, l_key.iv_dimm_height, l_key.iv_dimm_size);
             continue;
         }
 
-        // Now check the base SPD revision
-        FAPI_ASSERT( (MIN_FUNCTIONAL_SPD_REV <= l_spd_rev),
-                     fapi2::MSS_UNSUPPORTED_SPD_REVISION()
-                     .set_DIMM_TARGET(l_dimm)
-                     .set_SPD_REVISION(l_spd_rev)
-                     .set_MINIMUM_FUNCTIONAL_SPD_REVISION(MIN_FUNCTIONAL_SPD_REV),
-                     "%s DDIMM has unsupported SPD revision and needs to be updated (0x%02X < 0x%02X)",
-                     mss::c_str(l_dimm), l_spd_rev, MIN_FUNCTIONAL_SPD_REV );
-
-        // Finally check the SPD content revision
-        // Don't bother checking the return code here because this check only produces informational logs
-        // (and the RC is only used for unit tests)
-        check::spd_combined_revision(l_dimm, l_spd_rev, l_spd_content_rev, l_latest_combined_rev);
+        {
+            // Assemble the SPD combined revision
+            // We simply put the SPD revision before the content revision
+            fapi2::buffer<uint16_t> l_spd_combined_revision;
+            l_spd_combined_revision.insertFromRight<0, BITS_PER_BYTE>(l_spd_rev)
+            .insertFromRight<BITS_PER_BYTE, BITS_PER_BYTE>(l_spd_content_rev);
+
+            // Now check the minimum SPD combined revision
+            // Note: skipping target trace here as the 4th variable appears to cause issues w/ FAPI_TRY
+            // The DIMM target should be called out in the combined revision code
+            // We do want to callout the key here, so we know what type of DIMM failed
+            FAPI_TRY( check::spd_minimum_combined_revision(l_dimm, l_spd_combined_revision, l_min_combined_rev),
+                      "SPD min rev check failed key MFG_ID:0x%04X Height:%u Size:%u",
+                      l_key.iv_module_mfg_id, l_key.iv_dimm_height, l_key.iv_dimm_size );
+
+            // Finally check the latest SPD combined revision
+            // Don't bother checking the return code here because this check only produces informational logs
+            // (and the RC is only used for unit tests)
+            check::spd_latest_combined_revision(l_dimm, l_spd_combined_revision, l_latest_combined_rev);
+        }
     }
 
 fapi_try_exit:

src/import/chips/p9a/procedures/hwp/memory/lib/plug_rules/p9a_plug_rules.H

@@ -88,27 +88,6 @@ struct spd_lookup_key
     bool operator!=(const spd_lookup_key& i_rhs) const;
 };
 
-/// @note This is the oldest functional DDIMM SPD revision
-///       any DIMMs with older SPD will be called out
-static const uint8_t MIN_FUNCTIONAL_SPD_REV = 0x03;
-
-/// @note These are the latest DDIMM SPD combined revisions
-///       combined revision is the SPD revision and the SPD content revision
-///       any DIMMs with older SPD will generate an error
-///       The first byte is the major revision
-///               any updates to this are usually new bytes and will require code updates
-///       The second byte is the content revision
-///               updates to this byte are most likely values and it's less likely that code will need to be updated
-/// @note When adding new vendors, THIS NEEDS TO BE IN SORTED ORDER BY VENDOR ID ENCODING
-static const std::vector<std::pair<uint16_t, uint16_t>> LATEST_SPD_COMBINED_REV =
-{
-    {fapi2::ENUM_ATTR_MEM_EFF_MODULE_MFG_ID_SMART,      0x0400}, // 0x0194
-    {fapi2::ENUM_ATTR_MEM_EFF_MODULE_MFG_ID_US_MODULAR, 0x0400}, // 0x04AB
-    {fapi2::ENUM_ATTR_MEM_EFF_MODULE_MFG_ID_FUJITSU,    0x0400}, // 0x8004
-    {fapi2::ENUM_ATTR_MEM_EFF_MODULE_MFG_ID_MICRON,     0x0400}, // 0x802C
-    {fapi2::ENUM_ATTR_MEM_EFF_MODULE_MFG_ID_SAMSUNG,    0x0400}, // 0x80CE
-};
-
 ///
 /// @brief Enforce the plug-rules we can do before mss_freq
 /// @param[in] i_target FAPI2 target (proc chip)
@@ -149,29 +128,54 @@ namespace check
 {
 
 ///
-/// @brief Check that we recognize DDIMM module manufacturing ID
+/// @brief Check that we recognize SPD lookup key and return the SPD versions associated with the key
+/// @param[in] i_target dimm target
+/// @param[in] i_key the SPD lookup key to be used to grab the combined revisions
+/// @param[out] o_minimum_combined_rev minimum SPD combined revisions
+/// @param[out] o_latest_combined_rev latest SPD combined revisions
+/// @return fapi2::FAPI2_RC_SUCCESS if okay. A non-SUCCESS return will also produce an informational log
+///
+fapi2::ReturnCode spd_revision_key(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+                                   const spd_lookup_key& i_key,
+                                   uint16_t& o_minimum_combined_rev,
+                                   uint16_t& o_latest_combined_rev);
+
+///
+/// @brief Check DDIMM SPD revision and content revision versus minimum supported
 /// @param[in] i_target dimm target
-/// @param[in] i_module_mfg_id DIMM module manufacturing ID
-/// @param[out] o_latest_content_rev latest SPD content revision
+/// @param[in] i_spd_combined_revision the combined SPD revision and content
+/// @param[in] i_min_combined_rev SPD minimum combined revision information
 /// @return fapi2::FAPI2_RC_SUCCESS if okay. A non-SUCCESS return will also produce an informational log
+/// @note The return code from this function is only used in unit tests.
 ///
-fapi2::ReturnCode module_mfg_id(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
-                                const uint16_t i_module_mfg_id,
-                                uint16_t& o_latest_content_rev);
+fapi2::ReturnCode spd_minimum_combined_revision(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+        const uint16_t i_spd_combined_rev,
+        const uint16_t i_min_combined_rev);
 
 ///
 /// @brief Check DDIMM SPD revision and content revision versus latest supported
 /// @param[in] i_target dimm target
-/// @param[in] i_spd_rev SPD revision
-/// @param[in] i_spd_content_rev SPD content revision
-/// @param[in] i_latest_combined_rev latest SPD combined revision
+/// @param[in] i_spd_combined_revision the combined SPD revision and content
+/// @param[in] i_latest_combined_rev latest SPD combined revision information
+/// @return fapi2::FAPI2_RC_SUCCESS if okay. A non-SUCCESS return will also produce an informational log
+/// @note The return code from this function is only used in unit tests.
+///
+fapi2::ReturnCode spd_latest_combined_revision(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+        const uint16_t i_spd_combined_rev,
+        const uint16_t i_latest_combined_rev);
+
+///
+/// @brief Check DDIMM SPD revision and content revision versus minimum supported
+/// @param[in] i_target dimm target
+/// @param[in] i_spd_combined_revision the combined SPD revision and content
+/// @param[in] i_min_combined_rev SPD minimum combined revision information
 /// @return fapi2::FAPI2_RC_SUCCESS if okay. A non-SUCCESS return will also produce an informational log
 /// @note The return code from this function is only used in unit tests.
 ///
-fapi2::ReturnCode spd_combined_revision(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
-                                        const uint8_t i_spd_rev,
-                                        const uint8_t i_spd_content_rev,
-                                        const uint16_t i_latest_combined_rev);
+fapi2::ReturnCode spd_minimum_combined_revision(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+        const uint16_t i_spd_combined_rev,
+        const uint16_t i_min_combined_rev);
+
 } // namespace check
 
 ///

src/import/generic/memory/lib/utils/find.H

@@ -332,8 +332,6 @@ bool find_value_from_key(const std::vector<std::pair<T, OT> >& i_vector_of_pairs
     // Did you find it? Let me know.
     if( (l_value_iterator == i_vector_of_pairs.end()) || (i_key != l_value_iterator->first) )
     {
-        // Static cast ensures that the below print will not fail at compile time
-        FAPI_INF("Did not find a mapping value to key: %d", static_cast<uint64_t>(i_key));
         return false;
     }
 

src/import/generic/procedures/xml/error_info/generic_error.xml

@@ -1424,12 +1424,15 @@
   </hwpError>
 
   <hwpError>
-    <rc>RC_MSS_UNKNOWN_DIMM_MODULE_MFG_ID</rc>
+    <rc>RC_MSS_UNKNOWN_DIMM_SPD_KEY</rc>
     <description>
-        Module manufacturing ID from DIMM SPD was not recognized in
-        plug rule enforcement function.
+        DIMM SPD key from DIMM SPD was not recognized in
+        plug rule enforcement function. The key is the manufacturing ID,
+        the DIMM height, and the DIMM size.
     </description>
     <ffdc>MODULE_MFG_ID</ffdc>
+    <ffdc>DIMM_HEIGHT</ffdc>
+    <ffdc>DIMM_SIZE</ffdc>
     <callout>
       <target>DIMM_TARGET</target>
       <priority>HIGH</priority>
@@ -1470,12 +1473,12 @@
   </hwpError>
 
   <hwpError>
-    <rc>RC_MSS_UNSUPPORTED_SPD_CONTENT_REVISION</rc>
+    <rc>RC_MSS_UNSUPPORTED_SPD_COMBINED_REVISION</rc>
     <description>
-        DIMM SPD content revision is older than least supported revision.
+        DIMM SPD combined revision is older than least supported revision.
     </description>
-    <ffdc>SPD_CONTENT_REVISION</ffdc>
-    <ffdc>MINIMUM_FUNCTIONAL_SPD_CONTENT_REVISION</ffdc>
+    <ffdc>SPD_COMBINED_REVISION</ffdc>
+    <ffdc>MINIMUM_FUNCTIONAL_SPD_COMBINED_REVISION</ffdc>
     <callout>
       <procedure>MEMORY_PLUGGING_ERROR</procedure>
       <priority>HIGH</priority>