| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "aml-power.h" |
| |
| #include <optional> |
| |
| #include <ddk/platform-defs.h> |
| #include <mock/ddktl/protocol/pwm.h> |
| #include <mock/ddktl/protocol/vreg.h> |
| #include <soc/aml-common/aml-pwm-regs.h> |
| #include <zxtest/zxtest.h> |
| |
| bool operator==(const pwm_config_t& lhs, const pwm_config_t& rhs) { |
| return (lhs.polarity == rhs.polarity) && (lhs.period_ns == rhs.period_ns) && |
| (lhs.duty_cycle == rhs.duty_cycle) && (lhs.mode_config_size == rhs.mode_config_size) && |
| (static_cast<aml_pwm::mode_config*>(lhs.mode_config_buffer)->mode == |
| static_cast<aml_pwm::mode_config*>(rhs.mode_config_buffer)->mode); |
| } |
| |
| namespace power { |
| |
| const std::vector<aml_voltage_table_t> kTestVoltageTable = { |
| {1'050'000, 0}, {1'040'000, 3}, {1'030'000, 6}, {1'020'000, 8}, {1'010'000, 11}, |
| {1'000'000, 14}, {990'000, 17}, {980'000, 20}, {970'000, 23}, {960'000, 26}, |
| {950'000, 29}, {940'000, 31}, {930'000, 34}, {920'000, 37}, {910'000, 40}, |
| {900'000, 43}, {890'000, 45}, {880'000, 48}, {870'000, 51}, {860'000, 54}, |
| {850'000, 56}, {840'000, 59}, {830'000, 62}, {820'000, 65}, {810'000, 68}, |
| {800'000, 70}, {790'000, 73}, {780'000, 76}, {770'000, 79}, {760'000, 81}, |
| {750'000, 84}, {740'000, 87}, {730'000, 89}, {720'000, 92}, {710'000, 95}, |
| {700'000, 98}, {690'000, 100}, |
| }; |
| |
| constexpr voltage_pwm_period_ns_t kTestPwmPeriodNs = 1250; |
| |
| class AmlPowerTestWrapper : public AmlPower { |
| public: |
| AmlPowerTestWrapper(ddk::MockPwm& mock_big_pwm, ddk::MockPwm& mock_little_pwm, |
| std::vector<aml_voltage_table_t> voltage_table, |
| voltage_pwm_period_ns_t pwm_period) |
| : AmlPower(nullptr, mock_big_pwm.GetProto(), mock_little_pwm.GetProto(), |
| voltage_table, pwm_period) {} |
| |
| AmlPowerTestWrapper(ddk::MockVreg& mock_big_vreg, ddk::MockPwm& mock_little_pwm, |
| std::vector<aml_voltage_table_t> voltage_table, |
| voltage_pwm_period_ns_t pwm_period) |
| : AmlPower(nullptr, mock_big_vreg.GetProto(), mock_little_pwm.GetProto(), |
| voltage_table, pwm_period) {} |
| |
| AmlPowerTestWrapper(ddk::MockPwm& mock_big_pwm, std::vector<aml_voltage_table_t> voltage_table, |
| voltage_pwm_period_ns_t pwm_period) |
| : AmlPower(nullptr, mock_big_pwm.GetProto(), voltage_table, |
| pwm_period) {} |
| |
| static std::unique_ptr<AmlPowerTestWrapper> Create(ddk::MockPwm& mock_big_pwm, |
| std::vector<aml_voltage_table_t> voltage_table, |
| voltage_pwm_period_ns_t pwm_period) { |
| auto result = std::make_unique<AmlPowerTestWrapper>(mock_big_pwm, voltage_table, pwm_period); |
| return result; |
| } |
| |
| static std::unique_ptr<AmlPowerTestWrapper> Create(ddk::MockVreg& mock_big_vreg, |
| ddk::MockPwm& mock_little_pwm, |
| std::vector<aml_voltage_table_t> voltage_table, |
| voltage_pwm_period_ns_t pwm_period) { |
| auto result = std::make_unique<AmlPowerTestWrapper>(mock_big_vreg, mock_little_pwm, |
| voltage_table, pwm_period); |
| return result; |
| } |
| |
| static std::unique_ptr<AmlPowerTestWrapper> Create(ddk::MockPwm& mock_big_pwm, |
| ddk::MockPwm& mock_little_pwm, |
| std::vector<aml_voltage_table_t> voltage_table, |
| voltage_pwm_period_ns_t pwm_period) { |
| auto result = std::make_unique<AmlPowerTestWrapper>(mock_big_pwm, mock_little_pwm, |
| voltage_table, pwm_period); |
| return result; |
| } |
| |
| private: |
| }; |
| |
| class AmlPowerTest : public zxtest::Test { |
| public: |
| void TearDown() override { |
| big_cluster_pwm_.VerifyAndClear(); |
| little_cluster_pwm_.VerifyAndClear(); |
| big_cluster_vreg_.VerifyAndClear(); |
| } |
| |
| zx_status_t Create(uint32_t pid, std::vector<aml_voltage_table_t> voltage_table, |
| voltage_pwm_period_ns_t pwm_period) { |
| switch (pid) { |
| case PDEV_PID_ASTRO: { |
| aml_power_ = AmlPowerTestWrapper::Create(big_cluster_pwm_, voltage_table, pwm_period); |
| return ZX_OK; |
| } |
| case PDEV_PID_SHERLOCK: { |
| aml_power_ = AmlPowerTestWrapper::Create(big_cluster_pwm_, little_cluster_pwm_, |
| voltage_table, pwm_period); |
| return ZX_OK; |
| } |
| case PDEV_PID_LUIS: { |
| aml_power_ = AmlPowerTestWrapper::Create(big_cluster_vreg_, little_cluster_pwm_, |
| voltage_table, pwm_period); |
| return ZX_OK; |
| } |
| default: |
| return ZX_ERR_INTERNAL; |
| } |
| } |
| |
| zx_status_t Create(uint32_t pid) { return Create(pid, kTestVoltageTable, kTestPwmPeriodNs); } |
| |
| protected: |
| std::unique_ptr<AmlPowerTestWrapper> aml_power_; |
| |
| // Mmio Regs and Regions |
| ddk::MockPwm big_cluster_pwm_; |
| ddk::MockPwm little_cluster_pwm_; |
| ddk::MockVreg big_cluster_vreg_; |
| }; |
| |
| TEST_F(AmlPowerTest, SetVoltage) { |
| EXPECT_OK(Create(PDEV_PID_ASTRO)); |
| zx_status_t st; |
| constexpr uint32_t kTestVoltageInitial = 690'000; |
| constexpr uint32_t kTestVoltageFinal = 1'040'000; |
| |
| aml_pwm::mode_config on = {aml_pwm::ON, {}}; |
| |
| // Initialize to 0.69V |
| pwm_config_t cfg = {false, 1250, 100, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| |
| // Scale up to 1.05V |
| cfg = {false, 1250, 92, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 84, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 76, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 68, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 59, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 51, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 43, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 34, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 26, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 17, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 8, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 3, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| |
| uint32_t actual; |
| st = aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, |
| kTestVoltageInitial, &actual); |
| EXPECT_EQ(kTestVoltageInitial, actual); |
| EXPECT_OK(st); |
| |
| st = aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, |
| kTestVoltageFinal, &actual); |
| EXPECT_EQ(kTestVoltageFinal, actual); |
| EXPECT_OK(st); |
| } |
| |
| TEST_F(AmlPowerTest, ClusterIndexOutOfRange) { |
| constexpr uint32_t kTestVoltage = 690'000; |
| |
| EXPECT_OK(Create(PDEV_PID_ASTRO)); |
| |
| uint32_t actual; |
| zx_status_t st = aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kLittleClusterDomain, |
| kTestVoltage, &actual); |
| EXPECT_NOT_OK(st); |
| } |
| |
| TEST_F(AmlPowerTest, GetVoltageUnset) { |
| // Get the voltage before it's been set. Should return ZX_ERR_BAD_STATE. |
| EXPECT_OK(Create(PDEV_PID_ASTRO)); |
| |
| uint32_t voltage; |
| zx_status_t st = |
| aml_power_->PowerImplGetCurrentVoltage(AmlPowerTestWrapper::kBigClusterDomain, &voltage); |
| EXPECT_NOT_OK(st); |
| } |
| |
| TEST_F(AmlPowerTest, GetVoltage) { |
| // Get the voltage before it's been set. Should return ZX_ERR_BAD_STATE. |
| constexpr uint32_t kTestVoltage = 690'000; |
| zx_status_t st; |
| |
| EXPECT_OK(Create(PDEV_PID_ASTRO)); |
| |
| // Initialize to 0.69V |
| aml_pwm::mode_config on = {aml_pwm::ON, {}}; |
| pwm_config_t cfg = {false, 1250, 100, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| |
| uint32_t requested_voltage, actual_voltage; |
| st = aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, kTestVoltage, |
| &requested_voltage); |
| EXPECT_OK(st); |
| EXPECT_EQ(requested_voltage, kTestVoltage); |
| |
| st = aml_power_->PowerImplGetCurrentVoltage(AmlPowerTestWrapper::kBigClusterDomain, |
| &actual_voltage); |
| EXPECT_OK(st); |
| EXPECT_EQ(requested_voltage, actual_voltage); |
| } |
| |
| TEST_F(AmlPowerTest, GetVoltageOutOfRange) { |
| EXPECT_OK(Create(PDEV_PID_ASTRO)); |
| |
| uint32_t voltage; |
| zx_status_t st = |
| aml_power_->PowerImplGetCurrentVoltage(AmlPowerTestWrapper::kLittleClusterDomain, &voltage); |
| EXPECT_NOT_OK(st); |
| } |
| |
| TEST_F(AmlPowerTest, SetVoltageRoundDown) { |
| // Set a voltage that's not exactly supported and let the driver round down to the nearest |
| // voltage. |
| EXPECT_OK(Create(PDEV_PID_ASTRO)); |
| constexpr uint32_t kTestVoltageInitial = 830'000; |
| |
| // We expect the driver to give us the highest voltage that does not exceed the requested voltage. |
| constexpr uint32_t kTestVoltageFinalRequest = 935'000; |
| constexpr uint32_t kTestVoltageFinalActual = 930'000; |
| |
| aml_pwm::mode_config on = {aml_pwm::ON, {}}; |
| pwm_config_t cfg = {false, 1250, 62, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 54, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 45, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 37, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 34, &on, sizeof(on)}; |
| big_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| |
| uint32_t actual; |
| zx_status_t st; |
| |
| st = aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, |
| kTestVoltageInitial, &actual); |
| EXPECT_OK(st); |
| EXPECT_EQ(actual, kTestVoltageInitial); |
| |
| st = aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, |
| kTestVoltageFinalRequest, &actual); |
| EXPECT_OK(st); |
| EXPECT_EQ(actual, kTestVoltageFinalActual); |
| } |
| |
| TEST_F(AmlPowerTest, SetVoltageLittleCluster) { |
| // Set a voltage that's not exactly supported and let the driver round down to the nearest |
| // voltage. |
| EXPECT_OK(Create(PDEV_PID_SHERLOCK)); |
| constexpr uint32_t kTestVoltageInitial = 730'000; |
| constexpr uint32_t kTestVoltageFinal = 930'000; |
| |
| aml_pwm::mode_config on = {aml_pwm::ON, {}}; |
| pwm_config_t cfg = {false, 1250, 89, &on, sizeof(on)}; |
| little_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 81, &on, sizeof(on)}; |
| little_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 73, &on, sizeof(on)}; |
| little_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 65, &on, sizeof(on)}; |
| little_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 56, &on, sizeof(on)}; |
| little_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 48, &on, sizeof(on)}; |
| little_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 40, &on, sizeof(on)}; |
| little_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| cfg = {false, 1250, 34, &on, sizeof(on)}; |
| little_cluster_pwm_.ExpectSetConfig(ZX_OK, cfg); |
| |
| uint32_t actual; |
| zx_status_t st; |
| |
| st = aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kLittleClusterDomain, |
| kTestVoltageInitial, &actual); |
| EXPECT_OK(st); |
| EXPECT_EQ(actual, kTestVoltageInitial); |
| |
| st = aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kLittleClusterDomain, |
| kTestVoltageFinal, &actual); |
| EXPECT_OK(st); |
| EXPECT_EQ(actual, kTestVoltageFinal); |
| } |
| |
| TEST_F(AmlPowerTest, DomainEnableDisable) { |
| EXPECT_OK(Create(PDEV_PID_SHERLOCK)); |
| |
| // Enable. |
| EXPECT_OK(aml_power_->PowerImplEnablePowerDomain(AmlPowerTestWrapper::kLittleClusterDomain)); |
| EXPECT_OK(aml_power_->PowerImplEnablePowerDomain(AmlPowerTestWrapper::kBigClusterDomain)); |
| |
| // Disable. |
| EXPECT_OK(aml_power_->PowerImplDisablePowerDomain(AmlPowerTestWrapper::kLittleClusterDomain)); |
| EXPECT_OK(aml_power_->PowerImplDisablePowerDomain(AmlPowerTestWrapper::kBigClusterDomain)); |
| |
| // Out of bounds. |
| EXPECT_NOT_OK( |
| aml_power_->PowerImplDisablePowerDomain(AmlPowerTestWrapper::kLittleClusterDomain + 1)); |
| EXPECT_NOT_OK( |
| aml_power_->PowerImplEnablePowerDomain(AmlPowerTestWrapper::kLittleClusterDomain + 1)); |
| } |
| |
| TEST_F(AmlPowerTest, GetDomainStatus) { |
| EXPECT_OK(Create(PDEV_PID_ASTRO)); |
| |
| // Happy case. |
| power_domain_status_t result; |
| EXPECT_OK( |
| aml_power_->PowerImplGetPowerDomainStatus(AmlPowerTestWrapper::kBigClusterDomain, &result)); |
| EXPECT_EQ(result, POWER_DOMAIN_STATUS_ENABLED); |
| |
| // Out of bounds. |
| EXPECT_NOT_OK(aml_power_->PowerImplGetPowerDomainStatus(AmlPowerTestWrapper::kLittleClusterDomain, |
| &result)); |
| } |
| |
| TEST_F(AmlPowerTest, LuisSetBigCluster) { |
| EXPECT_OK(Create(PDEV_PID_LUIS)); |
| |
| vreg_params_t outparams; |
| outparams.min_uv = 100; |
| outparams.num_steps = 10; |
| outparams.step_size_uv = 10; |
| |
| big_cluster_vreg_.ExpectGetRegulatorParams(outparams); |
| big_cluster_vreg_.ExpectSetVoltageStep(ZX_OK, 5); |
| const uint32_t kTestVoltage = 155; |
| uint32_t actual; |
| EXPECT_OK(aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, |
| kTestVoltage, &actual)); |
| EXPECT_EQ(actual, 150); |
| |
| // Voltage is too low. |
| big_cluster_vreg_.ExpectGetRegulatorParams(outparams); |
| EXPECT_NOT_OK( |
| aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, 99, &actual)); |
| |
| // Set voltage to the threshold. |
| big_cluster_vreg_.ExpectGetRegulatorParams(outparams); |
| big_cluster_vreg_.ExpectSetVoltageStep(ZX_OK, 10); |
| EXPECT_OK( |
| aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, 200, &actual)); |
| EXPECT_EQ(actual, 200); |
| |
| // Set voltage beyond the threshold. |
| big_cluster_vreg_.ExpectGetRegulatorParams(outparams); |
| EXPECT_NOT_OK( |
| aml_power_->PowerImplRequestVoltage(AmlPowerTestWrapper::kBigClusterDomain, 300, &actual)); |
| } |
| |
| TEST_F(AmlPowerTest, LuisGetSupportedVoltageRange) { |
| EXPECT_OK(Create(PDEV_PID_LUIS)); |
| |
| vreg_params_t outparams; |
| outparams.min_uv = 100; |
| outparams.num_steps = 10; |
| outparams.step_size_uv = 10; |
| |
| big_cluster_vreg_.ExpectGetRegulatorParams(outparams); |
| |
| uint32_t max, min; |
| EXPECT_OK(aml_power_->PowerImplGetSupportedVoltageRange(AmlPowerTestWrapper::kBigClusterDomain, |
| &min, &max)); |
| EXPECT_EQ(max, 200); |
| EXPECT_EQ(min, 100); |
| |
| EXPECT_OK(aml_power_->PowerImplGetSupportedVoltageRange(AmlPowerTestWrapper::kLittleClusterDomain, |
| &min, &max)); |
| EXPECT_EQ(max, 1'050'000); |
| EXPECT_EQ(min, 690'000); |
| } |
| |
| } // namespace power |
