1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * processor_thermal.c - Passive cooling submodule of the ACPI processor driver
4  *
5  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7  *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
8  *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
9  *  			- Added processor hotplug support
10  */
11 
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/cpufreq.h>
16 #include <linux/acpi.h>
17 #include <acpi/processor.h>
18 #include <linux/uaccess.h>
19 
20 #ifdef CONFIG_CPU_FREQ
21 
22 /* If a passive cooling situation is detected, primarily CPUfreq is used, as it
23  * offers (in most cases) voltage scaling in addition to frequency scaling, and
24  * thus a cubic (instead of linear) reduction of energy. Also, we allow for
25  * _any_ cpufreq driver and not only the acpi-cpufreq driver.
26  */
27 
28 #define CPUFREQ_THERMAL_MIN_STEP 0
29 #define CPUFREQ_THERMAL_MAX_STEP 3
30 
31 static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg);
32 
33 #define reduction_pctg(cpu) \
34 	per_cpu(cpufreq_thermal_reduction_pctg, phys_package_first_cpu(cpu))
35 
36 /*
37  * Emulate "per package data" using per cpu data (which should really be
38  * provided elsewhere)
39  *
40  * Note we can lose a CPU on cpu hotunplug, in this case we forget the state
41  * temporarily. Fortunately that's not a big issue here (I hope)
42  */
43 static int phys_package_first_cpu(int cpu)
44 {
45 	int i;
46 	int id = topology_physical_package_id(cpu);
47 
48 	for_each_online_cpu(i)
49 		if (topology_physical_package_id(i) == id)
50 			return i;
51 	return 0;
52 }
53 
54 static int cpu_has_cpufreq(unsigned int cpu)
55 {
56 	struct cpufreq_policy *policy;
57 
58 	if (!acpi_processor_cpufreq_init)
59 		return 0;
60 
61 	policy = cpufreq_cpu_get(cpu);
62 	if (policy) {
63 		cpufreq_cpu_put(policy);
64 		return 1;
65 	}
66 	return 0;
67 }
68 
69 static int cpufreq_get_max_state(unsigned int cpu)
70 {
71 	if (!cpu_has_cpufreq(cpu))
72 		return 0;
73 
74 	return CPUFREQ_THERMAL_MAX_STEP;
75 }
76 
77 static int cpufreq_get_cur_state(unsigned int cpu)
78 {
79 	if (!cpu_has_cpufreq(cpu))
80 		return 0;
81 
82 	return reduction_pctg(cpu);
83 }
84 
85 static int cpufreq_set_cur_state(unsigned int cpu, int state)
86 {
87 	struct cpufreq_policy *policy;
88 	struct acpi_processor *pr;
89 	unsigned long max_freq;
90 	int i, ret;
91 
92 	if (!cpu_has_cpufreq(cpu))
93 		return 0;
94 
95 	reduction_pctg(cpu) = state;
96 
97 	/*
98 	 * Update all the CPUs in the same package because they all
99 	 * contribute to the temperature and often share the same
100 	 * frequency.
101 	 */
102 	for_each_online_cpu(i) {
103 		if (topology_physical_package_id(i) !=
104 		    topology_physical_package_id(cpu))
105 			continue;
106 
107 		pr = per_cpu(processors, i);
108 
109 		if (unlikely(!freq_qos_request_active(&pr->thermal_req)))
110 			continue;
111 
112 		policy = cpufreq_cpu_get(i);
113 		if (!policy)
114 			return -EINVAL;
115 
116 		max_freq = (policy->cpuinfo.max_freq * (100 - reduction_pctg(i) * 20)) / 100;
117 
118 		cpufreq_cpu_put(policy);
119 
120 		ret = freq_qos_update_request(&pr->thermal_req, max_freq);
121 		if (ret < 0) {
122 			pr_warn("Failed to update thermal freq constraint: CPU%d (%d)\n",
123 				pr->id, ret);
124 		}
125 	}
126 	return 0;
127 }
128 
129 void acpi_thermal_cpufreq_init(struct cpufreq_policy *policy)
130 {
131 	unsigned int cpu;
132 
133 	for_each_cpu(cpu, policy->related_cpus) {
134 		struct acpi_processor *pr = per_cpu(processors, cpu);
135 		int ret;
136 
137 		if (!pr)
138 			continue;
139 
140 		ret = freq_qos_add_request(&policy->constraints,
141 					   &pr->thermal_req,
142 					   FREQ_QOS_MAX, INT_MAX);
143 		if (ret < 0)
144 			pr_err("Failed to add freq constraint for CPU%d (%d)\n",
145 			       cpu, ret);
146 	}
147 }
148 
149 void acpi_thermal_cpufreq_exit(struct cpufreq_policy *policy)
150 {
151 	unsigned int cpu;
152 
153 	for_each_cpu(cpu, policy->related_cpus) {
154 		struct acpi_processor *pr = per_cpu(processors, policy->cpu);
155 
156 		if (pr)
157 			freq_qos_remove_request(&pr->thermal_req);
158 	}
159 }
160 #else				/* ! CONFIG_CPU_FREQ */
161 static int cpufreq_get_max_state(unsigned int cpu)
162 {
163 	return 0;
164 }
165 
166 static int cpufreq_get_cur_state(unsigned int cpu)
167 {
168 	return 0;
169 }
170 
171 static int cpufreq_set_cur_state(unsigned int cpu, int state)
172 {
173 	return 0;
174 }
175 
176 #endif
177 
178 /* thermal cooling device callbacks */
179 static int acpi_processor_max_state(struct acpi_processor *pr)
180 {
181 	int max_state = 0;
182 
183 	/*
184 	 * There exists four states according to
185 	 * cpufreq_thermal_reduction_pctg. 0, 1, 2, 3
186 	 */
187 	max_state += cpufreq_get_max_state(pr->id);
188 	if (pr->flags.throttling)
189 		max_state += (pr->throttling.state_count -1);
190 
191 	return max_state;
192 }
193 static int
194 processor_get_max_state(struct thermal_cooling_device *cdev,
195 			unsigned long *state)
196 {
197 	struct acpi_device *device = cdev->devdata;
198 	struct acpi_processor *pr;
199 
200 	if (!device)
201 		return -EINVAL;
202 
203 	pr = acpi_driver_data(device);
204 	if (!pr)
205 		return -EINVAL;
206 
207 	*state = acpi_processor_max_state(pr);
208 	return 0;
209 }
210 
211 static int
212 processor_get_cur_state(struct thermal_cooling_device *cdev,
213 			unsigned long *cur_state)
214 {
215 	struct acpi_device *device = cdev->devdata;
216 	struct acpi_processor *pr;
217 
218 	if (!device)
219 		return -EINVAL;
220 
221 	pr = acpi_driver_data(device);
222 	if (!pr)
223 		return -EINVAL;
224 
225 	*cur_state = cpufreq_get_cur_state(pr->id);
226 	if (pr->flags.throttling)
227 		*cur_state += pr->throttling.state;
228 	return 0;
229 }
230 
231 static int
232 processor_set_cur_state(struct thermal_cooling_device *cdev,
233 			unsigned long state)
234 {
235 	struct acpi_device *device = cdev->devdata;
236 	struct acpi_processor *pr;
237 	int result = 0;
238 	int max_pstate;
239 
240 	if (!device)
241 		return -EINVAL;
242 
243 	pr = acpi_driver_data(device);
244 	if (!pr)
245 		return -EINVAL;
246 
247 	max_pstate = cpufreq_get_max_state(pr->id);
248 
249 	if (state > acpi_processor_max_state(pr))
250 		return -EINVAL;
251 
252 	if (state <= max_pstate) {
253 		if (pr->flags.throttling && pr->throttling.state)
254 			result = acpi_processor_set_throttling(pr, 0, false);
255 		cpufreq_set_cur_state(pr->id, state);
256 	} else {
257 		cpufreq_set_cur_state(pr->id, max_pstate);
258 		result = acpi_processor_set_throttling(pr,
259 				state - max_pstate, false);
260 	}
261 	return result;
262 }
263 
264 const struct thermal_cooling_device_ops processor_cooling_ops = {
265 	.get_max_state = processor_get_max_state,
266 	.get_cur_state = processor_get_cur_state,
267 	.set_cur_state = processor_set_cur_state,
268 };
269