1 /*
2  * processor_perflib.c - ACPI Processor P-States Library ($Revision: 71 $)
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  *
13  *  This program is free software; you can redistribute it and/or modify
14  *  it under the terms of the GNU General Public License as published by
15  *  the Free Software Foundation; either version 2 of the License, or (at
16  *  your option) any later version.
17  *
18  *  This program is distributed in the hope that it will be useful, but
19  *  WITHOUT ANY WARRANTY; without even the implied warranty of
20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21  *  General Public License for more details.
22  *
23  *  You should have received a copy of the GNU General Public License along
24  *  with this program; if not, write to the Free Software Foundation, Inc.,
25  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
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 #ifdef CONFIG_X86
35 #include <asm/cpufeature.h>
36 #endif
37 
38 #include <acpi/acpi_bus.h>
39 #include <acpi/acpi_drivers.h>
40 #include <acpi/processor.h>
41 
42 #define PREFIX "ACPI: "
43 
44 #define ACPI_PROCESSOR_CLASS		"processor"
45 #define ACPI_PROCESSOR_FILE_PERFORMANCE	"performance"
46 #define _COMPONENT		ACPI_PROCESSOR_COMPONENT
47 ACPI_MODULE_NAME("processor_perflib");
48 
49 static DEFINE_MUTEX(performance_mutex);
50 
51 /* Use cpufreq debug layer for _PPC changes. */
52 #define cpufreq_printk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
53 						"cpufreq-core", msg)
54 
55 /*
56  * _PPC support is implemented as a CPUfreq policy notifier:
57  * This means each time a CPUfreq driver registered also with
58  * the ACPI core is asked to change the speed policy, the maximum
59  * value is adjusted so that it is within the platform limit.
60  *
61  * Also, when a new platform limit value is detected, the CPUfreq
62  * policy is adjusted accordingly.
63  */
64 
65 /* ignore_ppc:
66  * -1 -> cpufreq low level drivers not initialized -> _PSS, etc. not called yet
67  *       ignore _PPC
68  *  0 -> cpufreq low level drivers initialized -> consider _PPC values
69  *  1 -> ignore _PPC totally -> forced by user through boot param
70  */
71 static int ignore_ppc = -1;
72 module_param(ignore_ppc, int, 0644);
73 MODULE_PARM_DESC(ignore_ppc, "If the frequency of your machine gets wrongly" \
74 		 "limited by BIOS, this should help");
75 
76 #define PPC_REGISTERED   1
77 #define PPC_IN_USE       2
78 
79 static int acpi_processor_ppc_status;
80 
81 static int acpi_processor_ppc_notifier(struct notifier_block *nb,
82 				       unsigned long event, void *data)
83 {
84 	struct cpufreq_policy *policy = data;
85 	struct acpi_processor *pr;
86 	unsigned int ppc = 0;
87 
88 	if (event == CPUFREQ_START && ignore_ppc <= 0) {
89 		ignore_ppc = 0;
90 		return 0;
91 	}
92 
93 	if (ignore_ppc)
94 		return 0;
95 
96 	if (event != CPUFREQ_INCOMPATIBLE)
97 		return 0;
98 
99 	mutex_lock(&performance_mutex);
100 
101 	pr = per_cpu(processors, policy->cpu);
102 	if (!pr || !pr->performance)
103 		goto out;
104 
105 	ppc = (unsigned int)pr->performance_platform_limit;
106 
107 	if (ppc >= pr->performance->state_count)
108 		goto out;
109 
110 	cpufreq_verify_within_limits(policy, 0,
111 				     pr->performance->states[ppc].
112 				     core_frequency * 1000);
113 
114       out:
115 	mutex_unlock(&performance_mutex);
116 
117 	return 0;
118 }
119 
120 static struct notifier_block acpi_ppc_notifier_block = {
121 	.notifier_call = acpi_processor_ppc_notifier,
122 };
123 
124 static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
125 {
126 	acpi_status status = 0;
127 	unsigned long long ppc = 0;
128 
129 
130 	if (!pr)
131 		return -EINVAL;
132 
133 	/*
134 	 * _PPC indicates the maximum state currently supported by the platform
135 	 * (e.g. 0 = states 0..n; 1 = states 1..n; etc.
136 	 */
137 	status = acpi_evaluate_integer(pr->handle, "_PPC", NULL, &ppc);
138 
139 	if (status != AE_NOT_FOUND)
140 		acpi_processor_ppc_status |= PPC_IN_USE;
141 
142 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
143 		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PPC"));
144 		return -ENODEV;
145 	}
146 
147 	cpufreq_printk("CPU %d: _PPC is %d - frequency %s limited\n", pr->id,
148 		       (int)ppc, ppc ? "" : "not");
149 
150 	pr->performance_platform_limit = (int)ppc;
151 
152 	return 0;
153 }
154 
155 #define ACPI_PROCESSOR_NOTIFY_PERFORMANCE	0x80
156 /*
157  * acpi_processor_ppc_ost: Notify firmware the _PPC evaluation status
158  * @handle: ACPI processor handle
159  * @status: the status code of _PPC evaluation
160  *	0: success. OSPM is now using the performance state specificed.
161  *	1: failure. OSPM has not changed the number of P-states in use
162  */
163 static void acpi_processor_ppc_ost(acpi_handle handle, int status)
164 {
165 	union acpi_object params[2] = {
166 		{.type = ACPI_TYPE_INTEGER,},
167 		{.type = ACPI_TYPE_INTEGER,},
168 	};
169 	struct acpi_object_list arg_list = {2, params};
170 	acpi_handle temp;
171 
172 	params[0].integer.value = ACPI_PROCESSOR_NOTIFY_PERFORMANCE;
173 	params[1].integer.value =  status;
174 
175 	/* when there is no _OST , skip it */
176 	if (ACPI_FAILURE(acpi_get_handle(handle, "_OST", &temp)))
177 		return;
178 
179 	acpi_evaluate_object(handle, "_OST", &arg_list, NULL);
180 	return;
181 }
182 
183 int acpi_processor_ppc_has_changed(struct acpi_processor *pr, int event_flag)
184 {
185 	int ret;
186 
187 	if (ignore_ppc) {
188 		/*
189 		 * Only when it is notification event, the _OST object
190 		 * will be evaluated. Otherwise it is skipped.
191 		 */
192 		if (event_flag)
193 			acpi_processor_ppc_ost(pr->handle, 1);
194 		return 0;
195 	}
196 
197 	ret = acpi_processor_get_platform_limit(pr);
198 	/*
199 	 * Only when it is notification event, the _OST object
200 	 * will be evaluated. Otherwise it is skipped.
201 	 */
202 	if (event_flag) {
203 		if (ret < 0)
204 			acpi_processor_ppc_ost(pr->handle, 1);
205 		else
206 			acpi_processor_ppc_ost(pr->handle, 0);
207 	}
208 	if (ret < 0)
209 		return (ret);
210 	else
211 		return cpufreq_update_policy(pr->id);
212 }
213 
214 int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)
215 {
216 	struct acpi_processor *pr;
217 
218 	pr = per_cpu(processors, cpu);
219 	if (!pr || !pr->performance || !pr->performance->state_count)
220 		return -ENODEV;
221 	*limit = pr->performance->states[pr->performance_platform_limit].
222 		core_frequency * 1000;
223 	return 0;
224 }
225 EXPORT_SYMBOL(acpi_processor_get_bios_limit);
226 
227 void acpi_processor_ppc_init(void)
228 {
229 	if (!cpufreq_register_notifier
230 	    (&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER))
231 		acpi_processor_ppc_status |= PPC_REGISTERED;
232 	else
233 		printk(KERN_DEBUG
234 		       "Warning: Processor Platform Limit not supported.\n");
235 }
236 
237 void acpi_processor_ppc_exit(void)
238 {
239 	if (acpi_processor_ppc_status & PPC_REGISTERED)
240 		cpufreq_unregister_notifier(&acpi_ppc_notifier_block,
241 					    CPUFREQ_POLICY_NOTIFIER);
242 
243 	acpi_processor_ppc_status &= ~PPC_REGISTERED;
244 }
245 
246 static int acpi_processor_get_performance_control(struct acpi_processor *pr)
247 {
248 	int result = 0;
249 	acpi_status status = 0;
250 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
251 	union acpi_object *pct = NULL;
252 	union acpi_object obj = { 0 };
253 
254 
255 	status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer);
256 	if (ACPI_FAILURE(status)) {
257 		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PCT"));
258 		return -ENODEV;
259 	}
260 
261 	pct = (union acpi_object *)buffer.pointer;
262 	if (!pct || (pct->type != ACPI_TYPE_PACKAGE)
263 	    || (pct->package.count != 2)) {
264 		printk(KERN_ERR PREFIX "Invalid _PCT data\n");
265 		result = -EFAULT;
266 		goto end;
267 	}
268 
269 	/*
270 	 * control_register
271 	 */
272 
273 	obj = pct->package.elements[0];
274 
275 	if ((obj.type != ACPI_TYPE_BUFFER)
276 	    || (obj.buffer.length < sizeof(struct acpi_pct_register))
277 	    || (obj.buffer.pointer == NULL)) {
278 		printk(KERN_ERR PREFIX "Invalid _PCT data (control_register)\n");
279 		result = -EFAULT;
280 		goto end;
281 	}
282 	memcpy(&pr->performance->control_register, obj.buffer.pointer,
283 	       sizeof(struct acpi_pct_register));
284 
285 	/*
286 	 * status_register
287 	 */
288 
289 	obj = pct->package.elements[1];
290 
291 	if ((obj.type != ACPI_TYPE_BUFFER)
292 	    || (obj.buffer.length < sizeof(struct acpi_pct_register))
293 	    || (obj.buffer.pointer == NULL)) {
294 		printk(KERN_ERR PREFIX "Invalid _PCT data (status_register)\n");
295 		result = -EFAULT;
296 		goto end;
297 	}
298 
299 	memcpy(&pr->performance->status_register, obj.buffer.pointer,
300 	       sizeof(struct acpi_pct_register));
301 
302       end:
303 	kfree(buffer.pointer);
304 
305 	return result;
306 }
307 
308 static int acpi_processor_get_performance_states(struct acpi_processor *pr)
309 {
310 	int result = 0;
311 	acpi_status status = AE_OK;
312 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
313 	struct acpi_buffer format = { sizeof("NNNNNN"), "NNNNNN" };
314 	struct acpi_buffer state = { 0, NULL };
315 	union acpi_object *pss = NULL;
316 	int i;
317 
318 
319 	status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer);
320 	if (ACPI_FAILURE(status)) {
321 		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PSS"));
322 		return -ENODEV;
323 	}
324 
325 	pss = buffer.pointer;
326 	if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
327 		printk(KERN_ERR PREFIX "Invalid _PSS data\n");
328 		result = -EFAULT;
329 		goto end;
330 	}
331 
332 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d performance states\n",
333 			  pss->package.count));
334 
335 	pr->performance->state_count = pss->package.count;
336 	pr->performance->states =
337 	    kmalloc(sizeof(struct acpi_processor_px) * pss->package.count,
338 		    GFP_KERNEL);
339 	if (!pr->performance->states) {
340 		result = -ENOMEM;
341 		goto end;
342 	}
343 
344 	for (i = 0; i < pr->performance->state_count; i++) {
345 
346 		struct acpi_processor_px *px = &(pr->performance->states[i]);
347 
348 		state.length = sizeof(struct acpi_processor_px);
349 		state.pointer = px;
350 
351 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
352 
353 		status = acpi_extract_package(&(pss->package.elements[i]),
354 					      &format, &state);
355 		if (ACPI_FAILURE(status)) {
356 			ACPI_EXCEPTION((AE_INFO, status, "Invalid _PSS data"));
357 			result = -EFAULT;
358 			kfree(pr->performance->states);
359 			goto end;
360 		}
361 
362 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
363 				  "State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n",
364 				  i,
365 				  (u32) px->core_frequency,
366 				  (u32) px->power,
367 				  (u32) px->transition_latency,
368 				  (u32) px->bus_master_latency,
369 				  (u32) px->control, (u32) px->status));
370 
371 		/*
372  		 * Check that ACPI's u64 MHz will be valid as u32 KHz in cpufreq
373 		 */
374 		if (!px->core_frequency ||
375 		    ((u32)(px->core_frequency * 1000) !=
376 		     (px->core_frequency * 1000))) {
377 			printk(KERN_ERR FW_BUG PREFIX
378 			       "Invalid BIOS _PSS frequency: 0x%llx MHz\n",
379 			       px->core_frequency);
380 			result = -EFAULT;
381 			kfree(pr->performance->states);
382 			goto end;
383 		}
384 	}
385 
386       end:
387 	kfree(buffer.pointer);
388 
389 	return result;
390 }
391 
392 static int acpi_processor_get_performance_info(struct acpi_processor *pr)
393 {
394 	int result = 0;
395 	acpi_status status = AE_OK;
396 	acpi_handle handle = NULL;
397 
398 	if (!pr || !pr->performance || !pr->handle)
399 		return -EINVAL;
400 
401 	status = acpi_get_handle(pr->handle, "_PCT", &handle);
402 	if (ACPI_FAILURE(status)) {
403 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
404 				  "ACPI-based processor performance control unavailable\n"));
405 		return -ENODEV;
406 	}
407 
408 	result = acpi_processor_get_performance_control(pr);
409 	if (result)
410 		goto update_bios;
411 
412 	result = acpi_processor_get_performance_states(pr);
413 	if (result)
414 		goto update_bios;
415 
416 	return 0;
417 
418 	/*
419 	 * Having _PPC but missing frequencies (_PSS, _PCT) is a very good hint that
420 	 * the BIOS is older than the CPU and does not know its frequencies
421 	 */
422  update_bios:
423 #ifdef CONFIG_X86
424 	if (ACPI_SUCCESS(acpi_get_handle(pr->handle, "_PPC", &handle))){
425 		if(boot_cpu_has(X86_FEATURE_EST))
426 			printk(KERN_WARNING FW_BUG "BIOS needs update for CPU "
427 			       "frequency support\n");
428 	}
429 #endif
430 	return result;
431 }
432 
433 int acpi_processor_notify_smm(struct module *calling_module)
434 {
435 	acpi_status status;
436 	static int is_done = 0;
437 
438 
439 	if (!(acpi_processor_ppc_status & PPC_REGISTERED))
440 		return -EBUSY;
441 
442 	if (!try_module_get(calling_module))
443 		return -EINVAL;
444 
445 	/* is_done is set to negative if an error occured,
446 	 * and to postitive if _no_ error occured, but SMM
447 	 * was already notified. This avoids double notification
448 	 * which might lead to unexpected results...
449 	 */
450 	if (is_done > 0) {
451 		module_put(calling_module);
452 		return 0;
453 	} else if (is_done < 0) {
454 		module_put(calling_module);
455 		return is_done;
456 	}
457 
458 	is_done = -EIO;
459 
460 	/* Can't write pstate_control to smi_command if either value is zero */
461 	if ((!acpi_gbl_FADT.smi_command) || (!acpi_gbl_FADT.pstate_control)) {
462 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No SMI port or pstate_control\n"));
463 		module_put(calling_module);
464 		return 0;
465 	}
466 
467 	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
468 			  "Writing pstate_control [0x%x] to smi_command [0x%x]\n",
469 			  acpi_gbl_FADT.pstate_control, acpi_gbl_FADT.smi_command));
470 
471 	status = acpi_os_write_port(acpi_gbl_FADT.smi_command,
472 				    (u32) acpi_gbl_FADT.pstate_control, 8);
473 	if (ACPI_FAILURE(status)) {
474 		ACPI_EXCEPTION((AE_INFO, status,
475 				"Failed to write pstate_control [0x%x] to "
476 				"smi_command [0x%x]", acpi_gbl_FADT.pstate_control,
477 				acpi_gbl_FADT.smi_command));
478 		module_put(calling_module);
479 		return status;
480 	}
481 
482 	/* Success. If there's no _PPC, we need to fear nothing, so
483 	 * we can allow the cpufreq driver to be rmmod'ed. */
484 	is_done = 1;
485 
486 	if (!(acpi_processor_ppc_status & PPC_IN_USE))
487 		module_put(calling_module);
488 
489 	return 0;
490 }
491 
492 EXPORT_SYMBOL(acpi_processor_notify_smm);
493 
494 static int acpi_processor_get_psd(struct acpi_processor	*pr)
495 {
496 	int result = 0;
497 	acpi_status status = AE_OK;
498 	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
499 	struct acpi_buffer format = {sizeof("NNNNN"), "NNNNN"};
500 	struct acpi_buffer state = {0, NULL};
501 	union acpi_object  *psd = NULL;
502 	struct acpi_psd_package *pdomain;
503 
504 	status = acpi_evaluate_object(pr->handle, "_PSD", NULL, &buffer);
505 	if (ACPI_FAILURE(status)) {
506 		return -ENODEV;
507 	}
508 
509 	psd = buffer.pointer;
510 	if (!psd || (psd->type != ACPI_TYPE_PACKAGE)) {
511 		printk(KERN_ERR PREFIX "Invalid _PSD data\n");
512 		result = -EFAULT;
513 		goto end;
514 	}
515 
516 	if (psd->package.count != 1) {
517 		printk(KERN_ERR PREFIX "Invalid _PSD data\n");
518 		result = -EFAULT;
519 		goto end;
520 	}
521 
522 	pdomain = &(pr->performance->domain_info);
523 
524 	state.length = sizeof(struct acpi_psd_package);
525 	state.pointer = pdomain;
526 
527 	status = acpi_extract_package(&(psd->package.elements[0]),
528 		&format, &state);
529 	if (ACPI_FAILURE(status)) {
530 		printk(KERN_ERR PREFIX "Invalid _PSD data\n");
531 		result = -EFAULT;
532 		goto end;
533 	}
534 
535 	if (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES) {
536 		printk(KERN_ERR PREFIX "Unknown _PSD:num_entries\n");
537 		result = -EFAULT;
538 		goto end;
539 	}
540 
541 	if (pdomain->revision != ACPI_PSD_REV0_REVISION) {
542 		printk(KERN_ERR PREFIX "Unknown _PSD:revision\n");
543 		result = -EFAULT;
544 		goto end;
545 	}
546 
547 	if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL &&
548 	    pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY &&
549 	    pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) {
550 		printk(KERN_ERR PREFIX "Invalid _PSD:coord_type\n");
551 		result = -EFAULT;
552 		goto end;
553 	}
554 end:
555 	kfree(buffer.pointer);
556 	return result;
557 }
558 
559 int acpi_processor_preregister_performance(
560 		struct acpi_processor_performance *performance)
561 {
562 	int count, count_target;
563 	int retval = 0;
564 	unsigned int i, j;
565 	cpumask_var_t covered_cpus;
566 	struct acpi_processor *pr;
567 	struct acpi_psd_package *pdomain;
568 	struct acpi_processor *match_pr;
569 	struct acpi_psd_package *match_pdomain;
570 
571 	if (!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL))
572 		return -ENOMEM;
573 
574 	mutex_lock(&performance_mutex);
575 
576 	/*
577 	 * Check if another driver has already registered, and abort before
578 	 * changing pr->performance if it has. Check input data as well.
579 	 */
580 	for_each_possible_cpu(i) {
581 		pr = per_cpu(processors, i);
582 		if (!pr) {
583 			/* Look only at processors in ACPI namespace */
584 			continue;
585 		}
586 
587 		if (pr->performance) {
588 			retval = -EBUSY;
589 			goto err_out;
590 		}
591 
592 		if (!performance || !per_cpu_ptr(performance, i)) {
593 			retval = -EINVAL;
594 			goto err_out;
595 		}
596 	}
597 
598 	/* Call _PSD for all CPUs */
599 	for_each_possible_cpu(i) {
600 		pr = per_cpu(processors, i);
601 		if (!pr)
602 			continue;
603 
604 		pr->performance = per_cpu_ptr(performance, i);
605 		cpumask_set_cpu(i, pr->performance->shared_cpu_map);
606 		if (acpi_processor_get_psd(pr)) {
607 			retval = -EINVAL;
608 			continue;
609 		}
610 	}
611 	if (retval)
612 		goto err_ret;
613 
614 	/*
615 	 * Now that we have _PSD data from all CPUs, lets setup P-state
616 	 * domain info.
617 	 */
618 	for_each_possible_cpu(i) {
619 		pr = per_cpu(processors, i);
620 		if (!pr)
621 			continue;
622 
623 		if (cpumask_test_cpu(i, covered_cpus))
624 			continue;
625 
626 		pdomain = &(pr->performance->domain_info);
627 		cpumask_set_cpu(i, pr->performance->shared_cpu_map);
628 		cpumask_set_cpu(i, covered_cpus);
629 		if (pdomain->num_processors <= 1)
630 			continue;
631 
632 		/* Validate the Domain info */
633 		count_target = pdomain->num_processors;
634 		count = 1;
635 		if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL)
636 			pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
637 		else if (pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL)
638 			pr->performance->shared_type = CPUFREQ_SHARED_TYPE_HW;
639 		else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY)
640 			pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ANY;
641 
642 		for_each_possible_cpu(j) {
643 			if (i == j)
644 				continue;
645 
646 			match_pr = per_cpu(processors, j);
647 			if (!match_pr)
648 				continue;
649 
650 			match_pdomain = &(match_pr->performance->domain_info);
651 			if (match_pdomain->domain != pdomain->domain)
652 				continue;
653 
654 			/* Here i and j are in the same domain */
655 
656 			if (match_pdomain->num_processors != count_target) {
657 				retval = -EINVAL;
658 				goto err_ret;
659 			}
660 
661 			if (pdomain->coord_type != match_pdomain->coord_type) {
662 				retval = -EINVAL;
663 				goto err_ret;
664 			}
665 
666 			cpumask_set_cpu(j, covered_cpus);
667 			cpumask_set_cpu(j, pr->performance->shared_cpu_map);
668 			count++;
669 		}
670 
671 		for_each_possible_cpu(j) {
672 			if (i == j)
673 				continue;
674 
675 			match_pr = per_cpu(processors, j);
676 			if (!match_pr)
677 				continue;
678 
679 			match_pdomain = &(match_pr->performance->domain_info);
680 			if (match_pdomain->domain != pdomain->domain)
681 				continue;
682 
683 			match_pr->performance->shared_type =
684 					pr->performance->shared_type;
685 			cpumask_copy(match_pr->performance->shared_cpu_map,
686 				     pr->performance->shared_cpu_map);
687 		}
688 	}
689 
690 err_ret:
691 	for_each_possible_cpu(i) {
692 		pr = per_cpu(processors, i);
693 		if (!pr || !pr->performance)
694 			continue;
695 
696 		/* Assume no coordination on any error parsing domain info */
697 		if (retval) {
698 			cpumask_clear(pr->performance->shared_cpu_map);
699 			cpumask_set_cpu(i, pr->performance->shared_cpu_map);
700 			pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
701 		}
702 		pr->performance = NULL; /* Will be set for real in register */
703 	}
704 
705 err_out:
706 	mutex_unlock(&performance_mutex);
707 	free_cpumask_var(covered_cpus);
708 	return retval;
709 }
710 EXPORT_SYMBOL(acpi_processor_preregister_performance);
711 
712 int
713 acpi_processor_register_performance(struct acpi_processor_performance
714 				    *performance, unsigned int cpu)
715 {
716 	struct acpi_processor *pr;
717 
718 	if (!(acpi_processor_ppc_status & PPC_REGISTERED))
719 		return -EINVAL;
720 
721 	mutex_lock(&performance_mutex);
722 
723 	pr = per_cpu(processors, cpu);
724 	if (!pr) {
725 		mutex_unlock(&performance_mutex);
726 		return -ENODEV;
727 	}
728 
729 	if (pr->performance) {
730 		mutex_unlock(&performance_mutex);
731 		return -EBUSY;
732 	}
733 
734 	WARN_ON(!performance);
735 
736 	pr->performance = performance;
737 
738 	if (acpi_processor_get_performance_info(pr)) {
739 		pr->performance = NULL;
740 		mutex_unlock(&performance_mutex);
741 		return -EIO;
742 	}
743 
744 	mutex_unlock(&performance_mutex);
745 	return 0;
746 }
747 
748 EXPORT_SYMBOL(acpi_processor_register_performance);
749 
750 void
751 acpi_processor_unregister_performance(struct acpi_processor_performance
752 				      *performance, unsigned int cpu)
753 {
754 	struct acpi_processor *pr;
755 
756 	mutex_lock(&performance_mutex);
757 
758 	pr = per_cpu(processors, cpu);
759 	if (!pr) {
760 		mutex_unlock(&performance_mutex);
761 		return;
762 	}
763 
764 	if (pr->performance)
765 		kfree(pr->performance->states);
766 	pr->performance = NULL;
767 
768 	mutex_unlock(&performance_mutex);
769 
770 	return;
771 }
772 
773 EXPORT_SYMBOL(acpi_processor_unregister_performance);
774