318 lines
12 KiB
C++
318 lines
12 KiB
C++
/* --------------------------------------------------------------------------
|
|
* "THE BEER-WARE LICENSE" (Revision 42):
|
|
* <p-sam@d3vs.net>, <natinusala@gmail.com>, <m4x@m4xw.net>
|
|
* wrote this file. As long as you retain this notice you can do whatever you
|
|
* want with this stuff. If you meet any of us some day, and you think this
|
|
* stuff is worth it, you can buy us a beer in return. - The sys-clk authors
|
|
* --------------------------------------------------------------------------
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "../../ipc.h"
|
|
#include "base_menu_gui.h"
|
|
#include <inttypes.h>
|
|
|
|
class MiscGui : public BaseMenuGui
|
|
{
|
|
public:
|
|
MiscGui();
|
|
~MiscGui();
|
|
void preDraw(tsl::gfx::Renderer* render) override;
|
|
void listUI() override;
|
|
void update() override;
|
|
|
|
protected:
|
|
typedef enum {
|
|
PDCtrler_NewPDO = 1, //Received new Power Data Object
|
|
PDCtrler_NoPD = 2, //No Power Delivery source is detected
|
|
PDCtrler_AcceptedRDO = 3 //Received and accepted Request Data Object
|
|
} ChargeInfoPDCtrler; //BM92T series
|
|
|
|
typedef enum {
|
|
PowerRole_Sink = 1,
|
|
PowerRole_Source = 2
|
|
} ChargeInfoPowerRole;
|
|
|
|
constexpr const char* ChargeInfoPowerRoleToStr(ChargeInfoPowerRole in)
|
|
{
|
|
switch (in)
|
|
{
|
|
case PowerRole_Sink: return "Sink";
|
|
case PowerRole_Source: return "Source";
|
|
default: return "Unknown";
|
|
}
|
|
};
|
|
|
|
typedef enum {
|
|
ChargerType_None = 0,
|
|
ChargerType_PD = 1,
|
|
ChargerType_TypeC_1500mA = 2,
|
|
ChargerType_TypeC_3000mA = 3,
|
|
ChargerType_DCP = 4,
|
|
ChargerType_CDP = 5,
|
|
ChargerType_SDP = 6,
|
|
ChargerType_Apple_500mA = 7,
|
|
ChargerType_Apple_1000mA = 8,
|
|
ChargerType_Apple_2000mA = 9
|
|
} ChargeInfoChargerType;
|
|
|
|
constexpr const char* ChargeInfoChargerTypeToStr(ChargeInfoChargerType in) noexcept
|
|
{
|
|
switch (in)
|
|
{
|
|
case ChargerType_None: return "None";
|
|
case ChargerType_PD: return "USB-C PD";
|
|
case ChargerType_TypeC_1500mA:
|
|
case ChargerType_TypeC_3000mA: return "USB-C";
|
|
case ChargerType_DCP: return "USB DCP";
|
|
case ChargerType_CDP: return "USB CDP";
|
|
case ChargerType_SDP: return "USB SDP";
|
|
case ChargerType_Apple_500mA:
|
|
case ChargerType_Apple_1000mA:
|
|
case ChargerType_Apple_2000mA: return "Apple";
|
|
default: return "Unknown";
|
|
}
|
|
};
|
|
|
|
typedef enum {
|
|
Flags_NoHub = BIT(0), //If hub is disconnected
|
|
Flags_Rail = BIT(8), //At least one Joy-con is charging from rail
|
|
Flags_SPDSRC = BIT(12), //OTG
|
|
Flags_ACC = BIT(16) //Accessory
|
|
} ChargeInfoFlags;
|
|
|
|
typedef struct {
|
|
int32_t InputCurrentLimit; //Input (Sink) current limit in mA
|
|
int32_t VBUSCurrentLimit; //Output (Source/VBUS/OTG) current limit in mA
|
|
int32_t ChargeCurrentLimit; //Battery charging current limit in mA (512mA when Docked, 768mA when BatteryTemperature < 17.0 C)
|
|
int32_t ChargeVoltageLimit; //Battery charging voltage limit in mV (3952mV when BatteryTemperature >= 51.0 C)
|
|
int32_t unk_x10; //Possibly an emum, getting the same value as PowerRole in all tested cases
|
|
int32_t unk_x14; //Possibly flags
|
|
ChargeInfoPDCtrler PDCtrlerState; //Power Delivery Controller State
|
|
int32_t BatteryTemperature; //Battery temperature in milli C
|
|
int32_t RawBatteryCharge; //Raw battery charged capacity per cent-mille (i.e. 100% = 100000 pcm)
|
|
int32_t VoltageAvg; //Voltage avg in mV (more in Notes)
|
|
int32_t BatteryAge; //Battery age (capacity full / capacity design) per cent-mille (i.e. 100% = 100000 pcm)
|
|
ChargeInfoPowerRole PowerRole;
|
|
ChargeInfoChargerType ChargerType;
|
|
int32_t ChargerVoltageLimit; //Charger and external device voltage limit in mV
|
|
int32_t ChargerCurrentLimit; //Charger and external device current limit in mA
|
|
ChargeInfoFlags Flags; //Unknown flags
|
|
} ChargeInfo;
|
|
|
|
typedef enum
|
|
{
|
|
Max17050Reg_Current = 0x0A,
|
|
Max17050Reg_AvgCurrent = 0x0B,
|
|
Max17050Reg_Cycle = 0x17,
|
|
} Max17050Reg;
|
|
|
|
typedef enum
|
|
{
|
|
Max77812Reg_CPUVolt = 0x26,
|
|
Max77812Reg_GPUVolt = 0x23,
|
|
Max77812Reg_DRAMVolt = 0x25,
|
|
} Max77812Reg;
|
|
|
|
typedef struct {
|
|
float batCurrent;
|
|
u32 cpuVolt = 620;
|
|
u32 gpuVolt = 610;
|
|
u32 dramVolt = 600;
|
|
} I2cInfo;
|
|
|
|
void PsmUpdate(uint32_t dispatchId = 0)
|
|
{
|
|
smInitialize();
|
|
psmInitialize();
|
|
|
|
if (dispatchId)
|
|
{
|
|
serviceDispatch(psmGetServiceSession(), dispatchId);
|
|
svcSleepThread(1000);
|
|
}
|
|
|
|
serviceDispatchOut(psmGetServiceSession(), 17, *(this->chargeInfo));
|
|
psmIsEnoughPowerSupplied(&(this->isEnoughPowerSupplied));
|
|
|
|
psmExit();
|
|
smExit();
|
|
}
|
|
|
|
bool PsmIsChargerConnected()
|
|
{
|
|
return this->chargeInfo->ChargerType != ChargerType_None;
|
|
}
|
|
|
|
bool PsmIsCharging()
|
|
{
|
|
return PsmIsChargerConnected() && ((this->chargeInfo->unk_x14 >> 8) & 1);
|
|
}
|
|
|
|
bool PsmIsFastCharging()
|
|
{
|
|
return this->chargeInfo->ChargeCurrentLimit > 768;
|
|
}
|
|
|
|
bool PsmIsEnoughPowerSupplied()
|
|
{
|
|
return this->isEnoughPowerSupplied;
|
|
}
|
|
|
|
Result I2cReadRegHandler(u8 reg, I2cDevice dev, u16 *out)
|
|
{
|
|
// ams::fatal::srv::StopSoundTask::StopSound()
|
|
// I2C Bus Communication Reference: https://www.ti.com/lit/an/slva704/slva704.pdf
|
|
struct { u8 reg; } __attribute__((packed)) cmd;
|
|
struct { u16 val; } __attribute__((packed)) rec;
|
|
|
|
I2cSession _session;
|
|
|
|
Result res = i2cOpenSession(&_session, dev);
|
|
if (res)
|
|
return res;
|
|
|
|
cmd.reg = reg;
|
|
res = i2csessionSendAuto(&_session, &cmd, sizeof(cmd), I2cTransactionOption_All);
|
|
if (res)
|
|
{
|
|
i2csessionClose(&_session);
|
|
return res;
|
|
}
|
|
|
|
res = i2csessionReceiveAuto(&_session, &rec, sizeof(rec), I2cTransactionOption_All);
|
|
if (res)
|
|
{
|
|
i2csessionClose(&_session);
|
|
return res;
|
|
}
|
|
|
|
*out = rec.val;
|
|
i2csessionClose(&_session);
|
|
return 0;
|
|
}
|
|
|
|
void I2cGetInfo(I2cInfo* i2cInfo)
|
|
{
|
|
smInitialize();
|
|
i2cInitialize();
|
|
u16 data = 0;
|
|
|
|
// Read max17050 furl gauge regs. Sense resistor and CGain are from Hekate, too lazy to query configuration from reg
|
|
{
|
|
constexpr float SenseResistor = 5.; // in uOhm
|
|
constexpr float CGain = 1.99993;
|
|
|
|
if (R_SUCCEEDED(I2cReadRegHandler(Max17050Reg_Current, I2cDevice_Max17050, &data)))
|
|
i2cInfo->batCurrent = (s16)data * (1.5625 / (SenseResistor * CGain));
|
|
}
|
|
|
|
// Read max77812 volt regs
|
|
{
|
|
auto ConvertToMVolt = [](u32 *out, u16 data)
|
|
{
|
|
constexpr u32 MinMVolt = 250;
|
|
constexpr u32 StepMVolt = 5;
|
|
constexpr u32 VoltMask = 0xFF;
|
|
|
|
u32 mvolt = (data & VoltMask) * StepMVolt + MinMVolt;
|
|
|
|
// Ignore 850 mV as it is questionable
|
|
if (mvolt == 850)
|
|
return;
|
|
|
|
*out = mvolt;
|
|
};
|
|
|
|
if (R_SUCCEEDED(I2cReadRegHandler(Max77812Reg_CPUVolt, I2cDevice_Max77812_2, &data)))
|
|
ConvertToMVolt(&(i2cInfo->cpuVolt), data);
|
|
|
|
if (R_SUCCEEDED(I2cReadRegHandler(Max77812Reg_GPUVolt, I2cDevice_Max77812_2, &data)))
|
|
ConvertToMVolt(&(i2cInfo->gpuVolt), data);
|
|
|
|
if (R_SUCCEEDED(I2cReadRegHandler(Max77812Reg_DRAMVolt, I2cDevice_Max77812_2, &data)))
|
|
ConvertToMVolt(&(i2cInfo->dramVolt), data);
|
|
}
|
|
|
|
i2cExit();
|
|
smExit();
|
|
}
|
|
|
|
void PrintInfo(char* out, size_t outsize)
|
|
{
|
|
float chargerVoltLimit = (float)chargeInfo->ChargerVoltageLimit / 1000;
|
|
float chargerCurrLimit = (float)chargeInfo->ChargerCurrentLimit / 1000;
|
|
float chargerOutWatts = chargerVoltLimit * chargerCurrLimit;
|
|
|
|
char chargeVoltLimit[20] = "";
|
|
if (chargeInfo->ChargeVoltageLimit)
|
|
snprintf(chargeVoltLimit, sizeof(chargeVoltLimit), ", %u mV", chargeInfo->ChargeVoltageLimit);
|
|
|
|
char chargWattsInfo[50] = "";
|
|
if (chargeInfo->ChargerType)
|
|
snprintf(chargWattsInfo, sizeof(chargWattsInfo), " %.1fV/%.1fA (%.1fW)", chargerVoltLimit, chargerCurrLimit, chargerOutWatts);
|
|
|
|
char batCurInfo[30] = "";
|
|
if (std::abs(i2cInfo->batCurrent) < 10)
|
|
snprintf(batCurInfo, sizeof(batCurInfo), "0 mA");
|
|
else
|
|
snprintf(batCurInfo, sizeof(batCurInfo), "%+.2f mA (%+.2f W)",
|
|
i2cInfo->batCurrent, i2cInfo->batCurrent * (float)chargeInfo->VoltageAvg / 1000'000);
|
|
|
|
snprintf(out, outsize,
|
|
"%s"
|
|
"\nCharger: %s%s"
|
|
"\nBattery: %.3fV %.2f\u00B0C"
|
|
"\nCurrent Limit: %u mA IN, %u mA OUT"
|
|
"\nCharging Limit: %u mA%s"
|
|
"\nRaw Charge: %.2f%%"
|
|
"\nBattery Age: %.2f%%"
|
|
"\nPower Role: %s"
|
|
"\nCurrent Flow: %s\n"
|
|
"\nCPU Volt: %d mV"
|
|
"\nGPU Volt: %d mV"
|
|
"\nDRAM Volt: %d mV"
|
|
,
|
|
PsmIsEnoughPowerSupplied() ? "Enough Power Supplied" : "",
|
|
ChargeInfoChargerTypeToStr(chargeInfo->ChargerType), chargWattsInfo,
|
|
(float)chargeInfo->VoltageAvg / 1000,
|
|
(float)chargeInfo->BatteryTemperature / 1000,
|
|
chargeInfo->InputCurrentLimit, chargeInfo->VBUSCurrentLimit,
|
|
chargeInfo->ChargeCurrentLimit, chargeVoltLimit,
|
|
(float)chargeInfo->RawBatteryCharge / 1000,
|
|
(float)chargeInfo->BatteryAge / 1000,
|
|
ChargeInfoPowerRoleToStr(chargeInfo->PowerRole),
|
|
batCurInfo,
|
|
i2cInfo->cpuVolt,
|
|
i2cInfo->gpuVolt,
|
|
i2cInfo->dramVolt
|
|
);
|
|
}
|
|
|
|
bool PsmChargingToggler(bool enable)
|
|
{
|
|
if (!PsmIsChargerConnected())
|
|
return false;
|
|
|
|
PsmUpdate(enable ? 2 : 3);
|
|
|
|
return PsmIsCharging() == enable;
|
|
}
|
|
|
|
bool PsmFastChargingToggler(bool enable)
|
|
{
|
|
PsmUpdate(enable ? 10 : 11);
|
|
|
|
return PsmIsFastCharging() == enable;
|
|
}
|
|
|
|
tsl::elm::ToggleListItem *chargingToggle, *fastChargingToggle;
|
|
|
|
ChargeInfo* chargeInfo;
|
|
I2cInfo* i2cInfo;
|
|
bool isEnoughPowerSupplied = false;
|
|
char infoOutput[800] = "";
|
|
int frameCounter = 60;
|
|
};
|