cpufreq_conservative.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408
  1. /*
  2. * drivers/cpufreq/cpufreq_conservative.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. * (C) 2009 Alexander Clouter <alex@digriz.org.uk>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License version 2 as
  11. * published by the Free Software Foundation.
  12. */
  13. #include <linux/slab.h>
  14. #include "cpufreq_governor.h"
  15. /* Conservative governor macros */
  16. #define DEF_FREQUENCY_UP_THRESHOLD (80)
  17. #define DEF_FREQUENCY_DOWN_THRESHOLD (20)
  18. #define DEF_FREQUENCY_STEP (5)
  19. #define DEF_SAMPLING_DOWN_FACTOR (1)
  20. #define MAX_SAMPLING_DOWN_FACTOR (10)
  21. static DEFINE_PER_CPU(struct cs_cpu_dbs_info_s, cs_cpu_dbs_info);
  22. static inline unsigned int get_freq_target(struct cs_dbs_tuners *cs_tuners,
  23. struct cpufreq_policy *policy)
  24. {
  25. unsigned int freq_target = (cs_tuners->freq_step * policy->max) / 100;
  26. /* max freq cannot be less than 100. But who knows... */
  27. if (unlikely(freq_target == 0))
  28. freq_target = DEF_FREQUENCY_STEP;
  29. return freq_target;
  30. }
  31. /*
  32. * Every sampling_rate, we check, if current idle time is less than 20%
  33. * (default), then we try to increase frequency. Every sampling_rate *
  34. * sampling_down_factor, we check, if current idle time is more than 80%
  35. * (default), then we try to decrease frequency
  36. *
  37. * Any frequency increase takes it to the maximum frequency. Frequency reduction
  38. * happens at minimum steps of 5% (default) of maximum frequency
  39. */
  40. static void cs_check_cpu(int cpu, unsigned int load)
  41. {
  42. struct cs_cpu_dbs_info_s *dbs_info = &per_cpu(cs_cpu_dbs_info, cpu);
  43. struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy;
  44. struct dbs_data *dbs_data = policy->governor_data;
  45. struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
  46. /*
  47. * break out if we 'cannot' reduce the speed as the user might
  48. * want freq_step to be zero
  49. */
  50. if (cs_tuners->freq_step == 0)
  51. return;
  52. /* Check for frequency increase */
  53. if (load > cs_tuners->up_threshold) {
  54. dbs_info->down_skip = 0;
  55. /* if we are already at full speed then break out early */
  56. if (dbs_info->requested_freq == policy->max)
  57. return;
  58. dbs_info->requested_freq += get_freq_target(cs_tuners, policy);
  59. if (dbs_info->requested_freq > policy->max)
  60. dbs_info->requested_freq = policy->max;
  61. __cpufreq_driver_target(policy, dbs_info->requested_freq,
  62. CPUFREQ_RELATION_H);
  63. return;
  64. }
  65. /* if sampling_down_factor is active break out early */
  66. if (++dbs_info->down_skip < cs_tuners->sampling_down_factor)
  67. return;
  68. dbs_info->down_skip = 0;
  69. /* Check for frequency decrease */
  70. if (load < cs_tuners->down_threshold) {
  71. unsigned int freq_target;
  72. /*
  73. * if we cannot reduce the frequency anymore, break out early
  74. */
  75. if (policy->cur == policy->min)
  76. return;
  77. freq_target = get_freq_target(cs_tuners, policy);
  78. if (dbs_info->requested_freq > freq_target)
  79. dbs_info->requested_freq -= freq_target;
  80. else
  81. dbs_info->requested_freq = policy->min;
  82. __cpufreq_driver_target(policy, dbs_info->requested_freq,
  83. CPUFREQ_RELATION_L);
  84. return;
  85. }
  86. }
  87. static void cs_dbs_timer(struct work_struct *work)
  88. {
  89. struct cs_cpu_dbs_info_s *dbs_info = container_of(work,
  90. struct cs_cpu_dbs_info_s, cdbs.work.work);
  91. unsigned int cpu = dbs_info->cdbs.cur_policy->cpu;
  92. struct cs_cpu_dbs_info_s *core_dbs_info = &per_cpu(cs_cpu_dbs_info,
  93. cpu);
  94. struct dbs_data *dbs_data = dbs_info->cdbs.cur_policy->governor_data;
  95. struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
  96. int delay = delay_for_sampling_rate(cs_tuners->sampling_rate);
  97. bool modify_all = true;
  98. mutex_lock(&core_dbs_info->cdbs.timer_mutex);
  99. if (!need_load_eval(&core_dbs_info->cdbs, cs_tuners->sampling_rate))
  100. modify_all = false;
  101. else
  102. dbs_check_cpu(dbs_data, cpu);
  103. gov_queue_work(dbs_data, dbs_info->cdbs.cur_policy, delay, modify_all);
  104. mutex_unlock(&core_dbs_info->cdbs.timer_mutex);
  105. }
  106. static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
  107. void *data)
  108. {
  109. struct cpufreq_freqs *freq = data;
  110. struct cs_cpu_dbs_info_s *dbs_info =
  111. &per_cpu(cs_cpu_dbs_info, freq->cpu);
  112. struct cpufreq_policy *policy;
  113. if (!dbs_info->enable)
  114. return 0;
  115. policy = dbs_info->cdbs.cur_policy;
  116. /*
  117. * we only care if our internally tracked freq moves outside the 'valid'
  118. * ranges of frequency available to us otherwise we do not change it
  119. */
  120. if (dbs_info->requested_freq > policy->max
  121. || dbs_info->requested_freq < policy->min)
  122. dbs_info->requested_freq = freq->new;
  123. return 0;
  124. }
  125. /************************** sysfs interface ************************/
  126. static struct common_dbs_data cs_dbs_cdata;
  127. static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data,
  128. const char *buf, size_t count)
  129. {
  130. struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
  131. unsigned int input;
  132. int ret;
  133. ret = sscanf(buf, "%u", &input);
  134. if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
  135. return -EINVAL;
  136. cs_tuners->sampling_down_factor = input;
  137. return count;
  138. }
  139. static ssize_t store_sampling_rate(struct dbs_data *dbs_data, const char *buf,
  140. size_t count)
  141. {
  142. struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
  143. unsigned int input;
  144. int ret;
  145. ret = sscanf(buf, "%u", &input);
  146. if (ret != 1)
  147. return -EINVAL;
  148. cs_tuners->sampling_rate = max(input, dbs_data->min_sampling_rate);
  149. return count;
  150. }
  151. static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf,
  152. size_t count)
  153. {
  154. struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
  155. unsigned int input;
  156. int ret;
  157. ret = sscanf(buf, "%u", &input);
  158. if (ret != 1 || input > 100 || input <= cs_tuners->down_threshold)
  159. return -EINVAL;
  160. cs_tuners->up_threshold = input;
  161. return count;
  162. }
  163. static ssize_t store_down_threshold(struct dbs_data *dbs_data, const char *buf,
  164. size_t count)
  165. {
  166. struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
  167. unsigned int input;
  168. int ret;
  169. ret = sscanf(buf, "%u", &input);
  170. /* cannot be lower than 11 otherwise freq will not fall */
  171. if (ret != 1 || input < 11 || input > 100 ||
  172. input >= cs_tuners->up_threshold)
  173. return -EINVAL;
  174. cs_tuners->down_threshold = input;
  175. return count;
  176. }
  177. static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data,
  178. const char *buf, size_t count)
  179. {
  180. struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
  181. unsigned int input, j;
  182. int ret;
  183. ret = sscanf(buf, "%u", &input);
  184. if (ret != 1)
  185. return -EINVAL;
  186. if (input > 1)
  187. input = 1;
  188. if (input == cs_tuners->ignore_nice_load) /* nothing to do */
  189. return count;
  190. cs_tuners->ignore_nice_load = input;
  191. /* we need to re-evaluate prev_cpu_idle */
  192. for_each_online_cpu(j) {
  193. struct cs_cpu_dbs_info_s *dbs_info;
  194. dbs_info = &per_cpu(cs_cpu_dbs_info, j);
  195. dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j,
  196. &dbs_info->cdbs.prev_cpu_wall, 0);
  197. if (cs_tuners->ignore_nice_load)
  198. dbs_info->cdbs.prev_cpu_nice =
  199. kcpustat_cpu(j).cpustat[CPUTIME_NICE];
  200. }
  201. return count;
  202. }
  203. static ssize_t store_freq_step(struct dbs_data *dbs_data, const char *buf,
  204. size_t count)
  205. {
  206. struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
  207. unsigned int input;
  208. int ret;
  209. ret = sscanf(buf, "%u", &input);
  210. if (ret != 1)
  211. return -EINVAL;
  212. if (input > 100)
  213. input = 100;
  214. /*
  215. * no need to test here if freq_step is zero as the user might actually
  216. * want this, they would be crazy though :)
  217. */
  218. cs_tuners->freq_step = input;
  219. return count;
  220. }
  221. show_store_one(cs, sampling_rate);
  222. show_store_one(cs, sampling_down_factor);
  223. show_store_one(cs, up_threshold);
  224. show_store_one(cs, down_threshold);
  225. show_store_one(cs, ignore_nice_load);
  226. show_store_one(cs, freq_step);
  227. declare_show_sampling_rate_min(cs);
  228. gov_sys_pol_attr_rw(sampling_rate);
  229. gov_sys_pol_attr_rw(sampling_down_factor);
  230. gov_sys_pol_attr_rw(up_threshold);
  231. gov_sys_pol_attr_rw(down_threshold);
  232. gov_sys_pol_attr_rw(ignore_nice_load);
  233. gov_sys_pol_attr_rw(freq_step);
  234. gov_sys_pol_attr_ro(sampling_rate_min);
  235. static struct attribute *dbs_attributes_gov_sys[] = {
  236. &sampling_rate_min_gov_sys.attr,
  237. &sampling_rate_gov_sys.attr,
  238. &sampling_down_factor_gov_sys.attr,
  239. &up_threshold_gov_sys.attr,
  240. &down_threshold_gov_sys.attr,
  241. &ignore_nice_load_gov_sys.attr,
  242. &freq_step_gov_sys.attr,
  243. NULL
  244. };
  245. static struct attribute_group cs_attr_group_gov_sys = {
  246. .attrs = dbs_attributes_gov_sys,
  247. .name = "conservative",
  248. };
  249. static struct attribute *dbs_attributes_gov_pol[] = {
  250. &sampling_rate_min_gov_pol.attr,
  251. &sampling_rate_gov_pol.attr,
  252. &sampling_down_factor_gov_pol.attr,
  253. &up_threshold_gov_pol.attr,
  254. &down_threshold_gov_pol.attr,
  255. &ignore_nice_load_gov_pol.attr,
  256. &freq_step_gov_pol.attr,
  257. NULL
  258. };
  259. static struct attribute_group cs_attr_group_gov_pol = {
  260. .attrs = dbs_attributes_gov_pol,
  261. .name = "conservative",
  262. };
  263. /************************** sysfs end ************************/
  264. static int cs_init(struct dbs_data *dbs_data)
  265. {
  266. struct cs_dbs_tuners *tuners;
  267. tuners = kzalloc(sizeof(*tuners), GFP_KERNEL);
  268. if (!tuners) {
  269. pr_err("%s: kzalloc failed\n", __func__);
  270. return -ENOMEM;
  271. }
  272. tuners->up_threshold = DEF_FREQUENCY_UP_THRESHOLD;
  273. tuners->down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD;
  274. tuners->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR;
  275. tuners->ignore_nice_load = 0;
  276. tuners->freq_step = DEF_FREQUENCY_STEP;
  277. dbs_data->tuners = tuners;
  278. dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO *
  279. jiffies_to_usecs(10);
  280. mutex_init(&dbs_data->mutex);
  281. return 0;
  282. }
  283. static void cs_exit(struct dbs_data *dbs_data)
  284. {
  285. kfree(dbs_data->tuners);
  286. }
  287. define_get_cpu_dbs_routines(cs_cpu_dbs_info);
  288. static struct notifier_block cs_cpufreq_notifier_block = {
  289. .notifier_call = dbs_cpufreq_notifier,
  290. };
  291. static struct cs_ops cs_ops = {
  292. .notifier_block = &cs_cpufreq_notifier_block,
  293. };
  294. static struct common_dbs_data cs_dbs_cdata = {
  295. .governor = GOV_CONSERVATIVE,
  296. .attr_group_gov_sys = &cs_attr_group_gov_sys,
  297. .attr_group_gov_pol = &cs_attr_group_gov_pol,
  298. .get_cpu_cdbs = get_cpu_cdbs,
  299. .get_cpu_dbs_info_s = get_cpu_dbs_info_s,
  300. .gov_dbs_timer = cs_dbs_timer,
  301. .gov_check_cpu = cs_check_cpu,
  302. .gov_ops = &cs_ops,
  303. .init = cs_init,
  304. .exit = cs_exit,
  305. };
  306. static int cs_cpufreq_governor_dbs(struct cpufreq_policy *policy,
  307. unsigned int event)
  308. {
  309. return cpufreq_governor_dbs(policy, &cs_dbs_cdata, event);
  310. }
  311. #ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE
  312. static
  313. #endif
  314. struct cpufreq_governor cpufreq_gov_conservative = {
  315. .name = "conservative",
  316. .governor = cs_cpufreq_governor_dbs,
  317. .max_transition_latency = TRANSITION_LATENCY_LIMIT,
  318. .owner = THIS_MODULE,
  319. };
  320. static int __init cpufreq_gov_dbs_init(void)
  321. {
  322. return cpufreq_register_governor(&cpufreq_gov_conservative);
  323. }
  324. static void __exit cpufreq_gov_dbs_exit(void)
  325. {
  326. cpufreq_unregister_governor(&cpufreq_gov_conservative);
  327. }
  328. MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");
  329. MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for "
  330. "Low Latency Frequency Transition capable processors "
  331. "optimised for use in a battery environment");
  332. MODULE_LICENSE("GPL");
  333. #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE
  334. fs_initcall(cpufreq_gov_dbs_init);
  335. #else
  336. module_init(cpufreq_gov_dbs_init);
  337. #endif
  338. module_exit(cpufreq_gov_dbs_exit);