ia64-acpi-cpufreq.c 9.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * This file provides the ACPI based P-state support. This
 * module works with generic cpufreq infrastructure. Most of
 * the code is based on i386 version
 * (arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c)
 *
 * Copyright (C) 2005 Intel Corp
 *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
 */

#include <linux/kernel.h>
12
#include <linux/slab.h>
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/pal.h>

#include <linux/acpi.h>
#include <acpi/processor.h>

MODULE_AUTHOR("Venkatesh Pallipadi");
MODULE_DESCRIPTION("ACPI Processor P-States Driver");
MODULE_LICENSE("GPL");


struct cpufreq_acpi_io {
	struct acpi_processor_performance	acpi_data;
	struct cpufreq_frequency_table		*freq_table;
	unsigned int				resume;
};

static struct cpufreq_acpi_io	*acpi_io_data[NR_CPUS];

static struct cpufreq_driver acpi_cpufreq_driver;


static int
processor_set_pstate (
	u32	value)
{
	s64 retval;

47
	pr_debug("processor_set_pstate\n");
48 49 50 51

	retval = ia64_pal_set_pstate((u64)value);

	if (retval) {
52
		pr_debug("Failed to set freq to 0x%x, with error 0x%lx\n",
53 54 55 56 57 58 59 60 61 62 63 64 65 66
		        value, retval);
		return -ENODEV;
	}
	return (int)retval;
}


static int
processor_get_pstate (
	u32	*value)
{
	u64	pstate_index = 0;
	s64 	retval;

67
	pr_debug("processor_get_pstate\n");
68

69 70
	retval = ia64_pal_get_pstate(&pstate_index,
	                             PAL_GET_PSTATE_TYPE_INSTANT);
71 72 73
	*value = (u32) pstate_index;

	if (retval)
74
		pr_debug("Failed to get current freq with "
75
			"error 0x%lx, idx 0x%x\n", retval, *value);
76 77 78 79 80 81 82 83 84 85 86 87 88 89

	return (int)retval;
}


/* To be used only after data->acpi_data is initialized */
static unsigned
extract_clock (
	struct cpufreq_acpi_io *data,
	unsigned value,
	unsigned int cpu)
{
	unsigned long i;

90
	pr_debug("extract_clock\n");
91 92

	for (i = 0; i < data->acpi_data.state_count; i++) {
93
		if (value == data->acpi_data.states[i].status)
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
			return data->acpi_data.states[i].core_frequency;
	}
	return data->acpi_data.states[i-1].core_frequency;
}


static unsigned int
processor_get_freq (
	struct cpufreq_acpi_io	*data,
	unsigned int		cpu)
{
	int			ret = 0;
	u32			value = 0;
	cpumask_t		saved_mask;
	unsigned long 		clock_freq;

110
	pr_debug("processor_get_freq\n");
111 112

	saved_mask = current->cpus_allowed;
J
Julia Lawall 已提交
113
	set_cpus_allowed_ptr(current, cpumask_of(cpu));
A
Alex Williamson 已提交
114
	if (smp_processor_id() != cpu)
115 116
		goto migrate_end;

117
	/* processor_get_pstate gets the instantaneous frequency */
118 119 120
	ret = processor_get_pstate(&value);

	if (ret) {
J
Julia Lawall 已提交
121
		set_cpus_allowed_ptr(current, &saved_mask);
122 123
		printk(KERN_WARNING "get performance failed with error %d\n",
		       ret);
A
Alex Williamson 已提交
124
		ret = 0;
125 126 127 128 129 130
		goto migrate_end;
	}
	clock_freq = extract_clock(data, value, cpu);
	ret = (clock_freq*1000);

migrate_end:
J
Julia Lawall 已提交
131
	set_cpus_allowed_ptr(current, &saved_mask);
132 133 134 135 136 137 138
	return ret;
}


static int
processor_set_freq (
	struct cpufreq_acpi_io	*data,
139
	struct cpufreq_policy   *policy,
140 141 142 143 144 145 146 147
	int			state)
{
	int			ret = 0;
	u32			value = 0;
	struct cpufreq_freqs    cpufreq_freqs;
	cpumask_t		saved_mask;
	int			retval;

148
	pr_debug("processor_set_freq\n");
149 150

	saved_mask = current->cpus_allowed;
151 152
	set_cpus_allowed_ptr(current, cpumask_of(policy->cpu));
	if (smp_processor_id() != policy->cpu) {
153 154 155 156 157 158
		retval = -EAGAIN;
		goto migrate_end;
	}

	if (state == data->acpi_data.state) {
		if (unlikely(data->resume)) {
159
			pr_debug("Called after resume, resetting to P%d\n", state);
160 161
			data->resume = 0;
		} else {
162
			pr_debug("Already at target state (P%d)\n", state);
163 164 165 166 167
			retval = 0;
			goto migrate_end;
		}
	}

168
	pr_debug("Transitioning from P%d to P%d\n",
169 170 171 172 173 174 175
		data->acpi_data.state, state);

	/* cpufreq frequency struct */
	cpufreq_freqs.old = data->freq_table[data->acpi_data.state].frequency;
	cpufreq_freqs.new = data->freq_table[state].frequency;

	/* notify cpufreq */
176
	cpufreq_notify_transition(policy, &cpufreq_freqs, CPUFREQ_PRECHANGE);
177 178 179 180 181 182 183 184

	/*
	 * First we write the target state's 'control' value to the
	 * control_register.
	 */

	value = (u32) data->acpi_data.states[state].control;

185
	pr_debug("Transitioning to state: 0x%08x\n", value);
186 187 188 189

	ret = processor_set_pstate(value);
	if (ret) {
		unsigned int tmp = cpufreq_freqs.new;
190 191
		cpufreq_notify_transition(policy, &cpufreq_freqs,
				CPUFREQ_POSTCHANGE);
192 193
		cpufreq_freqs.new = cpufreq_freqs.old;
		cpufreq_freqs.old = tmp;
194 195 196 197
		cpufreq_notify_transition(policy, &cpufreq_freqs,
				CPUFREQ_PRECHANGE);
		cpufreq_notify_transition(policy, &cpufreq_freqs,
				CPUFREQ_POSTCHANGE);
198 199 200 201 202
		printk(KERN_WARNING "Transition failed with error %d\n", ret);
		retval = -ENODEV;
		goto migrate_end;
	}

203
	cpufreq_notify_transition(policy, &cpufreq_freqs, CPUFREQ_POSTCHANGE);
204 205 206 207 208 209

	data->acpi_data.state = state;

	retval = 0;

migrate_end:
J
Julia Lawall 已提交
210
	set_cpus_allowed_ptr(current, &saved_mask);
211 212 213 214 215 216 217 218 219 220
	return (retval);
}


static unsigned int
acpi_cpufreq_get (
	unsigned int		cpu)
{
	struct cpufreq_acpi_io *data = acpi_io_data[cpu];

221
	pr_debug("acpi_cpufreq_get\n");
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236

	return processor_get_freq(data, cpu);
}


static int
acpi_cpufreq_target (
	struct cpufreq_policy   *policy,
	unsigned int target_freq,
	unsigned int relation)
{
	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
	unsigned int next_state = 0;
	unsigned int result = 0;

237
	pr_debug("acpi_cpufreq_setpolicy\n");
238 239 240 241 242 243

	result = cpufreq_frequency_table_target(policy,
			data->freq_table, target_freq, relation, &next_state);
	if (result)
		return (result);

244
	result = processor_set_freq(data, policy, next_state);
245 246 247 248 249 250 251 252 253 254 255 256

	return (result);
}


static int
acpi_cpufreq_verify (
	struct cpufreq_policy   *policy)
{
	unsigned int result = 0;
	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];

257
	pr_debug("acpi_cpufreq_verify\n");
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274

	result = cpufreq_frequency_table_verify(policy,
			data->freq_table);

	return (result);
}


static int
acpi_cpufreq_cpu_init (
	struct cpufreq_policy   *policy)
{
	unsigned int		i;
	unsigned int		cpu = policy->cpu;
	struct cpufreq_acpi_io	*data;
	unsigned int		result = 0;

275
	pr_debug("acpi_cpufreq_cpu_init\n");
276

277
	data = kzalloc(sizeof(*data), GFP_KERNEL);
278 279 280 281 282 283 284 285 286 287 288 289
	if (!data)
		return (-ENOMEM);

	acpi_io_data[cpu] = data;

	result = acpi_processor_register_performance(&data->acpi_data, cpu);

	if (result)
		goto err_free;

	/* capability check */
	if (data->acpi_data.state_count <= 1) {
290
		pr_debug("No P-States\n");
291 292 293 294 295 296 297 298
		result = -ENODEV;
		goto err_unreg;
	}

	if ((data->acpi_data.control_register.space_id !=
					ACPI_ADR_SPACE_FIXED_HARDWARE) ||
	    (data->acpi_data.status_register.space_id !=
					ACPI_ADR_SPACE_FIXED_HARDWARE)) {
299
		pr_debug("Unsupported address space [%d, %d]\n",
300 301 302 303 304 305 306
			(u32) (data->acpi_data.control_register.space_id),
			(u32) (data->acpi_data.status_register.space_id));
		result = -ENODEV;
		goto err_unreg;
	}

	/* alloc freq_table */
307
	data->freq_table = kmalloc(sizeof(*data->freq_table) *
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
	                           (data->acpi_data.state_count + 1),
	                           GFP_KERNEL);
	if (!data->freq_table) {
		result = -ENOMEM;
		goto err_unreg;
	}

	/* detect transition latency */
	policy->cpuinfo.transition_latency = 0;
	for (i=0; i<data->acpi_data.state_count; i++) {
		if ((data->acpi_data.states[i].transition_latency * 1000) >
		    policy->cpuinfo.transition_latency) {
			policy->cpuinfo.transition_latency =
			    data->acpi_data.states[i].transition_latency * 1000;
		}
	}
	policy->cur = processor_get_freq(data, policy->cpu);

	/* table init */
	for (i = 0; i <= data->acpi_data.state_count; i++)
	{
329
		data->freq_table[i].driver_data = i;
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
		if (i < data->acpi_data.state_count) {
			data->freq_table[i].frequency =
			      data->acpi_data.states[i].core_frequency * 1000;
		} else {
			data->freq_table[i].frequency = CPUFREQ_TABLE_END;
		}
	}

	result = cpufreq_frequency_table_cpuinfo(policy, data->freq_table);
	if (result) {
		goto err_freqfree;
	}

	/* notify BIOS that we exist */
	acpi_processor_notify_smm(THIS_MODULE);

	printk(KERN_INFO "acpi-cpufreq: CPU%u - ACPI performance management "
	       "activated.\n", cpu);

	for (i = 0; i < data->acpi_data.state_count; i++)
350
		pr_debug("     %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n",
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
			(i == data->acpi_data.state?'*':' '), i,
			(u32) data->acpi_data.states[i].core_frequency,
			(u32) data->acpi_data.states[i].power,
			(u32) data->acpi_data.states[i].transition_latency,
			(u32) data->acpi_data.states[i].bus_master_latency,
			(u32) data->acpi_data.states[i].status,
			(u32) data->acpi_data.states[i].control);

	cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);

	/* the first call to ->target() should result in us actually
	 * writing something to the appropriate registers. */
	data->resume = 1;

	return (result);

 err_freqfree:
	kfree(data->freq_table);
 err_unreg:
	acpi_processor_unregister_performance(&data->acpi_data, cpu);
 err_free:
	kfree(data);
	acpi_io_data[cpu] = NULL;

	return (result);
}


static int
acpi_cpufreq_cpu_exit (
	struct cpufreq_policy   *policy)
{
	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];

385
	pr_debug("acpi_cpufreq_cpu_exit\n");
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419

	if (data) {
		cpufreq_frequency_table_put_attr(policy->cpu);
		acpi_io_data[policy->cpu] = NULL;
		acpi_processor_unregister_performance(&data->acpi_data,
		                                      policy->cpu);
		kfree(data);
	}

	return (0);
}


static struct freq_attr* acpi_cpufreq_attr[] = {
	&cpufreq_freq_attr_scaling_available_freqs,
	NULL,
};


static struct cpufreq_driver acpi_cpufreq_driver = {
	.verify 	= acpi_cpufreq_verify,
	.target 	= acpi_cpufreq_target,
	.get 		= acpi_cpufreq_get,
	.init		= acpi_cpufreq_cpu_init,
	.exit		= acpi_cpufreq_cpu_exit,
	.name		= "acpi-cpufreq",
	.owner		= THIS_MODULE,
	.attr           = acpi_cpufreq_attr,
};


static int __init
acpi_cpufreq_init (void)
{
420
	pr_debug("acpi_cpufreq_init\n");
421 422 423 424 425 426 427 428

 	return cpufreq_register_driver(&acpi_cpufreq_driver);
}


static void __exit
acpi_cpufreq_exit (void)
{
429
	pr_debug("acpi_cpufreq_exit\n");
430 431 432 433 434 435 436 437 438

	cpufreq_unregister_driver(&acpi_cpufreq_driver);
	return;
}


late_initcall(acpi_cpufreq_init);
module_exit(acpi_cpufreq_exit);