/* * acpi_processor.c - ACPI Processor Driver ($Revision: 71 $) * *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de> *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> *  			- Added processor hotplug support * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * *  This program is free software; you can redistribute it and/or modify *  it under the terms of the GNU General Public License as published by *  the Free Software Foundation; either version 2 of the License, or (at *  your option) any later version. * *  This program is distributed in the hope that it will be useful, but *  WITHOUT ANY WARRANTY; without even the implied warranty of *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *  General Public License for more details. * *  You should have received a copy of the GNU General Public License along *  with this program; if not, write to the Free Software Foundation, Inc., *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *  TBD: *	1. Make # power states dynamic. *	2. Support duty_cycle values that span bit 4. *	3. Optimize by having scheduler determine business instead of *	   having us try to calculate it here. *	4. Need C1 timing -- must modify kernel (IRQ handler) to get this. */ #include <linux/kernel.h>#include <linux/module.h>#include <linux/init.h>#include <linux/types.h>#include <linux/pci.h>#include <linux/pm.h>#include <linux/cpufreq.h>#include <linux/cpu.h>#include <linux/proc_fs.h>#include <linux/seq_file.h>#include <linux/dmi.h>#include <linux/moduleparam.h>#include <linux/cpuidle.h> #include <asm/io.h>#include <asm/system.h>#include <asm/cpu.h>#include <asm/delay.h>#include <asm/uaccess.h>#include <asm/processor.h>#include <asm/smp.h>#include <asm/acpi.h> #include <acpi/acpi_bus.h>#include <acpi/acpi_drivers.h>#include <acpi/processor.h> #define PREFIX "ACPI: " #define ACPI_PROCESSOR_CLASS		"processor"#define ACPI_PROCESSOR_DEVICE_NAME	"Processor"#define ACPI_PROCESSOR_FILE_INFO	"info"#define ACPI_PROCESSOR_FILE_THROTTLING	"throttling"#define ACPI_PROCESSOR_FILE_LIMIT	"limit"#define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80#define ACPI_PROCESSOR_NOTIFY_POWER	0x81#define ACPI_PROCESSOR_NOTIFY_THROTTLING	0x82 #define ACPI_PROCESSOR_LIMIT_USER	0#define ACPI_PROCESSOR_LIMIT_THERMAL	1 #define _COMPONENT		ACPI_PROCESSOR_COMPONENTACPI_MODULE_NAME("processor_core"); MODULE_AUTHOR("Paul Diefenbaugh");MODULE_DESCRIPTION("ACPI Processor Driver");MODULE_LICENSE("GPL"); static int acpi_processor_add(struct acpi_device *device);static int acpi_processor_remove(struct acpi_device *device, int type);#ifdef CONFIG_ACPI_PROCFSstatic int acpi_processor_info_open_fs(struct inode *inode, struct file *file);#endifstatic void acpi_processor_notify(struct acpi_device *device, u32 event);static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);static int acpi_processor_handle_eject(struct acpi_processor *pr);  static const struct acpi_device_id processor_device_ids[] = {	{ACPI_PROCESSOR_OBJECT_HID, 0},	{"ACPI0007", 0},	{"", 0},};MODULE_DEVICE_TABLE(acpi, processor_device_ids); static struct acpi_driver acpi_processor_driver = {	.name = "processor",	.class = ACPI_PROCESSOR_CLASS,	.ids = processor_device_ids,	.ops = {		.add = acpi_processor_add,		.remove = acpi_processor_remove,		.suspend = acpi_processor_suspend,		.resume = acpi_processor_resume,		.notify = acpi_processor_notify,		},}; #define INSTALL_NOTIFY_HANDLER		1#define UNINSTALL_NOTIFY_HANDLER	2#ifdef CONFIG_ACPI_PROCFSstatic const struct file_operations acpi_processor_info_fops = {	.owner = THIS_MODULE,	.open = acpi_processor_info_open_fs,	.read = seq_read,	.llseek = seq_lseek,	.release = single_release,};#endif DEFINE_PER_CPU(struct acpi_processor *, processors);struct acpi_processor_errata errata __read_mostly;static int set_no_mwait(const struct dmi_system_id *id){	printk(KERN_NOTICE PREFIX "%s detected - "		"disabling mwait for CPU C-states\n", id->ident);	idle_nomwait = 1;	return 0;} static struct dmi_system_id __cpuinitdata processor_idle_dmi_table[] = {	{	set_no_mwait, "IFL91 board", {	DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),	DMI_MATCH(DMI_SYS_VENDOR, "ZEPTO"),	DMI_MATCH(DMI_PRODUCT_VERSION, "3215W"),	DMI_MATCH(DMI_BOARD_NAME, "IFL91") }, NULL},	{	set_no_mwait, "Extensa 5220", {	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),	DMI_MATCH(DMI_PRODUCT_VERSION, "0100"),	DMI_MATCH(DMI_BOARD_NAME, "Columbia") }, NULL},	{},}; /* --------------------------------------------------------------------------                                Errata Handling   -------------------------------------------------------------------------- */ static int acpi_processor_errata_piix4(struct pci_dev *dev){	u8 value1 = 0;	u8 value2 = 0;  	if (!dev)		return -EINVAL; 	/*	 * Note that 'dev' references the PIIX4 ACPI Controller.	 */ 	switch (dev->revision) {	case 0:		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));		break;	case 1:		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));		break;	case 2:		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));		break;	case 3:		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));		break;	default:		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));		break;	} 	switch (dev->revision) { 	case 0:		/* PIIX4 A-step */	case 1:		/* PIIX4 B-step */		/*		 * See specification changes #13 ("Manual Throttle Duty Cycle")		 * and #14 ("Enabling and Disabling Manual Throttle"), plus		 * erratum #5 ("STPCLK# Deassertion Time") from the January		 * 2002 PIIX4 specification update.  Applies to only older		 * PIIX4 models.		 */		errata.piix4.throttle = 1; 	case 2:		/* PIIX4E */	case 3:		/* PIIX4M */		/*		 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA		 * Livelock") from the January 2002 PIIX4 specification update.		 * Applies to all PIIX4 models.		 */ 		/*		 * BM-IDE		 * ------		 * Find the PIIX4 IDE Controller and get the Bus Master IDE		 * Status register address.  We'll use this later to read		 * each IDE controller's DMA status to make sure we catch all		 * DMA activity.		 */		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,				     PCI_DEVICE_ID_INTEL_82371AB,				     PCI_ANY_ID, PCI_ANY_ID, NULL);		if (dev) {			errata.piix4.bmisx = pci_resource_start(dev, 4);			pci_dev_put(dev);		} 		/*		 * Type-F DMA		 * ----------		 * Find the PIIX4 ISA Controller and read the Motherboard		 * DMA controller's status to see if Type-F (Fast) DMA mode		 * is enabled (bit 7) on either channel.  Note that we'll		 * disable C3 support if this is enabled, as some legacy		 * devices won't operate well if fast DMA is disabled.		 */		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,				     PCI_DEVICE_ID_INTEL_82371AB_0,				     PCI_ANY_ID, PCI_ANY_ID, NULL);		if (dev) {			pci_read_config_byte(dev, 0x76, &value1);			pci_read_config_byte(dev, 0x77, &value2);			if ((value1 & 0x80) || (value2 & 0x80))				errata.piix4.fdma = 1;			pci_dev_put(dev);		} 		break;	} 	if (errata.piix4.bmisx)		ACPI_DEBUG_PRINT((ACPI_DB_INFO,				  "Bus master activity detection (BM-IDE) erratum enabled\n"));	if (errata.piix4.fdma)		ACPI_DEBUG_PRINT((ACPI_DB_INFO,				  "Type-F DMA livelock erratum (C3 disabled)\n")); 	return 0;} static int acpi_processor_errata(struct acpi_processor *pr){	int result = 0;	struct pci_dev *dev = NULL;  	if (!pr)		return -EINVAL; 	/*	 * PIIX4	 */	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,			     PCI_ANY_ID, NULL);	if (dev) {		result = acpi_processor_errata_piix4(dev);		pci_dev_put(dev);	} 	return result;} /* --------------------------------------------------------------------------                              Common ACPI processor functions   -------------------------------------------------------------------------- */ /* * _PDC is required for a BIOS-OS handshake for most of the newer * ACPI processor features. */static int acpi_processor_set_pdc(struct acpi_processor *pr){	struct acpi_object_list *pdc_in = pr->pdc;	acpi_status status = AE_OK;  	if (!pdc_in)		return status;	if (idle_nomwait) {		/*		 * If mwait is disabled for CPU C-states, the C2C3_FFH access		 * mode will be disabled in the parameter of _PDC object.		 * Of course C1_FFH access mode will also be disabled.		 */		union acpi_object *obj;		u32 *buffer = NULL; 		obj = pdc_in->pointer;		buffer = (u32 *)(obj->buffer.pointer);		buffer[2] &= ~(ACPI_PDC_C_C2C3_FFH | ACPI_PDC_C_C1_FFH); 	}	status = acpi_evaluate_object(pr->handle, "_PDC", pdc_in, NULL); 	if (ACPI_FAILURE(status))		ACPI_DEBUG_PRINT((ACPI_DB_INFO,		    "Could not evaluate _PDC, using legacy perf. control...\n")); 	return status;} /* --------------------------------------------------------------------------                              FS Interface (/proc)   -------------------------------------------------------------------------- */ #ifdef CONFIG_ACPI_PROCFSstatic struct proc_dir_entry *acpi_processor_dir = NULL; static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset){	struct acpi_processor *pr = seq->private;  	if (!pr)		goto end; 	seq_printf(seq, "processor id:            %d\n"		   "acpi id:                 %d\n"		   "bus mastering control:   %s\n"		   "power management:        %s\n"		   "throttling control:      %s\n"		   "limit interface:         %s\n",		   pr->id,		   pr->acpi_id,		   pr->flags.bm_control ? "yes" : "no",		   pr->flags.power ? "yes" : "no",		   pr->flags.throttling ? "yes" : "no",		   pr->flags.limit ? "yes" : "no");       end:	return 0;} static int acpi_processor_info_open_fs(struct inode *inode, struct file *file){	return single_open(file, acpi_processor_info_seq_show,			   PDE(inode)->data);} static int acpi_processor_add_fs(struct acpi_device *device){	struct proc_dir_entry *entry = NULL;  	if (!acpi_device_dir(device)) {		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),						     acpi_processor_dir);		if (!acpi_device_dir(device))			return -ENODEV;	} 	/* 'info' [R] */	entry = proc_create_data(ACPI_PROCESSOR_FILE_INFO,				 S_IRUGO, acpi_device_dir(device),				 &acpi_processor_info_fops,				 acpi_driver_data(device));	if (!entry)		return -EIO; 	/* 'throttling' [R/W] */	entry = proc_create_data(ACPI_PROCESSOR_FILE_THROTTLING,				 S_IFREG | S_IRUGO | S_IWUSR,				 acpi_device_dir(device),				 &acpi_processor_throttling_fops,				 acpi_driver_data(device));	if (!entry)		return -EIO; 	/* 'limit' [R/W] */	entry = proc_create_data(ACPI_PROCESSOR_FILE_LIMIT,				 S_IFREG | S_IRUGO | S_IWUSR,				 acpi_device_dir(device),				 &acpi_processor_limit_fops,				 acpi_driver_data(device));	if (!entry)		return -EIO;	return 0;}static int acpi_processor_remove_fs(struct acpi_device *device){ 	if (acpi_device_dir(device)) {		remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,				  acpi_device_dir(device));		remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,				  acpi_device_dir(device));		remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,				  acpi_device_dir(device));		remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);		acpi_device_dir(device) = NULL;	} 	return 0;}#elsestatic inline int acpi_processor_add_fs(struct acpi_device *device){	return 0;}static inline int acpi_processor_remove_fs(struct acpi_device *device){	return 0;}#endif /* Use the acpiid in MADT to map cpus in case of SMP */ #ifndef CONFIG_SMPstatic int get_cpu_id(acpi_handle handle, int type, u32 acpi_id) { return -1; }#else static struct acpi_table_madt *madt; static int map_lapic_id(struct acpi_subtable_header *entry,		 u32 acpi_id, int *apic_id){	struct acpi_madt_local_apic *lapic =		(struct acpi_madt_local_apic *)entry;	if ((lapic->lapic_flags & ACPI_MADT_ENABLED) &&	    lapic->processor_id == acpi_id) {		*apic_id = lapic->id;		return 1;	}	return 0;} static int map_x2apic_id(struct acpi_subtable_header *entry,			 int device_declaration, u32 acpi_id, int *apic_id){	struct acpi_madt_local_x2apic *apic =		(struct acpi_madt_local_x2apic *)entry;	u32 tmp = apic->local_apic_id; 	/* Only check enabled APICs*/	if (!(apic->lapic_flags & ACPI_MADT_ENABLED))		return 0; 	/* Device statement declaration type */	if (device_declaration) {		if (apic->uid == acpi_id)			goto found;	} 	return 0;found:	*apic_id = tmp;	return 1;} static int map_lsapic_id(struct acpi_subtable_header *entry,		int device_declaration, u32 acpi_id, int *apic_id){	struct acpi_madt_local_sapic *lsapic =		(struct acpi_madt_local_sapic *)entry;	u32 tmp = (lsapic->id << 8) | lsapic->eid; 	/* Only check enabled APICs*/	if (!(lsapic->lapic_flags & ACPI_MADT_ENABLED))		return 0; 	/* Device statement declaration type */	if (device_declaration) {		if (entry->length < 16)			printk(KERN_ERR PREFIX			    "Invalid LSAPIC with Device type processor (SAPIC ID %#x)\n",			    tmp);		else if (lsapic->uid == acpi_id)			goto found;	/* Processor statement declaration type */	} else if (lsapic->processor_id == acpi_id)		goto found; 	return 0;found:	*apic_id = tmp;	return 1;} static int map_madt_entry(int type, u32 acpi_id){	unsigned long madt_end, entry;	int apic_id = -1; 	if (!madt)

Lines 1–500 of 1209. Load more