Start hoc-clk rewrite

2026-03-20 17:46:42 +01:00
parent 2454afd58f
commit 3e75bd5b95
107 changed files with 15348 additions and 0 deletions
--- a/Source/rewrite-hoc-clk/common/src/apm_profile_table.c
+++ b/Source/rewrite-hoc-clk/common/src/apm_profile_table.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ * 
+ */
+ 
+/* --------------------------------------------------------------------------
+ * "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
+ * --------------------------------------------------------------------------
+ */
+
+
+#include <sysclk/apm.h>
+
+SysClkApmConfiguration sysclk_g_apm_configurations[] = {
+    {0x00010000, 1020000000, 384000000, 1600000000},
+    {0x00010001, 1020000000, 768000000, 1600000000},
+    {0x00010002, 1224000000, 691200000, 1600000000},
+    {0x00020000, 1020000000, 230400000, 1600000000},
+    {0x00020001, 1020000000, 307200000, 1600000000},
+    {0x00020002, 1224000000, 230400000, 1600000000},
+    {0x00020003, 1020000000, 307200000, 1331200000},
+    {0x00020004, 1020000000, 384000000, 1331200000},
+    {0x00020005, 1020000000, 307200000, 1065600000},
+    {0x00020006, 1020000000, 384000000, 1065600000},
+    {0x92220007, 1020000000, 460800000, 1600000000},
+    {0x92220008, 1020000000, 460800000, 1331200000},
+    {0x92220009, 1785000000,  76800000, 1600000000},
+    {0x9222000A, 1785000000,  76800000, 1331200000},
+    {0x9222000B, 1020000000,  76800000, 1600000000},
+    {0x9222000C, 1020000000,  76800000, 1331200000},
+    {0, 0, 0, 0},
+};
+
--- a/Source/rewrite-hoc-clk/common/src/client/ipc.c
+++ b/Source/rewrite-hoc-clk/common/src/client/ipc.c
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ * 
+ */
+ 
+/* --------------------------------------------------------------------------
+ * "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
+ * --------------------------------------------------------------------------
+ */
+
+
+#define NX_SERVICE_ASSUME_NON_DOMAIN
+#include <switch.h>
+#include <string.h>
+#include <stdatomic.h>
+#include <sysclk/client/ipc.h>
+
+static Service g_sysclkSrv;
+static atomic_size_t g_refCnt;
+
+bool sysclkIpcRunning()
+{
+    Handle handle;
+    bool running = R_FAILED(smRegisterService(&handle, smEncodeName(SYSCLK_IPC_SERVICE_NAME), false, 1));
+
+    if (!running)
+    {
+        smUnregisterService(smEncodeName(SYSCLK_IPC_SERVICE_NAME));
+    }
+
+  return running;
+}
+
+Result sysclkIpcInitialize(void)
+{
+    Result rc = 0;
+
+    g_refCnt++;
+
+    if (serviceIsActive(&g_sysclkSrv))
+        return 0;
+
+    rc = smGetService(&g_sysclkSrv, SYSCLK_IPC_SERVICE_NAME);
+
+    if (R_FAILED(rc)) sysclkIpcExit();
+
+    return rc;
+}
+
+void sysclkIpcExit(void)
+{
+    if (--g_refCnt == 0)
+    {
+        serviceClose(&g_sysclkSrv);
+    }
+}
+
+Result sysclkIpcGetAPIVersion(u32* out_ver)
+{
+    return serviceDispatchOut(&g_sysclkSrv, SysClkIpcCmd_GetApiVersion, *out_ver);
+}
+
+Result sysclkIpcGetVersionString(char* out, size_t len)
+{
+    return serviceDispatch(&g_sysclkSrv, SysClkIpcCmd_GetVersionString,
+        .buffer_attrs = { SfBufferAttr_HipcAutoSelect | SfBufferAttr_Out },
+        .buffers = {{out, len}},
+    );
+}
+
+Result sysclkIpcGetCurrentContext(SysClkContext* out_context)
+{
+    return serviceDispatch(&g_sysclkSrv, SysClkIpcCmd_GetCurrentContext,
+        .buffer_attrs = { SfBufferAttr_HipcAutoSelect | SfBufferAttr_Out },
+        .buffers = {{out_context, sizeof(SysClkContext)}},
+    );
+}
+
+Result sysclkIpcGetProfileCount(u64 tid, u8* out_count)
+{
+    return serviceDispatchInOut(&g_sysclkSrv, SysClkIpcCmd_GetProfileCount, tid, *out_count);
+}
+
+Result sysclkIpcSetEnabled(bool enabled)
+{
+    u8 enabledRaw = (u8)enabled;
+    return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetEnabled, enabledRaw);
+}
+
+Result sysclkIpcSetOverride(SysClkModule module, u32 hz)
+{
+    SysClkIpc_SetOverride_Args args = {
+        .module = module,
+        .hz = hz
+    };
+    return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetOverride, args);
+}
+
+Result sysclkIpcGetProfiles(u64 tid, SysClkTitleProfileList* out_profiles)
+{
+    return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_GetProfiles, tid,
+        .buffer_attrs = { SfBufferAttr_HipcAutoSelect | SfBufferAttr_Out },
+        .buffers = {{out_profiles, sizeof(SysClkTitleProfileList)}},
+    );
+}
+
+Result sysclkIpcSetProfiles(u64 tid, SysClkTitleProfileList* profiles)
+{
+    SysClkIpc_SetProfiles_Args args;
+    args.tid = tid;
+    memcpy(&args.profiles, profiles, sizeof(SysClkTitleProfileList));
+    return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetProfiles, args);
+}
+
+Result sysclkIpcGetConfigValues(SysClkConfigValueList* out_configValues)
+{
+    return serviceDispatch(&g_sysclkSrv, SysClkIpcCmd_GetConfigValues,
+        .buffer_attrs = { SfBufferAttr_HipcAutoSelect | SfBufferAttr_Out },
+        .buffers = {{out_configValues, sizeof(SysClkConfigValueList)}},
+    );
+}
+
+Result sysclkIpcSetConfigValues(SysClkConfigValueList* configValues)
+{
+    return serviceDispatch(&g_sysclkSrv, SysClkIpcCmd_SetConfigValues,
+        .buffer_attrs = { SfBufferAttr_HipcAutoSelect | SfBufferAttr_In },
+        .buffers = {{configValues, sizeof(SysClkConfigValueList)}},
+    );
+}
+
+Result sysclkIpcGetFreqList(SysClkModule module, u32* list, u32 maxCount, u32* outCount)
+{
+    SysClkIpc_GetFreqList_Args args = {
+        .module = module,
+        .maxCount = maxCount
+    };
+    return serviceDispatchInOut(&g_sysclkSrv, SysClkIpcCmd_GetFreqList, args, *outCount,
+        .buffer_attrs = { SfBufferAttr_HipcAutoSelect | SfBufferAttr_Out },
+        .buffers = {{list, maxCount * sizeof(u32)}},
+    );
+}
+
+Result hocClkIpcSetKipData()
+{
+    u32 temp = 0;
+    return serviceDispatchIn(&g_sysclkSrv, HocClkIpcCmd_SetKipData, temp);
+}
+
+Result hocClkIpcGetKipData()
+{
+    u32 temp = 0;
+    return serviceDispatchIn(&g_sysclkSrv, HocClkIpcCmd_GetKipData, temp);
+}
--- a/Source/rewrite-hoc-clk/common/src/display_refresh_rate.cpp
+++ b/Source/rewrite-hoc-clk/common/src/display_refresh_rate.cpp
@@ -0,0 +1,720 @@
+/*
+ * Copyright (c) Souldbminer, based on reasearch by MasaGratoR and Cooler3D
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+#include "display_refresh_rate.h"
+#include <string.h>
+#include <math.h>
+#include <stdarg.h>
+#include <switch.h>
+#define DSI_CLOCK_HZ 234000000llu
+#define NVDISP_GET_MODE2 0x803C021B
+#define NVDISP_SET_MODE2 0x403C021C
+#define NVDISP_VALIDATE_MODE2 0xC03C021D
+#define NVDISP_GET_MODE_DB2 0xEF20021E
+#define NVDISP_GET_PANEL_DATA 0xC01C0226
+
+#define MAX_REFRESH_RATE 72
+
+static DisplayRefreshConfig g_config = {0};
+static bool g_initialized = false;
+
+static uint8_t g_dockedHighestRefreshRate = 60;
+static uint8_t g_dockedLinkRate = 10;
+static bool g_wasRetroSuperTurnedOff = false;
+static uint32_t g_lastVActive = 1080;
+static bool g_canChangeRefreshRateDocked = false;
+static uint8_t g_lastVActiveSet = 0;
+
+static const uint8_t g_dockedRefreshRates[] = {40, 45, 50, 55, 60, 70, 72, 75, 80, 90, 95, 100, 110, 120, 130, 140, 144, 150, 160, 165, 170, 180, 190, 200, 210, 220, 230, 240};
+// Calculate with this tool:
+
+// https://tomverbeure.github.io/video_timings_calculator?horiz_pixels=1920&vert_pixels=1080&refresh_rate=240&margins=false&interlaced=false&bpc=8&color_fmt=rgb444&video_opt=false&custom_hblank=80&custom_vblank=6
+
+/*
+typedef struct {
+    uint16_t hFrontPorch;
+    uint8_t hSyncWidth;
+    uint8_t hBackPorch;
+    uint8_t vFrontPorch;
+    uint8_t vSyncWidth;
+    uint8_t vBackPorch;
+    uint8_t VIC;
+    uint32_t pixelClock_kHz;
+} DockedTimings;
+*/
+static const DockedTimings g_dockedTimings1080p[] = {
+    {8, 32, 40, 7, 8, 6, 0, 88080},        // 40Hz
+    {8, 32, 40, 9, 8, 6, 0, 99270},        // 45Hz
+    {528, 44, 148, 4, 5, 36, 31, 148500},  // 50Hz
+    {8, 32, 40, 15, 8, 6, 0, 121990},      // 55Hz
+    {88, 44, 148, 4, 5, 36, 16, 148500},   // 60Hz
+    {8, 32, 40, 22, 8, 6, 0, 156240},      // 70Hz
+    {8, 32, 40, 23, 8, 6, 0, 160848},      // 72Hz
+    {8, 32, 40, 25, 8, 6, 0, 167850},      // 75Hz
+    {8, 32, 40, 28, 8, 6, 0, 179520},      // 80Hz
+    {8, 32, 40, 33, 8, 6, 0, 202860},      // 90Hz
+    {8, 32, 40, 36, 8, 6, 0, 214700},      // 95Hz
+    {528, 44, 148, 4, 5, 36, 64, 297000},  // 100Hz
+    {8, 32, 40, 44, 8, 6, 0, 250360},      // 110Hz
+    {88, 44, 148, 4, 5, 36, 63, 297000},   // 120Hz
+    {8, 32, 40, 55, 8, 6, 0, 298750},      //130Hz CVT-RBv2
+    {8, 32, 40, 61, 8, 6, 0, 323400},      //140Hz CVT-RBv2
+    {8, 32, 40, 63, 8, 6, 0, 333216},      //144Hz CVT-RBv2
+    {8, 32, 40, 67, 8, 6, 0, 348300},      //150Hz CVT-RBv2
+    {8, 32, 40, 72, 8, 6, 0, 373120},      //160Hz CVT-RBv2
+    {8, 32, 40, 75, 8, 6, 0, 385770},      //165Hz CVT-RBv2
+    {8, 32, 40, 78, 8, 6, 0, 398480},      //170Hz CVT-RBv2
+    {8, 32, 40, 84, 8, 6, 0, 424080},      //180Hz CVT-RBv2
+    {8, 32, 40, 90, 8, 6, 0, 449920},      //190Hz CVT-RBv2
+    {8, 32, 40, 96, 8, 6, 0, 476000},      //200Hz CVT-RBv2
+    {8, 32, 40, 102, 8, 6, 0, 502320},     //210Hz CVT-RBv2
+    {8, 32, 40, 108, 8, 6, 0, 528880},     //220Hz CVT-RBv2
+    {8, 32, 40, 114, 8, 6, 0, 555680},     //230Hz CVT-RBv2
+    {8, 32, 40, 121, 8, 6, 0, 583200},     //240Hz CVT-RBv2
+    // technically you can go to 476hz, but in practice, why would you?
+};
+
+static const HandheldTimings g_handheldTimingsRETRO[] = {
+    {72, 136, 72, 1, 660, 9, 78000},
+    {72, 136, 72, 1, 443, 9, 77985},
+    {72, 136, 72, 1, 270, 9, 78000},
+    {72, 136, 72, 1, 128, 9, 77990},
+    {72, 136, 72, 1, 10, 9, 78000}
+};
+
+static const MinMaxRefreshRate g_handheldModeRefreshRate = {40, 80};
+
+static uint8_t _getDockedRefreshRateIterator(uint32_t refreshRate) {
+    for (size_t i = 0; i < sizeof(g_dockedRefreshRates) / sizeof(g_dockedRefreshRates[0]); i++) {
+        if (g_dockedRefreshRates[i] == refreshRate) return i;
+    }
+    return 0xFF;
+}
+
+static void _changeOledElvssSettings(const uint32_t* offsets, const uint32_t* value, uint32_t size, uint32_t start) {
+    if (!g_config.dsiVirtAddr || !value || !size) return;
+
+    volatile uint32_t* dsi = (uint32_t*)g_config.dsiVirtAddr;
+    
+    #define DSI_VIDEO_MODE_CONTROL 0x4E
+    #define DSI_WR_DATA 0xA
+    #define DSI_TRIGGER 0x13
+    #define MIPI_DSI_DCS_SHORT_WRITE_PARAM 0x15
+    #define MIPI_DSI_DCS_LONG_WRITE 0x39
+    #define MIPI_DCS_PRIV_SM_SET_REG_OFFSET 0xB0
+    #define MIPI_DCS_PRIV_SM_SET_ELVSS 0xB1
+
+    dsi[DSI_VIDEO_MODE_CONTROL] = true;
+    svcSleepThread(20000000);
+
+    dsi[DSI_WR_DATA] = MIPI_DSI_DCS_LONG_WRITE | (5 << 8);
+    dsi[DSI_WR_DATA] = 0x5A5A5AE2;
+    dsi[DSI_WR_DATA] = 0x5A;
+    dsi[DSI_TRIGGER] = 0;
+
+    for (size_t i = start; i < size; i++) {
+        dsi[DSI_WR_DATA] = ((MIPI_DCS_PRIV_SM_SET_REG_OFFSET | ((offsets[i] % 0x100) << 8)) << 8) | MIPI_DSI_DCS_SHORT_WRITE_PARAM;
+        dsi[DSI_TRIGGER] = 0;
+        dsi[DSI_WR_DATA] = ((MIPI_DCS_PRIV_SM_SET_ELVSS | (value[i] << 8)) << 8) | MIPI_DSI_DCS_SHORT_WRITE_PARAM;
+        dsi[DSI_TRIGGER] = 0;
+    }
+
+    dsi[DSI_WR_DATA] = MIPI_DSI_DCS_LONG_WRITE | (5 << 8);
+    dsi[DSI_WR_DATA] = 0xA55A5AE2;
+    dsi[DSI_WR_DATA] = 0xA5;
+    dsi[DSI_TRIGGER] = 0;
+
+    dsi[DSI_VIDEO_MODE_CONTROL] = false;
+    svcSleepThread(20000000);
+}
+void DisplayRefresh_SetDockedState(bool isDocked) {
+    g_config.isDocked = isDocked;
+}
+
+bool DisplayRefresh_Initialize(const DisplayRefreshConfig* config) {
+    if (!config) return false;
+    
+    g_config = *config;
+    g_initialized = true;
+    return true;
+}
+
+void DisplayRefresh_CorrectOledGamma(uint32_t refresh_rate) {
+    static uint32_t last_refresh_rate = 60;
+    static int counter = 0;
+    
+    if (g_config.isDocked || refresh_rate < 45 || refresh_rate > 60) {
+        last_refresh_rate = 60;
+        return;
+    }
+    
+    if (counter != 9) {
+        counter++;
+        return;
+    }
+    counter = 0;
+
+    uint32_t offsets[] = {0x1A, 0x24, 0x25};
+    uint32_t values[] = {2, 0, 0x83};
+    
+    if (refresh_rate == 60) {
+        if (last_refresh_rate == 60) return;
+    } else if (refresh_rate == 45) {
+        if (last_refresh_rate == 45) return;
+        uint32_t vals[] = {4, 1, 0};
+        memcpy(values, vals, sizeof(vals));
+    } else if (refresh_rate == 50) {
+        if (last_refresh_rate == 50) return;
+        uint32_t vals[] = {3, 1, 0};
+        memcpy(values, vals, sizeof(vals));
+    } else if (refresh_rate == 55) {
+        if (last_refresh_rate == 55) return;
+        uint32_t vals[] = {3, 1, 0};
+        memcpy(values, vals, sizeof(vals));
+    } else {
+        return;
+    }
+
+    for (int i = 0; i < 5; i++) {
+        _changeOledElvssSettings(offsets, values, 3, 0);
+    }
+    last_refresh_rate = refresh_rate;
+}
+
+void DisplayRefresh_SetAllowedDockedRatesIPC(uint32_t refreshRates, bool is720p) {
+    // Function kept for API compatibility but does nothing
+    (void)refreshRates;
+    (void)is720p;
+}
+
+uint8_t DisplayRefresh_GetDockedHighestAllowed(void) {
+    return (g_dockedHighestRefreshRate > 60) ? g_dockedHighestRefreshRate : 60;
+}
+
+static void _getDockedHighestRefreshRate(uint32_t fd_in) {
+    uint8_t highestRefreshRate = 60;
+    uint32_t fd = fd_in;
+    
+    if(!fd) nvOpen(&fd, "/dev/nvdisp-disp1");
+    NvdcModeDB2 db2 = {0};
+    int rc = nvIoctl(fd, NVDISP_GET_MODE_DB2, &db2);
+    
+    if (rc == 0) {
+        for (size_t i = 0; i < db2.num_modes; i++) {
+            if (db2.modes[i].hActive < 1920 || db2.modes[i].vActive < 1080) 
+                continue;
+            
+            uint32_t v_total = db2.modes[i].vActive + db2.modes[i].vSyncWidth + db2.modes[i].vFrontPorch + db2.modes[i].vBackPorch;
+            uint32_t h_total = db2.modes[i].hActive + db2.modes[i].hSyncWidth + db2.modes[i].hFrontPorch + db2.modes[i].hBackPorch;
+            double refreshRate = round((double)(db2.modes[i].pclkKHz * 1000) / (double)(v_total * h_total));
+            
+            if (highestRefreshRate < (uint8_t)refreshRate) 
+                highestRefreshRate = (uint8_t)refreshRate;
+        }
+    } else {
+        g_dockedHighestRefreshRate = 60;
+    }
+    
+    const size_t numRates = sizeof(g_dockedRefreshRates) / sizeof(g_dockedRefreshRates[0]);
+    if (highestRefreshRate > g_dockedRefreshRates[numRates - 1]) 
+        highestRefreshRate = g_dockedRefreshRates[numRates - 1];
+    
+    NvdcMode2 display_b = {0};
+    rc = nvIoctl(fd, NVDISP_GET_MODE2, &display_b);
+    
+    struct dpaux_read_0x100 {
+        uint32_t cmd;
+        uint32_t addr;
+        uint32_t size;
+        struct {
+            unsigned char link_rate;
+            unsigned int lane_count: 5;
+            unsigned int unk1: 2;
+            unsigned int isFramingEnhanced: 1;
+            unsigned char downspread;
+            unsigned char training_pattern;
+            unsigned char lane_pattern[4];
+            unsigned char unk2[8];
+        } set;
+    } dpaux = {6, 0x100, 0x10};
+    
+    rc = nvIoctl(fd, NVDISP_GET_PANEL_DATA, &dpaux);
+    if (rc == 0) {
+        g_dockedLinkRate = dpaux.set.link_rate;
+        // if (display_b.hActive == 1920 && display_b.vActive == 1080 && highestRefreshRate > 75 && dpaux.set.link_rate < 20 && ) 
+        //     highestRefreshRate = 75;
+    }
+    
+    if (!fd_in) nvClose(fd);
+    g_dockedHighestRefreshRate = highestRefreshRate;
+}
+
+static bool _setPLLDHandheldRefreshRate(uint32_t new_refreshRate) {
+    if (!g_config.clkVirtAddr) return false;
+
+    uint32_t fd = 0;
+    if (nvOpen(&fd, "/dev/nvdisp-disp0")) {
+        return false;
+    }
+    
+    struct dpaux_read {
+        uint32_t cmd;
+        uint32_t addr;
+        uint32_t size;
+        struct {
+            unsigned int rev_minor : 4;
+            unsigned int rev_major : 4;
+            unsigned char link_rate;
+            unsigned int lane_count: 5;
+            unsigned int unk1: 2;
+            unsigned int isFramingEnhanced: 1;
+            unsigned char unk2[13];
+        } DPCD;
+    } dpaux = {6, 0, 0x10};
+    
+    int rc = nvIoctl(fd, NVDISP_GET_PANEL_DATA, &dpaux);
+    nvClose(fd);
+    if (rc != 0x75c) return false;
+
+    PLLD_BASE base = {0};
+    PLLD_MISC misc = {0};
+    memcpy(&base, (void*)(g_config.clkVirtAddr + 0xD0), 4);
+    memcpy(&misc, (void*)(g_config.clkVirtAddr + 0xDC), 4);
+    
+    uint32_t value = ((base.PLLD_DIVN / base.PLLD_DIVM) * 10) / 4;
+    if (value == 0 || value == 80) return false;
+
+    if (new_refreshRate > g_handheldModeRefreshRate.max) {
+        new_refreshRate = g_handheldModeRefreshRate.max;
+    } else if (new_refreshRate < g_handheldModeRefreshRate.min) {
+        bool skip = false;
+        for (size_t i = 2; i <= 4; i++) {
+            if (new_refreshRate * i == 60) {
+                skip = true;
+                new_refreshRate = 60;
+                break;
+            }
+        }
+        if (!skip) {
+            for (size_t i = 2; i <= 4; i++) {
+                if (((new_refreshRate * i) >= g_handheldModeRefreshRate.min) && ((new_refreshRate * i) <= g_handheldModeRefreshRate.max)) {
+                    skip = true;
+                    new_refreshRate *= i;
+                    break;
+                }
+            }
+        }
+        if (!skip) new_refreshRate = 60;
+    }
+
+    uint32_t pixelClock = (9375 * ((4096 * ((2 * base.PLLD_DIVN) + 1)) + misc.PLLD_SDM_DIN)) / (8 * base.PLLD_DIVM);
+    uint16_t refreshRateNow = pixelClock / (DSI_CLOCK_HZ / 60);
+
+    if (refreshRateNow == new_refreshRate) {
+        return true;
+    }
+
+    uint8_t base_refreshRate = new_refreshRate - (new_refreshRate % 5);
+    base.PLLD_DIVN = (4 * base_refreshRate) / 10;
+    base.PLLD_DIVM = 1;
+
+    uint64_t expected_pixel_clock = (DSI_CLOCK_HZ * new_refreshRate) / 60;
+    misc.PLLD_SDM_DIN = ((8 * base.PLLD_DIVM * expected_pixel_clock) / 9375) - (4096 * ((2 * base.PLLD_DIVN) + 1));
+
+    memcpy((void*)(g_config.clkVirtAddr + 0xD0), &base, 4);
+    memcpy((void*)(g_config.clkVirtAddr + 0xDC), &misc, 4);
+    return true;
+}
+
+static bool _setNvDispDockedRefreshRate(uint32_t new_refreshRate) {
+    if (g_config.isLite || !g_canChangeRefreshRateDocked)
+        return false;
+    
+    uint32_t fd = 0;
+    if (nvOpen(&fd, "/dev/nvdisp-disp1")) {
+        return false;
+    }
+    
+    NvdcMode2 display_b = {0};
+    int rc = nvIoctl(fd, NVDISP_GET_MODE2, &display_b);
+    if (rc != 0) {
+        nvClose(fd);
+        return false;
+    }
+    
+    if (!display_b.pclkKHz) {
+        nvClose(fd);
+        return false;
+    }
+    
+    if (!((display_b.vActive == 480 && display_b.hActive == 720) || 
+          (display_b.vActive == 720 && display_b.hActive == 1280) || 
+          (display_b.vActive == 1080 && display_b.hActive == 1920))) {
+        nvClose(fd);
+        return false;
+    }
+
+    if (display_b.vActive != g_lastVActiveSet) {
+        g_lastVActiveSet = display_b.vActive;
+    }
+
+    uint32_t h_total = display_b.hActive + display_b.hFrontPorch + display_b.hSyncWidth + display_b.hBackPorch;
+    uint32_t v_total = display_b.vActive + display_b.vFrontPorch + display_b.vSyncWidth + display_b.vBackPorch;
+    uint32_t refreshRateNow = ((display_b.pclkKHz) * 1000 + 999) / (h_total * v_total);
+    
+    int8_t itr = -1;
+    const size_t numRates = sizeof(g_dockedRefreshRates) / sizeof(g_dockedRefreshRates[0]);
+    
+    // Find closest matching refresh rate
+    if ((new_refreshRate <= 60) && ((60 % new_refreshRate) == 0)) {
+        itr = _getDockedRefreshRateIterator(60);
+    }
+    
+    if (itr == -1) {
+        for (size_t i = 0; i < numRates; i++) {
+            uint8_t val = g_dockedRefreshRates[i];
+            if ((val % new_refreshRate) == 0) {
+                itr = i;
+                break;
+            }
+        }
+    }
+    
+    if (itr == -1) {
+        if (!g_config.matchLowestDocked) {
+            itr = _getDockedRefreshRateIterator(60);
+        } else {
+            for (size_t i = 0; i < numRates; i++) {
+                if (new_refreshRate < g_dockedRefreshRates[i]) {
+                    itr = i;
+                    break;
+                }
+            }
+        }
+    }
+    
+    if (itr == -1) itr = _getDockedRefreshRateIterator(60);
+    
+    // Clamp to highest allowed refresh rate
+    if (g_dockedRefreshRates[itr] > g_dockedHighestRefreshRate) {
+        for (int8_t i = itr; i >= 0; i--) {
+            if (g_dockedRefreshRates[i] <= g_dockedHighestRefreshRate) {
+                itr = i;
+                break;
+            }
+        }
+    }
+    
+    if (refreshRateNow == g_dockedRefreshRates[itr]) {
+        nvClose(fd);
+        return true;
+    }
+
+    if (itr >= 0 && itr < (int8_t)numRates) {
+        if (display_b.vActive == 720) {
+            uint32_t clock = ((h_total * v_total) * g_dockedRefreshRates[itr]) / 1000;
+            display_b.pclkKHz = clock;
+        } else {
+            display_b.hFrontPorch = g_dockedTimings1080p[itr].hFrontPorch;
+            display_b.hSyncWidth = g_dockedTimings1080p[itr].hSyncWidth;
+            display_b.hBackPorch = g_dockedTimings1080p[itr].hBackPorch;
+            display_b.vFrontPorch = g_dockedTimings1080p[itr].vFrontPorch;
+            display_b.vSyncWidth = g_dockedTimings1080p[itr].vSyncWidth;
+            display_b.vBackPorch = g_dockedTimings1080p[itr].vBackPorch;
+            display_b.pclkKHz = g_dockedTimings1080p[itr].pixelClock_kHz;
+            display_b.vmode = (g_dockedRefreshRates[itr] >= 100 ? 0x400000 : 0x200000);
+            display_b.unk1 = (g_dockedRefreshRates[itr] >= 100 ? 0x80 : 0);
+            display_b.sync = 3;
+            display_b.bitsPerPixel = 24;
+        }
+        
+        rc = nvIoctl(fd, NVDISP_VALIDATE_MODE2, &display_b);
+        if (rc == 0) {
+            rc = nvIoctl(fd, NVDISP_SET_MODE2, &display_b);
+        }
+    }
+    
+    nvClose(fd);
+    return true;
+}
+
+static bool _setNvDispHandheldRefreshRate(uint32_t new_refreshRate) {
+    if (!g_config.isRetroSUPER) return false;
+    
+    if (!g_config.displaySync) {
+        g_wasRetroSuperTurnedOff = false;
+    } else if (g_wasRetroSuperTurnedOff) {
+        svcSleepThread(2000000000);
+        g_wasRetroSuperTurnedOff = false;
+    }
+    
+    svcSleepThread(1000000000);
+    
+    uint32_t fd = 0;
+    if (nvOpen(&fd, "/dev/nvdisp-disp0")) {
+        return false;
+    }
+    
+    NvdcMode2 display_b = {0};
+    int rc = nvIoctl(fd, NVDISP_GET_MODE2, &display_b);
+    if (rc != 0) {
+        nvClose(fd);
+        return false;
+    }
+    
+    if (!display_b.pclkKHz) {
+        nvClose(fd);
+        return false;
+    }
+    
+    if ((display_b.vActive == 1280 && display_b.hActive == 720) == false) {
+        nvClose(fd);
+        return false;
+    }
+
+    uint32_t h_total = display_b.hActive + display_b.hFrontPorch + display_b.hSyncWidth + display_b.hBackPorch;
+    uint32_t v_total = display_b.vActive + display_b.vFrontPorch + display_b.vSyncWidth + display_b.vBackPorch;
+    uint32_t refreshRateNow = ((display_b.pclkKHz) * 1000 + 999) / (h_total * v_total);
+
+    if (new_refreshRate > g_handheldModeRefreshRate.max) {
+        new_refreshRate = g_handheldModeRefreshRate.max;
+    } else if (new_refreshRate < g_handheldModeRefreshRate.min) {
+        bool skip = false;
+        for (size_t i = 2; i <= 4; i++) {
+            if (new_refreshRate * i == 60) {
+                skip = true;
+                new_refreshRate = 60;
+                break;
+            }
+        }
+        if (!skip) {
+            for (size_t i = 2; i <= (sizeof(g_handheldTimingsRETRO) / sizeof(g_handheldTimingsRETRO[0])); i++) {
+                if (((new_refreshRate * i) >= g_handheldModeRefreshRate.min) && ((new_refreshRate * i) <= g_handheldModeRefreshRate.max)) {
+                    skip = true;
+                    new_refreshRate *= i;
+                    break;
+                }
+            }
+        }
+        if (!skip) new_refreshRate = 60;
+    }
+
+    if (new_refreshRate == refreshRateNow) {
+        nvClose(fd);
+        return true;
+    }
+
+    uint32_t itr = (new_refreshRate - 40) / 5;
+    display_b.hFrontPorch = g_handheldTimingsRETRO[itr].hFrontPorch;
+    display_b.hSyncWidth = g_handheldTimingsRETRO[itr].hSyncWidth;
+    display_b.hBackPorch = g_handheldTimingsRETRO[itr].hBackPorch;
+    display_b.vFrontPorch = g_handheldTimingsRETRO[itr].vFrontPorch;
+    display_b.vSyncWidth = g_handheldTimingsRETRO[itr].vSyncWidth;
+    display_b.vBackPorch = g_handheldTimingsRETRO[itr].vBackPorch;
+    display_b.pclkKHz = g_handheldTimingsRETRO[itr].pixelClock_kHz;
+
+    rc = nvIoctl(fd, NVDISP_VALIDATE_MODE2, &display_b);
+    if (rc == 0) {
+        for (size_t i = 0; i < 5; i++) {
+            nvIoctl(fd, NVDISP_SET_MODE2, &display_b);
+        }
+    }
+    
+    nvClose(fd);
+    return true;
+}
+
+bool DisplayRefresh_SetRate(uint32_t new_refreshRate) {
+    if (!new_refreshRate || !g_initialized) return false;
+
+    uint32_t fd = 0;
+    
+    if (g_config.isLite && g_config.isPossiblySpoofedRetro) {
+        g_config.isRetroSUPER = false; // Would check flag file here in original, but i dont care lol
+    }
+    
+    if (g_config.isRetroSUPER && !g_config.isDocked) {
+        return _setNvDispHandheldRefreshRate(new_refreshRate);
+    }
+
+    else if ((!g_config.isRetroSUPER && g_config.isLite) || R_FAILED(nvOpen(&fd, "/dev/nvdisp-disp1"))) {
+        if (_setPLLDHandheldRefreshRate(new_refreshRate) == false) 
+            return false;
+    }
+    else {
+        struct dpaux_read {
+            uint32_t cmd;
+            uint32_t addr;
+            uint32_t size;
+            struct {
+                unsigned int rev_minor : 4;
+                unsigned int rev_major : 4;
+                unsigned char link_rate;
+                unsigned int lane_count: 5;
+                unsigned int unk1: 2;
+                unsigned int isFramingEnhanced: 1;
+                unsigned char unk2[13];
+            } DPCD;
+        } dpaux = {6, 0, 0x10};
+        
+        int rc = nvIoctl(fd, NVDISP_GET_PANEL_DATA, &dpaux);
+        nvClose(fd);
+        
+        if (rc != 0) {
+                if (!g_config.isRetroSUPER) {
+                    return _setPLLDHandheldRefreshRate(new_refreshRate);
+                } else {
+                    return _setNvDispHandheldRefreshRate(new_refreshRate);
+                }
+        } else {
+            if(g_config.isDocked)
+                return _setNvDispDockedRefreshRate(new_refreshRate);
+            else 
+                return true;
+        }
+    }
+    return false;
+}
+
+bool DisplayRefresh_GetRate(uint32_t* out_refreshRate, bool internal) {
+    if (!out_refreshRate || !g_initialized || !g_config.clkVirtAddr) return false;
+    static uint32_t value = 60;
+
+    if (g_config.isRetroSUPER && !g_config.isDocked) {
+        uint32_t fd = 0;
+        PLLD_BASE temp = {0};
+        PLLD_MISC misc = {0};
+        memcpy(&temp, (void*)(g_config.clkVirtAddr + 0xD0), 4);
+        memcpy(&misc, (void*)(g_config.clkVirtAddr + 0xDC), 4);
+        
+        value = ((temp.PLLD_DIVN / temp.PLLD_DIVM) * 10) / 4;
+        
+        if (value != 0 && value != 80) {
+            if (!nvOpen(&fd, "/dev/nvdisp-disp0")) {
+                NvdcMode2 display_b = {0};
+                if (nvIoctl(fd, NVDISP_GET_MODE2, &display_b) == 0) {
+                    uint32_t h_total = display_b.hActive + display_b.hFrontPorch + display_b.hSyncWidth + display_b.hBackPorch;
+                    uint32_t v_total = display_b.vActive + display_b.vFrontPorch + display_b.vSyncWidth + display_b.vBackPorch;
+                    uint32_t pixelClock = display_b.pclkKHz * 1000 + 999;
+                    value = pixelClock / (h_total * v_total);
+                }
+                nvClose(fd);
+            } else {
+                return false;
+            }
+        } else {
+            g_wasRetroSuperTurnedOff = true;
+        }
+    }
+    else if ((!g_config.isPossiblySpoofedRetro) || (g_config.isPossiblySpoofedRetro && !g_config.isRetroSUPER)) {
+        PLLD_BASE temp = {0};
+        PLLD_MISC misc = {0};
+        memcpy(&temp, (void*)(g_config.clkVirtAddr + 0xD0), 4);
+        memcpy(&misc, (void*)(g_config.clkVirtAddr + 0xDC), 4);
+        
+        value = ((temp.PLLD_DIVN / temp.PLLD_DIVM) * 10) / 4;
+        
+        if (value == 0 || value == 80) {
+            // Docked mode
+            if (g_config.isLite) return false;
+            
+            g_config.isDocked = true;
+            
+            if (!g_canChangeRefreshRateDocked) {
+                uint32_t fd = 0;
+                if (!nvOpen(&fd, "/dev/nvdisp-disp1")) {
+                    struct dpaux_read_0x100 {
+                        uint32_t cmd;
+                        uint32_t addr;
+                        uint32_t size;
+                        struct {
+                            unsigned char link_rate;
+                            unsigned int lane_count: 5;
+                            unsigned int unk1: 2;
+                            unsigned int isFramingEnhanced: 1;
+                            unsigned char downspread;
+                            unsigned char training_pattern;
+                            unsigned char lane_pattern[4];
+                            unsigned char unk2[8];
+                        } set;
+                    } dpaux = {6, 0x100, 0x10};
+                    
+                    int rc = nvIoctl(fd, NVDISP_GET_PANEL_DATA, &dpaux);
+                    nvClose(fd);
+                    
+                    if (rc == 0) {
+                        _getDockedHighestRefreshRate(0);
+                        g_canChangeRefreshRateDocked = true;
+                    } else {
+                        svcSleepThread(1000000000);
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            }
+            if(internal) {
+                *out_refreshRate = value;
+                return true;
+            }
+            uint32_t fd = 0;
+            if (!nvOpen(&fd, "/dev/nvdisp-disp1")) {
+                NvdcMode2 display_b = {0};
+                if (nvIoctl(fd, NVDISP_GET_MODE2, &display_b) == 0) {
+                    if (!display_b.pclkKHz) {
+                        nvClose(fd);
+                        return false;
+                    }
+                    
+                    if (g_lastVActive != display_b.vActive) {
+                        g_lastVActive = display_b.vActive;
+                        _getDockedHighestRefreshRate(fd);
+                    }
+                    
+                    uint32_t h_total = display_b.hActive + display_b.hFrontPorch + display_b.hSyncWidth + display_b.hBackPorch;
+                    uint32_t v_total = display_b.vActive + display_b.vFrontPorch + display_b.vSyncWidth + display_b.vBackPorch;
+                    uint32_t pixelClock = display_b.pclkKHz * 1000 + 999;
+                    value = pixelClock / (h_total * v_total);
+                } else {
+                    value = 60;
+                }
+                nvClose(fd);
+            } else {
+                value = 60;
+            }
+        }
+        else if (!g_config.isRetroSUPER) {
+            // Handheld mode
+            g_config.isDocked = false;
+            g_canChangeRefreshRateDocked = false;
+            
+            uint32_t pixelClock = (9375 * ((4096 * ((2 * temp.PLLD_DIVN) + 1)) + misc.PLLD_SDM_DIN)) / (8 * temp.PLLD_DIVM);
+            value = pixelClock / (DSI_CLOCK_HZ / 60);
+        }
+        else {
+            return false;
+        }
+    }
+
+    *out_refreshRate = value;
+    return true;
+}
+
+void DisplayRefresh_Shutdown(void) {
+    g_initialized = false;
+    memset(&g_config, 0, sizeof(g_config));
+}
--- a/Source/rewrite-hoc-clk/common/src/i2c.cpp
+++ b/Source/rewrite-hoc-clk/common/src/i2c.cpp
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) KazushiMe
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ * 
+ */
+#include "i2c.h"
+
+Result I2cSet_U8(I2cDevice dev, u8 reg, u8 val) {
+    // ams::fatal::srv::StopSoundTask::StopSound()
+    // I2C Bus Communication Reference: https://www.ti.com/lit/an/slva704/slva704.pdf
+    struct {
+        u8 reg;
+        u8 val;
+    } __attribute__((packed)) cmd;
+
+    I2cSession _session;
+    Result res = i2cOpenSession(&_session, dev);
+    if (res)
+        return res;
+
+    cmd.reg = reg;
+    cmd.val = val;
+    res = i2csessionSendAuto(&_session, &cmd, sizeof(cmd), I2cTransactionOption_All);
+    i2csessionClose(&_session);
+    return res;
+}
+
+Result I2cRead_OutU8(I2cDevice dev, u8 reg, u8 *out) {
+    struct { u8 reg; } __attribute__((packed)) cmd;
+    struct { u8 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);
+    i2csessionClose(&_session);
+    if (res) {
+        return res;
+    }
+
+    *out = rec.val;
+    return 0;
+}
+
+Result I2cRead_OutU16(I2cDevice dev, u8 reg, u16 *out) {
+    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);
+    i2csessionClose(&_session);
+    if (res) {
+        return res;
+    }
+
+    *out = rec.val;
+    return 0;
+}
+
+float I2c_Max17050_GetBatteryCurrent() {
+    u16 val;
+    Result res = I2cRead_OutU16(I2cDevice_Max17050, MAX17050_CURRENT_REG, &val);
+    if (res)
+        return 0.f;
+
+    const float SenseResistor   = 5.; // in uOhm
+    const float CGain           = 1.99993;
+    return (s16)val * (1.5625 / (SenseResistor * CGain));
+}
+
+u32 I2c_BuckConverter_MultiplierToMvOut(const I2c_BuckConverter_Domain* domain, u8 multiplier) {
+    return (domain->uv_min + domain->uv_step * multiplier) / 1000;
+}
+
+u8 I2c_BuckConverter_MvOutToMultiplier(const I2c_BuckConverter_Domain* domain, u32 mvolt) {
+    u32 uvolt = mvolt * 1000;
+    if (uvolt < domain->uv_min)
+        uvolt = domain->uv_min;
+    if (uvolt > domain->uv_max)
+        uvolt = domain->uv_max;
+
+    return (uvolt - domain->uv_min) / domain->uv_step;
+}
+
+u32 I2c_BuckConverter_GetMvOut(const I2c_BuckConverter_Domain* domain) {
+    u8 val;
+    // Retry 5 times if received POR value
+    for (int i = 0; i < 5; i++) {
+        if (R_FAILED(I2cRead_OutU8(domain->device, domain->reg, &val)))
+            return 0u;
+
+        // Wait 1us
+        svcSleepThread(1E3);
+
+        if (!domain->por_val || val != domain->por_val)
+            break;
+    }
+    return I2c_BuckConverter_MultiplierToMvOut(domain, val & domain->volt_mask);
+}
+
+Result I2c_BuckConverter_SetMvOut(const I2c_BuckConverter_Domain* domain, u32 mvolt) {
+    u8 val;
+    Result res = I2cRead_OutU8(domain->device, domain->reg, &val);
+    if (R_FAILED(res))
+        return res;
+
+    u8 multiplier = I2c_BuckConverter_MvOutToMultiplier(domain, mvolt);
+    val &= ~domain->volt_mask;
+    val |= multiplier & domain->volt_mask;
+
+    res = I2cSet_U8(domain->device, domain->reg, val);
+    if (R_FAILED(res))
+        return res;
+
+    // 5ms Ramp delay
+    svcSleepThread(5E6);
+    u8 new_val;
+    res = I2cRead_OutU8(domain->device, domain->reg, &new_val);
+    if (R_FAILED(res))
+        return res;
+    if (new_val != val)
+        return -1;
+
+    return 0;
+}
+
+u8 I2c_Bq24193_Convert_mA_Raw(u32 ma) {
+    // Adjustment is required
+    u8 raw = 0;
+
+    if (ma > MA_RANGE_MAX) // capping
+        ma = MA_RANGE_MAX;
+
+    bool pct20 = ma <= (MA_RANGE_MIN - 64);
+    if (pct20) {
+        ma = ma * 5;
+        raw |= 0x1;
+    }
+
+    ma -= ma % 100; // round to 100
+    ma -= (MA_RANGE_MIN - 64); // ceiling
+    raw |= (ma >> 6) << 2;
+
+    return raw;
+};
+
+u32 I2c_Bq24193_Convert_Raw_mA(u8 raw) {
+    // No adjustment is allowed
+    u32 ma = (((raw >> 2)) << 6) + MA_RANGE_MIN;
+
+    bool pct20 = raw & 1;
+    if (pct20)
+        ma = ma * 20 / 100;
+
+    return ma;
+};
+
+Result I2c_Bq24193_GetFastChargeCurrentLimit(u32 *ma) {
+    u8 raw;
+    Result res = I2cRead_OutU8(I2cDevice_Bq24193, BQ24193_CHARGE_CURRENT_CONTROL_REG, &raw);
+    if (res)
+        return res;
+
+    *ma = I2c_Bq24193_Convert_Raw_mA(raw);
+    return 0;
+}
+
+Result I2c_Bq24193_SetFastChargeCurrentLimit(u32 ma) {
+    u8 raw = I2c_Bq24193_Convert_mA_Raw(ma);
+    return I2cSet_U8(I2cDevice_Bq24193, BQ24193_CHARGE_CURRENT_CONTROL_REG, raw);
+}
--- a/Source/rewrite-hoc-clk/common/src/memmem.c
+++ b/Source/rewrite-hoc-clk/common/src/memmem.c
@@ -0,0 +1,83 @@
+/*
+    MIT License
+
+    Copyright (c) 2024 Roy Merkel
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+*/
+
+#include "memmem.h"
+
+void *memmem_impl(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen)
+{
+	const unsigned char *cmpp;
+	const unsigned char *p;
+	const unsigned char *endp;
+	const unsigned char *q;
+	const unsigned char *endq;
+	unsigned char found;
+
+	if(haystack == NULL)
+	{
+		return NULL;
+	}
+	if(needle == NULL)
+	{
+		return (void*)haystack;
+	}
+	if(haystacklen == 0)
+	{
+		return NULL;
+	}
+	if(needlelen == 0)
+	{
+		return (void*)haystack;
+	}
+
+	if(needlelen > haystacklen)
+	{
+		return NULL;
+	}
+
+	endp = haystack + haystacklen - needlelen;
+	endq = needle + needlelen;
+	for(p = haystack; p <= endp; p++)
+	{
+		found = 1;
+		cmpp = p;
+		for(q = needle; q < endq; q++)
+		{
+			if(*cmpp != *q)
+			{
+				found = 0;
+				break;
+			}
+			else
+			{
+				cmpp++;
+			}
+		}
+		if(found)
+		{
+			return (void*)p;
+		}
+	}
+
+  return NULL;
+}
--- a/Source/rewrite-hoc-clk/common/src/psm_ext.c
+++ b/Source/rewrite-hoc-clk/common/src/psm_ext.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) KazushiMe
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ * 
+ */
+ 
+#include <sysclk/psm_ext.h>
+
+const char* PsmPowerRoleToStr(PsmPowerRole role) {
+    switch (role) {
+        case PsmPowerRole_Sink:     return "Sink";
+        case PsmPowerRole_Source:   return "Source";
+        default:                    return "Unknown";
+    }
+}
+
+const char* PsmInfoChargerTypeToStr(PsmInfoChargerType type) {
+    switch (type) {
+        case PsmInfoChargerType_None:           return "None";
+        case PsmInfoChargerType_PD:             return "USB-C PD";
+        case PsmInfoChargerType_TypeC_1500mA:
+        case PsmInfoChargerType_TypeC_3000mA:   return "USB-C";
+        case PsmInfoChargerType_DCP:            return "USB DCP";
+        case PsmInfoChargerType_CDP:            return "USB CDP";
+        case PsmInfoChargerType_SDP:            return "USB SDP";
+        case PsmInfoChargerType_Apple_500mA:
+        case PsmInfoChargerType_Apple_1000mA:
+        case PsmInfoChargerType_Apple_2000mA:   return "Apple";
+        default:                                return "Unknown";
+    }
+}
+
+bool PsmIsChargerConnected(const PsmChargeInfo* info) {
+    return info->ChargerType != PsmInfoChargerType_None;
+}
+
+bool PsmIsCharging(const PsmChargeInfo* info) {
+    return PsmIsChargerConnected(info) && ((info->unk_x14 >> 8) & 1);
+}
+
+PsmBatteryState PsmGetBatteryState(const PsmChargeInfo* info) {
+    if (!PsmIsChargerConnected(info))
+        return PsmBatteryState_Discharging;
+    if (!PsmIsCharging(info))
+        return PsmBatteryState_ChargingPaused;
+    return PsmBatteryState_FastCharging;
+}
+
+const char* PsmGetBatteryStateIcon(const PsmChargeInfo* info) {
+    switch (PsmGetBatteryState(info)) {
+        case PsmBatteryState_Discharging:   return "\u25c0"; // ◀
+        case PsmBatteryState_ChargingPaused:return "| |";
+        case PsmBatteryState_FastCharging:  return "\u25b6"; // ▶
+        default:                            return "?";
+    }
+}
--- a/Source/rewrite-hoc-clk/common/src/pwm.c
+++ b/Source/rewrite-hoc-clk/common/src/pwm.c
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) MasaGratoR
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+#define NX_SERVICE_ASSUME_NON_DOMAIN
+#include <switch.h>
+#include "service_guard.h"
+#include "pwm.h"
+
+static Service g_pwmSrv;
+
+NX_GENERATE_SERVICE_GUARD(pwm);
+
+Result _pwmInitialize(void) {
+    return smGetService(&g_pwmSrv, "pwm");
+}
+
+void _pwmCleanup(void) {
+    serviceClose(&g_pwmSrv);
+}
+
+Service* pwmGetServiceSession(void) {
+    return &g_pwmSrv;
+}
+
+Result pwmOpenSession2(PwmChannelSession *out, u32 device_code) {
+    return serviceDispatchIn(&g_pwmSrv, 2, device_code,
+        .out_num_objects = 1,
+        .out_objects = &out->s,
+    );
+}
+
+Result pwmChannelSessionGetDutyCycle(PwmChannelSession *c, double* out) {
+    return serviceDispatchOut(&c->s, 7, *out);
+}
+
+void pwmChannelSessionClose(PwmChannelSession *controller) {
+    serviceClose(&controller->s);
+}
--- a/Source/rewrite-hoc-clk/common/src/rgltr_services.cpp
+++ b/Source/rewrite-hoc-clk/common/src/rgltr_services.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) ppkantorski (bord2death)
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+#include <switch.h>
+#include "rgltr.h"
+#include "rgltr_services.h"  // for extern Service g_rgltrSrv, etc.
+
+// Global service handle
+Service g_rgltrSrv;
+
+Result rgltrInitialize(void) {
+    if (hosversionBefore(8, 0, 0)) {
+        return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
+    }
+    return smGetService(&g_rgltrSrv, "rgltr");
+}
+
+void rgltrExit(void) {
+    serviceClose(&g_rgltrSrv);
+}
+
+Result rgltrOpenSession(RgltrSession* session_out, PowerDomainId module_id) {
+    const u32 in = (u32)module_id;
+    return serviceDispatchIn(
+        &g_rgltrSrv,
+        0,
+        in,
+        .out_num_objects = 1,
+        .out_objects     = &session_out->s
+    );
+}
+
+Result rgltrGetVoltage(RgltrSession* session, u32* out_volt) {
+    u32 temp = 0;
+    Result rc = serviceDispatchOut(&session->s, 4, temp);
+    if (R_SUCCEEDED(rc)) {
+        *out_volt = temp;
+    }
+    return rc;
+}
+
+Result rgltrRequestVoltage(RgltrSession* session, u32 microvolt) {
+    return serviceDispatchIn(&session->s, 5, microvolt);
+}
+
+Result rgltrCancelVoltageRequest(RgltrSession* session) {
+    return serviceDispatch(&session->s, 6);
+}
+
+void rgltrCloseSession(RgltrSession* session) {
+    serviceClose(&session->s);
+}