290 lines
7.8 KiB
C
290 lines
7.8 KiB
C
/*
|
|
* Copyright (c) 2020-2023 CTCaer
|
|
* Copyright (c) 2023 p-sam
|
|
*
|
|
* 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 "nxExt/t210.h"
|
|
|
|
#define WAIT_NS 1000000000UL
|
|
|
|
#define usleep(x) svcSleepThread(1000UL * x)
|
|
|
|
#define GPU_TRIM_SYS_GPCPLL_COEFF 0x4
|
|
#define GPU_TRIM_SYS_GPCPLL(x) (*(volatile u32 *)(g_gpu_base + 0x137000ul + (x)))
|
|
|
|
#define CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL 0x60
|
|
#define CLK_RST_CONTROLLER_PTO_CLK_CNT_STATUS 0x64
|
|
#define CLK_RST_CONTROLLER_CLK_OUT_ENB_X 0x280
|
|
#define CLK_RST_CONTROLLER_RST_DEVICES_X 0x28C
|
|
|
|
/*! PTO_CLK_CNT */
|
|
#define PTO_REF_CLK_WIN_CFG_MASK 0xF
|
|
#define PTO_REF_CLK_WIN_CFG_16P 0xF
|
|
#define PTO_CNT_EN BIT(9)
|
|
#define PTO_CNT_RST BIT(10)
|
|
#define PTO_CLK_ENABLE BIT(13)
|
|
#define PTO_SRC_SEL_SHIFT 14
|
|
#define PTO_SRC_SEL_MASK 0x1FF
|
|
#define PTO_DIV_SEL_MASK (3 << 23)
|
|
#define PTO_DIV_SEL_GATED (0 << 23)
|
|
#define PTO_DIV_SEL_DIV1 (1 << 23)
|
|
#define PTO_DIV_SEL_DIV2_RISING (2 << 23)
|
|
#define PTO_DIV_SEL_DIV2_FALLING (3 << 23)
|
|
#define PTO_DIV_SEL_CPU_EARLY (0 << 23)
|
|
#define PTO_DIV_SEL_CPU_LATE (1 << 23)
|
|
|
|
#define PTO_CLK_CNT_BUSY BIT(31)
|
|
#define PTO_CLK_CNT 0xFFFFFF
|
|
#define CLK_PTO_CCLK_G 0x12
|
|
#define CLK_PTO_EMC 0x24
|
|
|
|
#define CLOCK(x) (*(volatile u32 *)(g_clk_base + (x)))
|
|
|
|
/* Actmon Global registers */
|
|
#define ACTMON_GLB_STATUS 0x0
|
|
#define ACTMON_MCCPU_MON_ACT BIT(8)
|
|
#define ACTMON_MCALL_MON_ACT BIT(9)
|
|
#define ACTMON_CPU_FREQ_MON_ACT BIT(10)
|
|
#define ACTMON_BPMP_MON_ACT BIT(14)
|
|
#define ACTMON_CPU_MON_ACT BIT(15)
|
|
|
|
#define ACTMON_GLB_PERIOD_CTRL 0x4
|
|
#define ACTMON_GLB_PERIOD_USEC BIT(8)
|
|
#define ACTMON_GLB_PERIOD_SAMPLE(n) (((n) - 1) & 0xFF)
|
|
|
|
/* Actmon Device Registers */
|
|
#define ACTMON_DEV_SIZE 0x40
|
|
/* Actmon CTRL */
|
|
#define ACTMON_DEV_CTRL_K_VAL(k) (((k) & 7) << 10)
|
|
#define ACTMON_DEV_CTRL_ENB_PERIODIC BIT(18)
|
|
#define ACTMON_DEV_CTRL_ENB BIT(31)
|
|
|
|
#define ACTMON_PERIOD_MS 20
|
|
#define DEV_COUNT_WEIGHT 1024
|
|
|
|
#define ACTMON_BASE (g_act_base + 0x800)
|
|
#define ACTMON_DEV_BASE (ACTMON_BASE + 0x80)
|
|
#define ACTMON(x) (*(volatile u32 *)(ACTMON_BASE + (x)))
|
|
|
|
typedef enum _actmon_dev_t
|
|
{
|
|
ACTMON_DEV_CPU,
|
|
ACTMON_DEV_BPMP,
|
|
ACTMON_DEV_AHB,
|
|
ACTMON_DEV_APB,
|
|
ACTMON_DEV_CPU_FREQ,
|
|
ACTMON_DEV_MC_ALL,
|
|
ACTMON_DEV_MC_CPU,
|
|
|
|
ACTMON_DEV_NUM,
|
|
} actmon_dev_t;
|
|
|
|
typedef struct _actmon_dev_reg_t
|
|
{
|
|
vu32 ctrl;
|
|
vu32 upper_wnark;
|
|
vu32 lower_wmark;
|
|
vu32 init_avg;
|
|
vu32 avg_upper_wmark;
|
|
vu32 avg_lower_wmark;
|
|
vu32 count_weight;
|
|
vu32 count;
|
|
vu32 avg_count;
|
|
vu32 intr_status;
|
|
vu32 ctrl2;
|
|
vu32 rsvd[5];
|
|
} actmon_dev_reg_t;
|
|
|
|
static uintptr_t g_clk_base = 0;
|
|
static uintptr_t g_gpu_base = 0;
|
|
static uintptr_t g_act_base = 0;
|
|
static u64 g_update_ticks = 0;
|
|
static u32 g_cpu_freq = 0;
|
|
static u32 g_gpu_freq = 0;
|
|
static u32 g_mem_freq = 0;
|
|
static u32 g_emc_lall = 0;
|
|
static u32 g_emc_lcpu = 0;
|
|
|
|
static u32 _clock_get_dev_freq(u32 id)
|
|
{
|
|
const u32 pto_win = 16;
|
|
const u32 pto_osc = 32768;
|
|
|
|
u32 val = ((id & PTO_SRC_SEL_MASK) << PTO_SRC_SEL_SHIFT) | PTO_DIV_SEL_DIV1 | PTO_CLK_ENABLE | (pto_win - 1);
|
|
CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL) = val;
|
|
(void)CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL);
|
|
usleep(2);
|
|
|
|
CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL) = val | PTO_CNT_RST;
|
|
(void)CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL);
|
|
usleep(2);
|
|
|
|
CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL) = val;
|
|
(void)CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL);
|
|
usleep(2);
|
|
|
|
CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL) = val | PTO_CNT_EN;
|
|
(void)CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL);
|
|
usleep((1000000ULL * pto_win / pto_osc) + 12 + 2); // 502 us.
|
|
|
|
while (CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_STATUS) & PTO_CLK_CNT_BUSY)
|
|
;
|
|
|
|
u32 cnt = CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_STATUS) & PTO_CLK_CNT;
|
|
|
|
CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL) = 0;
|
|
(void)CLOCK(CLK_RST_CONTROLLER_PTO_CLK_CNT_CNTL);
|
|
usleep(2);
|
|
|
|
u32 freq_khz = (u64)cnt * pto_osc / pto_win / 1000;
|
|
|
|
return freq_khz;
|
|
}
|
|
|
|
static void _actmon_dev_enable(actmon_dev_t dev, u32 freq, u32 weight)
|
|
{
|
|
actmon_dev_reg_t *regs = (actmon_dev_reg_t *)(ACTMON_DEV_BASE + (dev * ACTMON_DEV_SIZE));
|
|
|
|
regs->init_avg = (u32)freq * ACTMON_PERIOD_MS / 2;
|
|
regs->count_weight = weight;
|
|
|
|
regs->ctrl = ACTMON_DEV_CTRL_ENB | ACTMON_DEV_CTRL_ENB_PERIODIC | ACTMON_DEV_CTRL_K_VAL(3); // 8 samples average.
|
|
}
|
|
|
|
static u32 _actmon_dev_get_count_avg(actmon_dev_t dev)
|
|
{
|
|
actmon_dev_reg_t *regs = (actmon_dev_reg_t *)(ACTMON_DEV_BASE + (dev * ACTMON_DEV_SIZE));
|
|
|
|
return regs->avg_count;
|
|
}
|
|
|
|
static inline Result _svcQueryMemoryMappingFallback(u64* virtaddr, u64 physaddr, u64 size)
|
|
{
|
|
if(hosversionAtLeast(10,0,0))
|
|
{
|
|
u64 out_size;
|
|
return svcQueryMemoryMapping(virtaddr, &out_size, physaddr, size);
|
|
}
|
|
else
|
|
{
|
|
return svcLegacyQueryIoMapping(virtaddr, physaddr, size);
|
|
}
|
|
}
|
|
|
|
static void _clock_update_freqs(void)
|
|
{
|
|
u64 ticks = armGetSystemTick();
|
|
if(armTicksToNs(ticks - g_update_ticks) <= WAIT_NS)
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_update_ticks = ticks;
|
|
|
|
if (!g_clk_base)
|
|
{
|
|
_svcQueryMemoryMappingFallback(&g_clk_base, 0x60006000ul, 0x1000);
|
|
}
|
|
|
|
if(!g_clk_base)
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_mem_freq = _clock_get_dev_freq(CLK_PTO_EMC) * 1000;
|
|
g_cpu_freq = _clock_get_dev_freq(CLK_PTO_CCLK_G) * 1000;
|
|
|
|
if (!g_gpu_base)
|
|
{
|
|
_svcQueryMemoryMappingFallback(&g_gpu_base, 0x57000000ul, 0x1000000);
|
|
}
|
|
|
|
if (!g_gpu_base)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool gpu_enabled = (CLOCK(CLK_RST_CONTROLLER_CLK_OUT_ENB_X) & BIT(24)) && !(CLOCK(CLK_RST_CONTROLLER_RST_DEVICES_X) & BIT(24));
|
|
if(!gpu_enabled)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!g_act_base)
|
|
{
|
|
_svcQueryMemoryMappingFallback(&g_act_base, 0x6000C000ul, 0x1000);
|
|
}
|
|
|
|
if(!g_act_base)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const u32 osc = 38400000;
|
|
u32 coeff = GPU_TRIM_SYS_GPCPLL(GPU_TRIM_SYS_GPCPLL_COEFF);
|
|
u32 divm = coeff & 0xFF;
|
|
u32 divn = (coeff >> 8) & 0xFF;
|
|
u32 divp = (coeff >> 16) & 0x3F;
|
|
g_gpu_freq = osc * divn / (divm * divp) / 2;
|
|
|
|
u32 emc_freq = g_mem_freq / 1000;
|
|
|
|
// Check if actmon is disabled
|
|
if (!(ACTMON(ACTMON_GLB_STATUS) & ACTMON_MCALL_MON_ACT))
|
|
{
|
|
ACTMON(ACTMON_GLB_PERIOD_CTRL) = ACTMON_GLB_PERIOD_SAMPLE(ACTMON_PERIOD_MS);
|
|
_actmon_dev_enable(ACTMON_DEV_MC_ALL, emc_freq, 256 * 4);
|
|
}
|
|
|
|
// Check if actmon is disabled
|
|
if (!(ACTMON(ACTMON_GLB_STATUS) & ACTMON_MCCPU_MON_ACT))
|
|
_actmon_dev_enable(ACTMON_DEV_MC_CPU, emc_freq, 256 * 4);
|
|
|
|
// Get 1000 -> 100.0.
|
|
g_emc_lall = (u64)_actmon_dev_get_count_avg(ACTMON_DEV_MC_ALL) * 10 * 100 / (emc_freq * ACTMON_PERIOD_MS);
|
|
g_emc_lcpu = (u64)_actmon_dev_get_count_avg(ACTMON_DEV_MC_CPU) * 10 * 100 / (emc_freq * ACTMON_PERIOD_MS);
|
|
}
|
|
|
|
|
|
u32 t210ClkCpuFreq(void)
|
|
{
|
|
_clock_update_freqs();
|
|
return g_cpu_freq;
|
|
}
|
|
|
|
u32 t210ClkMemFreq(void)
|
|
{
|
|
_clock_update_freqs();
|
|
return g_mem_freq;
|
|
}
|
|
|
|
u32 t210ClkGpuFreq(void)
|
|
{
|
|
_clock_update_freqs();
|
|
return g_gpu_freq;
|
|
}
|
|
|
|
u32 t210EmcLoadAll()
|
|
{
|
|
_clock_update_freqs();
|
|
return g_emc_lall;
|
|
}
|
|
|
|
u32 t210EmcLoadCpu()
|
|
{
|
|
_clock_update_freqs();
|
|
return g_emc_lcpu;
|
|
}
|