[linux-2.6-block.git] / drivers / acpi / acpi_processor.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * acpi_processor.c - ACPI processor enumeration support
 *
 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 * Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
 * Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
 * Copyright (C) 2013, Intel Corporation
 *                     Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 */

#include <linux/acpi.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>

#include <acpi/processor.h>

#include <asm/cpu.h>

#include "internal.h"

#define _COMPONENT	ACPI_PROCESSOR_COMPONENT

ACPI_MODULE_NAME("processor");

DEFINE_PER_CPU(struct acpi_processor *, processors);
EXPORT_PER_CPU_SYMBOL(processors);

/* --------------------------------------------------------------------------
                                Errata Handling
   -------------------------------------------------------------------------- */

struct acpi_processor_errata errata __read_mostly;
EXPORT_SYMBOL_GPL(errata);

static int acpi_processor_errata_piix4(struct pci_dev *dev)
{
	u8 value1 = 0;
	u8 value2 = 0;


	if (!dev)
		return -EINVAL;

	/*
	 * Note that 'dev' references the PIIX4 ACPI Controller.
	 */

	switch (dev->revision) {
	case 0:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
		break;
	case 1:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
		break;
	case 2:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
		break;
	case 3:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
		break;
	}

	switch (dev->revision) {

	case 0:		/* PIIX4 A-step */
	case 1:		/* PIIX4 B-step */
		/*
		 * See specification changes #13 ("Manual Throttle Duty Cycle")
		 * and #14 ("Enabling and Disabling Manual Throttle"), plus
		 * erratum #5 ("STPCLK# Deassertion Time") from the January
		 * 2002 PIIX4 specification update.  Applies to only older
		 * PIIX4 models.
		 */
		errata.piix4.throttle = 1;
		/* fall through*/

	case 2:		/* PIIX4E */
	case 3:		/* PIIX4M */
		/*
		 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
		 * Livelock") from the January 2002 PIIX4 specification update.
		 * Applies to all PIIX4 models.
		 */

		/*
		 * BM-IDE
		 * ------
		 * Find the PIIX4 IDE Controller and get the Bus Master IDE
		 * Status register address.  We'll use this later to read
		 * each IDE controller's DMA status to make sure we catch all
		 * DMA activity.
		 */
		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
				     PCI_DEVICE_ID_INTEL_82371AB,
				     PCI_ANY_ID, PCI_ANY_ID, NULL);
		if (dev) {
			errata.piix4.bmisx = pci_resource_start(dev, 4);
			pci_dev_put(dev);
		}

		/*
		 * Type-F DMA
		 * ----------
		 * Find the PIIX4 ISA Controller and read the Motherboard
		 * DMA controller's status to see if Type-F (Fast) DMA mode
		 * is enabled (bit 7) on either channel.  Note that we'll
		 * disable C3 support if this is enabled, as some legacy
		 * devices won't operate well if fast DMA is disabled.
		 */
		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
				     PCI_DEVICE_ID_INTEL_82371AB_0,
				     PCI_ANY_ID, PCI_ANY_ID, NULL);
		if (dev) {
			pci_read_config_byte(dev, 0x76, &value1);
			pci_read_config_byte(dev, 0x77, &value2);
			if ((value1 & 0x80) || (value2 & 0x80))
				errata.piix4.fdma = 1;
			pci_dev_put(dev);
		}

		break;
	}

	if (errata.piix4.bmisx)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Bus master activity detection (BM-IDE) erratum enabled\n"));
	if (errata.piix4.fdma)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Type-F DMA livelock erratum (C3 disabled)\n"));

	return 0;
}

static int acpi_processor_errata(void)
{
	int result = 0;
	struct pci_dev *dev = NULL;

	/*
	 * PIIX4
	 */
	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
			     PCI_ANY_ID, NULL);
	if (dev) {
		result = acpi_processor_errata_piix4(dev);
		pci_dev_put(dev);
	}

	return result;
}

/* --------------------------------------------------------------------------
                                Initialization
   -------------------------------------------------------------------------- */

#ifdef CONFIG_ACPI_HOTPLUG_CPU
int __weak acpi_map_cpu(acpi_handle handle,
		phys_cpuid_t physid, u32 acpi_id, int *pcpu)
{
	return -ENODEV;
}

int __weak acpi_unmap_cpu(int cpu)
{
	return -ENODEV;
}

int __weak arch_register_cpu(int cpu)
{
	return -ENODEV;
}

void __weak arch_unregister_cpu(int cpu) {}

static int acpi_processor_hotadd_init(struct acpi_processor *pr)
{
	unsigned long long sta;
	acpi_status status;
	int ret;

	if (invalid_phys_cpuid(pr->phys_id))
		return -ENODEV;

	status = acpi_evaluate_integer(pr->handle, "_STA", NULL, &sta);
	if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT))
		return -ENODEV;

	cpu_maps_update_begin();
	cpu_hotplug_begin();

	ret = acpi_map_cpu(pr->handle, pr->phys_id, pr->acpi_id, &pr->id);
	if (ret)
		goto out;

	ret = arch_register_cpu(pr->id);
	if (ret) {
		acpi_unmap_cpu(pr->id);
		goto out;
	}

	/*
	 * CPU got hot-added, but cpu_data is not initialized yet.  Set a flag
	 * to delay cpu_idle/throttling initialization and do it when the CPU
	 * gets online for the first time.
	 */
	pr_info("CPU%d has been hot-added\n", pr->id);
	pr->flags.need_hotplug_init = 1;

out:
	cpu_hotplug_done();
	cpu_maps_update_done();
	return ret;
}
#else
static inline int acpi_processor_hotadd_init(struct acpi_processor *pr)
{
	return -ENODEV;
}
#endif /* CONFIG_ACPI_HOTPLUG_CPU */

static int acpi_processor_get_info(struct acpi_device *device)
{
	union acpi_object object = { 0 };
	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
	struct acpi_processor *pr = acpi_driver_data(device);
	int device_declaration = 0;
	acpi_status status = AE_OK;
	static int cpu0_initialized;
	unsigned long long value;

	acpi_processor_errata();

	/*
	 * Check to see if we have bus mastering arbitration control.  This
	 * is required for proper C3 usage (to maintain cache coherency).
	 */
	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
		pr->flags.bm_control = 1;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Bus mastering arbitration control present\n"));
	} else
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "No bus mastering arbitration control\n"));

	if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
		/* Declared with "Processor" statement; match ProcessorID */
		status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
		if (ACPI_FAILURE(status)) {
			dev_err(&device->dev,
				"Failed to evaluate processor object (0x%x)\n",
				status);
			return -ENODEV;
		}

		pr->acpi_id = object.processor.proc_id;
	} else {
		/*
		 * Declared with "Device" statement; match _UID.
		 * Note that we don't handle string _UIDs yet.
		 */
		status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
						NULL, &value);
		if (ACPI_FAILURE(status)) {
			dev_err(&device->dev,
				"Failed to evaluate processor _UID (0x%x)\n",
				status);
			return -ENODEV;
		}
		device_declaration = 1;
		pr->acpi_id = value;
	}

	if (acpi_duplicate_processor_id(pr->acpi_id)) {
		if (pr->acpi_id == 0xff)
			dev_info_once(&device->dev,
				"Entry not well-defined, consider updating BIOS\n");
		else
			dev_err(&device->dev,
				"Failed to get unique processor _UID (0x%x)\n",
				pr->acpi_id);
		return -ENODEV;
	}

	pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration,
					pr->acpi_id);
	if (invalid_phys_cpuid(pr->phys_id))
		acpi_handle_debug(pr->handle, "failed to get CPU physical ID.\n");

	pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id);
	if (!cpu0_initialized && !acpi_has_cpu_in_madt()) {
		cpu0_initialized = 1;
		/*
		 * Handle UP system running SMP kernel, with no CPU
		 * entry in MADT
		 */
		if (invalid_logical_cpuid(pr->id) && (num_online_cpus() == 1))
			pr->id = 0;
	}

	/*
	 *  Extra Processor objects may be enumerated on MP systems with
	 *  less than the max # of CPUs. They should be ignored _iff
	 *  they are physically not present.
	 *
	 *  NOTE: Even if the processor has a cpuid, it may not be present
	 *  because cpuid <-> apicid mapping is persistent now.
	 */
	if (invalid_logical_cpuid(pr->id) || !cpu_present(pr->id)) {
		int ret = acpi_processor_hotadd_init(pr);
		if (ret)
			return ret;
	}

	/*
	 * On some boxes several processors use the same processor bus id.
	 * But they are located in different scope. For example:
	 * \_SB.SCK0.CPU0
	 * \_SB.SCK1.CPU0
	 * Rename the processor device bus id. And the new bus id will be
	 * generated as the following format:
	 * CPU+CPU ID.
	 */
	sprintf(acpi_device_bid(device), "CPU%X", pr->id);
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
			  pr->acpi_id));

	if (!object.processor.pblk_address)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
	else if (object.processor.pblk_length != 6)
		dev_err(&device->dev, "Invalid PBLK length [%d]\n",
			    object.processor.pblk_length);
	else {
		pr->throttling.address = object.processor.pblk_address;
		pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
		pr->throttling.duty_width = acpi_gbl_FADT.duty_width;

		pr->pblk = object.processor.pblk_address;
	}

	/*
	 * If ACPI describes a slot number for this CPU, we can use it to
	 * ensure we get the right value in the "physical id" field
	 * of /proc/cpuinfo
	 */
	status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value);
	if (ACPI_SUCCESS(status))
		arch_fix_phys_package_id(pr->id, value);

	return 0;
}

/*
 * Do not put anything in here which needs the core to be online.
 * For example MSR access or setting up things which check for cpuinfo_x86
 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
 * Such things have to be put in and set up by the processor driver's .probe().
 */
static DEFINE_PER_CPU(void *, processor_device_array);

static int acpi_processor_add(struct acpi_device *device,
					const struct acpi_device_id *id)
{
	struct acpi_processor *pr;
	struct device *dev;
	int result = 0;

	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
	if (!pr)
		return -ENOMEM;

	if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
		result = -ENOMEM;
		goto err_free_pr;
	}

	pr->handle = device->handle;
	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
	device->driver_data = pr;

	result = acpi_processor_get_info(device);
	if (result) /* Processor is not physically present or unavailable */
		return 0;

	BUG_ON(pr->id >= nr_cpu_ids);

	/*
	 * Buggy BIOS check.
	 * ACPI id of processors can be reported wrongly by the BIOS.
	 * Don't trust it blindly
	 */
	if (per_cpu(processor_device_array, pr->id) != NULL &&
	    per_cpu(processor_device_array, pr->id) != device) {
		dev_warn(&device->dev,
			"BIOS reported wrong ACPI id %d for the processor\n",
			pr->id);
		/* Give up, but do not abort the namespace scan. */
		goto err;
	}
	/*
	 * processor_device_array is not cleared on errors to allow buggy BIOS
	 * checks.
	 */
	per_cpu(processor_device_array, pr->id) = device;
	per_cpu(processors, pr->id) = pr;

	dev = get_cpu_device(pr->id);
	if (!dev) {
		result = -ENODEV;
		goto err;
	}

	result = acpi_bind_one(dev, device);
	if (result)
		goto err;

	pr->dev = dev;

	/* Trigger the processor driver's .probe() if present. */
	if (device_attach(dev) >= 0)
		return 1;

	dev_err(dev, "Processor driver could not be attached\n");
	acpi_unbind_one(dev);

 err:
	free_cpumask_var(pr->throttling.shared_cpu_map);
	device->driver_data = NULL;
	per_cpu(processors, pr->id) = NULL;
 err_free_pr:
	kfree(pr);
	return result;
}

#ifdef CONFIG_ACPI_HOTPLUG_CPU
/* --------------------------------------------------------------------------
                                    Removal
   -------------------------------------------------------------------------- */

static void acpi_processor_remove(struct acpi_device *device)
{
	struct acpi_processor *pr;

	if (!device || !acpi_driver_data(device))
		return;

	pr = acpi_driver_data(device);
	if (pr->id >= nr_cpu_ids)
		goto out;

	/*
	 * The only reason why we ever get here is CPU hot-removal.  The CPU is
	 * already offline and the ACPI device removal locking prevents it from
	 * being put back online at this point.
	 *
	 * Unbind the driver from the processor device and detach it from the
	 * ACPI companion object.
	 */
	device_release_driver(pr->dev);
	acpi_unbind_one(pr->dev);

	/* Clean up. */
	per_cpu(processor_device_array, pr->id) = NULL;
	per_cpu(processors, pr->id) = NULL;

	cpu_maps_update_begin();
	cpu_hotplug_begin();

	/* Remove the CPU. */
	arch_unregister_cpu(pr->id);
	acpi_unmap_cpu(pr->id);

	cpu_hotplug_done();
	cpu_maps_update_done();

	try_offline_node(cpu_to_node(pr->id));

 out:
	free_cpumask_var(pr->throttling.shared_cpu_map);
	kfree(pr);
}
#endif /* CONFIG_ACPI_HOTPLUG_CPU */

#ifdef CONFIG_X86
static bool acpi_hwp_native_thermal_lvt_set;
static acpi_status __init acpi_hwp_native_thermal_lvt_osc(acpi_handle handle,
							  u32 lvl,
							  void *context,
							  void **rv)
{
	u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953";
	u32 capbuf[2];
	struct acpi_osc_context osc_context = {
		.uuid_str = sb_uuid_str,
		.rev = 1,
		.cap.length = 8,
		.cap.pointer = capbuf,
	};

	if (acpi_hwp_native_thermal_lvt_set)
		return AE_CTRL_TERMINATE;

	capbuf[0] = 0x0000;
	capbuf[1] = 0x1000; /* set bit 12 */

	if (ACPI_SUCCESS(acpi_run_osc(handle, &osc_context))) {
		if (osc_context.ret.pointer && osc_context.ret.length > 1) {
			u32 *capbuf_ret = osc_context.ret.pointer;

			if (capbuf_ret[1] & 0x1000) {
				acpi_handle_info(handle,
					"_OSC native thermal LVT Acked\n");
				acpi_hwp_native_thermal_lvt_set = true;
			}
		}
		kfree(osc_context.ret.pointer);
	}

	return AE_OK;
}

void __init acpi_early_processor_osc(void)
{
	if (boot_cpu_has(X86_FEATURE_HWP)) {
		acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
				    ACPI_UINT32_MAX,
				    acpi_hwp_native_thermal_lvt_osc,
				    NULL, NULL, NULL);
		acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID,
				 acpi_hwp_native_thermal_lvt_osc,
				 NULL, NULL);
	}
}
#endif

/*
 * The following ACPI IDs are known to be suitable for representing as
 * processor devices.
 */
static const struct acpi_device_id processor_device_ids[] = {

	{ ACPI_PROCESSOR_OBJECT_HID, },
	{ ACPI_PROCESSOR_DEVICE_HID, },

	{ }
};

static struct acpi_scan_handler processor_handler = {
	.ids = processor_device_ids,
	.attach = acpi_processor_add,
#ifdef CONFIG_ACPI_HOTPLUG_CPU
	.detach = acpi_processor_remove,
#endif
	.hotplug = {
		.enabled = true,
	},
};

static int acpi_processor_container_attach(struct acpi_device *dev,
					   const struct acpi_device_id *id)
{
	return 1;
}

static const struct acpi_device_id processor_container_ids[] = {
	{ ACPI_PROCESSOR_CONTAINER_HID, },
	{ }
};

static struct acpi_scan_handler processor_container_handler = {
	.ids = processor_container_ids,
	.attach = acpi_processor_container_attach,
};

/* The number of the unique processor IDs */
static int nr_unique_ids __initdata;

/* The number of the duplicate processor IDs */
static int nr_duplicate_ids;

/* Used to store the unique processor IDs */
static int unique_processor_ids[] __initdata = {
	[0 ... NR_CPUS - 1] = -1,
};

/* Used to store the duplicate processor IDs */
static int duplicate_processor_ids[] = {
	[0 ... NR_CPUS - 1] = -1,
};

static void __init processor_validated_ids_update(int proc_id)
{
	int i;

	if (nr_unique_ids == NR_CPUS||nr_duplicate_ids == NR_CPUS)
		return;

	/*
	 * Firstly, compare the proc_id with duplicate IDs, if the proc_id is
	 * already in the IDs, do nothing.
	 */
	for (i = 0; i < nr_duplicate_ids; i++) {
		if (duplicate_processor_ids[i] == proc_id)
			return;
	}

	/*
	 * Secondly, compare the proc_id with unique IDs, if the proc_id is in
	 * the IDs, put it in the duplicate IDs.
	 */
	for (i = 0; i < nr_unique_ids; i++) {
		if (unique_processor_ids[i] == proc_id) {
			duplicate_processor_ids[nr_duplicate_ids] = proc_id;
			nr_duplicate_ids++;
			return;
		}
	}

	/*
	 * Lastly, the proc_id is a unique ID, put it in the unique IDs.
	 */
	unique_processor_ids[nr_unique_ids] = proc_id;
	nr_unique_ids++;
}

static acpi_status __init acpi_processor_ids_walk(acpi_handle handle,
						  u32 lvl,
						  void *context,
						  void **rv)
{
	acpi_status status;
	acpi_object_type acpi_type;
	unsigned long long uid;
	union acpi_object object = { 0 };
	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };

	status = acpi_get_type(handle, &acpi_type);
	if (ACPI_FAILURE(status))
		return status;

	switch (acpi_type) {
	case ACPI_TYPE_PROCESSOR:
		status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
		if (ACPI_FAILURE(status))
			goto err;
		uid = object.processor.proc_id;
		break;

	case ACPI_TYPE_DEVICE:
		status = acpi_evaluate_integer(handle, "_UID", NULL, &uid);
		if (ACPI_FAILURE(status))
			goto err;
		break;
	default:
		goto err;
	}

	processor_validated_ids_update(uid);
	return AE_OK;

err:
	/* Exit on error, but don't abort the namespace walk */
	acpi_handle_info(handle, "Invalid processor object\n");
	return AE_OK;

}

static void __init acpi_processor_check_duplicates(void)
{
	/* check the correctness for all processors in ACPI namespace */
	acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
						ACPI_UINT32_MAX,
						acpi_processor_ids_walk,
						NULL, NULL, NULL);
	acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_ids_walk,
						NULL, NULL);
}

bool acpi_duplicate_processor_id(int proc_id)
{
	int i;

	/*
	 * compare the proc_id with duplicate IDs, if the proc_id is already
	 * in the duplicate IDs, return true, otherwise, return false.
	 */
	for (i = 0; i < nr_duplicate_ids; i++) {
		if (duplicate_processor_ids[i] == proc_id)
			return true;
	}
	return false;
}

void __init acpi_processor_init(void)
{
	acpi_processor_check_duplicates();
	acpi_scan_add_handler_with_hotplug(&processor_handler, "processor");
	acpi_scan_add_handler(&processor_container_handler);
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
ac212b69 RW	2	/*
	3	* acpi_processor.c - ACPI processor enumeration support
	4	*
	5	* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
	6	* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
	7	* Copyright (C) 2004 Dominik Brodowski <linux@brodo.de>
	8	* Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
	9	* Copyright (C) 2013, Intel Corporation
	10	* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
ac212b69 RW	11	*/
	12
	13	#include <linux/acpi.h>
	14	#include <linux/device.h>
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
	17	#include <linux/pci.h>
	18
	19	#include <acpi/processor.h>
	20
	21	#include <asm/cpu.h>
	22
	23	#include "internal.h"
	24
	25	#define _COMPONENT ACPI_PROCESSOR_COMPONENT
	26
	27	ACPI_MODULE_NAME("processor");
	28
2e4f1db4 RW	29	DEFINE_PER_CPU(struct acpi_processor *, processors);
	30	EXPORT_PER_CPU_SYMBOL(processors);
	31
ac212b69 RW	32	/* --------------------------------------------------------------------------
	33	Errata Handling
	34	-------------------------------------------------------------------------- */
	35
	36	struct acpi_processor_errata errata __read_mostly;
	37	EXPORT_SYMBOL_GPL(errata);
	38
	39	static int acpi_processor_errata_piix4(struct pci_dev *dev)
	40	{
	41	u8 value1 = 0;
	42	u8 value2 = 0;
	43
	44
	45	if (!dev)
	46	return -EINVAL;
	47
	48	/*
	49	* Note that 'dev' references the PIIX4 ACPI Controller.
	50	*/
	51
	52	switch (dev->revision) {
	53	case 0:
	54	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
	55	break;
	56	case 1:
	57	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
	58	break;
	59	case 2:
	60	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
	61	break;
	62	case 3:
	63	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
	64	break;
	65	default:
	66	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
	67	break;
	68	}
	69
	70	switch (dev->revision) {
	71
	72	case 0: /* PIIX4 A-step */
	73	case 1: /* PIIX4 B-step */
	74	/*
	75	* See specification changes #13 ("Manual Throttle Duty Cycle")
	76	* and #14 ("Enabling and Disabling Manual Throttle"), plus
	77	* erratum #5 ("STPCLK# Deassertion Time") from the January
	78	* 2002 PIIX4 specification update. Applies to only older
	79	* PIIX4 models.
	80	*/
	81	errata.piix4.throttle = 1;
1be9c3a0	82	/* fall through*/
ac212b69 RW	83
	84	case 2: /* PIIX4E */
	85	case 3: /* PIIX4M */
	86	/*
	87	* See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
	88	* Livelock") from the January 2002 PIIX4 specification update.
	89	* Applies to all PIIX4 models.
	90	*/
	91
	92	/*
	93	* BM-IDE
	94	* ------
	95	* Find the PIIX4 IDE Controller and get the Bus Master IDE
	96	* Status register address. We'll use this later to read
	97	* each IDE controller's DMA status to make sure we catch all
	98	* DMA activity.
	99	*/
	100	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
	101	PCI_DEVICE_ID_INTEL_82371AB,
	102	PCI_ANY_ID, PCI_ANY_ID, NULL);
	103	if (dev) {
	104	errata.piix4.bmisx = pci_resource_start(dev, 4);
	105	pci_dev_put(dev);
	106	}
	107
	108	/*
	109	* Type-F DMA
	110	* ----------
	111	* Find the PIIX4 ISA Controller and read the Motherboard
	112	* DMA controller's status to see if Type-F (Fast) DMA mode
	113	* is enabled (bit 7) on either channel. Note that we'll
	114	* disable C3 support if this is enabled, as some legacy
	115	* devices won't operate well if fast DMA is disabled.
	116	*/
	117	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
	118	PCI_DEVICE_ID_INTEL_82371AB_0,
	119	PCI_ANY_ID, PCI_ANY_ID, NULL);
	120	if (dev) {
	121	pci_read_config_byte(dev, 0x76, &value1);
	122	pci_read_config_byte(dev, 0x77, &value2);
	123	if ((value1 & 0x80) \|\| (value2 & 0x80))
	124	errata.piix4.fdma = 1;
	125	pci_dev_put(dev);
	126	}
	127
	128	break;
	129	}
	130
	131	if (errata.piix4.bmisx)
	132	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
	133	"Bus master activity detection (BM-IDE) erratum enabled\n"));
	134	if (errata.piix4.fdma)
	135	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
	136	"Type-F DMA livelock erratum (C3 disabled)\n"));
	137
	138	return 0;
	139	}
	140
082e12a0	141	static int acpi_processor_errata(void)
ac212b69 RW	142	{
	143	int result = 0;
	144	struct pci_dev *dev = NULL;
	145
ac212b69 RW	146	/*
	147	* PIIX4
	148	*/
	149	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
	150	PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
	151	PCI_ANY_ID, NULL);
	152	if (dev) {
	153	result = acpi_processor_errata_piix4(dev);
	154	pci_dev_put(dev);
	155	}
	156
	157	return result;
	158	}
	159
	160	/* --------------------------------------------------------------------------
	161	Initialization
	162	-------------------------------------------------------------------------- */
	163
	164	#ifdef CONFIG_ACPI_HOTPLUG_CPU
56cdc2a0	165	int __weak acpi_map_cpu(acpi_handle handle,
febf2407	166	phys_cpuid_t physid, u32 acpi_id, int *pcpu)
56cdc2a0 AC	167	{
	168	return -ENODEV;
	169	}
	170
	171	int __weak acpi_unmap_cpu(int cpu)
	172	{
	173	return -ENODEV;
	174	}
	175
	176	int __weak arch_register_cpu(int cpu)
	177	{
	178	return -ENODEV;
	179	}
	180
	181	void __weak arch_unregister_cpu(int cpu) {}
	182
ac212b69 RW	183	static int acpi_processor_hotadd_init(struct acpi_processor *pr)
	184	{
	185	unsigned long long sta;
	186	acpi_status status;
	187	int ret;
	188
ddcc18f5	189	if (invalid_phys_cpuid(pr->phys_id))
4985c32e LT	190	return -ENODEV;
4985c32e LT	191
ac212b69 RW	192	status = acpi_evaluate_integer(pr->handle, "_STA", NULL, &sta);
	193	if (ACPI_FAILURE(status) \|\| !(sta & ACPI_STA_DEVICE_PRESENT))
	194	return -ENODEV;
	195
b9d10be7 TK	196	cpu_maps_update_begin();
	197	cpu_hotplug_begin();
	198
febf2407	199	ret = acpi_map_cpu(pr->handle, pr->phys_id, pr->acpi_id, &pr->id);
ac212b69	200	if (ret)
b9d10be7	201	goto out;
ac212b69 RW	202
	203	ret = arch_register_cpu(pr->id);
	204	if (ret) {
d02dc27d	205	acpi_unmap_cpu(pr->id);
b9d10be7	206	goto out;
ac212b69 RW	207	}
	208
	209	/*
	210	* CPU got hot-added, but cpu_data is not initialized yet. Set a flag
	211	* to delay cpu_idle/throttling initialization and do it when the CPU
	212	* gets online for the first time.
	213	*/
	214	pr_info("CPU%d has been hot-added\n", pr->id);
	215	pr->flags.need_hotplug_init = 1;
b9d10be7 TK	216
	217	out:
	218	cpu_hotplug_done();
	219	cpu_maps_update_done();
	220	return ret;
ac212b69 RW	221	}
	222	#else
	223	static inline int acpi_processor_hotadd_init(struct acpi_processor *pr)
	224	{
	225	return -ENODEV;
	226	}
	227	#endif /* CONFIG_ACPI_HOTPLUG_CPU */
	228
	229	static int acpi_processor_get_info(struct acpi_device *device)
	230	{
	231	union acpi_object object = { 0 };
	232	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
	233	struct acpi_processor *pr = acpi_driver_data(device);
05eb3cd8	234	int device_declaration = 0;
ac212b69 RW	235	acpi_status status = AE_OK;
ac212b69 RW	236	static int cpu0_initialized;
6ebb5bc9	237	unsigned long long value;
ac212b69	238
082e12a0	239	acpi_processor_errata();
ac212b69 RW	240
	241	/*
	242	* Check to see if we have bus mastering arbitration control. This
	243	* is required for proper C3 usage (to maintain cache coherency).
	244	*/
	245	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
	246	pr->flags.bm_control = 1;
	247	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
	248	"Bus mastering arbitration control present\n"));
	249	} else
	250	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
	251	"No bus mastering arbitration control\n"));
	252
	253	if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
	254	/* Declared with "Processor" statement; match ProcessorID */
	255	status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
	256	if (ACPI_FAILURE(status)) {
	257	dev_err(&device->dev,
	258	"Failed to evaluate processor object (0x%x)\n",
	259	status);
	260	return -ENODEV;
	261	}
	262
ac212b69 RW	263	pr->acpi_id = object.processor.proc_id;
	264	} else {
	265	/*
	266	* Declared with "Device" statement; match _UID.
	267	* Note that we don't handle string _UIDs yet.
	268	*/
ac212b69 RW	269	status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
	270	NULL, &value);
	271	if (ACPI_FAILURE(status)) {
	272	dev_err(&device->dev,
	273	"Failed to evaluate processor _UID (0x%x)\n",
	274	status);
	275	return -ENODEV;
	276	}
	277	device_declaration = 1;
	278	pr->acpi_id = value;
	279	}
ac212b69	280
a77d6cd9	281	if (acpi_duplicate_processor_id(pr->acpi_id)) {
2c2b005f JS	282	if (pr->acpi_id == 0xff)
	283	dev_info_once(&device->dev,
	284	"Entry not well-defined, consider updating BIOS\n");
	285	else
	286	dev_err(&device->dev,
	287	"Failed to get unique processor _UID (0x%x)\n",
	288	pr->acpi_id);
a77d6cd9 DL	289	return -ENODEV;
	290	}
	291
8416c5bd HG	292	pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration,
8416c5bd HG	293	pr->acpi_id);
ddcc18f5	294	if (invalid_phys_cpuid(pr->phys_id))
af8f3f51	295	acpi_handle_debug(pr->handle, "failed to get CPU physical ID.\n");
ac212b69	296
05eb3cd8	297	pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id);
b50154d5	298	if (!cpu0_initialized && !acpi_has_cpu_in_madt()) {
b981513f	299	cpu0_initialized = 1;
af8f3f51 HG	300	/*
	301	* Handle UP system running SMP kernel, with no CPU
	302	* entry in MADT
	303	*/
05eb3cd8 HG	304	if (invalid_logical_cpuid(pr->id) && (num_online_cpus() == 1))
05eb3cd8 HG	305	pr->id = 0;
b981513f	306	}
ac212b69 RW	307
	308	/*
	309	* Extra Processor objects may be enumerated on MP systems with
	310	* less than the max # of CPUs. They should be ignored _iff
	311	* they are physically not present.
8ad893fa GZ	312	*
	313	* NOTE: Even if the processor has a cpuid, it may not be present
	314	* because cpuid <-> apicid mapping is persistent now.
ac212b69	315	*/
8ad893fa	316	if (invalid_logical_cpuid(pr->id) \|\| !cpu_present(pr->id)) {
ac212b69 RW	317	int ret = acpi_processor_hotadd_init(pr);
	318	if (ret)
	319	return ret;
	320	}
b981513f	321
ac212b69 RW	322	/*
	323	* On some boxes several processors use the same processor bus id.
	324	* But they are located in different scope. For example:
	325	* \_SB.SCK0.CPU0
	326	* \_SB.SCK1.CPU0
	327	* Rename the processor device bus id. And the new bus id will be
	328	* generated as the following format:
	329	* CPU+CPU ID.
	330	*/
	331	sprintf(acpi_device_bid(device), "CPU%X", pr->id);
	332	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
	333	pr->acpi_id));
	334
	335	if (!object.processor.pblk_address)
	336	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
	337	else if (object.processor.pblk_length != 6)
	338	dev_err(&device->dev, "Invalid PBLK length [%d]\n",
	339	object.processor.pblk_length);
	340	else {
	341	pr->throttling.address = object.processor.pblk_address;
	342	pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
	343	pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
	344
	345	pr->pblk = object.processor.pblk_address;
ac212b69 RW	346	}
	347
	348	/*
	349	* If ACPI describes a slot number for this CPU, we can use it to
	350	* ensure we get the right value in the "physical id" field
	351	* of /proc/cpuinfo
	352	*/
6ebb5bc9	353	status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value);
ac212b69	354	if (ACPI_SUCCESS(status))
6ebb5bc9	355	arch_fix_phys_package_id(pr->id, value);
ac212b69 RW	356
	357	return 0;
	358	}
	359
	360	/*
	361	* Do not put anything in here which needs the core to be online.
	362	* For example MSR access or setting up things which check for cpuinfo_x86
	363	* (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
	364	* Such things have to be put in and set up by the processor driver's .probe().
	365	*/
	366	static DEFINE_PER_CPU(void *, processor_device_array);
	367
fe7bf106	368	static int acpi_processor_add(struct acpi_device *device,
ac212b69 RW	369	const struct acpi_device_id *id)
	370	{
	371	struct acpi_processor *pr;
	372	struct device *dev;
	373	int result = 0;
	374
	375	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
	376	if (!pr)
	377	return -ENOMEM;
	378
	379	if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
	380	result = -ENOMEM;
	381	goto err_free_pr;
	382	}
	383
	384	pr->handle = device->handle;
	385	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
	386	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
	387	device->driver_data = pr;
	388
	389	result = acpi_processor_get_info(device);
	390	if (result) /* Processor is not physically present or unavailable */
	391	return 0;
	392
ac212b69 RW	393	BUG_ON(pr->id >= nr_cpu_ids);
	394
	395	/*
	396	* Buggy BIOS check.
	397	* ACPI id of processors can be reported wrongly by the BIOS.
	398	* Don't trust it blindly
	399	*/
	400	if (per_cpu(processor_device_array, pr->id) != NULL &&
	401	per_cpu(processor_device_array, pr->id) != device) {
	402	dev_warn(&device->dev,
	403	"BIOS reported wrong ACPI id %d for the processor\n",
	404	pr->id);
	405	/* Give up, but do not abort the namespace scan. */
	406	goto err;
	407	}
	408	/*
	409	* processor_device_array is not cleared on errors to allow buggy BIOS
	410	* checks.
	411	*/
	412	per_cpu(processor_device_array, pr->id) = device;
2e4f1db4	413	per_cpu(processors, pr->id) = pr;
ac212b69 RW	414
ac212b69 RW	415	dev = get_cpu_device(pr->id);
173a5a4c HG	416	if (!dev) {
	417	result = -ENODEV;
	418	goto err;
	419	}
	420
24dee1fc	421	result = acpi_bind_one(dev, device);
ac212b69 RW	422	if (result)
	423	goto err;
	424
	425	pr->dev = dev;
ac212b69 RW	426
	427	/* Trigger the processor driver's .probe() if present. */
	428	if (device_attach(dev) >= 0)
	429	return 1;
	430
	431	dev_err(dev, "Processor driver could not be attached\n");
	432	acpi_unbind_one(dev);
	433
	434	err:
	435	free_cpumask_var(pr->throttling.shared_cpu_map);
	436	device->driver_data = NULL;
2e4f1db4	437	per_cpu(processors, pr->id) = NULL;
ac212b69 RW	438	err_free_pr:
	439	kfree(pr);
	440	return result;
	441	}
	442
	443	#ifdef CONFIG_ACPI_HOTPLUG_CPU
	444	/* --------------------------------------------------------------------------
	445	Removal
	446	-------------------------------------------------------------------------- */
	447
	448	static void acpi_processor_remove(struct acpi_device *device)
	449	{
	450	struct acpi_processor *pr;
	451
	452	if (!device \|\| !acpi_driver_data(device))
	453	return;
	454
	455	pr = acpi_driver_data(device);
	456	if (pr->id >= nr_cpu_ids)
	457	goto out;
	458
	459	/*
	460	* The only reason why we ever get here is CPU hot-removal. The CPU is
	461	* already offline and the ACPI device removal locking prevents it from
	462	* being put back online at this point.
	463	*
	464	* Unbind the driver from the processor device and detach it from the
	465	* ACPI companion object.
	466	*/
	467	device_release_driver(pr->dev);
	468	acpi_unbind_one(pr->dev);
	469
	470	/* Clean up. */
	471	per_cpu(processor_device_array, pr->id) = NULL;
2e4f1db4	472	per_cpu(processors, pr->id) = NULL;
ac212b69	473
b9d10be7 TK	474	cpu_maps_update_begin();
	475	cpu_hotplug_begin();
	476
ac212b69	477	/* Remove the CPU. */
ac212b69	478	arch_unregister_cpu(pr->id);
d02dc27d	479	acpi_unmap_cpu(pr->id);
b9d10be7 TK	480
	481	cpu_hotplug_done();
	482	cpu_maps_update_done();
ac212b69	483
1e385f6f YI	484	try_offline_node(cpu_to_node(pr->id));
1e385f6f YI	485
ac212b69 RW	486	out:
	487	free_cpumask_var(pr->throttling.shared_cpu_map);
	488	kfree(pr);
	489	}
	490	#endif /* CONFIG_ACPI_HOTPLUG_CPU */
	491
a2121167 SP	492	#ifdef CONFIG_X86
	493	static bool acpi_hwp_native_thermal_lvt_set;
	494	static acpi_status __init acpi_hwp_native_thermal_lvt_osc(acpi_handle handle,
	495	u32 lvl,
	496	void *context,
	497	void **rv)
	498	{
	499	u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953";
	500	u32 capbuf[2];
	501	struct acpi_osc_context osc_context = {
	502	.uuid_str = sb_uuid_str,
	503	.rev = 1,
	504	.cap.length = 8,
	505	.cap.pointer = capbuf,
	506	};
	507
	508	if (acpi_hwp_native_thermal_lvt_set)
	509	return AE_CTRL_TERMINATE;
	510
	511	capbuf[0] = 0x0000;
	512	capbuf[1] = 0x1000; /* set bit 12 */
	513
	514	if (ACPI_SUCCESS(acpi_run_osc(handle, &osc_context))) {
	515	if (osc_context.ret.pointer && osc_context.ret.length > 1) {
	516	u32 *capbuf_ret = osc_context.ret.pointer;
	517
	518	if (capbuf_ret[1] & 0x1000) {
	519	acpi_handle_info(handle,
	520	"_OSC native thermal LVT Acked\n");
	521	acpi_hwp_native_thermal_lvt_set = true;
	522	}
	523	}
	524	kfree(osc_context.ret.pointer);
	525	}
	526
	527	return AE_OK;
	528	}
	529
	530	void __init acpi_early_processor_osc(void)
	531	{
	532	if (boot_cpu_has(X86_FEATURE_HWP)) {
	533	acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
	534	ACPI_UINT32_MAX,
	535	acpi_hwp_native_thermal_lvt_osc,
	536	NULL, NULL, NULL);
	537	acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID,
	538	acpi_hwp_native_thermal_lvt_osc,
	539	NULL, NULL);
	540	}
	541	}
	542	#endif
	543
ac212b69 RW	544	/*
	545	* The following ACPI IDs are known to be suitable for representing as
	546	* processor devices.
	547	*/
	548	static const struct acpi_device_id processor_device_ids[] = {
	549
	550	{ ACPI_PROCESSOR_OBJECT_HID, },
	551	{ ACPI_PROCESSOR_DEVICE_HID, },
	552
	553	{ }
	554	};
	555
8ce344c6	556	static struct acpi_scan_handler processor_handler = {
ac212b69 RW	557	.ids = processor_device_ids,
	558	.attach = acpi_processor_add,
	559	#ifdef CONFIG_ACPI_HOTPLUG_CPU
	560	.detach = acpi_processor_remove,
	561	#endif
	562	.hotplug = {
	563	.enabled = true,
	564	},
	565	};
	566
db62fda3 SH	567	static int acpi_processor_container_attach(struct acpi_device *dev,
	568	const struct acpi_device_id *id)
	569	{
	570	return 1;
	571	}
	572
	573	static const struct acpi_device_id processor_container_ids[] = {
	574	{ ACPI_PROCESSOR_CONTAINER_HID, },
	575	{ }
	576	};
	577
	578	static struct acpi_scan_handler processor_container_handler = {
	579	.ids = processor_container_ids,
	580	.attach = acpi_processor_container_attach,
	581	};
	582
8e089eaa DL	583	/* The number of the unique processor IDs */
	584	static int nr_unique_ids __initdata;
	585
	586	/* The number of the duplicate processor IDs */
a77d6cd9	587	static int nr_duplicate_ids;
8e089eaa DL	588
	589	/* Used to store the unique processor IDs */
	590	static int unique_processor_ids[] __initdata = {
	591	[0 ... NR_CPUS - 1] = -1,
	592	};
	593
	594	/* Used to store the duplicate processor IDs */
a77d6cd9	595	static int duplicate_processor_ids[] = {
8e089eaa DL	596	[0 ... NR_CPUS - 1] = -1,
	597	};
	598
	599	static void __init processor_validated_ids_update(int proc_id)
	600	{
	601	int i;
	602
	603	if (nr_unique_ids == NR_CPUS\|\|nr_duplicate_ids == NR_CPUS)
	604	return;
	605
	606	/*
	607	* Firstly, compare the proc_id with duplicate IDs, if the proc_id is
	608	* already in the IDs, do nothing.
	609	*/
	610	for (i = 0; i < nr_duplicate_ids; i++) {
	611	if (duplicate_processor_ids[i] == proc_id)
	612	return;
	613	}
	614
	615	/*
	616	* Secondly, compare the proc_id with unique IDs, if the proc_id is in
	617	* the IDs, put it in the duplicate IDs.
	618	*/
	619	for (i = 0; i < nr_unique_ids; i++) {
	620	if (unique_processor_ids[i] == proc_id) {
	621	duplicate_processor_ids[nr_duplicate_ids] = proc_id;
	622	nr_duplicate_ids++;
	623	return;
	624	}
	625	}
	626
	627	/*
	628	* Lastly, the proc_id is a unique ID, put it in the unique IDs.
	629	*/
	630	unique_processor_ids[nr_unique_ids] = proc_id;
	631	nr_unique_ids++;
	632	}
	633
	634	static acpi_status __init acpi_processor_ids_walk(acpi_handle handle,
	635	u32 lvl,
	636	void *context,
	637	void **rv)
	638	{
	639	acpi_status status;
8c8cb30f DL	640	acpi_object_type acpi_type;
8c8cb30f DL	641	unsigned long long uid;
8e089eaa DL	642	union acpi_object object = { 0 };
	643	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
	644
8c8cb30f	645	status = acpi_get_type(handle, &acpi_type);
8e089eaa	646	if (ACPI_FAILURE(status))
d0381bf4	647	return status;
8c8cb30f DL	648
	649	switch (acpi_type) {
	650	case ACPI_TYPE_PROCESSOR:
	651	status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
	652	if (ACPI_FAILURE(status))
	653	goto err;
	654	uid = object.processor.proc_id;
	655	break;
	656
	657	case ACPI_TYPE_DEVICE:
	658	status = acpi_evaluate_integer(handle, "_UID", NULL, &uid);
	659	if (ACPI_FAILURE(status))
	660	goto err;
	661	break;
	662	default:
	663	goto err;
	664	}
	665
	666	processor_validated_ids_update(uid);
d0381bf4	667	return AE_OK;
8c8cb30f DL	668
8c8cb30f DL	669	err:
d0381bf4	670	/* Exit on error, but don't abort the namespace walk */
8c8cb30f	671	acpi_handle_info(handle, "Invalid processor object\n");
d0381bf4	672	return AE_OK;
8e089eaa	673
8e089eaa DL	674	}
8e089eaa DL	675
0ed780e3	676	static void __init acpi_processor_check_duplicates(void)
8e089eaa	677	{
8c8cb30f	678	/* check the correctness for all processors in ACPI namespace */
8e089eaa DL	679	acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
	680	ACPI_UINT32_MAX,
	681	acpi_processor_ids_walk,
	682	NULL, NULL, NULL);
8c8cb30f DL	683	acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_ids_walk,
8c8cb30f DL	684	NULL, NULL);
8e089eaa DL	685	}
8e089eaa DL	686
a77d6cd9	687	bool acpi_duplicate_processor_id(int proc_id)
fd74da21 DL	688	{
	689	int i;
	690
	691	/*
	692	* compare the proc_id with duplicate IDs, if the proc_id is already
	693	* in the duplicate IDs, return true, otherwise, return false.
	694	*/
	695	for (i = 0; i < nr_duplicate_ids; i++) {
	696	if (duplicate_processor_ids[i] == proc_id)
	697	return true;
	698	}
	699	return false;
	700	}
	701
ac212b69 RW	702	void __init acpi_processor_init(void)
ac212b69 RW	703	{
8e089eaa	704	acpi_processor_check_duplicates();
ac212b69	705	acpi_scan_add_handler_with_hotplug(&processor_handler, "processor");
db62fda3	706	acpi_scan_add_handler(&processor_container_handler);
ac212b69	707	}