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