ed550655d5a6f77b6fbd66e93fbd09f6a324f6a8
[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 struct thermal_cooling_device *edp_cooling_device_create(void *v)
279 {
280         return thermal_cooling_device_register(
281                                 "edp",
282                                 NULL,
283                                 &tegra_edp_cooling_ops);
284 }
285
286 int tegra_system_edp_alarm(bool alarm)
287 {
288         int ret = -ENODEV;
289
290         mutex_lock(&tegra_cpu_lock);
291         system_edp_alarm = alarm;
292
293         /* Update cpu rate if cpufreq (at least on cpu0) is already started
294            and cancel emergency throttling after either edp limit is applied
295            or alarm is canceled */
296         if (target_cpu_speed[0]) {
297                 edp_update_limit();
298                 ret = tegra_cpu_set_speed_cap(NULL);
299         }
300         if (!ret || !alarm)
301                 tegra_edp_throttle_cpu_now(0);
302
303         mutex_unlock(&tegra_cpu_lock);
304
305         return ret;
306 }
307
308 bool tegra_cpu_edp_favor_up(unsigned int n, int mp_overhead)
309 {
310         unsigned int current_limit, next_limit;
311
312         if (n == 0)
313                 return true;
314
315         if (n >= ARRAY_SIZE(cpu_edp_limits->freq_limits))
316                 return false;
317
318         current_limit = edp_predict_limit(n);
319         next_limit = edp_predict_limit(n + 1);
320
321         return ((next_limit * (n + 1)) >=
322                 (current_limit * n * (100 + mp_overhead) / 100));
323 }
324
325 bool tegra_cpu_edp_favor_down(unsigned int n, int mp_overhead)
326 {
327         unsigned int current_limit, next_limit;
328
329         if (n <= 1)
330                 return false;
331
332         if (n > ARRAY_SIZE(cpu_edp_limits->freq_limits))
333                 return true;
334
335         current_limit = edp_predict_limit(n);
336         next_limit = edp_predict_limit(n - 1);
337
338         return ((next_limit * (n - 1) * (100 + mp_overhead) / 100)) >
339                 (current_limit * n);
340 }
341
342 static int tegra_cpu_edp_notify(
343         struct notifier_block *nb, unsigned long event, void *hcpu)
344 {
345         int ret = 0;
346         unsigned int cpu_speed, new_speed;
347         int cpu = (long)hcpu;
348
349         switch (event) {
350         case CPU_UP_PREPARE:
351                 mutex_lock(&tegra_cpu_lock);
352                 cpu_set(cpu, edp_cpumask);
353                 edp_update_limit();
354
355                 cpu_speed = tegra_getspeed(0);
356                 new_speed = edp_governor_speed(cpu_speed);
357                 if (new_speed < cpu_speed) {
358                         ret = tegra_cpu_set_speed_cap(NULL);
359                         printk(KERN_DEBUG "cpu-tegra:%sforce EDP limit %u kHz"
360                                 "\n", ret ? " failed to " : " ", new_speed);
361                 }
362                 if (!ret)
363                         ret = tegra_cpu_dvfs_alter(
364                                 edp_thermal_index, &edp_cpumask, false, event);
365                 if (ret) {
366                         cpu_clear(cpu, edp_cpumask);
367                         edp_update_limit();
368                 }
369                 mutex_unlock(&tegra_cpu_lock);
370                 break;
371         case CPU_DEAD:
372                 mutex_lock(&tegra_cpu_lock);
373                 cpu_clear(cpu, edp_cpumask);
374                 tegra_cpu_dvfs_alter(
375                         edp_thermal_index, &edp_cpumask, true, event);
376                 edp_update_limit();
377                 tegra_cpu_set_speed_cap(NULL);
378                 mutex_unlock(&tegra_cpu_lock);
379                 break;
380         }
381         return notifier_from_errno(ret);
382 }
383
384 static struct notifier_block tegra_cpu_edp_notifier = {
385         .notifier_call = tegra_cpu_edp_notify,
386 };
387
388 static void tegra_cpu_edp_init(bool resume)
389 {
390         tegra_get_system_edp_limits(&system_edp_limits);
391         tegra_get_cpu_edp_limits(&cpu_edp_limits, &cpu_edp_limits_size);
392
393         if (!(cpu_edp_limits || system_edp_limits)) {
394                 if (!resume)
395                         pr_info("cpu-tegra: no EDP table is provided\n");
396                 return;
397         }
398
399         /* FIXME: use the highest temperature limits if sensor is not on-line?
400          * If thermal zone is not set yet by the sensor, edp_thermal_index = 0.
401          * Boot frequency allowed SoC to get here, should work till sensor is
402          * initialized.
403          */
404         edp_cpumask = *cpu_online_mask;
405         edp_update_limit();
406
407         if (!resume) {
408                 register_hotcpu_notifier(&tegra_cpu_edp_notifier);
409                 pr_info("cpu-tegra: init EDP limit: %u MHz\n", edp_limit/1000);
410         }
411 }
412
413 static void tegra_cpu_edp_exit(void)
414 {
415         if (!(cpu_edp_limits || system_edp_limits))
416                 return;
417
418         unregister_hotcpu_notifier(&tegra_cpu_edp_notifier);
419 }
420
421 #ifdef CONFIG_DEBUG_FS
422
423 static int system_edp_alarm_get(void *data, u64 *val)
424 {
425         *val = (u64)system_edp_alarm;
426         return 0;
427 }
428 static int system_edp_alarm_set(void *data, u64 val)
429 {
430         if (val > 1) {  /* emulate emergency throttling */
431                 tegra_edp_throttle_cpu_now(val);
432                 return 0;
433         }
434         return tegra_system_edp_alarm((bool)val);
435 }
436 DEFINE_SIMPLE_ATTRIBUTE(system_edp_alarm_fops,
437                         system_edp_alarm_get, system_edp_alarm_set, "%llu\n");
438
439 static int __init tegra_edp_debug_init(struct dentry *cpu_tegra_debugfs_root)
440 {
441         if (!debugfs_create_file("edp_alarm", 0644, cpu_tegra_debugfs_root,
442                                  NULL, &system_edp_alarm_fops))
443                 return -ENOMEM;
444
445         return 0;
446 }
447 #endif
448
449 #else   /* CONFIG_TEGRA_EDP_LIMITS */
450 #define edp_governor_speed(requested_speed) (requested_speed)
451 #define tegra_cpu_edp_init(resume)
452 #define tegra_cpu_edp_exit()
453 #define tegra_edp_debug_init(cpu_tegra_debugfs_root) (0)
454 #endif  /* CONFIG_TEGRA_EDP_LIMITS */
455
456 #ifdef CONFIG_DEBUG_FS
457
458 static struct dentry *cpu_tegra_debugfs_root;
459
460 static int __init tegra_cpu_debug_init(void)
461 {
462         cpu_tegra_debugfs_root = debugfs_create_dir("cpu-tegra", 0);
463
464         if (!cpu_tegra_debugfs_root)
465                 return -ENOMEM;
466
467         if (tegra_edp_debug_init(cpu_tegra_debugfs_root))
468                 goto err_out;
469
470         return 0;
471
472 err_out:
473         debugfs_remove_recursive(cpu_tegra_debugfs_root);
474         return -ENOMEM;
475 }
476
477 static void __exit tegra_cpu_debug_exit(void)
478 {
479         debugfs_remove_recursive(cpu_tegra_debugfs_root);
480 }
481
482 late_initcall(tegra_cpu_debug_init);
483 module_exit(tegra_cpu_debug_exit);
484 #endif /* CONFIG_DEBUG_FS */
485
486 static int tegra_verify_speed(struct cpufreq_policy *policy)
487 {
488         return cpufreq_frequency_table_verify(policy, freq_table);
489 }
490
491 unsigned int tegra_getspeed(unsigned int cpu)
492 {
493         unsigned long rate;
494
495         if (cpu >= CONFIG_NR_CPUS)
496                 return 0;
497
498         rate = clk_get_rate(cpu_clk) / 1000;
499         return rate;
500 }
501
502 int tegra_update_cpu_speed(unsigned long rate)
503 {
504         int ret = 0;
505         struct cpufreq_freqs freqs;
506
507         freqs.old = tegra_getspeed(0);
508         freqs.new = rate;
509
510         rate = clk_round_rate(cpu_clk, rate * 1000);
511         if (!IS_ERR_VALUE(rate))
512                 freqs.new = rate / 1000;
513
514         if (freqs.old == freqs.new)
515                 return ret;
516
517         /*
518          * Vote on memory bus frequency based on cpu frequency
519          * This sets the minimum frequency, display or avp may request higher
520          */
521         if (freqs.old < freqs.new) {
522                 ret = tegra_update_mselect_rate(freqs.new);
523                 if (ret) {
524                         pr_err("cpu-tegra: Failed to scale mselect for cpu"
525                                " frequency %u kHz\n", freqs.new);
526                         return ret;
527                 }
528                 ret = clk_set_rate(emc_clk, tegra_emc_to_cpu_ratio(freqs.new));
529                 if (ret) {
530                         pr_err("cpu-tegra: Failed to scale emc for cpu"
531                                " frequency %u kHz\n", freqs.new);
532                         return ret;
533                 }
534         }
535
536         for_each_online_cpu(freqs.cpu)
537                 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
538
539 #ifdef CONFIG_CPU_FREQ_DEBUG
540         printk(KERN_DEBUG "cpufreq-tegra: transition: %u --> %u\n",
541                freqs.old, freqs.new);
542 #endif
543
544         ret = clk_set_rate(cpu_clk, freqs.new * 1000);
545         if (ret) {
546                 pr_err("cpu-tegra: Failed to set cpu frequency to %d kHz\n",
547                         freqs.new);
548                 return ret;
549         }
550
551         for_each_online_cpu(freqs.cpu)
552                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
553
554         if (freqs.old > freqs.new) {
555                 clk_set_rate(emc_clk, tegra_emc_to_cpu_ratio(freqs.new));
556                 tegra_update_mselect_rate(freqs.new);
557         }
558
559         return 0;
560 }
561
562 unsigned int tegra_count_slow_cpus(unsigned long speed_limit)
563 {
564         unsigned int cnt = 0;
565         int i;
566
567         for_each_online_cpu(i)
568                 if (target_cpu_speed[i] <= speed_limit)
569                         cnt++;
570         return cnt;
571 }
572
573 unsigned int tegra_get_slowest_cpu_n(void) {
574         unsigned int cpu = nr_cpu_ids;
575         unsigned long rate = ULONG_MAX;
576         int i;
577
578         for_each_online_cpu(i)
579                 if ((i > 0) && (rate > target_cpu_speed[i])) {
580                         cpu = i;
581                         rate = target_cpu_speed[i];
582                 }
583         return cpu;
584 }
585
586 unsigned long tegra_cpu_lowest_speed(void) {
587         unsigned long rate = ULONG_MAX;
588         int i;
589
590         for_each_online_cpu(i)
591                 rate = min(rate, target_cpu_speed[i]);
592         return rate;
593 }
594
595 unsigned long tegra_cpu_highest_speed(void) {
596         unsigned long policy_max = ULONG_MAX;
597         unsigned long rate = 0;
598         int i;
599
600         for_each_online_cpu(i) {
601                 if (force_policy_max)
602                         policy_max = min(policy_max, policy_max_speed[i]);
603                 rate = max(rate, target_cpu_speed[i]);
604         }
605         rate = min(rate, policy_max);
606         return rate;
607 }
608
609 int tegra_cpu_set_speed_cap(unsigned int *speed_cap)
610 {
611         int ret = 0;
612         unsigned int new_speed = tegra_cpu_highest_speed();
613
614 #ifdef CONFIG_TEGRA_EDP_LIMITS
615         edp_update_limit();
616 #endif
617
618         if (is_suspended)
619                 return -EBUSY;
620
621         new_speed = tegra_throttle_governor_speed(new_speed);
622         new_speed = edp_governor_speed(new_speed);
623         new_speed = user_cap_speed(new_speed);
624         if (speed_cap)
625                 *speed_cap = new_speed;
626
627         ret = tegra_update_cpu_speed(new_speed);
628         if (ret == 0)
629                 tegra_auto_hotplug_governor(new_speed, false);
630         return ret;
631 }
632
633 int tegra_suspended_target(unsigned int target_freq)
634 {
635         unsigned int new_speed = target_freq;
636
637         if (!is_suspended)
638                 return -EBUSY;
639
640         /* apply only "hard" caps */
641         new_speed = tegra_throttle_governor_speed(new_speed);
642         new_speed = edp_governor_speed(new_speed);
643
644         return tegra_update_cpu_speed(new_speed);
645 }
646
647 static int tegra_target(struct cpufreq_policy *policy,
648                        unsigned int target_freq,
649                        unsigned int relation)
650 {
651         int idx;
652         unsigned int freq;
653         unsigned int new_speed;
654         int ret = 0;
655
656         mutex_lock(&tegra_cpu_lock);
657
658         ret = cpufreq_frequency_table_target(policy, freq_table, target_freq,
659                 relation, &idx);
660         if (ret)
661                 goto _out;
662
663         freq = freq_table[idx].frequency;
664
665         target_cpu_speed[policy->cpu] = freq;
666         ret = tegra_cpu_set_speed_cap(&new_speed);
667 _out:
668         mutex_unlock(&tegra_cpu_lock);
669
670         return ret;
671 }
672
673
674 static int tegra_pm_notify(struct notifier_block *nb, unsigned long event,
675         void *dummy)
676 {
677         mutex_lock(&tegra_cpu_lock);
678         if (event == PM_SUSPEND_PREPARE) {
679                 is_suspended = true;
680                 pr_info("Tegra cpufreq suspend: setting frequency to %d kHz\n",
681                         freq_table[suspend_index].frequency);
682                 tegra_update_cpu_speed(freq_table[suspend_index].frequency);
683                 tegra_auto_hotplug_governor(
684                         freq_table[suspend_index].frequency, true);
685         } else if (event == PM_POST_SUSPEND) {
686                 unsigned int freq;
687                 is_suspended = false;
688                 tegra_cpu_edp_init(true);
689                 tegra_cpu_set_speed_cap(&freq);
690                 pr_info("Tegra cpufreq resume: restoring frequency to %d kHz\n",
691                         freq);
692         }
693         mutex_unlock(&tegra_cpu_lock);
694
695         return NOTIFY_OK;
696 }
697
698 static struct notifier_block tegra_cpu_pm_notifier = {
699         .notifier_call = tegra_pm_notify,
700 };
701
702 static int tegra_cpu_init(struct cpufreq_policy *policy)
703 {
704         int idx, ret;
705         unsigned int freq;
706
707         if (policy->cpu >= CONFIG_NR_CPUS)
708                 return -EINVAL;
709
710         cpu_clk = clk_get_sys(NULL, "cpu");
711         if (IS_ERR(cpu_clk))
712                 return PTR_ERR(cpu_clk);
713
714         emc_clk = clk_get_sys("cpu", "emc");
715         if (IS_ERR(emc_clk)) {
716                 clk_put(cpu_clk);
717                 return PTR_ERR(emc_clk);
718         }
719
720         clk_prepare_enable(emc_clk);
721         clk_prepare_enable(cpu_clk);
722
723         cpufreq_frequency_table_cpuinfo(policy, freq_table);
724         cpufreq_frequency_table_get_attr(freq_table, policy->cpu);
725
726         /* clip boot frequency to table entry */
727         freq = tegra_getspeed(policy->cpu);
728         ret = cpufreq_frequency_table_target(policy, freq_table, freq,
729                 CPUFREQ_RELATION_H, &idx);
730         if (!ret && (freq != freq_table[idx].frequency)) {
731                 ret = tegra_update_cpu_speed(freq_table[idx].frequency);
732                 if (!ret)
733                         freq = freq_table[idx].frequency;
734         }
735         policy->cur = freq;
736         target_cpu_speed[policy->cpu] = policy->cur;
737
738         /* FIXME: what's the actual transition time? */
739         policy->cpuinfo.transition_latency = 300 * 1000;
740
741         cpumask_copy(policy->cpus, cpu_possible_mask);
742
743         return 0;
744 }
745
746 static int tegra_cpu_exit(struct cpufreq_policy *policy)
747 {
748         cpufreq_frequency_table_cpuinfo(policy, freq_table);
749         clk_disable_unprepare(emc_clk);
750         clk_put(emc_clk);
751         clk_put(cpu_clk);
752         return 0;
753 }
754
755 static int tegra_cpufreq_policy_notifier(
756         struct notifier_block *nb, unsigned long event, void *data)
757 {
758 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
759         static int once = 1;
760 #endif
761         int i, ret;
762         struct cpufreq_policy *policy = data;
763
764         if (event == CPUFREQ_NOTIFY) {
765                 ret = cpufreq_frequency_table_target(policy, freq_table,
766                         policy->max, CPUFREQ_RELATION_H, &i);
767                 policy_max_speed[policy->cpu] =
768                         ret ? policy->max : freq_table[i].frequency;
769
770 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
771                 if (once &&
772                     sysfs_merge_group(&policy->kobj, &stats_attr_grp) == 0)
773                         once = 0;
774 #endif
775         }
776         return NOTIFY_OK;
777 }
778
779 static struct notifier_block tegra_cpufreq_policy_nb = {
780         .notifier_call = tegra_cpufreq_policy_notifier,
781 };
782
783 static struct freq_attr *tegra_cpufreq_attr[] = {
784         &cpufreq_freq_attr_scaling_available_freqs,
785 #ifdef CONFIG_TEGRA_THERMAL_THROTTLE
786         &throttle,
787 #endif
788         NULL,
789 };
790
791 static struct cpufreq_driver tegra_cpufreq_driver = {
792         .verify         = tegra_verify_speed,
793         .target         = tegra_target,
794         .get            = tegra_getspeed,
795         .init           = tegra_cpu_init,
796         .exit           = tegra_cpu_exit,
797         .name           = "tegra",
798         .attr           = tegra_cpufreq_attr,
799 };
800
801 static int __init tegra_cpufreq_init(void)
802 {
803         int ret = 0;
804
805         struct tegra_cpufreq_table_data *table_data =
806                 tegra_cpufreq_table_get();
807         if (IS_ERR_OR_NULL(table_data))
808                 return -EINVAL;
809
810         suspend_index = table_data->suspend_index;
811
812         ret = tegra_throttle_init(&tegra_cpu_lock);
813         if (ret)
814                 return ret;
815
816         ret = tegra_auto_hotplug_init(&tegra_cpu_lock);
817         if (ret)
818                 return ret;
819
820         freq_table = table_data->freq_table;
821         tegra_cpu_edp_init(false);
822
823         ret = register_pm_notifier(&tegra_cpu_pm_notifier);
824
825         if (ret)
826                 return ret;
827
828         ret = cpufreq_register_notifier(
829                 &tegra_cpufreq_policy_nb, CPUFREQ_POLICY_NOTIFIER);
830
831         if (ret)
832                 return ret;
833
834         return cpufreq_register_driver(&tegra_cpufreq_driver);
835 }
836
837 static void __exit tegra_cpufreq_exit(void)
838 {
839         tegra_throttle_exit();
840         tegra_cpu_edp_exit();
841         tegra_auto_hotplug_exit();
842         cpufreq_unregister_driver(&tegra_cpufreq_driver);
843         cpufreq_unregister_notifier(
844                 &tegra_cpufreq_policy_nb, CPUFREQ_POLICY_NOTIFIER);
845 }
846
847
848 MODULE_AUTHOR("Colin Cross <ccross@android.com>");
849 MODULE_DESCRIPTION("cpufreq driver for Nvidia Tegra2");
850 MODULE_LICENSE("GPL");
851 module_init(tegra_cpufreq_init);
852 module_exit(tegra_cpufreq_exit);