Change base decoder, add ddr4 namespace, and common API btw modules

Change-Id: I78b8b929e3136e3edec646321e0d8bb32229911d
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/38506
Reviewed-by: STEPHEN GLANCY <sglancy@us.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com>
Reviewed-by: Brian R. Silver <bsilver@us.ibm.com>
Reviewed-by: JACOB L. HARVEY <jlharvey@us.ibm.com>
Reviewed-by: Jennifer A. Stofer <stofer@us.ibm.com>
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/38507
Reviewed-by: Hostboot Team <hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+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>

3 files changed, 148 insertions, 149 deletions

diff --git a/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4.H b/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4.H
index effc7f983..9d62ea4b3 100644
--- a/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4.H
+++ b/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4.H
@@ -24,7 +24,7 @@
 /* IBM_PROLOG_END_TAG                                                     */
 
 ///
-/// @file rdimm_decoder.H
+/// @file rdimm_decoder_ddr4.H
 /// @brief RDIMM module SPD decoder declarations
 ///
 // *HWP HWP Owner: Andre Marin <aamarin@us.ibm.com>
@@ -33,8 +33,8 @@
 // *HWP Level: 2
 // *HWP Consumed by: HB:FSP
 
-#ifndef _MSS_RDIMM_DECODER_H_
-#define _MSS_RDIMM_DECODER_H_
+#ifndef _MSS_RDIMM_DECODER_DDR4_H_
+#define _MSS_RDIMM_DECODER_DDR4_H_
 
 #include <fapi2.H>
 #include <generic/memory/lib/spd/common/dimm_module_decoder.H>
@@ -43,12 +43,16 @@ namespace mss
 {
 namespace spd
 {
+namespace ddr4
+{
+namespace rdimm
+{
 
 ///
 /// @class decoder
 /// @brief RDIMM module SPD DRAM decoder for rev 1.0
 ///
-class rdimm_decoder_v1_0 : public dimm_module_decoder
+class decoder_v1_0 : public dimm_module_decoder
 {
     protected:
         enum
@@ -122,22 +126,47 @@ class rdimm_decoder_v1_0 : public dimm_module_decoder
         };
 
     public:
+
+        // First field - SPD byte
+        // Second field - start bit
+        // Third field - bit length
+        static constexpr field_t MODULE_NOMINAL_HEIGHT{128, MODULE_NOM_HEIGHT_START, MODULE_NOM_HEIGHT_LEN};
+        static constexpr field_t RAW_CARD_EXTENSION{128, RAW_CARD_EXT_START, RAW_CARD_EXT_LEN};
+        static constexpr field_t FRONT_MODULE_THICKNESS{129, FRONT_MODULE_THICKNESS_START, FRONT_MODULE_THICKNESS_LEN};
+        static constexpr field_t BACK_MODULE_THICKNESS{129, BACK_MODULE_THICKNESS_START, BACK_MODULE_THICKNESS_LEN};
+        static constexpr field_t REF_RAW_CARD{130, REF_RAW_CARD_START, REF_RAW_CARD_LEN};
+        static constexpr field_t REF_RAW_CARD_REV{130, REF_RAW_CARD_REV_START, REF_RAW_CARD_REV_LEN};
+        static constexpr field_t REF_RAW_CARD_EXT{130, REF_RAW_CARD_EXT_START, REF_RAW_CARD_EXT_LEN};
+        static constexpr field_t NUM_REGS_USED{131, REGS_USED_START, REGS_USED_LEN};
+        static constexpr field_t ROWS_OF_DRAMS{131, ROWS_OF_DRAMS_START, ROWS_OF_DRAMS_LEN};
+        static constexpr field_t REGISTER_TYPE{131, REGISTER_TYPE_START, REGISTER_TYPE_LEN};
+        static constexpr field_t HEAT_SPREADER_CHAR{132, HEAT_SPREADER_CHAR_START, HEAT_SPREADER_CHAR_LEN};
+        static constexpr field_t HEAT_SPREADER_SOL{132, HEAT_SPREADER_SOL_START, HEAT_SPREADER_SOL_LEN};
+        static constexpr field_t CONTINUATION_CODES{133, CONTINUATION_CODES_START, CONTINUATION_CODES_LEN};
+        static constexpr field_t ADDR_MAPPING{136, ADDR_MAPPING_START, ADDR_MAPPING_LEN};
+        static constexpr field_t CKE_DRIVER{137, CKE_DRIVER_START, CKE_DRIVER_LEN};
+        static constexpr field_t ODT_DRIVER{137, ODT_DRIVER_START, ODT_DRIVER_LEN};
+        static constexpr field_t CA_DRIVER{137, CA_DRIVER_START, CA_DRIVER_LEN};
+        static constexpr field_t CS_DRIVER{137, CS_DRIVER_START, CS_DRIVER_LEN};
+        static constexpr field_t YO_Y2_DRIVER{138, YO_Y2_DRIVER_START, YO_Y2_DRIVER_LEN};
+        static constexpr field_t Y1_Y3_DRIVER{138, Y1_Y3_DRIVER_START, Y1_Y3_DRIVER_LEN};
+
         // deleted default ctor
-        rdimm_decoder_v1_0() = delete;
+        decoder_v1_0() = delete;
 
         ///
         /// @brief ctor
         /// @param[in] i_target dimm target
         /// @param[in] i_spd_data vector DIMM SPD data
         ///
-        rdimm_decoder_v1_0(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
-                           const std::vector<uint8_t>& i_spd_data): iv_target(i_target), iv_spd_data(i_spd_data)
+        decoder_v1_0(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+                     const std::vector<uint8_t>& i_spd_data): iv_target(i_target), iv_spd_data(i_spd_data)
         {}
 
         ///
         /// @brief default dtor
         ///
-        virtual ~rdimm_decoder_v1_0() = default;
+        virtual ~decoder_v1_0() = default;
 
         ///
         /// @brief Decodes module nominal height max, in mm
@@ -330,32 +359,33 @@ class rdimm_decoder_v1_0 : public dimm_module_decoder
         const fapi2::Target<fapi2::TARGET_TYPE_DIMM> iv_target;
         const std::vector<uint8_t> iv_spd_data;
 
-};// rdimm_decoder_v1_0
+};// decoder_v1_0
 
 ///
 /// @class decoder
 /// @brief RDIMM module SPD DRAM decoder for rev 1.1
 ///
-class rdimm_decoder_v1_1 :  public rdimm_decoder_v1_0
+class decoder_v1_1 :  public decoder_v1_0
 {
     public:
 
         // deleted default ctor
-        rdimm_decoder_v1_1() = delete;
+        decoder_v1_1() = delete;
 
         ///
         /// @brief ctor
         /// @param[in] i_target dimm target
         /// @param[in] i_spd_data vector DIMM SPD data
         ///
-        rdimm_decoder_v1_1(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
-                           const std::vector<uint8_t>& i_spd_data): rdimm_decoder_v1_0(i_target, i_spd_data)
+        decoder_v1_1(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,
+                     const std::vector<uint8_t>& i_spd_data):
+            decoder_v1_0(i_target, i_spd_data)
         {}
 
         ///
         /// @brief default dtor
         ///
-        virtual ~rdimm_decoder_v1_1() = default;
+        virtual ~decoder_v1_1() = default;
 
         ///
         /// @brief Decodes register types
@@ -423,9 +453,11 @@ class rdimm_decoder_v1_1 :  public rdimm_decoder_v1_0
         ///
         virtual fapi2::ReturnCode a_side_clk_output_driver(uint8_t& o_output) override;
 
-};//rdimm_decoder_v1_1
+};//decoder_v1_1
 
+}// rdimm
+}// ddr4
 }// spd
 }// mss
 
-#endif //_MSS_RDIMM_DECODER_H_
+#endif //_MSS_RDIMM_DECODER_DDR4_H_
diff --git a/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4_v1_0.C b/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4_v1_0.C
index 43eb08c51..25ace3e70 100644
--- a/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4_v1_0.C
+++ b/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4_v1_0.C
@@ -55,6 +55,10 @@ namespace mss
 {
 namespace spd
 {
+namespace ddr4
+{
+namespace rdimm
+{
 
 /////////////////////////
 // Member Method implementation
@@ -70,20 +74,17 @@ namespace spd
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 48
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::max_module_nominal_height(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::max_module_nominal_height(uint8_t& o_output)
 {
-    constexpr size_t BYTE_INDEX = 128;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, MODULE_NOM_HEIGHT_START, MODULE_NOM_HEIGHT_LEN>(iv_target,
-                           iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<MODULE_NOMINAL_HEIGHT>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t MAX_VALID_VALUE = 0b11111;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits <= MAX_VALID_VALUE,
-              BYTE_INDEX,
+              MODULE_NOMINAL_HEIGHT.iv_byte,
               l_field_bits,
               "Failed bound check for module nominal height max") );
 
@@ -106,21 +107,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 48
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::front_module_max_thickness(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::front_module_max_thickness(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 129;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, FRONT_MODULE_THICKNESS_START, FRONT_MODULE_THICKNESS_LEN>
-                           (iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<FRONT_MODULE_THICKNESS>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t MAX_VALID_VALUE = 0b1111;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits <= MAX_VALID_VALUE,
-              BYTE_INDEX,
+              FRONT_MODULE_THICKNESS.iv_byte,
               l_field_bits,
               "Failed bound check for front module max thickness") );
 
@@ -144,20 +142,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 48
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::back_module_max_thickness(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::back_module_max_thickness(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 129;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, BACK_MODULE_THICKNESS_START, BACK_MODULE_THICKNESS_LEN>(iv_target,
-                           iv_spd_data);
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<BACK_MODULE_THICKNESS>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t MAX_VALID_VALUE = 0b1111;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits <= MAX_VALID_VALUE,
-              BYTE_INDEX,
+              BACK_MODULE_THICKNESS.iv_byte,
               l_field_bits,
               "Failed bound check for back module max thickness") );
 
@@ -181,20 +177,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 50
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::num_registers_used(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::num_registers_used(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 131;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, REGS_USED_START, REGS_USED_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<NUM_REGS_USED>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t MAX_VALID_VALUE = 0b11;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits <= MAX_VALID_VALUE,
-              BYTE_INDEX,
+              NUM_REGS_USED.iv_byte,
               l_field_bits,
               "Failed bound check for number of registers used on RDIMM ") );
 
@@ -218,20 +212,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 50
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::num_rows_of_drams(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::num_rows_of_drams(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 131;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, ROWS_OF_DRAMS_START, ROWS_OF_DRAMS_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<ROWS_OF_DRAMS>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t MAX_VALID_VALUE = 0b11;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits <= MAX_VALID_VALUE,
-              BYTE_INDEX,
+              ROWS_OF_DRAMS.iv_byte,
               l_field_bits,
               "Failed bound check for number of rows of DRAMs on RDIMM ") );
 
@@ -255,20 +247,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 51
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::heat_spreader_thermal_char(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::heat_spreader_thermal_char(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 132;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, HEAT_SPREADER_CHAR_START, HEAT_SPREADER_CHAR_LEN>(iv_target,
-                           iv_spd_data);
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<HEAT_SPREADER_CHAR>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t MAX_VALID_VALUE = 1;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits <= MAX_VALID_VALUE,
-              BYTE_INDEX,
+              HEAT_SPREADER_CHAR.iv_byte,
               l_field_bits,
               "Failed bound check for heat spreader thermal characteristics") );
 
@@ -291,21 +281,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 51
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::heat_spreader_solution(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::heat_spreader_solution(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 132;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, HEAT_SPREADER_SOL_START, HEAT_SPREADER_SOL_LEN>(iv_target,
-                           iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<HEAT_SPREADER_SOL>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t MAX_VALID_VALUE = 1;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits <= MAX_VALID_VALUE,
-              BYTE_INDEX,
+              HEAT_SPREADER_SOL.iv_byte,
               l_field_bits,
               "Failed bound check for heat spreader solution") );
 
@@ -329,21 +316,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 51
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::num_continuation_codes(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::num_continuation_codes(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 133;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, CONTINUATION_CODES_START, CONTINUATION_CODES_LEN>(iv_target,
-                           iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<CONTINUATION_CODES>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t MAX_VALID_VALUE = 10; // JEP106AS
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits <= MAX_VALID_VALUE,
-              BYTE_INDEX,
+              CONTINUATION_CODES.iv_byte,
               l_field_bits,
               "Failed bound check for number of continuation codes") );
 
@@ -367,7 +351,7 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 51
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::reg_manufacturer_id_code(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::reg_manufacturer_id_code(uint8_t& o_output)
 {
     constexpr size_t BYTE_INDEX = 134;
     uint8_t l_raw_byte = iv_spd_data[BYTE_INDEX];
@@ -396,7 +380,7 @@ fapi2::ReturnCode rdimm_decoder_v1_0::reg_manufacturer_id_code(uint8_t& o_output
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 51
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::register_rev_num(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::register_rev_num(uint8_t& o_output)
 {
     constexpr size_t BYTE_INDEX = 135;
     uint8_t l_raw_byte = iv_spd_data[BYTE_INDEX];
@@ -425,20 +409,18 @@ fapi2::ReturnCode rdimm_decoder_v1_0::register_rev_num(uint8_t& o_output)
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 52
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::register_to_dram_addr_mapping(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::register_to_dram_addr_mapping(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 136;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, ADDR_MAPPING_START, ADDR_MAPPING_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<ADDR_MAPPING>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t RESERVED = 0b11;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits < RESERVED, // extract sanity check
-              BYTE_INDEX,
+              ADDR_MAPPING.iv_byte,
               l_field_bits,
               "Failed bound check for to register to dram addr mapping") );
 
@@ -461,20 +443,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 53
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::cke_signal_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::cke_signal_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 137;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, CKE_DRIVER_START, CKE_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<CKE_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t RESERVED = 2;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits < RESERVED, // extract sanity check
-              BYTE_INDEX,
+              CKE_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for CKE") );
 
@@ -497,20 +477,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 53
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::odt_signal_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::odt_signal_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 137;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, ODT_DRIVER_START, ODT_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<ODT_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t RESERVED = 2;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits < RESERVED, // extract sanity check
-              BYTE_INDEX,
+              ODT_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for ODT") );
 
@@ -533,20 +511,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 53
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::ca_signal_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::ca_signal_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 137;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, CA_DRIVER_START, CA_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<CA_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t INVALID_VAL = 3;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits < INVALID_VAL, // extract sanity check
-              BYTE_INDEX,
+              CA_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for CA") );
 
@@ -569,20 +545,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 53
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::cs_signal_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::cs_signal_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 137;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, CS_DRIVER_START, CS_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<CS_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t RESERVED = 2;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits < RESERVED, // extract sanity check
-              BYTE_INDEX,
+              CS_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for CS") );
 
@@ -605,18 +579,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 53
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::b_side_clk_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::b_side_clk_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE_INDEX = 138;
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, YO_Y2_DRIVER_START, YO_Y2_DRIVER_LEN>(iv_target, iv_spd_data);
+    const uint8_t l_field_bits = extract_spd_field<YO_Y2_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t RESERVED = 2;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits < RESERVED, // extract sanity check
-              BYTE_INDEX,
+              YO_Y2_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for clock (Y0,Y2)") );
 
@@ -639,22 +613,18 @@ fapi_try_exit:
 /// @note DDR4 SPD Document Release 2
 /// @note Page 4.1.2.12 - 53
 ///
-fapi2::ReturnCode rdimm_decoder_v1_0::a_side_clk_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_0::a_side_clk_output_driver(uint8_t& o_output)
 {
-    // Trace in the front assists w/ debug
-    constexpr size_t BYTE_INDEX = 138;
-
     // Extracting desired bits
-    uint8_t l_field_bits = extract_spd_field<BYTE_INDEX, Y1_Y3_DRIVER_START, Y1_Y3_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<Y1_Y3_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field_Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
     constexpr size_t RESERVED = 2;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               l_field_bits < RESERVED,
-              BYTE_INDEX,
+              Y1_Y3_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for clock (Y1,Y3)") );
 
@@ -668,5 +638,7 @@ fapi_try_exit:
     return fapi2::current_err;
 }
 
-}//spd namespace
-}// mss namespace
+}// rdimm
+}// ddr4
+}// spd
+}// mss
diff --git a/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4_v1_1.C b/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4_v1_1.C
index 4517de0a7..753750fb9 100644
--- a/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4_v1_1.C
+++ b/src/import/generic/memory/lib/spd/rdimm/ddr4/rdimm_decoder_ddr4_v1_1.C
@@ -46,6 +46,10 @@ namespace mss
 {
 namespace spd
 {
+namespace ddr4
+{
+namespace rdimm
+{
 
 /////////////////////////
 // Member Method implementation
@@ -61,11 +65,10 @@ namespace spd
 /// @note DDR4 SPD Document Release 3
 /// @note Page 4.1.2.12.3 - 63
 ///
-fapi2::ReturnCode rdimm_decoder_v1_1::register_and_buffer_type(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_1::register_and_buffer_type(uint8_t& o_output)
 {
-    constexpr size_t BYTE = 131;
     // Extracting desired bits
-    uint8_t l_field_bits = extract_spd_field<BYTE, REGISTER_TYPE_START, REGISTER_TYPE_LEN>(iv_target, iv_spd_data);
+    const uint8_t l_field_bits = extract_spd_field<REGISTER_TYPE>(iv_target, iv_spd_data);
     FAPI_INF("Field Bits value: %d", l_field_bits);
 
     // This checks my extracting params returns a value within bound
@@ -73,7 +76,7 @@ fapi2::ReturnCode rdimm_decoder_v1_1::register_and_buffer_type(uint8_t& o_output
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               (l_field_bits < RESERVED), // extract sanity check
-              BYTE,
+              REGISTER_TYPE.iv_byte,
               l_field_bits,
               "Failed bounds check for Register and Data Buffer Types") );
 
@@ -98,20 +101,18 @@ fapi_try_exit:
 /// @note Page 76
 /// @note DDR4 SPD Document Release 4
 ///
-fapi2::ReturnCode rdimm_decoder_v1_1::cke_signal_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_1::cke_signal_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE = 137;
-    uint8_t l_field_bits = extract_spd_field<BYTE, CKE_DRIVER_START, CKE_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<CKE_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field Bits value: %d", l_field_bits);
 
     // This really just checks my extract gives me a valid value
     constexpr size_t MAX_VALID_VALUE = 0b11;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               (l_field_bits <= MAX_VALID_VALUE), // extract sanity check
-              BYTE,
+              CKE_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for CKE") );
 
@@ -134,20 +135,18 @@ fapi_try_exit:
 /// @note Page 76
 /// @note DDR4 SPD Document Release 4
 ///
-fapi2::ReturnCode rdimm_decoder_v1_1::odt_signal_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_1::odt_signal_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE = 137;
-    uint8_t l_field_bits = extract_spd_field<BYTE, ODT_DRIVER_START, ODT_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<ODT_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field Bits value: %d", l_field_bits);
 
     // This really just checks my extract gives me a valid value
     constexpr size_t MAX_VALID_VALUE = 0b11;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               (l_field_bits <= MAX_VALID_VALUE), // extract sanity check
-              BYTE,
+              ODT_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for ODT") );
 
@@ -170,20 +169,18 @@ fapi_try_exit:
 /// @note Page 76
 /// @note DDR4 SPD Document Release 4
 ///
-fapi2::ReturnCode rdimm_decoder_v1_1::cs_signal_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_1::cs_signal_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE = 137;
-    uint8_t l_field_bits = extract_spd_field<BYTE, CS_DRIVER_START, CS_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<CS_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field Bits value: %d", l_field_bits);
 
     // This really just checks my extract gives me a valid value
     constexpr size_t MAX_VALID_VALUE = 0b11;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               (l_field_bits <= MAX_VALID_VALUE), // extract sanity check
-              BYTE,
+              CS_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for chip select") );
 
@@ -206,20 +203,18 @@ fapi_try_exit:
 /// @note Page 76
 /// @note DDR4 SPD Document Release 4
 ///
-fapi2::ReturnCode rdimm_decoder_v1_1::b_side_clk_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_1::b_side_clk_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE = 138;
-    uint8_t l_field_bits = extract_spd_field<BYTE, YO_Y2_DRIVER_START, YO_Y2_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<YO_Y2_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field Bits value: %d", l_field_bits);
 
     // This really just checks my extract gives me a valid value
     constexpr size_t MAX_VALID_VAL = 2;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               (l_field_bits <= MAX_VALID_VAL), // extract sanity check
-              BYTE,
+              YO_Y2_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for clock (Y0,Y2)") );
 
@@ -242,20 +237,18 @@ fapi_try_exit:
 /// @note Page 76
 /// @note DDR4 SPD Document Release 4
 ///
-fapi2::ReturnCode rdimm_decoder_v1_1::a_side_clk_output_driver(uint8_t& o_output)
+fapi2::ReturnCode decoder_v1_1::a_side_clk_output_driver(uint8_t& o_output)
 {
     // Extracting desired bits
-    constexpr size_t BYTE = 138;
-    uint8_t l_field_bits = extract_spd_field<BYTE, Y1_Y3_DRIVER_START, Y1_Y3_DRIVER_LEN>(iv_target, iv_spd_data);
-
-    FAPI_INF("Field_Bits value: %d", l_field_bits);
+    const uint8_t l_field_bits = extract_spd_field<Y1_Y3_DRIVER>(iv_target, iv_spd_data);
+    FAPI_DBG("Field Bits value: %d", l_field_bits);
 
     // This really just checks my extract gives me a valid value
     constexpr size_t MAX_VALID_VAL = 2;
 
     FAPI_TRY( mss::check::spd::fail_for_invalid_value(iv_target,
               (l_field_bits <= MAX_VALID_VAL), // extract sanity check
-              BYTE,
+              Y1_Y3_DRIVER.iv_byte,
               l_field_bits,
               "Failed bounds check for Register Output Driver for clock (Y1,Y3)") );
 
@@ -269,5 +262,7 @@ fapi_try_exit:
     return fapi2::current_err;
 }
 
-}//spd
+}// rdimm
+}// ddr4
+}// spd
 }// mss