| // Copyright 2018 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-voltage.h" |
| |
| #include <lib/ddk/debug.h> |
| #include <lib/device-protocol/pdev.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #include <memory> |
| |
| #include <fbl/alloc_checker.h> |
| |
| namespace thermal { |
| |
| namespace { |
| |
| // Sleep for 200 microseconds inorder to let the voltage change |
| // take effect. Source: Amlogic SDK. |
| constexpr uint32_t kSleep = 200; |
| // Step up or down 3 steps in the voltage table while changing |
| // voltage and not directly. Source: Amlogic SDK |
| constexpr int kSteps = 3; |
| // Invalid index in the voltage-table |
| constexpr int kInvalidIndex = -1; |
| |
| } // namespace |
| |
| zx_status_t AmlVoltageRegulator::Create( |
| zx_device_t* parent, const fuchsia_hardware_thermal_ThermalDeviceInfo& thermal_config, |
| const aml_thermal_info_t* thermal_info) { |
| auto pdev = ddk::PDev::FromFragment(parent); |
| if (!pdev.is_valid()) { |
| zxlogf(ERROR, "aml-voltage: failed to get pdev protocol"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| pdev_device_info_t device_info; |
| zx_status_t status = pdev.GetDeviceInfo(&device_info); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "aml-voltage: failed to get GetDeviceInfo "); |
| return status; |
| } |
| |
| big_cluster_pwm_ = ddk::PwmProtocolClient(parent, "pwm-a"); |
| if (!big_cluster_pwm_.is_valid()) { |
| zxlogf(ERROR, "%s: failed to get big cluster PWM fragment", __func__); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if ((status = big_cluster_pwm_.Enable()) != ZX_OK) { |
| zxlogf(ERROR, "%s: Could not enable PWM", __func__); |
| return status; |
| } |
| |
| big_little_ = thermal_config.big_little; |
| if (big_little_) { |
| little_cluster_pwm_ = ddk::PwmProtocolClient(parent, "pwm-ao-d"); |
| if (!little_cluster_pwm_.is_valid()) { |
| zxlogf(ERROR, "%s: failed to get little cluster PWM fragment", __func__); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if ((status = little_cluster_pwm_.Enable()) != ZX_OK) { |
| zxlogf(ERROR, "%s: Could not enable PWM", __func__); |
| return status; |
| } |
| } |
| |
| return Init(thermal_config, thermal_info); |
| } |
| |
| zx_status_t AmlVoltageRegulator::Init( |
| const pwm_protocol_t* big_cluster_pwm, const pwm_protocol_t* little_cluster_pwm, |
| const fuchsia_hardware_thermal_ThermalDeviceInfo& thermal_config, |
| const aml_thermal_info_t* thermal_info) { |
| zx_status_t status = ZX_OK; |
| big_little_ = thermal_config.big_little; |
| |
| big_cluster_pwm_ = ddk::PwmProtocolClient(big_cluster_pwm); |
| if ((status = big_cluster_pwm_.Enable()) != ZX_OK) { |
| zxlogf(ERROR, "%s: Could not enable PWM", __func__); |
| return status; |
| } |
| |
| if (big_little_) { |
| little_cluster_pwm_ = ddk::PwmProtocolClient(little_cluster_pwm); |
| if ((status = little_cluster_pwm_.Enable()) != ZX_OK) { |
| zxlogf(ERROR, "%s: Could not enable PWM", __func__); |
| return status; |
| } |
| } |
| |
| return Init(thermal_config, thermal_info); |
| } |
| |
| zx_status_t AmlVoltageRegulator::Init( |
| const fuchsia_hardware_thermal_ThermalDeviceInfo& thermal_config, |
| const aml_thermal_info_t* thermal_info) { |
| ZX_DEBUG_ASSERT(thermal_info); |
| zx_status_t status = ZX_OK; |
| |
| // Get the voltage-table metadata. |
| memcpy(&thermal_info_, thermal_info, sizeof(aml_thermal_info_t)); |
| |
| current_big_cluster_voltage_index_ = kInvalidIndex; |
| current_little_cluster_voltage_index_ = kInvalidIndex; |
| |
| uint32_t max_big_cluster_microvolt = 0; |
| uint32_t max_little_cluster_microvolt = 0; |
| |
| const fuchsia_hardware_thermal_OperatingPoint& big_cluster_opp = |
| thermal_config.opps[fuchsia_hardware_thermal_PowerDomain_BIG_CLUSTER_POWER_DOMAIN]; |
| const fuchsia_hardware_thermal_OperatingPoint& little_cluster_opp = |
| thermal_config.opps[fuchsia_hardware_thermal_PowerDomain_LITTLE_CLUSTER_POWER_DOMAIN]; |
| |
| for (uint32_t i = 0; i < fuchsia_hardware_thermal_MAX_DVFS_OPPS; i++) { |
| if (i < big_cluster_opp.count && big_cluster_opp.opp[i].volt_uv > max_big_cluster_microvolt) { |
| max_big_cluster_microvolt = big_cluster_opp.opp[i].volt_uv; |
| } |
| if (i < little_cluster_opp.count && |
| little_cluster_opp.opp[i].volt_uv > max_little_cluster_microvolt) { |
| max_little_cluster_microvolt = little_cluster_opp.opp[i].volt_uv; |
| } |
| } |
| |
| // Set the voltage to maximum to start with |
| if ((status = SetBigClusterVoltage(max_big_cluster_microvolt)) != ZX_OK) { |
| return status; |
| } |
| if (big_little_ && (status = SetLittleClusterVoltage(max_little_cluster_microvolt)) != ZX_OK) { |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t AmlVoltageRegulator::SetClusterVoltage(int* current_voltage_index, |
| const ddk::PwmProtocolClient& pwm, |
| uint32_t microvolt) { |
| // Find the entry in the voltage-table. |
| int target_index; |
| for (target_index = 0; target_index < MAX_VOLTAGE_TABLE; target_index++) { |
| if (thermal_info_.voltage_table[target_index].microvolt == microvolt) { |
| break; |
| } |
| } |
| |
| // Invalid voltage request. |
| if (target_index == MAX_VOLTAGE_TABLE) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| zx_status_t status = ZX_OK; |
| // If this is the first time we are setting up the voltage |
| // we directly set it. |
| if (*current_voltage_index < 0) { |
| // Update new duty cycle. |
| aml_pwm::mode_config on = {aml_pwm::ON, {}}; |
| pwm_config_t cfg = {false, thermal_info_.voltage_pwm_period_ns, |
| static_cast<float>(thermal_info_.voltage_table[target_index].duty_cycle), |
| reinterpret_cast<uint8_t*>(&on), sizeof(on)}; |
| if ((status = pwm.SetConfig(&cfg)) != ZX_OK) { |
| zxlogf(ERROR, "%s: Could not initialize PWM", __func__); |
| return status; |
| } |
| usleep(kSleep); |
| *current_voltage_index = target_index; |
| return ZX_OK; |
| } |
| |
| // Otherwise we adjust to the target voltage step by step. |
| while (*current_voltage_index != target_index) { |
| if (*current_voltage_index < target_index) { |
| if (*current_voltage_index < target_index - kSteps) { |
| // Step up by 3 in the voltage table. |
| *current_voltage_index += kSteps; |
| } else { |
| *current_voltage_index = target_index; |
| } |
| } else { |
| if (*current_voltage_index > target_index + kSteps) { |
| // Step down by 3 in the voltage table. |
| *current_voltage_index -= kSteps; |
| } else { |
| *current_voltage_index = target_index; |
| } |
| } |
| // Update new duty cycle. |
| aml_pwm::mode_config on = {aml_pwm::ON, {}}; |
| pwm_config_t cfg = { |
| false, thermal_info_.voltage_pwm_period_ns, |
| static_cast<float>(thermal_info_.voltage_table[*current_voltage_index].duty_cycle), |
| reinterpret_cast<uint8_t*>(&on), sizeof(on)}; |
| if ((status = pwm.SetConfig(&cfg)) != ZX_OK) { |
| zxlogf(ERROR, "%s: Could not initialize PWM", __func__); |
| return status; |
| } |
| usleep(kSleep); |
| } |
| |
| return ZX_OK; |
| } |
| |
| } // namespace thermal |
