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