Linux Audio

Check our new training course

Loading...
v4.6
  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
569static int acpi_processor_container_attach(struct acpi_device *dev,
570					   const struct acpi_device_id *id)
571{
572	return 1;
573}
574
575static const struct acpi_device_id processor_container_ids[] = {
576	{ ACPI_PROCESSOR_CONTAINER_HID, },
577	{ }
578};
579
580static struct acpi_scan_handler processor_container_handler = {
581	.ids = processor_container_ids,
582	.attach = acpi_processor_container_attach,
583};
584
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
585void __init acpi_processor_init(void)
586{
 
587	acpi_scan_add_handler_with_hotplug(&processor_handler, "processor");
588	acpi_scan_add_handler(&processor_container_handler);
589}
v4.17
  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		/* fall through*/
 86
 87	case 2:		/* PIIX4E */
 88	case 3:		/* PIIX4M */
 89		/*
 90		 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
 91		 * Livelock") from the January 2002 PIIX4 specification update.
 92		 * Applies to all PIIX4 models.
 93		 */
 94
 95		/*
 96		 * BM-IDE
 97		 * ------
 98		 * Find the PIIX4 IDE Controller and get the Bus Master IDE
 99		 * Status register address.  We'll use this later to read
100		 * each IDE controller's DMA status to make sure we catch all
101		 * DMA activity.
102		 */
103		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
104				     PCI_DEVICE_ID_INTEL_82371AB,
105				     PCI_ANY_ID, PCI_ANY_ID, NULL);
106		if (dev) {
107			errata.piix4.bmisx = pci_resource_start(dev, 4);
108			pci_dev_put(dev);
109		}
110
111		/*
112		 * Type-F DMA
113		 * ----------
114		 * Find the PIIX4 ISA Controller and read the Motherboard
115		 * DMA controller's status to see if Type-F (Fast) DMA mode
116		 * is enabled (bit 7) on either channel.  Note that we'll
117		 * disable C3 support if this is enabled, as some legacy
118		 * devices won't operate well if fast DMA is disabled.
119		 */
120		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
121				     PCI_DEVICE_ID_INTEL_82371AB_0,
122				     PCI_ANY_ID, PCI_ANY_ID, NULL);
123		if (dev) {
124			pci_read_config_byte(dev, 0x76, &value1);
125			pci_read_config_byte(dev, 0x77, &value2);
126			if ((value1 & 0x80) || (value2 & 0x80))
127				errata.piix4.fdma = 1;
128			pci_dev_put(dev);
129		}
130
131		break;
132	}
133
134	if (errata.piix4.bmisx)
135		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
136				  "Bus master activity detection (BM-IDE) erratum enabled\n"));
137	if (errata.piix4.fdma)
138		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
139				  "Type-F DMA livelock erratum (C3 disabled)\n"));
140
141	return 0;
142}
143
144static int acpi_processor_errata(void)
145{
146	int result = 0;
147	struct pci_dev *dev = NULL;
148
149	/*
150	 * PIIX4
151	 */
152	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
153			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
154			     PCI_ANY_ID, NULL);
155	if (dev) {
156		result = acpi_processor_errata_piix4(dev);
157		pci_dev_put(dev);
158	}
159
160	return result;
161}
162
163/* --------------------------------------------------------------------------
164                                Initialization
165   -------------------------------------------------------------------------- */
166
167#ifdef CONFIG_ACPI_HOTPLUG_CPU
168int __weak acpi_map_cpu(acpi_handle handle,
169		phys_cpuid_t physid, u32 acpi_id, int *pcpu)
170{
171	return -ENODEV;
172}
173
174int __weak acpi_unmap_cpu(int cpu)
175{
176	return -ENODEV;
177}
178
179int __weak arch_register_cpu(int cpu)
180{
181	return -ENODEV;
182}
183
184void __weak arch_unregister_cpu(int cpu) {}
185
186static int acpi_processor_hotadd_init(struct acpi_processor *pr)
187{
188	unsigned long long sta;
189	acpi_status status;
190	int ret;
191
192	if (invalid_phys_cpuid(pr->phys_id))
193		return -ENODEV;
194
195	status = acpi_evaluate_integer(pr->handle, "_STA", NULL, &sta);
196	if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT))
197		return -ENODEV;
198
199	cpu_maps_update_begin();
200	cpu_hotplug_begin();
201
202	ret = acpi_map_cpu(pr->handle, pr->phys_id, pr->acpi_id, &pr->id);
203	if (ret)
204		goto out;
205
206	ret = arch_register_cpu(pr->id);
207	if (ret) {
208		acpi_unmap_cpu(pr->id);
209		goto out;
210	}
211
212	/*
213	 * CPU got hot-added, but cpu_data is not initialized yet.  Set a flag
214	 * to delay cpu_idle/throttling initialization and do it when the CPU
215	 * gets online for the first time.
216	 */
217	pr_info("CPU%d has been hot-added\n", pr->id);
218	pr->flags.need_hotplug_init = 1;
219
220out:
221	cpu_hotplug_done();
222	cpu_maps_update_done();
223	return ret;
224}
225#else
226static inline int acpi_processor_hotadd_init(struct acpi_processor *pr)
227{
228	return -ENODEV;
229}
230#endif /* CONFIG_ACPI_HOTPLUG_CPU */
231
232static int acpi_processor_get_info(struct acpi_device *device)
233{
234	union acpi_object object = { 0 };
235	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
236	struct acpi_processor *pr = acpi_driver_data(device);
237	int device_declaration = 0;
238	acpi_status status = AE_OK;
239	static int cpu0_initialized;
240	unsigned long long value;
241
242	acpi_processor_errata();
243
244	/*
245	 * Check to see if we have bus mastering arbitration control.  This
246	 * is required for proper C3 usage (to maintain cache coherency).
247	 */
248	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
249		pr->flags.bm_control = 1;
250		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
251				  "Bus mastering arbitration control present\n"));
252	} else
253		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
254				  "No bus mastering arbitration control\n"));
255
256	if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
257		/* Declared with "Processor" statement; match ProcessorID */
258		status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
259		if (ACPI_FAILURE(status)) {
260			dev_err(&device->dev,
261				"Failed to evaluate processor object (0x%x)\n",
262				status);
263			return -ENODEV;
264		}
265
266		pr->acpi_id = object.processor.proc_id;
267	} else {
268		/*
269		 * Declared with "Device" statement; match _UID.
270		 * Note that we don't handle string _UIDs yet.
271		 */
272		status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
273						NULL, &value);
274		if (ACPI_FAILURE(status)) {
275			dev_err(&device->dev,
276				"Failed to evaluate processor _UID (0x%x)\n",
277				status);
278			return -ENODEV;
279		}
280		device_declaration = 1;
281		pr->acpi_id = value;
282	}
283
284	if (acpi_duplicate_processor_id(pr->acpi_id)) {
285		dev_err(&device->dev,
286			"Failed to get unique processor _UID (0x%x)\n",
287			pr->acpi_id);
288		return -ENODEV;
289	}
290
291	pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration,
292					pr->acpi_id);
293	if (invalid_phys_cpuid(pr->phys_id))
294		acpi_handle_debug(pr->handle, "failed to get CPU physical ID.\n");
295
296	pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id);
297	if (!cpu0_initialized && !acpi_has_cpu_in_madt()) {
298		cpu0_initialized = 1;
299		/*
300		 * Handle UP system running SMP kernel, with no CPU
301		 * entry in MADT
302		 */
303		if (invalid_logical_cpuid(pr->id) && (num_online_cpus() == 1))
304			pr->id = 0;
305	}
306
307	/*
308	 *  Extra Processor objects may be enumerated on MP systems with
309	 *  less than the max # of CPUs. They should be ignored _iff
310	 *  they are physically not present.
311	 *
312	 *  NOTE: Even if the processor has a cpuid, it may not be present
313	 *  because cpuid <-> apicid mapping is persistent now.
314	 */
315	if (invalid_logical_cpuid(pr->id) || !cpu_present(pr->id)) {
316		int ret = acpi_processor_hotadd_init(pr);
317		if (ret)
318			return ret;
319	}
320
321	/*
322	 * On some boxes several processors use the same processor bus id.
323	 * But they are located in different scope. For example:
324	 * \_SB.SCK0.CPU0
325	 * \_SB.SCK1.CPU0
326	 * Rename the processor device bus id. And the new bus id will be
327	 * generated as the following format:
328	 * CPU+CPU ID.
329	 */
330	sprintf(acpi_device_bid(device), "CPU%X", pr->id);
331	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
332			  pr->acpi_id));
333
334	if (!object.processor.pblk_address)
335		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
336	else if (object.processor.pblk_length != 6)
337		dev_err(&device->dev, "Invalid PBLK length [%d]\n",
338			    object.processor.pblk_length);
339	else {
340		pr->throttling.address = object.processor.pblk_address;
341		pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
342		pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
343
344		pr->pblk = object.processor.pblk_address;
 
 
 
 
 
 
 
 
 
345	}
346
347	/*
348	 * If ACPI describes a slot number for this CPU, we can use it to
349	 * ensure we get the right value in the "physical id" field
350	 * of /proc/cpuinfo
351	 */
352	status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value);
353	if (ACPI_SUCCESS(status))
354		arch_fix_phys_package_id(pr->id, value);
355
356	return 0;
357}
358
359/*
360 * Do not put anything in here which needs the core to be online.
361 * For example MSR access or setting up things which check for cpuinfo_x86
362 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
363 * Such things have to be put in and set up by the processor driver's .probe().
364 */
365static DEFINE_PER_CPU(void *, processor_device_array);
366
367static int acpi_processor_add(struct acpi_device *device,
368					const struct acpi_device_id *id)
369{
370	struct acpi_processor *pr;
371	struct device *dev;
372	int result = 0;
373
374	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
375	if (!pr)
376		return -ENOMEM;
377
378	if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
379		result = -ENOMEM;
380		goto err_free_pr;
381	}
382
383	pr->handle = device->handle;
384	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
385	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
386	device->driver_data = pr;
387
388	result = acpi_processor_get_info(device);
389	if (result) /* Processor is not physically present or unavailable */
390		return 0;
391
 
 
 
 
 
392	BUG_ON(pr->id >= nr_cpu_ids);
393
394	/*
395	 * Buggy BIOS check.
396	 * ACPI id of processors can be reported wrongly by the BIOS.
397	 * Don't trust it blindly
398	 */
399	if (per_cpu(processor_device_array, pr->id) != NULL &&
400	    per_cpu(processor_device_array, pr->id) != device) {
401		dev_warn(&device->dev,
402			"BIOS reported wrong ACPI id %d for the processor\n",
403			pr->id);
404		/* Give up, but do not abort the namespace scan. */
405		goto err;
406	}
407	/*
408	 * processor_device_array is not cleared on errors to allow buggy BIOS
409	 * checks.
410	 */
411	per_cpu(processor_device_array, pr->id) = device;
412	per_cpu(processors, pr->id) = pr;
413
414	dev = get_cpu_device(pr->id);
415	if (!dev) {
416		result = -ENODEV;
417		goto err;
418	}
419
420	result = acpi_bind_one(dev, device);
421	if (result)
422		goto err;
423
424	pr->dev = dev;
425
426	/* Trigger the processor driver's .probe() if present. */
427	if (device_attach(dev) >= 0)
428		return 1;
429
430	dev_err(dev, "Processor driver could not be attached\n");
431	acpi_unbind_one(dev);
432
433 err:
434	free_cpumask_var(pr->throttling.shared_cpu_map);
435	device->driver_data = NULL;
436	per_cpu(processors, pr->id) = NULL;
437 err_free_pr:
438	kfree(pr);
439	return result;
440}
441
442#ifdef CONFIG_ACPI_HOTPLUG_CPU
443/* --------------------------------------------------------------------------
444                                    Removal
445   -------------------------------------------------------------------------- */
446
447static void acpi_processor_remove(struct acpi_device *device)
448{
449	struct acpi_processor *pr;
450
451	if (!device || !acpi_driver_data(device))
452		return;
453
454	pr = acpi_driver_data(device);
455	if (pr->id >= nr_cpu_ids)
456		goto out;
457
458	/*
459	 * The only reason why we ever get here is CPU hot-removal.  The CPU is
460	 * already offline and the ACPI device removal locking prevents it from
461	 * being put back online at this point.
462	 *
463	 * Unbind the driver from the processor device and detach it from the
464	 * ACPI companion object.
465	 */
466	device_release_driver(pr->dev);
467	acpi_unbind_one(pr->dev);
468
469	/* Clean up. */
470	per_cpu(processor_device_array, pr->id) = NULL;
471	per_cpu(processors, pr->id) = NULL;
472
473	cpu_maps_update_begin();
474	cpu_hotplug_begin();
475
476	/* Remove the CPU. */
477	arch_unregister_cpu(pr->id);
478	acpi_unmap_cpu(pr->id);
479
480	cpu_hotplug_done();
481	cpu_maps_update_done();
482
483	try_offline_node(cpu_to_node(pr->id));
484
485 out:
486	free_cpumask_var(pr->throttling.shared_cpu_map);
487	kfree(pr);
488}
489#endif /* CONFIG_ACPI_HOTPLUG_CPU */
490
491#ifdef CONFIG_X86
492static bool acpi_hwp_native_thermal_lvt_set;
493static acpi_status __init acpi_hwp_native_thermal_lvt_osc(acpi_handle handle,
494							  u32 lvl,
495							  void *context,
496							  void **rv)
497{
498	u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953";
499	u32 capbuf[2];
500	struct acpi_osc_context osc_context = {
501		.uuid_str = sb_uuid_str,
502		.rev = 1,
503		.cap.length = 8,
504		.cap.pointer = capbuf,
505	};
506
507	if (acpi_hwp_native_thermal_lvt_set)
508		return AE_CTRL_TERMINATE;
509
510	capbuf[0] = 0x0000;
511	capbuf[1] = 0x1000; /* set bit 12 */
512
513	if (ACPI_SUCCESS(acpi_run_osc(handle, &osc_context))) {
514		if (osc_context.ret.pointer && osc_context.ret.length > 1) {
515			u32 *capbuf_ret = osc_context.ret.pointer;
516
517			if (capbuf_ret[1] & 0x1000) {
518				acpi_handle_info(handle,
519					"_OSC native thermal LVT Acked\n");
520				acpi_hwp_native_thermal_lvt_set = true;
521			}
522		}
523		kfree(osc_context.ret.pointer);
524	}
525
526	return AE_OK;
527}
528
529void __init acpi_early_processor_osc(void)
530{
531	if (boot_cpu_has(X86_FEATURE_HWP)) {
532		acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
533				    ACPI_UINT32_MAX,
534				    acpi_hwp_native_thermal_lvt_osc,
535				    NULL, NULL, NULL);
536		acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID,
537				 acpi_hwp_native_thermal_lvt_osc,
538				 NULL, NULL);
539	}
540}
541#endif
542
543/*
544 * The following ACPI IDs are known to be suitable for representing as
545 * processor devices.
546 */
547static const struct acpi_device_id processor_device_ids[] = {
548
549	{ ACPI_PROCESSOR_OBJECT_HID, },
550	{ ACPI_PROCESSOR_DEVICE_HID, },
551
552	{ }
553};
554
555static struct acpi_scan_handler processor_handler = {
556	.ids = processor_device_ids,
557	.attach = acpi_processor_add,
558#ifdef CONFIG_ACPI_HOTPLUG_CPU
559	.detach = acpi_processor_remove,
560#endif
561	.hotplug = {
562		.enabled = true,
563	},
564};
565
566static int acpi_processor_container_attach(struct acpi_device *dev,
567					   const struct acpi_device_id *id)
568{
569	return 1;
570}
571
572static const struct acpi_device_id processor_container_ids[] = {
573	{ ACPI_PROCESSOR_CONTAINER_HID, },
574	{ }
575};
576
577static struct acpi_scan_handler processor_container_handler = {
578	.ids = processor_container_ids,
579	.attach = acpi_processor_container_attach,
580};
581
582/* The number of the unique processor IDs */
583static int nr_unique_ids __initdata;
584
585/* The number of the duplicate processor IDs */
586static int nr_duplicate_ids;
587
588/* Used to store the unique processor IDs */
589static int unique_processor_ids[] __initdata = {
590	[0 ... NR_CPUS - 1] = -1,
591};
592
593/* Used to store the duplicate processor IDs */
594static int duplicate_processor_ids[] = {
595	[0 ... NR_CPUS - 1] = -1,
596};
597
598static void __init processor_validated_ids_update(int proc_id)
599{
600	int i;
601
602	if (nr_unique_ids == NR_CPUS||nr_duplicate_ids == NR_CPUS)
603		return;
604
605	/*
606	 * Firstly, compare the proc_id with duplicate IDs, if the proc_id is
607	 * already in the IDs, do nothing.
608	 */
609	for (i = 0; i < nr_duplicate_ids; i++) {
610		if (duplicate_processor_ids[i] == proc_id)
611			return;
612	}
613
614	/*
615	 * Secondly, compare the proc_id with unique IDs, if the proc_id is in
616	 * the IDs, put it in the duplicate IDs.
617	 */
618	for (i = 0; i < nr_unique_ids; i++) {
619		if (unique_processor_ids[i] == proc_id) {
620			duplicate_processor_ids[nr_duplicate_ids] = proc_id;
621			nr_duplicate_ids++;
622			return;
623		}
624	}
625
626	/*
627	 * Lastly, the proc_id is a unique ID, put it in the unique IDs.
628	 */
629	unique_processor_ids[nr_unique_ids] = proc_id;
630	nr_unique_ids++;
631}
632
633static acpi_status __init acpi_processor_ids_walk(acpi_handle handle,
634						  u32 lvl,
635						  void *context,
636						  void **rv)
637{
638	acpi_status status;
639	acpi_object_type acpi_type;
640	unsigned long long uid;
641	union acpi_object object = { 0 };
642	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
643
644	status = acpi_get_type(handle, &acpi_type);
645	if (ACPI_FAILURE(status))
646		return false;
647
648	switch (acpi_type) {
649	case ACPI_TYPE_PROCESSOR:
650		status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
651		if (ACPI_FAILURE(status))
652			goto err;
653		uid = object.processor.proc_id;
654		break;
655
656	case ACPI_TYPE_DEVICE:
657		status = acpi_evaluate_integer(handle, "_UID", NULL, &uid);
658		if (ACPI_FAILURE(status))
659			goto err;
660		break;
661	default:
662		goto err;
663	}
664
665	processor_validated_ids_update(uid);
666	return true;
667
668err:
669	acpi_handle_info(handle, "Invalid processor object\n");
670	return false;
671
672}
673
674static void __init acpi_processor_check_duplicates(void)
675{
676	/* check the correctness for all processors in ACPI namespace */
677	acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
678						ACPI_UINT32_MAX,
679						acpi_processor_ids_walk,
680						NULL, NULL, NULL);
681	acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_ids_walk,
682						NULL, NULL);
683}
684
685bool acpi_duplicate_processor_id(int proc_id)
686{
687	int i;
688
689	/*
690	 * compare the proc_id with duplicate IDs, if the proc_id is already
691	 * in the duplicate IDs, return true, otherwise, return false.
692	 */
693	for (i = 0; i < nr_duplicate_ids; i++) {
694		if (duplicate_processor_ids[i] == proc_id)
695			return true;
696	}
697	return false;
698}
699
700void __init acpi_processor_init(void)
701{
702	acpi_processor_check_duplicates();
703	acpi_scan_add_handler_with_hotplug(&processor_handler, "processor");
704	acpi_scan_add_handler(&processor_container_handler);
705}