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 | #define pr_fmt(fmt) "ACPI: " fmt |
13 | |
14 | #include <linux/acpi.h> |
15 | #include <linux/cpu.h> |
16 | #include <linux/device.h> |
17 | #include <linux/dmi.h> |
18 | #include <linux/kernel.h> |
19 | #include <linux/module.h> |
20 | #include <linux/pci.h> |
21 | #include <linux/platform_device.h> |
22 | |
23 | #include <acpi/processor.h> |
24 | |
25 | #include <asm/cpu.h> |
26 | |
27 | #include <xen/xen.h> |
28 | |
29 | #include "internal.h" |
30 | |
31 | DEFINE_PER_CPU(struct acpi_processor *, processors); |
32 | EXPORT_PER_CPU_SYMBOL(processors); |
33 | |
34 | /* Errata Handling */ |
35 | struct acpi_processor_errata errata __read_mostly; |
36 | EXPORT_SYMBOL_GPL(errata); |
37 | |
38 | static int acpi_processor_errata_piix4(struct pci_dev *dev) |
39 | { |
40 | u8 value1 = 0; |
41 | u8 value2 = 0; |
42 | |
43 | |
44 | if (!dev) |
45 | return -EINVAL; |
46 | |
47 | /* |
48 | * Note that 'dev' references the PIIX4 ACPI Controller. |
49 | */ |
50 | |
51 | switch (dev->revision) { |
52 | case 0: |
53 | dev_dbg(&dev->dev, "Found PIIX4 A-step\n" ); |
54 | break; |
55 | case 1: |
56 | dev_dbg(&dev->dev, "Found PIIX4 B-step\n" ); |
57 | break; |
58 | case 2: |
59 | dev_dbg(&dev->dev, "Found PIIX4E\n" ); |
60 | break; |
61 | case 3: |
62 | dev_dbg(&dev->dev, "Found PIIX4M\n" ); |
63 | break; |
64 | default: |
65 | dev_dbg(&dev->dev, "Found unknown PIIX4\n" ); |
66 | break; |
67 | } |
68 | |
69 | switch (dev->revision) { |
70 | |
71 | case 0: /* PIIX4 A-step */ |
72 | case 1: /* PIIX4 B-step */ |
73 | /* |
74 | * See specification changes #13 ("Manual Throttle Duty Cycle") |
75 | * and #14 ("Enabling and Disabling Manual Throttle"), plus |
76 | * erratum #5 ("STPCLK# Deassertion Time") from the January |
77 | * 2002 PIIX4 specification update. Applies to only older |
78 | * PIIX4 models. |
79 | */ |
80 | errata.piix4.throttle = 1; |
81 | fallthrough; |
82 | |
83 | case 2: /* PIIX4E */ |
84 | case 3: /* PIIX4M */ |
85 | /* |
86 | * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA |
87 | * Livelock") from the January 2002 PIIX4 specification update. |
88 | * Applies to all PIIX4 models. |
89 | */ |
90 | |
91 | /* |
92 | * BM-IDE |
93 | * ------ |
94 | * Find the PIIX4 IDE Controller and get the Bus Master IDE |
95 | * Status register address. We'll use this later to read |
96 | * each IDE controller's DMA status to make sure we catch all |
97 | * DMA activity. |
98 | */ |
99 | dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, |
100 | PCI_DEVICE_ID_INTEL_82371AB, |
101 | PCI_ANY_ID, PCI_ANY_ID, NULL); |
102 | if (dev) { |
103 | errata.piix4.bmisx = pci_resource_start(dev, 4); |
104 | pci_dev_put(dev); |
105 | } |
106 | |
107 | /* |
108 | * Type-F DMA |
109 | * ---------- |
110 | * Find the PIIX4 ISA Controller and read the Motherboard |
111 | * DMA controller's status to see if Type-F (Fast) DMA mode |
112 | * is enabled (bit 7) on either channel. Note that we'll |
113 | * disable C3 support if this is enabled, as some legacy |
114 | * devices won't operate well if fast DMA is disabled. |
115 | */ |
116 | dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, |
117 | PCI_DEVICE_ID_INTEL_82371AB_0, |
118 | PCI_ANY_ID, PCI_ANY_ID, NULL); |
119 | if (dev) { |
120 | pci_read_config_byte(dev, where: 0x76, val: &value1); |
121 | pci_read_config_byte(dev, where: 0x77, val: &value2); |
122 | if ((value1 & 0x80) || (value2 & 0x80)) |
123 | errata.piix4.fdma = 1; |
124 | pci_dev_put(dev); |
125 | } |
126 | |
127 | break; |
128 | } |
129 | |
130 | if (errata.piix4.bmisx) |
131 | dev_dbg(&dev->dev, "Bus master activity detection (BM-IDE) erratum enabled\n" ); |
132 | if (errata.piix4.fdma) |
133 | dev_dbg(&dev->dev, "Type-F DMA livelock erratum (C3 disabled)\n" ); |
134 | |
135 | return 0; |
136 | } |
137 | |
138 | static int acpi_processor_errata(void) |
139 | { |
140 | int result = 0; |
141 | struct pci_dev *dev = NULL; |
142 | |
143 | /* |
144 | * PIIX4 |
145 | */ |
146 | dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, |
147 | PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID, |
148 | PCI_ANY_ID, NULL); |
149 | if (dev) { |
150 | result = acpi_processor_errata_piix4(dev); |
151 | pci_dev_put(dev); |
152 | } |
153 | |
154 | return result; |
155 | } |
156 | |
157 | /* Create a platform device to represent a CPU frequency control mechanism. */ |
158 | static void cpufreq_add_device(const char *name) |
159 | { |
160 | struct platform_device *pdev; |
161 | |
162 | pdev = platform_device_register_simple(name, PLATFORM_DEVID_NONE, NULL, num: 0); |
163 | if (IS_ERR(ptr: pdev)) |
164 | pr_info("%s device creation failed: %pe\n" , name, pdev); |
165 | } |
166 | |
167 | #ifdef CONFIG_X86 |
168 | /* Check presence of Processor Clocking Control by searching for \_SB.PCCH. */ |
169 | static void __init acpi_pcc_cpufreq_init(void) |
170 | { |
171 | acpi_status status; |
172 | acpi_handle handle; |
173 | |
174 | status = acpi_get_handle(NULL, pathname: "\\_SB" , ret_handle: &handle); |
175 | if (ACPI_FAILURE(status)) |
176 | return; |
177 | |
178 | if (acpi_has_method(handle, name: "PCCH" )) |
179 | cpufreq_add_device(name: "pcc-cpufreq" ); |
180 | } |
181 | #else |
182 | static void __init acpi_pcc_cpufreq_init(void) {} |
183 | #endif /* CONFIG_X86 */ |
184 | |
185 | /* Initialization */ |
186 | #ifdef CONFIG_ACPI_HOTPLUG_CPU |
187 | static int acpi_processor_hotadd_init(struct acpi_processor *pr) |
188 | { |
189 | unsigned long long sta; |
190 | acpi_status status; |
191 | int ret; |
192 | |
193 | if (invalid_phys_cpuid(phys_id: pr->phys_id)) |
194 | return -ENODEV; |
195 | |
196 | status = acpi_evaluate_integer(handle: pr->handle, pathname: "_STA" , NULL, data: &sta); |
197 | if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT)) |
198 | return -ENODEV; |
199 | |
200 | cpu_maps_update_begin(); |
201 | cpus_write_lock(); |
202 | |
203 | ret = acpi_map_cpu(handle: pr->handle, physid: pr->phys_id, acpi_id: pr->acpi_id, pcpu: &pr->id); |
204 | if (ret) |
205 | goto out; |
206 | |
207 | ret = arch_register_cpu(cpu: pr->id); |
208 | if (ret) { |
209 | acpi_unmap_cpu(cpu: pr->id); |
210 | goto out; |
211 | } |
212 | |
213 | /* |
214 | * CPU got hot-added, but cpu_data is not initialized yet. Set a flag |
215 | * to delay cpu_idle/throttling initialization and do it when the CPU |
216 | * gets online for the first time. |
217 | */ |
218 | pr_info("CPU%d has been hot-added\n" , pr->id); |
219 | pr->flags.need_hotplug_init = 1; |
220 | |
221 | out: |
222 | cpus_write_unlock(); |
223 | cpu_maps_update_done(); |
224 | return ret; |
225 | } |
226 | #else |
227 | static inline int acpi_processor_hotadd_init(struct acpi_processor *pr) |
228 | { |
229 | return -ENODEV; |
230 | } |
231 | #endif /* CONFIG_ACPI_HOTPLUG_CPU */ |
232 | |
233 | static int acpi_processor_get_info(struct acpi_device *device) |
234 | { |
235 | union acpi_object object = { 0 }; |
236 | struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; |
237 | struct acpi_processor *pr = acpi_driver_data(d: device); |
238 | int device_declaration = 0; |
239 | acpi_status status = AE_OK; |
240 | static int cpu0_initialized; |
241 | unsigned long long value; |
242 | |
243 | acpi_processor_errata(); |
244 | |
245 | /* |
246 | * Check to see if we have bus mastering arbitration control. This |
247 | * is required for proper C3 usage (to maintain cache coherency). |
248 | */ |
249 | if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) { |
250 | pr->flags.bm_control = 1; |
251 | dev_dbg(&device->dev, "Bus mastering arbitration control present\n" ); |
252 | } else |
253 | dev_dbg(&device->dev, "No bus mastering arbitration control\n" ); |
254 | |
255 | if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) { |
256 | /* Declared with "Processor" statement; match ProcessorID */ |
257 | status = acpi_evaluate_object(object: pr->handle, NULL, NULL, return_object_buffer: &buffer); |
258 | if (ACPI_FAILURE(status)) { |
259 | dev_err(&device->dev, |
260 | "Failed to evaluate processor object (0x%x)\n" , |
261 | status); |
262 | return -ENODEV; |
263 | } |
264 | |
265 | pr->acpi_id = object.processor.proc_id; |
266 | } else { |
267 | /* |
268 | * Declared with "Device" statement; match _UID. |
269 | */ |
270 | status = acpi_evaluate_integer(handle: pr->handle, METHOD_NAME__UID, |
271 | NULL, data: &value); |
272 | if (ACPI_FAILURE(status)) { |
273 | dev_err(&device->dev, |
274 | "Failed to evaluate processor _UID (0x%x)\n" , |
275 | status); |
276 | return -ENODEV; |
277 | } |
278 | device_declaration = 1; |
279 | pr->acpi_id = value; |
280 | } |
281 | |
282 | if (acpi_duplicate_processor_id(proc_id: pr->acpi_id)) { |
283 | if (pr->acpi_id == 0xff) |
284 | dev_info_once(&device->dev, |
285 | "Entry not well-defined, consider updating BIOS\n" ); |
286 | else |
287 | dev_err(&device->dev, |
288 | "Failed to get unique processor _UID (0x%x)\n" , |
289 | pr->acpi_id); |
290 | return -ENODEV; |
291 | } |
292 | |
293 | pr->phys_id = acpi_get_phys_id(pr->handle, type: device_declaration, |
294 | acpi_id: pr->acpi_id); |
295 | if (invalid_phys_cpuid(phys_id: pr->phys_id)) |
296 | dev_dbg(&device->dev, "Failed to get CPU physical ID.\n" ); |
297 | |
298 | pr->id = acpi_map_cpuid(phys_id: pr->phys_id, acpi_id: pr->acpi_id); |
299 | if (!cpu0_initialized) { |
300 | cpu0_initialized = 1; |
301 | /* |
302 | * Handle UP system running SMP kernel, with no CPU |
303 | * entry in MADT |
304 | */ |
305 | if (!acpi_has_cpu_in_madt() && invalid_logical_cpuid(cpuid: pr->id) && |
306 | (num_online_cpus() == 1)) |
307 | pr->id = 0; |
308 | /* |
309 | * Check availability of Processor Performance Control by |
310 | * looking at the presence of the _PCT object under the first |
311 | * processor definition. |
312 | */ |
313 | if (acpi_has_method(handle: pr->handle, name: "_PCT" )) |
314 | cpufreq_add_device(name: "acpi-cpufreq" ); |
315 | } |
316 | |
317 | /* |
318 | * Extra Processor objects may be enumerated on MP systems with |
319 | * less than the max # of CPUs. They should be ignored _iff |
320 | * they are physically not present. |
321 | * |
322 | * NOTE: Even if the processor has a cpuid, it may not be present |
323 | * because cpuid <-> apicid mapping is persistent now. |
324 | */ |
325 | if (invalid_logical_cpuid(cpuid: pr->id) || !cpu_present(cpu: pr->id)) { |
326 | int ret = acpi_processor_hotadd_init(pr); |
327 | |
328 | if (ret) |
329 | return ret; |
330 | } |
331 | |
332 | /* |
333 | * On some boxes several processors use the same processor bus id. |
334 | * But they are located in different scope. For example: |
335 | * \_SB.SCK0.CPU0 |
336 | * \_SB.SCK1.CPU0 |
337 | * Rename the processor device bus id. And the new bus id will be |
338 | * generated as the following format: |
339 | * CPU+CPU ID. |
340 | */ |
341 | sprintf(acpi_device_bid(device), fmt: "CPU%X" , pr->id); |
342 | dev_dbg(&device->dev, "Processor [%d:%d]\n" , pr->id, pr->acpi_id); |
343 | |
344 | if (!object.processor.pblk_address) |
345 | dev_dbg(&device->dev, "No PBLK (NULL address)\n" ); |
346 | else if (object.processor.pblk_length != 6) |
347 | dev_err(&device->dev, "Invalid PBLK length [%d]\n" , |
348 | object.processor.pblk_length); |
349 | else { |
350 | pr->throttling.address = object.processor.pblk_address; |
351 | pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset; |
352 | pr->throttling.duty_width = acpi_gbl_FADT.duty_width; |
353 | |
354 | pr->pblk = object.processor.pblk_address; |
355 | } |
356 | |
357 | /* |
358 | * If ACPI describes a slot number for this CPU, we can use it to |
359 | * ensure we get the right value in the "physical id" field |
360 | * of /proc/cpuinfo |
361 | */ |
362 | status = acpi_evaluate_integer(handle: pr->handle, pathname: "_SUN" , NULL, data: &value); |
363 | if (ACPI_SUCCESS(status)) |
364 | arch_fix_phys_package_id(num: pr->id, slot: value); |
365 | |
366 | return 0; |
367 | } |
368 | |
369 | /* |
370 | * Do not put anything in here which needs the core to be online. |
371 | * For example MSR access or setting up things which check for cpuinfo_x86 |
372 | * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc. |
373 | * Such things have to be put in and set up by the processor driver's .probe(). |
374 | */ |
375 | static DEFINE_PER_CPU(void *, processor_device_array); |
376 | |
377 | static int acpi_processor_add(struct acpi_device *device, |
378 | const struct acpi_device_id *id) |
379 | { |
380 | struct acpi_processor *pr; |
381 | struct device *dev; |
382 | int result = 0; |
383 | |
384 | if (!acpi_device_is_enabled(adev: device)) |
385 | return -ENODEV; |
386 | |
387 | pr = kzalloc(size: sizeof(struct acpi_processor), GFP_KERNEL); |
388 | if (!pr) |
389 | return -ENOMEM; |
390 | |
391 | if (!zalloc_cpumask_var(mask: &pr->throttling.shared_cpu_map, GFP_KERNEL)) { |
392 | result = -ENOMEM; |
393 | goto err_free_pr; |
394 | } |
395 | |
396 | pr->handle = device->handle; |
397 | strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME); |
398 | strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS); |
399 | device->driver_data = pr; |
400 | |
401 | result = acpi_processor_get_info(device); |
402 | if (result) /* Processor is not physically present or unavailable */ |
403 | return 0; |
404 | |
405 | BUG_ON(pr->id >= nr_cpu_ids); |
406 | |
407 | /* |
408 | * Buggy BIOS check. |
409 | * ACPI id of processors can be reported wrongly by the BIOS. |
410 | * Don't trust it blindly |
411 | */ |
412 | if (per_cpu(processor_device_array, pr->id) != NULL && |
413 | per_cpu(processor_device_array, pr->id) != device) { |
414 | dev_warn(&device->dev, |
415 | "BIOS reported wrong ACPI id %d for the processor\n" , |
416 | pr->id); |
417 | /* Give up, but do not abort the namespace scan. */ |
418 | goto err; |
419 | } |
420 | /* |
421 | * processor_device_array is not cleared on errors to allow buggy BIOS |
422 | * checks. |
423 | */ |
424 | per_cpu(processor_device_array, pr->id) = device; |
425 | per_cpu(processors, pr->id) = pr; |
426 | |
427 | dev = get_cpu_device(cpu: pr->id); |
428 | if (!dev) { |
429 | result = -ENODEV; |
430 | goto err; |
431 | } |
432 | |
433 | result = acpi_bind_one(dev, adev: device); |
434 | if (result) |
435 | goto err; |
436 | |
437 | pr->dev = dev; |
438 | |
439 | /* Trigger the processor driver's .probe() if present. */ |
440 | if (device_attach(dev) >= 0) |
441 | return 1; |
442 | |
443 | dev_err(dev, "Processor driver could not be attached\n" ); |
444 | acpi_unbind_one(dev); |
445 | |
446 | err: |
447 | free_cpumask_var(mask: pr->throttling.shared_cpu_map); |
448 | device->driver_data = NULL; |
449 | per_cpu(processors, pr->id) = NULL; |
450 | err_free_pr: |
451 | kfree(objp: pr); |
452 | return result; |
453 | } |
454 | |
455 | #ifdef CONFIG_ACPI_HOTPLUG_CPU |
456 | /* Removal */ |
457 | static void acpi_processor_remove(struct acpi_device *device) |
458 | { |
459 | struct acpi_processor *pr; |
460 | |
461 | if (!device || !acpi_driver_data(d: device)) |
462 | return; |
463 | |
464 | pr = acpi_driver_data(d: device); |
465 | if (pr->id >= nr_cpu_ids) |
466 | goto out; |
467 | |
468 | /* |
469 | * The only reason why we ever get here is CPU hot-removal. The CPU is |
470 | * already offline and the ACPI device removal locking prevents it from |
471 | * being put back online at this point. |
472 | * |
473 | * Unbind the driver from the processor device and detach it from the |
474 | * ACPI companion object. |
475 | */ |
476 | device_release_driver(dev: pr->dev); |
477 | acpi_unbind_one(dev: pr->dev); |
478 | |
479 | /* Clean up. */ |
480 | per_cpu(processor_device_array, pr->id) = NULL; |
481 | per_cpu(processors, pr->id) = NULL; |
482 | |
483 | cpu_maps_update_begin(); |
484 | cpus_write_lock(); |
485 | |
486 | /* Remove the CPU. */ |
487 | arch_unregister_cpu(cpu: pr->id); |
488 | acpi_unmap_cpu(cpu: pr->id); |
489 | |
490 | cpus_write_unlock(); |
491 | cpu_maps_update_done(); |
492 | |
493 | try_offline_node(cpu_to_node(cpu: pr->id)); |
494 | |
495 | out: |
496 | free_cpumask_var(mask: pr->throttling.shared_cpu_map); |
497 | kfree(objp: pr); |
498 | } |
499 | #endif /* CONFIG_ACPI_HOTPLUG_CPU */ |
500 | |
501 | #ifdef CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC |
502 | bool __init processor_physically_present(acpi_handle handle) |
503 | { |
504 | int cpuid, type; |
505 | u32 acpi_id; |
506 | acpi_status status; |
507 | acpi_object_type acpi_type; |
508 | unsigned long long tmp; |
509 | union acpi_object object = {}; |
510 | struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; |
511 | |
512 | status = acpi_get_type(object: handle, out_type: &acpi_type); |
513 | if (ACPI_FAILURE(status)) |
514 | return false; |
515 | |
516 | switch (acpi_type) { |
517 | case ACPI_TYPE_PROCESSOR: |
518 | status = acpi_evaluate_object(object: handle, NULL, NULL, return_object_buffer: &buffer); |
519 | if (ACPI_FAILURE(status)) |
520 | return false; |
521 | acpi_id = object.processor.proc_id; |
522 | break; |
523 | case ACPI_TYPE_DEVICE: |
524 | status = acpi_evaluate_integer(handle, METHOD_NAME__UID, |
525 | NULL, data: &tmp); |
526 | if (ACPI_FAILURE(status)) |
527 | return false; |
528 | acpi_id = tmp; |
529 | break; |
530 | default: |
531 | return false; |
532 | } |
533 | |
534 | if (xen_initial_domain()) |
535 | /* |
536 | * When running as a Xen dom0 the number of processors Linux |
537 | * sees can be different from the real number of processors on |
538 | * the system, and we still need to execute _PDC or _OSC for |
539 | * all of them. |
540 | */ |
541 | return xen_processor_present(acpi_id); |
542 | |
543 | type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0; |
544 | cpuid = acpi_get_cpuid(handle, type, acpi_id); |
545 | |
546 | return !invalid_logical_cpuid(cpuid); |
547 | } |
548 | |
549 | /* vendor specific UUID indicating an Intel platform */ |
550 | static u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953" ; |
551 | |
552 | static acpi_status __init acpi_processor_osc(acpi_handle handle, u32 lvl, |
553 | void *context, void **rv) |
554 | { |
555 | u32 capbuf[2] = {}; |
556 | struct acpi_osc_context osc_context = { |
557 | .uuid_str = sb_uuid_str, |
558 | .rev = 1, |
559 | .cap.length = 8, |
560 | .cap.pointer = capbuf, |
561 | }; |
562 | acpi_status status; |
563 | |
564 | if (!processor_physically_present(handle)) |
565 | return AE_OK; |
566 | |
567 | arch_acpi_set_proc_cap_bits(cap: &capbuf[OSC_SUPPORT_DWORD]); |
568 | |
569 | status = acpi_run_osc(handle, context: &osc_context); |
570 | if (ACPI_FAILURE(status)) |
571 | return status; |
572 | |
573 | kfree(objp: osc_context.ret.pointer); |
574 | |
575 | return AE_OK; |
576 | } |
577 | |
578 | static bool __init acpi_early_processor_osc(void) |
579 | { |
580 | acpi_status status; |
581 | |
582 | acpi_proc_quirk_mwait_check(); |
583 | |
584 | status = acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, |
585 | ACPI_UINT32_MAX, descending_callback: acpi_processor_osc, NULL, |
586 | NULL, NULL); |
587 | if (ACPI_FAILURE(status)) |
588 | return false; |
589 | |
590 | status = acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, user_function: acpi_processor_osc, |
591 | NULL, NULL); |
592 | if (ACPI_FAILURE(status)) |
593 | return false; |
594 | |
595 | return true; |
596 | } |
597 | |
598 | void __init acpi_early_processor_control_setup(void) |
599 | { |
600 | if (acpi_early_processor_osc()) { |
601 | pr_info("_OSC evaluated successfully for all CPUs\n" ); |
602 | } else { |
603 | pr_info("_OSC evaluation for CPUs failed, trying _PDC\n" ); |
604 | acpi_early_processor_set_pdc(); |
605 | } |
606 | } |
607 | #endif |
608 | |
609 | /* |
610 | * The following ACPI IDs are known to be suitable for representing as |
611 | * processor devices. |
612 | */ |
613 | static const struct acpi_device_id processor_device_ids[] = { |
614 | |
615 | { ACPI_PROCESSOR_OBJECT_HID, }, |
616 | { ACPI_PROCESSOR_DEVICE_HID, }, |
617 | |
618 | { } |
619 | }; |
620 | |
621 | static struct acpi_scan_handler processor_handler = { |
622 | .ids = processor_device_ids, |
623 | .attach = acpi_processor_add, |
624 | #ifdef CONFIG_ACPI_HOTPLUG_CPU |
625 | .detach = acpi_processor_remove, |
626 | #endif |
627 | .hotplug = { |
628 | .enabled = true, |
629 | }, |
630 | }; |
631 | |
632 | static int acpi_processor_container_attach(struct acpi_device *dev, |
633 | const struct acpi_device_id *id) |
634 | { |
635 | return 1; |
636 | } |
637 | |
638 | static const struct acpi_device_id processor_container_ids[] = { |
639 | { ACPI_PROCESSOR_CONTAINER_HID, }, |
640 | { } |
641 | }; |
642 | |
643 | static struct acpi_scan_handler processor_container_handler = { |
644 | .ids = processor_container_ids, |
645 | .attach = acpi_processor_container_attach, |
646 | }; |
647 | |
648 | /* The number of the unique processor IDs */ |
649 | static int nr_unique_ids __initdata; |
650 | |
651 | /* The number of the duplicate processor IDs */ |
652 | static int nr_duplicate_ids; |
653 | |
654 | /* Used to store the unique processor IDs */ |
655 | static int unique_processor_ids[] __initdata = { |
656 | [0 ... NR_CPUS - 1] = -1, |
657 | }; |
658 | |
659 | /* Used to store the duplicate processor IDs */ |
660 | static int duplicate_processor_ids[] = { |
661 | [0 ... NR_CPUS - 1] = -1, |
662 | }; |
663 | |
664 | static void __init processor_validated_ids_update(int proc_id) |
665 | { |
666 | int i; |
667 | |
668 | if (nr_unique_ids == NR_CPUS||nr_duplicate_ids == NR_CPUS) |
669 | return; |
670 | |
671 | /* |
672 | * Firstly, compare the proc_id with duplicate IDs, if the proc_id is |
673 | * already in the IDs, do nothing. |
674 | */ |
675 | for (i = 0; i < nr_duplicate_ids; i++) { |
676 | if (duplicate_processor_ids[i] == proc_id) |
677 | return; |
678 | } |
679 | |
680 | /* |
681 | * Secondly, compare the proc_id with unique IDs, if the proc_id is in |
682 | * the IDs, put it in the duplicate IDs. |
683 | */ |
684 | for (i = 0; i < nr_unique_ids; i++) { |
685 | if (unique_processor_ids[i] == proc_id) { |
686 | duplicate_processor_ids[nr_duplicate_ids] = proc_id; |
687 | nr_duplicate_ids++; |
688 | return; |
689 | } |
690 | } |
691 | |
692 | /* |
693 | * Lastly, the proc_id is a unique ID, put it in the unique IDs. |
694 | */ |
695 | unique_processor_ids[nr_unique_ids] = proc_id; |
696 | nr_unique_ids++; |
697 | } |
698 | |
699 | static acpi_status __init acpi_processor_ids_walk(acpi_handle handle, |
700 | u32 lvl, |
701 | void *context, |
702 | void **rv) |
703 | { |
704 | acpi_status status; |
705 | acpi_object_type acpi_type; |
706 | unsigned long long uid; |
707 | union acpi_object object = { 0 }; |
708 | struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; |
709 | |
710 | status = acpi_get_type(object: handle, out_type: &acpi_type); |
711 | if (ACPI_FAILURE(status)) |
712 | return status; |
713 | |
714 | switch (acpi_type) { |
715 | case ACPI_TYPE_PROCESSOR: |
716 | status = acpi_evaluate_object(object: handle, NULL, NULL, return_object_buffer: &buffer); |
717 | if (ACPI_FAILURE(status)) |
718 | goto err; |
719 | uid = object.processor.proc_id; |
720 | break; |
721 | |
722 | case ACPI_TYPE_DEVICE: |
723 | status = acpi_evaluate_integer(handle, pathname: "_UID" , NULL, data: &uid); |
724 | if (ACPI_FAILURE(status)) |
725 | goto err; |
726 | break; |
727 | default: |
728 | goto err; |
729 | } |
730 | |
731 | processor_validated_ids_update(proc_id: uid); |
732 | return AE_OK; |
733 | |
734 | err: |
735 | /* Exit on error, but don't abort the namespace walk */ |
736 | acpi_handle_info(handle, "Invalid processor object\n" ); |
737 | return AE_OK; |
738 | |
739 | } |
740 | |
741 | static void __init acpi_processor_check_duplicates(void) |
742 | { |
743 | /* check the correctness for all processors in ACPI namespace */ |
744 | acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, |
745 | ACPI_UINT32_MAX, |
746 | descending_callback: acpi_processor_ids_walk, |
747 | NULL, NULL, NULL); |
748 | acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, user_function: acpi_processor_ids_walk, |
749 | NULL, NULL); |
750 | } |
751 | |
752 | bool acpi_duplicate_processor_id(int proc_id) |
753 | { |
754 | int i; |
755 | |
756 | /* |
757 | * compare the proc_id with duplicate IDs, if the proc_id is already |
758 | * in the duplicate IDs, return true, otherwise, return false. |
759 | */ |
760 | for (i = 0; i < nr_duplicate_ids; i++) { |
761 | if (duplicate_processor_ids[i] == proc_id) |
762 | return true; |
763 | } |
764 | return false; |
765 | } |
766 | |
767 | void __init acpi_processor_init(void) |
768 | { |
769 | acpi_processor_check_duplicates(); |
770 | acpi_scan_add_handler_with_hotplug(handler: &processor_handler, hotplug_profile_name: "processor" ); |
771 | acpi_scan_add_handler(handler: &processor_container_handler); |
772 | acpi_pcc_cpufreq_init(); |
773 | } |
774 | |
775 | #ifdef CONFIG_ACPI_PROCESSOR_CSTATE |
776 | /** |
777 | * acpi_processor_claim_cst_control - Request _CST control from the platform. |
778 | */ |
779 | bool acpi_processor_claim_cst_control(void) |
780 | { |
781 | static bool cst_control_claimed; |
782 | acpi_status status; |
783 | |
784 | if (!acpi_gbl_FADT.cst_control || cst_control_claimed) |
785 | return true; |
786 | |
787 | status = acpi_os_write_port(address: acpi_gbl_FADT.smi_command, |
788 | value: acpi_gbl_FADT.cst_control, width: 8); |
789 | if (ACPI_FAILURE(status)) { |
790 | pr_warn("ACPI: Failed to claim processor _CST control\n" ); |
791 | return false; |
792 | } |
793 | |
794 | cst_control_claimed = true; |
795 | return true; |
796 | } |
797 | EXPORT_SYMBOL_GPL(acpi_processor_claim_cst_control); |
798 | |
799 | /** |
800 | * acpi_processor_evaluate_cst - Evaluate the processor _CST control method. |
801 | * @handle: ACPI handle of the processor object containing the _CST. |
802 | * @cpu: The numeric ID of the target CPU. |
803 | * @info: Object write the C-states information into. |
804 | * |
805 | * Extract the C-state information for the given CPU from the output of the _CST |
806 | * control method under the corresponding ACPI processor object (or processor |
807 | * device object) and populate @info with it. |
808 | * |
809 | * If any ACPI_ADR_SPACE_FIXED_HARDWARE C-states are found, invoke |
810 | * acpi_processor_ffh_cstate_probe() to verify them and update the |
811 | * cpu_cstate_entry data for @cpu. |
812 | */ |
813 | int acpi_processor_evaluate_cst(acpi_handle handle, u32 cpu, |
814 | struct acpi_processor_power *info) |
815 | { |
816 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; |
817 | union acpi_object *cst; |
818 | acpi_status status; |
819 | u64 count; |
820 | int last_index = 0; |
821 | int i, ret = 0; |
822 | |
823 | status = acpi_evaluate_object(object: handle, pathname: "_CST" , NULL, return_object_buffer: &buffer); |
824 | if (ACPI_FAILURE(status)) { |
825 | acpi_handle_debug(handle, "No _CST\n" ); |
826 | return -ENODEV; |
827 | } |
828 | |
829 | cst = buffer.pointer; |
830 | |
831 | /* There must be at least 2 elements. */ |
832 | if (!cst || cst->type != ACPI_TYPE_PACKAGE || cst->package.count < 2) { |
833 | acpi_handle_warn(handle, "Invalid _CST output\n" ); |
834 | ret = -EFAULT; |
835 | goto end; |
836 | } |
837 | |
838 | count = cst->package.elements[0].integer.value; |
839 | |
840 | /* Validate the number of C-states. */ |
841 | if (count < 1 || count != cst->package.count - 1) { |
842 | acpi_handle_warn(handle, "Inconsistent _CST data\n" ); |
843 | ret = -EFAULT; |
844 | goto end; |
845 | } |
846 | |
847 | for (i = 1; i <= count; i++) { |
848 | union acpi_object *element; |
849 | union acpi_object *obj; |
850 | struct acpi_power_register *reg; |
851 | struct acpi_processor_cx cx; |
852 | |
853 | /* |
854 | * If there is not enough space for all C-states, skip the |
855 | * excess ones and log a warning. |
856 | */ |
857 | if (last_index >= ACPI_PROCESSOR_MAX_POWER - 1) { |
858 | acpi_handle_warn(handle, |
859 | "No room for more idle states (limit: %d)\n" , |
860 | ACPI_PROCESSOR_MAX_POWER - 1); |
861 | break; |
862 | } |
863 | |
864 | memset(&cx, 0, sizeof(cx)); |
865 | |
866 | element = &cst->package.elements[i]; |
867 | if (element->type != ACPI_TYPE_PACKAGE) { |
868 | acpi_handle_info(handle, "_CST C%d type(%x) is not package, skip...\n" , |
869 | i, element->type); |
870 | continue; |
871 | } |
872 | |
873 | if (element->package.count != 4) { |
874 | acpi_handle_info(handle, "_CST C%d package count(%d) is not 4, skip...\n" , |
875 | i, element->package.count); |
876 | continue; |
877 | } |
878 | |
879 | obj = &element->package.elements[0]; |
880 | |
881 | if (obj->type != ACPI_TYPE_BUFFER) { |
882 | acpi_handle_info(handle, "_CST C%d package element[0] type(%x) is not buffer, skip...\n" , |
883 | i, obj->type); |
884 | continue; |
885 | } |
886 | |
887 | reg = (struct acpi_power_register *)obj->buffer.pointer; |
888 | |
889 | obj = &element->package.elements[1]; |
890 | if (obj->type != ACPI_TYPE_INTEGER) { |
891 | acpi_handle_info(handle, "_CST C[%d] package element[1] type(%x) is not integer, skip...\n" , |
892 | i, obj->type); |
893 | continue; |
894 | } |
895 | |
896 | cx.type = obj->integer.value; |
897 | /* |
898 | * There are known cases in which the _CST output does not |
899 | * contain C1, so if the type of the first state found is not |
900 | * C1, leave an empty slot for C1 to be filled in later. |
901 | */ |
902 | if (i == 1 && cx.type != ACPI_STATE_C1) |
903 | last_index = 1; |
904 | |
905 | cx.address = reg->address; |
906 | cx.index = last_index + 1; |
907 | |
908 | if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { |
909 | if (!acpi_processor_ffh_cstate_probe(cpu, cx: &cx, reg)) { |
910 | /* |
911 | * In the majority of cases _CST describes C1 as |
912 | * a FIXED_HARDWARE C-state, but if the command |
913 | * line forbids using MWAIT, use CSTATE_HALT for |
914 | * C1 regardless. |
915 | */ |
916 | if (cx.type == ACPI_STATE_C1 && |
917 | boot_option_idle_override == IDLE_NOMWAIT) { |
918 | cx.entry_method = ACPI_CSTATE_HALT; |
919 | snprintf(buf: cx.desc, ACPI_CX_DESC_LEN, fmt: "ACPI HLT" ); |
920 | } else { |
921 | cx.entry_method = ACPI_CSTATE_FFH; |
922 | } |
923 | } else if (cx.type == ACPI_STATE_C1) { |
924 | /* |
925 | * In the special case of C1, FIXED_HARDWARE can |
926 | * be handled by executing the HLT instruction. |
927 | */ |
928 | cx.entry_method = ACPI_CSTATE_HALT; |
929 | snprintf(buf: cx.desc, ACPI_CX_DESC_LEN, fmt: "ACPI HLT" ); |
930 | } else { |
931 | acpi_handle_info(handle, "_CST C%d declares FIXED_HARDWARE C-state but not supported in hardware, skip...\n" , |
932 | i); |
933 | continue; |
934 | } |
935 | } else if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) { |
936 | cx.entry_method = ACPI_CSTATE_SYSTEMIO; |
937 | snprintf(buf: cx.desc, ACPI_CX_DESC_LEN, fmt: "ACPI IOPORT 0x%x" , |
938 | cx.address); |
939 | } else { |
940 | acpi_handle_info(handle, "_CST C%d space_id(%x) neither FIXED_HARDWARE nor SYSTEM_IO, skip...\n" , |
941 | i, reg->space_id); |
942 | continue; |
943 | } |
944 | |
945 | if (cx.type == ACPI_STATE_C1) |
946 | cx.valid = 1; |
947 | |
948 | obj = &element->package.elements[2]; |
949 | if (obj->type != ACPI_TYPE_INTEGER) { |
950 | acpi_handle_info(handle, "_CST C%d package element[2] type(%x) not integer, skip...\n" , |
951 | i, obj->type); |
952 | continue; |
953 | } |
954 | |
955 | cx.latency = obj->integer.value; |
956 | |
957 | obj = &element->package.elements[3]; |
958 | if (obj->type != ACPI_TYPE_INTEGER) { |
959 | acpi_handle_info(handle, "_CST C%d package element[3] type(%x) not integer, skip...\n" , |
960 | i, obj->type); |
961 | continue; |
962 | } |
963 | |
964 | memcpy(&info->states[++last_index], &cx, sizeof(cx)); |
965 | } |
966 | |
967 | acpi_handle_info(handle, "Found %d idle states\n" , last_index); |
968 | |
969 | info->count = last_index; |
970 | |
971 | end: |
972 | kfree(objp: buffer.pointer); |
973 | |
974 | return ret; |
975 | } |
976 | EXPORT_SYMBOL_GPL(acpi_processor_evaluate_cst); |
977 | #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ |
978 | |