ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[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-2013 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 /*
61  * no_lp can be used to set what cluster cpuquiet uses
62  *  - no_lp = 1: only G cluster
63  *  - no_lp = 0: dynamically choose between both clusters (cpufreq based)
64  *  - no_lp = -1: only LP cluster
65  * Settings will be enforced directly upon write to no_lp
66  */
67 static int no_lp;
68 static bool enable;
69 static unsigned long up_delay;
70 static unsigned long down_delay;
71 static unsigned long hotplug_timeout;
72 static unsigned int idle_top_freq;
73 static unsigned int idle_bottom_freq;
74
75 static struct clk *cpu_clk;
76 static struct clk *cpu_g_clk;
77 static struct clk *cpu_lp_clk;
78
79 static struct cpumask cr_online_requests;
80 static struct cpumask cr_offline_requests;
81
82 enum {
83         TEGRA_CPQ_DISABLED = 0,
84         TEGRA_CPQ_ENABLED,
85         TEGRA_CPQ_IDLE,
86 };
87
88 enum {
89         TEGRA_CPQ_G = 0,
90         TEGRA_CPQ_LP,
91 };
92
93 static int cpq_target_state;
94 static int cpq_target_cluster_state;
95
96 static int cpq_state;
97
98 static struct {
99         cputime64_t time_up_total;
100         u64 last_update;
101         unsigned int up_down_count;
102 } hp_stats[CONFIG_NR_CPUS + 1]; /* Append LP CPU entry at the end */
103
104 static void hp_init_stats(void)
105 {
106         int i;
107         u64 cur_jiffies = get_jiffies_64();
108
109         mutex_lock(&tegra_cpq_lock_stats);
110
111         for (i = 0; i <= nr_cpu_ids; i++) {
112                 hp_stats[i].time_up_total = 0;
113                 hp_stats[i].last_update = cur_jiffies;
114
115                 hp_stats[i].up_down_count = 0;
116                 if (is_lp_cluster()) {
117                         if (i == nr_cpu_ids)
118                                 hp_stats[i].up_down_count = 1;
119                 } else {
120                         if ((i < nr_cpu_ids) && cpu_online(i))
121                                 hp_stats[i].up_down_count = 1;
122                 }
123         }
124
125         mutex_unlock(&tegra_cpq_lock_stats);
126 }
127
128 /* must be called with tegra_cpq_lock_stats held */
129 static void __hp_stats_update(unsigned int cpu, bool up)
130 {
131         u64 cur_jiffies = get_jiffies_64();
132         bool was_up;
133
134         was_up = hp_stats[cpu].up_down_count & 0x1;
135
136         if (was_up)
137                 hp_stats[cpu].time_up_total =
138                         hp_stats[cpu].time_up_total +
139                         (cur_jiffies - hp_stats[cpu].last_update);
140
141         if (was_up != up) {
142                 hp_stats[cpu].up_down_count++;
143                 if ((hp_stats[cpu].up_down_count & 0x1) != up) {
144                         /* FIXME: sysfs user space CPU control breaks stats */
145                         pr_err("tegra hotplug stats out of sync with %s CPU%d",
146                                (cpu < nr_cpu_ids) ? "G" : "LP",
147                                (cpu < nr_cpu_ids) ?  cpu : 0);
148                         hp_stats[cpu].up_down_count ^=  0x1;
149                 }
150         }
151         hp_stats[cpu].last_update = cur_jiffies;
152 }
153
154 static void hp_stats_update(unsigned int cpu, bool up)
155 {
156         mutex_lock(&tegra_cpq_lock_stats);
157
158         __hp_stats_update(cpu, up);
159
160         mutex_unlock(&tegra_cpq_lock_stats);
161 }
162
163 /* must be called with tegra_cpu_lock held */
164 static void __update_target_cluster(unsigned int cpu_freq, bool suspend)
165 {
166         int min_cpus = pm_qos_request(PM_QOS_MIN_ONLINE_CPUS);
167
168         if (num_online_cpus() > 1) {
169                 cpq_target_cluster_state = TEGRA_CPQ_G;
170                 del_timer(&updown_timer);
171
172                 /* Call worker to take us to single core */
173                 if (no_lp == -1)
174                         queue_work(cpuquiet_wq, &cpuquiet_work);
175         } else if (no_lp == 1) {
176                 if (is_lp_cluster()) {
177                         cpq_target_cluster_state = TEGRA_CPQ_G;
178                         del_timer(&updown_timer);
179                         queue_work(cpuquiet_wq, &cpuquiet_work);
180                 }
181         } else if (no_lp == -1) {
182                 if (!is_lp_cluster()) {
183                         cpq_target_cluster_state = TEGRA_CPQ_LP;
184                         del_timer(&updown_timer);
185                         queue_work(cpuquiet_wq, &cpuquiet_work);
186                 }
187         } else {
188                 if (min_cpus >= 1) {
189                         if (is_lp_cluster()) {
190                                 cpq_target_cluster_state = TEGRA_CPQ_G;
191                                 del_timer(&updown_timer);
192                                 queue_work(cpuquiet_wq, &cpuquiet_work);
193                         }
194                         return;
195                 }
196                 /* Cpu frequency dependent cluster switches */
197
198                 /* Switch to G cluster if suspend rate is high enough */
199                 if (suspend && cpu_freq >= idle_bottom_freq) {
200                         cpq_target_cluster_state = TEGRA_CPQ_G;
201                         queue_work(cpuquiet_wq, &cpuquiet_work);
202                         return;
203                 }
204
205                 if (is_lp_cluster()) {
206                         if (cpu_freq >= idle_top_freq &&
207                                 cpq_target_cluster_state != TEGRA_CPQ_G) {
208
209                                 /* Switch to G cluster after up_delay */
210                                 cpq_target_cluster_state = TEGRA_CPQ_G;
211                                 mod_timer(&updown_timer,
212                                                 jiffies + up_delay);
213                         } else if (cpu_freq < idle_top_freq &&
214                                    cpq_target_cluster_state == TEGRA_CPQ_G) {
215
216                                 /*
217                                  * CPU frequency dropped below idle_top_freq
218                                  * while waiting for up_delay, Cancel switch.
219                                  */
220                                 cpq_target_cluster_state = TEGRA_CPQ_LP;
221                                 del_timer(&updown_timer);
222                         }
223                 } else {
224                         if (cpu_freq <= idle_bottom_freq &&
225                                 cpq_target_cluster_state != TEGRA_CPQ_LP) {
226
227                                 /* Switch to slow cluster after down_delay */
228                                 mod_timer(&updown_timer, jiffies + down_delay);
229                                 cpq_target_cluster_state = TEGRA_CPQ_LP;
230                         } else if (cpu_freq > idle_bottom_freq &&
231                                    cpq_target_cluster_state == TEGRA_CPQ_LP) {
232
233                                 /*
234                                  * CPU frequency raised above idle_bottom_freq.
235                                  * Stay on the fast cluster.
236                                  */
237                                 del_timer(&updown_timer);
238                                 cpq_target_cluster_state = TEGRA_CPQ_G;
239                         }
240                 }
241         }
242 }
243
244 static int update_core_config(unsigned int cpunumber, bool up)
245 {
246         int ret = 0;
247
248         mutex_lock(tegra_cpu_lock);
249
250         if (cpq_state == TEGRA_CPQ_DISABLED || cpunumber >= nr_cpu_ids) {
251                 mutex_unlock(tegra_cpu_lock);
252                 return -EINVAL;
253         }
254
255
256         if (up) {
257                 cpumask_set_cpu(cpunumber, &cr_online_requests);
258                 cpumask_clear_cpu(cpunumber, &cr_offline_requests);
259                 if (is_lp_cluster())
260                         ret = -EBUSY;
261                 else
262                         queue_work(cpuquiet_wq, &cpuquiet_work);
263         } else {
264                 if (is_lp_cluster()) {
265                         ret = -EBUSY;
266                 } else {
267                         cpumask_set_cpu(cpunumber, &cr_offline_requests);
268                         cpumask_clear_cpu(cpunumber, &cr_online_requests);
269                         queue_work(cpuquiet_wq, &cpuquiet_work);
270                 }
271         }
272
273         mutex_unlock(tegra_cpu_lock);
274
275         return ret;
276 }
277
278 static int tegra_quiesence_cpu(unsigned int cpunumber, bool sync)
279 {
280         int err = 0;
281
282         err = update_core_config(cpunumber, false);
283         if (err || !sync)
284                 return err;
285
286         err = wait_event_interruptible_timeout(wait_cpu,
287                                                !cpu_online(cpunumber),
288                                                hotplug_timeout);
289
290         if (err < 0)
291                 return err;
292
293         if (err > 0)
294                 return 0;
295         else
296                 return -ETIMEDOUT;
297 }
298
299 static int tegra_wake_cpu(unsigned int cpunumber, bool sync)
300 {
301         int err = 0;
302
303         err = update_core_config(cpunumber, true);
304         if (err || !sync)
305                 return err;
306
307         err = wait_event_interruptible_timeout(wait_cpu, cpu_online(cpunumber),
308                                                hotplug_timeout);
309
310         if (err < 0)
311                 return err;
312
313         if (err > 0)
314                 return 0;
315         else
316                 return -ETIMEDOUT;
317 }
318
319 static struct cpuquiet_driver tegra_cpuquiet_driver = {
320         .name                   = "tegra",
321         .quiesence_cpu          = tegra_quiesence_cpu,
322         .wake_cpu               = tegra_wake_cpu,
323 };
324
325 static void updown_handler(unsigned long data)
326 {
327         queue_work(cpuquiet_wq, &cpuquiet_work);
328 }
329
330 /* must be called from worker function */
331 static int __apply_cluster_config(int state, int target_state)
332 {
333         int new_state = state;
334         unsigned long speed;
335
336         mutex_lock(tegra_cpu_lock);
337
338         if (state == TEGRA_CPQ_LP) {
339                 if (target_state == TEGRA_CPQ_G && no_lp != -1) {
340                         /* make sure cpu rate is within g-mode range before
341                            switching */
342                         speed = max((unsigned long)tegra_getspeed(0),
343                                         clk_get_min_rate(cpu_g_clk) / 1000);
344                         tegra_update_cpu_speed(speed);
345
346                         if (!tegra_cluster_switch(cpu_clk, cpu_g_clk)) {
347                                 hp_stats_update(nr_cpu_ids, false);
348                                 hp_stats_update(0, true);
349                                 new_state = TEGRA_CPQ_G;
350                         }
351                 }
352         } else if (target_state == TEGRA_CPQ_LP && no_lp != 1 &&
353                         num_online_cpus() == 1) {
354
355                 speed = min((unsigned long)tegra_getspeed(0),
356                             clk_get_max_rate(cpu_lp_clk) / 1000);
357                 tegra_update_cpu_speed(speed);
358
359                 if (!tegra_cluster_switch(cpu_clk, cpu_lp_clk)) {
360                         hp_stats_update(nr_cpu_ids, true);
361                         hp_stats_update(0, false);
362                         new_state = TEGRA_CPQ_LP;
363                 }
364         }
365
366         wake_up_interruptible(&wait_no_lp);
367
368         mutex_unlock(tegra_cpu_lock);
369
370         return new_state;
371 }
372
373 /* must be called from worker function */
374 static void __cpuinit __apply_core_config(void)
375 {
376         int count = -1;
377         unsigned int cpu;
378         int nr_cpus;
379         struct cpumask online, offline, cpu_online;
380         int max_cpus = pm_qos_request(PM_QOS_MAX_ONLINE_CPUS);
381         int min_cpus = pm_qos_request(PM_QOS_MIN_ONLINE_CPUS);
382
383         if (min_cpus > num_possible_cpus())
384                 min_cpus = 0;
385         if (max_cpus <= 0)
386                 max_cpus = num_present_cpus();
387
388         mutex_lock(tegra_cpu_lock);
389
390         online = cr_online_requests;
391         offline = cr_offline_requests;
392
393         mutex_unlock(tegra_cpu_lock);
394
395         /* always keep CPU0 online */
396         cpumask_set_cpu(0, &online);
397         cpu_online = *cpu_online_mask;
398
399         if (no_lp == -1) {
400                 max_cpus = 1;
401                 min_cpus = 0;
402         } else if (max_cpus < min_cpus)
403                 max_cpus = min_cpus;
404
405         nr_cpus = cpumask_weight(&online);
406         if (nr_cpus < min_cpus) {
407                 cpu = 0;
408                 count = min_cpus - nr_cpus;
409                 for (; count > 0; count--) {
410                         cpu = cpumask_next_zero(cpu, &online);
411                         cpumask_set_cpu(cpu, &online);
412                         cpumask_clear_cpu(cpu, &offline);
413                 }
414         } else if (nr_cpus > max_cpus) {
415                 count = nr_cpus - max_cpus;
416                 cpu = 0;
417                 for (; count > 0; count--) {
418                         /* CPU0 should always be online */
419                         cpu = cpumask_next(cpu, &online);
420                         cpumask_set_cpu(cpu, &offline);
421                         cpumask_clear_cpu(cpu, &online);
422                 }
423         }
424
425         cpumask_andnot(&online, &online, &cpu_online);
426         for_each_cpu(cpu, &online) {
427                 cpu_up(cpu);
428                 hp_stats_update(cpu, true);
429         }
430
431         cpumask_and(&offline, &offline, &cpu_online);
432         for_each_cpu(cpu, &offline) {
433                 cpu_down(cpu);
434                 hp_stats_update(cpu, false);
435         }
436         wake_up_interruptible(&wait_cpu);
437 }
438
439 static void __cpuinit tegra_cpuquiet_work_func(struct work_struct *work)
440 {
441         int new_cluster, current_cluster, action;
442
443         mutex_lock(tegra_cpu_lock);
444
445         current_cluster = is_lp_cluster();
446         action = cpq_target_state;
447         new_cluster = cpq_target_cluster_state;
448
449         if (action == TEGRA_CPQ_ENABLED) {
450                 hp_init_stats();
451                 cpuquiet_device_free();
452                 pr_info("Tegra cpuquiet clusterswitch enabled\n");
453                 cpq_state = TEGRA_CPQ_ENABLED;
454                 cpq_target_state = TEGRA_CPQ_IDLE;
455                 cpq_target_cluster_state = is_lp_cluster();
456                 wake_up_interruptible(&wait_enable);
457         }
458
459         if (cpq_state == TEGRA_CPQ_DISABLED) {
460                 mutex_unlock(tegra_cpu_lock);
461                 return;
462         }
463
464         if (action == TEGRA_CPQ_DISABLED) {
465                 cpq_state = TEGRA_CPQ_DISABLED;
466                 mutex_unlock(tegra_cpu_lock);
467                 cpuquiet_device_busy();
468                 pr_info("Tegra cpuquiet clusterswitch disabled\n");
469                 wake_up_interruptible(&wait_enable);
470                 return;
471         }
472
473         mutex_unlock(tegra_cpu_lock);
474
475         if (current_cluster != new_cluster) {
476                 current_cluster = __apply_cluster_config(current_cluster,
477                                         new_cluster);
478
479                 tegra_cpu_set_speed_cap(NULL);
480
481                 if (current_cluster == TEGRA_CPQ_LP)
482                         cpuquiet_device_busy();
483                 else
484                         cpuquiet_device_free();
485         }
486
487         if (current_cluster == TEGRA_CPQ_G)
488                 __apply_core_config();
489 }
490
491 static int min_cpus_notify(struct notifier_block *nb, unsigned long n, void *p)
492 {
493         mutex_lock(tegra_cpu_lock);
494
495         if (cpq_state == TEGRA_CPQ_DISABLED) {
496                 mutex_unlock(tegra_cpu_lock);
497                 return NOTIFY_OK;
498         }
499
500         __update_target_cluster(tegra_getspeed(0), false);
501         queue_work(cpuquiet_wq, &cpuquiet_work);
502         mutex_unlock(tegra_cpu_lock);
503
504         return NOTIFY_OK;
505 }
506
507 static int max_cpus_notify(struct notifier_block *nb, unsigned long n, void *p)
508 {
509         mutex_lock(tegra_cpu_lock);
510
511         if (cpq_state != TEGRA_CPQ_DISABLED)
512                 queue_work(cpuquiet_wq, &cpuquiet_work);
513
514         mutex_unlock(tegra_cpu_lock);
515
516         return NOTIFY_OK;
517 }
518
519 static int __cpuinit cpu_online_notify(struct notifier_block *nfb,
520                                         unsigned long action, void *hcpu)
521 {
522         switch (action) {
523         case CPU_POST_DEAD:
524                 if (num_online_cpus() == 1) {
525                         mutex_lock(tegra_cpu_lock);
526                         __update_target_cluster(tegra_getspeed(0), false);
527                         mutex_unlock(tegra_cpu_lock);
528                 }
529                 break;
530         case CPU_ONLINE:
531         case CPU_ONLINE_FROZEN:
532                 mutex_lock(tegra_cpu_lock);
533                 __update_target_cluster(tegra_getspeed(0), false);
534                 mutex_unlock(tegra_cpu_lock);
535                 break;
536         }
537
538         return NOTIFY_OK;
539 }
540
541 /* must be called with tegra_cpu_lock held */
542 void tegra_auto_hotplug_governor(unsigned int cpu_freq, bool suspend)
543 {
544         if (!is_g_cluster_present() || no_lp)
545                 return;
546
547         if (cpq_state == TEGRA_CPQ_DISABLED)
548                 return;
549
550         if (suspend) {
551                 __update_target_cluster(cpu_freq, suspend);
552                 return;
553         }
554
555         /*
556          * If there is more then 1 CPU online, we must be on the fast cluster
557          * and we can't switch.
558          */
559         if (num_online_cpus() > 1)
560                 return;
561
562         __update_target_cluster(cpu_freq, suspend);
563 }
564
565 static struct notifier_block min_cpus_notifier = {
566         .notifier_call = min_cpus_notify,
567 };
568
569 static struct notifier_block max_cpus_notifier = {
570         .notifier_call = max_cpus_notify,
571 };
572
573 static struct notifier_block __cpuinitdata cpu_online_notifier = {
574         .notifier_call = cpu_online_notify,
575 };
576
577 static void delay_callback(struct cpuquiet_attribute *attr)
578 {
579         unsigned long val;
580
581         if (attr) {
582                 val = (*((unsigned long *)(attr->param)));
583                 (*((unsigned long *)(attr->param))) = msecs_to_jiffies(val);
584         }
585 }
586
587 static void enable_callback(struct cpuquiet_attribute *attr)
588 {
589         int target_state = enable ? TEGRA_CPQ_ENABLED : TEGRA_CPQ_DISABLED;
590
591         mutex_lock(tegra_cpu_lock);
592
593         if (cpq_state != target_state) {
594                 cpq_target_state = target_state;
595                 queue_work(cpuquiet_wq, &cpuquiet_work);
596         }
597
598         mutex_unlock(tegra_cpu_lock);
599
600         wait_event_interruptible(wait_enable, cpq_state == target_state);
601 }
602
603 ssize_t store_no_lp(struct cpuquiet_attribute *attr,
604                 const char *buf,
605                 size_t count)
606 {
607         int lp_req;
608         int rv;
609
610         rv = store_int_attribute(attr, buf, count);
611         if (rv < 0)
612                 return rv;
613
614         mutex_lock(tegra_cpu_lock);
615
616         __update_target_cluster(tegra_getspeed(0), false);
617
618         /* Force switch if necessary. */
619         if (no_lp == 1 && is_lp_cluster()) {
620                 lp_req = 0;
621         } else if (no_lp == -1 && !is_lp_cluster()) {
622                 lp_req = 1;
623         } else {
624                 lp_req = is_lp_cluster();
625                 /* Reevaluate speed to see if we are on the wrong cluster */
626                 tegra_cpu_set_speed_cap_locked(NULL);
627         }
628
629         mutex_unlock(tegra_cpu_lock);
630
631         wait_event_interruptible_timeout(
632                 wait_no_lp,
633                 no_lp == 0 || is_lp_cluster() == lp_req,
634                 hotplug_timeout);
635
636         if (no_lp == 0 || is_lp_cluster() == lp_req)
637                 return rv;
638         else
639                 return -ETIMEDOUT;
640 }
641
642 CPQ_BASIC_ATTRIBUTE(idle_top_freq, 0644, uint);
643 CPQ_BASIC_ATTRIBUTE(idle_bottom_freq, 0644, uint);
644 CPQ_ATTRIBUTE_CUSTOM(no_lp, 0644, show_int_attribute, store_no_lp);
645 CPQ_ATTRIBUTE(up_delay, 0644, ulong, delay_callback);
646 CPQ_ATTRIBUTE(down_delay, 0644, ulong, delay_callback);
647 CPQ_ATTRIBUTE(hotplug_timeout, 0644, ulong, delay_callback);
648 CPQ_ATTRIBUTE(enable, 0644, bool, enable_callback);
649
650 static struct attribute *tegra_auto_attributes[] = {
651         &no_lp_attr.attr,
652         &up_delay_attr.attr,
653         &down_delay_attr.attr,
654         &idle_top_freq_attr.attr,
655         &idle_bottom_freq_attr.attr,
656         &enable_attr.attr,
657         &hotplug_timeout_attr.attr,
658         NULL,
659 };
660
661 static const struct sysfs_ops tegra_auto_sysfs_ops = {
662         .show = cpuquiet_auto_sysfs_show,
663         .store = cpuquiet_auto_sysfs_store,
664 };
665
666 static struct kobj_type ktype_sysfs = {
667         .sysfs_ops = &tegra_auto_sysfs_ops,
668         .default_attrs = tegra_auto_attributes,
669 };
670
671 static int tegra_auto_sysfs(void)
672 {
673         int err;
674
675         tegra_auto_sysfs_kobject = kzalloc(sizeof(*tegra_auto_sysfs_kobject),
676                                         GFP_KERNEL);
677
678         if (!tegra_auto_sysfs_kobject)
679                 return -ENOMEM;
680
681         err = cpuquiet_kobject_init(tegra_auto_sysfs_kobject, &ktype_sysfs,
682                                 "tegra_cpuquiet");
683
684         if (err)
685                 kfree(tegra_auto_sysfs_kobject);
686
687         return err;
688 }
689
690 #ifdef CONFIG_DEBUG_FS
691
692 static struct dentry *hp_debugfs_root;
693
694 static int hp_stats_show(struct seq_file *s, void *data)
695 {
696         int i;
697         u64 cur_jiffies = get_jiffies_64();
698
699         mutex_lock(tegra_cpu_lock);
700
701         mutex_lock(&tegra_cpq_lock_stats);
702
703         if (cpq_state != TEGRA_CPQ_DISABLED) {
704                 for (i = 0; i <= nr_cpu_ids; i++) {
705                         bool was_up = (hp_stats[i].up_down_count & 0x1);
706                         __hp_stats_update(i, was_up);
707                 }
708         }
709         mutex_unlock(&tegra_cpq_lock_stats);
710
711         mutex_unlock(tegra_cpu_lock);
712
713         seq_printf(s, "%-15s ", "cpu:");
714         for (i = 0; i < nr_cpu_ids; i++)
715                 seq_printf(s, "G%-9d ", i);
716         seq_printf(s, "LP\n");
717
718         seq_printf(s, "%-15s ", "transitions:");
719         for (i = 0; i <= nr_cpu_ids; i++)
720                 seq_printf(s, "%-10u ", hp_stats[i].up_down_count);
721         seq_printf(s, "\n");
722
723         seq_printf(s, "%-15s ", "time plugged:");
724         for (i = 0; i <= nr_cpu_ids; i++) {
725                 seq_printf(s, "%-10llu ",
726                            cputime64_to_clock_t(hp_stats[i].time_up_total));
727         }
728         seq_printf(s, "\n");
729
730         seq_printf(s, "%-15s %llu\n", "time-stamp:",
731                    cputime64_to_clock_t(cur_jiffies));
732
733         return 0;
734 }
735
736
737 static int hp_stats_open(struct inode *inode, struct file *file)
738 {
739         return single_open(file, hp_stats_show, inode->i_private);
740 }
741
742
743 static const struct file_operations hp_stats_fops = {
744         .open           = hp_stats_open,
745         .read           = seq_read,
746         .llseek         = seq_lseek,
747         .release        = single_release,
748 };
749
750
751 static int __init tegra_cpuquiet_debug_init(void)
752 {
753
754         hp_debugfs_root = debugfs_create_dir("tegra_hotplug", NULL);
755         if (!hp_debugfs_root)
756                 return -ENOMEM;
757
758         if (!debugfs_create_file(
759                 "stats", S_IRUGO, hp_debugfs_root, NULL, &hp_stats_fops))
760                 goto err_out;
761
762         return 0;
763
764 err_out:
765         debugfs_remove_recursive(hp_debugfs_root);
766         return -ENOMEM;
767 }
768
769 late_initcall(tegra_cpuquiet_debug_init);
770
771 #endif /* CONFIG_DEBUG_FS */
772
773
774 int __cpuinit tegra_auto_hotplug_init(struct mutex *cpulock)
775 {
776         int err;
777
778         cpu_clk = clk_get_sys(NULL, "cpu");
779         cpu_g_clk = clk_get_sys(NULL, "cpu_g");
780         cpu_lp_clk = clk_get_sys(NULL, "cpu_lp");
781
782         if (IS_ERR(cpu_clk) || IS_ERR(cpu_g_clk) || IS_ERR(cpu_lp_clk))
783                 return -ENOENT;
784
785         tegra_cpu_lock = cpulock;
786
787         init_waitqueue_head(&wait_no_lp);
788         init_waitqueue_head(&wait_enable);
789         init_waitqueue_head(&wait_cpu);
790
791         /*
792          * Not bound to the issuer CPU (=> high-priority), has rescue worker
793          * task, single-threaded, freezable.
794          */
795         cpuquiet_wq = alloc_workqueue(
796                 "cpuquiet", WQ_NON_REENTRANT | WQ_FREEZABLE, 1);
797
798         if (!cpuquiet_wq)
799                 return -ENOMEM;
800
801         INIT_WORK(&cpuquiet_work, tegra_cpuquiet_work_func);
802         init_timer(&updown_timer);
803         updown_timer.function = updown_handler;
804
805         idle_top_freq = clk_get_max_rate(cpu_lp_clk) / 1000;
806         idle_bottom_freq = clk_get_min_rate(cpu_g_clk) / 1000;
807
808         up_delay = msecs_to_jiffies(UP_DELAY_MS);
809         down_delay = msecs_to_jiffies(DOWN_DELAY_MS);
810         hotplug_timeout = msecs_to_jiffies(HOTPLUG_DELAY_MS);
811         cpumask_clear(&cr_online_requests);
812         cpumask_clear(&cr_offline_requests);
813
814         cpq_target_cluster_state = is_lp_cluster();
815         cpq_state = INITIAL_STATE;
816         enable = cpq_state == TEGRA_CPQ_DISABLED ? false : true;
817         hp_init_stats();
818
819         pr_info("Tegra cpuquiet initialized: %s\n",
820                 (cpq_state == TEGRA_CPQ_DISABLED) ? "disabled" : "enabled");
821
822         if (pm_qos_add_notifier(PM_QOS_MIN_ONLINE_CPUS, &min_cpus_notifier))
823                 pr_err("%s: Failed to register min cpus PM QoS notifier\n",
824                         __func__);
825         if (pm_qos_add_notifier(PM_QOS_MAX_ONLINE_CPUS, &max_cpus_notifier))
826                 pr_err("%s: Failed to register max cpus PM QoS notifier\n",
827                         __func__);
828
829         register_hotcpu_notifier(&cpu_online_notifier);
830
831         err = cpuquiet_register_driver(&tegra_cpuquiet_driver);
832         if (err) {
833                 destroy_workqueue(cpuquiet_wq);
834                 return err;
835         }
836
837         err = tegra_auto_sysfs();
838         if (err) {
839                 cpuquiet_unregister_driver(&tegra_cpuquiet_driver);
840                 destroy_workqueue(cpuquiet_wq);
841         }
842
843         return err;
844 }
845
846 void tegra_auto_hotplug_exit(void)
847 {
848         destroy_workqueue(cpuquiet_wq);
849         cpuquiet_unregister_driver(&tegra_cpuquiet_driver);
850         kobject_put(tegra_auto_sysfs_kobject);
851
852 #ifdef CONFIG_DEBUG_FS
853         debugfs_remove_recursive(hp_debugfs_root);
854 #endif
855 }