hoc-clk: add reversenx sync

Source/sys-clk/sysmodule/src/clock_manager.cpp

@@ -15,6 +15,30 @@
 #include "process_management.h"
 #include "errors.h"
 #include "ipc_service.h"
+
+ClockManager* ClockManager::instance = NULL;
+
+ClockManager* ClockManager::GetInstance()
+{
+    return instance;
+}
+
+void ClockManager::Exit()
+{
+    if(instance)
+    {
+        delete instance;
+    }
+}
+
+void ClockManager::Initialize()
+{
+    if(!instance)
+    {
+        instance = new ClockManager();
+    }
+}
+
 ClockManager::ClockManager()
 {
     this->config = Config::CreateDefault();
@@ -34,6 +58,9 @@ ClockManager::ClockManager()
     this->running = false;
     this->lastTempLogNs = 0;
     this->lastCsvWriteNs = 0;
+
+    this->rnxSync = new ReverseNXSync;
+
 }
 
 ClockManager::~ClockManager()
@@ -237,6 +264,8 @@ bool ClockManager::RefreshContext()
         FileUtils::LogLine("[mgr] TitleID change: %016lX", applicationId);
         this->context->applicationId = applicationId;
         hasChanged = true;
+        this->rnxSync->Reset(applicationId);
+
     }
 
     SysClkProfile profile = Board::GetProfile();
@@ -250,6 +279,7 @@ bool ClockManager::RefreshContext()
     // restore clocks to stock values on app or profile change
     if (hasChanged)
     {
+        this->rnxSync->ToggleSync(this->GetConfig()->GetConfigValue(HocClkConfigValue_SyncReverseNXMode));
         Board::ResetToStock();
         this->WaitForNextTick();
     }
@@ -347,3 +377,7 @@ bool ClockManager::RefreshContext()
 
     return hasChanged;
 }
+
+void ClockManager::SetRNXRTMode(ReverseNXMode mode) {
+    this->rnxSync->SetRTMode(mode);
+}

Source/sys-clk/sysmodule/src/clock_manager.h

@@ -16,10 +16,18 @@
 #include "config.h"
 #include "board.h"
 #include <nxExt/cpp/lockable_mutex.h>
+#include "integrations.h"
+
+class ReverseNXSync;
 
 class ClockManager
 {
   public:
+    static ClockManager* GetInstance();
+    static void Initialize();
+    static void Exit();
+
+
     ClockManager();
     virtual ~ClockManager();
 
@@ -30,6 +38,7 @@ class ClockManager
     void GetFreqList(SysClkModule module, std::uint32_t* list, std::uint32_t maxCount, std::uint32_t* outCount);
     void Tick();
     void WaitForNextTick();
+    void SetRNXRTMode(ReverseNXMode mode);
 
   protected:
     bool IsAssignableHz(SysClkModule module, std::uint32_t hz);
@@ -39,6 +48,8 @@ class ClockManager
     void RefreshFreqTableRow(SysClkModule module);
     bool RefreshContext();
 
+    static ClockManager *instance;
+
     std::atomic_bool running;
     LockableMutex contextMutex;
     struct {
@@ -51,4 +62,5 @@ class ClockManager
     std::uint64_t lastFreqLogNs;
     std::uint64_t lastPowerLogNs;
     std::uint64_t lastCsvWriteNs;
+    ReverseNXSync *rnxSync;
 };

Source/sys-clk/sysmodule/src/integrations.cpp

@@ -0,0 +1,66 @@
+#include "integrations.h"
+
+ReverseNXSync::ReverseNXSync()
+    : m_rt_mode(ReverseNX_NotFound), m_tool_mode(ReverseNX_NotFound) {
+    FILE *fp = fopen("/atmosphere/contents/0000000000534C56/flags/boot2.flag", "r");
+    m_tool_enabled = fp ? true : false;
+    if (fp)
+        fclose(fp);
+}
+
+SysClkProfile ReverseNXSync::GetProfile(SysClkProfile real) {
+    switch (this->GetMode()) {
+        case ReverseNX_Docked:
+            return SysClkProfile_Docked;
+        case ReverseNX_Handheld:
+            if (real == SysClkProfile_Docked)
+                return SysClkProfile_HandheldChargingOfficial;
+        default:
+            return real;
+    }
+}
+
+ReverseNXMode ReverseNXSync::GetMode() {
+    if (!this->m_sync_enabled)
+        return ReverseNX_NotFound;
+    if (this->m_rt_mode)
+        return this->m_rt_mode;
+    return this->m_tool_mode;
+}
+
+ReverseNXMode ReverseNXSync::GetToolModeFromPatch(const char* patch_path) {
+    constexpr uint32_t DOCKED_MAGIC = 0x320003E0;
+    constexpr uint32_t HANDHELD_MAGIC = 0x52A00000;
+    FILE *fp = fopen(patch_path, "rb");
+    if (fp) {
+        uint32_t buf = 0;
+        fread(&buf, sizeof(buf), 1, fp);
+        fclose(fp);
+
+        if (buf == DOCKED_MAGIC)
+            return ReverseNX_Docked;
+        if (buf == HANDHELD_MAGIC)
+            return ReverseNX_Handheld;
+    }
+
+    return ReverseNX_NotFound;
+}
+
+ReverseNXMode ReverseNXSync::RecheckToolMode() {
+    ReverseNXMode mode = ReverseNX_NotFound;
+    if (this->m_tool_enabled) {
+        const char* fileName = "_ZN2nn2oe18GetPerformanceModeEv.asm64"; // or _ZN2nn2oe18GetPerformanceModeEv.asm64
+        const char* filePath = new char[72];
+        SCOPE_EXIT { delete[] filePath; };
+        /* Check per-game patch */
+        snprintf((char*)filePath, 72, "/SaltySD/patches/%016lX/%s", this->m_app_id, fileName);
+        mode = this->GetToolModeFromPatch(filePath);
+        if (!mode) {
+            /* Check global patch */
+            snprintf((char*)filePath, 72, "/SaltySD/patches/%s", fileName);
+            mode = this->GetToolModeFromPatch(filePath);
+        }
+    }
+
+    return mode;
+}

Source/sys-clk/sysmodule/src/integrations.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <atomic>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <nxExt.h>
+#include <sysclk.h>
+#include <switch.h>
+#include "errors.h"
+#include "file_utils.h"
+
+class ReverseNXSync {
+public:
+    ReverseNXSync ();
+
+    void ToggleSync(bool enable)    { m_sync_enabled = enable; };
+    void Reset(uint64_t app_id)     { m_app_id = app_id; SetRTMode(ReverseNX_NotFound); GetToolMode(); }
+    ReverseNXMode GetRTMode()           { return m_rt_mode; };
+    void SetRTMode(ReverseNXMode mode)  { m_rt_mode = mode; };
+    ReverseNXMode GetToolMode()         { return m_tool_mode = RecheckToolMode(); };
+    SysClkProfile GetProfile(SysClkProfile real);
+    ReverseNXMode GetMode();
+
+protected:
+    std::atomic<ReverseNXMode> m_rt_mode;
+    ReverseNXMode m_tool_mode;
+    uint64_t m_app_id = 0;
+    bool m_tool_enabled;
+    bool m_sync_enabled;
+
+    ReverseNXMode GetToolModeFromPatch(const char* patch_path);
+    ReverseNXMode RecheckToolMode();
+};

Source/sys-clk/sysmodule/src/ipc_service.cpp

@@ -13,7 +13,7 @@
 #include <switch.h>
 #include "file_utils.h"
 #include "errors.h"
-
+#include "clock_manager.h"
 IpcService::IpcService(ClockManager* clockMgr)
 {
     std::int32_t priority;
@@ -166,7 +166,12 @@ Result IpcService::ServiceHandlerFunc(void* arg, const IpcServerRequest* r, u8*
                 );
             }
             break;
-
+        case SysClkIpcCmd_SetReverseNXRTMode:
+            if (r->data.size >= sizeof(ReverseNXMode)) {
+                ReverseNXMode mode = *((ReverseNXMode*)r->data.ptr);
+                return ipcSrv->SetReverseNXRTMode(mode);
+            }
+            break;
     }
 
     return SYSCLK_ERROR(Generic);
@@ -317,4 +322,9 @@ Result IpcService::GetFreqList(SysClkIpc_GetFreqList_Args* args, std::uint32_t*
     this->clockMgr->GetFreqList(args->module, out_list, args->maxCount, out_count);
 
     return 0;
-}
+}
+
+Result IpcService::SetReverseNXRTMode(ReverseNXMode mode) {
+    ClockManager::GetInstance()->SetRNXRTMode(mode);
+    return 0;
+}

Source/sys-clk/sysmodule/src/ipc_service.h

@@ -36,6 +36,7 @@ class IpcService
     Result GetConfigValues(SysClkConfigValueList* out_configValues);
     Result SetConfigValues(SysClkConfigValueList* configValues);
     Result GetFreqList(SysClkIpc_GetFreqList_Args* args, std::uint32_t* out_list, std::size_t size, std::uint32_t* out_count);
+    Result SetReverseNXRTMode(ReverseNXMode mode);
 
     bool running;
     Thread thread;