/*
|
* drivers/cpufreq/sunxi_autohotplug.c
|
*
|
* Copyright (C) 2016-2020 Allwinnertech.
|
* East Yang <yangdong@allwinnertech.com>
|
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* 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.
|
*/
|
|
#include <linux/cpumask.h>
|
#include <linux/cpufreq.h>
|
#include <linux/module.h>
|
#include "autohotplug.h"
|
|
#include <trace/events/autohotplug.h>
|
|
#if defined(CONFIG_SCHED_HMP) || defined(CONFIG_SCHED_SMP_DCMP)
|
static unsigned int load_save_up = 60;
|
static unsigned int little_core_coop_min_freq = 600000;
|
|
#ifdef CONFIG_SCHED_HMP
|
static unsigned long cpu_boost_lasttime;
|
static unsigned int load_try_boost = 90;
|
static unsigned int load_save_big_up = 80;
|
static unsigned int load_lastbig_stable_us = 1500000;
|
static unsigned int load_boost_stable_us = 200000;
|
static unsigned int cpu_boost_last_hold_us = 3000000;
|
int hmp_cluster0_is_big;
|
#endif
|
#endif
|
|
static int is_cpu_load_stable(unsigned int cpu, int stable_type)
|
{
|
int ret;
|
|
if (cpu >= CONFIG_NR_CPUS)
|
return 0;
|
|
if (stable_type == STABLE_DOWN)
|
ret = time_after_eq(jiffies, cpu_up_lasttime +
|
usecs_to_jiffies(load_down_stable_us));
|
else if (stable_type == STABLE_UP)
|
ret = time_after_eq(jiffies, cpu_up_lasttime +
|
usecs_to_jiffies(load_up_stable_us));
|
#if defined(CONFIG_SCHED_HMP)
|
else if (stable_type == STABLE_BOOST)
|
ret = time_after_eq(jiffies, cpu_up_lasttime +
|
usecs_to_jiffies(load_boost_stable_us));
|
else if (stable_type == STABLE_LAST_BIG)
|
ret = time_after_eq(jiffies, cpu_up_lasttime +
|
usecs_to_jiffies(load_lastbig_stable_us));
|
#endif
|
else
|
return 0;
|
|
trace_autohotplug_stable(ret);
|
return ret;
|
}
|
|
#if defined(CONFIG_SCHED_HMP)
|
static int autohotplug_smart_try_up_hmp_normal(
|
struct autohotplug_loadinfo *load)
|
{
|
unsigned int tmp = CONFIG_NR_CPUS;
|
int big_nr, little_nr, ret;
|
|
if ((load->max_load != INVALID_LOAD)
|
&& (load->max_load >= load_try_up)
|
&& is_cpu_load_stable(load->max_cpu, STABLE_UP)) {
|
if (load->max_load >= load_try_boost) {
|
if (get_bigs_under(load, load_save_up, NULL))
|
return 0;
|
|
get_cpus_online(load, &little_nr, &big_nr);
|
if (big_nr != 0) {
|
if (try_up_big())
|
ret = 1;
|
else
|
ret = try_up_little();
|
|
if (ret)
|
cpu_boost_lasttime = jiffies;
|
|
return ret;
|
}
|
|
if (try_up_little())
|
ret = 1;
|
else
|
ret = try_up_big();
|
|
if (ret)
|
cpu_boost_lasttime = jiffies;
|
|
return ret;
|
}
|
|
if (get_cpus_under(load, load_save_up, &tmp))
|
return 0;
|
|
if (try_up_little())
|
return 1;
|
|
if (get_cpus_under(load, load_save_big_up, NULL))
|
return 0;
|
|
return try_up_big();
|
}
|
|
return 0;
|
}
|
|
static int autohotplug_smart_try_down_hmp_normal(
|
struct autohotplug_loadinfo *load)
|
{
|
unsigned int to_down = CONFIG_NR_CPUS;
|
unsigned int on_boost = CONFIG_NR_CPUS;
|
|
if (get_cpus_under(load, load_try_down, &to_down, 0) >= 1) {
|
if (time_before(jiffies, cpu_boost_lasttime +
|
usecs_to_jiffies(cpu_boost_last_hold_us)))
|
return 0;
|
if (get_bigs_under(load, load_try_down, &to_down) >= 2)
|
return do_cpu_down(to_down);
|
else if (get_littles_under(load, load_try_down, &to_down) > 1)
|
return do_cpu_down(to_down);
|
else if (get_bigs_under(load, load_try_down, &to_down) == 1
|
&& !(get_bigs_above(load, load_try_boost,
|
&on_boost)
|
&& is_cpu_load_stable(on_boost, STABLE_BOOST))
|
&& (load->cpu_load[to_down] <=
|
load->big_min_load)
|
&& is_cpu_load_stable(to_down, STABLE_LAST_BIG))
|
return do_cpu_down(to_down);
|
else
|
return 0;
|
} else {
|
return 0;
|
}
|
}
|
|
static void autohotplug_smart_try_freq_limit_hmp_normal(void)
|
{
|
int i, big_cpu = CONFIG_NR_CPUS;
|
struct cpufreq_policy *policy = cpufreq_cpu_get(0);
|
|
for_each_online_cpu(i) {
|
if (is_cpu_big(i)) {
|
big_cpu = i;
|
break;
|
}
|
}
|
|
if (big_cpu != CONFIG_NR_CPUS) {
|
if (policy) {
|
if (policy->min < little_core_coop_min_freq) {
|
policy->user_policy.min =
|
little_core_coop_min_freq;
|
cpufreq_update_policy(0);
|
}
|
cpufreq_cpu_put(policy);
|
}
|
} else {
|
if (policy) {
|
if (policy->min > policy->cpuinfo.min_freq) {
|
policy->user_policy.min =
|
policy->cpuinfo.min_freq;
|
cpufreq_update_policy(0);
|
}
|
cpufreq_cpu_put(policy);
|
}
|
}
|
}
|
#endif
|
|
#if defined(CONFIG_SCHED_HMP) || defined(CONFIG_SCHED_SMP_DCMP)
|
static int autohotplug_smart_try_up_hmp_simple(
|
struct autohotplug_loadinfo *load)
|
{
|
int ret = 0;
|
unsigned int first;
|
|
if (!get_cpus_under(load, load_save_up, &first)
|
&& is_cpu_load_stable(load->max_cpu, STABLE_UP)) {
|
if (try_up_big()) {
|
ret = 1;
|
} else {
|
ret = try_up_little();
|
}
|
}
|
|
return ret;
|
}
|
|
static int autohotplug_smart_try_down_hmp_simple(
|
struct autohotplug_loadinfo *load)
|
{
|
int big_nr, little_nr;
|
unsigned int first, to_down;
|
|
get_cpus_online(load, &little_nr, &big_nr);
|
if (get_cpus_under(load, load_try_down, &first) >= 2
|
&& is_cpu_load_stable(first, STABLE_DOWN)) {
|
if (little_nr) {
|
if (get_littles_under(load, load_try_down * 2,
|
&to_down))
|
return do_cpu_down(to_down);
|
} else {
|
return do_cpu_down(first);
|
}
|
}
|
|
return 0;
|
}
|
|
#if defined(CONFIG_SCHED_HMP)
|
static void autohotplug_smart_try_freq_limit_hmp_simple(void)
|
{
|
struct cpufreq_policy *policy1 = NULL;
|
struct cpufreq_policy *policy2 = NULL;
|
int i, big_nr = 0, little_nr = 0, big = 0, little = 0;
|
|
for_each_online_cpu(i) {
|
if (is_cpu_little(i)) {
|
little_nr++;
|
little = i;
|
} else {
|
big = i;
|
big_nr++;
|
}
|
}
|
|
if (little_nr && big_nr) {
|
policy1 = cpufreq_cpu_get(big);
|
if (policy1 && policy1->min < little_core_coop_min_freq) {
|
policy1->user_policy.min = little_core_coop_min_freq;
|
cpufreq_update_policy(big);
|
}
|
|
policy2 = cpufreq_cpu_get(little);
|
if (policy2 && policy2->min < little_core_coop_min_freq) {
|
policy2->user_policy.min = little_core_coop_min_freq;
|
cpufreq_update_policy(little);
|
}
|
} else if (big_nr) {
|
policy1 = cpufreq_cpu_get(big);
|
if (policy1 && policy1->min < little_core_coop_min_freq) {
|
policy1->user_policy.min = little_core_coop_min_freq;
|
cpufreq_update_policy(big);
|
}
|
} else if (little_nr) {
|
policy2 = cpufreq_cpu_get(little);
|
if (policy2 && policy2->min < little_core_coop_min_freq) {
|
policy2->user_policy.min = little_core_coop_min_freq;
|
cpufreq_update_policy(little);
|
}
|
}
|
|
if (policy1)
|
cpufreq_cpu_put(policy1);
|
if (policy2)
|
cpufreq_cpu_put(policy2);
|
}
|
#endif
|
#endif
|
|
#if !defined(CONFIG_SCHED_HMP) && !defined(CONFIG_SCHED_SMP_DCMP)
|
static int autohotplug_smart_try_up_smp_normal(
|
struct autohotplug_loadinfo *load)
|
{
|
unsigned int first;
|
|
if (!get_cpus_under(load, load_try_up, &first)
|
&& is_cpu_load_stable(load->max_cpu, STABLE_UP))
|
return try_up_little();
|
|
return 0;
|
}
|
|
static int autohotplug_smart_try_down_smp_normal(
|
struct autohotplug_loadinfo *load)
|
{
|
unsigned int first;
|
|
if (get_cpus_under(load, load_try_down, &first) >= 2
|
&& is_cpu_load_stable(first, STABLE_DOWN))
|
return do_cpu_down(first);
|
|
return 0;
|
}
|
#endif
|
|
static int autohotplug_smart_get_fast_slow_cpus(struct cpumask *fast,
|
struct cpumask *slow)
|
{
|
#if defined(CONFIG_SCHED_HMP)
|
arch_get_fast_and_slow_cpus(fast, slow);
|
|
if (cpumask_test_cpu(0, fast))
|
hmp_cluster0_is_big = 1;
|
else
|
hmp_cluster0_is_big = 0;
|
|
if (hmp_cluster0_is_big) {
|
autohotplug_smart.try_up = autohotplug_smart_try_up_hmp_simple;
|
autohotplug_smart.try_down =
|
autohotplug_smart_try_down_hmp_simple;
|
autohotplug_smart.try_freq_limit =
|
autohotplug_smart_try_freq_limit_hmp_simple;
|
} else {
|
autohotplug_smart.try_up = autohotplug_smart_try_up_hmp_normal;
|
autohotplug_smart.try_down =
|
autohotplug_smart_try_down_hmp_normal;
|
autohotplug_smart.try_freq_limit =
|
autohotplug_smart_try_freq_limit_hmp_normal;
|
}
|
#elif defined(CONFIG_SCHED_SMP_DCMP)
|
if (strlen(CONFIG_CLUSTER0_CPU_MASK) &&
|
strlen(CONFIG_CLUSTER1_CPU_MASK)) {
|
if (cpulist_parse(CONFIG_CLUSTER0_CPU_MASK, fast)) {
|
pr_err("Failed to parse cluster0 cpu mask!\n");
|
return -1;
|
}
|
|
if (cpulist_parse(CONFIG_CLUSTER1_CPU_MASK, slow)) {
|
pr_err("Failed to parse cluster1 cpu mask!\n");
|
return -1;
|
}
|
}
|
autohotplug_smart.try_up = autohotplug_smart_try_up_hmp_simple;
|
autohotplug_smart.try_down = autohotplug_smart_try_down_hmp_simple;
|
#else
|
cpumask_copy(slow, cpu_possible_mask);
|
autohotplug_smart.try_up = autohotplug_smart_try_up_smp_normal;
|
autohotplug_smart.try_down = autohotplug_smart_try_down_smp_normal;
|
#endif
|
|
return 0;
|
}
|
|
static void autohotplug_smart_init_attr(void)
|
{
|
#if defined(CONFIG_SCHED_HMP) || defined(CONFIG_SCHED_SMP_DCMP)
|
autohotplug_attr_add("little_min_freq", &little_core_coop_min_freq,
|
0644, NULL, NULL);
|
autohotplug_attr_add("save_all_up_load", &load_save_up,
|
0644, NULL, NULL);
|
#ifdef CONFIG_SCHED_HMP
|
autohotplug_attr_add("try_boost_load", &load_try_boost,
|
0644, NULL, NULL);
|
autohotplug_attr_add("save_big_up_load", &load_save_big_up,
|
0644, NULL, NULL);
|
autohotplug_attr_add("stable_boost_us", &load_boost_stable_us,
|
0644, NULL, NULL);
|
autohotplug_attr_add("stable_last_big_us", &load_lastbig_stable_us,
|
0644, NULL, NULL);
|
autohotplug_attr_add("hold_last_boost_us", &cpu_boost_last_hold_us,
|
0644, NULL, NULL);
|
#endif
|
#endif
|
}
|
|
struct autohotplug_governor autohotplug_smart = {
|
.init_attr = autohotplug_smart_init_attr,
|
.get_fast_and_slow_cpus = autohotplug_smart_get_fast_slow_cpus,
|
};
|
|
MODULE_DESCRIPTION("SUNXI autohotplug");
|
MODULE_LICENSE("GPL");
|
