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