| // Copyright lowRISC contributors. |
| // Licensed under the Apache License, Version 2.0, see LICENSE for details. |
| // SPDX-License-Identifier: Apache-2.0 |
| |
| #include "sw/device/lib/dif/dif_sysrst_ctrl.h" |
| |
| #include "gtest/gtest.h" |
| #include "sw/device/lib/base/bitfield.h" |
| #include "sw/device/lib/base/mock_mmio.h" |
| #include "sw/device/lib/dif/dif_base.h" |
| #include "sw/device/lib/dif/dif_test_base.h" |
| |
| #include "sysrst_ctrl_regs.h" // Generated. |
| |
| namespace dif_sysrst_ctrl_unittest { |
| namespace { |
| using ::mock_mmio::LeInt; |
| using ::mock_mmio::MmioTest; |
| using ::mock_mmio::MockDevice; |
| |
| class SysrstCtrlTest : public testing::Test, public MmioTest { |
| protected: |
| dif_sysrst_ctrl_t sysrst_ctrl_ = {.base_addr = dev().region()}; |
| }; |
| |
| class KeyComboDetectConfigTest : public SysrstCtrlTest { |
| protected: |
| dif_sysrst_ctrl_key_combo_config_t config_ = { |
| .keys = kDifSysrstCtrlKey0 | kDifSysrstCtrlKeyPowerButton, |
| .detection_time_threshold = 0x5000, |
| .actions = kDifSysrstCtrlKeyComboActionEcReset, |
| .embedded_controller_reset_duration = 0x100, |
| }; |
| }; |
| |
| TEST_F(KeyComboDetectConfigTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_key_combo_detect_configure( |
| nullptr, kDifSysrstCtrlKeyCombo1, config_)); |
| } |
| |
| TEST_F(KeyComboDetectConfigTest, BadArgs) { |
| // Bad key combination. |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_key_combo_detect_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlKeyComboAll, config_)); |
| |
| // Bad keys. |
| config_.keys = 1U << 5; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_key_combo_detect_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlKeyCombo1, config_)); |
| |
| // Bad actions. |
| config_.keys = kDifSysrstCtrlKey0 | kDifSysrstCtrlKeyPowerButton, |
| config_.actions = static_cast<dif_sysrst_ctrl_key_combo_action_t>(1U << 5); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_key_combo_detect_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlKeyCombo1, config_)); |
| } |
| |
| TEST_F(KeyComboDetectConfigTest, Locked) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_EQ(dif_sysrst_ctrl_key_combo_detect_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlKeyCombo1, config_), |
| kDifLocked); |
| } |
| |
| TEST_F(KeyComboDetectConfigTest, SuccessWithoutEcReset) { |
| config_.actions = kDifSysrstCtrlKeyComboActionInterrupt | |
| kDifSysrstCtrlKeyComboActionBatteryDisable; |
| |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_WRITE32(SYSRST_CTRL_COM_SEL_CTL_1_REG_OFFSET, config_.keys); |
| EXPECT_WRITE32(SYSRST_CTRL_COM_DET_CTL_1_REG_OFFSET, |
| config_.detection_time_threshold); |
| EXPECT_WRITE32(SYSRST_CTRL_COM_OUT_CTL_1_REG_OFFSET, config_.actions); |
| |
| EXPECT_DIF_OK(dif_sysrst_ctrl_key_combo_detect_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlKeyCombo1, config_)); |
| } |
| |
| TEST_F(KeyComboDetectConfigTest, SuccessWithEcReset) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_WRITE32(SYSRST_CTRL_COM_SEL_CTL_1_REG_OFFSET, config_.keys); |
| EXPECT_WRITE32(SYSRST_CTRL_COM_DET_CTL_1_REG_OFFSET, |
| config_.detection_time_threshold); |
| EXPECT_WRITE32(SYSRST_CTRL_COM_OUT_CTL_1_REG_OFFSET, config_.actions); |
| EXPECT_WRITE32(SYSRST_CTRL_EC_RST_CTL_REG_OFFSET, |
| config_.embedded_controller_reset_duration); |
| |
| EXPECT_DIF_OK(dif_sysrst_ctrl_key_combo_detect_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlKeyCombo1, config_)); |
| } |
| |
| class InputChangeDetectConfigTest : public SysrstCtrlTest { |
| protected: |
| dif_sysrst_ctrl_input_change_config_t config_ = { |
| .input_changes = kDifSysrstCtrlInputAll, |
| .debounce_time_threshold = 0x1000, |
| }; |
| }; |
| |
| TEST_F(InputChangeDetectConfigTest, NullArgs) { |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_input_change_detect_configure(nullptr, config_)); |
| } |
| |
| TEST_F(InputChangeDetectConfigTest, BadArgs) { |
| // Bad input signal changes. |
| config_.input_changes = static_cast<dif_sysrst_ctrl_input_change_t>(1U << 14); |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_input_change_detect_configure(&sysrst_ctrl_, config_)); |
| } |
| |
| TEST_F(InputChangeDetectConfigTest, Locked) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_EQ( |
| dif_sysrst_ctrl_input_change_detect_configure(&sysrst_ctrl_, config_), |
| kDifLocked); |
| } |
| |
| TEST_F(InputChangeDetectConfigTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_WRITE32(SYSRST_CTRL_KEY_INTR_CTL_REG_OFFSET, config_.input_changes); |
| EXPECT_WRITE32(SYSRST_CTRL_KEY_INTR_DEBOUNCE_CTL_REG_OFFSET, |
| config_.debounce_time_threshold); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_input_change_detect_configure(&sysrst_ctrl_, config_)); |
| } |
| |
| class OutputPinOverrideConfigTest : public SysrstCtrlTest { |
| protected: |
| dif_sysrst_ctrl_pin_config_t config_ = { |
| .enabled = kDifToggleEnabled, |
| .allow_zero = true, |
| .allow_one = true, |
| .override_value = true, |
| }; |
| }; |
| |
| TEST_F(OutputPinOverrideConfigTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_configure( |
| nullptr, kDifSysrstCtrlPinBatteryDisableOut, config_)); |
| } |
| |
| TEST_F(OutputPinOverrideConfigTest, BadArgs) { |
| // Bad pin. |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey0In, config_)); |
| |
| // Bad enabled. |
| config_.enabled = static_cast<dif_toggle_t>(2); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey0Out, config_)); |
| |
| // Bad allow values. |
| config_ = { |
| .enabled = kDifToggleEnabled, |
| .allow_zero = false, |
| .allow_one = true, |
| .override_value = false, |
| }; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlPinBatteryDisableOut, config_)); |
| config_ = { |
| .enabled = kDifToggleEnabled, |
| .allow_zero = true, |
| .allow_one = false, |
| .override_value = true, |
| }; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlPinBatteryDisableOut, config_)); |
| } |
| |
| TEST_F(OutputPinOverrideConfigTest, Locked) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_EQ(dif_sysrst_ctrl_output_pin_override_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlPinBatteryDisableOut, config_), |
| kDifLocked); |
| } |
| |
| TEST_F(OutputPinOverrideConfigTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_CTL_Z3_WAKEUP_BIT, 1}}); |
| EXPECT_WRITE32(SYSRST_CTRL_PIN_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_CTL_BAT_DISABLE_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_CTL_Z3_WAKEUP_BIT, 1}}); |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_VALUE_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_VALUE_Z3_WAKEUP_BIT, 1}}); |
| EXPECT_WRITE32(SYSRST_CTRL_PIN_OUT_VALUE_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_VALUE_BAT_DISABLE_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_VALUE_Z3_WAKEUP_BIT, 1}}); |
| EXPECT_READ32(SYSRST_CTRL_PIN_ALLOWED_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_ALLOWED_CTL_Z3_WAKEUP_0_BIT, 1}}); |
| EXPECT_WRITE32(SYSRST_CTRL_PIN_ALLOWED_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_ALLOWED_CTL_Z3_WAKEUP_0_BIT, 1}, |
| {SYSRST_CTRL_PIN_ALLOWED_CTL_BAT_DISABLE_0_BIT, 1}, |
| {SYSRST_CTRL_PIN_ALLOWED_CTL_BAT_DISABLE_1_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_override_configure( |
| &sysrst_ctrl_, kDifSysrstCtrlPinBatteryDisableOut, config_)); |
| } |
| |
| class UlpWakeupConfigTest : public SysrstCtrlTest { |
| protected: |
| dif_sysrst_ctrl_ulp_wakeup_config_t config_ = { |
| .enabled = kDifToggleEnabled, |
| .ac_power_debounce_time_threshold = 0x100, |
| .lid_open_debounce_time_threshold = 0x200, |
| .power_button_debounce_time_threshold = 0x300, |
| }; |
| }; |
| |
| TEST_F(UlpWakeupConfigTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_ulp_wakeup_configure(nullptr, config_)); |
| } |
| |
| TEST_F(UlpWakeupConfigTest, BadArgs) { |
| // Bad enabled. |
| config_.enabled = static_cast<dif_toggle_t>(2); |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_ulp_wakeup_configure(&sysrst_ctrl_, config_)); |
| } |
| |
| TEST_F(UlpWakeupConfigTest, Locked) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_EQ(dif_sysrst_ctrl_ulp_wakeup_configure(&sysrst_ctrl_, config_), |
| kDifLocked); |
| } |
| |
| TEST_F(UlpWakeupConfigTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_WRITE32(SYSRST_CTRL_ULP_CTL_REG_OFFSET, 1); |
| EXPECT_WRITE32(SYSRST_CTRL_ULP_AC_DEBOUNCE_CTL_REG_OFFSET, |
| config_.ac_power_debounce_time_threshold); |
| EXPECT_WRITE32(SYSRST_CTRL_ULP_LID_DEBOUNCE_CTL_REG_OFFSET, |
| config_.lid_open_debounce_time_threshold); |
| EXPECT_WRITE32(SYSRST_CTRL_ULP_PWRB_DEBOUNCE_CTL_REG_OFFSET, |
| config_.power_button_debounce_time_threshold); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_ulp_wakeup_configure(&sysrst_ctrl_, config_)); |
| } |
| |
| class UlpWakeupSetEnabledTest : public SysrstCtrlTest {}; |
| |
| TEST_F(UlpWakeupSetEnabledTest, NullArgs) { |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_ulp_wakeup_set_enabled(nullptr, kDifToggleEnabled)); |
| } |
| |
| TEST_F(UlpWakeupSetEnabledTest, BadEnabled) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_ulp_wakeup_set_enabled( |
| &sysrst_ctrl_, static_cast<dif_toggle_t>(2))); |
| } |
| |
| TEST_F(UlpWakeupSetEnabledTest, Success) { |
| EXPECT_WRITE32(SYSRST_CTRL_ULP_CTL_REG_OFFSET, 0); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_ulp_wakeup_set_enabled(&sysrst_ctrl_, |
| kDifToggleDisabled)); |
| |
| EXPECT_WRITE32(SYSRST_CTRL_ULP_CTL_REG_OFFSET, 1); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_ulp_wakeup_set_enabled(&sysrst_ctrl_, kDifToggleEnabled)); |
| } |
| |
| class UlpWakeupGetEnabledTest : public SysrstCtrlTest {}; |
| |
| TEST_F(UlpWakeupGetEnabledTest, NullArgs) { |
| dif_toggle_t is_enabled; |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_ulp_wakeup_get_enabled(nullptr, &is_enabled)); |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_ulp_wakeup_get_enabled(&sysrst_ctrl_, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_ulp_wakeup_get_enabled(nullptr, nullptr)); |
| } |
| |
| TEST_F(UlpWakeupGetEnabledTest, Success) { |
| dif_toggle_t is_enabled; |
| |
| EXPECT_READ32(SYSRST_CTRL_ULP_CTL_REG_OFFSET, 0); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_ulp_wakeup_get_enabled(&sysrst_ctrl_, &is_enabled)); |
| EXPECT_EQ(is_enabled, kDifToggleDisabled); |
| |
| EXPECT_READ32(SYSRST_CTRL_ULP_CTL_REG_OFFSET, 1); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_ulp_wakeup_get_enabled(&sysrst_ctrl_, &is_enabled)); |
| EXPECT_EQ(is_enabled, kDifToggleEnabled); |
| } |
| |
| class PinsSetInvertedTest : public SysrstCtrlTest { |
| protected: |
| uint32_t pins_ = kDifSysrstCtrlPinKey1Out | kDifSysrstCtrlPinPowerButtonIn; |
| }; |
| |
| TEST_F(PinsSetInvertedTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_pins_set_inverted(nullptr, pins_, true)); |
| } |
| |
| TEST_F(PinsSetInvertedTest, BadPins) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_pins_set_inverted( |
| &sysrst_ctrl_, pins_ | kDifSysrstCtrlPinEcResetInOut, true)); |
| } |
| |
| TEST_F(PinsSetInvertedTest, Locked) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_EQ(dif_sysrst_ctrl_pins_set_inverted(&sysrst_ctrl_, pins_, true), |
| kDifLocked); |
| } |
| |
| TEST_F(PinsSetInvertedTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_READ32(SYSRST_CTRL_KEY_INVERT_CTL_REG_OFFSET, 0); |
| EXPECT_WRITE32(SYSRST_CTRL_KEY_INVERT_CTL_REG_OFFSET, pins_); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_pins_set_inverted(&sysrst_ctrl_, pins_, true)); |
| |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_READ32(SYSRST_CTRL_KEY_INVERT_CTL_REG_OFFSET, |
| pins_ | kDifSysrstCtrlPinBatteryDisableOut); |
| EXPECT_WRITE32(SYSRST_CTRL_KEY_INVERT_CTL_REG_OFFSET, |
| kDifSysrstCtrlPinBatteryDisableOut); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_pins_set_inverted(&sysrst_ctrl_, pins_, false)); |
| } |
| |
| class PinsGetInvertedTest : public SysrstCtrlTest {}; |
| |
| TEST_F(PinsGetInvertedTest, NullArgs) { |
| uint32_t inverted_pins; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_pins_get_inverted(nullptr, &inverted_pins)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_pins_get_inverted(&sysrst_ctrl_, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_pins_get_inverted(nullptr, nullptr)); |
| } |
| |
| TEST_F(PinsGetInvertedTest, Success) { |
| uint32_t inverted_pins; |
| EXPECT_READ32(SYSRST_CTRL_KEY_INVERT_CTL_REG_OFFSET, |
| kDifSysrstCtrlPinKey0In | kDifSysrstCtrlPinKey2Out); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_pins_get_inverted(&sysrst_ctrl_, &inverted_pins)); |
| EXPECT_EQ(inverted_pins, kDifSysrstCtrlPinKey0In | kDifSysrstCtrlPinKey2Out); |
| } |
| |
| class PinOverrideSetAllowedTest : public SysrstCtrlTest {}; |
| |
| TEST_F(PinOverrideSetAllowedTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_set_allowed( |
| nullptr, kDifSysrstCtrlPinKey1Out, true, true)); |
| } |
| |
| TEST_F(PinOverrideSetAllowedTest, BadPin) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_set_allowed( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1In, true, true)); |
| } |
| |
| TEST_F(PinOverrideSetAllowedTest, Locked) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_EQ(dif_sysrst_ctrl_output_pin_override_set_allowed( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, true, true), |
| kDifLocked); |
| } |
| |
| TEST_F(PinOverrideSetAllowedTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_READ32(SYSRST_CTRL_PIN_ALLOWED_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_ALLOWED_CTL_PWRB_OUT_0_BIT, 1}}); |
| EXPECT_WRITE32(SYSRST_CTRL_PIN_ALLOWED_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_ALLOWED_CTL_PWRB_OUT_0_BIT, 1}, |
| {SYSRST_CTRL_PIN_ALLOWED_CTL_EC_RST_L_0_BIT, 1}, |
| {SYSRST_CTRL_PIN_ALLOWED_CTL_EC_RST_L_1_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_override_set_allowed( |
| &sysrst_ctrl_, kDifSysrstCtrlPinEcResetInOut, true, true)); |
| } |
| |
| class PinOverrideGetAllowedTest : public SysrstCtrlTest {}; |
| |
| TEST_F(PinOverrideGetAllowedTest, NullArgs) { |
| bool allow_zero_; |
| bool allow_one_; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_allowed( |
| nullptr, kDifSysrstCtrlPinKey1Out, &allow_zero_, &allow_one_)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_allowed( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, nullptr, &allow_one_)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_allowed( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, &allow_zero_, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_allowed( |
| nullptr, kDifSysrstCtrlPinKey1Out, nullptr, nullptr)); |
| } |
| |
| TEST_F(PinOverrideGetAllowedTest, BadPin) { |
| bool allow_zero_; |
| bool allow_one_; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_allowed( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1In, &allow_zero_, &allow_one_)); |
| } |
| |
| TEST_F(PinOverrideGetAllowedTest, Success) { |
| bool allow_zero_; |
| bool allow_one_; |
| EXPECT_READ32(SYSRST_CTRL_PIN_ALLOWED_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_ALLOWED_CTL_PWRB_OUT_0_BIT, 1}, |
| {SYSRST_CTRL_PIN_ALLOWED_CTL_EC_RST_L_0_BIT, 1}, |
| {SYSRST_CTRL_PIN_ALLOWED_CTL_EC_RST_L_1_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_override_get_allowed( |
| &sysrst_ctrl_, kDifSysrstCtrlPinEcResetInOut, &allow_zero_, &allow_one_)); |
| EXPECT_TRUE(allow_zero_); |
| EXPECT_TRUE(allow_one_); |
| } |
| |
| class PinOverrideSetEnabledTest : public SysrstCtrlTest {}; |
| |
| TEST_F(PinOverrideSetEnabledTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_set_enabled( |
| nullptr, kDifSysrstCtrlPinKey1Out, kDifToggleEnabled)); |
| } |
| |
| TEST_F(PinOverrideSetEnabledTest, BadArgs) { |
| // Bad enabled. |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_set_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, static_cast<dif_toggle_t>(2))); |
| // Bad pin. |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_set_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1In, kDifToggleEnabled)); |
| } |
| |
| TEST_F(PinOverrideSetEnabledTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_CTL_Z3_WAKEUP_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_CTL_KEY2_OUT_BIT, 1}}); |
| EXPECT_WRITE32(SYSRST_CTRL_PIN_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_CTL_Z3_WAKEUP_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_CTL_KEY2_OUT_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_CTL_KEY1_OUT_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_override_set_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, kDifToggleEnabled)); |
| |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_CTL_Z3_WAKEUP_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_CTL_KEY2_OUT_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_CTL_KEY1_OUT_BIT, 1}}); |
| EXPECT_WRITE32(SYSRST_CTRL_PIN_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_CTL_Z3_WAKEUP_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_CTL_KEY1_OUT_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_override_set_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey2Out, kDifToggleDisabled)); |
| } |
| |
| class PinOverrideGetEnabledTest : public SysrstCtrlTest {}; |
| |
| TEST_F(PinOverrideGetEnabledTest, NullArgs) { |
| dif_toggle_t is_enabled; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_enabled( |
| nullptr, kDifSysrstCtrlPinKey1Out, &is_enabled)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_enabled( |
| nullptr, kDifSysrstCtrlPinKey1Out, nullptr)); |
| } |
| |
| TEST_F(PinOverrideGetEnabledTest, BadPin) { |
| dif_toggle_t is_enabled; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_override_get_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1In, &is_enabled)); |
| } |
| |
| TEST_F(PinOverrideGetEnabledTest, Success) { |
| dif_toggle_t is_enabled; |
| |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_CTL_Z3_WAKEUP_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_override_get_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlPinZ3WakeupOut, &is_enabled)); |
| EXPECT_EQ(is_enabled, kDifToggleEnabled); |
| |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_CTL_REG_OFFSET, 0); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_override_get_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlPinZ3WakeupOut, &is_enabled)); |
| EXPECT_EQ(is_enabled, kDifToggleDisabled); |
| } |
| |
| class PinSetOverrideTest : public SysrstCtrlTest {}; |
| |
| TEST_F(PinSetOverrideTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_set_override( |
| nullptr, kDifSysrstCtrlPinKey1Out, true)); |
| } |
| |
| TEST_F(PinSetOverrideTest, BadPin) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_set_override( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1In, true)); |
| } |
| |
| TEST_F(PinSetOverrideTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_VALUE_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_VALUE_FLASH_WP_L_BIT, 1}}); |
| EXPECT_WRITE32(SYSRST_CTRL_PIN_OUT_VALUE_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_VALUE_KEY1_OUT_BIT, 1}, |
| {SYSRST_CTRL_PIN_OUT_VALUE_FLASH_WP_L_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_set_override( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, true)); |
| } |
| |
| class PinGetOverrideTest : public SysrstCtrlTest {}; |
| |
| TEST_F(PinGetOverrideTest, NullArgs) { |
| bool value; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_get_override( |
| nullptr, kDifSysrstCtrlPinKey1Out, &value)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_get_override( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_get_override( |
| nullptr, kDifSysrstCtrlPinKey1Out, nullptr)); |
| } |
| |
| TEST_F(PinGetOverrideTest, BadPin) { |
| bool value; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_output_pin_get_override( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1In, &value)); |
| } |
| |
| TEST_F(PinGetOverrideTest, Success) { |
| bool value; |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_VALUE_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_VALUE_KEY1_OUT_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_get_override( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1Out, &value)); |
| EXPECT_TRUE(value); |
| |
| EXPECT_READ32(SYSRST_CTRL_PIN_OUT_VALUE_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_OUT_VALUE_KEY1_OUT_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_output_pin_get_override( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey2Out, &value)); |
| EXPECT_FALSE(value); |
| } |
| |
| class InputPinReadTest : public SysrstCtrlTest {}; |
| |
| TEST_F(InputPinReadTest, NullArgs) { |
| bool value; |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_input_pin_read(nullptr, kDifSysrstCtrlPinKey2In, &value)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_input_pin_read( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey2In, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_input_pin_read( |
| nullptr, kDifSysrstCtrlPinKey2In, nullptr)); |
| } |
| |
| TEST_F(InputPinReadTest, BadPin) { |
| bool value; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_input_pin_read( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey2Out, &value)); |
| } |
| |
| TEST_F(InputPinReadTest, Success) { |
| bool value; |
| EXPECT_READ32(SYSRST_CTRL_PIN_IN_VALUE_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_IN_VALUE_KEY1_IN_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_input_pin_read( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey1In, &value)); |
| EXPECT_TRUE(value); |
| |
| EXPECT_READ32(SYSRST_CTRL_PIN_IN_VALUE_REG_OFFSET, |
| {{SYSRST_CTRL_PIN_IN_VALUE_KEY1_IN_BIT, 1}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_input_pin_read( |
| &sysrst_ctrl_, kDifSysrstCtrlPinKey2In, &value)); |
| EXPECT_FALSE(value); |
| } |
| |
| class AutoOverrideConfigTest : public SysrstCtrlTest { |
| protected: |
| dif_sysrst_ctrl_auto_override_config_t config_ = { |
| .debounce_time_threshold = 0x150, |
| .override_key_0 = kDifToggleEnabled, |
| .key_0_override_value = false, |
| .override_key_1 = kDifToggleDisabled, |
| .key_1_override_value = true, |
| .override_key_2 = kDifToggleEnabled, |
| .key_2_override_value = true, |
| }; |
| }; |
| |
| TEST_F(AutoOverrideConfigTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_configure(nullptr, config_, |
| kDifToggleEnabled)); |
| } |
| |
| TEST_F(AutoOverrideConfigTest, BadArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_configure( |
| &sysrst_ctrl_, config_, static_cast<dif_toggle_t>(2))); |
| |
| config_.override_key_0 = static_cast<dif_toggle_t>(2); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_configure( |
| &sysrst_ctrl_, config_, kDifToggleEnabled)); |
| config_.override_key_0 = kDifToggleEnabled; |
| |
| config_.override_key_1 = static_cast<dif_toggle_t>(2); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_configure( |
| &sysrst_ctrl_, config_, kDifToggleEnabled)); |
| config_.override_key_1 = kDifToggleDisabled; |
| |
| config_.override_key_2 = static_cast<dif_toggle_t>(2); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_configure( |
| &sysrst_ctrl_, config_, kDifToggleEnabled)); |
| config_.override_key_2 = kDifToggleEnabled; |
| } |
| |
| TEST_F(AutoOverrideConfigTest, Locked) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_EQ(dif_sysrst_ctrl_auto_override_configure(&sysrst_ctrl_, config_, |
| kDifToggleEnabled), |
| kDifLocked); |
| } |
| |
| TEST_F(AutoOverrideConfigTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_WRITE32( |
| SYSRST_CTRL_AUTO_BLOCK_DEBOUNCE_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_AUTO_BLOCK_DEBOUNCE_CTL_AUTO_BLOCK_ENABLE_BIT, true}, |
| {SYSRST_CTRL_AUTO_BLOCK_DEBOUNCE_CTL_DEBOUNCE_TIMER_OFFSET, |
| config_.debounce_time_threshold}}); |
| EXPECT_WRITE32(SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY0_OUT_SEL_BIT, true}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY1_OUT_SEL_BIT, false}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY2_OUT_SEL_BIT, true}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY0_OUT_VALUE_BIT, false}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY1_OUT_VALUE_BIT, true}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY2_OUT_VALUE_BIT, true}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_auto_override_configure(&sysrst_ctrl_, config_, |
| kDifToggleEnabled)); |
| } |
| |
| class AutoOverrideSetEnabledTest : public SysrstCtrlTest {}; |
| |
| TEST_F(AutoOverrideSetEnabledTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_set_enabled( |
| nullptr, kDifSysrstCtrlKey1, kDifToggleEnabled)); |
| } |
| |
| TEST_F(AutoOverrideSetEnabledTest, BadArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_set_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlKeyPowerButton, kDifToggleEnabled)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_set_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlKey2, static_cast<dif_toggle_t>(2))); |
| } |
| |
| TEST_F(AutoOverrideSetEnabledTest, Locked) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_EQ(dif_sysrst_ctrl_auto_override_set_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlKey2, kDifToggleEnabled), |
| kDifLocked); |
| } |
| |
| TEST_F(AutoOverrideSetEnabledTest, Success) { |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_READ32(SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY0_OUT_SEL_BIT, true}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY1_OUT_SEL_BIT, false}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY2_OUT_SEL_BIT, true}}); |
| EXPECT_WRITE32(SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY0_OUT_SEL_BIT, true}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY1_OUT_SEL_BIT, false}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY2_OUT_SEL_BIT, false}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_auto_override_set_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlKey2, kDifToggleDisabled)); |
| } |
| |
| class AutoOverrideGetEnabledTest : public SysrstCtrlTest {}; |
| |
| TEST_F(AutoOverrideGetEnabledTest, NullArgs) { |
| dif_toggle_t is_enabled; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_get_enabled( |
| nullptr, kDifSysrstCtrlKey1, &is_enabled)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_get_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlKey1, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_get_enabled( |
| nullptr, kDifSysrstCtrlKey1, nullptr)); |
| } |
| |
| TEST_F(AutoOverrideGetEnabledTest, BadKey) { |
| dif_toggle_t is_enabled; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_auto_override_get_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlKeyPowerButton, &is_enabled)); |
| } |
| |
| TEST_F(AutoOverrideGetEnabledTest, Success) { |
| dif_toggle_t is_enabled; |
| EXPECT_READ32(SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_REG_OFFSET, |
| {{SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY0_OUT_SEL_BIT, true}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY1_OUT_SEL_BIT, false}, |
| {SYSRST_CTRL_AUTO_BLOCK_OUT_CTL_KEY2_OUT_SEL_BIT, true}}); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_auto_override_get_enabled( |
| &sysrst_ctrl_, kDifSysrstCtrlKey2, &is_enabled)); |
| EXPECT_EQ(is_enabled, kDifToggleEnabled); |
| } |
| |
| class KeyComboIrqGetCausesTest : public SysrstCtrlTest {}; |
| |
| TEST_F(KeyComboIrqGetCausesTest, NullArgs) { |
| uint32_t causes; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_key_combo_irq_get_causes(nullptr, &causes)); |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_key_combo_irq_get_causes(&sysrst_ctrl_, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_key_combo_irq_get_causes(nullptr, nullptr)); |
| } |
| |
| TEST_F(KeyComboIrqGetCausesTest, Success) { |
| uint32_t causes; |
| EXPECT_READ32(SYSRST_CTRL_COMBO_INTR_STATUS_REG_OFFSET, 0xf); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_key_combo_irq_get_causes(&sysrst_ctrl_, &causes)); |
| EXPECT_EQ(causes, 0xf); |
| } |
| |
| class KeyComboIrqClearCausesTest : public SysrstCtrlTest {}; |
| |
| TEST_F(KeyComboIrqClearCausesTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_key_combo_irq_clear_causes(nullptr, 0xf)); |
| } |
| |
| TEST_F(KeyComboIrqClearCausesTest, BadCauses) { |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_key_combo_irq_clear_causes(&sysrst_ctrl_, 0x1f)); |
| } |
| |
| TEST_F(KeyComboIrqClearCausesTest, Success) { |
| EXPECT_WRITE32(SYSRST_CTRL_COMBO_INTR_STATUS_REG_OFFSET, 0xf); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_key_combo_irq_clear_causes(&sysrst_ctrl_, 0xf)); |
| } |
| |
| class InputChangeIrqGetCausesTest : public SysrstCtrlTest {}; |
| |
| TEST_F(InputChangeIrqGetCausesTest, NullArgs) { |
| uint32_t causes; |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_input_change_irq_get_causes(nullptr, &causes)); |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_input_change_irq_get_causes(&sysrst_ctrl_, nullptr)); |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_input_change_irq_get_causes(nullptr, nullptr)); |
| } |
| |
| TEST_F(InputChangeIrqGetCausesTest, Success) { |
| uint32_t causes; |
| EXPECT_READ32(SYSRST_CTRL_KEY_INTR_STATUS_REG_OFFSET, 0x3f); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_input_change_irq_get_causes(&sysrst_ctrl_, &causes)); |
| EXPECT_EQ(causes, 0x3f); |
| } |
| |
| class InputChangeIrqClearCausesTest : public SysrstCtrlTest {}; |
| |
| TEST_F(InputChangeIrqClearCausesTest, NullArgs) { |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_input_change_irq_clear_causes(nullptr, 0xf)); |
| } |
| |
| TEST_F(InputChangeIrqClearCausesTest, BadCauses) { |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_input_change_irq_clear_causes(&sysrst_ctrl_, 0x4000)); |
| } |
| |
| TEST_F(InputChangeIrqClearCausesTest, Success) { |
| EXPECT_WRITE32(SYSRST_CTRL_KEY_INTR_STATUS_REG_OFFSET, 0xff); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_input_change_irq_clear_causes(&sysrst_ctrl_, 0xff)); |
| } |
| |
| class UlpWakeupGetStatusTest : public SysrstCtrlTest {}; |
| |
| TEST_F(UlpWakeupGetStatusTest, NullArgs) { |
| bool wakeup_detected; |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_ulp_wakeup_get_status(nullptr, &wakeup_detected)); |
| EXPECT_DIF_BADARG( |
| dif_sysrst_ctrl_ulp_wakeup_get_status(&sysrst_ctrl_, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_ulp_wakeup_get_status(nullptr, nullptr)); |
| } |
| |
| TEST_F(UlpWakeupGetStatusTest, Success) { |
| bool wakeup_detected; |
| EXPECT_READ32(SYSRST_CTRL_WKUP_STATUS_REG_OFFSET, 1); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_ulp_wakeup_get_status(&sysrst_ctrl_, &wakeup_detected)); |
| EXPECT_TRUE(wakeup_detected); |
| |
| EXPECT_READ32(SYSRST_CTRL_WKUP_STATUS_REG_OFFSET, 0); |
| EXPECT_DIF_OK( |
| dif_sysrst_ctrl_ulp_wakeup_get_status(&sysrst_ctrl_, &wakeup_detected)); |
| EXPECT_FALSE(wakeup_detected); |
| } |
| |
| class UlpWakeupClearStatusTest : public SysrstCtrlTest {}; |
| |
| TEST_F(UlpWakeupClearStatusTest, NullArgs) { |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_ulp_wakeup_clear_status(nullptr)); |
| } |
| |
| TEST_F(UlpWakeupClearStatusTest, Success) { |
| EXPECT_WRITE32(SYSRST_CTRL_WKUP_STATUS_REG_OFFSET, 1); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_ulp_wakeup_clear_status(&sysrst_ctrl_)); |
| } |
| |
| class LockTest : public SysrstCtrlTest {}; |
| |
| TEST_F(LockTest, NullArgs) { EXPECT_DIF_BADARG(dif_sysrst_ctrl_lock(nullptr)); } |
| |
| TEST_F(LockTest, Success) { |
| EXPECT_WRITE32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_lock(&sysrst_ctrl_)); |
| } |
| |
| class IsLockedTest : public SysrstCtrlTest {}; |
| |
| TEST_F(IsLockedTest, NullArgs) { |
| bool is_locked; |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_is_locked(nullptr, &is_locked)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_is_locked(&sysrst_ctrl_, nullptr)); |
| EXPECT_DIF_BADARG(dif_sysrst_ctrl_is_locked(nullptr, nullptr)); |
| } |
| |
| TEST_F(IsLockedTest, Success) { |
| bool is_locked; |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 0); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_is_locked(&sysrst_ctrl_, &is_locked)); |
| EXPECT_TRUE(is_locked); |
| |
| EXPECT_READ32(SYSRST_CTRL_REGWEN_REG_OFFSET, 1); |
| EXPECT_DIF_OK(dif_sysrst_ctrl_is_locked(&sysrst_ctrl_, &is_locked)); |
| EXPECT_FALSE(is_locked); |
| } |
| |
| } // namespace |
| } // namespace dif_sysrst_ctrl_unittest |
