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