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