Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

@@ -0,0 +1,26 @@
ccflags-y += -I$(srctree)/drivers/misc/mediatek/lpm/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/include/power_gs_v1
ccflags-y += -I$(srctree)/drivers/misc/mediatek/lpm/inc/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/lpm/mtk_lpm_fs/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/lpm/inc/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/lpm/modules/include/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/lpm/modules/include/mt6853/
obj-y += mt6853_dbg_fs.o
obj-y += mt6853_dbg_lpm_fs.o
obj-y += mt6853_dbg_lpm_rc_fs.o
obj-y += mt6853_dbg_spm_fs.o
obj-y += mt6853_logger.o
obj-y += mt6853_lpm_trace_event.o
obj-y += mt6853_cpupm_dbg.o
mt6853_cpupm_dbg-y += mtk_cpupm_dbg.o
mt6853_cpupm_dbg-y += mtk_cpuidle_status.o
mt6853_cpupm_dbg-y += mtk_cpuidle_cpc.o
mt6853_cpupm_dbg-y += mtk_idle_procfs.o
mt6853_cpupm_dbg-y += mtk_idle_procfs_state.o
mt6853_cpupm_dbg-y += mtk_idle_procfs_cpc.o
mt6853_cpupm_dbg-y += mtk_idle_procfs_profile.o
mt6853_cpupm_dbg-y += mtk_idle_procfs_control.o
@@ -0,0 +1,37 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <mtk_dbg_common_v1.h>
#include <mtk_lpm_module.h>
#include <mt6853_dbg_fs_common.h>
static void __exit mt6853_dbg_fs_exit(void)
{
mt6853_dbg_lpm_fs_deinit();
mt6853_dbg_spm_fs_deinit();
mt6853_dbg_lpm_deinit();
mtk_dbg_common_fs_exit();
}
static int __init mt6853_dbg_fs_init(void)
{
mt6853_dbg_lpm_init();
mt6853_dbg_lpm_fs_init();
mt6853_dbg_spm_fs_init();
mtk_dbg_common_fs_init();
pr_info("%s %d: finish", __func__, __LINE__);
return 0;
}
module_init(mt6853_dbg_fs_init);
module_exit(mt6853_dbg_fs_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("MT6853 Low Power FileSystem");
MODULE_AUTHOR("MediaTek Inc.");
@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT6853_DBG_FS_COMMON_H__
#define __MT6853_DBG_FS_COMMON_H__
/* Determine for user name handle */
#define MT_LP_RQ_USER_NAME_LEN (4)
#define MT_LP_RQ_USER_CHAR_U (8)
#define MT_LP_RQ_USER_CHAR_MASK (0xFF)
/* Determine for resource usage id */
#define MT_LP_RQ_ID_ALL_USAGE (-1)
int mt6853_dbg_lpm_init(void);
int mt6853_dbg_lpm_deinit(void);
int mt6853_dbg_lpm_fs_init(void);
int mt6853_dbg_lpm_fs_deinit(void);
int mt6853_dbg_spm_fs_init(void);
int mt6853_dbg_spm_fs_deinit(void);
#endif /* __MTK_LP_PLAT_FS_H__ */
@@ -0,0 +1,233 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/device.h>
#include <linux/of_device.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <mtk_dbg_common_v1.h>
#include <mtk_lpm_module.h>
#include <mtk_resource_constraint_v1.h>
#include <mt6853_pwr_ctrl.h>
#include <mt6853_dbg_fs_common.h>
#include <mt6853_cond.h>
#include <mt6853_spm_comm.h>
#include <mtk_lpm_sysfs.h>
#include <mtk_lp_sysfs.h>
#include <mtk_lpm_platform.h>
#define MT6853_GENERIC_TRACE_NODE_INIT(_n, _r, _w) ({\
_n.op.fs_read = _r;\
_n.op.fs_write = _w;\
_n.op.priv = &_n; })
#define mt6853_dbg_lpm_trace_log(buf, sz, len, fmt, args...) ({\
if (len < sz)\
len += scnprintf(buf + len, sz - len,\
fmt, ##args); })
/* Common section */
#define MT6853_DGB_TRACE_COMMON_BASE (0x0)
#define MT6853_DGB_TRACE_COMMON_SZ (0x20)
#define TRACE_DBG_LAST_RC_INFO_CPU_SHIFT (28)
#define TRACE_DBG_LAST_RC_INFO_CPU_MASK (0xf)
#define TRACE_DBG_LAST_RC_INFO_RCID_SHIFT (0)
#define TRACE_DBG_LAST_RC_INFO_RCID_MASK (0xffff)
#define TRACE_DBG_LAST_RC_INFO_CPU(info)\
((info >> TRACE_DBG_LAST_RC_INFO_CPU_SHIFT)\
& TRACE_DBG_LAST_RC_INFO_CPU_MASK)
#define TRACE_DBG_LAST_RC_INFO_RC_ID(info)\
((info >> TRACE_DBG_LAST_RC_INFO_RCID_SHIFT)\
& TRACE_DBG_LAST_RC_INFO_RCID_MASK)
/* Suspend section */
#define MT6853_DGB_TRACE_SUSPEND_BASE \
(MT6853_DGB_TRACE_COMMON_BASE + MT6853_DGB_TRACE_COMMON_SZ)
#define MT6853_DGB_TRACE_SUSPEND_SZ (0xe0)
/* Low power section */
#define MT6853_DGB_TRACE_LP_BASE \
(MT6853_DGB_TRACE_SUSPEND_BASE + MT6853_DGB_TRACE_SUSPEND_SZ)
#define MT6853_DGB_TRACE_LP_SZ (0x200)
struct MT6853_LPM_TRACE_NODE {
struct mtk_lp_sysfs_handle handle;
struct mtk_lp_sysfs_op op;
};
struct mtk_lp_sysfs_handle mt6853_entry_lpm_trace;
struct MT6853_LPM_TRACE_NODE mt6853_lpm_trace_node_comm;
struct MT6853_LPM_TRACE_NODE mt6853_lpm_trace_node_lp;
struct MT6853_LPM_TRACE_NODE mt6853_lpm_trace_node_suspend;
struct MT6853_TRACE_COMM {
unsigned int magic;
unsigned int common_fp;
unsigned int rc_timestamp_h;
unsigned int rc_timestamp_l;
unsigned int rc_info;
unsigned int rc_fp;
unsigned int rc_valid;
};
static ssize_t mt6853_dbg_lpm_trace_suspend_show(char *ToUserBuf,
size_t sz, void *priv)
{
struct MTK_LPM_PLAT_TRACE trace;
unsigned int dump[4], offset = 0;
size_t len = 0;
int ret = 0;
ret = mtk_lpm_platform_trace_get(MT_LPM_PLAT_TRACE_SYSRAM, &trace);
if (ret || !trace.read)
return -ENOENT;
while (((offset + sizeof(dump)) < MT6853_DGB_TRACE_SUSPEND_SZ)) {
dump[0] = dump[1] = dump[2] = dump[3] = 0;
trace.read((MT6853_DGB_TRACE_SUSPEND_BASE + offset),
dump, sizeof(dump));
mt6853_dbg_lpm_trace_log(ToUserBuf, sz, len,
"%03xh: %08x %08x %08x %08x\n", offset,
dump[0], dump[1], dump[2], dump[3]);
offset += sizeof(dump);
}
return len;
}
static ssize_t mt6853_dbg_lpm_trace_lp_show(char *ToUserBuf,
size_t sz, void *priv)
{
struct MTK_LPM_PLAT_TRACE trace;
unsigned int dump[4], offset = 0;
size_t len = 0;
int ret = 0;
ret = mtk_lpm_platform_trace_get(MT_LPM_PLAT_TRACE_SYSRAM, &trace);
if (ret || !trace.read)
return -ENOENT;
while (((offset + sizeof(dump)) <= MT6853_DGB_TRACE_LP_SZ)) {
dump[0] = dump[1] = dump[2] = dump[3] = 0;
trace.read((MT6853_DGB_TRACE_LP_BASE + offset),
dump, sizeof(dump));
mt6853_dbg_lpm_trace_log(ToUserBuf, sz, len,
"%03xh: %08x %08x %08x %08x\n", offset,
dump[0], dump[1], dump[2], dump[3]);
offset += sizeof(dump);
}
return len;
}
static ssize_t mt6853_dbg_lpm_trace_comm_show(char *ToUserBuf,
size_t sz, void *priv)
{
struct MTK_LPM_PLAT_TRACE trace;
struct MT6853_TRACE_COMM *data = NULL;
size_t len = 0, rSz = 0;
int ret = 0;
ret = mtk_lpm_platform_trace_get(MT_LPM_PLAT_TRACE_SYSRAM, &trace);
if (ret || !trace.read)
return -ENOENT;
data = kzalloc(sizeof(struct MT6853_TRACE_COMM),
GFP_KERNEL);
if (!data)
return -ENOMEM;
rSz = (sizeof(struct MT6853_TRACE_COMM) > MT6853_DGB_TRACE_COMMON_SZ) ?
MT6853_DGB_TRACE_COMMON_SZ : sizeof(struct MT6853_TRACE_COMM);
len = trace.read(MT6853_DGB_TRACE_COMMON_BASE, data, rSz);
if (len > 0) {
unsigned long long timestamp;
len = 0;
timestamp = data->rc_timestamp_h;
timestamp = (timestamp << 32) | data->rc_timestamp_l;
mt6853_dbg_lpm_trace_log(ToUserBuf, sz, len,
"magic: 0x%x\n", data->magic);
mt6853_dbg_lpm_trace_log(ToUserBuf, sz, len,
"common_footfprint: 0x%x\n", data->common_fp);
mt6853_dbg_lpm_trace_log(ToUserBuf, sz, len,
"timestamp: %llu.%03llu\n",
timestamp/1000000000,
timestamp%1000000000);
mt6853_dbg_lpm_trace_log(ToUserBuf, sz, len,
"last constriant\n - cpu:%d\n - rc_id:%d\n - valid:0x%x\n",
TRACE_DBG_LAST_RC_INFO_CPU(data->rc_info),
TRACE_DBG_LAST_RC_INFO_RC_ID(data->rc_info),
data->rc_valid);
}
kfree(data);
return sz;
}
int mt6853_dbg_lpm_init(void)
{
mtk_lpm_sysfs_root_entry_create();
mtk_lpm_sysfs_sub_entry_add("trace", 0644, NULL,
&mt6853_entry_lpm_trace);
MT6853_GENERIC_TRACE_NODE_INIT(mt6853_lpm_trace_node_comm,
mt6853_dbg_lpm_trace_comm_show,
NULL);
mtk_lpm_sysfs_sub_entry_node_add("common", 0400,
&mt6853_lpm_trace_node_comm.op,
&mt6853_entry_lpm_trace,
&mt6853_lpm_trace_node_comm.handle);
MT6853_GENERIC_TRACE_NODE_INIT(mt6853_lpm_trace_node_lp,
mt6853_dbg_lpm_trace_lp_show,
NULL);
mtk_lpm_sysfs_sub_entry_node_add("lp", 0400,
&mt6853_lpm_trace_node_lp.op,
&mt6853_entry_lpm_trace,
&mt6853_lpm_trace_node_lp.handle);
MT6853_GENERIC_TRACE_NODE_INIT(mt6853_lpm_trace_node_suspend,
mt6853_dbg_lpm_trace_suspend_show,
NULL);
mtk_lpm_sysfs_sub_entry_node_add("suspend", 0400,
&mt6853_lpm_trace_node_suspend.op,
&mt6853_entry_lpm_trace,
&mt6853_lpm_trace_node_suspend.handle);
return 0;
}
int mt6853_dbg_lpm_deinit(void)
{
mtk_lpm_sysfs_entry_node_remove(&mt6853_lpm_trace_node_suspend.handle);
mtk_lpm_sysfs_entry_node_remove(&mt6853_lpm_trace_node_lp.handle);
mtk_lpm_sysfs_entry_node_remove(&mt6853_lpm_trace_node_comm.handle);
mtk_lpm_sysfs_entry_node_remove(&mt6853_entry_lpm_trace);
return 0;
}
@@ -0,0 +1,619 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/console.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/spinlock.h>
#include <mtk_dbg_common_v1.h>
#include <mtk_lpm_module.h>
#include <mtk_resource_constraint_v1.h>
#include <mt6853_pwr_ctrl.h>
#include <mt6853_dbg_fs_common.h>
#include <mt6853_cond.h>
#include <mt6853_spm_comm.h>
#include <mtk_lpm_sysfs.h>
#include <mtk_lp_sysfs.h>
#include <mtk_lpm_timer.h>
#define SPM_RC_UPDATE_COND_ID_MASK 0xffff
#define SPM_RC_UPDATE_COND_RC_ID_MASK 0xffff
#define SPM_RC_UPDATE_COND_RC_ID_SHIFT (16)
#define SPM_RC_UPDATE_COND_CTRL_ID(rc, cond)\
(((rc & SPM_RC_UPDATE_COND_RC_ID_MASK)\
<< SPM_RC_UPDATE_COND_RC_ID_SHIFT)\
| (cond & SPM_RC_UPDATE_COND_ID_MASK))
#define MT6853_LPM_RC_RATIO_DEFAULT 10000
#define mt6853_rc_log(buf, sz, len, fmt, args...) ({\
if (len < sz)\
len += scnprintf(buf + len, sz - len,\
fmt, ##args); })
#define MT6853_DBG_SMC(_id, _act, _rc, _param) ({\
(unsigned long)mtk_lpm_smc_spm_dbg(_id, _act, _rc, _param); })
enum MT6853_RC_RATIO_TYPE {
MT6853_RC_RATIO_UNKNOWN,
MT6853_RC_RATIO_ENABLE,
MT6853_RC_RATIO_DISABLE,
MT6853_RC_RATIO_ENABLE_INFO,
MT6853_RC_RATIO_INFO,
};
enum MT6853_RC_NODE_TYPE {
MT6853_RC_NODE_STATE,
MT6853_RC_NODE_RC_ENABLE,
MT6853_RC_NODE_RC_STATE_SIMPLE,
MT6853_RC_NODE_RC_STATE,
MT6853_RC_NODE_COND_ENABLE,
MT6853_RC_NODE_COND_STATE,
MT6853_RC_NODE_COND_SET,
MT6853_RC_NODE_COND_CLR,
MT6853_RC_NODE_RATIO_ENABLE,
MT6853_RC_NODE_RATIO_INTERVAL,
MT6853_RC_NODE_VALID_BBLPM,
MT6853_RC_NODE_VALID_TRACE,
MT6853_RC_NODE_VALID_TIMESTAMP,
MT6853_RC_NODE_MAX
};
struct MT6853_RC_NODE {
const char *name;
int rc_id;
int type;
struct mtk_lp_sysfs_handle handle;
struct mtk_lp_sysfs_op op;
};
struct MT6853_RC_ENTERY {
const char *name;
struct mtk_lp_sysfs_handle handle;
};
struct MT6853_RC_COND_HANDLES {
struct MT6853_RC_ENTERY root;
struct MT6853_RC_NODE hSet;
struct MT6853_RC_NODE hClr;
struct MT6853_RC_NODE hState;
struct MT6853_RC_NODE hEnable;
};
struct MT6853_RC_VALID_HANDLES {
struct MT6853_RC_ENTERY root;
struct MT6853_RC_NODE hBblpm;
struct MT6853_RC_NODE hTrace;
struct MT6853_RC_NODE hTimestamp;
};
struct MT6853_RC_RATIO_HANDLES {
struct MT6853_RC_ENTERY root;
struct MT6853_RC_NODE hInterval;
struct MT6853_RC_NODE hEnable;
};
struct MT6853_RC_HANDLE_BASIC {
struct MT6853_RC_ENTERY root;
struct MT6853_RC_NODE hEnable;
struct MT6853_RC_NODE hState;
};
struct MT6853_RC_HANDLE {
struct MT6853_RC_HANDLE_BASIC basic;
struct MT6853_RC_COND_HANDLES hCond;
struct MT6853_RC_VALID_HANDLES valid;
};
#define MT6853_CONSTRAINT_GENERIC_OP(op, _priv) ({\
op.fs_read = mt6853_generic_rc_read;\
op.fs_write = mt6853_generic_rc_write;\
op.priv = _priv; })
#define MT6853_GENERIC_RC_NODE_INIT(_n, _name, _id, _type) ({\
_n.name = _name;\
_n.type = _type;\
_n.rc_id = _id;\
MT6853_CONSTRAINT_GENERIC_OP(_n.op, &_n); })
struct mtk_lp_sysfs_handle mt6853_entry_rc;
struct MT6853_RC_HANDLE rc_dram;
struct MT6853_RC_HANDLE rc_syspll;
struct MT6853_RC_HANDLE rc_bus26m;
struct MT6853_RC_HANDLE_BASIC rc_cpu_buckldo;
struct MT6853_RC_RATIO_HANDLES rc_Ratio;
struct MT6853_RC_NODE rc_state;
struct mt_lpm_timer rc_ratio_timer;
static char *mt6853_spm_cond_cg_str[PLAT_SPM_COND_MAX] = {
[PLAT_SPM_COND_MTCMOS_0] = "MTCMOS_0",
[PLAT_SPM_COND_CG_INFRA_0] = "INFRA_0",
[PLAT_SPM_COND_CG_INFRA_1] = "INFRA_1",
[PLAT_SPM_COND_CG_INFRA_2] = "INFRA_2",
[PLAT_SPM_COND_CG_INFRA_3] = "INFRA_3",
[PLAT_SPM_COND_CG_INFRA_4] = "INFRA_4",
[PLAT_SPM_COND_CG_INFRA_5] = "INFRA_5",
[PLAT_SPM_COND_CG_MMSYS_0] = "MMSYS_0",
[PLAT_SPM_COND_CG_MMSYS_1] = "MMSYS_1",
[PLAT_SPM_COND_CG_MMSYS_2] = "MMSYS_2",
[PLAT_SPM_COND_CG_MMSYS_3] = "MMSYS_3",
};
static char *mt6853_spm_cond_pll_str[PLAT_SPM_COND_PLL_MAX] = {
[PLAT_SPM_COND_UNIVPLL] = "UNIVPLL",
[PLAT_SPM_COND_MFGPLL] = "MFGPLL",
[PLAT_SPM_COND_MSDCPLL] = "MSDCPLL",
[PLAT_SPM_COND_TVPLL] = "TVPLL",
[PLAT_SPM_COND_MMPLL] = "MMPLL",
};
int mt6853_lpm_rc_cond_ctrl(int rc_id, unsigned int act,
unsigned int cond_id, unsigned int value)
{
unsigned int cond_ctrl_id;
int res = 0;
cond_ctrl_id = SPM_RC_UPDATE_COND_CTRL_ID(rc_id, cond_id);
if (cond_id < PLAT_SPM_COND_MAX)
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_COND_CTRL,
act, cond_ctrl_id, value);
else if ((cond_id - PLAT_SPM_COND_MAX) < PLAT_SPM_COND_PLL_MAX)
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_COND_CTRL,
act, cond_ctrl_id, !!value);
else
pr_info("[%s:%d] - unknown cond id = %u\n",
__func__, __LINE__, cond_id);
return res;
}
int mt6853_lpm_rc_ratio_timer_func(unsigned long long dur, void *priv)
{
/* spm tick to ms: tick/32 (ms) */
#define RC_RESIDENCY_COVERT(x) (x>>5)
#define RC_COVERT_RATIO(dur, x)\
((RC_RESIDENCY_COVERT(x) * 100)/dur)
unsigned long long rc_dram_t;
unsigned long long rc_syspll_t;
unsigned long long rc_bus26m_t;
rc_dram_t = (unsigned long long)
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_RES_INFO,
(MT_LPM_SMC_ACT_GET | MT_LPM_SMC_ACT_CLR),
MT_RM_CONSTRAINT_ID_DRAM, 0);
rc_syspll_t = (unsigned long long)
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_RES_INFO,
(MT_LPM_SMC_ACT_GET | MT_LPM_SMC_ACT_CLR),
MT_RM_CONSTRAINT_ID_SYSPLL, 0);
rc_bus26m_t = (unsigned long long)
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_RES_INFO,
(MT_LPM_SMC_ACT_GET | MT_LPM_SMC_ACT_CLR),
MT_RM_CONSTRAINT_ID_BUS26M, 0);
pr_info("[name:spm&][RC] ratio, duration_ms:%llu, dram:%llu%%, syspll:%llu%%, bus26m:%llu%%\n",
dur, RC_COVERT_RATIO(dur, rc_dram_t),
RC_COVERT_RATIO(dur, rc_syspll_t),
RC_COVERT_RATIO(dur, rc_bus26m_t));
return 0;
}
static ssize_t mt6853_lpm_rc_block_info(int rc_id,
char *ToUserBuf,
size_t sz)
{
uint32_t block, b;
int i;
ssize_t len = 0;
block = (uint32_t)
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_COND_BLOCK,
MT_LPM_SMC_ACT_GET, rc_id, 0);
b = (uint32_t)
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_COND_CHECK,
MT_LPM_SMC_ACT_GET, rc_id, 0);
mt6853_rc_log(ToUserBuf, sz, len,
"blocked=%u, blocked_cond=0x%08x\n",
b, block);
for (i = 0, b = block >> SPM_COND_BLOCKED_CG_IDX;
i < PLAT_SPM_COND_MAX; i++)
mt6853_rc_log(ToUserBuf, sz, len,
"[%2d] %8s=0x%08lx\n", i,
mt6853_spm_cond_cg_str[i],
((b >> i) & 0x1) ?
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_BLOCK_DETAIL,
MT_LPM_SMC_ACT_GET, rc_id, i) : 0);
for (i = 0, b = block >> SPM_COND_BLOCKED_PLL_IDX;
i < PLAT_SPM_COND_PLL_MAX; i++)
mt6853_rc_log(ToUserBuf, sz, len,
"[%2d] %8s=%d\n",
(i + PLAT_SPM_COND_MAX),
mt6853_spm_cond_pll_str[i],
((b >> i) & 0x1));
return len;
}
static ssize_t mt6853_rc_state(int rc_id, char *ToUserBuf, size_t sz)
{
ssize_t len = 0;
if (rc_id < 0)
return 0;
mt6853_rc_log(ToUserBuf, sz, len,
"enable=%lu, count=%lu, rc-id=%d\n",
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_SWITCH,
MT_LPM_SMC_ACT_GET, rc_id, 0)
& MT_SPM_RC_VALID_SW,
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_CNT,
MT_LPM_SMC_ACT_GET, rc_id, 0),
rc_id);
return len;
}
static ssize_t mt6853_generic_rc_read(char *ToUserBuf,
size_t sz, void *priv)
{
ssize_t len = 0;
struct MT6853_RC_NODE *node = (struct MT6853_RC_NODE *)priv;
if (!node)
return -EINVAL;
switch (node->type) {
case MT6853_RC_NODE_STATE:
mt6853_rc_log(ToUserBuf, sz, len, "count:%lu\n",
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_IDLE_CNT,
MT_LPM_SMC_ACT_GET, DBG_CTRL_COUNT, 0));
break;
case MT6853_RC_NODE_RC_STATE_SIMPLE:
len += mt6853_rc_state(node->rc_id, ToUserBuf, sz);
break;
case MT6853_RC_NODE_RC_STATE:
len += mt6853_rc_state(node->rc_id, ToUserBuf, sz);
len += mt6853_lpm_rc_block_info(node->rc_id,
ToUserBuf + len, sz - len);
break;
case MT6853_RC_NODE_RC_ENABLE:
mt6853_rc_log(ToUserBuf, sz, len, "%lu\n",
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_SWITCH,
MT_LPM_SMC_ACT_GET, node->rc_id, 0));
break;
case MT6853_RC_NODE_COND_ENABLE:
mt6853_rc_log(ToUserBuf, sz, len, "%lu\n",
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_COND_CHECK,
MT_LPM_SMC_ACT_GET, node->rc_id, 0));
break;
case MT6853_RC_NODE_COND_STATE:
len += mt6853_lpm_rc_block_info(node->rc_id, ToUserBuf, sz);
break;
case MT6853_RC_NODE_RATIO_ENABLE:
mt6853_rc_log(ToUserBuf, sz, len, "%lu\n",
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_RES_CTRL,
MT_LPM_SMC_ACT_GET, node->rc_id, 0));
break;
case MT6853_RC_NODE_RATIO_INTERVAL:
mt6853_rc_log(ToUserBuf, sz, len, "%lu\n",
mtk_lpm_timer_interval(&rc_ratio_timer));
break;
case MT6853_RC_NODE_VALID_BBLPM:
mt6853_rc_log(ToUserBuf, sz, len, "%lu\n",
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_BBLPM,
MT_LPM_SMC_ACT_GET, node->rc_id, 0));
break;
case MT6853_RC_NODE_VALID_TRACE:
mt6853_rc_log(ToUserBuf, sz, len, "%lu\n",
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_TRACE,
MT_LPM_SMC_ACT_GET, node->rc_id, 0));
break;
case MT6853_RC_NODE_VALID_TIMESTAMP:
mt6853_rc_log(ToUserBuf, sz, len, "%lu\n",
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_TRACE_TIME,
MT_LPM_SMC_ACT_GET, node->rc_id, 0));
break;
}
return len;
}
static ssize_t mt6853_generic_rc_write(char *FromUserBuf,
size_t sz, void *priv)
{
struct MT6853_RC_NODE *node = (struct MT6853_RC_NODE *)priv;
if (!node)
return -EINVAL;
if ((node->type == MT6853_RC_NODE_RC_ENABLE) ||
(node->type == MT6853_RC_NODE_COND_ENABLE) ||
(node->type == MT6853_RC_NODE_VALID_BBLPM) ||
(node->type == MT6853_RC_NODE_VALID_TRACE) ||
(node->type == MT6853_RC_NODE_VALID_TIMESTAMP)) {
unsigned int parm;
int cmd;
if ((!kstrtoint(FromUserBuf, 10, &parm)) == 1) {
cmd = (node->type == MT6853_RC_NODE_RC_ENABLE) ?
MT_SPM_DBG_SMC_UID_RC_SWITCH :
(node->type == MT6853_RC_NODE_COND_ENABLE) ?
MT_SPM_DBG_SMC_UID_COND_CHECK :
(node->type == MT6853_RC_NODE_VALID_BBLPM) ?
MT_SPM_DBG_SMC_UID_RC_BBLPM :
(node->type == MT6853_RC_NODE_VALID_TRACE) ?
MT_SPM_DBG_SMC_UID_RC_TRACE :
(node->type == MT6853_RC_NODE_VALID_TIMESTAMP) ?
MT_SPM_DBG_SMC_UID_RC_TRACE_TIME : -1;
if (cmd < 0)
return -EINVAL;
if (!!parm)
parm = MT_LPM_SMC_ACT_SET;
else
parm = MT_LPM_SMC_ACT_CLR;
MT6853_DBG_SMC(cmd, parm, node->rc_id, 0);
}
} else if ((node->type == MT6853_RC_NODE_COND_SET)
|| (node->type == MT6853_RC_NODE_COND_CLR)) {
unsigned int parm1, parm2, act;
if (sscanf(FromUserBuf, "%u %x", &parm1, &parm2) == 2) {
act = (node->type == MT6853_RC_NODE_COND_SET) ?
MT_LPM_SMC_ACT_SET :
(node->type == MT6853_RC_NODE_COND_CLR) ?
MT_LPM_SMC_ACT_CLR : 0;
if (act != 0)
mt6853_lpm_rc_cond_ctrl(node->rc_id, act,
parm1, parm2);
}
} else if ((node->type == MT6853_RC_NODE_RATIO_ENABLE)
|| (node->type == MT6853_RC_NODE_RATIO_INTERVAL)) {
unsigned int parm;
if ((!kstrtoint(FromUserBuf, 10, &parm)) == 1) {
if (node->type == MT6853_RC_NODE_RATIO_ENABLE) {
parm = (!!parm) ? MT_LPM_SMC_ACT_SET :
MT_LPM_SMC_ACT_CLR;
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_RES_CTRL,
parm, MT_RM_CONSTRAINT_ID_DRAM, 0);
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_RES_CTRL,
parm, MT_RM_CONSTRAINT_ID_SYSPLL, 0);
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_RES_CTRL,
parm, MT_RM_CONSTRAINT_ID_BUS26M, 0);
if (parm == MT_LPM_SMC_ACT_SET)
mtk_lpm_timer_start(&rc_ratio_timer);
else
mtk_lpm_timer_stop(&rc_ratio_timer);
} else if (node->type == MT6853_RC_NODE_RATIO_INTERVAL)
mtk_lpm_timer_interval_update(&rc_ratio_timer,
(unsigned long long)parm);
}
}
return sz;
}
static int mt6853_lpm_rc_node_add(struct MT6853_RC_NODE *n,
int mode, struct MT6853_RC_ENTERY *p)
{
return mtk_lpm_sysfs_sub_entry_node_add(n->name, mode,
&n->op, &p->handle, &n->handle);
}
static int mt6853_lpm_rc_entry_add(struct MT6853_RC_ENTERY *n,
int mode, struct MT6853_RC_ENTERY *p)
{
return mtk_lpm_sysfs_sub_entry_add(n->name, mode,
&p->handle, &n->handle);
}
static int mt6853_lpm_rc_valid_node_add(int rc_id,
struct MT6853_RC_ENTERY *parent,
struct MT6853_RC_VALID_HANDLES *valid)
{
int bRet = 0;
if (!valid || !parent)
return -EINVAL;
valid->root.name = "valid";
bRet = mt6853_lpm_rc_entry_add(&valid->root, 0644, parent);
if (!bRet) {
MT6853_GENERIC_RC_NODE_INIT(valid->hBblpm, "bblpm",
rc_id, MT6853_RC_NODE_VALID_BBLPM);
mt6853_lpm_rc_node_add(&valid->hBblpm, 0200, &valid->root);
MT6853_GENERIC_RC_NODE_INIT(valid->hTrace, "trace",
rc_id, MT6853_RC_NODE_VALID_TRACE);
mt6853_lpm_rc_node_add(&valid->hTrace, 0200, &valid->root);
MT6853_GENERIC_RC_NODE_INIT(valid->hTimestamp, "timestamp",
rc_id, MT6853_RC_NODE_VALID_TIMESTAMP);
mt6853_lpm_rc_node_add(&valid->hTimestamp, 0200, &valid->root);
}
return bRet;
}
static int mt6853_lpm_rc_ratio_entry(struct mtk_lp_sysfs_handle *parent,
struct MT6853_RC_RATIO_HANDLES *ratio)
{
int bRet = 0;
if (!ratio || !parent)
return -EINVAL;
ratio->root.name = "ratio";
bRet = mtk_lpm_sysfs_sub_entry_add(ratio->root.name, 0644,
parent, &ratio->root.handle);
if (!bRet) {
MT6853_GENERIC_RC_NODE_INIT(ratio->hEnable, "enable",
0, MT6853_RC_NODE_RATIO_ENABLE);
mt6853_lpm_rc_node_add(&ratio->hEnable, 0200, &ratio->root);
MT6853_GENERIC_RC_NODE_INIT(ratio->hInterval, "interval",
0, MT6853_RC_NODE_RATIO_INTERVAL);
mt6853_lpm_rc_node_add(&ratio->hInterval, 0200, &ratio->root);
}
return 0;
}
static int mt6853_lpm_rc_cond_node_add(int rc_id,
struct MT6853_RC_ENTERY *parent,
struct MT6853_RC_COND_HANDLES *cond)
{
int bRet = 0;
if (!cond || !parent)
return -EINVAL;
cond->root.name = "cond";
bRet = mt6853_lpm_rc_entry_add(&cond->root, 0644, parent);
if (!bRet) {
MT6853_GENERIC_RC_NODE_INIT(cond->hSet, "set",
rc_id, MT6853_RC_NODE_COND_SET);
mt6853_lpm_rc_node_add(&cond->hSet, 0200, &cond->root);
MT6853_GENERIC_RC_NODE_INIT(cond->hClr, "clr",
rc_id, MT6853_RC_NODE_COND_CLR);
mt6853_lpm_rc_node_add(&cond->hClr, 0200, &cond->root);
MT6853_GENERIC_RC_NODE_INIT(cond->hEnable, "enable",
rc_id, MT6853_RC_NODE_COND_ENABLE);
mt6853_lpm_rc_node_add(&cond->hEnable, 0644, &cond->root);
MT6853_GENERIC_RC_NODE_INIT(cond->hState, "state",
rc_id, MT6853_RC_NODE_COND_STATE);
mt6853_lpm_rc_node_add(&cond->hState, 0444, &cond->root);
}
return bRet;
}
static int mt6853_lpm_rc_entry_nodes_basic(int IsSimple,
const char *name, int rc_id,
struct mtk_lp_sysfs_handle *parent,
struct MT6853_RC_HANDLE_BASIC *rc)
{
int bRet = 0;
if (!parent || !rc)
return -EINVAL;
rc->root.name = name;
bRet = mtk_lpm_sysfs_sub_entry_add(rc->root.name, 0644,
parent, &rc->root.handle);
if (bRet)
return -EINVAL;
MT6853_GENERIC_RC_NODE_INIT(rc->hState, "state", rc_id,
(IsSimple) ? MT6853_RC_NODE_RC_STATE_SIMPLE
: MT6853_RC_NODE_RC_STATE);
mt6853_lpm_rc_node_add(&rc->hState, 0444, &rc->root);
MT6853_GENERIC_RC_NODE_INIT(rc->hEnable, "enable", rc_id,
MT6853_RC_NODE_RC_ENABLE);
mt6853_lpm_rc_node_add(&rc->hEnable, 0644, &rc->root);
return bRet;
}
int mt6853_lpm_rc_entry_nodes(const char *name, int rc_id,
struct mtk_lp_sysfs_handle *parent,
struct MT6853_RC_HANDLE *rc)
{
int bRet = 0;
if (!parent || !rc)
return -EINVAL;
memset(rc, 0, sizeof(struct MT6853_RC_HANDLE));
bRet = mt6853_lpm_rc_entry_nodes_basic(0, name, rc_id,
parent, &rc->basic);
bRet = mt6853_lpm_rc_cond_node_add(rc_id, &rc->basic.root,
&rc->hCond);
bRet = mt6853_lpm_rc_valid_node_add(rc_id, &rc->basic.root,
&rc->valid);
return 0;
}
int mt6853_dbg_lpm_fs_init(void)
{
/* enable resource constraint condition block latch */
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_BLOCK_LATCH,
MT_LPM_SMC_ACT_SET, 0, 0);
mtk_lpm_sysfs_root_entry_create();
mtk_lpm_sysfs_sub_entry_add("rc", 0644, NULL,
&mt6853_entry_rc);
MT6853_GENERIC_RC_NODE_INIT(rc_state, "state",
0, MT6853_RC_NODE_STATE);
mtk_lpm_sysfs_sub_entry_node_add(rc_state.name, 0444,
&rc_state.op, &mt6853_entry_rc,
&rc_state.handle);
mt6853_lpm_rc_ratio_entry(&mt6853_entry_rc, &rc_Ratio);
mt6853_lpm_rc_entry_nodes_basic(1, "cpu-buck-ldo",
MT_RM_CONSTRAINT_ID_CPU_BUCK_LDO,
&mt6853_entry_rc, &rc_cpu_buckldo);
mt6853_lpm_rc_entry_nodes("dram", MT_RM_CONSTRAINT_ID_DRAM,
&mt6853_entry_rc, &rc_dram);
mt6853_lpm_rc_entry_nodes("syspll", MT_RM_CONSTRAINT_ID_SYSPLL,
&mt6853_entry_rc, &rc_syspll);
mt6853_lpm_rc_entry_nodes("bus26m", MT_RM_CONSTRAINT_ID_BUS26M,
&mt6853_entry_rc, &rc_bus26m);
rc_ratio_timer.timeout = mt6853_lpm_rc_ratio_timer_func;
mtk_lpm_timer_init(&rc_ratio_timer, MTK_LPM_TIMER_REPEAT);
mtk_lpm_timer_interval_update(&rc_ratio_timer,
MT6853_LPM_RC_RATIO_DEFAULT);
/* enable constraint tracing */
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_TRACE,
MT_LPM_SMC_ACT_SET, MT_RM_CONSTRAINT_ID_BUS26M, 0);
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_TRACE,
MT_LPM_SMC_ACT_SET, MT_RM_CONSTRAINT_ID_SYSPLL, 0);
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_TRACE,
MT_LPM_SMC_ACT_SET, MT_RM_CONSTRAINT_ID_DRAM, 0);
return 0;
}
int mt6853_dbg_lpm_fs_deinit(void)
{
/* disable resource contraint condition block latch */
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_BLOCK_LATCH,
MT_LPM_SMC_ACT_CLR, 0, 0);
/* disable constraint tracing */
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_TRACE,
MT_LPM_SMC_ACT_CLR, MT_RM_CONSTRAINT_ID_BUS26M, 0);
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_TRACE,
MT_LPM_SMC_ACT_CLR, MT_RM_CONSTRAINT_ID_SYSPLL, 0);
MT6853_DBG_SMC(MT_SPM_DBG_SMC_UID_RC_TRACE,
MT_LPM_SMC_ACT_CLR, MT_RM_CONSTRAINT_ID_DRAM, 0);
return 0;
}
@@ -0,0 +1,469 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/spinlock.h>
#include <mtk_dbg_common_v1.h>
#include <mtk_lpm_module.h>
#include <mtk_idle_sysfs.h>
#include <mtk_suspend_sysfs.h>
#include <mtk_spm_sysfs.h>
#include <mt6853_pwr_ctrl.h>
#include <mt6853_dbg_fs_common.h>
#include <mt6853_cond.h>
#include <mt6853_spm_comm.h>
/* Determine for node route */
#define MT_LP_RQ_NODE "/sys/kernel/debug/spm/spm_resource_req"
#define DEFINE_ATTR_RO(_name) \
static struct kobj_attribute _name##_attr = { \
.attr = { \
.name = #_name, \
.mode = 0444, \
}, \
.show = _name##_show, \
}
#define DEFINE_ATTR_RW(_name) \
static struct kobj_attribute _name##_attr = { \
.attr = { \
.name = #_name, \
.mode = 0644, \
}, \
.show = _name##_show, \
.store = _name##_store, \
}
#define __ATTR_OF(_name) (&_name##_attr.attr)
#undef mtk_dbg_spm_log
#define mtk_dbg_spm_log(fmt, args...) \
do { \
int l = scnprintf(p, sz, fmt, ##args); \
p += l; \
sz -= l; \
} while (0)
static char *mt6853_pwr_ctrl_str[PW_MAX_COUNT] = {
[PW_PCM_FLAGS] = "pcm_flags",
[PW_PCM_FLAGS_CUST] = "pcm_flags_cust",
[PW_PCM_FLAGS_CUST_SET] = "pcm_flags_cust_set",
[PW_PCM_FLAGS_CUST_CLR] = "pcm_flags_cust_clr",
[PW_PCM_FLAGS1] = "pcm_flags1",
[PW_PCM_FLAGS1_CUST] = "pcm_flags1_cust",
[PW_PCM_FLAGS1_CUST_SET] = "pcm_flags1_cust_set",
[PW_PCM_FLAGS1_CUST_CLR] = "pcm_flags1_cust_clr",
[PW_TIMER_VAL] = "timer_val",
[PW_TIMER_VAL_CUST] = "timer_val_cust",
[PW_TIMER_VAL_RAMP_EN] = "timer_val_ramp_en",
[PW_TIMER_VAL_RAMP_EN_SEC] = "timer_val_ramp_en_sec",
[PW_WAKE_SRC] = "wake_src",
[PW_WAKE_SRC_CUST] = "wake_src_cust",
[PW_WAKELOCK_TIMER_VAL] = "wakelock_timer_val",
[PW_WDT_DISABLE] = "wdt_disable",
/* SPM_CLK_CON */
[PW_REG_SRCCLKEN0_CTL] = "reg_srcclken0_ctl",
[PW_REG_SRCCLKEN1_CTL] = "reg_srcclken1_ctl",
[PW_REG_SPM_LOCK_INFRA_DCM] = "reg_spm_lock_infra_dcm",
[PW_REG_SRCCLKEN_MASK] = "reg_srcclken_mask",
[PW_REG_MD1_C32RM_EN] = "reg_md1_c32rm_en",
[PW_REG_MD2_C32RM_EN] = "reg_md2_c32rm_en",
[PW_REG_CLKSQ0_SEL_CTRL] = "reg_clksq0_sel_ctrl",
[PW_REG_CLKSQ1_SEL_CTRL] = "reg_clksq1_sel_ctrl",
[PW_REG_SRCCLKEN0_EN] = "reg_srcclken0_en",
[PW_REG_SRCCLKEN1_EN] = "reg_srcclken1_en",
[PW_REG_SYSCLK0_SRC_MASK_B] = "reg_sysclk0_src_mask_b",
[PW_REG_SYSCLK1_SRC_MASK_B] = "reg_sysclk1_src_mask_b",
/* SPM_AP_STANDBY_CON */
[PW_REG_WFI_OP] = "reg_wfi_op",
[PW_REG_WFI_TYPE] = "reg_wfi_type",
[PW_REG_MP0_CPUTOP_IDLE_MASK] = "reg_mp0_cputop_idle_mask",
[PW_REG_MP1_CPUTOP_IDLE_MASK] = "reg_mp1_cputop_idle_mask",
[PW_REG_MCUSYS_IDLE_MASK] = "reg_mcusys_idle_mask",
[PW_REG_MD_APSRC_1_SEL] = "reg_md_apsrc_1_sel",
[PW_REG_MD_APSRC_0_SEL] = "reg_md_apsrc_0_sel",
[PW_REG_CONN_APSRC_SEL] = "reg_conn_apsrc_sel",
/* SPM_SRC6_MASK */
[PW_REG_CCIF_EVENT_INFRA_REQ_MASK_B] =
"reg_ccif_event_infra_req_mask_b",
[PW_REG_CCIF_EVENT_APSRC_REQ_MASK_B] =
"reg_ccif_event_apsrc_req_mask_b",
/* SPM_SRC_REQ */
[PW_REG_SPM_APSRC_REQ] = "reg_spm_apsrc_req",
[PW_REG_SPM_F26M_REQ] = "reg_spm_f26m_req",
[PW_REG_SPM_INFRA_REQ] = "reg_spm_infra_req",
[PW_REG_SPM_VRF18_REQ] = "reg_spm_vrf18_req",
[PW_REG_SPM_DDREN_REQ] = "reg_spm_ddren_req",
[PW_REG_SPM_DVFS_REQ] = "reg_spm_dvfs_req",
[PW_REG_SPM_SW_MAILBOX_REQ] = "reg_spm_sw_mailbox_req",
[PW_REG_SPM_SSPM_MAILBOX_REQ] = "reg_spm_sspm_mailbox_req",
[PW_REG_SPM_ADSP_MAILBOX_REQ] = "reg_spm_adsp_mailbox_req",
[PW_REG_SPM_SCP_MAILBOX_REQ] = "reg_spm_scp_mailbox_req",
/* SPM_SRC_MASK */
[PW_REG_MD_0_SRCCLKENA_MASK_B] = "reg_md_0_srcclkena_mask_b",
[PW_REG_MD_0_INFRA_REQ_MASK_B] = "reg_md_0_infra_req_mask_b",
[PW_REG_MD_0_APSRC_REQ_MASK_B] = "reg_md_0_apsrc_req_mask_b",
[PW_REG_MD_0_VRF18_REQ_MASK_B] = "reg_md_0_vrf18_req_mask_b",
[PW_REG_MD_0_DDREN_REQ_MASK_B] = "reg_md_0_ddren_req_mask_b",
[PW_REG_MD_1_SRCCLKENA_MASK_B] = "reg_md_1_srcclkena_mask_b",
[PW_REG_MD_1_INFRA_REQ_MASK_B] = "reg_md_1_infra_req_mask_b",
[PW_REG_MD_1_APSRC_REQ_MASK_B] = "reg_md_1_apsrc_req_mask_b",
[PW_REG_MD_1_VRF18_REQ_MASK_B] = "reg_md_1_vrf18_req_mask_b",
[PW_REG_MD_1_DDREN_REQ_MASK_B] = "reg_md_1_ddren_req_mask_b",
[PW_REG_CONN_SRCCLKENA_MASK_B] = "reg_conn_srcclkena_mask_b",
[PW_REG_CONN_SRCCLKENB_MASK_B] = "reg_conn_srcclkenb_mask_b",
[PW_REG_CONN_INFRA_REQ_MASK_B] = "reg_conn_infra_req_mask_b",
[PW_REG_CONN_APSRC_REQ_MASK_B] = "reg_conn_apsrc_req_mask_b",
[PW_REG_CONN_VRF18_REQ_MASK_B] = "reg_conn_vrf18_req_mask_b",
[PW_REG_CONN_DDREN_REQ_MASK_B] = "reg_conn_ddren_req_mask_b",
[PW_REG_CONN_VFE28_MASK_B] = "reg_conn_vfe28_mask_b",
[PW_REG_SRCCLKENI_SRCCLKENA_MASK_B] = "reg_srcclkeni_srcclkena_mask_b",
[PW_REG_SRCCLKENI_INFRA_REQ_MASK_B] = "reg_srcclkeni_infra_req_mask_b",
[PW_REG_INFRASYS_APSRC_REQ_MASK_B] = "reg_infrasys_apsrc_req_mask_b",
[PW_REG_INFRASYS_DDREN_REQ_MASK_B] = "reg_infrasys_ddren_req_mask_b",
[PW_REG_SSPM_SRCCLKENA_MASK_B] = "reg_sspm_srcclkena_mask_b",
[PW_REG_SSPM_INFRA_REQ_MASK_B] = "reg_sspm_infra_req_mask_b",
[PW_REG_SSPM_APSRC_REQ_MASK_B] = "reg_sspm_apsrc_req_mask_b",
[PW_REG_SSPM_VRF18_REQ_MASK_B] = "reg_sspm_vrf18_req_mask_b",
[PW_REG_SSPM_DDREN_REQ_MASK_B] = "reg_sspm_ddren_req_mask_b",
/* SPM_SRC2_MASK */
[PW_REG_SCP_SRCCLKENA_MASK_B] = "reg_scp_srcclkena_mask_b",
[PW_REG_SCP_INFRA_REQ_MASK_B] = "reg_scp_infra_req_mask_b",
[PW_REG_SCP_APSRC_REQ_MASK_B] = "reg_scp_apsrc_req_mask_b",
[PW_REG_SCP_VRF18_REQ_MASK_B] = "reg_scp_vrf18_req_mask_b",
[PW_REG_SCP_DDREN_REQ_MASK_B] = "reg_scp_ddren_req_mask_b",
[PW_REG_AUDIO_DSP_SRCCLKENA_MASK_B] = "reg_audio_dsp_srcclkena_mask_b",
[PW_REG_AUDIO_DSP_INFRA_REQ_MASK_B] = "reg_audio_dsp_infra_req_mask_b",
[PW_REG_AUDIO_DSP_APSRC_REQ_MASK_B] = "reg_audio_dsp_apsrc_req_mask_b",
[PW_REG_AUDIO_DSP_VRF18_REQ_MASK_B] = "reg_audio_dsp_vrf18_req_mask_b",
[PW_REG_AUDIO_DSP_DDREN_REQ_MASK_B] = "reg_audio_dsp_ddren_req_mask_b",
[PW_REG_UFS_SRCCLKENA_MASK_B] = "reg_ufs_srcclkena_mask_b",
[PW_REG_UFS_INFRA_REQ_MASK_B] = "reg_ufs_infra_req_mask_b",
[PW_REG_UFS_APSRC_REQ_MASK_B] = "reg_ufs_apsrc_req_mask_b",
[PW_REG_UFS_VRF18_REQ_MASK_B] = "reg_ufs_vrf18_req_mask_b",
[PW_REG_UFS_DDREN_REQ_MASK_B] = "reg_ufs_ddren_req_mask_b",
[PW_REG_DISP0_APSRC_REQ_MASK_B] = "reg_disp0_apsrc_req_mask_b",
[PW_REG_DISP0_DDREN_REQ_MASK_B] = "reg_disp0_ddren_req_mask_b",
[PW_REG_DISP1_APSRC_REQ_MASK_B] = "reg_disp1_apsrc_req_mask_b",
[PW_REG_DISP1_DDREN_REQ_MASK_B] = "reg_disp1_ddren_req_mask_b",
[PW_REG_GCE_INFRA_REQ_MASK_B] = "reg_gce_infra_req_mask_b",
[PW_REG_GCE_APSRC_REQ_MASK_B] = "reg_gce_apsrc_req_mask_b",
[PW_REG_GCE_VRF18_REQ_MASK_B] = "reg_gce_vrf18_req_mask_b",
[PW_REG_GCE_DDREN_REQ_MASK_B] = "reg_gce_ddren_req_mask_b",
[PW_REG_APU_SRCCLKENA_MASK_B] = "reg_apu_srcclkena_mask_b",
[PW_REG_APU_INFRA_REQ_MASK_B] = "reg_apu_infra_req_mask_b",
[PW_REG_APU_APSRC_REQ_MASK_B] = "reg_apu_apsrc_req_mask_b",
[PW_REG_APU_VRF18_REQ_MASK_B] = "reg_apu_vrf18_req_mask_b",
[PW_REG_APU_DDREN_REQ_MASK_B] = "reg_apu_ddren_req_mask_b",
[PW_REG_CG_CHECK_SRCCLKENA_MASK_B] = "reg_cg_check_srcclkena_mask_b",
[PW_REG_CG_CHECK_APSRC_REQ_MASK_B] = "reg_cg_check_apsrc_req_mask_b",
[PW_REG_CG_CHECK_VRF18_REQ_MASK_B] = "reg_cg_check_vrf18_req_mask_b",
[PW_REG_CG_CHECK_DDREN_REQ_MASK_B] = "reg_cg_check_ddren_req_mask_b",
/* SPM_SRC3_MASK */
[PW_REG_DVFSRC_EVENT_TRIGGER_MASK_B] =
"reg_dvfsrc_event_trigger_mask_b",
[PW_REG_SW2SPM_WAKEUP_MASK_B] = "reg_sw2spm_wakeup_mask_b",
[PW_REG_ADSP2SPM_WAKEUP_MASK_B] = "reg_adsp2spm_wakeup_mask_b",
[PW_REG_SSPM2SPM_WAKEUP_MASK_B] = "reg_sspm2spm_wakeup_mask_b",
[PW_REG_SCP2SPM_WAKEUP_MASK_B] = "reg_scp2spm_wakeup_mask_b",
[PW_REG_CSYSPWRUP_ACK_MASK] = "reg_csyspwrup_ack_mask",
[PW_REG_SPM_RESERVED_SRCCLKENA_MASK_B] =
"reg_spm_reserved_srcclkena_mask_b",
[PW_REG_SPM_RESERVED_INFRA_REQ_MASK_B] =
"reg_spm_reserved_infra_req_mask_b",
[PW_REG_SPM_RESERVED_APSRC_REQ_MASK_B] =
"reg_spm_reserved_apsrc_req_mask_b",
[PW_REG_SPM_RESERVED_VRF18_REQ_MASK_B] =
"reg_spm_reserved_vrf18_req_mask_b",
[PW_REG_SPM_RESERVED_DDREN_REQ_MASK_B] =
"reg_spm_reserved_ddren_req_mask_b",
[PW_REG_MCUPM_SRCCLKENA_MASK_B] = "reg_mcupm_srcclkena_mask_b",
[PW_REG_MCUPM_INFRA_REQ_MASK_B] = "reg_mcupm_infra_req_mask_b",
[PW_REG_MCUPM_APSRC_REQ_MASK_B] = "reg_mcupm_apsrc_req_mask_b",
[PW_REG_MCUPM_VRF18_REQ_MASK_B] = "reg_mcupm_vrf18_req_mask_b",
[PW_REG_MCUPM_DDREN_REQ_MASK_B] = "reg_mcupm_ddren_req_mask_b",
[PW_REG_MSDC0_SRCCLKENA_MASK_B] = "reg_msdc0_srcclkena_mask_b",
[PW_REG_MSDC0_INFRA_REQ_MASK_B] = "reg_msdc0_infra_req_mask_b",
[PW_REG_MSDC0_APSRC_REQ_MASK_B] = "reg_msdc0_apsrc_req_mask_b",
[PW_REG_MSDC0_VRF18_REQ_MASK_B] = "reg_msdc0_vrf18_req_mask_b",
[PW_REG_MSDC0_DDREN_REQ_MASK_B] = "reg_msdc0_ddren_req_mask_b",
[PW_REG_MSDC1_SRCCLKENA_MASK_B] = "reg_msdc1_srcclkena_mask_b",
[PW_REG_MSDC1_INFRA_REQ_MASK_B] = "reg_msdc1_infra_req_mask_b",
[PW_REG_MSDC1_APSRC_REQ_MASK_B] = "reg_msdc1_apsrc_req_mask_b",
[PW_REG_MSDC1_VRF18_REQ_MASK_B] = "reg_msdc1_vrf18_req_mask_b",
[PW_REG_MSDC1_DDREN_REQ_MASK_B] = "reg_msdc1_ddren_req_mask_b",
/* SPM_SRC4_MASK */
[PW_REG_CCIF_EVENT_SRCCLKENA_MASK_B] =
"reg_ccif_event_srcclkena_mask_b",
[PW_REG_BAK_PSRI_SRCCLKENA_MASK_B] = "reg_bak_psri_srcclkena_mask_b",
[PW_REG_BAK_PSRI_INFRA_REQ_MASK_B] = "reg_bak_psri_infra_req_mask_b",
[PW_REG_BAK_PSRI_APSRC_REQ_MASK_B] = "reg_bak_psri_apsrc_req_mask_b",
[PW_REG_BAK_PSRI_VRF18_REQ_MASK_B] = "reg_bak_psri_vrf18_req_mask_b",
[PW_REG_BAK_PSRI_DDREN_REQ_MASK_B] = "reg_bak_psri_ddren_req_mask_b",
[PW_REG_DRAMC_MD32_INFRA_REQ_MASK_B] =
"reg_dramc_md32_infra_req_mask_b",
[PW_REG_DRAMC_MD32_VRF18_REQ_MASK_B] =
"reg_dramc_md32_vrf18_req_mask_b",
[PW_REG_CONN_SRCCLKENB2PWRAP_MASK_B] =
"reg_conn_srcclkenb2pwrap_mask_b",
[PW_REG_DRAMC_MD32_APSRC_REQ_MASK_B] =
"reg_dramc_md32_apsrc_req_mask_b",
/* SPM_SRC5_MASK */
[PW_REG_MCUSYS_MERGE_APSRC_REQ_MASK_B] =
"reg_mcusys_merge_apsrc_req_mask_b",
[PW_REG_MCUSYS_MERGE_DDREN_REQ_MASK_B] =
"reg_mcusys_merge_ddren_req_mask_b",
[PW_REG_AFE_SRCCLKENA_MASK_B] = "reg_afe_srcclkena_mask_b",
[PW_REG_AFE_INFRA_REQ_MASK_B] = "reg_afe_infra_req_mask_b",
[PW_REG_AFE_APSRC_REQ_MASK_B] = "reg_afe_apsrc_req_mask_b",
[PW_REG_AFE_VRF18_REQ_MASK_B] = "reg_afe_vrf18_req_mask_b",
[PW_REG_AFE_DDREN_REQ_MASK_B] = "reg_afe_ddren_req_mask_b",
[PW_REG_MSDC2_SRCCLKENA_MASK_B] = "reg_msdc2_srcclkena_mask_b",
[PW_REG_MSDC2_INFRA_REQ_MASK_B] = "reg_msdc2_infra_req_mask_b",
[PW_REG_MSDC2_APSRC_REQ_MASK_B] = "reg_msdc2_apsrc_req_mask_b",
[PW_REG_MSDC2_VRF18_REQ_MASK_B] = "reg_msdc2_vrf18_req_mask_b",
[PW_REG_MSDC2_DDREN_REQ_MASK_B] = "reg_msdc2_ddren_req_mask_b",
/* SPM_SRC7_MASK */
[PW_REG_PCIE_SRCCLKENA_MASK_B] = "reg_pcie_srcclkena_mask_b",
[PW_REG_PCIE_INFRA_REQ_MASK_B] = "reg_pcie_infra_req_mask_b",
[PW_REG_PCIE_APSRC_REQ_MASK_B] = "reg_pcie_apsrc_req_mask_b",
[PW_REG_PCIE_VRF18_REQ_MASK_B] = "reg_pcie_vrf18_req_mask_b",
[PW_REG_PCIE_DDREN_REQ_MASK_B] = "reg_pcie_ddren_req_mask_b",
[PW_REG_DPMAIF_SRCCLKENA_MASK_B] = "reg_dpmaif_srcclkena_mask_b",
[PW_REG_DPMAIF_INFRA_REQ_MASK_B] = "reg_dpmaif_infra_req_mask_b",
[PW_REG_DPMAIF_APSRC_REQ_MASK_B] = "reg_dpmaif_apsrc_req_mask_b",
[PW_REG_DPMAIF_VRF18_REQ_MASK_B] = "reg_dpmaif_vrf18_req_mask_b",
[PW_REG_DPMAIF_DDREN_REQ_MASK_B] = "reg_dpmaif_ddren_req_mask_b",
/* SPM_WAKEUP_EVENT_MASK */
[PW_REG_WAKEUP_EVENT_MASK] = "reg_wakeup_event_mask",
/* SPM_WAKEUP_EVENT_EXT_MASK */
[PW_REG_EXT_WAKEUP_EVENT_MASK] = "reg_ext_wakeup_event_mask",
};
/**************************************
* xxx_ctrl_show Function
**************************************/
/* code gen by spm_pwr_ctrl_atf.pl, need struct pwr_ctrl */
static ssize_t mt6853_show_pwr_ctrl(int id, char *buf, size_t buf_sz)
{
char *p = buf;
size_t mSize = 0;
int i;
for (i = 0; i < PW_MAX_COUNT; i++) {
mSize += scnprintf(p + mSize, buf_sz - mSize,
"%s = 0x%zx\n",
mt6853_pwr_ctrl_str[i],
mtk_lpm_smc_spm_dbg(id, MT_LPM_SMC_ACT_GET, i, 0));
}
WARN_ON(buf_sz - mSize <= 0);
return mSize;
}
/**************************************
* xxx_ctrl_store Function
**************************************/
/* code gen by spm_pwr_ctrl_atf.pl, need struct pwr_ctrl */
static ssize_t mt6853_store_pwr_ctrl(int id, const char *buf, size_t count)
{
u32 val;
char cmd[64];
int i;
if (sscanf(buf, "%63s %x", cmd, &val) != 2)
return -EPERM;
pr_info("[SPM] pwr_ctrl: cmd = %s, val = 0x%x\n", cmd, val);
for (i = 0 ; i < PW_MAX_COUNT; i++) {
if (!strcmp(cmd, mt6853_pwr_ctrl_str[i])) {
mtk_lpm_smc_spm_dbg(id, MT_LPM_SMC_ACT_SET, i, val);
break;
}
}
return count;
}
static ssize_t suspend_ctrl_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
return mt6853_show_pwr_ctrl(MT_SPM_DBG_SMC_UID_SUSPEND_PWR_CTRL,
buf, get_mtk_lp_kernfs_bufsz_max());
}
static ssize_t idle_ctrl_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
return mt6853_show_pwr_ctrl(MT_SPM_DBG_SMC_UID_IDLE_PWR_CTRL,
buf, get_mtk_lp_kernfs_bufsz_max());
}
static ssize_t suspend_ctrl_store(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf, size_t count)
{
return mt6853_store_pwr_ctrl(MT_SPM_DBG_SMC_UID_SUSPEND_PWR_CTRL,
buf, count);
}
static ssize_t idle_ctrl_store(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf, size_t count)
{
return mt6853_store_pwr_ctrl(MT_SPM_DBG_SMC_UID_IDLE_PWR_CTRL,
buf, count);
}
/**************************************
* Init Function
**************************************/
DEFINE_ATTR_RW(suspend_ctrl);
DEFINE_ATTR_RW(idle_ctrl);
static struct attribute *pwrctrl_attrs[] = {
/* for spm_lp_scen.pwrctrl */
__ATTR_OF(suspend_ctrl),
__ATTR_OF(idle_ctrl),
/* must */
NULL,
};
static struct attribute_group pwrctrl_attr_group = {
.name = "spm",
.attrs = pwrctrl_attrs,
};
static char *mt6853_spm_resource_str[MT_SPM_RES_MAX] = {
[MT_SPM_RES_XO_FPM] = "XO_FPM",
[MT_SPM_RES_CK_26M] = "CK_26M",
[MT_SPM_RES_INFRA] = "INFRA",
[MT_SPM_RES_SYSPLL] = "SYSPLL",
[MT_SPM_RES_DRAM_S0] = "DRAM_S0",
[MT_SPM_RES_DRAM_S1] = "DRAM_S1",
};
static ssize_t mt6853_spm_res_rq_read(char *ToUserBuf, size_t sz, void *priv)
{
char *p = ToUserBuf;
int i, s, u;
unsigned int unum, uvalid, uname_i, uname_t;
unsigned int rnum, rusage, per_usage;
char uname[MT_LP_RQ_USER_NAME_LEN+1];
mtk_dbg_spm_log("resource_num=%d, user_num=%d, user_valid=0x%x\n",
rnum = mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_NUM,
MT_LPM_SMC_ACT_GET, 0, 0),
unum = mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_USER_NUM,
MT_LPM_SMC_ACT_GET, 0, 0),
uvalid = mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_USER_VALID,
MT_LPM_SMC_ACT_GET, 0, 0));
rusage = mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_USAGE,
MT_LPM_SMC_ACT_GET,
MT_LP_RQ_ID_ALL_USAGE, 0);
mtk_dbg_spm_log("\n");
mtk_dbg_spm_log("user [bit][valid]:\n");
for (i = 0; i < unum; i++) {
uname_i = mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_USER_NAME,
MT_LPM_SMC_ACT_GET, i, 0);
for (s = 0, u = 0; s < MT_LP_RQ_USER_NAME_LEN;
s++, u += MT_LP_RQ_USER_CHAR_U) {
uname_t = ((uname_i >> u) & MT_LP_RQ_USER_CHAR_MASK);
uname[s] = (uname_t) ? (char)uname_t : ' ';
}
uname[s] = '\0';
mtk_dbg_spm_log("%4s [%3d][%3s]\n", uname, i,
((1<<i) & uvalid) ? "yes" : "no");
}
mtk_dbg_spm_log("\n");
if (rnum != MT_SPM_RES_MAX) {
mtk_dbg_spm_log("Platform resource amount mismatch\n");
rnum = (rnum > MT_SPM_RES_MAX) ? MT_SPM_RES_MAX : rnum;
}
mtk_dbg_spm_log("resource [bit][user_usage][blocking]:\n");
for (i = 0; i < rnum; i++) {
mtk_dbg_spm_log("%8s [%3d][0x%08x][%3s]\n",
mt6853_spm_resource_str[i], i,
(per_usage =
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_USAGE,
MT_LPM_SMC_ACT_GET, i, 0)),
((1<<i) & rusage) ? "yes" : "no"
);
}
mtk_dbg_spm_log("\n");
mtk_dbg_spm_log("resource request command help:\n");
mtk_dbg_spm_log("echo enable ${user_bit} > %s\n", MT_LP_RQ_NODE);
mtk_dbg_spm_log("echo bypass ${user_bit} > %s\n", MT_LP_RQ_NODE);
mtk_dbg_spm_log("echo request ${resource_bit} > %s\n", MT_LP_RQ_NODE);
mtk_dbg_spm_log("echo release > %s\n", MT_LP_RQ_NODE);
return p - ToUserBuf;
}
static ssize_t mt6853_spm_res_rq_write(char *FromUserBuf, size_t sz, void *priv)
{
char cmd[128];
int parm;
if (sscanf(FromUserBuf, "%127s %x", cmd, &parm) == 2) {
if (!strcmp(cmd, "bypass"))
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_USER_VALID,
MT_LPM_SMC_ACT_SET,
parm, 0);
else if (!strcmp(cmd, "enable"))
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_USER_VALID,
MT_LPM_SMC_ACT_SET,
parm, 1);
else if (!strcmp(cmd, "request"))
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_REQ,
MT_LPM_SMC_ACT_SET,
0, parm);
return sz;
} else if (sscanf(FromUserBuf, "%127s", cmd) == 1) {
if (!strcmp(cmd, "release"))
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_RES_REQ,
MT_LPM_SMC_ACT_CLR,
0, 0);
return sz;
} else if ((!kstrtoint(FromUserBuf, 10, &parm)) == 1) {
return sz;
}
return -EINVAL;
}
static const struct mtk_lp_sysfs_op mt6853_spm_res_rq_fops = {
.fs_read = mt6853_spm_res_rq_read,
.fs_write = mt6853_spm_res_rq_write,
};
int mt6853_dbg_spm_fs_init(void)
{
int r;
mtk_spm_sysfs_root_entry_create();
mtk_spm_sysfs_entry_node_add("spm_resource_req", 0444
, &mt6853_spm_res_rq_fops, NULL);
/* create /sys/power/spm/xxx */
r = mtk_spm_sysfs_power_create_group(&pwrctrl_attr_group);
if (r)
pr_info("[SPM] FAILED TO CREATE /sys/power/spm (%d)\n", r);
return r;
}
int mt6853_dbg_spm_fs_deinit(void)
{
return 0;
}
@@ -0,0 +1,847 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_address.h>
#include <linux/io.h>
#include <linux/rtc.h>
#include <linux/wakeup_reason.h>
#include <linux/syscore_ops.h>
#include <mt6853_cond.h>
#include <mtk_lpm_module.h>
#include <aee.h>
#include <mtk_lpm.h>
#include <mt6853_spm_comm.h>
#include <mt6853_spm_reg.h>
#include <mt6853_pwr_ctrl.h>
#include <mt6853_pcm_def.h>
#include <mtk_dbg_common_v1.h>
#include <mt-plat/mtk_ccci_common.h>
#include <mtk_lpm_timer.h>
#include <mtk_lpm_sysfs.h>
#define MT6853_LOG_MONITOR_STATE_NAME "mcusysoff"
#define MT6853_LOG_DEFAULT_MS 5000
#define PCM_32K_TICKS_PER_SEC (32768)
#define PCM_TICK_TO_SEC(TICK) (TICK / PCM_32K_TICKS_PER_SEC)
static struct mt6853_spm_wake_status mt6853_wake;
void __iomem *mt6853_spm_base;
struct mt6853_log_helper {
short cur;
short prev;
struct mt6853_spm_wake_status *wakesrc;
};
struct mt6853_log_helper mt6853_logger_help = {
.wakesrc = &mt6853_wake,
.cur = 0,
.prev = 0,
};
static char *mt6853_spm_cond_cg_str[PLAT_SPM_COND_MAX] = {
[PLAT_SPM_COND_MTCMOS_0] = "MTCMOS_0",
[PLAT_SPM_COND_CG_INFRA_0] = "INFRA_0",
[PLAT_SPM_COND_CG_INFRA_1] = "INFRA_1",
[PLAT_SPM_COND_CG_INFRA_2] = "INFRA_2",
[PLAT_SPM_COND_CG_INFRA_3] = "INFRA_3",
[PLAT_SPM_COND_CG_INFRA_4] = "INFRA_4",
[PLAT_SPM_COND_CG_INFRA_5] = "INFRA_5",
[PLAT_SPM_COND_CG_MMSYS_0] = "MMSYS_0",
[PLAT_SPM_COND_CG_MMSYS_1] = "MMSYS_1",
[PLAT_SPM_COND_CG_MMSYS_2] = "MMSYS_2",
};
const char *mt6853_wakesrc_str[32] = {
[0] = " R12_PCM_TIMER",
[1] = " R12_RESERVED_DEBUG_B",
[2] = " R12_KP_IRQ_B",
[3] = " R12_APWDT_EVENT_B",
[4] = " R12_APXGPT1_EVENT_B",
[5] = " R12_CONN2AP_SPM_WAKEUP_B",
[6] = " R12_EINT_EVENT_B",
[7] = " R12_CONN_WDT_IRQ_B",
[8] = " R12_CCIF0_EVENT_B",
[9] = " R12_LOWBATTERY_IRQ_B",
[10] = " R12_SC_SSPM2SPM_WAKEUP_B",
[11] = " R12_SC_SCP2SPM_WAKEUP_B",
[12] = " R12_SC_ADSP2SPM_WAKEUP_B",
[13] = " R12_PCM_WDT_WAKEUP_B",
[14] = " R12_USB_CDSC_B",
[15] = " R12_USB_POWERDWN_B",
[16] = " R12_SYS_TIMER_EVENT_B",
[17] = " R12_EINT_EVENT_SECURE_B",
[18] = " R12_CCIF1_EVENT_B",
[19] = " R12_UART0_IRQ_B",
[20] = " R12_AFE_IRQ_MCU_B",
[21] = " R12_THERM_CTRL_EVENT_B",
[22] = " R12_SYS_CIRQ_IRQ_B",
[23] = " R12_MD2AP_PEER_EVENT_B",
[24] = " R12_CSYSPWREQ_B",
[25] = " R12_MD1_WDT_B",
[26] = " R12_AP2AP_PEER_WAKEUPEVENT_B",
[27] = " R12_SEJ_EVENT_B",
[28] = " R12_SPM_CPU_WAKEUPEVENT_B",
[29] = " R12_APUSYS",
[30] = " R12_PCIE_BRIDGE_IRQ",
[31] = " R12_PCIE_IRQ",
};
struct spm_wakesrc_irq_list mt6853_spm_wakesrc_irqs[] = {
/* mtk-kpd */
{ WAKE_SRC_STA1_KP_IRQ_B, "mediatek,kp", 0, 0},
/* mt_wdt */
{ WAKE_SRC_STA1_APWDT_EVENT_B, "mediatek,toprgu", 0, 0},
/* bt_cvsd_int */
{ WAKE_SRC_STA1_CONN2AP_SPM_WAKEUP_B, "mediatek,mtk-btcvsd-snd", 0, 0},
/* wf_hif_int */
{ WAKE_SRC_STA1_CONN2AP_SPM_WAKEUP_B, "mediatek,wifi", 0, 0},
/* conn2ap_btif_wakeup_out */
{ WAKE_SRC_STA1_CONN2AP_SPM_WAKEUP_B, "mediatek,mt6853-consys", 0, 0},
/* conn2ap_sw_irq */
{ WAKE_SRC_STA1_CONN2AP_SPM_WAKEUP_B, "mediatek,mt6853-consys", 2, 0},
/* CCIF_AP_DATA */
{ WAKE_SRC_STA1_CCIF0_EVENT_B, "mediatek,ap_ccif0", 0, 0},
/* SCP IPC0 */
{ WAKE_SRC_STA1_SC_SCP2SPM_WAKEUP_B, "mediatek,scp", 0, 0},
/* SCP IPC1 */
{ WAKE_SRC_STA1_SC_SCP2SPM_WAKEUP_B, "mediatek,scp", 1, 0},
/* MBOX_ISR0 */
{ WAKE_SRC_STA1_SC_SCP2SPM_WAKEUP_B, "mediatek,scp", 2, 0},
/* MBOX_ISR1 */
{ WAKE_SRC_STA1_SC_SCP2SPM_WAKEUP_B, "mediatek,scp", 3, 0},
/* MBOX_ISR2 */
{ WAKE_SRC_STA1_SC_SCP2SPM_WAKEUP_B, "mediatek,scp", 4, 0},
/* MBOX_ISR3 */
{ WAKE_SRC_STA1_SC_SCP2SPM_WAKEUP_B, "mediatek,scp", 5, 0},
/* MBOX_ISR4 */
{ WAKE_SRC_STA1_SC_SCP2SPM_WAKEUP_B, "mediatek,scp", 6, 0},
/* ADSP_A_AUD */
{ WAKE_SRC_STA1_SC_ADSP2SPM_WAKEUP_B, "mediatek,adsp_core_0", 2, 0},
/* ADSP_B_AUD */
{ WAKE_SRC_STA1_SC_ADSP2SPM_WAKEUP_B, "mediatek,adsp_core_1", 2, 0},
/* CCIF0_AP */
{ WAKE_SRC_STA1_MD1_WDT_B, "mediatek,mddriver", 2, 0},
/* DPMAIF_AP */
{ WAKE_SRC_STA1_AP2AP_PEER_WAKEUPEVENT_B, "mediatek,dpmaif", 0, 0},
};
#define plat_mmio_read(offset) __raw_readl(mt6853_spm_base + offset)
u64 ap_pd_count;
u64 ap_slp_duration;
u64 spm_26M_off_count;
u64 spm_26M_off_duration;
u32 before_ap_slp_duration;
#define IRQ_NUMBER \
(sizeof(mt6853_spm_wakesrc_irqs)/sizeof(struct spm_wakesrc_irq_list))
static void mt6853_get_spm_wakesrc_irq(void)
{
int i;
struct device_node *node = NULL;
for (i = 0; i < IRQ_NUMBER; i++) {
if (mt6853_spm_wakesrc_irqs[i].name == NULL)
continue;
node = of_find_compatible_node(NULL, NULL,
mt6853_spm_wakesrc_irqs[i].name);
if (!node) {
pr_info("[name:spm&][SPM] find '%s' node failed\n",
mt6853_spm_wakesrc_irqs[i].name);
continue;
}
mt6853_spm_wakesrc_irqs[i].irq_no =
irq_of_parse_and_map(node,
mt6853_spm_wakesrc_irqs[i].order);
if (!mt6853_spm_wakesrc_irqs[i].irq_no) {
pr_info("[name:spm&][SPM] get '%s' failed\n",
mt6853_spm_wakesrc_irqs[i].name);
}
}
}
struct mt6853_logger_timer {
struct mt_lpm_timer tm;
unsigned int fired;
};
struct mt6853_logger_fired_info {
unsigned int fired;
int state_index;
};
static struct mt6853_logger_timer mt6853_log_timer;
static struct mt6853_logger_fired_info mt6853_logger_fired;
int mt6853_get_wakeup_status(struct mt6853_log_helper *help)
{
if (!help->wakesrc || !mt6853_spm_base)
return -EINVAL;
help->wakesrc->r12 = plat_mmio_read(SPM_BK_WAKE_EVENT);
help->wakesrc->r12_ext = plat_mmio_read(SPM_WAKEUP_STA);
help->wakesrc->raw_sta = plat_mmio_read(SPM_WAKEUP_STA);
help->wakesrc->raw_ext_sta = plat_mmio_read(SPM_WAKEUP_EXT_STA);
help->wakesrc->md32pcm_wakeup_sta = plat_mmio_read(MD32PCM_WAKEUP_STA);
help->wakesrc->md32pcm_event_sta = plat_mmio_read(MD32PCM_EVENT_STA);
help->wakesrc->src_req = plat_mmio_read(SPM_SRC_REQ);
/* backup of SPM_WAKEUP_MISC */
help->wakesrc->wake_misc = plat_mmio_read(SPM_BK_WAKE_MISC);
/* get sleep time */
/* backup of PCM_TIMER_OUT */
help->wakesrc->timer_out = plat_mmio_read(SPM_BK_PCM_TIMER);
/* get other SYS and co-clock status */
help->wakesrc->r13 = plat_mmio_read(PCM_REG13_DATA);
help->wakesrc->idle_sta = plat_mmio_read(SUBSYS_IDLE_STA);
help->wakesrc->req_sta0 = plat_mmio_read(SRC_REQ_STA_0);
help->wakesrc->req_sta1 = plat_mmio_read(SRC_REQ_STA_1);
help->wakesrc->req_sta2 = plat_mmio_read(SRC_REQ_STA_2);
help->wakesrc->req_sta3 = plat_mmio_read(SRC_REQ_STA_3);
help->wakesrc->req_sta4 = plat_mmio_read(SRC_REQ_STA_4);
/* get HW CG check status */
help->wakesrc->cg_check_sta = plat_mmio_read(SPM_CG_CHECK_STA);
/* get debug flag for PCM execution check */
help->wakesrc->debug_flag = plat_mmio_read(PCM_WDT_LATCH_SPARE_0);
help->wakesrc->debug_flag1 = plat_mmio_read(PCM_WDT_LATCH_SPARE_1);
/* get backup SW flag status */
help->wakesrc->b_sw_flag0 = plat_mmio_read(SPM_SW_RSV_7);
help->wakesrc->b_sw_flag1 = plat_mmio_read(SPM_SW_RSV_8);
help->wakesrc->rt_req_sta0 = plat_mmio_read(SPM_SW_RSV_2);
help->wakesrc->rt_req_sta1 = plat_mmio_read(SPM_SW_RSV_3);
help->wakesrc->rt_req_sta2 = plat_mmio_read(SPM_SW_RSV_4);
help->wakesrc->rt_req_sta3 = plat_mmio_read(SPM_SW_RSV_5);
help->wakesrc->rt_req_sta4 = plat_mmio_read(SPM_SW_RSV_6);
/* get ISR status */
help->wakesrc->isr = plat_mmio_read(SPM_IRQ_STA);
/* get SW flag status */
help->wakesrc->sw_flag0 = plat_mmio_read(SPM_SW_FLAG_0);
help->wakesrc->sw_flag1 = plat_mmio_read(SPM_SW_FLAG_1);
/* get CLK SETTLE */
help->wakesrc->clk_settle = plat_mmio_read(SPM_CLK_SETTLE);
/* check abort */
help->wakesrc->is_abort =
help->wakesrc->debug_flag & DEBUG_ABORT_MASK;
help->wakesrc->is_abort |=
help->wakesrc->debug_flag1 & DEBUG_ABORT_MASK_1;
help->cur += 1;
return 0;
}
static void mt6853_save_sleep_info(void)
{
#define AVOID_OVERFLOW (0xFFFFFFFF00000000)
u32 off_26M_duration;
u32 slp_duration;
slp_duration = plat_mmio_read(SPM_BK_PCM_TIMER);
if (slp_duration == before_ap_slp_duration)
return;
/* Save ap off counter and duration */
if (ap_pd_count >= AVOID_OVERFLOW)
ap_pd_count = 0;
else
ap_pd_count++;
if (ap_slp_duration >= AVOID_OVERFLOW)
ap_slp_duration = 0;
else {
ap_slp_duration = ap_slp_duration + slp_duration;
before_ap_slp_duration = slp_duration;
}
/* Save 26M's off counter and duration */
if (spm_26M_off_duration >= AVOID_OVERFLOW)
spm_26M_off_duration = 0;
else {
off_26M_duration = plat_mmio_read(SPM_BK_VTCXO_DUR);
if (off_26M_duration == 0)
return;
spm_26M_off_duration = spm_26M_off_duration +
off_26M_duration;
}
if (spm_26M_off_count >= AVOID_OVERFLOW)
spm_26M_off_count = 0;
else
spm_26M_off_count = (plat_mmio_read(SPM_VTCXO_EVENT_COUNT_STA)
& 0xffff)
+ spm_26M_off_count;
}
static void mt6853_suspend_show_detailed_wakeup_reason
(struct mt6853_spm_wake_status *wakesta)
{
int i;
unsigned int irq_no;
#if !defined(CONFIG_FPGA_EARLY_PORTING)
#ifdef CONFIG_MTK_CCCI_DEVICES
exec_ccci_kern_func_by_md_id(0, ID_DUMP_MD_SLEEP_MODE,
NULL, 0);
#endif
#ifdef CONFIG_MTK_ECCCI_DRIVER
if (wakesta->r12 & R12_CLDMA_EVENT_B)
exec_ccci_kern_func_by_md_id(0, ID_GET_MD_WAKEUP_SRC,
NULL, 0);
if (wakesta->r12 & R12_MD2AP_PEER_EVENT_B)
exec_ccci_kern_func_by_md_id(0, ID_GET_MD_WAKEUP_SRC,
NULL, 0);
if (wakesta->r12 & R12_CCIF0_EVENT_B)
exec_ccci_kern_func_by_md_id(0, ID_GET_MD_WAKEUP_SRC,
NULL, 0);
if (wakesta->r12 & R12_CCIF1_EVENT_B)
exec_ccci_kern_func_by_md_id(2, ID_GET_MD_WAKEUP_SRC,
NULL, 0);
#endif
#endif
/* Check if pending irq happen and log them */
for (i = 0; i < IRQ_NUMBER; i++) {
if (mt6853_spm_wakesrc_irqs[i].name == NULL ||
!mt6853_spm_wakesrc_irqs[i].irq_no)
continue;
if (mt6853_spm_wakesrc_irqs[i].wakesrc & wakesta->r12) {
irq_no = mt6853_spm_wakesrc_irqs[i].irq_no;
if (mt_irq_get_pending(irq_no))
log_irq_wakeup_reason(irq_no);
}
}
}
static void dump_lp_cond(void)
{
#define mt6853_DBG_SMC(_id, _act, _rc, _param) ({\
(u32) mtk_lpm_smc_spm_dbg(_id, _act, _rc, _param); })
int i;
u32 blkcg;
for (i = 1 ; i < PLAT_SPM_COND_MAX ; i++) {
blkcg = mt6853_DBG_SMC(MT_SPM_DBG_SMC_UID_BLOCK_DETAIL, MT_LPM_SMC_ACT_GET, 0, i);
if (blkcg != 0)
printk_deferred("suspend warning: CG: %6s = 0x%08lx\n"
, mt6853_spm_cond_cg_str[i], blkcg);
}
}
static void mt6853_suspend_spm_rsc_req_check
(struct mt6853_spm_wake_status *wakesta)
{
#define LOG_BUF_SIZE 256
#define IS_BLOCKED_OVER_TIMES 10
#undef AVOID_OVERFLOW
#define AVOID_OVERFLOW (0xF0000000)
static u32 is_blocked_cnt;
char log_buf[LOG_BUF_SIZE] = { 0 };
int log_size = 0;
u32 is_no_blocked = 0;
u32 req_sta_0, req_sta_1, req_sta_4;
u32 src_req;
if (is_blocked_cnt >= AVOID_OVERFLOW)
is_blocked_cnt = 0;
/* Check if ever enter deepest System LPM */
is_no_blocked = wakesta->debug_flag & 0x2;
/* Check if System LPM ever is blocked over 10 times */
if (!is_no_blocked)
is_blocked_cnt++;
else
is_blocked_cnt = 0;
if (is_blocked_cnt < IS_BLOCKED_OVER_TIMES)
return;
/* Show who is blocking system LPM */
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size,
"suspend warning:(OneShot) System LPM is blocked by ");
req_sta_0 = plat_mmio_read(SRC_REQ_STA_0);
if (req_sta_0 & 0xFFF)
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "md ");
if (req_sta_0 & (0x3F << 12))
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "conn ");
if (req_sta_0 & (0x7 << 18))
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "nfc ");
if (req_sta_0 & (0xF << 26))
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "disp ");
req_sta_1 = plat_mmio_read(SRC_REQ_STA_1);
if (req_sta_1 & 0x1F)
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "scp ");
if (req_sta_1 & (0x1F << 5))
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "adsp ");
if (req_sta_1 & (0x1F << 10))
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "ufs ");
if (req_sta_1 & (0xF << 15))
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "gce ");
if (req_sta_1 & (0x3FF << 21))
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "msdc ");
req_sta_4 = plat_mmio_read(SRC_REQ_STA_4);
if (req_sta_4 & 0x1F)
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "apu ");
src_req = plat_mmio_read(SPM_SRC_REQ);
if (src_req & 0x9B) {
dump_lp_cond();
log_size += scnprintf(log_buf + log_size,
LOG_BUF_SIZE - log_size, "spm ");
}
WARN_ON(strlen(log_buf) >= LOG_BUF_SIZE);
printk_deferred("[name:spm&][SPM] %s", log_buf);
}
static int mt6853_show_message(struct mt6853_spm_wake_status *wakesrc, int type,
const char *prefix, void *data)
{
#undef LOG_BUF_SIZE
#define LOG_BUF_SIZE 256
#define LOG_BUF_OUT_SZ 768
#define IS_WAKE_MISC(x) (wakesrc->wake_misc & x)
#define IS_LOGBUF(ptr, newstr) \
((strlen(ptr) + strlen(newstr)) < LOG_BUF_SIZE)
int i;
unsigned int spm_26M_off_pct = 0;
char buf[LOG_BUF_SIZE] = { 0 };
char log_buf[LOG_BUF_OUT_SZ] = { 0 };
char *local_ptr = NULL;
int log_size = 0;
unsigned int wr = WR_UNKNOWN;
const char *scenario = prefix ?: "UNKNOWN";
/* Disable rcu lock checking */
if (type == MT_LPM_ISSUER_SUSPEND)
rcu_irq_enter_irqson();
if (wakesrc->is_abort != 0) {
/* add size check for vcoredvfs */
aee_sram_printk("SPM ABORT (%s), r13 = 0x%x, ",
scenario, wakesrc->r13);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
"[SPM] ABORT (%s), r13 = 0x%x, ",
scenario, wakesrc->r13);
aee_sram_printk(" debug_flag = 0x%x 0x%x",
wakesrc->debug_flag, wakesrc->debug_flag1);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
" debug_flag = 0x%x 0x%x",
wakesrc->debug_flag, wakesrc->debug_flag1);
aee_sram_printk(" sw_flag = 0x%x 0x%x",
wakesrc->sw_flag0, wakesrc->sw_flag1);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
" sw_flag = 0x%x 0x%x\n",
wakesrc->sw_flag0, wakesrc->sw_flag1);
aee_sram_printk(" b_sw_flag = 0x%x 0x%x",
wakesrc->b_sw_flag0, wakesrc->b_sw_flag1);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
" b_sw_flag = 0x%x 0x%x",
wakesrc->b_sw_flag0, wakesrc->b_sw_flag1);
wr = WR_ABORT;
} else {
if (wakesrc->r12 & R12_PCM_TIMER) {
if (wakesrc->wake_misc & WAKE_MISC_PCM_TIMER_EVENT) {
local_ptr = " PCM_TIMER";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_PCM_TIMER;
}
}
if (wakesrc->r12 & R12_TWAM_IRQ_B) {
if (IS_WAKE_MISC(WAKE_MISC_DVFSRC_IRQ)) {
local_ptr = " DVFSRC";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_DVFSRC;
}
if (IS_WAKE_MISC(WAKE_MISC_TWAM_IRQ_B)) {
local_ptr = " TWAM";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_TWAM;
}
if (IS_WAKE_MISC(WAKE_MISC_PMSR_IRQ_B_SET0)) {
local_ptr = " PMSR";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_PMSR;
}
if (IS_WAKE_MISC(WAKE_MISC_PMSR_IRQ_B_SET1)) {
local_ptr = " PMSR";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_PMSR;
}
if (IS_WAKE_MISC(WAKE_MISC_SPM_ACK_CHK_WAKEUP_0)) {
local_ptr = " SPM_ACK_CHK";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_SPM_ACK_CHK;
}
if (IS_WAKE_MISC(WAKE_MISC_SPM_ACK_CHK_WAKEUP_1)) {
local_ptr = " SPM_ACK_CHK";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_SPM_ACK_CHK;
}
if (IS_WAKE_MISC(WAKE_MISC_SPM_ACK_CHK_WAKEUP_2)) {
local_ptr = " SPM_ACK_CHK";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_SPM_ACK_CHK;
}
if (IS_WAKE_MISC(WAKE_MISC_SPM_ACK_CHK_WAKEUP_3)) {
local_ptr = " SPM_ACK_CHK";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_SPM_ACK_CHK;
}
if (IS_WAKE_MISC(WAKE_MISC_SPM_ACK_CHK_WAKEUP_ALL)) {
local_ptr = " SPM_ACK_CHK";
if (IS_LOGBUF(buf, local_ptr))
strncat(buf, local_ptr,
strlen(local_ptr));
wr = WR_SPM_ACK_CHK;
}
}
for (i = 1; i < 32; i++) {
if (wakesrc->r12 & (1U << i)) {
if (IS_LOGBUF(buf, mt6853_wakesrc_str[i]))
strncat(buf, mt6853_wakesrc_str[i],
strlen(mt6853_wakesrc_str[i]));
wr = WR_WAKE_SRC;
}
}
WARN_ON(strlen(buf) >= LOG_BUF_SIZE);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
"%s wake up by %s, timer_out = %u, r13 = 0x%x, debug_flag = 0x%x 0x%x, ",
scenario, buf, wakesrc->timer_out, wakesrc->r13,
wakesrc->debug_flag, wakesrc->debug_flag1);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
"r12 = 0x%x, r12_ext = 0x%x, raw_sta = 0x%x 0x%x 0x%x, idle_sta = 0x%x, ",
wakesrc->r12, wakesrc->r12_ext,
wakesrc->raw_sta,
wakesrc->md32pcm_wakeup_sta,
wakesrc->md32pcm_event_sta,
wakesrc->idle_sta);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
"req_sta = 0x%x 0x%x 0x%x 0x%x 0x%x, cg_check_sta =0x%x, isr = 0x%x, rt_req_sta0 = 0x%x rt_req_sta1 = 0x%x rt_req_sta2 = 0x%x rt_req_sta3 = 0x%x dram_sw_con_3 = 0x%x, ",
wakesrc->req_sta0, wakesrc->req_sta1,
wakesrc->req_sta2, wakesrc->req_sta3,
wakesrc->req_sta4, wakesrc->cg_check_sta,
wakesrc->isr, wakesrc->rt_req_sta0,
wakesrc->rt_req_sta1, wakesrc->rt_req_sta2,
wakesrc->rt_req_sta3, wakesrc->rt_req_sta4);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
"raw_ext_sta = 0x%x, wake_misc = 0x%x, pcm_flag = 0x%x 0x%x 0x%x 0x%x, req = 0x%x, ",
wakesrc->raw_ext_sta,
wakesrc->wake_misc,
wakesrc->sw_flag0,
wakesrc->sw_flag1, wakesrc->b_sw_flag0,
wakesrc->b_sw_flag0,
wakesrc->src_req);
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
" clk_settle = 0x%x, ", wakesrc->clk_settle);
if (type == MT_LPM_ISSUER_SUSPEND) {
/* calculate 26M off percentage in suspend period */
if (wakesrc->timer_out != 0) {
spm_26M_off_pct =
(100 * plat_mmio_read(SPM_BK_VTCXO_DUR))
/ wakesrc->timer_out;
}
log_size += scnprintf(log_buf + log_size,
LOG_BUF_OUT_SZ - log_size,
"wlk_cntcv_l = 0x%x, wlk_cntcv_h = 0x%x, 26M_off_pct = %d\n",
plat_mmio_read(SYS_TIMER_VALUE_L),
plat_mmio_read(SYS_TIMER_VALUE_H),
spm_26M_off_pct);
}
}
WARN_ON(log_size >= LOG_BUF_OUT_SZ);
if (type == MT_LPM_ISSUER_SUSPEND) {
printk_deferred("[name:spm&][SPM] %s", log_buf);
mt6853_suspend_show_detailed_wakeup_reason(wakesrc);
mt6853_suspend_spm_rsc_req_check(wakesrc);
printk_deferred("[name:spm&][SPM] Suspended for %d.%03d seconds",
PCM_TICK_TO_SEC(wakesrc->timer_out),
PCM_TICK_TO_SEC((wakesrc->timer_out %
PCM_32K_TICKS_PER_SEC)
* 1000));
/* Eable rcu lock checking */
rcu_irq_exit_irqson();
} else
pr_info("[name:spm&][SPM] %s", log_buf);
return wr;
}
int mt6853_issuer_func(int type, const char *prefix, void *data)
{
mt6853_get_wakeup_status(&mt6853_logger_help);
return mt6853_show_message(mt6853_logger_help.wakesrc,
type, prefix, data);
}
struct mtk_lpm_issuer mt6853_issuer = {
.log = mt6853_issuer_func,
};
static int mt6853_idle_save_sleep_info_nb_func(struct notifier_block *nb,
unsigned long action, void *data)
{
struct mtk_lpm_nb_data *nb_data = (struct mtk_lpm_nb_data *)data;
if (nb_data && (action == MTK_LPM_NB_BEFORE_REFLECT))
mt6853_save_sleep_info();
return NOTIFY_OK;
}
struct notifier_block mt6853_idle_save_sleep_info_nb = {
.notifier_call = mt6853_idle_save_sleep_info_nb_func,
};
static void mt6853_suspend_save_sleep_info_func(void)
{
mt6853_save_sleep_info();
}
static struct syscore_ops mt6853_suspend_save_sleep_info_syscore_ops = {
.resume = mt6853_suspend_save_sleep_info_func,
};
static int mt6853_log_timer_func(unsigned long long dur, void *priv)
{
struct mt6853_logger_timer *timer =
(struct mt6853_logger_timer *)priv;
struct mt6853_logger_fired_info *info = &mt6853_logger_fired;
if (timer->fired != info->fired) {
/* if the wake src had beed update before
* then won't do wake src update
*/
if (mt6853_logger_help.prev == mt6853_logger_help.cur)
mt6853_get_wakeup_status(&mt6853_logger_help);
mt6853_show_message(mt6853_logger_help.wakesrc,
MT_LPM_ISSUER_CPUIDLE,
"MCUSYSOFF", NULL);
mt6853_logger_help.prev = mt6853_logger_help.cur;
} else
pr_info("[name:spm&][SPM] MCUSYSOFF Didn't enter low power scenario\n");
timer->fired = info->fired;
return 0;
}
static int mt6853_logger_nb_func(struct notifier_block *nb,
unsigned long action, void *data)
{
struct mtk_lpm_nb_data *nb_data = (struct mtk_lpm_nb_data *)data;
struct mt6853_logger_fired_info *info = &mt6853_logger_fired;
if (nb_data && (action == MTK_LPM_NB_BEFORE_REFLECT)
&& (nb_data->index == info->state_index))
info->fired++;
return NOTIFY_OK;
}
struct notifier_block mt6853_logger_nb = {
.notifier_call = mt6853_logger_nb_func,
};
static ssize_t mt6853_logger_debugfs_read(char *ToUserBuf,
size_t sz, void *priv)
{
char *p = ToUserBuf;
int len;
if (priv == ((void *)&mt6853_log_timer)) {
len = scnprintf(p, sz, "%lu\n",
mtk_lpm_timer_interval(&mt6853_log_timer.tm));
p += len;
}
return (p - ToUserBuf);
}
static ssize_t mt6853_logger_debugfs_write(char *FromUserBuf,
size_t sz, void *priv)
{
if (priv == ((void *)&mt6853_log_timer)) {
unsigned int val = 0;
if (!kstrtouint(FromUserBuf, 10, &val)) {
if (val == 0)
mtk_lpm_timer_stop(&mt6853_log_timer.tm);
else
mtk_lpm_timer_interval_update(
&mt6853_log_timer.tm, val);
}
}
return sz;
}
struct MT6886_LOGGER_NODE {
struct mtk_lp_sysfs_handle handle;
struct mtk_lp_sysfs_op op;
};
#define MT6853_LOGGER_NODE_INIT(_n, _priv) ({\
_n.op.fs_read = mt6853_logger_debugfs_read;\
_n.op.fs_write = mt6853_logger_debugfs_write;\
_n.op.priv = _priv; })\
struct mtk_lp_sysfs_handle mt6853_log_tm_node;
struct MT6886_LOGGER_NODE mt6853_log_tm_interval;
int mt6853_logger_timer_debugfs_init(void)
{
mtk_lpm_sysfs_sub_entry_add("logger", 0644,
NULL, &mt6853_log_tm_node);
MT6853_LOGGER_NODE_INIT(mt6853_log_tm_interval,
&mt6853_log_timer);
mtk_lpm_sysfs_sub_entry_node_add("interval", 0644,
&mt6853_log_tm_interval.op,
&mt6853_log_tm_node,
&mt6853_log_tm_interval.handle);
return 0;
}
int __init mt6853_logger_init(void)
{
struct device_node *node = NULL;
struct cpuidle_driver *drv = NULL;
struct cpuidle_device *dev = NULL;
node = of_find_compatible_node(NULL, NULL, "mediatek,sleep");
if (node) {
mt6853_spm_base = of_iomap(node, 0);
of_node_put(node);
}
if (mt6853_spm_base)
mtk_lp_issuer_register(&mt6853_issuer);
else
pr_info("[name:mtk_lpm][P] - Don't register the issue by error! (%s:%d)\n",
__func__, __LINE__);
mt6853_get_spm_wakesrc_irq();
mtk_lpm_sysfs_root_entry_create();
mt6853_logger_timer_debugfs_init();
preempt_disable();
dev = cpuidle_get_device();
drv = cpuidle_get_cpu_driver(dev);
preempt_enable();
mt6853_logger_fired.state_index = -1;
if (drv) {
int idx;
for (idx = 0; idx < drv->state_count; ++idx) {
if (!strcmp(MT6853_LOG_MONITOR_STATE_NAME,
drv->states[idx].name)) {
mt6853_logger_fired.state_index = idx;
break;
}
}
}
mtk_lpm_notifier_register(&mt6853_logger_nb);
mtk_lpm_notifier_register(&mt6853_idle_save_sleep_info_nb);
mt6853_log_timer.tm.timeout = mt6853_log_timer_func;
mt6853_log_timer.tm.priv = &mt6853_log_timer;
mtk_lpm_timer_init(&mt6853_log_timer.tm, MTK_LPM_TIMER_REPEAT);
mtk_lpm_timer_interval_update(&mt6853_log_timer.tm,
MT6853_LOG_DEFAULT_MS);
mtk_lpm_timer_start(&mt6853_log_timer.tm);
register_syscore_ops(&mt6853_suspend_save_sleep_info_syscore_ops);
return 0;
}
late_initcall_sync(mt6853_logger_init);
@@ -0,0 +1,141 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/io.h>
#include <mtk_lpm_trace_event/mtk_lpm_trace_event.h>
#include <mtk_spm_sysfs.h>
#include <mt6853_spm_reg.h>
#define plat_mmio_read(offset) __raw_readl(spm_base + offset)
void __iomem *spm_base;
struct timer_list spm_resource_req_timer;
u32 spm_resource_req_timer_is_enabled;
u32 spm_resource_req_timer_ms;
static void spm_resource_req_timer_fn(struct timer_list *data)
{
u32 req_sta_0, req_sta_1, req_sta_4;
u32 src_req;
u32 md = 0, conn = 0, scp = 0, adsp = 0;
u32 ufs = 0, msdc = 0, disp = 0, apu = 0;
u32 spm = 0;
req_sta_0 = plat_mmio_read(SRC_REQ_STA_0);
if (req_sta_0 & 0xFFF)
md = 1;
if (req_sta_0 & (0x3F << 12))
conn = 1;
if (req_sta_0 & (0xF << 26))
disp = 1;
req_sta_1 = plat_mmio_read(SRC_REQ_STA_1);
if (req_sta_1 & 0x1F)
scp = 1;
if (req_sta_1 & (0x1F << 5))
adsp = 1;
if (req_sta_1 & (0x1F << 10))
ufs = 1;
if (req_sta_1 & (0x3FF << 21))
msdc = 1;
req_sta_4 = plat_mmio_read(SRC_REQ_STA_4);
if (req_sta_4 & 0x1F)
apu = 1;
src_req = plat_mmio_read(SPM_SRC_REQ);
if (src_req & 0x19B)
spm = 1;
spm_resource_req_timer.expires = jiffies +
msecs_to_jiffies(spm_resource_req_timer_ms);
add_timer(&spm_resource_req_timer);
}
static void spm_resource_req_timer_en(u32 enable, u32 timer_ms)
{
if (enable) {
if (spm_resource_req_timer_is_enabled)
return;
timer_setup(&spm_resource_req_timer,
spm_resource_req_timer_fn, 0);
spm_resource_req_timer_ms = timer_ms;
spm_resource_req_timer.expires = jiffies +
msecs_to_jiffies(spm_resource_req_timer_ms);
add_timer(&spm_resource_req_timer);
spm_resource_req_timer_is_enabled = true;
} else if (spm_resource_req_timer_is_enabled) {
del_timer(&spm_resource_req_timer);
spm_resource_req_timer_is_enabled = false;
}
}
ssize_t get_spm_resource_req_timer_enable(char *ToUserBuf
, size_t sz, void *priv)
{
int bLen = snprintf(ToUserBuf, sz
, "spm resource request timer is enabled: %d\n",
spm_resource_req_timer_is_enabled);
return (bLen > sz) ? sz : bLen;
}
ssize_t set_spm_resource_req_timer_enable(char *ToUserBuf
, size_t sz, void *priv)
{
u32 is_enable;
u32 timer_ms;
if (!ToUserBuf)
return -EINVAL;
if (sscanf(ToUserBuf, "%d %d", &is_enable, &timer_ms) == 2) {
spm_resource_req_timer_en(is_enable, timer_ms);
return sz;
}
if (kstrtouint(ToUserBuf, 10, &is_enable) == 0) {
if (is_enable == 0) {
spm_resource_req_timer_en(is_enable, 0);
return sz;
}
}
return -EINVAL;
}
static const struct mtk_lp_sysfs_op spm_resource_req_timer_enable_fops = {
.fs_read = get_spm_resource_req_timer_enable,
.fs_write = set_spm_resource_req_timer_enable,
};
bool spm_is_md1_sleep(void)
{
return !(plat_mmio_read(SRC_REQ_STA_0) & 0x3F);
}
EXPORT_SYMBOL(spm_is_md1_sleep);
int __init mt6853_lpm_trace_init(void)
{
struct device_node *node = NULL;
node = of_find_compatible_node(NULL, NULL, "mediatek,sleep");
if (node) {
spm_base = of_iomap(node, 0);
of_node_put(node);
}
mtk_spm_sysfs_root_entry_create();
mtk_spm_sysfs_entry_node_add("spm_dump_res_req_enable", 0444
, &spm_resource_req_timer_enable_fops, NULL);
return 0;
}
late_initcall_sync(mt6853_lpm_trace_init);
@@ -0,0 +1,270 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/pm_qos.h>
#include <mtk_lpm.h>
#include <mtk_lp_plat_reg.h>
#include "mtk_cpupm_dbg.h"
#include "mtk_cpuidle_cpc.h"
static DEFINE_SPINLOCK(cpc_prof_spin_lock);
/* profile latecny */
#define PROF_DEV_NAME_SIZE 36
#define get_core_type_index(cpu) ((cpu > 3) ? CPU_TYPE_B : CPU_TYPE_L)
struct mtk_cpc_lat_data {
char name[PROF_DEV_NAME_SIZE];
unsigned int on_sum;
unsigned int on_max;
unsigned int off_sum;
unsigned int off_max;
unsigned int on_cnt;
unsigned int off_cnt;
};
struct mtk_cpc_device {
union {
struct mtk_cpc_lat_data p[DEV_TYPE_NUM];
struct {
struct mtk_cpc_lat_data cpu[NF_CPU_TYPE];
struct mtk_cpc_lat_data cluster;
struct mtk_cpc_lat_data mcusys;
};
};
bool prof_en;
};
struct mtk_cpc_device cpc;
static void mtk_cpc_clr_lat(void)
{
unsigned int size;
unsigned int ofs;
int i;
ofs = sizeof(cpc.p[0].name);
size = sizeof(struct mtk_cpc_lat_data) - ofs;
for (i = 0; i < DEV_TYPE_NUM; i++)
memset((char *)&cpc.p[i] + ofs, 0, size);
}
static void mtk_cpc_cal_lat(void)
{
}
#define __mtk_cpc_record_lat(sum, max, lat) \
do { \
if (lat > max) \
max = lat; \
(sum) += (lat); \
} while (0)
static void mtk_cpc_record_lat(struct mtk_cpc_lat_data *lat,
unsigned int on_ticks, unsigned int off_ticks)
{
unsigned long flags;
if ((on_ticks == 0) || (off_ticks == 0))
return;
spin_lock_irqsave(&cpc_prof_spin_lock, flags);
__mtk_cpc_record_lat(lat->on_sum, lat->on_max, on_ticks);
lat->on_cnt++;
__mtk_cpc_record_lat(lat->off_sum, lat->off_max, off_ticks);
lat->off_cnt++;
spin_unlock_irqrestore(&cpc_prof_spin_lock, flags);
}
static void mtk_cpc_save_cpu_lat(int cpu)
{
unsigned int lat, on, off;
lat = mtk_cpupm_mcusys_read(CPC_CPU_LATENCY(cpu));
on = (lat >> 16) & 0xFFFF;
off = lat & 0xFFFF;
mtk_cpc_record_lat(&cpc.cpu[get_core_type_index(cpu)],
on, off);
}
static void mtk_cpc_save_cpusys_lat(void)
{
unsigned int lat_on, lat_off, on, off;
lat_on = mtk_cpupm_mcusys_read(CPC_CLUSTER_ON_LATENCY);
lat_off = mtk_cpupm_mcusys_read(CPC_CLUSTER_OFF_LATENCY);
on = lat_on & 0xFFFF;
off = lat_off & 0xFFFF;
mtk_cpc_record_lat(&cpc.cluster, on, off);
}
static void mtk_cpc_save_mcusys_lat(void)
{
unsigned int lat, on, off;
lat = mtk_cpupm_mcusys_read(CPC_MCUSYS_LATENCY);
on = (lat >> 16) & 0xFFFF;
off = lat & 0xFFFF;
mtk_cpc_record_lat(&cpc.mcusys, on, off);
}
static bool mtk_cpc_did_cluster_pwr_off(void)
{
static unsigned int last_cnt;
unsigned int cnt = mtk_cpupm_mcusys_read(CPC_DORMANT_COUNTER);
/**
* Cluster off count
* bit[0:15] : memory retention
* bit[16:31] : memory off
*/
if ((cnt & 0x7FFF) == 0)
cnt = ((cnt >> 16) & 0x7FFF);
else
cnt = cnt & 0x7FFF;
cnt += mtk_cpupm_syssram_read(SYSRAM_CPC_CPUSYS_CNT_BACKUP);
if (last_cnt == cnt)
return false;
last_cnt = cnt;
return true;
}
static bool mtk_cpc_did_mcusys_pwr_off(void)
{
static unsigned int last_cnt;
unsigned int cnt = mtk_cpupm_syssram_read(SYSRAM_MCUPM_MCUSYS_COUNTER);
cnt += mtk_cpupm_syssram_read(SYSRAM_MCUSYS_CNT);
if (last_cnt == cnt)
return false;
last_cnt = cnt;
return true;
}
static void mtk_cpc_save_latency(int cpu)
{
mtk_cpc_save_cpu_lat(cpu);
if (mtk_cpc_did_mcusys_pwr_off())
mtk_cpc_save_mcusys_lat();
else if (!mtk_cpc_did_cluster_pwr_off())
return;
mtk_cpc_save_cpusys_lat();
}
void mtk_cpc_prof_lat_dump(struct seq_file *m)
{
struct mtk_cpc_lat_data *lat;
int i;
for (i = 0; i < DEV_TYPE_NUM; i++) {
lat = &cpc.p[i];
seq_printf(m, "%s\n", lat->name);
if (lat->off_cnt) {
seq_printf(m, "\toff : avg = %2dus, max = %3dus, cnt = %d\n",
cpc_tick_to_us(lat->off_sum / lat->off_cnt),
cpc_tick_to_us(lat->off_max),
lat->off_cnt);
} else {
seq_puts(m, "\toff : None\n");
}
if (lat->on_cnt) {
seq_printf(m, "\ton : avg = %2dus, max = %3dus, cnt = %d\n",
cpc_tick_to_us(lat->on_sum / lat->on_cnt),
cpc_tick_to_us(lat->on_max),
lat->on_cnt);
} else {
seq_puts(m, "\ton : None\n");
}
}
}
void mtk_cpc_prof_start(void)
{
mtk_cpupm_block();
cpc_prof_en();
mtk_cpc_clr_lat();
cpc.prof_en = true;
mtk_cpupm_allow();
}
void mtk_cpc_prof_stop(void)
{
mtk_cpupm_block();
cpc.prof_en = false;
mtk_cpc_cal_lat();
cpc_prof_dis();
mtk_cpupm_allow();
}
int mtk_cpc_notify(struct notifier_block *nb,
unsigned long action, void *data)
{
struct mtk_lpm_nb_data *nb_data = (struct mtk_lpm_nb_data *)data;
if (!cpc.prof_en)
return NOTIFY_OK;
if (action & MTK_LPM_NB_BEFORE_REFLECT)
mtk_cpc_save_latency(nb_data->cpu);
return NOTIFY_OK;
}
struct notifier_block mtk_cpc_nb = {
.notifier_call = mtk_cpc_notify,
};
int __init mtk_cpc_init(void)
{
cpc.prof_en = false;
snprintf(cpc.cpu[CPU_TYPE_L].name, PROF_DEV_NAME_SIZE, "cpu_L");
snprintf(cpc.cpu[CPU_TYPE_B].name, PROF_DEV_NAME_SIZE, "cpu_B");
snprintf(cpc.cluster.name, PROF_DEV_NAME_SIZE, "cluster");
snprintf(cpc.mcusys.name, PROF_DEV_NAME_SIZE, "mcusys");
mtk_lpm_notifier_register(&mtk_cpc_nb);
return 0;
}
void __exit mtk_cpc_exit(void)
{
mtk_lpm_notifier_unregister(&mtk_cpc_nb);
}
@@ -0,0 +1,100 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_CPUIDLE_CPC_H__
#define __MTK_CPUIDLE_CPC_H__
#include <linux/seq_file.h>
#include <mtk_lpm_module.h>
enum {
CPU_TYPE_L,
CPU_TYPE_B,
NF_CPU_TYPE
};
enum {
CPC_SMC_EVENT_DUMP_TRACE_DATA,
CPC_SMC_EVENT_GIC_DPG_SET,
CPC_SMC_EVENT_CPC_CONFIG,
CPC_SMC_EVENT_READ_CONFIG,
NF_CPC_SMC_EVENT
};
enum {
CPC_SMC_CONFIG_PROF,
CPC_SMC_CONFIG_AUTO_OFF,
CPC_SMC_CONFIG_AUTO_OFF_THRES,
CPC_SMC_CONFIG_CNT_CLR,
CPC_SMC_CONFIG_TIME_SYNC,
NF_CPC_SMC_CONFIG
};
/**
* number of profile type :
* - (number of cpu type) + cluster + mcusys
*/
#define DEV_TYPE_NUM (NF_CPU_TYPE + 2)
/* smc */
#define mtk_cpc_smc(act, arg1, arg2)\
mtk_lpm_smc_cpu_pm(CPC_COMMAND, act, arg1, arg2)
/* configuration */
#define cpc_prof_en()\
mtk_cpc_smc(CPC_SMC_EVENT_CPC_CONFIG\
, CPC_SMC_CONFIG_PROF, 1)
#define cpc_prof_dis()\
mtk_cpc_smc(CPC_SMC_EVENT_CPC_CONFIG\
, CPC_SMC_CONFIG_PROF, 0)
#define cpc_auto_off_en()\
mtk_cpc_smc(CPC_SMC_EVENT_CPC_CONFIG\
, CPC_SMC_CONFIG_AUTO_OFF, 1)
#define cpc_auto_off_dis()\
mtk_cpc_smc(CPC_SMC_EVENT_CPC_CONFIG\
, CPC_SMC_CONFIG_AUTO_OFF, 0)
#define cpc_set_auto_off_thres(us)\
mtk_cpc_smc(CPC_SMC_EVENT_CPC_CONFIG\
, CPC_SMC_CONFIG_AUTO_OFF_THRES, us)
#define cpc_cluster_cnt_clr()\
mtk_cpc_smc(CPC_SMC_EVENT_CPC_CONFIG\
, CPC_SMC_CONFIG_CNT_CLR, 0)
#define cpc_time_sync()\
mtk_cpc_smc(CPC_SMC_EVENT_CPC_CONFIG\
, CPC_SMC_CONFIG_TIME_SYNC, 0)
/* status */
#define cpc_get_prof_sta()\
mtk_cpc_smc(CPC_SMC_EVENT_READ_CONFIG\
, CPC_SMC_CONFIG_PROF, 0)
#define cpc_get_auto_off_sta()\
mtk_cpc_smc(CPC_SMC_EVENT_READ_CONFIG\
, CPC_SMC_CONFIG_AUTO_OFF, 0)
#define cpc_get_auto_off_thres()\
mtk_cpc_smc(CPC_SMC_EVENT_READ_CONFIG\
, CPC_SMC_CONFIG_AUTO_OFF_THRES, 0)
#define cpc_tick_to_us(val) ((val) / 13)
void mtk_cpc_prof_start(void);
void mtk_cpc_prof_stop(void);
void mtk_cpc_prof_lat_dump(struct seq_file *m);
int __init mtk_cpc_init(void);
void __exit mtk_cpc_exit(void);
#endif /* __MTK_CPUIDLE_CPC_H__ */
@@ -0,0 +1,665 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/cpuidle.h>
#include <linux/sched/clock.h>
#include <linux/cpu.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/pm_qos.h>
#include <linux/tick.h>
#include <linux/timer.h>
#include <mboot_params.h>
//#include <mtk_ram_console.h>
#include <mt6853_spm_comm.h>
#include <mtk_lpm.h>
#include <mtk_lp_plat_reg.h>
#include "mtk_cpupm_dbg.h"
#include "mtk_cpuidle_status.h"
#include "mtk_cpuidle_cpc.h"
#define DUMP_INTERVAL sec_to_ns(5)
static u64 last_dump_ns;
static unsigned long long mtk_lpm_last_cpuidle_dis;
/* stress test */
static unsigned int timer_interval = 10 * 1000;
static struct task_struct *stress_tsk[NR_CPUS];
/* CPU off state : core, cluster and mcusys */
#define CPU_OFF_MAX_LV (3)
/* all core idle profiling */
struct all_cpu_idle_data {
unsigned long long last_ns;
unsigned long long dur_ns;
unsigned int cnt;
unsigned int bp; /* basis points : 0.01% */
};
struct all_cpu_idle {
unsigned long long start_us;
struct all_cpu_idle_data lv[CPU_OFF_MAX_LV];
};
static struct all_cpu_idle all_core_off;
/* idle ratio profiling */
struct mtk_cpuidle_ratio {
unsigned long long start_us;
unsigned long long idle_time_ns[CPUIDLE_STATE_MAX];
unsigned int bp[CPUIDLE_STATE_MAX];
};
/* idle latency profiling */
struct mtk_cpuidle_prof {
unsigned int cnt;
unsigned int max;
union {
u64 avg;
u64 sum;
};
};
/* idle information */
struct mtk_cpuidle_info {
u64 enter_time_ns;
int idle_index;
int cnt[CPUIDLE_STATE_MAX];
};
/* mtk cpu idle status */
struct mtk_cpuidle_device {
struct mtk_cpuidle_ratio ratio;
struct mtk_cpuidle_info info;
struct mtk_cpuidle_prof prof;
struct hrtimer timer;
int cpu;
int state_count;
bool tmr_running;
};
static DEFINE_PER_CPU(struct mtk_cpuidle_device, mtk_cpuidle_dev);
/* mtk cpu idle configuration */
struct mtk_cpuidle_control {
bool tmr_en;
bool prof_en;
bool log_en;
bool stress_en;
};
static struct mtk_cpuidle_control mtk_cpuidle_ctrl;
static int mtk_cpuidle_stress_task(void *arg)
{
while (mtk_cpuidle_ctrl.stress_en)
usleep_range(timer_interval - 10, timer_interval + 10);
return 0;
}
static void mtk_cpuidle_stress_start(void)
{
int i;
char name[20] = {0};
int ret = 0;
if (mtk_cpuidle_ctrl.stress_en)
return;
mtk_cpuidle_ctrl.stress_en = true;
for_each_online_cpu(i) {
ret = scnprintf(name, sizeof(name), "mtk_cpupm_stress_%d", i);
stress_tsk[i] =
kthread_create(mtk_cpuidle_stress_task, NULL, name);
if (!IS_ERR(stress_tsk[i])) {
kthread_bind(stress_tsk[i], i);
wake_up_process(stress_tsk[i]);
}
}
}
static void mtk_cpuidle_stress_stop(void)
{
mtk_cpuidle_ctrl.stress_en = false;
msleep(20);
}
void mtk_cpuidle_set_stress_test(bool en)
{
if (en)
mtk_cpuidle_stress_start();
else
mtk_cpuidle_stress_stop();
}
bool mtk_cpuidle_get_stress_status(void)
{
return mtk_cpuidle_ctrl.stress_en;
}
void mtk_cpuidle_set_stress_time(unsigned int val)
{
timer_interval = clamp_val(val, 100, 20000);
}
unsigned int mtk_cpuidle_get_stress_time(void)
{
return timer_interval;
}
void mtk_cpuidle_ctrl_timer_en(bool enable)
{
mtk_cpupm_block();
mtk_cpuidle_ctrl.tmr_en = enable;
mtk_cpupm_allow();
}
bool mtk_cpuidle_ctrl_timer_sta_get(void)
{
return mtk_cpuidle_ctrl.tmr_en;
}
void mtk_cpuidle_ctrl_log_en(bool enable)
{
mtk_cpupm_block();
mtk_cpuidle_ctrl.log_en = enable;
mtk_cpupm_allow();
}
bool mtk_cpuidle_ctrl_log_sta_get(void)
{
return mtk_cpuidle_ctrl.log_en;
}
static void _mtk_cpuidle_prof_ratio_start(void *data)
{
int i, cpu;
struct mtk_cpuidle_device *mtk_idle;
cpu = get_cpu();
mtk_idle = &per_cpu(mtk_cpuidle_dev, cpu);
put_cpu();
if (unlikely(!mtk_idle))
return;
mtk_idle->ratio.start_us = div64_u64(sched_clock(), 1000);
for (i = 0; i < mtk_idle->state_count; i++)
mtk_idle->ratio.idle_time_ns[i] = 0;
}
void mtk_cpuidle_prof_ratio_start(void)
{
int i;
if (mtk_cpuidle_ctrl.prof_en)
return;
mtk_cpupm_block();
for (i = 0; i < CPU_OFF_MAX_LV; i++) {
all_core_off.lv[i].dur_ns = 0;
all_core_off.lv[i].cnt = 0;
}
all_core_off.start_us = div64_u64(sched_clock(), 1000);
on_each_cpu(_mtk_cpuidle_prof_ratio_start, NULL, 1);
mtk_cpuidle_ctrl.prof_en = true;
mtk_cpupm_allow();
}
static void _mtk_cpuidle_prof_ratio_stop(void *stop_time)
{
int i, cpu;
uint64_t dur_us;
struct mtk_cpuidle_device *mtk_idle;
cpu = get_cpu();
mtk_idle = &per_cpu(mtk_cpuidle_dev, cpu);
put_cpu();
if (unlikely(!mtk_idle))
return;
dur_us = div64_u64(sched_clock(), 1000) -
mtk_idle->ratio.start_us;
for (i = 0; i < mtk_idle->state_count; i++)
mtk_idle->ratio.bp[i] = (unsigned int)div64_u64(
mtk_idle->ratio.idle_time_ns[i] * 10,
dur_us);
}
void mtk_cpuidle_prof_ratio_stop(void)
{
int i;
uint64_t time_us;
if (!mtk_cpuidle_ctrl.prof_en)
return;
mtk_cpupm_block();
on_each_cpu(_mtk_cpuidle_prof_ratio_stop, NULL, 1);
mtk_cpuidle_ctrl.prof_en = false;
time_us = div64_u64(sched_clock(), 1000) - all_core_off.start_us;
for (i = 0; i < CPU_OFF_MAX_LV; i++)
all_core_off.lv[i].bp = (unsigned int)div64_u64(
all_core_off.lv[i].dur_ns * 10, time_us);
mtk_cpupm_allow();
}
void mtk_cpuidle_prof_ratio_dump(struct seq_file *m)
{
int i, cpu;
struct mtk_cpuidle_device *mtk_idle;
seq_printf(m, "%6s%12s%12s%12s\n",
"",
"cpu_off",
"cluster_off",
"mcusys_off");
for_each_possible_cpu(cpu) {
mtk_idle = &per_cpu(mtk_cpuidle_dev, cpu);
if (!mtk_idle)
continue;
seq_printf(m, "cpu%d: ", cpu);
for (i = 1; i < mtk_idle->state_count; i++) {
seq_printf(m, "%5s%3u.%02u%%",
"",
mtk_idle->ratio.bp[i] / 100,
mtk_idle->ratio.bp[i] % 100);
}
seq_puts(m, "\n");
}
seq_puts(m, "All core off ratio :\n");
for (i = 0; i < CPU_OFF_MAX_LV; i++)
seq_printf(m, "\t C_%d = %3u.%02u%%\n",
i + 1,
all_core_off.lv[i].bp / 100,
all_core_off.lv[i].bp % 100);
}
void mtk_cpuidle_state_enable(bool en)
{
struct cpuidle_driver *drv;
int i, cpu;
int suspend_type = mtk_lpm_suspend_type_get();
mtk_cpupm_block();
for_each_possible_cpu(cpu) {
drv = cpuidle_get_cpu_driver(per_cpu(cpuidle_devices, cpu));
if (!drv)
continue;
for (i = drv->state_count - 1; i > 0; i--) {
if ((suspend_type == MTK_LPM_SUSPEND_S2IDLE) &&
!strcmp(drv->states[i].name, S2IDLE_STATE_NAME))
continue;
mtk_cpuidle_set_param(drv, i, IDLE_PARAM_EN, en);
}
}
if (!en)
mtk_lpm_last_cpuidle_dis = sched_clock();
mtk_cpupm_allow();
}
void mtk_s2idle_state_enable(bool en)
{
struct cpuidle_driver *drv;
int i, cpu;
int suspend_type = mtk_lpm_suspend_type_get();
mtk_cpupm_block();
for_each_possible_cpu(cpu) {
drv = cpuidle_get_cpu_driver(per_cpu(cpuidle_devices, cpu));
if (!drv)
continue;
i = drv->state_count - 1;
if ((suspend_type == MTK_LPM_SUSPEND_S2IDLE) &&
!strcmp(drv->states[i].name, S2IDLE_STATE_NAME)) {
mtk_cpuidle_set_param(drv, i, IDLE_PARAM_EN, en);
}
}
if (!en)
mtk_lpm_last_cpuidle_dis = sched_clock();
mtk_cpupm_allow();
}
unsigned long long mtk_cpuidle_state_last_dis_ms(void)
{
return (mtk_lpm_last_cpuidle_dis / 1000000);
}
static bool mtk_cpuidle_need_dump(unsigned int idx)
{
u64 curr_ns;
bool dump = false;
if (!mtk_cpuidle_ctrl.log_en || !idx)
return false;
curr_ns = sched_clock();
if (curr_ns - last_dump_ns > DUMP_INTERVAL) {
last_dump_ns = curr_ns;
dump = true;
}
return dump;
}
static unsigned int mtk_cpuidle_get_cluster_off_cnt(void)
{
unsigned int cnt = mtk_cpupm_mcusys_read(CPC_DORMANT_COUNTER);
/**
* Cluster off count
* bit[0:15] : memory retention
* bit[16:31] : memory off
*/
if ((cnt & 0x7FFF) == 0)
cnt = ((cnt >> 16) & 0x7FFF);
else
cnt = cnt & 0x7FFF;
cnt += mtk_cpupm_syssram_read(SYSRAM_CPC_CPUSYS_CNT_BACKUP);
cpc_cluster_cnt_clr();
mtk_cpupm_syssram_write(SYSRAM_CPC_CPUSYS_CNT_BACKUP, 0);
/**
* Add mcusys off count because CPC cluster counter will be cleared
* when mcusys power off.
*/
cnt += mtk_cpupm_syssram_read(SYSRAM_MCUPM_MCUSYS_COUNTER);
mtk_cpupm_syssram_write(SYSRAM_CPUSYS_CNT,
mtk_cpupm_syssram_read(SYSRAM_CPUSYS_CNT) + cnt);
return cnt;
}
static unsigned int mtk_cpuidle_get_mcusys_off_cnt(void)
{
unsigned int cnt = mtk_cpupm_syssram_read(SYSRAM_MCUPM_MCUSYS_COUNTER);
mtk_cpupm_syssram_write(SYSRAM_MCUPM_MCUSYS_COUNTER, 0);
mtk_cpupm_syssram_write(SYSRAM_MCUSYS_CNT,
mtk_cpupm_syssram_read(SYSRAM_MCUSYS_CNT) + cnt);
return cnt;
}
static void mtk_cpuidle_dump_info(void)
{
struct mtk_cpuidle_device *mtk_idle;
int cpu, idx, ofs;
unsigned int avail_cpu_mask = 0;
for_each_possible_cpu(cpu) {
if (cpu_online(cpu))
avail_cpu_mask |= (1 << cpu);
mtk_idle = &per_cpu(mtk_cpuidle_dev, cpu);
if (!mtk_idle)
continue;
ofs = SYSRAM_RECENT_CPU_CNT(cpu);
mtk_cpupm_syssram_write(ofs, 0);
for (idx = 1; idx < mtk_idle->state_count ; idx++) {
mtk_cpupm_syssram_write(ofs, mtk_cpupm_syssram_read(ofs)
+ mtk_idle->info.cnt[idx]);
mtk_idle->info.cnt[idx] = 0;
}
}
/* Should calculate cluster off count before mcusys counter reset */
mtk_cpupm_syssram_write(SYSRAM_RECENT_CPUSYS_CNT,
mtk_cpuidle_get_cluster_off_cnt());
mtk_cpupm_syssram_write(SYSRAM_RECENT_MCUSYS_CNT,
mtk_cpuidle_get_mcusys_off_cnt());
mtk_cpupm_syssram_write(SYSRAM_CPU_ONLINE, avail_cpu_mask);
mtk_cpupm_syssram_write(SYSRAM_RECENT_CNT_TS_H,
(unsigned int)((last_dump_ns >> 32) & 0xFFFFFFFF));
mtk_cpupm_syssram_write(SYSRAM_RECENT_CNT_TS_L,
(unsigned int)(last_dump_ns & 0xFFFFFFFF));
}
static enum hrtimer_restart mtk_cpuidle_hrtimer_func(struct hrtimer *timer)
{
return HRTIMER_NORESTART;
}
static void mtk_cpuidle_set_timer(struct mtk_cpuidle_device *mtk_idle)
{
int index;
int limit_sleep_us;
struct cpuidle_driver *drv;
if (!mtk_cpuidle_ctrl.tmr_en)
return;
index = mtk_idle->info.idle_index;
/* Only support WFI/CPU_OFF state */
if (index > 1)
return;
drv = cpuidle_get_driver();
if (unlikely(!drv))
return;
if (index + 1 >= mtk_idle->state_count
|| !tick_nohz_tick_stopped())
return;
limit_sleep_us = 4 * max_t(unsigned int,
get_residency(drv, index),
get_residency(drv, index + 1));
if (index != 0)
tick_broadcast_exit();
RCU_NONIDLE(hrtimer_start(&mtk_idle->timer,
ns_to_ktime(limit_sleep_us * NSEC_PER_USEC),
HRTIMER_MODE_REL_PINNED));
mtk_idle->tmr_running = true;
if (index != 0)
tick_broadcast_enter();
}
static void mtk_cpuidle_cancel_timer(struct mtk_cpuidle_device *mtk_idle)
{
if (!mtk_cpuidle_ctrl.tmr_en)
return;
if (mtk_idle->tmr_running) {
mtk_idle->tmr_running = true;
RCU_NONIDLE(hrtimer_try_to_cancel(&mtk_idle->timer));
}
}
static void mtk_cpuidle_set_last_off_ts(int idx)
{
int i;
uint64_t curr_ns = sched_clock();
if (!idx)
return;
if (idx > CPU_OFF_MAX_LV)
idx = CPU_OFF_MAX_LV;
for (i = 0; i < idx; i++) {
all_core_off.lv[i].cnt++;
if (all_core_off.lv[i].cnt == num_online_cpus())
all_core_off.lv[i].last_ns = curr_ns;
}
}
static void mtk_cpuidle_save_idle_time(int idx)
{
int i;
uint64_t curr_ns = sched_clock();
if (!idx)
return;
if (idx > CPU_OFF_MAX_LV)
idx = CPU_OFF_MAX_LV;
for (i = 0; i < idx; i++) {
if (all_core_off.lv[i].cnt == num_online_cpus())
all_core_off.lv[i].dur_ns += (curr_ns
- all_core_off.lv[i].last_ns);
all_core_off.lv[i].cnt--;
}
}
static int mtk_cpuidle_status_update(struct notifier_block *nb,
unsigned long action, void *data)
{
struct mtk_cpuidle_device *mtk_idle;
struct mtk_lpm_nb_data *nb_data = (struct mtk_lpm_nb_data *)data;
if (action & MTK_LPM_NB_BEFORE_REFLECT) {
/* prevent race conditions by mtk_lp_mod_locker */
if (mtk_cpuidle_ctrl.prof_en)
mtk_cpuidle_save_idle_time(nb_data->index);
if (mtk_cpuidle_need_dump(nb_data->index))
mtk_cpuidle_dump_info();
} else if (action & MTK_LPM_NB_RESUME) {
aee_rr_rec_mcdi_val(nb_data->cpu,
(nb_data->index << 16) | 0x0);
mtk_idle = &per_cpu(mtk_cpuidle_dev, nb_data->cpu);
mtk_idle->info.idle_index = -1;
mtk_idle->info.cnt[nb_data->index]++;
if (mtk_cpuidle_ctrl.prof_en)
mtk_idle->ratio.idle_time_ns[nb_data->index] +=
(sched_clock() - mtk_idle->info.enter_time_ns);
mtk_cpuidle_cancel_timer(mtk_idle);
} else if (action & MTK_LPM_NB_AFTER_PROMPT) {
/* prevent race conditions by mtk_lp_mod_locker */
if (mtk_cpuidle_ctrl.prof_en)
mtk_cpuidle_set_last_off_ts(nb_data->index);
} else if (action & MTK_LPM_NB_PREPARE) {
mtk_idle = &per_cpu(mtk_cpuidle_dev, nb_data->cpu);
mtk_idle->info.idle_index = nb_data->index;
mtk_idle->info.enter_time_ns = sched_clock();
mtk_cpuidle_set_timer(mtk_idle);
aee_rr_rec_mcdi_val(nb_data->cpu,
(nb_data->index << 16) | 0xff);
}
return NOTIFY_OK;
}
struct notifier_block mtk_cpuidle_status_nb = {
.notifier_call = mtk_cpuidle_status_update,
};
static void mtk_cpuidle_init_per_cpu(void *info)
{
struct mtk_cpuidle_device *mtk_idle;
int cpu;
cpu = get_cpu();
mtk_idle = &per_cpu(mtk_cpuidle_dev, cpu);
put_cpu();
hrtimer_init(&mtk_idle->timer,
CLOCK_MONOTONIC, HRTIMER_MODE_REL);
mtk_idle->cpu = cpu;
mtk_idle->timer.function = mtk_cpuidle_hrtimer_func;
mtk_idle->state_count = mtk_cpupm_get_idle_state_count(cpu);
}
int __init mtk_cpuidle_status_init(void)
{
mtk_cpuidle_ctrl.tmr_en = true;
mtk_cpuidle_ctrl.prof_en = false;
mtk_cpuidle_ctrl.log_en = true;
mtk_cpuidle_ctrl.stress_en = false;
mtk_cpupm_block();
on_each_cpu(mtk_cpuidle_init_per_cpu, NULL, 0);
mtk_cpupm_allow();
mtk_lpm_notifier_register(&mtk_cpuidle_status_nb);
return 0;
}
void __exit mtk_cpuidle_status_exit(void)
{
mtk_lpm_notifier_unregister(&mtk_cpuidle_status_nb);
}
@@ -0,0 +1,73 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_CPUIDLE_STATUS_H__
#define __MTK_CPUIDLE_STATUS_H__
#include <linux/seq_file.h>
#define sec_to_ns(v) ((v) * 1000 * 1000 * 1000ULL)
#define S2IDLE_STATE_NAME "s2idle"
enum {
IDLE_PARAM_LAT,
IDLE_PARAM_RES,
IDLE_PARAM_EN,
NF_IDLE_PARAM
};
#define get_residency(drv, idx)\
((drv)->states[idx].target_residency)
#define get_latency(drv, idx)\
((drv)->states[idx].exit_latency)
#define get_disabled(drv, idx)\
((drv)->states[idx].disabled)
#define mtk_cpuidle_get_param(drv, state, param) \
({ \
int val = -1; \
if (param == IDLE_PARAM_LAT) \
val = (int)get_latency(drv, state); \
else if (param == IDLE_PARAM_RES) \
val = (int)get_residency(drv, state); \
else if (param == IDLE_PARAM_EN) \
val = get_disabled(drv, state) ? 0 : 1 ; \
val; \
})
#define mtk_cpuidle_set_param(drv, state, param, val) \
do { \
if (param == IDLE_PARAM_LAT) \
get_latency(drv, state) = val; \
else if (param == IDLE_PARAM_RES) \
get_residency(drv, state) = val; \
else if (param == IDLE_PARAM_EN) \
get_disabled(drv, state) = !val ; \
} while (0)
void mtk_cpuidle_set_stress_test(bool en);
bool mtk_cpuidle_get_stress_status(void);
void mtk_cpuidle_set_stress_time(unsigned int val);
unsigned int mtk_cpuidle_get_stress_time(void);
void mtk_cpuidle_prof_ratio_start(void);
void mtk_cpuidle_prof_ratio_stop(void);
void mtk_cpuidle_prof_ratio_dump(struct seq_file *m);
void mtk_cpuidle_ctrl_timer_en(bool enable);
bool mtk_cpuidle_ctrl_timer_sta_get(void);
void mtk_cpuidle_ctrl_log_en(bool enable);
bool mtk_cpuidle_ctrl_log_sta_get(void);
void mtk_cpuidle_state_enable(bool en);
void mtk_s2idle_state_enable(bool en);
int __init mtk_cpuidle_status_init(void);
void __exit mtk_cpuidle_status_exit(void);
unsigned long long mtk_cpuidle_state_last_dis_ms(void);
#endif /* __MTK_CPUIDLE_STATUS_H__ */
@@ -0,0 +1,161 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_address.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/cpuidle.h>
#include <linux/pm_qos.h>
#include "mtk_cpuidle_status.h"
#include "mtk_cpuidle_cpc.h"
#include "mtk_idle_procfs.h"
static void __iomem *cpupm_mcusys_base_addr;
static void __iomem *cpupm_syssram_base_addr;
static struct pm_qos_request cpuidle_dbg_qos_req;
int mtk_cpupm_mcusys_write(int ofs, unsigned int val)
{
if (!cpupm_mcusys_base_addr)
return -EADDRNOTAVAIL;
if ((ofs % 4) != 0)
return -EINVAL;
__raw_writel(val, cpupm_mcusys_base_addr + ofs);
mb(); /* make sure register access in order */
return 0;
}
unsigned int mtk_cpupm_mcusys_read(int ofs)
{
if (!cpupm_mcusys_base_addr)
return 0;
if ((ofs % 4) != 0)
return 0;
return __raw_readl(cpupm_mcusys_base_addr + ofs);
}
int mtk_cpupm_syssram_write(int ofs, unsigned int val)
{
if (!cpupm_syssram_base_addr)
return -EADDRNOTAVAIL;
if ((ofs % 4) != 0)
return -EINVAL;
__raw_writel(val, cpupm_syssram_base_addr + ofs);
mb(); /* make sure register access in order */
return 0;
}
unsigned int mtk_cpupm_syssram_read(int ofs)
{
if (!cpupm_syssram_base_addr)
return 0;
if ((ofs % 4) != 0)
return 0;
return __raw_readl(cpupm_syssram_base_addr + ofs);
}
void mtk_cpupm_block(void)
{
pm_qos_update_request(&cpuidle_dbg_qos_req, 2);
}
void mtk_cpupm_allow(void)
{
pm_qos_update_request(&cpuidle_dbg_qos_req, PM_QOS_DEFAULT_VALUE);
}
int mtk_cpupm_get_idle_state_count(int cpu)
{
struct device_node *state_node, *cpu_node;
int i, state_count, start_idx = 1;
cpu_node = of_cpu_device_node_get(cpu);
if (!cpu_node)
return start_idx;
for (i = 0; ; i++) {
state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i);
if (!state_node)
break;
of_node_put(state_node);
}
of_node_put(cpu_node);
state_count = i + start_idx;
if (state_count > CPUIDLE_STATE_MAX)
state_count = CPUIDLE_STATE_MAX;
return state_count;
}
static void __init mtk_cpupm_node_init(void)
{
struct device_node *node = NULL;
cpupm_mcusys_base_addr = NULL;
cpupm_syssram_base_addr = NULL;
node = of_find_compatible_node(NULL, NULL,
"mediatek,mcusys-ctrl");
if (node) {
cpupm_mcusys_base_addr = of_iomap(node, 0);
of_node_put(node);
}
node = of_find_compatible_node(NULL, NULL,
"mediatek,cpupm-sysram");
if (node) {
cpupm_syssram_base_addr = of_iomap(node, 0);
of_node_put(node);
}
}
static int __init mtk_cpupm_dbg_init(void)
{
pm_qos_add_request(&cpuidle_dbg_qos_req,
PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE);
mtk_cpupm_node_init();
mtk_cpuidle_status_init();
mtk_cpc_init();
mtk_idle_procfs_init();
cpc_time_sync();
return 0;
}
static void __exit mtk_cpupm_dbg_exit(void)
{
mtk_idle_procfs_exit();
mtk_cpuidle_status_exit();
mtk_cpc_exit();
pm_qos_remove_request(&cpuidle_dbg_qos_req);
}
module_init(mtk_cpupm_dbg_init);
module_exit(mtk_cpupm_dbg_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("MediaTek CPU Idle Debug FileSystem");
MODULE_AUTHOR("MediaTek Inc.");
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_CPUPM_DBG_H__
#define __MTK_CPUPM_DBG_H__
int mtk_cpupm_mcusys_write(int ofs, unsigned int val);
unsigned int mtk_cpupm_mcusys_read(int ofs);
int mtk_cpupm_syssram_write(int ofs, unsigned int val);
unsigned int mtk_cpupm_syssram_read(int ofs);
void mtk_cpupm_block(void);
void mtk_cpupm_allow(void);
int mtk_cpupm_get_idle_state_count(int cpu);
#endif /* __MTK_CPUPM_DBG_H__ */
@@ -0,0 +1,158 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/seq_file.h>
#include <linux/cpuidle.h>
#include <mtk_lp_plat_reg.h>
#include <mtk_lpm.h>
#include <mt6853_spm_comm.h>
#include "mtk_cpupm_dbg.h"
#include "mtk_cpuidle_status.h"
#include "mtk_idle_procfs.h"
#define MTK_IDLE_PROC_FS_NAME "cpuidle"
static int idle_proc_info_show(struct seq_file *m, void *v)
{
int cpu;
unsigned long long ts, rem;
ts = mtk_cpupm_syssram_read(SYSRAM_RECENT_CNT_TS_H);
ts = (ts << 32) | mtk_cpupm_syssram_read(SYSRAM_RECENT_CNT_TS_L);
ts = div64_u64_rem(ts, 1000 * 1000 * 1000, &rem);
seq_puts(m, "\n========= Power off count =========\n");
seq_puts(m, "\n-- Within 5 seconds before dumped --\n");
seq_printf(m, "\nLast dump timestamp = %llu.%09llu\n",
ts, rem);
seq_printf(m, "%8s", "cpu:");
for_each_possible_cpu(cpu)
seq_printf(m, " %d", mtk_cpupm_syssram_read(
SYSRAM_RECENT_CPU_CNT(cpu)));
seq_puts(m, "\n");
seq_printf(m, "%8s %d\n",
"cluster:",
mtk_cpupm_syssram_read(SYSRAM_RECENT_CPUSYS_CNT));
seq_printf(m, "%8s %d\n",
"mcusys:",
mtk_cpupm_syssram_read(SYSRAM_RECENT_MCUSYS_CNT));
seq_printf(m, "%8s 0x%x\n",
"online:",
mtk_cpupm_syssram_read(SYSRAM_CPU_ONLINE));
seq_puts(m, "\n---- Total ----\n");
seq_printf(m, "%8s %d\n",
"cluster:",
mtk_cpupm_syssram_read(SYSRAM_CPUSYS_CNT)
+ mtk_cpupm_syssram_read(SYSRAM_RECENT_CPUSYS_CNT));
seq_printf(m, "%8s %d\n",
"mcusys:",
mtk_cpupm_syssram_read(SYSRAM_MCUSYS_CNT)
+ mtk_cpupm_syssram_read(SYSRAM_RECENT_MCUSYS_CNT));
return 0;
}
static ssize_t idle_proc_info_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
return count;
}
static int idle_proc_enable_show(struct seq_file *m, void *v)
{
struct cpuidle_driver *drv;
int i, cpu, en = 0;
int suspend_type = mtk_lpm_suspend_type_get();
for_each_possible_cpu(cpu) {
drv = cpuidle_get_cpu_driver(per_cpu(cpuidle_devices, cpu));
if (!drv)
continue;
for (i = 1; i < drv->state_count; i++) {
if ((suspend_type == MTK_LPM_SUSPEND_S2IDLE) &&
!strcmp(drv->states[i].name, S2IDLE_STATE_NAME))
continue;
en += mtk_cpuidle_get_param(drv, i, IDLE_PARAM_EN);
}
}
if (en == 0) {
seq_printf(m, "MCDI: Disable, %llu ms\n",
mtk_cpuidle_state_last_dis_ms());
} else {
seq_puts(m, "MCDI: Enable\n");
seq_puts(m,
"(cat /proc/cpuidle/state/enabled for more detail)\n");
}
return 0;
}
static ssize_t idle_proc_enable_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int enabled = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &enabled) != 0) {
ret = -EINVAL;
goto free;
}
mtk_cpuidle_state_enable(!!enabled);
free:
mtk_idle_procfs_free(buf);
return ret;
}
PROC_FOPS(info);
PROC_FOPS(enable);
int __init mtk_idle_procfs_init(void)
{
int i;
struct proc_dir_entry *dir = NULL;
const struct idle_proc_entry entries[] = {
PROC_ENTRY(info),
PROC_ENTRY(enable)
};
dir = proc_mkdir(MTK_IDLE_PROC_FS_NAME, NULL);
if (!dir) {
pr_notice("fail to create procfs @ %s()\n", __func__);
return -ENOMEM;
}
for (i = 0; i < ARRAY_SIZE(entries); i++)
PROC_CREATE_NODE(dir, entries[i]);
mtk_idle_procfs_state_dir_init(dir);
mtk_idle_procfs_cpc_dir_init(dir);
mtk_idle_procfs_profile_dir_init(dir);
mtk_idle_procfs_control_dir_init(dir);
return 0;
}
void __exit mtk_idle_procfs_exit(void)
{
remove_proc_subtree(MTK_IDLE_PROC_FS_NAME, NULL);
}
@@ -0,0 +1,75 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_IDLE_PROCFS__
#define __MTK_IDLE_PROCFS__
#include <linux/proc_fs.h>
#include <linux/uaccess.h>
struct idle_proc_entry {
const char *name;
const struct file_operations *fops;
};
#define PROC_FOPS(name) \
static int idle_proc_ ## name ## _open(struct inode *inode, struct file *file) \
{ \
return single_open(file, idle_proc_ ## name ## _show, PDE_DATA(inode));\
} \
static const struct file_operations idle_proc_ ## name ## _fops = { \
.owner = THIS_MODULE, \
.open = idle_proc_ ## name ## _open, \
.read = seq_read, \
.llseek = seq_lseek, \
.release = single_release, \
.write = idle_proc_ ## name ## _write, \
}
#define PROC_ENTRY(name) {__stringify(name), &idle_proc_ ## name ## _fops}
#define PROC_CREATE_NODE(dir, entry) \
do { \
if (!proc_create(entry.name, 0644, dir, entry.fops)) \
pr_notice("%s(), create procfs cpuidle node %s failed\n", \
__func__, entry.name); \
} while (0)
#define mtk_idle_procfs_alloc_from_user(buf, userbuf, count) \
do { \
buf = (char *)__get_free_page(GFP_USER); \
\
if (!buf) \
break; \
\
if (count >= PAGE_SIZE \
|| copy_from_user(buf, userbuf, count)) { \
free_page((unsigned long)buf); \
buf = NULL; \
break; \
} \
\
buf[count] = '\0'; \
\
} while (0)
#define mtk_idle_procfs_free(buf) \
do { \
if (!buf) \
break; \
\
free_page((unsigned long)buf); \
} while (0)
void __init mtk_idle_procfs_cpc_dir_init(struct proc_dir_entry *parent);
void __init mtk_idle_procfs_state_dir_init(struct proc_dir_entry *parent);
void __init mtk_idle_procfs_profile_dir_init(struct proc_dir_entry *parent);
void __init mtk_idle_procfs_control_dir_init(struct proc_dir_entry *parent);
int __init mtk_idle_procfs_init(void);
void __exit mtk_idle_procfs_exit(void);
#endif /* __MTK_IDLE_PROCFS__ */
@@ -0,0 +1,337 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/seq_file.h>
#include <mtk_lp_plat_apmcu_mbox.h>
#include "mtk_cpuidle_status.h"
#include "mtk_idle_procfs.h"
static int idle_proc_log_show(struct seq_file *m, void *v)
{
seq_printf(m, "CPU idle log : %s\n",
mtk_cpuidle_ctrl_log_sta_get() ?
"Enable" : "Disable");
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "echo [0|1] > /proc/cpuidle/control/log\n");
return 0;
}
static ssize_t idle_proc_log_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int enabled = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &enabled) != 0) {
ret = -EINVAL;
goto free;
}
mtk_cpuidle_ctrl_log_en(!!enabled);
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_timer_show(struct seq_file *m, void *v)
{
seq_printf(m, "Limit sleep timer : %s\n",
mtk_cpuidle_ctrl_timer_sta_get() ?
"Enable" : "Disable");
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "echo [0|1] > /proc/cpuidle/control/timer\n");
return 0;
}
static ssize_t idle_proc_timer_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int enabled = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &enabled) != 0) {
ret = -EINVAL;
goto free;
}
mtk_cpuidle_ctrl_timer_en(!!enabled);
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_stress_show(struct seq_file *m, void *v)
{
seq_printf(m, "CPU idle stress : %s\n",
mtk_cpuidle_get_stress_status() ?
"Enable" : "Disable");
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "echo [0|1] > /proc/cpuidle/control/stress\n");
return 0;
}
static ssize_t idle_proc_stress_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int enabled = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &enabled) != 0) {
ret = -EINVAL;
goto free;
}
mtk_cpuidle_set_stress_test(!!enabled);
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_stress_time_show(struct seq_file *m, void *v)
{
seq_printf(m, "CPU idle stress interval time : %u\n",
mtk_cpuidle_get_stress_time());
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "echo [us] > /proc/cpuidle/control/stress_time\n");
return 0;
}
static ssize_t idle_proc_stress_time_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int interval_us = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &interval_us) != 0) {
ret = -EINVAL;
goto free;
}
mtk_cpuidle_set_stress_time(interval_us);
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_buck_mode_show(struct seq_file *m, void *v)
{
int mode;
struct mode_param {
int id;
char *str;
};
const struct mode_param table[] = {
{MCUPM_BUCK_NORMAL_MODE, "on"},
{MCUPM_BUCK_LP_MODE, "low power"},
{MCUPM_BUCK_OFF_MODE, "off"},
{NF_MCUPM_BUCK_MODE, "unknown"},
};
mode = mtk_get_mcupm_buck_mode();
if (mode < 0 || mode > NF_MCUPM_BUCK_MODE)
mode = NF_MCUPM_BUCK_MODE;
seq_printf(m, "Vproc/Vproc_sram buck mode : %s\n",
table[mode].str);
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "echo [mode] > /proc/cpuidle/control/buck_mode\n");
seq_puts(m, "mode:\n");
for (mode = 0; mode < NF_MCUPM_BUCK_MODE; mode++)
seq_printf(m, "\t%d: %s\n",
table[mode].id,
table[mode].str);
return 0;
}
static ssize_t idle_proc_buck_mode_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int mode = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &mode) != 0) {
ret = -EINVAL;
goto free;
}
if (mode < NF_MCUPM_BUCK_MODE)
mtk_set_mcupm_buck_mode(mode);
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_armpll_mode_show(struct seq_file *m, void *v)
{
int mode;
struct mode_param {
int id;
char *str;
};
const struct mode_param table[] = {
{MCUPM_ARMPLL_ON, "on"},
{MCUPM_ARMPLL_GATING, "gating"},
{MCUPM_ARMPLL_OFF, "off"},
{NF_MCUPM_ARMPLL_MODE, "unknown"},
};
mode = mtk_get_mcupm_pll_mode();
if (mode < 0 || mode > NF_MCUPM_ARMPLL_MODE)
mode = NF_MCUPM_ARMPLL_MODE;
seq_printf(m, "armpll mode : %s\n",
table[mode].str);
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "echo [mode] > /proc/cpuidle/control/armpll_mode\n");
seq_puts(m, "mode:\n");
for (mode = 0; mode < NF_MCUPM_ARMPLL_MODE; mode++)
seq_printf(m, "\t%d: %s\n",
table[mode].id,
table[mode].str);
return 0;
}
static ssize_t idle_proc_armpll_mode_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int mode = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &mode) != 0) {
ret = -EINVAL;
goto free;
}
if (mode < NF_MCUPM_ARMPLL_MODE)
mtk_set_mcupm_pll_mode(mode);
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_notify_cm_show(struct seq_file *m, void *v)
{
bool notify;
notify = mtk_mcupm_cm_is_notified();
seq_printf(m, "mcupm cm mgr : %s\n",
notify ? "Enable" : "Disable");
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "Read Only : Not support dynamic control\n");
return 0;
}
static ssize_t idle_proc_notify_cm_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
return count;
}
PROC_FOPS(log);
PROC_FOPS(timer);
PROC_FOPS(stress);
PROC_FOPS(stress_time);
PROC_FOPS(buck_mode);
PROC_FOPS(armpll_mode);
PROC_FOPS(notify_cm);
void __init mtk_idle_procfs_control_dir_init(struct proc_dir_entry *parent)
{
int i;
struct proc_dir_entry *dir = NULL;
const struct idle_proc_entry entries[] = {
PROC_ENTRY(log),
PROC_ENTRY(timer),
PROC_ENTRY(stress),
PROC_ENTRY(stress_time),
PROC_ENTRY(buck_mode),
PROC_ENTRY(armpll_mode),
PROC_ENTRY(notify_cm)
};
dir = proc_mkdir("control", parent);
if (!dir) {
pr_notice("fail to create procfs @ %s()\n", __func__);
return;
}
for (i = 0; i < ARRAY_SIZE(entries); i++)
PROC_CREATE_NODE(dir, entries[i]);
}
@@ -0,0 +1,107 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/seq_file.h>
#include "mtk_cpuidle_cpc.h"
#include "mtk_idle_procfs.h"
static int idle_proc_auto_off_show(struct seq_file *m, void *v)
{
seq_printf(m, "auto_off mode : %s\n",
cpc_get_auto_off_sta() ? "Enabled" : "Disabled");
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "echo [0|1] > /proc/cpuidle/cpc/auto_off\n");
return 0;
}
static ssize_t idle_proc_auto_off_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int enabled = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &enabled) != 0) {
ret = -EINVAL;
goto free;
}
if (enabled)
cpc_auto_off_en();
else
cpc_auto_off_dis();
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_auto_off_thres_show(struct seq_file *m, void *v)
{
seq_printf(m, "auto_off threshold = %u us\n",
(unsigned int)cpc_get_auto_off_thres());
seq_puts(m, "\n======== Command Usage ========\n");
seq_puts(m, "echo [us] > /proc/cpuidle/cpc/auto_off_thres\n");
return 0;
}
static ssize_t idle_proc_auto_off_thres_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int threshold_us = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &threshold_us) != 0) {
ret = -EINVAL;
goto free;
}
cpc_set_auto_off_thres(threshold_us);
free:
mtk_idle_procfs_free(buf);
return ret;
}
PROC_FOPS(auto_off);
PROC_FOPS(auto_off_thres);
void __init mtk_idle_procfs_cpc_dir_init(struct proc_dir_entry *parent)
{
int i;
struct proc_dir_entry *dir = NULL;
const struct idle_proc_entry entries[] = {
PROC_ENTRY(auto_off),
PROC_ENTRY(auto_off_thres)
};
dir = proc_mkdir("cpc", parent);
if (!dir) {
pr_notice("fail to create procfs @ %s()\n", __func__);
return;
}
for (i = 0; i < ARRAY_SIZE(entries); i++)
PROC_CREATE_NODE(dir, entries[i]);
}
@@ -0,0 +1,173 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/seq_file.h>
#include "mtk_cpuidle_cpc.h"
#include "mtk_cpuidle_status.h"
#include "mtk_idle_procfs.h"
#include "mt6853_spm_comm.h"
static int idle_proc_kernel_show(struct seq_file *m, void *v)
{
seq_printf(m, "%s\n", __func__);
return 0;
}
static ssize_t idle_proc_kernel_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int enabled = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &enabled) != 0) {
ret = -EINVAL;
goto free;
}
/* Start/Stop kernel profile */
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_target_state_show(struct seq_file *m, void *v)
{
seq_printf(m, "%s\n", __func__);
return 0;
}
static ssize_t idle_proc_target_state_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
int state = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtoint(buf, 10, &state) != 0) {
ret = -EINVAL;
goto free;
}
/* Set target state */
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_ratio_show(struct seq_file *m, void *v)
{
mtk_cpuidle_prof_ratio_dump(m);
return 0;
}
static ssize_t idle_proc_ratio_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int enabled = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &enabled) != 0) {
ret = -EINVAL;
goto free;
}
if (enabled)
mtk_cpuidle_prof_ratio_start();
else
mtk_cpuidle_prof_ratio_stop();
free:
mtk_idle_procfs_free(buf);
return ret;
}
static int idle_proc_cpc_show(struct seq_file *m, void *v)
{
mtk_cpc_prof_lat_dump(m);
return 0;
}
static ssize_t idle_proc_cpc_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
ssize_t ret = count;
unsigned int enabled = 0;
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
if (kstrtouint(buf, 10, &enabled) != 0) {
ret = -EINVAL;
goto free;
}
if (enabled)
mtk_cpc_prof_start();
else
mtk_cpc_prof_stop();
free:
mtk_idle_procfs_free(buf);
return ret;
}
PROC_FOPS(kernel);
PROC_FOPS(target_state);
PROC_FOPS(ratio);
PROC_FOPS(cpc);
void __init mtk_idle_procfs_profile_dir_init(struct proc_dir_entry *parent)
{
int i;
struct proc_dir_entry *dir = NULL;
const struct idle_proc_entry entries[] = {
PROC_ENTRY(kernel),
PROC_ENTRY(target_state),
PROC_ENTRY(ratio),
PROC_ENTRY(cpc)
};
dir = proc_mkdir("profile", parent);
if (!dir) {
pr_notice("fail to create procfs @ %s()\n", __func__);
return;
}
for (i = 0; i < ARRAY_SIZE(entries); i++)
PROC_CREATE_NODE(dir, entries[i]);
}
@@ -0,0 +1,218 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/cpuidle.h>
#include <linux/seq_file.h>
#include "mtk_cpuidle_status.h"
#include "mtk_idle_procfs.h"
#define ALL_LITTLR_CPU_ID (10)
#define ALL_BIG_CPU_ID (20)
#define ALL_CPU_ID (100)
#define CPU_L_MASK (0x0f)
#define CPU_B_MASK (0xf0)
#define ALL_CPU_MASK (0xff)
static void idle_proc_state_uasge_print(struct seq_file *m, char *node_name)
{
seq_puts(m, "\n======== Command Usage ========\n");
seq_printf(m, "%s > /proc/cpuidle/state/%s\n",
"echo [cpu_id] [state_index] [val(dec)]",
node_name);
seq_puts(m, "\t cpu_id: 0~7 -> cpu number\n");
seq_printf(m, "\t %3d -> all little CPU\n", ALL_LITTLR_CPU_ID);
seq_printf(m, "\t %3d -> all big CPU\n", ALL_BIG_CPU_ID);
seq_printf(m, "\t %3d -> all CPU\n", ALL_CPU_ID);
seq_puts(m, "\t state_index: >0 (index 0 can't be modified)\n");
seq_puts(m, "\n");
}
static void idle_proc_state_param_show(struct seq_file *m, int param)
{
struct cpuidle_driver *drv;
int i, cpu, desc = 0;
for_each_possible_cpu(cpu) {
drv = cpuidle_get_cpu_driver(per_cpu(cpuidle_devices, cpu));
if (!drv)
continue;
if (desc == 0) {
seq_printf(m, "%-12s:", "state_index");
for (i = 0; i < drv->state_count; i++)
seq_printf(m, "%7d ", i);
seq_puts(m, "\n");
desc = 1;
}
seq_printf(m, "%11s%d:", "cpu", cpu);
for (i = 0; i < drv->state_count; i++)
seq_printf(m, "%7d ",
mtk_cpuidle_get_param(drv, i, param));
seq_puts(m, "\n");
}
}
static int idle_proc_state_param_setting(char *cmd, int param)
{
struct cpuidle_driver *drv;
char *args;
unsigned int cpu_mask, state_idx = 0, val = 0;
int cpu = 0, i;
struct cmd_param {
unsigned int id;
unsigned int mask;
};
const struct cmd_param table[] = {
{ALL_LITTLR_CPU_ID, CPU_L_MASK},
{ALL_BIG_CPU_ID, CPU_B_MASK},
{ALL_CPU_ID, ALL_CPU_MASK},
};
args = strsep(&cmd, " ");
if (!args || kstrtoint(args, 10, &cpu) != 0)
return -EINVAL;
args = strsep(&cmd, " ");
if (!args || kstrtouint(args, 10, &state_idx) != 0)
return -EINVAL;
args = strsep(&cmd, " ");
if (!args || kstrtouint(args, 10, &val) != 0)
return -EINVAL;
if (!state_idx)
return -EINVAL;
cpu_mask = 0;
if (cpu >= 0 && cpu < nr_cpu_ids) {
cpu_mask = (1 << cpu);
} else {
for (i = 0; i < ARRAY_SIZE(table); i++) {
if (cpu == table[i].id) {
cpu_mask = table[i].mask;
break;
}
}
}
for_each_possible_cpu(cpu) {
if ((cpu_mask & (1 << cpu)) == 0)
continue;
drv = cpuidle_get_cpu_driver(per_cpu(cpuidle_devices, cpu));
if (!drv)
continue;
mtk_cpuidle_set_param(drv, state_idx, param, val);
}
return 0;
}
static int idle_proc_latency_show(struct seq_file *m, void *v)
{
seq_puts(m, "==== CPU idle state: Exit latency ====\n");
idle_proc_state_param_show(m, IDLE_PARAM_LAT);
idle_proc_state_uasge_print(m, "latency");
return 0;
}
static ssize_t idle_proc_latency_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
idle_proc_state_param_setting(buf, IDLE_PARAM_LAT);
mtk_idle_procfs_free(buf);
return count;
}
static int idle_proc_residency_show(struct seq_file *m, void *v)
{
seq_puts(m, "==== CPU idle state: Target residency ====\n");
idle_proc_state_param_show(m, IDLE_PARAM_RES);
idle_proc_state_uasge_print(m, "residency");
return 0;
}
static ssize_t idle_proc_residency_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
idle_proc_state_param_setting(buf, IDLE_PARAM_RES);
mtk_idle_procfs_free(buf);
return count;
}
static int idle_proc_enabled_show(struct seq_file *m, void *v)
{
seq_puts(m, "==== CPU idle state: Enabled ====\n");
idle_proc_state_param_show(m, IDLE_PARAM_EN);
idle_proc_state_uasge_print(m, "enabled");
return 0;
}
static ssize_t idle_proc_enabled_write(struct file *filp,
const char __user *userbuf, size_t count, loff_t *f_pos)
{
char *buf;
mtk_idle_procfs_alloc_from_user(buf, userbuf, count);
if (!buf)
return -EINVAL;
idle_proc_state_param_setting(buf, IDLE_PARAM_EN);
mtk_idle_procfs_free(buf);
return count;
}
PROC_FOPS(latency);
PROC_FOPS(residency);
PROC_FOPS(enabled);
void __init mtk_idle_procfs_state_dir_init(struct proc_dir_entry *parent)
{
int i;
struct proc_dir_entry *dir = NULL;
const struct idle_proc_entry entries[] = {
PROC_ENTRY(latency),
PROC_ENTRY(residency),
PROC_ENTRY(enabled)
};
dir = proc_mkdir("state", parent);
if (!dir) {
pr_notice("fail to create procfs @ %s()\n", __func__);
return;
}
for (i = 0; i < ARRAY_SIZE(entries); i++)
PROC_CREATE_NODE(dir, entries[i]);
}