| // Copyright 2019 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 "mtk-power.h" |
| |
| #include <lib/device-protocol/pdev.h> |
| |
| #include <ddk/debug.h> |
| #include <ddk/platform-defs.h> |
| #include <ddk/protocol/platform/bus.h> |
| #include <ddk/protocol/platform/device.h> |
| #include <soc/mt8167/mt8167-power-regs.h> |
| #include <soc/mt8167/mt8167-power.h> |
| |
| #include "src/devices/power/drivers/mtk-power/mtk-power-bind.h" |
| |
| namespace power { |
| |
| const fbl::Vector<uint32_t> kSupportedVoltageList1{1800000, 1900000, 2000000, 2200000}; |
| const fbl::Vector<uint32_t> kSupportedVoltageList2{3300000, 3400000, 3500000, 3600000}; |
| const fbl::Vector<uint32_t> kSupportedVoltageList3{1800000, 3300000}; |
| const fbl::Vector<uint32_t> kSupportedVoltageList4{3000000, 3300000}; |
| const fbl::Vector<uint32_t> kSupportedVoltageList5{1200000, 1300000, 1500000, 1800000, |
| 2000000, 2800000, 3000000, 3300000}; |
| const fbl::Vector<uint32_t> kSupportedVoltageList6{1240000, 1390000}; |
| const fbl::Vector<uint32_t> kSupportedVoltageList7{1200000, 1300000, 1500000, 1800000}; |
| const fbl::Vector<uint32_t> kSupportedVoltageList8{1800000, 2000000}; |
| |
| void MtkRegulator::WaitForIdle() { |
| while (PmicWacs2RData::Get().ReadFrom(&pmic_mmio_).wacs2_fsm() != PmicWacs2RData::kFsmStateIdle) { |
| } |
| } |
| |
| void MtkRegulator::WaitForValidClear() { |
| while (PmicWacs2RData::Get().ReadFrom(&pmic_mmio_).wacs2_fsm() != |
| PmicWacs2RData::kFsmStateWfVldClear) { |
| } |
| } |
| |
| zx_status_t MtkRegulator::ReadPMICReg(uint32_t reg_addr, uint32_t* reg_value) { |
| WaitForIdle(); |
| PmicWacs2Cmd::Get() |
| .FromValue(0) |
| .set_wacs2_write(0) |
| .set_wacs2_addr(reg_addr >> 1) |
| .WriteTo(&pmic_mmio_); |
| // Wait for data to be available. |
| WaitForValidClear(); |
| |
| *reg_value = PmicWacs2RData::Get().ReadFrom(&pmic_mmio_).wacs2_rdata(); |
| |
| // Data is read. clear the valid flag. |
| PmicWacs2VldClear::Get().ReadFrom(&pmic_mmio_).set_wacs2_vldclr(1).WriteTo(&pmic_mmio_); |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkRegulator::WritePMICReg(uint32_t reg_addr, uint32_t value) { |
| WaitForIdle(); |
| PmicWacs2Cmd::Get() |
| .FromValue(0) |
| .set_wacs2_write(1) |
| .set_wacs2_addr(reg_addr >> 1) |
| .set_wacs2_data(value) |
| .WriteTo(&pmic_mmio_); |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkRegulator::Enable() { |
| if (enabled_) { |
| return ZX_OK; |
| } |
| uint32_t cur_val; |
| zx_status_t status = ReadPMICReg(enable_register_, &cur_val); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Reading PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| status = WritePMICReg(enable_register_, (cur_val | 1 << enable_bit_)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Writing PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| |
| enabled_ = true; |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkRegulator::Disable() { |
| if (!enabled_) { |
| return ZX_ERR_BAD_STATE; |
| } |
| uint32_t cur_val; |
| zx_status_t status = ReadPMICReg(enable_register_, &cur_val); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Reading PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| status = WritePMICReg(enable_register_, (cur_val &= ~(1 << enable_bit_))); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Writing PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| |
| enabled_ = false; |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkBuckRegulator::SetVoltageSelReg() { |
| uint32_t ctrl_reg_val; |
| zx_status_t status = ReadPMICReg(buck_voltage_ctrl_reg_, &ctrl_reg_val); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Reading PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| |
| if (ctrl_reg_val & (1 << 1)) { |
| voltage_sel_reg_ = buck_voltage_on_reg_; |
| } |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkBuckRegulator::GetVoltageSelector(uint32_t set_voltage, uint32_t* actual_voltage, |
| uint16_t* selector) { |
| if (!step_size_) { |
| return ZX_ERR_BAD_STATE; |
| } |
| if (set_voltage < min_voltage_) { |
| zxlogf(ERROR, "%s Voltage :%x is not a supported voltage", __FUNCTION__, set_voltage); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| if (set_voltage > max_voltage_) { |
| zxlogf(ERROR, "%s Voltage :%x is not a supported voltage", __FUNCTION__, set_voltage); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| uint16_t sel = static_cast<uint16_t>((set_voltage - min_voltage_) / step_size_); |
| *actual_voltage = min_voltage_ + (sel * step_size_); |
| *selector = sel; |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkBuckRegulator::RequestVoltage(uint32_t voltage, uint32_t* actual_voltage) { |
| uint16_t selector = 0; |
| zx_status_t status = GetVoltageSelector(voltage, actual_voltage, &selector); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| if (cur_voltage_ == *actual_voltage) { |
| return ZX_OK; |
| } |
| uint32_t cur_val; |
| status = ReadPMICReg(voltage_sel_reg_, &cur_val); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Reading PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| |
| cur_val &= ~voltage_sel_mask_; |
| cur_val |= (selector & voltage_sel_mask_); |
| |
| status = WritePMICReg(voltage_sel_reg_, cur_val); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Writing PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| |
| cur_voltage_ = *actual_voltage; |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkLdoRegulator::GetVoltageSelector(uint32_t set_voltage, uint32_t* actual_voltage, |
| uint16_t* selector) { |
| size_t num_voltages = supported_voltages_.size(); |
| if (num_voltages == 0) { |
| return ZX_ERR_BAD_STATE; |
| } |
| |
| if (set_voltage < supported_voltages_[0] || set_voltage > supported_voltages_[num_voltages - 1]) { |
| zxlogf(ERROR, "%s Voltage :%x is not a supported voltage", __FUNCTION__, set_voltage); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| for (size_t i = 0; i < num_voltages; i++) { |
| uint32_t voltage = supported_voltages_[i]; |
| if (voltage == set_voltage) { |
| *selector = static_cast<uint16_t>(i); |
| *actual_voltage = voltage; |
| return ZX_OK; |
| } |
| if (set_voltage > voltage && set_voltage < supported_voltages_[i + 1]) { |
| *selector = static_cast<uint16_t>(i); |
| *actual_voltage = voltage; |
| return ZX_OK; |
| } |
| } |
| return ZX_ERR_BAD_STATE; |
| } |
| |
| zx_status_t MtkLdoRegulator::RequestVoltage(uint32_t voltage, uint32_t* actual_voltage) { |
| uint16_t selector = 0; |
| zx_status_t status = GetVoltageSelector(voltage, actual_voltage, &selector); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| if (cur_voltage_ == *actual_voltage) { |
| return ZX_OK; |
| } |
| uint32_t cur_val; |
| status = ReadPMICReg(voltage_sel_reg_, &cur_val); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Reading PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| |
| cur_val &= ~voltage_sel_mask_; |
| cur_val |= ((selector << voltage_sel_shift_) & voltage_sel_mask_); |
| |
| status = WritePMICReg(voltage_sel_reg_, cur_val); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Writing PMIC reg failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| |
| cur_voltage_ = *actual_voltage; |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkPower::PowerImplGetCurrentVoltage(uint32_t index, uint32_t* current_voltage) { |
| if (index >= kMt8167NumPowerDomains) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| *current_voltage = power_domains_[index]->cur_voltage(); |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkPower::PowerImplDisablePowerDomain(uint32_t index) { |
| if (index >= kMt8167NumPowerDomains) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| zx_status_t status = power_domains_[index]->Disable(); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Disable power domain %d failed. Status: %d", __FUNCTION__, index, status); |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkPower::PowerImplEnablePowerDomain(uint32_t index) { |
| if (index >= kMt8167NumPowerDomains) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| return power_domains_[index]->Enable(); |
| } |
| |
| zx_status_t MtkPower::PowerImplGetPowerDomainStatus(uint32_t index, |
| power_domain_status_t* out_status) { |
| if (index >= kMt8167NumPowerDomains) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| *out_status = |
| power_domains_[index]->enabled() ? POWER_DOMAIN_STATUS_ENABLED : POWER_DOMAIN_STATUS_DISABLED; |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkPower::PowerImplGetSupportedVoltageRange(uint32_t index, uint32_t* min_voltage, |
| uint32_t* max_voltage) { |
| if (index >= kMt8167NumPowerDomains) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| return power_domains_[index]->GetSupportedVoltageRange(min_voltage, max_voltage); |
| } |
| |
| zx_status_t MtkPower::PowerImplRequestVoltage(uint32_t index, uint32_t voltage, |
| uint32_t* actual_voltage) { |
| if (index >= kMt8167NumPowerDomains) { |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| return power_domains_[index]->RequestVoltage(voltage, actual_voltage); |
| } |
| |
| zx_status_t MtkPower::PowerImplWritePmicCtrlReg(uint32_t index, uint32_t reg_addr, uint32_t value) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| zx_status_t MtkPower::PowerImplReadPmicCtrlReg(uint32_t index, uint32_t addr, uint32_t* value) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| void MtkPower::DdkRelease() { delete this; } |
| |
| void MtkPower::DdkUnbind(ddk::UnbindTxn txn) { txn.Reply(); } |
| |
| enum MtkRegulatorType { BUCK = 1, LDO, FIXED }; |
| |
| struct MtkRegulatorParams { |
| uint8_t type; |
| uint32_t enable_register = 0; |
| uint8_t enable_bit = 0; |
| uint32_t select_register = 0; |
| uint32_t select_mask = 0; |
| uint32_t select_shift = 0; |
| uint32_t buck_voltage_control_register = 0; |
| uint32_t buck_voltage_on_register = 0; |
| uint32_t min_voltage = 0; |
| uint32_t max_voltage = 0; |
| uint32_t default_voltage = 0; |
| uint32_t step_size = 0; |
| const fbl::Vector<uint32_t>& supported_voltage = kSupportedVoltageList1; |
| }; |
| |
| MtkRegulatorParams kMtkRegulatorParams[] = { |
| [kBuckVProc] = {.type = BUCK, |
| .enable_register = kPmicVprocCon7, |
| .enable_bit = 1, |
| .select_register = kPmicVprocCon9, |
| .select_mask = 0x7f, |
| .select_shift = 0, |
| .buck_voltage_control_register = kPmicVprocCon5, |
| .buck_voltage_on_register = kPmicVprocCon10, |
| .min_voltage = 700000, |
| .max_voltage = 1493750, |
| .step_size = 6250}, |
| [kBuckVCore] = {.type = BUCK, |
| .enable_register = kPmicVcoreCon7, |
| .enable_bit = 1, |
| .select_register = kPmicVcoreCon9, |
| .select_mask = 0x7f, |
| .select_shift = 0, |
| .buck_voltage_control_register = kPmicVcoreCon5, |
| .buck_voltage_on_register = kPmicVcoreCon10, |
| .min_voltage = 700000, |
| .max_voltage = 1493750, |
| .step_size = 6250}, |
| [kBuckVSys] = {.type = BUCK, |
| .enable_register = kPmicVsysCon7, |
| .enable_bit = 1, |
| .select_register = kPmicVsysCon9, |
| .select_mask = 0x7f, |
| .select_shift = 0, |
| .buck_voltage_control_register = kPmicVsysCon5, |
| .buck_voltage_on_register = kPmicVsysCon10, |
| .min_voltage = 1400000, |
| .max_voltage = 2987500, |
| .step_size = 12500}, |
| [kALdoVAud28] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicAnaLdoCon23, |
| .enable_bit = 14, |
| .default_voltage = 2800000, |
| }, |
| [kALdoVAud22] = |
| { |
| .type = LDO, |
| .enable_register = kPmicAnaLdoCon2, |
| .enable_bit = 14, |
| .select_register = kPmicAnaLdoCon8, |
| .select_mask = 0x60, |
| .select_shift = 5, |
| .supported_voltage = kSupportedVoltageList1, |
| }, |
| [kALdoVAdc18] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicAnaLdoCon25, |
| .enable_bit = 14, |
| .default_voltage = 1800000, |
| }, |
| [kALdoVXo22] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicAnaLdoCon1, |
| .enable_bit = 10, |
| .default_voltage = 2800000, |
| }, |
| [kALdoVCamA] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicAnaLdoCon4, |
| .enable_bit = 15, |
| .default_voltage = 2800000, |
| }, |
| [kVSysLdoVm] = |
| { |
| .type = LDO, |
| .enable_register = kPmicDigLdoCon47, |
| .enable_bit = 14, |
| .select_register = kPmicDigLdoCon48, |
| .select_mask = 0x30, |
| .select_shift = 4, |
| .supported_voltage = kSupportedVoltageList6, |
| }, |
| [kVSysLdoVcn18] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicDigLdoCon11, |
| .enable_bit = 14, |
| .default_voltage = 1800000, |
| }, |
| [kVSysLdoVio18] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicDigLdoCon49, |
| .enable_bit = 14, |
| .default_voltage = 1800000, |
| }, |
| [kVSysLdoVCamIo] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicDigLdoCon53, |
| .enable_bit = 14, |
| .default_voltage = 1800000, |
| }, |
| [kVSysLdoVCamD] = |
| { |
| .type = LDO, |
| .enable_register = kPmicDigLdoCon51, |
| .enable_bit = 14, |
| .select_register = kPmicDigLdoCon52, |
| .select_mask = 0x60, |
| .select_shift = 5, |
| .supported_voltage = kSupportedVoltageList7, |
| }, |
| [kVDLdoVcn35] = {.type = LDO, |
| .enable_register = kPmicAnaLdoCon21, |
| .enable_bit = 12, |
| .select_register = kPmicAnaLdoCon16, |
| .select_mask = 0xC, |
| .select_shift = 6, |
| .supported_voltage = kSupportedVoltageList2}, |
| [kVDLdoVio28] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicDigLdoCon0, |
| .enable_bit = 14, |
| .default_voltage = 2800000, |
| }, |
| [kVDLdoVemc33] = {.type = LDO, |
| .enable_register = kPmicDigLdoCon6, |
| .enable_bit = 14, |
| .select_register = kPmicDigLdoCon27, |
| .select_mask = 0x80, |
| .select_shift = 7, |
| .supported_voltage = kSupportedVoltageList4}, |
| [kVDLdoVmc] = {.type = LDO, |
| .enable_register = kPmicDigLdoCon3, |
| .enable_bit = 12, |
| .select_register = kPmicDigLdoCon24, |
| .select_mask = 0x10, |
| .select_shift = 4, |
| .supported_voltage = kSupportedVoltageList3}, |
| [kVDLdoVmch] = {.type = LDO, |
| .enable_register = kPmicDigLdoCon5, |
| .enable_bit = 14, |
| .select_register = kPmicDigLdoCon26, |
| .select_mask = 0x80, |
| .select_shift = 7, |
| .supported_voltage = kSupportedVoltageList4}, |
| [kVDLdoVUsb33] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicDigLdoCon2, |
| .enable_bit = 14, |
| .default_voltage = 3300000, |
| }, |
| [kVDLdoVGp1] = {.type = LDO, |
| .enable_register = kPmicDigLdoCon7, |
| .enable_bit = 15, |
| .select_register = kPmicDigLdoCon28, |
| .select_mask = 0xE0, |
| .select_shift = 5, |
| .supported_voltage = kSupportedVoltageList5}, |
| [kVDLdoVM25] = |
| { |
| .type = FIXED, |
| .enable_register = kPmicDigLdoCon55, |
| .enable_bit = 14, |
| .default_voltage = 2500000, |
| }, |
| [kVDLdoVGp2] = {.type = LDO, |
| .enable_register = kPmicDigLdoCon8, |
| .enable_bit = 15, |
| .select_register = kPmicDigLdoCon29, |
| .select_mask = 0xE0, |
| .select_shift = 5, |
| .supported_voltage = kSupportedVoltageList5}, |
| [kVDLdoVCamAf] = {.type = LDO, |
| .enable_register = kPmicDigLdoCon31, |
| .enable_bit = 15, |
| .select_register = kPmicDigLdoCon32, |
| .select_mask = 0xE0, |
| .select_shift = 5, |
| .supported_voltage = kSupportedVoltageList5}, |
| }; |
| |
| void MtkPower::InitializePowerDomains() { |
| for (size_t i = 0; i < kMt8167NumPowerDomains; i++) { |
| auto& reg_params = kMtkRegulatorParams[i]; |
| if (reg_params.type == BUCK) { |
| power_domains_[i] = std::make_unique<MtkBuckRegulator>( |
| pmic_mmio_.View(0), reg_params.enable_register, reg_params.enable_bit, |
| reg_params.select_register, reg_params.select_mask, reg_params.select_shift, |
| reg_params.buck_voltage_control_register, reg_params.buck_voltage_on_register, |
| reg_params.min_voltage, reg_params.max_voltage, reg_params.step_size); |
| MtkBuckRegulator* buck = static_cast<MtkBuckRegulator*>(power_domains_[i].get()); |
| buck->SetVoltageSelReg(); |
| } else if (reg_params.type == FIXED) { |
| power_domains_[i] = |
| std::make_unique<MtkFixedRegulator>(pmic_mmio_.View(0), reg_params.default_voltage, |
| reg_params.enable_register, reg_params.enable_bit); |
| } else if (reg_params.type == LDO) { |
| power_domains_[i] = std::make_unique<MtkLdoRegulator>( |
| pmic_mmio_.View(0), reg_params.enable_register, reg_params.enable_bit, |
| reg_params.select_register, reg_params.select_mask, reg_params.select_shift, |
| reg_params.supported_voltage); |
| } |
| } |
| } |
| |
| zx_status_t MtkPower::Init() { |
| // TODO(ravoorir): Check if bootloader did not init the PMIC and |
| // do the needful. |
| InitializePowerDomains(); |
| return ZX_OK; |
| } |
| |
| zx_status_t MtkPower::Bind() { |
| pbus_protocol_t pbus; |
| zx_status_t status = device_get_protocol(parent(), ZX_PROTOCOL_PBUS, &pbus); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s failed to get ZX_PROTOCOL_PBUS, %d", __FUNCTION__, status); |
| return status; |
| } |
| |
| power_impl_protocol_t power_proto = { |
| .ops = &power_impl_protocol_ops_, |
| .ctx = this, |
| }; |
| |
| status = pbus_register_protocol(&pbus, ZX_PROTOCOL_POWER_IMPL, &power_proto, sizeof(power_proto)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s pbus_register_protocol failed: %d", __FUNCTION__, status); |
| return status; |
| } |
| status = DdkAdd("mtk-power", DEVICE_ADD_ALLOW_MULTI_COMPOSITE); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s DdkAdd failed: %d", __FUNCTION__, status); |
| } |
| |
| return status; |
| } |
| |
| zx_status_t MtkPower::Create(void* ctx, zx_device_t* parent) { |
| zx_status_t status = ZX_OK; |
| |
| ddk::PDev pdev(parent); |
| if (!pdev.is_valid()) { |
| zxlogf(ERROR, "%s Could not get pdev: %d", __FUNCTION__, status); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| std::optional<ddk::MmioBuffer> mmio; |
| status = pdev.MapMmio(0, &mmio); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s Failed to get mmio: %d", __FUNCTION__, status); |
| return status; |
| } |
| auto dev = std::make_unique<MtkPower>(parent, *std::move(mmio)); |
| |
| if ((status = dev->Init()) != ZX_OK) { |
| return status; |
| } |
| |
| if ((status = dev->Bind()) != ZX_OK) { |
| return status; |
| } |
| |
| // devmgr is now in charge of the device. |
| __UNUSED auto* dummy = dev.release(); |
| return ZX_OK; |
| } |
| |
| static constexpr zx_driver_ops_t mtk_power_driver_ops = []() { |
| zx_driver_ops_t driver_ops = {}; |
| driver_ops.version = DRIVER_OPS_VERSION; |
| driver_ops.bind = MtkPower::Create; |
| return driver_ops; |
| }(); |
| |
| } // namespace power |
| |
| ZIRCON_DRIVER(mtk_power, power::mtk_power_driver_ops, "zircon", "0.1"); |
