diff --git a/libstratosphere/include/stratosphere.hpp b/libstratosphere/include/stratosphere.hpp index 8b8b105f..760e9bf8 100644 --- a/libstratosphere/include/stratosphere.hpp +++ b/libstratosphere/include/stratosphere.hpp @@ -41,6 +41,7 @@ /* At this point, just include the rest alphabetically. */ /* TODO: Figure out optimal order. */ #include +#include #include #include #include diff --git a/libstratosphere/include/stratosphere/cal.hpp b/libstratosphere/include/stratosphere/cal.hpp new file mode 100644 index 00000000..49df7ae1 --- /dev/null +++ b/libstratosphere/include/stratosphere/cal.hpp @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once + +#include diff --git a/libstratosphere/include/stratosphere/cal/cal_battery_api.hpp b/libstratosphere/include/stratosphere/cal/cal_battery_api.hpp new file mode 100644 index 00000000..e576c95f --- /dev/null +++ b/libstratosphere/include/stratosphere/cal/cal_battery_api.hpp @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include + +namespace ams::cal { + + Result GetBatteryVersion(u8 *out); + Result GetBatteryVendor(size_t *out_vendor_size, void *dst, size_t dst_size); + +} diff --git a/libstratosphere/include/stratosphere/powctl.hpp b/libstratosphere/include/stratosphere/powctl.hpp index 02d42195..3f293ccd 100644 --- a/libstratosphere/include/stratosphere/powctl.hpp +++ b/libstratosphere/include/stratosphere/powctl.hpp @@ -20,4 +20,7 @@ #include #include #include +#include #include +#include +#include diff --git a/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_charge_arbiter.hpp b/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_charge_arbiter.hpp new file mode 100644 index 00000000..5aad9f11 --- /dev/null +++ b/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_charge_arbiter.hpp @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include +#include + +namespace ams::powctl::driver::impl { + + class ChargeArbiter { + private: + const ChargeParametersRule *rules; + size_t num_rules; + int charge_voltage_limit; + BatteryTemperatureLevel temperature_level; + int avg_v_cell; + int open_circuit_voltage; + bool has_battery_done_current; + int battery_done_current; + PowerState power_state; + const ChargeParametersRule *selected_rule; + bool check_battery_done_current; + private: + static constexpr bool IsInRange(int value, int min, int max) { + if (!(min <= value)) { + return false; + } + + if (max == std::numeric_limits::max()) { + return value <= max; + } else { + return value < max; + } + } + + bool IsAcceptablePowerState(const PowerState *acceptable, size_t num_acceptable) const { + for (size_t i = 0; i < num_acceptable; ++i) { + if (this->power_state == acceptable[i]) { + return true; + } + } + return false; + } + public: + ChargeArbiter(const ChargeParametersRule *r, size_t nr, int cvl) + : rules(r), num_rules(nr), charge_voltage_limit(cvl), temperature_level(BatteryTemperatureLevel::Medium), + avg_v_cell(4080), open_circuit_voltage(4001), has_battery_done_current(false), battery_done_current(0), + power_state(PowerState::FullAwake), selected_rule(nullptr), check_battery_done_current(false) + { + this->UpdateSelectedRule(); + } + + void SetBatteryTemperatureLevel(BatteryTemperatureLevel btl) { + this->temperature_level = btl; + this->UpdateSelectedRule(); + } + + void SetBatteryAverageVCell(int avg) { + this->avg_v_cell = avg; + this->UpdateSelectedRule(); + } + + void SetBatteryOpenCircuitVoltage(int ocv) { + this->open_circuit_voltage = ocv; + this->UpdateSelectedRule(); + } + + void SetBatteryDoneCurrent(int current) { + this->battery_done_current = current; + this->has_battery_done_current = true; + this->UpdateSelectedRule(); + } + + void SetPowerState(PowerState ps) { + this->power_state = ps; + this->UpdateSelectedRule(); + } + + int GetChargeVoltageLimit() const { + return this->charge_voltage_limit; + } + + bool IsBatteryDoneCurrentAcceptable(int current) const { + const auto *rule = this->GetSelectedRule(); + AMS_ASSERT(rule != nullptr); + + return IsInRange(0, rule->min_battery_done_current, rule->max_battery_done_current); + } + + const ChargeParametersRule *GetSelectedRule() const { + return this->selected_rule; + } + + void UpdateSelectedRule() { + /* Try to find an entry that fits our current requirements. */ + const ChargeParametersRule *best_rule = nullptr; + for (size_t i = 0; i < this->num_rules; ++i) { + /* Get the current rule. */ + const ChargeParametersRule &cur_rule = this->rules[i]; + + /* Check the temperature level. */ + if (this->temperature_level != cur_rule.temperature_level) { + continue; + } + + /* Check that average voltage is in range. */ + if (!IsInRange(this->avg_v_cell, cur_rule.min_avg_v_cell, cur_rule.max_avg_v_cell)) { + continue; + } + + /* Check that open circuit voltage is in range. */ + if (!IsInRange(this->open_circuit_voltage, cur_rule.min_open_circuit_voltage, cur_rule.max_open_circuit_voltage)) { + continue; + } + + /* Check if our power state is acceptable. */ + if (!this->IsAcceptablePowerState(cur_rule.acceptable_power_states, cur_rule.num_acceptable_power_states)) { + continue; + } + + /* The limit is probably acceptable. */ + if (this->selected_rule != std::addressof(cur_rule)) { + /* We're selecting a new rule. Check if our need to deal with battery current is acceptable. */ + if (cur_rule.check_battery_current && this->check_battery_done_current) { + continue; + } + + /* Set whether we need to check the battery done current. */ + this->has_battery_done_current = false; + this->check_battery_done_current |= cur_rule.check_battery_current; + } else { + /* We're selecting the currently selected rule. Make sure the battery done current is acceptable if we have one. */ + if (this->has_battery_done_current && !IsInRange(this->battery_done_current, cur_rule.min_battery_done_current, cur_rule.max_battery_done_current)) { + continue; + } + } + + /* Select the current rule. */ + best_rule = std::addressof(cur_rule); + break; + } + + /* Update our selected rule. */ + this->selected_rule = best_rule; + } + }; + +} \ No newline at end of file diff --git a/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.hpp b/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.hpp new file mode 100644 index 00000000..ed517587 --- /dev/null +++ b/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.hpp @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include + +namespace ams::powctl::driver::impl { + + struct ChargeParametersRule { + BatteryTemperatureLevel temperature_level; + int min_avg_v_cell; + int max_avg_v_cell; + int min_open_circuit_voltage; + int max_open_circuit_voltage; + int min_battery_done_current; + int max_battery_done_current; + const PowerState *acceptable_power_states; + size_t num_acceptable_power_states; + bool check_battery_current; + bool reinitialize_charger; + int charge_voltage_limit; + int fast_charge_current_limit; + int battery_compensation; + int voltage_clamp; + }; + + struct UnknownParameterX { + int _00; + int _04; + double _08; + double _10; + }; + + struct ChargeParameters { + int temp_min; + int temp_low; + int temp_high; + int temp_max; + int low_voltage_fast_charge_current_limit; + int default_charge_voltage_limit; + const UnknownParameterX *unknown_x_table; + size_t x_table_size; + double _28; + double _30; + const ChargeParametersRule *rules; + size_t num_rules; + }; + + const ChargeParameters &GetChargeParameters(); + +} diff --git a/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_select_charger_parameters.hpp b/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_select_charger_parameters.hpp new file mode 100644 index 00000000..80ba5263 --- /dev/null +++ b/libstratosphere/include/stratosphere/powctl/driver/impl/powctl_select_charger_parameters.hpp @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include + +#if defined(ATMOSPHERE_BOARD_NINTENDO_NX) + + #include + +#else + #error "unknown board for powctl::driver::impl::ChargerParameters" +#endif \ No newline at end of file diff --git a/libstratosphere/include/stratosphere/powctl/impl/powctl_battery_charge_percentage.hpp b/libstratosphere/include/stratosphere/powctl/impl/powctl_battery_charge_percentage.hpp new file mode 100644 index 00000000..0ca9951e --- /dev/null +++ b/libstratosphere/include/stratosphere/powctl/impl/powctl_battery_charge_percentage.hpp @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include +#include + +namespace ams::powctl::impl { + + constexpr inline const double MinRawDefaultPercentage = 3.0; + constexpr inline const double MaxRawDefaultPercentage = 99.0; + + constexpr inline const double MinRawThresholdPercentage = 11.0; + + constexpr inline const int MinDisplayPercentage = 1; + constexpr inline const int MaxDisplayPercentage = 100; + + constexpr inline void CalculateMarginatedRawPercentage(double *out_marginated_min, double *out_marginated_max, double min, double max) { + /* Ensure minimum is in correct range. */ + min = std::max(std::min(min, MinRawThresholdPercentage), MinRawDefaultPercentage); + + /* Calculate the marginated values. */ + constexpr const double MinMarginPercentage = 0.93359375; + constexpr const double MaxMarginPercentage = -0.83593750; + + const auto margin_factor = (max - min) / (MaxRawDefaultPercentage - MinRawDefaultPercentage); + *out_marginated_min = min + MinMarginPercentage * margin_factor; + *out_marginated_max = max + MaxMarginPercentage * margin_factor; + } + + constexpr inline int GetDisplayPercentage(double raw_percentage, double min, double max) { + /* Calculate the display percentage. */ + constexpr const double BaseDisplayPercentage = 2.0; + const auto display_percentage = BaseDisplayPercentage + ((static_cast(MaxDisplayPercentage - MinDisplayPercentage) * (raw_percentage - min)) / (max - min)); + + /* Clamp the display percentage within bounds. */ + return std::max(std::min(static_cast(display_percentage), MaxDisplayPercentage), MinDisplayPercentage); + } + + constexpr inline int ConvertBatteryChargePercentage(double raw_percentage, double min, double max) { + /* Marginate the min/max. */ + double marginated_min = 0.0, marginated_max = 0.0; + CalculateMarginatedRawPercentage(std::addressof(marginated_min), std::addressof(marginated_max), min, max); + + /* Convert to display percentage. */ + return GetDisplayPercentage(raw_percentage, marginated_min, marginated_max); + } + + constexpr inline int ConvertBatteryChargePercentage(double raw_percentage) { + return ConvertBatteryChargePercentage(raw_percentage, MinRawDefaultPercentage, MaxRawDefaultPercentage); + } + +} diff --git a/libstratosphere/include/stratosphere/powctl/powctl_battery_api.hpp b/libstratosphere/include/stratosphere/powctl/powctl_battery_api.hpp index 1b74f6fb..60dd0788 100644 --- a/libstratosphere/include/stratosphere/powctl/powctl_battery_api.hpp +++ b/libstratosphere/include/stratosphere/powctl/powctl_battery_api.hpp @@ -25,15 +25,15 @@ namespace ams::powctl { Result GetBatterySocVf(float *out_percent, Session &session); - Result GetBatteryFullCapacity(u32 *out_mah, Session &session); - Result GetBatteryRemainingCapacity(u32 *out_mah, Session &session); + Result GetBatteryFullCapacity(int *out_mah, Session &session); + Result GetBatteryRemainingCapacity(int *out_mah, Session &session); Result SetBatteryPercentageMinimumAlertThreshold(Session &session, float percentage); Result SetBatteryPercentageMaximumAlertThreshold(Session &session, float percentage); Result SetBatteryPercentageFullThreshold(Session &session, float percentage); - Result GetBatteryAverageCurrent(u32 *out_ma, Session &session); - Result GetBatteryCurrent(u32 *out_ma, Session &session); + Result GetBatteryAverageCurrent(int *out_ma, Session &session); + Result GetBatteryCurrent(int *out_ma, Session &session); Result GetBatteryInternalState(void *dst, size_t *out_size, Session &session, size_t dst_size); Result SetBatteryInternalState(Session &session, const void *src, size_t src_size); @@ -44,10 +44,10 @@ namespace ams::powctl { Result IsBatteryI2cShutdownEnabled(bool *out, Session &session); Result SetBatteryI2cShutdownEnabled(Session &session, bool en); - Result IsBatteryRemoved(bool *out, Session &session); + Result IsBatteryPresent(bool *out, Session &session); - Result GetBatteryCycles(u32 *out, Session &session); - Result SetBatteryCycles(Session &session, u32 cycles); + Result GetBatteryCycles(int *out, Session &session); + Result SetBatteryCycles(Session &session, int cycles); Result GetBatteryAge(float *out_percent, Session &session); @@ -57,14 +57,14 @@ namespace ams::powctl { Result SetBatteryTemperatureMinimumAlertThreshold(Session &session, float c); Result SetBatteryTemperatureMaximumAlertThreshold(Session &session, float c); - Result GetBatteryVCell(u32 *out_mv, Session &session); - Result GetBatteryAverageVCell(u32 *out_mv, Session &session); + Result GetBatteryVCell(int *out_mv, Session &session); + Result GetBatteryAverageVCell(int *out_mv, Session &session); Result GetBatteryAverageVCellTime(TimeSpan *out, Session &session); - Result GetBatteryOpenCircuitVoltage(u32 *out_mv, Session &session); + Result GetBatteryOpenCircuitVoltage(int *out_mv, Session &session); - Result SetBatteryVoltageMinimumAlertThreshold(Session &session, u32 mv); - Result SetBatteryVoltageMaximumAlertThreshold(Session &session, u32 mv); + Result SetBatteryVoltageMinimumAlertThreshold(Session &session, int mv); + Result SetBatteryVoltageMaximumAlertThreshold(Session &session, int mv); } diff --git a/libstratosphere/include/stratosphere/powctl/powctl_charger_api.hpp b/libstratosphere/include/stratosphere/powctl/powctl_charger_api.hpp index acc6c106..c7a53068 100644 --- a/libstratosphere/include/stratosphere/powctl/powctl_charger_api.hpp +++ b/libstratosphere/include/stratosphere/powctl/powctl_charger_api.hpp @@ -24,22 +24,22 @@ namespace ams::powctl { Result GetChargerChargeCurrentState(ChargeCurrentState *out, Session &session); Result SetChargerChargeCurrentState(Session &session, ChargeCurrentState state); - Result GetChargerFastChargeCurrentLimit(u32 *out_ma, Session &session); - Result SetChargerFastChargeCurrentLimit(Session &session, u32 ma); + Result GetChargerFastChargeCurrentLimit(int *out_ma, Session &session); + Result SetChargerFastChargeCurrentLimit(Session &session, int ma); - Result GetChargerChargeVoltageLimit(u32 *out_mv, Session &session); - Result SetChargerChargeVoltageLimit(Session &session, u32 mv); + Result GetChargerChargeVoltageLimit(int *out_mv, Session &session); + Result SetChargerChargeVoltageLimit(Session &session, int mv); Result SetChargerChargerConfiguration(Session &session, ChargerConfiguration cfg); Result IsChargerHiZEnabled(bool *out, Session &session); Result SetChargerHiZEnabled(Session &session, bool en); - Result GetChargerInputCurrentLimit(u32 *out_ma, Session &session); - Result SetChargerInputCurrentLimit(Session &session, u32 ma); + Result GetChargerInputCurrentLimit(int *out_ma, Session &session); + Result SetChargerInputCurrentLimit(Session &session, int ma); - Result GetChargerInputVoltageLimit(u32 *out_mv, Session &session); - Result SetChargerInputVoltageLimit(Session &session, u32 mv); + Result GetChargerInputVoltageLimit(int *out_mv, Session &session); + Result SetChargerInputVoltageLimit(Session &session, int mv); Result GetChargerChargerStatus(ChargerStatus *out, Session &session); @@ -49,10 +49,10 @@ namespace ams::powctl { Result SetChargerWatchdogTimerTimeout(Session &session, TimeSpan timeout); Result ResetChargerWatchdogTimer(Session &session); - Result GetChargerBatteryCompensation(u32 *out_mo, Session &session); - Result SetChargerBatteryCompensation(Session &session, u32 mo); + Result GetChargerBatteryCompensation(int *out_mo, Session &session); + Result SetChargerBatteryCompensation(Session &session, int mo); - Result GetChargerVoltageClamp(u32 *out_mv, Session &session); - Result SetChargerVoltageClamp(Session &session, u32 mv); + Result GetChargerVoltageClamp(int *out_mv, Session &session); + Result SetChargerVoltageClamp(Session &session, int mv); } diff --git a/libstratosphere/include/stratosphere/powctl/powctl_types.hpp b/libstratosphere/include/stratosphere/powctl/powctl_types.hpp index 3a3538bb..ae65dbe1 100644 --- a/libstratosphere/include/stratosphere/powctl/powctl_types.hpp +++ b/libstratosphere/include/stratosphere/powctl/powctl_types.hpp @@ -27,9 +27,9 @@ namespace ams::powctl { }; enum ChargerConfiguration { - ChargerConfiguration_ChargeDisable = 0, - ChargerConfiguration_ChargeBattery = 1, - ChargerConfiguration_Otg = 2, + ChargerConfiguration_ChargeDisable = 1, + ChargerConfiguration_ChargeBattery = 2, + ChargerConfiguration_Otg = 3, }; enum ChargeCurrentState { @@ -38,4 +38,20 @@ namespace ams::powctl { ChargeCurrentState_Charging = 0x3, }; + enum class BatteryTemperatureLevel { + TooLow = 0, + Low = 1, + Medium = 2, + High = 3, + TooHigh = 4, + }; + + enum class PowerState { + FullAwake = 0, + MinimumAwake = 1, + SleepCharge = 2, + SleepDischarge = 3, + ShutdownChargeMain = 4, + }; + } \ No newline at end of file diff --git a/libstratosphere/include/stratosphere/spl/spl_types.hpp b/libstratosphere/include/stratosphere/spl/spl_types.hpp index 6232c3ee..1225cd6e 100644 --- a/libstratosphere/include/stratosphere/spl/spl_types.hpp +++ b/libstratosphere/include/stratosphere/spl/spl_types.hpp @@ -150,6 +150,15 @@ namespace ams::spl { }; }; static_assert(sizeof(BootReasonValue) == sizeof(u32), "BootReasonValue definition!"); + + enum BootReason { + BootReason_Unknown = 0, + BootReason_AcOk = 1, + BootReason_OnKey = 2, + BootReason_RtcAlarm1 = 3, + BootReason_RtcAlarm2 = 4, + }; + #pragma pack(push, 1) struct AesKey { diff --git a/libstratosphere/source/cal/cal_battery_api.cpp b/libstratosphere/source/cal/cal_battery_api.cpp new file mode 100644 index 00000000..3de3dce6 --- /dev/null +++ b/libstratosphere/source/cal/cal_battery_api.cpp @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#include +#include "cal_fs_utils.hpp" + +namespace ams::cal { + + namespace { + + constexpr inline s64 BatteryLotOffset = 0x2CE0; + constexpr inline size_t BatteryLotSize = 0x20; + + constexpr inline s64 BatteryVersionOffset = 0x4310; + constexpr inline size_t BatteryVersionSize = 0x10; + + constexpr inline size_t BatteryVendorSizeMax = 0x18; + + } + + Result GetBatteryVersion(u8 *out) { + /* Read the battery version. */ + u8 battery_version[BatteryVersionSize]; + R_TRY(cal::impl::ReadCalibrationBlock(BatteryVersionOffset, battery_version, sizeof(battery_version))); + + /* Write the output. */ + *out = battery_version[0]; + return ResultSuccess(); + } + + Result GetBatteryVendor(size_t *out_vendor_size, void *dst, size_t dst_size) { + /* Read the battery lot. */ + char battery_lot[BatteryLotSize]; + R_TRY(cal::impl::ReadCalibrationBlock(BatteryLotOffset, battery_lot, sizeof(battery_lot))); + + /* Copy output. */ + *out_vendor_size = static_cast(util::Strlcpy(static_cast(dst), battery_lot, std::min(dst_size, BatteryVendorSizeMax))); + return ResultSuccess(); + } + +} diff --git a/libstratosphere/source/cal/cal_crc_utils.cpp b/libstratosphere/source/cal/cal_crc_utils.cpp new file mode 100644 index 00000000..811aa37d --- /dev/null +++ b/libstratosphere/source/cal/cal_crc_utils.cpp @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#include +#include "cal_crc_utils.hpp" + +namespace ams::cal::impl { + + namespace { + + constexpr inline const u16 CrcTable[0x10] = { + 0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401, + 0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400 + }; + + } + + u16 CalculateCrc16(const void *data, size_t size) { + AMS_ASSERT(data != nullptr); + + u16 crc = 0x55AA; + const u8 *data_u8 = static_cast(data); + for (size_t i = 0; i < size; ++i) { + crc = (crc >> 4) ^ (CrcTable[crc & 0xF]) ^ (CrcTable[(data_u8[i] >> 0) & 0xF]); + crc = (crc >> 4) ^ (CrcTable[crc & 0xF]) ^ (CrcTable[(data_u8[i] >> 4) & 0xF]); + } + + return crc; + } + + Result ValidateCalibrationCrc(const void *data, size_t size) { + AMS_ASSERT(data != nullptr); + AMS_ASSERT(size >= sizeof(u16)); + + const u16 crc = *reinterpret_cast(reinterpret_cast(data) + size - sizeof(u16)); + R_UNLESS(CalculateCrc16(data, size - sizeof(u16)) == crc, cal::ResultCalibrationDataCrcError()); + + return ResultSuccess(); + } + +} diff --git a/libstratosphere/source/cal/cal_crc_utils.hpp b/libstratosphere/source/cal/cal_crc_utils.hpp new file mode 100644 index 00000000..2e2c4f85 --- /dev/null +++ b/libstratosphere/source/cal/cal_crc_utils.hpp @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include + +namespace ams::cal::impl { + + u16 CalculateCrc16(const void *data, size_t size); + Result ValidateCalibrationCrc(const void *data, size_t size); + +} diff --git a/libstratosphere/source/cal/cal_fs_utils.cpp b/libstratosphere/source/cal/cal_fs_utils.cpp new file mode 100644 index 00000000..70e58bcb --- /dev/null +++ b/libstratosphere/source/cal/cal_fs_utils.cpp @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#include +#include "cal_crc_utils.hpp" +#include "cal_fs_utils.hpp" + +namespace ams::cal::impl { + + Result ReadCalibrationBlock(s64 offset, void *dst, size_t block_size) { + /* Open the calibration binary partition. */ + std::unique_ptr storage; + R_TRY(fs::OpenBisPartition(std::addressof(storage), fs::BisPartitionId::CalibrationBinary)); + + /* Read data from the partition. */ + R_TRY(storage->Read(offset, dst, block_size)); + + /* Validate the crc. */ + R_TRY(ValidateCalibrationCrc(dst, block_size)); + + return ResultSuccess(); + } + +} diff --git a/libstratosphere/source/cal/cal_fs_utils.hpp b/libstratosphere/source/cal/cal_fs_utils.hpp new file mode 100644 index 00000000..2bea0fe4 --- /dev/null +++ b/libstratosphere/source/cal/cal_fs_utils.hpp @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#pragma once +#include + +namespace ams::cal::impl { + + Result ReadCalibrationBlock(s64 offset, void *dst, size_t block_size); + +} diff --git a/libstratosphere/source/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.cpp b/libstratosphere/source/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.cpp new file mode 100644 index 00000000..aa49183b --- /dev/null +++ b/libstratosphere/source/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +#include + +namespace ams::powctl::driver::impl { + + namespace { + + constexpr inline const PowerState AcceptablePowerStates[] = { + PowerState::FullAwake, + PowerState::MinimumAwake, + PowerState::SleepCharge, + PowerState::SleepDischarge, + PowerState::ShutdownChargeMain, + }; + + constexpr inline const PowerState AcceptablePowerStatesForNotAwakeCharge[] = { + PowerState::SleepCharge, + PowerState::ShutdownChargeMain, + }; + + constexpr inline const int Min = std::numeric_limits::min(); + constexpr inline const int Max = std::numeric_limits::max(); + + constexpr inline const UnknownParameterX UnknownXTableForBatteryVersion2[] = { + { 20000, 4320, 95.0, 100.4 }, + { 30000, 4304, 94.0, 99.7 }, + { 40000, 4288, 93.0, 98.4 }, + { 50000, 4272, 92.0, 97.0 }, + { 60000, 4256, 90.0, 95.7 }, + { 80000, 4240, 89.0, 94.2 }, + { 100000, 4224, 88.0, 93.0 }, + { Max, 4192, 85.0, 90.0 }, + }; + + /* Include automatically extracted charger parameters. */ + #include "powctl_charger_parameters.board.nintendo_nx.inc" + + } + + const ChargeParameters &GetChargeParameters() { + /* Get the battery version. */ + u8 battery_version; + if (R_FAILED(cal::GetBatteryVersion(std::addressof(battery_version)))) { + battery_version = 0; + } + + if (battery_version == 2) { + return ChargeParametersForBatteryVersion2; + } else if (battery_version == 1) { + return ChargeParametersForBatteryVersion1; + } else { + if (spl::GetHardwareType() == spl::HardwareType::_Five_) { + return ChargeParametersForBatteryVersion0ForFive; + } else { + return ChargeParametersForBatteryVersion0; + } + } + } + +} \ No newline at end of file diff --git a/libstratosphere/source/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.inc b/libstratosphere/source/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.inc new file mode 100644 index 00000000..70f86ac0 --- /dev/null +++ b/libstratosphere/source/powctl/driver/impl/powctl_charger_parameters.board.nintendo_nx.inc @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2018-2020 Atmosphère-NX + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* NOTE: This file is auto-generated by charger_parameters.py, do not edit manually. */ + +constexpr inline const ChargeParametersRule ChargeParametersRulesForBatteryVersion0[] = { + { BatteryTemperatureLevel::TooLow, Min, 3320, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 512, 0, 0 }, + { BatteryTemperatureLevel::TooLow, 3320, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 768, 0, 0 }, + { BatteryTemperatureLevel::Low, Min, 3320, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4208, 512, 0, 0 }, + { BatteryTemperatureLevel::Low, 3320, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4208, 768, 0, 0 }, + { BatteryTemperatureLevel::Medium, Min, 3320, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4208, 512, 0, 0 }, + { BatteryTemperatureLevel::Medium, 3320, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4208, 2048, 0, 0 }, + { BatteryTemperatureLevel::High, Min, 3320, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 3952, 512, 0, 0 }, + { BatteryTemperatureLevel::High, 3320, 4050, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 3952, 2048, 0, 0 }, + { BatteryTemperatureLevel::High, 4050, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 2048, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, Min, 3320, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 3952, 512, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, 3320, 4050, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 3952, 2048, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, 4050, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 2048, 0, 0 }, +}; + +constexpr inline const ChargeParametersRule ChargeParametersRulesForBatteryVersion1[] = { + { BatteryTemperatureLevel::TooLow, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 576, 0, 0 }, + { BatteryTemperatureLevel::Low, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4208, 576, 0, 0 }, + { BatteryTemperatureLevel::Medium, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4208, 1536, 0, 0 }, + { BatteryTemperatureLevel::High, Min, 3984, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 3984, 1536, 0, 0 }, + { BatteryTemperatureLevel::High, 3984, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 1536, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, Min, 3984, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 3984, 1536, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, 3984, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 1536, 0, 0 }, +}; + +constexpr inline const ChargeParametersRule ChargeParametersRulesForBatteryVersion2[] = { + { BatteryTemperatureLevel::TooLow, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4320, 640, 0, 0 }, + { BatteryTemperatureLevel::Low, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4320, 640, 0, 0 }, + { BatteryTemperatureLevel::Medium, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4320, 1664, 0, 0 }, + { BatteryTemperatureLevel::High, Min, 4080, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4080, 1664, 0, 0 }, + { BatteryTemperatureLevel::High, 4080, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4320, 1664, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, Min, 4080, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4080, 1664, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, 4080, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4320, 1664, 0, 0 }, +}; + +constexpr inline const ChargeParametersRule ChargeParametersRulesForBatteryVersion0ForFive[] = { + { BatteryTemperatureLevel::TooLow, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 768, 0, 0 }, + { BatteryTemperatureLevel::Low, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4208, 768, 0, 0 }, + { BatteryTemperatureLevel::Medium, Min, Max, Min, 4001, 2049, Max, AcceptablePowerStatesForNotAwakeCharge, util::size(AcceptablePowerStatesForNotAwakeCharge), true, true, 4000, 3072, 40, 112 }, + { BatteryTemperatureLevel::Medium, Min, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 4208, 2048, 0, 0 }, + { BatteryTemperatureLevel::High, Min, 4050, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, true, 3952, 2048, 0, 0 }, + { BatteryTemperatureLevel::High, 4050, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 2048, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, Min, 4050, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 3952, 2048, 0, 0 }, + { BatteryTemperatureLevel::TooHigh, 4050, Max, Min, Max, Min, Max, AcceptablePowerStates, util::size(AcceptablePowerStates), false, false, 4208, 2048, 0, 0 }, +}; + +constexpr inline const ChargeParameters ChargeParametersForBatteryVersion0 = { + 4, 17, 51, 60, 512, 4208, nullptr, 0, 95.0, 99.0, ChargeParametersRulesForBatteryVersion0, util::size(ChargeParametersRulesForBatteryVersion0) +}; + +constexpr inline const ChargeParameters ChargeParametersForBatteryVersion1 = { + 1, 19, 48, 59, 1536, 4208, nullptr, 0, 95.0, 99.0, ChargeParametersRulesForBatteryVersion1, util::size(ChargeParametersRulesForBatteryVersion1) +}; + +constexpr inline const ChargeParameters ChargeParametersForBatteryVersion2 = { + 1, 19, 48, 59, 1664, 4320, UnknownXTableForBatteryVersion2, util::size(UnknownXTableForBatteryVersion2), 95.0, 100.4, ChargeParametersRulesForBatteryVersion2, util::size(ChargeParametersRulesForBatteryVersion2) +}; + +constexpr inline const ChargeParameters ChargeParametersForBatteryVersion0ForFive = { + 4, 17, 51, 60, 512, 4208, nullptr, 0, 95.0, 99.0, ChargeParametersRulesForBatteryVersion0ForFive, util::size(ChargeParametersRulesForBatteryVersion0ForFive) +}; diff --git a/libstratosphere/source/powctl/impl/powctl_charger_driver.hpp b/libstratosphere/source/powctl/impl/powctl_charger_driver.hpp deleted file mode 100644 index c9a31a70..00000000 --- a/libstratosphere/source/powctl/impl/powctl_charger_driver.hpp +++ /dev/null @@ -1,136 +0,0 @@ -/* - * Copyright (c) 2018-2020 Atmosphère-NX - * - * This program is free software; you can redistribute it and/or modify it - * under the terms and conditions of the GNU General Public License, - * version 2, as published by the Free Software Foundation. - * - * This program is distributed in the hope it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ -#pragma once -#include - -namespace ams::powctl::impl { - - class IDevice : public ::ams::ddsf::IDevice { - NON_COPYABLE(IDevice); - NON_MOVEABLE(IDevice); - AMS_DDSF_CASTABLE_TRAITS(ams::powctl::impl::IDevice, ::ams::ddsf::IDevice); - public: - IDevice() : ddsf::IDevice(false) { /* ... */ } - virtual ~IDevice() { /* ... */ } - }; - - class IPowerControlDriver : public ::ams::ddsf::IDriver { - NON_COPYABLE(IPowerControlDriver); - NON_MOVEABLE(IPowerControlDriver); - AMS_DDSF_CASTABLE_TRAITS(ams::powctl::impl::IPowerControlDriver, ::ams::ddsf::IDriver); - private: - bool event_handler_enabled; - protected: - constexpr bool IsEventHandlerEnabled() const { - return this->event_handler_enabled; - } - public: - IPowerControlDriver(bool ev) : IDriver(), event_handler_enabled(ev) { /* ... */ } - virtual ~IPowerControlDriver() { /* ... */ } - - virtual void InitializeDriver() = 0; - virtual void FinalizeDriver() = 0; - - virtual Result GetDeviceSystemEvent(IDevice *device) = 0; - virtual Result SetDeviceInterruptEnabled(IDevice *device, bool enable) = 0; - - /* TODO: Eventually implement proper error status enum? */ - virtual Result GetDeviceErrorStatus(u32 *out, IDevice *device) = 0; - virtual Result SetDeviceErrorStatus(IDevice *device, u32 status) = 0; - - virtual Result GetBatterySocRep(float *out_percent, IDevice *device) = 0; - - virtual Result GetBatterySocVf(float *out_percent, IDevice *device) = 0; - - virtual Result GetBatteryFullCapacity(u32 *out_mah, IDevice *device) = 0; - virtual Result GetBatteryRemainingCapacity(u32 *out_mah, IDevice *device) = 0; - - virtual Result SetBatteryPercentageMinimumAlertThreshold(IDevice *device, float percentage) = 0; - virtual Result SetBatteryPercentageMaximumAlertThreshold(IDevice *device, float percentage) = 0; - virtual Result SetBatteryPercentageFullThreshold(IDevice *device, float percentage) = 0; - - virtual Result GetChargerChargeCurrentState(ChargeCurrentState *out, IDevice *device) = 0; - virtual Result SetChargerChargeCurrentState(IDevice *device, ChargeCurrentState state) = 0; - - virtual Result GetChargerFastChargeCurrentLimit(u32 *out_ma, IDevice *device) = 0; - virtual Result SetChargerFastChargeCurrentLimit(IDevice *device, u32 ma) = 0; - - virtual Result GetChargerChargeVoltageLimit(u32 *out_mv, IDevice *device) = 0; - virtual Result SetChargerChargeVoltageLimit(IDevice *device, u32 mv) = 0; - - virtual Result SetChargerChargerConfiguration(IDevice *device, ChargerConfiguration cfg) = 0; - - virtual Result IsChargerHiZEnabled(bool *out, IDevice *device) = 0; - virtual Result SetChargerHiZEnabled(IDevice *device, bool en) = 0; - - virtual Result GetBatteryAverageCurrent(u32 *out_ma, IDevice *device) = 0; - virtual Result GetBatteryCurrent(u32 *out_ma, IDevice *device) = 0; - - virtual Result GetChargerInputCurrentLimit(u32 *out_ma, IDevice *device) = 0; - virtual Result SetChargerInputCurrentLimit(IDevice *device, u32 ma) = 0; - - virtual Result GetChargerInputVoltageLimit(u32 *out_mv, IDevice *device) = 0; - virtual Result SetChargerInputVoltageLimit(IDevice *device, u32 mv) = 0; - - virtual Result GetBatteryInternalState(void *dst, size_t *out_size, IDevice *device, size_t dst_size) = 0; - virtual Result SetBatteryInternalState(IDevice *device, const void *src, size_t src_size) = 0; - - virtual Result GetBatteryNeedToRestoreParameters(bool *out, IDevice *device) = 0; - virtual Result SetBatteryNeedToRestoreParameters(IDevice *device, bool en) = 0; - - virtual Result IsBatteryI2cShutdownEnabled(bool *out, IDevice *device) = 0; - virtual Result SetBatteryI2cShutdownEnabled(IDevice *device, bool en) = 0; - - virtual Result IsBatteryRemoved(bool *out, IDevice *device) = 0; - - virtual Result GetChargerChargerStatus(ChargerStatus *out, IDevice *device) = 0; - - virtual Result GetBatteryCycles(u32 *out, IDevice *device) = 0; - virtual Result SetBatteryCycles(IDevice *device, u32 cycles) = 0; - - virtual Result GetBatteryAge(float *out_percent, IDevice *device) = 0; - - virtual Result GetBatteryTemperature(float *out_c, IDevice *device) = 0; - virtual Result GetBatteryMaximumTemperature(float *out_c, IDevice *device) = 0; - - virtual Result SetBatteryTemperatureMinimumAlertThreshold(IDevice *device, float c) = 0; - virtual Result SetBatteryTemperatureMaximumAlertThreshold(IDevice *device, float c) = 0; - - virtual Result GetBatteryVCell(u32 *out_mv, IDevice *device) = 0; - virtual Result GetBatteryAverageVCell(u32 *out_mv, IDevice *device) = 0; - - virtual Result GetBatteryAverageVCellTime(TimeSpan *out, IDevice *device) = 0; - - virtual Result SetBatteryVoltageMinimumAlertThreshold(IDevice *device, u32 mv) = 0; - - virtual Result GetBatteryOpenCircuitVoltage(u32 *out_mv, IDevice *device) = 0; - - virtual Result SetBatteryVoltageMaximumAlertThreshold(IDevice *device, u32 mv) = 0; - - virtual Result IsChargerWatchdogTimerEnabled(bool *out, IDevice *device) = 0; - virtual Result SetChargerWatchdogTimerEnabled(IDevice *device, bool en) = 0; - - virtual Result SetChargerWatchdogTimerTimeout(IDevice *device, TimeSpan timeout) = 0; - virtual Result ResetChargerWatchdogTimer(IDevice *device) = 0; - - virtual Result GetChargerBatteryCompensation(u32 *out_mo, IDevice *device) = 0; - virtual Result SetChargerBatteryCompensation(IDevice *device, u32 mo) = 0; - - virtual Result GetChargerVoltageClamp(u32 *out_mv, IDevice *device) = 0; - virtual Result SetChargerVoltageClamp(IDevice *device, u32 mv) = 0; - }; - -} diff --git a/libstratosphere/source/powctl/impl/powctl_i_power_control_driver.hpp b/libstratosphere/source/powctl/impl/powctl_i_power_control_driver.hpp index c9a31a70..fc4e1ee5 100644 --- a/libstratosphere/source/powctl/impl/powctl_i_power_control_driver.hpp +++ b/libstratosphere/source/powctl/impl/powctl_i_power_control_driver.hpp @@ -55,8 +55,8 @@ namespace ams::powctl::impl { virtual Result GetBatterySocVf(float *out_percent, IDevice *device) = 0; - virtual Result GetBatteryFullCapacity(u32 *out_mah, IDevice *device) = 0; - virtual Result GetBatteryRemainingCapacity(u32 *out_mah, IDevice *device) = 0; + virtual Result GetBatteryFullCapacity(int *out_mah, IDevice *device) = 0; + virtual Result GetBatteryRemainingCapacity(int *out_mah, IDevice *device) = 0; virtual Result SetBatteryPercentageMinimumAlertThreshold(IDevice *device, float percentage) = 0; virtual Result SetBatteryPercentageMaximumAlertThreshold(IDevice *device, float percentage) = 0; @@ -65,25 +65,25 @@ namespace ams::powctl::impl { virtual Result GetChargerChargeCurrentState(ChargeCurrentState *out, IDevice *device) = 0; virtual Result SetChargerChargeCurrentState(IDevice *device, ChargeCurrentState state) = 0; - virtual Result GetChargerFastChargeCurrentLimit(u32 *out_ma, IDevice *device) = 0; - virtual Result SetChargerFastChargeCurrentLimit(IDevice *device, u32 ma) = 0; + virtual Result GetChargerFastChargeCurrentLimit(int *out_ma, IDevice *device) = 0; + virtual Result SetChargerFastChargeCurrentLimit(IDevice *device, int ma) = 0; - virtual Result GetChargerChargeVoltageLimit(u32 *out_mv, IDevice *device) = 0; - virtual Result SetChargerChargeVoltageLimit(IDevice *device, u32 mv) = 0; + virtual Result GetChargerChargeVoltageLimit(int *out_mv, IDevice *device) = 0; + virtual Result SetChargerChargeVoltageLimit(IDevice *device, int mv) = 0; virtual Result SetChargerChargerConfiguration(IDevice *device, ChargerConfiguration cfg) = 0; virtual Result IsChargerHiZEnabled(bool *out, IDevice *device) = 0; virtual Result SetChargerHiZEnabled(IDevice *device, bool en) = 0; - virtual Result GetBatteryAverageCurrent(u32 *out_ma, IDevice *device) = 0; - virtual Result GetBatteryCurrent(u32 *out_ma, IDevice *device) = 0; + virtual Result GetBatteryAverageCurrent(int *out_ma, IDevice *device) = 0; + virtual Result GetBatteryCurrent(int *out_ma, IDevice *device) = 0; - virtual Result GetChargerInputCurrentLimit(u32 *out_ma, IDevice *device) = 0; - virtual Result SetChargerInputCurrentLimit(IDevice *device, u32 ma) = 0; + virtual Result GetChargerInputCurrentLimit(int *out_ma, IDevice *device) = 0; + virtual Result SetChargerInputCurrentLimit(IDevice *device, int ma) = 0; - virtual Result GetChargerInputVoltageLimit(u32 *out_mv, IDevice *device) = 0; - virtual Result SetChargerInputVoltageLimit(IDevice *device, u32 mv) = 0; + virtual Result GetChargerInputVoltageLimit(int *out_mv, IDevice *device) = 0; + virtual Result SetChargerInputVoltageLimit(IDevice *device, int mv) = 0; virtual Result GetBatteryInternalState(void *dst, size_t *out_size, IDevice *device, size_t dst_size) = 0; virtual Result SetBatteryInternalState(IDevice *device, const void *src, size_t src_size) = 0; @@ -94,12 +94,12 @@ namespace ams::powctl::impl { virtual Result IsBatteryI2cShutdownEnabled(bool *out, IDevice *device) = 0; virtual Result SetBatteryI2cShutdownEnabled(IDevice *device, bool en) = 0; - virtual Result IsBatteryRemoved(bool *out, IDevice *device) = 0; + virtual Result IsBatteryPresent(bool *out, IDevice *device) = 0; virtual Result GetChargerChargerStatus(ChargerStatus *out, IDevice *device) = 0; - virtual Result GetBatteryCycles(u32 *out, IDevice *device) = 0; - virtual Result SetBatteryCycles(IDevice *device, u32 cycles) = 0; + virtual Result GetBatteryCycles(int *out, IDevice *device) = 0; + virtual Result SetBatteryCycles(IDevice *device, int cycles) = 0; virtual Result GetBatteryAge(float *out_percent, IDevice *device) = 0; @@ -109,16 +109,16 @@ namespace ams::powctl::impl { virtual Result SetBatteryTemperatureMinimumAlertThreshold(IDevice *device, float c) = 0; virtual Result SetBatteryTemperatureMaximumAlertThreshold(IDevice *device, float c) = 0; - virtual Result GetBatteryVCell(u32 *out_mv, IDevice *device) = 0; - virtual Result GetBatteryAverageVCell(u32 *out_mv, IDevice *device) = 0; + virtual Result GetBatteryVCell(int *out_mv, IDevice *device) = 0; + virtual Result GetBatteryAverageVCell(int *out_mv, IDevice *device) = 0; virtual Result GetBatteryAverageVCellTime(TimeSpan *out, IDevice *device) = 0; - virtual Result SetBatteryVoltageMinimumAlertThreshold(IDevice *device, u32 mv) = 0; + virtual Result SetBatteryVoltageMinimumAlertThreshold(IDevice *device, int mv) = 0; - virtual Result GetBatteryOpenCircuitVoltage(u32 *out_mv, IDevice *device) = 0; + virtual Result GetBatteryOpenCircuitVoltage(int *out_mv, IDevice *device) = 0; - virtual Result SetBatteryVoltageMaximumAlertThreshold(IDevice *device, u32 mv) = 0; + virtual Result SetBatteryVoltageMaximumAlertThreshold(IDevice *device, int mv) = 0; virtual Result IsChargerWatchdogTimerEnabled(bool *out, IDevice *device) = 0; virtual Result SetChargerWatchdogTimerEnabled(IDevice *device, bool en) = 0; @@ -126,11 +126,11 @@ namespace ams::powctl::impl { virtual Result SetChargerWatchdogTimerTimeout(IDevice *device, TimeSpan timeout) = 0; virtual Result ResetChargerWatchdogTimer(IDevice *device) = 0; - virtual Result GetChargerBatteryCompensation(u32 *out_mo, IDevice *device) = 0; - virtual Result SetChargerBatteryCompensation(IDevice *device, u32 mo) = 0; + virtual Result GetChargerBatteryCompensation(int *out_mo, IDevice *device) = 0; + virtual Result SetChargerBatteryCompensation(IDevice *device, int mo) = 0; - virtual Result GetChargerVoltageClamp(u32 *out_mv, IDevice *device) = 0; - virtual Result SetChargerVoltageClamp(IDevice *device, u32 mv) = 0; + virtual Result GetChargerVoltageClamp(int *out_mv, IDevice *device) = 0; + virtual Result SetChargerVoltageClamp(IDevice *device, int mv) = 0; }; } diff --git a/libstratosphere/source/powctl/powctl_battery_api.cpp b/libstratosphere/source/powctl/powctl_battery_api.cpp index ba16bb4a..0be40c08 100644 --- a/libstratosphere/source/powctl/powctl_battery_api.cpp +++ b/libstratosphere/source/powctl/powctl_battery_api.cpp @@ -58,7 +58,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetBatterySocVf(out_percent, std::addressof(device)); } - Result GetBatteryFullCapacity(u32 *out_mah, Session &session) { + Result GetBatteryFullCapacity(int *out_mah, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -72,7 +72,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetBatteryFullCapacity(out_mah, std::addressof(device)); } - Result GetBatteryRemainingCapacity(u32 *out_mah, Session &session) { + Result GetBatteryRemainingCapacity(int *out_mah, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -128,7 +128,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetBatteryPercentageFullThreshold(std::addressof(device), percentage); } - Result GetBatteryAverageCurrent(u32 *out_ma, Session &session) { + Result GetBatteryAverageCurrent(int *out_ma, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -142,7 +142,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetBatteryAverageCurrent(out_ma, std::addressof(device)); } - Result GetBatteryCurrent(u32 *out_ma, Session &session) { + Result GetBatteryCurrent(int *out_ma, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -240,7 +240,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetBatteryI2cShutdownEnabled(std::addressof(device), en); } - Result IsBatteryRemoved(bool *out, Session &session) { + Result IsBatteryPresent(bool *out, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -251,10 +251,10 @@ namespace ams::powctl { auto &device = impl.GetDevice().SafeCastTo(); /* Call into the driver. */ - return device.GetDriver().SafeCastTo().IsBatteryRemoved(out, std::addressof(device)); + return device.GetDriver().SafeCastTo().IsBatteryPresent(out, std::addressof(device)); } - Result GetBatteryCycles(u32 *out, Session &session) { + Result GetBatteryCycles(int *out, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -268,7 +268,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetBatteryCycles(out, std::addressof(device)); } - Result SetBatteryCycles(Session &session, u32 cycles) { + Result SetBatteryCycles(Session &session, int cycles) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -352,7 +352,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetBatteryTemperatureMaximumAlertThreshold(std::addressof(device), c); } - Result GetBatteryVCell(u32 *out_mv, Session &session) { + Result GetBatteryVCell(int *out_mv, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -366,7 +366,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetBatteryVCell(out_mv, std::addressof(device)); } - Result GetBatteryAverageVCell(u32 *out_mv, Session &session) { + Result GetBatteryAverageVCell(int *out_mv, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -394,7 +394,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetBatteryAverageVCellTime(out, std::addressof(device)); } - Result GetBatteryOpenCircuitVoltage(u32 *out_mv, Session &session) { + Result GetBatteryOpenCircuitVoltage(int *out_mv, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -408,7 +408,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetBatteryOpenCircuitVoltage(out_mv, std::addressof(device)); } - Result SetBatteryVoltageMinimumAlertThreshold(Session &session, u32 mv) { + Result SetBatteryVoltageMinimumAlertThreshold(Session &session, int mv) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -422,7 +422,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetBatteryVoltageMinimumAlertThreshold(std::addressof(device), mv); } - Result SetBatteryVoltageMaximumAlertThreshold(Session &session, u32 mv) { + Result SetBatteryVoltageMaximumAlertThreshold(Session &session, int mv) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); diff --git a/libstratosphere/source/powctl/powctl_charger_api.cpp b/libstratosphere/source/powctl/powctl_charger_api.cpp index eb9fbff6..7744c919 100644 --- a/libstratosphere/source/powctl/powctl_charger_api.cpp +++ b/libstratosphere/source/powctl/powctl_charger_api.cpp @@ -58,7 +58,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetChargerChargeCurrentState(std::addressof(device), state); } - Result GetChargerFastChargeCurrentLimit(u32 *out_ma, Session &session) { + Result GetChargerFastChargeCurrentLimit(int *out_ma, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -72,7 +72,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetChargerFastChargeCurrentLimit(out_ma, std::addressof(device)); } - Result SetChargerFastChargeCurrentLimit(Session &session, u32 ma) { + Result SetChargerFastChargeCurrentLimit(Session &session, int ma) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -86,7 +86,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetChargerFastChargeCurrentLimit(std::addressof(device), ma); } - Result GetChargerChargeVoltageLimit(u32 *out_mv, Session &session) { + Result GetChargerChargeVoltageLimit(int *out_mv, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -100,7 +100,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetChargerChargeVoltageLimit(out_mv, std::addressof(device)); } - Result SetChargerChargeVoltageLimit(Session &session, u32 mv) { + Result SetChargerChargeVoltageLimit(Session &session, int mv) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -156,7 +156,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetChargerHiZEnabled(std::addressof(device), en); } - Result GetChargerInputCurrentLimit(u32 *out_ma, Session &session) { + Result GetChargerInputCurrentLimit(int *out_ma, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -170,7 +170,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetChargerInputCurrentLimit(out_ma, std::addressof(device)); } - Result SetChargerInputCurrentLimit(Session &session, u32 ma) { + Result SetChargerInputCurrentLimit(Session &session, int ma) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -184,7 +184,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetChargerInputCurrentLimit(std::addressof(device), ma); } - Result GetChargerInputVoltageLimit(u32 *out_mv, Session &session) { + Result GetChargerInputVoltageLimit(int *out_mv, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -198,7 +198,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetChargerInputVoltageLimit(out_mv, std::addressof(device)); } - Result SetChargerInputVoltageLimit(Session &session, u32 mv) { + Result SetChargerInputVoltageLimit(Session &session, int mv) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -270,7 +270,7 @@ namespace ams::powctl { Result ResetChargerWatchdogTimer(Session &session); - Result GetChargerBatteryCompensation(u32 *out_mo, Session &session) { + Result GetChargerBatteryCompensation(int *out_mo, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -284,7 +284,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetChargerBatteryCompensation(out_mo, std::addressof(device)); } - Result SetChargerBatteryCompensation(Session &session, u32 mo) { + Result SetChargerBatteryCompensation(Session &session, int mo) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -298,7 +298,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().SetChargerBatteryCompensation(std::addressof(device), mo); } - Result GetChargerVoltageClamp(u32 *out_mv, Session &session) { + Result GetChargerVoltageClamp(int *out_mv, Session &session) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session); @@ -312,7 +312,7 @@ namespace ams::powctl { return device.GetDriver().SafeCastTo().GetChargerVoltageClamp(out_mv, std::addressof(device)); } - Result SetChargerVoltageClamp(Session &session, u32 mv) { + Result SetChargerVoltageClamp(Session &session, int mv) { /* Get the session impl. */ auto &impl = GetOpenSessionImpl(session);