1 /*
2  * This file provides the ACPI based P-state support. This
3  * module works with generic cpufreq infrastructure. Most of
4  * the code is based on i386 version
5  * (arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c)
6  *
7  * Copyright (C) 2005 Intel Corp
8  *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
9  */
10 
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/cpufreq.h>
18 #include <linux/proc_fs.h>
19 #include <linux/seq_file.h>
20 #include <asm/io.h>
21 #include <linux/uaccess.h>
22 #include <asm/pal.h>
23 
24 #include <linux/acpi.h>
25 #include <acpi/processor.h>
26 
27 MODULE_AUTHOR("Venkatesh Pallipadi");
28 MODULE_DESCRIPTION("ACPI Processor P-States Driver");
29 MODULE_LICENSE("GPL");
30 
31 
32 struct cpufreq_acpi_io {
33 	struct acpi_processor_performance	acpi_data;
34 	unsigned int				resume;
35 };
36 
37 struct cpufreq_acpi_req {
38 	unsigned int		cpu;
39 	unsigned int		state;
40 };
41 
42 static struct cpufreq_acpi_io	*acpi_io_data[NR_CPUS];
43 
44 static struct cpufreq_driver acpi_cpufreq_driver;
45 
46 
47 static int
48 processor_set_pstate (
49 	u32	value)
50 {
51 	s64 retval;
52 
53 	pr_debug("processor_set_pstate\n");
54 
55 	retval = ia64_pal_set_pstate((u64)value);
56 
57 	if (retval) {
58 		pr_debug("Failed to set freq to 0x%x, with error 0x%lx\n",
59 		        value, retval);
60 		return -ENODEV;
61 	}
62 	return (int)retval;
63 }
64 
65 
66 static int
67 processor_get_pstate (
68 	u32	*value)
69 {
70 	u64	pstate_index = 0;
71 	s64 	retval;
72 
73 	pr_debug("processor_get_pstate\n");
74 
75 	retval = ia64_pal_get_pstate(&pstate_index,
76 	                             PAL_GET_PSTATE_TYPE_INSTANT);
77 	*value = (u32) pstate_index;
78 
79 	if (retval)
80 		pr_debug("Failed to get current freq with "
81 			"error 0x%lx, idx 0x%x\n", retval, *value);
82 
83 	return (int)retval;
84 }
85 
86 
87 /* To be used only after data->acpi_data is initialized */
88 static unsigned
89 extract_clock (
90 	struct cpufreq_acpi_io *data,
91 	unsigned value)
92 {
93 	unsigned long i;
94 
95 	pr_debug("extract_clock\n");
96 
97 	for (i = 0; i < data->acpi_data.state_count; i++) {
98 		if (value == data->acpi_data.states[i].status)
99 			return data->acpi_data.states[i].core_frequency;
100 	}
101 	return data->acpi_data.states[i-1].core_frequency;
102 }
103 
104 
105 static long
106 processor_get_freq (
107 	void *arg)
108 {
109 	struct cpufreq_acpi_req *req = arg;
110 	unsigned int		cpu = req->cpu;
111 	struct cpufreq_acpi_io	*data = acpi_io_data[cpu];
112 	u32			value;
113 	int			ret;
114 
115 	pr_debug("processor_get_freq\n");
116 	if (smp_processor_id() != cpu)
117 		return -EAGAIN;
118 
119 	/* processor_get_pstate gets the instantaneous frequency */
120 	ret = processor_get_pstate(&value);
121 	if (ret) {
122 		pr_warn("get performance failed with error %d\n", ret);
123 		return ret;
124 	}
125 	return 1000 * extract_clock(data, value);
126 }
127 
128 
129 static long
130 processor_set_freq (
131 	void *arg)
132 {
133 	struct cpufreq_acpi_req *req = arg;
134 	unsigned int		cpu = req->cpu;
135 	struct cpufreq_acpi_io	*data = acpi_io_data[cpu];
136 	int			ret, state = req->state;
137 	u32			value;
138 
139 	pr_debug("processor_set_freq\n");
140 	if (smp_processor_id() != cpu)
141 		return -EAGAIN;
142 
143 	if (state == data->acpi_data.state) {
144 		if (unlikely(data->resume)) {
145 			pr_debug("Called after resume, resetting to P%d\n", state);
146 			data->resume = 0;
147 		} else {
148 			pr_debug("Already at target state (P%d)\n", state);
149 			return 0;
150 		}
151 	}
152 
153 	pr_debug("Transitioning from P%d to P%d\n",
154 		data->acpi_data.state, state);
155 
156 	/*
157 	 * First we write the target state's 'control' value to the
158 	 * control_register.
159 	 */
160 	value = (u32) data->acpi_data.states[state].control;
161 
162 	pr_debug("Transitioning to state: 0x%08x\n", value);
163 
164 	ret = processor_set_pstate(value);
165 	if (ret) {
166 		pr_warn("Transition failed with error %d\n", ret);
167 		return -ENODEV;
168 	}
169 
170 	data->acpi_data.state = state;
171 	return 0;
172 }
173 
174 
175 static unsigned int
176 acpi_cpufreq_get (
177 	unsigned int		cpu)
178 {
179 	struct cpufreq_acpi_req req;
180 	long ret;
181 
182 	req.cpu = cpu;
183 	ret = work_on_cpu(cpu, processor_get_freq, &req);
184 
185 	return ret > 0 ? (unsigned int) ret : 0;
186 }
187 
188 
189 static int
190 acpi_cpufreq_target (
191 	struct cpufreq_policy   *policy,
192 	unsigned int index)
193 {
194 	struct cpufreq_acpi_req req;
195 
196 	req.cpu = policy->cpu;
197 	req.state = index;
198 
199 	return work_on_cpu(req.cpu, processor_set_freq, &req);
200 }
201 
202 static int
203 acpi_cpufreq_cpu_init (
204 	struct cpufreq_policy   *policy)
205 {
206 	unsigned int		i;
207 	unsigned int		cpu = policy->cpu;
208 	struct cpufreq_acpi_io	*data;
209 	unsigned int		result = 0;
210 	struct cpufreq_frequency_table *freq_table;
211 
212 	pr_debug("acpi_cpufreq_cpu_init\n");
213 
214 	data = kzalloc(sizeof(*data), GFP_KERNEL);
215 	if (!data)
216 		return (-ENOMEM);
217 
218 	acpi_io_data[cpu] = data;
219 
220 	result = acpi_processor_register_performance(&data->acpi_data, cpu);
221 
222 	if (result)
223 		goto err_free;
224 
225 	/* capability check */
226 	if (data->acpi_data.state_count <= 1) {
227 		pr_debug("No P-States\n");
228 		result = -ENODEV;
229 		goto err_unreg;
230 	}
231 
232 	if ((data->acpi_data.control_register.space_id !=
233 					ACPI_ADR_SPACE_FIXED_HARDWARE) ||
234 	    (data->acpi_data.status_register.space_id !=
235 					ACPI_ADR_SPACE_FIXED_HARDWARE)) {
236 		pr_debug("Unsupported address space [%d, %d]\n",
237 			(u32) (data->acpi_data.control_register.space_id),
238 			(u32) (data->acpi_data.status_register.space_id));
239 		result = -ENODEV;
240 		goto err_unreg;
241 	}
242 
243 	/* alloc freq_table */
244 	freq_table = kzalloc(sizeof(*freq_table) *
245 	                           (data->acpi_data.state_count + 1),
246 	                           GFP_KERNEL);
247 	if (!freq_table) {
248 		result = -ENOMEM;
249 		goto err_unreg;
250 	}
251 
252 	/* detect transition latency */
253 	policy->cpuinfo.transition_latency = 0;
254 	for (i=0; i<data->acpi_data.state_count; i++) {
255 		if ((data->acpi_data.states[i].transition_latency * 1000) >
256 		    policy->cpuinfo.transition_latency) {
257 			policy->cpuinfo.transition_latency =
258 			    data->acpi_data.states[i].transition_latency * 1000;
259 		}
260 	}
261 
262 	/* table init */
263 	for (i = 0; i <= data->acpi_data.state_count; i++)
264 	{
265 		if (i < data->acpi_data.state_count) {
266 			freq_table[i].frequency =
267 			      data->acpi_data.states[i].core_frequency * 1000;
268 		} else {
269 			freq_table[i].frequency = CPUFREQ_TABLE_END;
270 		}
271 	}
272 
273 	result = cpufreq_table_validate_and_show(policy, freq_table);
274 	if (result) {
275 		goto err_freqfree;
276 	}
277 
278 	/* notify BIOS that we exist */
279 	acpi_processor_notify_smm(THIS_MODULE);
280 
281 	pr_info("CPU%u - ACPI performance management activated\n", cpu);
282 
283 	for (i = 0; i < data->acpi_data.state_count; i++)
284 		pr_debug("     %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n",
285 			(i == data->acpi_data.state?'*':' '), i,
286 			(u32) data->acpi_data.states[i].core_frequency,
287 			(u32) data->acpi_data.states[i].power,
288 			(u32) data->acpi_data.states[i].transition_latency,
289 			(u32) data->acpi_data.states[i].bus_master_latency,
290 			(u32) data->acpi_data.states[i].status,
291 			(u32) data->acpi_data.states[i].control);
292 
293 	/* the first call to ->target() should result in us actually
294 	 * writing something to the appropriate registers. */
295 	data->resume = 1;
296 
297 	return (result);
298 
299  err_freqfree:
300 	kfree(freq_table);
301  err_unreg:
302 	acpi_processor_unregister_performance(cpu);
303  err_free:
304 	kfree(data);
305 	acpi_io_data[cpu] = NULL;
306 
307 	return (result);
308 }
309 
310 
311 static int
312 acpi_cpufreq_cpu_exit (
313 	struct cpufreq_policy   *policy)
314 {
315 	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
316 
317 	pr_debug("acpi_cpufreq_cpu_exit\n");
318 
319 	if (data) {
320 		acpi_io_data[policy->cpu] = NULL;
321 		acpi_processor_unregister_performance(policy->cpu);
322 		kfree(policy->freq_table);
323 		kfree(data);
324 	}
325 
326 	return (0);
327 }
328 
329 
330 static struct cpufreq_driver acpi_cpufreq_driver = {
331 	.verify 	= cpufreq_generic_frequency_table_verify,
332 	.target_index	= acpi_cpufreq_target,
333 	.get 		= acpi_cpufreq_get,
334 	.init		= acpi_cpufreq_cpu_init,
335 	.exit		= acpi_cpufreq_cpu_exit,
336 	.name		= "acpi-cpufreq",
337 	.attr		= cpufreq_generic_attr,
338 };
339 
340 
341 static int __init
342 acpi_cpufreq_init (void)
343 {
344 	pr_debug("acpi_cpufreq_init\n");
345 
346  	return cpufreq_register_driver(&acpi_cpufreq_driver);
347 }
348 
349 
350 static void __exit
351 acpi_cpufreq_exit (void)
352 {
353 	pr_debug("acpi_cpufreq_exit\n");
354 
355 	cpufreq_unregister_driver(&acpi_cpufreq_driver);
356 	return;
357 }
358 
359 
360 late_initcall(acpi_cpufreq_init);
361 module_exit(acpi_cpufreq_exit);
362 
363