1 /*
2  * processor_thermal.c - Passive cooling submodule of the ACPI processor driver
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
7  *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
8  *  			- Added processor hotplug support
9  *
10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or (at
15  *  your option) any later version.
16  *
17  *  This program is distributed in the hope that it will be useful, but
18  *  WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  *  General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License along
23  *  with this program; if not, write to the Free Software Foundation, Inc.,
24  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25  *
26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27  */
28 
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/cpufreq.h>
33 
34 #include <asm/uaccess.h>
35 
36 #include <acpi/acpi_bus.h>
37 #include <acpi/processor.h>
38 #include <acpi/acpi_drivers.h>
39 
40 #define PREFIX "ACPI: "
41 
42 #define ACPI_PROCESSOR_CLASS            "processor"
43 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
44 ACPI_MODULE_NAME("processor_thermal");
45 
46 #ifdef CONFIG_CPU_FREQ
47 
48 /* If a passive cooling situation is detected, primarily CPUfreq is used, as it
49  * offers (in most cases) voltage scaling in addition to frequency scaling, and
50  * thus a cubic (instead of linear) reduction of energy. Also, we allow for
51  * _any_ cpufreq driver and not only the acpi-cpufreq driver.
52  */
53 
54 #define CPUFREQ_THERMAL_MIN_STEP 0
55 #define CPUFREQ_THERMAL_MAX_STEP 3
56 
57 static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg);
58 static unsigned int acpi_thermal_cpufreq_is_init = 0;
59 
60 #define reduction_pctg(cpu) \
61 	per_cpu(cpufreq_thermal_reduction_pctg, phys_package_first_cpu(cpu))
62 
63 /*
64  * Emulate "per package data" using per cpu data (which should really be
65  * provided elsewhere)
66  *
67  * Note we can lose a CPU on cpu hotunplug, in this case we forget the state
68  * temporarily. Fortunately that's not a big issue here (I hope)
69  */
70 static int phys_package_first_cpu(int cpu)
71 {
72 	int i;
73 	int id = topology_physical_package_id(cpu);
74 
75 	for_each_online_cpu(i)
76 		if (topology_physical_package_id(i) == id)
77 			return i;
78 	return 0;
79 }
80 
81 static int cpu_has_cpufreq(unsigned int cpu)
82 {
83 	struct cpufreq_policy policy;
84 	if (!acpi_thermal_cpufreq_is_init || cpufreq_get_policy(&policy, cpu))
85 		return 0;
86 	return 1;
87 }
88 
89 static int acpi_thermal_cpufreq_notifier(struct notifier_block *nb,
90 					 unsigned long event, void *data)
91 {
92 	struct cpufreq_policy *policy = data;
93 	unsigned long max_freq = 0;
94 
95 	if (event != CPUFREQ_ADJUST)
96 		goto out;
97 
98 	max_freq = (
99 	    policy->cpuinfo.max_freq *
100 	    (100 - reduction_pctg(policy->cpu) * 20)
101 	) / 100;
102 
103 	cpufreq_verify_within_limits(policy, 0, max_freq);
104 
105       out:
106 	return 0;
107 }
108 
109 static struct notifier_block acpi_thermal_cpufreq_notifier_block = {
110 	.notifier_call = acpi_thermal_cpufreq_notifier,
111 };
112 
113 static int cpufreq_get_max_state(unsigned int cpu)
114 {
115 	if (!cpu_has_cpufreq(cpu))
116 		return 0;
117 
118 	return CPUFREQ_THERMAL_MAX_STEP;
119 }
120 
121 static int cpufreq_get_cur_state(unsigned int cpu)
122 {
123 	if (!cpu_has_cpufreq(cpu))
124 		return 0;
125 
126 	return reduction_pctg(cpu);
127 }
128 
129 static int cpufreq_set_cur_state(unsigned int cpu, int state)
130 {
131 	int i;
132 
133 	if (!cpu_has_cpufreq(cpu))
134 		return 0;
135 
136 	reduction_pctg(cpu) = state;
137 
138 	/*
139 	 * Update all the CPUs in the same package because they all
140 	 * contribute to the temperature and often share the same
141 	 * frequency.
142 	 */
143 	for_each_online_cpu(i) {
144 		if (topology_physical_package_id(i) ==
145 		    topology_physical_package_id(cpu))
146 			cpufreq_update_policy(i);
147 	}
148 	return 0;
149 }
150 
151 void acpi_thermal_cpufreq_init(void)
152 {
153 	int i;
154 
155 	i = cpufreq_register_notifier(&acpi_thermal_cpufreq_notifier_block,
156 				      CPUFREQ_POLICY_NOTIFIER);
157 	if (!i)
158 		acpi_thermal_cpufreq_is_init = 1;
159 }
160 
161 void acpi_thermal_cpufreq_exit(void)
162 {
163 	if (acpi_thermal_cpufreq_is_init)
164 		cpufreq_unregister_notifier
165 		    (&acpi_thermal_cpufreq_notifier_block,
166 		     CPUFREQ_POLICY_NOTIFIER);
167 
168 	acpi_thermal_cpufreq_is_init = 0;
169 }
170 
171 #else				/* ! CONFIG_CPU_FREQ */
172 static int cpufreq_get_max_state(unsigned int cpu)
173 {
174 	return 0;
175 }
176 
177 static int cpufreq_get_cur_state(unsigned int cpu)
178 {
179 	return 0;
180 }
181 
182 static int cpufreq_set_cur_state(unsigned int cpu, int state)
183 {
184 	return 0;
185 }
186 
187 #endif
188 
189 int acpi_processor_get_limit_info(struct acpi_processor *pr)
190 {
191 
192 	if (!pr)
193 		return -EINVAL;
194 
195 	if (pr->flags.throttling)
196 		pr->flags.limit = 1;
197 
198 	return 0;
199 }
200 
201 /* thermal coolign device callbacks */
202 static int acpi_processor_max_state(struct acpi_processor *pr)
203 {
204 	int max_state = 0;
205 
206 	/*
207 	 * There exists four states according to
208 	 * cpufreq_thermal_reduction_ptg. 0, 1, 2, 3
209 	 */
210 	max_state += cpufreq_get_max_state(pr->id);
211 	if (pr->flags.throttling)
212 		max_state += (pr->throttling.state_count -1);
213 
214 	return max_state;
215 }
216 static int
217 processor_get_max_state(struct thermal_cooling_device *cdev,
218 			unsigned long *state)
219 {
220 	struct acpi_device *device = cdev->devdata;
221 	struct acpi_processor *pr = acpi_driver_data(device);
222 
223 	if (!device || !pr)
224 		return -EINVAL;
225 
226 	*state = acpi_processor_max_state(pr);
227 	return 0;
228 }
229 
230 static int
231 processor_get_cur_state(struct thermal_cooling_device *cdev,
232 			unsigned long *cur_state)
233 {
234 	struct acpi_device *device = cdev->devdata;
235 	struct acpi_processor *pr = acpi_driver_data(device);
236 
237 	if (!device || !pr)
238 		return -EINVAL;
239 
240 	*cur_state = cpufreq_get_cur_state(pr->id);
241 	if (pr->flags.throttling)
242 		*cur_state += pr->throttling.state;
243 	return 0;
244 }
245 
246 static int
247 processor_set_cur_state(struct thermal_cooling_device *cdev,
248 			unsigned long state)
249 {
250 	struct acpi_device *device = cdev->devdata;
251 	struct acpi_processor *pr = acpi_driver_data(device);
252 	int result = 0;
253 	int max_pstate;
254 
255 	if (!device || !pr)
256 		return -EINVAL;
257 
258 	max_pstate = cpufreq_get_max_state(pr->id);
259 
260 	if (state > acpi_processor_max_state(pr))
261 		return -EINVAL;
262 
263 	if (state <= max_pstate) {
264 		if (pr->flags.throttling && pr->throttling.state)
265 			result = acpi_processor_set_throttling(pr, 0, false);
266 		cpufreq_set_cur_state(pr->id, state);
267 	} else {
268 		cpufreq_set_cur_state(pr->id, max_pstate);
269 		result = acpi_processor_set_throttling(pr,
270 				state - max_pstate, false);
271 	}
272 	return result;
273 }
274 
275 const struct thermal_cooling_device_ops processor_cooling_ops = {
276 	.get_max_state = processor_get_max_state,
277 	.get_cur_state = processor_get_cur_state,
278 	.set_cur_state = processor_set_cur_state,
279 };
280