ARM: tegra: power: Enforce cpufreq policy maximum
[linux-3.10.git] / arch / arm / mach-tegra / cpu-tegra.c
1 /*
2  * arch/arm/mach-tegra/cpu-tegra.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  *
6  * Author:
7  *      Colin Cross <ccross@google.com>
8  *      Based on arch/arm/plat-omap/cpu-omap.c, (C) 2005 Nokia Corporation
9  *
10  * Copyright (C) 2010-2011 NVIDIA Corporation
11  *
12  * This software is licensed under the terms of the GNU General Public
13  * License version 2, as published by the Free Software Foundation, and
14  * may be copied, distributed, and modified under those terms.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/types.h>
26 #include <linux/sched.h>
27 #include <linux/cpufreq.h>
28 #include <linux/delay.h>
29 #include <linux/init.h>
30 #include <linux/err.h>
31 #include <linux/clk.h>
32 #include <linux/io.h>
33 #include <linux/suspend.h>
34 #include <linux/debugfs.h>
35 #include <linux/cpu.h>
36
37 #include <mach/edp.h>
38
39 #include "clock.h"
40 #include "cpu-tegra.h"
41
42 /* tegra throttling and edp governors require frequencies in the table
43    to be in ascending order */
44 static struct cpufreq_frequency_table *freq_table;
45
46 static struct clk *cpu_clk;
47 static struct clk *emc_clk;
48
49 static unsigned long policy_max_speed[CONFIG_NR_CPUS];
50 static unsigned long target_cpu_speed[CONFIG_NR_CPUS];
51 static DEFINE_MUTEX(tegra_cpu_lock);
52 static bool is_suspended;
53 static int suspend_index;
54
55 static bool force_policy_max;
56
57 static int force_policy_max_set(const char *arg, const struct kernel_param *kp)
58 {
59         int ret;
60         bool old_policy = force_policy_max;
61
62         ret = param_set_bool(arg, kp);
63
64         if ((ret == 0) && (old_policy != force_policy_max))
65                 tegra_cpu_set_speed_cap(NULL);
66
67         return ret;
68 }
69
70 static int force_policy_max_get(char *buffer, const struct kernel_param *kp)
71 {
72         return param_get_bool(buffer, kp);
73 }
74
75 static struct kernel_param_ops policy_ops = {
76         .set = force_policy_max_set,
77         .get = force_policy_max_get,
78 };
79 module_param_cb(force_policy_max, &policy_ops, &force_policy_max, 0644);
80
81
82 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
83
84 static ssize_t show_throttle(struct cpufreq_policy *policy, char *buf)
85 {
86         return sprintf(buf, "%u\n", tegra_is_throttling());
87 }
88
89 cpufreq_freq_attr_ro(throttle);
90
91 #ifdef CONFIG_DEBUG_FS
92
93 static struct dentry *cpu_tegra_debugfs_root;
94
95 static int __init tegra_cpu_debug_init(void)
96 {
97         cpu_tegra_debugfs_root = debugfs_create_dir("cpu-tegra", 0);
98
99         if (!cpu_tegra_debugfs_root)
100                 return -ENOMEM;
101
102         if (tegra_throttle_debug_init(cpu_tegra_debugfs_root))
103                 goto err_out;
104
105         return 0;
106
107 err_out:
108         debugfs_remove_recursive(cpu_tegra_debugfs_root);
109         return -ENOMEM;
110
111 }
112
113 static void __exit tegra_cpu_debug_exit(void)
114 {
115         debugfs_remove_recursive(cpu_tegra_debugfs_root);
116 }
117
118 late_initcall(tegra_cpu_debug_init);
119 module_exit(tegra_cpu_debug_exit);
120 #endif /* CONFIG_DEBUG_FS */
121 #endif /* CONFIG_TEGRA_THERMAL_THROTTLE */
122
123 #ifdef CONFIG_TEGRA_EDP_LIMITS
124
125 static const struct tegra_edp_limits *cpu_edp_limits;
126 static int cpu_edp_limits_size;
127 static int edp_thermal_index;
128 static cpumask_t edp_cpumask;
129 static unsigned int edp_limit;
130
131 unsigned int tegra_get_edp_limit(void)
132 {
133         return edp_limit;
134 }
135
136 static void edp_update_limit(void)
137 {
138         unsigned int limit = cpumask_weight(&edp_cpumask);
139 #ifndef CONFIG_TEGRA_EDP_EXACT_FREQ
140         int i;
141 #endif
142
143         if (!cpu_edp_limits)
144                 return;
145
146         BUG_ON((edp_thermal_index >= cpu_edp_limits_size) || (limit == 0));
147 #ifdef CONFIG_TEGRA_EDP_EXACT_FREQ
148         edp_limit = cpu_edp_limits[edp_thermal_index].freq_limits[limit - 1];
149 #else
150         limit = cpu_edp_limits[edp_thermal_index].freq_limits[limit - 1];
151
152         for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
153                 if (freq_table[i].frequency > limit) {
154                         break;
155                 }
156         }
157         BUG_ON(i == 0); /* min freq above the limit or table empty */
158         edp_limit = freq_table[i-1].frequency;
159 #endif
160 }
161
162 static unsigned int edp_governor_speed(unsigned int requested_speed)
163 {
164         if ((!cpu_edp_limits) || (requested_speed <= edp_limit))
165                 return requested_speed;
166         else
167                 return edp_limit;
168 }
169
170 int tegra_edp_update_thermal_zone(int temperature)
171 {
172         int i;
173         int ret = 0;
174         int nlimits = cpu_edp_limits_size;
175         int index;
176
177         if (!cpu_edp_limits)
178                 return -EINVAL;
179
180         index = nlimits - 1;
181
182         if (temperature < cpu_edp_limits[0].temperature) {
183                 index = 0;
184         } else {
185                 for (i = 0; i < (nlimits - 1); i++) {
186                         if (temperature >= cpu_edp_limits[i].temperature &&
187                            temperature < cpu_edp_limits[i + 1].temperature) {
188                                 index = i + 1;
189                                 break;
190                         }
191                 }
192         }
193
194         mutex_lock(&tegra_cpu_lock);
195         edp_thermal_index = index;
196
197         /* Update cpu rate if cpufreq (at least on cpu0) is already started */
198         if (target_cpu_speed[0]) {
199                 edp_update_limit();
200                 tegra_cpu_set_speed_cap(NULL);
201         }
202         mutex_unlock(&tegra_cpu_lock);
203
204         return ret;
205 }
206 EXPORT_SYMBOL_GPL(tegra_edp_update_thermal_zone);
207
208 bool tegra_cpu_edp_favor_up(unsigned int n, int mp_overhead)
209 {
210         unsigned int current_limit, next_limit;
211
212         if (n == 0)
213                 return true;
214
215         if (n >= ARRAY_SIZE(cpu_edp_limits->freq_limits))
216                 return false;
217
218         current_limit = cpu_edp_limits[edp_thermal_index].freq_limits[n-1];
219         next_limit = cpu_edp_limits[edp_thermal_index].freq_limits[n];
220
221         return ((next_limit * (n + 1)) >
222                 (current_limit * n * (100 + mp_overhead) / 100));
223 }
224
225 bool tegra_cpu_edp_favor_down(unsigned int n, int mp_overhead)
226 {
227         unsigned int current_limit, next_limit;
228
229         if (n <= 1)
230                 return false;
231
232         if (n > ARRAY_SIZE(cpu_edp_limits->freq_limits))
233                 return true;
234
235         current_limit = cpu_edp_limits[edp_thermal_index].freq_limits[n-1];
236         next_limit = cpu_edp_limits[edp_thermal_index].freq_limits[n-2];
237
238         return ((next_limit * (n - 1) * (100 + mp_overhead) / 100)) >
239                 (current_limit * n);
240 }
241
242 static int tegra_cpu_edp_notify(
243         struct notifier_block *nb, unsigned long event, void *hcpu)
244 {
245         int ret = 0;
246         unsigned int cpu_speed, new_speed;
247         int cpu = (long)hcpu;
248
249         switch (event) {
250         case CPU_UP_PREPARE:
251                 mutex_lock(&tegra_cpu_lock);
252                 cpu_set(cpu, edp_cpumask);
253                 edp_update_limit();
254
255                 cpu_speed = tegra_getspeed(0);
256                 new_speed = edp_governor_speed(cpu_speed);
257                 if (new_speed < cpu_speed) {
258                         ret = tegra_cpu_set_speed_cap(NULL);
259                         if (ret) {
260                                 cpu_clear(cpu, edp_cpumask);
261                                 edp_update_limit();
262                         }
263
264                         printk(KERN_DEBUG "tegra CPU:%sforce EDP limit %u kHz"
265                                 "\n", ret ? " failed to " : " ", new_speed);
266                 }
267                 mutex_unlock(&tegra_cpu_lock);
268                 break;
269         case CPU_DEAD:
270                 mutex_lock(&tegra_cpu_lock);
271                 cpu_clear(cpu, edp_cpumask);
272                 edp_update_limit();
273                 tegra_cpu_set_speed_cap(NULL);
274                 mutex_unlock(&tegra_cpu_lock);
275                 break;
276         }
277         return notifier_from_errno(ret);
278 }
279
280 static struct notifier_block tegra_cpu_edp_notifier = {
281         .notifier_call = tegra_cpu_edp_notify,
282 };
283
284 static void tegra_cpu_edp_init(bool resume)
285 {
286         tegra_get_cpu_edp_limits(&cpu_edp_limits, &cpu_edp_limits_size);
287
288         if (!cpu_edp_limits) {
289                 if (!resume)
290                         pr_info("cpu-tegra: no EDP table is provided\n");
291                 return;
292         }
293
294         /* FIXME: use the highest temperature limits if sensor is not on-line?
295          * If thermal zone is not set yet by the sensor, edp_thermal_index = 0.
296          * Boot frequency allowed SoC to get here, should work till sensor is
297          * initialized.
298          */
299         edp_cpumask = *cpu_online_mask;
300         edp_update_limit();
301
302         if (!resume) {
303                 register_hotcpu_notifier(&tegra_cpu_edp_notifier);
304                 pr_info("cpu-tegra: init EDP limit: %u MHz\n", edp_limit/1000);
305         }
306 }
307
308 static void tegra_cpu_edp_exit(void)
309 {
310         if (!cpu_edp_limits)
311                 return;
312
313         unregister_hotcpu_notifier(&tegra_cpu_edp_notifier);
314 }
315
316 #else   /* CONFIG_TEGRA_EDP_LIMITS */
317
318 #define edp_governor_speed(requested_speed) (requested_speed)
319 #define tegra_cpu_edp_init(resume)
320 #define tegra_cpu_edp_exit()
321 #endif  /* CONFIG_TEGRA_EDP_LIMITS */
322
323 static int tegra_verify_speed(struct cpufreq_policy *policy)
324 {
325         return cpufreq_frequency_table_verify(policy, freq_table);
326 }
327
328 unsigned int tegra_getspeed(unsigned int cpu)
329 {
330         unsigned long rate;
331
332         if (cpu >= CONFIG_NR_CPUS)
333                 return 0;
334
335         rate = clk_get_rate(cpu_clk) / 1000;
336         return rate;
337 }
338
339 static int tegra_update_cpu_speed(unsigned long rate)
340 {
341         int ret = 0;
342         struct cpufreq_freqs freqs;
343
344         freqs.old = tegra_getspeed(0);
345         freqs.new = rate;
346
347         rate = clk_round_rate(cpu_clk, rate * 1000);
348         if (!IS_ERR_VALUE(rate))
349                 freqs.new = rate / 1000;
350
351         if (freqs.old == freqs.new)
352                 return ret;
353
354         /*
355          * Vote on memory bus frequency based on cpu frequency
356          * This sets the minimum frequency, display or avp may request higher
357          */
358         clk_set_rate(emc_clk, tegra_emc_to_cpu_ratio(freqs.new));
359
360         for_each_online_cpu(freqs.cpu)
361                 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
362
363 #ifdef CONFIG_CPU_FREQ_DEBUG
364         printk(KERN_DEBUG "cpufreq-tegra: transition: %u --> %u\n",
365                freqs.old, freqs.new);
366 #endif
367
368         ret = clk_set_rate(cpu_clk, freqs.new * 1000);
369         if (ret) {
370                 pr_err("cpu-tegra: Failed to set cpu frequency to %d kHz\n",
371                         freqs.new);
372                 return ret;
373         }
374
375         for_each_online_cpu(freqs.cpu)
376                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
377
378         return 0;
379 }
380
381 unsigned int tegra_count_slow_cpus(unsigned long speed_limit)
382 {
383         unsigned int cnt = 0;
384         int i;
385
386         for_each_online_cpu(i)
387                 if (target_cpu_speed[i] <= speed_limit)
388                         cnt++;
389         return cnt;
390 }
391
392 unsigned int tegra_get_slowest_cpu_n(void) {
393         unsigned int cpu = nr_cpu_ids;
394         unsigned long rate = ULONG_MAX;
395         int i;
396
397         for_each_online_cpu(i)
398                 if ((i > 0) && (rate > target_cpu_speed[i])) {
399                         cpu = i;
400                         rate = target_cpu_speed[i];
401                 }
402         return cpu;
403 }
404
405 unsigned long tegra_cpu_lowest_speed(void) {
406         unsigned long rate = ULONG_MAX;
407         int i;
408
409         for_each_online_cpu(i)
410                 rate = min(rate, target_cpu_speed[i]);
411         return rate;
412 }
413
414 unsigned long tegra_cpu_highest_speed(void) {
415         unsigned long policy_max = ULONG_MAX;
416         unsigned long rate = 0;
417         int i;
418
419         for_each_online_cpu(i) {
420                 if (force_policy_max)
421                         policy_max = min(policy_max, policy_max_speed[i]);
422                 rate = max(rate, target_cpu_speed[i]);
423         }
424         rate = min(rate, policy_max);
425         return rate;
426 }
427
428 int tegra_cpu_set_speed_cap(unsigned int *speed_cap)
429 {
430         int ret = 0;
431         unsigned int new_speed = tegra_cpu_highest_speed();
432
433         if (is_suspended)
434                 return -EBUSY;
435
436         new_speed = tegra_throttle_governor_speed(new_speed);
437         new_speed = edp_governor_speed(new_speed);
438         if (speed_cap)
439                 *speed_cap = new_speed;
440
441         ret = tegra_update_cpu_speed(new_speed);
442         if (ret == 0)
443                 tegra_auto_hotplug_governor(new_speed, false);
444         return ret;
445 }
446
447 static int tegra_target(struct cpufreq_policy *policy,
448                        unsigned int target_freq,
449                        unsigned int relation)
450 {
451         int idx;
452         unsigned int freq;
453         unsigned int new_speed;
454         int ret = 0;
455
456         mutex_lock(&tegra_cpu_lock);
457
458         cpufreq_frequency_table_target(policy, freq_table, target_freq,
459                 relation, &idx);
460
461         freq = freq_table[idx].frequency;
462
463         target_cpu_speed[policy->cpu] = freq;
464         ret = tegra_cpu_set_speed_cap(&new_speed);
465
466         mutex_unlock(&tegra_cpu_lock);
467
468         return ret;
469 }
470
471
472 static int tegra_pm_notify(struct notifier_block *nb, unsigned long event,
473         void *dummy)
474 {
475         mutex_lock(&tegra_cpu_lock);
476         if (event == PM_SUSPEND_PREPARE) {
477                 is_suspended = true;
478                 pr_info("Tegra cpufreq suspend: setting frequency to %d kHz\n",
479                         freq_table[suspend_index].frequency);
480                 tegra_update_cpu_speed(freq_table[suspend_index].frequency);
481                 tegra_auto_hotplug_governor(
482                         freq_table[suspend_index].frequency, true);
483         } else if (event == PM_POST_SUSPEND) {
484                 unsigned int freq;
485                 is_suspended = false;
486                 tegra_cpu_edp_init(true);
487                 tegra_cpu_set_speed_cap(&freq);
488                 pr_info("Tegra cpufreq resume: restoring frequency to %d kHz\n",
489                         freq);
490         }
491         mutex_unlock(&tegra_cpu_lock);
492
493         return NOTIFY_OK;
494 }
495
496 static struct notifier_block tegra_cpu_pm_notifier = {
497         .notifier_call = tegra_pm_notify,
498 };
499
500 static int tegra_cpu_init(struct cpufreq_policy *policy)
501 {
502         if (policy->cpu >= CONFIG_NR_CPUS)
503                 return -EINVAL;
504
505         cpu_clk = clk_get_sys(NULL, "cpu");
506         if (IS_ERR(cpu_clk))
507                 return PTR_ERR(cpu_clk);
508
509         emc_clk = clk_get_sys("cpu", "emc");
510         if (IS_ERR(emc_clk)) {
511                 clk_put(cpu_clk);
512                 return PTR_ERR(emc_clk);
513         }
514
515         clk_prepare_enable(emc_clk);
516         clk_prepare_enable(cpu_clk);
517
518         cpufreq_frequency_table_cpuinfo(policy, freq_table);
519         cpufreq_frequency_table_get_attr(freq_table, policy->cpu);
520         policy->cur = tegra_getspeed(policy->cpu);
521         target_cpu_speed[policy->cpu] = policy->cur;
522
523         /* FIXME: what's the actual transition time? */
524         policy->cpuinfo.transition_latency = 300 * 1000;
525
526         cpumask_copy(policy->cpus, cpu_possible_mask);
527
528         if (policy->cpu == 0) {
529                 register_pm_notifier(&tegra_cpu_pm_notifier);
530         }
531
532         return 0;
533 }
534
535 static int tegra_cpu_exit(struct cpufreq_policy *policy)
536 {
537         cpufreq_frequency_table_cpuinfo(policy, freq_table);
538         clk_disable_unprepare(emc_clk);
539         clk_put(emc_clk);
540         clk_put(cpu_clk);
541         return 0;
542 }
543
544 static int tegra_cpufreq_policy_notifier(
545         struct notifier_block *nb, unsigned long event, void *data)
546 {
547         int i, ret;
548         struct cpufreq_policy *policy = data;
549
550         if (event == CPUFREQ_NOTIFY) {
551                 ret = cpufreq_frequency_table_target(policy, freq_table,
552                         policy->max, CPUFREQ_RELATION_H, &i);
553                 policy_max_speed[policy->cpu] =
554                         ret ? policy->max : freq_table[i].frequency;
555         }
556         return NOTIFY_OK;
557 }
558
559 static struct notifier_block tegra_cpufreq_policy_nb = {
560         .notifier_call = tegra_cpufreq_policy_notifier,
561 };
562
563 static struct freq_attr *tegra_cpufreq_attr[] = {
564         &cpufreq_freq_attr_scaling_available_freqs,
565 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
566         &throttle,
567 #endif
568         NULL,
569 };
570
571 static struct cpufreq_driver tegra_cpufreq_driver = {
572         .verify         = tegra_verify_speed,
573         .target         = tegra_target,
574         .get            = tegra_getspeed,
575         .init           = tegra_cpu_init,
576         .exit           = tegra_cpu_exit,
577         .name           = "tegra",
578         .attr           = tegra_cpufreq_attr,
579 };
580
581 static int __init tegra_cpufreq_init(void)
582 {
583         int ret = 0;
584
585         struct tegra_cpufreq_table_data *table_data =
586                 tegra_cpufreq_table_get();
587         if (IS_ERR_OR_NULL(table_data))
588                 return -EINVAL;
589
590         suspend_index = table_data->suspend_index;
591
592         ret = tegra_throttle_init(&tegra_cpu_lock);
593         if (ret)
594                 return ret;
595
596         ret = tegra_auto_hotplug_init(&tegra_cpu_lock);
597         if (ret)
598                 return ret;
599
600         freq_table = table_data->freq_table;
601         tegra_cpu_edp_init(false);
602
603         ret = cpufreq_register_notifier(
604                 &tegra_cpufreq_policy_nb, CPUFREQ_POLICY_NOTIFIER);
605         if (ret)
606                 return ret;
607
608         return cpufreq_register_driver(&tegra_cpufreq_driver);
609 }
610
611 static void __exit tegra_cpufreq_exit(void)
612 {
613         tegra_throttle_exit();
614         tegra_cpu_edp_exit();
615         tegra_auto_hotplug_exit();
616         cpufreq_unregister_driver(&tegra_cpufreq_driver);
617         cpufreq_unregister_notifier(
618                 &tegra_cpufreq_policy_nb, CPUFREQ_POLICY_NOTIFIER);
619 }
620
621
622 MODULE_AUTHOR("Colin Cross <ccross@android.com>");
623 MODULE_DESCRIPTION("cpufreq driver for Nvidia Tegra2");
624 MODULE_LICENSE("GPL");
625 module_init(tegra_cpufreq_init);
626 module_exit(tegra_cpufreq_exit);