From c8262291615813508669b7d3ff1ddf601691c264 Mon Sep 17 00:00:00 2001 From: Bryan Stine Date: Tue, 26 Jan 2010 18:58:42 -0500 Subject: [PATCH] Import msm7k cpufreq governor from heroc kernel. Update kernel config to set msm7k governor to default, matching the values in heroc's kernel config. --- arch/arm/configs/htc_msm_android_defconfig | 15 +- arch/arm/mach-msm/Kconfig | 9 +- arch/arm/mach-msm/acpuclock.c | 6 +- arch/arm/mach-msm/cpufreq.c | 6 +- drivers/cpufreq/Kconfig | 17 + drivers/cpufreq/Makefile | 1 + drivers/cpufreq/cpufreq_msm7k.c | 684 ++++++++++++++++++++++++++++ include/linux/cpufreq.h | 3 + 8 files changed, 729 insertions(+), 12 deletions(-) create mode 100644 drivers/cpufreq/cpufreq_msm7k.c diff --git a/arch/arm/configs/htc_msm_android_defconfig b/arch/arm/configs/htc_msm_android_defconfig index ddf6c33..beea2e3 100644 --- a/arch/arm/configs/htc_msm_android_defconfig +++ b/arch/arm/configs/htc_msm_android_defconfig @@ -1,7 +1,7 @@ # # Automatically generated make config: don't edit # Linux kernel version: 2.6.27 -# Wed Jan 20 23:11:55 2010 +# Tue Jan 26 18:54:52 2010 # CONFIG_ARM=y CONFIG_SYS_SUPPORTS_APM_EMULATION=y @@ -242,10 +242,11 @@ CONFIG_MSM_SMD_7500=y CONFIG_MSM_ONCRPCROUTER=y CONFIG_MSM_RPCSERVERS=y CONFIG_MSM_CPU_FREQ=y -CONFIG_MSM_CPU_FREQ_ONDEMAND=y +# CONFIG_MSM_CPU_FREQ_ONDEMAND is not set +CONFIG_MSM_CPU_FREQ_MSM7K=y # CONFIG_MSM_CPU_FREQ_SCREEN is not set CONFIG_MSM_CPU_FREQ_ONDEMAND_MAX=528000 -CONFIG_MSM_CPU_FREQ_ONDEMAND_MIN=128000 +CONFIG_MSM_CPU_FREQ_ONDEMAND_MIN=245760 CONFIG_MSM_HW3D=y CONFIG_MSM_ADSP=y # CONFIG_HTC_FB_CONSOLE is not set @@ -335,15 +336,17 @@ CONFIG_CPU_FREQ_STAT=y # CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE is not set # CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set # CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set -CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y +# CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND is not set # CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set +CONFIG_CPU_FREQ_DEFAULT_GOV_MSM7K=y CONFIG_CPU_FREQ_GOV_PERFORMANCE=y # CONFIG_CPU_FREQ_GOV_POWERSAVE is not set # CONFIG_CPU_FREQ_GOV_USERSPACE is not set CONFIG_CPU_FREQ_GOV_ONDEMAND=y # CONFIG_CPU_FREQ_GOV_CONSERVATIVE is not set -CONFIG_CPU_FREQ_MIN_TICKS=10 -CONFIG_CPU_FREQ_SAMPLING_LATENCY_MULTIPLIER=1000 +CONFIG_CPU_FREQ_GOV_MSM7K=y +CONFIG_CPU_FREQ_MIN_TICKS=2 +CONFIG_CPU_FREQ_SAMPLING_LATENCY_MULTIPLIER=500 # # Floating point emulation diff --git a/arch/arm/mach-msm/Kconfig b/arch/arm/mach-msm/Kconfig index 4df8fbf..c984b97 100644 --- a/arch/arm/mach-msm/Kconfig +++ b/arch/arm/mach-msm/Kconfig @@ -353,17 +353,22 @@ config MSM_RPCSERVERS config MSM_CPU_FREQ bool - default y if MSM_CPU_FREQ_ONDEMAND || MSM_CPU_FREQ_SCREEN + default y if MSM_CPU_FREQ_ONDEMAND || MSM_CPU_FREQ_SCREEN || MSM_CPU_FREQ_MSM7K choice prompt "Cpufreq mode" default MSM_CPU_FREQ_ONDEMAND + default MSM_CPU_FREQ_MSM7K default MSM_CPU_FREQ_SCREEN config MSM_CPU_FREQ_ONDEMAND depends on CPU_FREQ_DEFAULT_GOV_ONDEMAND bool "Enable ONDEMAND cpufreq govoner for" + config MSM_CPU_FREQ_MSM7K + depends on CPU_FREQ_DEFAULT_GOV_MSM7K + bool "Enable MSM7K cpufreq governor for" + config MSM_CPU_FREQ_SCREEN depends on HAS_EARLYSUSPEND bool "Enable simple cpu frequency scaling" @@ -385,7 +390,7 @@ config MSM_CPU_FREQ_SCREEN_ON endif # MSM_CPU_FREQ_SCREEN -if MSM_CPU_FREQ_ONDEMAND +if MSM_CPU_FREQ_ONDEMAND || MSM_CPU_FREQ_MSM7K config MSM_CPU_FREQ_ONDEMAND_MAX int "Max" diff --git a/arch/arm/mach-msm/acpuclock.c b/arch/arm/mach-msm/acpuclock.c index ce5a860..a855a63 100644 --- a/arch/arm/mach-msm/acpuclock.c +++ b/arch/arm/mach-msm/acpuclock.c @@ -119,7 +119,8 @@ static struct clkctl_acpu_speed acpu_freq_tbl[] = { }; #endif -#ifdef CONFIG_MSM_CPU_FREQ_ONDEMAND +#if defined(CONFIG_MSM_CPU_FREQ_ONDEMAND) || \ + defined(CONFIG_MSM_CPU_FREQ_MSM7K) static struct cpufreq_frequency_table freq_table[] = { { 0, 19200 }, { 1, 122880 }, @@ -498,7 +499,8 @@ void __init msm_acpu_clock_init(struct msm_acpu_clock_platform_data *clkdata) drv_state.wait_for_irq_khz = clkdata->wait_for_irq_khz; acpuclk_init(); lpj_init(); -#ifdef CONFIG_MSM_CPU_FREQ_ONDEMAND +#if defined(CONFIG_MSM_CPU_FREQ_ONDEMAND) || \ + defined(CONFIG_MSM_CPU_FREQ_MSM7K) cpufreq_frequency_table_get_attr(freq_table, smp_processor_id()); #endif } diff --git a/arch/arm/mach-msm/cpufreq.c b/arch/arm/mach-msm/cpufreq.c index 729391c..c0d402c 100644 --- a/arch/arm/mach-msm/cpufreq.c +++ b/arch/arm/mach-msm/cpufreq.c @@ -21,7 +21,8 @@ #include #include "acpuclock.h" -#ifdef CONFIG_MSM_CPU_FREQ_ONDEMAND +#if defined(CONFIG_MSM_CPU_FREQ_ONDEMAND) || \ + defined(CONFIG_MSM_CPU_FREQ_MSM7K) #include #endif @@ -46,7 +47,8 @@ static int __init clock_late_init(void) } late_initcall(clock_late_init); -#elif defined(CONFIG_MSM_CPU_FREQ_ONDEMAND) +#elif defined(CONFIG_MSM_CPU_FREQ_ONDEMAND) || \ + defined(CONFIG_MSM_CPU_FREQ_MSM7K) static int msm_cpufreq_target(struct cpufreq_policy *policy, unsigned int target_freq, diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig index e9361a9..987b0e7 100644 --- a/drivers/cpufreq/Kconfig +++ b/drivers/cpufreq/Kconfig @@ -110,6 +110,15 @@ config CPU_FREQ_DEFAULT_GOV_CONSERVATIVE Be aware that not all cpufreq drivers support the conservative governor. If unsure have a look at the help section of the driver. Fallback governor will be the performance governor. + +config CPU_FREQ_DEFAULT_GOV_MSM7K + bool "msm7k" + select CPU_FREQ_GOV_MSM7K + select CPU_FREQ_GOV_PERFORMANCE + help + The msm7k governor is based on the conservative governor + with some hacks specific to the msm7k. + endchoice config CPU_FREQ_GOV_PERFORMANCE @@ -190,6 +199,14 @@ config CPU_FREQ_GOV_CONSERVATIVE If in doubt, say N. +config CPU_FREQ_GOV_MSM7K + tristate "'msm7k' cpufreq governor" + select CPU_FREQ_TABLE + depends on CPU_FREQ + help + based on 'conservative' with some msm7k specific hacks which + are not appropriate for the general conservative driver. + config CPU_FREQ_MIN_TICKS int "Ticks between governor polling interval." default 10 diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile index 71fc3b4..e2fa8c0 100644 --- a/drivers/cpufreq/Makefile +++ b/drivers/cpufreq/Makefile @@ -9,6 +9,7 @@ obj-$(CONFIG_CPU_FREQ_GOV_POWERSAVE) += cpufreq_powersave.o obj-$(CONFIG_CPU_FREQ_GOV_USERSPACE) += cpufreq_userspace.o obj-$(CONFIG_CPU_FREQ_GOV_ONDEMAND) += cpufreq_ondemand.o obj-$(CONFIG_CPU_FREQ_GOV_CONSERVATIVE) += cpufreq_conservative.o +obj-$(CONFIG_CPU_FREQ_GOV_MSM7K) += cpufreq_msm7k.o # CPUfreq cross-arch helpers obj-$(CONFIG_CPU_FREQ_TABLE) += freq_table.o diff --git a/drivers/cpufreq/cpufreq_msm7k.c b/drivers/cpufreq/cpufreq_msm7k.c new file mode 100644 index 0000000..3551e72 --- /dev/null +++ b/drivers/cpufreq/cpufreq_msm7k.c @@ -0,0 +1,684 @@ +/* + * drivers/cpufreq/cpufreq_msm7k.c + * + * Copyright (C) 2001 Russell King + * (C) 2003 Venkatesh Pallipadi . + * Jun Nakajima + * (C) 2004 Alexander Clouter + * + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +/* + * dbs is used in this file as a shortform for demandbased switching + * It helps to keep variable names smaller, simpler + */ + +#define DEF_FREQUENCY_UP_THRESHOLD (80) +#define DEF_FREQUENCY_DOWN_THRESHOLD (20) + +#define SWEET_SPOT_THRESHOLD 8 +/* + * * * Index in the cpufreq_frequency_table for the sweet spot. + * * This is ALWAYS the speed step 1 below policy max speed. + * */ +static int sweet_spot_index; + +/* + * The polling frequency of this governor depends on the capability of + * the processor. Default polling frequency is 1000 times the transition + * latency of the processor. The governor will work on any processor with + * transition latency <= 10mS, using appropriate sampling + * rate. + * For CPUs with transition latency > 10mS (mostly drivers + * with CPUFREQ_ETERNAL), this governor will not work. + * All times here are in uS. + */ +static unsigned int def_sampling_rate; +#define MIN_SAMPLING_RATE_RATIO (2) +/* for correct statistics, we need at least 10 ticks between each measure */ +#define MIN_STAT_SAMPLING_RATE \ + (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(CONFIG_CPU_FREQ_MIN_TICKS)) +#define MIN_SAMPLING_RATE \ + (def_sampling_rate / MIN_SAMPLING_RATE_RATIO) +#define MAX_SAMPLING_RATE (500 * def_sampling_rate) +#define DEF_SAMPLING_DOWN_FACTOR (1) +#define MAX_SAMPLING_DOWN_FACTOR (10) +#define TRANSITION_LATENCY_LIMIT (10 * 1000 * 1000) + +static void do_dbs_timer(struct work_struct *work); + +struct cpu_dbs_info_s { + struct cpufreq_policy *cur_policy; + unsigned int prev_cpu_idle_up; + unsigned int prev_cpu_idle_down; + unsigned int enable; + unsigned int down_skip; + unsigned int requested_freq; + unsigned int sweet_spot_skip; /* Threshold to stay in sweet spot. */ +}; +static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info); + +static unsigned int dbs_enable; /* number of CPUs using this policy */ + +/* + * DEADLOCK ALERT! There is a ordering requirement between cpu_hotplug + * lock and dbs_mutex. cpu_hotplug lock should always be held before + * dbs_mutex. If any function that can potentially take cpu_hotplug lock + * (like __cpufreq_driver_target()) is being called with dbs_mutex taken, then + * cpu_hotplug lock should be taken before that. Note that cpu_hotplug lock + * is recursive for the same process. -Venki + */ +static DEFINE_MUTEX(dbs_mutex); +static DECLARE_DELAYED_WORK(dbs_work, do_dbs_timer); + +struct dbs_tuners { + unsigned int sampling_rate; + unsigned int sampling_down_factor; + unsigned int up_threshold; + unsigned int down_threshold; + unsigned int ignore_nice; + unsigned int freq_step; +}; + +static struct dbs_tuners dbs_tuners_ins = { + .up_threshold = DEF_FREQUENCY_UP_THRESHOLD, + .down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD, + .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR, + .ignore_nice = 0, + .freq_step = 20, +}; + +static inline unsigned int get_cpu_idle_time(unsigned int cpu) +{ + unsigned int add_nice = 0, ret; + + if (dbs_tuners_ins.ignore_nice) + add_nice = kstat_cpu(cpu).cpustat.nice; + + ret = kstat_cpu(cpu).cpustat.idle + + kstat_cpu(cpu).cpustat.iowait + + add_nice; + + return ret; +} + +/* keep track of frequency transitions */ +static int +dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val, + void *data) +{ + struct cpufreq_freqs *freq = data; + struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, + freq->cpu); + + if (!this_dbs_info->enable) + return 0; +#if 0 /* It may stay in certain step. So, + it is better to keep original request value. */ + this_dbs_info->requested_freq = freq->new; +#endif + return 0; +} + +static struct notifier_block dbs_cpufreq_notifier_block = { + .notifier_call = dbs_cpufreq_notifier +}; + +/************************** sysfs interface ************************/ +static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf) +{ + return sprintf(buf, "%u\n", MAX_SAMPLING_RATE); +} + +static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf) +{ + return sprintf(buf, "%u\n", MIN_SAMPLING_RATE); +} + +#define define_one_ro(_name) \ +static struct freq_attr _name = \ +__ATTR(_name, 0444, show_##_name, NULL) + +define_one_ro(sampling_rate_max); +define_one_ro(sampling_rate_min); + +/* cpufreq_conservative Governor Tunables */ +#define show_one(file_name, object) \ +static ssize_t show_##file_name \ +(struct cpufreq_policy *unused, char *buf) \ +{ \ + return sprintf(buf, "%u\n", dbs_tuners_ins.object); \ +} +show_one(sampling_rate, sampling_rate); +show_one(sampling_down_factor, sampling_down_factor); +show_one(up_threshold, up_threshold); +show_one(down_threshold, down_threshold); +show_one(ignore_nice_load, ignore_nice); +show_one(freq_step, freq_step); + +static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, + const char *buf, size_t count) +{ + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1) + return -EINVAL; + + mutex_lock(&dbs_mutex); + dbs_tuners_ins.sampling_down_factor = input; + mutex_unlock(&dbs_mutex); + + return count; +} + +static ssize_t store_sampling_rate(struct cpufreq_policy *unused, + const char *buf, size_t count) +{ + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + mutex_lock(&dbs_mutex); + if (ret != 1 || input > MAX_SAMPLING_RATE + || input < MIN_SAMPLING_RATE) { + mutex_unlock(&dbs_mutex); + return -EINVAL; + } + + dbs_tuners_ins.sampling_rate = input; + mutex_unlock(&dbs_mutex); + + return count; +} + +static ssize_t store_up_threshold(struct cpufreq_policy *unused, + const char *buf, size_t count) +{ + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + mutex_lock(&dbs_mutex); + if (ret != 1 || input > 100 || input <= dbs_tuners_ins.down_threshold) { + mutex_unlock(&dbs_mutex); + return -EINVAL; + } + + dbs_tuners_ins.up_threshold = input; + mutex_unlock(&dbs_mutex); + + return count; +} + +static ssize_t store_down_threshold(struct cpufreq_policy *unused, + const char *buf, size_t count) +{ + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + mutex_lock(&dbs_mutex); + if (ret != 1 || input > 100 || input >= dbs_tuners_ins.up_threshold) { + mutex_unlock(&dbs_mutex); + return -EINVAL; + } + + dbs_tuners_ins.down_threshold = input; + mutex_unlock(&dbs_mutex); + + return count; +} + +static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy, + const char *buf, size_t count) +{ + unsigned int input; + int ret; + + unsigned int j; + + ret = sscanf(buf, "%u", &input); + if (ret != 1) + return -EINVAL; + + if (input > 1) + input = 1; + + mutex_lock(&dbs_mutex); + if (input == dbs_tuners_ins.ignore_nice) { /* nothing to do */ + mutex_unlock(&dbs_mutex); + return count; + } + dbs_tuners_ins.ignore_nice = input; + + /* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */ + for_each_online_cpu(j) { + struct cpu_dbs_info_s *j_dbs_info; + j_dbs_info = &per_cpu(cpu_dbs_info, j); + j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j); + j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up; + } + mutex_unlock(&dbs_mutex); + + return count; +} + +static ssize_t store_freq_step(struct cpufreq_policy *policy, + const char *buf, size_t count) +{ + unsigned int input; + int ret; + + ret = sscanf(buf, "%u", &input); + + if (ret != 1) + return -EINVAL; + + if (input > 100) + input = 100; + + /* no need to test here if freq_step is zero as the user might actually + * want this, they would be crazy though :) */ + mutex_lock(&dbs_mutex); + dbs_tuners_ins.freq_step = input; + mutex_unlock(&dbs_mutex); + + return count; +} + +#define define_one_rw(_name) \ +static struct freq_attr _name = \ +__ATTR(_name, 0644, show_##_name, store_##_name) + +define_one_rw(sampling_rate); +define_one_rw(sampling_down_factor); +define_one_rw(up_threshold); +define_one_rw(down_threshold); +define_one_rw(ignore_nice_load); +define_one_rw(freq_step); + +static struct attribute *dbs_attributes[] = { + &sampling_rate_max.attr, + &sampling_rate_min.attr, + &sampling_rate.attr, + &sampling_down_factor.attr, + &up_threshold.attr, + &down_threshold.attr, + &ignore_nice_load.attr, + &freq_step.attr, + NULL +}; + +static struct attribute_group dbs_attr_group = { + .attrs = dbs_attributes, + .name = "msm7k", +}; + +/************************** sysfs end ************************/ +/* Adjusts the requested frequency factoring in sweet spot optimzations. */ +static void freq_adjust(struct cpu_dbs_info_s *this_dbs_info) +{ + struct cpufreq_frequency_table *freq_tbl; + const struct cpufreq_policy *policy = this_dbs_info->cur_policy; + int index = sweet_spot_index; + /* + * * Re-adjust sweet spot if the policy has been updated. + * * Currently this can be updated from the android/power.c driver when + * * the framework calls "standby" and "wake". + * */ + freq_tbl = cpufreq_frequency_get_table(policy->cpu); + lock_policy_rwsem_read(policy->cpu); + while (freq_tbl[sweet_spot_index + 1].frequency > policy->max && + sweet_spot_index > 0) + sweet_spot_index--; + + /* + * * We should not have to worry about index overflow unless the value + * * from policy->max does not exist in freq_tbl, be safe just incase. + * */ + while (freq_tbl[sweet_spot_index + 1].frequency < policy->max && + freq_tbl[sweet_spot_index + 1].frequency != CPUFREQ_TABLE_END) + sweet_spot_index++; + + unlock_policy_rwsem_read(policy->cpu); + if (policy->cur != freq_tbl[sweet_spot_index].frequency) + return; + + /* + * Sweet spot as a weight of SWEET_SPOT_THRESHOLD which is + * how many times longer to say in this frequency before + * going to the next. + */ + if (++this_dbs_info->sweet_spot_skip > SWEET_SPOT_THRESHOLD) { + this_dbs_info->sweet_spot_skip = 0; + index++; + } + this_dbs_info->requested_freq = freq_tbl[index].frequency; +} + +static void dbs_check_cpu(int cpu) +{ + unsigned int idle_ticks, up_idle_ticks, down_idle_ticks; + unsigned int tmp_idle_ticks, total_idle_ticks; + unsigned int freq_target; + unsigned int freq_down_sampling_rate; + struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, cpu); + struct cpufreq_policy *policy; + + if (!this_dbs_info->enable) + return; + + policy = this_dbs_info->cur_policy; + + /* + * The default safe range is 20% to 80% + * Every sampling_rate, we check + * - If current idle time is less than 20%, then we try to + * increase frequency + * Every sampling_rate*sampling_down_factor, we check + * - If current idle time is more than 80%, then we try to + * decrease frequency + * + * Any frequency increase takes it to the maximum frequency. + * Frequency reduction happens at minimum steps of + * 5% (default) of max_frequency + */ + + /* Check for frequency increase */ + idle_ticks = UINT_MAX; + + /* Check for frequency increase */ + total_idle_ticks = get_cpu_idle_time(cpu); + tmp_idle_ticks = total_idle_ticks - + this_dbs_info->prev_cpu_idle_up; + this_dbs_info->prev_cpu_idle_up = total_idle_ticks; + + if (tmp_idle_ticks < idle_ticks) + idle_ticks = tmp_idle_ticks; + + /* Scale idle ticks by 100 and compare with up and down ticks */ + idle_ticks *= 100; + up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) * + usecs_to_jiffies(dbs_tuners_ins.sampling_rate); + + if (idle_ticks < up_idle_ticks) { + this_dbs_info->down_skip = 0; + this_dbs_info->prev_cpu_idle_down = + this_dbs_info->prev_cpu_idle_up; + + /* if we are already at full speed then break out early */ + if (this_dbs_info->requested_freq == policy->max) + return; + + freq_target = (dbs_tuners_ins.freq_step * + (policy->max - policy->min)) / 100; + + /* max freq cannot be less than 100. But who knows.... */ + if (unlikely(freq_target == 0)) + freq_target = 5; + + this_dbs_info->requested_freq += freq_target; + if (this_dbs_info->requested_freq > policy->max) + this_dbs_info->requested_freq = policy->max; + +#if 0 /* It may stay in certain step. So, + it is better to keep original request value. */ + freq_adjust(this_dbs_info); +#endif + + __cpufreq_driver_target(policy, this_dbs_info->requested_freq, + CPUFREQ_RELATION_H); + return; + } + + /* Reset sweet spot counter on clock down. */ + this_dbs_info->sweet_spot_skip = 0; + + /* Check for frequency decrease */ + this_dbs_info->down_skip++; + if (this_dbs_info->down_skip < dbs_tuners_ins.sampling_down_factor) + return; + + /* Check for frequency decrease */ + total_idle_ticks = this_dbs_info->prev_cpu_idle_up; + tmp_idle_ticks = total_idle_ticks - + this_dbs_info->prev_cpu_idle_down; + this_dbs_info->prev_cpu_idle_down = total_idle_ticks; + + if (tmp_idle_ticks < idle_ticks) + idle_ticks = tmp_idle_ticks; + + /* Scale idle ticks by 100 and compare with up and down ticks */ + idle_ticks *= 100; + this_dbs_info->down_skip = 0; + + freq_down_sampling_rate = dbs_tuners_ins.sampling_rate * + dbs_tuners_ins.sampling_down_factor; + down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) * + usecs_to_jiffies(freq_down_sampling_rate); + + if (idle_ticks > down_idle_ticks) { + /* + * if we are already at the lowest speed then break out early + * or if we 'cannot' reduce the speed as the user might want + * freq_target to be zero + */ + if (this_dbs_info->requested_freq == policy->min + || dbs_tuners_ins.freq_step == 0) + return; + + freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100; + + /* max freq cannot be less than 100. But who knows.... */ + if (unlikely(freq_target == 0)) + freq_target = 5; + + this_dbs_info->requested_freq -= freq_target; + if (this_dbs_info->requested_freq < policy->min) + this_dbs_info->requested_freq = policy->min; + + __cpufreq_driver_target(policy, this_dbs_info->requested_freq, + CPUFREQ_RELATION_H); + return; + } +} + +static void do_dbs_timer(struct work_struct *work) +{ + int i; + mutex_lock(&dbs_mutex); + for_each_online_cpu(i) + dbs_check_cpu(i); + + /* Replace timer from fix period to getting next wake + * timer wake up time, to prevent unnecessary interrupt + * */ + dbs_tuners_ins.sampling_rate = + jiffies_to_usecs(get_next_timer_interrupt(jiffies) - jiffies); + + + schedule_delayed_work(&dbs_work, + usecs_to_jiffies(dbs_tuners_ins.sampling_rate)); + mutex_unlock(&dbs_mutex); +} + +static inline void dbs_timer_init(void) +{ + schedule_delayed_work(&dbs_work, + usecs_to_jiffies(dbs_tuners_ins.sampling_rate)); + return; +} + +static inline void dbs_timer_exit(void) +{ + cancel_delayed_work(&dbs_work); + return; +} + +static int cpufreq_governor_dbs(struct cpufreq_policy *policy, + unsigned int event) +{ + unsigned int cpu = policy->cpu; + struct cpu_dbs_info_s *this_dbs_info; + unsigned int j; + int rc; + struct cpufreq_frequency_table *freq_tbl; + + this_dbs_info = &per_cpu(cpu_dbs_info, cpu); + + switch (event) { + case CPUFREQ_GOV_START: + if ((!cpu_online(cpu)) || (!policy->cur)) + return -EINVAL; + + if (this_dbs_info->enable) /* Already enabled */ + break; + + mutex_lock(&dbs_mutex); + /* Find the index of the sweet spot (freq just before max). */ +/* freq_tbl = cpufreq_frequency_get_table(cpu); + for (j = 0; freq_tbl[j].frequency != CPUFREQ_TABLE_END; j++) { + if (policy->max == freq_tbl[j].frequency) + sweet_spot_index = j > 0 ? j - 1 : 0; + }*/ + + rc = sysfs_create_group(&policy->kobj, &dbs_attr_group); + if (rc) { + mutex_unlock(&dbs_mutex); + return rc; + } + + for_each_cpu_mask_nr(j, policy->cpus) { + struct cpu_dbs_info_s *j_dbs_info; + j_dbs_info = &per_cpu(cpu_dbs_info, j); + j_dbs_info->cur_policy = policy; + + j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(cpu); + j_dbs_info->prev_cpu_idle_down + = j_dbs_info->prev_cpu_idle_up; + } + this_dbs_info->enable = 1; + this_dbs_info->down_skip = 0; + this_dbs_info->requested_freq = policy->cur; + + dbs_enable++; + /* + * Start the timerschedule work, when this governor + * is used for first time + */ + if (dbs_enable == 1) { + unsigned int latency; + /* policy latency is in nS. Convert it to uS first */ + latency = policy->cpuinfo.transition_latency / 1000; + if (latency == 0) + latency = 1; + + def_sampling_rate = 10 * latency * + CONFIG_CPU_FREQ_SAMPLING_LATENCY_MULTIPLIER; + + if (def_sampling_rate < MIN_STAT_SAMPLING_RATE) + def_sampling_rate = MIN_STAT_SAMPLING_RATE; + + dbs_tuners_ins.sampling_rate = def_sampling_rate; + + dbs_timer_init(); + cpufreq_register_notifier( + &dbs_cpufreq_notifier_block, + CPUFREQ_TRANSITION_NOTIFIER); + } + + mutex_unlock(&dbs_mutex); + break; + + case CPUFREQ_GOV_STOP: + mutex_lock(&dbs_mutex); + this_dbs_info->enable = 0; + sysfs_remove_group(&policy->kobj, &dbs_attr_group); + dbs_enable--; + /* + * Stop the timerschedule work, when this governor + * is used for first time + */ + if (dbs_enable == 0) { + dbs_timer_exit(); + cpufreq_unregister_notifier( + &dbs_cpufreq_notifier_block, + CPUFREQ_TRANSITION_NOTIFIER); + } + + mutex_unlock(&dbs_mutex); + + break; + + case CPUFREQ_GOV_LIMITS: + mutex_lock(&dbs_mutex); + if (policy->max < this_dbs_info->cur_policy->cur) + __cpufreq_driver_target( + this_dbs_info->cur_policy, + policy->max, CPUFREQ_RELATION_H); + else if (policy->min > this_dbs_info->cur_policy->cur) + __cpufreq_driver_target( + this_dbs_info->cur_policy, + policy->min, CPUFREQ_RELATION_L); + mutex_unlock(&dbs_mutex); + break; + } + return 0; +} + +struct cpufreq_governor cpufreq_gov_msm7k = { + .name = "msm7k", + .governor = cpufreq_governor_dbs, + .max_transition_latency = TRANSITION_LATENCY_LIMIT, + .owner = THIS_MODULE, +}; +EXPORT_SYMBOL(cpufreq_gov_msm7k); + +static int __init cpufreq_gov_dbs_init(void) +{ + return cpufreq_register_governor(&cpufreq_gov_msm7k); +} + +static void __exit cpufreq_gov_dbs_exit(void) +{ + /* Make sure that the scheduled work is indeed not running */ + flush_scheduled_work(); + + cpufreq_unregister_governor(&cpufreq_gov_msm7k); +} + + +MODULE_AUTHOR("Alexander Clouter "); +MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for " + "Low Latency Frequency Transition capable processors " + "optimised for use in a battery environment"); +MODULE_LICENSE("GPL"); + +#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_MSM7K +fs_initcall(cpufreq_gov_dbs_init); +#else +module_init(cpufreq_gov_dbs_init); +#endif +module_exit(cpufreq_gov_dbs_exit); diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h index 6fd5668..6611c4f 100644 --- a/include/linux/cpufreq.h +++ b/include/linux/cpufreq.h @@ -318,6 +318,9 @@ extern struct cpufreq_governor cpufreq_gov_ondemand; #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE) extern struct cpufreq_governor cpufreq_gov_conservative; #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative) +#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_MSM7K) +extern struct cpufreq_governor cpufreq_gov_msm7k; +#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_msm7k) #endif -- 1.6.6.1