drivers/cpuidle/cpuidle-powernv.c

   1 /*
   2  *  cpuidle-powernv - idle state cpuidle driver.
   3  *  Adapted from drivers/cpuidle/cpuidle-pseries
   4  *
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/init.h>
  10 #include <linux/moduleparam.h>
  11 #include <linux/cpuidle.h>
  12 #include <linux/cpu.h>
  13 #include <linux/notifier.h>
  14
  15 #include <asm/machdep.h>
  16 #include <asm/firmware.h>
  17
  18 struct cpuidle_driver powernv_idle_driver = {
  19         .name             = "powernv_idle",
  20         .owner            = THIS_MODULE,
  21 };
  22
  23 static int max_idle_state;
  24 static struct cpuidle_state *cpuidle_state_table;
  25
  26 static int snooze_loop(struct cpuidle_device *dev,
  27                         struct cpuidle_driver *drv,
  28                         int index)
  29 {
  30         local_irq_enable();
  31         set_thread_flag(TIF_POLLING_NRFLAG);
  32
  33         while (!need_resched()) {
  34                 HMT_low();
  35                 HMT_very_low();
  36         }
  37
  38         HMT_medium();
  39         clear_thread_flag(TIF_POLLING_NRFLAG);
  40         smp_mb();
  41         return index;
  42 }
  43
  44 static int nap_loop(struct cpuidle_device *dev,
  45                         struct cpuidle_driver *drv,
  46                         int index)
  47 {
  48         power7_idle();
  49         return index;
  50 }
  51
  52 /*
  53  * States for dedicated partition case.
  54  */
  55 static struct cpuidle_state powernv_states[] = {
  56         { /* Snooze */
  57                 .name = "snooze",
  58                 .desc = "snooze",
  59                 .flags = CPUIDLE_FLAG_TIME_VALID,
  60                 .exit_latency = 0,
  61                 .target_residency = 0,
  62                 .enter = &snooze_loop },
  63         { /* NAP */
  64                 .name = "NAP",
  65                 .desc = "NAP",
  66                 .flags = CPUIDLE_FLAG_TIME_VALID,
  67                 .exit_latency = 10,
  68                 .target_residency = 100,
  69                 .enter = &nap_loop },
  70 };
  71
  72 static int powernv_cpuidle_add_cpu_notifier(struct notifier_block *n,
  73                         unsigned long action, void *hcpu)
  74 {
  75         int hotcpu = (unsigned long)hcpu;
  76         struct cpuidle_device *dev =
  77                                 per_cpu(cpuidle_devices, hotcpu);
  78
  79         if (dev && cpuidle_get_driver()) {
  80                 switch (action) {
  81                 case CPU_ONLINE:
  82                 case CPU_ONLINE_FROZEN:
  83                         cpuidle_pause_and_lock();
  84                         cpuidle_enable_device(dev);
  85                         cpuidle_resume_and_unlock();
  86                         break;
  87
  88                 case CPU_DEAD:
  89                 case CPU_DEAD_FROZEN:
  90                         cpuidle_pause_and_lock();
  91                         cpuidle_disable_device(dev);
  92                         cpuidle_resume_and_unlock();
  93                         break;
  94
  95                 default:
  96                         return NOTIFY_DONE;
  97                 }
  98         }
  99         return NOTIFY_OK;
 100 }
 101
 102 static struct notifier_block setup_hotplug_notifier = {
 103         .notifier_call = powernv_cpuidle_add_cpu_notifier,
 104 };
 105
 106 /*
 107  * powernv_cpuidle_driver_init()
 108  */
 109 static int powernv_cpuidle_driver_init(void)
 110 {
 111         int idle_state;
 112         struct cpuidle_driver *drv = &powernv_idle_driver;
 113
 114         drv->state_count = 0;
 115
 116         for (idle_state = 0; idle_state < max_idle_state; ++idle_state) {
 117                 /* Is the state not enabled? */
 118                 if (cpuidle_state_table[idle_state].enter == NULL)
 119                         continue;
 120
 121                 drv->states[drv->state_count] = /* structure copy */
 122                         cpuidle_state_table[idle_state];
 123
 124                 drv->state_count += 1;
 125         }
 126
 127         return 0;
 128 }
 129
 130 /*
 131  * powernv_idle_probe()
 132  * Choose state table for shared versus dedicated partition
 133  */
 134 static int powernv_idle_probe(void)
 135 {
 136
 137         if (cpuidle_disable != IDLE_NO_OVERRIDE)
 138                 return -ENODEV;
 139
 140         if (firmware_has_feature(FW_FEATURE_OPALv3)) {
 141                 cpuidle_state_table = powernv_states;
 142                 max_idle_state = ARRAY_SIZE(powernv_states);
 143         } else
 144                 return -ENODEV;
 145
 146         return 0;
 147 }
 148
 149 static int __init powernv_processor_idle_init(void)
 150 {
 151         int retval;
 152
 153         retval = powernv_idle_probe();
 154         if (retval)
 155                 return retval;
 156
 157         powernv_cpuidle_driver_init();
 158         retval = cpuidle_register(&powernv_idle_driver, NULL);
 159         if (retval) {
 160                 printk(KERN_DEBUG "Registration of powernv driver failed.\n");
 161                 return retval;
 162         }
 163
 164         register_cpu_notifier(&setup_hotplug_notifier);
 165         printk(KERN_DEBUG "powernv_idle_driver registered\n");
 166         return 0;
 167 }
 168
 169 device_initcall(powernv_processor_idle_init);