Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
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>
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 : :
29 : : DEFINE_PER_CPU(struct acpi_processor *, processors);
30 : : EXPORT_PER_CPU_SYMBOL(processors);
31 : :
32 : : /* --------------------------------------------------------------------------
33 : : Errata Handling
34 : : -------------------------------------------------------------------------- */
35 : :
36 : : struct acpi_processor_errata errata __read_mostly;
37 : : EXPORT_SYMBOL_GPL(errata);
38 : :
39 : 21 : static int acpi_processor_errata_piix4(struct pci_dev *dev)
40 : : {
41 : 21 : u8 value1 = 0;
42 : 21 : u8 value2 = 0;
43 : :
44 : :
45 [ + - ]: 21 : if (!dev)
46 : : return -EINVAL;
47 : :
48 : : /*
49 : : * Note that 'dev' references the PIIX4 ACPI Controller.
50 : : */
51 : :
52 : 21 : 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 [ - + - ]: 21 : switch (dev->revision) {
71 : :
72 : 0 : 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 : 0 : errata.piix4.throttle = 1;
82 : : /* fall through*/
83 : :
84 : 21 : 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 : 21 : dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
101 : : PCI_DEVICE_ID_INTEL_82371AB,
102 : : PCI_ANY_ID, PCI_ANY_ID, NULL);
103 [ - + ]: 21 : if (dev) {
104 : 0 : errata.piix4.bmisx = pci_resource_start(dev, 4);
105 : 0 : 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 : 21 : dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
118 : : PCI_DEVICE_ID_INTEL_82371AB_0,
119 : : PCI_ANY_ID, PCI_ANY_ID, NULL);
120 [ - + ]: 21 : if (dev) {
121 : 0 : pci_read_config_byte(dev, 0x76, &value1);
122 : 0 : pci_read_config_byte(dev, 0x77, &value2);
123 [ # # # # ]: 0 : if ((value1 & 0x80) || (value2 & 0x80))
124 : 0 : errata.piix4.fdma = 1;
125 : 0 : pci_dev_put(dev);
126 : : }
127 : :
128 : : break;
129 : : }
130 : :
131 : 21 : if (errata.piix4.bmisx)
132 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
133 : : "Bus master activity detection (BM-IDE) erratum enabled\n"));
134 : 21 : if (errata.piix4.fdma)
135 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
136 : : "Type-F DMA livelock erratum (C3 disabled)\n"));
137 : :
138 : 21 : return 0;
139 : : }
140 : :
141 : 21 : static int acpi_processor_errata(void)
142 : : {
143 : 21 : int result = 0;
144 : 21 : struct pci_dev *dev = NULL;
145 : :
146 : : /*
147 : : * PIIX4
148 : : */
149 : 21 : dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
150 : : PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
151 : : PCI_ANY_ID, NULL);
152 [ + - ]: 21 : if (dev) {
153 : 21 : result = acpi_processor_errata_piix4(dev);
154 : 21 : pci_dev_put(dev);
155 : : }
156 : :
157 : 21 : return result;
158 : : }
159 : :
160 : : /* --------------------------------------------------------------------------
161 : : Initialization
162 : : -------------------------------------------------------------------------- */
163 : :
164 : : #ifdef CONFIG_ACPI_HOTPLUG_CPU
165 : 0 : int __weak acpi_map_cpu(acpi_handle handle,
166 : : phys_cpuid_t physid, u32 acpi_id, int *pcpu)
167 : : {
168 : 0 : return -ENODEV;
169 : : }
170 : :
171 : 0 : int __weak acpi_unmap_cpu(int cpu)
172 : : {
173 : 0 : return -ENODEV;
174 : : }
175 : :
176 : 0 : int __weak arch_register_cpu(int cpu)
177 : : {
178 : 0 : return -ENODEV;
179 : : }
180 : :
181 : 0 : void __weak arch_unregister_cpu(int cpu) {}
182 : :
183 : 0 : static int acpi_processor_hotadd_init(struct acpi_processor *pr)
184 : : {
185 : 0 : unsigned long long sta;
186 : 0 : acpi_status status;
187 : 0 : int ret;
188 : :
189 [ # # ]: 0 : if (invalid_phys_cpuid(pr->phys_id))
190 : : return -ENODEV;
191 : :
192 : 0 : status = acpi_evaluate_integer(pr->handle, "_STA", NULL, &sta);
193 [ # # # # ]: 0 : if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT))
194 : : return -ENODEV;
195 : :
196 : 0 : cpu_maps_update_begin();
197 : 0 : cpu_hotplug_begin();
198 : :
199 : 0 : ret = acpi_map_cpu(pr->handle, pr->phys_id, pr->acpi_id, &pr->id);
200 [ # # ]: 0 : if (ret)
201 : 0 : goto out;
202 : :
203 : 0 : ret = arch_register_cpu(pr->id);
204 [ # # ]: 0 : if (ret) {
205 : 0 : acpi_unmap_cpu(pr->id);
206 : 0 : goto out;
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 : 0 : pr_info("CPU%d has been hot-added\n", pr->id);
215 : 0 : pr->flags.need_hotplug_init = 1;
216 : :
217 : 0 : out:
218 : 0 : cpu_hotplug_done();
219 : 0 : cpu_maps_update_done();
220 : 0 : return ret;
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 : 21 : static int acpi_processor_get_info(struct acpi_device *device)
230 : : {
231 : 21 : union acpi_object object = { 0 };
232 : 21 : struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
233 : 21 : struct acpi_processor *pr = acpi_driver_data(device);
234 : 21 : int device_declaration = 0;
235 : 21 : acpi_status status = AE_OK;
236 : 21 : static int cpu0_initialized;
237 : 21 : unsigned long long value;
238 : :
239 : 21 : acpi_processor_errata();
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 [ - + - - ]: 21 : if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
246 : 0 : pr->flags.bm_control = 1;
247 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
248 : 0 : "Bus mastering arbitration control present\n"));
249 : : } else
250 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
251 : : "No bus mastering arbitration control\n"));
252 : :
253 [ + - ]: 21 : if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
254 : : /* Declared with "Processor" statement; match ProcessorID */
255 : 21 : status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
256 [ - + ]: 21 : if (ACPI_FAILURE(status)) {
257 : 0 : dev_err(&device->dev,
258 : : "Failed to evaluate processor object (0x%x)\n",
259 : : status);
260 : 0 : return -ENODEV;
261 : : }
262 : :
263 : 21 : 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 : : */
269 : 0 : status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
270 : : NULL, &value);
271 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
272 : 0 : dev_err(&device->dev,
273 : : "Failed to evaluate processor _UID (0x%x)\n",
274 : : status);
275 : 0 : return -ENODEV;
276 : : }
277 : 0 : device_declaration = 1;
278 : 0 : pr->acpi_id = value;
279 : : }
280 : :
281 [ - + ]: 21 : if (acpi_duplicate_processor_id(pr->acpi_id)) {
282 [ # # ]: 0 : if (pr->acpi_id == 0xff)
283 [ # # ]: 0 : dev_info_once(&device->dev,
284 : : "Entry not well-defined, consider updating BIOS\n");
285 : : else
286 : 0 : dev_err(&device->dev,
287 : : "Failed to get unique processor _UID (0x%x)\n",
288 : : pr->acpi_id);
289 : 0 : return -ENODEV;
290 : : }
291 : :
292 : 21 : pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration,
293 : : pr->acpi_id);
294 : 21 : if (invalid_phys_cpuid(pr->phys_id))
295 : : acpi_handle_debug(pr->handle, "failed to get CPU physical ID.\n");
296 : :
297 : 21 : pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id);
298 [ + - - + ]: 21 : if (!cpu0_initialized && !acpi_has_cpu_in_madt()) {
299 : 0 : cpu0_initialized = 1;
300 : : /*
301 : : * Handle UP system running SMP kernel, with no CPU
302 : : * entry in MADT
303 : : */
304 [ # # # # ]: 0 : if (invalid_logical_cpuid(pr->id) && (num_online_cpus() == 1))
305 : 0 : pr->id = 0;
306 : : }
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.
312 : : *
313 : : * NOTE: Even if the processor has a cpuid, it may not be present
314 : : * because cpuid <-> apicid mapping is persistent now.
315 : : */
316 [ + - - + ]: 42 : if (invalid_logical_cpuid(pr->id) || !cpu_present(pr->id)) {
317 : 0 : int ret = acpi_processor_hotadd_init(pr);
318 [ # # ]: 0 : if (ret)
319 : : return ret;
320 : : }
321 : :
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 : 21 : sprintf(acpi_device_bid(device), "CPU%X", pr->id);
332 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
333 : 21 : pr->acpi_id));
334 : :
335 [ - + ]: 21 : if (!object.processor.pblk_address)
336 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
337 [ # # ]: 0 : else if (object.processor.pblk_length != 6)
338 : 0 : dev_err(&device->dev, "Invalid PBLK length [%d]\n",
339 : : object.processor.pblk_length);
340 : : else {
341 : 0 : pr->throttling.address = object.processor.pblk_address;
342 : 0 : pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
343 : 0 : pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
344 : :
345 : 0 : pr->pblk = object.processor.pblk_address;
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 : : */
353 : 21 : status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value);
354 : 21 : if (ACPI_SUCCESS(status))
355 : : arch_fix_phys_package_id(pr->id, value);
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 : :
368 : 21 : static int acpi_processor_add(struct acpi_device *device,
369 : : const struct acpi_device_id *id)
370 : : {
371 : 21 : struct acpi_processor *pr;
372 : 21 : struct device *dev;
373 : 21 : int result = 0;
374 : :
375 : 21 : pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
376 [ + - ]: 21 : if (!pr)
377 : : return -ENOMEM;
378 : :
379 : 21 : if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
380 : : result = -ENOMEM;
381 : : goto err_free_pr;
382 : : }
383 : :
384 : 21 : pr->handle = device->handle;
385 : 21 : strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
386 : 21 : strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
387 : 21 : device->driver_data = pr;
388 : :
389 : 21 : result = acpi_processor_get_info(device);
390 [ + - ]: 21 : if (result) /* Processor is not physically present or unavailable */
391 : : return 0;
392 : :
393 [ - + ]: 21 : 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 [ - + ]: 21 : if (per_cpu(processor_device_array, pr->id) != NULL &&
401 [ # # ]: 0 : per_cpu(processor_device_array, pr->id) != device) {
402 : 0 : 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 : 0 : goto err;
407 : : }
408 : : /*
409 : : * processor_device_array is not cleared on errors to allow buggy BIOS
410 : : * checks.
411 : : */
412 : 21 : per_cpu(processor_device_array, pr->id) = device;
413 : 21 : per_cpu(processors, pr->id) = pr;
414 : :
415 : 21 : dev = get_cpu_device(pr->id);
416 [ - + ]: 21 : if (!dev) {
417 : 0 : result = -ENODEV;
418 : 0 : goto err;
419 : : }
420 : :
421 : 21 : result = acpi_bind_one(dev, device);
422 [ - + ]: 21 : if (result)
423 : 0 : goto err;
424 : :
425 : 21 : pr->dev = dev;
426 : :
427 : : /* Trigger the processor driver's .probe() if present. */
428 [ - + ]: 21 : if (device_attach(dev) >= 0)
429 : : return 1;
430 : :
431 : 0 : dev_err(dev, "Processor driver could not be attached\n");
432 : 0 : acpi_unbind_one(dev);
433 : :
434 : 0 : err:
435 : 0 : free_cpumask_var(pr->throttling.shared_cpu_map);
436 : 0 : device->driver_data = NULL;
437 : 0 : per_cpu(processors, pr->id) = NULL;
438 : : err_free_pr:
439 : 0 : kfree(pr);
440 : 0 : return result;
441 : : }
442 : :
443 : : #ifdef CONFIG_ACPI_HOTPLUG_CPU
444 : : /* --------------------------------------------------------------------------
445 : : Removal
446 : : -------------------------------------------------------------------------- */
447 : :
448 : 0 : static void acpi_processor_remove(struct acpi_device *device)
449 : : {
450 : 0 : struct acpi_processor *pr;
451 : :
452 [ # # # # ]: 0 : if (!device || !acpi_driver_data(device))
453 : : return;
454 : :
455 [ # # ]: 0 : pr = acpi_driver_data(device);
456 [ # # ]: 0 : if (pr->id >= nr_cpu_ids)
457 : 0 : 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 : 0 : device_release_driver(pr->dev);
468 : 0 : acpi_unbind_one(pr->dev);
469 : :
470 : : /* Clean up. */
471 : 0 : per_cpu(processor_device_array, pr->id) = NULL;
472 : 0 : per_cpu(processors, pr->id) = NULL;
473 : :
474 : 0 : cpu_maps_update_begin();
475 : 0 : cpu_hotplug_begin();
476 : :
477 : : /* Remove the CPU. */
478 : 0 : arch_unregister_cpu(pr->id);
479 : 0 : acpi_unmap_cpu(pr->id);
480 : :
481 : 0 : cpu_hotplug_done();
482 : 0 : cpu_maps_update_done();
483 : :
484 : 0 : try_offline_node(cpu_to_node(pr->id));
485 : :
486 : 0 : out:
487 : 0 : free_cpumask_var(pr->throttling.shared_cpu_map);
488 : 0 : kfree(pr);
489 : : }
490 : : #endif /* CONFIG_ACPI_HOTPLUG_CPU */
491 : :
492 : : #ifdef CONFIG_X86
493 : : static bool acpi_hwp_native_thermal_lvt_set;
494 : 0 : static acpi_status __init acpi_hwp_native_thermal_lvt_osc(acpi_handle handle,
495 : : u32 lvl,
496 : : void *context,
497 : : void **rv)
498 : : {
499 : 0 : u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953";
500 : 0 : u32 capbuf[2];
501 : 0 : 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 [ # # ]: 0 : if (acpi_hwp_native_thermal_lvt_set)
509 : : return AE_CTRL_TERMINATE;
510 : :
511 : 0 : capbuf[0] = 0x0000;
512 : 0 : capbuf[1] = 0x1000; /* set bit 12 */
513 : :
514 [ # # ]: 0 : if (ACPI_SUCCESS(acpi_run_osc(handle, &osc_context))) {
515 [ # # # # ]: 0 : if (osc_context.ret.pointer && osc_context.ret.length > 1) {
516 : 0 : u32 *capbuf_ret = osc_context.ret.pointer;
517 : :
518 [ # # ]: 0 : if (capbuf_ret[1] & 0x1000) {
519 : 0 : acpi_handle_info(handle,
520 : : "_OSC native thermal LVT Acked\n");
521 : 0 : acpi_hwp_native_thermal_lvt_set = true;
522 : : }
523 : : }
524 : 0 : kfree(osc_context.ret.pointer);
525 : : }
526 : :
527 : : return AE_OK;
528 : : }
529 : :
530 : 21 : void __init acpi_early_processor_osc(void)
531 : : {
532 [ - + ]: 21 : if (boot_cpu_has(X86_FEATURE_HWP)) {
533 : 0 : 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 : 0 : acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID,
538 : : acpi_hwp_native_thermal_lvt_osc,
539 : : NULL, NULL);
540 : : }
541 : 21 : }
542 : : #endif
543 : :
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 : :
556 : : static struct acpi_scan_handler processor_handler = {
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 : :
567 : 21 : static int acpi_processor_container_attach(struct acpi_device *dev,
568 : : const struct acpi_device_id *id)
569 : : {
570 : 21 : 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 : :
583 : : /* The number of the unique processor IDs */
584 : : static int nr_unique_ids __initdata;
585 : :
586 : : /* The number of the duplicate processor IDs */
587 : : static int nr_duplicate_ids;
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 */
595 : : static int duplicate_processor_ids[] = {
596 : : [0 ... NR_CPUS - 1] = -1,
597 : : };
598 : :
599 : 21 : static void __init processor_validated_ids_update(int proc_id)
600 : : {
601 : 21 : int i;
602 : :
603 [ + - + - ]: 21 : 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 [ - + ]: 21 : for (i = 0; i < nr_duplicate_ids; i++) {
611 [ # # ]: 0 : 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 [ - + ]: 21 : for (i = 0; i < nr_unique_ids; i++) {
620 [ # # ]: 0 : if (unique_processor_ids[i] == proc_id) {
621 : 0 : duplicate_processor_ids[nr_duplicate_ids] = proc_id;
622 : 0 : nr_duplicate_ids++;
623 : 0 : return;
624 : : }
625 : : }
626 : :
627 : : /*
628 : : * Lastly, the proc_id is a unique ID, put it in the unique IDs.
629 : : */
630 : 21 : unique_processor_ids[nr_unique_ids] = proc_id;
631 : 21 : nr_unique_ids++;
632 : : }
633 : :
634 : 21 : static acpi_status __init acpi_processor_ids_walk(acpi_handle handle,
635 : : u32 lvl,
636 : : void *context,
637 : : void **rv)
638 : : {
639 : 21 : acpi_status status;
640 : 21 : acpi_object_type acpi_type;
641 : 21 : unsigned long long uid;
642 : 21 : union acpi_object object = { 0 };
643 : 21 : struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
644 : :
645 : 21 : status = acpi_get_type(handle, &acpi_type);
646 [ + - ]: 21 : if (ACPI_FAILURE(status))
647 : : return status;
648 : :
649 [ + - - ]: 21 : switch (acpi_type) {
650 : 21 : case ACPI_TYPE_PROCESSOR:
651 : 21 : status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
652 [ - + ]: 21 : if (ACPI_FAILURE(status))
653 : 0 : goto err;
654 : 21 : uid = object.processor.proc_id;
655 : 21 : break;
656 : :
657 : 0 : case ACPI_TYPE_DEVICE:
658 : 0 : status = acpi_evaluate_integer(handle, "_UID", NULL, &uid);
659 [ # # ]: 0 : if (ACPI_FAILURE(status))
660 : 0 : goto err;
661 : : break;
662 : 0 : default:
663 : 0 : goto err;
664 : : }
665 : :
666 : 21 : processor_validated_ids_update(uid);
667 : 21 : return AE_OK;
668 : :
669 : 0 : err:
670 : : /* Exit on error, but don't abort the namespace walk */
671 : 0 : acpi_handle_info(handle, "Invalid processor object\n");
672 : 0 : return AE_OK;
673 : :
674 : : }
675 : :
676 : 21 : static void __init acpi_processor_check_duplicates(void)
677 : : {
678 : : /* check the correctness for all processors in ACPI namespace */
679 : 21 : acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
680 : : ACPI_UINT32_MAX,
681 : : acpi_processor_ids_walk,
682 : : NULL, NULL, NULL);
683 : 21 : acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_ids_walk,
684 : : NULL, NULL);
685 : 21 : }
686 : :
687 : 21 : bool acpi_duplicate_processor_id(int proc_id)
688 : : {
689 : 21 : 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 [ - - - + ]: 21 : for (i = 0; i < nr_duplicate_ids; i++) {
696 [ # # # # ]: 0 : if (duplicate_processor_ids[i] == proc_id)
697 : : return true;
698 : : }
699 : : return false;
700 : : }
701 : :
702 : 21 : void __init acpi_processor_init(void)
703 : : {
704 : 21 : acpi_processor_check_duplicates();
705 : 21 : acpi_scan_add_handler_with_hotplug(&processor_handler, "processor");
706 : 21 : acpi_scan_add_handler(&processor_container_handler);
707 : 21 : }
708 : :
709 : : #ifdef CONFIG_ACPI_PROCESSOR_CSTATE
710 : : /**
711 : : * acpi_processor_claim_cst_control - Request _CST control from the platform.
712 : : */
713 : 21 : bool acpi_processor_claim_cst_control(void)
714 : : {
715 : 21 : static bool cst_control_claimed;
716 : 21 : acpi_status status;
717 : :
718 [ - + - - ]: 21 : if (!acpi_gbl_FADT.cst_control || cst_control_claimed)
719 : : return true;
720 : :
721 : 0 : status = acpi_os_write_port(acpi_gbl_FADT.smi_command,
722 : : acpi_gbl_FADT.cst_control, 8);
723 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
724 : 0 : pr_warn("ACPI: Failed to claim processor _CST control\n");
725 : 0 : return false;
726 : : }
727 : :
728 : 0 : cst_control_claimed = true;
729 : 0 : return true;
730 : : }
731 : : EXPORT_SYMBOL_GPL(acpi_processor_claim_cst_control);
732 : :
733 : : /**
734 : : * acpi_processor_evaluate_cst - Evaluate the processor _CST control method.
735 : : * @handle: ACPI handle of the processor object containing the _CST.
736 : : * @cpu: The numeric ID of the target CPU.
737 : : * @info: Object write the C-states information into.
738 : : *
739 : : * Extract the C-state information for the given CPU from the output of the _CST
740 : : * control method under the corresponding ACPI processor object (or processor
741 : : * device object) and populate @info with it.
742 : : *
743 : : * If any ACPI_ADR_SPACE_FIXED_HARDWARE C-states are found, invoke
744 : : * acpi_processor_ffh_cstate_probe() to verify them and update the
745 : : * cpu_cstate_entry data for @cpu.
746 : : */
747 : 21 : int acpi_processor_evaluate_cst(acpi_handle handle, u32 cpu,
748 : : struct acpi_processor_power *info)
749 : : {
750 : 21 : struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
751 : 21 : union acpi_object *cst;
752 : 21 : acpi_status status;
753 : 21 : u64 count;
754 : 21 : int last_index = 0;
755 : 21 : int i, ret = 0;
756 : :
757 : 21 : status = acpi_evaluate_object(handle, "_CST", NULL, &buffer);
758 [ - + ]: 21 : if (ACPI_FAILURE(status)) {
759 : : acpi_handle_debug(handle, "No _CST\n");
760 : : return -ENODEV;
761 : : }
762 : :
763 : 0 : cst = buffer.pointer;
764 : :
765 : : /* There must be at least 2 elements. */
766 [ # # # # : 0 : if (!cst || cst->type != ACPI_TYPE_PACKAGE || cst->package.count < 2) {
# # ]
767 : 0 : acpi_handle_warn(handle, "Invalid _CST output\n");
768 : 0 : ret = -EFAULT;
769 : 0 : goto end;
770 : : }
771 : :
772 : 0 : count = cst->package.elements[0].integer.value;
773 : :
774 : : /* Validate the number of C-states. */
775 [ # # # # ]: 0 : if (count < 1 || count != cst->package.count - 1) {
776 : 0 : acpi_handle_warn(handle, "Inconsistent _CST data\n");
777 : 0 : ret = -EFAULT;
778 : 0 : goto end;
779 : : }
780 : :
781 [ # # ]: 0 : for (i = 1; i <= count; i++) {
782 : 0 : union acpi_object *element;
783 : 0 : union acpi_object *obj;
784 : 0 : struct acpi_power_register *reg;
785 : 0 : struct acpi_processor_cx cx;
786 : :
787 : : /*
788 : : * If there is not enough space for all C-states, skip the
789 : : * excess ones and log a warning.
790 : : */
791 [ # # ]: 0 : if (last_index >= ACPI_PROCESSOR_MAX_POWER - 1) {
792 : 0 : acpi_handle_warn(handle,
793 : : "No room for more idle states (limit: %d)\n",
794 : : ACPI_PROCESSOR_MAX_POWER - 1);
795 : 0 : break;
796 : : }
797 : :
798 : 0 : memset(&cx, 0, sizeof(cx));
799 : :
800 : 0 : element = &cst->package.elements[i];
801 [ # # ]: 0 : if (element->type != ACPI_TYPE_PACKAGE)
802 : 0 : continue;
803 : :
804 [ # # ]: 0 : if (element->package.count != 4)
805 : 0 : continue;
806 : :
807 : 0 : obj = &element->package.elements[0];
808 : :
809 [ # # ]: 0 : if (obj->type != ACPI_TYPE_BUFFER)
810 : 0 : continue;
811 : :
812 : 0 : reg = (struct acpi_power_register *)obj->buffer.pointer;
813 : :
814 : 0 : obj = &element->package.elements[1];
815 [ # # ]: 0 : if (obj->type != ACPI_TYPE_INTEGER)
816 : 0 : continue;
817 : :
818 : 0 : cx.type = obj->integer.value;
819 : : /*
820 : : * There are known cases in which the _CST output does not
821 : : * contain C1, so if the type of the first state found is not
822 : : * C1, leave an empty slot for C1 to be filled in later.
823 : : */
824 [ # # # # ]: 0 : if (i == 1 && cx.type != ACPI_STATE_C1)
825 : 0 : last_index = 1;
826 : :
827 : 0 : cx.address = reg->address;
828 : 0 : cx.index = last_index + 1;
829 : :
830 [ # # ]: 0 : if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
831 [ # # ]: 0 : if (!acpi_processor_ffh_cstate_probe(cpu, &cx, reg)) {
832 : : /*
833 : : * In the majority of cases _CST describes C1 as
834 : : * a FIXED_HARDWARE C-state, but if the command
835 : : * line forbids using MWAIT, use CSTATE_HALT for
836 : : * C1 regardless.
837 : : */
838 [ # # ]: 0 : if (cx.type == ACPI_STATE_C1 &&
839 [ # # ]: 0 : boot_option_idle_override == IDLE_NOMWAIT) {
840 : 0 : cx.entry_method = ACPI_CSTATE_HALT;
841 : 0 : snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
842 : : } else {
843 : 0 : cx.entry_method = ACPI_CSTATE_FFH;
844 : : }
845 [ # # ]: 0 : } else if (cx.type == ACPI_STATE_C1) {
846 : : /*
847 : : * In the special case of C1, FIXED_HARDWARE can
848 : : * be handled by executing the HLT instruction.
849 : : */
850 : 0 : cx.entry_method = ACPI_CSTATE_HALT;
851 : 0 : snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
852 : : } else {
853 : 0 : continue;
854 : : }
855 [ # # ]: 0 : } else if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
856 : 0 : cx.entry_method = ACPI_CSTATE_SYSTEMIO;
857 : 0 : snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x",
858 : : cx.address);
859 : : } else {
860 : 0 : continue;
861 : : }
862 : :
863 [ # # ]: 0 : if (cx.type == ACPI_STATE_C1)
864 : 0 : cx.valid = 1;
865 : :
866 : 0 : obj = &element->package.elements[2];
867 [ # # ]: 0 : if (obj->type != ACPI_TYPE_INTEGER)
868 : 0 : continue;
869 : :
870 : 0 : cx.latency = obj->integer.value;
871 : :
872 : 0 : obj = &element->package.elements[3];
873 [ # # ]: 0 : if (obj->type != ACPI_TYPE_INTEGER)
874 : 0 : continue;
875 : :
876 : 0 : memcpy(&info->states[++last_index], &cx, sizeof(cx));
877 : : }
878 : :
879 : 0 : acpi_handle_info(handle, "Found %d idle states\n", last_index);
880 : :
881 : 0 : info->count = last_index;
882 : :
883 : 0 : end:
884 : 0 : kfree(buffer.pointer);
885 : :
886 : 0 : return ret;
887 : : }
888 : : EXPORT_SYMBOL_GPL(acpi_processor_evaluate_cst);
889 : : #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */
|
