2 * acpi_processor.c - ACPI processor enumeration support
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 * Copyright (C) 2013, Intel Corporation
9 * Rafael J. Wysocki <rafael.j.wysocki@intel.com>
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License version 2 as published
13 * by the Free Software Foundation.
16 #include <linux/acpi.h>
17 #include <linux/device.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/pci.h>
22 #include <acpi/processor.h>
28 #define _COMPONENT ACPI_PROCESSOR_COMPONENT
30 ACPI_MODULE_NAME("processor");
32 DEFINE_PER_CPU(struct acpi_processor
*, processors
);
33 EXPORT_PER_CPU_SYMBOL(processors
);
35 /* --------------------------------------------------------------------------
37 -------------------------------------------------------------------------- */
39 struct acpi_processor_errata errata __read_mostly
;
40 EXPORT_SYMBOL_GPL(errata
);
42 static int acpi_processor_errata_piix4(struct pci_dev
*dev
)
52 * Note that 'dev' references the PIIX4 ACPI Controller.
55 switch (dev
->revision
) {
57 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Found PIIX4 A-step\n"));
60 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Found PIIX4 B-step\n"));
63 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Found PIIX4E\n"));
66 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Found PIIX4M\n"));
69 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Found unknown PIIX4\n"));
73 switch (dev
->revision
) {
75 case 0: /* PIIX4 A-step */
76 case 1: /* PIIX4 B-step */
78 * See specification changes #13 ("Manual Throttle Duty Cycle")
79 * and #14 ("Enabling and Disabling Manual Throttle"), plus
80 * erratum #5 ("STPCLK# Deassertion Time") from the January
81 * 2002 PIIX4 specification update. Applies to only older
84 errata
.piix4
.throttle
= 1;
89 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
90 * Livelock") from the January 2002 PIIX4 specification update.
91 * Applies to all PIIX4 models.
97 * Find the PIIX4 IDE Controller and get the Bus Master IDE
98 * Status register address. We'll use this later to read
99 * each IDE controller's DMA status to make sure we catch all
102 dev
= pci_get_subsys(PCI_VENDOR_ID_INTEL
,
103 PCI_DEVICE_ID_INTEL_82371AB
,
104 PCI_ANY_ID
, PCI_ANY_ID
, NULL
);
106 errata
.piix4
.bmisx
= pci_resource_start(dev
, 4);
113 * Find the PIIX4 ISA Controller and read the Motherboard
114 * DMA controller's status to see if Type-F (Fast) DMA mode
115 * is enabled (bit 7) on either channel. Note that we'll
116 * disable C3 support if this is enabled, as some legacy
117 * devices won't operate well if fast DMA is disabled.
119 dev
= pci_get_subsys(PCI_VENDOR_ID_INTEL
,
120 PCI_DEVICE_ID_INTEL_82371AB_0
,
121 PCI_ANY_ID
, PCI_ANY_ID
, NULL
);
123 pci_read_config_byte(dev
, 0x76, &value1
);
124 pci_read_config_byte(dev
, 0x77, &value2
);
125 if ((value1
& 0x80) || (value2
& 0x80))
126 errata
.piix4
.fdma
= 1;
133 if (errata
.piix4
.bmisx
)
134 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
135 "Bus master activity detection (BM-IDE) erratum enabled\n"));
136 if (errata
.piix4
.fdma
)
137 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
138 "Type-F DMA livelock erratum (C3 disabled)\n"));
143 static int acpi_processor_errata(struct acpi_processor
*pr
)
146 struct pci_dev
*dev
= NULL
;
155 dev
= pci_get_subsys(PCI_VENDOR_ID_INTEL
,
156 PCI_DEVICE_ID_INTEL_82371AB_3
, PCI_ANY_ID
,
159 result
= acpi_processor_errata_piix4(dev
);
166 /* --------------------------------------------------------------------------
168 -------------------------------------------------------------------------- */
170 #ifdef CONFIG_ACPI_HOTPLUG_CPU
171 static int acpi_processor_hotadd_init(struct acpi_processor
*pr
)
173 unsigned long long sta
;
177 status
= acpi_evaluate_integer(pr
->handle
, "_STA", NULL
, &sta
);
178 if (ACPI_FAILURE(status
) || !(sta
& ACPI_STA_DEVICE_PRESENT
))
181 cpu_maps_update_begin();
184 ret
= acpi_map_lsapic(pr
->handle
, &pr
->id
);
188 ret
= arch_register_cpu(pr
->id
);
190 acpi_unmap_lsapic(pr
->id
);
195 * CPU got hot-added, but cpu_data is not initialized yet. Set a flag
196 * to delay cpu_idle/throttling initialization and do it when the CPU
197 * gets online for the first time.
199 pr_info("CPU%d has been hot-added\n", pr
->id
);
200 pr
->flags
.need_hotplug_init
= 1;
204 cpu_maps_update_done();
208 static inline int acpi_processor_hotadd_init(struct acpi_processor
*pr
)
212 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
214 static int acpi_processor_get_info(struct acpi_device
*device
)
216 union acpi_object object
= { 0 };
217 struct acpi_buffer buffer
= { sizeof(union acpi_object
), &object
};
218 struct acpi_processor
*pr
= acpi_driver_data(device
);
219 int cpu_index
, device_declaration
= 0;
220 acpi_status status
= AE_OK
;
221 static int cpu0_initialized
;
223 if (num_online_cpus() > 1)
226 acpi_processor_errata(pr
);
229 * Check to see if we have bus mastering arbitration control. This
230 * is required for proper C3 usage (to maintain cache coherency).
232 if (acpi_gbl_FADT
.pm2_control_block
&& acpi_gbl_FADT
.pm2_control_length
) {
233 pr
->flags
.bm_control
= 1;
234 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
235 "Bus mastering arbitration control present\n"));
237 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
238 "No bus mastering arbitration control\n"));
240 if (!strcmp(acpi_device_hid(device
), ACPI_PROCESSOR_OBJECT_HID
)) {
241 /* Declared with "Processor" statement; match ProcessorID */
242 status
= acpi_evaluate_object(pr
->handle
, NULL
, NULL
, &buffer
);
243 if (ACPI_FAILURE(status
)) {
244 dev_err(&device
->dev
,
245 "Failed to evaluate processor object (0x%x)\n",
251 * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP.
252 * >>> 'acpi_get_processor_id(acpi_id, &id)' in
255 pr
->acpi_id
= object
.processor
.proc_id
;
258 * Declared with "Device" statement; match _UID.
259 * Note that we don't handle string _UIDs yet.
261 unsigned long long value
;
262 status
= acpi_evaluate_integer(pr
->handle
, METHOD_NAME__UID
,
264 if (ACPI_FAILURE(status
)) {
265 dev_err(&device
->dev
,
266 "Failed to evaluate processor _UID (0x%x)\n",
270 device_declaration
= 1;
273 cpu_index
= acpi_get_cpuid(pr
->handle
, device_declaration
, pr
->acpi_id
);
275 /* Handle UP system running SMP kernel, with no LAPIC in MADT */
276 if (!cpu0_initialized
&& (cpu_index
== -1) &&
277 (num_online_cpus() == 1)) {
281 cpu0_initialized
= 1;
286 * Extra Processor objects may be enumerated on MP systems with
287 * less than the max # of CPUs. They should be ignored _iff
288 * they are physically not present.
291 int ret
= acpi_processor_hotadd_init(pr
);
296 * On some boxes several processors use the same processor bus id.
297 * But they are located in different scope. For example:
300 * Rename the processor device bus id. And the new bus id will be
301 * generated as the following format:
304 sprintf(acpi_device_bid(device
), "CPU%X", pr
->id
);
305 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Processor [%d:%d]\n", pr
->id
,
308 if (!object
.processor
.pblk_address
)
309 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "No PBLK (NULL address)\n"));
310 else if (object
.processor
.pblk_length
!= 6)
311 dev_err(&device
->dev
, "Invalid PBLK length [%d]\n",
312 object
.processor
.pblk_length
);
314 pr
->throttling
.address
= object
.processor
.pblk_address
;
315 pr
->throttling
.duty_offset
= acpi_gbl_FADT
.duty_offset
;
316 pr
->throttling
.duty_width
= acpi_gbl_FADT
.duty_width
;
318 pr
->pblk
= object
.processor
.pblk_address
;
321 * We don't care about error returns - we just try to mark
322 * these reserved so that nobody else is confused into thinking
323 * that this region might be unused..
325 * (In particular, allocating the IO range for Cardbus)
327 request_region(pr
->throttling
.address
, 6, "ACPI CPU throttle");
331 * If ACPI describes a slot number for this CPU, we can use it to
332 * ensure we get the right value in the "physical id" field
335 status
= acpi_evaluate_object(pr
->handle
, "_SUN", NULL
, &buffer
);
336 if (ACPI_SUCCESS(status
))
337 arch_fix_phys_package_id(pr
->id
, object
.integer
.value
);
343 * Do not put anything in here which needs the core to be online.
344 * For example MSR access or setting up things which check for cpuinfo_x86
345 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
346 * Such things have to be put in and set up by the processor driver's .probe().
348 static DEFINE_PER_CPU(void *, processor_device_array
);
350 static int acpi_processor_add(struct acpi_device
*device
,
351 const struct acpi_device_id
*id
)
353 struct acpi_processor
*pr
;
357 pr
= kzalloc(sizeof(struct acpi_processor
), GFP_KERNEL
);
361 if (!zalloc_cpumask_var(&pr
->throttling
.shared_cpu_map
, GFP_KERNEL
)) {
366 pr
->handle
= device
->handle
;
367 strcpy(acpi_device_name(device
), ACPI_PROCESSOR_DEVICE_NAME
);
368 strcpy(acpi_device_class(device
), ACPI_PROCESSOR_CLASS
);
369 device
->driver_data
= pr
;
371 result
= acpi_processor_get_info(device
);
372 if (result
) /* Processor is not physically present or unavailable */
376 if (pr
->id
>= setup_max_cpus
&& pr
->id
!= 0)
380 BUG_ON(pr
->id
>= nr_cpu_ids
);
384 * ACPI id of processors can be reported wrongly by the BIOS.
385 * Don't trust it blindly
387 if (per_cpu(processor_device_array
, pr
->id
) != NULL
&&
388 per_cpu(processor_device_array
, pr
->id
) != device
) {
389 dev_warn(&device
->dev
,
390 "BIOS reported wrong ACPI id %d for the processor\n",
392 /* Give up, but do not abort the namespace scan. */
396 * processor_device_array is not cleared on errors to allow buggy BIOS
399 per_cpu(processor_device_array
, pr
->id
) = device
;
400 per_cpu(processors
, pr
->id
) = pr
;
402 dev
= get_cpu_device(pr
->id
);
408 result
= acpi_bind_one(dev
, pr
->handle
);
413 dev
->offline
= pr
->flags
.need_hotplug_init
;
415 /* Trigger the processor driver's .probe() if present. */
416 if (device_attach(dev
) >= 0)
419 dev_err(dev
, "Processor driver could not be attached\n");
420 acpi_unbind_one(dev
);
423 free_cpumask_var(pr
->throttling
.shared_cpu_map
);
424 device
->driver_data
= NULL
;
425 per_cpu(processors
, pr
->id
) = NULL
;
431 #ifdef CONFIG_ACPI_HOTPLUG_CPU
432 /* --------------------------------------------------------------------------
434 -------------------------------------------------------------------------- */
436 static void acpi_processor_remove(struct acpi_device
*device
)
438 struct acpi_processor
*pr
;
440 if (!device
|| !acpi_driver_data(device
))
443 pr
= acpi_driver_data(device
);
444 if (pr
->id
>= nr_cpu_ids
)
448 * The only reason why we ever get here is CPU hot-removal. The CPU is
449 * already offline and the ACPI device removal locking prevents it from
450 * being put back online at this point.
452 * Unbind the driver from the processor device and detach it from the
453 * ACPI companion object.
455 device_release_driver(pr
->dev
);
456 acpi_unbind_one(pr
->dev
);
459 per_cpu(processor_device_array
, pr
->id
) = NULL
;
460 per_cpu(processors
, pr
->id
) = NULL
;
462 cpu_maps_update_begin();
465 /* Remove the CPU. */
466 arch_unregister_cpu(pr
->id
);
467 acpi_unmap_lsapic(pr
->id
);
470 cpu_maps_update_done();
472 try_offline_node(cpu_to_node(pr
->id
));
475 free_cpumask_var(pr
->throttling
.shared_cpu_map
);
478 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
481 * The following ACPI IDs are known to be suitable for representing as
484 static const struct acpi_device_id processor_device_ids
[] = {
486 { ACPI_PROCESSOR_OBJECT_HID
, },
487 { ACPI_PROCESSOR_DEVICE_HID
, },
492 static struct acpi_scan_handler __refdata processor_handler
= {
493 .ids
= processor_device_ids
,
494 .attach
= acpi_processor_add
,
495 #ifdef CONFIG_ACPI_HOTPLUG_CPU
496 .detach
= acpi_processor_remove
,
503 void __init
acpi_processor_init(void)
505 acpi_scan_add_handler_with_hotplug(&processor_handler
, "processor");