ARM: tegra: cpuquiet: make userspace governor actions synchronous
[linux-3.10.git] / arch / arm / mach-tegra / cpuquiet.c
1 /*
2  * arch/arm/mach-tegra/cpuquiet.c
3  *
4  * Cpuquiet driver for Tegra CPUs
5  *
6  * Copyright (c) 2012 NVIDIA CORPORATION.  All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; version 2 of the License.
11  *
12  * This program is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/types.h>
24 #include <linux/sched.h>
25 #include <linux/module.h>
26 #include <linux/cpufreq.h>
27 #include <linux/delay.h>
28 #include <linux/err.h>
29 #include <linux/io.h>
30 #include <linux/cpu.h>
31 #include <linux/clk.h>
32 #include <linux/debugfs.h>
33 #include <linux/seq_file.h>
34 #include <linux/cpuquiet.h>
35 #include <linux/pm_qos.h>
36 #include <linux/debugfs.h>
37
38 #include "pm.h"
39 #include "cpu-tegra.h"
40 #include "clock.h"
41
42 #define INITIAL_STATE           TEGRA_CPQ_DISABLED
43 #define UP_DELAY_MS             70
44 #define DOWN_DELAY_MS           2000
45 #define HOTPLUG_DELAY_MS        100
46
47 static struct mutex *tegra_cpu_lock;
48 static DEFINE_MUTEX(tegra_cpq_lock_stats);
49
50 static struct workqueue_struct *cpuquiet_wq;
51 static struct work_struct cpuquiet_work;
52 static struct timer_list updown_timer;
53
54 static struct kobject *tegra_auto_sysfs_kobject;
55
56 static wait_queue_head_t wait_no_lp;
57 static wait_queue_head_t wait_enable;
58 static wait_queue_head_t wait_cpu;
59
60 static bool no_lp;
61 static bool enable;
62 static unsigned long up_delay;
63 static unsigned long down_delay;
64 static unsigned long hotplug_timeout;
65 static int mp_overhead = 10;
66 static unsigned int idle_top_freq;
67 static unsigned int idle_bottom_freq;
68
69 static struct clk *cpu_clk;
70 static struct clk *cpu_g_clk;
71 static struct clk *cpu_lp_clk;
72
73 static struct cpumask cr_online_requests;
74 static struct cpumask cr_offline_requests;
75
76 enum {
77         TEGRA_CPQ_DISABLED = 0,
78         TEGRA_CPQ_ENABLED,
79         TEGRA_CPQ_IDLE,
80 };
81
82 enum {
83         TEGRA_CPQ_G = 0,
84         TEGRA_CPQ_LP,
85 };
86
87 static int cpq_target_state;
88 static int cpq_target_cluster_state;
89
90 static int cpq_state;
91
92 static struct {
93         cputime64_t time_up_total;
94         u64 last_update;
95         unsigned int up_down_count;
96 } hp_stats[CONFIG_NR_CPUS + 1]; /* Append LP CPU entry at the end */
97
98 static void hp_init_stats(void)
99 {
100         int i;
101         u64 cur_jiffies = get_jiffies_64();
102
103         mutex_lock(&tegra_cpq_lock_stats);
104
105         for (i = 0; i <= CONFIG_NR_CPUS; i++) {
106                 hp_stats[i].time_up_total = 0;
107                 hp_stats[i].last_update = cur_jiffies;
108
109                 hp_stats[i].up_down_count = 0;
110                 if (is_lp_cluster()) {
111                         if (i == CONFIG_NR_CPUS)
112                                 hp_stats[i].up_down_count = 1;
113                 } else {
114                         if ((i < nr_cpu_ids) && cpu_online(i))
115                                 hp_stats[i].up_down_count = 1;
116                 }
117         }
118
119         mutex_unlock(&tegra_cpq_lock_stats);
120 }
121
122 /* must be called with tegra_cpq_lock_stats held */
123 static void __hp_stats_update(unsigned int cpu, bool up)
124 {
125         u64 cur_jiffies = get_jiffies_64();
126         bool was_up;
127
128         was_up = hp_stats[cpu].up_down_count & 0x1;
129
130         if (was_up)
131                 hp_stats[cpu].time_up_total =
132                         hp_stats[cpu].time_up_total +
133                         (cur_jiffies - hp_stats[cpu].last_update);
134
135         if (was_up != up) {
136                 hp_stats[cpu].up_down_count++;
137                 if ((hp_stats[cpu].up_down_count & 0x1) != up) {
138                         /* FIXME: sysfs user space CPU control breaks stats */
139                         pr_err("tegra hotplug stats out of sync with %s CPU%d",
140                                (cpu < CONFIG_NR_CPUS) ? "G" : "LP",
141                                (cpu < CONFIG_NR_CPUS) ?  cpu : 0);
142                         hp_stats[cpu].up_down_count ^=  0x1;
143                 }
144         }
145         hp_stats[cpu].last_update = cur_jiffies;
146 }
147
148 static void hp_stats_update(unsigned int cpu, bool up)
149 {
150         mutex_lock(&tegra_cpq_lock_stats);
151
152         __hp_stats_update(cpu, up);
153
154         mutex_unlock(&tegra_cpq_lock_stats);
155 }
156
157 static int update_core_config(unsigned int cpunumber, bool up)
158 {
159         int ret = 0;
160         unsigned int nr_cpus = num_online_cpus();
161
162         if (cpq_state == TEGRA_CPQ_DISABLED || cpunumber >= nr_cpu_ids)
163                 return -EINVAL;
164
165         mutex_lock(tegra_cpu_lock);
166
167         if (up) {
168                 cpumask_set_cpu(cpunumber, &cr_online_requests);
169                 cpumask_clear_cpu(cpunumber, &cr_offline_requests);
170                 if (is_lp_cluster())
171                         ret = -EBUSY;
172                 else if (tegra_cpu_edp_favor_up(nr_cpus, mp_overhead))
173                         queue_work(cpuquiet_wq, &cpuquiet_work);
174         } else {
175                 if (is_lp_cluster()) {
176                         ret = -EBUSY;
177                 } else {
178                         cpumask_set_cpu(cpunumber, &cr_offline_requests);
179                         cpumask_clear_cpu(cpunumber, &cr_online_requests);
180                         queue_work(cpuquiet_wq, &cpuquiet_work);
181                 }
182         }
183
184         mutex_unlock(tegra_cpu_lock);
185
186         return ret;
187 }
188
189 static int tegra_quiesence_cpu(unsigned int cpunumber, bool sync)
190 {
191         int err = 0;
192
193         err = update_core_config(cpunumber, false);
194         if (err || !sync)
195                 return err;
196
197         err = wait_event_interruptible_timeout(wait_cpu,
198                                                !cpu_online(cpunumber),
199                                                hotplug_timeout);
200
201         if (err < 0)
202                 return err;
203
204         if (err > 0)
205                 return 0;
206         else
207                 return -ETIMEDOUT;
208 }
209
210 static int tegra_wake_cpu(unsigned int cpunumber, bool sync)
211 {
212         int err = 0;
213
214         err = update_core_config(cpunumber, true);
215         if (err || !sync)
216                 return err;
217
218         err = wait_event_interruptible_timeout(wait_cpu, cpu_online(cpunumber),
219                                                hotplug_timeout);
220
221         if (err < 0)
222                 return err;
223
224         if (err > 0)
225                 return 0;
226         else
227                 return -ETIMEDOUT;
228 }
229
230 static struct cpuquiet_driver tegra_cpuquiet_driver = {
231         .name                   = "tegra",
232         .quiesence_cpu          = tegra_quiesence_cpu,
233         .wake_cpu               = tegra_wake_cpu,
234 };
235
236 static void updown_handler(unsigned long data)
237 {
238         queue_work(cpuquiet_wq, &cpuquiet_work);
239 }
240
241 /* must be called from worker function */
242 static int __apply_cluster_config(int state, int target_state)
243 {
244         int new_state = state;
245
246         if (state == TEGRA_CPQ_LP) {
247                 if (target_state == TEGRA_CPQ_G) {
248                         unsigned long speed;
249                         /* make sure cpu rate is within g-mode range before
250                            switching */
251                         speed = max((unsigned long)tegra_getspeed(0),
252                                         clk_get_min_rate(cpu_g_clk) / 1000);
253                         tegra_update_cpu_speed(speed);
254
255                         if (!tegra_cluster_switch(cpu_clk, cpu_g_clk)) {
256                                 hp_stats_update(CONFIG_NR_CPUS, false);
257                                 hp_stats_update(0, true);
258                                 new_state = TEGRA_CPQ_G;
259                         }
260                 }
261         } else if (target_state == TEGRA_CPQ_LP && !no_lp &&
262                         num_online_cpus() == 1) {
263                 if (!tegra_cluster_switch(cpu_clk, cpu_lp_clk)) {
264                         hp_stats_update(CONFIG_NR_CPUS, true);
265                         hp_stats_update(0, false);
266                         new_state = TEGRA_CPQ_LP;
267                 }
268         }
269
270         wake_up_interruptible(&wait_no_lp);
271
272         return new_state;
273 }
274
275 /* must be called from worker function */
276 static void __cpuinit __apply_core_config(void)
277 {
278         int count = -1;
279         unsigned int cpu;
280         int nr_cpus;
281         struct cpumask online, offline, cpu_online;
282         int max_cpus = pm_qos_request(PM_QOS_MAX_ONLINE_CPUS) ? :
283                                 num_present_cpus();
284         int min_cpus = pm_qos_request(PM_QOS_MIN_ONLINE_CPUS);
285
286         mutex_lock(tegra_cpu_lock);
287
288         online = cr_online_requests;
289         offline = cr_offline_requests;
290
291         mutex_unlock(tegra_cpu_lock);
292
293         /* always keep CPU0 online */
294         cpumask_set_cpu(0, &online);
295         cpu_online = *cpu_online_mask;
296
297         if (max_cpus < min_cpus)
298                 max_cpus = min_cpus;
299
300         nr_cpus = cpumask_weight(&online);
301         if (nr_cpus < min_cpus) {
302                 cpu = 0;
303                 count = min_cpus - nr_cpus;
304                 for (; count > 0; count--) {
305                         cpu = cpumask_next_zero(cpu, &online);
306                         cpumask_set_cpu(cpu, &online);
307                         cpumask_clear_cpu(cpu, &offline);
308                 }
309         } else if (nr_cpus > max_cpus) {
310                 count = nr_cpus - max_cpus;
311                 cpu = 1;
312                 for (; count > 0; count--) {
313                         /* CPU0 should always be online */
314                         cpu = cpumask_next(cpu, &online);
315                         cpumask_set_cpu(cpu, &offline);
316                         cpumask_clear_cpu(cpu, &online);
317                 }
318         }
319
320         cpumask_andnot(&online, &online, &cpu_online);
321         for_each_cpu(cpu, &online) {
322                 cpu_up(cpu);
323                 hp_stats_update(cpu, true);
324         }
325
326         cpumask_and(&offline, &offline, &cpu_online);
327         for_each_cpu(cpu, &offline) {
328                 cpu_down(cpu);
329                 hp_stats_update(cpu, false);
330         }
331 }
332
333 static void __cpuinit tegra_cpuquiet_work_func(struct work_struct *work)
334 {
335         int new_cluster, current_cluster, action;
336
337         mutex_lock(tegra_cpu_lock);
338
339         current_cluster = is_lp_cluster();
340         action = cpq_target_state;
341         new_cluster = cpq_target_cluster_state;
342
343         if (action == TEGRA_CPQ_ENABLED) {
344                 hp_init_stats();
345                 cpuquiet_device_free();
346                 pr_info("Tegra cpuquiet clusterswitch enabled\n");
347                 cpq_state = TEGRA_CPQ_ENABLED;
348                 cpq_target_state = TEGRA_CPQ_IDLE;
349                 cpq_target_cluster_state = is_lp_cluster();
350                 wake_up_interruptible(&wait_enable);
351         }
352
353         if (cpq_state == TEGRA_CPQ_DISABLED) {
354                 mutex_unlock(tegra_cpu_lock);
355                 return;
356         }
357
358         if (action == TEGRA_CPQ_DISABLED) {
359                 mutex_unlock(tegra_cpu_lock);
360                 cpq_state = TEGRA_CPQ_DISABLED;
361                 cpuquiet_device_busy();
362                 pr_info("Tegra cpuquiet clusterswitch disabled\n");
363                 wake_up_interruptible(&wait_enable);
364                 return;
365         }
366
367         if (current_cluster != new_cluster) {
368                 current_cluster = __apply_cluster_config(current_cluster,
369                                         new_cluster);
370
371                 mutex_unlock(tegra_cpu_lock);
372
373                 if (current_cluster == TEGRA_CPQ_LP)
374                         cpuquiet_device_busy();
375                 else
376                         cpuquiet_device_free();
377
378                 tegra_cpu_set_speed_cap(NULL);
379         } else
380                 mutex_unlock(tegra_cpu_lock);
381
382         if (current_cluster == TEGRA_CPQ_G)
383                 __apply_core_config();
384 }
385
386 static int min_cpus_notify(struct notifier_block *nb, unsigned long n, void *p)
387 {
388         mutex_lock(tegra_cpu_lock);
389
390         if (cpq_state == TEGRA_CPQ_DISABLED) {
391                 mutex_unlock(tegra_cpu_lock);
392                 return NOTIFY_OK;
393         }
394
395         if (n > 1)
396                 cpq_target_cluster_state = TEGRA_CPQ_G;
397
398         queue_work(cpuquiet_wq, &cpuquiet_work);
399
400         mutex_unlock(tegra_cpu_lock);
401
402         return NOTIFY_OK;
403 }
404
405 static int max_cpus_notify(struct notifier_block *nb, unsigned long n, void *p)
406 {
407         mutex_lock(tegra_cpu_lock);
408
409         if (cpq_state != TEGRA_CPQ_DISABLED)
410                 queue_work(cpuquiet_wq, &cpuquiet_work);
411
412         mutex_unlock(tegra_cpu_lock);
413
414         return NOTIFY_OK;
415 }
416
417 static int __cpuinit cpu_online_notify(struct notifier_block *nfb,
418                                         unsigned long action, void *hcpu)
419 {
420         switch (action) {
421         case CPU_POST_DEAD:
422                 if (num_online_cpus() == 1 &&
423                     tegra_getspeed(0) <= idle_bottom_freq) {
424                         mutex_lock(tegra_cpu_lock);
425
426                         cpq_target_cluster_state = TEGRA_CPQ_LP;
427                         mod_timer(&updown_timer, jiffies + down_delay);
428
429                         mutex_unlock(tegra_cpu_lock);
430                 }
431                 wake_up_interruptible(&wait_cpu);
432                 break;
433         case CPU_ONLINE:
434         case CPU_ONLINE_FROZEN:
435                 if (cpq_target_cluster_state == TEGRA_CPQ_LP) {
436                         mutex_lock(tegra_cpu_lock);
437
438                         if (cpq_target_cluster_state == TEGRA_CPQ_LP) {
439                                 cpq_target_cluster_state = TEGRA_CPQ_G;
440                                 del_timer(&updown_timer);
441                         }
442
443                         mutex_unlock(tegra_cpu_lock);
444                 }
445                 wake_up_interruptible(&wait_cpu);
446                 break;
447         }
448
449         return NOTIFY_OK;
450 }
451
452 /* must be called with tegra_cpu_lock held */
453 void tegra_auto_hotplug_governor(unsigned int cpu_freq, bool suspend)
454 {
455         if (!is_g_cluster_present() || no_lp)
456                 return;
457
458         if (cpq_state == TEGRA_CPQ_DISABLED)
459                 return;
460
461         if (suspend) {
462                 /* Switch to fast cluster if suspend rate is high enough */
463                 if (cpu_freq >= idle_bottom_freq) {
464
465                         /* Force switch now */
466                         cpq_target_cluster_state = TEGRA_CPQ_G;
467                         queue_work(cpuquiet_wq, &cpuquiet_work);
468                 }
469                 return;
470         }
471
472         /*
473          * If there is more then 1 CPU online, we must be on the fast cluster
474          * and we can't switch.
475          */
476         if (num_online_cpus() > 1)
477                 return;
478
479         if (is_lp_cluster()) {
480                 if (cpu_freq >= idle_top_freq &&
481                         cpq_target_cluster_state != TEGRA_CPQ_G) {
482
483                         /* Switch to fast cluster after up_delay */
484                         cpq_target_cluster_state = TEGRA_CPQ_G;
485                         mod_timer(&updown_timer, jiffies + up_delay);
486                 } else if (cpu_freq < idle_top_freq &&
487                                 cpq_target_cluster_state == TEGRA_CPQ_G) {
488
489                         /*
490                          * CPU frequency dropped below idle_top_freq while
491                          * waiting for up_delay, Cancel switch request.
492                          */
493                         cpq_target_cluster_state = TEGRA_CPQ_LP;
494                         del_timer(&updown_timer);
495                 }
496         } else {
497                 if (cpu_freq <= idle_bottom_freq &&
498                         cpq_target_cluster_state != TEGRA_CPQ_LP) {
499
500                         /* Switch to slow cluster after down_delay */
501                         cpq_target_cluster_state = TEGRA_CPQ_LP;
502                         mod_timer(&updown_timer, jiffies + down_delay);
503                 } else if (cpu_freq > idle_bottom_freq &&
504                         cpq_target_cluster_state == TEGRA_CPQ_LP) {
505
506                         /*
507                          * CPU frequency raised again above idle_bottom_freq.
508                          * Stay on the fast cluster.
509                          */
510                         cpq_target_cluster_state = TEGRA_CPQ_G;
511                         del_timer(&updown_timer);
512                 }
513         }
514 }
515
516 static struct notifier_block min_cpus_notifier = {
517         .notifier_call = min_cpus_notify,
518 };
519
520 static struct notifier_block max_cpus_notifier = {
521         .notifier_call = max_cpus_notify,
522 };
523
524 static struct notifier_block __cpuinitdata cpu_online_notifier = {
525         .notifier_call = cpu_online_notify,
526 };
527
528 static void delay_callback(struct cpuquiet_attribute *attr)
529 {
530         unsigned long val;
531
532         if (attr) {
533                 val = (*((unsigned long *)(attr->param)));
534                 (*((unsigned long *)(attr->param))) = msecs_to_jiffies(val);
535         }
536 }
537
538 static void enable_callback(struct cpuquiet_attribute *attr)
539 {
540         int target_state = enable ? TEGRA_CPQ_ENABLED : TEGRA_CPQ_DISABLED;
541
542         mutex_lock(tegra_cpu_lock);
543
544         if (cpq_state != target_state) {
545                 cpq_target_state = target_state;
546                 queue_work(cpuquiet_wq, &cpuquiet_work);
547         }
548
549         mutex_unlock(tegra_cpu_lock);
550
551         wait_event_interruptible(wait_enable, cpq_state == target_state);
552 }
553
554 static void no_lp_callback(struct cpuquiet_attribute *attr)
555 {
556         mutex_lock(tegra_cpu_lock);
557
558         if (no_lp && is_lp_cluster()) {
559                 /* Force switch */
560                 cpq_target_cluster_state = TEGRA_CPQ_G;
561                 queue_work(cpuquiet_wq, &cpuquiet_work);
562         }
563
564         mutex_unlock(tegra_cpu_lock);
565
566         wait_event_interruptible(wait_no_lp, no_lp ? !is_lp_cluster() : 1);
567 }
568
569 CPQ_BASIC_ATTRIBUTE(idle_top_freq, 0644, uint);
570 CPQ_BASIC_ATTRIBUTE(idle_bottom_freq, 0644, uint);
571 CPQ_BASIC_ATTRIBUTE(mp_overhead, 0644, int);
572 CPQ_ATTRIBUTE(no_lp, 0644, bool, no_lp_callback);
573 CPQ_ATTRIBUTE(up_delay, 0644, ulong, delay_callback);
574 CPQ_ATTRIBUTE(down_delay, 0644, ulong, delay_callback);
575 CPQ_ATTRIBUTE(hotplug_timeout, 0644, ulong, delay_callback);
576 CPQ_ATTRIBUTE(enable, 0644, bool, enable_callback);
577
578 static struct attribute *tegra_auto_attributes[] = {
579         &no_lp_attr.attr,
580         &up_delay_attr.attr,
581         &down_delay_attr.attr,
582         &idle_top_freq_attr.attr,
583         &idle_bottom_freq_attr.attr,
584         &mp_overhead_attr.attr,
585         &enable_attr.attr,
586         &hotplug_timeout_attr.attr,
587         NULL,
588 };
589
590 static const struct sysfs_ops tegra_auto_sysfs_ops = {
591         .show = cpuquiet_auto_sysfs_show,
592         .store = cpuquiet_auto_sysfs_store,
593 };
594
595 static struct kobj_type ktype_sysfs = {
596         .sysfs_ops = &tegra_auto_sysfs_ops,
597         .default_attrs = tegra_auto_attributes,
598 };
599
600 static int tegra_auto_sysfs(void)
601 {
602         int err;
603
604         tegra_auto_sysfs_kobject = kzalloc(sizeof(*tegra_auto_sysfs_kobject),
605                                         GFP_KERNEL);
606
607         if (!tegra_auto_sysfs_kobject)
608                 return -ENOMEM;
609
610         err = cpuquiet_kobject_init(tegra_auto_sysfs_kobject, &ktype_sysfs,
611                                 "tegra_cpuquiet");
612
613         if (err)
614                 kfree(tegra_auto_sysfs_kobject);
615
616         return err;
617 }
618
619 #ifdef CONFIG_DEBUG_FS
620
621 static struct dentry *hp_debugfs_root;
622
623 static int hp_stats_show(struct seq_file *s, void *data)
624 {
625         int i;
626         u64 cur_jiffies = get_jiffies_64();
627
628         mutex_lock(tegra_cpu_lock);
629
630         mutex_lock(&tegra_cpq_lock_stats);
631
632         if (cpq_state != TEGRA_CPQ_DISABLED) {
633                 for (i = 0; i <= CONFIG_NR_CPUS; i++) {
634                         bool was_up = (hp_stats[i].up_down_count & 0x1);
635                         __hp_stats_update(i, was_up);
636                 }
637         }
638         mutex_unlock(&tegra_cpq_lock_stats);
639
640         mutex_unlock(tegra_cpu_lock);
641
642         seq_printf(s, "%-15s ", "cpu:");
643         for (i = 0; i < CONFIG_NR_CPUS; i++)
644                 seq_printf(s, "G%-9d ", i);
645         seq_printf(s, "LP\n");
646
647         seq_printf(s, "%-15s ", "transitions:");
648         for (i = 0; i <= CONFIG_NR_CPUS; i++)
649                 seq_printf(s, "%-10u ", hp_stats[i].up_down_count);
650         seq_printf(s, "\n");
651
652         seq_printf(s, "%-15s ", "time plugged:");
653         for (i = 0; i <= CONFIG_NR_CPUS; i++) {
654                 seq_printf(s, "%-10llu ",
655                            cputime64_to_clock_t(hp_stats[i].time_up_total));
656         }
657         seq_printf(s, "\n");
658
659         seq_printf(s, "%-15s %llu\n", "time-stamp:",
660                    cputime64_to_clock_t(cur_jiffies));
661
662         return 0;
663 }
664
665
666 static int hp_stats_open(struct inode *inode, struct file *file)
667 {
668         return single_open(file, hp_stats_show, inode->i_private);
669 }
670
671
672 static const struct file_operations hp_stats_fops = {
673         .open           = hp_stats_open,
674         .read           = seq_read,
675         .llseek         = seq_lseek,
676         .release        = single_release,
677 };
678
679
680 static int __init tegra_cpuquiet_debug_init(void)
681 {
682
683         hp_debugfs_root = debugfs_create_dir("tegra_hotplug", NULL);
684         if (!hp_debugfs_root)
685                 return -ENOMEM;
686
687         if (!debugfs_create_file(
688                 "stats", S_IRUGO, hp_debugfs_root, NULL, &hp_stats_fops))
689                 goto err_out;
690
691         return 0;
692
693 err_out:
694         debugfs_remove_recursive(hp_debugfs_root);
695         return -ENOMEM;
696 }
697
698 late_initcall(tegra_cpuquiet_debug_init);
699
700 #endif /* CONFIG_DEBUG_FS */
701
702
703 int __cpuinit tegra_auto_hotplug_init(struct mutex *cpulock)
704 {
705         int err;
706
707         cpu_clk = clk_get_sys(NULL, "cpu");
708         cpu_g_clk = clk_get_sys(NULL, "cpu_g");
709         cpu_lp_clk = clk_get_sys(NULL, "cpu_lp");
710
711         if (IS_ERR(cpu_clk) || IS_ERR(cpu_g_clk) || IS_ERR(cpu_lp_clk))
712                 return -ENOENT;
713
714         tegra_cpu_lock = cpulock;
715
716         init_waitqueue_head(&wait_no_lp);
717         init_waitqueue_head(&wait_enable);
718         init_waitqueue_head(&wait_cpu);
719
720         /*
721          * Not bound to the issuer CPU (=> high-priority), has rescue worker
722          * task, single-threaded, freezable.
723          */
724         cpuquiet_wq = alloc_workqueue(
725                 "cpuquiet", WQ_NON_REENTRANT | WQ_RESCUER | WQ_FREEZABLE, 1);
726
727         if (!cpuquiet_wq)
728                 return -ENOMEM;
729
730         INIT_WORK(&cpuquiet_work, tegra_cpuquiet_work_func);
731         init_timer(&updown_timer);
732         updown_timer.function = updown_handler;
733
734         idle_top_freq = clk_get_max_rate(cpu_lp_clk) / 1000;
735         idle_bottom_freq = clk_get_min_rate(cpu_g_clk) / 1000;
736
737         up_delay = msecs_to_jiffies(UP_DELAY_MS);
738         down_delay = msecs_to_jiffies(DOWN_DELAY_MS);
739         hotplug_timeout = msecs_to_jiffies(HOTPLUG_DELAY_MS);
740         cpumask_clear(&cr_online_requests);
741         cpumask_clear(&cr_offline_requests);
742
743         cpq_target_cluster_state = is_lp_cluster();
744         cpq_state = INITIAL_STATE;
745         enable = cpq_state == TEGRA_CPQ_DISABLED ? false : true;
746         hp_init_stats();
747
748         pr_info("Tegra cpuquiet initialized: %s\n",
749                 (cpq_state == TEGRA_CPQ_DISABLED) ? "disabled" : "enabled");
750
751         if (pm_qos_add_notifier(PM_QOS_MIN_ONLINE_CPUS, &min_cpus_notifier))
752                 pr_err("%s: Failed to register min cpus PM QoS notifier\n",
753                         __func__);
754         if (pm_qos_add_notifier(PM_QOS_MAX_ONLINE_CPUS, &max_cpus_notifier))
755                 pr_err("%s: Failed to register max cpus PM QoS notifier\n",
756                         __func__);
757
758         register_hotcpu_notifier(&cpu_online_notifier);
759
760         err = cpuquiet_register_driver(&tegra_cpuquiet_driver);
761         if (err) {
762                 destroy_workqueue(cpuquiet_wq);
763                 return err;
764         }
765
766         err = tegra_auto_sysfs();
767         if (err) {
768                 cpuquiet_unregister_driver(&tegra_cpuquiet_driver);
769                 destroy_workqueue(cpuquiet_wq);
770         }
771
772         return err;
773 }
774
775 void tegra_auto_hotplug_exit(void)
776 {
777         destroy_workqueue(cpuquiet_wq);
778         cpuquiet_unregister_driver(&tegra_cpuquiet_driver);
779         kobject_put(tegra_auto_sysfs_kobject);
780
781 #ifdef CONFIG_DEBUG_FS
782         debugfs_remove_recursive(hp_debugfs_root);
783 #endif
784 }