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

+79
View File
@@ -0,0 +1,79 @@
config MTK_PERFMGR_TOUCH_BOOST
tristate "touch boost in performance manager"
help
MTK_PERFMGR_TOUCH_BOOST is the kernel config of touch boost
feature designed by MTK, which is a performance improving
feature for user experience. When the device receives touch
event, it will raise system resources(CPU frequency / CPU cores)
for better user experience.
config MTK_LOAD_TRACKER
tristate "CPU Loading Tracking Service"
depends on CPU_FREQ
help
MTK_LOAD_TRACKER is the kernel config of CPU Loading Tracking
Service designed by MTK, which is a service to get CPU Loading
information. User can register callback and config polling
duration to get CPU loading.
config MTK_CPU_CTRL_CFP
tristate "CPU CTRL Ceiling-Fool-Proof"
depends on MTK_LOAD_TRACKER
help
MTK_CPU_CTRL_CFP is the kernel config of CPU controller
Ceiling-Fool-Proof Mechanism designed by MTK. CPU controller
will free CPU frequency ceiling during heavy CPU loading.
This function depends on MTK_LOAD_TRACKER.
config MTK_PERF_OBSERVER
bool "MTK system performance observer support"
help
MTK_PERF_OBSERVER define if system performance observer should
be built-in or not. It supports system related performance index
via notifier. If you are not sure about whether to enable it or not,
please set n.
config MTK_RESYM
bool "MTK resource symphony support"
help
MTK_RESYM define if resource symphony should
be built-in or not. It supports system related usages.
If you are not sure about whether to enable it or not,
please set n.
config MTK_FPSGO_V3
bool "Support FPSGO_V3 framework"
help
Support FPSGO_V3 framework for most FPS performance and
low power balance. As a perquisite to ensure FPS performance,
FPSGO_V3 persuades lowest power consumption for better DoU
endurance and gaming experience.
FPSGO_V3 include AI performance and low power.
If you are not sure about this, set n.
config MTK_EARA_THERMAL
bool "MTK eara_thermal support"
depends on MTK_FPSGO_V3 && MTK_PPM && THERMAL
help
MTK_EARA_THERMAL is the kernel config of EARA_THERMAL mechanism.
EARA_THERMAL persuades FPS performance when thermal throttling.
This function depends on MTK_FPSGO_V3.
If you are not sure about this, please set n.
config MTK_GBE
bool "MTK GBE support"
depends on MTK_FPSGO_V3
help
MTK_GBE is the kernel config of GBE mechanism.
GBE stands for Game Boost Engine. GBE is a mechanism to
boost Game Engine while gaming for better gaming experience
This function depends on MTK_FPSGO_V3.
If you are not sure about this, please set n.
config MTK_FRS
tristate "Mediatek Frame Rate Smoother"
help
Support Frame Rate Smoother kernel intergface. It will adjustment
target fps by thermal.
If you are not sure about this, set n.
@@ -0,0 +1,72 @@
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/performance/perf_ioctl/ \
-I$(srctree)/drivers/misc/mediatek/performance/include/ \
-I$(srctree)/drivers/misc/mediatek/base/power/include/ \
-I$(srctree)/drivers/misc/mediatek/include/
ifeq ($(CONFIG_MACH_MT6739),y)
subdir-ccflags-y += -DMTK_MT6739_MTK_CPU_FREQ
endif
obj-y += perfmgr_main.o
obj-y += base/
obj-$(CONFIG_MTK_PERF_OBSERVER) += observer/
obj-$(CONFIG_MTK_RESYM) += resym/
obj-$(CONFIG_MTK_GBE) += gbe/
obj-y += syslimiter/
#ifeq (,$(findstring mt8,$(CONFIG_MTK_PLATFORM)))
obj-y += boost_ctrl/
obj-y += tchbst/
#endif
obj-y += perf_ioctl/
ifeq ($(CONFIG_MACH_MT6893),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6885),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6877),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6781),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6739),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6833),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6768),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6873),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6853),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6771),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else ifeq ($(CONFIG_MACH_MT6785),y)
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3_topology/
else
obj-$(CONFIG_MTK_FPSGO_V3) += fpsgo_v3/
endif
obj-$(CONFIG_MTK_FRS) += frs/
ifneq (,$(filter $(CONFIG_MTK_LEGACY_THERMAL_PLATFORM), "mt6779"))
obj-$(CONFIG_MTK_EARA_THERMAL) += eara_thermal/
endif
obj-$(CONFIG_MTK_LOAD_TRACKER) += load_track/
obj-$(CONFIG_MTK_LOAD_TRACKER) += uload_ind/
@@ -0,0 +1,15 @@
# Copyright (C) 2018 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y += utility.o
@@ -0,0 +1,150 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/uaccess.h>
#include "mtk_perfmgr_internal.h"
#ifdef CONFIG_TRACING
#include <linux/kallsyms.h>
#include <linux/trace_events.h>
#endif
char *perfmgr_copy_from_user_for_proc(const char __user *buffer,
size_t count)
{
char *buf = (char *)__get_free_page(GFP_USER);
if (!buf)
return NULL;
if (count >= PAGE_SIZE)
goto out;
if (copy_from_user(buf, buffer, count))
goto out;
buf[count] = '\0';
return buf;
out:
free_page((unsigned long)buf);
return NULL;
}
int check_proc_write(int *data, const char *ubuf, size_t cnt)
{
char buf[128];
if (cnt >= sizeof(buf))
return -EINVAL;
if (copy_from_user(buf, ubuf, cnt))
return -EFAULT;
buf[cnt] = 0;
if (kstrtoint(buf, 10, data))
return -1;
return 0;
}
int check_group_proc_write(int *cgroup, int *data,
const char *ubuf, size_t cnt)
{
char buf[128];
if (cnt >= sizeof(buf))
return -EINVAL;
if (copy_from_user(buf, ubuf, cnt))
return -EFAULT;
buf[cnt] = 0;
if (sscanf(buf, "%d %d", cgroup, data) != 2)
return -1;
return 0;
}
#ifdef CONFIG_TRACING
static unsigned long __read_mostly tracing_mark_write_addr;
static inline void __mt_update_tracing_mark_write_addr(void)
{
if (unlikely(tracing_mark_write_addr == 0))
tracing_mark_write_addr =
kallsyms_lookup_name("tracing_mark_write");
}
void perfmgr_trace_count(int val, const char *fmt, ...)
{
char log[128];
va_list args;
int len;
if (powerhal_tid <= 0)
return;
memset(log, ' ', sizeof(log));
va_start(args, fmt);
len = vsnprintf(log, sizeof(log), fmt, args);
va_end(args);
if (unlikely(len < 0))
return;
else if (unlikely(len == 128))
log[127] = '\0';
__mt_update_tracing_mark_write_addr();
preempt_disable();
event_trace_printk(tracing_mark_write_addr, "C|%d|%s|%d\n",
powerhal_tid, log, val);
preempt_enable();
}
void perfmgr_trace_printk(char *module, char *string)
{
__mt_update_tracing_mark_write_addr();
preempt_disable();
event_trace_printk(tracing_mark_write_addr, "%d [%s] %s\n",
current->tgid, module, string);
preempt_enable();
}
void perfmgr_trace_begin(char *name, int id, int a, int b)
{
__mt_update_tracing_mark_write_addr();
preempt_disable();
event_trace_printk(tracing_mark_write_addr, "B|%d|%s|%d|%d|%d\n",
current->tgid, name, id, a, b);
preempt_enable();
}
void perfmgr_trace_end(void)
{
__mt_update_tracing_mark_write_addr();
preempt_disable();
event_trace_printk(tracing_mark_write_addr, "E\n");
preempt_enable();
}
void perfmgr_trace_log(char *module, const char *fmt, ...)
{
char log[256];
va_list args;
int len;
va_start(args, fmt);
len = vsnprintf(log, sizeof(log), fmt, args);
if (unlikely(len == 256))
log[255] = '\0';
va_end(args);
perfmgr_trace_printk(module, log);
}
#endif
@@ -0,0 +1,23 @@
#
# Copyright (C) 2018 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y += boostctrl_main.o
obj-y += dram_ctrl/
obj-y += cpu_ctrl/
obj-y += eas_ctrl/
obj-y += topo_ctrl/
@@ -0,0 +1,33 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/proc_fs.h>
#include "boost_ctrl.h"
int init_boostctrl(struct proc_dir_entry *parent)
{
struct proc_dir_entry *bstctrl_root = NULL;
struct proc_dir_entry *easctrl_root = NULL;
pr_debug("__init %s\n", __func__);
bstctrl_root = proc_mkdir("boost_ctrl", parent);
/* init topology info first */
topo_ctrl_init(bstctrl_root);
cpu_ctrl_init(bstctrl_root);
dram_ctrl_init(bstctrl_root);
/* EAS */
easctrl_root = proc_mkdir("eas_ctrl", bstctrl_root);
uclamp_ctrl_init(easctrl_root);
eas_ctrl_init(easctrl_root);
return 0;
}
@@ -0,0 +1,69 @@
#
# Copyright (C) 2018 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
ifeq ($(CONFIG_MTK_PPM),y)
obj-y += cpu_ctrl.o
else
# no CONFIG_MTK_PPM but specific lagacy platform
ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6761" "mt6765" "mt6768" "mt6873" "mt6885" "mt6893" "mt6771" "mt6785" "mt6853" "mt6739"))
ifeq ($(CONFIG_MTK_GKI_COMPAT),y)
obj-y += cpu_ctrl_dummy.o
else
obj-y += cpu_ctrl.o
endif # CONFIG_MTK_GKI_COMPAT
else
obj-y += cpu_ctrl_dummy.o
endif
endif # CONFIG_MTK_PPM
ifeq ($(CONFIG_MACH_MT6893),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6885),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6877),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6873),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6853),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6781),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6739),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6833),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6768),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6771),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
else ifeq ($(CONFIG_MACH_MT6785),y)
ccflags-y += \
-DMTK_K14_CPU_BOOST
endif
obj-$(CONFIG_MTK_CPU_CTRL_CFP) += cpu_ctrl_cfp.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/include/
ccflags-y += -I$(srctree)drivers/misc/mediatek/performance/include/
@@ -0,0 +1,798 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#define pr_fmt(fmt) "[cpu_ctrl]"fmt
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/cpufreq.h>
#ifdef CONFIG_MTK_CORE_CTL
#include <mt-plat/core_ctl.h>
#endif
#include <mt-plat/cpu_ctrl.h>
#include <mt-plat/mtk_ppm_api.h>
#include "boost_ctrl.h"
#include "mtk_perfmgr_internal.h"
#include "topo_ctrl.h"
#ifdef CONFIG_MTK_CPU_CTRL_CFP
#include "cpu_ctrl_cfp.h"
#endif
#ifdef CONFIG_TRACING
#include <linux/kallsyms.h>
#include <linux/trace_events.h>
#endif
#include <linux/io.h>
#define MAX_CLUSTER_COUNT 3
static struct mutex boost_freq;
static struct mutex isolate_lock;
static struct ppm_limit_data *current_freq;
static struct ppm_limit_data *freq_set[CPU_MAX_KIR];
static int log_enable;
static unsigned long *policy_mask;
#ifdef CONFIG_MTK_CPU_CTRL_CFP
static int cfp_init_ret;
#endif
int powerhal_tid;
#include "eas_ctrl_plat.h"
#define MAX_CLUSTER_COUNT 3
static int num_cpu;
static struct mutex isolate_lock;
static int perfserv_isolation_cpu;
struct cluster_data {
int core_min;
int core_max;
};
static int *cpu_isolation[CPU_ISO_MAX_KIR];
static struct cluster_data core_set[CPU_ISO_MAX_KIR][MAX_CLUSTER_COUNT];
static struct cluster_data default_core_set[MAX_CLUSTER_COUNT];
static int isolation_used[CPU_ISO_MAX_KIR];
static int all_cpu_deisolated;
static int isBooting;
/*******************************************/
int update_userlimit_cpu_freq(int kicker, int num_cluster
, struct cpu_ctrl_data *freq_limit)
{
struct ppm_limit_data *final_freq;
int retval = 0;
int i, j, len = 0, len1 = 0;
char msg[LOG_BUF_SIZE];
char msg1[LOG_BUF_SIZE];
mutex_lock(&boost_freq);
final_freq = kcalloc(perfmgr_clusters
, sizeof(struct ppm_limit_data), GFP_KERNEL);
if (!final_freq) {
retval = -1;
perfmgr_trace_printk("cpu_ctrl", "!final_freq\n");
goto ret_update;
}
if (num_cluster != perfmgr_clusters) {
pr_debug(
"num_cluster : %d perfmgr_clusters: %d, doesn't match\n",
num_cluster, perfmgr_clusters);
retval = -1;
perfmgr_trace_printk("cpu_ctrl",
"num_cluster != perfmgr_clusters\n");
goto ret_update;
}
if (kicker < 0 || kicker >= CPU_MAX_KIR) {
pr_debug("kicker:%d, error\n", kicker);
retval = -1;
goto ret_update;
}
for_each_perfmgr_clusters(i) {
final_freq[i].min = -1;
final_freq[i].max = -1;
}
len += snprintf(msg + len, sizeof(msg) - len, "[%d] ", kicker);
if (len < 0) {
perfmgr_trace_printk("cpu_ctrl", "return -EIO 1\n");
mutex_unlock(&boost_freq);
return -EIO;
}
for_each_perfmgr_clusters(i) {
freq_set[kicker][i].min = freq_limit[i].min >= -1 ?
freq_limit[i].min : -1;
freq_set[kicker][i].max = freq_limit[i].max >= -1 ?
freq_limit[i].max : -1;
len += snprintf(msg + len, sizeof(msg) - len, "(%d)(%d) ",
freq_set[kicker][i].min, freq_set[kicker][i].max);
if (len < 0) {
perfmgr_trace_printk("cpu_ctrl", "return -EIO 2\n");
mutex_unlock(&boost_freq);
return -EIO;
}
if (freq_set[kicker][i].min == -1 &&
freq_set[kicker][i].max == -1)
clear_bit(kicker, &policy_mask[i]);
else
set_bit(kicker, &policy_mask[i]);
len1 += snprintf(msg1 + len1, sizeof(msg1) - len1,
"[0x %lx] ", policy_mask[i]);
if (len1 < 0) {
perfmgr_trace_printk("cpu_ctrl", "return -EIO 3\n");
mutex_unlock(&boost_freq);
return -EIO;
}
}
for (i = 0; i < CPU_MAX_KIR; i++) {
for_each_perfmgr_clusters(j) {
final_freq[j].min
= MAX(freq_set[i][j].min, final_freq[j].min);
#ifdef CONFIG_MTK_CPU_CTRL_CFP
final_freq[j].max
= final_freq[j].max != -1 &&
freq_set[i][j].max != -1 ?
MIN(freq_set[i][j].max, final_freq[j].max) :
MAX(freq_set[i][j].max, final_freq[j].max);
#else
final_freq[j].max
= MAX(freq_set[i][j].max, final_freq[j].max);
#endif
if (final_freq[j].min > final_freq[j].max &&
final_freq[j].max != -1)
final_freq[j].max = final_freq[j].min;
}
}
for_each_perfmgr_clusters(i) {
current_freq[i].min = final_freq[i].min;
current_freq[i].max = final_freq[i].max;
len += snprintf(msg + len, sizeof(msg) - len, "{%d}{%d} ",
current_freq[i].min, current_freq[i].max);
if (len < 0) {
perfmgr_trace_printk("cpu_ctrl", "return -EIO 4\n");
mutex_unlock(&boost_freq);
return -EIO;
}
}
if (len >= 0 && len < LOG_BUF_SIZE) {
len1 = LOG_BUF_SIZE - len - 1;
if (len1 > 0)
strncat(msg, msg1, len1);
}
if (log_enable)
pr_debug("%s", msg);
#ifdef CONFIG_TRACING
perfmgr_trace_printk("cpu_ctrl", msg);
#endif
#ifdef CONFIG_MTK_CPU_CTRL_CFP
if (!cfp_init_ret)
cpu_ctrl_cfp(final_freq);
else
mt_ppm_userlimit_cpu_freq(perfmgr_clusters, final_freq);
#else
mt_ppm_userlimit_cpu_freq(perfmgr_clusters, final_freq);
#endif
ret_update:
kfree(final_freq);
mutex_unlock(&boost_freq);
return retval;
return 0;
}
EXPORT_SYMBOL(update_userlimit_cpu_freq);
#ifdef CONFIG_MTK_CORE_CTL
int update_cpu_core_limit(int kicker, int cid, int min, int max)
{
int i, final_min, final_max;
if (kicker < 0 || cid < 0) {
pr_debug("kicker: %d, cid: %d errro\n", kicker, cid);
return -1;
}
perfmgr_trace_count(kicker,
"update_cpu_core_limit_%d_%d_%d_%d", kicker, cid, min, max);
mutex_lock(&boost_freq);
core_set[kicker][cid].core_min = min;
core_set[kicker][cid].core_max = max;
final_min = -1;
final_max = default_core_set[cid].core_max;
for (i = 0; i <= CPU_ISO_KIR_FPSGO; i++) {
if (core_set[i][cid].core_max >= 0 &&
final_min <= core_set[i][cid].core_max &&
core_set[i][cid].core_max <= final_max)
final_max = core_set[i][cid].core_max;
if (final_min < core_set[i][cid].core_min) {
if (core_set[i][cid].core_min <= final_max)
final_min = core_set[i][cid].core_min;
else
final_min = (final_max < 0) ?
core_set[i][cid].core_min : final_max;
}
}
if (final_max < 0)
final_max = default_core_set[cid].core_max;
if (final_min < 0)
final_min = MIN(default_core_set[cid].core_min, final_max);
perfmgr_trace_count(kicker,
"core_ctl_set_limit_cpus_%d_%d_%d", cid, final_min, final_max);
core_ctl_set_limit_cpus(cid, final_min, final_max);
mutex_unlock(&boost_freq);
return 0;
}
EXPORT_SYMBOL(update_cpu_core_limit);
#endif
/***************************************/
static ssize_t perfmgr_perfserv_freq_proc_write(struct file *filp
, const char __user *ubuf, size_t cnt, loff_t *pos)
{
int i = 0, data;
struct cpu_ctrl_data *freq_limit;
unsigned int arg_num = perfmgr_clusters * 2; /* for min and max */
char *tok, *tmp;
char *buf = perfmgr_copy_from_user_for_proc(ubuf, cnt);
if (!buf) {
pr_debug("buf is null\n");
goto out1;
}
freq_limit = kcalloc(perfmgr_clusters, sizeof(struct cpu_ctrl_data),
GFP_KERNEL);
if (!freq_limit)
goto out;
tmp = buf;
pr_debug("freq write_to_file\n");
while ((tok = strsep(&tmp, " ")) != NULL) {
if (i == arg_num) {
pr_debug(
"@%s: number of arguments > %d!\n",
__func__, arg_num);
goto out;
}
if (kstrtoint(tok, 10, &data)) {
pr_debug("@%s: Invalid input: %s\n",
__func__, tok);
goto out;
} else {
if (i % 2) /* max */
freq_limit[i/2].max = data;
else /* min */
freq_limit[i/2].min = data;
i++;
}
}
if (i < arg_num) {
pr_debug(
"@%s: number of arguments < %d!\n",
__func__, arg_num);
} else {
powerhal_tid = current->pid;
update_userlimit_cpu_freq(CPU_KIR_PERF
, perfmgr_clusters, freq_limit);
}
out:
free_page((unsigned long)buf);
kfree(freq_limit);
out1:
return cnt;
}
static int perfmgr_perfserv_freq_proc_show(struct seq_file *m, void *v)
{
int i;
for_each_perfmgr_clusters(i)
seq_printf(m, "cluster %d min:%d max:%d\n",
i, freq_set[CPU_KIR_PERF][i].min,
freq_set[CPU_KIR_PERF][i].max);
return 0;
}
/***************************************/
#define MAX_NR_FREQ 16
static ssize_t perfmgr_boot_freq_proc_write(struct file *filp,
const char __user *ubuf, size_t cnt, loff_t *pos)
{
int i = 0, data, cid;
struct cpu_ctrl_data *freq_limit;
unsigned int arg_num = perfmgr_clusters * 2; /* for min and max */
char *tok, *tmp;
char *buf = perfmgr_copy_from_user_for_proc(ubuf, cnt);
freq_limit = kcalloc(perfmgr_clusters,
sizeof(struct cpu_ctrl_data), GFP_KERNEL);
if (!freq_limit)
goto out;
for_each_perfmgr_clusters(cid)
freq_limit[cid].min = freq_limit[cid].max = -1;
tmp = buf;
while ((tok = strsep(&tmp, " ")) != NULL) {
if (i == arg_num) {
pr_debug("@%s: number of arguments > %d!\n",
__func__, arg_num);
break;
}
if (kstrtoint(tok, 10, &data)) {
pr_debug("@%s: Invalid input: %s\n", __func__, tok);
goto out;
} else {
if (i % 2) { /* max */
freq_limit[i/2].max =
(data < 0 || data > MAX_NR_FREQ - 1)
? -1 :
mt_cpufreq_get_freq_by_idx(i / 2, data);
}
else { /* min */
freq_limit[i/2].min =
(data < 0 || data > MAX_NR_FREQ - 1)
? -1 :
mt_cpufreq_get_freq_by_idx(i / 2, data);
}
i++;
}
}
isBooting = 0;
for_each_perfmgr_clusters(cid)
if (freq_limit[cid].min != -1 || freq_limit[cid].max != -1) {
isBooting = 1;
#ifdef CONFIG_MTK_CORE_CTL
core_ctl_set_boost(1);
#endif
break;
}
#ifdef CONFIG_MTK_CORE_CTL
if (!isBooting)
core_ctl_set_boost(all_cpu_deisolated);
#endif
if (i < arg_num)
pr_debug("@%s: number of arguments < %d!\n",
__func__, arg_num);
else
update_userlimit_cpu_freq(CPU_KIR_BOOT,
perfmgr_clusters, freq_limit);
out:
free_page((unsigned long)buf);
kfree(freq_limit);
return cnt;
}
static int perfmgr_boot_freq_proc_show(struct seq_file *m, void *v)
{
int i;
for_each_perfmgr_clusters(i)
seq_printf(m, "cluster %d min:%d max:%d\n",
i, freq_set[CPU_KIR_BOOT][i].min,
freq_set[CPU_KIR_BOOT][i].max);
return 0;
}
/***************************************/
static int perfmgr_current_freq_proc_show(struct seq_file *m, void *v)
{
int i, j;
for_each_perfmgr_clusters(i)
seq_printf(m, "cluster %d min:%d max:%d\n",
i, current_freq[i].min, current_freq[i].max);
seq_puts(m, "===== kicker =====\n");
for (i = 0; i < CPU_MAX_KIR; i++)
for_each_perfmgr_clusters(j)
if (freq_set[i][j].min != -1 ||
freq_set[i][j].max != -1)
seq_printf(m,
"KIR[%d] cluster %d min:%d max:%d\n",
i, j, freq_set[i][j].min, freq_set[i][j].max);
return 0;
}
/*******************************************/
static ssize_t perfmgr_perfmgr_log_proc_write(struct file *filp,
const char __user *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
log_enable = data > 0 ? 1 : 0;
return cnt;
}
static int perfmgr_perfmgr_log_proc_show(struct seq_file *m, void *v)
{
if (m)
seq_printf(m, "%d\n", log_enable);
return 0;
}
void update_isolation_cpu(int kicker, int enable, int cpu)
{
int i, final = -1;
mutex_lock(&isolate_lock);
if (kicker < 0 || kicker >= CPU_ISO_MAX_KIR) {
pr_debug("kicker:%d, error\n", kicker);
mutex_unlock(&isolate_lock);
return;
}
if (cpu < 0 || cpu >= num_cpu) {
pr_debug("cpu:%d, error\n", cpu);
mutex_unlock(&isolate_lock);
return;
}
if (enable == cpu_isolation[kicker][cpu]) {
mutex_unlock(&isolate_lock);
return;
}
cpu_isolation[kicker][cpu] = enable;
for (i = 0; i < CPU_ISO_MAX_KIR; i++) {
if (cpu_isolation[i][cpu] == 0) {
final = 0;
break;
} else if (cpu_isolation[i][cpu] == 1)
final = 1;
}
#ifdef CONFIG_TRACING
perfmgr_trace_count(enable, "cpu_ctrl_isolation_%d_%d", kicker, cpu);
#endif
if (final > 0)
sched_isolate_cpu(cpu);
else
sched_unisolate_cpu(cpu);
mutex_unlock(&isolate_lock);
}
EXPORT_SYMBOL(update_isolation_cpu);
static ssize_t perfmgr_perfserv_iso_cpu_proc_write(struct file *filp,
const char __user *ubuf, size_t cnt, loff_t *pos)
{
int i, data = 0, cid;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
perfserv_isolation_cpu = data;
cid = 0;
#ifdef CONFIG_MTK_CORE_CTL
isolation_used[CPU_ISO_KIR_PERF_ISO] = (data > 0) ? 1 : 0;
for_each_perfmgr_clusters(i) {
core_set[CPU_ISO_KIR_PERF_ISO][i].core_min = -1;
core_set[CPU_ISO_KIR_PERF_ISO][i].core_max =
default_core_set[i].core_max;
}
for (i = 0; i < num_cpu; i++) {
if ((perfserv_isolation_cpu & (1 << i)) > 0) {
core_set[CPU_ISO_KIR_PERF_ISO][cid].core_max--;
core_ctl_set_not_preferred(cid, i, 1);
} else {
core_ctl_set_not_preferred(cid, i, 0);
}
if (i+1 >= topo_ctrl_get_cluster_cpu_id(cid+1))
cid++;
}
for_each_perfmgr_clusters(i)
update_cpu_core_limit(CPU_ISO_KIR_PERF_ISO, i,
core_set[CPU_ISO_KIR_PERF_ISO][i].core_min,
core_set[CPU_ISO_KIR_PERF_ISO][i].core_max);
#else
for (i = 0; i < num_cpu; i++) {
if ((perfserv_isolation_cpu & (1 << i)) > 0)
update_isolation_cpu(CPU_ISO_KIR_PERF_ISO, 1, i);
else
update_isolation_cpu(CPU_ISO_KIR_PERF_ISO, -1, i);
}
#endif
return cnt;
}
static int perfmgr_perfserv_iso_cpu_proc_show(struct seq_file *m, void *v)
{
if (m)
seq_printf(m, "0x%x\n", perfserv_isolation_cpu);
return 0;
}
static ssize_t perfmgr_perfserv_core_proc_write(struct file *filp
, const char __user *ubuf, size_t cnt, loff_t *pos)
{
int i = 0, data, isDefault = 1;
unsigned int arg_num = perfmgr_clusters * 2; /* for min and max */
char *tok, *tmp;
char *buf = perfmgr_copy_from_user_for_proc(ubuf, cnt);
if (!buf) {
pr_debug("buf is null\n");
goto out1;
}
tmp = buf;
pr_debug("freq write_to_file\n");
while ((tok = strsep(&tmp, " ")) != NULL) {
if (i == arg_num) {
pr_debug(
"@%s: number of arguments > %d!\n",
__func__, arg_num);
goto out;
}
if (kstrtoint(tok, 10, &data)) {
pr_debug("@%s: Invalid input: %s\n",
__func__, tok);
goto out;
} else {
if (i % 2)
core_set[CPU_ISO_KIR_PERF_CORE][i/2].core_max = data;
else
core_set[CPU_ISO_KIR_PERF_CORE][i/2].core_min = data;
i++;
}
}
if (i < arg_num) {
pr_debug(
"@%s: number of arguments < %d!\n",
__func__, arg_num);
} else {
powerhal_tid = current->pid;
for_each_perfmgr_clusters(i) {
if (core_set[CPU_ISO_KIR_PERF_CORE][i].core_min != -1 ||
core_set[CPU_ISO_KIR_PERF_CORE][i].core_max != -1) {
isDefault = 0;
break;
}
}
isolation_used[CPU_ISO_KIR_PERF_CORE] = (isDefault) ? 0 : 1;
#ifdef CONFIG_MTK_CORE_CTL
for_each_perfmgr_clusters(i)
update_cpu_core_limit(CPU_ISO_KIR_PERF_CORE, i,
core_set[CPU_ISO_KIR_PERF_CORE][i].core_min,
core_set[CPU_ISO_KIR_PERF_CORE][i].core_max);
#endif
}
out:
free_page((unsigned long)buf);
out1:
return cnt;
}
static int perfmgr_perfserv_core_proc_show(struct seq_file *m, void *v)
{
int i;
for_each_perfmgr_clusters(i)
seq_printf(m, "cluster %d min:%d max:%d\n",
i, core_set[CPU_ISO_KIR_PERF_CORE][i].core_min,
core_set[CPU_ISO_KIR_PERF_CORE][i].core_max);
return 0;
}
/*******************************************/
static ssize_t perfmgr_perfserv_all_cpu_deisolated_proc_write
(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
all_cpu_deisolated = (data > 0) ? 1 : 0;
#ifdef CONFIG_MTK_CORE_CTL
if (isBooting)
core_ctl_set_boost(1);
else
core_ctl_set_boost(all_cpu_deisolated);
#endif
return cnt;
}
static int perfmgr_perfserv_all_cpu_deisolated_proc_show
(struct seq_file *m, void *v)
{
if (m)
seq_printf(m, "%d\n", all_cpu_deisolated);
return 0;
}
PROC_FOPS_RW(perfserv_freq);
PROC_FOPS_RW(boot_freq);
PROC_FOPS_RO(current_freq);
PROC_FOPS_RW(perfmgr_log);
PROC_FOPS_RW(perfserv_iso_cpu);
PROC_FOPS_RW(perfserv_core);
PROC_FOPS_RW(perfserv_all_cpu_deisolated);
/************************************************/
int cpu_ctrl_init(struct proc_dir_entry *parent)
{
struct proc_dir_entry *boost_dir = NULL;
int i, j, ret = 0;
size_t idx;
struct pentry {
const char *name;
const struct file_operations *fops;
};
const struct pentry entries[] = {
PROC_ENTRY(perfserv_freq),
PROC_ENTRY(boot_freq),
PROC_ENTRY(current_freq),
PROC_ENTRY(perfmgr_log),
PROC_ENTRY(perfserv_iso_cpu),
PROC_ENTRY(perfserv_core),
PROC_ENTRY(perfserv_all_cpu_deisolated),
};
mutex_init(&boost_freq);
mutex_init(&isolate_lock);
boost_dir = proc_mkdir("cpu_ctrl", parent);
if (!boost_dir)
pr_debug("boost_dir null\n ");
/* create procfs */
for (idx = 0; idx < ARRAY_SIZE(entries); idx++) {
if (!proc_create(entries[idx].name, 0644,
boost_dir, entries[idx].fops)) {
pr_debug("%s(), create /cpu_ctrl%s failed\n",
__func__, entries[idx].name);
ret = -EINVAL;
goto out;
}
}
#ifdef MTK_K14_CPU_BOOST
perfserv_isolation_cpu = 0;
#endif
#ifdef CONFIG_MTK_CPU_CTRL_CFP
cfp_init_ret = cpu_ctrl_cfp_init(boost_dir);
#endif
current_freq = kcalloc(perfmgr_clusters, sizeof(struct ppm_limit_data),
GFP_KERNEL);
policy_mask = kcalloc(perfmgr_clusters, sizeof(unsigned long),
GFP_KERNEL);
for (i = 0; i < CPU_MAX_KIR; i++)
freq_set[i] = kcalloc(perfmgr_clusters
, sizeof(struct ppm_limit_data)
, GFP_KERNEL);
for_each_perfmgr_clusters(i) {
current_freq[i].min = -1;
current_freq[i].max = -1;
policy_mask[i] = 0;
}
for (i = 0; i < CPU_MAX_KIR; i++) {
for_each_perfmgr_clusters(j) {
freq_set[i][j].min = -1;
freq_set[i][j].max = -1;
}
}
num_cpu = num_possible_cpus();
for (i = 0; i < CPU_ISO_MAX_KIR; i++) {
cpu_isolation[i] = kcalloc(num_cpu, sizeof(int),
GFP_KERNEL);
for (j = 0; j < num_cpu; j++)
cpu_isolation[i][j] = -1;
isolation_used[i] = 0;
for_each_perfmgr_clusters(j) {
core_set[i][j].core_min = -1;
core_set[i][j].core_max = -1;
}
}
perfserv_isolation_cpu = 0;
all_cpu_deisolated = 0;
// sync with core_ctl
for_each_perfmgr_clusters(i) {
if (i == 0) {
default_core_set[i].core_min = 4;
default_core_set[i].core_max = 4;
} else if (i == 1) {
default_core_set[i].core_min = 2;
default_core_set[i].core_max = 3;
} else if (i == 2) {
default_core_set[i].core_min = 0;
default_core_set[i].core_max = 1;
}
}
isBooting = 1;
out:
return ret;
}
void cpu_ctrl_exit(void)
{
int i;
kfree(current_freq);
kfree(policy_mask);
for (i = 0; i < CPU_MAX_KIR; i++)
kfree(freq_set[i]);
for (i = 0; i < CPU_ISO_MAX_KIR; i++)
kfree(cpu_isolation[i]);
#ifdef CONFIG_MTK_CPU_CTRL_CFP
if (!cfp_init_ret)
cpu_ctrl_cfp_exit();
#endif
}
@@ -0,0 +1,492 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#define pr_fmt(fmt) "[cpu_ctrl_cfp]"fmt
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/cpumask.h>
#include <mt-plat/cpu_ctrl.h>
#include <mt-plat/mtk_ppm_api.h>
#include "cpu_ctrl.h"
#include "boost_ctrl.h"
#include "mtk_perfmgr_internal.h"
#include "load_track.h"
#ifdef CONFIG_TRACING
#include <linux/kallsyms.h>
#include <linux/trace_events.h>
#endif
#define MAX_NR_FREQ 16
/* Configurable */
static int __cfp_enable;
static int __cfp_polling_ms;
static int __cfp_up_opp;
static int __cfp_down_opp;
static int __cfp_up_time;
static int __cfp_down_time;
static int __cfp_up_loading;
static int __cfp_down_loading;
/* Non-Configurable */
static int cc_is_ceiled;
static struct ppm_limit_data *cc_freq, *cfp_freq;
static int cfp_curr_headroom_opp;
static int cfp_curr_up_time;
static int cfp_curr_down_time;
static int cfp_curr_loading;
static int **freq_tbl;
DEFINE_MUTEX(cfp_mlock);
static inline void cfp_lock(const char *tag)
{
mutex_lock(&cfp_mlock);
}
static inline void cfp_unlock(const char *tag)
{
mutex_unlock(&cfp_mlock);
}
static inline void cfp_lockprove(const char *tag)
{
WARN_ON(!mutex_is_locked(&cfp_mlock));
}
static int cfp_get_idx_by_freq(int clu_idx, int freq)
{
int opp_idx;
cfp_lockprove(__func__);
for (opp_idx = 0; opp_idx < MAX_NR_FREQ &&
freq <= freq_tbl[clu_idx][opp_idx]; opp_idx++)
;
return opp_idx >= 1 ? opp_idx - 1 : 0;
}
static void set_cfp_ppm(struct ppm_limit_data *desired_freq, int headroom_opp)
{
int clu_idx, cfp_ceiling_opp;
cfp_lockprove(__func__);
for_each_perfmgr_clusters(clu_idx) {
cfp_freq[clu_idx].min = desired_freq[clu_idx].min;
if (headroom_opp > 0) {
cfp_ceiling_opp =
MAX(cfp_get_idx_by_freq(clu_idx,
desired_freq[clu_idx].max)
- headroom_opp, 0);
cfp_freq[clu_idx].max =
freq_tbl[clu_idx][cfp_ceiling_opp];
} else {
cfp_freq[clu_idx].max = desired_freq[clu_idx].max;
}
#ifdef CONFIG_TRACING
perfmgr_trace_count(cfp_freq[clu_idx].min,
"cfp_min%d", clu_idx);
perfmgr_trace_count(cfp_freq[clu_idx].max,
"cfp_max%d", clu_idx);
#endif
}
#ifdef CONFIG_TRACING
perfmgr_trace_count(cc_is_ceiled, "cfp_ceiled");
#endif
mt_ppm_userlimit_cpu_freq(perfmgr_clusters, cfp_freq);
}
static void cfp_lt_callback(int mask_loading, int loading)
{
cfp_lock(__func__);
cfp_curr_loading = loading;
if (loading > __cfp_up_loading) {
cfp_curr_down_time = 0;
cfp_curr_up_time =
MIN(cfp_curr_up_time + 1, __cfp_up_time);
if (cfp_curr_up_time >= __cfp_up_time) {
cfp_curr_headroom_opp =
MIN(cfp_curr_headroom_opp + __cfp_up_opp,
MAX_NR_FREQ - 1);
set_cfp_ppm(cc_freq, cfp_curr_headroom_opp);
}
} else if (loading > __cfp_down_loading) {
cfp_curr_down_time = cfp_curr_up_time = 0;
} else {
cfp_curr_up_time = 0;
cfp_curr_down_time =
MIN(cfp_curr_down_time + 1, __cfp_down_time);
if (cfp_curr_down_time >= __cfp_down_time) {
cfp_curr_headroom_opp =
MAX(cfp_curr_headroom_opp - __cfp_down_opp, 0);
set_cfp_ppm(cc_freq, cfp_curr_headroom_opp);
}
}
#ifdef CONFIG_TRACING
perfmgr_trace_count(cfp_curr_loading, "cfp_loading");
perfmgr_trace_count(cfp_curr_headroom_opp, "cfp_headroom_opp");
perfmgr_trace_count(cfp_curr_up_time, "cfp_up_time");
perfmgr_trace_count(cfp_curr_down_time, "cfp_down_time");
#endif
cfp_unlock(__func__);
}
static void start_cfp(void)
{
int reg_ret;
int poll_ms;
cfp_lockprove(__func__);
cc_is_ceiled = 1;
poll_ms = __cfp_polling_ms;
pr_debug("%s\n", __func__);
cfp_unlock(__func__);
reg_ret = reg_loading_tracking(cfp_lt_callback, poll_ms, cpu_possible_mask);
if (reg_ret)
pr_debug("%s reg_ret=%d\n", __func__, reg_ret);
cfp_lock(__func__);
}
static void stop_cfp(void)
{
int unreg_ret;
cfp_lockprove(__func__);
cfp_curr_headroom_opp = 0;
cfp_curr_up_time = 0;
cfp_curr_down_time = 0;
cfp_curr_loading = 0;
cc_is_ceiled = 0;
pr_debug("%s\n", __func__);
cfp_unlock(__func__);
unreg_ret = unreg_loading_tracking(cfp_lt_callback);
if (unreg_ret)
pr_debug("%s unreg_ret=%d\n", __func__, unreg_ret);
cfp_lock(__func__);
}
static void restart_cfp(void)
{
pr_debug("%s\n", __func__);
stop_cfp();
start_cfp();
}
static int cfp_check_ceiled(struct ppm_limit_data *freq)
{
int clu_idx;
int ret = 0;
cfp_lockprove(__func__);
for_each_perfmgr_clusters(clu_idx) {
if (freq[clu_idx].max != -1 &&
/* FPSGO jerk max is max freq not -1.
* cfp treated as ceiled to avoid ping-pong
*/
freq[clu_idx].max <= freq_tbl[clu_idx][0]) {
ret = 1;
break;
}
}
return ret;
}
void cpu_ctrl_cfp(struct ppm_limit_data *desired_freq)
{
int v_cc_is_ceiled;
cfp_lock(__func__);
memcpy(cc_freq, desired_freq,
perfmgr_clusters * sizeof(struct ppm_limit_data));
if (!__cfp_enable) {
set_cfp_ppm(desired_freq, cfp_curr_headroom_opp);
goto out_cpu_ctrl_cfp;
}
v_cc_is_ceiled = cfp_check_ceiled(desired_freq);
if (cc_is_ceiled && !v_cc_is_ceiled)
stop_cfp();
else if (!cc_is_ceiled && v_cc_is_ceiled)
start_cfp();
set_cfp_ppm(desired_freq, cfp_curr_headroom_opp);
out_cpu_ctrl_cfp:
cfp_unlock(__func__);
}
static int set_cfp_enable(int val)
{
int ret = 0;
cfp_lock(__func__);
if (__cfp_enable == !!val) {
ret = -EINVAL;
goto out;
}
__cfp_enable = !!val;
if (cfp_check_ceiled(cc_freq)) {
if (__cfp_enable)
start_cfp();
else
stop_cfp();
}
out:
cfp_unlock(__func__);
return ret;
}
static int perfmgr_cfp_curr_stat_proc_show(struct seq_file *m, void *v)
{
cfp_lock(__func__);
if (m) {
seq_printf(m,
"enable\tceiled\tloading\theadroom_opp\tup_time\tdown_time\n");
seq_printf(m, "%d\t%d\t%d\t%d\t\t%d\t%d\n",
__cfp_enable, cc_is_ceiled,
cfp_curr_loading, cfp_curr_headroom_opp,
cfp_curr_up_time, cfp_curr_down_time);
}
cfp_unlock(__func__);
return 0;
}
#define SET_CFP(name, lb, ub) \
static int set_cfp_##name(int val) \
{ \
int ret = 0; \
\
cfp_lock(__func__); \
if (__cfp_##name == val || val < (lb) || val > (ub)) { \
ret = -EINVAL; \
goto out; \
} \
\
__cfp_##name = val; \
\
if (cc_is_ceiled) \
restart_cfp(); \
\
out: \
cfp_unlock(__func__); \
return ret; \
\
}
#define GET_CFP(name) \
static int get_cfp_##name(void) \
{ \
int ret; \
\
cfp_lock(__func__); \
ret = __cfp_##name; \
cfp_unlock(__func__); \
\
return ret; \
}
#define CFP_WRITE(name) \
static ssize_t perfmgr_cfp_##name##_proc_write(struct file *filp, \
const char __user *ubuf, size_t cnt, loff_t *pos) \
{ \
int data = 0; \
\
int rv = check_proc_write(&data, ubuf, cnt); \
\
if (rv != 0) \
return rv; \
\
if (set_cfp_##name(data)) \
return -EINVAL; \
\
return cnt; \
}
#define CFP_SHOW(name) \
static int perfmgr_cfp_##name##_proc_show(struct seq_file *m, void *v) \
{ \
if (m) \
seq_printf(m, "%d\n", get_cfp_##name()); \
return 0; \
}
SET_CFP(polling_ms, 1, INT_MAX);
SET_CFP(up_opp, 0, MAX_NR_FREQ - 1);
SET_CFP(down_opp, 0, MAX_NR_FREQ - 1);
SET_CFP(up_time, 1, INT_MAX);
SET_CFP(down_time, 1, INT_MAX);
SET_CFP(up_loading, __cfp_down_loading, 100);
SET_CFP(down_loading, 0, __cfp_up_loading);
GET_CFP(enable);
GET_CFP(polling_ms);
GET_CFP(up_opp);
GET_CFP(down_opp);
GET_CFP(up_time);
GET_CFP(down_time);
GET_CFP(up_loading);
GET_CFP(down_loading);
CFP_WRITE(enable);
CFP_WRITE(polling_ms);
CFP_WRITE(up_opp);
CFP_WRITE(down_opp);
CFP_WRITE(up_time);
CFP_WRITE(down_time);
CFP_WRITE(up_loading);
CFP_WRITE(down_loading);
CFP_SHOW(enable);
CFP_SHOW(polling_ms);
CFP_SHOW(up_opp);
CFP_SHOW(down_opp);
CFP_SHOW(up_time);
CFP_SHOW(down_time);
CFP_SHOW(up_loading);
CFP_SHOW(down_loading);
PROC_FOPS_RW(cfp_enable);
PROC_FOPS_RW(cfp_polling_ms);
PROC_FOPS_RW(cfp_up_opp);
PROC_FOPS_RW(cfp_down_opp);
PROC_FOPS_RW(cfp_up_time);
PROC_FOPS_RW(cfp_down_time);
PROC_FOPS_RW(cfp_up_loading);
PROC_FOPS_RW(cfp_down_loading);
PROC_FOPS_RO(cfp_curr_stat);
int cpu_ctrl_cfp_init(struct proc_dir_entry *parent)
{
int i;
int clu_idx, opp_idx;
int ret = 0;
size_t idx;
struct pentry {
const char *name;
const struct file_operations *fops;
};
const struct pentry entries[] = {
PROC_ENTRY(cfp_enable),
PROC_ENTRY(cfp_polling_ms),
PROC_ENTRY(cfp_up_opp),
PROC_ENTRY(cfp_down_opp),
PROC_ENTRY(cfp_up_time),
PROC_ENTRY(cfp_down_time),
PROC_ENTRY(cfp_up_loading),
PROC_ENTRY(cfp_down_loading),
PROC_ENTRY(cfp_curr_stat),
};
for (idx = 0; idx < ARRAY_SIZE(entries); idx++) {
if (!proc_create(entries[idx].name, 0644,
parent, entries[idx].fops)) {
pr_debug("%s(), create /cpu_ctrl%s failed\n",
__func__, entries[idx].name);
ret = -EINVAL;
goto out_err;
}
}
cc_freq = kcalloc(perfmgr_clusters,
sizeof(struct ppm_limit_data), GFP_KERNEL);
if (!cc_freq) {
ret = -ENOMEM;
goto out_err;
}
cfp_freq = kcalloc(perfmgr_clusters,
sizeof(struct ppm_limit_data), GFP_KERNEL);
if (!cfp_freq) {
ret = -ENOMEM;
goto out_cfp_freq_alloc_err;
}
freq_tbl = kcalloc(perfmgr_clusters,
sizeof(int *), GFP_KERNEL);
if (!freq_tbl) {
ret = -ENOMEM;
goto out_freq_tbl_alloc_err;
}
for_each_perfmgr_clusters(clu_idx) {
freq_tbl[clu_idx] = kcalloc(MAX_NR_FREQ,
sizeof(int), GFP_KERNEL);
if (!freq_tbl[clu_idx]) {
ret = -ENOMEM;
goto out_freq_tbl_opp_alloc_err;
}
for (opp_idx = 0; opp_idx < MAX_NR_FREQ; opp_idx++)
freq_tbl[clu_idx][opp_idx] =
mt_cpufreq_get_freq_by_idx(clu_idx, opp_idx);
}
__cfp_enable = 1;
__cfp_polling_ms = 64;
__cfp_up_opp = 15;
__cfp_down_opp = 15;
__cfp_up_time = 1;
__cfp_down_time = 16;
__cfp_up_loading = 90;
__cfp_down_loading = 80;
return ret;
out_freq_tbl_opp_alloc_err:
for (i = 0; i < clu_idx; i++)
kfree(freq_tbl[i]);
out_freq_tbl_alloc_err:
kfree(freq_tbl);
out_cfp_freq_alloc_err:
kfree(cc_freq);
out_err:
return ret;
}
void cpu_ctrl_cfp_exit(void)
{
int clu_idx;
stop_cfp();
kfree(cc_freq);
kfree(cfp_freq);
for_each_perfmgr_clusters(clu_idx)
kfree(freq_tbl[clu_idx]);
kfree(freq_tbl);
}
@@ -0,0 +1,30 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <mt-plat/cpu_ctrl.h>
#include <linux/proc_fs.h>
int powerhal_tid;
/*******************************************/
int update_userlimit_cpu_freq(int kicker, int num_cluster
, struct cpu_ctrl_data *freq_limit)
{
return 0;
}
EXPORT_SYMBOL(update_userlimit_cpu_freq);
int cpu_ctrl_init(struct proc_dir_entry *parent)
{
struct proc_dir_entry *boost_dir = NULL;
boost_dir = proc_mkdir("cpu_ctrl_dummy", parent);
if (!boost_dir)
pr_debug("boost_dir null\n ");
return 0;
}
@@ -0,0 +1,75 @@
#
# Copyright (C) 2018 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#DRAM_CONTROLLER
ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6739" "mt6763"))
ccflags-y += \
-DVCORE_DVFS_OPP_SUPPORT
else
ccflags-y += \
-DMTK_QOS_SUPPORT
ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6771"))
ccflags-y += \
-DMTK_QOS_EMI_OPP
endif # ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6771"))
endif # ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6739" "mt6763"))
ifeq ($(CONFIG_MACH_MT6893),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6885),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6877),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6873),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6853),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6781),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6739),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6833),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6768),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6771),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
else ifeq ($(CONFIG_MACH_MT6785),y)
ccflags-y += \
-DMTK_K14_DRM_BOOST
endif
obj-y += dram_ctrl.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/include/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc/$(MTK_PLATFORM)/
ccflags-y += -I$(srctree)/include/memory/mediatek/
#if PM_DEVFREQ
ccflags-y += -I$(srctree)/drivers/devfreq/
#endif # PM_DEVFREQ
@@ -0,0 +1,548 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/pm_domain.h>
#include <linux/pm_opp.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/soc/mediatek/mtk_dvfsrc.h>
#if !defined(CONFIG_MACH_MT6771)
#include <linux/soc/mediatek/mtk-pm-qos.h>
#endif
#ifdef MTK_K14_DRM_BOOST
#if defined(MTK_QOS_SUPPORT)
#include <linux/pm_qos.h>
#include <helio-dvfsrc-opp.h>
#if defined(CONFIG_MACH_MT6771)
#define MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE PM_QOS_DDR_OPP_DEFAULT_VALUE
#define MTK_PM_QOS_DDR_OPP PM_QOS_DDR_OPP
#endif
#endif
#if defined(CONFIG_MTK_DRAMC)
#include "mtk_dramc.h"
#endif
#if defined(VCORE_DVFS_OPP_SUPPORT)
#include <mtk_vcorefs_governor.h>
#include <mtk_vcorefs_manager.h>
#endif
#include "mtk_perfmgr_internal.h"
#include "boost_ctrl.h"
#ifdef CONFIG_MEDIATEK_DRAMC
#include <dramc.h>
#endif
static int ddr_type;
char qos_has_dts_support;
#ifdef MTK_QOS_SUPPORT
/* QoS Method */
static int ddr_now;
static int ddr_lp5_now;
static int ddr_lp5_hfr_now;
static struct mtk_pm_qos_request emi_request;
static struct mtk_pm_qos_request emi_request_lp5;
static struct mtk_pm_qos_request emi_request_lp5_hfr;
static int emi_opp;
static int dfps;
static int hfr_fps;
#endif
#ifdef VCORE_DVFS_OPP_SUPPORT
static int vcore_now;
#endif
#endif
struct mtk_dram_ctrl {
struct device *dev;
struct proc_dir_entry *proc_dir;
int num_perf;
int *perfs;
int curr_opp;
int qos_ctrl;
};
struct proc_dir_entry *dram_proc_parent;
static struct mtk_pm_qos_request ddr_request;
void dram_ctl_update_dfrc_fps(int fps)
{
#ifdef MTK_K14_DRM_BOOST
#ifdef MTK_QOS_SUPPORT
if (fps == dfps || fps <= 0)
return;
dfps = fps;
#ifdef CONFIG_MEDIATEK_DRAMC
if (ddr_lp5_now == -1 && ddr_lp5_hfr_now == -1)
return;
if (mtk_dramc_get_ddr_type() != TYPE_LPDDR5)
return;
if (ddr_lp5_now != -1 && dfps <= hfr_fps)
mtk_pm_qos_update_request(&emi_request_lp5, ddr_lp5_now);
else if (ddr_lp5_hfr_now != -1 && dfps > hfr_fps)
mtk_pm_qos_update_request(&emi_request_lp5_hfr, ddr_lp5_hfr_now);
else if (ddr_lp5_now != -1)
mtk_pm_qos_update_request(&emi_request_lp5, -1);
else
mtk_pm_qos_update_request(&emi_request_lp5_hfr, -1);
#endif
#endif
#endif
}
static ssize_t ddr_ctrl_proc_write(struct file *filp, const char *ubuf,
size_t cnt, loff_t *data)
{
struct mtk_dram_ctrl *dram_ctrl = PDE_DATA(file_inode(filp));
char buf[64];
int val;
int ret;
if (cnt >= sizeof(buf)) {
pr_debug("ddr_write cnt >= sizeof\n");
return -EINVAL;
}
if (copy_from_user(buf, ubuf, cnt)) {
pr_debug("ddr_write copy_from_user\n");
return -EFAULT;
}
buf[cnt] = 0;
ret = kstrtoint(buf, 10, &val);
if (ret < 0) {
pr_debug("ddr_write ret < 0\n");
return ret;
}
if (dram_ctrl->qos_ctrl) {
if ((val > -1) && (val < dram_ctrl->num_perf))
mtk_pm_qos_update_request(&ddr_request,
dram_ctrl->perfs[val]);
else
mtk_pm_qos_update_request(&ddr_request,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if ((val > -1) && (val < dram_ctrl->num_perf))
dev_pm_genpd_set_performance_state(
dram_ctrl->dev,
dram_ctrl->perfs[val]);
else
dev_pm_genpd_set_performance_state(
dram_ctrl->dev, 0);
}
dram_ctrl->curr_opp = val;
return cnt;
}
static int ddr_ctrl_proc_show(struct seq_file *m, void *v)
{
struct mtk_dram_ctrl *dram_ctrl = m->private;
seq_printf(m, "%d\n", dram_ctrl->curr_opp);
return 0;
}
static int ddr_ctrl_proc_open(struct inode *inode, struct file *file)
{
return single_open(file, ddr_ctrl_proc_show, PDE_DATA(inode));
}
static const struct file_operations ddr_ctrl_proc_fops = {
.owner = THIS_MODULE,
.open = ddr_ctrl_proc_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
.write = ddr_ctrl_proc_write,
};
static int mtk_dram_ctrl_probe(struct platform_device *pdev)
{
struct mtk_dram_ctrl *dram_ctrl;
struct device *dev = &pdev->dev;
struct device_node *node = pdev->dev.of_node;
int i;
dram_ctrl = devm_kzalloc(dev, sizeof(*dram_ctrl), GFP_KERNEL);
if (!dram_ctrl)
return -ENOMEM;
dram_ctrl->num_perf = of_count_phandle_with_args(node,
"required-opps", NULL);
if (dram_ctrl->num_perf > 0) {
dram_ctrl->perfs = devm_kzalloc(&pdev->dev,
dram_ctrl->num_perf * sizeof(int),
GFP_KERNEL);
if (!dram_ctrl->perfs)
return -ENOMEM;
for (i = 0; i < dram_ctrl->num_perf; i++) {
dram_ctrl->perfs[i] =
dvfsrc_get_required_opp_performance_state(node, i);
}
} else
dram_ctrl->num_perf = 0;
if (of_device_is_compatible(node, "mediatek,dram-qosctrl")) {
mtk_pm_qos_add_request(&ddr_request, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
dram_ctrl->qos_ctrl = 1;
}
dram_ctrl->curr_opp = dram_ctrl->num_perf;
dram_ctrl->dev = dev;
platform_set_drvdata(pdev, dram_ctrl);
dram_ctrl->proc_dir = proc_mkdir("dram_ctrl", dram_proc_parent);
if (!dram_ctrl->proc_dir) {
pr_debug("drams_dir not create success\n");
return -ENOMEM;
}
proc_create_data("ddr", 0644,
dram_ctrl->proc_dir, &ddr_ctrl_proc_fops, dram_ctrl);
#ifdef MTK_K14_DRM_BOOST
qos_has_dts_support = 1;
#endif
return 0;
}
static int mtk_dram_ctrl_remove(struct platform_device *pdev)
{
return 0;
}
static const struct of_device_id mtk_dram_ctrl_of_match[] = {
{
.compatible = "mediatek,dram-ctrl",
}, {
.compatible = "mediatek,dram-qosctrl",
}, {
/* sentinel */
},
};
static struct platform_driver mtk_dram_ctrl_driver = {
.probe = mtk_dram_ctrl_probe,
.remove = mtk_dram_ctrl_remove,
.driver = {
.name = "mtk-dram_ctrl",
.of_match_table = of_match_ptr(mtk_dram_ctrl_of_match),
},
};
#ifdef MTK_K14_DRM_BOOST
#ifdef MTK_QOS_SUPPORT
static ssize_t perfmgr_ddr_lp5_hfr_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *data)
{
char buf[64];
int val;
int ret;
if (cnt >= sizeof(buf)) {
pr_debug("ddr_write cnt >= sizeof\n");
return -EINVAL;
}
if (copy_from_user(buf, ubuf, cnt)) {
pr_debug("ddr_write copy_from_user\n");
return -EFAULT;
}
buf[cnt] = 0;
ret = kstrtoint(buf, 10, &val);
if (ret < 0) {
pr_debug("ddr_write ret < 0\n");
return ret;
}
if (val < -1 || val > emi_opp) {
pr_debug("UNREQ\n");
return -1;
}
ddr_lp5_hfr_now = val;
#ifdef CONFIG_MEDIATEK_DRAMC
if (mtk_dramc_get_ddr_type() == TYPE_LPDDR5
&& dfps > hfr_fps)
mtk_pm_qos_update_request(&emi_request_lp5_hfr, val);
#endif
return cnt;
}
static int perfmgr_ddr_lp5_hfr_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", ddr_lp5_hfr_now);
return 0;
}
PROC_FOPS_RW(ddr_lp5_hfr);
static ssize_t perfmgr_ddr_lp5_proc_write(struct file *filp, const char *ubuf,
size_t cnt, loff_t *data)
{
char buf[64];
int val;
int ret;
if (cnt >= sizeof(buf)) {
pr_debug("ddr_write cnt >= sizeof\n");
return -EINVAL;
}
if (copy_from_user(buf, ubuf, cnt)) {
pr_debug("ddr_write copy_from_user\n");
return -EFAULT;
}
buf[cnt] = 0;
ret = kstrtoint(buf, 10, &val);
if (ret < 0) {
pr_debug("ddr_write ret < 0\n");
return ret;
}
if (val < -1 || val > emi_opp) {
pr_debug("UNREQ\n");
return -1;
}
ddr_lp5_now = val;
#ifdef CONFIG_MEDIATEK_DRAMC
if (mtk_dramc_get_ddr_type() == TYPE_LPDDR5
&& dfps <= hfr_fps)
mtk_pm_qos_update_request(&emi_request_lp5, val);
#endif
return cnt;
}
static int perfmgr_ddr_lp5_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", ddr_lp5_now);
return 0;
}
PROC_FOPS_RW(ddr_lp5);
static ssize_t perfmgr_ddr_proc_write(struct file *filp, const char *ubuf,
size_t cnt, loff_t *data)
{
char buf[64];
int val;
int ret;
if (cnt >= sizeof(buf)) {
pr_debug("ddr_write cnt >= sizeof\n");
return -EINVAL;
}
if (copy_from_user(buf, ubuf, cnt)) {
pr_debug("ddr_write copy_from_user\n");
return -EFAULT;
}
buf[cnt] = 0;
ret = kstrtoint(buf, 10, &val);
if (ret < 0) {
pr_debug("ddr_write ret < 0\n");
return ret;
}
if (val < -1 || val > emi_opp) {
pr_debug("UNREQ\n");
return -1;
}
mtk_pm_qos_update_request(&emi_request, val);
ddr_now = val;
return cnt;
}
static int perfmgr_ddr_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", ddr_now);
return 0;
}
PROC_FOPS_RW(ddr);
#endif
#ifdef MTK_K14_DRM_BOOST
#ifdef VCORE_DVFS_OPP_SUPPORT
static ssize_t perfmgr_vcore_proc_write(struct file *filp, const char *ubuf,
size_t cnt, loff_t *data)
{
char buf[64];
int val;
int ret;
if (cnt >= sizeof(buf)) {
pr_debug("vcore_write cnt >= sizeof\n");
return -EINVAL;
}
if (copy_from_user(buf, ubuf, cnt)) {
pr_debug("vcore_write copy_from_user\n");
return -EFAULT;
}
buf[cnt] = 0;
ret = kstrtoint(buf, 10, &val);
if (ret < 0) {
pr_debug("vcore_write ret < 0\n");
return ret;
}
if (val < -1 || val > 4) {
pr_debug("UNREQ\n");
return -1;
}
ret = vcorefs_request_dvfs_opp(KIR_PERF, val);
if (ret == 0)
vcore_now = val;
return cnt;
}
static int perfmgr_vcore_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", vcore_now);
return 0;
}
PROC_FOPS_RW(vcore);
#endif
#endif
static int perfmgr_dram_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "DDR_TYPE: %d\n", ddr_type);
return 0;
}
PROC_FOPS_RO(dram);
int dram_ctrl_init_with_no_dts_support(struct proc_dir_entry *parent)
{
int ret = 0;
size_t i;
#ifdef MTK_QOS_SUPPORT
char owner[20] = "dram_ctrl_lp5";
char owner_hfr[20] = "dram_ctrl_lp5_hfr";
#endif
struct proc_dir_entry *drams_dir;
struct pentry {
const char *name;
const struct file_operations *fops;
};
const struct pentry entries[] = {
PROC_ENTRY(dram),
#ifdef MTK_QOS_SUPPORT
PROC_ENTRY(ddr),
PROC_ENTRY(ddr_lp5),
PROC_ENTRY(ddr_lp5_hfr),
#endif
#ifdef VCORE_DVFS_OPP_SUPPORT
PROC_ENTRY(vcore),
#endif
};
pr_debug("init dram driver start\n");
drams_dir = proc_mkdir("dram_ctrl", parent);
if (!drams_dir) {
pr_debug("drams_dir not create success\n");
return -ENOMEM;
}
/* create procfs */
for (i = 0; i < ARRAY_SIZE(entries); i++) {
if (!proc_create(entries[i].name, 0644,
drams_dir, entries[i].fops)) {
pr_debug("%s(), create /dram_ctrl%s failed\n",
__func__, entries[i].name);
ret = -EINVAL;
goto out;
}
}
#ifdef MTK_QOS_SUPPORT
/* QoS Method */
hfr_fps = 66;
ddr_now = -1;
ddr_lp5_now = -1;
ddr_lp5_hfr_now = -1;
if (!mtk_pm_qos_request_active(&emi_request) ||
!mtk_pm_qos_request_active(&emi_request_lp5) ||
!mtk_pm_qos_request_active(&emi_request_lp5_hfr)) {
pr_debug("hh: emi pm_qos_add_request\n");
mtk_pm_qos_add_request(&emi_request, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
mtk_pm_qos_add_request(&emi_request_lp5, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
strncpy(emi_request_lp5.owner, owner,
sizeof(emi_request_lp5.owner) - 1);
mtk_pm_qos_add_request(&emi_request_lp5_hfr, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
strncpy(emi_request_lp5_hfr.owner, owner_hfr,
sizeof(emi_request_lp5_hfr.owner) - 1);
} else {
pr_debug("hh: emi pm_qos already request\n");
}
emi_opp = DDR_OPP_NUM - 1;
#endif
#ifdef VCORE_DVFS_OPP_SUPPORT
vcore_now = -1;
#endif
#ifdef CONFIG_MEDIATEK_DRAMC
ddr_type = mtk_dramc_get_ddr_type();
#else
ddr_type = -1;
#endif
pr_debug("init dram driver done\n");
out:
return ret;
}
#endif
int dram_ctrl_init(struct proc_dir_entry *parent)
{
int ret = 0;
dram_proc_parent = parent;
ret = platform_driver_register(&mtk_dram_ctrl_driver);
#ifdef MTK_K14_DRM_BOOST
if (!qos_has_dts_support)
dram_ctrl_init_with_no_dts_support(parent);
#endif
return ret;
}
void dram_ctrl_exit(void)
{
platform_driver_unregister(&mtk_dram_ctrl_driver);
}
@@ -0,0 +1,58 @@
#
# Copyright (C) 2018 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#EAS_CONTROLLER
MTK_TOP = $(srctree)/drivers/misc/mediatek/
ccflags-y += \
-I$(MTK_TOP)/base/power/include/ \
-I$(MTK_TOP)/base/power/$(MTK_PLATFORM)/ \
-I$(MTK_TOP)/dramc/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/performance/boost_ctrl/include/ \
-I$(srctree)/drivers/misc/mediatek/include/mt-plat/
ifeq ($(CONFIG_MACH_MT6893),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6885),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6877),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6781),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6739),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6833),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6768),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6853),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6873),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6771),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
else ifeq ($(CONFIG_MACH_MT6785),y)
ccflags-y += \
-DMTK_K14_EAS_BOOST
endif
obj-y += eas_ctrl.o uclamp_ctrl.o
@@ -0,0 +1,854 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#define pr_fmt(fmt) "[eas_ctrl]"fmt
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include "boost_ctrl.h"
#include "eas_ctrl_plat.h"
#include <mt-plat/eas_ctrl.h>
#include "mtk_perfmgr_internal.h"
//#include <mt-plat/mtk_sched.h>
#include <linux/sched.h>
#ifdef CONFIG_TRACING
#include <linux/kallsyms.h>
#include <linux/trace_events.h>
#endif
/* boost value */
static struct mutex boost_eas;
static bool perf_sched_big_task_rotation;
static pid_t last_cpu_prefer_pid;
static int last_cpu_perfer_type;
#ifdef MTK_K14_EAS_BOOST
#include "eas_ctrl.h"
#define SCHED_API_READY 0
#define MAX_BOOST_VALUE (100)
#define MIN_BOOST_VALUE (-100)
#define MAX_UCLAMP_VALUE (100)
#define MIN_UCLAMP_VALUE (0)
#define MIN_DEBUG_UCLAMP_VALUE (-1)
static int uclamp_min[NR_CGROUP][EAS_UCLAMP_MAX_KIR];
static int boost_value[NR_CGROUP][EAS_MAX_KIR];
static unsigned long prefer_idle[NR_CGROUP];
static int perf_sched_stune_task_thresh;
static int debug_fix_boost;
static int debug_boost_value[NR_CGROUP];
/* log */
static int log_enable;
#ifdef CONFIG_SCHED_TUNE
static int current_boost_value[NR_CGROUP];
static unsigned long policy_mask[NR_CGROUP];
#endif
#endif
/************************/
/************************/
/********************************************************************/
/* Add procfs to control sysctl_sched_rotation_enable */
/* sysctl_sched_rotation_enable: eas_ctrl_plat.h */
static ssize_t perfmgr_sched_big_task_rotation_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
perf_sched_big_task_rotation = data;
#ifdef CONFIG_MTK_SCHED_BIG_TASK_MIGRATE
if (data)
set_sched_rotation_enable(true);
else
set_sched_rotation_enable(false);
#endif
return cnt;
}
static int perfmgr_sched_big_task_rotation_proc_show(struct seq_file *m,
void *v)
{
seq_printf(m, "%d\n", perf_sched_big_task_rotation);
return 0;
}
/* Add procfs to control sched_boost */
/* set_sched_boost_type: eas_ctrl_plat.h */
static ssize_t perfmgr_sched_boost_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
if (data < 0 || data > 2)
return -EINVAL;
#if defined(CONFIG_CGROUPS) && defined(CONFIG_MTK_SCHED_CPU_PREFER)
if (set_sched_boost_type(data) < 0)
return -EINVAL;
#endif
return cnt;
}
static int perfmgr_sched_boost_proc_show(struct seq_file *m, void *v)
{
int boost_type = 0;
#if defined(CONFIG_CGROUPS) && defined(CONFIG_MTK_SCHED_CPU_PREFER)
boost_type = get_sched_boost_type();
#endif
seq_printf(m, "sched_boost = %d ", boost_type);
if (boost_type == 0)
seq_puts(m, "(no boost)\n");
else if (boost_type == 1)
seq_puts(m, "(all boost)\n");
else if (boost_type == 2)
seq_puts(m, "(foreground boost)\n");
else
seq_puts(m, "(invalid setting)\n");
return 0;
}
/* Add procfs to control cpu_prefer */
/* set_sched_boost_type: eas_ctrl_plat.h */
static ssize_t perfmgr_cpu_prefer_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
char buf[64];
pid_t pid, type;
if (cnt >= sizeof(buf))
return -EINVAL;
if (copy_from_user(buf, ubuf, cnt))
return -EFAULT;
buf[cnt] = '\0';
if (sscanf(buf, "%d %d", (int *)&pid, &type) != 2)
return -EFAULT;
#ifdef CONFIG_MTK_SCHED_CPU_PREFER
if (sched_set_cpuprefer(pid, type) != 0)
return -EINVAL;
#endif
last_cpu_prefer_pid = pid;
last_cpu_perfer_type = type;
return cnt;
}
static int perfmgr_cpu_prefer_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "last pid:%d, type:%d\n",
(int)last_cpu_prefer_pid, last_cpu_perfer_type);
return 0;
}
static int perfmgr_set_sched_isolation_proc_show(struct seq_file *m, void *v)
{
seq_puts(m, "");
return 0;
}
static ssize_t perfmgr_set_sched_isolation_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
unsigned int cpu_id = -1;
char buf[64];
if (cnt >= sizeof(buf))
return -EINVAL;
if (copy_from_user(buf, ubuf, cnt))
return -EFAULT;
buf[cnt] = '\0';
if (sscanf(buf, "%iu", &cpu_id) != 1)
return -EINVAL;
if (cpu_id >= nr_cpu_ids)
return cnt;
sched_isolate_cpu(cpu_id);
return cnt;
}
static int perfmgr_set_sched_deisolation_proc_show(struct seq_file *m, void *v)
{
seq_puts(m, "");
return 0;
}
static ssize_t perfmgr_set_sched_deisolation_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
unsigned int cpu_id = -1;
char buf[64];
if (cnt >= sizeof(buf))
return -EINVAL;
if (copy_from_user(buf, ubuf, cnt))
return -EFAULT;
buf[cnt] = '\0';
if (sscanf(buf, "%iu", &cpu_id) != 1)
return -EINVAL;
if (cpu_id >= nr_cpu_ids)
return cnt;
sched_unisolate_cpu(cpu_id);
return cnt;
}
static int perfmgr_sched_isolated_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "cpu_isolated_mask=0x%lx\n",
__cpu_isolated_mask.bits[0]);
return 0;
}
#ifdef MTK_K14_EAS_BOOST
static void walt_mode(int enable)
{
#ifdef CONFIG_SCHED_WALT
sched_walt_enable(LT_WALT_POWERHAL, enable);
#else
pr_debug("walt not be configured\n");
#endif
}
void ext_launch_start(void)
{
pr_debug("_ext_launch_start\n");
/*--feature start from here--*/
#ifdef CONFIG_TRACING
perfmgr_trace_begin("ext_launch_start", 0, 1, 0);
#endif
walt_mode(1);
#ifdef CONFIG_TRACING
perfmgr_trace_end();
#endif
}
void ext_launch_end(void)
{
pr_debug("_ext_launch_end\n");
/*--feature end from here--*/
#ifdef CONFIG_TRACING
perfmgr_trace_begin("ext_launch_end", 0, 0, 1);
#endif
walt_mode(0);
#ifdef CONFIG_TRACING
perfmgr_trace_end();
#endif
}
/************************/
static int check_boost_value(int boost_value)
{
return clamp(boost_value, MIN_BOOST_VALUE, MAX_BOOST_VALUE);
}
static int check_uclamp_value(int value)
{
return clamp(value, MIN_UCLAMP_VALUE, MAX_UCLAMP_VALUE);
}
#ifdef CONFIG_SCHED_TUNE
int update_eas_boost_value(int kicker, int cgroup_idx, int value)
{
int final_boost = 0;
int i, len = 0, len1 = 0;
char msg[LOG_BUF_SIZE];
char msg1[LOG_BUF_SIZE];
if (cgroup_idx >= NR_CGROUP || cgroup_idx < 0) {
pr_debug("cgroup_idx:%d, error\n", cgroup_idx);
perfmgr_trace_printk("cpu_ctrl", "cgroup_idx >= NR_CGROUP\n");
return -1;
}
if (kicker < 0 || kicker >= EAS_MAX_KIR) {
pr_debug("kicker:%d error\n", kicker);
return -1;
}
mutex_lock(&boost_eas);
boost_value[cgroup_idx][kicker] = value;
len += snprintf(msg + len, sizeof(msg) - len, "[%d] [%d] [%d]",
kicker, cgroup_idx, value);
/*ptr return error EIO:I/O error */
if (len < 0) {
perfmgr_trace_printk("cpu_ctrl", "return -EIO 1\n");
mutex_unlock(&boost_eas);
return -EIO;
}
for (i = 0; i < EAS_MAX_KIR; i++) {
if (boost_value[cgroup_idx][i] == 0) {
clear_bit(i, &policy_mask[cgroup_idx]);
continue;
}
/* Always set first to handle negative input */
if (final_boost == 0)
final_boost = boost_value[cgroup_idx][i];
else
final_boost = MAX(final_boost,
boost_value[cgroup_idx][i]);
set_bit(i, &policy_mask[cgroup_idx]);
}
current_boost_value[cgroup_idx] = check_boost_value(final_boost);
len += snprintf(msg + len, sizeof(msg) - len, "{%d} ", final_boost);
/*ptr return error EIO:I/O error */
if (len < 0) {
perfmgr_trace_printk("cpu_ctrl", "return -EIO 2\n");
mutex_unlock(&boost_eas);
return -EIO;
}
len1 += snprintf(msg1 + len1, sizeof(msg1) - len1, "[0x %lx] ",
policy_mask[cgroup_idx]);
if (len1 < 0) {
perfmgr_trace_printk("cpu_ctrl", "return -EIO 3\n");
mutex_unlock(&boost_eas);
return -EIO;
}
#if SCHED_API_READY
if (!debug_fix_boost)
boost_write_for_perf_idx(cgroup_idx,
current_boost_value[cgroup_idx]);
#endif
if (strlen(msg) + strlen(msg1) < LOG_BUF_SIZE)
strncat(msg, msg1, strlen(msg1));
if (log_enable)
pr_debug("%s\n", msg);
#ifdef CONFIG_TRACING
perfmgr_trace_printk("eas_ctrl", msg);
#endif
mutex_unlock(&boost_eas);
return current_boost_value[cgroup_idx];
}
#else
int update_eas_boost_value(int kicker, int cgroup_idx, int value)
{
return -1;
}
#endif
static ssize_t perfmgr_perfserv_prefer_idle_proc_write(
struct file *filp, const char *ubuf,
size_t cnt, loff_t *pos)
{
int cgroup = 0, data = 0;
int rv = check_group_proc_write(&cgroup, &data, ubuf, cnt);
if (rv != 0)
return rv;
if (data < 0 || data > 1)
return -EINVAL;
if (cgroup >= 0 && cgroup < NR_CGROUP) {
if (data != 0)
update_prefer_idle_value(EAS_PREFER_IDLE_KIR_PERF,
cgroup, 1);
else
update_prefer_idle_value(EAS_PREFER_IDLE_KIR_PERF,
cgroup, 0);
}
return cnt;
}
static int perfmgr_perfserv_prefer_idle_proc_show(struct seq_file *m, void *v)
{
int i;
for (i = 0; i < NR_CGROUP; i++)
seq_printf(m, "%d\n",
test_bit(EAS_PREFER_IDLE_KIR_PERF, &prefer_idle[i]));
return 0;
}
static ssize_t perfmgr_boot_boost_proc_write(
struct file *filp, const char *ubuf,
size_t cnt, loff_t *pos)
{
int cgroup = 0, data = 0;
int rv = check_group_proc_write(&cgroup, &data, ubuf, cnt);
if (rv != 0)
return rv;
data = check_uclamp_value(data);
if (cgroup >= 0 && cgroup < NR_CGROUP)
update_eas_uclamp_min(EAS_UCLAMP_KIR_BOOT, cgroup, data);
return cnt;
}
static int perfmgr_boot_boost_proc_show(struct seq_file *m, void *v)
{
int i;
for (i = 0; i < NR_CGROUP; i++)
seq_printf(m, "%d\n", uclamp_min[i][EAS_UCLAMP_KIR_BOOT]);
return 0;
}
static ssize_t perfmgr_perfserv_bg_boost_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
data = check_boost_value(data);
update_eas_boost_value(EAS_KIR_PERF, CGROUP_BG, data);
return cnt;
}
static int perfmgr_perfserv_bg_boost_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", boost_value[CGROUP_BG][EAS_KIR_PERF]);
return 0;
}
static ssize_t perfmgr_perfserv_fg_boost_proc_write(struct file *filp
, const char *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
data = check_boost_value(data);
update_eas_boost_value(EAS_KIR_PERF, CGROUP_FG, data);
return cnt;
}
static int perfmgr_perfserv_fg_boost_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", boost_value[CGROUP_FG][EAS_KIR_PERF]);
return 0;
}
static ssize_t perfmgr_perfserv_ta_boost_proc_write(
struct file *filp, const char *ubuf,
size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
data = check_boost_value(data);
update_eas_boost_value(EAS_KIR_PERF, CGROUP_TA, data);
return cnt;
}
static int perfmgr_perfserv_ta_boost_proc_show(
struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", boost_value[CGROUP_TA][EAS_KIR_PERF]);
return 0;
}
/* Add procfs to control sysctl_sched_migration_cost */
/* sysctl_sched_migration_cost: eas_ctrl_plat.h */
static ssize_t perfmgr_m_sched_migrate_cost_n_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
sysctl_sched_migration_cost = data;
return cnt;
}
static int perfmgr_m_sched_migrate_cost_n_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", sysctl_sched_migration_cost);
return 0;
}
static ssize_t perfmgr_sched_stune_task_thresh_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
perf_sched_stune_task_thresh = data;
#if SCHED_API_READY
#ifdef CONFIG_SCHED_TUNE
if (perf_sched_stune_task_thresh >= 0)
set_stune_task_threshold(perf_sched_stune_task_thresh);
else
set_stune_task_threshold(-1);
#endif
#endif
return cnt;
}
static int perfmgr_sched_stune_task_thresh_proc_show(struct seq_file *m,
void *v)
{
seq_printf(m, "%d\n", perf_sched_stune_task_thresh);
return 0;
}
static int ext_launch_state;
static ssize_t perfmgr_perfserv_ext_launch_mon_proc_write(struct file *filp,
const char *ubuf, size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
if (data) {
ext_launch_start();
ext_launch_state = 1;
} else {
ext_launch_end();
ext_launch_state = 0;
}
pr_debug("perfmgr_perfserv_ext_launch_mon");
return cnt;
}
static int
perfmgr_perfserv_ext_launch_mon_proc_show(
struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", ext_launch_state);
return 0;
}
/************************************************/
static int perfmgr_current_fg_boost_proc_show(struct seq_file *m, void *v)
{
#ifdef CONFIG_SCHED_TUNE
seq_printf(m, "%d\n", current_boost_value[CGROUP_FG]);
#else
seq_printf(m, "%d\n", -1);
#endif
return 0;
}
/************************************************************/
static ssize_t perfmgr_debug_fg_boost_proc_write(
struct file *filp, const char *ubuf,
size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
debug_boost_value[CGROUP_FG] = check_boost_value(data);
debug_fix_boost = debug_boost_value[CGROUP_FG] > 0 ? 1:0;
#if SCHED_API_READY
#ifdef CONFIG_SCHED_TUNE
boost_write_for_perf_idx(CGROUP_FG,
debug_boost_value[CGROUP_FG]);
#endif
#endif
return cnt;
}
static int perfmgr_debug_fg_boost_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", debug_boost_value[CGROUP_FG]);
return 0;
}
/*******************************************************/
static int perfmgr_current_bg_boost_proc_show(struct seq_file *m, void *v)
{
#ifdef CONFIG_SCHED_TUNE
seq_printf(m, "%d\n", current_boost_value[CGROUP_BG]);
#else
seq_printf(m, "%d\n", -1);
#endif
return 0;
}
/**************************************************/
static ssize_t perfmgr_debug_bg_boost_proc_write(
struct file *filp, const char *ubuf,
size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
debug_boost_value[CGROUP_BG] = check_boost_value(data);
debug_fix_boost = debug_boost_value[CGROUP_BG] > 0 ? 1:0;
#if SCHED_API_READY
#ifdef CONFIG_SCHED_TUNE
boost_write_for_perf_idx(CGROUP_BG,
debug_boost_value[CGROUP_BG]);
#endif
#endif
return cnt;
}
static int perfmgr_debug_bg_boost_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", debug_boost_value[CGROUP_BG]);
return 0;
}
/************************************************/
static int perfmgr_current_ta_boost_proc_show(struct seq_file *m, void *v)
{
#ifdef CONFIG_SCHED_TUNE
seq_printf(m, "%d\n", current_boost_value[CGROUP_TA]);
#else
seq_printf(m, "%d\n", -1);
#endif
return 0;
}
/**********************************/
static ssize_t perfmgr_debug_ta_boost_proc_write(
struct file *filp, const char *ubuf,
size_t cnt, loff_t *pos)
{
int data = 0;
int rv = check_proc_write(&data, ubuf, cnt);
if (rv != 0)
return rv;
debug_boost_value[CGROUP_TA] = check_boost_value(data);
debug_fix_boost = debug_boost_value[CGROUP_TA] > 0 ? 1:0;
#if SCHED_API_READY
#ifdef CONFIG_SCHED_TUNE
boost_write_for_perf_idx(CGROUP_TA,
debug_boost_value[CGROUP_TA]);
#endif
#endif
return cnt;
}
static int perfmgr_debug_ta_boost_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", debug_boost_value[CGROUP_TA]);
return 0;
}
#endif
/* others */
#ifdef MTK_K14_EAS_BOOST
PROC_FOPS_RW(m_sched_migrate_cost_n);
PROC_FOPS_RW(sched_stune_task_thresh);
#endif
PROC_FOPS_RW(sched_big_task_rotation);
PROC_FOPS_RW(sched_boost);
PROC_FOPS_RW(cpu_prefer);
#ifdef MTK_K14_EAS_BOOST
/* boost value */
PROC_FOPS_RW(perfserv_fg_boost);
PROC_FOPS_RW(perfserv_bg_boost);
PROC_FOPS_RW(perfserv_ta_boost);
PROC_FOPS_RW(boot_boost);
PROC_FOPS_RO(current_fg_boost);
PROC_FOPS_RW(debug_fg_boost);
PROC_FOPS_RO(current_bg_boost);
PROC_FOPS_RW(debug_bg_boost);
PROC_FOPS_RO(current_ta_boost);
PROC_FOPS_RW(debug_ta_boost);
#endif
#ifdef MTK_K14_EAS_BOOST
/*--ext_launch--*/
PROC_FOPS_RW(perfserv_ext_launch_mon);
PROC_FOPS_RW(perfserv_prefer_idle);
#endif
PROC_FOPS_RW(set_sched_isolation);
PROC_FOPS_RW(set_sched_deisolation);
PROC_FOPS_RO(sched_isolated);
/*******************************************/
int eas_ctrl_init(struct proc_dir_entry *parent)
{
#ifdef CONFIG_MTK_SCHED_EXTENSION
int ret = 0;
size_t i;
#ifdef MTK_K14_EAS_BOOST
#if defined(CONFIG_SCHED_TUNE)
int j;
#endif
#endif
struct pentry {
const char *name;
const struct file_operations *fops;
};
const struct pentry entries[] = {
/*--sched migrate cost n--*/
#ifdef MTK_K14_EAS_BOOST
PROC_ENTRY(m_sched_migrate_cost_n),
PROC_ENTRY(sched_stune_task_thresh),
#endif
PROC_ENTRY(sched_big_task_rotation),
PROC_ENTRY(sched_boost),
PROC_ENTRY(cpu_prefer),
PROC_ENTRY(set_sched_isolation),
PROC_ENTRY(set_sched_deisolation),
PROC_ENTRY(sched_isolated),
#ifdef MTK_K14_EAS_BOOST
PROC_ENTRY(perfserv_prefer_idle),
/*--ext_launch--*/
PROC_ENTRY(perfserv_ext_launch_mon),
/* boost value */
PROC_ENTRY(perfserv_fg_boost),
PROC_ENTRY(perfserv_bg_boost),
PROC_ENTRY(perfserv_ta_boost),
PROC_ENTRY(current_fg_boost),
PROC_ENTRY(debug_fg_boost),
PROC_ENTRY(current_bg_boost),
PROC_ENTRY(debug_bg_boost),
PROC_ENTRY(current_ta_boost),
PROC_ENTRY(debug_ta_boost),
PROC_ENTRY(boot_boost),
#endif
};
/* create procfs */
for (i = 0; i < ARRAY_SIZE(entries); i++) {
if (!proc_create(entries[i].name, 0644,
parent, entries[i].fops)) {
pr_debug("%s(), create /eas_ctrl%s failed\n",
__func__, entries[i].name);
ret = -EINVAL;
goto out;
}
}
perf_sched_big_task_rotation = 0;
#ifdef MTK_K14_EAS_BOOST
#if defined(CONFIG_SCHED_TUNE)
/* boost value */
for (i = 0; i < NR_CGROUP; i++) {
current_boost_value[i] = 0;
for (j = 0; j < EAS_MAX_KIR; j++)
boost_value[i][j] = 0;
prefer_idle[i] = 0;
}
#endif
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
/* uclamp */
for (i = 0; i < NR_CGROUP; i++) {
//cur_uclamp_min[i] = 0;
//debug_uclamp_min[i] = -1;
for (j = 0; j < EAS_UCLAMP_MAX_KIR; j++)
uclamp_min[i][j] = 0;
}
#endif
perf_sched_stune_task_thresh = -1;
debug_fix_boost = 0;
#endif
last_cpu_prefer_pid = (pid_t)0;
last_cpu_perfer_type = 0;
out:
#endif
mutex_init(&boost_eas);
return 0;
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,17 @@
#
# Copyright (C) 2018 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
ccflags-y += \
-I$(srctree)/kernel/
obj-y += topo_ctrl.o
@@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_CPU_TOPO_PLATFORM_H__
#define __MT_CPU_TOPO_PLATFORM_H__
#ifdef __cplusplus
extern "C" {
#endif
/*==============================================================*/
/* Macros */
/*==============================================================*/
/* TODO: remove these workaround for k49 migration */
#define NO_SCHEDULE_API (1)
#define TOTAL_CORE_NUM (CORE_NUM_L)
#define CORE_NUM_L (4)
#define get_cluster_cpu_core(id) \
(id ? 0 : CORE_NUM_L)
/*==============================================================*/
/* Enum */
/*==============================================================*/
enum ppm_cluster {
PPM_CLUSTER_L = 0,
NR_PPM_CLUSTERS,
};
/*==============================================================*/
/* Data Structures */
/*==============================================================*/
/*==============================================================*/
/* Global Variables */
/*==============================================================*/
/*==============================================================*/
/* APIs */
/*==============================================================*/
#ifdef __cplusplus
}
#endif
#endif
@@ -0,0 +1,55 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_CPU_TOPO_PLATFORM_H__
#define __MT_CPU_TOPO_PLATFORM_H__
#ifdef __cplusplus
extern "C" {
#endif
/*==============================================================*/
/* Macros */
/*==============================================================*/
/* TODO: remove these workaround for k49 migration */
#define NO_SCHEDULE_API (1)
#define TOTAL_CORE_NUM (CORE_NUM_L+CORE_NUM_B)
#define CORE_NUM_L (6)
#define CORE_NUM_B (2)
#define get_cluster_cpu_core(id) \
(id ? CORE_NUM_B : CORE_NUM_L)
/*==============================================================*/
/* Enum */
/*==============================================================*/
enum ppm_cluster {
PPM_CLUSTER_L = 0,
PPM_CLUSTER_B,
NR_PPM_CLUSTERS,
};
/*==============================================================*/
/* Data Structures */
/*==============================================================*/
/*==============================================================*/
/* Global Variables */
/*==============================================================*/
/*==============================================================*/
/* APIs */
/*==============================================================*/
#ifdef __cplusplus
}
#endif
#endif
@@ -0,0 +1,54 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_CPU_TOPO_PLATFORM_H__
#define __MT_CPU_TOPO_PLATFORM_H__
#ifdef __cplusplus
extern "C" {
#endif
/*==============================================================*/
/* Macros */
/*==============================================================*/
/* TODO: remove these workaround for k49 migration */
#define NO_SCHEDULE_API (1)
#define TOTAL_CORE_NUM (CORE_NUM_L+CORE_NUM_B)
#define CORE_NUM_L (6)
#define CORE_NUM_B (2)
#define get_cluster_cpu_core(id) \
(id ? CORE_NUM_B : CORE_NUM_L)
/*==============================================================*/
/* Enum */
/*==============================================================*/
enum ppm_cluster {
PPM_CLUSTER_L = 0,
PPM_CLUSTER_B,
NR_PPM_CLUSTERS,
};
/*==============================================================*/
/* Data Structures */
/*==============================================================*/
/*==============================================================*/
/* Global Variables */
/*==============================================================*/
/*==============================================================*/
/* APIs */
/*==============================================================*/
#ifdef __cplusplus
}
#endif
#endif
@@ -0,0 +1,56 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_CPU_TOPO_PLATFORM_H__
#define __MT_CPU_TOPO_PLATFORM_H__
#ifdef __cplusplus
extern "C" {
#endif
/*==============================================================*/
/* Macros */
/*==============================================================*/
/* TODO: remove these workaround for k49 migration */
#define NO_SCHEDULE_API (1)
#define TOTAL_CORE_NUM (CORE_NUM_L+CORE_NUM_B)
#define CORE_NUM_L (6)
#define CORE_NUM_B (2)
#define get_cluster_cpu_core(id) \
(id ? CORE_NUM_B : CORE_NUM_L)
/*==============================================================*/
/* Enum */
/*==============================================================*/
enum ppm_cluster {
PPM_CLUSTER_L = 0,
PPM_CLUSTER_B,
NR_PPM_CLUSTERS,
};
/*==============================================================*/
/* Data Structures */
/*==============================================================*/
/*==============================================================*/
/* Global Variables */
/*==============================================================*/
/*==============================================================*/
/* APIs */
/*==============================================================*/
#ifdef __cplusplus
}
#endif
#endif
@@ -0,0 +1,55 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_CPU_TOPO_PLATFORM_H__
#define __MT_CPU_TOPO_PLATFORM_H__
#ifdef __cplusplus
extern "C" {
#endif
/*==============================================================*/
/* Macros */
/*==============================================================*/
/* TODO: remove these workaround for k49 migration */
#define NO_SCHEDULE_API (1)
#define TOTAL_CORE_NUM (CORE_NUM_L+CORE_NUM_B)
#define CORE_NUM_L (4)
#define CORE_NUM_B (4)
#define get_cluster_cpu_core(id) \
(id ? CORE_NUM_B : CORE_NUM_L)
/*==============================================================*/
/* Enum */
/*==============================================================*/
enum ppm_cluster {
PPM_CLUSTER_L = 0,
PPM_CLUSTER_B,
NR_PPM_CLUSTERS,
};
/*==============================================================*/
/* Data Structures */
/*==============================================================*/
/*==============================================================*/
/* Global Variables */
/*==============================================================*/
/*==============================================================*/
/* APIs */
/*==============================================================*/
#ifdef __cplusplus
}
#endif
#endif
@@ -0,0 +1,88 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_CPU_TOPO_PLATFORM_H__
#define __MT_CPU_TOPO_PLATFORM_H__
#ifdef __cplusplus
extern "C" {
#endif
/*==============================================================*/
/* Macros */
/*==============================================================*/
/* TODO: remove these workaround for k49 migration */
#define NO_SCHEDULE_API (1)
#if defined(CONFIG_MTK_SCHED_MULTI_GEARS)
#define TOTAL_CORE_NUM (CORE_NUM_L+CORE_NUM_B+CORE_NUM_BB)
#define CORE_NUM_L (4)
#define CORE_NUM_B (3)
#define CORE_NUM_BB (1)
static inline unsigned int get_cluster_cpu_core(unsigned int id)
{
if (id == 0)
return CORE_NUM_L;
else if (id == 1)
return CORE_NUM_B;
else if (id == 2)
return CORE_NUM_BB;
return 0;
}
/*==============================================================*/
/* Enum */
/*==============================================================*/
enum ppm_cluster {
PPM_CLUSTER_L = 0,
PPM_CLUSTER_B,
PPM_CLUSTER_BB,
NR_PPM_CLUSTERS,
};
#else
#define TOTAL_CORE_NUM (CORE_NUM_L+CORE_NUM_B)
#define CORE_NUM_L (4)
#define CORE_NUM_B (4)
#define get_cluster_cpu_core(id) \
(id ? CORE_NUM_B : CORE_NUM_L)
/*==============================================================*/
/* Enum */
/*==============================================================*/
enum ppm_cluster {
PPM_CLUSTER_L = 0,
PPM_CLUSTER_B,
NR_PPM_CLUSTERS,
};
#endif /* CONFIG_MTK_SCHED_MULTI_GEARS */
/*==============================================================*/
/* Data Structures */
/*==============================================================*/
/*==============================================================*/
/* Global Variables */
/*==============================================================*/
/*==============================================================*/
/* APIs */
/*==============================================================*/
#ifdef __cplusplus
}
#endif
#endif
@@ -0,0 +1,256 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#define pr_fmt(fmt) "[topo_ctrl]"fmt
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/topology.h>
#include <sched/sched.h>
#include "topo_ctrl.h"
#include "mtk_perfmgr_internal.h"
/* data type */
struct topo_plat_cluster_info {
unsigned int core_num;
unsigned int cpu_id; /* cpu id of the dvfs policy owner */
struct cpumask cpus;
};
/* global variable */
int topo_cluster_num;
static int *calc_cpu_cap, *calc_cpu_num;
static int s_clstr_core, b_clstr_core;
static struct topo_plat_cluster_info *topo_cluster_info;
int topo_ctrl_get_nr_clusters(void)
{
return topo_cluster_num;
}
EXPORT_SYMBOL(topo_ctrl_get_nr_clusters);
int topo_ctrl_get_cluster_cpu_id(int id)
{
if (id < 0 || id >= topo_cluster_num)
return -1;
return topo_cluster_info[id].cpu_id;
}
EXPORT_SYMBOL(topo_ctrl_get_cluster_cpu_id);
/***************************************/
static void topo_platform_init(void)
{
int i, j, bit = 0, cpu, clus_id;
/* get cluster num */
topo_cluster_num = arch_nr_clusters();
if (topo_cluster_num <= 0)
return;
topo_cluster_info = kcalloc(topo_cluster_num,
sizeof(struct topo_plat_cluster_info), GFP_KERNEL);
if (!topo_cluster_info) {
topo_cluster_num = 0;
return;
}
/* init value */
for (i = 0; i < topo_cluster_num; i++)
topo_cluster_info[i].core_num = 0;
/* calculate cpu number */
for_each_possible_cpu(cpu) {
clus_id = arch_cpu_cluster_id(cpu);
if (clus_id < topo_cluster_num && clus_id >= 0)
topo_cluster_info[clus_id].core_num += 1;
}
for (i = 0; i < topo_cluster_num; i++) {
if (i > 0)
topo_cluster_info[i].cpu_id =
topo_cluster_info[i-1].cpu_id +
topo_cluster_info[i-1].core_num;
else
topo_cluster_info[i].cpu_id = 0;
cpumask_clear(&topo_cluster_info[i].cpus);
for (j = 0; j < topo_cluster_info[i].core_num; j++) {
cpumask_set_cpu(bit, &topo_cluster_info[i].cpus);
bit++;
}
}
}
static void calc_min_cpucap(void)
{
int i, cpu_num = 0, min = INT_MAX, max = 0;
int cpu;
struct cpumask cpus;
struct cpumask cpu_online_cpumask;
unsigned long cap_orig;
for (i = 0; i < topo_cluster_num ; i++) {
memcpy(&cpus, &topo_cluster_info[i].cpus,
sizeof(struct cpumask));
cpumask_and(&cpu_online_cpumask,
&cpus, cpu_possible_mask);
calc_cpu_num[i] = cpumask_weight(&cpu_online_cpumask);
for_each_possible_cpu(cpu) {
if (arch_cpu_cluster_id(cpu) == i) {
cap_orig = capacity_orig_of(cpu);
break;
}
}
calc_cpu_cap[i] = (int)cap_orig;
if (calc_cpu_cap[i] < min) {
s_clstr_core = i;
min = calc_cpu_cap[i];
}
if (calc_cpu_cap[i] > max) {
b_clstr_core = i;
max = calc_cpu_cap[i];
}
cpu_num += calc_cpu_num[i];
}
}
int get_min_clstr_cap(void)
{
/*get smallest cluster num*/
return s_clstr_core;
}
int get_max_clstr_cap(void)
{
/*get biggest cluster num*/
return b_clstr_core;
}
static int perfmgr_glb_info_proc_show(struct seq_file *m, void *v)
{
int i;
seq_printf(m, "perfmgr_clusters : %d\n", topo_cluster_num);
for (i = 0 ; i < topo_cluster_num ; i++) {
seq_printf(m, "calc_cpu_cap[%d]:%d\n", i, calc_cpu_cap[i]);
seq_printf(m, "calc_cpu_num[%d]:%d\n", i, calc_cpu_num[i]);
}
seq_printf(m, "s_clstr_core : %d\n", s_clstr_core);
seq_printf(m, "b_clstr_core : %d\n", b_clstr_core);
return 0;
}
static int perfmgr_topo_ctrl_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", topo_cluster_num);
return 0;
}
static int perfmgr_is_big_little_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", (topo_cluster_num) > 1 ? 1 : 0);
return 0;
}
static int perfmgr_nr_clusters_proc_show(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", topo_cluster_num);
return 0;
}
static int perfmgr_cpus_per_cluster_proc_show(struct seq_file *m, void *v)
{
int i;
for (i = 0; i < topo_cluster_num; i++)
seq_printf(m, "cluster%d: %0lx\n", i,
*cpumask_bits(&topo_cluster_info[i].cpus));
return 0;
}
PROC_FOPS_RO(topo_ctrl);
PROC_FOPS_RO(glb_info);
PROC_FOPS_RO(is_big_little);
PROC_FOPS_RO(nr_clusters);
PROC_FOPS_RO(cpus_per_cluster);
/************************************************/
int topo_ctrl_init(struct proc_dir_entry *parent)
{
struct proc_dir_entry *topo_dir = NULL;
int ret = 0;
size_t i;
struct pentry {
const char *name;
const struct file_operations *fops;
};
const struct pentry entries[] = {
PROC_ENTRY(topo_ctrl),
PROC_ENTRY(glb_info),
PROC_ENTRY(is_big_little),
PROC_ENTRY(nr_clusters),
PROC_ENTRY(cpus_per_cluster),
};
topo_dir = proc_mkdir("topo_ctrl", parent);
if (!topo_dir)
pr_debug("topo_dir null\n ");
/* create procfs */
for (i = 0; i < ARRAY_SIZE(entries); i++) {
if (!proc_create(entries[i].name, 0644,
topo_dir, entries[i].fops)) {
pr_debug("%s(), create /topo_ctrl%s failed\n",
__func__, entries[i].name);
ret = -EINVAL;
goto out;
}
}
topo_cluster_num = 0;
topo_cluster_info = NULL;
topo_platform_init();
if (topo_cluster_num > 0) {
calc_cpu_cap = kcalloc(topo_cluster_num,
sizeof(int), GFP_KERNEL);
calc_cpu_num = kcalloc(topo_cluster_num,
sizeof(int), GFP_KERNEL);
if (!calc_cpu_cap || !calc_cpu_num)
goto out;
} else {
calc_cpu_cap = NULL;
calc_cpu_num = NULL;
}
calc_min_cpucap();
out:
return ret;
}
void topo_ctrl_exit(void)
{
kfree(topo_cluster_info);
kfree(calc_cpu_cap);
kfree(calc_cpu_num);
}
@@ -0,0 +1,47 @@
#
# Copyright (C) 2018 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
MTK_TOP = $(srctree)/drivers/misc/mediatek/
EARA_THRM_TOP = $(srctree)/drivers/misc/mediatek/performance/eara_thermal
FPSGO_TOP = $(srctree)/drivers/misc/mediatek/performance/fpsgo_v3/
obj-y += platform/$(MTK_PLATFORM)/thermal_budget_platform.o
obj-y += thermal_budget.o
obj-y += thermal_base.o
ccflags-y += -I$(MTK_TOP)/thermal/common/inc/
ccflags-y += -I$(MTK_TOP)/thermal/$(MTK_PLATFORM)/inc/
ccflags-y += -I$(MTK_TOP)/base/power/$(MTK_PLATFORM)/
ccflags-y += -I$(MTK_TOP)/base/power/include/
ccflags-y += -I$(MTK_TOP)/base/power/ppm_v3/src/mach/$(MTK_PLATFORM)/
ccflags-y += -I$(MTK_TOP)/base/power/ppm_v3/inc/
ccflags-y += -I$(srctree)/kernel/
ccflags-y += -I$(srctree)/drivers/gpu/mediatek/gpufreq/include/
ccflags-y += -I$(FPSGO_TOP)/
ccflags-y += -I$(EARA_THRM_TOP)/platform/$(MTK_PLATFORM)/
ifeq ($(CONFIG_MTK_APUSYS_SUPPORT),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/apusys/power/2.0/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/apusys/power/2.0/
else
ccflags-y += -I$(MTK_TOP)/vpu/$(MTK_PLATFORM)/
ccflags-y += -I$(MTK_TOP)/mdla/1.0/
endif
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(MTK_TOP)/include/mt-plat/$(MTK_PLATFORM)/include/mach/
@@ -0,0 +1,105 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include "mtk_gpufreq.h"
#include "thermal_internal.h"
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio)
{
/* should be locked unless init */
struct mt_gpufreq_power_table_info *tbl = NULL;
int opp_num = *input_opp_num;
if (!(*gpu_tbl)) {
/*
* Bind @thr_gpu_tbl, @g_opp_ratio and @g_gpu_opp_num together.
* JUST check one of them to know if initialized or not.
*/
opp_num = mt_gpufreq_get_dvfs_table_num();
if (!opp_num) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*in_max_opp_idx = mt_gpufreq_get_seg_max_opp_index();
if (*in_max_opp_idx + opp_num
!= mt_gpufreq_get_real_dvfs_table_num()) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*gpu_tbl = kcalloc(opp_num,
sizeof(struct mt_gpufreq_power_table_info),
GFP_KERNEL);
*opp_ratio = kcalloc(opp_num,
sizeof(struct thrm_pb_ratio), GFP_KERNEL);
if (!(*gpu_tbl) || !(*opp_ratio)) {
kfree(*gpu_tbl);
*gpu_tbl = NULL;
kfree(*opp_ratio);
*opp_ratio = NULL;
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*input_opp_num = opp_num;
}
tbl = pass_gpu_table_to_eara();
if (!tbl)
return;
memcpy((*gpu_tbl), &tbl[*in_max_opp_idx],
opp_num * sizeof(*tbl));
}
int eara_thrm_get_vpu_core_num(void)
{
return 0;
}
int eara_thrm_get_mdla_core_num(void)
{
return 0;
}
int eara_thrm_vpu_opp_to_freq(int opp)
{
return 100;
}
int eara_thrm_mdla_opp_to_freq(int opp)
{
return 100;
}
int eara_thrm_apu_ready(void)
{
return 1;
}
int eara_thrm_vpu_onoff(void)
{
return 0;
}
int eara_thrm_mdla_onoff(void)
{
return 0;
}
int eara_thrm_keep_little_core(void)
{
return 1;
}
@@ -0,0 +1,115 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include "mtk_gpufreq.h"
#include "thermal_budget_platform.h"
#include "thermal_budget.h"
#if defined(CONFIG_MTK_VPU_SUPPORT)
#include "vpu_dvfs.h"
#endif
#if defined(CONFIG_MTK_MDLA_SUPPORT)
#include "mdla_dvfs.h"
#endif
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio)
{
/* should be locked unless init */
struct mt_gpufreq_power_table_info *tbl = NULL;
int opp_num = *input_opp_num;
if (!(*gpu_tbl)) {
/*
* Bind @thr_gpu_tbl, @g_opp_ratio and @g_gpu_opp_num together.
* JUST check one of them to know if initialized or not.
*/
opp_num = mt_gpufreq_get_dvfs_table_num();
if (!opp_num) {
*input_opp_num = 0;
return;
}
*gpu_tbl = kcalloc(opp_num,
sizeof(struct mt_gpufreq_power_table_info),
GFP_KERNEL);
*opp_ratio = kcalloc(opp_num,
sizeof(struct thrm_pb_ratio), GFP_KERNEL);
if (!(*gpu_tbl) || !(*opp_ratio)) {
kfree(*gpu_tbl);
*gpu_tbl = NULL;
kfree(*opp_ratio);
*opp_ratio = NULL;
*input_opp_num = 0;
return;
}
*input_opp_num = opp_num;
}
tbl = pass_gpu_table_to_eara();
if (!tbl)
return;
memcpy((*gpu_tbl), tbl, opp_num * sizeof(*tbl));
}
int eara_thrm_get_vpu_core_num(void)
{
#if defined(CONFIG_MTK_VPU_SUPPORT)
return 2;
#else
return 0;
#endif
}
int eara_thrm_get_mdla_core_num(void)
{
#ifdef CONFIG_MTK_MDLA_SUPPORT
return 1;
#else
return 0;
#endif
}
int eara_thrm_vpu_opp_to_freq(int opp)
{
#if defined(CONFIG_MTK_VPU_SUPPORT)
return get_vpu_opp_to_freq(opp);
#else
return 100;
#endif
}
int eara_thrm_mdla_opp_to_freq(int opp)
{
#ifdef CONFIG_MTK_MDLA_SUPPORT
return get_mdla_opp_to_freq(opp);
#else
return 100;
#endif
}
int eara_thrm_apu_ready(void)
{
return 1;
}
int eara_thrm_vpu_onoff(void)
{
return 0;
}
int eara_thrm_mdla_onoff(void)
{
return 0;
}
@@ -0,0 +1,16 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef EARA_THRM_PB_PLAT_H
#define EARA_THRM_PB_PLAT_H
#define CPU_OPP_NUM 16
#define KEEP_L_CORE 1
#define CLUSTER_B 1
#define CLUSTER_L 0
#define CPU_CORE_NUM 8
#endif
@@ -0,0 +1,105 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include "mtk_gpufreq.h"
#include "thermal_internal.h"
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio)
{
/* should be locked unless init */
struct mt_gpufreq_power_table_info *tbl = NULL;
int opp_num = *input_opp_num;
if (!(*gpu_tbl)) {
/*
* Bind @thr_gpu_tbl, @g_opp_ratio and @g_gpu_opp_num together.
* JUST check one of them to know if initialized or not.
*/
opp_num = mt_gpufreq_get_dvfs_table_num();
if (!opp_num) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*in_max_opp_idx = mt_gpufreq_get_seg_max_opp_index();
if (*in_max_opp_idx + opp_num
!= mt_gpufreq_get_real_dvfs_table_num()) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*gpu_tbl = kcalloc(opp_num,
sizeof(struct mt_gpufreq_power_table_info),
GFP_KERNEL);
*opp_ratio = kcalloc(opp_num,
sizeof(struct thrm_pb_ratio), GFP_KERNEL);
if (!(*gpu_tbl) || !(*opp_ratio)) {
kfree(*gpu_tbl);
*gpu_tbl = NULL;
kfree(*opp_ratio);
*opp_ratio = NULL;
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*input_opp_num = opp_num;
}
tbl = pass_gpu_table_to_eara();
if (!tbl)
return;
memcpy((*gpu_tbl), &tbl[*in_max_opp_idx], opp_num * sizeof(*tbl));
}
int eara_thrm_get_vpu_core_num(void)
{
return 0;
}
int eara_thrm_get_mdla_core_num(void)
{
return 0;
}
int eara_thrm_vpu_opp_to_freq(int opp)
{
return 100;
}
int eara_thrm_mdla_opp_to_freq(int opp)
{
return 100;
}
int eara_thrm_apu_ready(void)
{
return 0;
}
int eara_thrm_vpu_onoff(void)
{
return 0;
}
int eara_thrm_mdla_onoff(void)
{
return 0;
}
int eara_thrm_keep_little_core(void)
{
return 1;
}
@@ -0,0 +1,117 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include "mtk_gpufreq.h"
#include "thermal_internal.h"
#if defined(CONFIG_MTK_VPU_SUPPORT)
#include "vpu_dvfs.h"
#endif
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio)
{
/* should be locked unless init */
struct mt_gpufreq_power_table_info *tbl = NULL;
int opp_num = *input_opp_num;
if (!(*gpu_tbl)) {
/*
* Bind @thr_gpu_tbl, @g_opp_ratio and @g_gpu_opp_num together.
* JUST check one of them to know if initialized or not.
*/
opp_num = mt_gpufreq_get_dvfs_table_num();
if (!opp_num) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*in_max_opp_idx = mt_gpufreq_get_seg_max_opp_index();
if (*in_max_opp_idx + opp_num
!= mt_gpufreq_get_real_dvfs_table_num()) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*gpu_tbl = kcalloc(opp_num,
sizeof(struct mt_gpufreq_power_table_info),
GFP_KERNEL);
*opp_ratio = kcalloc(opp_num,
sizeof(struct thrm_pb_ratio), GFP_KERNEL);
if (!(*gpu_tbl) || !(*opp_ratio)) {
kfree(*gpu_tbl);
*gpu_tbl = NULL;
kfree(*opp_ratio);
*opp_ratio = NULL;
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*input_opp_num = opp_num;
}
tbl = pass_gpu_table_to_eara();
if (!tbl)
return;
memcpy((*gpu_tbl), &tbl[*in_max_opp_idx], opp_num * sizeof(*tbl));
}
int eara_thrm_get_vpu_core_num(void)
{
#ifdef CONFIG_MTK_VPU_SUPPORT
return 2;
#else
return 0;
#endif
}
int eara_thrm_get_mdla_core_num(void)
{
return 0;
}
int eara_thrm_vpu_opp_to_freq(int opp)
{
#if defined(CONFIG_MTK_VPU_SUPPORT)
return get_vpu_opp_to_freq(opp);
#else
return 100;
#endif
}
int eara_thrm_mdla_opp_to_freq(int opp)
{
return 100;
}
int eara_thrm_apu_ready(void)
{
return 1;
}
int eara_thrm_vpu_onoff(void)
{
return 0;
}
int eara_thrm_mdla_onoff(void)
{
return 0;
}
int eara_thrm_keep_little_core(void)
{
return 1;
}
@@ -0,0 +1,135 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include "mtk_gpufreq.h"
#include "thermal_internal.h"
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
#include <linux/platform_device.h>
#include "apusys_power.h"
#include "apu_power_table.h"
#endif
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio)
{
/* should be locked unless init */
struct mt_gpufreq_power_table_info *tbl = NULL;
int opp_num = *input_opp_num;
if (!(*gpu_tbl)) {
/*
* Bind @thr_gpu_tbl, @g_opp_ratio and @g_gpu_opp_num together.
* JUST check one of them to know if initialized or not.
*/
opp_num = mt_gpufreq_get_dvfs_table_num();
if (!opp_num) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*in_max_opp_idx = mt_gpufreq_get_seg_max_opp_index();
if (*in_max_opp_idx + opp_num
!= mt_gpufreq_get_real_dvfs_table_num()) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*gpu_tbl = kcalloc(opp_num,
sizeof(struct mt_gpufreq_power_table_info),
GFP_KERNEL);
*opp_ratio = kcalloc(opp_num,
sizeof(struct thrm_pb_ratio), GFP_KERNEL);
if (!(*gpu_tbl) || !(*opp_ratio)) {
kfree(*gpu_tbl);
*gpu_tbl = NULL;
kfree(*opp_ratio);
*opp_ratio = NULL;
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*input_opp_num = opp_num;
}
tbl = pass_gpu_table_to_eara();
if (!tbl)
return;
memcpy((*gpu_tbl), &tbl[*in_max_opp_idx], opp_num * sizeof(*tbl));
}
int eara_thrm_get_vpu_core_num(void)
{
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
return 2;
#else
return 0;
#endif
}
int eara_thrm_get_mdla_core_num(void)
{
return 0;
}
int eara_thrm_vpu_opp_to_freq(int opp)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!eara_thrm_apu_ready())
return 100;
return apusys_opp_to_freq(VPU0, opp);
#else
return 100;
#endif
}
int eara_thrm_mdla_opp_to_freq(int opp)
{
return 100;
}
int eara_thrm_apu_ready(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return 1;
#else
return 1;
#endif
}
int eara_thrm_vpu_onoff(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return apu_get_power_on_status(VPU0);
#else
return 0;
#endif
}
int eara_thrm_mdla_onoff(void)
{
return 0;
}
int eara_thrm_keep_little_core(void)
{
return 1;
}
@@ -0,0 +1,136 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include "mtk_gpufreq.h"
#include "thermal_internal.h"
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
#include <linux/platform_device.h>
#include "apusys_power.h"
#include "apu_power_table.h"
#endif
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio)
{
/* should be locked unless init */
struct mt_gpufreq_power_table_info *tbl = NULL;
int opp_num = *input_opp_num;
if (!(*gpu_tbl)) {
/*
* Bind @thr_gpu_tbl, @g_opp_ratio and @g_gpu_opp_num together.
* JUST check one of them to know if initialized or not.
*/
opp_num = mt_gpufreq_get_dvfs_table_num();
if (!opp_num) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*in_max_opp_idx = mt_gpufreq_get_seg_max_opp_index();
if (*in_max_opp_idx + opp_num
!= mt_gpufreq_get_real_dvfs_table_num()) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*gpu_tbl = kcalloc(opp_num,
sizeof(struct mt_gpufreq_power_table_info),
GFP_KERNEL);
*opp_ratio = kcalloc(opp_num,
sizeof(struct thrm_pb_ratio), GFP_KERNEL);
if (!(*gpu_tbl) || !(*opp_ratio)) {
kfree(*gpu_tbl);
*gpu_tbl = NULL;
kfree(*opp_ratio);
*opp_ratio = NULL;
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*input_opp_num = opp_num;
}
tbl = pass_gpu_table_to_eara();
if (!tbl)
return;
memcpy((*gpu_tbl), &tbl[*in_max_opp_idx], opp_num * sizeof(*tbl));
}
int eara_thrm_get_vpu_core_num(void)
{
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
return 2;
#else
return 0;
#endif
}
int eara_thrm_get_mdla_core_num(void)
{
return 0;
}
int eara_thrm_vpu_opp_to_freq(int opp)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!eara_thrm_apu_ready())
return 100;
return apusys_opp_to_freq(VPU0, opp);
#else
return 100;
#endif
}
int eara_thrm_mdla_opp_to_freq(int opp)
{
return 100;
}
int eara_thrm_apu_ready(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return 1;
#else
return 1;
#endif
}
int eara_thrm_vpu_onoff(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return apu_get_power_on_status(VPU0);
#else
return 0;
#endif
}
int eara_thrm_mdla_onoff(void)
{
return 0;
}
int eara_thrm_keep_little_core(void)
{
return 1;
}
@@ -0,0 +1,153 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include "mtk_gpufreq.h"
#include "thermal_internal.h"
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
#include <linux/platform_device.h>
#include "apusys_power.h"
#include "apu_power_table.h"
#endif
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio)
{
/* should be locked unless init */
struct mt_gpufreq_power_table_info *tbl = NULL;
int opp_num = *input_opp_num;
if (!(*gpu_tbl)) {
/*
* Bind @thr_gpu_tbl, @g_opp_ratio and @g_gpu_opp_num together.
* JUST check one of them to know if initialized or not.
*/
opp_num = mt_gpufreq_get_dvfs_table_num();
if (!opp_num) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*in_max_opp_idx = mt_gpufreq_get_seg_max_opp_index();
if (*in_max_opp_idx + opp_num
!= mt_gpufreq_get_real_dvfs_table_num()) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*gpu_tbl = kcalloc(opp_num,
sizeof(struct mt_gpufreq_power_table_info),
GFP_KERNEL);
*opp_ratio = kcalloc(opp_num,
sizeof(struct thrm_pb_ratio), GFP_KERNEL);
if (!(*gpu_tbl) || !(*opp_ratio)) {
kfree(*gpu_tbl);
*gpu_tbl = NULL;
kfree(*opp_ratio);
*opp_ratio = NULL;
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*input_opp_num = opp_num;
}
tbl = pass_gpu_table_to_eara();
if (!tbl)
return;
memcpy((*gpu_tbl), &tbl[*in_max_opp_idx], opp_num * sizeof(*tbl));
}
int eara_thrm_get_vpu_core_num(void)
{
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
return 2;
#else
return 0;
#endif
}
int eara_thrm_get_mdla_core_num(void)
{
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
return 1;
#else
return 0;
#endif
}
int eara_thrm_vpu_opp_to_freq(int opp)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!eara_thrm_apu_ready())
return 100;
return apusys_opp_to_freq(VPU0, opp);
#else
return 100;
#endif
}
int eara_thrm_mdla_opp_to_freq(int opp)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!eara_thrm_apu_ready())
return 100;
return apusys_opp_to_freq(MDLA0, opp);
#else
return 100;
#endif
}
int eara_thrm_apu_ready(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return 1;
#else
return 1;
#endif
}
int eara_thrm_vpu_onoff(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return apu_get_power_on_status(VPU0);
#else
return 0;
#endif
}
int eara_thrm_mdla_onoff(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return apu_get_power_on_status(MDLA0);
#else
return 0;
#endif
}
int eara_thrm_keep_little_core(void)
{
return 1;
}
@@ -0,0 +1,153 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include "mtk_gpufreq.h"
#include "thermal_internal.h"
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
#include <linux/platform_device.h>
#include "apusys_power.h"
#include "apu_power_table.h"
#endif
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio)
{
/* should be locked unless init */
struct mt_gpufreq_power_table_info *tbl = NULL;
int opp_num = *input_opp_num;
if (!(*gpu_tbl)) {
/*
* Bind @thr_gpu_tbl, @g_opp_ratio and @g_gpu_opp_num together.
* JUST check one of them to know if initialized or not.
*/
opp_num = mt_gpufreq_get_dvfs_table_num();
if (!opp_num) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*in_max_opp_idx = mt_gpufreq_get_seg_max_opp_index();
if (*in_max_opp_idx + opp_num
!= mt_gpufreq_get_real_dvfs_table_num()) {
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*gpu_tbl = kcalloc(opp_num,
sizeof(struct mt_gpufreq_power_table_info),
GFP_KERNEL);
*opp_ratio = kcalloc(opp_num,
sizeof(struct thrm_pb_ratio), GFP_KERNEL);
if (!(*gpu_tbl) || !(*opp_ratio)) {
kfree(*gpu_tbl);
*gpu_tbl = NULL;
kfree(*opp_ratio);
*opp_ratio = NULL;
*input_opp_num = 0;
*in_max_opp_idx = 0;
return;
}
*input_opp_num = opp_num;
}
tbl = pass_gpu_table_to_eara();
if (!tbl)
return;
memcpy((*gpu_tbl), &tbl[*in_max_opp_idx], opp_num * sizeof(*tbl));
}
int eara_thrm_get_vpu_core_num(void)
{
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
return 3;
#else
return 0;
#endif
}
int eara_thrm_get_mdla_core_num(void)
{
#if defined(CONFIG_MTK_APUSYS_SUPPORT)
return 2;
#else
return 0;
#endif
}
int eara_thrm_vpu_opp_to_freq(int opp)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!eara_thrm_apu_ready())
return 100;
return apusys_opp_to_freq(VPU0, opp);
#else
return 100;
#endif
}
int eara_thrm_mdla_opp_to_freq(int opp)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!eara_thrm_apu_ready())
return 100;
return apusys_opp_to_freq(MDLA0, opp);
#else
return 100;
#endif
}
int eara_thrm_apu_ready(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return 1;
#else
return 1;
#endif
}
int eara_thrm_vpu_onoff(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return apu_get_power_on_status(VPU0);
#else
return 0;
#endif
}
int eara_thrm_mdla_onoff(void)
{
#ifdef CONFIG_MTK_APUSYS_SUPPORT
if (!apusys_power_check())
return 0;
return apu_get_power_on_status(MDLA0);
#else
return 0;
#endif
}
int eara_thrm_keep_little_core(void)
{
return 1;
}
@@ -0,0 +1,96 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/trace_events.h>
#include <trace/events/fpsgo.h>
#include "thermal_base.h"
#define EARA_THRM_SYSFS_DIR_NAME "eara_thermal"
struct kobject *thrm_kobj;
static unsigned long __read_mostly mark_addr;
void eara_thrm_systrace(pid_t pid, int val, const char *fmt, ...)
{
char log[256];
va_list args;
int len;
if (pid <= 1)
return;
memset(log, ' ', sizeof(log));
va_start(args, fmt);
len = vsnprintf(log, sizeof(log), fmt, args);
va_end(args);
if (len == 256)
log[255] = '\0';
preempt_disable();
event_trace_printk(mark_addr, "C|%d|%s|%d\n", pid, log, val);
preempt_enable();
}
void eara_thrm_tracelog(const char *fmt, ...)
{
char log[256];
va_list args;
int len;
va_start(args, fmt);
len = vsnprintf(log, sizeof(log), fmt, args);
if (unlikely(len == 256))
log[255] = '\0';
va_end(args);
trace_eara_thrm_log(log);
}
void eara_thrm_sysfs_create_file(struct kobj_attribute *kobj_attr)
{
int ret;
if (kobj_attr == NULL || thrm_kobj == NULL)
return;
ret = sysfs_create_file(thrm_kobj, &(kobj_attr->attr));
if (ret)
pr_debug("Failed to create sysfs file\n");
}
void eara_thrm_sysfs_remove_file(struct kobj_attribute *kobj_attr)
{
if (kobj_attr == NULL || thrm_kobj == NULL)
return;
sysfs_remove_file(thrm_kobj, &(kobj_attr->attr));
}
int eara_thrm_base_init(void)
{
mark_addr = kallsyms_lookup_name("tracing_mark_write");
if (kernel_kobj == NULL)
return -1;
thrm_kobj = kobject_create_and_add(EARA_THRM_SYSFS_DIR_NAME,
kernel_kobj);
if (thrm_kobj == NULL)
return -1;
return 0;
}
void eara_thrm_base_exit(void)
{
if (thrm_kobj == NULL)
return;
kobject_put(thrm_kobj);
thrm_kobj = NULL;
}
@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#ifndef __EARA_THERMAL_BASE_H__
#define __EARA_THERMAL_BASE_H__
#include <linux/kobject.h>
#define EARA_SYSFS_MAX_BUFF_SIZE 1024
#define KOBJ_ATTR_RW(_name) \
struct kobj_attribute kobj_attr_##_name = \
__ATTR(_name, 0660, \
_name##_show, _name##_store)
#define KOBJ_ATTR_RO(_name) \
struct kobj_attribute kobj_attr_##_name = \
__ATTR(_name, 0440, \
_name##_show, NULL)
void eara_thrm_tracelog(const char *fmt, ...);
void eara_thrm_systrace(pid_t pid, int val, const char *fmt, ...);
void eara_thrm_sysfs_create_file(struct kobj_attribute *kobj_attr);
void eara_thrm_sysfs_remove_file(struct kobj_attribute *kobj_attr);
int eara_thrm_base_init(void);
void eara_thrm_base_exit(void);
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef EARA_THRM_PB_H
#define EARA_THRM_PB_H
extern struct ppm_cobra_data *ppm_cobra_pass_tbl(void);
extern void eara_pass_perf_first_hint(int enable);
extern struct mt_gpufreq_power_table_info *pass_gpu_table_to_eara(void);
extern unsigned int mt_gpufreq_get_dvfs_table_num(void);
extern void (*eara_thrm_gblock_bypass_fp)(int pid,
unsigned long long bufid, int bypass);
extern void (*eara_thrm_frame_start_fp)(int pid, unsigned long long bufID,
int cpu_time, int vpu_time, int mdla_time,
int cpu_cap, int vpu_cap, int mdla_cap,
int queuefps, unsigned long long q2q_time,
int AI_cross_vpu, int AI_cross_mdla, int AI_bg_vpu,
int AI_bg_mdla, ktime_t cur_time);
extern void (*eara_thrm_enqueue_end_fp)(int pid, unsigned long long bufID,
int gpu_time, int gpu_freq, unsigned long long enq);
/* platform */
struct thrm_pb_ratio {
int ratio;
int vpu_power;
int mdla_power;
};
void eara_thrm_update_gpu_info(int *input_opp_num, int *in_max_opp_idx,
struct mt_gpufreq_power_table_info **gpu_tbl,
struct thrm_pb_ratio **opp_ratio);
int eara_thrm_get_vpu_core_num(void);
int eara_thrm_get_mdla_core_num(void);
int eara_thrm_vpu_opp_to_freq(int opp);
int eara_thrm_mdla_opp_to_freq(int opp);
int eara_thrm_apu_ready(void);
int eara_thrm_vpu_onoff(void);
int eara_thrm_mdla_onoff(void);
#endif
@@ -0,0 +1,41 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
MTK_TOP = $(srctree)/drivers/misc/mediatek/
FPSGO_TOP = $(srctree)/drivers/misc/mediatek/performance/fpsgo_v3/
BASE_TOP = $(FPSGO_TOP)/base
FBT_TOP = $(FPSGO_TOP)/fbt
FSTB_TOP = $(FPSGO_TOP)/fstb
COM_TOP = $(FPSGO_TOP)/composer
VIDEOX_TOP += $(srctree)/drivers/misc/mediatek/video/$(MTK_PLATFORM)/videox
obj-y += fpsgo_main.o
obj-y += base/
obj-y += composer/
obj-y += fbt/
obj-y += fstb/
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(MTK_TOP)/dfrc/ \
-I$(BASE_TOP)/include/ \
-I$(FBT_TOP)/include/ \
-I$(FSTB_TOP)/ \
-I$(COM_TOP)/include/ \
-I$(EARA_JOB_TOP)/include/ \
-I$(VIDEOX_TOP)/ \
-I$(srctree)/drivers/gpu/drm/mediatek/ \
@@ -0,0 +1,32 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
MTK_TOP = $(srctree)/drivers/misc/mediatek/
FPSGO_TOP = $(MTK_TOP)/performance/fpsgo_v3/
BASE_TOP = $(FPSGO_TOP)/base/
COMP_TOP = $(FPSGO_TOP)/composer/
FBT_TOP = $(FPSGO_TOP)/fbt/
obj-y += \
src/fpsgo_base.o \
src/fpsgo_sysfs.o \
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(BASE_TOP)/include/ \
-I$(COMP_TOP)/include/ \
-I$(FBT_TOP)/include/ \
@@ -0,0 +1,225 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FPSGO_BASE_H__
#define __FPSGO_BASE_H__
#include <linux/compiler.h>
#include <linux/mutex.h>
#include <linux/rbtree.h>
#include <linux/hrtimer.h>
#include <linux/workqueue.h>
#define WINDOW 20
#define RESCUE_TIMER_NUM 2
/* EARA job type */
enum HW_EVENT4RENDER {
PER_FRAME = 0,
CRO_FRAME = 10,
BACKGROUND = 20
};
struct fbt_jerk {
int id;
int jerking;
int postpone;
struct hrtimer timer;
struct work_struct work;
};
struct fbt_proc {
int active_jerk_id;
struct fbt_jerk jerks[RESCUE_TIMER_NUM];
};
struct fbt_frame_info {
int target_fps;
int mips_diff;
long mips;
unsigned long long running_time;
int count;
};
struct fbt_thread_loading {
int pid;
unsigned long long buffer_id;
atomic_t loading;
atomic_t *loading_cl;
atomic_t last_cb_ts;
struct list_head entry;
};
struct fbt_thread_blc {
int pid;
unsigned long long buffer_id;
unsigned int blc;
int freerun;
struct list_head entry;
};
struct fbt_boost_info {
unsigned long long target_time;
unsigned int last_blc;
/* adjust loading */
int loading_weight;
int weight_cnt;
int hit_cnt;
int deb_cnt;
/* rescue*/
struct fbt_proc proc;
/* variance control */
struct fbt_frame_info frame_info[WINDOW];
unsigned int floor;
int floor_count;
int reset_floor_bound;
int f_iter;
};
struct render_info {
struct rb_node render_key_node;
struct list_head bufferid_list;
struct rb_node linger_node;
/*render basic info pid bufferId..etc*/
int pid;
unsigned long long render_key; /*pid,identifier*/
unsigned long long identifier;
unsigned long long buffer_id;
int queue_SF;
int tgid; /*render's process pid*/
int api; /*connected API*/
int frame_type;
/*render queue/dequeue/frame time info*/
unsigned long long t_enqueue_start;
unsigned long long t_enqueue_end;
unsigned long long t_dequeue_start;
unsigned long long t_dequeue_end;
unsigned long long enqueue_length;
unsigned long long dequeue_length;
unsigned long long Q2Q_time;
unsigned long long running_time;
/*fbt*/
int linger;
struct fbt_boost_info boost_info;
struct fbt_thread_loading *pLoading;
struct fbt_thread_blc *p_blc;
int is_listed;
struct fpsgo_loading *dep_arr;
int dep_valid_size;
unsigned long long dep_loading_ts;
unsigned long long linger_ts;
/*TODO: EARA mid list*/
unsigned long long mid;
struct mutex thr_mlock;
};
struct BQ_id {
unsigned long long key;
unsigned long long identifier;
unsigned long long buffer_id;
int queue_SF;
int pid;
int queue_pid;
struct rb_node entry;
};
struct fpsgo_loading {
int pid;
int loading;
int prefer_type;
};
struct gbe_runtime {
int pid;
unsigned long long runtime;
unsigned long long loading;
};
#ifdef FPSGO_DEBUG
#define FPSGO_LOGI(...) pr_debug("FPSGO:" __VA_ARGS__)
#else
#define FPSGO_LOGI(...)
#endif
#define FPSGO_LOGE(...) pr_debug("FPSGO:" __VA_ARGS__)
#define FPSGO_CONTAINER_OF(ptr, type, member) \
((type *)(((char *)ptr) - offsetof(type, member)))
void *fpsgo_alloc_atomic(int i32Size);
void fpsgo_free(void *pvBuf, int i32Size);
unsigned long long fpsgo_get_time(void);
int fpsgo_get_tgid(int pid);
void fpsgo_render_tree_lock(const char *tag);
void fpsgo_render_tree_unlock(const char *tag);
void fpsgo_thread_lock(struct mutex *mlock);
void fpsgo_thread_unlock(struct mutex *mlock);
void fpsgo_lockprove(const char *tag);
void fpsgo_thread_lockprove(const char *tag, struct mutex *mlock);
void fpsgo_delete_render_info(int pid,
unsigned long long buffer_id, unsigned long long identifier);
struct render_info *fpsgo_search_and_add_render_info(int pid,
unsigned long long identifier, int force);
int fpsgo_has_bypass(void);
void fpsgo_check_thread_status(void);
void fpsgo_clear(void);
struct BQ_id *fpsgo_find_BQ_id(int pid, int tgid, long long identifier,
int action);
int fpsgo_get_BQid_pair(int pid, int tgid, long long identifier,
unsigned long long *buffer_id, int *queue_SF, int enqueue);
void fpsgo_main_trace(const char *fmt, ...);
void fpsgo_clear_uclamp_boost(int check);
void fpsgo_clear_llf_cpu_policy(int orig_llf);
void fpsgo_del_linger(struct render_info *thr);
int init_fpsgo_common(void);
enum FPSGO_ERROR {
FPSGO_OK,
FPSGO_ERROR_FAIL,
FPSGO_ERROR_OOM,
FPSGO_ERROR_OUT_OF_FD,
FPSGO_ERROR_FAIL_WITH_LIMIT,
FPSGO_ERROR_TIMEOUT,
FPSGO_ERROR_CMD_NOT_PROCESSED,
FPSGO_ERROR_INVALID_PARAMS,
FPSGO_INTENTIONAL_BLOCK
};
enum FPSGO_FRAME_TYPE {
NON_VSYNC_ALIGNED_TYPE = 0,
BY_PASS_TYPE = 1,
};
enum FPSGO_CONNECT_API {
WINDOW_DISCONNECT = 0,
NATIVE_WINDOW_API_EGL = 1,
NATIVE_WINDOW_API_CPU = 2,
NATIVE_WINDOW_API_MEDIA = 3,
NATIVE_WINDOW_API_CAMERA = 4,
};
enum FPSGO_FORCE {
FPSGO_FORCE_OFF = 0,
FPSGO_FORCE_ON = 1,
FPSGO_FREE = 2,
};
enum FPSGO_BQID_ACT {
ACTION_FIND = 0,
ACTION_FIND_ADD,
ACTION_FIND_DEL,
ACTION_DEL_PID
};
#endif
@@ -0,0 +1,36 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#ifndef __GED_SYSFS_H__
#define __GED_SYSFS_H__
#include <linux/kobject.h>
//#include "fpsgo_type.h"
#define FPSGO_SYSFS_MAX_BUFF_SIZE 1024
#define KOBJ_ATTR_RW(_name) \
struct kobj_attribute kobj_attr_##_name = \
__ATTR(_name, 0660, \
_name##_show, _name##_store)
#define KOBJ_ATTR_RO(_name) \
struct kobj_attribute kobj_attr_##_name = \
__ATTR(_name, 0440, \
_name##_show, NULL)
int fpsgo_sysfs_create_dir(struct kobject *parent,
const char *name, struct kobject **ppsKobj);
void fpsgo_sysfs_remove_dir(struct kobject **ppsKobj);
void fpsgo_sysfs_create_file(struct kobject *parent,
struct kobj_attribute *kobj_attr);
void fpsgo_sysfs_remove_file(struct kobject *parent,
struct kobj_attribute *kobj_attr);
void fpsgo_sysfs_init(void);
void fpsgo_sysfs_exit(void);
extern struct kobject *kernel_kobj;
#endif
@@ -0,0 +1,39 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FPSGO_USEDEXT_H__
#define __FPSGO_USEDEXT_H__
extern void (*cpufreq_notifier_fp)(int cid, unsigned long freq);
extern void (*fpsgo_notify_qudeq_fp)(int qudeq, unsigned int startend,
int pid, unsigned long long identifier);
extern void (*fpsgo_notify_connect_fp)(int pid, int connectedAPI,
unsigned long long identifier);
extern void (*fpsgo_notify_bqid_fp)(int pid, unsigned long long bufID,
int queue_SF,
unsigned long long identifier, int create);
extern void (*fpsgo_notify_vsync_fp)(void);
extern void (*fpsgo_get_fps_fp)(int *pid, int *fps);
extern void (*fpsgo_notify_nn_job_begin_fp)(unsigned int tid,
unsigned long long mid);
extern void (*fpsgo_notify_nn_job_end_fp)(int pid, int tid,
unsigned long long mid, int num_step, __s32 *boost,
__s32 *device, __u64 *exec_time);
extern int (*fpsgo_get_nn_priority_fp)(unsigned int pid,
unsigned long long mid);
extern void (*fpsgo_get_nn_ttime_fp)(unsigned int pid,
unsigned long long mid, int num_step, __u64 *time);
extern void (*ged_vsync_notifier_fp)(void);
int fpsgo_is_force_enable(void);
void fpsgo_force_switch_enable(int enable);
int fpsgo_is_gpu_block_boost_enable(void);
int fpsgo_is_gpu_block_boost_perf_enable(void);
int fpsgo_is_gpu_block_boost_camera_enable(void);
void fpsgo_gpu_block_boost_enable_perf(int enable);
void fpsgo_gpu_block_boost_enable_camera(int enable);
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,85 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include "fpsgo_sysfs.h"
#include "fpsgo_base.h"
#define FPSGO_SYSFS_DIR_NAME "fpsgo"
static struct kobject *fpsgo_kobj;
int fpsgo_sysfs_create_dir(struct kobject *parent,
const char *name, struct kobject **ppsKobj)
{
struct kobject *psKobj = NULL;
if (name == NULL || ppsKobj == NULL) {
FPSGO_LOGE("Failed to create sysfs directory %p %p\n",
name, ppsKobj);
return -1;
}
parent = (parent != NULL) ? parent : fpsgo_kobj;
psKobj = kobject_create_and_add(name, parent);
if (!psKobj) {
FPSGO_LOGE("Failed to create '%s' sysfs directory\n",
name);
return -1;
}
*ppsKobj = psKobj;
return 0;
}
// --------------------------------------------------
void fpsgo_sysfs_remove_dir(struct kobject **ppsKobj)
{
if (ppsKobj == NULL)
return;
kobject_put(*ppsKobj);
*ppsKobj = NULL;
}
// --------------------------------------------------
void fpsgo_sysfs_create_file(struct kobject *parent,
struct kobj_attribute *kobj_attr)
{
if (kobj_attr == NULL) {
FPSGO_LOGE("Failed to create '%s' sysfs file kobj_attr=NULL\n");
return;
}
parent = (parent != NULL) ? parent : fpsgo_kobj;
if (sysfs_create_file(parent, &(kobj_attr->attr))) {
FPSGO_LOGE("Failed to create '%s' sysfs file\n",
(kobj_attr->attr).name);
return;
}
}
// --------------------------------------------------
void fpsgo_sysfs_remove_file(struct kobject *parent,
struct kobj_attribute *kobj_attr)
{
if (kobj_attr == NULL)
return;
parent = (parent != NULL) ? parent : fpsgo_kobj;
sysfs_remove_file(parent, &(kobj_attr->attr));
}
// --------------------------------------------------
void fpsgo_sysfs_init(void)
{
fpsgo_kobj = kobject_create_and_add(FPSGO_SYSFS_DIR_NAME,
kernel_kobj);
if (!fpsgo_kobj) {
FPSGO_LOGE("Failed to create '%s' sysfs root directory\n",
FPSGO_SYSFS_DIR_NAME);
}
}
// --------------------------------------------------
void fpsgo_sysfs_exit(void)
{
kobject_put(fpsgo_kobj);
fpsgo_kobj = NULL;
}
@@ -0,0 +1,33 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
MTK_TOP = $(srctree)/drivers/misc/mediatek/
FPSGO_TOP = $(srctree)/drivers/misc/mediatek/performance/fpsgo_v3/
BASE_TOP = $(FPSGO_TOP)/base
FBT_TOP = $(FPSGO_TOP)/fbt
FSTB_TOP = $(FPSGO_TOP)/fstb
COM_TOP = $(FPSGO_TOP)/composer
obj-y += src/fps_composer.o
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(BASE_TOP)/include/ \
-I$(COM_TOP)/include/ \
-I$(FBT_TOP)/include/ \
-I$(FSTB_TOP)/ \
@@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FPS_COMPOSER_H__
#define __FPS_COMPOSER_H__
#include <linux/rbtree.h>
enum FPSGO_COM_ERROR {
FPSGO_COM_IS_RENDER,
FPSGO_COM_TASK_NOT_EXIST,
FPSGO_COM_IS_SF,
};
struct connect_api_info {
struct rb_node rb_node;
struct list_head render_list;
int pid;
int tgid;
unsigned long long buffer_id;
unsigned long long buffer_key;
int api;
};
int fpsgo_composer_init(void);
void fpsgo_composer_exit(void);
void fpsgo_ctrl2comp_dequeue_end(int pid,
unsigned long long dequeue_end_time,
unsigned long long identifier);
void fpsgo_ctrl2comp_dequeue_start(int pid,
unsigned long long dequeue_start_time,
unsigned long long identifier);
void fpsgo_ctrl2comp_enqueue_end(int pid,
unsigned long long enqueue_end_time,
unsigned long long identifier);
void fpsgo_ctrl2comp_enqueue_start(int pid,
unsigned long long enqueue_start_time,
unsigned long long identifier);
void fpsgo_ctrl2comp_bqid(int pid, unsigned long long buffer_id,
int queue_SF, unsigned long long identifier,
int create);
void fpsgo_ctrl2comp_connect_api(int pid, int api,
unsigned long long identifier);
void fpsgo_ctrl2comp_disconnect_api(int pid, int api,
unsigned long long identifier);
void fpsgo_fstb2comp_check_connect_api(void);
#endif
@@ -0,0 +1,811 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/seq_file.h>
#include <linux/security.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/mutex.h>
#include <linux/sched/task.h>
#include <mt-plat/fpsgo_common.h>
#include "fpsgo_base.h"
#include "fpsgo_sysfs.h"
#include "fpsgo_usedext.h"
#include "fps_composer.h"
#include "fbt_cpu.h"
#include "fstb.h"
#include "xgf.h"
#include "mini_top.h"
/*#define FPSGO_COM_DEBUG*/
#ifdef FPSGO_COM_DEBUG
#define FPSGO_COM_TRACE(...) xgf_trace("fpsgo_com:" __VA_ARGS__)
#else
#define FPSGO_COM_TRACE(...)
#endif
#define COMP_TAG "FPSGO_COMP"
#define TIME_1MS 1000000
static struct kobject *comp_kobj;
static struct rb_root ui_pid_tree;
static struct rb_root connect_api_tree;
static inline int fpsgo_com_check_is_surfaceflinger(int pid)
{
struct task_struct *tsk;
int is_surfaceflinger = FPSGO_COM_IS_RENDER;
rcu_read_lock();
tsk = find_task_by_vpid(pid);
if (tsk)
get_task_struct(tsk);
rcu_read_unlock();
if (!tsk)
return FPSGO_COM_TASK_NOT_EXIST;
if (strstr(tsk->comm, "surfaceflinger"))
is_surfaceflinger = FPSGO_COM_IS_SF;
put_task_struct(tsk);
return is_surfaceflinger;
}
struct connect_api_info *fpsgo_com_search_and_add_connect_api_info(int pid,
unsigned long long buffer_id, int force)
{
struct rb_node **p = &connect_api_tree.rb_node;
struct rb_node *parent = NULL;
struct connect_api_info *tmp = NULL;
unsigned long long buffer_key;
int tgid;
fpsgo_lockprove(__func__);
tgid = fpsgo_get_tgid(pid);
buffer_key = (buffer_id & 0xFFFFFFFFFFFF)
| (((unsigned long long)tgid) << 48);
FPSGO_COM_TRACE("%s key:%llu tgid:%d buffer_id:%llu",
__func__, buffer_key, tgid, buffer_id);
while (*p) {
parent = *p;
tmp = rb_entry(parent, struct connect_api_info, rb_node);
if (buffer_key < tmp->buffer_key)
p = &(*p)->rb_left;
else if (buffer_key > tmp->buffer_key)
p = &(*p)->rb_right;
else
return tmp;
}
if (!force)
return NULL;
tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
if (!tmp)
return NULL;
INIT_LIST_HEAD(&(tmp->render_list));
tmp->pid = pid;
tmp->tgid = tgid;
tmp->buffer_id = buffer_id;
tmp->buffer_key = buffer_key;
rb_link_node(&tmp->rb_node, parent, p);
rb_insert_color(&tmp->rb_node, &connect_api_tree);
return tmp;
}
int fpsgo_com_check_frame_type(int api, int type)
{
int new_type = 0;
switch (api) {
case NATIVE_WINDOW_API_MEDIA:
new_type = BY_PASS_TYPE;
return new_type;
default:
break;
}
return type;
}
int fpsgo_com_update_render_api_info(struct render_info *f_render)
{
struct connect_api_info *connect_api;
int new_type;
fpsgo_lockprove(__func__);
fpsgo_thread_lockprove(__func__, &(f_render->thr_mlock));
connect_api =
fpsgo_com_search_and_add_connect_api_info(f_render->pid,
f_render->buffer_id, 0);
if (!connect_api) {
FPSGO_COM_TRACE("no pair connect api pid[%d] buffer_id[%llu]",
f_render->pid, f_render->buffer_id);
return 0;
}
f_render->api = connect_api->api;
list_add(&(f_render->bufferid_list), &(connect_api->render_list));
FPSGO_COM_TRACE("add connect api pid[%d] key[%llu] buffer_id[%llu]",
connect_api->pid, connect_api->buffer_key,
connect_api->buffer_id);
new_type = fpsgo_com_check_frame_type(f_render->api,
f_render->frame_type);
f_render->frame_type = new_type;
return 1;
}
static int fpsgo_com_refetch_buffer(struct render_info *f_render, int pid,
unsigned long long identifier, int enqueue)
{
int ret;
unsigned long long buffer_id = 0;
int queue_SF = 0;
if (!f_render)
return 0;
fpsgo_lockprove(__func__);
fpsgo_thread_lockprove(__func__, &(f_render->thr_mlock));
ret = fpsgo_get_BQid_pair(pid, f_render->tgid,
identifier, &buffer_id, &queue_SF, enqueue);
if (!ret || !buffer_id) {
FPSGO_LOGI("refetch %d: %llu, %d, %llu\n",
pid, buffer_id, queue_SF, identifier);
fpsgo_main_trace("COMP: refetch %d: %llu, %d, %llu\n",
pid, buffer_id, queue_SF, identifier);
return 0;
}
f_render->buffer_id = buffer_id;
f_render->queue_SF = queue_SF;
if (!f_render->pLoading || !f_render->p_blc)
fpsgo_base2fbt_node_init(f_render);
FPSGO_COM_TRACE("%s: refetch %d: %llu, %llu, %d\n", __func__,
pid, identifier, buffer_id, queue_SF);
return 1;
}
void fpsgo_ctrl2comp_enqueue_start(int pid,
unsigned long long enqueue_start_time,
unsigned long long identifier)
{
struct render_info *f_render;
int xgf_ret = 0;
int check_render;
int ret;
FPSGO_COM_TRACE("%s pid[%d] id %llu", __func__, pid, identifier);
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
fpsgo_render_tree_lock(__func__);
f_render = fpsgo_search_and_add_render_info(pid, identifier, 1);
if (!f_render) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: store frame info fail : %d !!!!\n",
__func__, pid);
return;
}
fpsgo_thread_lock(&f_render->thr_mlock);
/* @buffer_id and @queue_SF MUST be initialized
* with @api at the same time
*/
if (!f_render->api && identifier) {
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 1);
if (!ret) {
fpsgo_render_tree_unlock(__func__);
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
ret = fpsgo_com_update_render_api_info(f_render);
if (!ret) {
fpsgo_render_tree_unlock(__func__);
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
} else if (identifier) {
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 1);
if (!ret) {
fpsgo_render_tree_unlock(__func__);
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
}
fpsgo_render_tree_unlock(__func__);
if (f_render->api == NATIVE_WINDOW_API_CAMERA)
fpsgo_comp2fstb_camera_active(pid);
if (!f_render->queue_SF) {
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
switch (f_render->frame_type) {
case NON_VSYNC_ALIGNED_TYPE:
f_render->t_enqueue_start = enqueue_start_time;
FPSGO_COM_TRACE(
"pid[%d] type[%d] enqueue_s:%llu",
pid, f_render->frame_type,
enqueue_start_time);
FPSGO_COM_TRACE("update pid[%d] tgid[%d] buffer_id:%llu api:%d",
f_render->pid, f_render->tgid,
f_render->buffer_id, f_render->api);
xgf_ret =
fpsgo_comp2xgf_qudeq_notify(pid, f_render->buffer_id,
XGF_QUEUE_START, NULL, NULL,
enqueue_start_time);
break;
case BY_PASS_TYPE:
f_render->t_enqueue_start = enqueue_start_time;
fpsgo_comp2fbt_bypass_enq();
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "%d-frame_time", pid);
break;
default:
FPSGO_COM_TRACE("type not found pid[%d] type[%d]",
pid, f_render->frame_type);
break;
}
fpsgo_thread_unlock(&f_render->thr_mlock);
}
void fpsgo_ctrl2comp_enqueue_end(int pid,
unsigned long long enqueue_end_time,
unsigned long long identifier)
{
struct render_info *f_render;
int xgf_ret = 0;
int check_render;
unsigned long long running_time = 0;
unsigned long long mid = 0;
int ret;
FPSGO_COM_TRACE("%s pid[%d] id %llu", __func__, pid, identifier);
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
fpsgo_render_tree_lock(__func__);
f_render = fpsgo_search_and_add_render_info(pid, identifier, 0);
if (!f_render) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: NON pair frame info : %d !!!!\n",
__func__, pid);
return;
}
fpsgo_thread_lock(&f_render->thr_mlock);
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 0);
if (!ret) {
fpsgo_render_tree_unlock(__func__);
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
fpsgo_render_tree_unlock(__func__);
if (!f_render->queue_SF) {
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
switch (f_render->frame_type) {
case NON_VSYNC_ALIGNED_TYPE:
if (f_render->t_enqueue_end)
f_render->Q2Q_time =
enqueue_end_time - f_render->t_enqueue_end;
f_render->t_enqueue_end = enqueue_end_time;
f_render->enqueue_length =
enqueue_end_time - f_render->t_enqueue_start;
FPSGO_COM_TRACE(
"pid[%d] type[%d] enqueue_e:%llu enqueue_l:%llu",
pid, f_render->frame_type,
enqueue_end_time, f_render->enqueue_length);
xgf_ret =
fpsgo_comp2xgf_qudeq_notify(pid, f_render->buffer_id,
XGF_QUEUE_END, &running_time, &mid,
enqueue_end_time);
if (running_time != 0)
f_render->running_time = running_time;
f_render->mid = mid;
fpsgo_comp2fbt_frame_start(f_render,
enqueue_end_time);
fpsgo_comp2fstb_queue_time_update(pid,
f_render->buffer_id,
f_render->frame_type,
enqueue_end_time,
f_render->api);
fpsgo_comp2fstb_enq_end(f_render->pid,
f_render->buffer_id,
f_render->enqueue_length);
fpsgo_comp2minitop_queue_update(enqueue_end_time);
fpsgo_systrace_c_fbt_gm(-300, 0, f_render->enqueue_length,
"%d_%d-enqueue_length", pid, f_render->frame_type);
break;
case BY_PASS_TYPE:
break;
default:
FPSGO_COM_TRACE("type not found pid[%d] type[%d]",
pid, f_render->frame_type);
break;
}
fpsgo_thread_unlock(&f_render->thr_mlock);
}
void fpsgo_ctrl2comp_dequeue_start(int pid,
unsigned long long dequeue_start_time,
unsigned long long identifier)
{
struct render_info *f_render;
int xgf_ret = 0;
int check_render;
int ret;
FPSGO_COM_TRACE("%s pid[%d] id %llu", __func__, pid, identifier);
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
fpsgo_render_tree_lock(__func__);
f_render = fpsgo_search_and_add_render_info(pid, identifier, 0);
if (!f_render) {
struct BQ_id *pair;
pair = fpsgo_find_BQ_id(pid, 0, identifier, ACTION_FIND);
if (pair) {
FPSGO_COM_TRACE("%s: find pair enqueuer: %d, %d\n",
__func__, pid, pair->queue_pid);
pid = pair->queue_pid;
f_render = fpsgo_search_and_add_render_info(pid,
identifier, 0);
if (!f_render) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: NO pair enqueuer: %d\n",
__func__, pid);
return;
}
} else {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: NO pair enqueuer: %d\n",
__func__, pid);
return;
}
}
fpsgo_thread_lock(&f_render->thr_mlock);
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 0);
if (!ret) {
fpsgo_render_tree_unlock(__func__);
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
fpsgo_render_tree_unlock(__func__);
if (!f_render->queue_SF) {
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
switch (f_render->frame_type) {
case NON_VSYNC_ALIGNED_TYPE:
f_render->t_dequeue_start = dequeue_start_time;
FPSGO_COM_TRACE("pid[%d] type[%d] dequeue_s:%llu",
pid, f_render->frame_type, dequeue_start_time);
xgf_ret =
fpsgo_comp2xgf_qudeq_notify(pid, f_render->buffer_id,
XGF_DEQUEUE_START, NULL, NULL,
dequeue_start_time);
break;
case BY_PASS_TYPE:
break;
default:
FPSGO_COM_TRACE("type not found pid[%d] type[%d]",
pid, f_render->frame_type);
break;
}
fpsgo_thread_unlock(&f_render->thr_mlock);
}
void fpsgo_ctrl2comp_dequeue_end(int pid,
unsigned long long dequeue_end_time,
unsigned long long identifier)
{
struct render_info *f_render;
int xgf_ret = 0;
int check_render;
int ret;
FPSGO_COM_TRACE("%s pid[%d] id %llu", __func__, pid, identifier);
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
fpsgo_render_tree_lock(__func__);
f_render = fpsgo_search_and_add_render_info(pid, identifier, 0);
if (!f_render) {
struct BQ_id *pair;
pair = fpsgo_find_BQ_id(pid, 0, identifier, ACTION_FIND);
if (pair) {
pid = pair->queue_pid;
f_render = fpsgo_search_and_add_render_info(pid,
identifier, 0);
}
if (!f_render) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: NO pair enqueuer: %d\n",
__func__, pid);
return;
}
}
fpsgo_thread_lock(&f_render->thr_mlock);
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 0);
if (!ret) {
fpsgo_render_tree_unlock(__func__);
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
fpsgo_render_tree_unlock(__func__);
if (!f_render->queue_SF) {
fpsgo_thread_unlock(&f_render->thr_mlock);
return;
}
switch (f_render->frame_type) {
case NON_VSYNC_ALIGNED_TYPE:
f_render->t_dequeue_end = dequeue_end_time;
f_render->dequeue_length =
dequeue_end_time - f_render->t_dequeue_start;
FPSGO_COM_TRACE(
"pid[%d] type[%d] dequeue_e:%llu dequeue_l:%llu",
pid, f_render->frame_type,
dequeue_end_time, f_render->dequeue_length);
xgf_ret =
fpsgo_comp2xgf_qudeq_notify(pid, f_render->buffer_id,
XGF_DEQUEUE_END, NULL, NULL, dequeue_end_time);
fpsgo_comp2fbt_deq_end(f_render, dequeue_end_time);
fpsgo_systrace_c_fbt_gm(-300, 0, f_render->dequeue_length,
"%d_%d-dequeue_length", pid, f_render->frame_type);
break;
case BY_PASS_TYPE:
break;
default:
FPSGO_COM_TRACE("type not found pid[%d] type[%d]",
pid, f_render->frame_type);
break;
}
fpsgo_thread_unlock(&f_render->thr_mlock);
}
void fpsgo_ctrl2comp_connect_api(int pid, int api,
unsigned long long identifier)
{
struct connect_api_info *connect_api;
int check_render;
unsigned long long buffer_id = 0;
int queue_SF = 0;
int ret;
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
FPSGO_COM_TRACE("%s pid[%d], identifier:%llu",
__func__, pid, identifier);
fpsgo_render_tree_lock(__func__);
ret = fpsgo_get_BQid_pair(pid, 0, identifier, &buffer_id, &queue_SF, 0);
if (!ret || !buffer_id) {
FPSGO_LOGI("connect %d: %llu, %llu\n",
pid, buffer_id, identifier);
fpsgo_main_trace("COMP: connect %d: %llu, %llu\n",
pid, buffer_id, identifier);
fpsgo_render_tree_unlock(__func__);
return;
}
connect_api =
fpsgo_com_search_and_add_connect_api_info(pid, buffer_id, 1);
if (!connect_api) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: store frame info fail : %d !!!!\n",
__func__, pid);
return;
}
connect_api->api = api;
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_ctrl2comp_bqid(int pid, unsigned long long buffer_id,
int queue_SF, unsigned long long identifier, int create)
{
struct BQ_id *pair;
if (!identifier || !pid)
return;
if (!buffer_id && create)
return;
fpsgo_render_tree_lock(__func__);
FPSGO_LOGI("pid %d: bufid %llu, id %llu, queue_SF %d, create %d\n",
pid, buffer_id, identifier, queue_SF, create);
if (create) {
pair = fpsgo_find_BQ_id(pid, 0,
identifier, ACTION_FIND_ADD);
if (!pair) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: add fail : %d !!!!\n",
__func__, pid);
return;
}
if (pair->pid != pid)
FPSGO_LOGI("%d: diff render same key %d\n",
pid, pair->pid);
pair->buffer_id = buffer_id;
pair->queue_SF = queue_SF;
} else
fpsgo_find_BQ_id(pid, 0,
identifier, ACTION_FIND_DEL);
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_com_clear_connect_api_render_list(
struct connect_api_info *connect_api)
{
struct render_info *pos, *next;
fpsgo_lockprove(__func__);
list_for_each_entry_safe(pos, next,
&connect_api->render_list, bufferid_list) {
fpsgo_delete_render_info(pos->pid,
pos->buffer_id, pos->identifier);
}
}
void fpsgo_ctrl2comp_disconnect_api(
int pid, int api, unsigned long long identifier)
{
struct connect_api_info *connect_api;
int check_render;
unsigned long long buffer_id = 0;
int queue_SF = 0;
int ret;
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
FPSGO_COM_TRACE("%s pid[%d], identifier:%llu",
__func__, pid, identifier);
fpsgo_render_tree_lock(__func__);
ret = fpsgo_get_BQid_pair(pid, 0, identifier, &buffer_id, &queue_SF, 0);
if (!ret || !buffer_id) {
FPSGO_LOGI("disconnect %d: %llu, %llu\n",
pid, buffer_id, identifier);
fpsgo_main_trace("COMP: disconnect %d: %llu, %llu\n",
pid, buffer_id, identifier);
fpsgo_render_tree_unlock(__func__);
return;
}
connect_api =
fpsgo_com_search_and_add_connect_api_info(pid, buffer_id, 0);
if (!connect_api) {
FPSGO_COM_TRACE(
"%s: FPSGo composer distory connect api fail : %d !!!!\n",
__func__, pid);
fpsgo_render_tree_unlock(__func__);
return;
}
fpsgo_com_clear_connect_api_render_list(connect_api);
rb_erase(&connect_api->rb_node, &connect_api_tree);
kfree(connect_api);
fpsgo_comp2fbt_bypass_disconnect();
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_fstb2comp_check_connect_api(void)
{
struct rb_node *n;
struct connect_api_info *iter;
struct task_struct *tsk;
FPSGO_COM_TRACE("%s ", __func__);
fpsgo_render_tree_lock(__func__);
n = rb_first(&connect_api_tree);
while (n) {
iter = rb_entry(n, struct connect_api_info, rb_node);
rcu_read_lock();
tsk = find_task_by_vpid(iter->tgid);
rcu_read_unlock();
if (!tsk) {
fpsgo_com_clear_connect_api_render_list(iter);
rb_erase(&iter->rb_node, &connect_api_tree);
n = rb_first(&connect_api_tree);
kfree(iter);
} else
n = rb_next(n);
}
fpsgo_render_tree_unlock(__func__);
}
static ssize_t connect_api_info_show
(struct kobject *kobj,
struct kobj_attribute *attr,
char *buf)
{
struct rb_node *n;
struct connect_api_info *iter;
struct task_struct *tsk;
struct render_info *pos, *next;
char temp[FPSGO_SYSFS_MAX_BUFF_SIZE] = "";
int posi = 0;
int length;
length = scnprintf(temp + posi, FPSGO_SYSFS_MAX_BUFF_SIZE - posi,
"=================================\n");
posi += length;
fpsgo_render_tree_lock(__func__);
rcu_read_lock();
for (n = rb_first(&connect_api_tree); n != NULL; n = rb_next(n)) {
iter = rb_entry(n, struct connect_api_info, rb_node);
tsk = find_task_by_vpid(iter->tgid);
if (tsk) {
get_task_struct(tsk);
length = scnprintf(temp + posi,
FPSGO_SYSFS_MAX_BUFF_SIZE - posi,
"PID TGID NAME BufferID API Key\n");
posi += length;
length = scnprintf(temp + posi,
FPSGO_SYSFS_MAX_BUFF_SIZE - posi,
"%5d %5d %5s %4llu %5d %4llu\n",
iter->pid, iter->tgid, tsk->comm,
iter->buffer_id, iter->api, iter->buffer_key);
posi += length;
put_task_struct(tsk);
}
length = scnprintf(temp + posi,
FPSGO_SYSFS_MAX_BUFF_SIZE - posi,
"******render list******\n");
posi += length;
list_for_each_entry_safe(pos, next,
&iter->render_list, bufferid_list) {
fpsgo_thread_lock(&pos->thr_mlock);
length = scnprintf(temp + posi,
FPSGO_SYSFS_MAX_BUFF_SIZE - posi,
" PID TGID BufferID API TYPE\n");
posi += length;
length = scnprintf(temp + posi,
FPSGO_SYSFS_MAX_BUFF_SIZE - posi,
"%5d %5d %4llu %5d %5d\n",
pos->pid, pos->tgid, pos->buffer_id,
pos->api, pos->frame_type);
posi += length;
}
length = scnprintf(temp + posi,
FPSGO_SYSFS_MAX_BUFF_SIZE - posi,
"***********************\n");
posi += length;
length = scnprintf(temp + posi,
FPSGO_SYSFS_MAX_BUFF_SIZE - posi,
"=================================\n");
posi += length;
}
rcu_read_unlock();
fpsgo_render_tree_unlock(__func__);
return scnprintf(buf, PAGE_SIZE, "%s", temp);
}
static KOBJ_ATTR_RO(connect_api_info);
void __exit fpsgo_composer_exit(void)
{
fpsgo_sysfs_remove_file(comp_kobj, &kobj_attr_connect_api_info);
fpsgo_sysfs_remove_dir(&comp_kobj);
}
int __init fpsgo_composer_init(void)
{
ui_pid_tree = RB_ROOT;
connect_api_tree = RB_ROOT;
if (!fpsgo_sysfs_create_dir(NULL, "composer", &comp_kobj))
fpsgo_sysfs_create_file(comp_kobj, &kobj_attr_connect_api_info);
return 0;
}
@@ -0,0 +1,52 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
FPSGO_TOP = $(srctree)/drivers/misc/mediatek/performance/fpsgo_v3
FBT_TOP = $(FPSGO_TOP)/fbt
COMP_TOP = $(FPSGO_TOP)/composer
MTK_TOP = $(srctree)/drivers/misc/mediatek
BASE_TOP = $(FPSGO_TOP)/base
FSTB_TOP = $(FPSGO_TOP)/fstb
ccflags-y += -DNR_FREQ_CPU=16
ifeq ($(CONFIG_MACH_MT6781),y)
obj-y += platform/mt6781/fbt_cpu_platform.o
else ifeq ($(CONFIG_MACH_MT6877),y)
obj-y += platform/mt6877/fbt_cpu_platform.o
else ifeq ($(CONFIG_MACH_MT6893),y)
obj-y += platform/mt6893/fbt_cpu_platform.o
else
obj-y += platform/$(MTK_PLATFORM)/fbt_cpu_platform.o
endif
obj-y += \
src/fbt_cpu.o \
src/xgf.o \
src/mini_top.o
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(FPSGO_TOP)/base/include/ \
-I$(COMP_TOP)/include/ \
-I$(FBT_TOP)/include/ \
-I$(BASE_TOP)/include/ \
-I$(MTK_TOP)/base/power/include/ \
-I$(MTK_TOP)/base/power/$(MTK_PLATFORM)/ \
-I$(FSTB_TOP)/ \
-I$(MTK_TOP)/cm_mgr/ \
-I$(srctree)/kernel/
@@ -0,0 +1,87 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FBT_CPU_H__
#define __FBT_CPU_H__
#include "fpsgo_base.h"
extern int fpsgo_fbt2xgf_get_dep_list_num(int pid, unsigned long long bufID);
extern int fpsgo_fbt2xgf_get_dep_list(int pid, int count,
struct fpsgo_loading *arr, unsigned long long bufID);
#if defined(CONFIG_MTK_FPSGO) || defined(CONFIG_MTK_FPSGO_V3)
void fpsgo_ctrl2fbt_dfrc_fps(int fps_limit);
void fpsgo_ctrl2fbt_cpufreq_cb(int cid, unsigned long freq);
void fpsgo_ctrl2fbt_vsync(unsigned long long ts);
void fpsgo_comp2fbt_frame_start(struct render_info *thr,
unsigned long long ts);
void fpsgo_comp2fbt_deq_end(struct render_info *thr,
unsigned long long ts);
void fpsgo_base2fbt_node_init(struct render_info *obj);
void fpsgo_base2fbt_item_del(struct fbt_thread_loading *obj,
struct fbt_thread_blc *pblc,
struct fpsgo_loading *pdep,
struct render_info *thr);
int fpsgo_base2fbt_get_max_blc_pid(void);
unsigned long long fpsgo_base2fbt_get_max_blc_buffer_id(void);
void fpsgo_comp2fbt_bypass_enq(void);
void fpsgo_comp2fbt_bypass_disconnect(void);
void fpsgo_base2fbt_set_bypass(int has_bypass);
void fpsgo_base2fbt_check_max_blc(void);
void fpsgo_base2fbt_no_one_render(void);
void fpsgo_base2fbt_only_bypass(void);
void fpsgo_base2fbt_set_min_cap(struct render_info *thr, int min_cap,
int check);
void fpsgo_base2fbt_clear_llf_policy(struct render_info *thr,
int orig_policy);
void fpsgo_base2fbt_cancel_jerk(struct render_info *thr);
int __init fbt_cpu_init(void);
void __exit fbt_cpu_exit(void);
int fpsgo_ctrl2fbt_switch_fbt(int enable);
int fbt_switch_ceiling(int value);
#else
static inline void fpsgo_ctrl2fbt_dfrc_fps(int fps_limit) { }
static inline void fpsgo_ctrl2fbt_cpufreq_cb(int cid,
unsigned long freq) { }
static inline void fpsgo_ctrl2fbt_vsync(unsigned long long ts) { }
static inline void fpsgo_comp2fbt_frame_start(struct render_info *thr,
unsigned long long ts) { }
static inline void fpsgo_comp2fbt_deq_end(struct render_info *thr,
unsigned long long ts) { }
static inline int fbt_cpu_init(void) { return 0; }
static inline void fbt_cpu_exit(void) { }
static inline int fpsgo_ctrl2fbt_switch_fbt(int enable) { return 0; }
static inline void fpsgo_base2fbt_node_init(struct render_info *obj) { }
static inline void fpsgo_base2fbt_item_del(
struct fbt_thread_loading *obj, struct fbt_thread_blc *pblc,
struct fpsgo_loading *pdep,
struct render_info *thr) { }
static inline int fpsgo_base2fbt_get_max_blc_pid(void) { return 0; }
static inline unsigned long long fpsgo_base2fbt_get_max_blc_buffer_id(void)
{ return 0; }
static inline void fpsgo_comp2fbt_bypass_enq(void) { }
static inline void fpsgo_comp2fbt_bypass_disconnect(void) { }
static inline void fpsgo_base2fbt_set_bypass(int has_bypass) { }
static inline void fpsgo_base2fbt_check_max_blc(void) { }
static inline void fpsgo_base2fbt_no_one_render(void) { }
static inline void fpsgo_base2fbt_only_bypass(void) { }
static inline int fbt_switch_ceiling(int en) { return 0; }
static inline void fpsgo_base2fbt_set_min_cap(struct render_info *thr,
int min_cap, int check) { }
static inline void fpsgo_base2fbt_clear_llf_policy(struct render_info *thr,
int orig_policy) { }
static inline void fpsgo_base2fbt_cancel_jerk(struct render_info *thr) { }
#endif
#endif
@@ -0,0 +1,38 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FBT_CPU_PLATFORM_H__
#define __FBT_CPU_PLATFORM_H__
#include "fbt_cpu.h"
enum FPSGO_CPU_PREFER {
FPSGO_PREFER_NONE = 0,
FPSGO_PREFER_BIG = 1,
FPSGO_PREFER_LITTLE = 2,
FPSGO_PREFER_L_M = 3,
FPSGO_PREFER_TOTAL,
};
extern long sched_setaffinity(pid_t pid, const struct cpumask *in_mask);
extern int sched_set_cpuprefer(pid_t pid, unsigned int prefer_type);
extern int capacity_min_write_for_perf_idx(int idx, int capacity_min);
extern void cm_mgr_perf_set_status(int enable);
extern int set_task_util_min(pid_t pid, unsigned int util_min);
void fbt_set_boost_value(unsigned int base_blc);
void fbt_clear_boost_value(void);
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc);
int fbt_get_L_cluster_num(void);
int fbt_get_L_min_ceiling(void);
void fbt_notify_CM_limit(int reach_limit);
void fbt_reg_dram_request(int reg);
void fbt_boost_dram(int boost);
int fbt_get_default_boost_ta(void);
int fbt_get_default_adj_loading(void);
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type);
void fbt_set_affinity(pid_t pid, unsigned int prefer_type);
#endif
@@ -0,0 +1,25 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FBT_USEDEXT_H__
#define __FBT_USEDEXT_H__
extern int prefer_idle_for_perf_idx(int idx, int prefer_idle);
extern unsigned int mt_ppm_userlimit_freq_limit_by_others(
unsigned int cluster);
extern unsigned long get_cpu_orig_capacity(unsigned int cpu);
extern int upower_get_turn_point(void);
extern void set_capacity_margin(unsigned int margin);
extern unsigned int get_capacity_margin(void);
extern int fpsgo_fbt2minitop_start(int count, struct fpsgo_loading *fl);
extern int fpsgo_fbt2minitop_query(int count, struct fpsgo_loading *fl);
extern int fpsgo_fbt2minitop_end(void);
extern int fpsgo_fbt2minitop_query_single(pid_t pid);
extern struct workqueue_struct *g_psNotifyWorkQueue;
#endif
@@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _FPSGO_MINI_TOP_H_
#define _FPSGO_MINI_TOP_H_
#include <linux/rbtree.h>
#include <linux/list.h>
struct tid_util {
pid_t tid;
int util;
};
struct minitop_work {
pid_t tid[NR_CPUS];
int util[NR_CPUS];
struct work_struct work;
struct list_head link;
};
#define MINITOP_SCHED (0x1 << 0)
#define MINITOP_FTEH (0x1 << 1)
#define MINITOP_FBT (0x1 << 2)
struct minitop_rec {
pid_t tid;
struct rb_node node;
u64 init_runtime;
u64 init_timestamp;
u64 ratio;
u32 life;
int debnc;
int ever;
int source;
int debnc_fteh; /* irrelative to ceiling switch */
int debnc_fbt;
u64 runtime_inst;
u64 ratio_inst;
};
int __init minitop_init(void);
void __exit minitop_exit(void);
extern void (*fpsgo_sched_nominate_fp)(pid_t *tid, int *util);
void fpsgo_comp2minitop_queue_update(unsigned long long ts);
#endif
@@ -0,0 +1,370 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _XGF_H_
#define _XGF_H_
#include <linux/rbtree.h>
#define HW_EVENT_NUM 2
#define HW_MONITER_WINDOW 10
#define HW_MONITER_LEVEL 8
#define EMA_DIVISOR 10
#define EMA_DIVIDEND 7
#define EMA_REST_DIVIDEND (EMA_DIVISOR - EMA_DIVIDEND)
#define SP_ALLOW_NAME "UnityMain"
#define SP_ALLOW_NAME2 "Thread-"
#define XGF_DEP_FRAMES_MIN 2
#define XGF_DEP_FRAMES_MAX 20
#define XGF_DO_SP_SUB 0
#define XGF_MAX_UFRMAES 200
#define N 8
enum XGF_ERROR {
XGF_NOTIFY_OK,
XGF_SLPTIME_OK,
XGF_DISABLE,
XGF_THREAD_NOT_FOUND,
XGF_PARAM_ERR,
XGF_BUFFER_ERR,
XGF_BUFFER_OW,
XGF_BUFFER_ZERO,
XGF_DEP_LIST_ERR
};
enum {
XGF_QUEUE_START = 0,
XGF_QUEUE_END,
XGF_DEQUEUE_START,
XGF_DEQUEUE_END
};
enum HW_EVENT {
HW_AI = 0,
HW_CV
};
enum XGF_DEPS_CAT {
INNER_DEPS = 0,
OUTER_DEPS,
PREVI_DEPS
};
struct xgf_sub_sect {
struct hlist_node hlist;
unsigned long long start_ts;
unsigned long long end_ts;
};
struct xgf_ema2_predictor {
/* data */
long long learn_rate;
long long beta;
long long epsilon;
long long alpha;
long long mu;
long long one;
long long L[N];
long long W[N];
long long RMSProp[N];
long long nabla[N];
long long rho[N];
long long x_record[N];
long long acc_x;
long long acc_xx[N + 1];
long long x_front[N];
long long xt_last;
long long xt_last_valid;
int record_idx;
long long ar_error_diff;
long long ar_coeff_sum;
bool ar_coeff_enable;
int ar_coeff_frames;
int acc_idx;
int coeff_shift;
int order;
long long t;
bool ar_coeff_valid;
int invalid_th;
unsigned int invalid_input_cnt;
unsigned int invalid_negative_output_cnt;
unsigned int skip_grad_update_cnt;
bool rmsprop_initialized;
bool x_record_initialized;
int err_code;
};
struct xgf_render {
struct hlist_node hlist;
pid_t parent;
pid_t render;
unsigned long long bufID;
struct hlist_head sector_head;
int sector_nr;
struct hlist_head hw_head;
int prev_index;
unsigned long long prev_ts;
int curr_index;
unsigned long long curr_ts;
int event_count;
int frame_count;
int u_wake_r;
int u_wake_r_count;
struct rb_root deps_list;
struct rb_root out_deps_list;
struct rb_root prev_deps_list;
struct xgf_sub_sect deque;
struct xgf_sub_sect queue;
unsigned long long ema_runtime;
unsigned long long pre_u_runtime;
unsigned long long u_runtime[XGF_MAX_UFRMAES];
unsigned long long u_avg_runtime;
unsigned long long u_runtime_sd;
int u_runtime_idx;
int spid;
int dep_frames;
};
struct xgf_dep {
struct rb_node rb_node;
pid_t tid;
int render_dep;
int frame_idx;
};
struct xgf_runtime_sect {
struct hlist_node hlist;
unsigned long long start_ts;
unsigned long long end_ts;
};
struct xgf_render_sector {
struct hlist_node hlist;
int sector_id;
int counted;
struct hlist_head path_head;
unsigned long long head_ts;
unsigned long long tail_ts;
int head_index;
int tail_index;
int got_next_index;
int stop_at_irq;
int raw_head_index;
int raw_tail_index;
int special_rs;
};
struct xgf_pid_rec {
struct hlist_node hlist;
pid_t pid;
};
struct xgf_hw_rec {
struct hlist_node hlist;
unsigned long long mid;
int event_type;
int hw_type;
};
struct xgf_irq_stack {
int index;
int event;
struct xgf_irq_stack *next;
};
struct xgf_hw_event {
struct hlist_node hlist;
int event_type;
int event_index;
pid_t tid;
pid_t render;
unsigned long long mid;
int valid;
unsigned long long head_ts;
unsigned long long tail_ts;
};
struct xgf_spid {
struct hlist_node hlist;
char process_name[16];
char thread_name[16];
int pid;
int rpid;
int tid;
unsigned long long bufID;
int action;
};
extern int (*xgf_est_runtime_fp)(pid_t r_pid,
struct xgf_render *render,
unsigned long long *runtime,
unsigned long long ts);
extern int (*fpsgo_xgf2ko_calculate_target_fps_fp)(int pid,
unsigned long long bufID,
int *target_fps_margin,
unsigned long long cur_dequeue_start_ts,
unsigned long long cur_queue_end_ts);
extern void (*fpsgo_xgf2ko_do_recycle_fp)(int pid,
unsigned long long bufID);
extern long long (*xgf_ema2_predict_fp)(struct xgf_ema2_predictor *pt, long long X);
extern void (*xgf_ema2_init_fp)(struct xgf_ema2_predictor *pt);
void xgf_lockprove(const char *tag);
void xgf_trace(const char *fmt, ...);
void xgf_reset_renders(void);
int xgf_est_runtime(pid_t r_pid, struct xgf_render *render,
unsigned long long *runtime, unsigned long long ts);
void *xgf_alloc(int size);
void xgf_free(void *block);
void *xgf_atomic_val_assign(int select);
int *xgf_extra_sub_assign(void);
int *xgf_spid_sub_assign(void);
int xgf_atomic_read(atomic_t *val);
int xgf_atomic_inc_return(atomic_t *val);
void xgf_atomic_set(atomic_t *val, int i);
unsigned int xgf_cpumask_next(int cpu, const struct cpumask *srcp);
int xgf_num_possible_cpus(void);
int xgf_get_task_wake_cpu(struct task_struct *t);
int xgf_get_task_pid(struct task_struct *t);
long xgf_get_task_state(struct task_struct *t);
void notify_xgf_ko_ready(void);
unsigned long long xgf_get_time(void);
int xgf_dep_frames_mod(struct xgf_render *render, int pos);
struct xgf_dep *xgf_get_dep(pid_t tid, struct xgf_render *render,
int pos, int force);
void xgf_clean_deps_list(struct xgf_render *render, int pos);
int xgf_hw_events_update(int rpid, struct xgf_render *render);
void fpsgo_ctrl2xgf_switch_xgf(int val);
void fpsgo_ctrl2xgf_nn_job_begin(unsigned int tid, unsigned long long mid);
int fpsgo_ctrl2xgf_nn_job_end(unsigned int tid, unsigned long long mid);
int fpsgo_comp2xgf_qudeq_notify(int rpid, unsigned long long bufID, int cmd,
unsigned long long *run_time, unsigned long long *mid,
unsigned long long ts);
void fpsgo_fstb2xgf_do_recycle(int fstb_active);
void fpsgo_create_render_dep(void);
int has_xgf_dep(pid_t tid);
int fpsgo_xgf2ko_calculate_target_fps(int pid, unsigned long long bufID,
int *target_fps_margin, unsigned long long cur_dequeue_start_ts,
unsigned long long cur_queue_end_ts);
void fpsgo_xgf2ko_do_recycle(int pid, unsigned long long bufID);
void fpsgo_ctrl2xgf_display_rate(int dfrc_fps);
int xgf_get_display_rate(void);
int xgf_get_process_id(int pid);
int xgf_check_main_sf_pid(int pid, int process_id);
int xgf_check_specific_pid(int pid);
void xgf_set_logical_render_runtime(int pid, unsigned long long bufID,
unsigned long long l_runtime, unsigned long long r_runtime);
void xgf_set_logical_render_info(int pid, unsigned long long bufID,
int *l_arr, int l_num, int *r_arr, int r_num,
unsigned long long l_start_ts,
unsigned long long f_start_ts);
void xgf_set_timer_info(int pid, unsigned long long bufID,
int hrtimer_pid, int hrtimer_flag,
unsigned long long hrtimer_ts, unsigned long long prev_queue_end_ts);
long long xgf_ema2_predict(struct xgf_ema2_predictor *pt, long long X);
void xgf_ema2_init(struct xgf_ema2_predictor *pt);
enum XGF_EVENT {
SCHED_SWITCH,
SCHED_WAKEUP,
IPI_RAISE,
IPI_ENTRY,
IPI_EXIT,
IRQ_ENTRY,
IRQ_EXIT,
SOFTIRQ_ENTRY,
SOFTIRQ_EXIT,
SCHED_WAKING,
HRTIMER_ENTRY,
HRTIMER_EXIT
};
struct xgf_trace_event {
unsigned long long ts;
int event;
int cpu;
union {
int prev_pid;
int pid;
int target_cpu;
int irqnr;
int none;
};
union {
int note;
};
};
struct fstb_trace_event {
unsigned long long ts;
int event;
int cpu;
int note;
int state;
int pid;
};
extern struct xgf_trace_event *xgf_event_data;
extern void *xgf_event_index;
extern void *xgf_ko_enabled;
extern int xgf_max_events;
extern struct fstb_trace_event *fstb_event_data;
extern atomic_t fstb_event_data_idx;
extern int fstb_event_buffer_size;
extern int fstb_frame_num;
extern int fstb_no_stable_thr;
extern int fstb_no_stable_multiple;
extern int fstb_no_stable_multiple_eara;
extern int fstb_is_eara_active;
extern int fstb_can_update_thr;
extern int fstb_target_fps_margin_low_fps;
extern int fstb_target_fps_margin_high_fps;
extern int fstb_separate_runtime_enable;
extern int fstb_fps_num;
extern int fstb_fps_choice[];
int __init init_xgf(void);
extern int (*xgff_est_runtime_fp)(pid_t r_pid,
struct xgf_render *render,
unsigned long long *runtime,
unsigned long long ts);
int xgff_est_runtime(pid_t r_pid, struct xgf_render *render,
unsigned long long *runtime, unsigned long long ts);
extern int (*xgff_update_start_prev_index_fp)(struct xgf_render *render);
int xgff_update_start_prev_index(struct xgf_render *render);
void xgff_clean_deps_list(struct xgf_render *render, int pos);
int xgff_dep_frames_mod(struct xgf_render *render, int pos);
struct xgf_dep *xgff_get_dep(
pid_t tid, struct xgf_render *render, int pos, int force);
#endif
@@ -0,0 +1,177 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <mtk_vcorefs_governor.h>
#include <mtk_vcorefs_manager.h>
#include <mach/mtk_ppm_api.h>
#include <linux/cpumask.h>
int ultra_req;
int cm_req;
/*
* cpi_uclamp_thres = 123500000 / 149500000 * 100
*/
static int cpi_thres = 250;
static unsigned int cpi_uclamp_thres = 82;
void fbt_notify_CM_limit(int reach_limit)
{
}
void fbt_reg_dram_request(int reg)
{
}
void fbt_dram_arbitration(void)
{
int ret = -1;
if (cm_req || ultra_req)
ret = vcorefs_request_dvfs_opp(KIR_FBT, 0);
else
ret = vcorefs_request_dvfs_opp(KIR_FBT, -1);
if (ret < 0)
fpsgo_systrace_c_fbt_gm(-100, 0, ret,
"fbt_dram_arbitration_ret");
fpsgo_systrace_c_fbt_gm(-100, 0, cm_req, "cm_req");
fpsgo_systrace_c_fbt_gm(-100, 0, ultra_req, "ultra_req");
}
void fbt_boost_dram(int boost)
{
if (boost == ultra_req)
return;
ultra_req = boost;
fbt_dram_arbitration();
}
void fbt_set_boost_value(unsigned int base_blc)
{
int cpi = 0;
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
/* single cluster for mt6739 */
cpi = ppm_get_cluster_cpi(0);
fpsgo_systrace_c_fbt_gm(-100, 0, cpi, "cpi");
cm_req = base_blc > cpi_uclamp_thres && cpi > cpi_thres;
fbt_dram_arbitration();
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
cm_req = 0;
ultra_req = 0;
fbt_notify_CM_limit(0);
fbt_dram_arbitration();
}
/*
* mt6739 use boost_ta to support CM optimize.
* per-task uclamp doesn't support CM optimize.
*/
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (!pid)
return;
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 1;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 0;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
@@ -0,0 +1,181 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "mt-plat/eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <mt-plat/fpsgo_common.h>
#include "mtk_cm_mgr_common.h"
#define API_READY 0
#if API_READY
static struct pm_qos_request dram_req;
#endif
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
#if API_READY
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, PM_QOS_DDR_OPP,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
#endif
}
void fbt_boost_dram(int boost)
{
#if API_READY
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
#endif
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (!pid)
return;
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(4, cpu_mask);
cpumask_set_cpu(5, cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(4, cpu_mask);
cpumask_clear_cpu(5, cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
@@ -0,0 +1,181 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "mt-plat/eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <mt-plat/fpsgo_common.h>
#include "mtk_cm_mgr_common.h"
#define API_READY 0
#if API_READY
static struct pm_qos_request dram_req;
#endif
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
#if API_READY
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, PM_QOS_DDR_OPP,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
#endif
}
void fbt_boost_dram(int boost)
{
#if API_READY
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
#endif
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (!pid)
return;
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(0, cpu_mask);
cpumask_set_cpu(1, cpu_mask);
cpumask_set_cpu(2, cpu_mask);
cpumask_set_cpu(3, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(0, cpu_mask);
cpumask_clear_cpu(1, cpu_mask);
cpumask_clear_cpu(2, cpu_mask);
cpumask_clear_cpu(3, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_cluster_num(void)
{
return 1;
}
int fbt_get_L_min_ceiling(void)
{
return 1100000;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
@@ -0,0 +1,204 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (pid <= 0)
return ;
if (base_blc < 0 || base_blc > 100)
return ;
#ifdef CONFIG_UCLAMP_TASK
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 1;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 0;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
@@ -0,0 +1,181 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "mt-plat/eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <mt-plat/fpsgo_common.h>
#include "mtk_cm_mgr_common.h"
#define API_READY 0
#if API_READY
static struct pm_qos_request dram_req;
#endif
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
#if API_READY
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, PM_QOS_DDR_OPP,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
#endif
}
void fbt_boost_dram(int boost)
{
#if API_READY
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
#endif
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (!pid)
return;
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(4, cpu_mask);
cpumask_set_cpu(5, cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(4, cpu_mask);
cpumask_clear_cpu(5, cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
@@ -0,0 +1,212 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
#include "mt-plat/eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <mt-plat/fpsgo_common.h>
#include "mtk_cm_mgr_common.h"
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (pid <= 0)
return ;
if (base_blc < 0 || base_blc > 100)
return ;
#ifdef CONFIG_UCLAMP_TASK
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_L_M) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_L_M, &mask[FPSGO_PREFER_L_M]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 25;
}
int fbt_get_default_qr_enable(void)
{
return 1;
}
int fbt_get_default_gcc_enable(void)
{
return 1;
}
int fbt_get_l_min_bhropp(void)
{
return 1;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
@@ -0,0 +1,204 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (pid <= 0)
return ;
if (base_blc < 0 || base_blc > 100)
return ;
#ifdef CONFIG_UCLAMP_TASK
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 0;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
@@ -0,0 +1,203 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (pid <= 0)
return ;
if (base_blc < 0 || base_blc > 100)
return ;
#ifdef CONFIG_UCLAMP_TASK
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 1;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 25;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
@@ -0,0 +1,203 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (pid <= 0)
return ;
if (base_blc < 0 || base_blc > 100)
return ;
#ifdef CONFIG_UCLAMP_TASK
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 1;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 25;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
@@ -0,0 +1,194 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, PM_QOS_DDR_OPP,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
if (!pid)
return;
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min_pct(pid, base_blc);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(4, cpu_mask);
cpumask_clear_cpu(5, cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(4, cpu_mask);
cpumask_set_cpu(5, cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 1;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 0;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
@@ -0,0 +1,207 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (pid <= 0)
return ;
if (base_blc < 0 || base_blc > 100)
return ;
#ifdef CONFIG_UCLAMP_TASK
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_L_M) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_L_M, &mask[FPSGO_PREFER_L_M]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 25;
}
int fbt_get_default_qr_enable(void)
{
return 1;
}
int fbt_get_default_gcc_enable(void)
{
return 1;
}
int fbt_get_l_min_bhropp(void)
{
return 1;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
@@ -0,0 +1,209 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (pid <= 0)
return ;
if (base_blc < 0 || base_blc > 100)
return ;
#ifdef CONFIG_UCLAMP_TASK
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(4, cpu_mask);
cpumask_clear_cpu(5, cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
#if defined(CONFIG_MTK_SCHED_MULTI_GEARS)
cpumask_set_cpu(7, cpu_mask);
#else
cpumask_set_cpu(4, cpu_mask);
cpumask_set_cpu(5, cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
#endif
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 1;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 0;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
@@ -0,0 +1,215 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
static struct pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (pid <= 0)
return ;
if (base_blc < 0 || base_blc > 100)
return ;
#ifdef CONFIG_UCLAMP_TASK
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(4, cpu_mask);
cpumask_clear_cpu(5, cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_L_M) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_L_M, &mask[FPSGO_PREFER_L_M]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 1;
}
int fbt_get_default_adj_count(void)
{
return 10;
}
int fbt_get_default_adj_tdiff(void)
{
return 1000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
/*
* when return value is zero -> no limit
* when cluster is not set -> no limit
* when cluster is set and freq is set -> ceiling limit
* when cluster is set and r_freq is set -> rescue ceiling limit
*/
*cluster = 2;
*freq = 2600000;
return 1;
}
int fbt_get_default_uboost(void)
{
return 75;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 1;
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,716 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/workqueue.h>
#include <linux/unistd.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/cpufreq.h>
#include <linux/topology.h>
#include "mt-plat/fpsgo_common.h"
#include "fpsgo_base.h"
#include "fpsgo_sysfs.h"
#include "fpsgo_usedext.h"
#include "fbt_cpu.h"
#include "fstb.h"
#include "fps_composer.h"
#include "xgf.h"
#ifdef CONFIG_DRM_MEDIATEK
#include "mtk_drm_arr.h"
#endif
#define CREATE_TRACE_POINTS
#include <trace/events/fpsgo.h>
#define API_READY 0
#define TARGET_UNLIMITED_FPS 240
enum FPSGO_NOTIFIER_PUSH_TYPE {
FPSGO_NOTIFIER_SWITCH_FPSGO = 0x00,
FPSGO_NOTIFIER_QUEUE_DEQUEUE = 0x01,
FPSGO_NOTIFIER_CONNECT = 0x02,
FPSGO_NOTIFIER_DFRC_FPS = 0x03,
FPSGO_NOTIFIER_BQID = 0x04,
FPSGO_NOTIFIER_NN_JOB_BEGIN = 0x05,
FPSGO_NOTIFIER_NN_JOB_END = 0x06,
FPSGO_NOTIFIER_GPU_BLOCK = 0x07,
FPSGO_NOTIFIER_VSYNC = 0x08,
};
/* TODO: use union*/
struct FPSGO_NOTIFIER_PUSH_TAG {
enum FPSGO_NOTIFIER_PUSH_TYPE ePushType;
int pid;
unsigned long long cur_ts;
int enable;
int qudeq_cmd;
unsigned int queue_arg;
unsigned long long bufID;
int connectedAPI;
int queue_SF;
unsigned long long identifier;
int create;
int dfrc_fps;
int num_step;
__s32 *device;
__s32 *boost;
__u64 *exec_time;
int tid;
int start;
struct work_struct sWork;
};
static struct mutex notify_lock;
struct workqueue_struct *g_psNotifyWorkQueue;
static int fpsgo_enable;
static int fpsgo_force_onoff;
static int gpu_boost_enable_perf;
static int gpu_boost_enable_camera;
void (*rsu_cpufreq_notifier_fp)(int cluster_id, unsigned long freq);
/* TODO: event register & dispatch */
int fpsgo_is_enable(void)
{
int enable;
mutex_lock(&notify_lock);
enable = fpsgo_enable;
mutex_unlock(&notify_lock);
FPSGO_LOGI("[FPSGO_CTRL] isenable %d\n", enable);
return enable;
}
static void fpsgo_notifier_wq_cb_vsync(unsigned long long ts)
{
FPSGO_LOGI("[FPSGO_CB] vsync: %llu\n", ts);
if (!fpsgo_is_enable())
return;
fpsgo_ctrl2fbt_vsync(ts);
}
static void fpsgo_notifier_wq_cb_dfrc_fps(int dfrc_fps)
{
FPSGO_LOGI("[FPSGO_CB] dfrc_fps %d\n", dfrc_fps);
fpsgo_ctrl2fstb_dfrc_fps(dfrc_fps);
fpsgo_ctrl2fbt_dfrc_fps(dfrc_fps);
}
static void fpsgo_notifier_wq_cb_connect(int pid,
int connectedAPI, unsigned long long id)
{
FPSGO_LOGI(
"[FPSGO_CB] connect: pid %d, API %d, id %llu\n",
pid, connectedAPI, id);
if (connectedAPI == WINDOW_DISCONNECT)
fpsgo_ctrl2comp_disconnect_api(pid, connectedAPI, id);
else
fpsgo_ctrl2comp_connect_api(pid, connectedAPI, id);
}
static void fpsgo_notifier_wq_cb_bqid(int pid, unsigned long long bufID,
int queue_SF, unsigned long long id, int create)
{
FPSGO_LOGI(
"[FPSGO_CB] bqid: pid %d, bufID %llu, queue_SF %d, id %llu, create %d\n",
pid, bufID, queue_SF, id, create);
fpsgo_ctrl2comp_bqid(pid, bufID, queue_SF, id, create);
}
static void fpsgo_notifier_wq_cb_gblock(int tid, int start)
{
FPSGO_LOGI(
"[FPSGO_CB] gblock: tid %d, start %d\n",
tid, start);
if (!fpsgo_is_enable())
return;
fpsgo_ctrl2fstb_gblock(tid, start);
}
static void fpsgo_notifier_wq_cb_qudeq(int qudeq,
unsigned int startend, int cur_pid,
unsigned long long curr_ts, unsigned long long id)
{
FPSGO_LOGI("[FPSGO_CB] qudeq: %d-%d, pid %d, ts %llu, id %llu\n",
qudeq, startend, cur_pid, curr_ts, id);
if (!fpsgo_is_enable())
return;
switch (qudeq) {
case 1:
if (startend) {
FPSGO_LOGI("[FPSGO_CB] QUEUE Start: pid %d\n",
cur_pid);
fpsgo_ctrl2comp_enqueue_start(cur_pid,
curr_ts, id);
} else {
FPSGO_LOGI("[FPSGO_CB] QUEUE End: pid %d\n",
cur_pid);
fpsgo_ctrl2comp_enqueue_end(cur_pid, curr_ts,
id);
}
break;
case 0:
if (startend) {
FPSGO_LOGI("[FPSGO_CB] DEQUEUE Start: pid %d\n",
cur_pid);
fpsgo_ctrl2comp_dequeue_start(cur_pid,
curr_ts, id);
} else {
FPSGO_LOGI("[FPSGO_CB] DEQUEUE End: pid %d\n",
cur_pid);
fpsgo_ctrl2comp_dequeue_end(cur_pid,
curr_ts, id);
}
break;
default:
break;
}
}
static void fpsgo_notifier_wq_cb_enable(int enable)
{
FPSGO_LOGI(
"[FPSGO_CB] enable %d, fpsgo_enable %d, force_onoff %d\n",
enable, fpsgo_enable, fpsgo_force_onoff);
mutex_lock(&notify_lock);
if (enable == fpsgo_enable) {
mutex_unlock(&notify_lock);
return;
}
if (fpsgo_force_onoff != FPSGO_FREE &&
enable != fpsgo_force_onoff) {
mutex_unlock(&notify_lock);
return;
}
fpsgo_ctrl2fbt_switch_fbt(enable);
fpsgo_ctrl2fstb_switch_fstb(enable);
fpsgo_ctrl2xgf_switch_xgf(enable);
fpsgo_enable = enable;
if (!fpsgo_enable)
fpsgo_clear();
FPSGO_LOGI("[FPSGO_CB] fpsgo_enable %d\n",
fpsgo_enable);
mutex_unlock(&notify_lock);
}
static void fpsgo_notifier_wq_cb(struct work_struct *psWork)
{
struct FPSGO_NOTIFIER_PUSH_TAG *vpPush =
FPSGO_CONTAINER_OF(psWork,
struct FPSGO_NOTIFIER_PUSH_TAG, sWork);
if (!vpPush) {
FPSGO_LOGE("[FPSGO_CTRL] ERROR\n");
return;
}
FPSGO_LOGI("[FPSGO_CTRL] push type = %d\n",
vpPush->ePushType);
switch (vpPush->ePushType) {
case FPSGO_NOTIFIER_SWITCH_FPSGO:
fpsgo_notifier_wq_cb_enable(vpPush->enable);
break;
case FPSGO_NOTIFIER_QUEUE_DEQUEUE:
fpsgo_notifier_wq_cb_qudeq(vpPush->qudeq_cmd,
vpPush->queue_arg, vpPush->pid,
vpPush->cur_ts, vpPush->identifier);
break;
case FPSGO_NOTIFIER_CONNECT:
fpsgo_notifier_wq_cb_connect(vpPush->pid,
vpPush->connectedAPI, vpPush->identifier);
break;
case FPSGO_NOTIFIER_DFRC_FPS:
fpsgo_notifier_wq_cb_dfrc_fps(vpPush->dfrc_fps);
break;
case FPSGO_NOTIFIER_BQID:
fpsgo_notifier_wq_cb_bqid(vpPush->pid, vpPush->bufID,
vpPush->queue_SF, vpPush->identifier, vpPush->create);
break;
case FPSGO_NOTIFIER_GPU_BLOCK:
fpsgo_notifier_wq_cb_gblock(vpPush->tid, vpPush->start);
break;
case FPSGO_NOTIFIER_VSYNC:
fpsgo_notifier_wq_cb_vsync(vpPush->cur_ts);
break;
default:
FPSGO_LOGE("[FPSGO_CTRL] unhandled push type = %d\n",
vpPush->ePushType);
break;
}
fpsgo_free(vpPush, sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
}
void fpsgo_notify_qudeq(int qudeq,
unsigned int startend,
int pid, unsigned long long id)
{
unsigned long long cur_ts;
struct FPSGO_NOTIFIER_PUSH_TAG *vpPush;
FPSGO_LOGI("[FPSGO_CTRL] qudeq %d-%d, id %llu pid %d\n",
qudeq, startend, id, pid);
if (!fpsgo_is_enable())
return;
vpPush =
(struct FPSGO_NOTIFIER_PUSH_TAG *)
fpsgo_alloc_atomic(sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
if (!vpPush) {
FPSGO_LOGE("[FPSGO_CTRL] OOM\n");
return;
}
if (!g_psNotifyWorkQueue) {
FPSGO_LOGE("[FPSGO_CTRL] NULL WorkQueue\n");
fpsgo_free(vpPush, sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
return;
}
cur_ts = fpsgo_get_time();
vpPush->ePushType = FPSGO_NOTIFIER_QUEUE_DEQUEUE;
vpPush->pid = pid;
vpPush->cur_ts = cur_ts;
vpPush->qudeq_cmd = qudeq;
vpPush->queue_arg = startend;
vpPush->identifier = id;
INIT_WORK(&vpPush->sWork, fpsgo_notifier_wq_cb);
queue_work(g_psNotifyWorkQueue, &vpPush->sWork);
}
void fpsgo_notify_connect(int pid,
int connectedAPI, unsigned long long id)
{
struct FPSGO_NOTIFIER_PUSH_TAG *vpPush;
FPSGO_LOGI(
"[FPSGO_CTRL] connect pid %d, id %llu, API %d\n",
pid, id, connectedAPI);
vpPush =
(struct FPSGO_NOTIFIER_PUSH_TAG *)
fpsgo_alloc_atomic(sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
if (!vpPush) {
FPSGO_LOGE("[FPSGO_CTRL] OOM\n");
return;
}
if (!g_psNotifyWorkQueue) {
FPSGO_LOGE("[FPSGO_CTRL] NULL WorkQueue\n");
fpsgo_free(vpPush, sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
return;
}
vpPush->ePushType = FPSGO_NOTIFIER_CONNECT;
vpPush->pid = pid;
vpPush->connectedAPI = connectedAPI;
vpPush->identifier = id;
INIT_WORK(&vpPush->sWork, fpsgo_notifier_wq_cb);
queue_work(g_psNotifyWorkQueue, &vpPush->sWork);
}
void fpsgo_notify_bqid(int pid, unsigned long long bufID,
int queue_SF, unsigned long long id, int create)
{
struct FPSGO_NOTIFIER_PUSH_TAG *vpPush;
FPSGO_LOGI("[FPSGO_CTRL] bqid pid %d, buf %llu, queue_SF %d, id %llu\n",
pid, bufID, queue_SF, id);
vpPush = (struct FPSGO_NOTIFIER_PUSH_TAG *)
fpsgo_alloc_atomic(sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
if (!vpPush) {
FPSGO_LOGE("[FPSGO_CTRL] OOM\n");
return;
}
if (!g_psNotifyWorkQueue) {
FPSGO_LOGE("[FPSGO_CTRL] NULL WorkQueue\n");
fpsgo_free(vpPush, sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
return;
}
vpPush->ePushType = FPSGO_NOTIFIER_BQID;
vpPush->pid = pid;
vpPush->bufID = bufID;
vpPush->queue_SF = queue_SF;
vpPush->identifier = id;
vpPush->create = create;
INIT_WORK(&vpPush->sWork, fpsgo_notifier_wq_cb);
queue_work(g_psNotifyWorkQueue, &vpPush->sWork);
}
int fpsgo_is_gpu_block_boost_enable(void)
{
int enable;
mutex_lock(&notify_lock);
enable = max(gpu_boost_enable_camera,
gpu_boost_enable_perf);
mutex_unlock(&notify_lock);
return enable;
}
int fpsgo_is_gpu_block_boost_perf_enable(void)
{
int enable;
mutex_lock(&notify_lock);
enable = gpu_boost_enable_perf;
mutex_unlock(&notify_lock);
return enable;
}
int fpsgo_is_gpu_block_boost_camera_enable(void)
{
int enable;
mutex_lock(&notify_lock);
enable = gpu_boost_enable_camera;
mutex_unlock(&notify_lock);
return enable;
}
void fpsgo_gpu_block_boost_enable_perf(int enable)
{
mutex_lock(&notify_lock);
gpu_boost_enable_perf = enable;
mutex_unlock(&notify_lock);
}
void fpsgo_gpu_block_boost_enable_camera(int enable)
{
mutex_lock(&notify_lock);
gpu_boost_enable_camera = enable;
mutex_unlock(&notify_lock);
}
int fpsgo_notify_gpu_block(int tid, unsigned long long mid, int start)
{
struct FPSGO_NOTIFIER_PUSH_TAG *vpPush;
int g_enable;
FPSGO_LOGI("[FPSGO_CTRL] gblock pid %d, start %d\n",
tid, start);
g_enable = fpsgo_is_gpu_block_boost_enable();
if (g_enable < 0 || g_enable > 100)
return -1;
vpPush = (struct FPSGO_NOTIFIER_PUSH_TAG *)
fpsgo_alloc_atomic(sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
if (!vpPush) {
FPSGO_LOGE("[FPSGO_CTRL] OOM\n");
return -1;
}
if (!g_psNotifyWorkQueue) {
FPSGO_LOGE("[FPSGO_CTRL] NULL WorkQueue\n");
fpsgo_free(vpPush, sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
return -1;
}
vpPush->ePushType = FPSGO_NOTIFIER_GPU_BLOCK;
vpPush->tid = tid;
vpPush->start = start;
INIT_WORK(&vpPush->sWork, fpsgo_notifier_wq_cb);
queue_work(g_psNotifyWorkQueue, &vpPush->sWork);
return g_enable;
}
void fpsgo_notify_vsync(void)
{
struct FPSGO_NOTIFIER_PUSH_TAG *vpPush;
FPSGO_LOGI("[FPSGO_CTRL] vsync\n");
if (!fpsgo_is_enable())
return;
vpPush = (struct FPSGO_NOTIFIER_PUSH_TAG *)
fpsgo_alloc_atomic(sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
if (!vpPush) {
FPSGO_LOGE("[FPSGO_CTRL] OOM\n");
return;
}
if (!g_psNotifyWorkQueue) {
FPSGO_LOGE("[FPSGO_CTRL] NULL WorkQueue\n");
fpsgo_free(vpPush, sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
return;
}
vpPush->ePushType = FPSGO_NOTIFIER_VSYNC;
vpPush->cur_ts = fpsgo_get_time();
INIT_WORK(&vpPush->sWork, fpsgo_notifier_wq_cb);
queue_work(g_psNotifyWorkQueue, &vpPush->sWork);
}
void fpsgo_get_fps(int *pid, int *fps)
{
//int pid = -1, fps = -1;
fpsgo_ctrl2fstb_get_fps(pid, fps);
FPSGO_LOGE("[FPSGO_CTRL] get_fps %d %d\n", *pid, *fps);
//return fps;
}
void fpsgo_notify_cpufreq(int cid, unsigned long freq)
{
FPSGO_LOGI("[FPSGO_CTRL] cid %d, cpufreq %lu\n", cid, freq);
if (rsu_cpufreq_notifier_fp)
rsu_cpufreq_notifier_fp(cid, freq);
if (!fpsgo_enable)
return;
fpsgo_ctrl2fbt_cpufreq_cb(cid, freq);
}
void dfrc_fps_limit_cb(unsigned int fps_limit)
{
unsigned int vTmp = TARGET_UNLIMITED_FPS;
struct FPSGO_NOTIFIER_PUSH_TAG *vpPush;
if (!fpsgo_is_enable())
return;
if (fps_limit > 0 && fps_limit <= TARGET_UNLIMITED_FPS)
vTmp = fps_limit;
FPSGO_LOGI("[FPSGO_CTRL] dfrc_fps %d\n", vTmp);
vpPush =
(struct FPSGO_NOTIFIER_PUSH_TAG *)
fpsgo_alloc_atomic(sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
if (!vpPush) {
FPSGO_LOGE("[FPSGO_CTRL] OOM\n");
return;
}
if (!g_psNotifyWorkQueue) {
FPSGO_LOGE("[FPSGO_CTRL] NULL WorkQueue\n");
fpsgo_free(vpPush, sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
return;
}
vpPush->ePushType = FPSGO_NOTIFIER_DFRC_FPS;
vpPush->dfrc_fps = vTmp;
INIT_WORK(&vpPush->sWork, fpsgo_notifier_wq_cb);
queue_work(g_psNotifyWorkQueue, &vpPush->sWork);
}
/* FPSGO control */
void fpsgo_switch_enable(int enable)
{
struct FPSGO_NOTIFIER_PUSH_TAG *vpPush = NULL;
if (!g_psNotifyWorkQueue) {
FPSGO_LOGE("[FPSGO_CTRL] NULL WorkQueue\n");
return;
}
FPSGO_LOGI("[FPSGO_CTRL] switch enable %d\n", enable);
if (fpsgo_is_force_enable() !=
FPSGO_FREE && enable !=
fpsgo_is_force_enable())
return;
vpPush =
(struct FPSGO_NOTIFIER_PUSH_TAG *)
fpsgo_alloc_atomic(sizeof(struct FPSGO_NOTIFIER_PUSH_TAG));
if (!vpPush) {
FPSGO_LOGE("[FPSGO_CTRL] OOM\n");
return;
}
vpPush->ePushType = FPSGO_NOTIFIER_SWITCH_FPSGO;
vpPush->enable = enable;
INIT_WORK(&vpPush->sWork, fpsgo_notifier_wq_cb);
queue_work(g_psNotifyWorkQueue, &vpPush->sWork);
}
int fpsgo_is_force_enable(void)
{
int temp_onoff;
mutex_lock(&notify_lock);
temp_onoff = fpsgo_force_onoff;
mutex_unlock(&notify_lock);
return temp_onoff;
}
void fpsgo_force_switch_enable(int enable)
{
mutex_lock(&notify_lock);
fpsgo_force_onoff = enable;
mutex_unlock(&notify_lock);
fpsgo_switch_enable(enable?1:0);
}
/* FSTB control */
int fpsgo_is_fstb_enable(void)
{
return is_fstb_enable();
}
int fpsgo_switch_fstb(int enable)
{
return fpsgo_ctrl2fstb_switch_fstb(enable);
}
int fpsgo_fstb_sample_window(long long time_usec)
{
return switch_sample_window(time_usec);
}
int fpsgo_fstb_fps_range(int nr_level,
struct fps_level *level)
{
return switch_fps_range(nr_level, level);
}
int fpsgo_fstb_process_fps_range(char *proc_name,
int nr_level, struct fps_level *level)
{
return switch_process_fps_range(proc_name, nr_level, level);
}
int fpsgo_fstb_thread_fps_range(pid_t pid,
int nr_level, struct fps_level *level)
{
return switch_thread_fps_range(pid, nr_level, level);
}
int fpsgo_fstb_fps_error_threhosld(int threshold)
{
return switch_fps_error_threhosld(threshold);
}
int fpsgo_fstb_percentile_frametime(int ratio)
{
return switch_percentile_frametime(ratio);
}
static void __exit fpsgo_exit(void)
{
fpsgo_notifier_wq_cb_enable(0);
if (g_psNotifyWorkQueue) {
flush_workqueue(g_psNotifyWorkQueue);
destroy_workqueue(g_psNotifyWorkQueue);
g_psNotifyWorkQueue = NULL;
}
#if API_READY
disp_unregister_fps_chg_callback(dfrc_fps_limit_cb);
#endif
fbt_cpu_exit();
mtk_fstb_exit();
fpsgo_composer_exit();
fpsgo_sysfs_exit();
}
static int __init fpsgo_init(void)
{
FPSGO_LOGI("[FPSGO_CTRL] init\n");
fpsgo_sysfs_init();
g_psNotifyWorkQueue =
create_singlethread_workqueue("fpsgo_notifier_wq");
if (g_psNotifyWorkQueue == NULL)
return -EFAULT;
mutex_init(&notify_lock);
fpsgo_force_onoff = FPSGO_FREE;
gpu_boost_enable_perf = gpu_boost_enable_camera = -1;
init_fpsgo_common();
fbt_cpu_init();
mtk_fstb_init();
fpsgo_composer_init();
fpsgo_switch_enable(1);
cpufreq_notifier_fp = fpsgo_notify_cpufreq;
fpsgo_notify_vsync_fp = fpsgo_notify_vsync;
fpsgo_get_fps_fp = fpsgo_get_fps;
fpsgo_notify_qudeq_fp = fpsgo_notify_qudeq;
fpsgo_notify_connect_fp = fpsgo_notify_connect;
fpsgo_notify_bqid_fp = fpsgo_notify_bqid;
#ifdef CONFIG_DRM_MEDIATEK
drm_register_fps_chg_callback(dfrc_fps_limit_cb);
#else
#if API_READY
disp_register_fps_chg_callback(dfrc_fps_limit_cb);
#endif
#endif
return 0;
}
module_init(fpsgo_init);
module_exit(fpsgo_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("MediaTek FPSGO");
MODULE_AUTHOR("MediaTek Inc.");
@@ -0,0 +1,25 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y += fstb.o
MTK_TOP = $(srctree)/drivers/misc/mediatek/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
ccflags-y += -I$(srctree)/drivers/gpu/mediatek/ged/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dfrc/
ccflags-y += -I$(srctree)/kernel/trace/
ccflags-y += -I$(MTK_TOP)/base/power/include/
ccflags-y += -I$(MTK_TOP)/base/power/$(MTK_PLATFORM)/
ccflags-y += -I$(MTK_TOP)/performance/fpsgo_v3/base/include
ccflags-y += -I$(MTK_TOP)/performance/fpsgo_v3/eara_job/include
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,79 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef FSTB_H
#define FSTB_H
int mtk_fstb_exit(void);
int mtk_fstb_init(void);
void fpsgo_comp2fstb_queue_time_update(
int pid, unsigned long long bufID, int frame_type,
unsigned long long ts,
int api);
int fpsgo_comp2fstb_enq_end(int pid,
unsigned long long bufID, unsigned long long enq);
int fpsgo_ctrl2fstb_gblock(int tid, int start);
void fpsgo_ctrl2fstb_get_fps(int *pid, int *fps);
void fpsgo_comp2fstb_camera_active(int pid);
#if defined(CONFIG_MTK_FPSGO) || defined(CONFIG_MTK_FPSGO_V3)
int is_fstb_enable(void);
int is_fstb_active(long long time_diff);
int fpsgo_ctrl2fstb_switch_fstb(int value);
int switch_sample_window(long long time_usec);
int switch_fps_range(int nr_level, struct fps_level *level);
int switch_process_fps_range(char *proc_name,
int nr_level, struct fps_level *level);
int switch_thread_fps_range(pid_t pid, int nr_level, struct fps_level *level);
int switch_dfps_ceiling(int fps);
int switch_fps_error_threhosld(int threshold);
int switch_percentile_frametime(int ratio);
int fpsgo_fbt2fstb_update_cpu_frame_info(
int pid,
unsigned long long bufID,
int tgid,
int frame_type,
unsigned long long Q2Q_time,
unsigned long long Runnging_time,
unsigned int Curr_cap,
unsigned int Max_cap,
unsigned long long mid);
void fpsgo_fbt2fstb_query_fps(int pid, unsigned long long bufID,
int *target_fps, int *target_cpu_time,
int tgid, unsigned long long mid);
void fpsgo_ctrl2fstb_dfrc_fps(int dfrc_fps);
#else
static inline int is_fstb_enable(void) { return 0; }
static inline int fpsgo_ctrl2fstb_switch_fstb(int en) { return 0; }
static inline int switch_sample_window(long long time_usec) { return 0; }
static inline int switch_fps_range(int nr_level,
struct fps_level *level) { return 0; }
static inline int switch_process_fps_range(char *proc_name,
int nr_level, struct fps_level *level) { return 0; }
static inline int switch_thread_fps_range(pid_t pid,
int nr_level, struct fps_level *level) { return 0; }
static inline int switch_dfps_ceiling(int fps) { return 0; }
static inline int switch_fps_error_threhosld(int threshold) { return 0; }
static inline int switch_percentile_frametime(int ratio) { return 0; }
static inline int fpsgo_fbt2fstb_update_cpu_frame_info(
int pid,
unsigned long long bufID,
int tgid,
int frame_type,
unsigned long long Q2Q_time,
unsigned long long Runnging_time,
unsigned int Curr_cap,
unsigned int Max_cap,
unsigned long long mid) { return 0; }
static inline void fpsgo_fbt2fstb_query_fps(int pid,
int *target_fps, int *target_cpu_time,
int tgid, unsigned long long mid) { }
static void fpsgo_ctrl2fstb_dfrc_fps(int dfrc_fps) { }
#endif
#endif
@@ -0,0 +1,104 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef FSTB_USEDEXT_H
#define FSTB_USEDEXT_H
#include <mt-plat/fpsgo_common.h>
#include <trace/events/fpsgo.h>
#include <linux/list.h>
#include <linux/sched.h>
#define DEFAULT_DFPS 60
#define CFG_MAX_FPS_LIMIT 240
#define CFG_MIN_FPS_LIMIT 10
#define FRAME_TIME_BUFFER_SIZE 200
#define MAX_NR_FPS_LEVELS 1
#define MAX_NR_RENDER_FPS_LEVELS 10
#define DISPLAY_FPS_FILTER_NS 100000000ULL
#define ASFC_THRESHOLD_NS 20000000ULL
#define ASFC_THRESHOLD_PERCENTAGE 30
#define VPU_MAX_CAP 100
#define MDLA_MAX_CAP 100
#define RESET_TOLERENCE 3
#define DEFAULT_JUMP_CHECK_NUM 21
#define JUMP_VOTE_MAX_I 60
extern int (*fbt_notifier_cpu_frame_time_fps_stabilizer)(
int pid,
int frame_type,
unsigned long long Q2Q_time,
unsigned long long Runnging_time,
unsigned int Curr_cap,
unsigned int Max_cap,
unsigned int Target_fps);
extern void (*ged_kpi_output_gfx_info2_fp)(long long t_gpu,
unsigned int cur_freq, unsigned int cur_max_freq, u64 ulID);
struct FSTB_FRAME_INFO {
struct hlist_node hlist;
int pid;
int proc_id;
char proc_name[16];
int target_fps;
int target_fps_margin;
int target_fps_margin2;
int target_fps_margin_dbnc_a;
int target_fps_margin_dbnc_b;
int sbe_state; /* -1: no chase, 0: free run, 1: max_fps*/
int queue_fps;
unsigned long long bufid;
int in_list;
int new_info;
long long m_c_time;
unsigned int m_c_cap;
long long m_v_time;
unsigned int m_v_cap;
long long m_m_time;
unsigned int m_m_cap;
long long cpu_time;
long long gpu_time;
int gpu_freq;
unsigned long long queue_time_ts[FRAME_TIME_BUFFER_SIZE]; /*timestamp*/
int queue_time_begin;
int queue_time_end;
int vote_fps[JUMP_VOTE_MAX_I];
int vote_i;
unsigned long long weighted_cpu_time[FRAME_TIME_BUFFER_SIZE];
unsigned long long weighted_cpu_time_ts[FRAME_TIME_BUFFER_SIZE];
unsigned long long weighted_gpu_time[FRAME_TIME_BUFFER_SIZE];
unsigned long long weighted_gpu_time_ts[FRAME_TIME_BUFFER_SIZE];
int weighted_cpu_time_begin;
int weighted_cpu_time_end;
int weighted_gpu_time_begin;
int weighted_gpu_time_end;
unsigned long long sorted_weighted_cpu_time[FRAME_TIME_BUFFER_SIZE];
unsigned long long sorted_weighted_gpu_time[FRAME_TIME_BUFFER_SIZE];
unsigned long long gblock_b;
unsigned long long gblock_time;
int fps_raise_flag;
};
struct FSTB_RENDER_TARGET_FPS {
struct hlist_node hlist;
char process_name[16];
int pid;
int nr_level;
struct fps_level level[MAX_NR_RENDER_FPS_LEVELS];
};
struct FSTB_POWERFPS_LIST {
int pid;
int fps;
};
#endif
@@ -0,0 +1,45 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
MTK_TOP = $(srctree)/drivers/misc/mediatek/
FPSGO_TOP = $(srctree)/drivers/misc/mediatek/performance/fpsgo_v3_topology/
BASE_TOP = $(FPSGO_TOP)/base
FBT_TOP = $(FPSGO_TOP)/fbt
FSTB_TOP = $(FPSGO_TOP)/fstb
COM_TOP = $(FPSGO_TOP)/composer
EARA_JOB_TOP = $(FPSGO_TOP)/eara_job
VIDEOX_TOP += $(srctree)/drivers/misc/mediatek/video/$(MTK_PLATFORM)/videox
obj-y += fpsgo_main.o
obj-y += base/
obj-y += composer/
obj-$(CONFIG_MTK_EARA_AI) += eara_job/
obj-y += fbt/
obj-y += fstb/
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(MTK_TOP)/dfrc/ \
-I$(BASE_TOP)/include/ \
-I$(FBT_TOP)/include/ \
-I$(FSTB_TOP)/ \
-I$(COM_TOP)/include/ \
-I$(EARA_JOB_TOP)/include/ \
-I$(VIDEOX_TOP)/ \
-I$(srctree)/drivers/gpu/drm/mediatek/ \
-I$(MTK_TOP)/include/mt-plat/ \
@@ -0,0 +1,32 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
MTK_TOP = $(srctree)/drivers/misc/mediatek/
FPSGO_TOP = $(MTK_TOP)/performance/fpsgo_v3_topology/
BASE_TOP = $(FPSGO_TOP)/base/
COMP_TOP = $(FPSGO_TOP)/composer/
FBT_TOP = $(FPSGO_TOP)/fbt/
obj-y += \
src/fpsgo_base.o \
src/fpsgo_sysfs.o \
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(BASE_TOP)/include/ \
-I$(COMP_TOP)/include/ \
-I$(FBT_TOP)/include/ \
@@ -0,0 +1,272 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FPSGO_BASE_H__
#define __FPSGO_BASE_H__
#include <linux/compiler.h>
#include <linux/mutex.h>
#include <linux/rbtree.h>
#include <linux/hrtimer.h>
#include <linux/workqueue.h>
#define WINDOW 20
#define RESCUE_TIMER_NUM 5
#define QUOTA_MAX_SIZE 300
#define GCC_MAX_SIZE 300
/* EARA job type */
enum HW_EVENT4RENDER {
PER_FRAME = 0,
CRO_FRAME = 10,
BACKGROUND = 20
};
struct fbt_jerk {
int id;
int jerking;
int postpone;
struct hrtimer timer;
struct work_struct work;
};
struct fbt_proc {
int active_jerk_id;
struct fbt_jerk jerks[RESCUE_TIMER_NUM];
};
struct fbt_frame_info {
int target_fps;
int mips_diff;
long mips;
unsigned long long running_time;
int count;
};
struct fbt_thread_loading {
int pid;
unsigned long long buffer_id;
atomic_t loading;
atomic_t *loading_cl;
atomic_t last_cb_ts;
struct list_head entry;
};
struct fbt_thread_blc {
int pid;
unsigned long long buffer_id;
unsigned int blc;
struct list_head entry;
};
struct fbt_boost_info {
int target_fps;
unsigned long long target_time;
unsigned int last_blc;
/* adjust loading */
int loading_weight;
int weight_cnt;
int hit_cnt;
int deb_cnt;
int hit_cluster;
/* rescue*/
struct fbt_proc proc;
int cur_stage;
/* variance control */
struct fbt_frame_info frame_info[WINDOW];
unsigned int floor;
int floor_count;
int reset_floor_bound;
int f_iter;
/* quota */
long long quota_raw[QUOTA_MAX_SIZE];
int quota_cnt;
int quota_cur_idx;
int quota_fps;
int quota;
int quota_adj; /* remove outlier */
int quota_mod; /* mod target time */
int enq_raw[QUOTA_MAX_SIZE];
int enq_sum;
int enq_avg;
/* GCC */
int gcc_quota;
int gcc_count;
int gcc_target_fps;
int correction;
int gcc_pct_thrs;
int gcc_avg_pct;
unsigned long long gcc_pct_reset_ts;
int quantile_cpu_time;
int quantile_gpu_time;
};
struct uboost {
unsigned long long vsync_u_runtime;
unsigned long long checkp_u_runtime;
unsigned long long timer_period;
int uboosting;
struct hrtimer timer;
struct work_struct work;
};
struct render_info {
struct rb_node render_key_node;
struct list_head bufferid_list;
struct rb_node linger_node;
/*render basic info pid bufferId..etc*/
int pid;
unsigned long long render_key; /*pid,identifier*/
unsigned long long identifier;
unsigned long long buffer_id;
int queue_SF;
int tgid; /*render's process pid*/
int api; /*connected API*/
int frame_type;
int hwui;
int ux;
/*render queue/dequeue/frame time info*/
unsigned long long t_enqueue_start;
unsigned long long t_enqueue_end;
unsigned long long t_dequeue_start;
unsigned long long t_dequeue_end;
unsigned long long enqueue_length;
unsigned long long dequeue_length;
unsigned long long Q2Q_time;
unsigned long long running_time;
/*fbt*/
int linger;
struct fbt_boost_info boost_info;
struct fbt_thread_loading *pLoading;
struct fbt_thread_blc *p_blc;
struct fpsgo_loading *dep_arr;
int dep_valid_size;
unsigned long long dep_loading_ts;
unsigned long long linger_ts;
long long last_sched_runtime;
/*TODO: EARA mid list*/
unsigned long long mid;
/*uboost*/
struct uboost uboost_info;
struct mutex thr_mlock;
};
struct BQ_id {
unsigned long long key;
unsigned long long identifier;
unsigned long long buffer_id;
int queue_SF;
int pid;
int queue_pid;
struct rb_node entry;
};
struct hwui_info {
int pid;
struct rb_node entry;
};
struct fpsgo_loading {
int pid;
int loading;
int prefer_type;
int policy;
long nice_bk;
};
struct gbe_runtime {
int pid;
unsigned long long runtime;
unsigned long long loading;
};
#ifdef FPSGO_DEBUG
#define FPSGO_LOGI(...) pr_debug("FPSGO:" __VA_ARGS__)
#else
#define FPSGO_LOGI(...)
#endif
#define FPSGO_LOGE(...) pr_debug("FPSGO:" __VA_ARGS__)
#define FPSGO_CONTAINER_OF(ptr, type, member) \
((type *)(((char *)ptr) - offsetof(type, member)))
void *fpsgo_alloc_atomic(int i32Size);
void fpsgo_free(void *pvBuf, int i32Size);
unsigned long long fpsgo_get_time(void);
int fpsgo_get_tgid(int pid);
void fpsgo_render_tree_lock(const char *tag);
void fpsgo_render_tree_unlock(const char *tag);
void fpsgo_thread_lock(struct mutex *mlock);
void fpsgo_thread_unlock(struct mutex *mlock);
void fpsgo_lockprove(const char *tag);
void fpsgo_thread_lockprove(const char *tag, struct mutex *mlock);
void fpsgo_delete_render_info(int pid,
unsigned long long buffer_id, unsigned long long identifier);
struct render_info *fpsgo_search_and_add_render_info(int pid,
unsigned long long identifier, int force);
struct hwui_info *fpsgo_search_and_add_hwui_info(int pid, int force);
void fpsgo_delete_hwui_info(int pid);
int fpsgo_has_bypass(void);
void fpsgo_check_thread_status(void);
void fpsgo_clear(void);
struct BQ_id *fpsgo_find_BQ_id(int pid, int tgid, long long identifier,
int action);
int fpsgo_get_BQid_pair(int pid, int tgid, long long identifier,
unsigned long long *buffer_id, int *queue_SF, int enqueue);
void fpsgo_main_trace(const char *fmt, ...);
void fpsgo_clear_uclamp_boost(void);
void fpsgo_clear_llf_cpu_policy(int orig_llf);
void fpsgo_del_linger(struct render_info *thr);
int fpsgo_uboost_traverse(unsigned long long ts);
int fpsgo_base_is_finished(struct render_info *thr);
int fpsgo_update_swap_buffer(int pid);
int init_fpsgo_common(void);
enum FPSGO_FRAME_TYPE {
NON_VSYNC_ALIGNED_TYPE = 0,
BY_PASS_TYPE = 1,
};
enum FPSGO_CONNECT_API {
WINDOW_DISCONNECT = 0,
NATIVE_WINDOW_API_EGL = 1,
NATIVE_WINDOW_API_CPU = 2,
NATIVE_WINDOW_API_MEDIA = 3,
NATIVE_WINDOW_API_CAMERA = 4,
};
enum FPSGO_FORCE {
FPSGO_FORCE_OFF = 0,
FPSGO_FORCE_ON = 1,
FPSGO_FREE = 2,
};
enum FPSGO_BQID_ACT {
ACTION_FIND = 0,
ACTION_FIND_ADD,
ACTION_FIND_DEL,
ACTION_DEL_PID
};
enum FPSGO_RENDER_INFO_HWUI {
RENDER_INFO_HWUI_UNKNOWN = 0,
RENDER_INFO_HWUI_TYPE = 1,
RENDER_INFO_HWUI_NONE = 2,
};
#endif
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#ifndef __FPSGO_SYSFS_H__
#define __FPSGO_SYSFS_H__
#include <linux/kobject.h>
//#include "fpsgo_type.h"
#define FPSGO_SYSFS_MAX_BUFF_SIZE 1024
#define KOBJ_ATTR_RW(_name) \
struct kobj_attribute kobj_attr_##_name = \
__ATTR(_name, 0660, \
_name##_show, _name##_store)
#define KOBJ_ATTR_RO(_name) \
struct kobj_attribute kobj_attr_##_name = \
__ATTR(_name, 0440, \
_name##_show, NULL)
#define KOBJ_ATTR_RWO(_name) \
struct kobj_attribute kobj_attr_##_name = \
__ATTR(_name, 0664, \
_name##_show, _name##_store)
#define KOBJ_ATTR_ROO(_name) \
struct kobj_attribute kobj_attr_##_name = \
__ATTR(_name, 0444, \
_name##_show, NULL)
int fpsgo_sysfs_create_dir(struct kobject *parent,
const char *name, struct kobject **ppsKobj);
void fpsgo_sysfs_remove_dir(struct kobject **ppsKobj);
void fpsgo_sysfs_create_file(struct kobject *parent,
struct kobj_attribute *kobj_attr);
void fpsgo_sysfs_remove_file(struct kobject *parent,
struct kobj_attribute *kobj_attr);
void fpsgo_sysfs_init(void);
void fpsgo_sysfs_exit(void);
extern struct kobject *kernel_kobj;
#endif
@@ -0,0 +1,41 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FPSGO_USEDEXT_H__
#define __FPSGO_USEDEXT_H__
extern void (*cpufreq_notifier_fp)(int cid, unsigned long freq);
extern void (*fpsgo_notify_qudeq_fp)(int qudeq, unsigned int startend,
int pid, unsigned long long identifier);
extern void (*fpsgo_notify_connect_fp)(int pid, int connectedAPI,
unsigned long long identifier);
extern void (*fpsgo_notify_bqid_fp)(int pid, unsigned long long bufID,
int queue_SF,
unsigned long long identifier, int create);
extern void (*fpsgo_notify_vsync_fp)(void);
extern void (*fpsgo_notify_swap_buffer_fp)(int pid);
extern void (*fpsgo_get_fps_fp)(int *pid, int *fps);
extern void (*fpsgo_notify_nn_job_begin_fp)(unsigned int tid,
unsigned long long mid);
extern void (*fpsgo_notify_nn_job_end_fp)(int pid, int tid,
unsigned long long mid, int num_step, __s32 *boost,
__s32 *device, __u64 *exec_time);
extern int (*fpsgo_get_nn_priority_fp)(unsigned int pid,
unsigned long long mid);
extern void (*fpsgo_get_nn_ttime_fp)(unsigned int pid,
unsigned long long mid, int num_step, __u64 *time);
extern void (*ged_vsync_notifier_fp)(void);
int fpsgo_is_force_enable(void);
void fpsgo_force_switch_enable(int enable);
int fpsgo_is_gpu_block_boost_enable(void);
int fpsgo_is_gpu_block_boost_perf_enable(void);
int fpsgo_is_gpu_block_boost_camera_enable(void);
void fpsgo_gpu_block_boost_enable_perf(int enable);
void fpsgo_gpu_block_boost_enable_camera(int enable);
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,84 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include "fpsgo_sysfs.h"
#include "fpsgo_base.h"
#define FPSGO_SYSFS_DIR_NAME "fpsgo"
static struct kobject *fpsgo_kobj;
int fpsgo_sysfs_create_dir(struct kobject *parent,
const char *name, struct kobject **ppsKobj)
{
struct kobject *psKobj = NULL;
if (name == NULL || ppsKobj == NULL) {
FPSGO_LOGE("Failed to create sysfs directory %p %p\n",
name, ppsKobj);
return -1;
}
parent = (parent != NULL) ? parent : fpsgo_kobj;
psKobj = kobject_create_and_add(name, parent);
if (!psKobj) {
FPSGO_LOGE("Failed to create '%s' sysfs directory\n",
name);
return -1;
}
*ppsKobj = psKobj;
return 0;
}
// --------------------------------------------------
void fpsgo_sysfs_remove_dir(struct kobject **ppsKobj)
{
if (ppsKobj == NULL)
return;
kobject_put(*ppsKobj);
*ppsKobj = NULL;
}
// --------------------------------------------------
void fpsgo_sysfs_create_file(struct kobject *parent,
struct kobj_attribute *kobj_attr)
{
if (kobj_attr == NULL) {
FPSGO_LOGE("Failed to create '%s' sysfs file kobj_attr=NULL\n");
return;
}
parent = (parent != NULL) ? parent : fpsgo_kobj;
if (sysfs_create_file(parent, &(kobj_attr->attr))) {
FPSGO_LOGE("Failed to create sysfs file\n");
return;
}
}
// --------------------------------------------------
void fpsgo_sysfs_remove_file(struct kobject *parent,
struct kobj_attribute *kobj_attr)
{
if (kobj_attr == NULL)
return;
parent = (parent != NULL) ? parent : fpsgo_kobj;
sysfs_remove_file(parent, &(kobj_attr->attr));
}
// --------------------------------------------------
void fpsgo_sysfs_init(void)
{
fpsgo_kobj = kobject_create_and_add(FPSGO_SYSFS_DIR_NAME,
kernel_kobj);
if (!fpsgo_kobj) {
FPSGO_LOGE("Failed to create '%s' sysfs root directory\n",
FPSGO_SYSFS_DIR_NAME);
}
}
// --------------------------------------------------
void fpsgo_sysfs_exit(void)
{
kobject_put(fpsgo_kobj);
fpsgo_kobj = NULL;
}
@@ -0,0 +1,35 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
MTK_TOP = $(srctree)/drivers/misc/mediatek/
FPSGO_TOP = $(srctree)/drivers/misc/mediatek/performance/fpsgo_v3_topology/
GBE_TOP = $(srctree)/drivers/misc/mediatek/performance/gbe/
BASE_TOP = $(FPSGO_TOP)/base
FBT_TOP = $(FPSGO_TOP)/fbt
FSTB_TOP = $(FPSGO_TOP)/fstb
COM_TOP = $(FPSGO_TOP)/composer
obj-y += src/fps_composer.o
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(BASE_TOP)/include/ \
-I$(COM_TOP)/include/ \
-I$(FBT_TOP)/include/ \
-I$(FSTB_TOP)/ \
-I$(GBE_TOP)/ \
@@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FPS_COMPOSER_H__
#define __FPS_COMPOSER_H__
#include <linux/rbtree.h>
enum FPSGO_COM_ERROR {
FPSGO_COM_IS_RENDER,
FPSGO_COM_TASK_NOT_EXIST,
FPSGO_COM_IS_SF,
};
struct connect_api_info {
struct rb_node rb_node;
struct list_head render_list;
int pid;
int tgid;
unsigned long long buffer_id;
unsigned long long buffer_key;
int api;
};
int fpsgo_composer_init(void);
void fpsgo_composer_exit(void);
void fpsgo_ctrl2comp_dequeue_end(int pid,
unsigned long long dequeue_end_time,
unsigned long long identifier);
void fpsgo_ctrl2comp_dequeue_start(int pid,
unsigned long long dequeue_start_time,
unsigned long long identifier);
void fpsgo_ctrl2comp_enqueue_end(int pid,
unsigned long long enqueue_end_time,
unsigned long long identifier);
void fpsgo_ctrl2comp_enqueue_start(int pid,
unsigned long long enqueue_start_time,
unsigned long long identifier);
void fpsgo_ctrl2comp_bqid(int pid, unsigned long long buffer_id,
int queue_SF, unsigned long long identifier,
int create);
void fpsgo_ctrl2comp_connect_api(int pid, int api,
unsigned long long identifier);
void fpsgo_ctrl2comp_disconnect_api(int pid, int api,
unsigned long long identifier);
void fpsgo_fstb2comp_check_connect_api(void);
#endif
@@ -0,0 +1,741 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/seq_file.h>
#include <linux/security.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/mutex.h>
#include <linux/sched/task.h>
#include <fpsgo_common.h>
#include "fpsgo_base.h"
#include "fpsgo_sysfs.h"
#include "fpsgo_common.h"
#include "fpsgo_usedext.h"
#include "fps_composer.h"
#include "fbt_cpu.h"
#include "fstb.h"
#include "xgf.h"
#include "uboost.h"
#include "mini_top.h"
#if defined(CONFIG_MTK_GBE)
#include "gbe2.h"
#endif
/*#define FPSGO_COM_DEBUG*/
#ifdef FPSGO_COM_DEBUG
#define FPSGO_COM_TRACE(...) xgf_trace("fpsgo_com:" __VA_ARGS__)
#else
#define FPSGO_COM_TRACE(...)
#endif
#define COMP_TAG "FPSGO_COMP"
#define TIME_1MS 1000000
static struct kobject *comp_kobj;
static struct rb_root ui_pid_tree;
static struct rb_root connect_api_tree;
static inline int fpsgo_com_check_is_surfaceflinger(int pid)
{
struct task_struct *tsk;
int is_surfaceflinger = FPSGO_COM_IS_RENDER;
rcu_read_lock();
tsk = find_task_by_vpid(pid);
if (tsk)
get_task_struct(tsk);
rcu_read_unlock();
if (!tsk)
return FPSGO_COM_TASK_NOT_EXIST;
if (strstr(tsk->comm, "surfaceflinger"))
is_surfaceflinger = FPSGO_COM_IS_SF;
put_task_struct(tsk);
return is_surfaceflinger;
}
struct connect_api_info *fpsgo_com_search_and_add_connect_api_info(int pid,
unsigned long long buffer_id, int force)
{
struct rb_node **p = &connect_api_tree.rb_node;
struct rb_node *parent = NULL;
struct connect_api_info *tmp = NULL;
unsigned long long buffer_key;
int tgid;
fpsgo_lockprove(__func__);
tgid = fpsgo_get_tgid(pid);
buffer_key = (buffer_id & 0xFFFFFFFFFFFF)
| (((unsigned long long)tgid) << 48);
FPSGO_COM_TRACE("%s key:%llu tgid:%d buffer_id:%llu",
__func__, buffer_key, tgid, buffer_id);
while (*p) {
parent = *p;
tmp = rb_entry(parent, struct connect_api_info, rb_node);
if (buffer_key < tmp->buffer_key)
p = &(*p)->rb_left;
else if (buffer_key > tmp->buffer_key)
p = &(*p)->rb_right;
else
return tmp;
}
if (!force)
return NULL;
tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
if (!tmp)
return NULL;
INIT_LIST_HEAD(&(tmp->render_list));
tmp->pid = pid;
tmp->tgid = tgid;
tmp->buffer_id = buffer_id;
tmp->buffer_key = buffer_key;
rb_link_node(&tmp->rb_node, parent, p);
rb_insert_color(&tmp->rb_node, &connect_api_tree);
return tmp;
}
int fpsgo_com_check_frame_type(int api, int type)
{
int new_type = 0;
switch (api) {
case NATIVE_WINDOW_API_MEDIA:
new_type = BY_PASS_TYPE;
return new_type;
default:
break;
}
return type;
}
int fpsgo_com_update_render_api_info(struct render_info *f_render)
{
struct connect_api_info *connect_api;
int new_type;
fpsgo_lockprove(__func__);
fpsgo_thread_lockprove(__func__, &(f_render->thr_mlock));
connect_api =
fpsgo_com_search_and_add_connect_api_info(f_render->pid,
f_render->buffer_id, 0);
if (!connect_api) {
FPSGO_COM_TRACE("no pair connect api pid[%d] buffer_id[%llu]",
f_render->pid, f_render->buffer_id);
return 0;
}
f_render->api = connect_api->api;
list_add(&(f_render->bufferid_list), &(connect_api->render_list));
FPSGO_COM_TRACE("add connect api pid[%d] key[%llu] buffer_id[%llu]",
connect_api->pid, connect_api->buffer_key,
connect_api->buffer_id);
new_type = fpsgo_com_check_frame_type(f_render->api,
f_render->frame_type);
f_render->frame_type = new_type;
return 1;
}
static int fpsgo_com_refetch_buffer(struct render_info *f_render, int pid,
unsigned long long identifier, int enqueue)
{
int ret;
unsigned long long buffer_id = 0;
int queue_SF = 0;
if (!f_render)
return 0;
fpsgo_lockprove(__func__);
fpsgo_thread_lockprove(__func__, &(f_render->thr_mlock));
ret = fpsgo_get_BQid_pair(pid, f_render->tgid,
identifier, &buffer_id, &queue_SF, enqueue);
if (!ret || !buffer_id) {
FPSGO_LOGI("refetch %d: %llu, %d, %llu\n",
pid, buffer_id, queue_SF, identifier);
fpsgo_main_trace("COMP: refetch %d: %llu, %d, %llu\n",
pid, buffer_id, queue_SF, identifier);
return 0;
}
f_render->buffer_id = buffer_id;
f_render->queue_SF = queue_SF;
if (!f_render->pLoading || !f_render->p_blc) {
fpsgo_base2fbt_node_init(f_render);
fpsgo_base2uboost_init(f_render);
}
FPSGO_COM_TRACE("%s: refetch %d: %llu, %llu, %d\n", __func__,
pid, identifier, buffer_id, queue_SF);
return 1;
}
void fpsgo_ctrl2comp_enqueue_start(int pid,
unsigned long long enqueue_start_time,
unsigned long long identifier)
{
struct render_info *f_render;
int xgf_ret = 0;
int check_render;
int ret;
FPSGO_COM_TRACE("%s pid[%d] id %llu", __func__, pid, identifier);
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
fpsgo_render_tree_lock(__func__);
f_render = fpsgo_search_and_add_render_info(pid, identifier, 1);
if (!f_render) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: store frame info fail : %d !!!!\n",
__func__, pid);
return;
}
fpsgo_thread_lock(&f_render->thr_mlock);
/* @buffer_id and @queue_SF MUST be initialized
* with @api at the same time
*/
if (!f_render->api && identifier) {
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 1);
if (!ret) {
goto exit;
return;
}
ret = fpsgo_com_update_render_api_info(f_render);
if (!ret) {
goto exit;
return;
}
} else if (identifier) {
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 1);
if (!ret) {
goto exit;
return;
}
}
if (f_render->api == NATIVE_WINDOW_API_CAMERA)
fpsgo_comp2fstb_camera_active(pid);
if (!f_render->queue_SF) {
goto exit;
return;
}
switch (f_render->frame_type) {
case NON_VSYNC_ALIGNED_TYPE:
f_render->t_enqueue_start = enqueue_start_time;
FPSGO_COM_TRACE(
"pid[%d] type[%d] enqueue_s:%llu",
pid, f_render->frame_type,
enqueue_start_time);
FPSGO_COM_TRACE("update pid[%d] tgid[%d] buffer_id:%llu api:%d",
f_render->pid, f_render->tgid,
f_render->buffer_id, f_render->api);
xgf_ret =
fpsgo_comp2xgf_qudeq_notify(pid, f_render->buffer_id,
XGF_QUEUE_START, NULL, NULL,
enqueue_start_time, f_render->hwui);
break;
case BY_PASS_TYPE:
f_render->t_enqueue_start = enqueue_start_time;
fpsgo_comp2fbt_bypass_enq();
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "%d-frame_time", pid);
break;
default:
FPSGO_COM_TRACE("type not found pid[%d] type[%d]",
pid, f_render->frame_type);
break;
}
exit:
fpsgo_thread_unlock(&f_render->thr_mlock);
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_ctrl2comp_enqueue_end(int pid,
unsigned long long enqueue_end_time,
unsigned long long identifier)
{
struct render_info *f_render;
struct hwui_info *h_info;
int xgf_ret = 0;
int check_render;
unsigned long long running_time = 0;
unsigned long long mid = 0;
int ret;
FPSGO_COM_TRACE("%s pid[%d] id %llu", __func__, pid, identifier);
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
fpsgo_render_tree_lock(__func__);
f_render = fpsgo_search_and_add_render_info(pid, identifier, 0);
if (!f_render) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: NON pair frame info : %d !!!!\n",
__func__, pid);
return;
}
fpsgo_thread_lock(&f_render->thr_mlock);
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 0);
if (!ret) {
goto exit;
return;
}
/* hwui */
if (!f_render->hwui) {
h_info = fpsgo_search_and_add_hwui_info(f_render->pid, 0);
if (h_info)
f_render->hwui = RENDER_INFO_HWUI_TYPE;
else
f_render->hwui = RENDER_INFO_HWUI_NONE;
}
if (!f_render->queue_SF) {
goto exit;
return;
}
switch (f_render->frame_type) {
case NON_VSYNC_ALIGNED_TYPE:
if (f_render->t_enqueue_end)
f_render->Q2Q_time =
enqueue_end_time - f_render->t_enqueue_end;
f_render->t_enqueue_end = enqueue_end_time;
f_render->enqueue_length =
enqueue_end_time - f_render->t_enqueue_start;
FPSGO_COM_TRACE(
"pid[%d] type[%d] enqueue_e:%llu enqueue_l:%llu",
pid, f_render->frame_type,
enqueue_end_time, f_render->enqueue_length);
xgf_ret =
fpsgo_comp2xgf_qudeq_notify(pid, f_render->buffer_id,
XGF_QUEUE_END, &running_time, &mid,
enqueue_end_time, f_render->hwui);
if (running_time != 0)
f_render->running_time = running_time;
f_render->mid = mid;
fpsgo_comp2fbt_frame_start(f_render,
enqueue_end_time);
fpsgo_comp2fstb_queue_time_update(pid,
f_render->buffer_id,
f_render->frame_type,
enqueue_end_time,
f_render->api,
f_render->hwui);
fpsgo_comp2fstb_enq_end(f_render->pid,
f_render->buffer_id,
f_render->enqueue_length);
fpsgo_comp2minitop_queue_update(enqueue_end_time);
#if defined(CONFIG_MTK_GBE)
fpsgo_comp2gbe_frame_update(f_render->pid, f_render->buffer_id);
#endif
fpsgo_systrace_c_fbt_gm(-300, 0, f_render->enqueue_length,
"%d_%d-enqueue_length", pid, f_render->frame_type);
break;
case BY_PASS_TYPE:
break;
default:
FPSGO_COM_TRACE("type not found pid[%d] type[%d]",
pid, f_render->frame_type);
break;
}
exit:
fpsgo_thread_unlock(&f_render->thr_mlock);
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_ctrl2comp_dequeue_start(int pid,
unsigned long long dequeue_start_time,
unsigned long long identifier)
{
struct render_info *f_render;
int xgf_ret = 0;
int check_render;
int ret;
FPSGO_COM_TRACE("%s pid[%d] id %llu", __func__, pid, identifier);
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
fpsgo_render_tree_lock(__func__);
f_render = fpsgo_search_and_add_render_info(pid, identifier, 0);
if (!f_render) {
struct BQ_id *pair;
pair = fpsgo_find_BQ_id(pid, 0, identifier, ACTION_FIND);
if (pair) {
FPSGO_COM_TRACE("%s: find pair enqueuer: %d, %d\n",
__func__, pid, pair->queue_pid);
pid = pair->queue_pid;
f_render = fpsgo_search_and_add_render_info(pid,
identifier, 0);
if (!f_render) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: NO pair enqueuer: %d\n",
__func__, pid);
return;
}
} else {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: NO pair enqueuer: %d\n",
__func__, pid);
return;
}
}
fpsgo_thread_lock(&f_render->thr_mlock);
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 0);
if (!ret) {
goto exit;
return;
}
if (!f_render->queue_SF) {
goto exit;
return;
}
switch (f_render->frame_type) {
case NON_VSYNC_ALIGNED_TYPE:
f_render->t_dequeue_start = dequeue_start_time;
FPSGO_COM_TRACE("pid[%d] type[%d] dequeue_s:%llu",
pid, f_render->frame_type, dequeue_start_time);
xgf_ret =
fpsgo_comp2xgf_qudeq_notify(pid, f_render->buffer_id,
XGF_DEQUEUE_START, NULL, NULL,
dequeue_start_time, f_render->hwui);
break;
case BY_PASS_TYPE:
break;
default:
FPSGO_COM_TRACE("type not found pid[%d] type[%d]",
pid, f_render->frame_type);
break;
}
exit:
fpsgo_thread_unlock(&f_render->thr_mlock);
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_ctrl2comp_dequeue_end(int pid,
unsigned long long dequeue_end_time,
unsigned long long identifier)
{
struct render_info *f_render;
int xgf_ret = 0;
int check_render;
int ret;
FPSGO_COM_TRACE("%s pid[%d] id %llu", __func__, pid, identifier);
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
fpsgo_render_tree_lock(__func__);
f_render = fpsgo_search_and_add_render_info(pid, identifier, 0);
if (!f_render) {
struct BQ_id *pair;
pair = fpsgo_find_BQ_id(pid, 0, identifier, ACTION_FIND);
if (pair) {
pid = pair->queue_pid;
f_render = fpsgo_search_and_add_render_info(pid,
identifier, 0);
}
if (!f_render) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: NO pair enqueuer: %d\n",
__func__, pid);
return;
}
}
fpsgo_thread_lock(&f_render->thr_mlock);
ret = fpsgo_com_refetch_buffer(f_render, pid, identifier, 0);
if (!ret) {
goto exit;
return;
}
if (!f_render->queue_SF) {
goto exit;
return;
}
switch (f_render->frame_type) {
case NON_VSYNC_ALIGNED_TYPE:
f_render->t_dequeue_end = dequeue_end_time;
f_render->dequeue_length =
dequeue_end_time - f_render->t_dequeue_start;
FPSGO_COM_TRACE(
"pid[%d] type[%d] dequeue_e:%llu dequeue_l:%llu",
pid, f_render->frame_type,
dequeue_end_time, f_render->dequeue_length);
xgf_ret =
fpsgo_comp2xgf_qudeq_notify(pid, f_render->buffer_id,
XGF_DEQUEUE_END, NULL, NULL, dequeue_end_time, f_render->hwui);
fpsgo_comp2fbt_deq_end(f_render, dequeue_end_time);
fpsgo_systrace_c_fbt_gm(-300, 0, f_render->dequeue_length,
"%d_%d-dequeue_length", pid, f_render->frame_type);
break;
case BY_PASS_TYPE:
break;
default:
FPSGO_COM_TRACE("type not found pid[%d] type[%d]",
pid, f_render->frame_type);
break;
}
exit:
fpsgo_thread_unlock(&f_render->thr_mlock);
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_ctrl2comp_connect_api(int pid, int api,
unsigned long long identifier)
{
struct connect_api_info *connect_api;
int check_render;
unsigned long long buffer_id = 0;
int queue_SF = 0;
int ret;
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
FPSGO_COM_TRACE("%s pid[%d], identifier:%llu",
__func__, pid, identifier);
fpsgo_render_tree_lock(__func__);
ret = fpsgo_get_BQid_pair(pid, 0, identifier, &buffer_id, &queue_SF, 0);
if (!ret || !buffer_id) {
FPSGO_LOGI("connect %d: %llu, %llu\n",
pid, buffer_id, identifier);
fpsgo_main_trace("COMP: connect %d: %llu, %llu\n",
pid, buffer_id, identifier);
fpsgo_render_tree_unlock(__func__);
return;
}
connect_api =
fpsgo_com_search_and_add_connect_api_info(pid, buffer_id, 1);
if (!connect_api) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: store frame info fail : %d !!!!\n",
__func__, pid);
return;
}
connect_api->api = api;
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_ctrl2comp_bqid(int pid, unsigned long long buffer_id,
int queue_SF, unsigned long long identifier, int create)
{
struct BQ_id *pair;
if (!identifier || !pid)
return;
if (!buffer_id && create)
return;
fpsgo_render_tree_lock(__func__);
FPSGO_LOGI("pid %d: bufid %llu, id %llu, queue_SF %d, create %d\n",
pid, buffer_id, identifier, queue_SF, create);
if (create) {
pair = fpsgo_find_BQ_id(pid, 0,
identifier, ACTION_FIND_ADD);
if (!pair) {
fpsgo_render_tree_unlock(__func__);
FPSGO_COM_TRACE("%s: add fail : %d !!!!\n",
__func__, pid);
return;
}
if (pair->pid != pid)
FPSGO_LOGI("%d: diff render same key %d\n",
pid, pair->pid);
pair->buffer_id = buffer_id;
pair->queue_SF = queue_SF;
} else
fpsgo_find_BQ_id(pid, 0,
identifier, ACTION_FIND_DEL);
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_com_clear_connect_api_render_list(
struct connect_api_info *connect_api)
{
struct render_info *pos, *next;
fpsgo_lockprove(__func__);
list_for_each_entry_safe(pos, next,
&connect_api->render_list, bufferid_list) {
fpsgo_delete_render_info(pos->pid,
pos->buffer_id, pos->identifier);
}
}
void fpsgo_ctrl2comp_disconnect_api(
int pid, int api, unsigned long long identifier)
{
struct connect_api_info *connect_api;
int check_render;
unsigned long long buffer_id = 0;
int queue_SF = 0;
int ret;
check_render = fpsgo_com_check_is_surfaceflinger(pid);
if (check_render != FPSGO_COM_IS_RENDER)
return;
FPSGO_COM_TRACE("%s pid[%d], identifier:%llu",
__func__, pid, identifier);
fpsgo_render_tree_lock(__func__);
ret = fpsgo_get_BQid_pair(pid, 0, identifier, &buffer_id, &queue_SF, 0);
if (!ret || !buffer_id) {
FPSGO_LOGI("disconnect %d: %llu, %llu\n",
pid, buffer_id, identifier);
fpsgo_main_trace("COMP: disconnect %d: %llu, %llu\n",
pid, buffer_id, identifier);
fpsgo_render_tree_unlock(__func__);
return;
}
connect_api =
fpsgo_com_search_and_add_connect_api_info(pid, buffer_id, 0);
if (!connect_api) {
FPSGO_COM_TRACE(
"%s: FPSGo composer distory connect api fail : %d !!!!\n",
__func__, pid);
fpsgo_render_tree_unlock(__func__);
return;
}
fpsgo_com_clear_connect_api_render_list(connect_api);
rb_erase(&connect_api->rb_node, &connect_api_tree);
kfree(connect_api);
fpsgo_comp2fbt_bypass_disconnect();
fpsgo_render_tree_unlock(__func__);
}
void fpsgo_fstb2comp_check_connect_api(void)
{
struct rb_node *n;
struct connect_api_info *iter;
struct task_struct *tsk;
FPSGO_COM_TRACE("%s ", __func__);
fpsgo_render_tree_lock(__func__);
n = rb_first(&connect_api_tree);
while (n) {
iter = rb_entry(n, struct connect_api_info, rb_node);
rcu_read_lock();
tsk = find_task_by_vpid(iter->tgid);
rcu_read_unlock();
if (!tsk) {
fpsgo_com_clear_connect_api_render_list(iter);
rb_erase(&iter->rb_node, &connect_api_tree);
n = rb_first(&connect_api_tree);
kfree(iter);
} else
n = rb_next(n);
}
fpsgo_render_tree_unlock(__func__);
}
void __exit fpsgo_composer_exit(void)
{
fpsgo_sysfs_remove_dir(&comp_kobj);
}
int __init fpsgo_composer_init(void)
{
ui_pid_tree = RB_ROOT;
connect_api_tree = RB_ROOT;
return 0;
}
@@ -0,0 +1,33 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
FPSGO_TOP = $(srctree)/drivers/misc/mediatek/performance/fpsgo_v3_topology
FSTB_TOP = $(FPSGO_TOP)/fstb
EARA_TOP = $(FPSGO_TOP)/eara_job
obj-y += src/eara_job.o
ccflags-y += \
-Iinclude/ \
-I$(FPSGO_TOP)/base/include/ \
-I$(srctree)/drivers/misc/mediatek/base/power/include \
-I$(FSTB_TOP)/ \
-I$(EARA_TOP)/include/ \
-I$(srctree)/drivers/misc/mediatek/vpu/$(MTK_PLATFORM) \
-I$(srctree)/drivers/misc/mediatek/mdla/1.0 \
-I$(srctree)/drivers/misc/mediatek/performance/observer \
-I$(srctree)/drivers/misc/mediatek/apusys/power/2.0/ \
-I$(srctree)/drivers/misc/mediatek/apusys/power/2.0/$(MTK_PLATFORM)
@@ -0,0 +1,69 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __EARA_JOB_H__
#define __EARA_JOB_H__
#define MAX_DEVICE 2
#if defined(CONFIG_MTK_EARA_AI)
void fpsgo_ctrl2eara_nn_job_collect(int pid, int tid, unsigned long long mid,
int hw_type, int num_step, __s32 *boost,
__s32 *device, __u64 *exec_time);
int fpsgo_ctrl2eara_get_nn_priority(unsigned int pid,
unsigned long long mid);
void fpsgo_ctrl2eara_get_nn_ttime(unsigned int pid,
unsigned long long mid, int num_step, __u64 *time);
void fpsgo_fstb2eara_notify_fps_bound(void);
void fpsgo_fstb2eara_notify_fps_active(int active);
void fpsgo_fstb2eara_get_exec_time(int pid,
unsigned long long mid, unsigned long long *t_v,
unsigned long long *t_m);
void fpsgo_fstb2eara_get_boost_value(int pid, unsigned long long mid,
int *b_v, int *b_m);
void fpsgo_fstb2eara_optimize_power(unsigned long long mid,
int tgid, long long *t_c_time, long long t_t_t,
long long c_time, long long v_time, long long m_time,
unsigned int c_cap, unsigned int v_cap, unsigned int m_cap);
void fpsgo_fstb2eara_get_jobs_status(int *vpu_cross,
int *mdla_cross, int *vpu_bg, int *mdla_bg);
#else
static inline void fpsgo_ctrl2eara_nn_job_collect(
int pid, int tid, unsigned long long mid,
int hw_type, int num_step, __s32 *boost,
__s32 *device, __u64 *exec_time) { }
static inline int fpsgo_ctrl2eara_get_nn_priority(unsigned int pid,
unsigned long long mid) { return 0; }
static inline void fpsgo_ctrl2eara_get_nn_ttime(unsigned int pid,
unsigned long long mid, int num_step, __u64 *time) { }
static inline void fpsgo_fstb2eara_notify_fps_bound(void) { }
static inline void fpsgo_fstb2eara_notify_fps_active(int active) { }
static inline void fpsgo_fstb2eara_get_exec_time(int pid,
unsigned long long mid, unsigned long long *t_v,
unsigned long long *t_m) {
*t_v = 0;
*t_m = 0;
}
static inline void fpsgo_fstb2eara_get_boost_value(
int pid, unsigned long long mid,
int *b_v, int *b_m) {
*b_v = 0;
*b_m = 0;
}
static inline void fpsgo_fstb2eara_optimize_power(unsigned long long mid,
int tgid, long long *t_c_time, long long t_t_t,
long long c_time, long long v_time, long long m_time,
unsigned int c_cap, unsigned int v_cap, unsigned int m_cap) {
*t_c_time = t_t_t;
}
static inline void fpsgo_fstb2eara_get_jobs_status(int *vpu_cross,
int *mdla_cross, int *vpu_bg, int *mdla_bg){
*vpu_cross = 0;
*mdla_cross = 0;
*vpu_bg = 0;
*mdla_bg = 0;
}
#endif
#endif
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef EARA_JOB_USEDEXT_H
#define EARA_JOB_USEDEXT_H
enum device_component {
DEVICE_CPU,
DEVICE_GPU,
DEVICE_VPU,
DEVICE_MDLA,
DEVICE_NEON
};
extern struct ppm_cobra_data *ppm_cobra_pass_tbl(void);
extern unsigned int mt_cpufreq_get_freq_by_idx(int id, int idx);
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,68 @@
#
# Copyright (C) 2017 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
FPSGO_TOP = $(srctree)/drivers/misc/mediatek/performance/fpsgo_v3_topology
FBT_TOP = $(FPSGO_TOP)/fbt
COMP_TOP = $(FPSGO_TOP)/composer
MTK_TOP = $(srctree)/drivers/misc/mediatek
BASE_TOP = $(FPSGO_TOP)/base
FSTB_TOP = $(FPSGO_TOP)/fstb
EARA_TOP = $(FPSGO_TOP)/eara_job
ccflags-y += -DNR_FREQ_CPU=16
ifeq ($(CONFIG_MACH_MT6893),y)
obj-y += platform/mt6893/fbt_cpu_platform.o
else ifeq ($(CONFIG_MACH_MT6877),y)
obj-y += platform/mt6877/fbt_cpu_platform.o
else ifeq ($(CONFIG_MACH_MT6781),y)
obj-y += platform/mt6781/fbt_cpu_platform.o
else
obj-y += platform/$(MTK_PLATFORM)/fbt_cpu_platform.o
endif
ifeq ($(CONFIG_MACH_MT6893),y)
CONFIG_FPSGO_THERMAL_SUPPORT := y
ccflags-y += -DCONFIG_FPSGO_THERMAL_SUPPORT
else
CONFIG_FPSGO_THERMAL_SUPPORT := n
endif
obj-y += \
src/fbt_cpu.o \
src/xgf.o \
src/mini_top.o \
src/uboost.o \
obj-$(CONFIG_FPSGO_THERMAL_SUPPORT) += src/thermal_aware.o
ccflags-y += \
-I$(srctree)/include/ \
-I$(MTK_TOP)/include/ \
-I$(FPSGO_TOP)/base/include/ \
-I$(COMP_TOP)/include/ \
-I$(FBT_TOP)/include/ \
-I$(BASE_TOP)/include/ \
-I$(MTK_TOP)/base/power/include/ \
-I$(MTK_TOP)/base/power/$(MTK_PLATFORM)/ \
-I$(FSTB_TOP)/ \
-I$(EARA_TOP)/include/ \
-I$(srctree)/kernel/ \
-I$(MTK_TOP)/thermal/$(MTK_PLATFORM)/inc/ \
-I$(MTK_TOP)/thermal/$(MTK_PLATFORM)/inc/mach \
-I$(MTK_TOP)/include/mt-plat \
-I$(MTK_TOP)/include/mt-plat/$(MTK_PLATFORM)/include/mach \
-I$(srctree)/drivers/gpu/mediatek/gpufreq/ \
@@ -0,0 +1,89 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FBT_CPU_H__
#define __FBT_CPU_H__
#include "fpsgo_base.h"
extern int fpsgo_fbt2xgf_get_dep_list_num(int pid, unsigned long long bufID);
extern int fpsgo_fbt2xgf_get_dep_list(int pid, int count,
struct fpsgo_loading *arr, unsigned long long bufID);
#if defined(CONFIG_MTK_FPSGO) || defined(CONFIG_MTK_FPSGO_V3)
void fpsgo_ctrl2fbt_dfrc_fps(int fps_limit);
void fpsgo_ctrl2fbt_cpufreq_cb(int cid, unsigned long freq);
void fpsgo_ctrl2fbt_vsync(unsigned long long ts);
void fpsgo_comp2fbt_frame_start(struct render_info *thr,
unsigned long long ts);
void fpsgo_comp2fbt_deq_end(struct render_info *thr,
unsigned long long ts);
void fpsgo_base2fbt_node_init(struct render_info *obj);
void fpsgo_base2fbt_item_del(struct fbt_thread_loading *obj,
struct fbt_thread_blc *pblc,
struct fpsgo_loading *pdep,
struct render_info *thr);
int fpsgo_base2fbt_get_max_blc_pid(int *pid, unsigned long long *buffer_id);
void fpsgo_comp2fbt_bypass_enq(void);
void fpsgo_comp2fbt_bypass_disconnect(void);
void fpsgo_base2fbt_set_bypass(int has_bypass);
void fpsgo_base2fbt_check_max_blc(void);
void fpsgo_base2fbt_no_one_render(void);
void fpsgo_base2fbt_only_bypass(void);
void fpsgo_base2fbt_set_min_cap(struct render_info *thr, int min_cap);
void fpsgo_base2fbt_clear_llf_policy(struct render_info *thr,
int orig_policy);
void fpsgo_base2fbt_cancel_jerk(struct render_info *thr);
int fpsgo_base2fbt_is_finished(struct render_info *thr);
void fpsgo_uboost2fbt_uboost(struct render_info *thr);
void fpsgo_base2fbt_stop_boost(struct render_info *thr);
int __init fbt_cpu_init(void);
void __exit fbt_cpu_exit(void);
int fpsgo_ctrl2fbt_switch_fbt(int enable);
int fbt_switch_ceiling(int value);
#else
static inline void fpsgo_ctrl2fbt_dfrc_fps(int fps_limit) { }
static inline void fpsgo_ctrl2fbt_cpufreq_cb(int cid,
unsigned long freq) { }
static inline void fpsgo_ctrl2fbt_vsync(unsigned long long ts) { }
static inline void fpsgo_comp2fbt_frame_start(struct render_info *thr,
unsigned long long ts) { }
static inline void fpsgo_comp2fbt_deq_end(struct render_info *thr,
unsigned long long ts) { }
static inline int fbt_cpu_init(void) { return 0; }
static inline void fbt_cpu_exit(void) { }
static inline int fpsgo_ctrl2fbt_switch_fbt(int enable) { return 0; }
static inline void fpsgo_base2fbt_node_init(struct render_info *obj) { }
static inline void fpsgo_base2fbt_item_del(
struct fbt_thread_loading *obj, struct fbt_thread_blc *pblc,
struct fpsgo_loading *pdep,
struct render_info *thr) { }
static inline int fpsgo_base2fbt_get_max_blc_pid(int *pid,
unsigned long long *buffer_id) { return 0; }
static inline void fpsgo_comp2fbt_bypass_enq(void) { }
static inline void fpsgo_comp2fbt_bypass_disconnect(void) { }
static inline void fpsgo_base2fbt_set_bypass(int has_bypass) { }
static inline void fpsgo_base2fbt_check_max_blc(void) { }
static inline void fpsgo_base2fbt_no_one_render(void) { }
static inline void fpsgo_base2fbt_only_bypass(void) { }
static inline int fbt_switch_ceiling(int en) { return 0; }
static inline void fpsgo_base2fbt_set_min_cap(struct render_info *thr,
int min_cap) { }
static inline void fpsgo_base2fbt_clear_llf_policy(struct render_info *thr,
int orig_policy) { }
static inline void fpsgo_base2fbt_cancel_jerk(struct render_info *thr) { }
static inline int fpsgo_base2fbt_is_finished(struct render_info *thr) { return 0; }
static inline void fpsgo_uboost2fbt_uboost(struct render_info *thr) { }
static inline void fpsgo_base2fbt_stop_boost(struct render_info *thr) { }
#endif
#endif
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FBT_CPU_PLATFORM_H__
#define __FBT_CPU_PLATFORM_H__
#include "fbt_cpu.h"
enum FPSGO_CPU_PREFER {
FPSGO_PREFER_NONE = 0,
FPSGO_PREFER_BIG = 1,
FPSGO_PREFER_LITTLE = 2,
FPSGO_PREFER_L_M = 3,
FPSGO_PREFER_TOTAL,
};
extern long sched_setaffinity(pid_t pid, const struct cpumask *in_mask);
extern int sched_set_cpuprefer(pid_t pid, unsigned int prefer_type);
extern int capacity_min_write_for_perf_idx(int idx, int capacity_min);
extern void cm_mgr_perf_set_status(int enable);
extern int set_task_util_min(pid_t pid, unsigned int util_min);
void fbt_set_boost_value(unsigned int base_blc);
void fbt_clear_boost_value(void);
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc);
int fbt_get_L_min_ceiling(void);
void fbt_notify_CM_limit(int reach_limit);
void fbt_reg_dram_request(int reg);
void fbt_boost_dram(int boost);
int fbt_get_default_boost_ta(void);
int fbt_get_default_adj_loading(void);
int fbt_get_default_adj_count(void);
int fbt_get_default_adj_tdiff(void);
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type);
void fbt_set_affinity(pid_t pid, unsigned int prefer_type);
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq);
int fbt_get_default_uboost(void);
int fbt_get_default_qr_enable(void);
int fbt_get_default_gcc_enable(void);
int fbt_get_l_min_bhropp(void);
#endif
@@ -0,0 +1,25 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FBT_USEDEXT_H__
#define __FBT_USEDEXT_H__
extern int prefer_idle_for_perf_idx(int idx, int prefer_idle);
extern unsigned int mt_ppm_userlimit_freq_limit_by_others(
unsigned int cluster);
extern unsigned long get_cpu_orig_capacity(unsigned int cpu);
extern int upower_get_turn_point(void);
extern void set_capacity_margin(unsigned int margin);
extern unsigned int get_capacity_margin(void);
extern void set_user_nice(struct task_struct *p, long nice);
extern int fpsgo_fbt2minitop_start(int count, struct fpsgo_loading *fl);
extern int fpsgo_fbt2minitop_query(int count, struct fpsgo_loading *fl);
extern int fpsgo_fbt2minitop_end(void);
extern int fpsgo_fbt2minitop_query_single(pid_t pid);
extern struct workqueue_struct *g_psNotifyWorkQueue;
#endif
@@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _FPSGO_MINI_TOP_H_
#define _FPSGO_MINI_TOP_H_
#include <linux/rbtree.h>
#include <linux/list.h>
struct tid_util {
pid_t tid;
int util;
};
struct minitop_work {
pid_t tid[NR_CPUS];
int util[NR_CPUS];
struct work_struct work;
struct list_head link;
};
#define MINITOP_SCHED (0x1 << 0)
#define MINITOP_FTEH (0x1 << 1)
#define MINITOP_FBT (0x1 << 2)
struct minitop_rec {
pid_t tid;
struct rb_node node;
u64 init_runtime;
u64 init_timestamp;
u64 ratio;
u32 life;
int debnc;
int ever;
int source;
int debnc_fteh; /* irrelative to ceiling switch */
int debnc_fbt;
u64 runtime_inst;
u64 ratio_inst;
};
int __init minitop_init(void);
void __exit minitop_exit(void);
extern void (*fpsgo_sched_nominate_fp)(pid_t *tid, int *util);
void fpsgo_comp2minitop_queue_update(unsigned long long ts);
#endif
@@ -0,0 +1,21 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FPSGO_THERMAL_AWARE_H__
#define __FPSGO_THERMAL_AWARE_H__
#ifdef CONFIG_FPSGO_THERMAL_SUPPORT
void __init thrm_aware_init(struct kobject *dir_kobj);
void __exit thrm_aware_exit(void);
void thrm_aware_frame_start(int perf_hint, int target_fps);
void thrm_aware_switch(int enable);
#else
static inline void thrm_aware_init(struct kobject *dir_kobj) { }
static inline void thrm_aware_exit(void) { }
static inline void thrm_aware_frame_start(int perf_hint, int target_fps) { }
static inline void thrm_aware_switch(int enable) { }
#endif
#endif
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __FPSGO_UBOOST_H__
#define __FPSGO_UBOOST_H__
#include "fpsgo_base.h"
void fpsgo_base2uboost_compute(struct render_info *render, unsigned long long ts);
void fpsgo_base2uboost_init(struct render_info *obj);
void fpsgo_base2uboost_cancel(struct render_info *obj);
int __init fpsgo_uboost_init(void);
void __exit fpsgo_uboost_exit(void);
#endif
@@ -0,0 +1,379 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _XGF_H_
#define _XGF_H_
#include <linux/rbtree.h>
#define HW_EVENT_NUM 2
#define HW_MONITER_WINDOW 10
#define HW_MONITER_LEVEL 8
#define EMA_DIVISOR 10
#define EMA_DIVIDEND 7
#define EMA_REST_DIVIDEND (EMA_DIVISOR - EMA_DIVIDEND)
#define SP_ALLOW_NAME "UnityMain"
#define SP_ALLOW_NAME2 "Thread-"
#define XGF_DEP_FRAMES_MIN 2
#define XGF_DEP_FRAMES_MAX 20
#define XGF_DO_SP_SUB 0
#define XGF_MAX_UFRMAES 200
#define XGF_UBOOST 1
#define XGF_UBOOST_STDDEV_M 1
#define TIME_50MS 50000000
#define UB_SKIP_FRAME 20
#define UB_BEGIN_FRAME 50
#define XGF_MAX_SPID_LIST_LENGTH 20
#define N 8
enum XGF_ERROR {
XGF_NOTIFY_OK,
XGF_SLPTIME_OK,
XGF_DISABLE,
XGF_THREAD_NOT_FOUND,
XGF_PARAM_ERR,
XGF_BUFFER_ERR,
XGF_BUFFER_OW,
XGF_BUFFER_ZERO,
XGF_DEP_LIST_ERR
};
enum {
XGF_QUEUE_START = 0,
XGF_QUEUE_END,
XGF_DEQUEUE_START,
XGF_DEQUEUE_END
};
enum HW_EVENT {
HW_AI = 0,
HW_CV
};
enum XGF_DEPS_CAT {
INNER_DEPS = 0,
OUTER_DEPS,
PREVI_DEPS
};
struct xgf_sub_sect {
struct hlist_node hlist;
unsigned long long start_ts;
unsigned long long end_ts;
};
struct xgf_ema2_predictor {
/* data */
long long learn_rate;
long long beta;
long long epsilon;
long long alpha;
long long mu;
long long one;
long long L[N];
long long W[N];
long long RMSProp[N];
long long nabla[N];
long long rho[N];
long long x_record[N];
long long acc_x;
long long acc_xx[N + 1];
long long x_front[N];
long long xt_last;
long long xt_last_valid;
int record_idx;
long long ar_error_diff;
long long ar_coeff_sum;
bool ar_coeff_enable;
int ar_coeff_frames;
int acc_idx;
int coeff_shift;
int order;
long long t;
bool ar_coeff_valid;
int invalid_th;
unsigned int invalid_input_cnt;
unsigned int invalid_negative_output_cnt;
unsigned int skip_grad_update_cnt;
bool rmsprop_initialized;
bool x_record_initialized;
int err_code;
};
struct xgf_render {
struct hlist_node hlist;
pid_t parent;
pid_t render;
unsigned long long bufID;
struct hlist_head sector_head;
int sector_nr;
struct hlist_head hw_head;
int prev_index;
unsigned long long prev_ts;
int curr_index;
unsigned long long curr_ts;
int event_count;
int frame_count;
int u_wake_r;
int u_wake_r_count;
struct rb_root deps_list;
struct rb_root out_deps_list;
struct rb_root prev_deps_list;
struct xgf_sub_sect deque;
struct xgf_sub_sect queue;
unsigned long long ema_runtime;
unsigned long long pre_u_runtime;
unsigned long long u_runtime[XGF_MAX_UFRMAES];
unsigned long long u_avg_runtime;
unsigned long long u_runtime_sd;
int u_runtime_idx;
int spid;
int dep_frames;
int hwui_flag;
};
struct xgf_dep {
struct rb_node rb_node;
pid_t tid;
int render_dep;
int frame_idx;
};
struct xgf_runtime_sect {
struct hlist_node hlist;
unsigned long long start_ts;
unsigned long long end_ts;
};
struct xgf_render_sector {
struct hlist_node hlist;
int sector_id;
int counted;
struct hlist_head path_head;
unsigned long long head_ts;
unsigned long long tail_ts;
int head_index;
int tail_index;
int got_next_index;
int stop_at_irq;
int raw_head_index;
int raw_tail_index;
int special_rs;
};
struct xgf_pid_rec {
struct hlist_node hlist;
pid_t pid;
};
struct xgf_hw_rec {
struct hlist_node hlist;
unsigned long long mid;
int event_type;
int hw_type;
};
struct xgf_irq_stack {
int index;
int event;
struct xgf_irq_stack *next;
};
struct xgf_hw_event {
struct hlist_node hlist;
int event_type;
int event_index;
pid_t tid;
pid_t render;
unsigned long long mid;
int valid;
unsigned long long head_ts;
unsigned long long tail_ts;
};
struct xgf_spid {
struct hlist_node hlist;
char process_name[16];
char thread_name[16];
int pid;
int rpid;
int tid;
unsigned long long bufID;
int action;
};
extern int (*xgf_est_runtime_fp)(pid_t r_pid,
struct xgf_render *render,
unsigned long long *runtime,
unsigned long long ts);
extern int (*fpsgo_xgf2ko_calculate_target_fps_fp)(int pid,
unsigned long long bufID,
int *target_fps_margin,
unsigned long long cur_dequeue_start_ts,
unsigned long long cur_queue_end_ts);
extern void (*fpsgo_xgf2ko_do_recycle_fp)(int pid,
unsigned long long bufID);
extern long long (*xgf_ema2_predict_fp)(struct xgf_ema2_predictor *pt, long long X);
extern void (*xgf_ema2_init_fp)(struct xgf_ema2_predictor *pt);
void xgf_lockprove(const char *tag);
void xgf_trace(const char *fmt, ...);
void xgf_reset_renders(void);
int xgf_est_runtime(pid_t r_pid, struct xgf_render *render,
unsigned long long *runtime, unsigned long long ts);
void *xgf_alloc(int size);
void xgf_free(void *block);
void *xgf_atomic_val_assign(int select);
int *xgf_extra_sub_assign(void);
int *xgf_spid_sub_assign(void);
int xgf_atomic_read(atomic_t *val);
int xgf_atomic_inc_return(atomic_t *val);
void xgf_atomic_set(atomic_t *val, int i);
unsigned int xgf_cpumask_next(int cpu, const struct cpumask *srcp);
int xgf_num_possible_cpus(void);
int xgf_get_task_wake_cpu(struct task_struct *t);
int xgf_get_task_pid(struct task_struct *t);
long xgf_get_task_state(struct task_struct *t);
void notify_xgf_ko_ready(void);
unsigned long long xgf_get_time(void);
int xgf_dep_frames_mod(struct xgf_render *render, int pos);
struct xgf_dep *xgf_get_dep(pid_t tid, struct xgf_render *render,
int pos, int force);
void xgf_clean_deps_list(struct xgf_render *render, int pos);
int xgf_hw_events_update(int rpid, struct xgf_render *render);
void fpsgo_ctrl2xgf_switch_xgf(int val);
void fpsgo_ctrl2xgf_nn_job_begin(unsigned int tid, unsigned long long mid);
int fpsgo_ctrl2xgf_nn_job_end(unsigned int tid, unsigned long long mid);
int fpsgo_comp2xgf_qudeq_notify(int rpid, unsigned long long bufID, int cmd,
unsigned long long *run_time, unsigned long long *mid,
unsigned long long ts, int hwui_flag);
void fpsgo_fstb2xgf_do_recycle(int fstb_active);
void fpsgo_create_render_dep(void);
int has_xgf_dep(pid_t tid);
int uboost2xgf_get_info(int pid, unsigned long long bufID,
unsigned long long *timer_period, int *frame_idx);
int fpsgo_xgf2ko_calculate_target_fps(int pid, unsigned long long bufID,
int *target_fps_margin, unsigned long long cur_dequeue_start_ts,
unsigned long long cur_queue_end_ts);
void fpsgo_xgf2ko_do_recycle(int pid, unsigned long long bufID);
int xgf_get_display_rate(void);
int xgf_get_process_id(int pid);
int xgf_check_main_sf_pid(int pid, int process_id);
int xgf_check_specific_pid(int pid);
void xgf_set_logical_render_runtime(int pid, unsigned long long bufID,
unsigned long long l_runtime, unsigned long long r_runtime);
void xgf_set_logical_render_info(int pid, unsigned long long bufID,
int *l_arr, int l_num, int *r_arr, int r_num,
unsigned long long l_start_ts,
unsigned long long f_start_ts);
void xgf_set_timer_info(int pid, unsigned long long bufID,
int hrtimer_pid, int hrtimer_flag,
unsigned long long hrtimer_ts, unsigned long long prev_queue_end_ts);
long long xgf_ema2_predict(struct xgf_ema2_predictor *pt, long long X);
void xgf_ema2_init(struct xgf_ema2_predictor *pt);
enum XGF_EVENT {
SCHED_SWITCH,
SCHED_WAKEUP,
IPI_RAISE,
IPI_ENTRY,
IPI_EXIT,
IRQ_ENTRY,
IRQ_EXIT,
SOFTIRQ_ENTRY,
SOFTIRQ_EXIT,
SCHED_WAKING,
HRTIMER_ENTRY,
HRTIMER_EXIT
};
struct xgf_trace_event {
unsigned long long ts;
int event;
int cpu;
union {
int prev_pid;
int pid;
int target_cpu;
int irqnr;
int none;
};
union {
int note;
};
};
struct fstb_trace_event {
unsigned long long ts;
int event;
int cpu;
int note;
int state;
int pid;
};
extern struct xgf_trace_event *xgf_event_data;
extern void *xgf_event_index;
extern void *xgf_ko_enabled;
extern int xgf_max_events;
extern struct fstb_trace_event *fstb_event_data;
extern atomic_t fstb_event_data_idx;
extern int fstb_event_buffer_size;
extern int fstb_frame_num;
extern int fstb_no_stable_thr;
extern int fstb_no_stable_multiple;
extern int fstb_no_stable_multiple_eara;
extern int fstb_is_eara_active;
extern int fstb_can_update_thr;
extern int fstb_target_fps_margin_low_fps;
extern int fstb_target_fps_margin_high_fps;
extern int fstb_separate_runtime_enable;
extern int fstb_fps_num;
extern int fstb_fps_choice[];
int __init init_xgf(void);
extern int (*xgff_est_runtime_fp)(pid_t r_pid,
struct xgf_render *render,
unsigned long long *runtime,
unsigned long long ts);
int xgff_est_runtime(pid_t r_pid, struct xgf_render *render,
unsigned long long *runtime, unsigned long long ts);
extern int (*xgff_update_start_prev_index_fp)(struct xgf_render *render);
int xgff_update_start_prev_index(struct xgf_render *render);
void xgff_clean_deps_list(struct xgf_render *render, int pos);
int xgff_dep_frames_mod(struct xgf_render *render, int pos);
struct xgf_dep *xgff_get_dep(
pid_t tid, struct xgf_render *render, int pos, int force);
#endif
@@ -0,0 +1,237 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/cpumask.h>
#include <linux/soc/mediatek/mtk-pm-qos.h>
#include <linux/of.h>
static struct mtk_pm_qos_request dram_req;
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
static int fbt_get_dts_value(char *name)
{
struct device_node *node = NULL;
int value = 0;
int ret = 0;
node = of_find_compatible_node(NULL, NULL, "mediatek,performance_fpsgo");
if (node)
ret = of_property_read_u32(node, name, &value);
return value;
}
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
if (reg) {
if (!mtk_pm_qos_request_active(&dram_req))
mtk_pm_qos_add_request(&dram_req, MTK_PM_QOS_DDR_OPP,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (mtk_pm_qos_request_active(&dram_req))
mtk_pm_qos_remove_request(&dram_req);
}
}
void fbt_boost_dram(int boost)
{
if (!mtk_pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!mtk_pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
mtk_pm_qos_update_request(&dram_req, 0);
else
mtk_pm_qos_update_request(&dram_req,
MTK_PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (!pid)
return;
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
struct device_node *node;
int cpu_mask_num = 0;
int ret = 0;
int num[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int i = 0;
node = of_find_compatible_node(NULL, NULL, "mediatek,performance_misc");
if (node) {
ret = of_property_read_u32(node, "fbt_cpu_mask_num", &cpu_mask_num);
if (ret)
return -1;
ret = of_property_read_u32_array(node, "fbt_cpu_mask", num, cpu_mask_num);
if (ret)
return -1;
}
if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
for (i = 0; i < cpu_mask_num; i++)
cpumask_set_cpu(num[i], cpu_mask);
} else if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
for (i = 0; i < cpu_mask_num; i++)
cpumask_clear_cpu(num[i], cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_cluster_num(void)
{
return fbt_get_dts_value("l_cluster_num");
}
int fbt_get_L_min_ceiling(void)
{
return fbt_get_dts_value("l_min_ceiling");
}
int fbt_get_default_boost_ta(void)
{
return fbt_get_dts_value("default_boost_ta");
}
int fbt_get_default_adj_loading(void)
{
return fbt_get_dts_value("default_adj_loading");
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return fbt_get_dts_value("cluster_limit");
}
int fbt_get_l_min_bhropp(void)
{
return fbt_get_dts_value("l_min_bhropp");
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_default_uboost(void)
{
return fbt_get_dts_value("default_uboost");
}
int fbt_get_default_qr_enable(void)
{
return fbt_get_dts_value("default_qr_enable");
}
int fbt_get_default_gcc_enable(void)
{
return fbt_get_dts_value("default_gcc_enable");
}
@@ -0,0 +1,172 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include "eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <fpsgo_common.h>
#include <linux/pm_qos.h>
#include <mtk_vcorefs_governor.h>
#include <mtk_vcorefs_manager.h>
#include <mach/mtk_ppm_api.h>
#include <linux/cpumask.h>
int ultra_req;
int cm_req;
/*
* cpi_uclamp_thres = 123500000 / 149500000 * 100
*/
static int cpi_thres = 250;
static unsigned int cpi_uclamp_thres = 82;
void fbt_notify_CM_limit(int reach_limit)
{
}
void fbt_reg_dram_request(int reg)
{
}
void fbt_dram_arbitration(void)
{
int ret = -1;
if (cm_req || ultra_req)
ret = vcorefs_request_dvfs_opp(KIR_FBT, 0);
else
ret = vcorefs_request_dvfs_opp(KIR_FBT, -1);
if (ret < 0)
fpsgo_systrace_c_fbt_gm(-100, 0, ret,
"fbt_dram_arbitration_ret");
fpsgo_systrace_c_fbt_gm(-100, 0, cm_req, "cm_req");
fpsgo_systrace_c_fbt_gm(-100, 0, ultra_req, "ultra_req");
}
void fbt_boost_dram(int boost)
{
if (boost == ultra_req)
return;
ultra_req = boost;
fbt_dram_arbitration();
}
void fbt_set_boost_value(unsigned int base_blc)
{
int cpi = 0;
base_blc = clamp(base_blc, 1U, 100U);
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
/* single cluster for mt6739 */
cpi = ppm_get_cluster_cpi(0);
fpsgo_systrace_c_fbt_gm(-100, 0, cpi, "cpi");
cm_req = base_blc > cpi_uclamp_thres && cpi > cpi_thres;
fbt_dram_arbitration();
}
void fbt_clear_boost_value(void)
{
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
cm_req = 0;
ultra_req = 0;
fbt_notify_CM_limit(0);
fbt_dram_arbitration();
}
/*
* mt6739 use boost_ta to support CM optimize.
* per-task uclamp doesn't support CM optimize.
*/
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (!pid)
return;
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 1;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 0;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
@@ -0,0 +1,216 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "mt-plat/eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <mt-plat/fpsgo_common.h>
//#include "mtk_cm_mgr_common.h"
#define API_READY 0
#if API_READY
static struct pm_qos_request dram_req;
#endif
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
#if API_READY
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, PM_QOS_DDR_OPP,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
#endif
}
void fbt_boost_dram(int boost)
{
#if API_READY
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
#endif
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (!pid)
return;
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(4, cpu_mask);
cpumask_set_cpu(5, cpu_mask);
cpumask_set_cpu(6, cpu_mask);
cpumask_set_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(4, cpu_mask);
cpumask_clear_cpu(5, cpu_mask);
cpumask_clear_cpu(6, cpu_mask);
cpumask_clear_cpu(7, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_cluster_num(void)
{
return 0;
}
int fbt_get_L_min_ceiling(void)
{
return 0;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 0;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
@@ -0,0 +1,218 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "mt-plat/eas_ctrl.h"
#include "fbt_cpu_platform.h"
#include <mt-plat/fpsgo_common.h>
#define API_READY 0
#if API_READY
static struct pm_qos_request dram_req;
#endif
static struct cpumask mask[FPSGO_PREFER_TOTAL];
static int mask_done;
void fbt_notify_CM_limit(int reach_limit)
{
#ifdef CONFIG_MTK_CM_MGR
cm_mgr_perf_set_status(reach_limit);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, reach_limit, "notify_cm");
}
void fbt_reg_dram_request(int reg)
{
#if API_READY
if (reg) {
if (!pm_qos_request_active(&dram_req))
pm_qos_add_request(&dram_req, PM_QOS_DDR_OPP,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
} else {
if (pm_qos_request_active(&dram_req))
pm_qos_remove_request(&dram_req);
}
#endif
}
void fbt_boost_dram(int boost)
{
#if API_READY
if (!pm_qos_request_active(&dram_req)) {
fbt_reg_dram_request(1);
if (!pm_qos_request_active(&dram_req)) {
fpsgo_systrace_c_fbt_gm(-100, 0, -1, "dram_boost");
return;
}
}
if (boost)
pm_qos_update_request(&dram_req, 0);
else
pm_qos_update_request(&dram_req,
PM_QOS_DDR_OPP_DEFAULT_VALUE);
fpsgo_systrace_c_fbt_gm(-100, 0, boost, "dram_boost");
#endif
}
void fbt_set_boost_value(unsigned int base_blc)
{
base_blc = clamp(base_blc, 1U, 100U);
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, (int)base_blc);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, base_blc, "TA_cap");
}
void fbt_clear_boost_value(void)
{
#if defined(CONFIG_UCLAMP_TASK_GROUP) && defined(CONFIG_SCHED_TUNE)
update_eas_uclamp_min(EAS_UCLAMP_KIR_FPSGO, CGROUP_TA, 0);
#endif
fpsgo_systrace_c_fbt_gm(-100, 0, 0, "TA_cap");
fbt_notify_CM_limit(0);
fbt_boost_dram(0);
}
void fbt_set_per_task_min_cap(int pid, unsigned int base_blc)
{
int ret = -1;
unsigned int base_blc_1024;
if (!pid)
return;
base_blc_1024 = (base_blc << 10) / 100U;
base_blc_1024 = clamp(base_blc_1024, 1U, 1024U);
#ifdef CONFIG_UCLAMP_TASK
ret = set_task_util_min(pid, base_blc_1024);
#endif
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "uclamp fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "uclamp fail");
return;
}
fpsgo_systrace_c_fbt_gm(pid, 0, base_blc, "min_cap");
}
static int generate_cpu_mask(unsigned int prefer_type, struct cpumask *cpu_mask)
{
if (prefer_type == FPSGO_PREFER_BIG) {
cpumask_clear(cpu_mask);
cpumask_set_cpu(0, cpu_mask);
cpumask_set_cpu(1, cpu_mask);
cpumask_set_cpu(2, cpu_mask);
cpumask_set_cpu(3, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_LITTLE) {
cpumask_setall(cpu_mask);
cpumask_clear_cpu(0, cpu_mask);
cpumask_clear_cpu(1, cpu_mask);
cpumask_clear_cpu(2, cpu_mask);
cpumask_clear_cpu(3, cpu_mask);
} else if (prefer_type == FPSGO_PREFER_NONE)
cpumask_setall(cpu_mask);
else
return -1;
mask_done = 1;
return 0;
}
void fbt_set_affinity(pid_t pid, unsigned int prefer_type)
{
long ret;
if (!mask_done) {
generate_cpu_mask(FPSGO_PREFER_LITTLE,
&mask[FPSGO_PREFER_LITTLE]);
generate_cpu_mask(FPSGO_PREFER_BIG, &mask[FPSGO_PREFER_BIG]);
generate_cpu_mask(FPSGO_PREFER_NONE, &mask[FPSGO_PREFER_NONE]);
}
ret = sched_setaffinity(pid, &mask[prefer_type]);
if (ret != 0) {
fpsgo_systrace_c_fbt(pid, 0, ret, "setaffinity fail");
fpsgo_systrace_c_fbt(pid, 0, 0, "setaffinity fail");
return;
}
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_affinity");
}
void fbt_set_cpu_prefer(int pid, unsigned int prefer_type)
{
#if defined(CONFIG_MTK_SCHED_CPU_PREFER)
long ret;
if (!pid)
return;
ret = sched_set_cpuprefer(pid, prefer_type);
fpsgo_systrace_c_fbt(pid, 0, prefer_type, "set_cpuprefer");
#endif
}
int fbt_get_L_cluster_num(void)
{
return 1;
}
int fbt_get_L_min_ceiling(void)
{
return 1100000;
}
int fbt_get_default_boost_ta(void)
{
return 0;
}
int fbt_get_default_adj_loading(void)
{
return 0;
}
int fbt_get_default_adj_count(void)
{
return 30;
}
int fbt_get_default_adj_tdiff(void)
{
return 2000000;
}
int fbt_get_cluster_limit(int *cluster, int *freq, int *r_freq)
{
return 0;
}
int fbt_get_default_uboost(void)
{
return 0;
}
int fbt_get_default_qr_enable(void)
{
return 0;
}
int fbt_get_default_gcc_enable(void)
{
return 0;
}
int fbt_get_l_min_bhropp(void)
{
return 0;
}
Loaded 100 of 80519 files, more files were not shown because too many files have changed in this diff. Show more