2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* acpi.c - Architecture-Specific Low-Level ACPI Support
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 VA Linux Systems
|
|
|
|
* Copyright (C) 1999,2000 Walt Drummond <drummond@valinux.com>
|
|
|
|
* Copyright (C) 2000, 2002-2003 Hewlett-Packard Co.
|
|
|
|
* David Mosberger-Tang <davidm@hpl.hp.com>
|
|
|
|
* Copyright (C) 2000 Intel Corp.
|
|
|
|
* Copyright (C) 2000,2001 J.I. Lee <jung-ik.lee@intel.com>
|
|
|
|
* Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
|
|
* Copyright (C) 2001 Jenna Hall <jenna.s.hall@intel.com>
|
|
|
|
* Copyright (C) 2001 Takayoshi Kochi <t-kochi@bq.jp.nec.com>
|
|
|
|
* Copyright (C) 2002 Erich Focht <efocht@ess.nec.de>
|
2005-03-31 20:51:10 -07:00
|
|
|
* Copyright (C) 2004 Ashok Raj <ashok.raj@intel.com>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/acpi.h>
|
|
|
|
#include <linux/efi.h>
|
|
|
|
#include <linux/mmzone.h>
|
|
|
|
#include <linux/nodemask.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2010-02-22 12:11:39 -07:00
|
|
|
#include <acpi/processor.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/iosapic.h>
|
|
|
|
#include <asm/machvec.h>
|
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/numa.h>
|
|
|
|
#include <asm/sal.h>
|
|
|
|
#include <asm/cyclone.h>
|
2008-10-16 20:18:09 -06:00
|
|
|
#include <asm/xen/hypervisor.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define BAD_MADT_ENTRY(entry, end) ( \
|
|
|
|
(!entry) || (unsigned long)entry + sizeof(*entry) > end || \
|
2007-02-02 09:48:22 -07:00
|
|
|
((struct acpi_subtable_header *)entry)->length < sizeof(*entry))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
|
2008-12-17 01:55:18 -07:00
|
|
|
u32 acpi_rsdt_forced;
|
2005-03-31 20:51:10 -07:00
|
|
|
unsigned int acpi_cpei_override;
|
|
|
|
unsigned int acpi_cpei_phys_cpuid;
|
|
|
|
|
2007-07-24 20:26:33 -06:00
|
|
|
unsigned long acpi_wakeup_address = 0;
|
|
|
|
|
2007-11-23 18:08:02 -07:00
|
|
|
#ifdef CONFIG_IA64_GENERIC
|
|
|
|
static unsigned long __init acpi_find_rsdp(void)
|
|
|
|
{
|
|
|
|
unsigned long rsdp_phys = 0;
|
|
|
|
|
|
|
|
if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
|
|
|
|
rsdp_phys = efi.acpi20;
|
|
|
|
else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
|
|
|
|
printk(KERN_WARNING PREFIX
|
|
|
|
"v1.0/r0.71 tables no longer supported\n");
|
|
|
|
return rsdp_phys;
|
|
|
|
}
|
|
|
|
|
2007-05-24 11:59:44 -06:00
|
|
|
const char __init *
|
|
|
|
acpi_get_sysname(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned long rsdp_phys;
|
2007-02-02 09:48:19 -07:00
|
|
|
struct acpi_table_rsdp *rsdp;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct acpi_table_xsdt *xsdt;
|
|
|
|
struct acpi_table_header *hdr;
|
2011-08-23 18:05:25 -06:00
|
|
|
#ifdef CONFIG_INTEL_IOMMU
|
2008-10-17 13:14:13 -06:00
|
|
|
u64 i, nentries;
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rsdp_phys = acpi_find_rsdp();
|
|
|
|
if (!rsdp_phys) {
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR
|
|
|
|
"ACPI 2.0 RSDP not found, default to \"dig\"\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return "dig";
|
|
|
|
}
|
|
|
|
|
2007-02-02 09:48:19 -07:00
|
|
|
rsdp = (struct acpi_table_rsdp *)__va(rsdp_phys);
|
|
|
|
if (strncmp(rsdp->signature, ACPI_SIG_RSDP, sizeof(ACPI_SIG_RSDP) - 1)) {
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR
|
|
|
|
"ACPI 2.0 RSDP signature incorrect, default to \"dig\"\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return "dig";
|
|
|
|
}
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
xsdt = (struct acpi_table_xsdt *)__va(rsdp->xsdt_physical_address);
|
2005-04-16 16:20:36 -06:00
|
|
|
hdr = &xsdt->header;
|
2007-02-02 09:48:19 -07:00
|
|
|
if (strncmp(hdr->signature, ACPI_SIG_XSDT, sizeof(ACPI_SIG_XSDT) - 1)) {
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR
|
|
|
|
"ACPI 2.0 XSDT signature incorrect, default to \"dig\"\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return "dig";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(hdr->oem_id, "HP")) {
|
|
|
|
return "hpzx1";
|
2005-08-04 22:44:28 -06:00
|
|
|
} else if (!strcmp(hdr->oem_id, "SGI")) {
|
2008-05-06 14:18:57 -06:00
|
|
|
if (!strcmp(hdr->oem_table_id + 4, "UV"))
|
|
|
|
return "uv";
|
|
|
|
else
|
|
|
|
return "sn2";
|
2008-10-16 20:18:09 -06:00
|
|
|
} else if (xen_pv_domain() && !strcmp(hdr->oem_id, "XEN")) {
|
|
|
|
return "xen";
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-08-23 18:05:25 -06:00
|
|
|
#ifdef CONFIG_INTEL_IOMMU
|
2008-10-17 13:14:13 -06:00
|
|
|
/* Look for Intel IOMMU */
|
|
|
|
nentries = (hdr->length - sizeof(*hdr)) /
|
|
|
|
sizeof(xsdt->table_offset_entry[0]);
|
|
|
|
for (i = 0; i < nentries; i++) {
|
|
|
|
hdr = __va(xsdt->table_offset_entry[i]);
|
|
|
|
if (strncmp(hdr->signature, ACPI_SIG_DMAR,
|
|
|
|
sizeof(ACPI_SIG_DMAR) - 1) == 0)
|
|
|
|
return "dig_vtd";
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return "dig";
|
|
|
|
}
|
2010-02-25 14:09:52 -07:00
|
|
|
#endif /* CONFIG_IA64_GENERIC */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define ACPI_MAX_PLATFORM_INTERRUPTS 256
|
|
|
|
|
|
|
|
/* Array to record platform interrupt vectors for generic interrupt routing. */
|
|
|
|
int platform_intr_list[ACPI_MAX_PLATFORM_INTERRUPTS] = {
|
|
|
|
[0 ... ACPI_MAX_PLATFORM_INTERRUPTS - 1] = -1
|
|
|
|
};
|
|
|
|
|
|
|
|
enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_IOSAPIC;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Interrupt routing API for device drivers. Provides interrupt vector for
|
|
|
|
* a generic platform event. Currently only CPEI is implemented.
|
|
|
|
*/
|
2005-08-04 22:44:28 -06:00
|
|
|
int acpi_request_vector(u32 int_type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int vector = -1;
|
|
|
|
|
|
|
|
if (int_type < ACPI_MAX_PLATFORM_INTERRUPTS) {
|
|
|
|
/* corrected platform error interrupt */
|
|
|
|
vector = platform_intr_list[int_type];
|
|
|
|
} else
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR
|
|
|
|
"acpi_request_vector(): invalid interrupt type\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return vector;
|
|
|
|
}
|
|
|
|
|
2007-12-13 01:33:59 -07:00
|
|
|
char *__init __acpi_map_table(unsigned long phys_addr, unsigned long size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return __va(phys_addr);
|
|
|
|
}
|
|
|
|
|
2009-02-15 15:06:13 -07:00
|
|
|
void __init __acpi_unmap_table(char *map, unsigned long size)
|
2009-02-07 16:39:41 -07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Boot-time Table Parsing
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int available_cpus __initdata;
|
|
|
|
struct acpi_table_madt *acpi_madt __initdata;
|
|
|
|
static u8 has_8259;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static int __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header,
|
2005-08-04 22:44:28 -06:00
|
|
|
const unsigned long end)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_local_apic_override *lapic;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
lapic = (struct acpi_madt_local_apic_override *)header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (BAD_MADT_ENTRY(lapic, end))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (lapic->address) {
|
|
|
|
iounmap(ipi_base_addr);
|
|
|
|
ipi_base_addr = ioremap(lapic->address, 0);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_parse_lsapic(struct acpi_subtable_header * header, const unsigned long end)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_local_sapic *lsapic;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
lsapic = (struct acpi_madt_local_sapic *)header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
/*Skip BAD_MADT_ENTRY check, as lsapic size could vary */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
if (lsapic->lapic_flags & ACPI_MADT_ENABLED) {
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_SMP
|
2005-08-04 22:44:28 -06:00
|
|
|
smp_boot_data.cpu_phys_id[available_cpus] =
|
|
|
|
(lsapic->id << 8) | lsapic->eid;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
++available_cpus;
|
|
|
|
}
|
|
|
|
|
|
|
|
total_cpus++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_local_apic_nmi *lacpi_nmi;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
lacpi_nmi = (struct acpi_madt_local_apic_nmi *)header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (BAD_MADT_ENTRY(lacpi_nmi, end))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* TBD: Support lapic_nmi entries */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_parse_iosapic(struct acpi_subtable_header * header, const unsigned long end)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_io_sapic *iosapic;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
iosapic = (struct acpi_madt_io_sapic *)header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (BAD_MADT_ENTRY(iosapic, end))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-28 01:25:58 -06:00
|
|
|
return iosapic_init(iosapic->address, iosapic->global_irq_base);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-05-12 23:12:15 -06:00
|
|
|
static unsigned int __initdata acpi_madt_rev;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_parse_plat_int_src(struct acpi_subtable_header * header,
|
2005-08-04 22:44:28 -06:00
|
|
|
const unsigned long end)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_interrupt_source *plintsrc;
|
2005-04-16 16:20:36 -06:00
|
|
|
int vector;
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
plintsrc = (struct acpi_madt_interrupt_source *)header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (BAD_MADT_ENTRY(plintsrc, end))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get vector assignment for this interrupt, set attributes,
|
|
|
|
* and program the IOSAPIC routing table.
|
|
|
|
*/
|
|
|
|
vector = iosapic_register_platform_intr(plintsrc->type,
|
|
|
|
plintsrc->global_irq,
|
2007-02-02 09:48:22 -07:00
|
|
|
plintsrc->io_sapic_vector,
|
2005-04-16 16:20:36 -06:00
|
|
|
plintsrc->eid,
|
|
|
|
plintsrc->id,
|
2007-02-02 09:48:22 -07:00
|
|
|
((plintsrc->inti_flags & ACPI_MADT_POLARITY_MASK) ==
|
|
|
|
ACPI_MADT_POLARITY_ACTIVE_HIGH) ?
|
|
|
|
IOSAPIC_POL_HIGH : IOSAPIC_POL_LOW,
|
|
|
|
((plintsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) ==
|
|
|
|
ACPI_MADT_TRIGGER_EDGE) ?
|
|
|
|
IOSAPIC_EDGE : IOSAPIC_LEVEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
platform_intr_list[plintsrc->type] = vector;
|
2005-03-31 20:51:10 -07:00
|
|
|
if (acpi_madt_rev > 1) {
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_cpei_override = plintsrc->flags & ACPI_MADT_CPEI_OVERRIDE;
|
2005-03-31 20:51:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the physical id, so we can check when its being removed
|
|
|
|
*/
|
|
|
|
acpi_cpei_phys_cpuid = ((plintsrc->id << 8) | (plintsrc->eid)) & 0xffff;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-19 17:18:47 -07:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
2005-03-31 20:51:10 -07:00
|
|
|
unsigned int can_cpei_retarget(void)
|
|
|
|
{
|
|
|
|
extern int cpe_vector;
|
2005-11-11 15:32:40 -07:00
|
|
|
extern unsigned int force_cpei_retarget;
|
2005-03-31 20:51:10 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Only if CPEI is supported and the override flag
|
|
|
|
* is present, otherwise return that its re-targettable
|
|
|
|
* if we are in polling mode.
|
|
|
|
*/
|
2005-11-11 15:32:40 -07:00
|
|
|
if (cpe_vector > 0) {
|
|
|
|
if (acpi_cpei_override || force_cpei_retarget)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
2005-03-31 20:51:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int is_cpu_cpei_target(unsigned int cpu)
|
|
|
|
{
|
|
|
|
unsigned int logical_id;
|
|
|
|
|
|
|
|
logical_id = cpu_logical_id(acpi_cpei_phys_cpuid);
|
|
|
|
|
|
|
|
if (logical_id == cpu)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_cpei_target_cpu(unsigned int cpu)
|
|
|
|
{
|
|
|
|
acpi_cpei_phys_cpuid = cpu_physical_id(cpu);
|
|
|
|
}
|
2006-01-19 17:18:47 -07:00
|
|
|
#endif
|
2005-03-31 20:51:10 -07:00
|
|
|
|
|
|
|
unsigned int get_cpei_target_cpu(void)
|
|
|
|
{
|
|
|
|
return acpi_cpei_phys_cpuid;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_parse_int_src_ovr(struct acpi_subtable_header * header,
|
2005-08-04 22:44:28 -06:00
|
|
|
const unsigned long end)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_interrupt_override *p;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
p = (struct acpi_madt_interrupt_override *)header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (BAD_MADT_ENTRY(p, end))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
iosapic_override_isa_irq(p->source_irq, p->global_irq,
|
|
|
|
((p->inti_flags & ACPI_MADT_POLARITY_MASK) ==
|
2012-03-13 08:07:09 -06:00
|
|
|
ACPI_MADT_POLARITY_ACTIVE_LOW) ?
|
|
|
|
IOSAPIC_POL_LOW : IOSAPIC_POL_HIGH,
|
2007-02-02 09:48:22 -07:00
|
|
|
((p->inti_flags & ACPI_MADT_TRIGGER_MASK) ==
|
2012-03-13 08:07:09 -06:00
|
|
|
ACPI_MADT_TRIGGER_LEVEL) ?
|
|
|
|
IOSAPIC_LEVEL : IOSAPIC_EDGE);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_nmi_source *nmi_src;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
nmi_src = (struct acpi_madt_nmi_source *)header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (BAD_MADT_ENTRY(nmi_src, end))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* TBD: Support nimsrc entries */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static void __init acpi_madt_oem_check(char *oem_id, char *oem_table_id)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
if (!strncmp(oem_id, "IBM", 3) && (!strncmp(oem_table_id, "SERMOW", 6))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Unfortunately ITC_DRIFT is not yet part of the
|
|
|
|
* official SAL spec, so the ITC_DRIFT bit is not
|
|
|
|
* set by the BIOS on this hardware.
|
|
|
|
*/
|
|
|
|
sal_platform_features |= IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT;
|
|
|
|
|
|
|
|
cyclone_setup();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
static int __init acpi_parse_madt(struct acpi_table_header *table)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-02 09:48:22 -07:00
|
|
|
if (!table)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_madt = (struct acpi_table_madt *)table;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-03-31 20:51:10 -07:00
|
|
|
acpi_madt_rev = acpi_madt->header.revision;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* remember the value for reference after free_initmem() */
|
|
|
|
#ifdef CONFIG_ITANIUM
|
2005-08-04 22:44:28 -06:00
|
|
|
has_8259 = 1; /* Firmware on old Itanium systems is broken */
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2007-02-02 09:48:22 -07:00
|
|
|
has_8259 = acpi_madt->flags & ACPI_MADT_PCAT_COMPAT;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
iosapic_system_init(has_8259);
|
|
|
|
|
|
|
|
/* Get base address of IPI Message Block */
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
if (acpi_madt->address)
|
|
|
|
ipi_base_addr = ioremap(acpi_madt->address, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
printk(KERN_INFO PREFIX "Local APIC address %p\n", ipi_base_addr);
|
|
|
|
|
|
|
|
acpi_madt_oem_check(acpi_madt->header.oem_id,
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_madt->header.oem_table_id);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI_NUMA
|
|
|
|
|
|
|
|
#undef SLIT_DEBUG
|
|
|
|
|
|
|
|
#define PXM_FLAG_LEN ((MAX_PXM_DOMAINS + 1)/32)
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int __initdata srat_num_cpus; /* number of cpus */
|
2005-04-16 16:20:36 -06:00
|
|
|
static u32 __devinitdata pxm_flag[PXM_FLAG_LEN];
|
|
|
|
#define pxm_bit_set(bit) (set_bit(bit,(void *)pxm_flag))
|
|
|
|
#define pxm_bit_test(bit) (test_bit(bit,(void *)pxm_flag))
|
|
|
|
static struct acpi_table_slit __initdata *slit_table;
|
2008-04-03 14:17:13 -06:00
|
|
|
cpumask_t early_cpu_possible_map = CPU_MASK_NONE;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-01-17 02:21:49 -07:00
|
|
|
static int __init
|
|
|
|
get_processor_proximity_domain(struct acpi_srat_cpu_affinity *pa)
|
2006-03-02 15:02:25 -07:00
|
|
|
{
|
|
|
|
int pxm;
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
pxm = pa->proximity_domain_lo;
|
2012-01-17 02:21:49 -07:00
|
|
|
if (ia64_platform_is("sn2") || acpi_srat_revision >= 2)
|
2007-02-02 09:48:22 -07:00
|
|
|
pxm += pa->proximity_domain_hi[0] << 8;
|
2006-03-02 15:02:25 -07:00
|
|
|
return pxm;
|
|
|
|
}
|
|
|
|
|
2012-01-17 02:21:49 -07:00
|
|
|
static int __init
|
|
|
|
get_memory_proximity_domain(struct acpi_srat_mem_affinity *ma)
|
2006-03-02 15:02:25 -07:00
|
|
|
{
|
|
|
|
int pxm;
|
|
|
|
|
|
|
|
pxm = ma->proximity_domain;
|
2012-01-17 02:21:49 -07:00
|
|
|
if (!ia64_platform_is("sn2") && acpi_srat_revision <= 1)
|
2007-02-02 20:02:55 -07:00
|
|
|
pxm &= 0xff;
|
2007-02-02 09:48:22 -07:00
|
|
|
|
2006-03-02 15:02:25 -07:00
|
|
|
return pxm;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* ACPI 2.0 SLIT (System Locality Information Table)
|
|
|
|
* http://devresource.hp.com/devresource/Docs/TechPapers/IA64/slit.pdf
|
|
|
|
*/
|
2005-08-04 22:44:28 -06:00
|
|
|
void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
u32 len;
|
|
|
|
|
|
|
|
len = sizeof(struct acpi_table_header) + 8
|
2007-02-02 09:48:22 -07:00
|
|
|
+ slit->locality_count * slit->locality_count;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (slit->header.length != len) {
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR
|
|
|
|
"ACPI 2.0 SLIT: size mismatch: %d expected, %d actual\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
len, slit->header.length);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
slit_table = slit;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-03-02 15:02:25 -07:00
|
|
|
int pxm;
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
if (!(pa->flags & ACPI_SRAT_CPU_ENABLED))
|
2006-03-14 22:45:11 -07:00
|
|
|
return;
|
|
|
|
|
2011-01-07 10:11:55 -07:00
|
|
|
if (srat_num_cpus >= ARRAY_SIZE(node_cpuid)) {
|
|
|
|
printk_once(KERN_WARNING
|
2011-01-12 12:02:43 -07:00
|
|
|
"node_cpuid[%ld] is too small, may not be able to use all cpus\n",
|
2011-01-07 10:11:55 -07:00
|
|
|
ARRAY_SIZE(node_cpuid));
|
|
|
|
return;
|
|
|
|
}
|
2006-03-02 15:02:25 -07:00
|
|
|
pxm = get_processor_proximity_domain(pa);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* record this node in proximity bitmap */
|
2006-03-02 15:02:25 -07:00
|
|
|
pxm_bit_set(pxm);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
node_cpuid[srat_num_cpus].phys_id =
|
2007-02-02 09:48:22 -07:00
|
|
|
(pa->apic_id << 8) | (pa->local_sapic_eid);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* nid should be overridden as logical node id later */
|
2006-03-02 15:02:25 -07:00
|
|
|
node_cpuid[srat_num_cpus].nid = pxm;
|
2008-04-03 14:17:13 -06:00
|
|
|
cpu_set(srat_num_cpus, early_cpu_possible_map);
|
2005-04-16 16:20:36 -06:00
|
|
|
srat_num_cpus++;
|
|
|
|
}
|
|
|
|
|
2012-07-31 09:41:09 -06:00
|
|
|
int __init
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned long paddr, size;
|
2006-03-02 15:02:25 -07:00
|
|
|
int pxm;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct node_memblk_s *p, *q, *pend;
|
|
|
|
|
2006-03-02 15:02:25 -07:00
|
|
|
pxm = get_memory_proximity_domain(ma);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* fill node memory chunk structure */
|
2007-02-02 09:48:22 -07:00
|
|
|
paddr = ma->base_address;
|
|
|
|
size = ma->length;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Ignore disabled entries */
|
2007-02-02 09:48:22 -07:00
|
|
|
if (!(ma->flags & ACPI_SRAT_MEM_ENABLED))
|
2012-07-31 09:41:09 -06:00
|
|
|
return -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* record this node in proximity bitmap */
|
|
|
|
pxm_bit_set(pxm);
|
|
|
|
|
|
|
|
/* Insertion sort based on base address */
|
|
|
|
pend = &node_memblk[num_node_memblks];
|
|
|
|
for (p = &node_memblk[0]; p < pend; p++) {
|
|
|
|
if (paddr < p->start_paddr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (p < pend) {
|
|
|
|
for (q = pend - 1; q >= p; q--)
|
|
|
|
*(q + 1) = *q;
|
|
|
|
}
|
|
|
|
p->start_paddr = paddr;
|
|
|
|
p->size = size;
|
|
|
|
p->nid = pxm;
|
|
|
|
num_node_memblks++;
|
2012-07-31 09:41:09 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
void __init acpi_numa_arch_fixup(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i, j, node_from, node_to;
|
|
|
|
|
|
|
|
/* If there's no SRAT, fix the phys_id and mark node 0 online */
|
|
|
|
if (srat_num_cpus == 0) {
|
|
|
|
node_set_online(0);
|
|
|
|
node_cpuid[0].phys_id = hard_smp_processor_id();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MCD - This can probably be dropped now. No need for pxm ID to node ID
|
|
|
|
* mapping with sparse node numbering iff MAX_PXM_DOMAINS <= MAX_NUMNODES.
|
|
|
|
*/
|
|
|
|
nodes_clear(node_online_map);
|
|
|
|
for (i = 0; i < MAX_PXM_DOMAINS; i++) {
|
|
|
|
if (pxm_bit_test(i)) {
|
2006-06-23 03:03:19 -06:00
|
|
|
int nid = acpi_map_pxm_to_node(i);
|
2005-04-16 16:20:36 -06:00
|
|
|
node_set_online(nid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set logical node id in memory chunk structure */
|
|
|
|
for (i = 0; i < num_node_memblks; i++)
|
2006-06-23 03:03:19 -06:00
|
|
|
node_memblk[i].nid = pxm_to_node(node_memblk[i].nid);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* assign memory bank numbers for each chunk on each node */
|
|
|
|
for_each_online_node(i) {
|
|
|
|
int bank;
|
|
|
|
|
|
|
|
bank = 0;
|
|
|
|
for (j = 0; j < num_node_memblks; j++)
|
|
|
|
if (node_memblk[j].nid == i)
|
|
|
|
node_memblk[j].bank = bank++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set logical node id in cpu structure */
|
2008-04-03 14:17:13 -06:00
|
|
|
for_each_possible_early_cpu(i)
|
2006-06-23 03:03:19 -06:00
|
|
|
node_cpuid[i].nid = pxm_to_node(node_cpuid[i].nid);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_INFO "Number of logical nodes in system = %d\n",
|
|
|
|
num_online_nodes());
|
|
|
|
printk(KERN_INFO "Number of memory chunks in system = %d\n",
|
|
|
|
num_node_memblks);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-09 17:48:18 -06:00
|
|
|
if (!slit_table) {
|
|
|
|
for (i = 0; i < MAX_NUMNODES; i++)
|
|
|
|
for (j = 0; j < MAX_NUMNODES; j++)
|
|
|
|
node_distance(i, j) = i == j ? LOCAL_DISTANCE :
|
|
|
|
REMOTE_DISTANCE;
|
2005-08-04 22:44:28 -06:00
|
|
|
return;
|
2008-06-09 17:48:18 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
memset(numa_slit, -1, sizeof(numa_slit));
|
2007-02-02 09:48:22 -07:00
|
|
|
for (i = 0; i < slit_table->locality_count; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!pxm_bit_test(i))
|
|
|
|
continue;
|
2006-06-23 03:03:19 -06:00
|
|
|
node_from = pxm_to_node(i);
|
2007-02-02 09:48:22 -07:00
|
|
|
for (j = 0; j < slit_table->locality_count; j++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!pxm_bit_test(j))
|
|
|
|
continue;
|
2006-06-23 03:03:19 -06:00
|
|
|
node_to = pxm_to_node(j);
|
2005-04-16 16:20:36 -06:00
|
|
|
node_distance(node_from, node_to) =
|
2007-02-02 09:48:22 -07:00
|
|
|
slit_table->entry[i * slit_table->locality_count + j];
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef SLIT_DEBUG
|
|
|
|
printk("ACPI 2.0 SLIT locality table:\n");
|
|
|
|
for_each_online_node(i) {
|
|
|
|
for_each_online_node(j)
|
2005-08-04 22:44:28 -06:00
|
|
|
printk("%03d ", node_distance(i, j));
|
2005-04-16 16:20:36 -06:00
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
#endif /* CONFIG_ACPI_NUMA */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-28 12:42:00 -06:00
|
|
|
/*
|
|
|
|
* success: return IRQ number (>=0)
|
|
|
|
* failure: return < 0
|
|
|
|
*/
|
2009-04-27 19:01:20 -06:00
|
|
|
int acpi_register_gsi(struct device *dev, u32 gsi, int triggering, int polarity)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-12-22 10:50:04 -07:00
|
|
|
if (acpi_irq_model == ACPI_IRQ_MODEL_PLATFORM)
|
|
|
|
return gsi;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (has_8259 && gsi < 16)
|
|
|
|
return isa_irq_to_vector(gsi);
|
|
|
|
|
|
|
|
return iosapic_register_intr(gsi,
|
2005-12-28 00:43:51 -07:00
|
|
|
(polarity ==
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_ACTIVE_HIGH) ? IOSAPIC_POL_HIGH :
|
|
|
|
IOSAPIC_POL_LOW,
|
2005-12-28 00:43:51 -07:00
|
|
|
(triggering ==
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
|
|
|
|
IOSAPIC_LEVEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
|
|
|
|
void acpi_unregister_gsi(u32 gsi)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-03 02:14:02 -07:00
|
|
|
if (acpi_irq_model == ACPI_IRQ_MODEL_PLATFORM)
|
|
|
|
return;
|
|
|
|
|
2008-05-14 10:00:24 -06:00
|
|
|
if (has_8259 && gsi < 16)
|
|
|
|
return;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
iosapic_unregister_intr(gsi);
|
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
static int __init acpi_parse_fadt(struct acpi_table_header *table)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct acpi_table_header *fadt_header;
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_table_fadt *fadt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
if (!table)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
fadt_header = (struct acpi_table_header *)table;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (fadt_header->revision != 3)
|
2005-08-04 22:44:28 -06:00
|
|
|
return -ENODEV; /* Only deal with ACPI 2.0 FADT */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
fadt = (struct acpi_table_fadt *)fadt_header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-27 19:01:20 -06:00
|
|
|
acpi_register_gsi(NULL, fadt->sci_interrupt, ACPI_LEVEL_SENSITIVE,
|
|
|
|
ACPI_ACTIVE_LOW);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-05 15:57:52 -07:00
|
|
|
int __init early_acpi_boot_init(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* do a partial walk of MADT to determine how many CPUs
|
|
|
|
* we have including offline CPUs
|
|
|
|
*/
|
|
|
|
if (acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
|
|
|
|
printk(KERN_ERR PREFIX "Can't find MADT\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_SAPIC,
|
|
|
|
acpi_parse_lsapic, NR_CPUS);
|
|
|
|
if (ret < 1)
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Error parsing MADT - no LAPIC entries\n");
|
|
|
|
|
2009-10-01 22:28:56 -06:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
if (available_cpus == 0) {
|
|
|
|
printk(KERN_INFO "ACPI: Found 0 CPUS; assuming 1\n");
|
|
|
|
printk(KERN_INFO "CPU 0 (0x%04x)", hard_smp_processor_id());
|
|
|
|
smp_boot_data.cpu_phys_id[available_cpus] =
|
|
|
|
hard_smp_processor_id();
|
|
|
|
available_cpus = 1; /* We've got at least one of these, no? */
|
|
|
|
}
|
|
|
|
smp_boot_data.cpu_count = available_cpus;
|
|
|
|
#endif
|
|
|
|
/* Make boot-up look pretty */
|
|
|
|
printk(KERN_INFO "%d CPUs available, %d CPUs total\n", available_cpus,
|
|
|
|
total_cpus);
|
|
|
|
|
2008-11-05 15:57:52 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
int __init acpi_boot_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MADT
|
|
|
|
* ----
|
|
|
|
* Parse the Multiple APIC Description Table (MADT), if exists.
|
|
|
|
* Note that this table provides platform SMP configuration
|
|
|
|
* information -- the successor to MPS tables.
|
|
|
|
*/
|
|
|
|
|
2007-02-16 14:07:27 -07:00
|
|
|
if (acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR PREFIX "Can't find MADT\n");
|
|
|
|
goto skip_madt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Local APIC */
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
if (acpi_table_parse_madt
|
2007-02-02 09:48:22 -07:00
|
|
|
(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, acpi_parse_lapic_addr_ovr, 0) < 0)
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Error parsing LAPIC address override entry\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
if (acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, acpi_parse_lapic_nmi, 0)
|
2005-08-04 22:44:28 -06:00
|
|
|
< 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n");
|
|
|
|
|
|
|
|
/* I/O APIC */
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
if (acpi_table_parse_madt
|
2007-10-11 13:33:55 -06:00
|
|
|
(ACPI_MADT_TYPE_IO_SAPIC, acpi_parse_iosapic, NR_IOSAPICS) < 1) {
|
|
|
|
if (!ia64_platform_is("sn2"))
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Error parsing MADT - no IOSAPIC entries\n");
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* System-Level Interrupt Routing */
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
if (acpi_table_parse_madt
|
2007-02-02 09:48:22 -07:00
|
|
|
(ACPI_MADT_TYPE_INTERRUPT_SOURCE, acpi_parse_plat_int_src,
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_MAX_PLATFORM_INTERRUPTS) < 0)
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Error parsing platform interrupt source entry\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
if (acpi_table_parse_madt
|
2007-02-02 09:48:22 -07:00
|
|
|
(ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, acpi_parse_int_src_ovr, 0) < 0)
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Error parsing interrupt source overrides entry\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
if (acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE, acpi_parse_nmi_src, 0) < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n");
|
2005-08-04 22:44:28 -06:00
|
|
|
skip_madt:
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* FADT says whether a legacy keyboard controller is present.
|
|
|
|
* The FADT also contains an SCI_INT line, by which the system
|
|
|
|
* gets interrupts such as power and sleep buttons. If it's not
|
|
|
|
* on a Legacy interrupt, it needs to be setup.
|
|
|
|
*/
|
2007-02-16 14:07:27 -07:00
|
|
|
if (acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt))
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR PREFIX "Can't find FADT\n");
|
|
|
|
|
2009-10-01 22:28:56 -06:00
|
|
|
#ifdef CONFIG_ACPI_NUMA
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
if (srat_num_cpus == 0) {
|
|
|
|
int cpu, i = 1;
|
|
|
|
for (cpu = 0; cpu < smp_boot_data.cpu_count; cpu++)
|
2005-08-04 22:44:28 -06:00
|
|
|
if (smp_boot_data.cpu_phys_id[cpu] !=
|
|
|
|
hard_smp_processor_id())
|
|
|
|
node_cpuid[i++].phys_id =
|
|
|
|
smp_boot_data.cpu_phys_id[cpu];
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-07-06 19:18:10 -06:00
|
|
|
#endif
|
|
|
|
build_cpu_to_node_map();
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
int acpi_gsi_to_irq(u32 gsi, unsigned int *irq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-26 00:31:34 -06:00
|
|
|
int tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (has_8259 && gsi < 16)
|
|
|
|
*irq = isa_irq_to_vector(gsi);
|
|
|
|
else {
|
2007-07-26 00:31:34 -06:00
|
|
|
tmp = gsi_to_irq(gsi);
|
|
|
|
if (tmp == -1)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -1;
|
2007-07-26 00:31:34 -06:00
|
|
|
*irq = tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-30 02:07:02 -06:00
|
|
|
int acpi_isa_irq_to_gsi(unsigned isa_irq, u32 *gsi)
|
|
|
|
{
|
|
|
|
if (isa_irq >= 16)
|
|
|
|
return -1;
|
|
|
|
*gsi = isa_irq;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* ACPI based hotplug CPU support
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_ACPI_HOTPLUG_CPU
|
2011-02-17 09:36:24 -07:00
|
|
|
static __cpuinit
|
2008-07-16 12:47:08 -06:00
|
|
|
int acpi_map_cpu2node(acpi_handle handle, int cpu, int physid)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_ACPI_NUMA
|
2005-08-04 22:44:28 -06:00
|
|
|
int pxm_id;
|
2006-09-25 17:25:21 -06:00
|
|
|
int nid;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
pxm_id = acpi_get_pxm(handle);
|
|
|
|
/*
|
2006-09-25 17:25:21 -06:00
|
|
|
* We don't have cpu-only-node hotadd. But if the system equips
|
|
|
|
* SRAT table, pxm is already found and node is ready.
|
|
|
|
* So, just pxm_to_nid(pxm) is OK.
|
|
|
|
* This code here is for the system which doesn't have full SRAT
|
|
|
|
* table for possible cpus.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2006-09-25 17:25:21 -06:00
|
|
|
nid = acpi_map_pxm_to_node(pxm_id);
|
2005-08-04 22:44:28 -06:00
|
|
|
node_cpuid[cpu].phys_id = physid;
|
2006-09-25 17:25:21 -06:00
|
|
|
node_cpuid[cpu].nid = nid;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2005-08-04 22:44:28 -06:00
|
|
|
return (0);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-02-14 16:01:12 -07:00
|
|
|
int additional_cpus __initdata = -1;
|
|
|
|
|
|
|
|
static __init int setup_additional_cpus(char *s)
|
|
|
|
{
|
|
|
|
if (s)
|
|
|
|
additional_cpus = simple_strtol(s, NULL, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
early_param("additional_cpus", setup_additional_cpus);
|
|
|
|
|
|
|
|
/*
|
2012-03-28 23:08:31 -06:00
|
|
|
* cpu_possible_mask should be static, it cannot change as CPUs
|
2006-02-14 16:01:12 -07:00
|
|
|
* are onlined, or offlined. The reason is per-cpu data-structures
|
|
|
|
* are allocated by some modules at init time, and dont expect to
|
|
|
|
* do this dynamically on cpu arrival/departure.
|
2012-03-28 15:42:46 -06:00
|
|
|
* cpu_present_mask on the other hand can change dynamically.
|
2006-02-14 16:01:12 -07:00
|
|
|
* In case when cpu_hotplug is not compiled, then we resort to current
|
|
|
|
* behaviour, which is cpu_possible == cpu_present.
|
|
|
|
* - Ashok Raj
|
|
|
|
*
|
|
|
|
* Three ways to find out the number of additional hotplug CPUs:
|
|
|
|
* - If the BIOS specified disabled CPUs in ACPI/mptables use that.
|
|
|
|
* - The user can overwrite it with additional_cpus=NUM
|
|
|
|
* - Otherwise don't reserve additional CPUs.
|
|
|
|
*/
|
|
|
|
__init void prefill_possible_map(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int possible, disabled_cpus;
|
|
|
|
|
|
|
|
disabled_cpus = total_cpus - available_cpus;
|
2006-02-16 15:01:48 -07:00
|
|
|
|
2006-02-14 16:01:12 -07:00
|
|
|
if (additional_cpus == -1) {
|
2006-02-16 15:01:48 -07:00
|
|
|
if (disabled_cpus > 0)
|
2006-02-14 16:01:12 -07:00
|
|
|
additional_cpus = disabled_cpus;
|
2006-02-16 15:01:48 -07:00
|
|
|
else
|
2006-02-14 16:01:12 -07:00
|
|
|
additional_cpus = 0;
|
2006-02-16 15:01:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
possible = available_cpus + additional_cpus;
|
|
|
|
|
2010-02-10 02:20:37 -07:00
|
|
|
if (possible > nr_cpu_ids)
|
|
|
|
possible = nr_cpu_ids;
|
2006-02-14 16:01:12 -07:00
|
|
|
|
|
|
|
printk(KERN_INFO "SMP: Allowing %d CPUs, %d hotplug CPUs\n",
|
2006-02-16 15:01:48 -07:00
|
|
|
possible, max((possible - available_cpus), 0));
|
2006-02-14 16:01:12 -07:00
|
|
|
|
|
|
|
for (i = 0; i < possible; i++)
|
2009-03-15 21:42:43 -06:00
|
|
|
set_cpu_possible(i, true);
|
2006-02-14 16:01:12 -07:00
|
|
|
}
|
|
|
|
|
2011-02-17 09:36:24 -07:00
|
|
|
static int __cpuinit _acpi_map_lsapic(acpi_handle handle, int *pcpu)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
2005-04-16 16:20:36 -06:00
|
|
|
union acpi_object *obj;
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_local_sapic *lsapic;
|
2005-04-16 16:20:36 -06:00
|
|
|
cpumask_t tmp_map;
|
2008-07-16 12:47:08 -06:00
|
|
|
int cpu, physid;
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
if (!buffer.length || !buffer.pointer)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
obj = buffer.pointer;
|
2007-02-02 09:48:22 -07:00
|
|
|
if (obj->type != ACPI_TYPE_BUFFER)
|
|
|
|
{
|
2006-06-30 01:19:10 -06:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
lsapic = (struct acpi_madt_local_sapic *)obj->buffer.pointer;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
if ((lsapic->header.type != ACPI_MADT_TYPE_LOCAL_SAPIC) ||
|
2007-12-07 15:59:30 -07:00
|
|
|
(!(lsapic->lapic_flags & ACPI_MADT_ENABLED))) {
|
2006-06-30 01:19:10 -06:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
physid = ((lsapic->id << 8) | (lsapic->eid));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-30 01:19:10 -06:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 16:20:36 -06:00
|
|
|
buffer.length = ACPI_ALLOCATE_BUFFER;
|
|
|
|
buffer.pointer = NULL;
|
|
|
|
|
2009-03-15 21:42:42 -06:00
|
|
|
cpumask_complement(&tmp_map, cpu_present_mask);
|
|
|
|
cpu = cpumask_first(&tmp_map);
|
|
|
|
if (cpu >= nr_cpu_ids)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
acpi_map_cpu2node(handle, cpu, physid);
|
|
|
|
|
2012-03-28 15:42:46 -06:00
|
|
|
set_cpu_present(cpu, true);
|
2005-04-16 16:20:36 -06:00
|
|
|
ia64_cpu_to_sapicid[cpu] = physid;
|
|
|
|
|
2010-02-22 12:11:39 -07:00
|
|
|
acpi_processor_set_pdc(handle);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
*pcpu = cpu;
|
2005-08-04 22:44:28 -06:00
|
|
|
return (0);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-02-17 09:36:24 -07:00
|
|
|
/* wrapper to silence section mismatch warning */
|
|
|
|
int __ref acpi_map_lsapic(acpi_handle handle, int *pcpu)
|
|
|
|
{
|
|
|
|
return _acpi_map_lsapic(handle, pcpu);
|
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
EXPORT_SYMBOL(acpi_map_lsapic);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
int acpi_unmap_lsapic(int cpu)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
ia64_cpu_to_sapicid[cpu] = -1;
|
2012-03-28 15:42:46 -06:00
|
|
|
set_cpu_present(cpu, false);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI_NUMA
|
|
|
|
/* NUMA specific cleanup's */
|
|
|
|
#endif
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
return (0);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
EXPORT_SYMBOL(acpi_unmap_lsapic);
|
2005-08-04 22:44:28 -06:00
|
|
|
#endif /* CONFIG_ACPI_HOTPLUG_CPU */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI_NUMA
|
2005-09-16 11:43:45 -06:00
|
|
|
static acpi_status __devinit
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_map_iosapic(acpi_handle handle, u32 depth, void *context, void **ret)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
2005-04-16 16:20:36 -06:00
|
|
|
union acpi_object *obj;
|
2007-02-02 09:48:22 -07:00
|
|
|
struct acpi_madt_io_sapic *iosapic;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int gsi_base;
|
2005-03-24 22:58:00 -07:00
|
|
|
int pxm, node;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Only care about objects w/ a method that returns the MADT */
|
|
|
|
if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
|
|
|
|
return AE_OK;
|
|
|
|
|
|
|
|
if (!buffer.length || !buffer.pointer)
|
|
|
|
return AE_OK;
|
|
|
|
|
|
|
|
obj = buffer.pointer;
|
|
|
|
if (obj->type != ACPI_TYPE_BUFFER ||
|
|
|
|
obj->buffer.length < sizeof(*iosapic)) {
|
2006-06-30 01:19:10 -06:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 16:20:36 -06:00
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
iosapic = (struct acpi_madt_io_sapic *)obj->buffer.pointer;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-02 09:48:22 -07:00
|
|
|
if (iosapic->header.type != ACPI_MADT_TYPE_IO_SAPIC) {
|
2006-06-30 01:19:10 -06:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 16:20:36 -06:00
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
gsi_base = iosapic->global_irq_base;
|
|
|
|
|
2006-06-30 01:19:10 -06:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2005-03-24 22:58:00 -07:00
|
|
|
* OK, it's an IOSAPIC MADT entry, look for a _PXM value to tell
|
2005-04-16 16:20:36 -06:00
|
|
|
* us which node to associate this with.
|
|
|
|
*/
|
2005-03-24 22:58:00 -07:00
|
|
|
pxm = acpi_get_pxm(handle);
|
|
|
|
if (pxm < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return AE_OK;
|
|
|
|
|
2006-06-23 03:03:19 -06:00
|
|
|
node = pxm_to_node(pxm);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (node >= MAX_NUMNODES || !node_online(node) ||
|
2008-12-26 04:53:40 -07:00
|
|
|
cpumask_empty(cpumask_of_node(node)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return AE_OK;
|
|
|
|
|
|
|
|
/* We know a gsi to node mapping! */
|
|
|
|
map_iosapic_to_node(gsi_base, node);
|
|
|
|
return AE_OK;
|
|
|
|
}
|
2005-09-16 11:43:45 -06:00
|
|
|
|
|
|
|
static int __init
|
|
|
|
acpi_map_iosapics (void)
|
|
|
|
{
|
|
|
|
acpi_get_devices(NULL, acpi_map_iosapic, NULL, NULL);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
fs_initcall(acpi_map_iosapics);
|
|
|
|
#endif /* CONFIG_ACPI_NUMA */
|
2005-04-28 01:25:58 -06:00
|
|
|
|
2008-04-30 01:51:06 -06:00
|
|
|
int __ref acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base)
|
2005-04-28 01:25:58 -06:00
|
|
|
{
|
2005-04-28 01:25:58 -06:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if ((err = iosapic_init(phys_addr, gsi_base)))
|
|
|
|
return err;
|
|
|
|
|
2005-09-14 23:36:35 -06:00
|
|
|
#ifdef CONFIG_ACPI_NUMA
|
2005-04-28 01:25:58 -06:00
|
|
|
acpi_map_iosapic(handle, 0, NULL, NULL);
|
2005-08-04 22:44:28 -06:00
|
|
|
#endif /* CONFIG_ACPI_NUMA */
|
2005-04-28 01:25:58 -06:00
|
|
|
|
|
|
|
return 0;
|
2005-04-28 01:25:58 -06:00
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2005-04-28 01:25:58 -06:00
|
|
|
EXPORT_SYMBOL(acpi_register_ioapic);
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base)
|
2005-04-28 01:25:58 -06:00
|
|
|
{
|
2005-04-28 01:25:58 -06:00
|
|
|
return iosapic_remove(gsi_base);
|
2005-04-28 01:25:58 -06:00
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2005-04-28 01:25:58 -06:00
|
|
|
EXPORT_SYMBOL(acpi_unregister_ioapic);
|
|
|
|
|
2007-07-24 20:26:33 -06:00
|
|
|
/*
|
2011-02-08 15:42:22 -07:00
|
|
|
* acpi_suspend_lowlevel() - save kernel state and suspend.
|
2007-07-24 20:26:33 -06:00
|
|
|
*
|
|
|
|
* TBD when when IA64 starts to support suspend...
|
|
|
|
*/
|
2011-02-08 15:42:22 -07:00
|
|
|
int acpi_suspend_lowlevel(void) { return 0; }
|