ARM: tegra: power: Add dynamic CPU regulator mode control
[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-2013 NVIDIA CORPORATION. All rights reserved.
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 #include <linux/regulator/consumer.h>
37
38 #include <mach/edp.h>
39
40 #include "clock.h"
41 #include "cpu-tegra.h"
42 #include "dvfs.h"
43
44 /* tegra throttling and edp governors require frequencies in the table
45    to be in ascending order */
46 static struct cpufreq_frequency_table *freq_table;
47
48 static struct clk *cpu_clk;
49
50 static unsigned long policy_max_speed[CONFIG_NR_CPUS];
51 static unsigned long target_cpu_speed[CONFIG_NR_CPUS];
52 static DEFINE_MUTEX(tegra_cpu_lock);
53 static bool is_suspended;
54 static int suspend_index;
55 static unsigned int volt_capped_speed;
56
57
58 static bool force_policy_max;
59
60 static int force_policy_max_set(const char *arg, const struct kernel_param *kp)
61 {
62         int ret;
63         bool old_policy = force_policy_max;
64
65         mutex_lock(&tegra_cpu_lock);
66
67         ret = param_set_bool(arg, kp);
68         if ((ret == 0) && (old_policy != force_policy_max))
69                 tegra_cpu_set_speed_cap_locked(NULL);
70
71         mutex_unlock(&tegra_cpu_lock);
72         return ret;
73 }
74
75 static int force_policy_max_get(char *buffer, const struct kernel_param *kp)
76 {
77         return param_get_bool(buffer, kp);
78 }
79
80 static struct kernel_param_ops policy_ops = {
81         .set = force_policy_max_set,
82         .get = force_policy_max_get,
83 };
84 module_param_cb(force_policy_max, &policy_ops, &force_policy_max, 0644);
85
86
87 static unsigned int cpu_user_cap;
88
89 static inline void _cpu_user_cap_set_locked(void)
90 {
91 #ifndef CONFIG_TEGRA_CPU_CAP_EXACT_FREQ
92         if (cpu_user_cap != 0) {
93                 int i;
94                 for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
95                         if (freq_table[i].frequency > cpu_user_cap)
96                                 break;
97                 }
98                 i = (i == 0) ? 0 : i - 1;
99                 cpu_user_cap = freq_table[i].frequency;
100         }
101 #endif
102         tegra_cpu_set_speed_cap_locked(NULL);
103 }
104
105 void tegra_cpu_user_cap_set(unsigned int speed_khz)
106 {
107         mutex_lock(&tegra_cpu_lock);
108
109         cpu_user_cap = speed_khz;
110         _cpu_user_cap_set_locked();
111
112         mutex_unlock(&tegra_cpu_lock);
113 }
114
115 static int cpu_user_cap_set(const char *arg, const struct kernel_param *kp)
116 {
117         int ret;
118
119         mutex_lock(&tegra_cpu_lock);
120
121         ret = param_set_uint(arg, kp);
122         if (ret == 0)
123                 _cpu_user_cap_set_locked();
124
125         mutex_unlock(&tegra_cpu_lock);
126         return ret;
127 }
128
129 static int cpu_user_cap_get(char *buffer, const struct kernel_param *kp)
130 {
131         return param_get_uint(buffer, kp);
132 }
133
134 static struct kernel_param_ops cap_ops = {
135         .set = cpu_user_cap_set,
136         .get = cpu_user_cap_get,
137 };
138 module_param_cb(cpu_user_cap, &cap_ops, &cpu_user_cap, 0644);
139
140 static unsigned int user_cap_speed(unsigned int requested_speed)
141 {
142         if ((cpu_user_cap) && (requested_speed > cpu_user_cap))
143                 return cpu_user_cap;
144         return requested_speed;
145 }
146
147 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
148
149 static ssize_t show_throttle(struct cpufreq_policy *policy, char *buf)
150 {
151         return sprintf(buf, "%u\n", tegra_is_throttling(NULL));
152 }
153
154 cpufreq_freq_attr_ro(throttle);
155
156 static ssize_t show_throttle_count(struct cpufreq_policy *policy, char *buf)
157 {
158         int count;
159
160         tegra_is_throttling(&count);
161         return sprintf(buf, "%u\n", count);
162 }
163
164 static struct freq_attr _attr_throttle_count = {
165         .attr = {.name = "throttle_count", .mode = 0444, },
166         .show = show_throttle_count,
167 };
168
169 static struct attribute *new_attrs[] = {
170         &_attr_throttle_count.attr,
171         NULL
172 };
173
174 static struct attribute_group stats_attr_grp = {
175         .attrs = new_attrs,
176         .name = "stats"
177 };
178
179 #endif /* CONFIG_TEGRA_THERMAL_THROTTLE */
180
181 #ifdef CONFIG_TEGRA_EDP_LIMITS
182
183 static const struct tegra_edp_limits *cpu_edp_limits;
184 static int cpu_edp_limits_size;
185
186 static const struct tegra_edp_limits *cpu_reg_idle_limits;
187 static unsigned int reg_mode;
188 static bool reg_mode_force_normal;
189
190 static const unsigned int *system_edp_limits;
191 static bool system_edp_alarm;
192
193 static int edp_thermal_index;
194 static cpumask_t edp_cpumask;
195 static unsigned int edp_limit;
196
197 unsigned int tegra_get_edp_limit(int *get_edp_thermal_index)
198 {
199         if (get_edp_thermal_index)
200                 *get_edp_thermal_index = edp_thermal_index;
201         return edp_limit;
202 }
203
204 static unsigned int edp_predict_limit(unsigned int cpus)
205 {
206         unsigned int limit = 0;
207
208         BUG_ON(cpus == 0);
209         if (cpu_edp_limits) {
210                 BUG_ON(edp_thermal_index >= cpu_edp_limits_size);
211                 limit = cpu_edp_limits[edp_thermal_index].freq_limits[cpus - 1];
212         }
213         if (system_edp_limits && system_edp_alarm)
214                 limit = min(limit, system_edp_limits[cpus - 1]);
215
216         return limit;
217 }
218
219 /* Must be called while holding cpu_tegra_lock */
220 static void edp_update_limit(void)
221 {
222         unsigned int limit = edp_predict_limit(cpumask_weight(&edp_cpumask));
223         BUG_ON(!mutex_is_locked(&tegra_cpu_lock));
224 #ifdef CONFIG_TEGRA_EDP_EXACT_FREQ
225         edp_limit = limit;
226 #else
227         unsigned int i;
228         for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
229                 if (freq_table[i].frequency > limit) {
230                         break;
231                 }
232         }
233         BUG_ON(i == 0); /* min freq above the limit or table empty */
234         edp_limit = freq_table[i-1].frequency;
235 #endif
236 }
237
238 static unsigned int edp_governor_speed(unsigned int requested_speed)
239 {
240         if ((!edp_limit) || (requested_speed <= edp_limit))
241                 return requested_speed;
242         else
243                 return edp_limit;
244 }
245
246 int tegra_edp_get_max_state(struct thermal_cooling_device *cdev,
247                                 unsigned long *max_state)
248 {
249         *max_state = cpu_edp_limits_size - 1;
250         return 0;
251 }
252
253 int tegra_edp_get_cur_state(struct thermal_cooling_device *cdev,
254                                 unsigned long *cur_state)
255 {
256         *cur_state = edp_thermal_index;
257         return 0;
258 }
259
260 int tegra_edp_set_cur_state(struct thermal_cooling_device *cdev,
261                                 unsigned long cur_state)
262 {
263         mutex_lock(&tegra_cpu_lock);
264         edp_thermal_index = cur_state;
265
266         /* Update cpu rate if cpufreq (at least on cpu0) is already started;
267            alter cpu dvfs table for this thermal zone if necessary */
268         tegra_cpu_dvfs_alter(edp_thermal_index, &edp_cpumask, true, 0);
269         if (target_cpu_speed[0]) {
270                 edp_update_limit();
271                 tegra_cpu_set_speed_cap_locked(NULL);
272         }
273         tegra_cpu_dvfs_alter(edp_thermal_index, &edp_cpumask, false, 0);
274         mutex_unlock(&tegra_cpu_lock);
275
276         return 0;
277 }
278
279 static struct thermal_cooling_device_ops tegra_edp_cooling_ops = {
280         .get_max_state = tegra_edp_get_max_state,
281         .get_cur_state = tegra_edp_get_cur_state,
282         .set_cur_state = tegra_edp_set_cur_state,
283 };
284
285 static int __init edp_init(void)
286 {
287         thermal_cooling_device_register(
288                                 "cpu_edp",
289                                 NULL,
290                                 &tegra_edp_cooling_ops);
291         return 0;
292 }
293 module_init(edp_init);
294
295 int tegra_system_edp_alarm(bool alarm)
296 {
297         int ret = -ENODEV;
298
299         mutex_lock(&tegra_cpu_lock);
300         system_edp_alarm = alarm;
301
302         /* Update cpu rate if cpufreq (at least on cpu0) is already started
303            and cancel emergency throttling after either edp limit is applied
304            or alarm is canceled */
305         if (target_cpu_speed[0]) {
306                 edp_update_limit();
307                 ret = tegra_cpu_set_speed_cap_locked(NULL);
308         }
309         if (!ret || !alarm)
310                 tegra_edp_throttle_cpu_now(0);
311
312         mutex_unlock(&tegra_cpu_lock);
313
314         return ret;
315 }
316
317 bool tegra_cpu_edp_favor_up(unsigned int n, int mp_overhead)
318 {
319         unsigned int current_limit, next_limit;
320
321         if (n == 0)
322                 return true;
323
324         if (n >= ARRAY_SIZE(cpu_edp_limits->freq_limits))
325                 return false;
326
327         current_limit = edp_predict_limit(n);
328         next_limit = edp_predict_limit(n + 1);
329
330         return ((next_limit * (n + 1)) >=
331                 (current_limit * n * (100 + mp_overhead) / 100));
332 }
333
334 bool tegra_cpu_edp_favor_down(unsigned int n, int mp_overhead)
335 {
336         unsigned int current_limit, next_limit;
337
338         if (n <= 1)
339                 return false;
340
341         if (n > ARRAY_SIZE(cpu_edp_limits->freq_limits))
342                 return true;
343
344         current_limit = edp_predict_limit(n);
345         next_limit = edp_predict_limit(n - 1);
346
347         return ((next_limit * (n - 1) * (100 + mp_overhead) / 100)) >
348                 (current_limit * n);
349 }
350
351 static int tegra_cpu_edp_notify(
352         struct notifier_block *nb, unsigned long event, void *hcpu)
353 {
354         int ret = 0;
355         unsigned int cpu_speed, new_speed;
356         int cpu = (long)hcpu;
357
358         switch (event) {
359         case CPU_UP_PREPARE:
360                 mutex_lock(&tegra_cpu_lock);
361                 cpu_set(cpu, edp_cpumask);
362                 edp_update_limit();
363
364                 cpu_speed = tegra_getspeed(0);
365                 new_speed = edp_governor_speed(cpu_speed);
366                 if (new_speed < cpu_speed ||
367                     (!is_suspended && cpu_reg_idle_limits)) {
368                         ret = tegra_cpu_set_speed_cap_locked(NULL);
369                         printk(KERN_DEBUG "cpu-tegra:%sforce EDP limit %u kHz"
370                                 "\n", ret ? " failed to " : " ", new_speed);
371                 }
372                 if (!ret)
373                         ret = tegra_cpu_dvfs_alter(
374                                 edp_thermal_index, &edp_cpumask, false, event);
375                 if (ret) {
376                         cpu_clear(cpu, edp_cpumask);
377                         edp_update_limit();
378                 }
379                 mutex_unlock(&tegra_cpu_lock);
380                 break;
381         case CPU_DEAD:
382                 mutex_lock(&tegra_cpu_lock);
383                 cpu_clear(cpu, edp_cpumask);
384                 tegra_cpu_dvfs_alter(
385                         edp_thermal_index, &edp_cpumask, true, event);
386                 edp_update_limit();
387                 tegra_cpu_set_speed_cap_locked(NULL);
388                 mutex_unlock(&tegra_cpu_lock);
389                 break;
390         }
391         return notifier_from_errno(ret);
392 }
393
394 static struct notifier_block tegra_cpu_edp_notifier = {
395         .notifier_call = tegra_cpu_edp_notify,
396 };
397
398 static void tegra_cpu_edp_init(bool resume)
399 {
400         tegra_get_system_edp_limits(&system_edp_limits);
401         tegra_get_cpu_edp_limits(&cpu_edp_limits, &cpu_edp_limits_size);
402
403         if (!(cpu_edp_limits || system_edp_limits)) {
404                 if (!resume)
405                         pr_info("cpu-tegra: no EDP table is provided\n");
406                 return;
407         }
408
409         /* FIXME: use the highest temperature limits if sensor is not on-line?
410          * If thermal zone is not set yet by the sensor, edp_thermal_index = 0.
411          * Boot frequency allowed SoC to get here, should work till sensor is
412          * initialized.
413          */
414         edp_cpumask = *cpu_online_mask;
415         edp_update_limit();
416
417         if (!resume) {
418                 register_hotcpu_notifier(&tegra_cpu_edp_notifier);
419                 pr_info("cpu-tegra: init EDP limit: %u MHz\n", edp_limit/1000);
420         }
421 }
422
423 static void tegra_cpu_edp_exit(void)
424 {
425         if (!(cpu_edp_limits || system_edp_limits))
426                 return;
427
428         unregister_hotcpu_notifier(&tegra_cpu_edp_notifier);
429 }
430
431 static unsigned int cpu_reg_mode_predict_idle_limit(void)
432 {
433         unsigned int cpus, limit;
434
435         if (!cpu_reg_idle_limits)
436                 return 0;
437
438         cpus = cpumask_weight(&edp_cpumask);
439         BUG_ON(cpus == 0);
440         BUG_ON(edp_thermal_index >= cpu_edp_limits_size);
441         limit = cpu_reg_idle_limits[edp_thermal_index].freq_limits[cpus - 1];
442         return limit ? : 1; /* bump 0 to 1kHz to differentiate from no-table */
443 }
444
445 static int cpu_reg_mode_limits_init(void)
446 {
447         int limits_size;
448
449         tegra_get_cpu_reg_mode_limits(&cpu_reg_idle_limits, &limits_size,
450                                       REGULATOR_MODE_IDLE);
451
452         if (!cpu_reg_idle_limits) {
453                 reg_mode = -ENOENT;
454                 return -ENOENT;
455         }
456
457         if (!cpu_edp_limits || (limits_size != cpu_edp_limits_size)) {
458                 pr_err("cpu-tegra: EDP and regulator mode tables mismatch\n");
459                 cpu_reg_idle_limits = NULL;
460                 reg_mode = -EINVAL;
461                 return -EINVAL;
462         }
463
464         reg_mode_force_normal = false;
465         return 0;
466 }
467
468 int tegra_cpu_reg_mode_force_normal(bool force)
469 {
470         int ret = 0;
471
472         mutex_lock(&tegra_cpu_lock);
473         if (cpu_reg_idle_limits) {
474                 reg_mode_force_normal = force;
475                 ret = tegra_cpu_set_speed_cap_locked(NULL);
476         }
477         mutex_unlock(&tegra_cpu_lock);
478         return ret;
479 }
480
481 int tegra_update_cpu_edp_limits(void)
482 {
483         int ret;
484
485         mutex_lock(&tegra_cpu_lock);
486         tegra_recalculate_cpu_edp_limits();
487         cpu_reg_mode_limits_init();
488         ret = tegra_cpu_set_speed_cap_locked(NULL);
489         mutex_unlock(&tegra_cpu_lock);
490
491         return ret;
492 }
493
494 #ifdef CONFIG_DEBUG_FS
495
496 static int system_edp_alarm_get(void *data, u64 *val)
497 {
498         *val = (u64)system_edp_alarm;
499         return 0;
500 }
501 static int system_edp_alarm_set(void *data, u64 val)
502 {
503         if (val > 1) {  /* emulate emergency throttling */
504                 tegra_edp_throttle_cpu_now(val);
505                 return 0;
506         }
507         return tegra_system_edp_alarm((bool)val);
508 }
509 DEFINE_SIMPLE_ATTRIBUTE(system_edp_alarm_fops,
510                         system_edp_alarm_get, system_edp_alarm_set, "%llu\n");
511
512 static int reg_mode_force_normal_get(void *data, u64 *val)
513 {
514         *val = (u64)reg_mode_force_normal;
515         return 0;
516 }
517 static int reg_mode_force_normal_set(void *data, u64 val)
518 {
519         return tegra_cpu_reg_mode_force_normal(val);
520 }
521 DEFINE_SIMPLE_ATTRIBUTE(force_normal_fops, reg_mode_force_normal_get,
522                         reg_mode_force_normal_set, "%llu\n");
523
524 static int reg_mode_get(void *data, u64 *val)
525 {
526         *val = (u64)reg_mode;
527         return 0;
528 }
529 DEFINE_SIMPLE_ATTRIBUTE(reg_mode_fops, reg_mode_get, NULL, "0x%llx\n");
530
531 static int __init tegra_edp_debug_init(struct dentry *cpu_tegra_debugfs_root)
532 {
533         if (!debugfs_create_file("edp_alarm", 0644, cpu_tegra_debugfs_root,
534                                  NULL, &system_edp_alarm_fops))
535                 return -ENOMEM;
536
537         if (!debugfs_create_file("reg_mode_force_normal", 0644,
538                         cpu_tegra_debugfs_root, NULL, &force_normal_fops))
539                 return -ENOMEM;
540
541         if (!debugfs_create_file("reg_mode", 0444,
542                         cpu_tegra_debugfs_root, NULL, &reg_mode_fops))
543                 return -ENOMEM;
544
545         return 0;
546 }
547 #endif
548
549 #else   /* CONFIG_TEGRA_EDP_LIMITS */
550 #define edp_governor_speed(requested_speed) (requested_speed)
551 #define tegra_cpu_edp_init(resume)
552 #define tegra_cpu_edp_exit()
553 #define tegra_edp_debug_init(cpu_tegra_debugfs_root) (0)
554 #define cpu_reg_mode_predict_idle_limit() (0)
555 static unsigned int reg_mode;
556 #endif  /* CONFIG_TEGRA_EDP_LIMITS */
557
558 #ifdef CONFIG_DEBUG_FS
559
560 static struct dentry *cpu_tegra_debugfs_root;
561
562 static int __init tegra_cpu_debug_init(void)
563 {
564         cpu_tegra_debugfs_root = debugfs_create_dir("cpu-tegra", 0);
565
566         if (!cpu_tegra_debugfs_root)
567                 return -ENOMEM;
568
569         if (tegra_edp_debug_init(cpu_tegra_debugfs_root))
570                 goto err_out;
571
572         return 0;
573
574 err_out:
575         debugfs_remove_recursive(cpu_tegra_debugfs_root);
576         return -ENOMEM;
577 }
578
579 static void __exit tegra_cpu_debug_exit(void)
580 {
581         debugfs_remove_recursive(cpu_tegra_debugfs_root);
582 }
583
584 late_initcall(tegra_cpu_debug_init);
585 module_exit(tegra_cpu_debug_exit);
586 #endif /* CONFIG_DEBUG_FS */
587
588 static int tegra_verify_speed(struct cpufreq_policy *policy)
589 {
590         return cpufreq_frequency_table_verify(policy, freq_table);
591 }
592
593 unsigned int tegra_getspeed(unsigned int cpu)
594 {
595         unsigned long rate;
596
597         if (cpu >= CONFIG_NR_CPUS)
598                 return 0;
599
600         rate = clk_get_rate(cpu_clk) / 1000;
601         return rate;
602 }
603
604 int tegra_update_cpu_speed(unsigned long rate)
605 {
606         int ret = 0;
607         struct cpufreq_freqs freqs;
608         unsigned int mode, mode_limit = cpu_reg_mode_predict_idle_limit();
609
610         freqs.old = tegra_getspeed(0);
611         freqs.new = rate;
612
613         rate = clk_round_rate(cpu_clk, rate * 1000);
614         if (!IS_ERR_VALUE(rate))
615                 freqs.new = rate / 1000;
616
617         mode = REGULATOR_MODE_NORMAL;
618         if (mode_limit && (mode_limit < freqs.new || reg_mode_force_normal)) {
619                 mode_limit = 0;         /* prevent further mode controls */
620                 if (reg_mode != mode) {
621                         ret = tegra_dvfs_rail_set_mode(tegra_cpu_rail, mode);
622                         if (ret)
623                                 return ret;
624                         reg_mode = mode;
625                 }
626         }
627
628         if (freqs.old == freqs.new)
629                 goto _out;
630
631         /*
632          * Vote on memory bus frequency based on cpu frequency
633          * This sets the minimum frequency, display or avp may request higher
634          */
635         if (freqs.old < freqs.new) {
636                 ret = tegra_update_mselect_rate(freqs.new);
637                 if (ret) {
638                         pr_err("cpu-tegra: Failed to scale mselect for cpu"
639                                " frequency %u kHz\n", freqs.new);
640                         return ret;
641                 }
642         }
643
644         for_each_online_cpu(freqs.cpu)
645                 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
646
647 #ifdef CONFIG_CPU_FREQ_DEBUG
648         printk(KERN_DEBUG "cpufreq-tegra: transition: %u --> %u\n",
649                freqs.old, freqs.new);
650 #endif
651
652         ret = clk_set_rate(cpu_clk, freqs.new * 1000);
653         if (ret) {
654                 pr_err("cpu-tegra: Failed to set cpu frequency to %d kHz\n",
655                         freqs.new);
656                 return ret;
657         }
658
659         for_each_online_cpu(freqs.cpu)
660                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
661
662         if (freqs.old > freqs.new)
663                 tegra_update_mselect_rate(freqs.new);
664 _out:
665         mode = REGULATOR_MODE_IDLE;
666         if ((mode_limit >= freqs.new) && (reg_mode != mode))
667                 if (!tegra_dvfs_rail_set_mode(tegra_cpu_rail, mode))
668                         reg_mode = mode;
669
670         return 0;
671 }
672
673 unsigned int tegra_count_slow_cpus(unsigned long speed_limit)
674 {
675         unsigned int cnt = 0;
676         int i;
677
678         for_each_online_cpu(i)
679                 if (target_cpu_speed[i] <= speed_limit)
680                         cnt++;
681         return cnt;
682 }
683
684 unsigned int tegra_get_slowest_cpu_n(void) {
685         unsigned int cpu = nr_cpu_ids;
686         unsigned long rate = ULONG_MAX;
687         int i;
688
689         for_each_online_cpu(i)
690                 if ((i > 0) && (rate > target_cpu_speed[i])) {
691                         cpu = i;
692                         rate = target_cpu_speed[i];
693                 }
694         return cpu;
695 }
696
697 unsigned long tegra_cpu_lowest_speed(void) {
698         unsigned long rate = ULONG_MAX;
699         int i;
700
701         for_each_online_cpu(i)
702                 rate = min(rate, target_cpu_speed[i]);
703         return rate;
704 }
705
706 unsigned long tegra_cpu_highest_speed(void) {
707         unsigned long policy_max = ULONG_MAX;
708         unsigned long rate = 0;
709         int i;
710
711         for_each_online_cpu(i) {
712                 if (force_policy_max)
713                         policy_max = min(policy_max, policy_max_speed[i]);
714                 rate = max(rate, target_cpu_speed[i]);
715         }
716         rate = min(rate, policy_max);
717         return rate;
718 }
719
720 void tegra_cpu_set_volt_cap(unsigned int cap)
721 {
722         mutex_lock(&tegra_cpu_lock);
723         if (cap != volt_capped_speed) {
724                 volt_capped_speed = cap;
725                 tegra_cpu_set_speed_cap_locked(NULL);
726         }
727         mutex_unlock(&tegra_cpu_lock);
728         if (cap)
729                 pr_debug("tegra_cpu:volt limit to %u Khz\n", cap);
730         else
731                 pr_debug("tegra_cpu:volt limit removed\n");
732 }
733
734 static unsigned int volt_cap_speed(unsigned int requested_speed)
735 {
736         if (volt_capped_speed && requested_speed > volt_capped_speed)
737                 return volt_capped_speed;
738         return requested_speed;
739 }
740
741 /* Must be called with tegra_cpu_lock held */
742 int tegra_cpu_set_speed_cap_locked(unsigned int *speed_cap)
743 {
744         int ret = 0;
745         unsigned int new_speed = tegra_cpu_highest_speed();
746         BUG_ON(!mutex_is_locked(&tegra_cpu_lock));
747 #ifdef CONFIG_TEGRA_EDP_LIMITS
748         edp_update_limit();
749 #endif
750
751         if (is_suspended)
752                 return -EBUSY;
753
754         new_speed = tegra_throttle_governor_speed(new_speed);
755         new_speed = edp_governor_speed(new_speed);
756         new_speed = user_cap_speed(new_speed);
757         new_speed = volt_cap_speed(new_speed);
758         if (speed_cap)
759                 *speed_cap = new_speed;
760
761         ret = tegra_update_cpu_speed(new_speed);
762         if (ret == 0)
763                 tegra_auto_hotplug_governor(new_speed, false);
764         return ret;
765 }
766
767 int tegra_cpu_set_speed_cap(unsigned int *speed_cap)
768 {
769         int ret;
770         mutex_lock(&tegra_cpu_lock);
771         ret = tegra_cpu_set_speed_cap_locked(speed_cap);
772         mutex_unlock(&tegra_cpu_lock);
773         return ret;
774 }
775
776
777 int tegra_suspended_target(unsigned int target_freq)
778 {
779         unsigned int new_speed = target_freq;
780
781         if (!is_suspended)
782                 return -EBUSY;
783
784         /* apply only "hard" caps */
785         new_speed = tegra_throttle_governor_speed(new_speed);
786         new_speed = edp_governor_speed(new_speed);
787
788         return tegra_update_cpu_speed(new_speed);
789 }
790
791 static int tegra_target(struct cpufreq_policy *policy,
792                        unsigned int target_freq,
793                        unsigned int relation)
794 {
795         int idx;
796         unsigned int freq;
797         unsigned int new_speed;
798         int ret = 0;
799
800         mutex_lock(&tegra_cpu_lock);
801
802         ret = cpufreq_frequency_table_target(policy, freq_table, target_freq,
803                 relation, &idx);
804         if (ret)
805                 goto _out;
806
807         freq = freq_table[idx].frequency;
808
809         target_cpu_speed[policy->cpu] = freq;
810         ret = tegra_cpu_set_speed_cap_locked(&new_speed);
811 _out:
812         mutex_unlock(&tegra_cpu_lock);
813
814         return ret;
815 }
816
817
818 static int tegra_pm_notify(struct notifier_block *nb, unsigned long event,
819         void *dummy)
820 {
821         mutex_lock(&tegra_cpu_lock);
822         if (event == PM_SUSPEND_PREPARE) {
823                 is_suspended = true;
824                 if (cpu_reg_idle_limits)
825                         reg_mode_force_normal = true;
826                 pr_info("Tegra cpufreq suspend: setting frequency to %d kHz\n",
827                         freq_table[suspend_index].frequency);
828                 tegra_update_cpu_speed(freq_table[suspend_index].frequency);
829                 tegra_auto_hotplug_governor(
830                         freq_table[suspend_index].frequency, true);
831         } else if (event == PM_POST_SUSPEND) {
832                 unsigned int freq;
833                 is_suspended = false;
834                 reg_mode_force_normal = false;
835                 tegra_cpu_edp_init(true);
836                 tegra_cpu_set_speed_cap_locked(&freq);
837                 pr_info("Tegra cpufreq resume: restoring frequency to %d kHz\n",
838                         freq);
839         }
840         mutex_unlock(&tegra_cpu_lock);
841
842         return NOTIFY_OK;
843 }
844
845 static struct notifier_block tegra_cpu_pm_notifier = {
846         .notifier_call = tegra_pm_notify,
847 };
848
849 static int tegra_cpu_init(struct cpufreq_policy *policy)
850 {
851         int idx, ret;
852         unsigned int freq;
853
854         if (policy->cpu >= CONFIG_NR_CPUS)
855                 return -EINVAL;
856
857         cpu_clk = clk_get_sys(NULL, "cpu");
858         if (IS_ERR(cpu_clk))
859                 return PTR_ERR(cpu_clk);
860
861         clk_prepare_enable(cpu_clk);
862
863         cpufreq_frequency_table_cpuinfo(policy, freq_table);
864         cpufreq_frequency_table_get_attr(freq_table, policy->cpu);
865
866         /* clip boot frequency to table entry */
867         freq = tegra_getspeed(policy->cpu);
868         ret = cpufreq_frequency_table_target(policy, freq_table, freq,
869                 CPUFREQ_RELATION_H, &idx);
870         if (!ret && (freq != freq_table[idx].frequency)) {
871                 ret = tegra_update_cpu_speed(freq_table[idx].frequency);
872                 if (!ret)
873                         freq = freq_table[idx].frequency;
874         }
875         policy->cur = freq;
876         target_cpu_speed[policy->cpu] = policy->cur;
877
878         /* FIXME: what's the actual transition time? */
879         policy->cpuinfo.transition_latency = 300 * 1000;
880
881         cpumask_copy(policy->cpus, cpu_possible_mask);
882
883         return 0;
884 }
885
886 static int tegra_cpu_exit(struct cpufreq_policy *policy)
887 {
888         cpufreq_frequency_table_cpuinfo(policy, freq_table);
889         clk_put(cpu_clk);
890         return 0;
891 }
892
893 static int tegra_cpufreq_policy_notifier(
894         struct notifier_block *nb, unsigned long event, void *data)
895 {
896 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
897         static int once = 1;
898 #endif
899         int i, ret;
900         struct cpufreq_policy *policy = data;
901
902         if (event == CPUFREQ_NOTIFY) {
903                 ret = cpufreq_frequency_table_target(policy, freq_table,
904                         policy->max, CPUFREQ_RELATION_H, &i);
905                 policy_max_speed[policy->cpu] =
906                         ret ? policy->max : freq_table[i].frequency;
907
908 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
909                 if (once &&
910                     sysfs_merge_group(&policy->kobj, &stats_attr_grp) == 0)
911                         once = 0;
912 #endif
913         }
914         return NOTIFY_OK;
915 }
916
917 static struct notifier_block tegra_cpufreq_policy_nb = {
918         .notifier_call = tegra_cpufreq_policy_notifier,
919 };
920
921 static struct freq_attr *tegra_cpufreq_attr[] = {
922         &cpufreq_freq_attr_scaling_available_freqs,
923 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
924         &throttle,
925 #endif
926         NULL,
927 };
928
929 static struct cpufreq_driver tegra_cpufreq_driver = {
930         .verify         = tegra_verify_speed,
931         .target         = tegra_target,
932         .get            = tegra_getspeed,
933         .init           = tegra_cpu_init,
934         .exit           = tegra_cpu_exit,
935         .name           = "tegra",
936         .attr           = tegra_cpufreq_attr,
937 };
938
939 static int __init tegra_cpufreq_init(void)
940 {
941         int ret = 0;
942
943         struct tegra_cpufreq_table_data *table_data =
944                 tegra_cpufreq_table_get();
945         if (IS_ERR_OR_NULL(table_data))
946                 return -EINVAL;
947
948         suspend_index = table_data->suspend_index;
949
950         ret = tegra_throttle_init(&tegra_cpu_lock);
951         if (ret)
952                 return ret;
953
954         ret = tegra_auto_hotplug_init(&tegra_cpu_lock);
955         if (ret)
956                 return ret;
957
958         freq_table = table_data->freq_table;
959         mutex_lock(&tegra_cpu_lock);
960         tegra_cpu_edp_init(false);
961         mutex_unlock(&tegra_cpu_lock);
962
963         ret = register_pm_notifier(&tegra_cpu_pm_notifier);
964
965         if (ret)
966                 return ret;
967
968         ret = cpufreq_register_notifier(
969                 &tegra_cpufreq_policy_nb, CPUFREQ_POLICY_NOTIFIER);
970
971         if (ret)
972                 return ret;
973
974         return cpufreq_register_driver(&tegra_cpufreq_driver);
975 }
976
977 static void __exit tegra_cpufreq_exit(void)
978 {
979         tegra_throttle_exit();
980         tegra_cpu_edp_exit();
981         tegra_auto_hotplug_exit();
982         cpufreq_unregister_driver(&tegra_cpufreq_driver);
983         cpufreq_unregister_notifier(
984                 &tegra_cpufreq_policy_nb, CPUFREQ_POLICY_NOTIFIER);
985 }
986
987
988 MODULE_AUTHOR("Colin Cross <ccross@android.com>");
989 MODULE_DESCRIPTION("cpufreq driver for Nvidia Tegra2");
990 MODULE_LICENSE("GPL");
991 module_init(tegra_cpufreq_init);
992 module_exit(tegra_cpufreq_exit);