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 | 11 | */ |
003e0694 | 12 | #define pr_fmt(fmt) "ACPI: " fmt |
ac212b69 RW |
13 | |
14 | #include <linux/acpi.h> | |
c4dd854f | 15 | #include <linux/cpu.h> |
ac212b69 | 16 | #include <linux/device.h> |
3272a4aa | 17 | #include <linux/dmi.h> |
ac212b69 RW |
18 | #include <linux/kernel.h> |
19 | #include <linux/module.h> | |
20 | #include <linux/pci.h> | |
691a6371 | 21 | #include <linux/platform_device.h> |
ac212b69 RW |
22 | |
23 | #include <acpi/processor.h> | |
24 | ||
25 | #include <asm/cpu.h> | |
26 | ||
3272a4aa MW |
27 | #include <xen/xen.h> |
28 | ||
ac212b69 RW |
29 | #include "internal.h" |
30 | ||
2e4f1db4 RW |
31 | DEFINE_PER_CPU(struct acpi_processor *, processors); |
32 | EXPORT_PER_CPU_SYMBOL(processors); | |
33 | ||
c8deb1c2 | 34 | /* Errata Handling */ |
ac212b69 RW |
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: | |
52af99c3 | 53 | dev_dbg(&dev->dev, "Found PIIX4 A-step\n"); |
ac212b69 RW |
54 | break; |
55 | case 1: | |
52af99c3 | 56 | dev_dbg(&dev->dev, "Found PIIX4 B-step\n"); |
ac212b69 RW |
57 | break; |
58 | case 2: | |
52af99c3 | 59 | dev_dbg(&dev->dev, "Found PIIX4E\n"); |
ac212b69 RW |
60 | break; |
61 | case 3: | |
52af99c3 | 62 | dev_dbg(&dev->dev, "Found PIIX4M\n"); |
ac212b69 RW |
63 | break; |
64 | default: | |
52af99c3 | 65 | dev_dbg(&dev->dev, "Found unknown PIIX4\n"); |
ac212b69 RW |
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; | |
57d2dd4b | 81 | fallthrough; |
ac212b69 RW |
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, 0x76, &value1); | |
121 | pci_read_config_byte(dev, 0x77, &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) | |
52af99c3 | 131 | dev_dbg(&dev->dev, "Bus master activity detection (BM-IDE) erratum enabled\n"); |
ac212b69 | 132 | if (errata.piix4.fdma) |
52af99c3 | 133 | dev_dbg(&dev->dev, "Type-F DMA livelock erratum (C3 disabled)\n"); |
ac212b69 RW |
134 | |
135 | return 0; | |
136 | } | |
137 | ||
082e12a0 | 138 | static int acpi_processor_errata(void) |
ac212b69 RW |
139 | { |
140 | int result = 0; | |
141 | struct pci_dev *dev = NULL; | |
142 | ||
ac212b69 RW |
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 | ||
691a6371 PP |
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, 0); | |
163 | if (IS_ERR(pdev)) | |
164 | pr_info("%s device creation failed: %ld\n", name, PTR_ERR(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, "\\_SB", &handle); | |
175 | if (ACPI_FAILURE(status)) | |
176 | return; | |
177 | ||
178 | if (acpi_has_method(handle, "PCCH")) | |
179 | cpufreq_add_device("pcc-cpufreq"); | |
180 | } | |
181 | #else | |
182 | static void __init acpi_pcc_cpufreq_init(void) {} | |
183 | #endif /* CONFIG_X86 */ | |
184 | ||
c8deb1c2 | 185 | /* Initialization */ |
ac212b69 RW |
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 | ||
ddcc18f5 | 193 | if (invalid_phys_cpuid(pr->phys_id)) |
4985c32e LT |
194 | return -ENODEV; |
195 | ||
ac212b69 RW |
196 | status = acpi_evaluate_integer(pr->handle, "_STA", NULL, &sta); |
197 | if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT)) | |
198 | return -ENODEV; | |
199 | ||
b9d10be7 | 200 | cpu_maps_update_begin(); |
95ac7067 | 201 | cpus_write_lock(); |
b9d10be7 | 202 | |
febf2407 | 203 | ret = acpi_map_cpu(pr->handle, pr->phys_id, pr->acpi_id, &pr->id); |
ac212b69 | 204 | if (ret) |
b9d10be7 | 205 | goto out; |
ac212b69 RW |
206 | |
207 | ret = arch_register_cpu(pr->id); | |
208 | if (ret) { | |
d02dc27d | 209 | acpi_unmap_cpu(pr->id); |
b9d10be7 | 210 | goto out; |
ac212b69 RW |
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; | |
b9d10be7 TK |
220 | |
221 | out: | |
95ac7067 | 222 | cpus_write_unlock(); |
b9d10be7 TK |
223 | cpu_maps_update_done(); |
224 | return ret; | |
ac212b69 RW |
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(device); | |
05eb3cd8 | 238 | int device_declaration = 0; |
ac212b69 RW |
239 | acpi_status status = AE_OK; |
240 | static int cpu0_initialized; | |
6ebb5bc9 | 241 | unsigned long long value; |
ac212b69 | 242 | |
082e12a0 | 243 | acpi_processor_errata(); |
ac212b69 RW |
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; | |
52af99c3 | 251 | dev_dbg(&device->dev, "Bus mastering arbitration control present\n"); |
ac212b69 | 252 | } else |
52af99c3 | 253 | dev_dbg(&device->dev, "No bus mastering arbitration control\n"); |
ac212b69 RW |
254 | |
255 | if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) { | |
256 | /* Declared with "Processor" statement; match ProcessorID */ | |
257 | status = acpi_evaluate_object(pr->handle, NULL, NULL, &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 | ||
ac212b69 RW |
265 | pr->acpi_id = object.processor.proc_id; |
266 | } else { | |
267 | /* | |
268 | * Declared with "Device" statement; match _UID. | |
ac212b69 | 269 | */ |
ac212b69 RW |
270 | status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID, |
271 | NULL, &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 | } | |
ac212b69 | 281 | |
a77d6cd9 | 282 | if (acpi_duplicate_processor_id(pr->acpi_id)) { |
2c2b005f JS |
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); | |
a77d6cd9 DL |
290 | return -ENODEV; |
291 | } | |
292 | ||
8416c5bd HG |
293 | pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration, |
294 | pr->acpi_id); | |
ddcc18f5 | 295 | if (invalid_phys_cpuid(pr->phys_id)) |
52af99c3 | 296 | dev_dbg(&device->dev, "Failed to get CPU physical ID.\n"); |
ac212b69 | 297 | |
05eb3cd8 | 298 | pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id); |
691a6371 | 299 | if (!cpu0_initialized) { |
b981513f | 300 | cpu0_initialized = 1; |
af8f3f51 HG |
301 | /* |
302 | * Handle UP system running SMP kernel, with no CPU | |
303 | * entry in MADT | |
304 | */ | |
691a6371 PP |
305 | if (!acpi_has_cpu_in_madt() && invalid_logical_cpuid(pr->id) && |
306 | (num_online_cpus() == 1)) | |
05eb3cd8 | 307 | pr->id = 0; |
691a6371 PP |
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(pr->handle, "_PCT")) | |
314 | cpufreq_add_device("acpi-cpufreq"); | |
b981513f | 315 | } |
ac212b69 RW |
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. | |
8ad893fa GZ |
321 | * |
322 | * NOTE: Even if the processor has a cpuid, it may not be present | |
323 | * because cpuid <-> apicid mapping is persistent now. | |
ac212b69 | 324 | */ |
8ad893fa | 325 | if (invalid_logical_cpuid(pr->id) || !cpu_present(pr->id)) { |
ac212b69 | 326 | int ret = acpi_processor_hotadd_init(pr); |
c8deb1c2 | 327 | |
ac212b69 RW |
328 | if (ret) |
329 | return ret; | |
330 | } | |
b981513f | 331 | |
ac212b69 RW |
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), "CPU%X", pr->id); | |
52af99c3 | 342 | dev_dbg(&device->dev, "Processor [%d:%d]\n", pr->id, pr->acpi_id); |
ac212b69 RW |
343 | |
344 | if (!object.processor.pblk_address) | |
52af99c3 | 345 | dev_dbg(&device->dev, "No PBLK (NULL address)\n"); |
ac212b69 RW |
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; | |
ac212b69 RW |
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 | */ | |
6ebb5bc9 | 362 | status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value); |
ac212b69 | 363 | if (ACPI_SUCCESS(status)) |
6ebb5bc9 | 364 | arch_fix_phys_package_id(pr->id, value); |
ac212b69 RW |
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 | ||
fe7bf106 | 377 | static int acpi_processor_add(struct acpi_device *device, |
ac212b69 RW |
378 | const struct acpi_device_id *id) |
379 | { | |
380 | struct acpi_processor *pr; | |
381 | struct device *dev; | |
382 | int result = 0; | |
383 | ||
384 | pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL); | |
385 | if (!pr) | |
386 | return -ENOMEM; | |
387 | ||
388 | if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) { | |
389 | result = -ENOMEM; | |
390 | goto err_free_pr; | |
391 | } | |
392 | ||
393 | pr->handle = device->handle; | |
394 | strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME); | |
395 | strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS); | |
396 | device->driver_data = pr; | |
397 | ||
398 | result = acpi_processor_get_info(device); | |
399 | if (result) /* Processor is not physically present or unavailable */ | |
400 | return 0; | |
401 | ||
ac212b69 RW |
402 | BUG_ON(pr->id >= nr_cpu_ids); |
403 | ||
404 | /* | |
405 | * Buggy BIOS check. | |
406 | * ACPI id of processors can be reported wrongly by the BIOS. | |
407 | * Don't trust it blindly | |
408 | */ | |
409 | if (per_cpu(processor_device_array, pr->id) != NULL && | |
410 | per_cpu(processor_device_array, pr->id) != device) { | |
411 | dev_warn(&device->dev, | |
412 | "BIOS reported wrong ACPI id %d for the processor\n", | |
413 | pr->id); | |
414 | /* Give up, but do not abort the namespace scan. */ | |
415 | goto err; | |
416 | } | |
417 | /* | |
418 | * processor_device_array is not cleared on errors to allow buggy BIOS | |
419 | * checks. | |
420 | */ | |
421 | per_cpu(processor_device_array, pr->id) = device; | |
2e4f1db4 | 422 | per_cpu(processors, pr->id) = pr; |
ac212b69 RW |
423 | |
424 | dev = get_cpu_device(pr->id); | |
173a5a4c HG |
425 | if (!dev) { |
426 | result = -ENODEV; | |
427 | goto err; | |
428 | } | |
429 | ||
24dee1fc | 430 | result = acpi_bind_one(dev, device); |
ac212b69 RW |
431 | if (result) |
432 | goto err; | |
433 | ||
434 | pr->dev = dev; | |
ac212b69 RW |
435 | |
436 | /* Trigger the processor driver's .probe() if present. */ | |
437 | if (device_attach(dev) >= 0) | |
438 | return 1; | |
439 | ||
440 | dev_err(dev, "Processor driver could not be attached\n"); | |
441 | acpi_unbind_one(dev); | |
442 | ||
443 | err: | |
444 | free_cpumask_var(pr->throttling.shared_cpu_map); | |
445 | device->driver_data = NULL; | |
2e4f1db4 | 446 | per_cpu(processors, pr->id) = NULL; |
ac212b69 RW |
447 | err_free_pr: |
448 | kfree(pr); | |
449 | return result; | |
450 | } | |
451 | ||
452 | #ifdef CONFIG_ACPI_HOTPLUG_CPU | |
c8deb1c2 | 453 | /* Removal */ |
ac212b69 RW |
454 | static void acpi_processor_remove(struct acpi_device *device) |
455 | { | |
456 | struct acpi_processor *pr; | |
457 | ||
458 | if (!device || !acpi_driver_data(device)) | |
459 | return; | |
460 | ||
461 | pr = acpi_driver_data(device); | |
462 | if (pr->id >= nr_cpu_ids) | |
463 | goto out; | |
464 | ||
465 | /* | |
466 | * The only reason why we ever get here is CPU hot-removal. The CPU is | |
467 | * already offline and the ACPI device removal locking prevents it from | |
468 | * being put back online at this point. | |
469 | * | |
470 | * Unbind the driver from the processor device and detach it from the | |
471 | * ACPI companion object. | |
472 | */ | |
473 | device_release_driver(pr->dev); | |
474 | acpi_unbind_one(pr->dev); | |
475 | ||
476 | /* Clean up. */ | |
477 | per_cpu(processor_device_array, pr->id) = NULL; | |
2e4f1db4 | 478 | per_cpu(processors, pr->id) = NULL; |
ac212b69 | 479 | |
b9d10be7 | 480 | cpu_maps_update_begin(); |
95ac7067 | 481 | cpus_write_lock(); |
b9d10be7 | 482 | |
ac212b69 | 483 | /* Remove the CPU. */ |
ac212b69 | 484 | arch_unregister_cpu(pr->id); |
d02dc27d | 485 | acpi_unmap_cpu(pr->id); |
b9d10be7 | 486 | |
95ac7067 | 487 | cpus_write_unlock(); |
b9d10be7 | 488 | cpu_maps_update_done(); |
ac212b69 | 489 | |
1e385f6f YI |
490 | try_offline_node(cpu_to_node(pr->id)); |
491 | ||
ac212b69 RW |
492 | out: |
493 | free_cpumask_var(pr->throttling.shared_cpu_map); | |
494 | kfree(pr); | |
495 | } | |
496 | #endif /* CONFIG_ACPI_HOTPLUG_CPU */ | |
497 | ||
3272a4aa MW |
498 | #ifdef CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC |
499 | bool __init processor_physically_present(acpi_handle handle) | |
500 | { | |
501 | int cpuid, type; | |
502 | u32 acpi_id; | |
503 | acpi_status status; | |
504 | acpi_object_type acpi_type; | |
505 | unsigned long long tmp; | |
506 | union acpi_object object = {}; | |
507 | struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; | |
508 | ||
509 | status = acpi_get_type(handle, &acpi_type); | |
510 | if (ACPI_FAILURE(status)) | |
511 | return false; | |
512 | ||
513 | switch (acpi_type) { | |
514 | case ACPI_TYPE_PROCESSOR: | |
515 | status = acpi_evaluate_object(handle, NULL, NULL, &buffer); | |
516 | if (ACPI_FAILURE(status)) | |
517 | return false; | |
518 | acpi_id = object.processor.proc_id; | |
519 | break; | |
520 | case ACPI_TYPE_DEVICE: | |
521 | status = acpi_evaluate_integer(handle, METHOD_NAME__UID, | |
522 | NULL, &tmp); | |
523 | if (ACPI_FAILURE(status)) | |
524 | return false; | |
525 | acpi_id = tmp; | |
526 | break; | |
527 | default: | |
528 | return false; | |
529 | } | |
530 | ||
531 | if (xen_initial_domain()) | |
532 | /* | |
533 | * When running as a Xen dom0 the number of processors Linux | |
534 | * sees can be different from the real number of processors on | |
535 | * the system, and we still need to execute _PDC or _OSC for | |
536 | * all of them. | |
537 | */ | |
538 | return xen_processor_present(acpi_id); | |
539 | ||
540 | type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0; | |
541 | cpuid = acpi_get_cpuid(handle, type, acpi_id); | |
542 | ||
543 | return !invalid_logical_cpuid(cpuid); | |
544 | } | |
545 | ||
5ba30be7 MW |
546 | /* vendor specific UUID indicating an Intel platform */ |
547 | static u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953"; | |
5ba30be7 MW |
548 | |
549 | static acpi_status __init acpi_processor_osc(acpi_handle handle, u32 lvl, | |
550 | void *context, void **rv) | |
551 | { | |
552 | u32 capbuf[2] = {}; | |
553 | struct acpi_osc_context osc_context = { | |
554 | .uuid_str = sb_uuid_str, | |
555 | .rev = 1, | |
556 | .cap.length = 8, | |
557 | .cap.pointer = capbuf, | |
558 | }; | |
559 | acpi_status status; | |
560 | ||
561 | if (!processor_physically_present(handle)) | |
562 | return AE_OK; | |
563 | ||
564 | arch_acpi_set_proc_cap_bits(&capbuf[OSC_SUPPORT_DWORD]); | |
565 | ||
566 | status = acpi_run_osc(handle, &osc_context); | |
567 | if (ACPI_FAILURE(status)) | |
568 | return status; | |
569 | ||
570 | kfree(osc_context.ret.pointer); | |
571 | ||
572 | return AE_OK; | |
573 | } | |
574 | ||
95272641 | 575 | static bool __init acpi_early_processor_osc(void) |
a2121167 | 576 | { |
95272641 MW |
577 | acpi_status status; |
578 | ||
579 | acpi_proc_quirk_mwait_check(); | |
580 | ||
581 | status = acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, | |
582 | ACPI_UINT32_MAX, acpi_processor_osc, NULL, | |
583 | NULL, NULL); | |
584 | if (ACPI_FAILURE(status)) | |
585 | return false; | |
586 | ||
587 | status = acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_osc, | |
588 | NULL, NULL); | |
589 | if (ACPI_FAILURE(status)) | |
590 | return false; | |
591 | ||
592 | return true; | |
593 | } | |
594 | ||
595 | void __init acpi_early_processor_control_setup(void) | |
596 | { | |
597 | if (acpi_early_processor_osc()) { | |
003e0694 | 598 | pr_info("_OSC evaluated successfully for all CPUs\n"); |
95272641 | 599 | } else { |
003e0694 | 600 | pr_info("_OSC evaluation for CPUs failed, trying _PDC\n"); |
95272641 | 601 | acpi_early_processor_set_pdc(); |
a2121167 SP |
602 | } |
603 | } | |
604 | #endif | |
605 | ||
ac212b69 RW |
606 | /* |
607 | * The following ACPI IDs are known to be suitable for representing as | |
608 | * processor devices. | |
609 | */ | |
610 | static const struct acpi_device_id processor_device_ids[] = { | |
611 | ||
612 | { ACPI_PROCESSOR_OBJECT_HID, }, | |
613 | { ACPI_PROCESSOR_DEVICE_HID, }, | |
614 | ||
615 | { } | |
616 | }; | |
617 | ||
8ce344c6 | 618 | static struct acpi_scan_handler processor_handler = { |
ac212b69 RW |
619 | .ids = processor_device_ids, |
620 | .attach = acpi_processor_add, | |
621 | #ifdef CONFIG_ACPI_HOTPLUG_CPU | |
622 | .detach = acpi_processor_remove, | |
623 | #endif | |
624 | .hotplug = { | |
625 | .enabled = true, | |
626 | }, | |
627 | }; | |
628 | ||
db62fda3 SH |
629 | static int acpi_processor_container_attach(struct acpi_device *dev, |
630 | const struct acpi_device_id *id) | |
631 | { | |
632 | return 1; | |
633 | } | |
634 | ||
635 | static const struct acpi_device_id processor_container_ids[] = { | |
636 | { ACPI_PROCESSOR_CONTAINER_HID, }, | |
637 | { } | |
638 | }; | |
639 | ||
640 | static struct acpi_scan_handler processor_container_handler = { | |
641 | .ids = processor_container_ids, | |
642 | .attach = acpi_processor_container_attach, | |
643 | }; | |
644 | ||
8e089eaa DL |
645 | /* The number of the unique processor IDs */ |
646 | static int nr_unique_ids __initdata; | |
647 | ||
648 | /* The number of the duplicate processor IDs */ | |
a77d6cd9 | 649 | static int nr_duplicate_ids; |
8e089eaa DL |
650 | |
651 | /* Used to store the unique processor IDs */ | |
652 | static int unique_processor_ids[] __initdata = { | |
653 | [0 ... NR_CPUS - 1] = -1, | |
654 | }; | |
655 | ||
656 | /* Used to store the duplicate processor IDs */ | |
a77d6cd9 | 657 | static int duplicate_processor_ids[] = { |
8e089eaa DL |
658 | [0 ... NR_CPUS - 1] = -1, |
659 | }; | |
660 | ||
661 | static void __init processor_validated_ids_update(int proc_id) | |
662 | { | |
663 | int i; | |
664 | ||
665 | if (nr_unique_ids == NR_CPUS||nr_duplicate_ids == NR_CPUS) | |
666 | return; | |
667 | ||
668 | /* | |
669 | * Firstly, compare the proc_id with duplicate IDs, if the proc_id is | |
670 | * already in the IDs, do nothing. | |
671 | */ | |
672 | for (i = 0; i < nr_duplicate_ids; i++) { | |
673 | if (duplicate_processor_ids[i] == proc_id) | |
674 | return; | |
675 | } | |
676 | ||
677 | /* | |
678 | * Secondly, compare the proc_id with unique IDs, if the proc_id is in | |
679 | * the IDs, put it in the duplicate IDs. | |
680 | */ | |
681 | for (i = 0; i < nr_unique_ids; i++) { | |
682 | if (unique_processor_ids[i] == proc_id) { | |
683 | duplicate_processor_ids[nr_duplicate_ids] = proc_id; | |
684 | nr_duplicate_ids++; | |
685 | return; | |
686 | } | |
687 | } | |
688 | ||
689 | /* | |
690 | * Lastly, the proc_id is a unique ID, put it in the unique IDs. | |
691 | */ | |
692 | unique_processor_ids[nr_unique_ids] = proc_id; | |
693 | nr_unique_ids++; | |
694 | } | |
695 | ||
696 | static acpi_status __init acpi_processor_ids_walk(acpi_handle handle, | |
697 | u32 lvl, | |
698 | void *context, | |
699 | void **rv) | |
700 | { | |
701 | acpi_status status; | |
8c8cb30f DL |
702 | acpi_object_type acpi_type; |
703 | unsigned long long uid; | |
8e089eaa DL |
704 | union acpi_object object = { 0 }; |
705 | struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; | |
706 | ||
8c8cb30f | 707 | status = acpi_get_type(handle, &acpi_type); |
8e089eaa | 708 | if (ACPI_FAILURE(status)) |
d0381bf4 | 709 | return status; |
8c8cb30f DL |
710 | |
711 | switch (acpi_type) { | |
712 | case ACPI_TYPE_PROCESSOR: | |
713 | status = acpi_evaluate_object(handle, NULL, NULL, &buffer); | |
714 | if (ACPI_FAILURE(status)) | |
715 | goto err; | |
716 | uid = object.processor.proc_id; | |
717 | break; | |
718 | ||
719 | case ACPI_TYPE_DEVICE: | |
720 | status = acpi_evaluate_integer(handle, "_UID", NULL, &uid); | |
721 | if (ACPI_FAILURE(status)) | |
722 | goto err; | |
723 | break; | |
724 | default: | |
725 | goto err; | |
726 | } | |
727 | ||
728 | processor_validated_ids_update(uid); | |
d0381bf4 | 729 | return AE_OK; |
8c8cb30f DL |
730 | |
731 | err: | |
d0381bf4 | 732 | /* Exit on error, but don't abort the namespace walk */ |
8c8cb30f | 733 | acpi_handle_info(handle, "Invalid processor object\n"); |
d0381bf4 | 734 | return AE_OK; |
8e089eaa | 735 | |
8e089eaa DL |
736 | } |
737 | ||
0ed780e3 | 738 | static void __init acpi_processor_check_duplicates(void) |
8e089eaa | 739 | { |
8c8cb30f | 740 | /* check the correctness for all processors in ACPI namespace */ |
8e089eaa DL |
741 | acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, |
742 | ACPI_UINT32_MAX, | |
743 | acpi_processor_ids_walk, | |
744 | NULL, NULL, NULL); | |
8c8cb30f DL |
745 | acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_ids_walk, |
746 | NULL, NULL); | |
8e089eaa DL |
747 | } |
748 | ||
a77d6cd9 | 749 | bool acpi_duplicate_processor_id(int proc_id) |
fd74da21 DL |
750 | { |
751 | int i; | |
752 | ||
753 | /* | |
754 | * compare the proc_id with duplicate IDs, if the proc_id is already | |
755 | * in the duplicate IDs, return true, otherwise, return false. | |
756 | */ | |
757 | for (i = 0; i < nr_duplicate_ids; i++) { | |
758 | if (duplicate_processor_ids[i] == proc_id) | |
759 | return true; | |
760 | } | |
761 | return false; | |
762 | } | |
763 | ||
ac212b69 RW |
764 | void __init acpi_processor_init(void) |
765 | { | |
8e089eaa | 766 | acpi_processor_check_duplicates(); |
ac212b69 | 767 | acpi_scan_add_handler_with_hotplug(&processor_handler, "processor"); |
db62fda3 | 768 | acpi_scan_add_handler(&processor_container_handler); |
691a6371 | 769 | acpi_pcc_cpufreq_init(); |
ac212b69 | 770 | } |
bc946388 RW |
771 | |
772 | #ifdef CONFIG_ACPI_PROCESSOR_CSTATE | |
773 | /** | |
774 | * acpi_processor_claim_cst_control - Request _CST control from the platform. | |
775 | */ | |
776 | bool acpi_processor_claim_cst_control(void) | |
777 | { | |
778 | static bool cst_control_claimed; | |
779 | acpi_status status; | |
780 | ||
781 | if (!acpi_gbl_FADT.cst_control || cst_control_claimed) | |
782 | return true; | |
783 | ||
784 | status = acpi_os_write_port(acpi_gbl_FADT.smi_command, | |
785 | acpi_gbl_FADT.cst_control, 8); | |
786 | if (ACPI_FAILURE(status)) { | |
787 | pr_warn("ACPI: Failed to claim processor _CST control\n"); | |
788 | return false; | |
789 | } | |
790 | ||
791 | cst_control_claimed = true; | |
792 | return true; | |
793 | } | |
794 | EXPORT_SYMBOL_GPL(acpi_processor_claim_cst_control); | |
77fb4e0a RW |
795 | |
796 | /** | |
797 | * acpi_processor_evaluate_cst - Evaluate the processor _CST control method. | |
798 | * @handle: ACPI handle of the processor object containing the _CST. | |
799 | * @cpu: The numeric ID of the target CPU. | |
800 | * @info: Object write the C-states information into. | |
801 | * | |
802 | * Extract the C-state information for the given CPU from the output of the _CST | |
803 | * control method under the corresponding ACPI processor object (or processor | |
804 | * device object) and populate @info with it. | |
805 | * | |
806 | * If any ACPI_ADR_SPACE_FIXED_HARDWARE C-states are found, invoke | |
807 | * acpi_processor_ffh_cstate_probe() to verify them and update the | |
808 | * cpu_cstate_entry data for @cpu. | |
809 | */ | |
810 | int acpi_processor_evaluate_cst(acpi_handle handle, u32 cpu, | |
811 | struct acpi_processor_power *info) | |
812 | { | |
813 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; | |
814 | union acpi_object *cst; | |
815 | acpi_status status; | |
816 | u64 count; | |
817 | int last_index = 0; | |
818 | int i, ret = 0; | |
819 | ||
820 | status = acpi_evaluate_object(handle, "_CST", NULL, &buffer); | |
821 | if (ACPI_FAILURE(status)) { | |
822 | acpi_handle_debug(handle, "No _CST\n"); | |
823 | return -ENODEV; | |
824 | } | |
825 | ||
826 | cst = buffer.pointer; | |
827 | ||
828 | /* There must be at least 2 elements. */ | |
829 | if (!cst || cst->type != ACPI_TYPE_PACKAGE || cst->package.count < 2) { | |
830 | acpi_handle_warn(handle, "Invalid _CST output\n"); | |
831 | ret = -EFAULT; | |
832 | goto end; | |
833 | } | |
834 | ||
835 | count = cst->package.elements[0].integer.value; | |
836 | ||
837 | /* Validate the number of C-states. */ | |
838 | if (count < 1 || count != cst->package.count - 1) { | |
839 | acpi_handle_warn(handle, "Inconsistent _CST data\n"); | |
840 | ret = -EFAULT; | |
841 | goto end; | |
842 | } | |
843 | ||
844 | for (i = 1; i <= count; i++) { | |
845 | union acpi_object *element; | |
846 | union acpi_object *obj; | |
847 | struct acpi_power_register *reg; | |
848 | struct acpi_processor_cx cx; | |
849 | ||
850 | /* | |
851 | * If there is not enough space for all C-states, skip the | |
852 | * excess ones and log a warning. | |
853 | */ | |
854 | if (last_index >= ACPI_PROCESSOR_MAX_POWER - 1) { | |
855 | acpi_handle_warn(handle, | |
856 | "No room for more idle states (limit: %d)\n", | |
857 | ACPI_PROCESSOR_MAX_POWER - 1); | |
858 | break; | |
859 | } | |
860 | ||
861 | memset(&cx, 0, sizeof(cx)); | |
862 | ||
863 | element = &cst->package.elements[i]; | |
653f68b6 CY |
864 | if (element->type != ACPI_TYPE_PACKAGE) { |
865 | acpi_handle_info(handle, "_CST C%d type(%x) is not package, skip...\n", | |
866 | i, element->type); | |
77fb4e0a | 867 | continue; |
653f68b6 | 868 | } |
77fb4e0a | 869 | |
653f68b6 CY |
870 | if (element->package.count != 4) { |
871 | acpi_handle_info(handle, "_CST C%d package count(%d) is not 4, skip...\n", | |
872 | i, element->package.count); | |
77fb4e0a | 873 | continue; |
653f68b6 | 874 | } |
77fb4e0a RW |
875 | |
876 | obj = &element->package.elements[0]; | |
877 | ||
653f68b6 CY |
878 | if (obj->type != ACPI_TYPE_BUFFER) { |
879 | acpi_handle_info(handle, "_CST C%d package element[0] type(%x) is not buffer, skip...\n", | |
880 | i, obj->type); | |
77fb4e0a | 881 | continue; |
653f68b6 | 882 | } |
77fb4e0a RW |
883 | |
884 | reg = (struct acpi_power_register *)obj->buffer.pointer; | |
885 | ||
886 | obj = &element->package.elements[1]; | |
653f68b6 CY |
887 | if (obj->type != ACPI_TYPE_INTEGER) { |
888 | acpi_handle_info(handle, "_CST C[%d] package element[1] type(%x) is not integer, skip...\n", | |
889 | i, obj->type); | |
77fb4e0a | 890 | continue; |
653f68b6 | 891 | } |
77fb4e0a RW |
892 | |
893 | cx.type = obj->integer.value; | |
894 | /* | |
895 | * There are known cases in which the _CST output does not | |
896 | * contain C1, so if the type of the first state found is not | |
897 | * C1, leave an empty slot for C1 to be filled in later. | |
898 | */ | |
899 | if (i == 1 && cx.type != ACPI_STATE_C1) | |
900 | last_index = 1; | |
901 | ||
902 | cx.address = reg->address; | |
903 | cx.index = last_index + 1; | |
904 | ||
905 | if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { | |
906 | if (!acpi_processor_ffh_cstate_probe(cpu, &cx, reg)) { | |
907 | /* | |
908 | * In the majority of cases _CST describes C1 as | |
909 | * a FIXED_HARDWARE C-state, but if the command | |
910 | * line forbids using MWAIT, use CSTATE_HALT for | |
911 | * C1 regardless. | |
912 | */ | |
913 | if (cx.type == ACPI_STATE_C1 && | |
914 | boot_option_idle_override == IDLE_NOMWAIT) { | |
915 | cx.entry_method = ACPI_CSTATE_HALT; | |
916 | snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); | |
917 | } else { | |
918 | cx.entry_method = ACPI_CSTATE_FFH; | |
919 | } | |
920 | } else if (cx.type == ACPI_STATE_C1) { | |
921 | /* | |
922 | * In the special case of C1, FIXED_HARDWARE can | |
923 | * be handled by executing the HLT instruction. | |
924 | */ | |
925 | cx.entry_method = ACPI_CSTATE_HALT; | |
926 | snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); | |
927 | } else { | |
653f68b6 CY |
928 | acpi_handle_info(handle, "_CST C%d declares FIXED_HARDWARE C-state but not supported in hardware, skip...\n", |
929 | i); | |
77fb4e0a RW |
930 | continue; |
931 | } | |
932 | } else if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) { | |
933 | cx.entry_method = ACPI_CSTATE_SYSTEMIO; | |
934 | snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x", | |
935 | cx.address); | |
936 | } else { | |
653f68b6 CY |
937 | acpi_handle_info(handle, "_CST C%d space_id(%x) neither FIXED_HARDWARE nor SYSTEM_IO, skip...\n", |
938 | i, reg->space_id); | |
77fb4e0a RW |
939 | continue; |
940 | } | |
941 | ||
942 | if (cx.type == ACPI_STATE_C1) | |
943 | cx.valid = 1; | |
944 | ||
945 | obj = &element->package.elements[2]; | |
653f68b6 CY |
946 | if (obj->type != ACPI_TYPE_INTEGER) { |
947 | acpi_handle_info(handle, "_CST C%d package element[2] type(%x) not integer, skip...\n", | |
948 | i, obj->type); | |
77fb4e0a | 949 | continue; |
653f68b6 | 950 | } |
77fb4e0a RW |
951 | |
952 | cx.latency = obj->integer.value; | |
953 | ||
954 | obj = &element->package.elements[3]; | |
653f68b6 CY |
955 | if (obj->type != ACPI_TYPE_INTEGER) { |
956 | acpi_handle_info(handle, "_CST C%d package element[3] type(%x) not integer, skip...\n", | |
957 | i, obj->type); | |
77fb4e0a | 958 | continue; |
653f68b6 | 959 | } |
77fb4e0a RW |
960 | |
961 | memcpy(&info->states[++last_index], &cx, sizeof(cx)); | |
962 | } | |
963 | ||
964 | acpi_handle_info(handle, "Found %d idle states\n", last_index); | |
965 | ||
966 | info->count = last_index; | |
967 | ||
c8deb1c2 | 968 | end: |
77fb4e0a RW |
969 | kfree(buffer.pointer); |
970 | ||
971 | return ret; | |
972 | } | |
973 | EXPORT_SYMBOL_GPL(acpi_processor_evaluate_cst); | |
bc946388 | 974 | #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ |