projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix section mismatch warnings
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / cpufreq / cpufreq_hotplug.c
CommitLineData
6fa3eb70
S		 1/*
2 * drivers/cpufreq/cpufreq_hotplug.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
6 * Jun Nakajima <jun.nakajima@intel.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/cpufreq.h>
16#include <linux/init.h>
17#include <linux/kernel.h>
18#include <linux/kernel_stat.h>
19#include <linux/kobject.h>
20#include <linux/module.h>
21#include <linux/mutex.h>
22#include <linux/percpu-defs.h>
23#include <linux/slab.h>
24#include <linux/sysfs.h>
25#include <linux/tick.h>
26#include <linux/types.h>
27#include <linux/cpu.h>
28#include <linux/sched.h>
29#include <linux/sched/rt.h>
30#include <linux/kthread.h>
31#include <linux/input.h> /* <-XXX */
32#include <linux/slab.h> /* <-XXX */
33#include "mach/mt_cpufreq.h" /* <-XXX */
34
35#include "cpufreq_governor.h"
36
37/* Hot-plug governor macros */
38#define DEF_FREQUENCY_DOWN_DIFFERENTIAL (10)
39#define DEF_FREQUENCY_UP_THRESHOLD (80)
40#define DEF_SAMPLING_DOWN_FACTOR (1)
41#define MAX_SAMPLING_DOWN_FACTOR (100000)
42#define MICRO_FREQUENCY_DOWN_DIFFERENTIAL (15)
43#define MIN_FREQUENCY_DOWN_DIFFERENTIAL (5) /* <-XXX */
44#define MAX_FREQUENCY_DOWN_DIFFERENTIAL (20) /* <-XXX */
45#define MICRO_FREQUENCY_UP_THRESHOLD (85)
46#ifdef CONFIG_MTK_SDIOAUTOK_SUPPORT
47#define MICRO_FREQUENCY_MIN_SAMPLE_RATE (27000)
48#else
49#define MICRO_FREQUENCY_MIN_SAMPLE_RATE (30000)
50#endif
51#define MIN_FREQUENCY_UP_THRESHOLD (21)
52#define MAX_FREQUENCY_UP_THRESHOLD (100)
53
54/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
55/*
56 * cpu hotplug - macro
57 */
58#define DEF_CPU_DOWN_DIFFERENTIAL (10)
59#define MICRO_CPU_DOWN_DIFFERENTIAL (10)
60#define MIN_CPU_DOWN_DIFFERENTIAL (0)
61#define MAX_CPU_DOWN_DIFFERENTIAL (30)
62
63#define DEF_CPU_UP_THRESHOLD (90)
64#define MICRO_CPU_UP_THRESHOLD (90)
65#define MIN_CPU_UP_THRESHOLD (50)
66#define MAX_CPU_UP_THRESHOLD (100)
67
68#define DEF_CPU_UP_AVG_TIMES (10)
69#define MIN_CPU_UP_AVG_TIMES (1)
70#define MAX_CPU_UP_AVG_TIMES (20)
71
72#define DEF_CPU_DOWN_AVG_TIMES (100)
73#define MIN_CPU_DOWN_AVG_TIMES (20)
74#define MAX_CPU_DOWN_AVG_TIMES (200)
75
76#define DEF_CPU_INPUT_BOOST_ENABLE (1)
77#define DEF_CPU_INPUT_BOOST_NUM (2)
78
79#define DEF_CPU_RUSH_BOOST_ENABLE (1)
80
81#define DEF_CPU_RUSH_THRESHOLD (98)
82#define MICRO_CPU_RUSH_THRESHOLD (98)
83#define MIN_CPU_RUSH_THRESHOLD (80)
84#define MAX_CPU_RUSH_THRESHOLD (100)
85
86#define DEF_CPU_RUSH_AVG_TIMES (5)
87#define MIN_CPU_RUSH_AVG_TIMES (1)
88#define MAX_CPU_RUSH_AVG_TIMES (10)
89
90#define DEF_CPU_RUSH_TLP_TIMES (5)
91#define MIN_CPU_RUSH_TLP_TIMES (1)
92#define MAX_CPU_RUSH_TLP_TIMES (10)
93
94/* #define DEBUG_LOG */
95
96/*
97 * cpu hotplug - enum
98 */
99typedef enum {
100 CPU_HOTPLUG_WORK_TYPE_NONE = 0,
101 CPU_HOTPLUG_WORK_TYPE_BASE,
102 CPU_HOTPLUG_WORK_TYPE_LIMIT,
103 CPU_HOTPLUG_WORK_TYPE_UP,
104 CPU_HOTPLUG_WORK_TYPE_DOWN,
105 CPU_HOTPLUG_WORK_TYPE_RUSH,
106} cpu_hotplug_work_type_t;
107
108/*
109 * cpu hotplug - global variable, function declaration
110 */
111static DEFINE_MUTEX(hp_mutex);
112DEFINE_MUTEX(hp_onoff_mutex);
113
114int g_cpus_sum_load_current = 0; /* set global for information purpose */
115#ifdef CONFIG_HOTPLUG_CPU
116
117static long g_cpu_up_sum_load;
118static int g_cpu_up_count;
119static int g_cpu_up_load_index;
120static long g_cpu_up_load_history[MAX_CPU_UP_AVG_TIMES] = { 0 };
121
122static long g_cpu_down_sum_load;
123static int g_cpu_down_count;
124static int g_cpu_down_load_index;
125static long g_cpu_down_load_history[MAX_CPU_DOWN_AVG_TIMES] = { 0 };
126
127static cpu_hotplug_work_type_t g_trigger_hp_work;
128static unsigned int g_next_hp_action;
129static struct delayed_work hp_work;
130struct workqueue_struct *hp_wq = NULL;
131
132static int g_tlp_avg_current; /* set global for information purpose */
133static int g_tlp_avg_sum;
134static int g_tlp_avg_count;
135static int g_tlp_avg_index;
136static int g_tlp_avg_average; /* set global for information purpose */
137static int g_tlp_avg_history[MAX_CPU_RUSH_TLP_TIMES] = { 0 };
138
139static int g_tlp_iowait_av;
140
141static int g_cpu_rush_count;
142
143static void hp_reset_strategy_nolock(void);
144static void hp_reset_strategy(void);
145
146#else /* #ifdef CONFIG_HOTPLUG_CPU */
147
148static void hp_reset_strategy_nolock(void)
149{
150};
151
152#endif /* #ifdef CONFIG_HOTPLUG_CPU */
153
154/* dvfs - function declaration */
155static void dbs_freq_increase(struct cpufreq_policy *p, unsigned int freq);
156
157#if defined(CONFIG_THERMAL_LIMIT_TEST)
158extern unsigned int mt_cpufreq_thermal_test_limited_load(void);
159#endif
160
161static unsigned int dbs_ignore = 1;
162static unsigned int dbs_thermal_limited;
163static unsigned int dbs_thermal_limited_freq;
164
165/* dvfs thermal limit */
166void dbs_freq_thermal_limited(unsigned int limited, unsigned int freq)
167{
168 dbs_thermal_limited = limited;
169 dbs_thermal_limited_freq = freq;
170}
171EXPORT_SYMBOL(dbs_freq_thermal_limited);
172
173
174void (*cpufreq_freq_check) (enum mt_cpu_dvfs_id id) = NULL;
175/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
176
177static DEFINE_PER_CPU(struct hp_cpu_dbs_info_s, hp_cpu_dbs_info);
178
179static struct hp_ops hp_ops;
180
181#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_HOTPLUG
182static struct cpufreq_governor cpufreq_gov_hotplug;
183#endif
184
185static unsigned int default_powersave_bias;
186
187static void hotplug_powersave_bias_init_cpu(int cpu)
188{
189 struct hp_cpu_dbs_info_s *dbs_info = &per_cpu(hp_cpu_dbs_info, cpu);
190
191 dbs_info->freq_table = cpufreq_frequency_get_table(cpu);
192 dbs_info->freq_lo = 0;
193}
194
195/*
196 * Not all CPUs want IO time to be accounted as busy; this depends on how
197 * efficient idling at a higher frequency/voltage is.
198 * Pavel Machek says this is not so for various generations of AMD and old
199 * Intel systems.
200 * Mike Chan (android.com) claims this is also not true for ARM.
201 * Because of this, whitelist specific known (series) of CPUs by default, and
202 * leave all others up to the user.
203 */
204static int should_io_be_busy(void)
205{
206#if defined(CONFIG_X86)
207 /*
208 * For Intel, Core 2 (model 15) and later have an efficient idle.
209 */
210 if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL &&
211 boot_cpu_data.x86 == 6 && boot_cpu_data.x86_model >= 15)
212 return 1;
213#endif
214 return 1; /* io wait time should be subtracted from idle time // <-XXX */
215}
216
217/*
218 * Find right freq to be set now with powersave_bias on.
219 * Returns the freq_hi to be used right now and will set freq_hi_jiffies,
220 * freq_lo, and freq_lo_jiffies in percpu area for averaging freqs.
221 */
222static unsigned int generic_powersave_bias_target(struct cpufreq_policy *policy,
223 unsigned int freq_next, unsigned int relation)
224{
225 unsigned int freq_req, freq_reduc, freq_avg;
226 unsigned int freq_hi, freq_lo;
227 unsigned int index = 0;
228 unsigned int jiffies_total, jiffies_hi, jiffies_lo;
229 struct hp_cpu_dbs_info_s *dbs_info = &per_cpu(hp_cpu_dbs_info,
230 policy->cpu);
231 struct dbs_data *dbs_data = policy->governor_data;
232 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
233
234 if (!dbs_info->freq_table) {
235 dbs_info->freq_lo = 0;
236 dbs_info->freq_lo_jiffies = 0;
237 return freq_next;
238 }
239
240 cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_next, relation, &index);
241 freq_req = dbs_info->freq_table[index].frequency;
242 freq_reduc = freq_req * hp_tuners->powersave_bias / 1000;
243 freq_avg = freq_req - freq_reduc;
244
245 /* Find freq bounds for freq_avg in freq_table */
246 index = 0;
247 cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg,
248 CPUFREQ_RELATION_H, &index);
249 freq_lo = dbs_info->freq_table[index].frequency;
250 index = 0;
251 cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg,
252 CPUFREQ_RELATION_L, &index);
253 freq_hi = dbs_info->freq_table[index].frequency;
254
255 /* Find out how long we have to be in hi and lo freqs */
256 if (freq_hi == freq_lo) {
257 dbs_info->freq_lo = 0;
258 dbs_info->freq_lo_jiffies = 0;
259 return freq_lo;
260 }
261 jiffies_total = usecs_to_jiffies(hp_tuners->sampling_rate);
262 jiffies_hi = (freq_avg - freq_lo) * jiffies_total;
263 jiffies_hi += ((freq_hi - freq_lo) / 2);
264 jiffies_hi /= (freq_hi - freq_lo);
265 jiffies_lo = jiffies_total - jiffies_hi;
266 dbs_info->freq_lo = freq_lo;
267 dbs_info->freq_lo_jiffies = jiffies_lo;
268 dbs_info->freq_hi_jiffies = jiffies_hi;
269 return freq_hi;
270}
271
272static void hotplug_powersave_bias_init(void)
273{
274 int i;
275 for_each_online_cpu(i) {
276 hotplug_powersave_bias_init_cpu(i);
277 }
278}
279
280static void dbs_freq_increase(struct cpufreq_policy *p, unsigned int freq)
281{
282 struct dbs_data *dbs_data = p->governor_data;
283 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
284
285 if (hp_tuners->powersave_bias)
286 freq = hp_ops.powersave_bias_target(p, freq, CPUFREQ_RELATION_H);
287 else if (p->cur == p->max) {
288/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
289 if (dbs_ignore == 0) {
290 if ((dbs_thermal_limited == 1) && (freq > dbs_thermal_limited_freq)) {
291 freq = dbs_thermal_limited_freq;
292 pr_debug("[dbs_freq_increase] thermal limit freq = %d\n", freq);
293 }
294
295 dbs_ignore = 1;
296 } else
297/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
298 return;
299 }
300
301 __cpufreq_driver_target(p, freq, hp_tuners->powersave_bias ?
302 CPUFREQ_RELATION_L : CPUFREQ_RELATION_H);
303}
304
305/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
306/*
307 * cpu hotplug - function definition
308 */
309int hp_get_dynamic_cpu_hotplug_enable(void)
310{
311 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
312 struct hp_dbs_tuners *hp_tuners;
313
314 if (!dbs_data)
315 return 0;
316 hp_tuners = dbs_data->tuners;
317 if (!hp_tuners)
318 return 0;
319
320 return !(hp_tuners->is_cpu_hotplug_disable);
321}
322EXPORT_SYMBOL(hp_get_dynamic_cpu_hotplug_enable);
323
324void hp_set_dynamic_cpu_hotplug_enable(int enable)
325{
326 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
327 struct hp_dbs_tuners *hp_tuners;
328
329 if (!dbs_data)
330 return;
331 hp_tuners = dbs_data->tuners;
332 if (!hp_tuners)
333 return;
334
335 if (enable > 1 || enable < 0)
336 return;
337
338 mutex_lock(&hp_mutex);
339
340 if (hp_tuners->is_cpu_hotplug_disable && enable)
341 hp_reset_strategy_nolock();
342
343 hp_tuners->is_cpu_hotplug_disable = !enable;
344 mutex_unlock(&hp_mutex);
345}
346EXPORT_SYMBOL(hp_set_dynamic_cpu_hotplug_enable);
347
348void hp_limited_cpu_num(int num)
349{
350 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
351 struct hp_dbs_tuners *hp_tuners;
352
353 if (!dbs_data)
354 return;
355 hp_tuners = dbs_data->tuners;
356 if (!hp_tuners)
357 return;
358
359 if (num > num_possible_cpus() || num < 1)
360 return;
361
362 mutex_lock(&hp_mutex);
363 hp_tuners->cpu_num_limit = num;
364 mutex_unlock(&hp_mutex);
365}
366EXPORT_SYMBOL(hp_limited_cpu_num);
367
368void hp_based_cpu_num(int num)
369{
370 unsigned int online_cpus_count;
371 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
372 struct hp_dbs_tuners *hp_tuners;
373
374 if (!dbs_data)
375 return;
376 hp_tuners = dbs_data->tuners;
377 if (!hp_tuners)
378 return;
379
380 if (num > num_possible_cpus() || num < 1)
381 return;
382
383 mutex_lock(&hp_mutex);
384
385 hp_tuners->cpu_num_base = num;
386 online_cpus_count = num_online_cpus();
387#ifdef CONFIG_HOTPLUG_CPU
388
389 if (online_cpus_count < num && online_cpus_count < hp_tuners->cpu_num_limit) {
390 struct hp_cpu_dbs_info_s *dbs_info;
391 struct cpufreq_policy *policy;
392
393 dbs_info = &per_cpu(hp_cpu_dbs_info, 0); /* TODO: FIXME, cpu = 0 */
394 policy = dbs_info->cdbs.cur_policy;
395
396 dbs_freq_increase(policy, policy->max);
397 g_trigger_hp_work = CPU_HOTPLUG_WORK_TYPE_BASE;
398 /* schedule_delayed_work_on(0, &hp_work, 0); */
399 if (hp_wq == NULL)
400 pr_emerg("[power/hotplug] %s():%d, impossible\n", __func__, __LINE__);
401 else
402 queue_delayed_work_on(0, hp_wq, &hp_work, 0);
403 }
404#endif
405
406 mutex_unlock(&hp_mutex);
407}
408EXPORT_SYMBOL(hp_based_cpu_num);
409
410int hp_get_cpu_rush_boost_enable(void)
411{
412 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
413 struct hp_dbs_tuners *hp_tuners;
414
415 if (!dbs_data)
416 return 0;
417 hp_tuners = dbs_data->tuners;
418 if (!hp_tuners)
419 return 0;
420
421 return hp_tuners->cpu_rush_boost_enable;
422}
423EXPORT_SYMBOL(hp_get_cpu_rush_boost_enable);
424
425void hp_set_cpu_rush_boost_enable(int enable)
426{
427 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
428 struct hp_dbs_tuners *hp_tuners;
429
430 if (!dbs_data)
431 return;
432 hp_tuners = dbs_data->tuners;
433 if (!hp_tuners)
434 return;
435
436 if (enable > 1 || enable < 0)
437 return;
438
439 mutex_lock(&hp_mutex);
440 hp_tuners->cpu_rush_boost_enable = enable;
441 mutex_unlock(&hp_mutex);
442}
443EXPORT_SYMBOL(hp_set_cpu_rush_boost_enable);
444
445#ifdef CONFIG_HOTPLUG_CPU
446
447#ifdef CONFIG_MTK_SCHED_RQAVG_KS
448extern void sched_get_nr_running_avg(int *avg, int *iowait_avg);
449#else /* #ifdef CONFIG_MTK_SCHED_RQAVG_KS */
450static void sched_get_nr_running_avg(int *avg, int *iowait_avg)
451{
452 *avg = num_possible_cpus() * 100;
453}
454#endif /* #ifdef CONFIG_MTK_SCHED_RQAVG_KS */
455
456static void hp_reset_strategy_nolock(void)
457{
458 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
459 struct hp_dbs_tuners *hp_tuners;
460
461 if (!dbs_data)
462 return;
463 hp_tuners = dbs_data->tuners;
464 if (!hp_tuners)
465 return;
466
467 g_cpu_up_count = 0;
468 g_cpu_up_sum_load = 0;
469 g_cpu_up_load_index = 0;
470 g_cpu_up_load_history[hp_tuners->cpu_up_avg_times - 1] = 0;
471 /* memset(g_cpu_up_load_history, 0, sizeof(long) * MAX_CPU_UP_AVG_TIMES); */
472
473 g_cpu_down_count = 0;
474 g_cpu_down_sum_load = 0;
475 g_cpu_down_load_index = 0;
476 g_cpu_down_load_history[hp_tuners->cpu_down_avg_times - 1] = 0;
477 /* memset(g_cpu_down_load_history, 0, sizeof(long) * MAX_CPU_DOWN_AVG_TIMES); */
478
479 g_tlp_avg_sum = 0;
480 g_tlp_avg_count = 0;
481 g_tlp_avg_index = 0;
482 g_tlp_avg_history[hp_tuners->cpu_rush_tlp_times - 1] = 0;
483 g_cpu_rush_count = 0;
484
485 g_trigger_hp_work = CPU_HOTPLUG_WORK_TYPE_NONE;
486}
487
488static void hp_reset_strategy(void)
489{
490 mutex_lock(&hp_mutex);
491
492 hp_reset_strategy_nolock();
493
494 mutex_unlock(&hp_mutex);
495}
496
8ca3027e 497static void __cpuinit hp_work_handler(struct work_struct *work)
6fa3eb70
S		 498{
499 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
500 struct hp_dbs_tuners *hp_tuners;
501
502 if (!dbs_data)
503 return;
504 hp_tuners = dbs_data->tuners;
505 if (!hp_tuners)
506 return;
507
508 if (mutex_trylock(&hp_onoff_mutex)) {
509 if (!hp_tuners->is_cpu_hotplug_disable) {
510 unsigned int online_cpus_count = num_online_cpus();
511 unsigned int i;
512
513 pr_debug
514 ("[power/hotplug] hp_work_handler(%d)(%d)(%d)(%d)(%ld)(%ld)(%d)(%d) begin\n",
515 g_trigger_hp_work, g_tlp_avg_average, g_tlp_avg_current,
516 g_cpus_sum_load_current, g_cpu_up_sum_load, g_cpu_down_sum_load,
517 hp_tuners->cpu_num_base, hp_tuners->cpu_num_limit);
518
519 switch (g_trigger_hp_work) {
520 case CPU_HOTPLUG_WORK_TYPE_RUSH:
521 for (i = online_cpus_count;
522 i < min(g_next_hp_action, hp_tuners->cpu_num_limit); ++i)
523 cpu_up(i);
524
525 break;
526
527 case CPU_HOTPLUG_WORK_TYPE_BASE:
528 for (i = online_cpus_count;
529 i < min(hp_tuners->cpu_num_base, hp_tuners->cpu_num_limit);
530 ++i)
531 cpu_up(i);
532
533 break;
534
535 case CPU_HOTPLUG_WORK_TYPE_LIMIT:
536 for (i = online_cpus_count - 1; i >= hp_tuners->cpu_num_limit; --i)
537 cpu_down(i);
538
539 break;
540
541 case CPU_HOTPLUG_WORK_TYPE_UP:
542 for (i = online_cpus_count; i < g_next_hp_action; ++i)
543 cpu_up(i);
544
545 break;
546
547 case CPU_HOTPLUG_WORK_TYPE_DOWN:
548 for (i = online_cpus_count - 1; i >= g_next_hp_action; --i)
549 cpu_down(i);
550
551 break;
552
553 default:
554 for (i = online_cpus_count;
555 i < min(hp_tuners->cpu_input_boost_num,
556 hp_tuners->cpu_num_limit); ++i)
557 cpu_up(i);
558
559 /* pr_debug("[power/hotplug] cpu input boost\n"); */
560 break;
561 }
562
563 hp_reset_strategy();
564 dbs_ignore = 0; /* force trigger frequency scaling */
565
566 pr_debug("[power/hotplug] hp_work_handler end\n");
567
568 /*
569 if (g_next_hp_action) // turn on CPU
570 {
571 if (online_cpus_count < num_possible_cpus())
572 {
573 pr_debug("hp_work_handler: cpu_up(%d) kick off\n", online_cpus_count);
574 cpu_up(online_cpus_count);
575 hp_reset_strategy();
576 pr_debug("hp_work_handler: cpu_up(%d) completion\n", online_cpus_count);
577
578 dbs_ignore = 0; // force trigger frequency scaling
579 }
580 }
581 else // turn off CPU
582 {
583 if (online_cpus_count > 1)
584 {
585 pr_debug("hp_work_handler: cpu_down(%d) kick off\n", (online_cpus_count - 1));
586 cpu_down((online_cpus_count - 1));
587 hp_reset_strategy();
588 pr_debug("hp_work_handler: cpu_down(%d) completion\n", (online_cpus_count - 1));
589
590 dbs_ignore = 0; // force trigger frequency scaling
591 }
592 }
593 */
594 }
595
596 mutex_unlock(&hp_onoff_mutex);
597 }
598}
599#endif /* #ifdef CONFIG_HOTPLUG_CPU */
600/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
601
602/*
603 * Every sampling_rate, we check, if current idle time is less than 20%
604 * (default), then we try to increase frequency. Every sampling_rate, we look
605 * for the lowest frequency which can sustain the load while keeping idle time
606 * over 30%. If such a frequency exist, we try to decrease to this frequency.
607 *
608 * Any frequency increase takes it to the maximum frequency. Frequency reduction
609 * happens at minimum steps of 5% (default) of current frequency
610 */
611static void hp_check_cpu(int cpu, unsigned int load_freq)
612{
613 struct hp_cpu_dbs_info_s *dbs_info = &per_cpu(hp_cpu_dbs_info, cpu);
614 struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy;
615 struct dbs_data *dbs_data = policy->governor_data;
616 struct hp_dbs_tuners *hp_tuners;
617
618 if (!dbs_data)
619 return;
620 hp_tuners = dbs_data->tuners;
621 if (!hp_tuners)
622 return;
623
624 dbs_info->freq_lo = 0;
625
626 /* pr_emerg("***** cpu: %d, load_freq: %u, smp_processor_id: %d *****\n", cpu, load_freq, smp_processor_id()); */
627
628 /* Check for frequency increase */
629 if (load_freq > hp_tuners->up_threshold * policy->cur) {
630 /* If switching to max speed, apply sampling_down_factor */
631 if (policy->cur < policy->max)
632 dbs_info->rate_mult = hp_tuners->sampling_down_factor;
633 dbs_freq_increase(policy, policy->max);
634 goto hp_check; /* <-XXX */
635 }
636
637 /* Check for frequency decrease */
638 /* if we cannot reduce the frequency anymore, break out early */
639 if (policy->cur == policy->min)
640 goto hp_check; /* <-XXX */
641
642 /*
643 * The optimal frequency is the frequency that is the lowest that can
644 * support the current CPU usage without triggering the up policy. To be
645 * safe, we focus 10 points under the threshold.
646 */
647 if (load_freq < hp_tuners->adj_up_threshold * policy->cur) {
648 unsigned int freq_next;
649 freq_next = load_freq / hp_tuners->adj_up_threshold;
650
651 /* No longer fully busy, reset rate_mult */
652 dbs_info->rate_mult = 1;
653
654 if (freq_next < policy->min)
655 freq_next = policy->min;
656
657 if (!hp_tuners->powersave_bias) {
658 __cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_L);
659 } else {
660 freq_next = hp_ops.powersave_bias_target(policy, freq_next,
661 CPUFREQ_RELATION_L);
662 __cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_L);
663 }
664 }
665/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
666 hp_check:{
667#ifdef CONFIG_HOTPLUG_CPU
668 long cpus_sum_load_last_up = 0;
669 long cpus_sum_load_last_down = 0;
670 unsigned int online_cpus_count;
671
672 int v_tlp_avg_last = 0;
673#endif
674
675 /* If Hot Plug policy disable, return directly */
676 if (hp_tuners->is_cpu_hotplug_disable)
677 return;
678
679#ifdef CONFIG_HOTPLUG_CPU
680
681 if (g_trigger_hp_work != CPU_HOTPLUG_WORK_TYPE_NONE)
682 return;
683
684 mutex_lock(&hp_mutex);
685
686 online_cpus_count = num_online_cpus();
687
688 sched_get_nr_running_avg(&g_tlp_avg_current, &g_tlp_iowait_av);
689
690 v_tlp_avg_last = g_tlp_avg_history[g_tlp_avg_index];
691 g_tlp_avg_history[g_tlp_avg_index] = g_tlp_avg_current;
692 g_tlp_avg_sum += g_tlp_avg_current;
693
694 g_tlp_avg_index =
695 (g_tlp_avg_index + 1 ==
696 hp_tuners->cpu_rush_tlp_times) ? 0 : g_tlp_avg_index + 1;
697 g_tlp_avg_count++;
698
699 if (g_tlp_avg_count >= hp_tuners->cpu_rush_tlp_times) {
700 if (g_tlp_avg_sum > v_tlp_avg_last)
701 g_tlp_avg_sum -= v_tlp_avg_last;
702 else
703 g_tlp_avg_sum = 0;
704 }
705
706 g_tlp_avg_average = g_tlp_avg_sum / hp_tuners->cpu_rush_tlp_times;
707
708 if (hp_tuners->cpu_rush_boost_enable) {
709 /* pr_debug("@@@@@@@@@@@@@@@@@@@@@@@@@@@ tlp: %d @@@@@@@@@@@@@@@@@@@@@@@@@@@\n", g_tlp_avg_average); */
710
711 if (g_cpus_sum_load_current >
712 hp_tuners->cpu_rush_threshold * online_cpus_count)
713 ++g_cpu_rush_count;
714 else
715 g_cpu_rush_count = 0;
716
717 if ((g_cpu_rush_count >= hp_tuners->cpu_rush_avg_times) &&
718 (online_cpus_count * 100 < g_tlp_avg_average) &&
719 (online_cpus_count < hp_tuners->cpu_num_limit) &&
720 (online_cpus_count < num_possible_cpus())) {
721 dbs_freq_increase(policy, policy->max);
722 pr_debug("dbs_check_cpu: turn on CPU\n");
723 g_next_hp_action =
724 g_tlp_avg_average / 100 + (g_tlp_avg_average % 100 ? 1 : 0);
725
726 if (g_next_hp_action > num_possible_cpus())
727 g_next_hp_action = num_possible_cpus();
728
729 g_trigger_hp_work = CPU_HOTPLUG_WORK_TYPE_RUSH;
730 /* schedule_delayed_work_on(0, &hp_work, 0); */
731 if (hp_wq == NULL)
732 pr_emerg("[power/hotplug] %s():%d, impossible\n", __func__, __LINE__);
733 else
734 queue_delayed_work_on(0, hp_wq, &hp_work, 0);
735
736 goto hp_check_end;
737 }
738 }
739
740 if (online_cpus_count < hp_tuners->cpu_num_base
741 && online_cpus_count < hp_tuners->cpu_num_limit) {
742 dbs_freq_increase(policy, policy->max);
743 pr_debug("dbs_check_cpu: turn on CPU\n");
744 g_trigger_hp_work = CPU_HOTPLUG_WORK_TYPE_BASE;
745 /* schedule_delayed_work_on(0, &hp_work, 0); */
746 if (hp_wq == NULL)
747 pr_emerg("[power/hotplug] %s():%d, impossible\n", __func__, __LINE__);
748 else
749 queue_delayed_work_on(0, hp_wq, &hp_work, 0);
750
751 goto hp_check_end;
752 }
753
754 if (online_cpus_count > hp_tuners->cpu_num_limit) {
755 dbs_freq_increase(policy, policy->max);
756 pr_debug("dbs_check_cpu: turn off CPU\n");
757 g_trigger_hp_work = CPU_HOTPLUG_WORK_TYPE_LIMIT;
758 /* schedule_delayed_work_on(0, &hp_work, 0); */
759 if (hp_wq == NULL)
760 pr_emerg("[power/hotplug] %s():%d, impossible\n", __func__, __LINE__);
761 else
762 queue_delayed_work_on(0, hp_wq, &hp_work, 0);
763
764 goto hp_check_end;
765 }
766
767 /* Check CPU loading to power up slave CPU */
768 if (online_cpus_count < num_possible_cpus()) {
769 cpus_sum_load_last_up = g_cpu_up_load_history[g_cpu_up_load_index];
770 g_cpu_up_load_history[g_cpu_up_load_index] = g_cpus_sum_load_current;
771 g_cpu_up_sum_load += g_cpus_sum_load_current;
772
773 g_cpu_up_count++;
774 g_cpu_up_load_index =
775 (g_cpu_up_load_index + 1 ==
776 hp_tuners->cpu_up_avg_times) ? 0 : g_cpu_up_load_index + 1;
777
778 if (g_cpu_up_count >= hp_tuners->cpu_up_avg_times) {
779 if (g_cpu_up_sum_load > cpus_sum_load_last_up)
780 g_cpu_up_sum_load -= cpus_sum_load_last_up;
781 else
782 g_cpu_up_sum_load = 0;
783
784 /* g_cpu_up_sum_load /= hp_tuners->cpu_up_avg_times; */
785 if (g_cpu_up_sum_load >
786 (hp_tuners->cpu_up_threshold * online_cpus_count *
787 hp_tuners->cpu_up_avg_times)) {
788 if (online_cpus_count < hp_tuners->cpu_num_limit) {
789#ifdef DEBUG_LOG
790 pr_debug("dbs_check_cpu: g_cpu_up_sum_load = %d\n",
791 g_cpu_up_sum_load);
792#endif
793 dbs_freq_increase(policy, policy->max);
794 pr_debug("dbs_check_cpu: turn on CPU\n");
795 g_next_hp_action = online_cpus_count + 1;
796 g_trigger_hp_work = CPU_HOTPLUG_WORK_TYPE_UP;
797 /* schedule_delayed_work_on(0, &hp_work, 0); */
798 if (hp_wq == NULL)
799 pr_emerg("[power/hotplug] %s():%d, impossible\n", __func__, __LINE__);
800 else
801 queue_delayed_work_on(0, hp_wq, &hp_work, 0);
802
803 goto hp_check_end;
804 }
805 }
806 }
807#ifdef DEBUG_LOG
808 pr_debug("dbs_check_cpu: g_cpu_up_count = %d, g_cpu_up_sum_load = %d\n",
809 g_cpu_up_count, g_cpu_up_sum_load);
810 pr_debug("dbs_check_cpu: cpu_up_threshold = %d\n",
811 (hp_tuners->cpu_up_threshold * online_cpus_count));
812#endif
813
814 }
815
816 /* Check CPU loading to power down slave CPU */
817 if (online_cpus_count > 1) {
818 cpus_sum_load_last_down = g_cpu_down_load_history[g_cpu_down_load_index];
819 g_cpu_down_load_history[g_cpu_down_load_index] = g_cpus_sum_load_current;
820 g_cpu_down_sum_load += g_cpus_sum_load_current;
821
822 g_cpu_down_count++;
823 g_cpu_down_load_index =
824 (g_cpu_down_load_index + 1 ==
825 hp_tuners->cpu_down_avg_times) ? 0 : g_cpu_down_load_index + 1;
826
827 if (g_cpu_down_count >= hp_tuners->cpu_down_avg_times) {
828 long cpu_down_threshold;
829
830 if (g_cpu_down_sum_load > cpus_sum_load_last_down)
831 g_cpu_down_sum_load -= cpus_sum_load_last_down;
832 else
833 g_cpu_down_sum_load = 0;
834
835 g_next_hp_action = online_cpus_count;
836 cpu_down_threshold =
837 ((hp_tuners->cpu_up_threshold -
838 hp_tuners->cpu_down_differential) *
839 hp_tuners->cpu_down_avg_times);
840
841 while ((g_cpu_down_sum_load <
842 cpu_down_threshold * (g_next_hp_action - 1)) &&
843 /* (g_next_hp_action > tlp_cpu_num) && */
844 (g_next_hp_action > hp_tuners->cpu_num_base))
845 --g_next_hp_action;
846
847 /* pr_debug("### g_next_hp_action: %d, tlp_cpu_num: %d, g_cpu_down_sum_load / hp_tuners->cpu_down_avg_times: %d ###\n", g_next_hp_action, tlp_cpu_num, g_cpu_down_sum_load / hp_tuners->cpu_down_avg_times); */
848 if (g_next_hp_action < online_cpus_count) {
849#ifdef DEBUG_LOG
850 pr_debug("dbs_check_cpu: g_cpu_down_sum_load = %d\n",
851 g_cpu_down_sum_load);
852#endif
853 dbs_freq_increase(policy, policy->max);
854 pr_debug("dbs_check_cpu: turn off CPU\n");
855 g_trigger_hp_work = CPU_HOTPLUG_WORK_TYPE_DOWN;
856 /* schedule_delayed_work_on(0, &hp_work, 0); */
857 if (hp_wq == NULL)
858 pr_emerg("[power/hotplug] %s():%d, impossible\n", __func__, __LINE__);
859 else
860 queue_delayed_work_on(0, hp_wq, &hp_work, 0);
861 }
862 }
863#ifdef DEBUG_LOG
864 pr_debug("dbs_check_cpu: g_cpu_down_count = %d, g_cpu_down_sum_load = %d\n",
865 g_cpu_down_count, g_cpu_down_sum_load);
866 pr_debug("dbs_check_cpu: cpu_down_threshold = %d\n",
867 ((hp_tuners->cpu_up_threshold -
868 hp_tuners->cpu_down_differential) * (online_cpus_count - 1)));
869#endif
870 }
871
872 hp_check_end:
873 mutex_unlock(&hp_mutex);
874
875#endif /* #ifdef CONFIG_HOTPLUG_CPU */
876 }
877/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
878}
879
880static void hp_dbs_timer(struct work_struct *work)
881{
882 struct hp_cpu_dbs_info_s *dbs_info =
883 container_of(work, struct hp_cpu_dbs_info_s, cdbs.work.work);
884 unsigned int cpu = dbs_info->cdbs.cur_policy->cpu;
885 struct hp_cpu_dbs_info_s *core_dbs_info = &per_cpu(hp_cpu_dbs_info,
886 cpu);
887 struct dbs_data *dbs_data = dbs_info->cdbs.cur_policy->governor_data;
888 struct hp_dbs_tuners *hp_tuners;
889
890 int delay = 0, sample_type = core_dbs_info->sample_type;
891 bool modify_all = true;
892
893 if (!dbs_data)
894 return;
895 hp_tuners = dbs_data->tuners;
896 if (!hp_tuners)
897 return;
898
899 mutex_lock(&core_dbs_info->cdbs.timer_mutex);
900 if (!need_load_eval(&core_dbs_info->cdbs, hp_tuners->sampling_rate)) {
901 modify_all = false;
902 goto max_delay;
903 }
904
905 /* Common NORMAL_SAMPLE setup */
906 core_dbs_info->sample_type = HP_NORMAL_SAMPLE;
907 if (sample_type == HP_SUB_SAMPLE) {
908 delay = core_dbs_info->freq_lo_jiffies;
909 __cpufreq_driver_target(core_dbs_info->cdbs.cur_policy,
910 core_dbs_info->freq_lo, CPUFREQ_RELATION_H);
911 } else {
912 dbs_check_cpu(dbs_data, cpu);
913 if (core_dbs_info->freq_lo) {
914 /* Setup timer for SUB_SAMPLE */
915 core_dbs_info->sample_type = HP_SUB_SAMPLE;
916 delay = core_dbs_info->freq_hi_jiffies;
917 }
918 }
919
920 max_delay:
921 if (!delay)
922 delay = delay_for_sampling_rate(hp_tuners->sampling_rate
923 * core_dbs_info->rate_mult);
924
925 gov_queue_work(dbs_data, dbs_info->cdbs.cur_policy, delay, modify_all);
926 mutex_unlock(&core_dbs_info->cdbs.timer_mutex);
927
928/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
929 /* for downgrade */ /* TODO: FIXME */
930 if (cpufreq_freq_check)
931 cpufreq_freq_check(0); /* TODO: FIXME, fix cpuid = 0 */
932/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
933}
934
935/************************** sysfs interface ************************/
936static struct common_dbs_data hp_dbs_cdata;
937
938/**
939 * update_sampling_rate - update sampling rate effective immediately if needed.
940 * @new_rate: new sampling rate
941 *
942 * If new rate is smaller than the old, simply updating
943 * dbs_tuners_int.sampling_rate might not be appropriate. For example, if the
944 * original sampling_rate was 1 second and the requested new sampling rate is 10
945 * ms because the user needs immediate reaction from hotplug governor, but not
946 * sure if higher frequency will be required or not, then, the governor may
947 * change the sampling rate too late; up to 1 second later. Thus, if we are
948 * reducing the sampling rate, we need to make the new value effective
949 * immediately.
950 */
951static void update_sampling_rate(struct dbs_data *dbs_data, unsigned int new_rate)
952{
953 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
954
955 hp_tuners->sampling_rate = new_rate = max(new_rate, dbs_data->min_sampling_rate);
956
957 {
958 struct cpufreq_policy *policy;
959 struct hp_cpu_dbs_info_s *dbs_info;
960 unsigned long next_sampling, appointed_at;
961
962 policy = cpufreq_cpu_get(0);
963 if (!policy)
964 return;
965 if (policy->governor != &cpufreq_gov_hotplug) {
966 cpufreq_cpu_put(policy);
967 return;
968 }
969 dbs_info = &per_cpu(hp_cpu_dbs_info, 0);
970 cpufreq_cpu_put(policy);
971
972 mutex_lock(&dbs_info->cdbs.timer_mutex);
973
974 if (!delayed_work_pending(&dbs_info->cdbs.work)) {
975 mutex_unlock(&dbs_info->cdbs.timer_mutex);
976 return;
977 }
978
979 next_sampling = jiffies + usecs_to_jiffies(new_rate);
980 appointed_at = dbs_info->cdbs.work.timer.expires;
981
982 if (time_before(next_sampling, appointed_at)) {
983
984 mutex_unlock(&dbs_info->cdbs.timer_mutex);
985 cancel_delayed_work_sync(&dbs_info->cdbs.work);
986 mutex_lock(&dbs_info->cdbs.timer_mutex);
987
988 gov_queue_work(dbs_data, dbs_info->cdbs.cur_policy,
989 usecs_to_jiffies(new_rate), true);
990
991 }
992 mutex_unlock(&dbs_info->cdbs.timer_mutex);
993 }
994}
995
996void hp_enable_timer(int enable)
997{
998#if 1
999 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
1000 static unsigned int sampling_rate_backup = 0;
1001
1002 if (!dbs_data || dbs_data->cdata->governor != GOV_HOTPLUG || (enable && !sampling_rate_backup))
1003 return;
1004
1005 if (enable)
1006 update_sampling_rate(dbs_data, sampling_rate_backup);
1007 else {
1008 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1009
1010 sampling_rate_backup = hp_tuners->sampling_rate;
1011 update_sampling_rate(dbs_data, 30000 * 100);
1012 }
1013#else
1014 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
1015 int cpu = 0;
1016 struct cpufreq_policy *policy;
1017 struct hp_dbs_tuners *hp_tuners;
1018 struct hp_cpu_dbs_info_s *dbs_info;
1019
1020 policy = cpufreq_cpu_get(cpu);
1021 if (!policy)
1022 continue;
1023 if (policy->governor != &cpufreq_gov_hotplug) {
1024 cpufreq_cpu_put(policy);
1025 continue;
1026 }
1027 dbs_info = &per_cpu(hp_cpu_dbs_info, cpu);
1028 cpufreq_cpu_put(policy);
1029
1030 if (enable) {
1031 hp_tuners = dbs_data->tuners;
1032 mutex_lock(&dbs_info->cdbs.timer_mutex);
1033 gov_queue_work(dbs_data, dbs_info->cdbs.cur_policy, usecs_to_jiffies(hp_tuners->sampling_rate), true);
1034 mutex_unlock(&dbs_info->cdbs.timer_mutex);
1035 } else
1036 cancel_delayed_work_sync(&dbs_info->cdbs.work);
1037 }
1038#endif
1039}
1040EXPORT_SYMBOL(hp_enable_timer);
1041
1042static ssize_t store_sampling_rate(struct dbs_data *dbs_data, const char *buf, size_t count)
1043{
1044 unsigned int input;
1045 int ret;
1046 ret = sscanf(buf, "%u", &input);
1047 if (ret != 1)
1048 return -EINVAL;
1049
1050 update_sampling_rate(dbs_data, input);
1051 return count;
1052}
1053
1054static ssize_t store_io_is_busy(struct dbs_data *dbs_data, const char *buf, size_t count)
1055{
1056 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1057 unsigned int input;
1058 int ret;
1059 unsigned int j;
1060
1061 ret = sscanf(buf, "%u", &input);
1062 if (ret != 1)
1063 return -EINVAL;
1064 hp_tuners->io_is_busy = !!input;
1065
1066 /* we need to re-evaluate prev_cpu_idle */
1067 for_each_online_cpu(j) {
1068 struct hp_cpu_dbs_info_s *dbs_info = &per_cpu(hp_cpu_dbs_info,
1069 j);
1070 dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j,
1071 &dbs_info->cdbs.prev_cpu_wall,
1072 hp_tuners->io_is_busy);
1073 }
1074 return count;
1075}
1076
1077static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf, size_t count)
1078{
1079 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1080 unsigned int input;
1081 int ret;
1082 ret = sscanf(buf, "%u", &input);
1083
1084 if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || input < MIN_FREQUENCY_UP_THRESHOLD)
1085 return -EINVAL;
1086
1087 /* Calculate the new adj_up_threshold */
1088 hp_tuners->adj_up_threshold += input;
1089 hp_tuners->adj_up_threshold -= hp_tuners->up_threshold;
1090
1091 hp_tuners->up_threshold = input;
1092 return count;
1093}
1094
1095static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data, const char *buf, size_t count)
1096{
1097 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1098 unsigned int input, j;
1099 int ret;
1100 ret = sscanf(buf, "%u", &input);
1101
1102 if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
1103 return -EINVAL;
1104 hp_tuners->sampling_down_factor = input;
1105
1106 /* Reset down sampling multiplier in case it was active */
1107 for_each_online_cpu(j) {
1108 struct hp_cpu_dbs_info_s *dbs_info = &per_cpu(hp_cpu_dbs_info,
1109 j);
1110 dbs_info->rate_mult = 1;
1111 }
1112 return count;
1113}
1114
1115static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data, const char *buf, size_t count)
1116{
1117 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1118 unsigned int input;
1119 int ret;
1120
1121 unsigned int j;
1122
1123 ret = sscanf(buf, "%u", &input);
1124 if (ret != 1)
1125 return -EINVAL;
1126
1127 if (input > 1)
1128 input = 1;
1129
1130 if (input == hp_tuners->ignore_nice_load) /* nothing to do */
1131 return count;
1132
1133 hp_tuners->ignore_nice_load = input;
1134
1135 /* we need to re-evaluate prev_cpu_idle */
1136 for_each_online_cpu(j) {
1137 struct hp_cpu_dbs_info_s *dbs_info;
1138 dbs_info = &per_cpu(hp_cpu_dbs_info, j);
1139 dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j,
1140 &dbs_info->cdbs.prev_cpu_wall,
1141 hp_tuners->io_is_busy);
1142 if (hp_tuners->ignore_nice_load)
1143 dbs_info->cdbs.prev_cpu_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE];
1144
1145 }
1146 return count;
1147}
1148
1149static ssize_t store_powersave_bias(struct dbs_data *dbs_data, const char *buf, size_t count)
1150{
1151 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1152 unsigned int input;
1153 int ret;
1154 ret = sscanf(buf, "%u", &input);
1155
1156 if (ret != 1)
1157 return -EINVAL;
1158
1159 if (input > 1000)
1160 input = 1000;
1161
1162 hp_tuners->powersave_bias = input;
1163 hotplug_powersave_bias_init();
1164 return count;
1165}
1166
1167show_store_one(hp, sampling_rate);
1168show_store_one(hp, io_is_busy);
1169show_store_one(hp, up_threshold);
1170show_store_one(hp, sampling_down_factor);
1171show_store_one(hp, ignore_nice_load);
1172show_store_one(hp, powersave_bias);
1173declare_show_sampling_rate_min(hp);
1174
1175gov_sys_pol_attr_rw(sampling_rate);
1176gov_sys_pol_attr_rw(io_is_busy);
1177gov_sys_pol_attr_rw(up_threshold);
1178gov_sys_pol_attr_rw(sampling_down_factor);
1179gov_sys_pol_attr_rw(ignore_nice_load);
1180gov_sys_pol_attr_rw(powersave_bias);
1181gov_sys_pol_attr_ro(sampling_rate_min);
1182
1183/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
1184static ssize_t store_down_differential(struct dbs_data *dbs_data, const char *buf, size_t count)
1185{
1186 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1187 unsigned int input;
1188 int ret;
1189 ret = sscanf(buf, "%u", &input);
1190
1191 if (ret != 1
1192 || input > MAX_FREQUENCY_DOWN_DIFFERENTIAL || input < MIN_FREQUENCY_DOWN_DIFFERENTIAL)
1193 return -EINVAL;
1194
1195 hp_tuners->down_differential = input;
1196
1197 return count;
1198}
1199
1200/*
1201 * cpu hotplug - function definition of sysfs
1202 */
1203static ssize_t store_cpu_up_threshold(struct dbs_data *dbs_data, const char *buf, size_t count)
1204{
1205 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1206 unsigned int input;
1207 int ret;
1208 ret = sscanf(buf, "%u", &input);
1209
1210 if (ret != 1 || input > MAX_CPU_UP_THRESHOLD || input < MIN_CPU_UP_THRESHOLD)
1211 return -EINVAL;
1212
1213 mutex_lock(&hp_mutex);
1214 hp_tuners->cpu_up_threshold = input;
1215 hp_reset_strategy_nolock();
1216 mutex_unlock(&hp_mutex);
1217
1218 return count;
1219}
1220
1221static ssize_t store_cpu_down_differential(struct dbs_data *dbs_data, const char *buf, size_t count)
1222{
1223 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1224 unsigned int input;
1225 int ret;
1226 ret = sscanf(buf, "%u", &input);
1227
1228 if (ret != 1 || input > MAX_CPU_DOWN_DIFFERENTIAL || input < MIN_CPU_DOWN_DIFFERENTIAL)
1229 return -EINVAL;
1230
1231 mutex_lock(&hp_mutex);
1232 hp_tuners->cpu_down_differential = input;
1233 hp_reset_strategy_nolock();
1234 mutex_unlock(&hp_mutex);
1235
1236 return count;
1237}
1238
1239static ssize_t store_cpu_up_avg_times(struct dbs_data *dbs_data, const char *buf, size_t count)
1240{
1241 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1242 unsigned int input;
1243 int ret;
1244 ret = sscanf(buf, "%u", &input);
1245
1246 if (ret != 1 || input > MAX_CPU_UP_AVG_TIMES || input < MIN_CPU_UP_AVG_TIMES)
1247 return -EINVAL;
1248
1249 mutex_lock(&hp_mutex);
1250 hp_tuners->cpu_up_avg_times = input;
1251 hp_reset_strategy_nolock();
1252 mutex_unlock(&hp_mutex);
1253
1254 return count;
1255}
1256
1257static ssize_t store_cpu_down_avg_times(struct dbs_data *dbs_data, const char *buf, size_t count)
1258{
1259 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1260 unsigned int input;
1261 int ret;
1262 ret = sscanf(buf, "%u", &input);
1263
1264 if (ret != 1 || input > MAX_CPU_DOWN_AVG_TIMES || input < MIN_CPU_DOWN_AVG_TIMES)
1265 return -EINVAL;
1266
1267 mutex_lock(&hp_mutex);
1268 hp_tuners->cpu_down_avg_times = input;
1269 hp_reset_strategy_nolock();
1270 mutex_unlock(&hp_mutex);
1271
1272 return count;
1273}
1274
1275static ssize_t store_cpu_num_limit(struct dbs_data *dbs_data, const char *buf, size_t count)
1276{
1277 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1278 unsigned int input;
1279 int ret;
1280 ret = sscanf(buf, "%u", &input);
1281
1282 if (ret != 1 || input > num_possible_cpus()
1283 || input < 1)
1284 return -EINVAL;
1285
1286 mutex_lock(&hp_mutex);
1287 hp_tuners->cpu_num_limit = input;
1288 mutex_unlock(&hp_mutex);
1289
1290 return count;
1291}
1292
1293static ssize_t store_cpu_num_base(struct dbs_data *dbs_data, const char *buf, size_t count)
1294{
1295 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1296 unsigned int input;
1297 unsigned int online_cpus_count;
1298 int ret;
1299 ret = sscanf(buf, "%u", &input);
1300
1301 if (ret != 1 || input > num_possible_cpus()
1302 || input < 1)
1303 return -EINVAL;
1304
1305 mutex_lock(&hp_mutex);
1306
1307 hp_tuners->cpu_num_base = input;
1308 online_cpus_count = num_online_cpus();
1309#ifdef CONFIG_HOTPLUG_CPU
1310
1311 if (online_cpus_count < input && online_cpus_count < hp_tuners->cpu_num_limit) {
1312 struct cpufreq_policy *policy = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy; /* TODO: FIXME, cpu = 0 */
1313
1314 dbs_freq_increase(policy, policy->max);
1315 g_trigger_hp_work = CPU_HOTPLUG_WORK_TYPE_BASE;
1316 /* schedule_delayed_work_on(0, &hp_work, 0); */
1317 if (hp_wq == NULL)
1318 pr_emerg("[power/hotplug] %s():%d, impossible\n", __func__, __LINE__);
1319 else
1320 queue_delayed_work_on(0, hp_wq, &hp_work, 0);
1321 }
1322#endif
1323
1324 mutex_unlock(&hp_mutex);
1325
1326 return count;
1327}
1328
1329static ssize_t store_is_cpu_hotplug_disable(struct dbs_data *dbs_data, const char *buf,
1330 size_t count)
1331{
1332 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1333 unsigned int input;
1334 int ret;
1335 ret = sscanf(buf, "%u", &input);
1336
1337 if (ret != 1 || input > 1 || input < 0)
1338 return -EINVAL;
1339
1340 mutex_lock(&hp_mutex);
1341
1342 if (hp_tuners->is_cpu_hotplug_disable && !input)
1343 hp_reset_strategy_nolock();
1344
1345 hp_tuners->is_cpu_hotplug_disable = input;
1346 mutex_unlock(&hp_mutex);
1347
1348 return count;
1349}
1350
1351static ssize_t store_cpu_input_boost_enable(struct dbs_data *dbs_data, const char *buf,
1352 size_t count)
1353{
1354 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1355 unsigned int input;
1356 int ret;
1357 ret = sscanf(buf, "%u", &input);
1358
1359 if (ret != 1 || input > 1 || input < 0)
1360 return -EINVAL;
1361
1362 mutex_lock(&hp_mutex);
1363 hp_tuners->cpu_input_boost_enable = input;
1364 mutex_unlock(&hp_mutex);
1365
1366 return count;
1367}
1368
1369static ssize_t store_cpu_input_boost_num(struct dbs_data *dbs_data, const char *buf, size_t count)
1370{
1371 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1372 unsigned int input;
1373 int ret;
1374 ret = sscanf(buf, "%u", &input);
1375
1376 if (ret != 1 || input > num_possible_cpus()
1377 || input < 2)
1378 return -EINVAL;
1379
1380 mutex_lock(&hp_mutex);
1381 hp_tuners->cpu_input_boost_num = input;
1382 mutex_unlock(&hp_mutex);
1383
1384 return count;
1385}
1386
1387static ssize_t store_cpu_rush_boost_enable(struct dbs_data *dbs_data, const char *buf, size_t count)
1388{
1389 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1390 unsigned int input;
1391 int ret;
1392 ret = sscanf(buf, "%u", &input);
1393
1394 if (ret != 1 || input > 1 || input < 0)
1395 return -EINVAL;
1396
1397 mutex_lock(&hp_mutex);
1398 hp_tuners->cpu_rush_boost_enable = input;
1399 mutex_unlock(&hp_mutex);
1400
1401 return count;
1402}
1403
1404static ssize_t store_cpu_rush_boost_num(struct dbs_data *dbs_data, const char *buf, size_t count)
1405{
1406 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1407 unsigned int input;
1408 int ret;
1409 ret = sscanf(buf, "%u", &input);
1410
1411 if (ret != 1 || input > num_possible_cpus()
1412 || input < 2)
1413 return -EINVAL;
1414
1415 mutex_lock(&hp_mutex);
1416 hp_tuners->cpu_rush_boost_num = input;
1417 mutex_unlock(&hp_mutex);
1418
1419 return count;
1420}
1421
1422static ssize_t store_cpu_rush_threshold(struct dbs_data *dbs_data, const char *buf, size_t count)
1423{
1424 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1425 unsigned int input;
1426 int ret;
1427 ret = sscanf(buf, "%u", &input);
1428
1429 if (ret != 1 || input > MAX_CPU_RUSH_THRESHOLD || input < MIN_CPU_RUSH_THRESHOLD)
1430 return -EINVAL;
1431
1432 mutex_lock(&hp_mutex);
1433 hp_tuners->cpu_rush_threshold = input;
1434 /* hp_reset_strategy_nolock(); //no need */
1435 mutex_unlock(&hp_mutex);
1436
1437 return count;
1438}
1439
1440static ssize_t store_cpu_rush_tlp_times(struct dbs_data *dbs_data, const char *buf, size_t count)
1441{
1442 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1443 unsigned int input;
1444 int ret;
1445 ret = sscanf(buf, "%u", &input);
1446
1447 if (ret != 1 || input > MAX_CPU_RUSH_TLP_TIMES || input < MIN_CPU_RUSH_TLP_TIMES)
1448 return -EINVAL;
1449
1450 mutex_lock(&hp_mutex);
1451 hp_tuners->cpu_rush_tlp_times = input;
1452 hp_reset_strategy_nolock();
1453 mutex_unlock(&hp_mutex);
1454
1455 return count;
1456}
1457
1458static ssize_t store_cpu_rush_avg_times(struct dbs_data *dbs_data, const char *buf, size_t count)
1459{
1460 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1461 unsigned int input;
1462 int ret;
1463 ret = sscanf(buf, "%u", &input);
1464
1465 if (ret != 1 || input > MAX_CPU_RUSH_AVG_TIMES || input < MIN_CPU_RUSH_AVG_TIMES)
1466 return -EINVAL;
1467
1468 mutex_lock(&hp_mutex);
1469 hp_tuners->cpu_rush_avg_times = input;
1470 hp_reset_strategy_nolock();
1471 mutex_unlock(&hp_mutex);
1472
1473 return count;
1474}
1475
1476show_store_one(hp, down_differential);
1477show_store_one(hp, cpu_up_threshold);
1478show_store_one(hp, cpu_down_differential);
1479show_store_one(hp, cpu_up_avg_times);
1480show_store_one(hp, cpu_down_avg_times);
1481show_store_one(hp, cpu_num_limit);
1482show_store_one(hp, cpu_num_base);
1483show_store_one(hp, is_cpu_hotplug_disable);
1484show_store_one(hp, cpu_input_boost_enable);
1485show_store_one(hp, cpu_input_boost_num);
1486show_store_one(hp, cpu_rush_boost_enable);
1487show_store_one(hp, cpu_rush_boost_num);
1488show_store_one(hp, cpu_rush_threshold);
1489show_store_one(hp, cpu_rush_tlp_times);
1490show_store_one(hp, cpu_rush_avg_times);
1491
1492gov_sys_pol_attr_rw(down_differential);
1493gov_sys_pol_attr_rw(cpu_up_threshold);
1494gov_sys_pol_attr_rw(cpu_down_differential);
1495gov_sys_pol_attr_rw(cpu_up_avg_times);
1496gov_sys_pol_attr_rw(cpu_down_avg_times);
1497gov_sys_pol_attr_rw(cpu_num_limit);
1498gov_sys_pol_attr_rw(cpu_num_base);
1499gov_sys_pol_attr_rw(is_cpu_hotplug_disable);
1500gov_sys_pol_attr_rw(cpu_input_boost_enable);
1501gov_sys_pol_attr_rw(cpu_input_boost_num);
1502gov_sys_pol_attr_rw(cpu_rush_boost_enable);
1503gov_sys_pol_attr_rw(cpu_rush_boost_num);
1504gov_sys_pol_attr_rw(cpu_rush_threshold);
1505gov_sys_pol_attr_rw(cpu_rush_tlp_times);
1506gov_sys_pol_attr_rw(cpu_rush_avg_times);
1507/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
1508
1509static struct attribute *dbs_attributes_gov_sys[] = {
1510 &sampling_rate_min_gov_sys.attr,
1511 &sampling_rate_gov_sys.attr,
1512 &up_threshold_gov_sys.attr,
1513 &sampling_down_factor_gov_sys.attr,
1514 &ignore_nice_load_gov_sys.attr,
1515 &powersave_bias_gov_sys.attr,
1516 &io_is_busy_gov_sys.attr,
1517/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
1518 &down_differential_gov_sys.attr,
1519 &cpu_up_threshold_gov_sys.attr,
1520 &cpu_down_differential_gov_sys.attr,
1521 &cpu_up_avg_times_gov_sys.attr,
1522 &cpu_down_avg_times_gov_sys.attr,
1523 &cpu_num_limit_gov_sys.attr,
1524 &cpu_num_base_gov_sys.attr,
1525 &is_cpu_hotplug_disable_gov_sys.attr,
1526 &cpu_input_boost_enable_gov_sys.attr,
1527 &cpu_input_boost_num_gov_sys.attr,
1528 &cpu_rush_boost_enable_gov_sys.attr,
1529 &cpu_rush_boost_num_gov_sys.attr,
1530 &cpu_rush_threshold_gov_sys.attr,
1531 &cpu_rush_tlp_times_gov_sys.attr,
1532 &cpu_rush_avg_times_gov_sys.attr,
1533/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
1534 NULL
1535};
1536
1537static struct attribute_group hp_attr_group_gov_sys = {
1538 .attrs = dbs_attributes_gov_sys,
1539 .name = "hotplug",
1540};
1541
1542static struct attribute *dbs_attributes_gov_pol[] = {
1543 &sampling_rate_min_gov_pol.attr,
1544 &sampling_rate_gov_pol.attr,
1545 &up_threshold_gov_pol.attr,
1546 &sampling_down_factor_gov_pol.attr,
1547 &ignore_nice_load_gov_pol.attr,
1548 &powersave_bias_gov_pol.attr,
1549 &io_is_busy_gov_pol.attr,
1550/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
1551 &down_differential_gov_pol.attr,
1552 &cpu_up_threshold_gov_pol.attr,
1553 &cpu_down_differential_gov_pol.attr,
1554 &cpu_up_avg_times_gov_pol.attr,
1555 &cpu_down_avg_times_gov_pol.attr,
1556 &cpu_num_limit_gov_pol.attr,
1557 &cpu_num_base_gov_pol.attr,
1558 &is_cpu_hotplug_disable_gov_pol.attr,
1559 &cpu_input_boost_enable_gov_pol.attr,
1560 &cpu_input_boost_num_gov_pol.attr,
1561 &cpu_rush_boost_enable_gov_pol.attr,
1562 &cpu_rush_boost_num_gov_pol.attr,
1563 &cpu_rush_threshold_gov_pol.attr,
1564 &cpu_rush_tlp_times_gov_pol.attr,
1565 &cpu_rush_avg_times_gov_pol.attr,
1566/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
1567 NULL
1568};
1569
1570static struct attribute_group hp_attr_group_gov_pol = {
1571 .attrs = dbs_attributes_gov_pol,
1572 .name = "hotplug",
1573};
1574
1575/************************** sysfs end ************************/
1576
1577/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
1578
1579#ifdef CONFIG_HOTPLUG_CPU
1580
1581static struct task_struct *freq_up_task;
1582
1583static int touch_freq_up_task(void *data)
1584{
1585 struct cpufreq_policy *policy;
1586
1587 while (1) {
1588 policy = cpufreq_cpu_get(0);
1589 dbs_freq_increase(policy, policy->max);
1590 cpufreq_cpu_put(policy);
1591 /* mt_cpufreq_set_ramp_down_count_const(0, 100); */
1592 pr_debug("@%s():%d\n", __func__, __LINE__);
1593
1594 set_current_state(TASK_INTERRUPTIBLE);
1595 schedule();
1596
1597 if (kthread_should_stop())
1598 break;
1599 }
1600
1601 return 0;
1602}
1603
1604static void dbs_input_event(struct input_handle *handle, unsigned int type,
1605 unsigned int code, int value)
1606{
1607 /* int i; */
1608
1609 /* if ((dbs_tuners_ins.powersave_bias == POWERSAVE_BIAS_MAXLEVEL) || */
1610 /* (dbs_tuners_ins.powersave_bias == POWERSAVE_BIAS_MINLEVEL)) { */
1611 /* nothing to do */
1612 /* return; */
1613 /* } */
1614
1615 /* for_each_online_cpu(i) { */
1616 /* queue_work_on(i, input_wq, &per_cpu(dbs_refresh_work, i)); */
1617 /* } */
1618 /* pr_debug("$$$ in_interrupt(): %d, in_irq(): %d, type: %d, code: %d, value: %d $$$\n", in_interrupt(), in_irq(), type, code, value); */
1619
1620 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
1621 struct hp_dbs_tuners *hp_tuners;
1622
1623 if (!dbs_data)
1624 return;
1625 hp_tuners = dbs_data->tuners;
1626 if (!hp_tuners)
1627 return;
1628
1629 if ((type == EV_KEY) && (code == BTN_TOUCH) && (value == 1)
1630 && (dbs_data->cdata->governor == GOV_HOTPLUG && hp_tuners->cpu_input_boost_enable)) {
1631 /* if (!in_interrupt()) */
1632 /* { */
1633 unsigned int online_cpus_count = num_online_cpus();
1634
1635 pr_debug("@%s():%d, online_cpus_count = %d, cpu_input_boost_num = %d\n", __func__, __LINE__, online_cpus_count, hp_tuners->cpu_input_boost_num);
1636
1637 if (online_cpus_count < hp_tuners->cpu_input_boost_num && online_cpus_count < hp_tuners->cpu_num_limit) {
1638 /* schedule_delayed_work_on(0, &hp_work, 0); */
1639 if (hp_wq == NULL)
1640 pr_emerg("[power/hotplug] %s():%d, impossible\n", __func__, __LINE__);
1641 else
1642 queue_delayed_work_on(0, hp_wq, &hp_work, 0);
1643 }
1644
1645 if (online_cpus_count <= hp_tuners->cpu_input_boost_num && online_cpus_count <= hp_tuners->cpu_num_limit)
1646 wake_up_process(freq_up_task);
1647
1648 /* } */
1649 }
1650}
1651
1652static int dbs_input_connect(struct input_handler *handler,
1653 struct input_dev *dev, const struct input_device_id *id)
1654{
1655 struct input_handle *handle;
1656 int error;
1657
1658 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1659
1660 if (!handle)
1661 return -ENOMEM;
1662
1663 handle->dev = dev;
1664 handle->handler = handler;
1665 handle->name = "cpufreq";
1666
1667 error = input_register_handle(handle);
1668
1669 if (error)
1670 goto err2;
1671
1672 error = input_open_device(handle);
1673
1674 if (error)
1675 goto err1;
1676
1677 return 0;
1678 err1:
1679 input_unregister_handle(handle);
1680 err2:
1681 kfree(handle);
1682 return error;
1683}
1684
1685static void dbs_input_disconnect(struct input_handle *handle)
1686{
1687 input_close_device(handle);
1688 input_unregister_handle(handle);
1689 kfree(handle);
1690}
1691
1692static const struct input_device_id dbs_ids[] = {
1693 {.driver_info = 1},
1694 {},
1695};
1696
1697static struct input_handler dbs_input_handler = {
1698 .event = dbs_input_event,
1699 .connect = dbs_input_connect,
1700 .disconnect = dbs_input_disconnect,
1701 .name = "cpufreq_ond",
1702 .id_table = dbs_ids,
1703};
1704#endif /* #ifdef CONFIG_HOTPLUG_CPU */
1705
1706/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
1707
1708static int hp_init(struct dbs_data *dbs_data)
1709{
1710 struct hp_dbs_tuners *tuners;
1711 u64 idle_time;
1712 int cpu;
1713
1714 tuners = kzalloc(sizeof(struct hp_dbs_tuners), GFP_KERNEL);
1715 if (!tuners) {
1716 pr_err("%s: kzalloc failed\n", __func__);
1717 return -ENOMEM;
1718 }
1719
1720 cpu = get_cpu();
1721 idle_time = get_cpu_idle_time_us(cpu, NULL);
1722 put_cpu();
1723 if (idle_time != -1ULL) {
1724 /* Idle micro accounting is supported. Use finer thresholds */
1725 tuners->up_threshold = MICRO_FREQUENCY_UP_THRESHOLD;
1726 tuners->adj_up_threshold = MICRO_FREQUENCY_UP_THRESHOLD -
1727 MICRO_FREQUENCY_DOWN_DIFFERENTIAL;
1728 tuners->down_differential = MICRO_FREQUENCY_DOWN_DIFFERENTIAL; /* <-XXX */
1729 tuners->cpu_up_threshold = MICRO_CPU_UP_THRESHOLD; /* <-XXX */
1730 tuners->cpu_down_differential = MICRO_CPU_DOWN_DIFFERENTIAL; /* <-XXX */
1731 /*
1732 * In nohz/micro accounting case we set the minimum frequency
1733 * not depending on HZ, but fixed (very low). The deferred
1734 * timer might skip some samples if idle/sleeping as needed.
1735 */
1736 dbs_data->min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE;
1737
1738 /* cpu rush boost */
1739 tuners->cpu_rush_threshold = MICRO_CPU_RUSH_THRESHOLD; /* <-XXX */
1740 } else {
1741 tuners->up_threshold = DEF_FREQUENCY_UP_THRESHOLD;
1742 tuners->adj_up_threshold = DEF_FREQUENCY_UP_THRESHOLD -
1743 DEF_FREQUENCY_DOWN_DIFFERENTIAL;
1744 tuners->down_differential = DEF_FREQUENCY_DOWN_DIFFERENTIAL; /* <-XXX */
1745 tuners->cpu_up_threshold = DEF_CPU_UP_THRESHOLD; /* <-XXX */
1746 tuners->cpu_down_differential = DEF_CPU_DOWN_DIFFERENTIAL; /* <-XXX */
1747
1748 /* For correct statistics, we need 10 ticks for each measure */
1749 dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10);
1750
1751 /* cpu rush boost */
1752 tuners->cpu_rush_threshold = DEF_CPU_RUSH_THRESHOLD; /* <-XXX */
1753 }
1754
1755 tuners->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR;
1756 tuners->ignore_nice_load = 0;
1757 tuners->powersave_bias = default_powersave_bias;
1758 tuners->io_is_busy = should_io_be_busy();
1759/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
1760 tuners->cpu_up_avg_times = DEF_CPU_UP_AVG_TIMES;
1761 tuners->cpu_down_avg_times = DEF_CPU_DOWN_AVG_TIMES;
1762 tuners->cpu_num_limit = num_possible_cpus();
1763 tuners->cpu_num_base = 1;
1764 tuners->is_cpu_hotplug_disable = (tuners->cpu_num_limit > 1) ? 0 : 1;
1765 tuners->cpu_input_boost_enable = DEF_CPU_INPUT_BOOST_ENABLE;
1766 tuners->cpu_input_boost_num = DEF_CPU_INPUT_BOOST_NUM;
1767 tuners->cpu_rush_boost_enable = DEF_CPU_RUSH_BOOST_ENABLE;
1768 tuners->cpu_rush_boost_num = num_possible_cpus();
1769 tuners->cpu_rush_tlp_times = DEF_CPU_RUSH_TLP_TIMES;
1770 tuners->cpu_rush_avg_times = DEF_CPU_RUSH_AVG_TIMES;
1771
1772#ifdef CONFIG_HOTPLUG_CPU
1773 INIT_DEFERRABLE_WORK(&hp_work, hp_work_handler);
1774 hp_wq = alloc_workqueue("hp_work_handler", WQ_HIGHPRI, 0);
1775 g_next_hp_action = num_online_cpus();
1776#endif
1777
1778#ifdef DEBUG_LOG
1779 pr_debug("cpufreq_gov_dbs_init: min_sampling_rate = %d\n", dbs_data->min_sampling_rate);
1780 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.up_threshold = %d\n", tuners->up_threshold);
1781 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.down_differential = %d\n",
1782 tuners->down_differential);
1783 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_up_threshold = %d\n",
1784 tuners->cpu_up_threshold);
1785 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_down_differential = %d\n",
1786 tuners->cpu_down_differential);
1787 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_up_avg_times = %d\n",
1788 tuners->cpu_up_avg_times);
1789 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_down_avg_times = %d\n",
1790 tuners->cpu_down_avg_times);
1791 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_num_limit = %d\n",
1792 tuners->cpu_num_limit);
1793 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_num_base = %d\n", tuners->cpu_num_base);
1794 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.is_cpu_hotplug_disable = %d\n",
1795 tuners->is_cpu_hotplug_disable);
1796 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_input_boost_enable = %d\n",
1797 tuners->cpu_input_boost_enable);
1798 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_input_boost_num = %d\n",
1799 tuners->cpu_input_boost_num);
1800 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_rush_boost_enable = %d\n",
1801 tuners->cpu_rush_boost_enable);
1802 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_rush_boost_num = %d\n",
1803 tuners->cpu_rush_boost_num);
1804 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_rush_threshold = %d\n",
1805 tuners->cpu_rush_threshold);
1806 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_rush_tlp_times = %d\n",
1807 tuners->cpu_rush_tlp_times);
1808 pr_debug("cpufreq_gov_dbs_init: dbs_tuners_ins.cpu_rush_avg_times = %d\n",
1809 tuners->cpu_rush_avg_times);
1810#endif
1811/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
1812
1813 dbs_data->tuners = tuners;
1814 mutex_init(&dbs_data->mutex);
1815 return 0;
1816}
1817
1818static void hp_exit(struct dbs_data *dbs_data)
1819{
1820/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
1821#ifdef CONFIG_HOTPLUG_CPU
1822 cancel_delayed_work_sync(&hp_work);
1823 if (hp_wq)
1824 destroy_workqueue(hp_wq);
1825#endif
1826/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
1827 kfree(dbs_data->tuners);
1828}
1829
1830define_get_cpu_dbs_routines(hp_cpu_dbs_info);
1831
1832static struct hp_ops hp_ops = {
1833 .powersave_bias_init_cpu = hotplug_powersave_bias_init_cpu,
1834 .powersave_bias_target = generic_powersave_bias_target,
1835 .freq_increase = dbs_freq_increase,
1836 .input_handler = &dbs_input_handler,
1837};
1838
1839static struct common_dbs_data hp_dbs_cdata = {
1840 .governor = GOV_HOTPLUG,
1841 .attr_group_gov_sys = &hp_attr_group_gov_sys,
1842 .attr_group_gov_pol = &hp_attr_group_gov_pol,
1843 .get_cpu_cdbs = get_cpu_cdbs,
1844 .get_cpu_dbs_info_s = get_cpu_dbs_info_s,
1845 .gov_dbs_timer = hp_dbs_timer,
1846 .gov_check_cpu = hp_check_cpu,
1847 .gov_ops = &hp_ops,
1848 .init = hp_init,
1849 .exit = hp_exit,
1850};
1851
1852static void hp_set_powersave_bias(unsigned int powersave_bias)
1853{
1854 struct cpufreq_policy *policy;
1855 struct dbs_data *dbs_data;
1856 struct hp_dbs_tuners *hp_tuners;
1857 unsigned int cpu;
1858 cpumask_t done;
1859
1860 default_powersave_bias = powersave_bias;
1861 cpumask_clear(&done);
1862
1863 get_online_cpus();
1864 for_each_online_cpu(cpu) {
1865 if (cpumask_test_cpu(cpu, &done))
1866 continue;
1867
1868 policy = per_cpu(hp_cpu_dbs_info, cpu).cdbs.cur_policy;
1869 if (!policy)
1870 continue;
1871
1872 cpumask_or(&done, &done, policy->cpus);
1873
1874 if (policy->governor != &cpufreq_gov_hotplug)
1875 continue;
1876
1877 dbs_data = policy->governor_data;
1878 hp_tuners = dbs_data->tuners;
1879 hp_tuners->powersave_bias = default_powersave_bias;
1880 }
1881 put_online_cpus();
1882}
1883
1884void hp_register_powersave_bias_handler(unsigned int (*f)
1885 (struct cpufreq_policy *, unsigned int, unsigned int),
1886 unsigned int powersave_bias)
1887{
1888 hp_ops.powersave_bias_target = f;
1889 hp_set_powersave_bias(powersave_bias);
1890}
1891EXPORT_SYMBOL_GPL(hp_register_powersave_bias_handler);
1892
1893void hp_unregister_powersave_bias_handler(void)
1894{
1895 hp_ops.powersave_bias_target = generic_powersave_bias_target;
1896 hp_set_powersave_bias(0);
1897}
1898EXPORT_SYMBOL_GPL(hp_unregister_powersave_bias_handler);
1899
1900static int hp_cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event)
1901{
1902/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
1903 struct dbs_data *dbs_data;
1904 int rc = 0;
1905
1906 if (have_governor_per_policy())
1907 dbs_data = policy->governor_data;
1908 else
1909 dbs_data = hp_dbs_cdata.gdbs_data;
1910
1911 /* pr_emerg("***** policy->cpu: %d, event: %u, smp_processor_id: %d, have_governor_per_policy: %d *****\n", policy->cpu, event, smp_processor_id(), have_governor_per_policy()); */
1912 switch (event) {
1913 case CPUFREQ_GOV_START:
1914#ifdef DEBUG_LOG
1915 {
1916 struct hp_dbs_tuners *hp_tuners = dbs_data->tuners;
1917
1918 BUG_ON(NULL == dbs_data);
1919 BUG_ON(NULL == dbs_data->tuners);
1920
1921 pr_debug("cpufreq_governor_dbs: min_sampling_rate = %d\n",
1922 dbs_data->min_sampling_rate);
1923 pr_debug("cpufreq_governor_dbs: dbs_tuners_ins.sampling_rate = %d\n",
1924 hp_tuners->sampling_rate);
1925 pr_debug("cpufreq_governor_dbs: dbs_tuners_ins.io_is_busy = %d\n",
1926 hp_tuners->io_is_busy);
1927 }
1928#endif
1929#ifdef CONFIG_HOTPLUG_CPU
1930 if (0) /* (!policy->cpu) // <-XXX */
1931 rc = input_register_handler(&dbs_input_handler);
1932#endif
1933 break;
1934
1935 case CPUFREQ_GOV_STOP:
1936#ifdef CONFIG_HOTPLUG_CPU
1937 if (0) /* (!policy->cpu) // <-XXX */
1938 input_unregister_handler(&dbs_input_handler);
1939
1940#endif
1941 break;
1942 }
1943
1944/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
1945 return cpufreq_governor_dbs(policy, &hp_dbs_cdata, event);
1946}
1947
1948/* <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
1949#if 0
1950int cpufreq_gov_dbs_get_sum_load(void)
1951{
1952 return g_cpus_sum_load_current;
1953}
1954#endif
1955/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> */
1956
1957#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_HOTPLUG
1958static
1959#endif
1960struct cpufreq_governor cpufreq_gov_hotplug = {
1961 .name = "hotplug",
1962 .governor = hp_cpufreq_governor_dbs,
1963 .max_transition_latency = TRANSITION_LATENCY_LIMIT,
1964 .owner = THIS_MODULE,
1965};
1966
1967#ifdef CONFIG_MTK_SDIOAUTOK_SUPPORT
1968void cpufreq_min_sampling_rate_change(unsigned int sample_rate)
1969{
1970 struct dbs_data *dbs_data = per_cpu(hp_cpu_dbs_info, 0).cdbs.cur_policy->governor_data; /* TODO: FIXME, cpu = 0 */
1971
1972 if (!dbs_data)
1973 return;
1974
1975 dbs_data->min_sampling_rate = sample_rate;
1976 update_sampling_rate(dbs_data, sample_rate);
1977}
1978EXPORT_SYMBOL(cpufreq_min_sampling_rate_change);
1979#endif
1980
1981static int __init cpufreq_gov_dbs_init(void)
1982{
1983 struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
1984
1985 freq_up_task = kthread_create(touch_freq_up_task, NULL, "touch_freq_up_task");
1986
1987 if (IS_ERR(freq_up_task))
1988 return PTR_ERR(freq_up_task);
1989
1990 sched_setscheduler_nocheck(freq_up_task, SCHED_FIFO, &param);
1991 get_task_struct(freq_up_task);
1992
1993 return cpufreq_register_governor(&cpufreq_gov_hotplug);
1994}
1995
1996static void __exit cpufreq_gov_dbs_exit(void)
1997{
1998 cpufreq_unregister_governor(&cpufreq_gov_hotplug);
1999
2000 kthread_stop(freq_up_task);
2001 put_task_struct(freq_up_task);
2002}
2003
2004MODULE_AUTHOR("Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>");
2005MODULE_AUTHOR("Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>");
2006MODULE_DESCRIPTION("'cpufreq_hotplug' - A dynamic cpufreq governor for "
2007 "Low Latency Frequency Transition capable processors");
2008MODULE_LICENSE("GPL");
2009
2010#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_HOTPLUG
2011fs_initcall(cpufreq_gov_dbs_init);
2012#else
2013module_init(cpufreq_gov_dbs_init);
2014#endif
2015module_exit(cpufreq_gov_dbs_exit);
kernel source for telekom puls (alcatel/mediatek)