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