From 8231492521707f86e108fa9876d1d8e177238b9f Mon Sep 17 00:00:00 2001 From: Mark Pizzutillo Date: Mon, 22 Apr 2019 19:23:22 -0400 Subject: Add attributes for PMIC SPD fields Change-Id: Ia818bdc031524325df2036846c75ee8334414b64 Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/75997 Tested-by: FSP CI Jenkins Tested-by: Jenkins Server Tested-by: HWSV CI Tested-by: Hostboot CI Reviewed-by: Louis Stermole Reviewed-by: STEPHEN GLANCY Reviewed-by: Jennifer A. Stofer Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/76186 Tested-by: Jenkins OP Build CI Tested-by: Jenkins OP HW Reviewed-by: Christian R. Geddes --- .../pmic/lib/eff_config/pmic_attr_engine_traits.H | 2721 ++++++++++++++++++++ .../procedures/hwp/pmic/lib/utils/pmic_consts.H | 167 ++ .../xml/attribute_info/pmic_eff_attributes.xml | 677 +++++ src/import/generic/memory/lib/spd/spd_facade.H | 14 + 4 files changed, 3579 insertions(+) diff --git a/src/import/chips/ocmb/common/procedures/hwp/pmic/lib/eff_config/pmic_attr_engine_traits.H b/src/import/chips/ocmb/common/procedures/hwp/pmic/lib/eff_config/pmic_attr_engine_traits.H index 24eb0c65f..7187d6955 100644 --- a/src/import/chips/ocmb/common/procedures/hwp/pmic/lib/eff_config/pmic_attr_engine_traits.H +++ b/src/import/chips/ocmb/common/procedures/hwp/pmic/lib/eff_config/pmic_attr_engine_traits.H @@ -22,3 +22,2724 @@ /* permissions and limitations under the License. */ /* */ /* IBM_PROLOG_END_TAG */ + +/// +/// @file pmic_attr_engine_traits.H +/// @brief Trait class definitions for pmic attrs +/// + +// *HWP HWP Owner: Mark Pizzutillo +// *HWP FW Owner: Andre Marin +// *HWP Team: Memory +// *HWP Level: 2 +// *HWP Consumed by: HB:CI + +#ifndef _MSS_PMIC_ATTR_ENGINE_TRAITS_H_ +#define _MSS_PMIC_ATTR_ENGINE_TRAITS_H_ + +#include +#include +#include +#include +#include +#include +#include + +namespace mss +{ + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, ATTR_EFF_BASE_CASE specialization +/// NOP for base case needed to trigger partial specialization of attr_engine +/// +template<> +struct attrEngineTraits {}; + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, DRAM_MODULE_HEIGHT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_DRAM_MODULE_HEIGHT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_DRAM_MODULE_HEIGHT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_DRAM_MODULE_HEIGHT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_dram_module_height(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_dram_module_height(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.module_base_height(o_setting); + } +}; + +//---------------------------------------- +// PMIC 0 +//---------------------------------------- + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_MFG_ID specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_MFG_ID_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_MFG_ID_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_MFG_ID; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_mfg_id(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_mfg_id(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.mfg_id_pmic0(o_setting); + } +}; + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWA_VOLTAGE_SETTING specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_SETTING_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_SETTING_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWA_VOLTAGE_SETTING; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swa_voltage_setting(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swa_voltage_setting(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_swa_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWA_VOLTAGE_RANGE_SELECT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_RANGE_SELECT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_RANGE_SELECT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWA_VOLTAGE_RANGE_SELECT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swa_voltage_range_select(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swa_voltage_range_select(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_range_swa_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWA_VOLTAGE_OFFSET specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_OFFSET_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_OFFSET_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWA_VOLTAGE_OFFSET; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swa_voltage_offset(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swa_voltage_offset(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_swa_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWA_VOLTAGE_OFFSET_DIRECTION specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_OFFSET_DIRECTION_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_OFFSET_DIRECTION_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWA_VOLTAGE_OFFSET_DIRECTION; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swa_voltage_offset_direction(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swa_voltage_offset_direction(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_direction_swa_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWA_SEQUENCE_DELAY specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWA_SEQUENCE_DELAY_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWA_SEQUENCE_DELAY_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWA_SEQUENCE_DELAY; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swa_sequence_delay(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swa_sequence_delay(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_delay_swa_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWA_SEQUENCE_ORDER specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWA_SEQUENCE_ORDER_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWA_SEQUENCE_ORDER_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWA_SEQUENCE_ORDER; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swa_sequence_order(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swa_sequence_order(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_order_swa_pmic0(o_setting); + } +}; + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWB_VOLTAGE_SETTING specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_SETTING_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_SETTING_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWB_VOLTAGE_SETTING; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swb_voltage_setting(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swb_voltage_setting(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_swb_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWB_VOLTAGE_RANGE_SELECT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_RANGE_SELECT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_RANGE_SELECT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWB_VOLTAGE_RANGE_SELECT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swb_voltage_range_select(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swb_voltage_range_select(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_range_swb_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWB_VOLTAGE_OFFSET specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_OFFSET_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_OFFSET_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWB_VOLTAGE_OFFSET; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swb_voltage_offset(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swb_voltage_offset(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_swb_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWB_VOLTAGE_OFFSET_DIRECTION specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_OFFSET_DIRECTION_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_OFFSET_DIRECTION_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWB_VOLTAGE_OFFSET_DIRECTION; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swb_voltage_offset_direction(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swb_voltage_offset_direction(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_direction_swb_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWB_SEQUENCE_DELAY specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWB_SEQUENCE_DELAY_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWB_SEQUENCE_DELAY_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWB_SEQUENCE_DELAY; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swb_sequence_delay(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swb_sequence_delay(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_delay_swb_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWB_SEQUENCE_ORDER specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWB_SEQUENCE_ORDER_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWB_SEQUENCE_ORDER_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWB_SEQUENCE_ORDER; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swb_sequence_order(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swb_sequence_order(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_order_swb_pmic0(o_setting); + } +}; + + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWC_VOLTAGE_SETTING specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_SETTING_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_SETTING_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWC_VOLTAGE_SETTING; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swc_voltage_setting(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swc_voltage_setting(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_swc_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWC_VOLTAGE_RANGE_SELECT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_RANGE_SELECT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_RANGE_SELECT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWC_VOLTAGE_RANGE_SELECT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swc_voltage_range_select(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swc_voltage_range_select(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_range_swc_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWC_VOLTAGE_OFFSET specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_OFFSET_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_OFFSET_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWC_VOLTAGE_OFFSET; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swc_voltage_offset(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swc_voltage_offset(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_swc_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWC_VOLTAGE_OFFSET_DIRECTION specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_OFFSET_DIRECTION_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_OFFSET_DIRECTION_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWC_VOLTAGE_OFFSET_DIRECTION; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swc_voltage_offset_direction(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swc_voltage_offset_direction(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_direction_swc_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWC_SEQUENCE_DELAY specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWC_SEQUENCE_DELAY_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWC_SEQUENCE_DELAY_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWC_SEQUENCE_DELAY; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swc_sequence_delay(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swc_sequence_delay(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_delay_swc_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWC_SEQUENCE_ORDER specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWC_SEQUENCE_ORDER_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWC_SEQUENCE_ORDER_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWC_SEQUENCE_ORDER; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swc_sequence_order(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swc_sequence_order(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_order_swc_pmic0(o_setting); + } +}; + + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWD_VOLTAGE_SETTING specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_SETTING_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_SETTING_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWD_VOLTAGE_SETTING; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swd_voltage_setting(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swd_voltage_setting(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_swd_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWD_VOLTAGE_RANGE_SELECT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_RANGE_SELECT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_RANGE_SELECT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWD_VOLTAGE_RANGE_SELECT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swd_voltage_range_select(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swd_voltage_range_select(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_range_swd_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWD_VOLTAGE_OFFSET specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_OFFSET_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_OFFSET_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWD_VOLTAGE_OFFSET; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swd_voltage_offset(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swd_voltage_offset(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_swd_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWD_VOLTAGE_OFFSET_DIRECTION specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_OFFSET_DIRECTION_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_OFFSET_DIRECTION_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWD_VOLTAGE_OFFSET_DIRECTION; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swd_voltage_offset_direction(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swd_voltage_offset_direction(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_direction_swd_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWD_SEQUENCE_DELAY specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWD_SEQUENCE_DELAY_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWD_SEQUENCE_DELAY_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWD_SEQUENCE_DELAY; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swd_sequence_delay(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swd_sequence_delay(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_delay_swd_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_SWD_SEQUENCE_ORDER specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_SWD_SEQUENCE_ORDER_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_SWD_SEQUENCE_ORDER_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_SWD_SEQUENCE_ORDER; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_swd_sequence_order(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_swd_sequence_order(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_order_swd_pmic0(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC0_PHASE_COMB specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC0_PHASE_COMB_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC0_PHASE_COMB_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC0_PHASE_COMB; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic0_phase_comb(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic0_phase_comb(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.phase_combination_pmic0(o_setting); + } +}; + + +//---------------------------------------- +// PMIC 1 +//---------------------------------------- + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_MFG_ID specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_MFG_ID_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_MFG_ID_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_MFG_ID; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_mfg_id(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_mfg_id(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.mfg_id_pmic1(o_setting); + } +}; + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWA_VOLTAGE_SETTING specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_SETTING_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_SETTING_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWA_VOLTAGE_SETTING; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swa_voltage_setting(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swa_voltage_setting(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_swa_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWA_VOLTAGE_RANGE_SELECT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_RANGE_SELECT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_RANGE_SELECT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWA_VOLTAGE_RANGE_SELECT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swa_voltage_range_select(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swa_voltage_range_select(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_range_swa_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWA_VOLTAGE_OFFSET specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_OFFSET_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_OFFSET_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWA_VOLTAGE_OFFSET; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swa_voltage_offset(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swa_voltage_offset(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_swa_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWA_VOLTAGE_OFFSET_DIRECTION specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_OFFSET_DIRECTION_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_OFFSET_DIRECTION_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWA_VOLTAGE_OFFSET_DIRECTION; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swa_voltage_offset_direction(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swa_voltage_offset_direction(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_direction_swa_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWA_SEQUENCE_DELAY specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWA_SEQUENCE_DELAY_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWA_SEQUENCE_DELAY_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWA_SEQUENCE_DELAY; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swa_sequence_delay(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swa_sequence_delay(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_delay_swa_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWA_SEQUENCE_ORDER specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWA_SEQUENCE_ORDER_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWA_SEQUENCE_ORDER_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWA_SEQUENCE_ORDER; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swa_sequence_order(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swa_sequence_order(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_order_swa_pmic1(o_setting); + } +}; + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWB_VOLTAGE_SETTING specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_SETTING_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_SETTING_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWB_VOLTAGE_SETTING; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swb_voltage_setting(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swb_voltage_setting(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_swb_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWB_VOLTAGE_RANGE_SELECT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_RANGE_SELECT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_RANGE_SELECT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWB_VOLTAGE_RANGE_SELECT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swb_voltage_range_select(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swb_voltage_range_select(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_range_swb_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWB_VOLTAGE_OFFSET specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_OFFSET_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_OFFSET_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWB_VOLTAGE_OFFSET; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swb_voltage_offset(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swb_voltage_offset(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_swb_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWB_VOLTAGE_OFFSET_DIRECTION specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_OFFSET_DIRECTION_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_OFFSET_DIRECTION_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWB_VOLTAGE_OFFSET_DIRECTION; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swb_voltage_offset_direction(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swb_voltage_offset_direction(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_direction_swb_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWB_SEQUENCE_DELAY specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWB_SEQUENCE_DELAY_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWB_SEQUENCE_DELAY_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWB_SEQUENCE_DELAY; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swb_sequence_delay(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swb_sequence_delay(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_delay_swb_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWB_SEQUENCE_ORDER specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWB_SEQUENCE_ORDER_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWB_SEQUENCE_ORDER_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWB_SEQUENCE_ORDER; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swb_sequence_order(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swb_sequence_order(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_order_swb_pmic1(o_setting); + } +}; + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWC_VOLTAGE_SETTING specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_SETTING_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_SETTING_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWC_VOLTAGE_SETTING; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swc_voltage_setting(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swc_voltage_setting(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_swc_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWC_VOLTAGE_RANGE_SELECT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_RANGE_SELECT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_RANGE_SELECT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWC_VOLTAGE_RANGE_SELECT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swc_voltage_range_select(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swc_voltage_range_select(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_range_swc_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWC_VOLTAGE_OFFSET specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_OFFSET_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_OFFSET_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWC_VOLTAGE_OFFSET; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swc_voltage_offset(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swc_voltage_offset(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_swc_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWC_VOLTAGE_OFFSET_DIRECTION specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_OFFSET_DIRECTION_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_OFFSET_DIRECTION_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWC_VOLTAGE_OFFSET_DIRECTION; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swc_voltage_offset_direction(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swc_voltage_offset_direction(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_direction_swc_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWC_SEQUENCE_DELAY specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWC_SEQUENCE_DELAY_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWC_SEQUENCE_DELAY_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWC_SEQUENCE_DELAY; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swc_sequence_delay(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swc_sequence_delay(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_delay_swc_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWC_SEQUENCE_ORDER specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWC_SEQUENCE_ORDER_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWC_SEQUENCE_ORDER_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWC_SEQUENCE_ORDER; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swc_sequence_order(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swc_sequence_order(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_order_swc_pmic1(o_setting); + } +}; + +/// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWD_VOLTAGE_SETTING specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_SETTING_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_SETTING_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWD_VOLTAGE_SETTING; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swd_voltage_setting(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swd_voltage_setting(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_swd_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWD_VOLTAGE_RANGE_SELECT specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_RANGE_SELECT_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_RANGE_SELECT_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWD_VOLTAGE_RANGE_SELECT; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swd_voltage_range_select(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swd_voltage_range_select(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_setpoint_range_swd_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWD_VOLTAGE_OFFSET specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_OFFSET_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_OFFSET_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWD_VOLTAGE_OFFSET; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swd_voltage_offset(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swd_voltage_offset(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_swd_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWD_VOLTAGE_OFFSET_DIRECTION specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_OFFSET_DIRECTION_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_OFFSET_DIRECTION_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWD_VOLTAGE_OFFSET_DIRECTION; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swd_voltage_offset_direction(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swd_voltage_offset_direction(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_offset_direction_swd_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWD_SEQUENCE_DELAY specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWD_SEQUENCE_DELAY_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWD_SEQUENCE_DELAY_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWD_SEQUENCE_DELAY; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swd_sequence_delay(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swd_sequence_delay(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_delay_swd_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_SWD_SEQUENCE_ORDER specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_SWD_SEQUENCE_ORDER_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_SWD_SEQUENCE_ORDER_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_SWD_SEQUENCE_ORDER; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_swd_sequence_order(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_swd_sequence_order(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.volt_order_swd_pmic1(o_setting); + } +}; + +// +/// @brief Traits for attr_engine +/// @class attrEngineTraits +/// @note attr_eff_engine_fields, PMIC1_PHASE_COMB specialization +/// +template<> +struct attrEngineTraits +{ + using attr_type = fapi2::ATTR_MEM_EFF_PMIC1_PHASE_COMB_Type; + using attr_integral_type = std::remove_all_extents::type; + static constexpr fapi2::TargetType TARGET_TYPE = fapi2::ATTR_MEM_EFF_PMIC1_PHASE_COMB_TargetType; + static constexpr pmic::ffdc_codes FFDC_CODE = pmic::SET_PMIC1_PHASE_COMB; + + /// + /// @brief attribute getter + /// @param[in] i_target the fapi2 target + /// @param[out] o_setting array to populate + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_attr(const fapi2::Target& i_target, + attr_type& o_setting) + { + return attr::get_pmic1_phase_comb(i_target, o_setting); + } + + /// + /// @brief attribute setter + /// @param[in] i_target the fapi2 target + /// @param[in] i_setting array to set + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode set_attr(const fapi2::Target& i_target, + attr_type& i_setting) + { + return attr::set_pmic1_phase_comb(i_target, i_setting); + } + + /// + /// @brief Computes setting for attribute + /// @param[in] i_spd_data EFD data + /// @param[out] o_setting value we want to set attr with + /// @return FAPI2_RC_SUCCESS iff okay + /// + static fapi2::ReturnCode get_value_to_set(const spd::facade& i_spd_data, + attr_integral_type& o_setting) + { + return i_spd_data.phase_combination_pmic1(o_setting); + } +}; + +/// +/// @brief Value traits for attr_eff_engine_fields +/// @class attrEngineTraits +/// @note attr_eff_engine_fields +/// +template < > +struct attrEnumTraits +{ + static constexpr size_t DISPATCHER = pmic::ATTR_EFF_DISPATCHER; +}; + +/// +/// @brief Value traits for attr_eff_engine_fields +/// @class attrEngineTraits +/// @note attr_eff_engine_fields +/// +template < > +struct attrEnumTraits +{ + static constexpr size_t DISPATCHER = ATTR_METADATA_DISPATCHER; +}; + +}//mss + +#endif diff --git a/src/import/chips/ocmb/common/procedures/hwp/pmic/lib/utils/pmic_consts.H b/src/import/chips/ocmb/common/procedures/hwp/pmic/lib/utils/pmic_consts.H index 70e29b1b7..c8410ea6d 100644 --- a/src/import/chips/ocmb/common/procedures/hwp/pmic/lib/utils/pmic_consts.H +++ b/src/import/chips/ocmb/common/procedures/hwp/pmic/lib/utils/pmic_consts.H @@ -22,3 +22,170 @@ /* permissions and limitations under the License. */ /* */ /* IBM_PROLOG_END_TAG */ + +/// +/// @file pmic_consts.H +/// @brief Constants for PMIC procedures / i2C +/// +// *HWP HWP Owner: Mark Pizzutillo +// *HWP HWP Backup: Andre A. Marin +// *HWP Team: Memory +// *HWP Level: 1 +// *HWP Consumed by: CI + +#ifndef MSS_PMIC_CONSTS_H +#define MSS_PMIC_CONSTS_H + +namespace mss +{ +namespace pmic +{ + +enum attr_eff_engine_fields +{ + // Template recursive base case + ATTR_EFF_BASE_CASE = 0, + + PMIC0_SWA_VOLTAGE_SETTING = 1, + PMIC0_SWA_VOLTAGE_RANGE_SELECT = 2, + PMIC0_SWA_VOLTAGE_OFFSET = 3, + PMIC0_SWA_VOLTAGE_OFFSET_DIRECTION = 4, + PMIC0_SWA_SEQUENCE_DELAY = 5, + PMIC0_SWA_SEQUENCE_ORDER = 6, + + PMIC0_SWB_VOLTAGE_SETTING = 7, + PMIC0_SWB_VOLTAGE_RANGE_SELECT = 8, + PMIC0_SWB_VOLTAGE_OFFSET = 9, + PMIC0_SWB_VOLTAGE_OFFSET_DIRECTION = 10, + PMIC0_SWB_SEQUENCE_DELAY = 11, + PMIC0_SWB_SEQUENCE_ORDER = 12, + + PMIC0_SWC_VOLTAGE_SETTING = 13, + PMIC0_SWC_VOLTAGE_RANGE_SELECT = 14, + PMIC0_SWC_VOLTAGE_OFFSET = 15, + PMIC0_SWC_VOLTAGE_OFFSET_DIRECTION = 16, + PMIC0_SWC_SEQUENCE_DELAY = 17, + PMIC0_SWC_SEQUENCE_ORDER = 18, + + PMIC0_SWD_VOLTAGE_SETTING = 19, + PMIC0_SWD_VOLTAGE_RANGE_SELECT = 20, + PMIC0_SWD_VOLTAGE_OFFSET = 21, + PMIC0_SWD_VOLTAGE_OFFSET_DIRECTION = 22, + PMIC0_SWD_SEQUENCE_DELAY = 23, + PMIC0_SWD_SEQUENCE_ORDER = 24, + + PMIC1_SWA_VOLTAGE_SETTING = 25, + PMIC1_SWA_VOLTAGE_RANGE_SELECT = 26, + PMIC1_SWA_VOLTAGE_OFFSET = 27, + PMIC1_SWA_VOLTAGE_OFFSET_DIRECTION = 28, + PMIC1_SWA_SEQUENCE_DELAY = 29, + PMIC1_SWA_SEQUENCE_ORDER = 30, + + PMIC1_SWB_VOLTAGE_SETTING = 31, + PMIC1_SWB_VOLTAGE_RANGE_SELECT = 32, + PMIC1_SWB_VOLTAGE_OFFSET = 33, + PMIC1_SWB_VOLTAGE_OFFSET_DIRECTION = 34, + PMIC1_SWB_SEQUENCE_DELAY = 35, + PMIC1_SWB_SEQUENCE_ORDER = 36, + + PMIC1_SWC_VOLTAGE_SETTING = 37, + PMIC1_SWC_VOLTAGE_RANGE_SELECT = 38, + PMIC1_SWC_VOLTAGE_OFFSET = 39, + PMIC1_SWC_VOLTAGE_OFFSET_DIRECTION = 40, + PMIC1_SWC_SEQUENCE_DELAY = 41, + PMIC1_SWC_SEQUENCE_ORDER = 42, + + PMIC1_SWD_VOLTAGE_SETTING = 43, + PMIC1_SWD_VOLTAGE_RANGE_SELECT = 44, + PMIC1_SWD_VOLTAGE_OFFSET = 45, + PMIC1_SWD_VOLTAGE_OFFSET_DIRECTION = 46, + PMIC1_SWD_SEQUENCE_DELAY = 47, + PMIC1_SWD_SEQUENCE_ORDER = 48, + + PMIC0_PHASE_COMB = 49, + PMIC1_PHASE_COMB = 50, + + PMIC0_MFG_ID = 51, + PMIC1_MFG_ID = 52, + + DRAM_MODULE_HEIGHT = 53, + + // Dispatcher set to last enum value + ATTR_EFF_DISPATCHER = DRAM_MODULE_HEIGHT, +}; + +/// +/// @brief explorer ffdc codes +/// +enum ffdc_codes +{ + SET_PMIC0_SWA_VOLTAGE_SETTING = 0x1052, + SET_PMIC0_SWA_VOLTAGE_RANGE_SELECT = 0x1053, + SET_PMIC0_SWA_VOLTAGE_OFFSET = 0x1054, + SET_PMIC0_SWA_VOLTAGE_OFFSET_DIRECTION = 0x1055, + SET_PMIC0_SWA_SEQUENCE_DELAY = 0x1056, + SET_PMIC0_SWA_SEQUENCE_ORDER = 0X1057, + + SET_PMIC0_SWB_VOLTAGE_SETTING = 0x1058, + SET_PMIC0_SWB_VOLTAGE_RANGE_SELECT = 0x1059, + SET_PMIC0_SWB_VOLTAGE_OFFSET = 0x105A, + SET_PMIC0_SWB_VOLTAGE_OFFSET_DIRECTION = 0x105B, + SET_PMIC0_SWB_SEQUENCE_DELAY = 0x105C, + SET_PMIC0_SWB_SEQUENCE_ORDER = 0X105D, + + SET_PMIC0_SWC_VOLTAGE_SETTING = 0x105E, + SET_PMIC0_SWC_VOLTAGE_RANGE_SELECT = 0x105F, + SET_PMIC0_SWC_VOLTAGE_OFFSET = 0x1060, + SET_PMIC0_SWC_VOLTAGE_OFFSET_DIRECTION = 0x1061, + SET_PMIC0_SWC_SEQUENCE_DELAY = 0x1062, + SET_PMIC0_SWC_SEQUENCE_ORDER = 0X1063, + + SET_PMIC0_SWD_VOLTAGE_SETTING = 0x1064, + SET_PMIC0_SWD_VOLTAGE_RANGE_SELECT = 0x1065, + SET_PMIC0_SWD_VOLTAGE_OFFSET = 0x1066, + SET_PMIC0_SWD_VOLTAGE_OFFSET_DIRECTION = 0x1067, + SET_PMIC0_SWD_SEQUENCE_DELAY = 0x1068, + SET_PMIC0_SWD_SEQUENCE_ORDER = 0X1069, + + SET_PMIC1_SWA_VOLTAGE_SETTING = 0x106A, + SET_PMIC1_SWA_VOLTAGE_RANGE_SELECT = 0x106B, + SET_PMIC1_SWA_VOLTAGE_OFFSET = 0x106C, + SET_PMIC1_SWA_VOLTAGE_OFFSET_DIRECTION = 0x106D, + SET_PMIC1_SWA_SEQUENCE_DELAY = 0x106E, + SET_PMIC1_SWA_SEQUENCE_ORDER = 0X106F, + + SET_PMIC1_SWB_VOLTAGE_SETTING = 0x1070, + SET_PMIC1_SWB_VOLTAGE_RANGE_SELECT = 0x1071, + SET_PMIC1_SWB_VOLTAGE_OFFSET = 0x1072, + SET_PMIC1_SWB_VOLTAGE_OFFSET_DIRECTION = 0x1073, + SET_PMIC1_SWB_SEQUENCE_DELAY = 0x1074, + SET_PMIC1_SWB_SEQUENCE_ORDER = 0X1075, + + SET_PMIC1_SWC_VOLTAGE_SETTING = 0x1076, + SET_PMIC1_SWC_VOLTAGE_RANGE_SELECT = 0x1077, + SET_PMIC1_SWC_VOLTAGE_OFFSET = 0x1078, + SET_PMIC1_SWC_VOLTAGE_OFFSET_DIRECTION = 0x1079, + SET_PMIC1_SWC_SEQUENCE_DELAY = 0x107A, + SET_PMIC1_SWC_SEQUENCE_ORDER = 0X107B, + + SET_PMIC1_SWD_VOLTAGE_SETTING = 0x107C, + SET_PMIC1_SWD_VOLTAGE_RANGE_SELECT = 0x107D, + SET_PMIC1_SWD_VOLTAGE_OFFSET = 0x107E, + SET_PMIC1_SWD_VOLTAGE_OFFSET_DIRECTION = 0x107F, + SET_PMIC1_SWD_SEQUENCE_DELAY = 0x1080, + SET_PMIC1_SWD_SEQUENCE_ORDER = 0X1081, + + SET_PMIC0_PHASE_COMB = 0x1082, + SET_PMIC1_PHASE_COMB = 0x1083, + + SET_PMIC0_MFG_ID = 0x1084, + SET_PMIC1_MFG_ID = 0x1085, + + SET_DRAM_MODULE_HEIGHT = 0x1086, +}; + + +} // pmic +} // mss + +#endif diff --git a/src/import/chips/ocmb/common/procedures/xml/attribute_info/pmic_eff_attributes.xml b/src/import/chips/ocmb/common/procedures/xml/attribute_info/pmic_eff_attributes.xml index cf813e35f..59a53831c 100644 --- a/src/import/chips/ocmb/common/procedures/xml/attribute_info/pmic_eff_attributes.xml +++ b/src/import/chips/ocmb/common/procedures/xml/attribute_info/pmic_eff_attributes.xml @@ -23,4 +23,681 @@ + + + ATTR_MEM_EFF_PMIC0_MFG_ID + TARGET_TYPE_MEM_PORT + + Manufacturer ID Code + + + uint16 + + 2 + pmic0_mfg_id + + + + ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_SETTING + TARGET_TYPE_MEM_PORT + + PMIC0 SWA Voltage Setting + + + uint8 + + 2 + pmic0_swa_voltage_setting + + + + ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_RANGE_SELECT + TARGET_TYPE_MEM_PORT + + PMIC0 SWA Voltage Range + + + uint8 + + 2 + pmic0_swa_voltage_range_select + + + + ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_OFFSET + TARGET_TYPE_MEM_PORT + + PMIC0 SWA Voltage Offset in steps (1 bit increments) + + + uint8 + + 2 + pmic0_swa_voltage_offset + + + + ATTR_MEM_EFF_PMIC0_SWA_VOLTAGE_OFFSET_DIRECTION + TARGET_TYPE_MEM_PORT + + Add (0), Subtract (1) + + + uint8 + + 2 + pmic0_swa_voltage_offset_direction + + + + ATTR_MEM_EFF_PMIC0_SWA_SEQUENCE_DELAY + TARGET_TYPE_MEM_PORT + + Delay after the sequence which enables SWA + + + uint8 + + 2 + pmic0_swa_sequence_delay + + + + ATTR_MEM_EFF_PMIC0_SWA_SEQUENCE_ORDER + TARGET_TYPE_MEM_PORT + + The sequence at which SWA will be enabled + + + uint8 + + 2 + pmic0_swa_sequence_order + + + + ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_SETTING + TARGET_TYPE_MEM_PORT + + PMIC0 SWB Voltage Setting + + + uint8 + + 2 + pmic0_swb_voltage_setting + + + + ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_RANGE_SELECT + TARGET_TYPE_MEM_PORT + + PMIC0 SWB Voltage Range + + + uint8 + + 2 + pmic0_swb_voltage_range_select + + + + ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_OFFSET + TARGET_TYPE_MEM_PORT + + PMIC0 SWB Voltage Offset in steps (1 bit increments) + + + uint8 + + 2 + pmic0_swb_voltage_offset + + + + ATTR_MEM_EFF_PMIC0_SWB_VOLTAGE_OFFSET_DIRECTION + TARGET_TYPE_MEM_PORT + + Add (0), Subtract (1) + + + uint8 + + 2 + pmic0_swb_voltage_offset_direction + + + + ATTR_MEM_EFF_PMIC0_SWB_SEQUENCE_DELAY + TARGET_TYPE_MEM_PORT + + Delay after the sequence which enables SWB + + + uint8 + + 2 + pmic0_swb_sequence_delay + + + + ATTR_MEM_EFF_PMIC0_SWB_SEQUENCE_ORDER + TARGET_TYPE_MEM_PORT + + The sequence at which SWB will be enabled + + + uint8 + + 2 + pmic0_swb_sequence_order + + + + ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_SETTING + TARGET_TYPE_MEM_PORT + + PMIC0 SWC Voltage Setting + + + uint8 + + 2 + pmic0_swc_voltage_setting + + + + ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_RANGE_SELECT + TARGET_TYPE_MEM_PORT + + PMIC0 SWC Voltage Range + + + uint8 + + 2 + pmic0_swc_voltage_range_select + + + + ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_OFFSET + TARGET_TYPE_MEM_PORT + + PMIC0 SWC Voltage Offset in steps (1 bit increments) + + + uint8 + + 2 + pmic0_swc_voltage_offset + + + + ATTR_MEM_EFF_PMIC0_SWC_VOLTAGE_OFFSET_DIRECTION + TARGET_TYPE_MEM_PORT + + Add (0), Subtract (1) + + + uint8 + + 2 + pmic0_swc_voltage_offset_direction + + + + ATTR_MEM_EFF_PMIC0_SWC_SEQUENCE_DELAY + TARGET_TYPE_MEM_PORT + + Delay after the sequence which enables SWC + + + uint8 + + 2 + pmic0_swc_sequence_delay + + + + ATTR_MEM_EFF_PMIC0_SWC_SEQUENCE_ORDER + TARGET_TYPE_MEM_PORT + + The sequence at which SWC will be enabled + + + uint8 + + 2 + pmic0_swc_sequence_order + + + + ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_SETTING + TARGET_TYPE_MEM_PORT + + PMIC0 SWD Voltage Setting + + + uint8 + + 2 + pmic0_swd_voltage_setting + + + + ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_RANGE_SELECT + TARGET_TYPE_MEM_PORT + + PMIC0 SWD Voltage Range + + + uint8 + + 2 + pmic0_swd_voltage_range_select + + + + ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_OFFSET + TARGET_TYPE_MEM_PORT + + PMIC0 SWD Voltage Offset in steps (1 bit increments) + + + uint8 + + 2 + pmic0_swd_voltage_offset + + + + ATTR_MEM_EFF_PMIC0_SWD_VOLTAGE_OFFSET_DIRECTION + TARGET_TYPE_MEM_PORT + + Add (0), Subtract (1) + + + uint8 + + 2 + pmic0_swd_voltage_offset_direction + + + + ATTR_MEM_EFF_PMIC0_SWD_SEQUENCE_DELAY + TARGET_TYPE_MEM_PORT + + Delay after the sequence which enables SWD + + + uint8 + + 2 + pmic0_swd_sequence_delay + + + + ATTR_MEM_EFF_PMIC0_SWD_SEQUENCE_ORDER + TARGET_TYPE_MEM_PORT + + The sequence at which SWD will be enabled + + + uint8 + + 2 + pmic0_swd_sequence_order + + + + ATTR_MEM_EFF_PMIC1_MFG_ID + TARGET_TYPE_MEM_PORT + + Manufacturer ID Code + + + uint16 + + 2 + pmic1_mfg_id + + + + ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_SETTING + TARGET_TYPE_MEM_PORT + + PMIC1 SWA Voltage Setting + + + uint8 + + 2 + pmic1_swa_voltage_setting + + + + ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_RANGE_SELECT + TARGET_TYPE_MEM_PORT + + PMIC1 SWA Voltage Range + + + uint8 + + 2 + pmic1_swa_voltage_range_select + + + + ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_OFFSET + TARGET_TYPE_MEM_PORT + + PMIC1 SWA Voltage Offset in steps (1 bit increments) + + + uint8 + + 2 + pmic1_swa_voltage_offset + + + + ATTR_MEM_EFF_PMIC1_SWA_VOLTAGE_OFFSET_DIRECTION + TARGET_TYPE_MEM_PORT + + Add (0), Subtract (1) + + + uint8 + + 2 + pmic1_swa_voltage_offset_direction + + + + ATTR_MEM_EFF_PMIC1_SWA_SEQUENCE_DELAY + TARGET_TYPE_MEM_PORT + + Delay after the sequence which enables SWA + + + uint8 + + 2 + pmic1_swa_sequence_delay + + + + ATTR_MEM_EFF_PMIC1_SWA_SEQUENCE_ORDER + TARGET_TYPE_MEM_PORT + + The sequence at which SWA will be enabled + + + uint8 + + 2 + pmic1_swa_sequence_order + + + + ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_SETTING + TARGET_TYPE_MEM_PORT + + PMIC1 SWB Voltage Setting + + + uint8 + + 2 + pmic1_swb_voltage_setting + + + + ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_RANGE_SELECT + TARGET_TYPE_MEM_PORT + + PMIC1 SWB Voltage Range + + + uint8 + + 2 + pmic1_swb_voltage_range_select + + + + ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_OFFSET + TARGET_TYPE_MEM_PORT + + PMIC1 SWB Voltage Offset in steps (1 bit increments) + + + uint8 + + 2 + pmic1_swb_voltage_offset + + + + ATTR_MEM_EFF_PMIC1_SWB_VOLTAGE_OFFSET_DIRECTION + TARGET_TYPE_MEM_PORT + + Add (0), Subtract (1) + + + uint8 + + 2 + pmic1_swb_voltage_offset_direction + + + + ATTR_MEM_EFF_PMIC1_SWB_SEQUENCE_DELAY + TARGET_TYPE_MEM_PORT + + Delay after the sequence which enables SWB + + + uint8 + + 2 + pmic1_swb_sequence_delay + + + + ATTR_MEM_EFF_PMIC1_SWB_SEQUENCE_ORDER + TARGET_TYPE_MEM_PORT + + The sequence at which SWB will be enabled + + + uint8 + + 2 + pmic1_swb_sequence_order + + + + ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_SETTING + TARGET_TYPE_MEM_PORT + + PMIC1 SWC Voltage Setting + + + uint8 + + 2 + pmic1_swc_voltage_setting + + + + ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_RANGE_SELECT + TARGET_TYPE_MEM_PORT + + PMIC1 SWC Voltage Range + + + uint8 + + 2 + pmic1_swc_voltage_range_select + + + + ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_OFFSET + TARGET_TYPE_MEM_PORT + + PMIC1 SWC Voltage Offset in steps (1 bit increments) + + + uint8 + + 2 + pmic1_swc_voltage_offset + + + + ATTR_MEM_EFF_PMIC1_SWC_VOLTAGE_OFFSET_DIRECTION + TARGET_TYPE_MEM_PORT + + Add (0), Subtract (1) + + + uint8 + + 2 + pmic1_swc_voltage_offset_direction + + + + ATTR_MEM_EFF_PMIC1_SWC_SEQUENCE_DELAY + TARGET_TYPE_MEM_PORT + + Delay after the sequence which enables SWC + + + uint8 + + 2 + pmic1_swc_sequence_delay + + + + ATTR_MEM_EFF_PMIC1_SWC_SEQUENCE_ORDER + TARGET_TYPE_MEM_PORT + + The sequence at which SWC will be enabled + + + uint8 + + 2 + pmic1_swc_sequence_order + + + + ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_SETTING + TARGET_TYPE_MEM_PORT + + PMIC1 SWD Voltage Setting + + + uint8 + + 2 + pmic1_swd_voltage_setting + + + + ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_RANGE_SELECT + TARGET_TYPE_MEM_PORT + + PMIC1 SWD Voltage Range + + + uint8 + + 2 + pmic1_swd_voltage_range_select + + + + ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_OFFSET + TARGET_TYPE_MEM_PORT + + PMIC1 SWD Voltage Offset in steps (1 bit increments) + + + uint8 + + 2 + pmic1_swd_voltage_offset + + + + ATTR_MEM_EFF_PMIC1_SWD_VOLTAGE_OFFSET_DIRECTION + TARGET_TYPE_MEM_PORT + + Add (0), Subtract (1) + + + uint8 + + 2 + pmic1_swd_voltage_offset_direction + + + + ATTR_MEM_EFF_PMIC1_SWD_SEQUENCE_DELAY + TARGET_TYPE_MEM_PORT + + Delay after the sequence which enables SWD + + + uint8 + + 2 + pmic1_swd_sequence_delay + + + + ATTR_MEM_EFF_PMIC1_SWD_SEQUENCE_ORDER + TARGET_TYPE_MEM_PORT + + The sequence at which SWD will be enabled + + + uint8 + + 2 + pmic1_swd_sequence_order + + + + ATTR_MEM_EFF_PMIC0_PHASE_COMB + TARGET_TYPE_MEM_PORT + + Phase configuration for PMIC0 + + + uint8 + + 2 + pmic0_phase_comb + + + + ATTR_MEM_EFF_PMIC1_PHASE_COMB + TARGET_TYPE_MEM_PORT + + Phase configuration for PMIC1 + + + uint8 + + 2 + pmic1_phase_comb + + diff --git a/src/import/generic/memory/lib/spd/spd_facade.H b/src/import/generic/memory/lib/spd/spd_facade.H index 7f1769f77..81689604f 100644 --- a/src/import/generic/memory/lib/spd/spd_facade.H +++ b/src/import/generic/memory/lib/spd/spd_facade.H @@ -1059,6 +1059,20 @@ class facade final fapi_try_exit: return fapi2::current_err; } + + /// + /// @brief Decodes module base height + /// @param[out] o_value SPD encoded value + /// @return FAPI2_RC_SUCCESS if okay + /// + fapi2::ReturnCode module_base_height(uint8_t& o_value) const + { + FAPI_TRY( iv_dimm_module_decoder->module_base_height(o_value) ); + + fapi_try_exit: + return fapi2::current_err; + } + /// /// @brief Decodes module nominal height max /// @param[out] o_value SPD encoded value -- cgit v1.2.1