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,84 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2017 MediaTek Inc.
*/
#ifndef __MTK_MCDI_H__
#define __MTK_MCDI_H__
#include <linux/arm-smccc.h>
#ifdef CONFIG_ARM64
#define MTK_SIP_SMC_AARCH_BIT 0x40000000
#else
#define MTK_SIP_SMC_AARCH_BIT 0x00000000
#endif
/* MCDI related SMC call */
#define MTK_SIP_KERNEL_MCDI_ARGS \
(0x82000231 | MTK_SIP_SMC_AARCH_BIT)
enum {
MCDI_SMC_EVENT_ASYNC_WAKEUP_EN = 0,
MCDI_SMC_EVENT_DUMP_TRACE_DATA,
MCDI_SMC_EVENT_LAST_CORE_REQ,
MCDI_SMC_EVENT_LAST_CORE_CLR,
MCDI_SMC_EVENT_GIC_DPG_SET,
MCDI_SMC_EVENT_CPC_CONFIG,
MCDI_SMC_EVENT_MCUPM_FW_STA,
NF_MCDI_SMC_EVENT
};
extern void aee_rr_rec_mcdi_val(int id, unsigned int val);
extern unsigned long long notrace sched_clock(void);
/* mtk_menu */
unsigned int get_menu_predict_us(void);
unsigned int get_menu_next_timer_us(void);
/* main */
int wfi_enter(int cpu);
int mcdi_enter(int cpu);
bool _mcdi_task_pause(bool paused);
void mcdi_avail_cpu_mask(unsigned int cpu_mask);
void _mcdi_cpu_iso_mask(unsigned int iso_mask);
void mcdi_wakeup_all_cpu(void);
bool __mcdi_pause(unsigned int id, bool paused);
#ifndef CONFIG_MACH_MT6739
static inline size_t mt_secure_call(size_t function_id, size_t arg0,
size_t arg1, size_t arg2, size_t arg3)
{
struct arm_smccc_res res;
arm_smccc_smc(function_id, arg0, arg1, arg2, arg3, 0, 0, 0,
&res);
return res.a0;
}
#else
#ifndef mt_secure_call
#define mt_secure_call(x1, x2, x3, x4, x5) ({\
struct arm_smccc_res res;\
mtk_idle_smc_impl(x1, x2, x3, x4, x5, res);\
res.a0; })
#endif
#endif
#define mtk_idle_smc_impl(p1, p2, p3, p4, p5, res) \
arm_smccc_smc(p1, p2, p3, p4,\
p5, 0, 0, 0, &res)
#ifndef SMC_CALL
/* SMC call's marco */
#define SMC_CALL(_name, _arg0, _arg1, _arg2) ({\
struct arm_smccc_res res;\
mtk_idle_smc_impl(MTK_SIP_KERNEL_SPM_##_name,\
_arg0, _arg1, _arg2, 0, res);\
res.a0; })
#endif
#endif /* __MTK_MCDI_H__ */
@@ -0,0 +1,92 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2017 MediaTek Inc.
*/
#ifndef __MTK_MCDI_CPC_H__
#define __MTK_MCDI_CPC_H__
#include <linux/proc_fs.h>
#include <mtk_mcdi_plat.h>
#define CPC_LAT_NAME_SIZE 36
/**
* number of profile type :
* - (number of cpu type) * (cpu/cluster state) + mcusys
*/
#define PROF_TYPE_NUM (NF_CPU_TYPE * 2 + 1)
#define DEFAULT_AUTO_OFF_THRES_US (8 * 1000U)
#define MAX_AUTO_OFF_THRES_US (1290 * 1000U)
enum cpc_cfg {
MCDI_CPC_CFG_PROF,
MCDI_CPC_CFG_AUTO_OFF,
MCDI_CPC_CFG_AUTO_OFF_THRES,
MCDI_CPC_CFG_CNT_CLR,
NF_MCDI_CPC_CFG
};
enum prof_distribute {
MCDI_PROF_U10_US,
MCDI_PROF_U20_US,
MCDI_PROF_U50_US,
MCDI_PROF_O50_US,
NF_MCDI_PROF_DIST
};
struct mcdi_cpc_prof {
char name[CPC_LAT_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 mcdi_cpc_distribute {
unsigned int on[NF_MCDI_PROF_DIST];
unsigned int off[NF_MCDI_PROF_DIST];
unsigned int cnt;
};
struct mcdi_cpc_status {
bool prof_en;
bool prof_pause;
bool prof_saving;
bool dbg_en;
bool auto_off;
};
struct mcdi_cpc_dev {
struct mcdi_cpc_status sta;
union {
struct mcdi_cpc_prof p[PROF_TYPE_NUM];
struct {
struct mcdi_cpc_prof cpu[NF_CPU_TYPE];
struct mcdi_cpc_prof cluster[NF_CPU_TYPE];
struct mcdi_cpc_prof mcusys;
};
};
struct mcdi_cpc_distribute dist_cnt[NF_CPU_TYPE];
unsigned int mp_off_cnt[NF_CLUSTER];
unsigned int mp_off_lat[NF_CPU];
unsigned int auto_off_thres_us;
};
#define cpc_tick_to_us(val) ((val) / 13)
#define cpc_us_to_tick(val) ((val) * 13)
void mcdi_cpc_init(void);
void mcdi_cpc_reflect(int cpu, int last_core);
void mcdi_cpc_prof_en(bool enable);
void mcdi_procfs_cpc_init(struct proc_dir_entry *mcdi_dir);
#ifdef CONFIG_MACH_MT6739
void mcdi_cpc_auto_off_counter_suspend(void);
void mcdi_cpc_auto_off_counter_resume(void);
#endif
#endif /* __MTK_MCDI_CPC_H__ */
@@ -0,0 +1,30 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_MCDI_MCUPM_H__
#define __MTK_MCDI_MCUPM_H__
enum {
MCUPM_SMC_CALL = 0x00F,
MCUPM_FW_PARSE = 0x0F0,
MCUPM_FW_KICK = 0x0FF,
};
void mcdi_cluster_counter_set_cpu_residency(int cpu);
void mcdi_mcupm_init(void);
int get_mcupmfw_load_info(void);
void set_mcupmfw_load_info(int value);
bool mcdi_mcupm_sram_is_ready(void);
void mcdi_set_pllbuck_req(int param);
unsigned int mcdi_get_pllbuck_req(void);
extern bool mcupm_sram_is_ready;
/* only use in mcusys off flow */
#define MCUPM_PROT_NO_RESPONSE 0
#define MCUPM_PROT_SUCCESS 0xbabe
#define MCUPM_PROT_FAIL 0xdead
#endif /* __MTK_MCDI_MCUPM_H__ */
@@ -0,0 +1,131 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2017 MediaTek Inc.
*/
#ifndef __MTK_MCDI_PROFILE_H__
#define __MTK_MCDI_PROFILE_H__
#include <linux/proc_fs.h>
#include <linux/cpuidle.h>
#include <mtk_mcdi_plat.h>
/* #define MCDI_PWR_SEQ_PROF_BREAKDOWN */
#define MCDI_LAT_NAME_SIZE 36
enum {
MCDI_PROF_FLAG_STOP,
MCDI_PROF_FLAG_START,
MCDI_PROF_FLAG_POLLING,
NF_MCDI_PROF_FLAG
};
enum {
MCDI_PROFILE_ENTER = 0,
MCDI_PROFILE_CPU_DORMANT_ENTER,
MCDI_PROFILE_CPU_DORMANT_LEAVE,
MCDI_PROFILE_LEAVE,
MCDI_PROFILE_RSV0,
MCDI_PROFILE_RSV1,
NF_MCDI_PROFILE,
};
struct mcdi_prof_lat_raw {
unsigned int cnt;
unsigned int max;
union {
unsigned long long avg;
unsigned long long sum;
};
};
struct mcdi_prof_lat_data {
const char *name;
bool valid;
int start;
int end;
unsigned long long *start_ts;
unsigned long long *end_ts;
struct mcdi_prof_lat_raw curr[NF_CPU_TYPE];
struct mcdi_prof_lat_raw result[NF_CPU_TYPE];
unsigned long long ts[NF_CPU];
};
struct mcdi_prof_lat {
bool enable;
bool pause;
struct mcdi_prof_lat_data section[NF_MCDI_PROFILE];
};
struct mcdi_prof_dev {
int cpu;
int last_residency;
int last_state_idx;
int actual_state;
unsigned long long enter;
unsigned long long leave;
struct {
unsigned int cnt;
unsigned long long dur;
} state[CPUIDLE_STATE_MAX];
};
struct mcdi_prof_usage {
bool enable;
bool pause;
unsigned int cpu_valid;
unsigned long long start;
unsigned long long prof_dur;
int last_id[NF_CLUSTER];
struct mcdi_prof_dev dev[NF_CPU];
};
/* this define should sync with mcdi in sspm */
#ifdef MCDI_PWR_SEQ_PROF_BREAKDOWN
enum prof_bk_onoff {
MCDI_PROF_BK_ON = 0,
MCDI_PROF_BK_OFF,
MCDI_PROF_BK_ONOFF_NUM,
};
enum prof_bk_ts {
CLUSTER,
CPU,
ARMPLL,
BUCK,
MCDI_PROF_BK_NUM,
};
struct mcdi_prof_breakdown_item {
unsigned int item[MCDI_PROF_BK_NUM][NF_CLUSTER];
unsigned int count[MCDI_PROF_BK_NUM][NF_CLUSTER];
};
struct mcdi_prof_breakdown {
struct mcdi_prof_breakdown_item onoff[MCDI_PROF_BK_ONOFF_NUM];
};
#endif
unsigned int mcdi_usage_get_cnt(int cpu, int state_idx);
void mcdi_usage_time_start(int cpu);
void mcdi_usage_time_stop(int cpu);
void mcdi_usage_calc(int cpu);
bool mcdi_usage_cpu_valid(int cpu);
void mcdi_profile_ts(int cpu_idx, unsigned int prof_idx);
#ifdef CONFIG_MACH_MT6739
void mcdi_profile_ts_clr(int cpu_idx, unsigned int prof_idx);
#endif
void mcdi_profile_calc(int cpu);
void mcdi_prof_core_cluster_off_token(int cpu);
void mcdi_prof_set_idle_state(int cpu, int state);
void mcdi_prof_init(void);
void mcdi_procfs_profile_init(struct proc_dir_entry *mcdi_dir);
#endif /* __MTK_MCDI_PROFILE_H__ */
@@ -0,0 +1,71 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2017 MediaTek Inc.
*/
#ifndef __MTK_MCDI_UTIL_H__
#define __MTK_MCDI_UTIL_H__
#include <mt-plat/sync_write.h>
#define mcdi_read(addr) __raw_readl((void __force __iomem *)(addr))
#define mcdi_write(addr, val) mt_reg_sync_writel(val, addr)
#define NF_CMD_BUF 128
#define LOG_BUF_LEN 1024
#define log2buf(p, s, fmt, args...) \
(p += scnprintf(p, sizeof(s) - strlen(s), fmt, ##args))
#undef mcdi_log
#define mcdi_log(fmt, args...) log2buf(p, dbg_buf, fmt, ##args)
struct mtk_mcdi_buf {
char buf[LOG_BUF_LEN];
char *p_idx;
};
#define reset_mcdi_buf(mcdi) ((mcdi).p_idx = (mcdi).buf)
#define get_mcdi_buf(mcdi) ((mcdi).buf)
#define mcdi_buf_append(mcdi, fmt, args...) \
((mcdi).p_idx += snprintf((mcdi).p_idx, \
LOG_BUF_LEN - strlen((mcdi).buf), \
fmt, ##args))
#define PROC_FOPS_MCDI(name) \
static int _mcdi_ ## name ## _open(struct seq_file *s, void *data) \
{ \
return 0; \
} \
static int mcdi_ ## name ## _open(struct inode *inode, struct file *file)\
{ \
return single_open(file, _mcdi_ ## name ## _open, inode->i_private);\
} \
static const struct file_operations mcdi_ ## name ## _fops = { \
.owner = THIS_MODULE, \
.open = mcdi_ ## name ## _open, \
.read = mcdi_ ## name ## _read, \
.write = mcdi_ ## name ## _write, \
.llseek = seq_lseek, \
.release = single_release, \
}
#define PROC_CREATE_MCDI(parent, name) \
do { \
if (!proc_create(#name, 0644, parent, &mcdi_ ## name ## _fops)) \
pr_notice("%s(), create /proc/mcdi/%s failed\n", \
__func__, #name); \
} while (0)
unsigned int mcdi_mbox_read(int id);
void mcdi_mbox_write(int id, unsigned int val);
int mcdi_fw_is_ready(void);
bool mcdi_is_cpc_mode(void);
unsigned int mcdi_get_cluster_off_cnt(unsigned int cluster);
void mcdi_notify_cluster_off(unsigned int cluster);
unsigned int mcdi_get_raw_pwr_sta(void);
void mcdi_set_cpu_iso_smc(unsigned int iso_mask);
void mcdi_set_cpu_iso_mbox(unsigned int iso_mask);
unsigned long long idle_get_current_time_us(void);
#endif /* __MTK_MCDI_UTIL_H__ */
@@ -0,0 +1,45 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2017 MediaTek Inc.
*/
#ifndef __MTK_MCDI_COMMON_H__
#define __MTK_MCDI_COMMON_H__
enum {
SYSTEM_IDLE_HINT_USER_MCDI_TEST = 0,
SYSTEM_IDLE_HINT_USER_BLUE_TOOTH,
SYSTEM_IDLE_HINT_USER_AUDIO,
NF_SYSTEM_IDLE_HINT
};
enum {
MCDI_PAUSE_BY_HOTPLUG = 1,
MCDI_PAUSE_BY_EEM,
NF_MCDI_PAUSE
};
void __attribute__((weak))
mcdi_cpu_iso_mask(unsigned int iso_mask)
{
}
bool __attribute__((weak))
mcdi_task_pause(bool paused)
{
return true;
}
bool __attribute__((weak))
system_idle_hint_request(unsigned int id, bool value)
{
return false;
}
void __attribute__((weak))
mcdi_pause(unsigned int id, bool paused)
{
}
#endif /* __MTK_MCDI_COMMON_H__ */
@@ -0,0 +1,73 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2017 MediaTek Inc.
*/
#ifndef __MTK_MCDI_GOVERNOR_H__
#define __MTK_MCDI_GOVERNOR_H__
#include <linux/hrtimer.h>
enum {
PAUSE_CNT = 0,
MULTI_CORE_CNT,
LATENCY_CNT,
RESIDENCY_CNT,
LAST_CORE_CNT,
NF_ANY_CORE_CPU_COND_INFO
};
struct mcdi_feature_status {
bool enable;
bool pause;
bool cluster_off;
bool any_core;
int s_state;
unsigned int pauseby;
};
struct mcdi_cluster_dev {
int owner;
bool chk_res_each_core;
bool use_max_remain;
unsigned int chk_res_cnt;
unsigned int chk_res_fail;
bool tmr_en;
bool tmr_running;
struct hrtimer timer;
};
int mcdi_governor_select(int cpu, int cluster_idx);
void mcdi_governor_reflect(int cpu, int state);
void mcdi_avail_cpu_cluster_update(void);
void mcdi_governor_init(void);
void set_mcdi_enable_status(bool enabled);
void set_mcdi_s_state(int state);
void set_mcdi_idle_state(int cpu, int state);
const struct mcdi_feature_status *get_mcdi_feature_stat(void);
struct mcdi_cluster_dev *get_mcdi_cluster_dev(void);
void get_mcdi_feature_status(struct mcdi_feature_status *stat);
void get_mcdi_avail_mask(unsigned int *cpu_mask, unsigned int *cluster_mask);
int get_residency_latency_result(int cpu);
int get_cluster_off_token(int cpu);
void mcdi_state_pause(unsigned int id, bool pause);
void any_core_cpu_cond_get(unsigned long buf[NF_ANY_CORE_CPU_COND_INFO]);
void any_core_cpu_cond_inc(int idx);
bool is_mcdi_working(void);
bool is_last_core_in_mcusys(int cpu);
bool is_last_core_in_cluster(int cpu);
unsigned int mcdi_get_gov_data_num_mcusys(void);
#ifdef CONFIG_MACH_MT6739
void mcdi_cluster_chk_res_each_core_set(bool en);
void mcdi_cluster_tmr_en_set(bool en);
unsigned int mcdi_get_mtk_idle_mode(void);
#endif
void idle_refcnt_inc(void);
void idle_refcnt_dec(void);
int all_cpu_idle_ratio_get(void);
bool is_all_cpu_idle_criteria(void);
unsigned int mcdi_get_boot_time_check(void);
#endif /* __MTK_MCDI_GOVERNOR_H__ */
@@ -0,0 +1,13 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2017 MediaTek Inc.
*/
#ifndef __MTK_MCDI_GOVERNOR_HINT_H__
#define __MTK_MCDI_GOVERNOR_HINT_H__
unsigned int system_idle_hint_result_raw(void);
bool system_idle_hint_result(void);
bool _system_idle_hint_request(unsigned int id, bool value);
#endif /* __MTK_MCDI_GOVERNOR_HINT_H__ */
@@ -0,0 +1,15 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2017 MediaTek Inc.
*/
#ifndef __MTK_MCDI_GOVERNOR_LIB_H__
#define __MTK_MCDI_GOVERNOR_LIB_H__
int acquire_last_core_prot(int cpu);
int acquire_cluster_last_core_prot(int cpu);
void release_last_core_prot(void);
void release_cluster_last_core_prot(void);
void mcdi_ap_ready(void);
#endif /* __MTK_MCDI_GOVERNOR_LIB_H__ */