// 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 <mock-mmio-reg/mock-mmio-reg.h>
#include <zxtest/zxtest.h>

namespace {

static constexpr uint32_t kPmicMmioRegCount = 768;

}  // namespace

namespace power {

class MtkPowerTest : public MtkPower {
 public:
  MtkPowerTest(ddk_mock::MockMmioRegRegion& pmic_mmio)
      : MtkPower(nullptr, ddk::MmioBuffer(pmic_mmio.GetMmioBuffer())) {}
  void InitPowerRegulators() { InitializePowerDomains(); }
  MtkRegulator& GetPowerDomain(uint32_t index) { return *(power_domains_[index]); }
};

template <class T>
ddk_mock::MockMmioReg& GetMockReg(ddk_mock::MockMmioRegRegion& registers) {
  return registers[T::Get().addr()];
}

template <class T>
ddk_mock::MockMmioReg& GetMockReg(int reg_offset, ddk_mock::MockMmioRegRegion& registers) {
  return registers[T::Get(reg_offset).addr()];
}

void ReadPmicRegHelper(ddk_mock::MockMmioRegRegion& pmic_regs, uint32_t reg_addr,
                       uint32_t reg_value) {
  // Match idle
  GetMockReg<PmicWacs2RData>(pmic_regs).ExpectRead(
      PmicWacs2RData().set_wacs2_fsm(PmicWacs2RData::kFsmStateIdle).reg_value());
  // Match cmd
  GetMockReg<PmicWacs2Cmd>(pmic_regs).ExpectWrite(
      PmicWacs2Cmd().set_wacs2_write(0).set_wacs2_addr(reg_addr >> 1).reg_value());
  // Match vldclr
  GetMockReg<PmicWacs2RData>(pmic_regs).ExpectRead(
      PmicWacs2RData().set_wacs2_fsm(PmicWacs2RData::kFsmStateWfVldClear).reg_value());
  // Match data read
  GetMockReg<PmicWacs2RData>(pmic_regs).ExpectRead(reg_value);

  // Match vldclr
  GetMockReg<PmicWacs2VldClear>(pmic_regs).ExpectRead(0).ExpectWrite(
      PmicWacs2VldClear().set_wacs2_vldclr(1).reg_value());
}

void WritePmicRegHelper(ddk_mock::MockMmioRegRegion& pmic_regs, uint32_t reg_addr,
                        uint32_t reg_value) {
  // Match idle
  GetMockReg<PmicWacs2RData>(pmic_regs).ExpectRead(
      PmicWacs2RData().set_wacs2_fsm(PmicWacs2RData::kFsmStateIdle).reg_value());

  // Match cmd write
  GetMockReg<PmicWacs2Cmd>(pmic_regs).ExpectWrite(PmicWacs2Cmd()
                                                      .set_wacs2_write(1)
                                                      .set_wacs2_addr(reg_addr >> 1)
                                                      .set_wacs2_data(reg_value)
                                                      .reg_value());
}

void EnableDomainHelper(ddk_mock::MockMmioRegRegion& pmic_regs, MtkRegulator& domain) {
  ReadPmicRegHelper(pmic_regs, domain.enable_register(), 0);
  WritePmicRegHelper(pmic_regs, domain.enable_register(), 1 << domain.enable_bit());
}

void InitPowerRegulatorsHelper(ddk_mock::MockMmioRegRegion& pmic_regs) {
  ReadPmicRegHelper(pmic_regs, kPmicVprocCon5, 1 << 1);
  ReadPmicRegHelper(pmic_regs, kPmicVcoreCon5, 1 << 1);
  ReadPmicRegHelper(pmic_regs, kPmicVsysCon5, 1 << 1);
}

TEST(PowerTest, Init) {
  ddk_mock::MockMmioReg pmic_reg_array[kPmicMmioRegCount];
  ddk_mock::MockMmioRegRegion pmic_regs(pmic_reg_array, sizeof(uint32_t), kPmicMmioRegCount);
  MtkPowerTest power_test(pmic_regs);

  InitPowerRegulatorsHelper(pmic_regs);
  power_test.InitPowerRegulators();

  // Test if the buck regulators have the right voltage_sel_reg
  MtkBuckRegulator& domain = static_cast<MtkBuckRegulator&>(power_test.GetPowerDomain(0));
  ASSERT_EQ(domain.voltage_sel_reg(), kPmicVprocCon10);
}

TEST(PowerTest, EnablePowerDomain) {
  ddk_mock::MockMmioReg pmic_reg_array[kPmicMmioRegCount];
  ddk_mock::MockMmioRegRegion pmic_regs(pmic_reg_array, sizeof(uint32_t), kPmicMmioRegCount);
  MtkPowerTest power_test(pmic_regs);

  InitPowerRegulatorsHelper(pmic_regs);
  power_test.InitPowerRegulators();

  // Test enabling invalid PowerDomain fails
  ASSERT_EQ(power_test.PowerImplEnablePowerDomain(kMt8167NumPowerDomains + 1), ZX_ERR_OUT_OF_RANGE);

  uint32_t test_index = 0;
  MtkRegulator& domain = power_test.GetPowerDomain(test_index);
  EnableDomainHelper(pmic_regs, domain);
  ASSERT_OK(power_test.PowerImplEnablePowerDomain(test_index));
  ASSERT_EQ(domain.enabled(), true);
  pmic_regs.VerifyAll();
}

TEST(PowerTest, DisablePowerDomain) {
  ddk_mock::MockMmioReg pmic_reg_array[kPmicMmioRegCount];
  ddk_mock::MockMmioRegRegion pmic_regs(pmic_reg_array, sizeof(uint32_t), kPmicMmioRegCount);
  MtkPowerTest power_test(pmic_regs);

  InitPowerRegulatorsHelper(pmic_regs);
  power_test.InitPowerRegulators();

  // Test disabling invalid PowerDomain fails
  ASSERT_EQ(power_test.PowerImplDisablePowerDomain(kMt8167NumPowerDomains + 1),
            ZX_ERR_OUT_OF_RANGE);

  // Test disabling a regulator that is not enabled fails
  uint32_t test_index = 0;
  MtkRegulator& domain = power_test.GetPowerDomain(test_index);
  ASSERT_EQ(domain.enabled(), false);
  ASSERT_EQ(power_test.PowerImplDisablePowerDomain(test_index), ZX_ERR_BAD_STATE);

  // Enable power domain
  EnableDomainHelper(pmic_regs, domain);
  ASSERT_OK(power_test.PowerImplEnablePowerDomain(test_index));
  pmic_regs.VerifyAll();

  // Test disabling the above enabled power domain succeeds
  ReadPmicRegHelper(pmic_regs, domain.enable_register(), 0);
  WritePmicRegHelper(pmic_regs, domain.enable_register(), 0);
  ASSERT_OK(power_test.PowerImplDisablePowerDomain(test_index));
  pmic_regs.VerifyAll();
  ASSERT_EQ(domain.enabled(), false);
}

TEST(PowerTest, GetSupportedVoltageRange) {
  ddk_mock::MockMmioReg pmic_reg_array[kPmicMmioRegCount];
  ddk_mock::MockMmioRegRegion pmic_regs(pmic_reg_array, sizeof(uint32_t), kPmicMmioRegCount);
  MtkPowerTest power_test(pmic_regs);

  InitPowerRegulatorsHelper(pmic_regs);
  power_test.InitPowerRegulators();

  uint32_t min_voltage = 0, max_voltage = 0;

  // Test Buck Regulator
  ASSERT_OK(power_test.PowerImplGetSupportedVoltageRange(0, &min_voltage, &max_voltage));
  ASSERT_EQ(min_voltage, 700000);
  ASSERT_EQ(max_voltage, 1493750);

  // Test Ldo Regulator
  ASSERT_OK(power_test.PowerImplGetSupportedVoltageRange(4, &min_voltage, &max_voltage));
  ASSERT_EQ(min_voltage, 1800000);
  ASSERT_EQ(max_voltage, 2200000);

  // Test Fixed Regulator
  ASSERT_EQ(power_test.PowerImplGetSupportedVoltageRange(3, &min_voltage, &max_voltage),
            ZX_ERR_NOT_SUPPORTED);
}

TEST(PowerTest, RequestVoltage) {
  ddk_mock::MockMmioReg pmic_reg_array[kPmicMmioRegCount];
  ddk_mock::MockMmioRegRegion pmic_regs(pmic_reg_array, sizeof(uint32_t), kPmicMmioRegCount);
  MtkPowerTest power_test(pmic_regs);

  InitPowerRegulatorsHelper(pmic_regs);
  power_test.InitPowerRegulators();
  pmic_regs.VerifyAll();

  uint32_t out_voltage;
  // Fixed Regulator tests
  ASSERT_EQ(power_test.PowerImplRequestVoltage(3, 0, &out_voltage), ZX_ERR_NOT_SUPPORTED);

  // BUCK Regulator tests
  uint32_t test_index = 0;
  // With voltage less than min voltage
  ASSERT_EQ(power_test.PowerImplRequestVoltage(test_index, 0, &out_voltage), ZX_ERR_NOT_SUPPORTED);
  // With voltage greater than max voltage
  ASSERT_EQ(power_test.PowerImplRequestVoltage(test_index, 1500000, &out_voltage),
            ZX_ERR_NOT_SUPPORTED);

  // With a supported voltage
  uint32_t test_voltage = 706251;
  uint16_t expected_selector = 1;
  uint32_t expected_out_voltage = 706250;

  MtkBuckRegulator& buck_domain =
      static_cast<MtkBuckRegulator&>(power_test.GetPowerDomain(test_index));
  uint32_t expected_write_value =
      ((expected_selector << buck_domain.voltage_sel_shift()) & buck_domain.voltage_sel_mask());
  ReadPmicRegHelper(pmic_regs, buck_domain.voltage_sel_reg(), 0);
  WritePmicRegHelper(pmic_regs, buck_domain.voltage_sel_reg(), expected_write_value);
  ASSERT_OK(power_test.PowerImplRequestVoltage(test_index, test_voltage, &out_voltage));
  ASSERT_EQ(buck_domain.cur_voltage(), out_voltage);
  ASSERT_EQ(out_voltage, expected_out_voltage);

  // With a voltage that is already set
  ASSERT_OK(power_test.PowerImplRequestVoltage(test_index, test_voltage, &out_voltage));

  // LDO Regulator tests
  test_index = 4;
  // With voltage less than min voltage
  ASSERT_EQ(power_test.PowerImplRequestVoltage(test_index, 1700000, &out_voltage),
            ZX_ERR_NOT_SUPPORTED);
  // With voltage greater than max voltage
  ASSERT_EQ(power_test.PowerImplRequestVoltage(test_index, 2200500, &out_voltage),
            ZX_ERR_NOT_SUPPORTED);
  test_voltage = 1800500;
  expected_selector = 0;
  expected_out_voltage = 1800000;
  MtkLdoRegulator& ldo_domain =
      static_cast<MtkLdoRegulator&>(power_test.GetPowerDomain(test_index));
  expected_write_value =
      ((expected_selector << ldo_domain.voltage_sel_shift()) & ldo_domain.voltage_sel_mask());
  ReadPmicRegHelper(pmic_regs, ldo_domain.voltage_sel_reg(), 0);
  WritePmicRegHelper(pmic_regs, ldo_domain.voltage_sel_reg(), expected_write_value);
  ASSERT_OK(power_test.PowerImplRequestVoltage(test_index, test_voltage, &out_voltage));
  ASSERT_EQ(ldo_domain.cur_voltage(), out_voltage);
  ASSERT_EQ(out_voltage, expected_out_voltage);

  // With a voltage that is already set
  ASSERT_OK(power_test.PowerImplRequestVoltage(test_index, test_voltage, &out_voltage));
}

TEST(PowerTest, GetCurrentVoltage) {
  ddk_mock::MockMmioReg pmic_reg_array[kPmicMmioRegCount];
  ddk_mock::MockMmioRegRegion pmic_regs(pmic_reg_array, sizeof(uint32_t), kPmicMmioRegCount);
  MtkPowerTest power_test(pmic_regs);

  InitPowerRegulatorsHelper(pmic_regs);
  power_test.InitPowerRegulators();
  pmic_regs.VerifyAll();

  uint32_t out_voltage;
  uint32_t test_index = 0;

  // Fixed Regulator tests
  test_index = 3;
  MtkFixedRegulator& fixed_domain =
      static_cast<MtkFixedRegulator&>(power_test.GetPowerDomain(test_index));
  ASSERT_OK(power_test.PowerImplGetCurrentVoltage(test_index, &out_voltage));
  ASSERT_EQ(fixed_domain.default_voltage(), out_voltage);

  // BUCK Regulator tests
  test_index = 0;
  MtkBuckRegulator& buck_domain =
      static_cast<MtkBuckRegulator&>(power_test.GetPowerDomain(test_index));
  ASSERT_OK(power_test.PowerImplGetCurrentVoltage(test_index, &out_voltage));
  ASSERT_EQ(buck_domain.default_voltage(), out_voltage);

  // change current voltage
  uint32_t test_voltage = 706251;
  uint16_t expected_selector = 1;
  uint32_t expected_out_voltage = 706250;

  uint32_t expected_write_value =
      ((expected_selector << buck_domain.voltage_sel_shift()) & buck_domain.voltage_sel_mask());
  ReadPmicRegHelper(pmic_regs, buck_domain.voltage_sel_reg(), 0);
  WritePmicRegHelper(pmic_regs, buck_domain.voltage_sel_reg(), expected_write_value);

  ASSERT_OK(power_test.PowerImplRequestVoltage(test_index, test_voltage, &out_voltage));
  ASSERT_EQ(out_voltage, expected_out_voltage);
  ASSERT_OK(power_test.PowerImplGetCurrentVoltage(test_index, &out_voltage));
  ASSERT_EQ(buck_domain.cur_voltage(), out_voltage);

  // LDO Regulator tests
  test_index = 4;
  MtkLdoRegulator& ldo_domain =
      static_cast<MtkLdoRegulator&>(power_test.GetPowerDomain(test_index));
  ASSERT_OK(power_test.PowerImplGetCurrentVoltage(test_index, &out_voltage));
  ASSERT_EQ(ldo_domain.default_voltage(), out_voltage);

  // change current voltage
  test_voltage = 1800500;
  expected_selector = 0;
  expected_out_voltage = 1800000;
  expected_write_value =
      ((expected_selector << ldo_domain.voltage_sel_shift()) & ldo_domain.voltage_sel_mask());
  ReadPmicRegHelper(pmic_regs, ldo_domain.voltage_sel_reg(), 0);
  WritePmicRegHelper(pmic_regs, ldo_domain.voltage_sel_reg(), expected_write_value);
  ASSERT_OK(power_test.PowerImplRequestVoltage(test_index, test_voltage, &out_voltage));
  ASSERT_EQ(out_voltage, expected_out_voltage);
  ASSERT_OK(power_test.PowerImplGetCurrentVoltage(test_index, &out_voltage));
  ASSERT_EQ(ldo_domain.cur_voltage(), out_voltage);
}

}  // namespace power
