diff options
Diffstat (limited to 'drivers/cpufreq/cpufreq_sprdemand.c')
| -rw-r--r-- | drivers/cpufreq/cpufreq_sprdemand.c | 2199 |
1 files changed, 2199 insertions, 0 deletions
diff --git a/drivers/cpufreq/cpufreq_sprdemand.c b/drivers/cpufreq/cpufreq_sprdemand.c new file mode 100644 index 00000000..4a908760 --- /dev/null +++ b/drivers/cpufreq/cpufreq_sprdemand.c @@ -0,0 +1,2199 @@ +/* + * drivers/cpufreq/cpufreq_sprdemand.c + * + * Copyright (C) 2001 Russell King + * (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>. + * Jun Nakajima <jun.nakajima@intel.com> + * + * 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. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/cpufreq.h> +#include <linux/init.h> +#include <linux/kernel.h> +#include <linux/kernel_stat.h> +#include <linux/kobject.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/percpu-defs.h> +#include <linux/slab.h> +#include <linux/sysfs.h> +#include <linux/tick.h> +#include <linux/types.h> +#include <linux/cpu.h> +#include <linux/thermal.h> +#include <linux/err.h> +#include <linux/earlysuspend.h> +#include <linux/suspend.h> +#include <asm/cacheflush.h> +#include <linux/kthread.h> +#include <linux/delay.h> + +#include "cpufreq_governor.h" +#include <linux/input.h> +#include <linux/sprd_cpu_cooling.h> +#include <linux/platform_device.h> +#ifdef CONFIG_OF +#include <linux/of_device.h> +#endif + +/* On-demand governor macros */ +#define DEF_FREQUENCY_DOWN_DIFFERENTIAL (10) +#define DEF_FREQUENCY_UP_THRESHOLD (80) +#define DEF_SAMPLING_DOWN_FACTOR (1) +#define MAX_SAMPLING_DOWN_FACTOR (100000) +#define MICRO_FREQUENCY_DOWN_DIFFERENTIAL (10) +#define MICRO_FREQUENCY_UP_THRESHOLD (80) +#define MICRO_FREQUENCY_MIN_SAMPLE_RATE (10000) +#define MIN_FREQUENCY_UP_THRESHOLD (11) +#define MAX_FREQUENCY_UP_THRESHOLD (100) + +/* whether plugin cpu according to this score up threshold */ +#define DEF_CPU_SCORE_UP_THRESHOLD (100) +/* whether unplug cpu according to this down threshold*/ +#define DEF_CPU_LOAD_DOWN_THRESHOLD (30) +#define DEF_CPU_DOWN_COUNT (3) + +#define LOAD_CRITICAL 100 +#define LOAD_HI 90 +#define LOAD_MID 80 +#define LOAD_LIGHT 50 +#define LOAD_LO 0 + +#define LOAD_CRITICAL_SCORE 10 +#define LOAD_HI_SCORE 5 +#define LOAD_MID_SCORE 0 +#define LOAD_LIGHT_SCORE -10 +#define LOAD_LO_SCORE -20 + +#define DEF_CPU_UP_MID_THRESHOLD (80) +#define DEF_CPU_UP_HIGH_THRESHOLD (90) +#define DEF_CPU_DOWN_MID_THRESHOLD (30) +#define DEF_CPU_DOWN_HIGH_THRESHOLD (40) + +#define GOVERNOR_BOOT_TIME (50*HZ) +static unsigned long boot_done; + +unsigned int cpu_hotplug_disable_set = false; +static int g_is_suspend = false; + +#if 0 +struct unplug_work_info { + unsigned int cpuid; + struct delayed_work unplug_work; + struct dbs_data *dbs_data; +}; +static DEFINE_PER_CPU(struct unplug_work_info, uwi); +#endif + +struct delayed_work plugin_work; +struct delayed_work unplug_work; +struct work_struct thm_unplug_work; +struct work_struct plugin_all_work; +struct work_struct unplug_all_work; +static int cpu_num_limit_temp; +static void sprd_thm_unplug_cpu(struct work_struct *work); + +static DEFINE_PER_CPU(struct unplug_work_info, uwi); + +static DEFINE_SPINLOCK(g_lock); +static unsigned int percpu_total_load[CONFIG_NR_CPUS] = {0}; +static unsigned int percpu_check_count[CONFIG_NR_CPUS] = {0}; +static int cpu_score = 0; + +/* FIXME. default touch boost is enabled */ +#define CONFIG_TOUCH_BOOST + +#ifdef CONFIG_TOUCH_BOOST +static struct task_struct *ksprd_tb; +atomic_t g_atomic_tb_cnt = ATOMIC_INIT(0); +struct semaphore tb_sem; +static unsigned long tp_time; + +#if 0 +static struct workqueue_struct *input_wq; +static struct work_struct dbs_refresh_work; +#endif + +#endif + +static DEFINE_PER_CPU(struct od_cpu_dbs_info_s, sd_cpu_dbs_info); + +static struct od_ops sd_ops; + +#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_SPRDEMAND +static struct cpufreq_governor cpufreq_gov_sprdemand; +#endif + +static void update_sampling_rate(struct dbs_data *dbs_data, unsigned int new_rate); + +static void sprdemand_powersave_bias_init_cpu(int cpu) +{ + struct od_cpu_dbs_info_s *dbs_info = &per_cpu(sd_cpu_dbs_info, cpu); + + dbs_info->freq_table = cpufreq_frequency_get_table(cpu); + dbs_info->freq_lo = 0; +} + +/* + * Not all CPUs want IO time to be accounted as busy; this depends on how + * efficient idling at a higher frequency/voltage is. + * Pavel Machek says this is not so for various generations of AMD and old + * Intel systems. + * Mike Chan (android.com) claims this is also not true for ARM. + * Because of this, whitelist specific known (series) of CPUs by default, and + * leave all others up to the user. + */ +static int should_io_be_busy(void) +{ +#if defined(CONFIG_X86) + /* + * For Intel, Core 2 (model 15) and later have an efficient idle. + */ + if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL && + boot_cpu_data.x86 == 6 && + boot_cpu_data.x86_model >= 15) + return 1; +#endif + return 1; +} + +struct sd_dbs_tuners *g_sd_tuners = NULL; +int cpu_core_thermal_limit(int cluster, int max_core) +{ + struct cpufreq_policy *policy = cpufreq_cpu_get(0); + struct dbs_data *dbs_data = NULL; + struct sd_dbs_tuners *sd_tuners = NULL; + + if (NULL == policy){ + return -1; + }else{ + dbs_data = policy->governor_data; + } + if (NULL == dbs_data){ + if (g_sd_tuners == NULL){ + return -1; + } + sd_tuners = g_sd_tuners; + }else{ + sd_tuners = dbs_data->tuners; + } + + if (sd_tuners->cpu_num_limit <= max_core) { + sd_tuners->cpu_num_limit = max_core; + g_sd_tuners->cpu_num_limit = max_core; + return 0; + } + sd_tuners->cpu_num_limit = max_core; + g_sd_tuners->cpu_num_limit = max_core; + schedule_work_on(0, &thm_unplug_work); + + return 0; +} + +/* + * Find right freq to be set now with powersave_bias on. + * Returns the freq_hi to be used right now and will set freq_hi_jiffies, + * freq_lo, and freq_lo_jiffies in percpu area for averaging freqs. + */ +static unsigned int generic_powersave_bias_target(struct cpufreq_policy *policy, + unsigned int freq_next, unsigned int relation) +{ + unsigned int freq_req, freq_reduc, freq_avg; + unsigned int freq_hi, freq_lo; + unsigned int index = 0; + unsigned int jiffies_total, jiffies_hi, jiffies_lo; + struct od_cpu_dbs_info_s *dbs_info = &per_cpu(sd_cpu_dbs_info, + policy->cpu); + struct dbs_data *dbs_data = policy->governor_data; + struct sd_dbs_tuners *sd_tuners = NULL; + + if (NULL == dbs_data) { + pr_info("generic_powersave_bias_target governor %s return\n", policy->governor->name); + if (g_sd_tuners == NULL) + return freq_next; + sd_tuners = g_sd_tuners; + } else { + sd_tuners = dbs_data->tuners; + } + + if (!dbs_info->freq_table) { + dbs_info->freq_lo = 0; + dbs_info->freq_lo_jiffies = 0; + return freq_next; + } + + cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_next, + relation, &index); + freq_req = dbs_info->freq_table[index].frequency; + freq_reduc = freq_req * sd_tuners->powersave_bias / 1000; + freq_avg = freq_req - freq_reduc; + + /* Find freq bounds for freq_avg in freq_table */ + index = 0; + cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg, + CPUFREQ_RELATION_H, &index); + freq_lo = dbs_info->freq_table[index].frequency; + index = 0; + cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg, + CPUFREQ_RELATION_L, &index); + freq_hi = dbs_info->freq_table[index].frequency; + + /* Find out how long we have to be in hi and lo freqs */ + if (freq_hi == freq_lo) { + dbs_info->freq_lo = 0; + dbs_info->freq_lo_jiffies = 0; + return freq_lo; + } + jiffies_total = usecs_to_jiffies(sd_tuners->sampling_rate); + jiffies_hi = (freq_avg - freq_lo) * jiffies_total; + jiffies_hi += ((freq_hi - freq_lo) / 2); + jiffies_hi /= (freq_hi - freq_lo); + jiffies_lo = jiffies_total - jiffies_hi; + dbs_info->freq_lo = freq_lo; + dbs_info->freq_lo_jiffies = jiffies_lo; + dbs_info->freq_hi_jiffies = jiffies_hi; + return freq_hi; +} + +static void sprdemand_powersave_bias_init(void) +{ + int i; + for_each_online_cpu(i) { + sprdemand_powersave_bias_init_cpu(i); + } +} + +static void dbs_freq_increase(struct cpufreq_policy *p, unsigned int freq) +{ + struct dbs_data *dbs_data = p->governor_data; + struct sd_dbs_tuners *sd_tuners = NULL; + + if (NULL == dbs_data) { + pr_info("dbs_freq_increase governor %s return\n", p->governor->name); + if (g_sd_tuners == NULL) + return ; + sd_tuners = g_sd_tuners; + } else { + sd_tuners = dbs_data->tuners; + } + + if (sd_tuners->powersave_bias) + freq = sd_ops.powersave_bias_target(p, freq, + CPUFREQ_RELATION_H); + else if (p->cur == p->max) + return; + + __cpufreq_driver_target(p, freq, sd_tuners->powersave_bias ? + CPUFREQ_RELATION_L : CPUFREQ_RELATION_H); +} + +static void sprd_unplug_one_cpu(struct work_struct *work) +{ + struct cpufreq_policy *policy = cpufreq_cpu_get(0); + struct dbs_data *dbs_data = policy->governor_data; + struct sd_dbs_tuners *sd_tuners = NULL; + int cpuid; + + if (NULL == dbs_data) { + pr_info("sprd_unplug_one_cpu return\n"); + if (g_sd_tuners == NULL) + return ; + sd_tuners = g_sd_tuners; + } else { + sd_tuners = dbs_data->tuners; + } + +#ifdef CONFIG_HOTPLUG_CPU + if (num_online_cpus() > 1) { + if (!sd_tuners->cpu_hotplug_disable) { + cpuid = cpumask_next(0, cpu_online_mask); + pr_info("!! we gonna unplug cpu%d !!\n", cpuid); + cpu_down(cpuid); + } + } +#endif + return; +} + +static void sprd_plugin_one_cpu(struct work_struct *work) +{ + int cpuid; + struct cpufreq_policy *policy = cpufreq_cpu_get(0); + struct dbs_data *dbs_data = policy->governor_data; + struct sd_dbs_tuners *sd_tuners = NULL; + + if (NULL == dbs_data) { + pr_info("sprd_plugin_one_cpu return\n"); + if (g_sd_tuners == NULL) + return ; + sd_tuners = g_sd_tuners; + } else { + sd_tuners = dbs_data->tuners; + } + +#ifdef CONFIG_HOTPLUG_CPU + if (num_online_cpus() < sd_tuners->cpu_num_limit) { + cpuid = cpumask_next_zero(0, cpu_online_mask); + if (!sd_tuners->cpu_hotplug_disable) { + pr_info("!! we gonna plugin cpu%d !!\n", cpuid); + cpu_up(cpuid); + } + } +#endif + return; +} + +static void sprd_unplug_all_cpu(struct work_struct *work) +{ + struct cpufreq_policy *policy = cpufreq_cpu_get(0); + struct dbs_data *dbs_data = policy->governor_data; + struct sd_dbs_tuners *sd_tuners = NULL; + int cpu; + + if (NULL == dbs_data) { + pr_info("sprd_unplug_all_cpu return\n"); + if (g_sd_tuners == NULL) + return ; + sd_tuners = g_sd_tuners; + } else { + sd_tuners = dbs_data->tuners; + } + +#ifdef CONFIG_HOTPLUG_CPU + if (num_online_cpus() > 1) { + for_each_online_cpu(cpu) { + if (0 == cpu) + continue; + pr_info("!! all gonna unplug cpu%d !!\n", cpu); + cpu_down(cpu); + } + } +#endif + return; +} + +static void sprd_plugin_all_cpu(struct work_struct *work) +{ + int cpu; + struct cpufreq_policy *policy = cpufreq_cpu_get(0); + struct dbs_data *dbs_data = policy->governor_data; + struct sd_dbs_tuners *sd_tuners = NULL; + + if (NULL == dbs_data) { + pr_info("sprd_plugin_all_cpu return\n"); + if (g_sd_tuners == NULL) + return ; + sd_tuners = g_sd_tuners; + } else { + sd_tuners = dbs_data->tuners; + } + +#ifdef CONFIG_HOTPLUG_CPU + if (num_online_cpus() < sd_tuners->cpu_num_limit) { + for_each_possible_cpu(cpu) { + if (!cpu_online(cpu)) { + pr_info("!! all gonna plugin cpu%d !!\n", + cpu); + cpu_up(cpu); + } + } + } +#endif + return; +} + +unsigned int percpu_load[4] = {0}; +#define MAX_CPU_NUM (4) +#define MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE (10) +#define MAX_PLUG_AVG_LOAD_SIZE (2) + +unsigned int ga_percpu_total_load[MAX_CPU_NUM][MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE] = {{0}}; +extern unsigned int dvfs_unplug_select; +extern unsigned int dvfs_plug_select; + +unsigned int cur_window_size[MAX_CPU_NUM] ={0}; +unsigned int prev_window_size[MAX_CPU_NUM] ={0}; + +int cur_window_index[MAX_CPU_NUM] = {0}; +unsigned int cur_window_cnt[MAX_CPU_NUM] = {0}; +int first_window_flag[4] = {0}; + +unsigned int sum_load[4] = {0}; + +unsigned int plug_avg_load[MAX_CPU_NUM][MAX_PLUG_AVG_LOAD_SIZE] = {{50}}; +unsigned int plug_avg_load_index[MAX_CPU_NUM] = {0}; + +#define mod(n, div) ((n) % (div)) + +extern unsigned int dvfs_score_select; +extern unsigned int dvfs_score_hi[4]; +extern unsigned int dvfs_score_mid[4]; +extern unsigned int dvfs_score_critical[4]; + +int a_score_sub[4][4][11]= +{ + { + {0,0,0,0,0,0,0,0,5,5,10}, + {-5,-5,0,0,0,0,0,0,0,5,5}, + {-10,-5,0,0,0,0,0,0,0,5,5}, + {0,0,0,0,0,0,0,0,0,0,0} + }, + { + {0,0,0,0,0,0,0,0,13,13,30}, + {-9,-9,0,0,0,0,0,0,9,9,10}, + {-18,-9,0,0,0,0,0,0,4,5,9}, + {0,0,0,0,0,0,0,0,0,0,0} + }, + { + {0,0,0,0,0,0,0,10,20,20,30}, + {0,0,0,0,0,0,0,5,10,10,20}, + {0,0,0,0,0,0,0,0,5,5,10}, + {0,0,0,0,0,0,0,0,0,0,0} + }, + { + {0,0,0,0,0,0,0,0,30,30,50}, + {-20,-20,0,0,0,0,0,0,20,20,30}, + {-40,-20,0,0,0,0,0,0,5,10,20}, + {0,0,0,0,0,0,0,0,0,0,0} + } +}; + +int ga_samp_rate[11] = {100000,100000,100000,100000,100000,100000,50000,50000,30000,30000,30000}; + +unsigned int a_sub_windowsize[8][6] = +{ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {4,5,5,6,7,7}, + {4,5,5,6,7,7}, + {3,4,4,5,6,6}, + {2,3,3,4,5,5}, + {1,2,2,3,4,4}, + {0,1,1,2,3,3} +}; + +static int cpu_evaluate_score(int cpu, struct sd_dbs_tuners *sd_tunners , unsigned int load) +{ + int score = 0; + static int rate[4] = {1}; + int delta = 0; + int a_samp_rate[5] = {30000,30000,50000,50000,50000}; + + if(dvfs_score_select < 4) + { + if (load >= sd_tunners->load_critical) + { + score = dvfs_score_critical[num_online_cpus()]; + sd_tunners->sampling_rate = a_samp_rate[0]; + } + else if (load >= sd_tunners->load_hi) + { + score = dvfs_score_hi[num_online_cpus()]; + sd_tunners->sampling_rate = a_samp_rate[1]; + } + else if (load >= sd_tunners->load_mid) + { + score = dvfs_score_mid[num_online_cpus()]; + sd_tunners->sampling_rate = a_samp_rate[2]; + } + else if (load >= sd_tunners->load_light) + { + score = sd_tunners->load_light_score; + sd_tunners->sampling_rate = a_samp_rate[3]; + } + else if (load >= sd_tunners->load_lo) + { + score = sd_tunners->load_lo_score; + sd_tunners->sampling_rate = a_samp_rate[4]; + } + else + { + score = 0; + sd_tunners->sampling_rate = a_samp_rate[4]; + } + + } + else + { + delta = abs(percpu_load[cpu] - load); + if((delta > 30) + &&(load > 80)) + { + if (unlikely(rate[cpu] > 100)) + rate[cpu] = 1; + + rate[cpu] +=2; + score = a_score_sub[dvfs_score_select % 4][num_online_cpus() - 1][load/10] * rate[cpu]; + rate[cpu] --; + } + else + { + score = a_score_sub[dvfs_score_select % 4][num_online_cpus() - 1][load/10]; + rate[cpu] = 1; + } + } + pr_debug("[DVFS SCORE] rate[%d] %d load %d score %d\n",cpu,rate[cpu],load,score); + return score; +} + + + +static int sd_adjust_window(struct sd_dbs_tuners *sd_tunners , unsigned int load) +{ + unsigned int cur_window_size = 0; + + if (load >= sd_tunners->load_critical) + cur_window_size = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - a_sub_windowsize[dvfs_unplug_select][0]; + else if (load >= sd_tunners->load_hi) + cur_window_size = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - a_sub_windowsize[dvfs_unplug_select][1]; + else if (load >= sd_tunners->load_mid) + cur_window_size = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - a_sub_windowsize[dvfs_unplug_select][2]; + else if (load >= sd_tunners->load_light) + cur_window_size = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - a_sub_windowsize[dvfs_unplug_select][3]; + else if (load >= sd_tunners->load_lo) + cur_window_size = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - a_sub_windowsize[dvfs_unplug_select][4]; + else + cur_window_size = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - a_sub_windowsize[dvfs_unplug_select][5]; + + return cur_window_size; +} + +static unsigned int sd_unplug_avg_load(int cpu, struct sd_dbs_tuners *sd_tunners , unsigned int load) +{ + int sum_idx_lo = 0; + unsigned int sum_idx_hi = 0; + unsigned int * p_valid_pos = NULL; + unsigned int sum_load = 0; + + /* + initialize the window size for the first time + */ + if(!cur_window_size[cpu]) + { + cur_window_size[cpu] = sd_adjust_window(sd_tunners,load); + pr_debug("[DVFS_UNPLUG]cur_window_size[%d] = %d\n",cpu,cur_window_size[cpu]); + return 100; + } + else + { + /* + record the load in the percpu array + */ + ga_percpu_total_load[cpu][cur_window_index[cpu]] = load; + cur_window_cnt[cpu]++; + /* + update the windw index + */ + cur_window_index[cpu]++; + cur_window_index[cpu] = mod(cur_window_index[cpu], MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + + /* + window array is not full, break + */ + if(cur_window_cnt[cpu] < cur_window_size[cpu]) + { + return 100; + } + else + { + /* + adjust the window index for it be added one more extra time + */ + if(!cur_window_index[cpu]) + { + cur_window_index[cpu] = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - 1; + } + else + { + cur_window_index[cpu]--; + } + /* + find the valid position according to current window size and indexs + */ + p_valid_pos = (unsigned int *)&ga_percpu_total_load[cpu][cur_window_index[cpu]]; + /* + calculate the average load value by decrease the index, for we need the very updated value which locate in the end of the array + */ + for(sum_idx_lo = 0; sum_idx_lo < cur_window_size[cpu]; sum_idx_lo++) + { + /* + calculate the lower part + */ + if((cur_window_index[cpu] - sum_idx_lo) >=0) + { + sum_load += *(unsigned int *)((unsigned int)p_valid_pos - sum_idx_lo * sizeof(p_valid_pos)); + } + else + { + /* + calculate the higher part + */ + sum_idx_hi = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - (cur_window_size[cpu] - sum_idx_lo); + for(; sum_idx_hi < MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE; sum_idx_hi++) + { + sum_load += ga_percpu_total_load[cpu][sum_idx_hi]; + } + break; + + } + + } + sum_load = sum_load / cur_window_size[cpu]; + /* + adjust the window according to previews load + */ + cur_window_size[cpu] = sd_adjust_window(sd_tunners, sum_load); + cur_window_cnt[cpu] = 0; + pr_debug("[DVFS_UNPLUG]cur_window_size %d sum_load %d\n",cur_window_size[cpu],sum_load); + } + return sum_load; + } + +} + + +static unsigned int sd_unplug_avg_load1(int cpu, struct sd_dbs_tuners *sd_tunners , unsigned int load) +{ + int avg_load = 0; + int cur_window_pos = 0; + int cur_window_pos_tail = 0; + int idx = 0; + + /* + initialize the window size for the first time + cur_window_cnt[cpu] will be cleared when the core is unpluged + */ + if((!first_window_flag[cpu]) + ||(!cur_window_size[cpu])) + { + if(!cur_window_size[cpu]) + { + cur_window_size[cpu] = sd_adjust_window(sd_tunners,load); + prev_window_size[cpu] = cur_window_size[cpu]; + } + if(cur_window_cnt[cpu] < (cur_window_size[cpu] - 1)) + { + /* + record the load in the percpu array + */ + ga_percpu_total_load[cpu][cur_window_index[cpu]] = load; + /* + update the windw index + */ + cur_window_index[cpu]++; + cur_window_index[cpu] = mod(cur_window_index[cpu], MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + + cur_window_cnt[cpu]++; + + sum_load[cpu] += load; + + return LOAD_LIGHT; + } + else + { + first_window_flag[cpu] = 1; + } + } + /* + record the load in the percpu array + */ + ga_percpu_total_load[cpu][cur_window_index[cpu]] = load; + /* + update the windw index + */ + cur_window_index[cpu]++; + cur_window_index[cpu] = mod(cur_window_index[cpu], MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + + /* + adjust the window index for it be added one more extra time + */ + if(!cur_window_index[cpu]) + { + cur_window_pos = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - 1; + } + else + { + cur_window_pos = cur_window_index[cpu] - 1; + } + + /* + tail = (c_w_p + max_window_size - c_w_s) % max_window_size + tail = (2 + 8 - 5) % 8 = 5 + tail = (6 + 8 - 5) % 8 = 1 + */ + cur_window_pos_tail = mod(MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE + cur_window_pos - cur_window_size[cpu],MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + + /* + no window size change + */ + if(prev_window_size[cpu] == cur_window_size[cpu] ) + { + sum_load[cpu] = sum_load[cpu] + ga_percpu_total_load[cpu][cur_window_pos] - ga_percpu_total_load[cpu][cur_window_pos_tail] ; + } + else + { + /* + window size change, recalculate the sum load + */ + sum_load[cpu] = 0; + while(idx < cur_window_size[cpu]) + { + sum_load[cpu] += ga_percpu_total_load[cpu][mod(cur_window_pos_tail + 1 +idx,MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE)]; + idx++; + } + } + avg_load = sum_load[cpu] / cur_window_size[cpu]; + + percpu_load[cpu] = avg_load; + + prev_window_size[cpu] = cur_window_size[cpu]; + + cur_window_size[cpu] = (load > avg_load) ? sd_adjust_window(sd_tunners, load) : prev_window_size[cpu]; + + sd_tunners->sampling_rate = ga_samp_rate[mod(avg_load/10,11)]; + + pr_debug("[DVFS_UNPLUG]sum_load[%d]=%d tail[%d]=%d cur[%d]=%d cur_window_size %d load %d avg_load %d\n",cpu,sum_load[cpu],cur_window_pos_tail, + ga_percpu_total_load[cpu][cur_window_pos_tail],cur_window_pos,ga_percpu_total_load[cpu][cur_window_pos],cur_window_size[cpu],load,avg_load); + if(avg_load > 100) + { + pr_info("cur_window_pos %d cur_window_pos_tail %d load %d sum_load %d\n",cur_window_pos,cur_window_pos_tail,load,sum_load[cpu] ); + } + return avg_load; + +} + +static unsigned int sd_unplug_avg_load11(int cpu, struct sd_dbs_tuners *sd_tunners , unsigned int load) +{ + int avg_load = 0; + int cur_window_pos = 0; + int cur_window_pos_tail = 0; + int idx = 0; + /* + initialize the window size for the first time + cur_window_cnt[cpu] will be cleared when the core is unpluged + */ + if((!first_window_flag[cpu]) + ||(!cur_window_size[cpu])) + { + if(!cur_window_size[cpu]) + { + cur_window_size[cpu] = sd_adjust_window(sd_tunners,load); + prev_window_size[cpu] = cur_window_size[cpu]; + } + if(cur_window_cnt[cpu] < (cur_window_size[cpu] - 1)) + { + /* + record the load in the percpu array + */ + ga_percpu_total_load[cpu][cur_window_index[cpu]] = load; + /* + update the windw index + */ + cur_window_index[cpu]++; + cur_window_index[cpu] = mod(cur_window_index[cpu], MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + + cur_window_cnt[cpu]++; + + sum_load[cpu] += load; + + return LOAD_LIGHT; + } + else + { + first_window_flag[cpu] = 1; + } + } + /* + record the load in the percpu array + */ + ga_percpu_total_load[cpu][cur_window_index[cpu]] = load; + /* + update the windw index + */ + cur_window_index[cpu]++; + cur_window_index[cpu] = mod(cur_window_index[cpu], MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + + /* + adjust the window index for it be added one more extra time + */ + if(!cur_window_index[cpu]) + { + cur_window_pos = MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE - 1; + } + else + { + cur_window_pos = cur_window_index[cpu] - 1; + } + + /* + tail = (c_w_p + max_window_size - c_w_s) % max_window_size + tail = (2 + 8 - 5) % 8 = 5 + tail = (6 + 8 - 5) % 8 = 1 + */ + cur_window_pos_tail = mod(MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE + cur_window_pos - cur_window_size[cpu],MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + + /* + sum load = current load + current new data - tail data + */ + sum_load[cpu] = sum_load[cpu] + ga_percpu_total_load[cpu][cur_window_pos] - ga_percpu_total_load[cpu][cur_window_pos_tail] ; + + /* + calc the average load + */ + avg_load = sum_load[cpu] / cur_window_size[cpu]; + + percpu_load[cpu] = avg_load; + + sd_tunners->sampling_rate = ga_samp_rate[mod(avg_load/10,11)]; + + return avg_load; +} + +#define MAX_ARRAY_SIZE (10) +#define LOAD_WINDOW_SIZE (3) +unsigned int load_array[CONFIG_NR_CPUS][MAX_ARRAY_SIZE] = { {0} }; +unsigned int window_index[CONFIG_NR_CPUS] = {0}; + +static unsigned int sd_avg_load(int cpu, struct sd_dbs_tuners *sd_tuners, + unsigned int load) +{ + unsigned int count; + unsigned int scale; + unsigned int sum_scale = 0; + unsigned int sum_load = 0; + unsigned int window_tail = 0, window_head = 0; + + load_array[cpu][window_index[cpu]] = load; + window_index[cpu]++; + window_index[cpu] = mod(window_index[cpu], MAX_ARRAY_SIZE); + if(!window_index[cpu]) + window_tail = MAX_ARRAY_SIZE - 1; + else + window_tail = window_index[cpu] - 1; + + window_head = mod(MAX_ARRAY_SIZE + window_tail - + sd_tuners->window_size + 1, MAX_ARRAY_SIZE); + for (scale = 1, count = 0; count < sd_tuners->window_size; + scale += scale, count++) { + pr_debug("load_array[%d][%d]: %d, scale: %d\n", + cpu, window_head, load_array[cpu][window_head], scale); + sum_load += (load_array[cpu][window_head] * scale); + sum_scale += scale; + window_head++; + window_head = mod(window_head, MAX_ARRAY_SIZE); + } + + return sum_load / sum_scale; +} + +/* + * Every sampling_rate, we check, if current idle time is less than 20% + * (default), then we try to increase frequency. Every sampling_rate, we look + * for the lowest frequency which can sustain the load while keeping idle time + * over 30%. If such a frequency exist, we try to decrease to this frequency. + * + * Any frequency increase takes it to the maximum frequency. Frequency reduction + * happens at minimum steps of 5% (default) of current frequency + */ +static void sd_check_cpu(int cpu, unsigned int load) +{ + struct od_cpu_dbs_info_s *dbs_info = &per_cpu(sd_cpu_dbs_info, cpu); + struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy; + struct dbs_data *dbs_data = policy->governor_data; + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int itself_avg_load = 0; + int local_cpu = 0; + + if (time_before(jiffies, boot_done)) + return; + + local_cpu = smp_processor_id(); + + if (local_cpu) + return; + + /* skip cpufreq adjustment if system enter into suspend */ + if (true == sd_tuners->is_suspend) { + pr_info("%s: is_suspend=%s, skip cpufreq adjust\n", + __func__, sd_tuners->is_suspend?"true":"false"); + goto plug_check; + } + + dbs_info->freq_lo = 0; + pr_debug("efficient load %d, cur freq %d, online CPUs %d\n", + load, policy->cur, num_online_cpus()); + +#ifdef CONFIG_TOUCH_BOOST + if (atomic_read(&g_atomic_tb_cnt)) { + atomic_sub_return(1, &g_atomic_tb_cnt); + goto plug_check; + } +#endif + + /* Check for frequency increase */ + if (load > sd_tuners->up_threshold) { + /* If switching to max speed, apply sampling_down_factor */ + if (policy->cur < policy->max) + dbs_info->rate_mult = + sd_tuners->sampling_down_factor; + if (num_online_cpus() == sd_tuners->cpu_num_limit) + dbs_freq_increase(policy, policy->max); + else + dbs_freq_increase(policy, policy->max-1); + goto plug_check; + } + + /* Check for frequency decrease */ + /* if we cannot reduce the frequency anymore, break out early */ + if (policy->cur == policy->min) + goto plug_check; + + /* + * The optimal frequency is the frequency that is the lowest that can + * support the current CPU usage without triggering the up policy. To be + * safe, we focus 3 points under the threshold. + */ + if (load < sd_tuners->adj_up_threshold) { + unsigned int freq_next; + unsigned int load_freq; + load_freq = load * policy->cur; + freq_next = load_freq / sd_tuners->adj_up_threshold; + /* No longer fully busy, reset rate_mult */ + dbs_info->rate_mult = 1; + + if (freq_next < policy->min) + freq_next = policy->min; + + if (!sd_tuners->powersave_bias) { + __cpufreq_driver_target(policy, freq_next, + CPUFREQ_RELATION_L); + goto plug_check; + } + + freq_next = sd_ops.powersave_bias_target(policy, freq_next, + CPUFREQ_RELATION_L); + __cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_L); + + } + +plug_check: + + /* skip cpu hotplug check if hotplug is disabled */ + if (sd_tuners->cpu_hotplug_disable) + return; + + /* cpu plugin check */ + itself_avg_load = sd_avg_load(cpu, sd_tuners, load); + pr_debug(" itself_avg_load %d\n", itself_avg_load); + if (num_online_cpus() < sd_tuners->cpu_num_limit) { + int cpu_up_threshold; + + if (num_online_cpus() == 1) + cpu_up_threshold = sd_tuners->cpu_up_mid_threshold; + else + cpu_up_threshold = sd_tuners->cpu_up_high_threshold; + + if (itself_avg_load > cpu_up_threshold) { + schedule_delayed_work_on(0, &plugin_work, 0); + return; + } + } + + /* cpu unplug check */ + if (num_online_cpus() > 1) { + int cpu_down_threshold; + + if (num_online_cpus() > 2) + cpu_down_threshold = sd_tuners->cpu_down_high_threshold; + else + cpu_down_threshold = sd_tuners->cpu_down_mid_threshold; + + if (itself_avg_load < cpu_down_threshold) + schedule_delayed_work_on(0, &unplug_work, 0); + } + +#if 0 + itself_avg_load = sd_unplug_avg_load1(local_cpu, sd_tuners, load); + /* cpu plugin check */ + if(num_online_cpus() < sd_tuners->cpu_num_limit) { + cpu_score += cpu_evaluate_score(policy->cpu,sd_tuners, itself_avg_load); + if (cpu_score < 0) + cpu_score = 0; + if (cpu_score >= sd_tuners->cpu_score_up_threshold) { + pr_debug("cpu_score=%d, begin plugin cpu!\n", cpu_score); + cpu_score = 0; + schedule_delayed_work_on(0, &plugin_work, 0); + return; + } + } + + + /* cpu unplug check */ + puwi = &per_cpu(uwi, local_cpu); + if((num_online_cpus() > 1) && (dvfs_unplug_select == 1)){ + percpu_total_load[local_cpu] += load; + percpu_check_count[local_cpu]++; + if(percpu_check_count[cpu] == sd_tuners->cpu_down_count) { + /* calculate itself's average load */ + itself_avg_load = percpu_total_load[local_cpu]/sd_tuners->cpu_down_count; + pr_debug("check unplug: for cpu%u avg_load=%d\n", local_cpu, itself_avg_load); + if(itself_avg_load < sd_tuners->cpu_down_threshold) { + pr_info("cpu%u's avg_load=%d,begin unplug cpu\n", + policy->cpu, itself_avg_load); + schedule_delayed_work_on(0, &unplug_work, 0); + } + percpu_check_count[local_cpu] = 0; + percpu_total_load[local_cpu] = 0; + } + } + else if((num_online_cpus() > 1) && (dvfs_unplug_select == 2)) + { + /* calculate itself's average load */ + pr_debug("check unplug: for cpu%u avg_load=%d\n", local_cpu, itself_avg_load); + if(itself_avg_load < sd_tuners->cpu_down_threshold) + { + pr_info("cpu%u's avg_load=%d,begin unplug cpu\n", + local_cpu, itself_avg_load); + percpu_load[local_cpu] = 0; + cur_window_size[local_cpu] = 0; + cur_window_index[local_cpu] = 0; + cur_window_cnt[local_cpu] = 0; + prev_window_size[local_cpu] = 0; + first_window_flag[local_cpu] = 0; + sum_load[local_cpu] = 0; + memset(&ga_percpu_total_load[local_cpu][0],0,sizeof(int) * MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + schedule_delayed_work_on(0, &unplug_work, 0); + } + } + else if((num_online_cpus() > 1) && (dvfs_unplug_select > 2)) + { + /* calculate itself's average load */ + itself_avg_load = sd_unplug_avg_load11(local_cpu, sd_tuners, load); + pr_debug("check unplug: for cpu%u avg_load=%d\n", local_cpu, itself_avg_load); + if(itself_avg_load < sd_tuners->cpu_down_threshold) + { + pr_info("cpu%u's avg_load=%d,begin unplug cpu\n", + local_cpu, itself_avg_load); + percpu_load[local_cpu] = 0; + cur_window_size[local_cpu] = 0; + cur_window_index[local_cpu] = 0; + cur_window_cnt[local_cpu] = 0; + prev_window_size[local_cpu] = 0; + first_window_flag[local_cpu] = 0; + sum_load[local_cpu] = 0; + memset(&ga_percpu_total_load[local_cpu][0],0,sizeof(int) * MAX_PERCPU_TOTAL_LOAD_WINDOW_SIZE); + schedule_delayed_work_on(0, &unplug_work, 0); + } + } +#endif +} + +static void sd_dbs_timer(struct work_struct *work) +{ + struct od_cpu_dbs_info_s *dbs_info = + container_of(work, struct od_cpu_dbs_info_s, cdbs.work.work); + unsigned int cpu = dbs_info->cdbs.cur_policy->cpu; + struct od_cpu_dbs_info_s *core_dbs_info = &per_cpu(sd_cpu_dbs_info, + cpu); + struct dbs_data *dbs_data = dbs_info->cdbs.cur_policy->governor_data; + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + int delay = 0, sample_type = core_dbs_info->sample_type; + bool modify_all = false; + + if (smp_processor_id()) + return; + + /* CPUFREQ_GOV_STOP will set cur_policy as NULL*/ + if (NULL == core_dbs_info->cdbs.cur_policy) { + pr_err("%s cur_policy is cleared, just exit\n", __func__); + return; + } + + mutex_lock(&core_dbs_info->cdbs.timer_mutex); + if (time_before(jiffies, boot_done)) + goto max_delay; + + if (!need_load_eval(&core_dbs_info->cdbs, sd_tuners->sampling_rate)) { + modify_all = false; + goto max_delay; + } + + /* Common NORMAL_SAMPLE setup */ + core_dbs_info->sample_type = OD_NORMAL_SAMPLE; + if (sample_type == OD_SUB_SAMPLE) { + delay = core_dbs_info->freq_lo_jiffies; + __cpufreq_driver_target(core_dbs_info->cdbs.cur_policy, + core_dbs_info->freq_lo, CPUFREQ_RELATION_H); + } else { + dbs_check_cpu(dbs_data, cpu); + if (core_dbs_info->freq_lo) { + /* Setup timer for SUB_SAMPLE */ + core_dbs_info->sample_type = OD_SUB_SAMPLE; + delay = core_dbs_info->freq_hi_jiffies; + } + } + +max_delay: + if (!delay) + delay = delay_for_sampling_rate(sd_tuners->sampling_rate + * core_dbs_info->rate_mult); + + gov_queue_work(dbs_data, dbs_info->cdbs.cur_policy, delay, modify_all); + mutex_unlock(&core_dbs_info->cdbs.timer_mutex); +} + +/************************** sysfs interface ************************/ +static struct common_dbs_data sd_dbs_cdata; + +/** + * update_sampling_rate - update sampling rate effective immediately if needed. + * @new_rate: new sampling rate + * + * If new rate is smaller than the old, simply updating + * dbs_tuners_int.sampling_rate might not be appropriate. For example, if the + * original sampling_rate was 1 second and the requested new sampling rate is 10 + * ms because the user needs immediate reaction from ondemand governor, but not + * sure if higher frequency will be required or not, then, the governor may + * change the sampling rate too late; up to 1 second later. Thus, if we are + * reducing the sampling rate, we need to make the new value effective + * immediately. + */ +static void update_sampling_rate(struct dbs_data *dbs_data, + unsigned int new_rate) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + int cpu; + + sd_tuners->sampling_rate = new_rate = max(new_rate, + dbs_data->min_sampling_rate); + + for_each_online_cpu(cpu) { + struct cpufreq_policy *policy; + struct od_cpu_dbs_info_s *dbs_info; + unsigned long next_sampling, appointed_at; + + policy = cpufreq_cpu_get(cpu); + if (!policy) + continue; + if (policy->governor != &cpufreq_gov_sprdemand) { + cpufreq_cpu_put(policy); + continue; + } + dbs_info = &per_cpu(sd_cpu_dbs_info, cpu); + cpufreq_cpu_put(policy); + + mutex_lock(&dbs_info->cdbs.timer_mutex); + + if (!delayed_work_pending(&dbs_info->cdbs.work)) { + mutex_unlock(&dbs_info->cdbs.timer_mutex); + continue; + } + + next_sampling = jiffies + usecs_to_jiffies(new_rate); + appointed_at = dbs_info->cdbs.work.timer.expires; + + if (time_before(next_sampling, appointed_at)) { + + mutex_unlock(&dbs_info->cdbs.timer_mutex); + cancel_delayed_work_sync(&dbs_info->cdbs.work); + mutex_lock(&dbs_info->cdbs.timer_mutex); + + gov_queue_work(dbs_data, dbs_info->cdbs.cur_policy, + usecs_to_jiffies(new_rate), true); + + } + mutex_unlock(&dbs_info->cdbs.timer_mutex); + } +} + +static ssize_t store_sampling_rate(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + if (ret != 1) + return -EINVAL; + + update_sampling_rate(dbs_data, input); + return count; +} + +static ssize_t store_io_is_busy(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + unsigned int j; + + ret = sscanf(buf, "%u", &input); + if (ret != 1) + return -EINVAL; + sd_tuners->io_is_busy = !!input; + + /* we need to re-evaluate prev_cpu_idle */ + for_each_online_cpu(j) { + struct od_cpu_dbs_info_s *dbs_info = &per_cpu(sd_cpu_dbs_info, + j); + dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j, + &dbs_info->cdbs.prev_cpu_wall, sd_tuners->io_is_busy); + } + return count; +} + +static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || + input < MIN_FREQUENCY_UP_THRESHOLD) { + return -EINVAL; + } + /* Calculate the new adj_up_threshold */ + sd_tuners->adj_up_threshold += input; + sd_tuners->adj_up_threshold -= sd_tuners->up_threshold; + + sd_tuners->up_threshold = input; + return count; +} + +static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data, + const char *buf, size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input, j; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1) + return -EINVAL; + sd_tuners->sampling_down_factor = input; + + /* Reset down sampling multiplier in case it was active */ + for_each_online_cpu(j) { + struct od_cpu_dbs_info_s *dbs_info = &per_cpu(sd_cpu_dbs_info, + j); + dbs_info->rate_mult = 1; + } + return count; +} + +static ssize_t store_ignore_nice(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + + unsigned int j; + + ret = sscanf(buf, "%u", &input); + if (ret != 1) + return -EINVAL; + + if (input > 1) + input = 1; + + if (input == sd_tuners->ignore_nice) { /* nothing to do */ + return count; + } + sd_tuners->ignore_nice = input; + + /* we need to re-evaluate prev_cpu_idle */ + for_each_online_cpu(j) { + struct od_cpu_dbs_info_s *dbs_info; + dbs_info = &per_cpu(sd_cpu_dbs_info, j); + dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j, + &dbs_info->cdbs.prev_cpu_wall, sd_tuners->io_is_busy); + if (sd_tuners->ignore_nice) + dbs_info->cdbs.prev_cpu_nice = + kcpustat_cpu(j).cpustat[CPUTIME_NICE]; + + } + return count; +} + +static ssize_t store_powersave_bias(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) + return -EINVAL; + + if (input > 1000) + input = 1000; + + sd_tuners->powersave_bias = input; + sprdemand_powersave_bias_init(); + return count; +} + +static ssize_t store_cpu_num_limit(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->cpu_num_limit = input; + return count; +} + +static ssize_t store_cpu_score_up_threshold(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->cpu_score_up_threshold = input; + return count; +} + +static ssize_t store_load_critical(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_critical = input; + return count; +} + +static ssize_t store_load_hi(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_hi = input; + return count; +} + +static ssize_t store_load_mid(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_mid = input; + return count; +} + +static ssize_t store_load_light(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_light = input; + return count; +} + +static ssize_t store_load_lo(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_lo = input; + return count; +} + +static ssize_t store_load_critical_score(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + int input; + int ret; + ret = sscanf(buf, "%d", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_critical_score = input; + return count; +} + +static ssize_t store_load_hi_score(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + int input; + int ret; + ret = sscanf(buf, "%d", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_hi_score = input; + return count; +} + + +static ssize_t store_load_mid_score(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + int input; + int ret; + ret = sscanf(buf, "%d", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_mid_score = input; + return count; +} + +static ssize_t store_load_light_score(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + int input; + int ret; + ret = sscanf(buf, "%d", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_light_score = input; + return count; +} + +static ssize_t store_load_lo_score(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + int input; + int ret; + ret = sscanf(buf, "%d", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->load_lo_score = input; + return count; +} + +static ssize_t store_cpu_down_threshold(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->cpu_down_threshold = input; + return count; +} + +static ssize_t store_cpu_down_count(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + sd_tuners->cpu_down_count = input; + return count; +} + +static ssize_t store_cpu_hotplug_disable(struct dbs_data *dbs_data, const char *buf, + size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input, cpu; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) { + return -EINVAL; + } + + if (sd_tuners->cpu_hotplug_disable == input) { + return count; + } + if (sd_tuners->cpu_num_limit > 1) + sd_tuners->cpu_hotplug_disable = input; + + if (sd_tuners->cpu_hotplug_disable > 0) + cpu_hotplug_disable_set = true; + else + cpu_hotplug_disable_set = false; + + smp_wmb(); + /* plug-in all offline cpu mandatory if we didn't + * enbale CPU_DYNAMIC_HOTPLUG + */ +#ifdef CONFIG_HOTPLUG_CPU + if (sd_tuners->cpu_hotplug_disable && + num_online_cpus() < sd_tuners->cpu_num_limit) { + schedule_work_on(0, &plugin_all_work); + do { + msleep(5); + pr_debug("wait for all cpu online!\n"); + } while (num_online_cpus() < sd_tuners->cpu_num_limit); + } +#endif + return count; +} + +static ssize_t store_cpu_up_mid_threshold(struct dbs_data *dbs_data, + const char *buf, size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) + return -EINVAL; + + sd_tuners->cpu_up_mid_threshold = input; + return count; +} + +static ssize_t store_cpu_up_high_threshold(struct dbs_data *dbs_data, + const char *buf, size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) + return -EINVAL; + + sd_tuners->cpu_up_high_threshold = input; + return count; +} + +static ssize_t store_cpu_down_mid_threshold(struct dbs_data *dbs_data, + const char *buf, size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) + return -EINVAL; + + sd_tuners->cpu_down_mid_threshold = input; + return count; +} + +static ssize_t store_cpu_down_high_threshold(struct dbs_data *dbs_data, + const char *buf, size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) + return -EINVAL; + + sd_tuners->cpu_down_high_threshold = input; + return count; +} + +static ssize_t store_window_size(struct dbs_data *dbs_data, + const char *buf, size_t count) +{ + struct sd_dbs_tuners *sd_tuners = dbs_data->tuners; + unsigned int input; + int ret; + ret = sscanf(buf, "%u", &input); + + if (ret != 1) + return -EINVAL; + + if (input > MAX_ARRAY_SIZE || input < 1) + return -EINVAL; + + sd_tuners->window_size = input; + return count; +} + +show_store_one(sd, sampling_rate); +show_store_one(sd, io_is_busy); +show_store_one(sd, up_threshold); +show_store_one(sd, sampling_down_factor); +show_store_one(sd, ignore_nice); +show_store_one(sd, powersave_bias); +declare_show_sampling_rate_min(sd); +show_store_one(sd, cpu_score_up_threshold); +show_store_one(sd, load_critical); +show_store_one(sd, load_hi); +show_store_one(sd, load_mid); +show_store_one(sd, load_light); +show_store_one(sd, load_lo); +show_store_one(sd, load_critical_score); +show_store_one(sd, load_hi_score); +show_store_one(sd, load_mid_score); +show_store_one(sd, load_light_score); +show_store_one(sd, load_lo_score); +show_store_one(sd, cpu_down_threshold); +show_store_one(sd, cpu_down_count); +show_store_one(sd, cpu_hotplug_disable); +show_store_one(sd, cpu_num_limit); +show_store_one(sd, cpu_up_mid_threshold); +show_store_one(sd, cpu_up_high_threshold); +show_store_one(sd, cpu_down_mid_threshold); +show_store_one(sd, cpu_down_high_threshold); +show_store_one(sd, window_size); + +gov_sys_pol_attr_rw(sampling_rate); +gov_sys_pol_attr_rw(io_is_busy); +gov_sys_pol_attr_rw(up_threshold); +gov_sys_pol_attr_rw(sampling_down_factor); +gov_sys_pol_attr_rw(ignore_nice); +gov_sys_pol_attr_rw(powersave_bias); +gov_sys_pol_attr_ro(sampling_rate_min); +gov_sys_pol_attr_rw(cpu_score_up_threshold); +gov_sys_pol_attr_rw(load_critical); +gov_sys_pol_attr_rw(load_hi); +gov_sys_pol_attr_rw(load_mid); +gov_sys_pol_attr_rw(load_light); +gov_sys_pol_attr_rw(load_lo); +gov_sys_pol_attr_rw(load_critical_score); +gov_sys_pol_attr_rw(load_hi_score); +gov_sys_pol_attr_rw(load_mid_score); +gov_sys_pol_attr_rw(load_light_score); +gov_sys_pol_attr_rw(load_lo_score); +gov_sys_pol_attr_rw(cpu_down_threshold); +gov_sys_pol_attr_rw(cpu_down_count); +gov_sys_pol_attr_rw(cpu_hotplug_disable); +gov_sys_pol_attr_rw(cpu_num_limit); +gov_sys_pol_attr_rw(cpu_up_mid_threshold); +gov_sys_pol_attr_rw(cpu_up_high_threshold); +gov_sys_pol_attr_rw(cpu_down_mid_threshold); +gov_sys_pol_attr_rw(cpu_down_high_threshold); +gov_sys_pol_attr_rw(window_size); + +static struct attribute *dbs_attributes_gov_sys[] = { + &sampling_rate_min_gov_sys.attr, + &sampling_rate_gov_sys.attr, + &up_threshold_gov_sys.attr, + &sampling_down_factor_gov_sys.attr, + &ignore_nice_gov_sys.attr, + &powersave_bias_gov_sys.attr, + &io_is_busy_gov_sys.attr, + &cpu_score_up_threshold_gov_sys.attr, + &load_critical_gov_sys.attr, + &load_hi_gov_sys.attr, + &load_mid_gov_sys.attr, + &load_light_gov_sys.attr, + &load_lo_gov_sys.attr, + &load_critical_score_gov_sys.attr, + &load_hi_score_gov_sys.attr, + &load_mid_score_gov_sys.attr, + &load_light_score_gov_sys.attr, + &load_lo_score_gov_sys.attr, + &cpu_down_threshold_gov_sys.attr, + &cpu_down_count_gov_sys.attr, + &cpu_hotplug_disable_gov_sys.attr, + &cpu_num_limit_gov_sys.attr, + &cpu_up_mid_threshold_gov_sys.attr, + &cpu_up_high_threshold_gov_sys.attr, + &cpu_down_mid_threshold_gov_sys.attr, + &cpu_down_high_threshold_gov_sys.attr, + &window_size_gov_sys.attr, + NULL +}; + +static struct attribute_group sd_attr_group_gov_sys = { + .attrs = dbs_attributes_gov_sys, + .name = "sprdemand", +}; + +static struct attribute *dbs_attributes_gov_pol[] = { + &sampling_rate_min_gov_pol.attr, + &sampling_rate_gov_pol.attr, + &up_threshold_gov_pol.attr, + &sampling_down_factor_gov_pol.attr, + &ignore_nice_gov_pol.attr, + &powersave_bias_gov_pol.attr, + &io_is_busy_gov_pol.attr, + &cpu_score_up_threshold_gov_pol.attr, + &load_critical_gov_pol.attr, + &load_hi_gov_pol.attr, + &load_mid_gov_pol.attr, + &load_light_gov_pol.attr, + &load_lo_gov_pol.attr, + &load_critical_score_gov_pol.attr, + &load_hi_score_gov_pol.attr, + &load_mid_score_gov_pol.attr, + &load_light_score_gov_pol.attr, + &load_lo_score_gov_pol.attr, + &cpu_down_threshold_gov_pol.attr, + &cpu_down_count_gov_pol.attr, + &cpu_hotplug_disable_gov_pol.attr, + &cpu_num_limit_gov_pol.attr, + &cpu_up_mid_threshold_gov_pol.attr, + &cpu_up_high_threshold_gov_pol.attr, + &cpu_down_mid_threshold_gov_pol.attr, + &cpu_down_high_threshold_gov_pol.attr, + &window_size_gov_pol.attr, + NULL +}; + +static struct attribute_group sd_attr_group_gov_pol = { + .attrs = dbs_attributes_gov_pol, + .name = "sprdemand", +}; + +/************************** sysfs end ************************/ + +static int sd_init(struct dbs_data *dbs_data) +{ + struct sd_dbs_tuners *tuners; + u64 idle_time; + int cpu, i; + + tuners = kzalloc(sizeof(struct sd_dbs_tuners), GFP_KERNEL); + + if (!tuners) { + pr_err("%s: kzalloc failed\n", __func__); + return -ENOMEM; + } + + cpu = get_cpu(); + idle_time = get_cpu_idle_time_us(cpu, NULL); + put_cpu(); + if (idle_time != -1ULL) { + /* Idle micro accounting is supported. Use finer thresholds */ + tuners->up_threshold = MICRO_FREQUENCY_UP_THRESHOLD; + tuners->adj_up_threshold = MICRO_FREQUENCY_UP_THRESHOLD - + MICRO_FREQUENCY_DOWN_DIFFERENTIAL; + /* + * In nohz/micro accounting case we set the minimum frequency + * not depending on HZ, but fixed (very low). The deferred + * timer might skip some samples if idle/sleeping as needed. + */ + dbs_data->min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE; + } else { + tuners->up_threshold = DEF_FREQUENCY_UP_THRESHOLD; + tuners->adj_up_threshold = DEF_FREQUENCY_UP_THRESHOLD - + DEF_FREQUENCY_DOWN_DIFFERENTIAL; + + /* For correct statistics, we need 10 ticks for each measure */ + dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO * + jiffies_to_usecs(10); + } + + tuners->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR; + tuners->ignore_nice = 0; + tuners->powersave_bias = 0; + tuners->io_is_busy = should_io_be_busy(); + + tuners->cpu_hotplug_disable = true; + tuners->is_suspend = false; + tuners->cpu_score_up_threshold = DEF_CPU_SCORE_UP_THRESHOLD; + tuners->load_critical = LOAD_CRITICAL; + tuners->load_hi = LOAD_HI; + tuners->load_mid = LOAD_MID; + tuners->load_light = LOAD_LIGHT; + tuners->load_lo = LOAD_LO; + tuners->load_critical_score = LOAD_CRITICAL_SCORE; + tuners->load_hi_score = LOAD_HI_SCORE; + tuners->load_mid_score = LOAD_MID_SCORE; + tuners->load_light_score = LOAD_LIGHT_SCORE; + tuners->load_lo_score = LOAD_LO_SCORE; + tuners->cpu_down_threshold = DEF_CPU_LOAD_DOWN_THRESHOLD; + tuners->cpu_down_count = DEF_CPU_DOWN_COUNT; + tuners->cpu_up_mid_threshold = DEF_CPU_UP_MID_THRESHOLD; + tuners->cpu_up_high_threshold = DEF_CPU_UP_HIGH_THRESHOLD; + tuners->cpu_down_mid_threshold = DEF_CPU_DOWN_MID_THRESHOLD; + tuners->cpu_down_high_threshold = DEF_CPU_DOWN_HIGH_THRESHOLD; + tuners->window_size = LOAD_WINDOW_SIZE; + tuners->cpu_num_limit = nr_cpu_ids; + if (tuners->cpu_num_limit > 1) + tuners->cpu_hotplug_disable = false; + + memcpy(g_sd_tuners,tuners,sizeof(struct sd_dbs_tuners)); + + dbs_data->tuners = tuners; + mutex_init(&dbs_data->mutex); + + INIT_DELAYED_WORK(&plugin_work, sprd_plugin_one_cpu); + INIT_DELAYED_WORK(&unplug_work, sprd_unplug_one_cpu); + INIT_WORK(&thm_unplug_work, sprd_thm_unplug_cpu); + INIT_WORK(&plugin_all_work, sprd_plugin_all_cpu); + INIT_WORK(&unplug_all_work, sprd_unplug_all_cpu); + +#if 0 + for_each_possible_cpu(i) { + puwi = &per_cpu(uwi, i); + puwi->cpuid = i; + puwi->dbs_data = dbs_data; + INIT_DELAYED_WORK(&puwi->unplug_work, sprd_unplug_one_cpu); + } +#endif + + return 0; +} + +static void sd_exit(struct dbs_data *dbs_data) +{ + kfree(dbs_data->tuners); +} + +define_get_cpu_dbs_routines(sd_cpu_dbs_info); + +static struct od_ops sd_ops = { + .powersave_bias_init_cpu = sprdemand_powersave_bias_init_cpu, + .powersave_bias_target = generic_powersave_bias_target, + .freq_increase = dbs_freq_increase, +}; + +static struct common_dbs_data sd_dbs_cdata = { + /* sprdemand belong to ondemand gov */ + .governor = GOV_ONDEMAND, + .attr_group_gov_sys = &sd_attr_group_gov_sys, + .attr_group_gov_pol = &sd_attr_group_gov_pol, + .get_cpu_cdbs = get_cpu_cdbs, + .get_cpu_dbs_info_s = get_cpu_dbs_info_s, + .gov_dbs_timer = sd_dbs_timer, + .gov_check_cpu = sd_check_cpu, + .gov_ops = &sd_ops, + .init = sd_init, + .exit = sd_exit, +}; + +static int sd_cpufreq_governor_dbs(struct cpufreq_policy *policy, + unsigned int event) +{ + return cpufreq_governor_dbs(policy, &sd_dbs_cdata, event); +} + +#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_SPRDEMAND +static +#endif +struct cpufreq_governor cpufreq_gov_sprdemand = { + .name = "sprdemand", + .governor = sd_cpufreq_governor_dbs, + .max_transition_latency = TRANSITION_LATENCY_LIMIT, + .owner = THIS_MODULE, +}; + +static void sprd_thm_unplug_cpu(struct work_struct *work) +{ + struct cpufreq_policy *policy = cpufreq_cpu_get(0); + struct dbs_data *dbs_data = policy->governor_data; + struct sd_dbs_tuners *sd_tuners = NULL; + int cpuid, max_core, cpus, i; + + if(NULL == dbs_data) + { + pr_info("%s return\n", __func__); + if (g_sd_tuners == NULL) + return ; + sd_tuners = g_sd_tuners; + } + else + { + sd_tuners = dbs_data->tuners; + } + +#ifdef CONFIG_HOTPLUG_CPU + cpus = num_online_cpus(); + max_core = sd_tuners->cpu_num_limit; + for (i = 0; i < cpus - max_core; ++i){ + if (!sd_tuners->cpu_hotplug_disable) { + cpuid = cpumask_next(0, cpu_online_mask); + pr_info("!! we gonna unplug cpu%d !!\n", cpuid); + if (cpu_down(cpuid)){ + pr_info("unplug cpu%d failed!\n", cpuid); + } + } + } +#endif + return; +} + +static int sprdemand_gov_pm_notifier_call(struct notifier_block *nb, + unsigned long event, void *dummy) +{ + struct cpufreq_policy *policy = cpufreq_cpu_get(0); + struct dbs_data *dbs_data = policy->governor_data; + struct sd_dbs_tuners *sd_tuners = NULL; + + if (NULL == dbs_data) { + pr_info("sprdemand_gov_pm_notifier_call governor %s return\n", policy->governor->name); + if (g_sd_tuners == NULL) + return NOTIFY_OK; + sd_tuners = g_sd_tuners; + } else { + sd_tuners = dbs_data->tuners; + } + + /* in suspend and hibernation process, we need set frequency to the orignal + * one to make sure all things go right */ + if (event == PM_SUSPEND_PREPARE || event == PM_HIBERNATION_PREPARE) { + pr_info(" %s, recv pm suspend notify\n", __func__ ); + cpu_num_limit_temp = sd_tuners->cpu_num_limit; + sd_tuners->cpu_num_limit = 1; + + if (!sd_tuners->cpu_hotplug_disable) + schedule_work_on(0, &unplug_all_work); + cpufreq_driver_target(policy, 1000000, CPUFREQ_RELATION_H); + + sd_tuners->is_suspend = true; + g_is_suspend = true; + pr_info(" %s, recv pm suspend notify done\n", __func__ ); + } + if (event == PM_POST_SUSPEND) { + sd_tuners->is_suspend = false; + g_is_suspend = false; + sd_tuners->cpu_num_limit = cpu_num_limit_temp ; + } + + return NOTIFY_OK; +} + +static struct notifier_block sprdemand_gov_pm_notifier = { + .notifier_call = sprdemand_gov_pm_notifier_call, +}; + +#ifdef CONFIG_TOUCH_BOOST +static void dbs_refresh_callback(struct work_struct *work) +{ + unsigned int cpu = smp_processor_id(); + struct od_cpu_dbs_info_s *core_dbs_info = &per_cpu(sd_cpu_dbs_info, + cpu); + struct cpufreq_policy *policy; + + policy = core_dbs_info->cdbs.cur_policy; + + if (!policy || g_is_suspend) { + return; + } + + if (policy->cur < policy->max) { + cpufreq_driver_target(policy, + policy->max, CPUFREQ_RELATION_H); + atomic_add(5, &g_atomic_tb_cnt); + + core_dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(cpu, + &core_dbs_info->cdbs.prev_cpu_wall, + should_io_be_busy()); + } +} + +static void dbs_input_event(struct input_handle *handle, unsigned int type, + unsigned int code, int value) +{ + int i; + bool ret; + + if (time_before(jiffies, boot_done)) + return; + + if (strcmp(handle->dev->name, "focaltech_ts")&& + strcmp(handle->dev->name,"msg2138_ts")) + return; + + if (time_after(jiffies, tp_time) && !atomic_read(&g_atomic_tb_cnt)) + tp_time = jiffies + HZ / 2; + else + return; + + up(&tb_sem); + +#if 0 + if (!dvfs_plug_select) + return; + + if (jiffies <= (tp_time + 10)) { + tp_time = jiffies; + return; + } + tp_time = jiffies; + ret = queue_work_on(0, input_wq, &dbs_refresh_work); + pr_debug("[DVFS] dbs_input_event %d\n",ret); +#endif +} + +static int dbs_input_connect(struct input_handler *handler, + struct input_dev *dev, const struct input_device_id *id) +{ + struct input_handle *handle; + int error; + + handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL); + if (!handle) + return -ENOMEM; + + handle->dev = dev; + handle->handler = handler; + handle->name = "cpufreq"; + + error = input_register_handle(handle); + if (error) + goto err2; + + error = input_open_device(handle); + if (error) + goto err1; + + pr_debug("[DVFS] dbs_input_connect register success\n"); + return 0; +err1: + pr_info("[DVFS] dbs_input_connect register fail err1\n"); + input_unregister_handle(handle); +err2: + pr_info("[DVFS] dbs_input_connect register fail err2\n"); + kfree(handle); + return error; +} + +static void dbs_input_disconnect(struct input_handle *handle) +{ + input_close_device(handle); + input_unregister_handle(handle); + kfree(handle); +} + +static const struct input_device_id dbs_ids[] = { + { .driver_info = 1 }, + { }, +}; + +void sprd_tb_thread() +{ + while (1) { + down(&tb_sem); + dbs_refresh_callback(NULL); + if (num_online_cpus() < 3) + schedule_delayed_work_on(0, &plugin_work, 0); + } +} + +struct input_handler dbs_input_handler = { + .event = dbs_input_event, + .connect = dbs_input_connect, + .disconnect = dbs_input_disconnect, + .name = "cpufreq_ond", + .id_table = dbs_ids, +}; +#endif + +static struct task_struct *ksprd_tb; +static int __init cpufreq_gov_dbs_init(void) +{ + int i = 0; + boot_done = jiffies + GOVERNOR_BOOT_TIME; +#if !(defined(CONFIG_MACH_SP9838AEA_5MOD) || defined(CONFIG_MACH_SP9838AEA_POWER_DEBUG) || defined(CONFIG_MACH_SP9838AEA_8CORE_LIGHT_SLEEP) || defined(CONFIG_MACH_SP9838AEA_FHD) || defined(CONFIG_MACH_SS_SHARKLT8) || defined(CONFIG_MACH_SS_SHARKLT8LIGHTSLEEP)) + register_pm_notifier(&sprdemand_gov_pm_notifier); +#endif + g_sd_tuners = kzalloc(sizeof(struct sd_dbs_tuners), GFP_KERNEL); + +#ifdef CONFIG_TOUCH_BOOST +#if 0 + input_wq = alloc_workqueue("iewq", WQ_MEM_RECLAIM|WQ_SYSFS, 1); + + if (!input_wq) + { + printk(KERN_ERR "Failed to create iewq workqueue\n"); + return -EFAULT; + } + + INIT_WORK(&dbs_refresh_work, dbs_refresh_callback); +#endif + tp_time = jiffies; + + if(input_register_handler(&dbs_input_handler)) + { + pr_err("[DVFS] input_register_handler failed\n"); + } + + sema_init(&tb_sem, 0); + + ksprd_tb = kthread_create(sprd_tb_thread, NULL, "sprd_tb_thread"); + + wake_up_process(ksprd_tb); +#endif + + return cpufreq_register_governor(&cpufreq_gov_sprdemand); +} + +static void __exit cpufreq_gov_dbs_exit(void) +{ + cpufreq_unregister_governor(&cpufreq_gov_sprdemand); + unregister_pm_notifier(&sprdemand_gov_pm_notifier); + +#ifdef CONFIG_TOUCH_BOOST + input_unregister_handler(&dbs_input_handler); + kthread_stop(ksprd_tb); +#endif +} + +MODULE_AUTHOR("Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>"); +MODULE_AUTHOR("Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>"); +MODULE_DESCRIPTION("'cpufreq_sprdemand' - A dynamic cpufreq governor for " + "Low Latency Frequency Transition capable processors"); +MODULE_LICENSE("GPL"); + +#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_SPRDEMAND +fs_initcall(cpufreq_gov_dbs_init); +#else +module_init(cpufreq_gov_dbs_init); +#endif +module_exit(cpufreq_gov_dbs_exit); |