2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Intel Multiprocessor Specification 1.1 and 1.4
|
|
|
|
* compliant MP-table parsing routines.
|
|
|
|
*
|
|
|
|
* (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
|
|
|
|
* (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
|
2008-04-04 19:43:18 +00:00
|
|
|
* (c) 2008 Alexey Starikovskiy <astarikovskiy@suse.de>
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <linux/mc146818rtc.h>
|
|
|
|
#include <linux/bitops.h>
|
2008-04-04 19:43:18 +00:00
|
|
|
#include <linux/acpi.h>
|
|
|
|
#include <linux/module.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/mtrr.h>
|
|
|
|
#include <asm/mpspec.h>
|
2008-04-04 19:43:18 +00:00
|
|
|
#include <asm/pgalloc.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/io_apic.h>
|
2008-04-04 19:43:18 +00:00
|
|
|
#include <asm/proto.h>
|
|
|
|
#include <asm/acpi.h>
|
2008-03-17 19:08:17 +00:00
|
|
|
#include <asm/bios_ebda.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <mach_apic.h>
|
2008-04-04 19:43:18 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2006-09-26 08:52:26 +00:00
|
|
|
#include <mach_apicdef.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <mach_mpparse.h>
|
2008-04-04 19:43:18 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Have we found an MP table */
|
|
|
|
int smp_found_config;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Various Linux-internal data structures created from the
|
|
|
|
* MP-table.
|
|
|
|
*/
|
2008-03-20 11:55:02 +00:00
|
|
|
#if defined (CONFIG_MCA) || defined (CONFIG_EISA)
|
2008-04-04 19:42:03 +00:00
|
|
|
int mp_bus_id_to_type[MAX_MP_BUSSES];
|
2008-03-20 11:55:02 +00:00
|
|
|
#endif
|
2008-04-04 19:43:18 +00:00
|
|
|
|
2008-03-20 11:54:09 +00:00
|
|
|
DECLARE_BITMAP(mp_bus_not_pci, MAX_MP_BUSSES);
|
2008-04-04 19:42:03 +00:00
|
|
|
int mp_bus_id_to_pci_bus[MAX_MP_BUSSES] = {[0 ... MAX_MP_BUSSES - 1] = -1 };
|
2008-04-04 19:43:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int mp_current_pci_id;
|
|
|
|
|
|
|
|
int pic_mode;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Intel MP BIOS table parsing routines:
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Checksum an MP configuration block.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int __init mpf_checksum(unsigned char *mp, int len)
|
|
|
|
{
|
|
|
|
int sum = 0;
|
|
|
|
|
|
|
|
while (len--)
|
|
|
|
sum += *mp++;
|
|
|
|
|
|
|
|
return sum & 0xFF;
|
|
|
|
}
|
|
|
|
|
2008-03-17 19:08:55 +00:00
|
|
|
#ifdef CONFIG_X86_NUMAQ
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Have to match translation table entries to main table entries by counter
|
|
|
|
* hence the mpc_record variable .... can't see a less disgusting way of
|
|
|
|
* doing this ....
|
|
|
|
*/
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
static int mpc_record;
|
|
|
|
static struct mpc_config_translation *translation_table[MAX_MPC_ENTRY]
|
|
|
|
__cpuinitdata;
|
2008-03-17 19:08:55 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-27 20:54:13 +00:00
|
|
|
static void __cpuinit MP_processor_info(struct mpc_config_processor *m)
|
|
|
|
{
|
|
|
|
int apicid;
|
2008-04-04 19:42:15 +00:00
|
|
|
char *bootup_cpu = "";
|
2008-03-27 20:54:13 +00:00
|
|
|
|
2008-03-03 17:12:41 +00:00
|
|
|
if (!(m->mpc_cpuflag & CPU_ENABLED)) {
|
|
|
|
disabled_cpus++;
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
2008-03-03 17:12:41 +00:00
|
|
|
}
|
2008-03-17 19:08:36 +00:00
|
|
|
#ifdef CONFIG_X86_NUMAQ
|
2005-04-16 22:20:36 +00:00
|
|
|
apicid = mpc_apic_id(m, translation_table[mpc_record]);
|
2008-03-17 19:08:36 +00:00
|
|
|
#else
|
|
|
|
apicid = m->mpc_apicid;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
if (m->mpc_cpuflag & CPU_BOOTPROCESSOR) {
|
2008-04-04 19:42:15 +00:00
|
|
|
bootup_cpu = " (Bootup-CPU)";
|
2005-04-16 22:20:36 +00:00
|
|
|
boot_cpu_physical_apicid = m->mpc_apicid;
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:15 +00:00
|
|
|
printk(KERN_INFO "Processor #%d%s\n", m->mpc_apicid, bootup_cpu);
|
2008-03-27 20:54:13 +00:00
|
|
|
generic_processor_info(apicid, m->mpc_apicver);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
static void __init MP_bus_info(struct mpc_config_bus *m)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char str[7];
|
|
|
|
|
|
|
|
memcpy(str, m->mpc_bustype, 6);
|
|
|
|
str[6] = 0;
|
|
|
|
|
2008-03-17 19:08:48 +00:00
|
|
|
#ifdef CONFIG_X86_NUMAQ
|
2005-04-16 22:20:36 +00:00
|
|
|
mpc_oem_bus_info(m, str, translation_table[mpc_record]);
|
2008-03-17 19:08:48 +00:00
|
|
|
#else
|
|
|
|
Dprintk("Bus #%d is %s\n", m->mpc_busid, str);
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-26 08:52:35 +00:00
|
|
|
#if MAX_MP_BUSSES < 256
|
2006-04-11 05:53:13 +00:00
|
|
|
if (m->mpc_busid >= MAX_MP_BUSSES) {
|
|
|
|
printk(KERN_WARNING "MP table busid value (%d) for bustype %s "
|
2008-04-04 19:42:03 +00:00
|
|
|
" is too large, max. supported is %d\n",
|
|
|
|
m->mpc_busid, str, MAX_MP_BUSSES - 1);
|
2006-04-11 05:53:13 +00:00
|
|
|
return;
|
|
|
|
}
|
2006-09-26 08:52:35 +00:00
|
|
|
#endif
|
2006-04-11 05:53:13 +00:00
|
|
|
|
2008-04-04 19:42:21 +00:00
|
|
|
if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) {
|
|
|
|
set_bit(m->mpc_busid, mp_bus_not_pci);
|
|
|
|
#if defined(CONFIG_EISA) || defined (CONFIG_MCA)
|
|
|
|
mp_bus_id_to_type[m->mpc_busid] = MP_BUS_ISA;
|
|
|
|
#endif
|
|
|
|
} else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) {
|
2008-03-17 19:08:42 +00:00
|
|
|
#ifdef CONFIG_X86_NUMAQ
|
2005-04-16 22:20:36 +00:00
|
|
|
mpc_oem_pci_bus(m, translation_table[mpc_record]);
|
2008-03-17 19:08:42 +00:00
|
|
|
#endif
|
2008-03-20 11:54:09 +00:00
|
|
|
clear_bit(m->mpc_busid, mp_bus_not_pci);
|
2005-04-16 22:20:36 +00:00
|
|
|
mp_bus_id_to_pci_bus[m->mpc_busid] = mp_current_pci_id;
|
|
|
|
mp_current_pci_id++;
|
2008-03-20 11:55:02 +00:00
|
|
|
#if defined(CONFIG_EISA) || defined (CONFIG_MCA)
|
|
|
|
mp_bus_id_to_type[m->mpc_busid] = MP_BUS_PCI;
|
2008-04-04 19:42:03 +00:00
|
|
|
} else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) {
|
2008-03-20 11:54:56 +00:00
|
|
|
mp_bus_id_to_type[m->mpc_busid] = MP_BUS_EISA;
|
2008-04-04 19:42:03 +00:00
|
|
|
} else if (strncmp(str, BUSTYPE_MCA, sizeof(BUSTYPE_MCA) - 1) == 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
mp_bus_id_to_type[m->mpc_busid] = MP_BUS_MCA;
|
2008-03-20 11:55:02 +00:00
|
|
|
#endif
|
2008-04-04 19:42:21 +00:00
|
|
|
} else
|
|
|
|
printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-04 19:41:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
|
|
|
|
2008-03-17 19:08:05 +00:00
|
|
|
static int bad_ioapic(unsigned long address)
|
|
|
|
{
|
|
|
|
if (nr_ioapics >= MAX_IO_APICS) {
|
|
|
|
printk(KERN_ERR "ERROR: Max # of I/O APICs (%d) exceeded "
|
|
|
|
"(found %d)\n", MAX_IO_APICS, nr_ioapics);
|
|
|
|
panic("Recompile kernel with bigger MAX_IO_APICS!\n");
|
|
|
|
}
|
|
|
|
if (!address) {
|
|
|
|
printk(KERN_ERR "WARNING: Bogus (zero) I/O APIC address"
|
|
|
|
" found in table, skipping!\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
static void __init MP_ioapic_info(struct mpc_config_ioapic *m)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (!(m->mpc_flags & MPC_APIC_USABLE))
|
|
|
|
return;
|
|
|
|
|
2008-01-30 12:30:35 +00:00
|
|
|
printk(KERN_INFO "I/O APIC #%d Version %d at 0x%X.\n",
|
2008-04-04 19:42:03 +00:00
|
|
|
m->mpc_apicid, m->mpc_apicver, m->mpc_apicaddr);
|
2008-03-17 19:08:05 +00:00
|
|
|
|
|
|
|
if (bad_ioapic(m->mpc_apicaddr))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
2008-03-17 19:08:05 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
mp_ioapics[nr_ioapics] = *m;
|
|
|
|
nr_ioapics++;
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
static void __init MP_intsrc_info(struct mpc_config_intsrc *m)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:03 +00:00
|
|
|
mp_irqs[mp_irq_entries] = *m;
|
2005-04-16 22:20:36 +00:00
|
|
|
Dprintk("Int: type %d, pol %d, trig %d, bus %d,"
|
|
|
|
" IRQ %02x, APIC ID %x, APIC INT %02x\n",
|
2008-04-04 19:42:03 +00:00
|
|
|
m->mpc_irqtype, m->mpc_irqflag & 3,
|
|
|
|
(m->mpc_irqflag >> 2) & 3, m->mpc_srcbus,
|
|
|
|
m->mpc_srcbusirq, m->mpc_dstapic, m->mpc_dstirq);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (++mp_irq_entries == MAX_IRQ_SOURCES)
|
|
|
|
panic("Max # of irq sources exceeded!!\n");
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:41:07 +00:00
|
|
|
#endif
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
static void __init MP_lintsrc_info(struct mpc_config_lintsrc *m)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
Dprintk("Lint: type %d, pol %d, trig %d, bus %d,"
|
|
|
|
" IRQ %02x, APIC ID %x, APIC LINT %02x\n",
|
2008-04-04 19:42:03 +00:00
|
|
|
m->mpc_irqtype, m->mpc_irqflag & 3,
|
|
|
|
(m->mpc_irqflag >> 2) & 3, m->mpc_srcbusid,
|
|
|
|
m->mpc_srcbusirq, m->mpc_destapic, m->mpc_destapiclint);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_NUMAQ
|
2008-04-04 19:42:03 +00:00
|
|
|
static void __init MP_translation_info(struct mpc_config_translation *m)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:03 +00:00
|
|
|
printk(KERN_INFO
|
|
|
|
"Translation: record %d, type %d, quad %d, global %d, local %d\n",
|
|
|
|
mpc_record, m->trans_type, m->trans_quad, m->trans_global,
|
|
|
|
m->trans_local);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
if (mpc_record >= MAX_MPC_ENTRY)
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_ERR "MAX_MPC_ENTRY exceeded!\n");
|
|
|
|
else
|
2008-04-04 19:42:03 +00:00
|
|
|
translation_table[mpc_record] = m; /* stash this for later */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (m->trans_quad < MAX_NUMNODES && !node_online(m->trans_quad))
|
|
|
|
node_set_online(m->trans_quad);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read/parse the MPC oem tables
|
|
|
|
*/
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
static void __init smp_read_mpc_oem(struct mp_config_oemtable *oemtable,
|
|
|
|
unsigned short oemsize)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:03 +00:00
|
|
|
int count = sizeof(*oemtable); /* the header size */
|
|
|
|
unsigned char *oemptr = ((unsigned char *)oemtable) + count;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
mpc_record = 0;
|
2008-04-04 19:42:03 +00:00
|
|
|
printk(KERN_INFO "Found an OEM MPC table at %8p - parsing it ... \n",
|
|
|
|
oemtable);
|
|
|
|
if (memcmp(oemtable->oem_signature, MPC_OEM_SIGNATURE, 4)) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"SMP mpc oemtable: bad signature [%c%c%c%c]!\n",
|
|
|
|
oemtable->oem_signature[0], oemtable->oem_signature[1],
|
|
|
|
oemtable->oem_signature[2], oemtable->oem_signature[3]);
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
if (mpf_checksum((unsigned char *)oemtable, oemtable->oem_length)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_WARNING "SMP oem mptable: checksum error!\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
while (count < oemtable->oem_length) {
|
|
|
|
switch (*oemptr) {
|
2008-04-04 19:42:03 +00:00
|
|
|
case MP_TRANSLATION:
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:03 +00:00
|
|
|
struct mpc_config_translation *m =
|
|
|
|
(struct mpc_config_translation *)oemptr;
|
2005-04-16 22:20:36 +00:00
|
|
|
MP_translation_info(m);
|
|
|
|
oemptr += sizeof(*m);
|
|
|
|
count += sizeof(*m);
|
|
|
|
++mpc_record;
|
|
|
|
break;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
default:
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:03 +00:00
|
|
|
printk(KERN_WARNING
|
|
|
|
"Unrecognised OEM table entry type! - %d\n",
|
|
|
|
(int)*oemptr);
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void mps_oem_check(struct mp_config_table *mpc, char *oem,
|
2008-04-04 19:42:03 +00:00
|
|
|
char *productid)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (strncmp(oem, "IBM NUMA", 8))
|
|
|
|
printk("Warning! May not be a NUMA-Q system!\n");
|
|
|
|
if (mpc->mpc_oemptr)
|
2008-04-04 19:42:03 +00:00
|
|
|
smp_read_mpc_oem((struct mp_config_oemtable *)mpc->mpc_oemptr,
|
|
|
|
mpc->mpc_oemsize);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
#endif /* CONFIG_X86_NUMAQ */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Read/parse the MPC
|
|
|
|
*/
|
|
|
|
|
2008-04-04 19:42:09 +00:00
|
|
|
static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char str[16];
|
|
|
|
char oem[10];
|
2008-04-04 19:42:03 +00:00
|
|
|
int count = sizeof(*mpc);
|
|
|
|
unsigned char *mpt = ((unsigned char *)mpc) + count;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
if (memcmp(mpc->mpc_signature, MPC_SIGNATURE, 4)) {
|
2008-04-04 19:42:27 +00:00
|
|
|
printk(KERN_ERR "MPTABLE: bad signature [%c%c%c%c]!\n",
|
|
|
|
mpc->mpc_signature[0], mpc->mpc_signature[1],
|
|
|
|
mpc->mpc_signature[2], mpc->mpc_signature[3]);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
if (mpf_checksum((unsigned char *)mpc, mpc->mpc_length)) {
|
2008-04-04 19:42:27 +00:00
|
|
|
printk(KERN_ERR "MPTABLE: checksum error!\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
if (mpc->mpc_spec != 0x01 && mpc->mpc_spec != 0x04) {
|
2008-04-04 19:42:27 +00:00
|
|
|
printk(KERN_ERR "MPTABLE: bad table version (%d)!!\n",
|
2008-04-04 19:42:03 +00:00
|
|
|
mpc->mpc_spec);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!mpc->mpc_lapic) {
|
2008-04-04 19:42:27 +00:00
|
|
|
printk(KERN_ERR "MPTABLE: null local APIC address!\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
memcpy(oem, mpc->mpc_oem, 8);
|
|
|
|
oem[8] = 0;
|
2008-04-04 19:42:27 +00:00
|
|
|
printk(KERN_INFO "MPTABLE: OEM ID: %s ", oem);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
memcpy(str, mpc->mpc_productid, 12);
|
|
|
|
str[12] = 0;
|
|
|
|
printk("Product ID: %s ", str);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:27 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2005-04-16 22:20:36 +00:00
|
|
|
mps_oem_check(mpc, oem, str);
|
2008-04-04 19:42:27 +00:00
|
|
|
#endif
|
|
|
|
printk(KERN_INFO "MPTABLE: Product ID: %s ", str);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:27 +00:00
|
|
|
printk(KERN_INFO "MPTABLE: APIC at: 0x%X\n", mpc->mpc_lapic);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:27 +00:00
|
|
|
/* save the local APIC address, it might be non-default */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!acpi_lapic)
|
|
|
|
mp_lapic_addr = mpc->mpc_lapic;
|
|
|
|
|
2008-04-04 19:42:09 +00:00
|
|
|
if (early)
|
|
|
|
return 1;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2008-04-04 19:42:03 +00:00
|
|
|
* Now process the configuration blocks.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-03-17 19:08:55 +00:00
|
|
|
#ifdef CONFIG_X86_NUMAQ
|
2005-04-16 22:20:36 +00:00
|
|
|
mpc_record = 0;
|
2008-03-17 19:08:55 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
while (count < mpc->mpc_length) {
|
2008-04-04 19:42:03 +00:00
|
|
|
switch (*mpt) {
|
|
|
|
case MP_PROCESSOR:
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:03 +00:00
|
|
|
struct mpc_config_processor *m =
|
|
|
|
(struct mpc_config_processor *)mpt;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* ACPI may have already provided this data */
|
|
|
|
if (!acpi_lapic)
|
|
|
|
MP_processor_info(m);
|
|
|
|
mpt += sizeof(*m);
|
|
|
|
count += sizeof(*m);
|
|
|
|
break;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
case MP_BUS:
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:03 +00:00
|
|
|
struct mpc_config_bus *m =
|
|
|
|
(struct mpc_config_bus *)mpt;
|
2005-04-16 22:20:36 +00:00
|
|
|
MP_bus_info(m);
|
|
|
|
mpt += sizeof(*m);
|
|
|
|
count += sizeof(*m);
|
|
|
|
break;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
case MP_IOAPIC:
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:41:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
2008-04-04 19:42:03 +00:00
|
|
|
struct mpc_config_ioapic *m =
|
|
|
|
(struct mpc_config_ioapic *)mpt;
|
2005-04-16 22:20:36 +00:00
|
|
|
MP_ioapic_info(m);
|
2008-04-04 19:41:07 +00:00
|
|
|
#endif
|
2008-04-04 19:42:03 +00:00
|
|
|
mpt += sizeof(struct mpc_config_ioapic);
|
|
|
|
count += sizeof(struct mpc_config_ioapic);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
case MP_INTSRC:
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:41:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
2008-04-04 19:42:03 +00:00
|
|
|
struct mpc_config_intsrc *m =
|
|
|
|
(struct mpc_config_intsrc *)mpt;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
MP_intsrc_info(m);
|
2008-04-04 19:41:07 +00:00
|
|
|
#endif
|
2008-04-04 19:42:03 +00:00
|
|
|
mpt += sizeof(struct mpc_config_intsrc);
|
|
|
|
count += sizeof(struct mpc_config_intsrc);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
case MP_LINTSRC:
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:03 +00:00
|
|
|
struct mpc_config_lintsrc *m =
|
|
|
|
(struct mpc_config_lintsrc *)mpt;
|
2005-04-16 22:20:36 +00:00
|
|
|
MP_lintsrc_info(m);
|
2008-04-04 19:42:03 +00:00
|
|
|
mpt += sizeof(*m);
|
|
|
|
count += sizeof(*m);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
default:
|
2008-04-07 18:36:39 +00:00
|
|
|
/* wrong mptable */
|
|
|
|
printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n");
|
|
|
|
printk(KERN_ERR "type %x\n", *mpt);
|
|
|
|
print_hex_dump(KERN_ERR, " ", DUMP_PREFIX_ADDRESS, 16,
|
|
|
|
1, mpc, mpc->mpc_length, 1);
|
|
|
|
count = mpc->mpc_length;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-03-17 19:08:55 +00:00
|
|
|
#ifdef CONFIG_X86_NUMAQ
|
2005-04-16 22:20:36 +00:00
|
|
|
++mpc_record;
|
2008-03-17 19:08:55 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-05-02 17:27:04 +00:00
|
|
|
setup_apic_routing();
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!num_processors)
|
2008-04-04 19:42:27 +00:00
|
|
|
printk(KERN_ERR "MPTABLE: no processors registered!\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return num_processors;
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:41:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int __init ELCR_trigger(unsigned int irq)
|
|
|
|
{
|
|
|
|
unsigned int port;
|
|
|
|
|
|
|
|
port = 0x4d0 + (irq >> 3);
|
|
|
|
return (inb(port) >> (irq & 7)) & 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init construct_default_ioirq_mptable(int mpc_default_type)
|
|
|
|
{
|
|
|
|
struct mpc_config_intsrc intsrc;
|
|
|
|
int i;
|
|
|
|
int ELCR_fallback = 0;
|
|
|
|
|
|
|
|
intsrc.mpc_type = MP_INTSRC;
|
2008-04-04 19:42:03 +00:00
|
|
|
intsrc.mpc_irqflag = 0; /* conforming */
|
2005-04-16 22:20:36 +00:00
|
|
|
intsrc.mpc_srcbus = 0;
|
|
|
|
intsrc.mpc_dstapic = mp_ioapics[0].mpc_apicid;
|
|
|
|
|
|
|
|
intsrc.mpc_irqtype = mp_INT;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If true, we have an ISA/PCI system with no IRQ entries
|
|
|
|
* in the MP table. To prevent the PCI interrupts from being set up
|
|
|
|
* incorrectly, we try to use the ELCR. The sanity check to see if
|
|
|
|
* there is good ELCR data is very simple - IRQ0, 1, 2 and 13 can
|
|
|
|
* never be level sensitive, so we simply see if the ELCR agrees.
|
|
|
|
* If it does, we assume it's valid.
|
|
|
|
*/
|
|
|
|
if (mpc_default_type == 5) {
|
2008-04-04 19:42:34 +00:00
|
|
|
printk(KERN_INFO "ISA/PCI bus type with no IRQ information... "
|
|
|
|
"falling back to ELCR\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:34 +00:00
|
|
|
if (ELCR_trigger(0) || ELCR_trigger(1) || ELCR_trigger(2) ||
|
|
|
|
ELCR_trigger(13))
|
|
|
|
printk(KERN_ERR "ELCR contains invalid data... "
|
|
|
|
"not using ELCR\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
else {
|
2008-04-04 19:42:03 +00:00
|
|
|
printk(KERN_INFO
|
|
|
|
"Using ELCR to identify PCI interrupts\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
ELCR_fallback = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
switch (mpc_default_type) {
|
|
|
|
case 2:
|
|
|
|
if (i == 0 || i == 13)
|
|
|
|
continue; /* IRQ0 & IRQ13 not connected */
|
|
|
|
/* fall through */
|
|
|
|
default:
|
|
|
|
if (i == 2)
|
|
|
|
continue; /* IRQ2 is never connected */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ELCR_fallback) {
|
|
|
|
/*
|
|
|
|
* If the ELCR indicates a level-sensitive interrupt, we
|
|
|
|
* copy that information over to the MP table in the
|
|
|
|
* irqflag field (level sensitive, active high polarity).
|
|
|
|
*/
|
|
|
|
if (ELCR_trigger(i))
|
|
|
|
intsrc.mpc_irqflag = 13;
|
|
|
|
else
|
|
|
|
intsrc.mpc_irqflag = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
intsrc.mpc_srcbusirq = i;
|
2008-04-04 19:42:03 +00:00
|
|
|
intsrc.mpc_dstirq = i ? i : 2; /* IRQ0 to INTIN2 */
|
2005-04-16 22:20:36 +00:00
|
|
|
MP_intsrc_info(&intsrc);
|
|
|
|
}
|
|
|
|
|
|
|
|
intsrc.mpc_irqtype = mp_ExtINT;
|
|
|
|
intsrc.mpc_srcbusirq = 0;
|
2008-04-04 19:42:03 +00:00
|
|
|
intsrc.mpc_dstirq = 0; /* 8259A to INTIN0 */
|
2005-04-16 22:20:36 +00:00
|
|
|
MP_intsrc_info(&intsrc);
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:41:07 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline void __init construct_default_ISA_mptable(int mpc_default_type)
|
|
|
|
{
|
|
|
|
struct mpc_config_processor processor;
|
|
|
|
struct mpc_config_bus bus;
|
2008-04-04 19:41:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
2005-04-16 22:20:36 +00:00
|
|
|
struct mpc_config_ioapic ioapic;
|
2008-04-04 19:41:07 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
struct mpc_config_lintsrc lintsrc;
|
|
|
|
int linttypes[2] = { mp_ExtINT, mp_NMI };
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* local APIC has default address
|
|
|
|
*/
|
|
|
|
mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 2 CPUs, numbered 0 & 1.
|
|
|
|
*/
|
|
|
|
processor.mpc_type = MP_PROCESSOR;
|
|
|
|
/* Either an integrated APIC or a discrete 82489DX. */
|
|
|
|
processor.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
|
|
|
|
processor.mpc_cpuflag = CPU_ENABLED;
|
|
|
|
processor.mpc_cpufeature = (boot_cpu_data.x86 << 8) |
|
2008-04-04 19:42:03 +00:00
|
|
|
(boot_cpu_data.x86_model << 4) | boot_cpu_data.x86_mask;
|
2005-04-16 22:20:36 +00:00
|
|
|
processor.mpc_featureflag = boot_cpu_data.x86_capability[0];
|
|
|
|
processor.mpc_reserved[0] = 0;
|
|
|
|
processor.mpc_reserved[1] = 0;
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
processor.mpc_apicid = i;
|
|
|
|
MP_processor_info(&processor);
|
|
|
|
}
|
|
|
|
|
|
|
|
bus.mpc_type = MP_BUS;
|
|
|
|
bus.mpc_busid = 0;
|
|
|
|
switch (mpc_default_type) {
|
2008-04-04 19:42:03 +00:00
|
|
|
default:
|
2008-04-04 19:42:34 +00:00
|
|
|
printk(KERN_ERR "???\nUnknown standard configuration %d\n",
|
2008-04-04 19:42:03 +00:00
|
|
|
mpc_default_type);
|
|
|
|
/* fall through */
|
|
|
|
case 1:
|
|
|
|
case 5:
|
|
|
|
memcpy(bus.mpc_bustype, "ISA ", 6);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
case 6:
|
|
|
|
case 3:
|
|
|
|
memcpy(bus.mpc_bustype, "EISA ", 6);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
case 7:
|
|
|
|
memcpy(bus.mpc_bustype, "MCA ", 6);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
MP_bus_info(&bus);
|
|
|
|
if (mpc_default_type > 4) {
|
|
|
|
bus.mpc_busid = 1;
|
|
|
|
memcpy(bus.mpc_bustype, "PCI ", 6);
|
|
|
|
MP_bus_info(&bus);
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:41:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
2005-04-16 22:20:36 +00:00
|
|
|
ioapic.mpc_type = MP_IOAPIC;
|
|
|
|
ioapic.mpc_apicid = 2;
|
|
|
|
ioapic.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
|
|
|
|
ioapic.mpc_flags = MPC_APIC_USABLE;
|
|
|
|
ioapic.mpc_apicaddr = 0xFEC00000;
|
|
|
|
MP_ioapic_info(&ioapic);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We set up most of the low 16 IO-APIC pins according to MPS rules.
|
|
|
|
*/
|
|
|
|
construct_default_ioirq_mptable(mpc_default_type);
|
2008-04-04 19:41:07 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
lintsrc.mpc_type = MP_LINTSRC;
|
2008-04-04 19:42:03 +00:00
|
|
|
lintsrc.mpc_irqflag = 0; /* conforming */
|
2005-04-16 22:20:36 +00:00
|
|
|
lintsrc.mpc_srcbusid = 0;
|
|
|
|
lintsrc.mpc_srcbusirq = 0;
|
|
|
|
lintsrc.mpc_destapic = MP_APIC_ALL;
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
lintsrc.mpc_irqtype = linttypes[i];
|
|
|
|
lintsrc.mpc_destapiclint = i;
|
|
|
|
MP_lintsrc_info(&lintsrc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct intel_mp_floating *mpf_found;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan the memory blocks for an SMP configuration block.
|
|
|
|
*/
|
2008-04-04 19:42:09 +00:00
|
|
|
static void __init __get_smp_config(unsigned early)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct intel_mp_floating *mpf = mpf_found;
|
|
|
|
|
2008-04-04 19:42:09 +00:00
|
|
|
if (acpi_lapic && early)
|
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2008-04-04 19:42:03 +00:00
|
|
|
* ACPI supports both logical (e.g. Hyper-Threading) and physical
|
2005-04-16 22:20:36 +00:00
|
|
|
* processors, where MPS only supports physical.
|
|
|
|
*/
|
|
|
|
if (acpi_lapic && acpi_ioapic) {
|
2008-04-04 19:42:40 +00:00
|
|
|
printk(KERN_INFO "Using ACPI (MADT) for SMP configuration "
|
|
|
|
"information\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
2008-04-04 19:42:03 +00:00
|
|
|
} else if (acpi_lapic)
|
2008-04-04 19:42:40 +00:00
|
|
|
printk(KERN_INFO "Using ACPI for processor (LAPIC) "
|
|
|
|
"configuration information\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
printk(KERN_INFO "Intel MultiProcessor Specification v1.%d\n",
|
|
|
|
mpf->mpf_specification);
|
2008-04-04 19:42:40 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-04-04 19:42:03 +00:00
|
|
|
if (mpf->mpf_feature2 & (1 << 7)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_INFO " IMCR and PIC compatibility mode.\n");
|
|
|
|
pic_mode = 1;
|
|
|
|
} else {
|
|
|
|
printk(KERN_INFO " Virtual Wire compatibility mode.\n");
|
|
|
|
pic_mode = 0;
|
|
|
|
}
|
2008-04-04 19:42:40 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Now see if we need to read further.
|
|
|
|
*/
|
|
|
|
if (mpf->mpf_feature1 != 0) {
|
2008-04-04 19:42:09 +00:00
|
|
|
if (early) {
|
|
|
|
/*
|
|
|
|
* local APIC has default address
|
|
|
|
*/
|
|
|
|
mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
|
|
|
|
return;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
printk(KERN_INFO "Default MP configuration #%d\n",
|
|
|
|
mpf->mpf_feature1);
|
2005-04-16 22:20:36 +00:00
|
|
|
construct_default_ISA_mptable(mpf->mpf_feature1);
|
|
|
|
|
|
|
|
} else if (mpf->mpf_physptr) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the physical hardware table. Anything here will
|
|
|
|
* override the defaults.
|
|
|
|
*/
|
2008-04-04 19:42:09 +00:00
|
|
|
if (!smp_read_mpc(phys_to_virt(mpf->mpf_physptr), early)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
smp_found_config = 0;
|
2008-04-04 19:42:03 +00:00
|
|
|
printk(KERN_ERR
|
|
|
|
"BIOS bug, MP table errors detected!...\n");
|
2008-04-04 19:42:40 +00:00
|
|
|
printk(KERN_ERR "... disabling SMP support. "
|
|
|
|
"(tell your hw vendor)\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-04-04 19:41:07 +00:00
|
|
|
|
2008-04-04 19:42:09 +00:00
|
|
|
if (early)
|
|
|
|
return;
|
2008-04-04 19:41:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* If there are no explicit MP IRQ entries, then we are
|
|
|
|
* broken. We set up most of the low 16 IO-APIC pins to
|
|
|
|
* ISA defaults and hope it will work.
|
|
|
|
*/
|
|
|
|
if (!mp_irq_entries) {
|
|
|
|
struct mpc_config_bus bus;
|
|
|
|
|
2008-04-04 19:42:40 +00:00
|
|
|
printk(KERN_ERR "BIOS bug, no explicit IRQ entries, "
|
|
|
|
"using default mptable. "
|
|
|
|
"(tell your hw vendor)\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
bus.mpc_type = MP_BUS;
|
|
|
|
bus.mpc_busid = 0;
|
|
|
|
memcpy(bus.mpc_bustype, "ISA ", 6);
|
|
|
|
MP_bus_info(&bus);
|
|
|
|
|
|
|
|
construct_default_ioirq_mptable(0);
|
|
|
|
}
|
2008-04-04 19:41:07 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
} else
|
|
|
|
BUG();
|
|
|
|
|
2008-04-04 19:42:09 +00:00
|
|
|
if (!early)
|
|
|
|
printk(KERN_INFO "Processors: %d\n", num_processors);
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Only use the first configuration found.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:09 +00:00
|
|
|
void __init early_get_smp_config(void)
|
|
|
|
{
|
|
|
|
__get_smp_config(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init get_smp_config(void)
|
|
|
|
{
|
|
|
|
__get_smp_config(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init smp_scan_config(unsigned long base, unsigned long length,
|
|
|
|
unsigned reserve)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-04 19:42:46 +00:00
|
|
|
extern void __bad_mpf_size(void);
|
|
|
|
unsigned int *bp = phys_to_virt(base);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct intel_mp_floating *mpf;
|
|
|
|
|
2008-04-04 19:42:46 +00:00
|
|
|
Dprintk("Scan SMP from %p for %ld bytes.\n", bp, length);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sizeof(*mpf) != 16)
|
2008-04-04 19:42:46 +00:00
|
|
|
__bad_mpf_size();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
while (length > 0) {
|
|
|
|
mpf = (struct intel_mp_floating *)bp;
|
|
|
|
if ((*bp == SMP_MAGIC_IDENT) &&
|
2008-04-04 19:42:03 +00:00
|
|
|
(mpf->mpf_length == 1) &&
|
|
|
|
!mpf_checksum((unsigned char *)bp, 16) &&
|
|
|
|
((mpf->mpf_specification == 1)
|
|
|
|
|| (mpf->mpf_specification == 4))) {
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
smp_found_config = 1;
|
2008-04-04 19:42:46 +00:00
|
|
|
mpf_found = mpf;
|
|
|
|
#ifdef CONFIG_X86_32
|
2008-01-30 12:33:08 +00:00
|
|
|
printk(KERN_INFO "found SMP MP-table at [%p] %08lx\n",
|
2008-04-04 19:42:03 +00:00
|
|
|
mpf, virt_to_phys(mpf));
|
2008-02-07 08:15:17 +00:00
|
|
|
reserve_bootmem(virt_to_phys(mpf), PAGE_SIZE,
|
|
|
|
BOOTMEM_DEFAULT);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (mpf->mpf_physptr) {
|
|
|
|
/*
|
|
|
|
* We cannot access to MPC table to compute
|
|
|
|
* table size yet, as only few megabytes from
|
|
|
|
* the bottom is mapped now.
|
|
|
|
* PC-9800's MPC table places on the very last
|
|
|
|
* of physical memory; so that simply reserving
|
|
|
|
* PAGE_SIZE from mpg->mpf_physptr yields BUG()
|
|
|
|
* in reserve_bootmem.
|
|
|
|
*/
|
|
|
|
unsigned long size = PAGE_SIZE;
|
|
|
|
unsigned long end = max_low_pfn * PAGE_SIZE;
|
|
|
|
if (mpf->mpf_physptr + size > end)
|
|
|
|
size = end - mpf->mpf_physptr;
|
2008-02-07 08:15:17 +00:00
|
|
|
reserve_bootmem(mpf->mpf_physptr, size,
|
|
|
|
BOOTMEM_DEFAULT);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:46 +00:00
|
|
|
#else
|
|
|
|
if (!reserve)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
reserve_bootmem_generic(virt_to_phys(mpf), PAGE_SIZE);
|
|
|
|
if (mpf->mpf_physptr)
|
|
|
|
reserve_bootmem_generic(mpf->mpf_physptr,
|
|
|
|
PAGE_SIZE);
|
|
|
|
#endif
|
|
|
|
return 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
bp += 4;
|
|
|
|
length -= 16;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:09 +00:00
|
|
|
static void __init __find_smp_config(unsigned reserve)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned int address;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: Linux assumes you have 640K of base ram..
|
|
|
|
* this continues the error...
|
|
|
|
*
|
|
|
|
* 1) Scan the bottom 1K for a signature
|
|
|
|
* 2) Scan the top 1K of base RAM
|
|
|
|
* 3) Scan the 64K of bios
|
|
|
|
*/
|
2008-04-04 19:42:09 +00:00
|
|
|
if (smp_scan_config(0x0, 0x400, reserve) ||
|
|
|
|
smp_scan_config(639 * 0x400, 0x400, reserve) ||
|
|
|
|
smp_scan_config(0xF0000, 0x10000, reserve))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* If it is an SMP machine we should know now, unless the
|
|
|
|
* configuration is in an EISA/MCA bus machine with an
|
|
|
|
* extended bios data area.
|
|
|
|
*
|
|
|
|
* there is a real-mode segmented pointer pointing to the
|
|
|
|
* 4K EBDA area at 0x40E, calculate and scan it here.
|
|
|
|
*
|
|
|
|
* NOTE! There are Linux loaders that will corrupt the EBDA
|
|
|
|
* area, and as such this kind of SMP config may be less
|
|
|
|
* trustworthy, simply because the SMP table may have been
|
|
|
|
* stomped on during early boot. These loaders are buggy and
|
|
|
|
* should be fixed.
|
|
|
|
*
|
|
|
|
* MP1.4 SPEC states to only scan first 1K of 4K EBDA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
address = get_bios_ebda();
|
|
|
|
if (address)
|
2008-04-04 19:42:09 +00:00
|
|
|
smp_scan_config(address, 0x400, reserve);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init early_find_smp_config(void)
|
|
|
|
{
|
|
|
|
__find_smp_config(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init find_smp_config(void)
|
|
|
|
{
|
|
|
|
__find_smp_config(1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
ACPI-based MP Configuration
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-24 16:07:20 +00:00
|
|
|
#ifdef CONFIG_ACPI
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-08-24 16:09:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define MP_ISA_BUS 0
|
|
|
|
#define MP_MAX_IOAPIC_PIN 127
|
|
|
|
|
2008-04-04 19:41:26 +00:00
|
|
|
extern struct mp_ioapic_routing mp_ioapic_routing[MAX_IO_APICS];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
static int mp_find_ioapic(int gsi)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-09-26 08:52:30 +00:00
|
|
|
int i = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Find the IOAPIC that manages this GSI. */
|
|
|
|
for (i = 0; i < nr_ioapics; i++) {
|
|
|
|
if ((gsi >= mp_ioapic_routing[i].gsi_base)
|
2008-04-04 19:42:03 +00:00
|
|
|
&& (gsi <= mp_ioapic_routing[i].gsi_end))
|
2005-04-16 22:20:36 +00:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_ERR "ERROR: Unable to locate IOAPIC for GSI %d\n", gsi);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-03-17 19:08:11 +00:00
|
|
|
static u8 uniq_ioapic_id(u8 id)
|
|
|
|
{
|
2008-04-04 19:42:53 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-03-17 19:08:11 +00:00
|
|
|
if ((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) &&
|
|
|
|
!APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
|
|
|
|
return io_apic_get_unique_id(nr_ioapics, id);
|
|
|
|
else
|
|
|
|
return id;
|
2008-04-04 19:42:53 +00:00
|
|
|
#else
|
|
|
|
int i;
|
|
|
|
DECLARE_BITMAP(used, 256);
|
|
|
|
bitmap_zero(used, 256);
|
|
|
|
for (i = 0; i < nr_ioapics; i++) {
|
|
|
|
struct mpc_config_ioapic *ia = &mp_ioapics[i];
|
|
|
|
__set_bit(ia->mpc_apicid, used);
|
|
|
|
}
|
|
|
|
if (!test_bit(id, used))
|
|
|
|
return id;
|
|
|
|
return find_first_zero_bit(used, 256);
|
|
|
|
#endif
|
2008-03-17 19:08:11 +00:00
|
|
|
}
|
|
|
|
|
2008-03-28 19:12:08 +00:00
|
|
|
void __init mp_register_ioapic(int id, u32 address, u32 gsi_base)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-09-26 08:52:30 +00:00
|
|
|
int idx = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-17 19:08:05 +00:00
|
|
|
if (bad_ioapic(address))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
2008-03-17 19:08:11 +00:00
|
|
|
idx = nr_ioapics;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
mp_ioapics[idx].mpc_type = MP_IOAPIC;
|
|
|
|
mp_ioapics[idx].mpc_flags = MPC_APIC_USABLE;
|
|
|
|
mp_ioapics[idx].mpc_apicaddr = address;
|
|
|
|
|
|
|
|
set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address);
|
2008-03-17 19:08:11 +00:00
|
|
|
mp_ioapics[idx].mpc_apicid = uniq_ioapic_id(id);
|
2008-04-04 19:43:00 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2005-04-16 22:20:36 +00:00
|
|
|
mp_ioapics[idx].mpc_apicver = io_apic_get_version(idx);
|
2008-04-04 19:43:00 +00:00
|
|
|
#else
|
|
|
|
mp_ioapics[idx].mpc_apicver = 0;
|
|
|
|
#endif
|
2008-04-04 19:42:03 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Build basic GSI lookup table to facilitate gsi->io_apic lookups
|
|
|
|
* and to prevent reprogramming of IOAPIC pins (PCI GSIs).
|
|
|
|
*/
|
|
|
|
mp_ioapic_routing[idx].apic_id = mp_ioapics[idx].mpc_apicid;
|
|
|
|
mp_ioapic_routing[idx].gsi_base = gsi_base;
|
2008-01-30 12:30:35 +00:00
|
|
|
mp_ioapic_routing[idx].gsi_end = gsi_base +
|
2008-04-04 19:42:03 +00:00
|
|
|
io_apic_get_redir_entries(idx);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:43:00 +00:00
|
|
|
printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%x, "
|
2008-01-30 12:30:35 +00:00
|
|
|
"GSI %d-%d\n", idx, mp_ioapics[idx].mpc_apicid,
|
2008-04-04 19:43:00 +00:00
|
|
|
mp_ioapics[idx].mpc_apicver, mp_ioapics[idx].mpc_apicaddr,
|
2008-04-04 19:42:03 +00:00
|
|
|
mp_ioapic_routing[idx].gsi_base, mp_ioapic_routing[idx].gsi_end);
|
2008-03-17 19:08:11 +00:00
|
|
|
|
|
|
|
nr_ioapics++;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
void __init mp_override_legacy_irq(u8 bus_irq, u8 polarity, u8 trigger, u32 gsi)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct mpc_config_intsrc intsrc;
|
2008-04-04 19:42:03 +00:00
|
|
|
int ioapic = -1;
|
|
|
|
int pin = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Convert 'gsi' to 'ioapic.pin'.
|
|
|
|
*/
|
|
|
|
ioapic = mp_find_ioapic(gsi);
|
|
|
|
if (ioapic < 0)
|
|
|
|
return;
|
|
|
|
pin = gsi - mp_ioapic_routing[ioapic].gsi_base;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TBD: This check is for faulty timer entries, where the override
|
2008-04-04 19:42:03 +00:00
|
|
|
* erroneously sets the trigger to level, resulting in a HUGE
|
2005-04-16 22:20:36 +00:00
|
|
|
* increase of timer interrupts!
|
|
|
|
*/
|
|
|
|
if ((bus_irq == 0) && (trigger == 3))
|
|
|
|
trigger = 1;
|
|
|
|
|
|
|
|
intsrc.mpc_type = MP_INTSRC;
|
|
|
|
intsrc.mpc_irqtype = mp_INT;
|
|
|
|
intsrc.mpc_irqflag = (trigger << 2) | polarity;
|
|
|
|
intsrc.mpc_srcbus = MP_ISA_BUS;
|
2008-04-04 19:42:03 +00:00
|
|
|
intsrc.mpc_srcbusirq = bus_irq; /* IRQ */
|
|
|
|
intsrc.mpc_dstapic = mp_ioapics[ioapic].mpc_apicid; /* APIC ID */
|
|
|
|
intsrc.mpc_dstirq = pin; /* INTIN# */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
Dprintk("Int: type %d, pol %d, trig %d, bus %d, irq %d, %d-%d\n",
|
2008-04-04 19:42:03 +00:00
|
|
|
intsrc.mpc_irqtype, intsrc.mpc_irqflag & 3,
|
|
|
|
(intsrc.mpc_irqflag >> 2) & 3, intsrc.mpc_srcbus,
|
2005-04-16 22:20:36 +00:00
|
|
|
intsrc.mpc_srcbusirq, intsrc.mpc_dstapic, intsrc.mpc_dstirq);
|
|
|
|
|
|
|
|
mp_irqs[mp_irq_entries] = intsrc;
|
|
|
|
if (++mp_irq_entries == MAX_IRQ_SOURCES)
|
|
|
|
panic("Max # of irq sources exceeded!\n");
|
|
|
|
}
|
|
|
|
|
2008-03-27 20:53:54 +00:00
|
|
|
int es7000_plat;
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
void __init mp_config_acpi_legacy_irqs(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct mpc_config_intsrc intsrc;
|
2006-09-26 08:52:30 +00:00
|
|
|
int i = 0;
|
|
|
|
int ioapic = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-20 11:55:02 +00:00
|
|
|
#if defined (CONFIG_MCA) || defined (CONFIG_EISA)
|
2008-04-04 19:42:03 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Fabricate the legacy ISA bus (bus #31).
|
|
|
|
*/
|
|
|
|
mp_bus_id_to_type[MP_ISA_BUS] = MP_BUS_ISA;
|
2008-03-20 11:55:02 +00:00
|
|
|
#endif
|
2008-03-20 11:54:09 +00:00
|
|
|
set_bit(MP_ISA_BUS, mp_bus_not_pci);
|
2005-04-16 22:20:36 +00:00
|
|
|
Dprintk("Bus #%d is ISA\n", MP_ISA_BUS);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Older generations of ES7000 have no legacy identity mappings
|
|
|
|
*/
|
|
|
|
if (es7000_plat == 1)
|
|
|
|
return;
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
/*
|
|
|
|
* Locate the IOAPIC that manages the ISA IRQs (0-15).
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
ioapic = mp_find_ioapic(0);
|
|
|
|
if (ioapic < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
intsrc.mpc_type = MP_INTSRC;
|
2008-04-04 19:42:03 +00:00
|
|
|
intsrc.mpc_irqflag = 0; /* Conforming */
|
2005-04-16 22:20:36 +00:00
|
|
|
intsrc.mpc_srcbus = MP_ISA_BUS;
|
2008-04-04 19:41:07 +00:00
|
|
|
#ifdef CONFIG_X86_IO_APIC
|
2005-04-16 22:20:36 +00:00
|
|
|
intsrc.mpc_dstapic = mp_ioapics[ioapic].mpc_apicid;
|
2008-04-04 19:41:07 +00:00
|
|
|
#endif
|
2008-04-04 19:42:03 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Use the default configuration for the IRQs 0-15. Unless
|
2007-10-19 23:13:56 +00:00
|
|
|
* overridden by (MADT) interrupt source override entries.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
for (idx = 0; idx < mp_irq_entries; idx++) {
|
|
|
|
struct mpc_config_intsrc *irq = mp_irqs + idx;
|
|
|
|
|
|
|
|
/* Do we already have a mapping for this ISA IRQ? */
|
2008-04-04 19:42:03 +00:00
|
|
|
if (irq->mpc_srcbus == MP_ISA_BUS
|
|
|
|
&& irq->mpc_srcbusirq == i)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Do we already have a mapping for this IOAPIC pin */
|
|
|
|
if ((irq->mpc_dstapic == intsrc.mpc_dstapic) &&
|
2008-04-04 19:42:03 +00:00
|
|
|
(irq->mpc_dstirq == i))
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (idx != mp_irq_entries) {
|
|
|
|
printk(KERN_DEBUG "ACPI: IRQ%d used by override.\n", i);
|
2008-04-04 19:42:03 +00:00
|
|
|
continue; /* IRQ already used */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
intsrc.mpc_irqtype = mp_INT;
|
2008-04-04 19:42:03 +00:00
|
|
|
intsrc.mpc_srcbusirq = i; /* Identity mapped */
|
2005-04-16 22:20:36 +00:00
|
|
|
intsrc.mpc_dstirq = i;
|
|
|
|
|
|
|
|
Dprintk("Int: type %d, pol %d, trig %d, bus %d, irq %d, "
|
2008-04-04 19:42:03 +00:00
|
|
|
"%d-%d\n", intsrc.mpc_irqtype, intsrc.mpc_irqflag & 3,
|
|
|
|
(intsrc.mpc_irqflag >> 2) & 3, intsrc.mpc_srcbus,
|
|
|
|
intsrc.mpc_srcbusirq, intsrc.mpc_dstapic,
|
2005-04-16 22:20:36 +00:00
|
|
|
intsrc.mpc_dstirq);
|
|
|
|
|
|
|
|
mp_irqs[mp_irq_entries] = intsrc;
|
|
|
|
if (++mp_irq_entries == MAX_IRQ_SOURCES)
|
|
|
|
panic("Max # of irq sources exceeded!\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-26 08:52:30 +00:00
|
|
|
int mp_register_gsi(u32 gsi, int triggering, int polarity)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-09-26 08:52:30 +00:00
|
|
|
int ioapic = -1;
|
|
|
|
int ioapic_pin = 0;
|
|
|
|
int idx, bit = 0;
|
2008-04-04 19:43:12 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
#define MAX_GSI_NUM 4096
|
|
|
|
#define IRQ_COMPRESSION_START 64
|
|
|
|
|
x86: 32-bit IOAPIC: de-fang IRQ compression
commit c434b7a6aedfe428ad17cd61b21b125a7b7a29ce
(x86: avoid wasting IRQs for PCI devices)
created a concept of "IRQ compression" on i386
to conserve IRQ numbers on systems with many
sparsely populated IO APICs.
The same scheme was also added to x86_64,
but later removed when x86_64 recieved an IRQ over-haul
that made it unnecessary -- including per-CPU
IRQ vectors that greatly increased the IRQ capacity
on the machine.
i386 has not received the analogous over-haul,
and thus a previous attempt to delete IRQ compression
from i386 was rejected on the theory that there may
exist machines that actually need it. The fact is
that the author of IRQ compression patch was unable
to confirm the actual existence of such a system.
As a result, all i386 kernels with IOAPIC support
pay the following:
1. confusion
IRQ compression re-names the traditional IOAPIC
pin numbers (aka ACPI GSI's) into sequential IRQ #s:
ACPI: PCI Interrupt 0000:00:1c.0[A] -> GSI 20 (level, low) -> IRQ 16
ACPI: PCI Interrupt 0000:00:1c.1[B] -> GSI 21 (level, low) -> IRQ 17
ACPI: PCI Interrupt 0000:00:1c.2[C] -> GSI 22 (level, low) -> IRQ 18
ACPI: PCI Interrupt 0000:00:1c.3[D] -> GSI 23 (level, low) -> IRQ 19
ACPI: PCI Interrupt 0000:00:1c.4[A] -> GSI 20 (level, low) -> IRQ 16
This makes /proc/interrupts look different
depending on system configuration and device probe order.
It is also different than the x86_64 kernel running
on the exact same system. As a result, programmers
get confused when comparing systems.
2. complexity
The IRQ code in Linux is already overly complex,
and IRQ compression makes it worse. There have
already been two bug workarounds related to IRQ
compression -- the IRQ0 timer workaround and
the VIA PCI IRQ workaround.
3. size
All i386 kernels with IOAPIC support contain an int[4096] --
a 4 page array to contain the renamed IRQs.
So while the irq compression code on i386 should really
be deleted -- even before merging the x86_64 irq-overhaul,
this patch simply disables it on all high volume systems
to avoid problems #1 and #2 on most all i386 systems.
A large system with pin numbers >=64 will still have compression
to conserve limited IRQ numbers for sparse IOAPICS. However,
the vast majority of the planet, those with only pin numbers < 64
will use an identity GSI -> IRQ mapping.
Signed-off-by: Len Brown <len.brown@intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: "Eric W. Biederman" <ebiederm@xmission.com>
2008-01-30 12:31:02 +00:00
|
|
|
static int pci_irq = IRQ_COMPRESSION_START;
|
[PATCH] x86: avoid wasting IRQs for PCI devices
I have submitted the patch for x86_64, this is submission for i386.
The patch changes the way IRQs are handed out to PCI devices. Currently,
each I/O APIC pin gets associated with an IRQ, no matter if the pin is used
or not. This imposes severe limitation on systems that have designs that
employ many I/O APICs, only utilizing couple lines of each, such as P64H2
chipset. It is used in ES7000, and currently, there is no way to boot the
system with more that 9 I/O APICs.
The simple change below allows to boot a system with say 64 (or more) I/O
APICs, each providing 1 slot, which otherwise impossible because of the IRQ
gaps created for unused lines on each I/O APIC. It does not resolve the
problem with number of devices that exceeds number of possible IRQs, but
eases up a tension for IRQs on any large system with potentually large
number of devices.
Signed-off-by: Natalie Protasevich <Natalie.Protasevich@unisys.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:08:29 +00:00
|
|
|
/*
|
2008-01-30 12:31:42 +00:00
|
|
|
* Mapping between Global System Interrupts, which
|
[PATCH] x86: avoid wasting IRQs for PCI devices
I have submitted the patch for x86_64, this is submission for i386.
The patch changes the way IRQs are handed out to PCI devices. Currently,
each I/O APIC pin gets associated with an IRQ, no matter if the pin is used
or not. This imposes severe limitation on systems that have designs that
employ many I/O APICs, only utilizing couple lines of each, such as P64H2
chipset. It is used in ES7000, and currently, there is no way to boot the
system with more that 9 I/O APICs.
The simple change below allows to boot a system with say 64 (or more) I/O
APICs, each providing 1 slot, which otherwise impossible because of the IRQ
gaps created for unused lines on each I/O APIC. It does not resolve the
problem with number of devices that exceeds number of possible IRQs, but
eases up a tension for IRQs on any large system with potentually large
number of devices.
Signed-off-by: Natalie Protasevich <Natalie.Protasevich@unisys.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:08:29 +00:00
|
|
|
* represent all possible interrupts, and IRQs
|
|
|
|
* assigned to actual devices.
|
|
|
|
*/
|
2008-04-04 19:42:03 +00:00
|
|
|
static int gsi_to_irq[MAX_GSI_NUM];
|
2008-04-04 19:43:12 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
if (acpi_irq_model != ACPI_IRQ_MODEL_IOAPIC)
|
|
|
|
return gsi;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Don't set up the ACPI SCI because it's already set up */
|
2007-02-02 16:48:22 +00:00
|
|
|
if (acpi_gbl_FADT.sci_interrupt == gsi)
|
2005-04-16 22:20:36 +00:00
|
|
|
return gsi;
|
|
|
|
|
|
|
|
ioapic = mp_find_ioapic(gsi);
|
|
|
|
if (ioapic < 0) {
|
|
|
|
printk(KERN_WARNING "No IOAPIC for GSI %u\n", gsi);
|
|
|
|
return gsi;
|
|
|
|
}
|
|
|
|
|
|
|
|
ioapic_pin = gsi - mp_ioapic_routing[ioapic].gsi_base;
|
|
|
|
|
2008-04-04 19:43:12 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ioapic_renumber_irq)
|
|
|
|
gsi = ioapic_renumber_irq(ioapic, gsi);
|
2008-04-04 19:43:12 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
/*
|
|
|
|
* Avoid pin reprogramming. PRTs typically include entries
|
2005-04-16 22:20:36 +00:00
|
|
|
* with redundant pin->gsi mappings (but unique PCI devices);
|
|
|
|
* we only program the IOAPIC on the first.
|
|
|
|
*/
|
|
|
|
bit = ioapic_pin % 32;
|
|
|
|
idx = (ioapic_pin < 32) ? 0 : (ioapic_pin / 32);
|
|
|
|
if (idx > 3) {
|
|
|
|
printk(KERN_ERR "Invalid reference to IOAPIC pin "
|
2008-04-04 19:42:03 +00:00
|
|
|
"%d-%d\n", mp_ioapic_routing[ioapic].apic_id,
|
|
|
|
ioapic_pin);
|
2005-04-16 22:20:36 +00:00
|
|
|
return gsi;
|
|
|
|
}
|
2008-04-04 19:42:03 +00:00
|
|
|
if ((1 << bit) & mp_ioapic_routing[ioapic].pin_programmed[idx]) {
|
2005-04-16 22:20:36 +00:00
|
|
|
Dprintk(KERN_DEBUG "Pin %d-%d already programmed\n",
|
|
|
|
mp_ioapic_routing[ioapic].apic_id, ioapic_pin);
|
2008-04-04 19:43:12 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
x86: 32-bit IOAPIC: de-fang IRQ compression
commit c434b7a6aedfe428ad17cd61b21b125a7b7a29ce
(x86: avoid wasting IRQs for PCI devices)
created a concept of "IRQ compression" on i386
to conserve IRQ numbers on systems with many
sparsely populated IO APICs.
The same scheme was also added to x86_64,
but later removed when x86_64 recieved an IRQ over-haul
that made it unnecessary -- including per-CPU
IRQ vectors that greatly increased the IRQ capacity
on the machine.
i386 has not received the analogous over-haul,
and thus a previous attempt to delete IRQ compression
from i386 was rejected on the theory that there may
exist machines that actually need it. The fact is
that the author of IRQ compression patch was unable
to confirm the actual existence of such a system.
As a result, all i386 kernels with IOAPIC support
pay the following:
1. confusion
IRQ compression re-names the traditional IOAPIC
pin numbers (aka ACPI GSI's) into sequential IRQ #s:
ACPI: PCI Interrupt 0000:00:1c.0[A] -> GSI 20 (level, low) -> IRQ 16
ACPI: PCI Interrupt 0000:00:1c.1[B] -> GSI 21 (level, low) -> IRQ 17
ACPI: PCI Interrupt 0000:00:1c.2[C] -> GSI 22 (level, low) -> IRQ 18
ACPI: PCI Interrupt 0000:00:1c.3[D] -> GSI 23 (level, low) -> IRQ 19
ACPI: PCI Interrupt 0000:00:1c.4[A] -> GSI 20 (level, low) -> IRQ 16
This makes /proc/interrupts look different
depending on system configuration and device probe order.
It is also different than the x86_64 kernel running
on the exact same system. As a result, programmers
get confused when comparing systems.
2. complexity
The IRQ code in Linux is already overly complex,
and IRQ compression makes it worse. There have
already been two bug workarounds related to IRQ
compression -- the IRQ0 timer workaround and
the VIA PCI IRQ workaround.
3. size
All i386 kernels with IOAPIC support contain an int[4096] --
a 4 page array to contain the renamed IRQs.
So while the irq compression code on i386 should really
be deleted -- even before merging the x86_64 irq-overhaul,
this patch simply disables it on all high volume systems
to avoid problems #1 and #2 on most all i386 systems.
A large system with pin numbers >=64 will still have compression
to conserve limited IRQ numbers for sparse IOAPICS. However,
the vast majority of the planet, those with only pin numbers < 64
will use an identity GSI -> IRQ mapping.
Signed-off-by: Len Brown <len.brown@intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: "Eric W. Biederman" <ebiederm@xmission.com>
2008-01-30 12:31:02 +00:00
|
|
|
return (gsi < IRQ_COMPRESSION_START ? gsi : gsi_to_irq[gsi]);
|
2008-04-04 19:43:12 +00:00
|
|
|
#else
|
|
|
|
return gsi;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-04 19:42:03 +00:00
|
|
|
mp_ioapic_routing[ioapic].pin_programmed[idx] |= (1 << bit);
|
2008-04-04 19:43:12 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
x86: 32-bit IOAPIC: de-fang IRQ compression
commit c434b7a6aedfe428ad17cd61b21b125a7b7a29ce
(x86: avoid wasting IRQs for PCI devices)
created a concept of "IRQ compression" on i386
to conserve IRQ numbers on systems with many
sparsely populated IO APICs.
The same scheme was also added to x86_64,
but later removed when x86_64 recieved an IRQ over-haul
that made it unnecessary -- including per-CPU
IRQ vectors that greatly increased the IRQ capacity
on the machine.
i386 has not received the analogous over-haul,
and thus a previous attempt to delete IRQ compression
from i386 was rejected on the theory that there may
exist machines that actually need it. The fact is
that the author of IRQ compression patch was unable
to confirm the actual existence of such a system.
As a result, all i386 kernels with IOAPIC support
pay the following:
1. confusion
IRQ compression re-names the traditional IOAPIC
pin numbers (aka ACPI GSI's) into sequential IRQ #s:
ACPI: PCI Interrupt 0000:00:1c.0[A] -> GSI 20 (level, low) -> IRQ 16
ACPI: PCI Interrupt 0000:00:1c.1[B] -> GSI 21 (level, low) -> IRQ 17
ACPI: PCI Interrupt 0000:00:1c.2[C] -> GSI 22 (level, low) -> IRQ 18
ACPI: PCI Interrupt 0000:00:1c.3[D] -> GSI 23 (level, low) -> IRQ 19
ACPI: PCI Interrupt 0000:00:1c.4[A] -> GSI 20 (level, low) -> IRQ 16
This makes /proc/interrupts look different
depending on system configuration and device probe order.
It is also different than the x86_64 kernel running
on the exact same system. As a result, programmers
get confused when comparing systems.
2. complexity
The IRQ code in Linux is already overly complex,
and IRQ compression makes it worse. There have
already been two bug workarounds related to IRQ
compression -- the IRQ0 timer workaround and
the VIA PCI IRQ workaround.
3. size
All i386 kernels with IOAPIC support contain an int[4096] --
a 4 page array to contain the renamed IRQs.
So while the irq compression code on i386 should really
be deleted -- even before merging the x86_64 irq-overhaul,
this patch simply disables it on all high volume systems
to avoid problems #1 and #2 on most all i386 systems.
A large system with pin numbers >=64 will still have compression
to conserve limited IRQ numbers for sparse IOAPICS. However,
the vast majority of the planet, those with only pin numbers < 64
will use an identity GSI -> IRQ mapping.
Signed-off-by: Len Brown <len.brown@intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: "Eric W. Biederman" <ebiederm@xmission.com>
2008-01-30 12:31:02 +00:00
|
|
|
/*
|
|
|
|
* For GSI >= 64, use IRQ compression
|
|
|
|
*/
|
|
|
|
if ((gsi >= IRQ_COMPRESSION_START)
|
2008-04-04 19:42:03 +00:00
|
|
|
&& (triggering == ACPI_LEVEL_SENSITIVE)) {
|
[PATCH] x86: avoid wasting IRQs for PCI devices
I have submitted the patch for x86_64, this is submission for i386.
The patch changes the way IRQs are handed out to PCI devices. Currently,
each I/O APIC pin gets associated with an IRQ, no matter if the pin is used
or not. This imposes severe limitation on systems that have designs that
employ many I/O APICs, only utilizing couple lines of each, such as P64H2
chipset. It is used in ES7000, and currently, there is no way to boot the
system with more that 9 I/O APICs.
The simple change below allows to boot a system with say 64 (or more) I/O
APICs, each providing 1 slot, which otherwise impossible because of the IRQ
gaps created for unused lines on each I/O APIC. It does not resolve the
problem with number of devices that exceeds number of possible IRQs, but
eases up a tension for IRQs on any large system with potentually large
number of devices.
Signed-off-by: Natalie Protasevich <Natalie.Protasevich@unisys.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:08:29 +00:00
|
|
|
/*
|
|
|
|
* For PCI devices assign IRQs in order, avoiding gaps
|
|
|
|
* due to unused I/O APIC pins.
|
|
|
|
*/
|
|
|
|
int irq = gsi;
|
|
|
|
if (gsi < MAX_GSI_NUM) {
|
2006-05-08 13:17:16 +00:00
|
|
|
/*
|
|
|
|
* Retain the VIA chipset work-around (gsi > 15), but
|
|
|
|
* avoid a problem where the 8254 timer (IRQ0) is setup
|
|
|
|
* via an override (so it's not on pin 0 of the ioapic),
|
|
|
|
* and at the same time, the pin 0 interrupt is a PCI
|
|
|
|
* type. The gsi > 15 test could cause these two pins
|
|
|
|
* to be shared as IRQ0, and they are not shareable.
|
|
|
|
* So test for this condition, and if necessary, avoid
|
|
|
|
* the pin collision.
|
|
|
|
*/
|
2008-03-17 20:29:32 +00:00
|
|
|
gsi = pci_irq++;
|
2005-07-29 21:03:32 +00:00
|
|
|
/*
|
|
|
|
* Don't assign IRQ used by ACPI SCI
|
|
|
|
*/
|
2007-02-02 16:48:22 +00:00
|
|
|
if (gsi == acpi_gbl_FADT.sci_interrupt)
|
2005-07-29 21:03:32 +00:00
|
|
|
gsi = pci_irq++;
|
[PATCH] x86: avoid wasting IRQs for PCI devices
I have submitted the patch for x86_64, this is submission for i386.
The patch changes the way IRQs are handed out to PCI devices. Currently,
each I/O APIC pin gets associated with an IRQ, no matter if the pin is used
or not. This imposes severe limitation on systems that have designs that
employ many I/O APICs, only utilizing couple lines of each, such as P64H2
chipset. It is used in ES7000, and currently, there is no way to boot the
system with more that 9 I/O APICs.
The simple change below allows to boot a system with say 64 (or more) I/O
APICs, each providing 1 slot, which otherwise impossible because of the IRQ
gaps created for unused lines on each I/O APIC. It does not resolve the
problem with number of devices that exceeds number of possible IRQs, but
eases up a tension for IRQs on any large system with potentually large
number of devices.
Signed-off-by: Natalie Protasevich <Natalie.Protasevich@unisys.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:08:29 +00:00
|
|
|
gsi_to_irq[irq] = gsi;
|
|
|
|
} else {
|
|
|
|
printk(KERN_ERR "GSI %u is too high\n", gsi);
|
|
|
|
return gsi;
|
|
|
|
}
|
|
|
|
}
|
2008-04-04 19:43:12 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
io_apic_set_pci_routing(ioapic, ioapic_pin, gsi,
|
2008-04-04 19:42:03 +00:00
|
|
|
triggering == ACPI_EDGE_SENSITIVE ? 0 : 1,
|
|
|
|
polarity == ACPI_ACTIVE_HIGH ? 0 : 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
return gsi;
|
|
|
|
}
|
|
|
|
|
2005-08-24 16:09:07 +00:00
|
|
|
#endif /* CONFIG_X86_IO_APIC */
|
2005-08-24 16:07:20 +00:00
|
|
|
#endif /* CONFIG_ACPI */
|