x86 idle: move mwait_idle_with_hints() to where it is used
[linux-2.6.git] / arch / sh / kernel / idle.c
1 /*
2  * The idle loop for all SuperH platforms.
3  *
4  *  Copyright (C) 2002 - 2009  Paul Mundt
5  *
6  * This file is subject to the terms and conditions of the GNU General Public
7  * License.  See the file "COPYING" in the main directory of this archive
8  * for more details.
9  */
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/mm.h>
13 #include <linux/pm.h>
14 #include <linux/tick.h>
15 #include <linux/preempt.h>
16 #include <linux/thread_info.h>
17 #include <linux/irqflags.h>
18 #include <linux/smp.h>
19 #include <asm/pgalloc.h>
20 #include <asm/system.h>
21 #include <asm/atomic.h>
22 #include <asm/smp.h>
23
24 void (*pm_idle)(void) = NULL;
25
26 static int hlt_counter;
27
28 static int __init nohlt_setup(char *__unused)
29 {
30         hlt_counter = 1;
31         return 1;
32 }
33 __setup("nohlt", nohlt_setup);
34
35 static int __init hlt_setup(char *__unused)
36 {
37         hlt_counter = 0;
38         return 1;
39 }
40 __setup("hlt", hlt_setup);
41
42 static inline int hlt_works(void)
43 {
44         return !hlt_counter;
45 }
46
47 /*
48  * On SMP it's slightly faster (but much more power-consuming!)
49  * to poll the ->work.need_resched flag instead of waiting for the
50  * cross-CPU IPI to arrive. Use this option with caution.
51  */
52 static void poll_idle(void)
53 {
54         local_irq_enable();
55         while (!need_resched())
56                 cpu_relax();
57 }
58
59 void default_idle(void)
60 {
61         if (hlt_works()) {
62                 clear_thread_flag(TIF_POLLING_NRFLAG);
63                 smp_mb__after_clear_bit();
64
65                 set_bl_bit();
66                 if (!need_resched()) {
67                         local_irq_enable();
68                         cpu_sleep();
69                 } else
70                         local_irq_enable();
71
72                 set_thread_flag(TIF_POLLING_NRFLAG);
73                 clear_bl_bit();
74         } else
75                 poll_idle();
76 }
77
78 /*
79  * The idle thread. There's no useful work to be done, so just try to conserve
80  * power and have a low exit latency (ie sit in a loop waiting for somebody to
81  * say that they'd like to reschedule)
82  */
83 void cpu_idle(void)
84 {
85         unsigned int cpu = smp_processor_id();
86
87         set_thread_flag(TIF_POLLING_NRFLAG);
88
89         /* endless idle loop with no priority at all */
90         while (1) {
91                 tick_nohz_stop_sched_tick(1);
92
93                 while (!need_resched()) {
94                         check_pgt_cache();
95                         rmb();
96
97                         if (cpu_is_offline(cpu))
98                                 play_dead();
99
100                         local_irq_disable();
101                         /* Don't trace irqs off for idle */
102                         stop_critical_timings();
103                         pm_idle();
104                         /*
105                          * Sanity check to ensure that pm_idle() returns
106                          * with IRQs enabled
107                          */
108                         WARN_ON(irqs_disabled());
109                         start_critical_timings();
110                 }
111
112                 tick_nohz_restart_sched_tick();
113                 preempt_enable_no_resched();
114                 schedule();
115                 preempt_disable();
116         }
117 }
118
119 void __init select_idle_routine(void)
120 {
121         /*
122          * If a platform has set its own idle routine, leave it alone.
123          */
124         if (pm_idle)
125                 return;
126
127         if (hlt_works())
128                 pm_idle = default_idle;
129         else
130                 pm_idle = poll_idle;
131 }
132
133 static void do_nothing(void *unused)
134 {
135 }
136
137 void stop_this_cpu(void *unused)
138 {
139         local_irq_disable();
140         set_cpu_online(smp_processor_id(), false);
141
142         for (;;)
143                 cpu_sleep();
144 }
145
146 /*
147  * cpu_idle_wait - Used to ensure that all the CPUs discard old value of
148  * pm_idle and update to new pm_idle value. Required while changing pm_idle
149  * handler on SMP systems.
150  *
151  * Caller must have changed pm_idle to the new value before the call. Old
152  * pm_idle value will not be used by any CPU after the return of this function.
153  */
154 void cpu_idle_wait(void)
155 {
156         smp_mb();
157         /* kick all the CPUs so that they exit out of pm_idle */
158         smp_call_function(do_nothing, NULL, 1);
159 }
160 EXPORT_SYMBOL_GPL(cpu_idle_wait);