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