1/*
2 * acpi_processor.c - ACPI processor enumeration support
3 *
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 * Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
7 * Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
8 * Copyright (C) 2013, Intel Corporation
9 *                     Rafael J. Wysocki <rafael.j.wysocki@intel.com>
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License version 2 as published
13 * by the Free Software Foundation.
14 */
15
16#include <linux/acpi.h>
17#include <linux/device.h>
18#include <linux/kernel.h>
19#include <linux/module.h>
20#include <linux/pci.h>
21
22#include <acpi/processor.h>
23
24#include <asm/cpu.h>
25
26#include "internal.h"
27
28#define _COMPONENT	ACPI_PROCESSOR_COMPONENT
29
30ACPI_MODULE_NAME("processor");
31
32DEFINE_PER_CPU(struct acpi_processor *, processors);
33EXPORT_PER_CPU_SYMBOL(processors);
34
35/* --------------------------------------------------------------------------
36                                Errata Handling
37   -------------------------------------------------------------------------- */
38
39struct acpi_processor_errata errata __read_mostly;
40EXPORT_SYMBOL_GPL(errata);
41
42static int acpi_processor_errata_piix4(struct pci_dev *dev)
43{
44	u8 value1 = 0;
45	u8 value2 = 0;
46
47
48	if (!dev)
49		return -EINVAL;
50
51	/*
52	 * Note that 'dev' references the PIIX4 ACPI Controller.
53	 */
54
55	switch (dev->revision) {
56	case 0:
57		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
58		break;
59	case 1:
60		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
61		break;
62	case 2:
63		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
64		break;
65	case 3:
66		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
67		break;
68	default:
69		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
70		break;
71	}
72
73	switch (dev->revision) {
74
75	case 0:		/* PIIX4 A-step */
76	case 1:		/* PIIX4 B-step */
77		/*
78		 * See specification changes #13 ("Manual Throttle Duty Cycle")
79		 * and #14 ("Enabling and Disabling Manual Throttle"), plus
80		 * erratum #5 ("STPCLK# Deassertion Time") from the January
81		 * 2002 PIIX4 specification update.  Applies to only older
82		 * PIIX4 models.
83		 */
84		errata.piix4.throttle = 1;
85
86	case 2:		/* PIIX4E */
87	case 3:		/* PIIX4M */
88		/*
89		 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
90		 * Livelock") from the January 2002 PIIX4 specification update.
91		 * Applies to all PIIX4 models.
92		 */
93
94		/*
95		 * BM-IDE
96		 * ------
97		 * Find the PIIX4 IDE Controller and get the Bus Master IDE
98		 * Status register address.  We'll use this later to read
99		 * each IDE controller's DMA status to make sure we catch all
100		 * DMA activity.
101		 */
102		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
103				     PCI_DEVICE_ID_INTEL_82371AB,
104				     PCI_ANY_ID, PCI_ANY_ID, NULL);
105		if (dev) {
106			errata.piix4.bmisx = pci_resource_start(dev, 4);
107			pci_dev_put(dev);
108		}
109
110		/*
111		 * Type-F DMA
112		 * ----------
113		 * Find the PIIX4 ISA Controller and read the Motherboard
114		 * DMA controller's status to see if Type-F (Fast) DMA mode
115		 * is enabled (bit 7) on either channel.  Note that we'll
116		 * disable C3 support if this is enabled, as some legacy
117		 * devices won't operate well if fast DMA is disabled.
118		 */
119		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
120				     PCI_DEVICE_ID_INTEL_82371AB_0,
121				     PCI_ANY_ID, PCI_ANY_ID, NULL);
122		if (dev) {
123			pci_read_config_byte(dev, 0x76, &value1);
124			pci_read_config_byte(dev, 0x77, &value2);
125			if ((value1 & 0x80) || (value2 & 0x80))
126				errata.piix4.fdma = 1;
127			pci_dev_put(dev);
128		}
129
130		break;
131	}
132
133	if (errata.piix4.bmisx)
134		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
135				  "Bus master activity detection (BM-IDE) erratum enabled\n"));
136	if (errata.piix4.fdma)
137		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
138				  "Type-F DMA livelock erratum (C3 disabled)\n"));
139
140	return 0;
141}
142
143static int acpi_processor_errata(void)
144{
145	int result = 0;
146	struct pci_dev *dev = NULL;
147
148	/*
149	 * PIIX4
150	 */
151	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
152			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
153			     PCI_ANY_ID, NULL);
154	if (dev) {
155		result = acpi_processor_errata_piix4(dev);
156		pci_dev_put(dev);
157	}
158
159	return result;
160}
161
162/* --------------------------------------------------------------------------
163                                Initialization
164   -------------------------------------------------------------------------- */
165
166#ifdef CONFIG_ACPI_HOTPLUG_CPU
167int __weak acpi_map_cpu(acpi_handle handle,
168		phys_cpuid_t physid, int *pcpu)
169{
170	return -ENODEV;
171}
172
173int __weak acpi_unmap_cpu(int cpu)
174{
175	return -ENODEV;
176}
177
178int __weak arch_register_cpu(int cpu)
179{
180	return -ENODEV;
181}
182
183void __weak arch_unregister_cpu(int cpu) {}
184
185static int acpi_processor_hotadd_init(struct acpi_processor *pr)
186{
187	unsigned long long sta;
188	acpi_status status;
189	int ret;
190
191	if (invalid_phys_cpuid(pr->phys_id))
192		return -ENODEV;
193
194	status = acpi_evaluate_integer(pr->handle, "_STA", NULL, &sta);
195	if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT))
196		return -ENODEV;
197
198	cpu_maps_update_begin();
199	cpu_hotplug_begin();
200
201	ret = acpi_map_cpu(pr->handle, pr->phys_id, &pr->id);
202	if (ret)
203		goto out;
204
205	ret = arch_register_cpu(pr->id);
206	if (ret) {
207		acpi_unmap_cpu(pr->id);
208		goto out;
209	}
210
211	/*
212	 * CPU got hot-added, but cpu_data is not initialized yet.  Set a flag
213	 * to delay cpu_idle/throttling initialization and do it when the CPU
214	 * gets online for the first time.
215	 */
216	pr_info("CPU%d has been hot-added\n", pr->id);
217	pr->flags.need_hotplug_init = 1;
218
219out:
220	cpu_hotplug_done();
221	cpu_maps_update_done();
222	return ret;
223}
224#else
225static inline int acpi_processor_hotadd_init(struct acpi_processor *pr)
226{
227	return -ENODEV;
228}
229#endif /* CONFIG_ACPI_HOTPLUG_CPU */
230
231static int acpi_processor_get_info(struct acpi_device *device)
232{
233	union acpi_object object = { 0 };
234	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
235	struct acpi_processor *pr = acpi_driver_data(device);
236	int device_declaration = 0;
237	acpi_status status = AE_OK;
238	static int cpu0_initialized;
239	unsigned long long value;
240
241	acpi_processor_errata();
242
243	/*
244	 * Check to see if we have bus mastering arbitration control.  This
245	 * is required for proper C3 usage (to maintain cache coherency).
246	 */
247	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
248		pr->flags.bm_control = 1;
249		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
250				  "Bus mastering arbitration control present\n"));
251	} else
252		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
253				  "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(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
265		pr->acpi_id = object.processor.proc_id;
266	} else {
267		/*
268		 * Declared with "Device" statement; match _UID.
269		 * Note that we don't handle string _UIDs yet.
270		 */
271		status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
272						NULL, &value);
273		if (ACPI_FAILURE(status)) {
274			dev_err(&device->dev,
275				"Failed to evaluate processor _UID (0x%x)\n",
276				status);
277			return -ENODEV;
278		}
279		device_declaration = 1;
280		pr->acpi_id = value;
281	}
282
283	pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration,
284					pr->acpi_id);
285	if (invalid_phys_cpuid(pr->phys_id))
286		acpi_handle_debug(pr->handle, "failed to get CPU physical ID.\n");
287
288	pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id);
289	if (!cpu0_initialized && !acpi_has_cpu_in_madt()) {
290		cpu0_initialized = 1;
291		/*
292		 * Handle UP system running SMP kernel, with no CPU
293		 * entry in MADT
294		 */
295		if (invalid_logical_cpuid(pr->id) && (num_online_cpus() == 1))
296			pr->id = 0;
297	}
298
299	/*
300	 *  Extra Processor objects may be enumerated on MP systems with
301	 *  less than the max # of CPUs. They should be ignored _iff
302	 *  they are physically not present.
303	 */
304	if (invalid_logical_cpuid(pr->id)) {
305		int ret = acpi_processor_hotadd_init(pr);
306		if (ret)
307			return ret;
308	}
309
310	/*
311	 * On some boxes several processors use the same processor bus id.
312	 * But they are located in different scope. For example:
313	 * \_SB.SCK0.CPU0
314	 * \_SB.SCK1.CPU0
315	 * Rename the processor device bus id. And the new bus id will be
316	 * generated as the following format:
317	 * CPU+CPU ID.
318	 */
319	sprintf(acpi_device_bid(device), "CPU%X", pr->id);
320	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
321			  pr->acpi_id));
322
323	if (!object.processor.pblk_address)
324		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
325	else if (object.processor.pblk_length != 6)
326		dev_err(&device->dev, "Invalid PBLK length [%d]\n",
327			    object.processor.pblk_length);
328	else {
329		pr->throttling.address = object.processor.pblk_address;
330		pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
331		pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
332
333		pr->pblk = object.processor.pblk_address;
334
335		/*
336		 * We don't care about error returns - we just try to mark
337		 * these reserved so that nobody else is confused into thinking
338		 * that this region might be unused..
339		 *
340		 * (In particular, allocating the IO range for Cardbus)
341		 */
342		request_region(pr->throttling.address, 6, "ACPI CPU throttle");
343	}
344
345	/*
346	 * If ACPI describes a slot number for this CPU, we can use it to
347	 * ensure we get the right value in the "physical id" field
348	 * of /proc/cpuinfo
349	 */
350	status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value);
351	if (ACPI_SUCCESS(status))
352		arch_fix_phys_package_id(pr->id, value);
353
354	return 0;
355}
356
357/*
358 * Do not put anything in here which needs the core to be online.
359 * For example MSR access or setting up things which check for cpuinfo_x86
360 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
361 * Such things have to be put in and set up by the processor driver's .probe().
362 */
363static DEFINE_PER_CPU(void *, processor_device_array);
364
365static int acpi_processor_add(struct acpi_device *device,
366					const struct acpi_device_id *id)
367{
368	struct acpi_processor *pr;
369	struct device *dev;
370	int result = 0;
371
372	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
373	if (!pr)
374		return -ENOMEM;
375
376	if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
377		result = -ENOMEM;
378		goto err_free_pr;
379	}
380
381	pr->handle = device->handle;
382	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
383	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
384	device->driver_data = pr;
385
386	result = acpi_processor_get_info(device);
387	if (result) /* Processor is not physically present or unavailable */
388		return 0;
389
390#ifdef CONFIG_SMP
391	if (pr->id >= setup_max_cpus && pr->id != 0)
392		return 0;
393#endif
394
395	BUG_ON(pr->id >= nr_cpu_ids);
396
397	/*
398	 * Buggy BIOS check.
399	 * ACPI id of processors can be reported wrongly by the BIOS.
400	 * Don't trust it blindly
401	 */
402	if (per_cpu(processor_device_array, pr->id) != NULL &&
403	    per_cpu(processor_device_array, pr->id) != device) {
404		dev_warn(&device->dev,
405			"BIOS reported wrong ACPI id %d for the processor\n",
406			pr->id);
407		/* Give up, but do not abort the namespace scan. */
408		goto err;
409	}
410	/*
411	 * processor_device_array is not cleared on errors to allow buggy BIOS
412	 * checks.
413	 */
414	per_cpu(processor_device_array, pr->id) = device;
415	per_cpu(processors, pr->id) = pr;
416
417	dev = get_cpu_device(pr->id);
418	if (!dev) {
419		result = -ENODEV;
420		goto err;
421	}
422
423	result = acpi_bind_one(dev, device);
424	if (result)
425		goto err;
426
427	pr->dev = dev;
428
429	/* Trigger the processor driver's .probe() if present. */
430	if (device_attach(dev) >= 0)
431		return 1;
432
433	dev_err(dev, "Processor driver could not be attached\n");
434	acpi_unbind_one(dev);
435
436 err:
437	free_cpumask_var(pr->throttling.shared_cpu_map);
438	device->driver_data = NULL;
439	per_cpu(processors, pr->id) = NULL;
440 err_free_pr:
441	kfree(pr);
442	return result;
443}
444
445#ifdef CONFIG_ACPI_HOTPLUG_CPU
446/* --------------------------------------------------------------------------
447                                    Removal
448   -------------------------------------------------------------------------- */
449
450static void acpi_processor_remove(struct acpi_device *device)
451{
452	struct acpi_processor *pr;
453
454	if (!device || !acpi_driver_data(device))
455		return;
456
457	pr = acpi_driver_data(device);
458	if (pr->id >= nr_cpu_ids)
459		goto out;
460
461	/*
462	 * The only reason why we ever get here is CPU hot-removal.  The CPU is
463	 * already offline and the ACPI device removal locking prevents it from
464	 * being put back online at this point.
465	 *
466	 * Unbind the driver from the processor device and detach it from the
467	 * ACPI companion object.
468	 */
469	device_release_driver(pr->dev);
470	acpi_unbind_one(pr->dev);
471
472	/* Clean up. */
473	per_cpu(processor_device_array, pr->id) = NULL;
474	per_cpu(processors, pr->id) = NULL;
475
476	cpu_maps_update_begin();
477	cpu_hotplug_begin();
478
479	/* Remove the CPU. */
480	arch_unregister_cpu(pr->id);
481	acpi_unmap_cpu(pr->id);
482
483	cpu_hotplug_done();
484	cpu_maps_update_done();
485
486	try_offline_node(cpu_to_node(pr->id));
487
488 out:
489	free_cpumask_var(pr->throttling.shared_cpu_map);
490	kfree(pr);
491}
492#endif /* CONFIG_ACPI_HOTPLUG_CPU */
493
494#ifdef CONFIG_X86
495static bool acpi_hwp_native_thermal_lvt_set;
496static acpi_status __init acpi_hwp_native_thermal_lvt_osc(acpi_handle handle,
497							  u32 lvl,
498							  void *context,
499							  void **rv)
500{
501	u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953";
502	u32 capbuf[2];
503	struct acpi_osc_context osc_context = {
504		.uuid_str = sb_uuid_str,
505		.rev = 1,
506		.cap.length = 8,
507		.cap.pointer = capbuf,
508	};
509
510	if (acpi_hwp_native_thermal_lvt_set)
511		return AE_CTRL_TERMINATE;
512
513	capbuf[0] = 0x0000;
514	capbuf[1] = 0x1000; /* set bit 12 */
515
516	if (ACPI_SUCCESS(acpi_run_osc(handle, &osc_context))) {
517		if (osc_context.ret.pointer && osc_context.ret.length > 1) {
518			u32 *capbuf_ret = osc_context.ret.pointer;
519
520			if (capbuf_ret[1] & 0x1000) {
521				acpi_handle_info(handle,
522					"_OSC native thermal LVT Acked\n");
523				acpi_hwp_native_thermal_lvt_set = true;
524			}
525		}
526		kfree(osc_context.ret.pointer);
527	}
528
529	return AE_OK;
530}
531
532void __init acpi_early_processor_osc(void)
533{
534	if (boot_cpu_has(X86_FEATURE_HWP)) {
535		acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
536				    ACPI_UINT32_MAX,
537				    acpi_hwp_native_thermal_lvt_osc,
538				    NULL, NULL, NULL);
539		acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID,
540				 acpi_hwp_native_thermal_lvt_osc,
541				 NULL, NULL);
542	}
543}
544#endif
545
546/*
547 * The following ACPI IDs are known to be suitable for representing as
548 * processor devices.
549 */
550static const struct acpi_device_id processor_device_ids[] = {
551
552	{ ACPI_PROCESSOR_OBJECT_HID, },
553	{ ACPI_PROCESSOR_DEVICE_HID, },
554
555	{ }
556};
557
558static struct acpi_scan_handler processor_handler = {
559	.ids = processor_device_ids,
560	.attach = acpi_processor_add,
561#ifdef CONFIG_ACPI_HOTPLUG_CPU
562	.detach = acpi_processor_remove,
563#endif
564	.hotplug = {
565		.enabled = true,
566	},
567};
568
569void __init acpi_processor_init(void)
570{
571	acpi_scan_add_handler_with_hotplug(&processor_handler, "processor");
572}
573