e9248bb9173ae267ff09c14d06128527352f9f20
[cascardo/linux.git] / 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 #include <linux/clockchips.h>
15 #include <linux/of.h>
16
17 #include <asm/machdep.h>
18 #include <asm/firmware.h>
19 #include <asm/runlatch.h>
20
21 /* Flags and constants used in PowerNV platform */
22
23 #define MAX_POWERNV_IDLE_STATES 8
24 #define IDLE_USE_INST_NAP       0x00010000 /* Use nap instruction */
25 #define IDLE_USE_INST_SLEEP     0x00020000 /* Use sleep instruction */
26
27 struct cpuidle_driver powernv_idle_driver = {
28         .name             = "powernv_idle",
29         .owner            = THIS_MODULE,
30 };
31
32 static int max_idle_state;
33 static struct cpuidle_state *cpuidle_state_table;
34
35 static int snooze_loop(struct cpuidle_device *dev,
36                         struct cpuidle_driver *drv,
37                         int index)
38 {
39         local_irq_enable();
40         set_thread_flag(TIF_POLLING_NRFLAG);
41
42         ppc64_runlatch_off();
43         while (!need_resched()) {
44                 HMT_low();
45                 HMT_very_low();
46         }
47
48         HMT_medium();
49         ppc64_runlatch_on();
50         clear_thread_flag(TIF_POLLING_NRFLAG);
51         smp_mb();
52         return index;
53 }
54
55 static int nap_loop(struct cpuidle_device *dev,
56                         struct cpuidle_driver *drv,
57                         int index)
58 {
59         ppc64_runlatch_off();
60         power7_idle();
61         ppc64_runlatch_on();
62         return index;
63 }
64
65 static int fastsleep_loop(struct cpuidle_device *dev,
66                                 struct cpuidle_driver *drv,
67                                 int index)
68 {
69         unsigned long old_lpcr = mfspr(SPRN_LPCR);
70         unsigned long new_lpcr;
71
72         if (unlikely(system_state < SYSTEM_RUNNING))
73                 return index;
74
75         new_lpcr = old_lpcr;
76         /* Do not exit powersave upon decrementer as we've setup the timer
77          * offload.
78          */
79         new_lpcr &= ~LPCR_PECE1;
80
81         mtspr(SPRN_LPCR, new_lpcr);
82         power7_sleep();
83
84         mtspr(SPRN_LPCR, old_lpcr);
85
86         return index;
87 }
88
89 /*
90  * States for dedicated partition case.
91  */
92 static struct cpuidle_state powernv_states[MAX_POWERNV_IDLE_STATES] = {
93         { /* Snooze */
94                 .name = "snooze",
95                 .desc = "snooze",
96                 .exit_latency = 0,
97                 .target_residency = 0,
98                 .enter = &snooze_loop },
99 };
100
101 static int powernv_cpuidle_add_cpu_notifier(struct notifier_block *n,
102                         unsigned long action, void *hcpu)
103 {
104         int hotcpu = (unsigned long)hcpu;
105         struct cpuidle_device *dev =
106                                 per_cpu(cpuidle_devices, hotcpu);
107
108         if (dev && cpuidle_get_driver()) {
109                 switch (action) {
110                 case CPU_ONLINE:
111                 case CPU_ONLINE_FROZEN:
112                         cpuidle_pause_and_lock();
113                         cpuidle_enable_device(dev);
114                         cpuidle_resume_and_unlock();
115                         break;
116
117                 case CPU_DEAD:
118                 case CPU_DEAD_FROZEN:
119                         cpuidle_pause_and_lock();
120                         cpuidle_disable_device(dev);
121                         cpuidle_resume_and_unlock();
122                         break;
123
124                 default:
125                         return NOTIFY_DONE;
126                 }
127         }
128         return NOTIFY_OK;
129 }
130
131 static struct notifier_block setup_hotplug_notifier = {
132         .notifier_call = powernv_cpuidle_add_cpu_notifier,
133 };
134
135 /*
136  * powernv_cpuidle_driver_init()
137  */
138 static int powernv_cpuidle_driver_init(void)
139 {
140         int idle_state;
141         struct cpuidle_driver *drv = &powernv_idle_driver;
142
143         drv->state_count = 0;
144
145         for (idle_state = 0; idle_state < max_idle_state; ++idle_state) {
146                 /* Is the state not enabled? */
147                 if (cpuidle_state_table[idle_state].enter == NULL)
148                         continue;
149
150                 drv->states[drv->state_count] = /* structure copy */
151                         cpuidle_state_table[idle_state];
152
153                 drv->state_count += 1;
154         }
155
156         return 0;
157 }
158
159 static int powernv_add_idle_states(void)
160 {
161         struct device_node *power_mgt;
162         int nr_idle_states = 1; /* Snooze */
163         int dt_idle_states;
164         const __be32 *idle_state_flags;
165         const __be32 *idle_state_latency;
166         u32 len_flags, flags, latency_ns;
167         int i;
168
169         /* Currently we have snooze statically defined */
170
171         power_mgt = of_find_node_by_path("/ibm,opal/power-mgt");
172         if (!power_mgt) {
173                 pr_warn("opal: PowerMgmt Node not found\n");
174                 return nr_idle_states;
175         }
176
177         idle_state_flags = of_get_property(power_mgt, "ibm,cpu-idle-state-flags", &len_flags);
178         if (!idle_state_flags) {
179                 pr_warn("DT-PowerMgmt: missing ibm,cpu-idle-state-flags\n");
180                 return nr_idle_states;
181         }
182
183         idle_state_latency = of_get_property(power_mgt,
184                         "ibm,cpu-idle-state-latencies-ns", NULL);
185         if (!idle_state_latency) {
186                 pr_warn("DT-PowerMgmt: missing ibm,cpu-idle-state-latencies-ns\n");
187                 return nr_idle_states;
188         }
189
190         dt_idle_states = len_flags / sizeof(u32);
191
192         for (i = 0; i < dt_idle_states; i++) {
193
194                 flags = be32_to_cpu(idle_state_flags[i]);
195
196                 /* Cpuidle accepts exit_latency in us and we estimate
197                  * target residency to be 10x exit_latency
198                  */
199                 latency_ns = be32_to_cpu(idle_state_latency[i]);
200                 if (flags & IDLE_USE_INST_NAP) {
201                         /* Add NAP state */
202                         strcpy(powernv_states[nr_idle_states].name, "Nap");
203                         strcpy(powernv_states[nr_idle_states].desc, "Nap");
204                         powernv_states[nr_idle_states].flags = 0;
205                         powernv_states[nr_idle_states].exit_latency =
206                                         ((unsigned int)latency_ns) / 1000;
207                         powernv_states[nr_idle_states].target_residency =
208                                         ((unsigned int)latency_ns / 100);
209                         powernv_states[nr_idle_states].enter = &nap_loop;
210                         nr_idle_states++;
211                 }
212
213                 if (flags & IDLE_USE_INST_SLEEP) {
214                         /* Add FASTSLEEP state */
215                         strcpy(powernv_states[nr_idle_states].name, "FastSleep");
216                         strcpy(powernv_states[nr_idle_states].desc, "FastSleep");
217                         powernv_states[nr_idle_states].flags = CPUIDLE_FLAG_TIMER_STOP;
218                         powernv_states[nr_idle_states].exit_latency =
219                                         ((unsigned int)latency_ns) / 1000;
220                         powernv_states[nr_idle_states].target_residency =
221                                         ((unsigned int)latency_ns / 100);
222                         powernv_states[nr_idle_states].enter = &fastsleep_loop;
223                         nr_idle_states++;
224                 }
225         }
226
227         return nr_idle_states;
228 }
229
230 /*
231  * powernv_idle_probe()
232  * Choose state table for shared versus dedicated partition
233  */
234 static int powernv_idle_probe(void)
235 {
236         if (cpuidle_disable != IDLE_NO_OVERRIDE)
237                 return -ENODEV;
238
239         if (firmware_has_feature(FW_FEATURE_OPALv3)) {
240                 cpuidle_state_table = powernv_states;
241                 /* Device tree can indicate more idle states */
242                 max_idle_state = powernv_add_idle_states();
243         } else
244                 return -ENODEV;
245
246         return 0;
247 }
248
249 static int __init powernv_processor_idle_init(void)
250 {
251         int retval;
252
253         retval = powernv_idle_probe();
254         if (retval)
255                 return retval;
256
257         powernv_cpuidle_driver_init();
258         retval = cpuidle_register(&powernv_idle_driver, NULL);
259         if (retval) {
260                 printk(KERN_DEBUG "Registration of powernv driver failed.\n");
261                 return retval;
262         }
263
264         register_cpu_notifier(&setup_hotplug_notifier);
265         printk(KERN_DEBUG "powernv_idle_driver registered\n");
266         return 0;
267 }
268
269 device_initcall(powernv_processor_idle_init);