GNU Linux-libre 4.4.289-gnu1
[releases.git] / drivers / cpuidle / cpuidle-cps.c
1 /*
2  * Copyright (C) 2014 Imagination Technologies
3  * Author: Paul Burton <paul.burton@imgtec.com>
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the
7  * Free Software Foundation;  either version 2 of the  License, or (at your
8  * option) any later version.
9  */
10
11 #include <linux/cpu_pm.h>
12 #include <linux/cpuidle.h>
13 #include <linux/init.h>
14
15 #include <asm/idle.h>
16 #include <asm/pm-cps.h>
17
18 /* Enumeration of the various idle states this driver may enter */
19 enum cps_idle_state {
20         STATE_WAIT = 0,         /* MIPS wait instruction, coherent */
21         STATE_NC_WAIT,          /* MIPS wait instruction, non-coherent */
22         STATE_CLOCK_GATED,      /* Core clock gated */
23         STATE_POWER_GATED,      /* Core power gated */
24         STATE_COUNT
25 };
26
27 static int cps_nc_enter(struct cpuidle_device *dev,
28                         struct cpuidle_driver *drv, int index)
29 {
30         enum cps_pm_state pm_state;
31         int err;
32
33         /*
34          * At least one core must remain powered up & clocked in order for the
35          * system to have any hope of functioning.
36          *
37          * TODO: don't treat core 0 specially, just prevent the final core
38          * TODO: remap interrupt affinity temporarily
39          */
40         if (!cpu_data[dev->cpu].core && (index > STATE_NC_WAIT))
41                 index = STATE_NC_WAIT;
42
43         /* Select the appropriate cps_pm_state */
44         switch (index) {
45         case STATE_NC_WAIT:
46                 pm_state = CPS_PM_NC_WAIT;
47                 break;
48         case STATE_CLOCK_GATED:
49                 pm_state = CPS_PM_CLOCK_GATED;
50                 break;
51         case STATE_POWER_GATED:
52                 pm_state = CPS_PM_POWER_GATED;
53                 break;
54         default:
55                 BUG();
56                 return -EINVAL;
57         }
58
59         /* Notify listeners the CPU is about to power down */
60         if ((pm_state == CPS_PM_POWER_GATED) && cpu_pm_enter())
61                 return -EINTR;
62
63         /* Enter that state */
64         err = cps_pm_enter_state(pm_state);
65
66         /* Notify listeners the CPU is back up */
67         if (pm_state == CPS_PM_POWER_GATED)
68                 cpu_pm_exit();
69
70         return err ?: index;
71 }
72
73 static struct cpuidle_driver cps_driver = {
74         .name                   = "cpc_cpuidle",
75         .owner                  = THIS_MODULE,
76         .states = {
77                 [STATE_WAIT] = MIPS_CPUIDLE_WAIT_STATE,
78                 [STATE_NC_WAIT] = {
79                         .enter  = cps_nc_enter,
80                         .exit_latency           = 200,
81                         .target_residency       = 450,
82                         .name   = "nc-wait",
83                         .desc   = "non-coherent MIPS wait",
84                 },
85                 [STATE_CLOCK_GATED] = {
86                         .enter  = cps_nc_enter,
87                         .exit_latency           = 300,
88                         .target_residency       = 700,
89                         .flags  = CPUIDLE_FLAG_TIMER_STOP,
90                         .name   = "clock-gated",
91                         .desc   = "core clock gated",
92                 },
93                 [STATE_POWER_GATED] = {
94                         .enter  = cps_nc_enter,
95                         .exit_latency           = 600,
96                         .target_residency       = 1000,
97                         .flags  = CPUIDLE_FLAG_TIMER_STOP,
98                         .name   = "power-gated",
99                         .desc   = "core power gated",
100                 },
101         },
102         .state_count            = STATE_COUNT,
103         .safe_state_index       = 0,
104 };
105
106 static void __init cps_cpuidle_unregister(void)
107 {
108         int cpu;
109         struct cpuidle_device *device;
110
111         for_each_possible_cpu(cpu) {
112                 device = &per_cpu(cpuidle_dev, cpu);
113                 cpuidle_unregister_device(device);
114         }
115
116         cpuidle_unregister_driver(&cps_driver);
117 }
118
119 static int __init cps_cpuidle_init(void)
120 {
121         int err, cpu, core, i;
122         struct cpuidle_device *device;
123
124         /* Detect supported states */
125         if (!cps_pm_support_state(CPS_PM_POWER_GATED))
126                 cps_driver.state_count = STATE_CLOCK_GATED + 1;
127         if (!cps_pm_support_state(CPS_PM_CLOCK_GATED))
128                 cps_driver.state_count = STATE_NC_WAIT + 1;
129         if (!cps_pm_support_state(CPS_PM_NC_WAIT))
130                 cps_driver.state_count = STATE_WAIT + 1;
131
132         /* Inform the user if some states are unavailable */
133         if (cps_driver.state_count < STATE_COUNT) {
134                 pr_info("cpuidle-cps: limited to ");
135                 switch (cps_driver.state_count - 1) {
136                 case STATE_WAIT:
137                         pr_cont("coherent wait\n");
138                         break;
139                 case STATE_NC_WAIT:
140                         pr_cont("non-coherent wait\n");
141                         break;
142                 case STATE_CLOCK_GATED:
143                         pr_cont("clock gating\n");
144                         break;
145                 }
146         }
147
148         /*
149          * Set the coupled flag on the appropriate states if this system
150          * requires it.
151          */
152         if (coupled_coherence)
153                 for (i = STATE_NC_WAIT; i < cps_driver.state_count; i++)
154                         cps_driver.states[i].flags |= CPUIDLE_FLAG_COUPLED;
155
156         err = cpuidle_register_driver(&cps_driver);
157         if (err) {
158                 pr_err("Failed to register CPS cpuidle driver\n");
159                 return err;
160         }
161
162         for_each_possible_cpu(cpu) {
163                 core = cpu_data[cpu].core;
164                 device = &per_cpu(cpuidle_dev, cpu);
165                 device->cpu = cpu;
166 #ifdef CONFIG_MIPS_MT
167                 cpumask_copy(&device->coupled_cpus, &cpu_sibling_map[cpu]);
168 #endif
169
170                 err = cpuidle_register_device(device);
171                 if (err) {
172                         pr_err("Failed to register CPU%d cpuidle device\n",
173                                cpu);
174                         goto err_out;
175                 }
176         }
177
178         return 0;
179 err_out:
180         cps_cpuidle_unregister();
181         return err;
182 }
183 device_initcall(cps_cpuidle_init);