mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2025-05-31 06:48:22 -04:00
strat: use m_ for member variables
This commit is contained in:
Michael Scire
parent
ce28591ab2
commit
a595c232b9
425 changed files with 8531 additions and 8484 deletions
|
|
@ -45,16 +45,16 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
}
|
||||
|
||||
BatteryDevice::BatteryDevice(bool ev) : use_event_handler(ev), event_handler() {
|
||||
if (this->use_event_handler) {
|
||||
BatteryDevice::BatteryDevice(bool ev) : m_use_event_handler(ev), m_event_handler() {
|
||||
if (m_use_event_handler) {
|
||||
/* Create the system event. */
|
||||
os::CreateSystemEvent(std::addressof(this->system_event), os::EventClearMode_ManualClear, true);
|
||||
os::CreateSystemEvent(std::addressof(m_system_event), os::EventClearMode_ManualClear, true);
|
||||
|
||||
/* Create the handler. */
|
||||
this->event_handler.emplace(this);
|
||||
m_event_handler.emplace(this);
|
||||
|
||||
/* Register the event handler. */
|
||||
powctl::impl::RegisterInterruptHandler(std::addressof(*this->event_handler));
|
||||
powctl::impl::RegisterInterruptHandler(std::addressof(*m_event_handler));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -25,17 +25,17 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
NON_MOVEABLE(BatteryDevice);
|
||||
AMS_DDSF_CASTABLE_TRAITS(ams::powctl::impl::board::nintendo::nx::BatteryDevice, ::ams::powctl::impl::IDevice);
|
||||
private:
|
||||
bool use_event_handler;
|
||||
util::optional<BatteryInterruptEventHandler> event_handler;
|
||||
os::SystemEventType system_event;
|
||||
bool m_use_event_handler;
|
||||
util::optional<BatteryInterruptEventHandler> m_event_handler;
|
||||
os::SystemEventType m_system_event;
|
||||
public:
|
||||
BatteryDevice(bool ev);
|
||||
|
||||
os::SystemEventType *GetSystemEvent() { return std::addressof(this->system_event); }
|
||||
os::SystemEventType *GetSystemEvent() { return std::addressof(m_system_event); }
|
||||
|
||||
void SetInterruptEnabled(bool en) {
|
||||
if (this->use_event_handler) {
|
||||
this->event_handler->SetInterruptEnabled(en);
|
||||
if (m_use_event_handler) {
|
||||
m_event_handler->SetInterruptEnabled(en);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -267,25 +267,25 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::SetPreChargeCurrentLimit(int ma) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::PreChargeTerminationCurrentControl, 0xF0, bq24193::EncodePreChargeCurrentLimit(ma));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::PreChargeTerminationCurrentControl, 0xF0, bq24193::EncodePreChargeCurrentLimit(ma));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::SetTerminationCurrentLimit(int ma) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::PreChargeTerminationCurrentControl, 0x0F, bq24193::EncodeTerminationCurrentLimit(ma));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::PreChargeTerminationCurrentControl, 0x0F, bq24193::EncodeTerminationCurrentLimit(ma));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::SetMinimumSystemVoltageLimit(int mv) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::PowerOnConfiguration, 0x0E, bq24193::EncodeMinimumSystemVoltageLimit(mv));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::PowerOnConfiguration, 0x0E, bq24193::EncodeMinimumSystemVoltageLimit(mv));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::SetChargingSafetyTimerEnabled(bool en) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::ChargeTerminationTimerControl, 0x08, en ? 0x08 : 0x00);
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::ChargeTerminationTimerControl, 0x08, en ? 0x08 : 0x00);
|
||||
}
|
||||
|
||||
Result Bq24193Driver::GetForce20PercentChargeCurrent(bool *out) {
|
||||
/* Get the register. */
|
||||
u8 val;
|
||||
R_TRY(i2c::ReadSingleRegister(this->i2c_session, bq24193::ChargeCurrentControl, std::addressof(val)));
|
||||
R_TRY(i2c::ReadSingleRegister(m_i2c_session, bq24193::ChargeCurrentControl, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out = (val & 0x01) != 0;
|
||||
|
|
@ -293,13 +293,13 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::SetForce20PercentChargeCurrent(bool en) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::ChargeCurrentControl, 0x01, en ? 0x01 : 0x00);
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::ChargeCurrentControl, 0x01, en ? 0x01 : 0x00);
|
||||
}
|
||||
|
||||
Result Bq24193Driver::GetFastChargeCurrentLimit(int *out_ma) {
|
||||
/* Get the register. */
|
||||
u8 val;
|
||||
R_TRY(i2c::ReadSingleRegister(this->i2c_session, bq24193::ChargeCurrentControl, std::addressof(val)));
|
||||
R_TRY(i2c::ReadSingleRegister(m_i2c_session, bq24193::ChargeCurrentControl, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out_ma = bq24193::DecodeFastChargeCurrentLimit(val);
|
||||
|
|
@ -307,13 +307,13 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::SetFastChargeCurrentLimit(int ma) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::ChargeCurrentControl, 0xFC, bq24193::EncodeFastChargeCurrentLimit(ma));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::ChargeCurrentControl, 0xFC, bq24193::EncodeFastChargeCurrentLimit(ma));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::GetChargeVoltageLimit(int *out_mv) {
|
||||
/* Get the register. */
|
||||
u8 val;
|
||||
R_TRY(i2c::ReadSingleRegister(this->i2c_session, bq24193::ChargeVoltageControl, std::addressof(val)));
|
||||
R_TRY(i2c::ReadSingleRegister(m_i2c_session, bq24193::ChargeVoltageControl, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out_mv = bq24193::DecodeChargeVoltageLimit(val);
|
||||
|
|
@ -321,17 +321,17 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::SetChargeVoltageLimit(int mv) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::ChargeVoltageControl, 0xFC, bq24193::EncodeChargeVoltageLimit(mv));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::ChargeVoltageControl, 0xFC, bq24193::EncodeChargeVoltageLimit(mv));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::SetChargerConfiguration(bq24193::ChargerConfiguration cfg) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::PowerOnConfiguration, 0x30, bq24193::EncodeChargerConfiguration(cfg));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::PowerOnConfiguration, 0x30, bq24193::EncodeChargerConfiguration(cfg));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::IsHiZEnabled(bool *out) {
|
||||
/* Get the register. */
|
||||
u8 val;
|
||||
R_TRY(i2c::ReadSingleRegister(this->i2c_session, bq24193::InputSourceControl, std::addressof(val)));
|
||||
R_TRY(i2c::ReadSingleRegister(m_i2c_session, bq24193::InputSourceControl, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out = (val & 0x80) != 0;
|
||||
|
|
@ -339,13 +339,13 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::SetHiZEnabled(bool en) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::InputSourceControl, 0x80, en ? 0x80 : 0x00);
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::InputSourceControl, 0x80, en ? 0x80 : 0x00);
|
||||
}
|
||||
|
||||
Result Bq24193Driver::GetInputCurrentLimit(int *out_ma) {
|
||||
/* Get the register. */
|
||||
u8 val;
|
||||
R_TRY(i2c::ReadSingleRegister(this->i2c_session, bq24193::InputSourceControl, std::addressof(val)));
|
||||
R_TRY(i2c::ReadSingleRegister(m_i2c_session, bq24193::InputSourceControl, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out_ma = bq24193::DecodeInputCurrentLimit(val);
|
||||
|
|
@ -353,21 +353,21 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::SetInputCurrentLimit(int ma) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::InputSourceControl, 0x07, bq24193::EncodeInputCurrentLimit(ma));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::InputSourceControl, 0x07, bq24193::EncodeInputCurrentLimit(ma));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::SetInputVoltageLimit(int mv) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::InputSourceControl, 0x78, bq24193::EncodeInputVoltageLimit(mv));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::InputSourceControl, 0x78, bq24193::EncodeInputVoltageLimit(mv));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::SetBoostModeCurrentLimit(int ma) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::PowerOnConfiguration, 0x01, bq24193::EncodeBoostModeCurrentLimit(ma));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::PowerOnConfiguration, 0x01, bq24193::EncodeBoostModeCurrentLimit(ma));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::GetChargerStatus(bq24193::ChargerStatus *out) {
|
||||
/* Get the register. */
|
||||
u8 val;
|
||||
R_TRY(i2c::ReadSingleRegister(this->i2c_session, bq24193::SystemStatus, std::addressof(val)));
|
||||
R_TRY(i2c::ReadSingleRegister(m_i2c_session, bq24193::SystemStatus, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out = bq24193::DecodeChargerStatus(val);
|
||||
|
|
@ -375,17 +375,17 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::ResetWatchdogTimer() {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::PowerOnConfiguration, 0x40, 0x40);
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::PowerOnConfiguration, 0x40, 0x40);
|
||||
}
|
||||
|
||||
Result Bq24193Driver::SetWatchdogTimerSetting(int seconds) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::ChargeTerminationTimerControl, 0x30, bq24193::EncodeWatchdogTimerSetting(seconds));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::ChargeTerminationTimerControl, 0x30, bq24193::EncodeWatchdogTimerSetting(seconds));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::GetBatteryCompensation(int *out_mo) {
|
||||
/* Get the register. */
|
||||
u8 val;
|
||||
R_TRY(i2c::ReadSingleRegister(this->i2c_session, bq24193::IrCompensationThermalRegulationControl, std::addressof(val)));
|
||||
R_TRY(i2c::ReadSingleRegister(m_i2c_session, bq24193::IrCompensationThermalRegulationControl, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out_mo = bq24193::DecodeBatteryCompensation(val);
|
||||
|
|
@ -393,13 +393,13 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::SetBatteryCompensation(int mo) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::IrCompensationThermalRegulationControl, 0xE0, bq24193::EncodeBatteryCompensation(mo));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::IrCompensationThermalRegulationControl, 0xE0, bq24193::EncodeBatteryCompensation(mo));
|
||||
}
|
||||
|
||||
Result Bq24193Driver::GetVoltageClamp(int *out_mv) {
|
||||
/* Get the register. */
|
||||
u8 val;
|
||||
R_TRY(i2c::ReadSingleRegister(this->i2c_session, bq24193::IrCompensationThermalRegulationControl, std::addressof(val)));
|
||||
R_TRY(i2c::ReadSingleRegister(m_i2c_session, bq24193::IrCompensationThermalRegulationControl, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out_mv = bq24193::DecodeVoltageClamp(val);
|
||||
|
|
@ -407,7 +407,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Bq24193Driver::SetVoltageClamp(int mv) {
|
||||
return ReadWriteRegister(this->i2c_session, bq24193::IrCompensationThermalRegulationControl, 0x1C, bq24193::EncodeVoltageClamp(mv));
|
||||
return ReadWriteRegister(m_i2c_session, bq24193::IrCompensationThermalRegulationControl, 0x1C, bq24193::EncodeVoltageClamp(mv));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -37,24 +37,24 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
class Bq24193Driver {
|
||||
private:
|
||||
os::SdkMutex mutex;
|
||||
int init_count;
|
||||
i2c::I2cSession i2c_session;
|
||||
os::SdkMutex m_mutex;
|
||||
int m_init_count;
|
||||
i2c::I2cSession m_i2c_session;
|
||||
private:
|
||||
Result InitializeSession();
|
||||
public:
|
||||
Bq24193Driver() : mutex(), init_count(0), i2c_session() {
|
||||
Bq24193Driver() : m_mutex(), m_init_count(0), m_i2c_session() {
|
||||
/* ... */
|
||||
}
|
||||
|
||||
void Initialize() {
|
||||
std::scoped_lock lk(this->mutex);
|
||||
if ((this->init_count++) == 0) {
|
||||
std::scoped_lock lk(m_mutex);
|
||||
if ((m_init_count++) == 0) {
|
||||
/* Initialize i2c library. */
|
||||
i2c::InitializeEmpty();
|
||||
|
||||
/* Open session. */
|
||||
R_ABORT_UNLESS(i2c::OpenSession(std::addressof(this->i2c_session), i2c::DeviceCode_Bq24193));
|
||||
R_ABORT_UNLESS(i2c::OpenSession(std::addressof(m_i2c_session), i2c::DeviceCode_Bq24193));
|
||||
|
||||
/* Initialize session. */
|
||||
R_ABORT_UNLESS(this->InitializeSession());
|
||||
|
|
@ -62,10 +62,10 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
void Finalize() {
|
||||
std::scoped_lock lk(this->mutex);
|
||||
if ((--this->init_count) == 0) {
|
||||
std::scoped_lock lk(m_mutex);
|
||||
if ((--m_init_count) == 0) {
|
||||
/* Close session. */
|
||||
i2c::CloseSession(this->i2c_session);
|
||||
i2c::CloseSession(m_i2c_session);
|
||||
|
||||
/* Finalize i2c library. */
|
||||
i2c::Finalize();
|
||||
|
|
|
|||
|
|
@ -43,16 +43,16 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
}
|
||||
|
||||
ChargerDevice::ChargerDevice(bool ev) : gpio_pad_session(), watchdog_timer_enabled(false), watchdog_timer_timeout(0), use_event_handler(ev), event_handler() {
|
||||
if (this->use_event_handler) {
|
||||
ChargerDevice::ChargerDevice(bool ev) : m_gpio_pad_session(), m_watchdog_timer_enabled(false), m_watchdog_timer_timeout(0), m_use_event_handler(ev), m_event_handler() {
|
||||
if (m_use_event_handler) {
|
||||
/* Create the system event. */
|
||||
os::CreateSystemEvent(std::addressof(this->system_event), os::EventClearMode_ManualClear, true);
|
||||
os::CreateSystemEvent(std::addressof(m_system_event), os::EventClearMode_ManualClear, true);
|
||||
|
||||
/* Create the handler. */
|
||||
this->event_handler.emplace(this);
|
||||
m_event_handler.emplace(this);
|
||||
|
||||
/* Register the event handler. */
|
||||
powctl::impl::RegisterInterruptHandler(std::addressof(*this->event_handler));
|
||||
powctl::impl::RegisterInterruptHandler(std::addressof(*m_event_handler));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -25,28 +25,28 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
NON_MOVEABLE(ChargerDevice);
|
||||
AMS_DDSF_CASTABLE_TRAITS(ams::powctl::impl::board::nintendo::nx::ChargerDevice, ::ams::powctl::impl::IDevice);
|
||||
private:
|
||||
gpio::GpioPadSession gpio_pad_session;
|
||||
bool watchdog_timer_enabled;
|
||||
TimeSpan watchdog_timer_timeout;
|
||||
bool use_event_handler;
|
||||
util::optional<ChargerInterruptEventHandler> event_handler;
|
||||
os::SystemEventType system_event;
|
||||
gpio::GpioPadSession m_gpio_pad_session;
|
||||
bool m_watchdog_timer_enabled;
|
||||
TimeSpan m_watchdog_timer_timeout;
|
||||
bool m_use_event_handler;
|
||||
util::optional<ChargerInterruptEventHandler> m_event_handler;
|
||||
os::SystemEventType m_system_event;
|
||||
public:
|
||||
ChargerDevice(bool ev);
|
||||
|
||||
bool IsWatchdogTimerEnabled() const { return this->watchdog_timer_enabled; }
|
||||
void SetWatchdogTimerEnabled(bool en) { this->watchdog_timer_enabled = en; }
|
||||
bool IsWatchdogTimerEnabled() const { return m_watchdog_timer_enabled; }
|
||||
void SetWatchdogTimerEnabled(bool en) { m_watchdog_timer_enabled = en; }
|
||||
|
||||
TimeSpan GetWatchdogTimerTimeout() const { return this->watchdog_timer_timeout; }
|
||||
void SetWatchdogTimerTimeout(TimeSpan ts) { this->watchdog_timer_timeout = ts; }
|
||||
TimeSpan GetWatchdogTimerTimeout() const { return m_watchdog_timer_timeout; }
|
||||
void SetWatchdogTimerTimeout(TimeSpan ts) { m_watchdog_timer_timeout = ts; }
|
||||
|
||||
gpio::GpioPadSession *GetPadSession() { return std::addressof(this->gpio_pad_session); }
|
||||
gpio::GpioPadSession *GetPadSession() { return std::addressof(m_gpio_pad_session); }
|
||||
|
||||
os::SystemEventType *GetSystemEvent() { return std::addressof(this->system_event); }
|
||||
os::SystemEventType *GetSystemEvent() { return std::addressof(m_system_event); }
|
||||
|
||||
void SetInterruptEnabled(bool en) {
|
||||
if (this->use_event_handler) {
|
||||
this->event_handler->SetInterruptEnabled(en);
|
||||
if (m_use_event_handler) {
|
||||
m_event_handler->SetInterruptEnabled(en);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -22,41 +22,41 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
template<typename Derived>
|
||||
class InterruptEventHandler : public ddsf::IEventHandler {
|
||||
private:
|
||||
IDevice *device;
|
||||
gpio::GpioPadSession gpio_session;
|
||||
os::SystemEventType gpio_system_event;
|
||||
os::SdkMutex mutex;
|
||||
IDevice *m_device;
|
||||
gpio::GpioPadSession m_gpio_session;
|
||||
os::SystemEventType m_gpio_system_event;
|
||||
os::SdkMutex m_mutex;
|
||||
public:
|
||||
InterruptEventHandler(IDevice *dv) : IEventHandler(), device(dv), mutex() {
|
||||
InterruptEventHandler(IDevice *dv) : IEventHandler(), m_device(dv), m_mutex() {
|
||||
/* Initialize the gpio session. */
|
||||
Derived::Initialize(std::addressof(this->gpio_session), std::addressof(this->gpio_system_event));
|
||||
Derived::Initialize(std::addressof(m_gpio_session), std::addressof(m_gpio_system_event));
|
||||
|
||||
/* Initialize ourselves as an event handler. */
|
||||
IEventHandler::Initialize(std::addressof(this->gpio_system_event));
|
||||
IEventHandler::Initialize(std::addressof(m_gpio_system_event));
|
||||
}
|
||||
|
||||
os::SystemEventType *GetSystemEvent() {
|
||||
return std::addressof(this->gpio_system_event);
|
||||
return std::addressof(m_gpio_system_event);
|
||||
}
|
||||
|
||||
void SetInterruptEnabled(bool en) {
|
||||
std::scoped_lock lk(this->mutex);
|
||||
std::scoped_lock lk(m_mutex);
|
||||
|
||||
gpio::SetInterruptEnable(std::addressof(this->gpio_session), en);
|
||||
gpio::SetInterruptEnable(std::addressof(m_gpio_session), en);
|
||||
}
|
||||
|
||||
virtual void HandleEvent() override final {
|
||||
/* Acquire exclusive access to ourselves. */
|
||||
std::scoped_lock lk(this->mutex);
|
||||
std::scoped_lock lk(m_mutex);
|
||||
|
||||
/* Clear our interrupt status. */
|
||||
gpio::ClearInterruptStatus(std::addressof(this->gpio_session));
|
||||
gpio::ClearInterruptStatus(std::addressof(m_gpio_session));
|
||||
|
||||
/* Clear our system event. */
|
||||
os::ClearSystemEvent(std::addressof(this->gpio_system_event));
|
||||
os::ClearSystemEvent(std::addressof(m_gpio_system_event));
|
||||
|
||||
/* Signal the event. */
|
||||
static_cast<Derived *>(this)->SignalEvent(this->device);
|
||||
static_cast<Derived *>(this)->SignalEvent(m_device);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -255,22 +255,22 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
os::SleepThread(TimeSpan::FromMilliSeconds(500));
|
||||
|
||||
/* Write initial config. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::Config, 0x7210));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::Config, 0x7210));
|
||||
|
||||
/* Write initial filter config. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::FilterCfg, 0x8784));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::FilterCfg, 0x8784));
|
||||
|
||||
/* Write relax config. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::RelaxCfg, params.relaxcfg));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::RelaxCfg, params.relaxcfg));
|
||||
|
||||
/* Write initial learn config. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::LearnCfg, 0x2603));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::LearnCfg, 0x2603));
|
||||
|
||||
/* Write fullsocthr. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::FullSocThr, params.fullsocthr));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::FullSocThr, params.fullsocthr));
|
||||
|
||||
/* Write iavgempty. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::IAvgEmpty, params.iavgempty));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::IAvgEmpty, params.iavgempty));
|
||||
|
||||
/* Unlock model table, write model table. */
|
||||
do {
|
||||
|
|
@ -295,33 +295,33 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
/* Write and validate rcomp0 */
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::RComp0, params.rcomp0)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::RComp0, params.rcomp0)) { /* ... */ }
|
||||
|
||||
/* Write and validate tempco */
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::TempCo, params.tempco)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::TempCo, params.tempco)) { /* ... */ }
|
||||
|
||||
/* Write ichgterm. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::IChgTerm, params.ichgterm));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::IChgTerm, params.ichgterm));
|
||||
|
||||
/* Write tgain. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::TGain, params.tgain));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::TGain, params.tgain));
|
||||
|
||||
/* Write toff. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::TOff, params.toff));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::TOff, params.toff));
|
||||
|
||||
/* Write and validate vempty. */
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::VEmpty, params.vempty)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::VEmpty, params.vempty)) { /* ... */ }
|
||||
|
||||
/* Write and validate qresidual. */
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::QResidual00, params.qresidual00)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::QResidual10, params.qresidual10)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::QResidual20, params.qresidual20)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::QResidual30, params.qresidual30)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::QResidual00, params.qresidual00)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::QResidual10, params.qresidual10)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::QResidual20, params.qresidual20)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::QResidual30, params.qresidual30)) { /* ... */ }
|
||||
|
||||
/* Write capacity parameters. */
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::FullCap, params.fullcap)) { /* ... */ }
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::DesignCap, params.vffullcap));
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::FullCapNom, params.vffullcap)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::FullCap, params.fullcap)) { /* ... */ }
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::DesignCap, params.vffullcap));
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::FullCapNom, params.vffullcap)) { /* ... */ }
|
||||
|
||||
/* Give some time for configuration to take. */
|
||||
os::SleepThread(TimeSpan::FromMilliSeconds(350));
|
||||
|
|
@ -329,81 +329,81 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
/* Write vfsoc to vfsoc0, qh, to qh0. */
|
||||
u16 vfsoc, qh;
|
||||
{
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::SocVf, std::addressof(vfsoc)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::SocVf, std::addressof(vfsoc)));
|
||||
R_TRY(this->UnlockVfSoc());
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::SocVf0, vfsoc)) { /* ... */ }
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::Qh, std::addressof(qh)));
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::Qh0, qh));
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::SocVf0, vfsoc)) { /* ... */ }
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::Qh, std::addressof(qh)));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::Qh0, qh));
|
||||
R_TRY(this->LockVfSoc());
|
||||
}
|
||||
|
||||
/* Reset cycles. */
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::Cycles, 0x0060)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::Cycles, 0x0060)) { /* ... */ }
|
||||
|
||||
/* Load new capacity parameters. */
|
||||
const u16 remcap = static_cast<u16>((vfsoc * params.vffullcap) / 0x6400);
|
||||
const u16 repcap = static_cast<u16>(remcap * (params.fullcap / params.vffullcap));
|
||||
const u16 dpacc = 0x0C80;
|
||||
const u16 dqacc = params.vffullcap / 0x10;
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::RemCapMix, remcap)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::RemCapRep, repcap)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::DPAcc, dpacc)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::DQAcc, dqacc)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::RemCapMix, remcap)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::RemCapRep, repcap)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::DPAcc, dpacc)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::DQAcc, dqacc)) { /* ... */ }
|
||||
|
||||
/* Write capacity parameters. */
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::FullCap, params.fullcap)) { /* ... */ }
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::DesignCap, params.vffullcap));
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::FullCapNom, params.vffullcap)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::FullCap, params.fullcap)) { /* ... */ }
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::DesignCap, params.vffullcap));
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::FullCapNom, params.vffullcap)) { /* ... */ }
|
||||
|
||||
/* Write soc rep. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::SocRep, vfsoc));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::SocRep, vfsoc));
|
||||
|
||||
/* Clear power on reset. */
|
||||
R_TRY(ReadWriteValidateRegister(this->i2c_session, max17050::Status, 0x0002, 0x0000));
|
||||
R_TRY(ReadWriteValidateRegister(m_i2c_session, max17050::Status, 0x0002, 0x0000));
|
||||
|
||||
/* Set cgain. */
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::CGain, 0x7FFF));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::CGain, 0x7FFF));
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result Max17050Driver::SetMaximumShutdownTimerThreshold() {
|
||||
return WriteRegister(this->i2c_session, max17050::ShdnTimer, 0xE000);
|
||||
return WriteRegister(m_i2c_session, max17050::ShdnTimer, 0xE000);
|
||||
}
|
||||
|
||||
bool Max17050Driver::IsPowerOnReset() {
|
||||
/* Get the register. */
|
||||
u16 val;
|
||||
R_ABORT_UNLESS(ReadRegister(this->i2c_session, max17050::Status, std::addressof(val)));
|
||||
R_ABORT_UNLESS(ReadRegister(m_i2c_session, max17050::Status, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
return (val & 0x0002) != 0;
|
||||
}
|
||||
|
||||
Result Max17050Driver::LockVfSoc() {
|
||||
return WriteRegister(this->i2c_session, max17050::SocVfAccess, 0x0000);
|
||||
return WriteRegister(m_i2c_session, max17050::SocVfAccess, 0x0000);
|
||||
}
|
||||
|
||||
Result Max17050Driver::UnlockVfSoc() {
|
||||
return WriteRegister(this->i2c_session, max17050::SocVfAccess, 0x0080);
|
||||
return WriteRegister(m_i2c_session, max17050::SocVfAccess, 0x0080);
|
||||
}
|
||||
|
||||
Result Max17050Driver::LockModelTable() {
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::ModelAccess0, 0x0000));
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::ModelAccess1, 0x0000));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::ModelAccess0, 0x0000));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::ModelAccess1, 0x0000));
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result Max17050Driver::UnlockModelTable() {
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::ModelAccess0, 0x0059));
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::ModelAccess1, 0x00C4));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::ModelAccess0, 0x0059));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::ModelAccess1, 0x00C4));
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
bool Max17050Driver::IsModelTableLocked() {
|
||||
for (size_t i = 0; i < max17050::ModelChrTblSize; ++i) {
|
||||
u16 val;
|
||||
R_ABORT_UNLESS(ReadRegister(this->i2c_session, max17050::ModelChrTblStart + i, std::addressof(val)));
|
||||
R_ABORT_UNLESS(ReadRegister(m_i2c_session, max17050::ModelChrTblStart + i, std::addressof(val)));
|
||||
|
||||
if (val != 0) {
|
||||
return false;
|
||||
|
|
@ -415,7 +415,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
Result Max17050Driver::SetModelTable(const u16 *model_table) {
|
||||
for (size_t i = 0; i < max17050::ModelChrTblSize; ++i) {
|
||||
R_TRY(WriteRegister(this->i2c_session, max17050::ModelChrTblStart + i, model_table[i]));
|
||||
R_TRY(WriteRegister(m_i2c_session, max17050::ModelChrTblStart + i, model_table[i]));
|
||||
}
|
||||
|
||||
return ResultSuccess();
|
||||
|
|
@ -424,7 +424,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
bool Max17050Driver::IsModelTableSet(const u16 *model_table) {
|
||||
for (size_t i = 0; i < max17050::ModelChrTblSize; ++i) {
|
||||
u16 val;
|
||||
R_ABORT_UNLESS(ReadRegister(this->i2c_session, max17050::ModelChrTblStart + i, std::addressof(val)));
|
||||
R_ABORT_UNLESS(ReadRegister(m_i2c_session, max17050::ModelChrTblStart + i, std::addressof(val)));
|
||||
|
||||
if (val != model_table[i]) {
|
||||
return false;
|
||||
|
|
@ -435,45 +435,45 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Max17050Driver::ReadInternalState() {
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::RComp0, std::addressof(this->internal_state.rcomp0)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::TempCo, std::addressof(this->internal_state.tempco)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::FullCap, std::addressof(this->internal_state.fullcap)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::Cycles, std::addressof(this->internal_state.cycles)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::FullCapNom, std::addressof(this->internal_state.fullcapnom)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::IAvgEmpty, std::addressof(this->internal_state.iavgempty)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::QResidual00, std::addressof(this->internal_state.qresidual00)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::QResidual10, std::addressof(this->internal_state.qresidual10)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::QResidual20, std::addressof(this->internal_state.qresidual20)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::QResidual30, std::addressof(this->internal_state.qresidual30)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::RComp0, std::addressof(m_internal_state.rcomp0)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::TempCo, std::addressof(m_internal_state.tempco)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::FullCap, std::addressof(m_internal_state.fullcap)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::Cycles, std::addressof(m_internal_state.cycles)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::FullCapNom, std::addressof(m_internal_state.fullcapnom)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::IAvgEmpty, std::addressof(m_internal_state.iavgempty)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::QResidual00, std::addressof(m_internal_state.qresidual00)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::QResidual10, std::addressof(m_internal_state.qresidual10)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::QResidual20, std::addressof(m_internal_state.qresidual20)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::QResidual30, std::addressof(m_internal_state.qresidual30)));
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result Max17050Driver::WriteInternalState() {
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::RComp0, this->internal_state.rcomp0)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::TempCo, this->internal_state.tempco)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::FullCapNom, this->internal_state.fullcapnom)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::IAvgEmpty, this->internal_state.iavgempty)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::QResidual00, this->internal_state.qresidual00)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::QResidual10, this->internal_state.qresidual10)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::QResidual20, this->internal_state.qresidual20)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::QResidual30, this->internal_state.qresidual30)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::RComp0, m_internal_state.rcomp0)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::TempCo, m_internal_state.tempco)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::FullCapNom, m_internal_state.fullcapnom)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::IAvgEmpty, m_internal_state.iavgempty)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::QResidual00, m_internal_state.qresidual00)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::QResidual10, m_internal_state.qresidual10)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::QResidual20, m_internal_state.qresidual20)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::QResidual30, m_internal_state.qresidual30)) { /* ... */ }
|
||||
|
||||
os::SleepThread(TimeSpan::FromMilliSeconds(350));
|
||||
|
||||
u16 fullcap0, socmix;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::FullCap0, std::addressof(fullcap0)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::SocMix, std::addressof(socmix)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::FullCap0, std::addressof(fullcap0)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::SocMix, std::addressof(socmix)));
|
||||
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::RemCapMix, static_cast<u16>((fullcap0 * socmix) / 0x6400))) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::FullCap, this->internal_state.fullcap)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::DPAcc, 0x0C80)) { /* ... */ }
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::DQAcc, this->internal_state.fullcapnom / 0x10)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::RemCapMix, static_cast<u16>((fullcap0 * socmix) / 0x6400))) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::FullCap, m_internal_state.fullcap)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::DPAcc, 0x0C80)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::DQAcc, m_internal_state.fullcapnom / 0x10)) { /* ... */ }
|
||||
|
||||
os::SleepThread(TimeSpan::FromMilliSeconds(350));
|
||||
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::Cycles, this->internal_state.cycles)) { /* ... */ }
|
||||
if (this->internal_state.cycles >= 0x100) {
|
||||
while (!WriteValidateRegister(this->i2c_session, max17050::LearnCfg, 0x2673)) { /* ... */ }
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::Cycles, m_internal_state.cycles)) { /* ... */ }
|
||||
if (m_internal_state.cycles >= 0x100) {
|
||||
while (!WriteValidateRegister(m_i2c_session, max17050::LearnCfg, 0x2673)) { /* ... */ }
|
||||
}
|
||||
|
||||
return ResultSuccess();
|
||||
|
|
@ -485,7 +485,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::SocRep, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::SocRep, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = static_cast<double>(val) * 0.00390625;
|
||||
|
|
@ -498,7 +498,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::SocVf, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::SocVf, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = static_cast<double>(val) * 0.00390625;
|
||||
|
|
@ -512,8 +512,8 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the values. */
|
||||
u16 cgain, fullcap;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::CGain, std::addressof(cgain)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::FullCap, std::addressof(fullcap)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::CGain, std::addressof(cgain)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::FullCap, std::addressof(fullcap)));
|
||||
|
||||
/* Set output. */
|
||||
*out = ((static_cast<double>(fullcap) * 0.005) / sense_resistor) / (static_cast<double>(cgain) * 0.0000610351562);
|
||||
|
|
@ -527,8 +527,8 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the values. */
|
||||
u16 cgain, remcap;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::CGain, std::addressof(cgain)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::RemCapRep, std::addressof(remcap)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::CGain, std::addressof(cgain)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::RemCapRep, std::addressof(remcap)));
|
||||
|
||||
/* Set output. */
|
||||
*out = ((static_cast<double>(remcap) * 0.005) / sense_resistor) / (static_cast<double>(cgain) * 0.0000610351562);
|
||||
|
|
@ -536,11 +536,11 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Max17050Driver::SetPercentageMinimumAlertThreshold(int percentage) {
|
||||
return ReadWriteRegister(this->i2c_session, max17050::SocAlrtThreshold, 0x00FF, static_cast<u8>(percentage));
|
||||
return ReadWriteRegister(m_i2c_session, max17050::SocAlrtThreshold, 0x00FF, static_cast<u8>(percentage));
|
||||
}
|
||||
|
||||
Result Max17050Driver::SetPercentageMaximumAlertThreshold(int percentage) {
|
||||
return ReadWriteRegister(this->i2c_session, max17050::SocAlrtThreshold, 0xFF00, static_cast<u16>(static_cast<u8>(percentage)) << 8);
|
||||
return ReadWriteRegister(m_i2c_session, max17050::SocAlrtThreshold, 0xFF00, static_cast<u16>(static_cast<u8>(percentage)) << 8);
|
||||
}
|
||||
|
||||
Result Max17050Driver::SetPercentageFullThreshold(double percentage) {
|
||||
|
|
@ -550,7 +550,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
#error "Unknown architecture for floating point -> fixed point"
|
||||
#endif
|
||||
|
||||
return WriteRegister(this->i2c_session, max17050::FullSocThr, val);
|
||||
return WriteRegister(m_i2c_session, max17050::FullSocThr, val);
|
||||
}
|
||||
|
||||
Result Max17050Driver::GetAverageCurrent(double *out, double sense_resistor) {
|
||||
|
|
@ -560,9 +560,9 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the values. */
|
||||
u16 cgain, coff, avg_current;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::CGain, std::addressof(cgain)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::COff, std::addressof(coff)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::AverageCurrent, std::addressof(avg_current)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::CGain, std::addressof(cgain)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::COff, std::addressof(coff)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::AverageCurrent, std::addressof(avg_current)));
|
||||
|
||||
/* Set output. */
|
||||
*out = (((static_cast<double>(avg_current) - (static_cast<double>(coff) + static_cast<double>(coff))) / (static_cast<double>(cgain) * 0.0000610351562)) * 1.5625) / (sense_resistor * 1000.0);
|
||||
|
|
@ -576,9 +576,9 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the values. */
|
||||
u16 cgain, coff, current;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::CGain, std::addressof(cgain)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::COff, std::addressof(coff)));
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::Current, std::addressof(current)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::CGain, std::addressof(cgain)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::COff, std::addressof(coff)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::Current, std::addressof(current)));
|
||||
|
||||
/* Set output. */
|
||||
*out = (((static_cast<double>(current) - (static_cast<double>(coff) + static_cast<double>(coff))) / (static_cast<double>(cgain) * 0.0000610351562)) * 1.5625) / (sense_resistor * 1000.0);
|
||||
|
|
@ -588,7 +588,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
Result Max17050Driver::GetNeedToRestoreParameters(bool *out) {
|
||||
/* Get the register. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::MiscCfg, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::MiscCfg, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out = (val & 0x8000) != 0;
|
||||
|
|
@ -596,13 +596,13 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Max17050Driver::SetNeedToRestoreParameters(bool en) {
|
||||
return ReadWriteRegister(this->i2c_session, max17050::MiscCfg, 0x8000, en ? 0x8000 : 0);
|
||||
return ReadWriteRegister(m_i2c_session, max17050::MiscCfg, 0x8000, en ? 0x8000 : 0);
|
||||
}
|
||||
|
||||
Result Max17050Driver::IsI2cShutdownEnabled(bool *out) {
|
||||
/* Get the register. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::Config, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::Config, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out = (val & 0x0040) != 0;
|
||||
|
|
@ -610,20 +610,20 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Max17050Driver::SetI2cShutdownEnabled(bool en) {
|
||||
return ReadWriteRegister(this->i2c_session, max17050::Config, 0x0040, en ? 0x0040 : 0);
|
||||
return ReadWriteRegister(m_i2c_session, max17050::Config, 0x0040, en ? 0x0040 : 0);
|
||||
}
|
||||
|
||||
Result Max17050Driver::GetStatus(u16 *out) {
|
||||
/* Validate parameters. */
|
||||
AMS_ABORT_UNLESS(out != nullptr);
|
||||
|
||||
return ReadRegister(this->i2c_session, max17050::Status, out);
|
||||
return ReadRegister(m_i2c_session, max17050::Status, out);
|
||||
}
|
||||
|
||||
Result Max17050Driver::GetCycles(u16 *out) {
|
||||
/* Get the register. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::Cycles, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::Cycles, std::addressof(val)));
|
||||
|
||||
/* Extract the value. */
|
||||
*out = std::max<u16>(val, 0x60) - 0x60;
|
||||
|
|
@ -631,7 +631,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Max17050Driver::ResetCycles() {
|
||||
return WriteRegister(this->i2c_session, max17050::Cycles, 0x0060);
|
||||
return WriteRegister(m_i2c_session, max17050::Cycles, 0x0060);
|
||||
}
|
||||
|
||||
Result Max17050Driver::GetAge(double *out) {
|
||||
|
|
@ -640,7 +640,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::Age, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::Age, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = static_cast<double>(val) * 0.00390625;
|
||||
|
|
@ -653,7 +653,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::Temperature, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::Temperature, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = static_cast<double>(val) * 0.00390625;
|
||||
|
|
@ -666,7 +666,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::MaxMinTemp, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::MaxMinTemp, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = static_cast<u8>(val >> 8);
|
||||
|
|
@ -674,11 +674,11 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Max17050Driver::SetTemperatureMinimumAlertThreshold(int c) {
|
||||
return ReadWriteRegister(this->i2c_session, max17050::TAlrtThreshold, 0x00FF, static_cast<u8>(c));
|
||||
return ReadWriteRegister(m_i2c_session, max17050::TAlrtThreshold, 0x00FF, static_cast<u8>(c));
|
||||
}
|
||||
|
||||
Result Max17050Driver::SetTemperatureMaximumAlertThreshold(int c) {
|
||||
return ReadWriteRegister(this->i2c_session, max17050::TAlrtThreshold, 0xFF00, static_cast<u16>(static_cast<u8>(c)) << 8);
|
||||
return ReadWriteRegister(m_i2c_session, max17050::TAlrtThreshold, 0xFF00, static_cast<u16>(static_cast<u8>(c)) << 8);
|
||||
}
|
||||
|
||||
Result Max17050Driver::GetVCell(int *out) {
|
||||
|
|
@ -687,7 +687,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::VCell, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::VCell, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = (625 * (val >> 3)) / 1000;
|
||||
|
|
@ -700,7 +700,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::AverageVCell, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::AverageVCell, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = (625 * (val >> 3)) / 1000;
|
||||
|
|
@ -713,7 +713,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::FilterCfg, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::FilterCfg, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = 175.8 * ExponentiateTwoToPower(6 + ((val >> 4) & 7), 1.0);
|
||||
|
|
@ -726,7 +726,7 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
/* Read the value. */
|
||||
u16 val;
|
||||
R_TRY(ReadRegister(this->i2c_session, max17050::VFocV, std::addressof(val)));
|
||||
R_TRY(ReadRegister(m_i2c_session, max17050::VFocV, std::addressof(val)));
|
||||
|
||||
/* Set output. */
|
||||
*out = (1250 * (val >> 4)) / 1000;
|
||||
|
|
@ -734,11 +734,11 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
Result Max17050Driver::SetVoltageMinimumAlertThreshold(int mv) {
|
||||
return ReadWriteRegister(this->i2c_session, max17050::VAlrtThreshold, 0x00FF, static_cast<u8>(util::DivideUp(mv, 20)));
|
||||
return ReadWriteRegister(m_i2c_session, max17050::VAlrtThreshold, 0x00FF, static_cast<u8>(util::DivideUp(mv, 20)));
|
||||
}
|
||||
|
||||
Result Max17050Driver::SetVoltageMaximumAlertThreshold(int mv) {
|
||||
return ReadWriteRegister(this->i2c_session, max17050::VAlrtThreshold, 0xFF00, static_cast<u16>(static_cast<u8>(mv / 20)) << 8);
|
||||
return ReadWriteRegister(m_i2c_session, max17050::VAlrtThreshold, 0xFF00, static_cast<u16>(static_cast<u8>(mv / 20)) << 8);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,10 +37,10 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
|
||||
class Max17050Driver {
|
||||
private:
|
||||
os::SdkMutex mutex;
|
||||
int init_count;
|
||||
i2c::I2cSession i2c_session;
|
||||
max17050::InternalState internal_state;
|
||||
os::SdkMutex m_mutex;
|
||||
int m_init_count;
|
||||
i2c::I2cSession m_i2c_session;
|
||||
max17050::InternalState m_internal_state;
|
||||
private:
|
||||
Result InitializeSession(const char *battery_vendor, u8 battery_version);
|
||||
Result SetMaximumShutdownTimerThreshold();
|
||||
|
|
@ -54,18 +54,18 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
Result SetModelTable(const u16 *model_table);
|
||||
bool IsModelTableSet(const u16 *model_table);
|
||||
public:
|
||||
Max17050Driver() : mutex(), init_count(0), i2c_session(), internal_state() {
|
||||
Max17050Driver() : m_mutex(), m_init_count(0), m_i2c_session(), m_internal_state() {
|
||||
/* ... */
|
||||
}
|
||||
|
||||
void Initialize(const char *battery_vendor, u8 battery_version) {
|
||||
std::scoped_lock lk(this->mutex);
|
||||
if ((this->init_count++) == 0) {
|
||||
std::scoped_lock lk(m_mutex);
|
||||
if ((m_init_count++) == 0) {
|
||||
/* Initialize i2c library. */
|
||||
i2c::InitializeEmpty();
|
||||
|
||||
/* Open session. */
|
||||
R_ABORT_UNLESS(i2c::OpenSession(std::addressof(this->i2c_session), i2c::DeviceCode_Max17050));
|
||||
R_ABORT_UNLESS(i2c::OpenSession(std::addressof(m_i2c_session), i2c::DeviceCode_Max17050));
|
||||
|
||||
/* Initialize session. */
|
||||
R_ABORT_UNLESS(this->InitializeSession(battery_vendor, battery_version));
|
||||
|
|
@ -76,10 +76,10 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
}
|
||||
|
||||
void Finalize() {
|
||||
std::scoped_lock lk(this->mutex);
|
||||
if ((--this->init_count) == 0) {
|
||||
std::scoped_lock lk(m_mutex);
|
||||
if ((--m_init_count) == 0) {
|
||||
/* Close session. */
|
||||
i2c::CloseSession(this->i2c_session);
|
||||
i2c::CloseSession(m_i2c_session);
|
||||
|
||||
/* Finalize i2c library. */
|
||||
i2c::Finalize();
|
||||
|
|
@ -90,11 +90,11 @@ namespace ams::powctl::impl::board::nintendo::nx {
|
|||
Result WriteInternalState();
|
||||
|
||||
void GetInternalState(max17050::InternalState *dst) {
|
||||
*dst = this->internal_state;
|
||||
*dst = m_internal_state;
|
||||
}
|
||||
|
||||
void SetInternalState(const max17050::InternalState &src) {
|
||||
this->internal_state = src;
|
||||
m_internal_state = src;
|
||||
}
|
||||
|
||||
Result GetSocRep(double *out);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue